From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: multipart/mixed; boundary="===============3742846903586883894==" MIME-Version: 1.0 From: kernel test robot To: kbuild-all@lists.01.org Subject: Re: [RFC v1 08/12] kunit: mock: add basic matchers and actions Date: Sat, 19 Sep 2020 08:24:26 +0800 Message-ID: <202009190847.lHCvkJDK%lkp@intel.com> In-Reply-To: <20200918183114.2571146-9-dlatypov@google.com> List-Id: --===============3742846903586883894== Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Hi Daniel, [FYI, it's a private test report for your RFC patch.] [auto build test WARNING on 10b82d5176488acee2820e5a2cf0f2ec5c3488b6] url: https://github.com/0day-ci/linux/commits/Daniel-Latypov/kunit-intro= duce-class-mocking-support/20200919-023253 base: 10b82d5176488acee2820e5a2cf0f2ec5c3488b6 config: arm-randconfig-r013-20200917 (attached as .config) compiler: clang version 12.0.0 (https://github.com/llvm/llvm-project 0ff28f= a6a75617d61b1aeea77463d6a1684c3c89) 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 # install arm cross compiling tool for clang build # apt-get install binutils-arm-linux-gnueabi # save the attached .config to linux build tree COMPILER_INSTALL_PATH=3D$HOME/0day COMPILER=3Dclang make.cross ARCH= =3Darm = If you fix the issue, kindly add following tag as appropriate Reported-by: kernel test robot All warnings (new ones prefixed by >>): >> lib/kunit/common-mocks.c:105:1: warning: no previous prototype for funct= ion 'to_mock_u8_matcher' [-Wmissing-prototypes] DEFINE_MATCHER(u8); ^ lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:89:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_TO_MATCHER_STRUCT(type_name) = \ ^ lib/kunit/common-mocks.c:37:3: note: expanded from macro 'DEFINE_TO_MATC= HER_STRUCT' to_mock_##type_name##_matcher( = \ ^ :32:1: note: expanded from here to_mock_u8_matcher ^ lib/kunit/common-mocks.c:105:1: note: declare 'static' if the function i= s not intended to be used outside of this translation unit lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:89:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_TO_MATCHER_STRUCT(type_name) = \ ^ lib/kunit/common-mocks.c:36:3: note: expanded from macro 'DEFINE_TO_MATC= HER_STRUCT' struct mock_##type_name##_matcher * = \ ^ >> lib/kunit/common-mocks.c:105:1: warning: no previous prototype for funct= ion 'match_u8_eq' [-Wmissing-prototypes] DEFINE_MATCHER(u8); ^ lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:90:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_MATCH_FUNC(type_name, type, eq, =3D=3D) = \ ^ lib/kunit/common-mocks.c:46:8: note: expanded from macro 'DEFINE_MATCH_F= UNC' bool match_##type_name##_##op_name( = \ ^ :42:1: note: expanded from here match_u8_eq ^ lib/kunit/common-mocks.c:105:1: note: declare 'static' if the function i= s not intended to be used outside of this translation unit lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:90:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_MATCH_FUNC(type_name, type, eq, =3D=3D) = \ ^ lib/kunit/common-mocks.c:46:3: note: expanded from macro 'DEFINE_MATCH_F= UNC' bool match_##type_name##_##op_name( = \ ^ >> lib/kunit/common-mocks.c:105:1: warning: no previous prototype for funct= ion 'match_u8_ne' [-Wmissing-prototypes] DEFINE_MATCHER(u8); ^ lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:92:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_MATCH_FUNC(type_name, type, ne, !=3D) = \ ^ lib/kunit/common-mocks.c:46:8: note: expanded from macro 'DEFINE_MATCH_F= UNC' bool match_##type_name##_##op_name( = \ ^ :59:1: note: expanded from here match_u8_ne ^ lib/kunit/common-mocks.c:105:1: note: declare 'static' if the function i= s not intended to be used outside of this translation unit lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:92:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_MATCH_FUNC(type_name, type, ne, !=3D) = \ ^ lib/kunit/common-mocks.c:46:3: note: expanded from macro 'DEFINE_MATCH_F= UNC' bool match_##type_name##_##op_name( = \ ^ >> lib/kunit/common-mocks.c:105:1: warning: no previous prototype for funct= ion 'match_u8_le' [-Wmissing-prototypes] DEFINE_MATCHER(u8); ^ lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:94:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_MATCH_FUNC(type_name, type, le, <=3D) = \ ^ lib/kunit/common-mocks.c:46:8: note: expanded from macro 'DEFINE_MATCH_F= UNC' bool match_##type_name##_##op_name( = \ ^ :76:1: note: expanded from here match_u8_le ^ lib/kunit/common-mocks.c:105:1: note: declare 'static' if the function i= s not intended to be used outside of this translation unit lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:94:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_MATCH_FUNC(type_name, type, le, <=3D) = \ ^ lib/kunit/common-mocks.c:46:3: note: expanded from macro 'DEFINE_MATCH_F= UNC' bool match_##type_name##_##op_name( = \ ^ >> lib/kunit/common-mocks.c:105:1: warning: no previous prototype for funct= ion 'match_u8_lt' [-Wmissing-prototypes] DEFINE_MATCHER(u8); ^ lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:96:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_MATCH_FUNC(type_name, type, lt, <) = \ ^ lib/kunit/common-mocks.c:46:8: note: expanded from macro 'DEFINE_MATCH_F= UNC' bool match_##type_name##_##op_name( = \ ^ :93:1: note: expanded from here match_u8_lt ^ lib/kunit/common-mocks.c:105:1: note: declare 'static' if the function i= s not intended to be used outside of this translation unit lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:96:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_MATCH_FUNC(type_name, type, lt, <) = \ ^ lib/kunit/common-mocks.c:46:3: note: expanded from macro 'DEFINE_MATCH_F= UNC' bool match_##type_name##_##op_name( = \ ^ >> lib/kunit/common-mocks.c:105:1: warning: no previous prototype for funct= ion 'match_u8_ge' [-Wmissing-prototypes] DEFINE_MATCHER(u8); ^ lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:98:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_MATCH_FUNC(type_name, type, ge, >=3D) = \ ^ lib/kunit/common-mocks.c:46:8: note: expanded from macro 'DEFINE_MATCH_F= UNC' bool match_##type_name##_##op_name( = \ ^ :110:1: note: expanded from here match_u8_ge ^ lib/kunit/common-mocks.c:105:1: note: declare 'static' if the function i= s not intended to be used outside of this translation unit lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:98:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_MATCH_FUNC(type_name, type, ge, >=3D) = \ ^ lib/kunit/common-mocks.c:46:3: note: expanded from macro 'DEFINE_MATCH_F= UNC' bool match_##type_name##_##op_name( = \ ^ >> lib/kunit/common-mocks.c:105:1: warning: no previous prototype for funct= ion 'match_u8_gt' [-Wmissing-prototypes] DEFINE_MATCHER(u8); ^ lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:100:3: note: expanded from macro 'DEFINE_MATCHE= R_WITH_TYPENAME' DEFINE_MATCH_FUNC(type_name, type, gt, >) = \ ^ lib/kunit/common-mocks.c:46:8: note: expanded from macro 'DEFINE_MATCH_F= UNC' bool match_##type_name##_##op_name( = \ ^ :127:1: note: expanded from here match_u8_gt ^ lib/kunit/common-mocks.c:105:1: note: declare 'static' if the function i= s not intended to be used outside of this translation unit lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:100:3: note: expanded from macro 'DEFINE_MATCHE= R_WITH_TYPENAME' DEFINE_MATCH_FUNC(type_name, type, gt, >) = \ ^ lib/kunit/common-mocks.c:46:3: note: expanded from macro 'DEFINE_MATCH_F= UNC' bool match_##type_name##_##op_name( = \ ^ >> lib/kunit/common-mocks.c:106:1: warning: no previous prototype for funct= ion 'to_mock_u16_matcher' [-Wmissing-prototypes] DEFINE_MATCHER(u16); ^ lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:89:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_TO_MATCHER_STRUCT(type_name) = \ ^ lib/kunit/common-mocks.c:37:3: note: expanded from macro 'DEFINE_TO_MATC= HER_STRUCT' to_mock_##type_name##_matcher( = \ ^ :145:1: note: expanded from here to_mock_u16_matcher ^ lib/kunit/common-mocks.c:106:1: note: declare 'static' if the function i= s not intended to be used outside of this translation unit lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:89:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_TO_MATCHER_STRUCT(type_name) = \ ^ lib/kunit/common-mocks.c:36:3: note: expanded from macro 'DEFINE_TO_MATC= HER_STRUCT' struct mock_##type_name##_matcher * = \ ^ >> lib/kunit/common-mocks.c:106:1: warning: no previous prototype for funct= ion 'match_u16_eq' [-Wmissing-prototypes] DEFINE_MATCHER(u16); ^ lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:90:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_MATCH_FUNC(type_name, type, eq, =3D=3D) = \ ^ lib/kunit/common-mocks.c:46:8: note: expanded from macro 'DEFINE_MATCH_F= UNC' bool match_##type_name##_##op_name( = \ ^ :155:1: note: expanded from here match_u16_eq ^ lib/kunit/common-mocks.c:106:1: note: declare 'static' if the function i= s not intended to be used outside of this translation unit lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:90:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_MATCH_FUNC(type_name, type, eq, =3D=3D) = \ ^ lib/kunit/common-mocks.c:46:3: note: expanded from macro 'DEFINE_MATCH_F= UNC' bool match_##type_name##_##op_name( = \ ^ >> lib/kunit/common-mocks.c:106:1: warning: no previous prototype for funct= ion 'match_u16_ne' [-Wmissing-prototypes] DEFINE_MATCHER(u16); ^ lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:92:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_MATCH_FUNC(type_name, type, ne, !=3D) = \ ^ lib/kunit/common-mocks.c:46:8: note: expanded from macro 'DEFINE_MATCH_F= UNC' bool match_##type_name##_##op_name( = \ ^ :172:1: note: expanded from here match_u16_ne ^ lib/kunit/common-mocks.c:106:1: note: declare 'static' if the function i= s not intended to be used outside of this translation unit lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:92:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_MATCH_FUNC(type_name, type, ne, !=3D) = \ ^ lib/kunit/common-mocks.c:46:3: note: expanded from macro 'DEFINE_MATCH_F= UNC' bool match_##type_name##_##op_name( = \ ^ >> lib/kunit/common-mocks.c:106:1: warning: no previous prototype for funct= ion 'match_u16_le' [-Wmissing-prototypes] DEFINE_MATCHER(u16); ^ lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:94:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_MATCH_FUNC(type_name, type, le, <=3D) = \ ^ lib/kunit/common-mocks.c:46:8: note: expanded from macro 'DEFINE_MATCH_F= UNC' bool match_##type_name##_##op_name( = \ ^ :189:1: note: expanded from here match_u16_le ^ lib/kunit/common-mocks.c:106:1: note: declare 'static' if the function i= s not intended to be used outside of this translation unit lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:94:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_MATCH_FUNC(type_name, type, le, <=3D) = \ ^ lib/kunit/common-mocks.c:46:3: note: expanded from macro 'DEFINE_MATCH_F= UNC' bool match_##type_name##_##op_name( = \ ^ >> lib/kunit/common-mocks.c:106:1: warning: no previous prototype for funct= ion 'match_u16_lt' [-Wmissing-prototypes] DEFINE_MATCHER(u16); ^ lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:96:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_MATCH_FUNC(type_name, type, lt, <) = \ ^ lib/kunit/common-mocks.c:46:8: note: expanded from macro 'DEFINE_MATCH_F= UNC' bool match_##type_name##_##op_name( = \ ^ :206:1: note: expanded from here match_u16_lt ^ lib/kunit/common-mocks.c:106:1: note: declare 'static' if the function i= s not intended to be used outside of this translation unit lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:96:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_MATCH_FUNC(type_name, type, lt, <) = \ ^ lib/kunit/common-mocks.c:46:3: note: expanded from macro 'DEFINE_MATCH_F= UNC' bool match_##type_name##_##op_name( = \ ^ >> lib/kunit/common-mocks.c:106:1: warning: no previous prototype for funct= ion 'match_u16_ge' [-Wmissing-prototypes] DEFINE_MATCHER(u16); ^ lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:98:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_MATCH_FUNC(type_name, type, ge, >=3D) = \ ^ lib/kunit/common-mocks.c:46:8: note: expanded from macro 'DEFINE_MATCH_F= UNC' bool match_##type_name##_##op_name( = \ ^ :223:1: note: expanded from here match_u16_ge ^ lib/kunit/common-mocks.c:106:1: note: declare 'static' if the function i= s not intended to be used outside of this translation unit lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:98:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_MATCH_FUNC(type_name, type, ge, >=3D) = \ ^ lib/kunit/common-mocks.c:46:3: note: expanded from macro 'DEFINE_MATCH_F= UNC' bool match_##type_name##_##op_name( = \ ^ >> lib/kunit/common-mocks.c:106:1: warning: no previous prototype for funct= ion 'match_u16_gt' [-Wmissing-prototypes] DEFINE_MATCHER(u16); ^ lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:100:3: note: expanded from macro 'DEFINE_MATCHE= R_WITH_TYPENAME' DEFINE_MATCH_FUNC(type_name, type, gt, >) = \ ^ lib/kunit/common-mocks.c:46:8: note: expanded from macro 'DEFINE_MATCH_F= UNC' bool match_##type_name##_##op_name( = \ ^ :240:1: note: expanded from here match_u16_gt ^ lib/kunit/common-mocks.c:106:1: note: declare 'static' if the function i= s not intended to be used outside of this translation unit lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:100:3: note: expanded from macro 'DEFINE_MATCHE= R_WITH_TYPENAME' DEFINE_MATCH_FUNC(type_name, type, gt, >) = \ ^ lib/kunit/common-mocks.c:46:3: note: expanded from macro 'DEFINE_MATCH_F= UNC' bool match_##type_name##_##op_name( = \ ^ >> lib/kunit/common-mocks.c:107:1: warning: no previous prototype for funct= ion 'to_mock_u32_matcher' [-Wmissing-prototypes] DEFINE_MATCHER(u32); ^ lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:89:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_TO_MATCHER_STRUCT(type_name) = \ ^ lib/kunit/common-mocks.c:37:3: note: expanded from macro 'DEFINE_TO_MATC= HER_STRUCT' to_mock_##type_name##_matcher( = \ ^ :258:1: note: expanded from here to_mock_u32_matcher ^ lib/kunit/common-mocks.c:107:1: note: declare 'static' if the function i= s not intended to be used outside of this translation unit lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:89:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_TO_MATCHER_STRUCT(type_name) = \ ^ lib/kunit/common-mocks.c:36:3: note: expanded from macro 'DEFINE_TO_MATC= HER_STRUCT' struct mock_##type_name##_matcher * = \ ^ >> lib/kunit/common-mocks.c:107:1: warning: no previous prototype for funct= ion 'match_u32_eq' [-Wmissing-prototypes] DEFINE_MATCHER(u32); ^ lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:90:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_MATCH_FUNC(type_name, type, eq, =3D=3D) = \ ^ lib/kunit/common-mocks.c:46:8: note: expanded from macro 'DEFINE_MATCH_F= UNC' bool match_##type_name##_##op_name( = \ ^ :268:1: note: expanded from here match_u32_eq ^ lib/kunit/common-mocks.c:107:1: note: declare 'static' if the function i= s not intended to be used outside of this translation unit lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:90:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_MATCH_FUNC(type_name, type, eq, =3D=3D) = \ ^ lib/kunit/common-mocks.c:46:3: note: expanded from macro 'DEFINE_MATCH_F= UNC' bool match_##type_name##_##op_name( = \ ^ >> lib/kunit/common-mocks.c:107:1: warning: no previous prototype for funct= ion 'match_u32_ne' [-Wmissing-prototypes] DEFINE_MATCHER(u32); ^ lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:92:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_MATCH_FUNC(type_name, type, ne, !=3D) = \ ^ lib/kunit/common-mocks.c:46:8: note: expanded from macro 'DEFINE_MATCH_F= UNC' bool match_##type_name##_##op_name( = \ ^ :285:1: note: expanded from here match_u32_ne ^ lib/kunit/common-mocks.c:107:1: note: declare 'static' if the function i= s not intended to be used outside of this translation unit lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:92:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_MATCH_FUNC(type_name, type, ne, !=3D) = \ ^ lib/kunit/common-mocks.c:46:3: note: expanded from macro 'DEFINE_MATCH_F= UNC' bool match_##type_name##_##op_name( = \ ^ >> lib/kunit/common-mocks.c:107:1: warning: no previous prototype for funct= ion 'match_u32_le' [-Wmissing-prototypes] DEFINE_MATCHER(u32); ^ lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:94:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_MATCH_FUNC(type_name, type, le, <=3D) = \ ^ lib/kunit/common-mocks.c:46:8: note: expanded from macro 'DEFINE_MATCH_F= UNC' bool match_##type_name##_##op_name( = \ ^ :302:1: note: expanded from here match_u32_le ^ lib/kunit/common-mocks.c:107:1: note: declare 'static' if the function i= s not intended to be used outside of this translation unit lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:94:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_MATCH_FUNC(type_name, type, le, <=3D) = \ ^ lib/kunit/common-mocks.c:46:3: note: expanded from macro 'DEFINE_MATCH_F= UNC' bool match_##type_name##_##op_name( = \ ^ >> lib/kunit/common-mocks.c:107:1: warning: no previous prototype for funct= ion 'match_u32_lt' [-Wmissing-prototypes] DEFINE_MATCHER(u32); ^ lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:96:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_MATCH_FUNC(type_name, type, lt, <) = \ ^ lib/kunit/common-mocks.c:46:8: note: expanded from macro 'DEFINE_MATCH_F= UNC' bool match_##type_name##_##op_name( = \ ^ :15:1: note: expanded from here match_u32_lt ^ lib/kunit/common-mocks.c:107:1: note: declare 'static' if the function i= s not intended to be used outside of this translation unit lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:96:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_MATCH_FUNC(type_name, type, lt, <) = \ ^ lib/kunit/common-mocks.c:46:3: note: expanded from macro 'DEFINE_MATCH_F= UNC' bool match_##type_name##_##op_name( = \ ^ >> lib/kunit/common-mocks.c:107:1: warning: no previous prototype for funct= ion 'match_u32_ge' [-Wmissing-prototypes] DEFINE_MATCHER(u32); ^ lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:98:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_MATCH_FUNC(type_name, type, ge, >=3D) = \ ^ lib/kunit/common-mocks.c:46:8: note: expanded from macro 'DEFINE_MATCH_F= UNC' bool match_##type_name##_##op_name( = \ ^ :32:1: note: expanded from here match_u32_ge ^ lib/kunit/common-mocks.c:107:1: note: declare 'static' if the function i= s not intended to be used outside of this translation unit lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:98:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_MATCH_FUNC(type_name, type, ge, >=3D) = \ ^ lib/kunit/common-mocks.c:46:3: note: expanded from macro 'DEFINE_MATCH_F= UNC' bool match_##type_name##_##op_name( = \ ^ lib/kunit/common-mocks.c:107:1: warning: no previous prototype for funct= ion 'match_u32_gt' [-Wmissing-prototypes] DEFINE_MATCHER(u32); ^ lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:100:3: note: expanded from macro 'DEFINE_MATCHE= R_WITH_TYPENAME' DEFINE_MATCH_FUNC(type_name, type, gt, >) = \ ^ lib/kunit/common-mocks.c:46:8: note: expanded from macro 'DEFINE_MATCH_F= UNC' bool match_##type_name##_##op_name( = \ ^ :49:1: note: expanded from here match_u32_gt ^ lib/kunit/common-mocks.c:107:1: note: declare 'static' if the function i= s not intended to be used outside of this translation unit lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:100:3: note: expanded from macro 'DEFINE_MATCHE= R_WITH_TYPENAME' DEFINE_MATCH_FUNC(type_name, type, gt, >) = \ ^ lib/kunit/common-mocks.c:46:3: note: expanded from macro 'DEFINE_MATCH_F= UNC' bool match_##type_name##_##op_name( = \ ^ lib/kunit/common-mocks.c:108:1: warning: no previous prototype for funct= ion 'to_mock_u64_matcher' [-Wmissing-prototypes] DEFINE_MATCHER(u64); ^ lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:89:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_TO_MATCHER_STRUCT(type_name) = \ ^ lib/kunit/common-mocks.c:37:3: note: expanded from macro 'DEFINE_TO_MATC= HER_STRUCT' to_mock_##type_name##_matcher( = \ ^ :67:1: note: expanded from here to_mock_u64_matcher ^ lib/kunit/common-mocks.c:108:1: note: declare 'static' if the function i= s not intended to be used outside of this translation unit lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^ lib/kunit/common-mocks.c:89:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_TO_MATCHER_STRUCT(type_name) = \ ^ lib/kunit/common-mocks.c:36:3: note: expanded from macro 'DEFINE_TO_MATC= HER_STRUCT' struct mock_##type_name##_matcher * = \ ^ lib/kunit/common-mocks.c:108:1: warning: format specifies type 'int' but= the argument has type 'u64' (aka 'unsigned long long') [-Wformat] DEFINE_MATCHER(u64); ^~~~~~~~~~~~~~~~~~~ lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ lib/kunit/common-mocks.c:90:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_MATCH_FUNC(type_name, type, eq, =3D=3D) = \ ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ lib/kunit/common-mocks.c:59:8: note: expanded from macro 'DEFINE_MATCH_F= UNC' actual, = \ ^~~~~~ lib/kunit/common-mocks.c:108:1: warning: format specifies type 'int' but= the argument has type 'u64' (aka 'unsigned long long') [-Wformat] DEFINE_MATCHER(u64); ^~~~~~~~~~~~~~~~~~~ lib/kunit/common-mocks.c:103:30: note: expanded from macro 'DEFINE_MATCH= ER' #define DEFINE_MATCHER(type) DEFINE_MATCHER_WITH_TYPENAME(type, type) ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ lib/kunit/common-mocks.c:90:3: note: expanded from macro 'DEFINE_MATCHER= _WITH_TYPENAME' DEFINE_MATCH_FUNC(type_name, type, eq, =3D=3D) = \ ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ lib/kunit/common-mocks.c:60:8: note: expanded from macro 'DEFINE_MATCH_F= UNC' matcher->expected); = \ ^~~~~~~~~~~~~~~~~ lib/kunit/common-mocks.c:108:1: warning: format specifies type 'int' but= the argument has type 'u64' (aka 'unsigned long long') [-Wformat] DEFINE_MATCHER(u64); # https://github.com/0day-ci/linux/commit/32db0336f68431c2ad957f5dcd80ce827= 488660f git remote add linux-review https://github.com/0day-ci/linux git fetch --no-tags linux-review Daniel-Latypov/kunit-introduce-class-mocki= ng-support/20200919-023253 git checkout 32db0336f68431c2ad957f5dcd80ce827488660f vim +/to_mock_u8_matcher +105 lib/kunit/common-mocks.c 104 = > 105 DEFINE_MATCHER(u8); > 106 DEFINE_MATCHER(u16); > 107 DEFINE_MATCHER(u32); > 108 DEFINE_MATCHER(u64); > 109 DEFINE_MATCHER(char); > 110 DEFINE_MATCHER_WITH_TYPENAME(uchar, unsigned char); > 111 DEFINE_MATCHER_WITH_TYPENAME(schar, signed char); > 112 DEFINE_MATCHER(short); > 113 DEFINE_MATCHER_WITH_TYPENAME(ushort, unsigned short); > 114 DEFINE_MATCHER(int); > 115 DEFINE_MATCHER_WITH_TYPENAME(uint, unsigned int); > 116 DEFINE_MATCHER(long); > 117 DEFINE_MATCHER_WITH_TYPENAME(ulong, unsigned long); > 118 DEFINE_MATCHER_WITH_TYPENAME(longlong, long long); > 119 DEFINE_MATCHER_WITH_TYPENAME(ulonglong, unsigned long long); 120 = > 121 DEFINE_MATCHER_WITH_TYPENAME(ptr, void *); 122 = 123 struct mock_memeq_matcher { 124 struct mock_param_matcher matcher; 125 const void *expected; 126 size_t size; 127 }; 128 = 129 static bool match_memeq(struct mock_param_matcher *pmatcher, 130 struct kunit_stream *stream, 131 const void *pactual) 132 { 133 struct mock_memeq_matcher *matcher =3D 134 container_of(pmatcher, 135 struct mock_memeq_matcher, 136 matcher); 137 const void *actual =3D CONVERT_TO_ACTUAL_TYPE(const void *, pactual= ); 138 bool matches =3D !memcmp(actual, matcher->expected, matcher->size); 139 int i; 140 = 141 for (i =3D 0; i < matcher->size; i++) 142 kunit_stream_add(stream, "%02x, ", ((const char *) actual)[i]); 143 if (matches) 144 kunit_stream_add(stream, "=3D=3D "); 145 else 146 kunit_stream_add(stream, "!=3D "); 147 for (i =3D 0; i < matcher->size; i++) 148 kunit_stream_add(stream, 149 "%02x, ", 150 ((const char *) matcher->expected)[i]); 151 = 152 return matches; 153 } 154 = 155 struct mock_param_matcher *kunit_memeq(struct kunit *test, 156 const void *buf, 157 size_t size) 158 { 159 struct mock_memeq_matcher *matcher; 160 = 161 matcher =3D kunit_kzalloc(test, sizeof(*matcher), GFP_KERNEL); 162 if (!matcher) 163 return NULL; 164 = 165 matcher->matcher.match =3D match_memeq; 166 matcher->expected =3D buf; 167 matcher->size =3D size; 168 = 169 return &matcher->matcher; 170 } 171 = 172 struct mock_streq_matcher { 173 struct mock_param_matcher matcher; 174 const char *expected; 175 }; 176 = 177 static bool match_streq(struct mock_param_matcher *pmatcher, 178 struct kunit_stream *stream, 179 const void *pactual) 180 { 181 struct mock_streq_matcher *matcher =3D 182 container_of(pmatcher, 183 struct mock_streq_matcher, 184 matcher); 185 const char *actual =3D CONVERT_TO_ACTUAL_TYPE(const char *, pactual= ); 186 bool matches =3D !strcmp(actual, matcher->expected); 187 = 188 if (matches) 189 kunit_stream_add(stream, "%s =3D=3D %s", actual, matcher->expected= ); 190 else 191 kunit_stream_add(stream, "%s !=3D %s", actual, matcher->expected); 192 = 193 return matches; 194 } 195 = 196 struct mock_param_matcher *kunit_streq(struct kunit *test, const cha= r *str) 197 { 198 struct mock_streq_matcher *matcher; 199 = 200 matcher =3D kunit_kzalloc(test, sizeof(*matcher), GFP_KERNEL); 201 if (!matcher) 202 return NULL; 203 = 204 matcher->matcher.match =3D match_streq; 205 matcher->expected =3D str; 206 = 207 return &matcher->matcher; 208 } 209 = 210 #define DEFINE_RETURN_ACTION_STRUCT(type_name, type) \ 211 struct mock_##type_name##_action { \ 212 struct mock_action action; \ 213 type ret; \ 214 } 215 = 216 #define DEFINE_RETURN_ACTION_FUNC(type_name, type) \ 217 void *do_##type_name##_return(struct mock_action *paction, \ 218 const void **params, \ 219 int len) \ 220 { \ 221 struct mock_##type_name##_action *action =3D \ 222 container_of(paction, \ 223 struct mock_##type_name##_action,\ 224 action); \ 225 \ 226 return (void *) &action->ret; \ 227 } 228 = 229 #define DEFINE_RETURN_ACTION_FACTORY(type_name, type) \ 230 struct mock_action *kunit_##type_name##_return( \ 231 struct kunit *test, \ 232 type ret) \ 233 { \ 234 struct mock_##type_name##_action *action; \ 235 \ 236 action =3D kunit_kmalloc(test, \ 237 sizeof(*action), \ 238 GFP_KERNEL); \ 239 if (!action) \ 240 return NULL; \ 241 \ 242 action->action.do_action =3D do_##type_name##_return; \ 243 action->ret =3D ret; \ 244 \ 245 return &action->action; \ 246 } 247 = 248 #define DEFINE_RETURN_ACTION_WITH_TYPENAME(type_name, type) \ 249 DEFINE_RETURN_ACTION_STRUCT(type_name, type); \ 250 DEFINE_RETURN_ACTION_FUNC(type_name, type); \ 251 DEFINE_RETURN_ACTION_FACTORY(type_name, type) 252 = 253 #define DEFINE_RETURN_ACTION(type) \ 254 DEFINE_RETURN_ACTION_WITH_TYPENAME(type, type) 255 = > 256 DEFINE_RETURN_ACTION(u8); > 257 DEFINE_RETURN_ACTION(u16); > 258 DEFINE_RETURN_ACTION(u32); > 259 DEFINE_RETURN_ACTION(u64); > 260 DEFINE_RETURN_ACTION(char); > 261 DEFINE_RETURN_ACTION_WITH_TYPENAME(uchar, unsigned char); > 262 DEFINE_RETURN_ACTION_WITH_TYPENAME(schar, signed char); > 263 DEFINE_RETURN_ACTION(short); > 264 DEFINE_RETURN_ACTION_WITH_TYPENAME(ushort, unsigned short); > 265 DEFINE_RETURN_ACTION(int); > 266 DEFINE_RETURN_ACTION_WITH_TYPENAME(uint, unsigned int); > 267 DEFINE_RETURN_ACTION(long); > 268 DEFINE_RETURN_ACTION_WITH_TYPENAME(ulong, unsigned long); > 269 DEFINE_RETURN_ACTION_WITH_TYPENAME(longlong, long long); > 270 DEFINE_RETURN_ACTION_WITH_TYPENAME(ulonglong, unsigned long long); > 271 DEFINE_RETURN_ACTION_WITH_TYPENAME(ptr, void *); --- 0-DAY CI Kernel Test Service, Intel Corporation https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org --===============3742846903586883894== Content-Type: application/gzip MIME-Version: 1.0 Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="config.gz" H4sICElCZV8AAy5jb25maWcAjDzLduO2kvt8BU9nc2eRtERZD88cLyASlBCRBJsA9fCGR22zO55r Wx5Z7pv++ykAfAAgqCQnJzGrCgWgUKgXAP36y68e+ricXo6Xp4fj8/NP73v1Wp2Pl+rR+/b0XP2P F1IvpdzDIeG/A3H89Prx1+fj+cWb/n77++i388PU21Tn1+rZC06v356+f0Djp9PrL7/+EtA0Iqsy CMotzhmhacnxnt99eng+vn73flTnd6Dzxv7vo99H3r++P13++/Nn+O/L0/l8On9+fv7xUr6dT/9b PVy86nF+u/Dnx+p4c3NTzW5vp9++Th4ns+PXB//rN/hjMhnP55OH//rU9Lrqur0bNcA4bGH+ZDqS /2jDJKwMYpSu7n62QPHZthn7VoM1YiViSbminGqNTERJC54V3IknaUxS3KFI/qXc0XzTQZYFiUNO ElxytIxxyWguWIF4f/VWcqmevffq8vHWCXyZ0w1OS5A3SzKNd0p4idNtiXKQBEkIv5v4wKUZFU0y Ah1wzLj39O69ni6CcSs6GqC4EcSnTy5wiQpdDHLkJUMx1+jXaIvLDc5THJere6INT8fE9wlyY/b3 Qy3oEOIGEO0sta71Sdp4MYBr+P399dbUIUFjQDUsxBEqYi7XRpNSA15TxlOU4LtP/3o9vVag3W1X bIcyRyfswLYkC7oeaoD4f8BjXRQZZWRfJl8KXGAHpx3iwbqUWL1VkFPGygQnND+UiHMUrB2NC4Zj suxGgQowH9YCoRz4S4QYG4pji7yDSmWHreG9f3x9//l+qV46ZV/hFOckkDsny+lS20w6iq3pbhhT xniLYzceRxEOOBEDjqIyQWzjpiPpH4IOdoc2zTwEFIPFKnPMcBq6mwZrfSMISEgTRFITxkjiIirX BOdCloc+84QRQTmI6PWzRmkINqDmbDQV5BHNAxyWfJ1jFBLdULIM5Qy7O5Md4WWxipjUpOr10Tt9 sxbU1SiBPUDqMeV9vtIqbnvK06ADsE0bWNeUM02zhNIJ68tJsBGWEoUBYvxqa4NM6iJ/egHv5VJH yZamGLRKY5rScn0vLGwi1aPdTADMoDcaksCxiVQrApO3OBksyGotlEtKI2emWaol3RuuZgRyjJOM A9/UZQQa9JbGRcpRfjAMiEJeaRZQaNUILciKz/z4/m/vAsPxjjC098vx8u4dHx5OH6+Xp9fvlhih QYkCyUPpWtvzluTcQouFc4xEqJHUE4NR46FYKGxGgMGiAZ4PY8rtpENysAGMI12tBAh0PEaHhlE7 VonaC6hLUIx0TOCjtfwhYcLdh/qG+QcClILOg8JjLtVMDyXg9MHBZ4n3oIOuwTFFrDe3QEIQkke9 axyoHqgIsQvOcxTgdnj1jM2ZtGu6UX9otmnTKh4N9PmRzRoslbUv2tBFxCgROAAS8Tt/1CkvSfkG ApcIWzTjiW0lWLAGeyhtRaPm7OHP6vHjuTp736rj5eNcvUtwPSMHtg0LVzktMqYPH9xssHJGGst4 UzdwzEwh1OA6IUWI5KWJ6bx6BFYO7OyOhHzt7BA2nNbWSVJ3m5HQJe4am4d6aFcDI7AX99LE28xC vCUBvtYd7IqBzdWyANejeSoabFoU4kjvVMRa4Mlg27t7XONgk1FQD2FxOc1dJlOphAiFZR86e3BV IOcQg3kMEB+QYi6siIOvWHGQhgwVc21Z5TdKgDGjBbhnLYzMwybG7riH5RJAvrvrcDjwBdxA0Ctb 0WHUjWMygLhnXJvFklLhLsxtDYkSzcB6k3ssQg/hK+F/CUoDMyS1yBj84Q6NVQSsB6EFCcczbRhZ 1H0ow6j3JKkdrGWgAjGvFqSwFeYiWCy7+MTSgxrhYBepkEfzDDJUVx5eg0pDZX+XaaL5FKX6bc84 jkDKTr1dIojfokKPpKICEnbrE7a3JqGM6vSMrFIUR9qyyiFHhqmRMVUUuhZoDfZOC9UINUw5LQuY 4MrREIVbAoOvBWpb0CXKcwiRXRmZoD4kmkgbSGlElC1UykhsUJEP6N2A3lxZT6EZ0q3romkj0W6I wCIN5PoYW5bhL87dBe1wGGKXKKVui+1S2gGwBMKAym0CgzW9ZRaMR8ZulZ6rru5k1fnb6fxyfH2o PPyjeoXAA4FPC0ToAdGlCvG0PlTHznj0H3LU4r1EsVMBZS/MbfQnLpbK2rucAU0yxCGU3xg7MUZL lyYCJ5OMusnQEpYvX+EmbtP2gsAJvxYTBu4CNjRNhrAiT4SAQlMOti6iCBKxDAFvuU4I3I2R1XOc SP8lqlMkIkBg5J4QCUUkNsJdGWJJ92XkYWYVqVNPfSvmiVRVJnygkTAKDHh0qVEE8puij5JgmAQY hwTW8G6hTaJkRZbRHHIslMEagx1FdgotFBmiOuHnjTSIUNEQEnItdYaoPNioSLJm3OFEjAaut49Q 9JAoRDFasT6+3agiQFrp3UVglDHK4wN8l4btauLD9Q5DfuZKL0EeyxyCAJU1dAT3kIiVRowk+2/l VMgiB9MH8cWUeSYLN9kapCvypH7fRjiUrVRdUVZA2J1fB7Ey4vb4z7eqSyCs1YVOEpB+macQUxAY WgKKsbiGR/u78cwkEI4zg0UXfl3fcRKLlwyNxyPnZlcE2e1kvx/GRxBVLHMSrtwRpKQBPZr4V3iQ fXZzrY+Qbq9wz/bucEoi8ywYRsqpX5k7mwT+1YFREP64Z82Tj+fL09tz5b09Hy/C/ALquXqoS/ZN og5G+Fx5344vT88/DQKzC1Wg2bpCIh0/t9WmbqYwrSG6NjSjfa3W5liQLL65PYMiiDOSXlkqlPMM X1kQxDLsdLYKy2/HRpIBC5igaegbfqQFT1zupMXetDWT59PDv99PH2dwkY/npx+QN7pXgyc4Vnmo ygIgTHOlRH06HiwtaytmUhZcjyI1OFtCcy3oVEUtAbNE0LVhSegCryd+snchpJ0S+ZHZU0cgysO0 zGI7mJdI4oOlKfZm21q0hiq24ta0U4onSyx9XQZJsyBE+CLveH748+kCy1A9euwUvHc2sqEviV2K aDHBYZUWrgy5pVjnvrNlylzZfoueTkbjfTPQDU3RPxlnQpdETzVahL8Y7/cu+Hg2u3HBJ9PpyAFX HZSxDz4PUuNhCpYEzeDp5U/QdNSMvi6iWO38xWTq4DadTOcTp/hmlq8w8HmQML60+eE81qOdBLXA crnyBxGBkfFYyC9DYwjJigQ01uM85eX2h5RqHp9NZV2kTKK+gilal3XR0PbyKei0kT7+6+fr6d1S GFFtrVv745G5i2r4zbhn7GrO/nQ0YO8agtlooOnN+G+a3vjO0UwXIw2uYHISrAA7rp/EiPBDGAJW yGBZxT/Hl/eP1+/gBl9eTq/e6U0Y3PfGQS5PMBoLlp3+AyoLyczxe/UCuUwnuZo1mBVVQNJGa2Hg v0W6EeWLu9mNVjN0D8ZaeXEQABHqZtiBrQkjg556rxVv4aPk93o5V5pXkuxLlEIiYp/aCsQqc5En SegCs7zd6mH14wmc2+VcVd7p9flnG4Sczpfqr99QGwxouihWGdhMbZURMHfE1GDHA7okcBNTjQA0 c3Qwc23fBsdiVwtmFgX6eHcQ16CL4dYxG4/8MeoFeY3wPtd/JN7x/efLS3U5Pz14LzLMOp8eqvf3 J1CrYQHPwQOjuWNKc2f5psYVcWY32Uaza2H8BkM66z6AUsqJQwLxwKZnVBPuz0djJ+MaP5subq/j b9210Bo/n/kuY9phbx2DWoz9+TWmi/FkOiyNBDPqOspSSBIvMSrs9LQBl8l4tO05hSQZjBvA6aF8 O+9NgsCfKeGHK9PAeVDkrkq1YrzFy8JykBIGJuTghDtGAeksClE5mbt8gEkxtXg2iMV+AHG7H+pu 774aIkmuZ3tpFiRDAqGqUqHOj4knPhuLHnUHRSr8Ebga6LEm3jdKbFRm1phhXkfzzkFJqom/UXVY 99nwwFAMmUk+3RmfPofPKPkcwr858iKZLvaSREE1GZaZQN8MWjiBnQ4YG5RMJnqIqmA3CmZwgdHN h2M/0YefxQWzpuZ/nny+8dhb9fD0DexmpB/nOduX/JCRAA3ba1FFktQlC/OgZ7blQsTV9+PDTy9r cuDweDlCxHE8PzblGHvtBsdp0fWXyi4pkDwaXqgvkOoNiTAP7YJVjlFsmewWviV4d6UqAuosbsQM 9QXh79YIQWVU1wLt7lLM0GC2BYsSZStk6JAAaFFiV9WWcWKGkesoQXHjpJftc7K+GQ9psMLOTBWW wJFdM2E8mdgJh4Ql2Xg6780b4so9GZYxR+nKdUdNIfEqt5ezSEkmLhr1OioW05HLOqtCDd5nYKRY r1WDEIcd4lAJTUt0W+Ic0v4r9bK2Fctc92UUDRcDska/SxaLXnJ6b5mO+71/O5uPfJvskGoFVqkE NDdL7QIm7kAirlJplRCoCOt0tqqoQluzP26Wpv7qhQnxzddFsoToKxPFWRM18X/MNj2Q1R4tc15i m2smwTZU5uVDUJJxC06zQ7mdWcONlz0G6o4rCa3moK59SF1btgTntrhJGWfIHSsmSm6mutVAPNRE XiYSF5P1rbvL6tMIVysx6qXIKlOIS1NzNgoG6f7ChBMlz/pej4kLbVx3tC16Ap0PSdDeCRoYEFim gOcaZ3WqVC5zlIpCtGJCjR28ESeT5RrHmfuKzDZk2rVaWnCgtqo4GlAeX2ozk7AlLG6OjEKFQkRY 3K+iaRn7ruBOHJuohFGRx/5+ZPM2YVk8GY9qG1JOF4vJ7HYAOffnt7oWmsjp5HY+xHY+u70Z3/Yn 05jHARWLx42ExD2iUts8fezdTMeJA7QEJ+ISEgjMVB15KofR9lAmduGqPS5yqSnZJcmem3zq+d1M RrfziRM190fzxa0bNb2Z+L4bNTcLNAZqMvJ9e6/WyMV4MfGn5WLq3/gu/dBJ/fFQFwt/OjOXS0dO QQ9cBQGDBvofu3kL1OQab98ZcOtHa6qa9CGuZr69QaquFzk1UYAIVGRTs9Bb6Ef0mr1sbcAW168A OtvmzAbrK9lJyfS7eS1UBQYii3Ag+c4IlLYJy2LCy4nrHL5Diks7rma++8Zbgx67uMpzchpFkA/d jf5ajsynHfJUlAXE2iRpXq4yQu/80U17bLm+F6e6OOzejABkPDICS4D4AydzAjVQggLUZLjVdBgF vbsCrPX9HWA6Sunk/PqVwUAM1RwOk5BsXYqP0dKIYCl81zcnhuIt4eXXNMbNm4CEhvpNemWNcAy+ qXk04KKIYnH0Aiqf2iZONJd3y13o7h1BFqXlFsXEUERREoVm7rt8wmXumpvuGRqsuOxQyusjqbhc FysMsY5pEGBChbirEev3bORVeXHkLU/0Kbji/G7st82a2xDi9oFWThVXGUWAuyN8LW9/ZsaNa4YD sRrODZAj+1i0gdkXoB3N9xAogCg0KwoQ3eTYFsZVB2/mwMRW1ETE0crIALoLkHKIYHJ4XjhvcN7L a4E5TdTLsdFfoz5mCemFhpDGKhO5G7APeS8WFKMR8GG1DpJQPsr6pL222eA9dqUcQY7YugwL/Z2V uPpZ3otbYmGYG2ZbF1d70q4ODhL94KDFRefq/z6q14ef3vvD8VndkDc0OMrtu2HdXXFH65YxeXyu bF7iocEgL9VAh/TGLflFz6fjRVaVT0+vF696+Xg+6ncL0MV7ro7vIIfXqsN6Lx8A+lrVh9vVY6dN 20gTLXz80KIT2FdaWFO/rxLmpcG0Ax4clvPspq/TvUOjGqDdXLYQbEMyKyDOQNNjjA1nDDChLxLu 2tYJ2J8NlhU+g1ELrV/yGa7AwK9cepsl1iB61+a6TaNfzHIP0Thqh+/mopEyrtrAd1/KjO4gX8BR RAIi7F/v4ly/fSu1YQrd3shE1z7Cb5Ylo4yRXhTtPBesz8yWoFZy7nrbVrEGVUfthqfzy3+O58oL 5d2NdzO+Y0FCxN02TgMamwNSKCkq+4mWQmfDLbNey3YtI5InO5Rj4VoS5/tBsGcZzDg/AJeGWucA lpoJwx2BLwlR78ZNQ1XkOYGIgO7LfMe1tVgGyc18vy/TLdh9nW+DYDArV5VxRekKfKw2JBMhLs1K l8DNCKFpB91hlUO1pHr3NZnwuDAjqjF07omafJu5r/CLI87QeVdDHn6aT3BqUJm5rxapyLWMtNeL XaieBIF9vNrCRbkgoFucHywFkUh5WBe2Be/q+/nofWu0Vd000l4OiYJgSbaBrvkDbVqLa6u+sd9A v4wX0/Ib8l80Lo2LpxbCsvg2NsAunH8NN50NdTgd+zWq85IKiSDYBYwzHNAJIDTpMW5Q1gsGhVyt RTSh0MPcgzzg41FIoqF5AcFkcNLBGsG//qhzkSY+o/FhPBlN7RnadOm6pRScrpEGRb7F/nQ6vu2R NjrBhGuHFC9nZZSBQe89cT9qd4F+e6zeQMtMR93lLOrms0uAcoM0eKMOpi7VOifxBwR3ZYyW2HWz X3LsnFmRysBevP+RcbzlTERkLF7Fc3ERSDzgtvbuxr7bq6A55k4E5M9OeNq/uiezd3HPeU2pfaVO lJjgm5NVQQuNV/vGDeYvYsP62W+fQCLFSxDIT3iRWZMWCSIkQ5xEh+aFUp9gAw7eftjUIsUhp8od ndOSo6pziHK3Jlxeqrf4TPwl4aJCUNrP0HO8gi0pIjZxebxeOIh6bBmKZxgWSL5zEO1dcFlaVTzN /KAbeqda1mhlzile7atX1c3PLjhY1BkhOMaY92ozsncRJmC78GtihhRbaAXkXVJzNsZTAokeeIVr UV19gSspIGJvEn0ciKcMHV6l1kzuHPF2Ke+JSiiIxMgXFuLqlENKxj10iwDvQTFs1Xa0WvRXqHms y2kW0l2qGsToQI1f+4jFjf4lSBACl1DrnYpfxyCrOu6c9BDI+jWB+gWL0mQhUWu44g0cBQPUJEL5 zr6+6aDox9/dtuO5OHUwuGkKZCGv1Ydq4rpOYozrCqptLp8ygB8xXkWI5EZ/FNQe3q8g6Pnt6/G9 evT+rYoWb+fTtyc7exZkjmKZ3bckqz1G2Tzjax7OXOnJUDHxWzRZXKxULtR7ePM3vq0NzUFM4gWe bu/lgzQmXnJ1Bct6z+irVYtX1aRiitxha01VpNcoalvk9pU1B5YH7U/CDNx9ayiJO+ms0ULlxYHv NRrxOmpXJgRys1R7wQtxtTwBcTYtUjAosMkOyZLGbhLQy6Sh24jHf65Dqto68RwLsdKN7vyW9aPw 9nMDYT4jYMK+FFj3T83D3iVbOYHGD6l0r4BFUE744Qqq5OaFiIZAFCRdyYZ8U66KX8rx5Hbr3dKd DynOywIyTJec5NxBjjRDsc1S/QJSiVMZLFolBlWdOZ4vT7JKJM5MtBwaxsiJzMxRuBWPgo3iL4IM Lu1oXJuc7Du8Zn5Z5AKjBEyygdBeX6CcuLvSb4/9HQULKfsbmjhM/oaCrQZG0qh+DJrtnDcrUhd4 I27FuRA4Im5xiJ8cmi2ujkJTM619U1OxFlxXo+RLmekHOTVMhCKEmuCse7RBu99dMHIFaEmoerD/ /5x9SZPbONLoX6mYw4uZiK+jRWo/+ABuEixuRVASVRdGtV3zdcVU2w67HNP97x8SAEksCarfO3hR ZgLEjsxELgm//3Off5BGd7pFtiXdIMgriijDVbJmKybRp9TeF8+l2g+Ms8PiJNbPEPNpl7Sc34n7 prgid2bJdwUI/zmpazgXQRctLWeIzoBP6ktl+f/y6ef7829vLyL424Nwz33XtlxEy6xogeEy9vEI 7bOkppjCkeOUX7NZhsWNYWEyOVtKPDwMOYW8QF78cKkhyFktwp8Bl4sTch4L6cET4PATTjX3SBrQ fuXoy4Ei4neRbgbBu60EgHEp+MZZeui9/PH1+1+aZh1RR889qA1vaQUpz+Z5Oz2kSRzSBVXYrI2v pkQox0xvW2W7ndbChd1cqqpplFW2R698xa1bwcBx6YF9WBkcrsX1ipfdJoUlb0gO/DRuiM0ggxDb D27tw6Rw7lBf8uCMXFZcHLWs2U4M0+gMLL5g7Qtaio30YbXYj1YaZQrvWKBX5JLQSVcl5Sm/lExr mbgw4o3wn36H9QGXMaM8H/aUsA/bqZanuqqwuXyKzsYif2LS5R9TrypRXngz85OsSeVMT4dbMnij D8IgtnhAy8ql1djwVedjI/TrZsSkw7nuI37rHwuiXPIHL1Dv8p9GfFQPlS/v//36/T/wsuNsEr6U Tqn1IAqQPqEEaz0/ezXpA36BGl4vL2B26Ylj9HCSXdYUQhuAYnlnwP8B0xWXZutpLR1nIRAZfgHV IyPUN8IuC6u17utSjzYnfvfJMa6tjwEYNOC4NbwiaEiD46FftPZEWZTIQwPe78UZkx0lRd+eyzK1 YqeUfKNXJ+pR18mClxY3fgVsVp3ncNNn8Q/AtPQED5IkcCnzjJhsmucBX2DH7upAWHAWqI3rAWxW f05q/wIVFA253qEALJ8XLplXuPsHfJ3/9zCuNuwFaKCJz5Gu0BlVJgr/4R+ffv72+ukfZu1FsrYk w3HVXTbmMr1s1FoHC0fcel0QyQhBrIVHQ490C73fzE3tZnZuN8jkmm0oaL3xY601q6MYbZ1ec1i/ abCxF+gSnn/Exd3e6tQpLVfaTFNlYAYVddazEwShGH0/nqWHTZ9f731PkPG7APe/l9Nc5/MVFTVf O35MfzpDBFyIb4sJqXwGIfIuaFTVlaSdC3VbQyxgxmh2MzCiSH28CYUcv+KK2gpVyGmkbhZnK+sZ JD+IktjTIzAuiD1Hc5N4VBoUN5tvzcgbLTzo4+4XHJWTMrXJi7ryWO1zZNSEmx3u4JOHnh64MTsU Qr5vwCHFiDXKAMINB3mT+90iDDDPzSSNrWtWQvwXaJ5rxxn/odu9tkS3hABdCxe/8tQE0zpJausn 6D901roLDedWLsVh8YfqY2U1fpNXV8uWbVoyaZrCMKyxgGzQ5SEqoOCsHn++/HzhfNWvSmY1wnMq 6j6OHu1ZAPCxxVo7YjNdPBqg1iocwHVDMT+VAS2OqUe3tkYPpjQAWRZhQLQLbfqIsdQjOsrcqmL9 vXcA8u2P1k/u9OyAdiFh7tkEcP5vio5f0vjZTjGAj3fawU4RUCC9PVan1AU/4uMZg4w625Ls0SWy KyHYFzNk/o9HdNRrit9UIz5HRbFpLhk6xpKncRSX8dvzjx/gkmcFxC+F06ZTFQeBPh9Vnwz4NqZl knZYUXFg+bY2EOgmJAPsrPuUKYB4vjSkVAWHpecdPtEEdvHz+wMBFixobGJeIY2Mh0Ca9mDVmQuE KvSH0AFegOGzEdVP8OoCjMGU8kiPkK8hYw+bp5GU0c3DF2lEfFg9w6EIirR1LjqFgqfZ+cIxKU2D 6GEwCGptO24ommn7PdEDBCUlA6/jCkL+f/hjVLHww5sILbyhUxuhw38xm3OdKtfe9zR4QlpPvSW2 VzR8Ycb21uu0NSs2zvNFEbpz/qOgILGYwKpOywu70jbGhYsLBKVNfWxpTsuTJQUWdW7dNQDpD8wI mSlgcC5Y6hpjPZQMb9ORzdwcoiucv/FS5EsIlQ9imUWlaB6b1tC+wW8IFIVWKJCc8ffU0xdHaq/y MkZjnai4v4KlN241DSH5fOvybbo+OrNbbwY8jR7N96w66z9S9yJQWqqH95cf79YztGjJqbWCl5t8 bVNxibjiskuFu/A71VsIXTumzS8pGpKgd39MTMswvrAbcsUJVXAsDXC4mr8/BvvlfmArOWAI+TLZ xBpfusSoL4ZAdUjLWO4vwNeeTR6TPAaDDtAGoEpMIDIjmQEky1P1cb2nDdKej6R8Am/PEosbAgSn CwHToDqmqRkZF5CQ7yCNUVcDju0goqfbjrjHQb0WWdHF6c9oAhxvtwtnuADYU49oNVEMX/I0nGYU /nX7W/T+2atTcpqGSV+MMWlcyPgBfXF8JOA+ZQLTgqneG03JdsHGE0zGnLY7zbXrHbuB6zbkPHUz FatOwCygvfNMM6sy9WQy7rwz44IZBNf99/Mn/SUdyHcgrnICd6wk0GhwyhIAY8yL2BhoITWCohFo sSKOCFZQjKC/2HnYhYN3ittTsz5pqiBDy+MRipFjajzzTWYEQgqniUe7w+9BnAUUGDRMPscULGtT 3UE3ahF+pYVXwKxNJ1vZ6O3ny/vXr++/P3yWTf9sex1ErbAOyY1qjAOc/z7GNGqtWdDA0l9FGq3h 7R8pfTX3RXvy1d60mAQ4ULDEDAou4WeC5q9QheIiXCw7pyE13zsuNDN2gARejuamhilqLp5mkva4 tDvHu8usm9ZC2z2YfMZ8c6op2TLOnXhDyWb9CY1JdKVNmhsmynF2APVQYLBSuQAJpSk8M2M7UBWD /ZTmFbyEXklT8pPHkHBHsjgFW2AVr7qv8FCYIzVYS/GWitDy8KyVHpLIbbKwDx1sEYFEhBRDPz88 QNSeFA8Tndhw80Rxk5DBIGOe8ooLawWJnTEfYPxSgxdn1jaoUkQnG4w4//EPFb7w6x8vD/99/f7y 9vLjx7BkHsAdkMMenh8gv9/Dp69f3r9/fXt4fvvfr99f33/XUsWMdRcpO6Jt85xeI17P94RUyoaX ZJ9kYlbEi5Tnuc9xYb0XzhPgcCsCKC6mhQ5xp/8yfqpaZdavnaY5z04UjeAPfPjeUkHs68nsyGDY OaKb4ef3tf/Nn1DdkY3/srOXCBivxeFsaWbfkBMyrY99TlGdbKarYrNYxCBtSW4CS51VVIAejiwT ah2TAGLHJHfjXJUvz98fsteXt88i7NjPL0pF9vBPXuZf6qTTri1Rk579DACw5wKdtQNgltR2Ezio pyGqVINayvVyaVUMIJsNmRDzdYXIuMBl4UJMXmuCosXhqyaUte60SJhLW3Y1MocSqKjNWVtm16Zc 213V5Mq/NX/D12pGijq3NLc0M56RsIc9hUp4tywzGi6s81Wd6zoQYZsChjB6rRmhOVjBodsibY8t px80LL7XplRJ9R/MgKWoRycpIo1Fl25z5GgH2DYkL/uH6zSrAd08W4BEMsyAuAEbJEJvV8ASpvvI DhDNHcCoS+CEVykjngCIJhncin+LeErp42loX7dmQyF5oQNAsxkCDtiHE7P6M+PuDFiIUZdDJGER bkIwvHjj+I47R+b3IBGMAzQsnwCQxsTqFK0uVkWN1ctaBdOaNDhVCw8WtuQojaY5TF3wkGzss6tr EQMHgTc9Xcta/rcV+QTgYlV7ykC+0inNoY3AFm+qdBr2Vy5LLt4UmEQsCjnR1SfonCpCo4osUzwN VaCqQ0EAMQ312Hga0FmWKRq3ViBUtHFn1pKXH6//++UKbrMwgSIJA7NDA4kakqv1reQqBtn5FIeL +HSA9C54CDPsmdKc3Pg+jolpQyL7LcOl7rCjU6wuCGTrlMJCZY03y9wASOPYr7/xlfz6BugXe4Am G0I/ldwCz59fIOuQQE/bBInDJJockyQ1bEh16DDsGKo2DJUdFDZj/cdtGKTIdA2aibtNH83o8SNg PB7SL59FNAz7UOByvUgShH7eKDhW9eO/r++ffscPHP20vKqXgzY1XMnnq5hqiEljRuSMi5j6NJNN Yl1+qrW/fIJQqr99f/38v2ZkwVtattjB1pCaJvpbgQIIB3th9wP+fkst/sZAoO6Ppuvbrvd7I431 eaSCqbpzIV+I9UEYsGBJi2lSB7xwh+pjKTjIPKHP314/g1eCHHpnyoaSLaPrbef2P65Z3yFwoN/s cHp+B4RY65tO4JboovM0dHIQf/2k+LGHyolGJH0EZYzDqU0GGKJiHY3025e2qHVt2wDpC5XRVsG5 3FkmBDw8jXXZyNrHcBsiFbqzFscQCW9f+abW4i1kV+Gkp7d3BAlGN4F4gBMy7bgoPcXGmDoyldIC PRoMMkbA2eY8B4dVZDVNBQbfPKs6wamjs2h3d5TIpSvtxfSUGLhq4d2nY9EtpDS6Db2gNlujwrcx /SIlHJRbqixn/Qorwvcwp0X/WDHNhlCvR9RARPY+VY9wzEebKmsYyFJRFvkeJEc73vhsXCjTrenH BGLgd80ZUyvnOcT1iHQv/iY9GE4b8rcpIyoYy2mBlO2Lwjj9VAV6pu+hAggKA4pFbeMUZHCakeFX jOHnyEzchiI2AbpqPPt7jJzoKAtE3Asz1p8ArBYLhzXVUPJ0bBtdNy65tP5AQevdaDw9xGy5prpG QoawN4dPRE0HfXvDAWVqpoUWyCquQxZjppaMgsgMq86oUoqUBz3AQ8slg2uhK3JbKRLqXxuYriFx IC4XalGZ4bfWuyNV7TBiUNqCvuqmGWpAsNRYMshhQZcM1SS2Zg6dNnEtdy330G/P338YFxgUIs1W eBlq4wPgId7QgDI+pHsnetrWVxlelmRstpx0rOULvrNL8j0iIhg5pRHHyKGrYgTOPyAQ21dwLJQZ NNvvz19+qMhq+fNfzphE+YmfhfaImA5cWWsoFMoMfZehZaan1G2ypDcAjGV6AhhWmGgxkFXtDOLo FsqPDWlG4kx7Q4pfm6r4NXt7/sHZxt9fv7kMjJjLjJrf+5gmaWydmgDnB2s/gM3VkFFh1yOjJ/jm FbYzpN/pRQrtPjArt7DhLHZlYuH7NEBgIQKD1z3j7XDsQZEwd0sBhvMwGNs7oM8ttWas0XUXAlBZ ABKxtGz142JmuqRc9/ztG9ipDG8V//76XVI9f4Jg4NacVnA4djButXpn0hfP8cYs7zUNjMR9RMkq 3JdEJ4HgscIf0DN6/AgnW6ttpopcUMGU9ZemL9FALKIUlxWHeGmDhHtnvOQz0Mvbv38Bier59cvL 5wdelfdlWHymiNfrwBk3AYWkoRnFPLU0GuutAjAsd1ZLfXRA/I8Ng7igbdWSXD7n6B6XCps2IvgF YINwZzZaHGYhdNhRsbz++M8v1ZdfYhgsny4Xqkiq+LC0OgP5H2ifMSOiHRg3lxxVfAhWLrT9sJpm 7f6EyPcRLlQYbupwTJYpgD0TAKg+hbhuVzDsKkxXWZxAJdwz7yBy7e3PTGp/aJZoV17Dqv8/8t/w AbLe/CHdNtGFJcjM9jzym6PqkWNYVtmXF2O53/+gXsc5ss58DuivuYjyw47g+m0tJ0EQpZEKphku bFzGLyGDjR4Qh/ycRs6eFtXBEvRMl2DsDcYuabVrsjLMrzmnASKDR07gWHDRhhAkegXKkxdFnaro owFIbiUpqNGAIWCAATN4/ipTjrjT78JQk1SZSFDUXOAS113KJQJsiA2YDFdgRCsUma3GRAAyHpaZ nHkCTAynBPUei4gBTbrdbrvH/fEGGn6uYBb1A7oEbk13NZcBVhxAX57zHH7ozbRxvbRLoOXHNPZF zUiMm3aoAfSKjMEpSiGVcYd95WzFwbbQeVXVbsUAFU7vIsKS/lA+UMgIf0CHG7cosqSJfAFnxBBE iftx1u1coHFLaEDVwim7tI5zLhAxjmB2GycX3WBQBytxlem9NgmuiKpjWLktEcsZ3hiRfkO0bcmD 91lT8fvfTDSkoUELg9tZSdMD36KaH++GdWOeWH7Qpu4bA0B7K2DHMFkXPfKYIJTOoqBDM+HHa2E+ AAhohu9LgfM5cEokaQ4prpY2eiEZytcfn1zlAGdLWdVA0GS2zC+LUA/5lqzDddcnddWiQFNlIjMF t7ERnCk5F8VNnZLTWXIkZYvGtG1pVliDLEBcLjW4MBqz/TJkqwWarEI0hOkudWkZ5xU7g9UUqI9i I0Bk3dNcO6RJnbD9bhES0x+JsjzcLxZ42jaJDD2ZNtUIt5xojad9VRTRMdjqiVYGuGjSfmEcY8ci 3izXmLlpwoLNTpOEmHFEMMEodqn9Vjg+cjjqt2kXinfJniUZGvkdgrz0XFA3Xy4vNSkpar0dqmtK xtlJRZhj57VJwvmchpoMqIB5eiDxzQEXpNvs9OyHCr5fxmb+UgXnEma/2x/r1JN1VJGlabBYrNC9 ZjV+7GG0DRbWcpYw24RpAvaEsXMh5eoPYyziP59/PNAvP96//4TwHz8efvz+/J1zy++g1YBPPrxx 7vnhM9/gr9/gvzqrDLov/Ij4/6gXOzWsY0A+/XIRus6HDtAv7y9vD5yf4vzq95e3Z0i+7cz0hd+s g0ZtAqENn6tvnPT4qG1qsTZJzufCNC8Z16wPbJgkHUlEStITjVKkpzDEUP2UnQpC2M/EDDpg2o5K 8RR8dJT84wyQiJVXVNoB3RCa9MDO6qmwY/3RXZQxokQKiDLwsaBCL5mNy040RrXi4f2vby8P/+Qr 4T//8/D+/O3lfx7i5Be+6P+lL7WRUcGdluJjI9GoafJQVvdjGAocEFhsmGGKDozHPH4OA4kQQYlP 8ypI8upwwB1hBJoJdxiVx2AaqHbYMz+sGQP5GJkjfumPYPP7VPwtcN42QCI5pE6A8/uX/4MgSGsv AyYy1YAMr0fjlaim1po3COtWR52Buwr7UV+rk6O9MEWazNiF8juZXV1wWiC0JD8Tp5HWHjL2YQ28 qOsgYg4P0JhmDADhDGxUQeDdpjFV+oAUsUSxvovvFWOq21gzUfjv6/vvnP7LLyzLHr48v3PJfXLS 0BYSVEGO+hElQEUVQRTWXNiY5ZRfhguniN7Vqb2AgNccjH8CXFLs9CycAmaMxlEayViQOL0Q5ztF 60nBfpwxuBLIIe+mWeSxaugjvn+h05TzG8EmxDRzclDAEgIbTUZzncsQoCwbdzmfoU/21H36+eP9 6x8P/ITFpq1O+B43T1+o9JEZ0cDkt7uVvZ6iQlRrP+7Q6hfICm+3x7BZgeJxkWxWC48TlaAoakpN Zg2gJdttVwHGpgo06PydMnMGZoBvnpTPmWGg8O/nt7ffnj/95+HXhzeZ4hczyoPyktPDeE5ETNZh RSKehJO0lY+NExies3SfuSIR1+nCgQQuxCVarTcGDJH/OFToM/T4tIMR73SDqryXXmNMRaDuOXaf Ur7BN+mBsrbxZawZtRLFEI3fHdZEOyuTwmZhRcnMtPwfqKTiDyIskkPaiDjV+P0KlVDQgVKmv0kn wiiW8Q6I9DjE9P9PICgxBM2uU5ztSFR2DR+SlaRmxwpjShLIlErFK9iFQvRmy4sdqvaqPDjy2lC+ 8OYo0gi75BOhyzdGIFYmNROkoOoWmkCcdRFmK1ZMU46BRWoAntLGnqxx0eItSlKpizTm9+yRFTkO shf4cNLYCP9OlpNTan+I37y0xU4AmEBhQecMhBh8ZoCRGNFShTJIaZPUFHNqR2FtoCEAOuosDsha 8eFGCZiaEK0P9IWg2UI1OoPAIDieGQIW1QhaIbOzmTBB/gbu1IFlhm5gIERThiuk8DE6WK9OChe3 eJQbhUa4bSkzpmn6ECz3q4d/Zq/fX678z79cmSijTarMa6aKFayvjjEe83Ck4COGz8dIUXrGeiKo mBUTcBBS5zowKgWF35KpkCqR5RhVZeJzDBM6NhQDDTycSYOfi+njmeT0aSYKp08vCfEWU4InwylI DOHF8BVce1GXzocB8y6Pz0REmvSc4PrRgyeQGm8f8/id837FMtcVjm4jNV+4zSoYZ+CLxQrUocP7 i5jupmLM5xl9sVTmE0IqvH1fLfPCExGdNHGJHhIQnU7a4ZkJ6gHsXWWA9WmpVXw8gu9DwKalH8cZ eS6s4+sT8DRpt9twjW9hQeAPwsfZ1TRcLHyvFZBH2oviS6Ty+MEKB0U5gthD+/v3199+grpKGe4S LdGFwf0O1v9/s8io9WqP4PPbmqcJv2uTqumXcWUIge2tPlYoP6gVIgmpW1NbrECg42vgHLxTAef5 jLMsbYNl4ItwOxTKSSx4J1PJw0XcCrWNM4q2Vh4vzgtZKugJJbWVLbvXiYI86bengTKTLBTJLggC +51LU7Xzst4YV0Od/GguW0rwDzYxDoe5r6yNm/s2R47H9QCEb+HngW8Q783mmTOqphwvIH0Z7XZo KmetcNRUJLFWbrTCw2dGcQHXhSdgfdnhgxH7VkdLD5VtgK9VhvU6OhTE2CwCIHyrfNSogkZapXq9 6PnnffHKpmEDxxqjKSXWBq3M5NWjX5e+yJVjoQs9F+iK5HJPzkyZUIH61hNWZkDjoz6i8emf0Jfs TqO57GS+NcRst//zzlKMIX+kcZThT1t6ERGl31j7h7TgotF4VHtEpP3Ck/88wa9u7ZuJeVwLdu2M x6/VS6kXgelDeYgLPwwSneLuqVp9kCHXjMsYpeHdtqdP8ZEalooS0pc1UxoEkSTc3uVuTRlp+EVl yJFZy5dz4BnXrD24WKTaJk3BuVhPGWKOd8byvn4Upj/4hzi+ExvfS3KgpMw8jA8Uh97jR9aI7S+4 ueZEYH/d7atM6mqsXdQTRCtypIzCLW1cwEfarY9J2B980ayhFB9GP7perLw36rFkEOkY7y4gvTcC R2IhyfTunMk1pejhRnfhWvf10lEqotC0hvFllSqtqEHnYUnpAQ9lweGemaadrwhHeD4CGF91K1/L OMJXxnZhGRZhESzws4Ue8CXwsbiz8ArSXFLT5b+4bFbLrvMunOLi3YAFiGW48FBcao/SoO5IsNl5 P8dOB8/D5OmGV6h3TzlO3xkEPgKkrExHirzje8eTYCvv1kLX4MOy6yw6w0Ig6u2hcWPuhBPb7dYB L4srhU7sabdb+UK/WTVX9lXB+77lM/43SoInPbp1i1tj2q7y38HCM3FZSvLyzudK0qqPTdMqQfiU s91yF965gyC2dWOnGAs9S/nSoXHjzeqaqqwK46Qvszv8Qmn2ifI7Lf1/u6F3y71x+s3Zn5ZpeLq/ KsoLTajBbIlH2QQ3OtQKViejN5weTQqklVCZc9LyQEvThfLIhUW+MtFu3FLw3szoHaG7TksG2VvR JfqYVwfT4fkxJ/ycw62XHnOveMPrBMNKH/oRTWOiN+QMFjWFIbc8xmQLARjd8G0jAdhS+W76pri7 aprEdPbeLFZ3tgsEL7FiTuyC5d6jsgJUW+F7qdkFm/29j/HlQBg6cw3ENG5QFCMFZ6uNxyUGl7HH XlYvmaaPeJVVTpqM/zH2NfModRkEhoL5vLM0OXtnRnhl8T5cLDFDTKOUaedC2d7DhnNUsL8zoaww fTlZEe8Dj/FeTb0cvyjmKQefmEeu7p3SrIpBJdwZpviMH5TkHhPNWnFJGeXaAiSG+6vhbHLepK5v RUrw2xZWXOrJaQ8Rnz2q2ZJiBht6I25lVTMz3GByjfsutyUAt2ybHs+mhYGE3ClllqB9Qi4UYnl5 OTxOE9ecvYFMNcyTiEHR4LgcjS2hteli3kT8Z98cffk0AQvBImP8lVOr9kqfSjPFiYT017VvoY8E y3vSrRt6SBn9womdU0/4fkVDOuo/2RVNnvP59NFkSYKvOM7n1dgKKGSQEHhA0w0twAtAdyUayJrU BkbwzGtHThox55L6mippaBsR1JJhaENfnDu3ZQCd+7SiAG/KmY8rKohF0KSemJEGoUpg1Xle/ATx HUlc0ND6cbUI9rMEu8UG19EJAn5+QiRP6nlCFCQXX/BGge7qGI3jdrwZ/gfsyiGGiJAmkMj6AIYo HKVXIZ0kKH0AuOMVOnGpCRiEHD1vYUXixymlvp9A8r+Rl4AvmW0HLvp+/G47j+/j26E8Mz+J0rbP 1bFeBWBYNtOI1W4XeAliGkOQLC9aaky9eDjZ5xqY1CBBhbP4Nt4F/gaKGla7efxmewe/t/HDIUe7 VCwSfVnSuM5nZkV6RHdXcvOS5GD/3AaLIIj9NF3rxSn9yV08F4b9NELcn0ULmf1vULT+6RkFeC9F KezciL8lEOmz/Ug4f+ffLKTdLZZ+9ONsC5TIMYMXUoIfzyWF2ZECFtSPbNNg0eHiDbx38gufxv6P X8BuiqVevLrKD/ysDBv4G9eG5Z5Up3WNwxn+RAEh0GXSD8cuAVAx8WjCAXkiV582DtB1eiDsjL/k q8jru2CN81QTHtfdAR70UTuPXA54/senmgY0rY84v3+1RLAhcnl/RUNQA/n0nF9YojCH7MIAk9+M cq3xEs9/zpiecuzaY/INGFuPo2P33nL7U3/0THVMmnwfbPGJ4kU3J5y/J816HeIvjVeab8LAW6NP fX2Ny+Wmw1SC5mAWplZUADzf2m7i9aLzJHvQa8Ufyj3P16ula1OtMQFxwXwsICAzXIzTWzO8lSIo 53mE1tfQJ7sALvThrvlqv1n7cMv9you70gwTKOxmNowaLQWXEIIfX8e0KTxpYev1SgXawtENZQWa g1JvDvLAwVndtGkJ/tEBKSyYIRIefpnCQKT4EVVcczSSqdEqJKBrwdfsIsBTSgPuz8UczvPYALhw Duevc7H0lwvWftxm6a9zs8RHneP2Vp3YqGGvF/zIiUXyGjszBlJBQ+zX+qYNO1S6N4q5mlBxh+3w /SVxW6RSjhEBRZlT1T70vPkpLJvFJn7sNlySWaznTVN2YpfOfncGyy/Hme9Cf/FVAlgurPmQ193u 3mSZBuT8Z79H7eb0QmYUxvgahHcXhak7u+ZBuMaNcwDl4WY4ysfoXHP7BRFpw9MtIQ5r95Tw1uNN AVQQNNjzo16tkLjT0rS/eWzLTJhdxZ7cp2MOjeOVeVQUA1PaQFJx8UkPJ920vX3VCGXC9bUg3cN1 SEgSff/6/Pm35y+ftQAN2sEA9vU0XC0WhZvSQlmK3q1Qqw/VXIqnIGHe7A3BodBICI6px0UH9o2+ QVv5rZVF3b7xFtboc6kLKEtQdezFzAF8Kfo6yk/OdNAv336+ez2vaVmfzXTzAPBlfJHILIMQP7kV DlbiIGWiz4xcUjARFPFUEEwikiQFaRvanWQMpjHq4RtMOZbQTBWqziw1AvKYcMhMoWssLSzj8j1f B92HYBGu5mluH7abnUnysbohn04vKFB6l2mT44tMJguc0ltUyWDYCj5AuIBTr9e7nRezxzDtKTKW /4h5bIMFGsTDoNCjeGiIMNhgiETlM202uzX60fx0QsPXjASgKkYqFvH4YLWleGfamGxWARboXifZ rQJs9OQCxNtb7JYhZlplUOhpZrRau+1yjc1JETMMWjf8KkBbwcoL6+trwwFzTTG8mHUoX8q99ESz kWV6bU3zi2m87GQQLgnkvoU7ETs8RqKa84jAPyBfn96KHUxbXcnVNHrUkCIHGJ5dcqI6l6cI20b0 kW1CrDkQt3eFwNt4yTcXVqItwr6tzvERH92Wi3WLJbZRuhZvW0xq0OUhGCPh3rRo2pMYYPSg095r 4Cc/EkME1JPcitI6YqIbfjdOFGDBwf+tsdN9omK3ktSgqcM+PyJ7VlhhUyai+CaiF99pDYSaPjkJ DhyyNAdmSne0dHFzjYEAqGlOPQ9LU2vEwvC4jk5kWRWDLBNj+jHtm3hzWNpQgqaQE2hS13kq2uEW hfeP/dbztiUo4hupPaaDAg9j5cmZJQkujO97Qtxv+x8EZa/GJTFX+0RlJfQaL2nGsR7rTEHSQg4H bK0oNAyc5AKmpaIBwZu6hpSH+musjt/t6mK30VNR6liSbHfb/RzOTuBlUDScdQk8A2QQiihihWm9 gRL07RITkQ3aM7+GaRfTBm93dA6DRbCcQYaeHoMSoSrTnsblbqlf0wbRbRe3BQlWizn8IQi8+LZl tesj7ZI4+dG8pCu/YalOnJD9YonvNpsMDYZmEMHKbyq8j0dS1OxoROrX0WnaUg/mQHLiWasSp44b 39ClXbxcoFK6TpWdP9KWnX2VHKoqQYMRG32kSZrWeFNpTsPADDFnoMFS4U71bMNu202A1384l0/e 1ZOe2iwMwnvbKM2J50hJc8+0Xgm8FV93i4WnXZLACGGmozk7GgQ7X2HOkq6NZNoGsmBBsPLg0jwj rC9o7SMYrh9sLopuc877lnlPOVqmHR6aQP/EaRuEvho4iyoSu9ybkYRLuu26W2zwpjaE1VHaNDcI En31fUz8v4Gwtnc3uvj/lXr8qTXCcxzx8+7erpo7lK9JK6wpvGvjymWYwLtjrsV+i74EGa2EF8yq qCtGW8/JAyTjGYN3FZ4ySfmR3pstIFwW/s/Qtpj7Rtqem+jeqgLC2b0OBEkRw/JFoww5jWpmtoIg SFytttMiyBFDcgn/Oz2o2qqeq/Aj5GC4dyCKQcur2TENsWcom+rpBhb61Lvf5exwTiRerfGHQpta HBCz1RF2c0bLvyVpGwaYwG8QcnkarkLPUc3R4WLR2fFfHQrPiSmRW885VPSth9tkNE9J4sMx//Zn bRAuQx+uyMxMKAa2223Q9z6jPzXbrBdbD2fxlLabMPRwjE/C68H39aY6FoqpvDdjXOY3fNyUlEzN m0dCB669r0pc4aKRDVRuLZyDD1bYqanQgunm4r51JkhsxHnc9cKGpstuwfvbtroDv1LEFqBi6S80 aoiVpGcgkFoYvxppUMZ22y2frrFbCHa/BHPsliJjxwl2+3B9Z+gE1X7rr6UguxWqm5R4oQ2MOAeo +yBoqCSNq8SDE0NkY0hLRXqwNg1tFGia+J2k0G5bT137EbcgHVTk17QpiMfgWNLcUuJJUyzxcREs 9u6nISZODtOtBtJbvuEXHkw8vnbE/gyDnZ+CdHXIV3qdnpyyUsM1U7kiQIf9PLxHmCNG8oIwo0p7 TONsvdgsl3xVYwb8I9FuvV05tV+LaenY9XKcaKh/JE+7xVrtIXR5NVVLmhsEcFUr0PqElO/u7A8g 2izxLSh5tR6ZpKTLl6sOO4kEwqMqkDS04AMen93C/OAMN3tcCzQsTmJLfRYFvLidokR/kPN3vbmE cPYebYWhht6s59FbH5q1cAwG9sA2BV1Zl7UAmYn0AMKKyIJki6ULsZkDAQ8TFWzapg8CBxLaEF2J rCArG7J2IfAII16ejs/fP4sEjfTX6sEO7ms2VvyEv81sHBJck8ZQXEso5EY/ma6hijwG7TAy2RKd 00jqpK1iDcHew9W3ZKAbtBwHgm+Av2wTm0pwBa4jBCqfnHT42RqpAylSc5AGSF+y9XqHwHMjOOoI TotzsDhhposjSVZI4X18J8emdIorjrwCy5f435+/P396hxy8dgKFtjXYmAs2jueSdnt+U7Q3bXNJ AzwvUCXwCNebqfJcJNiFiKaQctR5xWYv31+f39yMQ1L/JBPgxPoRqBC7cL2wl4UCc6agbtKYX8QJ lu4NLRJs1usF6S+Eg0o07Z9OnYGd3Qltk4jWXemhNnSkEbFdR6SdHthVx5SNcExlH1YYtuHjTYt0 jiTt4Bg2X1N1fEHK20xeY52UsDrlg3rxesrqxCJhKOTRuDOYMtCtnXDD6CTDrmmjjqvpQqPPFctx RHL1fQ9NsmM0qA13uw6vtjIyTNkY2HoV+FOcPURFu1lvt76W4WnXEULnSdekgbyXUwQnmULm65df oCinFjtShND/oWVlN2uAi4DXsfDYG9tUuEmUtclFJlfwUfCmuR+q9doeKwL13OwfACdKt4LTwuM+ O6LH1vorh+2RU1OEsFDDMXG/kukACCwKk4/RgN4z6KOe807BLu1uvcCOUom439DKStOogbHCzlTR jKLOxQM+jssO+4BE3G8fi4MNZaAVRQdsRPsx9uOcwkdxsVl6LAiHhSpZmI8tOdhnJkoIRE47NBzI 0+Kodo56nSgi56Th19+HIFiHi4WvVYL27vApz5maDY2zazMJ7ldoxAKcYN5FCzi+B2S3A+fzTe3j OjkSIkflNTqqE8r7ZUFCyyxPO0/fLYq/s95j8K8XydLpgcacKcLyhQ4rEPKRu6Mlwd5ms7pJUKC/ RFssHSZ7gP+dTsnE2fNLvEmwA5dD7y+ZguZRSkCNwGz5xcb2w/ZwmmhQoX0a83saLKn9NUgvPhiv 2R8pZaqWxBe/uOwPDGMuyuqpsgLuQELBtsWdXUSidX5yooqk42XIXz+NFMCMvI8A6HRjBwXQ7Wj1 +mJ3FQqzWtNSRcOIUeLt94aD5DjwIilbrA8CYSpV8vnbpK591qkq5PBcYVoXtD/yect9prp1ESmn feljkxE0luDxyiXaMtHzO46gHhh1LlUaWTQn7OBg5SAisloaxoIaKi7C3RJ3GJqoxDt435QH3K5+ IrRv8gkjx3C2MLBG/BsxXoGHn9MJCjTC7ERRtCdseNLuVpoRZCdczFchygWCtRS1/M749BaeyCIc dfLhINmu3G7Id3hBU23QxvxPXeDN5QjscQOKUGa/MUmoAwBexV5LOgr8qkor2LCOL8+XqkWZW6Ay jgwAXFrI49NU3c39HGuXy6daT09jY0y9G2ck8pt1ogwwx/PBxqtsu+oId3Uf+oTJwW7O/B6NqqoF vQSSmx6UqK5Zvd5gGC9hnAlpkE2wzE9uwbhAbNqNc6AMtiHjOPx8e3/99vbyJ282fFwkt0YkMDHD TSTVVrzSPE9LNF6aqt+ytJ6gRqCPAZy38Wqp20YMiDom+/XKzGlpoP7Ej86BhpZwJ8w0s0kPduVJ 6inqVF/kXVzneMrr2YHVW3FM8zpthLLK7P9gk6nPQH6oIjomg4R6Rz1d9POHNnEyB1L8wCvh8N+/ /njXkiC5mi9ZOQ3Wy7X9RQ7cLBFgt7QHjhTJdo0ZySskxPs2K6KD0lGHMdTyAFCQh2ll05fiERc7 xgVWRLrj6+5sl2OUrdf7taccx26WC6TMfoO+unKkFcdIgfg5he/yv368v/zx8BufHTUbD//8g0/T 218PL3/89vL588vnh18V1S9fv/zyia+ffzk7UghV3jVK2j2uAxGHiHuPm1g36s6AOFVohGyBBpfo NrJLqYjZnkIxHKY2dyu3IqOH8go6PSx1lpcWjX8oiAb5x/5SWqQX3xqSt721MdzzTRyNeipu/S1G rOyicwCcxXSO91Na8FPFOfPazRq1kxLIy2bVmfm7xern3FVC0Zdfjq2Ec4X5bZsdE9suns1cJkg6 Z+1zUM9y4klJAhTNCY1BKpIPsmUcroKFe/cphAWkhZV7QUA9+YEEinN+GW4vO+ExO0vADoo8DTQo SXFon5lwCNBBWqpLxQC+FtbtPYYZk7l//+TMxRcuJXLUr/Jgf/78/O3dd6AntAIT+rM9hCoJvQls qqhqs/PTU18xmtlD2ZKK9ZxX9Q0ILW9mClh5+tWQB1J6m4keVO+/y+tQNV87/cymP3XhfrM1q8uU n+/wCOW7/OyZPGN2XgIFq9NaSABSmYzdwwhytHmtsScSuKXvkER2NBWtUw6TsDRWdpyUDGB9AaZ1 qABw1fCGqIwGh2O1qQU4Mk+gmtpN1VK39cOnt6+f/oPxjBzZB+vdDnKy2Y4Sqr9u+VEal/zXND3C NJHGA6I/NNW51k4vDjd4S40eeLXszIupbNHaJ/j/8E8YCDlpTpOGphC23IYhAgfDlj0C5/cyDuVX iMHgDDhhsoHdTyMBdrENyCKuwyVbYI70AwmjpRXCfsR0wXqBndMjQev2Bez6OhcsbW9c+NOtfHSh whrGBVdxmlfINwVDY3i3GZjlGuud1FN4HYYGMs9r7oQOQSCYGaQobXJaYi2AxYNmETVK9tEBWWAT Lk6wukf8KsaUpOMgFMigceB6iYI3DNkDHL495zWK2BWFB1564DU6V4DBXnbHdQ4aYWRjNQUE0ltu kcU04HbICAy4PYJzfEsHxKgaQuFQJ7pblsjsCnBRB+uti7NYEAMcLjyIpQ/Rd5aP24CdffsdiK7F bmeaU0rVwsvn1+f25T8P316/fHr/jthbpLRsTRXbOJPtqb8gQwLwojKUUhNquwn3WCc457zcb9H7 x9tG54RC1oBkUnRnsgHD77tjSQ66eQVp4qNkbeMza6tCiguaaS78NgwKFICLFKyFbKN9Tgsu+6+D cKCoMksMGYrQ5tGOmiOvMPug08pBKqWMmXUNN+KoLXr54+v3vx7+eP72jYunojJnUkW5LZdGRMRV qz4psFpA3fkl7WoLOwicCLg7sFFINXCuECr1Vl4pVNr1Xkltjf9gI2PWk7Xwj88MQR+4OblJ0jW2 3CvXRX7FH3MEVgS2v+AehIKgiHYbtsVfiSVBLcy1fa2yDlIJ6+xhNq1OpEFbvtgETm+aBFMXyEVH CrJOQr5zKueL8pXeBt5YbGqSBdhneyKQmnBmlpLyla/YU3pBpgZ4Ff/APnlrg5C3mfKUHk8f73Ya 9UQC+vLnt+cvn91t5oTs0KHm45vClPaMHa69pWyQsw3hJTxmtxNBOLPEhH52eY8AZX0UGgysO6u5 bU1jzuUt3AXAVk6ofE2osoZRnmZZMj+8UbJdrEN7eKOENzsorhcLLm2vDUmqjft07sj9SMqnvm1z qyZXASS3fb3ce+IUKvxui2pURux6s7Z3tXLIsPexxajLIbYDVagZAf+b3QYDh4E9eAK81y2QJfiR 83ZOFXZ8C7mZpcOiBR19DG3g2l0qHLzfr3B+wF0SSpNO3aVi1hq1O/+Bysv/X8aupDluXEn/FUXM 4V1mYkhwP/SBRbKq+MTNBGuRLwyFWt2jCFtySHK/7n8/SIALlgTLB8tSfomVQAIJJDLHEvxxu3oj 4Y5JQMRHBGfmET24wqw6m1US3o3o7lZV14MZNGckBy2D9HDoiwO8DbGuIEzjl80NL678+yhEOK+Y +z//eZlOcOrHj09lFjJOcYrBnei0VyWPCckp8RPHhsQEQ5S1TE7gXmoMUHdZx/zLDKhL4JqAHpSz KqSNctvpt8e/ntVmi4MoCH2oVkjQqXKfv5ChwbLGrAKxFQB/hzl4K7NwuMpVj5oYD0Ok8KDP52QO oebjiT3ULZ/C4doT3yrZ9yy9EjhXHIhixwa4OBAXjm+rYVy4uGKijgxJp4H3XmN6Rp36c6wvqBr2 QiJPJ1XbaflBlCC0e+kQzGDZLgk45t0dPeYX7HWQnAA27dM+H81w2tTjmqjEZz/L0Zjg18FmVC4z w+M5xgmnhzfaUA0ZSQKC9xmoocSzNe9LY/GXKzP9ao0tNx8yy3IFcaNJZ6aR9cI7H1bQvBu3YvJA QiuC7pj7Aowk2CqSy4aDIkMUa8COBodEYfTUddWDWQlB33DSrbAdL1bnxBCqAViR1szPVjkuCQnx 1g4Er7JUCjLCDI85JupqR8OGhFnwAu/Sga1HD8urY6R2YCICYT5AbdC0tzl1diGOi5t8zSwgAUNM VssMsYPlLoTnraTSrJrpdCcNy7kZClHE2dOIc/LdFxIpnuM0QDfB1mG2D9io9MyVD+OJDQ72nSYv m3rjwHOPg9MDpNGMrjzenunggSVyfDtCsLZwzNhial06P4jdZCppB6VsDDA+DeQHjTMAqgmJTLq6 7Vqz4d9Ubs2S0eCFATaSpCq4vvbWZcbEm6B2YgpRSxYpH01tUpEEaeX0LN0E2Ejx3eCK1YlDaJg3 mYMEllwj9dJDggJW4HauTNVzsMS03nk+djM+M0yaX4QNt0N6OhRimfS3vlM/JH4QmI06ZdR1HIK0 dlHVzdbmSZKgbiS4NJf29fAnU44UzVsQp7vfoxp5Q7xhevx8+esZe0wIr3EpeGrwXWUDqCDYpdzK UIMXNmkFVIDABoQ2IMGrwSA0MKHM4UYRmmtCZJGzAkN0dS2AbwdcvIIMQm8/FY7IlmuEdRTcuqGF 0SwKie3p2MRzLcd92oAWy7RSzLxw4YTHZZn+dlnG8Cv5pTLw9hGp/XDtkGGRsR9p2Y+Z4r1tRrnB 8FDUHQLRkCC9x/ThEBt+k5eBNM+wdpXBPbzB22jWPnKZyrc3MwYgJvsDlu0+CrwowF/JCo4DRetz qAI3prjhmMRDHPSVxMLBdjepWWNGJghVmII1JnIsj6HrIX1dDjEywf6d+Uj2bLvXuwT7YkxVKdji iHXDcie10UghmJHpIgCkghNgvlaT4MT2XHPhYcvflvwBDuIGlgJ8QvDQQgqPj1k6Khwh1p8cQKYA 7BFCJ0TrxDE17h/GEcZ4tgnSzYzuuRE2bhgShgSVmxzycO8xCo+/3X+cB/WXo3DY651g9c46D13b 6uraFwd89gxZKLuhWJIUzZ64uzrTV/TlM9ayCfNKjTx0TNURrutIDNgGSIKRT1vVMbrggIfvzcxi fODXcXSjkui+UYIJnm+yXZ0kIB66neEQuqtTORDx0mVx5GHzDwCfIAOrGTJxOlpSxc52wbOBTTD0 8wIURVvigHEwVRURvE3HI0uaQJtlYxer1qoShjVsHweKFZjugXnhrDVjQWRzRrAtzg5CDO7RtaDc 1WO233db+ZYN7U5MreuobGW3oL0XEFzsMEiPampwdDTwHWTyl7QKY9fDFpqaMB0U2dnyJSaK0REp oNWT1fYS4MUu0o2TpEeHvJDjztaYZyzEsUluhgT44sKkJj7vAfN9NJS7xBKHMSKCumvBFiakKkxl 8x2foAKBYYEXRtvLyCnLE5uXJpkHfw04c1zzrnDxWnytQmt48rl1lxpWjY38ZUMTy0pBjwO+0WDA Da2AcXh/b5TO8Az52NM7FGSXXRdsyY+wyhR15vrOlpxmHMR1UPnHoPBCNgctRM30oxqr7YTgi4dA d5q1lc40DBQd9rSuQ3xHxTQNl8R5rGrLCBuNYrKpUbO2x9iuo2xS4qDqMSDoxa7E4BEszyGLkM3K cKyzAJuDdec6+AwEBD98U1i2Gs4YUIELdLTudRe4yJ7JvA5YkDIN4xBRkc4DxKDC6DHx0BXkEntR 5OGeVFaO2EU0YwASN7flmhDMN5zCgTSa09GBKRAQO9bHghJrxWS61eORzBVa3MgsPCGJjntLhRhW HPdb6TVbCZkuj0y+v0orgwBRpqawehrAb8mo6htvxoq66A9FA067phuhMS+q9GGs6W+Su5CZ3bhp 0fB2bxZx6UsecwEil6tBR2aOvBAPtA7tGaL/duOltATaw1Ls4XCFu5jaqJicAFy6QYyqrDArq2aI 40sVcXiXNgf+A4ex0rPuJH1XyTr0vO+LLzO02SNFDZup0nIPNnOB8SfSS/DkzRhXUwwhjB7XNVbf yTQbqe7cIP5gAksKJsRIOn6Wy6PBPb19v4N3St8xF3HwlCByXbOu0xsDBBD31miKsaFYFQGhPf4x JvsAa015O4bnvx8/7srXj8/3n9+fXz8/7A0aypG2GVYLhmzV4HYZwtfe4/ePn69/2iswGcbLFZh9 oliSinyH+uXp/e352/PT5/vb68vTRhvpYPb+SuP3ytqZ4wrWRY1HlxN+arBq366ZuDjgT5NZP/75 /ojUXbrhBQt99pF4Wei32MxqzUkYrG9O8uXF4hbTJR2yY96iaxT42G8pLXeKyx/5aSCw0OmBnZwq 4y7Y8NQzquWSl62eZv2GEgO+5DIGnpqiETsAFj42oHDu4sxWjMpmLWxisxiEskmfIo0HsvqXqDRY FGL1UThsxczN1jJe22HkSPdVSnEf93LSAwQMzWps4VbYNJt3gekmGKuDij9+vj59vry9zj5HjRle 73Mj7A7QJq9jbIbXB9xAgnNlQ5z4gSUYFTBQL0JDv8+gqrSCG2BhhU1wlZUnSwcSR47xoFRmARuq E9XcgAkE/LuDC7CsxW4tVp5jleXSdwaAh+Zy5GMsTjXNmnku3Dk3RtPP/AGpwasJZocvOqrM5Bdl 0Evc+uGKEGXTB0g83TkhZXIEO86bwZBgSUJMfZ5AV7Ua5tSqwW4gAZpWsKpLZb0IkEM6FJe2vzfu pnhfZa43WZlYB0ndkZBgNwkAHsuQ6W5agD6wOe/mnl5vsRmVlaM5K5nAqmOgHCUACFQJYLc34xoC jduvZ3Wby3YaACwW7BJNRDRwMGKAEEN91GG2GxM9ikKCHSytsPlBBT3GrDxWOPHQZLHFDH9iiBMH OwBZUBIYLZssQ8ycEkyr5+gQKkfmM02+huG0+XJEJSuP8yU6OPNXKbP1jyLhZhf5aY7adc6wasEz me5rXqV4GbUaw5PXRBi/673SD4FjMUXicBYMAXqjwtH7WLaD5qQmGEJXI9IiQ2pJSz8KdZeeHKgD +XBlIRkLHUfuH2I2kPE7t3R3DRxzUVAzGOrOtmSYz6OAyrbyae15wRWiv+CfDNjEAxO1HWCbFWu9 w7Kr6pNeCHe+epo2VZYS9HclYCvkOqrtk3hQYnlcN0d7seQvPUZRO4DT0QuxBRYmS1oz+ZMalKy8 pZEyidGy4xA3sVsYEjTIkwQTpDRGVe+cJoSJWU8OxTZFydC8uc3BNVRDU57FBKWnXIt+dKlCx78x Pi+VSyJvm6eqvQC1zufF6w+NOLE2p9IQVWF4xUxNRDahF0fXnZYPoyaeQdUeIHEReY0D7RvLD3vV DVlffm2b1BZRFHqljn199dNP4laa+Vn107mVhvImia/SRDijPHJjQ9BOiG5Ap6ZCz9UnccQU4arj riY1ISh0ZACojvBYGQb73pD3lyxPPN8+e+YTaRB9fYHbcPf80UyHDEnZW5tNy5iruFwjrrVeY+Rw 7QUD9uUV3Ne31aAZ5qws4OnyJNz00lNtseRe2eFcjx/roQkMdrabOjDxg9XN2JJpUCjHCVsx0Jdi 9aZGAvPAQzctEkuTamHjJMz2QkVimVUSJPms29zowmm0bxZjzBUZMnQlaSRo2ouKhDaEuOh34IiL Dqy0CbxAllAaFsdojuqeTIryxNUJvFsFdg7Q11grW0mrxHPQGsHNPoncFMPYYhB6aEcjjhQkkG1X IkuFOYZvsWSmOCL48xOZxVI12AOgTV13B5YyY/waU2ISK+B2zRhPGIVYBTBNSUWDGH+3p3Bxtek2 Wxz62zXlPCE6Fg11SIPwecShyLNCib3lXKf7labHBNMMJaasc1n34PXrAt/Fv0wXx0FiQ3AhXXdf ooQ4liYxjc8S6EJlIjdbzZiCWwMTmOJtGbDooEhysf3fTN7tSllBkIAsTfwAHUWShmpi+9PXwnUs 3dedmZAMbw1yznWj2ZwnsRVzwQ7pVvwLxFae/LDhIOhVZ81CbGXhau2NRkx67mY9YLeHl0BJ3aXO rYEGXPTmcKRBHUchbr0ocVWHwLXZFElsfIu5a1vdGZ6V99wX+91p/0u83WV7b2VsY1cIdO7dDkMo 0/+dEF0JGRQTHxUDHIoatKiOBm7oobJI0rBRjHi4ZBYaM0HnlBlyVcdiVPpxzLXXU1XBDSy2Yop2 rGCaJixhi3MJbIe95fZK2rdbnEtLHKu5DJJeqHo3ChE63m0mPIi3wqLohJqAqdJduVNcJvWZ7W4i M07HgNK0Q7nXvOzUBXhfBhQe0LZoqA7BM+GSQiiTmRZVDYp2OaG7vD9z39m0qIps8YzN/XrNetzn Pz+elRvVqVZpze+GzIppjExdqdrDOJx/gRf8MA4Q6+lXmPsU/H7c5qN5f7P/ZkdTto7k74RXTPWA pvbUnPBc5gVEuz3rebE/4N1TxT8I79jzy+/Pb3718vrz77u3H6BES5dzIp+zX0mTdKWppxcSHT5u wT5up9xGCoY0P5v3hQqHULvrsoFlLW0OhTIHeQH8SnOsGFvGfsO2JYLt0oj35EufYa2Vhp3kaH3t C63DER554C73m5yYTw7C/3j59vn8/vz73eMHqyXYF8Dvn3f/2nPg7ruc+F/miIdNxM1xlJXmEOJd ytZMok37lY58XU6vi7qV7cdXJK/FQCoPaH51WlWtPjCWhFRO5Ffr6BcXzHqBbK7vizHL1GjQM2Rz CjcNtfkNnpYO9/cpMLF5yDN5Qzchwm/kdGfoj6VR1RWBgA61epg/ZRJ0bHzX2EnjylCXXTlm1FYA z2CcIsahFeAMJTWLX2vYia+YdsMJXSimHqx9L7qOZ/EYQYEWB9cIFSpP+itFajAxDJ19/k8s58EQ LuJevKRWoNQkBQxiAu4lpsGFSmrg4zIWZVKFrWwFJEiPr08v3749vv+jT/305+8vb0w8P72BH6b/ vvvx/vb0/PHxxqTBI8vz+8vfih2EaMhwng/uVXKeRr4ac2sBktjH9xgLh8vUavuIH4o09N0AmV8c sdhBTDOJdh6+e5lmKPU8J0ZmLg08H3+ptTJUHsHsEaa6VWePOGmZEW+n99aJNdnzjSWLbaMi+bXN SvUSs4rnjkS07jYkRds8jLthz7T8q7zE/Np350Okz+nCKMv8WeCkYaAfOE2FKCnXdVzOTV914eUu uhwzAD9hWDn82N4PgIeOb0xJQYYdJAbF5veZyFiK3RC7CUIMQrNFjBziR2QCv6eOS7BL/mlIV3HI ai67sF8+R+TKJ70y2RCE/Bgwkq9kVfrUSn3GnbvA9TfmKuCBUQdGjhTfChP5QmLzwwyXJFGfl0h0 7ORshc3Wn7urRwgyrur0mhD1qFIapjARHpV5gg7/yLV4Qp2ExJUEhvCTN3roFHl+3SxxY2hwXH3b JU2iaEtQCg7M1GnFPR/5KhywnHvOHIkXJ9hN6oTfxzEyPo80JtPZmtJlS/dIXfbynQmxv57BVvgO otkY4uXU5SHTyeU7AhmYXnMq5Zh5rqvm/wqWpzfGw0QnXOzNxSIyMgrIEV+0tzMTxsh5f/f585Vt wdcSZmtgDRKL/svH0zNb71+f3yA60/O3H1JSvYcjzzEEQB0Q5VW1oCKaFNuQwEYwn14WzfsQe/lq 8pYJMe4nQzSzK/XKru3UMWGI/vb27ePuE+bQX8/f3n7cvT7/5+6Pd6b8sGSIWmTugzjP4f3xx/+B IbURG+18SCEumdRsQQDRAVGf6G9uOEPCkBqsU+SRLFPZnrcvLkzzkKcQvE4ou9PZtGiYGHLZRyP7 Q2y9c1qq1Lwb09PVjMjGMe5fplZjAy50WlR72FviZY/3NZ2iiKmZAn2/WyEkZ1anGozd266t2sPD 2Bd7TA+GBHuujS+PP9SiBNiyja9Q21w5AvDKUBXp/dgdHyj3YGkpCELjjUwXzeFr1BDQyehHZXEH 2jDUBoHrJl16ALvttlLhA9vNc0NoS7fZMEhHj6ALYOhZqwTNjsUS+wYsQyaxePf2bs4jKZ0I3McW Y2whnRloWbmhrxbIYz5dO76hT+SQBgYYKEJ7q25CoPb1EtXwv+RMj3mlhp5YiKyf2st4avKi70+Y QTifKWnFZgpTJKv0QfsKbV1MwXtnOSzVQS2vZyq85TkSwGmdM0lgqUHTns5FKpk8TgQ2Vg9p9jBm w1U5NtO4tIMHpJCZUxiIBCh5fjT2m2eWMIuGE9o+lYvJOyx2ntRO7m2wKg/HQRu6h0IbvGc2D/QP KzR/a0efcvy9CP8IVvFVH9IDkY1QODt/4KXRMIN2/v2ztIeoR8e8LhGkOudGS9ra4m6TC48SyrDC X672Zu7a7GiToFNQYBGLUO4Aqq8fFMJDnPhzykKvOYB9cSi5n2EmtA8l+lhUyeeUt1g2OcVeiHBx Tasxz7R6ajFHFpJu+8RFny6Q6VCbS2KXNjxmrDjlfPn48e3xn7uObUu+GTKRs3KfWVueSyVOeqLj V8dhi1sddMHYDF4QJCFSPvtmxXgswXKAbapyG8dwdh33cmIzqUJzwUaZQGhZdzdqW1Rlno73uRcM rnyPvXLsi/JaNuM9qwTbkZBdqr4VVxgf4F3o/sGJHOLnJQlTz8GjSaypSjgJvIf/ErbRx04WJd6m aSsIkepEydcsxWr777wcq4FVoC6cwFFv31euezZ0J+HP2u4kUY76j5T6uEhzqGY13LNsj57rhxf0 W6x8rPRj7sYkwfia9pwCHx8croOxtFVZF9cRFjT2a3NiH8GYSxNnX1JwIXkc2wGs6hL8PZGUgObw j33Rgamg0Rh4lsfhaxL2M6VtU2bj+Xx1nb3j+Q16crYmkZ1eDO2JiaesL4oGb0OfPuQlG+N9HUZu gr14QnljQ35PLG2za8d+xwZC7lkGwXwiTsPcDfPttqy8hXdMLRNAYgq9fztX1E8Gyh7HqcN2C9QP SLGXDfpx7jS1Nako79vR9y7nvWuTzRMnUwa6sfrCxkDv0qsaDddgo44XnaP8YrHDQPh9b3Cr4jZ/ ObBPVbKdzhBFqGcQGy8qq/ihZppdfeKn9x3epKE/VQ+TVI7Gy5frATumXfnPJWVaR3uF4ZaQBJ3O bG52Bfs4165zgiAjkaL0auuLnHzXl/mhQCX/jChLVMn01/c/Hp+e73bvL7//+WysVjxIo315zY6s CweWPezydXk/S0RGarQoslw9YusMw3JdBaphv3osO3CwkndXeFnGVJ9dHDhMc91f9K/QXKpFT7WO DlAXuqHxfNSzs+gl2HyPHY1DgszHBUQdFvF9QQlDqowVB5QCKBOHXPU8gUw82zIhltr1q6nbumPZ QEyFLPRYJ7pscbTkMrT0WO7S6ZhVdf2E4LglE8KIm2iJHec47DsffQMy4bQJA/at1Lctc9oudwnV XHTLO2duwcDmbNpcQ88P9CxkPMLDmChsead+Kx5sOj9HgWsIMAkSz0msfSBzMgXfUod1m68eZwjy mB53ZjEIX0mo+bpFZtisgXTAY4gXUzZoA3iwSYWzp20+z5lvEJbaqUgxNOm5PBsKmyBvOcrgylbW HXSlBKwB2N4IpyKq1tdBE6D1lRqE/U4lZWXfs336l6LWij/ULjl5ukzoKiWEPB/958LYfFyLxiCM ey5yG+Owgu3vNlYelopqqnKd5VpLhzKnWlvF6YExVfM9fhXBdVWX2AVEfbDvJs/l/3f2ZU2O20iD 7/srFH7YmIkYj3VLNRv9AJGURItXEaSk6hdGuUrurnAdHXXE2N+v30yAIHEkWN59sLuUmcSNRCKR h68DnB0Zfa6BsBplMqdFc13H5YGrM277evt0Gf328fvvl9dRaOt8tpsmSEMMM9uXCjBh+3Wjg7S/ Wy2e0OkZX4X6RR5Lhv+2cZKU0pLLRAR5cQOlMAcB87eLNnB/cTBldGyK+BwlGKSr2dxUZqP5Daer QwRZHSLo6ooyR405HLkV/qyzlBVFhH5hVhHbvIziXdbASoyZIYUDcpNX+xZDzjaSwD8uRY+HhlVw AnbFW901jHFwCqIt3A2gobq5ABIfd8zIRolVu6ojgGKyjVYbahaNV3QcpyoWAYrcxfVdZe92wjng /AnOYI1PkdIuHWIVUKcWFnQDt5/pWOcROtRZhAwkEhg6s5NxyisTUh8jbs5sDrInvhDYjeaTUDj6 082ToVusTyTQ40zY4y29S4+gZ6qMj3ZFCPIGIFB4f24URdHVRzc3Xs3HVsUynxdNLtW5dksF0D8k Ld7Tc4l0x4tVNxPT6bEDftYpoLKLaoLKLapLBZoEtBJGkXlGA3F0r/jMXmkzXM10MfZR0IHMV8Me zIIgSuwKYkq3iesuyoEtxmZBh5vSZCqzUE8K3gLIigTCO9fHPA/zfGIUdazgCjEzGRDcAiJrI7Py 4PAU+l0cmQQrUzjpfGiockEqXwB3SgG3MKo+pRXeyEqbBVepxXsRIEfFGX8MKuBrDgbfrLeeVVSH icnQNiBjnav5wuKLtkEeHhHM8ILEjkt/1R4m5CvxwqdJWdpmj1BlkKfm8sMktVOr5BYmrFB3ZnoB DetdGPL6Z65mDtxXd2MVI7XSHQaQd8NxTUDU+6ttD9vhsxqfNvmXmfslR6Ejpj4yhEXjA5dBWbit fbj0+AANsoMKs76KhwPPTtUKNA2rDdwRjrLPvpcXEWWialLMOwqiikWH9C3lvhIeUrclsx/6q4KB gc3bbINDU4igVocvY5KKJ1FUNGyL7ynY70bltRMSC9JtN1JpJCyOovadNCSEFlkoigEhJocs2MyM PeSQeC/9LqW64hN9DZSmqAmP9Jz2FPaw+yk7tweiRnmJkCvIg+OwOFIv2tFo6lfpz8dcUZKXFRnK 8fbuj8eHb9/fR/97hCdv6+HgGJCgYl+Y/6OjQxwYSiPEDSTw7k5lbwE9Be0B2OPtOFgmxswDpjC9 8yxRoXDqOSURLXP0dK4PkkPCQvRNHVNNECgzkU6PpHLOUUNDZBdziISLuJ6AxUJdkZhivViQg2pH tdFaw7IwLxndI+WkNthU079eq/O4mI5XSUEXvQmXEzJqlDbYZXAOsoz+3plpFSh0eB+oWuC6p16b FQQNwOjLnan8ASaRm78a8VAGN8OMRkBlE0ONqeGCpK6mUzo7s2MGpsrmea2LHOJnk4tD0YwJaGLg 1h7B1o3JvD9GgVnYWOFNEFToDK4FNFESusA4Cq4WaxMepizKdqiSdsrZn8KoMEE8uu4ZjAYv2SmF O58JhL0vY6Lk2y2aU5nYX41MvwoC0kpRV6a7F5eDhUZfxihm6Fl1xiOOdJtSvc6NOOE9EJhqDR0n kMQghzcZw6CAwpXL+gSN/EBID0EAm5rNU36DeRKiB5mvkWUeNKZMheAjRkbjkUBvPfG6DbI4qw5e Mp+fmihC5ot2prpGlyQX3IR1mt54qN3hxi9wcTTR0bgH6TgXCtK9i2DB1cp+dRKds/2tBLBtpTEM IEzkZBxdHIauSnONVQU7esc1rTidZUT0o4xZ0tST5cKM/Cc+LOo5nf4AlwSsmpRl0/OcGIA2Fyw7 RoPIzpxrbFZsRWQVcso+/FkYGGvRipEB6LZPLaBXJEQhd7GWdY4CE6wEwcD4BMDFSDawiaivepzM sTuxCQqMDCwsOE2LU4UXKwgqx7is/h3TU0oZ1DNVPRmPdykcXg6T6iloHblJYx5rJq5TR9LYPIvO UmfoqT9g4wkp6LtkpocWhQfh2reTNFLxVuNrMY9n48Xcu8ZchGd1tydzt4rd2srILYyBzJKhe66h +ui/SQsYUJtjiVbg0klybP/X6MtybmzCMnV4TpkyRmw69v4EN4vWmHT0D4yz+09zA0pbQ9zXgX4z IT8066w5naMcccK8PCaNyAXXyq2Bx8jsgrds7LWHGMUPBgQJJFPCAFG0w/4lUCS4jKfOuaijeRHG dAyNjjJFxkhbWfZD7Am+nYVdRH0sSzbGRC5nQhXEm9M+5lXiyA0RcIVMPDwRXdGwMGjOAuEvQeuC 9/vLK9wyL5e3u9vHyygo6s41M3h5enp51khbR27ik/+Yi4sLqQNtFEtiwhHDGTEziEiviXkUZdXA vc6e0rinNDGJNCryNyEOtnHi+crfpbqKE6Lt6F2Bkl+YMhqJHautjomEEdRmUaVt42saKYfCmuP2 OmFN3MO/0/Pot5fb13tq/qL6ALyo9SClNgrWFvH1jM5HpDdpVyW2jaSBt3cauZJwoxvBfO0xjA3/ 0sEFbgz1FJOWLqeTMbWNDnF5OOV5OLCNZRt2VMN2ovQ48+Py2jlTFRqNi5IEn7Jr6oVGJxUj6K1H YodqAvaCplU5FAHCeoZJXthQd13biQ5TTVdGGiYD3gR8Pp3P1148xnBZkgslrZarK09CyI5kPVmR OcM0gvWMqhzhbYCwpuIzNp2uIuGcCfx5Rezb9ouQraaTq2HCQ7OpgiMPqU61xpaDveL5Ft2XErji kImYFVnV73s3P4eI1zDCNXyrMwR318vADpI1uk0RSFi2g+0QBeCSK80N+fdb5dYsZP+BWlU8I3cC unwfzJbEDGwSWqm5bYLizMkE3TYdTBOj7pFI1IZs8AgeLVYYbaEVRSpSyg/U2X7gOePO1bbYMbuy rwS71ZHW5OqoKvSokVoBBi8z8HfRrUMxCkSyGl3u84wUC1ndHaiEiMbqCW3Ga5KcCU4kMcsBjJXl VMOa7uMGZjIhuJrCwCV1AElXd5hPzFDbGma+GDpzgWBhX31a+HIy8xRp5Uh2CBYzPeSZBl/Yaj8B T4KF8VqtEJtwuqYRVcMDYocGfLZIZsSoSwTZHYnyqk46ioWv1CVd6nyaDI6SoFgQK6tFOEnEDbQn R7VBQ/lLGhQrz4DMp0syIbBGsBrTDV95OrTybBTEnc/EomgRA6Mwm5Dxd3WKOd2a2fyKLhMDpHjS qioazFJLRslVFOKYJ9asPP6pekEaHZKf2pflMCIHIuKryWw+2GYgsTJREyTr2YSO8KGTTNcea4Pu El6lS0qiQyeppjzMxjOCL3RhjRtOdlFITOP1EBfThSr6+8V4eJAE0ZLM1KpTXBnpt43aV5Sw2GLo xd9heUiwfIm9IjaabCuF4CAST5YYJb5VFg7TtPH5XCK4NU6Wa2IiEbFaX3kRvv0q0Fc+YxWdyoj7 ayEGSp+Nl+PPS4dFviYEb4Whpwmwi8n0Ty/C1ypY78P33TJZTmfEIJfVxDBt0OCz8ZpeLWW1WE6I zYVwuo7Fck2clBLuq2M1JladAHu/mJCVY9ZI+YU7bIBcIHLo4tBrCWwMKr9Dbr8Xahj0F05ZQVXd Osww+L8I3jnUgrjctuK3Ryz1iNqcp1MjKryOWFIiY4ugFycg54slwZTglj6bElsJ4e4rUHsrhMvc 0H2tYny6WBBNFIilB7GihAVA2KlpdNTKEwnWoPHEUdNoQFAdkuxEDLgJwc2qLbtaryhEHyNtEElP Vkcwm5yJqenRzoObg/6sAn/xYXCezKkZaVUZFEZKYx4MdX0Q8eJmBEIkMKGEabQRnZDrEjGegO0G ydBMI8Ga6DSGqqM4FMKnhFgqQtt56GfELkQ4JYUifOFpz4IUy0WovSGRHgkojg5wI2SZCafXEarW xsQKF3C6LI8qTmCGbytIshqWzgSJJ929RrKm4x92JJxh3K6BMfwqVCpXy2LqPDsqwWu1oPI7dBSo FiRVmqguJOFLeuAyVq8XnjCUOs3akxvMoCFzyJgUc6oRVcGWIHMwawJbLZ2pszGKlQcp6uDJp44e bdcqj9RdyYq9wHv7pnuxEZ3THgqlZUEcuorMve6CBT+ajVCj3cBRWEbZrtrrrQN8ySihpJbF6ITq NdJ9SvtxuXu4fRTNIbIb46dsjmETyH4LdFCSsXYFrjAMvgWoxkdiu3mbKDnElM8UIoM9Bkgwiwn2 MfyygXnJWVzawNrIUIOwlAUsSayvizIP40N0w+3Gybd6X+NurOdbBMLE7PKslKnhu7J6aLOlnozw ywijgm3tFmD09Dz1TkH0FZrtKXAXpZu4dNfDljSaFagkL+O8doYB6hARKrzNONxQT+eIObHESimF 0GMcnUS4DG+Ju5vSyWWvoWOMDm2OfGyG5EHQr2xDqt8RV53ibG86+smuZjyG/eatOQlUXj7jO8vM 08Bk+TF36HO47w5tLuG2k8Jk+EY2hZEtdRN/CbwR0dNNaBnJBWjRxkGZ83xbWWBkZGV0Y7c4rZMq dpaBRpBVsf1NXvrMicS2Yxn6P8Oio3mroIkqltxktAguCIAb+Dy4BD5hmQiMEVDXCbn7McaQOQjA TIx3QgkTr14WEIOQJ3F2sLvOq4j59hngogRN4SKLe0D5RVJbwFK3fhJ7A+PEMK4bEXUggoXwlJXV r/kNluzbDPExN+uATcut8OoCvIfN4etWtS9rXnWWk92HOtzP/2o805rCdJ4TLCSO07zybYNznKXO 7voalflAd7/ehHB25c7m57D50RWjpuKtiiMsKSRzVI+DxBkqDlE0NjLP+a4ikYk1HliwJs4obvMC 0OL15f3l7uWROrWx8MOGYkWIEexEb/8n5dpk/UPn/5JxEz1dxEc1p4taSEPjs85UTa9Aa3S+D2Kf 97SWOMEEuhH6EYopJaoypuwWEV0nRWxadMmisszOl8zRYTHYN3vGm30QGhiTrAhi67ssy+ssiJos OrWG451kaIZ/xVHX81RohbSWfuhAxWNOpygRdIaNtpcsr+i3/BYn5KM6qJKYjBWoqMKYsw1O0rk1 xoB9ZPYdDWTFBOwizJa5cedNZIypgalmaAqGwSenZnNS82Dud8fL2/so6JN3OF5gYiqXq/N47MxY c8YltjfjZXbwcLMLGGXW2VE4c6ygcPBmEWecwrbuSwQqrQ4U9BhtagJumRcjPEL4pgxSXlkTQAKj vvc2tMzzCqexqSp7bAS+qnAZi3CqngGKyAES0C1PCGh6DujmCTc1H6qM3d3eYa3ILjQRmowO9UGN s/u1G3yTKp+e8PxcTyfjfeGOf8yLyWR5dhFb2Gto9eUgcnIec20UPBjsugflzFxfnM3p8n4sfIWR Q1CTzRZQ5SyS5ZnYTvuAINJKNeamRoPsfeBbmDxZTyZuvR0YJsDi+OWaLZcYFM2dq/Q8JcrCUjZB ylyoM3gIFFlKUpnSqONr0ndyFDzevr25NimCZQbWgAq3F1MCQ/CJtINBTJUGqsoMBK3/jMRAVDnc GaLR/eUHhgQfoUVtwOPRbx/vo01ywKOr4eHo6fYvZXd7+/j2MvrtMnq+XO4v9/8HarkYJe0vjz+E VePTy+tl9PD8+4vZkZbObncL9rrr6DStA0M/Hi1AnCuFNU5dwaxiW7ahkVsQrEGY8DUq5uGUDDWg E8HfzOGfCsnDsBxTejybaLHwFfFrnRZ8n/vFAEXIElaH1IVYJ8qzSNzy6PE4oOk+jWr1IcBOWOAZ TTgOm3qznOr6ZrFXGdcXffx0++3h+Zsb2VpIAGFgpMYWMLzKGhMP0LiwvBwk7Ejxmx4uHI34lzWB zOBqEPDeuUai9kYgqpa8NmMkSOjQCsbAhDN7ggWw2bFwF/kEL0nitKGFA2OyBqqqnVoQJkrwrh9B MdgMQRFirvQyTyK3TjuCgoALxheW9ki1iNwrbAq8bA75adcOR1IsHm/fgQM9jXaPH5dRcvvX5dVa XIIfwv+WY/MFqEMKZ3n7bumSsXS2oJUWfTN54ZMaBF6zVpa3A3EepAz45/3FSCInuH6cw9ZNKGWg OKIydDXEmNCpI8VUql+I9HwfnoKZOX0IEVcmAtyuR/Muggh3Ebk0f3f6pIg/4rYqvSvIFRgFuJNR 3Kr3rPDPqyxzS4SNdsmG7mSngHoCEZt2jylBImeCFLypPdHPDaKBndPROHJdhzGCnhsYh5l0GMc5 TQmwq+WYAk4alz8qetF8Z/oJOrmUFL8hi/KvJNxKwrWEFKlqzldTZ/tL31WyKPPiTpYZpbFuldCC pksTxMK6qs9uzUce+a/oSbTLK1RKe0YscW+26qwOblbBkvI9kEQiPKU1g6HSIul3kgqdmRPm3MHE M1AbOJd6GkN0k27hMsh4hRlYdlbJPObwz3Hn7InEJ9gDk8uC6BhvSiZj9JpLIz+xEm6LvrFCIdy9 5XFYaEI838ZnT0pFue4w5MP2ZHbhBj6wdk70VYza2VoQeNOGf6eLydm+H/A4wD9mi7FzfivcfElG aReDFWeHBqYA49VEjqiwZzk/RDfWSqxcoRd13f6HIFHWGR8Fffq1iO2SiCj4LCRk19sPt1bx/a+3 h7vbR3la03ur2GuNz/JCFhpEsRYyAQ5kOJFVilykcHBQjAkXcgYerEdDK1ix/TFvKXsltwJKBra5 UUq6ATY2M+OKi0P/zLEd3tWJaR2M7oqBdU5hocrEVzY7rfDAkBq9JqWrluUOybE6CQbxjCxlgImn kTja+GR6+jIlsOougSG+NvV2i1EOejoVYQB+c3ky9Cvp8vrw4/vlFTreKwqtu7TUhJgsTLjD4gr1 dFk4UcKutVgi7lb7nqJ0N8Txtyvt011DKtWDddE/s+nKFvCPbeEWbGbrObLCCcKi4FCA0Kr4hFNs itXbTRi09ZqCGimcIbGrF0/DxWK2dBoPt9GpChjvggckVkGxtiZglx8sJWq0m44rchnaIff6DXh2 Wikia3QqZH2vkYvO5M0b4VjPjZS/YrW4uh2QPnmTWCxKLXobGuHxbQOtDLRtocT32ybf2OfWtsnc FkUuqNijFsEhjNze1BvuEqYYtatXBxk4m2dsm5oF9t5r6mPgtKlTixngym69/HPrXBAUnJADaToW 0HYbBhGOsU/8UjTOmHcYZ+h1TD+4dNVlFpJhQ81y7DnrMN0c06Xrc/hZJVtY0g33jzjO+udDKVYC 7VxC0LWRwD9vWru8fGVhfJy/U6f1Huqpy162Gs6j1tUoKiJgAvKg3e39t8v76MfrBdNkvrxd7jHN /e8P3z5eb8nnRXw+9/bJnyxAsNOKMg8RXLVdx4REQeY2lIdoFqAVkLsbe4xdpY9saLlrZORd1s+Q 2rOiwpuLfYz0bNUU8TDy06A2bUczqyCUQUOIowLF3kPMbCCwoCZ1xm4nbXm8g7bz2idIbLjZ0dFD JPoUbQLmZ31o5UGpgbRD8/MF24niN4Xu8CB+wj4ojIXWQQMq3pjESnFtahe1D2ectzmQzdIw4qBM 5djts+qvH5efg1H68fj+8OPx8ufl9Zfwov0a8f8+vN99pywmZKEpJu+KZ6Ipixlt6fr/U5HdQvb4 fnl9vn2/jNKXeyLMu2wN5kVNqvZBysC00cx7LNU6TyWGWAsSesNPcaW/NqSpNqHFqcTQZxEF7IIK 94rQNGg2SR4ciGnmaMxbMzNbJH5gJ3CVutY0+IWHv+BHA6YFRjm+WxHiWJnCP7HRSRVyIJR9M8ri 4Z5cq4gztZoK0uy5XQhLAlLNIXB4qZEtMr5Jz7SCUQxUvE3xyY8uMT1yQ7AUX6TCJ0l/g1Fgu2IV iMBbe7BZkXG6EHeExUiOI+m5Jb6ozcuZaALX35cRckormyTcx0tYttan6pmxsOdYIQy1gujO9d6m 3fNra5zaLEWFO09tDCbfXFSGOWIapbyKyV2BRkhm2DphoyPi5lKwxrIu1TDiTAnyxNS5CYJNiXqx DBWO+xPqm7Jd5Bq5oQmtw4rE9ypgrVUvY9VkqnulSmgGfHxxxWwwny3nCwd6mo51F2nZXIxhpbvc 9NDF2ulcVZdlDIJ8mpGW4oImSWeLmd1QAZy6wOV86lSC4CvS2btDjydn5zP09fD4Kwl8EbAr66DR 0a3Vm9WUYnY1p31kOvzCW2RSLBbnsxOevMNNJxRwRrRisVgO1LJejN2SzNjCCrg2vV76gfE84HUE y9kAgYzfLCK+e94KO7IFxdcE1o4+3QEX9ropTqkFKaMdpgSntmM4XY/9Y1fNFlfugDMeBwMrqQrY ckHGSZboJFhcGZ6Gcn2y82q1XNg7Q4Kv7H0p4mrrSrBuGy3+dJd+lG2nk01KqdQEwaEKp8srexxj Pptsk9nkym5qi5C+hxa/ElYtvz0+PP/xj8k/hQxU7jaj1iXg4xkjpBOWwqN/9BbV/7Q43gY19vaM 8hsemGZucurT9ZgMrCLHITnDSrBKqnnkLosqhrGs263pnUiQeyfjhctq+C6dTUwnsW6UqteHb99c tt5agtoHjTIQVTGHrVa22ByOE5/Ni0EItz7q5DNo0ir0NGIfgci4iVjlwesZYOj6AzLFuUHC4PJ5 jPW8NQbaND42O9caAotlIcb74cf77W+Pl7fRuxz0fglml/ffH1Aoby9To3/g3LzfvsJd65+6NGvO QskyjjnJPusE3Pki00LSQBfMcvehiLKoMuJcWyWgR5x9aHRjaOo1MU0L5/EG8yffqLGBTXj7x8cP 7P/by+Nl9Pbjcrn7LlC9QT9F0fcphv9nIJSRnn5RyFC0ztHkmgelbv4sUI6pOkItmja9Pex1XdMp UMqGpmuMrA8EzJJOQifxImN7c6ZMmGWrbrK84DdabWUVNEaSMQRYMiGC9gGIqPaHLVAFRf/p9f1u /JNOAMgq10VtDej/yjIgQlB2TIV2UkwgAEYPKsWjcTlD0jirtnJMyYHqSDCyODFOHV6uTvc7tIas 46jBiOye78PyqB5fO/8JbLQj8ipiTeo1KuxwngwOioZtNouvEade93uSKP96ZY6qhJ/Xurit4L39 uFsbn62mtHe1Igk5ZvwZaA4SrOZutQBfmk9ACrO/SdcL0oBBUdhSn4KDMLG8MoN7aijM3zFQqCOJ KER5WI+Jykq+CGarqYuIeTKZUl9IxNT7iW44ojBngC9ccBFs1ws9SISBGC9n1BgI3GxJS3wG0d+h WQ/NUDqfVPo7nQlvTmFFNXATrkAKpsSejuJ6Nj1Qn1anZD72RNfqms2SlAxA0hVS8PV4PJtQFZTB olpOKKNeRcHh6nelp01RiG2KwcTIQmFLkhoQjWCxptsDn07pgASKJErh1kzHKe1KOQLJ0ICXx/V6 TKwzvkgJYAi8YN2dzEXsZ4ZEjEakxwRELhMluA5cgYcZE6zR6WQ6xJlE368CkgdJXLM/Ub5J3Uv4 J60M0tx/NLU8cLqm46JpJIsJ5cSiEyyICUL+ul40W5bGyQ3VRUnwWeXL9dCSB4LVdL3wFL+af14+ 8PEhpixKIRhmyKfzMXWqWPdoHb6klnF1mKwqRp0l83W1JhgywmdkjxFjRu9wSXi6nJJxG3sGN1+P iQ6UxSIYk4wAV+ow3/OmndIJFgS3VtmiXMzXm+w6LdTOfXn+GW9En23aeCd1iYONjdMzmYZO4U1V +R5zJPAZhvUKiNmdBeQ5mIzJ2I46fuKWhoZEZXplZMDWcZylhNglE1cS68gROkU5QrCfrYdmC8Mk ZGbus+6kqeCvsSdkS9e9dG1lyHVPU0+M467xZ2K0AdgciaXLsyOnGivirfskc7k5QdKjKqqmRk7J Hr6cCQHO3XfVakkGqem212o2JqZcPOeQ50MVTiZXZ+doQFUQv8A989W3G0KYYOkhTL1b4rhPxw0r Nq1Rv/gU/tzUW81xuCWHW14gDPL6lvOTgOptrtvP3eokoklz2ERdVnG9pYjlUbLFOw7V3pZkHzE9 z6oOFZfAKCXKleggta657aXd6nKnAqjPreWxxgPC+XylC5sYR57xII5tK+l9NVkeZrRsCzsPXzHK hPQuLFgpvBYLTKjY1yR+KmSf8rIFl7mYm4UJlk8lTRpxblgeSOwGvXMV7qef+va1bWs2CSYaI7ug k1DKPg2vnny6b0Xt/m/6ZtaGpRm+BcZGdAoEFbhFdlEWl9eUNQRQhHDLbynM0pj+9I8AHpVBzmcm UKSs7Yw6jLqzqCKNr/Crsta1HQhKt8upJkYct5h4IE/TWryKT0yMRZflgtKCpoayqwM5+eQwr6+b 0Quh5vuMhKDqm1I5HsPCUM/F2+BIL46jMGG2i2lDFNy9vry9/P4+2v/14/L683H07ePy9m7YNLTb 8jNSQXu+PCsluhMTC+NqbTCtkP5ShEChW4NluIt4l/TIIMBBjI5VsLc+RG2tkQQZgLqaDWnQwoZV FAa1WnuY6vIY87w0cfAfWi27aZYRucsqS3HUQxsvxxU0JctE7r9GpFeyipXIlNlIforzKtkgkV1p ccT4V5yMV0YStkPmaR+6BJOjihZMxyC1gOiG25wTI59lFz2tKXZhXDZ8D8PxRbMpIZaI+nZXRjeG aX4LaCJuRs2r2C72JKzY5Um4jTltQ5ZuwwajJDURbRcR7Ms8jTofdOrcS6MkYVl+Jtzf5dtMs88r TLzowHUuIoTXINE8XOEHrgvYHYfalnIBhym54LDRBlo+7FiFdLBW8ldiRPD4cveH/rwFZ96ovPx+ eb08311G95e3h2+6eBEHulsJlseL9WRsgo7RuU1/yY3sXX+zMm3YobA9D6l3Ha1HGCNxvl6QvVWK ur7IHscDMhWzQaE7XOiIeGGEerdQCy9qMvc1Jl54XttNohUtyGtEQRhEqzEVt9MikrmLCRyH+8y4 CQq6E9O04BO6g5iYDP7dRZm5IK7zUk8IpX3RRWL3DItXP6fTnFLP18eAUiTonUFhPi0mixXZuk24 mqzPZ0/p2/jc5tCjKsHPg3SKYafDY2GOR2vW4wCbQ54xsiUxvlgY7Wi/2JfUHUZhM+7WDMApVRKn L+FiFzFebDBEI5nJFS95NsvCm9w6TQlYZtctoLShaYe+dgQUh5ekl/uH2+ryB6bW6vmVziacrFA6 0koM5aBgnrkZONIlgUsG0Hy2P1viYxgFFrWXdh9vjfc3lyKq9p9QbMLiEwpWh59Q7GYDFHidHkD1 TaQHRdDIjn4+goJYtvezAQTSK3+zroZHTlAMjv56MqO5qEz35e0uIuWa+ry364WdKcN3oBqboNuf GFJKcnbLHEvHlLA9dD9K+Zw8Wy3Mva3g6zMNv7LgOrO1AytKD30xj7xtRUZ+WcWY6T5JbNZBWZMq +ejEizhDI2FNZupgtsqwRyj1jsZk+MvH6x1lPo2GK3Dz7suREGDVG00eayMu2Lm1of28DKwUrCrn pkWrjgYb3qlPHcRJ6IsGoEa7u8keN+fC/qoMnXqle5wFlFpNp5tSM9lUVeAZAZhc+YBngtVEENAm KYy2yyB9VukmHK+JGGKZpSbFLsnh6kl9Kz8D6VZ/U2hbYX/ZiNBogDWWm/QorYJN+5lTTLv+06By +yn3imnvh9n66DFEjQGrDK1fi0GN6q5wK0B4VaTEAJsK1jRONhHc5+yKRSgejAzRFHG1nG9cOd/a Nt2HDErMz+Zgp3tNZ4JNSw0SdaUy6YpkNh1blN1KPp+b8lSlFrqL6kLABag5bONtLtMbTxfLrlhh fGN9pDZrC9VuobGA0TdN2X3HHaEjkHtrzwunDI0ZFGFgNaZNflgEgble4G5+bZFKZVacH5kNY/p1 R4J6WybBEXeX58vrw91IIEfF7beLMENzHYBVJXDbrzBcpFu9wsB6Y8bLBUnQ6ZyJEXE+gFVwXPHB MiUJWWq3jj/rrFm/sFzSdUkK3MbwZJxX+zKvd5pdfb5tLIWhWIkK1jW/h3r9T3AbcaMoBVG2ZmHV bOIsjLOdMTQdmQrsubnBtnpCG/QLGRaXHJhBbHOcOLJ7eXl6eb/8eH25IwwBIgwCbN92eijcXKMj WSWyjZ7O2yruSYl9OtSw5WZN6f0a49WQ5RtbsOza3q4iordyFH48vX0jBqBIuW4Ahz+Fyt2GXYOA BKeQjEntwSDAGEeBl/pjcsmbjep6ltdZiInTv3S5mz+e708Pr5c2cKH+AKVoRTO6D2DE/sH/enu/ PI3y51Hw/eHHP9Hq8u7hd9hgvauVTA//9PjyDcCYJFl/LlNJ4Am0/A7NOO+9n7lYbRNUVxOZN45W lXZ4vi2d9bx5fbm9v3t5smq2jgknnrx2q5ZIak1BlU401xbQtHPb9o9shYz2eC5+6VNMX7+8xtfO ILVFX9dxAIKJSGdPDgRGwSiDIiVXz2cVSctlzOvtqV5KK8FxCn1rQuB6cUZmh8oDqRfQ+++UKx8y tBuROzfqhDTPzDjblizY7kxogea+p9LM49VyFPoeishebaCeS6gGiaZef9w+wvzZy6j7ksTrQ+K9 YPEjBUPO78BlsC8HXOgHSw8Th4fzYtXh1RQ6qM5pBZN3FIkpe6PMLoSg6Z/YLRI1UyjtGOuQk8kc sZ433Z5s6pBpgylptkYMLA2e5KegKhMKV+hOrB0YRNVjnlQigqbd545o9hlRZxl3fnh8eP6TXtVt 5uVjUOsLj/hCO9swFVEVkbv67/HuTipP8R1rW0bXqqntz9HuBQifX/SWtqhmlx9Vip48C6OU6c9M OlERlSL3dKa/mxoEyEg5O3rQ6BHDC+b9GgSf+BjZLXeijOOyb5eyCGLUdVjDIy8zkYbIJfhXE4Zl oCg8Qp1cVE4V/ThjUu/MMJ41EKqhWR5QvgEkbWHt9yroPU+iP9/vXp5VxGJnaCQxnBPsar42LFxb DLq5UD4KEpuy82S+WK3s2hExmy0WFNxyIusRpvF2C5dPCkTDiipbTEgnvZagrNZXqxkjPuXpYjGm jU9bChVjjHw5THM9+xGsCXMlFclkNW1Sg69I5QIPS2a6Q0t4tCFDIMQYi1DT+4hrxa4wS+iA7lWj v6TKkhpekslPpF4RVpbxaCvOSj3JCVzgFzMA6exSyNDbNJhiHzR4qw8xmypX62I+xQBRFCNvlzMv zdDOckul9AmhuHXkwcfkJGamuwT8bFJOTQJi4lBTyCBABkeodEMXBBdwVyty/URHaJXniV0X8kVP ZcKzy/RHOqaRnqkMfoL0+HD/jdjOSFrxeDJfm59v2SEyvn+5fb2nPo+RerUWHgsdtY95GOou+GH7 RyHI8hBCkFj0BKjZJxhMxXog7NFVQGWAQTwqWZw3N4VAVaz/u/Zlz/wqKhMz+5mJlgK9p0wUubeV NTBwfEzsWjA+PWXd3uJMfZ8AXvPlVHdPQKBw/J7ZZePmRTM7T/Ha45rxWav8FspDz6fCxXrtDFm7 4z0fcTMJlQSlpIt7h5NqY+Mbn1GrwMVRoD8StLB96SzS6pQ4BZ8ST64wxNoGwAj72tlkoIncHQhZ rqUUYFA+N0+HXRw4ADz8mqzsY5gr+HGqtR0BmHNhw7JDFLqFHGcUrIkr7oObkTEQd7Rbd8RKyy9z R2Mr3h6k8V9/msHKjynGLvcvi4NFY9gLwv5bTYB5J1ML3l6ZbXj7JBIHlcY/pLbNHmt8B4mzyjis XKruBqvNLiurGMNOIZcOilovAJclSAi62rW87t61oIOhGXsNiwcKzCxG7SeBzqq01tS97RmI5QZ5 uoGLfalfC5zV1pUFYvLBzJO0yTG9ZgWTbFi8t7E44yIPjNzuXe6kMsLIugDFmKzGpeYzjGScpipQ wF2OSVPgr4CRzpqCDONvJc3uZFeMxkEOTEUiMqGEDUmLyYNtYYY0lghMey2c/AfaP/C2aRI0u6R2 GoXOGPo6i1WToFpdsQGY/Xy8kljFgDAwLf/47U1c+Xru01rXmnFpNWCTxkXchAYawdK4xIyN071o YkTVhvwk4yrcas9ZDRTlbIgUGZ8iH4rsLxEugniWJF/GsktsKquY1RoEW3GAtY5hXfTRDjTd+2de lrR3vU7lDp7CcJhp0+3ewLLkSEmlSIPigzSiMadAztgZVj8xb63TyWqB3wRJLXL6SQpzCMT+FGPm G1NJ4VYt7ghQBZqa5anTcR1fV8a1QcOuz/3HRsNa04ZiMlHFe6eoOLNmus5SEWHb04uOxowALGrC V1mqBQCvyZCHCnvmbq9ZIQJuNmmYLpem3zLi8yBK8go5bkh6iyCNUP+LCNXc/lxDebvanhdhAUd1 GOV2EerROhaRp4HAO65Kl2BtD41C3erqrdPSDgXjPdhQsULDMjTHsWOO7nzpqJkH1bIPY6fA/6dr S4TEhrYcFMPBeHopTnnAw4/ALFXFGbY3R5iuMSmYARdSSXtSmhxTYMyOAsMv4iKy+ocZQCbTNuNJ e/6bzF7rGyrSrIx4vdqbvDiVVgo8w9YVfzcHGOGKDsXHnu9fXx7u9dcAloVl7skvqcg7QU5P7aoi Rug/7aukBAqBKTauhz0iD/KK7r9FA9IC5YmBezwyNchtU4oUJICQOW3EE0WU6DaofV3M4W/Kl0Wt XLq+7IghsHZFqY74/Wn0/np7h9mXiDCVvKLjekphyY7DqhJ7ukVqz0YgBxHN3nKNr8MPlS0TriV6 OErEtHllzSA5GkJmodTeqToMEwkN6Nph5vLULI9vIrQBsQvLA5+6iOJuIkoeCIvnqBtyPXCn+xBV nxsW7lZXU032QKDZX4SkKqyielAiyu02PSynwlhMPCaNSngSp4aojwB5XLTPHMYiKOHvLAoocSbI azt+sVy60lIqIGUg1CdeR0ZDtxXUX7MwjKiDqjc/EvZVrMB0Hdo4WYmJ8Lc890L65dJSSIkJ2z5g ZCDBF/Uni4AF+6g55XATktGHNMUYS+KQVVGDcbNZyfX7DIBi0+oQ7n3TZmtrohHUnFlVUZI/4Gfu JzNRX85jWEMBddVRNDwK6tIIQAWYuRFrvQX0xbkorRS9FXOvaYpA9qxfq+3XTTg1f9nqPQwxvhFD rl9xYhhajIVtOhErMBCTUTA7AmFIEmfmJtdK9Y7/r6pS7bc+Ul1hv2rjRLINJPCNl/i4YlWM4TyN Lp5F/cQnuy231xJcPgWMMiGrSqsjCkLNe4cT4yr2/86e/46mrPE2AFN90/g8hCWtE+VKghmHSaAt jvo6oi1aPMZbKqx7FifuWGynvoHzLXVUmJv7QkJk4GHgqhoOXXrRk+UQ66p6fMTEJ+4bG68dKw3c 3sqbApVDHmsL0dGK6uiWE/7ZEkRphiTGCQm4Zd5Pruu8Mm6cAoDetMK0SJwDWxaQwj3GNW/pT6zM jIGRYGufS2BVRto+v96mVXOc2ICp9ZWhu0PXwy03eZqEGSCUkgxAYIhNrYetTpDDRCTsxt5kHbRB A/oSzsQG/iGGhKJkyYndQMPyJMlPnmLjLIxoU1KNKI1gGPLCmEUp0N3efTfDpG254Ka0P4GkluTh zyBs/hIeQ3EQOudgzPMruKGa7DBPYj08/lcgMhJ5hFs1fqpGuhb5+p7zX7as+iU64/9BbiDbAThr TlIOX9K7/dhRa18rC80AZE50Nv4yn60ofJyjGR7qyX56eHtZrxdXP09+0ndST1pXWyqCkuiJddx6 avh4/33dBcbLKmv5CoDDQQW0PNECztBgSq3f2+Xj/mX0OzXI4sC0LukIOqboOEIygFwE+5N70/wI xxgTvMcVGbdcWnnu4yQsdT/CQ1QantrWda5KC7N9AjAoFUkKcdRrXDuSvsCR4bws/+klDnV3dodM W4Yxl5E4ZLgLajkCKwU58qBTaXNszzkeBlPrt/FOJyGe3grk/MuTRT5v6FQqIiV85omjiF8iA1WG xaSRniLCiYNbY5hZfVHmxnVYaFbmeh3UnW1XwomDDylxrsdyhcPV/om9NSq0vZ94nZW6q4P83eyM 8JdFAGIcwppDuTEeKVty1Y04E/IeJj8OMFAEPXLqI69lRRAVe5p3BTGsBm368LcQEznpAYpYjBdw 6lsmp0vvg6A6RQydaPGlhvaOF1R1gYEC/HifyCyQDqvqobTVTI/HnFsFLCKfo5wg/KR9ech8qYWY Ixh2qKuCnogs0Vdy0sem0I8FDa3OlQbOFfPDDrPyY1YLD2ath+eyMFMvxl+aESXJxC1pp3OLiApJ Z5F426UHYrMw84F20bHkLCLKFd4iufLUfjVb+jCLsbddV6Qdgkkyv/J3a0UHAkAiEKhwhTXrzzs+ mS7+xrQBlW/eRLwks/uq+ondeIXwdVzhZ3R5zhwrhH+CFYVvdhV+Rdd45enYzNeSCZV01SCwttYh j9dNScBqu4qUBajYZfQdUFEEESbe8DRCEsCNrC5zs0qBKXNWxSwjMDdlnCRmyCSF27EoiWmlZ0cC 9zUy30iLjwPMFhxSpcdZHdP3fGNI4k9GparLgy+qC9LYknh/VU48uauyGDcHKUQbGkHp13K5+3h9 eP/LDcSGJ5Yuvd7gve+6xuzCSp3Vi8VRyWMQ/+DODIQlemhR8mqJz7ChKrnXvUkdQoshPgRwE+6b HKphqGow2yXDvMWBjVLqKwzMxYVdQVXGgSGjDWq4FJI8Q0X4GrjrhFEG7a5FRK/iRgY4apNZdJQW kd4At4QtFIGBisg6bWIRWqow01lvQQ5FRQnP6zKg3/WFbi4QxWBirH2UFKSdhrrW9SOph4FPePrl J/SUvX/57/O//rp9uv3X48vt/Y+H53+93f5+gXIe7v+Foc6/4QL7128/fv9JrrnD5fX58jj6fvt6 f3nG55Z+7bUuL08vr3+NHp4f3h9uHx/+R+RS00JiBMImR8RoOrISNmJcuUH3SSpMGGg+BcRo/4J2 QlmeUfdAjQImRquGKgMpvDkJBV2eySWiJUQYJN4Cf/LSdg455HAptH+0O/8Imweozp/zUqoLdV2U CNBoJsuSMLh5BsWNDT3re0GCimsbUrI4XMIODXLN0UcwBZwuqc55/evH+8vo7uX1Mnp5HX2/PP7Q syJLYhjcneEDbICnLjxiIQl0SfkhiAsjT62FcD/ZGymoNKBLWur6xR5GErqh5FTDvS1hvsYfisKl PhSFWwLaoLikcMABC3LLbeFmnB6JQq5DXbOMD7tbqfXe0lLttpPpOq0TB5HVCQ10my7+IWa/rvaR GWy0xXict9UyiEUQOamJ+vjt8eHu5z8uf43uxLL99nr74/tfzmotOXPqD90lE+k+8R2MJCxDokhg 3sdoulhMrlQD2cf798vz+8Pd7fvlfhQ9i1bC1h/99+H9+4i9vb3cPQhUePt+6zQ70LP5qhkxc6Yq yj1ICmw6LvLkZjIbk8Gs1KbbxRg5nChEocQQD0xAdB073AOGZM+AmR5VzzcitMPTy73u8qtau3HH OdhuXFjlLviAWKVR4H6blCcHlhN1FFRjzkQlIAC1Pp3Wot+rQXeXeAhCaVW7k4iZaLqR2t++ffcN VMrcxu0p4JnqxlFSSh35w7fL27tbQxnMptQmFAj/IjifSaa7SdghmrqjLOHuoEIt1WQc6q5Gap2T 5XuHOg3nBIygi2GdCktGd7jKNJzoWf40sJkRrkdMF2T4vA4/0xPFqv2zZxMKCGVR4MVk+uXJBc9c 2pSA4TvZJt8Rra925eRqYIZPxWLSxzcSOevdBcoid04B1lSEaJDVm5igLoM50TqQhk7eIJxq8TAM pUkmWewo8BJlaXM1nLs+EOpOQ0h0cyv+JZp+2LOvbIh/soQzYl0oHu5OYhS5xycc7oV05rRXATWc VTQwStUpx6F2imrh/QDKpfDy9OP18vYmrwp2RSAyYTTXoWlLvpJhECVyPadEmeQrpVPpkXt3M3/l VScmlLfP9y9Po+zj6bfLqwzWYl911BrlcRMUlJAYlpudiIBMY0imLDFWsGwdF9CK8J7CKfLXGO9F Edp26lcATeRrY/NQ0iCiHOW9h8wrhncUZUaxlQ6N0r2/HmyFMqzRrx2PD7+93sIl6/Xl4/3hmTgS k3hDch0Bl7zERbTHj5vL3aWhGNReaiGQSm5SsgCJokKLO0QDixlpOjFysMGGtOmiKZ6FcHWEglCM sauuhkiGqteOYn9H/45EitTd8WcXtacSNsNdNk0jVDIJtRQ+ohkXXYUs6k3S0vB64yWripSmOS/G V00Qla3WK3JM9YpDwNcisjVisYyOon9ebkuXGOoZGwpZqbD9RAESj5ciLIcyyYx3qKwqImk/JAye Wi1dt7sur+8YhAHuGm8i/iMGUL59/4A7/t33y90fD8/f9MwQ+MCsaxFLwyzHxXMj20CLj85VyfTh 8yn/8ixk5Y1dH9VRWTDsVMyxyStv03oKwWfwL9lCZUzyN4ZDFbmJM2ydMFTaqvFMvGxKalgKwzlR wZoNXHjhpCjJ/KNxFrESaLNdZNpPMGEPRtnHxSDeYUQVbc0KTiV4FoVVTlggF2YBKkFL4eahr2md JIkyDzZDv7IqTqwwrWXoeQeA4UujJqvTDTSI9AjA5ar7BHb+YkFs28OK7qHFQJAW52Avn/HLyLhE BHB7hrPSAE2WJoV79QiauKob86uZJZEAYCjGXEsAjCfa3KyJTyXGE8JbkrDy5BeikGITe6peGgeg LVoHZD7meNPdAntK7R5k3/Uws2rlng2wcsM81QanR4FUJ3yrSsMIGqFh5MK/4okAsoGZFuCrPNQs KAiTRMkIpUoWoiJJP6dbAkIkQS7AFP35K4Lt381ZzwXWwoTXTGGICS0mZkt6cbR4jIU/jK72sM+I mW4pOJwxbiM3wa8OzJzFvsfN7qvuyqwhWrHb2sPEa80m2Bs/0HKK4/NCyXTbJmE7esTwqYbBJ+M8 D2LgGYLZlUZGHybs53W3HgTJjEiqwSkzDXMzuGI1XCKA6e2qvYVDBDpP4YuO3g7kRCLhRhiWTdUs 57AzzXpgcBJWYpimvRDcrY+xbTyq6sJtVIeH21sZ5qdsgERo9xG9zUsnXQxNZTqYywwhZtOzPFOt blKDAyO2jBxQoKWduvx++/H4jomT3x++fbx8vI2e5PvJ7evlFg7c/7n8RxPu4WMUR5t0cwOL7stk 6WDQJR4agmaXk7HG1BSeo1ZHfE3zTZ2uL4viokaJpk+5iWOUg0wg0q+ASJbiZK+1d2REoP+sx5if 7xI7b0t4rR+ISW44LuHvoYMoS0yDxSD52lRMm2J09AfxXKsiLWIjzTP82OoRaPI4xIhsIE6Vxo6D Xai2+jHkucsAdlGFXj35NmSESzh+0+gxnDl6FeZ6zDR89gujItcaw2GrGSsQn52znX78dAKfI6+Z 76NKABbQH68Pz+9/iGyi90+Xt2/ui72QBWWEZUNQk2C0LqNfXoDD5cLAf5eAYJZ070srL8V1jWbS XQgMdUlwSugoRAqwtiFhZKQ6C28yhpEJLXt6A6zeGzVZPt3keImKyhLoqP0iP4T/QNbc5DzSx907 lp0q6eHx8vP7w1MreL8J0jsJf3VHXtbV6g0cGNrL10FkWJFoWF4kHkMSjSg8sXJLn7+7cIOZpuKi ollMlImXtLRGpaPHs2gLx1skPB2Ai03n+tIt4FRD59PU8lVioYxDzOljfw8EIFOj8WZl2TUavYOL lggtksY8ZZV++toY0bwmz5Ibe5Dh2Ajgllln8gPB5mDjahxDHDUnTEMle1rk4gTXDel1OF2BtDON 1BHVX9v+7noxIlC3uzy8/Pbx7Ru+y8fPb++vH0+X53fdr5JhcBq4P+pBXzRgZxwgZ/nL+M8JRSUj nNAltNFPOBr3YFjCn36yOs/dhdvZ5g5NbWsjLehS9KocKMdjftFfGw+wzPXv8Tdt/7ThtsmVFQ57 cOTNLkjbb3s5oGW8Eiha64uuMI0dI0uMzlWUcanysPqOeHGwUsoX/BZEK0vlIjQxeczzzJclrC8a vcwGSE60T45E5ptfYfORkWuTeiONtq2Dth0vEHAT2Cb2iH0GR+MRcbbKyPWT5Xg8thvV0XpDz1t0 nd3MlkwUahILQyEe6DaGLYMSpj11m9iyP4FExgSJjLLQ5axWq46U13snAbc0cVnVLHGXSovw9kJG YBRWQ5pgJS2gDgz2A6EylVh030DpJMuF0yPKkHhnkNdH28SoX+R2A/neyovZCttAP8pffrz9a5S8 3P3x8UMyxv3t8zddboGaA7R2yo1LhAFG1+Q66uOBSaQQ3motSylqXPDOElWwfvV7Hc+3lYvseoHy ibjj6YSiDkq/5SVuW2ksXays2WMokIpxeoWcruFsghMuzD3RKlHJKuuhfaMGx1naecK5dP+BhxHB qeRatgQwCTRlGgFTu7+3HyPKNtcnztMhigqpFJWqSrTD6FnwP95+PDyjbQZ04enj/fLnBf64vN/9 +9///mffUOG6KorcCZHa9bopSkz82/qqUlolmSOHVfY2L+EuWVfRWX+eaNe2k4en3XQduc1aTxIH zDI/Fayi3rXaSk/ccJmSUNFG68olPILMAAM9MSC8VbAqRzGaJ1FUUBXhOIqHNZUSWa9CtAS2CgYn 8Nk/9b2lLjj/D7NsXKqqkpnpwIXwhwaWdYYPz7A0pWJv6CCQx5iHLf0hpYD723e49sPxf4d6djOt tRykePC0KWy8uXZ27oxJc2VL39xzIjx+syZkFcNbT1kTztXGtvf0w641gEsI3PxB0uPOgJRBTbEF feI1fWpQi2itTTfXGsK3VgwidH/HmHbeJSVKshcAAqNrIuhAn/vB6IazK69bMb4UAvzAlEoPeZDc UGNFtQ91vVlwU+XajsryQrbZMP0+atcSEquuuVvVXz+yOcXVHvUctujVolMRuURY0erRpAQJerLi 5hGU4pJjFxK0H8pSeqQs28oMJRQam3q71fsjA3AjvfH2Bf9UOJYyRLAzCg690r54CDWmr25u1tDh 8YwHjlu0dyp8s/D5BHRFtpnRrbgxKB3Kymgz7/IaRIjtEIk8hl0CNXcnWIxOf9r2trNuuhUL0oZn rOD7nIxlI77dAHuF6ZLdsuI+GLjId3dTaJYBx2P4hCq/s54RFRWsToWnGaOsdGCoNslBxF6Kc0lF 6TnoraLplTKYYrGSaQ8W/Fou9DjDw8UZWrG5Bl9Utc3T0znlQC0sEbp9HB6yv2qWK1aiot7Pc7UK PyUuyihK4cwRqgWMzuCl5AyjiVLDpF1rZJyx9pZvqsCkO05L45xJt69PxpnUfSYCylfCqbbNWEW0 oM5OGHeidNQ6mptUS2G9WxkngR1spJUI/BcxWMRxFiR1GH356en27vsv99iFn+HP15d/85/65nUv Ux25oPzl4/muNWT793fNdqGIURRXvDQOPalucygy3u3pbGDmiOqa5ury9o7iGd4ZAkxycfvtojmC 1ca1UsZBcpKF9eGRbFh0FgvFkRckVpxKnkA7SlJCLW9etjsu1o0mi5Qm0t4GtmKb+8vTm5RFlQze RtBR3EQGvXCbtWVxwhP9UQMhUi1jCfYCkbJDpLzrLBQys/aWa0S9AdQWxe7Pm0Wq8WS1aaBq/RvF 9HI5sqTKyXkjlA2mB4/UMXBg3PmxZWvm2zLS0zwL+LM4w6FtyL7QxJFoI3AO+8oxuKYdpyj5xPJ/ AW8g0zOMigIA --===============3742846903586883894==--