From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 2E6FDC433EF for ; Thu, 11 Nov 2021 23:00:10 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 097A26134F for ; Thu, 11 Nov 2021 23:00:10 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234464AbhKKXC6 (ORCPT ); Thu, 11 Nov 2021 18:02:58 -0500 Received: from mga17.intel.com ([192.55.52.151]:64767 "EHLO mga17.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234417AbhKKXCw (ORCPT ); Thu, 11 Nov 2021 18:02:52 -0500 X-IronPort-AV: E=McAfee;i="6200,9189,10165"; a="213759718" X-IronPort-AV: E=Sophos;i="5.87,227,1631602800"; d="gz'50?scan'50,208,50";a="213759718" Received: from orsmga007.jf.intel.com ([10.7.209.58]) by fmsmga107.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 11 Nov 2021 15:00:00 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.87,227,1631602800"; d="gz'50?scan'50,208,50";a="492731675" Received: from lkp-server02.sh.intel.com (HELO c20d8bc80006) ([10.239.97.151]) by orsmga007.jf.intel.com with ESMTP; 11 Nov 2021 14:59:58 -0800 Received: from kbuild by c20d8bc80006 with local (Exim 4.92) (envelope-from ) id 1mlJ2z-000HD8-W8; Thu, 11 Nov 2021 22:59:58 +0000 Date: Fri, 12 Nov 2021 06:58:56 +0800 From: kernel test robot To: Toke =?iso-8859-1?Q?H=F8iland-J=F8rgensen?= Cc: kbuild-all@lists.01.org, linux-kernel@vger.kernel.org Subject: [toke:xdp-queueing-01 4/9] net/core/filter.c:4153:31: error: implicit declaration of function 'pifo_map_dequeue' Message-ID: <202111120649.DqUsCPnZ-lkp@intel.com> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="mYCpIKhGyMATD0i+" Content-Disposition: inline User-Agent: Mutt/1.10.1 (2018-07-13) Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org --mYCpIKhGyMATD0i+ Content-Type: text/plain; charset=us-ascii Content-Disposition: inline tree: https://git.kernel.org/pub/scm/linux/kernel/git/toke/linux.git xdp-queueing-01 head: 7cdc645073a59261514e56e1a4c6d0dac1b24b32 commit: de44bbfd9cf981baab181c006dc363c5f412d94c [4/9] bpf: Add helpers to dequeue from a PIFO map config: sparc-defconfig (attached as .config) compiler: sparc-linux-gcc (GCC) 11.2.0 reproduce (this is a W=1 build): wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross # https://git.kernel.org/pub/scm/linux/kernel/git/toke/linux.git/commit/?id=de44bbfd9cf981baab181c006dc363c5f412d94c git remote add toke https://git.kernel.org/pub/scm/linux/kernel/git/toke/linux.git git fetch --no-tags toke xdp-queueing-01 git checkout de44bbfd9cf981baab181c006dc363c5f412d94c # save the attached .config to linux build tree COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-11.2.0 make.cross ARCH=sparc If you fix the issue, kindly add following tag as appropriate Reported-by: kernel test robot All errors (new ones prefixed by >>): net/core/filter.c: In function 'xdp_do_redirect': net/core/filter.c:3992:31: error: implicit declaration of function 'pifo_map_enqueue'; did you mean 'cpu_map_enqueue'? [-Werror=implicit-function-declaration] 3992 | err = pifo_map_enqueue(map, xdp, ri->tgt_index); | ^~~~~~~~~~~~~~~~ | cpu_map_enqueue net/core/filter.c: In function '____bpf_packet_dequeue': >> net/core/filter.c:4153:31: error: implicit declaration of function 'pifo_map_dequeue' [-Werror=implicit-function-declaration] 4153 | return (unsigned long)pifo_map_dequeue(map, flags); | ^~~~~~~~~~~~~~~~ net/core/filter.c: At top level: net/core/filter.c:10088:35: error: 'bpf_prog_test_run_dequeue' undeclared here (not in a function); did you mean 'bpf_prog_test_run_syscall'? 10088 | .test_run = bpf_prog_test_run_dequeue, | ^~~~~~~~~~~~~~~~~~~~~~~~~ | bpf_prog_test_run_syscall cc1: some warnings being treated as errors vim +/pifo_map_dequeue +4153 net/core/filter.c 3960 3961 int xdp_do_redirect(struct net_device *dev, struct xdp_buff *xdp, 3962 struct bpf_prog *xdp_prog) 3963 { 3964 struct bpf_redirect_info *ri = this_cpu_ptr(&bpf_redirect_info); 3965 enum bpf_map_type map_type = ri->map_type; 3966 void *fwd = ri->tgt_value; 3967 u32 map_id = ri->map_id; 3968 struct bpf_map *map; 3969 int err; 3970 3971 ri->map_id = 0; /* Valid map id idr range: [1,INT_MAX[ */ 3972 ri->map_type = BPF_MAP_TYPE_UNSPEC; 3973 3974 switch (map_type) { 3975 case BPF_MAP_TYPE_DEVMAP: 3976 fallthrough; 3977 case BPF_MAP_TYPE_DEVMAP_HASH: 3978 map = READ_ONCE(ri->map); 3979 if (unlikely(map)) { 3980 WRITE_ONCE(ri->map, NULL); 3981 err = dev_map_enqueue_multi(xdp, dev, map, 3982 ri->flags & BPF_F_EXCLUDE_INGRESS); 3983 } else { 3984 err = dev_map_enqueue(fwd, xdp, dev); 3985 } 3986 break; 3987 case BPF_MAP_TYPE_PIFO: 3988 map = READ_ONCE(ri->map); 3989 if (unlikely(!map)) 3990 err = -EINVAL; 3991 else > 3992 err = pifo_map_enqueue(map, xdp, ri->tgt_index); 3993 break; 3994 case BPF_MAP_TYPE_CPUMAP: 3995 err = cpu_map_enqueue(fwd, xdp, dev); 3996 break; 3997 case BPF_MAP_TYPE_XSKMAP: 3998 err = __xsk_map_redirect(fwd, xdp); 3999 break; 4000 case BPF_MAP_TYPE_UNSPEC: 4001 if (map_id == INT_MAX) { 4002 fwd = dev_get_by_index_rcu(dev_net(dev), ri->tgt_index); 4003 if (unlikely(!fwd)) { 4004 err = -EINVAL; 4005 break; 4006 } 4007 err = dev_xdp_enqueue(fwd, xdp, dev); 4008 break; 4009 } 4010 fallthrough; 4011 default: 4012 err = -EBADRQC; 4013 } 4014 4015 if (unlikely(err)) 4016 goto err; 4017 4018 _trace_xdp_redirect_map(dev, xdp_prog, fwd, map_type, map_id, ri->tgt_index); 4019 return 0; 4020 err: 4021 _trace_xdp_redirect_map_err(dev, xdp_prog, fwd, map_type, map_id, ri->tgt_index, err); 4022 return err; 4023 } 4024 EXPORT_SYMBOL_GPL(xdp_do_redirect); 4025 4026 static int xdp_do_generic_redirect_map(struct net_device *dev, 4027 struct sk_buff *skb, 4028 struct xdp_buff *xdp, 4029 struct bpf_prog *xdp_prog, 4030 void *fwd, 4031 enum bpf_map_type map_type, u32 map_id) 4032 { 4033 struct bpf_redirect_info *ri = this_cpu_ptr(&bpf_redirect_info); 4034 struct bpf_map *map; 4035 int err; 4036 4037 switch (map_type) { 4038 case BPF_MAP_TYPE_DEVMAP: 4039 fallthrough; 4040 case BPF_MAP_TYPE_DEVMAP_HASH: 4041 map = READ_ONCE(ri->map); 4042 if (unlikely(map)) { 4043 WRITE_ONCE(ri->map, NULL); 4044 err = dev_map_redirect_multi(dev, skb, xdp_prog, map, 4045 ri->flags & BPF_F_EXCLUDE_INGRESS); 4046 } else { 4047 err = dev_map_generic_redirect(fwd, skb, xdp_prog); 4048 } 4049 if (unlikely(err)) 4050 goto err; 4051 break; 4052 case BPF_MAP_TYPE_XSKMAP: 4053 err = xsk_generic_rcv(fwd, xdp); 4054 if (err) 4055 goto err; 4056 consume_skb(skb); 4057 break; 4058 case BPF_MAP_TYPE_CPUMAP: 4059 err = cpu_map_generic_redirect(fwd, skb); 4060 if (unlikely(err)) 4061 goto err; 4062 break; 4063 default: 4064 err = -EBADRQC; 4065 goto err; 4066 } 4067 4068 _trace_xdp_redirect_map(dev, xdp_prog, fwd, map_type, map_id, ri->tgt_index); 4069 return 0; 4070 err: 4071 _trace_xdp_redirect_map_err(dev, xdp_prog, fwd, map_type, map_id, ri->tgt_index, err); 4072 return err; 4073 } 4074 4075 int xdp_do_generic_redirect(struct net_device *dev, struct sk_buff *skb, 4076 struct xdp_buff *xdp, struct bpf_prog *xdp_prog) 4077 { 4078 struct bpf_redirect_info *ri = this_cpu_ptr(&bpf_redirect_info); 4079 enum bpf_map_type map_type = ri->map_type; 4080 void *fwd = ri->tgt_value; 4081 u32 map_id = ri->map_id; 4082 int err; 4083 4084 ri->map_id = 0; /* Valid map id idr range: [1,INT_MAX[ */ 4085 ri->map_type = BPF_MAP_TYPE_UNSPEC; 4086 4087 if (map_type == BPF_MAP_TYPE_UNSPEC && map_id == INT_MAX) { 4088 fwd = dev_get_by_index_rcu(dev_net(dev), ri->tgt_index); 4089 if (unlikely(!fwd)) { 4090 err = -EINVAL; 4091 goto err; 4092 } 4093 4094 err = xdp_ok_fwd_dev(fwd, skb->len); 4095 if (unlikely(err)) 4096 goto err; 4097 4098 skb->dev = fwd; 4099 _trace_xdp_redirect(dev, xdp_prog, ri->tgt_index); 4100 generic_xdp_tx(skb, xdp_prog); 4101 return 0; 4102 } 4103 4104 return xdp_do_generic_redirect_map(dev, skb, xdp, xdp_prog, fwd, map_type, map_id); 4105 err: 4106 _trace_xdp_redirect_err(dev, xdp_prog, ri->tgt_index, err); 4107 return err; 4108 } 4109 4110 BPF_CALL_2(bpf_xdp_redirect, u32, ifindex, u64, flags) 4111 { 4112 struct bpf_redirect_info *ri = this_cpu_ptr(&bpf_redirect_info); 4113 4114 if (unlikely(flags)) 4115 return XDP_ABORTED; 4116 4117 /* NB! Map type UNSPEC and map_id == INT_MAX (never generated 4118 * by map_idr) is used for ifindex based XDP redirect. 4119 */ 4120 ri->tgt_index = ifindex; 4121 ri->map_id = INT_MAX; 4122 ri->map_type = BPF_MAP_TYPE_UNSPEC; 4123 4124 return XDP_REDIRECT; 4125 } 4126 4127 static const struct bpf_func_proto bpf_xdp_redirect_proto = { 4128 .func = bpf_xdp_redirect, 4129 .gpl_only = false, 4130 .ret_type = RET_INTEGER, 4131 .arg1_type = ARG_ANYTHING, 4132 .arg2_type = ARG_ANYTHING, 4133 }; 4134 4135 BPF_CALL_3(bpf_xdp_redirect_map, struct bpf_map *, map, u32, ifindex, 4136 u64, flags) 4137 { 4138 return map->ops->map_redirect(map, ifindex, flags); 4139 } 4140 4141 static const struct bpf_func_proto bpf_xdp_redirect_map_proto = { 4142 .func = bpf_xdp_redirect_map, 4143 .gpl_only = false, 4144 .ret_type = RET_INTEGER, 4145 .arg1_type = ARG_CONST_MAP_PTR, 4146 .arg2_type = ARG_ANYTHING, 4147 .arg3_type = ARG_ANYTHING, 4148 }; 4149 4150 BPF_CALL_3(bpf_packet_dequeue, struct dequeue_data *, ctx, struct bpf_map *, map, 4151 u64, flags) 4152 { > 4153 return (unsigned long)pifo_map_dequeue(map, flags); 4154 } 4155 --- 0-DAY CI Kernel Test Service, Intel Corporation https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org --mYCpIKhGyMATD0i+ Content-Type: application/gzip Content-Disposition: attachment; filename=".config.gz" Content-Transfer-Encoding: base64 H4sICFGcjWEAAy5jb25maWcAnDxdc9u2su/9FZz0JZ05TS3Jduy54wcIBElUJEEDoD78wlFs JdXUlnIkuR///i5AUgQoQMq9Z+akEXYBLHYX+4Vlfv7p5wC9H7Zvy8P6efn6+m/wbbVZ7ZaH 1Uvwdf26+p8gZEHOZEBCKj8BcrrevP/z2/77cvcc3Hwa3Hy6Ciar3Wb1GuDt5uv62zvMXW83 P/38E2Z5ROMK42pKuKAsrySZy4cPeu6vr2qdX789PwcfY4x/CQaDT8NPVx+MWVRUAHn4tx2K u5UeBoOr4dXVETlFeXyEHYeR0GvkZbcGDLVow9HnboU0VKjjKOxQYciNagCuDHITWBuJrIqZ ZN0qPUDFSlmU0gmneUpzcgLKWVVwFtGUVFFeISl5h0L5YzVjfAIjwPCfg1jL7jXYrw7v3zsR jDmbkLwCCYisMGbnVFYkn1aIw7FoRuXDaAirtPuzrFC7SiJksN4Hm+1BLdwhzAjnjJuglkUM o7Tl0YcPruEKlSabxiUFtgqUSgM/JBEqU6npdAwnTMgcZeThw8fNdrP65YggZsg4pViIKS3w yYD6L5ZpN14wQedV9liSkrhHuykdD5DESaWhDkZgzoSoMpIxvlCiQzjpVi4FSenYXAyVcMnM ZbRQQcjB/v3L/t/9YfXWCTUmOeEUax0QCZvphVabl2D7tTelPwODICZkSnIpWsWR67fVbu/a JnmqCpjFQopNUkErAULDlDhVQ4OdkITGScWJqCTNQBVsnIb8E2qOalJEHf8SNCUVhqHqdyrb g8BP6xTHfRWeEh9KUyddzTpOeuxFj5rBCckKCWfNSTUmQA5lJTeZ1GJMWVrmEoEOHNGcNLT4 TizHru2hcVH+Jpf7P4MDMC5YAtH7w/KwD5bPz9v3zWG9+dbJU1I8qWBChTBmQBXNY5PksQiV ucEE9BYw3BdfIjEREknhPoWgTi7+AJX6NByXgThVRKB0UQHMpBZ+VmQO+ikdnBI1sjldtPMb kuytunXppP6L83x0khAU9nT3aOKULQNNS2gkHwbXndRoLidg4CLSxxnVpxbPf6xe3l9Xu+Dr anl43632ergh1AE1DHXMWVm4yFHmURQIpGmYHQk+xfitTKH+fVwPDBOHIZfy0dCamxPZm4sT gicFg9OqSy4Zd9sHAXih9gGadjfOQkQCrD1oPEaShE4kTlK0cFA6Ticwdap9Bw9tn8dRBgsL uF+YGH6Fh1X8RA3PAQNjGBhaI+lThqyB+VMPznq/r63fT0KG1oVjTFan2tbFAKwAS0mfwPsz rkwx/CdDOSYW13toAv7iuhE9j6ctaEnDwa3lHQEHbhUmsKIK2jiyN/NeuN5KGThpqnTJWDwm MgPj0Vpia1slk/5wlKAcfEzfHde+wxjV18sMJ+LuB0kjYDA3FhkjAXwqrY1KCE57P0HdjVUK ZtFL4xylZryoaTIHtIc1B0QCkYARi1JDUyirSl7b4hYcTqkgLUuMw8IiY8Q5NRk7USiLzLqK 7VjVc3l9sOaGukeSTi1BK9npUCty3z2gg4ShfTG10WoSgmK1+7rdvS03z6uA/LXagK1HYM6w svbg30379oMzWtqnWc3dSrswSxVU1IrAhXJDHUSKrDhLpOXYdT0ADbjLY9LGmPYkgEbgfVMq wLiBXrLMbbcsxATxEOIuNwdFUkYRhNgFgj1BHhAgS+aLDVQOABri9K124N/Nur0eU6dvLBA3 Q2L1c2QYOviZ6DigmqirU2duHY8hfBgrBchDinJjlopf9VxDWzPDCavgz7oDxyBWoCo0DWsR SzQGzqQgZ1D+xkkWu+3zar/f7oLDv9/rGMLylu1xMrdHgYh1cHXlYAcAhjdXprRhZGSj9lZx L/MAy/TPlswIHFueHhruNR1zcG2gbuDFetzP0KI20OCfo9AQFgHDqvxhhbNijhPDZIDpxwQm zqsniA4ZKB5X8UXLlTKvisxSaSV2YHHo0hAgEaXKMwmWEtcsljtV8ZyM6hD9fR9sv6siwT74 WGAarA7Pn37pAj0xLo37rH5huESGamDgHfxh4MDJWEFyUFjw7A9vRuTu3kvTka33z005Qx8p eNmt/6rtkmNdMNZvZgQcgj+AeyEGV8OqxJKnTmZ497DS9eXu+Y/1YfWsmPTry+o7TAbb1xJu lFI4EknPlwkIwSKDX9pdq6QwSlEMHrUsCsYN5dMqpRVMYyaMTU41Ey6Qzu0qmXCIdXuaORqC UalYFFUn64qsyljY5PiiN2+GwGKrcBM4AS6nLRB0FRfJ2rSmNR4sLFPIFcETaTeuvFRvSzIH WvpksjCsuFROGmFp7cFUmYHGohQg1/BkvI/eeJP6xMrD20YQ0lwSRRRT5Yui6JhOx5hNf/2y 3K9egj9rz/Z9t/26fq0zsc5qn0Prm/YLSnIMMSUEXmCuzZBfe3iRqcjqqsda82LXQ40VSRly mYUGp8wV3Du5Bjutp6EePrhaBzK1Y6XIk7G3mM7AuQEq+XGVyzZ61Z98hKvI/9wuR8S5u6zR R1Nh/jlE5exnVUaFAJfe5WkVzdR1deVeMBHs0FgFCzJ5+PDb/st689vb9gVU5svqmMSMVW3H yi+aRGgsYvA27tLHMVeSJOZULs5iKdfiPprCmI3dJQMFE+CzWIE89RdAqCugEFZgvtDJx0lk WSx3h7VS+ECCc7GcPhgVSXXGApGzSpCc6itCJjpU24U4hklEreHOy/UIMfPO7LFxT3X5jnXZ u2HLAYmyOg0OwXbZpV8DOFmMiVVUagHj6NHpcuz9urxXs1YUNNe3E0+UjzDzYg1XZrSBn4M5 585AdYhvsglsZmvukH9Wz++H5ZfXlX5uCHT4fzD4NKZ5lEll/a2MznaCOkYNS/BabXFYeYum TGPYwXotgTkt5MkwXEYMPt5YUq1oCt1HbB1OrN62u3+DbLlZflu9Of03uGRphb+iSMGvFFJz BRyKeLjX/7PcDz7q3lHTYyUNZSh6+UCrPjSGsNJS5DEkSnYaPxGZY2rLvyxDBayjLlPIH66v 7m+7mg8oX0G4doATK57EKYGLh0A9nVc84iyXqjjvhOIMOcefCsbcJuNJuzSG3VW6sM2rVJwz cTNK2bIm7+i4S7g62Ul9s3bsZVG/h2xWq5d9cNgGfyz/WgUhGZdwPgGKorTjpRP5RPFRP3y0 Gh8uD8sAPasYOci2m/Vhu2vDglYGKPPE1r65x3DTq4NGxc5Qv8kY4idJ8jZa01Tkq8Pf292f sPCpBoM2Toi0lVGNVJAIuhhc5tSoqqhfcPvMGkhUDzJmJeh6rL9kF3ynLv84j7ixsPoFTjZm vSFdjzICeT2oHB+PwP06t9MoohxXEPFT7HaOGqe+ducWAZ2iQlLso79CSY9eCAt6IxBAM/MV T9VgJ2RhHqoZchF0tMq2FGlRl+sw8rz1AULrVivOIMB0vU0AUpGbD4z6dxUmuOhtpoZV5dNt ChoEjrgbrs5HC0/AVgNj5RAgU567quIao5JlnhPrMU8scjC5bEKJOzatJ04l9UIjVp6Dddu6 NEAJxdIAPVBrQMebZkzlX94gu0UCxcaFb6e+IulBrWJHzpgQ56C6o308XLTDNj1lWPjvtMbg aHYBQ0FBrkJy5r6Ianf4a3wuCDzi4HJMjcJK6/ta+MOH5/cv6+cP9upZeONOOUAzbm01n942 d0W92kUeVQekunavDAPYfhfF6uy3SjXe7BGlG282i25/SDluL2nHbasebz1aM1rceueY2tMj 9ThqL9e7TCZIUHnCThirbrmTRQqchxDDQa4XErkoiGmIpl4KtN0rVK1DFRzdF79G1LL0wwWJ b6t0Vm9zAS3JkCds0UpTpD+wEGUou7BhVvQkbBok1TgC1EDcxSceK1nIQjXXQJIaLUxZtLOL ZKGrIuDYsuKkNt0hRzTteQzz3d0PBHMZYs8JACawx4Hw0C1HELSb7RCXO8fToWeHMadh7Ol9 UHZKuIPZaYry6u5qOHh0gkOCYbabkhQPPaSjdOKEzIc37qVQ4S4EFAnzbX+bslmBcrckCCHq TDfXXn7olNV9ZOwpSoBIkM7lnWBVlp2KGZU4cTNaqB4XT4cCUARJ6cTva7Ii9UcAuXBvmQi3 Euvza0pD4j6MwkhHVQbBF/gKH9Yjl/4NcixchlR71Xk1LsWish8wx49pL+APDqu93SuiTcBE xiQ3a+on6D2AmTgY3EEZRyFl7tzPo1meYhJkDXzOfVc5qibYfZuznr1ohmeUE7D8dh9DFCuV HpxkgEfAMQP8smrTPlUQCMCyawSj1NOMqPhftfQl+olGvdE/XBk2K5pQT6VTyeHekzUj6g4s MCmSylfxyyM37woBdtzX0qVCxsgNczmh9n4LWemSgPHKwBmQV79pd8UBRFM2daYVRCaSsbS9 tsdEevXX+hly7/6rTfNoZrwP9X8YfQbd0THVFRW4Kg4SFBSJIrOW0SOup+IjrGAzwgXQ4+a2 haaean4IuWsB8SKC43bfAHX4zGkpFOSxpHwieiepdHHDu5qQpceZAJAytylTsIK70ygNQ4K6 3UUCOWNaaqzT4jCMPW83h932VXVKdc951tqRhD8HnrddhaD6StuXsJM9wtV+/W0zW+5Weju8 hb+I9+/ft7uD+bJzDq2uFm6/AHXrVwVeeZc5g1Ufa/myUr0SGtwdXbVOdmuZeoFRSEBxqiJF dQOtlwu/fx4OiAOlbea7uPOxUu6WylFiZPPyfbve9GlVzQW6j8y5vTXxuNT+7/Xh+Y8f0AEx azyyJNi7vn81w8rO06pnMYyNMOKerjVU0J4v7B6E18+NTQvYsfzWVcbqvpeEpIUnZobwQWZF 5LJi4H/yEKXWEytkpnrFiPJshjipW7FbGxutd29/Ky1+3YLAd0Ype6ZfCM0eJDKXHB3XUY11 nXFvsevewjPUd5jtU5pTPn26jvVE/aymnqms+v2RNapMG3I69fJOI5Ap9ySCNYKqADfLVJxk zGOyNRoSixy3yPoBz3kgj+SPDRMv2tlZqpCxufRE61lCT9XSaIloVzMUmYH/xr3mI1sFOker xxHPAqEbZ9WXH+qK6F4Po/ZMVdPW16WyErvtYfu8fTVt2/9rvqUoEIrVfYNOHsSMxepButHH k3PJ1bfdMvjanq6+2yaBHoQTFQxPrEKc99W2lYt0lS6Y8bTFIqUkmeSEWIMTNv7dVGUYUtFS r/nVqMpzFcw4NmuecV1PxHmZpuqHOxRvkCLXCXAINJuVlRZbOR0hQjg4LUbDuasa26KmjBVd 0cgc1e9QutPv4e50i5CP/c/R+lgX4GJ+d4YsjoygzxhsCBrcumA6ttePZt0FUyxS2RQOp256 IJHXMlXx7lmCLx2YC5vRdZI3zYgVYvS5pODOuB8AlSdf0LCTElObDpo7dh1XDkuGwpvhzbwC f+82Z2DHs4V6NfZULVAuPb2YkkaZdgVOKIRCKRMlOD3wSlOKPUY/KSrITTylFClhXkVwMXJ0 cR/xBGiF+2izah4qyaub4g3G2ljI/y3WXPWGQlIZRv2IptW/Yd8g1O/vRJkbV7xYQ0ArPVWk Bn4/wvPb8wjz+fWtU0N6mxvEjj8Prk7k1pjtf5Z7cA37w+79TXcI7/8AK/wSHHbLzV6tE7yu N2CuQdfW39VfbZv+f55tCJHkgnEBWbUYqU6KE9rQKzisZRAVMTL8xvbvjYpSgret6skIPu5W /31f71ZAxhD/YnEcJ24tU50JENpg9QEAdmdNGoVLMfdiJGiMclQhT9Y1LVBO3cGwdW3rj1VU takeMVSnZRMAVbeS6WI4oqH+dtEZlqoJEO5lVkMODNq/7AZhPaI7lLu2O01WQ0/dffoRBPnn f4LD8vvqPwEOfwV1MzpNjx7AohUnvB494z7hQhutIu2E2OUCx8JtEo6zPBXMhiu5Cto9dUyN krI49pXeNYLAqo6qwtAThdUMk63q73syBBWvZWa9kSpIhE+FaWNQ/ecFJKG+fL2MktIx/OcM Di9cy7SfTvXO+JPNvJnuMLcemjTE93BSQ/VXO/7Ys5bdPB6PavzzSNeXkMb5fHgGZ0yGZ4CN Go7A0cD/9E3075QUnocLDYU17ud2bHGCcFZSyJsR12CEz5OHKP58lgCFcH8B4f76HEI2PXuC bFpmZySlX51BL85gcJx5Hgo0nMD2Qzc8IzHShjQns5i4K+ZHnBT+4mlWOeKcP2khR5cQhhcQ 6Cg7c1SRIS6LxzPsLCOR4LPqKinzfD2oKVhwd3Gy3v/E4dneZj4a3A/O7B6FLEOQmvg8bm0I i3NWMleNpWfhyFeqrI8gyRldFovsZoTv4Na7nw410iM4EIqrwfDO9UmLgQK8Nv1bA0GXjFeI R/c3/5y5EIrG+8/ut0ONkQvIHf3gWfh5cH+GCyf1a4tFZd5rsKkDi+yCJSqyu6urwZlNe07d dEa9wMnKAN0X1k2IRDwm0p/eRKVw9VCr59pgMLq/Dj5GEIfO4P+/uBKAiHKinsbcazfAKmdi 4Tzq2W2MF0ZwTtT6QDlvzmSVKFgeuls4dW5o6qWiKi59foY8liiF7Nz/kupLdVVrE/FkcRnC 6mXfHTAUXtB07oOo5wdPVXGMOClDt9GLPd0KQJ/w5IVwLlx/4+XWsdJNIIxXUy0p/U9ceGZP faWMPD1pcW3vAO+3QLSSkwnhVvuq2n4KqTGkRSNIH0x9mUKu67GMclEkzN78dD0UokIS61+8 aIZUEZ1HvmsR896JHUvHxNZtIgejga9PsZ2UQmhEYfvE/iSVYiZcKZU1VRK7fxxh4vN8Cpmj SgpX06i5aIaezGzNAlnZFPy8GwwG3qJWocRtm/f2dGWeNh+6O3aBe5xLanVuo8f+NyOOeeZn r+a4MBuVTYBSO2alQEimvlac1O0SFMCtMAriE8UFnRhzhsKe3o+v3X50jDNlUjzf5kB64U5R fWoiaczykXcxjzNeQLSS9atQ5kTXtbcPrN4vrfPm6Pyc5sHTKVqMprTM3KCEpEJ/n2/k63qo km4RH8FuthzBbvl04Gl04UAQbll09e+yY4r+UMS6KjHJILY82lQnTaHbDhsLh7aFrLuEU+rq sTFnNU0c3Ubp0P3mABYg7Pc5nK6nvofW/3aDmRBfpJ084YQWTuHXL0dOUFKiGaFOEL0b3szd NkR9X2CVGIgvqCf9L8u7MCJ2ZzIwPvW0Fs99UwDg6WO9vvIA4gs6llEVCLDI6oP5PbsgupRK W3J6QP950Y9C8jgldg9PNs18HWZi4unWFJOFy/mYG8EuKGcWnVk6v658KXg6v/EH5QAVs7Pg aHaZ1bY6TcTd3Y3bLNUgWNbdWTYRT3d31ydFY498mxtjmB48vPv91qPKOZ4PrwHqBgNLP1+P Lri4WqvAVjmvFWT31BIK/B5ceeQcEZTmF7bLkWw262xaPeQOYsXd6G7oyprNNYlU/3yaFYCJ oUdLp/P4wo2Bv3KWs8xtnnKbdlrBenBRcog5M9Xk0Q8BTle4G91f2TZ9OLmsHfmUhnYspr8D Dy9eYjb5X8aurLdxXFn/FWMeDu4Bes7Ea+yHeZAp2WZHW0TJS14Et+PuGJPEge3gnr6//rJI bZSqpADTyYT1cRXXYtVHo8QSH3RMNJm/meMvuW+6r6/kplT2ULRhdw4Yhix4x+4wdHwBxC5o 42otSDXHR9caUurIR5fcPck0t46fUuJH1GmlWpAE7oI8Y+P3yKx7uXTUr6Uq8sCTKyXhdRB5 nR0jso2qR5O7UUfPjxw4TRgr/bQ/nBF6dRDFAT4soml/MuvKzAfNKfrhIjAFj1CRsDy5yTB8 lQSsjvXjChLTcR7xJANXHhDlP5M0hVAryPB0AZ+zo2cK7lrmHMJmg7thvyuWeXfDxYzSJnLR n3V8UOEJow84IWekdlJiZ/0+cRIA4ahr5hQBk/OmQTxUlcZqcTCqF3uyg3/h0yWVk+vKCsOd J7tqeZ8n5XOZkBHw6Bi6T9lnHFwVxMBbxicWDJ50lGznB6E8Jxm74w1Lt+6yNnSbcWNnlcTG bKpDOmKZMXjKQrk9Ab8eQfgUxTWdVTPNtbkUyD/TaCVna3zJk1K5j5PfOsZ4/CrJbvhTzWtV h6SbMdULC8AQ5WuqJK7tJ6qJZxYVMGfCfhRNP8NYW07PrRnGdeX3oDAL2yYu7XlITOjyE1HW /XqDCFu/2WxMeNXDRjnVqteqPDOlFbmOumo/W5jGNqSVUoXEbUztVKgSXJ2vtz+vp+djLxHz 4t4eUMfjc+ZNAZLc4cR63n/cjhdMV72hFKkbq6kAB1X0K7jQS6GRyKaeSFZlI0Kl63pb0F1R azzq0lCeqISNqObfPz5vpGEF9w3qaPVnulgAIWDdfUXLhCJaAgoCvAgK5FlxxLd1kCpOcj1e XsEo85RbYhpmW1n8IBFOzWfJAHwPdmBw+GaGOms0EJgb36qNQXl56AgPzm4eWFWCzzwkteKH uV2dtAuJ+/BAWNAVEN/ZxISCusCACxqc4/D7vQIm4mBjbVCS0hKT+FRhA/lhcJ1RAdnGtfo0 v0/ZPurPNBSDsu2LoNRyQ4FA0/nOxoJhQyx/hyEmlGuZFQLXASZkO2XbjYkUXYeydjPOdoXc kUMdFOH4tFZm74DShdhiV3ILErZ6QDkSS9AC+Dsy5bsh1CR51e+mw+WewnVU0i3Zz5k3pu49 NWIt5OnCIiZwXYC8kVOYKOlBLscguJfjajYNUe7PBPmDBkB9hFxaCL1H1t24oM4YfISb9K32 l2dlKsf/Cnp1QyQ4PJddVTMjAp1iwY2oEb+NCCmf3o0qPVwHyp+KC6+6kVMCeb6VnxnpAlos 11k9XmrRImuDL3ZKml2l1BKu5ywG4H/elkzEOtKwwjkFSBQCFS0tz2nq4rMFD/sixb0utkbp ZeFlf9kfYIUubXzzTWNcobdcV6lE9d0jjHpfuIq0SFSRFQLKfEu0wUgpJbIUAKMTcV0MzDKz aRrGu0o22laGDMxMvQfjwtbbVTwDQF+d0eBpa7rj5bR/xXyOMjLN6WB81+j9/vn9TyW46uhq E4RscbI0Hpb2PPUpGySN8aztkDyYVSHE8UxDEiuK6ztfEyGXrToZZR7+JLc+S1LQ/KolQCR4 KEpFWsotlNE3JzFFCqk4wxrlyHtQ5ixdz+m7IDh/s4LwBSeu7XMEY/6W2CPniP6Ei3vKRk2D lpGclOQY5sJ1IpgB4GO1Rchmo++xtfwitAuWnWtC0YkE3tMWcRTSs5sUL4SbumFXHgrF/YXr bLugDJQKQEVq8yVncgRH6BxYG82NZHxtmmtTliZ+uiQ6ix88BZRKGVxwYoKBMctYGRUTPodr HskpNO/F+DIdejzVtOqYs7WcRTW3dXW9KwI1yzkPPEL7UQLn1miIX0mUGMbiiLBcLkFbHq5k f0RRsM+SnxAnslsbVHvy74wIt9RkMPkvxCsie7e7o1o5b4soEbEyBdYui2g3ai6K+nAzYNgk D8FYKlV4BT3EdEIiNHQ6YMVNmsBJmWadqMeofWC9voW85+2vUBdWOsXayHIHhuNqFsH7MYi3 2r5c6/GJos15PLd8w6oegrM7fTJt2wF2/rrTnwGRc3AKcwWlLgcMTClt8nBrDahZWopB6wwX ZiSgbbGAL7DlxNfNlVW1Znna+Y9emC4f2wptmbaE5Xf9fL2dPl6P/8X1K6pASdOrDKLmzplZ 32j0BPmPojQBMXj4zeWRj/ZtAlTsOpPBltjSQCYuRZwgQmKuXeE8CKFJgBCKFgIEPw4B0dSg ybDD60k7GCGu+DJR5irS6Ac1oeIavhKl9ptdoGWIeJRDSbIX3c4GL4CWxqEs5/nwT1PZBNRP /fF0ql+LqviLG+GKuizwS3ZLRzGh9DLtJOiOSK6o21kW89i7vRx7++dnRaYr11tVnOt/DI1j o5SV+nO/Sb6eH3Fkg1A60g2+NmkmjsgRxEm4YOoIXUyhs9p45k2vCsi8xuuTgd79729y+sTP DNrbzLLvh33COrqAxBJD7fczjBjedyDklLywwNPWjyOCcrVMLXSoNy0yiNxfC4sDTWxEmGTU gKHAuRNzHB8/yOmLsOfPMIv7/vRujNvDVDHTwYLwmMozi6f3rQA3ZoPZ6J5eITKcPGj1+33C UryCmbVnp85r9wNqp5yBovvx4A5XSJd9hZFHi6xmXkdHCdn0fkhYfVQxo0F7nfyYpWCABtSH xKsnBZTFk8m0vWaAub/HnVULTMg8+milMYKL8XjWng7cYI7uvfbPqkHzYcentWxxP71vT2rN rcl0QmynckzcH3R0tHU8HRC78hyymQ4ng/tV+xDSIIdAqW9K0Lyr9xLtAN2MCqDYFYLPa4d8 gR3t58yzUPi8RiStPc9he/Pz8/2gKNuRy60ssreAiwPPcdXukBFe5SVq5TKbUDFLjAenAkJ9 K8W2NbsbD8gZRKXA+mBh0opZ8clo0E/lNgcvySpmilCJ4cPHDVnKCUU1yCj/VMhaGTbKnAkW Eon4bvlPKfMCyi4PMA+OF7rEawnQBvGEGkLOE5iuEddbEJe1SiObDQeEjQLIhTcmfHyUNPZC wogPpDvBiBskEMewFR8Ox9s0FvI8Q/ehOBST8azf3k3iR287xb3wQbzeTsf4fKZ6csSf5Bau NYONNx3227uh7gte/y6de3R1IuElzWRyR/O2UVo5fjtLeAGJWDIiht8yMAc9cXuOza2UgWOH fioHP8U72Plbx0XiaTKny/7j5XS4NvfW66UlW31e0XPrAMULuIRnAPqTkmSnSphR4c4x1AmL y/7t2Pvx+fMnnMibDBuLOVotNJrmHNof/nk9/Xq59f7Vk3Nc8066nCOYrTliEXOCclKWBzxX XdvQ0JyfqD1nnfX5/Xp+VTQNH6/731kfaTa0Jg5hdSWvESx/u4nni7+nd7g8Cjbi78G40hk6 ci84neodoLKmBYnfPIivuN2sgww0ThTcBm7U2Il2cgaKHH9JONZIIHVBlaw4dl8MSWe8d8WV xsfxAFpQiNB4Hgvw1qjulKRCWYQyrysZ3I02IiRgLUjEmDvuA6+abMkwJvcY0a4exuVfu3ra LEiWFj5XgNizgAoS17iq6GqUE0Ur77GNOLLll4EfcYGPBoA4njyJ4PsnJXYdXK+phE9A+F/L c+l4c07oopV8ERE6WxC6QcQDQt0JgDVfWy5ppARr+I6+71aAHd0WG8uNCTdunbezEQFlLquK v9PvnZAADjpDojV53OiO3605sW8Dabzh/go1gtMt4cObTnFNEQAu+UypD8h0XccP1vg2SXfU JWfq2r8F4oJ5eIt8t5DzL2YfCeLI0R3XHFZV145qcACvZjT7oeJTb+8LPvGCAsjAcRM3UwBp aPlwupC9le7ooRNb7s7Ht3UKALc+BK2AkoOFSQQdjh4PErNTz3m0tHYYcbmgk2Jh8baqZqbJ tNzx2uODhgZcrWgE6c+cSR0XrpwoViyu7JZCt2XWiCjVK4xZMCSRxxJ6nCl+iO/BrjWLmLcM GTmrCEpPBfIElsg0FPjJCBBb7nt0+k9OFLSW7mlny7WwpY/oE3W6Ikh01dro1ikk8htKbHEu TDgqe4nC+EGesIMV4+BgFbtO4/1WkJcPRpbbBRmcuGGDUrIiVnY5K0ukK2bXohIxKi+kAUhZ PTybDJMQHr78vp4OspLu/jfO5+oHoUpwyxy+RtupJR2zkkvLXhKKX3hPAl9/IGIE+8QWNnqP OhHJXQBpluU7G3ibFe9cFmMO6D64S73Xx+VPn88tH9vqRTEDs6by00OA2pqbQSsWB2KHB2ab +L//uNwOd39UAeDpK/uZGSsLrMUqj20xI68pQeZn17nq08sA0ya1ApTn0IWmZjLzV+FAGIYE 1wgxq+Fpwh3lYoofNqHU0bpxd1Xc8UJJa90aTr9mcCM5b9SPZ/ikZEDwa4EcYov+8A7XGBsQ XDVQhYzay6IguIamCpnhKuOiRtZ2MuvjWowcE83uCY1MgdiOxtMOiBiz4WjaXZiOxgvZYtAf dHwmFt6buuRqHxuwVI7P7Ma+6Bxwa9bsO0iTDgcEL45ZwvYvE61lJ5kRj4uUrTrp95u2a+Hr /gaPIHYXtT8g9FMVyJjQXlch486eOJmO04XlceJIV0Hej7oGx2B01z7ERPzQv4+tjr40msYd tQfIkOomOWA8q09SSiK8yaCjJvPH0bSjM0fhmHUMLego7UNYmyA0usn5/U8WJl2dpM2sI8cs Yvl/d8RVZ1GV++Fd8+EO2BCJ4zs8TN5RkGXg2gtOvPJig1J/XeeK1W8DeNY8WVQeTSzVPcAB vuCERZaOB8+VEhu9WsKVXUCytbkIKRbohHIzXlACHuXE5thOL7Mu8xw/MR28VDBFg5bH8qhM 7RBTr6zVOwyNvFQoRVmhpZqSSG9uER68jIr4cDlfzz9vvdXvj+Plz3Xv1+fxejMUnAX9aTu0 zF4eaUibMRaAHgkVyXMkyeDZ2hc1Z6rctxFnvA288QZmGo3qM2VOIc6fF+IeLHf3l4fleDLC tcdoIpU0LO7OA0wNyGW5k8pJw3j7QAl74f7XUb+0izyL0QXVe8Tj2/l2/LicD+hYd7wgBvph 3N4OiawT/Xi7/kLTCz2Rd3U8RSNm5eODJrhOs6a3ArJs/5Mx5AfvPfZy+vh37wpnvp/FQwEl G//b6/mXDBZnhjntYWKt57+c98+H8xsVEZVry5Vt+Nficjxe5anq2Hs8X/gjlUgXVGFP//G2 VAINWdXWyD3djlo6/zy9PoMmPm8k5ENphhHZtrmdi0sYbn49dZX84+f+VbYT2ZCovNoNWGpq xVTk7en19P5fKk1MWigHvtR7ygKol4zWi8jBSdadLdDEUYfYICLOoMSU78e4ugPo5MnnVDZN i1SghD/ImmH3UmAUzglr2nq0SomBX4IsgzIMIzqO3hCvdnIW+nFV7V4tTXavAlZweO1WO3gF TfvBgCaDei6ReekD3NYmYj7oSE0/9WN/BSQsl1CjAQosYbm3nXqPpJsZwDy+hRtgDia4bZmG WysdTH0PLDAJq8YqCmqKfkazsSuxQctO3vsT7w1GBJOtzH3U+MzW+/PlfHo2uptvR0GdMTSf fTN4ZctnoVQ0psm6+rNQZZSDRwVHmIX2agNE9gd4gQ8z4iUeBdM39/VrxFyP2EyyjKmY7rEk FxQjLA8I4yuXe9SoU89zM/1ADbEPSvzGE6LFS1yG/7C+LT/JiV13G2NtWFsut63YkcVPles0 5iAhZRyccsvvJOfGQVpVN2UB6RZYyZvBYSD4NrWY2xQJhyURj41LFSkbpgTRuJSNUvStJ5mY N88f3qtMYFzWSsqI9L7Toi0tWi7ASRaXzeOW7HzutkRdDBoxy8qhjQj7SXOw5GHpPDNXRpOT J7MU5NykglnAKYJFu5C85pEIOVPj1BUL4Qexfjg3H/X1AK4D9Kv0xmOIWoDm+ZgEMXZgAnfE hYDuUPGXVWE6qEwdPIeJNs8eFaqJ9SDZH15qViVCdTD8cKDRGq4eXvgLHr6BoVeOvLwZRDCb TO5qxfweuJw45z3JGEQFEnvRqFteJLwY+uweiL8WVvyXs4WfflwraLl8CImkGm8t49IjtUXo xy1jRMqa4z+f3dqKrXck1+Pn87n3E2v38vmMasCD6S6pwsCaLXZrgaEF7GKBz+PA6L1KKA+P rh052C35gxP51VwbK1zj/brKTA+/kMbKtwTN2hYe++CyCyNd85AaGQZy17V06G9g2S2yBS1b tYrg5pCcNltKM6dFLbFYZHnUcxWPiSVWVKdumfiBRHRLTiVeS+1DWvbob0et0gm1LERZluX8 p0PA+syx0/lOrwKVCyAlDvwivOzDYJJOOBTtxJoqXdLyaaKAKnfuImP2zlyoq2T8vR7U/h4a G0QVAmsjPqGAmHiqG7YgG3PnXDRVEKd+vSA2F0AbIWfdELs5lhDs9nEZWfAGKTiSVnhF4BPU /5QFNTNsPBOU+FFosJLpkBanLfUyMjVIODVEvLl6JIw4lrHAtugJgvrsbrU1XVE8JfzH6Xqe TsezP/uVC1IAyGwcNeuOhviljgG6/xKI8JgwQNMxrnGvgfAbhhroS9l9oeBTwgOlBsKvNGqg rxR8QhA9mSBiXJmgrzTBBL8wqoFm3aDZ8Aspzb7ygWfEbaMJGn2hTFOC9gZAcmsHfT/F79SM ZPqDrxRbouhOYAnGCVf8Slno+DmCbpkcQXefHNHdJnTHyRH0t84R9NDKEfQHLNqjuzKEy6IB oavzEPBpSrzRkYtxb0EQAwukXNoJSrgcwRw35gRDawHxYych/BcLUBRYMe/KbBdxl6KjykFL i2SsKiCRQ9j85QjOgCGL4KTIMX7C8ZOV0XxdlYqT6IG6mwJMEi/wUZz4HIYnsibyIN08quW8 eGa3oqvJaHYOn5fT7Td20frgUG9vZYqV1PYcoRS5ccQJdVKObRWiK7ripFpZke34cr8Jp3oW hDv1KjWzaqekBgzPDmxMmcJ4ssWaL2dnuGzrUKmnVTF0coX39x/A5Ac3dt/gB7xK+e33/m3/ Dd6m/Di9f7vufx5lgqfnb2BZ9Qta+NuPj59/6EZ/OF7ej6+9l/3l+fgOysCy8fV96vHtfPnd O72fbqf96+n/9iCtsvXxGOrCHoA3xVBJKZHcgqtGKupB6Fty8EIOAwKb78iYskcEC80UDPyh CcHCeWkc/BAxeq4kqpeL6dYp2WRqnbYoJ6iXgvwSlF1+f9zOvcP5cuydL72X4+tH9dV1DZZN tbTCCie6ETxohjuWjQY2oeKBKboVUtCMIlt5hQY2oZG/xMJQYLEZbhScLMlDGCKVh3fkm8Ga FL1Zzyx8UO0kmSjB9cFmxOJEBBaBopH8ctEfTL3EbQiA+AcNxEqifqHvcGd1TuKV4zMkJmqn GH7+eD0d/vzn+Lt3UP3vFzgu/a7Oq/l3IV6HzMT1R89MqcM65e3JOyzqQAiPeMgma7dEHuAG 43F/1mgD6/P2cny/nQ772/G557yrhgAvxP893V561vV6PpyUyN7f9kjLMIY56+RfnXnYV1xZ 8r/BXRi4O9IKsxitSw42dHQewnnk60YPcmQOcs5c5/PLXJlsvJ2fq1azeXnmWI9hC8yCOxfG ERYlxtbGokTzqpI3C3Uj3FMtEwdthQih4M0kt8Sjuflk4ew2EXFHmDc6GBDFCcHznVVHCNPq PGO0vL4UrdxoHpzKO585PQv7DFtZybZyrGuJaqX26dfxemt+6IgNB1iTKUFbLtvtyqJskTRi 7loPzgC/YjUgrR9HFiTu39kcewspH1PZulOPio2m2kxtj5B4nt0WhctxpO62sWaLPLtPKCPy wbmyMKb+UjoYT5pL7soa97HpXwqIR6byWbBdHMvN0zwglGMaswll1o3+xE4fL4YHaDE7CaSY MjRF6eeLfgAvcsiP+EYIcmUf0lEteJQH9cosEGAImMdvysZo6ATJyyb8nzLxQv1u7czZPN82 d0ehPGkimQtvREeLNwHafll4Wf3MZ/rt43K8Xo19eVHHhWuZbpD5xPyEH34z8ZQwPC5iE8+d FeJV66z2JOKml3QkzzHnt57/+fbjeNG2gPlpo9EFfXhiO4xQKti87tF8mZuZIhJiPtayjslQ geQa2Z55I9/vHNy7HTAyCnfERjSVO/3O/Atgvnv/EpiiZKzj4ATRnCL0Aeb19OOylwemy/nz dnpHNhtAX4pPGyD5whIBMD2yOlHorq+Jy1cOucvlT87ffTSxr2zWyqLhm7smulgB6kmtNs0W Pl5uYMMnd6NX9UTC9fTrfX/7lCfGw8vx8I88flZtBL8CV3i3+cmK0oBRHM6nPOdyNQFz8cqN cW7rJhcan4U7eVgPvNzEAYG4jk9I4RGFJOau2U2CyCaUZOBw68hTkzfH7dcLI7z/r+xYdhvH Yb9SzGkHmC2m3WJmLj3IttK48SOR7SbNxei2QVF0+0CTLubzl6T8kGzS7R4GmIqMJEsUXyKp MO5ieJwVD0GLh6MnbG0opCbh78bKigeOy6rmKsyTvjWYw19Yuj6ZDQ01HyGJQx1c/2J+aiES 1yUUZdZKeM/EYgSCbxCgwv0GQETAT+YzgOY5JTTk7Burc3pBTFR+dXqhtnissB6wFWtuay/s 2tlsUQKin8B/kwDEE9uOUokFbLbNk5je3/Xm149RG8UoLse4sfpxNmpUJuXayjlQ+giAj354 Eqtpp5D+ZJtySlODEoSXzA+FFe4XoL7Yui9pOoAAAKcsBCfCAjZbAT8X2s/Ydtwjp16BoqA9 N7jSNuGFde0F82F75M0tVRg25tzUah3VhQUkVH9lAEMA9Em+W4fMuhxpygZCpBk+zrr08luw WU1V7L1IrKfUmeDK8RxliR9z2LI8VeZAAC5thckW33zwXLFmRYXP2XEBkjsDFcAlWg7aiJqR BPE9x61ootbXt4fnwyOlOt497fb3nDMf2HlWLqhoqMTuEY7uW0G1IY9zSdEGQRUnUc3WvQmb Qj8JPvt6pZPO9fhTxFhVsS7Pz7rYIiA5vGoc9XDWzwXrRLdTjrSUshVdZwo2aiJ8wcMYlbpq P/w6DXKQBbU2BtDd2kf0M/gHQjvIC+1uoLgpnQHx8M/uz8PDU6M77An11ra/cVtoRwM+nDOT nBmYWb1WJjs/+X565m6biZe1KjD4OZUi8VVEflYlFFmfayy+B2ccq7SzJG3nVugQozsxPCzF 2oQOhQ8gNNM6zxJPJ7e90HOX9VqrBYa14KFmrxE+vYReRlRzgqLd3+/393i7ED/vD2/vT1he uFesqTwMBicZ511Cp7G7LtEZLtz5998nHFbzpA3bQ/tCgV5V9Kj2ly+jdRBvxYj74eMVfdfj v5wS/X7FLgK2LvX+tq9rpRguOGAsKRDaIuKdUlVQ8KV8cNKLsKCCuOkyTpoI3UEK2uTe+JSG YY86GZ5EDEtsvbPNLVPXma+CA3/RmxKrCwmXY7ZDRCQJwfNM7GaZx1hPSbDzbDd5cKlDwYXa nJxE8UvagOm2r0K+yPPmcI5ylLB0RhW9hEIYtr8rvso/rSFlINHl4Pho4stmGEwmFCS1SPP4 Yj5IqGhZv71HXCikhL46mg/F6D1YzjrLASsuwXysVRR1lcH8S8R+e0dLNsfMpJEXF/GP8pfX /bej5OX28f3VMo35zfP9wErL4KjCScj5MHcPjskOFXABH4iyNq9KaO73KZ+VGItXLWGWJdBE zt8/I6ieV7AKpSoWLplbttOBukFOTp1h8PSC5qpSB5HmxBmdEm73UV236xVbcraDI/eo7eex HHt68W08AjDyu3d6CoE7uJbOZXlOcFQVhSI/TO9DusEFXWi9HJxoa9bjhU/Pnv7Yvz48U4n1 b0dP74fd7x38Z3e4PT4+/joW3KgcV6XeCC7QhmqZJOMBysedmHWhBVFvEawCC0wHvnMCrcni sF6vxjzku6V8ECDmsjJafntgvbaTZ21NZw9nE1216vH/2ImRBmVWYLQOgxPaOaJeQjEMGVa7 wjgGspAnlmlh2bsk9xgl0WFFj1bm3d0cbo5Q2N2iN4lR+5JYWK5GUH0AL6bEE+XHxAM3T89M UIBldaRKhRqyqZgMHu+AC580HDU0sLxZCSrKOD3GhBXPAAAABKKSCSpDlA9JEZGMnn2qLzR5 RKhesW9atInq3ncMVwD4qdV1DaPltqdBpcuEqY+xf715ux2sUTPoEORajuVuf8ADg2w3fPl3 93Zzv/NivqpMCmZriAStIDC14+zSqvQsspVSLI4v7EHEh/mVXePadeGYKkNOTFuDPGhYu4Jk TRpnVOlDlkZRfCW42YLOmkVuNEECAV7xTcDJg5EnOVaPELEo7RIEaj3dGdg7QAgyvPU8THNQ +vK53kRVKryYAzZhdvGJThpEGynHs4cWrwiFqDtCWABGKaSrEgIZ80IJfBohVNkE2DpQZHhV DdOJXehGGSP4EAiOiXyzJOfDKgjDoF+VXv2c2BHphomgccRfvlilasELoPbb82GxGxd+lcom jF0cvIUSoybtGMupxU/gLM3RpyO9TTSLwSiBedYB2LrzVBlewaHeZrFJxfemLC1QAt3E98gu oYZaKQ5UjG+1FJvmExQD9k2ogGonB0HtSeCmbSfTCBSZiVYmr85O8vRROKV1Gf4HDCROJKTW AAA= --mYCpIKhGyMATD0i+--