From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: multipart/mixed; boundary="===============7700639269631873679==" MIME-Version: 1.0 From: kernel test robot To: kbuild-all@lists.01.org Subject: Re: [PATCH 20/49] perf/x86/intel: Add Alder Lake Hybrid support Date: Tue, 09 Feb 2021 10:28:40 +0800 Message-ID: <202102091035.DaWTrEfK-lkp@intel.com> In-Reply-To: <1612797946-18784-21-git-send-email-kan.liang@linux.intel.com> List-Id: --===============7700639269631873679== Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Hi, Thank you for the patch! Yet something to improve: [auto build test ERROR on tip/perf/core] [cannot apply to tip/master linus/master tip/x86/core v5.11-rc6 next-202101= 25] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in https://git-scm.com/docs/git-format-patch] url: https://github.com/0day-ci/linux/commits/kan-liang-linux-intel-com/= Add-Alder-Lake-support-for-perf/20210209-070642 base: https://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git 3245161= 4da2a9cf4296f90d3606ac77814fb519d config: x86_64-randconfig-s021-20210209 (attached as .config) compiler: gcc-9 (Debian 9.3.0-15) 9.3.0 reproduce: # apt-get install sparse # sparse version: v0.6.3-215-g0fb77bb6-dirty # https://github.com/0day-ci/linux/commit/b4dd7dba3e07b911b667e9c80= 52547a7af28298b git remote add linux-review https://github.com/0day-ci/linux git fetch --no-tags linux-review kan-liang-linux-intel-com/Add-Alde= r-Lake-support-for-perf/20210209-070642 git checkout b4dd7dba3e07b911b667e9c8052547a7af28298b # save the attached .config to linux build tree make W=3D1 C=3D1 CF=3D'-fdiagnostic-prefix -D__CHECK_ENDIAN__' ARCH= =3Dx86_64 = If you fix the issue, kindly add following tag as appropriate Reported-by: kernel test robot All errors (new ones prefixed by >>): arch/x86/events/intel/core.c: In function 'intel_pmu_init': >> arch/x86/events/intel/core.c:6110:7: error: 'INTEL_FAM6_ALDERLAKE_L' und= eclared (first use in this function); did you mean 'INTEL_FAM6_ALDERLAKE'? 6110 | case INTEL_FAM6_ALDERLAKE_L: | ^~~~~~~~~~~~~~~~~~~~~~ | INTEL_FAM6_ALDERLAKE arch/x86/events/intel/core.c:6110:7: note: each undeclared identifier is= reported only once for each function it appears in vim +6110 arch/x86/events/intel/core.c 5499 = 5500 __init int intel_pmu_init(void) 5501 { 5502 struct attribute **extra_skl_attr =3D &empty_attrs; 5503 struct attribute **extra_attr =3D &empty_attrs; 5504 struct attribute **td_attr =3D &empty_attrs; 5505 struct attribute **mem_attr =3D &empty_attrs; 5506 struct attribute **tsx_attr =3D &empty_attrs; 5507 union cpuid10_edx edx; 5508 union cpuid10_eax eax; 5509 union cpuid10_ebx ebx; 5510 unsigned int fixed_mask; 5511 bool pmem =3D false; 5512 int version, i; 5513 char *name; 5514 struct x86_hybrid_pmu *pmu; 5515 = 5516 if (!cpu_has(&boot_cpu_data, X86_FEATURE_ARCH_PERFMON)) { 5517 switch (boot_cpu_data.x86) { 5518 case 0x6: 5519 return p6_pmu_init(); 5520 case 0xb: 5521 return knc_pmu_init(); 5522 case 0xf: 5523 return p4_pmu_init(); 5524 } 5525 return -ENODEV; 5526 } 5527 = 5528 /* 5529 * Check whether the Architectural PerfMon supports 5530 * Branch Misses Retired hw_event or not. 5531 */ 5532 cpuid(10, &eax.full, &ebx.full, &fixed_mask, &edx.full); 5533 if (eax.split.mask_length < ARCH_PERFMON_EVENTS_COUNT) 5534 return -ENODEV; 5535 = 5536 version =3D eax.split.version_id; 5537 if (version < 2) 5538 x86_pmu =3D core_pmu; 5539 else 5540 x86_pmu =3D intel_pmu; 5541 = 5542 x86_pmu.version =3D version; 5543 x86_pmu.num_counters =3D eax.split.num_counters; 5544 x86_pmu.cntval_bits =3D eax.split.bit_width; 5545 x86_pmu.cntval_mask =3D (1ULL << eax.split.bit_width) - 1; 5546 = 5547 x86_pmu.events_maskl =3D ebx.full; 5548 x86_pmu.events_mask_len =3D eax.split.mask_length; 5549 = 5550 x86_pmu.max_pebs_events =3D min_t(unsigned, MAX_PEBS_EVENTS, x86_p= mu.num_counters); 5551 = 5552 /* 5553 * Quirk: v2 perfmon does not report fixed-purpose events, so 5554 * assume@least 3 events, when not running in a hypervisor: 5555 */ 5556 if (version > 1 && version < 5) { 5557 int assume =3D 3 * !boot_cpu_has(X86_FEATURE_HYPERVISOR); 5558 = 5559 x86_pmu.num_counters_fixed =3D 5560 max((int)edx.split.num_counters_fixed, assume); 5561 = 5562 fixed_mask =3D (1L << x86_pmu.num_counters_fixed) - 1; 5563 } else if (version >=3D 5) 5564 x86_pmu.num_counters_fixed =3D fls(fixed_mask); 5565 = 5566 if (boot_cpu_has(X86_FEATURE_PDCM)) { 5567 u64 capabilities; 5568 = 5569 rdmsrl(MSR_IA32_PERF_CAPABILITIES, capabilities); 5570 x86_pmu.intel_cap.capabilities =3D capabilities; 5571 } 5572 = 5573 if (x86_pmu.intel_cap.lbr_format =3D=3D LBR_FORMAT_32) { 5574 x86_pmu.lbr_reset =3D intel_pmu_lbr_reset_32; 5575 x86_pmu.lbr_read =3D intel_pmu_lbr_read_32; 5576 } 5577 = 5578 if (boot_cpu_has(X86_FEATURE_ARCH_LBR)) 5579 intel_pmu_arch_lbr_init(); 5580 = 5581 intel_ds_init(); 5582 = 5583 x86_add_quirk(intel_arch_events_quirk); /* Install first, so it run= s last */ 5584 = 5585 if (version >=3D 5) { 5586 x86_pmu.intel_cap.anythread_deprecated =3D edx.split.anythread_dep= recated; 5587 if (x86_pmu.intel_cap.anythread_deprecated) 5588 pr_cont(" AnyThread deprecated, "); 5589 } 5590 = 5591 /* 5592 * Install the hw-cache-events table: 5593 */ 5594 switch (boot_cpu_data.x86_model) { 5595 case INTEL_FAM6_CORE_YONAH: 5596 pr_cont("Core events, "); 5597 name =3D "core"; 5598 break; 5599 = 5600 case INTEL_FAM6_CORE2_MEROM: 5601 x86_add_quirk(intel_clovertown_quirk); 5602 fallthrough; 5603 = 5604 case INTEL_FAM6_CORE2_MEROM_L: 5605 case INTEL_FAM6_CORE2_PENRYN: 5606 case INTEL_FAM6_CORE2_DUNNINGTON: 5607 memcpy(hw_cache_event_ids, core2_hw_cache_event_ids, 5608 sizeof(hw_cache_event_ids)); 5609 = 5610 intel_pmu_lbr_init_core(); 5611 = 5612 x86_pmu.event_constraints =3D intel_core2_event_constraints; 5613 x86_pmu.pebs_constraints =3D intel_core2_pebs_event_constraints; 5614 pr_cont("Core2 events, "); 5615 name =3D "core2"; 5616 break; 5617 = 5618 case INTEL_FAM6_NEHALEM: 5619 case INTEL_FAM6_NEHALEM_EP: 5620 case INTEL_FAM6_NEHALEM_EX: 5621 memcpy(hw_cache_event_ids, nehalem_hw_cache_event_ids, 5622 sizeof(hw_cache_event_ids)); 5623 memcpy(hw_cache_extra_regs, nehalem_hw_cache_extra_regs, 5624 sizeof(hw_cache_extra_regs)); 5625 = 5626 intel_pmu_lbr_init_nhm(); 5627 = 5628 x86_pmu.event_constraints =3D intel_nehalem_event_constraints; 5629 x86_pmu.pebs_constraints =3D intel_nehalem_pebs_event_constraints; 5630 x86_pmu.enable_all =3D intel_pmu_nhm_enable_all; 5631 x86_pmu.extra_regs =3D intel_nehalem_extra_regs; 5632 x86_pmu.limit_period =3D nhm_limit_period; 5633 = 5634 mem_attr =3D nhm_mem_events_attrs; 5635 = 5636 /* UOPS_ISSUED.STALLED_CYCLES */ 5637 intel_perfmon_event_map[PERF_COUNT_HW_STALLED_CYCLES_FRONTEND] =3D 5638 X86_CONFIG(.event=3D0x0e, .umask=3D0x01, .inv=3D1, .cmask=3D1); 5639 /* UOPS_EXECUTED.CORE_ACTIVE_CYCLES,c=3D1,i=3D1 */ 5640 intel_perfmon_event_map[PERF_COUNT_HW_STALLED_CYCLES_BACKEND] =3D 5641 X86_CONFIG(.event=3D0xb1, .umask=3D0x3f, .inv=3D1, .cmask=3D1); 5642 = 5643 intel_pmu_pebs_data_source_nhm(); 5644 x86_add_quirk(intel_nehalem_quirk); 5645 x86_pmu.pebs_no_tlb =3D 1; 5646 extra_attr =3D nhm_format_attr; 5647 = 5648 pr_cont("Nehalem events, "); 5649 name =3D "nehalem"; 5650 break; 5651 = 5652 case INTEL_FAM6_ATOM_BONNELL: 5653 case INTEL_FAM6_ATOM_BONNELL_MID: 5654 case INTEL_FAM6_ATOM_SALTWELL: 5655 case INTEL_FAM6_ATOM_SALTWELL_MID: 5656 case INTEL_FAM6_ATOM_SALTWELL_TABLET: 5657 memcpy(hw_cache_event_ids, atom_hw_cache_event_ids, 5658 sizeof(hw_cache_event_ids)); 5659 = 5660 intel_pmu_lbr_init_atom(); 5661 = 5662 x86_pmu.event_constraints =3D intel_gen_event_constraints; 5663 x86_pmu.pebs_constraints =3D intel_atom_pebs_event_constraints; 5664 x86_pmu.pebs_aliases =3D intel_pebs_aliases_core2; 5665 pr_cont("Atom events, "); 5666 name =3D "bonnell"; 5667 break; 5668 = 5669 case INTEL_FAM6_ATOM_SILVERMONT: 5670 case INTEL_FAM6_ATOM_SILVERMONT_D: 5671 case INTEL_FAM6_ATOM_SILVERMONT_MID: 5672 case INTEL_FAM6_ATOM_AIRMONT: 5673 case INTEL_FAM6_ATOM_AIRMONT_MID: 5674 memcpy(hw_cache_event_ids, slm_hw_cache_event_ids, 5675 sizeof(hw_cache_event_ids)); 5676 memcpy(hw_cache_extra_regs, slm_hw_cache_extra_regs, 5677 sizeof(hw_cache_extra_regs)); 5678 = 5679 intel_pmu_lbr_init_slm(); 5680 = 5681 x86_pmu.event_constraints =3D intel_slm_event_constraints; 5682 x86_pmu.pebs_constraints =3D intel_slm_pebs_event_constraints; 5683 x86_pmu.extra_regs =3D intel_slm_extra_regs; 5684 x86_pmu.flags |=3D PMU_FL_HAS_RSP_1; 5685 td_attr =3D slm_events_attrs; 5686 extra_attr =3D slm_format_attr; 5687 pr_cont("Silvermont events, "); 5688 name =3D "silvermont"; 5689 break; 5690 = 5691 case INTEL_FAM6_ATOM_GOLDMONT: 5692 case INTEL_FAM6_ATOM_GOLDMONT_D: 5693 memcpy(hw_cache_event_ids, glm_hw_cache_event_ids, 5694 sizeof(hw_cache_event_ids)); 5695 memcpy(hw_cache_extra_regs, glm_hw_cache_extra_regs, 5696 sizeof(hw_cache_extra_regs)); 5697 = 5698 intel_pmu_lbr_init_skl(); 5699 = 5700 x86_pmu.event_constraints =3D intel_slm_event_constraints; 5701 x86_pmu.pebs_constraints =3D intel_glm_pebs_event_constraints; 5702 x86_pmu.extra_regs =3D intel_glm_extra_regs; 5703 /* 5704 * It's recommended to use CPU_CLK_UNHALTED.CORE_P + NPEBS 5705 * for precise cycles. 5706 * :pp is identical to :ppp 5707 */ 5708 x86_pmu.pebs_aliases =3D NULL; 5709 x86_pmu.pebs_prec_dist =3D true; 5710 x86_pmu.lbr_pt_coexist =3D true; 5711 x86_pmu.flags |=3D PMU_FL_HAS_RSP_1; 5712 td_attr =3D glm_events_attrs; 5713 extra_attr =3D slm_format_attr; 5714 pr_cont("Goldmont events, "); 5715 name =3D "goldmont"; 5716 break; 5717 = 5718 case INTEL_FAM6_ATOM_GOLDMONT_PLUS: 5719 memcpy(hw_cache_event_ids, glp_hw_cache_event_ids, 5720 sizeof(hw_cache_event_ids)); 5721 memcpy(hw_cache_extra_regs, glp_hw_cache_extra_regs, 5722 sizeof(hw_cache_extra_regs)); 5723 = 5724 intel_pmu_lbr_init_skl(); 5725 = 5726 x86_pmu.event_constraints =3D intel_slm_event_constraints; 5727 x86_pmu.extra_regs =3D intel_glm_extra_regs; 5728 /* 5729 * It's recommended to use CPU_CLK_UNHALTED.CORE_P + NPEBS 5730 * for precise cycles. 5731 */ 5732 x86_pmu.pebs_aliases =3D NULL; 5733 x86_pmu.pebs_prec_dist =3D true; 5734 x86_pmu.lbr_pt_coexist =3D true; 5735 x86_pmu.flags |=3D PMU_FL_HAS_RSP_1; 5736 x86_pmu.flags |=3D PMU_FL_PEBS_ALL; 5737 x86_pmu.get_event_constraints =3D glp_get_event_constraints; 5738 td_attr =3D glm_events_attrs; 5739 /* Goldmont Plus has 4-wide pipeline */ 5740 event_attr_td_total_slots_scale_glm.event_str =3D "4"; 5741 extra_attr =3D slm_format_attr; 5742 pr_cont("Goldmont plus events, "); 5743 name =3D "goldmont_plus"; 5744 break; 5745 = 5746 case INTEL_FAM6_ATOM_TREMONT_D: 5747 case INTEL_FAM6_ATOM_TREMONT: 5748 case INTEL_FAM6_ATOM_TREMONT_L: 5749 x86_pmu.late_ack =3D true; 5750 memcpy(hw_cache_event_ids, glp_hw_cache_event_ids, 5751 sizeof(hw_cache_event_ids)); 5752 memcpy(hw_cache_extra_regs, tnt_hw_cache_extra_regs, 5753 sizeof(hw_cache_extra_regs)); 5754 hw_cache_event_ids[C(ITLB)][C(OP_READ)][C(RESULT_ACCESS)] =3D -1; 5755 = 5756 intel_pmu_lbr_init_skl(); 5757 = 5758 x86_pmu.event_constraints =3D intel_slm_event_constraints; 5759 x86_pmu.extra_regs =3D intel_tnt_extra_regs; 5760 /* 5761 * It's recommended to use CPU_CLK_UNHALTED.CORE_P + NPEBS 5762 * for precise cycles. 5763 */ 5764 x86_pmu.pebs_aliases =3D NULL; 5765 x86_pmu.pebs_prec_dist =3D true; 5766 x86_pmu.lbr_pt_coexist =3D true; 5767 x86_pmu.flags |=3D PMU_FL_HAS_RSP_1; 5768 x86_pmu.get_event_constraints =3D tnt_get_event_constraints; 5769 td_attr =3D tnt_events_attrs; 5770 extra_attr =3D slm_format_attr; 5771 pr_cont("Tremont events, "); 5772 name =3D "Tremont"; 5773 break; 5774 = 5775 case INTEL_FAM6_WESTMERE: 5776 case INTEL_FAM6_WESTMERE_EP: 5777 case INTEL_FAM6_WESTMERE_EX: 5778 memcpy(hw_cache_event_ids, westmere_hw_cache_event_ids, 5779 sizeof(hw_cache_event_ids)); 5780 memcpy(hw_cache_extra_regs, nehalem_hw_cache_extra_regs, 5781 sizeof(hw_cache_extra_regs)); 5782 = 5783 intel_pmu_lbr_init_nhm(); 5784 = 5785 x86_pmu.event_constraints =3D intel_westmere_event_constraints; 5786 x86_pmu.enable_all =3D intel_pmu_nhm_enable_all; 5787 x86_pmu.pebs_constraints =3D intel_westmere_pebs_event_constraints; 5788 x86_pmu.extra_regs =3D intel_westmere_extra_regs; 5789 x86_pmu.flags |=3D PMU_FL_HAS_RSP_1; 5790 = 5791 mem_attr =3D nhm_mem_events_attrs; 5792 = 5793 /* UOPS_ISSUED.STALLED_CYCLES */ 5794 intel_perfmon_event_map[PERF_COUNT_HW_STALLED_CYCLES_FRONTEND] =3D 5795 X86_CONFIG(.event=3D0x0e, .umask=3D0x01, .inv=3D1, .cmask=3D1); 5796 /* UOPS_EXECUTED.CORE_ACTIVE_CYCLES,c=3D1,i=3D1 */ 5797 intel_perfmon_event_map[PERF_COUNT_HW_STALLED_CYCLES_BACKEND] =3D 5798 X86_CONFIG(.event=3D0xb1, .umask=3D0x3f, .inv=3D1, .cmask=3D1); 5799 = 5800 intel_pmu_pebs_data_source_nhm(); 5801 extra_attr =3D nhm_format_attr; 5802 pr_cont("Westmere events, "); 5803 name =3D "westmere"; 5804 break; 5805 = 5806 case INTEL_FAM6_SANDYBRIDGE: 5807 case INTEL_FAM6_SANDYBRIDGE_X: 5808 x86_add_quirk(intel_sandybridge_quirk); 5809 x86_add_quirk(intel_ht_bug); 5810 memcpy(hw_cache_event_ids, snb_hw_cache_event_ids, 5811 sizeof(hw_cache_event_ids)); 5812 memcpy(hw_cache_extra_regs, snb_hw_cache_extra_regs, 5813 sizeof(hw_cache_extra_regs)); 5814 = 5815 intel_pmu_lbr_init_snb(); 5816 = 5817 x86_pmu.event_constraints =3D intel_snb_event_constraints; 5818 x86_pmu.pebs_constraints =3D intel_snb_pebs_event_constraints; 5819 x86_pmu.pebs_aliases =3D intel_pebs_aliases_snb; 5820 if (boot_cpu_data.x86_model =3D=3D INTEL_FAM6_SANDYBRIDGE_X) 5821 x86_pmu.extra_regs =3D intel_snbep_extra_regs; 5822 else 5823 x86_pmu.extra_regs =3D intel_snb_extra_regs; 5824 = 5825 = 5826 /* all extra regs are per-cpu when HT is on */ 5827 x86_pmu.flags |=3D PMU_FL_HAS_RSP_1; 5828 x86_pmu.flags |=3D PMU_FL_NO_HT_SHARING; 5829 = 5830 td_attr =3D snb_events_attrs; 5831 mem_attr =3D snb_mem_events_attrs; 5832 = 5833 /* UOPS_ISSUED.ANY,c=3D1,i=3D1 to count stall cycles */ 5834 intel_perfmon_event_map[PERF_COUNT_HW_STALLED_CYCLES_FRONTEND] =3D 5835 X86_CONFIG(.event=3D0x0e, .umask=3D0x01, .inv=3D1, .cmask=3D1); 5836 /* UOPS_DISPATCHED.THREAD,c=3D1,i=3D1 to count stall cycles*/ 5837 intel_perfmon_event_map[PERF_COUNT_HW_STALLED_CYCLES_BACKEND] =3D 5838 X86_CONFIG(.event=3D0xb1, .umask=3D0x01, .inv=3D1, .cmask=3D1); 5839 = 5840 extra_attr =3D nhm_format_attr; 5841 = 5842 pr_cont("SandyBridge events, "); 5843 name =3D "sandybridge"; 5844 break; 5845 = 5846 case INTEL_FAM6_IVYBRIDGE: 5847 case INTEL_FAM6_IVYBRIDGE_X: 5848 x86_add_quirk(intel_ht_bug); 5849 memcpy(hw_cache_event_ids, snb_hw_cache_event_ids, 5850 sizeof(hw_cache_event_ids)); 5851 /* dTLB-load-misses on IVB is different than SNB */ 5852 hw_cache_event_ids[C(DTLB)][C(OP_READ)][C(RESULT_MISS)] =3D 0x8108= ; /* DTLB_LOAD_MISSES.DEMAND_LD_MISS_CAUSES_A_WALK */ 5853 = 5854 memcpy(hw_cache_extra_regs, snb_hw_cache_extra_regs, 5855 sizeof(hw_cache_extra_regs)); 5856 = 5857 intel_pmu_lbr_init_snb(); 5858 = 5859 x86_pmu.event_constraints =3D intel_ivb_event_constraints; 5860 x86_pmu.pebs_constraints =3D intel_ivb_pebs_event_constraints; 5861 x86_pmu.pebs_aliases =3D intel_pebs_aliases_ivb; 5862 x86_pmu.pebs_prec_dist =3D true; 5863 if (boot_cpu_data.x86_model =3D=3D INTEL_FAM6_IVYBRIDGE_X) 5864 x86_pmu.extra_regs =3D intel_snbep_extra_regs; 5865 else 5866 x86_pmu.extra_regs =3D intel_snb_extra_regs; 5867 /* all extra regs are per-cpu when HT is on */ 5868 x86_pmu.flags |=3D PMU_FL_HAS_RSP_1; 5869 x86_pmu.flags |=3D PMU_FL_NO_HT_SHARING; 5870 = 5871 td_attr =3D snb_events_attrs; 5872 mem_attr =3D snb_mem_events_attrs; 5873 = 5874 /* UOPS_ISSUED.ANY,c=3D1,i=3D1 to count stall cycles */ 5875 intel_perfmon_event_map[PERF_COUNT_HW_STALLED_CYCLES_FRONTEND] =3D 5876 X86_CONFIG(.event=3D0x0e, .umask=3D0x01, .inv=3D1, .cmask=3D1); 5877 = 5878 extra_attr =3D nhm_format_attr; 5879 = 5880 pr_cont("IvyBridge events, "); 5881 name =3D "ivybridge"; 5882 break; 5883 = 5884 = 5885 case INTEL_FAM6_HASWELL: 5886 case INTEL_FAM6_HASWELL_X: 5887 case INTEL_FAM6_HASWELL_L: 5888 case INTEL_FAM6_HASWELL_G: 5889 x86_add_quirk(intel_ht_bug); 5890 x86_add_quirk(intel_pebs_isolation_quirk); 5891 x86_pmu.late_ack =3D true; 5892 memcpy(hw_cache_event_ids, hsw_hw_cache_event_ids, sizeof(hw_cache= _event_ids)); 5893 memcpy(hw_cache_extra_regs, hsw_hw_cache_extra_regs, sizeof(hw_cac= he_extra_regs)); 5894 = 5895 intel_pmu_lbr_init_hsw(); 5896 = 5897 x86_pmu.event_constraints =3D intel_hsw_event_constraints; 5898 x86_pmu.pebs_constraints =3D intel_hsw_pebs_event_constraints; 5899 x86_pmu.extra_regs =3D intel_snbep_extra_regs; 5900 x86_pmu.pebs_aliases =3D intel_pebs_aliases_ivb; 5901 x86_pmu.pebs_prec_dist =3D true; 5902 /* all extra regs are per-cpu when HT is on */ 5903 x86_pmu.flags |=3D PMU_FL_HAS_RSP_1; 5904 x86_pmu.flags |=3D PMU_FL_NO_HT_SHARING; 5905 = 5906 x86_pmu.hw_config =3D hsw_hw_config; 5907 x86_pmu.get_event_constraints =3D hsw_get_event_constraints; 5908 x86_pmu.lbr_double_abort =3D true; 5909 extra_attr =3D boot_cpu_has(X86_FEATURE_RTM) ? 5910 hsw_format_attr : nhm_format_attr; 5911 td_attr =3D hsw_events_attrs; 5912 mem_attr =3D hsw_mem_events_attrs; 5913 tsx_attr =3D hsw_tsx_events_attrs; 5914 pr_cont("Haswell events, "); 5915 name =3D "haswell"; 5916 break; 5917 = 5918 case INTEL_FAM6_BROADWELL: 5919 case INTEL_FAM6_BROADWELL_D: 5920 case INTEL_FAM6_BROADWELL_G: 5921 case INTEL_FAM6_BROADWELL_X: 5922 x86_add_quirk(intel_pebs_isolation_quirk); 5923 x86_pmu.late_ack =3D true; 5924 memcpy(hw_cache_event_ids, hsw_hw_cache_event_ids, sizeof(hw_cache= _event_ids)); 5925 memcpy(hw_cache_extra_regs, hsw_hw_cache_extra_regs, sizeof(hw_cac= he_extra_regs)); 5926 = 5927 /* L3_MISS_LOCAL_DRAM is BIT(26) in Broadwell */ 5928 hw_cache_extra_regs[C(LL)][C(OP_READ)][C(RESULT_MISS)] =3D HSW_DEM= AND_READ | 5929 BDW_L3_MISS|HSW_SNOOP_DRAM; 5930 hw_cache_extra_regs[C(LL)][C(OP_WRITE)][C(RESULT_MISS)] =3D HSW_DE= MAND_WRITE|BDW_L3_MISS| 5931 HSW_SNOOP_DRAM; 5932 hw_cache_extra_regs[C(NODE)][C(OP_READ)][C(RESULT_ACCESS)] =3D HSW= _DEMAND_READ| 5933 BDW_L3_MISS_LOCAL|HSW_SNOOP_DRAM; 5934 hw_cache_extra_regs[C(NODE)][C(OP_WRITE)][C(RESULT_ACCESS)] =3D HS= W_DEMAND_WRITE| 5935 BDW_L3_MISS_LOCAL|HSW_SNOOP_DRAM; 5936 = 5937 intel_pmu_lbr_init_hsw(); 5938 = 5939 x86_pmu.event_constraints =3D intel_bdw_event_constraints; 5940 x86_pmu.pebs_constraints =3D intel_bdw_pebs_event_constraints; 5941 x86_pmu.extra_regs =3D intel_snbep_extra_regs; 5942 x86_pmu.pebs_aliases =3D intel_pebs_aliases_ivb; 5943 x86_pmu.pebs_prec_dist =3D true; 5944 /* all extra regs are per-cpu when HT is on */ 5945 x86_pmu.flags |=3D PMU_FL_HAS_RSP_1; 5946 x86_pmu.flags |=3D PMU_FL_NO_HT_SHARING; 5947 = 5948 x86_pmu.hw_config =3D hsw_hw_config; 5949 x86_pmu.get_event_constraints =3D hsw_get_event_constraints; 5950 x86_pmu.limit_period =3D bdw_limit_period; 5951 extra_attr =3D boot_cpu_has(X86_FEATURE_RTM) ? 5952 hsw_format_attr : nhm_format_attr; 5953 td_attr =3D hsw_events_attrs; 5954 mem_attr =3D hsw_mem_events_attrs; 5955 tsx_attr =3D hsw_tsx_events_attrs; 5956 pr_cont("Broadwell events, "); 5957 name =3D "broadwell"; 5958 break; 5959 = 5960 case INTEL_FAM6_XEON_PHI_KNL: 5961 case INTEL_FAM6_XEON_PHI_KNM: 5962 memcpy(hw_cache_event_ids, 5963 slm_hw_cache_event_ids, sizeof(hw_cache_event_ids)); 5964 memcpy(hw_cache_extra_regs, 5965 knl_hw_cache_extra_regs, sizeof(hw_cache_extra_regs)); 5966 intel_pmu_lbr_init_knl(); 5967 = 5968 x86_pmu.event_constraints =3D intel_slm_event_constraints; 5969 x86_pmu.pebs_constraints =3D intel_slm_pebs_event_constraints; 5970 x86_pmu.extra_regs =3D intel_knl_extra_regs; 5971 = 5972 /* all extra regs are per-cpu when HT is on */ 5973 x86_pmu.flags |=3D PMU_FL_HAS_RSP_1; 5974 x86_pmu.flags |=3D PMU_FL_NO_HT_SHARING; 5975 extra_attr =3D slm_format_attr; 5976 pr_cont("Knights Landing/Mill events, "); 5977 name =3D "knights-landing"; 5978 break; 5979 = 5980 case INTEL_FAM6_SKYLAKE_X: 5981 pmem =3D true; 5982 fallthrough; 5983 case INTEL_FAM6_SKYLAKE_L: 5984 case INTEL_FAM6_SKYLAKE: 5985 case INTEL_FAM6_KABYLAKE_L: 5986 case INTEL_FAM6_KABYLAKE: 5987 case INTEL_FAM6_COMETLAKE_L: 5988 case INTEL_FAM6_COMETLAKE: 5989 x86_add_quirk(intel_pebs_isolation_quirk); 5990 x86_pmu.late_ack =3D true; 5991 memcpy(hw_cache_event_ids, skl_hw_cache_event_ids, sizeof(hw_cache= _event_ids)); 5992 memcpy(hw_cache_extra_regs, skl_hw_cache_extra_regs, sizeof(hw_cac= he_extra_regs)); 5993 intel_pmu_lbr_init_skl(); 5994 = 5995 /* INT_MISC.RECOVERY_CYCLES has umask 1 in Skylake */ 5996 event_attr_td_recovery_bubbles.event_str_noht =3D 5997 "event=3D0xd,umask=3D0x1,cmask=3D1"; 5998 event_attr_td_recovery_bubbles.event_str_ht =3D 5999 "event=3D0xd,umask=3D0x1,cmask=3D1,any=3D1"; 6000 = 6001 x86_pmu.event_constraints =3D intel_skl_event_constraints; 6002 x86_pmu.pebs_constraints =3D intel_skl_pebs_event_constraints; 6003 x86_pmu.extra_regs =3D intel_skl_extra_regs; 6004 x86_pmu.pebs_aliases =3D intel_pebs_aliases_skl; 6005 x86_pmu.pebs_prec_dist =3D true; 6006 /* all extra regs are per-cpu when HT is on */ 6007 x86_pmu.flags |=3D PMU_FL_HAS_RSP_1; 6008 x86_pmu.flags |=3D PMU_FL_NO_HT_SHARING; 6009 = 6010 x86_pmu.hw_config =3D hsw_hw_config; 6011 x86_pmu.get_event_constraints =3D hsw_get_event_constraints; 6012 extra_attr =3D boot_cpu_has(X86_FEATURE_RTM) ? 6013 hsw_format_attr : nhm_format_attr; 6014 extra_skl_attr =3D skl_format_attr; 6015 td_attr =3D hsw_events_attrs; 6016 mem_attr =3D hsw_mem_events_attrs; 6017 tsx_attr =3D hsw_tsx_events_attrs; 6018 intel_pmu_pebs_data_source_skl(pmem); 6019 = 6020 if (boot_cpu_has(X86_FEATURE_TSX_FORCE_ABORT)) { 6021 x86_pmu.flags |=3D PMU_FL_TFA; 6022 x86_pmu.get_event_constraints =3D tfa_get_event_constraints; 6023 x86_pmu.enable_all =3D intel_tfa_pmu_enable_all; 6024 x86_pmu.commit_scheduling =3D intel_tfa_commit_scheduling; 6025 } 6026 = 6027 pr_cont("Skylake events, "); 6028 name =3D "skylake"; 6029 break; 6030 = 6031 case INTEL_FAM6_ICELAKE_X: 6032 case INTEL_FAM6_ICELAKE_D: 6033 pmem =3D true; 6034 fallthrough; 6035 case INTEL_FAM6_ICELAKE_L: 6036 case INTEL_FAM6_ICELAKE: 6037 case INTEL_FAM6_TIGERLAKE_L: 6038 case INTEL_FAM6_TIGERLAKE: 6039 case INTEL_FAM6_ROCKETLAKE: 6040 x86_pmu.late_ack =3D true; 6041 memcpy(hw_cache_event_ids, skl_hw_cache_event_ids, sizeof(hw_cache= _event_ids)); 6042 memcpy(hw_cache_extra_regs, skl_hw_cache_extra_regs, sizeof(hw_cac= he_extra_regs)); 6043 hw_cache_event_ids[C(ITLB)][C(OP_READ)][C(RESULT_ACCESS)] =3D -1; 6044 intel_pmu_lbr_init_skl(); 6045 = 6046 x86_pmu.event_constraints =3D intel_icl_event_constraints; 6047 x86_pmu.pebs_constraints =3D intel_icl_pebs_event_constraints; 6048 x86_pmu.extra_regs =3D intel_icl_extra_regs; 6049 x86_pmu.pebs_aliases =3D NULL; 6050 x86_pmu.pebs_prec_dist =3D true; 6051 x86_pmu.flags |=3D PMU_FL_HAS_RSP_1; 6052 x86_pmu.flags |=3D PMU_FL_NO_HT_SHARING; 6053 = 6054 x86_pmu.hw_config =3D hsw_hw_config; 6055 x86_pmu.get_event_constraints =3D icl_get_event_constraints; 6056 extra_attr =3D boot_cpu_has(X86_FEATURE_RTM) ? 6057 hsw_format_attr : nhm_format_attr; 6058 extra_skl_attr =3D skl_format_attr; 6059 mem_attr =3D icl_events_attrs; 6060 td_attr =3D icl_td_events_attrs; 6061 tsx_attr =3D icl_tsx_events_attrs; 6062 x86_pmu.rtm_abort_event =3D X86_CONFIG(.event=3D0xc9, .umask=3D0x0= 4); 6063 x86_pmu.lbr_pt_coexist =3D true; 6064 intel_pmu_pebs_data_source_skl(pmem); 6065 x86_pmu.num_topdown_events =3D 4; 6066 x86_pmu.update_topdown_event =3D icl_update_topdown_event; 6067 x86_pmu.set_topdown_event_period =3D icl_set_topdown_event_period; 6068 pr_cont("Icelake events, "); 6069 name =3D "icelake"; 6070 break; 6071 = 6072 case INTEL_FAM6_SAPPHIRERAPIDS_X: 6073 pmem =3D true; 6074 x86_pmu.late_ack =3D true; 6075 memcpy(hw_cache_event_ids, spr_hw_cache_event_ids, sizeof(hw_cache= _event_ids)); 6076 memcpy(hw_cache_extra_regs, spr_hw_cache_extra_regs, sizeof(hw_cac= he_extra_regs)); 6077 = 6078 x86_pmu.event_constraints =3D intel_spr_event_constraints; 6079 x86_pmu.pebs_constraints =3D intel_spr_pebs_event_constraints; 6080 x86_pmu.extra_regs =3D intel_spr_extra_regs; 6081 x86_pmu.limit_period =3D spr_limit_period; 6082 x86_pmu.pebs_aliases =3D NULL; 6083 x86_pmu.pebs_prec_dist =3D true; 6084 x86_pmu.pebs_block =3D true; 6085 x86_pmu.flags |=3D PMU_FL_HAS_RSP_1; 6086 x86_pmu.flags |=3D PMU_FL_NO_HT_SHARING; 6087 x86_pmu.flags |=3D PMU_FL_PEBS_ALL; 6088 x86_pmu.flags |=3D PMU_FL_INSTR_LATENCY; 6089 x86_pmu.flags |=3D PMU_FL_MEM_LOADS_AUX; 6090 = 6091 x86_pmu.hw_config =3D hsw_hw_config; 6092 x86_pmu.get_event_constraints =3D spr_get_event_constraints; 6093 extra_attr =3D boot_cpu_has(X86_FEATURE_RTM) ? 6094 hsw_format_attr : nhm_format_attr; 6095 extra_skl_attr =3D skl_format_attr; 6096 mem_attr =3D spr_events_attrs; 6097 td_attr =3D spr_td_events_attrs; 6098 tsx_attr =3D spr_tsx_events_attrs; 6099 x86_pmu.rtm_abort_event =3D X86_CONFIG(.event=3D0xc9, .umask=3D0x0= 4); 6100 x86_pmu.lbr_pt_coexist =3D true; 6101 intel_pmu_pebs_data_source_skl(pmem); 6102 x86_pmu.num_topdown_events =3D 8; 6103 x86_pmu.update_topdown_event =3D icl_update_topdown_event; 6104 x86_pmu.set_topdown_event_period =3D icl_set_topdown_event_period; 6105 pr_cont("Sapphire Rapids events, "); 6106 name =3D "sapphire_rapids"; 6107 break; 6108 = 6109 case INTEL_FAM6_ALDERLAKE: > 6110 case INTEL_FAM6_ALDERLAKE_L: 6111 /* 6112 * Alder Lake has 2 types of CPU, core and atom. 6113 * 6114 * Initialize the common PerfMon capabilities here. 6115 */ 6116 x86_pmu.late_ack =3D true; 6117 x86_pmu.pebs_aliases =3D NULL; 6118 x86_pmu.pebs_prec_dist =3D true; 6119 x86_pmu.flags |=3D PMU_FL_HAS_RSP_1; 6120 x86_pmu.flags |=3D PMU_FL_NO_HT_SHARING; 6121 x86_pmu.flags |=3D PMU_FL_PEBS_ALL; 6122 x86_pmu.flags |=3D PMU_FL_INSTR_LATENCY; 6123 x86_pmu.flags |=3D PMU_FL_MEM_LOADS_AUX; 6124 x86_pmu.lbr_pt_coexist =3D true; 6125 intel_pmu_pebs_data_source_skl(false); 6126 x86_pmu.num_topdown_events =3D 8; 6127 x86_pmu.update_topdown_event =3D adl_update_topdown_event; 6128 x86_pmu.set_topdown_event_period =3D adl_set_topdown_event_period; 6129 = 6130 x86_pmu.filter_match =3D intel_pmu_filter_match; 6131 x86_pmu.get_event_constraints =3D adl_get_event_constraints; 6132 x86_pmu.hw_config =3D adl_hw_config; 6133 x86_pmu.limit_period =3D spr_limit_period; 6134 /* 6135 * The rtm_abort_event is used to check whether to enable GPRs 6136 * for the RTM abort event. Atom doesn't have the RTM abort 6137 * event. There is no harmful to set it in the common 6138 * x86_pmu.rtm_abort_event. 6139 */ 6140 x86_pmu.rtm_abort_event =3D X86_CONFIG(.event=3D0xc9, .umask=3D0x0= 4); 6141 = 6142 td_attr =3D adl_hybrid_events_attrs; 6143 mem_attr =3D adl_hybrid_mem_attrs; 6144 tsx_attr =3D adl_hybrid_tsx_attrs; 6145 extra_attr =3D boot_cpu_has(X86_FEATURE_RTM) ? 6146 adl_hybrid_extra_attr_rtm : adl_hybrid_extra_attr; 6147 = 6148 /* Initialize big core specific PerfMon capabilities.*/ 6149 set_bit(X86_HYBRID_PMU_CORE_IDX, &x86_pmu.hybrid_pmu_bitmap); 6150 pmu =3D &x86_pmu.hybrid_pmu[X86_HYBRID_PMU_CORE_IDX]; 6151 pmu->name =3D "cpu_core"; 6152 pmu->cpu_type =3D X86_HYBRID_CORE_CPU_TYPE; 6153 pmu->num_counters =3D x86_pmu.num_counters + 2; 6154 pmu->num_counters_fixed =3D x86_pmu.num_counters_fixed + 1; 6155 pmu->max_pebs_events =3D min_t(unsigned, MAX_PEBS_EVENTS, pmu->num= _counters); 6156 pmu->unconstrained =3D (struct event_constraint) 6157 __EVENT_CONSTRAINT(0, (1ULL << pmu->num_counters) - 1, 6158 0, pmu->num_counters, 0, 0); 6159 pmu->intel_cap.capabilities =3D x86_pmu.intel_cap.capabilities; 6160 pmu->intel_cap.perf_metrics =3D 1; 6161 pmu->intel_cap.pebs_output_pt_available =3D 0; 6162 = 6163 memcpy(pmu->hw_cache_event_ids, spr_hw_cache_event_ids, sizeof(pmu= ->hw_cache_event_ids)); 6164 memcpy(pmu->hw_cache_extra_regs, spr_hw_cache_extra_regs, sizeof(p= mu->hw_cache_extra_regs)); 6165 pmu->event_constraints =3D intel_spr_event_constraints; 6166 pmu->pebs_constraints =3D intel_spr_pebs_event_constraints; 6167 pmu->extra_regs =3D intel_spr_extra_regs; 6168 = 6169 /* Initialize Atom core specific PerfMon capabilities.*/ 6170 set_bit(X86_HYBRID_PMU_ATOM_IDX, &x86_pmu.hybrid_pmu_bitmap); 6171 pmu =3D &x86_pmu.hybrid_pmu[X86_HYBRID_PMU_ATOM_IDX]; 6172 pmu->name =3D "cpu_atom"; 6173 pmu->cpu_type =3D X86_HYBRID_ATOM_CPU_TYPE; 6174 pmu->num_counters =3D x86_pmu.num_counters; 6175 pmu->num_counters_fixed =3D x86_pmu.num_counters_fixed; 6176 pmu->max_pebs_events =3D x86_pmu.max_pebs_events; 6177 pmu->unconstrained =3D (struct event_constraint) 6178 __EVENT_CONSTRAINT(0, (1ULL << pmu->num_counters) - 1, 6179 0, pmu->num_counters, 0, 0); 6180 pmu->intel_cap.capabilities =3D x86_pmu.intel_cap.capabilities; 6181 pmu->intel_cap.perf_metrics =3D 0; 6182 pmu->intel_cap.pebs_output_pt_available =3D 1; 6183 = 6184 memcpy(pmu->hw_cache_event_ids, glp_hw_cache_event_ids, sizeof(pmu= ->hw_cache_event_ids)); 6185 memcpy(pmu->hw_cache_extra_regs, tnt_hw_cache_extra_regs, sizeof(p= mu->hw_cache_extra_regs)); 6186 pmu->hw_cache_event_ids[C(ITLB)][C(OP_READ)][C(RESULT_ACCESS)] =3D= -1; 6187 pmu->event_constraints =3D intel_slm_event_constraints; 6188 pmu->pebs_constraints =3D intel_grt_pebs_event_constraints; 6189 pmu->extra_regs =3D intel_grt_extra_regs; 6190 pr_cont("Alderlake Hybrid events, "); 6191 name =3D "alderlake_hybrid"; 6192 break; 6193 = 6194 default: 6195 switch (x86_pmu.version) { 6196 case 1: 6197 x86_pmu.event_constraints =3D intel_v1_event_constraints; 6198 pr_cont("generic architected perfmon v1, "); 6199 name =3D "generic_arch_v1"; 6200 break; 6201 default: 6202 /* 6203 * default constraints for v2 and up 6204 */ 6205 x86_pmu.event_constraints =3D intel_gen_event_constraints; 6206 pr_cont("generic architected perfmon, "); 6207 name =3D "generic_arch_v2+"; 6208 break; 6209 } 6210 } 6211 = 6212 snprintf(pmu_name_str, sizeof(pmu_name_str), "%s", name); 6213 = 6214 if (!IS_X86_HYBRID) { 6215 group_events_td.attrs =3D td_attr; 6216 group_events_mem.attrs =3D mem_attr; 6217 group_events_tsx.attrs =3D tsx_attr; 6218 group_format_extra.attrs =3D extra_attr; 6219 group_format_extra_skl.attrs =3D extra_skl_attr; 6220 = 6221 x86_pmu.attr_update =3D attr_update; 6222 } else { 6223 hybrid_group_events_td.attrs =3D td_attr; 6224 hybrid_group_events_mem.attrs =3D mem_attr; 6225 hybrid_group_events_tsx.attrs =3D tsx_attr; 6226 hybrid_group_format_extra.attrs =3D extra_attr; 6227 = 6228 x86_pmu.attr_update =3D hybrid_attr_update; 6229 } 6230 = 6231 intel_pmu_check_num_counters(&x86_pmu.num_counters, 6232 &x86_pmu.num_counters_fixed, 6233 &x86_pmu.intel_ctrl, 6234 (u64)fixed_mask); 6235 = 6236 /* AnyThread may be deprecated on arch perfmon v5 or later */ 6237 if (x86_pmu.intel_cap.anythread_deprecated) 6238 x86_pmu.format_attrs =3D intel_arch_formats_attr; 6239 = 6240 intel_pmu_check_event_constraints(x86_pmu.event_constraints, 6241 x86_pmu.num_counters, 6242 x86_pmu.num_counters_fixed, 6243 x86_pmu.intel_ctrl); 6244 /* 6245 * Access LBR MSR may cause #GP under certain circumstances. 6246 * E.g. KVM doesn't support LBR MSR 6247 * Check all LBT MSR here. 6248 * Disable LBR access if any LBR MSRs can not be accessed. 6249 */ 6250 if (x86_pmu.lbr_nr && !check_msr(x86_pmu.lbr_tos, 0x3UL)) 6251 x86_pmu.lbr_nr =3D 0; 6252 for (i =3D 0; i < x86_pmu.lbr_nr; i++) { 6253 if (!(check_msr(x86_pmu.lbr_from + i, 0xffffUL) && 6254 check_msr(x86_pmu.lbr_to + i, 0xffffUL))) 6255 x86_pmu.lbr_nr =3D 0; 6256 } 6257 = 6258 if (x86_pmu.lbr_nr) 6259 pr_cont("%d-deep LBR, ", x86_pmu.lbr_nr); 6260 = 6261 intel_pmu_check_extra_regs(x86_pmu.extra_regs); 6262 = 6263 /* Support full width counters using alternative MSR range */ 6264 if (x86_pmu.intel_cap.full_width_write) { 6265 x86_pmu.max_period =3D x86_pmu.cntval_mask >> 1; 6266 x86_pmu.perfctr =3D MSR_IA32_PMC0; 6267 pr_cont("full-width counters, "); 6268 } 6269 = 6270 if (!IS_X86_HYBRID && x86_pmu.intel_cap.perf_metrics) 6271 x86_pmu.intel_ctrl |=3D 1ULL << GLOBAL_CTRL_EN_PERF_METRICS; 6272 = 6273 return 0; 6274 } 6275 = --- 0-DAY CI Kernel Test Service, Intel Corporation https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org --===============7700639269631873679== Content-Type: application/gzip MIME-Version: 1.0 Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="config.gz" H4sICILmIWAAAy5jb25maWcAjFxLc9w2Er7nV0w5l+TgrCTbKqe2dABJkAMPQdAAOA9dUIo89qrW lrx67Mb/frsBPgAQnMQH24NuvBvdXzca/Pmnn1fk5fnh283z3e3N168/Vl+O98fHm+fjp9Xnu6/H f64KsWqEXtGC6d+Aub67f/nzH3++vzSXb1fvfjs//+3s9ePtxWpzfLw/fl3lD/ef7768QAN3D/c/ /fxTLpqSVSbPzZZKxURjNN3rq1dfbm9f/776pTj+cXdzv/r9tzfQzPm7X93/XnnVmDJVnl/9GIqq qamr38/enJ0NhLoYyy/evDuzf8Z2atJUI3mq4tU58/rMSWNq1mymXr1CozTRLA9oa6IMUdxUQosk gTVQlXok0Sgtu1wLqaZSJj+anZBev1nH6kIzTo0mWU2NElJPVL2WlBTQeCngL2BRWBVW/edVZXfx 6+rp+PzyfdoH1jBtaLM1RML0GWf66s0FsI/D4i2DbjRVenX3tLp/eMYWhtodaZlZQ5dUWpZpJLXI ST0s5atXqWJDOn9x7MyMIrX2+NdkS82GyobWprpm7cTuUzKgXKRJ9TUnacr+eqmGWCK8TROulS4m SjjacSX9oforGTPggE/R99ena4vT5LenyDiRxC4XtCRdra2seHszFK+F0g3h9OrVL/cP98dfRwa1 I96GqYPasjafFeC/ua6n8lYotjf8Y0c7mi6dqowz2BGdr42lJmaQS6GU4ZQLeTBEa5Kv/cqdojXL EvVIB0ou2nQioSNLwFGQ2ht5VGrPHRzh1dPLH08/np6P36ZzV9GGSpbbE95KkXkz9UlqLXZpCi1L mmuGAypLw91Jj/ha2hSssWok3QhnlQTdBUc0SWbNB+zDJ6+JLICkYHONpAo6SFfN1/5hxZJCcMKa sEwxnmIya0YlrvNhYdhESxAGWGVQJ6Ax01w4PLm10zNcFDTsqRQyp0WvMWGRPLlsiVR0edEKmnVV qawAHe8/rR4+R5s8GRmRb5TooCMnn4XwurFy5LPY4/UjVXlLalYQTU1NlDb5Ia8T4mKNwnYmkwPZ tke3tNHqJNFkUpAiJ74yT7Fx2CZSfOiSfFwo07U45OjwuFOct50drlTWRA0mzp4Xffft+PiUOjJg YzdGNBTOhH8mr0HMJROFtcDjkW4EUlhR06TCc+Syq+uUthANYhKjJck3gWjEFCdFE902642NVWsU w36yvsTMpjnqOUkpbzU0ZeHBOOKhfCvqrtFEHpLz6rkSkxrq5wKqD4sNG/EPffP079UzDGd1A0N7 er55flrd3N4+vNw/391/mZZ/y6S2O0dy24ZbmLFnuzshOTGKRCMoNeHRtJIc9OKLkMrXcG7JdlBr 4wgyVaAqzSmoeqidWgSUNkRrKhg5imBBa3I4Vc3skTirx8TpCbeKBbuo2Gg3C6YQwhXhRvby8Td2 xkNpsKBMidrqOr85u8ky71YqcZxAIAzQpuWFH4bu4TR5x0sFHLZOVIRLaqv2pz9BmhV1BU2V47FK jAl2rK4RinLfEiGloSAKilZ5VjNfESGtJI3o9NXl23mhqSkpr84vg6ZEnuFCLo7JWGjNM/8Uh0sb ItmMNRfeYrCN+8+8xAqtX+wAtaema4GNloAGWKmvLs78ctx7TvYe/fxiOvOs0eCfkJJGbZy/Cc5U B86Hcyfs4bJ6ftAR6vZfx08vX4+Pq8/Hm+eXx+OTLe5XIEENDJzq2hZcFGWajhOTEfC78uBMW64d aTQQte29azhpja4zU9adWs/cJ5jT+cX7qIWxn5iaV1J0rbeYLamo04LUAw6ADfMq+hkBWFe2gX88 p6Xe9D3EPZqdZJpmJN/MKHaRp9KSMGmSlLwEc0yaYscKHQBWUKJehZQJc+SWFYGq64tlseBj9PQS jvk1lWmWFtCyVst9FnTLcproFWou6NdhtFSWs8WyaMvTRyLfjCSiPd8OXRCAbqD+p7IOBS9U9mhb mtTw0RUJeWGiMuKdFDkrlkgN1ekeYK/yTStAQhEUAG71kENv1cAjHqRpbA8gHchBQcGCA9pNbrdE 6xVKJWyDRZTSkyf7m3BozQFLz5mTxcxjhaKZtzqRQscaCnx/2tJF1FjkfE6E3n+eDLkQiFPw/6lV zI1oYRvZNUX4ZaVGSA56JRS6iE3BfxKtgaIWsl2TBnSQ9KxL7JS632Aec9paj8LahRjd5qrdwIjA EOOQvA1pPcGOTSwHMMBQ1oJNr6hGp870gD4xdCcXM8BfwmSKOsSOFnU7EJqEhmgmPA3pzEbDmR+d 8Q7h8jwJOE6Iqr3hdICYo59werzlaIXPr1jVkLr0pNaO2y+wHohfoNaBUiYsED2AaJ2M0NlIJMWW KTqsYmp1Jqcf98hCt7Iwu9AwZERK5tuTDbZ24GpeYoLdmkozAHCwOCjPAQwZOezi4klHrz84L215 QkwmAzsAT+T/4Pua3sQis4r2dpoe9NKAd+cU13S0Ff2Y6Bdq0aLwzZk7I9CVif1QWwijMFtunXpf 1M7P3g5QpA8pt8fHzw+P327ub48r+t/jPcBiAmgkR2AMTtUEcZN9WYOS6nHENH+zm9Gn4a6PAVR4 fam6y0YLNp1tLO0Rhj3DIWgfFJjgLYHNsq6xV5ekAlXYZMgmsqS8Y33oWwIG6sVhmQ1hAOJqI0Gj CJ7s1mfD2BD4AIEuV+uuLAFYWtQ1BmwW+uwsAgdeqRlJyTIg5ZLVAX60etga1cC/DsPdA/Pl28yX +729tAh++8bSBeRR2Rc0F4V/vMGJaMGPsIZHX706fv18+fb1n+8vX1++9WPdG7DaAzT1pEIDKnR+ xYzGeRcdQY5oWDboULiwy9XF+1MMZI8R/CTDIFJDQwvtBGzQ3OQojWEwRUzh2/+BEJgJr3DUW8Zu VXBIXOfgffc21JRFPm8EtBvLJAbBihDsjHoKRQe72adoBPAV3tZQCwQSHCBXMCzTViBjccgXAK+D py50AY6gBzvRBR1IVudBUxLDdOvOvzAK+OxpSLK58bCMysZFLsF2K5bV8ZBVpzC6u0S2+t4uHanN ugMwUWcTy7WAdYD9e+NdmtjYta3smx4FwEitSSF2RpQlrMPV2Z+fPsOf27PxT3iajOLtbKy9b9bZ SLe39SXAEkpkfcgxRuvb8LZyDmkNqrVWV6MT3/uAMC7qzhFuF81dENgaifbx4fb49PTwuHr+8d2F TgLHNVqDlFbzZ4CzKinRnaTOxfC1GxL3F6RleaIZJPLWBpP9OpWoi5KpdVIHSqoBDoGYLrTnZByg qKzDIdK9BnFAEZuBMiRv3ZyCgacG4pHxmNagJoqwJVdct0qF5YRPfU8+4AjBVGl4xuYlsX+HTY3y 0l/YgINcdyHmcO6S4CCyJXg0o1pJ4bcDnDoAeeADVF1wRwlbQzAgGUDlvsyNK+36DSyqZY2N0i+s 4HqLWqvGGIDZDjI6bQFNWf0NoIlomO6ioO0wmA3CX+seME8D2qb2cBzmYjh15BjiPWOLH2DF1wLh kR1LClXmshkHOtbjm/fJJeOtytMEBJPp+1AwrEnMMRoEHyQPkikbsNO9to+jYchTnwfES5+mVR42 mPN2n6+rCCHg7cY2LAFbynjH7eksCWf1wQs7IoMVJvAfufIwBAP9a1WLCTxNe1z5fqZ0JgiEEW70 aGlNc//GCHqHo+NO6LwYDui8cH2obEw1CCUjIQdAS7rUeRo4rtdE7P0LvXVLnbDJqIyCh4uGW2pv gUmbjcxj7wVnqR0HPAgKw0EjTz72oNQS7I21sQpRK1jZjFYImdJEvL58f/77jNpDY28Xe4pX4lSQ 4j6ws0U8n2sqnqNXLRYUhc2KMGhGIokWiUJJpUA/EYMamRQb2riACd7KRmIZRkT6IgwE17QiefoG qedyUrRk1YAeiNNQiLepag12ZU5yd8mjkfZ8q28P93fPD4/BZZPnufUWp2vyIGA255CkrU/Rc7z5 WWjBWi+x66Wx9yEWBhmu1fkl4OSFdRpuY/sTwMKj5na4rfEvKlOqjr0PtDJnORx+UHBL2+Jrlx4t sCLu8p2FVAtNFEzCLpkqQ4Q6gzp5S1yyk9IsTwc/cSHBbMPJyuUheRGJFwF+w1gDyxalETAlyVu2 zGSvFmCJU53BaqlY2TtQaoGZGypJ4OuRPOiCiG6V74BQML2gjjhQUZsNCq3LcJv0fo3Hrx4gC97u dxRx9fHm05n3J1yFFsfyF+fWBpjBbxMKgzSya+P7wECNYHYE3gvtPKXGtfQvReAXQm2mwWdaLO8X cFyoswU2XFIMYFllOjCf+2MCrzNaRIAgCnwBPP2kvxuZBAcZ5qGJYEUU+LQLC9BxNoPEPeZ1m9p7 FuiEbeghLe5TJa32VgzQT/rbrEubE/H1iXLhzKp9shtasmT5+tqcn50tkS7eLZLehLWC5s48S399 de45g87srSWmBfhD39A9TTlLthyd8JRv7ohtJysMHh1m7WHQOJn1RdTaFJ3vzrXrg2JobUGPSfRm z+PDJqkNUqFIp1D1UJ/UrGqg/kXgA6+FbuuuCsEpmmfE2twne0vnIpJpmjvxsSUJ7HrMshdNndYR MSfmmKQv+XhhYyUw8pSlAKFk5cHUhZ5fP9iASc22tMXr3GCcQ2Ey4eGU2z4TCFIUZrBQPq3XRP0B 7lc0iHP34XVnM6yzwOKYd9+IamvwLlsEBtq/D28f/nd8XAEquPly/Ha8f7ZDRQO1eviOOc5e/HkW zHE3+x5gdFGcWcFwAxsAyZ6kNqy1gfjUqez7oqPj6a2QNxC/XX98qiEtplehA58Sfg7HpnDxWR0m 9iKpptQ/aX1JGE6BUtRmA+/kw3KzIxu65E63PGhiFlLHZost3gEWc8994sEc5fmijyONYhGFHVSc t+eXWg8Gs0zOL86CwfRZIzq1SUDO603Q/eDTuvTHAHftPjpgigmfLGd0usdJNx01Fe9KGJBDsfVo s1+DxrDaUAFWEJsuboyzaq37WzKs0vrRW1sCOkIDeHHTsCBczQPfltNuQBXKfUCwV1Vp4Gl7anNp llS3m1DL4k7jFcIySbdGbKmUrKCpGCvygN2ZUkF9Asln48+IBqh3WBpV1mnt5zbZwi30LaKykjSz tjVJpQS4ZRN++oktsjEKSUGqVDzuKbQQu0oRmRWzxRiJUXnSIEbNkaoCVBgm8rqZrcEvIjGwtgbA TRz1dNdWkhTxeE7RZtrDjSdHURDpYBcunGg0nCi6NEMmel89Eskspc9czQjP2l46pQUHC6bXolgW dEmLDnUdXrntEFYv2nznOpUsfc+XdKx8S+4EuqWeYgjLwzQBnz3sxPJWa7rgNo4sYcx3aeksK2XN h0TXhuK9SqTL3ca3ugzCTfDbqaXkoBwZJK5k21QkzGmBPaCDuCP3/zJQ5C2470a0IOnLThlajjCA pkp2NSXrrsrH439ejve3P1ZPtzdfXcgkiN3h0V5KKE3UHhtmn74evddZmFAaJZEMZaYSW1MDAktG 2wMuTptusQlN009VAqYh3J0UT0caQuN+5GackZcFYl2qeUL4AD//EtXZpcpenoaC1S+gMVbH59vf fvXiVqBEXAwl2Hoo5dz9SF8pAEPeZBdnMO2PHZObVDBIEbAT/uMwdwmLIUJP/DCaEqQCWGfxoMos Oe+FCbnJ3t3fPP5Y0W8vX28GZDutJ0avx7jWose7f3OR7nfWtm28vHv89r+bx+OqeLz7b5DLQYtA WcLP2NPuKSWT3KpE0CTcz99kKlfMsKzUwOPjv4kwlZU7k5d9fobfr18+uEnJyVdCVDUdR5N6PAeu Ogivf9rHoj4Vwb2IOH55vFl9Hlbmk10ZPwd3gWEgz9Y0UOSbLffnh/dBHfi217NtHQQMjO92/+7c vzrGCBs5Nw2Lyy7eXcal4Al39kI0eJV483j7r7vn4y36e68/Hb/D0PEQzjwq59KHkWAXAgjLBqMc hOcHaAwYWnoJBMJlldB5SZ/XYxP02tpPY7NLd6IiGMX57cbGXX8nxeVDx1vQqlkYmZ2cP/vE1Hp1 GHosl95jxhfsdpyT59A1NmyBmaY5gq95tM0mr2vWmCxMfrYNMVhjTBJJpEhskj1v8D47RRBturxv BuCMKVMZlmXXuIgcQHMEoqkHalsaYpIpgc+2uAYnJiKiFkV4x6pO+Bp2EBjwYJ1Jcq/FEni0BF8G QyJ9Xu2cQdEhWLxA7CPvfLbobuTuYa/LSDK7NdM0fPEwZn0oUxwagljDvk9xNeImFccYTv8ON94D QChwxjHSgPkVvaSEVsbxKfpxaXvwNfFixfXOZDAdlwod0Tjbg3ROZGWHEzHZxGwQrU42phGw8EHq ZZxmmJAGhM0YarD55S59JMo+nxpJ9D8kD8p+icIQ47Rr06E+TfWzOns2zjsDLtGa9v6sjQglyfg0 JcXSS5c7De4NSH+hHQ+mVwm9cGFcLeLo67l7ygVaIbrARZ7mqWiOGWUnSH3ylYd64yozxkkz9hR3 rb8U+/G6xB2rQbyi8cySiXzd61FONr5jeg2600mFTUyJRSdffFuYJNusKx08IrF8f/mOzunrv3xM xwWKcxcn6bpiHhcPSrSxVzlgTzCzLCEvi3yJrpyYAh0zcePYkk1js0SMwwKgkGkJE6VVoPowm0cx XOfRHNSEF5kCUocxLbR5YFDtEUyoZkuyd0xB2uDUd5B9GRvePdNpmxHWmhI6J1EcHv3OjRuMlLkI 9ZhHGjoF4CWEWrdP6HxzkTGXoZGaCC6/iWRtslAa7KAevhMgdx4UOkGKq7s1T1ZPkaaxgddcg7vR X82ENgv1uJ+AHYOaPoV9uJGeH/sBWC1TZl/rmIRz6f1IGGftc87hBAzJ5g795mL7+o+bp+On1b9d zvn3x4fPd7Ffj2z9+i7l9+MkLdsAQEmfIjakQ5/oKZg1fk0FkfMQhY7Sqf8Cpw9NSQTNoMh89Wef LyjMtvduiN0h9LVtLwj2YTXsLUkHwXqurjnFMeCbUy0omY+fI6nT2HvgXPDdezKeMQl45xQPbv4O II5SqK/HB2uGcSsmKUDfgH4CzXfgmajVXHvZB7lxWD6rg7AvvgazHq6kH8PMwun1Ihw8lPeQhE/I MlUlC2uWzcsxxlJJppNP0XqS0edn/n4PDJiPm4pjD3RQo0LrOnp1PqdiQkNyD+xk+3tNm9yRMuXI tMvSS8TwgTVokUM8gJGei6RX1jdq+Md4XVArhPEFu1mY2tqStDQig1NHg0ZLvflubx6f7/BMrvSP 70f/Scxwdzfel10FkVoBkHrkSYdq2T7NMfjAqvRuCL3AFKtIkqCJZCkCJ3myWBVCBYRpbVSBr+o3 Mz96qMoaGLzqsmRtfEAvmeozUU4tQQfN2BBTsrPpwrvgJ1dKVSw9j6623zc5WbdrUouzIZInVxkD S4li/AbP5fv0KLzDklqLIXAaSZov4PwjRjZDoYcyBK9MhMX2gtd9MEdMj8qDiCPUZMLllRSAqBay 5D2uzSHznYqhOCvDz0aUH81wgGfPqacvvASjmuJZzbkXvWv6g4mJ4dY2zbDUdPOqBfroknuf97Em 01WG8yl2wV0TKGgAMQtEi4EWaGNkx34cqZiy1ieWZUpcWe7SVWflIyppcERgYmvStqieSVGgmTTW 8qWg4vDE0GS0xH/Qzw4/3+PxujyWnYTG/TlP6RNWgOifx9uX55s/vh7tJ+xWNqvz2dOKGWtKrhHs eyemLsOYYs+kcsl8GNkXg1UPLv+wLsYFktK0NCA7Wn789vD4Y8Wnu4hZGPRk9uGUushJ05EUZSqy z5KGAKdLl0y1BD6ppL7fMJG2Ls4+S6OcccSxIvyWUdWF72hxOuOXTAJYGKT0pBSiS9exqTouVfut vxngAOWL+ty6ppLiyVx6Jzx+KWshJ8zKtdHxC0P3AEOEFzcYvJmHrTbK25bhqa5dWfeppUJevT37 P2fv1uS2kTQK/pUOP5zwxH4+xoUAwY3QAwiAJNS4CQWSaL0g2hJtd0yrW9vdmrHPr9/MKlzqksX2 7sRYEjOzCnXNysrKyyak2YnhKaMOmwE/nJsaxrlazLLnnlL39mtuxSCEHpopVMYy4kUWC5tN6omm raGcXoJ8hMb1Q13vP6vqaf5zlsHr2b4U/9bt5ay0tuB51gLRinZdufIFOv7etQIH2nPGWsQSxM9G /+Gnr5ffH+/fLj/pdX9u6rpYqt0e7dVqpP5OuABcr5AJz+t/VumHn/6P//vz49efVJqpMlmm4eWk n1tZ5zS3ba5G9zifIIN6IZofj9BdcXoJkfsITcnaVtWj8ogb1FtuOrlEm3rA+XRruK+rqhXjSppm J/VWuL+Z7mWjnSOPdkX51IC805luZtN3ub5MPjrK8fjm23A4ZEWjBTSzn1rLUSN9DYOkQH2teITi 5151efvv88u/H57+kA48iUcntxn55gXCuCKDgQiVKG+aHJbmMc3Zu8Ji2r1rS7u5Gbb/NqMMunLR z+WhvBHnK4bUI6sCgtl2kbv2UBdTIGoq+TGb/x7SQ9JoH0Mwtzi2fQwJ2ril8Xxemvwaco8Xn6w8 9kQzBcXQHasqU3wUQawD5lPf5pb3T1Hw1NHG64jd1cdruOWz9AdwWoaY9rrluIxZRkw0DTmnZbaX 7spAXHAaqEuaCaxWf0wb+wLlFG18focCsTAvwH1q2hIMvw7/3M+rjejOTJMct7K2fOKzE/7DT19+ /Pbw5Se19jINaEt8mNlQXaancFzrqNulHSY4kYjhg/5GQ2rR9GHvw2tTG16d25CYXLUNZd6Edmxe 0F5JHKktaBnF8s4YEoANYUtNDEdXKVwyuJDe3TWZUVoswyv9mMR8Yc57hZBPjR3Psn04FOf3vsfJ DmVMCzBiDTTF9YrKBhYWzWgwaig+/5WxGiJlQoFYzh874AgsGzo6I5CaL4ozkNwo4kx6frngeQWX t7fLiy3G+VLRctIZKPgXjyz+zYrC0H0SeocbsOJygwLlwQBFjMRvUmcEAqqiTfrl6qTBpLBosKsq KxU014NRooZCtesaui9D3iZawxccNJ97tZFh1dQu5Fr9nTTCxBRPY7wvjtlABqeDSioQBL+pv42O IEx0QYXpDUJYGbNPx2y0TJZ7bG5Mo8G9oIE6+UrsuRbh9ebL87ffHp4uX2++PaOO6pVahT1+ub3V i77dv/xxebOV6OJ2n/FwbNW0PIiluhCqi1UmEKNIzMFSuMKgZ5btbhLvxLeu1ggCOTes+Yd1SjNz tZf/aCiAc5XMmKlv929f/rwyQRjHHG/7nMXT9Qsiig2YVMKS/9siqF/lXYqgyDKrwHpiBk/Mm//7 H7DEHYoSbczZ/0rb7xjbUYiB9C0ZNwgwof7uKkmKmlwNrzJDkH0Nzjk2ZwG2GSpGNDj0HFB5M+9B BT4eJRp0Xohc0aIhtT2hlFjWIn0fqDDse7UvMrMGkBZpLfaVORon8T/htWmkp4uWjpTpspKM0xXS 07XMQkhNWSiPZ2ibm1AMFe4GLDM64ekE5uyFV6cvtE1AeH0Grg0wuU1C67G4bfN0T8tpAoXk2faK uLdtRLdt+zxNEus9kiWWO2ab0h8D4ZPS9sSdcluHn0NS5NQpgKgiVuOiI6xsaloGR+S29cKI5haF 11GfYZ100d4jt1iU/XxY9d9Dvi9hPKq6bvT3aYE/QavHBWZTMI+UZUu1aEQmO0lFLEz78OLHYk18 RRBRC29F5Hiu9A69wIb9qVV0CRKqPJHNSrNEU3YIiF2NURTSpRJ+eOpUxgXl+dB7gVQobiTLg+ZQ ay0Ii/rcxLSeP8+yDDsUWA4PPNgtAZXTRLZ3gHUV8xd0Cjb904KUzcwkeBor3ZAwpKevhC/HZA1U WXsUK4kImYltWdZNVp3YOdfctqclIs4A5VIwwQx1hY4vYLuo8bFPwnHjVCa5XPWE5c/G7yOMSPGT jK9qZMqmYPq+QdiwZ/QzAEfiyraNlQj8TI3Tgek3zEGMqXYpUygKH0UAFOboq9untlNqxd8DK2kl CUfCPdtSz1Aecr2FVcIo5UUrB1NvdzzXgqz86mX8aBqD1WH8IxKRFDFjshc+5yAY0Z7dDWpw4O0n Rak4BrK16CF3aGwlUlqpGuabt8vrm2Zjx1t42+0zmnNwptrWzQALKzcCmI5nu1G9hpA12wsXL0HC 4yMzGu58+ffl7aa9//rwjDZ6b89fnh/lkAIKM8RfwDnKGCOxqkGBocUtGT+trRf3m7j/315w8zS2 ++vlPw9fJv8h1fTiNrdYtoWol7eIFp8yNFAnmdcd7NEBDeh3aS+zwxl+kOF3cSk/NVxt9bzAYokD YKo2kMhUwDYpVcD+rLxHAuSju/E3ZO8QmzNNyy6GDA6fVLTJcGLDUiejZac+Ud26EciKJCbDAscY jvakkydxkaAxMWpLLeyJdyiuPg85/Mu3VH17inH4myTP5GDQ/BMD0UyRBm8K/GipdCSSTYE4OFmv HQKERszGdzjine/k6D0XV3rDS6rh5dQm61iV/6RrTRbfkqPFPsZqgBwEZiUzh2EXuaHjqrBlGvR2 Tx+0Nrspeh1vNosa4gn1To/xNV6TcsWaRGNGEfiTkeyR2BjzxpftaTDmdZa2CqTd4aGu8P4JOHQd /d6BFVUZKU7DoVN2jVbdIU/p+wziKKXcFhPJKM0sspQpgJLt1OBf207JH7ZAr3j1AXYKBjl5tQv/ 3Mcfl7fn57c/Tc69lNSiQWJfkvwYtx0FGw4rErxNWEMi4u7g3+rjOOJsEQTl4vuw7/WKTwfFZhAG sT0pxuzWfktXCbiB921DvzwA8jahlvc5b7NC0dOf0RlHNQPjIDVlT7Lb47VC2sNVwQH8iX00Xlt2 y0iNmyUrMPYf9x2APUUmDZmokwxdDHPh/zDU1ZGRlaKRN3SD51HAB+Vsn9KR4KUS8CMrimMRw7mL PnfXmoHUPMo2JjvLW3MQ5rfChm7guPyvtylp03iybrrWmrOyuco40eZhgnDDhjYhEG2C9lWsa7OC xs6mWP+E6sNP3x6eXt9eLo/Dn28/GYRlxpSQWDMCGQfRzxlP8Ay5UjaZktDPXGo1RliGGV3VwoCV vv5MVKes3YIMafW1WxpWlAvHMuthXfx+HYfuSg2Ysst+w53J8i1j/4SuIaiMPjXFlQahm9XhH1Ry OJfNtWpgmQhD2PerQtKExe/V9k/61qUF0+OmaEvHTHGhTOcBvfMxGxkPsj+7+bS721y+xonf02m5 6A0FOK+aI7XpR/S+ke+ReDHbNPrvxcRcucFtGusgJHEu556CX+aIcqj1JZVjj0yJvZFkzWGgU8tW OzVf5Q4mO9/nncXtA/EVKdUh5qDKiQhih7RQjr/xBnz/crN7uDxiHpNv3348PXzhmuebn6HMv8bz 9FVV9AODzHJ8Tbd8vKkC35ffjEfQkHtKWpV/+O1Ztcdi2GyZOrX5Tg19SJgOjKgUcyug/amkym1r ftCp7/B4DKu5vYWnqmJEiAa0aMUufxxutx1aKI7qJUrtw51Al3Q7fFxtd0NBrMnl+NtWsXKR0H9Q oeTwmoIH6vZoyWkG+Jg1lGSEqKFRFfU8qg2pIkIMD2Ojf/5aVP0EHdSE5eUYgREDBVpqZ91xq/YX cyAZwFhJMgQAtA5HCW+M0KQi8/qkt7dp6YsWx8Usp1TF/Duj078yttwxFxasPUbsTHUtN89MhD79 trlCvCUzmoTPWg//ID8zhVDR7pJCSwWwL89Pby/Pj5j6cbl3jCv89eGPpzOGnEFC/uDMfnz//vzy JoetuUYmHCGef4N6Hx4RfbFWc4VK8LH7rxeM4M3RS6Mx965R1/u0s9sTPQLz6GRPX78/Pzy9qaGh siqdgl4oS2mCz4HDLMsqg1XeTTkXpJbMX5u///rfh7cvf9KTJO+j86iI7rJEr9Rehdz4JCbt1dq4 yVP5oB4BAzdhm8Jm+o6OHrd+2w9dP3DfBqIKDPdd7RWP7Bmnii9LtccSPZDVAH0TNjmUpK5twnP3 3CERajeRU/f++8NX9AkTY2SM7VSyY3mw7s32JCCP9QQc6cOIpt9nlWdi2p5jfHn2LK1bIi49fBnP n5vatLQ+Cmd6YeNNvvqdurJRLyMTbChRQCTfVOMqjYtanrOmFV+aI3bxxLnTEM9hqx6fYVe+LGO7 O3O/cMXfawLxszvFRLcLEn2X4vkjUszapRSP5SI6TFUqoUESEIF15d4vlFe9wDF2mO4RY0bpGrsr qSu41zh6OdM+ZfMUcAVcm58sszbq59pMmzmE88C4oiycwhj+g+JA5fCpZsPtscIwElrqF15DLC4t oh4eyomoRpSfiDLNDUFK78IFAF4LjT4dC0xwtc2LvMtlv7U22yteE+L3KI+qMFbkpeKcNcEbOWjQ CCxLhaONtbafzNKwC1LUJpmYRH5IRk7Go5rwJbvTk6HAqs2qRNzs6VVj2c1zrMJFoJ+ua4d8dEZb LooCZL8fjng8L5Yc30oEQV12h7+qySNl3uwo2E25GOeP7ytbyISOfsisqZh/eiDihnuOjwGGl8NK gKiVXanBqKtmVpVw3Ypp7daYT3NQSo2gPAYnUNSjY7yC6gg32W1heTkbiXb0CExolOMYS2Gk8sb3 ejodwOc2prMjTLUcy+w6AT7TXyVI2+31hlbv4NntO/iezio14W1dTNK2LvFVN0lPlli6Xcydk/Eu RxKMpgXvzdR7I9AydXrEXfxUZpJAO91IAappnOdxPMkeuJxQmPTHanZwjjmcS4u3K0fvaNU4x1ks 7jmKW8MZHxuN5OBGxLpDa/HTkQita0omutrE2cKWfomXh1bcJR5ev5jckGUVq1s2FDnzi5PjyWGa 0sAL+gHk8o4EztqNiVsfy/IODwNi6PJtiTH3FBZziCs6v9mcdw/u2xIz6fJdqa0LDlr3vaTvzhO2 8T224u+JixahSoqa4fsR5nzRH+im+x4cZYUcb7xJ2SZyvFg1k8lZ4W0ch3o/FihPCe8yjXAHuCCg MolMFNuDK56DjbK8JRuHZnCHMgn9gPbDTZkbRjRqNDXaonBFB9hoY0PbMV/TLA91Peam7QeW7jI5 hfGpiSv14pF4+kEk4hRkDdpsvOo8QcCBW3krZVoF+EpSoJGijPswWgdEi0eCjZ/0UurbEZqn3RBt Dk3GegOXZa7jrGQ5QGv8LAps166jLVwB065qEhA2CwMxdwr0NUbB/ev+9SbHx5Uf33gy5tc/QVz+ evP2cv/0ip+8eXx4utx8hY3+8B3/Kd9pOlQZkazi/0e95gpF/oEMgRJN0OiTp81qFA9BkWgoJ0BD qbp2zfCuJy3BZ/whTRRX4dmYThG4sur8iX7hyZKDxfIN7+xxkdSt1fKAk7SYschGcYi3cRUPMaUw PKINmbyYFHataD1z9TE1V63j+ZxjsKvpadjYSzwSVllLnL6NgdfGXack7gYq9Zea75hDJsciFcoF 3d28bnljxlaI1DY/w1L69//cvN1/v/zPTZL+ArtGiiA+Cz2KA31yaAWUVgnOhciQ7FNZebNNMDVF D+8A/Btv6+QzMCco6v1eswDhcIZ2ILGemmYZhW7aUa/adDCM3G9OAEgAJFjE66YwDKNTW+BFvoW/ yAL6xCL0UGOqGCUGKUe1zfyFebXqvdNG68wz7qmHKGJoOUvgeEpHI/q4mJ9+v/UFGbkYZqKVSSST bKveExSSqJl5E8RYXP556OF/fL/Y6jw06vsFB0LBTd9T7uIT2pyYGPWKOixO8Ns6NE9ABpKjTgoA xq/iOvApG7GUFX2kwBx4ncgnPpTsQ6DkAZuIxIkk9JIUf1fIypjdfiAqQauJps26DtPK5RW9i+fu bOyDBejNivdW/gaCrPd3wfFO5hhzmPnMKeEwhHRBRl0YiY6lwSYbFI1ro0LuS8vurEwFrvBK/koO zKARnpx4EEQdzq6r7KyEu50RZUkB47zY1j2BEbITgSBGq+l8EurhSPFH7332wV1iucqlruE9gi2V cds1n3JjFI87dkiu7D4QmXSOtT0yYNh5YtS1K2J24PKsfTWWdy31eD3hZCN8IW40J5WhANdVH7o5 oKYFENF3kJVtn0zL3nc3bmr2RTx3WoUPTrRPO8o4fzpT9JWcN8bBg6ksaxOIdpPmadhl1l3M7srA TyLYtJ4+8zOGp/YQwdIw8Aq3InNttFN4hnjPPrihhQrXIKeQkxirFKXZvaY1ugYwSiepk+iqahn/ ia/JAbaDo33wUxEP6pLpkhKh3pUzBAsZB5dYMom/Cf6ych3s+Wa90tpwTtfupjfrusZhm5I6nZoy ctTLuNiUu1jTb8hYPUCiONEPWcHyesDdY7aMTqpIScLzwaWIPagJQ5FHurYiSJiTKzIIgicTMJ6F gToUgYZH8NUL8ow6RK8R13Bha4yvsDy9/vfh7U+gf/qF7XY3T/dvD/+53Dw8vV1efr//IqUs4lXE iukoB5X1FuMhFw0moCtyYPbS8TwXumb0zIlglydu6KlrQvQIBBVeh60oywtPWmActNvN9wPo1Re9 u19+vL49f7tJMSSa1NVFGZGCZJySAdP4Jz8xRfcumtFrjdiW4kojmgEQui2cTHJAwZnKc3Mg0jO5 nvkcnLS2VDoAVQc5y/Qm54XxGZaTIgRHnc4G+bGwzssp1zfAKe+A287eMc0/HRO+VeIi1zaPkiJd QNpOPp8FrIPRVJ8fBLiJwjXF8DgahNtw1Rulkjvj+VFGwzHRap8HmcEPQ6MiBNu/jtjeq4iqep+s qveH1JK9m9PkXeS5lE5xwfba1z7ydOh6G0BwgrtWYTQC7upo+mX7QpVXH2Pf0yqrWLReuYEGrYt0 3AAKFGQvRUXAobBRPcdb68S4f7UQeRyOrmDMkmpaEKS0UpwjmZ5aV0Fitu8WA+NcqR42XBhRStoR y4wWdzU75FuKEQl0m+9E4iS1GOw9W5FzXm3rajYDaPL6l+enx7/1jajGhpt2hGNxfRFrg5g2McUO MZn6lI0HhAZuP49ePopxxe/3j4+/3X/5982vN4+XP+6//G1aiGDh5TVVrtK4k0hcZLqLl8raKVP+ VC5S2dDqObjq5FUWU4c14FBwceQvcohrQkyiVRBqTZnfpOhvcUlVjhA/WWkuCgdLLhedYHzUsL9c j3TCKgETL7Ku1TJqzI+Y5ZT5isItsLTU9da85E41Np6oRCh+jBIRY/Ja/EFb6GMlINs1LQZlVerG OIvQbp73VxHZAHdEj4S8yVIFqqW5AMiU1lkB8kw1cO6ecsx+oISgxEpU09kJAjfTTwr03MKZacwg ILItzWcQ1VKbHz8x2gfJxGVukTEBN8rbMvnnrKVsRrEi6amUgA6fCgtCtXNRUAfyGUghyevYWBlF TNlSI+rI1EnCG6c65dyEQqsRbvJ0LErAAdMXCRnkAgLI/9rdDW1dd9xy35biYimxy+jzBxeZESRA xmLAFr5WrKtizhBB9GMOQqU8f8K1MNdyXSAM85+o2xGhjUUViji071IiUUyhCcYPW4qpt9RRp2sr wLbN8no+wnZHpoW5FhBUiBNVjEj1s1OJmBL6RqSsfNILJh3tcDCiR12/odDHUBo3rr9Z3fy8e3i5 nOG/f5mPLbu8zVQzqAky1MpVbQbDMCkzMSMqclQXdM3EIp/i7Fxrn3RcocsUyjCjPZol9tro1iod frkRLgEXJzXvx2qPyc8PauI/LWqJgAyu57i0eRPHOoGrV6K6tY+wREukJZpXbpy//rLBZXXDVHMO +4ui9xzxyE8jVFcEjMAzDq2qCyiFxYTFLKe0PI6MEYBi7QtZleu1A+iKBDFRcGv87bEl+TgS4QJD t7/YiFH0Gf6wFKpyTKDe6iVGMM+nAMuC1lTqhHnardcw85ZPcbQXePq3JrhVNlKI2uQ0KBmwFOzU Xv0bcbmNGYtTPRyGRHKo2/wznUcWvxAbzba7BPLZgD0Gi8wIADXBeVPtjxYKaYevMpgIdtGXKngh 5jky7mB8+JC9P5usBjmVxAo3M5PxCC+Kh9e3l4fffrxdvk6G3LGUfUsJ0zF5VPzDIlOfeHwOJSx3 mZpecyBwwBQPfkKaK0kUcRo3nWz5MgLQ+KHdKceAXAokY2Vcs871XVtw6alQESdc8pSkOVbkSc2M mD5ziS6jF6Iw0OiYHj5lLlnGn22mdDIVbQIok3w6xlWX02oQma61WL5JJDhzteW0momOIDmrW4xD hmobRQ51zZcKb9s6TmHKpevQaqX8EB5WcO8U2UgMHE/icgUvXwFLvArLJFUvKWOSSr4kd/m+rnz9 tzB4VGvotZ8Da4WP17Ri7uBiVepmwkBqCym0jE0SyxlptpURgm0kRboqoQQDheiUH6WR7g7HCr0J oNtDs6PhJwt8u+9pRLtX1DDim0NDRsAr8k9H1X1Hbq14iJCmZ3yZ6FwKNriqE+2EICPQTMgVUdNq DMJmVrU6UUbhE3pMysSvxZYegeyusL1Me4MkZ5Zni6E3c9IPcCkm74aa4CdVmGaUAl0mUK2N0sKT bY9gpnVPvwnG3/Xe608Gd1byxVKm+Zwc8sbSfpHx/noFh2N8lo3eJFQeeYFsxiGjxhgmy/y4JPvK Rl2cQudYApnv6bAYAD9Z4tH3tiKAsHxkZf06NdcfS/qIXJTa0zF90g9qdmsJBMpu72gLWLl+qDyu 6ncmH/XtcviLWxZFK0XwREiAcR8oPfst+wz0vR7TSPtAjQvs3fYiIctK0h1eIrtrlU/hb9chsxnt srio6MVXxR1+SmmzAFFfZ5EfqRbQclUZBgAlpRCVqq2r2rIWKnn35EOPMUO5erFEFWFmZy+Rv3nn yK9OwPMlDSN/wU0zWWMmUde3ypgAWf0uzxRJXEbnTXsikIk6qximXn6PTtgSXO8biF7FGEJqRH7C UHNZGcs+YWWl56gZi7epTBY6K4cmy1CalLhy5Pob2SgXf3d1bQAGJajFBOS30+6M6t/WxEaut1Gh +KaErrPcrk1qb+SGG8uqaGHF0LojmQgDaxoRLEcki0vUcVyvgWXZJ1t5TLu5g//eOTpYXsiB81iy 8RzftVWav7u6WMneXa+sTmC7Zu/Jg6zjHElqXFdi9tJM9csZoVOkL/IdW5CYj03pGeHGg5EAG+fj VA0dMERq+FFJLt40d2WmJAzkyitJFsNInaoioMqP73zjrqobkLTlRidDX+yVrbfA1KuBVFGXHY6K R4z2WyZVHGfQe/rM04EwdZi6gnT7lio6qSoK+Dm0BzrxKOIwnlei5D+W6jrnnzXuLCDDOdDEGZPA txBI1QvnE1qXm6YWm/y8aewZl9gWxSfqNfVwp0VMQYDk18rOir6zyFJ8Cd7jG5iC2OU9oBQQ281W QGWe32DYGVt0O7hya3rVFJ+0FMh45R6hy0W4j6L1JtzqYW2WS+B4/bXEvYEba7By8bn5oDxlltza V/sYgKNVFLn2jwHBWpSjvyXC006DvFwzcrhexpZi4/1Eb0wK9z57v/KkKdDVV5m9vlMBwuOkP8d3 GiFa7Hau47qJihjlVxoIEpneRiFpWodrlhP/AUVnjLpMglKc2qqKvw/HWlurHmr6GLvuPLnTOuoi x9dgn8xaR7lA7+d4+FpaiKfu1EuFucPBZe05iAqu01N3etRywTLKE2160wZFVs8EdknkugTtKiKA 4ZoCblTgaF+ld2h0m9vDfvda/JM0HODBPbghv6Kt1FKrjmRakANBmHfbmI6Px9H4EFjlyqnEEbp2 hgOVWAIcArOCoQRznXLUwcxMDWA35Y/Ht4fvj5e/pKg5TcKsnA5wQw9/fJBeuAj6mbyRjcyaBhOj Y2QKeUgQPCZHpTg8YOfMWBKsbJpMg+BLt3YaNE2tJXVAkO073DxDrZQbbHTqszWjc0Kw4pBMY3t4 fn375fXh6+XmyLaz0xWWuVy+Xr5immWOmQJ1x1/vv2MSDjkS0HTyFpYcAmcL/FT2sLt8+vw9fsw7 dhwsVx5o0kp/35QPYljPLLfp3qXIZBN7Zmml/sIHQSXocJML+22CDD2P0yLjoVKk505Rp8RgkT5l 1IwIXOHW+XySf0PQzZ/3L195iBMqwjgvdNglVxwMBQFfcNbPxqdy1+bdZ63tmNA0S3dxb3Yih39X 9NOAIDiH4cbT64Oh/6g8nIjmpXJ+i7H+JjZhTLbDrE7KXoGfQ6NFHBBv7k/ff7xZHRt52ET5kIaf WkBiAdvtMKuyGudWYETK7lsldorAlDHIb/2I4Y05vl5eHu+BFc0Gyq9aWzAWEMu0ABgqBoP8kXlE NTIG8kBWDf0H1/FW12nuPqzDSCX5WN+JVijQ7EQ2LTtpz4/S0NtC94mSt9ndthZea4tGbISBaEpf NiWCJggiOtCFRrQhBmwh6W63dBM+gWgW0NcIhWb9Lo3nhu/QpGPCjTaMguuUxe2tJXjGTIIRP9+n 4Kkisneq6pI4XLl0MiqZKFq570yF2BHv9K2MfI8+EhQa/x2aMu7XfkAnIliIEvp0WQia1vXc6zRV du4sb50zDaaEwbe9dz5H6IUIoq4+x+eYlmUXqmP17iLJP7HQe2c+utIbuvqYHDRrOZOy7979IF4f Bos53DLmHQj9JamclNiXdDzgT+CKHgEa4kL2SFvg27uUAqNWFP6WZcEFCRJW3OBl4CoS7hqqeD2T jI4GynE6I3l2Mrtn4UKYgZSFj/jvkLEMb5yWJznps3xq8/c+uqsTvI2RCY0WqlNpm5p5ULS6Wdbm lui9giBumiLjjbxChJqFzZrKXijwyV3cxHqrcBz1gDQqRo9OYSPjfbtCeGJ938f0q6eg0Lm1Okbz yiJbu6BRTLftGTjPMSG0dOOYIEMMV/d6TyH8lIKmSiMkOC2EzgRJvSWNmGeC/c67Javet+Q1RsEP ctiBBXPM4YAr646sF5UysO0oTfVMw/I0O+eVEjpxRnal/Max1Dv58dGIwZO9ZmYkXB/avKY+U8Z7 /tpIoED8TLK63dpQW8VEbcFhOhK6S+c8hR/keH0+ZNXheHUOYxY4cjKBGYEC5VG9Ts+4vrGkKZ8p mr4lH38n/I7lcajo+cSy52kcLRlZBQGyFiEGX6HCSC0kui3zlWHFKu7V08Ut/7W+0QN4ZK1mO6pH 4tMo+M8hj5yVpwPhz9EYRwEnXeQla1eLDYUYuCwCQ6a0Ahxd5FvlKBVQxWJWgEYbMIIYQHjhNAq0 CUUt5FAZftR6v4/LTO3jBBkqBrI9AS+UoE8zOCuPrnNLmQvPJLsyGn2PR50RNZGzxTR1uxRXdLi4 339BRYkRQE3T0Zwo9nOs8n4TDU13pxyaws2Jg4lCBY8TjNZjGFl1unSyy8vD/aOpHxNH75DFbXGX yFZgIyLyAocEDmkGckwSd1nKnb5qNWK6TNlUtF2CTOOGQeDEwykGkCWAjkS9Q559S7cLQKyWo98r jVZCEcltVNyfJUTWywoHGVO1A6biYR9WFLY9VhireSYhe531XQaHChmWQm71WX0jUlC2UW87L4pI t3+JCORiRldc5vPaqZ6ffkEYVMIXEdcNmuGhRGHsb5F35vhPCOsEzQTzwLoaherFIgGtdX5kpQFD yTn/ZAFba2JJUvWNBXyllBvmDF+oyLbP6CsFNXFvxIOwG/p0VAdBMDLmj128H3NW6VVoFFMfrm3V sQiSX/lySzUY+T7xBZMIZl9EL9dnv208Y5gAtiwX3zO+umMwsY3eXpIqr9Df9nrXWKOEVlqA0gJY QkioLFcrVSZdO6dk0RtUiUBiKR0hvhr2akjMqv5cl7TczZXVIL7SWTZOU8hpog2oGbTdaOZoTFSt Y+RXeUQmMQou9CDcVGlBBtoG9HZ8qRJC+U5RtB/OIIBUaa10fQbyyPggMGhBeQ0yw+JjQWmG6AZ+ G698l2iPGg9BBqvBSBZMnzeHTDMwhyturjkKLHe8c0zGFYfBKmUrE/h9qwCqkxaME0S4a5HOT7pJ 96Eh/UFgEvfJIcObAg67XKJL4D8yFQoMfKI6HfZwL7ubVAJTJglDZpJbL6a6PbKOB3oTweNNpTNc 2U01v/zwiOFU+LW9btC9WZZ8EMp1UMARlM2JCHwMJM2TOfIApRR9OQDLYz8dpNLjJW9i8ufDd7Kd WEhL1zRBiy5Z+U6otwtRTRJvghUl16oUf5m1whiYwLLok2aMtTBFl7zWA7n8GPMfxVC1Yk0vhqC4 2Ndb2Vt3AkJzp6HDj80yOAZOX4ZtfAO+gZoB/ufz69vV5B2i8twN/ED/IgBDnwCqoTk4uEzXQWgZ aUBGrusSZYayoU2KuZ4pIl0YOYrJ7joCUmoDhiEaVvo3K65qoO55HMvNVmGhHbU5yuFCtQkMYOg7 +gcAugnJdyhAajZgI6hR/cxFOmWMbkQ8bvJPJKWZR4fv8L9f3y7fbn7DMPqi6M3P32D6H/++uXz7 7fIVH65/Hal+ARn2CyzWf6kLIcHw/OZGSzNMAsnDsqlym4Y0ckdr+CuxkXRK+f6BuKzMTp4KMtvJ b80igFlefZzyBiituc1K2MPWRVcb7xHykkqU6B3axJcd6XaBSGGXMu3d7C/g5k8gCgHqV7FL70f7 AXJ3djG+D/CnXV6+fvtTsJuxsDThGtecGZY8xeK1YRD5zmRmZuUpWk+7I6lRRRQ1/xw4Rnu+Vo7H wj6KMAXaAhIJA1uLB8RMgjzyHRJDgpP6bvBtX87MmlYMIRiYs9PSa5wlBPn4j2erbyTXo33z1Xwh B6b+UE5ioVJjuRbNZgE/PmAcaikzHI/+pkRuUnOrNlR2x0Wu7hqkMJgPwsZvURYwWGlS5OhVcMvF I9J8Z6bhChu9USNOfxKYP/8Hxsu5f3t+MU/CroHGPX/5N9k06JEbRNHABTGj5uzp/rfHy42wl7xB G4Uq6zDyEbcBxr7AtaRsMKzB2zMUu9zA1oTN/PUBs6fADucffv3fsmut2Z55DPIKL0HS5OSVkJYk AviXpNkbc9gsiGVR8uU+VkkNuMBoocVGYBpvnFBxyJkwZdJ4PnPoJ+2JiPVu4JAhv0aCbXwHFzE1 JtuEAzG6be9OeXa+UkFxV/VT/jO9hVA83+VZQfRLS2E9j0EBQjNGPjFR27buOyU22NTMuIJbKV0o yeCmCofELTGyWQV3DbLGrLg9oMqHrDIry7xj22O7N3H7rMyrnC4Hd0ca8TFmzdxpYxIQzsfw2hxk 59zSInas2pxllhnq8v38ZZEDDTbv6/3rzfeHpy9vL4+UQ7qNZN4JwBgUpeAIAGmAdTx8TpHDCH4I XE+mGNQ8O1OhvP00uicqu0nXTvAaeGhtSneOyES5/syg4eRqUG6Y4Sw3o8u355e/b77df/8OQhvn eoQ0KHpQpg2tzeHo9Bw31HHNkaMyVy0xMxW7sMbpclkGF53YRiGTQ9SJAcprHXTqoyDQYLOMpHVu 2I2R5acrl31oBL8HlvrLiMXHCW3w5NpdZzWgYe0qyrTvIoYnxXNDGgNlNMRu7UaR3n4xLKUGzbto rQ+SGj5/gvkuGb+Ao5fwdgqUuWHCG7ecONdGZL49cOjlr+9wypHLzLQqM9evQ61qNdSpDLckuRFv X3g1982iI/zdomu9LU2yiwJjcXZNnnjR+CIoyYLaaIhNuUvfHSUepIQ2ahDbEU7WgLp/Llh9Y3yM q89D1xXGUJhXGRlbNNHa17tbMtnnS4xLXJRy2HAObJOgCyLfGCwWBk4UGi3hiCikjaYWio1L+QAJ /Keyj/S9dky27kr1wxZrvIx8i/3hhN9sVqScT8zhnOn0vbkVagz7Z+d8S9ZNQogmAgEHdW0yAJ5K WHAh+1rPM0EjRwYWc5gmvgh2qiRjpXp/enh5+wHi6hVeGe/3bbaPlWjAou0gOB8b+StkbVOZs6IH OruoFzfkbveX/z6Md9Dy/vVNmw0oJO5a3HSSdDZfSFLmrSJJcSBj3HNJIVS9wgJn+1zuJtFIufHs 8f4/8gM31DNec0HAVb8r4EzRVM9g7IATaIMmoSiWrFC4vq3W0ILwLCUiJ7CU8B0bwrUhfGuXfH9I SMMWlSqiaw6cnkasI0sj15G+JpceZw5lQKeSuGtiWYzTP8u+9ZknRFXcqSXgUHah76khjyUshg6j X+IEFTs2TXFnlhbwa8nSZTJ7pr8GnQORlOZ+o8QYpwlc7TrYK5QXmuDaopplDHi2Vw2GKgr08ESZ wwmVyRmrH5Kz57hUKLOJAOc1lCZchkc2uGuBeyacbZnZYAU4xWpVgFPx7SdPzTWjIdTXGR15SD9R gzKh0244wozB0KILCDllc/dA4vDpo1QmsaTFm0hAnnPXzoo63TUSj2o3x3mkpDuNLEhvsBRUpjHh oHi0cWjL94kGpSFvfZXEYm66fIVPpznpReeHgWvCsVerYL22NHm9Djd05CKpV5vIrBdmeeUGvQWx cajvIcoLrvcfadY+tackisD25SDaODRiE5FNYuXWX9EtmtbFPj7uM3zh8zbkM95E13aBQy+Nttus AtpvZCLh+vAj2zaU2Db3I91sNsHK7OA5LxLlSVsJHcZ/Dic1trAAjkptLUaNsC8SqSkI27Qxi2W6 XrlyohEZHlHw0nU8NXWIgqLmXKUIbbVurLX6tKQs07jr9fUvb7yVQ325W/euBbGyIywjAKiQtvyU KNa2WtcBgWC+Jf8oS9ahRy3lmaLPh11coVQMom1BVXIbYai5K3Xcug5SUGV3cekGB/Mo11tRphgA qN3fEZ1D3wNWJnT/tnQ8rYUAvSfJol3fXF8xCfwR57BhGzIwt07WsCP1HW7s8c4Apiz0iPnGJLCe S8Ax+AArSwLDj87ROYDCBVQT8+AWI6JeaSDqmpxgZ1bKlVDebk9hAn8dMBNRJq6/jny6kTuWHMrU hO+LwI0Y0WNAeA6JAGksJsGeCT3kh9D1iSnI4cKp8dhl1AKHKIHPhuNu0AsoWrgJ+jFZEQ2CDdO6 HrUoeDKEfUbNozi46NNHpVlbnWoUOjLslkrhWRoCEsM1toMUnkuwMo7wiBHhiJWtREiNFEcQ+wcF JY+YCoSHTkjuEY5zKf9VhSIkjkNEbOjP+e6aWnWY9Zjc+RzhbywIaiFxRGD7hr1ZG6pI0viWc70s ekwUubOEGJhzaSdhsLpKUWbVznO3ZWJeDnXKdg1b3yfmvQxJ6Non12pJppeW0MQYAZSY6KKMqGVY RmRzInKdAfyajFKU1MQAlNox5Yb88CbwfEKa44gVsegEgth5TRKtfWrnIWJF7bCqS4Q6KmeaqcxM kXSwiah7ikyxpqQgQMBNmxiIquHRjajPcSX9hpYDGqtD4VSabTtbJtuJ4tCRWgMJT+1zAPt/keCE otbNxeYjv8yAwRDzkMEhvKL2DiA81yE3CqDCMx3lf25IyZLVuiQ5xITbXBN9BdHWp/gS6zq2Dqju l2UYUlJxmrhelEb0FYWtI49CQC8jakryKvYcgvMinF5bgPE9i9v6whBJh9kZfSgTinl3ZeNSK53D iWnlcKK3AF85RGcRTg0CwAOXqB8jyCXN0XYLAHQYhfQr1UzTuZ7lsWMhiTz/2vo7R/567RPCKCIi l7wHIGrj0h5AEoVHCKUcQYwGh5PcXWDwmLRYyUiExToKOkJ+FqiworsZeuvDzvJpwGUHOkLwTGW8 dFHmofqeQVtuTaW6XLNuHVe+InP2L0dqHAFSTvrFlH1EsS7ucnQxpeweJqKshPtjVqFjHjal3u2W /NiOWadNvJjwmPIH3VYx/J9qszZRTKlr9zVmt8+a4Zwz2mKQKrHDOyM7xGTwUKoA+mMKb2Jz7NQK qcZaG0nQYawx/gf9IaohaXbatdknaXaNFmCUbh6izrQlfnq7PKIl28u3+0fSCpk/dPJpTYqYvEoL ElYnQ9oB663ZTrccVgiWdi7rGyj8ldMTDVmqQAJzCfMNMPVTiTQtioRmkaatk7kIBjkf2rhRrGOv tskYm+Qw1Uabm5JDPDVGfk8hZvAcd8khrcn8wWwL88JYvlWc79hW+YEuWnI+Bl4qyTFrL116wqpA 4TczJ2igS6pEJE59b90mZUzUhWCNSLQXU+4u1IsOWaagtcwzBaup10aOX5pvVD61HiPNJiV90VII bcGHBJH+RLd4yPz+4+kL2pNag/qVu1TbXQhBLaSq88T4McKQx6M0CbxQ3HnR2pmqm4sijgcUcXra yoMTpJtg7Zbnk5Ui7hvP6XVth9yN0Tpdi6iFqBJdm8hkn9gt/pAl28pOwMBTh2XUyalhFyd4YMJC onzo640DqBvYBhVVbMpjnwQ0wpfsuFdM6NFBmuDGMTQxyxP6uQvRUCFtFoRVC/b06Ri3t4QPRdEk qlkfAlRfm5lt8wFODh3yqNxKULY72dplaYLqaa3CNatMDam4hiy40bRJGciRGZfJsCUjb8s0nVYp jwKlwrglVlLWSj4TRAhLLBUWRTxju94kAaaVgjM+JK2nxSaYHxVVKH9OJKDRylir4r2Ufnqb8Z69 ieJlklKLLNhIa0oXKpqJCbbROzKpm/Q2t1lHRQdHlPQ0PO39EaLqtGeouuZHIzOCgS4GVDJwemuU Ybq1HAJZlpBclOWrddjbkvxxijJwXKMYAq0hkZDg9i6CpSFxq3jbB0bH4q3v2oB112h9uGOJmlYS oV0O13LfD0DyYoktHCESFo2/WdGMSqCjtSVO4fiZorROuma1iPaFrhMoF39hrujS1g0CSSYm5x8n TB0XOKmIn9qs2V3OpaKQgm5cg0WMcM8eaUsQAXexPLJ252Ll+I7dZwoIMPXEtVV4Llxv7RPboij9 QN8BuvkmwjQjb378C/NYEkgdhAlbrQuPDGGGLSwDResywVxHhyG70uvmUMp4bkSuTN6Nt3H3mvQi ruvG19HsyZA3hJGqBkvSjb9STDavSoBT2Tbb42VOVeHOQGsixIVChM8/1UUn3rIMAvTdP/LoIhU7 ah7uCxVeRflNdKa7+lU46/bKrlBQ+um5IOOki6KQ0uNKNGngy6eQhBEiLonifJDEjIu0SGv3Gh5k HjSmI0kmedycn0l2pebObn2lEdEHtkoU/oOaPAvH1IgoxZ+0oOIq8AN5/y843Y1mweSs2PgW4Uih Cr21S+svFzI8fdbXW8lJPLot3GKMOh5UErqLRZf4QbSxocJ1SKFM4U7FBZGtWBSuyI9xVGjZRlxS I50RNBp6H0lCJ105CJ8eZbguEY13IPWQUfFrWbBSUdHGMndlE0WWKLcSEcif76zi2SiXxAT0sEyi ruWTpOC8kMyCDVEcHVtW5C1TptGlYQl3iiLH1jaOjN7b+pxq8y7VmfIaW/A8Y5bq6Kwhj2w7nLTg qAtJG7Nmi26iqOdbYhUOcdflFR2QVyospPX3qLqVFn+CJMLLwNWutl158ixDzryyickXPJWG0ccG C8poHZLcwrwMSLhiH+jpDRcsyJWBC6v+aqMkaZvEedYdIORn7/qYTbK5rfpRMKdxrm9hCpSTEk2k yeQL1nyOoUhWtAihC3zaii/ibb6V9LRtorNFDDGgvOcVOekm0aL6LKlTLVN6jgkBZxS5snO+OygS mSCcCCStTzt8PCUknNXVHY2Iq7tawsitwHeT5no7SpAyb7cpWXVfNiQ8F5a31BfbpCyvfJCPKUbi UjlSAiwnh5ksazL5CdSbVZn2pdzmZDE1sI3PNjx02hLPGMpiLMFc7bAeGBLXwPFUd+qlHrufpW1s STqC88ET13+O6cCVeTs5o2IDrH3b121THPdaB1SSY2zxngRs10HR3DI7RV032zi51ReSPZQ2Yi2t hfr6bd0P6ckSKQYaU5OpsiilT4ZBhRBjyca9EODVoSbdfATNiDdrHxFjpp0rX2HHbdqepGTa5pPD 5evD/XTRfPv7u+zDNrY0LjHq4dIYBSsCZw/dyUaQ5vu8g6uknaKN0aHRgmRpa0NNHus2PPc1ksdw dik3uiwNxZfnFyJJyilPs3pQ3PvH0am55XYhs570tF2WhfJRpfLRF/Pr5XlVPDz9+Ovm+Tve+l/1 r55WhXSyLzBVySDBcdYzmHVZqy7QcXoS6gEdITQCZV5xcavaZ0ynwJyiUh/5h8qs9OA/dVw4ZlfE 7MDz9yXwL6Zjz1Utp0HnX9ged/gUSkDTEtaB3mREnMq4KOpEHmdqPJXZnUOjLaOtb815SnEmrbtT ImuzT0dcbGLEhYfx4+X+9YIl+Sr78/6NB4u58BAzX83WtJf/58fl9e0mFlGCsr4BVoapeeNCDoxh 7QUnSh/+eHi7f7zpTuZawkVZKhl6EKLkreUkcQ+rJG46FCfccBkbRKZ3VcyfeXCd0MZ5nCzD+HkM 2E0O51tRM4Y5JazkxyKjXBbHHhN9khmX/jjadfhELMJPGQwDMAs/kFfF/fe3H/Ztz+qiDhUXlHFL nEHAXJlQ2Qx5gYU9+dFf75/uH5//wP5ZPp+fupNeIcLkGNR5nXSFIqxIdHHBqIfUcedvpw9oRUeE yOY80GEfBeUh6/NjOQamMSsa0bUlg7UgKvut3se0812ub7EO2q9//v3by8PXK2OX9K4xGQjjY2Ii PD+KAn3ZjGF/E4ObAn2gWCsq4OkT2mgkPRlWQyC3XTQG85D2BwDJUMfj4ozjtesbq3AEk/2ccK1x fEwY+CyJ4qtd3n7L5kS7izEvnsZ14tPadZ0h105IAaZgQ81SFb49pvusM2StBWVlLlNJ2ihEoohP xBBL+AbNcLRWeQmedFmf1I36Tk1h9YMXaUBA7mpPhaGnnOx5z+k6VwfITzIYu5uRoyNQ1r4f6qah Y+Hi2bAXtxm5bem2zdO9BmVljoEpDB7VHH0YeLl/QtSbzxcN3mVxsFbUDEIyzFdrR9GXiwiMCKVu B3MhV3Wwn8VFjqJuVWO1ajlRH5yLOf8XfYNY2h9S71djm2ALrZ3wYPZ7B8eDMUziSY5iUiv5mXo8 YU76mTdJSZ6mWFjghGDJ4SDS1Y0uAHIMSmIo9+SENOZJ4hhZkBLhPJXV6Pvmyo4ixVjOpFahBTyc 1GNuVSyLQlhtURauSDYLuoJKr3+Rg3ng7kI1zuT7XP3MgsX7jR2L3+bXmAWjHSenvKSvmRP6lNOX 2rm4RylvJywqSBKdqcgtMi6Uu4eXyxlDYvycZ1l24/qb1b8sB8Mub7NUlm0k4JyWUr+2yYGsBOj+ 6cvD4+P9y9+EqZw4wLsulnn3yJ7a8QIlbFB/fH14hkvhl2eMk/M/N99fnr9cXl8xwiQGgvz28Jdm FTttu/iYkkYaIz6N1ytVRTkjNhEZQmHGu5vNuidKZpiKMKBUgRKBZ0irJWt8RVc58hPm+44pI7HA l52OFmjhe4ZA0RUn33PiPPF8Q244Qkf8lXGBPZeR4ka0QGUHu3EZNt6alY3B87iucdvtBoFbbHf/ 0VyKWIQpmwkNsT+OwyBSYqsp5Mv93VoF3LfRd5e4hgPYYO0IDp2VOeUjApVG1llHmsgc5xGMRc16 QbIknSpnbBCShULqnU9gb5mjeHeOa6+IQuhCuDar47yZjBQm46l9gG+u6xV1kE97swncFXFSAjgw L3OnZu04xvh1Zy+ipqQ7b7QgJCbaOIcQal4jT03vC2djaUXhQr1X1jGxPNfu2ugev32slAh32hqV vnJ5ulK3OY0cHBm7li/nNb3KzT2OYH9FLn5ffV5eEAH5cjvhN360MfhOfBtFhJh0YJHnEKMzj4Q0 Og/fgHP85/Lt8vR2g9HTjWE6Nmm4cnzXYIgCEfnmd8w6l+PnV0Hy5RlogF+hBRD5WWRM68A7MIPp WWsQWbDS9ubtx9PlRa8WhRAQcD0xW0sKF41enLkPr18ucNw+XZ4x38Dl8btZ3zzWa98xJroMvLUa tmY8jy3mb2OfOx5YO3U8Ukt0pVXi0L7/dnm5hzJPcAyY6cjGJdN0eYV65cJs3SEPyIwHY9tLGDzj Ds6hG6KnJe7RK51FAtIzcUFvjO0GUN/yNT+grKcEuj45XmwypfrkhSsSGhjnM0IjYkY5nDbvmQnW K9q6YCIIwhVlQTGhVe/6pZDJjTjUYEYIVZ0FJ/jaI0MozOi1R5xJAA/f6dA6XNsPO6yXGvVInMQa dBOuyFHfhOSr9Yxem+qi+uT6UWCIgScWhp5BXHab0nEMvRcHU7IuItwrHBzwjeO7ZMHOsZhlLBSu S5u5zRQnx+LaKlGQJhAL3nWN7rLW8Z0m8Y3pquq6clwSVQZlXRjXxzaNk9IjprL9GKyqa01nwW0Y 23W7HG0wYICusmRvitPBbbCNd2YzEtLzU+CyLspuFRmZZrWcCxcAozwMp4M8iEhPpelAX/trYqum 5w1c7q8MEhKE19gtEETOejglJXm2KK0Wd9zH+9c/radI2rhhQAgyaEkdXmMOQBCuQrIN6hfFad7k +vG7nNw6Tr0QT295Yg5+vL49f3v4PxfU4vLj3rhAc3rMedLIPnoyDq+rarJMDRspJ5aBlOVYs961 a8VuIjmsj4Lk2jhbSY60lCw7z+ktDUJcaOkJx/lWnBeGVpyrsj8Z+6lzbV4NMlmfeI5nca9QyAKH jNmlEq00izGluX0BdQSWbN8G4dpu4DCSJasVixzbwKFcqkYFMheI+37Hd4njkGeQQeTRDeE4SyPH Vni2Vmar9wd9l4BQaFtZUdSyEOogjEHGFhzjje2oVDex51oiQ8pkebdxfdJbRiJqgV2bVhfT1PuO 2+5o7KfSTV0YzpVlqDl+C91dKQcLwahkDvZ6ucH3+t3L89MbFJlz43Cfitc3uFHfv3y9+fn1/g1u Cg9vl3/d/C6Rjs3g7xnd1ok2kpg7AkPFW0AAT87G+UtXkHIwqdMYsaHrOn8ZVYWKlMGfb2AHyZyI w6IoZb4INEL17wtPYvN/3bxdXuAO+IZZOK09Tdv+Vq19YriJl2pvcLhyQu1dqqyiaKWa1C9gRTsi 7BNO21+YdQaUKpLeW9FqoRkrm2rzr3a+q72lfS5gyvxQb58AU5ov3tHg4Cr602lKvSgy14TGKGfa jbV6Mf3kmnFoPj9OTOSQoZmmaXM0B7aplBdSbA+xp4y5/UYbxokBpKPVsIESU6OX4h/qdfrY3DOi eEgB1wTQmAhYhvqW6BicfRod7BFiajBnSUzG119GkUsb83rtbn627iR1AhsQRax7HpG90T1vTYwO ALVlzFekr78Tt32qd6+A23Jkm23Ru5XWiqrvQmOiYSsFxFbyA23W03yLo1xuaXBigNcIJqGNAd2Y 60/0wLCQiHcbx6WtWRGdJXSY0mnb+aGx8FIPzjbdpA+hK1e39Gu7wot8hwIajJHzUMr8g49w6sKZ idZTdSqvwGTk6VYujts40te/GCvPJaHaNAqGtZ4+GncMvlk9v7z9eRPDZe7hy/3Tr7fPL5f7p5tu 2Qu/JvykSbuTtWWwuDxHfbtHcN0G1nBTE94lb+T8GTiBi5RuOVLs0873zU+NcFoLJRFY4mMJCpg0 6/rBreloskJ8jALPo2BDqppaSZjTigpJNX/DnblSztLrbEkuutFXAGysyNzvyBY9hymfUE/q//X/ 6btdgn6M2hBwsWDlz3Zwk2mfVOHN89Pj36Nw92tTFGqtQjNrHEjQJeDa5FnFUZv5bYVlyWQ8OV2m b35/fhGCiSEa+Zv+7qO2zKrtwQsI2MaANWqszhlqW9bo57jSDX84UJ9CAdT2MN6wfXP1s2hfXFv8 gCeNy3iV3RaETd84RIGJhGHwl60fvRc4gbHK+RXGo69BEw/3tT4d6vbI/FjrKEvqzjMsnQ5ZkVWZ IXImz9++PT/xCEwvv99/udz8nFWB43nuv66mSZ74vbPZ6B9iehJj9Xpi3EJ4M7rn58dXzBoJq+7y +Pz95unyX7sokR7L8m7YZeR3bEYPvJL9y/33Px++kIk54709dNe+U26Wp308xC3tuIE4ds47zNxY U5YPqZzvBn6IjKipnNoUoWkDnK83s4ZzHA+XX5YUlGXFDi1QVNxtycas2yZ8tyVRojpoRsm6oaub uqj3d0Ob7ZhKt+PW9HMANQpZn7JW2D7B6SrN5UxQZDHPIsp43h96PwIxJnQf4CKcohlMiamR6fHF VosXfQnWdaUBIDu+z8qBHdBgicKetFoYTPQsj+Aj3fhUegN809A/SuVESngQ7UJrd4XBXeGGtPp2 Iqn6hqv6NhEdjMqg07OFSZnebI0Xgk9bSlrd5WlVAssj08ZpprpWLVAeHKHpSNtKIIrLVOQdV4oK 6MCoRMESPslvLSWJj1Jk+7jtxPLfmQZccdLc/CxMaJLnZjKd+Rf8ePr94Y8fL/dohC9xSlEtBnGS lTX/rJZRDHj9/nj/90329MfD0+W976Taqhcw+L8xESPmkCYU35MomJLo62pzli8cWIzlLTVX9fGU xcoEjyBgBfs4uRuSrr/iADYRCyvHgARP8Sk/+DS6LKXE9iqqObKDOowTHp3qinx/0NhrvpHDxU+Q yTegrbfZh59+0nYkEiRx0x3bbMjatrbtBU44rlziG/vT7K3x9eXbrw8Au0kvv/34A6bnD3V9cPoz /5a+GDjKFhlFJeABIe3lkX1eq4Od4eSuktGnZai3mJmekfXNpMBik9shjS1OMtr3j5QV2FLpcj6a NRT1GRbgCU78ro0TkbKXetzTPnnaFnF1O2SnWHbb0ojaY4U5soemlLcTMWfqXAJz+P0B7pH7Hw9f L19v6u9vDyBFEbtfrDg+Xvid+tjhaQvnLbWWRORW7vh4ZE1WpR9AKjUoDxlwwm0Wd1wMak9xgWQm XdNmWdl083dBUDdo0HNqcgTbHtndOc67DxHVPgbChtwFg4CnGi9yXEPHVggdLjGi10ZOOdH3mXam n0As0k/9837XUzCQYBLzlNuXcWDTViJnZRRX48LgPt57yv0TgJ/6Qv/Atk4OtpXZxFU2R4+d+HVz /3R5fFWXDCe0xY+gmP5YiVyH4fEw1ztjlHYsV43ty8PXPy5ak4TDbN7DP/p11GtDPmPThmqeWbc6 aFlXxaec9GQBbJK3cJ8aPmWlIXmctnXPH6EtRcWhpYmX6a7X62ldj1RviYk3vppTtgtc6IxPsT7o WS+cnjFuA2wyRk1J3eboM8kdDz8d8/ZWo8J0321cpdxRQrzlv9x/u9z89uP330EWTPUnfbg6JGWK WV+WegBW1V2+u5NBctcm2Z1L8kQHd+hIkygVJju0fC+KFs4KA5HUzR1UFxuIvIRB2ha5WoTBLYOs CxFkXYig64LBzvJ9NQADzWOFCQByW3eHEUMyAiSBv0yKBQ/f64psqV7rheKGgsOW7WAfc39HlRgu pUo+ePy0KckAtKzTbLz2qFV3ecG73+U88ra5Nv68f/n63/uXC2XAgvPBN5dtHJqSUvtgsTvgTJ6i kJOhxkKJ20SbhRhuUDB4tAscXySssyJh3MjXEECBPKj6L+64ppnWk+KeWJHP63j53qvLrYbzGH2S mFY7c1MeIIqupQL+lOsNEkBLjL4FrzkLLQh5kcj1tvnJ2tF8Tfpt4GrOIieQc9PgVMYt7EUMMF7J Pii4FHk6Y+3DAjiUUCar8iMlaUpUd6zLQeKg66Ak3QWrBA/AHhuX2RloNc1dKOZxfIfOnpoWV3J3 51pMWASW7hDzVV7gj5tGWVr8PLFVzXJK0sD1biy4Ew9pgayVB5Hf2QsOGOisbOAs2sIG7e7U5ZfV wG9zdQpu71qVrfmpLJKNALhpJ1mhNYsjrLvgVNdpXbt6V7oo9OhXM+SHINxkFSXFcS50q1XWlNaa YAeUeUVpsnDo9ei3uMG2IF/23comYPLx5QEqLSs8gxVe1aWxL7bQYRt70a3beNvWo0nPZIVHyQr8 HNjef/n348Mff77d/K+bIkmn6CKGVzrgRESMMb6Q3ELETa6ARBvnLWatYKG47VIvoGwFFhI9rqtU vcaxiPq1iG8EhQhyebUFc7h2ojhPO3m1NI+idS6ylOoCiw9xG1OYOG2iSM0UraDWJIrKRywVFCFG 3xvu0HfIJnHUhsQ0USD7Q0sdNCK+Sc0xMgEsOHtWguWjp8Bz1gWlM1uItmnoOmvLcLRJn1SaSDju oHf2yfQhEEsw64y0HQ9pqYSWgFtSTX7BeAGZamD1sZLTCOHPAWOT6H7zKgbv/rDhcmpLMqXCKuUX 91YFNUmpAtIyzqo9MEQTdTinWaOCWPZp2ekSvI3PJUgwKvCjiIilQYQrrRqkh4ke4qOG0vUKgwD1 WYtIusPYasQaveQjhhG/8orpdSKajw259njXWwMvj5kSeEb9NOpdgGWl7IPvqXVOYbLqIh3GuDpU fzAXzE6r9JS125pl4xmvd2fB5lV3a+2TTd3IqyhhhetrRXjJb487Yw0cUe3V6u3giwPfCq1NmIte mVCsBdfSkJ3gwDeXn7nOlhJi/WgoOJzNMmVzXDnucIxb7RN1U/iDcnmToVihNjW9SR0nm/Uw+arL A2q42/PFyBp9JI1RlCvHYHNaG+Yeqluna8gwImJgMDTdcHTDQMkpNw+NXhnvE8+6hNIrdRjyalE9 UKopcnkfteGPUzeSIxSLjjHdzpuDWX6w7hYQZ/NeGw0B41drjaHFxyhyHRPmETBfh509vWXbLlrT T4CITWLHtTw2cjSPUmLpVt3f7bOKWIYcrrcjYSsvsmTLE+iQFDM5sut32tykcVvEnjEPe5700FJN Ed+NZYyKViqQV7PSKxflLdlgcU3WFaWbEwdErH4hSw61kvevwjwrab6v9a8KqEUEWQjSj+8Q5LVt eKcKev3TWcVcnxTSFqyxB3elLSowP7NSRkfInJC0kMybmWTu+srwc6uMqLc1d0KXeoNv63bvehaH OD7vdWGb16IPV+Eq04/XvDdYdlV6amQAwXL6g/18b/OmgwulHV9mpMHfiNuEags4SBZ/BVeOIz0b 6AIW/Ml2HON9sma1VmEvkmEr1d2VO42P8BvgIf2FP3dLXtV8FWh7BQBzwje4vDATy+dW/ygiuHRo aT/iQU7lAKpKFAC3mS5cqjg+QB9cnYAHvuKWKbq4glh+6MKnMUjaLdVqQSDeNa40XpCxfF/+v5Rd W3PbuJL+K67zNPNwdiVSlKit2geIpCSOeDNBSnJeWFmPJuMax045nqrJvz/dAC+4NOjsS2L117iy ATSARjdzNF9y0FcGOk+/VyAxeUzrRMsiuTJTCVJwpofTtFHfm0e72FY+FB7xCmZmTpk6yl8EZOxa XcbsykwaxWg/sCBFUHQjmueAUth7BFbPQkZ5t1tbJ3ax0OwZGcor6Hiq23W7g4GaXBtHMRVKYlZi B31K/tdbrEJr2uyKY2aUJOlYxXEE6ctAWieXlDTGEjpYafQzxkMT6tvOFDVEhuE/sxFEtsEijcq6 slRPQY8d4bAHXJrpuFsxcGjRrxWoPqMP/HXowaZLPczWeJKiTOs5jEjMmlyGkdPJuyhf+yJoHu8u x5Q3mbVjSmDKKMRlGzBZWv2EVvrjXmkN/Br1voLQBnj/drt9f/z8fLuLqnZ8PNbbj06svRNSIsn/ 6FM/F9vKDNTpmhAPRDgz91U9kN9bTRlza2FUupSfMWPuyJhXcbp3ZZ1AfWblR1QtjfYpGTtZzcnd 5mt0trexgKX5VbStNfT74UHz3KcyVCcQlmO69tDlpOeIID8WSt9FjLiMbijNQ4XZzNzYwTC0fXBC 3Veknh09dCQmgvvu8Q47zh5gviwOXcFyUyVD/rw5wXYoOvPYxni5HytMo0aAUxUSgW/nOgWZeisy tPua72HJDPUoq6SesXdT+B01xrK6S1mfuvs2aROaS/bifNuHkL3EEJngcU9NtihP6jrdp0kWU02i uxUmc9S9T8nP9ULvTVdNQNd34nPVNmJFURb/j6Kjcr9Pko+LnvhcRcM2x1UuXdUyTxqRIqt+OlGT HtDn4k83L8lOR9jSfNw+hZFm+I3xSi/6Iz4aZ1n8M9mMbDTcq1LWWZCKmzHeTVx4M5Q65ge9KLiz C3vgsHkWodpRXcyW82V3O8YT3ZzGYHOKUh9pti1iVMVEbh9UkUryQQWuTVIIqwepIDT50+Pb6+35 9vj+9vqCtwpAgn0qhpCW3tnUdxbDWvXzqcwqXFOo2rVXZWhMfiG8I2RNQxwJT5xisZ/pomuzrw5M L+zTtWtiQhlF83qGf08e7qWQWC9nNP2XOJKViipru7ZJM6KZiC39jedGdNMFDd0sCPmTyNWJrGcQ d1m6s0ANWao+x00EtvEzIF3caUVneVqtgpCSAEAC5/awZ1irT7hV+opq1ynwwzVJDwKqalkUrD2f qtsu9px2ByMP7DgjyhZxYBgChzsELOJ+kJlb8QkgGi4B65h0guhHdDoPZUk1cay8jOpaAQSEDPYA LRMStA6nJujDumzIr4OQPyc5yKC7Y1ER5wHryOBo6GZpRoRV0es1dFi3KFz+0rfO0AdoRZmmaQxb ql7o7pbO8+ot6HiRA0fMNh41wmCVJJuZcPS8P5MhMHgrovcSHvpLYmgi3SOGpqTTUnVo8jU1haag QXb1yZe+NMytCLtuw0VIFCUQP9iQi7oAg8VckwWL+jhfA7aeC/Fp2R6wD0RpZOMxMVVLdEtKhazv 3BDIeR5ul2sM/dufiRIlKDx99CSbqYry5TokPhUCG/OmTwFcw0zAW5cRmcqlxfA1gJnc/cV68XHu IMohI7MXCC22gGJsaDpdsPSI46wecNUXZN0nLdlHhgzWMKL7a/TWFZB0fxHSIoVnakvrPmVA/Lmp Sx7H0VmGnrN1EoXKzGatOSfRyH07iIxBi/k4X7qDNvg0huoffmjQkRhRGXFfIE/UHQgtMCNaJwcj yuLEgvaAHYN/cavvskxRWPOWGBc8rffqrorg6M/kTDLPPX9BLrQIrRdWwHibaxVQkydvmO9Zt2QD Yr6dtVjSjjOnKQlwNIx7Aa2ZCGjtuuYbODbrlV1pAWzIWRcgDBE6n2uwWRJfRwD2zXsPgSbsvqEV POjdn/SgPnLs2TbcELOx4jJ/FqTld2TwNV9INuxdqb5U4Y8KIAWlh+PouiRt4Uc+7jPP2xCb7YZL vc6BBES1RSQBWkWHpXLr+5STY41jRRR3ycNgSUoAIh/sUwTLnAaDDCExcWGggyWxfCCdUtpEYATL PGFEKBfJKgOlNyLdtEQa6aT+JGI2zI0zZKBWI6BLJ/oknZZAjJ+7IMaGoNN5bdeu77idnXSQYePI ckPurxFxeLYeWThDB/QzxX4ShznbdeURXYaq5CYgJg4RipyUBBmkfE75bNZruosK1sImYr5ByBPM jvaCMvcaAaqVEqCmqIqtQWFiRJqsQut36F68SalLF8N5wicXLdqRlZZOLuFoR0oeTE2wDlzVQxFx YZ5ViVzvJ7pyFSxNRdLYfhkARPXLwM9uJ074HsTle3FojkTXA1vNFJWpJbLp75vt689vt0d0uYTV sY7xMCFbNYl6VyVoUa2qOSOp2+8NaqU9pxCkFm/nddouyU5podPQs0z9YDYjOqbwizLSFGjZHlit 5wPfn2XZg06s6jJOT8kDt/K3bC9U8KGqE26lgc4/lEWdctqwCVkSdEBDHcMKMEsiNWaXoH2C2umk Q5LvUlX0BHFfGykPGcZYVE0OkHpOzyzTbVWRDIWIt9DOip8eKHsHRC4sa1SLWFlKcuFloVqciCo9 1IbTHKSmkeZHQJAag/Ab26kvOJDUXNLiyIy8TknBUxgd+m0dIlkkbF0cjZAvR/QESVGeqVNHAZaw E7eGw0DFH5XSJSNdHRZIrNt8lyUViz0JqQ8a0sN2tTCERcMvxyTJZsRJPCnLQQIScyBk+CLKJD6I KL1mL4jY4AcyVKdIluLZa7lvjNxKdKBgCm7eZk0qxEynF02qE8paC1wuBiorGpgIQKYVwVeI1oxT JQ3LHgpjdqpg1siimCQa77ZVZP5Bo8qJz1jorho5NDs/FZEB3PVsM4ZxhWEk0Tfrcg5LQT9wwpyB 7NHPEiSc87agjPEEWiVJ3F8TquRmsP/SiSCPsLgk1IZQcLRFlbXWvFnnlCG2mDDQMwPj+rvLkegW fZ6zuvmtfOhLG5ZohWrJS5OeS7NiMK9xaL+z75ojzDWUEakE65Y35sMOlWrVocXlu6vUJ6xihk3T vDRnxGta5KVO+pTUpdm/A801kYh0DzHqRq4xzmFOLevu2FrDo0ciaFGZ97+cpbCsMmR4uCElNI/R vRipHeH946DaKN68VF6Zwcv77fku5UdHNuJGGGBT3ZqA0XlDXF4KabFItoEuSXrQyuM7vpcAN6uA dnAAmq0h04y2lmoJg6bHd115jFKXCwXEJ2uCsaFIxrDsTZ3Stk/I0GZVigqrkwH+LKy3hArOalwS Ge+OUWyU7kgh7XFE9yETNlVRSkd69eeP70+PIDrZ5x+a38axiKKsRIbXKNEdoWgNwLp3Z6uJfX/P lGRkw5zBh5uHKqFfzWPCuoRPJr0okjx5Th3t5aBMNqn6xm+gjB4O+riYX1/ffvD3p8e/qJiYfZK2 4GyfwHrP21wN68FBRe52WamVw0eKVcLx9fs7ukkbnGnGzhKbdJ93quehEflNqBVF54faedOI18GW 2sEXycVYXfGXfCBN0TpL41EwoazAuuyY0QTnrkadoICtQHe8oO/K4qCvFjLOTULsqER6xv31KmBG 3cRb7IVVLUGmn3JMOH1ANeDrFdVtI7rQAysKOh4jeNTbcYFWEdsGumNrle5+YCy4HFOGrE/lb1cr s2eAGNilZVWwuNIK0FSb4AOGtT/DcMlD11G4wO337TYeOPu+uuRWm+rkgB5GSTd5UvZiL1RtTuTX ipb+Rg0lKqhNxNbBYmNSsyjYagfGoxgF/5j5JsXeW+7yMUDuJNPCBPf/np9e/vpl+auYK+vDTuBQ 8b9f0LsmscDf/TLpT78ao2KH+qbdI3l2hU5x9zFay7pR0KA34W7mEzWwduZtbzI3w1bx9XIRUCd5 AueH3F+uFmo/NW9PX77Ygx/X3IMRxVkFZp5Ia2wlzD/Hkl52NMY45ZSNnMYzusAzhaXHSQ85GkdU tR8VwiJQtqUPFDqP+WljbI98sNLpn0t0+9O3d/RG//3uXfb9JIvF7f2Pp+d39PQqXHne/YKf6P3z 25fb+6+q5qB/ipoVPKUdoOitZ/DNmLNhsGFNaTVAYyuSJk5odcXIDo8EKb1d7+/+AHLMBH3GcN57 oiGLSeHfIt2xgtrNJrBd6GBuwjf4PKpb5ZWsgCyzVaSq5Quu3vMpf+B7WrUUXK5X8z2IZ7gw6yVG DUB/Vq8NJ5p0PQrNQzec2kmU4Ek2gX4XKqhp6G035JCXsBlapKd6pHdzCSb+0iMSXX3qxF4mCbRw 3T1tQdCWNm3jq7S6ifS3zUiApWO1DpehjQz601hVJB6jpoRPR9QWUUAa2I7o+fTEwYHFv97eHxf/ UhkMv1xIKs55MjrnA8Ld0+DzUJlOkRG2bHspS3oGgo5+Gwiy5gNDpXZtmhjeDET96nPX+1Id96dY J0u5G5jDsMrDxdXOhe12wadE3edPSFJ+2lL0a6jHsxiQmC/9BXXlpzKoF1oKfa1a1g70nF3XW1Ne eiDcbkMbqHkQ+VRWKc9AzokUEtCf0w7YFRD68mngqKK9eRlLcWjh9zTEdyJrn6qSgEJauR57Z7Vs QlpHHFh2975Hn8SNBbEsJ+0pRvkD/SPQbK40RAsoPn6eKGiCkGwYhz3DdkHdcwwc+9y0pByzBYkk Y3IpDEG4dCX1qAv6gSHJ/YVq0DcmPAOdkkCg+6Q01ecwXMx/OR7QT/NHPIYBFlpKBobVdA5/wkQe +TGQ+4fTRsxhy0U2RiKw2czJ0zpFXD0ZsJ3oDujAbUTtRaaP00ckE7Wunj+/g4r/db7KUV5aSwTS z2LOnpuaPD1MmYLQYd5VhoCUaZzXwqDbszzNqAtChW+zIiatmHurxYrM2bWN0xgCV9L1B2LYnJab htEuD6dZJmxC2q2JykJav6gMAbHG5DxfeytS8Hb3q3AxKzRVEC3IsY4CNz8t2rtrW54Hh2vWsugv qaWqfxEwCPHry79xX6KLsFWPfQN/uaKrjp0UubySjhzN2p/CZ4kjXBn9+IPiL2kWlR351CrOmdSa VAfGI21UnMYsFexsadDSP3XObP/G6HFKPkLXihn8K4oTriLJ9EoMD9CHvUUGWxIGsnQAbCL3R+pA UxXznlqyRjKPDaiyK+ZNdEX/nOnTQ3GfV11caaUIN4BHLKXLD3lDAUrdL1hEZHl86+nUZ+hTaM9F j7zttHx7gvGoFLRQyTV2f/T8dHt5V7qf8Yci6pqrnl2MPjC0ADfjV+pqlsZKlrt2P7xIV55gYab7 VDW/4BdBVa4HZGKtDPjd5eU5mdxbq+KF6BBbgHTMLlmOCas4kVTQxY7AjH8z+DjXWzNmGyk9w9pr nPIqY8o9MwYQ0i9449VqEy6st5A9Xbv2yfEbRGnquMUFqu5VoBJexuW5b5fDltrwKqvXqdtlXalf 86sIfeikcIjTaurCRLUuatG0WH/Vj6QKJ5hDUqT1PX0LATwxxgD6gIeR0xMiPKmjUt3RiGKjVPE9 ouVUJA19GifS1S133DcBmu/XDlPc8548UYYWdbsHYQiWswI+knbPjrPb4BuOSIywfnwiKXgoSh11 neNKkVH8hQZjNgV7QKEeS97ATNhkO5NYSx/kKs1kwapoNRTUwnEZJVEekZGFJHjm2oVPT9RbJmi4 0PL+unGKCyBvhfDd6/fXP97vjj++3d7+fb778vft+zsVjOz4UCX1mZwIPsplqM6hTh52+t03bxjM ktTp0TVcj851O2tlFb4bLrqHUfjZ7fKSvkRnWZpIxyIX0pRBLnOYBcdxfOnaKtb8mU4MzbEtYnQo qXqlya+5WZ8qYfeO0q4pK/OhAWOTkvoYa9MCkjp8CZ0lpDNIieul4nV1RV5GCgO/7qC9emC85V3G Ks08TBCHYpUFJ4p3TP2dZFnH812q7ysUstl6kofnZHQe5Kh3TWGUV+9aqwYlbB8XBhU/FFNn3ZFq 2JHhFqTs6v0pzUjv1O1vaQPawthHY8IBafAtPT2KDxV8CxilSQNbHdJ2oxqdg08Uu+eRqH9l9Lhd NxlZahrDys3ivspEqdIKhOPjfTVcg5RwcWjMK2+ICqSBwtzxTB+y94pi0SwWC6874wWBmTfMgVl5 MaklOzWgJWV2cWf4/tStOk8tmUWaOf4iqYJxkPyWNCeXdlVWXgP9Xj2pETNOU/JjutPU4J6EL6Cd QjTwHA1Na6DTk4QoMcorRQkU/ukzq8KZ3QbQe5gw7yQkF+gPhHRMuND5NmvLtcxY7Qrm7doqEw9U xJ08fD5gKJpUm0Fz2DAMM7r9rdOKmuEkVuvBsXo3EWgqBpQiiTRxVMyK+Lfb7XfY2qFjh7vm9vjn y+vz65cf0wm1y+BI2NSh8oxhA0SkqT3rXbdr1kQ/X4CefyvCaXT7OrlH05ymLjNzVETHJo7wyrO6 6NNgP5T2GV7OJnXOrKQ5WhwKr3G7tmlKO22Nicd8jX6FxUPst5xfo8ob+8JhguD/BB36U+c6SgY1 aMraa9oea4sUulwV+v6TRK2DTHEa/pIUgPDXT7BBSeJZAdEG7B+cJNUNTV1iGLU+a61fJAbLHAwZ ulNHjmanxl+fjkemvHofCq7oHiPOjw017w94Vtnl4AVMUxrk007YwlKReUZ/DmY02LEQ5N+pFv4D 0sexpFomV6ZjSweyHbnM+0gVb/kOVl0z3tNwcKPpiz2NCqxpsohFj9v5TdKuzHOgabCi1Ca7aQqs E1jPywb9rlt0dcXkrZhzaKkaQL8f52UFyVPywHnMpy59az44olfJKFO2EfBDhL8ty1Nb2Yzor7Fi qiNHuWnvM5k+1UgVD6NWIXXYqTDxNPBXS0cOCAbUQbPOo9oiKUgUR8lmsaYxEeC6iypXyV5ecfKM W2GSF0Jk/tJsaOjDC6/SQjXKi55fH/+6469/vz3e7IN7yCA5N3i1HSh7dvGz0439gHMHM7rBGV9A 8dmNIQ6mR1VUqaMkgiK204McVRE93QzHiDvSt3MKvdCiF3+l6oI0mR7IANi3l9vb0+OdAO+qz19u wi5EscOdIkV8wKpM5KIk97gecGmdgqcODczC7UGzNMSdlCzK1C7q29fX99u3t9dH8rA4QVNwvNAm d8tEYpnpt6/fvxDXN1XOtYNjQRDzLnXALUA9noOkiePVg/CoVVfUjkuyKUcpQ321eo3TyuCka/iO IE8vv1+e3m72mfXk0AufERVaZIwRGrwoW8C99uBqog9eWYX72OHNkqwK9Pwv/Mf399vXu/LlLvrz 6duvd9/Rwu0PkJ5YN1JmX0FjAzI6rFQ/5mDmTcAygNDb6+ffH1+/uhKSuGAortV/Tw4x71/f0ntX Jh+xSkuq/8qvrgwsTIDJixg32dP7TaK7v5+e0fRq7CQiq59PJFLd//35GZrv7B8Sn74yqr7D97w+ PT+9/GNk1HP2dw3nqFVllkoxvmX4KemYtD08fEJFfahN//Pu8AqML69qZXqoO5Tn4QVqWcRJztSw MypTBRsLdAxX6HGhNBZc4B3xJFQ+tK3kFVMHl5YNzHHpOTEbYZl+T+01o4skV9xtDRkk/7w/vr70 Y13JZjKWEuwdg00MxrShbKZ6jjr9VBbanrpH9pyB5kBaaEkG/YyhJ47nEP5KdUKvoWIHRJQIuspy FWwoU52Jw/eDwMoX6JvNeuvTQLiygVFtMCtRNUWwJC9be4a6Cbcbn+oxngcBeQfc48NLCqsyAETU lkOFG/jXJ+Nb5LDiqRpwqh39pCXonfu9+sRqonXRjiTrN5Ma3bz+VFA08S8LfB5hFHbap3vBpZN7 80vc4hA1lH+q5mpKGotVlMpxSI8snsrCL1ZcqJ5M5jhVbRiHcrl6fLw9395ev97etXHL4mvmrxS5 7Am6rwZBVK3AeoLOtcvZUr92A8qKNJWELSuIqnmIqVL1rGPmqd41YuarTjXg49bxYmsQ1FM45Umb zN3XX4VhhzYDxK5kmMjTlcdbNZUgOJzznK7Rb6flYqmZseSR7/nkQMjZZqXODj3B9OuE5PWatmIA LFwF9CsSwLZBQAc4kRhlcZdfI/h6ms0LkNZeQPpfaU6hv1TdOABhx4KFur4aUigl8+UzqEp37693 vz99eXr//Izm27AqmHK6WWyXtSaoG2+rbf2Asl6su1TuW1kNGh7pyBv4tlv1MiNOO/jmuOYoe6MI Y84vdeLxqjlzUY/FNL6sibyVHmVGkMjtrEC2ikUcria+bq2Im+H10vEBo8pfeY4Pj64OmuQkLFfW C6wlyVewdkNbAcnlBmZ/rYFiV3D+D2XPtty2ruv7/gpPn86ZWZ36nvihD7Ik26p1iyQ7Tl40buI2 npXYObYzu91fvwFSF5AE3XVmVldrAKR4AUGQxAU3aTOAtsDlaRSUge1zLclaIzEIAK/Gxio2vS7/ RFwI6u5tj6tRIPMqZltTpFIDN0ZDa4a9xpyUfWen4+ECuu6zegowkNXZ4f0VtEY1DkfkDvsjZbG0 VFJBetm9CUdFaXOkaE1OEcIkpQvGU1eh8B+TioRKXX9Mhav8rYse181vLQwYOHeWi9/c9QZdPYOH gOkB6zC4Q4bJ3PN5OrBEJktzC2b9eDvh0wkYYyYNt/bPteEWSP4q9YMaEqXaLOQerZmXqOh2F27d eNn66S4d5c1rmhwJeQDN07pc06b2/GEgFXWg0CrkcdVUSF2+4mhg7q3kU17wjrrjoSpmRwNWuwbE cDjWSEeTAcuO3mhMQ+rg78lYbbuLlisO1QLy4ZAGEYrG/YFqTQtyctTj1HAQksObPtk+QB5A3aNR JaVr26RrYyJfiGBCnz/e3n5XJ0S6CsVgy/Mbk62xfgHSK6gy0O/+72N3ePrdyX8fLi+78/4/6Evn efmXNAybJCXiCk7cZ20vx9MXb3++nPbfP9CSivLKVTpp+/uyPe8+h0C2e+6Ex+N753/gO//b+dG0 40zaQev+/5Zscypf7aHCkj9/n47np+P7DobOkHXTaN5jY6/ONk7eh11bSXjewFTeIot4/pAlmj4Y patBd2SLYlqtKVkOlUVjuQkUPmvq6GI+qJ2DNI4zuyxF1W77enkhIr+Gni6dbHvZdaLjYX9RbhOc mT/UrJzx9NntsZp4hVLSX7PVEyRtkWzPx9v+eX/5zU2XE/VtEce8RcFeki88VL5ofBfP7Xct+vxi hRk6adr1RZH3+z39t77lLIpVn424GtxIpZf87itTZvS2ejoGMYG+sG+77fnjtHvbwZ7/AaOnMW/Q s4bHnW2S/FYJxlpD9MYvo82Ya3wQr8vAjYb9Ma2FQvWaEAfsPmbYXT8ehXk09nJ+o73Se+ktK3JB t+xRMwfaKjjU7NjxvsHUKsc7x1uBzkdzYDrhQGEH+I1hKpWtJ/XyyYBleYGa0NzgTn4z6NNPThe9 m5F6lAUIu+u5ERSlAZoRoO5KAOE97QExHqtB/uZp30m7XV6dl0joabfLxccJ7vIxMLoyno1WkIf9 SbenRjlUcGwYZIHq9RWlmR6mQ2tAIEmQZglZx99yB5NWtoAszbojulbrJjVZ68kBKhtZcnSGa+CG ocs1BcTbUM99W8EmbF1x4vQGFie1JC2Ao/g2pNCzfldHNzKk11OSEcDvoXasWQ4GFv8EWHqrdZD3 +UYVbj4Y9rjYpAKjJNioBreASdXc4QToluNRxNzQWgAwHNGQ2Kt81LvtKxvo2o1DHHbOClWgBkTC rv0oHHdVTzQJY7MMrMNxj55XHmFaYOgVPU4VN9JmdfvzsLvIqwdGEC1vJzf0dmHZnUwUiSDvpiJn HrNA46rGmYMQ49pPVgcW9AvMheRnUgWpS0fuYNQfUhkuZbD4FK901K3Q0Y3ZXuSOlAtlDaGFZ62Q WaS64ajwpte1SS83yHL4P14v+/fX3S9NnVTg1Ub69Lo/GBPFiZ8gduH83owfuz4IubxHLbOkEO9+ lo2M+br4fB3sofO5c75sD89wPDjsdPW/Sm9fnwot2qMwDctWaaGcHglBgVYwmI78DxUJkxbuCMo3 ttqKD6DfCX/F7eHnxyv8+/143uPZwFwXYksZlmllq9ssrz9XoSj078cLKAR75vp51KeyxcthaRMW xfPckOZ3wXNcl+bIQcBIjZhcpCFqtOz0WhrENhYGjvrwhFE66XV57V0tIk9Yp90ZNSFG1kzT7rgb zakcSfvqFQz+1q7AwwVIRPogmIKaxOvEZgzTtMvJ9sBNe92etjumYa83smiogASpRi+q89G4p4y+ hNjKA3JwY4iuur0MVB2EYjSk7LFI+92xInYfUweUrzE798aMtJrpYX/4qcgauo8oyGpuj7/2b3gE wCXwvMcl9sQeVoX+NGKVgjDw0Bg2KPxyTTl82tPUx5T3dMhm3s3NUElOlc2UiNmbicIg8HukiHIg JysJN+ZBVw2Svw5Hg7BrJAshQ3p1ICqrl/PxFcMJ2a74iYnLVUophXdv73iroa6sdrxRXnUdNCeN eCtlskx0mnoGws2kO+7RiyYBUWeliEBN5911BYq7hSpAXquutALS99jB5bpKFNWCt3ZcR74e0q/m I2pVBj/0oBoIMvxNEVg98PJVlt69qxeoZsFSIExz7asIUZ0qWyhj+Y1IEdhLfU+R2kN213l62b9z CfsMXCNwUsddqkmcpwmGCC+gUX1V/ckCB63OE1dJ1wOiyi9qm2wle7HETDM3yosp/nLNcphr4yF3 WzOJdPHQyT++n4W5Sbtz1LZLgKbjIWI9ziMEc2+tblQuk9hBsn5VtB7IxUOZbpyyfxtH5SJXXfkU JJblzz1A5cJkpHrMR4VCvpRhG30t4mErSpQuNy1EMxbXod4C0rTfSUPtYaFFEJgX+lVIIGWPcqcG 46S7EwZDEPLrTd56cTx0jayZVGrWCT9Kl+aDqQB6TBwYvqH6qzZELO8zGTWbTviwXAqTd/TSZSZd lo8cJaqNc3g+HffPRBOJvSxRA6RWoHIaoLMaGrRbHsZkVeQQHkzjtRdEvIm853DGnnUMIPpTl0oV EN8Cc89pIgYt7juX0/ZJbM26M0ZeKOICfkozdcwJGrCpdBoK+HhZ6IWZy3yCzZNVBqcKgORJyL6C tURMEDaCnRWZYohVZTlemBBVWDZQPWF8g+CTCjTonP1GlK/YytLC7gkJ6HYLqe9Lzalqa8XUpNxO 6TfvVPBPzhCQghtpEZUJjc4OKwQndB3Abq9I9zyg11L4C6W/ZuOUh0Gk+50CSD5Ou0XG2RaIk50r vYuUK8BkhRj+kT7JC3aRaVZy8qFo/wragBCS1ILQddyFSJvtVSHgFC3OQV0T9EyQJamT5exxEnBB ElFJ62+KfjnTTc0QVG6couAqAfygpKu3AuABMthA00KtNoHMfXeVafHqWpKhXuFQr1BD1dVpGE3e ClgrQ8knvk29vvpLLwsfiaZiyGl3Mj+AoQWcJerdNztqY6DqHX+W63OQuBLGbfWF/Dwlr2HtiF0p iCk5QBNCLp5nWhzHhiZbxWXuwMA9lLYYEZJWGzUJdHIYpIKv2J+Va1BwZhwnxEFojsWsbx9TbAC7 69i4B90LdHaXMBkTGWQL11cMwCEcKxRnfjTexSCvDzqets+P3ewhNe+iWgocDnZhzHLdV8nTAYEE CBNfwruOTne3Sgrl7UQAMMaAMPtv/Bg5dT4DbEV/72Sx1kWJsAV6vJtFRblWjkMSxNkhiarcQpEf zqpIZvmQXwsSqciOGYyEAnCVDBpV8AdKkKwxEfuDBYYpNIIMfT29ILtOUGVQn8HhgHoyE1LUtxT/ GYLbwFSKDjH9JGSRD0OUpE2YBnf79LJTjsezXEgt3lZGUkty73OWRF+8tSc2nHa/IRcbyWQ87vJj v/Jm9UKtK+crlPduSf5l5hRf/A3+Py5sn4xyoLSt9jWU5RsjqtX2EITUbjxBgk4xcAz7+unj8uO2 iVsZFxr7CIBxQBbQ7J7fwK/1TJ46zruP52Pnh9LjZnElrtIAAVjqQY0EdB1ZTLAEFg+XRahVlDoY 2iYBOU6twQTKXQShl/mxXgJzPWDE/7xwipXeMDddieMtKEYtZulnMe2CptwXUWr85ISzRAitQwfC 0vB81UJpsZqD7Jqy3ACHiZlXupmv+Jg3eQzmwRwd0OXoEEEh/mr31vowaM5e850gl7GZpFc8lR8Z BhUy9mnHs+kAzkxjxIVRGCAyFQi7GZsfEyBDLrdoW1PMmtzMiVjS/G7l5AuVuIbJPdEQRSyVFKBs LRgkOEpLTAvFH7w0QhFk4FpNMgpBChq8GuraLGAowCbJI5yIr1OEj2xKyRadsI3dPF4r9ZgXNHdd DR5i6oj1VLi8PvpsvX409T3P5+JjtVOSOfPIhz1fHjhEXQMiha2KbBTEsKiVfTQy2Ti1q3N38WZo qxxwY22NVCA98HD7UQWCnurozfGg58OQ6CTW4dItX//d7ClL9ImcPoB6/LXX7Q+7JlmI5zFkOvXp oyKAqb+GHFJkuxE06IXbEPBXcpLydtj/R3TIUiyhSmZtsN7depjYxicG2bWm0bHg6PkWNg349Lz7 8bq97D4ZFbvmdY5Ogo6v9m81lzl6MRCY9lKPSWxy1TQ0OA9h+AdjKHz6xOAEB4rlOR4y6MjZwGaN oV5abyOClo3Xy8NWtlYWz8pYwRIibyzZsVtd3Xj8LLFLADiQ3CfZku6q3DmRWj/Bj3au9+fj7e1o 8rlHZhsJMNK8UIaGan5dnohPwquSUEsSBXOrGpVpODbzjUpir/jGhhlf+eSYN2bSiPibf42Ie1/W SIZXGsJ5xmgkY2sPJxbMZDC2fnLCukpqxfu2iocTe19uuF0dSeDMhAxY3lpq7fVpnmYd1dO/KAJa Wqem/ph9hmsKG9vV+IH+4Rrxp36ObAW53NIUr/FyDZ7w4N7AAh9a4Ea7lklwW3L3mQ1ypVaFoWJB NaB52Gqw62N2KQ4eF/4qS/RvC1yWOEXAhnprSB6yIAy5iueOz8Mzn6barMEBNFBxLG8Q8SoouNaJ jl5vXbHKlkG+UCtdFTPF3NQLuY1vFQfI5WRTkYAyRg/3MHgUtlpNRFp6/FLuwqUHze7p44TmCG2s 3ObzmAuY18er+2IMk5qLJ9kiC1xe7eCuqg2kZf8SC1mE/UNWDA0btFoJxpg5IjxSDCrpSkRfTR/q eBWJmkhUJ+NuCpNMXAPKRyZyNEArOFeUjGC8F36Y0ntCFo15aRZfP305f98fvnycd6e34/Pu88vu 9X13arSQWglux5U68YR59PUT+qc8H/99+Ov39m371+tx+/y+P/x13v7YQcP3z39hILSfOJF/fX// 8UnO7XJ3OuxeOy/b0/NOmOS0c/yvNlVdZ3/YoyH6/j/byium+m6AN/3QKXcJnBUriplAYUgBHGJL 8iGNdAaLi1BSrrS0o0bbu9F4eulMXH98k2TyHELt5UUQaPUlXMIiP3LTBx26oZc9EpTe6RAMPj2G heAmSoSuh1SE+pKL6vT7/XLsPB1Pu87x1JEsQIIQCWIY0bkSykcB902473gs0CTNl26QLijDagiz yMKhEooATdKMXuW3MJaQnGa0hltb4tgav0xTk3pJnzTrGvAoY5K2MZBZuFlAfRtQqTGtmJBW2vtY RTWf9fq3SiadChGvQh6oOkVIeCr+ZlZahRd/MUyxKhZ+7DIVWgwiau4IIrOyebjCp3kh4DbCK1He zX58f90/ff5797vzJLj952n7/vLbYPIsd4wqPZPTfNdlYCxh5uUO07U84lS1eqBW2drvj0a9CVOy RWIHDdsX5+PygvarT3AUfu74B9FdNOb99/7y0nHO5+PTXqC87WVr9N91I3NIGZi7cOC/fjdNwgf0 sWBW+jzAtCFMB2oU/COPgzLP/StDkft3gSG4YFgXDojvdT29U+EkiRvY2ezSlGMtd8Zlta2RhbmQ XGbZ+O6UqTpUXxBUZDKbGtWksokqcMN8D9Se+8wxJUi8sM5DixIDfQ3vrDfcqnYwaHix4vS9ehgw rlA9FYvt+cU2E5Fj9nPBATf8pK21hA+1qffufDE/lrmDvlmzBDehxgy2QDSr8VECmLEQpKV9RDYb doOahs7S75sMIOHmfFfwSpAZDSl6XS+Y2TFVM80FzTbOykINg2A8dvXgX28yHnd8bJBmlVEAC1iE qTVnKIs8Xm4ggnUWbvH9kTlQAB5Qh8NasCycHvMRBMNKyX3Wx6+hgQ9JKq7eUa9vR3JNlGU4MFNF xMAKUGGnyZzpTzHPepOrHH2fwrevEQh2KQUrlXEgl46xCt39+4saurIW9iZbA6xUH28IgvuCviqS +1nALi+JMMI86HgrI2NiUDiZc1ZsGsWf66i2N5CqFe1VsWIU6jOl9DKY2YHvKuJGbOMAbmmTSclI HYSS8qayxMw3wAal7/m2MjPxt8nVTpg7zMqtdQ+uexXqj70DVTmVIbUMASAxYrf8p9VcGxBC0rfS RCasuE9YJq/gtomv0ZYvqehycK9k5VFplE7JRX58e0fHG+Uw3kyyeBgyapMvnyrsdmgKu/DRbK14 /jKg1auodEjZHp6Pb5344+377lRHyeCah5mBSzflDoNeNp3XuVkYDKugSAy3jQoMp0AiwgB+CzA3 sI+uBqk5E3iiK7lDd43gm9BgycFaZ/OGJmMdknSq6jRvrcWPxekymeJDm+W5qNmsHNXOkN5BvO6/ n7an353T8eOyPzA6ZBhM2T1FwDPX5KHKHGTtCxKbpkVwXCokk8o+Zkgk5RCpyUbCo9oT3tUa6CnR RHOSGOGNOpeJJ8Fe7+qAWbVCpaprzbxawx/PkUhk0ZoW98wUYeTy1PHwZs0+RUjkFJEemdDAcsf8 FovN6g6Z+wKgcLV44gqm9Di7DEJz55i7YQUvvcXtZPTL0jAkcDHxoR07VlNna+ghnzTR0oa1efhQ WnEND+2woN2FH+ZqLi+ClZad1wQMUuXOzN+4Pp8dh85kFCbzwC3nG0alxTAoP8RFyrnzA32D9j8P 0oXv6WX39Pf+8FMJ1PQPyOveToPYyR6kye2s3stCq+yTd7jibre1UK9g5dSPXdijMo7fwyD2nawU VmrUlsPRLJynAZwgMLMa2b9rBzU4XMRu+lDOsiTS7hgpSejHFmzsFyKRRm6iZkHswf8yUGSnAeX5 JPOoOIGBivwyXkVTaGMLzsS7C/XBa7zq3EB3gahRGliIOzQmdqN04y7mwrw782caBRoUzlDhFnZl aRjQnjZ15A8RaBpxFZRAkb8urHzY7BVQb6xSmAd6aG6xKtVSg772U31QUzFh4PrTBz5brULCa7mC wMnuHdVpTSJgyvhCquLpaqcklzO6ADlv3ti45HW9uVIhKyD2koh0n6mWmkW1dSFUmgmqcDTzg9On psg+yt1Ug/JmXQjlatbsvFooMe9Sqdn2UeMtDczRbx4RrP+urpNahxUJFe6ZKedSVxEESlLYCujQ 3CYtrFjAWjUQeQorxYBO3W9McywT2naznD8GZB0TRPioZGZtEZtHC33CwlXzSy3ZgBJ2E+9f2p/C y2LthKUKRhECwod6SUoQOqaUilBCuJ5eFl1WWkAsslNJBIjeOfX6EziRXddJhbqtW0eLfMCel5UF HO4UwZvf18kt26d+JAYV3+b6UX+o2YdIbfNQDhcZG5F2Q3+glq5KeTCPnWKlpJZJV5GTLzEjq3jv VTBlpgyad0c3gjCZqr+olKwHKlSt0N3wER/1SWuzO9RfSb1RGoA4IB8NIuU3+ttiIp5cyQck1Oma gdZenphsNfcLDDeTzDx6JKdlRBqXku4qswQvKppkKhR6+4tuLgKETicynxmdIegfzTzWbHYpuuoq Z88GtZJuieUsXOWL2nVOJxKGDjSbVe1t4C7vHWoEKUCenya0WcCUytyiGUc8Zy1HDLVJtTCo9TQB fT/tD5e/ZYCLt935p5mHWahkSzHUdBFUYBfjUHPGRa40MQXlYR6CIhU2D8k3Voq7VeAXXxuDzCox sVnDkNjyJ0lRN8XzQ4c3XfEeYicK3CummQqFLdMb6DLTBHSD0s8yIFeSSmAx+LPGFKi5khTPOsLN BdL+dff5sn+rtOKzIH2S8JM5H/JbsCcn+vcRhk5ZK1fN5kmwtST3+XBShDIHjY63EiJE3r2Tzfhr 3LkH8sXNgpR1oaxuR6IVXtiiqCMrM4OhFf52X297kz4xQAKOT0snRyf6iDdCynzHExUDFWd8BGhM RyAyMVIZJruUgyBAa6woyCOncMn+oWNE88okDh/0OmaJ8HVfxbKAEwYY0oy+cEkrncprOVCji9M6 7n1nKRInGO4a9fHqn7LOv2hKqUoMeLvvHz9/ooVOcDhfTh9vakr3yMEzYP6QZ8R8hgAb6yA5kV+7 v3ptLyidDCnCqi2iq7kxgLnYIO9LOUH60OTCbkMQROh1foVDm5rQIspmiiZk8BKYlX4Lf3OuSo24 n+ZO5SUcPPp6SwX2+vfc3FGsqv7R5KjjhL5nPjNC6JplHNwrq62mXiLdUcL6mwJDlHO8iHihsHBW /Vg2uY/V61QBTZMAE63GFmnbVI1e0VbmyBJYIU2QD30SJM39RmcgCmkOv4W3imgiWPG7NJwNJdie Ik1+IZliyBWDcyswe/ZUKdC+7k+1yxR11o+gr4ANl7krIersDZBOYFzcBpa8ktb1/tvcj+bhavrf yo5lN24b+Cs+tkBhJG1hpIceZEm7q1ov62GtTwsjWQRFkcSo7SKf33mQEjkc0s5pF5wRRVLDeXNo UT3aIUDg1nb3gSFiUKlq4HPhSC0kQT/MSGfUETRhDWKlMDhlW0gpI8jorjn1e8pelYt614QtlHYh CySswEE/GOe8CAznfZy8tLHI4VbDNGfK7jeAaN98KRElesppGVGDlssoXmwU6hG+Cpg1aOzVRkix Shp8uxArzQ+zMZMXcG4AXG3fZMpzWguGhp52huIOQQ257TZGDRae5w4QL5YdbgKBAN2MNQM0YmN4 1dbeHUzcylbae9mZmZRKKoyhl0BakRBgMJuumOVpLj9fd+P8QuU5VMN2iRsiXXTfHp9+ucAS+C+P rFAcHr5+dg2CDG/QBuWm8+xvrxn1m7ncOAUDyZybpz/fOZyi203oX5yR7U7AbdT7PTAT3GCxYYw9 wcI2HvU5WFpfDpUi8HTA68wnsKVVpOUWlDxQ9YpOl2G0/Pw2deHTi8n5/KC0fXpBTU0RzMy/xAlP bvR1f2ojXutqFFrf/qfHJbwpy57d3uxvx5zBTfn46enx76+YRwhT+PLyfP5+hj/n54+Xl5c/O5VD sXgIdbkng1Qa3/3Q3aklQhgwZAt30cKC6rUgCYwzlCwLnUTzVB7LQEw6l8r6/E9HXxaGgODqFjoF IN+0jN4xd26lgQnehG1gu4dc0QCirBmvz0a1uS5jT+PyUhDbKBiaCKEhAeGj04g1py8OTa/TVPzD 25bMd14PmnE/FvymJaumlUg3B8QP0JHtks9kAjci4bitp99+ahvH/0KsNTiJSrYZfJXT3I5lWcCG Yb94QirfsKbzOgboq6CVjGWgYfN2/4f1908Pzw8XqLh/xGBXYLvXlaYc9tgcpY5xL4mPCt1UnorI itiJtGbQbbEGc+Uf30gO0+8/H2Dt2qnigvucW5LPqg3BG9m9dH5tspO1X9OnTGu2Ax5WjtTaY7SM MCyptD2nrB0ioU5D5v4qfn5973dDFBR5urxVqqLQeOkY1WlP5Am6U9XpdU79NRNs59YoSAOpXiFN cGUmMM8wNKuTJ07PXJ3Onm1bp1NjDgBu8/upc6vIYcLKtpFC/t1SnW4AOW5h0tBWJ0caCivUH3Qc 63WTpQEV4GmppgP6kcc3oJmyROibfAt6NgS9GnBDFhKdFRoKgYJlZ4iqEBPs3XYKOsEsJunzzk1v 3LXgcwMdXRerwUPJRekGFAbyfk66FJPwvVg2EgTS0AizzcNP4XRlHCbj4nqae7BWG+Akw60+1+B9 1uqWLzKIin8+4OHo1yXnvnlGO/kXkN/6tEp7GmuN0N/rpPcGqgtHA0wRT/drI2E7VS4YLDnox7ug ndXAcN6Hpc6m+HSbpurETG0pBKZlKXaBMbRgDR66kE4tYDUbfZq5BpELpGZmHJxJtO0mMwCLk9AD pe7WxaINmJtCF9LpvHqGLq9L3gHKd5LtOnZk12+a0X0L35mfUgd6AGFnLyzQtDPun7dpWLh3213J FBZ3vyohRvsOsL7RDsd19qiR4Tw5/JmHMVqiz1DHlIEM7uOmqDuiH0Jea3fSXi/KGswx9aGVdOP9 OmyKIkExnQBVk6ooT90hr97/9gcXEjYOke1LZ3jRnVqvavPEUO3eyniZ/ZCL0Q4YJ1AWv3+40vQo oeoGbDJUhUOcMhvqexsRm0c34+DD1cmEp4i9zr3+VKSv4nofeYAqdB8L/3ySsTHrawqJameNKewt 7FuSkNu33ma35ULALDAhAcs3J60YvF6RyODdUb3ZyoH7n24FzPGA4oojQwtSf6PwZDZkkXhV3isF JEUfpEQk4EQGqZXgJaOIiB9JshuC/ExofsrPMbcLF8ruBu/jru0cqyOWJcv/GvXXJ3U3ED2dn57R OkSnSP7tv/O/D5/P214g55fjSqMxGse8bPYDBNxWHmkHn6QjnqGkt0UsaGtXYZSXbuH5i4N/nvxq dDR1/dtyQuH16gOW6XLdRue1K6Cqx9pNxsAWDqMIJ4ToYy2g4AkCfLjJblAW3M4x4iGsqrO2Uxxn h46FCNgfjI3OpZjrjX84nz26I6gI3Z1hg73voAWAJipBjpMWyb4le6Zhfay+KSbdL8DuPRTnI3Cg OEpTtRhr0W/jIIzo89ebzQXbNyEwKZkqAafEp67uGlSGo/zQTcFKSFGODEVkJ/uorn5XY1xudYW0 1/pQHjHQllgzTm7hpCiddVq8Me917sj+ccCYOi2Bm8BrurHbuGba+F3Nc6UnTRD0mA1DRFgQHAvZ 7kBNiGMMmM1JYZ/EwmW+LPWhoEolaPkmQegwZVH+2YenghW8OOhFkCVaxDv6XQJYw2Y4dBRkvNO5 CCZGwzh11djvbVcNzZINiYXkmrEKWcAbgEnXhRRAQ2muMdBEDvemgoiFeICN+bip6FFPa1Mgnto3 jHUMeuXPEVddzL6h8jfRokHM2somB3MyuU0pbT6SJ2Q7SSNQrRmUYaq9RBi+Zwx6DLmLX35GVy2C GjWcCPc/j2n8/PNnAgA= --===============7700639269631873679==--