From mboxrd@z Thu Jan 1 00:00:00 1970 Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.remote-ip=209.85.214.179 ARC-Seal: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; cv=none; t=1795385476; b=hCkIA+x3uTKhdAFOpYKebR87gC+dJcQz3Wsrv02Ufl/P5qCiA0s2gaBsihgd/DPe6k27 lI2tNIldXtqSwaGZp3kjaG+/iwCWzwYfn5bXfoP5WrC2Njjwdc1CfcpJLYtlO6EXyT/B/ nebbLGepcQYzFc1ET2qK/0/SwVNSeB0CFdBbqkQ5PMxtdYuDr/QnQY5oDqE/a9aO3Wfyh SqNpylX7yy/GPIIiJbKJ40q+VsFQbcXrTY2IzoCuywyZVi7SkO2vrDQNxPo3LL5LIjjSF IuAAH6BPg2/WIvvtV13t4dpKmo1nxj+LcBJyDjG75dQPe/FFv1sSZJrQpInuIyW2WXA== ARC-Message-Signature: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; c=relaxed/relaxed; t=1795385476; h=DMARC-Filter:Received:DKIM-Signature:X-Google-DKIM-Signature: X-Forwarded-Encrypted:X-Gm-Message-State:X-Gm-Gg:X-Received:Received: Date:From:To:Cc:Subject:Message-ID:MIME-Version:Content-Type; bh=HwEHPw8X8kP8p7in+x2fLKj35tkSbNdjvSzkRf8gDd0=; b=IBW2LTXdxQ8xv6hoSb7cDX9U52gCHc8kRZjT5CWn0lLUVmi5BZLb+d1Y8gjHT5kBpr+U HWnXVlt+p7cnoHSlgnCxSnE+0jjO0VSGWlq+HLGSJkZUJtNjnQXTyzYqoTQAu9r3mrtcE 0aM2qTrYlR8k18+rrgbdSOBcdDXkiqVG0PZHmHi8qEf5Rrm2Y0nEGCyPqOnnWQYlAvi3v 6ra7BuwnvgoTaGqQVD6TnlxV4kehB94XhEVDcpnXKEtUNupDPOOhNYp30Dcgcno78eVm7 XnhJ0XnALEdNGJrlodVBlGp1JH644m16KHb5HWbup885LhDVnI6jduW9ynJn1LZZ7HA== ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20260707 header.b=DDGoy3cl; arc=none smtp.remote-ip=209.85.214.179 Received: from mail-pl1-f179.google.com (mail-pl1-f179.google.com [209.85.214.179]) (using TLSv1.3 with cipher TLS_AES_128_GCM_SHA256 (128/128 bits) key-exchange X25519 server-signature ECDSA (prime256v1) server-digest SHA256) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 25AF1606A31D for ; Sun, 22 Nov 2026 22:11:15 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.4.2 smtp.subspace.kernel.org 25AF1606A31D Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20260707 header.b=DDGoy3cl Received: by mail-pl1-f179.google.com with SMTP id d9443c01a7336-2f0621eec70so12867195ad.2 for ; Sun, 22 Nov 2026 14:11:15 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20260707; t=1795385475; x=1795990275; darn=vger.kernel.org; h=content-type:mime-version:message-id:subject:cc:to:from:date:from :to:cc:subject:date:message-id:reply-to:content-type; bh=HwEHPw8X8kP8p7in+x2fLKj35tkSbNdjvSzkRf8gDd0=; b=DDGoy3cldL7dRfjVIWycf01JI/6WHXpI+A9eFvmI0/G/Sjr1jtCeRWGN/DeY6DiaVj A2zTjE/VmR1CBiRUBybChgOvWam3w+ITVSTCNMxfA35BU40TAewSAhIPKMgD7dFR3wmE L9QAlDXooNZMQL9BJgnjY0gS2gOHR0d7f3eHiNpGHTEcLm2+NMs+WZLULHnHQCF/Yyzx WXyX/p6zEeqHNGTZqAR93auiiG+6+8FaWl4Ru+2ijbNM76OUSue6Tbxzxju1ejLeFU1K bMJLeYH1EmKjifdgMJzxQH3d21NMmKJ3qs5i0xJ0kpu8zYBvdnuUU0QHX/H7567jdCog 5CTw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20260707; t=1795385475; x=1795990275; h=content-type:mime-version:message-id:subject:cc:to:from:date :x-gm-gg:x-gm-message-state:from:to:cc:subject:date:message-id :reply-to:content-type; bh=HwEHPw8X8kP8p7in+x2fLKj35tkSbNdjvSzkRf8gDd0=; b=Ta+8qpt3H5+n72QAsImdC/2pEyn4WGeMSQYmZsekj1NyOjrGV7j7vz2Wtq7CoSR4kW YsawcGShNAlhkNxTjzhnZg0NqmpCZNf/YJBIdLuUPVumOTB0+GmZioUI4lfa6NIEpc8b 5SpHh8db9foyOqKlolyyrRDn8VaTC48bcQbadOwlJRYRyTKf/iyG+lrPLI3ozUeQObow vARwogtOptCD8ogmpES4UbcdFaqCOL5FcOaOQAZTS/uthm/cVNmjfyuPHT4/A3bJCEHK 6BhiZ3U8N8CDfJxYSHPH4p9mDFraiLo3uaTEO9WxgeterIgUMGOBUDWu0kP2uZ4oWihd wqSQ== X-Forwarded-Encrypted: i=1; AL+hErEkwX3oqTZuljbuYKDthHftVohiauu3vUs/Z5K1Kpvpayn941vaAhzD2qtEx9oKrjY17HHHPI7ewwTHLFQ=@vger.kernel.org X-Gm-Message-State: APuU4Z/ooIDvtVzTD7P0x2KLlPTfuXqNb9Bu2CfzCUXIUAeN3TSq2GMK hhhv15LDfdbKpTJ33EKEc0HnTWWIBr/9aEKTp9ngobCom2wGngCbxumu X-Gm-Gg: AZFdTZdtf8qi6svM594OW+yDpD9Cer4OdvlmIRFxnXck0QzzI2f/GunRnRJm+smUhjc uNbyDHpjYHwCI9vW/R7Pnn76Hxbh4gjkMxPuht0z6BcpH1uUgkKSdsIMm+U1TSuYV9+Hom1m7PB 3qZs3TqUgaVhnSgruhid1x0qIO5vUYub2O/DPD1lwx1G0/Ek2J/gIANQxMrdGxBwEK0bD04fJmz 9FKV5XDNaPW0O0zfP6NqG7hvvEEGMOyE0iI/sQvWriReUnRv2pBfrrrfzWM1vLnIsS0anIeLqsA 2N3tbTfsd2jhdCko7peRdxL0trAlfrNeXCLIp9lnmqjshVcH6fPuRRv+JRy2GXfkYQtXbirCMrq xTjgc64A8mO2ipwudvOETDmQ1k7znQOFU7CRBBme+6PmkL3lEEvxmgUsGdAuvQFvt6oqdVkLScc FUW13cQcmAE/wpvVt9J879uqbFdmHnazYeWExr/Oh7+BOj8muSDoIFMQndQ8P1UievUAwZQYd7H u1R3/elPX9tKCuUznF8xMeRa5MR9e4vbjb6cNLXHz6MJi64DmDlfacaVVAgIwRZXZc9Vc2SZoiG /vchZC5NglVvV73CRA== X-Received: by 2002:a17:90b:2d8a:b0:3aa:6b5d:a00a with SMTP id 98e67ed59e1d1-3b41c95b7femr8887768a91.53.1795385475213; Sun, 22 Nov 2026 14:11:15 -0800 (PST) Received: from [172.21.0.2] (vldb.skku.ac.kr. [115.145.173.180]) by smtp.gmail.com with ESMTPSA id 98e67ed59e1d1-3b405d639fdsm17693929a91.10.2026.11.22.14.11.12 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 22 Nov 2026 14:11:14 -0800 (PST) Date: Sun, 22 Nov 2026 14:11:14 -0800 (PST) From: Kyuwon Cho To: Johannes Berg Cc: Sergey Matyukevich , linux-wireless@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [BUG] wifi: cfg80211: CSA onto a hidden SSID group warns in cfg80211_update_assoc_bss_entry() and leaves freed beacon IEs Message-ID: <179538423867.2896802.12596731671226623616@gmail.com> X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Post: List-Help: List-Subscribe: List-Unsubscribe: List-Owner: Precedence: list MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="===============8455935433251778651==" --===============8455935433251778651== Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Hi Johannes, While testing v7.4-rc3 with an LLM-guided test generator that we are developing as a research prototype, we found that when a station follows a channel switch to a channel where its AP already has a hidden SSID group in the scan list, cfg80211_update_assoc_bss_entry() warns: WARNING: net/wireless/scan.c:3537 at cfg80211_update_assoc_bss_entry+0x53a/0x7c0, CPU#0: kworker/u8:2/44 Workqueue: events_unbound cfg80211_wiphy_work RIP: 0010:cfg80211_update_assoc_bss_entry (net/wireless/scan.c:3537) Call Trace: cfg80211_ch_switch_notify (net/wireless/nl80211.c:23295) ieee80211_sta_process_chanswitch (net/mac80211/mlme.c:3328) ieee80211_rx_mgmt_beacon (net/mac80211/mlme.c:8381) ieee80211_sta_rx_queued_frame (net/mac80211/mlme.c:11909) ieee80211_iface_work (net/mac80211/iface.c:1805 net/mac80211/iface.c:1862) cfg80211_wiphy_work (net/wireless/core.c:609) process_one_work (kernel/workqueue.c:3495) worker_thread (kernel/workqueue.c:3578 kernel/workqueue.c:3659) kthread (kernel/kthread.c:436) ret_from_fork (arch/x86/kernel/process.c:158) ret_from_fork_asm (arch/x86/entry/entry_64.S:245) and a later scan dump can read the group's beacon IEs after they were freed: BUG: KASAN: slab-use-after-free in nl80211_send_bss.constprop.0 (net/wireless/nl80211.c:12959) Read of size 1 at addr ff1100001428e61c by task test/115 Call Trace: nl80211_send_bss.constprop.0 (net/wireless/nl80211.c:12959) nl80211_dump_scan (net/wireless/nl80211.c:13105) genl_dumpit (net/netlink/genetlink.c:1026) netlink_dump (net/netlink/af_netlink.c:2360) __netlink_dump_start (net/netlink/af_netlink.c:2475) genl_family_rcv_msg_dumpit (net/netlink/genetlink.c:1075) genl_rcv_msg (net/netlink/genetlink.c:1191 net/netlink/genetlink.c:1209) netlink_rcv_skb (net/netlink/af_netlink.c:2585) genl_rcv (net/netlink/genetlink.c:1218) netlink_unicast (net/netlink/af_netlink.c:1336 net/netlink/af_netlink.c:1362) netlink_sendmsg (net/netlink/af_netlink.c:1921) __sys_sendto (net/socket.c:2283) do_syscall_64 (arch/x86/entry/syscall_64.c:61 arch/x86/entry/syscall_64.c:89) entry_SYSCALL_64_after_hwframe (arch/x86/entry/entry_64.S:121) The entry on the new channel that matches the associated BSS gives its IEs to cbss and is then unlinked: if (new) { /* to save time, update IEs for transmitting bss only */ cfg80211_update_known_bss(rdev, cbss, new, false); new->pub.proberesp_ies = NULL; new->pub.beacon_ies = NULL; ... WARN_ON(atomic_read(&new->hold)); if (!WARN_ON(!__cfg80211_unlink_bss(rdev, new))) rdev->bss_generation++; } When new is the beacon entry of a hidden SSID group, __cfg80211_unlink_bss() refuses to remove it while the group has probe response entries. new stays on the list, so cfg80211_rehash_bss() of cbss also warns in rb_insert_bss(), and the probe response entries still share the beacon IEs that cfg80211_update_known_bss() just gave to cbss. Once cbss is freed, bss_free() frees those IEs, and the next GET_SCAN dump reads them through a probe response entry. cc45f313d855 ("wifi: cfg80211: preserve hidden-group beacon IE ownership") covers the case where new is a member of such a group; this is the case where new is the group's beacon entry. The reproducer runs as root and drives two mac80211_hwsim radios over nl80211: an AP interface sends hidden SSID beacons and probe responses on channel 1 while the station scans, the station associates with the same AP on channel 6, and the AP announces a channel switch to channel 1. The WARN fires on every run. The use-after-free also needs the station to disconnect, a flush scan that expires the old entry and a GET_SCAN dump, and shows up in some runs. Checked against v7.4-rc3 (aebb72744764); the code is the same in the wireless tree and in wireless-next. A fix follows as a reply. The reproducer (repro.c) and the kernel config are attached. Thanks, Kyuwon Cho --===============8455935433251778651== Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename="repro.c" MIME-Version: 1.0 /* * repro.c: cfg80211_update_hidden_bsses / cfg80211_update_assoc_bss_entry sibling of 26e84445f02c. * * Everything goes through nl80211 (generic netlink) and ioctl. The AP interface (hap0) does all * of the on-air work: beacons, probe responses (NL80211_CMD_FRAME), auth/assoc answers, and CSA * countdown beacons (NL80211_CMD_SET_BEACON with a CSA IE). * * A AP on ch1 with a hidden zero-SSID beacon; the station (phy1) scans ch1 -> owner O1. * The AP sends hidnet probe responses while the station scans -> member M1 in O1's group, * sharing O1's beacon_ies blob B. * B AP restarted on ch6 (hidden zero-SSID); the station scans ch6 -> entry O6. * C station associates to the AP on ch6 (userspace AP answers auth/assoc). cbss = O6. * D AP keeps running on ch6 and beacons a CSA IE (new channel 1, count 4..0). The station * follows to ch1 and cfg80211_ch_switch_notify -> cfg80211_update_assoc_bss_entry(cbss=O6, * new=O1): O6 takes B, O1 loses beacon_ies but stays linked (it has a member), and M1 still * points at B. * E AP stops, station disconnects (drops the cbss ref). AP restarts on ch1 with non-hidden * "hidnet" beacons: these refresh only M1 (exact SSID, early-return branch, no repoint). * A FLUSH scan expires O6 (ts older than the scan) -> bss_free(O6) -> kfree_rcu(B). * GET_SCAN dump reads M1->beacon_ies (nl80211_send_bss) -> use after free expected. */ #define _GNU_SOURCE #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifndef NLA_F_NESTED #define NLA_F_NESTED (1 << 15) #endif #ifndef SOL_NETLINK #define SOL_NETLINK 270 #endif #define ALIGN4(x) (((x) + 3) & ~3) #define REQ_ACK (NLM_F_REQUEST | NLM_F_ACK) static const uint8_t AP_MAC[6] = {0x02, 0xaa, 0x00, 0x00, 0x00, 0x01}; static const uint8_t STA_MAC[6] = {0x02, 0xaa, 0x00, 0x00, 0x00, 0x02}; static const uint8_t BCAST[6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; static const uint8_t RATES[8] = {0x82, 0x84, 0x8b, 0x96, 0x0c, 0x12, 0x18, 0x24}; static int nlfam, mlme_gid; static int ctl_fd = -1, apfd = -1, evfd = -1; static int AP_IDX, STA_IDX; static int auth_rsp_sent, assoc_rsp_sent; static uint8_t ch_of(uint32_t freq) { return (uint8_t)((freq - 2407) / 5); } /* ---------- netlink message building ---------- */ static unsigned char mb[8192]; static int ml; static unsigned char rb[8192]; static int rep_len; static void msg_begin(uint8_t cmd, uint16_t type, uint16_t flags) { memset(mb, 0, 20); struct nlmsghdr *nh = (void *)mb; nh->nlmsg_type = type; nh->nlmsg_flags = flags; struct genlmsghdr *gh = (void *)(mb + 16); gh->cmd = cmd; gh->version = 1; ml = 20; } static void msg_add(uint16_t type, const void *data, int dlen) { struct nlattr *a = (void *)(mb + ml); a->nla_type = type; a->nla_len = 4 + dlen; if (dlen) memcpy(mb + ml + 4, data, dlen); ml += ALIGN4(4 + dlen); } static void msg_u32(uint16_t type, uint32_t v) { msg_add(type, &v, 4); } static int nest_begin(uint16_t type) { int off = ml; struct nlattr *a = (void *)(mb + ml); a->nla_type = type | NLA_F_NESTED; a->nla_len = 4; ml += 4; return off; } static void nest_end(int off) { struct nlattr *a = (void *)(mb + off); a->nla_len = ml - off; } static int nl_send(int fd) { struct nlmsghdr *nh = (void *)mb; struct sockaddr_nl sa; nh->nlmsg_len = ml; memset(&sa, 0, sizeof(sa)); sa.nl_family = AF_NETLINK; if (sendto(fd, mb, ml, 0, (void *)&sa, sizeof(sa)) != ml) return -errno; return 0; } /* Send the built message and wait for its ack. The first data reply is kept in rb. */ static int nl_xact(int fd) { static unsigned char in[16384]; int r, n; rep_len = 0; r = nl_send(fd); if (r) return r; for (;;) { n = recv(fd, in, sizeof(in), 0); if (n < 0) return -errno; for (struct nlmsghdr *nh = (void *)in; NLMSG_OK(nh, n); nh = NLMSG_NEXT(nh, n)) { if (nh->nlmsg_type == NLMSG_ERROR) { struct nlmsgerr *e = NLMSG_DATA(nh); return e->error; } if (nh->nlmsg_type == NLMSG_DONE) return 0; if (rep_len == 0 && nh->nlmsg_len <= sizeof(rb)) { memcpy(rb, nh, nh->nlmsg_len); rep_len = nh->nlmsg_len; } } } } /* ---------- attribute iteration ---------- */ struct it { const unsigned char *p; int left; }; static int it_next(struct it *s, uint16_t *type, const unsigned char **data, int *dlen) { const struct nlattr *n; int adv; if (s->left < 4) return 0; n = (const void *)s->p; if (n->nla_len < 4 || n->nla_len > s->left) return 0; *type = n->nla_type & 0x3fff; *data = s->p + 4; *dlen = n->nla_len - 4; adv = ALIGN4(n->nla_len); if (adv > s->left) adv = s->left; s->p += adv; s->left -= adv; return 1; } static const unsigned char *attr_find(const unsigned char *p, int len, uint16_t type, int *dlen) { struct it s = {p, len}; uint16_t t; const unsigned char *d; int dl; while (it_next(&s, &t, &d, &dl)) if (t == type) { *dlen = dl; return d; } *dlen = 0; return NULL; } static long ms_since(const struct timespec *t0) { struct timespec t; clock_gettime(CLOCK_MONOTONIC, &t); return (t.tv_sec - t0->tv_sec) * 1000L + (t.tv_nsec - t0->tv_nsec) / 1000000L; } static int nl_open(void) { struct sockaddr_nl sa; struct timeval tv = {5, 0}; int fd = socket(AF_NETLINK, SOCK_RAW | SOCK_CLOEXEC, NETLINK_GENERIC); if (fd < 0) { perror("socket netlink"); exit(1); } memset(&sa, 0, sizeof(sa)); sa.nl_family = AF_NETLINK; if (bind(fd, (void *)&sa, sizeof(sa))) { perror("bind netlink"); exit(1); } setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)); return fd; } static int get_family(void) { const unsigned char *g; int l, gl; struct it top; uint16_t ty, ty2; const unsigned char *d, *d2; int dl, dl2; int rc; msg_begin(CTRL_CMD_GETFAMILY, GENL_ID_CTRL, REQ_ACK); msg_add(CTRL_ATTR_FAMILY_NAME, "nl80211", 8); rc = nl_xact(ctl_fd); if (rc) { printf("getfamily rc=%d\n", rc); return -1; } g = attr_find(rb + 20, rep_len - 20, CTRL_ATTR_FAMILY_ID, &l); nlfam = g ? *(const uint16_t *)g : 0; g = attr_find(rb + 20, rep_len - 20, CTRL_ATTR_MCAST_GROUPS, &gl); if (g) { top.p = g; top.left = gl; while (it_next(&top, &ty, &d, &dl)) { struct it grp = {d, dl}; const unsigned char *nm = NULL; int nml = 0; uint32_t gid = 0; while (it_next(&grp, &ty2, &d2, &dl2)) { if (ty2 == CTRL_ATTR_MCAST_GRP_NAME) { nm = d2; nml = dl2; } if (ty2 == CTRL_ATTR_MCAST_GRP_ID && dl2 >= 4) memcpy(&gid, d2, 4); } if (nm && nml >= 5 && !strncmp((const char *)nm, "mlme", 4)) mlme_gid = gid; } } return nlfam ? 0 : -1; } static int new_iface(uint32_t wiphy, uint32_t type, const char *name) { int rc, l; const unsigned char *p; uint32_t idx = 0; msg_begin(NL80211_CMD_NEW_INTERFACE, nlfam, REQ_ACK); msg_u32(NL80211_ATTR_WIPHY, wiphy); msg_u32(NL80211_ATTR_IFTYPE, type); msg_add(NL80211_ATTR_IFNAME, name, strlen(name) + 1); rc = nl_xact(ctl_fd); p = attr_find(rb + 20, rep_len - 20, NL80211_ATTR_IFINDEX, &l); if (p && l >= 4) memcpy(&idx, p, 4); printf("new_iface %s wiphy=%u type=%u rc=%d ifindex=%u\n", name, wiphy, type, rc, idx); return (int)idx; } /* ---------- frame builders ---------- */ static int mk_hdr(unsigned char *f, uint16_t fc, const uint8_t *da, const uint8_t *sa, const uint8_t *bssid) { memset(f, 0, 24); f[0] = fc & 0xff; f[1] = fc >> 8; memcpy(f + 4, da, 6); memcpy(f + 10, sa, 6); memcpy(f + 16, bssid, 6); return 24; } static int ie_put(unsigned char *p, int id, const void *d, int dl) { p[0] = id; p[1] = dl; if (dl) memcpy(p + 2, d, dl); return 2 + dl; } static int beacon_fixed(unsigned char *p) { memset(p, 0, 8); p[8] = 100; /* interval 100 TU */ p[9] = 0; p[10] = 0x01; /* ESS */ p[11] = 0; return 12; } /* Beacon from AP_MAC on channel ch. slen 0 = hidden (zero-length SSID element). * csa_count >= 0 adds a CSA IE (mode 1, new channel 1, count csa_count). */ static int mk_beacon(unsigned char *f, uint8_t ch, const char *ssid, int slen, int csa_count) { int n = mk_hdr(f, 0x0080, BCAST, AP_MAC, AP_MAC); uint8_t csa[3]; n += beacon_fixed(f + n); n += ie_put(f + n, 0, ssid, slen); n += ie_put(f + n, 1, RATES, 8); n += ie_put(f + n, 3, &ch, 1); if (csa_count >= 0) { csa[0] = 1; csa[1] = 1; csa[2] = (uint8_t)csa_count; n += ie_put(f + n, 37, csa, 3); } return n; } /* Probe response with SSID "hidnet" from AP_MAC to the station, channel ch. */ static int mk_probe(unsigned char *f, uint8_t ch) { int n = mk_hdr(f, 0x0050, STA_MAC, AP_MAC, AP_MAC); n += beacon_fixed(f + n); n += ie_put(f + n, 0, "hidnet", 6); n += ie_put(f + n, 1, RATES, 8); n += ie_put(f + n, 3, &ch, 1); return n; } static int mk_auth_rsp(unsigned char *f, const uint8_t *sta) { int n = mk_hdr(f, 0x00b0, sta, AP_MAC, AP_MAC); f[24] = 0; /* open system */ f[25] = 0; f[26] = 2; /* seq 2 */ f[27] = 0; f[28] = 0; /* status success */ f[29] = 0; return n + 6; } static int mk_assoc_rsp(unsigned char *f, const uint8_t *sta) { int n = mk_hdr(f, 0x0010, sta, AP_MAC, AP_MAC); f[24] = 0x01; /* capability */ f[25] = 0x00; f[26] = 0; /* status success */ f[27] = 0; f[28] = 0x01; /* AID 1 with the two top bits set */ f[29] = 0xc0; n += 6; n += ie_put(f + n, 1, RATES, 8); return n; } /* ---------- nl80211 operations ---------- */ static int send_ap_frame(const unsigned char *f, int fl, uint32_t freq, const char *tag) { int rc; msg_begin(NL80211_CMD_FRAME, nlfam, REQ_ACK); msg_u32(NL80211_ATTR_IFINDEX, AP_IDX); msg_u32(NL80211_ATTR_WIPHY_FREQ, freq); msg_add(NL80211_ATTR_FRAME, f, fl); rc = nl_xact(ctl_fd); if (tag) printf("ap tx %s len=%d rc=%d\n", tag, fl, rc); return rc; } /* Answer the station's auth and assoc requests as the AP (AP mode does not do it itself). */ static void serve_ap(int ms, int *done_flag) { struct timespec t0; static unsigned char eb[16384]; clock_gettime(CLOCK_MONOTONIC, &t0); while (!*done_flag && ms_since(&t0) < ms) { struct pollfd p = {apfd, POLLIN, 0}; int n; if (poll(&p, 1, 100) <= 0) continue; n = recv(apfd, eb, sizeof(eb), 0); if (n <= 0) continue; for (struct nlmsghdr *nh = (void *)eb; NLMSG_OK(nh, n); nh = NLMSG_NEXT(nh, n)) { struct genlmsghdr *gh = (void *)((unsigned char *)nh + 16); const unsigned char *fr; int fl; uint16_t fc; unsigned char rsp[128]; int rl = 0; if (gh->cmd != NL80211_CMD_FRAME) continue; fr = attr_find((unsigned char *)nh + 20, nh->nlmsg_len - 20, NL80211_ATTR_FRAME, &fl); if (!fr || fl < 28) continue; fc = fr[0] | (fr[1] << 8); printf("ap rx fc=0x%04x len=%d algo/seq=%u/%u\n", fc, fl, fr[24] | (fr[25] << 8), fr[26] | (fr[27] << 8)); if (fc == 0x00b0 && !auth_rsp_sent && (fr[26] | (fr[27] << 8)) == 1) { rl = mk_auth_rsp(rsp, fr + 10); send_ap_frame(rsp, rl, 2437, "auth"); auth_rsp_sent = 1; } else if (fc == 0x0000 && !assoc_rsp_sent) { rl = mk_assoc_rsp(rsp, fr + 10); send_ap_frame(rsp, rl, 2437, "assoc"); assoc_rsp_sent = 1; } } } } static int trigger_scan(uint32_t freq, int flush) { int off; msg_begin(NL80211_CMD_TRIGGER_SCAN, nlfam, REQ_ACK); msg_u32(NL80211_ATTR_IFINDEX, STA_IDX); off = nest_begin(NL80211_ATTR_SCAN_FREQUENCIES); msg_u32(1, freq); nest_end(off); if (flush) msg_u32(NL80211_ATTR_SCAN_FLAGS, NL80211_SCAN_FLAG_FLUSH); return nl_xact(ctl_fd); } static int start_ap(uint32_t freq, const char *ssid, int hidden) { unsigned char head[256]; int hl, rc; uint8_t ch = ch_of(freq); hl = mk_beacon(head, ch, ssid, hidden ? 0 : (int)strlen(ssid), -1); msg_begin(NL80211_CMD_START_AP, nlfam, REQ_ACK); msg_u32(NL80211_ATTR_IFINDEX, AP_IDX); msg_add(NL80211_ATTR_BEACON_HEAD, head, hl); msg_u32(NL80211_ATTR_BEACON_INTERVAL, 100); msg_u32(NL80211_ATTR_DTIM_PERIOD, 2); msg_u32(NL80211_ATTR_WIPHY_FREQ, freq); msg_u32(NL80211_ATTR_CHANNEL_WIDTH, NL80211_CHAN_WIDTH_20_NOHT); msg_add(NL80211_ATTR_SSID, ssid, strlen(ssid)); if (hidden) msg_u32(NL80211_ATTR_HIDDEN_SSID, NL80211_HIDDEN_SSID_ZERO_LEN); rc = nl_xact(ctl_fd); printf("start_ap %u ssid=%s hidden=%d rc=%d\n", freq, ssid, hidden, rc); return rc; } /* AP channel switch to new_freq with a 5-beacon countdown. The countdown beacons use a * non-hidden "hidnet" head on head_ch; the beacons after the switch use a hidden zero-SSID head * (post_hidden) or a non-hidden "hidnet" head on the new channel. */ static int chan_switch(uint32_t new_freq, uint8_t head_ch, int post_hidden) { unsigned char head_csa[256], head_after[256], tail[8]; int hl_csa, hl_after, rc, o; uint16_t off = 4; /* counter byte inside the CSA IE tail: 37,3,mode,new,count */ hl_csa = mk_beacon(head_csa, head_ch, "hidnet", 6, -1); if (post_hidden) hl_after = mk_beacon(head_after, ch_of(new_freq), NULL, 0, -1); else hl_after = mk_beacon(head_after, ch_of(new_freq), "hidnet", 6, -1); tail[0] = 37; tail[1] = 3; tail[2] = 1; /* mode */ tail[3] = ch_of(new_freq); /* new channel */ tail[4] = 5; /* count */ msg_begin(NL80211_CMD_CHANNEL_SWITCH, nlfam, REQ_ACK); msg_u32(NL80211_ATTR_IFINDEX, AP_IDX); msg_u32(NL80211_ATTR_WIPHY_FREQ, new_freq); msg_u32(NL80211_ATTR_CHANNEL_WIDTH, NL80211_CHAN_WIDTH_20_NOHT); msg_u32(NL80211_ATTR_CH_SWITCH_COUNT, 5); msg_add(NL80211_ATTR_BEACON_HEAD, head_after, hl_after); o = nest_begin(NL80211_ATTR_CSA_IES); msg_add(NL80211_ATTR_BEACON_HEAD, head_csa, hl_csa); msg_add(NL80211_ATTR_BEACON_TAIL, tail, 5); msg_add(NL80211_ATTR_CNTDWN_OFFS_BEACON, &off, 2); nest_end(o); rc = nl_xact(ctl_fd); printf("channel_switch %u rc=%d\n", new_freq, rc); return rc; } static int reg_frame(uint16_t fc) { int rc; msg_begin(NL80211_CMD_REGISTER_FRAME, nlfam, REQ_ACK); msg_u32(NL80211_ATTR_IFINDEX, AP_IDX); msg_add(NL80211_ATTR_FRAME_TYPE, &fc, 2); msg_add(NL80211_ATTR_FRAME_MATCH, NULL, 0); rc = nl_xact(apfd); printf("register_frame 0x%04x rc=%d\n", fc, rc); return rc; } static int do_auth(void) { msg_begin(NL80211_CMD_AUTHENTICATE, nlfam, REQ_ACK); msg_u32(NL80211_ATTR_IFINDEX, STA_IDX); msg_add(NL80211_ATTR_MAC, AP_MAC, 6); msg_u32(NL80211_ATTR_AUTH_TYPE, NL80211_AUTHTYPE_OPEN_SYSTEM); msg_add(NL80211_ATTR_SSID, NULL, 0); msg_u32(NL80211_ATTR_WIPHY_FREQ, 2437); return nl_xact(ctl_fd); } static int do_assoc(void) { msg_begin(NL80211_CMD_ASSOCIATE, nlfam, REQ_ACK); msg_u32(NL80211_ATTR_IFINDEX, STA_IDX); msg_add(NL80211_ATTR_MAC, AP_MAC, 6); msg_add(NL80211_ATTR_SSID, NULL, 0); msg_u32(NL80211_ATTR_WIPHY_FREQ, 2437); return nl_xact(ctl_fd); } static int stop_ap(void) { msg_begin(NL80211_CMD_STOP_AP, nlfam, REQ_ACK); msg_u32(NL80211_ATTR_IFINDEX, AP_IDX); return nl_xact(ctl_fd); } static int disconnect(void) { uint16_t reason = 3; msg_begin(NL80211_CMD_DISCONNECT, nlfam, REQ_ACK); msg_u32(NL80211_ATTR_IFINDEX, STA_IDX); msg_add(NL80211_ATTR_REASON_CODE, &reason, 2); return nl_xact(ctl_fd); } /* Dump the station's scan cache and print each BSS (bssid and frequency). */ static void dump_scan(const char *tag) { static unsigned char dbuf[65536]; int n, cnt = 0, done = 0; msg_begin(NL80211_CMD_GET_SCAN, nlfam, NLM_F_REQUEST | NLM_F_DUMP); msg_u32(NL80211_ATTR_IFINDEX, STA_IDX); if (nl_send(ctl_fd)) { printf("%s: dump send failed\n", tag); return; } while (!done) { n = recv(ctl_fd, dbuf, sizeof(dbuf), 0); if (n <= 0) break; for (struct nlmsghdr *nh = (void *)dbuf; NLMSG_OK(nh, n); nh = NLMSG_NEXT(nh, n)) { const unsigned char *at, *bss, *bid, *fq; int alen, bl, bbl = 0, ffl = 0; uint32_t freq = 0; if (nh->nlmsg_type == NLMSG_DONE || nh->nlmsg_type == NLMSG_ERROR) { done = 1; break; } at = (unsigned char *)nh + 20; alen = nh->nlmsg_len - 20; bss = attr_find(at, alen, NL80211_ATTR_BSS, &bl); if (!bss) continue; cnt++; bid = attr_find(bss, bl, NL80211_BSS_BSSID, &bbl); fq = attr_find(bss, bl, NL80211_BSS_FREQUENCY, &ffl); if (fq && ffl >= 4) memcpy(&freq, fq, 4); { int sl = 0, ssl = 0, bil = 0, st_l = 0, seen_l = 0; const unsigned char *ies, *st, *seen, *bi; const unsigned char *ssid = NULL; int ssid_len = -1; uint32_t status = 0, seen_ms = 0; ies = attr_find(bss, bl, NL80211_BSS_INFORMATION_ELEMENTS, &sl); if (ies) for (int k = 0; k + 2 <= sl && ies[k] == 0 && k + 2 + ies[k + 1] <= sl; ) { ssid = ies + k + 2; ssid_len = ies[k + 1]; break; } st = attr_find(bss, bl, NL80211_BSS_STATUS, &st_l); if (st && st_l >= 4) memcpy(&status, st, 4); seen = attr_find(bss, bl, NL80211_BSS_SEEN_MS_AGO, &seen_l); if (seen && seen_l >= 4) memcpy(&seen_ms, seen, 4); bi = attr_find(bss, bl, NL80211_BSS_BEACON_IES, &bil); printf("%s: bss %d bssid=%02x:%02x:%02x:%02x:%02x:%02x freq=%u ssid_len=%d" " status=%u presp=%d beacon_ies=%d(len %d) seen_ms=%u\n", tag, cnt, bid && bbl >= 6 ? bid[0] : 0, bid && bbl >= 6 ? bid[1] : 0, bid && bbl >= 6 ? bid[2] : 0, bid && bbl >= 6 ? bid[3] : 0, bid && bbl >= 6 ? bid[4] : 0, bid && bbl >= 6 ? bid[5] : 0, freq, ssid_len, status, attr_find(bss, bl, NL80211_BSS_PRESP_DATA, &sl) != NULL, bi != NULL, bil, seen_ms); (void)ssid; } } } printf("%s: %d entries\n", tag, cnt); } static void drain_mlme(void) { static unsigned char eb[16384]; for (;;) { struct pollfd p = {evfd, POLLIN, 0}; int n; if (poll(&p, 1, 0) <= 0) return; n = recv(evfd, eb, sizeof(eb), 0); if (n <= 0) return; for (struct nlmsghdr *nh = (void *)eb; NLMSG_OK(nh, n); nh = NLMSG_NEXT(nh, n)) { struct genlmsghdr *gh = (void *)((unsigned char *)nh + 16); const unsigned char *st; int sl = 0; if (nh->nlmsg_type != nlfam) continue; st = attr_find((unsigned char *)nh + 20, nh->nlmsg_len - 20, NL80211_ATTR_STATUS_CODE, &sl); printf("mlme event cmd=%u status=%d\n", gh->cmd, st && sl >= 2 ? st[0] | (st[1] << 8) : -1); } } } /* Send probe responses from the AP on freq for ms milliseconds. */ static void ap_probe_burst(int ms, uint32_t freq) { struct timespec t0; unsigned char f[256]; int n; clock_gettime(CLOCK_MONOTONIC, &t0); do { n = mk_probe(f, freq == 2437 ? 6 : 1); send_ap_frame(f, n, freq, NULL); usleep(20000); } while (ms_since(&t0) < ms); } int main(void) { int rc; setvbuf(stdout, NULL, _IONBF, 0); printf("repro: start\n"); ctl_fd = nl_open(); apfd = nl_open(); evfd = nl_open(); if (get_family()) { printf("repro: no nl80211 family\n"); return 0; } if (mlme_gid) setsockopt(evfd, SOL_NETLINK, NETLINK_ADD_MEMBERSHIP, &mlme_gid, sizeof(mlme_gid)); printf("repro: nl80211 family=%d mlme group=%d\n", nlfam, mlme_gid); AP_IDX = new_iface(0, NL80211_IFTYPE_AP, "hap0"); STA_IDX = new_iface(1, NL80211_IFTYPE_STATION, "hsta0"); { /* MACs and link state for the two interfaces */ int s = socket(AF_INET, SOCK_DGRAM, 0); struct ifreq ifr; const char *names[2] = {"hap0", "hsta0"}; const uint8_t *macs[2] = {AP_MAC, STA_MAC}; for (int i = 0; i < 2; i++) { memset(&ifr, 0, sizeof(ifr)); strncpy(ifr.ifr_name, names[i], IFNAMSIZ - 1); ifr.ifr_hwaddr.sa_family = 1; /* ARPHRD_ETHER */ memcpy(ifr.ifr_hwaddr.sa_data, macs[i], 6); if (ioctl(s, SIOCSIFHWADDR, &ifr)) printf("set mac %s errno=%d\n", names[i], errno); if (ioctl(s, SIOCGIFFLAGS, &ifr)) printf("getflags %s errno=%d\n", names[i], errno); ifr.ifr_flags |= IFF_UP; if (ioctl(s, SIOCSIFFLAGS, &ifr)) printf("setflags %s errno=%d\n", names[i], errno); } close(s); } /* Stage A: owner O1 (hidden zero-SSID AP beacons on ch1) and member M1 (hidnet probe responses). */ printf("stage A: owner and member on ch1\n"); rc = start_ap(2412, "hidnet", 1); reg_frame(0x00b0); reg_frame(0x0000); usleep(300000); for (int r = 0; r < 8; r++) { trigger_scan(2412, 0); ap_probe_burst(250, 2412); usleep(50000); } dump_scan("A"); /* Stage A2: owner O11 (hidden zero-SSID AP beacons on ch11), used by the second CSA. */ printf("stage A2: owner on ch11\n"); stop_ap(); rc = start_ap(2462, "hidnet", 1); reg_frame(0x00b0); reg_frame(0x0000); usleep(300000); for (int r = 0; r < 6; r++) { trigger_scan(2462, 0); usleep(300000); } dump_scan("A2"); /* Stage B: AP restarts on ch6, station scans ch6 for entry O6. */ printf("stage B: AP on ch6\n"); stop_ap(); rc = start_ap(2437, "hidnet", 1); reg_frame(0x00b0); reg_frame(0x0000); usleep(300000); for (int r = 0; r < 6; r++) { trigger_scan(2437, 0); usleep(300000); } dump_scan("B"); /* Stage C: associate to the hidden AP on ch6. */ printf("stage C: associate\n"); auth_rsp_sent = assoc_rsp_sent = 0; rc = do_auth(); printf("auth rc=%d\n", rc); serve_ap(4000, &auth_rsp_sent); usleep(300000); rc = do_assoc(); printf("assoc rc=%d\n", rc); serve_ap(4000, &assoc_rsp_sent); usleep(1000000); drain_mlme(); dump_scan("C"); /* Stage D: CSA countdown from the AP (SET_BEACON with a CSA IE announcing ch1). */ printf("stage D: CSA to ch1\n"); rc = chan_switch(2412, 6, 0); usleep(2000000); drain_mlme(); dump_scan("D"); /* Stage D2: second CSA, to ch11 where O11 is. The leaked cbss (O6) takes O11's IEs and * kfree_rcu()s its own old blob B, which M1 still points at. */ printf("stage D2: second CSA to ch11\n"); usleep(1000000); rc = chan_switch(2462, 1, 1); usleep(2000000); drain_mlme(); dump_scan("D2"); usleep(1000000); dump_scan("D3"); printf("repro: done\n"); return 0; } --===============8455935433251778651== Content-Type: application/gzip Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="config.gz" MIME-Version: 1.0 H4sICJnt/WoAAy5jb25maWcAlDzLdtu4kvv+Ch33pnuhXMt2ezJnjhcQCUqISIINkLLkDY9aph3NtaVcSU4ns7jffqsAPgAQdDJZdEdVhVeh3gXm119+HZG38+F1c95tNy8v30fP1b46bs7V4+hp91L9zyjko5TnIxqy/AMQx7v927d/fPt4O/qvDzcfLsfH7fVoUR331csoOOyfds9vMHh32P/y6y8BTyM2K4OgXFIhGU/LnK7yu4vn7Xb0W/HX2/78Nppcf7iGWW7f1M+rf1/BnDcfJr/XiAtjEibLWRDcfW9As27iu8n15fXlZUsck3TW4lowkWqOtOjmAFBDdnVz1c0Qh0g6jcKOFEB+UgPRAkUhc2N3k8vJpYOL42XSTXgNBNcegoR84sIgM9gRkLSMWbrodgjAORyIyKSc8ZyXvMizIh/G54yGPaKc81iWssgyLvJS0Fh4J2AprE09KFkkfXDKy0zwiMW0jNKS5Lk9Kc/y8oEKDrOyvMxIGDK4vynL5d3FhUMHUwEe+DHr40JGZimXOQvgBHN+XwJai9wPKdV5cNVgTljaHyBzwYK8jGK6KokQZA1bGz+dzsfd9jx+eqm+jTfH4+b76e7aHUniGOaXORe0DElOSkECKuGUgiT+43kH4HL7wxhU9PD3+HQ+HKvx4+a8GR832+p0YQgpzhJxEdByJniRqekCkqP8XIzHT4fjtho/Hw9vX9RcW6Ws7njYxT0RaSnuV6Wks4SmeBXjMWzg781xPz7+/W18qp5fq/355J7gvr4hKmXJIzhnsAAxS2gypQLmuMdDPD4eq9NpfHgaf9ls/1k9jl+r17+qo28qOEpC8pKDDkTIlxTMyCITLM2jPveMAbkoUn3sHw8JaUSKOEdxkbkWwiKVJKID5GBdYpSVjMOc7akeN/vnl93+efzlsNufPadZxqSMiZhRUeZzgtdx//VlM37ZHJ+r4/j8ebO/m1w4mnOPgpfOeNZyoKc5uKUC 95GwlOTAaz1EnYORmD3Ul9/bDxUCjEtIQZf0QByBu6qOx8Px7rE67Z736AnGu/3u3B+eFgmyrLFOOHD/9jreHvZfq+PJFCtjp7U8gEsByYSFaVizr5aE/eEMggkLV48/IQ71WJBqcGDjA6z7BPrhG9jysROMejAq8f758GV8Pr7t+/qAdraQtFxQmgGH1NIxWXfXoM01XlaRphRUVRKxhmVIKpMiB831UCpTeM/yeZkW8SAB/D/AjfsIZCEzFjBeSACmOUtoKdfJlMcozerqQZi7gRmZc5ix56iUyIsiAGtjUDPxZ3nPheFbpgWLQ7VKTqYwkQTvYDiNuaAE5SdCGw4kEodCCPDraKbCiZfRqTq/femCAqVkNF2CMQUuswQE7/oKyNttJRlyANiXj3anEUgFztCM1qJr+GawcHErhxc+cEmKnDvnKSWJTecwJ0u8Z5HSuJw9sKwjNzFTwFz5UfFDQvyY1cPQCD6EuPEjHmRuRCX2blv+mVs1+ecS4Ibfw68e3h/N30ffvIfGg3jutjHG2hhduOA5eO2UQIxx8dv+sK9+bwnkWi5ZZsSHNQD/H+RxH44yRgwhzrhkqzL5s6AF9UO7qdqz3JM8mJcK6zlLIDh4QfB9HCwChD0kmBuxZwEhtXPHRMBsCoFLget2yDuoUi7Q09Hp7a/T99O5eu2Ua0ZTCuGKUmOIu6bGcUwUBj5+DI0iGuQMNxRFEITKRZ8uo6kK04DeP0nCZkLbWeOMIgQUWK97CC0lzGDbnJAnGH15YOWcUYHcWfcXSyR7ZxcEDP+qiYJMo2FS4WbEUocLCQ+pvQUVToW1lYMzG7IEYRz4Br16KxTmzCGdFrNI2opQ7R9Hhyfn+rrshQcLyQsM4ZR4hdxYUUmISaL0xEbfE4jXLKLaPNsxe7NNRUiXKsh7D1lOBSdhQGT+k2QlC+P31wMhAcscfip+NGcAoWxMw58iGj5owsFJZxBUG8i5QLcmkEUiQTMDvsVc SOmltgJBVpSKWCoX57jIn6GpExKMDoKFJUkupuGd0vN89woRlU/VIYNZlDyloMsGByHemT+ggUuU9rWCCcAMOMFDFnislR5Vr9uO0dCoiOOhIQav2GyOulRzwJxGc4cUq1ouvQrRO2frrrPIuREKoPJTz4A24HJBJEk9etE6km68YjH89PEXqXqmuBvaHq9ZlsT3kBvCjXiY1dA0OzAtI+KKFJKUZYeOIhsfiHWmYhhr1QxydNC3gfVimfT23fKm5bt9+FagBaUJhM8qVnJYiSFog4/Jw9q6ag337MgZ4UBBfVPrPsFPUMyTc9rSgHAFc1BxVRxwZ7B8TTMiXEO4wMy4QE0QQHrd3D3o7D/yzemfozPI32gDPDmdN+fTaLPdHt72Z8gOHIVDJSeB2q9W4vbsSyZyB43mxxsHoXtQIXVH67tFGaITx7wCCW2pc3Dl8tozA9ohmROTYco0hRTymGZOE7HywBgfOHEmmVeXf4Kpre0DfjHJ4yZaUJcigmIkPQYPrrUEXP+iNbDdF/ws6QrMnU8Q1SzSmkZxSY2q3YVhTil6/wbvGeKC0Ig7u8SJ4RLiuDPLBkatIOksmMbMdIWIUy7J1FabM4Y8LfRf/MK2mEMMAEbZw42YY0IEhm7Oovxu8tGE490kZGXir0xVZ2kOwpGGdOWZWJnkAjJMnTNqxUPz31yy3H6uHt9equPoqdqc347VSSukHl4EMUkyxVOviHlG942UMh48T7kZESh0XeSUkIMnpJySmKSB5ZM7pzHFOAw2X6QJgQ3F0zKKC2kE83W5BrgxufpogVmSxZCo52UElw8hJC9mc6w87F6/vOy2u/P4afPycv58PLw9f777wyxdJBIEOKepVKn8xfjp9TSuvp2rPdZWurrbLAgml6pwiHXJcgo6GkprC4O4mUa+X2N6n8DmZHv+LnyweOuRkVoqIDUy68aqdmnVL2ZUO4haFyxC4O0SS1nrFIJ36ZV/SMICr3mNF/Uk 7up6ZwazOmB5TyHSMfQ0IkyU9qhuixGExCQN71mYz717A5dhjB3kUZKUAQt728yYdd0aKEJViXD5FAIbfHlqzUWwig9U9CabFzMKMm/As0LS3IrvalC5nAzPH9IlC3q3jENth9McDGStB7QiwRqWMBn0gCrxMrw+DxYtiuRGmQarCZDHBWalrkCrYPpLdNMeQLkMpVHAwbKCSQUsERYA7sr6ndJc/+74OKfBQhWWMdbBJoBXZLREYE1LHcnDc0GtKiXKOfBfpYvCTLvxN0lARnWqaJRcROhUwQDgFL8AYte8AGCWuhSeO79vrN91PauLaThXlXjHkXnNTZCEmOmB4PJEDdRUhizUBOjJ7gWYbhZSEpcxTe8ml1eTPhMyXQmgZYI3bNlBDgFmwh4olgOUbGIpOg2sZMklk/AXn8MNSy6yOUlVm6VbxYbDNpc0vrtQ5Xi7SFmwcHJrlbSCPAZvEVAVBesAxNwYUOAV60xmyFNngcwWcDYIxPBw5vjBSMrZSQKZC0OxNzYHxgNLSP08KoKTWhUCnSS2yaMVZBiibOo1jaMmlm/Ie6dolisgw3Z+gkb2IJCEYcoB/nzu4pKMG/tXTNMIwaeFxLZRHd1YowaQFCYz65LYhonNlrNihAlQdQ4TIOdg0A1nzExjxMtC2PFMuGSSNvdgcBi7cxAhMPPaFkFiqr6kVokLf5cSAhvaxSg+w49uHXOP/uUvcAvrxDJ+DQxC4TgaqP23NHZ1tIn3uqPAkmngyIZtPhKJxgB2llNstWcZcEs614uKXrbFMRWd1s8dsuqo+k77bTWiX7EVOiIQlwaY3VTHU5ey2FO0h1UOSiOxv7RMVI3SG+j+5IqGOcATqeYxBGwsYgFxk2PsxlvCoUyGcjzGQb9VW5W6bY+b02czRm/uV4CS1NVTg83LBNmu+kHGhdMVde9DwSwJUETY/RpoHSD6U5H4PJ7eTFiYcqthc55nsWk1NBjzmro4L0g6gwDg4+S/ r0y2D5xfcSfefa1GxZfHzVmnt5p6Dn/lX6ujmcfoXaOxw/jZe8M/mqyhs9tpzXFub6ZmJWz18RZA1m/T4euGH7qJkAY8NJVevwapu6zgeV6ebm/G3z7ejm9vzK7aIqRZo0aGMcpJsNCpbw+XJIWjhQlmUiLVpRysA99dfXyPgKywQ+gl0J2cbqKBeSwymG5y24b2TcFekjI0w5m2ciyLpA+1HJEBVLGXap/ULwSke3bIxWqPW0Zh4FmPxGyqCl+hHca1dg7zclxm5eLYlIpUdzLAnUo2jfv2T2LzxofGHpMiMu20hHhEzknI77EmCVH+3eW3xyf4s71s/1g2E88cl/nK7Uu0hrdQXSmDKxG4fUpEvA6wAWO6tGymiwcqFpJ3f2jdy46HbXU6HY6j8/cvWmP6xkmahgB1YnVFMmaZG4QCG/DxQ2LXsQyCJFNdHnecvgEIvETstVVIAxmVL59DlHKbISzsC7eQADPnYM6ywcmXMhlGFstBlL6ehIWDFDMehxGT/my1myLOpD/ZRhKSdEerMz8PJxiXUZlMmXn4BqY95AD7OieuDThk4HFhuhadIfEEKy8Q27e6aPj3NThfiIggTp8V1Cy7YdEZK7nmrhpYKSFM6LUwjJ3Nl6i+8RSMIXjfQPccO9ZQX5y0WCbuHnSjLyuwHwNqFed1tNhtaOm/n3ajP64tt6RNUa6d5BOwc84xLlHb8i5EAshRhtHT+Xr53vDaSoSrPk2XTamQTrEiVRbViEjbpzAkW0U95dH2F/g3cEtKFlLwfjpGrWubtyZJPBnG5WbFQd26MueE2tBg9dEBJHxpQ8BhsQRfUoE5iUjC4vXd7Y1JoLQA0rtEGrLLyPVVGVFwZ9bbBmUWkpXCgDbo2oZVt0HF0azvg0Fl+8D5emZGjg04gHCWFKKPeJgTvjKb+F072FM3nWdUC6pwYBQySfR/IjcYHSaWoZgREF3GIbbwl/zISnoDxVSocpUO+sopnWHw4Ufi E4U/Jj1k3aMzbqrGdLFHXbMLMJ/k9g2pd0ll7YtaZcoY7DjMIfVf0MLxXNh9scgRKKiAeE0XGoDJC5rq4gm+sHBkLOh5LwBhUSSmMxKshxxfQF1RacCWqDRAfCAh5zwOPYvBRJ/AGJoraU9u5DSvh/3ufDha/TYjeaotRpE6+X6PQpAsfg8fYEZqccSkUY6L39uB+gBdu5fBmabC3+oeOLfJ0sltL6qnMoNQyYntIRDQyXWtNFamp6Uni/E/1KyGJCwQPNBvXTqVaYClUj5sLDuew0MaToectGWy6piJOYITMgFyUc6mWOKXruQEGcG8ImfqrbbfDSXqeTGoqmqQ+/S9MGN6pLchOl/SKmhj0EFI1/7rWFbFhHpd4omxW3RjKmw8dm3LhcqS1Qv1zrDHqJJxE62USxIXFAPuavN4afxxYlhc6V1dVnVlyH04PpMRosj6YoLGQz1Lb2KqjlAPN4QnF1ZUg79LyBNYzh68iqM2SRxpLhKzuty00KYOVUAdQP1+sEdYx7V679jzozrLXdC1m4BlANNvCG58gW0uV+oZGOY7P4iBO1JfXOehq9+hWlPJ2Wo4kMceQp1+qQzbswyNjCom/ADCYmpDmuqDYgzobWyjE7Yye10Iap4VQ/ps7nf+UE4uL73bBdTVH4Ooa3uUNd2l4f0f7iZGQqndKD7SMuXPTiebKtIwUlWU3qfICjHDB4Jusu2QSeY2iPsE+sHg+2TTB5ZgT1PV59Y/nvaTVdbyUTQ3PETlK48pivbzhyECZ4peNa0tSrTlC6Sr1dR4Wmn45PlaMgyCQKIF1hMmdhkB3zQFJK8Na1d1xiOq5sqUSF862c6rvi2Aea/s6oTeObohc9q6MIS9PF+zRpnVzsmueBpb751cAnxq4FWCphsFhtbXgwHzgKIQh2a1vOvg6C+QQFAgF1SGYKi7pFKRGNKfDF8tOPXsRZy5D7qU7YegFnNAEAY0m3fGc5P3ai2O7cZ0IyyJ7Bl1 GfdhgkKKkkLQWHg+YoP4CY24/hTMwuIHHSyto4YpSASmyapxB5HR3cX4dbd/3B2r7Xn81xGiq8/j7Wn85Vg97b65n4UEkekl1AORi/HT9gnID2eYYHfY3+Eb8/fH6S30R+rVR+qrrf99e/0yPm/+eql6n0tFSlKVeqs3HurbFzXgZH8NZBDHnJvEL4eDRRxBVKrrf/WXdAG4h8lkED1d41cqXTVUCXGP9Up6FErdmHmfXiC+G4JwYEacL1E6oH7Uoct75vOvPiGISsbtN7021pYhA1ekApNJlCYvXu09pFk+N9/kdhrbHW2wGmXMxqbZ9J3FGCQD76ClkFZkYKJiX7XJIJiFfhaLaAAhM5BfiD6nc+bFJwPjckL89Anj6oEbdZ5XGDTxJI+GbhCEwAxAPDtdTt5HXw0wdTrEATn131I+cHJpJhGNywM1KZvMRSe0h7+r4wgSu81zhR9IKoOJqcXo8AUNg1Gg7hXs9RM9o4apK/U9QP+lTjMLbWuPso+0v8Uw1pUpyfAFOdZp/RToIuunHF1M18ff+NyRQQahhiK9u3j5v0NrsLIEJAfZCFGe860iokAyjIikgdTl/S7xTlRorXD+umiiYmn11OfHpFiF8TxU7wj+5LoJUzdbddXGF5Ik1t6bZ0nWvsMlPiQJ+ybGpMJ+eCMA3nVqvjgPn3Bk/RrEgdS1te5bpj913QM//2EBo91jee+WMNabrVVS44tm7MgRFcAudjmlrzqIUt4AQxG+KNwwNME3d/V3UjgkC936WX0X+hSqyCP7rUhFmc+pSPAlEJuaLFA4xcCZN43Vq2SBKHuxqUJFWegrQOgTZszdhSPaCiboUj2zFCykvhYd0tg98xrk+9TIpCAut6Ykz6mV7yhokeemnVDAJWyGO7CIpL1d5N4PETRXrbcvCqRK3oKC2EnpoOpX7Vx0xTo/2v7EqJ42C+qL9Y5x4ANJgbMOmc0EVQni0AFrkXJXbVpg9T+A4HMhmnMY BhXZTJDQPdB7uJ490asGKFx8UBbh7zmBeGqIF4y7nVItr9OBEpwa6211apma9RQwncd5b3742+CW68Kcs2ZCfAM6G0EyalgaG16mdjuhRQyfMcxyf0Go4Sr83f3Yz7qXSBSDJ8yCPsejaD5Engi7Z5wlDLMEkFL/W6xaoBOnaobeoO6/NB/DjKJj9a+3ar/9PjptNy9WPb7RWTvSV1o840v1b3uU0qzYWej+J2ktGtXcnzU3FE2dAicy3l/+PwahX5AgA75eo29AGy94d2xSqjJVkTOfJ7Q4MPRw1KL5mX26+/PheRpSWCocXAlgdXXmx4u1RzQl5cmVlNHjcffVev7W1UCzXt9FCSD+YzZZgesMVFBVR8ZxAza8vQv18e615yWCJvMqn6Kp/ZEt2i4G/j/tbR8vK+X35eLju28htJDjS0lgNsvXg8QQ4NEQ4hjdYxUs9X9kr9a+0Z17OHWvsXb6vDlWj/2kozmKfl9QiEabzQ+3PAagvXH2+FLZ5sD9YrSBKamJIUHyhlIWVULTYnCKnPrKchaJ8T6iNfUa0jyhcE+ojuE+RkBCf7fuh0md/oj07dQARr+BDx5V5+2H341mJrhlXbkyonGAJYn+YeSdCoIPAiaXRgmvfqCGzWDDn2JDa+r8bhp7zRee/p3pXe/2m+P3EX19e9k4wqKeGZhdxY5hFqbVvxB2CMHK8NOiFQwjU99Tq7oKe23k8e4/0VCTYMO7wIYdVsPwHyf6T2lv1hw5jqwLvs+vkNXDtW6zrtOxKEKhO1YPDC4RSHETQUaE8oWmUqoyNa2UciTl6a7768cd4AKA7mTUmTKrzAz4BxA7HA5frJYOWtPmRk2XqneIY2qdHiirGP3GflvBgAWdRoU28LW3iAEozfJ4AjLQDBkiBqoiAwhq9XuyNLuMLmr47DrARHk1gRhotwwRchKxm0IM3oyHNT1NQk5JMo2Y6rXYKaOd2x3gkIQTiJt1+1Q6hvLvlIuKaZzW uakTfwoZe1N1D9Nb39XhGIDk7jSBOIVpfpjAdCpeE7jmpVOath4kMLIcNNA1h1u0TM27tayPRSXdh2D97wp9Fgwl1pYDo/u3h29PKNz/ia7XHn/AdoMHweB8ba9QMmHVX/Wb5iTAjytZ8u95rYKRIR0clsuUNMzb3YIzta+kYyTY7b1gjI7eIoZ0mcei1C9+pmynJaPqQRybykaWSxpbbN6SBmYlLcHBO13XvNSpGQdzx3komyDfuNrL+HgDS24bOg92MJF8pX1A2rO4QPXJEcOXLC/dDw/0qLUPjE58V6WNjzVUAw0Hkx/VO/EtsBRpvZVHzxiUG3xycQrv0urm0SXLbpxPC5gCqG6P72MOadBrOpX4jiIQrTWLwSpEjlyzWdCFehk0jBFQBaT9jFNa9xamfeFpHTXHZRHAtKCgSdGFwpyMYm9HyBcdOuQdYnpnTwpN9CRyefAbtqMqqwi/PDLJNfurvRIRYiXgkkqlWqDtOocAuKY32jIMsXlkTTxXEtsaIEQCJ9hn0gkRYrSHCUe90yoh96Rwne3oftEu5bStSn3cC+DPxUA/Wns6alx8aEcVOgeJSzNt/eIQG42hrAjQM6N0HbKhu1O4YDV+5Nz5WIQwxnDF1hOuWWc2f65x0rxY6iTL65E9H9EtHlvW/lhvoXe0mbBDU4o8BlmqGjogtbE17+9pBrPEsvxz7d7s6a9r4BUBXjyVnXWplNwdc+0qPQroFdsUtPEH0VGA6aQ+S9S4NZMrmn62tVT6aWNtxSPUzkTHvHJVNZz9e/gGzNedsshzd0zlDEJ5MMuiCAao1KaiJreJxaB/G6XtXISR49Wmmf16U6nRySgw+vnJ3w/1aQ7KtrLwlI0rDFPo1kapXLSllHuhl1SWu53XHgLNYsLnSgfRVEFrJjO0IKuGeo6qQ5prGVq/a39orStGApvFgYGnBkmGvnoi5EmozWWzM26WAbA/bBuK1uzn3vT7T97o+RYWnnQ7TVEa TRDzVeG8dByNbOBtpGNR4jLTfqwnATjypg05pI85O/GjgUBcDY7AYprVpQxm3FmEp5HloYxY2yRGWY1huQ6Y8ZXkshRDL0nu3gCsfomWvEoWRhQBF2lAVe45o5MT+vhB960wmZGLQvcXxJphccSn9HKt9KZCTu2WiDbA1LpRdKgsqoIOLJoVAonJzbEQJVlTmUXqRC/vBt0QtDrLoY+2wsZelgUVPscio4ibEG6axB6E6oeogFxkJ2LwwpNAX2fa5SQxDbBiSANIdkxdyDi1rwLWrtUOpJpvWZO6DDPWkOSj7Fy9gSpRrmFdyhViQoiiGrKCo37j4AzEuYU6f/XljSHum0yOkYtAj9P1ehKxWK2HkNbtk8Wfbz+hq3inisYBux+OdJop9muMdICzKhh4DUWuoeGGWIDeuVgyTF2hvVB1F4MegYeSFLtGuWLZE5ohaeieczfoJJZboY2YuD2XZv1xK3AnNJXW5+j1X5tjqbHH7aA8gNChtSCUqsfgTqBVUFvF3qOx2kdIbna9qZDZKVLfevR0uFy0usE2L97dZ2Efsq6gvZYung2KodV+pEg9CcOLRGtPMpxm7WWdpww8kPa7NOf6xZ4wjW8IWH3UgdDBDAVKx0DD3BiVXMYVpfcO0jyYEZkI6ngeuNZ57cUK5r5iCYjscBdBF2t30KWURjhwInHoRepw4jDNpIm0ASFxUW7vvHBRafdXLZrzs8Ovv9+/P365+Jf2kPHj7fWPp+bBujcTBFjzkbExV7A2TEWrfN26XRj5kl1VH3jguNoJc3L2t7r2waK+3I6S5+tRuqGsa92mlYvp1up4cAtA5A5WOrDAVRGitY/VxPPknN1OA6sVnduYp1TDLpirrlnRvGJbA9ARKxhHpg0G/eeYJ7SVtSO6JWtCjeouPV/KVaW95I9VVRZ+51M+pk3/WyTji7Eh45LEMBljGB0MJBFSInfcuSpDr4K4A9CdpYV0sNz3v/3yz/ffn17++f31 C0zY3x9/6T8AO24CnQN7ZgAnwV3ClKX4P+Uu09XJ29rejNTPVo0P1SvtwUL/Y8DGqe3MOSt7F3zAOaOzRdNetvVbtpU7QnvEoMZiS5uhd47PynBXOA/vDkYxz9BqdDMYDOvwOUtt134tAd06lmXMTSyEHbfU0Wo0XaACPJw5d2THiMzPTGmRRbItjHWl8PyIpFtZHOws9+hZiwB9cLVnn6NIpPWb798+nnAvuCj//GH76+wUeDuNVmpOySCThq5vV2+0OTOT+8d354tmQ03tWj0D0f4YxfYhrC3fG4xj0lxCHEV/JDky4EHLRdZ7HDUefKBEkekHFXwXccwUeuLN3dYWRbSEbXRLKh3Y3+tZclu/3pOpoRhfpc0IopeKgccxRye3zPBwLxLDnafa03VmfeMyr/jFUQJfxBBV5zO0jjtTgRKC3oVGDyEoXUe5tEbEroQNyoUKsIQhbRDmfrk40t8dpJscTBPzRfkH62IbOXpXPZfbeh2rt2GUNc+adkwBA6sfmtA1YW52WK/fr2Ze+J/Hh5/KfkgFZbvQ8W6MObgVaZSUyOwNbicUqWEKTSwGm8LLW6vIgRfqxmOwsYB0WdIvhMkYN8mOG04ospHSdjOaa4dqZPL4/fXtz4ukV7IZvK3ab1Sfm5/dPFEJhnt1cpfTILkvRHqj9okz0O1JnfV4+Bv3a2LKsVkc8wkWt7mkY7aMFEwHWhnLsPf/WhYmWguHtw08PstOsKWG+vP7dxV87KIJQfb6Zoy1jYBP3l88vH7/Dtv/7xgiCmZSnwsm0MX/ef/3/Y+L/3Xxf97uv5unUfvRgWapS1ch35Qg5LdNP1dH6qhdVz/f/07Wv52rsWmCfXOIGsflrS9p4/Ibe9vmyaF3FtALrJGKmfH5q7m908/IFhBfaODaRCtiKei28m/CkuY+sfKq32jyTdNz/YGvHT2SxxjTUcbH9lUUxY18qwvUQqv1NntaQVnBdz4XjK7tvTScgIk1uc6e dIA/UGLgOnIYIEwxjc7SOHt1BE7Ga0frDDbwTsNSCFzjanmI1bdL5era5APDE+p2oKujxvalMDV/1Ad0s9pXzt54u79qWBTuEE32ed22Om3zDLsMVTyUz/WSOlCbujQw1MstbQ7FpUjnPKMkcD4qOqCDMS0JadfQ3GRMdygBRLaHdoSlvJQTAYuIJLMdncSfwykBCwrts6gEFuVg3pZzP9d7QY1MQKhcEq464v5O2RYWdel6d8QHxuGj7Y0Z6KPThsbR0iF2guK3y9m148NkyofaIL23/TvmmZAo1R+49RlMbiW+8eKhG3Hjab6E2eUe5znesmFSt68fKkRolMWCUgdOktpUJBh/vyFfbTrNTuOKTMAS7UWX3J7IDDA1SQVoEqwc+urmqnyT1TEy6AacXzEja/v65zgUOP/Tgz4Zy1gmeST/SiONDH+1kUbW/1EjzU+zjSQmrwp1qaZLrsTNpPc9g27sC43HSyVdxe+6G4c+CsQOFg5c39SCMPdZdQFpZKptWcgWcNdA/bIYpcOjqZcz4348jqiGCBXUBBaxEk1i/NegjkQBvIlvm+tbONUpJAxvcYBCkNqulfO+gfKQDEsdOkALRIvQDoNghzs0B0JLD9AlsFIE+m3eeQ3pVArRQWmr4maW2gYNMxUslEoU9y2luIXqYZY4IGh5IEpK6Z4qWn9BX/WtJ88eURVqKutXnoH3SxRm2c5u2xRTnVy9R8HADu/yUkf7AoBqCXV1zgnPSypn3vywPmQ+zrjBw/Sw8wwpMkasfiU0Kc+ymAsm2le3DPUbuKkCA1tcFNQ+zCPzWV2GkFJqVrM32ENRAfYHimlHlUpQJKBOaCj6SKoDmAg4wE01EpNUmLkNgrGboEDTK/CqC1x287n+Uayo3PBULUWthkSptkWor3Uwp4pyuohkWxbVKAIYS1vxVbD2Y1uio9LDhHLOqYJ8+bEnXD5WzWnlxcx8HhymGONpa4l1v9X9Lbj/uL/wHtC1 zUVCOB4MPEfWrBIayapydUZJkjXooPitP+3EnEpUcRmGX2l6gJ7OCoEjh0F4RyBDi8rmRsY1vaXzkph+yzajDYbokWdXWArGmBgSaScnTd5szShHFjYID/ZswservWdJyjDNL/zlohMupI8f/359+xfaIg4u5Sr6tOPWF1NUQHiyKwV+IJeUZ4cqFea0i1RCnWWWiaBKc0tv+YbYZjdjyTtKPkWm80b8BazQLnOSGpWs3uKqTWxuzrRZFoLU6RB5jDmtgshqW6MbHp+xXUSMvgiNFUI6c7SatXcaFcrcHm84VqzNRCdR37ZamJeROfEsy4nEV4Nkp+xhwymL2I45FIittH/BXmnUOMhVrCEnPJKRzM0GbAb6cIMZfmMGoLXWmsh1iBU7Ciukdj5ElE9Y+50B9SC3+OAXDo9Qp9w8bhQKpFW6djSrEfisOKQBG7/NTBXJjgI7mbSUvIGSm6Y5+ncd7P1hovJJOUgtvMKZEiIXg5QdyrThkDm5hLrESO0xgXenlS6k82DMdFzTTieuX0dxxiIxO7PrbrroXCQysTwf9YkG8wQsP3w+uxH247tuwaGkrC2RVgVGV1i5oox2qdzQ+j6k2TG1aXq0e3JFCyXteEfoKuNmRXUIUvWFBqMRVcW25dXXNsQZXpVoL2+N8/M22a4Bdsz4iVB4xwkEUmH6oZYvxSjgt+Gfu27hWidBS9wKKlBvR/arre2lo6Mc4cPHLKPFvx1qD/+aQMhpyN02poPId5BDuPOYO3sLSel4BR0dZWQ48uOoeKKucMOgrek7xF3IzNsOIWK4dWVioj2BP9lxfkBPnw5QZL4f0md2P0O2lGypc+npTpCWUDgd4ZDb4n/75eHn708Pv5gzzzNOO/ydBCvLeynsOGt7yzusm1NJeWmklwyCtBQcmQPgYKnXJlxYa4tB0CmaQ7DWn0pE3UZXp2iIAtaHGSoNGe5HdrUTka95qogpkYMuebj5qiz0jq1I0g473abV 64LsLySngZC+kpaUd3loj9Nwq8TEXeHChryBU4VqizpC9CmG+YmDsEseOwptfHvysb0T7tZ1fCQbpWj7xPSC1adrDs+ZsnnclTUyvJmXrElcf2Q69khJXlqcDp4WKs05o3Ras5z60jCiPAog8FZvszB5mTfcVuQyyCpTvtfGeMAEJjnzEBKWrnFNl2QeVQ1tW4hASXH7XPoJ9vXtES9ifzw9fzy+wc+XP56+/nxTDhn621hfMnV9bEjEJbKhyBtgQ3gydryw5YwtScfZaGpPAVTodJ3Z7EW75BrNNjk2yYFigNOx7u6ASh9lpDkYynKMnEnjrpKit8U0VfJEKxVDP8g7iWV9H5aFeRyhtFlS7cw8k9TPy74zTDrKGOkFbsHQ7xrjR8vCaQPFaRzO+qyij9IBUC0ParBMoFrTkumF7OBQSu123d5ZTYL0y5ztNA99OFGniIWKRkrYLxdUZHgLIwqfzQ9zQ4UOYDRj7SmQTvdeno9UVnopdYm3MYLPX0JPMPlLY1cYWa27uIL7HLlgIwwtZI1hih5pzEtqk6b7006TYohLPAmL3nbt15DsedRvfHcpzJrTnYV3b+1dkiNB6NMhWft7NbqxRNEsLRFGol+68PBU7oMC2F2f7nPom1gHjrP1gVVpMGQxcHylnWzvcJjQYKwPY7cxkxHZ20BQfLFqoOd8byANgDR3G1ZJmRU2Wn3mk+XLqU8bdHprJWunNTFmrbqjsIqpupYguRlgy2c7olQThSuun0fmSgqqvJkbbLFnQKJjMAVpumqI6uuiJk/jItydxj3NaYCRaXiQDFbTacjTDohj4tMheBiIRTFFJ+0BHrXZfn96efxy8f0VdXvfKYboVOpT9jv9HbV0EDBZI3wQZWvycf/29fHD0uG28pZegQYjKizk9JcatHqRkRX9eEFmaFjW8zMQjZ+AU3wJBT2/mYFkLo0UeE/fIEjoecPaoPHRWPnXODtHTGrlk0jFHY4Wdl5d0zNW TltiisHCyaOEAkf6rBgvMVKb+dk1wDcE7imZxIfaT8qZdTaO+4nOhWqcXQl+nyfA1OVxWKKfJ5LdFQ1Ulpdovpmzu8z3+4+HbyPbHKrA4duoEk9wfaJhcC+b7hIN1dYxZ6O1h6yz4VmCdnjnw9NURdn4KxnUDeMvZUA26a9kOGcP7dHtLXK01Jx9N3ChLsc4ig0Pf2k0z9ubNTb0ac1/Csq8WhBQZOz+0njswzg/f/6dc55o5IjwkkSrsJfnww9TvFWDjBfOhY+AhOmupGXvFPqvdG7i0dYOJPScE63BKrklp4RBZEgjVw40hmb5egKK9lbnjYR+wZ8YC1Q/Zjl3An5T4uZ9LlzdpM4Fn30cN/DQi89gPVuw7+ziPHYgoSEg6np2ZnGuK2wGo55Dzm0PnsOMDSqB1if82WiRnD3A1dKxYGodL4+JhY0XbumoPChPdd7pt8Vq7aRuBbKLtS0Ncmnc8rdx7kK2Qbih059pKOzGYcPY7WIIY0K/D4Ep80joVnC0FxTqHEyKwbgGH6WBXHcB6ZxKN586Bydc3SUbpmyi3Gl1cB6yIEE9t3DfO/BBwDS1RLMqdFAxXzQmw3hAfrzdv7z/eH37QKcRH68Pr88Xz6/3Xy5+v3++f3lAPbX3nz+Qbt7DdYFaOMw+TxqYKpjGsFoXBobT2jAguBMOmH3V0vfWXHnYkoLmbTTxOEqN2TmJWUepEf3ar4nZgXuLVl/djpaM5LFKB2P9KMeIyWhOxqJPU1NaItpMzmMm6WGD6pgj51S1n9UbI08ykifReUQahCd7Kdz/+PH89KD2+4tvj88/qJmSRkSYcJH/7zPeEyNUYCg89TR7ackK9dHcppvCQn1zVhRaBNlK0Z0ie0nvoEwtH3VLtKWjYjsGaD/qFQzrHpGf6Kn4wIdKct+dNFVZM9FuRJ+Ozw/NK00/OpAuckoFACnNRZ6dvR2Eu3GZmCLXPMUksCy5x3ndjY2IxjVSo3GtQHwaOWhD 67NhZJ42E/m/1+dN5X7Krtkpu56asmtuyq6ZKUsffsaU5QBkAdQ8s6rUTsp1PylFvuYn2vqMmWZgwkqs6TVmwXDPmEahoGsataeUQCwENreL9EgXwp4B67OXiInkpr6BkcXoJ89ZSOvzV5IJTXPaSmF8pZB7vj21mlXQaXlYs7nRXElC7ibaY4aN7r/hd6/Ow8+0yjFRHW7HlHzdmyX+roPtDn0s+uT1VCNaHT+l+KtUm9A6Au5Iw8IIqBuluq0PKhLpTJYyUhFYKxF+wv+kNR2StIKTheY459JyA4y/YFDg28jROunKJ1HmJNrV9ErbJKtMYBgW6w11TLoyKfxNBVG0AQdKkUKaB6WrVtTMA7FLYKzTLMstF7YN9RB7aeOu2HVN1MxUhhVoyH7ESj3qQFLjpL64mS3mt+bX+tR6d2A+aWASB9P2VGyM6WmxsrrZy7dElnyfORfGdZwdc49SRRBhGOL3Vxbj1afWadz8Izzl0KEoq/fIfbnP0r2tNyRYI90njL6Uje8OdZjf/nz8+QgXuH82fposA7IGXe/L7aCIeh+ZvnLaVNuRV5uqxIy3w3QrCkqbKCPiazIispfhbUykbqNhor+Vw8SwJJDJLbbBjr7ZFe3R7duRDYG/B7ZfKNovCu6rRLtvtjTB32c34TD5luonHwPcDpOjW47ie1TZVNH7PdGFuSBz0+mk3Z0qJa521JgR0KDy4lwsHGGkJg2dwuoL2/P9+/vTH81Vzp7zfux8AxLQn7Hwh8lK//dymB4dh2nV0qpik6QiA5C7VAvgX7n0p2CXGX5Mvx4S7cgjorYxxgAcpivOynIUi5QwscPJ9GmN49/lwh6IhujzzzgtRD0yToEGwtkhhOeKegz6eZ/C+F4qaHmFARK5ZESBFoiRq6uO9nzHHBV9wqiHjnCYvvNsLbadp7UwqUOpzZOIYrBJYbr0kjwmvmHrmLUVAramdFeZKkXQGpMt+Wbb5HQIvqySYSrUSA5T 8cwepg6msyq2eRomKKVIo4zohpttkhHdIyKib7S6XWPEOfgANV6DhxIsWH105LGuxeABMIUpfSWrYmGl39opM8OktmgRWf7dAp+aUUGKEVlkFh/MHWMLjKqn3GZSae0/GaLpk99ID8w5aKQnje1oz0EaeVg/vQYI7zu09UCWh+lBHoW1vx16c1gnxeHdu+QYeOSto2yAwSKAsWgxFD9rIwb2mGmj3OsaWbirBVPqnRkGSKXgUWUx7ioV9iXCljQ1nWjvZeFOX91FjNIjvlYsUU2oVO4JLQXd26JkdQTq1JeU3VCOrjPQSy0Go0ktDvekpjXenuVv86vuAmcGkCkiqQIRGS3EDq6Lk9aRRQc29oXmZGZvfNRi9WxOzCAMDIQxEcrfVvKutqO6bm8tayk005BlEXqJDjzDPIFrhdBWi9h0EnDx8fj+4bgLV3W9KR0laPtCVWR5DZNLDPzUNbKLQfEOwXRO0PWIuUHDD7QxtRO2fmIn7BzAp/n18tpOEtIyoN6aewJKOELTJwWkFBGuGyKpLs3IIZg3Da3rc5ME+0s9IphqUfopaQjsYXsRWBWvzYNW/YQLuY9++/zCccustBzpOzzQEhmxzAuQvUzm9E6/LVvxgPO10fB+QG+jUg62Vx1/9/nn48fr68e3iy+P//308GiE0DYL2ftiW1aS8XKt6JXHiPqa7H6ymC3pY65DXC6vrsYQkVMFi3qA/52+SYoD4266bLZsjtoEDfcFHZOZ7bZOFhTBLlLkllVLm8ZLsnuE8mwHhxGjI+ECYcdS8e7GwfwJW5xuGEvV4rSj2ZzixN5+4IM3PmVHYO2XZtckPmk2g2L/orJMS44CHS6bt04/2qGwZG4ddEoGM1dul9D/MX1JazLiARXGGfrtwrgYcKBQR3yHbmL1oof9VPl/3gXbYW2Uy7A2JAlCatshlfFxLR/NrYVtkAcyQRfiF4FnRK8YlnGkt5RGymQ4eGhTlAsj04SoIxQ+uoTC cYxpauf+8RzUb798f3p5/3h7fK6/ffwyACahyct0ybi/WpPHwMvWhxkbaKEFa2dKGPx9pGvwVtxqp5y0s7PONVsR3QiTP9C/29rZiSLNK+d6cZ27v+soGCTpXcrl4ZCAnBDLJADAlZC7dH4z8MMcdRzJO2nk2OmhDHwnaAEnUlN7T26SavawQADs44NzKn28f7uInh6fv1z4r9+//3xpX/L/Bjn+3uzCtjEJlNREXcdPsl+LGOUVpOXparmsuXOvR4gFoyYHCDyDRouQpeqSsTLSUz7aBrmMjkW6GpbRcX5n9V7HtVOiBes+PbRzb1Mch0XoShG9BfZJwHvDDIvdm0/LxrjJyhWcdMSJsGHb5tU69J2OCdb1TJfIeh5C57KZdRkOyz2GFmsvbC3LHuhTPuiYo/Z+pWKj+UZUw9ZhY45Dmlk+KS0c0gOgW8F6kN/AXXxbWRtcF6Ua8gxZEiOvR/KziiLNaBVtCuXzu6PlKFiU0ED+cx0Mj5+zwMAyZEWClvxMRes8Cd3q1HlJcRPYHYl0+hTPZtvfn+ppdrNDqiwr8lUISF45KKuU9GuXHlGmXcqnoQp1p9PcQkVGKzwjLc1Drvlwr7Wb38Y0tvuvzPdctWz3EIedV3vFdpCgjr9dDtOyd3dkzEpusnp+Tm9aJsjPmZ3NBGV+GWZwd5sEyn3uD04P/MLD68vH2+vz8+Mbdcc5JMEgl3//5fHl4bGJvQVlPBqF6NytbvE4stlC3p++vhzv30YLNKd2KJnAEGpMg2Odxx7cfDL37td6Wpz8oA598fo79MbT8xnNnILqvo4D74yyRmEdiB63bkzDly8/Xp9ePtyuC9NA+Zwl+8XK2BX1/u+nj4dvE7NETbBjI0IrQ/qwHS/NLiw/FsrLX3NqsFtAiyv969V6ScL8U4xSK3Kd+15humX1E1947m8VAK32hXlHgWz6KGq66deH+7cvF7+/PX35atrU3eETd59N/ayzhZsCDcz2bmIp 3BToCpTThwNkJvdia7lUzoP11eKabTLqmejIiGamwstFYN/8dUQ/DEL39NAc8heZ67/Tq04iFl5xVzvHc6WdBw+tqFomKDwoT94GW9Sk6HBfluC+pWBcbaqsQhx05Bjt9VmHW2tcjBh+o6HZaeDFVizmvNAVjUSRwEU3hHaIuNMniJ7evv8bNgulH27q1UZHNTUsLkmFBm/L+e0XI7Rbh9auP0dMy3okFYyuB7X8o5mxyoeutZrl57ajExxgOAAURRvBgdqRVYHuaJqTagwUXh/1cJBjrsjhobC1CHU6MrrtUBYhxoIme0jBtE/1BqyGm/hcy3U24nbhmyITk4jB8VQhNPlQxRgvYQsTvRRmGUW4s3hZuFzqaNABzKIosqU50bHl0HVEKmVvRPvBMQNADteeFlH+fKfud8leuPudS6tdfqGV3hkldntdBrcXO2Y6+m9ovPwMFkl/E1DpXpFcyD/fPx6/o6og7vkX9/Atw4uxePl4fPvjHi4ReWOIYZ6G/6P8fXvDgLKr79a5G88lSITNJEKC9gZNzWSkoTQ/gXWILt/R0zjGy4tg2bgvZUL6EpjZbUTf7nE1R7vhpzoAUrbqTToOI/rKjIsRPbN2zRts5FC5i7+F//l4fHl/wnBf3aB1ffj3C9lZvbRdCC0KpRn+FVOCk+o9DG5aiG1VmksC6QUGhU/CNoiatdSRjhXtNrm0LDJaHI1Q38slRt3UcBbGivqhAtrnCLonFYy5N+xG+LKtQ7UmsMZ3nhtu0Ppa4YuF1mVlIYGQ2tsJXn9IpUzVtRi/wHdDLvqVLLOkljIomzh3d4MubMtvuprvv8zPGt/4JCY7JFGz/cYZ9YCMhcgtOlQScXOmtaHj/sKEanTz7p8xbtjFHy3SZCabUnmQQpWPX9/uXZqZnwEMzsFgwHlGR5+xXNilXEjYkn4eyCKiJ3XMJrHbl62ABEX+rni6SaK4N9NDs3LP3MhqlXi350ebjdD0sZ7meOc0 3up0lFTrXagJnJpWcYw/6CegBhRRG6sfFFlCFYkXM5jM0FsiXy5OJyLvZx0kq8uKv2vcRuHOwgfTc0BcAD0T5gbNo1FEKEEa6AQGpCBNHOXPxku7U3GXAl9XzB+SCtuV0oDOfb3FqKh/v749m3GGFUAF1sU68I1sHPrBBn2Haj/cNqOwTVyq0WjOGoiqszXjTrqdMahuMpitKlXFztKeEDfDmRYUW2pmdnN7S4QQtsKzGYnNV3rJjklTbx4qeld/0uDtDrnRsKTESo0uDBRCLZHxelc6V5/aJrbBnbMcFV8HsYW7CMmq64avBwcYUTk0dO2668DZlwNh5CUFqREjtkcaZzyricoEhZbXm/XVUpqn9weKC/aC1WJ1qoM8Y6JxVElyV4uCNs7M93ApYkI6FnlCM2CliBLFhZFU4cvr5UJezub0SZ36cSZRHwFuh+qeQkv08lrE9OO8lwfyejNbeJz/dxkvrmczWkiiiYsZzXyGqcwKWZcAWq3GMdv9/OqKhuwTf71c0XqugZyvNzRJwmqj8xzrE4a6GRX9dyIvnkFE6UV6qmUQuYKrdlaWeFujSYzM21+4R7jmwEPgQxPKtFxTUJy83lytKC5MA66X/smyJWrSBXCKm+t9HsoTuXKcLxs13V7NZ/y0bcc1FpJ/zvNQYcjD62xOGnQonZEkNNiPLqm2XzX69PLErKMOsZOMLXiH8CcR+4D1Mt5C8tMUAipS84Z1B33XPCSMNH8Xpsdbuq1bP6kP9PGMcZ2h32Hcau6ZQEGKUp7OQHDvsBWqGdJr65B7KSOZvQG2ovbz1YzeCHTPSRkKcqpaW7oO64tKlI1C0bt7QVU3a63pbIgyRaDuptTFXWVwFVEx0f5lx2FTKUrwEXV8tqpWU5+Ljz9/PF787cvT+7/+cfFx/+PxHxd+8Cssub8bAcGbU1VadfX3hU4ltdvaLIb4pcuwG3ItW7kjy/YphqTpCBQFp/ZznqLAbXDHMXIKoKQf nrs39l1Ttj423p3RkrnQozP4ZuQPh81GaEnKBEh68hxILLaSiYGhMUVOFdPGUHba+H/ZnXeMUXtqKARiHYcoqpLgjMiB1JCddtulxo+DLqdA2/S0GMFsw8UIsZlySziG4T+15vgv7XNJ84qKCmVcn060EmQLGB0pD581RsieP149T/hXoxVAwPUE4PpyDJAcRluQHKpkZKSUm3/JBFnViMJPJC0fU/QQPr+g6QncIdSWmYZHTsW6wwwd6Q4x4y3Ny+UUYDEBEMtkpKlx6OXj4y0Tryjz25EO3+dwWaNXql46FXrqZw5AXcu7gj5UWyrdwoZfyA/jS1dyh29zdp2W8+v5SA9EWsmG5Q3azXaMmo/t06ng1IhbujdnGATdwJIx/tHUu2S19Dew7zC3Bl3BkUlyq4avni82I5W4jb2pPTTwl9er/4ysS6zo9RUtwFKIY3A1vx5pK6+ko7mSZGJzy5PNzL52mtShJqV1gDWv4CO1c3xUmKejw7N1clDzVVziFQ6VNUytNfUAnqDGsfEaCYlNRLs6LArzRQpJSspmJzUiz76+mPg5z8hXIUXM+1ikfq94cfHvp49vgH/5VUbRxcv9x9N/P148tTJug7lRH92b6mwqKcm2Al8wlFaY8vS4dCqFmZTaCmqB0XcsRARHZs3r1uLTvrfnlixipIgXlNsFRYuijrOFZj647X/4+f7x+v1CCX2Mtvc3ggCYN04kpL5+Kwe2OVblTlzVtolmxnXlIIWuoYIZigk4oELFA7U/NNqNCa1wpmhMQDQ9dYDZ52LQt30/RmT2UkU8HHliFY+M94FbuZpYhlIO3wnzyQ7ux1xNvJg0cVOkxFa6U2lFyRysmlzCkI3S8836it4uFcBPgvXlGP1uoFRhA8LIo2epogJjsFzTZiodfax6SD8tGAW2DkCL6RRdlJvFfIo+UoFPifALToNOrQCvgI2fnqwKkIalPw4Q6SePMWnXALm5upxTci5FzuLAXbg6 HZgybodRANiDFrPFWPfjLgXF84DCCwTHaGtAQMV/VCTp7wd1RnluWGCsr5EyYW9YM3xIPrY96JNSK4CNAAoRxQw3lY9tE4p4FOk2S4dqoLnIfn19ef7T3SoG+4NakDOW09RzDsd7ar6MdBDOjJFB53kYPaSfgRWdDVrYat/8cf/8/Pv9w78u/nnx/Pj1/uFPUgey5Tjo4xuIo8qMCBherdqLFfFqZaYlQeMw1zL/gbtarJPJIpXOUxCWVrScriT92u8UJ9LQo7S6gIYs6MwqB1Pmw5Qh6NL2jrVVim0jwrAgURp6pUiHvRJYj8hBwrq4UoVENuPbwqE0ZV7hpd4uLJSKOm1bj4WIDLXNpSlMDJRCP6zZEtUKA83uml+pUhWdgYz6AWTlU8sqTqZeLveZnVju8f5WZAeBcdote28sxDYvaVPg6nvr1EY9BA863USEW3r7QVJBryv8Xky7MwsS5bsjK5x6oNtBVI6UORfyHEDuVaenfA4LdzS74NhcabxxKBIr5sUoSNT1lqNpvVeOGsXeTUgtcqDBQSHKO6cROlH9Fd3VRZaVyvBOCvpO2Ofg3rNwPilNbY6KA6EmBTvqKMLf4Uc4gHp05oh87CKsfMBEA24DBzEvVVElHY0t7dszDMOL+fL68uJv0dPb4xH+/zv1ABeJIkQbWrrshlinmXSa3DpGHPtMt9+h+SWe1o3aqnG5Re9/YVIlGSyAbWl7yBgoriZCWADVKcZeCKe1vRvgY3f/E1uyq7Tqe9fELpHdMbNDnlovj7cVcP6f+QAZnAqAiDi3PmXoOc5zMAVfd4yA7xygyKo0KOCqnbIILw0y9gOo4HJQCjGuk6keg0qIWy9GOy1r7BpPPv1hCUklee6KXHnqi5fGeOo066kgZ7IfTpbPIGQpDraDS68IHb/jLdb2rJhHZHRAL7H97cnQdhEG/5JZ7Dr/aVJRAT5MA6VuwkSytX2HKL8ekNJqgcamNn1ZWX0CP+uDmu1F JjGgG9U9YWl6udEaN44LwzROmNsPAG8E507oUFjhiL3CT0lv++jesl/eBgMIu24WZ9SLJFQaDeKdmQ2HSJAV9dK3deoOWcFJRsu7fJ9lZJzIvjwv8PIytB0w6CR8wC8iZw8kCgCeyBr/sJwv55ROn5kp9nzFZlgXJBkLPyPtG6yscLmx7VuapDoMaeajUUgo5VRTEu9zZm9qqdcNx1Rea/+En5v5fO7qfvXLDacLcyWGvPVpt2Ue2gM5OPSI2sBmnJbC7qVbV4eZyFf45KzzpLp+EwTsnMyZ2jHTrjKmtZ2QQLcWKZySCT3p/VMNzOvEYOnDw1FOvaRl8lsfg60y2tL4YkpXw3mPaZek2GXp0tjT1O96f0zseYflMk8Ad3CNSNiQG5CRI+wm5ozvBWHqeuPraAdRWd1V7uF4xXi8aMRN+zcxIUwcBxOy3THbmIEpGIyuH0ZXJ8mxuK1cY7YB0akj0Qn7MJb2FbFJqkt6YndkxhaxJdMzrydP1kxIP7P3LXL6mVkwek3qkaMdQG/6LmfU0hwGAM7hWDgmX4v5jJG4KjBJacRK9eaSFusEyfV8Rq81KHO1WE+cOIEbUjqIF7QulYTpxljeG+UBdx6HlkhyGy4mT4kw3cWh41W+lI7BNpHts78XOTkeUZXuhBNfF9IYpWMj4y7Ldna23WGizXshBR7R1la1F9vEn9pb9pV3DG37d8G9WCsKGQq9L09sFqsTfSIpdbKeEs5nM/uX+zN0f8N2bOs/iR39cg/pXHwa9vxWFC7X5YzJBAQuDyMbiZL5jAl2tWPuYQGzj4sTfXX/lEyMegwcHj1IzZuCdUc6JNwOLW/I+SVv7ix3w/h75HVc+0YYGDu61MljIIGKe2lmrf0kPl3WnKpMfFrxcgqgyuMoOTpO1ccWKEZbbmUl+eSxgI9Btprajdw4Ri0WaTWHOtJvPzfyM2Qd6JvSH82aHa4/lr306pLxhHfwufjDVpEyTAQ9/RQ1i+gr VlLBNdca3R1pTWxmuSus3Q1/z2dMlM4o9OJ04rhKbX9QAi4EYSOBRk/5tcuREiV4ZdP+vhidRF925Wa5sTX+iTJhccX4IlgW9nNcuiU9W5k54T6fZrZ6dxpNjOJmeT2zRQuLG/7hSPtnyJmLuFmZA/B7BuujdEUCS1ZgoLMbqxMBlk0sojxMJcqWrDMkm1x7WgXJzHQbe0tOD/E2du8YpuDiFKY1R77lwosb1yO8DNgXEspk1ax8herniXVHuIUE9A5OV6NIJgeqCGyXFOvZ5cQMxdiiZWgxepv58pqUbSGhzAxjuyahzm0mv01Gbxt1eRRsFOoWuJnb3jYsAD43oyNKZWNM1KrYzNfXVqtLb0pwUcB2ID1JTt8CfS0XJEl6CTC7loq4RPZkmnmUYXhLFykc0aX0rxezJaVuZuWydb+FvOZ0AYWcX0/MAZnFXhHB/9YMloz4WaJzO5y79OmNZCnCqekvE2lN1TAXPqvPCNjrOaOToYiXUxuxzHzYUMITfYDJUh1wVuvLRL0pTA6sLWTde3l+l4Qeo6oEkydkLJ7QX3TKHDWC8iVpVuIuzXJp27gHR78+xTtnMxnmLcN9VVobtk6hr6OKVJfp1LbilIjeuIBry/d36JCPLjomw+IYZR5ClNxy9+yDLbyDn3WBfiVofkigLmQMk6KknhKNYo9eujvZY5xyV5Vy5KqSDkjEt8RnToqtjezMWjRmd3ha4LWB/GiDiWMYuMmJcBKFI+FrGAQkLPIJKfNnO6ABPqDtPXoSRUFAKrzt7xzni5hg+IyTR0ixyHXu+TeeHaEsDgNU2Nmh5gFA6BqIE/o4YqjS5rK0nawQF4jnvVl7cjFHOw6uVE8UtZduNrP5KCQEyHy+5zEJX3EvQIWGEeIcdtgJwOUIoJGR84DTZnN1vd6ygFaMzAP8ZHU5VgcAXI31MtA3l9CDo4CrkQJ8AZwc38RGCsjSG0kgSxd+HleSJcenks+qzP5OR++Oz452 KuV8Np/7LKaRJEzS4TY2idlsbhdjo9HjTgv4bwR30rpR9W4aslnDNOaLwjh7wNDW6KOVw6g7+yhZ3a7rcs4PVY86p5xxEF4yeURWZoWKVsAhUuVsx+NbhH5+/W3JD5QCXK7q8pMHfNY4bhLjp4v1bGSjufW9zXKkAKTPNiN0qrta3l9fZ2p9UvRXgj5Zvx3RFyx9K2A/jDeD0RFHXpQnluF8xmhm43MrHKbC5z8e5Chv4NcQ0ksfzo7xEi434/T11QT9erwGwWpkcSrE7mrBIxqdepbecDQ7OI8XBf5JzAE0q9W+eYyEg29fs1TaySd5TqT1jpqNRB+uPajfqW1r3OLg/+WCjjOhqoRaRCz15uChX0P0xRDR0mNEydipsd0era8xBvHHqT7nfEJRywr+igJWoISgUAb15WwxihHKLVk60s5ktJp56N1M9tQnz9VJtulZVDpKqZqbg+8qa/7WRMdi8jDnRvmOYQz+VRckcpwOXTRKL2EPCuVqwz3dpnW0ma9nzCMoxtAZr0Az18Ygib/1RgFqDMYA1WAEW6fGwx52Fkrr49J146I5cXz0IN3ptsz9MUVVM8T1qxcVy9uk/mTFR2xYzluPC+qgAD4qHAtOKqcwyYHrCk2WPsa3EPTVX0GaR3u6ucnP54+nH8+P/3EdJw+JFon3cSxHbjJArU8IoUaPyNpdyHJbQS7P660MXEdVFn3MTRjSR4IuITnJcz6vUl7GPZxDZB7t/h0oxiMc/gyddmWhDt4Bc0fWtCaDi6K8nLmYy7HPbKYL+O3SzM6odmAeDPrM9tvAI4VFVY5XS1JqImPzyV3Ge0vAh9TOIy+j26wwyracJys9UvzXmqgCrMImmNlAgRBJvlfSLUPijXfklM+QnIc7TzJ+YZFelPFmznh36umMQgbQ8fluwzxdIB3+55SqkLyX9FMw0kS+p+WYR0sZFn/1Wo6J8yoAKZvFnJJLW/lKS0ERfo48MAN1Ra9ORWF5CKBe s/mub+o9M8q+V8TXc4bDgazrG1o06RWr1YLWSDqKeL1gDKugRE6l4OinyzUz2JhtzjZvvqAC/9pDkNgP0l55tfZXs4GXIiIvredHNx3SR3xZbNGdBndmIjGiBZJmbVrNlF4Ekh8X3CMB0hYc7RhfXq9XHG15fcnSjsCsnlHNQgo7RszqsvGRNJGZUOyIxTbENyxaxNMQlfUSuiqmWQqsNqPlnBzjzdQcaqUoFrcE02g2r+gygfaf2RiN0dZA2mKMxpc5W/L55iuetl6yZV6P5LteMCq3msaXeb0eyTf2vRX16mONkqEGQpGzAiUlzsNWkmzm52wF6YkpNq+KMIbpZU33ODrFU8u58FyVwqJcnGbUS5KVbfhCrc5Sxt5X066IQoGiQk/IQVHXC0YprKEybgkaKhMGEKlXi6U3SmVeknQjNuHod0eocFKPfBfbS8/XtkU89XQ6ccTjZsNSqGAa1iBLaz7Bz/qatIkwM+Hb+VbSs9QOB+0f54vJiWa/WR7j+WJF8/ZIYg5vIHFM3DFmzBDMOny+Czxrfn4O5sB1FZRKm5lPPc2EaWq9gd6WKZ6yAwef7U7QRWU8SmE8qqIYqT46K/xISsrQbA/LgNOOYLkNauTdhDGjFNqjPDcW7BDS1lVdWNFM8Pnx/f0CamfeYI9HRvZgZejxh+SE1iVk9aLqE1ytqjpkHkCD8GD1njLc6+O/aSPKlx8/P1gPjE4QR/XTCfeo06IIvUTbUUo1RarQpzeOBbumaeWzG9qMXUMO4uDFgYh0flXl6v3x7RljRdCCsKZoNLd0Qn47kE/ZHR0TXJPDg5bUGt3ExcTTGW7Cu23m2F62aXBHyVerDXVT7iHlzZbOfFvOZ8z9zcIw9wcDs5ivJzBBE7W9WG9ozrNDxjc3W/qy3EFK39tczum9ty8n2SyZO4yFWU5gEu90tVzR2lo9KC9g1xrHpOGxZN5hOkyWhylumjQr3MFkmR29I2OI3qOqdLork0Vd ZpW/d0zMh8hTOVlY4yinlpTah7GA+sWsfta5XBBJtRebQej79O1dQCWjbiT8necUUd6lXo7PTaPEWiY6JNUA0jSN/K6IMI7KDUVTzu2VO2mLI+3oYYynGGNYb1QwxIuhYOSx/dfUQJIGqT0oynxkL227yp58SNS/R4toe8nJLsNCMHpgGqAiq6hKjoBQI4LzfqcR/p2X02acmo6dyrqe1pCDBLbOGyuknxPjJfU45iRvDwUJIIunb9NqL/Uc62cCs2QsLDpAQIuOOoCfbRnPGx1kFzEGTz2iYIyzLETNCMB7UCXiOEwYV/sdTMkZPH8CJUUQHoX7ljDElUlAD2T/PaXmPY45ekUhGKd0HSjxdsoEZKLi6LYkY3x+2qitx1hQ9DB83JvsgqMI4Mc46PM+TPfVxFTx5Go2pw+8DoOcUDU1FU65G37OReSnYmLcbo+C2Rs7SCSFt57q6TCV4d6bmm5hKD3qdqJXuorxZO32OkXJpWEkfaa5JkrkcP2fQu299Mg94xmwmy38mAKNifobmN7cYfr7WUJ5XWxaj5u79IswtD0x9MmwUV1trmh2yoKhULdOGFtlE7mtFvMZ499ugGPU7k0cypeyNKyFn25WM5pbtfB3G79MvDljlmpDy1LmvC3XEDv9+QAPoIJxgWPg9l6Syz3nsMZEhiGnDG2Cdl7sncbOfAt98peccoKJa+6ek7hdlgXiVG/DAu4V7AltNR9OCcawz4ZhgOb9abNirOstMAZigz8vuZcNG5wKtHCqfVlyFjscfjNfT2cQsYAJfhaO3V4MmFzLu6s1vcVbQ1Gln8+YUzdltJgzykIWkDs2bdD0fFc7VX10PRmPYM+ZRk2p1+dMZphJ8/nmjM8niZzPaY7XgoVx5Mk6EfkZWJ7NNmFpdlC6o+kB9m5m/zenDjA2jGNJC5aGJ8ZQ14TBXVeF7Z0e7qCso3J1mtFeVE2o+neBEfPOgwLjOF1PcfIFzVlZUyMolaL1OdNI vc1nSZ5JzpJhUFNRck5cLaj01Z483fuAXMwYlaohbnrhShGHHG9jwsr5gvFqY8OS6IwJKU+b9eqMNuRyvZoxXl5N4OewXC8YqZGJK7J90jAU02BxK1dnbPgAu1owPLVVR+Up/4wDpD3KlvP5gr+aYkyfoQwVuLQ546GjARw362tmP9eILfBEjHixEYUuTzPoxJKTimlU7sv8hl59TQMSb3M5+iEv91LGCKsBlDFsrNsyZSKhNSChYkyXIT19O3Et3NjSBjkGPJWfaGa0aXd2DIuE0xXTmLvQY/W9NMJP5rOxr1Tqr9HujzYrRhyjEYF3tdjM0BAQxSBjHRic4uXopBKJhA/S7F+DuJWL9TV9Oe0Q68V6AnG1WIwNopAePp81bRrtXo/la5uighCmX4AKXAFc48cmclAcFuv16oye1MirUWSRiMvBTUO9Ouzv377oqLv/zC7ccEt4dhhapMMAtA5C/azFZna5cBPhTzdUrSbkPgpqiR1Jk2Ox1RJhJ1vhMV7tFbVx4eYU7H5ZLlBLcqyYwmfLqPiTdecl4dDlVvMIR3V45weUeinTD0/f7t/uHz5QlbULV9lu86VhFngwntL8xq1iWXipjJWVjDSRLYBKgykKNyTLpBRG/diRt0J5CSWGrUrF6XpT56VtkNtEGsVkIlNDhSrCBcdwwhEHKlJdVWboO7N9KZOPb0/3z0Pd50YsMYyK3RA2i9WMTGxiI1uj35Lm69Vq5tUHD5JShgsx8REKKikNIxM06HmTaIeOM2vpC9sk1KbRhPDkFTQlyU46/CXXdJ8aKhOQFnXlFaX8bbmgyG0cd425pGunXX7SNZR7rwgxzirTUcr9OE8vJNORiZfCVMwKJ26d3Z1oz8oY3Zt14LehrhrlYrOhtDlMUJybD0pWZQXTOzn6g7e1Fa3BoTT37Krr2aSD+b6+/IqpAFaLS4UlJDwdNwUAN7nk5AsNBEfdtc22EbbjYSPRWB9uqZ+YmKkNGZ/Q BB2Wt0FI308ZO7QOMV8LeTU++M0J86n00O8xf4j00EkYI9luyEXOn2VAjiQ0Pp/6hkKJFOM5DKFt7CV7d3WGJ9URHwNHCUHtJUp3nTkT4QoSxIz/mXrHDGqafc44B0QYZ57WxN8f/EYfh5g/Ks5lRW1srf3YcOqJPBEoYg/ikIpfAMdi5xu6y9MlYigq5BQSxvVFD1QKvxMYL6Fv1T1i612S/lN6hOMrwiSww9eDTqhPX1D+TaBroZGGLtDBio0O5IYDbMvM7bcR/I0XOHpxQv/v/H2ID1fYofSN14f/c7qfoW99jMVAEk8iju+2zKOHIg4snFp7rgFjppV5Fj6h6rQwnGEqmyxIqbO8CHfCZFcwVSlRwEq1vUIBwYczkVU6AnpSUUcNUvZhDEeG4qbsbzmKDpjkxbtsK8pONwma0zGu25/vRtsak6oLKATSv72+f9D2aVYl4aY6Xy0ZtfOWvmaijbd0JsyRoifB1YoWEDZkdLc8Rq+TnLqUIBXuN3N3VIRkBKyamDC3aiBi6BrmRg3UVL1CM9dTpCvfZPUuZ+7JOLpCrlbXfF8Dfb1kbq2afM08OCCZC/7T0LjHKCR/3nvZSQyDLqgwOMzEkb59HvSL7c/3j8fvF7/DHGyyXvztO0zG5z8vHr///vjly+OXi382qF+B13n49vTj727pQSjFLlURNNlnObVkebUsNaS+Nx6OT/drUjIhNpCsTb0HTQ3/A1vNCxzPgPmnXnL3X+5/fPBLLRAZqsBUjCBabSn5Yj3nJ8goL4yAIttmZVR9/lxnUjBOQQFWepms4YzgAQLYcmejVc3JPr5BA/smG6PsNjeJT37OROjSc3J4xrW3b26TcwaurBhVXiTG3oGfN/g8mwhfnWAZJ2lT8xBtgEenoIbgNj0BGZxqRmuJBi4pOwZIrdHUZ2HbNDLRqmTO8Gx7SXo+yq1bGPwcGs3pQyaXFw/PT48vH+/UzQQz+rFAd5c3PItgoJRwYQq0 yxmOCDEqJpfnhKXUdS1zqOvrw7+GXACQ6vlqs6kVO2KY2lrpKiYZujVpj+Dw5f7358cL7RbqAnWT07DEwHDKrQc2GPjyJEehzMcrVOTxAhYNbA5fnj6eXnHHUNV5/y+uIvXNIWErc0jayvbttxEiKDeLnNGfHWJ9ehdwgJG/pK/XDi7h+LpBM/jiMA5JfbikuMvW+HswpmpggjyOh9rtXdmf4+Xsakm8BDalUtmNmonULwvKWypOTJgJjejMHJmGQrb0yNhr4/vC0MekQ5fhbRWmPi33ayBVnsdWbcx0NjqQBRqENxD5SvlZQhDD28tyhIwsMzpEQwX5GaPFsPVKuKXfIXbH6dd1mONixpyXLSSQiyvGRMuCjFdGQWjmr4U0Tjlryah8drhFUs0YBaYOwwRqa/uPo7f5t7eLK45PaDGoB3E1YzxEW6AFI15qawOgzfWMC5WgMXG+ueKc0rSQ0r+crxf0iBvfurq6vqJvFFaFrrjQDhoDXXQJN5cpzIrjyNse2nnVLsS6L64vx+fQLouDSEj6dtKCinI1Y/butlZFec1dqbqKB9fX18wLfPularecM9MwqsK4aViSbBwtvk4O4ewNKqFlmPa2QrIWbOqA2wS7iCqeWSFrDy661a4q6CvUAEV3UwcLri4Z9R0LQhus9JBkPlvQ3WRj6BGxMfSbr4VZ0pPIxMyv6IVkYK4XjN5jjynZSKw2Zqo+gFlzAlEDw5gr2ZiJft6XUzW+rVATLK9ghtfBCh3tjuPlcqpe0r9aMzZEPaaScPXa1cVd9YnRXOqwJ1FH6MQqU4HSRrE3G4wYNA6Zz6Yx2+sZE4GlhUReMl/tRw7urvpoKyITTj7egAq/FL7ZzHiqWLllnS63kPKUjw8Dbjq+xwrnGxD8gf5NfU4e4gJzRu+1xSn59uQYBHK9GG9fIOdT8yxAH5Yy4Z5dNEisbmovoXnObriv5pvZipYPmJjNIqI12XvQanm14p5iG4z094ys vIOUsgyr0uMilba4ndh527syrI8ALXizkA4fr+Yb9pmqwyxmU5h8vP67q/WMFr4ZiPF5uRf79ZxhNTqMXHJqsx2krCYOELFaTaw0lHZMTmgh48VmxqjrdKByM35SffIZ/rMFqB3p8xSkmC8mVhes9mQxr097xpVPi4uROcrxVQ0D8yZezQgGO3yYZodsEoUeY5mgIh1GcZDjB6DGXLG6rBbuerxHNGZ8riiOnHE+YGIWzB3MwkzMFYWZbv/lgrFptjFn1Jm5ztmYcRYTb0fMpcaErGeMzx8LNB9nDhVmPc6sIuZ6sj7L+dXERqNBTEcr4ma62eupE09jxkdKYZaTPbNeM5qmFuasrplYNom/vDwUU1to4ufL2VTT/Pz6emISlj6nR90hcrlYbibmeyJSIeG4rJK6Sq42s1PJaVQ0+OIKDsXxuR8nzKtgD7iaBEws92TiogOA8QURJ4zoxwBMVZLxjGAApio5tRPDbW0KMFXJ69ViOT5RFIaRUNiY8fbm/uZqObEHI+ZyYodI/RK2s/F2IeZqYpI0mMkzEXBQ78nvweoYHwzEXDMGGh0mV+EBxjGfT2V9U3g3YTrxwR44UXsEKs2f8QIz36/zzWSHKRVzhkHIE05Fo8tdruBIG7/fyn05sUcCYvmfKcTlJMKf+MrIu3x390pCODbHp3SY+PPLiW0TMZv5+AABZjGfLmexZMR3BmaNAvLxxifSv7xKzgNNbFQatl1OHLRwIVytJ7YHhVmOy9RkWcqrCfbUC/z5YhNsJsV88mqzmMBAd24mJqxIvQVj2WFCJvYGhCzHKwOQ5WJq9eTBaj7R8NJnrEg6wD7xJ5irMsm5EL8WZHxGK8hEZZP8cmI6I2SiWxCynmh0kq8Ys74OgsqpE+cphnfyURg5cZkG3HrDGMd0mHLOmaH1kM1i4vZ/3CyvrpbjQh3EbObjEg/EXJ+DWZyBGe9oBRnf6AASX21WrE2AiVozzhkMFOxN+3HhmAaF E6gTaiWMIu6ynRd55ytedVsRqiyeIa0tb2bzKZE5Cq+PjJ6IBZoQcuyzFMNaT5S0z92PNYByj3Z1RgDoJsGIgNEV1pJk6ZVCsrZWLUy9SUXjGKXsjq/X9Jt6CwuTsIBRRfsZ7P0silAq693Vifxt5oLbJ7JBdSKvist6lx0wGAt0iLDD1lLACGXRygpjoql9FrSL0n5qRrPwpRPA0foiAGMY1GwgAxM5UT00h2nxo2VhQHdlUjVYReLl4/EZlW/evltGSl0ROpSVGkk/9uxNuoGcNuvuS4fQLzPDhEdnL31Dlxjh+Q3qQSR5N6W/u1+UmV8HpaSa1y9/gC4vZ6eJ+iOE7qZGq2W0rEFX+PvRPu9aDOsliwUzyhq1j8RoxejR6ZyKeqW/DzIruE2bxuvjdYg0O3p3jmKfi9F2BPU2yzAsM/rTMcx7OhT6/mvVBGGJDz8l7ySzt/RfKpQuU50XIaFwqF2I3n88fPvy+vUif3v8ePr++Prz42L3Cl3y8qrG3AYNfFP2+2wWld2HyVo1ImsZzmfoHGEcszwLs0NfeGseegy8kiU2oZRG6/xZiAINXUdBGPo49SdAwXGcjoJCDAo2CvL820rAecE1yQsO2oHgGYjQ50GxSFA5fxRwNZ/NWUC4hZW63FzygJNXsET1TLjhmymBSZ7NYDtgXlLh45Eoc38x3pthVWSjnSW2VzN+colt4kmaDzp6Ucg3T6yXs1kotzwgXONM4Khql4OdfLRxAnqHL6LcXM0X0SidJSInNfZluJ8sRrpNyejmS5aeHtiBXc9GukXFnoPb+3I+Hwctr7ZXI80rbxM8TDkyXq3Y7aZh4ccAm6urUfr1GB1ndpifYGlNDL6aIkko+F4W17Ml30+p8K9m841Lbyx9xK+/378/fumPBf/+7YsTQknk/mgVoWQnvIl2uyy3k4UDhi687SV0YZdJKbaO/SjpkXPrJx4JR8KgfirY1B8/Xx5QpXokhlQSBUrJh7k5 I1kmnCpIjhYCypcz85KF2ZVj1Bkj0FGA4Hp1NU+OtKGYquApX8x4D0UI8XfbEaK8nMWr2XgB8nIRXy5HMQkcoIwzUtUVgYeTlc2O5NVi9AsKQt/lWzKjJ9GRaWFBQ+Y82yhyzAjaVdP9+fI04iVKYfLFmtHgi3O/FozdGdI4mzQsVm8SaHWurvXn4LiARD0sT/x6yyi/KRS6Y+GH8pOXfq79JAsYkwvE3MAVhzHvQfJmkycb5pm0p/NzQdHXjOaxnq2n1TWjvdfQ55cr5gWxAVxdrRgRXgdYM+KpDnA10ggF2DCBixrA5ppx49XRGfXTjs6I23s6LVVV9HLNPea15LEuBvLYx8M0Wsy3jLYgItQj4DXjVRroB5GHhTLAZSFwpWJi3uDefncF7WMcSmPmwF8u5vwcK8rLDSNR1WRWWbshz0dOjsJflSvmBVRVXlxerU/8ZVcfXitGIK6oN3cbWAP8tgd3V59x84XkOF9ej0xe1OlnYq0guRR1nPBjg8r13CMp0nMvTpjgU+g4bj5jlPdHvcqpeinAhn5b6gHMq33bMmj7yFmoitgw1rod4Ho+flxq0CXvu/AYX86WsxHPtcd4PbscAahhTJarkVmsGXF+iZ42Iye6V4jPWeqNtvKYbC5HDgogL+fjJzNCJvgfgFyPbDTAxS7WEzxYlet4ClG+43cUFZfC3VHbWKhjTGtfTBHuUKLJeDMvfNp9mB/6lNGbiqBWA1HZdHGusMzMbl4in/rA7u3+x7enh/ehXaUHm3ZZFWHj58D0ptN6Io0MxwcHEYSWcwWvOgVC5rFH+RTxdkYkCfiBLgLWl3bSIGAfJkrGRSrSHNt56/q2Kw1PGbu8qrdVEBiOvoKiiwME/4Rh/f3n169PL18vXn/gOFvXEQA0FjKuFndrg0iWYHwK/cyKOpDCqkB9k8imt81mIyX34BJJNhyphb3DGpTG6laGceiX2imGdvmlRxtuhljXxgrYbWO0Re8upGTe wrX2v+7ltHWAQ37LLgLdkdUwUWFdiiJBjwFMg5opxXRTSw1ynH64YNhKu9ChGxAa3H2YIkt/lL4P/PEC9gF6xiEAZZnYCcPpW+/CpJb7BP6kOweWmOPXQj9TqMnaOsHrXxyMZKccSQnkVaUKEexCu1Y5ugftKXqFPb3/eL7/Uz0eqGhQF9u3py9fHwczULnkOOV1CbfCazeCebvY2MLsssIy9Q6Cvr+r7ks8TiFUkSuae0XaXkgYNuHwyGY74E5rdwum1Mr2AbXat+Fvv/wyIPterjbgsCiygsjexj9mAfg4l5cUpUDTY1l2TyKLGfw3rJ+SxLeYOYnBb+jXSnSEIyuZh2nw22I1RO5Dryi3oVfq2CMHL0bYEAdtgktpX7f15SSmbszFfruiCkRXvW2Dt5W8O3qi/G1DNUaWWW62dwBQfgFiAb0SVIXaFX+b23Mh2Xk7LnIs0tOsOoQeFYyzWy3uMsnvXx6fB2tDL6wu4lCdld7V4npG2wz1GeCsyLcwYe7gADI8Go8uraYCdnG3J/p1UR9IwAzwB4Ysr1aMYa8iy2C+nA2dtTQPZRd/vL61/mn+eLv/DgftH384EkO14CMRMA5j1FdEksfhGOIQSm9Ab7tmoi7OlqmCM23HPrbNYCj4I1YURSXr25C5iukNbL6olsxVFQFVwI/YYZudFAvHI3YhFeBekbSrNzhd7K2mT0fWxj2PDpDGfy057iL64oXkE8cf6EmeFciRqPVZ4yPfjWzXVISDdKFHqXmAtSZORLslI7OpfNv7h389P3399nHxvy5iPxjxXAFUYJU8iSaAB+FTLdh6/k2sPAKbQEuO3iG84/X1FeO1v0fdlJ83m/UUSt5dXa1oGUAPgm0U9mvGGNuoF871CcytCvQAq2+qXh6wZfQ1zfhgkEMTOft+C8VIwXoU3qIZzU8LxFmzGKDDajG7immVwR62DdZzRnJo1L3wT35K79ET868z9AfO0pxHLZutmO7hNRTu K6/PcK1tDgB9vR3eEQ87b+h7N6iS5G4iGf6OqySVcAzT9CI7SmAPjMvteJUMaUnhwfGMe87ARWRT1ODO62zWvh9SHmJkVqWm61jnh/Z0YyflfmIn7I9BmNtJMrzt17mR/skzvRm1Ka2TchXntKs2UjMp8apGVVzXhKpgo9PiltU61kpEmhWMPiZWXQsV6iwOYNmT/nHx00Xm15G0P3xAibBUzK/v0vwS+Bq4ZcCtMLup8kHlXKc3FhUzN3FovVgE/M0VwdXAO5FZxQTq4HZYkHi13G2raDCI6MrHRauxxXk9TG61iRpdP7eRCKlIXTZVi2F4ZD3IklFRxjxYD5bqQV/zeWH2oFYlS4eDPhGMxxykJ2Xu0Tcv3Vbt4Fi5BufLyCtHbdyqoHA7wwvmmw2jxK8ajHbYY+RLLviApovVJWe1gHQp9pw/NySXQnBekztynWQB4+VWgarNhlMLbsic7WZD5gxIkXxkTAGQ9rlcLjkzC6BvMVYPv0C92ZxhWxQ5EdzDqNrlTnc797Zi5paXC8YJVEPmwonpveMU8Z8OvCL2Rnp0p8xGWHLs3Y1m18UzFg1t8TxZF8/TkyxlTBOQyHgdRRrcLTPO1iDFl+pAME4TezLzAN0Dgk+TJfDD1hbBI+BgnM9u+HnR0EcKSOWcdTLT0Uc+IOfXnC1QQ+aswoEcJVykM3WGByO7PhL5LQSYjvkVZ8fW0kcmlZKtb058v7QAvgo3WbGbL0bqEGcxPznj0/pyfck5HMGZ7cG5VWSMcYqa+ifWyTuQ02TBeOnSx85pzxhvALUQeQlXap6ehEy0roZ6zX9ZUZk3YX2mMs+Wipilwj+I7Ui/lQXUPB078b0NawDX0yeOMBQQVJnkd4fDifU4AdS7JKLU3vbBr97PL0+vRiQTtRI8h/cNvI4fd9aMVxehThhZWF4bi4uLfdnCctSuU08cLK+pYNppI2pIt0zhbFgY8rf4LGPf2tyiitCL4wy9In8Oe5OW vt7Oy1pLYFWXuq/DcPpjQbVtoPK+wnnht6Gc42sbBYnhyRuZl8a3w9Qr7tgA8E65Hm9iNQCOLFoDqN5dzwJebzjXdE5nLmecH4kGqBzoCsbCyyoMJwgXqdSpnxI9ngFEEcPInHSik3SpCQYETsshyX406U6TOt3HJZUeqOi/mEhR1e39iPr+OMnV5G8jSLXbhZmpklt3gajw0RWnTNciKm8+clYrhDwt+IuYil7pCY8JutKVMV8wPjYNyOVlciP4BY2odcRFLW4RexFx1l2K2feDxdhFSYXAzhj70Z6+H0eUMEeGeg8OSMWUIgMD6Susbwfq0OdLnvk3jJdelS1QQ+4zNqLqMKVe/ZBy2qwt15r4uBvn4cQkGnpUb/OLTuJiBP0QVtwYxHTuZ8siTHflni6q8I5mxmpPHihYXrOpuJ8Zxu/TmgU/Hh8w3g2WR6hyY07vkt2VFdn3Kz7CrkYUFc16KCorgO6oTMTZjl5u6y0TOsaA3GyZ4DGI4UK+K2KF2y9L3obxDeOAUpPxlTKiZ6QCiN0W433zCH+PL4AjZAG/RuiZ8qo4Qq92TDRGJCeeD9wJX3xeZIHAWJ/8B/jDVZGhe0sBfJTcwolJ700Kd6fez1k6LJJdlhZC8tMpTORYR7MRtzURmEwmipEiM7GDkHYQkhNsKvpn6D+WGpWc/zW93pOtYHR1FT1injEVMc4KkY3M/X3G8h2KfJeHBb+2d1m2w2iKpYdKbSMdfxAHL2Ykkqqgcr1ZjkxRyWeFnh3fnm7u+PlS+cA5Mxwa0o/AljGCWN2s8Khubzyi8Gn2FIkn4WUkk6a65K7RaHA2eoEmmWyRXIxtpH3ytszrHVLLo0j3I8vjJkylgANsZJrHPu8+QdGZF0ZNQ8vXEXIpgTEYGWaM1+4nMNf5DkhgNIuR+ifeXRR7jDNxBQh33jEr4mBsrhfeDb+gilDvYvwnhF9kaHDMIzLU1xnZTzDsqxhfEyly4WnA93dacvMy LQuxcydlE6hJ7kXImK8gClglMnaoOmXgGgnHIOxXxjuekQg97n40D1MY75RSf9Pk0ovv0tMgG5ym+DTLnncYZbHAVc1vm/mJCWeoJ0Ce8T1beJ9HlkheYCjzkekDNRtZ/kXm+x4/dYBN4EegibXgdpcMEzeTTUehgpq1XLnAu1iMPvweWz8yD8OAjfWtEGXo8WceUMMYH7FCSg1Xs+1pHlfSbWnBBfbB3Ri1sjw5wuUoJ3Gfsjssmd9kxYHrJjhnZBgOrg8lBtDjy9vDlsx3RbkvKlnqh1P+DMTLR51LWiirEIsI5iw/patUvX96MaytYGRk8yqWI4zo0Rvjv45CsGHmNT09cs4z9GELuwVLxfaNjtznuwDuOSMbt3bGU++Z8FnqohHn/AcSP19wzscUK1Z5x9CZoK1KN3HJ06JXEfy6zSNL/akVszgkK5SifYttknhxZAvIrKE33MVggA6sHKGGpcVBAKidK6/j08QtQitLJ8GFjDRBDsvGQIdAZkumshu1Lvc+V3Ljs2XvT9TaLaK1A3d6o731K/lOYIkTcEn1CQ2i1TdpvuUWaKKzvS/qWJQl8Olw4gsvtUsbiDCUxCtLnEAkmArsGz5E0EtMybjiXDDhZ5W0rvBhLDxZ7327SfbHrVjfTQIOpZ3opSmc/X5Yp+GxUdjptAqTp/eHx+fn+5fH15/vqnd6sxGjiNavE5rTCFm6zY2gYJGKUh26gnmcUeVMq+eokSj5ngOaumdXfhkLRrOjGQKpxgAD0qCvAEcIZ3ZQr/+t3Wn9tqAaD7A93BE/a+1MfB/6bW7ikt5KRU0zjIDq9xFQCW85agKtr06zGQ40Uzt0Gt/MAyujSg+2O9+jlG06hKNgYqbDcKWhZIwce+BYAMsOJUUQbr2Ua0TINEKlF+gCCU6DuuRGSMHKEmew9PehM8FDpp0qPZK0vMqs1XQbs1O1mM/2uTtOFkjIfD5fn0bGMuu7gUil2pCNVdHcUJgOlvFm Ph+tdbHx1uvV9dUoCGuggqslDk/dTffGJ5T/fP9OxuRUC83nqg/MfFra6nyVco3DD0mZDGW4KbA9//tCtbvMCox58OXxB2z97xevLxfSl+Li958fF9v4Rr1EyuDi+/2fF/fP768Xvz9evDw+fnn88n9fYMhEs4j94/MPpS7//fXt8eLp5Y9Xe3NscIOe18kjWn8mauxZyyrNK73IoxknExcBF87xiCZOyIAz+jBh8G/msmSiZBAUjBKyC2OMdk3YpyrJ5T6b/qwXe1VAXzdMWJaG/FXfBN54RTJdXCODrWFA/OnxgJ22rrbrBaMnqB/gJLmyxPd7ZY75Zaj0r46dwOccXSgy3jdHZpbIaYNe/PKXn/fPv35//fI4EclbnWNBKmkjX7Myai8JGImAOmyPPn27aoi0iFBVYC+AAQz5gcPt2Ykq0bUUmUGuZVrLk8xms09M/jARjFeZhsrEblM7ZlCVzIuRrtpBhvzmEoe7rGTljAoxsue3E9y/u/IZvzcaptws8t0e8KJG1UR8lCIMrvu7CQLqJBJKt1rHGOQb9MnnZwBOd/piqzpTABO4PTDW9apwvrPKwgMW+yC2gzDAdmdkR68oxAiCVVfWDIsMS30QR+KENpYjsx0tMCI6zi0C7iA3P7PCz4qxP/ETFxk2+Huxmp/47W8vgduHfyxXjPttE3S5ZgIbqL4X6Q3qigI3P9pFMD8yyb0hqflWJuRazr/9+f70cP98Ed//SW9zaZZrhtcPGXPcdptZupoUxvWT+Y5dyM4LdszjfnmXM9bhiptDGxR5FJz8P+GC5wFzVFeR5JjAJEzQ0zElEcVrJd62eqZW3b2UIZjJFPWpNf92YICUcN7PYmaxKOS2wFme4ja1P+LYp7twaBWErynEeKoSvJw2TFTETBYe2p+rUI1c+CNdzBHYKEatUAGUmxP6mO7p9Gpr6WsmWpmi5753PV4AetOh11dfAOPUpgOsGaczHeB6rIRtsFjP1smB XjwthAuBouiNTpS85LhWfe/3PXTCMwKI/dX1fGq8VnRoD10RuZxH8XJ+PTT37aebujb8/vz08q+/zf+uVn+x2140j3s/X74AgpBIXvytF1j/fTBht7gT0setoifxyec8o7WAgmEaFB0N43kq+oTcbMc6rvSXXDy8HmCHWtAWrnB1/KYC2pevbw/fnFWrIG3vOcmYVL49ff2q06yB1hKg4UbUEph9gwRTMeEpGNw02IuLBQS2h2bMLVTnf2Aa2pleTkP9sY2vBXl+KQ6ipE9TuymNlIxwhP704+P+9+fH94sPPUb95E8fP/54ev6Af8EF44+nrxd/w6H8uH/7+vgxnPndKACvJQWn5G030ks4n5IWLmfd1FgwuEE6vla44lCTjX4BsZtyTtdqbe3wAC0e3hDl0/f7j6cH7oxDm1B0aipiZxQbuoA/U4GSO+sdo0tVuwG65iSr6eL010Y/A1eaoBlC05V9R0YtQjRWNKsDO9algZmqSlLumUuAAcr8ImBu+QYKMQd6niGpLk40B66IUtDct1G+yDNBc88GSBa0Xo1ZDrdnm20pC9m4PDoLCkUeSL3/MPB8YKMzlORLv6iMVwlFGjyUFKUP/PvWTsBoVevNfDOkDDhHTNz7ZSbvqLmFVKCU2d63y2kSWyPlX94+Hma/2KUOhHMGLT0A09tK9CHh4ql11GMcMggEniTSfvjt76t0tBMmkh07aDO9rkRYuxbRdq2Lw+ASpF/jFr6qKbERtPm87Xb1OWSesHtQmH2mBXktJJBwy6E5LBPChHcyIOsrmt1rIegS/5ph9lpMIVf+cqIcIeP5gonwZGMYw50WdAIILb1sESp23WK8ixWGiwhogc7BMH48uz68nJdMKMoWsr1dLmhepEVIuKBcM4GmW0yULLkw0t1YnTYzxmLFgMwZl9kGZMXYy5ofYuxTWkiYLGdMJLiulANAxmcNQpibVw/ZbBgJSNe9weJytmK0q3sQLLoh6yxz4ax7 c19ZoOETaguJzose4JHRPmu/gG6k2f1+ES8XE+2HSbrgYhVbE5nzsG0NxzUjBu5Hfu0YRWmX9c/3H3Ah+853FWb2k2xw+DRb1YJxRGpAVhPzFiGr8SbinrhZ1ZGXCEbX3EBeMTKBHgKzanwPluXN/Kr0xud4crkpJ1qPkOX4ekPIavxcSWSyXkw0qshXvi1hU+P7+vIrXmomJnRUwr+mdqBdFgeRsGVUrZ7QhXx8eYd7PTmLAvRif2hULLpi+9Qhx6E9hAEr2jt16nPVYboTqemMBtKU8SkGDYNraxrG0qZ2VmLtDSCGq4gH/brj+V2lWARkJi5hCzhxrHdLVlZxzD21QWVeydUjj081R9MizTL0WUQTyGeCfOLoqAGVs1VD6i1HVE6h9th/dbJL6Nb3GILbDI5Ybb+1NOynjU4nC2zzcD4ngB7SX9vLyr1gSeBTx2dHHBBhMDDNH7pg9eRd6tclPxYB2tYS7Cukb6toqIKkyouEE8fjqNLJD1RNSczHgTTyLN8A9qHn6iC2LvTsahqfZV6XDhFHUJdd7ROHGKnGDZ2X+nvTTaZOdn8rjR7rLmWn42ug598NyEmYVlQeshwvSETKlaQ+1JKsNgJxi3bdtnDIBigpB5ExSUijwoaq7tkYOTCoYUwiW4WkxbBD3QDU5Y4iBzm1gA77DDVhdL/1YJWaMq82mnqQmU8z2ZqOBg2yUT5supL9vo4Zh65Yb+rsmKKwK0Nt/M4LZ/L08Pb6/vrHx8X+zx+Pb78eLr7+fHz/oFRLlfHSgZzsU6X0heyK8I6Lyw27X8gYNe1yRgIiS2/HqSlT53P/sX0Bn+s0pugaJWEce2l2GlOsklWBJsR9Sdb+0xCXjf8D1D7fsT67GvAuZwyS2y8V2RImclmSK0WFd2zqUhNshlZ8ZsOp2tn1roMa6UcR07eO5JSwhTV2LEDGGHLjcmdtvcUWBYt3hLoTO297V4YsYCvKWIn9RMSHkoXOLfYBfSIg rUYL+5izqdSIkaJVPzT2y4NjDZWn9zLJGxVQV+8aSbzGeIfAkSNXqFu8w9MwD76qXMZpFNKWQX3wPX9Pz1dEHLcF058JCiTzca1KL4Cbx3E41XuAUvvYJYz6i4oJHHs5Z3SoAwuPDupY6GHvzkvDzAk63NDCMMz95tvm8iPXVxAyiwuvd3D0RDfc6ouqT6IEXm2kkS2kxKOAXnu7HOaAchVQR4zNIlnvPf3FtkfrfVZyWhZim8CRyjh5aAMxBwPuyuI3lXhZ5ouacQLV3CaY0KfNK7GHbyflfHa9GKxJbXQgfzw+foH73PPjw8dF+fjw7eX1+fXrn72kl7fDULZXTXwC7Rd86G3CMnA4/1vup3Bvkdu4jo51lQceY9nTY8t9lQbopjImJMSqLtXLA+qyRm+P/+/Px5eHP1s99WEzq1SFpo6K8LblL0bayJbrFqtNwfmXCMQctiU9XzU53Md1LsOaYa2b+JjeTVl4YiyccF6h5YLI6W1SYwpG4aiZCmjPBikpTIURWFnBkCif7rT8p2m1ZLR7ULcx94Kx7aCJiYtzQC9P9BMai5IzyTDwow+lCnW3vUbHERwDi+oKN1g/9iTrEDGz52I4+m2WcS/iXV13UNfPGRPb3sCVMLIM/6gi2N9Wwr8BLpNRWE2k4ILOI2lkHJDMHSwNbfxwbAxMoaWxd7pj+6SFjVSlhdwyAq8yk3ux9eptOXYUtag9t2m3AJ5Hgv72E2aRKalRPDqzRxuZe6mnnAuM9gQa047R72QZJlfrkQmc5ThbRgvRHmGV6hosaICnpeB3bJlXRX/0AvOPQg5aKOHhLTcbsSzUB+LooSr9ipUXGYjRmSlCuPhKDELgldDh3L55FCkKeeoomV3VrEuU7JRzS6ysTmGQ1el2dqnWi0dFbc0XpkmcmmRH2114m9bcpptbU53CFkJJXBQbn2SWAb028av9mDGzPspcpLGzL+qT9Pn14V8X8vXnmxUeti03vgkPcPJs FquloQqBP2ssrk8D5DYOOmTvWpwqv82UwLG3zU6GiwDfp+TC24zyPCWg0RX8eTB8D+o0LxduUv/gr0NzPb48vj09XCjiRX7/9VHp/1jWoa1H8wmoMT/Vl5Qoh2P6GoTWQ1KCobIQPmVTNoTG3mdLamUjck/Kcl9k1Y5yStVgk0FXyWHviSw3PHCrmxKmWyL8QvPzpnqMFp1roLvkm0+N8slWa0jZglWYD+cOCpfQ2svIRtYIjUKjRjtp0IMRZQknilu48ydeTsjq9EQY5ml8edW5JSLUwcx6Gjs4eekORF5i7x/mRPqhDOSwKUgphPQP9iOJC8HLlAoIN8y99ZOF47RW65Y8fn/9ePzx9vpAvluFaMyPaiQk401k1oX++P7+lSwvT2TzHrFTSvUFc8XSwKFXt/7T1if0wzLU8m9Sh5XJXi78b08//n7xjiquf8AqD2y1Te87XIAgWb7aD3atXIMg68glb6/3Xx5ev3MZSbq2Dzzl/4TLyeP7wz1sMrevb+KWK2QKqrB//Px/nj7ef3JlUGStEflfyYnLNKApYvii9sX46eNRU7c/n55RhbLrXKKo8zMZB3fuJ5ermesdUI9uyVXaoWj0x/1bBL8V5ZxJ0Zf213KaPJ5fl0O/uqen56eX/3B1p6hdTc6az1q7ILkIXr/fP70M5rdFGUxvg2rPbjobRe7nFJ3HJSna7c/7ZyiH+w5JbolWWR0XrmTSKCkgt5PwhHdkRhafZIxXP8Fc79OSfjTIj0PrHjhvLh5g5IZuJPAkUnc5sTX5qkEGoz45xjLhnjmKEO2zGjlJbCtP6kmyvwPe5ncdeMvclbszbE/3A6TDHT3VirNofzRm1LdL3HK6j7cmBmiY0E2lH41ijHVOwGlV32DwXDTyGtarnQnTZdqNaJ6ToYohZ4uEsPzk1YtNmijjsGkU1pGtX9/hRm58s3FcJ/Tz0Tbo1Z33+IbNuX8BVvv768vTx+sbJRwMjupJPoTVUNEV GinHmEi8V4bLQdW8ly9vr09frM2lSTJu0GKbHgLhBn7trpfUJaDVgDV/doquxksQJsfeXVaVdK1DZF+S2isZj/wNPQznM0ZXqUEki8uYnve6EoUTOUmr7BwvPt7uH9CEmhgwWY4xzuWeHESiyD4nG6C5DJko2NVImHXJBpCIRcLtQ0oePSaR9NEbHLOF5CEjIti7coxWH0K7frBOw+gJGA+96kyNJvWiVB/RS522FbCuADruUVhHEm5chSSVz4EGDLVnxKKCFFlaMae0JgBqcBieNloBgCiUxN4K+Qxn06KOKIEAUC6tGFAqoZLq4V3lc0hY90yKE7QvHpJk6FeFKO+cj1+yiuiftsHCBONvFgwfSLaqi/svf4JEe71+MqtIDvQno6YsgNeq+KRHpBRoMUp16mlQJ0xpg3Id6C3AhHjSF6JmpikCb6usZPTAJluPCNJXEBKCwhOpWl/6umuQYnTcu8+yGyddczc4KR3CtizCEMqqrV0WKVkKN7PQNa5wKaqTJUkvwtwThdvDR4+xSTpR49lyJpFcWCsAqj0YvzZtoms7WFGltfRSmF/KkIHexTSan2ea7knYKOhdTgPCUw6sVYJxNakgc6mI3RZGi7aBZgL2NgWrT15pxipuk81toD8cGuLo8lIgWMXAaTKyLl2MEsuI9JMOkT4ClF3IZUEKfxRKZNjCQWWrNIKpVBdHycRDwacY9RF6RyJ3Q1zF9gxq0+otyj7rLCeLE3GoZKPC9r6Jo5z6xV3O94PEyH20DVwk06wUkRmV3E0QOkFZuVkf9jSBKFVtQX0J6ieqhymZS/dgbBamIdw61FTcMqw8UQI7JhVdTlMWTg380hgHdHzmznR1tFkj43PeOxqRHT3wWI4hNnW+ANlg+qdGwIsMhgcjydvf7lNRS0gf3YGg+AIK6cVH7w7aB3ex7MgUK9KAcYNhgE4w/qq3poBJCF2c5fSyNnC0Frh///DNVACH2dIfehbLrQm4/dPc sKLzO2ckCdWe9lFBV0JXKPgV2O5/BodAMXQDfk7I7Hq9nlkz6FMWi9AQt34GkEmvgqgd5PaL9Fe0SnAm/xl55T/DE/6ZlnQ9ImdnTiTks1IOLgR/t5JtDAOTowuvy+UVRRcZep2Bq/1vvzy9v242q+tf57+Ym0APrcpoQ8xOVX2Hj2S+8PPjj80v3QwoB0dtkwRMdMTt6jaWnwZtUeShbWCWWIXvdr5lvb7cCoz3XLE+czUu/nyqT3y8gvYDHOvQXjLGJoK+ob8//vzyevEHNUEGoVxVwo0d2kelHRJXC99Ibp8PAybC6Z209leVEycW+oYUZVYMivX3Ig6KkDqTdWZ0JovOQHGtV0b9b8IitcLP2uanZZIPflInsSa0DEx/U1XJsOkFIWMSohEDNrs9WFSV9b4l6321g2Nva1bITOrvlzpR91gGZ3kiPoc1Xuzhvjf+emVmHXyFLpCAobokQtXzm1Irt46ozisrqqSm+PqdO37/9F8cMxRG4uAV7Vpq5UHDWdvtYkJqswetmmAfjAW6rBh8qX/dDUZoEU8LFRdF13/v8ArwGx1Bu1eBkVr5hZeQRcvbypN7a0I3KZrnay+1vfTDIuvzfqRcmD24V9YYlyGmC/L3mVraGri9qzmP+X0OAKqvT5dtI5V6CC3UGcuBL62c144uo1rL02XrHgVmLCYDb7fQz61k3CXEn5mAbj2AiRTVVfTzOP2zLJnQWi3iUrnxRG+eGC1wHBsm2zAIQjL2YDeVCm+H18Smb1QIwmW/GFPYPB3uNOGn+j7nabfp6XKUuua2kKL5ZL9OdArq36MJzJ2+PrnkLO3S+/MHXVMy/uPYHazo7gv9jtGksReXDuDck7t06obY0gyBmUvq29yYhrmAzyKnU2FymsoaA1J31qCyJkYj82Dz3RBNxgyAjTkNLwvITmgLhWJRWnjS9xdsAvUNXKxCxi1Lj1SOSvVsRiMpir8LyyOaENnnTEsccp94kV5Q5SBh aWc9LO1RVWmXbnHySHqw1uB6Nvj6ZU19P0/bw0C/RBhcWNpKFazp36U2GbgylWc8sswoBmaU+mJTzXktkjwOleRJ+QzHyFxZ4on0t1/+9fj28vj8X69vX38ZNG8Om81OhzQit4CsrNPhqJB3OoOO1+5WBp5Si7sFIWuJUSlTZyIEQiq+qApy8k4aSWp3hYagXVNYiMwUxkO/uz/11DA+CHNn6Esm1QdYYmojySotct/9Xe+kHKThptHYTRubZO7DPoP4+qbYrqwDT2fj9raGDNebUvn8sZjBMN+zjBBnuSCTLeF4x2AwA49n65hd+zp3FrFKmBDVagwlpmwHwjQ8hx9d7F/nBhvL7n5dw/3amjIm7WpJu4ewQVe0gwELtGGcLDsg2seAAzrrc2dUfMPErXNAtPMIB3ROxRk3Gg6I5uEc0DldsKZdQzgg2vODBbpenlHS9TkDfM24JLFBl2fUacM4MUKQkBnKg2rae4ZVzJxz/u2iKGkuYtSrl73m2s/P3WXVEvg+aBH8RGkR063np0iL4Ee1RfCLqEXwQ9V1w3Rj5tOtmfPNucnEpmaEXS2ZvqAhGf01AEPOmOG1COD/nPi0BCQtw4qJM9WBigx4iKmP3RUijic+t/PCSUgRMj7mWwRcrmPOeV+HSStBP+VZ3TfVqLIqbhzjcAOBIlp7FVW+XChTKeuUrFLhO9EuGorI6uOtKcG2tB208uPjw8+3p48/h84s0BjC/Az+rovwtkKv3jwL14Tewesp5EDBFPNo2hRJS+0wyFkY8IDmFW0MgmZlwb7OoEKKRWX4mIZxqIMklEoxbqCLb0tCUX2ne68pfKrbO5wC1HlZOA9oHSDNhoV0qESGXtyY+8B0yXO3L50mGAIvr+eIVDBsiwFuKbSAq83W3LeojFMuLt0y6hMX0LZD5p6rwdROYa3edKKuPbGEfkGRK/r6QHedv61Xq+XaKL5Utj/4GIoWAvswzkldna4aEvaPtDJsUVxK vYVbTe4VXjKCCcJDGGf5CMI7+K5SxAAjRVB6WxzLPboOkL9dj0EXMG9NedBitR79ulnscDj6lnBPMj0UNjLG6q+FlFmS3TFStm6W5tCrCeNCvUPFmRfkTOTuDnTncb6Zujp7ESrAunHehl+D2152THGiTSBhKbiWVcYE3rmqVF0ixtpMPTdAwgA1WMOCc4KE1kRYq1C50suKbivFiUtvpQfKpUgrWSKWRpdzgAk8yg0B9N5vvzzfv3xBK7B/4B9fXv/98o8/77/fw6/7Lz+eXv7xfv/HI2R5+vKP98fnp5ef//nH+/d7QH+8fn/98/Uf9z9+3L99f337x9OPx3/8/uOPX/ThdaOEExff7t++PL6gkmN/iGnPMo+QBy3Xnz6e7p+f/s89Ug3DNrUM1Ht5fVA2+KJsXSL3C5NEYXBJuKObr3Iszh54SFRagLD3M5bBBsaLY8pHMw0kv5WlSMt85llqAMZ4TONPWE07VQ9gmHncXjGM7c7iFgiy/d3WbQ85RNrA4PUnRsR6+Pb48C8YXFMZFg5NpeYis4o7PfdeEYRpqB0+D1UdWisF5xtaEbefT39caAHYxZf7j/uL94+3nw8fP99M3QcM7td9zHpfqnbYoRgIC7Vmi4pQ+mnVdM/4YCcDgnUNe33ll2oGmdwdvxw6MxGX2+ueDJXrMvuZWacBm+Lnd27qyfTzpZPyWzel8ESwhqH3s4OxTJBvw3mqx/Ptzx8frxfKG8Pr28W3x+cfyvGMBYYZvLOsOa3kxTDd0qc1EodQKXZUGgG88UW+DwuWMMyCRyyZOIQW6bAakEY0jf2ax1XwJs+HaEgcloDvbUMo3GPgvj8st0m3tH4bEhuZoaGnFWO/39Bz9fcYQv1FiXHbtlTlHu4Iw3YX25VOd0vcQvI+8YobcoXS81Src/z8/fnp4dd/Pf558aBQX9/uf3z7czCJC+kRnw2o219DC/1hA0I/2BPFQLKkOYIOUEwgkngAaJ/+mRbq XVrZdj88/fhmG423q04StfXSaiu4l3eNKJi43O1oxdnR9avmzBAPPacJqs99T5a06MQA0IKgdtQYRyXtLNt7n5knr3bXCJkwHh29yDmvMy0kuWytscZgJRNpriUfs6F/uvZwtIZWRzB5fPn68e3XH3AiPb79N54xDVm5acYQfJZtVjua6CewrGgmuhtxn7JXbkdkD1cbbzEbrAd/O1wjfjncrXzzrtWtiS0xO/aQnZZGNoC4oMMlNOSTq+vY9OY5XafNpPC59G/3Pz++Pb58PD3cfzx+gTLUyoMz++LfTx/fLu7f318fnhQJGYW/Gwtw0LHhTqBL6OnOzbP4br6crYad5yeDtB2VFqZicNTDXL4lUkP4pKDgqCZoxcL+/9UfDUP3/u3x/R8XX56+Pr5/wD+wx+HeSnXXNvZuwgXlxKPtDMg4PNZ14mBPDWgpbkce3YaKJJjbzzFOx+69+bC3YSRXayp5NafOaiDQwuhumxkno6L3NqOFBA3mmK/moyvqBKt4lH7aD+KwdawzN7R6bAv//eJvD38+wAF28fb4Bbj9e/T3pRj+978T4w85lovR2igEzSVMfE1/7vU77gHv+io6PFkGWhrO7vM5I0Zxc0npGnRZLokskLofbedQD6RtptEC7cMBOv31+8XLz++/P75dfEVfKe1Ve9C+Yjs6Vz4JvO2GaJjMXNnYj6mvVbC5vv9AL3W9v7q/fXmE+qqN4+8DDkXHAyJuFy2B5uM7Knsx6BAUc98RybtKR21852ZbmcVhaV32Jhuqz5KHh8dn7CDYGP2ed4Pp6T1/fYWr4Lfv2h4a9fX+9p/NmloSwMTVqdCi2HOYssa3yDiHpbmzvwKFakAtvMPpf5RpcVYuYAzP/gLwiGdiG26uljI8pxot/K8VfmYbkW38Kz1p4c/5QMNR/mVkvTwygXUd+Hn1xhvEX2qoneGclqocu0hngCPunCwNM9Z8CCcEucn9D9aty5EcqdtmeKhzbyCq pmBemaDzSn/0iOiByHbMLkevGgj2fdqTgQFJBez9p9pP09WKCXxpoG/ROGW/uV79Z7qmiPWXp/MK9deLs3CXZ5Z3ueDCrjrA9ZkFtq0+0M6NqXafCYWWTyMpf0tDFL60nDhFUXMSJXG2E369O1Fq3p68S5IQH2bVqy5GFrZkjS0xr7Zxg5HV1oadVrPr2g9Rbix8NN7XlvvWs+yNLzd1XogD0rEU1rofoVd1AncV1IWhi7rSAbA578P48hMGdR5qbVC0+lQ1Yy1DRS775yJ8j4nI4BT+49sHev2BvUNvEe9PX1/uUYhsitLbSujXZeO93TYlGdLlb78YmqANPTyVhWf2LvdclqWBV9y536PRumi4j6HLdlnS4JYlPaPRhCiQ2CIxuetc6oV8K1JsAkyTtIxaOXb89Pvb/dufF2+vPz+eXmwhCHricerdFQW3J/RibczT1sHOGA0uXamf39UR+hppTH0JSBymDDUNy6EeiZ8VASNLytEuvU6rZEsHANEaFl48/JLjA0OZJqHyrp/kJ3+vNWqLMHIQ+MAUeRi8Au1J8liYjejKgIVfe2maaa1lS77jz60rsA8HD1ws7CRRVrWdtFw4P9W37FyNedbwk514H9UjsgEFI5u0XT6kaDkpmT6og0Wk5F8GDdWM+JIpuU5HI4RoLU0LzmgaJRdStMK/JAmNwGWENtIFWnQ1QhrJWhWHcLFaza8nyOcU0c53EraLgOMjb5EWlf9OEgxlcpjOCuxMIl9shyiUysh8zvbiiGwQQaQgqiXw32dEVT1pNKsWZ3EkJ+spK7QRhaTSHLB+tzTfM9sUBtg/Hhmln+wRRws13BlQuuOkNjKfPjX+nHUm03aqNrNz0y9J9CWJRqnOwDChTaSwVCGnz5js/sb7zyBNOTDLh1ivSKi0cg+HDEVYXw5SJfBdw4KV79NBaiL8IrPNqRrK1v9knoJNqstaNdS+M+qdZbZlELZAWJAU+/sG4fSZwWdM+iWZ juM1PIKV/odXmi/2yq3HwYtbNx1t272i8O70oWsy2DLzBRx4h7BWgJ6E5zSc8KZbIJ1k28L0abVt0Azpljti9HCcAZurNfVMuw0VxEIDYLHsGBJwPLty79BUvDsvVwp35r0B2QgViFAF+tZuAgzO9yiyMt4OEnqtJ7TRhrm6vjR41hZzl3qJoJSh8IO6xnf2M7SqSS7G472pdpAv1W0FdrEeb2NrVP55uouDQcirurDGI7g1Obg4M1qfxrZRpB9/RvNzY0oVt3igGAWgYbAZ5i0QifU7E0ovCFj7wphSSscZlXDNa8ghkJnSpFG2oMMpvgtL4MrCLArM2dlSVW50ahLF2RGVb8vQL53CoQTUrMmMmRxlKLJz7bpU6uY/Jn+pklDvS0dZMaYM+m/MYmfO4azPlRqxKXXuSDgsWpFTpJ2nOYDrqF1Ehkp7qIN1Ucm941WtLzWD+0LiOxSlPHb0YuPcUklBmGclldaqPqO6GElHS9SoQK/1uDBaOqwsx412fLwd7LH9U6l7m+p6WhTJ0StC1/F4laLZYiTSoL2QdbpQ7YVXpf54e3r5+Jd6I/ry/fH961DrXV3rbmqcTdZ9XiejQhuj2qL6QGl619tKoBd8Uj0FLg2Z8g21i1FLuDNGu2IRtxW6qen6spU5DEowtiHU9WyrHIQxI1ZtNqmxHcdEDFw/tg2/S7YZil3CosBwBebJhNng/wMG+ZF2yFCHBgmlJ2JXK6KZEOy42Z/SFqFuBdA9RTst8Onq6fnx14+n741kQD+/P+j0t+GE0GXYVzpYT7imUoy2AMMFd+k43AIXP2wg5htoeg4RAUzqqC5hr1Cv4t2Y0uUpNC1mdlH0+7KBKsKg8kl3AwaoZTDg2Op0DkdRyNZOfdmEcxbnBlzmMWNyswu26GdQ5KS4Rm1GyqPgb4vZ5cZcsAWasUv0FMvEXkTDdfUA5zEK4Oi5E4OQqQgqjE6bboPUvu9wMiZe6VOKSy5EVRodJRpH Wrb9VOoTpSu/SaqBzS4ySlaZZli9onVbqg8R6zH3rBVhhcxottfg8fefX7+iLot4QV3V702I3Xav8lCmK+9kYdyljMSOl9LvnL/N/jOnUDpYDV1CE8hGol1S6oconLT63XRB0aYoDumIfw5nckdlFu3eU1wwjM4NzDszP/6mZNfdMb2VnnF8tz+7/CoB/WZTTgYapWuN2WZVGsgmaohTYkOkU5ksci+icliVQByUGjdRnbZQk7fRaWFaJcOiYObt0oRTaFNicgUc73Df6kBFUGmtE5rCnNdnzVQdbOHx49+vb8gm9ChTfovCUnyjKMLIB0YPz/gbzpEYQFN5DlLPNi4Kb0dF85o4rosypb2NkXU3bR/IFikD3vBUhinrkU3XAIHqOkFtV3G11TBzvPtU2npA0Qu/GubUzq8wQDAtgu4dXqkbDQ/KM4FBtphnhb5hOEwjkCJTqvtDJrX9Vone1ahIP+YEbRgT4N/j0LsZ7jcthf5ECLs2XmvR+wfvRVGbJKKRh47MRT82NIOyRS+scliRhkC+KzFQtBU5A4a8dEHX3AaireAZMJw9e86ljA3VjqgoL+IkvFG3abmvuTGt98BNw1pmHWw0p7wyxqmk425NwowNGmKYBsMJ7J4VurRDUue79qbjtPDAONdoc44S22LPqIIoysojzsmGwPZE40y6uSe6qw+DgMO4JB7pPdf2yneDMg+UYMWNPa1zk2zX0RA1fpp4w9OkJ+Cyc8Qo+gTW1KG0X1NxBsPqA+ZBOY1GCRFKlyzZqfNhq1zoNbi0wVST+JoN+5M4ORmNT/echyJkFbrspcZU04XyuO0W53ikdxvvfEO/8yI/Pt63keLFzOwqZTxT0jJEtmmYea45PPUeA6C4798Kf5G9/nj/x0X8+vCvnz80Q7u/f/nqvMtiJEZguDPaibOmK7lSVf42M5ZzFpW4JVe4+6MsiWS7VcvQMMyBwqU3CCxrUAJEltehtEgPawbDl1hSaMxe 7zGSZunJG5OiOe2O1DVsvpi1oM642YCpXvhtxn1Bv6DYyg/HW7i6wAUmYNSCgY6rXzmnlyhVLkJc6jxvqJtNMkDjo61dHMCt5stPvMqYzJC1NdvXe5XWmmf3tnNEMYONDU7EhLFc0ggVL3oYsQqrbvCof3v/8fSC1hfQqu8/Px7/gyrOjx8P//Vf/2VosCq2QBW7w01nIKoEbuBguiG3kgvvqAtIoYcdN+Udv8Fu7yjJr8rwFA6uV22QyYEUhoYfj5oCjGF2RC8ALkD5cx9kUzV0dmhlrh3mgwRt5j5fuclK1CIb6tql6tO6EeghZDEfg/T29MOifAEsS+wVNdxRq6a0+cKdGQ2a7XI9c6CfwpA4/5pR1irJlPaKPbiwxSgtIpbT68dljB+UfjRdlC8D/dGjJ0pK2thKff/CGmi7Rnc+HAPOo5CdXqd2sNUUA0mrPZRzU9oInpr81D2mE/cSvIjmJ5mTacqguBlPISnGCZPHpExjdx4VAUCMs+LANQEDXA4Ye2u35SyUlSmAX1HbbLPn+FZcUGTkMYTnyNxByOQEQxDwSkxZBghPHSWo6w6/flEjPTzlBGZmf6kHwL8Qw3xsMDnUF25JP+etaYPVee7YwLGpWduiYOctVm4Ph3isLyNl2AZ5o7cCAKT+HRckuhH774oMeA7nstyKd9BSwXj6GLpBzHLdE8bboeKMirDEGDR96iBBwaIq1VJRspD2gSJqO5sn1kdR7ls3BVOwJi4DPvecA/eKQakNGb+HCbg1Y1zWyc+nGTp8gKPJet9iv/wpyR0U+nZXsxdBeSas8D+6amhdc+cktlLkRN2VGSIOJgnwlZV/EZBE9RyGC6XJC/yzOUP0wKqHQ2cUdTt9x1EwdqUOnNUnqqi+Cm9xOjj34cqCz/IoT3enUMOt4cs12VuD8toHZbegBkg8FlMtirSTEOW2G9YY1AI1Zm3fEcCIqx5rSqYVgu2lwb9KjgGg8XCdicYgTTeNfkZx 0SOA/RH2GgLQkDOZZkKGfcf2/D8Kj+i8vfwrEZki093U7Ex6XVBneTMDZerlcp9Zx65D6iQXjC/gbeGlMNG0GC4cPJa16Y3SKnrlURkYa/IODsuZArYfjZV/cfT2Rnka24ZN0GsVDQJWP+4uBSXDujHRhmCfTg7p5G0eDdLanctNp0toV5OlmiLvUtjuhtG71QGkk6k7M+qNl4XY7bQ2kT2uzbahA1PRt89uW+D8Qwx3pQlk+2UvVso8OMCj07b0gPvJR5gf48t/CdzplqiNJgjjkonlaWYyvPuNdJuxsSr1A75CxrDi7soDzbk5jrTGfES5oTiMjI8OZs7xksjNigDOxb0v5svrS6Wa5Yo6pYdOtdmHAU1uh1kzHO5RTkAGynm9vFZFFhXN+2VoKALqV78GYVZRZDZtcGP5z2ZNcfOhV8R3rYJJJU19zc26bjU68BCrTM/2Ri46tQ62O+tu636oPgWMpXgYCZRqDyLeOMwsxnJBNSluVLqjhPIcjo1DbcsAlxpxLe57Vc/62Wkzc7q7JTDePzpExavtdJhRtRKtAoSyPNvGI+cDt+mMLXPoXh4TMdZm3TXqAT237nh5hY7FUHbBfrdKjxjcrKizwhI5d+lahUNtwy4H0Fyc7HlqKoCVj+8fKE1AmaD/+t+Pb/dfH00h8A3Wj37Lba7LtdKrmApf2PJiI+AWakdDNJhFT8Qy9iylAkzTj5WDZ1gDYxXIODwzC0y8m7B15cqjkJ/QV2AeE6GMaLqRpjKGXYC82aKazdmN08lctEkHbFxM4ZylXwC7DfRGuynrZwb8pq72wLUrzlyLTeskTK0JrwTWwZ4JEx/fBEwcZ51PHLg4VqG2huIR2/4SDuuUPx9VSSguGVNPKHTMV56RUCrMWQy3mJGj2FIzH3lJ16+0LF1LPteX47JI0+fceOP34Yk9JrTJJpyKJRPOWgG0PitP14r0IwPJiNmsIUKR8uCZ1sYAAzfyanIzMtOgBc6r l01vngB5AD51Knk2vRJh58ZvTLHNSqe5UV6Y4Jvxo63+L4/Qoe14+sjBqvNrl8G8Z2o1P5KMPr81Fa+ZnEqhHv4wgSt/PTKB1EMwczDpnsAVhQfDyGciRkioiEqsov1njr/WKXS2/YSa7Nz+idaYUGWEmnthk0Qe2WPns5Yk/3z/MPS3eyGplT7wfWnb+rbxW+vPfmE8pXfJcFuF1P8PdITuHIOYAgA= --===============8455935433251778651==--