From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1755228AbdBNU2Z (ORCPT ); Tue, 14 Feb 2017 15:28:25 -0500 Received: from mga01.intel.com ([192.55.52.88]:3973 "EHLO mga01.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752597AbdBNU2R (ORCPT ); Tue, 14 Feb 2017 15:28:17 -0500 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.35,162,1484035200"; d="gz'50?scan'50,208,50";a="58586517" Date: Wed, 15 Feb 2017 04:27:15 +0800 From: kbuild test robot To: Arushi Singhal Cc: kbuild-all@01.org, gregkh@linuxfoundation.org, devel@driverdev.osuosl.org, linux-kernel@vger.kernel.org Subject: Re: [PATCH] staging: fwserial: replace 'a' with '(a)' to avoid precedence issues Message-ID: <201702150412.TGebg11i%fengguang.wu@intel.com> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="r5Pyd7+fXNt84Ff3" Content-Disposition: inline In-Reply-To: <20170214175620.GA7418@arushi-HP-Pavilion-Notebook> User-Agent: Mutt/1.5.23 (2014-03-12) X-SA-Exim-Connect-IP: X-SA-Exim-Mail-From: fengguang.wu@intel.com X-SA-Exim-Scanned: No (on bee); SAEximRunCond expanded to false Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org --r5Pyd7+fXNt84Ff3 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline Hi Arushi, [auto build test ERROR on staging/staging-testing] [also build test ERROR on v4.10-rc8 next-20170214] [if your patch is applied to the wrong git tree, please drop us a note to help improve the system] url: https://github.com/0day-ci/linux/commits/Arushi-Singhal/staging-fwserial-replace-a-with-a-to-avoid-precedence-issues/20170215-020955 config: i386-randconfig-s0-02131304 (attached as .config) compiler: gcc-6 (Debian 6.2.0-3) 6.2.0 20160901 reproduce: # save the attached .config to linux build tree make ARCH=i386 All error/warnings (new ones prefixed by >>): >> drivers/staging/fwserial/fwserial.c:101:19: error: "(" may not appear in macro parameter list #define to_device((a), b) (a->b) ^ In file included from drivers/staging/fwserial/fwserial.c:21:0: drivers/staging/fwserial/fwserial.c: In function 'fwtty_log_tx_error': >> drivers/staging/fwserial/fwserial.c:111:22: error: implicit declaration of function 'to_device' [-Werror=implicit-function-declaration] dev_err_ratelimited(to_device(p, device), fmt, ##__VA_ARGS__) ^ include/linux/device.h:1364:13: note: in definition of macro 'dev_level_ratelimited' dev_level(dev, fmt, ##__VA_ARGS__); \ ^~~ >> drivers/staging/fwserial/fwserial.c:111:2: note: in expansion of macro 'dev_err_ratelimited' dev_err_ratelimited(to_device(p, device), fmt, ##__VA_ARGS__) ^~~~~~~~~~~~~~~~~~~ >> drivers/staging/fwserial/fwserial.c:201:3: note: in expansion of macro 'fwtty_err_ratelimited' fwtty_err_ratelimited(port, "card busy\n"); ^~~~~~~~~~~~~~~~~~~~~ >> drivers/staging/fwserial/fwserial.c:111:35: error: 'device' undeclared (first use in this function) dev_err_ratelimited(to_device(p, device), fmt, ##__VA_ARGS__) ^ include/linux/device.h:1364:13: note: in definition of macro 'dev_level_ratelimited' dev_level(dev, fmt, ##__VA_ARGS__); \ ^~~ >> drivers/staging/fwserial/fwserial.c:111:2: note: in expansion of macro 'dev_err_ratelimited' dev_err_ratelimited(to_device(p, device), fmt, ##__VA_ARGS__) ^~~~~~~~~~~~~~~~~~~ >> drivers/staging/fwserial/fwserial.c:201:3: note: in expansion of macro 'fwtty_err_ratelimited' fwtty_err_ratelimited(port, "card busy\n"); ^~~~~~~~~~~~~~~~~~~~~ drivers/staging/fwserial/fwserial.c:111:35: note: each undeclared identifier is reported only once for each function it appears in dev_err_ratelimited(to_device(p, device), fmt, ##__VA_ARGS__) ^ include/linux/device.h:1364:13: note: in definition of macro 'dev_level_ratelimited' dev_level(dev, fmt, ##__VA_ARGS__); \ ^~~ >> drivers/staging/fwserial/fwserial.c:111:2: note: in expansion of macro 'dev_err_ratelimited' dev_err_ratelimited(to_device(p, device), fmt, ##__VA_ARGS__) ^~~~~~~~~~~~~~~~~~~ >> drivers/staging/fwserial/fwserial.c:201:3: note: in expansion of macro 'fwtty_err_ratelimited' fwtty_err_ratelimited(port, "card busy\n"); ^~~~~~~~~~~~~~~~~~~~~ In file included from include/linux/printk.h:320:0, from include/linux/kernel.h:13, from include/linux/sched.h:17, from drivers/staging/fwserial/fwserial.c:19: drivers/staging/fwserial/fwserial.c: In function '__fwtty_restart_tx': drivers/staging/fwserial/fwserial.c:109:23: error: 'device' undeclared (first use in this function) dev_dbg(to_device(p, device), "%s: " fmt, __func__, ##__VA_ARGS__) ^ include/linux/dynamic_debug.h:134:34: note: in definition of macro 'dynamic_dev_dbg' __dynamic_dev_dbg(&descriptor, dev, fmt, \ ^~~ >> drivers/staging/fwserial/fwserial.c:109:2: note: in expansion of macro 'dev_dbg' dev_dbg(to_device(p, device), "%s: " fmt, __func__, ##__VA_ARGS__) ^~~~~~~ >> drivers/staging/fwserial/fwserial.c:290:2: note: in expansion of macro 'fwtty_dbg' fwtty_dbg(port, "fifo len: %d avail: %d\n", len, avail); ^~~~~~~~~ drivers/staging/fwserial/fwserial.c: In function 'fwtty_update_port_status': drivers/staging/fwserial/fwserial.c:109:23: error: 'device' undeclared (first use in this function) dev_dbg(to_device(p, device), "%s: " fmt, __func__, ##__VA_ARGS__) ^ include/linux/dynamic_debug.h:134:34: note: in definition of macro 'dynamic_dev_dbg' __dynamic_dev_dbg(&descriptor, dev, fmt, \ ^~~ >> drivers/staging/fwserial/fwserial.c:109:2: note: in expansion of macro 'dev_dbg' dev_dbg(to_device(p, device), "%s: " fmt, __func__, ##__VA_ARGS__) ^~~~~~~ drivers/staging/fwserial/fwserial.c:327:2: note: in expansion of macro 'fwtty_dbg' fwtty_dbg(port, "status: %x delta: %x\n", status, delta); ^~~~~~~~~ drivers/staging/fwserial/fwserial.c: In function 'fwtty_emit_breaks': drivers/staging/fwserial/fwserial.c:109:23: error: 'device' undeclared (first use in this function) dev_dbg(to_device(p, device), "%s: " fmt, __func__, ##__VA_ARGS__) ^ include/linux/dynamic_debug.h:134:34: note: in definition of macro 'dynamic_dev_dbg' __dynamic_dev_dbg(&descriptor, dev, fmt, \ ^~~ >> drivers/staging/fwserial/fwserial.c:109:2: note: in expansion of macro 'dev_dbg' dev_dbg(to_device(p, device), "%s: " fmt, __func__, ##__VA_ARGS__) ^~~~~~~ drivers/staging/fwserial/fwserial.c:523:2: note: in expansion of macro 'fwtty_dbg' fwtty_dbg(port, "sending %d brks\n", n); ^~~~~~~~~ drivers/staging/fwserial/fwserial.c: In function 'fwtty_rx': drivers/staging/fwserial/fwserial.c:109:23: error: 'device' undeclared (first use in this function) dev_dbg(to_device(p, device), "%s: " fmt, __func__, ##__VA_ARGS__) ^ include/linux/dynamic_debug.h:134:34: note: in definition of macro 'dynamic_dev_dbg' __dynamic_dev_dbg(&descriptor, dev, fmt, \ ^~~ >> drivers/staging/fwserial/fwserial.c:109:2: note: in expansion of macro 'dev_dbg' dev_dbg(to_device(p, device), "%s: " fmt, __func__, ##__VA_ARGS__) ^~~~~~~ drivers/staging/fwserial/fwserial.c:547:2: note: in expansion of macro 'fwtty_dbg' fwtty_dbg(port, "%d\n", n); ^~~~~~~~~ In file included from drivers/staging/fwserial/fwserial.c:21:0: drivers/staging/fwserial/fwserial.c: In function 'fwtty_port_handler': >> drivers/staging/fwserial/fwserial.c:111:35: error: 'device' undeclared (first use in this function) dev_err_ratelimited(to_device(p, device), fmt, ##__VA_ARGS__) ^ include/linux/device.h:1364:13: note: in definition of macro 'dev_level_ratelimited' dev_level(dev, fmt, ##__VA_ARGS__); \ ^~~ >> drivers/staging/fwserial/fwserial.c:111:2: note: in expansion of macro 'dev_err_ratelimited' dev_err_ratelimited(to_device(p, device), fmt, ##__VA_ARGS__) ^~~~~~~~~~~~~~~~~~~ drivers/staging/fwserial/fwserial.c:630:3: note: in expansion of macro 'fwtty_err_ratelimited' fwtty_err_ratelimited(port, "ignoring unauthenticated data\n"); ^~~~~~~~~~~~~~~~~~~~~ In file included from include/linux/printk.h:320:0, from include/linux/kernel.h:13, from include/linux/sched.h:17, from drivers/staging/fwserial/fwserial.c:19: drivers/staging/fwserial/fwserial.c: In function 'fwtty_tx_complete': drivers/staging/fwserial/fwserial.c:109:23: error: 'device' undeclared (first use in this function) dev_dbg(to_device(p, device), "%s: " fmt, __func__, ##__VA_ARGS__) ^ include/linux/dynamic_debug.h:134:34: note: in definition of macro 'dynamic_dev_dbg' __dynamic_dev_dbg(&descriptor, dev, fmt, \ ^~~ >> drivers/staging/fwserial/fwserial.c:109:2: note: in expansion of macro 'dev_dbg' dev_dbg(to_device(p, device), "%s: " fmt, __func__, ##__VA_ARGS__) ^~~~~~~ drivers/staging/fwserial/fwserial.c:687:2: note: in expansion of macro 'fwtty_dbg' fwtty_dbg(port, "rcode: %d\n", rcode); ^~~~~~~~~ drivers/staging/fwserial/fwserial.c: In function 'fwtty_tx': drivers/staging/fwserial/fwserial.c:109:23: error: 'device' undeclared (first use in this function) dev_dbg(to_device(p, device), "%s: " fmt, __func__, ##__VA_ARGS__) ^ include/linux/dynamic_debug.h:134:34: note: in definition of macro 'dynamic_dev_dbg' __dynamic_dev_dbg(&descriptor, dev, fmt, \ ^~~ >> drivers/staging/fwserial/fwserial.c:109:2: note: in expansion of macro 'dev_dbg' dev_dbg(to_device(p, device), "%s: " fmt, __func__, ##__VA_ARGS__) ^~~~~~~ drivers/staging/fwserial/fwserial.c:750:3: note: in expansion of macro 'fwtty_dbg' fwtty_dbg(port, "out: %u rem: %d\n", txn->dma_pended.len, n); ^~~~~~~~~ drivers/staging/fwserial/fwserial.c: In function 'fwtty_write_xchar': drivers/staging/fwserial/fwserial.c:109:23: error: 'device' undeclared (first use in this function) dev_dbg(to_device(p, device), "%s: " fmt, __func__, ##__VA_ARGS__) ^ include/linux/dynamic_debug.h:134:34: note: in definition of macro 'dynamic_dev_dbg' __dynamic_dev_dbg(&descriptor, dev, fmt, \ ^~~ >> drivers/staging/fwserial/fwserial.c:109:2: note: in expansion of macro 'dev_dbg' dev_dbg(to_device(p, device), "%s: " fmt, __func__, ##__VA_ARGS__) ^~~~~~~ drivers/staging/fwserial/fwserial.c:820:2: note: in expansion of macro 'fwtty_dbg' fwtty_dbg(port, "%02x\n", ch); ^~~~~~~~~ drivers/staging/fwserial/fwserial.c: In function 'fwtty_port_dtr_rts': drivers/staging/fwserial/fwserial.c:109:23: error: 'device' undeclared (first use in this function) dev_dbg(to_device(p, device), "%s: " fmt, __func__, ##__VA_ARGS__) ^ include/linux/dynamic_debug.h:134:34: note: in definition of macro 'dynamic_dev_dbg' __dynamic_dev_dbg(&descriptor, dev, fmt, \ ^~~ >> drivers/staging/fwserial/fwserial.c:109:2: note: in expansion of macro 'dev_dbg' dev_dbg(to_device(p, device), "%s: " fmt, __func__, ##__VA_ARGS__) ^~~~~~~ drivers/staging/fwserial/fwserial.c:905:2: note: in expansion of macro 'fwtty_dbg' fwtty_dbg(port, "on/off: %d\n", on); ^~~~~~~~~ drivers/staging/fwserial/fwserial.c: In function 'fwtty_port_carrier_raised': drivers/staging/fwserial/fwserial.c:109:23: error: 'device' undeclared (first use in this function) dev_dbg(to_device(p, device), "%s: " fmt, __func__, ##__VA_ARGS__) ^ include/linux/dynamic_debug.h:134:34: note: in definition of macro 'dynamic_dev_dbg' __dynamic_dev_dbg(&descriptor, dev, fmt, \ ^~~ vim +101 drivers/staging/fwserial/fwserial.c 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 */ 16 17 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 18 > 19 #include 20 #include > 21 #include 22 #include 23 #include 24 #include 25 #include 26 #include 27 #include 28 29 #include "fwserial.h" 30 31 #define be32_to_u64(hi, lo) ((u64)be32_to_cpu(hi) << 32 | be32_to_cpu(lo)) 32 33 #define LINUX_VENDOR_ID 0xd00d1eU /* same id used in card root directory */ 34 #define FWSERIAL_VERSION 0x00e81cU /* must be unique within LINUX_VENDOR_ID */ 35 36 /* configurable options */ 37 static int num_ttys = 4; /* # of std ttys to create per fw_card */ 38 /* - doubles as loopback port index */ 39 static bool auto_connect = true; /* try to VIRT_CABLE to every peer */ 40 static bool create_loop_dev = true; /* create a loopback device for each card */ 41 42 module_param_named(ttys, num_ttys, int, 0644); 43 module_param_named(auto, auto_connect, bool, 0644); 44 module_param_named(loop, create_loop_dev, bool, 0644); 45 46 /* 47 * Threshold below which the tty is woken for writing 48 * - should be equal to WAKEUP_CHARS in drivers/tty/n_tty.c because 49 * even if the writer is woken, n_tty_poll() won't set POLLOUT until 50 * our fifo is below this level 51 */ 52 #define WAKEUP_CHARS 256 53 54 /** 55 * fwserial_list: list of every fw_serial created for each fw_card 56 * See discussion in fwserial_probe. 57 */ 58 static LIST_HEAD(fwserial_list); 59 static DEFINE_MUTEX(fwserial_list_mutex); 60 61 /** 62 * port_table: array of tty ports allocated to each fw_card 63 * 64 * tty ports are allocated during probe when an fw_serial is first 65 * created for a given fw_card. Ports are allocated in a contiguous block, 66 * each block consisting of 'num_ports' ports. 67 */ 68 static struct fwtty_port *port_table[MAX_TOTAL_PORTS]; 69 static DEFINE_MUTEX(port_table_lock); 70 static bool port_table_corrupt; 71 #define FWTTY_INVALID_INDEX MAX_TOTAL_PORTS 72 73 #define loop_idx(port) (((port)->index) / num_ports) 74 #define table_idx(loop) ((loop) * num_ports + num_ttys) 75 76 /* total # of tty ports created per fw_card */ 77 static int num_ports; 78 79 /* slab used as pool for struct fwtty_transactions */ 80 static struct kmem_cache *fwtty_txn_cache; 81 82 struct tty_driver *fwtty_driver; 83 static struct tty_driver *fwloop_driver; 84 85 static struct dentry *fwserial_debugfs; 86 87 struct fwtty_transaction; 88 typedef void (*fwtty_transaction_cb)(struct fw_card *card, int rcode, 89 void *data, size_t length, 90 struct fwtty_transaction *txn); 91 92 struct fwtty_transaction { 93 struct fw_transaction fw_txn; 94 fwtty_transaction_cb callback; 95 struct fwtty_port *port; 96 union { 97 struct dma_pending dma_pended; 98 }; 99 }; 100 > 101 #define to_device((a), b) (a->b) 102 #define fwtty_err(p, fmt, ...) \ 103 dev_err(to_device(p, device), fmt, ##__VA_ARGS__) 104 #define fwtty_info(p, fmt, ...) \ 105 dev_info(to_device(p, device), fmt, ##__VA_ARGS__) 106 #define fwtty_notice(p, fmt, ...) \ 107 dev_notice(to_device(p, device), fmt, ##__VA_ARGS__) 108 #define fwtty_dbg(p, fmt, ...) \ > 109 dev_dbg(to_device(p, device), "%s: " fmt, __func__, ##__VA_ARGS__) 110 #define fwtty_err_ratelimited(p, fmt, ...) \ > 111 dev_err_ratelimited(to_device(p, device), fmt, ##__VA_ARGS__) 112 113 #ifdef DEBUG 114 static inline void debug_short_write(struct fwtty_port *port, int c, int n) 115 { 116 int avail; 117 118 if (n < c) { 119 spin_lock_bh(&port->lock); 120 avail = dma_fifo_avail(&port->tx_fifo); 121 spin_unlock_bh(&port->lock); 122 fwtty_dbg(port, "short write: avail:%d req:%d wrote:%d\n", 123 avail, c, n); 124 } 125 } 126 #else 127 #define debug_short_write(port, c, n) 128 #endif 129 130 static struct fwtty_peer *__fwserial_peer_by_node_id(struct fw_card *card, 131 int generation, int id); 132 133 #ifdef FWTTY_PROFILING 134 135 static void fwtty_profile_fifo(struct fwtty_port *port, unsigned int *stat) 136 { 137 spin_lock_bh(&port->lock); 138 fwtty_profile_data(stat, dma_fifo_avail(&port->tx_fifo)); 139 spin_unlock_bh(&port->lock); 140 } 141 142 static void fwtty_dump_profile(struct seq_file *m, struct stats *stats) 143 { 144 /* for each stat, print sum of 0 to 2^k, then individually */ 145 int k = 4; 146 unsigned int sum; 147 int j; 148 char t[10]; 149 150 snprintf(t, 10, "< %d", 1 << k); 151 seq_printf(m, "\n%14s %6s", " ", t); 152 for (j = k + 1; j < DISTRIBUTION_MAX_INDEX; ++j) 153 seq_printf(m, "%6d", 1 << j); 154 155 ++k; 156 for (j = 0, sum = 0; j <= k; ++j) 157 sum += stats->reads[j]; 158 seq_printf(m, "\n%14s: %6d", "reads", sum); 159 for (j = k + 1; j <= DISTRIBUTION_MAX_INDEX; ++j) 160 seq_printf(m, "%6d", stats->reads[j]); 161 162 for (j = 0, sum = 0; j <= k; ++j) 163 sum += stats->writes[j]; 164 seq_printf(m, "\n%14s: %6d", "writes", sum); 165 for (j = k + 1; j <= DISTRIBUTION_MAX_INDEX; ++j) 166 seq_printf(m, "%6d", stats->writes[j]); 167 168 for (j = 0, sum = 0; j <= k; ++j) 169 sum += stats->txns[j]; 170 seq_printf(m, "\n%14s: %6d", "txns", sum); 171 for (j = k + 1; j <= DISTRIBUTION_MAX_INDEX; ++j) 172 seq_printf(m, "%6d", stats->txns[j]); 173 174 for (j = 0, sum = 0; j <= k; ++j) 175 sum += stats->unthrottle[j]; 176 seq_printf(m, "\n%14s: %6d", "avail @ unthr", sum); 177 for (j = k + 1; j <= DISTRIBUTION_MAX_INDEX; ++j) 178 seq_printf(m, "%6d", stats->unthrottle[j]); 179 } 180 181 #else 182 #define fwtty_profile_fifo(port, stat) 183 #define fwtty_dump_profile(m, stats) 184 #endif 185 186 /* 187 * Returns the max receive packet size for the given node 188 * Devices which are OHCI v1.0/ v1.1/ v1.2-draft or RFC 2734 compliant 189 * are required by specification to support max_rec of 8 (512 bytes) or more. 190 */ 191 static inline int device_max_receive(struct fw_device *fw_device) 192 { 193 /* see IEEE 1394-2008 table 8-8 */ 194 return min(2 << fw_device->max_rec, 4096); 195 } 196 197 static void fwtty_log_tx_error(struct fwtty_port *port, int rcode) 198 { 199 switch (rcode) { 200 case RCODE_SEND_ERROR: > 201 fwtty_err_ratelimited(port, "card busy\n"); 202 break; 203 case RCODE_ADDRESS_ERROR: 204 fwtty_err_ratelimited(port, "bad unit addr or write length\n"); 205 break; 206 case RCODE_DATA_ERROR: 207 fwtty_err_ratelimited(port, "failed rx\n"); 208 break; 209 case RCODE_NO_ACK: 210 fwtty_err_ratelimited(port, "missing ack\n"); 211 break; 212 case RCODE_BUSY: 213 fwtty_err_ratelimited(port, "remote busy\n"); 214 break; 215 default: 216 fwtty_err_ratelimited(port, "failed tx: %d\n", rcode); 217 } 218 } 219 220 static void fwtty_txn_constructor(void *this) 221 { 222 struct fwtty_transaction *txn = this; 223 224 init_timer(&txn->fw_txn.split_timeout_timer); 225 } 226 227 static void fwtty_common_callback(struct fw_card *card, int rcode, 228 void *payload, size_t len, void *cb_data) 229 { 230 struct fwtty_transaction *txn = cb_data; 231 struct fwtty_port *port = txn->port; 232 233 if (port && rcode != RCODE_COMPLETE) 234 fwtty_log_tx_error(port, rcode); 235 if (txn->callback) 236 txn->callback(card, rcode, payload, len, txn); 237 kmem_cache_free(fwtty_txn_cache, txn); 238 } 239 240 static int fwtty_send_data_async(struct fwtty_peer *peer, int tcode, 241 unsigned long long addr, void *payload, 242 size_t len, fwtty_transaction_cb callback, 243 struct fwtty_port *port) 244 { 245 struct fwtty_transaction *txn; 246 int generation; 247 248 txn = kmem_cache_alloc(fwtty_txn_cache, GFP_ATOMIC); 249 if (!txn) 250 return -ENOMEM; 251 252 txn->callback = callback; 253 txn->port = port; 254 255 generation = peer->generation; 256 smp_rmb(); 257 fw_send_request(peer->serial->card, &txn->fw_txn, tcode, 258 peer->node_id, generation, peer->speed, addr, payload, 259 len, fwtty_common_callback, txn); 260 return 0; 261 } 262 263 static void fwtty_send_txn_async(struct fwtty_peer *peer, 264 struct fwtty_transaction *txn, int tcode, 265 unsigned long long addr, void *payload, 266 size_t len, fwtty_transaction_cb callback, 267 struct fwtty_port *port) 268 { 269 int generation; 270 271 txn->callback = callback; 272 txn->port = port; 273 274 generation = peer->generation; 275 smp_rmb(); 276 fw_send_request(peer->serial->card, &txn->fw_txn, tcode, 277 peer->node_id, generation, peer->speed, addr, payload, 278 len, fwtty_common_callback, txn); 279 } 280 281 static void __fwtty_restart_tx(struct fwtty_port *port) 282 { 283 int len, avail; 284 285 len = dma_fifo_out_level(&port->tx_fifo); 286 if (len) 287 schedule_delayed_work(&port->drain, 0); 288 avail = dma_fifo_avail(&port->tx_fifo); 289 > 290 fwtty_dbg(port, "fifo len: %d avail: %d\n", len, avail); 291 } 292 293 static void fwtty_restart_tx(struct fwtty_port *port) --- 0-DAY kernel test infrastructure Open Source Technology Center https://lists.01.org/pipermail/kbuild-all Intel Corporation --r5Pyd7+fXNt84Ff3 Content-Type: application/gzip Content-Disposition: attachment; filename=".config.gz" Content-Transfer-Encoding: base64 H4sICNJko1gAAy5jb25maWcAjFxbc9u4kn6fX6HK7MM5D5P4Fo9PbfkBIkEJI4JgAFAXv7Ac W8m4xrGztjyX/fXbDZAiADWVzYMrRDfuje6vuwH9/NPPE/a2e/52u3u4u318/Gfydfu0fbnd be8nXx4et/89ydWkUnbCc2HfA3P58PT294eH86vLycX705P3J7+83P06WWxfnraPk+z56cvD 1zeo/vD89NPPwJ6pqhCz9vJiKuzk4XXy9LybvG53P3Xl66vL9vzs+p/ge/gQlbG6yaxQVZvz TOVcD0TV2LqxbaG0ZPb63fbxy/nZLzisdz0H09kc6hX+8/rd7cvd7x/+vrr8cOdG+eom0d5v v/jvfb1SZYuc161p6lppO3RpLMsWVrOMH9KkbIYP17OUrG51lbcwc9NKUV1fHaOz9fXpJc2Q KVkz+8N2IraouYrzvM0la5EVZmH5MFZHMzNHLnk1s/OBNuMV1yJrhWFIPyRMm9lh4XzFxWxu 0+Vgm3bOlryts7bIs4GqV4bLdp3NZyzPW1bOlBZ2Lg/bzVgpphoGD5task3S/pyZNqubVgNt TdFYNudtKSrYPHETLIAblOG2qduaa9cG05wlK9STuJzCVyG0sW02b6rFCF/NZpxm8yMSU64r 5kS7VsaIackTFtOYmsO2jpBXrLLtvIFeagkbOIcxUxxu8VjpOG05PejDibFpVW2FhGXJ4dDB GolqNsaZc9h0Nz1WwklJ1lFUlpetXdvoSMMRb0t2s2lnZqzZptZqygNyIdYtZ7rcwHcreSAP fgRa5cwGu1TPLINVAhle8tJcnw3cRX+uhQFF8eHx4fOHb8/3b4/b1w//1VRMcpQZzgz/8D7R BEJ/aldKB5s3bUSZw1Lxlq99fyZSA3YOooOLWCj401pmsLLThDOnVx9R+719h5K+Ra0WvGph kkbWoe4TtuXVEpYJRy6FvT7fzynTIBPuvAuQi3fvBj3blbWWG0rdwoaxcsm1AbnDekRxyxqr kl1dgKzCts5uRE1TpkA5o0nlTag4Qsr6ZqzGSP/lzQUQ9nMNRhVONaW7sR1jwBEeo69vjtdW xEJHIx4kkTUlHFplLIrd9bt/PT0/bf+93wazYnU4QbMxS1FnZO+gFeCAyE8NbzjJ4GUEDo7S m5ZZMF1zYpzFnFV5qFsaw0HLhqNgTU6abrcz7hA7DhgsCFHZSzscncnr2+fXf15322+DtO8t Cpwsd+IJYwMkM1crmpLNQxnEklxJBkaRKAMtC7oPRrg5bEsagZyjhKHZ/UIEDTsVRKwJsgAi yUCPek0QKVJTM2143G2GaMOoBuqAwrbZPFep6g1ZYp0XUpZgHXM0jiVDm7PJSmJtneZaDluV WlhsD/RnZc1RIiotlmfQ0XE2ACsty39rSD6pUOvnHow4mbEP37Yvr5TYWJEtQEVykIugqUq1 8xtUeVJFGwWFYIaFykVG7JGvJSKpd2VRE4BgwCwYt2LahM14WFs3H+zt6x+THYx5cvt0P3nd 3e5eJ7d3d89vT7uHp6/J4B2syDLVVDaSCZQYtysUcWpyPCUZh5MMdBuOMKW1y3NSD6AJQsh3 OAedNRNDrXW1aYEWdgafYPBgUSlFYBJm1yNWIXixIRhNWRLbZjXnjsFBbHIy/ThA3/B2qhQ1 HGeiAQVXZwE4EYvOCzgocYs4FJcKWyhAA4nCXp/+upcQKVLaeaQJG3BWPCAAnJn7YxCc1JlW TR2cKocP3Y6HTg2o62wWrokrcIaBmmm56BoOq3h4NNCIip7QrgBo8yk7HKefQ4DFmNBtTBns TAHqAIzISuSWsjDajtb05bXIzfgYCxCKG7dEab0O0VJVa7BiToUN5hI2GXvqaLTF9O3mfClG xK/jgDbwxI0PGg5KQYz4wGoMll5liz0XqHiq6TnPFrUCgI16yaoQ7iOaAOOS8WjODWjgilpa WAENlEAYYWHC74rb6NuLNALDA2kDW1KgU1BrnoEqzykJiL01lExYY4dwdSBk7ptJaM1btACf 6jzBnlCQQE4oiZEmFIQA09FV8n1B9Y4QGlbYQ+T3X/93P4os27tJaOTdLmP0ocp4tNkJG3qb lNYEI2wDG8wqwN6iUnnoBHnNIvLTICriK4IazHjt/EenLpM6dWbqBQyxZBbHGKx+XQwfXqUH 4C/uSQJaFSgsQedw5iTo93bAEIkodITRGbcH6MNDWW9oh9IF8JiNJErapN+hfGpU2YBlgFnB GaVgec86BXfPCaYVy2Dtag3na5F+o/IPXcBIQ/OyAJHR1BaPbwL2XjThIhQw7iBswWsVUo2Y VawsgtPilisscJCriBQs7PWx7ZhHXjUTKkL9+VLAILvqhtRaKBrOpSmoY19nov3UCL2IlBL0 OWVaAzAnqrjgSh5aHi/M0E2bwlJXCCNol7IPRDhU00Ui6+3Ll+eXb7dPd9sJ/3P7BNiMAUrL EJ0ByBzgDtl4F+Q47GI/j6X0lXobTq9QH5LTC2oDShY5WqZsprR1KNUYgU2dhcTQRqvBCitJ M26M5dKZlhb8fFGIzMWeqG3TqhBlBEOVL+OHJd0aOEVRl6EAu407UhHxlJPhgfZbI2vwXqY8 FHxAruAsLPgGNAscNYxrRDbOh43ISbshuMAzaAw4QGjCMsTLY84sL2BdBE6oqeIaiUeGMoEw E6Ay4HDvtYcNCdAHGGqFwdmEtEjjXL5Uc0sSwJLQFXwpho0KSv9HGmvw1B3rXKlFQsTgL3xb MWtUQ/h+BnYGPabOq02WAwONgAE2AEPQx3TmwQXuk140n4GSrnIfSO+WtmV1OtSspMYHfP5c JrT5Cs4XZx4bJTQp1rCHA9m4MaT2FeEQbECjK3AELRyOUCpTDUQsraMSDff6Q3cTzhuZSopb P0rwu7i138rWsAKWRdYYJU8Xy5f6GN4ILVfNSABZ1ACLXVSijwoS4zM8Q0XWwsG1B0szA7xT l81MVJGeD4rHjhtwuHXBU8IzQLQJioqJFCROeWD7qhSLJRywTU3JNK2tD7hBjFVFBXqGxVkJ Owc14He40IjEU21wzMWPzmaFESLexfXRQwywmMqbEg48qh6EHJoQFuMpzgwcpjgOk04JA1+D piQPeFzrKt5FVW/6sLctIxkYuoWxzcklx8zStHFKgNrgEvazRQ91xXQejFeBhw+YqEuRnB8Q mEsaRpJQNxjlGVR8URyxGm7Qyy5blkXG28fyM7X85fPt6/Z+8ofHG99fnr88PPq4T3AI1LIL BROz2++aY+sNYwSN/QnrlLBX0nOOEhJYSFAcmG4IXBs0yIAmQ0F0iNMgjLk+CcCYFypibL24 uZhMCQajCTTXNI5tlNOcFSHV+3dTE+HkoLgUNJwZPEPLZ1rYzVGuG5ANCnf2dJBJZW2MZFxU ROYuC+jUno5pq6k9KGjNp3QeWCo/HUhFffuye8DM98T+830bYkymrXC+GsBq9BcjmM7AfagG HnLSDDyk4xzKFD9qQ8LB+BGPZVrQPL1ksGygR8je5MocrVrmMqoaFCeG3cwE3QkATf3DpTDN j5ZzwcBvPzpWXoyMAJMyl1dH6wYSls4VpUd+Qt+o91eEmpi737eYjwzdEqF80KVSKsx3dKU5 aFvsIhxYT8uKT+Sc+/RTX5cYeM8Sd9qXdh1cv3t6fv6+j4o0lcsYg3apwQw2Vawb4iQvswoR oparhAOtmktl5a4Zl9YYZ9GrhGEIEvpz+PJ8t319fX6Z7OAcuuj8l+3t7u0lPJOoPrpLDcPe SipaignsgjPAh9xH2oaOHQnzLT0d/ZOELmunaQJQDUaqEGYebZ7Lm+scXBVy87AhvrZg7PCO QRdQGBmrb6usTWSMkcLkUJmIcw6CVLRyKhLhcmWjmS9sfr/PXdaxYKJswjhldxVAaBENzcst iIb1AKp1WJ2MEMw3AKqXwgA2mzU8zCvBIrOl0JF32JeNjnoBbnzfzqAclp0+akcgQumq+Ip0 crbvN4F9lLvdsyYJA8AqmN/wIZpBx15cXVI6+aO7NjWwwbc1dOIYaVKuadpl3PxAAJhlRSOF +AH5OJ0OTvTUC5q6GBnS4teR8iu6PNONUXRcXzpYyEeMhVyJCtPO2chAOvJ5PtJ2yUbanXGV 89n69Ai1LUd2KtuAHRxd76Vg2XlL33pwxJG1w0DmSC3U3SPnvgOo8Tl3JxjD2d3NK580uwxZ ytOEFimrGhAx6NWK1FFO8Z6cFPENNKfjMHAjEeGHoexBL6I/jj5LoqRFJWQjnZtQAFAqN9cX QUQMAxXoDvKSh1EN5Aal51tOvQ0kuF0ClUe7mx0TaGU6ieWbgKmwRh926vxFyS3zFygPmm1k lvTc69Ca2zT25sq4BNfYcnAggr3Mw3BH5S63mevTYW04l7U9cLz78qUqQfUxTUP5jouMQvr6 TnMO/TcYJ7HcZWviDcR1rFMZxK1Rh8UuVEKwC9UXRoKouVaYVcBkTndbC1Uz+vWU6+TEKU4J dUVeTkbtOzgGzjOVoxLv2/jNy6CHOkGY+9vz08Pu+SXxQcPQVXcCqjRfcYRZs5ryXQ8Zs+Re qVtoDp74Bhzp8FZv9zWk/RUc/ykNe8QVFTj3m4J7UIi1z6oPekpkcFxB7YwuszQUsEAKiLbI QxOMt0ASC9wVXdB53I56OUJeSlOXgHLOf0TGuC8xyJ7hLPKsh9K02gHLKQ1BZrxVRWG4vT75 ++rE/0uUMaNk0gHzAk4kzLnlFSMusTrsO052CrXHixK2LQh+iBLlp+zRIN5wavj1yd5HPFa3 H5RkVcPiLOV+RJ5GXYrzlePWWmfLfL3AORqa86mKNADNZRItiYq7RsMG/a11YTKmc6J6N11A wCVLXVPXdIca/RXUKjkI+0GjMNTWDcEp9Iuk/SkmvCLH1Rf4jFYWO7VUmRQzfTDAer4BJzDP dWsPXwQMERbQ+aQK9JBaYcAw6Eg2YdR+QPGGgiu9L+simv56Wq6vL07+E1+9H/dkwkRmQKGv XhERXepCWnhvfBGIXVZysAmIkMKOC61A69I3grLYn4XPI5dO9tSCvH+DKRfNmbne34G6qZUK ztjNtAm05c15AX5t8G1kckG8v6ENS1/7qNx+KD2zO0TEYPoQqLsQ3qfXxqIMsMdcawwluCSU 128dYhgsC2azHAVzYgvaOXNGAe/dtFNwgDHNr5s6lnNkwSOHfpzshWJg9NVjds0Bgi4xrLq6 vrwIJMpqOi/hpncku+t8b0kKxIB7ZR1eLyhE9AFL1cS5aJ/yoY3cTXt6cjJGOvt4QowDCOcn J5Gycq3QvNfnof3x4YG5xnuUdDSPrzl10xPVjUCoB1Kl0baddqato2uOSNDGdmmfPnEx83jn 3El1tcKLCH0vzvOAXs4S+9ldAljmRo2cQx8uBDGiwSHYNlFs2jK31HUOjwOf/9q+TAAH3n7d fts+7VzQi2W1mDx/x4j0awgJu7TJCILZP0yhVjTQTvUQtR0UvNxHuEdjLjkwHd50DkudcwKQ +/r07CToTdV11HuUJl59ApywAiU6ZHg6XR+oiSxMNeNXj1CdDJiDRIdPfuFjpi4thFXq8PGS K+luV/j+HQw2hw/EHKdbk1lsqCKCc09pJeD6BmxbGN8ThceQR/Nlq5agAUXOw8dDcUs8o3R/ zMOoQ+UoU2YBkW2S2U0ba0Pd6AqXMAyVlBUs5crjqHE/V+92712Lw8VwDGOjFLUUB7WyxlgF omtyytDsc3KO19urpgYok/NkeMdoB+fCjzcTeJVn7BkkSHTvlCcjBnvPQEGMznMO5qdsZge+ rhfOqUlKoqu94ZpIbucqP+h/OtM0UOvELW/wuM8Br64AMLSqKjeUVt8fIFbzg8spfXl8u4Jg Hzhnc57OzJVz8JAP5uAp+BpvXC3Zwh+spNFAVyVHaA0AmnSoMMmhas1naRJaZzGREgWvRtI2 emy8tu0qG++hFxj4P4nqTLFPPOENyeJl+z9v26e7fyavd7eP0asFFwnTPHyq0pW0M7XEF0UY D7Mj5MPb/XvyCMTb03uIjs2MXbEleXHdDEjTaLDtoAoqW3dv+v9fRVU5YM8R40nWABriPXfT 9Ni8D+dLcvSzHKHvp0Su19gM6C0cxh3KzJdUZib3Lw9/RslLYPPLEItHV+ZSUDlfphEyj1Nr p+zHdCTOvlKrdpHEdgfCrzFhtnZwR6o8LgcExHMw2z7AqkWlfkRve6AY4+49nyAf2MU8JtRu btwXPvEjY73bRaPcglXuQRkVyPWxzGqmm6rfoNffb1+29wHoI4fhX/iRJPd8GrPI4B/3vst+ 68X94zYEkigv6EiNey2ImM2eD8O5dRnf2nDtTd9e+zFP/gV2crLd3b3/d3CBIosMOVrSmUKf jI5iOrKU/pNS0I4hF5rHb6p8uSrH3lw6Mqso84a0fYNhmXswaNJesmp6dlJyf0F6rDOOCHLa UHoc25BGxH2NP110IxkxfEjT/jF3F6RLngA73JL4h3MX/h5pjUX3tKFAqGVcUOtk6DUzYegV i5ILkT3ISUQhKHbGj3ZqAqYMxYuAJwGLmdf76+TI/fvz625y9/y0e3l+fAQ360Df4V61+cop tmgSWBpFHfx1Nyrp7n9iobsNG1agrHiGTmbkr7uSufYQkqiCQh1WwO92rU4/QlV60cCdpXOP FbcfP56cEp3MuIp2HmOYsRjKTJCPm4DRR/W6Rf/l7vblfvL55eH+a3hpY4PJsKEH99mqs7RE i0zN00Ir0hIOTrdtKn7A6TMSYUygFrlQBwUuTrv3Vs8Dn79n6A6UXrd23brwFLmk+/YkjmqW 3M45ZBs5ykOvjcTwRegM9LRsLkPvqy+WOLg282bZPw+9/f5wj7eT/nrY3f0eCP3BcKwRH3+l ZWXfa23a9frIkLGNy6tQWMKqM15RBrBn0WvHEtwDdUZtY4ppPxv+9/bubXf7+XHrftZm4rJm u9fJhwn/9vZ4m5hLvFEpLV6nDcJkZZFFr+46JpNpUacXzxkKRMpJFkoQoTCUjv5UeE28ix6d pz+v0N2lEiqKhNYyc5ShpOL7ZGG13f31/PIHQjYiKgSgccEpZN5UYh1uDH6D5DM6qoxvBxec zveCXNOeJJTj72xg2FGyEYOIDdcWUEnJjBEF3UPfUD3fuHMJYFLWSXA3ZPZX2mn9Z+lo61SL fEafz2XJqvbq5Ox07AZeNrYAZZnRlwRETR8sZllJr9P67CPdBavpa7f1XI0NS3DOcT4f6bs5 uCUuOktPN6P7yyt8hmEU/uIIvcKw9MzdlaVXGV/L8hFNCkMqRbUYl09Zj7xmm5uRVwH+Wa4T Py1GQrgDjxdPyrtCKhgCsHObNn7eN/1UJmd0stu+7pJM/pxJzfKxEYxcMhI6p1PrU3rHjQUs KLvL0cQkVgJ/LCe+WpgVMxQS+h4T+BoHRD+rvtbTdnv/Otk9Tz5vJ9snVNH3qJ4nkmWOYVDL fQnGENybAvydK/9zToHtXQkopa1RsRAlHWP3pO55SPLcJJL3/9BJkYyJgq5T0M5EuQLoUY1c B8nxJzww8Tc6DDDUKOfEDuEPbeFl2Y6jF6x8++fD3XaS78348KNED3dd8USlfmPjH/jNeVmH gbGoGITFzoPX2tCxlXURiUhf1kq80ENBWsuqnJWqil7j+m4KoaULLbqfdhjoxQrcX5bHIdM9 s6jGn17wtdVszxqMfd+kf7e1n/fQPMXQFuA+TdlIegpdq5V7ktBb9xHrgFdOcy3G1GLHwJea fLLhyXgBuWsEhFmqZRSxAEj0f4w925LbOK6/4qdTM1WbjSVbtnyq8iBTkq1pyVJE+ZYXlSfx TFzT6e7qdnYy+/WHICmJF1A5D7kYAC8iQRIAAVBxoUVb6fOzMJ1duAhjjalUoC0auXzYMtLE EvG7zdSUHBJWFJpgLQnVFDkgFPP8ZjFk30hVPgQUdxE0g+B5rAy/DJfM/8fl+6NQ4m5/fn/+ /jb5dv32/PrP5PJ6vUzebv+9/q9ivoIG4QawWJ/ZeA4uJz0CAsxBVdhoG0+PpnDfyss6L957 uqGqn9MWGR5uoJKoye/4HX7nD/khHGwtX/hmoIl/7J+dK9CuaJRVx36A0Z+7wEGEA8VRwhjC fUm4B8s7z1kBD7flV7F6YIxNCFFmjvsFIFYDL6hZUyniY9BoJ4aO6mVfjo/L/o1tiIVIFMdj x5vXy9ObUBUm+eUfzQIANazzB7ZgjOEw3HdSNeXDzvrV1rq5AGCO4ypuDVy3xKmWXZEWept8 JMrK6KWZeQxgffQKW3dFRA0xWaiIUfG+Lov36ePl7evk89fbi20b4fOiuhsA4LeEycLGngFw tq30acG0zrAaQB7kmTVKNKQUqGDrWEdM+uPJaFpPr9zA+qPYudkDA+9wMkc64fAatylRZ93u 4zPjYzjMx4Ypc/jRd+hwrBUwwSdq9sZ+8Asmk1irk3DXkQgz6XTofZMZ7Me4xgCUhVlxtKaJ LidwhisuLy/KjQMXEznbXT5DxI+6n/H2me7MPqfzOMJ3Y87r27PDgUbBsh3EWiM9hsdPR+xb HREGsMi4jQ6uutPciIdVv7yIl4tTXRpjlJGtDUzo2reA5CGczm1aStZ+yxs2P4KJk/fro7Pb +Xw+3WCmG94tfmdzgMjrWm8PbKFipvms0OvjH+/g+L3cnph8zyjkIYTvGFVBgsBgeQEDj/9U N0goSLe3Gx+DnPVohAkMrLpUm9hkW/D3asoG3ItAAVF9CCU2qXnULWA9P9Qb4+eCD8Ng8nh8 e/vrXfn0jgBfW1K7UgVjpI1i8lpDqkC2NzZt8cGb29BGcfKEWYdEDAkh+hh3UHZuIBiLczrq NcHDu/mgF/I22DG0vJI4gYwbaP0C1eJme5MqbpDv2VR6bpseUfIdmI0QVyzGqs9iS57gcG5p Hu1XRh/KnZ61EkGKU08ND/5/0MaQpmqQTt2k4JaOj+1AuV43PB/c6McwjpsjfSNRmmBgGgSz E4KAv2hWIBglVxIyXadd5Dr6OcE2o1kwxXpY8KxOujy4S3bGNThff3nFBnbyP+Jff1KRotMV 0J2Kk+ktfuS+14h4Q6tMbpS6HNCE3o8fgHEvIlGSK/ZzbidlorVrLPZrQ9xigPaY8ywNdAte usZmxQnWyVomGvaneuOAhShX44S0aDb5Plk7ItK6RmDbw66ntKOVHaf7XdY4khiDIM+ON0hN MHwmA3YLAoHJW8MBrimYUKGB57eW9UejU+BWl0eY9mF6Coq0KroHoAvQ6jdzHZQyBTvCpf+h YJtmKW4QVGjonqdDHSXbUNSDVmKjUxguVwu76+xcm9vQXSk/qoPvKu2HtFUUbGaY3jtc+70+ 358/Pz+qN6u7SvfalNkdLEC72+c5/FCHssOluIGadTdD4yO6cnCDSyks0Kya+SdN6PiECws8 w0T1sSUZ47pYzdULAEooeA5WCdbLOCKrBeYQ3RHsjVikDk7Ko/uI7YhyLaZfhfI4CBFoF5p4 Up+rppRlhXhSr5nodnsTdtrfr58v39+uE55fM6UTJo/zSx7Ricfr5/v1iyqV97O1HkvdUdIY +056wnSXDqvJZwpQftrwGoKKs0Q3FRlrtpSY7Tlt9dCQ+BA7wNI+BSlyBruKRnB0W3UhNxts MG2C5lGF4JesdHH4dmw4a3pSPmR3KJLWuMnsZoWhsNp5EeBd7FYDcGm0ZpIQNRpJiQFoonqT aB43CpjzoqsBSZISV+GUmMWFwnh7+6xYu2RBpltSdnzCiwCz/DD1dZ/XOPCDUxtXqKduvC+K s358ZOuijajqGb+NdtodLKQzyUqi7JRNlhbGJHDQ8nTyNAsQoauZT+eou0WyYx9NIe0EOOpl RvpXLn0FbZFu0FjCbdVmueqYXcV0FU79SM/hlNHcX02nM6QGgfJ1PxQ5sg3DBWgkSEex3nrL 5VQZIwnn/VhN1VSCBVnMAsVcE1NvEWq2j4O8HxBBathBxo7nartX3N72dN3SY9ZABCONVvNQ 7YvYS5SDwnVRQ3w48Cy2SxKQUCZv319enl/v6gYoMGyx+3NsRgVWRCUM/ZHgIjotwmVgwVcz clLOZrJeetOOuYaecqjLc0TBMl6m+0LY2bpNv7n+uLxNsqe3++v3bzyZpnQ0vINNFL5x8sj0 ejgXPt9e4L/qNzdgJBphBViG8m6AF4se79fXyyStNtHkj9vrt79ZU5Mvz38/PT5fvkzE2x3D Yo7gBj8CM1SlBo+KoCfVdbwHtfouN8CbExp2KJjrUChJe57AYlJkhFvThXbeXalRkqUI+MB2 Jxs6VLQFJzMXkoA3FNKMk/75pc+BQ++X+3VSDKFBv5CSFr+aN4HQv766jr/IVlOcySnnUVH4 UmDIKN13l09l5Uz8l6kBE+KHkP8erxcmS7xdr5P4+TNnNG5tf3/7coU//77/uHOT39fr48v7 29Mfz5PnpwmIcFwzU7MnxUl7YicxDwvW2gKvEDAF6kB29up+d30qMoakeEJuQG20k0NA2jFy d0txkj9k+B2+0hkyds4zvJQtbYSUorW+8kyd7FxC7xF49JCQ6nquZyMN1lZG1W1t73///ucf tx/6VRL/VHFBOCZcI6p+L3YW8WKOhxgq38SUg/HR4DeHafpB8eVUvuFN2Z+RylWNUPwGfQCS FZZ1bCaO41Jrmq7LSE1p3mGsBCl9EbbNLnwPG4L6kyM80vg+wx+2w0YJWfgn3A2ip8kzLzjh z0b0NEW8nKOeez1Fk2UnRLXgc3iy4U2dpVqq4L4AE1j8KQ6fueAByj6Awe9deoG5amaLcZLf eC6J8SVJiec7YmF7Ps+yseHLmtBb+siabULfm6F7EmDGqtzRcDn3ArvOKib+lHFFq0VqW9hd crSx9HDUM3n3iCwrXLfXAw2bEW+c02hOVtNkgeW3GlinYBKn3bdDFoU+OZ0wbiPhgkynHrop xoOHANdu5I2EtS1wtV0LIamjLOYxUNorCapDPi9j5pcDmPRQw+Qh3kwfPWSV7JRsU9rkfZed FinvfmGC2F//mtwvL9d/TUj8jkmJv9q7nK5lk20toI7XMSS6pA6CvlY0VW9XuRLy28PI1hi2 XrGxhoDAVQakm3YNX15uNvqjSwClBPwJ6XlHtPluOun1zZhrMLd2s6t3ICUCgTvPAUXG/7aI tOohwNRmHg7PszX7B0GIl5/0tgAOz4k5MhcKmrpCG8vLI38rTznlOJy7W/C3HKzm1ruTL6hw Dkj8EaRkj9mxZQv1xFeQexC3FcXdFjmW1bE6oYdShxZDqJeKIMrAXWkUEbNPGjojS22HkQA4 5yhP3yG8pZRn+joKSPgAHnt5dG4L+iFQUhB0JELzsnLkaFh4d+ODVbJOuKNc05zFaxXGLAPZ yuz26qfdXjm6PVhJJJHaccwurpHJL7AqMb9hZA5Wc+NjAGAHXIut9EDR+yKJ3BfWdl01TA8t zSGESzm2IExwTQpamzsXa9HXHnTaRPysYGcqkwLVLvaoAr107rCmLaBH2LsEU9pnKNSHfYK7 ym7EVTRSagzvIztSEdVN9dEcwX1KtyRGgfodS4do4yNhhzSO5KUQNcEq7E6IKneTJlOt32Iz 21N2WOjp3sQWD04SPOmU2xhQHeRpb+zHO1TlkbLAaeatvNgqlBgKo9GbPU8sK2L63GQb/PWt 7kQyBzerzAmFBDmZyfoMGHnTqQGtqsikKwoT8imr2qSqtJeLegQFj1jSmKuHijdwjDE9F8GM hGyVY/5R8mtqqxiDjTwk15OY7rgq/iPnD7jjmlrVf8yjkZNQTDiZrYIfzr0Mvmq1nBtDsKOV ns6RQ4/x0ls5zzt896uK0fOsKkJNLOZAcclg7oqmeBZv2zqOiA3dspk92uCksBcZA0f5Hg9u ZOiSxoIjo6Y0uQRw+9zcZAAa89OD2xWTIUflgNaTjBsCFdy/7IR4GRuCgkJxSOp1CW8w1LV+ kQ9IMwC16wDgqqK/QiN9KOnb5O/b/Sujf3pH03TydLnf/nOd3OCJoj8unzUjKq8k2qJeMD0O eWuKg0ly0L8VgB/LOsNCeHltbPCJt/CVs1Y0wtPSQXFtRgFFs9zHXQ85Nk2xUw6950Pzoa6t RGgCMuLyJQmkLkHHKDsjHO4dJu+YHM98pXv94RTxG3QIG6aeoxKGnLsSI96H63shoVLDsbRA iNWaeLPVfPJLenu9HtmfX21VNs3qBGJ4lG5ISFtu1WOiB9O1+s5eD96V9KyJMxFha6+kW2kA doZnIUEF6o2e/V1PL9/vTtU821VqUCX/yWQm9bEQAUtTyM6Waw4iAgOxWJpLgQCLzI4PWhyD wBQRPEIgMb2v+COk3OqXrm4QFcXKPU1YQ5ixlRP8Vp6NtBgCnhzGSiUHsaspg+XyGhQFHpKz YafsIEzU1XZqBV4FQYj7PBtEK6SjA0nzsI7RFj423nSJmTsVCt9bTNHC+cPDGtfsehLwARyr HfCcExJsXBoSLebeAm2c4cK595OxESwz1oG8CGf+DGkbELMZ2jTbOpazYHTEC/VWfoBWtaeb nXsUU1Qa9Aq1pyirhGcQxiqmUUH3em7HYYjluwcyb/BYE7Qpj9FRfTV0QO13gofsMoXuVzN0 mK1U7La1Jzg52RJeUW8TPIJvIIoqz0PNET3JmhT2uuYbAlp1vx9QZ9JDQcJz0jhidwVBuSdb SuokccSHip5kqPtXXWRz6yKZAzPfSU8L5ZadQ9LpzKogdYSLSiQeDC2QM9zeLpG4CCKQAcYF EhV0W+j28vqF3zhn78uJaRwEPzpFtrK9/gwK/rPNwuncN4Hsb90dUIBJE/pk6U1NODuNNL6X UMI0OavqPFsLqOKXAfA6OuLqCsfKi3RWEr2r581RvzAt06IsZDaj+KxJimo9VjPPRxJVVAtD 2lPTb1EiNlGRyMHriTsYU6HYMTRSqM3naLmk2HvTB5wte6KUqU1ILPPXy+vl8x1yw5i+Rk2j iUkHV4aFVdhWjWpkkqkpXUDp1uYHC3Ugo1zVYZR1yEPmzSEjZ5JHseMBsFMkPCNylZ85mNt+ NC4/74iMNTYghfFYtIC2G0caiPJTWWAKTqbbWnbtNs7xTXnXbqhDiAdjANNS0KuX/mwS0yWh TOzS8oCz3w8CIGNaXm+XR9stXE4ET1ZMVM1AIkI/mKLAdnhHu4t0w+k0h1oVkcKUPeA4BqKl al7WWlbfztaa0mxHCmJXt3seLznHsDW8eFMkYyTde0bmbtLhi2h3HsmZo5Ly8GBHRip9fOFh R919T+s1jVy9SSnuAaZVf/xJ+3Xjh+EJb9t8sEkbCtyOo1KwhWnVC47sg0FA5Jd4fnoHBVg9 nHn5nSHipyZrgOnL8agQSaE7MSpAhd/MWn9Dc7NLJCVkd7LZW4CdTEyJt8joEi42sA716JGC WnS6xDIeXid1HCEtyuPytybawCghn2lQdH0fYyNZBMjdIwTOjI4mOxTWlk55gkeeT+zQdlWl E/y8QiYC2GPExALXjAGO7SF8gSvGOoGsK98qwGDDpjNcV0ksW59sCclvcaFGeJL9Sk7wJG6c bTJS5o5gnP6OCjtFOEJ1DcoRhq0qQ8mXnt3uAYY8xkzA3MW5nouCw6toB4nxD0a4rEoiLC7i RaZUS5PA0arXggDQLDVAdsJu0Tik3SxThXp7lBnUEZBITpeV2pk6YLtXlCxEVMQYmD+QhSEO WYSDpdTSD6DSswrbkXYHwxG4nq0WmA4RVVXOmEa/pCp3Z0c+wuIYoblgZYSwGa9YkXA5W/xw 2TB2lFhFmKSPpBLpPrvSnfD5408FHv/M2G4jnkAwXoxqyAZGzQBk1PRqF1C1uY6Q7beQZMvh Wa1SZQyycz3PphLu9oeyGaHboWouYHhH9G53repQUq91wIGNArjmnM72WNBmNvtU+XM3Rj91 2AIw3gFka9eU2tnGnJ+NLJLC+MeUcttA6psZwWGg7MzSAOW2Cv0xYQCLFHQGDPJ9a0ZTBiz2 p07OKL4/3m8vj9cfTCeCfvFoZkTO4ExQr4X9jVWa58kOfSVF1t9xugGtSLQK5p4L8QNBZDvS 1JqBvUOxocFtJT4kzVcKj3SzyE+kymOzepkvCFLmOArTQkmECSMXPf75/Hq7f/32pk0qExUg BW5jtgDgimCXLQM2Uuvv7R3gnT7MkPSYnbD+MLg7BarReOYFs8DZOMMuZvpcSCdUA1jEy2Bh fRqHtnQehpghQZKEnmfwQRZOPbOujKLpmgWqMJgdXDjnZg3uvMx8GsHjcRWYhRh4McPM3BK5 WpzMIgc0Y6rEsH2nm0t++WjporxeUmTqjL/983a/fpv8DomAZCKNX76xCX78Z3L99vv1y5fr l8l7SfWO6QvgL/2rXiUBP2h7KcYJzTY77iGhHwMG0r6mNAk072sdt47OTJdXs4oAQbLxp9Zi SIrk4Mir6BPrPNWQD0lRoTkB+PZp2L85k5DI8V2VqppJgP2F9cPMmnuaFQ36tA0ghYD+oU9w er++PjGNjqHei0V7+XJ5ubsXq4zWddTexfLmYN40+9VEYBZHLuvK+1ex4csuKDxmMJAwrLci CZ4mNwkhKNKzR6qDkkd6VrMeKAOiRjZv8EJzvn44kMA2+RMS4wAeuu+Q+WiFWra2qvS95e6X wxks7NE0U3bePl6Hgx9vEIw1jCxUACdzV7aqqC0RVPqLieynfTPel5ZNoLW0JOcP7TwYoqGC ymOR3lZrTeIQ/sPIzFXad+1PyF14uT+/2sdWU7GOP3/+C5M4IIesF4ShSLxv1ZzwDJSTanvO szV/RsmZU/b+PIFYJcbybKl9uUGoElt/vOG3f7ubBCUdUx57gUR8w+3JmPaBTshZSjn2vwHQ 5eYbEH1HBOu6pReJaSM6W/q+3gaH6w4bHZiy0UA1157g5AXTk11fFeWF6hLRwZUt3mqMaSN1 fT5kCWZs64gMXbKvl4npjfEmYdfF/a7OaOLy+wMu1J5NKFPj/OMSrJ6sQBYCe6OeAUbMA1K+ 87tWYVb0EIfyu9/pIG+LFCXfLi8v7PTmawbZ9nlJiOfhaRcdnymNUOaXFbGa5VrATpU/XRnA +BhVa/wTUGdOQVA7D2OOxx/X4Kj8vDvxWbMqLdhi22NKbTfURFWAOPBwCoPAgOnnbMW2k3dy mOGG0BhqtWC69DRrr/iSJlyak64GQHSQmef1bYLQxtu5/nhhOxI2qWMeGpIAjZZTeGmKcZhv 9l9CdRu68J4AVWtm0kuomU1F4tLQyByvjUK3a+ilmiojfuhNra27SGN7mLQxqLNP5c7kbFKf acMtgOqrOgLVhZhpDB6tpmo4+gAMrL7aUqSOz6vZao4F14vx6bZHvVBNgiYInaU6Rwh9zOgi 8L0QGUyGWHmYSiLwx3wxnZuscdxm9CE5Y0N2LMLVav5BCbkcnxJTYePQdROeLMZju3ppLpTK Wjp1TGa+Z3MNLePoAE8KW2wDEtvzK77ItA6Qyp/RaTg0ePS67/Te/X2TKnRxYXqTWvjoyfyZ 3Auo1Lo24GLqz0NcV1GJvCNmqBwo5Jmidoo+Xv6j+6MxciEvN+wsddQnCKiRcqZHQHen+Haj 0XgYm+q1LNQBVRCqN5SGmHkuxMzZ19kMXl/7SV+Wiyle8zJ0IjxXk2EyxUzFPcn6o7+c6q+4 iKffooPjWSOO5VE5mOQjXp/cV1V+tusUcPcbQHFkvn3XHdlRTOznHnmWaaOAJGIiUBOu5kFk Y/oR7junYkJHGK1KgmVB0Qh8rHbzQScDLV5ItErB/OBBZn2L3UHQlwWBiIn56T7J2020d0XF yvLsKPWWU1ecu06E7wyg6234xnIKV2iSlo4ir8Klv1T72mEctwpD1bvIeLFUadWbB8vlaGnW sRXarkDhW0hHw+Zg7gXYHGgUakywivCDJY5Yqoe6gghCrCparGdz9Bv46TldYaenRuJ7S3s5 cAZp84b4K9Vy3aOlS4rdn7ph6ysw+W56cr4Luz0WqqTLf8LDrCZI2keEqiLcBUREAqJK9Pl6 1lmz3+zrPXozbNAoO3qPi5dzTzOuahicPwaSwpv62K6gUwRYu4BYuBArB0I9exTEyp+jeZCi uGEfMZYHSVCgtTLEwnfWinpL6xQBWpiS5WJ0zB7CJikqu0cP3hRHwPVnQo0on765tYfmsegJ /o+xK2tuHNfVfyVv95yqMzXaJT/MA7XY1kSy1Ja8pF9cmSTd4zrppCvpvnfm31+A1MIFVOah F+MDF3EBQRIE+nNLfH7eRR7hHgp9P6mWyxNSVLCLr+nTv4mJi2xc1D5mo8PojCxleAvKK3VG OXLg9s8J1+Y38H2ht95QX7GOQz8ObRZPgqfOXD9O/A+/Yg3bSPItzcTQg8544AGrzVpuqtBN ZLdmEuA5JACrOyPJHkHlO2S2oxphW24jl7wmmVo/rZmqmUpIW5BP5UYGKHcUiESvhouDFc+O hzlgpoWd/ULS37OAnMwgtPeu5y2VikENMNaE0Yhi8SCnOYdWtG4h8cDyuiQKkMNzCfHJAY/8 IA4F1CWgwhERs1sAhDRAVSNyIqIiHHEJcc2BKKEBVSWRkCjyqfcUCgfdjxxadHnHOVYxWSPf jVdEg8Ce03doeddnkSUs15S42K09N60zMd6XOqSOfLIr65hSKiWYGhp1TLYu0JdX86q27AEk huXqJPRUqBcnZlWvyLUb6LS9+gQT6gxQQ88PLEBADG0BEO0ozH6IQYFA4BHjaNdnYktfduqz 2RHPepgRRK0RiKm+BAA2ZoT4RmDlkHobP9VbUVKlHWwbzCQ1HRVVVr08eqx5oRNFVgH40Yjr Mz9xl0TVIHiIDgXEc+KQFlZ+EATUdIY9T5Qk5HRuuwC2eUsj7pDlK+3EQIZsjqhGns9VtKyJ ddueEvVA9oivBLL/F1UXALKlNYUwjZj0rrpwYz9e/IwC1J/AoX1JSTyeS+6HJY7o5DnUd9Vd FsQ1KXNHbGV76SKzpf5q+UtAPQsjbrGs+26mWb1/kJ1P+c+a61VH1BoKiqTrJXniEqslA43b oYYFAHHiUSmgaRNqxJQ7Jq6LTNUJENqfz8zge1SefRaTQqjf1tniYtzXreuQCzlHlsYOZyA+ HOgBNaKQTq/hx5JhCDXUKBe7FviiJCK9JYwcveu5dBl94vlL8/GUwG5C80siQSvX4jRJ5vGW thmcg1h1OJ2UAwLB7YHlolpirOIk7In9i4AixRfYDMFk2hJbM4EU28lnpGZVZW5v0aLSdu4y MfW3jis/6eOLNKsMgn5SM5KbtUnDaB08uHS/L1WLjpFj8CN32TTo1a1oL6eyo27pKf41K/fi Wc1HOfM4iF1r87RCJRnOuUXMNzLi3Jjq46pYP47kTNluw//6oMz5o2xlLnzDfEzYHsY0NM7N QZY48uK43hefKB6tTkWNgUtLdVvLXXwsJBauj/mnZBWrFU8HiHRNdsl7EL9NtzYeAqssRCHz BAJWP3DOaCrz9o16MjcwmBODz6/xG/eF6uEZkkRSEq1m6bkHxbLMFht4aIFsu9BK8lWIUUHz ZcRI0UwgJ/KuObE7EQp8vjgaQW4AYjTi6f7Hw5+Pr19Nzw6zQGrW/ZQNPZbE2RfFI3OExCch EPk2wCMAcRe8TBbvp9HNT8YqpQPnnetCbU85gy/Oddt4fLS02A6fy3KPF3CLTBnLeVzRpdY6 yR84pdzvwj5yk6WUeBDgn89E++yL/kDmyrJPB3S7At9LZMhd1PUFtOZJjoDFqrJGe2y9lZAe g1an5zYx8KPLxFZa14awkQDVS34CnGIsmr7NPLL6xWHfjPWj5FAaQ4ZK3fGET3avd2Loz1tl iXzHKbpUoxaoU6skqKreBpx2LHZ5I25HLZawfRK73lrPLolVyrYl+lLYfuiM8POy44+ysibX PJWiL2G9noM5LN1u/CTA9dUydke1ayJHbw/oLNBzHIMYe4FRPqxhoW0cwDZnNFXS8gLEj9N4 aqcpO9R46dxGpUzNCahJHJvElUGsWbb9bLQeDMuihS2WvzQf5wgAakOWK8fXvgwk04V57kAc bVx++eP+/elxFtPor1822czKNqOmBeSixbVTxX379vTj+u3p9eePm80rSPyXV8WwZJSj6Duz rAtYU1A1IZYciUHWw3Yiro+5Cln4W0b7N7RU5B/lv5RvB3O7bbquFF5RhbXO68v14f2muz5f H15fbtL7h/9+f75/kQJCQCppJGIWWcmd5EpZzQNkxi0V6PKy0ZMTsEYtq0K1SETqEBrBcuOe Yrhm/XPTt9f7x4fXbzfv358erl+uDzesTpkSUgmSmaZw+Pzqy8+XBx6t2Bppc51rSgqnaEZv SDONOji182P56nKkqfcCXAfj9okefUDFk7HeS2LH5mONs+ATvQv6js+U4KYTtK0yOfQxAtA4 4cqRbck4O78up2jqczneGuKhgqKdzGTdEY760agd+dSxxoTKdoSY7aCjGbWYzAs1WkSkV4/y B6pLHoYgiLeJZ72FBqJZkW0ZBSD+8AOkVQ19sLKuzHyVBqm1N3CYhZC2nw5sf0s+wxlY0SFM KZv3IUExlZ03IGp15kIGnwokXbPV1kAtrAKiv7Pd50tWw6pNVRc5xIqv5pkk3NOmnpkg01fM Ew4rt63TBtMbPVu0zo0j8jJxhpOITraiDr0mOAmMcSXMjuhTyQn3qOP1CZWvw2ZiYpTUR9pp qgyOuwU1K9Sl9XzabB3CBKFPjw9Z6gbOogyarUtlYt+dqQGz70PHt7XpYMRrpLlNHDJCN2Ji Z6En6YrM/qaJM5RBHJ0/4KlDMsYYx27vEhhtnlFw3dHCj6XncLkdRxtlsaT39fXh7ZWHC3wb lnfEeUAj7k2R3PAii8URGS9Cs+9HWo9+d30/PF/6LmP6YiGMsfWvRMu5xNYl+gMWtPZynVCx 8RVGYqQRkIDis16moCfUWf4My/fFE1VYmqmZlfwbyIVISmeMK05PosVkK9eQbAPdW+gaYAGR 6CvH1f2pChzfOmgGO3RCXTlVrhf7xukU77raDy1zXTTM6NzFzpL5YbKiw+hwnH5Gg5D2lITr GPr7A4k4LLWqktEFsc2pLv/0Gjbi9FXUCLt2lYtb6ttkKgcTraXrJDBXMqD67tmqCI0sobMw IKZHAwNtX2zwNFO+w55IuhvnGViX5wLaval6xVhmZkAPIAfh66U7KE8WZx48+eUHv4tc86pu QKgqJ/ItmwoNWvR8XDSjeehb7GElph38Qz3kkVhGrZxKzrXz5eSacjwjpjItdYqmzGpISFdH qLCL1Zk0WgrxXLILOOKSQ4TtYG9jq45FE50ZhPZLJy67auVbNDqFK/Jil7rKm5lwIYotxXBs ucm4rffZljyJQ0ojk1iE0LOkBzCKqYVp5pGUUxILk8gCJVGwskIR2ddcYVR1Ew0kTZg0npWt sroyqoBcl/4oc65YW3KPVeMaCRv2X+pyp+JxQmcLEGjdlkqDHm3zvDoxCaVm8bva9eFz4dIC sD0miUN3FocSO6QaYs0g8eKN4hL68WLFJV3WwEAtCd3ItzTdqNp9UAlk83wyjrfKFDqeby8J tcJ/kMWKbEvzzYGBJVZsRctUSWczsEkxoBBlYa+LvGTjeftvsq+gb0+P1/ubh9e3J+rRvkiX sZqHerUe1ws2WCOrBlTGo1SQlhM6ecM3nzMPrbxw5j3L8QHhh3xdTl4l6Lll/4ApK0gulafZ 9Xv0WC5pKMcyL5qL4WAOiceg8iDPlMdsJONUzHx6hiw/6mqXAITKVZc7nH5st1FDUPd4uk04 5RherGOHE6YV4uswJdECYsMoBsjT401dZ7/iCezo62RyjyFyv395uD4/37/9PTu6+fHzBf79 D2T28v6K/7l6D/Dr+/U/N19g8/nj6eXxXXJ2Mw7YNN8fudumrqiKbBq67Ofj9fXm8enh9ZHn OoXdfeeuI75d/5LqtM+7iXUKu3t9fHq1UDGHe6UAFX96UanZ/TeMmyy+TPJEzMH18/37nzpR 5HP9BtX+XxEcmMdGHWH+db8KpodX4IJPw/NkhQlDrD894xH8KzqKenr+/vSmcnSiqW9+4h0J JH9/fbg8iLo+ahGHRXP3h508qCUiesRp5SN4GetzlijxIQ0wPltBF1DXiq4S+dW+DNa9p54v S9gZA2omNix0HEtdz1lgxeosCEAS++MI7F9fn9/RFQl07dPz6/ebl6f/m0fy2AWbt/vvf+LB iuHHhW0kqw/4gZfDGqHXCaoXECTxk1P6LAjQHQgL0osVgp3qHZCT0N8K/QYGYdojFiLFel1m iss+caS76aX7meOGocs5g8AjsWzaQ/ebG8mQiBJf7BvpTjWXfTzBDxCBbXnJZWc+SM2hsQ5n 01kex0RIPC2f27obnMSZ9HU6Q7NVB4BrLtQnCyDa+gP4qoblFxhLOYZx4YHMKLMGYOx7rVqb or7g9ZStago2+awYBNTNELJbkgtScuFNMHbkd+AjvSsrV7a9HunoCRhn5Up2r4EgLNVK9880 vrFve63uMJShx/X2FNSLJbiXxJGVlBtYiWGh0MsGHdLyUTCH2GZZe/Mvsahkr+24mPwbQ0Z9 uX79+cbjocuL5ZAfXmZYK7trDseCUQ80eXuuZOvekQJioN0ySoGaODLW8tB0PBSWtXDOOjSD sZA/vn379QoMN/nTHz+/fr2+fNW/jSc//YMi7MGdkOUIA9gO1qfNmtK2+civWSjL4oEWETQ/ Uk/HkHzIKYsy3mvynTEXIRu28fRss3K/P3SXTzC5VeDTuVIJaZNtO5U0eBYWI1yit0z4XOON nV/fvz/f/33Twgr+rM1NzjivucqXCez3vLxUvRM7deGEdMDymRn+Zl2D/oqPx7PrrB0/2Okf PBQp4shcuqhIGKNZQKi2l+qT67h7tzvLhtcGU+cEfu9Whc6U7st8U+gtMV87pG/Xx69PWqOI 7UV5hv+cY8VPCRfrhzrly4aIkKdORBBbbb/zg4g+lRX1Rnl1gd1W5NFHu8gFghEDbyeR5Upd 8JQrx7ONawzVVaZMnHDHUax+RV9e+nUbuI4pe2EvEIfq+aICkTdevN32WbsxZO22xACdZVpT Z8N8Wpy1UQ2EdapnIwJjGAJm/QZ65s0fP798gcUn12NzrCUlYFwR+fookVOMlIsPMBXarunL 9Z1CytXYWUDhkZSPRbe0Y8X84c+6rKq92FeoQNa0d1ArZgA86HpaqQ5gB2zPw86fiwofTlzS O9J/P/B1dx1dMgJkyQjIJc/IutkX5WZ3KXag6u0UKG367UxXWqjcDABthpheoJi+Kggm7Ssa OaAp9kaxhkUD9qayizWuQGWHVPsmmK3CtZtccM3wqp+MjYIVZ9nt6BlTSgMJBjVIrU1fVrzF emHwZw7NP0cnvMR+GDuVrwJ0Vdra06oOFOjWdXNB54vNbge9axl5d2mx97QnZTIdBzWdVHj7 lxMxkEnQRxaDUhywXW8FoQvcyAoWHaXwA1KsS3VaKp4UsLs3TKvmFL3MMpjcXDOHwWz5/kXL SBAtl1ozrh2bzIA8hOR89+XR8rVlLL8pxMlRJE4YJ3rvsT3MaYz2tCO95vHBPTii0kmwj0EP 3OWhNqaDgDEi2aeDRZ4MTBsqY+16U8qSHQvLzJ60eaV9hDpvbfcBp2foABoRc3H89neuRx0e C0zJhmH8Jb3jkDg+Fagy6kHUyHQmUk71tYxLX5VZ/rDeSCR2FNeecs6CaG+sAWdZpjrhRai0 TJGjMRWO/EQVVxF0hJ+t6a37wHge/MmXKciL/s4yeYoGVplS/cLbu70qzP18fTYI5MdwwHZF jRVrmrxp6IsRhHvQtOjrB5TuoEUWdsHH9tQmkctptVNh4tZC0dCmM1JBy2H1pTiSL1QUnuzQ 9bKBJOShhcoYKZfqTBCN4TmSKfsgFEsp7H7OfaBskzCZ4cCIjwB+Ba9KiAIEwa6p1RrWKbS5 JogHGj8c3mjjf8QUk0VcqvcNy7ttUaiSgB2ay627cs4kVV8RR7p1hIg9khXtYFVxKFsLBOvY lU7cJ0GAQkTagA8wErOKdd0Q1kWuKGKji1WirDlnLQMDn13OTnlLiT9YX2ZO3ShgRrjHIApo 62QVuJdTpcYFmxk6Bls6aoGUMs/bJJEvIDUoJqGq9iN/ZSl0uDUk+3dmG+/dPmATBhqLn6C6 BpYqeQw9J65aCkvzyHWkfRzoVB369pEoeGdDK6nbvJZUKdjfNuov9EGDYS1gnpIAV+BIJKsO vSeHQOmawy7Xfl6aTo8co9LxyQCM2lJ2O6Tkssv1CDVIajM1wWV7yotWJe3ZqQaNTCX+zuQo LCNlCJeq3a8h2hWgFe0y+hmw+A48n1WzrGGPtkfIqPRAVIoYyDDDD5tyZ3ERNfDxprBy5Hc7 hhbo/N6O9LuxmyTPBaQ43hcatYGF/mJZ6RE/Fvu06QoiWJZaFYtHSp6F8GmqNk5ew3Z6kx7W eoWGbsSesJbWtJWP0VE/Ygo+ZOpSdioWOYZwojqP3P3tIXDcixazTKqmSj2eTRrLVjHMj7zI tFYSMdj1NsoPdU1pXDyrSrzWkSvYt8wY6XXfkTGwxCwQUQPdKAwdIyH/XEtKHGo123nngPjA wYcpk50NE+D4Vuk3R6lTOjjY0CeZMaRZ7iZq/HIVrjqf9p8iwED3zcLJZRiEtNbA8a7cknfx HOzL8qx1iaDxkwZNsrFDkihhgweaZ1YKqJYgyhw+kU5oEPnc+77i8gOIaZ/I16oT6dIc8VW5 iGalFJAxx3Xo3T6H61J7FKdOz/PdxhLMmqfuAo/0EzuA0VmrrKBh3PNLroYfFmgYLrSVeCvF DvSbEM7Rn9fa2pKzfcU8ras23DuKXnzF7pDVLj55VhY3YGOuttkqMtcmXK0YKItVSiMU2bbx N3pVy11ebmytIEA1Rt1Mz3//IJnWZWMqjTxIXJKos+4614+N5hZk+3QtOnflU2cEIxhpk0PQ hNqgF2aEkpbVFDEUxbXE68v//Lj58vr29ekHXvTfPz7e/PHz+vzjl+vLzZfr2zc8OHxHhhtM ZthUjPnVRuNnhRtbQq1PuHX08Jv15Gy04Ui3OOIEjttmv3G9hYKrpiJ93SB0joIoKIyVrWZF B7tI0m2P0LT0KKdA3dVeaJdDbXbe2nWofdn2oE5bytvXhe+pQwFIq0ivASda9hViQSXfX3Co 7GJHcXyIRLxdO5ZpoamUwxGFplCULBE7bFVzE2Sxxtj1O9zIN51twh/PundIIN7Va+q58zb/ hV9560NWEztAmOK6KNkiwPV662RiF9g9cAKVJar0aaFvC1SMt4YUpnZgaPFFM7er0PVURLli BkVjQBVjFZwZxIXiQuUFW1duaqaEtVHxoy6nZ2jY3VnKt94uaGxDhFxbIbis6wqIiupTQkep BVji4WZQ/6CZfCcMzIKMMDpTH36gQIqs94WZEqpr7XvVrGIqCwcD6ERQy8/Fb1Eg4+tyX5xK vZyRaur+uXJ4I1Sj9UlbKTv1CHzKEQ2sNKWtSJvUUjaayzrO2YL2rMuYsbp0jcU7Md/Xw7aw poQnV+mlCJjbMqfsgbdqQPQ5mCXNzkNvkjHUD7A9aLZZqV40zh+KuHEGh0Tuu2bLuss2U06q ADNqhjQeaH2+3Zvo7Z9/v18f7p9vqvu/6Vh9WFq7vSMbc9e0HD9nRXkkORAVoY1sEet6tj02 er3V9CzfFPT5NsKHqi31eHgjfJKGFPy4nLZy3MNaebNbZ/ptWXvaw/YZdDiZbyAalqCQPFWD 506k4aTjt2Su+IylMCAzciFHs291d46pMPjFODyF/bEwQd5ijNRsjpFKvFnF5F2+zagdH2Kn tMu1wsp1fenUN/RAHs/WLflkaSxLYiQduYG60eAHqE4Z7ZvK0YsYlq1La63taELSal16qXtl tauLuuvLjLoFwV1XVeSSKMJf4nyaol3W8Pd2bH2gUxOGszPWu57F/zVnSLM68skLvxkOlbtV TudvSheyxWPkgNpAc3RX9IFiMsSppz1rjYJE4CxrTuoJsSga3y8HZo2BHFrzqdownHyQGhmG oex0cyb6BFH2RTEQk9Axkw9n82ols6o4YnCxkrremtsj1JsOqZGvU83ILJw8vUtZGBW5lzjW xho8TnSBYqcnvqv3w5XeLDwmAfR52jS3+ng2nnBxap8xfPujU6ssXLnGuDGerk0jNPxLIza9 55itPnlOsH3wbZ970Urv2LLz3XXluyu9QgMgNhXaFOUb1D+ery///Zf7b7707Tcpx6Hsnxhw 66ZDHzewFOJSPT3YgB+XflvuNrX0LEP0VVXubmutCvqzf05E+1ONBPukOEmVevZv169fKVkC u6fNpiBPyvGyGT328LvsuYgiZxjcvsFT9i7bH1INMlSKQjMX5FzCqM30CSjzaCsmp9U1nd9m S5q9iMrWeRydtYz+n7InWW5bV/ZXXHd1TtVLRaTmxVlwlBhxMkHKsjcsx9Z1VLEtP1mum9yv f90ASAJgU85b2epuYh4aPQZzzRRGwqa2CYsW9mI+zfvQ5Xzaox1rvg0SZvdhwdjqQ3fjhUk3 NZzS2xaRTngcWyzsGfXRgAWrRFr9NuppE4vS09l0BGC46tnCWvQxzS3XNgKBaw+u1VuaU0M8 4EpgWAfxdCpfwFwdGrNWxQISv4BDLTQTj7ZwVPOYTeQIP9gSI8VbUGw1Hgn5cqyfuKkbcuFO P+BaKWkc153eBYx05m1JdgvNdb2BG+lsG7jPUCtvdq/D9PMmDBF6QVpWBc2jq6RzSpqmEMzm RDPXt8liqvnASwTGkVyaC1Ai9PANOmJOInqRgRpcwabemPY5lxQRi2GvEvUJBDX2O4BPqdp4 +gD70jRzihE1IBwziFhQQzixygU1ghxuhhNssO712KZ1mm2Fgz7UzQ7p+9p2mF50lHYqLjlC SxoGDOpy5FykCZMxnWCnrQh2EtU4gE8XFgnX0mw18CAZj2xivRXo7t06sWEKTv2IUI8btCxH gQJXQrf06B3ZP1p6W2psj4nVB+vBtmxy6xdbaPHSs3tnaP58fwYe5uVyjV6SMfKksbWoBx18 ahHDifApsVzxiFhgYPQk0tM86gSfnUOzATWnQjK3Py9mPlmQoSQUisXCXBSiB9x8APhxc6wE lt9GDZqu+dJxxNOKTshP+cPgcr+Gc3+pJLNLJxQrN9a8dBZUE5LJolzQWgeVZHy5CUgypTIV tQQsmdkTYum715OFnvigXfn51CM1Ug0B7gziTLi7Ta+TVl11fP3i5dVnN74McHFpDNMtsZEK 4LjarLv4ThDOxfSe9BNH2LipHiQtzGSdFcy2QQkFXOL0fUfQDiVIV5pjCMLaGENrJ02DWK/Z iDmIkEwzZAlZDJxlQkm5xdszAqTqEYmRywGklnENb3mUdkLhySqhxXYdDVGTf4NFeobQW0J7 ACn+aUfKez7sX8/apDvsNvXqclcb9bUEPio2WN/RH+BuFV4d39DtURl8Xl4YabFYbzi0AzjV zo9YHjvKs2zDRlrmDvGbG5/8M/oFz3EDAe93+NxuoF7orPAcnyiMfAerCzS2s1vdQZRgz70o QrtMdYLWpTXbkG5SlSrTqTABeRTqgBw3wSpIjXTqiPKTIJEoWlSL6bYD6qmPGHghe5lqZc5r QztbU2+CiDQod2b9eVExUgaMubPDma0dyNuQtJjA3aMYLynQLq319nA6Y0yE/uEi/R1piaVE uqh/0Z0KJIYr+8iRkwSJEexNhj94OB3fj/8+X61/v+1PX7ZXTx/79zOptLjNg4J6NbHSWWmh wNFPBcOd+l6W0tBaYw91TE1fymwqWHTxKIOuvJ/v0eXW1Eo4Dw/75/3p+LJXA2o4r/fPxyce aODwdDjfP189HF/hMz3XuePPZyPtESEgdRRiSDV0bozjgMgSIUpviv5++PJ4OO1F9GKtHqXc cj7WfYZkEIy3+wco5PVh/weNtabKfcZ/20bj55N+HT5vG/wRZbPfr+cf+/dDO1YN4uk3LI2H 49v+SkYbaQjS/fk/x9NP3u3f/92f/ucqennbP/JGe2RLp8txyy3Hh6cfZ6XITrXWZEtisb0c kbLtElC/5r+aopwHnt93/7o/Pf2+4jOOKyLy1LqD+WI60YeFg0yHCiFp2L8fn1HcNzT4ImqF FLVdfcFV+PoIs6+G8BZW8boJIcB2q77xAHvb3//8eMM6oOI9xsneP/zQA4Xy3VX31Mdy5T2e jodHpb9sbSS9h8dHkUVolnKDuoysuK036CZFi5GHAjA0zXAzpyCdgxp1qjCiVLb9TVnyPOB1 mWHMIrytmKI77vAelCzR4/bSalRFNbdS64pNSr/DpU6qXVH+KqVFTCtWh/nKQddWog9Ci1B7 8abexSnafm9u7gpVpaVFSsdfZtxOJ0pqzxAuaUi4elB7PYjn+mVKUgs4PbbR2k9Mt7QN2tTQ 2p1VEdzSSs7dYta6XdQdw9m1ysPMFQlt0ojItR9SDY6jIOUuyTeqbb7DKlbHTl6q1roy+bEb qY9PDiQpb3RzkAYGY5TR/JkoPoM3OyU0CKtvUcmqrq5u02qYQWvvhowntFIWSOlZmGlE6/86 73t4Yf4N2DpxwGjBKeIHxj9vYxKINlJn5jpKN7njN9x7pzlXEWgCfMnTWycWcT8cD/UGkRE1 q0/4aXFVypwwMFSpOgl3/hiuZ52Vm+AWTo+YjuPT5mb2nZwe5CAI8gujyNdtfyWnrrkaRTnG fGmFyKlWSsIeaGUnzABAo+AELnr7QSSYEppslVqott2yLkI87LWBk8i1MRIG2ugWr8hLcooB F2871HQFW81MTyC2btkLaWTkfJN5rJJ+KPCGwE2AB1SulV1mTesANZPKI0qG3TAHKdklZnca 0msysDX376pXSbUz212wXvdY4sDzXTiqKy/bbY5pQehORvmAcVFVCEazyMa1W5UlmfZYllOl UYklKf2M4c7CpD3Ncd6h2qvSSGHbwvMop8bdWxdZErQFKotWYLL+Yd4ickzjq7xxm6QTvXhS DSJWO9MAYSzKzABvXB8PC8pLGu5sjCYFj6RNpTRqjfZxeLHnRQBsvNqq9tJvuErv+PICjLv3 fHz4KeIcILfbsVgKm6DoHfpIFk3HU+2hoyMt2vBdJ5pT61Mh8XwvmI/oBiBuaU8HWuAxHiNh IPISUsio5Z+1Mt1RB6ZC0IaZp77Od7RQRSWJvDEt9VSnorTnAw6uPSp4Cw8pKfu0UbL6c+Kt H3h/Tr2Owj8nDsr1nxO7fm4QC5FjE6iDvR1e+fo2Xs9i0bPjx4nKuAMVsIJrp1XpPkCDbWlC +c9at2gDSheOp4ayu1x4Apw8ouUXcDpxh0C4fj4hSMpqwBi9oSiTir79pdMhvHNoRgtte9yM kvhGMPiV9DHUQEac2BU+Uw8PVxx5ld8/7c/33+HJx8yYhuLrKNsqN3oWCrAmfS0Ex9m7W3VC BVizbdK/kQSqyZR14coRhGGc5fltfeM0HSv2L8fzHmOHEnoleHCWgVTDC+q3l/ee0Aatbf9i v9/P+5erDI7eH4e3v7ucUb5O3CaVYkdSSA8X+y6qWeFQXuSYb0eNCJknTZbSVgosflIpy5p8 pjxrKzfghOHyg8RRfXlVojwo8Np0UtXWWSNA623pGqi8VzqCNqA/JelWC3IYi7aB2QnfnJCu vyazFuyQi2kKCH6dMUFZL2OnRsxziuq+xhKh2/dJYD+yeocYj/Ww9h2G5+6hN21LM5AKQhKY aU4kmGsRWA4PxyRiXg9dlBh83SEaxZLplLSyk/jGaFnhzLjcRdmTKjJCuW4VhqqRVwerPVcH b3hwJOFCrICllRdyRURZ4l/VRkb5pkfKE0cwXL0tia2SsJte9AUJ7kqkhbGS2k0cS7VbcBPP mo7alzEB1QNj+I6tfu47YyOkGxyO/ogKbi8wit8RB+h5YDY75lPKyc3O+7axRpZyyyXAmYw1 W2VnPtESpwhALz8KgGekhRdgFma2ogRtR2neRuDINE08Dq/alJ03s9W2sXKzGKvBOxDgOlxw +f+TmttLbfgBslxSdyVm51gsai13kedZwIdaOjBItwHcM+jTUsK7KtOCxq53dAAK9Bbd7WRB nQ1k6dm0ph/Po/FMm818PNEdv1Knmi8GstSIcwW2ukPGGcN0Tb43Wlhac7okTsZXinJpZo1M rJiPl7dnuBFVfu3H/oX7X7C+PN0pY2hdvpbCD1rc61wPvLi3dwvVQJafDPJJ1ghTdA0rQdGs o/XhsdF0o+ZGPLAUhge1U6yT/9sts8BY3nxIfcRK4yMaJ9spH3cfr6oov1F2oGeqWO30Ep+O VL01JrtZjPQlP51MaLsIQE2XYyq0hp9npYy02azAmT1WLX5giU7VTAj4e6EatcOSncxV0yWx ekShra7s8ePl5XfnWttNPw6UYGR6wRVkmL/9/37sXx9+t2qi/6Lew/fZ1zyO9VcDZ3Dvz8fT V//wfj4dvn/IcL/C/ujH/fv+SwyE+8er+Hh8u/oLSvj76t9tDe9KDX+ii2pviZWlhcvhv3sH bl6NR4NZnOSCWd0WWT12dhHrrSWOQluuBt2NYblC+9/+W2t//3z+oWzMBno6XxX35/1Vcnw9 nM09GwaTyWggZxZwSSOLqunj5fB4OP+mlGpOYo8t6vDz16VqurX28RhWNvy6ZLa60MRvfZ+t 4b2lHfwsmo9GVG2IsNt7JYKFckZT+Zf9/fvHScTu/4DR0JruJpGcSOouTnYzreoo3eIkz4hJ 1pd7Wccsmfls1xtHUzPZDKEUj6vb/5tfs7E6fk4M+3akcYtO7rOlEXNDRy5JDsBdW3NVsYu/ VW7HS8a2pVoxIkA9NOD3WM/OApDZQHInRM2m1HW6ym0nh1lzRiOF19S1tHrePQ6zyJSZ35iD TvNdOUVejHT3nLLQ/G1guU/0RAJZXsJwKiQ5lGmPdBiLLHhkaIuy3IzHA2qx0mPjyYAgjuNI w+FmDFAdrRnscsBCB0ymatqZik2tha08F7deGuvd3AZJPBvN292S3D+97s+ChyZW5waeKerV hL+n6u/Rcqlzx5KvTpzVUCBKQI0tIzkisLpTe0AaKDcWL5EfkJeVMIk3hTcdqYCPXh+eD6+9 zv6J2h0bsS6knKd9h2htRDlGUVR52RAM9qZEsTLGFPqUUlh7ElTaBfZ2PMMhd+heQt1bhcFT iGTg4WqfGmkm83hk5Ewka4HhOStrJE7ypSXWmLiLMRXKx4m4TB03H81GiWLM4ya5rT/V8Ld5 varMn+sUlHHUOh+prHYeW6qLufhtZGzO47FOxKYzLWM3/218BLCxwjHJpZkXmspNhZp9KacT cj7WuT2aKTXd5Q4cu7MeQGVg+ZXyikYpxlrOT8dfhxe8tNES/PHwLmx+iBs8jnxU/EVlUG/J w2i3nBqhm4pQz8Irds/+5Q35M33eu/0d75ajmUV5eJRJPtLNojiEDhRYwn4gzXA5wtbsNNLS JQi3SaD60MNPGcme8klGYs9ZWt5uQj/SkKCES2FC2RMhMnQ2gVbX8f70SFcVIf3cSHzdfjgk K8OPdBc+hORRpueZv6HElVFx7a0jVeGLyRow+J2zq9OiC+kR5Rjgz9DucWOdGtNY2QNsiAx5 FuWZV5KxWWGDBKWerKv9WOCccj0fsMfneDco4mjADYkTxLlnLXZDmemQIgnYkCMTx+cRKx0Y J9r8Q9CwzEPTn0sUZTKgZpJ4lCvTaz6SjpuC8kIZaGx+AV0Gq8Kp3TyhlXJh0r8wMbYC+/j+ zoXn3aJrQjkDWuGX1reob6vtRZrUa6aaxWqoirlq3FMvqTeY4xfBRoEovvYcZX1KNbmTazYH idcPK5HvT+iPwo+9F/EU6ud3KrT01Osq9TEwY9xlMOvZvwlrN40PlwZwboRfDyrfU9iVAwGD Shou+lque13jC01LeqNoebrZNJaj+FRGxCJE7r7WK/hZZyFledXmgoD+JI5pPFW4qhLJ811d M+snERlpBOCmlyUHeQ4K4GHvpUGdwgYIwghO1Dh2Na1AxDwW1ZEbltA6VVnSIdRGhDe1F64G PYdXWbaKg7afzVpYHY9Pz/sLIyi/Y7opiITCYAGAZXoYZKELCaOrv4JfwFq9H76rNbSpVv7u a/FwILaOageOkIDpcbwaKmksQekU+IBu+rOJCLwFGuQ/CxVTVClywjw4gx4rF7FoAClC/zRH u46HLc0qGJQ2PJDWYNPZodln3GomLzKoT1qFNY8eXqaWegshaKiRw/WBhtWsUxqU+6fTfRsa rpNayf2BVrL8sFMVcx4sQehsVvjSp72rCZjzKNNHblfadagtewmqd05ZUpI6wI/7nyAIzkCG 2XQ82vCsoWKBVxV0wHggmdShrp+aaCUb1U6GCtSJgtQrbnMzpZpKYbgQfXN9jSXB38NGj6xO XD7sOksQwUwCjty43zhCq+LTAfz2WV+RYDh9Fv+8dMoIY7jQz9LdUHNXITPXCaYHsGlqtyya 7hkQbSJNHAwgj8yMV78IwtCxbw0NbOaaOSmg+d4brr2XGUKAHQaTQm3ZNIr7fQztoQHBGpyd trWIrgU7NHvQF7SAyJBFerabiJ8z3kZzIUGVOoY6uR3AQ1nd8lbBbWqj7kYTIFJfxDENc94N gNP/pEVeV1lJc5EcgwbeGNhDiBpCWnHPKb1S29eYnTVkk4GBhyYas+QBiKDEsLWxc2su2xYK O1TmuoA/vZvOu3/4oaWYYs0O1wF8S+mLRiLWsNGyFW170dCYSWUkOHO/YbviSLWx5ChcA4yC mUUpmLYhzbXi+V+KLPnqb31+ifTukIhly9lspO3gb1kcBdqFfQdkA3HDKz80Zk/IZjL2NXTK r2lp1NtxxwxohqKRb+HbIVxa9naqYK3f9x+PR7hCiW7KyOfa0xNBmwE9IEfi60ZfrhycY/aV JIODKaMuTU4DrGHsF4GySTdBkaqDbLCVZZLrzeOAT24JQTN0e6+rFexKV61FgngXlPXD/xjH OCwoYNE0EBqM8JMJ45kEib7XeCbpoSPU8Xt3oATVxQ2tKQiHygr4AWiyJQ0QX82MO+1QI2L0 EX7ncWW2rIPSw99cMkGvTxw0fCu7vS4pDOYg89BeVQZEngKjHvwGbtTANIfpsIDBQP9aKjyB ZRXw2oV2jbSf9RaZQYL5gVCsCBcTaizgz3Bv7ozMbQIa31HyU4Hj8u3+J0XlRhSbB2BjphsI pjtEuzRfNFgtsiUxGtInwPYP1urwBwiRg7X9/CKH6sHZrR0T15XD1hRE8Ag9XlRHi1uPkp82 ZH6AI1Ez2DExXZCkSKp4wEqUpEQ7KowpcKFqvqbIKs0R7lPEdwMB1DsCMsxxW/cdMaKTDb7O XG6DfkcPRpC4ge8HlLCgG/nCWSVBWtaSa8Cyxq0UdGcszSRK4YwxOJdk6DxY571T5zrdTYZP FsDOhrHFcE2tI0N3+3EIn5x2v5OlSkKYApLOpJq0VERtXl88YZLkCaNOe4kVzFB3626N4asu nMq7bGh0pEejcR02yFj/0cYo/tfh/bhYTJdfrH+paAyCzLmKiarD0TDzYYyq99QwC90Z18BR WhWDZHrhc8ryVCeZXah9Rtv1GUS0XNogopRWBslkaIBmg0M3m11oPGUmqZEsx8OfL6e0UsIo 4NPpWU6WQ42fGx0G7h1XXb0YbJRl/0mrgGp43njYjIFGNw2wzAY0iKHeNvgx3aGBfvbWbYOg TdVUiqFl3eCXdI3WQAOtyVBTLNowBUk2WbSoKY6+RVZ6bRjRBU5yNQZ2A/YCuIs9sxECA2/1 ilRatyRFBuyMngG4xd1iRrmIsqNoSFZOENN1r4ogIEMLS3wEzdbcC1pEWqk5jLXOR1T/y6rY aPkMEVGVYRtUY7M/ve6fr37cP/wUqeybt1WBPolRcR3GzoqZbi1vp8Pr+afQYr/s35/64W5E Dq1aMq7dSwsvM0y1FgfbIG4vhnnLDfDnC0HRhg7gGapl6SLWTaebkDnCtEhI3vHlDZ7EX86H l/3Vw4/9w8933u4HAT8pTe+kR1gADHZIc8JBih449Y1TYFpWzPLmlDpLZJImFSuF0I+SkMAV LUr7xxrZbUdZWUQ5HCsJ3Nrq7VoEjs8LBZTC4acVA7YeSN0s1hkJHM/sJiXzvImeao/CAKX/ UkSpjC0nZMBN4xMHnsIJppFQOAsDI0YnS2Nlfnj8+RsHOEPR5Tzj8jJVLqjCzcrDrIAleRM4 G+6kANy1KjpE/ThwIjzGUB/YejqJCfln9MvSC0f5BHdDENZX+5fj6feVv//+8fSk7Qs+msGu DFIW6SF5RDmI5+kSKI4Mv4XOoe9+uurNUYup00xKfj8tpL4L1ASzog1CpsYGwDBVcSiDnZL4 EE6nIRw3tBosGVnC/pA02MKr+OoiN4pOKh5PcF5UuBAG121DLndZc1YYU8tix+0tZIDVMSwl ZeGLbBp8MSRBIpFGAxvMYJPQJmFTV0yTMAnUNulDMGGgIW1tUUWv1QDMV/xA7mHaHLVGg2Xw F3hkUc9gpc+84SgyDuPspl+Ohh4qiW9wHKLm8GgLaYEXJp+tjTBgQpKKe/AKTcg/3sTJvb5/ fdKNpTJvU+Wt1wg5N4iq1+j9XzpMO9fEudCi+BLPKlhF9kiRXcGtg5GgEoUwR19/SjI2RFtv nbgKOpHVzTWchnBW+pmaP4JTohhJ05hoYFmQpSObhneZYGDE/b56SIAHbzeO5qJ+6pHPvxWL PMBUceZEi6nEpvxfY0fX3DaO+yuee7qHm07tpp3swz1QEm2zkWRFH3GSF0029W0yc006iTN3 ++8XAEkLJCHfzexOWwDml0gQXwSutG4iOySLnbHPbqNObPQcPis4cd7F39/dq+X3fyx+fhwP /z3AXw7Hx0+fPrHk6rbbtoebtte3OjkfHQwlfJbsjodMvt9bDPCJ3R691TEBubSIz0f28ZuT 30pYPcTYWq7B3qWFmOUo048CsM/UXuqwwelHeD2oxpz4vazk0wDg1ICkqOec/PS9SSIUOKJl wmfOtaMYMQOKEv1Xlg7+dxVYk9U26W3VGA+O2Yi85SySfHwmyosf0eStxsJjRpXp5oQ7LJAK ok+PaPFMUbAD3YBOuJGPxcxnmOxV2ADw4PMU/+NrIgnervBVy/LENVZLjvcfm4H0dZp+1B6W ayeatV4oixbUOoBBaELzouiRdl9l1G27a4E1fbfSJGN/lUwUaFe6x+ASkU4Su4nvC32tlSmd zMC8w6a0oteccEcUFYbltFhXmW9YQlF4uV3qELFGRhP2FQzsJKPLxxdUjzq/k/MXoY+bHd60 hAPd2uuhth0RUTuH3bSq2co0XvFaR9tGQI5702+jLMq2H4uuSOaj2nc8CRuRoEOStixS0jmK G8ndD20rE9K2nYc3QEup7SJHEQPSp96P3Z6HEWFLSCJ4OOwMUpbx8UK6Z394P0ZMo7wqesln jgeXuNvYRX1k07cErj57wrMeZHhf0WByKtKV8e3idCPITAg73+rbYpgJSCUC1E7rjS/KPjeH KyDreSlUgpL2HuQQJnBm+kqJycwQOwymiNppt6rbRtkw7OhtwaWAOZtCU9W05ZffLiiLcSwS T0wLkx6fS2OGXbA4xHAWAxklhJ+BBBxqXaTBwPFWPRXrwxcqkUrZKXylKfpBJnF7UwScCv8t uaB97bchA9XSqpfmnthZsEW8iu4JQRWth1JyABM+8CQkLc/4EZFMlWZTo5dormXqNrId4PiB xWPSYNPZ46nZpsA9mfeOYgLTqw8Rg1kQfdF3lNp58iit2vLOGZpk6Fhkm0D0CpAYP5pOjfIu 9ni0oofUE4J1tjag7/Wjg0a3arujnTN7jt3lLL3IL3YDHBqrLKeye5mty0Gs0+byyfThsxra i5hoeOaSwTzPeCbG/q7R4+fby8+TihLj4HMuZdwQJbYOsfWuRifjaSonLHYnLg+jEN2ZJ/zg rYzpT7FXUZx1VzgfIow8FovIkomK4kyCp0adiabAKIMKzxkoNqaW9Q3bDxwynobECcKVEQxB uAuduMGtazbtHF4foW21Ozx+vOFzpsT8e6XvuPIKVwTcZugTBgReHDxgciKfOGk7AHlBcCkG xoYQOIKA++m7sdiOGI2skiiMia+60FLMP97RMwziD2dpJbXIoYIMK/Z5wG0sZFH6uxpGPFDW 8ubOCpLKZrlIuHpCzieZIM/swWmqQR78CPvPv50csrcgM5PAzmPvcLVPyczztz9/HV8Xj69v h8Xr2+Lp8O9fvHa3JYbpbYL0WAF4lcK1KkRgSpqVV7lptlxqizHpj5xIkAJT0pbHnE4wkfBk c0yGPjuSq6YRgWkTGBYQxGb7fjupBIJDFuk0dS4AK1WrjbCGDi71i9ttvmP3w7EwHVljyeSQ NL9ZL1eX1VAmiPC6Z8B0sdDMDCrWoBMM/ZHuo2oGroZ+q+s8gXemKvxuVx/HJ3xe+/hwPPxY 6JdH3P34uOc/z8enhXp/f318JlTxcHzgwr0fUi5J+H418iqdw1bBf6vPza68W37huXz86PS1 uRE+8lbBPXDjx51Reo6frz94aK/vIkvnnPfpXsiFD6jzTNgaZSsZhR2ykfq7FdoG7u3qitoU Fw/vT3MzCMp6+ONchQUEfU/Q/fzgbqopa0rx/AcoaWlnbf5lJbVsEZbnz/dAVMJWBSgsTSkd BkD2y88Fr6Thd4zIyNheicdYFdLr3hNS/ImBvQS3WGXkR3OeDVXFUkzYz/BhEMyEWH2V8nRN +C+8aI/f91u1lIDQlgT+upR4GCCkiBmH7Tft8jfpZ/sGmktU+/z511OYK9PfW+neBtj49TId KcJrY/dQiqyHLEw84xFtfuazwv29Xxthn3hEUjvX7ztV6bI0SkCgA3vuR12fcimEfhNGXoj6 rEOu6c+UL2zVvSqkr4kJzFdittyAQFx5z2gFBqvTuwLuvsamTkwGYTFj1+kVdnRme+l0Zfv9 TvxUDj636B5tJ3aKdMAcD888Y9Zp1ddoKZQ4txgo6pCXFynjKu8vxGYutkJljYeXH68/F/XH z98Pbz5XlB1fsqPrDp8LtqIi42fRZmhHqYdkUITZSpeCxUQGIY7LxdcDjCJp8rvpe92iWhUJ 5kxOIgsSdnuOg54IOyct/l/E7YxTLaZTc752f11KV7bq7qpKozpEuhRprtw+NKGbISsdVTdk SJjyR8z49C8Snd6plvL78x8vNhkFReJE5lAbSMqVv3bmIQPqSVfcn+783+ZexTa0m+0OWFet JUOTxWEKE4whKIyqXf1i3kC5GeZMLJmpVessPutk9uXz728Pb38u3l4/js8vQQlbZYpvY8NC VTLTtxorSAWrPemDE14y99Kkef0VnwgA9No6B11z3e6qKB0FJyl1PYOFdRuH3vCAXo/CN91o BrWW2xSPhbiiN7geNQsW7H1rvHkopL4pTfhkD6QkEK/hMIrnN18GLD8fU4kKuuyHMbhvIlEN ZTRmJuFdIwYOgM7uLmdOGSOZyfpuSVS7B94sTwLwweoCiBdPN9lJOJ0IgjhXLKHT2+VEfVL1 frnFjVQXuyqcskPBTcDD1BnUvnoI4RQjb2p/53DodBP5ObAw+RAqtRyFyzOoRH17j2C+HBaC hi7xizg0pbgQy144AhNUNHRA1VZCVwDtt0MlP+hwNOgfPtNbln9POosjuPzkx829aUREBoiV iCnvKyUi+DORgH43A79IT7Vg52o1BpHsyl0g2XAomvguZ1DQ4RkUP/UZj1DM6ATUnbe5Thhy yN8odCzyyDfVdbvcAG8lJtzySFNkTMDEuC/BgtDyPQbMjXwWfHnt2+/ObGqFXnq2kNecg5e7 LPyXcCjr0j0h8k2X95gdPmBUu7YQz3pR8BTQ7TWV0ZkgVWOC4u9Dji/kyOnHm+8wtqEUY8s6 zBSzk1w4HS6CMrWAQjfCSO6HCUkO7EI3OzbzzjoLAfAXvflcew6UAQA= --r5Pyd7+fXNt84Ff3--