From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: multipart/mixed; boundary="===============4126326859864490354==" MIME-Version: 1.0 From: kernel test robot To: kbuild-all@lists.01.org Subject: [android-common:mirror-pa-android12-5.10-staging 1622/1718] drivers/usb/typec/tcpm/tcpm.c:4025:6: warning: this statement may fall through Date: Tue, 08 Dec 2020 10:46:53 +0800 Message-ID: <202012081048.0cDCLAp8-lkp@intel.com> List-Id: --===============4126326859864490354== Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Hi Badhri, FYI, the error/warning still remains. tree: https://android.googlesource.com/kernel/common mirror-pa-android12-= 5.10-staging head: 0927548be1b3d5699f9b9849f90bb711ca481a07 commit: dd5bb066956e7c347ba93db4b4e0b65a84c7b933 [1622/1718] FROMLIST: usb:= typec: tcpm: Honour pSnkStdby requirement during negotiation config: arm64-randconfig-r006-20201208 (attached as .config) compiler: aarch64-linux-gcc (GCC) 9.3.0 reproduce (this is a W=3D1 build): wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/= make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross git remote add android-common https://android.googlesource.com/kern= el/common git fetch --no-tags android-common mirror-pa-android12-5.10-staging git checkout dd5bb066956e7c347ba93db4b4e0b65a84c7b933 # save the attached .config to linux build tree COMPILER_INSTALL_PATH=3D$HOME/0day COMPILER=3Dgcc-9.3.0 make.cross = ARCH=3Darm64 = If you fix the issue, kindly add following tag as appropriate Reported-by: kernel test robot All warnings (new ones prefixed by >>): drivers/usb/typec/tcpm/tcpm.c: In function 'run_state_machine': >> drivers/usb/typec/tcpm/tcpm.c:4025:6: warning: this statement may fall t= hrough [-Wimplicit-fallthrough=3D] 4025 | if (port->psnkstdby_after_accept) | ^ drivers/usb/typec/tcpm/tcpm.c:4029:2: note: here 4029 | case SNK_TRANSITION_SINK_VBUS: | ^~~~ At top level: drivers/usb/typec/tcpm/tcpm.c:2072:39: warning: 'tcpm_altmode_ops' defin= ed but not used [-Wunused-const-variable=3D] 2072 | static const struct typec_altmode_ops tcpm_altmode_ops =3D { | ^~~~~~~~~~~~~~~~ vim +4025 drivers/usb/typec/tcpm/tcpm.c 3568 = 3569 static void run_state_machine(struct tcpm_port *port) 3570 { 3571 int ret; 3572 enum typec_pwr_opmode opmode; 3573 unsigned int msecs; 3574 enum tcpm_state upcoming_state; 3575 = 3576 port->enter_state =3D port->state; 3577 switch (port->state) { 3578 case TOGGLING: 3579 break; 3580 /* SRC states */ 3581 case SRC_UNATTACHED: 3582 if (!port->non_pd_role_swap) 3583 tcpm_swap_complete(port, -ENOTCONN); 3584 tcpm_src_detach(port); 3585 if (port->debouncing) { 3586 port->debouncing =3D false; 3587 if (port->tcpc->check_contaminant && 3588 port->tcpc->check_contaminant(port->tcpc)) { 3589 /* Contaminant detection would handle toggling */ 3590 tcpm_set_state(port, TOGGLING, 0); 3591 break; 3592 } 3593 } 3594 if (tcpm_start_toggling(port, tcpm_rp_cc(port))) { 3595 tcpm_set_state(port, TOGGLING, 0); 3596 break; 3597 } 3598 tcpm_set_cc(port, tcpm_rp_cc(port)); 3599 if (port->port_type =3D=3D TYPEC_PORT_DRP) 3600 tcpm_set_state(port, SNK_UNATTACHED, PD_T_DRP_SNK); 3601 break; 3602 case SRC_ATTACH_WAIT: 3603 port->debouncing =3D true; 3604 if (tcpm_port_is_debug(port)) 3605 tcpm_set_state(port, DEBUG_ACC_ATTACHED, 3606 PD_T_CC_DEBOUNCE); 3607 else if (tcpm_port_is_audio(port)) 3608 tcpm_set_state(port, AUDIO_ACC_ATTACHED, 3609 PD_T_CC_DEBOUNCE); 3610 else if (tcpm_port_is_source(port)) 3611 tcpm_set_state(port, 3612 tcpm_try_snk(port) ? SNK_TRY 3613 : SRC_ATTACHED, 3614 PD_T_CC_DEBOUNCE); 3615 break; 3616 = 3617 case SNK_TRY: 3618 port->debouncing =3D false; 3619 port->try_snk_count++; 3620 /* 3621 * Requirements: 3622 * - Do not drive vconn or vbus 3623 * - Terminate CC pins (both) to Rd 3624 * Action: 3625 * - Wait for tDRPTry (PD_T_DRP_TRY). 3626 * Until then, ignore any state changes. 3627 */ 3628 tcpm_set_cc(port, TYPEC_CC_RD); 3629 tcpm_set_state(port, SNK_TRY_WAIT, PD_T_DRP_TRY); 3630 break; 3631 case SNK_TRY_WAIT: 3632 if (tcpm_port_is_sink(port)) { 3633 tcpm_set_state(port, SNK_TRY_WAIT_DEBOUNCE, 0); 3634 } else { 3635 tcpm_set_state(port, SRC_TRYWAIT, 0); 3636 port->max_wait =3D 0; 3637 } 3638 break; 3639 case SNK_TRY_WAIT_DEBOUNCE: 3640 tcpm_set_state(port, SNK_TRY_WAIT_DEBOUNCE_CHECK_VBUS, 3641 PD_T_TRY_CC_DEBOUNCE); 3642 break; 3643 case SNK_TRY_WAIT_DEBOUNCE_CHECK_VBUS: 3644 if (port->vbus_present && tcpm_port_is_sink(port)) 3645 tcpm_set_state(port, SNK_ATTACHED, 0); 3646 else 3647 port->max_wait =3D 0; 3648 break; 3649 case SRC_TRYWAIT: 3650 tcpm_set_cc(port, tcpm_rp_cc(port)); 3651 if (port->max_wait =3D=3D 0) { 3652 port->max_wait =3D jiffies + 3653 msecs_to_jiffies(PD_T_DRP_TRY); 3654 tcpm_set_state(port, SRC_TRYWAIT_UNATTACHED, 3655 PD_T_DRP_TRY); 3656 } else { 3657 if (time_is_after_jiffies(port->max_wait)) 3658 tcpm_set_state(port, SRC_TRYWAIT_UNATTACHED, 3659 jiffies_to_msecs(port->max_wait - 3660 jiffies)); 3661 else 3662 tcpm_set_state(port, SNK_UNATTACHED, 0); 3663 } 3664 break; 3665 case SRC_TRYWAIT_DEBOUNCE: 3666 tcpm_set_state(port, SRC_ATTACHED, PD_T_CC_DEBOUNCE); 3667 break; 3668 case SRC_TRYWAIT_UNATTACHED: 3669 tcpm_set_state(port, SNK_UNATTACHED, 0); 3670 break; 3671 = 3672 case SRC_ATTACHED: 3673 ret =3D tcpm_src_attach(port); 3674 tcpm_set_state(port, SRC_UNATTACHED, 3675 ret < 0 ? 0 : PD_T_PS_SOURCE_ON); 3676 break; 3677 case SRC_STARTUP: 3678 opmode =3D tcpm_get_pwr_opmode(tcpm_rp_cc(port)); 3679 typec_set_pwr_opmode(port->typec_port, opmode); 3680 port->pwr_opmode =3D TYPEC_PWR_MODE_USB; 3681 port->caps_count =3D 0; 3682 port->negotiated_rev =3D PD_MAX_REV; 3683 port->svdm_version =3D SVDM_MAX_VER; 3684 port->message_id =3D 0; 3685 port->rx_msgid =3D -1; 3686 port->explicit_contract =3D false; 3687 /* SNK -> SRC POWER/FAST_ROLE_SWAP finished */ 3688 if (port->ams =3D=3D POWER_ROLE_SWAP || 3689 port->ams =3D=3D FAST_ROLE_SWAP) 3690 tcpm_ams_finish(port); 3691 port->upcoming_state =3D SRC_SEND_CAPABILITIES; 3692 tcpm_ams_start(port, POWER_NEGOTIATION); 3693 break; 3694 case SRC_SEND_CAPABILITIES: 3695 port->caps_count++; 3696 if (port->caps_count > PD_N_CAPS_COUNT) { 3697 tcpm_set_state(port, SRC_READY, 0); 3698 break; 3699 } 3700 ret =3D tcpm_pd_send_source_caps(port); 3701 if (ret < 0) { 3702 tcpm_set_state(port, SRC_SEND_CAPABILITIES, 3703 PD_T_SEND_SOURCE_CAP); 3704 } else { 3705 /* 3706 * Per standard, we should clear the reset counter here. 3707 * However, that can result in state machine hang-ups. 3708 * Reset it only in READY state to improve stability. 3709 */ 3710 /* port->hard_reset_count =3D 0; */ 3711 port->caps_count =3D 0; 3712 = 3713 tcpm_set_pd_capable(port, true); 3714 tcpm_set_state_cond(port, SRC_SEND_CAPABILITIES_TIMEOUT, 3715 PD_T_SEND_SOURCE_CAP); 3716 } 3717 break; 3718 case SRC_SEND_CAPABILITIES_TIMEOUT: 3719 /* 3720 * Error recovery for a PD_DATA_SOURCE_CAP reply timeout. 3721 * 3722 * PD 2.0 sinks are supposed to accept src-capabilities with a 3723 * 3.0 header and simply ignore any src PDOs which the sink does 3724 * not understand such as PPS but some 2.0 sinks instead ignore 3725 * the entire PD_DATA_SOURCE_CAP message, causing contract 3726 * negotiation to fail. 3727 * 3728 * After PD_N_HARD_RESET_COUNT hard-reset attempts, we try 3729 * sending src-capabilities with a lower PD revision to 3730 * make these broken sinks work. 3731 */ 3732 if (port->hard_reset_count < PD_N_HARD_RESET_COUNT) { 3733 tcpm_set_state(port, HARD_RESET_SEND, 0); 3734 } else if (port->negotiated_rev > PD_REV20) { 3735 port->negotiated_rev--; 3736 port->hard_reset_count =3D 0; 3737 tcpm_set_state(port, SRC_SEND_CAPABILITIES, 0); 3738 } else { 3739 tcpm_set_state(port, hard_reset_state(port), 0); 3740 } 3741 break; 3742 case SRC_NEGOTIATE_CAPABILITIES: 3743 ret =3D tcpm_pd_check_request(port); 3744 if (ret < 0) { 3745 tcpm_pd_send_control(port, PD_CTRL_REJECT); 3746 if (!port->explicit_contract) { 3747 tcpm_set_state(port, 3748 SRC_WAIT_NEW_CAPABILITIES, 0); 3749 } else { 3750 tcpm_set_state(port, SRC_READY, 0); 3751 } 3752 } else { 3753 tcpm_pd_send_control(port, PD_CTRL_ACCEPT); 3754 port->usb_comm_capable =3D port->sink_request & 3755 RDO_USB_COMM; 3756 /* Notify TCPC of usb_comm_capable. */ 3757 tcpm_set_attached_state(port, true); 3758 tcpm_set_state(port, SRC_TRANSITION_SUPPLY, 3759 PD_T_SRC_TRANSITION); 3760 } 3761 break; 3762 case SRC_TRANSITION_SUPPLY: 3763 /* XXX: regulator_set_voltage(vbus, ...) */ 3764 tcpm_pd_send_control(port, PD_CTRL_PS_RDY); 3765 port->explicit_contract =3D true; 3766 typec_set_pwr_opmode(port->typec_port, TYPEC_PWR_MODE_PD); 3767 port->pwr_opmode =3D TYPEC_PWR_MODE_PD; 3768 tcpm_set_state_cond(port, SRC_READY, 0); 3769 break; 3770 case SRC_READY: 3771 #if 1 3772 port->hard_reset_count =3D 0; 3773 #endif 3774 port->try_src_count =3D 0; 3775 = 3776 tcpm_swap_complete(port, 0); 3777 tcpm_typec_connect(port); 3778 = 3779 if (port->ams !=3D NONE_AMS) 3780 tcpm_ams_finish(port); 3781 if (port->next_ams !=3D NONE_AMS) { 3782 port->ams =3D port->next_ams; 3783 port->next_ams =3D NONE_AMS; 3784 } 3785 = 3786 /* 3787 * If previous AMS is interrupted, switch to the upcoming 3788 * state. 3789 */ 3790 upcoming_state =3D port->upcoming_state; 3791 if (port->upcoming_state !=3D INVALID_STATE) { 3792 port->upcoming_state =3D INVALID_STATE; 3793 tcpm_set_state(port, upcoming_state, 0); 3794 break; 3795 } 3796 tcpm_check_send_discover(port); 3797 /* 3798 * 6.3.5 3799 * Sending ping messages is not necessary if 3800 * - the source operates at vSafe5V 3801 * or 3802 * - The system is not operating in PD mode 3803 * or 3804 * - Both partners are connected using a Type-C connector 3805 * 3806 * There is no actual need to send PD messages since the local 3807 * port type-c and the spec does not clearly say whether PD is 3808 * possible when type-c is connected to Type-A/B 3809 */ 3810 break; 3811 case SRC_WAIT_NEW_CAPABILITIES: 3812 /* Nothing to do... */ 3813 break; 3814 = 3815 /* SNK states */ 3816 case SNK_UNATTACHED: 3817 if (!port->non_pd_role_swap) 3818 tcpm_swap_complete(port, -ENOTCONN); 3819 tcpm_pps_complete(port, -ENOTCONN); 3820 tcpm_snk_detach(port); 3821 if (port->debouncing) { 3822 port->debouncing =3D false; 3823 if (port->tcpc->check_contaminant && 3824 port->tcpc->check_contaminant(port->tcpc)) { 3825 /* Contaminant detection would handle toggling */ 3826 tcpm_set_state(port, TOGGLING, 0); 3827 break; 3828 } 3829 } 3830 if (tcpm_start_toggling(port, TYPEC_CC_RD)) { 3831 tcpm_set_state(port, TOGGLING, 0); 3832 break; 3833 } 3834 tcpm_set_cc(port, TYPEC_CC_RD); 3835 if (port->port_type =3D=3D TYPEC_PORT_DRP) 3836 tcpm_set_state(port, SRC_UNATTACHED, PD_T_DRP_SRC); 3837 break; 3838 case SNK_ATTACH_WAIT: 3839 port->debouncing =3D true; 3840 if ((port->cc1 =3D=3D TYPEC_CC_OPEN && 3841 port->cc2 !=3D TYPEC_CC_OPEN) || 3842 (port->cc1 !=3D TYPEC_CC_OPEN && 3843 port->cc2 =3D=3D TYPEC_CC_OPEN)) 3844 tcpm_set_state(port, SNK_DEBOUNCED, 3845 PD_T_CC_DEBOUNCE); 3846 else if (tcpm_port_is_disconnected(port)) 3847 tcpm_set_state(port, SNK_UNATTACHED, 3848 PD_T_PD_DEBOUNCE); 3849 break; 3850 case SNK_DEBOUNCED: 3851 if (tcpm_port_is_disconnected(port)) { 3852 tcpm_set_state(port, SNK_UNATTACHED, 3853 PD_T_PD_DEBOUNCE); 3854 } else if (port->vbus_present) { 3855 tcpm_set_state(port, 3856 tcpm_try_src(port) ? SRC_TRY 3857 : SNK_ATTACHED, 3858 0); 3859 port->debouncing =3D false; 3860 } else { 3861 /* Wait for VBUS, but not forever */ 3862 tcpm_set_state(port, PORT_RESET, PD_T_PS_SOURCE_ON); 3863 port->debouncing =3D false; 3864 } 3865 break; 3866 = 3867 case SRC_TRY: 3868 port->try_src_count++; 3869 tcpm_set_cc(port, tcpm_rp_cc(port)); 3870 port->max_wait =3D 0; 3871 tcpm_set_state(port, SRC_TRY_WAIT, 0); 3872 break; 3873 case SRC_TRY_WAIT: 3874 if (port->max_wait =3D=3D 0) { 3875 port->max_wait =3D jiffies + 3876 msecs_to_jiffies(PD_T_DRP_TRY); 3877 msecs =3D PD_T_DRP_TRY; 3878 } else { 3879 if (time_is_after_jiffies(port->max_wait)) 3880 msecs =3D jiffies_to_msecs(port->max_wait - 3881 jiffies); 3882 else 3883 msecs =3D 0; 3884 } 3885 tcpm_set_state(port, SNK_TRYWAIT, msecs); 3886 break; 3887 case SRC_TRY_DEBOUNCE: 3888 tcpm_set_state(port, SRC_ATTACHED, PD_T_PD_DEBOUNCE); 3889 break; 3890 case SNK_TRYWAIT: 3891 tcpm_set_cc(port, TYPEC_CC_RD); 3892 tcpm_set_state(port, SNK_TRYWAIT_VBUS, PD_T_CC_DEBOUNCE); 3893 break; 3894 case SNK_TRYWAIT_VBUS: 3895 /* 3896 * TCPM stays in this state indefinitely until VBUS 3897 * is detected as long as Rp is not detected for 3898 * more than a time period of tPDDebounce. 3899 */ 3900 if (port->vbus_present && tcpm_port_is_sink(port)) { 3901 tcpm_set_state(port, SNK_ATTACHED, 0); 3902 break; 3903 } 3904 if (!tcpm_port_is_sink(port)) 3905 tcpm_set_state(port, SNK_TRYWAIT_DEBOUNCE, 0); 3906 break; 3907 case SNK_TRYWAIT_DEBOUNCE: 3908 tcpm_set_state(port, SNK_UNATTACHED, PD_T_PD_DEBOUNCE); 3909 break; 3910 case SNK_ATTACHED: 3911 ret =3D tcpm_snk_attach(port); 3912 if (ret < 0) 3913 tcpm_set_state(port, SNK_UNATTACHED, 0); 3914 else 3915 tcpm_set_state(port, SNK_STARTUP, 0); 3916 break; 3917 case SNK_STARTUP: 3918 opmode =3D tcpm_get_pwr_opmode(port->polarity ? 3919 port->cc2 : port->cc1); 3920 typec_set_pwr_opmode(port->typec_port, opmode); 3921 port->pwr_opmode =3D TYPEC_PWR_MODE_USB; 3922 port->negotiated_rev =3D PD_MAX_REV; 3923 port->svdm_version =3D SVDM_MAX_VER; 3924 port->message_id =3D 0; 3925 port->rx_msgid =3D -1; 3926 port->explicit_contract =3D false; 3927 = 3928 if (port->ams =3D=3D POWER_ROLE_SWAP || 3929 port->ams =3D=3D FAST_ROLE_SWAP) 3930 /* SRC -> SNK POWER/FAST_ROLE_SWAP finished */ 3931 tcpm_ams_finish(port); 3932 = 3933 tcpm_set_state(port, SNK_DISCOVERY, 500); 3934 break; 3935 case SNK_DISCOVERY: 3936 if (port->vbus_present) { 3937 if (port->psnkstdby_after_accept || tcpm_get_current_limit(port) = <=3D 3938 PD_P_SNK_STDBY_5V) 3939 tcpm_set_current_limit(port, tcpm_get_current_limit(port), 5000); 3940 else 3941 tcpm_set_current_limit(port, PD_P_SNK_STDBY_5V, 5000); 3942 tcpm_set_charge(port, true); 3943 tcpm_set_state(port, SNK_WAIT_CAPABILITIES, 0); 3944 break; 3945 } 3946 /* 3947 * For DRP, timeouts differ. Also, handling is supposed to be 3948 * different and much more complex (dead battery detection; 3949 * see USB power delivery specification, section 8.3.3.6.1.5.1). 3950 */ 3951 tcpm_set_state(port, hard_reset_state(port), 3952 port->port_type =3D=3D TYPEC_PORT_DRP ? 3953 PD_T_DB_DETECT : PD_T_NO_RESPONSE); 3954 break; 3955 case SNK_DISCOVERY_DEBOUNCE: 3956 tcpm_set_state(port, SNK_DISCOVERY_DEBOUNCE_DONE, 3957 PD_T_CC_DEBOUNCE); 3958 break; 3959 case SNK_DISCOVERY_DEBOUNCE_DONE: 3960 if (!tcpm_port_is_disconnected(port) && 3961 tcpm_port_is_sink(port) && 3962 ktime_after(port->delayed_runtime, ktime_get())) { 3963 tcpm_set_state(port, SNK_DISCOVERY, 3964 ktime_to_ms(ktime_sub(port->delayed_runtime, ktime_get())= )); 3965 break; 3966 } 3967 tcpm_set_state(port, unattached_state(port), 0); 3968 break; 3969 case SNK_WAIT_CAPABILITIES: 3970 ret =3D port->tcpc->set_pd_rx(port->tcpc, true); 3971 if (ret < 0) { 3972 tcpm_set_state(port, SNK_READY, 0); 3973 break; 3974 } 3975 /* 3976 * If VBUS has never been low, and we time out waiting 3977 * for source cap, try a soft reset first, in case we 3978 * were already in a stable contract before this boot. 3979 * Do this only once. 3980 */ 3981 if (port->vbus_never_low) { 3982 port->vbus_never_low =3D false; 3983 tcpm_set_state(port, SNK_SOFT_RESET, 3984 PD_T_SINK_WAIT_CAP); 3985 } else { 3986 tcpm_set_state(port, hard_reset_state(port), 3987 PD_T_SINK_WAIT_CAP); 3988 } 3989 break; 3990 case SNK_NEGOTIATE_CAPABILITIES: 3991 tcpm_set_pd_capable(port, true); 3992 port->usb_comm_capable =3D port->source_caps[0] & 3993 PDO_FIXED_USB_COMM; 3994 /* Notify TCPC of usb_comm_capable. */ 3995 tcpm_set_attached_state(port, true); 3996 port->hard_reset_count =3D 0; 3997 ret =3D tcpm_pd_send_request(port); 3998 if (ret < 0) { 3999 /* Let the Source send capabilities again. */ 4000 tcpm_set_state(port, SNK_WAIT_CAPABILITIES, 0); 4001 } else { 4002 tcpm_set_state_cond(port, hard_reset_state(port), 4003 PD_T_SENDER_RESPONSE); 4004 } 4005 break; 4006 case SNK_NEGOTIATE_PPS_CAPABILITIES: 4007 ret =3D tcpm_pd_send_pps_request(port); 4008 if (ret < 0) { 4009 port->pps_status =3D ret; 4010 /* 4011 * If this was called due to updates to sink 4012 * capabilities, and pps is no longer valid, we should 4013 * safely fall back to a standard PDO. 4014 */ 4015 if (port->update_sink_caps) 4016 tcpm_set_state(port, SNK_NEGOTIATE_CAPABILITIES, 0); 4017 else 4018 tcpm_set_state(port, SNK_READY, 0); 4019 } else { 4020 tcpm_set_state_cond(port, hard_reset_state(port), 4021 PD_T_SENDER_RESPONSE); 4022 } 4023 break; 4024 case SNK_TRANSITION_SINK: > 4025 if (port->psnkstdby_after_accept) 4026 tcpm_set_current_limit(port, tcpm_get_current_limit(port) > 4027 PD_P_SNK_STDBY_5V ? PD_P_SNK_STDBY_5V : 4028 tcpm_get_current_limit(port), 5000); 4029 case SNK_TRANSITION_SINK_VBUS: 4030 tcpm_set_state(port, hard_reset_state(port), 4031 PD_T_PS_TRANSITION); 4032 break; 4033 case SNK_READY: 4034 port->try_snk_count =3D 0; 4035 port->update_sink_caps =3D false; 4036 if (port->explicit_contract) { 4037 typec_set_pwr_opmode(port->typec_port, 4038 TYPEC_PWR_MODE_PD); 4039 port->pwr_opmode =3D TYPEC_PWR_MODE_PD; 4040 } 4041 = 4042 /* Set current limit for NON-PD link when psnkstdby_after_accept i= s not set*/ 4043 if (!port->pd_capable && !port->psnkstdby_after_accept) 4044 tcpm_set_current_limit(port, tcpm_get_current_limit(port), 5000); 4045 = 4046 tcpm_swap_complete(port, 0); 4047 tcpm_typec_connect(port); 4048 tcpm_pps_complete(port, port->pps_status); 4049 = 4050 if (port->ams !=3D NONE_AMS) 4051 tcpm_ams_finish(port); 4052 if (port->next_ams !=3D NONE_AMS) { 4053 port->ams =3D port->next_ams; 4054 port->next_ams =3D NONE_AMS; 4055 } 4056 = 4057 /* 4058 * If previous AMS is interrupted, switch to the upcoming 4059 * state. 4060 */ 4061 upcoming_state =3D port->upcoming_state; 4062 if (port->upcoming_state !=3D INVALID_STATE) { 4063 port->upcoming_state =3D INVALID_STATE; 4064 tcpm_set_state(port, upcoming_state, 0); 4065 break; 4066 } 4067 tcpm_check_send_discover(port); 4068 power_supply_changed(port->psy); 4069 = 4070 break; 4071 = 4072 /* Accessory states */ 4073 case ACC_UNATTACHED: 4074 tcpm_acc_detach(port); 4075 tcpm_set_state(port, SRC_UNATTACHED, 0); 4076 break; 4077 case DEBUG_ACC_ATTACHED: 4078 case AUDIO_ACC_ATTACHED: 4079 ret =3D tcpm_acc_attach(port); 4080 if (ret < 0) 4081 tcpm_set_state(port, ACC_UNATTACHED, 0); 4082 break; 4083 case AUDIO_ACC_DEBOUNCE: 4084 tcpm_set_state(port, ACC_UNATTACHED, PD_T_CC_DEBOUNCE); 4085 break; 4086 = 4087 /* Hard_Reset states */ 4088 case HARD_RESET_SEND: 4089 if (port->ams !=3D NONE_AMS) 4090 tcpm_ams_finish(port); 4091 /* 4092 * State machine will be directed to HARD_RESET_START, 4093 * thus set upcoming_state to INVALID_STATE. 4094 */ 4095 port->upcoming_state =3D INVALID_STATE; 4096 tcpm_ams_start(port, HARD_RESET); 4097 break; 4098 case HARD_RESET_START: 4099 port->hard_reset_count++; 4100 port->tcpc->set_pd_rx(port->tcpc, false); 4101 tcpm_unregister_altmodes(port); 4102 port->send_discover =3D true; 4103 port->usb_comm_capable =3D false; 4104 if (port->pwr_role =3D=3D TYPEC_SOURCE) 4105 tcpm_set_state(port, SRC_HARD_RESET_VBUS_OFF, 4106 PD_T_PS_HARD_RESET); 4107 else 4108 tcpm_set_state(port, SNK_HARD_RESET_SINK_OFF, 0); 4109 break; 4110 case SRC_HARD_RESET_VBUS_OFF: 4111 /* 4112 * 7.1.5 Response to Hard Resets 4113 * Hard Reset Signaling indicates a communication failure has occu= rred and the 4114 * Source Shall stop driving VCONN, Shall remove Rp from the VCONN= pin and Shall 4115 * drive VBUS to vSafe0V as shown in Figure 7-9. 4116 */ 4117 tcpm_set_vconn(port, false); 4118 tcpm_set_vbus(port, false); 4119 tcpm_set_roles(port, port->self_powered, TYPEC_SOURCE, 4120 tcpm_data_role_for_source(port)); 4121 /* 4122 * If tcpc fails to notify vbus off, TCPM will wait for PD_T_SAFE_= 0V + 4123 * PD_T_SRC_RECOVER before turning vbus back on. 4124 * From Table 7-12 Sequence Description for a Source Initiated Har= d Reset: 4125 * 4. Policy Engine waits tPSHardReset after sending Hard Reset Si= gnaling and then 4126 * tells the Device Policy Manager to instruct the power supply to= perform a 4127 * Hard Reset. The transition to vSafe0V Shall occur within tSafe0= V (t2). 4128 * 5. After tSrcRecover the Source applies power to VBUS in an att= empt to 4129 * re-establish communication with the Sink and resume USB Default= Operation. 4130 * The transition to vSafe5V Shall occur within tSrcTurnOn(t4). 4131 */ 4132 tcpm_set_state(port, SRC_HARD_RESET_VBUS_ON, PD_T_SAFE_0V + PD_T_S= RC_RECOVER); 4133 break; 4134 case SRC_HARD_RESET_VBUS_ON: 4135 tcpm_set_vconn(port, true); 4136 tcpm_set_vbus(port, true); 4137 if (port->ams =3D=3D HARD_RESET) 4138 tcpm_ams_finish(port); 4139 port->tcpc->set_pd_rx(port->tcpc, true); 4140 tcpm_set_attached_state(port, true); 4141 tcpm_set_state(port, SRC_UNATTACHED, PD_T_PS_SOURCE_ON); 4142 break; 4143 case SNK_HARD_RESET_SINK_OFF: 4144 memset(&port->pps_data, 0, sizeof(port->pps_data)); 4145 tcpm_set_vconn(port, false); 4146 if (port->pd_capable) 4147 tcpm_set_charge(port, false); 4148 tcpm_set_roles(port, port->self_powered, TYPEC_SINK, 4149 tcpm_data_role_for_sink(port)); 4150 /* 4151 * VBUS may or may not toggle, depending on the adapter. 4152 * If it doesn't toggle, transition to SNK_HARD_RESET_SINK_ON 4153 * directly after timeout. 4154 */ 4155 tcpm_set_state(port, SNK_HARD_RESET_SINK_ON, PD_T_SAFE_0V); 4156 break; 4157 case SNK_HARD_RESET_WAIT_VBUS: 4158 if (port->ams =3D=3D HARD_RESET) 4159 tcpm_ams_finish(port); 4160 /* Assume we're disconnected if VBUS doesn't come back. */ 4161 tcpm_set_state(port, SNK_UNATTACHED, 4162 PD_T_SRC_RECOVER_MAX + PD_T_SRC_TURN_ON); 4163 break; 4164 case SNK_HARD_RESET_SINK_ON: 4165 /* Note: There is no guarantee that VBUS is on in this state */ 4166 /* 4167 * XXX: 4168 * The specification suggests that dual mode ports in sink 4169 * mode should transition to state PE_SRC_Transition_to_default. 4170 * See USB power delivery specification chapter 8.3.3.6.1.3. 4171 * This would mean to to 4172 * - turn off VCONN, reset power supply 4173 * - request hardware reset 4174 * - turn on VCONN 4175 * - Transition to state PE_Src_Startup 4176 * SNK only ports shall transition to state Snk_Startup 4177 * (see chapter 8.3.3.3.8). 4178 * Similar, dual-mode ports in source mode should transition 4179 * to PE_SNK_Transition_to_default. 4180 */ 4181 if (port->pd_capable) { 4182 tcpm_set_current_limit(port, 4183 tcpm_get_current_limit(port), 4184 5000); 4185 tcpm_set_charge(port, true); 4186 } 4187 if (port->ams =3D=3D HARD_RESET) 4188 tcpm_ams_finish(port); 4189 tcpm_set_attached_state(port, true); 4190 tcpm_set_state(port, SNK_STARTUP, 0); 4191 break; 4192 = 4193 /* Soft_Reset states */ 4194 case SOFT_RESET: 4195 port->message_id =3D 0; 4196 port->rx_msgid =3D -1; 4197 tcpm_pd_send_control(port, PD_CTRL_ACCEPT); 4198 tcpm_ams_finish(port); 4199 if (port->pwr_role =3D=3D TYPEC_SOURCE) { 4200 port->upcoming_state =3D SRC_SEND_CAPABILITIES; 4201 tcpm_ams_start(port, POWER_NEGOTIATION); 4202 } else { 4203 tcpm_set_state(port, SNK_WAIT_CAPABILITIES, 0); 4204 } 4205 break; 4206 case SRC_SOFT_RESET_WAIT_SNK_TX: 4207 case SNK_SOFT_RESET: 4208 if (port->ams !=3D NONE_AMS) 4209 tcpm_ams_finish(port); 4210 port->upcoming_state =3D SOFT_RESET_SEND; 4211 tcpm_ams_start(port, SOFT_RESET_AMS); 4212 break; 4213 case SOFT_RESET_SEND: 4214 port->message_id =3D 0; 4215 port->rx_msgid =3D -1; 4216 if (tcpm_pd_send_control(port, PD_CTRL_SOFT_RESET)) 4217 tcpm_set_state_cond(port, hard_reset_state(port), 0); 4218 else 4219 tcpm_set_state_cond(port, hard_reset_state(port), 4220 PD_T_SENDER_RESPONSE); 4221 break; 4222 = 4223 /* DR_Swap states */ 4224 case DR_SWAP_SEND: 4225 tcpm_pd_send_control(port, PD_CTRL_DR_SWAP); 4226 tcpm_set_state_cond(port, DR_SWAP_SEND_TIMEOUT, 4227 PD_T_SENDER_RESPONSE); 4228 break; 4229 case DR_SWAP_ACCEPT: 4230 tcpm_pd_send_control(port, PD_CTRL_ACCEPT); 4231 /* Set VDM state machine running flag ASAP */ 4232 if (port->data_role =3D=3D TYPEC_DEVICE && port->send_discover) 4233 port->vdm_sm_running =3D true; 4234 tcpm_set_state_cond(port, DR_SWAP_CHANGE_DR, 0); 4235 break; 4236 case DR_SWAP_SEND_TIMEOUT: 4237 tcpm_swap_complete(port, -ETIMEDOUT); 4238 tcpm_ams_finish(port); 4239 tcpm_set_state(port, ready_state(port), 0); 4240 break; 4241 case DR_SWAP_CHANGE_DR: 4242 if (port->data_role =3D=3D TYPEC_HOST) { 4243 tcpm_unregister_altmodes(port); 4244 tcpm_set_roles(port, true, port->pwr_role, 4245 TYPEC_DEVICE); 4246 } else { 4247 tcpm_set_roles(port, true, port->pwr_role, 4248 TYPEC_HOST); 4249 port->send_discover =3D true; 4250 } 4251 tcpm_ams_finish(port); 4252 tcpm_set_state(port, ready_state(port), 0); 4253 break; 4254 = 4255 /* PR_Swap states */ 4256 case PR_SWAP_ACCEPT: 4257 tcpm_pd_send_control(port, PD_CTRL_ACCEPT); 4258 tcpm_set_state(port, PR_SWAP_START, 0); 4259 break; 4260 case PR_SWAP_SEND: 4261 tcpm_pd_send_control(port, PD_CTRL_PR_SWAP); 4262 tcpm_set_state_cond(port, PR_SWAP_SEND_TIMEOUT, 4263 PD_T_SENDER_RESPONSE); 4264 break; 4265 case PR_SWAP_SEND_TIMEOUT: 4266 tcpm_swap_complete(port, -ETIMEDOUT); 4267 tcpm_set_state(port, ready_state(port), 0); 4268 break; 4269 case PR_SWAP_START: 4270 if (port->pwr_role =3D=3D TYPEC_SOURCE) 4271 tcpm_set_state(port, PR_SWAP_SRC_SNK_TRANSITION_OFF, 4272 PD_T_SRC_TRANSITION); 4273 else 4274 tcpm_set_state(port, PR_SWAP_SNK_SRC_SINK_OFF, 0); 4275 break; 4276 case PR_SWAP_SRC_SNK_TRANSITION_OFF: 4277 tcpm_set_vbus(port, false); 4278 port->explicit_contract =3D false; 4279 /* allow time for Vbus discharge, must be < tSrcSwapStdby */ 4280 tcpm_set_state(port, PR_SWAP_SRC_SNK_SOURCE_OFF, 4281 PD_T_SRCSWAPSTDBY); 4282 break; 4283 case PR_SWAP_SRC_SNK_SOURCE_OFF: 4284 tcpm_set_cc(port, TYPEC_CC_RD); 4285 /* allow CC debounce */ 4286 tcpm_set_state(port, PR_SWAP_SRC_SNK_SOURCE_OFF_CC_DEBOUNCED, 4287 PD_T_CC_DEBOUNCE); 4288 break; 4289 case PR_SWAP_SRC_SNK_SOURCE_OFF_CC_DEBOUNCED: 4290 /* 4291 * USB-PD standard, 6.2.1.4, Port Power Role: 4292 * "During the Power Role Swap Sequence, for the initial Source 4293 * Port, the Port Power Role field shall be set to Sink in the 4294 * PS_RDY Message indicating that the initial Source=E2=80=99s pow= er 4295 * supply is turned off" 4296 */ 4297 tcpm_set_pwr_role(port, TYPEC_SINK); 4298 if (tcpm_pd_send_control(port, PD_CTRL_PS_RDY)) { 4299 tcpm_set_state(port, ERROR_RECOVERY, 0); 4300 break; 4301 } 4302 tcpm_set_state(port, ERROR_RECOVERY, PD_T_PS_SOURCE_ON_PRS); 4303 break; 4304 case PR_SWAP_SRC_SNK_SINK_ON: 4305 tcpm_set_state(port, SNK_STARTUP, 0); 4306 break; 4307 case PR_SWAP_SNK_SRC_SINK_OFF: 4308 tcpm_set_charge(port, false); 4309 tcpm_set_state(port, hard_reset_state(port), 4310 PD_T_PS_SOURCE_OFF); 4311 break; 4312 case PR_SWAP_SNK_SRC_SOURCE_ON: 4313 tcpm_set_cc(port, tcpm_rp_cc(port)); 4314 tcpm_set_vbus(port, true); 4315 /* 4316 * allow time VBUS ramp-up, must be < tNewSrc 4317 * Also, this window overlaps with CC debounce as well. 4318 * So, Wait for the max of two which is PD_T_NEWSRC 4319 */ 4320 tcpm_set_state(port, PR_SWAP_SNK_SRC_SOURCE_ON_VBUS_RAMPED_UP, 4321 PD_T_NEWSRC); 4322 break; 4323 case PR_SWAP_SNK_SRC_SOURCE_ON_VBUS_RAMPED_UP: 4324 /* 4325 * USB PD standard, 6.2.1.4: 4326 * "Subsequent Messages initiated by the Policy Engine, 4327 * such as the PS_RDY Message sent to indicate that Vbus 4328 * is ready, will have the Port Power Role field set to 4329 * Source." 4330 */ 4331 tcpm_set_pwr_role(port, TYPEC_SOURCE); 4332 tcpm_pd_send_control(port, PD_CTRL_PS_RDY); 4333 tcpm_set_state(port, SRC_STARTUP, PD_T_SWAP_SRC_START); 4334 break; 4335 = 4336 case VCONN_SWAP_ACCEPT: 4337 tcpm_pd_send_control(port, PD_CTRL_ACCEPT); 4338 tcpm_ams_finish(port); 4339 tcpm_set_state(port, VCONN_SWAP_START, 0); 4340 break; 4341 case VCONN_SWAP_SEND: 4342 tcpm_pd_send_control(port, PD_CTRL_VCONN_SWAP); 4343 tcpm_set_state(port, VCONN_SWAP_SEND_TIMEOUT, 4344 PD_T_SENDER_RESPONSE); 4345 break; 4346 case VCONN_SWAP_SEND_TIMEOUT: 4347 tcpm_swap_complete(port, -ETIMEDOUT); 4348 if (port->data_role =3D=3D TYPEC_HOST && port->send_discover) 4349 port->vdm_sm_running =3D true; 4350 tcpm_set_state(port, ready_state(port), 0); 4351 break; 4352 case VCONN_SWAP_START: 4353 if (port->vconn_role =3D=3D TYPEC_SOURCE) 4354 tcpm_set_state(port, VCONN_SWAP_WAIT_FOR_VCONN, 0); 4355 else 4356 tcpm_set_state(port, VCONN_SWAP_TURN_ON_VCONN, 0); 4357 break; 4358 case VCONN_SWAP_WAIT_FOR_VCONN: 4359 tcpm_set_state(port, hard_reset_state(port), 4360 PD_T_VCONN_SOURCE_ON); 4361 break; 4362 case VCONN_SWAP_TURN_ON_VCONN: 4363 tcpm_set_vconn(port, true); 4364 tcpm_pd_send_control(port, PD_CTRL_PS_RDY); 4365 if (port->data_role =3D=3D TYPEC_HOST && port->send_discover) 4366 port->vdm_sm_running =3D true; 4367 tcpm_set_state(port, ready_state(port), 0); 4368 break; 4369 case VCONN_SWAP_TURN_OFF_VCONN: 4370 tcpm_set_vconn(port, false); 4371 if (port->data_role =3D=3D TYPEC_HOST && port->send_discover) 4372 port->vdm_sm_running =3D true; 4373 tcpm_set_state(port, ready_state(port), 0); 4374 break; 4375 = 4376 case DR_SWAP_CANCEL: 4377 case PR_SWAP_CANCEL: 4378 case VCONN_SWAP_CANCEL: 4379 tcpm_swap_complete(port, port->swap_status); 4380 if (port->data_role =3D=3D TYPEC_HOST && port->send_discover) 4381 port->vdm_sm_running =3D true; 4382 if (port->pwr_role =3D=3D TYPEC_SOURCE) 4383 tcpm_set_state(port, SRC_READY, 0); 4384 else 4385 tcpm_set_state(port, SNK_READY, 0); 4386 break; 4387 = 4388 case BIST_RX: 4389 switch (BDO_MODE_MASK(port->bist_request)) { 4390 case BDO_MODE_CARRIER2: 4391 tcpm_pd_transmit(port, TCPC_TX_BIST_MODE_2, NULL); 4392 tcpm_set_state(port, unattached_state(port), 4393 PD_T_BIST_CONT_MODE); 4394 break; 4395 case BDO_MODE_TESTDATA: 4396 if (port->tcpc->set_bist_data) { 4397 tcpm_log(port, "Enable BIST MODE TESTDATA"); 4398 port->tcpc->set_bist_data(port->tcpc, true); 4399 } 4400 break; 4401 default: 4402 break; 4403 } 4404 break; 4405 case GET_STATUS_SEND: 4406 tcpm_pd_send_control(port, PD_CTRL_GET_STATUS); 4407 tcpm_set_state(port, GET_STATUS_SEND_TIMEOUT, 4408 PD_T_SENDER_RESPONSE); 4409 break; 4410 case GET_STATUS_SEND_TIMEOUT: 4411 tcpm_set_state(port, ready_state(port), 0); 4412 break; 4413 case GET_PPS_STATUS_SEND: 4414 tcpm_pd_send_control(port, PD_CTRL_GET_PPS_STATUS); 4415 tcpm_set_state(port, GET_PPS_STATUS_SEND_TIMEOUT, 4416 PD_T_SENDER_RESPONSE); 4417 break; 4418 case GET_PPS_STATUS_SEND_TIMEOUT: 4419 tcpm_set_state(port, ready_state(port), 0); 4420 break; 4421 case ERROR_RECOVERY: 4422 tcpm_swap_complete(port, -EPROTO); 4423 tcpm_pps_complete(port, -EPROTO); 4424 tcpm_set_state(port, PORT_RESET, 0); 4425 break; 4426 case PORT_RESET: 4427 tcpm_reset_port(port); 4428 tcpm_set_cc(port, TYPEC_CC_OPEN); 4429 tcpm_set_state(port, PORT_RESET_WAIT_OFF, 4430 PD_T_ERROR_RECOVERY); 4431 break; 4432 case PORT_RESET_WAIT_OFF: 4433 tcpm_set_state(port, 4434 tcpm_default_state(port), 4435 port->vbus_present ? PD_T_PS_SOURCE_OFF : 0); 4436 break; 4437 = 4438 /* AMS intermediate state */ 4439 case AMS_START: 4440 if (port->upcoming_state =3D=3D INVALID_STATE) { 4441 tcpm_set_state(port, port->pwr_role =3D=3D TYPEC_SOURCE ? 4442 SRC_READY : SNK_READY, 0); 4443 break; 4444 } 4445 = 4446 upcoming_state =3D port->upcoming_state; 4447 port->upcoming_state =3D INVALID_STATE; 4448 tcpm_set_state(port, upcoming_state, 0); 4449 break; 4450 = 4451 /* Chunk state */ 4452 case CHUNK_NOT_SUPP: 4453 tcpm_pd_send_control(port, PD_CTRL_NOT_SUPP); 4454 tcpm_set_state(port, port->pwr_role =3D=3D TYPEC_SOURCE ? 4455 SRC_READY : SNK_READY, 0); 4456 break; 4457 default: 4458 WARN(1, "Unexpected port state %d\n", port->state); 4459 break; 4460 } 4461 } 4462 = --- 0-DAY CI Kernel Test Service, Intel Corporation https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org --===============4126326859864490354== Content-Type: application/gzip MIME-Version: 1.0 Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="config.gz" H4sICN/hzl8AAy5jb25maWcAnDxbc+O2zu/9FZ725ZyHbn1LNjvf5IGSKJu1biEpO86Lxs16t5lm kx4nabv//gNIXUiKknPOTqe7JkASBAEQAEH99MNPE/L2+vzt8Ppwf3h8/D75enw6ng6vx8+TLw+P x/+bRPkky+WERkx+AOTk4entn18Op2+Xy8nFh08fppPN8fR0fJyEz09fHr6+QdeH56cffvohzLOY raowrLaUC5ZnlaS38vrHw+F0//vl8udHHOjnr/f3k3+twvDfk08fFh+mPxrdmKgAcP29aVp1Q11/ mi6m0waQRG37fLGcqj/tOAnJVi14agy/JqIiIq1Wucy7SQwAyxKWUQOUZ0LyMpQ5F10r4zfVLueb riUoWRJJltJKkiChlci57KByzSmJYPA4h/8BisCuwK+fJivF+cfJy/H17c+OgyxjsqLZtiIc1spS Jq8Xc0BvyUoLBtNIKuTk4WXy9PyKI7TMyUOSNOv/8ceunwmoSClzT2e1lEqQRGLXujGiMSkTqejy NK9zITOS0usf//X0/HT8d4sgdqTo+CD2YsuKsNeAf4cy6dqLXLDbKr0paUn9rV2XdnE7IsN1paDm sjqm8VyIKqVpzvcVkZKEay9eKWjCAi+IlKARHp6tyZbCVsH0CgNpI0nS7DGIy+Tl7beX7y+vx2/d Hq9oRjkLlTQVPA+MlZogsc53w5AqoVua+OE0jmkoGZIWx1Wqpc6Dl7IVJxJl5Xu3IB4BSMAGVpwK mkX+ruGaFbZeRHlKWGa3CZb6kKo1oxy5trehMRGS5qwDAzlZlFBTBU0iWMH6gFQwBA4CeoTqORrS rK6KqJyHNKpVmWUrQ4gLwgWte7SiYhIY0aBcxcIWqePT58nzF0c4vNsDGsYaFvTXo6zOthM5BxyC zm9ARjJpcE+JKto8ycJNFfCcRCEwfbS3habkWj58O55efKKths0zChJqDJrl1foObVeqRK1lFTQW MFsesdCjW7oXg8WbfXRrXCaJpwv8hedOJTkJN9ZeuRC9rQ6Jhkyw1RrlXzFZiV+7b73Ft1aKU5oW EobKLIqb9m2elJkkfO+1MDWWCVO8DovyF3l4+WPyCvNODkDDy+vh9WVyuL9/fnt6fXj62nF/y7is oENFwjCHuTQH2inU5thgDw89g6BU2EqhZM+axTSIIlyDxpDtytamQERo70IK1hj6SpM2F1ZtFx7a 8AAVkpgSjU2gZwnZ98ZUoFts9XNcMK9ivoPjrVQBm5jIk8aIqh3jYTkRHtWADa4A1pEOPyp6Cxpg qIqwMFQf0esELEiSTp8MSEaB8YKuwiBhplojLCZZXsrry2W/EQ4TEl/PLm2IkK5aqCnyMMCFu5wW SrfUEivl9aSBl702e7ox2Eb/w7tXbLOGIUETvU4P+i4xnIosltezj2Y7blBKbk34vNNXlskNODwx dcdYuOZQS7Qyis02i/vfj5/fHo+nyZfj4fXtdHxRzfUqPVDLBouyKMBVFFVWpqQKCHiuoW2wtG8K JM7mV44Bbzu70HDF87IwtKMgK1opLTVPEHCFwpXz0/HYdNsG/rK0NNnUc/iMrwJoVnUDxYTxyoZ0 jlkMhwscbzsWybVnRDBEQz11e8Ein0TUUB6lxNMpBqW6o9zvKhbgBMqRMSO6ZSH1jAo9By1NQy3l sWdkkYebdngiiXEogWcNTgYYRXPCEqXGR6IyypkZroCHndl9BeX+zsBKq29GpdMX9iDcFDnIHJ6M EBhR32K06YcIQy3I7A+eCux3ROGkC4mkkW/D0Y4bB0aCpn2rgg9uyJT6TVIYTeQlHuNmqMOjanXH fAIKkAAgc8OeRVVylxKr4fbOgefO76X1+05Ig7Igz2Wl/22pcl7A5rA7im6HkoOcp6DxtiA5aAL+ 4eOwEzLp33CQhLSQKvJGM2yQVMTmLPrA8YyrvE2UD2to5LHrYcbaJXXjs9ZVsuyr+7vKUsNpB/e4 +0GTGHjHTdoJ+Nfo6xmTl+DHOT8rMw5QHohuDtPiNlybMxS5OZZgq4wksbF/ag1mg3KBzQax1jax scfMEA+WVyW3rDiJtkzQhoUGc2CQgHDOTHZvEGWfin6LZgRqB0Z1lkUu4mZ0z56q02JHQGObgB3x f2WWm4R7roCxTyXbiKGjGCbMQmenIBCyoiBAplHkVXK1QagDVRudqJOzTi0Vx9OX59O3w9P9cUL/ Oj6B50XgTA3R9wLHu3Oo7CHak/edw7TubqrHaE5J2+TlaUGAaXzjU8SEBJZ9S8pgAA2Yx+EgrjfB 7gRQPJHQX6s4KFaees8QGxHDdHBNIj/quoxjiGjV4Q+CkYO5zbnflEiaqkMHs2YsZqGTDgCXPGZJ E0fUHLZTV52gpJeGabxcBsxwQNPU8GEVqibPdco0CH7IGrS0BDFNCZzrGRhyBqdgCmH87GoMgdxe zwdGaPa2HWj2DjwYr/OSwTlmOTpi0G4muySEmNoXrh01w0IkCV2RpFLHKGjSliQlvZ7+8/l4+Dw1 /nQ+bLiBE7M/kB4fwqs4ISvRhzeOq2VgjcbWmDSkeFIs6x2FMNiXHBBl6mklCQs4nOw6HOsQ7iAg riLzmG1aFnNTKIDrNFNZ1DpXt85lkZgL8ONw+NfWsEUiNXZjQ3lGkyrNI/CNqCnbMZxZlPBkD78r y6gXK53MVSk2cb2wpm+d71Ll7tzkCgax1QaNo06B18ateDy8oj0CpXk83ttZc50/DFHz3NHIiiXq uOsykZqG7JZ5dV/3SgqW+XOhCh6E6fxqcTGKAM4jrGToQAgoT8wcmm5kss6sOaPxMBXSZxv1ft7u s1z011gQfnsx1GmzcCYHiQMhDklBXcBqtnGa1kyw3nwbigecPzmjLQKNGEj3ZgxD5NkIeEuDcgR8 O8juGzBCPYIhyE4ccmxwRgXp8xV2dYPZ26F+QimlsxeUSJmMSJSQmEi+nU1HUPbZDYRI1HcQKQRJ V5x4xID7TzndZ11m0UAsZyLMhzHKjBWYcB4iawseM8Q7rmbeotnrUXt3OzzRHTAgLWx4faJ6rIPp EsVdgkE1wyE5OZ5Oh9fD5O/n0x+HEzg1n18mfz0cJq+/HyeHR/Bwng6vD38dXyZfTodvR8Qy7Q2e sXiPRSBGwyMuoSQD+w2xm3tIUw4bW6bV1fxyMfs0DP2oocaKbfhyevlpgDUW4uzT8uPcuxUW2mI+ /XgxSM1iOZ9PB6HLxXJ4JbPpfPlxduWCDWaJgoZlfXYSObzm2ezy4mI+JHgWJvBucfnx7KpnF4vp p/lihDZOC9DUSiYBG1zg/OryavpxELy8XMznFyPLuljOgX/+PAfZMkBpUOfzxUefAXfRFjCm5XU7 8I/Li8v3zLeYzmYj88nbeTemLa1xCTGRKFvwdAY+2Mw7J54dCUOXoeXI5exyOr2a+rcaTXcVk2QD EX0nZNPFf4P8ybMohXoTxaBZ047u6aWhFb7R6Gy6nFkBSB6C34FXI62BxrsIJv23Vv+b6bFlbblR vr/oC9nssgaNaM3l0oNjYWyJ9tYXHovUwJZX57pfLz658UrTtR/J6B7LKyuTCI0QCGfgNWQ+qQSE hOGxWuMYDqxKoqWhtU+qTaS+1E3GVeLyen7Rxia16+wm6jHb7AvJ84RiNlk55kYq5Q6lz+wPLfML /yEPoMV0EIQK5Zv47nrWRTt6jWuOF1VDKW91paoEQEW2Lpq6kgVnvo4SBsFdKG77OQkNZRNaYMyQ OBgQbknf8F0hQBFnGNYxM2e0F90C1uWKgoGOXYdCpWkQWBUpbDRE+C71mIVRh3SFtSoqP+gPjUQB gqWGKWR9ZdHJEQ0xovVlgAknePlnxEF1i+e6rx1vQ29pCLHUgHcYciLWVVR6Z7ylGV67G0f1rXnR qK5o1fUNimXOwY8zovQywwi9Du/g0KPJ1NwOzI9A5EEyFZOB646lPK7iChEY28RzlQnBfGObL9Mc jfqGROwqKQM+BSb5tFsjSbJaYTo8inhFAivm0GmF3nUv9Pvr6sNsgnVTD6/gC75hpsW6YbJmWO8q EkeBP2fUWKdhAhOBTkyeslC4vCkBNALerqmZEzpDt7G2+fDa7PlJ3ud6Abo3slQQNggn5fB6w6zo Uz1IkUH14t07UkiO9x+++6z6Tq+VyhyUlITgtRk6V+NgahoBJc+U+NgBiFA40LfXFsasyugKszCc YCpKerZpcDHGgpfv3CaSlorlPUoAvL2qlq7cgOnDNOfKQ9bglAZZF+8kK5Csx1MP32282tOdFo6+ Y9TsycxaxA8S5licbS/EKgQto7y+F3GEqT7tOMs5k3tVyuWv2uBUpXnrQ6m7DFNk440S3iAMiSSW bGDSEjlD0U7iicWpWepkgwtwEutiRjfvHlubFjzDdM9/YkRrbFGYRqra0ry2o7G/GsMaQafSnv8+ nibfDk+Hr8dvxydz/O6UKyFMy3y3D4WZ50s1g02OQRuJtng3F2mgdwwImTfWOE0SVFeRWa7t7qYq 8h1wjMYxCxntbmP8QztDVXnc84XU4vDaTbBmw5tMwhBzmmKiGiNtMZqkAsLY58ejyUZV3xK5R3tX J6M7tN3j0/E/b8en+++Tl/vDoy5NssaKOb0ZHMvT2wT36FaDxw+nb38fTsdJdIKY42TbAXAoU6b0 PQ/zxNGuGqh2RrPaf2oAXjE2SDE8iI0Z0Upl2mOIsTxTISzpEmngqPG61GAAgQvjSkXFerAik76m DSjbZUmOJTmYBR8WPskA3VprDVjl+Qr8ypjxdKf90q7cUYMw4a0uv5UJ8owN+t1m2y0LCPYP5oyN Utfalwba09CsCbfbq4iJMN9Svu/tiQJDYAuy23Ow5PHr6TD50ojNZyU2RpUWJiErtg1NpRro04B7 MtjuGL+pgn1BsPqYZBCyGA4o+tUlhAl3zo3bZps6K4YWHMmuuDUh5vW02Q4Obempzts0V55mP2xM U/Myu8VNhXu7jq2ozniHdKuFGosP7NG2sXc0nZUFJyBOSoFXFYndrbV+wJ89lmWpWrL66BlYp+ax B7hVVJaZqm4J17XbYczGIPLmGPJtqVPqX/uLfF9YLwbUb4zOINZ2rzw74MVsPgycNWPb1R/dyC3c d1735xgcaKHhA3GZxkoX75ktXY5NtVpjjOcbxsUMeShn04jF75iUUDHAwxZSmebRAwTvJh1HCMxj vIeA94VeFBAl+G8+dW4Ua2iRJ/vZYnrhh2ZrF+5yqSMgED371Vy+G97m8efPxz/BFtm+UD3mrxB6 VwkJqHV0YWAASrahmJmgSTzwnkQpUue2lBkYrFWGEW0Y0r7GuReiuhXcbC8gLjN154m5SfApWfYr Dd3HCIBm1Qt1aRZ1Ab7O840DjFKiygfYqsxLz6W2AHagS1MX9PcRFBDrhIAxsixMi1DnYOKcSxbv m+KzPsKG0sKtWWuBMGqdYBoA1hbJqikw1q2fFOnHSdVuzSS1S301qkjxsK9f/LicB9ceJAzvMtCt rzezIr0qqrqox7tp+D5psON6B8EWJbpa0IGpsh2kwNeu6hM1VZgz8jHAEugRqFkuVaOlEKtCaLxW 0QsmyrCexgvGImYfSr1RWix16XCvyEyB61b98GoAFuXlQA6xTtJhWs0q3DUwkEcJsNgB2oHaUAA3 GNiBWOU9hyEcfFWhwGcfDCis868GGrXOMEtL62QoJnp9eCpRurV0BOS9xDQ2Jq6wlBD336NiCtSE xb6hrRIiZwAb5tQeWYV2Mi/Q7dY9ErLH0vvuKEiwACYAdoI7HRmT1MVGizmMr9jlIxCXrTfONOld 61gVH2wwA7tRp0357tYUhUGQ212z2sbp6KsfKfJq7YMWsC+LeZOw8NS84P6BgeQUF4Siaa4S09lm wZ7/FqimFuZAUdfnJsQKP/92eDl+nvyhMxV/np6/PDxaD2gQqWaAZ/EKqiviqO24eiBdtdzIxBZ3 8Mkr3tk46QOj2Rs6v9MhaBNFsHtYHGsex6q6VKRI+LSbuNYnX6lwrWnqeUoCZ7B5TAb1jUP7cwNB pWCwGTclNQ+qpro7ECtvY8KCfjsGGyvMhY2AKvAxTQ42CHiL4EsJqVcNOiVVqQsibg++C6Q7HDRV 6Y3X1dWzYdrOffhncgR8qLwgvppdBOvXyBXNlEdo+UReMN7yJgHpHqcUh9PrA278RH7/085Swwol 00d4nefy7bCIctGhdtNjGG82d4knZ0aT3vRGHRJmPIjNKhWnH8rm3YMZi1joyXJ9LRiB25MMlbUZ eJt94C3maeBBfGPSbU/dpuHat3zg6TG7rJ3YjzSIyGaOsaj3RxT45pvvbYUYwqiC9QjSmTHeN4D9 HG8QRZCt6/KYaGV2hhiNME5OjTNOUIdUPzjx4yqHeJimFjxIUYcxSI+FMswghTbGIANhnJxzDHKQ Rhm0A6tIRzjUwQdpMlAGSbJxhpmk8ca4ZGKcIekcn1ysHqNGlfWcng6r6Kh2jivmeZ08o23nFO2d OjasXqOaNa5U5/VpTJXOaNE5BXqn7oyozbjGnFGWd+jJqIqc046zivFenbBLbnQFQMVTI0evfEgt QeBJQKBjOk18J2g6BFSTDsBa/199zCNSaIhvHL/DELcz3/m79tpbBz9DiraUJ6QoMIqtL94r9QbT Fw3ph1fAT+hgfaJhgx+xiLAEJeJp/SDQ9uo7DE5XGOnUSF73xsBuMpB97D6uUM9XxuZGDLwoeddw aRoaw/Xhq4LlZ+ZTV1Lvmwyr7Uenq29Q/Dj4zCbcVzvMW8AWaYh3mFIEo9Mge4JSjOLwIhWrM7wp z7BGfVXlfTKw3hd4OShyfr4HBAUQqOX42qWXS6b/HO/fXg+/PR7V558m6sHcq5E8DlgWp1ha5V5B d4C2xsRWjq3OwdThu6uhq6xEEL5ENQI56FA/KjSqpDhVmcCuIAtGHf4WQE2XCDkr7KBNA1ImfI8s cJo639gGBkPMUZxLj9+eT9+N2+h+4t1fS9iVHNeFhCnJSm8c2NUqahQjUdNAPE1Yi8OpmTfqQFv4 H1qatnaxuw5wcYbuAtRHIVa9rDgmvNUDUfu8qtdufiHDhvQeeNntNV2D4EYmcufjXSNPw3RlpKqK 1DWzy04G0oKEbVjbRnsr9BfwIPQX3ni+oRSq64fKqU8t1nuhKwGl+zgyyMssdBLRTeRpErMRqYeC hgtqb1Om68Wul9NPl9Yetcd5zZ2YsKS0tc2GeG2KLz/rUyh8UdI8KOlkngNn8DsT/jtCb2nyXZGb lQh3QWkVZ90t4jzxZTDuVD4rt2qom7b2gV+qD3ovOS0yGjjfWVXfF6mihorlKl/ZEQq7Qjmn7U2N EiT1FTWDIH3XhJAmtz6WzizU00o76R1zgl+BcrL6YFgxId98Kqc7EcqiCmgWrlPifdJsTYUPXRix cpnDZq8ZIaPtk8fs+IrF/w9PX/vGETRtQ61KY/xdwZFvFWOVGfM/qAJ1939qA9rxPQzeoAysET9s UcgCPxYoBIuN86fpC5qqcu/AvrSw7ikAo72SMafUjd6EWleZIn3KK6SZOuUsMq879O8q5dZ3NLYJ yaqr6Xzmzz9GNHSY0zjeiWGN4If59lYS85Ybk6WgGQmtmzu2F1HkLeSeG89OwHsOTLOXa5noBqGU IvkXy4Hdab72oqTo5u34dgQZ+qXO0jlVZTV+FQY3w6NVaxlYm6gbYxE6+6jasdpyZCz1nYwbX0c+ sPMNXMS+N7Ad9KZPo6Q3iW8qGfi+JNMxQ/SHAin1jE9wtf32FTe/4dO0RgJ1ykcP/E194t325K7K aF7enGG22AR+AsN1vqG+IW/iMUEI7ScdTXN8MwQJiX+a2K98rWyt/5+zL2tuHEf+/Cp62n937PQ2 D/F6mAeKpCS2eZmgDteLQuNSTzvGZVfYrpnu/fSLBEASR4Ke2Ic6lL8k7iORyExsF/GuxHbNCVVk orkDCVYSxJyPT5Dn6/v70+9Pj1qMVvguq7QBQglwC1RmJnnIyiaXQ66MADPZU4oD1IOPuW+OaE+O HfYV0MOF77aVHAtzpGZGjKGpLp1tfoypycf1kV5DINHx+k7CCgZYOxQ+TTPUMWscLeVWcWbIMzzM aN7ApSUVl4/oFcaG7iEpu7eR9oiJNv73qJx7ZrjBTj4SLoJVokkbZtISxqIEIUkfIbBVIV+hj5Rx n9fJVdt2G/1am10cTTxYPiqHERePdgI9HtxpmdZdZUwnoF12pEX7hoHCotI6FBqC+X3siTTY7vtB WQvh94XUmAzLoOEgx/iTg7v1WxYrUV62zjIuYooxgUdZRCWAS0HaWt9DwDzycFGjJW3utfURppGI UayKfKuP2/vHuFEL0dGANEAWE+fG2ad1n+Yl3iMZ6tikXdZC9J4iR2cThD3UeKsit1za0tFBtmAG g6dkTh7aPkU6HEB/ISYP94h4/nH7eH39+GP19fbvp8fRmlhWugzc1FtJqx/U3/dZqvzeZ+VmOJCN Vp+RzCKyIU4RKO8mw32sZJ56wGRrmaNXgzSPELH1Jmc4pGhwMvF1VnuOfzYq3qWuY1K3aHMc6R88 g7o/6iUG0kUv8Qynw96/0z8Z7uwfUBAqqPVkW9PpLx+zrGNk/OxU9kWlGGCOlAuPOTNSQf2pBupi JAjtopFI92AwlcpWkm13ILa7pqQxAi+329f31cfr6h83WhVQnX0FtdmqTjPGMI/xkQJH1AszHwY3 T+bRKlmgnEpKxZydtnelvDLx32zyGsSy6WTLK0EFVbW6mCWGHJF0YmuxbOwUV9xVBc3YKrO0RIWR rSxsbcHifVcOsp4PiE1WGgS4/DCJ6sAC6l7/luxzdgYUa/X1bbV9uj1DULRv3368CElx9RNl/VmM PGlZggSGfhslkZNqycpRvoEAeibuOC4Rt7nawpx0KT009jOk0gTrtZYwkOATg+z7COnCVwCDjCbg jS2oFLEus77lQfytBdUXjpEG2S98gvQYIxul46uQ3udk8Fz6r94XgipSUcoE8XzpQNEqgrHQzCwF b86dGJPKd4K8nLa/PfVN8En+SaAfnSY54b8ar5PegaRUYivU6VlulQ2/OlHhqikw7TvoQOEqUGYv hv3QttUoUFrt5ecYi2yi5XwNRx3U0nojdSB3Pkr30qDlptFqg3cZHvury7K0Nz2emIHg06MowKo1 vSUP3KByX1SdJZZSXhyHurMYtNE1vMlTMGnFi9Xz5EfvMf7QhFHMyYvq+fX6VXbJ2lIhs4ULn7lV JhJTnuYQunkG4QYknX3V5kcr5q+YmTmvrtywKMNkW4dWbv4E7g/gthgdvHrlpo2Wmwwf5RuocXhU IF7jGE7t6st9Sy53B3hDZFBsLTktpzs6tFmhoVMEPzDipoKi5VEKgI+Hiv5IN2VVDqVsQyquSaWd ll1r67/V1U3QlLVtotUm8eQaJNVpbcxENnoYE8wyaV6BmwiLscEGz1YdBwBuiybjanlMUzM2CbdZ b+lBqd09yCKcZdLxI8CPd2l7nYVHHibvsitBXu9xDUHdngdUuzvHJarkh1bYhXuxKZWYbnTD7uDi oYYew/xA+TpEfzWK0x2n7+SOGaOjGUGPt6S61OOQmIu/L/U8Z6lXapbppMqL0Crdw0Is8sCv+L13 Q1Cr5WFSKs/Gqt+vb++6zemQ0+aPmJmrJR3ZXFjVygHYbs1v1dS3ZDF1OiqZL+2YOgJxJyG4reN3 rr+41gSY2xYztlfjmJiMIOe0TfWAdo/ZZqzRDu/glf0K9rM8wu7wdn15f+Zbc3X9S9nyIMtNdUeX L6PRWDWsLcbQS4+J4ttBEZn1X5deUhyWKt5vc/H5PDXINsfkPFKrGbF+bjujGvrtpgRNZtMQ2wle upl8E/q0/rVv61+3z9f3P1aPfzx9N7UCbNRtSz2/34q8yNh6bcmVrlT6I0MiKaa8azvNBWMEm1Y8 CKBkB8iG7uAPcD9ou8gdGSsLo8a2K9q6GFQ3bsBg0d6kzd2FPQ9wwcOxIYx4HDaEEfeMRRixWGFY CUO1GTVYjas51r6014vBmDZ9Atdmv5WxsRwNy93ElE24YmsaKXWuhLkf6VTyS03qYSi1mUIHuLHy WOJcs/VxQ+jijq5CC1OFG+Zcv38HVaIgMvUD47o+0n1Fn08t7IPn0QxAmwVgsFGbU0CQkQBOCJMc u0Omg2NmSpupsKW+K+qywQ5hChMY3DFrDzWTKh3GFh8v7j9pFv6iye35918eX18+rk8vt68rmpSp o1QKC44Q2yol+NUImwLZvvP8Oy/ALnfYekkPrIE2WkjFS6/U2CDRPzqN/qbC2JBWXJMkm8AIlIqu REROc70Y2WM8qLV+NMmf3v/1S/vySwYtZjvOsQZps52kiNiwG8eGHqrrv7trkwrRzecXYz5tfa62 oWctNVOgaEo+Nu2bAhCUyKO9P3BDYJxDSLg42MpWCzLgnWGz2RmdxcAConKcQKdfK1YVFgaI46Ev I6eLqJPSc/LHG/Wiju+v1//8SoWW6/Pz7Zk14Op3vnzQ1n57fTacjsYk8wIc3i85bmoysYHgzlLF hzjjAXG43GZoyUF0DxzMGmJiEQGgdXJ91nuIkY1IyhMCK8ZyZWDxgNdJlkqT0QOv9njJhKV0hqn3 Mnxdfnp/RIYt/MXVh0jrl+SubSyhqtk60ZXzcBi1RDA9WI5VRxfG1f/i/3qrLqtX37j5EipbMTa1 Le/Zu52j8DRl8XnCRiHV84tEZtawa2auBOFHUDPQkg2QC9lqXX2Qg/wKwuVUsQgBZN9Wub4AMoZN sRF3dp6jFglQsO+sF8Q64NlVB3qgXGRZFuaZ+TJ+8swHqZLy5knPVKDCUPUWlAhmtIPiok+J3CQP he7azW8KIX9o0rpUcjUD7lGaolKgv5tCLQg8ltkfQbSX7XI5APf5Co07GUgXLvRsoL7fIAiX9BzH URKaAN2+1ia1gbOcVBnh+moQLg0EuVRDm+S9vMZ80WQ2+M33C10XJjMIC1IpUsCs3hA5wyW/ucP2 G7rdPb3zO6N/3B6vP95vK3bQ35IVFVaYwR//BCKk375K96VjleRYniNR2YkkIvcelx7zkDFDemBt c+nuhiw/5lqTjWShRyJ/j3H4ZJjDQrBRGAmgWMaM6opGHJa54WyhbnwSDD2CR7sTthG8o7n8cKyL Ffnx/fvr24d0uUOpF934nhGZuRsVdLESMob9SbW2ANo23fQ8Zqia2Ba9Qjmy15P7nWomKJEvEN6J LmuH5a/Z0NJKIpCtEs9LaYNpezKvvOgphNBVma6XxK+OjieHc8kDLzhf8k7xb5iJ+v2LDGm3K7Pa 8VDXD7DQINWkrZn4Hlk7SvBuugtXLQEbAxEtDltTRRhwMvTyypB2OUlix0tlU7CSVF7iOL5O8RR/ +rFZBooFlmjQI89m70YRFvl5ZGDlSBzljZN9nYV+gJ18c+KGsXKOhkWeVpyKf50vlJBYbtpqdoZH jc4Xkm8LbEiCm8ilH4hkVNAdu7SR94nMEys2d6UpOjjRvusTi9PpVPek1XomBgaROy4Z5Do9h3Fk sid+dg4R6vm8DpWRwoEyHy5xsu8KgttVC7aicB1HU4+MbjFqRUVMvT+v76vy5f3j7cc39tTW+x/X N7qQf4AuEPhWz/RQAwv849N3+K8sbkPUQfyw//+RrjkCYfJaLjQVFuViAl5W4fFzu/k175cPenyg sgKV/d5uz1e6CZn9fWw79Rrk2CpeRUuJTJ2Y7aUrjWksXkZ7lvFML69Z/ACfkXI8NBolY0E46laO d52WObyHLkc3AC71l/pyE6OIC1BlTQD6uF/ruzsrlyjQ6uOv77fVT7TL/vW31cf1++1vqyz/hQ6p n5W7ELEbE9xaKdv3HMZPZtPXmNnX9K38QuNIy/ZaVTM4qKeNquRnSNXudjZTQMZAMjCQhLfy8AYZ xkGsRq5ln1Khn3UMNmiBYZtNHad+WbK/F78lEJzZ7HVGr8qN9maQ9Em6UFcI+tySAcKrWfPtO6nQ o9ZDawmjkU/sES5bmvneKGu+v/R5iurwBbzvLuSkD/L9pdAfXODktDqk6OqEzbYxTX5tDwLeeJ6W 1hY5eggBHmg5BQf9zKaFOFYQGk+FxofL54KybGpTqM5m9cbqP08ff1D05Rey3a74Ax2rJ3gJ8ffr 401aJCCtdA9BYOdyz0IMAFlxxPy0GGY+4QRU9lSS7ZP7tle9KaAEUEhkV0bk+1pVBvGnZ/MCwpmh KbCnE9Je+whWQlyOEaBFSS9ATL4R2DqQLwXyWZxWqMyCXw5pZJwVOMWMSK0zCHmQWGNXCz62LsHV eMkDCushhqBt85qZagwlismly2trfiwRJRTsyCwu9URkXBYXQFELanw8KiCcLHWuTQlampLIdaDk DoIfkoHF21bmHMUODUQy69QLUUpn3vV4LUiTdmSvRiOj5GFfsgu2YwmRFnEPPkhYfVxrpND18l6h shO2yVxsiJYvFU8sOVXKGy6UUpfqKkJJEFgXbFzGyAZyyjBs8aS/FL3aj/JolpOY6Jd7bOlWOIje ojO0R4OSsnHBtSfKADzYuHWvS+h/Zj6As2+r9K7QUweF+fBgGRmncpAFB9G+rCuJQkail8H4lX1b xIFVP4sP8CKjoVaTQAg9J88yoHWqNAck6HT1/CR8LkTGuK0rf/Xc8JfIWouXcAFBNHEvxDqns3V6 RV0mKmLzyNYXOhHepjw0ZS0/fsGBctikyr0CUIWlr7RmU2JNMjDtLFEtN2M4KqajjGa8+MepXYYb enT7BypNoYfLrC+qyx2JkySQZeuukiN8d51y9Uh/XjYkt73d07EICdX43IdE5r6plm/qrjM+YPNP N3CUOVqLnR/91hB3JYztOIM89olSYVLtVQGMopNVHRqljnGAT+JgfMci3cP/8JfjwEEBRjC3iMNE 5VOVKoEA4DddBZq8BT/fGn94U2GS93hYzUbDcJS3VqNDyOCmb1Pod7QiMmMGAfE/5WLX/f8VF90+ P2ekrU/lc2yVV7jE26l49ZmRtRrfXob7VD9tKqj5DCrORzAVgMwhC+EyfShteX95yFPb4Bl57g8p 6G6bdFIVMc+I1ekJnBt+Mt2ffgYPivfbjT2ox7mMG6uT/FycsOqXfsFNqUmBZVmjsiGjqN6AusWW C4ZoixKjnT3s0UU697JLTrww8CRHc8pfqr/Ym9rSTTx4j7PtA+1QmhesMThWNGKvmvTlFq264BJq c31XG02/0UxKkuNPfDRHZYIKjdH3Hx9WhYzmmcJ+aj4snLbdwr2K8PeZS8IwcNGjdcHLyjh4DJU7 PKgLZ6lTKgyf77ixy2TV93yl59zpjKgoKcRnLZUmtMwVht/aB375pH1YHJe+Ko6SuxxvQpvNBf+A SmubNu2VjhxpdK3ugiDGLLg0FulJ2BkZ7jZ4sveD6wTYuU/hiBwk0fvBc0MMyIWbah/GAQJXd3fy DddE1yUcBWADBN08J7YhS8O1G6JJUCxeuzE6vCYmPnyWeao69j1/qRjAIXvxSMmfIz9I0PLVGbb8 znDXu56LpNkUp0F5dWWqsK7BmJC2KxoQeBczJGlNDvoDiSM2tKf0lGKHiJnn0NhGXHlPQu+TVm7p FMbsSObq1d5laA/ZXjvhTAxnGPFLKWRp57rnM9J0G/mxjbkLBgj0W2bmKsCWj4WFi64eBF4CXWBh UXxwHbBggLoSKm8X+KotSoJHBevrcq0ZVjGS6sIAFO7AMKXKaTUm/DNoK9+wjRS4wlMnMkdcXPck QNzYlYM+tj4JaG1mFOD2sAIMjN1tf337ynxayl/b1ajHHnf/QnE4Zz/hb9XIgZPp/qQsbJwKnlF3 sqcBJ9MjVUdUZwZGp+INesHDkuKXOfw7NWvi1corsOKDPsO4qWSC5s3XWYLdVx60htildSHaYEpk pF0aQrchJJGJoeK9JvTPWPvP10yI5MF38D+ub9dHuqmb193K2ewoP1fQNqStCh78q9KD9h+HkUES Lk8mjfLNZAjIlyuKPIj1lMSXbniQ0hZhHG1EYcUhvXtcwatgTAkMblmjFEFub0/XZ1OMht5JK+Rd MgHEXuCgRHqYo8dS5lJhmtDLfPAIvJNejikl6bdIEtsWzlvYiVJmMlpUKVCd2hKvIZxmhq1GMlfT M4dUKSKejPbwZEddLLEUZxC5ixwvX502D8wx2NJQKekK2phH1SlW5mDuWsIOC60nV/vrBhQoa08w 7anSI6Sy5nP6PP3Bi2PMdV1majXrch2DCckCdx5wgzyZn8ktS1zglISYdnKboNeXXyAVSmHzhN3T zucVPSlYmmlijmsz/VC58P1Lm3r84b6iLuEuzN5us3yF0vnwlB+dxXBmdY3jYorZC2DIh4JOhVTf RZ84VxjORsmgRJViha0B1mk/MUwz1zXrtYcXHe2lUqUbiWjNtSY1Vn1Sf952wLQrGvEOpDUHZq8E fHZE+taocbktjwuFIFnWnDtzgDCytUwkc8OSROcz3mITvPChIjUaqOICO84gLrf8NqQ7PTQBzvF5 F4gP0EVWwmC08rVaX+llpk16yHvQOLtu4DmOrXT/XcnK7Tk8hw5SSWGr1ZGLHhzGyLBHr/05CBb4 VWdpyBn8vKSMt2y2VXFG21HDF8Yq/VWcmQd4uSszKrFgerdx8tBN/IvrB9iQ73rcTGZc+k+aGnfy OFGkIj3DbOgrQ7kgwIabxeRavAHB1Fx2RA4JArbGXLic77PAsZqF00LvJjhMuNp3lCmPmdDXKypI Sj0XWCAoxq+8H8sJog7wKDapzZWAaQYPppTCfO6hSWhNNFvtnmnL5VJV3cI46jrFJFvY6BpLT0mP zZc9beRKDn3AqLCTa5fanA4mitw1GkXg0lvePRnEL+Pmt4k1mChHW04iaEQbhp0gVF7e6pmwJ5Lb 7VYhbxbypkcF/kobQmLRWem5ipvaz0Nhwjfp2sfFjpnHGttnZgG/CzwDm0nLzFGcH5qW4F9ndBxZ LMcgvi8aSRP099PoFzSImcTo4E8tHYKGjP7pLG1DAfQKGQwxiba9CapB0BUeEvmS9ahedGSh2+B0 3YVAdN0s1WdTZbQ5HNtBDdANMD7/ATnS2oJ1xvkBqcPg+1862S5XR9Q920C1RqD7VPVgC25gHrvn juXd0h8I3VLbdpiCnXAFuJchVwdyuaBhmK4N3JWUuepliJeqCtMzlfX6gOL1wRJ/mWIiPAqctbHF wIO3VvlCOlUkff7n69vTxx/f3pW6UElh12600NiC3GV4JNUZx63ztOymIkxaEwg3gZxxWM3Kc7DP FX3O3Bd/vX/cvq3+AcEqhDPtT99e3z+e/1rdvv3j9vXr7evqV8H1Cz1XgZftz3oGwoHO3i3w4ITu qyfheUHKXcOC6eiGIhpMqhSVhjU2zNoPWIq6OGJ6LYaxFS5QB6IaWG2kcAM38cSv6gzHJn2NHZUB uSvqrsrVBBt6Ns7LO5XYMtW8RlPizzDKqdLzpuNnyecRWPijJWoMpokOxxHbdwct+74stXnb38nh DNmc2V9qOhcUQcBjMdaGItNLYJz6JUx2MZfIXJrWSpGl03pT/EkXqRcqFlLgVzqB6Ti/fr1+ZyuX cf0Gg6hs4bL7oK9IedV4KmX2cVPq0Lebdtgevny5tBaxAiqatoTKNbWa4lA2D8IqnpW9/fiDFnMu uDRJ9RnINnC4pK47NKoI8GzF7i+tKOjqofRTpT7nNJKEZ4XWRsy8Ud1yZzqsbubMZgaRlk1G3iuk 73z0VKQcOLtyDkki04rpiUbwoKiv7zAOZrti80aWWa6zc5+aUnrmVu1Fs1Oe6gCaYbjFiIcBZMLq QSUjrscSGYwtcouvR1dKC57+fX4CBarts5MWZYoR+fhWUtkS3LGLY9UnpQP9AxwajZ5R11SgVHXk XKqqU6n84LkxiUaKQMw18QXoLZ9TlgLCeuqtFSVHB2cRxzNaom+zO4vnNoO7rNyqyfRGIdnyem+S 1YjfE6e+ECscxM9CWnI7nrlxSUIH2+sYTldlUrZamQmYqOrl4woovYjgqW9Jmy3irrtWk2FUz7kQ FmBDT25CLYEIgecMgbD1D/nyb/niy0NzX3eXndnoaZ0rC8GP54+n78+3P+kSYDoaQXUPZ5m/e3v9 eH18fRYriOrw0rGVwSaFstpWReidUeUqfKwuuRNpfD9bzYkh5IGudUxjOfQt/vhSaXqGi5B0Unr0 YAtKTbjftkZs26N2Z50aOor+NC3oeaiyjqwen5+495ve1PBZVpVg4n7HzsR6mgJkt2J4KUYWZHeW UF0WnYr2T/b69Mfrm1w6jg4dLfjr47+QYg/dxQ3iGGzV5zeLhV2csJsF4yPbgyyygdz161cWlYxK LCy39/9jywecH2OvYzYmcx0NFj349Rj+zKjOlEvZgF5oHidjcEABXFi0dfkF4bLh88Pkp/TL9tBk 2o0ipET/h2fBgblGIteU+JGHmweMLJvajWNsWo0MddZ5PnFi9cBpoMpyoaMmQmgXymLpRD+7geoI PCFDvcUWrRFvs6KSHbEn+qlCsokcB80kQe9vpsYq+qpsbC39+ZeXzW6dIWXULlSmRLv72AkxYx6F I15jH5fd/dpxk8XOLz/NgHFEtgxCx2IXJlUsDsPF4UU5khDtjDqvk9ANPs3gHC3VgGUgh2VTgMgG JGsbYP0CGeb3GVk7SEpMWmF7h24XpXKQDedYbAOSRW6M38NOLHm93A2UIV4H6JSoYxfV5kkMionE RNfvaUdgUouidLgFDpEmo4JWt0VWIEq89HEaRevUXUATrIgzGi6jiylHi9/Gi2iyjAYmOt4+Y2TX QxqOy4kukhGP5XpW3FymIQ0KSCQfOqCjykXKxYBEOu+DvKAcRQSBxaFgvl08BlHgeiNHu9UOOuMn ZX+v+gYwjRJ7dUajGTHLGJXZjzqTPCresPt2/f799nXFBBtDscG+i+iBQTv48YB74/F2tuBiD98u 6PQYQ54eaXPhZxTOcEo7XIbkOrQB/rFZXcgNsKTQ4ny9fq/HyPvqhF3nMaxqd2V2NNp2E4ckOuvU ovniepGRft1l8fmMbeTchK5y5MnGaEI1paZDV5c0yD06/NoNFhOGM43nMJXY6oWFR5zVKwVGthvU MNi4AELgCxr+n+OjFk79LAVfYP2lKfXtRWzcTsppRr39+Z0Kz+Z4FpbwZqacbgk8I1gaff7tThdF MytNNQejesYg4VTdoIuPhCxNAh8/rs8M0cJM6LJtHEQLKQxdmXmxPpkkRZrWlnzt2ObLbbzJIyfw zDamdDf2UONOvjQkThBoDaRrmBiRK8Tt1aq6OFpqOMCDEHPYEZ2irvxTT0Vh4JhzpCNh4FnEwJkj Dhf7gXIkqAu9jJstMdzX5xj37mP4qY5917rWACpqNM4vs28n/cVin9N9wpWFlrHNfDdx0UHv6Itc nfl+HOvTpitJKz8cxhcOutGvHV8uOFJA7sNDlx+j4NNXCKpO+d2uL3ap8qwsLyw9J8sXGyclItXJ Ba2KoSpwf/nPk9Cazyqg+ROuewZ3sXXiaMlJWIwfZ2Um92Txk5x4rCEwZxayK9FlAamFXDvyfP33 Ta2YUETtC/VqbUIIftk/4VBrJ5AbWwZiK8BCuYun9DAO17d9GloAz0crQKHYwZYT5WNf71QJcj/9 2FZW379kfWYDY1uWgYOtCjJHJM9FFXBxIC7kk56KuJE8W9WxMgnSYB5zSY+SRMtvHTv5VWfGBIEm B5QoVD7KQU5CxfsS2GlO4tIFQx2D/w42OzyZGYxnPmWq0RfNZY5qyLwksFaqHkLcr0xmEkXGG218 wcKWg83UR+YxZUgTnUygMOOegr3CAE7rkrqZf6ZiUwYQw7CWQWsR4eH36sEsHKdbA7coTFqQxy5P OS6NebbdMp9a9YJGAIwdm3dsI9ZTgzivE21KCqxVduyd7S6gRwV0dG1SuDd8gAdZ42QdYHd6I0t2 8hz5NDvSYaKrWikZQRWmCoOLJ6nGLRwRssEcCseaEjXuy/jR5t6L8IPUlGGauAFaByqCuJGzXqqF YPHMejDEk8WasaQl6eAbrLvoR3HiYJN05ACpVD0vjojFCGZOmgUPMotTDX4YuJbSuOsgihZS5Y4k reANg9CSDpOKF0sHLIlvFo924NoNzli6DErwo43M4wVLVQCOyA/QnAOeMwLEskpqGoP1xl9HJp1J 5k6CDrJdetgVfO1eL8/Tfggcf2ls9AOdxkhFDhlxHcdDKjKdwQwgSZJA2qe1VY39vBzl13A5Sdhp cCUU95jhEdQQhzIR1TSPfOVGd6avrXRFYpmR2nU8TEhSOQIsUQBCG5BYAN/FATeKUCChUiNe8oE2 wnJ4WOBZo4c/lQMtEgVCzwLIelkVwBoKLnDQKpAsCj2bA5PgOUPY9Aa7TDZ5wckpq5dikXIWzTRj Kg74yC3nMJy7pcGS0b/SsgfBsjUbghkYD4VqFS8gEnpIm0JAXs/FCst1GgtF2cLNRbA10wQg9rY7 DAn8KCBYdjv0gntE68z1o9inQyAzU91VgRvLDgsS4DkoQOWDFCUj41EYQDZYqfflPnRRP+2Ro9zU aYEUgdK74ozQhxiZpr9la6RkVMDqXQ/rVhYlcVdgReaL+lLHcg6kFALQY2Pr8CfBeoErwco8ZHRP RVYKADw3sGS59jzU6kfmWCOLBgNCSzm8EJ0TIE+4VofImSd0UBWdwuIi6zcDwhgHEqRHmJoq8pCx wREfqR+Eog49pJ0Z4OPFCsO1Z2mREBeiFA572bGRUGed76AlrM59sROTUcOGLAyQnbkumq3nbupM lxbmXSU7I/OwqkMfo2IbE6XivNiwq7FtmFKRXq/qGM0tRnOL8RlSx9HieK3qZKn7KIyMLkpFy0BP +j7SCQxYY1ObAWjBuyyOfPTeW+ZYq8eOEWqGjGvtSjK0eCSoiTUb6JTDJFiZI8L6kgL0OIk0T9Nl dYSNqjbLLl1sW0AZmtBDI+69ODHhzbWNgwQTHbpae8Rz+qTGH3GRhUYPq/emgItudHeh29ol2247 y0vDI1dDugM9c3bkM8beD7xPBDjKYzGEmTk6EqwdZPyVpApjKlrgM8cLnBB7+EzZytCJywGIz3uo VB28xOLH+KYmdpClGvGNwrFtUp4TLQolnAXba/miHCOdDsh6jR8VQEMQxvg90jTazgXd9JZKRQ+k a2eNbWYUCfwwSrC8D1meOBbP/ZnDc5CV9Jx3heuh+9qXKtTCAZgVOsGzHJjn2shB9oOLtCQl4yI3 Bfw/l9PLkD7L64Lu9OgYLqjgvEZVNxKH5zq+5eMQVGyLrUBqkq2jeunMMrJgGwnHNn6CFp8MA6HD dDHtmsof6K7uenEeu8jsTHMSxZ4NiLCzKm2JGBNIyib1HHRYAmIzWJ9ZfG9RNTBkqvneRN/X2aLQ NdSd66ADmyH+YrkYC3bXLTGs8bUHkOUa1V3gIqKDpMXXkcH1XDSzU+xHkY8+FyNxxG5uJgpAYgW8 3JZdsjSVGAO6onMEVgswt1pOoqKr74C0A4fCBjlWUyj0ov3WkjXFij12bTHxMBU/ku54ya6vm3ok ZSZqpZZgs8KhHMufbOgZlpByo4VXQA1vNlmdyuwSWf0lXrJoFTmJAcR47VRGuXv2ZVen2SWrGy3R EdXu1ziGmv4zL4vff7w8sre0jadYRQL11nj9k1LG6w+NSvxI1qWNNO3SkLkzgFWQZ3kUAT5LBy+O HCMGuMwCbt7MpYm/Xql+z8B9leW4gSvw0LYJEseyCjKGPAkitz7hriMsm3PnOSz4iqWQusXLTFON 3iW6Yu7Omn+yi1TyZmQft2Ge8PgTHD1czajZcaB3s1gAwWdMLedZ3yCTWOxtNpkrGZ+Flse3Rxhb /gToyisFoykepEARRsIVPAenIrt0KMBVhOkBtU7LXP8sn6UkotmVI6CdsBjUeaGXWCqwL0O6cY0W 3SoQBGcNoHIYvGlXZr5Ko7kqRnWQAI/7qdImt2ilgHHc0QO/fcpy3D7eGB6i1hF89POLM6Nd2C2X ZxunkvWYQY1DjJr4aBbxGhc7BEOcOLiiYsI9e9UZnnzyfYK+Aw/oEPqhXkFKk7VWjDbqkmZy8eUM xoydtqAIklKGYwnPprZ4yB1g6IvhoH9Ej/X0EIpesAHMjEz6zlidJ/cEW1bs1k7/qs+CIYjtvdTf xahcyLAmGEJZ2mbFKDJkbyPlOgrPRuQDBtWBg4mPDLt7iOkAltaUdHMOHMdIKN1AKDf76xYsMSqI 2va9yRpEog3gQ+n7dCUYSMZvIZT0qs5PFsY3XJBbzsci9ao+WOEureoUV5TAJa7rBNic5/e7su8A p0RnvfCcHqNvvE+welE80T0Xu8YeK8WsWY2WFEasGl0YoyLUONTTEEanKNXDqdiWMGFL2ylloquy JR7RcKro+XphsFGG0Fl/MhpPletF/jJPVfuBbx9hQ+YHcWJb+7mxrTFo22zfpLsUV5Ay8asvv7RN qssSKA9+7cOqV8drR+us6cyhNgQ3NrKLLoLB2Pf1o8pMw/r9xJzE7Otcu6+5yTdqoyOzqJYK6sc6 QgZYkV1jzdOdI9WiZnnir+34eHCGVasv8KBUPTNV7ZDxNdpOL51UxiogysyJpD+OMgPb8gxhYdtq 0O4jZxaI5HXg4fTIobY83DCzT+9eoR8Y7FQq2ikLyAzBISuW1yEVEucvpAhpHvioNCGxaEc1FZGV nDOCeB8ooO6CgHAxyWOxYLqvgoIormYaglZmmzaBH6iHCQ3FXZRnJtVrbKZzkdyOHAMfLSyX2DGk JFXiO2jd4SLAi9wUw2Bvj1y8hgzD7p9lljjy0PJM2yOaMN0jsUtkjSW0NH3FN4RPhgtwhRG28c88 0rkBxQJ1Y1FAw8IOZ4vD9WclZVzodaDKo9ka66VBhRydSb7b1DDluk/HZFstCRNHUu0lAgWPYjxL CsUJnmPWubRtbZXtgrX7SVW7OA4SNGmK4Atm3d1HifqYuATSE5OLCe8qi4fXlCJBbEPU24EZAzey NaoIV3g6y9fbw5fCdssjsR3pCvbJyGM8saVhGIjqgSSeU41/PJ7wFr8emfZYA3JvdHjPtKvteCe/ 1aCB8NraUYmpOjPM5z6k8KZxKMJEvLpL0VOfykPwHYgEdRyF6OpknhglrNoFtO/RHWQW1EyIpuiE 6DZBodhbo/OGQVGDQXC16dJZYcFCT9FMqBid/uhkks55Fiyxp+nay6Iez3QMr7p5gNOwBBc5zMOc JDCq8VokwLhFkrD7us7GyBr4cLW6HKosAVrg6ZBjm8RVuik3uH94n9n08JmhQQFK0w7ltlTs5gsW TEbOXpD4G9QQuxE7ysC7fowTHEWUqMgs533kq3cLjFUE2ycB/q4B8NgiG8JS0h0qUsTANucG9D4t G7JP8/akYryQRgEVsngmUzlbCXyT90cW5ZQUlfastAgo8PXpOh564HV7+XKGt09as3uDqQRaHmmT woOxw3FksbY0BAof4BmCo60+fQqvklqzInn/aSZj9AB7Ksw9B0lGclY32mTM41jmBXvaVS85/QEG 1Eq06/y4GYcva+vj09fb67p6evnx5/hc4tzYPOXjupIm/UxTr3MkOvRwQXtYtbnmDGl+tDpIcQ5+ Pq3Lhj1U2ezkIKScYzg0cpVYnnVRe+C/pQYCB4TdMMIzgJesUq45OHpqFB8xlsPmsIXIDwj1WKdV Je4xRc9gLSgN48c5tqPRvno3Qe/ISVtTYOnnT/98+rg+r4ajmTJ0c61Ea2WU9Ew7IO3gJdK/u6EM idhsvN3Vp7EBLSCOFilYGK1L1RIC4SvQtQbYDxX6sLqoFVJuedpP17G8kiIk8O9Pzx+3t9vX1fWd pvZ8e/yA/3+s/mfLgNU3+eP/0ZsYFrN57rGET7d/PF6/mW82MdGKDTNtuGiA/PKiyrQjVMJVSXUQ qgcDVqDh6ISWu1iWThWjQu6Ux2VTNPdI3vwZBD07AXVlikl2M0c+ZMSRXYRnqBjamuDpQpDxzvJm 4cz1WwFhOn77jKvyHCfYZLhjxsx3R/PMsFVXYmmbMkvxItdpj6vwJZY+AY8bPGzJzNacYvSSb+Zo j4FsXq4Asn2uBlzQb7o085zIgkS+OdIk0GIrP3ORYo2K/hJHk9D8ZV2qjp1RiHbFeWNFfsMLDX8F qDGhzuOiSTMoWEobO5TrPHhdAQqt2bqBpYnuE1njpQGZpaj3if/JECPDneOiQ4kiruvjecIaJNu0 S9Ch6aoDwSB6vvTxcg6tFv0Z5Tl0tvelJa5jHPi48cPMdMwc3/KEp8REVwDstD5znMuevRSblQNW 3S+ZfzaW0+6EX8CILYIus/jzhZvLl94PlaC/fDO4OxUbWlCN7HmyapgnToHhOO5j6cv1+fWfv36d N1UIRGJsa0L6OjjKJYhMHeU8XbZAk2O7PGyIylozUtNt4viYqnRiaB5IIUldE/0QhvLpc6J/CR15 xRvpWUGP4w5WhCJzQ+w+YMRhc3XNBOtz5bou2ZoI/ZfcPWBZfcld32aTWxP+cY+9zgwJbLzMExZd 3UWJHYeh+q0O8KSEG5ZKUs3foN9+uioj4+elcUGF51gd4jKdjQyrvC540oqk1gRoOS33YDkLhsVF UvtxuK3Ba3h+F5LV9fH12ze4HGMyn+3wMhz1OPHZA7+e25Z9LSKXa1K+px3wZzpyFGJ0evJoO/2c wpC85gJ+uUPTm44Tlk5fGA7aUIChRsq0aS91PihPhNNCzydQbjSJNTWwTacozqUvFPMhi70vVCnv C3EWSRVx2almuybDb11hPwfKjPXWOGmOsDBhU6zUOEdfNAVJCc3lYBZjBLcZrjKB5l5qNH5iqbNf CR3BKxjf4lEH2XcdugQGOJ3+5rFOiTXHSdeXx6fn5+vbX/opKP3x9emVTt7HV4gr9bfV97dXOovf IUg0hHX+9vSnkvE49NNDLt/kCXKeRmvfONFTchKvHYNcwFvmqlgiIaiRmhgspPMVIwOxMxLfd2Iz uYxQeRfbM2a48r3UKF919D0nLTPP35iJHvLU9de4FME5TnUcRfZsAZYdMIWWo/MiUndnY0y2zcNl M2wvHJs6/L/rPtbTfU4mRr1DSZqGY7xBkbLCPit05CRMBYwe4BbBfb1qQF7HyBYBQOhgrlEzHquu qgoAmkXrx5shdo3Wp8QgRIhhaGZyRxzXw60QxSilcgCtQIjZTE2tHrmuMY452RgC7JKXzi8bXShS 9bl07ALXYlMicaAXaxMeKcE7BPnkxXIgrZGaJI5ZRKAaDQtUs/bH7uxzP3dp0MFYvipD3Rx+rNki 7CQj5vnZC+K1EkdQG9FShrcX60SJeLhUkxwb4jQb8ZFRRU5Guf21j49nH3VHmfFAvjFTyKqCfYQS P042Bvkujl1kJg57Env65anShlN7SW349I2uRv++fbu9fKzgaS2jMQ9dHq4d30WkOw7p9qlKlmby 84b2K2ehctz3N7ocgqXTWAJz1IRR4O3xV3qWE+MxJ/N+9fHjhcqJcw5jtEcN4vvx0/vjjW7FL7fX H++rP27P36VP9VaPfHMy1YGneNJzKqIxJ8OlLrsyF1qbUUSw589b5/rt9nalzfBCdxHraY/Kyw3c PlRGpnWZdp1AtLbel0GA6UREDeqz567NrxgdNxmZGQLsRDbDkSVd9KZ+gn318nCmo8Y6HG6PXmjK OkANjO0GqDHKay4l7TEIVYdcib5UHAoby1V7DLUYsTO3JVKvxLCcW4IUPfICY3WiVMVUaqKizReF 5jIKKeBNEscL46w9JpaWTPDoFiPs+nFgaDiOJAw9ZHTVQ1I7qLpTwk1ZGciu6gI5AZ2DBuCc8MFx 8A8H110SVCnH0UGteSQcLerRNXcd0ju+02W+0V1N2zaOO0J6GYK6rXCduThV5WlWL5wJ+t+CdWMW JrgLU2R7YXTcWGViWBfZzi5NUIZgk27x5U+nFkNc3BlDhwRZ5NdKfGB88WXrckVp2At544YexAut k95FfhSY7ZCfksjFjaNnhhA3RJ0YYie6HC1P8SilZsXePl/f/7DuKzlYuiEiEFjEo1dWExyuQ7kl 1Wym6NDafqvlsiNuqLvFSZGbzc2SH64BS+cz+mwccc69OHb4C1X9EU0XSUHVUI1X0jzhH+8fr9+e /u8N1HBMtFAylL6AVyg79ElrmYkezV3xKgiaCMVjzxLg0OBDZW8zN9W8VsOTOEZ9TGSuIg0iWcNq ghEO1qR0HMuH9eA5iuehhik+Yzrm22pEUS/EA59rbK7F6URmux9cB42qITOdtRs0FQsUMzgVWzuO dSDU54p+GtgVqTJbhJmhcDxbr0lsiUmgMKZU6AstToDGkLKEtZcZt5njWG4oDTZMI20w+ZYByAvk 2VqgWOMBTNT0qTxrG29x3JOQpmFt4+GQJrjkoS4PnhtY5kk5JK5vmQs93WYMQ6ap833H7be2gt3X bu7SprNozQzWDa3lGl00sWVQXh/fb0xvun17ffmgn0zKTub78v5xffl6ffu6+un9+kFPQk8ft59X v0usojygpyXDxokTSXAXRAgYoxOPTuL8iRD1WydKDF0XYQ0VaYpZ1dDpdJ5fw1FL/8ie4PvfK7pn 0GPpx9sT3MRY6pH35zs16XEtzrxcUaWzspT63JPL1MTxOvK0gjKiP5aUkn4h/037Zmdv7eoNxIiy tSvLYfBd40bwS0X7wcdE/RnVOy/Yu2sP6TxPfW5l7Gh8tk4fmWODdS42NozLRNg0DRWH1kWOY3k3 4/9RdmVNbtvK+q+ozsOt5CEViZQ0mnsrDyAJichwMwFq8Qtr4oydqTgzrvGkzvG/v93gIiyNcc6D a6yvGyCWBtAAGt1TBlHAtzbSj1yuzuS5kU49jvVstSTKpolD97xZQigAtewPebBxnFiJhkxDnTZQ byiJcFsVpNS+WdQflbD8hboskzFRVwyMxIIFGnpBKy2zbKvFD/9k1MkGtBm31Ih5pYYKRjdBSRuo nvRrUY6pxWoc8t7ALrbrmx21Mlwralp2I1qd1ZZqMxVvQl/GcRfbSrwukEiw9Uv6vtbkoM0fRo4b 5AjVeSA7d5uA3i7d+XqsrTfmebp6c8THW082QcmPlq4hLKLrlWsfq2/Ue9udnm4yfdGPxpA15TFg znG3NMUwHRcBWwC9KYDeGF4bwXZQZuChmWOY+W6mojAloSTV88vrHwsG+9fHD/dPP989vzzcPy3U dZj8nOoFK1PH4IABYYuWS0cC63azityVEcHh9YJV8CSFfSKpImvxP2Qqjt38R3TjDZYDrIJBUcCx t3Qmf9btNlFEYb1zcW5Qjmval9L8FVtrHeKHyeyfT0K30cobDztvPOhJMFrOJhD6E/Ya/j//1XdV ip5pKD1hHc8qzWQMZGS4eH76/G1U6n5uisKVaIDC65FetaB+MGEHZf7KczuPJsnTyRh6OjNYfHx+ GRQZT5WKb8+XXz1xqZI8CilNmuhIC2CN2zUa86QaH6yuycg9M9XNaAAdHQr38rEr/HJ3KAjZBzhg QKxzUglsRGL6YGCcQbbbzX+CdHGONstNyHRJb3IiT0a18ZdTgbxuOxkzd5pNaxV5s2zOCyc+zCBc g7WPACl++Xj/4WHxA682yyha/WgayHvOvKZJeXl7635INvQhUnB7Yp8G+cYaupyHl/svfzx+IGKL DwFC0RWafXtn4miVxE8sNHrIAJSA6iskUJyMF4OIHjAkO7pf40VjLXJAuyulTRtWCfjC9dTvesNm wGYmGEyyP7VC8TE0llnU/sz9uGX7l/u/Hha//f3xI/RW5p4v7qGzygx9pV8LC5h+XXUxIeP/oxlX DxvTzEqVwr+9KIqWm1GiR0JaNxdIxTyCKNmBJ4Wwk8iLpPNCApkXEsy85pbBUtUtF4eq5xVspil/ pdMXLaOyPZr/7Xnb8qw3zXoAx9YvxCG3y4ZBjMb+tbNRotDFUkI7L/Q75g/Yu/77/oVwjgepQRjS Is2cOnWgxFDvy4BUN7xCizrpJJGrTD/EDjRADhVIoKQ9urSz27aUabc/uyXIKEeO2KUJDIWzWm/M qWqPrzm0mwszGxBZoODrpX1bVwo6iByI2LhcAUdd0v5hsJCho12kSVQlrTBm5MDQPZPcf/jz8+On P15hbYemmB6BefML0ManKVB+YZrmIaVY70FZXEfKvKvWhFJGu/iwt3UrTVHHeLN8R83/SBaFuI3M y8EJjM1NIIIqq6N1aWPHwyGCfRFbu1+lQu1aDKyU8fZ2fyAt98cabZaru71b0/y8i83TNMRqVcZR ZLp1nMdSoDGv9OGJuAfrt6WngmcU0fXseaWwDF/5O8F/LCKpLV158HolXpI10aRbOuui2W02tBJx ZZoebn+HbfCx8h2mQAQqo0THTbS8KRqqJkm2XZmW4Ma32/ScVlWgkm6Ul3HUfWdsTV/RF0/0dJpn +p3+qKM8fX2G3dPvj1+/fL6fFAN/pGZdWV60s5zadJxqwfC36MpK/rJb0vS2Pslfos08q7Ss5Em3 3+OJ0JzzdULyyWNUrr5pYZ1qL9RMRSRqa8XQDNuYScmsx4VKsTteH8d3wJOC9XYzzcOzPhirHP7C KCrdGZaFyvL4apCOB/qMyGBJi05FozHAWCBPZ5uSybqrTJ/E+LPH14+2gbiNQ4NymDqEGWPGyqVC n2ulqZAh1KSlB/S8cBLmp4w3NiT5O2+SQrxlp1JkwgZ/tUKYTsj4mNF6yiiHKvGyK2ywFGfo6doO 8DgVGGCi+ScqUe28nUArL/s9aiDL6al5XWTja2Pze22d9mZEewSP6PBRck3cexW4UkWl7gIfnezu 7eLqgGZjevopyNgE57argi+gkSlVRX9khcicYaYLOMTT9fq/AwWLgIcZI8A99qCTYuwOHMCsK5TP gCLV8yOvAjQfBTXLJ5RNt16u+s6KIqpbcn56YDcw1iTQYqyoa2dM0N9UDTu6kDQjTQ9FbgUr+m61 3ViutudCe2IPIliyKjqvvd1Onv2kjRONNwEo8hlzxkDG8L05fDjFlUr6VL1H9OFpNrDKgwSYgTQQ aDFkGYZ8wt3pxKYNYVJX/hca9CIO8yp6cA4KPDKmkEGK4ZML59EfyTd4bqCqNNClOJRMcdJlu8V4 FCycCy7a/6DQqWhbOiCLzYbPrZk7IAw6W1q3TT7VtNuiqLC1J3pp5NBXsm+1WLzckKFLbMnz8x8D 1uq4y+N0sLwumrNs+8VquZ8Z1GCUFp8Gs92hQqcPpbmvnYuBslPUWJP3/Jft2q5oyFEo0jpJX2Po dDV9gYE0vQsk9n/DmBaZr9HlVoxLkV2j0aqWVweVW1RYma+/Oy/ttUOGY88vDx/wyBU/TJiWYQq2 Bk0uJ+ujyWnaqbpLKUf7A73tznYZNNTv9w7aNLZaOYOC8vmoqdJ8Q6yRDjvUaS5e3InKxVTdDEWw vpeIQ4IdRAVQQHqag+p5cVOluYBf1BKiqbWO4mgXIK27A3OwkqUgjBcbBG0iE3f84lTUH5kabaKQ pacmQ+Moge5BExi21I5Pc128ENsIg2Qd6qoVkjp3QAZeSq9TecEqF+Gp+WRywGoHeA81dgW3TETr SvO+dbI6FHUralcs8hoXCKtGGnE62qrvQW13cUjyoHha6O3P3F24DXQpLDiWL3kAT7BamToFYkfB T+iqwGE9XNpJU7PKJlKW0aqgpqow7VeWkK6akKZOosrd/rrjlRQwy9QOXqROFHAN8swFqvrodC42 CU4pbqUmvM9oJx4WD/xo6NeVM0ugb5HedmVS8IZl0Vtch9v1kp4KkHrKOS98iS8ZdHgJEshdvMBD PRe8aBdCNgp7Wz3W3AaCPUtby3pPuSXRdFxVWu5NT7DLUsKboy2WSugFiTo70WQl7CJWqjVfHSME miq/s6EGFBeYMGFIWie6BvzWAGx4Be1YhWrbcMWKS+WsLQ3MxMMBsg9aZ/smThxxm+RgfrY+rSkw 32E3i9SbP/VRCHUePXQ5pMockYF9ZMqUmw+sJbSyOxD1y2U7H3w6ah4oVBdPanWsYvRT4cCKs9Ir gELBBy2CU+qr5pjde1gJWzKWsp7nWs4rJoWxDZkhYpWWJWztfq0v+JHQXCbcaQfmXMnd+UnlMLd5 NVQ5qOZq2A8H8u9Q0eobGdv5ddH+PW+dL5+YE1JHg0KUtQqtpWcBsm/ngvm6rTphbw2j95cMFK6a ugrSbanDPPV554yNEU+hIdBjqP7laWdFIKKjnnVAGfGiOU629ITaqfVO1KpJJRgdVAzKrD2oRNiR E9AzTtvcu58ZDB6ilP42EOZvjxl4vPPOxczVKEydp6LHa7GCj1dzhpZueRAzwME3hVlnRNHdHE6/ RIciuSsa0Seucx34b+U439bOT1pcS5nsc3OOs3yFDD5VKpiJU95X/DSeB852IvZzQmzZq7sMq9zj Pq/HM24hQ761ws7idDOqULWBonXlLlUF5G6XHydq3WYHji7lE7+ptcvIDqZBfeBWsMsvkUkeuuEq os9fX/GoeTINyNyrTN3k25vzcjm2rFWLMwpDnlKGXtq/zEi2S6jRtq4VjtVeKYKqFHaQhE0KlXYv CyqNffoz44PvC4KQG/doXvecu2i1zBu3chaTkM1qtT2/ybOH7oSc3mgkHaE0WvntVJOtV4fqVH+v Th2ekbxVVlnsVqs3Stru0BLm9sYvFH7Wjmg3odpnZzloBLPUDTe3i/Tz/dev/u25luLU8fGkT5tN LR3BU+ZwqXI+EKhgTfrfxeA1qgYtlC9+f/iCJiqL56eFTKVY/Pb36yIp7nAa6GW2+Ov+22Rcf//5 6/Pit4fF08PD7w+//x+0w4OVU/7w+Ys2qvrr+eVh8fj08dku/cjndsAIBw+2TZ7xKPBavRHQ47vx +nbOmim2Z/SBjsm3B6UEJuXvFELIzIpAa9Lg/7ZKZxJllrVL+qGzy7ahX8aYbL92ZSPzOjTRTmys YF3muTGcqHXFQ6c7Jtsda10xnkiTTyRo4jShWXgFDZNsnWdoevAx3zMODgXx1/2nx6dPtIvNMkt3 Sy8rvXuiNWcgi8Y5WxywIzWZXHF9Pi9/2RHECnQq2ASsbBJaYrl5eZc+evHIKkmb3eu66Hkia+lj Rr2MntJwciCGHMilOToM4E5fTqhf/iuplGWAIspzgOIdD0/rw812SYL+HDoTMAxoO9xMz2KCahg9 U3ZS3kTuGNW3MxRG3Xob1LEaoTEyMA02O4EcmGhTlpAmPSZXexfD0hnIYzjnDE8LY03yeB3ywTmy nHLYYeacKbIp0Ks1nvrygvtq1PSRBhZv1wvhSBqng3IXqAYvac9dBsteZQLasyY/cBSybkmKaNg7 mkDz8+zAXZfaBBn2mt8p7m4VmbcwNmkT0w11gClVuLuEqSInGu86Esfj44ZVfUPM8xbH2/W4K6QI pUdrul4GPeaObGWqYIscaAtt9UZTankTGK0DbbXpG9YGxRF5dmtvRZio5853je6zVexYfq+FmiKy /LUYpFqJreU9wqC9S1lHC8G7jhW4CwwUXTZpsztTduEmE9uHph0kQcvBPjmkvM6TF29bdhItjHrX cfXEcimTmp49VUhs0kvCWzQSefvrZ5gda9d76ThXnZi3QZ5aXLt0fDvnuqwEaDh0j0H61N9+T2XC I5G+/K7YnITMk7qiT+TN5pMd/e7IlAZFj5yuyW52++VNTA+RScGYl0V7y06uj7wUW8/XM4BRyKUx yzrlC/FR8oONFfxQK/vmQMP+LnlaKdLLTUrGIh6YdDhyN63I9BF8IJFeP8arKSuZvm7MQKUoGHWb p8l9uYe9NJMqzVl74E6NhYQ/x4M/z04EVCUCxSq8JlAtq1J+FEmLkUUCyUR9Ym0r3EUPt5Du9l1y NWwt9+KsOkfdBVUKz8D3ztpyAT6nX/l73YpnRxrxXAL+RpvVOXFrkkuR4n/iTeDtv8m0pp3+6TZC X8rQO9rTg6+LsloON4ezrDd/fPv6+OH+86K4/0Y94sB0TW6cj1ejO9xzyoXrfb8RtRMbSbH8qL0m mxWewUErTS7T2VeoB0GHjV0n48PTDatoWnEtTGO0CdEXiLOuYpxyBqpvt/uBgSpDFU5dGtN1nP7Z q9QMLTVjqXDBVq1uVqvchfcoBqY7wQHuUvOJCf7q0/TgcuVZLOXoHtAugQ4htDubfa++fXn4KR2e zX/5/PCfh5efswfj10L++/H1wx/EcxqdJcalaESsi7uJI7dp/9vc3WIxDC7xdP/6sCiffyeeQwyF yBrYoavSuhwaKNVR6Hg0M5UqXeAj1vkUGtXKk1DmdXZpxr1uTi0a23EKnLc114R9UtSmJegMTYe6 835Ze7C17fSQeRzZhh/cwRVu+Nh1FmdMToQHMaigVsMfMnotUGWWm4I8Qz36koZNj5TOqfSVoynU njoa0hyNk6kqIUMnWvaQkyByF/rJTlYyMlLuxKOP+ipc8IHRzjc7ub+H4npoUnR8LyzT4JHiHp6O cC7im9tderROvEbaXezULsc/Ym+jxw4ffdtYJ/PURaCKW5BVh3M64OvMOwskpO+8nszlOxsolSOm 9cnQYEteSlABLbuRCfOFbHQH9dfzyzf5+vjhT39Az2m7SiveoN10pSkAsmnrefBcPykH7M2PffdG Yv442WB4r2PfZusrEydMzRXrHbMFg6KtDdK6sK8LNUPSooJRoVKXn3C1rg7cN4LD9xRe2+n0jKlV ZHq+HNAKVpPNLXNhGW/XGw89RZbnnqFcabmN7VC8V5x0LDnUd4w2aWHtcokvttcOzovVJlrG1otW TdCRvkkw8sqjnZxRJ3cz9TY6k6mWK/oVjmYYAnWGssWwmxtzy26i05WinaH7CscpTxPfrin9bqZu 3K8VzWajg6qO96EuzXz8fAVjvykA3oYbsNlZoV4mcLd1+0fX3gw7bKJ0myBxG1P2H5o8hTpXTHXu iHPDEGowY+kqWsul6Sh0+JD5ckwjRCzvQbyzyIpwO9RXxZtbd4Bco9balVIpw9iToUqpIt3cOi5a hvyIYME+/ZboQBgY9qNyKxmv9tEqMbUUjd+pLNreujUVMl7ti3h16/bjSIiujpeuU5K+v/rt8+PT nz+shrAX7SFZjE/A/n76HdU+37hh8cPV2ORHU10Z+gE3NZTmoKmw8qee0JfFuTV31hrEWOkOhI4H k4viDqwEtGQXGE84jdy4+RzKeLVemu2hXh4/ffLn6PGWXfqyMl6/6zcg4dlhYqthmXAur2hG2K5T x0cWT6myYHlyDvpnwhm1/7EYCSsxi542XYDCUiWOQl2CZXh7wpxrOhpQ1P7T98cvr+hb5evideiV qzRWD69DfDt0ZfDx8dPiB+y81/uXTw+vP9J9p48dpLCe4dg11SEyg7VpWEVehlhMFVfWkzAnB7Rw dyVzbs4x9MT89UExF4kooJGJD3OYLH0LG0TtX3g4xdILDjnzcZcmOSFRBnY8h5CgBHCHcMYbIbOE Gn1HXx0P2Zfpxom1rdJBoyKSgIJ/tcLxMP9G0aAdacUVOHyXCUxeKtiqnHte4eWU1tgqXnibRQxE w6uD5VoBsfER/JTOLmxfW3Z9qJS2eIt4wKIQZ29lgu7Gl3acCNDQeplgINWAIRjsQthZhLZOe4nX OObNNSLvBmTOA/dVBR4psi2lttzFvZOgPPZnDEJMaRqww+itLzZFHC9tSB/9RMueNYmb9UBaAY1u Ji15bqIzRkY894EUA/H9pXpXNnY5HFLjZKsfoyesDGSsyTk2W18eSmPgXQmGQJx0Hzlb4hG9AnLf N1a6KdaODaLrEDvhxKevvy0KrIXQg53dATPWH2BDPAx0l9xIUdiCkzWMRZP4zMMq/fz48PRqnVLM A8tpOXPA4iEIPfTHsaaF3vhQ0u39SFX6Q3thntDIk0avQDcktkYnBqQt6yO/+kcxy4ZUyYs9ljEw PyELLK2NJJJqHGdZxWmn0U5t5jmgO4+H82amebZe3+xoT0SixMZOhcALBtpUVa22dzG1+xlvFHE5 40ZH65/zdePSgdtaN/bGhoetLuinUjLzymCgJmjUN9H+9a+JiPcL2jq9gKnSmitNCn3hb3DonTpZ PataYwpDKqz7dVHDwGuPaOog2nc2IcO4XTPherKMadpOhpy6Q9O+ETEMyHZ8KfyNGn7ngUcYdx7Y QKHM0oxwgs/9yBuYkUE/T/W/W1KF0Wd4g0+h3luPnVLpmwBRqyJxwVaYBvtH28RmYBmrfa2MRitO q8cDVRvrEdXUxKN0DplGGMr8Rpb4/ESO5sujruQfSj1+eHn++vzxdZF/+/Lw8tNx8envh6+vxhm7 EYjkbVbNe354Cvq6wLeUY4cai9YV1LHz2ksP+4imsDUi5JJp2yUwDg5aZQpd0CAn2jryI+g83nfS O276XwDQfvqPXLDcgUI70MjW1YW5yD6/NLzV9iuBcsC/BK39x/ejdmEOla1Raww0ee17ob/GFvfJ JRvIxFdB1UOZRW47ZxQvsv5oc3qEUWGDaH/ZnwumrIsKonOnRIeWX6ybthHouTQfNCt2sIYPtDU3 3+YPv13tfUaHDZVezsR73t8lv0TL9e4NtpKdTc6lw1oKmVJuBkZyUgecPo30wJo/Uj0TlxEXkr3x zSYtbsjYHgbdjl9iEqjrfoNunlxe4d0qouEtDe/Ir5cxlOut1mJlU0BrizpaLrERwkUdOJs0irfI 6JVipm9jkg7T/W7pV1XDflVhP0eicrUtV0RVgbLcvV0BnZhOuiOtRox0ji3slbJdL6kdysSgot2S LC4Q3hIoTV/79Ud4Q8M3JGyfZU+Esowj8rBmZNgXG0L8GN7fiXoV9ZSwIVWItu5JBz/TMEOh/P/K nmy5cWPXX3Hl6Zyq5MSSJVl6mAeKpCSOuImLLfuF5djKjCpje0q275ncr79ANxegG63JTVXiCEA3 e28AjSUaX259q3Z/tkezyMxCJLmvkwMZ3wt2o/HSAqeAqRoQ76bSjLVYyUeTUiRcN2KgRrOzBxCQ xd4y983VKOxOTzIZG9CBJx4Cidw8QNQOFVg3kvistJP49JagnI7t40WJe86jMagWczHXwzAaUMFs Km4DwAS1pM9neDQUchZWAUfOdfom2c4vxSCGLcF8PLVX15zl9SbARjjatvpvHNnLkZya0lKthPWe ootS3cZ+HPQhq6BJb8RcnO0F3ljhDLT5y00g2XB1SWK155IOLvrydHo9PlHd1caQACJTVuoCkLZF B8quUcvMK6RVvgYWLF97KLcRSSiNgIcrcxrVAeNhrirzd+Otk9F4NtnCWWXhlsFsdjW5nlgIjDA4 uVymMuI6EOHTKzOWZo+5lnrWEmCkxdHsyqrSisDI4FMZzg1vGUYO50dIJmKwekYwE2rP/WA+Fd8Y W4LCm8+v7faWs+By7I2EGgEzGpnerAZJmMMZJPvldCSb0ehSTufQUZTBaDxfuFuuw3sKTVfwmQy/ EruEmOmZ8S2r6+uraSEVBcx8cXOuI3AG3MWiT1xHEGNK0YlQe+2PZo5IjwPFtZjgpsPnAVRxfWnv olv1spBVPGxup7uTjYaU6AsyXJaGqaju2pbQGrIrOlEFD4iCu353qC60sHS6tCQsdk8HNB6gejCP azWAs3wpm1d3JEYUjw6swwhZFZ4xRe07XUTBOgy45WKHNJ/GOzj6U59p4604hsomzF2K2Vx1QG5s 1kO5/WYeTbhGUEfffnj76/AuhbA2ML3cG8X4+ICTvaIxldG8Cr/KpPVNgpYs2JqSe29j7NEWg7bD sKDimMc0xKJK8ehSCK2zOFhFpRz+Ay9nVOw0oexN5m9gCYe9e6ycACyOvTTbUx/aDqUeqokGhsMp C7HBYGB+TCyy4AeqLmAVb+vcJsToXXDdEn2qftA2KulhQ4BcrYv/9tpbaalnfYxEXhz+PJwOL48H mM234xeqSo98g5WDGst8LiabQNxNuNcG7FnpU6XHP/wu/9CmDLYuTrHrnraamDtEGEIFt+ZUHKBN NGNmLQRV+knkQOQORDSFG96JmppMNUGOpKubk0wmrpqvTeGpwy2T0dzxTkCo/MAPrx2XtEG2ENM9 UCKVw6Dxc7GteO2UXuQahnGSl45rEPG7rIh2TmyMeWbmKkFzIIaKIF+yXqsJDo7e84VvfHkpLYPr 0XxvSvB916N9G5PPsXnQZCJLS3O/4etpOTUTkZsEciKlHr2wFCLD+odlOfNvrlw6FUa4cOyhq9ns 0om6dqJsM1q+M5nROxwsITDyEbWZL6t6KRITBG9bBWKzH7Xn5SB69VC8Vpbo9p4lzepWHPQqai2U kN71CrwOSqI0UaAiT3xf7OrOiJajyL3plZH3hWLVisn9Ep2Q5wuqZqRoX6MXErrI7W+qXZgEiDv3 YUATWwgv3zVr+NT8cj7h0CSxwBGAvRyuCJZHvYfOLkdzDsaaJ5c8K3kHR2qhnVHfoNmeVxaLUE3L 86XDuGn4TMyH1KPZ0A9QmoJvgPJ49AiPW7j0iUAXW8yoDhGh8QBllenhdtTWN4IK2qSUCdbEC3lQ YEXJnNVQ3xmKtgpHAlMkyOufkXRfkeZ/B9tCLxvWenyniErcFHBOS2MEBOsWa5SLc68NRy6UpoS6 5ecoEqjoHF5pes60Eebf91TnJ2RZlO1iYWcdjkNV42NrOxQEvpuVJQYEZYiuFrtqPSETtuQQ0bUW UI7GtkNuVamGVKi0bcFINJXtsEbcjGHJuItpvFkwT6Imx+BLyHhHUm4Obbqz0sdVX3CLh9Xel0Q4 dUBq2xvG12NUnOvriTcSoIupBGR36gAVK7gWaecidCFDzTYsvMvZ+pLawSswWhoB+3QFPN5aQKE7 JPxC36eSWVsMw4IlcR8UMhbmgWtfe/7QDPWnHXTQv2k24ZLQYIbYktQBbmBkUEVTCK17RXyw4jO9 uQWpOhW9UbRYU75+nB4lZzYV+T0jRkYaohgM1vOy8A1zC2TajOj+uoUGEHquA5pZUf85Bp/yMXay J13rBmmWxc1tVmy9ok3XwJRG6BRf1VDg8nI+nUubHjm0GN3Ie9rRDHN4j6ijgZ6yjgBqYhn7sEW6 MSBtsgPqruysWkv0rfKpkZ2JrBJiOFN23eNFOqimHW4YjJyDMVuaPKpmEyNMEpNqjenvr1AvipfZ nvcp2ZAWdZoDE3o1vmwSVjRLvHysgh7acAVqtqhv0RG9x9MZWQWtiSnQSIs+6mywoLkp/GGxbZFv Nj6ouWwD2PbUcE7WLCwyqFHOjDDa/Gxl7mqVtucs4yhB3zD+LVUrVEjY6Ai2fQ3/vfFMGNQQVQqj Q6InzLx7KEewC/p2gvh2PVlbvzg8v74fvp9eH6Ug4kWIgS4xK4a4cITCutLvz29f7IMEuO2S6ToV QJmvCcOnkVoG4eFNTUwrATBsb4Q2NJY1ilydeDpgeAxrbDAW/L/Kv9/eD88X2cuF//X4/d8Xb+gi 8ufx0XbTw7MuBz4BVnOUllZ2PY7uNFne87fXL1Bb+eqzCegeuAS0LgftODw5i9lYnTPs9Prw9Pj6 bJTrR8JvloWflNWSDpxYSEec2+e/r06Hw9vjw7fDxe71FO3kmjstPdGkthAMy+5vmR0Qopawj42N yMA8r4uy/CYl2EG/o2XklwlGVVaeQ926qyNgvbQFr8MiHZ1nWaRObVfskxhU7aj+bOy0b8h/kr1r ji2cQu4+Hr7BXJkzbEjkaAu4S3IXl4gciIfRNJfGiYWWok3JFE4aXi4lg0WFi2PfVCBsi7usicfM K5viM1+//1JYHhR2li2F2QHrK2OKpFqha5lZFxf7e1AeWB0DcC49hClkq2Awarr1U+TQqiK2LhGW 7kqcKboVLd5b8TY922rCB6ac8E49YilrIwmFL0tyhCKUnu0G/IKLJBTxk4JUPqBgR2cWM4ldI/hr ub65DF44wFTOuwOB1hZ7BrBMzDpGwXId1zL1XAYvHGDSkgJNlH1q1aAJOQhTqDgEEh3tzwLnlCHt YeRqo6Op+SSMxFpmvohDn5iSW7jSkvOZMysLJVtMTDLSQU2zYqH9CTzObvmGHXB5YjZ6e9V4yUzo DSA+X49HIUepqmiAFa2ilcZLO6egnsPzLTcXqCdK6WNkW1GUVuh7FbXVdYzF/vjt+PJDvo5b56Ab v6YHklSij/r9j1gh8gyb4BPpqgh3woSE+8ofgjKHP94fX1+6CLkWV6WJ4XL1FhO6E1o4j4vdAhNv P5pMr68lxNXVlOlpBoxyWxaXWUuTV+lU1su0BPpWQFUMGhMLXymq+eL6SjIWbQnKZDqlBqgtuItg RIQVZR7PpbI8Hl2Pm4StWGRKopXgTVXkOpqHIc8k8kaLxNce5q8OP0zvSwQtwyKOWLQuhGKzVpUk xCN2Ey1vKl5NtCtnY5rFFIHKMZ++hyKQn24K0na5ymuzHe3B52iHEWBbgaJQR45g1QB0UxjvbTow fbG7eITNIkSmL3Z4uvIZZAlnWkBDOYwOBsu1SYshRG0Hv7myaW+umqgqXfCWbSVomBnaDHTDzJdN 5Fc0vgpm7PIa5k/UDTP2bIDGJS5iRph7IJvhGyHGk/f5pLS8nnSOD+ddYY8ePQwH5BD035yHfhpy zHPJrDb6SJ2ZX9GYsn3Aff2A51ODjn4IzmP6zcChWubCXz79oMZqF9b1rQnvOXkmUQ8oYxANErQJ kIRujTQCQ2moHmL7a/0zovvdtXvyFJ9XO2T78Kn2Tb65uyg//nhTN86wabpsiNxAaQC2Ce8ZGsHW Mzk6H2+z1NNaXvyacAJAQUzWhMkTqqwomNaFItvvDScCwenom+JEMDIvvhFPWKBRR3iynyc7HvhH 93cPi4P2mlXf6rlqnvCOESjtmFXvJsIFCRO0tMYS1aKwKFMVJW/McXp9Q28qz2xKi3I3Jd8DJzhP ExVKkFfbo+wvJl6eb7I0xPdE6Mklx2Z+GGdo3lkE1L8PUa1ItptfziZig1sV3Q7fbM1mi4T4Hqtq Ok8J924oWyv2JLJoPqDbYbAL6kiM58qqgJZpDsd+mFRZczMWRqWL5+hEqclwNkAMe2ANlGm3B/hO tJXM+in+So2hq/SVWiU/rQJDA/IOtoJMkOvHQLP+Fq32miJwzmEnEUEjHc1o2Y6mXhmrskcIM6wZ tP25pQhyyXTSLnfHp7WEchvdDx9W6nd7a1UAGo1Hl/Qe5edyT42GqCygVkLzBcCPJs77PBX54fTn 6+n5AS3mnl9fju+vJ+ZiStgUXwlKteOtx/cZX6lYYCdxUNat3NoX0Ap6d5EyD/siXf/PtL2/Lb1B u2u5NqRBkfFcSC2oWUYp8FT4KHDe1aFjeAoP7o11XnP9Vhwt05sg4mGnu5wf6Fgt9DVFZ3OiX8ds 0zxROVLQtDVLboSdrZxVq7Y0PAlm4JGXkPSGtV/9NOUIfeqtcsMgu6VFeasMPJv53txevJ8eHjHZ hMV+lxWrCn7ie2aFXuZw8sk2DT0NPtDJ5rpI48xJDbgyqwuYNr/XB9u4PqgRbZ9mAquNuDSEfvbi X74mAkz7ipbjKjPCdVgo9axH5EioqEnWRU9oGGn3+Fa3ICMjP5xcOnCJ52/22VjAarN0q62Y0eU+ tLBtA3IMuuRndc7YcFVfEa6NxJywgAlGfiRAfLCS7NhWJXuLiLpUW03aBXclOJ2azgobZVOwtG4E 7qmEfxxV+jTGuoIsQ8N0HYCZb7xgSveT8taDUdurcdOBAUhkXOFNAYPtesH6ejGWWZ8WX44mlw47 qHrvGhBE9Y6HXfABoTn9VZQ0WU6TYkf02RV/NcSZoQPHUcJFQAC0TyFcLdjD03XQ4dgmLeD/01BM puBjRky2GCvk5TCEPw2Y2r/YV3BtwqXKg30nLMSE8m9RPFmQ0BEylGlqslbHb4cLfXET9Vrgw7YL 0U4iaJ9jaI9uvDgKvCqE1YNSeynmVARchCwE01qNGx5MoQU1e6+qpEoAf9WwyF0aALxFGcHy8WOj NoUsQ78uHIHD9tXErHByrsKJq0JO5EplpZDbOo10mHby4c/LgPFy+NtZDb5XLdWcUPE7gpFflaw7 PVA9oApwfLVvWo0xkdj7qpxT8bn70tBiOmzi0Hw+PxmINuI4qBKVV0UY2pb0a299HSG7OnPIVXtX 2wie+g3h7yxVcV9UEBERg84pUWE24tYr5Lth33VPduFZlbj0Rdyy0pMhsU5RrAuyG2TsIscmUL7K WOn9KkUrEHNralgb6DvLxeqjOGwQb/oHA/uKXmV3jEJuX5j6xV3eJsWWwHCzr3l3GTbSk6N+y1+4 CQsdq9EEmatvQCzrCO67FK6GderhWVtSqj6EVndcmoBIA4wAnivPjr3lXsIYYGVVTuR51Ui29fEZ y1gXvpwxo412RAtn0O/YuzPKD1BMYR0VcIM18EdsrkTrxbceMMWrLI6zW6EhpAyKOXupPU2K0703 0zYRgj2MthqQn7UrCSvPz3LpKIpgPYVoI4V67l5Q8x8evx6YwUp3BpO1qK9KPLTkDajxqDrLQFJn DJlGWYtQg7PlZxxDnvtUoXBPlRLMioozYOj3BxM/3T/d1+A3EKR+D24CxRNYLEFUZgtUChp3QBZH YqKJe6CnC6wOVl3R7uPyB3Xwu6z8feVVv4d7/G9ayU0CHFvESQnlGOTGJMHfXfQfH/hwjBX1aXJ1 LeGjDG3QyrD69Mvx7XU+ny5+G/1CZp6Q1tVK5mFVBxwneWVsYAWwIn0qaGG46nQM3blh0lqVt8PH 0+vFn9LwKVaAT6cCbVHQk/REiESdPn3yUcBc2VhmwOXwGPEKCVxrHBSh9A6wDYuUjoAh4FdJzpun AGfvdU2heBi7YISS10yOQLSp12EVL8WZSkLtUht6NO5y//CzjtZeWkV6GMjmU38GvqXTFdkzQu5N jDalNqwKpShzB2lYoQGzi66jotFZ4Ue3VtliJuhuNzSwG3jBHnPtxtDQCwwzp3HODczYiWFv8QZO Ck7OSWbOT1ITGwPjbAyNmmFgJk6MczhmM3fXZlKUCEayoIFbOMY5zosrV9cWk4WrmdxbDHFwnuOq aSSPJFZ2NHY2BVDGBKhQnq5PSfZhFG/0qwNfyeCJDJ7K4JkMvpbBCxk8unJ2TfKHZgRGu7ZZNG8K AVZzGIbchWuVZ0LrEH6ImTwcX9YEaRXWNGljjykykMoc1d4VURyfrXjthTF9OurhRUiTO3fgyMdk boGASOuoktqg+hyJ6Rw7EmDjtxHNcYIIvLlpfSCq43KVWMSsud3Rk5ypTrRp+OHx43R8/9uO2tuq ugcHK/gNfPKuRttixabJrzdhUQLjBrOCJdAETDrqq6IGmsDQp7cikgWHX02wAYEuLDzLJbuT1jEE bKme8qsi8h1abbdk36Hoba6CPABDFYQptAklI+TFdZxKz2AcLDJZ+QoyAUpZWkUu6ta9SiWgCwvM qGXa3otoDFW/+fTL729/HF9+/3g7nJ5fnw6/fT18+3449Rdmx/cNw+Ux45bk0y/oPfP0+t+XX/9+ eH749dvrw9P348uvbw9/HqCBx6dfjy/vhy+4WH794/ufv+j1sz2cXg7fLr4+nJ4OL6i4H9YRyQ90 cXw5vh8fvh3/9wGxhEVHNRN0CsT1NOOWDQqlRGkYbUfeAYsYVelO2k7rKjepQ7t71NsQmnumV7xk hdY9UCMlFf3aeKNQMODR/PzOhO5pihQNyncmBKNuz2Cp+xmJ3qL2TtYLgqe/v7+/XjximvvX04Ve DcPAa2LUUzAHBAYe2/DQC0SgTVpu/Sjf0LVrIOwiG5bOiQBt0oLFW+1hImHPRloNd7bEczV+m+c2 9Zbq6bsaMFiTTWp5dXE4U6+2qFpWVvOC6NSr0iMYKtuWar0ajedJHVuItI5loN30XP21wOqPsCjq ahPSAO/d7EeJTdznbdAC4Mcf346Pv/11+PviUS3iL6eH71//ttZuwSIJalhgL6DQt1sR+iJhEQhV wnF5E46nOtSGfgz/eP96eHk/Pj68H54uwhfVSjgILv57fP964b29vT4eFSp4eH+g70tdjb4Yz6Sd Kj+xm7CB69YbX+ZZfMcDr/VbcB2VI549zECpkXd/tgx3KtOoWTyED8PhyvywtQeW8rXEm+bNmhl/ aQ+5v1rasMreCb6wfEN/KTQtNlUMHJ2tJAOtfjELTdwLnwbW47bw7P2dbtyTgaHJqzqRRrMshaHc PLx9dY0kSxPRHYkaaFa+hz65e3yjC2ld1fHL4e3d/ljhX42FmUOwPVh78bhext42HNtTreH2+ELl 1egyoPkYu40g1u8c9SSYCLCpME5JBGtaGRs6go21x0uCURDdA4p4ZgTag8fTmQRmQSu7bbdh0Qd6 oFQFgHlU4R58JfSyTMQ4tS2yAj5pyeP1tahqXYwWYjxajb/NdSP0uXb8/pU5OfSHTilUDdCmkj0X O4q0XkaSvNDhC38iVAw8160ztly30DyMEBeJ8a07Ch1jkaUjIzh7zSF0JrRHNlprkSv5Ht1uvHuB uSq9uPSEhdNdCXYBbVNhLYewyEEmO7MkEnv/VKF9HVa32SoSNmYLHwZQL5DX5++nw9sbY/r7UVrF TD3Znev3mQWbTyTWKL4XY7T1yI19mN2XVZ+vpnh4eXp9vkg/nv84nC7Wh5fDyRBP+mWJiaBziekM iuXayAhCMRvp/NYY6XRTGOlWRIQF/BxhHNEQbfSpHEH4xta7WGIpEaUa4R7BnszJy/cU0tD0SFFq wE93r/pUYPl2/OP0AOLZ6fXj/fgiXIlxtGzPFwGuzwcb0V4/nYn9ORr7Ptda85tQUemNJ1agUeQb 1nrtic4sW6TpWc6zDWacqY0OHIPUXaHAQGN4isXZ7jrvW1bT+S53ZOeO52FoBjb3/CA5bsnNrb15 whvle+B7XuI64DlNOxLojBCWwgYmxOLxT+py2cdItJ+FjU/xSpsmzRmjitLqfJMVhbbiaqpNHHyC NfRTcozK0lLT7CRnR+9nY0PGeXeWL2ClPHV0uGIgSCXyrW/SnxvldP2TxrexEDwxeA+hbe3ni1Ri tJCgnEr+EYTAqxJM+zeWttaAD+WwVyYZ7pjLiSA0A4Xv2zJOC28C+/RWjc/PltI/3ZXivljZJxTi d77NFbRw7IRjLBDbJon0Ytm6S6burrfzY0gLCBeAJskS8SpEpJlNjI6ktwr3fhg7Oub7hWjgSkiU L1MZOpdJEmfoKbneSy/QrCVjqiXyyrskCVGfrnTw1V0eisi8XsYtTVkvW7LBLGggrPKEUklmbtPL ReOHqCaPfLTY1Oaaw2dhM5dzleAJsViZRHHdB1LqscMThcKrGClQXH4oiNaoy89DbQ2GJlaqOZGQ 99Y/nN7Re/zh/fCmYilj7OSH94/T4eLx6+Hxr+PLF5oLEV+/6fsHT71m40uSjq/FhvsKY6MNg2SV tyh0KKrJ5YLEooL1kqWBV9yZzZGHRNcMXBKmIC4rmbizlPkHY6KzODvZPa3jprrvDtIsw9QHzrog z3BoUOcVQJKumYOcZ8TkWUYg+mIqFjJmitlRbI+E7bwyQWZO/fxOB6LlVnKUJA5TBzYN0eomio0s MEUgPkPCAocLN62TJQsHox/AqHNt7zWKXsPcfFn1CW3s/CTf+5u1smoswpVBgRYhmCOms5iPeEC7 tg7YxCAIpVnVP8G1FFHa2s7l/Hjz0eupYpKuz7JvAYWt+/GbqKobXoqrn3yMwNEm/uTnncLAQRQu 72TbJkYiy46KwCtuuyxxDAHrQy40Y2IHF0J8msg8WtpaNp8E2DXVaphnutKT4OsUfpZEAGs+yBI+ KC0KxGZVrNDm8ASKLiUm/B7ZahDJuFR+r2UJAwpCulAzQqWalSwu0k/kloCULpArsES/v2+Y74H+ 3eznMwumXPxymzby6By2QI+mERhg1Qa2pYXAtDt2vUv/swXjkzR0qFneR/TRiGDie5apeEDs7x30 mQM+EeGtXsQ4U+hLd3eA0qTbS7Us0xIT1BZewg6FKixuvLhBTSPlGTD6C5wg6sQtPKK2wFMIzi/q Q7cxkyqrlN05tRIL4dYqNQJO3nW1MXAq87OXq4dz0xJO5ZwMgqKpmtlkGVX8OzA4sVegi9sm5C7z /aFZhlWd240a8PhWi+hVVrTJWX9GpaNImCSIxUQTQmPa5Ji87WmWdpRNwq4ExPaoPMtijipCi7o9 3DtMfyKq0csjp4BbruM+4Wd31OV1U/AP7OhNFmfsnQd/94eaaCXTGk121cf3TeWRoYiKHSofaLiP nGcZgx+rgIwm+q+i7xzc5GxpwnLt9sRNUGb2TlmHFUrI2SrwhIgOWEZL0PTiXGUwB208S9pvhIuG 2Ug//zE3apj/oLdqiTGUY7qYy7Ux0bDHes/BjgaWvzG/aEaTrsXx79k8i3vjNiEd76ug30/Hl/e/ Lh6g5NPz4e2LbXEELE9abdU4EQ5OA32PhyHxteMpJh2KgWOL+0f+ayfFro7C6tNkGAUtH1g1TMga v0s9jEXt9olhFI3DDBlYp2WGAlJYFEBOk8urYvAvMJ3LrGSBFZ0D1mvWj98Ov70fn1ue+k2RPmr4 yR7eVnhNanzm4L5WKzi8Q+UWxLQ7uARyOLPRjzlhbOsmxLg5aJ8MB6uYE0H3DEQM5fGSRGXiVfTq MDHq6+i2xGJBKTiscd3APFPXSmk2vIXTwfvHw6PTKqHu//jYrdzg8MfHly9o+xO9vL2fPp4PL+9k IBMPZWmQh2gsIALsDZD0iH+6/DGifkYDnQ7Q4xw8bknewdSheutUcfRkaBGiKBNU9J35SFtha39l yUTbNY2e2V9J9bL0MEBKGlWYi9ijp6zC0bZrYhBJJXWXRi4xem1p1NGFH2OwM99kYYWH1Fj/ZHbN EURD/zC2hP3WeKyvg5xeeJiA3B2mpeGUrTCwRsssdQnX+ptFFniV58rAPHADivh2bx4jFNJLhVVQ J+TC1b8NezQ12W234XKIQ28rzLgmuEmafF2pdW18XsKYhaOiqqnwqsFtinQ04hNXoKeXk4wADghu /TXVJPrqkxprP6BoLPoj4P2WZsN6Al7Q8BtWdZyzIhwWgraswJ8X2ev3t18v4tfHvz6+62Nn8/Dy hd508Ekf7RUzxjgyMPos1+EQGU0jFZNRV58uiUvN2W9qK184AZ8+8NgTFm4Jl0EwONh2Ro5CEXO9 YmO2YZgbq1ordtA8aNhq/3r7fnxBkyFo5PPH++HHAf7n8P74n//8599DU5Tfpqpb5T4VeKNbOM/q Ktz/hC/5f3x8uOw8f6uCkbDv4a0EB01Tp/iyDgOlxW1hf5JdxC50sjD+0ifQ08P7wwUePY+oEaNO 7Ko0959DCCwJdTLAti3qzvHUWACOuvVLt19LMw9gxZOrO7xfWuPRUDUvyHq6qlN9g6sxK4z92WPX cOhvZJqOd1p1o+5GNrdRtUHO3LTObtGJfs1Ci9giMEjQ/0v1DykVq2BW4rcFdS0DEks41qH+rqwo xZzFogUIOQ1VxJeovXvD3iTh4fQ8m7CpGm6RCDepismHcQgD2acVD/YS83OK+8KsnrLr1eHtHTcL Hh3+6/8cTg9fDsQboGaHs44PYL3hDGEDTFi4V6Mi4tTkcLvVfqS23MRZn91wJgO4jRxEdTmcGn91 XK9SnhV4BfPzHUmQiS1q5BpMropRAcPmFaGnNemXPyaX8M9QUwErRz2RQkd0MulUCscE097rLbnB uTz+llW6lqn+D1JalHeZAQIA --===============4126326859864490354==--