From 3bf24abc8c30df2d3075de7c6632b66b25e6ef30 Mon Sep 17 00:00:00 2001 From: Stefan Berger Date: Wed, 7 Apr 2010 23:02:18 +0200 Subject: [PATCH] nwfilter: Support for learning a VM's IP address This patch implements support for learning a VM's IP address. It uses the pcap library to listen on the VM's backend network interface (tap) or the physical ethernet device (macvtap) and tries to capture packets with source or destination MAC address of the VM and learn from DHCP Offers, ARP traffic, or first-sent IPv4 packet what the IP address of the VM's interface is. This then allows to instantiate the network traffic filtering rules without the user having to provide the IP parameter somewhere in the filter description or in the interface description as a parameter. This only supports to detect the parameter IP, which is for the assumed single IPv4 address of a VM. There is not support for interfaces that may have multiple IP addresses (IP aliasing) or IPv6 that may then require more than one valid IP address to be detected. A VM can have multiple independent interfaces that each uses a different IP address and in that case it will be attempted to detect each one of the address independently. So, when for example an interface description in the domain XML has looked like this up to now: you may omit the IP parameter: Internally I am walking the 'tree' of a VM's referenced network filters and determine with the given variables which variables are missing. Now, the above IP parameter may be missing and this causes a libvirt-internal thread to be started that uses the pcap library's API to listen to the backend interface (in case of macvtap to the physical interface) in an attempt to determine the missing IP parameter. If the backend interface disappears the thread terminates assuming the VM was brought down. In case of a macvtap device a timeout is being used to wait for packets from the given VM (filtering by VM's interface MAC address). If the VM's macvtap device disappeared the thread also terminates. In all other cases it tries to determine the IP address of the VM and will then apply the rules late on the given interface, which would have happened immediately if the IP parameter had been explicitly given. In case an error happens while the firewall rules are applied, the VM's backend interface is 'down'ed preventing it to communicate. Reasons for failure for applying the network firewall rules may that an ebtables/iptables command failes or OOM errors. Essentially the same failure reasons may occur as when the firewall rules are applied immediately on VM start, except that due to the late application of the filtering rules the VM now is already running and cannot be hindered anymore from starting. Bringing down the whole VM would probably be considered too drastic. While a VM's IP address is attempted to be determined only limited updates to network filters are allowed. In particular it is prevented that filters are modified in such a way that they would introduce new variables. A caveat: The algorithm does not know which one is the appropriate IP address of a VM. If the VM spoofs an IP address in its first ARP traffic or IPv4 packets its filtering rules will be instantiated for this IP address, thus 'locking' it to the found IP address. So, it's still 'safer' to explicitly provide the IP address of a VM's interface in the filter description if it is known beforehand. * configure.ac: detect libpcap * libvirt.spec.in: require libpcap[-devel] if qemu is built * src/internal.h: add the new ATTRIBUTE_PACKED define * src/Makefile.am src/libvirt_private.syms: add the new modules and symbols * src/nwfilter/nwfilter_learnipaddr.[ch]: new module being added * src/nwfilter/nwfilter_driver.c src/conf/nwfilter_conf.[ch] src/nwfilter/nwfilter_ebiptables_driver.[ch] src/nwfilter/nwfilter_gentech_driver.[ch]: plu the new functionality in * tests/nwfilterxml2xmltest: extend testing --- configure.ac | 39 ++ libvirt.spec.in | 9 + src/Makefile.am | 14 +- src/conf/nwfilter_conf.c | 7 +- src/conf/nwfilter_conf.h | 3 + src/internal.h | 17 + src/libvirt_private.syms | 12 + src/nwfilter/nwfilter_driver.c | 11 +- src/nwfilter/nwfilter_ebiptables_driver.c | 236 ++++++++ src/nwfilter/nwfilter_ebiptables_driver.h | 8 + src/nwfilter/nwfilter_gentech_driver.c | 406 +++++++++++++- src/nwfilter/nwfilter_gentech_driver.h | 14 +- src/nwfilter/nwfilter_learnipaddr.c | 622 ++++++++++++++++++++++ src/nwfilter/nwfilter_learnipaddr.h | 67 +++ tests/nwfilterxml2xmltest | Bin 0 -> 462966 bytes 15 files changed, 1427 insertions(+), 38 deletions(-) create mode 100644 src/nwfilter/nwfilter_learnipaddr.c create mode 100644 src/nwfilter/nwfilter_learnipaddr.h create mode 100755 tests/nwfilterxml2xmltest diff --git a/configure.ac b/configure.ac index e13961efa7..dd1298f178 100644 --- a/configure.ac +++ b/configure.ac @@ -41,6 +41,7 @@ XMLRPC_REQUIRED=1.14.0 HAL_REQUIRED=0.5.0 DEVMAPPER_REQUIRED=1.0.0 LIBCURL_REQUIRED="7.18.0" +LIBPCAP_REQUIRED="1.0.0" dnl Checks for C compiler. AC_PROG_CC @@ -1045,6 +1046,39 @@ AC_SUBST([NUMACTL_CFLAGS]) AC_SUBST([NUMACTL_LIBS]) +dnl pcap lib +LIBPCAP_CONFIG="pcap-config" +LIBPCAP_CFLAGS="" +LIBPCAP_LIBS="" +LIBPCAP_FOUND="no" + +AC_ARG_WITH([libpcap], AC_HELP_STRING([--with-libpcap=@<:@PFX@:>@], [libpcap location])) +if test "$with_qemu" = "yes"; then + if test "x$with_libpcap" != "xno" ; then + if test "x$with_libpcap" != "x" ; then + LIBPCAP_CONFIG=$with_libpcap/bin/$LIBPCAP_CONFIG + fi + AC_MSG_CHECKING(libpcap $LIBPCAP_CONFIG >= $LIBPCAP_REQUIRED ) + if ! $LIBPCAP_CONFIG --libs > /dev/null 2>&1 ; then + AC_MSG_RESULT(no) + else + LIBPCAP_LIBS="`$LIBPCAP_CONFIG --libs`" + LIBPCAP_CFLAGS="`$LIBPCAP_CONFIG --cflags`" + LIBPCAP_FOUND="yes" + AC_MSG_RESULT(yes) + fi + fi +fi + +if test "x$LIBPCAP_FOUND" = "xyes"; then + AC_DEFINE_UNQUOTED([HAVE_LIBPCAP], 1, [whether libpcap can be used]) +fi + +AC_SUBST([LIBPCAP_CFLAGS]) +AC_SUBST([LIBPCAP_LIBS]) + + + dnl dnl Checks for the UML driver dnl @@ -2129,6 +2163,11 @@ AC_MSG_NOTICE([ xmlrpc: $XMLRPC_CFLAGS $XMLRPC_LIBS]) else AC_MSG_NOTICE([ xmlrpc: no]) fi +if test "$with_qemu" = "yes" ; then +AC_MSG_NOTICE([ pcap: $LIBPCAP_CFLAGS $LIBPCAP_LIBS]) +else +AC_MSG_NOTICE([ pcap: no]) +fi AC_MSG_NOTICE([]) AC_MSG_NOTICE([Test suite]) AC_MSG_NOTICE([]) diff --git a/libvirt.spec.in b/libvirt.spec.in index dcbc139dcb..834b1a666e 100644 --- a/libvirt.spec.in +++ b/libvirt.spec.in @@ -61,6 +61,7 @@ %define with_udev 0%{!?_without_udev:0} %define with_hal 0%{!?_without_hal:0} %define with_yajl 0%{!?_without_yajl:0} +%define with_libpcap 0%{!?_without_libpcap:0} # Non-server/HV driver defaults which are always enabled %define with_python 0%{!?_without_python:1} @@ -147,6 +148,11 @@ %define with_yajl 0%{!?_without_yajl:%{server_drivers}} %endif +# Enable libpcap library +%if %{with_qemu} +%define with_libpcap 0%{!?_without_libpcap:%{server_drivers}} +%endif + # Force QEMU to run as non-root %if 0%{?fedora} >= 12 || 0%{?rhel} >= 6 %define qemu_user qemu @@ -266,6 +272,9 @@ BuildRequires: libpciaccess-devel >= 0.10.9 %if %{with_yajl} BuildRequires: yajl-devel %endif +%if %{with_libpcap} +BuildRequires: libpcap-devel +%endif %if %{with_avahi} BuildRequires: avahi-devel %endif diff --git a/src/Makefile.am b/src/Makefile.am index cd1848ef18..db69ab96b8 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -308,7 +308,9 @@ NWFILTER_DRIVER_SOURCES = \ nwfilter/nwfilter_gentech_driver.c \ nwfilter/nwfilter_gentech_driver.h \ nwfilter/nwfilter_ebiptables_driver.c \ - nwfilter/nwfilter_ebiptables_driver.h + nwfilter/nwfilter_ebiptables_driver.h \ + nwfilter/nwfilter_learnipaddr.c \ + nwfilter/nwfilter_learnipaddr.h # Security framework and drivers for various models @@ -764,10 +766,11 @@ else libvirt_la_LIBADD += libvirt_driver_nwfilter.la noinst_LTLIBRARIES += libvirt_driver_nwfilter.la endif -libvirt_driver_nwfilter_la_CFLAGS = \ +libvirt_driver_nwfilter_la_CFLAGS = $(LIBPCAP_CFLAGS) \ -I@top_srcdir@/src/conf +libvirt_driver_nwfilter_la_LDFLAGS = $(LIBPCAP_LIBS) if WITH_DRIVER_MODULES -libvirt_driver_nwfilter_la_LDFLAGS = -module -avoid-version ../gnulib/lib/libgnu.la +libvirt_driver_nwfilter_la_LDFLAGS += -module -avoid-version ../gnulib/lib/libgnu.la endif libvirt_driver_nwfilter_la_SOURCES = $(NWFILTER_DRIVER_SOURCES) endif @@ -912,6 +915,7 @@ libvirt_la_LDFLAGS = $(VERSION_SCRIPT_FLAGS)libvirt.syms \ -version-info $(LIBVIRT_VERSION_INFO) \ $(COVERAGE_CFLAGS:-f%=-Wc,-f%) \ $(LIBXML_LIBS) \ + $(LIBPCAP_LIBS) \ $(DRIVER_MODULE_LIBS) \ $(CYGWIN_EXTRA_LDFLAGS) $(MINGW_EXTRA_LDFLAGS) libvirt_la_CFLAGS = $(COVERAGE_CFLAGS) -DIN_LIBVIRT @@ -960,8 +964,8 @@ libvirt_lxc_SOURCES = \ $(NODE_INFO_SOURCES) \ $(ENCRYPTION_CONF_SOURCES) \ $(DOMAIN_CONF_SOURCES) \ - $(NWFILTER_PARAM_CONF_SOURCES) \ - $(CPU_CONF_SOURCES) + $(CPU_CONF_SOURCES) \ + $(NWFILTER_PARAM_CONF_SOURCES) libvirt_lxc_LDFLAGS = $(WARN_CFLAGS) $(COVERAGE_LDCFLAGS) $(CAPNG_LIBS) $(YAJL_LIBS) libvirt_lxc_LDADD = $(LIBXML_LIBS) $(NUMACTL_LIBS) ../gnulib/lib/libgnu.la libvirt_lxc_CFLAGS = \ diff --git a/src/conf/nwfilter_conf.c b/src/conf/nwfilter_conf.c index 16c1a255ba..3991c3bf98 100644 --- a/src/conf/nwfilter_conf.c +++ b/src/conf/nwfilter_conf.c @@ -114,17 +114,18 @@ struct int_map { */ static virMutex updateMutex; -static void +void virNWFilterLockFilterUpdates(void) { virMutexLock(&updateMutex); } -static void +void virNWFilterUnlockFilterUpdates(void) { virMutexUnlock(&updateMutex); } + /* * attribute names for the rules XML */ @@ -2615,7 +2616,7 @@ int virNWFilterConfLayerInit(virHashIterator domUpdateCB) { virNWFilterDomainFWUpdateCB = domUpdateCB; - if (virMutexInit(&updateMutex)) + if (virMutexInitRecursive(&updateMutex)) return 1; return 0; diff --git a/src/conf/nwfilter_conf.h b/src/conf/nwfilter_conf.h index 37d75dfe54..fc3ce16e7a 100644 --- a/src/conf/nwfilter_conf.h +++ b/src/conf/nwfilter_conf.h @@ -558,6 +558,9 @@ virNWFilterDefPtr virNWFilterDefParseFile(virConnectPtr conn, void virNWFilterPoolObjLock(virNWFilterPoolObjPtr obj); void virNWFilterPoolObjUnlock(virNWFilterPoolObjPtr obj); +void virNWFilterLockFilterUpdates(void); +void virNWFilterUnlockFilterUpdates(void); + int virNWFilterConfLayerInit(virHashIterator domUpdateCB); void virNWFilterConfLayerShutdown(void); diff --git a/src/internal.h b/src/internal.h index 807288b868..2e73210d0e 100644 --- a/src/internal.h +++ b/src/internal.h @@ -138,6 +138,23 @@ # endif # endif +/** + * ATTRIBUTE_PACKED + * + * force a structure to be packed, i.e. not following architecture and + * compiler best alignments for its sub components. It's needed for example + * for the network filetering code when defining the content of raw + * ethernet packets. + * Others compiler than gcc may use something different e.g. #pragma pack(1) + */ +# ifndef ATTRIBUTE_PACKED +# if __GNUC_PREREQ (3, 3) +# define ATTRIBUTE_PACKED __attribute__((packed)) +# else +# error "Need an __attribute__((packed)) equivalent" +# endif +# endif + # ifndef ATTRIBUTE_NONNULL # if __GNUC_PREREQ (3, 3) # define ATTRIBUTE_NONNULL(m) __attribute__((__nonnull__(m))) diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index 1682b25cd1..814e2d8bc8 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -499,6 +499,8 @@ virNWFilterRegisterCallbackDriver; virNWFilterTestUnassignDef; virNWFilterConfLayerInit; virNWFilterConfLayerShutdown; +virNWFilterLockFilterUpdates; +virNWFilterUnlockFilterUpdates; #nwfilter_params.h @@ -514,6 +516,16 @@ virNWFilterInstantiateFilter; virNWFilterTeardownFilter; +#nwfilter_learnipaddr.h +ipAddressMap; +ipAddressMapLock; +pendingLearnReq; +pendingLearnReqLock; +virNWFilterGetIpAddrForIfname; +virNWFilterDelIpAddrForIfname; +virNWFilterLookupLearnReq; + + # pci.h pciGetDevice; pciFreeDevice; diff --git a/src/nwfilter/nwfilter_driver.c b/src/nwfilter/nwfilter_driver.c index 58df4e126a..f366005c70 100644 --- a/src/nwfilter/nwfilter_driver.c +++ b/src/nwfilter/nwfilter_driver.c @@ -37,6 +37,8 @@ #include "nwfilter_gentech_driver.h" +#include "nwfilter_learnipaddr.h" + #define VIR_FROM_THIS VIR_FROM_NWFILTER #define nwfilterLog(msg...) fprintf(stderr, msg) @@ -65,9 +67,12 @@ static int nwfilterDriverStartup(int privileged) { char *base = NULL; - if (virNWFilterConfLayerInit(virNWFilterDomainFWUpdateCB) < 0) + if (virNWFilterLearnInit() < 0) return -1; + if (virNWFilterConfLayerInit(virNWFilterDomainFWUpdateCB) < 0) + goto conf_init_err; + if (VIR_ALLOC(driverState) < 0) goto alloc_err_exit; @@ -120,6 +125,9 @@ error: alloc_err_exit: virNWFilterConfLayerShutdown(); +conf_init_err: + virNWFilterLearnShutdown(); + return -1; } @@ -413,5 +421,6 @@ static virStateDriver stateDriver = { int nwfilterRegister(void) { virRegisterNWFilterDriver(&nwfilterDriver); virRegisterStateDriver(&stateDriver); + virNWFilterLearnInit(); return 0; } diff --git a/src/nwfilter/nwfilter_ebiptables_driver.c b/src/nwfilter/nwfilter_ebiptables_driver.c index 4ec7edffc0..23c50dfd12 100644 --- a/src/nwfilter/nwfilter_ebiptables_driver.c +++ b/src/nwfilter/nwfilter_ebiptables_driver.c @@ -2519,6 +2519,242 @@ ebiptablesInstCommand(virBufferPtr buf, } +/** + * ebtablesApplyBasicRules + * + * @conn: virConnect object + * @ifname: name of the backend-interface to which to apply the rules + * @macaddr: MAC address the VM is using in packets sent through the + * interface + * + * Returns 0 on success, 1 on failure with the rules removed + * + * Apply basic filtering rules on the given interface + * - filtering for MAC address spoofing + * - allowing IPv4 & ARP traffic + */ +int +ebtablesApplyBasicRules(const char *ifname, + const unsigned char *macaddr) +{ + virBuffer buf = VIR_BUFFER_INITIALIZER; + int cli_status; + char chain[MAX_CHAINNAME_LENGTH]; + char chainPrefix = CHAINPREFIX_HOST_IN_TEMP; + char macaddr_str[VIR_MAC_STRING_BUFLEN]; + + virFormatMacAddr(macaddr, macaddr_str); + + ebtablesUnlinkTmpRootChain(&buf, 1, ifname); + ebtablesUnlinkTmpRootChain(&buf, 0, ifname); + ebtablesRemoveTmpSubChains(&buf, ifname); + ebtablesRemoveTmpRootChain(&buf, 1, ifname); + ebtablesRemoveTmpRootChain(&buf, 0, ifname); + ebiptablesExecCLI(&buf, &cli_status); + + ebtablesCreateTmpRootChain(&buf, 1, ifname, 1); + + PRINT_ROOT_CHAIN(chain, chainPrefix, ifname); + virBufferVSprintf(&buf, + CMD_DEF(EBTABLES_CMD + " -t %s -A %s -s ! %s -j DROP") CMD_SEPARATOR + CMD_EXEC + "%s", + + EBTABLES_DEFAULT_TABLE, + chain, + macaddr_str, + CMD_STOPONERR(1)); + + virBufferVSprintf(&buf, + CMD_DEF(EBTABLES_CMD + " -t %s -A %s -p IPv4 -j ACCEPT") CMD_SEPARATOR + CMD_EXEC + "%s", + + EBTABLES_DEFAULT_TABLE, + chain, + CMD_STOPONERR(1)); + + virBufferVSprintf(&buf, + CMD_DEF(EBTABLES_CMD + " -t %s -A %s -p ARP -j ACCEPT") CMD_SEPARATOR + CMD_EXEC + "%s", + + EBTABLES_DEFAULT_TABLE, + chain, + CMD_STOPONERR(1)); + + virBufferVSprintf(&buf, + CMD_DEF(EBTABLES_CMD + " -t %s -A %s -j DROP") CMD_SEPARATOR + CMD_EXEC + "%s", + + EBTABLES_DEFAULT_TABLE, + chain, + CMD_STOPONERR(1)); + + ebtablesLinkTmpRootChain(&buf, 1, ifname, 1); + + if (ebiptablesExecCLI(&buf, &cli_status) || cli_status != 0) + goto tear_down_tmpebchains; + + return 0; + +tear_down_tmpebchains: + ebtablesRemoveBasicRules(ifname); + + virNWFilterReportError(VIR_ERR_BUILD_FIREWALL, + "%s", + _("Some rules could not be created.")); + + return 1; +} + + +/** + * ebtablesApplyDHCPOnlyRules + * + * @ifname: name of the backend-interface to which to apply the rules + * @macaddr: MAC address the VM is using in packets sent through the + * interface + * @dhcpserver: The DHCP server from which the VM may receive traffic + * from; may be NULL + * + * Returns 0 on success, 1 on failure with the rules removed + * + * Apply filtering rules so that the VM can only send and receive + * DHCP traffic and nothing else. + */ +int +ebtablesApplyDHCPOnlyRules(const char *ifname, + const unsigned char *macaddr, + const char *dhcpserver) +{ + virBuffer buf = VIR_BUFFER_INITIALIZER; + int cli_status; + char chain_in [MAX_CHAINNAME_LENGTH], + chain_out[MAX_CHAINNAME_LENGTH]; + char macaddr_str[VIR_MAC_STRING_BUFLEN]; + char *srcIPParam = NULL; + + if (dhcpserver) { + virBufferVSprintf(&buf, " --ip-src %s", dhcpserver); + if (virBufferError(&buf)) + return 1; + srcIPParam = virBufferContentAndReset(&buf); + } + + virFormatMacAddr(macaddr, macaddr_str); + + ebtablesUnlinkTmpRootChain(&buf, 1, ifname); + ebtablesUnlinkTmpRootChain(&buf, 0, ifname); + ebtablesRemoveTmpSubChains(&buf, ifname); + ebtablesRemoveTmpRootChain(&buf, 1, ifname); + ebtablesRemoveTmpRootChain(&buf, 0, ifname); + ebiptablesExecCLI(&buf, &cli_status); + + ebtablesCreateTmpRootChain(&buf, 1, ifname, 1); + ebtablesCreateTmpRootChain(&buf, 0, ifname, 1); + + PRINT_ROOT_CHAIN(chain_in , CHAINPREFIX_HOST_IN_TEMP , ifname); + PRINT_ROOT_CHAIN(chain_out, CHAINPREFIX_HOST_OUT_TEMP, ifname); + + virBufferVSprintf(&buf, + CMD_DEF(EBTABLES_CMD + " -t %s -A %s" + " -s %s -d Broadcast " + " -p ipv4 --ip-protocol udp" + " --ip-src 0.0.0.0 --ip-dst 255.255.255.255" + " --ip-sport 68 --ip-dport 67" + " -j ACCEPT") CMD_SEPARATOR + CMD_EXEC + "%s", + + EBTABLES_DEFAULT_TABLE, + chain_in, + macaddr_str, + CMD_STOPONERR(1)); + + virBufferVSprintf(&buf, + CMD_DEF(EBTABLES_CMD + " -t %s -A %s -j DROP") CMD_SEPARATOR + CMD_EXEC + "%s", + + EBTABLES_DEFAULT_TABLE, + chain_in, + CMD_STOPONERR(1)); + + virBufferVSprintf(&buf, + CMD_DEF(EBTABLES_CMD + " -t %s -A %s" + " -d %s" + " -p ipv4 --ip-protocol udp" + " %s" + " --ip-sport 67 --ip-dport 68" + " -j ACCEPT") CMD_SEPARATOR + CMD_EXEC + "%s", + + EBTABLES_DEFAULT_TABLE, + chain_out, + macaddr_str, + srcIPParam != NULL ? srcIPParam : "", + CMD_STOPONERR(1)); + + virBufferVSprintf(&buf, + CMD_DEF(EBTABLES_CMD + " -t %s -A %s -j DROP") CMD_SEPARATOR + CMD_EXEC + "%s", + + EBTABLES_DEFAULT_TABLE, + chain_out, + CMD_STOPONERR(1)); + + ebtablesLinkTmpRootChain(&buf, 1, ifname, 1); + ebtablesLinkTmpRootChain(&buf, 0, ifname, 1); + + if (ebiptablesExecCLI(&buf, &cli_status) || cli_status != 0) + goto tear_down_tmpebchains; + + VIR_FREE(srcIPParam); + + return 0; + +tear_down_tmpebchains: + ebtablesRemoveBasicRules(ifname); + + virNWFilterReportError(VIR_ERR_BUILD_FIREWALL, + "%s", + _("Some rules could not be created.")); + + VIR_FREE(srcIPParam); + + return 1; +} + + +int +ebtablesRemoveBasicRules(const char *ifname) +{ + virBuffer buf = VIR_BUFFER_INITIALIZER; + int cli_status; + + ebtablesUnlinkTmpRootChain(&buf, 1, ifname); + ebtablesUnlinkTmpRootChain(&buf, 0, ifname); + ebtablesRemoveTmpSubChains(&buf, ifname); + ebtablesRemoveTmpRootChain(&buf, 1, ifname); + ebtablesRemoveTmpRootChain(&buf, 0, ifname); + + ebiptablesExecCLI(&buf, &cli_status); + return 0; +} + + static int ebiptablesRuleOrderSort(const void *a, const void *b) { diff --git a/src/nwfilter/nwfilter_ebiptables_driver.h b/src/nwfilter/nwfilter_ebiptables_driver.h index d99de3b719..4129d05d8d 100644 --- a/src/nwfilter/nwfilter_ebiptables_driver.h +++ b/src/nwfilter/nwfilter_ebiptables_driver.h @@ -45,4 +45,12 @@ extern virNWFilterTechDriver ebiptables_driver; # define EBIPTABLES_DRIVER_ID "ebiptables" + +int ebtablesApplyBasicRules(const char *ifname, + const unsigned char *macaddr); +int ebtablesApplyDHCPOnlyRules(const char *ifname, + const unsigned char *macaddr, + const char *dhcpServer); +int ebtablesRemoveBasicRules(const char *ifname); + #endif diff --git a/src/nwfilter/nwfilter_gentech_driver.c b/src/nwfilter/nwfilter_gentech_driver.c index 76967c10a2..270dc2b05b 100644 --- a/src/nwfilter/nwfilter_gentech_driver.c +++ b/src/nwfilter/nwfilter_gentech_driver.c @@ -24,6 +24,9 @@ #include #include +#include +#include +#include #include "internal.h" @@ -34,12 +37,16 @@ #include "virterror_internal.h" #include "nwfilter_gentech_driver.h" #include "nwfilter_ebiptables_driver.h" +#include "nwfilter_learnipaddr.h" #define VIR_FROM_THIS VIR_FROM_NWFILTER #define NWFILTER_STD_VAR_MAC "MAC" +#define NWFILTER_STD_VAR_IP "IP" + +static int _virNWFilterTeardownFilter(const char *ifname); static virNWFilterTechDriverPtr filter_tech_drivers[] = { @@ -108,6 +115,8 @@ virNWFilterRuleInstFree(virNWFilterRuleInstPtr inst) * @tables: pointer to hash tabel to add values to * @macaddr: The string of the MAC address to add to the hash table, * may be NULL + * @ipaddr: The string of the IP address to add to the hash table; + * may be NULL * * Returns 0 in case of success, 1 in case an error happened with * error having been reported. @@ -116,7 +125,8 @@ virNWFilterRuleInstFree(virNWFilterRuleInstPtr inst) */ static int virNWFilterVarHashmapAddStdValues(virNWFilterHashTablePtr table, - char *macaddr) + char *macaddr, + char *ipaddr) { if (macaddr) { if (virHashAddEntry(table->hashTable, @@ -128,6 +138,16 @@ virNWFilterVarHashmapAddStdValues(virNWFilterHashTablePtr table, } } + if (ipaddr) { + if (virHashAddEntry(table->hashTable, + NWFILTER_STD_VAR_IP, + ipaddr) < 0) { + virNWFilterReportError(VIR_ERR_INTERNAL_ERROR, + "%s", _("Could not add variable 'IP' to hashmap")); + return 1; + } + } + return 0; } @@ -135,22 +155,24 @@ virNWFilterVarHashmapAddStdValues(virNWFilterHashTablePtr table, /** * virNWFilterCreateVarHashmap: * @macaddr: pointer to string containing formatted MAC address of interface + * @ipaddr: pointer to string containing formatted IP address used by + * VM on this interface; may be NULL * * Create a hashmap used for evaluating the firewall rules. Initializes - * it with the standard variable 'MAC'. + * it with the standard variable 'MAC' and 'IP' if provided. * * Returns pointer to hashmap, NULL if an error occcurred and error message * is attached to the virConnect object. */ virNWFilterHashTablePtr -virNWFilterCreateVarHashmap(char *macaddr) { +virNWFilterCreateVarHashmap(char *macaddr, char *ipaddr) { virNWFilterHashTablePtr table = virNWFilterHashTableCreate(0); if (!table) { virReportOOMError(); return NULL; } - if (virNWFilterVarHashmapAddStdValues(table, macaddr)) { + if (virNWFilterVarHashmapAddStdValues(table, macaddr, ipaddr)) { virNWFilterHashTableFree(table); return NULL; } @@ -276,9 +298,9 @@ _virNWFilterInstantiateRec(virConnectPtr conn, virNWFilterHashTablePtr vars, int *nEntries, virNWFilterRuleInstPtr **insts, - enum instCase useNewFilter, int *foundNewFilter) + enum instCase useNewFilter, int *foundNewFilter, + virNWFilterDriverStatePtr driver) { - virNWFilterDriverStatePtr driver = conn->nwfilterPrivateData; virNWFilterPoolObjPtr obj; int rc = 0; int i; @@ -356,7 +378,95 @@ _virNWFilterInstantiateRec(virConnectPtr conn, tmpvars, nEntries, insts, useNewFilter, - foundNewFilter); + foundNewFilter, + driver); + + virNWFilterHashTableFree(tmpvars); + + virNWFilterPoolObjUnlock(obj); + if (rc) + break; + } else { + virNWFilterReportError(VIR_ERR_INTERNAL_ERROR, + _("referenced filter '%s' is missing"), + inc->filterref); + rc = 1; + break; + } + } + } + return rc; +} + + +static int +virNWFilterDetermineMissingVarsRec(virConnectPtr conn, + virNWFilterDefPtr filter, + virNWFilterHashTablePtr vars, + virNWFilterHashTablePtr missing_vars, + int useNewFilter, + virNWFilterDriverStatePtr driver) +{ + virNWFilterPoolObjPtr obj; + int rc = 0; + int i, j; + virNWFilterDefPtr next_filter; + + for (i = 0; i < filter->nentries; i++) { + virNWFilterRuleDefPtr rule = filter->filterEntries[i]->rule; + virNWFilterIncludeDefPtr inc = filter->filterEntries[i]->include; + if (rule) { + // check all variables of this rule + for (j = 0; j < rule->nvars; j++) { + if (!virHashLookup(vars->hashTable, rule->vars[j])) { + virNWFilterHashTablePut(missing_vars, rule->vars[j], + strdup("1"), 1); + } + } + } else if (inc) { + VIR_DEBUG("Following filter %s\n", inc->filterref); + obj = virNWFilterPoolObjFindByName(&driver->pools, + inc->filterref); + if (obj) { + + if (obj->wantRemoved) { + virNWFilterReportError(VIR_ERR_NO_NWFILTER, + _("Filter '%s' is in use."), + inc->filterref); + rc = 1; + virNWFilterPoolObjUnlock(obj); + break; + } + + // create a temporary hashmap for depth-first tree traversal + virNWFilterHashTablePtr tmpvars = + virNWFilterCreateVarsFrom(inc->params, + vars); + if (!tmpvars) { + virReportOOMError(); + rc = 1; + virNWFilterPoolObjUnlock(obj); + break; + } + + next_filter = obj->def; + + switch (useNewFilter) { + case INSTANTIATE_FOLLOW_NEWFILTER: + if (obj->newDef) { + next_filter = obj->newDef; + } + break; + case INSTANTIATE_ALWAYS: + break; + } + + rc = virNWFilterDetermineMissingVarsRec(conn, + next_filter, + tmpvars, + missing_vars, + useNewFilter, + driver); virNWFilterHashTableFree(tmpvars); @@ -429,9 +539,12 @@ virNWFilterInstantiate(virConnectPtr conn, enum virDomainNetType nettype, virNWFilterDefPtr filter, const char *ifname, + const char *linkdev, virNWFilterHashTablePtr vars, enum instCase useNewFilter, int *foundNewFilter, - bool teardownOld) + bool teardownOld, + const unsigned char *macaddr, + virNWFilterDriverStatePtr driver) { int rc; int j, nptrs; @@ -440,6 +553,44 @@ virNWFilterInstantiate(virConnectPtr conn, void **ptrs = NULL; int instantiate = 1; + virNWFilterLockFilterUpdates(); + + virNWFilterHashTablePtr missing_vars = virNWFilterHashTableCreate(0); + if (!missing_vars) { + virReportOOMError(); + rc = 1; + goto err_exit; + } + + rc = virNWFilterDetermineMissingVarsRec(conn, + filter, + vars, + missing_vars, + useNewFilter, + driver); + if (rc) + goto err_exit; + + if (virHashSize(missing_vars->hashTable) == 1) { + if (virHashLookup(missing_vars->hashTable, + NWFILTER_STD_VAR_IP) != NULL) { + if (virNWFilterLookupLearnReq(ifname) == NULL) { + rc = virNWFilterLearnIPAddress(ifname, + linkdev, + nettype, macaddr, + filter->name, + vars, driver, + DETECT_DHCP|DETECT_STATIC); + } + goto err_exit; + } + rc = 1; + goto err_exit; + } else if (virHashSize(missing_vars->hashTable) > 1) { + rc = 1; + goto err_exit; + } + rc = _virNWFilterInstantiateRec(conn, techdriver, nettype, @@ -447,7 +598,8 @@ virNWFilterInstantiate(virConnectPtr conn, ifname, vars, &nEntries, &insts, - useNewFilter, foundNewFilter); + useNewFilter, foundNewFilter, + driver); if (rc) goto err_exit; @@ -478,24 +630,33 @@ virNWFilterInstantiate(virConnectPtr conn, err_exit: + virNWFilterUnlockFilterUpdates(); + for (j = 0; j < nEntries; j++) virNWFilterRuleInstFree(insts[j]); VIR_FREE(insts); + virNWFilterHashTableFree(missing_vars); + return rc; } static int -_virNWFilterInstantiateFilter(virConnectPtr conn, - const virDomainNetDefPtr net, - bool teardownOld, - enum instCase useNewFilter) +__virNWFilterInstantiateFilter(virConnectPtr conn, + bool teardownOld, + const char *ifname, + const char *linkdev, + enum virDomainNetType nettype, + const unsigned char *macaddr, + const char *filtername, + virNWFilterHashTablePtr filterparams, + enum instCase useNewFilter, + virNWFilterDriverStatePtr driver) { int rc; const char *drvname = EBIPTABLES_DRIVER_ID; - virNWFilterDriverStatePtr driver = conn->nwfilterPrivateData; virNWFilterTechDriverPtr techdriver; virNWFilterPoolObjPtr obj; virNWFilterHashTablePtr vars, vars1; @@ -503,6 +664,8 @@ _virNWFilterInstantiateFilter(virConnectPtr conn, char vmmacaddr[VIR_MAC_STRING_BUFLEN] = {0}; int foundNewFilter = 0; char *str_macaddr = NULL; + const char *ipaddr; + char *str_ipaddr = NULL; techdriver = virNWFilterTechDriverForName(drvname); @@ -514,25 +677,25 @@ _virNWFilterInstantiateFilter(virConnectPtr conn, return 1; } - VIR_DEBUG("filter name: %s", net->filter); + VIR_DEBUG("filter name: %s", filtername); - obj = virNWFilterPoolObjFindByName(&driver->pools, net->filter); + obj = virNWFilterPoolObjFindByName(&driver->pools, filtername); if (!obj) { virNWFilterReportError(VIR_ERR_NO_NWFILTER, _("Could not find filter '%s'"), - net->filter); + filtername); return 1; } if (obj->wantRemoved) { virNWFilterReportError(VIR_ERR_NO_NWFILTER, _("Filter '%s' is in use."), - net->filter); + filtername); rc = 1; goto err_exit; } - virFormatMacAddr(net->mac, vmmacaddr); + virFormatMacAddr(macaddr, vmmacaddr); str_macaddr = strdup(vmmacaddr); if (!str_macaddr) { virReportOOMError(); @@ -540,16 +703,27 @@ _virNWFilterInstantiateFilter(virConnectPtr conn, goto err_exit; } - vars1 = virNWFilterCreateVarHashmap(str_macaddr); + ipaddr = virNWFilterGetIpAddrForIfname(ifname); + if (ipaddr) { + str_ipaddr = strdup(ipaddr); + if (!str_ipaddr) { + virReportOOMError(); + rc = 1; + goto err_exit; + } + } + + vars1 = virNWFilterCreateVarHashmap(str_macaddr, str_ipaddr); if (!vars1) { rc = 1; goto err_exit; } str_macaddr = NULL; + str_ipaddr = NULL; vars = virNWFilterCreateVarsFrom(vars1, - net->filterparams); + filterparams); if (!vars) { rc = 1; goto err_exit_vars1; @@ -571,12 +745,15 @@ _virNWFilterInstantiateFilter(virConnectPtr conn, rc = virNWFilterInstantiate(conn, techdriver, - net->type, + nettype, filter, - net->ifname, + ifname, + linkdev, vars, useNewFilter, &foundNewFilter, - teardownOld); + teardownOld, + macaddr, + driver); virNWFilterHashTableFree(vars); @@ -584,15 +761,180 @@ err_exit_vars1: virNWFilterHashTableFree(vars1); err_exit: - virNWFilterPoolObjUnlock(obj); + VIR_FREE(str_ipaddr); VIR_FREE(str_macaddr); return rc; } +static int +_virNWFilterInstantiateFilter(virConnectPtr conn, + const virDomainNetDefPtr net, + bool teardownOld, + enum instCase useNewFilter) +{ + const char *linkdev = (net->type == VIR_DOMAIN_NET_TYPE_DIRECT) + ? net->data.direct.linkdev + : NULL; + return __virNWFilterInstantiateFilter(conn, + teardownOld, + net->ifname, + linkdev, + net->type, + net->mac, + net->filter, + net->filterparams, + useNewFilter, + conn->nwfilterPrivateData); +} + + +// FIXME: move chgIfFlags, ifUp, checkIf into common file & share w/ macvtap.c + +/* + * chgIfFlags: Change flags on an interface + * @ifname : name of the interface + * @flagclear : the flags to clear + * @flagset : the flags to set + * + * The new flags of the interface will be calculated as + * flagmask = (~0 ^ flagclear) + * newflags = (curflags & flagmask) | flagset; + * + * Returns 0 on success, errno on failure. + */ +static int chgIfFlags(const char *ifname, short flagclear, short flagset) { + struct ifreq ifr; + int rc = 0; + int flags; + short flagmask = (~0 ^ flagclear); + int fd = socket(PF_PACKET, SOCK_DGRAM, 0); + + if (fd < 0) + return errno; + + if (virStrncpy(ifr.ifr_name, + ifname, strlen(ifname), sizeof(ifr.ifr_name)) == NULL) { + rc = ENODEV; + goto err_exit; + } + + if (ioctl(fd, SIOCGIFFLAGS, &ifr) < 0) { + rc = errno; + goto err_exit; + } + + flags = (ifr.ifr_flags & flagmask) | flagset; + + if (ifr.ifr_flags != flags) { + ifr.ifr_flags = flags; + + if (ioctl(fd, SIOCSIFFLAGS, &ifr) < 0) + rc = errno; + } + +err_exit: + close(fd); + return rc; +} + +/* + * ifUp + * @name: name of the interface + * @up: 1 for up, 0 for down + * + * Function to control if an interface is activated (up, 1) or not (down, 0) + * + * Returns 0 in case of success or an errno code in case of failure. + */ +static int +ifUp(const char *name, int up) +{ + return chgIfFlags(name, + (up) ? 0 : IFF_UP, + (up) ? IFF_UP : 0); +} + + +/** + * checkIf + * + * @ifname: Name of the interface + * @macaddr: expected MAC address of the interface + * + * FIXME: the interface's index is another good parameter to check + * + * Determine whether a given interface is still available. If so, + * it must have the given MAC address. + * + * Returns an error code ENODEV in case the interface does not exist + * anymore or its MAC address is different, 0 otherwise. + */ +int +checkIf(const char *ifname, const unsigned char *macaddr) +{ + struct ifreq ifr; + int fd = socket(PF_PACKET, SOCK_DGRAM, 0); + int rc = 0; + + if (fd < 0) + return errno; + + if (virStrncpy(ifr.ifr_name, + ifname, strlen(ifname), sizeof(ifr.ifr_name)) == NULL) { + rc = ENODEV; + goto err_exit; + } + + if (ioctl(fd, SIOCGIFHWADDR, &ifr) < 0) { + rc = errno; + goto err_exit; + } + + if (memcmp(&ifr.ifr_hwaddr.sa_data, macaddr, 6) != 0) + rc = ENODEV; + + err_exit: + close(fd); + return rc; +} + + +int +virNWFilterInstantiateFilterLate(virConnectPtr conn, + const char *ifname, + const char *linkdev, + enum virDomainNetType nettype, + const unsigned char *macaddr, + const char *filtername, + virNWFilterHashTablePtr filterparams, + virNWFilterDriverStatePtr driver) +{ + int rc; + rc = __virNWFilterInstantiateFilter(conn, + 1, + ifname, + linkdev, + nettype, + macaddr, + filtername, + filterparams, + INSTANTIATE_ALWAYS, + driver); + if (rc) { + //something went wrong... 'DOWN' the interface + if (ifUp(ifname ,0)) { + // assuming interface disappeared... + _virNWFilterTeardownFilter(ifname); + } + } + return rc; +} + + int virNWFilterInstantiateFilter(virConnectPtr conn, const virDomainNetDefPtr net) @@ -649,8 +991,8 @@ virNWFilterTearOldFilter(virConnectPtr conn, } -int -virNWFilterTeardownFilter(const virDomainNetDefPtr net) +static int +_virNWFilterTeardownFilter(const char *ifname) { const char *drvname = EBIPTABLES_DRIVER_ID; virNWFilterTechDriverPtr techdriver; @@ -663,13 +1005,21 @@ virNWFilterTeardownFilter(const virDomainNetDefPtr net) drvname); return 1; } + techdriver->allTeardown(ifname); - techdriver->allTeardown(net->ifname); + virNWFilterDelIpAddrForIfname(ifname); return 0; } +int +virNWFilterTeardownFilter(const virDomainNetDefPtr net) +{ + return _virNWFilterTeardownFilter(net->ifname); +} + + void virNWFilterDomainFWUpdateCB(void *payload, const char *name ATTRIBUTE_UNUSED, diff --git a/src/nwfilter/nwfilter_gentech_driver.h b/src/nwfilter/nwfilter_gentech_driver.h index 1068102357..ebb0b64f72 100644 --- a/src/nwfilter/nwfilter_gentech_driver.h +++ b/src/nwfilter/nwfilter_gentech_driver.h @@ -45,12 +45,24 @@ int virNWFilterRollbackUpdateFilter(virConnectPtr conn, int virNWFilterTearOldFilter(virConnectPtr conn, const virDomainNetDefPtr net); +int virNWFilterInstantiateFilterLate(virConnectPtr conn, + const char *ifname, + const char *linkdev, + enum virDomainNetType nettype, + const unsigned char *macaddr, + const char *filtername, + virNWFilterHashTablePtr filterparams, + virNWFilterDriverStatePtr driver); + int virNWFilterTeardownFilter(const virDomainNetDefPtr net); -virNWFilterHashTablePtr virNWFilterCreateVarHashmap(char *macaddr); +virNWFilterHashTablePtr virNWFilterCreateVarHashmap(char *macaddr, + char *ipaddr); void virNWFilterDomainFWUpdateCB(void *payload, const char *name ATTRIBUTE_UNUSED, void *data); +int checkIf(const char *ifname, const unsigned char *macaddr); + #endif diff --git a/src/nwfilter/nwfilter_learnipaddr.c b/src/nwfilter/nwfilter_learnipaddr.c new file mode 100644 index 0000000000..4a74582967 --- /dev/null +++ b/src/nwfilter/nwfilter_learnipaddr.c @@ -0,0 +1,622 @@ +/* + * nwfilter_learnipaddr.c: support for learning IP address used by a VM + * on an interface + * + * Copyright (C) 2010 IBM Corp. + * Copyright (C) 2010 Stefan Berger + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Author: Stefan Berger + */ + +#include + +#ifdef HAVE_LIBPCAP +# include +#endif + +#include +#include + +#include +#include +#include +#include +#include + +#include "internal.h" + +#include "buf.h" +#include "memory.h" +#include "logging.h" +#include "datatypes.h" +#include "virterror_internal.h" +#include "threads.h" +#include "conf/nwfilter_params.h" +#include "conf/domain_conf.h" +#include "nwfilter_gentech_driver.h" +#include "nwfilter_ebiptables_driver.h" +#include "nwfilter_learnipaddr.h" + +#define VIR_FROM_THIS VIR_FROM_NWFILTER + + +/* structure of an ARP request/reply message */ +struct f_arphdr { + struct arphdr arphdr; + uint8_t ar_sha[ETH_ALEN]; + uint32_t ar_sip; + uint8_t ar_tha[ETH_ALEN]; + uint32_t ar_tip; +} ATTRIBUTE_PACKED; + + +/* structure representing DHCP message */ +struct dhcp { + uint8_t op; + uint8_t htype; + uint8_t hlen; + uint8_t hops; + uint32_t xid; + uint16_t secs; + uint16_t flags; + uint32_t ciaddr; + uint32_t yiaddr; + uint32_t siaddr; + uint32_t giaddr; + uint8_t chaddr[16]; + /* omitted */ +} ATTRIBUTE_PACKED; + + +struct ether_vlan_header +{ + uint8_t dhost[ETH_ALEN]; + uint8_t shost[ETH_ALEN]; + uint16_t vlan_type; + uint16_t vlan_flags; + uint16_t ether_type; +} ATTRIBUTE_PACKED; + + +static virMutex pendingLearnReqLock; +static virHashTablePtr pendingLearnReq; + +static virMutex ipAddressMapLock; +static virNWFilterHashTablePtr ipAddressMap; + + +static void +virNWFilterIPAddrLearnReqFree(virNWFilterIPAddrLearnReqPtr req) { + if (!req) + return; + + VIR_FREE(req->filtername); + virNWFilterHashTableFree(req->filterparams); + + VIR_FREE(req); +} + + +#if HAVE_LIBPCAP + +static int +virNWFilterRegisterLearnReq(virNWFilterIPAddrLearnReqPtr req) { + int res = -1; + virMutexLock(&pendingLearnReqLock); + + if (!virHashLookup(pendingLearnReq, req->ifname)) + res = virHashAddEntry(pendingLearnReq, req->ifname, req); + + virMutexUnlock(&pendingLearnReqLock); + + return res; +} + +#endif + + +virNWFilterIPAddrLearnReqPtr +virNWFilterLookupLearnReq(const char *ifname) { + void *res; + + virMutexLock(&pendingLearnReqLock); + + res = virHashLookup(pendingLearnReq, ifname); + + virMutexUnlock(&pendingLearnReqLock); + + return res; +} + + +static void +freeLearnReqEntry(void *payload, const char *name ATTRIBUTE_UNUSED) { + virNWFilterIPAddrLearnReqFree(payload); +} + + +#ifdef HAVE_LIBPCAP + +static virNWFilterIPAddrLearnReqPtr +virNWFilterDeregisterLearnReq(const char *ifname) { + virNWFilterIPAddrLearnReqPtr res; + + virMutexLock(&pendingLearnReqLock); + + res = virHashLookup(pendingLearnReq, ifname); + + if (res) + virHashRemoveEntry(pendingLearnReq, ifname, NULL); + + virMutexUnlock(&pendingLearnReqLock); + + return res; +} + + + +static int +virNWFilterAddIpAddrForIfname(const char *ifname, char *addr) { + int ret; + + virMutexLock(&ipAddressMapLock); + + ret = virNWFilterHashTablePut(ipAddressMap, ifname, addr, 1); + + virMutexUnlock(&ipAddressMapLock); + + return ret; +} +#endif + + +void +virNWFilterDelIpAddrForIfname(const char *ifname) { + + virMutexLock(&ipAddressMapLock); + + if (virHashLookup(ipAddressMap->hashTable, ifname)) + virNWFilterHashTableRemoveEntry(ipAddressMap, ifname); + + virMutexUnlock(&ipAddressMapLock); +} + + +const char * +virNWFilterGetIpAddrForIfname(const char *ifname) { + const char *res; + + virMutexLock(&ipAddressMapLock); + + res = virHashLookup(ipAddressMap->hashTable, ifname); + + virMutexUnlock(&ipAddressMapLock); + + return res; +} + + +#ifdef HAVE_LIBPCAP + +/** + * learnIPAddressThread + * arg: pointer to virNWFilterIPAddrLearnReq structure + * + * Learn the IP address being used on an interface. Use ARP Request and + * Reply messages, DHCP offers and the first IP packet being sent from + * the VM to detect the IP address it is using. Detects only one IP address + * per interface (IP aliasing not supported). The method on how the + * IP address is detected can be chosen through flags. DETECT_DHCP will + * require that the IP address is detected from a DHCP OFFER, DETECT_STATIC + * will require that the IP address was taken from an ARP packet or an IPv4 + * packet. Both flags can be set at the same time. + */ +static void * +learnIPAddressThread(void *arg) +{ + char errbuf[PCAP_ERRBUF_SIZE] = {0}; + pcap_t *handle; + struct bpf_program fp; + struct pcap_pkthdr header; + const u_char *packet; + struct ether_header *ether_hdr; + struct ether_vlan_header *vlan_hdr; + virNWFilterIPAddrLearnReqPtr req = arg; + uint32_t vmaddr = 0; + unsigned int ethHdrSize; + char *listen_if = (strlen(req->linkdev) != 0) ? req->linkdev + : req->ifname; + int to_ms = (strlen(req->linkdev) != 0) ? 1000 + : 0; + char macaddr[VIR_MAC_STRING_BUFLEN]; + virBuffer buf = VIR_BUFFER_INITIALIZER; + char *filter= NULL; + uint16_t etherType; + enum howDetect howDetected = 0; + + req->status = 0; + + handle = pcap_open_live(listen_if, BUFSIZ, 0, to_ms, errbuf); + + if (handle == NULL) { + VIR_DEBUG("Couldn't open device %s: %s\n", listen_if, errbuf); + req->status = ENODEV; + goto done; + } + + virFormatMacAddr(req->macaddr, macaddr); + + switch (req->howDetect) { + case DETECT_DHCP: + virBufferVSprintf(&buf, " ether dst %s" + " and src port 67 and dst port 68", + macaddr); + break; + default: + virBufferVSprintf(&buf, "ether host %s", macaddr); + } + + if (virBufferError(&buf)) { + req->status = ENOMEM; + goto done; + } + + filter = virBufferContentAndReset(&buf); + + if (pcap_compile(handle, &fp, filter, 1, 0) != 0 || + pcap_setfilter(handle, &fp) != 0) { + VIR_DEBUG("Couldn't compile or set filter '%s'.\n", filter); + req->status = EINVAL; + goto done; + } + + while (req->status == 0 && vmaddr == 0) { + packet = pcap_next(handle, &header); + + if (!packet) { + if (to_ms == 0) { + /* assuming IF disappeared */ + req->status = ENODEV; + break; + } + /* listening on linkdev, check whether VM's dev is still there */ + if (checkIf(req->ifname, req->macaddr)) { + req->status = ENODEV; + break; + } + continue; + } + + if (header.len >= sizeof(struct ether_header)) { + ether_hdr = (struct ether_header*)packet; + + switch (ntohs(ether_hdr->ether_type)) { + + case ETHERTYPE_IP: + ethHdrSize = sizeof(struct ether_header); + etherType = ntohs(ether_hdr->ether_type); + break; + + case ETHERTYPE_VLAN: + ethHdrSize = sizeof(struct ether_vlan_header); + vlan_hdr = (struct ether_vlan_header *)packet; + if (ntohs(vlan_hdr->ether_type) != ETHERTYPE_IP || + header.len < ethHdrSize) + continue; + etherType = ntohs(vlan_hdr->ether_type); + break; + + default: + continue; + } + + if (memcmp(ether_hdr->ether_shost, + req->macaddr, + VIR_MAC_BUFLEN) == 0) { + // packets from the VM + + if (etherType == ETHERTYPE_IP && + (header.len >= ethHdrSize + + sizeof(struct iphdr))) { + struct iphdr *iphdr = (struct iphdr*)(packet + + ethHdrSize); + vmaddr = iphdr->saddr; + // skip eth. bcast and mcast addresses, + // and zero address in DHCP Requests + if ((ntohl(vmaddr) & 0xc0000000) || vmaddr == 0) { + vmaddr = 0; + continue; + } + + howDetected = DETECT_STATIC; + } else if (etherType == ETHERTYPE_ARP && + (header.len >= ethHdrSize + + sizeof(struct f_arphdr))) { + struct f_arphdr *arphdr = (struct f_arphdr*)(packet + + ethHdrSize); + switch (ntohs(arphdr->arphdr.ar_op)) { + case ARPOP_REPLY: + vmaddr = arphdr->ar_sip; + howDetected = DETECT_STATIC; + break; + case ARPOP_REQUEST: + vmaddr = arphdr->ar_tip; + howDetected = DETECT_STATIC; + break; + } + } + } else if (memcmp(ether_hdr->ether_dhost, + req->macaddr, + VIR_MAC_BUFLEN) == 0) { + // packets to the VM + if (etherType == ETHERTYPE_IP && + (header.len >= ethHdrSize + + sizeof(struct iphdr))) { + struct iphdr *iphdr = (struct iphdr*)(packet + + ethHdrSize); + if ((iphdr->protocol == IPPROTO_UDP) && + (header.len >= ethHdrSize + + iphdr->ihl * 4 + + sizeof(struct udphdr))) { + struct udphdr *udphdr= (struct udphdr *) + ((char *)iphdr + iphdr->ihl * 4); + if (ntohs(udphdr->source) == 67 && + ntohs(udphdr->dest) == 68 && + header.len >= ethHdrSize + + iphdr->ihl * 4 + + sizeof(struct udphdr) + + sizeof(struct dhcp)) { + struct dhcp *dhcp = (struct dhcp *) + ((char *)udphdr + sizeof(udphdr)); + if (dhcp->op == 2 /* DHCP OFFER */ && + !memcmp(&dhcp->chaddr[0], + req->macaddr, + 6)) { + vmaddr = dhcp->yiaddr; + howDetected = DETECT_DHCP; + } + } + } + } + } + } + if (vmaddr && (req->howDetect & howDetected) == 0) { + vmaddr = 0; + howDetected = 0; + } + } /* while */ + + done: + VIR_FREE(filter); + + if (handle) + pcap_close(handle); + + ebtablesRemoveBasicRules(req->ifname); + + if (req->status == 0) { + int ret; + char inetaddr[INET_ADDRSTRLEN]; + inet_ntop(AF_INET, &vmaddr, inetaddr, sizeof(inetaddr)); + + virNWFilterAddIpAddrForIfname(req->ifname, strdup(inetaddr)); + + ret = virNWFilterInstantiateFilterLate(NULL, + req->ifname, + req->linkdev, + req->nettype, + req->macaddr, + req->filtername, + req->filterparams, + req->driver); + VIR_DEBUG("Result from applying firewall rules on " + "%s with IP addr %s : %d\n", req->ifname, inetaddr, ret); + } + + memset(&req->thread, 0x0, sizeof(req->thread)); + + VIR_DEBUG("pcap thread terminating for interface %s\n",req->ifname); + + virNWFilterDeregisterLearnReq(req->ifname); + + virNWFilterIPAddrLearnReqFree(req); + + return 0; +} + + +/** + * virNWFilterLearnIPAddress + * @conn: pointer to virConnect object + * @ifname: the name of the interface + * @linkdev : the name of the link device; currently only used in case of a + * macvtap device + * @nettype : the type of interface + * @macaddr : the MAC address of the interface + * @filtername : the name of the top-level filter to apply to the interface + * once its IP address has been detected + * @driver : the network filter driver + * @howDetect : the method on how the thread is supposed to detect the + * IP address; must choose any of the available flags + * + * Instruct to learn the IP address being used on a given interface (ifname). + * Unless there already is a thread attempting to learn the IP address + * being used on the interface, a thread is started that will listen on + * the traffic being sent on the interface (or link device) with the + * MAC address that is provided. Will then launch the application of the + * firewall rules on the interface. + */ +int +virNWFilterLearnIPAddress(const char *ifname, + const char *linkdev, + enum virDomainNetType nettype, + const unsigned char *macaddr, + const char *filtername, + virNWFilterHashTablePtr filterparams, + virNWFilterDriverStatePtr driver, + enum howDetect howDetect) { + int rc; + virNWFilterIPAddrLearnReqPtr req = NULL; + virNWFilterHashTablePtr ht = NULL; + + if (howDetect == 0) + return 1; + + if (VIR_ALLOC(req) < 0) { + virReportOOMError(); + goto err_no_req; + } + + ht = virNWFilterHashTableCreate(0); + if (ht == NULL) { + virReportOOMError(); + goto err_no_ht; + } + + if (virNWFilterHashTablePutAll(filterparams, ht)) + goto err_free_ht; + + req->filtername = strdup(filtername); + if (req->filtername == NULL) { + virReportOOMError(); + goto err_free_ht; + } + + if (virStrcpyStatic(req->ifname, ifname) == NULL) { + virNWFilterReportError(VIR_ERR_INTERNAL_ERROR, + _("Destination buffer for ifname ('%s') " + "not large enough"), ifname); + goto err_free_ht; + } + + if (linkdev) { + if (virStrcpyStatic(req->linkdev, linkdev) == NULL) { + virNWFilterReportError(VIR_ERR_INTERNAL_ERROR, + _("Destination buffer for linkdev ('%s') " + "not large enough"), linkdev); + goto err_free_ht; + } + } + req->nettype = nettype; + memcpy(req->macaddr, macaddr, sizeof(req->macaddr)); + req->driver = driver; + req->filterparams = ht; + ht = NULL; + req->howDetect = howDetect; + + rc = virNWFilterRegisterLearnReq(req); + + if (rc) + goto err_free_ht; + + switch (howDetect) { + case DETECT_DHCP: + if (ebtablesApplyDHCPOnlyRules(ifname, + macaddr, + NULL)) + goto err_free_ht; + break; + default: + if (ebtablesApplyBasicRules(ifname, + macaddr)) + goto err_free_ht; + } + + + if (pthread_create(&req->thread, + NULL, + learnIPAddressThread, + req) != 0) + goto err_remove_rules; + + return 0; + +err_remove_rules: + ebtablesRemoveBasicRules(ifname); +err_free_ht: + virNWFilterHashTableFree(ht); +err_no_ht: + virNWFilterIPAddrLearnReqFree(req); +err_no_req: + return 1; +} + +#else + +int +virNWFilterLearnIPAddress(const char *ifname ATTRIBUTE_UNUSED, + const char *linkdev ATTRIBUTE_UNUSED, + enum virDomainNetType nettype ATTRIBUTE_UNUSED, + const unsigned char *macaddr ATTRIBUTE_UNUSED, + const char *filtername ATTRIBUTE_UNUSED, + virNWFilterHashTablePtr filterparams ATTRIBUTE_UNUSED, + virNWFilterDriverStatePtr driver ATTRIBUTE_UNUSED, + enum howDetect howDetect ATTRIBUTE_UNUSED) { + virNWFilterReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("IP parameter must be given since libvirt " + "was not compiled with IP address learning " + "support")); + return 1; +} +#endif /* HAVE_LIBPCAP */ + + +/** + * virNWFilterLearnInit + * Initialization of this layer + */ +int +virNWFilterLearnInit(void) { + pendingLearnReq = virHashCreate(0); + if (!pendingLearnReq) { + virReportOOMError(); + return 1; + } + + if (virMutexInit(&pendingLearnReqLock)) { + virNWFilterLearnShutdown(); + return 1; + } + + ipAddressMap = virNWFilterHashTableCreate(0); + if (!ipAddressMap) { + virReportOOMError(); + virNWFilterLearnShutdown(); + return 1; + } + + if (virMutexInit(&ipAddressMapLock)) { + virNWFilterLearnShutdown(); + return 1; + } + + return 0; +} + + +/** + * virNWFilterLearnShutdown + * Shutdown of this layer + */ +void +virNWFilterLearnShutdown(void) { + virHashFree(pendingLearnReq, freeLearnReqEntry); + pendingLearnReq = NULL; + + virNWFilterHashTableFree(ipAddressMap); + ipAddressMap = NULL; +} diff --git a/src/nwfilter/nwfilter_learnipaddr.h b/src/nwfilter/nwfilter_learnipaddr.h new file mode 100644 index 0000000000..ffdd342a95 --- /dev/null +++ b/src/nwfilter/nwfilter_learnipaddr.h @@ -0,0 +1,67 @@ +/* + * nwfilter_learnipaddr.h: support for learning IP address used by a VM + * on an interface + * + * Copyright (C) 2010 IBM Corp. + * Copyright (C) 2010 Stefan Berger + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Author: Stefan Berger + */ + +#ifndef __NWFILTER_LEARNIPADDR_H +# define __NWFILTER_LEARNIPADDR_H + +enum howDetect { + DETECT_DHCP = 1, + DETECT_STATIC = 2, +}; + +typedef struct _virNWFilterIPAddrLearnReq virNWFilterIPAddrLearnReq; +typedef virNWFilterIPAddrLearnReq *virNWFilterIPAddrLearnReqPtr; +struct _virNWFilterIPAddrLearnReq { + char ifname[IF_NAMESIZE]; + char linkdev[IF_NAMESIZE]; + enum virDomainNetType nettype; + unsigned char macaddr[VIR_MAC_BUFLEN]; + char *filtername; + virNWFilterHashTablePtr filterparams; + virNWFilterDriverStatePtr driver; + enum howDetect howDetect; + + int status; + pthread_t thread; +}; + +int virNWFilterLearnIPAddress(const char *ifname, + const char *linkdev, + enum virDomainNetType nettype, + const unsigned char *macaddr, + const char *filtername, + virNWFilterHashTablePtr filterparams, + virNWFilterDriverStatePtr driver, + enum howDetect howDetect); + +virNWFilterIPAddrLearnReqPtr virNWFilterLookupLearnReq(const char *ifname); + + +void virNWFilterDelIpAddrForIfname(const char *ifname); +const char *virNWFilterGetIpAddrForIfname(const char *ifname); + +int virNWFilterLearnInit(void); +void virNWFilterLearnShutdown(void); + +#endif /* __NWFILTER_LEARNIPADDR_H */ diff --git a/tests/nwfilterxml2xmltest b/tests/nwfilterxml2xmltest new file mode 100755 index 0000000000000000000000000000000000000000..7382a9fb54cc5bb215ff0f5625a21c743a0bcc15 GIT binary patch literal 462966 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 z zO4wk8fp>R)zElKVc?cK-#=-x8dBSjGNBalK>p(&+U|f(%7Vb{N;~P@V1k$kEZ9FRnWS}l3 zYso1fkUIbY^0H)dT%Z&7A7~RL&{od>?8#CFoHxcM-G5rLP2Gma_K7R=6f$9W^ z=qhztU=XdmG|}r3e3S*+X{}WM(OO^_;{6q?6GVaGDpDR|50Vi20HYCu>TRtPhpi3Zh?Y0(|4pTUi(k7#dhh$;k|iZMe`53g){%s6c4 z_&UoHX8Uf=#V|YtW$W8C9el`r6nqGb1RttR1RrXwfOXhn2AQs7U>&|X9oFI1Ct$i3 zJO!>j>U0+^K2bq>(#r`lVDa+r8CAV+P0+f7s2}-^^5+&m} zo$fod2qoVfgY$^SNUX%R?WD+jF|^RVMtgs8WJ*#v4pOFAE883P;W#_$#8Tizb zRi`Jl5YLZ+zJraO2wM8l0fZf|PT*#$N&=dCh&3nLwnRI$>c5MJ5ugQD0r_(_fsh{}j=h{)te8kI5b58cg<+FP3sgbtUEEEv z>Y}OvFR5Axzr)=X=yCmO|IydqVWTU7$OC(^Gg6UvrmVUX&Dd)HVusWw*vhCuc!BfS zw7Z|9$UrJaZ3~sxHf)k~R5+WlZP1%Trv~0cc|%qDBJ!D_(k3>}W^&rk`5GG_kE--G zY%3J1^uxe^gPu&I%1@*gP*gx3(c%MUbjOCK~rOSZc7&I2A-#Sn< zye{eXNsNiepMJ23mpIK%Sz(jp8csfmqR$?hoVw$tA_HT)EFx~sQ~12`f=s5yJ&aEp zv>c3kWF;vj?3BmNYf4{07E3)7_vk!)DHU}j5912z(if1$vOnVHBb}@nlO^Ng=3b`y z6{3(MQxN?|qu6+1)$I!7JBnh+O1s@s6F-Jfc;I0XijeqXjHWL4a@26S#mxV0Azt>lLD*lswPd$SFA_`lH3NPuPY4J&C ztK;;gOm>SeixbcyrHOo;q8KzL-xECCMz!$m}P(CVh^4YYgZvlMP-avRxVIF%TWku#a<0 z5l)ZAcag7~d_}0|Gwja2YNKjK&mQt&v)hDVWZDR&Gwr-oHZQi6Z(5Y6=yqv@1#_!j zrjyO9vLy+vnh`=9C!2mwHb}`=bXlP#&MvnFuF<0J*H)`t$(IR^`8F*Rc)*w!6|8Ew#>p4W)rFNdI14Vz%_T@FS` z(>0+lIB0x_iuX^W$afitcSpx}r!jIU(ZB@FIDs68FjaWz8O`b$T|teQ?( za~!Od4i?meW>i8Sj$BVzTO6#tH9~n%1@#>B0bzYo!*0@7HLT-3()5=?pD+#xMwd=9 zIi8Zu(Knoj@Mv`+=8=G5pa-%KHbSL@2;L)9tJU9FmSmo=;Dl+zu!({l-- zDv0&mq9EcFh>pOul*a z5Mdp0u+BSJicN1eLeMb?lyR$_OfI}h1b6N>Ju8^N>Zk~`sjxf+wM)yg8{Hr)_+*`C z`~~?~)|#+#9jvigA@UI3Kx@c$Qt4%?>H0sFbK}gtU^H+)HAv zC)u2nhgkB|L-o7K z=AwXgC2Bj9U~M}unyZb94dt89s}NSEgVnrts2FU7u$<{gSb4Q=F&K4EUR|V^C!Cu? zSTmixo^-HqRNg|})?dEGB z;qq-FFzVO@W$J_w0K}*Q!CoL;uTIhJYB>ZQ90E$!SL+6xyf=-=aBv?PwI>|8M zC)2)J!siT=dn)b6CY)lJ!!yjP=%dqYNG6?;!hG`udoYuBfBOMC!!Rcw(#&-jJzp|R zz{fQ6N6a~A87A7(n)xZl<5%p*Oxo|g)By6$FsEMB%ySqyU$dkdw9~x=?}`~_&KsIp z2ebD#43lF%GZ$b^{FY%7EMVqym@CdROm>CL>;!@Mj$u+;#Y`_M{XM%_gZ6v7BhL%$ zY7N@&ohJE}@B_mthR){tLsrQ_RdwsP(T5^UFnM?!suk%zmv&Umur416*MUj(UTckjsSM z*biASdrciy$nOl=wt$p{F$tReOV*I6RWT z_;~^AF>+G*9}Vdw$S>eTWuDTAPJ;Z3x}@<|jp!suN4%@Tah2$p%iNA0tIE-^(=M|Z zyspNVN~qXn4u&MB^JgS<(PjFeHLCOXBy`1P#6$` zfI_RV>-6N-{kD3K%dyonrJNPNM50Rqmte5fU{!M{JT)pnx49bIWLn@RG-7Smo-iKB zu`{0FWV}1Vo~>{>LkoNl2H($S6Tv)(U`+^t7Dz*HHfGNe+I9!+yPW_1Nlh8Rf#cwC zdv=9#`Xk4lnIM<{^UP#z+Qh(W?#412fWCGE#|Q%b7OHCl$Wu?k2-LvH?W5A4V40h)>F8Ys;}KOYv{IJ95lu(mQ7?i4ecT@ij;+bn8@$hU^!xCkgjy2lxGk|Gv@lWmKq0O+gPWWmwY( z9)@OF$zb*eo&>X2tMqN?inS^|51Q~<#v9Ss4ZNV6Cm5gi8q$GAm|Hfnbi&PQWHSq+ zHxWb@+A65Gtt$KaDE0-`pGbx_vRm?~ll?Y(ZDSGt1~%=W`UHj`qc>DWQ^CqzY#U{? z!>Q+cjY8I{feEmG_Oee2?UYmA&-YYuFmy{1p#^d=YO^?rR174xHpfyd@H9%Sr=I6y z{=H8H? zF2?-Wmaif5b&c(Y>;O6P(E@!Ty6p)g@HpC&tJ1e&M|9#Ri1JKhyO%E8l-5uljiz?t zw+M|jvC*QNI0Yaic0wLcY(l4lo7h#zwlUNKB~S={^x#bit+j*Jw@GMuBcQA=hj?mZSiGM?s;6=EpR{<#Kz~i==q73L zK8nm|@VSl2;++6VnaLM7CX4ql%9_Q|BhupSj%j8#-`kih-bc{+`TS60vUr;Vn#0ip z(&AkPM$F}4w6u5|!+v_0gQ?Qu9S>$a!ofRf@m|HuIggKQ0*hA*L|`}%<}Ws-y%YH` za33bG1xiH!!AM)EMD!fmS7?be8njeBKMMg{$uCn5*I~mlTuJpb3zf+P=!DgT7J%E> zgr|8*Gg|*Qv&H0okbu@2Q2ijT>v=0e>(I>3d3dw`(778hm^SlCggd>NqY3RSwZKOh z6kGU{gz>b4@#;N=;!|hBHbM(50smj3Oal!dAFuGwWjZ!Trl%&n&EeQWiPZjJktzxn zsdp@qI)XO8%U?tL%{&+v2l)P`5UE-yg zpYXSvL8P=mFVyi>{#J7e7Jyc-!wh>|b^1p1;0e{~-yoaQ>Um2H&ok!rFB5KH0V;5n?;yH2TR0OV=prcR-LR3b^W%hZ+QIn6#;`Ii zjgfPM&;swnu)Rf@22P>}{!!2U7*U!|>FXGk4LYB>A8f~ zwWU2;Mz#zs-3yTx`V>N&>EyQ5K~tJ_F@|o0{tTgQa?o}=XiBpdW3-giss0C$bF}^` zk(_c!esf6f?j;5`fd_v5AHt=%hb~+PTG_a&(+hwWrD5!BeXyo)LXj#CXwuQNIrE) z>X9jwfsvc3e?@5LTiKm)WRQOKx{UXd`Wwziworgcbj zg0g%EEW2OzNHTOm1C>6D=S}pnlCaE|xL?Z>a&@@bQJSfv9;BH%=|P&Qv#vDLlbDjb z=ta$;nV!Uy)>S_Ymp$fj2xy*ux;ZpcIMh@({k!JSOeW^H?)sJH&`iCc7<%Y`Hz&<> z1UdB7G0dfAYK|W4rDHTp&D0g|dg~apQZwbC6@7FJP^p<#VUYFJG3=yf+KHn3>6=>6 zWOqM(C($wBlhTfnE4toN9gahR2SP&!YCcme~6ho zph!mRkndy6d29hQw1tEXln(=2VI?fmp-N-7$aKGi*L65yQj+pUu%x^hEGauJN$CX*yG!rU4wBLa zZQZR8X$MION5{UUuZ6!A^B3s5J^BH-cQQZ4OtDx0sU0LG6IyYf9?_m8r6=vr>w)$p zDd}j-e!XdXl9XG>qevguUY&+ZM_U%_i1!rkUfdR&nkcbQ$AT-Ssst$ZM7Nme;B8@J`_PH?Dkg-_^p^?k4F~OL``|B&7B8MdmZ$VD3HKWZ_tt+^ zfo$;9W*-G@Y3CGYl_A9dA%46 zB%19IP|8|ZgDx-@THptL2~j-h6tTso&;qBR+kVu^oLL6!OZtAoe$T=Fx*sR8v*@PN77fH@H&&yCkQU_d3&Hm5P8 zJqA<(F~wiaO>S=soZBiiy78kS}VxC}GBFixu&v7O*zEFfsl)Tr8#jv>js z181OKy+#f_Y1+|dKMGXaIY;bIG;*1TuJRcp2zQ)=yTHMvlO_t+1#$EnD+zb4gIm-w z#0|(}k)b;uzhmqr8i$GMxI^_r2$dFS2*xKFR|)N=gN7CpnzS1*_>&1Ea2uUgR;9;c zBF!*J@~&V`s9}&Hy%e2S+i2E_&Oe~<$Z1BuPNB-FBFO6+qX=!hgZ5ab&@o=0wi=9O zgtpp2d#%%djN2<13k{9^g!^76yDcYy3nDG>Jq+e1#y5oVLnnJ=|7~Mf8U285f)<9m zGeXhHbZ)`}23-58!O_JC8XR4Xpuv%6sKGG|0@>Xt+X(`d0{-hk$-oh{F8cS>poyh5`I_*UR?dGF=uL#j6WN$($DI`k>goKWi5Kvm^0#c-f-U*>f4OMy*1;qklK_67?sHhPIX)1yu zJXo+G3KmdN5QXn~pP9Sa`0@GY_ur4#i|m{`=bSm`Ogne(nVEFHJO3P&AXHb2M_g-0I&Z#o$3J=p0h#Ks zym- zYBSI<{yJ#tFt?`hk4+$;uIzAH{Miiz<;zX7TKp5pD-gr_@u1amB|#0u$NhNF!iLri zxs8+jMFdS{G_p6o%!as4h1_c$|JM|PZj$SATKs1atA%}lLfKsewPgLtd#pE&phAYo zdt5b_pw=uVd5;Ii64XY_@5kO_E0lh-eJlbt4rR2nk45-t20t9;Z;#$dLDWllM3VP!HCRyvN5;-mP+*s)$GUc1CZx13+$f%(#u?(aC$n zw%Ck5ye*cz$NR<;)K_k&)p^rO#_e*OvCan|W(<@(_4orz2pS@J>Y7n|9x89kZD?YH zdm)Ge4{GhC2XSsncF!mk*wmkl;{-A$vqoAx&Kby%`<~oVuBoa4VG~BibZ&DAeA-{e z3^A`S+RS1IJd@FK;nMA|j^H@oo zCnA=isUghY<=#f+8S_Be1xL)d=VF&hMz_s4mJLDe8S1cE1hr@MP-m2(6>yxqTQfGI z5qI6r%y1x1tdUWIua1G4cOp*i*kXhrzOfV`h}+j8;@RYg=d^i8xW%wWd!(N54S`09bA%By3wsn2+G1!OEv_<;)BG3386V>o zvDAk4QN-!})%+2u@rkG9HTLwt0hCYEXkX)XCr(N+Z_x7^Z^)ein`r2-@g`8BC4&;1 z!6eOn#H7brUp)v0%ZNeN*OI};2ugp0&z-ut4`1WX?!6toU<1jL^LWXGXhdFv5=c05{$ zw+WKf&@wb*7B!9R1kf5mBF;{HZ~&SosI&4Nc-r7?N(ZV5R9X^_8V{72h~~;Vi$iCF zt)mB0b`#Dnj6^n$;Wh#ja71Ka6Sigt-o@3XfxCI|2^{foXm*;5L$e>mk3oYtzJqp8 z9*E|L`&ELsHpHoiI1(_}^A^6y!uXiR#bA$C19{WLKpbrjqCVY0v#TlxCd}`3a@&`dt zmy*jOf(rwKZHh&b;sVN8EGf*-p~?~fSDa>V$hZ{1I+vLZ;7$NL+-6_UF9T3vn#WP( zasVeiW_y@z1%QiQ&3GQrn(9=f|2YqrzwT9(-x4J2rS?xEy+LXJ3>e>~v`>dH8>RN< zP-<1dyOo%%4&^{wBytlOJKC3S?}JGMk~g-U6`OZ>B<#y#S8V`^q)o?f(vp|HQr1 zuHXTGiOu+67~?~dG0p9ue?N(k{3lJOINCZy@nIOnF`MEXpc9=z@hvU{@&r$=4pE#6 zqxi29o^?MB-AVXfu-vD>Di3HzbKsrX3|`GBS#AcuIuhdbbr`R2!g-yQyfmXL>h$|h zK;Fe*@(bRfHu(=> ze^riwe(g$}oEh8#-!~W|E+Bu~TI9c7hW!1LF%g_xiCHVS5_5boQQ)fkz>c}Vy1X1% zMN^o|G+a#)Oc&dc{|i3J24=XB-wn521afeTZ=f!a0@ZOJNnpN!yYL{+SPo3|VVd#c zr29aG8(SK8d$FZ)t^qgV7hIekh{ySQfk+3oG~%L^=)j%0L?O`C#AzH8+&GQn1Kc4W zNW~Gl0o*_nuLZj-f?UnTLCCdx9^`UPX4hpp_2w-keWBCwYu%^3@G0y=Nv+l?;$W& zy zw0K;75*#J4K;qUC=26264i`;EKv}4muoX5RCpv=5Ltb#1ASQ#$Bj`#K*)CfA1PDEe z>4?j{P;rty1MVs>Pp0@frIgDb@*79f-UCcFrr>0a>!ihcn{M+CQs z4^cEO!3o~4nshN4EBJu;dL-M|4KDYI&zQ>t{1?(D^oJPR#AWd6N9m&Ac9A>ER^t(+ z#_F*IJSISw6F-i|h~N%+jHZ_0hf)uV#-sSG^N}#t98}yZV!$Yze}oHa0xh`Wa@Ju$ ziPLakLhwzoew4ZpB3Qvk25a%1QRZ8s#V8zof$Kejd)YufE#Z;zl+{9ifQ#8aDzx=y zl)Vz#DiAuk_+=Uyg01v}lo$6BRv3b<^-H7d*3d?Ud=#SH-l9Vavd<5b5a_4>&HTaD z7*ZG4V@Hjq?7`SPSu^!!N?Rpb&FXAmYp7N;jaT!mVOq^}KI_ODuGP%AN8T?{hk9Mj z_^zY*gZgMR{3V2&(^W4gAkZ742Hsx)yCh<`4h)`x20eEY8npWroB$(6JxZu1-z7Dg zFM+lAuC+1m%ZmdJuEdRx;#n@@<k9y44MiE?o{xrBybk;KpC5G;}n z48b^9bSpiKg21)b(OZSsD_8^Z8$HhD3)lDZcct2VO}1=5b;b;zsfl+4UfA+($s(M6 z0*-%PJWhSsFE>)uO{I1z_DF8csln%uf#7>M$#t*?bx=??VhSY@3R-WBCf)#T{b{Jj zH$h1PwkCooRB{6o%Talz5KHJ$ZJZ2B5X_v5*APnMeJBs_Ln7b2i_DmZjk}`2`AGW&>d}s-yaehHyNNFU)>u5jgZxz~ zNa9rC{Cq!>{I#gocklqN%9H=aCm~U;nk-7)TXC-0NvTik@pcuTL=_kC4b&&uw3pHR z`DD+0+@v8+VSh7f`*dY(e+njz>hle@U!d^%e1R<|HLdYy(@+tzZQ7THJsrA#>{}|k z33s2<+5Q8M`WVD7V?8)V?Pw22a_Hz7WmdrsokYUdBCj zy;}Ygq3{EG-i^o$PgCMvB+jAxyd#CY8AllP(OJk{isZwPkZmTAP%LC09YTuUt$6t9 zqe~H6v50+jh$wm#eT3%FUq`-ctnwU);5$^ z9OBfWlG801a;J;#3aftzyRC>q>#Hl39-^M_4CTKv(N?-HD?N$SYJ!_BL_W{mj}qLb zY#8-S*82251mBC-(8Sw##4g3>)v)p$I1r?XJg&4tJ^w0{?;*-2UDq-SX44yB*j5xk z-CFYgjElC)@7hFVM0C^eF=aqO-)Xs@nD8u-%kUI}Z|18J>v+IHpW$xrXsl@qC-Ggu zyLze%$$7B_4|%aAPKyHL#x>D~+R6snU6pw%RCchG%H~nEt&UOk2`WqWn|9nNzaY2` zck2#3=j-p1n}&I!mtt`Sx2zZI9h0g57vnO@GQw!#q=d&&beojyp-#~>>J$d);SS0z z%%{YWcV+(x;%(|F*~!l+o?{N!;_VBG_mqHmwGP?^-1fMDzUDH#2Y@@7SAWGchD9uQd;kz zEuLRm?~oF2s$#Jf;>Cnp?@&m*^ggzDM?=;-WLxhLXLS}sW)g$*LOUq=jXr3Lwv|Nd z!jr*yNK)&trgf#>et|d89OhQ}62{lTE_S&~72%~2gH)=RCOoqY=9%Tm!*;72;({)} z9+uG#2?6SWrv%Br9 zJi|>nV$1Rx%W}^V^cX0&hiAGkkpCq*+3PG@&U>m`zsc8@Ony&_TEWmBg1YgP_Ld7% z+ONpv5ofOprbvFDRB5eb>2@ewmBV4G99F7yUrtV^_&7owRjBh0+iDD>oSTMCor!FW z_dSU7O%tY!0t_*yzK@t79MmN~iNLYoo9F>|ZBSCz{;02P0-ZD(OS-W^{u=>58lSeVh9(Y7kBEHbW>-sq+VR&6IM@ybpNh1e)?DbN(fQi||G#rnux-me6J- z&0L+yh5~i2Gdy?@5_hw~DE(+g7Dp z2RM%-mGA`txZJMd?ey$jV$gB(*pT|5WA$UTD5%y}WZ^i&uCkLvE43Ge)K8dZH_Wcw zFdfGT#yhg;=0f;M=VP+v_25o2=@@Q^hFQf`u}(3m2r+9%%({%3NX_;t77QK(c5AT~ zb6=DYHeQzxZ2X6(*|v`2H{H)vVSd@Gj+5SSIKNheL!fuOXwhmMn;pFWSi_fBi|&f& z{UP2seDWsl6ltt_ljAJRHMki0LTput--ZZcr`wju=NIXT$E7g!_*MFm<2>R#jpJ=v zyP4xfMOx#S&EmD`cCT;EllAH2Hp@0{ux#>?t?$il=vz*3H*VQ&c``rvk*a+#qS`OF zYajk}#8EZk!V2x(#nb7T^)ZdQV<|BZi9wWj>|^d%sG`>5`w4vgtte0u{u+|hKf{*n zc2-tDVfV2CtXtC)Qu#rw{KOLo>Ju+c#l6S`QE!6C4 zDb!;jlBpq*e2{z(l3ELJP~5x-?hfMYOxz?>&QB1fQHMvC`4Py>b3mN(2t-)qafe+H zf$=C0J4D4ondV7iQ3NK5-e^~sG1;Ps+jz`55+Mf-Jmx_oUW-DRwJxBUM@F!RBDT|O zWiG;y=n0pGbyDG%C9FV8jh5-3hrt(+X?{J5jezEP_rul!nZ|;vup;;xON6P2c;+cJ zs}_L*S<>h6E(V}g$)PDdn|=}wk`bt z10~gF?`EKZl4|o3!ysN_sDs&d2w&}%*93!vOv_b+68U`oYI;7@s8n#6e9rGj!wtM2 z<=sE7GL7$*VuS$^^7@VCG(KMD%~@HQJ_J8vq=E07d0(R3QIh8wq(>VtR9*qf9mAhe z^SUptO!ErMSOY68d2x6tA17twg@y43K5()zqfh~`N+an7Of)LJ0GV!-*JdOG81wV6 zKcCXl#@J~xKn*FihHvCdLVqS2M-fgiaqKXFQp`(Q-l{zWzJOV8j&#Al~uNqvse z*#F`j+nM`00>c>zM({muO<2b+?~+>1WvhhtW*4Gp8Jyu827P6DJNp_azwF@ zy7c!%-zhzwxFrzO_j5{QQQ{gB1(bO33re)0MC&t@=s<~{Us9si9rzkXi6NAD35oHP zX!8pzEW4h<3RXxCzX;j?|@JRwvy{f#?Mq<1xX+#MAW3|ruZRxe)?;6ZL1OE zO?Mzzkr{zOnmf(oxvV!*eQ zaL&@SjYz~$;s_F{l$dmm619-^9VKv%>|ftgqBSMvpQl6@O8kTbPTp&Nff6Gq@hTFN zXQ7i&VlE{HBe9$k`j3>jn-Z6i*hY!Fexk%vl(_yg+2R#SIM$z;+kf9I7^S;y6f8p? z{X}_XiKOIRANUaoT6l*3B>jR0 zNRJDDBd0iOi`VriX=T@H!@lmcYsk5p#oCJDm=oJc>CY(q^C9WC6H!x^z8y<1dP`Z`v#c{NW7uyq3-gfl$Axd9y{tUP zUAe40mtF5%oKY?2@nH?QIH*y~=X4z&h8M6qp2rUGLUzS@ngBzABBWc?R=kH7)opUE z?xGSj@4PK=(jwd3+qnFvF56D_!z{z^m+e>0?Ob-^@0bR#Z1$)dv_pTl-|HW9rxX0m z@5+3Q7qR(@?3d|v$ygVH63@92(C%1YF}R3@f1ZUG13JKXW#6f>8IAmHcgIuotoS|p zlk^8A-l9ZzBwnP%R7!M;PNCj%mY^pIDnx+YuaxMIQ#Vb=5WDW!BWR%Wr6EGi)DVy- z%v3EZxCoYN49CAvR&9Z@P?M0Q<}9+Swop}VQ*M^6xN1c&a-IJi&o3K*ixgdt5dAZY zLN6PriWXPc+x~kTzifbHh(etlBKayr(iS9Tk|cf+zifb{T%oQHk;E+yy=?Hk0g|Nu z9DdmV$ySB>Y>1>oh@=IdIVnjFO0Nkd6$;v-x;WH*aVCKC8hiR8g^Ov?~`9sxhOW=!sY;wN=D*@)pZ%e_K-)5!|DNF57V9n$w zFqWvf37Mrc-ok`4F6C$$lB1QBW2~LZ8;tJ^MJ5(C^G?G%Zq4Z+ykJALF^`i3f!I0t zyc*4)S5MEwXXm_F^uBiH^Gj^cyS-Uqd&v+^Kvd}zK4vzO4tyt*9d&lRJDbbp0QLq+ zT&phH=oiX1i zUuN;I^z2hGDW?a8HwYSZjhL8Az~th*{&7nbw+tj^TonECDA7SF*T2ycc3jnRd54Y! z?)pIujwsUz8X|iDs1O*oP9GimFq=cT(yedQ`Zc5{Z9PVhbg@ zBk?#Ta;{SXP471(zM#bJ8|2Vkr9}S=EJB4+v(r|v(@FJan$QZPC~*%ZI<%wN;((Gm zI*lZ|(<~k`7OtYuI`$e1Inv<9Vtri*a#qJe-S0$bXy)M<^~S?-mV6^_E9PJ(`#?@y z<*JHT{~lT^qq=XB(U(yW_mNMmp?OmW!YtySEd3jbLtHUoYqOm0sm_C(7LVn-uJJEP5VL(w4#+zqxl32`_x! zVhF7m3!nEOF1gdzG<#w7B$xRrJ(W}Bsn8UutbdqQ18jBRJ##c$y->{u2--MeOkL+Hs2^OfhF#{F>x1j&c*&=Im~0Q%|q8pN)V>d zY${_OwK2PaM>fXY!Zn;z5zeC|2}Zbi2j^@Jr(y1|uL|u$D0u}R5IP=X%yJv^DI4?L zs?bN)lJ7AOmi#44Q?FZ5pP;nv{FwvMUo=3!I<#_t39eS;9<3w=t!r`f)j&$0qsVcC zT*-KR8C}wwb81(~aiHTboy0kftK?*2RrAi}oYT5WP9n-#ww-f2+d24tRHA{~^4B@1 ze|Qeddd!y9N25JQ_3m|{{YOO`&_O0U{==wRi9%gMV9_&p)tu+pFSCaIv%u5qLY=ng zX=uFEafwmS3|FX!!6h9|?P`Z_J3&nkrmTO4gTOB?ggviqzL zb;6=Y!Q~Oh1V%kGR-v{hu&4#v=1Y!coK-$PynylO`Ilz39O zNtWWv&~e8pnKd~~tfHGB@u!a8I4gZhIKv`z(r+C84J^jg@T@QK!uW$Dm$S}H3(rF6 zjQGvbma~dxgqQUgmXH5-4B@QwJHl0N4u*bXHfL4L3S;O)u;sc9p@F*SYYhH1jK>&N z>!nc32^=~ZWB6ruKWMf>Jk`MsmAzyKI_V#-S7h<8$$`A6CEBO%MwE}~C{<7Y_Z&DZ zybRN^LlI~*;Syrno=)^}ngJ)>T{$^N{V9LHt4GtG+j)Bg;kQCiyK=8X-4&4bRwOllFf_7WYpi?Yz9~ zgymLkrblSLM?laFIpkH&h{WYjq6Ns`qTI;0klPX)M%Q|U7Il;y)5ueJ*5(1ci_tT` zmQEfkkw+%OK`Cwr7tn`I4-Z|Hh#)>*Di5ZMSt@lEm0<>-t3!^9JKz4+?v`t?Rdey1m`j zbs5hSG#Ac=aPzqkE}RSD=5rxjI2Xdr=R&x!mDN>(1qK(kvbt7-P;O;)t##;XE30eW z7xGk#XxG6!dKihVtgb_xM2_o7OC+(C)%9K%Y|ivRc06RO_%#oT=wibz&4Y3V+OWNq z)%7k6z*|{eA2@iErw76>tt5ySGPa0!$d%7Nl{Ug`%iGjRrQ;V*J z%i1y-Frtf*Q-c9_^o!I4%q#|c(Kk~WX12ZsB++kDLotIoYBV8wX$}E3bu5>sM_;0L zZRT(>IV8ts9X^7`DkL}(8*4prXh)IQSnG+;LzlzGT2D2!0nLStwVnhE*2KnIPhu}L zR5z$yYpExRxDgJe?lecpF0OK9#g{WKHp{rKpqEx#4_s8{Hb=-buDZZY*vYs{>2Hi! zO?_VPDn@fe^ErAHi-=|&djz!D?;0Wr6T~8-S?{`#JH7a+gn)XAD8;ae>M;?*p!ItE zl!@vwQG`2_o&+r1xhRrkOsyIf`hhq5hS=!VI^xh&+ z#rpao=|jg%rI!`)2A}hDQWg5hHTlc9BSimj+>zpW?#@wAKSSUbeksyL3^T1sa{_}G~~X69nsPz5-N=$y@!zA4@E$idYWjh^zNQEwSFa3q$LbdMeh6C)|{~GE6s}- z+lIPBZA`-AqCEaYkvw#i;$x@BmCWDX1VjR1uaIahs?>-*@;c%?oeHhd+L1&2PA=48w`s#+HsdK}YslVHn z=?N)QCN3ruPw?_Du}g3(RNsy8;+_Kktbi>ZgY5%oh#BJSJ-qz~<7|N<`aD$Lt5jYl zmp2dPjRlKI(-52l{QU$5FQID6F%(?~xCQJMV7zK<3Gh$GgIidiGm7s-<*kVO8_`r< zlSiLhFwx8>5?S0WDDFjoLzo`q*9lDIoj&|&N8FYZhX|#1m<=53x6V)Gb)NQ^B=i|g zspx8GW|L)ORz=PV6+MNDj_0B$qiE4v+I2G9wU<^)v_!$f%y2O?hi4ywn+1 zV_&&Zor-s^L6W^?1KzRog+crUZ#_>X?9Lf*k|QRfgI0CP$n@@;HejhEr1L(^y~?+^-?2Mg9PJ_CS4in^KE^2D7WPz_7B%}=`nYckMD>va1&raFSU}9~zO(n2S`pCuU^>@|R+s&ByA1LpqSrhNrkQxZmFZe4FHeZ~qMN zoq;=)wOG-j8$ByzGdRRT!VL@_JcXX{Uem#YCsGmyvmP*jw})S$V|h27BUe#9MN}4c z(>ZdHZ(%o`BR5Z>zKfgKYKYB@`V~+&q~HniEfi?fK>b)X(vaNF`)%7`Wa-50g$M2z zf28Y#r1cxVb#~5^CdEh_|Ij9mHfHQDA?*B0>;hy}!G1lZDlFt#o)Ds(L zwT}s`frj>oA}q+j&WJ4dzaB^Td1?bo_E>_mgM%Hi^4`Pv1*OC4)OuS+$}GbE#rA1k#M$OPx74gC6%H2DP`+ zvpP)(T0u~59ZFoKL@hK(o9qn88ZHFc-Sjv=k>=m6kiB*^y-C$+Lo_q!SsvPdg`#=i zwpg>=6ZH5h<>wxzM4Kccu5ie;o{TFBYnalpF4iW*s2VQ07Ltc<(%qSTn|+ zbE{0WZk{=ve$f!G)R;M)(Sn!JOw624HFKJnIh|_eG%<5J)y!#P=5(r=)5Of_R5PcE znbWCeP7^byQ_Y9l7~lRam9<}@*LI_;U$#LVf;6ytg3G%<5JvqTxs zoF-;YXOLyTsF|2Kow*GCrkR*IoppH5yP}zxIh_Tf9nYL5W=>~4I72jZnwUAA^~Fq{ zIZe!*&c7zV@)%siJ8;cL7nDkV&-&qRHr$bm^q!r4DApmW=>}(hIR=P zGpDmNchB9z#LVgJ%5qi+6Eml?yI3P3^;QNSJ%E@kt0NaQsSyflpNoQ)<)fg@^-xd?T)}At zGx#WkdMGHj4hp)IgMxmd=RWJtEG*C*qNzN}Iz{#Fw{YWhv~`01##jwV)L5%SLo8q1 zLIPXX4x){-0>mfYT3DCnMC%iJl3;Bo{6y;vDVStEL#9Z!UdGj*RvX-DZjB|(>Xt#H zL7KIM%1yT>QMnmb1Nxh3MN=s?pkNseld)bZfP(uG(qy&9xM1z62LgK`8iCJt#P`01CFjMch_ICKUW20}9Tn2L+eZ zgo1&3Q1F)eP;f>86uc)F3jU2ZSIeIb1+V8o!CJVW*y@o91#iiLf&=rRpk4zCZmJ0d zPh~>E=b)fflXA1HMWj)-^**(VptXuP)U-O`m|W{#dS1(FLTw<|!UcY{twxw%tar$O zdDbwJp{{kLAr3#7MYIK0bCRT<6{P3&t-t7b18Y7#X=t4xo{g-lwefn_kDfQNvPp}k z)(CoXljSAdn_09g@T%0y*-ARo1Y1VKmaldAbBlX_Ztmhi@5uO$T+EAVAz z?jlP2aNenB9ye>>YxH93nLiTmV!kF=`zv2h>1f|V;^JA@I}P_&U}4|0_$xn7L@g_s zp?Q`do#PuwBdTX9`euO-j*sU~q#OFC&876RrhFudet15~kg|rm@eOKUdLw*&$;6t8 zx8VkyLDU%UgYj_ryiFmW=EHXeZ?gw^jG0YxdYdC1?ZXkS-WDsPaY_xmFmFqw)8nyZ z<1Iuw$M-qCZhKovp~h47dy818_+gXAYu?sKH}%aV0ln>;@IdQs{krJgiZQg<&_A(Dm2HVa;{{7C-hN zQcU;mwrKQ^pHebY^S**mYt4saa=ovj4&1(P$bI&{_G3I$e4d6>@1CK2Z%D~1oXm)H zij?IIR#yu7rc{^3s*vhxlPUd{tOJ});e8jDZR)$an$ib`N_C&SlYoOm`PgFLD0B+P}r>7e--Im?7^1)0J734m3?*PWW5_vBEX(0oULb_&2o;rkPYI6agnH{aK5 zum=Oc{la&44gsGXNWetr>ogz7RHi25_6XnI)M&kDn1L=E%U77UH|suZarT~tnYQY_ z{%Z;N7HB(k-whb*9Dtp=Z_Zc(z8jy6Bkz2ppwD@DExUE!df5L0fC}9=nL3L12hbeQ zeXoP&M*v53UjlM|8p=l%`=&zbpSjKGzRQs9;;(+R0pAGN;1YoEbl)UY;cxHixHr_- z2{yP423K_7VzB-lz+bwr`UC?009v`jcO0y*vPB)fooFY2qJGyod`D2uHMX0>=PD!M zZ?>Dmw-yGu4q&Up*9BF71HdB=volz0(pzwt_pQh0J)VVkIn0;A!okoB4)b%^(O}Ho z4zn?sIHm94FoWoA5e&WKFmZ;n*Cl$#@xg{&mJs9?uT z+Am>g-Hp~;Kw`_*?80OCt2?`2yrV7K1M2oMoB~jT!T#Q`1+>z(=GsABL;x)PD3~3-Rr!04qB~DVgpq6lFdf42c%f zN-V>8Wp;$&ix_a5$53`_u?AZq%ye>1y=@ps(DZiLtx{_)bI+!~3C;L?6z>teIEr$x z-O2l&Uco%itiu?iH>?hxu{_4;2rrE`dAvBPcdia!KY;rAP~VsgU;h${KBiwyhOa*g zz;V4!3Vi*u=(->2!&2buuR@#sSf7-_zWy@Ugtefg2mdzO(3kp^RQBM%1edS$=<4jjV@maYt*2CH z5B_tsg>Uqn>g>VyMSnf3r>C$7KX)SrH{Ga?^VrQTGcda8Kce3Wb2MuIJG~2^$1Z#Q zd5#1;Bg|E3Q5W>S)o~uXiD)|S5Bh`Eahs2M5>@b{-Y@~T`Dl6(!glj}N1;hja+xpK zgGMqR`1xu|R{}BYzMS%COlcTMmpWMi`*<I!asp5R~FoM!-wTfD|uRZ{ptuX2P8mQUo zZ5lCr4NoQVZ1px7!`FyM7R`5=`lzol4=kFmJz@Zxev`-WC3qvpE_Iaf#~^2vP7 zcpMSF9@LY4%>gVXGi;=qH46s#`9{YmycU=p7x{7Vz-oBS%@O)y-Lec`^R|h2`POeG zOPF1U;(KH<q~9>&I}j9*wyV{3zDM>=yivPKaxYG@tLzdntW8 zN{aSHLWTjrr~Wno&c|&(vOsJ2FPwN1YbGkfdJsD}tu1IUyM!4}WOoki(I2=K1D%zOUY$M!w>2hkHbdEbyr!g^(2p93HSJE2zL*noUA|QLb#T&mUU)1gnMcw zguAdF!u7iw!mTcaaN96YS^hFaZs{Kos`=bK#7DnMBAV}BqNMlAMhqVZ<6}r@v?=pY z%@_{WL@gXf{kk>188uq-Kt>Ft`Zk&`sz63Oi7?aLE70<|qnK~=q$dx&H{TK5wD}Bo zb01Gg(I(oqxt~cAOf+uuT?W!kv~KeN134y(a*%-n6YbkP#6Z(TG;s5J z7;`q4O1k<{wR0FEU5lwe9n>b?afen!3`p z4eHLP50$#YWj7-kI-;4aOK}{mj+!9NaaxCIF+`ewP6LSp8Lt3lysk9IOMqET zmzpPz8BQ%HL6@4Fy&--gL**i|_pO~ZGl?;2HiEBcChOAuW{=HG)o;Y}Y{c!Tx~|rf z(vg?Om^2%4`^#Wxry$!J0q)5^FCZ1IM{u@^wX>YZy{YKQgO}m!gr0$D>feS~jC<`V z;C_TH7}oYlz{PnU4r}d9;3hS~Ym+8c5mHkBi8vNm?4z{1-$a<#E9%7Ab>t>c zdBx(3gK(^BG*T`9 zE(TP~-xxli-E9wOKSUsaN}T4mYuVT~sZOpXm6Rb8PP`lsReoWGphQwN7`H-T*hLi}TuaZ^#sWk~l|1Xv3FCJ74ej+9N`a65cMe;pb zj1#qa4cqq_*~8xzX~Xvcj;Qa(%h|p~;P2WlHF8)sO z2~fHxtDc#FB~Cbayu=xUHI@`DX~_gIbQCdWJI3h~!hx=u{xSKm(Wyfzo%|6FvCx}P zxzW|9FbRr=@vE2SyN$-OnBn~9rTGTX92YYJXeYJ!k_lSO=+O!6h;|{jKW5B|1dQZl z5J(p=d7JTmqEGU)4wDM=KBe+5CfWWJI#gbKM?6? z-+b^L)Rfz)iC472NT*XN;O}yeqQ8E0PQ3^#QA1~-kXDpT@DAUBLi*wDXGBx3BVL;u zDGR}(qIVSJh$h{=rC83fdX^%_iLx0uZ=7BGwdr2JoTnNKA%IO{Z_LDd7|Wu|?dX;1!3@o)mP zq|HD+A--Yc^Nfra_9*wLe!IEEHDn z(qMmM@ngS^rlW5p7+AcL2PLeO2bR2uMJOLmaSkl~9fkUukPQRN zp2QNAZw=K)U^&w1nm(Nj7g#tX4TXv{d;lQJcp6XU2Q$)af$<$h8N}9`Mq(P6Jgs2E zRKr_nv`DAn<~R;gu>PKg;RXlR7*^&i3~2pV;tji789ry}8~CHpx2xgNTNQYH)2)58 zvC?VXQ-%#3R&6p{d9?Km^~dsbYZFa%@v3TqiE9}x`O!Sx#I=l;TpP_YaV?{jBlc#&$HcXami(GtVB%Uv zt2P4-OlAe&#ja4n-{U(3iZ>6U#hqls%7t&Tj0(2EzYWweSJ+9ga} z%V>2GcV_c4Ag*P!>}wfKT+3+nVEqmV6W20Yx5_19VZv3i>}wf$Y0->Uf-7c5(b-sAY8Yp?{Caz_)Lf10txR%k%nVE@hfQGH(T1KnZ za)h7owTxD&$f-dM2%qk($*hrP;+vi&*BIPVuBoa4;f2SV&TTHi#1>|2hPXWoZ3fpe zS~D3f$HcXa)*TGgF>x)UHA{S&jW&a88Lc_uP&S$gSKC~>nc!MRYaT0!Z>G4G(aLR5 zgI}YlJRR3ET3v3bfuV2_cf)B|6odn5b(dZ~97wB&^zz|ATI`d$X(&S@?pn^wZmI$A z!YVmj0}|s}MvJdywD?*^i?3z0_*zDbuVu9OT1JbnWwiKOMoV7HsN-5jYy48;qvKje zYvPv>j<033N?{gWf3+r~B+Z9w8LcwN?DpYWMr#V&)Q4*st*NJR36T%iGFsCxi>Ldz z`O9k=eYlpwwH}Kz6S(t9l zgC$y%J+PvWR$OL`Yg{@Cjn1~Q0BJg|WwhQ+&c>2Iu4S|iVrY=19||k|@OfD}u4S|i zbjs#i+~}{4YZ3Ffhz|Drf=@n#(Kl6?(o%%Ry&1m$+b>h@L{d1F8U zPUDkXW$++PZk0h8Ynt3D!@-p4A{M7EmFPUU+d*P|BJ4Q6D?!|I+KN$7%+(~JW$>oJ zp*r3k+awdr2N(@wcqPG^)5^wcVmQO+2(HluTW&|{UuE;2gDgH)Ym|-;8Mj8Q$BaLD-KLk$~7Eb7T zUMe?4DK#dfTvx)+Vdb7@uXj98+e z_|J%Y2A6i0N9aHr)g2!*e2)9UB!aWr0RKDY_$cyuE6w)|pH5TKy(6Wos3P4vwsbzt z{{l;=qhY=&^i7Z?beT>9%wgEM5C_Te`h0-MVyJy0=-H{pq%J@5ryo z=}NkxwdBb^RiwkiD7g*YkCM~HqhO`JpC46H<$G-Dv|L*{FIQb!hAo{>hjhIG4@Q7@ zqz>F?Gi+)7I!}0+wzSbYq+Oe7OB=&Ae=<`^8<8vT5wNAD_sc}hmT?dmJR{Ve0@d6? zGIl1?oVF4LWl-zqBjR_7Q0sqjGhbc9N){=?hrBj}YPD@8moQ024O_{jTm^jq^Fbtc z3gGUqVJo?utE5qut>g+8U|yE3SDTeQqm<0eR3da&zghdiWE1Oo159`) z%4UJ+!cN(|-_c!Rha-X+S7o&3Po;EiaS?sIoQvG5IIi;9O1?-aby&%A=s1zs)nOeM zK*dJ@vWg3V_#=UNtl?rPI3Osrx~$+5?hrwx&ta)gj|HJhJ8esM*p@Cz^S@Rbm6!|q zZn6&6DY5!T+2U=fW7k19u7lG-yAHZ@9mLeM>!61K?p-zQI_SxDpy$|i(2MI}P>x*( zy}884bCk^6>c|u4mCU*KM9Rd0$nZKS;X3#w$F75+TnB}-|W}a>GpP^DoE!*T5q0uIQa3RGdkSFHaHSi1QmgU+t@Eg?oBiF8h%h0Z8ZOUcs zINav`+Df^3dGa(STe*>bnb_Gbrx;r!+_;`j8dy* zNWG7!u$&eWg?n1>9M-M{SD5G}tE;7eI=6v&x;PB%pz4Q;QI`)E!-w$?I>e%Lg0OX_cZ1X<|x)XV}`M1LS zZR^_R-v;xqscW16VSZbytIU6`uG|M;o4>A-Wr+H%%jSO?*7xTV3%33DDEmYJ_z=CoNULntdk?B^CJ|ip&G!+Tt=$kI7dE#pJyZv-?8K zj)gNj9?t9|Fnd8V`&QODN1Q7rM`CSe$pyC6Ir8y*zHRjuV3%HC+qDpOol{`jwH54o zlE8Xw*CH?%J=v<@NLHO{k1{--)E1LKHe5;(TXj!>xPN0vis2l#U5}(VglTF7yv08C zY@tR%sI3I%O`T9m&KtPBT~Af#Mp^KXP{D{Zua7+oaqG)?n?il;S%}-9fd84Jy@d;} zw8yeSyBT)gD|a)LDv4iAl)n?2Rc;$Jj1-7taD2GI@!V2IZi)!Gn<7GP zqll2(C?e!GiU_%X!o>aw$LiCd$NmY&8YDgL2pJ9^A;aOl;GcjaM-gkEMvplZ-eEXv zYB)iJBh(F!P&YV2-QWmygCo=pj!-u^Lfzm9b%P_+4USMZI6~dv2z7%a)D4bMH#kDw z;0SetBh(F!P&YV2-QWmygCo=pj!-u^Lfzm9b%P_+4USMZI6~dv2z7%a)D4bMH#kDw z;0SetBh(F!P&YV2-H;LLq+rV}L^H)MpmAtTfc8KG{-2z5h7s2egu-B1zg z<|(x0*yA{x;v~AZITO7k@D29TxKYDVyg$h07fY#|`>{XBrFPc(u|LSA_6PZ~Kggx_ z2l=r-$ffoN`LRF9rS=E;u|LSA_6PZ~Kggx_2l=r-$ffoN`LRF9W$zF2V}Fp#-XG-0 z{vemVKgf^$K`wiLkRSVlT$$nxCzcNV*dOG|67M*%bm*VOXKJXOwSMdma@jj;{n#Jm zsw2MQm<>Pn2e}Hw7LM8QV}FpVo_LS<2l=r-$W>n)a$to|{MaAl>L9N0vZ5dRgIpaM+A93mALJ@#Xov7)e~_yaL%W0@`-5Da#Z$aL$dCO& zE_-LKANzw`-NhLv?+?Oxa+>Rf7~UV`dKFs7Vt<@D7f%@)P><@COowZK) zYV6r^pLeJc4D#~`hNq}#etOY<8qiF+li^K9z;lOT&RmAA-5k|sa8#SYQEdiCwHX}M zW^h!S!BK4nN3|Io)n;&1o54|S21m6S9MxuURGYz3Z3aiR864GSa8#SYQEdiCwHY$1 z&6H7Xf)8K17aOpZaF2ft;W(9$oZ4Oew?xThy3`XN0RdQ>p4# z;b>Q6cUR$PS7dir;b>Q6cUR$PSNKbTUxlMVCel@fqX8maRXExe8II<3pTfpYI~)z= z`c*hun6A1WrmG4^^Q&;QFkPK`n643eShc$JFkRhxn69R-bXDPKc~Vyuj+V#aXnqxr zhMFMFRX7?T(p-h3ZIiXE!qJrGDjZE}9#G+EQggowN4vs9TR?@Q0h5L=6^@oChc6Y5 zHq*<)mkLKy!0xJ`ypKXdfeR#*+z?@YL-^GBc;f>)P_inr6s<0~zPDfSe+@u;aiTpSrSt`g1 zozYT3R%O^!>+a8gGgvvaMe}x=>^#Y9y$GJc@hzUz3QEVmNwb%y`YCLWj(wIMc+ycb z?%1w4Wh!GH?mgGcN8!w-9A=h_y)ZdB8{W82!HjQ}_NK<*Qu`9kTYWza7B^J$rXgj- z4b!~oNV(&NYu*g*7Mh7$rM>Yf?0J6(F2CK2#r1pJ)05aov0`{1q|;&>-G>)g7DIhaWuh6_4hTHjn%;9{FKBR64&h zE&0`x{F2IGjH6;U&SAlyWWJW@D43@Qv9?{lVrF$!0J8 zsm`yppMg$ew_wFs|7J)1W1QAz&3O@B+6X?F4>~H;ypT4 zMms{x;4-q=1tgjbE+QKxd;k_{BI-U~q~$tLluhGo4u|kLaP(9{fTex`1HOr4DH!B5 z6k6>unpg(fK>$!$%K_a@P@PkX-C6aU%GWckMiWfs+nG2C8Q#8^5A8r1MXKztLNZjx zF2{+K&)e0x7`{mo*rJhISEw7!)e*fYygKlZt0PHsgG-)heIGAyTvW{a#oL8UqU;QA z6vM&yrbbe=k!+SmY^c=`vMC#Ch@u-_&8Gh#MBfzjk2kVSeG@Eok-&6bnQDeMS+ged`ro_OYvAE2>~SK<-bR8{3>r#KXtKpqtp- zHsE#`@KAGQv6ZoMW!r96PB#V{Zd}OX#^ur6vnkyWOI4BU@v0+4Lo8KAZcxDg%+Wr= z2~`@-?oo?aFW)B@u_}~W4YSo^V2gh{lEZMj)Nve6xxf|Sz76kVw^tsnVV~OZZ^w10 zb2{Aa2scy61to{QytEB7ygFGy$6LA)`vUaETY9vpcNX1@TUq_LQ9oYnP!bJrNS52% z3C|mL%qx`k2GAyM`;I4o&fuy9`UIUI%h9It;%1-P|f zUmq#J4Jj9;M0*kJD{6P-EBEx~;1hhEiyX^;!P9SlVCUm?#dRFGDnGC@3;BVakL?Wm zz#jAHeZ02MdpK2v$0dc%9>Vz+Y~L1V`TKEzcYm_Mw3lX!OdL7-|{77F%#K4l~6 z%<`zhTas)G^>|3A7CMA_sL&Rwg^nikaiJ|#3qCg0+e!-6Qil+&2}-sUv+l{^LfouF zh?(G_rHGB-ctosID37Js<>M5P0GEFR#lK7VspL8w`5oss5fDdZz0XxpL{-LueE`ON z0CM9y3h-fouOjzDAfE)tedrj#tkztkJ@FtyXY=h+669C6B{^=`mWW_WOlWOeB7!Y( zkl^Yg0YSFdHnv?N*e)H~NV~Y$E|0XaD@($k5}ekZUfq-Mnjs?DHeGHO%2rVfAH7*t z*in?ZQ?()`-mWxT%sEb5%$?kd>fS$MT+^9fS45orH>nN2R=kM4b{yq zZXjP%o|NZVhG(^<$~>V8Jg=Gmi+TRY1-6{2Pj z2f{RdIz}b3xlK=pwAtK&Wb$1+oxuZnP#i%)*SMexCDxl+p>K0;yUSif$>|-0CWqE* zu;mzlY|CpfyZtBEFE@@JZlZ^^({WJRZMn7S=RJaR zaZK3sPLyaxiM>b^Q{oB^R@ahuEB5;`!|N(0Oqdu|S9QeJE&SylCaTD)>Wzr|16*Cb zxQlldS{|G8wzGU?jGNhHM+Ll&sN|>^5i6o`4obY{h-&6-?(G<$88S=rdJ8F^rf-$R z5m+)wbE=;b>7G#1N_(umZ8wUuv1=b3xiAolM$S|=jqYC@D9Lh@}#_@#Yt}LfoB}o02 zMRM9SiSZ%XsV9c=Sg&NGikc~kjZ!m}#0sHSj|^jzR#&w0NhxdkItJ3c4Sm2#cZP|c zfvsAZ&M?7hRHZ^a6?s6HRY|9lvzT31{2Nv<42!C_X2TF`fH`3x@u-z5>M?C!Z$CCe zu2ZYWh_#WR<`#}XZ)#jYG*i?KFFc(|^Bab#RnRa@qk5iDL#Xe?MV<|-DAJJ2q(mbm zQiywFlzOY^9bt>rB>Vxr2zx0>Z-WgLVY7xx>gFB|;%ZuphAe)|%92|7(1!lM_5izu zM%XRXW%miU>=UNlCp=aAgtuy+@Kx;ykySfFRArB;(gP}ac)gKcpBK2X;SDxmgmn$e zZvJuq-u~jl+g~-bzl0E?v$8%Do#8#=pBR!=vNO~bs9*fAhMQWo;a0EOB-5(0t|UvZ z6aaV`m1P0UY*+~r(;5w{AZLYv=qs|p1RGXiQByVIf0Ub3SNp#LslKAxptG{CcvN2j z!#XGiS$VSe)D0)09un4>2rP&b;1B$IPOk0x;Rtx%pt76EN@*D0uNsB-xW<*8tVz`& zpsBNpy>F`8`dx-9Qu0v|KsjW;G4Rx{Bh}Bpce>PY_{wqKuAKc zF%SaS281QsvSmq;WLvUHRau)AWJyR*UMS$ig0yL8rZ!}2JF%f@JDt`fZ6?#{K$13X zXKIpky8K#`beWm94oUZ^Y0|Xw`%Qo6-20aMB$*^L{mp#-|4)Ma*1Md0&i8!Jx%a&% zn)M3NtXHaLeWlT>UA4l{zNDVcS6Re9sSK?Hys%VWuE z5lhyTgORl&MBKDRC~}?X^=?KSx&^(%t;IUOUNlpF=(a6Fp&PJJd*zl(uDO&sCcO>1 zl2y+)pv6Wb5Y)^CL7P;A-pm1HixGovUu?!}@q(>virncL46quJc9+SyhkzTLs$YMaq2 zw;SPQNBIDv)`$spM#QK$+Wk(w484S1Mi|+x@u|fkpRyF&;2!Y+-uVAHqg2VdU|JQ$ zDp@Hi?9%d@y-YL(d>M#o#aw{C(gm=yDu7q1I$JHGrP|ny zbNR6vBcyNQxWBpBBDNSE!R_3_w~GAo4%HyHiMF-9Ja+F8-E(bupr|w2etj{m+o`g- zT`I}mt>1y_XAz0+9;5GV(2>MiY^pYu%`_TeuIX+07u|MCEgHXbAn3Ge(?-*zM$^=z zOwl42ixzo_YVAu@Yrj;C7%x-J@N#a3#U7?S;VVCI%gSlj^70V8!ss+gJxzI!bd}Nj zUu^{4Ym8%ZZMjnZbZA??W7OEBg>&^}k((K9Hc{f@MV zyMoJ%-2d|Bg6-%{c^&0_lgmQo*dtLTH)i$ji#*L!)su6*8lSoiD>#b2zf#p5t?U+N^THd+cVf1F(jP7f@(Yfs~da7DA zlCM);R=w&mbR;)MA-j#v$x_}=>@j-W2BX`smIEx?T<)+@^!4i1O`;!ZHhMxk_k=B~ z_ig14)KMNd+KhM7oPT^4>*E7KLX0$pqr=q1MHFEIunmvY6pOqK5Cs`6ifunYL9g5NuE2O6p19zgGo z*zvb;2c?06=pdGe4#MCLH2k~V2;x_iN0kZ@u__UNmzIw-ml@}JmK#aK3ZuoWRE2n@ zkuzK+qTtnY8T&OxG`rS_BiE@Tb-fW#R*67;!(6&?qfs|j8=-LxSBAAZ2`v+@7R|Z} zLb>Ig6Nw@^`u2zfAMb_6@m^#c@5Q4^-kaJQ+Bc7rivQ)SezY88t%{tss{{_6`sO6Ss8_M-fB zx5^KTmwg!d?@A-9ywb=*uM)ZI)havY*$a_j&XulSnAmiP}_};x3cmR<(NlTt-tSXC@d;l@a!;%NyuMqfe+Yn!u*FrKAE5ii1B- z9sK#KN-oefSfB7!kWke0MO>8^tEzX2s(MS*LBG_f+?N@Z`*K~muP`cig;BXHjS99@ zRIuWCm~s=SE5tBkr5J!*xy86bqZmQ27BTl4M9^!+h~hd?SFfK-0ah8&^#-Fp+-O9e z)jEi-nM?WC8kPShqkA^0a5Fkhp}S=cPKHUREB!E*F*Jit_ec zVYKH;qe?6_3UirpD3;Hq7AuT!wbH01R~iTXDkCOdt&Zb#sts@vgoDrUH-Iu(@@@XusQ4a5>jIhq~p zOKyUHax^Dbg>lVlPL3qfo2q)Th51whcKJ4JM4~a+hW^MynP^TsoJhkaF`1y<>Sk{! z*9%+o^m>AsP&U+uH_hiarDT3-E*;(%ibS$Xaj+Ma`F0`&e?j8V-hp&>Ur~A3H(nY( z|NYIH-E74zc@qRooU;$?+|fTzBFn1gnaMJGnsiT2)aFyPzBABS{gZnAr>kS*k9QUw zoAc-GUaVh7PtGIc2c~Ig#l6E*Bu1;|N%R}Aw^s_9JD`C#jlfRGPljfXypLQm`iTO$ zWQ6ocRc3mW9;dr#K)M<_^d9^OxykkpbVxmt8~U#)l?fFCRVt@yM>dg)Zx+U0QI%LY zB`3?OO-SZSqbU$6t3dN~1)9f>hO%*faa~UyhI~UJwG&&Q-im6N=!^2pl`XwK*vdxZ z(LsJ1btM&2FF}3z>{dlz?l3R+(k=JW`>r8BC$T4nySqNUleTpQcF`MK128}%2T$YR z&6^>)DYB%F+Q6 z{p6BqBG-{iVr;t(l;MkqMxngtB$;iGvu!`yZh`GDOEbsEIvw;LIC6#^`69uy&mELj zn_=%MLT63}j=_`Y^?7erm>hA3j{iw*71yTlXt={1`j_D>EHoJ9y#^vvjMO^h`=y zmf4#hK6b9Pku0Wlw3aLx2f3`Gc5?S5`TX##bn~+IU1ZH@H|YGW=0I)ziFxzLGlx+M zUp0@CfFE{$a+p@Y{)8EKess8sZC52GHq@UzG5ip@gjSF%ex2+`gw( z-?K}BYR=*DR$;XR>)I$hOVRc4ZQdOeK>H23`lpFUk#l3@)*4VPIsd$ zZQpU#5Y8?HwV~O0L|Tu_@Dq{+Z&`u8@1xk%no-h2r(k!0SF>pUAR9@l+lwfqwus&@@0MvxrQRfJ~BrMv{P1{2C}i-43bl zh!wM`2(soGa7Tr#`8s6H7a(iiT#$vuC*rxN3W(8UG^|vs02maLk$bbzP{ddrZ|HoX zGxJ4g&7_k_t^7nPmR4>|#8aW9a&aOa3d@OfN`cO3wl9$u`orAue1kid1a~YM+;K!{ zO=du8N<5q48v@e8E#XjRLn_YC^rhseT1he;4keXql!1jEd>{w5qSSKJGZIosl*${BVxC<0VCL_C$wM)7Tjd906e^fy@*^#AQ;=E|L2&GdLZSt2jp zd9r@P59;mYK;08R4BS&serB37?~-;bl{POubIeH=jgoya+JD>5&)wD0N`7Rbt19WP zJoydrKY5f4_{l;){C@l-8K^r!-{{JB(er12O}|;N*Ka02e(wxDwqs|_UGxy0xIoSj z{}yt|+zw2nM7JWKEPwd@*0_yPbtE!}+8&K-^cA_J<$ zq;<>Al6`)uvGQYdf;9Wz_N8AK_S3t(ExYw=*I(8BcwsLYpwn-XES;e-`uh6r0@*hz zHB`Px^JL9PB{?u#NuC{^-PPU}c!fUEew4g%NWP)AzB=F934{m#FOXlFt5#LN93(^I z^c#SNRjp*RznQov$)-v2Y<`OR>!FkV1N02}>L8t^Ze;A0rDRUKoaXKp-%Y!$gxe*ZA<>>An#j9$A2!ZSxJUk z$nw};(l_0Gl-{;+2fcB}&b^=pEoAZd*+G(-BF_v@0#g1qg&z6OuAnh(XY2~;c5^G~ z7XPD*Q*0rh*Dte#xfbaH*$_5}3jkqr98Uti|$CYQnx zjnvc157mE&v`$ac&u)`8Ek6tmx@SMSpd*)|Yx>_AhVb`Y<_`>#qlf6KmR{N$Cx0}L z(s67-fnMMZpp$Qspwh1T+PHpv_D%AhIgYmp$BjL4&eD%<+YLVad^QHvpI9<_eA~M_ zy6BtGg#@m)uRK17ztW>6Z%^h?7?A-EnM)TE2IJWKNSsv&268 z(2nSFI6_^tms~P+g7nYOd>+(s6iC3CEPBs>SW?BdCt>^fB{Q)7`D_*2uDcy%@%=1C z!TjwK;24Cwz)pQ;37Biky^cZjiGkYczyoU;AmyeJ|KubDjDoL8o zNHrS&By!QCQ5!n7^KQfYs0iu?+?0KHVfpE~TQ&*s# z4v}A*fcwzB+cq8>0wwgHASrtK1Jp%k-%H13xc4VRSk7Y$W?=h=Lo(a0BY!$1${s`N~bKjglm4Ka72gcdXEct*Lc!spT;mkWV)!{HP(maaZWE~Bf6oyxC5LqE<$_s{cZ+unTX49TA+i)Ath ztoQK&P>qeZ^+)_W4{WTjCorP(NE;f`?bEQ;io(CW?ink@BN&`~`CXHA`K=G!Op5|x&K&uH|;wDTr(!!yn?KxGP!J$>~A5L`HAy1 zSvFZ9OKHo=GjttD^WO$g&ZD%7Z8JqwcTlv)D2n`7166FhYV+9*^?`R28SFv26R*)5HjqUvj~9*=$h9LR&_V`d(v8bV4Z!;L zt0vCFUC$3OK71SoaL2~#vGZGLHLXPa7?N&7DL(=yz-zV8jU+oQ?OIBf`e}gt>b+BR zU0>ne0vMcpWb9-YSv*OujFBZRz}xrc1GkeQf3Rch)ct9Tmt5j6fYMiOBsRd+jX$X- zRkVdHgnt90uybmd#sWV9fTFSU()Oifn$imC)|KEI-XHIzeb4`nZlu4++v`t~T`-uR z7?yULVKk2n&Z3dN3l1%s&Xa4Z?tF-Df#c5)Fl>2_(pB%K&z;ypk}?$TZ>gh?lWf&Q z7p-flBbkv4c+ih=Chhhq+r6h%)dbIQwg1s0G)A60ENz1ztb)Ef-U)%`^S?WpqxGMJ z*1SN@novbQJ`75Z_22&u7^T0-qb$F(2mx|3U&XdtpjH1ch$HzA@1j)?=6`bkC+W-2 zTgZWtz)#}PFo1$7thgSH?|k=Xj_{okW(|J0hU97N)Ctz`{Nx3^$zMlbg=kmVM)ZHEly z)2C>PJaB0I1o@RjSB<^a0+Q^8c-28Nv;RbI3e>hHVkiKM)pfPSH3_(v*dbun)t@0wUy)z6Rk7Xlj$W>9&%uuK13FdK2N@rrmMhNJxe!_ z(YvHgl^;7HwJ(JRuQRidc>+k~U=?V8-DeLUJAw^6P_^f7T6y9F;G8PRWic`|4fee0 zN~nBQt5ma$Joes6bDZoO-?#%&tq)NxUl(|(c_&$X8f>|OTv|uI_pV78TT z?++lte+nGpeDV_WfuEvPHS`g>8#Hj_RDO*7>q1N(jAzioeta3<#`|BpYzh$LgDF&{ zKVEVA7TCEj6%e6a@nC7At| zO0pDShqTafsbMLweR-zNk3G5`JifHujOkvp8Q(o1nVvJh!!Y_kpYtsVkPV4oLv?To zrhApYVzd=Dr1PZGXu2eGC%yB`U1?;i$9@nLMnVwJD(4m$V?;45oUdh*i^| znkwbQ7bNxaK82JUe_bb|M=g8DyI)0qRjtB69M+u&4(<|n8e}&!s)1te1 zsmIBabJX@dcKu7(Xnr|s+d}+VhIRiG>SpP=brC!`oOVxi>36ma6mmtKW?KJ;EGgf#9q z^QPF|6x*(2+aqin{PKU$^Yl4r)^@YQ@#protfLh;;3@w9DH5h5Vy1KXTx*Ljnp&yI;+l9a;ac7q8jIeDMCqv{Q?WlzI{;Z#(&o}}5 zcP@kdANEVN*utkNisg<9sd2>^-1d}?bNYtR^BhEpSDV_6%Y+r%;cFt z3f|7Yv$t@prm24Cj`}z~LZ8R~;`_c^PreJvL0`G+j{5w--FF9GIsf#D`vMQpPmy08 z9Qjck(B=U`Pw%9kK1Tj5^{nfmXZgXkOsi-TC*2Z1f&wx4bL*)~Q7A0n85 z{tcTO_#mm<-T%tTR|?hCi#i6QAE>vV0&+6DsvfTTk3-m{qtZBR|NEgjwp~~K_{NSC zWJ#=zCME);IX1l$-C-gA-8gyCL}yw8feG@rhesTp-LP>9t*VqR1BW-tW<2qY@&6qz zkR=H(o&lc2f4wcIB{(@P8;PFbOCMJ}!605YLmVPm@nclV75%pP(mp?cUz~#PPO#>!WZ@E5?^QXhl7g1$KLye8xOWU9ZA0j*`C{rd9Qw0s2FG z;K>L7>EVYN29VB{0=d}_VOf1^>mjm!WamFwLe=j9?f4P1>4zl<^3L~v$MHx3Cnw;d z=iy%~Spf`g-z;wO1FdA$6jVym(_bUsKLmsur15WNnd~`DN2PVkx52+xUwF1atx2-K zt`z|16=1CP`g;pd(>D(z>HD~u&OSf*Z70s9^-}p!vSJzwe0Z4pmkvA#eS2~kmHk^L z8iSoDhS3VZ!^FsCqpe*XT>)u6XyAtVsFV5sK3XPDQmAx;Yw1u9_RA@$puI)&6n_fs zRc08Zay(3*NEI^fLW*9bOYb=6uFTN8PbmiT%?0MA5TMR3{ryt%`S;GQUcY*M+qp;c zokvdIb^@o@>Jsz@TK!7XK>Pb9;wQ+TgY$Cw_BtLX^|T5=%TA)xEillJy_aI#Iy(>C zik((0YbB2#q?47utR%mfKYN0n51d0TF-|6jTgZ1zn6DZI^3sBND>5|IK!*H<{(HKz zFO%H%U4>5a!0@zm<8pG%bby4U)#ir+(oK~Y$kLVo z$)L&A1~$bZR;{kx`N3Dnw+>geo(KS>PE5c*Vn5wVmW&5Te(Gi1pP0y#uShLmG;LRs z1F%rf7-ZhT$6;>x|b#C!Qx$^T)}zq4dY0^lu*o z6aCI1$&Kluzh$$zFPQ7tHiq^unyX;@DK_u?Pv#leep1;UW!rpS+n?8VzF{6AkIkbM znBBSmIG>LxkSnH1+Fw8M^h?L2&dSc0x(c;{jZfE(1xRWHaAfBfq`IZeT_i4(4-dC& zC4>GiA1D2OvdCYcAZ1zsH?~FtpQY7fCyq(om7V907itRtII)RBZNBCV;Ec51+)Az* zC#@r-n(0pneLr3f^_@Qk_4QIG1g%dVz#jhHJURk9XWv`JcIx`cL%_DotrMgZp#LbS z>c1m$9UbH^| zyQH;CrJI-1$07Q^%SI0PF&CY0>1PvDE%`G+GSsqHs$2HSwuuw?-@OI<-_iZ#4?{o( zp5cl&(M9sJ3^1=VBVc~)Z8`BW=vjgc4EyH9AYzy#eQSu(cO;H3yPs3gi*DJ~E z5U8?A|?JQM&hp z*}SU0kS9G;Fq$&_t3xCkZP@!tS1)jmkyACONvo^{dwmV@Pp+~~zy@pXUVKHn=@;eZ z_e+J=l2ET6IdQ)DVscTG(u z=n-!l>@I}%WTR2O1t;t-zL^PSb1a_$+t7%FoM5#r#8$C20}Hjn`HgC&d@q!j(|yoN zegHgiBEmNlAgg}fjA$yHj%cmmnUsa^G?P-gyw5DGC&12TLbB4zw^&-RNL=anuF{o$ zW|f`5xd`+wkrK|RM28B)rcCy~=c|hC{E(O{i9AjE$Di6s^1!sK038d?Z;_RL@_SQV zW&J?>Rr2A*w4(A9xV^PzvT&RXQ~`QM=uX=D$9(O_9nPl0tFS>X9RaT1()VBoLl z1bH|!MSc%H@dHFAZyc1R4V4>OKLdOIyPhQn#(zeBa2UMs*x?q4)MfG)ht&%pZoli9 z5C0UX4V-@RPz(8%B$Fo&si(gs@zdXe*x=ZXt{U134C{rbC&(`@nR)$)cJoVtzNbsH^?^+LQLzge~@+qQ#-St&EH=Nd_W>k?PuQo zQjlw`K!aq-%x(QANq~;hx>y~#5f}-H&-%d!uEaz`hOUBbx{f~6j>n!JrjsupIl-I% z5H!DTD;dwtwt`b11Il!n{|I!oi^!+hv<|rViaL_=*A&i?OQxPVHt{T6STpw0OD85C zJoZYo{zF}3dGZ&R;xrq?5+H{<*ocwun*8slfk4*|$2ZQ66$0cMKZ!#d>O1$*niD+9U)f$qfGn9X#Q;B`3az1 z-)77CJ}1%H*Y}X=L)32uf-z&J|6->9s{a0~nLNFO&g}gNUGp3;hkfM!VgFapkUszw zxPQ3i>vV#y>&#Eo7OD&PKJ`j%p^tv<1qWF%P7*C+arzJqkRKl&A>-yL`0M}r*?S9t zdkbCn9C?_&7ud`~D&KQtM{hOF)3r|WiGwrb0s$HvYB_V1R7{OQga)j3&2sYK!CCT4 zQg;t*jGWwllpZ#OanPS5&K|OGgg8dY zb0*~6E#&9WoUfWjx_0kyko(LyC3OMwQ76r(Cvj3>1^MFPDe|1T4*u4W-w_yup%&5` zBR9gB{PEBTIULGdBLc7mN>sH*?Ncw0CsjMS?GH|cw$<~n*$jV2^ zhs@&;R`8Cl*QD%w)T?(M%pRPafG&U%jKgwVEFL z;+xRUI`Rngd=Z@?|6!t2&lh0yAmskEnQc#*VEfn76d5}-@^xCEw-@dWkRM5t4LB(+d)v83Cc4M#+6)G3GAD`*2Ov+U=+MUkQL9 zTY`m$0G9$E0D3(`e@>RsRrR%j!e5d85imM3P)F9nNSN!%_ob=5+h815_(`81Gt_i> zg0?|`I7K(ngY5rF7Rq}$)Z4=tX8et+r^VEG5K zv*nHTJC)Fy3TWUYL=E(=JHCi(cY0|h?IoW=ZF(6rj3i*=so~S~0)4&b%rnx4l@laU zM^?zv%~x2-U>%Tj+V=d8BXJt1r(T4%e#tajTj-_rU!h-yvf41`T}3`J4E=kVTs}#A z&ytN`2)&@MG7S_Q@dIS>IG{C%ZZ%wUlH7pGyc-10(m1<7O`kYL+^G3KF+p<+XG!f0 z1Tj~{&SQ4Cikumy@-bFFIco;3incucWBS{pFYVY#2cQ9N^5?@~Y%)mjIl%rIa#f7p z+uBJ!IXq6j4>rCFae921&S3I-i?rQLo;T4+atHi#QWW8j57Alrb?-j10`oIdDYg*c z*()dp@n23=u^sdV7hu4vTM+GGz^D3OU{jqfswcqc^0F$jzwRs^YNzA$cIoDow3VLu zoYcCM?DMzG#BeRf6L*pIs8b(4beaO!fAy{t(CBgU*I7Dq*DVj)EVTQhyS7if@|kG& zcCv7k9FwSgbjOjJU=0~Ky*vLJk!NVK8v?HuJPN*l6L^#Qq5MzD{t=q$CVysb(Jzm~ z<+E_PG!NJ`d#AVQA=6xI^#60Iq&b+lDTEXZZr-Oow84q2c`mApOz2^MWJ8SHMddqoo&R_WRIUd*1hvD_W?Fk1NA!ndwP^Un3*7-8E*Oh z9s9ssmtYooV5&Y>PljR-KN27VwBloMyazKgH_S|st0B(bKg(yr|B+=7-Z1?SEhsnT z^NC35#I_hAiYvq4IzSYbde5006;_6$u8f-acL2x*lezN9J-_cJ{gd>3_k{}p+N zBWZhO;>_c3obPWA^f&K3a=yNnq)!8}X?Bo47_8HIY4sJTK~Y*^qdRax z$eLdyY!@T+1zLo@K#$ND2od@MLxjFSi_jNn5&8l{gub9SLSLXq=nM1+eV!pgU!X_Q z3k+#}wn|~1qGmJm%+l(LBv7X}y0-=LFI7`d_ct(k8%0`oDV^DTl*r@FxO`q`u3qj$jd%BU2eRNo=Ge7uPYgcV+-X4fI2kVdE6xAn4dYW7z zHJOQ(Rw$=yAI4Lwz5%dNCABOi|6q#I$L_HFEYRP2sdFCwmbiCuE!?8-zF^hN6q1G;7(`4~zckl>YGfQhv1ahq;M@Q{}2R?c{@C3=$&*1ZXAXi>2l%DjdZ4x+zk?a{qU@@gp#hTvIq7Kv#!tzy!$Jr7{B$^ z!?W}*x|a6|F2Y6YxIlk=VjtNLH8m{-&q8mgZK?0tvGW(uUkIJ0+n2EzyySt zQ?$1OsC3tDj%w+)$_oXWe?PfPsy3f&AFZLwFFXmvc9c$RqJ;?(pY7ezwefjcZLjZa z?L09yLE5Hip!O75HVzSAoI-)!pWpi$IOTkh9GIRU1JkdNkC+f9 z(GrN$8_wPv2-N0D_%yk03fy+#C>%#N(hdR1l~esRN$ws8Zhm>yMBx%RYY)Q^wn#nD_Da&;bF`5qjpGcV7d+fdz4 zKU7QikZ(#el_%;U)~=(wws#Lu$M5b4B8P#xI0oecT; z(KM-`Q(Y6}!x9A7iS2E#LVP(+`ex3MN?P&00*Qh2>qyLhD_IS-MCfE^>#1|Cfk0g4A8NVdeLpKea8Q96!LhDvYd?ui(Ys*}89n4j{|j_1@hx3`!N=U0wOCSUm~9(S(z-WgCh@<1M(hxJ{N*h z3?bhz&48h#@ZplbWDj4yV#4)3A7x7e&YL8w`E_#j6!Ac}T4z_cKe!<h#X$so>cCXK?m(y-{`f9eC zf_A-x|co588-TH+TBL$(ZsG_if$;Ba=w6v$%y7 z;YdLbE>@GTL8&PywhadWMV<@wbBSYR7LVJT4fA0&MP(E(IJQ)L75mAj@L|npWEFm$ z^x|D}fc$x-SS%}(Nl)wDHiNWTV?+fr1?8}@t>xbZ@fM>2^$WGwK&6K4a=6+95lrq#Zxs*+L2-AUJD48_KU6_U=o(tuL{8p^0I-lg zQ4=5KEVdMmK}-8gVi)iz$TbOyC|D-bR~KXj%*(IZw6SL6 z#+prcth(6)n%*3e`SA@~Zb4P@vJ?%g4!gj|Odl~e!r~~Ips~tDXu;d`;Z-H^782z~ zbdif37OxL5L=GpJj$9lExIVc%0QVB<6cYl6LBYz=xIxI9g7|ermGb~{Btf#mFsRVM zWSvutM8OQ@8ci$~)ePL(w44s7lXk0)1e-Uh&?AgxNS2vx$Zydni^HL4jIG#Tpy1jp z-c}Q)=C-ikt)d!w?!N8ZCZ zsYSEJ8|<)nOrf4!5W>qy;-UhxHvv5`;H{2+(Da}IH5pVVidE@n5;3#v(4GZ-aoyl+7nOWvSVU zev|b>b#>uh7^qx67E25ojg_%Gjbp%N$W77HUPPu&m(wNyKZ3btbF5bv^#aI=1g-Tz zt65io*#b+jMss0PJSv9=BBr9NR2*ZF8w){H$!hfi!Ul`Yz?5<_jJc>Of%ri5igz%S zo)I8Z;Jb`8Fw1zmtPG%%tFs|uxab`o_ghd59z`%NE(|3b$e`#7m{i%ov&fiJJT(*m zUWLYrsF$l@UPo||9Hrq*;sCIfa2{9MB=dbK(R8+Qyx@9?a@@KFwJx8^=b{LvN)W?5 zl_3lO66$RT`kFm9ixv6>*J0;u4L)|<+wAcL+w4xZ<9E4jPB_%Y?9b(DV@Eq|9SNNI9v^_V)0%}qb=Cj?riWuuf6Py#RmZv$O-z3yLMNH zwhghM&C;grw%y5_r|xeGHo8Ev&r1`Fs+&R*#nAo0eud!^6_O2vW{7Mcg7H*79PAGTlZl*MqP0P5lg9!W+8<2iqG3hw?mb>s zajODH7#86fG%vsxpU1wZ-KQ9uMFmV(yH~ZCMm&Z~llx#uQ0VbQq?{Uxy})9@=%G^0 zNIbSCo8O>8ZMHUsfKX%~qsINgyxMH5&0z_kAoP)OxIk<7*nOJzIpN2vownWCZtnn0 zg;6OQOci{f9)>==0L8d;8Ce<{TIWe^YV;JRNvpd|)0dLT4Y0|J0?y)#*R$HSAYDSe(fljb@Y_J#fGiGqS2Jq9B zpXm{|EK@iHjfn;1Y8A9#zLJ?q-)q8OV0k(Q(YOJFL35Rr;iL0F;<> zNpuB*qBeK}ZeQtO8dTZ`oJj8!1|1t!?Q=ogqi{GJ15{*dv?m`or8Ch~urD-d>WRkE z*{B9gexF^3Sk-oo;?(M8bO<`_P)aWaT&gKq2oep3QelV=bWAVP zFM~|?G$^TieaHlw+2C?EYNp?YG+yI13O^Q&RwZQ2mv{wTY6OL7YV+x6>(+YjY6sy! zUxK-zlpGoi%4MW0N;Vh@LofhcW(pwpa%i!3*uAI%c4wnY;P5Kga@wHrr4)pWeL2J1 zW6StpQw-A*WgNF+8eY*%Jgz>yg^w(bcJPm+MSrU<`g<8I(w)G#*s&O%E$z*?e1dI1mhfv z$ts3J_Z)VwPw+rx1fa$t`e`H`d8W2#j|he#)f<78m{4<-fKO|lT8NwtrE*CeaE@8} zb)7Dcm6>io5V4%WhGFCL2?B9#l|5C@`w13a6P$CrATdeV_01y>!a;s9rY{`vpIV3QE=LszsT2KvUCib-+nh+^3=CjBF9>{LGjy6v&K z9a<3{OQ#ardG%l-n#(6;f!-pJfMi#i8FDOuD_#rkw?@3MJZs$RG|MZI8CKe32_ zHf_)dXgMEAAMl}Ko7cHC&-@_Fgj2FI6pVeLOqdP_F@|E3&6@ri`3VF`!A_gKso7V| zl5NiBpuJ|Bn2&MTnk)?gcA&+z2i=s<<8ojS-!lZ3r3U(K-X<+_=bd2ytV~q%fDdiZ z0udd~K`FN(Q&KpuGS-|+aIV9k4`Q!k-X=&6d9BZ;7U#A3gyaKYy@s$X5H8j*T|lgG zZsqDN7Uo~z2f`4ar8qWhXxCY&GFO(9vnX|(!ivfbNl;kKL&526^lk{baOS~*4%F&l zDyJM~QxN=7x?o>k2Fi+A0nB3rgQi#_nv5_YXZbr5uq&2pfvUopAyb3JjYN|{S#S>o zE`a`k;Sqq~j43m~bRU|7K}07eZ@tP4d_y{w!kmQUTFE8Uvb_5e8E+;OR>APdfDPAC?x^$A>dsf1U^}m1fTe2>ke207;tB`cCaKxu+ajz zVO1OMfH82V6Dc|8(;Muzc)Z$$pt2kBXA|DihPsM@?LbN>SRH&dpRJu}a<=;%Ufgtf zSgsl0e;t%dZUmb(g~Kdkf@z&HlG7R!&VYTS61iUJcoamI#Sm4qCC<=H!F>r(nQXKl zR3vB6DSsQji<${Fl~#oSE;F6%XR=^tftc>+kHUg-MR82=D9%E`4XseLJDU#U>Kv`) zW|ylKhpi7MHp|V;p*x2SfV%b^o4*jWRg{_){xtyj`_LN!7_u%aYlpJTvoni9bH;>o zLnssKNhI0&V^F;QP?BYr;IuoDfqsP|?I~d3HdkYD=|Elq0YScPUcD(EKuW;X7?z=q z0fb2oRs0YH_3_mv%obB<$1)(3U^HIfY0M9}T+DPD)7icdgf?Mq)(9^|c>%6^>~5c0 zc8M~%tTrXl#9sPct-S5M7`~iosA3;@=7fy8pcjM8%HmLz4<&+Yww?LD9zk=#ORM!8 z;aFzmi;pK}VR0!Clwk$A!&P!rsWqL9@Jj%qa9x)sNvo^P0>n#cY;!25fCKXe8ggI} zYE!(7Ap*GAEe?cw;7FjxDGkf5(PUJPx-kQX>o)-GgEe91B{2Hdj%^B?!Z-=SQ>s{- z;+ehB!@fa%1bjZXE*owIp@;>{MpsklEjWyHc8GU9w+|=Wd}(_s66FOk3gU7rvxRCC zHsd-M4w$Ogm4y)sa_KeLt(tS-Z4ord2dH54>3RsEGS2Gwz$FV;!C@zI`gm0CP3L5` z;7c0?^x7R=Mu&v?De%HFW?z+_H-ebkkf$&tWaEv4$>&npEC+a;JUbJKvD{p=FXNMk zoN8s*eij-Fz~vMb8$2I2Rx@?LZk8Gp&UtNMnLdQ^a3}??S}hxkYj?IfU7b#rcG7#- z-sUjvi$*g*D#1@6JYmWPJLSozIumlQ=GochP(eFJOD0(!vdFTatWH79{x*j&6oM`X zz2K0&%`VnN#Xad|bE`++$D9yvg8YX~Cl_VeLMv2>_C z&S&gaLz}HOABdZ4yxRh}robT%D71>Lz+l(=Z4IcedsqS*%CltS{l2uKnIK0dc+h3Q zTo`%=yE2TsDV`1XMf=J@T?Zf?$P|D;o%dDb4F;_kd^<#!_J)#vmw+X5HUKgJ25YoG zq4F)IK5$=ngRP8vR5Cp*O`)l^Z7_igLUe0m`pO(!j`gyLN&1=MlP5TyTcH=5mRWQ6)1`XqQ>Mif16a0 zy-kV}h+bg20JRLDQ_;avT~h2wgH@h%;wp`6J5u}!0#pjb$h<+ss*QjQAOH{3@hVVmDh>n#5f?Zf!XsH-T%q(Y-qU4S}WK6_&T zomGvFTn!GJ#luyDxp_ee+Cp-;H=0AMRLBPGhWA<76r|pepkhJlS6~oqS>{jxbBoW5 zNuhSXsTV^7>z1ZTl7{;Z#m9o5s9)d7(ppGIV`uYFCt^f)2qL&9U|j1XI3Rt2bXI2dNY!Q29b%`gf;GFZ9+K+_oc z1De|~A05!`(rSUw$h2nNp1X~5JuJk2Nm|NI1~m?p!LjyhI(?WM05@a`XO5q#$vPWLs@}+M872X(geeV~!$(9xSv86K1H@(Ln%Z?&6Ds#$w0GO3C0r8`Xvd zcF_D@&}`-z)CArpeDoU^yFz7mb2fp?R?YR5@pcX`cu_` zfqkfP;J)Y(U-)Lt_FLI|+`#d)g$6sq88Fjiv_G0u-tPv-?bvJ(n=9r{r;|D5HYa~6 z2b{O$Wk5M)6{c2T8+(-^@?Ca^4eRG;Oe_kGg~CxQd(T~QI}GJ1)$l9bvU;(XKTd-U zvgh15ZaEeYW#E7{8cU>b@wiEO=%xc(4FX`%XOO#beDDT3>qCG{rSVZH4D>uvWJ!i@ zgi=sK#0#O92}z5oA1lBdklqak2t1$J!y~bhqivQ3LEW?#p;Yz$DBRis-B4Fo=dgV$ z6ysH_JuT@TtIBK2TR>VRv7KFZhQ0;gli)?5w+ePbe2<+4p!}h@a0fR&pc-WZtedmb zW)P!0kwR0{l}Qxip+RJ?w`X`p(*o)UIiCk0>5O^&HVroi98yOvMl=H0Hd?0d~Mc9?cjg9@_$1mQf;s`I`=t)eF^|=fq=AMg7B%*IgAlq20P2 zgFg9`Hw2(1={KZ`!)&c@UgecTy0IH+itcH3{4{a}C4!2vsRl8=7EoJNdqFD&E)wbo z=foaW)|RGOJWloXM!fb?urdf8YxkvPV99ZnX7)w)t_N3~D5XURGHut}!Wfg zYz5<5)@WAAky%nh0?LcQI=)thS$~m_W5!u*v0`5Y0$rrcY8x~nZ2(DCjoM&0Y3gIY zMciJKHmZOTza!pjnXF7PU(e}jYw(zcb;BhVsO6~Da03J-`_h`i?9WHDL*-CF^z1yc)y zdF4v()!YDk(U&o#(#$u?CZh!^S;R|&<=|IOkGfoKdTvzg^V}p}w8b)7qD=bmgmS6) z5WWn>sivf=zp@xvQ%ROEDJEY*gQr!kQc=2;LA#1@MF_(3f`-k7wkXfegu*5Tz}CHr zeeM~ijF1*qJ&+^OqXI;xm~OL_K7Y$kg1z=fG3v6(kfI<{NG%w03c0y5yv*=3dKTAO zlnX0Q$Axrf49e|8Ip&mU9`>TbNLhcXyUSv3qai)FQMO8so#5FteiMJcmH>v#<0xam zhegM%GXAnm8iZ$q73sJymh34?>t!Q`xdQfdQ(4O?iJ%laFwEY?1x^wd0^yuW;0LmL zbvmKeGV7%QbD4~i4k?OV&OKM@%R@;5KJYMBTehmtVk)sruy|6qXs(lsS+UwoAp}bU3e2x2K}QubEZUZe2%>8e zu&X#NE~JL>D$pu?zJ@y_F}+x7oO&mW0TN0>3wp|h&jw9kpoY)ZF?9n8_vPZ+oRgjc z(JXHceNjG+$5IqIHAXL;h@LBKW;5&|HPtK-^5O{^>l~PnD$B$9yeuCOg*#wCU!r(L z^d?d^OBE^MvP%4?xfpFCL{D%!ixx4Yifx2FN}{(1msXW5CrP&fp}QbYkXS)g3SsJvv>v}`yjkP0}bkn%=_lb1$V<>x?)eU(CC zHC4+L2gr)qu@MpSNMcCkv1^*pb>}WT&BVso)P?Ji9=O$eX>3&RyLB>>|Js4MhfOE zGvjZ}q3cdTOqdFDQ}#YIkc>D#fVl)cF(nRP87JvZ8$x%*)WtjZ{Y{NGPbTGG)}`NZEB$IdO^v1~yTWv@G)D<#Yj%N?YI5rzhw& zz;KGw>&EP=rb2lYt#d*ye6DGOMs3x+rW{sV1HMnfTD)RH3D!|VZAlm(PWBC?o3TbE z3!$-s5SXh*081~|u1l0G3rY(4_j0UNTTx(Grxqz)Y*94u>dc?+&b-*b>MP0?6=fL=b$RDn?K#H+HRvbKr8r4dGED3?sfP57=@mb2z()jY1cMBnGaXYTM#hfvCa zbV|Jr z1YL}=#rymif2)Dgpfry}SQ#wgqy?ZsvBP3<21&S;w>t*a&xF7k7CCDzXAeCYd#Bc+ zj4re|k&7q~;HX0NS;6lr*W)@hrGO-R$D~lQIv{D~f-q0_1``oQqu@g2K{S*M&@Ft! zSsZl~l^_ygf8%{}Iu-*@BtxK)LZuMJt_B=TNB|rLndn(vwa2!Uy5+_B#&n;JKWTxo z*WDEFm$OHh88GUNqJa2xaKe=1JN%;d6kA81NM-V}p`nUEBlvz9y;7xy27D~XFht4> zHS9AxR9gb_7(ltGs;M4lD5HJ@FwEYwtoO56efXq=^0FAUMzu>~o7u4F)rkU-)#t&u ztc3RA`?mxc8r6$+rby#ZRf?Oa>a@}F1*!1SR+`Bb3_BDvjF<+IyfI}e5mq^R+50-MNT2gLb(mf%U|8fyOi46eKtRklSWIs!&h|F zVzsz^_6}Rn=~nCYCgS*L5`HcLnl+H#7frEdg_SnpH7cPC279vUP$V3}CtmfYW9!sy z#a>ve#cf4zwWhmLwn2WE&=utdEN72eQBe<^E>D}qQFLDu6YW4~Uo@X#4Kuvr0=pJ0 zE{8FD_7*&p#XxT~)t4)}q|t(}zSIPTkE^qHjA(sQ#bUh8gHKj_6(I+MDSTgtqB260 znatE?qO32{!lD!S#E`Y9VRN;C8?LfOk5dFqq44#+sy|={Rgd6_vUteJZ|-AWU3nh~ zxNc~5R`JLdewn((F*K+?mMnfXN`dPrdji-O>M`Z;B}))3GYXc&C1LCuU{(yvFeN7U zWt=%@7QY;VZ*fTUt3Pw|YZ4+aP~95H3bAfyM^a?_uQh z7D3r zi7Lw3E=W`VegY~11j5R*mHcyLJpYZKwJ0w%HN;WlHzj0%qM*Wj7_(y$eX1`TRbQo^ z>IsGh6FK$6IYQy_sO--7BokqKL>OGB%Wro!u!kB4LRodajy8!3X6EX-TUq5RieHrt zY8DfHESV0eFO3mwSQ&DxPV+V6ZqI6eiPtgLnjP*8Q9T*K@b*yn>qWI3Vu{a5U%oC7(jm?_!&{W z`0|*Nmf8Ghl@NEdg)*4kRf#S15~D1e@@-oNYfQ{6g}|R-+~acj_*Z^ZlWp`^n%HB& zP;$#@G9P5P(V~(d<2_;8{m-okg|e9rK*FO zEF}bn?kbltV{vB1p~P2kK|?Icmwy?SyZN)$&a~b}rXYjG`s8f$xms;bZ&?AjnU+Au zI-|)Xsv~BCo~V4??I3dAY=+iMKF)iJX<8!T>9sCN$Q$1lRLw@WGbgqcUJ)m)0I z1!`UkbcuaqrARHUu7-9d5N711-&NsH>+{F1@f|tE-;q%)7+o-m1I2<JF~nTgIRnjmm=pP+Z4FJ94-q7Tnzx}%1FMU8BN*k za@ZRJ+?b0k9C4%c8$l?XF!Cj+!B*_IH5Aek&}CdOaxwKD4|E!rm2&0xdmX-@&ttQh zL_}ac1i=g@`oLMc)47EDf&e`=iX>gxX47&x14z5t7&w6|FOm{eqvVpbM7ozhLcwfC z8-Bt1`!cq{4F60UD}<4U2!9_)Ipg=*?z{+hVOEvOv9Cj+*H6cJ%e9x|HQAgtk3}6z zmMSQNaaatSYQ;B%>spJ{OAI6+`8-z&Qmxy*`^8FbQ8$ zVCyucd+siWMHUW3R*%a)_rT+~u?%FMIZ0zQP!b=g%~p?cPRiH?z70p4BY=a}1b>kf zt_NTuHrN9Q)Y4{CKJ|tcp;I@$&>r0>dI@mbL43c6FbvJ@O*Vs#G6%^=ponuQGW@^P zy$5_$RoXv(NkT{C&5sC`w2|QOZoF06LQpk^v&g%#cYy6cpRC;;JYXY#Xeg z;EJp3+C^CvJGQmEtPO07x^^tTd+vRn^W1x$dot0#@B4oKe0I(EKJ7fG*Ez>(t31dx zr!*$LyZTw7fLW7qz_OyKzP{4l7){w18ZK&F3_Z_GyHR$&X$)0ZY(R@4j;O-oYGHd$ zCDKE@5=(7oAndd5yS4|%_L$o2b=(a{XpR;65=VNuS~B(dUwf2g&txs~Oy7#}=%1D6 zM#WTdQcHw3BgndUbNIgkI>{8?_g$fmtMsMIx(V1EP+0R#IcCw$n&j+9w8zeYa!Ig6 zj18=y!)9AnZB08pTFyjewOei0+@caH;9?8YSY*nI%(Htb`-zwMB5{1tI_n_vNaT); zufDx^c1v*a-7M?Q{8^4!pO|(Fzr|0?o%P(^zF?KI8qP%Ao?jJPPsGu&MdzTqW{I_u zAtrD|^I-|WI-}|}=4f^-=rvN+Lbme?BCTEtA(@On;(+00IN&+5mxiUzDw z#^qfZ%?<0VMW5M4!QvVAB7&>67T4OCHAqb=YvAV|8CcbpWtcBv&Qe#o3Ya~v2sFf! zM$B$+tQHz3p8+@<3cZ!mnt;niDRDKJ^`7OT3U#5x90kr5?=P&VQVOayYqTbW)d~Dr z?^JsVZZBK~mWoM~V=6Z@j@_wqDD2Ux24c%)doT@~+hl4*jp$v?@?vJXxDU(x5C;Ur zz5SK(YIBex?!ib|ZBe~_F|)gG(vLHXii=Bq_8i4EbGDlfrz^?;+c|TmN&$Tk&d99V zX+I94%+{11QpsaSamKb4p3s(arRhE+VLg#+t!pTw$O@j-R=0$|_-Jm-0XHOKK{o1E znT6I-EauKC88ce+YBkmRR?szLT4X(Mo3dV-ltWCJWN>J`CT@>As?E;UJ_92nVFoLr zH5N*jIA}1|E=jJ{B+q`v-OE%ca~1sYVO65e8XLLSO=+iAEXj%$eX}{Y)^by3XPSyt ziC;~}tNFTH(yA=gi7F8f!&=j`4?JMT`DV^`PU_R;hBc_Q_Nc6dG_m1p^()#@vuqyB z8tv)=yaosGZO<(l5?0S9S`2IH|CD4yy?#gr701#PKhU>y?LxDlG$2-#t?C$q)qAWUW0H>mYl7G zbGlh<4m)QXHO>iz9O)FzbB(6$^%Q7^#X(waF9F*(;y`Pab(}j@m9&NfqVp3Srn}{; zaCMH>-OW>LE91+&<~HI`kJXk#V+yND6!lW;Qek^hLhNHy$pbSD4XHpfRwaJ?;JIKn zr?`}wo`BCaXt3rXB1|*9#mexM)qNTs)z&JFR�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 literal 0 Hc-jL100001 -- 2.47.2