From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1750801AbdE0V5p (ORCPT ); Sat, 27 May 2017 17:57:45 -0400 Received: from mga11.intel.com ([192.55.52.93]:24088 "EHLO mga11.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750746AbdE0V5n (ORCPT ); Sat, 27 May 2017 17:57:43 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.38,405,1491289200"; d="gz'50?scan'50,208,50";a="1175197718" Date: Sun, 28 May 2017 05:57:01 +0800 From: kbuild test robot To: Kees Cook Cc: kbuild-all@01.org, linux-kernel@vger.kernel.org, Andrew Morton , David Windsor , Kees Cook , Hans Liljestrand , Elena Reshetova , Davidlohr Bueso , Manfred Spraul , Mauro Carvalho Chehab , Bjorn Helgaas , Michal Hocko Subject: Re: [PATCH] ipc: Convert kern_ipc_perm.refcount to refcount_t Message-ID: <201705280516.bAHdBQAm%fengguang.wu@intel.com> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="MGYHOYXEY6WxJCY8" Content-Disposition: inline In-Reply-To: <20170527195947.GA28160@beast> User-Agent: Mutt/1.5.23 (2014-03-12) X-SA-Exim-Connect-IP: X-SA-Exim-Mail-From: fengguang.wu@intel.com X-SA-Exim-Scanned: No (on bee); SAEximRunCond expanded to false Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org --MGYHOYXEY6WxJCY8 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline Hi Elena, [auto build test ERROR on next-20170526] [cannot apply to linus/master linux/master kees/for-next/pstore v4.9-rc8 v4.9-rc7 v4.9-rc6 v4.12-rc2] [if your patch is applied to the wrong git tree, please drop us a note to help improve the system] url: https://github.com/0day-ci/linux/commits/Kees-Cook/ipc-Convert-kern_ipc_perm-refcount-to-refcount_t/20170528-040601 config: m32r-m32104ut_defconfig (attached as .config) compiler: m32r-linux-gcc (GCC) 6.2.0 reproduce: wget https://raw.githubusercontent.com/01org/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross # save the attached .config to linux build tree make.cross ARCH=m32r All errors (new ones prefixed by >>): In file included from include/uapi/linux/shm.h:4:0, from include/linux/shm.h:6, from ipc/util.c:44: include/linux/ipc.h:25:2: error: unknown type name 'refcount_t' refcount_t refcount; ^~~~~~~~~~ ipc/util.c: In function 'ipc_addid': >> ipc/util.c:235:15: error: passing argument 1 of 'refcount_set' from incompatible pointer type [-Werror=incompatible-pointer-types] refcount_set(&new->refcount, 1); ^ In file included from include/linux/key.h:26:0, from include/linux/security.h:26, from ipc/util.c:52: include/linux/refcount.h:28:20: note: expected 'refcount_t * {aka struct refcount_struct *}' but argument is of type 'int *' static inline void refcount_set(refcount_t *r, unsigned int n) ^~~~~~~~~~~~ ipc/util.c: In function 'ipc_rcu_getref': >> ipc/util.c:400:31: error: passing argument 1 of 'refcount_inc_not_zero' from incompatible pointer type [-Werror=incompatible-pointer-types] return refcount_inc_not_zero(&ptr->refcount); ^ In file included from include/linux/key.h:26:0, from include/linux/security.h:26, from ipc/util.c:52: include/linux/refcount.h:47:26: note: expected 'refcount_t * {aka struct refcount_struct *}' but argument is of type 'int *' extern __must_check bool refcount_inc_not_zero(refcount_t *r); ^~~~~~~~~~~~~~~~~~~~~ ipc/util.c: In function 'ipc_rcu_putref': >> ipc/util.c:406:29: error: passing argument 1 of 'refcount_dec_and_test' from incompatible pointer type [-Werror=incompatible-pointer-types] if (!refcount_dec_and_test(&ptr->refcount)) ^ In file included from include/linux/key.h:26:0, from include/linux/security.h:26, from ipc/util.c:52: include/linux/refcount.h:53:26: note: expected 'refcount_t * {aka struct refcount_struct *}' but argument is of type 'int *' extern __must_check bool refcount_dec_and_test(refcount_t *r); ^~~~~~~~~~~~~~~~~~~~~ cc1: some warnings being treated as errors vim +/refcount_set +235 ipc/util.c 38 * 39 * Note that sems have a special fast path that avoids kern_ipc_perm.lock - 40 * see sem_lock(). 41 */ 42 43 #include > 44 #include 45 #include 46 #include 47 #include 48 #include 49 #include 50 #include 51 #include > 52 #include 53 #include 54 #include 55 #include 56 #include 57 #include 58 #include 59 #include 60 #include 61 #include 62 63 #include 64 65 #include "util.h" 66 67 struct ipc_proc_iface { 68 const char *path; 69 const char *header; 70 int ids; 71 int (*show)(struct seq_file *, void *); 72 }; 73 74 /** 75 * ipc_init - initialise ipc subsystem 76 * 77 * The various sysv ipc resources (semaphores, messages and shared 78 * memory) are initialised. 79 * 80 * A callback routine is registered into the memory hotplug notifier 81 * chain: since msgmni scales to lowmem this callback routine will be 82 * called upon successful memory add / remove to recompute msmgni. 83 */ 84 static int __init ipc_init(void) 85 { 86 sem_init(); 87 msg_init(); 88 shm_init(); 89 return 0; 90 } 91 device_initcall(ipc_init); 92 93 /** 94 * ipc_init_ids - initialise ipc identifiers 95 * @ids: ipc identifier set 96 * 97 * Set up the sequence range to use for the ipc identifier range (limited 98 * below IPCMNI) then initialise the ids idr. 99 */ 100 void ipc_init_ids(struct ipc_ids *ids) 101 { 102 ids->in_use = 0; 103 ids->seq = 0; 104 ids->next_id = -1; 105 init_rwsem(&ids->rwsem); 106 idr_init(&ids->ipcs_idr); 107 } 108 109 #ifdef CONFIG_PROC_FS 110 static const struct file_operations sysvipc_proc_fops; 111 /** 112 * ipc_init_proc_interface - create a proc interface for sysipc types using a seq_file interface. 113 * @path: Path in procfs 114 * @header: Banner to be printed at the beginning of the file. 115 * @ids: ipc id table to iterate. 116 * @show: show routine. 117 */ 118 void __init ipc_init_proc_interface(const char *path, const char *header, 119 int ids, int (*show)(struct seq_file *, void *)) 120 { 121 struct proc_dir_entry *pde; 122 struct ipc_proc_iface *iface; 123 124 iface = kmalloc(sizeof(*iface), GFP_KERNEL); 125 if (!iface) 126 return; 127 iface->path = path; 128 iface->header = header; 129 iface->ids = ids; 130 iface->show = show; 131 132 pde = proc_create_data(path, 133 S_IRUGO, /* world readable */ 134 NULL, /* parent dir */ 135 &sysvipc_proc_fops, 136 iface); 137 if (!pde) 138 kfree(iface); 139 } 140 #endif 141 142 /** 143 * ipc_findkey - find a key in an ipc identifier set 144 * @ids: ipc identifier set 145 * @key: key to find 146 * 147 * Returns the locked pointer to the ipc structure if found or NULL 148 * otherwise. If key is found ipc points to the owning ipc structure 149 * 150 * Called with ipc_ids.rwsem held. 151 */ 152 static struct kern_ipc_perm *ipc_findkey(struct ipc_ids *ids, key_t key) 153 { 154 struct kern_ipc_perm *ipc; 155 int next_id; 156 int total; 157 158 for (total = 0, next_id = 0; total < ids->in_use; next_id++) { 159 ipc = idr_find(&ids->ipcs_idr, next_id); 160 161 if (ipc == NULL) 162 continue; 163 164 if (ipc->key != key) { 165 total++; 166 continue; 167 } 168 169 rcu_read_lock(); 170 ipc_lock_object(ipc); 171 return ipc; 172 } 173 174 return NULL; 175 } 176 177 /** 178 * ipc_get_maxid - get the last assigned id 179 * @ids: ipc identifier set 180 * 181 * Called with ipc_ids.rwsem held. 182 */ 183 int ipc_get_maxid(struct ipc_ids *ids) 184 { 185 struct kern_ipc_perm *ipc; 186 int max_id = -1; 187 int total, id; 188 189 if (ids->in_use == 0) 190 return -1; 191 192 if (ids->in_use == IPCMNI) 193 return IPCMNI - 1; 194 195 /* Look for the last assigned id */ 196 total = 0; 197 for (id = 0; id < IPCMNI && total < ids->in_use; id++) { 198 ipc = idr_find(&ids->ipcs_idr, id); 199 if (ipc != NULL) { 200 max_id = id; 201 total++; 202 } 203 } 204 return max_id; 205 } 206 207 /** 208 * ipc_addid - add an ipc identifier 209 * @ids: ipc identifier set 210 * @new: new ipc permission set 211 * @size: limit for the number of used ids 212 * 213 * Add an entry 'new' to the ipc ids idr. The permissions object is 214 * initialised and the first free entry is set up and the id assigned 215 * is returned. The 'new' entry is returned in a locked state on success. 216 * On failure the entry is not locked and a negative err-code is returned. 217 * 218 * Called with writer ipc_ids.rwsem held. 219 */ 220 int ipc_addid(struct ipc_ids *ids, struct kern_ipc_perm *new, int size) 221 { 222 kuid_t euid; 223 kgid_t egid; 224 int id; 225 int next_id = ids->next_id; 226 227 if (size > IPCMNI) 228 size = IPCMNI; 229 230 if (ids->in_use >= size) 231 return -ENOSPC; 232 233 idr_preload(GFP_KERNEL); 234 > 235 refcount_set(&new->refcount, 1); 236 spin_lock_init(&new->lock); 237 new->deleted = false; 238 rcu_read_lock(); 239 spin_lock(&new->lock); 240 241 current_euid_egid(&euid, &egid); 242 new->cuid = new->uid = euid; 243 new->gid = new->cgid = egid; 244 245 id = idr_alloc(&ids->ipcs_idr, new, 246 (next_id < 0) ? 0 : ipcid_to_idx(next_id), 0, 247 GFP_NOWAIT); 248 idr_preload_end(); 249 if (id < 0) { 250 spin_unlock(&new->lock); 251 rcu_read_unlock(); 252 return id; 253 } 254 255 ids->in_use++; 256 257 if (next_id < 0) { 258 new->seq = ids->seq++; 259 if (ids->seq > IPCID_SEQ_MAX) 260 ids->seq = 0; 261 } else { 262 new->seq = ipcid_to_seqx(next_id); 263 ids->next_id = -1; 264 } 265 266 new->id = ipc_buildid(id, new->seq); 267 return id; 268 } 269 270 /** 271 * ipcget_new - create a new ipc object 272 * @ns: ipc namespace 273 * @ids: ipc identifier set 274 * @ops: the actual creation routine to call 275 * @params: its parameters 276 * 277 * This routine is called by sys_msgget, sys_semget() and sys_shmget() 278 * when the key is IPC_PRIVATE. 279 */ 280 static int ipcget_new(struct ipc_namespace *ns, struct ipc_ids *ids, 281 const struct ipc_ops *ops, struct ipc_params *params) 282 { 283 int err; 284 285 down_write(&ids->rwsem); 286 err = ops->getnew(ns, params); 287 up_write(&ids->rwsem); 288 return err; 289 } 290 291 /** 292 * ipc_check_perms - check security and permissions for an ipc object 293 * @ns: ipc namespace 294 * @ipcp: ipc permission set 295 * @ops: the actual security routine to call 296 * @params: its parameters 297 * 298 * This routine is called by sys_msgget(), sys_semget() and sys_shmget() 299 * when the key is not IPC_PRIVATE and that key already exists in the 300 * ds IDR. 301 * 302 * On success, the ipc id is returned. 303 * 304 * It is called with ipc_ids.rwsem and ipcp->lock held. 305 */ 306 static int ipc_check_perms(struct ipc_namespace *ns, 307 struct kern_ipc_perm *ipcp, 308 const struct ipc_ops *ops, 309 struct ipc_params *params) 310 { 311 int err; 312 313 if (ipcperms(ns, ipcp, params->flg)) 314 err = -EACCES; 315 else { 316 err = ops->associate(ipcp, params->flg); 317 if (!err) 318 err = ipcp->id; 319 } 320 321 return err; 322 } 323 324 /** 325 * ipcget_public - get an ipc object or create a new one 326 * @ns: ipc namespace 327 * @ids: ipc identifier set 328 * @ops: the actual creation routine to call 329 * @params: its parameters 330 * 331 * This routine is called by sys_msgget, sys_semget() and sys_shmget() 332 * when the key is not IPC_PRIVATE. 333 * It adds a new entry if the key is not found and does some permission 334 * / security checkings if the key is found. 335 * 336 * On success, the ipc id is returned. 337 */ 338 static int ipcget_public(struct ipc_namespace *ns, struct ipc_ids *ids, 339 const struct ipc_ops *ops, struct ipc_params *params) 340 { 341 struct kern_ipc_perm *ipcp; 342 int flg = params->flg; 343 int err; 344 345 /* 346 * Take the lock as a writer since we are potentially going to add 347 * a new entry + read locks are not "upgradable" 348 */ 349 down_write(&ids->rwsem); 350 ipcp = ipc_findkey(ids, params->key); 351 if (ipcp == NULL) { 352 /* key not used */ 353 if (!(flg & IPC_CREAT)) 354 err = -ENOENT; 355 else 356 err = ops->getnew(ns, params); 357 } else { 358 /* ipc object has been locked by ipc_findkey() */ 359 360 if (flg & IPC_CREAT && flg & IPC_EXCL) 361 err = -EEXIST; 362 else { 363 err = 0; 364 if (ops->more_checks) 365 err = ops->more_checks(ipcp, params); 366 if (!err) 367 /* 368 * ipc_check_perms returns the IPC id on 369 * success 370 */ 371 err = ipc_check_perms(ns, ipcp, ops, params); 372 } 373 ipc_unlock(ipcp); 374 } 375 up_write(&ids->rwsem); 376 377 return err; 378 } 379 380 381 /** 382 * ipc_rmid - remove an ipc identifier 383 * @ids: ipc identifier set 384 * @ipcp: ipc perm structure containing the identifier to remove 385 * 386 * ipc_ids.rwsem (as a writer) and the spinlock for this ID are held 387 * before this function is called, and remain locked on the exit. 388 */ 389 void ipc_rmid(struct ipc_ids *ids, struct kern_ipc_perm *ipcp) 390 { 391 int lid = ipcid_to_idx(ipcp->id); 392 393 idr_remove(&ids->ipcs_idr, lid); 394 ids->in_use--; 395 ipcp->deleted = true; 396 } 397 398 int ipc_rcu_getref(struct kern_ipc_perm *ptr) 399 { > 400 return refcount_inc_not_zero(&ptr->refcount); 401 } 402 403 void ipc_rcu_putref(struct kern_ipc_perm *ptr, 404 void (*func)(struct rcu_head *head)) 405 { > 406 if (!refcount_dec_and_test(&ptr->refcount)) 407 return; 408 409 call_rcu(&ptr->rcu, func); --- 0-DAY kernel test infrastructure Open Source Technology Center https://lists.01.org/pipermail/kbuild-all Intel Corporation --MGYHOYXEY6WxJCY8 Content-Type: application/gzip Content-Disposition: attachment; filename=".config.gz" Content-Transfer-Encoding: base64 H4sICP3xKVkAAy5jb25maWcAlDxdc+O2ru/nV2i296GdabuOk+wm904eKImyeSyJikjZTl40 3kS762nWybGdfvz7C1CSRcmgk7MzbWwCJEEQxBdB//Svnzz2un/+sdqvH1ZPT/9436pNtV3t q0fv6/qp+j8vlF4qtcdDoX8H5Hi9ef3744/z8da7+P1s/Pvot+3D2JtV20315AXPm6/rb6/Q ff28+ddP/wpkGolJmZyP85t/2m8TnvJcBKVQrAwT1gHuZcr7LakshcxkrsuEZdD8k9cBANFb 77zN897bVfu2x/T+5mw0ar+FPGo+xULpmw8fn9ZfPv54fnx9qnYf/6dIWcLLnMecKf7x9wdD /Ie2r8hvy4XMZzAtrOQnb2L48oSTvb50a/NzOeNpKdNSJVlHuUiFLnk6L1mOkydC35yPW2CQ S6XKQCaZiPnNhw/dupq2UnOlidXFMmDxnOdKyBT7Ec0lK7Ts6JiyOS9nPE95XE7uRUZDfICM aVB8b29If6QD2fYwNtlDBByMWBZsEytiXU6l0rgnNx9+3jxvql8OC1R3ai6yoKOjacC/gY5t UjKpxLJMbgtecGKqaMrSEJhu9SgUj4VPks0KkHobYiQBJMPbvX7Z/bPbVz86STjINQhOlkuf EyIPIDWVC0tOoCWUCRNp18byYIpUKeintUi4jCLFdSuIQVZ81KvdH95+/aPyVptHb7df7Xfe 6uHh+XWzX2++dTRpEcxK6FCyIJBFqkU6sZfuqxBJDTiII2BokgmaqZnSTKsjRuRB4aljRmQ5 50mmSwDbk8HXki8znlOSrWrkdkoYYdiEVJS9JhwQCItjPDaJTPuQlPOwVHwS+ObsH2B+IeKw 9EU6tuRJzOoPxy2GP11zLHGECHZRRPrm7KJbs0j1rFQs4kOcc+t4T3JZZIpkczDlwSyTMAyo JKVlTokvng6VMdiwjqRCqzK1vuO5MN9tCc+hiRgvE2Gvb8r1oK8CukKjVAztJOlwCiMFpxg2 PmCahyQS6Fl2R0L8eAad50Zn5iFBZRCUMoODIO55Gcm8BBmCPwlLg95BHqIp+ECJWqsz2uOW gtYUqQxtpvpZZA/tlNsE9JZA/vZ4Buc2AXk1U4F80kQAyxp4r6+h7kTPWsGhWsgtemeArO6S 3ta1bSXzlYwLzZFxoAyIQQ+oPphCs1VazC0FVou3fYiso8LjCE5gbqGbUaIitrgcwfxLq08m bagSk5TFUWidd1yg3cDnPNWmoROcLDrBKCYsO8jCuQCaGmyLcQlPfJbnor+D0MjD0CHJWXA2 ujhSho0LlFXbr8/bH6vNQ+XxP6sNKGYGKjpA1Vxtd52WnCf1kkqjmHubiV4A0+BaWBxXMfN7 chIXtM1CxDICBYpqr8zB3MnEdWo1T8qQaVaC8yAiAYcXPAhK5nIZibg2Hk2TrNv4zY+e13Bo tkg1gE8XPnhELIaNRn0SoM2hNg1t34IBW1CNZSyHTWsdnv5RB80P+jKXmgegLKmjKcMiBiMK p9OIKEq1JdETzXzwtGLYBJCH8YBcQ8eUqSnJOnRd/QIOViYodQX2FhxUHgFHBe4wmO8jfpgJ 5uDW1guh3Q/EQZUm4XC0PlS+WP5XyK135e4EywQiwD/R75rDQq9ZPESv3eVAzn/7stpBHPFH fTJets8QUdTuyfGIiN/IGTCnf6D7nGudKQgA4KRMeQ4spjQsnAORRpYOwDACtVBPz6OmUgkq 4dFAcOwtaxYKViVA+84oK9XgFCnCLQVjdz0A7ZEb+abdgqY7OEMHB9/BnBZTTE6BUbfkg7PX uXq5SIBGODFhOUN7QCzTRDbodIEhUsKPbbUPgYilsmI/ZJENBYMYKAEHEbxz45IduQC+oom3 4C5fvfMiNJ/kQp/2NTDWpLU7YgRJCNqO1/ond6ItfPpUmZUCC2XG4qODka22+zXGx57+56Xa 2YcBptNCmz0O5+jdkGKmQqk6VMtARqLXXMcq0lMP3yuMeG3jI2Tt16VS2kFr0xpyZtZ/DAmi W3vb2sCt7XAitnP0RAJO9Grmvfnw8PU/h2gwuT1BqQWc3fl9q94C/OiWmLNIRWp2XWUiNSfV CPOhN9rU+7401Bu6fX6odrvnrbeHDTUB2ddqtX/dDjYXfCpMY/RNRh9cqHzuhibn48+jUUHL nMGQmcpOwtlMnY9pge7oo0P4Dn5OeQgNgeAZFb2THUxF1lDuCHtq+NloTAzbQS+OBp2HPKBJ NWDkBaW+wHQ3+aj+0tAIge4YiYBykG2UM9EPbG3YmO6OzkJgBOryYmT+9fzcMhRzEfKbs/GV tQpwI2KhNShtnoaCUY4ZeK8yv0MXItc3o79Hg8FbMARCCD3rQ43tDYWCr1pMABfmYT2FbgMt Vx7Xi/ESjt9k5g7xIxwvExNlQHYbU/Xtty+lxo5onA0KZbwzWHmZaWQZMkLdXJt/FtOnd+B/ hWFe6tq3JEaZCzD5WiL37ZxikhTGignwk4zF40v0Rm/OBm4JuqGq1FNw0RaMkiWzWoipzFbN kp6ExhwUOAN1Q0rofSYlbcXv/YLS+iJnSbfNo8+9jayBzSaP6m0+OD0LBbxufSZUbUO9VmMs g+kE2AmWfSLBek7pmOHgrolYTsZlcU4fwCHapwtiSS1N0wUXk6mVoWkBEKkJP2cQt4aYO7Bi IaPFZQIiEuWYwzVpk76ub5NQENzTW9AizCE0ToGxd9Spr3HsOLjuZGI2W6ZA0Nt8T20V/Ned 9/yCdn7n/ZwF4lcvC5JAsF89DiroVy8J4H/w6RfANh3Carf+tlmsthVgCggY4YN6fXl53u5b FGznm8eX5/Vm3zMtgUAVYbjgiFgD1s+smO787+rhdb/68lSZXL9nAte95SagA51o4Hcusr6/ VgNQE7gddSYL6lQ2fRPQLXbIm/OwSHqqRPe+wJGdoOPaejZptf/refsHxBMtn60MJERUvEdw 3QIKjU1o07/sJczguwt3GeW9k47fTYaNZISBqsIHEY1FQPukBicRExT1E4NoiM6VFgHtuiOH ZpwSYpH2WYEWFTV0wBS9eYDQ+p9lDnvIqegakAwMNB2DOCAczJCldKrQbGQmTgFhl+HAJwUd gtY4pS5SCFQdeY0UxEnOBHdzSmRzTfthCC3CkxMgSiQLmncIZI6sAcK4otcuarIwPHPDjSCc oMwgHcOPhkjQeOucpQov1+xbqz6GGckJ9jkf9sUzM2jSQdY29+lELg/PWB8jZ4s3MBAKwqJ0 LumzhbPDx8mpiOqAExS+sHRSG4S0cIhCXr+sHz70R0/CS1fIDVL2ySVBeLUIQWKQsJxO/uDy Mp015yuil9cOBN6Q8SRBSSRg4im9BaiRiAdW8tAIi/WLk90OHDzcQ6GFAi0MpmNfbV13v13/ Tn8fgeATRF6zmx8UZQ3w6ILKiWju/rq85DECOCW9qTB9naZwHhx5OEDAOx3oHnI6PgMMk06k Eibd/MsaB+Y2DFwa07vzHp5/fFlvqkevuZmmmLfE2CufDbvuV9tv1b4XZ/b6gF8zATkyd0uq SN6g7oDeiBy9Hx1eqALaLT5GncZvDTY9dRKOsEUYcxM6vbsH7OA7aW0YfXK0NHr/eGnUSuTJ IdH8c4dJpvAB+/24WS6XThVyjA5H4b8YPMgSR0LRgS4zjRnknvD05Brc0IfvlVuuE6YhwsDw T99l76C0xvez6K0tqxHxPpmDg+/asQaLvEojEMMgyN4YCxSL+36Vwn/H0asxeZC+MbfLJSFQ 8UbEVLO8b+4Tp75GOOHwkNjgskzevd3xWL+TRzFPJ3pKmYwOxdTwnMJIWPAG/IRaaVBM5kTm 71ACdYc0cpZtENhSRe9GXaTv0a018nFscwJ3pvHIvsGI20Jq9t7pCcV5ApmzOHlj9pwH9J0S gasC/dbZPkRu7xwRNGM6OSlKtcZ9Y1o0j+9loSuRA5GW4s4ocX5cEiSy/z3hE9r+EnjXOTM+ 8gVNZVQqaYL2UyhhkZ2Eo9/GcoeGqcHD7h005//mQT1/tx2wbgCJ7ODL2RwBSGOapsSQNsJA LdugPKu3540RtI6HVDUO/qC19S/MaobABDSqfYvf61ITSUGIySFaGzYB5w9sGgJoWgHQkWRz B22oU0QDTcPy0HHPCXaHTlxqOu85NCVdIiwX4YTKYJsMmAlRFRtEXNhEDjaPWVpejcZntyQ4 hO1wHMY4dlyFiMxxk69ZTHvby/ElPQXL6IvXbCpdZAnOOa7n0nE+ua5zufRyA8dFL2wSM1ek JFhmPJ2rhYAjQjO51ipOf9VEiM6sQ5LFdM+pcprLsqbGGTticHIOUq/qONyNlQaKqjcxqZIl 3nLclf2yKv82HqRLvX212w9qMEymYaYnPKVXxpKchULSV22M7iTykJZxx5U5A/2xzF2nMipn gaOISYNBT4iL+ga+EFjfrXq3UEE0QaE8o8Vc+EfAmlltr01VPULk/ex9qbxqg/HKI2bOPfD/ DIJV9960oAdgXGdoWTYXNd2MCwGttPqKZsJR7IF7dk2rpIAJ2s0LeIZ+LH2q0ojmfaYYyLzT kShFRMPixYk8Zah0eXQ51sAgDAJK6xq9vtbkczybRJeE3ZkqrwajFfmw+nP9UHnhdv1nXfzQ 1fGvH5pmTw7vDoq6Km/K44xbrxZ6zSBvEC7YhfswtU6yiMr/wOanIYtl2qunrIeLRJ4sWM7r qmTrinVhqoxsAg6oIm3KtKzSjyVE7AeMHmGHkeoq4Ib+iMWxP0h3tYctjuXC1MhYdzKd5QRH u2TqLg3KMBdzZAWWujsS8aqcgq+fz4WStHY8XPVlBU4pAjKDlvNJ75a5/l6KcWA7CVgPpqaw /hCrryOiUgPv5B6NUPQyC/AnPSoi7DS+ps2TpHIJoIdMRt0iq2kqJ8pxwBo4W15dfb7+5B60 PBtfXfTLqYBlVBVVWsQxfqEVcIMUwC7XdfPElC1S3KsPslvLRKTNNegVMXh+l2kZD4p7jtDC 3KcS8od1+KHNybY5Z1QiMwhzmaAdC8J52LmVveZGMBSQTIIXRinZLMXiWIlizjXtThyI8mkx SecJLx261cBqh/pIVpP17oESVsVTOEwKHzSdx/PRmJ6VhZfjy2UZZpI2t3Cskzt8fEIb70Bd n4/VxYg2kTwNYqkKUEUKz3bguGdjWaiuwf4xh8ckVDy+Ho3OTwDHdM1QywMNSJeXp3H86dnn z6dRDKHXI9oGT5Pg0/kl7VyH6uzTFQ0qlN+4fWWk2PXFlYOEgSx3Omk8TAPVN/Yc1G3i7Q51 Ad2mGAjI65j2tRt4zCfMcQ3dYIAz8unqMx0DNCjX58GSvthqEESoy6vracbVcWGwrv5e7Tyx 2e23rz9Mffzu+2oLPtR+u9rscFne03pTeY9wANYv+NEl/mgAjoZnmHhYeVE2Yd7X9fbHX1hQ 8fj81+bpedXesPQKkDEKZWiks+NaTbHZV09eIgJjOmqPofUjVABu1nHzHFTecWs30PR5t3cC g9X2kZrGif/8cig+VPvVvvKS1Wb1rUK+ej8HUiW/DN0fpO8wXLdvwdTh3y9jUyPtBLKoaD0B mVHG2wTCWNzWXQubL3VFy1O12lWADm7a84ORB5Mr+rh+rPC/3/d/741z/b16evm43nx99p43 HgzgPeIa7IrWkKOyzgRlEBGomKbeHiJoEvaIg+84VO/C+tBKVvxb8wThsb00zfiMwZf4FiHP Za4cZMIENK+RAnwDVwoZaPJ2HxDwrVoZHUpkkE8P39cvgNWqjI9fXr99Xf895Fzjh1FEYXUj vrY6af1gjMF73EZ4IWCtjZils9qjjLXgiexVjuRMIJd1TjrS0MEuAoPu9WvhTjtgWxPD0/rW zHlLvYmwMQZ8NMto6K+LfH8G7fTHr95+9VL96gXhb6D0frHKphquKEsWgmlet/Wcw7ZVKjJ/ fRgop/wglYNMpSH5+OUw3YSaTgVUetIsHT5jwKLVEV9jOZkMSgv6CCrAtAzGBrQg6FbB7wZC oDJRb/rRnFFwLA19DGH+/waSYuo9KBAbw58TOHl2UjiBRQvznqinOgxEu7KXBoolsfWTQPfk RaSmAe3t1UdhWMAxANPuq4FJFTYFsa4giNadCaHr7LakfjgKWg0Tz/ajl7DESnvmiLhCowdG 5IwGdDYYzLTRHlYDvbikHZakLVdmDv8eEIyqcDwncWUxDhFOYkJ7bb/v7mD98NWhmGwMV5WO mSYScjCgQa+f5WBWnU3ASuMXukIIOpi4rQueoEWlLFNTqQcj6ymEf6AmIbQXMnWpBRzRWQMN QPC8XKBEoJl0QXFLXbB7ntO+DI56cq8Nx1yvlAFY54Bc0ChmgwJMG4ovLB1ChFx256sBirdU C+juCLTC5I1HT21Zj+NNuSlrEr035WmD3nMIZBo6BAejSVtA+G3BYnHvvkEuNXcEPgkL8BqE hM2XLgj0UtwRZHONNk26c5iYM3cSikA0ijqHD44F6YKmCtrLuWGl+cEPBwVzV2ohjQfJmdpj x/RuFys99t37cA1x1frLK/5+i/prvX/47rEt+ID76gFfJFno7VbpKSYTB7XWtV8BwRELUO6C aS8nUodMWjmk6dA7Yff2AzUbBAKSgr2hgXnPEbUhBegEyhIZJrOQD34RAMTCP02jn0sWBrJX 0e1f0CG0HyToJzsUwABwPBW/x3dJ5Irx+MY05Gp8uVySoITl4Gr0fI1knrguahIURFb6jhrA w6AiyPv+y0xdXV2elQn5xt7qmTIQiESQpMLHXKYy4ST06vx6ZAPGo9Gop030VDpqJ9ohUN9g MtMm/BYaSg4icLprDlsKXh9JWY5XhTkJUixRRf/XVNRy4vNhopDoyfktPaSMWQ5WJKfZpBLV OxcqCa7P6KQVol6f9YHEgBp3W/bG1Akw7O01zB1HdyHu0/5rg7qlXFyeOR4AHhDOR5THZ9N7 l8oMvOTeO9JFUC7jyWCXLe9NyOZigU6+T+9cF2JZ7HilkGWOX0GJiYJGTPf8tls/Vl6h/EMM iVhV9dhcHCKkvZ5lj6sXrJw5ipYXYPo6luO3g1IME81nDpjua249dbqQ/W6JrY9skKUwCWiA DwZp0EDHDUG5Ej21g78FRT66szt2KpAC8hACGhdnctZcFVIwjibOBbSTEDbA/pEhu1078O/v Qlvt2CBjHXmasjYDwc09s7dY41Xxz8dPn37B+2jMou2/t1idpe+OmuuyXoU0IJ0nRxItNi+v e2dSR6RZ//2vaSijCN+Kxq7fHaiR0NVylT/UGMrc888S5nojg0gJ07lYDpEM7cWu2j7hA+01 /hjL19XgbqXpL/H3D07S8W95dxqBz9+CDw6hxdqja+teTwgxfMnyXtasbQNVkF1eXl2REw+Q romj1aHomU/PcKvPRo7rFAtnfPbpDZx4NnNcmB1QdMA+XZzRYbuNdHVx9saK4+Tq/Jy+Zzrg wJH5fH55/QaS4/Fdh5DlZ2P61uyAk/KFlvR5O+BgERPGX//f2JU1t40r67+iOk9zqm4mErU/ 5IEiKYsxtxCkJOdFpciaRJXYcsl2ncm/v90AF4DsJlM1Mx6hP2JfGo1eeooTWbyzd8yFtUbl UW9n77N78ilWWxKaXAd/HhJhEUlwO0gElb56cKlkuNv68DdJKCKc+HaCJo8U0XlITHuimiRN eaQ5rMEdV3S45Ed4q6F5hrp4D88sn2Et6tLi3NnckzrxNWiNPhqbNylFFl7q25xPFwTYSRJ4 spQOENxOpss5fXNRCOfBTmh5i6JjrzTf1BqQrdjv93ZXJtWQ9eRU45D96dxqUXWaFucriFQx ZRQQFQC7TsDFhtFwKya5z2hopKE/aQlPFHd3vD3KB0b/YzxoSrZhVDVWSP7E/xYWlzXbKAlw sNELUJGBSVXLrfFZau9oXlRSi4s6fNkBAmrISRyLbFKHzSOXEJJ0Z4ce+Yjt/Djejifkcmv9 huKbLNPM/LcaQ+UoEY4yWg2knzKhI0tAnbbZaWm1sCXTCGiKzoi00AJ8uTgk2YNWjHo8ZxML dRhrOjN70A7QC4FSA0sZLZHDnaDlYdIU6yBoxTdgMpRnjvo+5G3vIanV5+J8uxx/tcU/Rf0W 1nRYi321RM2rY+FcTDRnYYlcIxtP1VIHRekht9NMfJpQ1BRdlIZeBSHL8fbAGnO++Yyq82uj KjCzFou2jkJ0ff6AdEiR3SYvbYTSRZEVVjfwM9KRiUKY7hGLRHRDAyMbEx1aksqZ2tUQ4TjR nrmSlojRzBfzPSMsUKBis/ic2XfYnj+A9sJSej8tyGsRHIKkLxPp9Sun+SDplZKRySYJy4En oX9QboDpT2GD6HCbmI6XM/qUlebqUhWCXskO/JsQFyo4J9v3KEszJoMfB8mmmf7sMFm5imyk bQDqbQ0DCkhueFTQKIVSaOE5uqpUdbqhPsur6YpEVlr6/R18Q61Kta8M/nq6vr79+j04P307 P6J842OB+gArClUR/mvct6Bs10Pfn1KxtVPTALExzxIjOXHs/jySvY3+Uli68MOMeUlA8h7d YLY3DO9fOM6eYacAzEcRYocdC0kOcQ+X9VBKnXw9C6XPAH3jsKjMjgVcJtuTKn77AWXXtdEG qVkTkTGeRCUxsLeMQoocPHxfbLJGBAS9CvVAuEUuGIdpApYxvXwF42EtaZurJVkyOP26nn5S uzt6XxjBdVp57mqPuZLJFCJElCqw3hg04czx8VF6/4O5Igt+/Vsv8i7xY04guaPvlUm8w7W7 ZbZISYVVwzDIii5yuGFQBpybneFXW/48bH1DLVclFlNhQ8hAo+MbTDxq+lUamO58MqI3VQOy IKpYA8LR0BrpXIxOmOpVNkm0iMHEUOISAzEeMQUsrUmP+qmbQdP+BENPAAMz41h9DdOnDisx tAJohRHOfMYIOmpM4rFcWgHJ9kl3Jq6YWdSzQE0fzSyy69fz0WI4pS1hdMzCWjNqMxVoOp5P SZ2fAnEXTEcLEVK1AJI1ZFj7CjOfDekrtYboHteNv5mNxl0d5WeLOVXBz86kO2vYIdKR1aOJ LbV5GMv8CpM51nLSPa8kZtlTVuZMRtPuaYMYa9Rb1sSyuhsvMf11nliMvNPEdNc5tPej2XA2 7RhECRktqXGUpBktCNUxy3kfZDYb02JQA9MzaySmRzVfYvrrMx7Ne2ZE6CTjYc9ulDkzxgq1 GqNwRsuIa8Cccn2qkaft0wdS52TqgkpdDMnUMZlKHmmQPu+s5HJIf7bsWQnhsq93llNr3NfF gJn0LF2J6V5yibOYj3uWHGImVvfsijJgoTdeGvqC03ysoE4Gy6u7CxAz7zk5ATNfDLv7GjHL YXdXJs56MV0yLGHIMtPF12KT9awXQIz/7UM4PYd36I3m4+4h8EJnNGGMgDSMNerHzHaWabHU rHAonMk8JLmFktazChRsNe7ZtYSzmc72e8K+rg3NMjHvOc1EGM5mPQyZ64yshbtgnsJqmBgN e85FwMwXVk8+0NuLnhnkR7Y17D5JEMJKpSrI2Ord25l3jwqwCZ2ewygLk1HPspSQ7lkoId1d BxDOsE6H9DR5m40aRuoNwG4xni9GLjXXkbQcdXPmEsMYFxqY7v6QkC6OBgDBfDHNBFNRIM5I Ab2GmVnzzZr5Hmjehr4EyI2feXfboYcVl/TwJsRKD32gpOvX58vpdSAuvy6n6/NgdTz9fPl1 bFiuCUoVceWEdiu71e16fDxdnwavL+fT5Z/LaWCHK1vPDD9r3bPD919vl3/en08yukChoUHc usO1y8tskCifEofMwkSAvU+s4Z5/4QOIay+HzKWlItNzpyCPmAWLZDgzxvs9XwE4mQ6JLXyH L+HeC5OAnt9IXiwSYMb4Gig6vZHKGgKrPZnO6WOiAMznM2b5FIDFctiRQTbjjiFJ9qK1NVqF /AilXkb7sEUisBdTGCC+emk2HXaQhT+Zz/bd00yEU2YjlNT7hwV0IeNgfLWfDoc92T+g83qW nPlwio3H0/0hEw4cnywwSMbLCd9SyCcI6Y7MEjEbDaf0OkLidDjnF5kCLBi7lRJgjfg5gFVL gFPuKcNimIYKsBxZnWt9F4ys+bh7NIJwPO2YL1nI6S3jdpP6X+PI7q5DuFgumXcZ7y4PWNMm qSYoJaDUW/Xd7fjyA/d2Qj7spm25u+0kg7/s98fLdeBcq8gg/+U9oUEm+LpPvDhJ1Pp2fDoP vr3/88/5VmiGGXv5mvOR5NzLl4ND4LhU4yrk9s5G/3Rt3Qao8ev1l7TDhrPsd3GQtF+qIAPy of3OdjAoaryW/uNj1t+IckXgNJ/vjWT4G+RhJD4thjQ9jXfikzXVTts4j9oO7ze+227AxnRe Dj/RxVTmybgaqfQMSR8yvsupX+Qbn9LlwKxrS1vFOeAJf/wla9Z6nEe8PWkqDclUJyVf8yQN tYVaH+So1Mp8sfKCe91ADdMc4I7Sh2aaD78emnk7cgkxeddaWsY30HV3cZT6jGU5QrxQHNY0 6ybJgefElDWDJH6991r1vPPClc8oYEj6mnk3RCLkx2tgScAD35SdHWSMKxRZ8EPairxnAHy0 bWGa6metwc52frQh48WolkTCh1ltRtRDSuDI5yC2GoEXxduYyRYV+aipWqbjD0ZzvoIww430 NA+BQ05s1+pC3S0nwy76buN5Qee0Cu0735Eqah2Qh3XQCA2ok9GoAvc9c/GEMeoqtGelNEns nloRE6sAabCve7RyHFITO8JrThB3TPvEy+zgIWLcnyAAVn3AmB5LOmpTpnHEhaaQmJT1coZk YftdzSiMbXg6vjSxRv8SkeHAw87L6A9ITB4lASM4Q3rKPTjjEkblQrhx0O84MvfQTrPP8UNn EZm/pdkgSYwTwb2oSfomzUWm/AiyoBwPrUMiaFZMbVYOo/qC1L0fhXwV0fa2s4Fo9ADLg9/q 1N39sGF0EuRZFhAv+VJhxTjeq2+kigt5IKOXnnjj+GacLc3pG3rxUcyTmVgFONo4BvPQ0GVV RgeQRplqYnry4/fr5QTnf3D8TeuKYGnJhnHdHieSvnc8n9Z1Quqd7VIOpmTx1/9JtvIXFvtb 6jBgUMIPDleTPEh8VlMj39FjFnKXUDjhWdXeyNvBecP4b1XhY/2VH3Amz2nmqDAGJNUNbcLb nDKgDe1VvtZCCtUsJTq9w/CkdJXyveuLhLMeh42Y8YUog5QptbF2bbaXG9SDGg38zI+hb817 U+E77HS7vl7/eRtsYDRvH7aD7+/n1zdqbSj/fHgFTtj328xm/X5sdmVEMXqEbT9YxW11qfT8 dH07o+8iqmmpF8YZOpJq+xFJX55evzcXkgDgX0Ipo8XPAwfVzGrRWcP/USVbE1enmdHl73Df SK97IY/2Pu+vC+pwYE5pJH1lIjsl6HFgu0492hGbt0fbdW7xxCk913zmKp3sKHbZhgsosDzS NWmU6kHwfAyaxa52qVPUZxm/DttjiLuZeP+m9AIN5afCGSS33a2c8HCPcgDYiSwWhcpXqORn LaIQdcEYr4s6CvOjUcgOO4y1Wei093o9+vfT9fnydr1Rqy6120vdfn68XS+Phm+yyE1j8uBy 7b3h/X3b0PnWFi+jComWLQfzZqsEDug4zZBWaFHo6nFFVOvT2kuSgTX18RQUw82pGaD7Ithn lnK7ZCYc9uh1p52cxMLfw2EQtEnCc3L0h2FQxs3Mx3wuYzaXSTOXCZ/LpJGLvrIn6EgR/a1w Nz+J4cx1P69cwx4Ef7NgqES4avm2TD24fqdAY9wOfeZJe550t0ZrJ5oWOx3EVdZRl8gPOj5d W60v65aTI4MsnRmVvUwr3OXQzuxkdPLCg45meIaWHRlGWm3QtTXADHZFj+IMIy7V8q9mgq8S pMWNkbWtCGTH8HE0JKXhSU5jZrJ4LSZsd6MBFzfEwMcAE9Qgq/3g2IzpsxYt90CKLD2qfXS3 rtwpWhuFL+LlbDY0FuLnOPBN1wNfAUZOitxd46dP+u8oqNy9ubH4uLazj1FGlw40o2QVkVtP 2TYh+LuKhB27HjJbnybjOUX3Y1Tgh8P1038ur9fFYrr8MNIdOmvQPFvTovsoay0IdT69nt8f rzLaZ6tZtdM7PQFfUTLDMl8mOxs/cFOPmsvonFrPRvo1M6QeOdxHArjW2GTkBPVH1r8eIjTO k6sLcsvg3qDnF8uoQPzeYbsdtDVP23SS8JrLbmUdtVnxpI6vHGA8Oe9wX3JbbBjitmOnDn0M c9pDRL8ucDchQlDX/R92dFTC075E+0kndcbt6mlRZD3JVAo+MaD77we1iTfJcVSl17MZNb9Y /+VbrnY5V7XSBsCcqyWxUWv8vbUav8eG8yOZgqcXvc6RzAW/EWzc6rXQPGTjr3apbk+x7oGM mnMnzRUTNArVzL2x05s/4Xuz4UpZSts38ihNTI83MqXD06GMcMCtIJ9jLZyE/SZ2bX7n4GZA oI9wIMrd+tN/Ti+w5f9HJ5VnwQEIxgDoNE6FzgQxeocGaMHoVDRA9GWoAfqj4v6g4gtGj7MB ohUFGqA/qTijddIAMWvKBP1JF8yYCLAmiFaTM0DL8R/ktJySPpTMfCx2pi0nf1CRBaNshyDg uJBhOTBciZ7NyPqTyQgofuRt4fhkQBytJqNmY0sCP1dKBD9RSkR/R/BTpETwo1oi+EVUIvhR q7qhvzGMAZYB4ZtzH/uLA+PvsSTTWjJIRqdjcEYzDEaJcLygEUWPgESZlzMOQCtQGgNT01fY Q+oHnPOPEnRns/5BKkjqMS9bJcJ30PMG4xigxES5TytwGN3X16gsT+99wbmbFPyFwg3auin3 59vz+dfgx/H0U0WUkqkvt8vz20/5lvD4dH79TonSpeH2fStCYX0BkEodQXwnvSlXB2h1XQo9 IXB3aCEmpe7K0wtccT68XZ7OA7h0nn6+ygqdVPpNq1PJekfoROSws9NIc3mgSQwUPcxFEU1Z u9sBa66+/DQaWhNd9pb6CWxSIXCSIcNGRuhrCumrmAmToQwrSU5j42FgH1FVqPGN8BwUN+Dd SUYMJHJoQlQHxFFgCKtUC6U/HUbOK1/NkWFmIoqoCqmwRa15FJ6frrffA/f87f3790ZsMnkI SI8PghOTSQhUTrT8EBuFK4G59HOtPcxjcIKitzK4PKD0Yh3Eu0oUgHUaBNfTz/cXNYU2x+fv 5lyGVefg1SKmRUYG/bC1gxyjfxlEXAdxnulBwWRYvAPa+3f0J35373nNgO+ydljnuksHf72+ XJ6lvfH/DZ7e387/nuF/zm+nv//+2zDJ3+1gjmfeHmZGsM7oqKpap8G/RVgDTXLVpqi3Gydn xjiFbj8gmWoqXM8yjDXDVAY+k9GjYPiCoOpJa1TSlf8Up3EdhB4rYgGRiUUQLLw+VbV/f5a7 SdaOnydjYgU+/EdwWnYSwlLtLA59ZzYhO93MY+PtMSRXRyEyemzh0oGJfom4ewBmMaOaigC5 RzOa80hf+Rnnh0/S85xx0S2pKYbDk46bOtpqMyeV6vB7xmGOLBxjnTlxwvjDlvVPOhpXhlLr KIH3FF6MA7AYDqqNMWIgWCNoNo8Bppw4TXP+HUBF4GNuoanctKMMzu6VsKNDFMvwX/Rpgwhi DVXaDMqfELB7agHIA7BwH3R6v13eflOHOdvE8t0D7cCEfDCEuclEqy6xnUT6EMTdSHo8iWDH xIHHcZcNcFAob0gemzC6ODV0iAnhHqKWEnmuKCls3U7b0bdBk4pR+UoGR0ZHK/vWuf1+ebsC b3I7D4pINzI4jwFGDxoquA2VbLXTgTXQgqDViW3oKrh3/GSjx+JtUtof4dokE9vQVA9mXaeR wIqRa1Wdrcl9khDNR784xj23LIMJvVuQmSgZBdVzXIqJKqhFgIVWXYp0qjY5HbTU/PDg+kIy n7ivCCKXu/XIWoQ5pd1bIHBHaHUpJrZ7DoWXX3Iv94iC5B96Uy+r3A+x82zjRfSdqYA0j0D1 Pv7+9uMMZ/DpiL7tvecTLht8nv7f5e3HwH59vZ4ukuQe3476/lRWnokgW3ZiN9nZ2PCPNUzi 4GE0Zgx/CqzwvpjqWM1ZtLGBC0X/TEojRfqfebo+6o7wymJXRojLMjWjufCKTO2TVekrIscg 3fGfJHQt9kwM5XJdeg+7lPDBuzm+/qha26o67a693F9C2yGm5R7q11WTbSPTIlDCd+Dk2h2e OmOLKkQSOns9dbLR0OVi7xazjOVpyr4m5ldjibmT1lIO3SkxQMBTbmy4HIeMhKLcEkN3xJj7 aghGSlsjLCbCTo0Yk55cykWzsUetdkEiZEslT0cW0WIg0HKucmO5SxsW3o3NL1H5qpl5eflh mGNUpyi1CUMqpwBWIqJ85XcuGeDDqDeV6jSOd2sfjt32Ma0I5QsKsWHA/T0IGOXkCiOyzm0N AVR42vLo9ARR8lr+7dwnNvZXu/PEEHYgbMYBTWN77t6WPUqVqqKmiRdlRBMyj7JtKYm7mByT Ir0ekkoudTu/vjZswKoeXAc2oyhY7tNfmTCNirxgvLJUX9Mi3pq8IVQuj8+P16dB9P707XxT 0bNbRmzVDMcAcklKSmHKRqYrlMVEeavLJIXZ4hWNtrnQIK08P/toyOWhjmLyQIytvCcCA83f NZtAUTCifwROGbXZJg4Z845jb0f1iLeVHjQd2w6r/k8wDJxoj6Fzvr2hMizwR68y5MTr5fvz UQYEktLRhkBj5Ud2+kBIAJRk6fLtdrz9Htyu72+XZ51pWfkZxjVPhWmRhBc0ecWs6URjS+1P DPiRZ77+iFqSdH/KcNwCSwfDq4+5M5qZXeUc2meyRvSz/GBmMG6w6ZDQJQorAIHveKuHBfGp onDLTkLsdMevekSsGMk/UClXP4G/KrgYY7479BFv566fqeFRvkTL3ibRykq1u09gj5JZmc7Z MdX1tPQqz/1XJJDFKdJh5Xwmysk84EA9rHldSp12uA+TemS19FVIJq+Flo6yED9WrpW1JBVt tEjAcPMRBkKPEzMiDaRLnX5aHOx+0QM9BaZiaznRS4GgMaHi1GVGxXXp7chPvxzY4GYC/kkC 0mu9QM3n2FD6qkREAp08wv2F+kyJBOGz/wdWAI6hVrIAAA== --MGYHOYXEY6WxJCY8--