From mboxrd@z Thu Jan 1 00:00:00 1970 From: kbuild test robot Date: Fri, 29 May 2020 11:10:37 +0800 Subject: [Intel-wired-lan] [jkirsher-next-queue:dev-queue 160/177] include/linux/avf/virtchnl.h:809:31: error: enumerator value for 'virtchnl_static_assert_virtchnl_get_capabilities' is not an integer constant Message-ID: <202005291133.G5VPl22D%lkp@intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit To: intel-wired-lan@osuosl.org List-ID: tree: https://git.kernel.org/pub/scm/linux/kernel/git/jkirsher/next-queue.git dev-queue head: ffc26e8fa1ec68b0f0e428fd3977ff87938c19de commit: 560358c5b47c0f997336911f532d1ab29448b41b [160/177] virtchnl: Extend AVF ops config: i386-randconfig-a013-20200528 (attached as .config) compiler: gcc-5 (Ubuntu 5.5.0-12ubuntu1) 5.5.0 20171010 reproduce (this is a W=1 build): git checkout 560358c5b47c0f997336911f532d1ab29448b41b # save the attached .config to linux build tree make W=1 ARCH=i386 If you fix the issue, kindly add following tag as appropriate Reported-by: kbuild test robot All errors (new ones prefixed by >>, old ones prefixed by <<): In file included from drivers/net/ethernet/intel/i40e/i40e_prototype.h:9:0, from drivers/net/ethernet/intel/i40e/i40e.h:40, from drivers/net/ethernet/intel/i40e/i40e_debugfs.c:9: include/linux/avf/virtchnl.h:175:36: warning: division by zero [-Wdiv-by-zero] { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) } ^ include/linux/avf/virtchnl.h:809:1: note: in expansion of macro 'VIRTCHNL_CHECK_STRUCT_LEN' VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_get_capabilities); ^ >> include/linux/avf/virtchnl.h:809:31: error: enumerator value for 'virtchnl_static_assert_virtchnl_get_capabilities' is not an integer constant VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_get_capabilities); ^ include/linux/avf/virtchnl.h:175:53: note: in definition of macro 'VIRTCHNL_CHECK_STRUCT_LEN' { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) } ^ include/linux/avf/virtchnl.h:175:36: warning: division by zero [-Wdiv-by-zero] { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) } ^ include/linux/avf/virtchnl.h:891:1: note: in expansion of macro 'VIRTCHNL_CHECK_STRUCT_LEN' VIRTCHNL_CHECK_STRUCT_LEN(40, virtchnl_txq_info_v2); ^ include/linux/avf/virtchnl.h:891:31: error: enumerator value for 'virtchnl_static_assert_virtchnl_txq_info_v2' is not an integer constant VIRTCHNL_CHECK_STRUCT_LEN(40, virtchnl_txq_info_v2); ^ include/linux/avf/virtchnl.h:175:53: note: in definition of macro 'VIRTCHNL_CHECK_STRUCT_LEN' { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) } ^ include/linux/avf/virtchnl.h:175:36: warning: division by zero [-Wdiv-by-zero] { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) } ^ include/linux/avf/virtchnl.h:907:1: note: in expansion of macro 'VIRTCHNL_CHECK_STRUCT_LEN' VIRTCHNL_CHECK_STRUCT_LEN(48, virtchnl_config_tx_queues); ^ include/linux/avf/virtchnl.h:907:31: error: enumerator value for 'virtchnl_static_assert_virtchnl_config_tx_queues' is not an integer constant VIRTCHNL_CHECK_STRUCT_LEN(48, virtchnl_config_tx_queues); ^ include/linux/avf/virtchnl.h:175:53: note: in definition of macro 'VIRTCHNL_CHECK_STRUCT_LEN' { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) } ^ include/linux/avf/virtchnl.h:175:36: warning: division by zero [-Wdiv-by-zero] { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) } ^ include/linux/avf/virtchnl.h:937:1: note: in expansion of macro 'VIRTCHNL_CHECK_STRUCT_LEN' VIRTCHNL_CHECK_STRUCT_LEN(72, virtchnl_rxq_info_v2); ^ include/linux/avf/virtchnl.h:937:31: error: enumerator value for 'virtchnl_static_assert_virtchnl_rxq_info_v2' is not an integer constant VIRTCHNL_CHECK_STRUCT_LEN(72, virtchnl_rxq_info_v2); ^ include/linux/avf/virtchnl.h:175:53: note: in definition of macro 'VIRTCHNL_CHECK_STRUCT_LEN' { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) } ^ include/linux/avf/virtchnl.h:175:36: warning: division by zero [-Wdiv-by-zero] { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) } ^ include/linux/avf/virtchnl.h:952:1: note: in expansion of macro 'VIRTCHNL_CHECK_STRUCT_LEN' VIRTCHNL_CHECK_STRUCT_LEN(80, virtchnl_config_rx_queues); ^ include/linux/avf/virtchnl.h:952:31: error: enumerator value for 'virtchnl_static_assert_virtchnl_config_rx_queues' is not an integer constant VIRTCHNL_CHECK_STRUCT_LEN(80, virtchnl_config_rx_queues); ^ include/linux/avf/virtchnl.h:175:53: note: in definition of macro 'VIRTCHNL_CHECK_STRUCT_LEN' { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) } ^ include/linux/avf/virtchnl.h:175:36: warning: division by zero [-Wdiv-by-zero] { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) } ^ include/linux/avf/virtchnl.h:1090:1: note: in expansion of macro 'VIRTCHNL_CHECK_STRUCT_LEN' VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_rss_hash); ^ include/linux/avf/virtchnl.h:1090:31: error: enumerator value for 'virtchnl_static_assert_virtchnl_rss_hash' is not an integer constant VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_rss_hash); ^ include/linux/avf/virtchnl.h:175:53: note: in definition of macro 'VIRTCHNL_CHECK_STRUCT_LEN' { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) } ^ -- In file included from drivers/net/ethernet/intel/i40e/i40e_prototype.h:9:0, from drivers/net/ethernet/intel/i40e/i40e.h:40, from drivers/net/ethernet/intel/i40e/i40e_main.c:10: include/linux/avf/virtchnl.h:175:36: warning: division by zero [-Wdiv-by-zero] { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) } ^ include/linux/avf/virtchnl.h:809:1: note: in expansion of macro 'VIRTCHNL_CHECK_STRUCT_LEN' VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_get_capabilities); ^ >> include/linux/avf/virtchnl.h:809:31: error: enumerator value for 'virtchnl_static_assert_virtchnl_get_capabilities' is not an integer constant VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_get_capabilities); ^ include/linux/avf/virtchnl.h:175:53: note: in definition of macro 'VIRTCHNL_CHECK_STRUCT_LEN' { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) } ^ include/linux/avf/virtchnl.h:175:36: warning: division by zero [-Wdiv-by-zero] { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) } ^ include/linux/avf/virtchnl.h:891:1: note: in expansion of macro 'VIRTCHNL_CHECK_STRUCT_LEN' VIRTCHNL_CHECK_STRUCT_LEN(40, virtchnl_txq_info_v2); ^ include/linux/avf/virtchnl.h:891:31: error: enumerator value for 'virtchnl_static_assert_virtchnl_txq_info_v2' is not an integer constant VIRTCHNL_CHECK_STRUCT_LEN(40, virtchnl_txq_info_v2); ^ include/linux/avf/virtchnl.h:175:53: note: in definition of macro 'VIRTCHNL_CHECK_STRUCT_LEN' { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) } ^ include/linux/avf/virtchnl.h:175:36: warning: division by zero [-Wdiv-by-zero] { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) } ^ include/linux/avf/virtchnl.h:907:1: note: in expansion of macro 'VIRTCHNL_CHECK_STRUCT_LEN' VIRTCHNL_CHECK_STRUCT_LEN(48, virtchnl_config_tx_queues); ^ include/linux/avf/virtchnl.h:907:31: error: enumerator value for 'virtchnl_static_assert_virtchnl_config_tx_queues' is not an integer constant VIRTCHNL_CHECK_STRUCT_LEN(48, virtchnl_config_tx_queues); ^ include/linux/avf/virtchnl.h:175:53: note: in definition of macro 'VIRTCHNL_CHECK_STRUCT_LEN' { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) } ^ include/linux/avf/virtchnl.h:175:36: warning: division by zero [-Wdiv-by-zero] { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) } ^ include/linux/avf/virtchnl.h:937:1: note: in expansion of macro 'VIRTCHNL_CHECK_STRUCT_LEN' VIRTCHNL_CHECK_STRUCT_LEN(72, virtchnl_rxq_info_v2); ^ include/linux/avf/virtchnl.h:937:31: error: enumerator value for 'virtchnl_static_assert_virtchnl_rxq_info_v2' is not an integer constant VIRTCHNL_CHECK_STRUCT_LEN(72, virtchnl_rxq_info_v2); ^ include/linux/avf/virtchnl.h:175:53: note: in definition of macro 'VIRTCHNL_CHECK_STRUCT_LEN' { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) } ^ include/linux/avf/virtchnl.h:175:36: warning: division by zero [-Wdiv-by-zero] { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) } ^ include/linux/avf/virtchnl.h:952:1: note: in expansion of macro 'VIRTCHNL_CHECK_STRUCT_LEN' VIRTCHNL_CHECK_STRUCT_LEN(80, virtchnl_config_rx_queues); ^ include/linux/avf/virtchnl.h:952:31: error: enumerator value for 'virtchnl_static_assert_virtchnl_config_rx_queues' is not an integer constant VIRTCHNL_CHECK_STRUCT_LEN(80, virtchnl_config_rx_queues); ^ include/linux/avf/virtchnl.h:175:53: note: in definition of macro 'VIRTCHNL_CHECK_STRUCT_LEN' { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) } ^ include/linux/avf/virtchnl.h:175:36: warning: division by zero [-Wdiv-by-zero] { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) } ^ include/linux/avf/virtchnl.h:1090:1: note: in expansion of macro 'VIRTCHNL_CHECK_STRUCT_LEN' VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_rss_hash); ^ include/linux/avf/virtchnl.h:1090:31: error: enumerator value for 'virtchnl_static_assert_virtchnl_rss_hash' is not an integer constant VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_rss_hash); ^ include/linux/avf/virtchnl.h:175:53: note: in definition of macro 'VIRTCHNL_CHECK_STRUCT_LEN' { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) } ^ In file included from drivers/net/ethernet/intel/i40e/i40e_trace.h:209:0, from drivers/net/ethernet/intel/i40e/i40e_main.c:20: include/trace/define_trace.h:95:43: fatal error: ./i40e_trace.h: No such file or directory compilation terminated. -- In file included from drivers/net/ethernet/intel/iavf/iavf.h:38:0, from drivers/net/ethernet/intel/iavf/iavf_main.c:4: include/linux/avf/virtchnl.h:175:36: warning: division by zero [-Wdiv-by-zero] { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) } ^ include/linux/avf/virtchnl.h:809:1: note: in expansion of macro 'VIRTCHNL_CHECK_STRUCT_LEN' VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_get_capabilities); ^ >> include/linux/avf/virtchnl.h:809:31: error: enumerator value for 'virtchnl_static_assert_virtchnl_get_capabilities' is not an integer constant VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_get_capabilities); ^ include/linux/avf/virtchnl.h:175:53: note: in definition of macro 'VIRTCHNL_CHECK_STRUCT_LEN' { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) } ^ include/linux/avf/virtchnl.h:175:36: warning: division by zero [-Wdiv-by-zero] { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) } ^ include/linux/avf/virtchnl.h:891:1: note: in expansion of macro 'VIRTCHNL_CHECK_STRUCT_LEN' VIRTCHNL_CHECK_STRUCT_LEN(40, virtchnl_txq_info_v2); ^ include/linux/avf/virtchnl.h:891:31: error: enumerator value for 'virtchnl_static_assert_virtchnl_txq_info_v2' is not an integer constant VIRTCHNL_CHECK_STRUCT_LEN(40, virtchnl_txq_info_v2); ^ include/linux/avf/virtchnl.h:175:53: note: in definition of macro 'VIRTCHNL_CHECK_STRUCT_LEN' { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) } ^ include/linux/avf/virtchnl.h:175:36: warning: division by zero [-Wdiv-by-zero] { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) } ^ include/linux/avf/virtchnl.h:907:1: note: in expansion of macro 'VIRTCHNL_CHECK_STRUCT_LEN' VIRTCHNL_CHECK_STRUCT_LEN(48, virtchnl_config_tx_queues); ^ include/linux/avf/virtchnl.h:907:31: error: enumerator value for 'virtchnl_static_assert_virtchnl_config_tx_queues' is not an integer constant VIRTCHNL_CHECK_STRUCT_LEN(48, virtchnl_config_tx_queues); ^ include/linux/avf/virtchnl.h:175:53: note: in definition of macro 'VIRTCHNL_CHECK_STRUCT_LEN' { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) } ^ include/linux/avf/virtchnl.h:175:36: warning: division by zero [-Wdiv-by-zero] { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) } ^ include/linux/avf/virtchnl.h:937:1: note: in expansion of macro 'VIRTCHNL_CHECK_STRUCT_LEN' VIRTCHNL_CHECK_STRUCT_LEN(72, virtchnl_rxq_info_v2); ^ include/linux/avf/virtchnl.h:937:31: error: enumerator value for 'virtchnl_static_assert_virtchnl_rxq_info_v2' is not an integer constant VIRTCHNL_CHECK_STRUCT_LEN(72, virtchnl_rxq_info_v2); ^ include/linux/avf/virtchnl.h:175:53: note: in definition of macro 'VIRTCHNL_CHECK_STRUCT_LEN' { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) } ^ include/linux/avf/virtchnl.h:175:36: warning: division by zero [-Wdiv-by-zero] { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) } ^ include/linux/avf/virtchnl.h:952:1: note: in expansion of macro 'VIRTCHNL_CHECK_STRUCT_LEN' VIRTCHNL_CHECK_STRUCT_LEN(80, virtchnl_config_rx_queues); ^ include/linux/avf/virtchnl.h:952:31: error: enumerator value for 'virtchnl_static_assert_virtchnl_config_rx_queues' is not an integer constant VIRTCHNL_CHECK_STRUCT_LEN(80, virtchnl_config_rx_queues); ^ include/linux/avf/virtchnl.h:175:53: note: in definition of macro 'VIRTCHNL_CHECK_STRUCT_LEN' { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) } ^ include/linux/avf/virtchnl.h:175:36: warning: division by zero [-Wdiv-by-zero] { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) } ^ include/linux/avf/virtchnl.h:1090:1: note: in expansion of macro 'VIRTCHNL_CHECK_STRUCT_LEN' VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_rss_hash); ^ include/linux/avf/virtchnl.h:1090:31: error: enumerator value for 'virtchnl_static_assert_virtchnl_rss_hash' is not an integer constant VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_rss_hash); ^ include/linux/avf/virtchnl.h:175:53: note: in definition of macro 'VIRTCHNL_CHECK_STRUCT_LEN' { virtchnl_static_assert_##X = (n)/((sizeof(struct X) == (n)) ? 1 : 0) } ^ In file included from drivers/net/ethernet/intel/iavf/iavf_trace.h:209:0, from drivers/net/ethernet/intel/iavf/iavf_main.c:12: include/trace/define_trace.h:95:43: fatal error: ./iavf_trace.h: No such file or directory compilation terminated. vim +/virtchnl_static_assert_virtchnl_get_capabilities +809 include/linux/avf/virtchnl.h 808 > 809 VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_get_capabilities); 810 --- 0-DAY CI Kernel Test Service, Intel Corporation https://lists.01.org/hyperkitty/list/kbuild-all at lists.01.org -------------- next part -------------- A non-text attachment was scrubbed... Name: .config.gz Type: application/gzip Size: 39835 bytes Desc: not available URL: From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: multipart/mixed; boundary="===============2946642378261956521==" MIME-Version: 1.0 From: kbuild test robot To: kbuild-all@lists.01.org Subject: [jkirsher-next-queue:dev-queue 160/177] include/linux/avf/virtchnl.h:809:31: error: enumerator value for 'virtchnl_static_assert_virtchnl_get_capabilities' is not an integer constant Date: Fri, 29 May 2020 11:10:37 +0800 Message-ID: <202005291133.G5VPl22D%lkp@intel.com> List-Id: --===============2946642378261956521== Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable tree: https://git.kernel.org/pub/scm/linux/kernel/git/jkirsher/next-queue= .git dev-queue head: ffc26e8fa1ec68b0f0e428fd3977ff87938c19de commit: 560358c5b47c0f997336911f532d1ab29448b41b [160/177] virtchnl: Extend= AVF ops config: i386-randconfig-a013-20200528 (attached as .config) compiler: gcc-5 (Ubuntu 5.5.0-12ubuntu1) 5.5.0 20171010 reproduce (this is a W=3D1 build): git checkout 560358c5b47c0f997336911f532d1ab29448b41b # save the attached .config to linux build tree make W=3D1 ARCH=3Di386 = If you fix the issue, kindly add following tag as appropriate Reported-by: kbuild test robot All errors (new ones prefixed by >>, old ones prefixed by <<): In file included from drivers/net/ethernet/intel/i40e/i40e_prototype.h:9:0, from drivers/net/ethernet/intel/i40e/i40e.h:40, from drivers/net/ethernet/intel/i40e/i40e_debugfs.c:9: include/linux/avf/virtchnl.h:175:36: warning: division by zero [-Wdiv-by-ze= ro] { virtchnl_static_assert_##X =3D (n)/((sizeof(struct X) =3D=3D (n)) ? 1 : 0= ) } ^ include/linux/avf/virtchnl.h:809:1: note: in expansion of macro 'VIRTCHNL_C= HECK_STRUCT_LEN' VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_get_capabilities); ^ >> include/linux/avf/virtchnl.h:809:31: error: enumerator value for 'virtch= nl_static_assert_virtchnl_get_capabilities' is not an integer constant VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_get_capabilities); ^ include/linux/avf/virtchnl.h:175:53: note: in definition of macro 'VIRTCHNL= _CHECK_STRUCT_LEN' { virtchnl_static_assert_##X =3D (n)/((sizeof(struct X) =3D=3D (n)) ? 1 : 0= ) } ^ include/linux/avf/virtchnl.h:175:36: warning: division by zero [-Wdiv-by-ze= ro] { virtchnl_static_assert_##X =3D (n)/((sizeof(struct X) =3D=3D (n)) ? 1 : 0= ) } ^ include/linux/avf/virtchnl.h:891:1: note: in expansion of macro 'VIRTCHNL_C= HECK_STRUCT_LEN' VIRTCHNL_CHECK_STRUCT_LEN(40, virtchnl_txq_info_v2); ^ include/linux/avf/virtchnl.h:891:31: error: enumerator value for 'virtchnl_= static_assert_virtchnl_txq_info_v2' is not an integer constant VIRTCHNL_CHECK_STRUCT_LEN(40, virtchnl_txq_info_v2); ^ include/linux/avf/virtchnl.h:175:53: note: in definition of macro 'VIRTCHNL= _CHECK_STRUCT_LEN' { virtchnl_static_assert_##X =3D (n)/((sizeof(struct X) =3D=3D (n)) ? 1 : 0= ) } ^ include/linux/avf/virtchnl.h:175:36: warning: division by zero [-Wdiv-by-ze= ro] { virtchnl_static_assert_##X =3D (n)/((sizeof(struct X) =3D=3D (n)) ? 1 : 0= ) } ^ include/linux/avf/virtchnl.h:907:1: note: in expansion of macro 'VIRTCHNL_C= HECK_STRUCT_LEN' VIRTCHNL_CHECK_STRUCT_LEN(48, virtchnl_config_tx_queues); ^ include/linux/avf/virtchnl.h:907:31: error: enumerator value for 'virtchnl_= static_assert_virtchnl_config_tx_queues' is not an integer constant VIRTCHNL_CHECK_STRUCT_LEN(48, virtchnl_config_tx_queues); ^ include/linux/avf/virtchnl.h:175:53: note: in definition of macro 'VIRTCHNL= _CHECK_STRUCT_LEN' { virtchnl_static_assert_##X =3D (n)/((sizeof(struct X) =3D=3D (n)) ? 1 : 0= ) } ^ include/linux/avf/virtchnl.h:175:36: warning: division by zero [-Wdiv-by-ze= ro] { virtchnl_static_assert_##X =3D (n)/((sizeof(struct X) =3D=3D (n)) ? 1 : 0= ) } ^ include/linux/avf/virtchnl.h:937:1: note: in expansion of macro 'VIRTCHNL_C= HECK_STRUCT_LEN' VIRTCHNL_CHECK_STRUCT_LEN(72, virtchnl_rxq_info_v2); ^ include/linux/avf/virtchnl.h:937:31: error: enumerator value for 'virtchnl_= static_assert_virtchnl_rxq_info_v2' is not an integer constant VIRTCHNL_CHECK_STRUCT_LEN(72, virtchnl_rxq_info_v2); ^ include/linux/avf/virtchnl.h:175:53: note: in definition of macro 'VIRTCHNL= _CHECK_STRUCT_LEN' { virtchnl_static_assert_##X =3D (n)/((sizeof(struct X) =3D=3D (n)) ? 1 : 0= ) } ^ include/linux/avf/virtchnl.h:175:36: warning: division by zero [-Wdiv-by-ze= ro] { virtchnl_static_assert_##X =3D (n)/((sizeof(struct X) =3D=3D (n)) ? 1 : 0= ) } ^ include/linux/avf/virtchnl.h:952:1: note: in expansion of macro 'VIRTCHNL_C= HECK_STRUCT_LEN' VIRTCHNL_CHECK_STRUCT_LEN(80, virtchnl_config_rx_queues); ^ include/linux/avf/virtchnl.h:952:31: error: enumerator value for 'virtchnl_= static_assert_virtchnl_config_rx_queues' is not an integer constant VIRTCHNL_CHECK_STRUCT_LEN(80, virtchnl_config_rx_queues); ^ include/linux/avf/virtchnl.h:175:53: note: in definition of macro 'VIRTCHNL= _CHECK_STRUCT_LEN' { virtchnl_static_assert_##X =3D (n)/((sizeof(struct X) =3D=3D (n)) ? 1 : 0= ) } ^ include/linux/avf/virtchnl.h:175:36: warning: division by zero [-Wdiv-by-ze= ro] { virtchnl_static_assert_##X =3D (n)/((sizeof(struct X) =3D=3D (n)) ? 1 : 0= ) } ^ include/linux/avf/virtchnl.h:1090:1: note: in expansion of macro 'VIRTCHNL_= CHECK_STRUCT_LEN' VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_rss_hash); ^ include/linux/avf/virtchnl.h:1090:31: error: enumerator value for 'virtchnl= _static_assert_virtchnl_rss_hash' is not an integer constant VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_rss_hash); ^ include/linux/avf/virtchnl.h:175:53: note: in definition of macro 'VIRTCHNL= _CHECK_STRUCT_LEN' { virtchnl_static_assert_##X =3D (n)/((sizeof(struct X) =3D=3D (n)) ? 1 : 0= ) } ^ -- In file included from drivers/net/ethernet/intel/i40e/i40e_prototype.h:9:0, from drivers/net/ethernet/intel/i40e/i40e.h:40, from drivers/net/ethernet/intel/i40e/i40e_main.c:10: include/linux/avf/virtchnl.h:175:36: warning: division by zero [-Wdiv-by-ze= ro] { virtchnl_static_assert_##X =3D (n)/((sizeof(struct X) =3D=3D (n)) ? 1 : 0= ) } ^ include/linux/avf/virtchnl.h:809:1: note: in expansion of macro 'VIRTCHNL_C= HECK_STRUCT_LEN' VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_get_capabilities); ^ >> include/linux/avf/virtchnl.h:809:31: error: enumerator value for 'virtch= nl_static_assert_virtchnl_get_capabilities' is not an integer constant VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_get_capabilities); ^ include/linux/avf/virtchnl.h:175:53: note: in definition of macro 'VIRTCHNL= _CHECK_STRUCT_LEN' { virtchnl_static_assert_##X =3D (n)/((sizeof(struct X) =3D=3D (n)) ? 1 : 0= ) } ^ include/linux/avf/virtchnl.h:175:36: warning: division by zero [-Wdiv-by-ze= ro] { virtchnl_static_assert_##X =3D (n)/((sizeof(struct X) =3D=3D (n)) ? 1 : 0= ) } ^ include/linux/avf/virtchnl.h:891:1: note: in expansion of macro 'VIRTCHNL_C= HECK_STRUCT_LEN' VIRTCHNL_CHECK_STRUCT_LEN(40, virtchnl_txq_info_v2); ^ include/linux/avf/virtchnl.h:891:31: error: enumerator value for 'virtchnl_= static_assert_virtchnl_txq_info_v2' is not an integer constant VIRTCHNL_CHECK_STRUCT_LEN(40, virtchnl_txq_info_v2); ^ include/linux/avf/virtchnl.h:175:53: note: in definition of macro 'VIRTCHNL= _CHECK_STRUCT_LEN' { virtchnl_static_assert_##X =3D (n)/((sizeof(struct X) =3D=3D (n)) ? 1 : 0= ) } ^ include/linux/avf/virtchnl.h:175:36: warning: division by zero [-Wdiv-by-ze= ro] { virtchnl_static_assert_##X =3D (n)/((sizeof(struct X) =3D=3D (n)) ? 1 : 0= ) } ^ include/linux/avf/virtchnl.h:907:1: note: in expansion of macro 'VIRTCHNL_C= HECK_STRUCT_LEN' VIRTCHNL_CHECK_STRUCT_LEN(48, virtchnl_config_tx_queues); ^ include/linux/avf/virtchnl.h:907:31: error: enumerator value for 'virtchnl_= static_assert_virtchnl_config_tx_queues' is not an integer constant VIRTCHNL_CHECK_STRUCT_LEN(48, virtchnl_config_tx_queues); ^ include/linux/avf/virtchnl.h:175:53: note: in definition of macro 'VIRTCHNL= _CHECK_STRUCT_LEN' { virtchnl_static_assert_##X =3D (n)/((sizeof(struct X) =3D=3D (n)) ? 1 : 0= ) } ^ include/linux/avf/virtchnl.h:175:36: warning: division by zero [-Wdiv-by-ze= ro] { virtchnl_static_assert_##X =3D (n)/((sizeof(struct X) =3D=3D (n)) ? 1 : 0= ) } ^ include/linux/avf/virtchnl.h:937:1: note: in expansion of macro 'VIRTCHNL_C= HECK_STRUCT_LEN' VIRTCHNL_CHECK_STRUCT_LEN(72, virtchnl_rxq_info_v2); ^ include/linux/avf/virtchnl.h:937:31: error: enumerator value for 'virtchnl_= static_assert_virtchnl_rxq_info_v2' is not an integer constant VIRTCHNL_CHECK_STRUCT_LEN(72, virtchnl_rxq_info_v2); ^ include/linux/avf/virtchnl.h:175:53: note: in definition of macro 'VIRTCHNL= _CHECK_STRUCT_LEN' { virtchnl_static_assert_##X =3D (n)/((sizeof(struct X) =3D=3D (n)) ? 1 : 0= ) } ^ include/linux/avf/virtchnl.h:175:36: warning: division by zero [-Wdiv-by-ze= ro] { virtchnl_static_assert_##X =3D (n)/((sizeof(struct X) =3D=3D (n)) ? 1 : 0= ) } ^ include/linux/avf/virtchnl.h:952:1: note: in expansion of macro 'VIRTCHNL_C= HECK_STRUCT_LEN' VIRTCHNL_CHECK_STRUCT_LEN(80, virtchnl_config_rx_queues); ^ include/linux/avf/virtchnl.h:952:31: error: enumerator value for 'virtchnl_= static_assert_virtchnl_config_rx_queues' is not an integer constant VIRTCHNL_CHECK_STRUCT_LEN(80, virtchnl_config_rx_queues); ^ include/linux/avf/virtchnl.h:175:53: note: in definition of macro 'VIRTCHNL= _CHECK_STRUCT_LEN' { virtchnl_static_assert_##X =3D (n)/((sizeof(struct X) =3D=3D (n)) ? 1 : 0= ) } ^ include/linux/avf/virtchnl.h:175:36: warning: division by zero [-Wdiv-by-ze= ro] { virtchnl_static_assert_##X =3D (n)/((sizeof(struct X) =3D=3D (n)) ? 1 : 0= ) } ^ include/linux/avf/virtchnl.h:1090:1: note: in expansion of macro 'VIRTCHNL_= CHECK_STRUCT_LEN' VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_rss_hash); ^ include/linux/avf/virtchnl.h:1090:31: error: enumerator value for 'virtchnl= _static_assert_virtchnl_rss_hash' is not an integer constant VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_rss_hash); ^ include/linux/avf/virtchnl.h:175:53: note: in definition of macro 'VIRTCHNL= _CHECK_STRUCT_LEN' { virtchnl_static_assert_##X =3D (n)/((sizeof(struct X) =3D=3D (n)) ? 1 : 0= ) } ^ In file included from drivers/net/ethernet/intel/i40e/i40e_trace.h:209:0, from drivers/net/ethernet/intel/i40e/i40e_main.c:20: include/trace/define_trace.h:95:43: fatal error: ./i40e_trace.h: No such fi= le or directory compilation terminated. -- In file included from drivers/net/ethernet/intel/iavf/iavf.h:38:0, from drivers/net/ethernet/intel/iavf/iavf_main.c:4: include/linux/avf/virtchnl.h:175:36: warning: division by zero [-Wdiv-by-ze= ro] { virtchnl_static_assert_##X =3D (n)/((sizeof(struct X) =3D=3D (n)) ? 1 : 0= ) } ^ include/linux/avf/virtchnl.h:809:1: note: in expansion of macro 'VIRTCHNL_C= HECK_STRUCT_LEN' VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_get_capabilities); ^ >> include/linux/avf/virtchnl.h:809:31: error: enumerator value for 'virtch= nl_static_assert_virtchnl_get_capabilities' is not an integer constant VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_get_capabilities); ^ include/linux/avf/virtchnl.h:175:53: note: in definition of macro 'VIRTCHNL= _CHECK_STRUCT_LEN' { virtchnl_static_assert_##X =3D (n)/((sizeof(struct X) =3D=3D (n)) ? 1 : 0= ) } ^ include/linux/avf/virtchnl.h:175:36: warning: division by zero [-Wdiv-by-ze= ro] { virtchnl_static_assert_##X =3D (n)/((sizeof(struct X) =3D=3D (n)) ? 1 : 0= ) } ^ include/linux/avf/virtchnl.h:891:1: note: in expansion of macro 'VIRTCHNL_C= HECK_STRUCT_LEN' VIRTCHNL_CHECK_STRUCT_LEN(40, virtchnl_txq_info_v2); ^ include/linux/avf/virtchnl.h:891:31: error: enumerator value for 'virtchnl_= static_assert_virtchnl_txq_info_v2' is not an integer constant VIRTCHNL_CHECK_STRUCT_LEN(40, virtchnl_txq_info_v2); ^ include/linux/avf/virtchnl.h:175:53: note: in definition of macro 'VIRTCHNL= _CHECK_STRUCT_LEN' { virtchnl_static_assert_##X =3D (n)/((sizeof(struct X) =3D=3D (n)) ? 1 : 0= ) } ^ include/linux/avf/virtchnl.h:175:36: warning: division by zero [-Wdiv-by-ze= ro] { virtchnl_static_assert_##X =3D (n)/((sizeof(struct X) =3D=3D (n)) ? 1 : 0= ) } ^ include/linux/avf/virtchnl.h:907:1: note: in expansion of macro 'VIRTCHNL_C= HECK_STRUCT_LEN' VIRTCHNL_CHECK_STRUCT_LEN(48, virtchnl_config_tx_queues); ^ include/linux/avf/virtchnl.h:907:31: error: enumerator value for 'virtchnl_= static_assert_virtchnl_config_tx_queues' is not an integer constant VIRTCHNL_CHECK_STRUCT_LEN(48, virtchnl_config_tx_queues); ^ include/linux/avf/virtchnl.h:175:53: note: in definition of macro 'VIRTCHNL= _CHECK_STRUCT_LEN' { virtchnl_static_assert_##X =3D (n)/((sizeof(struct X) =3D=3D (n)) ? 1 : 0= ) } ^ include/linux/avf/virtchnl.h:175:36: warning: division by zero [-Wdiv-by-ze= ro] { virtchnl_static_assert_##X =3D (n)/((sizeof(struct X) =3D=3D (n)) ? 1 : 0= ) } ^ include/linux/avf/virtchnl.h:937:1: note: in expansion of macro 'VIRTCHNL_C= HECK_STRUCT_LEN' VIRTCHNL_CHECK_STRUCT_LEN(72, virtchnl_rxq_info_v2); ^ include/linux/avf/virtchnl.h:937:31: error: enumerator value for 'virtchnl_= static_assert_virtchnl_rxq_info_v2' is not an integer constant VIRTCHNL_CHECK_STRUCT_LEN(72, virtchnl_rxq_info_v2); ^ include/linux/avf/virtchnl.h:175:53: note: in definition of macro 'VIRTCHNL= _CHECK_STRUCT_LEN' { virtchnl_static_assert_##X =3D (n)/((sizeof(struct X) =3D=3D (n)) ? 1 : 0= ) } ^ include/linux/avf/virtchnl.h:175:36: warning: division by zero [-Wdiv-by-ze= ro] { virtchnl_static_assert_##X =3D (n)/((sizeof(struct X) =3D=3D (n)) ? 1 : 0= ) } ^ include/linux/avf/virtchnl.h:952:1: note: in expansion of macro 'VIRTCHNL_C= HECK_STRUCT_LEN' VIRTCHNL_CHECK_STRUCT_LEN(80, virtchnl_config_rx_queues); ^ include/linux/avf/virtchnl.h:952:31: error: enumerator value for 'virtchnl_= static_assert_virtchnl_config_rx_queues' is not an integer constant VIRTCHNL_CHECK_STRUCT_LEN(80, virtchnl_config_rx_queues); ^ include/linux/avf/virtchnl.h:175:53: note: in definition of macro 'VIRTCHNL= _CHECK_STRUCT_LEN' { virtchnl_static_assert_##X =3D (n)/((sizeof(struct X) =3D=3D (n)) ? 1 : 0= ) } ^ include/linux/avf/virtchnl.h:175:36: warning: division by zero [-Wdiv-by-ze= ro] { virtchnl_static_assert_##X =3D (n)/((sizeof(struct X) =3D=3D (n)) ? 1 : 0= ) } ^ include/linux/avf/virtchnl.h:1090:1: note: in expansion of macro 'VIRTCHNL_= CHECK_STRUCT_LEN' VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_rss_hash); ^ include/linux/avf/virtchnl.h:1090:31: error: enumerator value for 'virtchnl= _static_assert_virtchnl_rss_hash' is not an integer constant VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_rss_hash); ^ include/linux/avf/virtchnl.h:175:53: note: in definition of macro 'VIRTCHNL= _CHECK_STRUCT_LEN' { virtchnl_static_assert_##X =3D (n)/((sizeof(struct X) =3D=3D (n)) ? 1 : 0= ) } ^ In file included from drivers/net/ethernet/intel/iavf/iavf_trace.h:209:0, from drivers/net/ethernet/intel/iavf/iavf_main.c:12: include/trace/define_trace.h:95:43: fatal error: ./iavf_trace.h: No such fi= le or directory compilation terminated. vim +/virtchnl_static_assert_virtchnl_get_capabilities +809 include/linux/a= vf/virtchnl.h 808 = > 809 VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_get_capabilities); 810 = --- 0-DAY CI Kernel Test Service, Intel Corporation https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org --===============2946642378261956521== Content-Type: application/gzip MIME-Version: 1.0 Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="config.gz" H4sICJZ20F4AAy5jb25maWcAlDxLc9w20vf8iqnkkhyS1cNyXLulA0iCHGQIggbA0YwuKEUeO6q1 JX8jaTf+9183wAcAgpPs1paj6caz0W80+MN3P6zI68vTl7uXh/u7z5+/rT4dHg/Hu5fDh9XHh8+H f60KsWqEXtGC6V+gcf3w+PrnPx4u371dXf3y6y9nPx/vr1abw/Hx8HmVPz1+fPj0Cr0fnh6/++E7 +P8PAPzyFQY6/nP16f7+56vVj93vr48vr9D7CnqfX7zan+c/OcDq4uz81/Oz8zPom4umZJXJc8OU qfL8+tsAgh9mS6Viorm+Ors6OxsQdTHCLy7fnNn/jePUpKlG9Jk3fE4aU7NmM00AwDVRhihuKqGF hxCN0rLLtZBqgjL53twI6Q2QdawuNOPUaJLV1Cgh9YTVa0lJYVhTCvgHmijsaslVWfJ/Xj0fXl6/ TkRgDdOGNltDJOyScaavLy+QusOyeMtgGk2VXj08rx6fXnCEkSwiJ/Ww8++/T4EN6fx92vUbRWrt tV+TLTUbKhtam+qWtVNzH5MB5iKNqm85SWN2t0s9xBLiDSBGAnir8vcf4+3aTjXAFZ7C725P9xYJ 6gcr7mEFLUlXa7MWSjeE0+vvf3x8ejz8NNJa3RCPvmqvtqzNZwD8b67rCd4KxXaGv+9oR9PQqcvE PVIoZTjlQu4N0Zrk68Q2OkVrlk2Dkg5UQnQ4ROZrh8BZSF1HzSeoZXaQm9Xz6+/P355fDl8mZq9o QyXLrVi1UmTeTnyUWoubNIaWJc01wwWVpeFOvKJ2LW0K1ljZTQ/CWSWJRonx9igLQCk4HSOpghHS XfO1LxwIKQQnrAlhivFUI7NmVCIh9/PBuWLpBfeI2TzBhoiWwAZAf5B7UGDpVrgvubUbN1wUNFxi KWROi16BAfk8jmyJVLRf3cha/sgFzbqqVKEAHR4/rJ4+RpwwqWyRb5ToYE5zQ3S+LoQ3o2U2vwkq SU9Ve5gtqVlBNDU1Udrk+7xO8JRV19sZ4w5oOx7d0kark0iTSUGKHCY63YzDUZPity7ZjgtluhaX PMiKfvhyOD6nxEWzfGNEQ0EevKEaYda3aBi45eDxRADYwhyiYHlCyF0vVvj0sTBPCFi1Ri6x9LJW cDzF2RqnaVtJKW81DNbQpAodGmxF3TWayH1idX0bT7H1nXIBfWZgJ7vOC2m7f+i753+vXmCJqztY 7vPL3cvz6u7+/gn8j4fHTxE9oYMhuR3Xsfm4UGRlyyoTOrFUqw5VvgZhIdsqFguH0GsqOalxuUp1 Mk2XTBWoBHNogjOmzDv6D0oTny8RBAJXk73t5M9tUbuFoVrF/LbwczRVBVPoyhRJ+f0b9PXsDdCW KVFbJeMPZ49K5t1KJbgcztQAbn74DjiODj8N3QGPp/anghHsmBEIaRnOgwMCeet6kiYP01A4SUWr PKuZ0r40hBsZtejG/eHp1c24IZEHnLZZg5YFGUu6dOiklWAEWamvL858ONKXk52HP7+YiMYavQHP rqTRGOeXAe924Og619XyqtVcgzSp+z8OH17BqV99PNy9vB4Pz07IekcBPG3eWkomeSXRO1DpN6TR JkN1D/N2DScwVp2Zsu7U2lPvlRRd67F8SyrqFAGVPhXBr8mrtGjVm36YBIEdwu1+mqQkTJokJi9B 85OmuGGFXgf8qP0OyzO1rFCBV+bAsgg90hBbAgffUhmTxay7igLRPHgL/puvIZDZcM4ek5i5oFuW 0+W5oWOsW4atUFku98vacrZe6xt4zoTINyOKaOLPge4yOBugEFNTrGm+aQXwOJoocHI8O9ZrY4hz 7MCBPt4rOL6CgkoB1yh5ShKVqRcg1ahft9bnkB4b2N+Ew2jO9fDCJ1kMUdPEG8WJkASQi+EI4MJQ xO8joikg8kjzvxBoOvHvJB6iYAFWlLNbio6fPVYBFqtJc0XUWsEfQcASBCpOx7Di/G3cBpR3Tq3x Bv0Mxxz1aXPVbmAtYD1wMd6J+GzlDMD0O5qJg0FjwPae4CgQGIwUzMwBdMwxA5drkPZ6FmWNXlGg cOPfpuHMj7YDDyPaYoLWGQFXu+yC5XSa7qKfIN8eSVoR7IpVDalLj3Xtyn2AdVR9gFqDMvUccOYF 50yYTkauEim2TNGBdCl5hfEyIiXzT2KDbfdczSEmOIARaqmB8okhnz8/sISpVZKAgJlONOjwG9Mw zw3ZKxN6JwMrAdtYj8injDVcmDKaNgTjN+DJOxU0iaOi7xODQi9aFL49ccwOU5k45mjz87M3gynu U2/t4fjx6fjl7vH+sKL/OTyC60XA2ubofIFLPrlR4Yjjsqz+dUjYn9lyGyUmzfffnHGYcMvddINp 9jaCWSsCpt4mziZdXJMsqY5U3WUpl64Wnp3D3nAIEnyB3nENxl53ZQk+jfUVxkA4Neheacqt7cGU IStZPuQCvIhFlKxOu/9Wc1k7FARIYXZvaLx799ZceikzG2SbYg+WDmLBMtKC0No3Ny4didqyoDnE 654giU63nTZWZ+vr7w+fP15e/IypWz8DuAGrZ1TXtkGGEny/fGMnnuM47yLG5+ijyQaMGXOB7fW7 U3iyuz5/m24wsMRfjBM0C4YbEw6KmMLPNg6IwM9wo0KQ1JsWUxb5vAtoCZZJTB8UoRMwSj163KiA dikcAb8D88s0MoljC+AiEAzTVsBRcUYNXDPnULmIVFJvSzb0GFBWg8BQEhMc687PZgftLOsnm7n1 sIzKxqV/wKApltXxklWnMHm2hLbuuyUdhLYzP7QfwbKUGtQOLMkKY7R3kB5aG73TAfODqBjF26Uh O5sx9LRMCUaZElnvc8xo+farrVyEU4OCqtX1GP/02X9F8MhQEPBcaO5SZlbrtsen+8Pz89Nx9fLt q4t3vUioH+ZWQP+AB4Nl41ZKSjQE/s6nDVG8tQk1jxtFXZRMhbEF1WDVWZPyx3CQjFVuzrEHQulO w/khTyx7GNjO0b9uVbQ0wqeufZTg+wGqNDxjc0js5ONQ47H12WeIr+pO0tmBM8kCe+V8ecHBVpfg boPsoq6lKVW+3gPrgx8CLmnVUT/bBgQmWyYDCzHA3GLTmaqhiWpZY5OMC/Rbb1F11BlwEBiRPEi5 7mhgS+CnabepcSxiveVBVweK+AnACsVmCnyC4Z2sxfnXcMzU7QXME9HNJV7bDtOEICm17j3LiULh SNM1yZYnlxETNkqvzU9sTEdMUf6bd2/VLjkrotKIqxMIrfJFHOcLM71dGhAUJgQcnLG/QJ/GpwR1 wAXXYXyzsI7Nrwvwd2l4Ljsl0olJTkvwimjoI0/YG9bgNUi+sJAefVksjF2ThXErCk5OtTs/gTX1 wvHke8l2i0TeMpJfmnQsbpELtEMXf6EXeJc8LW+gHnr34oTylQ3uxjkQLkn3q9+kPl/GOd2NsUou 2n2oT9HDb8GmuWyJ6niIBs4PATlvd/m6evsmBottZLNYw3jHrZ9RgvNa76/f+ngr+xDic+VpQkZA v6MhNEGCANtv+W7JRPYpccwz0JpGWSiYHgyLo0E6s9G3sAwB9uVkIzB3J/HrfZUMFMdJQEBJJ1Mr BA+7UZxCkBGuIWrW8dwFCLMBbtdE7Fhq9nVLnSINJi44S7RtrGuoDKwGnMOMVuB5X6SReOf59k2M G0Kty7iXB3EmW3E9t+N8SQhshYIhLYs4kokEUFIJEY9LPmVSbMCk2QwX3thGfBrFUwjAZHhNK5Lv Y3eJ5/QEK1mHqMkZhrg8mRibxvjNMapzIb34+cvT48PL09HdQo3B4kKLgD52wSAnfkwY/nLkamv8 h9p82XQTJEBxZKnsMnu3iakgKRITnOmuXfJ3ArG2GgJ9BC8OEXh36Fzw6T7Sgd6kfa0e+3YBveWq rcEHvEzF4APyIshJDdDzVBcbHImyxIT42Z/vzsIKItxSS2hMmbwlGCZopjTLU7Sx/lIJDjPsBASI JEIq6+svo62KG3xkvJX3FCWrkQvqwQPGu+6OXp+Fa2xxbMcti1xsrQGEDEJh1kp2bXw9F3ADVgng FdINqoPJ4mmZ8sHtLkCBFCKyNYqTKCQCL8iD0JIFP4DQnZ/toTmmAgJ+ujXnZ2dpZro1F1eLqMuw VzDcmReZ3l6fezzhFNha4qWxv4wN3dGUVmvXe8VQqQHHSGSy85DHJLVJqZ4JpkDP0g5T65jsXDgU G+fbAXxDOUxIalY1MOFFMN9a6LburEEJEqEg6+hsc79Bij7OnfcbzfJ720IFNxI5L2w2BOZIq1Rg cFbuTV3oIUebTESeCsIDxnMyZZzctxi8av82s3367+G4Aj179+nw5fD4YkciectWT1+xkjG43OyT HylO6TMndAz6VKjnxsRKii0gmKsp9Th/gJgogAc4XmFZXDo85eaGbOhSYNryYI4hJg/GL7Z4x1PM Y+B4bbPehZ3dVeqkO0bZzAFipM4DaF57qamb96DebkC52ZjD2tpEdhf96arXj0tKaEw44AF7anb2 a7CtVhQVKDqx6eKkEwfrpPvKN+zS+tlDC+nzyG7xaCRgqFlC1ba0pKxCby1AWGc+eeJupjaXbrHL bdBpLpVbTYpA2EbSrRFbKiUraCrFh21oPhRzRQiSz5afEQ1WKVXN49Cd1n5JhQVuYW4RwUoSt9Kk iGnopNoH2VBEUuAfFS92CiFyezKL6LAcKkRGcNbymI9CDZuegVSVBHbTs/H6EqFE0rgnASq2rq0k KeiM9AF26QCipJxbWM7wWiVmUfhbE9Dc8SKHHTIROuWOL7OY7kHZhBu4UxAog3+j1yLGZVWYoOuZ tOhQQWFB5g2B6FA0dYrFJtEkLfUOJoT3l7HhFIhISlLR6vK0CNEd2JdIqTK8HYczTqv/gbzwdxnF Kqgg4yhOlakozkYi0Bxtt0dEX+EjGrwAARRDbTJYs7BBISYvdKJJ68J6lIW0gsGeDGws2ZusJs0m tU00LjX4jKa/GBtq81bl8fB/r4fH+2+r5/u7z0E53iDBnl8xyHQltlivjDkAvYCOS7ZGJIp8AjxU u2Ffr94hjr3nbZEhMP26mCqYdcETsIUsf7+LaAoK61nOR8x6AK6v5/1flma92k6zlBkNyBuSKNli IMwCfqTCAn7Y8uL5TvtbaDJuxme4jzHDrT4cH/7jrsp92jjS6CTppjxbaw3IYqMWH5m4sZZzCL21 OtnIErMB+VnI74Zt0vlKm3rcWdEHT2mxCSgGWoDz4vJXkjXibzRleTrxH7ZSPK1Z7erfuNz+qaUN x9LYi/J08s5lj5pKduk88oBfA88vNqAT9wbK3vLI8x93x8OHIEaYimETCm1kPfbh8yFUb72DEcik vVxB9q1JUSw4fkE7TptuQVzHNpqKxXmGi5x0fNwjh2ufZEA2bW4M0f4ytLJUyV6fB8DqR3A+VoeX +19+8opWwB+pBGYmAqNqoZy7n+lYyDYpmKR5WoRdA9Ikq80B18/pQdzFnQfIm+ziDGj4vmP+CzAs QMg6FQIKTjBx6e8CwKn6kxzj9DBTipC1dN5A2gTXLH3x0VB9dXWWvjKxorlXZZY80oWTcaf28Hh3 /LaiX14/3w0yMDCWi/z7nPUw1qx96I6BC4iFG8KlhOwU5cPxy39BzFbFXDnTIhWFl0xy6xFyyoPc Unlj8rIv5ktDh8TEhK2EqGo6jukfR4/Cux+bZJ5FXnapFBy1H+mfL4fH54ffPx+m/TAskvp4d3/4 aaVev359Or4EWyshBiLJum9EUeVHjwgpIeCf7RgRWAY+IKdiGsRIvFvl1NxI0rZBWRZic9KqDksj BClC39PHWpaHfwn8m6vU7TG21uHlcdtiAZbEbLRm/pUO5hS1e3+2gdBasyp6fmWXnbMLM0uPIaZ/ n2BlsojLZnsW/F/OY5i1sztu/ahnBIXFWHYVED4D66+NzejKEDmUoQzsrQ+fjnerj8MinAfiW5KF BgN6Jh6BQG38ooEBgrch4fM0H1PGBYg93ODNSnATP2JnRaII5NwvDUUIsdWQfonuOAJXcWSG0LGk yt2EYklwOOK2jOcY6rVA3+s93ufYV7Z98c7CxrJ9S/zMwIhshAkLZrHuoAMVextxpSNzUOMAPoNM lhXaWdFjjIjDi3gIzjv3ZDIVRkH0v91dnXslg1iutCbnpmEx7OLqrYMGz4vvjvd/PLwc7jFb+vOH w1dgKDTPkzMzKHJJ1HooYh1I1If77irPp5twJZFe2wGCIfYYxw7bjCu1fut4C+5O5pPHXqzkZkP3 Cq9BylCZiFbHg/SjQtwwq5yclYbZRU8pxa6xOXJ8JJBjYibKuuC1Ob6LBkEwWfg+d4OFWNHgNsAG eCcbYCbNyqDI2RW4AV2xpDFR9zcjjoMm5ukpn4afoIbFl13jikctx/ZXlNGb1y0Nq9Wnl752xLUQ mwiJbg78Bg3eCd8FGgRUwTlbv9O9I01kt8Cz13gH0D+imDdAU+HuwxaQzukzgUX0Vu5e4LviWXOz ZiCTbFbjhKWMaizEtQ/nXI+o3eVFxjTeG5rZg2jFMR/dP7KPT0fSCkS5KVyVYc91vYMYtFN++iM8 OPwgwGLHIIluIesbk8HW3RuZCMfZDnh/Qiu7wKjR32Brr8Y8wTmYs8MIz776cWWVtkdqkMT8Q426 7IlWdDx5willksL6Dwf6Zqh7wfdY0z6hbl9ZJdH4ADDVpOdEJznusV1fRBMfkIO6QocFXCG6hSpb /AKAe3Y9fNwhsdX+jrSvMvY06wLc64kEroEbIuSsJnYwFn3dbIC2L34DfZ7sG3UCMRMzd8NtnOk1 KGB3+Lb2M+aQxAPdmNEFMhKPnZ1BpzV4HY8GAauXsSQg1Q5x+E4ivhOyB2OReNMIBljG3UEfDLf+ NMeXBR5riaLD2yY0NWDskDcT6s1ihgvh1NqCevvY3O1AVSX1btjrXciLot0PSlPXUVQLYW6oe/Ia S5/xChTCpsJrLfCjIqzq086XMwSJjM8YR6J+xTNNKXsNJkUPX9mQNzufqRZRcXdH+WT3FGqidQtn dHkx3NuHSn50G8BSpSw9qkH/dUzctX9QZGiTy307lg5Vudj+/Pvd8+HD6t/uMc7X49PHhzBtjo36 nSdGtdjBN4seQcW4hAdqm7h3JeaN+dWP8k8tLqAefsQH/UjWJJ/I/IWHOgaNcD741M3XAvY9mMIn TNNnfnrJ8vfZn6t7bYOBbqq61rXpGsQvdnbopVqGwfgv4XEcJfPxQzwLKbih5UKqq0ejxODnBE61 cVcwnCmFH0AZ39Maxu3VeIIMXQNcDBK655nwpX/QV/YhfXxFntXBdSy+mFW5wsu792E9+fCWNlPB pZkHrln6Sdj0ClfTSjKdLm4aWuGDjPQp2ZfgfVmKC9wXm91kqZDMTeEq2+M9IOVES+pZdqi9O748 IDuv9Lev4Rt6WIRmzr/rizFSzKkKoaamYa7BB0/52GhGf/n8PaZOwlMBGIa9fqCNYHul6L7gI6bn /F7YCP2YcKVRBZiMMKvmITf7LMwuDYisfJ9M4ITzDSNOHxdx/mjwVYD+/fgYFDfnXozWsMa9zGrB p+iakGOjghGXn5Tc++iQVT2uMxyVuAnuxuWNAt29gLSqfwE3mg37waZiemcyNVnGxJ3lTbrrDD7a hgZXBNqoJm2LCoIUBWoUE93STRZ0eOdqMloOV8vhp4O8traea8g6Ti2mDxm4xOmfh/vXlzvM0eFn 6Fa2EPbF47CMNSXX6Ap5bF+XYaaib6RyydqgiKBHgApMP/LAYTCwSCcRF9ZmF84PX56O31Z8uvKY 5VROVnMOZaKcNB0JzPJUI+pwqeS36xyOZuwjAtfP/6TYOJxLscROKuVWf/e9Z1F0iR9Sqnx13+9n /LCLP5UtvLNFd64q/E3UKUOTFL6uta5fHpfL/T9nX9rbOJIk+leM/fCwC2y/5iFK1AP6A0+JJV5m UhJdXwh3lafbGFe5YLt3ev79y8hMknlEUoUdoKesiMiDeUZExiEdkAeQn2Fr4h64SPiuhKkkRs3V EAwk2Rof+3G7ieUQUjFlyuQlz52TGvVdB8RBUxA+EWkapqd1xmHzuE9p99vG2atesHZnOMkxRsag I4MJMNi7IBXsauY+ItefU7GrB90WVkJ2ZaQ/TOu/GYi6dwGWdisiv+2WIp9bmxXo5/iMXXqfSaVP oHDjrPh5JXdoImZrHONjhUKKKeYndZxyH6WTtzjouk74UuMeiLqHHz3emJeGGpjpAAFQKD9/rCL5 tRDAhww2CbOpZnbvyPEJaCY1ysoC8d1c7T0es7LVwnLZz6Spilq2n6E/KEN16BQNKAAzDUZOMfcl nXRb7ASsnz7+9fr2TzCpMI4+uqNPmeKBCb9pzyNJRKeX8qD+oid4pUHUIiCSfpN+LF6py7ag0L5B TadzOYwI/KJHxKHRQCJayPJuCkD2NJHbTHgYCTnH8JBQJNgTM6PgJ1Wmtbd4FGiIotVN3mFuThla f9qyWDqZGu1BArOBxDxAajUmUNHyoCkQ1w4jbxerYeaF02mF8yKmW6jI+H7Aa2ANwOsgt7nVauDO PZwm6nE7k5mMsi9xgxrKzyRJGVEBSA7dQ8XzutV/j+kxabWuAJhZyNs6AQRd1GGnKNtdrfwAxyF0 b9FVW50HHTH251oR4md6hTt4qOn91pwKNCwSL3LpC7WWc4rXnjdnA7D0RNb+ADI6agAqTioDJmCg ILfKyRMR3VEJNmwF/wSx9GUg2xT6VzAMClQPDk6XtBgYRkeA1W520XVt2zAcnUvQYUqvE9AK/fMw bxQEFct82AxNzjj8Spu4Ng1W0bFPWgxMLPCHuIwQ+CU7RASB1xcECJy96rw0o0plQUjV11jA3Bn/ kEVHtGBRUqmtKbClPtOkCf6tSXrARj5W/SQFx0YHHnV64dhpYoxiR20RmwQw4KsUbOhXKabpXyVi o7BKQcdjFU9HZhXf4ZM4oacR/u0/vvz1+/OX/5BHvkoDokRCbC9b9ai9bMV1AjJ+bjluKRGPPAbX 5ZiunDBbelitIOn5s4Llp4+9D1XR4laZDFuUqKMlq9k4qKCAclozCKGyyTetWgobtx3GKDN0nVIR l8lw/UObafWhzR46nUy5DSYIXnj1BofenmNQFeLrmtfAptv2OSQ7bMfyOret1Q5YylhjW3Yh4HHi tDXWlnO1Ngs69lqICZqtcs6wn8ZK5lDomxGjXW4DgsjDwxwIB5ZrvO1bwbrkiqfyVJqKs+ylhPJZ VYvLK5RUf/SbQfLttKhLuiKlItBMZGgyk9e3J2D8//H88vH0ZiQCMBrBxAuBgpEu1OhFE4qHFKDS ULtScIp3a8VrsdFNAs13wyRoCBbdss7hnKuZnLgIIxTKQrJqbggCTGukkooCnusYVQlRQYEmm1hw 3MlL+QIZzd/l8QUo08Eaolvx5wjZYrsxJvy5Xet1z17EGnpNyXtIxpCkt2Aof1YWfWb90gjcBvBL VqHLLXy8QnT0Pf82VdHh+kSFiE46c7K2vAgptKS23DjqlLc/8wkQz+onqCwZFNQ518ZMmZ1pB39b 20OH8kxFMEyUpJXUUa/sIPobXL6YRY+yFgBRRYRuaeEAt6DEDfTNAE2irQE3NyP9lnN1yGrlU/Le 1m8qJ4HuRog5ctNz9EOjJjqkLJ2HpUI4i5R6eO4PBQQDoELYWKkgbUhn4UiBNfEnymWpMH5caqCm j/QWWWwLBMaHWxsLeNXXh+IYoRbEgGIaGqUKrr3Qq9AOZgUH9nED/j7IKnyo1wjG9NyKBWKt4idI 8muKkCytsPXDtZn6sEk4CTzvq2HmuNiFPLD3ife7L6/ffn/+/vT17tsrvJm9Y5fx0E9XDbJfB75G 7QzJQsed8JTmPx7f/nj6sLXaRx3oPLVEIhiJheEx6ZCurhdANx5CyPW16MBPJKAr1kxcMbJS5a1Q EtR5HqPUeASZota2GFK6hpDHFiWVSZyXcvYNnGRirtabbdgt8pPtgm40I/2tSqf74aenfrk3froI 7cjP03Y2tTBKnbSVarSh7KNvjx9f/lzZvT2k3UnTTgh5eFOcjIo/twaeEyZGlHSMqDwTPOwiRkyZ 4Ky2z+REVdfxQ28REi0FDOHsZgH90r1V4OeOlYX+p5a4IG/Pln3F8YI5XmuR3ii2RAYYNUlQEWom yJL6RoOaqsROCNf6xLSsVcjfrX6yznK19+gLiUnEApr97JRSgd6iWNcpS6+/1XaZ1YceZXYQWjZ2 a59bqVE3UIqfX7tchdOg2VMQ8jrXc0AgRBaBGSFUDWEQCv6Utk5y6lVlF0LDWdj1XouL5+d63mVR Wd2qMANX6p+dCBB8f65thBlGiKwe6hZipk39+QLdDV3TQsvvutXpUU19EYKz6lq6qn9aVIBqnAj+ m8UP94KtBo0LYI3GojXoZwzfdyhSje8jcHASYhUKuM6Dq1jLjjSJ7A0AtkYGYG7f/ByGsiJqiD49 1Yn2m6JudJpSWPsk6l+pvNDf3lUycOkx5vxCVCU6BTB1LV7NhegRcjiQilvcTt71hCUkXBAfb4/f 38F7FIyeP16/vL7cvbw+fr37/fHl8fsXMIl4n719leq4RktRJMuIc2pBREfx2orgrAjlwVaCC1Xb 8jnvk6mlbJrKS6Bh/jjq2km6Bw4qE3PMryV+unBsjr0pcVRzyY36Y9aCATM6kh51CDmaXauwu1mQ Z6lJX98bnDsbP3JUhlBrd1lDoVSmWilT8TJFnWaDuvAef/x4ef7Czru7P59efmBTVueqdCRK/7+f UNzn8JzXRey1ZKNoJfjdw+GqIpYrXBgGV3ZM6jheVNKSTIoj3pahY9FrVDUsRbxGMDVqsc1QNTD6 t06Nq51iinytPh1tHwT5W+VNSVFFO+sw5Zms80ngs9rAzCSUj8dX8kzRteIp6BuG7ftSR+DksxAu 1IBabwQaU7IpdJrOQil8Q15XaE3FBk63qjSYBqI+lJY7BuYvupo9Jlly1r0RFAK6XFAbJ44yH9l0 CtErmQVa28hip//P9uf2+rKnt9pSX/Y0dl0qe3pr29Nby57G386lPW1pUt2xeo+xyrHdp5cTuxbn Crb27bn9if0p0WTnYoufVQoZnL23qZrW8rCnUB1xPYlCA1/Oc0/epq1+4jM72w6TaEi3WpG5KXSK lUPGbFHf1DoF3ddr6NUdvkWPMrmPN88ymbhutdGbd/zahkbvbljl7DBIs+T708dPHAeUsGaa3fHQ RfG5FDEq507cqgi7fLk5we1XxhW6ySIhH7OY14qTrZ6l6qMzN91LFltAPlAUcJckRfpuGyFR0QhE HiIszEhfO+wXhDXQ7kTV510y8uzry8jberb0W6RqOz5++ecUW16rGMlyI1evVSCLV8qzPPwa0/gA L4iJHFeAIyZLM2afyq1gqjSQh8NKB1FN0Km1ltAzTMv0Zg9sWGhXWxu8Rc0gtEtRI8SiVXRy8Hus KLMRgShnKTAyJ1/J7pwB9QajHs8oAmpH7LPlaapkyxm+hfTfY3Go6OzWTaP7Ugj8pYxqcRhrGh+d skJ5bB4VAbYaUVKZ4QB6ZBzG0PFcJX22jIy6ve+72PUuEcVdUpk2OBqBHQPGh2qcVJniQK66OfeE sn5SZsVU/QlHnMhn2xg0kL7Coqicie4TS4t0Qve+4+NI8ilyXSfAkfSYLkpZYcsWhzFdC3Q8XNBF IVFUF3mR8utHrkxcSNwqFKmqLCVtFf0hB0nqIzkeCrgEs2hkKrjs1b2bNK2Nq0rRvTx40nCVUSvl K2iPjfY5W8q9tpZcR0WWZTAoASo7shOJx1JmJ/v9X09/PdFT+lfhIKud+IJ+TGI8vOiEP/a4q/WM zwlmXzmh265oNE00g7NnhfWWO4tz9oQ3YhQa+PX6++ze+kTICWKL+cg8dDbfCsBmfY59eB/BkKzW e7j15SlZMQgFAvpvpr8+8JIdzjLP03J/s3fkFN+kSY7Nyfq4wCjub0xOogftNyjy+58gSqITdvkv dWBTdDyuz3tbrNW52LKaBUuUq1tWDMG6I5gaQ1WXvDy+vz//Q6j5FFuAMSmNDlAQRMKwv+Ewij5h 2sRVGnbW2s4gIMivimUMg8ELzQwUAC3O0wRFrI94u+Ri0apJBBa1wdQzeryuEiQrz+Z8CNvc/Dio VjPmExgmy+JBU4AkY3j1Ns3mN7fkJGfQWlBJ1ap9EHBmJ4FilNGX4JBrDEX02dCjiCSqixTFFC3J 8DLgbW+MWaSZZQOAP+dqnwBwiAS0QA8RN/qNzQqqouuy1KyARFVbIhUbXQOgahw5dS1LCwRMCn0y GPQU4+QJpNczoLRvxIQCF2RCjQXIqhUWKQimL+q8QXtYNchAFTkyStw4FJxKsQb0dc8nDPXaADRt gbVudFcgBMtgIsTZpDfXJ5Pn8dpJX+RKqOs0wXKHpzXEuCNNeZG52JjKWBGLvKLIPzN0+hO385Tp LD5eEkmK+qVLBHVi6URlccWVK9eTtOg4S9UsHPKtnoOOBn/zb6isdKFCEZx03xAg8zGSJvUifJHx 6WTm4qp7Jts+ylEAECqISeuIQaawtSqUngG68TOouIh0Lh+JaoYy8p6r9uHwwuyDLg9MExTUfdd3 6q+RqDFeGaw/Y88zrDOJHBQXfo1NVkGMopHrDyUhp2vlIMo5YeEg5UyarcIb8BuPtaLzdSaF4STN ZK8BImA8aPFx43v5R5uPn5RQGhRA+i6LKiMyMlTJlPiTqZMcRuDu4+n9AxFl2lN/yGyjl3ZNO1JZ v9CUlUadGkKOWbDoK6ouSlkEJBG06cs/nz7uusevz6/zK78SuymiAiA2qpHiR0B/6kpmCRMn0q0B gMNV/f3J3fv7SZtLAXfp0/88f5EDpUvEF6Tty5BYxE7AklLDSjhY6UpfkqhM4CEbXDDlWIuAy8ts SORrjX1MZ4A+RfXnsaB/+Sr8dIkg1mebFFku3V4t50y0flhAc7JyFJcUGjjZ7Rx9tBhQj9WPUGAZ 1RWygoVPr3NLChdKUY32oW+z6LSMhTpjnyJIJWgpSJpcHITzgiFtcfc8hT3XFsyx8F130JuoktYL XE1WmCywzBrVwjw6Go/LQaxVaKtYunjQQNg5PYs6VV0zwWyvdwuexToey0YJ9DxhNT1+N5yUeJn5 eJIVhpaTDR4uOxF2UICuRZeViuvjBAGGRoJmzPNCdsZlIPDu00BEzu8siArpMkryA2iRJHV2XTIA c0UVgbqWuRLUMFVZCVH6x2vU1XTx4BzBTJ9APP+84EEwx6Y+ozGAJmoIAkg/HMIZ1ixr5SGNzS6z QGZT+E4gYYHAEbrpIaDFkRobtPS5SyMpH5/5UVecyyyLWBvSCcKV+LRca8UlSWVH9qdCsR6e0bYn IsoKTF2ZC02wsUsg3BSsTtRzWSKb0in+x3/wE4K8fnu6+9fz29PL0/v7lBvpDpLaUNjd493b48fT 3ZfX7x9vry93jy9/vL49f/z5Tb4G59qrDHXsmvFllhK09/ZQUnLdZIrOpNw9aiUsOQ7aRt3wCIBr jYhgMvqZsHSirDKTn57RVLC/OXvjsbdW3yTxSu1FTMjt6lvDjHFG9WlpR0LfhRHoQPfqZyWx8LWg UKTVLj8VMmfIfxvzLMBF3Z6xPSbQh1aOPgnc3b7Vfy9BKhUekSKGDOdxBBp5/pyvrAKzWU+y9ige YjUIvBH1/YM2kDMWDjJN2pQevdFMwUKFoXyrIq1LgRA0iAhyIKApoYeOiPQmQJTDp30rZTEKhDBI Hl2kkMN20L0OOL4iqgsY3BKquz6EpmsUcTrrj33TlJMsJwlZLB71Iirwh2sLH8uJC/nZzPw1XkqY CI0PZRhICyMKzAPPi/C8HlRWRJ/QGE2NhBlXgqXqP8a0qaJCjgUNXBtcMzx24NyFKZkGlAESbCFQ cKSuGAESPIylzJglXaJ2ICJK+l8BwXLpzrj1xIYqGVylP0W8ZA209b2VHQAYJFX5PE6lPobLqPhq UGcp9mAII6+koBEAFkeeT6OKY1mPjExk9qMEsOAeAnEIRSpqyOBspYUU55Z+MiH6HMtt0xMOUPCY yYI34smpobASh5BthyRSVwOLSst4UQ5TkUVzUQF0o2mASNEVsBq1DAzLcrftAuYdjj8WyWRFjE29 TKHmdNYxUIG1C5Dp7FYHyLFVjm2uHaAFBVf08vQm5ZSUhiTv6f+7ck55gB4b0hsmCjNCBKo0lvRQ 0CN1MLqRPr0///H9CqmhoEfMPYbongd8V131bXZlLZpQEG1x6FRA7RrPjHnAn1/YHqNXoXY7T7ZH K93nUXZff6cD+/wC6Cf985a4l3Yqzqg+fn36/uWJo5dZe5ecNNRPSqI0o2fW8tG4HHuz2jkcN75a 5pWUff/645VK1FpH6CmSsgQtaPNKwbmq9389f3z5E1+b6ulzFbrOPkus9dtrW9ZHEnWpuiiqpLDp T7o0Ppvuz23yy5fHt693v789f/1DDZD+kNU9FlCri9oilTlGARh7Uuw814SzAFki2M1vvsTdTgTi yO6GsR9GW4D8ubYqogUOSrzzGaepFOb6zxV/qFWYY4GFQLE4CztRsKD9Y6LFlGBj1T3+eP4KIdP5 dBmnkTQ2wW4wu5ZQsWEYsG5BiW242i8oTI8tb2W0uoGR+LKO1tLnJXvZ8xfBHN41enjZM8+lwV2J l89RwCw7H4i5E3OcXfqqVQMmTbCxgqgtqFUdhBYqlcw2lP9nzcwZKCFX2GydM6fqA38w2bMnvy5J FnUQizyc0orkIOcDlXWXlJTLhyylWHYkfRBQNOXWyxLytMhfv1CuJpOA1JkgVKCHhP65s3oKsuMA rzJFWJd0aiwrBY7ToNJEMaViV1wspuGz1rGzWAhzAlCEiWooqwbpgVBiRsYzGQpill4NWSBTYGmI AA3MHqOTxC8JfTmX9EcU05tcz4d5UOKu899j4SUGjMicjoCpORinwp2USAwOK5agiC2xXF4tgMrZ XTdljVMTtJibcE7k+5UJcHIyiGboZR9MeEGHqNrVqMlC1bEYY1RtOMloUwEpO+3U3CxxN1QA1iJx d8B5s7hncnOHmqC6pV5N9NKnbN6R22lOpvHj8e1dzX/RQ4qnHUvCIYeKp2ApzYiOanIMSqeHZZhd QXEnJhZIn2Ww+MVV+69UwdIcsmRFFqszswSkfWrq8gHnB4xhYKNzpn9SDoxFHbqLKGkPvrE88+9d +fhvjfWARlnnrV3i6Qg6XG7Ke4tdmA1RWDFdnlqrIyRPcXsqUumF5Ilt1CdYgFmC7ANqTt1CNyZ/ XZ5ukS6qfu2a6tf85fGdsl9/Pv8wL3W2yPJCXSmfsjRLtEMI4AeQHgVY6R6tgb3yQ2BVLXeRRAVH ShzVp/FapP1xdNXKNay3it1o24S2X7gIzMN6ymQNXFU/f0yVkj41K6RXeWRCz31RantNlpUZoNEA UUym6DYTL2OfLi7GPP74AW/Ok3r9H69vnOrxCz3S9Dlt4NgcpnD/2lEAWSyU20ICTgHXUBz9/q7/ zfk7dNj/MJIyq39DETB9bPZ+8zB0k+NNQqarqC9KY9FNBIesKmpcAlfIWspDQtgjy7TzlOlj2iR5 GcnWHWy2qnS3HYxJLJKjCcxI7HGguvJOobMBamtPSRJ7I2vcSlJn/cfTi+ULys3GOQzGMKnaCbn3 TOa+QNLFTht7KrLyJbyIxzdWH38Henr5xy8g5z2yMHK0KnHjYvIja6hKggB32QE0ZGNaH5AqObae f/IC7PWWDSrpvUDbnaQ09md7nL5XrrxPKXT9jvHgIw2NyvP7P39pvv+SwAAZOmr1E5vk4KNX5e3B lD+ghsyw6hMwu0zqDDAoELYWpM29dlpgVJlGMJ+2u0pQNWoUIxnlDXBnHLSB1HueJQkoE45RpWrj LQT0Bk30E/c6ii9Vd4xUOE6OxlR1j//6lbIijy8vdF8B8d0/+Pm7qGLUk5VVmGaQ/RnpJkeoGn4d mfZoJ5MoRx8WZzwJAn9Aqq0GVRswI+DIsx8lQLFqgSL1jGmyjLGrnt+/qINDTMepuRb4P8rNIxi6 vpojNl4FOTW1moAeQXKeBMmUsEbLspSpFxVOqibXwejiuJ+2kDwUbTEtSDZYZQt3z//h/3p3bVLd feOpdlCmjJGpNd6Dra7EgIlz4nbFRrf0814A2bvjhsUUp/KB/NrXCq5JlR0VsLrmNdRkUqW0eo4L AzBeS5Y5lhybMlWSXk0EcRYL2z/P0XGQZ0zLyTShIIRwbOcSWM26RCHhjw9t1imZvNJeOoEaJUo8 Fc3OddHrsdsXLGRa65Uc0BR4auJPCkCkEldg08KVYYqYTn/XsvxMf1eKirPJp2dlBcZz+On50Su6 +PvpBRNEDTVW1QJYFLccNLa45DOhoyEMd3vs0p4oXC+UuHwl1w5LtCMsNZhFxxzJtpVMLBdi9W1H JPiUOz3l/KzPZQk/cGtmQWSxxpvQoPsnBJiHovW9ATN5+Ay8hmQuB7/5LRxHFpmWkYh8blhyMaMb Z0q8SlBSOXOVIO3i9S+tb+DJgOt8J7yNt0pSyiWDzW6SXvAWKFvIFixYCyDjC6+ctBH5lVOebQkN 4629gS6G5sxM5OZyuDVKHRnMJ7f6UmXKI5Q+tIBHVRQUMeYWLy3A8TAQKEOpNDpf4JIKbhnfNPCC YUxb1MghPVfVgzh1FhVJXI0RQR/Yj1Hdy0JSX+SVxqoy0G4YFMO0IiF73yMbB3PYpgxJ2ZAzGAVm HTMTlYse27EoMWv1qE3JPnS8SE1LXnp7R3Zq5hBPenWl0jqhd+LYU0wQIIj46IIpsAFnLe4dOR14 lWz9QFJwpMTdhtLvi3gSmPNcTiMJXoLHs2RPBPcI/XbK4La+8QxPOv3FfnoKZDrKBcXfhUeS5pnM VcNbV9cTRaJsL21Uo+JA4ql3A/9NFwvtRdSNnssGjedrzVqQg5GHU46h+9vD49wseMxoXmDL7BDJ UT8FuIqGbbgLDPjeT4YtAh2GjZKVRSCKtB/D/bHNCHa0C6Iscx1nI3Np2jfPoxTvXEfbDBym24Yt QLrPyLlqezmPYv/09+P7XfH9/ePtL0ja+H73/ufjGxUblyCDL1SMvPtKd/zzD/hTHvYeNFvomfG/ qFdSc4otUBbEh5cIbD9CaIgI9EqtknsNOMcqKxDQKNv6LNB+yIwNdKkYS8oDWn0HxQllpyin/Pb0 8vhBvwFZgJem1V8VlhA6K1XM858cG20LRSWdXk0inLaWCj5GcVRHY6RYu5zBQQftj3J6L3VQXq1Q rbSL1JTdILn6pE8wwkyyzOtVo9yaXVSkI7Ct+NMYqw9VYyANKTc5zpPjl+ocud+SzjY/Ey0HMJ/8 LMvuXH+/ufvP/Pnt6Ur/+y/zq/Oiy8C+Xv7qCTY2R1SPNuO1SA0LvCH4S8hqn+aFAobKfUOO4glR 1uNGyZhV56qhQlvcq5FKhOOEvOCUNVUjY7iw/dqncAjlx9F7eMI6gaR/F0AId6fDElntPMGaau/8 /bcNLksvU80FPYgxes/ht7be+wmlq0Mndd3H2/Pvf8GGFpYE0duXP58/nr58/PX2ZArocaCEZ6I/ mZi78rQMJBWz6zBoZApQVHMKo/4uitcLUz4oVbmgKfpKnFQjyTHbiokChAGsZElZt+KeB61ZKV71 u8B3sAqqSxhmW2eLuRrNNEXSNUyTciKfF/2RWZdMt9/sdj9bJ5U0g5sVAtHInJLslbKPGVQjFwM5 HsqGsm4eug4majMQkUEigums9Oc+iUIk/g+Yj/bZaSRVYSJJRa+eJYiP2aqEt9zZKKmqZJhILlSm JYTexCTZ+cNwk0DVL9mIJHXSYgX4k3t4vqj7I3gKye9cqekUcKEcM728/aTBJBuJIkqjtpe5ZwFg L2a5dqnI5Q6Z5SqTicooAe1Agr+DKJR9pptJqpxWj+Y5lquoos/q/ssoTzIN162ysttblYau60JR RYKA89jHdwctMg6H+PaA3J/hYLKka5PobBnWJBL4sMaaPmQmO3dNd7O9uGui9OZaoVSJkoAsrrVg W4JQ6N0VdWaU2OMazcUuxflGH5JjVhJ1vQvQ2OPH0oz2kZpn5AatcXOxpHSYu1N0nWrek5Bw/7ft 1phLkaRRVyoqmspFIOi9PNz89Vg+DpYuDGD0jmpANEqpgTS70YNUdWtJS0/6Rc51GvEp1yCThRbW JmUDy5WoPBPVZ7jqblEdmsYW7FSiOp6ja2a7KgVNEXqBfuRPKBDbJJFbsW+HXwovwQCW2KcHzPmB Qi+SNUFBjxRFHNKPGBmuFNw4sqwZ6biLmhsW9U/JK9dRMzUcsAXyqbLdEFXUXTJriKCJiFJEdSO/ DpbDhu4HDaA9EAPIdBacCA2DXJkksAthFEuuq+gci2Qgfw5lzOQFciJhuPHU37K8wX/TmpUyn2mh ScJGR3Zi/26tdkZI6EFxo9cPsosL/HIdOWZmTvmyGt8QddRD/UpHOQhrkoR+6Bns9lRVBsE2G1u0 i4Wqa+pGSZySy6GK8hbCHU6xq/6tw6O4Gmv5bQoQxlKSG7wxeKG/d+Sh8U4rM1dfivT27d+c8Pc+ etY3N/mCNmJhzbl5/k32oM1qEtG/1r/xvmwO8pjdl5E/yEfkfZnU6ls+h1Dpr2iwLJACfbzqsUrh jUOZn3v5YZz+4FUqoAxdmpTVKkEmk0iTaKcd0QJkkZ8m7DmSFcT3CShK1eA0lf1i7Sy2lDIJF3zW J6HL6HxGBP3WDkILKaI3h6zXSKKK3tKy4h0uEsH3IuRZdo8jmpLKCvQ/+frPleVAf46awZGKS1JQ 3OESABDYFtJcmC7RgxbLF3A5LAK7d/T0BUVp8T9RiGyBMScCKldK7EBbJK662oBg77qY/p2hNp5j GeAE7GQH2xIjPTvpb37A+fY3PtRNSx5ufGifHc+9dGXMv7Eqe/wwkyguBebjJBFci8+KxMt/j9dA 4b9mqK+OuoDHZzKaeTBMmqKeUzBjVUQ1Fg5f6ix/lFq6JR6poqHQDg2BKEs6flp2uzxNsfOIXvmK CwQV2jrwhO8w2FiCznnsVCta5uMeC051uvG53xaoXjWgYjjCIUkFNiLKh3BE0ceRYgEnKhirs2rb KcENSy+MBgSILrPULDL5UTFCPf8YzVrtx4IUlLPRBp6hivZ+47h7i36fE4TOFosVytB0K0NEkqIy ah7aBNta7fFBFa4YQHouJVcKWX6W9Brsu+JwAN8chuCv4kVxR3+umK6SHOcZo7SooSarckPDTRih zhiV3gkTmViF0oWzAyWjDgx3CJAHP9MGYVJSCOpFy5xUwcbdONYPgFY2YehaviIpkijVvkGI2yow jegWMdtPW2BrPUvtgO2T0HW1uqDQJkTr2u6sn8Lxe0tbeTFkqdpOkbQl3SkqjD0+DtfoQYWXBPQJ ruO6iYYYehUgZDscSIUHDcGkIhPGVdjaCCyI3jZhs1ijVlmzmExRqddYD7Qu0EnzhYat4z50fG0V 3psNTPpprX7BmFnnDFix6UstN7/aDukz1xmk5yZQgNIdUSTaRE76ZQUorpUDPQ287sAf0NSJoFLn fh9USpCQtrSIk22Lw4lWgB0zx9f3j1/en78+3Z1JPD0KMqqnp69PX5nxPWCmEIXR18cfkE3FeNK8 QpBY6WYXwcOuamwdoFoU2ZXGQuNkqOGVSlExEV566q0s8bjlYisqVJlsUv1NdRed9EsmnFRNi/6l vXquGvpOwXloWLziOluVLNTXcrPfYg80FOPvN8F0oTz/6wV+3v0Kf7Ei6dPvf/3xB/hTLG7Jcr2s rZV8Kz9To9SZayG7eAnAFGJpgaaXSvldXSrte1m5GGLJ4lk9RDyJ9Y9jldgjoCwUwElhkWOl0A+2 j9aXQEcKJbAIGJzI38Yhs6c02jFB05a4qnVC26KBZF2VoVxLsDFDeVCYGiWIApS3MQGYY9lx+yIV r8fQaruCVAFuWSUPGKJyxOkgRw0ucMtkXSS4suUo773BsgWVglZ5XqGSw/HQH+PeHVSAEdIPgER5 sJQrlE3jkqvryTw+/83J1RoUjDxTctW9Anc9WYnJf+tlOUzrq+upb9AUEqKWxtdSiwrJfos2pOIc mqJs/rVgQZWnR1fmlGW7PT4/pBGuLJOpGLub1TUmri4x7q6KswhY447iHONGhN8ff395urs+Q1i5 /zRj8v7X3ccrrfjp7uPPiQrh5K8WfQXTnzFDGjRQEka3aktcDfDqieLy86eiJ+cRPRyY38FFNenn 7cHoKCGpzVhqBUnlBwDk55jKaX85qHSbYs7s+w1Ad38+vn1lARowNz5W6JjrYZB0NBMw9baiS5V3 Ra/kKuIY0mZZmkf4UctJCvp3naGabk5w3W73nlk1HaxP6Eu2qLaVhfJavQPpz7HVTMKFfeGPvz6s BnUsbKFylwKAHdAY+8CQeQ4G/2r4V46BUNpKBHEOJiyi7Elx7OWYKqJi7iAws8P9yyO9RbGgvqIQ WJZpjhIqBqIOnrFjRyMjlF2m+2T4zXW8zTrNw2+7baiSfGoe0F5kFy2KjYblbxHS5NiCBfICp+wh brQoRBOMcsVtEIS4O4NGhOs7FiLIIYWryRea/hTj/binYmWAX5wKze4mjedub9CkIpZ+tw2Ddcry dLI4QcwkVldEhYKtbEugiZmwT6LtxsUzuchE4ca9MWF8W9z4tir0PfzgVmj8GzT0/tn5wY3FUSX4 5bkQtJ3r4fYZM02dXXuLqn6mgfwKcOffaE68bNyYuKZM84IcRdCUGzX2zTW6RriEv1Cd65srivRV i/Ppy1fSAw/ndpd1Unlj35yTI4XcoKTSnuPf2DNDf7PfoHMZ9WhpBlHUgp5lnShOcP+pZbX0lG0D e3VUzFrOX+shSo9e0heJpFGdIGNUR2VzwBB+ikFTheOc4UkTdxgbOBMccu+Eljx0Fk2LQkF3zGrt 54IeOFXTI11mYmOkPmDMSFKk2RUSzmBvgzNVX6UJWrygnLRu1a/TUDm0K5rV+qvowAw/8C5SPiZr OsxARqUBPyPk+wnkAJDZyeWzrkVKf6Ctfj5m9fGMv83PRGmMH4TLvERVllgOsaUb5y6GwAI5vk+W tUcCx8Vs12cKYDG0YGEzbmgjLEaqNE3lia4TeuW6yFC1BMqrQh2CpMwe2ng7dKi10ITPSRFtY5M3 YlmOMRZXoOHE4xyXpB1dgOBk3kKEftmHQMaHYVuFW9mpTcZGKdmFqvOUit6FqPG2QbS31Q84NbYZ glcGXcF3lBF1V8qDpnKs1HdilGDs/ZsfcqZsTTEkRWerLT57ruPi/INB5+1vtAcq8qbOxiKpQ98N bY3KZIGDM3gK/UOY9NXBdTHtqErY96TV/TtNAuvoC7ymozApNjYXFpk0jfZO4NkqAg/7tsOUHjLV MapactRsuGWCLOsxfl4hOURlZNkuHAf+G0VUWkiGxNdMbmS0UCHc6MOhadLC0ocjvc/kLBQyrigL uvAGW+NkSx52W+x8VRo/15/tA3jqc8/1bm2lTHnNUDENjrhG8NJ4DR35dDYJrIuRsu2uG9oKU349 UEwAFGRFXHdj+2R6gOQRGauixd6/FUr2w1ZPUQ3bczn2aJ5dhbDOhsIyStVp53qWmyCrWVxTy7in /Zj3weBscTz7u4MgEiv4a2GZ1R4Csfl+MMDn2QbgnMTuBn2zUT5jOoGxJZD27PXcugiuVL5zrev/ Wu13FlZd6SeJWWi1hhRo8kN1Xbn+LvRXxqygArwNTxJ2lljmmqI9xxlWDmhOsVlDBmvInW2kumpE 4yErp0lRZnLyJBVH7JNEetfzrSc9lRbz222DSGmp/dzllFX2164lMoRbNPu2MkQt2QbOznIMf876 redZJvYzExqsg9scK8EiYB4aylFwTxTLfCEKFrLZHYdNfN7Y1JDeE8PakJQJczfKppHhFtcyhUTh 3wSGMV5UOjbORI6Pq8i16MeEWtAfHDpKvU1DIoaCVOOloJJp3+DunJNaddjt6GzyAbDrQRnZ3qeM RNsXxhhTdLjf72xYfhSM7bXj3UbUsVUUbla/OmqjGk3qxNGH1ovMaplCLqZcASrjSjRpBqm2O0sN bBytFSRtAm+m0scp6GtBwE59jPuaIEupL+kVCri1b+8LFqW5z3Bfhln7S2XhWlBau3sa+k97syMs n0mlJbXVaB4y9gy6QpFUroNx9xzbZYdzCQvSslDYweK5oX0wo6H16G5ts5P5BUK7tRRe6edEuz6z 5+nNQx2pJA+D3QYZwmt1a7EBCWtTr7Q7hU4AXefHELYKu6aPugeIGtPgOhtOy8UF/EBjuMCO2/oz TusB5x/G1UGN0qH0NzgbMS2PyMdzNnI8PEWe4tQW9YgTUTY/YjqHkv4VR2unW9pdPDj6+XJb22KM chv8NOUOo1RnFKJYEPRg6KpC92NiIDXSOUDUOOcMUsUaJJej/kwQnX1icC8V8Ux0ejmxn4B4OkR1 jhcwjFXgqGCjVxDMxkTH6S22+LW5g1dG6SVL6zcSwk2jYD/HInRk7yoOpP+vx3bjiKQPvWSH6gE4 QRt12vuVgCdFS7AoBBxdFjFF691QYkhwkPBkRogpqOKpqdQCXYJRR63aoHhrxx4CeQH+RIV+wlkb WFBgqvGQJshYkyAIEXi5QYBZdXadk4tg8oqLpbMxFLYwltA1yOs0f8X/8/Ht8QsYDxqh+PteOcsu mD7xXBfDnt45vZxoU5iv2YB094JA6QVzbMeS5VWB1AeQS2Ja6eTp7fnxxYy+wRUlYxZ15UMiHw0C EXpqfK4ZSDmVtstYLPspVDlOx6MNKrM/odxtEDjReIkoyPbaJdPn8IyAmTDJRBREGjl7n9LpKrL0 Ugm4KSGyIepwTN0xJyzy2wbDdnRaiiqbSdAPyga4WSyPtDJhxEw4xgvUduP70yu3UEfrSfGkUErH ey8MUXcgiahsiWW6q8LY7BQFCRaQ8Lg8ft/r91+gKIWwNcrsc5FwUqIqyuL7NptThQS//wUJDGSJ Kw8EhXotSkBphem1fiL4K6JAkyIvLAlOJookqQeLcfNE4W4LYlOSCCK68uKsSyOL87mgEmf/pz46 6OvKQnqLrMiH7WCxhRAkEHfvVjXCXLwlNyltQSkEumtxOUWgc1LSlXyrDUZV1JBP/RZpAh5xLNFO cSgSegDjPOE0lW2n7fw5WrlyWGtrsEr6bs7OqtdZ07XJUiTpVU9X3mRgQC8klKAeD5ZFXDefm8ri OAexXm01sjw2dO3X2Ml9vCRLkCYJpsThBcAgP68JgMybq8PAbAjP5hHF0hnB8NHO6hwZBYFVb91j /WQIVS4v2+kkwOhbzc5KREC1lyjaqqCsZZ2WitkhQFsIE8lNQhQpZMFRyd4WxJZRCftv9g2ge7NT 6pHnFBxBU/My3DXqk2MqWzHw7oE03+S5Ao6N/khTe6Vsap3K5tcziGWLo6xhlaFYwz1hQUUV9u68 4A9Zk2KdAD9QvEY+n+hYgVlagbtdkKZ+UJWe1VVL2jpR8hQaahLmNgl3/vZvPTUz5fdUCB1ePkZz MxRyskUxri+26MGQCGA1x9cFNhE2sq3qew6/WUQ2jDaqD8kxAyMEmF5lSyb0vxbvG53rxJq2iN4g 5YMt9qTJpstfzBdad4akoO3ZMiwSEWRr4lnbDM4G9LKm+aqnPL/wjKheQpnoLjvgsSYAzcQoCFov 7SQK1hPMMNiRkiomrRTIPV65T+ZfLx/PP16e/qYjAF1kmTUQhguKRV3MRTVaaVlm9cFydPAWbN6t C1pzvJ0QZZ9sfAe3Q5xo2iTaBxvsbVSl+BtroC1qOPdXCnN3XqVgmv1c0aockrZMZQFydYzVVkRC QD0zsURBKn6XzYsqevnj9e35489v78q6omzaoYmLXv8OALcJenTP2EjuvdbG3O4sFkP+t2XFiJSh d7SfFP7n6/vHaipe3mjhBn6grlEG3PoIcPCNb6rSHZqoRiAhXJpWUQU2n55eURGisTgZimjvIgxW 4SwgINuiGDBNFOBq9uLkqX0SwJFs9qE2GDwuC90yZ70LpCBBsEd95Th26ztqXRS23w4qjN9sKqBl nn9sOuFcwqeOJFUhL8b3f79/PH27+x1SAoqERv/5ja6Bl3/fPX37/ekrOFn+Kqh+obIeZDr6L7XK BDzn1SuM7z9SHGoWfliVxjSkEsMQJyElfs3qNclqAA0XRw+UlS1KvZXs4Dn2JZFV2QVTcgHO/GJ2 1HInNJ5hXlaRAsEpq6aTRoI2dvtjtiyTaD07DSMa0PcHiulO/qCvp0oJ0AiwOcYE9yj6m96v36kQ Q1G/8nPhUTjWoosKyX4B4D4CA9+LqTRoPv7kJ6uoXFp92tLiJsJjDwEolLkTHJYWBFAqmpNCPxTR A1DbnXgSeYaCRaiNJIAWh0Nt+UKAcmvsr4UETvAbJNY43BKLIpXzsQdl7bmee0xqnqcSbk6gKMMY V8o1kvR8qR7fYUUky2WBZPaCclz/gAvTgB4K9i+PMGXpzxINRCkLbyJUCNFzbEoUSMomZQimE8IY nKvVgVWgIYyIFZ9bRDGWYGiAcGLZoDm/KDQWXgxQZbVzxrJs1cnhio7YBCIT30DqbjTsDMtRNESe bBSxwMzMRlMoAhVKEjekF5njaWCmQdPW1CA/4AKkp/xMWeQ5KJtUzCCibynfwk8uy6d8fqjvq3Y8 3PNBWJauxOBhykro2NlMVgJFp8Q6YvnL2viWrWNNdcBmrGlacIoc9URIClVfZltvsOjfoG79FpSw FtXOkWDmmK2aVpX+NI8CzhW25O7LyzPPdmAOExSkUwXZu09M+kP7IFGx141bROIyuUWmb5C5w39A ouXHj9c3k8ntW/o5r1/+acp1FDW6QRiOTCr9TfWs5XFj7sBJsM76a9OxiB1M4CV9VEFaUdnF9vHr V5bYl96frLX3/2trR13iGu6k+ltq2CLtQ6+1+FqZtBYHGY3wUl3Re8YcuLnPXLySXuVEim6BGA9d c24lVR6FcynSpAdhLD/TYupzFNRE/8Kb4AhJpwHXJSLzLV8s+hURf+fh+uWZBKxEcPeMmcSSnWHC M2sIjIGcCKqk9XzihOrnAobQVaU+U8yYwQ0c7MSbCfoqH7CSzDxkpWCTZGXTYyUn9nn1a5Nj1nUP lyLD36kmsvKBXoCQfGelJ1pc3LkbXTMoNhBz01FdN3UZnTIEl6VRR7nnk4mirMEl6zRbsnnpsoDI UOdaR+mQ8VbN78yuBYnPHcZizVN1rruCZGw4sDr64gDZ6E74uT+31CTHOjpEmDnPvNJAyRUho0M2 u9INLIjQhlDdySdUdn+m13Hc4VG34chWWBQBYNkK26g/inSGgTvnRW5yTc7iyYuVNHZTLUV3r7Ii /DRAypMHIgfBYDBxqmhQ5qzqLMo3nk7y2+OPH1QuZlcQEgiAldxthsHOIvLPMPhiBVulrbImuCbP ZGdVgvQatXhgdIaGF3Fbi3kP/ziuY7Q6H7mIHKrQdchoH8trqoEKVTXDYCwk7AVnD/hcxOGW7LCD j09qVEVB6tG12MRno3bz9VbFyhGjpzWSyCcNN+EcwiDQYHp4xmnyxlx85KRUtK8dzp3Qe/UXgQXD FW11ybW7zmaE6H+bMNPaBUwBKHeLY2gZY2zynYsbDfA5ZWNfGaWKPtzZJ4tYUjRMSB+PWsrQ16KO m1pfM1fibhPR+4kvWRuyWcXFoE9//6D8mzmUIp6B8XUCDofKygZOa/y5nw8clSBL7OVKOlkc7Lzx 9NUkoOq7KrfBAqW5PxjdF3C9+yoJGKDqTfVtkXihOAIkNYM2iPw0zFNzcNV+xOnOCTw8+oAg2Ac7 t7pi8Sv4eTb5rRnAwPjqT1H9eex7TNvP8LP+TTl32nAXbPVdrV+X8zyAmbvRcJcEfRDizDhf8bqP vjLms8GHUTF3kggxVfmC91xz/TJEuLXuMYbfu/r6E2DPrM90+pfRwvfIKHY9FuSUgaGb/fA1nYom 8H6vBS2YjlJz4YlXjOLWghSPC7a+xH04GLuPcnlyVm6xe8wbDBJLisPXvhIgKy6n8rDHBr6c0sT3 kCEhDUQMLXXDoOk0NL9+1lqsnoGUVXG3G6M1Zoi1tx/T/ARz9dFKfD8M9XXVFqQhndHE0EV02WBe Orwuyu2Lp+jJuMb8Fq1EcjpLLOBVDivmjvxGZ6Pi/vKvZ6EKNjQ5lJLrP1lglEaNMDbjUuJtQlyE lIncKy57LzQWXd9CQA6KLhvpuvxJ5OXxf57Ur+GKasjsUinjweFEMcmYwfB9TqB9u4QK8T4vFK5v L4ydaAqFZy0cWpy0leLoUaVSuJZv9u3d9v0xQeMQqFQhXnMghwmQETt5v6gI1zoKmYOdHyqJu0PW jVgfs1gHRj5jdFF0giwlQdJaNHqsRJcRNLACx5Jz25aSd4gMNdNjKFiWwwFvGKIqAyn24dy1BNSs ygHAwa1I3iEZoJDeWlccwavCgxzcYS4I9hkQJhsYRAd19p5Kw/xtpYmV4aEN7lrgngknsSTDTt1S gFVURwZwKh7fezsl54aG0G1ddPQxxVhLnSrtxzOdNjrcIoCc/nEaeyfBXZXRmjDgiL5zNrieXCPC T2eFyEMvuGk411YAc1d0cKZvogHm0sPFpInEGhBsaYfN4no7vb8NsMUoddbdBLuduWLSrGdP1Zxk G2wt38o43/UWmHOn2QJdCxs3GCwIOduNjPACpLOA2MmWJxIiCPcO1ndSxf4Gi6gwEXAmG+uHYK93 2Do8ROdDBrZP3h61a5rphNGuuca7PnDUy2Zqt+v3mwDT1E4E7GH8TOI2NTt9TojryG9v8xhxYWxB aNly2M/xovoAcKB4zT4iIbrrxw8qcGPOKSLte7rzXcmjR4JvrHBFoFkwFYSrwd76FIoAqxQQWxti b0H4rq0f7g7f1RLN3tvgrmETRb8bXAdruacjZkFs7AjXgth6FsTOVtUOG0Hi7xx0NEiy21pC8c00 QzHmUQ38N+WnMfl8ojyFfVa1SPMsWmSVYB2LlawtCxy8bhB4P7TotKZk661NGGXl6XeaFaaQo4Bo L9MTjrvRRilqkiETIUNeBCcqr8YmAhR2TpBjDTJdnpfj1uQLUeDvAszpdKKYnO2jFBnxnCTHChnZ Qxm4IalQhOegCMogRdhnUITN+UMQcFsrzOB2IjkWx63ro2u2iKvIYk8tkbSWVJLL/ARWVyZOAeY/ sJ5XeglqVHNgPiUbZNdSfrVzPQ9Z7GVRZ9EhQxDT0xA2DPzywqUplWanh6mw0uERXRWqPfYBfUJ5 BGR3AcJzA0v3N57lEVeh2WBXqUKxtXTJ2yJdYqGQXPQMAdTW2a4PKSNysQAHCsU2xJveI+uF6Wp2 nmfpE8VZAnZKRNvt6t3KKHzkpmQIbLkyRICMLEPsd/bO7tfO4SppfQc7iKty6LIDnAomrk+2wQZt MKtzz42rZEXuXC7HBA0uP6+YauujC7XarX0QRfvI8qt2+KqvbrAelABXuC8E4Xp3QrQ7oaU7IcZb L2h0t1d7ZL1QKNrwPvB8dO4YarPOenCatQOA++UgvQTExkN2W90nXJlWEMXGd8YnPd29yLcAYodx VxSxCx10+wJqj+p6ZoqWpcLCPiAPg71yULWVYUyqF7pWNy5Wcuxd5Bso2EMPRYrw/15tk1Ika2eP MJpHeK8qo0cbepJklIfBdcsShec6yDRRxPbqOfjHVCTZ7KrV3goSbI1zXOxjhzjpe7ILLK1W2xu3 Cj2cXC9MQxfTyy5EZBd6yMXCEDtc3KGjEa5eDUUdeQ5yMwAcW5cU7nvYCd4nO3Sj98cqQZUPM0HV uvj2YZi1VcAIkBGh8A2+BABzQ+ChJIG71uqliMBDTQg7RnmK3oZbzDZkpuhdDxP5Ln3o4WLrNfR3 O39dMgCa0MUerWWKvYtw/wzhpbaW92ujwQjQ64Vj4ECyuHFJhOUuDHpiqYUitzVq7b7QbL3dMUe/ jGKyIypwcQWzoRXRPHDMTQWeg4b+2STrT44l0izcP5HiEyFA9ByJ+oJYwgpNRFmVdYeshkAkwssX BNnoYazIb45Zp8EcafhGGrcJdu0KFn4ZUkuqJscTxZSz6dBcIEldC2HO0JCQCH0eFR29OCItGi1C CSFpeIDvlaqNKhH83EUcDQ4Ko5qzVEYv3VBUfu15olqdLQh5VsjaugkFNmYL9L7pintpcQgwN0SV 4CIbyMfTC9gsv33DwsvwtI6kSca0p4d2Q3Ldk0sh0CpnO4BS+BtnWG0DCMwesw0yfWOnZa5jhbbY uM2PXavNK1XRT4ghH2VVJCszwQkhAIa88+aoQthASg93wr8eO35ITHcgIUWsBSUhmCNSnFSRTC6B 1V8sCRuzSMAqVyjwN5KZgjSY7orhuXe5np5eRh2qKBmTCherFELbKwgnQt0TmBfHP/76/gWs7c0k taKCKk+nZTtXymCUpfRxlgrQUdKH+02AZuYCNPF38vU7wVQRnK0pZkrm4eI3Kxb1XrhzbEG8GQmL 9gk+Q4kcW2FBHctE1tQBArLY7h2Z/WLQyd5Kq4VFRMRgajg5NnDCKU/xUgfEbDOlfB6HWvVHEgmu OuJzNRkpa1NIwT4m283YEC+EKhgWrDmJcID6qNH9hJVfMaEmofpVYu9JcGNYdS3wBNt6+hfwGIuW D5gfTuXxTVx/UBPlSeCVcZ8ojM4eiy1lgdnHy7VSMW5sI1IkWO8ASSvSPGChNn623p+j7jQ70iIV lG0iLIclgO7lPV9Jer4XlABO/mtir2BMjhSPLlyTME1GNPz98olq5C0VPlm1IyPD0LaTmpHdk62H rU5AMqvIpGqU1ImA0M0hAcYjGTsYMECAW/3QkN6ZtS0Or8Po+8qCVh/8Fzhq/7ig9z5aLNzY9gh/ ucf6GO4923EiohOjhfaYzM2w/VYR9Rls0jjKVWWfWQQM7KWAHUuA05vush4PcQLINskDekpgQyCM NTVmjtU4Gx7KwOmZWoZxg1cNeAqd0OhkHfRbS/4xwJMsWbv5SLHZbfUY7QxRBY6LgDR/DwY/PYR0 URrnKOhikGajeAiW0ZlLRDFErlvtq4iazq0u++r5y9vr08vTl4+31+/PX97vuBFwMeUZNPPvMQLd 7oYDDV/hySDy55tRuqp5NwBMSTIQqfmaAF+2/t66pcDQJTQmvwdv5ZU1GpVVhAqpLdm6TqBmGmBW Gi7OR03B5C29m8yotQ827D5mqGbzMcHDjSWf4PSxdBRQLkHCK7bmUoMhAg23AwJVzLYlqIdD9QWl 4Ox3PyWhF4FsJTmFuzY344SJzqka2I4its7G3DVKZyCN785fpykrP0APMz6ymAE9wyR+EO4tuVMB f18N1ttF8/Zh3cCeUxmz3BWfm3qdzZ1obH7/bCyqEM/hIZC+fjoLA0eDQxNwYvIUgAkcS94BQbDf b7SznSVVSHduqEsUE0aYFqmH/1zK4gPCj01goDD9sjhUczmLtYiHPZ/Ocsgmmyw4F54ix8v9XMLJ 2+JhLBR5MUAg16bslcf2hQACy515LElyruQAGgsN6IGYGmiVirJXB2X7KyiVR9NQW2eH4UCiDeXD R0Klgb8PUYxYs2XauGt4OoNgvouSaKKyilEFZgnHpE900SxEk4y7OmnI2lSQesZwlMrupbRQGUya tLSY0Lda2vRpUnEWgxiFyLNcjxoRttekRR7VgR/YumKRzaSkDEw0xAtz3CVArfMXsoKUe99BVypF bb2dG2E49HCW0JR/2a1/OiOxLEhmyntrobALHpMgNJKtZXQ5G7Vent9plvIUud3h7kcL1SSkrbYD REG4xdtZsQdWiMLtZo9NFUNt0SNsEc5wVGCZH4bc4ebYGtUeN6DQPw99spKIhHJES8Gg4JXcVSoq lJ+HZVTr0oG1fWQb2DI+y0RhaEmwrBJtby3nqr3f7S2qS4mKCrk3zhQg8fCh0CTkBdPm58+ZqzoV SthLGDrb9QXIaEJ0lTHUHkddK7zJNS9PiQqk4Fs0TKS+QTSJraufSMpD4Dq2QSK0Bgd9RlZoQm+D MhpUBAjcrY+uU0lEQ3Gej29vLnTha0FKCYZ8zIovrE6ETyzDub5la01y3+3qNX9bHWvJXaOR3d58 k6z3c2Try8QU5iQcF95QdlYE90GaNd+9MRJFjkiEqkeF1E1f5IXCBAuyb1K7yYjHHy6LLlFKihxc apKsbqyzGYVrc9n2vk2yvUXy6XKzIYgjfZMmqh8ajEgiOUZdO+cc+6YUr6h0cYrTW60MVbveRsGd P7AmuqSqVgqzqbgUSabMBIUuachsvcpqK+pYDMExteQv491dw0FMbBueDtmZ4JFToHRPxbXCMko8 tQkdH2m9nS8NxBXSxixLu6jHD36YUYtiAFB9l0XVZ3QPULQImQFd1JosDk3XlufD2rcdzlGNx2ek 2L6nRdEvp5M5RbbTGuWhagrruuMhBbDTo2D3L8UpoykyApsgyE9Qk6rolWCVgFYHgnZ1iJthTC+Y bVOVQbBekF95FNPldfnb09fnx7svr29PZsw4XiqJKvZ2ORdedBsMT0e2bA5jf5lIcD0Io4XEEz18 1M8QdxEEEbhNR9LuJ6jgJEaoVJqGee8oKQ4uRZo1o5EuAYCXTenROmNI2xChasaFTq+QlVV0Whwe pRfTe5ijuG6mKmrgr6L6YAmpy4nBMIKcsjLrUasm1nyVVR79T33nZpj8WvOMAyIoFKwRxNaLjxpr amX8aY1zXCVhDYGpxIFs7hGn0gdn6TBLzVAqqRk4CTmOl+ysfA53hV6q1GexoP/a566gTRqTV8Cl kMwvIXzjPH29q6rkV0JX7RRNWHr6YCXjc+5pHMICR5YJg9Mvblp9LBgmrfiaLQ5ofVVUlk2izuLj 9y/PLy+Pb/9eomF//PWd/vvf9Nu/v7/CH8/eF/rrx/N/3/3j7fX7x9P3r+//ZU47LPzuwgLDE7rO EsvkswGDM1jVxs7Bi7LvX16/sva/Pk1/iZ6wgJSvLJTyn08vP+g/EJz7fYp2Gf319flVKvXj7fXL 0/tc8Nvz3+YE0JNnUuGr4DTabVTGeUbsQ4svtqDIou3GDTBds0Qg+zSJxUxaf+MY4IT4vvrIOMED H7XyX9Cl70XGh5UX33OiIvH82Kz0nEaub3Ei5xSUxd3tcCOihcDHZXGxWVpvR6oWuwvFlgVuMe5z KozPcei6lMwzq08hiaItj2jFSC/PX59ercT0PN25so6Cg+M+dPcIUHUOn8FbXCPB8Sfi4AntxTyX 4fay2253xlEVRTvXNRYABw/GRF7aQMuyLCFQRdWM3yne0gJ89UI58/cE3e8dH2kE4JhguqDNL7m0 g8+d+aSJgq35qOxcZH537s4YgGTwAroT1dqevs91aD1mtaxMC8PL0R+l9bIzPoWDA3NgAOFvcIZX otivUpzCEJU0xeAeSeg584cnj9+e3h7FGWmmcuRlmou33RhfAdDAWPYADVFac3iai+rwNkGD7R4Z nOay26FWOzMa7eRua04AVIXR7pEaLmS79YylXfX7Ssm6MYN710VOfoq4OC7uBbFQ4KG2xBLrHN9p E9/oYPcp2NTuNKElnUnTqnNaPEG47KD85fH9T2nKjZUGmlVMp8vx8MS8NTpDodvNVt1Wz9/oZfo/ T9+evn/Md65+dbQpHXrfxXRvMgU7e5f7+lfewJdX2gK9rOEtc2rAOOR3gXecE8tQLv+OcSoqE1A9 v395ogzN96dXSO6isgn6Ntr5jnETVIG3U8NqCJZFf+eWYgX+L3iWOVCZ1kUl8JdZgjNtgIsWjlKK uGlg+UT99f7x+u35/ekuvcR3+cTETWPWv76+vENAb7qSnl5ef9x9f/rXwurJDdgqYjSHt8cff4I9 jiE4RgfpnZT+gCw5GqBXXu0ZyBJqGnDMShCzZKI4nolGrZ4URK+eQFhzTO4A5EWvIMvzIslkA6LL IYJ0UwYAnlIgDQ75zd3KKHIteogX3ciJz+ToZPQHFeYg00JcYFCiQVM6ROfBTJ/FcCx6SVVhUMqc 5yABLcoFwJ0qIlI7qWUAnscLah7DpULakYoKVH3TNlTwfxi7LMfGFQrkTDZGfDsWZEOlMi6nuI5j osssYsHoyRTETekQZDYbqTSSUuG4qyDLBbqExPAlGcakA7LvtaGjACZdtdEhG9umKVU0pKRDhw/K YfADlVqZw4FlyG04KEeOIPNi2MucrgROJcEL3b0a4pJUhGdgowzhVq2K580peZhEDQ7pPEAO2oeD PgEKOnCsJ6atb/xi6CqTj2Ej01BRU0n9JZOqPekiemrjulFA09PlYMmXB+i6OV+yyI4v9i4me7FJ OGTa4rnQGdUn6nqQjXwWGF3mib4xDlUUyIKhgG3VRzAB9beWEB3sqwmm7GJnzCE6eHojSdF1ZzLe 0w2rIrok6iAjzDGtCgRTXlKid+1+wGPpAy5ukqPtyBCZSHliMQneRjxBElsx6fP7j5fHf9+19N5/ 0RYNI6QnM60q6wg9d1SjuYUkbrLxWMB7OeUA8LtHJe4vruNez3S1lJgotBBj48ExpKhaS9rjhSgr izQaT6kf9K7lEXUhzrNiKOrxRLs2FpUXRw72UKbQP4AbX/7g7BxvkxbeNvKdFO9uAUmoT/Sfve+t VztTFnsqzCTI3NFLvG5KyFjo7Pafkwgj+ZQWY9nTjlWZEzj68uQ0p6I+pAVpwZXzlDr7Xeps8N7T uyOFTpX9iVZ2TN3Qw2KSSLMTVeRcQ5L6vbNBGy8pMnb84F4WqFX0YRPI0S4WJLzQ1SUVusNjqQZX kWiaSwRdrns/CCwvoyj13nHX12RTFlU2jGWSwp/1mS6aBu9DAwkb+iw5jk0PZnh7jMWXyEkK/9H1 11MBfTcGfk+wz6f/H5EG0gFfLoPr5I6/qfEZ7iLSxpBpgyVLOtOzIumyrMZJH9KC7siu2u7cvWVQ JSIQpG8MKmR8Yl//6egEO9rFPWquKheoYyrTxXTZpj76QdO6ItvU3abGKa4TZf4xWt9tEu3W/+QM DrrgFKrqdrNhGDn0oiSbwMtyB5d88YJRdGtUSVacmnHjXy+5i3voS7Ts3be8p0uqc8mAJsA0qInj 7y679OpYFsFMtvF7t8xuVVr0dFqLYST9bie7YVhIwv3F0iwoN6Nk2Hib6IS9bZqkwTaITgary2n6 FlTSjhf2dImuf4Ig3fhVn0WWQWE07cG9edL03bl84KfSfjde74cD/py6lKDnS5vR5TG0rRMEibfz UOZQu8nlz4i7IpWNkKXLeMIozMDiEBK/PX/9Q2cmk7QmQqpSBQNxl/x/yq6k120cCf+VYA6DnsMA lmTZ8gA50FpstrVFlLdchHTjJR1MOmkkr4Hufz9VpBYuRb83hyyur7gVtyLFqgJSLf2EehuG2/og v/x4War8wNCJJPo6ydobvp6DA8Q+iVeXaCjoT/NS/wQduu3raE0++FItRw13aEWyMV8UW6DnWwVy gX4Pf3iy8Tx4Uzx8t/K8Ap3wMFo/wFHBGXvIy9UfeY3uutNNBEINVqE/w74RR75nytBhu6HcBBFs W1tCFk69QJVssOMU7TpwFksARL2JYfwk9LeAKXWbBaFYBfQnE6mTy+/lsG6w+rahP+nYbFvDJsFA s/atc17DG+c4CLyAa8ViM/hPysshwJxEijyw417l/jg5FCYG60OcDqd5qp/6/DPcrEXe1+zCqTfs UmZd2h7Ods2rmygoRwQYPxLx4y2J4q2hH08QKrshaU6pc0TrwJd4Tb71mzgqDut89K6nUnd5y1rP s6eJB/al+GEBuHFFsXWncLMVLSAMBex0fV47p4TLvrnJ61KPyEtcDu9mfn1WONcIXRD6ZiQcVG1u wemXD+r46NNWBbswezvJb/hqYSjwkWAuaL0V1OG87uX91fDuzLuTxYWRuTpWZ818GVN8//D705tf /vz4EUPG2hcbxX5Iqwz9WS75AE2+ErzrJL3Z0/WWvOwiGggZZLp/BCwE/hS8LDvY1Bwgbdo7ZMcc AM7Dh3xfcjOJuAs6LwTIvBDQ81paskdx5/xQDzCgOOmHbSrRePaATcwLOBbk2aCvG/K2Mj3vrfIv B2aEYgMavuMq+eFoNqGCDX28XTNLw5sDrD1MlwPZtb9N4ZadjzcoTHmXYrW8rSi9HrnvcOAJjROv TnU6l3XWb9jbQZa2pHklevpdBoAgIfLMCND5kgtm5YUkX1Z5Qb1+wlFteG3GrjqY/dSAkijDg5u9 F2STQwctL+uifybZ9p8L4DN4Wzj0MaFn0PELtZCgTNV3SJ25zBM4KtJv4nGEyRgrdG7q2tJolCIR jRqBucqPcnQfkeEo6e/0Qqswl3vwvOoZ0YOnUYj5BCuo75NIt5bnmUQIYgRYmub0JSPyeDYJHMnc O5DrvIFFi1PaD6Cne9dYVYlgN/OW0zRZ09DnaIR70MQ90uhBf87r3przJ+N3W0XmasG6yt5VRhps VAx2u4vpTs0A07PoG9pjNORzyGGV9HSc6acAZ8i+gqHRr2NrOXMDBcjOkAalC03qG/Lbj6Z1aJMp x2N3U+VWR2DwxJA0lMRV5w6r+8UcXPKgYg8sAevOijaekk3dBvQxltzy5Y6x//Drf798/vTb85t/ vinTbLLcdb6Z4sVcWjIhxlfles0QK9fFCs5JYe8JyCF5KgEa46EgY+BKhv4Sxat3miSQqvTYm0uM 9FdrSOyzJlxXJu1yOITrKGRru8YPYmkizCoRbXbFQf8SNTYCBtSp0O+0kK4UcZPW9FUEGrjuGmxa drzCXDjGoJ+kOBeu1hPeauHw2r4uLNK7P10LGYnoWuaUWrdwCXZkHdlO22ZeKzRDE7iVFzLDHSzg 5PjmYYXw2Ui0ImskoR2dd9kmcUyvmAaTZSRK9Qvq3GR0WU1qi2MUB9PcYLjisSy6tTHTmidnrdKX OFxtS+qOb2HaZ5tgtaUzAJ3ultYeT3Iz1+gf4CUJ5hm5Tr2wGk0VBtUQfWzaz5RpVdm+DyibQ0MW 7jwYmXIQzVlf5eXPoRHCeipt0ocWTiMl43rUBSOXWvrN0L+ZI6lNK4cw5GXmEnme7uLEpGcVy+sD bppOPsdrlrcmSeTvlgVIo3fsWoH2aRJhGYAWQeOaosB3DSb6M9qgOJSB1+25Nx/wCyUjfHRhEit+ yzuE3KYq4tyDGnlA0xpeezxqj3xSzMS4l2LpiE7I7jVDn2LSmMGqD76nAc0kE2+j0CxqNDIYQI3w 2FvICnVNOhRWppe82zcil6Af43V/suXgO0LIlCp8oTNEBnHYnwtnLJwxsHVHDJFzVd093G5/YYpR qJMTWJcBhxfoe4YKqWMmlaW77TCZNJitd801rN43ukFqPMfs3/Kpn+b2CcdBxqz5kjFqziAZJrYk uIga7/ucSrVg8kz/NjCriiwtuimVr4b84zVjShRQC4xf7gyIhUFdwr6Yj+AHOAHmpVtjhRuPz0zI XlpNVF0xvFg+EPMbs0eChrNVYF54u3jkCUJiMkrDkFfII1rFa7c2ToD6uddU8EQZ9HEc8KtlV5mH m1tal7uZZaIdB4CL5bfek6rFwVA2WPn3+dvNWseVC8P6aM9DRc+kL59xNJvLmXcJK3iXX7ldj4k6 GPdacpY6O0xzK65WbYR58zXn2KgbTaNq+3zfUJfiRjXQmG9lRg408J6JlFHav8FVNf3ZrVXB7BaJ JnUIauHan+0VEpBxMD3asJFt2nRdZHreSBXacoJa4TpqKwAjkL6HQ8I2DHbVbYenGNjkdDefFmvX x5t1/IAHyon+cobTCHYXmUESygw84ldOdZVMnVwqfuoauVf2tMtiOUTSahNJz6lCBsHuS5+nd7mJ wuir5QU28Ds7hviWjtZcH799h7P009OPXz98eXqTtuf50XL67fffv33VWL/9gZ6wfhBJ/mPuPELq AyUo9R0xhBARzFllJ6h651tg52zPsEjfPBkLYqRIoM144Sszh/q8UCgoTwUv3bx5dZMVOqtpOb0t fyRfY5EIMarYJgzQexoxKXh1IIkyIa/9WHO2FZERxC/XZYmfWc49JQ/kkcKC7B/IZGHzlwRjFL/N N3Jh7mr0oc+IATG6vVUvnEvQoWwxA8JbO6Eijp7CCYBeNJayXsAfJZ2+Dfl4jkxc85JoBeubCrq7 4OF8V/MqJrqVFOPDVp3uJTt5ay1O1PCWEGu90GnvhQ7lyQeltTdVWvihCmRLjtkZJm8DSDEMBRyI SmK3MbkEahP+hkxsoLLgx/VZp3/IDHugESVV3+dG1gr1Zl8+4z7lEYMMClHgN9SsvIPmVR8GOPt5 bNfJgevsYx72fXaVO1+8erTzufzb7QtN2HegL/5fNbn3aae28dfWZU4RB56NfxxVeIkkxoqHr2b1 qhMmK5y9d+g1Cl+yvIa/Zmf0rfSQF5om+dNbuNqGt1fxSmUpehVrLpIo2LyKtW7UAeQRLyw7ILAw 2bwwJpBPtr4MY5iV1Rq647XDw0grRQ4qIXvdQFFqpJaKPDVpbb/1bhrfjH+Q5KF8IQHIbJe8IDNY nOVg3EQq413oiuylhPBPHKzN9A82g/+vIXaC1xQg67V6cUxNR8/pXELzV/1p2PfpRWSUFEVTzDqJ q0OTfrLh3I7hTZTB9fLN6QXv2mQqu643XvL6RuuJI6Y2IdQE2Oi/xmnTyCl1twfj4NYX7YGZhb2/ DX1GnOnkQzZ1vn472UzLR5tuBG/9GOnZKxlspcO55yXRTMQC43mwidy8yOYBYrqFcVBBnj4BHa38 3UMhYkGQDEf6/anDRztOntlO62C1JqoA9CAh6Wv7Gn2kx/Y10EjfBBFNN4KwzvQ40h2fa/SYLLdM 401IFLDPwoQG+kGkjUuf3OHa5DF8jGdApSKKy4hoiAKI8hVAiEoBsQ8ghJKKdVhSUpRATIzKEaAH pQK92fkqsCUbuQ43ZFPWoRHHXad76rt9UN2tZwYhdrsR42UEvDlGQURXTz38pOg7io7+W6iMlNrk AkpH8tCJErKK0hLUc1t6pOZiG1DDDugh1TalitH0kJCsotOCHTGyqw59taEWXdhj5ytzGmIuglZp Q3eKVtR0mR0uwwJA7NZSW06Ilk16tAdBRcQDxdTSKhHdgYwB7EIfElETTWXm3PdLSFTJDpTpa5pN rtoebARtWgWbhOgHBLYJMQRHgO5xCe6IgT4CD1PRAwVBw8W8BfizRNCXZbTaEB07At4sJejNEgRJ jIgJ8WcqUV+ucRD+5QW8eUqQzBJmCTmPu3ITRsQ4AHq0pka6PGCR5F1CjcuuhzUWFoPs+mA4qpMB las8MdAtAuWdWrGQTrZIHqVpOrV5qsOBh07MTXmq9/BviVk+Xl9YMTB0NAltsRFsoDm+hisIXsUV v9BR4tCXpnHvjOCXUjgl+RF61M5ol8N/yOTSKonB35Yr3oWjK4aHl2bTlb1NFlVouPLXgc2K0I1G gB6RE0i3U90zEEDPIkpHQHpMCRrNmRj11YuJMI7JY4SEPDEadJ7tljJh0zjMOEU6sA2INkggJBoB ABwIiBkvnflRKlBfsF2ypYDFS95DkO4WnYHs1JkhCm5UC2c4vFHN0eEXaiBZXqiD88VWg7P0Fqwf 9p+IWBhuiWv7XihN2YNQRz3pfpDSMK9VEgdElyOd6iJJ9+ST0PkY7/t0OrXDSSeHHv6ImI9IpzRk pFPzUdLpdm2p/UDSiUmE9IRYcoCeUIqlotNjasTIwYSOz1d0fXeecnbUPijpdH13W08+W7p/dmYg 1BkRzONcb+J4L++pdps2JCqCyvI2JlYMjOpA7fiSTioxgGxI696JAa+E4zUhJXlXTE0Hdf1OVHu8 lyemYss2oEsxtcJPXr6M2zEjido38TkeeQe2wHaL1VZ66Fh7lLh326Cjk0nENDwcEe3Jh3ptxjP3 MT0Q9QrBz2EvryDv0s94feipS2dg65j2bOasstEyWS7b1Z3rH0+/fv7wRdbBuVxEfrZGTxJmHizt zjeCNBSFXWf5apyUnEQF+fhLQmd8r+SIIC9P5Fd0BNFXWXc365UeOfy62/mkzRmOxN56VSxlZXn3 4m3XZPyU332VV8/InELv8qGOJw103KGpOxW5XjMInaggXE/KHB2eFWa70Z2xHoZa0t5Dle1KHfJq zzvq5b5Ei65yUpRNxxtvx0EZ0uOJWfbpnpuEKyv7prXzvvD8Kj2s+Opz7yw3bEjlKcus7Hmf23n/ zPbkW3vE+iuvj6y2k5zyWnCYaqQDcmQoU/myzyy7zDObUDeXxqI1Bz7OLKPIiY4/WvqN/MxCjghE u3O1L/OWZaE1JRE87NYrK6mBX495Xgr/cJPWZRUMAEvkFfRoZ3dNxe5FyYQ1GmSMhYPDy/HeuSl6 WyYVrqBdfvdV6Fz2fBpzRsKajPWMSNNZ72LltGZ1D2sIjG/ffGjznpX3+uakhFUGjRG8C0bJaulr JfVNm7ZDP16mQATjqpYGTfqssYhtnqM9ts3b58yZvkCE7oU9IPdVBfJvS/1Fouwy/U5STkV0aMSE uczNRP/wUYZsAzGARMW6/ufmPha+7LEa3Z9vzy+N3VZYYUROmiVJ9Ahz21oj+2N3Fv38KH7xSKDR /XU44+47tCKy1jrOMZaKSbzxurLWhPd519iNn2j+Qt/fM9h97ckkYOnCaH7nvTMAFKKsJcdfvk24 bIWuZlHawuy80VRj5iLxW+aR07Y8TrL5RbRGnHUZsR+aY8oHNGgHnU3Z3mu6DuBEiA8kw4qM9qi0 1yZkOJctR5XMywD/rX1xFRFnHS7ZTAzHNLNK96RQL9CkpJAJm6ppYDO9/e3vH59/BZmXH/5++k6F sKibVmZ4S3PTcYjRABnO5eI0cZT3g5KsbFh2yGmL6h4mNm2JiAm7BrpMeZQlBFJV2vGtvXZo5JFT xNnmdUk47MtGtyyaSZNtTqItJajSn5kvzAqkRCcazssEFRRDxcU4fvvx/Cb99vX5+7cvX9BUlggq UqWu0Y2BiuyYkkGdAbvuRWa2hpVp05mknhcwd42hhuTJPtlfMB1LGpB0vzViVlfSrAPKMLoByWeo Pd9Ah67s4kd7E9umRi/l3THldrKjeOdhn3wetW6iqj/RrQR1uOfpicixzq+4FGg7G/5SZrYUbbBU F4nsO7RCqNHM7XhFX8b1Qep7yhF6ThyjZLLJItXKjbE+CPWvbIpaR6sw3jGbLKLNOrap8hm7GTt3 oceUrwTVQvPTv6J1q1WwDoK1k1leBnG4ilYe34OSR8b/pq4HFjR0Mpa+2ynL4xndhbbQkLoKbKod v1IS67xfG66nJPXamUGAJRHksYsjb1Vss1lVkzbarSmHXjOqPy0YiXEsI5KOD9jsDOM4pP0tLDjl cWFGN4SM2yQmvQVO6DZxh08pLa99iaSw4hstxPjmbJUu1yairrRU94xx0XvWn+2JqSzVHWIahGux Mi/QVFFX0nofITLUuJo6WZiQTmiVZPoo3kVOojGWrC9VnzIMnOkk68s03gWk2weV7RjG1y3PHwB3 wjGMrjt34vgvi9j0hiNllTyvizDYV6lT8KnPQpiV/u7lIgqKMgp23kaNHOqu3Vo5pYXHL18+f/3v T8G/pGbSHfZvRnPwP7+iD25CD33z06LSG6GeVIfi4cg7EMRdpLr+rNpf3mCAWER8Cm6vMDzdJnt7 hRGoT951nV91Nmiv1dl5vbqsdXZ3aSFcZzH13z9/+uTuMKjgHqz4YDrg2jjTbA3sbceG1pAMxqqn TlYGyzEHXWufs95u1oiTLnYMjtTj8txgYimc/nhPXRAYfOMaTkGjWeYgu0WK+vMfzx9++fL0482z kvcy/Oqn54+fvzyjC/hvXz9+/vTmJ+yW5w/fPz09/4vuFRUEkRvWzGY7ZYxCD9iyWn/5ZGCwwxnG 81ZCvDK2R9osNtuJIrojEoLv0RU2ffvJ4e8aNLKa6vocnyihEQ0HRTPtzpqNp4SW05lG1cuXXMrj Hk7Kgj6PSS6fUbuqQ5Vt9UczkphvDXdcIy0ObRpPwmQbt069gL7bxtSSpuDIeBAw0kLT472i5lEQ kh6ZJXyLEjubeO1mDbXc2MQuCTcuZ7yiKoEhqb1t2UZ6Nl2fmha7SIDtbr1JgmRE5twRk9ozkXlW sSXgrEObHX65yGWClLvcirlOCdFpgbKTNXKYvDNJTb3OS7Nky7wLKY12k46nmY4NlTgAorFdB3bj yK27sEOzR4NNPZ3nQNNDUrTpcVBss8ja8oYkQmCwZO8HI1Ppa+eImQ7VoTLWzQWiRH+V9Z2Mw5cP DIr+IIVhKgfE3JZFLsOMpFy/4BJnu5GiGFqranNnpl8+P319Ns7QTNxrOP85glkqjh4JiLM60Pfn YrKt1V7KY34F1y8PxFVSjfuaMbmnRICGqrnko69Leogj0xSyxgyioDDYFFv6Gsaq+zwMz7fRxbMm 4Wy93uoPA9BAlImUc3QrpfH1weakP8luWSddkLRjNIqZrDzcS/DtyiJ3jZRcbJLV4Rc0RSEMx3ft GG+i6WfsH/+YQIz+g46v9iW6idHFoyO0DyGNQx7NCflbzRpTaLeEugZwliGQC5PQYkzQQ17z7p0J ZBjEhgKY6XUESaAnpo2g/ZzJQlJOOe/SOGBfv9m5tt1ZeO4oAa2KjccLNaLHy0NvYZeCvNuEtoIe 2+JlSMVq6EnjsIRrK+VgRYPNQKUyMAqcLM4O0VhlFtrif9coFMA9erOgIwMrBulMxS28MlUejTw5 tZ2CotNyyloyXtyxQTPppi/1+FqSmLW1RbI5LIFIGnS/UU1JxO9jYrz4HiXj3lWiNdSPbx+f3xz/ /uPp+78vbz79+fTjmXhhYHkUHD/MTL6Olm8Gii4fT1DfCRQ8dsdb7WvBSzWR1b09fZ3OfU4N8fmE nq9GluqljG0lJtWd7C7klQG8Ln16pAaLKiM9Wa6hgezRPmXpdzG2m9MfT5AJ/uzxu43z/gPBQ21q 7Qtt3CUsCE4P0knWMAVEdkHUZkxQXOWANB1iYwqYWJjX0m4du+DbB1+9J5ROCisBzKElTBsSMbry cCsNV2ySbmhe80uZoT1kGBv+qGQwDyZinExpD11+Nz2o9OzA9W+kKUbhMm6QFcV7iphhdSiUOzp/ nw+n/dtwtU4esFXspnOunCIrLtIHa+bIxQUbnBDiI9am5daMvqMBIXUbqeMbMr9oReeXBNQ1mI6T +SVBQuZXRVvPFjWy4PtmEA9v4ICEQvAXrjjbNIw2yOjUYsY3EYnDsp+sqFZL4EGr4YBkWinOdBFs KuqadWFYJWNdyMQPkyb6iUxL5aFv1vrD7Yneh8mKGjkIeALF6hwPu05yUG5bdXzrKZyMsTvhVRWF +hXSSC/KOKA6gqFKxpsgHKiPHxoT510zBBsiC46DlYerE6WdjTzp5oYWRo1Tr6pNVfBep2LZuyCk vgePeA0s/cDCIHa7dMTc0iRQEdWYgGCTUVjJ9m3qGY0wURl1wbPAGSNFD0hF6pELfqYkhi943kUO XcTkcsW9S2MSxrGpSs6ih7+u6AMka5yNQaEMMw5WkTttNDgmlwyd4dE01vn0OwEX/h9jV9bcNq6s /4orT/dWzdxYsiTLtyoP4CYx4maAlGS/sDS2kqhiWy7ZrpmcX3/QAEFiaSjzEkf9NbEvDaCX2XZ7 Np/xJfpS5fKNkeVhgOEi6hxs+MV2YeNCrYcz6IHZ+BLbAjr0eou+/phMcxnK05PEDR632mGaIyVc Aza6HuF92aGeEEMOG/YA4zBhnd1hszOlaPE4NNhmaT2RI7uk9SrvZeUbJv6AbzGmY6xaPYiKFCEI leHvqyb3SrxOUe19h1Ycd4W4kRpdou9qHdeCC2LLKnIXC36Q3ro1S8NKLlTo9n0blIRG498U7Ct1 2tZmEe6MGlB4PLP1CPUhscs7xewxHxK5spBEcv9HOfZVHk8ukdUlj6E5sC1nNh1j+79AtrhHbY3F cueNsVz/lkXuemeHdyG2mAjfUaEtEITW0RRZSdkM2b/yVD8KDUnXaQmHJ2RLczsZ9jl880Mk3ZX8 a9zgIyuIX4K+cish5qc7RRgxLoetdj8rhng+rPF+oGXTBbXRHh4yXkW0/zk05wt14LnSqWezKR7t TEZMMKNCK7uJ3c+PV3gAfDs+7S/eXvf7hx+GXxqcQ7sQl6fU1nE5KyNKvzyejodH80ocwmhjl3T6 WzIEeWJ3rBYBt001F4BkmG5iaZar2NRdpm4hxeqGN5Fygwo6xai1vVJKs8OlLVgLLnHgnti46CxS Xn5WEc8CmEMtslW7zYot/GdzT834GnVS279bsshH49lk1SaGTUmHBtEM7Lyxo3PHAaEbJpdBgXws oGtPSCvFML1yyojFZesQiFwxmuG3xxrLlUdEMViwE5nOoJtrGfQRSp/MffQZUpEqjOZTVEGqY6Bk Pr+eOimyWXQ5Jm5OEH52NB4hObG44qeFM5Vly9FID9ShyCwajec3WIoikop3XRhYPBGoeoYrpB5A nyJ0O56dRpcBWk06xMEznjcUPWPzsRlUukOacDRDBecBv750C9ZUEf/uGk1yI5QMyhqL5rRJs3Bk vT8rmtDGPfONabi5Yrxc2ljtbv1cJQYFwLpCPfGAFI9yPIqtWh2LYUGniFYMtp6sny0HYlkFRuwD hVi2Q4osLficsq7TgJIavW7uqyxilkZttbxzk7UVGBUd95XVl3GTYx/ZXecyVLiUq3BbCbuDq3Qi HivFvrfYvf3cv3cRPt70zdVC+lvkNIOXeejXRI+vl8ZZBJnKK/fhZSMHVVsoDvMq/6+4/HOJakrc ZgvjJX2TYGeN7Xw2OJN1lB+Eg9KNblrDf7RBbiohpLF0PL0xXelL/QL4oF42RQQxIDKsTfNtbuZR xeTWpGxTUuZWSUgY02WUmIQWtvosNoNtSCDHO1xYgLaLvMFaBwxAuQhYWaaAgqxywpRU4pgLjf13 HTUKo0A/wUTg75TlQVqar/AD2VtonYfl+BoieGhQY69KHdYg+ZbzuS+AOzBAdxI8+KyCpX3h0Fh5 mpUtTVZp5gkl13xNa9Z07YUt/R1DTYIs1pe1ii8lZbiK6zaxjCOrM6HrOHim7wA1x3Ed8p350tsX EIuNC/A4FnFRlkRI1QYJVhg4MXCdVWHl6Rwyg9Yaq8ZtpRmEdT58wXTWjEPSafYUNV8Zxu3aVCvs XArHRVZu3OlaklVNSYrJyZJhzUeU/hlrKIQSaK+6IBJlReNF6lGQUMwVLa/4klbXHr6cpf7hAKDV RVUoVav4elk1Hgcq0jDxbFd0LLcjbD1Vth5B3Q1mY4x04BLvRAVbCxhfXMO8MpQz+AGiItm5UmZn 61CRgggL5bMVLYu7s7g4n13PRBFRDrBcrAn1dxKY1YnbKD5sOGdRp8YLa55tEY/o3bjVY9JKEmXO 6BZWl6GMKG9jwbbehHyq8Fao88ZGq7xXM3PoqdkbHcCPfMLHPCYQ5FKlVFuV1HGySiu9xkmk/FZq FwZLLgHGfUswG+HsvJ0tlbgeqoMcff9xcuncZRpOSBSRVjlbuGRDtlXErEISEEEsLPIqEGbmWDzg 3nfnkp/YTXmnzwa+CPDzdceyDpCSiNdyPfZUXxmxxlq2pj3oVeQVHA0LKmH2vsBvPAeePr60cZIo WzTSe853S1KU2CyQmv3tsqwhMphDNy6cshUoSnARftVoksYSAvnAHUQFUcypeZ3X3U8oIbaL+hE+ HR9+yiCbfx9PPwclF+1Go4+DOLQQpy5ZhBmzad+Bi5fJfIqVoqWrufMQozCWTvkx33djqnNNPU8t Gs9ogubPkYkXub5EkTAK4+tL+11WR2/Qk77OxETQaT2ajYb2TjE9WeBGQxrDOpx6Pg2i69Hcf5mt 2JJ0y6ev/Vg6+LPBB40mY234AlKAlatzcyg/YseP0wMS15tnzqhQH9e9NXFqvK4RapBFPXWQHsBR Q7hMK74E17NJgFcBK0Y/1bgEFJTa42F/RMqXhtBchdjkVnrZRhJdmsKCV78OzfOG/7vWFbNLwvRT veQh+oosSYPBgjyP7l/2p8PDhQAvqt33vbAQuWCuV/LfsZr5OAurIku9IlC/rPmm1Cw0Y9QykVza eYfv2FKGd3b8jtHad43MvQJp1xRrV44wCmncQWt4kpVVddduiC9/FpIMCi3D2A/J+XUNVXVEg9P9 8/F9/3o6PriDncbgdwEiJn7RVMmQL2RKr89v35FEug18eE0AgthfkSJKUKjiL8DorC1Ina61HnEY qH7kkGivODuU2Sib4hbhRLswa10Yqo+Xx83htHftI3reFrzlFEZwsh4S/dInVoYX/8N+vb3vny9K vhj9OLz+LzxjPBy+8ZEdmb4KyPPT8TsnQ6Am3UmBellAYPkdvIs8ej9zURmS+nTcPT4cn33fobhg KLbV5yF81O3xlN76Evkdq7QS+79860vAwQR4+7F74kXzlh3Fh64C23/VQ9vD0+HlHyuhjrMLS7AO G30cYV/0L1b/qr+1tVlcaCU0xqz34y0cHlRB43/eH/h+Jgcl5jJBsrdkW43nmNZWhyeMcElHt3CS dPME3hH7U/rV5GbmoFxoGk2mukvaAbi6mhr7+4D4LG4HDtPmtqNXdTEdmTa8HULr+c31Fabn2DGw fDo19Q07QHn1QEWNgaf35o9fBPAVknpM/TxJFzX+yLrmB60AdQsm75CHH/JIYGzzm9yriwuYDPa3 zLjsZ99IA3yuhoCDbVZSYzIdoFmlu39QFFv5ZKD7g8IDj7Bt14VxUeE618+qQKo3mZ08J9lhr6V3 HXp78cBno6shzxGQw/TLYi5a6v46IEwoaaXJyuB3x06wT6+CkMyGMrV4+W1roQ5pulwX7738kzLE vazTmMW10PihZZaZRgUSC2iYszqAXyHBb/gkYxf/DPPJLBnAG7Cy4hZtVi3vuLD115tYzoYGU8Fr zBeSgchl2yptIwMOwrxdlQWB2TTuvhz6jX/TbahtXVIaF7ghgs4HyWOjR2NhaUx1c2DAYBSn+Xae 30JJ7EJAbOxsKL63ENWWtON5kfNzZYpeuOg8UGMnI1JVy7Lg8lqUz2bo0wiwlWGclfAuS6OY2WnI /gQPP+jZwew87VO4AQ1t5QU11MPAmTnV/vTteHrevfBdhx+oDu/HExZD6BxbP86IUQveMhMnu0Fp Q03HIqKl6cmzI7VBCk829q3XGVWMLA2KdZTm2MIT6a7jCr4S59ZPd8mlcIfBqjYG+Th3qrLcXLyf dg+Hl++YUy9W428isl/rJVolJMn+BaJaEH0RE8e7ClqntQ1WHVAsyNirBoRbyhe0/4LZXuZtjnCN vo4orj7Qk3ZO7ME0jCeX3gwgVta2HHvcLwk2+XbrNAIXr+L7eED7tLvSVOC6ICybKkOvz0TS8sHA ODqidEGM9HCRitImeYxToXoexK6RAfZ5m40FMEkaX00ANtS7E2b+ED6e4MquKHWXoIB0zvvsZ3AN Wja4ZKOxEOFqESse5+H7T24nzYIYHqOxG0q4vefdthU7o7Td+3h6P7w+7f/BPb3lzbYl0eL6Zoyb RHc4G00uMRkaYFNQBkpvEKms9pAy9KePVL9wgV8tplnAsjTHJUERtzbsHxW0mzFH43WoVclqdD2x ThOipZIDqNqJfUP3DRDy+Re3m5JGnY+LoRZrkqURqWPeW2D+bDh44aS0zE0lOi5Zj1ufZ4ptfXUG m/gwGqc8X56bB//qQGoREMCXZ21Z4JTbpqzxEQJoVbKUj5MQl7eAw+MeD6CyEBaywvzSy7QhFH92 BNDvGG+RMG/LlqELKvGspk4rKNpvKtuz8dHB5V4YnQvqc33SM9OGn8pIwfnEXSNeYMntr6zECeP9 jrf2kF2ctGsunyZ4sYo0O9Nuydg/qqB8BNPK0NtNP8rCXagpRCha53CxRB9nwXUAXLmvDJvMnAtC oM5058ETMHQO6V1V2/sEE82BevtJmPtIFHl9NaQSUV6dhhyI9xMxtYZCip9gqy1u8sTqBu/vhrhL ObljhInBK4n2huTwHYJvk7xu14bioyRhVkAiqbA2zpdghpswewUywFa/gU4acDluTKqQk/CTv7Sh 901d3lsZubNgua/tHn7od5QJEwu12dty7QZncL5hLDmWKavLBSWYfKx4lBsZ5+My+Mq3JC5j23uN qjtwwUDFHXd0FZGViv7kAvXnaB2J3WjYjAYpmZU3EHHV02BNlDiQygdPWzo+KdnnhNSf4y38y4+h ntxzxjl9ea/5t/4d7AxY1MhCozbqcyWT57S3/cfj8eKbUeJ+ApWhMTQFYWVqGAga3ADUmUUEHwHg QTytdR+qAgqXaRZR3ThefgGej8Gfr+2AcBXTQi+IOlN1P+u8MldHQfjNFiR5tqSuUSfMzYKvLYGe S0cS9dJW01jqP8TENC6BP9bM5sN4TWibGJ6dkQ7okwaDdTH0hdaKUcOSggcY/xZDojNY4sdisfD7 0KX/Qw5Jb9meXflMWYMzxTknmp3ZfZsg9X8Z8qXKA7HbhrClb4pu/WnmacHHmm8hzs+0W+XHbovt 5Cw686MUyVTNNaV4Y/yGB0BwFiEUtailaNqxZPdlD+P3XIpv8m/5luG/4pxPxv+K757VEcposml1 PN8I6lnUYXQYPj3uvz3t3vefHMaClZnb3PbjZkdOasrlGH/J+djVRQO+NKy9k+DMvKKlH+RSFT+w rfSlBylPoXt04z+Ghji8Hefz6c2fo09ampwBYgWJTWFydY0nOLDI0Fj459fXmA6KwTLXDfktZOxF pl7k2ofMvPnoYbotxFuC2ZW30vMZZsxjsXgrMJt5kRsPcnM18xbmZopdPluf+2p5M/FlOdfjdgHC 5TUYSe3c88Fo7O1nDo3s8gsvbfiQ1zLDNK50fIyX8QonT+xCKAC3b9I5MPMmHXdmiAJufvPhyFPW kaf5R1M7p1WZzlv81qiHsbtEAMG1Id+d9AgSihzGWa0/og10fsBraIkgtCR1iqZ1R9Msw1JbkFjS jTILhMYx7txecaS8iJYPVpenaFLsXtyoPFrmuqGrlC3tojV1gl0rRpn22MB/uIespkhhQmAn8LLd GC+Txv2d1ELZP3ycDu+/XI+OEIBLzwZ+tzS+bWJwlQYHNmz/iinjhzzek8DPz+YLI42gSwffruR9 RBz5WTjQRsu25NmIQFXYlsXisIH7C3AoyMQDZk1TXclaMbgU83zRJ9RtlbhEAsuQ0AqDiZSJUuFC p0qtIvYDjuot+bqzxY/ISUnFbQorG4qKDnCcSkNx2wKqXss4q4w4thgsCvPl0+e3vw4vnz/e9qfn 4+P+zx/7p9f96RNSdsbHL94OPUtd5uUdrtrQ85CqIrwU+NLSc2Uliar0N615RzwOTIcykwTesO0Y OW5u4SoqN0WbMdQIXF1e6iOkJ0KA4YKfZlFTx4ELjCmNi/nUU3hOlyWL4UGTnwPbGgIkgUp66fEd Hq/Rl8tO32+YFLpTXV7VL59AkfTx+PfLH792z7s/no67x9fDyx9vu297ns7h8Y/Dy/v+OywRn+SK sdqfXvZPFz92p8f9C7w2DiuHfGXZPx9Pvy4OL4f3w+7p8J8doJpOBRgj8MEYrtqiLGKzOVPQTJR+ 9jyqig4zvOB5edWjC14kBftr1Otu2atk/0LAu0ZczrLBLZ9YxUr16BSefr2+Hy8ejqf9xfF0IeeW pjAsmHmVF8Q0WdDIY5cekwgluqxsFabVUl8JLMD9ZGmEZdGILis1/AD2NJTRPWWpgntLQnyFX1WV y82JbgpwhHNZB2+rKN39wAxNYHK3UcrEDqBcEptci2Q0nudN5gBFk+FEN/tK/HXI4g8yEpp6GZue lzvE9ulsDYk0dxNbZE3cdtvFVg/M3eG9V3B51fjx19Ph4c+f+18XD2Lkfz/tXn/8cgY8NTypSFq0 REochxG+XfY4jRi+iqpGaug6Hk+nI0NilholH+8/9i/vhwd+pH+8iF9EkfkEv/j78P7jgry9HR8O Aop27zunDmGYu62F0MIll5bI+LIqs7uREQq+n7mLlI30uNKqQ+LbdO22OE+NL39r1eaBsAWArfvN LaNpaSRpSeDSand4h8hgjkP324xuHFqJ5FFhhdmaTrzVVI7vIIqQf6gWS39rgv/eunH7AYIv9I22 3L398LWZ4XlerX8YcYvVaC055avB4fv+7d3NgYZXY6RjBLlXE0dApKkEHbyC8iXG317brVjVrU2K 711kFY8D4x1KR1Afqn2+9egy0v17qzmAbiDe/sqjCUJD+FI+7oUSnttyNI9GZpAuDZh5nIb1HOMp 6lWwx68M51Pd1FzqDlQGIk8LI0tfmg75yiXmV0g1ICh1HJSoM91uZV/Q0Y2bx6aSOUtZ5PD6wzRX UuuPO9E5TarCu+Qi7YeoXU5SNEF6ZtAQGrqdzQWoTZIiQ0YBnWmXOyUI2CGm7k4SEjij+j5itTu4 gOp2XIQ0TKK2YmfNWpJ7gp8yVC+SjJExdqtm7RTYCMAVo3qUVoYNvUlvGYvH7RTZvVnu9kcduy3K T8BoF3V0X2MrWGatLDZfT/u3N+NU0Ld3YrqyVjvMfenQ5hNsNczuUQ/NPbh01w54TVCFo7uXx+Pz RfHx/Nf+JM3MrPNLP9BZ2oYVJv9GNFhYTud1pNtI7IJLDI+6oLNgGzUADvFrCn6DYlAPr+4cFOTZ FjtyKECdAuxy9rg6P5wb8D0z9ahl2HxwhjkzykFLAT2ZQOQk+8j1dPjrtOPHvtPx4/3wguzzWRqg S5+gy4XKGV4c+u3OCExyJivdd09KkulcwwguVH51+bDFCuhq4+Uyd3offxmdYzlfXsX22xJbAu/5 cns2zaUrVILmaUUiMyCti6GdquM8RxRfxIZaq4ZICxnpgcCZuT0eo+a0DhtU+HKCFyEM3TMs0G8J tuV0CD85zW+m/4S4iY7FG4Jf4fPFFGwzPXSXJ791cqZQIqM1FlcbyWrtipGiOfjBkxkuAyQBXLB1 /p7Q7+zYKBoE94HbEBGwZfNzOcvXx3lWLtKwXWwxOZuwuzyP4apZ3FJDuOYhBw2smiDreFgTmGzb 6eVNG8Zw0ZuG8EBta8xWq5DNRSAIQCENjONaxQXyoHAJAB/r9YQLTHBtFkt9QaERCWWwrrPl+ro/ vYPRIj8Zv4lwkm+H7y+794/T/uLhx/7h5+Hlux4YSjjLVPeX3avAUCQXZxDOSH/7Bjze1mBCMLSN 7za3LCJC7+z8cG6ZNF/Pwc0Hq3FmpRv2Lyqt6hSkBZRB6CYmalfKvNsRJWk0a6vb4XSmKG0QFyEX GKi23oENmdGCQcoPB+CvXRtJyuaKnxuKsLqD4B+5dYels2Rx4UGLuJaxaVwoSYsIXPzxhgtSI34A jfQjGm+GPG6LJg/Ap7xWRxhcJHMTBvfVSjHcgixyHxc+AYG/U/lPzZu6kE9qLgoZJCsqAeeRR1l0 reK51k1rJmC4sRcHcBWSzKHz2R4Hd9bZVEM8UR8kC6Eb31iXHEHq0aikIapLEFoHsFAPiZoG7sVE qN1KdZcIQ/PDewYmM1BSRGWutQpSEl3ZZ0gSqGBxY9PvQVLgQp55PLiXco9F1RWYTCqWsqmeZNDx kujKRxYZ49/eA1lvHUmBy1SkWTpQ2OLp/oo6empEO+yIRPe/M9DqJZ9zSMbg/BcTVDo4CL86qZkj e6hmu7jX7WM1wDiyqekrXnaIoSrK99uoZWVWGsdHnQoPw3MPxDM8A+nRc2q+g7AYFgyM1q7yalia NHqQo+SEaXShmL4mWVtL4aHf9FkZpsI/Be8NaoQXJML0RbcjlCQRO9BY4oBuOO8uRCVlNE2+bi/q pYWJ4JWkEqclvThUhsaECBO0rdvZxFi1u2hWWl9y1lBkLG8y9992H0/v4HD7/fD94/jxdvEsn9V2 p/2O74b/2f+/dsKCB0wI1JRDmGY2RDzsAQY3eRLUV0YdrmIKOiFckMGXOCMpz0Pxfys7st24beB7 vyKPLdAGSWq0zkMetDp2hdVlHd64Lws3WRhG6iTwUfjzOwcpDcmh4j4EiMlZHiNyLs7hAqnxGCmV 9gL5p0YLyvnyW0JWFy9jNWwrvyYYR7rMr8Gio5uOvfNhswvJ+qp24/6lMJSmQj9mMWb1F7oeSPxh QUHQujQBte7cHPXwR5GJ0TFqFsMGQR4QJ3VKh3coIjgSByXosnf6MhuUm77NRyx11xZZooSC42+O koc6HSPJCzJaokUTll/emFrPn+UlpyYMtwDkOYn1rMN5uj8klRCmqCnLu1beBLgXXlQaI0DlZrOA GMh37mu5FYup9fv97dfHL6+u4Zef704PN6H3DcmOe0KFXIhpxipxkQoW5IeKCd8qkAmr+c31zyjE xVTm44ez+ZgY1SEY4Uy48WDtUbOULK8StVLrVZNgBkOv6jAoQpsWFaC87wFAVhNGwCP8u8RUuwNv 2+A2iq/Zonj7z+m3x9s7I4w/EOgnbr8PsctzGZtR0AbXIJtSNw2s6B1AxNSFLgGUHZK+0EW7bbbB CL+yi0Tc5A3na5rQho30RMFu0QPuKODpw/nb9+9+Eue0A8aDAeluKEGfJxkNmwx6bPkux1wWA+e7 VAkI7w5ULJTbMW6hxoJP4tN6PbQ8DGkUBIDX3bXEMkP8Fi1Q/OMhT/ZI/MPq9Ev+tpd9cCevmLmK 2envp5sbdPMovz483j/dmdrI9vwnqOODaijL0IrG2deEP9OHN89vNShO36GPYFJ7DOhLh5miluq9 BguDR2pZQoFzIzGGf2t2CKsSTZshMZGUyP8S6WtAfXIwBh71J1fu3GAaq8Ebg8JXwoHkrJHQDQSb ua4KQ2YKAlQPwYs+q4tYjDCShh9uNVuQzkvzYIIgI1EEATBvBieqn8fAXisKeGd67rIXWymoKudo D417NagVrgzmxY1YMpaZMJ41enf7NkvGxBPmZ617zKZayCf8d5AgwjTH09rxVBzxN4ToMB0RXqqC oovXjybiwror8/kenCpQn05ECP3Pa/tRIgVBzsTTx6Dc77wY3Okum5MIsn8FZC5cr+1ZwQt7z02D JxhbMgw8IzMweZMxC/GXelmHM1/W5Lrge/aGUL1Gd+bebgvq+FZm4bcUyYCU/TglwS2MNHMGLfL2 U64W8wjUdtRc6Au+CR0YKltw2vAQn2FnmtKq9wmSqsXIYckvNdNP4Qv7roYLAfGm2nGuKKNSAdCr 9tv3h19fVd8+fXn6zmxsd/31xokp7RLMiA2stdVDwJ1+TLkw5U6NeUwkjcL4JErP40PIhPd4hDMr FfKhLcZoJ0p+XQJMXILRDC+BMUsTF6LPvKnwmxaS/QUQ2kQCLLoYH2ZejDhUOMNxh0nUx2TQyMXh Qpa5dFkVD67yqvUvzY74IMd8fkLhRWE+fKd9UZoaXSGW2uwz6eK+qoztnks8Hvs87xw1z1wyoL51 N2dpxeULZvvzw/fbr+h/Bju7e3o8PZ/gP6fHT69fv/5lWT+9utFwVO4qUOW6Hq6fSFIg9B3s6JMD D9EAnj0eKGfAjfvLR3vKNOYf5ZOguYsmxW9AcnTww4F7jgNQCfKb92c6DHkd/IwfJF0rAfma511I 0ExHlLxSHQUQI6s877SJELn0Nm+Yq8MPaSVwgdAwEXMEXTZprQ93QsP9H59+tplhoCOaJTymQIST Opc20hcAVcepQW8XONxsR1aYJLPaFTZlII5YKCNxEysI2vuFZcfP14/Xr1Bo/ITvOQ7pNbgtVWyZ C4K9weEK7hElvSg9GYXEhuZIYhlIWv3UhQEkDg2JrNhfcAoqbI5VC6owLQQIOaqAy1ctFW4r8rA4 yiSISUinY6cI+73fih7k2KRjzkzp3Vt37CA61unNL9TMLzaVr7M7Hy9Av1nH7BXt0jVE0HUBgR/f flWfadiGSXLPplabi1Hcc2ht0iunjA65uiynP6SFTdsxAgSnI0mmmBpWsNd7t6DE7XQYa5MpvIun dB4P5bhDe6Cvi2pgWdnjXUOrlA9uwGoSmWE8fBz0QDCvBJ0GhCTTQDAIejFdeY2pGY2HFoeWdo62 3qO3TV5K6tJ8MuxtpqKQ2KKCNATvMET8wHgiBth1GuJYDEUU/wCA0uJrOCnaaNW9BvNZ1cyfyAAq JlG7Y8dUR/ZU8xvNlhQ7V7Hj8uOT8vJDMk8O5Ac9D9yINWRYyt5zi0qgMtutE3a/oJi+oUz63l+A PFoEA85Dee0sXgX36ACXemmd8Yx53mJB/QYL5pwPwVEdGtBfdm14hm3HrOi454mH3QCThMPI+PPE J6cvp4ArPYrRACQNcKmE4szol7mqbVhguLMWTJmU96BOt6n25FGDfjwRnO1hlk2+fMTF7CU7kHc2 UbxP3hh29q4I2uyB9dtjq8AxzEpQcexLNf52nfjZW+w+96EfytiXWK/FzXZDQzFhKhtf+pFARFYc z5GFfQoKNQPoxjczXVLRWyJ+cGW+bdpezuchJD724I8JyAJdIC2oy4oBhxecXh6Os5Bqr+1VA8SG 8QT0Mz6pPEjrkCgZwQc+tru0fPv7+zN6GESLhGZ9wbLO7n3gJvkB1bBlCcVvK862ZDe9JusuTQy2 Jh9bENp+JEEOg+wOcJfzZE8HanUsPwenD2BqOmCpxdWB+K9Y2h6GuSxKjA8B8lFn6NmkJ0o0wLZa nJYXVtilKIdvOTDXdh9+OHrcwASy9PP5H5os7Wo9IZ/GspXmmYs49OTmwEz6yniPaTaIvCiP3RaW xOZaX8LVi+Nk7bSpQsOz92NMhlVNqg86yVwzlxNbWrxLYFPoAIJ5l1etu2Vr7u6bj+d6aI6AyPWI ihliij1AzhB+mLGR7+kNEy1DkfxRXTxdII/gCaVGy6tL5eWeUUNvO51bgIdqs6FaH51sag6cyzp8 OzMqj3sI5bPzeHp4RFUdbU3pt39P99c3J6nd7iedilldFV9p297wGy9RZFfrYMpwbUHMLz60HLfJ R84w/LKxZwEyXKqFoOc6dQ9FUlb8bEIWGvUgEEyd7HOb/CIOVbZWpY3DFGheiXQ765wfAzUFG+QJ EurZHuZFm1T7bHSMJmyeRMliaCP5UAmkLhuler2EiP7esBOZuVUX/RbFF27JikiwQWeqlX7p6hWn NNIza4XB87NORORgo9sfZ/Jeu1jZ5R+RGK+gjf1HOIparbBpoIa0u5Jsn121oWNsNdcl6jZuxndO o/Fh8YeCZirXvPLgOkUyZVDvx7joQf32FSUO0aMLKSVMicP4YVBub5lp9Vz4jO9rDw+XNdte3VYy wqQt4dpBTxfgEZ3Ddy09511KdJL3M6BTl6PlELYKupD86WvbdJoe/mP8zBwRyuJCXvL+t3Xe0VYu eV6noMJqRmY7BRqSpW+g/Z3bCg3+bTAVxMbQTO8n29A5U5CRg72m/gOzQ4T+bYYCAA== --===============2946642378261956521==--