Content-Type: multipart/mixed; boundary="===============4339029617058625209==" MIME-Version: 1.0 From: kernel test robot To: kbuild-all@lists.01.org Subject: Re: [PATCH] Bluetooth: Add support for reading AOSP vendor capabilities Date: Wed, 07 Apr 2021 01:41:38 +0800 Message-ID: <202104070105.D3aQ8W32-lkp@intel.com> In-Reply-To: <20210406133632.241599-1-marcel@holtmann.org> List-Id: --===============4339029617058625209== Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Hi Marcel, I love your patch! Yet something to improve: [auto build test ERROR on bluetooth-next/master] [also build test ERROR on v5.12-rc6 next-20210406] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in https://git-scm.com/docs/git-format-patch] url: https://github.com/0day-ci/linux/commits/Marcel-Holtmann/Bluetooth-= Add-support-for-reading-AOSP-vendor-capabilities/20210406-213836 base: https://git.kernel.org/pub/scm/linux/kernel/git/bluetooth/bluetooth= -next.git master config: powerpc-randconfig-r012-20210406 (attached as .config) compiler: clang version 13.0.0 (https://github.com/llvm/llvm-project a46f59= a747a7273cc439efaf3b4f98d8b63d2f20) reproduce (this is a W=3D1 build): wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/= make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross # install powerpc cross compiling tool for clang build # apt-get install binutils-powerpc-linux-gnu # https://github.com/0day-ci/linux/commit/71e8a18c61c482db0f170ec89= 7450ba76c18b7ec git remote add linux-review https://github.com/0day-ci/linux git fetch --no-tags linux-review Marcel-Holtmann/Bluetooth-Add-supp= ort-for-reading-AOSP-vendor-capabilities/20210406-213836 git checkout 71e8a18c61c482db0f170ec897450ba76c18b7ec # save the attached .config to linux build tree COMPILER_INSTALL_PATH=3D$HOME/0day COMPILER=3Dclang make.cross ARCH= =3Dpowerpc = If you fix the issue, kindly add following tag as appropriate Reported-by: kernel test robot All errors (new ones prefixed by >>): In file included from include/linux/io.h:13: In file included from arch/powerpc/include/asm/io.h:619: arch/powerpc/include/asm/io-defs.h:47:1: warning: performing pointer ari= thmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] DEF_PCI_AC_NORET(insl, (unsigned long p, void *b, unsigned long c), ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ arch/powerpc/include/asm/io.h:616:3: note: expanded from macro 'DEF_PCI_= AC_NORET' __do_##name al; \ ^~~~~~~~~~~~~~ :42:1: note: expanded from here __do_insl ^ arch/powerpc/include/asm/io.h:558:56: note: expanded from macro '__do_in= sl' #define __do_insl(p, b, n) readsl((PCI_IO_ADDR)_IO_BASE+(p), (b), (= n)) ~~~~~~~~~~~~~~~~~~~~~^ In file included from net/bluetooth/hci_core.c:33: In file included from include/linux/suspend.h:5: In file included from include/linux/swap.h:9: In file included from include/linux/memcontrol.h:13: In file included from include/linux/cgroup.h:26: In file included from include/linux/kernel_stat.h:9: In file included from include/linux/interrupt.h:11: In file included from include/linux/hardirq.h:10: In file included from arch/powerpc/include/asm/hardirq.h:6: In file included from include/linux/irq.h:20: In file included from include/linux/io.h:13: In file included from arch/powerpc/include/asm/io.h:619: arch/powerpc/include/asm/io-defs.h:49:1: warning: performing pointer ari= thmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] DEF_PCI_AC_NORET(outsb, (unsigned long p, const void *b, unsigned long c= ), ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~= ~~ arch/powerpc/include/asm/io.h:616:3: note: expanded from macro 'DEF_PCI_= AC_NORET' __do_##name al; \ ^~~~~~~~~~~~~~ :44:1: note: expanded from here __do_outsb ^ arch/powerpc/include/asm/io.h:559:58: note: expanded from macro '__do_ou= tsb' #define __do_outsb(p, b, n) writesb((PCI_IO_ADDR)_IO_BASE+(p),(b),(n= )) ~~~~~~~~~~~~~~~~~~~~~^ In file included from net/bluetooth/hci_core.c:33: In file included from include/linux/suspend.h:5: In file included from include/linux/swap.h:9: In file included from include/linux/memcontrol.h:13: In file included from include/linux/cgroup.h:26: In file included from include/linux/kernel_stat.h:9: In file included from include/linux/interrupt.h:11: In file included from include/linux/hardirq.h:10: In file included from arch/powerpc/include/asm/hardirq.h:6: In file included from include/linux/irq.h:20: In file included from include/linux/io.h:13: In file included from arch/powerpc/include/asm/io.h:619: arch/powerpc/include/asm/io-defs.h:51:1: warning: performing pointer ari= thmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] DEF_PCI_AC_NORET(outsw, (unsigned long p, const void *b, unsigned long c= ), ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~= ~~ arch/powerpc/include/asm/io.h:616:3: note: expanded from macro 'DEF_PCI_= AC_NORET' __do_##name al; \ ^~~~~~~~~~~~~~ :46:1: note: expanded from here __do_outsw ^ arch/powerpc/include/asm/io.h:560:58: note: expanded from macro '__do_ou= tsw' #define __do_outsw(p, b, n) writesw((PCI_IO_ADDR)_IO_BASE+(p),(b),(n= )) ~~~~~~~~~~~~~~~~~~~~~^ In file included from net/bluetooth/hci_core.c:33: In file included from include/linux/suspend.h:5: In file included from include/linux/swap.h:9: In file included from include/linux/memcontrol.h:13: In file included from include/linux/cgroup.h:26: In file included from include/linux/kernel_stat.h:9: In file included from include/linux/interrupt.h:11: In file included from include/linux/hardirq.h:10: In file included from arch/powerpc/include/asm/hardirq.h:6: In file included from include/linux/irq.h:20: In file included from include/linux/io.h:13: In file included from arch/powerpc/include/asm/io.h:619: arch/powerpc/include/asm/io-defs.h:53:1: warning: performing pointer ari= thmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] DEF_PCI_AC_NORET(outsl, (unsigned long p, const void *b, unsigned long c= ), ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~= ~~ arch/powerpc/include/asm/io.h:616:3: note: expanded from macro 'DEF_PCI_= AC_NORET' __do_##name al; \ ^~~~~~~~~~~~~~ :48:1: note: expanded from here __do_outsl ^ arch/powerpc/include/asm/io.h:561:58: note: expanded from macro '__do_ou= tsl' #define __do_outsl(p, b, n) writesl((PCI_IO_ADDR)_IO_BASE+(p),(b),(n= )) ~~~~~~~~~~~~~~~~~~~~~^ In file included from net/bluetooth/hci_core.c:47: net/bluetooth/aosp.h:13:20: error: redefinition of 'msft_do_open' static inline void msft_do_open(struct hci_dev *hdev) {} ^ net/bluetooth/msft.h:33:20: note: previous definition is here static inline void msft_do_open(struct hci_dev *hdev) {} ^ In file included from net/bluetooth/hci_core.c:47: net/bluetooth/aosp.h:14:20: error: redefinition of 'msft_do_close' static inline void msft_do_close(struct hci_dev *hdev) {} ^ net/bluetooth/msft.h:34:20: note: previous definition is here static inline void msft_do_close(struct hci_dev *hdev) {} ^ >> net/bluetooth/hci_core.c:1590:2: error: implicit declaration of function= 'aosp_do_open' [-Werror,-Wimplicit-function-declaration] aosp_do_open(hdev); ^ net/bluetooth/hci_core.c:1590:2: note: did you mean 'msft_do_open'? net/bluetooth/aosp.h:13:20: note: 'msft_do_open' declared here static inline void msft_do_open(struct hci_dev *hdev) {} ^ >> net/bluetooth/hci_core.c:1787:2: error: implicit declaration of function= 'aosp_do_close' [-Werror,-Wimplicit-function-declaration] aosp_do_close(hdev); ^ net/bluetooth/hci_core.c:1787:2: note: did you mean 'msft_do_close'? net/bluetooth/aosp.h:14:20: note: 'msft_do_close' declared here static inline void msft_do_close(struct hci_dev *hdev) {} ^ 12 warnings and 4 errors generated. vim +/aosp_do_open +1590 net/bluetooth/hci_core.c 1432 = 1433 static int hci_dev_do_open(struct hci_dev *hdev) 1434 { 1435 int ret =3D 0; 1436 = 1437 BT_DBG("%s %p", hdev->name, hdev); 1438 = 1439 hci_req_sync_lock(hdev); 1440 = 1441 if (hci_dev_test_flag(hdev, HCI_UNREGISTER)) { 1442 ret =3D -ENODEV; 1443 goto done; 1444 } 1445 = 1446 if (!hci_dev_test_flag(hdev, HCI_SETUP) && 1447 !hci_dev_test_flag(hdev, HCI_CONFIG)) { 1448 /* Check for rfkill but allow the HCI setup stage to 1449 * proceed (which in itself doesn't cause any RF activity). 1450 */ 1451 if (hci_dev_test_flag(hdev, HCI_RFKILLED)) { 1452 ret =3D -ERFKILL; 1453 goto done; 1454 } 1455 = 1456 /* Check for valid public address or a configured static 1457 * random adddress, but let the HCI setup proceed to 1458 * be able to determine if there is a public address 1459 * or not. 1460 * 1461 * In case of user channel usage, it is not important 1462 * if a public address or static random address is 1463 * available. 1464 * 1465 * This check is only valid for BR/EDR controllers 1466 * since AMP controllers do not have an address. 1467 */ 1468 if (!hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 1469 hdev->dev_type =3D=3D HCI_PRIMARY && 1470 !bacmp(&hdev->bdaddr, BDADDR_ANY) && 1471 !bacmp(&hdev->static_addr, BDADDR_ANY)) { 1472 ret =3D -EADDRNOTAVAIL; 1473 goto done; 1474 } 1475 } 1476 = 1477 if (test_bit(HCI_UP, &hdev->flags)) { 1478 ret =3D -EALREADY; 1479 goto done; 1480 } 1481 = 1482 if (hdev->open(hdev)) { 1483 ret =3D -EIO; 1484 goto done; 1485 } 1486 = 1487 set_bit(HCI_RUNNING, &hdev->flags); 1488 hci_sock_dev_event(hdev, HCI_DEV_OPEN); 1489 = 1490 atomic_set(&hdev->cmd_cnt, 1); 1491 set_bit(HCI_INIT, &hdev->flags); 1492 = 1493 if (hci_dev_test_flag(hdev, HCI_SETUP) || 1494 test_bit(HCI_QUIRK_NON_PERSISTENT_SETUP, &hdev->quirks)) { 1495 bool invalid_bdaddr; 1496 = 1497 hci_sock_dev_event(hdev, HCI_DEV_SETUP); 1498 = 1499 if (hdev->setup) 1500 ret =3D hdev->setup(hdev); 1501 = 1502 /* The transport driver can set the quirk to mark the 1503 * BD_ADDR invalid before creating the HCI device or in 1504 * its setup callback. 1505 */ 1506 invalid_bdaddr =3D test_bit(HCI_QUIRK_INVALID_BDADDR, 1507 &hdev->quirks); 1508 = 1509 if (ret) 1510 goto setup_failed; 1511 = 1512 if (test_bit(HCI_QUIRK_USE_BDADDR_PROPERTY, &hdev->quirks)) { 1513 if (!bacmp(&hdev->public_addr, BDADDR_ANY)) 1514 hci_dev_get_bd_addr_from_property(hdev); 1515 = 1516 if (bacmp(&hdev->public_addr, BDADDR_ANY) && 1517 hdev->set_bdaddr) { 1518 ret =3D hdev->set_bdaddr(hdev, 1519 &hdev->public_addr); 1520 = 1521 /* If setting of the BD_ADDR from the device 1522 * property succeeds, then treat the address 1523 * as valid even if the invalid BD_ADDR 1524 * quirk indicates otherwise. 1525 */ 1526 if (!ret) 1527 invalid_bdaddr =3D false; 1528 } 1529 } 1530 = 1531 setup_failed: 1532 /* The transport driver can set these quirks before 1533 * creating the HCI device or in its setup callback. 1534 * 1535 * For the invalid BD_ADDR quirk it is possible that 1536 * it becomes a valid address if the bootloader does 1537 * provide it (see above). 1538 * 1539 * In case any of them is set, the controller has to 1540 * start up as unconfigured. 1541 */ 1542 if (test_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks) || 1543 invalid_bdaddr) 1544 hci_dev_set_flag(hdev, HCI_UNCONFIGURED); 1545 = 1546 /* For an unconfigured controller it is required to 1547 * read at least the version information provided by 1548 * the Read Local Version Information command. 1549 * 1550 * If the set_bdaddr driver callback is provided, then 1551 * also the original Bluetooth public device address 1552 * will be read using the Read BD Address command. 1553 */ 1554 if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) 1555 ret =3D __hci_unconf_init(hdev); 1556 } 1557 = 1558 if (hci_dev_test_flag(hdev, HCI_CONFIG)) { 1559 /* If public address change is configured, ensure that 1560 * the address gets programmed. If the driver does not 1561 * support changing the public address, fail the power 1562 * on procedure. 1563 */ 1564 if (bacmp(&hdev->public_addr, BDADDR_ANY) && 1565 hdev->set_bdaddr) 1566 ret =3D hdev->set_bdaddr(hdev, &hdev->public_addr); 1567 else 1568 ret =3D -EADDRNOTAVAIL; 1569 } 1570 = 1571 if (!ret) { 1572 if (!hci_dev_test_flag(hdev, HCI_UNCONFIGURED) && 1573 !hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 1574 ret =3D __hci_init(hdev); 1575 if (!ret && hdev->post_init) 1576 ret =3D hdev->post_init(hdev); 1577 } 1578 } 1579 = 1580 /* If the HCI Reset command is clearing all diagnostic settings, 1581 * then they need to be reprogrammed after the init procedure 1582 * completed. 1583 */ 1584 if (test_bit(HCI_QUIRK_NON_PERSISTENT_DIAG, &hdev->quirks) && 1585 !hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 1586 hci_dev_test_flag(hdev, HCI_VENDOR_DIAG) && hdev->set_diag) 1587 ret =3D hdev->set_diag(hdev, true); 1588 = 1589 msft_do_open(hdev); > 1590 aosp_do_open(hdev); 1591 = 1592 clear_bit(HCI_INIT, &hdev->flags); 1593 = 1594 if (!ret) { 1595 hci_dev_hold(hdev); 1596 hci_dev_set_flag(hdev, HCI_RPA_EXPIRED); 1597 hci_adv_instances_set_rpa_expired(hdev, true); 1598 set_bit(HCI_UP, &hdev->flags); 1599 hci_sock_dev_event(hdev, HCI_DEV_UP); 1600 hci_leds_update_powered(hdev, true); 1601 if (!hci_dev_test_flag(hdev, HCI_SETUP) && 1602 !hci_dev_test_flag(hdev, HCI_CONFIG) && 1603 !hci_dev_test_flag(hdev, HCI_UNCONFIGURED) && 1604 !hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 1605 hci_dev_test_flag(hdev, HCI_MGMT) && 1606 hdev->dev_type =3D=3D HCI_PRIMARY) { 1607 ret =3D __hci_req_hci_power_on(hdev); 1608 mgmt_power_on(hdev, ret); 1609 } 1610 } else { 1611 /* Init failed, cleanup */ 1612 flush_work(&hdev->tx_work); 1613 flush_work(&hdev->cmd_work); 1614 flush_work(&hdev->rx_work); 1615 = 1616 skb_queue_purge(&hdev->cmd_q); 1617 skb_queue_purge(&hdev->rx_q); 1618 = 1619 if (hdev->flush) 1620 hdev->flush(hdev); 1621 = 1622 if (hdev->sent_cmd) { 1623 kfree_skb(hdev->sent_cmd); 1624 hdev->sent_cmd =3D NULL; 1625 } 1626 = 1627 clear_bit(HCI_RUNNING, &hdev->flags); 1628 hci_sock_dev_event(hdev, HCI_DEV_CLOSE); 1629 = 1630 hdev->close(hdev); 1631 hdev->flags &=3D BIT(HCI_RAW); 1632 } 1633 = 1634 done: 1635 hci_req_sync_unlock(hdev); 1636 return ret; 1637 } 1638 = 1639 /* ---- HCI ioctl helpers ---- */ 1640 = 1641 int hci_dev_open(__u16 dev) 1642 { 1643 struct hci_dev *hdev; 1644 int err; 1645 = 1646 hdev =3D hci_dev_get(dev); 1647 if (!hdev) 1648 return -ENODEV; 1649 = 1650 /* Devices that are marked as unconfigured can only be powered 1651 * up as user channel. Trying to bring them up as normal devices 1652 * will result into a failure. Only user channel operation is 1653 * possible. 1654 * 1655 * When this function is called for a user channel, the flag 1656 * HCI_USER_CHANNEL will be set first before attempting to 1657 * open the device. 1658 */ 1659 if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED) && 1660 !hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 1661 err =3D -EOPNOTSUPP; 1662 goto done; 1663 } 1664 = 1665 /* We need to ensure that no other power on/off work is pending 1666 * before proceeding to call hci_dev_do_open. This is 1667 * particularly important if the setup procedure has not yet 1668 * completed. 1669 */ 1670 if (hci_dev_test_and_clear_flag(hdev, HCI_AUTO_OFF)) 1671 cancel_delayed_work(&hdev->power_off); 1672 = 1673 /* After this call it is guaranteed that the setup procedure 1674 * has finished. This means that error conditions like RFKILL 1675 * or no valid public or static random address apply. 1676 */ 1677 flush_workqueue(hdev->req_workqueue); 1678 = 1679 /* For controllers not using the management interface and that 1680 * are brought up using legacy ioctl, set the HCI_BONDABLE bit 1681 * so that pairing works for them. Once the management interface 1682 * is in use this bit will be cleared again and userspace has 1683 * to explicitly enable it. 1684 */ 1685 if (!hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 1686 !hci_dev_test_flag(hdev, HCI_MGMT)) 1687 hci_dev_set_flag(hdev, HCI_BONDABLE); 1688 = 1689 err =3D hci_dev_do_open(hdev); 1690 = 1691 done: 1692 hci_dev_put(hdev); 1693 return err; 1694 } 1695 = 1696 /* This function requires the caller holds hdev->lock */ 1697 static void hci_pend_le_actions_clear(struct hci_dev *hdev) 1698 { 1699 struct hci_conn_params *p; 1700 = 1701 list_for_each_entry(p, &hdev->le_conn_params, list) { 1702 if (p->conn) { 1703 hci_conn_drop(p->conn); 1704 hci_conn_put(p->conn); 1705 p->conn =3D NULL; 1706 } 1707 list_del_init(&p->action); 1708 } 1709 = 1710 BT_DBG("All LE pending actions cleared"); 1711 } 1712 = 1713 int hci_dev_do_close(struct hci_dev *hdev) 1714 { 1715 bool auto_off; 1716 = 1717 BT_DBG("%s %p", hdev->name, hdev); 1718 = 1719 if (!hci_dev_test_flag(hdev, HCI_UNREGISTER) && 1720 !hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 1721 test_bit(HCI_UP, &hdev->flags)) { 1722 /* Execute vendor specific shutdown routine */ 1723 if (hdev->shutdown) 1724 hdev->shutdown(hdev); 1725 } 1726 = 1727 cancel_delayed_work(&hdev->power_off); 1728 = 1729 hci_request_cancel_all(hdev); 1730 hci_req_sync_lock(hdev); 1731 = 1732 if (!test_and_clear_bit(HCI_UP, &hdev->flags)) { 1733 cancel_delayed_work_sync(&hdev->cmd_timer); 1734 hci_req_sync_unlock(hdev); 1735 return 0; 1736 } 1737 = 1738 hci_leds_update_powered(hdev, false); 1739 = 1740 /* Flush RX and TX works */ 1741 flush_work(&hdev->tx_work); 1742 flush_work(&hdev->rx_work); 1743 = 1744 if (hdev->discov_timeout > 0) { 1745 hdev->discov_timeout =3D 0; 1746 hci_dev_clear_flag(hdev, HCI_DISCOVERABLE); 1747 hci_dev_clear_flag(hdev, HCI_LIMITED_DISCOVERABLE); 1748 } 1749 = 1750 if (hci_dev_test_and_clear_flag(hdev, HCI_SERVICE_CACHE)) 1751 cancel_delayed_work(&hdev->service_cache); 1752 = 1753 if (hci_dev_test_flag(hdev, HCI_MGMT)) { 1754 struct adv_info *adv_instance; 1755 = 1756 cancel_delayed_work_sync(&hdev->rpa_expired); 1757 = 1758 list_for_each_entry(adv_instance, &hdev->adv_instances, list) 1759 cancel_delayed_work_sync(&adv_instance->rpa_expired_cb); 1760 } 1761 = 1762 /* Avoid potential lockdep warnings from the *_flush() calls by 1763 * ensuring the workqueue is empty up front. 1764 */ 1765 drain_workqueue(hdev->workqueue); 1766 = 1767 hci_dev_lock(hdev); 1768 = 1769 hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 1770 = 1771 auto_off =3D hci_dev_test_and_clear_flag(hdev, HCI_AUTO_OFF); 1772 = 1773 if (!auto_off && hdev->dev_type =3D=3D HCI_PRIMARY && 1774 !hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 1775 hci_dev_test_flag(hdev, HCI_MGMT)) 1776 __mgmt_power_off(hdev); 1777 = 1778 hci_inquiry_cache_flush(hdev); 1779 hci_pend_le_actions_clear(hdev); 1780 hci_conn_hash_flush(hdev); 1781 hci_dev_unlock(hdev); 1782 = 1783 smp_unregister(hdev); 1784 = 1785 hci_sock_dev_event(hdev, HCI_DEV_DOWN); 1786 = > 1787 aosp_do_close(hdev); 1788 msft_do_close(hdev); 1789 = 1790 if (hdev->flush) 1791 hdev->flush(hdev); 1792 = 1793 /* Reset device */ 1794 skb_queue_purge(&hdev->cmd_q); 1795 atomic_set(&hdev->cmd_cnt, 1); 1796 if (test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks) && 1797 !auto_off && !hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 1798 set_bit(HCI_INIT, &hdev->flags); 1799 __hci_req_sync(hdev, hci_reset_req, 0, HCI_CMD_TIMEOUT, NULL); 1800 clear_bit(HCI_INIT, &hdev->flags); 1801 } 1802 = 1803 /* flush cmd work */ 1804 flush_work(&hdev->cmd_work); 1805 = 1806 /* Drop queues */ 1807 skb_queue_purge(&hdev->rx_q); 1808 skb_queue_purge(&hdev->cmd_q); 1809 skb_queue_purge(&hdev->raw_q); 1810 = 1811 /* Drop last sent command */ 1812 if (hdev->sent_cmd) { 1813 cancel_delayed_work_sync(&hdev->cmd_timer); 1814 kfree_skb(hdev->sent_cmd); 1815 hdev->sent_cmd =3D NULL; 1816 } 1817 = 1818 clear_bit(HCI_RUNNING, &hdev->flags); 1819 hci_sock_dev_event(hdev, HCI_DEV_CLOSE); 1820 = 1821 if (test_and_clear_bit(SUSPEND_POWERING_DOWN, hdev->suspend_tasks)) 1822 wake_up(&hdev->suspend_wait_q); 1823 = 1824 /* After this point our queues are empty 1825 * and no tasks are scheduled. */ 1826 hdev->close(hdev); 1827 = 1828 /* Clear flags */ 1829 hdev->flags &=3D BIT(HCI_RAW); 1830 hci_dev_clear_volatile_flags(hdev); 1831 = 1832 /* Controller radio is available but is currently powered down */ 1833 hdev->amp_status =3D AMP_STATUS_POWERED_DOWN; 1834 = 1835 memset(hdev->eir, 0, sizeof(hdev->eir)); 1836 memset(hdev->dev_class, 0, sizeof(hdev->dev_class)); 1837 bacpy(&hdev->random_addr, BDADDR_ANY); 1838 = 1839 hci_req_sync_unlock(hdev); 1840 = 1841 hci_dev_put(hdev); 1842 return 0; 1843 } 1844 = --- 0-DAY CI Kernel Test Service, Intel Corporation https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org --===============4339029617058625209== Content-Type: application/gzip MIME-Version: 1.0 Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="config.gz" H4sICFKTbGAAAy5jb25maWcAlDzLdtu4kvv+Cp305s7idvsVJz1zvABJkEKLJGgAlCxveBRbTnva tjKy0rfz91MF8AGAoOzOIomrCgWgUG+A/vmnn2fk+2H3vDk83m2enn7Mvm5ftvvNYXs/e3h82v7P LOGzkqsZTZj6BYjzx5fvf//6bfef7f7b3ezjL6env5zMFtv9y/ZpFu9eHh6/fofRj7uXn37+KeZl yrImjpslFZLxslH0Rl19uHvavHyd/bXdvwLd7PT8lxPg8a+vj4f//vVX+Pv5cb/f7X99evrrufm2 3/3v9u4w21xcPnz8bfPp4tPm09mn87u7i/Pftg+bh/MvFw+/fb7//OXy/P7s4ezkvz50s2bDtFcn HTBPxjCgY7KJc1JmVz8sQgDmeTKANEU//PT8BP705BZjFwPc50Q2RBZNxhW32LmIhteqqlUQz8qc lXRAMXHdrLhYDJCoZnmiWEEbRaKcNpILi5WaC0pgQ2XK4S8gkTgUDujnWaZP+2n2uj18/zYcGSuZ ami5bIiAzbGCqavzs35lvKgYTKKotCbJeUzyTgYfPjgrayTJlQWckyVtFlSUNG+yW1YNXILAhKak zpVelcWlA8+5VCUp6NWHf73sXragAj/PWhK5ItXs8XX2sjvgFruRci2XrIqHGVoA/hurHOA9h4pL dtMU1zWtaYDTiqh43misPSoWXMqmoAUX64YoReJ5YHAtac6iYRWkBiMbftRSIgL4awSujeS5Rz5A 9XmCasxev395/fF62D4P55nRkgoWa82Rc74amPiYJqdLmofxBcsEUXi+QTQrf6fxNDqe22eKkIQX hJUuTLIiRNTMGRUoi7WLTYlUlLMBDVIrkxzUcLyIQjIcM4kIriflIqZJa0LMdhGyIkLSMEfNjUZ1 lkqtFtuX+9nuwTsdf5C23+XomDt0DBa2gMMplbU3rR7oJxSLF00kOEliYptlYPRRsoLLpq4Somin UurxGTx1SKv0nLykoDcWq5I381t0EoXWhN4mAFjBHDxhsW0LPd6MY3B4AVMxyLS2BQP/YDxplCDx whzNYIAezpzjFGPL5lg2bwSV+jCEc3gjOVhOQlBaVAqYlTS4t45gyfO6VESsAytpaYa1dINiDmNG YGNn+oTiqv5VbV7/nB1gibMNLPf1sDm8zjZ3d7vvL4fHl6/DmS2ZAI5V3ZBY83VUOoBEzXAtQqtp aLT2VzKeg7mQZdYaxiACyVzRtGJ9x+L7A4eVMclzYm9exPVMBnQTpNQAbixOBwg/NPQG9NISsHQo NCMPBAFU6qGt2QRQI1Cd0BAcFZSO1yQV+IDBiCxMSUG+kmZxlDPbghGXkhLSiKvLizEQ/DpJr04v XYxUvgEgPOLc56xB4NJysr76OGQ3ekE8jvBo7MP29tbo/KOIggrgHuDAgy3MfwKmwhZzYGjsUyuB vPtje//9abufPWw3h+/77eugCTUkbkXVZT0uMKrBKYJHNCb2cVhUgKGXmLFSnZ59trxRJnhdWa65 Ihk1jKkYoJATxJn3Y7OAf6xkLl+03HzuzUowRSNwaSOMtrsBmhImGhcz+MYUQgBEyRVL1DzorsAL WGNDmcsg0ya80oolcgQUSUGclRhwCiZ2S0VgHlArSZV0/IjgMXJvcaFBhmtClyymgelgILgvFdx5 t3oq0mP4qDqK1qE/lHdCDO5piCKWgOY0XlQclAqjj+LCSvdbl1or7okaUgU4yoSCZ4shYCfTmGZ5 ZgtCoB0H1oeaB2LTibaw2OmfSQEsJa8hjmISPjBLdLoeVqSkiQB3NoXMbwsSWAdgbm6dBSMpn+Zy EWZyK5W1C/BhGEzx/45WxA2HcFqwW4pZgj57LgpSBvMFn1rCf7wQCPVOgv4u5uDy8ZgbiiVU6aXO 7yfjooKsFmoNUTpHbEoV52cIZjHVyYHxvtbuq3T4oQ95vRQKqKQYGFTICmVGVYGmPuSmQ4WlNa1F BA8oNRl5KOPRtZWVafUmDnawCDLz7GqAE0jFMT0ML6GGZDCwAFpxbzcsK0meJkEueqFpyB3qvDq1 7W/ueHTCuD0L400NWwzvhCRLBntpJSoDswHriAjB7LCyQNp1IceQxikmeqgWGPoBxZauljSjCgTV Qpfa9hb7ymNYToPDMDqFChSLTK5LqDSMjxvsWNLrkGiLiCaJ7du0jaGRNn0xNGhOfHri+AKdHbTt qWq7f9jtnzcvd9sZ/Wv7AkkmgWgfY5oJmf2QMfjM25zgnWz6ZLowPLocwFko9lCIgkpsEbK3nESO VuZ1FNQVmfMpBIlA4gIykLZLMjGNjr2YSDYCrJQX7rQ2fk5EAtlu2DTkvE7TnJqcB5SAQ9ThIVcC 0TtleVestYJ1m1A9aRVfXnQJXrXf3W1fX3d7qL++fdvtD6bw6SnRuS/OZXMZigQ9njaaYwvua97K rhJ6WheWVpjFZnIEdeLLwhtVFJgfg/rPQzMg2tFeoNb+NHRYhRX4S6GzH6snh0wTzkVEW4fWinYs N7uYitDAyoQRK65cXkR2E8os0TbmoiCQyZUQ2RlkzgW5sZYRImDl1ennMEFnBR2j00/voEN+p27N SZXJ2UztCsWGJSoslzqUdiZNygToczyvy8UEnVbjMJnAulZefTzt91wWrGEVs5y/Ahdoah9ZV5Xb itVgYJHmJJNjPHZpIG0bIzplRYIIdrgYo+YryrK5cjTNCvlE5Os2tNpFStl2nrBwPP184ruokCrq fJQXTIF3IAVYPeatdjRCbayTKGtOLz9+PLH0BzuW+mz9AMEiKkzmg1mBZFFOPZJWItidEjyiniFC 1DRZd8BIBxwjsbw6C+OSY7gl4E4cWyMra7+3vARHW1hqV2WmEa+7qfLqovViT5sDxg7LifUy5YXV MezyFpljzdB7FsfjXVNwFxSK8XAlAuG1pKpTjiDNAkJUVkO5EcTSilSQDRNBsC004VZ5atJqLA8g mXKuKRAPbgtSyxvQF8dEiko3TYbss2q1MBQzNLKQmbD6XbN0v/2/79uXux+z17vNk9PiQguGsGW1 ZTtIk/EltuMFuowJtN9z6ZFg1k7G3CO6ewgcPVE8vDGIryA9AE/2/iGYksmK/JNZeJlQWFg4gAdH AA6mWeoUMVycj8do51Arlk+I1xLQFEUnjavnIL7f+sT4bp+T5ztsaoLE3kOvcA++ws3u949/mbzR bmYGNLPjwe6ftu0oAPWcEWynM7rN6VVMzgxmgAWxGQ98rmmTVSxcNYNbaISKg1OMvJSdRO++4eXu q73e+W1z6nqhAXGm3b9Nej7hsAyXMJsrYONGn7nAywfHhRA1hwBfm+5wgA0U0tg1BDuuI6hUlA5C w/RcVXmthT/h6vQlHwyvWIlB2K9xaKkdfnvn17J7i0bA/2w1XNAb6jhGDYBUJFg/Q/mGiTYxwdLu 7nRgfUcbMl0BKWmT1IV3I6ebzphZDglPbYe1kicUspY5S9VVn9OBQaJZo9oitSYCBfYqNrPpnEpp uPjhneY0Vp1oCqDIfQp93wYErRitlec5zUje5SHNkuQ1vTr5++P9dnP/Zbt9ODF/3OTSzKSTCTdm XSx0AuhlETonNDsfcr/2Zr0F92133c3xafUNFKa5Ol3gUE2Jq9Nzq4bSii2L4HkViY6tw+U3vYGQ 2ygCJR5UqQO8ckq4qpjsRQKqSxzNvadTn66ujR9uaJqymGEZO11IjllBXmBlnoDKhjP16+nOo2iX En1/tVyMmwbZ60NQHoX9l81jUNwS4zes0Lww8Nr0PE0xIzj5++7E/TMYpn6XADzEMbJqvpYsJgPh iAA0KWdRI8AVVfaGMMeqSc5uR+7Leaex2d/98XjY3uGVxL/vt99gy9uXw1hkxsBjp49sfInfd1mY dDpwrL+De2hyElG3RdaJcS3RaNMJD6NtflCeuoS9ZSX2seMYfIBn2+hC8KWIYmUT4aMNz3kwWDQW g7BW/4HEwi8HDFRQFUTwKgxv2UD20KRe51Tj07rUbxsaKgQXobcOmgyKQQ+i96c5ziGLH1dtmCFj tG99SaBzBo5DsXTd9d499rJAy2of3vi7wmKogVzI1KSt7BtS+YvE5tt0hy2wK+wGYRTUlx0KRNE2 zkNM3IpsgGMi1y7MjUSD3BwV7AI9lD0ZBHsYbGIctqiCaLx5fIPEeHWnh68nXhFQWqz00TWA3CBb JAobNqPzMYfeSJJScNPVTTz3o/4KqnUMyhRbriS+rpkIT6ejDL4p6Z5RBSQiaYyF+REUZgtONT4a MiIcjLvFxASC0WTo0FPG49cXNho0Fjtftx746PODKQr3DYJxCG8+RACj6PIGGrPUvqQHVA2JiPY6 4MF0GzzAn94whf5AP0tSzqVrb5t6uO6cju+Bxs2wY500q0k2jC6XUFeDz7KvUnNsNmCXfQU2aCE4 vrNjmaxhw071Y5pn52cwi5ZZYBsYtxrF3R4G2rfdwvaXr5V2dD1lwlXMl//+snnd3s/+NFH+2373 8NjW6UMVAmRtaA2oWb86TWY6x7QhboPz6Ex+g/mN6Nnn1ZCH4o2RHST0fYkscPZTT498xWozvZzb 3rxF1WULHuoWe4xBh3ogIRc/6ftbnqDXkAjEMjCdFHH3Jnfq3q6jDL7AaJGoW8KEc39chxpdDk+Q 3dyO1o8XCaumYFKiE8Annrrub1ihO4H2pHUJxgz6vy4i7l6aDdd3ghUd3QLvwCYXJc2jnxzitX3d HqFB2D8uIGeXDMR8XTtPYYcHHI1YtW0jC4U37JF07qAtMGSHR2/mFc0EU+sxyx7VqNOTEHMsO0K6 1eEhAeFK5Y4rHeNALCufe1uemOglgtJHslUU7jRa8mL4uouW8fptwphPNC7NmrFvm4Y1QZ8ctrAr EvI7iDZPrqF0icW6cvO8ILpJ26vPzgNWm/3hEd3KTP34tnX6JSAlxfQgkiyxERY0eJlwOZBa1VTK HPDQtvFmtNdbXOu4yri7DV0smnfDfHjyZJURMI5xU5jiWwVdgz4HkIt1ZGccHThKr4F8kHt63XSn N3pZNDySdZYy+LrydJigLtsTwG6M9pqj6NzfFxAFwTluRGG9etbu3QyGY+Cr0l492CwtppA6KE7g +lJmulX0RhPJGixW4aEj+HDDXjC+sp6T+z/3hCUuHdx/TqoKLZokiXbBXVdVawT9e3v3/bD58rTV H4LM9J33wdKNiJVpoTADspQzT/36siWTsWBVqFBs8eDlY1tXkA1WBUEVmVqbXnixfd7tf8yKzcvm 6/Y5WB0fbTYNfaaClFCSBzBWQwyvDfXbmQoCltfYsjpWN9jqoyHUEv7CPLBvag3JuE8zlYrrd5yZ Har0US8orfSzC9c6dI+uw+E3IZbGGIHYb2xdzKit6cLbJU+iu4sC7n3QIqscctNKaePS/ccL7x4y 9rsiljfNMNNBW596UtN/txDqXWHmiwbQqP7qe9BdSHuDr8AW0tKBblf6GEGimt3Vxclv/WPbGGq/ UtdUNvc4+PbttuI8H5zsbVQn1k/nKaT51s86I3VbYx1Md2oCE3SNB3Mh3HZWbAawHyoEeiklajAT LWF8Ahh6iZt0rz7GdaC5HF7q5oDVbzOdYlyc/Y0GBAX3e6KhNlHU1HDESfynzXywTftR9yJCK6Rl lyprX1FuD//Z7f/E25yRkwClWwCHZ/fnJmEksx0VhKLQ0zKVS5sKfmwfpIZpofiy7OEmFYX7E+TC mfOGTAMn3utpnG6Fp+jQn71Rso4avKuNQ09ANYUxGDqaT/f+pGJxKHfWFJChewtnldt8wEvpBV3b q2pB3bRBG75JKv18lqrQ3Myc9fDCrjJOGT9yCbIDgi75aiAjUUE5ApHG4ad/UIMk3gxVGX70itth 1cSLWIPMBHZXijqkOYaiUXXp9KnlugRXyBeMOoWPoV4qNsGpTsasEJ7y2j4CFGBDQh+paYw5Vpca YNgc8wvWEREoYhwKXcws3dUODdR64y9aY3qgOwvaZMiu4grbVFl/1AO3HhWxeDDxHhrXYfgKXNSK 8xCjOfwvMGIuJ+DryG469fAlzYgMwMtlAIjvNHXWMOafV0HmJQ+A15TMA2CWQ5TmzFG3HpnE3qmO SeLk6KFEkRjW3X/L2YrFDkYaoeUSnG+gKMN33R1Bd3hHiYTHxUN3q7/68MePL0+bD/auiuSjZFb8 A7O8dF3G8rJ1NvgxUhr0OEBi3pejm20St1eEyn45baaX2k6fffr3GOrlW5Z6OTZVXGvBqsvhFDWI wQE+u0MnDfpyDEUW4M6cbSBMhvMPRLU83GUYB+estUvT9Z2A9OaEqIhdHzk6sUIf2dTckmaXTb4K OKYeOy9IfHS4eZrv6UmV92yDb6LQrTgvqFAFcehU2MEvxrHBXxARflvf0UBKrPvEEO2LysupB1L/ lqEH2d7WtD12+y1mWlCqHbb70W8JsOdvOcCkWJAemxj/B+5pEVpASgoGqS0RVQjbDsSbA3UM333U PUmQ8+wYmkurMC5TdBulTpIdKDAJfCvbIoAVJI1HxYBcvQ9E7bkaPG2P84DEjmDYqTpk+MnVRCvN oTO3hW/Ttc9N30eotfBtUn1JOD230lfHHMJW0MPZJJnbv7BRMlbTS+mIIOOCajb4rbG9YIJv1IiT Btvo9MhMPdH8/Oz8bSomQu7HIQl8Ee7gQd8ixmVTysGnOgSydHJ8R3sqVU1qoCTlm5KSbIq1SpWH UpZf8E6ns8s5zatguj824SyvIfl3hVIS5cgAfh7O0gXjwn2YXrIPhGKbCTqeCKxXghsSJAk6IigJ QOVu1s6wPrjZ2zdAHXLD0m4JjMOx+SnsFzn3rwiLHRn0n7h4RHBO5neHOGDXbSJgTIP7dmfQInKt RaGIgtsJFQoI5dHvXt7loKd+yYfBcUV8foLiK5BJfpMv6BGpPwpxtqirfgdiCl4X5oUV2KrRAU80 nW6Ejzupq+BZT8HTVdLBn8d6eNPrnA7nN7oz+zq72z1/eXzZ3s+ed9jMt1or9tAuQoVQqEEaHZxU P+J+duc8bPZft4epqcxzufb3rDyHMo+ByNT8aVCAIfLjS+2o1HH8/G0W2HHTL+UnZNaSTSQnA8Eo MbBpJgwrwKbET0Or40suU1zNGyST6ZZFxE3+dJQTdpCwkXicqHO4R6ks73uUDiZ8g0CYPtwxkrgq pPTV+XlzuPvjiOXgLx/CbrNaV3TyMA3Z1CfrAVJzxfqWArS0eS3R809ZU0sFGS7khu9eABhTtFZT uWl4gM4A/9EAjDv/ZIBfOR2nPqarLZX99WAAj8nqcQK6NL8S4Lj0ExlOeseUNC6PrtjrAwYoMKz9 I8G+Ix0baPOj4mg7FMc2wCpBymzKFjuapTw6T36m3hJDTsts4pdrhKj/icDC3YQg4WQsaQl0Q8T5 zDBAVaZTlXJP4uYkAbx7Tx6gMPcRx0kWSru547qu87T3irKNFe8Tp6AkL944dogpnpubpsVi8g12 Jv97JztlbmyOU+i24lGlkEo4t3gBkjZWHV875ijvW3l9fqYPtfue6Vi7aGieuZ/wmZ/1R8RnHy89 aMQwR2mYe4fh4TyzmqBDawnfFCEROr/G+S13DtxPuVzsu1jra27LxY2xZUAs/fxxGIWI5/C6gF3L 9Y21lVQd4fGu8doVBbcGSObfZbZ4/csJwr8ICCiWXj8XAKMmqYPUD8ccKQEQ6pv2je5Z+1wKQsTs sN+8vOIHcvjk9LC72z3Nnnab+9mXzdPm5Q7vlEef+Rp2pk+k4sqfp28ghRFkFIBtLKAmd9WNnxrr N7aGTb52T7H8TQjhHQbAVmLiGhVwua9iSJ9P2twSv3uYZMaXqaMoyD/KY19sCAssMwleoGiU/Ysa DKQYQSRN/MnL65HKrHifzWtByvm0LEHDexX7bI0pjowpzJj/5+zLlttGlgV/hU8T3THTt7EQIDgR 5wEEQBIWNqFAEvILQm2r24ojWx5Jvqd7vn4yq7DUkkU55sELMxO1ZlVlZeWSV2nWq3x5//370+Mn vl+uvjw8fTe/rfaJ/lyOrIDGvhQb/O8r2ntJp5Dt25i/XkgxNgAuDjEBlxVfQm8xwSltFWBs2s2R JG4t2lxUZBgtQZW6+iggYCOhXL7Q7BhNWAi4fq/CEHIxU05UgeJKT5lJAJ435sMTwsdr3JGGC5Fc nqoZ1TbiKKW5eSbrOu1hClHvfDneSiUNo/a9piEw2lcdSJdVgW7jiz44MC/j6JiI8anJRIz1yNLD NW4d2fm/w59j6IVxQwvjavCZbUNTqzZSKzq6fb6zHUYLC6t1LHwZUmwcyjwUakwnzVEo851lHiWa 7JSTgXUUIlz9RvWj/N90yrxKqGNhQWBvRJRHa9NLeh+XKNrO0iLWHg2M6Q41Imalka7tJcnoNRPS y0KngJVxDW2supnrrzE1uUmHk7o2zZJvD28/sSSAsOKquuHQxjt0tK9beem9V5DUjER6ecrTgyLX 7a7ualwnMp6r/DEvSfL01f6oPH4yIJln9WiTqXxlH17AhGjIkd2+5T69Fsz01TJMtlYvfRo9o4/3 n/6teUxNRRsdUYvXCpBFau3Wib8HDNVT7z4kFg2doBktYIQNGjdqQIsXYjCt5OwYu2bdBKE1jjL/ 4idbcK3mNqWMCzolJjz+GsoszWNVIudw7vehGGRysMUQLe5KmcPh55AUpFcUoopY9rJASNnUsV7A rvXCiNqUR+2U9EsJRS7Dzz41eLLkckB5SV6cfLnaDNG5LR5Tom8JwFcNAHvlYYgcz72lUXG79X2X xu3apJxMJqwEVz5t2ow7SJIUx6yAK0OW3dDoA7vkDY3Cf6+1yjoMmRVTdpZm3LCPNKLtivVgKa1O sqLuruGuzchtYikWuHXrOz6NZB9i13UCGgkHQF7Icp2M7Fu2cZx+QZ6hIr2BC2w4nFs1nsKCKs/k LUEcZ6qtIT/grPbAhXzDhB/e8ivu4uJGXijoNBc3TZEhgrKW9qRRKeJmJxmaH+tKfvUNi/rSxMot YARNC5sof6KojolREgLhU9ZRRSIOZQTre41MeKypkZUpdLlXxpX1Li/yjnpilclwPlAlaSkFNuer 7TwADTqqH9P2nfYeRGnmeCEiT0pLV+QKUlqdTJFyeZmsaqLgjCiJx1mWIUcHawo2VMX4Hx7cN8f5 k52XJMrZrGARKxbk2BDK5jBO5uoV+3NblPA0kYSitGIY2rrGHDHyotvBYRZzV0iihBp26jPsuRis Sar0bPcEmEx3RjeNqelNoT7pcAhs57LzE0IWXpOhcInSTEy5IMzUCFLM8oo1iA6oRhWoufTxhRlV 4Qrqtu0UnRX+HlhJ2+5yJDTO6mtQJYxyDWjlkALtnvHQILK3AXpitb0wiYFmckfBBd0rEQmETyfW 1rSyi6mEWDwopLZB+bsTuxvGKMwTQ9wq6gqMSPyBtP3FIvboIT4ZEMkuPau3h9c3TXjmLbzpDllF Ss7GlxpC9hKSpj0u2zjNKV1lEkuyAPxQ9R4I2MmSCgIOGsEHd+tvZW5AYM5qQl0LmFX68N+Pnx5W qRSZTvrunMQ0o3Bkn5CrHnGsSNTzJ+Fnz9la2Bg2kzs8MXKwidbODKBsTTuMkpylFq9yzGthx6QW /29Y/myP0Uts6LhmzRW0/djddXNQJIWJgVOzuDu1RFAVEffq6cfD2/Pz25fVZzEoS3DBpQh06ZL2 IIAoUhn8Pib5rmPAjTr0FMtPKwsMWtsqu4+EOq61LkyICi5WlOuiRLJLZEcwCRF3R//GUm5BeuMv eP+iRM6RMGJk6FJhjdnmcSIBsfk9Ehjp90jiQ9j37xGV7dney7QrXI33+Yz61Iv/iCxOWRK3qfnZ Gf7Qn2EbFGZAwGCwDVw/KJjBSrdw7YHzSVYFWdl5lpf3sPu3jSSbTpBJN7VcdmcEj7k1FDWjl/VM SChHppOuvyHDq8CnN4nkcsm6NovLMZ7FAkaFbauGfEGWLJSAZhMExTgJmnF7Rpl/OQht6zUQa+4M ovwsD0myP6Ak5lJ3lHzHUdLlYoTMmihxLExFfHt4+Py6ente/fEAs4dmZ5/Rn341SnuuFAxihKAh wfRu3IvgWUtCoP1NLh/m4jePQ6pLjVtKFE/ifC+fgPleUqDJ0MpwjVDxJ0aFUUmy5qjq6iYIqgW6 7k7T8c1YDMygSbBTV/aK9zX8BNnzkHexxRYN8BW5MBEDS1ZW96PiKuWXzlG0uX9Z7R8fnjDbwNev P75Nr3y/AOmv41JTTn0soqmC9XrIPdoJgON9X62Vg/AT9cVCILwBdwBr58o8aWuRb9JaJes8F/6N tb6O0LniWfz6qW7P12cWg9Cu2wkN+Z5SW0meWxpETZiSYij40YF/BIFwC/xR6BcLLjmXTLWgQVFI 9VbiPvPc1X/ZXeK8wLAcy6hk3bEDEsmnYRY6MbriKBrPinxd+JOJmySX2bQhWbBJxqNk/l0muaJ5 FBAe22pIcmbIMU3y26f7l8+rP14eP//FeXEJX/n4aWzbqtZ97U8izJiwBVy6qYBhyLqjknkIBrUr G4tnEmxSVRoXVzLy8bL3eVte4laEn0yN/uwfX77+5/7lgVt2yA/p+wsfBOV0mEB8clMoUcm4g/Fa p9qkgK3LVzweoj4EJFqONjT3aKGcYmqRgrfeo/mgiXmM1/MceUVSbvE4XDTOBuXyPxxbcl/mW0Er n6ACihLz+MGgR0XmuJhnjRkpRNTeRUu9ZPLgebK0oL48hL4c1LjNDqUcY1T8HvcdFcbgckl8ixF8 CFiZGwVcXAOEgXnMyuU8olOBSbIzW9TkQ3yWI1GmJUYbjlvBc3tVv4LIfVYlIkIHHVTcsjzniLzL yTJxxBhgAuM11O1QyNnrOndAdaYK6OXg/3XfyUZqx5zlRQ4/hqJRzlIULGGXy+n0YSzHbR6DD8P8 EJsZhggup4mfvyqPuU6vBA7WTxP4p5oimEibB3CU6e04cWMli4P4C29ZuayM40CQpWkEy9v9hJH2 Xo477foRRWnoOmnzhh985cxmSEuAsO/3L6+afgCp43bDQ4vRGypSwF0q9Pv+HSopHBw5QEhT7wVa ba8QuIe8hA20UxR4C7Jre3lUEIPM38B0X6sQVgfPVEHUOqGETwgGLBIhk35z1WqUInhIYx5onY7f ZtCjTFRXxZ38FmxOCZ+TE/x3VQqvKZ5cqkNTwych9RT3/6gx2nBeihvYVrVuiU6YoKGV7nT7TtZq Gr+GVoqalqv4dp+qnzO2T6UdlJUjWhnEum5sUzSHtcOYWlwzOok2bVz+3tbl7/un+9cvq09fHr+b ChLOeftc7fCHLM0S7bRAOOY/mMAq7+5znvil5mH9bC3FfXgXVzcDz6E5SJHpCKx3FbtWsVh/7hIw j4Ch1gNvmV91TFymTN8LEA5CUWxCeaoLdUXEpQaoNUC8Y7D9yWL6lTkScdnuv3+X0mbwSyanuv+E Kaq0iaxxc+8nzTNTO49Bu4TXmTJ3I5jwuyTJaioCh0yAt1YRzEupnSWB5yTyOxFCQUbnCG0DZkHg aLBZqjZgQ1zV1V1Zn/T+FnEnpmQJf/XOaIq0uA9Pf/726fnb2z33w4SiTPWiMjSYuGBfwNXeOnhl cmw8/8YL6DgTfHyaLMYXi9xOAVe9wHKAgcRlcF9znHovt6RLAWophG90njgPxeXo8fXfv9Xffktw jOxqcj4IdXLwSQHh/fEU93S4eajsjBCh/VH6BTsdYkggBgHHqO885a/KDhPFlH1a32FHNNyD2YkM 3yFT1bK1iIzwetwhDzjy/2jnYHzhPbrCAblBIIJKJgmM5V8weqZt/DxOQKS2aIIO7ILPLaXyFGUh AP5L9HbLZLvkSE4x1cJZEYHzyvtRNLArrP6H+NeDW2+5+iri0ZHHEidTZ/kWIy9KR9BYxfsFEyNd 048jiD/t7KvweAdXSVp2TjtpCmolOg0Ibqcq7yxpHwCLOWTSbidHJt8PsKl0nRKEH4AiAiGJuql3 HxTAGKNUgSlXpprrBJXf8EHWnlGYyEqtCyL8KWV5AEi8Mi1maceszSo9MGGJmfYmzQoKLqMb3XJF ECBKAS9CKiuvFWOU5eoEY7cj7UWSVBzB8zcf6c1vKqoAOUu6g0lQHqJShIyJdLwwa+PfftVxabtT Xhnw9yAGac6GQb9+TL3bXYs+LfYZEzg2dclcL+O48lmJtInDhI+8SXqW9lUFPF6S2dJ9FX3RFH2Y zAf5BdVxihUCj6isz5fR7XZn7oPVucxWTN8BEaq9EXCQ8NNE7ZcKP16UTHUcto93cCQwHZpoAGGr TAKBdeF8PrZKalIZj+xBq38loj2p+5UIRFi8ZW+VR0TIi4+vn0zNA0idrG4Zun35xdnxpEmO08AL +iFt5BwxElDV78gIRZmTnsryju8tsoFMwra+x9YO9eYSdyXmBmJS6VmVFDXD917cgvAVfMFxtUZS 51WSqdmnOQKD+bYNNXpxk7Jt5HixGlo0Z4W3dRzKlFOgZJl0Gr4OMJia00Dsju5mQ8B55VvZIO9Y JqEfeAsgZW4YeXLTcGeHvsOZ2/hj5nXK4FRZ+j2mB+4Hlu4zRbJpzg3mKqVffDx9rxXSRgbna2lK GgIO0+ZJllQLMJC0tgKI6cUSJcTKiCjjPow2lAnySLD1kz4kPtz6fb+mHD9GPFwNh2h7bDLWG03M Mtdx1vLi0TrKO989/H3/usq/vb69/PjKs1S/frl/Aal1cVt8QinnMyyzx+/432WAOrwpynqK/4/C qAXLF5o0GApOey7inYjRjeB+tW8O8erPSXH9+fk/37ijpYgrs/oFEy4+vjxAA73kV1maj9GPIMZb b0O/xmXJsSbFQGXzmTmeZ4aRYzHlPDTImNv14f4VhMYHuFc8f+KjxPU1vz9+fsA///Xy+sZvaeiS 9/vjtz+fV8/fVlCAkOykLQ5geObIe9Kc4wFQLO5ipQXDQTmXBQRLoHaEGWkpPmHmyY/g1ALGa8qu xkQ6mBeLUVIN0EF1FreXFA8EdoP5HDrqRogEXN26n+ML4ZjhVReoJpb//Y8ff/35+Lf6+DnVj7dn zDlqcBdm75gucERGXpZjaHhJKR/nKc8eq/SSaQZ2y2WRKF1iTXJ6ytSclFK+H8JdIq9AblZA2DDH gLgmxCRaB6ECW0QNGcqlPGX/A+AY+YUS6YQAJVukWBJK6QTjocnepxTPQW12yOG4tAV3n0XXcsou Zw5vKuka0lJ38uFf7lXjhYlq1KaWcRUfQDrEH3S0TCwkx8tezmTvAAA3mIMHRhGf3nBZq7WcKgzG 0Oh5MhYCLq7bkKyKG3asrfjumHMd6DnHkOjWlhtzOcHghn1Lf8JVFtN3CzjbMfV3q3c40Z9rF1SZ 4/6ifI8+j0syYBmDnK0APmatPoUzp9P1pRlcD1XOOMlRpXB6+AuQwitwlxWxzRcQqnHUtTMDJxVP W9cdt6ehcy0t9PssUaqbLaPVQeHjr471kjdohs6By1plersEqDlnE01BJGbhkq3CEIbTIEmCOd88 xzvGIkrumgUmdvIsy1auv12vftnDAX6BP7+aO/E+bzNu+Se1coINWmCJxSPyWtHSPhYnMDQ1JsPl L8sWk/LRklXSOuWKOUU1DiQltbeJFhpDQAbXoy8TI9YJpA18BCr2wyMskaOvTbC63Dp//22Dy7M3 lZzDrFP0nqPcHzTEIIsL6JU2jqJ8eS7FjUqlU4KiCzOv+UvVkKvr6FxQHHkkjds5asx3tKh/314e //jxBjIr+8/j26cvq1hKBkfpw3eBJbbq6KW0A75ne49mGE6h6lFmaFx1+a3NlazsNoHvEPBzFGWh E1IotLhKjnmDfmGLD5rRYIVuu95srjRdoY02W8KFyyDRpXu16X1vS3bAaRiqZWGVFUVmVjW7Axpl jw5mV0peHMmMj0eUzVBNoyoVW9gJe5vEEeGlh8GiuuwGX0FMJIPe2v3mZKxhg0fRlLT3wUR7xsMA k4qyZAO3TrNCjcA2jToZJVYvXsg/ud7mqy1mY1X0t1gtnK9p3Q4+8LRkOSeeyvwk2EjX9wUabfXW j8XERZxwyYR+3Rovix2jbypyQWX8kZQ3FZrUaHJVJoXsEgI0Q39Q36AnGDpPWWro8d1HHSgOGs6e ree3J9x0rHHRZrqW1q9IJCJSdE2pniWqJE7R5EhtZBIXfZbCgjoogaiUz875SY+xNiN5hifq1pTC qeY4smSEv8eUmpOZ0FH3M0pt7JZ9xF1NboWADFXDRmkfneswr7nNLWksaR+3cRrfkbVgSmLM3yEN khDvFhmHFcO+JJ1yENXcii3pHxnIx1bbqg55XEFL9KLTJo49XHjv9OH0Ie+Yogwe2Xlfnj+4kW1X Hz8/1PWh0GOTTsjZ8us9rjue4ktGv2RJVHnkBdZTZqLRPUUkXBm354x0QpGJgCKu6l6SBYueXYy8 6gtU6OnpZ7iFCDfAkrbq4kSK8lqAyrzKy7hQwPuLrXNwXNvjo8pU/FB/ZxCQjGVyWnB+go9+5OJe wg3tv9rxls2qijss+b2Wwn/buqptQQZnMqmJVY4bpb6ElyYWTaJBYHXUarjEqdwmqxjmfbaMNmy4 BUpi7/WihfqYJbGNTIb+rjb30pFmfO6XzF75OZIpz0YSeSanfJcRdRG3cJFtbasWhY93mlInaMUl +7+wCq1WMxWANjPqnicX0nEue6emu6pu2J1sTnxJhr44iJCG5gfnXFKewg+Aw11XSagrUV/yj8op IX4Pl8CVz5sZ6hPQ3YkNc3T/uZ8SMq8EmuQBiS6u6IuQ1FzxdnJ9xPq8pcQpBHuNdJuDA5P7HKgA ya6XXQAinT45HO6DAC3K0b3ppwpX5xWQWR0dUQLCYpadI2N1NRz6Qi89TlGDdaRe8SeJx/ikj+Cq Eu4sn03SzaB0DW56wdpdO3phszUsXVZSbnqBVVWhZbSOIlf/SiHYXCt1SO4O1YkZbRT+zdMsLRfl HKSx2FLcKFTpjUxBEBuHgdLJJ00x1r/snX2nF8KP2qG/xHfWvhYshw3KdVw3sdKMp/K7eNc5WNor jj51vJbbqzapC6Iz5kgmwTNK/7biiujYaOuE7qFQvLCOXCEpSSLH7/XSbqcqiKKm+6VSzHiYaEA4 OuZ+Sra5LNHni3WZ6/SWpG5wNQL2yhNmaVDaRH7keWotCOySyHVNMKwBAhhuKOBWBU4XUQU4Phsf YHfxWvxb2j/E9N+waLsNSmn7RzF5dFLXgIrHR73XBO3pu1YNq8fBcASvKZ0UR2o3Nw6LWZNlqVHO Lu92MW28x9GopR19R7UPUR2LciF1RnMK85bFwSiMwxXkyodchIOhLbUulHWv+ARzYJ10mZJBGIF5 c7t23K0JjZxwPenquD6j/PH09vj96eFv1ZhunJyhPPXmlCFUGRkKP7qiUqgpQVwvOy2pFCXmy52d aJuEWY8xwA19I1viIKS4q3r55Z4oYSZvlDso/Bx2DA8nSjZHbJqhKZ2kPkOgGdQQoWVjeY/lSBwG PPttFHXc0YIt4ih5HOFqWDKshz/hqa3lj3qd+lzC6EhprDjOjrHH59e3314fPz+s0O131PLzbx4e Po/+zIiZInzEn++/Y3xC46nhgvqZf+Rfs2okLWG/teA6JRAM/Lzyfql+WJLZ/WSaSSRRpEcJn+Qs oYRkmWa69FpQLdzC5eKPNVpMvFPmeOzamsUD58GIvVfKdNraymljnRMpInEaWsvQX+gJGkueYJmE zLErE3y8S+XcrTKKi6NZVcX/0gXvNr6TH1EusZIIEN2/yYbBqkiGlHlh4FFPEBhRjOtUpUe5JcbT 9NZCR4DaxzdZsSNrlahAZgnbvec7lIC4kJVAs/6wdix1JYkXeO8UEaf7jbf2yJ6USes5MYk6Xliu xgFEF6lcMaLlIYRGt2vSfi6VtgP8hc9tstJDpeA/YVZk1xAOKtyaszjfrb4iaPXl/uWzMGfST47q rKpAzyCHa0am4vX02/cfb1b7lbxqTnI0ffzJQ+LosP0e7aN5DAsNw7jH3Y2S30lgyrhr837EzC5r T/dwqD1+g531z3stEMH4WX1imS1sgyD5UN9dJ8jOdErMCYvmG1/lAbI7e4hPbrK7XR23lG2y1GpF XELA0DBq4Qnc7LypQJO7uFFMHgQ4w31Ce4PSSM4MbpIxaTHE8ZpQI9pwV8UNl9gV1eE8zJgJRNky J9gQwxWmpkTPhcKX7CsWqOz9J0FzAprUuzYm4Ie9d0OB21xx91IQgyVB6EJ0wnfFsqbU9TMRPwlj OSfYjGJ5ml0w0n5LILsyTcim5fwB4lqVl7ht87olv0YXWNQ0X/ueW77U7Y5qMqJ2cVFQOAxxR/fl kqfwg8B8PGbV8UTNWMwCR443MyNwKZ9Ketoa1jcxd1+51r89y+Nwp+oUkHt5SHNL/HlBUJ+SI8NA rrTefVzYOanIbMt8rTlrcZAaHgAh4qVUgZQ7DbJ3pIDSE4RvELVG6aWjQaxO77oGxNMhvmNA1gYk 1iGBQRMEs1A9HVD57/UKzxbFCl8J9Ee4xEwUkq1vi1e9yFlT26bAwt9qOioBLvIdbLaS8oJDFWMY ARqVAH3DcHfWixkfeAVGaxcA8dpDi1ri6zaxbPkjvtkRddb4phA3ataWsbOoKbhaJPc/1Zp74iji k0NcZroT0gQbKhYE0ZWPhkKxJ6emfjasoqQOcaqCSHP/Ce9VhtdG1ymarTM90Kcq77fR0HR3lBmW MMLn2GWUF+DoJyRlfypSWN88HgjGRZnYmj28PN4/mVKXOLKFT1oiKy5GROQFDgmEu17TZjwOwOQ1 TtO5YRA48XCOAVR1TOeIiWyPBxF995bJAMRqMseG0rYyttWTWOLmSCRlVoGETdkhyFRVyyNCsX+t KWwLs5KX2TWSrIerUZql9LCVcXXH825ZR0yo0IazHpeKIOVhUkbHQbKsNOt4go2Wsm1V+iXHOVdK uKjPJBJql5Re5AexrLxSP1UUH3JtnRdFdHBBmQx2GzeyBCGU6WClNcc8o/1GZUIUFDSvG4KKB4Ih RhSDfNiM76vnb7/hxwDhC5KrbEwrfFEQV5QQFQjPq3eXgiBr0sQYdoGB7SnuiOKTomEb16Ve1EYK 89FVgQuul2M8UHhYFXrNE57omk5axr3vOs77JFe6kZc9wXkA/ZkGINm0bV6jw74WeXe1LDSCTmht zUhxZMjlvkcaekzzpvhQSsCpO+Z85Pv8nBEsIBDvs5iw6iQG8fbKRyxJqt4QDWbE+7WyxA1zhq+F qryqo+0YLtUaozFjhWek3jzY0HdZm8bX+WKUtz508eH6zjwSqoFFTRyysTgH9FNEJtrFpxTzev7L dQPPcTTKsmcgEVAVjbIjiI4crQ+JirbyUQni2k9SUNuZxf5uRKPVVtFYoy/OfF5lPQ/mlh/yBGQf SrM1TTTGVSPmn4OlLhgbCggGH10/uLqUu9K3ybZYxDnbneixFijbANYX6iQA6M/sVcC0V5qUF7sM 5EUQsuXbDYUdJkY0Rkah+okW4Y5oTukccEQRVvUWJV07xlbVG1tBxTwAYivHXOfqZHmPatDiqYmb djieB8y4nRwtIcKr4cBIo08MWdApfiUYZm5MoqFDmRrF8pwsMQIXlfcZszDsSE9h0Tl021JeaCU4 HxJMFKzcIwGA7leVnFBlgcEt4gzixXxxGB37JwZcVGdNmcMFt0oL+YGQQ1HMES5cGhx9lgfNUUjC zNl2F9UEIsWjtFBJ7WNSicTpWK6Vyli+1xp8wYRnaX3Q668vWVvvdeqbhA07NXTKKF4jhpMAmmKE htu7KGSShkCUgUHMF5zc593P9Pl4gVt/laqBMGYgTzkMl+Myoxh1IdvFazm30IKYXUYMDN/L6Eq5 dRK5ZCSajnrBWvBZf1fVjC4fx/XqxzfZHetqOWXUgktgOcjZLBZMDxcA4YA3vmTjY9TqE3GFXzas uyrhuTUS6nqOkWMxkcfacZTHngW+pt55WNJ6a0X4zJspgja5JVpbOpUIfKTFewHIDc0U1VmJPYCB jfSgpRjjmsMxvp6kXYB94JAcM1SaIttJ+0oCf5qSGnQE/6PQ5UyT3EaoAVB1jRJwSFpZMTFhQKwb b03GR4jKAVJlsjeqjK1O57pTnYgQbXuuRtwZ+jaIvIdmKzvf/9jIwRZ0jKpbNbBK30ESK+5w+5da N8G0mG5LtgmTW+Zvp7lpTyD2YLxGEUXXfG7zEuKVTXlagaHjT0kY20nabr1kDEmnwY4xz72gfI+G LZMdzGICwyvnocuoFoDcuBPKQiiyKLJKTag4FsspaG34TAB/X6UoumTtO2T27JGiSeJtsHaNTo2I v00E2tMYwLLok6ZQcgpcHQ61qWOUZFT9WZrKSsFB88zGT389vzy+ffn6qg1tcah3eaePJ4KbZG8d LIGPSWbUqpubMGtdMQ4tOc/HvA+OqSe3+/Wf17eHr6s/MHTtGArwl6/Pr29P/6wevv7x8BnNX34f qX57/vYbBk74Ve9ip7licyg/se0d7LaU9ypH9b0c3pCvitkoS6sFETc16dXD0W1Ssm6nFpbgQtcz CiACrVYri/aA4zOWHyoe7ZtSS8mU09VJryLba5caFcvPccobEbFUk/mqlYNoWWK5idk/HIu4Si1q O76tl2R2U46B1dsY21VeN4pPIMI+fFxvIkdv6U1WNoWdH4om8Sghhy/oRqu17MJAr7XsNqGn7xvn cN0bhD1TAaPkqQJrPFY1wlq1ZEDIpdD7Cav2Pe5oSuBKraSm0hrQ9MaSAtDAivhMivOAF4Ghklz/ rs1JDSzfx/zEW8txPTjwKFLrGacAy0u44lnnEONO2+oxdkAuEu/pBO0LfnMFf/Id0vIHkacqhCuK d8m1nt1Vtye4Gxjrkmugh11DGkciwaTxVsuboMNehaN1VNzlyuUPwJfSGAarywVHFlp9fdFsdU5t Ex7ORUSs+htklG9w4wfE73BGwa5+P9oqGg9WvNtxzeB2WU7f129fxOk4fiwdC+qHy/kqAfcslw9c 65mkMsZJ2545h6uSDgeN4asIYh6mHINKGhs6D7OiB1YgSPC4fYfEFvRdFuuk78iUS0qcOJS9tWgx CJoDV8swfh8Rz49NvirvX8fs2G8vz09P8F/COImH+ecnM90Q7hS/ljW7COuOm60Gakt0//A36rVM UJcWj0CB3brDiVm1jVMBaNuYaoYcKlWf839BLs3J8C6IHJ/G1LZL72U6PFSOLQk4HJkxTShl3CqX CA4VJvaKMhHvU8J32dLOETt12viYeDFSCBYZxFJB1myNrk0LUwGhLpi2n5nwSxslBDfzZ3vY47Aa BYVPDvsi642R0iUXhIGoAf/ubfXji5JS+Ac90AwCiyaK1u7QdpbVJrqpPKeOwES+Sk9Ao7Pcz5mE ZsTkCUcz+N/eooZHGi66XEGjFHMFfaOH65XHv+HhdU56uzhcn2t1HEVMEcbsDa/htMgrynWHY0E0 8tY633U5sWyQdHAd50Yd1LrNZXUCgpo8UbVmM3BgtzbGASHJ09sx+TDpA9Pa+f/21KhlgKSEwqRe BEvcKGehY8kxghSUg7xAwF6j89b4kKhWzQ+5svM2RP1NSwvVExLtJ20NGLWSOmiaNLWsDtmDltc4 3uK4NOJCjQtkSUxm8D5PNB5Cycx11+owcajnwEaE0eaJLxA35rxSmtn1/dbSSlPEQ2iPbtgaiMts aoNAMtNHDK1SMP5Lx8NP0nV+hGEghxsRZTMcbu0sGpdzdHouFUj6DdMOAsd2UQ0hffPy/Pb86flp FCdeVWL4o+iW+C5R1w1mjeLyljbmRRZ6vaPxsirJLayMGk8Kzu5A9sHYtlXX1oVaQ3pXxWUuvzUq 2ZLw11Ay2OeACBVakv5UfuWAH4qOTZgqsnz1aZam5qxjHPz0iPFKZckKi0DdG7kUmoZIatY1UM7z p39L87J80MFuGEQRBq9LTCP9jKdUXAm33BUayFdZd6lb7rrJB5J1cYk5LjAHI0YPBREehP7PPC0M 3AR4xa//JTmWKRXCffUoC+1mW6Wm5hU+j1F2gHDAK8fsCODRiDFI3phjOXC9iaLeay+P0yd5e6vv 1UIC1/WP0nfIOXumljUkSmLaGTScXQ065UFQoXOSL6FMFVH0v95///7wecWbQsT84h9u4Jjgnn62 xo4Ks3+070yNmYkdmDloutQuWg/0u6xt71Ak7JW9ieOvKM5mfH9gs9ZNwY1aNW1sx5g9Ku0k0Bq9 TS9xQ1kGcmSGT5uNnEpQgEutzn2H/ziuQ8/orIjR0a3q8MCBKNhqdMfiojchl0OycUhRH/LkrHPP aElndNtue8TR5S4K2abXqiiz6qPrbYxJLJsk6i3SpCAwxEkF2+szi7oxtR98O5WmQy0fhC1b4Vwt oa2oNNYgLC7jIPVgZ6l3J2OshCxkXfK5HERHgDDCUiIcbBW4yUqwLfHQAjrlHUvqymgJFylsDRES ShRqRXVsHcmpezhwljFU2kuS8su4ChVRuZi+0GbxQ20jSCB2Rvho5TgMl7FPhAPq9FJi3+vmdwMO ffj7O5xIiuww5jxqAjhhtL7HaaWvncNlmF5pFDaM+41vMUlcCDxrn/hbkd+b7CrgFuvchWTjEJ/u o2BzZal1cDHxIpfSSE7ssB1VKJLmSBtGcdTsU3N4taOizT9qm7e2vafQC7e8UJ5uYvuNt44cfJ8D hY7e2MmiTRAG5CRtwsDaYVZ4USKK05Z1VzbWVd01DMqMQq1lHOy5Oktx8Fb2ZhHg27I31uOljHxX cZ4nBnqWjq/yN5zwbrjW9040kt26JtcJbqYv9YIg8f0ousLuTc5qRt36xcKH3WctewmJQkWWTKm7 RLd4d8+PL28/QFLUhBqF3w4H2FUxV6feaRAhT0oiDrK06ZuLK3PDxUVR3xB53d/+8zhqjI2rCXwi FKTou7xWs0UsODjYiMGSv3UvpdaSEWV95F5I2IEO2E60W+4Pe7pXwvRDgeNtCCO3LbM3wxmqfb8a YOy4E9gQkTYiMoqnkMQLHD04C6nra4MjlUI93isUnm9rQkQGWlU+9h1r+31KjlEpfGIUBQKkgsSG jOixDJye/kI8bpIInb2XrmfO+p3mR5m7kReSyjbz7Q3N7nhmKjVd1ALm4rlFtNfJFCleRh4yDA64 GPnRRI3qoqfj8L+dTf8vE6OiBigtUfhlyjEA4NR/qqwu8baBRyPLLvQ939Zm2OJORdyR+lWVjneL rmI2p7NUIiTMd4dEkM0T8F6LzPdaGU1Kf23Gk8uWdSqrG0W1JE5pXuIpT+aYfqm89hk7NU1xpw+Z gM7PYFrjR6wR/nIiwqhkSCidSeO9L06TYRd3sFsroWCECDDgFniiheWRghdLEvBc4nY06oUwmQNK wE5I7Vhjs4Y46aLtOpBuRBMmaZSY7DP44jluYMJx45HDestw1QxDwVxrGyfwzCKL7ACX8LNvYmqR eluDjt5fVBvYjnYfnAZQw4/YKVcG2zGq0N0tciXF7HPPNLF3qg7gbkAPFseQbZ1IQMBzN5p5qo2I 8mhQSDy3N5sHtw9gJ185WSccZxfKoHbEQ6nRVg4UPiFQsOdKBQ2ub+tLQXzwr1RVdH4YuFQjhVsk D/vTu+swoKQIqcH8YmG2jBu4sHK3o6qAyV+7ATX5CsWWKBcRXkAMBSI28quyhAigMhoRWeoIthGB gP746w3Vo/HSQ9vATExziE+HTJx662tr+lAX6T5nR3OVtl3g+AR/tB3sTwHVMNz9ffpCsz9lxdgm cUZcXeWnhLmOQ62JedjS7XYbSHettgq60I30nV/LZch/Dudc0S0I4GgUosUoFj6l929wX6F8u8ck dil0e616D82YtWt5HJNJondIStch9XUqhWzmoCCUVHEqavt+zaSELVO4mw1Z89ZbUyn/0m7Tuw7d pA5GkrTnlyjW9o/XruWRXKYJLY+yMs3m3UZsqNFm/kbx5p/AiWqEOCP6fNjH1fyyRXypR3GcMV3f XJuXHYYZPXdmnSMC0xa0JTOrTOCvOMfzQ81tpOMbdrpSfcpCKj8k5nKkBkKcv2OkH6NKDBjVU3fE iWC/CfxNwMxyy8T1N5FvK/hQBG5E+p9JFJ7DSrPkAwhXMVnm5h3+Gm1zKdF1Ijnmx9D1ifHLd2Wc Ea0BeJP1BBxfKy6lYkExoj4ka8+EwvbZuh41dTxBnOoBMKP4KWPz2pRpNtaAVDqd1SxFptteW6WC gugjehu4AcGFiPBcYl1zhGcpylvbvgipYeQIonKUgFzXpcYXUR6VVkcmCJ2QaAfHuFsLIoxs1W3f qc4HidSj9iWBI8P3SSSh2AWor8PQJy0xZAqKczmCSj3LEduNpTpo7FUuKpPGd6gtqyz6NjvgQjZx XRLKssn8SVbtPXdXJrY1WbYb2G584hxIk55Y3kUZ+uSCLK+eX4C2fXZtlwU0OYoAvy6/FKVFiy0R UHmGJXRAVxxdY9Oi3FILsNx6dGHb623YBp5PTCpHrKndhCOINVl1iVDu5qyrW2oRVUkHd3Tay32k GJ0TDE6pWOx7pHxUJ8nQRJasVArRFi7SmdluwFHl8icw0munGb2h9A9Kzc1OliW9kLoDKhSU5LXD QCx7otFwMg7Jft+QFeYVa07tkDesodQKM1nrBx61BwBijDBtIBoWrB3qE1aEEQglNAt6cJ0P3z/3 NlTQLYnCj1xywYznBKVyVs8Fx7Y7e867ezuQBLbPYbeNrssJSLRe0z69C0kURvTR1cDgXK+gKcNN uO7o6BUjSZ/BoUnsHbfBmn1wnSgmzh+4la+dNSUkACbwww1xCJ+SdKv5Ncsoj3RkmSj6tMlcqr6P RejShTaXUpc8DRrZQsimYp0F8+UtV8fsOkbm5GbHzr0+QUBhM3VeKPy/rzXr2CXE0svgNrCWNV4S wnMtiBDVqyYGEx2sN6VLyZes69iGki9ZWYYhuTDhfHe9KI3caws7Ttkm8iKzXI7YUPdLaH9EblxV 7DkEQyKcEjQA7pM7YJdsiO2vO5YJJYp1ZeM65OnLMdfOX05A9B3ga3q3QsxVpQkQBC4x65fI32z8 A42I3JRGbN2UagVHeZT5nkJhacaW5BaBwZWs211SpAVsud21403QhBXV48U4wuAIzMJSus4wy7NE FWP2MSmOgABghGzdDHtC8Rc/DNRKtXkiysqsPWQVxmgcn8JEauWhZP9ydOJJCWhUpbv1a2hMeIwh YQdMl02/S0ykaSa8bQ/1GROeNMMltyR8pL7Yo0KFxxC80mX5AwzXKWLxUt2SKcWTWVwUdaI/YRrf /XRTlF5SLUACdIIaLMlGZDqlLwRe64FJlJX4PJvLet4Jhea2kjIYfZQMlkQX5gn4VQJGZSnB5y7e +Fdy6rEmi1uzNHaqIqLmOYcOUQ3aSV6piKNhAfhkE/P25lLX6ZXv0/qcmQ0anfoMOKrnQk+Cz1Wh 5xFRyxgn/e3hCe3OX74qkVE5Mk6afAWbiL92eoJmNne4TrdEj6Wq4uXsXp7vP396/kpUMvZhtHgw u82TXzFzOnmK5lYZ+bEd1sp4U7qHv+9foa2vby8/vqL7ANnxiYVzzHdHDe5c2/vlCbu1+6+vP779 dW2UbSRSc2Ah11cYSn5iXwaG13H74/4JxuTKDPAHvA6PFpm3xLMeOnB0WdkIhTU5DtYKlrI+9t42 3NCjOa/d9tqKuTnC0kB90Imr7IllN0XEovYFtoN9jLF8p0Sek214kUQECdIcIIDbYuJjBMujxckw xQqyDfXgh/ixghKOM70C4TGlAqsJqNYyNRNzwiYlfZ1QCGkPDUEy2ngsoWn+/PHtEzqpWFMglfvU TIsKsMl0gmwPEojQ2IcGeJQyIsAiZufkZSQEHD2S0YlVS5mzII9FYi0WM/1tHVmw5tDJGFdmIl5g 33hm/nCFpMRYQmTiBvye5YmkROS2+qOFg9Kr8dVFcTac4KGnNpbDfAPmymI+wtA0/Wbnb30dzmOY DEUTM6b39xB3GfouseFARs7nHU5cv9dHcASqgZxkhJbnnKMaL7S8enJ0D41sNQ7RKLwANqtrJMc8 hKsHH3hLd4AiCHpOIcknXTI0YvKU3uS3LPS0rus22QiLoqZUfAsWYGAMAxpcBBtKfzqiJ2ML/TOA R7SOaiEgVakjOto6G6PYLvRDStkxIbcbbYInVbpcUvaRx4OirF74nqEaUCGozbqTCqFMaibYQG8c M1pLl4KllZHBtPxEUyeeN2Uyt1AGpr2JHEonwHHC5EErPV9vwjlur7r9jdoaS3GsDBxXZSgO0o4j Dr+5i4B7tC1CGHZMXZurjnd94DhGuA35Q7T8n84A+PH46eX54enh09vL87fHT68r4RmQTxmAyLAW SGI+Gk7izc+XaZwYGDCmJWMlcoLJMUiCdeiD6/uwvDuWaC/PiC8af7v2rSsIPi/KE4lGyx/XCWjj GeEiQVpPCNRGY0TTp2KGeq6xRDseVmHjU5ZUEj6QXyGl8iICKjw01FpGuOWZQiHRQi0g7lK43sa/ xmtF6QfmMhOeIbbjVHjVaBKBAFInzISiXbT5TsTWm8JbG60vA5d89ZmQskOjgEVb2BmNYgBq2zRG jY5eDFq3UuOJRVHPBWLZXtaRqh0aV7PvAS/w+JX2FQ80nMKQBgC3tzGZ4RDHj8JZMlcu0NxXornG C4oOS/F0uyaHzlfwySxcHrQZaKZqNChEautzXXRoV/GPSYCBY08i9DY7lbJ34EKD2hOuPJGpiOaA GHCIQtrgW6JR5YcFhbJ1pOquJWQa+CTDSSQV/NNQJUuyMVH0NYe1hUo72aVJ0KReFSPLuBrGt2Bc 1W5BwXnk3quRuFTBcKEM/CCwDC/H2hzBFjLLLWshEDInXUfOChDZqdd/hSb0Nm5M9QDPtA3ZN44h B5obGvc2TBBYMTY+xJfPIKKsR1SacBNSZaNIHEQ2FEi1nkNx0iwqk+uOP1aur7eJ04TkupvkZWvZ 24A6MPTWXevVluR1josccu0InEeXOd68dAFUpdiQ9h4qTbQluaZMGhdGm8Y1wdqlm9VEUbC1YUKS C8vmdrNVbSkkJFxKXOp1SSVRvd5UHJk6SyWRrz0LptnlMaNZAv2U16TzrUxjXnEk7D7qyXdnmeT0 MdOemCXsGfYq8jKn0UQkx3PUlkZdSgrM9YRtUx4pXp2ViNYvT2w3nDWLlIVEfg6X0v8NcWcJeyV9 qt/PJFS3jhxyu9St7mVMefbIcWFe2cSOS3MEItk7nMqCMtqEll3GtOo3SZb7IFVAcQC59h2eEhLh rq5ZZxNhBMm5zfa7E+X5plM2F2tBXHAdziWZckAihG45YWzp1l0UeevrEhWn2VTUpKFViBv65D6G VxzPp08EcWvzSBaR7nlEg6f73tUWcyLXt0wl5XpiIyIZX+BkCV7DKV77kphrBOGSxGR8BacQ+l1H W/hFvMt3cl7NRE/PmQxKaN8il72FWwwBmtQpXmGWx8R2qLIZIb0nwvpNAgk+Dy7HhBOGGFgg+HCm i2R1dUcj4uqupjHHuG0s7SgT1N2m19vSl7bPc+FGc+XbNilL6mM+lJimg8wAkenzwpPAc3ir5PtY 4OgiWpO5oQTNiFeunjIC7mYYjInW0YyEu7Q981jwLCuyRKlrDA31+fF+ujy+/fNddvIfWxqXmF9q asw/KlakSx66s40Ao4l3mDbLStHGKc8ISiJZ2tpQU3wkG557uy44KUKM0WVpKD49vxAJxc95miGr no35rblTjJIUJz3vFslSqVQpfIxf8fnheV08fvvx9+r5O97kX/Vaz+tC2n8XmJq9TILjrGcw6/KL iUDH6VkP2ysQ4pZf5hUXJqpDJu0WvMwyKz30klaGgGP46xsmVx+SIpbzqAvspRIO1VKMDbPHyvjP gYGN8dCHHEdan3UJ22a3J+QBMRAimt3Tw/3rAy4BPvlf7t94yLkHHqjus9mE9uH//Hh4fVvFQkuW 9U3W5mVWAUfLL9PWpnOi9PGvx7f7p1V3NruEvFKKUG0SpJIDBHCSuIfJi5sO93E3lFFjbEExeYrA zbEZZpRgsPRz2PeKmrGBTm+OxKcik9zZx74RrZd3DlPLLdbz1Frr7oahKaFJS9ZYXga+kKM2ixdr WREgWHnaZrvAidXC4cC8dcMoTFoKrskPZHklN+qRzGRKNrA8ruqhTLszBW/pZdk1B3krB9iyhYk3 aNp6Cwnn5WfSSfOnF6dY7cNGeq06Madl8juD2VtBaVPwddmVFLuIkwuHirLOxV671Kp2Pi8TY//K hXurCcST0SwBEbgGeCKicG1U4JVmYXiASxXjANHNRAx8xCeTD8P+8eXhgvFLfsmzLFu5/nb96ype hkNZYfu8zeBb8klHXSPSsrn/9unx6en+5R/CcECcq10XJ0d9IFB+4ap8YZ304/PjMxxkn54xHtL/ Wn1/ef708Pr6/PLKY21+ffxbKVgU0Z3jUyq/AI7gNN6sfeOcAfA2Wit36BGRxeHaDejXZYnEoxWC gqJkjb8mr1wCnzDfl81pJ2jgyx4rC7TwvdjoQXH2PSfOE8/f6bhTGrv+2jN7BzL5hvQyWtD+1uC4 xtuwsunN4rgEvOv2A2BJPvm5meST3qZsJtTnlsVxGIw+B2PJCvkicViLAAlh40bEhAsEpRBb8Ouo 1wcFwaGzpssDBC73q2VG1PyMiKsf77qIuxRqnwKYDOAwY8NQ78MNc1w51sTIvEUUQhdCAwGzsHFl xwwZbAwQ1wbD0iOW2Ii52svu3ATu2iwVwYHRBgBvHIcY0O7iRWSQpwm9FVE4jM8Abh9NRJsDcW56 X3HeHccz7rceVwFLbIrcf68sDnn7lQZ2Q6k4xp2h94JpD5NlUHJdPHyzLq2NFsVUQljchaSVs7m2 DwqK98rw19dXny/ryBdwIL/mKGDqqI3TrR9tjZ0yvokignePLPIcYmTnUZRG9vEr7Gr//YAmoCtM xGUM8alJw7Xju8YWLhCRb9ZjlrkcjL8LEhAov7/AXopvpGS1uGluAu/I5OKvlyBMQNJ29fbjG0ip WrEoaaGHmbsJ5CJ1eiENPL5+egBB4NvD84/X1ZeHp+9SefpiO7KNT7qfjAso8DZbY1lpT/9jnzu0 rsxTPfL/JLbYWyWadf/14eUevvkGR5SULVNlGRDsK7ylF3qTjnkQGJtsXsKIrUmocdIiNIjMbiF8 Y9/FEE0MUImhL8nC/MAuA9Rnx4td4qCsz15oCae0EATUW9uCjoxWcmhA1rYh/RAndBCuicIAakhQ HGqcZvVZdVhfaDc0lGxkEG6vbW/1eeMFlPZ+RitvsDOU7NuGbNlmQ9FGkcmJ9XlLlrslx2G78Qnp pj67fhTQDufjKcjC0LPzatltS8cxdm4ONsV0BLvmPg/gxvEpcOeo7mgLwnWpp9oZf3bIas50o85E o1jr+E6T+MZYVnVdOe6E0psWlHVhuR9zgjaNk9Kzr4T2Q7CuzMYEN2FsHDgcahymAF1nyYGS74Ob YBdTrz0Cn3VRdkPsVyxINn7pk3swvcfy7bcAGKV4mU7wILoyDvHNxt8Yaz+9bDfm7ovQ0Lh/ATRy NsM5KeXjTWmUuEU/3b9+oXIpT+3EJ3L7cYY2cKHBJAAN16FcsVrNHANZO0uVQg7MDUNPOZz1L6S7 OuKoy3/Sp14UOSLBR3tNAaCUoN7zu1OVzRnwkh+vb89fH//vAyrbuKxg6AU4PeYybNSImTIWLu1u 5JHv6xpZpJyHBlKxxTQqkC1pNOw2ijbW1mVxsAlp32mTjjT9lqhKlivbpILrPNWdQcOFjq2NHEta h6tEnnxZ1HCub2nWbec6rrXqPvEcj7SLVIgCzSNfxa4dSwB6pY19AaUEdg2tTLbpLB1N1msWqXdD BY+CcEif/SZLWULMyYT7BOabEhUMIo9uMcf51xjb9mU2pncnCwWB1IIro6hlIXxqGcLuFG+tPMxy zw2saynvti5t6ywRtXAcEI+I8+z6jkumPlV4tnRTFwZubRkajt9BH9fyrkrtZ/JG9/rAFc37l+dv b/DJ7HbJLVtf3+Dyf//yefXL6/0b3EYe3x5+Xf0pkY7NQB0s63ZOtJXuCSNwDDGhAM/O1vlbHo4Z TFpGjtjQdcmvAE5vZfzVBpYOGdGVI6MoZb6I6ED1+hPPnfQ/V3BowO3z7eXx/kntv/rO0/ZUZHSu 9B5368RLU6MHuXV18jZWUbTeUALhgp3bD6Df2M/MVtJ7a0VBNgNVQzReR+eTAiniPhYwvX6oliOA W6OjwdFdk2LRNP2enPNj4h9tl51pt7RvlsQsV2ra6kyJh63Qb2jT5gjHB6V8fjKT0Zn5O0bG3H6r FzVuFqnrGFVzlJgRswFQUW/Uf4pxWVn7L8qilIILdkPNvb5SgTXl05vXzeBw1OhgERm9wkxEsRtS A8qllplfu9Uv1vUlt6UBgUZvH8J6oyPeRm+MAHra18iPvgaERZyqkAJu5JFL9WNtTEzVdyFtwDYu JNX0bVosfkB7+fAG5Tsc3HL3LgWloR7xG8RrHRXQxoBuTQYVvdXWZrzfOjq/Zgm52/vhRu82l9w9 h7L/mdFrV7X+QUTbFV5ERpZasPo84warNf5j6sKZi0/zdaqzCr9SyByajCeBlTdxxUf6ohCj5pGc 4/nmIHnchlcoTzsGdVbPL29fVjHcQR8/3X/7/eb55eH+26pb1srvCT+f0u5sbRkwpOc42hKp28BV HAwmoKsP3S6BG6Br7L/FIe1837EdqyM6sHwWUu7IAg8TpbMPLlJHEyviUxR4HgUbFHsACX5eF0TB 7rwT5Sz9+a1oqzp3jAsnskn883boOeZ7P69YPbP/x/utUY+DBJ1XrooIa3/O3TkZk0hlr56/Pf0z Soe/N0WhdldRHy8HFvQYtnLyLOOo7byGWJZMhjmTkmD15/OLkFYIKcrf9ncfbDxS7Y5y/OoZtjVg jTlLHGobKHRbWZtcy8GWQGMLnrqpcvaD+7222IsDiw6F3gcE9saBEnc7EFKt+x3sJmEYGEJx3nuB E1CuUKPU28Ihrm/UuJ/7WlOPdXtifqwRsqTuvEyv9JgVmZpeXUytsCZaHGh/yarA8Tz3V9lYyzDB mLZix7hSNIrWyHaNEXFUnp+fXjGvKXDdw9Pz99W3h/9ckd9PZXk37LVoTIoWybQZ4YUcXu6/f0Fn YSI/K0YNypvT2XQ2XSpXw5WIIwBgst5uehSTwELD93L/9WH1x48//4RRTPVnoD0MYpliROblkRFg Vd3l+zsZJE/mPm9LTBA/wOWS8gHHQvdodFMUbZZIN+oRkdTNHXweG4i8jA/ZrsjVT9gdo8tCBFkW Iuiy9jDE+aEasgruxZXS513dHRf40lnAwD8CQc4OUEA1XZERRFovFOu2PVr+7bO2zdJB9ovHGuPk psgPR7XxmPYGV1GjmY0BqssL3tkuV6NkmSzwBS6u/7l/eaCU0zgNYzpVuhNxqzxUAuR8iMl7BKBO IPXEGnlzbqndFTB1k1W4ANQBYm6qRevASWQFnCAnreiL7cKDw1Nakq5hFRiagG4Thnw99N06kLdC gM+pLmTg6GOrtarMurau6pJe2Htx7tP5WpEP2jpO2THLNMZnKJ1uFBhmvfdMyJiNwjC/nvHVqYQf 7F+++SXD4Hw59VGqhl5RPjHcla+Q7SnFpkomG0grmDPwiwV1TMt8tF01KNYzhbaEEBnMyPc7wNKf IEoZ5bmvkJR5NewxTzZPw3PzL8dWX5FlDRzCmCEQ+y4SZRmLHT/Y71bN/beHJ26akwk7DynWhV46 LrwUSq2b2A8pHpoIun2zdp1rBE3qekzJIjXTwO9KpOhJz/lVPJ8cir0Wktml4droNnGVFZyDzNpG HGZaL61obhMYJ30QBvFNSTZJEBaH5pgXecOGYgeX9Vsy9oJeOPefKZjjb86b9KK+9Wq0XYNmno4X dR3coN8ve6Rf+2WXxa61f+hgVBUR3NyPxZgwYBQj3uUiSVONbjw5a0ipiJQ+RDS9+0//fnr868sb 3GaKJJ18PQyvDsAJp4XRsUceJcQV6z1cl9deR1rdcIqSwZ3/sJdzWnJ4d/YD5/asQmEat57X69Ug 2Cd1k4jt0tpbl/o358PBW/teTFkQIH5OHq59F5fMD7f7g0MHRxr7BKfWzd7a6WMf+XLCKYTV6Mzo BZKsNMsZ6hDLYdpmipsu9cin4IXEDImy4JpLSfZmoRAhFt4h4v52l4JMY79Qzf56RAlxin7a1Exq NGqSZqkno9fze0MR+mpeFw1JWRdJJE2khVhYcJOT7DtDdcXFciHSIgQu9Z8Dz9kUDcUruzR0ZelD Grc26ZOqolAwZfIG887yn77ntgCa3DuixiN84u/6oOSUw9+YaebUg9hc0cKfRGOIsRRRUpw6z1uT G51xw5saxupTpeZdqlLj0D7CPcrY+Y6y9wX8WFIbdm1WHTolnCLg2/hC9uB0JG9pWOIYa3PWw3x/ +ITaHvyAuB7gF/EaTqCjpbg4aU8Kz87AgcwwytGNsJKQQSe40BV6ObusuMnpGxiikyP61l9B5/Dr Cr4+HWJK2XzkXi1JXBR3aisT/raqwe4akMqY3nSYmkNdtVogZ4kgK+FyuFfLQl/QutRgH2+yO730 Q1bu8tY6xftWK+RQ1G1en4xWnvNzXKSUvIpYqJhHLVDLurnL9GIucdHVVOQ8UUd2AalKiVWITbpr RdxlBZoncaqxRt4Z9X2Id2T8SsR1l7w6xlqxN1nF4Jrc6dUViZ7yD4FZqldYZFV9pgLkcGR9yHGF GB+NcPzRUKMzE8jJkBHYnspdkTVx6hmow3btCKC8XeUXuDAWTFtySmvK+JAnJfCAjSFLmMSWD5D2 3R13JbV81WaC09UhLPOkrVm97zRwXcFuZrJzeSq6nLOatflVZ+NSuONmN2o9IOpiiF1gemk7lYDa APJPsi4u7irqUs7RsJXAmaU3fASDkH39O0m78w+FxqL1Bk2oLKXtK2WiJLftYyBwouMtLD9j8Tdt Xsa2DrM4N4aVgZR6qg56OTzNIAbktxUFFxJtPwIQsCucQ5nRKqihKU6UkoCzm3pN5BsJhlSJWU6H 7uVFlnHbfajv9HIVoi63LnDY21iWaSdzd4QNpdQb0x3bE+vKmHVkGAMkOeGpPTTMV8u75HlZd9re 1+dVWet1fMza+soQfbxL4fzVV6RIvTAcTztjwAUmgXZjtBv+y3ZwF43ijkEJD+IBy0s0AWfRfXvJ oEknSyR2/bMJIQOnBmHonfqY5KomVl5GSHElmIPs/tpcWpbdwqFMAFkabaKNCZ6MPZfyhl1RJzcE aPICj2YREd11T7EWRQLI0RXWkBWF/69wAT4+v76tkuWVhIhniuXYIggijqUwbHrFHAjbRbenL20L DfPJ6JoLHvMY6MWXdR+r06CgUfkwHEmbR+xMfM4rs8mTTtbeXjqIJmL8RJ0mAAzHi5iXvL2VwheM SC2B9QROSzKQNs5kCUVpsUdGsFZ1esxNCH89gNITYqJyHn2yrTBdB1BYGmCGveFjedF/i0nXqwH4 rjhl+zyjg/4KEhGZm/j2mPubbZSc6TRUI9GNb3TuiP/ktBjDO4XdD9u6sBjSYhmnqqf1tIhNboFH LU06sltt8SalF8m5ujmvXpSLSgmSfJcn1OlXZRd+fksiHPzSA3IsMBG0g8RwEQkO+1pZWZxg16Jg UWWoxr5gkuvqkJn3TdSfEBc8XkJc+Y4XbOkTVFDAUU1nPhBo5oe24PmCADNhkYor3oOkDH05OdUC DXSoFq5TwFrHQcONtTE2WeFiUkybFQan6U4t3NNgC6pyai1zGq7mcrRqOdCjgL7REO4gQamIZ+xW dqWaoY6rQ+fIgDIQtiJvrZoKiJGpdyDWD7enHSX2cxKM+heoMbtkuC00KKdRg5aLRmOA6jUBDIyR agLFD2ACBjwCZKkkOZ1xsu3UAiTGG8ChfbybKHDMklBJqAH5KATmwI5wY3RMqtCnQ25zgil6chd3 FtmUk5l6UhWbuN6aOVGgN16OecghS9xhba2lXuQYE9T5wVbntDECpwatmMlAVdb1u5wSQsSyS2KM N6cV1BVJsHUNtqBSCszLLaDy+XFs3XmOPqNy9H8ZjsrucKuPQc58d1/47lZv0YjwiEU3xrLfFV1y ZRvm5k5/PD1++/cv7q8rkFVX7WG3GtXcP77hywshX69+WS4fv0pPJnwS8RKmzzhP4KBvoiL/sNFw jAdtG0p0p9rdqboYMWM85Py4Ym1f542xe7JD6bvr2SBM+Ivhu1P3/PLpy9Xzqu2iQE0EOY9t9/L4 11/UNx2ckgdbLJ84STLMkZPDXYJWGObwd5Xv4ooShjJYgQOsKoz3xJL2JEW/4ijjKb7tEri27JQI kwDiRz1loYUZW3iIOyk6zgzTQ4dJmLOSIQdlVcMcKGZ3FUilPdyfeLo6lB/4W+Ul7+RINxiOKasO itkQwuY44+I7tYVDLamvYoyKFw8lOwBmYYa4zyc5d4TwFFk7jECXKxqXpD6ieTGZ5xIr+/BxvZG9 fRDGYtftVWNVhGJqBqqUy9KcZQqbrQ/LOS2lKP7cHkUHZEq/8hJkw5TfEOTqRdz4HKDh2sJpnKBu MGExJZDc+GPViwia7HnllFibF7ssPnX4diKP8Qzvx84qj7uNVpiC7Cw1nYdejWeP6XBo2mrX7MeB Vt5JeOhVW90ztjxRWiuBLpVZ4Wm5tAkYRSXbzanLDm3sOUPc7NQZFgjX4dMigfNyNygTP927eFuU oZ0xvV75TNLj+4xl1HrYnqp++HhX3eIDfKN17GNvu412N3C10agRmNzSH/AX1yPy6FAeSkVHsaDo 5ZPyvF7KrXeELgC25wwmx1aF20vM1PGGqyD8zoZdzDIDuhTGkxnqAz0ViBog2zzn2nr9f6w9y3Lj OJK/4uNsxPYO36QOe6BIPdgmRZqgZFVdFB6XpkrRtuW1XbFd8/WLBEAqE0zKPRF76C4rE48ECCQS iXwodkVCtnaFDkLX1kKyoxaz0ezpBDnzGDZKxiB/gEKHdqK5qOZulyYhLPElrt5ltUKzy6LkxPet rka6k78PFeRntO05DU4syiWQJEaY9SJtJqCgi+gWFQk/SClGR+l2D6YhZcqfo/KYaOHxlxlNQTSd 8qdcJe0OHiyL9o6vIKlcVKYE2oBQtd2SoJfylOLC7wHbXu+keLlJV6zsAxXxc7n+DULkFrdjwLu8 4faFwTaSWDxEA55DJMOaf+Y0RYpNs+V0mD01FVVOIXBv63slRi4QjWZK/gLdJiHUwECk5xpQmQOL uitxgCIFbAv6XqChMHtjJSdkWXo///PjZv3r9fj22+7mu4rxiXXIQyCc60V7Glbt4gsEZ79wjy5d AUUDQHKzRV5QIQMgk/rTAa2z5KotVXyF0Mf/7TlBcqWYvMLgko5VtCpENo6BaJDzepMzRNrKYopt 0tbEKaZwIXaHfNOM4IVIuS3St5aVMevgjfBewBCpEJy9MMLjy8EFnGCPbwyOeHDC9l75MRvQxRRI q6aUE1/U8qYIUzBqWhdoMs+PruMj3+BtGuRmTFg1KMaPhypvDixUuFHlcnAnYQlUNbglnoqrZEE9 ktHnAo8CGq2ux3RewhpWI7zrTlR0r3wkhQ/HlAA4ZsHUnK9HVFJETK9smWUZMmsuhbi5Re16h4TF FUVbH9gpLmABFp5zy0kgpkwW7SEYdz1qumqyiN1RaX7netyLs8FvZJHuIGXVcPzxDG7cm0JUDBk9 wo1yDlem8yabWPhy86XcUX9B56nLLSSJmTLfv5TYXi+hNOZ3vBNtzwnD64ypyooLS7THns31zjrQ l3WyHdk09Je5y9O7QwzpDcetGyzwpYDvYZj7jNdpXIopMeAKJXfbVJmhyA4bjpbECwMOON6QADww LOhW/wsqD559av57jffyDG9yRXKIjl/dbb3ttJjS3x66UlOKlDMAkTeBL00n5zKrGnbKabHutuCs fmih+wU6iOusW9SbwwLsVHSscf2aLhf6+8fD99PL91Em9MfH49Px7fx8tMMgpVIKdyPP4TeAwdoB 8XqPMtqq7unl4en8XTnOGWfRx/OLJGXcb5xM2FVKlGdnIut7vNY67r9H/+P027fT21En2ZuipIt9 mxTa32etmbCKrw+PstgLhKafGP5lhC5VUktIHPA0fN6u8c0FwgYXXfHr5ePH8f1Eep2Bg/sv3KuE 8Fark82pzjbHj/89v/2h5ufXv45v/3lTPL8evykaM3bA4cwnEUD/Ygtm9X7I1SxrHt++/7pRqw3W eJHhDhZxEgZ0cAo0keWzx+q0zmhJT3Wlwzcf389PoJT/9AN7wvVcElv1s7qDdQuzjbF2S11NdPie 0eUoffn2dj59I26fBjRoIIt2cS//O4BdVYrcs5f3XfdFhWnvakj5AZcCHK39gs/SNjdo37uQthKH ZbNK53XNiU7bTSG+CNGkKNUG+N8tid5IQw7pqnK9KLiVkhbLIkyxeR5FfhDzClJTBtwdAmc+6aA5 lInzz4qE/udF4gm3VygAniIuTvuI4L7nTMBDHk7DuhMM73COigTJhKfQpUDEtN5kudwyV2e7TZNk IhSyKSGiHEKvTvcvC7hWCswes2ikKMYFde0LrF3XiUbzBU6RXjJj4b4znl8N52ZAYdhEZbhA6I6b 7OLYD1uuSYlJZrtrUwZZ4HhlWF+ghEjOwajXbeZG7pgYCY5HTmUK0eSyQuxc/cT3yteg7ngrLfXi 0aQp9wp9K2IHOwkavQtkZOtabNDeI3p3cszWexzvutBjLRfpAVyvOGDdgOHtGKOtvn/Z4Da9H5fd FfOWvpgPw2uLfLWQHHNNLJp79IThRI/WEaBtwu6Z2RIkMcQAxU6OPdCYFFrQtM3WSIcO72vKy0bp 6TEYjJ0Ou2xdIG2qicBvW0KR0pArB504TRFIocBIr6uH9z+OH1zgAgvT194XJbzCwSpZonErSzQY Dcl1tK7AfAlGKb/HFt1dwC/JYHA2KFKxaetlsVmQg+reNooeMPIzg1lbFDvwrsA/UTVVIcsIVYp7 iVnmkEk38NzJtJIavYtohDPO1LG/yKzlFlsMnoVUd9fW4sCmKagWZZlu6v3FI/Fi8aiMAw7rumvK LdpWBo614XUp7584Wr0C7GuIsc7ADgtizWhSDWXlLTuZ63u5xDdgPjsSh7Kn8+MfN+L88+3xOI4T olKDk6dnDZGfe47Wu+xXQJa+irjDmWWtatAtcwt52S24sUwdgYuVNtYbEJfn53v1tDiV4HzZdVUr mem4YrFv4NlyMjP6QtSbaFytvi/HdS431jy9ghXbTVBM9qgeRO2R77okdBwbummyKu6JRxYBopp5 ETNW82ny+R4aa9qs2rIE9qErpmdlL0a0yFUlpeTx/G7UgJSreXNlUgxtTSEgFdCUDkoX6tPZc/eU ttrFlXpZK+QRhe83ndycsn1O2NY40TGTZbwzbK9bdHwvu8qejHq/SeW514jxfMAD8ZWlAS/rn07S 73DCTAxFrM22zCpkGTNAq25LrrT9k24t5/Raa11FHuYWZshyzjiDj/5j7tGj7TrxYQVXbUJ8cnoo G/vEYBvSt+4Ygv2osDUdt0CHhSJXCeKjaZfJWXMdZm8o3yq58BqY1yiwDqJet8AxyGFTpEU5r4mv NBBZSRhD4ZCdrFpv8fFapZJ3+LCr23u5sKA2UZlJvq2otJu9rHNjDzSFh7NWMocr+Mjzxng6yIN5 f6cGDGmTgU0ab4IBvL7Js6mG9Z6WlbE1DRhTVPmdnoXLYgYzIzB4olDYOma6MFGqSfxN5PG45RxY jMbi+fxxhIxU4wOwXYArkTzuLKOIHnrIpAzFDK3YwFN6dtg1W8kTdHU0QpE1VO8xokBT9vr8/p0h qpETQegBgDII4LSkCrlBT6EacqGDgNUErsD+0a5wwQDAxprnfTwqQj1ieODUDfqV0ZcQdXbzN/Hr /eP4fFO/3GQ/Tq//cfMOppv/PD2OY7DAgdxUh7yWK3QjjJM74sgE3QvR6fPT+btsTZwzzipSHf6H LN3sUj5uuNBylvwrFdvWClEPyJVkUnVWbJbclWUoQggjyMUCI58pshoaxyYk3Jj0YJVH4dRYNRbY JbBUXo2EyohNXfPaelOo8dJPG2Km5jKMMbUXLj5zoe6hyOkBb8Bi2Y5W0/zt/PDt8fw8NfxeQFVX WP5orjPtO8GGmFJYKVCJjpifKqZnB5TtAzdwJGl18b75+/LteHx/fHg63tyd34o7i24kfoD2wLa9 ARj48We3VhQzVGZepRvNxq3KA+KQso5eUOZuqvLdVOWJUlLaY69fd9siy0aWsVAXfJyIf4RSn8Bl VNQlyb372TSquT79V7XnJxcO71WT7Tx2f6r1V+0TYr41akw/NMkrxp9/TnSirx931QoxKwPcNAvc ONOMan6h0vnelKePo+58/vP0BHbuA7Mc9VoW3QIdneqnGlFWowTPQ89/vYdLIpHu+Ac/4v5Qp8e8 PDnTxjr6JW9o02xJTjeAN2AQft+mnPxvDjIpGdq1NBR9S94SV5asKlmQ3bLsyNSY734+PEE23yn+ os5LuJmnm1xewNi+9ZkqRYUDG01Ao8WchFtTwLLMOGWEwjV5O0R8oYLRHShVWIw8xNejTkSVA2Ka 8vtsI8SI51P5sMX7k50zvL/M5YRIN2D9lrGyjfxomcIR22cFTNI4nk3k5EIleD0uboL3d7uUiLlY RKgBBzGQCzScoJh/mEAFIk65j/F8f5E70SEfCAkVSDj1G8LHzkTL6bWZq+o5b4p7aSCYajm4PgWB x81A4E80ln32gYPFZx8lYB9rEH7uInG5v86t2iUDLWrNq8gO6JGfcDIlCWnlxYS80tvk7+qyS1cL iNzTlPRWPBTzR8UmO+34c3+rlE5abBuJZ/vT0+nFPiKHqsZCf5dtWa7MVR5iKfylWwTSRldwFC3b BWcavdh3mQqEqc/dPz8ezy/G9Wd8IdGFD6m88v6eUlWUQS1FOgvYHWUK0JBiBlile98PwxG86Tah ZSVhMJp9gw4drGHZj2NKtl0yi33eT8QUEVUYskEZDR58A1i6JUKuDfl//XSLLkpVTcNN9VIQbqQA i+7tconvdBfYIUMWUAhMvAYo3IiWXC1w95bS5LayO7uFp5MD8Q0AsPGBkxcajkL951KwdUZFVa9C hTDtiyCTASgk7o3ROfuVTAlTl59VRPBit9gMBlGfWz1xnK3HoffiNN+XkLScWJco0KR1icYKHKNW AWNvBDClaNMSzDctbzMu9l6TvyEdM76jVSmfln1eZXJDKS/GEjdwgdLXRoLpDWX6S0rqsTs9T32S HqJK2xw/yWvAzALgV2EUbEb37BObdrUguh4FD4DcS/Ne5KgP9dMegQbyk3y7z36/dWmiscz3sP25 lHzlWY3YlgHQKeyBZCEAMLLS11VpMhW3UeJmYTiRck/heOO9SmWSm0jets8ij82PK7JUZeRBzhC3 iU/NbwE0T8P/N6vAYeEfRLGqUskP5MmM90nszNw2xBsydj3L2it2ZxwbB2vCiNhyAGTG73yJ8Egv 3iyxegliTrEvEZFj9yIhh2KZZgvwsUjlJZS7SJBy5LEebAIl5b/I7+TgWr3E7D4ExMyljc180hhk eaRjm7G5KAARzKxeZzNOa5TmsyCKca+F8pSVQgOpD5otCeN1aUrtlVZpmHuThUAPVSgd9VQJFQDE xg5MagaMbdVouvpzfbNblHUDPlCdiiWNj3yIX6OGgQKzJYFPzoT1Pp5IJ1dsUm+/n6CmV6cTYopq H+cUVDaZm+hWkKqjyXxvBOwyL8AJPhWAxH0AwCyyqsxoqsJ07zoem8JTYlySrklDyF4BkBewuR4l xsd2cBIwI4ZKVdZIqQppdAAQ4Lw9AJi5dtrFbnELgU/COAYHQ2vVVYvN4aubJBOfYZNuY+JfA6/R 9AsowXMHErAdeESrJir5efaHfT2upKTVYgK+m4BLMPpkyoN19aWt7d3UbsIuckfDGl+whORC7NBN JApChgrPZYHUgoRkE3ZwEP3YpSeGPhsMmMknsnwp8upAbYwwRq9s3KDconyDnZozJ3HJ/PRQnz9e e3QgHI9brRrveq6fYEsRBXQS4eIl05dNhBOOwZErIi+yGpENYJclDYtnIRHpNDTxA875ySCjJBmN WuiALxOVKnnvsr66BHdlFoQButPvlpFyZ0fFzAV233+bf9c8XyXbuVmQ9Fgg2LULKX5Qpfe4hnnp en2SV15Lfkh8etSvqyzwQl5MuTSgbwY/js+nRzB1Vzm7cbNdmcobzNpIpeh0U4jF13qEmVeLKEEy lP5tS9cKRiTDLBMJZmpFeked5JtKxI6DznGR5b4z3nUKysu2Gmdbf8MIiraAC/GKBGERjbAyun9N Znt2SkdTqCNYn74ZgDJt10mdSCzrXtzXV0bKWC10f4dEC4RvH6+qSpgmemtK/R4rmr6eTZO6Y4hm qKWJsm68lwLr7RzvgnHDpFpnEcPjyLKwcIZX0pRs55sHvVOmvFxCZyKSiET5Ea8nBNSEeBkGnkvF xzAIeNFYIshlOgxnXqsDNhChUsH5FsKZ39ImsLmz/B15QWuLz2GURPZv+xYI0FlkbxWMjtlrkkIk WJ6GtOjWb0qiJcxLIcWhYwKBnQrk/qRfVsJ70OZNDekSkCyYiyDwcKA1I0XmNBSGlP/caGIVgGwY TZyeVeT5U6h0H9IcAwSVsKetlOuCGPs8AGDmeSPZgEQK6UEjRthp/+jEg7Bn/DEo8WGIhWUNi4ke w8Ai7Parz8XchN4c/Kau7MfBTe/bz+fnPhEcNnUe4UyWruP//Dy+PP4a3LD+BSG+8lyYjIvI2HUF rksPH+e3v+cnyND4j5/grEacwCAOHmJXV+uplpsfD+/H30pZ7PjtpjyfX2/+JvuFrJI9Xe+ILtzX Ut6QHLzGJSAm6WT+3bYv6WOuzgnhjd9/vZ3fH8+vR/nl7bNdKfucxKEbD4Aumzqxx5GtrBSGERno vhXezIYEVJ09r1buxJZb7lPhQbZX7gRHZ6K6D/jI47pqtr6D59wA2MNG1wYd2uisUSgIwqzRbE2I 9WbX7la+5zjcjhh/BS0eHB+ePn4gqauHvn3ctA8fx5vq/HL6oB9tuQgCLARpAGJy8Kbg2BdUgJAE kGwnCInp0lT9fD59O338YtZR5flYjM/XHWYfa7gr4Fy6EuA5E1rP9bYq8qLDSSU64XnocNG/6Sc1 MCI3rLstdaQSRWxpBBHCI59tNFbNvCSX+IBYg8/Hh/efb8fno5TKf8q5Y9TrvBLa4OhuUaA4HIGo DF2QFL/6ty1TKxiRA5b7WiQx9ZPoYRMi8oAmDd1W+wjL5pvdociqwIuwthRDrT2HMVS8kxi5TSO1 TckjEUbYbfUITlIsRRXlYj/atgbOMoMeZ3nEXvniuAH4YCZWIQO9PCTpCIwqvQ/DjH+Xm8B3LQ3n FtRQ7FIqfbKH5G/JfHDMwCYXM59+egWbTcm7Iva9CR3efO3GtsoboVgxOZNyiYszwAOABtGVEJ9V u2YQ1pfoFwEShZzUtGq8tHGwJkJD5Gw4zpI8n9yJSLKJtOSeTYaLiSjl4eWisAkUg2MwK4iLJTb8 gFOOEzdoTNOyVtO/i9T1sJDVNq1Dovn2lAwBlAchtQ2pU2O5k6sjYCNayNNAHhjW+QAQdE/Z1Cn1 Dq2bTq4lREojaVVRozF5hetisuB3gBoR3a3v07Tocu9td4VgHVu7TPiBi042BYi98Xx08juEWKmq AIkFiHFVCQhCn8zZVoRu4vFuzrtsUwYOy9Q1yicJsHeLqowcVojSKJwAfFdG+lVzqP5VTrdnvdAO TIkyEG2k9/D95fihX50Y1nKbzGJ8HYPfhNz01pnN2MhV5hm0SlfEbgWBJ59qLyWsN14Jk3yO5yZo l0DVRVdXC0jt6U8E2PdDL0BTadi56pWX7XqSJ2S7nl67dr/S1lUWJoE/XoIGQU8XG0mO1B7ZVr5L 3hwJnG/Q4Mjx9yWt0nUq/xGhT6QZdnXodfPz6eP0+nT801KYKMXRlld0kTpGLnp8Or1MrT6sxNpk ZbEZvugEd9QGEYe27lTyK5YItktFTB/c+OY3CCTx8k1eQ1+O9thUaoh223Sf2Fb0vmnGbWrQv42K 0AJ0zX0RS8Hp7nhKjYzwIsVzFen54eX7zyf59+v5/aRCr4wmWJ1qwaGpiW3lOG2NDpoLUbH5VO1/ pVNytXw9f0h56HQxMRmkltDDrDaHGGn0xSsMqCCgQGxgBo0hj7WgFXFohGOCc9kgBYCxGL4q7Lgc l+6a0r4xTQybnRL5QemtoKyamTtKsTDRsq6t1Q9vx3eQPBmuPm+cyKmQ8/G8ajxqHQO/7UuCghFG lJdreSKR7Zg3UhTl5oVIMQscPnTd4G9cZI1rXUKb0nWxyYj6bVmMaBg1GGlK38XXy0qE9L1U/bYa 0jBL3wlQn1fKGfavxsS/lIXBhD5y3XhOxGtQvzaplHj50EajL3u5HbxA+JvLB0cSuj/z+RedcT2z fM5/np7hJgvb+tvpXYdSYtpWomxoixz96i3ytFWeBYcdZ2dSzV0PZ/lorJCm7RJCPLGWhqJdYuWF 2M98fK2Rv0N6h4EK3KMeiGG+4xG5KvRLp7/woYm/Oid/LdYRuqJ5Ysbf9SEMElUHfdKsPsCOz6+g jWQ3veL1TirPrUWFM7x0mTdLkFJIcs2iOkCMtKrWJr7YdmPYwqaVywYp9zMnYqNMahT+yF0lb12R 9RvZv3Ty5KOXEgWZELBBR+UmIb9XuDkZ1to98liUP/SBS0F9iP+LZbAEKj9xlpYBK28cvHcHlDBe ZsxcKeyiLZWtN4YNPmUI2PvnU6gOqG+TbDzUJ7pcF/MdimwCoKLau7RhCfFiq5ASDEqaqU8h9Gqb 6K5/TBFZZ9NpDHMmKwrr+wCEibIBKOVPVIjGghqDFzqQai9sSlTStLya9sKHQioFDftEorD7lHaj 3FIoxDjeg3M7RRjzE5ssxpaf4ksvyRo2q5hCm/RxBNTmo15Yf36NqXzP2jZG1rUXgbI5mWhGeRNQ OrpioZNPkUYkdN1O5TqHAjomxiT6K1lL+tbR3t08/ji9jjNES4w956ncNwV/Rv+u4i+kE9j+y8o9 kkHDTcHlbxlKyZ6Je4eBt19TVyHZPvqPrTrhZFERJHARxPHbe7u5LtvSXHx9l+tEE43JkQUv+RXS Il/wYazAV1IWhQSk7MUI0JtO3g9HNoLQQfZ/lT1Zc9w4j3/FlafdqplvfLQd52Ee2BLVzViXKand 9ovKcXoS18RH+diZ7K9fABQlHlDP7EucBiDexEECYFUsVelaQZi5fYUxznWyxudYPV0es6L7qesn Iy+cYaeJtUguMJkROxmNbMPgRw8n2jUb2zVgt83R4Tb+iuKF2QilAR9w/AEaxxF7iMHtZ2bxIeG6 SbmH8wwSXSU9TctAiaOv+IfPDQm+easu9xEY9j5bM4Wtx90y0eyiw0ciheYyMBs6dDCMv2YzxngU Jvawci0PB1G7nqAG3iSFimDmXdIQihywqI9OP0aYKsHsjnF7599RNPiW3qhM2EefDMX4AmVU9rhT V3nHx4cYOnzrhDtCN5mjhjVEeUIcXysfeWaiKIzJsL4+aN6/vFKY1cRU8c0VDQwHE7n9ZIB9oWoF dqOLRrDVEugp2taxVhFJL7l4sgKAMKanhwo/4G4GqCqTa+HoWCDVsV+hjzzB5OLSr3VYotuVwTFf I476gwS9KAXmzttHF/d7yC6AbfDCbxGXXK9KTGQHhc/0kJ530vixY7rb/FrY52EevGKRoKQHXThD y6c48VtbNsfMYCCUnoch1cItR2P7RCv8gSWw12anL0Px/kCIVJaJ7NtKg9ziMiC5VGmQRNDFNbBR 2PfuPSKRbyq/cahRU+T/5dBwr/RCbYGPjjPMqyeU8o7S7AQp7zwCytODVfz04SgCUGSavvkofMO2 rJg1bph3v9FbfJGBG9mBQoN6MLMeTHaik4+nFMyXd/gcdx8vYxJqZq45RNSjYgO2Vg/lQsO6tlBh wyz+nB6wDAbVoQOtuz8+L8GqaVTiVzGiaGCCKUPkXOpBqr+oT/ZMFKHjKinRF7P8EN5lnBZisdsm GtMqkXmFHo06lU04PqSb7O3BkAjpcnF4FBGGZJfDEIVweva7rJs+k0Vb9ZtgfY0064ZGeq6EqPW2 beeHZ9u9ndCC0g3tJSGff1me7BMFo39/Sr+2h2GLpvBr3Eppo8KNzNHGrHBEtde1DBbHoPymtckD GrZgQBMXIYKZ2ge6uG6btQ4WWiQrLWqe549qRMxGXNTJDCoWn5MFYZ5Id5vTGtP06OToEDscrvwJ v7D4sEOtWi8OP+5dGMZSBQr4wdlLSEOW6dGnRV8fd34bUzGoI1PT6JBgMBh8Fgj6W61qGQyOUa8v pCyWAuatcN9JjfGMXBlPXIj1zy2IiYqq8JrgvXPnnW566ptTLeZCSvg0K27ANfygNHuDo3i9e/nj 6eWBTkgfjJ+Y99rUJEz6pOC0XMSkRXIG4rEe0g7alu4p2tFx/WxdUaZ3W02Z6koFR4szWeBztSw3 qSo8+2OZU94aeoCM6UaZIoU7j8uW01eqzD5hNgBS4ZjJ5aaQRfAzPK80QDKyVUSL4CqpWuc4zLzo 2cus813KzQdW/ZaY1I7tmEfmlWxQmB40qBLlmqlvBBlpk2ElUf8wnKtJhXe8OPJTKoezjiwB0yTU KIMmDVURZ8Bcv84MjPzKDpH3iXFktqVN5xI2Kdtc+4YKyw0+ir2q3XgwE1AWDBBlNLQw41B5dfD2 cntHdzbhERZ0xHP6RpehFp/BQ83kIUZgMqTWR6RdUVz7oKbqdCLH7Fo/GdwauHO7lMIpzLCh1nnn 1kL6FUAjOiiOowVBxUDrVjHQ6bzeOmTGY2U/Cg1z/N0XK22Ndt7FOCDqxYw/ypCAs9ag1ZCDPecx aQuzxEEEy4hHbj3f3oGlN3yeNkulErk4DD1qRmwhkvW2Ot5XiMnI7joOUqMzLeWNjLBDo2p0y7Ap ZR688rRcKQpaGlsDPNDBzI9/OvfAhTteRd2Hs2jJGu9yF372paR8Gn1ZpfyJCRIVgkydmdTzDgWG Nj0wcJPN0Ec1iZvDnyBLGSRnB2DlZkRtpbRiFv7r5cqx914OeGS++GYXzMN2cil1XHKYFG0dhjmu Pn46dqz1AdgcLdz3oRA6pHuZGCHA4ofGYl+gOOeX8hK6wq/eZvx3uFKuCvP6pHMaroohw9pcxkly 34H/lzLhT7BhpSIJf9FYNS3bmSD3j4k+uf+xOzC6lDOkG4EX4q2EKcXsBo172A0gRU/kuilzjntX wg+Afiva1jv3s4i6ahTMT8L33lI1Mul08Bb7RHISVnnilRxUe/LPBS7CAhdhgQHKFhdggpfYPy/T Y/9XSAFFFctEeM8zaKlg1AHjtmkEUrJM/0B1wFDWhDhNaVyqmRz+wogImEHamvY8uL+H1MT9xkvY gZjLrmp54bSdWwIOXrdheVVJb9g2ie64IwEkuRK6DD+be8R1lTXHXm8GQI+PDeAjTGnuqCggRS35 JAYGWF8dz9yijxSgFemmxiQgw0HUfvKmFS3vpWNIqE/IrS/yir9jdekyvqhlq6OJnpRrlZu2cBLk OFgHBMA2e6t1IIu5gEXsWwKWxtlj/ve0BeZab76mV3dV+RmY6KyYHqrBkzr0jFLsRQauItfKmWML uBGyxuc8Bga2FayqvqrZ8VS5tKvOsUHA4sM8DNczeChUlvSAoKrKGTDoPqtmDqfMfqLfHs1GRiNu gfFuYmiWnQIJXmK6n1K0nWYfnM6a6HHyEKAMgDaP00AR0hGjCX7iK9V0AEeiFNPvOMcLGoADGXIM b1gNOODQBthq6SiOl1kBXM9z/zEg7pyKCkhaZ7WIrq2yZuHtIwPztxZ03gMknok3PPLtElQwC7m4 9rbiBAMRkCoNO6KHP+4UcyQivxJgd2VVnlf8VavzlSpTyefod4i2MKfUTe5kYSIrJIxWVV9b/S+5 vfu+8zJJG3HpaccE2sM6LQVeSVQrLfgXMgxNJKENuFoiM+lz1Tg7hlC4R91ZGmGxa5aDY5vivA1J vTYjkP4KVv9v6SYllS3S2FRTfcILGF9Cfa5yNeMDcQNfsNy9S7N+YGK2HXzdxi+4an7LRPub3OK/ Zcu3LjOiwfNUhS958bIZqZ2v7SPqCRg+tQADbnHykcOrCt8SaGT7+4f716fz89NPvx59cNaAQ9q1 Ge9iTX3h21a2dn9OkrLllAwfra/YCd47eOZ08nX3/vXp4A9uUEnV88UNgS5CK95Hb4oZK5+weJnf 5lGZOORgWJQKBNLcp8la5amWjiy6kLp02ZA9CBzLbouaHWbzx2q/04FqPBqjtFRNQoIS39KRhcv7 tChXMmCrIo3mcQAFc2WRWUQvSXDyy2Q9NX2C1Hk3q24t5ZzOvYyKmiX9nIUqrYUMTOgwgl+BwJZh HtAJCxgS6pmnDRh80xWF0PyV8VhCZGR4BI7WhfF3ysvCYkhuTNRpUHJ+w9s3BqvRGXIfvlsqXh0c mlUAk+nLqtxXiCECVaIKLUqWsFE33J5zSTKxqToNXfOEBQgHdrKby040a293DRCjL1p7cjp28NBG wvPeepYQD8SKGppernJ+KEJSOrrZ01iPDtPGJnXHdCCyGEYMLod95ec3C/a7YMFEFd4wrbhp2pQB L+gaBW9TcE7Z2mSxlGkqOefWaRa0WBUS9NBBbcGyTkYRGFrahSrB3PD5QFXMMYJ1HXGry3K7mLf2 AHs2V5ge6nGOIQiCj2piEuFrY9uEaNjSFj6JEtB2ZkQTsO0NX38XMUADMbyLLazbY/ZLXcUcdYDt EeMjyRxHGwlulHs0ZqGj/wkK0lwVqv39aFQqZHtV6QtefCWyXgfNHUB77edEuTOGv4xm7D2nRmCB yj1o72RpQ9vkSiQ8PyPyrk7gi3n83PgQMtaFRyhnNU1YvOypQZ+4DjuVjk2Kim2uSqa1o4aRCm9R i1BDcJrrkUSMdaQE20w3rH5U5u79Z95YHdRTUh201XJ70HL9D0fMxxPPLdbHfeSceD2S89PDmYLP 3dyGAeZ0FjPXzHM3qUeAOZr95ni2a+dnnKNMQLKYLfh0T8Fn7KIOiDivao/k08nZTIc/zQ75JzdU wcf4qXn9xnzkwpiQBEw7XFS9l7HV+/bo+JQL6QppjvyuiCZRKizTVsYH1rkUfCIxl2Jubi1+4bfH gk958BkP/jjXg7m5HXt4Es7FiPmnmXDjQhF+UanzXjOwzocVIkF5KsqwZkQkErQoNtntSFC2stNV XGaiK9EqUYZDQbhrrfJc8aEclmglZL637pWWbvSSBStotChTrjuq7BSvkXojAa3eU23b6QvVrP0e o6XvnDO65/rwI2TzXalwD3gahwGBTaALkasbitvvG5ln+CwYa9t7F2smJeXu7v0FozKfnjHk3LHk fbmGv3otLzt8cSySNvgAkgIdATRHINSgm8+E82pUOFIqjVNXzDnwQDDNE/zq0zVYY1ILa5CNZSKS Dl9VYpC8Kjcc2fdpIRvy4W+1mrM1BlpejRUbCf/oVJbQTjwFxjNBUlgSYTJ4T/Z1SMYd7lWazpON J4jrHQK9SehLNMTCxxhZNChy7fr3D7+9frl//O39dffy8PR19+v33Y/n3csoyu1J0zQibu7GvCl+ /4Dp+b4+/fX4y8/bh9tffjzdfn2+f/zl9faPHTT8/usv949vu2+4an758vzHB7OQLnYvj7sfB99v X77uKCJ6WlDDi2YPTy8/D+4f7zG10/3/3vpJApMERquhU9h+IzBphWqxO6CeOmc3LNWN1J51SkAM aLmIzOWYAubNqYYrAymwipk7caCjKw2Y/nFoZ+51LDE6fczSjs+kscNl0fOjPaaEDTe27fy20sYI cvXK5rocM1l6sEIWSX0dQrdeTmIC1ZchRAuVnsFOS6pNiGq3GF0qlmDz15d4se8/MxMRYZsjKuIV 1Xga//Lz+e3p4O7pZXfw9HJgFr2zvogYr56El/3YBR/HcClSFhiTNheJqtfuFg0Q8SewlNcsMCbV 7m3QBGMJRz0+avhsS8Rc4y/qOqYGYFwCHqHEpCAaxYopd4D7hp9BIUvjLTnv03FtoLBjj2t9crlt 8U14JI5as8qOjs+LLo8QZZfzQK7hNf2dbwn9cRyY7Mh17RoEH1NgKMbN4fv7lx/3d7/+uft5cEdL /tvL7fP3n65Xrl0KDee/NSDTeOXJJGFg6TpqsUx02kQbsW+KeP5BxGzk8enp0Se7T8X723dMt3J3 +7b7eiAfqROY7Oav+7fvB+L19enunlDp7dtttH+TpIhnzw9ptJRrUFLE8WFd5deYVG3fkhJypRpY AvPD1chLtWFGZy2AqW9s35aU1xaF7mvc8mU8ukm2jGFtvFsSZs3KJP4211fRZFWZ5wc/rtUlpycP 2C1TH6hZ+F5oVH65tiMc84QU1OK2i2cMT9c31glvffv6fW7MChEP2poDbs3wht3cAG20g9L7b7vX t7gynZwcM3OE4KjX2+3AvMMal7m4kMe8441HsodlQZXt0WGqsnipsyJjnICwlUW6iDlvGk8UwPq6 jvteKFjgFIrHDa4u0mDPcBQzaS8niuMw+0hEccKm4rQ7cy2OYlYEQLZHgID6OPDpESPT1+IkGtSm OIkJ0QtjWa2YUWpXmn8lasBf1aeUfNIw8Pvn754b6cig4g0JsL5VUfNAtbvKFLNKLMK+d8CwTFFI sLH3SI1EoPVnv49x8dJCaDzeqeeWYGCZ8fmJeVUj8kbsWwKW1cfTInVtHucLp3DB1NNeVTg+Eb9I nh6eMWuUb6/YjmS5aGXMiW+qqIPni3iFBVdDE3S9hz3THdCwYvTt49enh4Py/eHL7sWmVOdaKspG 9Umty1XUsFQv6amiLp4nxLAM12A4bkQYToohIgJ+Vmh7SQwCq68jLOqCPaewW4RpQtihETurlI8U 3Hi4SFjAm1jbHSnIQIiX0oiXJemo1RJDP1rOFnXUfnKRDeyZH/dfXm7BEHx5en+7f2RkJKY65tgD wXUSCwDKjWxEkM0ksI+GxZkdt/dzQ8KjRqVwfwmT7hjOEKLTmU5baQj6L15fHu0j2Vf9rFoz9W7S LlmiUdiEy2PNenM010Uh8VSKjrQw4tW70JnQdbfMB6qmWyJhzLMwg/YfpGS/HvyBIX733x5NJq+7 77u7P+8fvzlhT3S95x7Oac/7MMY3v3/4EGCNfZVIPZzEyej7iMLcLy8OP52NlBL+kwp9zTTGvZXF 4mB9Jhfo9GZpeHe1fzEQQwrAuY1mzjHofGNsg4X1SzDdgEFqLlcMerIK3ZOrj5t6SwROs0sF6sNG ajdwzeb4AM2iTOrrPtMU/e2yMpckl+UMtsScJq1y7/qSSqe+RldrVUgwbIsltIK7bqeTVeHYwpif asgZ65zb6GSNzQDFvd4m6xX5B2vp6bEJ2HDA8z3Q0ZlPEWu/Sa/arve/OjkOfo5n3z5HJgxsGLm8 ntNWHRL+waKBROgrMcPFEQ8T6TXJfY0nQV7s/nIuJ4FZxNZH4oQIjebGOB9lWhVuj0cUaBmjC5MP NW4uPhxdV1Ds+ErMjeGvARR0mqnkBxfqlOzAF0w7EMq2A1QapnACc/TbGwS7S9hA+u05b00MaIrH rvlbpIFEiTPu4mzACjdT3gRr17B3IkRTw46IoMvkcwTz53DqsecE5IB9NyC7191LCLtSJDBRUD4q T2V3oVjs+QwKmJu7N8PPXFwL7L2RyAE4WH9R1Cx8WbDgrHHgS/JxH3+S8zyeBvtg0TRVooBRbSTM iBaONol3BqrygsANiIKEvLAxhHunzPADIyQiQL+8roW7JEsaHIMHdrxyw3EJhwhMeYBXNyHTRJxI U923/dnCYyMpPU6c5EJjCPGadGUfi3pm5MPiIaBZ7Iq3LdonxJpVbtaVMwFgAHb9eCM1Mcm6w+if vsoyujrh+GTdgUXvDnh66UiVVV55jpX4m73RtOOaD055lr3orrdO+LbG/KZvhftIiL5E3c6ptaiV 94wI/MhSZ5ArlVJULQhab1HBQrM7b5M2zoW2ha5ki16fVZa6qzGrytZGqDn+5Ag9/9vdUgTCuy4Y AZk4DWowsD1XPqSuqjxYVbiYMS+Cb0IBYIgejqkJZ/JyFLXAYAu14ug6fAwd+FCWd806iBIciehi 1E2h0cDK9ia/xnRIztOL1fKzWHk5jPGatlztv9WOVDf/QtJquwR9frl/fPvT5CB+2L1+i++9ExOn D7rLKgetLB+vUz7OUlx2Sra/L6YBbhryqAtLWLhKbLGsUIuXWpci9AweOjbb2PFc4v7H7te3+4dB mX0l0jsDf4m7lmmoycQjHh8uzv1RroGDYlqMgr9A12Dpki0LVNy1OKAlvtZSwtZ3N9fAgEy4G3rE F6J1ZUSIoeZhWKXn3T3EDFaYLCHrymSII1P44MTMaav7yZUUF+ikgPyHNxP+7VjSyNMxy/2dXWLp 7sv7t294C6seX99e3vG9Ii9bdSFWiqIYNJcy0MZDMv21jpBzzo0jGV6GEWWBMdh7KhkKxIvxgJUZ Mb1KPQaMvzlbdeQDy0ZgnrJStWDL9YHHI2HnfCguEvwU+Yyy6UKHyfhXw+t3DIM6ZB6PIEZgRMbx cLc+lutEr+C2BS0EX6Z1+aMpDLGBKAwQ9rxnuoGdTCwsuroq2eSuhKwr1VR+3J8p3gR4MetjQOyT kD5h5mlMPo6SNTdzWPQFnm8AJrxDDrBnkVpS41/P5QpgyYMBPQqLbXLBLVBaYcPSAJmWw/4Pe/ZP cJSFJFTNMcXR2eHh4QxlaHMG6NHVI8tm+zsSk29Lk/hecENfyR+lQ9nCKWoghNOBRpZpHI5vCtlw 3HvczwON0m0nmO00IGZ7AZ3A2GB0dPH0DQQaHy28ideaXqXBCXYyNpmdZHg0aqVNwJ+cMcCgzAzY 2MwQWTSnfxoHoguBvCc+/TNYXOuodJTVxNhAN5eNF/cVcZFA4q1Ngmhz5YhEB9XT8+svB/jw6Puz ES/r28dvbvCcwOTSGHfkWRweGP1gOuluhKbKWjxo6fBApoVBrXj/CfRG20M3th5R/Rrz27Wgzbvb wyzjEUUso+pgVx6PO2NZVS1odaJwyKj9jjk3RxJ37eoS1AFQCtKKi5rAbdebHrm52PYPtvF6BBH/ 9R3lOiMEzEYK/C8NcDigd2EUwOCuC67scJniwF1IWUenlv5mAG5d1LELCHbKkYr/9fp8/4ieB9Df h/e33d87+M/u7e4///nPf0+9olB/KndFCvVgf/gxlZsxpJ9tFpWBHZ5lAGhOd2DHy0iQNNBZPyRn YBk8+dWVwQCDr67IrTHa6/qqkQV3WmnQ1NhAXCMslXVY2QxYtFWBelsu+U9wHOmWaRC/jV8R5tfF RANWPNg1PfYsOrtrksz/yDWum9SUeiVUy8UEWWPo/7E4/C4Bv8py4aZmIG7aapOnYNqUqKCjV2RX NlKmsC3MceSelXxhxPm89Bti2DUYumLK1WZ28p9GDfx6+3Z7gPrfHZ7eO1xzmBDlj9ewhRA8W22z ir+wYmomJBZVk7JPRSvwGB0fM5t7LG1v48NaEw0DWbYqeCTTXPEmHcem5hYK6mKY215G/mMOQfCx g9Eycz6fli3iUDKTeTdy/uMjv2JaLLz9CFh5uS+ajRpOXtn9CotBZUBVfHJJf0wC1nE5WH2adIl4 ik3aE1Dz8QKDGyE89y6T67aqAx1kND2pn3oOC82v1zxNeg3WPjCVzG4rrwAC9gUpx+Q566YAJxIM hacJQEqwGMo21JOS4UNTinO6Cl/McP4smjbLAARm7Hc5AgHsfnUyig1wP/faANV10eBBnMKjyxBp fvlxoROqnFNTBpJNhm8mYvK5IsVbMid1nKPTmiSeg+0r3fhZs9wMhXvAGWHM4dHTX7uX5zvWcqyT 0SP1ijRcR3+j1C5GMwcxA7LsbOF+J4sOV1zaW13CsnwK5kb9xz0Cm/CfMfwQ7B+Z95mknDZG6fcs xTmi2VhUWAx9pragJTo1TkcZjerNKd4+qxN7heesqJpSRqj4gHpbzHjJ04gInTNpfRyKusXgS1fv iifHPQZsd69vKA9REUye/mf3cvvNe5/yoisVe8LMWS0m86JtTfFPpk0pW5MekaeatuF8bqhwTV+g U31ot4C1AmDDGnrX+c2nxl/WrqZjXo3nDn5MDZLgUZ7uKBycD1c1VDDNQkthrOTDv/G53tEa0MCB 8GYZlwmu4cHJaFIoL1L2XS2j2ePdfuMdkhO8UCUeNniJYwmBtExhS6vE0IqNjHVN10uzwtK98vK3 n3cPFeCGUw5fhBp98mzBbiw3ZmKmLdTJtdzSyvfHZDgmN3cyDguxyCZxvasIegHgttq6Q0Fw4lYZ uzUJb3b/XPO6TqVBRVtzGxfWs8dKJ7zGK+8WV2nQ18Hlyy9NpXxWP9MlumaYXWcXRVADdBENcB+4 KYwx4UPJ04uyQgVF1FnURvJYWVd0nLXhOK/CfNeqne7jgpHMlC5A+w4HZEiPEzQslbkI53yIGvOj 68ymkkUiYKSCD8YLmaAUNH5UG/UQSlHlTLyk6QFuFTztZJ9Il8W4K/w4J5Z7BxZJoZqGMiRWCTEt XoE3xstSGSbcsMplcHP0f+LjGjH2TQIA --===============4339029617058625209==--