Content-Type: multipart/mixed; boundary="===============6993917380575334829==" MIME-Version: 1.0 From: kbuild test robot To: kbuild-all@lists.01.org Subject: Re: [PATCH] iwlwifi: actually check allocated conf_tlv pointer Date: Thu, 02 Apr 2020 17:41:00 +0800 Message-ID: <202004021740.oe608hk0%lkp@intel.com> In-Reply-To: <20200402050219.4842-1-chris@rorvick.com> List-Id: --===============6993917380575334829== Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Hi Chris, Thank you for the patch! Yet something to improve: [auto build test ERROR on wireless-drivers/master] [also build test ERROR on v5.6 next-20200402] [cannot apply to wireless-drivers-next/master] [if your patch is applied to the wrong git tree, please drop us a note to h= elp improve the system. BTW, we also suggest to use '--base' option to specify = the base tree in git format-patch, please see https://stackoverflow.com/a/37406= 982] url: https://github.com/0day-ci/linux/commits/Chris-Rorvick/iwlwifi-actu= ally-check-allocated-conf_tlv-pointer/20200402-145204 base: https://git.kernel.org/pub/scm/linux/kernel/git/kvalo/wireless-driv= ers.git master config: mips-ip27_defconfig (attached as .config) compiler: mips64-linux-gcc (GCC) 9.3.0 reproduce: wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/= make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross # save the attached .config to linux build tree GCC_VERSION=3D9.3.0 make.cross ARCH=3Dmips = If you fix the issue, kindly add following tag Reported-by: kbuild test robot All errors (new ones prefixed by >>): drivers/net/wireless/intel/iwlwifi/iwl-drv.c: In function 'iwl_req_fw_ca= llback': >> drivers/net/wireless/intel/iwlwifi/iwl-drv.c:1470:16: error: 'struct iwl= _fw' has no member named 'dbg_conf_tlv' 1470 | if (!drv->fw.dbg_conf_tlv[i]) | ^ vim +1470 drivers/net/wireless/intel/iwlwifi/iwl-drv.c 1323 = 1324 /** 1325 * iwl_req_fw_callback - callback when firmware was loaded 1326 * 1327 * If loaded successfully, copies the firmware into buffers 1328 * for the card to fetch (via DMA). 1329 */ 1330 static void iwl_req_fw_callback(const struct firmware *ucode_raw, vo= id *context) 1331 { 1332 struct iwl_drv *drv =3D context; 1333 struct iwl_fw *fw =3D &drv->fw; 1334 struct iwl_ucode_header *ucode; 1335 struct iwlwifi_opmode_table *op; 1336 int err; 1337 struct iwl_firmware_pieces *pieces; 1338 const unsigned int api_max =3D drv->trans->cfg->ucode_api_max; 1339 const unsigned int api_min =3D drv->trans->cfg->ucode_api_min; 1340 size_t trigger_tlv_sz[FW_DBG_TRIGGER_MAX]; 1341 u32 api_ver; 1342 int i; 1343 bool load_module =3D false; 1344 bool usniffer_images =3D false; 1345 = 1346 fw->ucode_capa.max_probe_length =3D IWL_DEFAULT_MAX_PROBE_LENGTH; 1347 fw->ucode_capa.standard_phy_calibration_size =3D 1348 IWL_DEFAULT_STANDARD_PHY_CALIBRATE_TBL_SIZE; 1349 fw->ucode_capa.n_scan_channels =3D IWL_DEFAULT_SCAN_CHANNELS; 1350 /* dump all fw memory areas by default */ 1351 fw->dbg.dump_mask =3D 0xffffffff; 1352 = 1353 pieces =3D kzalloc(sizeof(*pieces), GFP_KERNEL); 1354 if (!pieces) 1355 goto out_free_fw; 1356 = 1357 if (!ucode_raw) 1358 goto try_again; 1359 = 1360 IWL_DEBUG_FW_INFO(drv, "Loaded firmware file '%s' (%zd bytes).\n", 1361 drv->firmware_name, ucode_raw->size); 1362 = 1363 /* Make sure that we got at least the API version number */ 1364 if (ucode_raw->size < 4) { 1365 IWL_ERR(drv, "File size way too small!\n"); 1366 goto try_again; 1367 } 1368 = 1369 /* Data from ucode file: header followed by uCode images */ 1370 ucode =3D (struct iwl_ucode_header *)ucode_raw->data; 1371 = 1372 if (ucode->ver) 1373 err =3D iwl_parse_v1_v2_firmware(drv, ucode_raw, pieces); 1374 else 1375 err =3D iwl_parse_tlv_firmware(drv, ucode_raw, pieces, 1376 &fw->ucode_capa, &usniffer_images); 1377 = 1378 if (err) 1379 goto try_again; 1380 = 1381 if (fw_has_api(&drv->fw.ucode_capa, IWL_UCODE_TLV_API_NEW_VERSION)) 1382 api_ver =3D drv->fw.ucode_ver; 1383 else 1384 api_ver =3D IWL_UCODE_API(drv->fw.ucode_ver); 1385 = 1386 /* 1387 * api_ver should match the api version forming part of the 1388 * firmware filename ... but we don't check for that and only rely 1389 * on the API version read from firmware header from here on forward 1390 */ 1391 if (api_ver < api_min || api_ver > api_max) { 1392 IWL_ERR(drv, 1393 "Driver unable to support your firmware API. " 1394 "Driver supports v%u, firmware is v%u.\n", 1395 api_max, api_ver); 1396 goto try_again; 1397 } 1398 = 1399 /* 1400 * In mvm uCode there is no difference between data and instructions 1401 * sections. 1402 */ 1403 if (fw->type =3D=3D IWL_FW_DVM && validate_sec_sizes(drv, pieces, 1404 drv->trans->cfg)) 1405 goto try_again; 1406 = 1407 /* Allocate ucode buffers for card's bus-master loading ... */ 1408 = 1409 /* Runtime instructions and 2 copies of data: 1410 * 1) unmodified from disk 1411 * 2) backup cache for save/restore during power-downs 1412 */ 1413 for (i =3D 0; i < IWL_UCODE_TYPE_MAX; i++) 1414 if (iwl_alloc_ucode(drv, pieces, i)) 1415 goto out_free_fw; 1416 = 1417 if (pieces->dbg_dest_tlv_init) { 1418 size_t dbg_dest_size =3D sizeof(*drv->fw.dbg.dest_tlv) + 1419 sizeof(drv->fw.dbg.dest_tlv->reg_ops[0]) * 1420 drv->fw.dbg.n_dest_reg; 1421 = 1422 drv->fw.dbg.dest_tlv =3D kmalloc(dbg_dest_size, GFP_KERNEL); 1423 = 1424 if (!drv->fw.dbg.dest_tlv) 1425 goto out_free_fw; 1426 = 1427 if (*pieces->dbg_dest_ver =3D=3D 0) { 1428 memcpy(drv->fw.dbg.dest_tlv, pieces->dbg_dest_tlv_v1, 1429 dbg_dest_size); 1430 } else { 1431 struct iwl_fw_dbg_dest_tlv_v1 *dest_tlv =3D 1432 drv->fw.dbg.dest_tlv; 1433 = 1434 dest_tlv->version =3D pieces->dbg_dest_tlv->version; 1435 dest_tlv->monitor_mode =3D 1436 pieces->dbg_dest_tlv->monitor_mode; 1437 dest_tlv->size_power =3D 1438 pieces->dbg_dest_tlv->size_power; 1439 dest_tlv->wrap_count =3D 1440 pieces->dbg_dest_tlv->wrap_count; 1441 dest_tlv->write_ptr_reg =3D 1442 pieces->dbg_dest_tlv->write_ptr_reg; 1443 dest_tlv->base_shift =3D 1444 pieces->dbg_dest_tlv->base_shift; 1445 memcpy(dest_tlv->reg_ops, 1446 pieces->dbg_dest_tlv->reg_ops, 1447 sizeof(drv->fw.dbg.dest_tlv->reg_ops[0]) * 1448 drv->fw.dbg.n_dest_reg); 1449 = 1450 /* In version 1 of the destination tlv, which is 1451 * relevant for internal buffer exclusively, 1452 * the base address is part of given with the length 1453 * of the buffer, and the size shift is give instead of 1454 * end shift. We now store these values in base_reg, 1455 * and end shift, and when dumping the data we'll 1456 * manipulate it for extracting both the length and 1457 * base address */ 1458 dest_tlv->base_reg =3D pieces->dbg_dest_tlv->cfg_reg; 1459 dest_tlv->end_shift =3D 1460 pieces->dbg_dest_tlv->size_shift; 1461 } 1462 } 1463 = 1464 for (i =3D 0; i < ARRAY_SIZE(drv->fw.dbg.conf_tlv); i++) { 1465 if (pieces->dbg_conf_tlv[i]) { 1466 drv->fw.dbg.conf_tlv[i] =3D 1467 kmemdup(pieces->dbg_conf_tlv[i], 1468 pieces->dbg_conf_tlv_len[i], 1469 GFP_KERNEL); > 1470 if (!drv->fw.dbg_conf_tlv[i]) 1471 goto out_free_fw; 1472 } 1473 } 1474 = 1475 memset(&trigger_tlv_sz, 0xff, sizeof(trigger_tlv_sz)); 1476 = 1477 trigger_tlv_sz[FW_DBG_TRIGGER_MISSED_BEACONS] =3D 1478 sizeof(struct iwl_fw_dbg_trigger_missed_bcon); 1479 trigger_tlv_sz[FW_DBG_TRIGGER_CHANNEL_SWITCH] =3D 0; 1480 trigger_tlv_sz[FW_DBG_TRIGGER_FW_NOTIF] =3D 1481 sizeof(struct iwl_fw_dbg_trigger_cmd); 1482 trigger_tlv_sz[FW_DBG_TRIGGER_MLME] =3D 1483 sizeof(struct iwl_fw_dbg_trigger_mlme); 1484 trigger_tlv_sz[FW_DBG_TRIGGER_STATS] =3D 1485 sizeof(struct iwl_fw_dbg_trigger_stats); 1486 trigger_tlv_sz[FW_DBG_TRIGGER_RSSI] =3D 1487 sizeof(struct iwl_fw_dbg_trigger_low_rssi); 1488 trigger_tlv_sz[FW_DBG_TRIGGER_TXQ_TIMERS] =3D 1489 sizeof(struct iwl_fw_dbg_trigger_txq_timer); 1490 trigger_tlv_sz[FW_DBG_TRIGGER_TIME_EVENT] =3D 1491 sizeof(struct iwl_fw_dbg_trigger_time_event); 1492 trigger_tlv_sz[FW_DBG_TRIGGER_BA] =3D 1493 sizeof(struct iwl_fw_dbg_trigger_ba); 1494 trigger_tlv_sz[FW_DBG_TRIGGER_TDLS] =3D 1495 sizeof(struct iwl_fw_dbg_trigger_tdls); 1496 = 1497 for (i =3D 0; i < ARRAY_SIZE(drv->fw.dbg.trigger_tlv); i++) { 1498 if (pieces->dbg_trigger_tlv[i]) { 1499 /* 1500 * If the trigger isn't long enough, WARN and exit. 1501 * Someone is trying to debug something and he won't 1502 * be able to catch the bug he is trying to chase. 1503 * We'd better be noisy to be sure he knows what's 1504 * going on. 1505 */ 1506 if (WARN_ON(pieces->dbg_trigger_tlv_len[i] < 1507 (trigger_tlv_sz[i] + 1508 sizeof(struct iwl_fw_dbg_trigger_tlv)))) 1509 goto out_free_fw; 1510 drv->fw.dbg.trigger_tlv_len[i] =3D 1511 pieces->dbg_trigger_tlv_len[i]; 1512 drv->fw.dbg.trigger_tlv[i] =3D 1513 kmemdup(pieces->dbg_trigger_tlv[i], 1514 drv->fw.dbg.trigger_tlv_len[i], 1515 GFP_KERNEL); 1516 if (!drv->fw.dbg.trigger_tlv[i]) 1517 goto out_free_fw; 1518 } 1519 } 1520 = 1521 /* Now that we can no longer fail, copy information */ 1522 = 1523 drv->fw.dbg.mem_tlv =3D pieces->dbg_mem_tlv; 1524 pieces->dbg_mem_tlv =3D NULL; 1525 drv->fw.dbg.n_mem_tlv =3D pieces->n_mem_tlv; 1526 = 1527 /* 1528 * The (size - 16) / 12 formula is based on the information recorded 1529 * for each event, which is of mode 1 (including timestamp) for all 1530 * new microcodes that include this information. 1531 */ 1532 fw->init_evtlog_ptr =3D pieces->init_evtlog_ptr; 1533 if (pieces->init_evtlog_size) 1534 fw->init_evtlog_size =3D (pieces->init_evtlog_size - 16)/12; 1535 else 1536 fw->init_evtlog_size =3D 1537 drv->trans->trans_cfg->base_params->max_event_log_size; 1538 fw->init_errlog_ptr =3D pieces->init_errlog_ptr; 1539 fw->inst_evtlog_ptr =3D pieces->inst_evtlog_ptr; 1540 if (pieces->inst_evtlog_size) 1541 fw->inst_evtlog_size =3D (pieces->inst_evtlog_size - 16)/12; 1542 else 1543 fw->inst_evtlog_size =3D 1544 drv->trans->trans_cfg->base_params->max_event_log_size; 1545 fw->inst_errlog_ptr =3D pieces->inst_errlog_ptr; 1546 = 1547 /* 1548 * figure out the offset of chain noise reset and gain commands 1549 * base on the size of standard phy calibration commands table size 1550 */ 1551 if (fw->ucode_capa.standard_phy_calibration_size > 1552 IWL_MAX_PHY_CALIBRATE_TBL_SIZE) 1553 fw->ucode_capa.standard_phy_calibration_size =3D 1554 IWL_MAX_STANDARD_PHY_CALIBRATE_TBL_SIZE; 1555 = 1556 /* We have our copies now, allow OS release its copies */ 1557 release_firmware(ucode_raw); 1558 = 1559 mutex_lock(&iwlwifi_opmode_table_mtx); 1560 switch (fw->type) { 1561 case IWL_FW_DVM: 1562 op =3D &iwlwifi_opmode_table[DVM_OP_MODE]; 1563 break; 1564 default: 1565 WARN(1, "Invalid fw type %d\n", fw->type); 1566 /* fall through */ 1567 case IWL_FW_MVM: 1568 op =3D &iwlwifi_opmode_table[MVM_OP_MODE]; 1569 break; 1570 } 1571 = 1572 IWL_INFO(drv, "loaded firmware version %s op_mode %s\n", 1573 drv->fw.fw_version, op->name); 1574 = 1575 iwl_dbg_tlv_load_bin(drv->trans->dev, drv->trans); 1576 = 1577 /* add this device to the list of devices using this op_mode */ 1578 list_add_tail(&drv->list, &op->drv); 1579 = 1580 if (op->ops) { 1581 drv->op_mode =3D _iwl_op_mode_start(drv, op); 1582 = 1583 if (!drv->op_mode) { 1584 mutex_unlock(&iwlwifi_opmode_table_mtx); 1585 goto out_unbind; 1586 } 1587 } else { 1588 load_module =3D true; 1589 } 1590 mutex_unlock(&iwlwifi_opmode_table_mtx); 1591 = 1592 /* 1593 * Complete the firmware request last so that 1594 * a driver unbind (stop) doesn't run while we 1595 * are doing the start() above. 1596 */ 1597 complete(&drv->request_firmware_complete); 1598 = 1599 /* 1600 * Load the module last so we don't block anything 1601 * else from proceeding if the module fails to load 1602 * or hangs loading. 1603 */ 1604 if (load_module) { 1605 request_module("%s", op->name); 1606 #ifdef CONFIG_IWLWIFI_OPMODE_MODULAR 1607 if (err) 1608 IWL_ERR(drv, 1609 "failed to load module %s (error %d), is dynamic loading enabled= ?\n", 1610 op->name, err); 1611 #endif 1612 } 1613 goto free; 1614 = 1615 try_again: 1616 /* try next, if any */ 1617 release_firmware(ucode_raw); 1618 if (iwl_request_firmware(drv, false)) 1619 goto out_unbind; 1620 goto free; 1621 = 1622 out_free_fw: 1623 release_firmware(ucode_raw); 1624 out_unbind: 1625 complete(&drv->request_firmware_complete); 1626 device_release_driver(drv->trans->dev); 1627 free: 1628 if (pieces) { 1629 for (i =3D 0; i < ARRAY_SIZE(pieces->img); i++) 1630 kfree(pieces->img[i].sec); 1631 kfree(pieces->dbg_mem_tlv); 1632 kfree(pieces); 1633 } 1634 } 1635 = --- 0-DAY CI Kernel Test Service, Intel Corporation https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org --===============6993917380575334829== Content-Type: application/gzip MIME-Version: 1.0 Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="config.gz" H4sICKurhV4AAy5jb25maWcAjDxZc+M20u/5FarJS1Kbw9cok+8rP4AgKGFFEjQAyva8sByPZuJa H1O2nGz+/XaDF0A25NnaXY+6G42rbwD8/rvvF+x1//Rws7+7vbm//2fxZfe4e77Z7z4tPt/d7/5/ kapFqexCpNL+AsT53ePrf399uPv6snj/y/KXo5+fb08Xm93z4+5+wZ8eP999eYXWd0+P333/Hfz3 ewA+fAVGz/+3wEbLs5/vkcPPX25vFz+sOP9x8fsvp78cASlXZSZXDeeNNA1gzv/pQfCj2QptpCrP fz86PToaaHNWrgbUkcdizUzDTNGslFUjIw8hy1yWYoa6ZLpsCnadiKYuZSmtZLn8KNKRUOqL5lLp zQhJapmnVhaisSzJRWOUtoB1s1+51bxfvOz2r1/HSSLnRpTbhulVk8tC2vPTE1ysbjCqqCRwssLY xd3L4vFpjxz61rniLO9n/e4dBW5Y7U/cDbExLLcefSoyVue2WStjS1aI83c/PD497n4cCMwlq0Ye 5tpsZcVnAPzLbT7CK2XkVVNc1KIWNHTWhGtlTFOIQunrhlnL+BqQw3rURuQy8VdiQLEaBNPHuGWH TVq8vP7x8s/LfvcwLvtKlEJL7vaw0irxhuejzFpd0hiRZYJbuRUNyzKQE7Oh6fhaVqHIpKpgsqRg zVoKzTRfX4/YNStT2P+OAGjDhpnSXKSNXWvBUlmu3FrtHj8tnj5Ppt63Qv6gLopvjKqhcZMyy+Zj d1K8xd1heT5HOwZiK0prCGShTFNXwFj00m/vHnbPL9ROWMk3jSoFLLUdWZWqWX9E6S9U6e8/ACvo Q6WSE+rQtpKwYH6bFprVeR5r4i23XK0bLYybvzb+cs6mMMizFqKoLLAqg357+FbldWmZvibFtqOa CS6v6l/tzct/Fnvod3EDY3jZ3+xfFje3t0+vj/u7xy+TNYQGDeNcQV+9IHTordR2gsa9IoeDQuX2 fqQl6RKTouJwAdoKpJYksqAWxjJr6JkbGcK7hf6GmQ/WAiYljcqZlU5O3MppXi8MIWiw0A3g/JWB n424AomijKtpif3mIQhbw/TyfBRUD1MKUEwjVjzJpbG+JIUDHNR50/7DU/DNICOK+8OWmzWoO8gn 6RLQyGdgumRmz4/f+3BcroJd+fiTUYplaTfgGTIx5XE6VXDD1zA3ZwP6RTe3f+4+vYJ3X3ze3exf n3cvDtzNmMBO3C10fnzywfMDK63qyvizBqfAI8KYb7oGJLpFtaM+RFDJlJbUDq/Tgh3CZyAiH4Um NgUW3gjfVOKOYn8dxp9mxywVW8nFoe6gaVTzBiZJvaJEW/HNQNPa/9FcQgBgKgaaTXNeC76pFOwX 2kmrND3GVkQw9ojvC3iXzMAYwQRy8BUpMVAtcnbtjw63GpbGxU2a3s1EKTB37t/UVvBGVWDhIJZD 74nuBP4UrOSB8Z6SGfgHwW3NIAKAgCoFfYQ+09adNgIjubK3SgPTg4TUNk2Co/Y3WCwuKmwCRolx L3RJqmz80dq18XcBEZ4EYdMev5WwGLo0Mz/fbs0MnLXhyDSWG5xlYEumv5uykH4g6lk6kWewKNqf CjPC+Wyv89qKq8lP0CGPS6WCOchVyfLMi9jdOH2Ai2B8gFmDlRl/MumFzlI1tW5da49Ot9KIfpm8 BQAmCdNa+ou9QZLrIjBpPaxhZHAyoN1qoC5gxBmoQ5X13ZO6gPvtYvuM1C4jLnxuzlw4KMkMJiXS lNRTpweoSs00KHRAGEazLWCQoR+r+PHR2Szy6XLIavf8+en54ebxdrcQf+0eIQJg4E04xgAQiLVB ktdH2zEZUXwjx37I26Jl1rgIKJBszMeYbRI/6zM5S/xZmbymMxSTq4TScmgPEqNXok/EQm6ARc+C UUSjQf9UQXNf11kGqULFgJFbagbWmbYqVhSt/YEkUWaSzywV+KdM5rPgr1vPMJcdhF46f+02pri5 /fPucQcU97vbrggwOnIg7GMJciqOgOXgQgo6aGb6Nxpu1yfvY5jffqfdxZvDSXhx9tvVVQy3PI3g HGOuEki2aTwkt7DlHEPkiQMIaf7NPn6MY2GXRBkZes4ghKe1OWeGHRhXrlS5Mqo8PXmb5kRkbxMt z+I0Fcg2/JUqvo5gPSwdfXUceGSkpeBAojdClnRE49pv9dlxZBvLK4gdbXJycnQYTQteVUD3hg6A NAMV29DavJKNrE5OKP1tUb8FVqKFfTjA65Qefoek187I5NqKhuu1LCNxXkfBdCFoFzTyUId5vElg LqGXQwS5tDYXptYHuYBlV4YWpY4kkasok1I2kUE4ObJXp7/HzEGLP4vi5UYrKzeNTt5H9oOzrayL RnErIPqDKJ6WyLxornINgTCLhMgtRXWAwulcxTTD4kFECE3ZFE0BsexUEgFROkRkHaoKcoON0GVE ZLSocnRKotlAjDcxUp0PmnuYaZa6vhRytfYi4KE+BWqXaGSfdulFkLSoQlrwuJAGNS7P8YO47BIL aF4EiNU0U1eV0hZrXlhK9MIFcLUuuxVM59ezsBjT8QTjqjKVrAxbDTzfJFjXEMXnSebHXFw2V5ZB qpRoma68sLqv9OIuwe5a2Tl+f9fzY1ghWIk2/W9+O4g+/81bioYXKRbTG1Xm19NFW5550T2maBD0 O1hf7gqCBW+J9PER/Ge+qAHOrx4RMmEZhFe2kYaBcG3HA4JgJZdnCex8K5fhLg0kpydvknwDF9wy DNOGcKkLUPf/fN2Nc3eMggIILv+WgUgAj7MPhFa62A9T1eZsE8SkI+J4uaGj05Fkebah4lRXa3b1 o49gqJVOQTGOj/0J4q5AMp8J66r2HqZXvbQuqgakdSJTWdUvTthMn20AV8+BrQQGjBCFNTeDNV0D Ht861pC7F5Jr1UWnk9Ga65JPxsKMTDvZPpojcO3PP9C7CtYmzB6dcQA1MwLgoMV4KOTVuOuCRXQ6 RLnkygiLJSqh20quFh6BKzX2KJelNZnUkC7wdV16BqcEk2y6uS2HjosqMooAUzruZrAgvjp3uPPl WbBgLRj/gMlHpF/GP6HDQcCc0VEMYEDZo6hI7IM9vY+2Onm/pJJZ19PR5Nzh+CgcMrViTKPuBwcK H8+RV+hh1hor9kEhQFwJ2plzzcza6Q3VueCYkc6MhDo9Ab1ZnvUjI5q2yUlnrzPQD2eUc4V1Zd+e +qZprCXzTSoIncUofuOKUnNctWoPRXPIrXNzftpavuT1ZfH0FW31y+IH8Fs/LSpecMl+Wggw1j8t 3P9Z/uNoFtG5pVri8WZvVjwNLuqJ/hUge40uW82FWZdezZsiYFfnxx9ogj757xl9Cxmyez+u5jdP 198m2MyW57QOMT+BncK75iAPM1jpwxJZZoVzyQ7qtqZ6+nv3vHi4ebz5snvYPe77gXtbUQQ+ppjX mwfk5QUEU5dgokSWSS6xutJZEjK6i/Y9BAstRTFQDLcMACc/3e/8goM7JkpzQXY1NvAhM/aOX3b3 /PD3zfNukT7f/TUpQoHFLSBBEVj8A1EgV2Gl1ApUoCcl1FJkso0W+XigZXdfnm8Wn/u+P7m+/eOV CEGPno16HBBG9zVebJhVIIJLCzfPEGzvIaZ6fd79/Gn3FRiTAtEaq7CS67yXagtKQaawaaNlcqH+ jXFCzhJBlUWdumFJES8zWFk2SXg/wfUoYRCokdCJnaA20zC9hWphSURQtnYQNwBn5tZKbSbItGB4 +mDlqlY1cToOXtUJY3doPzFXGJRAoGVldt20B/TTvo3LubrbHdOxarECLwRGyFliPJl1B7TVdAZd 5Xc2qXHdJ+O6ZKCxaGFcODPctCGIOvP3TbQqTz16akCdhwOVyYNELAZvYyWcPG684FZ5yO6sMUT3 5/a+CyPaThoZq5V/FOD6xW2HfNWJxkbO0JFz+Kngzk/gI+JXYmyJlrTPJyZ0ICZ9DCo4lnk9H6DS OodYELUID1/wbOEglhikuIJYR5XtRRlcHUKUXWtXs4bEgppG4H0nBK4DUkvCVqNDJ/h63jjGxCf5 MBfSPuK1qkrVZdm2y9m1qqeGhavquhsw5CZ+upGDjDUJrBGY/XR+ntCmlbjrk3xGef4yy6YzcPnW GgJQq9DsUOvbXSDTzXrSFvcWPFXUSLZ5S3+4BEF8741WXG1//uPmZfdp8Z82Nvz6/PT57r69kTKe ERwgG+KHvF7htSdlLOfn777861/vgjHgdb+WxrejAXB0rQO44ddtIJSjANEHCB51ziyuLvxPw/a9 RY3CDLpfT8/dJycjbzjMfi5gDwo8xvR9jjvrM3hY5uWfrUIGcb4DdUk5hu1UjN/S1CXio41bNF2q Gx1NDI98jObDbcPIQWRPKenwsEPjrmnwWIdo8GjrEoJYY9B+DrcVGlm4HIw+Bi1B3MEpXheJymkS q2XR023w0JVYz6S78TL83EBCZyTYx4taGBti8JZCYlYkMJdBdWa81GDFSsdktqfC6kvk5gPeg+lS Oqe+dA0byS4T+uzHzQmLoBXLZ+FgdfO8v0MJXlhIB/1EoC8l4pE4XqUIpI1BQFiONPT5nLx6g0KZ 7C0ehVyxt2gs0/INmoJxmqLHm1SZoHw6Lp9Jm1SazSx09fLzEqZq6uTwGPBSm5amufqwfGO0NfBz ecfhfvO0ODipaUV45J+Dary1OaZ+a4M3TBeRzfFSH3IEmNwuP7zB35N7iqrPKycSHGj2LHtGZSgu sOIQwlze214vVuPdNk8foJFUba0HL/yEF8w95OY66aotHa5HJNkFOf6wv8Ghm/J45N9eaAcHDu4K bTtMLLw33OJdlNLiD+HItpdgpESssY8MWw+Bh7v7nbohupvII0kcM22sL+mmI9ztkPjv7vZ1f/PH /c49Y1i4GyB7b6/G0sekrxGB4a31dhBAYY6Lv9radh8sYqvukuasymK4llVQ2e8Q4NSoa83IHZn7 ZbnYtNrbF7uHp+d/vOrFPFMfytKTKrK7JQaRU1srniYU7bV8dNEQLnm50VjjvrIQUc4SEVG0CoZM XTE4xGfM2GZV+3XoKoeAuLKtWmJt+WxcDVBSPj23WmkWglxczNJUN3Y4SelQLg+DkDmpw8tYpiAW v99QF/WD8XY8z5fv358u/eBhnozRVioX4B7x8IJEZ5BUWixmREwcfWr9sVKKNvofk5qOFD6a9jYW iYQpC61RC12g254M4YVLktrVMhxJn/bSx0tCu9OS6HVw2P8mESVf42WNWNXHZTx4iI8ZLct9jYgL /SjgswoqwvAOBoioMd2J3EiNV2swHA2BYgIzmwTlXpR9QcbpYLnb//30/B9Id4i6KaxTeOm3hYAL Z9SdVXTxY3+1CyB4UHt1sGnrUTxzKpq9yrSn/fgLYuuVmoDcjdGHkZcDulPxjEXuJzsSiHCaSuWS X0e67pRWTPpzl6GMldxMELJyRx0P/lZsxHW4NwCY85XBxsuqNXKcmWALAN4Hr42G3J68yA1EDocP ziABSQO2VVlNGAKkSdecVucOj8cuBwk00zTeSWglDyFX6JdEUV8Rc2kpGluXeFL94K9PN8fZ85sB RweB15B7K7WRkaJu2+HWyig2U/Uh3DhcugPc6Iat4zgRuYgl26GhgFGbjtjZMpWdvoZy1lhe9eCQ fZ1WcQ11FJpdvkGBWNhPLD7SOSL2Dv9cDaJMTGeg4XXi1wSHOleHP393+/rH3e07v12RvjfBE5Vq uwx/dbrj7gFQGJhIpiaI9qY9Kn2T+rU+nPMSNjRc9SVuo2+SBmCjsixSCmlppjbE9V7IajntwVkc asuXI9TTCuAyEWsfZSD4eJhCmqVOJ8tQQgbHXYxkrysxQc7VFIfeR2vuaNVMmoAJxldLU3CrwaFa D+Apy9icKlmYotmezNgYsVo2+WU73IhZ68nA1UcuAFeWU5oIG4AvbrH6j1FCaPsrW3VmOQuejPSN ICJ0JVbwMEUVC1OAuD1SoKsj1QEkGKeUx2294REzryOvjmAb6NVhlr6AmJ9EemhvgVE3Hdz5FhoW wyZLhiCS2TZnZfPh6OSYvlacCg6t6fHlnL7WyPCuGh1KRG7V5qyK3GLCS6R098tcXVYs8uxRCIFz ek9d8cDVcGl5H9tdvO5edxDZ/drl4sFjzI664clFGKwgcG0TApgZPodWWqo51KnnRSj4CIdw3TdJ Pdhk1E2uEUsM0YqLnIAmGcWfJ3FXj3jQpoN4y3CaB4a4aic2gabGqf8MDn8hoyXGmWpaZ4dlvZiO Y76Um+RNGr5WGzo26ikupoWdKQew/rTZ7Cmyi28g4uyNcbwxjPX68L5VkjInPbZPm4iNwGOUNyTm sEQRt0baWxj3Ny8vd5/vbm/CG6TYjueTFA4AeM4iJ2qHYMtlmYqrOcK5x7M5PLucw+rTE3/yHci9 U6LqOx167tJcv2ZbEaMB6JIYDNi4ObR96Tk18G4Rqvg+9/wi7q4nKZjl69ixjwu6HUVEXJAD4zac NsOiA+aOYg5fIfUww5Uj1SqZExZSE0YRMYbh2WBkQEhQMhsuousFP3xCspNk1jCgN0msJTc17cmH OVSRTKcnQGd8kODQBnejK1TkkUBHIrO4KUF8G+ph6h0ls7yvkhywGpl0icEYSXDaxaelwafHCr9w Qoc7ECAxdxRFHyRVotyaSzkRyjHAwdfRB8yQqxdF87SDW1Yausu1OeCe3EhTQU8GKfJT/AAJJl2H qEpuqAxF+9eidea+5uBf97gKH+F3j8ZdvE17bo9iViRxWS5+f8BcN+Fj3eQiD8nQ8nQfxAkraov9 7mXfXzbww/+NnX3UoisNzlpOEH6RztsUVmiWRjw+j+hd5FiVZTBvHYvns2bDqdpzJpNG10Fidym1 yIPyYw9B7fKgeA8pPKRwoO5TEj7IVNczIrn1KqXZCkPj48CC5Q7kvksUfejTN0SxFLnCC+r4VSWI DiKfFujpucALcN2z1EaVNZWGDtR4+g5r4N57Y+1OrNJkPnp3dNS+ymhJ0GAZgq4vg1QUkuuUEU8V evRlsAcBGN/jB41ymfTLOoFAL9eVhVZVFMd5EUfajQzqIwM69jkISMMnQ+khruDuP3gaEJrjaYix wd0wHzscnHwL1fm7h7vHl/3z7r75c//Os6Y9KaTtVAgx4HORhtdjvIamP5yIJf0DcfsAvhBlfagv Yxmuy9q9hcEXM+dHI69LCVDKzmYbmXuJVft7Nm60ZL9Hjn+YpH05F9W6iX0Wq8xoo1PNo6CwUBvx +lRpp3fM+OIEz7a8y1pawfDyafwNBgG9qD/xjMlcbcmiu7Brq1Te+97eH6S7v+5u/avYg93GbxH4 Z/bTH93ntAwJ9B4VjIvFpUDtTUhLhFhmqiJg5yDUg/4B5+7DGxgsvT8BGdqcbyIev2YSJWyqSP0I F6EggwTEoJHdmMlMDtz4R6yxkU8hIFIqOlhBHHigOA4fYtFhlLKYXyLVLD9E2O3T4/756R6/Q/Rp kJpOll7uvjxe4iV5JORP8A/z+vXr0/Pev9R4iKyNR24+7fDzEoDded3hZ8NmzN6mHW6t0GMf5iUe P319unvcB9/EgJUSZepesJJBUdBwYPXy993+9k96pcKtvewiUzt9uOTxj3PzmfHYI2TNKjkJwMZn CXe3neov1HC+OrSs2w94rEVeRZIEMEG2qDJKn8G+lyn7H2VX29y2raz/ij6dSWdOb0VSlKg7cz5A JCWx5psJSqLzhePGbuKpE+fazrT993cX4AsALqiezjSJdhcgCIDAYrH7bKq5hZeVrHGI8hBAiv1S NERYPL/AoL6Oa9H+0g4hVf1q1sBWNNSDKIzjGthLi1vXudaPkrTLpBn50bWrb4P0oURnQs23ZOga 3AVljJWl74RAfK4sN31SAJXDrhpQubLCsngJMYaRmL2wCMMgBmYI4EYf+lNdGMiNoNZpviXyd5u4 odCGVBfd6eQZotEexLaizaZdFWa83rWHhO8wxo/sa7XsoAEWsFWKOAJFHTvkNgfXmv4MCnrbL1ll ie3rPEUpF9P8BErHLqUcLMKoKjTjaV8GNw3OI2gfAkXYgFA64VMWU0eZnp0WhTJCKlU414iIh9EJ v+cLvbYQZYn2RdXO7g8rXvoKn99c4Td0cGnPrxj1yqI/8VgaRmfFhq2REWZvjz5igaLOaQKXibdQ /w2DFooKE6pHVK9c65SK6yMpz9jnLNY2PrMnkU+qjMBoTVWzP2WrlUoHtae3T9SHxiLf9ZsWdi36 GA0rVXaHPoWWux+W1xZ0JDhPZmKxo69/Qr71XL5aOiQ7zsO04Cc8Y8bVObFB4x1hrUlpcwErI76F 0wOzeS7w1N0ul94M0wI/w+OcFxVvaxDyLZHOvczu6Gw28yKiodsl/Y0fs3Dt+fQdXsSddUCzSrT7 H22gWMbHQyowE/zjQapBlCo4hUV7W/y0ay6S0i00hs0j09SyfrAFBz4vS4R6x0/jAwtpi2cnAefA dbDxiU+3E9h6YbNWP92OnkR1G2yPZczpYejE4thZLlfkF2e8ndIbu42znHwHXZTpX/dviwRP4T++ CnC0ty+gOjws3l/vv71hPYtnBFx5gG/36Tv+Uw9B/a9Li+Ls+f3x9X6xLw9MCWB9+fMbaiyLry/o 6bz48Pr4fz+eXh/hAa4IBR+/K7yNZ6ixldNwheTb++PzIkvCxb8Wr4/PAsqcGPAz7D3GwW70t56p QtnR4/xyS68scXi0gVrxEDHOEIIypA87QqSqeWOVOLIdy1nLaCBdbZXVTseJjtmTRNPpgIEtXWGl 0/qPFqNeskKx7FYsiRCvu+LjTodSipskltGi1ARlPNSrVIGPuh+cKUVjulYIKILFB5hIf/x78X7/ /fHfizD6Gaa7ghEwbNxKC8NjJWlEnA6vqB2UVy3o/BEJojfUdlB29p4WHvVOQD0QDxVqCKKgp8Xh oMV3CioP8faigyYZ37/uv6Q3YyB4mXRdr9ezD0lyIv4kxqrlCIlvoafJDv4iGBi910GFjIu6YFal rI2cnOYrGf1yETAR2iQVHNovSPIEqpBALjW7vznsPCmkjvPAW0kedRQU9eaNO5Tu50jsTurr5413 aRv4T3wTtjqPJWeTtkDBbdNQ1sOeLYdAL8Ws52fJZqHZEEMgCTeNRasfBLb2ZgF7u2oatV0dyY4/ LNaPM/U2gjpjVlKEEF48tTj7dGKnzDqqUVnD0bCYdid6TsIsmukPPA5a4OGQH0PjXJqfgdYglso8 vtgg2AeZGRVjkIFHWfu3rL3pJwtUFztP2K4P8X8cN6BKzfFdatwE4lJ5S+9TQuK058dwZh4eEdPY ghQtnnxXUc5MsDDtQ+O6Yx8WNlhqbKoNLbPbohrP2TozDd132Rhsu7IQOkQ1fdcr1+ByZn6JbCO0 1tDzmQ0KSb5gHc98zvwu870wgM+TRJdEkVvYmJIQQZWWk2X9NmWTg57JnyynukhazlUQhd7W/2vm 88Pmbze0di4kLtHG2c70wOyyVGZivZxM8DILlpbzodwl9vP9Aqf4lCdFa85NrWFHU186tlXEQuMb BiqcNfllSo4zQpalJ6ZawCjVTlm7dZjVfsGJplqTSssk2HsUIz6GRsaYQFYpV4uR2BiXmhBSnCll OSm28teamHRXZvVRkxSXLnfa3mwzowxGpKyHk5m+aKSZxSIC52hk7U77pKDEuxjTDBT2Q1wJDC3b fWSEkei8rpKSdOAHtjCIja8MFJ6zUuRQ0R9dH3GhqopzgtFJMw+0B6UBU4R0zkrAKcxac2rguo4s 9NEqKu09MPcEWr9FUL/xMhaFCjgf46rQqiHmhUptVR9XjcHNHhQYobZ3i05kXiYcQHFfoJnVs3af MpubFHARjNsS+48DbPdY6rpNjJLFIJ9dARfoADKtFrL9iVMAUeg3vXC87WrxYQ8H9Av8/xN1xt4n VYyOKnTdHbPNC260rj+Gzz1GuViWSTNUIP5E0dnzeHCJGdeFIo+sXwVaG0kOtvZwsqnd8a2A1Jrx m9xTYb7Jfmc6CdYxaVnOWIiOf6o0kmpL3GhSWt0Ez42Ng3ctlgubgyXMANrALVY4eBn4Fy8sDgf1 iW4E0NuzGDaRFox02jwb9u88zWzYD5UZmiDvfp/e3l+ffvuBth0uLyyZAt+iXYD298D/sIjiwYCe R9rGaHr3S1ND64WFFtl5LiqbNlfflceChFJQ6mMRK2HtVqvsSGg1q/YJCUOnVgC7lfbJxLXjObaA wr5QCqdO3DO07G08TcKCUwcWrSiCW2vtDa349p39r+bXXiJjH9XocI2lg5VkUeA4Dg6ZxSwNZT1K c1brhBUgrxNGP1D1p1LpOEkKFfGgTjU3cvjtEM9FcjzOJfypnYdYem2wTrAJa/E/ktLmuyDQzxnT wruqYJGcs/2SulrpmleGawl5T5k3rmI+yxOt3XVyKHLPUkwzN8iMFqadf2xBbvU7Hl8iZLpNdJdT arBSBgvkpof6wEOcdrW6+njK8boe3rG1uGSrIufrIruDZVVQZCqLTIcjX1oW8jS5PZmOF8RLygON 5h3cnXFqap4OTE+Ljeip9HluZJ/J0ImOjYBK1GoawklUiTaNczPko5dDyMWc6eradklO/ggXcqqS SF9mxQZ+ShNbcEBfyvSEi1LXkhMCBtb07JrWF4Muq+ZJ2sWu1mD5G/8yZeAvb0JL8YnVhMxv7o7s ckPO/vijnvVSYUkAVJJ1PLFLnJCsJHD9pqFZoNVqZuLYZhlBBjWcgq6sn8lhp/04a4FvSXOgjFBI 1k4ryWppuWo+ULrfr1lMTqmMVec41V4wO2c2p3R+Y4EdgdG6smNl8BSWF0onZ2mzgg9GOVcjQejP qt6JRKtfcV8CtUktVBg4vv2wAVx+mWXvL1deJwk1l+MbHgS+AyW1wO0b/jEIVpPrNbq6opvU4yrJ 8s3Ku7K3ipI8zuiJnd1VidYt8NtZWgZxH7M0v/K4nNXdw8ZlSJJotZwHXuBe2eExqLIyIblccnc4 NwdtduDv3hlMoILTec70h1VFXmT0GpHrb5a0WL+0qGQSxJHUM5QaAm+rWJ5YEwSbrRJH1xG6q3lt MXdvrs+T/AzbpraLyAS9hjI5LVjcqHns6mNBb1MdTEycH5Jch4M8MkwvQ4/yXYzufvvkykmhjHOO UK3apVthaN7TYtJWPLb+NmVeo18H3aahtZomzltD8bslrV7qI094cZ5pCtZtiC4RNkCBKrs6M6pI 272r9XJ15cOoYjx+aHt34HhbCwQAsuqCXrirwFlvrz0sx3sl8rOoMGCtIlmcZaA2aGgkHPcq83xD lIzjW7pKhCbcw/8qavJetTvvwzYLI/V6e3w48PY4elcmI09Spq844dZdepReqZXSPgr4ubXdkyTc 2V4ZX55xNcl5Fm4dbVrHZRI6pE6BJbeOLi1oq2uLLS9C+Oa0MCKVW4v9RHvHOkO8yuvDedITabOy vMtiZsnZBVMmpt2yQgzpy8l1MDmRixa/y4uS32kjE13CtkkPxuc6LVvHx1OtLI3db+oxtbY31Ekb lqBEIOgHtwTL14bti6iz4Mdkpy3odej5gUN5dSnlzvomAD/bSQo1hYfRcWEiLiymdV2Sj7kOFiYp 7cW3qbqDgHft9C7d59TKO4c6XEnTxAL01MmwJrGvuPsosvgsJWVJTR/Uarusx7qZzMTpk7QQ70gS egJJiaTesfygKatIh88QQ9cSSxI3FOmO0ETNMJ0M7N40jhA7+IB3OsCdWBfhSQukd/dtRDQFi/CK 5mjJdJlFdl5nZbILSG1mZxWAXkTXjzl+sJnjd8af2QpWQeCYAv1ikoQsEu3XTALyMG4pEzGYIvKR 2k1Niaqsa20J8uswcCZN0WtYBfP89eYKf2vl75Mmngxmr2eFZXri5juJw23bXNidpViK3ia1s3Sc sCvbMzCKVyV0B0nzCT0ZDh3Wdsuz1CxbnI3+gURt7/3hoGR5VZkkm6X6a932JZTASqmVmW/a6U/W 56MORb2Fsnvrz+F17CwbLSABbdGwuCbh5DHDYl/HnMdm27r19ABrhVvhn7TlubQ4xxgmJrG2HF/e 3n9+e3p4XJz4bnCdRKnHx4fHB8SLFZw+NJ493H9/f3ydunpeDD1sCDe/RJQhH8XHq4dMqsfDQpcF WpQx3rd2IINfyQpq7foAxW2mBuD5N7qxHAjz4l1cqFpkS1vegLO+oZWIS5KuXYfeh6GYs6RrvIS5 tyZ96vQOyLRMLOLn0FXoIW+Q1MKUZd5T7IArD5dnprFbznc6ATbfmAtBmVeG68j1mgS9BQwiUJay 5nftaEs12TpSpwRQ5g5TUj4lpeWUpqYCRVoXeq1QjpdKP60g0TaFgCcd9LQulaRp3R2dekLHuvoc 3Xl6JJvdNEqLEStR5zGStOpSVgAH7RkzYugPadMDkbmn1TR1shqGepXVm3j7TbG8wPemeAZ1BGhf nmgpe3qG6Fmd7JoVuLYKkCFgQGo1tLDnYJgFtFzP9NQzbwuCaDQGtEngGO6LQLFOh+RizjqgrLZr XyN42xUSxFbw9Ocz/lz8gv9CyUX0+NuPz58R9YQIne0fQPngdtff/6RGpTGXZK/5SQMpOtPqN7Ay nSWa1sGG/C8+78+n359Q4AdmeX17W/z59P7l5cf7oqsV9jVZyRjaPf+y2LqZd7W/mTlHK56oaZIK DEoZB0X+HuN+/7Yw2vxcsWzCLtNmUhduXyMtrrJYc8uVFAyl53RndwIyl+r+InI5GSjf/U6TNuMD emUHTiYmLUdnhXRCLv3VZJ9HmvYCSNCXTdFyf0XvbuPNyPjdxFWteyb3tBl/8kHEgjAy8NGTDgeJ rL9nzjwow4lm8eTILmlAheRqLxxHCTPMjVm9Wf9luWgSPNfOW3p2nuNTpgq1NTJ1vWYwrd2GNDdo xQaT6VAqDZxAWYyBgNnkI20chdTWtYBadFw+y7XsXcjduB6b5e5mag6CePa5M1xQhq3PvQRUfmet K7mmvMLPdku65aiFdMjz8OK4V4dMNb9dUsf1HfWDdFzd1A+UwKLWdleHxCM+3kWqZVtlCRNHnOtX 87d1vhdJesLEMocH+KILtxh6RBII/CQnm038TaTVuDwhkM+HKUTYT4v3F5B+XLx/6aUIq87F5nGX NehARF/HoWsggYMzblc8Ii2WZ+0qBH62pRHj3wVEfoeNchLUp9gbytPUP+54//ogwjKTX4qFGX+G N4OKjRx/4p8d1NV4RhUMGK+Sk0EHgg2rKbCVE7agVuxikjqvLylsPoO72SSrrF66ClujGYPESYiQ rAPL4qmLUaclUH00xpASvS67/cv96/0nPHaPsfD97lprGNZnalfGpA/boC1rFcesV9gtxA5hwfXX erewFPNgSuSTirx+Kz6Cqqs5WrYHi2LRZYCGDYKe5ohBUdekQUtAoGMkQZeyrqNH8VnmqhmtbfH5 xoCakKGSj69P98/KF6m/pJJbV2cErr8kifCksopD2HojAVRf6HkHVUln7ftL1p4ZkHILgKQqv0e1 kdr3VaFQ+s3SbdOQrVRG3LCK5uRVe2JVrWTUUbkVZhzN4jkRkeskiiO6+ozliO1YabGuCp8fUcmV aaHITpEhJFaQB62xFohyrbrL9WpqNwgILIyXbz8jHyhiSgkLGrFqdlVhj5k3JrqEDseoEJUxNmv9 1fKJdWwehnljMQv2Es464RtbfKcU2oXZ2psX6dbcX2uGju/29XUUvSaGsBBXq6osEVWSXZX0Mt6x 9zxt0/LaM4QUqO9p3ExF+5ApfVWZ1CHyOpoYAuNSjkeZvKZXw6TMkvYI625K3jgdL10CXeWo15NE OgPYrzId9JyVJTpa0xNHJBmxQzvVIfxf0omwzuau3iRpemeDTphubmojZPOrE69F2LYEs5oqLG44 tUhLPKfxB1QAW5aRVsQNJ9n8BA1WH0RGUq0RQKYT5CBHYnCJHUmviWd4Lam1A7Mn7bRcHx2xDFlv jME3GpQFhIwaX6/DYFtAzUD/8vL2TsOwaZUnju/55hOBuPYIYmMSs2jjryc09H/XiUmwNCkayAFS yiRpVjopF95Prtnb0kuqPZQUyqbo24T7/tZ4LSCuveWEtl03Og3v3k1CKaLDxin199v749fFb4jY Jbt18eEr9Pfz34vHr789PuAFyS+d1M+wC3z68vRdgx3BaqMYAWeFyaZMWY2wi/T3bchagoZRLD64 S0uSNezyzJIZCHi/flxtAuokh8wC9xhjrsKUHJpt9mmG8SLGmMkrqulZ6S/4wL/Byggyv8iJe9/d JJETtmYFb0GX60ejgDPUq1JYGRI13sb61WgNr087s9k8tUFmymFBz0Q7KtQggh/xFRErgoyyhCnl PMu+VlrCpkuLB+eRxussNfMJ/JwapuRyU/LFp+cnCdgzVW2wYJiK7OM3Yq+xXEwOUkJ/vyZ0KAlM R2zJZ5E9+/3ldbos1iW08+XTH9PtANP+OH4QYJxpeNNPrO4QL/01FvcwFrktDZBymr9/eBDZYWFC i6e9/Y/WG9qTEKYpzMgxn7ZWqSTJw7qi7xKxY2w4vhc69Fyiw7IzrXpILqbrpJeVAVu2TOlb8eMl Iz31MFQpY5pfekdSEvjZy7UxzKVDnOOZFJtQ7PcyzrbNuAqm3ItjZCumo0JPm3Ku3h50+lAg0E9c tpeEx1QrVcE9Syp5LqFVIqKIwOcUIcqzRey1E4Kz7UUBdGcSf1x95j9sHoaKMGtG5Qum7YgKEiiB Y3JHzpOddjDlSuQEioiIdz1CCMkdymdGD6W8C55ULq6qv2pCY/UqVeARCZxgso6Br92HDgxeUDeV gt+DkxJFLW9ECqHTYxtmlvQBQpBcqrMfz+9Pv//49kmkr564k3UVZPtoGqMBNKjY3y4tRzwhEG39 jZNdaExmlGBN6S4b3PKsIhlq8fSZHNkR2y7X9IltYNOW0Y7tWAAOxbNDB/3Ore071qGAjg7pJ6Ql aFhkmhrkSG1Xe96vLP8I41jYgnFQ5ibOypQOEkd2EAhQkSt8OgOa7O7GWfmbzZzAZrPe2vsUBILt cqaCeu1tZ9hxvnedXWafEVVck1j6wCrDvQ/jrZxJekrLopCg4vZojkIVhZ7r2Kd1VftLz/7+PFlt 1s1MqBHKZL4F90Vwb+4CGARLYrtd4y+neIt6BXc8tKzAyK4R8Mbz/KateQj9YhVMS2+7sr8p1JNm dHbVuuRrZ+lbwkmB6S839h6WAsF69sllsPGuVLF13Nm1Be+aNt58X6aZ58+Mdn2bNTMNPTeBb//Y WJV8LHI238Ys2G4twESHRIgkhbkA9WiNc+u7YjqJD7hpFzZ8MTxZdwlKJlvI4fX++5enT6Sqfz6w KbR1x4uqqZ2dAU1F8O3eQiVLubBcfGA/Hp5eFuFL+foCjLeX15/gx7ffnz7/eO3TtY01/KMCEnb9 9f7rI5wZf/8dDpHRFE54TyN1k8Uk/vf9pz+enz5/eV/8a5GG0cxVGXBleqPOZZ3ezVl4kyaHYz0j 2qOHX3nygF5uDqEyw4pTTt3cnEDlKo6gEKVJXYMOHecwR5QLEOSPKW2Uq7Dd4NxuuSvbtae0TMyj r8IecrYfw8io21JCaleip1FI2NyNXA1IL7/8/fb0CY5p6f3fdI6CvChFhU0YJ2eyy2fq0V/ywKKD 5QCFiXrp5QALVgV09wxuT2bbOOMMD1DUzVAeXwwvGfwl55fmmTJQEXTIknZMCO0qnKE5uvQeL2gg zQ96/J3oVRClelnUIFZdWosZ+fQG2fPXK+paWHJxX1tN3i0tfd+lt+WRb1H1er5FF+34gbHtq9wy ZFvfbyatQvqajAmWfR25wdKdlKpDhnusvTF1GsL+aNHehz7WQfOMYRMe3789P33744Pzk5j71WEn +FDmx7cHkODfHz/hLccxiUa7KPwQ3k2H7KfJwO/QB8iSixj5WdrAdmXn4zF15qWFxtI5jpFvVr8+ ff6sHX9kQRmOY34jfZSOMGRNx6DjFvAlHAvqul0TO8asqnexmihS4w9Lv/VBYUlrY5oQC+vknNBX 5apcb5sQHnbS6/P7O1rA3hb/X9mzNDeO43zfX5Hq02xVz0ziPDp96IOetjp6RZQcJxeXJ3GnXZPE KdvZb/r79QuQokSKgJI9JSYgPkEQBPE4qEnqlzlfH35sMOw2Pi/AkXr0G87lYbV7XB/cNe5mrfJy geq79zsdeBl3C7TwSo8L62OhqbheH6murqOKlqTtSW24OxvmPkSlQZJycdLQzC9PfI88aSu4Yir3 MKNAsWaraBbUhbilC7UL3Kfd4f74k4mAUW7gHLe/agsHX/XSYh2wlsQIy1uzCrnsUHC0eQHC+LGy bFEQMcnruI2t/Mspt5MKdsWDFCRm+bJJIql+IidZ9rqaO1H/uwcc7ClxGunvPN8/v4sEzf17pKi4 +/oOyuKSSYWgUUJxcspwbhOFiVZqoFx8oQ8jjYLZBDhnZo1TifPg9J16EgH3qGM6n4mNMxmvaAEo 9G1JY8DF/ZI7gy0cTutjIZ1+BOkjOJfjONnZSX05Ps/+9SkTokdjCJB4vh7TPFDjxNnpCSM2dQsK 9Mf4Fhko55e0HGTWMhlfqig7PZ6Mk3E1B5Rxuqnml5dMDpNuYkLYLpfOpsZ3L3tTm0wDn6XR96hM 9OmG+Pio8wFmEIrTCSN9GmQxOfnI8L8GE6fr5dPqALLV83v9CLKCVg4bTGDCaCcMlPOT8cVGlPPx NZCpWs6XsZclzLOPgfnlbHzuQjE5G2YhGa55fXXypfbGaSc7u6zt0RMIp+fDA0VDzsc5eSayi8k7 I/Gvz2CfjBNBeR4wukCNgmQyvmO1PtOhpO3L7ygUvkNHcQ3/vccV0B7ADl+iTHlBshfrlz1cBZhW QlThz4cpjpQjTeb5TdwlSjYt4DB3W5wwwT3VdygxD19HtIuNXbEhjjWLMBHlIP6uvmDbD0vwcxkw CVIRVuK0TKOcsytEnBCEIQLHwPAiQzHdKFvnoBCndiG+Puksos92Exjxhu9j1TCp4RCaxRdMSiJp y66elyhNDILx+yhv7KgUspgzSNFfZcRjfba532332x+Ho9mv1/Xu9/nR49t6f6CyXL6H2jc4rSLX mExTWO1NB2F6ta4kKUVnybLsAwD31RZpGCdc4vUbOElyfEd0xhjIB3yxfdvdkzFgSbihw/GS1C9I szK40DaGxs1KaSmBR+UK7mLSgIFIQvoeqpLl18/bw/p1t70neUmUFTXmiKITthEfq0pfn/ePZH1l JjTF0DVaX6ojHBr/TShLrOLlKEAbq6M9qiB+dNkZO52f9/y0fYRisQ2otaDA6juoEGP0Mp+5UKUG 3m1XD/fbZ+47Eq5shhfln/Fuvd7fr2BFrre75Jqr5D1UdYv/I1twFTgwCbx+Wz1B19i+k3BjoxXB snZ9Yhabp83LP06d7Udt/IJ50JCLT33cGdZ+iAr6pmRO5XlcRTQXjxYYZ5pTqhYVc6ln1AF5Tb+H YK5DjlOVN+5bCZ4naENI2LJW14qDwcFvxV3L8RiCpQga1xJeW5YNazU+x0BxbBelPRDanNdVkaaE 2S0GrxBvfykDSHOhdQLWkXAvyyt8JGuEz4diQQuscuEtJ5d5hgZsjMGYiYX1sVgqTErkaNO1NZY1 GuNTtDwKmJjpWUAvfeW5gpH38rDbbh6smD55WBXDpEua67ToPXaa+Pk8TDJalRqS+eS15sb82Slo lLB3g8n37tFzjfJaYJKAq8kcBr/Wbk5ulf2XMocfeXgnBeNakCYZR6TSozpQ+XNJBOnINNQfd07b Vmp49Vi4ATariMBiXnMvTUKvjpaxwJS6grTCBxgct2YEAOA0k6WpDWsLlgvMeeYWl4VIFksvSF2Q iIIGEzNYkNNh5ad8LadsLWfDWs74Ws4GtZhMlY/x+t0Prciu+JtFhgYylYnFusdFCcw6wGKaFL47 IH3uSEAve+Pv66aojTAZi8Fw+zMLAIxfCIKKHPPWLEVQMXlLEQnDErBA3hN8GosJPSC/rgZD0iX0 IDoozChapI6m+OiQqyZfCi8HPKlhZUzWJDY/CAX3BKwcE3W9ay6KZWqTmO5WnqTufPRMZcItPkfH KFXHwqZfVdZm4ClIs0O8vuqkPEb8OfSHrEFuGML7DgpMD4zpeDg7SsBwM7t0sLyoYWYMT8dhQaIK 5GOZ1bCnAGSbchcQ7clynXNT8djYMwPuSYSgtqgMnV9iccYtkQIziwS9tug5gAIrQrC6ZTJVoyM0 WgXH7qEbrO5/mo8UsVB85XlQIO2Rhb1iCjBLRF1MufTDGovfARqj8L+jw2KakKmAJA4Sj/U835eO NGAgMX3VV1E1F2peZC7UP8N5KE884sBLRPH14uKYm/MmjB2QboeuW2mHCvFn7NV/5jXXbiYAh2t1 Dt9ysLwmzgZ90tPNKjF2v3572B79sLqjhb8uwaxZcGW7aMoytM+r00Fh6WHg6S5eUC9TIjCYJWlY RZTd/FVU5Wargxe1OiudnxSXUwAtafTajGYKO9sndyKIh2gaXEUg6lgxIOQffoKJSexVL0Kp/VT+ DWuTFRXakfBnuheOwGIeFklWy0Fn/IcAkiEWGbA/0ld/pDs8KIDdSq6EuG48MbOS1LYl6pBx5CMb HCbVQCQeooURuj6i//00pStqMWTWM1oypzCXJUjkjNVC94EkyrHe3Q0CqHaA9I6xnOwRmLQHXdt3 4/A7UTNpPTXGmUz4h3n/RHLH5FLQuFHmR2FIxirvV6zypjIyfXsWQaXfTg2ut+DpJ0ty2PYkBRWZ lhJ78i75mq7zxdko9IKHVm1b9OUbDiXGGhdYwpw9YUb2U8WKEtp/y2Y4GqgmxPo9nwx+n1pBUmQJ slX6zEEwTY8IEjeM3qDCHNQ5PQDcTomQfkxNWFI2l4BCkdNUxtMo0dXbiLqAwujwJ/TZHnQbdqs/ cJq8KoPh7+VUGOwICuAaiGXLq8o/t2KsKHQ9jCSX90W0KQ3QFJJR3rcf8YJOVM5YNppwgCL0+BOE pbA8ZYgyT4JBgEMtLxXLGxWtQtsPm5qENujI/dtuc/hlPI51B74d+Bx/w43ouoGL10jOzRKjyQGN o+NldFsBJ2eOprZKejOpe0kU8igAwAyxBbQnHcG4mCVKKYAPZELqD+sqYdQyGpfiii3I3Kgzbw6S ODrl59DPRj6nlbeYJ6QIvIFw5aDRYjlGj4b7kiiairHLli6KgawGg1oqH3+iw9qqrh+/Z2ydVGTf PuEj0MP2/14+/1o9rz4/bVcPr5uXz/vVjzXUs3n4jPZUj0ganxSlXK13L+uno5+r3cP6xQgqpR86 svXzdvfraPOyOWxWT5v/1+bx3WUwqbH7cI3Ni9w63KcBiKVpM03gcl9XDciskXfFm1jS6P4t3Nb/ V/xhVhdDh5egSaJaTcNGcRQ5rqKIxdWPivQsaTA/yX08j8GG7fRFGDgXWamZh0++b9tXA1UGQnVQ 3g5LF2YMUVVUXg9LMJftBWyloJj3ILlfC63ADXa/Xg/bo/vtbo1hLX+un17Xu54WFDL6pntlMqyj LZ645ZEXGtfxvtBFFVdBUs7MxCIDgPvJDMQestBFrWRsfqeMRNT04Hac7YnHdf6qLAlslHLd4jZZ M1duKT5b0HDDkR92B6jUvznVT+OTySWI3M5wMXIWWUj1pJR/+b7IPwQtNPUMTg5LW6EgpDlm+fbX 0+b+97/Xv47uJb0+oofKL4dMK+ERfQzpZ/kWGgXvwauQCQGlx9hU82hyfn7y1em493b4uX45bO5X mMU1epG9R9crDCh75O332/uNBIWrw8oZThBkzsxNg4yYtWAGp7w3OS6L9PbklDGZ7PbhNEErMH7R RHSdzJ2WI2gB+Odcm8f50jbheftgash0f3xqbYOY8sjRwLpymgxqQXTDd8rS6oZorhhrrlRdtAsX tSDqAfnlpmJEcT2n6O1UN1RII91tIfqpm632P7mZyzy3X7PMlAl0Z6kRzNXnSlu2eVzvD24LVXA6 CYh9IgH8CBYLyXiHLfqYbnziE/OmINQtpW+wPjkOk9il8rYph90Q9D1gfuGZU1sWnrvcNQFyjlL8 654QWQj7gyy+OKaKJ2aAo774dOJii5l3QhVSVUDx+cmEmAYA0NaXGp6Ng2sQf3wy6ILmwtPq5OvE 6dBNqfqjJIfN60/LjLbjL9QmgtKBzccAnjd+4u52rwrc9fRlpjmSFhXACQStCc7DFJRm7KYOgDcl 7iNRn5Ol7oqFkTuEWP51iq9m3h0hJQkvFZ6kG47Hj/HtiKgwqkq44lFUlJ2NUEDkzlJ9U5DT3pb3 E6joY/v8ulvv99bdopunOEUdscPI7wqio5eMUW33EZPWtwPPaOuPFmGosVNmaKuXh+3zUf72/Nd6 p8zhei/iIekKTARWkaaDesCVP1XGkQ7JIKRl8I7kImGcZ6WJFJD6UAPDafd7gp5MEdrnlLfEpMvw LiDdv9t+h6gl9g8hV0yEmSEe3hr4kWHflm1UPvM687T5a7eCy9tu+3bYvBDHbJr4LaMiyhXPcego 8akjjUJTW/VdLFJudPEopoLl+jDEsNx30bcJ2chHJMK+y7QE6WIzB9bshiLiaK4yyIDoNroPe0Ss /vhsdAIROcmmdRS8v0EAVXhxtAiYHH1m+5nMNLqcLqgcsnCrzrII9VJSqYXaSOvKrYFl46ctjmh8 G21xfvx1GUSoP0ow4G9rD2Q98F0F4hLDec4RjrWwNkOI+gXTCgh8LKSr+iIvVVgPrahKpqjvKiP1 9COtKLBnCeEQG6x3BzSahDvLXjr77jePL6vD2259dP9zfY8RzPutphToKgCn0g9Wlt2DCxffPhl+ hS08WtSVZ84YpxIsMKz07bA97uUAq4btjB60oqaR9Yv0Bwat3IVZrqMUMaaCRpcsfbgHA/uvrDwH aFpJm6L7CQhvaINvkJS2mMTQ7k2dpOZlv6hCU8LtjCuDZGhspkGDYhleAS0sgqxcBDP1BlBFsSlR B3BVhePE5AfByYWN4Ur60FTdLO2vTgdKBijA1JrxUC1gI8Bmi/zbS+JTBeHkA4niVTccUSkMP2GM A6vggq2ZFq2CL4Yrd+JTV7GAuph3d6/+DUhGtx2fHXwFxdPRFrXu1JkyKAXJSwazrSLzlQZL1eus XY4iE4Euiy38rr+LOwSQPBXT0QK7mUdAa5VnaDoxqIcKPDwowietpUWlWG6lrpJkK9NThWG1rJcX Zxg114ztjrCSyMqjWcQ0VTplg4ylARzyS69uTEVtUDZw3zP7E14blhR5aptrBundsvYMF2600IaD 1/gkKxPLybtIMMzVFFhVZU3QPOr27TwUhbubp1GNsQiKODRnNi7y2ngbNEsv/zF3rixC4ysgsygw cAXaNhdGjwXMr5oC4wkEeSpJoR1zdXjmcABSIhOzNExO3dG1wIoFpmNA4Gihqb02YU0HtJ9U9Bkn S193m5fD39JJ9OF5vX+k/NZUVG4ZEIJ+hVPwwBtayXccXIZtxzzXKTD+LkTkty8sxnWTRHUfV19L B04NZ8YbHz4pt12RQTKpHXGb+QXKNVFV5XCTNp8r2ZnoroKbp/Xvh81ze2buJeq9Kt9R86Yi3qJs T3QlyqVmO8PQ3nJXGhRbQdek1ew3kCEvbWosgVrQgj3jnBa8UFbssdmsMPigwDfpevAgpTdqCSsN 4jigpEk+sONUYwJRBYUrNG3KvJoMBzhEkeNBe+FbtzoZ/3p5gy9lJRXyQ0sxH10Dy1Wspfs+QVny sj/s3p4xmK9ld+eh1AxiFeP52HaVUgZKJibZ9dU0tKx28Dd1YuiAT40vvNbKGGfcSy2LUgklPldf eSmwcbSaMan4Q6P+lzUkNLYzMweqUrRa06yjfUfsKrOYA+5LmetCcJa9qkJElKcRzUOwmuIm52In y7tBkYgi5wRi1YqyMqX3Rku7qUctiVzDdkLgvMZnW5dQNWSsevnq3CC7ouV22OxhixXlodr7I/Ux GQDbRZLOWk46uuHMqz2F4gZLvUbn0Zo4TosbYtubYIrRy5vs8spD8tSevR1dqWJZx7cT55G6Jy6n 1dnAtetfXb7Co2L7uv98lG7v/357Vcxgtnp5tE8vDJ+DL+YFbdFuwdHNpYm+HdtAKX40tRlyWRRx jdeIpmwzsTCRBts0LbMGpIjaE0yW22syirCdXJEdqzKtAX748PYkI/X1u9SiOZ1S0yZFafdNtkpV OVwbnJmrKCoHm1LdJfFxrWdAv+1fNy8yWvjno+e3w/qfNfyzPtz/8ccf/zYiU6Hrgax7KgUv1/ir rIACtYsBOZ2yDhzXyJ5A6bupowVji9VSHuH0PNyB71Zyc6OQgPEUN6U3dBmze3UjIuZgVwhyaDwX bcPw10WGR1kKC/NOXTjHUvHZCrh027JVoHC8MjjP2z0VdwMdlZb/B6owJR/gGjJfFt00yhYwLcsm xxcEIHZ1uRwZ/ZU6KRi+8rc6Ph9Wh9URnpv3qCshhLuhN8OQ874DF2NHmfRbSQaxCnpxFw+7fBl6 tYcqkqohPGss9sEMadhqUMH85XXi2QaA6kUhaGghAAB4ysQ8cSAGR0EGCh5TUi7teO7kxIRLEjC5 ARZG16R7iPaptzrt7M7rVvqs+FBzbeYKuQtA0kEtKxPezasxWH9dlMTw5DEbN7kSi+VAqsE9uINO K6+c0TjhLVxcYHfHeiqsClRKuUw6fUqrqSocoKCfhpxfxASJKq+HZoZB+6GqxfCmkHWr9BFWoc2o 9SXGWarB2DmTQ2Q1PEJZRVEGpF5dL+EiyGWPA7DAZAljLckzcQRhdgPLOYbQ3uC0DZ7CZNzz2lR/ au6Z/Ffy+6XIQUqjIyv6wNTg3gAHoFRzDy0bdbmXA+eQefjUB8zp1KEDMYwiopm/fKsoljwH7smp Vwe/t4AqlQXLMoSXlSkRYOd5A+IPIeWoOYaK49SbCpciZU7DVkNgKSyzUDqx+kWRkhxk0KCpTanX +wMeYyiNBdv/rHerx7XJGK8aTjTX3B1VETIz9nd1YabpR1IYiTO8UV7ZlpJKIgfBG4rbGSotdS3i U8y4TXCIq4P7exgVR77HyHcH4ST7NFFYqK8PdCkujBwcPpp6jMAjvE4VaZEhZ+GwpAsnyPbL8cqU 5w4PV5LVxRkj4mgsw3KVRZKzM4sWYZPRQpqaPqV/VKbXDN9o8UTAWHqrpzPAqJn4AhJB7gvaplnC lW50FA7kzGRxkBhNM4z0YEIXUnPOw6lrp41R4QODzH8zMuHcQ6uEJiH9YKuInQnhK4HzjBfK1eDR GoA1xlczWI5NP77zzQp53tBBXuMkD3EV3uG/sjbMwY5p1kYISrpzjozHUbEOCVL6DrAeFYoos2KE ItBqHE7g0d0hHxkZDqsrYREAxl5TRvm7Y0CvVOr/BUPS5uIcEAEA --===============6993917380575334829==--