From xen-devel-bounces@lists.xen.org Mon Mar 03 11:54:02 2014 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Mon, 03 Mar 2014 11:54:02 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WKRRJ-0004fI-MV; Mon, 03 Mar 2014 11:53:45 +0000 Received: from mail6.bemta4.messagelabs.com ([85.158.143.247]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WKRRG-0004eY-TD for xen-devel@lists.xenproject.org; Mon, 03 Mar 2014 11:53:43 +0000 Received: from [85.158.143.35:49285] by server-1.bemta-4.messagelabs.com id FD/FB-31661-64D64135; Mon, 03 Mar 2014 11:53:42 +0000 X-Env-Sender: andrewbe@dhcp-3-231.uk.xensource.com X-Msg-Ref: server-12.tower-21.messagelabs.com!1393847616!9545422!3 X-Originating-IP: [66.165.176.89] X-SpamReason: No, hits=0.0 required=7.0 tests=sa_preprocessor: VHJ1c3RlZCBJUDogNjYuMTY1LjE3Ni44OSA9PiAyMDMwMDc=\n X-StarScan-Received: X-StarScan-Version: 6.9.16; banners=-,-,- X-VirusChecked: Checked Received: (qmail 654 invoked from network); 3 Mar 2014 11:53:39 -0000 Received: from smtp.citrix.com (HELO SMTP.CITRIX.COM) (66.165.176.89) by server-12.tower-21.messagelabs.com with RC4-SHA encrypted SMTP; 3 Mar 2014 11:53:39 -0000 X-IronPort-AV: E=Sophos;i="4.97,577,1389744000"; d="scan'208";a="107519360" Received: from accessns.citrite.net (HELO FTLPEX01CL01.citrite.net) ([10.9.154.239]) by FTLPIPO01.CITRIX.COM with ESMTP; 03 Mar 2014 11:47:59 +0000 Received: from ukmail1.uk.xensource.com (10.80.16.128) by smtprelay.citrix.com (10.13.107.78) with Microsoft SMTP Server id 14.2.342.4; Mon, 3 Mar 2014 06:47:57 -0500 Received: from [10.80.3.220] (helo=dhcp-3-231.uk.xensource.com) by ukmail1.uk.xensource.com with esmtp (Exim 4.69) (envelope-from ) id 1WKRLh-0000QM-IH; Mon, 03 Mar 2014 11:47:57 +0000 Received: from andrewbe by dhcp-3-231.uk.xensource.com with local (Exim 4.80) (envelope-from ) id 1WKRLh-0001pd-Aa; Mon, 03 Mar 2014 11:47:57 +0000 From: "Andrew J. Bennieston" To: Date: Mon, 3 Mar 2014 11:47:45 +0000 Message-ID: <1393847269-6981-2-git-send-email-andrew.bennieston@citrix.com> X-Mailer: git-send-email 1.7.10.4 In-Reply-To: <1393847269-6981-1-git-send-email-andrew.bennieston@citrix.com> References: <1393847269-6981-1-git-send-email-andrew.bennieston@citrix.com> MIME-Version: 1.0 X-DLP: MIA2 Cc: wei.liu2@citrix.com, ian.campbell@citrix.com, netdev@vger.kernel.org, paul.durrant@citrix.com, david.vrabel@citrix.com, "Andrew J. Bennieston" Subject: [Xen-devel] [PATCH V6 net-next 1/5] xen-netback: Factor queue-specific data into queue struct. X-BeenThere: xen-devel@lists.xen.org X-Mailman-Version: 2.1.13 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Sender: xen-devel-bounces@lists.xen.org Errors-To: xen-devel-bounces@lists.xen.org From: "Andrew J. Bennieston" In preparation for multi-queue support in xen-netback, move the queue-specific data from struct xenvif into struct xenvif_queue, and update the rest of the code to use this. Also adds loops over queues where appropriate, even though only one is configured at this point, and uses alloc_netdev_mq() and the corresponding multi-queue netif wake/start/stop functions in preparation for multiple active queues. Finally, implements a trivial queue selection function suitable for ndo_select_queue, which simply returns 0 for a single queue and uses skb_get_hash() to compute the queue index otherwise. Signed-off-by: Andrew J. Bennieston Reviewed-by: Paul Durrant --- drivers/net/xen-netback/common.h | 85 ++++-- drivers/net/xen-netback/interface.c | 329 ++++++++++++++-------- drivers/net/xen-netback/netback.c | 530 ++++++++++++++++++----------------- drivers/net/xen-netback/xenbus.c | 87 ++++-- 4 files changed, 608 insertions(+), 423 deletions(-) diff --git a/drivers/net/xen-netback/common.h b/drivers/net/xen-netback/common.h index ae413a2..4176539 100644 --- a/drivers/net/xen-netback/common.h +++ b/drivers/net/xen-netback/common.h @@ -108,17 +108,39 @@ struct xenvif_rx_meta { */ #define MAX_GRANT_COPY_OPS (MAX_SKB_FRAGS * XEN_NETIF_RX_RING_SIZE) -struct xenvif { - /* Unique identifier for this interface. */ - domid_t domid; - unsigned int handle; +/* Queue name is interface name with "-qNNN" appended */ +#define QUEUE_NAME_SIZE (IFNAMSIZ + 6) + +/* IRQ name is queue name with "-tx" or "-rx" appended */ +#define IRQ_NAME_SIZE (QUEUE_NAME_SIZE + 3) + +struct xenvif; + +struct xenvif_stats { + /* Stats fields to be updated per-queue. + * A subset of struct net_device_stats that contains only the + * fields that are updated in netback.c for each queue. + */ + unsigned int rx_bytes; + unsigned int rx_packets; + unsigned int tx_bytes; + unsigned int tx_packets; + + /* Additional stats used by xenvif */ + unsigned long rx_gso_checksum_fixup; +}; + +struct xenvif_queue { /* Per-queue data for xenvif */ + unsigned int id; /* Queue ID, 0-based */ + char name[QUEUE_NAME_SIZE]; /* DEVNAME-qN */ + struct xenvif *vif; /* Parent VIF */ /* Use NAPI for guest TX */ struct napi_struct napi; /* When feature-split-event-channels = 0, tx_irq = rx_irq. */ unsigned int tx_irq; /* Only used when feature-split-event-channels = 1 */ - char tx_irq_name[IFNAMSIZ+4]; /* DEVNAME-tx */ + char tx_irq_name[IRQ_NAME_SIZE]; /* DEVNAME-qN-tx */ struct xen_netif_tx_back_ring tx; struct sk_buff_head tx_queue; struct page *mmap_pages[MAX_PENDING_REQS]; @@ -140,19 +162,34 @@ struct xenvif { /* When feature-split-event-channels = 0, tx_irq = rx_irq. */ unsigned int rx_irq; /* Only used when feature-split-event-channels = 1 */ - char rx_irq_name[IFNAMSIZ+4]; /* DEVNAME-rx */ + char rx_irq_name[IRQ_NAME_SIZE]; /* DEVNAME-qN-rx */ struct xen_netif_rx_back_ring rx; struct sk_buff_head rx_queue; RING_IDX rx_last_skb_slots; - /* This array is allocated seperately as it is large */ - struct gnttab_copy *grant_copy_op; + struct gnttab_copy grant_copy_op[MAX_GRANT_COPY_OPS]; /* We create one meta structure per ring request we consume, so * the maximum number is the same as the ring size. */ struct xenvif_rx_meta meta[XEN_NETIF_RX_RING_SIZE]; + /* Transmit shaping: allow 'credit_bytes' every 'credit_usec'. */ + unsigned long credit_bytes; + unsigned long credit_usec; + unsigned long remaining_credit; + struct timer_list credit_timeout; + u64 credit_window_start; + + /* Statistics */ + struct xenvif_stats stats; +}; + +struct xenvif { + /* Unique identifier for this interface. */ + domid_t domid; + unsigned int handle; + u8 fe_dev_addr[6]; /* Frontend feature information. */ @@ -166,15 +203,9 @@ struct xenvif { /* Internal feature information. */ u8 can_queue:1; /* can queue packets for receiver? */ - /* Transmit shaping: allow 'credit_bytes' every 'credit_usec'. */ - unsigned long credit_bytes; - unsigned long credit_usec; - unsigned long remaining_credit; - struct timer_list credit_timeout; - u64 credit_window_start; - - /* Statistics */ - unsigned long rx_gso_checksum_fixup; + /* Queues */ + unsigned int num_queues; + struct xenvif_queue *queues; /* Miscellaneous private stuff. */ struct net_device *dev; @@ -189,7 +220,9 @@ struct xenvif *xenvif_alloc(struct device *parent, domid_t domid, unsigned int handle); -int xenvif_connect(struct xenvif *vif, unsigned long tx_ring_ref, +void xenvif_init_queue(struct xenvif_queue *queue); + +int xenvif_connect(struct xenvif_queue *queue, unsigned long tx_ring_ref, unsigned long rx_ring_ref, unsigned int tx_evtchn, unsigned int rx_evtchn); void xenvif_disconnect(struct xenvif *vif); @@ -200,31 +233,31 @@ void xenvif_xenbus_fini(void); int xenvif_schedulable(struct xenvif *vif); -int xenvif_must_stop_queue(struct xenvif *vif); +int xenvif_must_stop_queue(struct xenvif_queue *queue); /* (Un)Map communication rings. */ -void xenvif_unmap_frontend_rings(struct xenvif *vif); -int xenvif_map_frontend_rings(struct xenvif *vif, +void xenvif_unmap_frontend_rings(struct xenvif_queue *queue); +int xenvif_map_frontend_rings(struct xenvif_queue *queue, grant_ref_t tx_ring_ref, grant_ref_t rx_ring_ref); /* Check for SKBs from frontend and schedule backend processing */ -void xenvif_check_rx_xenvif(struct xenvif *vif); +void xenvif_check_rx_xenvif(struct xenvif_queue *queue); /* Prevent the device from generating any further traffic. */ void xenvif_carrier_off(struct xenvif *vif); -int xenvif_tx_action(struct xenvif *vif, int budget); +int xenvif_tx_action(struct xenvif_queue *queue, int budget); int xenvif_kthread(void *data); -void xenvif_kick_thread(struct xenvif *vif); +void xenvif_kick_thread(struct xenvif_queue *queue); /* Determine whether the needed number of slots (req) are available, * and set req_event if not. */ -bool xenvif_rx_ring_slots_available(struct xenvif *vif, int needed); +bool xenvif_rx_ring_slots_available(struct xenvif_queue *queue, int needed); -void xenvif_stop_queue(struct xenvif *vif); +void xenvif_carrier_on(struct xenvif *vif); extern bool separate_tx_rx_irq; diff --git a/drivers/net/xen-netback/interface.c b/drivers/net/xen-netback/interface.c index 7669d49..0297980 100644 --- a/drivers/net/xen-netback/interface.c +++ b/drivers/net/xen-netback/interface.c @@ -34,7 +34,6 @@ #include #include #include -#include #include #include @@ -42,6 +41,16 @@ #define XENVIF_QUEUE_LENGTH 32 #define XENVIF_NAPI_WEIGHT 64 +static inline void xenvif_stop_queue(struct xenvif_queue *queue) +{ + struct net_device *dev = queue->vif->dev; + + if (!queue->vif->can_queue) + return; + + netif_tx_stop_queue(netdev_get_tx_queue(dev, queue->id)); +} + int xenvif_schedulable(struct xenvif *vif) { return netif_running(vif->dev) && netif_carrier_ok(vif->dev); @@ -49,20 +58,20 @@ int xenvif_schedulable(struct xenvif *vif) static irqreturn_t xenvif_tx_interrupt(int irq, void *dev_id) { - struct xenvif *vif = dev_id; + struct xenvif_queue *queue = dev_id; - if (RING_HAS_UNCONSUMED_REQUESTS(&vif->tx)) - napi_schedule(&vif->napi); + if (RING_HAS_UNCONSUMED_REQUESTS(&queue->tx)) + napi_schedule(&queue->napi); return IRQ_HANDLED; } -static int xenvif_poll(struct napi_struct *napi, int budget) +int xenvif_poll(struct napi_struct *napi, int budget) { - struct xenvif *vif = container_of(napi, struct xenvif, napi); + struct xenvif_queue *queue = container_of(napi, struct xenvif_queue, napi); int work_done; - work_done = xenvif_tx_action(vif, budget); + work_done = xenvif_tx_action(queue, budget); if (work_done < budget) { int more_to_do = 0; @@ -86,7 +95,7 @@ static int xenvif_poll(struct napi_struct *napi, int budget) local_irq_save(flags); - RING_FINAL_CHECK_FOR_REQUESTS(&vif->tx, more_to_do); + RING_FINAL_CHECK_FOR_REQUESTS(&queue->tx, more_to_do); if (!more_to_do) __napi_complete(napi); @@ -98,9 +107,9 @@ static int xenvif_poll(struct napi_struct *napi, int budget) static irqreturn_t xenvif_rx_interrupt(int irq, void *dev_id) { - struct xenvif *vif = dev_id; + struct xenvif_queue *queue = dev_id; - xenvif_kick_thread(vif); + xenvif_kick_thread(queue); return IRQ_HANDLED; } @@ -113,15 +122,48 @@ static irqreturn_t xenvif_interrupt(int irq, void *dev_id) return IRQ_HANDLED; } +static u16 xenvif_select_queue(struct net_device *dev, struct sk_buff *skb, + void *accel_priv, select_queue_fallback_t fallback) +{ + struct xenvif *vif = netdev_priv(dev); + u32 hash; + u16 queue_index; + + /* First, check if there is only one queue to optimise the + * single-queue or old frontend scenario. + */ + if (vif->num_queues == 1) { + queue_index = 0; + } else { + /* Use skb_get_hash to obtain an L4 hash if available */ + hash = skb_get_hash(skb); + queue_index = (u16) (((u64)hash * vif->num_queues) >> 32); + } + + return queue_index; +} + static int xenvif_start_xmit(struct sk_buff *skb, struct net_device *dev) { struct xenvif *vif = netdev_priv(dev); + struct xenvif_queue *queue = NULL; + u16 index; int min_slots_needed; BUG_ON(skb->dev != dev); + /* Drop the packet if queues are not set up */ + if (vif->num_queues < 1) + goto drop; + + /* Obtain the queue to be used to transmit this packet */ + index = skb_get_queue_mapping(skb); + if (index >= vif->num_queues) + index = 0; /* Fall back to queue 0 if out of range */ + queue = &vif->queues[index]; + /* Drop the packet if vif is not ready */ - if (vif->task == NULL || !xenvif_schedulable(vif)) + if (queue->task == NULL || !xenvif_schedulable(vif)) goto drop; /* At best we'll need one slot for the header and one for each @@ -140,11 +182,11 @@ static int xenvif_start_xmit(struct sk_buff *skb, struct net_device *dev) * then turn off the queue to give the ring a chance to * drain. */ - if (!xenvif_rx_ring_slots_available(vif, min_slots_needed)) - xenvif_stop_queue(vif); + if (!xenvif_rx_ring_slots_available(queue, min_slots_needed)) + xenvif_stop_queue(queue); - skb_queue_tail(&vif->rx_queue, skb); - xenvif_kick_thread(vif); + skb_queue_tail(&queue->rx_queue, skb); + xenvif_kick_thread(queue); return NETDEV_TX_OK; @@ -157,25 +199,58 @@ static int xenvif_start_xmit(struct sk_buff *skb, struct net_device *dev) static struct net_device_stats *xenvif_get_stats(struct net_device *dev) { struct xenvif *vif = netdev_priv(dev); + struct xenvif_queue *queue = NULL; + unsigned long rx_bytes = 0; + unsigned long rx_packets = 0; + unsigned long tx_bytes = 0; + unsigned long tx_packets = 0; + unsigned int index; + + /* Aggregate tx and rx stats from each queue */ + for (index = 0; index < vif->num_queues; ++index) { + queue = &vif->queues[index]; + rx_bytes += queue->stats.rx_bytes; + rx_packets += queue->stats.rx_packets; + tx_bytes += queue->stats.tx_bytes; + tx_packets += queue->stats.tx_packets; + } + + vif->dev->stats.rx_bytes = rx_bytes; + vif->dev->stats.rx_packets = rx_packets; + vif->dev->stats.tx_bytes = tx_bytes; + vif->dev->stats.tx_packets = tx_packets; + return &vif->dev->stats; } static void xenvif_up(struct xenvif *vif) { - napi_enable(&vif->napi); - enable_irq(vif->tx_irq); - if (vif->tx_irq != vif->rx_irq) - enable_irq(vif->rx_irq); - xenvif_check_rx_xenvif(vif); + struct xenvif_queue *queue = NULL; + unsigned int queue_index; + + for (queue_index = 0; queue_index < vif->num_queues; ++queue_index) { + queue = &vif->queues[queue_index]; + napi_enable(&queue->napi); + enable_irq(queue->tx_irq); + if (queue->tx_irq != queue->rx_irq) + enable_irq(queue->rx_irq); + xenvif_check_rx_xenvif(queue); + } } static void xenvif_down(struct xenvif *vif) { - napi_disable(&vif->napi); - disable_irq(vif->tx_irq); - if (vif->tx_irq != vif->rx_irq) - disable_irq(vif->rx_irq); - del_timer_sync(&vif->credit_timeout); + struct xenvif_queue *queue = NULL; + unsigned int queue_index; + + for (queue_index = 0; queue_index < vif->num_queues; ++queue_index) { + queue = &vif->queues[queue_index]; + napi_disable(&queue->napi); + disable_irq(queue->tx_irq); + if (queue->tx_irq != queue->rx_irq) + disable_irq(queue->rx_irq); + del_timer_sync(&queue->credit_timeout); + } } static int xenvif_open(struct net_device *dev) @@ -183,7 +258,7 @@ static int xenvif_open(struct net_device *dev) struct xenvif *vif = netdev_priv(dev); if (netif_carrier_ok(dev)) xenvif_up(vif); - netif_start_queue(dev); + netif_tx_start_all_queues(dev); return 0; } @@ -192,7 +267,7 @@ static int xenvif_close(struct net_device *dev) struct xenvif *vif = netdev_priv(dev); if (netif_carrier_ok(dev)) xenvif_down(vif); - netif_stop_queue(dev); + netif_tx_stop_all_queues(dev); return 0; } @@ -232,7 +307,7 @@ static const struct xenvif_stat { } xenvif_stats[] = { { "rx_gso_checksum_fixup", - offsetof(struct xenvif, rx_gso_checksum_fixup) + offsetof(struct xenvif_stats, rx_gso_checksum_fixup) }, }; @@ -249,11 +324,19 @@ static int xenvif_get_sset_count(struct net_device *dev, int string_set) static void xenvif_get_ethtool_stats(struct net_device *dev, struct ethtool_stats *stats, u64 * data) { - void *vif = netdev_priv(dev); + struct xenvif *vif = netdev_priv(dev); int i; - - for (i = 0; i < ARRAY_SIZE(xenvif_stats); i++) - data[i] = *(unsigned long *)(vif + xenvif_stats[i].offset); + unsigned int queue_index; + struct xenvif_stats *vif_stats; + + for (i = 0; i < ARRAY_SIZE(xenvif_stats); i++) { + unsigned long accum = 0; + for (queue_index = 0; queue_index < vif->num_queues; ++queue_index) { + vif_stats = &vif->queues[queue_index].stats; + accum += *(unsigned long *)(vif_stats + xenvif_stats[i].offset); + } + data[i] = accum; + } } static void xenvif_get_strings(struct net_device *dev, u32 stringset, u8 * data) @@ -286,6 +369,7 @@ static const struct net_device_ops xenvif_netdev_ops = { .ndo_fix_features = xenvif_fix_features, .ndo_set_mac_address = eth_mac_addr, .ndo_validate_addr = eth_validate_addr, + .ndo_select_queue = xenvif_select_queue, }; struct xenvif *xenvif_alloc(struct device *parent, domid_t domid, @@ -295,10 +379,9 @@ struct xenvif *xenvif_alloc(struct device *parent, domid_t domid, struct net_device *dev; struct xenvif *vif; char name[IFNAMSIZ] = {}; - int i; snprintf(name, IFNAMSIZ - 1, "vif%u.%u", domid, handle); - dev = alloc_netdev(sizeof(struct xenvif), name, ether_setup); + dev = alloc_netdev_mq(sizeof(struct xenvif), name, ether_setup, 1); if (dev == NULL) { pr_warn("Could not allocate netdev for %s\n", name); return ERR_PTR(-ENOMEM); @@ -308,24 +391,15 @@ struct xenvif *xenvif_alloc(struct device *parent, domid_t domid, vif = netdev_priv(dev); - vif->grant_copy_op = vmalloc(sizeof(struct gnttab_copy) * - MAX_GRANT_COPY_OPS); - if (vif->grant_copy_op == NULL) { - pr_warn("Could not allocate grant copy space for %s\n", name); - free_netdev(dev); - return ERR_PTR(-ENOMEM); - } - vif->domid = domid; vif->handle = handle; vif->can_sg = 1; vif->ip_csum = 1; vif->dev = dev; - vif->credit_bytes = vif->remaining_credit = ~0UL; - vif->credit_usec = 0UL; - init_timer(&vif->credit_timeout); - vif->credit_window_start = get_jiffies_64(); + /* Start out with no queues */ + vif->num_queues = 0; + vif->queues = NULL; dev->netdev_ops = &xenvif_netdev_ops; dev->hw_features = NETIF_F_SG | @@ -336,16 +410,6 @@ struct xenvif *xenvif_alloc(struct device *parent, domid_t domid, dev->tx_queue_len = XENVIF_QUEUE_LENGTH; - skb_queue_head_init(&vif->rx_queue); - skb_queue_head_init(&vif->tx_queue); - - vif->pending_cons = 0; - vif->pending_prod = MAX_PENDING_REQS; - for (i = 0; i < MAX_PENDING_REQS; i++) - vif->pending_ring[i] = i; - for (i = 0; i < MAX_PENDING_REQS; i++) - vif->mmap_pages[i] = NULL; - /* * Initialise a dummy MAC address. We choose the numerically * largest non-broadcast address to prevent the address getting @@ -355,8 +419,6 @@ struct xenvif *xenvif_alloc(struct device *parent, domid_t domid, memset(dev->dev_addr, 0xFF, ETH_ALEN); dev->dev_addr[0] &= ~0x01; - netif_napi_add(dev, &vif->napi, xenvif_poll, XENVIF_NAPI_WEIGHT); - netif_carrier_off(dev); err = register_netdev(dev); @@ -373,85 +435,111 @@ struct xenvif *xenvif_alloc(struct device *parent, domid_t domid, return vif; } -int xenvif_connect(struct xenvif *vif, unsigned long tx_ring_ref, +void xenvif_init_queue(struct xenvif_queue *queue) +{ + int i; + + queue->credit_bytes = queue->remaining_credit = ~0UL; + queue->credit_usec = 0UL; + init_timer(&queue->credit_timeout); + queue->credit_window_start = get_jiffies_64(); + + skb_queue_head_init(&queue->rx_queue); + skb_queue_head_init(&queue->tx_queue); + + queue->pending_cons = 0; + queue->pending_prod = MAX_PENDING_REQS; + for (i = 0; i < MAX_PENDING_REQS; ++i) { + queue->pending_ring[i] = i; + queue->mmap_pages[i] = NULL; + } + + netif_napi_add(queue->vif->dev, &queue->napi, xenvif_poll, + XENVIF_NAPI_WEIGHT); +} + +void xenvif_carrier_on(struct xenvif *vif) +{ + rtnl_lock(); + if (!vif->can_sg && vif->dev->mtu > ETH_DATA_LEN) + dev_set_mtu(vif->dev, ETH_DATA_LEN); + netdev_update_features(vif->dev); + netif_carrier_on(vif->dev); + if (netif_running(vif->dev)) + xenvif_up(vif); + rtnl_unlock(); +} + +int xenvif_connect(struct xenvif_queue *queue, unsigned long tx_ring_ref, unsigned long rx_ring_ref, unsigned int tx_evtchn, unsigned int rx_evtchn) { struct task_struct *task; int err = -ENOMEM; - BUG_ON(vif->tx_irq); - BUG_ON(vif->task); + BUG_ON(queue->tx_irq); + BUG_ON(queue->task); - err = xenvif_map_frontend_rings(vif, tx_ring_ref, rx_ring_ref); + err = xenvif_map_frontend_rings(queue, tx_ring_ref, rx_ring_ref); if (err < 0) goto err; - init_waitqueue_head(&vif->wq); + init_waitqueue_head(&queue->wq); if (tx_evtchn == rx_evtchn) { /* feature-split-event-channels == 0 */ err = bind_interdomain_evtchn_to_irqhandler( - vif->domid, tx_evtchn, xenvif_interrupt, 0, - vif->dev->name, vif); + queue->vif->domid, tx_evtchn, xenvif_interrupt, 0, + queue->name, queue); if (err < 0) goto err_unmap; - vif->tx_irq = vif->rx_irq = err; - disable_irq(vif->tx_irq); + queue->tx_irq = queue->rx_irq = err; + disable_irq(queue->tx_irq); } else { /* feature-split-event-channels == 1 */ - snprintf(vif->tx_irq_name, sizeof(vif->tx_irq_name), - "%s-tx", vif->dev->name); + snprintf(queue->tx_irq_name, sizeof(queue->tx_irq_name), + "%s-tx", queue->name); err = bind_interdomain_evtchn_to_irqhandler( - vif->domid, tx_evtchn, xenvif_tx_interrupt, 0, - vif->tx_irq_name, vif); + queue->vif->domid, tx_evtchn, xenvif_tx_interrupt, 0, + queue->tx_irq_name, queue); if (err < 0) goto err_unmap; - vif->tx_irq = err; - disable_irq(vif->tx_irq); + queue->tx_irq = err; + disable_irq(queue->tx_irq); - snprintf(vif->rx_irq_name, sizeof(vif->rx_irq_name), - "%s-rx", vif->dev->name); + snprintf(queue->rx_irq_name, sizeof(queue->rx_irq_name), + "%s-rx", queue->name); err = bind_interdomain_evtchn_to_irqhandler( - vif->domid, rx_evtchn, xenvif_rx_interrupt, 0, - vif->rx_irq_name, vif); + queue->vif->domid, rx_evtchn, xenvif_rx_interrupt, 0, + queue->rx_irq_name, queue); if (err < 0) goto err_tx_unbind; - vif->rx_irq = err; - disable_irq(vif->rx_irq); + queue->rx_irq = err; + disable_irq(queue->rx_irq); } task = kthread_create(xenvif_kthread, - (void *)vif, "%s", vif->dev->name); + (void *)queue, "%s", queue->name); if (IS_ERR(task)) { - pr_warn("Could not allocate kthread for %s\n", vif->dev->name); + pr_warn("Could not allocate kthread for %s\n", queue->name); err = PTR_ERR(task); goto err_rx_unbind; } - vif->task = task; + queue->task = task; - rtnl_lock(); - if (!vif->can_sg && vif->dev->mtu > ETH_DATA_LEN) - dev_set_mtu(vif->dev, ETH_DATA_LEN); - netdev_update_features(vif->dev); - netif_carrier_on(vif->dev); - if (netif_running(vif->dev)) - xenvif_up(vif); - rtnl_unlock(); - - wake_up_process(vif->task); + wake_up_process(queue->task); return 0; err_rx_unbind: - unbind_from_irqhandler(vif->rx_irq, vif); - vif->rx_irq = 0; + unbind_from_irqhandler(queue->rx_irq, queue); + queue->rx_irq = 0; err_tx_unbind: - unbind_from_irqhandler(vif->tx_irq, vif); - vif->tx_irq = 0; + unbind_from_irqhandler(queue->tx_irq, queue); + queue->tx_irq = 0; err_unmap: - xenvif_unmap_frontend_rings(vif); + xenvif_unmap_frontend_rings(queue); err: module_put(THIS_MODULE); return err; @@ -470,34 +558,53 @@ void xenvif_carrier_off(struct xenvif *vif) void xenvif_disconnect(struct xenvif *vif) { + struct xenvif_queue *queue = NULL; + unsigned int queue_index; + if (netif_carrier_ok(vif->dev)) xenvif_carrier_off(vif); - if (vif->task) { - kthread_stop(vif->task); - vif->task = NULL; - } + for (queue_index = 0; queue_index < vif->num_queues; ++queue_index) { + queue = &vif->queues[queue_index]; - if (vif->tx_irq) { - if (vif->tx_irq == vif->rx_irq) - unbind_from_irqhandler(vif->tx_irq, vif); - else { - unbind_from_irqhandler(vif->tx_irq, vif); - unbind_from_irqhandler(vif->rx_irq, vif); + if (queue->task) { + kthread_stop(queue->task); + queue->task = NULL; } - vif->tx_irq = 0; + + if (queue->tx_irq) { + if (queue->tx_irq == queue->rx_irq) + unbind_from_irqhandler(queue->tx_irq, queue); + else { + unbind_from_irqhandler(queue->tx_irq, queue); + unbind_from_irqhandler(queue->rx_irq, queue); + } + queue->tx_irq = 0; + } + + xenvif_unmap_frontend_rings(queue); } - xenvif_unmap_frontend_rings(vif); + } void xenvif_free(struct xenvif *vif) { - netif_napi_del(&vif->napi); + struct xenvif_queue *queue = NULL; + unsigned int queue_index; unregister_netdev(vif->dev); - vfree(vif->grant_copy_op); + for (queue_index = 0; queue_index < vif->num_queues; ++queue_index) { + queue = &vif->queues[queue_index]; + netif_napi_del(&queue->napi); + } + + /* Free the array of queues */ + vif->num_queues = 0; + vfree(vif->queues); + vif->queues = NULL; + free_netdev(vif->dev); module_put(THIS_MODULE); diff --git a/drivers/net/xen-netback/netback.c b/drivers/net/xen-netback/netback.c index e5284bc..a32abd6 100644 --- a/drivers/net/xen-netback/netback.c +++ b/drivers/net/xen-netback/netback.c @@ -75,38 +75,38 @@ module_param(fatal_skb_slots, uint, 0444); * one or more merged tx requests, otherwise it is the continuation of * previous tx request. */ -static inline int pending_tx_is_head(struct xenvif *vif, RING_IDX idx) +static inline int pending_tx_is_head(struct xenvif_queue *queue, RING_IDX idx) { - return vif->pending_tx_info[idx].head != INVALID_PENDING_RING_IDX; + return queue->pending_tx_info[idx].head != INVALID_PENDING_RING_IDX; } -static void xenvif_idx_release(struct xenvif *vif, u16 pending_idx, +static void xenvif_idx_release(struct xenvif_queue *queue, u16 pending_idx, u8 status); -static void make_tx_response(struct xenvif *vif, +static void make_tx_response(struct xenvif_queue *queue, struct xen_netif_tx_request *txp, s8 st); -static inline int tx_work_todo(struct xenvif *vif); -static inline int rx_work_todo(struct xenvif *vif); +static inline int tx_work_todo(struct xenvif_queue *queue); +static inline int rx_work_todo(struct xenvif_queue *queue); -static struct xen_netif_rx_response *make_rx_response(struct xenvif *vif, +static struct xen_netif_rx_response *make_rx_response(struct xenvif_queue *queue, u16 id, s8 st, u16 offset, u16 size, u16 flags); -static inline unsigned long idx_to_pfn(struct xenvif *vif, +static inline unsigned long idx_to_pfn(struct xenvif_queue *queue, u16 idx) { - return page_to_pfn(vif->mmap_pages[idx]); + return page_to_pfn(queue->mmap_pages[idx]); } -static inline unsigned long idx_to_kaddr(struct xenvif *vif, +static inline unsigned long idx_to_kaddr(struct xenvif_queue *queue, u16 idx) { - return (unsigned long)pfn_to_kaddr(idx_to_pfn(vif, idx)); + return (unsigned long)pfn_to_kaddr(idx_to_pfn(queue, idx)); } /* This is a miniumum size for the linear area to avoid lots of @@ -131,30 +131,30 @@ static inline pending_ring_idx_t pending_index(unsigned i) return i & (MAX_PENDING_REQS-1); } -static inline pending_ring_idx_t nr_pending_reqs(struct xenvif *vif) +static inline pending_ring_idx_t nr_pending_reqs(struct xenvif_queue *queue) { return MAX_PENDING_REQS - - vif->pending_prod + vif->pending_cons; + queue->pending_prod + queue->pending_cons; } -bool xenvif_rx_ring_slots_available(struct xenvif *vif, int needed) +bool xenvif_rx_ring_slots_available(struct xenvif_queue *queue, int needed) { RING_IDX prod, cons; do { - prod = vif->rx.sring->req_prod; - cons = vif->rx.req_cons; + prod = queue->rx.sring->req_prod; + cons = queue->rx.req_cons; if (prod - cons >= needed) return true; - vif->rx.sring->req_event = prod + 1; + queue->rx.sring->req_event = prod + 1; /* Make sure event is visible before we check prod * again. */ mb(); - } while (vif->rx.sring->req_prod != prod); + } while (queue->rx.sring->req_prod != prod); return false; } @@ -208,13 +208,13 @@ struct netrx_pending_operations { grant_ref_t copy_gref; }; -static struct xenvif_rx_meta *get_next_rx_buffer(struct xenvif *vif, +static struct xenvif_rx_meta *get_next_rx_buffer(struct xenvif_queue *queue, struct netrx_pending_operations *npo) { struct xenvif_rx_meta *meta; struct xen_netif_rx_request *req; - req = RING_GET_REQUEST(&vif->rx, vif->rx.req_cons++); + req = RING_GET_REQUEST(&queue->rx, queue->rx.req_cons++); meta = npo->meta + npo->meta_prod++; meta->gso_type = XEN_NETIF_GSO_TYPE_NONE; @@ -232,7 +232,7 @@ static struct xenvif_rx_meta *get_next_rx_buffer(struct xenvif *vif, * Set up the grant operations for this fragment. If it's a flipping * interface, we also set up the unmap request from here. */ -static void xenvif_gop_frag_copy(struct xenvif *vif, struct sk_buff *skb, +static void xenvif_gop_frag_copy(struct xenvif_queue *queue, struct sk_buff *skb, struct netrx_pending_operations *npo, struct page *page, unsigned long size, unsigned long offset, int *head) @@ -267,7 +267,7 @@ static void xenvif_gop_frag_copy(struct xenvif *vif, struct sk_buff *skb, */ BUG_ON(*head); - meta = get_next_rx_buffer(vif, npo); + meta = get_next_rx_buffer(queue, npo); } if (npo->copy_off + bytes > MAX_BUFFER_OFFSET) @@ -281,7 +281,7 @@ static void xenvif_gop_frag_copy(struct xenvif *vif, struct sk_buff *skb, copy_gop->source.u.gmfn = virt_to_mfn(page_address(page)); copy_gop->source.offset = offset; - copy_gop->dest.domid = vif->domid; + copy_gop->dest.domid = queue->vif->domid; copy_gop->dest.offset = npo->copy_off; copy_gop->dest.u.ref = npo->copy_gref; @@ -306,8 +306,8 @@ static void xenvif_gop_frag_copy(struct xenvif *vif, struct sk_buff *skb, else gso_type = XEN_NETIF_GSO_TYPE_NONE; - if (*head && ((1 << gso_type) & vif->gso_mask)) - vif->rx.req_cons++; + if (*head && ((1 << gso_type) & queue->vif->gso_mask)) + queue->rx.req_cons++; *head = 0; /* There must be something in this buffer now. */ @@ -327,7 +327,8 @@ static void xenvif_gop_frag_copy(struct xenvif *vif, struct sk_buff *skb, * frontend-side LRO). */ static int xenvif_gop_skb(struct sk_buff *skb, - struct netrx_pending_operations *npo) + struct netrx_pending_operations *npo, + struct xenvif_queue *queue) { struct xenvif *vif = netdev_priv(skb->dev); int nr_frags = skb_shinfo(skb)->nr_frags; @@ -355,7 +356,7 @@ static int xenvif_gop_skb(struct sk_buff *skb, /* Set up a GSO prefix descriptor, if necessary */ if ((1 << gso_type) & vif->gso_prefix_mask) { - req = RING_GET_REQUEST(&vif->rx, vif->rx.req_cons++); + req = RING_GET_REQUEST(&queue->rx, queue->rx.req_cons++); meta = npo->meta + npo->meta_prod++; meta->gso_type = gso_type; meta->gso_size = gso_size; @@ -363,7 +364,7 @@ static int xenvif_gop_skb(struct sk_buff *skb, meta->id = req->id; } - req = RING_GET_REQUEST(&vif->rx, vif->rx.req_cons++); + req = RING_GET_REQUEST(&queue->rx, queue->rx.req_cons++); meta = npo->meta + npo->meta_prod++; if ((1 << gso_type) & vif->gso_mask) { @@ -387,13 +388,13 @@ static int xenvif_gop_skb(struct sk_buff *skb, if (data + len > skb_tail_pointer(skb)) len = skb_tail_pointer(skb) - data; - xenvif_gop_frag_copy(vif, skb, npo, + xenvif_gop_frag_copy(queue, skb, npo, virt_to_page(data), len, offset, &head); data += len; } for (i = 0; i < nr_frags; i++) { - xenvif_gop_frag_copy(vif, skb, npo, + xenvif_gop_frag_copy(queue, skb, npo, skb_frag_page(&skb_shinfo(skb)->frags[i]), skb_frag_size(&skb_shinfo(skb)->frags[i]), skb_shinfo(skb)->frags[i].page_offset, @@ -429,7 +430,7 @@ static int xenvif_check_gop(struct xenvif *vif, int nr_meta_slots, return status; } -static void xenvif_add_frag_responses(struct xenvif *vif, int status, +static void xenvif_add_frag_responses(struct xenvif_queue *queue, int status, struct xenvif_rx_meta *meta, int nr_meta_slots) { @@ -450,7 +451,7 @@ static void xenvif_add_frag_responses(struct xenvif *vif, int status, flags = XEN_NETRXF_more_data; offset = 0; - make_rx_response(vif, meta[i].id, status, offset, + make_rx_response(queue, meta[i].id, status, offset, meta[i].size, flags); } } @@ -459,12 +460,12 @@ struct skb_cb_overlay { int meta_slots_used; }; -void xenvif_kick_thread(struct xenvif *vif) +void xenvif_kick_thread(struct xenvif_queue *queue) { - wake_up(&vif->wq); + wake_up(&queue->wq); } -static void xenvif_rx_action(struct xenvif *vif) +static void xenvif_rx_action(struct xenvif_queue *queue) { s8 status; u16 flags; @@ -478,13 +479,13 @@ static void xenvif_rx_action(struct xenvif *vif) bool need_to_notify = false; struct netrx_pending_operations npo = { - .copy = vif->grant_copy_op, - .meta = vif->meta, + .copy = queue->grant_copy_op, + .meta = queue->meta, }; skb_queue_head_init(&rxq); - while ((skb = skb_dequeue(&vif->rx_queue)) != NULL) { + while ((skb = skb_dequeue(&queue->rx_queue)) != NULL) { RING_IDX max_slots_needed; int i; @@ -505,41 +506,41 @@ static void xenvif_rx_action(struct xenvif *vif) max_slots_needed++; /* If the skb may not fit then bail out now */ - if (!xenvif_rx_ring_slots_available(vif, max_slots_needed)) { - skb_queue_head(&vif->rx_queue, skb); + if (!xenvif_rx_ring_slots_available(queue, max_slots_needed)) { + skb_queue_head(&queue->rx_queue, skb); need_to_notify = true; - vif->rx_last_skb_slots = max_slots_needed; + queue->rx_last_skb_slots = max_slots_needed; break; } else - vif->rx_last_skb_slots = 0; + queue->rx_last_skb_slots = 0; sco = (struct skb_cb_overlay *)skb->cb; - sco->meta_slots_used = xenvif_gop_skb(skb, &npo); + sco->meta_slots_used = xenvif_gop_skb(skb, &npo, queue); BUG_ON(sco->meta_slots_used > max_slots_needed); __skb_queue_tail(&rxq, skb); } - BUG_ON(npo.meta_prod > ARRAY_SIZE(vif->meta)); + BUG_ON(npo.meta_prod > ARRAY_SIZE(queue->meta)); if (!npo.copy_prod) goto done; BUG_ON(npo.copy_prod > MAX_GRANT_COPY_OPS); - gnttab_batch_copy(vif->grant_copy_op, npo.copy_prod); + gnttab_batch_copy(queue->grant_copy_op, npo.copy_prod); while ((skb = __skb_dequeue(&rxq)) != NULL) { sco = (struct skb_cb_overlay *)skb->cb; - if ((1 << vif->meta[npo.meta_cons].gso_type) & - vif->gso_prefix_mask) { - resp = RING_GET_RESPONSE(&vif->rx, - vif->rx.rsp_prod_pvt++); + if ((1 << queue->meta[npo.meta_cons].gso_type) & + queue->vif->gso_prefix_mask) { + resp = RING_GET_RESPONSE(&queue->rx, + queue->rx.rsp_prod_pvt++); resp->flags = XEN_NETRXF_gso_prefix | XEN_NETRXF_more_data; - resp->offset = vif->meta[npo.meta_cons].gso_size; - resp->id = vif->meta[npo.meta_cons].id; + resp->offset = queue->meta[npo.meta_cons].gso_size; + resp->id = queue->meta[npo.meta_cons].id; resp->status = sco->meta_slots_used; npo.meta_cons++; @@ -547,10 +548,10 @@ static void xenvif_rx_action(struct xenvif *vif) } - vif->dev->stats.tx_bytes += skb->len; - vif->dev->stats.tx_packets++; + queue->stats.tx_bytes += skb->len; + queue->stats.tx_packets++; - status = xenvif_check_gop(vif, sco->meta_slots_used, &npo); + status = xenvif_check_gop(queue->vif, sco->meta_slots_used, &npo); if (sco->meta_slots_used == 1) flags = 0; @@ -564,22 +565,22 @@ static void xenvif_rx_action(struct xenvif *vif) flags |= XEN_NETRXF_data_validated; offset = 0; - resp = make_rx_response(vif, vif->meta[npo.meta_cons].id, + resp = make_rx_response(queue, queue->meta[npo.meta_cons].id, status, offset, - vif->meta[npo.meta_cons].size, + queue->meta[npo.meta_cons].size, flags); - if ((1 << vif->meta[npo.meta_cons].gso_type) & - vif->gso_mask) { + if ((1 << queue->meta[npo.meta_cons].gso_type) & + queue->vif->gso_mask) { struct xen_netif_extra_info *gso = (struct xen_netif_extra_info *) - RING_GET_RESPONSE(&vif->rx, - vif->rx.rsp_prod_pvt++); + RING_GET_RESPONSE(&queue->rx, + queue->rx.rsp_prod_pvt++); resp->flags |= XEN_NETRXF_extra_info; - gso->u.gso.type = vif->meta[npo.meta_cons].gso_type; - gso->u.gso.size = vif->meta[npo.meta_cons].gso_size; + gso->u.gso.type = queue->meta[npo.meta_cons].gso_type; + gso->u.gso.size = queue->meta[npo.meta_cons].gso_size; gso->u.gso.pad = 0; gso->u.gso.features = 0; @@ -587,11 +588,11 @@ static void xenvif_rx_action(struct xenvif *vif) gso->flags = 0; } - xenvif_add_frag_responses(vif, status, - vif->meta + npo.meta_cons + 1, + xenvif_add_frag_responses(queue, status, + queue->meta + npo.meta_cons + 1, sco->meta_slots_used); - RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&vif->rx, ret); + RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&queue->rx, ret); need_to_notify |= !!ret; @@ -601,20 +602,20 @@ static void xenvif_rx_action(struct xenvif *vif) done: if (need_to_notify) - notify_remote_via_irq(vif->rx_irq); + notify_remote_via_irq(queue->rx_irq); } -void xenvif_check_rx_xenvif(struct xenvif *vif) +void xenvif_check_rx_xenvif(struct xenvif_queue *queue) { int more_to_do; - RING_FINAL_CHECK_FOR_REQUESTS(&vif->tx, more_to_do); + RING_FINAL_CHECK_FOR_REQUESTS(&queue->tx, more_to_do); if (more_to_do) - napi_schedule(&vif->napi); + napi_schedule(&queue->napi); } -static void tx_add_credit(struct xenvif *vif) +static void tx_add_credit(struct xenvif_queue *queue) { unsigned long max_burst, max_credit; @@ -622,37 +623,37 @@ static void tx_add_credit(struct xenvif *vif) * Allow a burst big enough to transmit a jumbo packet of up to 128kB. * Otherwise the interface can seize up due to insufficient credit. */ - max_burst = RING_GET_REQUEST(&vif->tx, vif->tx.req_cons)->size; + max_burst = RING_GET_REQUEST(&queue->tx, queue->tx.req_cons)->size; max_burst = min(max_burst, 131072UL); - max_burst = max(max_burst, vif->credit_bytes); + max_burst = max(max_burst, queue->credit_bytes); /* Take care that adding a new chunk of credit doesn't wrap to zero. */ - max_credit = vif->remaining_credit + vif->credit_bytes; - if (max_credit < vif->remaining_credit) + max_credit = queue->remaining_credit + queue->credit_bytes; + if (max_credit < queue->remaining_credit) max_credit = ULONG_MAX; /* wrapped: clamp to ULONG_MAX */ - vif->remaining_credit = min(max_credit, max_burst); + queue->remaining_credit = min(max_credit, max_burst); } static void tx_credit_callback(unsigned long data) { - struct xenvif *vif = (struct xenvif *)data; - tx_add_credit(vif); - xenvif_check_rx_xenvif(vif); + struct xenvif_queue *queue = (struct xenvif_queue *)data; + tx_add_credit(queue); + xenvif_check_rx_xenvif(queue); } -static void xenvif_tx_err(struct xenvif *vif, +static void xenvif_tx_err(struct xenvif_queue *queue, struct xen_netif_tx_request *txp, RING_IDX end) { - RING_IDX cons = vif->tx.req_cons; + RING_IDX cons = queue->tx.req_cons; do { - make_tx_response(vif, txp, XEN_NETIF_RSP_ERROR); + make_tx_response(queue, txp, XEN_NETIF_RSP_ERROR); if (cons == end) break; - txp = RING_GET_REQUEST(&vif->tx, cons++); + txp = RING_GET_REQUEST(&queue->tx, cons++); } while (1); - vif->tx.req_cons = cons; + queue->tx.req_cons = cons; } static void xenvif_fatal_tx_err(struct xenvif *vif) @@ -661,12 +662,12 @@ static void xenvif_fatal_tx_err(struct xenvif *vif) xenvif_carrier_off(vif); } -static int xenvif_count_requests(struct xenvif *vif, +static int xenvif_count_requests(struct xenvif_queue *queue, struct xen_netif_tx_request *first, struct xen_netif_tx_request *txp, int work_to_do) { - RING_IDX cons = vif->tx.req_cons; + RING_IDX cons = queue->tx.req_cons; int slots = 0; int drop_err = 0; int more_data; @@ -678,10 +679,10 @@ static int xenvif_count_requests(struct xenvif *vif, struct xen_netif_tx_request dropped_tx = { 0 }; if (slots >= work_to_do) { - netdev_err(vif->dev, + netdev_err(queue->vif->dev, "Asked for %d slots but exceeds this limit\n", work_to_do); - xenvif_fatal_tx_err(vif); + xenvif_fatal_tx_err(queue->vif); return -ENODATA; } @@ -689,10 +690,10 @@ static int xenvif_count_requests(struct xenvif *vif, * considered malicious. */ if (unlikely(slots >= fatal_skb_slots)) { - netdev_err(vif->dev, + netdev_err(queue->vif->dev, "Malicious frontend using %d slots, threshold %u\n", slots, fatal_skb_slots); - xenvif_fatal_tx_err(vif); + xenvif_fatal_tx_err(queue->vif); return -E2BIG; } @@ -705,7 +706,7 @@ static int xenvif_count_requests(struct xenvif *vif, */ if (!drop_err && slots >= XEN_NETBK_LEGACY_SLOTS_MAX) { if (net_ratelimit()) - netdev_dbg(vif->dev, + netdev_dbg(queue->vif->dev, "Too many slots (%d) exceeding limit (%d), dropping packet\n", slots, XEN_NETBK_LEGACY_SLOTS_MAX); drop_err = -E2BIG; @@ -714,7 +715,7 @@ static int xenvif_count_requests(struct xenvif *vif, if (drop_err) txp = &dropped_tx; - memcpy(txp, RING_GET_REQUEST(&vif->tx, cons + slots), + memcpy(txp, RING_GET_REQUEST(&queue->tx, cons + slots), sizeof(*txp)); /* If the guest submitted a frame >= 64 KiB then @@ -728,7 +729,7 @@ static int xenvif_count_requests(struct xenvif *vif, */ if (!drop_err && txp->size > first->size) { if (net_ratelimit()) - netdev_dbg(vif->dev, + netdev_dbg(queue->vif->dev, "Invalid tx request, slot size %u > remaining size %u\n", txp->size, first->size); drop_err = -EIO; @@ -738,9 +739,9 @@ static int xenvif_count_requests(struct xenvif *vif, slots++; if (unlikely((txp->offset + txp->size) > PAGE_SIZE)) { - netdev_err(vif->dev, "Cross page boundary, txp->offset: %x, size: %u\n", + netdev_err(queue->vif->dev, "Cross page boundary, txp->offset: %x, size: %u\n", txp->offset, txp->size); - xenvif_fatal_tx_err(vif); + xenvif_fatal_tx_err(queue->vif); return -EINVAL; } @@ -752,14 +753,14 @@ static int xenvif_count_requests(struct xenvif *vif, } while (more_data); if (drop_err) { - xenvif_tx_err(vif, first, cons + slots); + xenvif_tx_err(queue, first, cons + slots); return drop_err; } return slots; } -static struct page *xenvif_alloc_page(struct xenvif *vif, +static struct page *xenvif_alloc_page(struct xenvif_queue *queue, u16 pending_idx) { struct page *page; @@ -767,12 +768,12 @@ static struct page *xenvif_alloc_page(struct xenvif *vif, page = alloc_page(GFP_ATOMIC|__GFP_COLD); if (!page) return NULL; - vif->mmap_pages[pending_idx] = page; + queue->mmap_pages[pending_idx] = page; return page; } -static struct gnttab_copy *xenvif_get_requests(struct xenvif *vif, +static struct gnttab_copy *xenvif_get_requests(struct xenvif_queue *queue, struct sk_buff *skb, struct xen_netif_tx_request *txp, struct gnttab_copy *gop) @@ -803,7 +804,7 @@ static struct gnttab_copy *xenvif_get_requests(struct xenvif *vif, for (shinfo->nr_frags = slot = start; slot < nr_slots; shinfo->nr_frags++) { struct pending_tx_info *pending_tx_info = - vif->pending_tx_info; + queue->pending_tx_info; page = alloc_page(GFP_ATOMIC|__GFP_COLD); if (!page) @@ -815,7 +816,7 @@ static struct gnttab_copy *xenvif_get_requests(struct xenvif *vif, gop->flags = GNTCOPY_source_gref; gop->source.u.ref = txp->gref; - gop->source.domid = vif->domid; + gop->source.domid = queue->vif->domid; gop->source.offset = txp->offset; gop->dest.domid = DOMID_SELF; @@ -840,9 +841,9 @@ static struct gnttab_copy *xenvif_get_requests(struct xenvif *vif, gop->len = txp->size; dst_offset += gop->len; - index = pending_index(vif->pending_cons++); + index = pending_index(queue->pending_cons++); - pending_idx = vif->pending_ring[index]; + pending_idx = queue->pending_ring[index]; memcpy(&pending_tx_info[pending_idx].req, txp, sizeof(*txp)); @@ -851,7 +852,7 @@ static struct gnttab_copy *xenvif_get_requests(struct xenvif *vif, * fields for head tx req will be set * to correct values after the loop. */ - vif->mmap_pages[pending_idx] = (void *)(~0UL); + queue->mmap_pages[pending_idx] = (void *)(~0UL); pending_tx_info[pending_idx].head = INVALID_PENDING_RING_IDX; @@ -871,7 +872,7 @@ static struct gnttab_copy *xenvif_get_requests(struct xenvif *vif, first->req.offset = 0; first->req.size = dst_offset; first->head = start_idx; - vif->mmap_pages[head_idx] = page; + queue->mmap_pages[head_idx] = page; frag_set_pending_idx(&frags[shinfo->nr_frags], head_idx); } @@ -881,18 +882,18 @@ static struct gnttab_copy *xenvif_get_requests(struct xenvif *vif, err: /* Unwind, freeing all pages and sending error responses. */ while (shinfo->nr_frags-- > start) { - xenvif_idx_release(vif, + xenvif_idx_release(queue, frag_get_pending_idx(&frags[shinfo->nr_frags]), XEN_NETIF_RSP_ERROR); } /* The head too, if necessary. */ if (start) - xenvif_idx_release(vif, pending_idx, XEN_NETIF_RSP_ERROR); + xenvif_idx_release(queue, pending_idx, XEN_NETIF_RSP_ERROR); return NULL; } -static int xenvif_tx_check_gop(struct xenvif *vif, +static int xenvif_tx_check_gop(struct xenvif_queue *queue, struct sk_buff *skb, struct gnttab_copy **gopp) { @@ -907,7 +908,7 @@ static int xenvif_tx_check_gop(struct xenvif *vif, /* Check status of header. */ err = gop->status; if (unlikely(err)) - xenvif_idx_release(vif, pending_idx, XEN_NETIF_RSP_ERROR); + xenvif_idx_release(queue, pending_idx, XEN_NETIF_RSP_ERROR); /* Skip first skb fragment if it is on same page as header fragment. */ start = (frag_get_pending_idx(&shinfo->frags[0]) == pending_idx); @@ -917,7 +918,7 @@ static int xenvif_tx_check_gop(struct xenvif *vif, pending_ring_idx_t head; pending_idx = frag_get_pending_idx(&shinfo->frags[i]); - tx_info = &vif->pending_tx_info[pending_idx]; + tx_info = &queue->pending_tx_info[pending_idx]; head = tx_info->head; /* Check error status: if okay then remember grant handle. */ @@ -925,19 +926,19 @@ static int xenvif_tx_check_gop(struct xenvif *vif, newerr = (++gop)->status; if (newerr) break; - peek = vif->pending_ring[pending_index(++head)]; - } while (!pending_tx_is_head(vif, peek)); + peek = queue->pending_ring[pending_index(++head)]; + } while (!pending_tx_is_head(queue, peek)); if (likely(!newerr)) { /* Had a previous error? Invalidate this fragment. */ if (unlikely(err)) - xenvif_idx_release(vif, pending_idx, + xenvif_idx_release(queue, pending_idx, XEN_NETIF_RSP_OKAY); continue; } /* Error on this fragment: respond to client with an error. */ - xenvif_idx_release(vif, pending_idx, XEN_NETIF_RSP_ERROR); + xenvif_idx_release(queue, pending_idx, XEN_NETIF_RSP_ERROR); /* Not the first error? Preceding frags already invalidated. */ if (err) @@ -945,10 +946,10 @@ static int xenvif_tx_check_gop(struct xenvif *vif, /* First error: invalidate header and preceding fragments. */ pending_idx = *((u16 *)skb->data); - xenvif_idx_release(vif, pending_idx, XEN_NETIF_RSP_OKAY); + xenvif_idx_release(queue, pending_idx, XEN_NETIF_RSP_OKAY); for (j = start; j < i; j++) { pending_idx = frag_get_pending_idx(&shinfo->frags[j]); - xenvif_idx_release(vif, pending_idx, + xenvif_idx_release(queue, pending_idx, XEN_NETIF_RSP_OKAY); } @@ -960,7 +961,7 @@ static int xenvif_tx_check_gop(struct xenvif *vif, return err; } -static void xenvif_fill_frags(struct xenvif *vif, struct sk_buff *skb) +static void xenvif_fill_frags(struct xenvif_queue *queue, struct sk_buff *skb) { struct skb_shared_info *shinfo = skb_shinfo(skb); int nr_frags = shinfo->nr_frags; @@ -974,46 +975,46 @@ static void xenvif_fill_frags(struct xenvif *vif, struct sk_buff *skb) pending_idx = frag_get_pending_idx(frag); - txp = &vif->pending_tx_info[pending_idx].req; - page = virt_to_page(idx_to_kaddr(vif, pending_idx)); + txp = &queue->pending_tx_info[pending_idx].req; + page = virt_to_page(idx_to_kaddr(queue, pending_idx)); __skb_fill_page_desc(skb, i, page, txp->offset, txp->size); skb->len += txp->size; skb->data_len += txp->size; skb->truesize += txp->size; /* Take an extra reference to offset xenvif_idx_release */ - get_page(vif->mmap_pages[pending_idx]); - xenvif_idx_release(vif, pending_idx, XEN_NETIF_RSP_OKAY); + get_page(queue->mmap_pages[pending_idx]); + xenvif_idx_release(queue, pending_idx, XEN_NETIF_RSP_OKAY); } } -static int xenvif_get_extras(struct xenvif *vif, +static int xenvif_get_extras(struct xenvif_queue *queue, struct xen_netif_extra_info *extras, int work_to_do) { struct xen_netif_extra_info extra; - RING_IDX cons = vif->tx.req_cons; + RING_IDX cons = queue->tx.req_cons; do { if (unlikely(work_to_do-- <= 0)) { - netdev_err(vif->dev, "Missing extra info\n"); - xenvif_fatal_tx_err(vif); + netdev_err(queue->vif->dev, "Missing extra info\n"); + xenvif_fatal_tx_err(queue->vif); return -EBADR; } - memcpy(&extra, RING_GET_REQUEST(&vif->tx, cons), + memcpy(&extra, RING_GET_REQUEST(&queue->tx, cons), sizeof(extra)); if (unlikely(!extra.type || extra.type >= XEN_NETIF_EXTRA_TYPE_MAX)) { - vif->tx.req_cons = ++cons; - netdev_err(vif->dev, + queue->tx.req_cons = ++cons; + netdev_err(queue->vif->dev, "Invalid extra type: %d\n", extra.type); - xenvif_fatal_tx_err(vif); + xenvif_fatal_tx_err(queue->vif); return -EINVAL; } memcpy(&extras[extra.type - 1], &extra, sizeof(extra)); - vif->tx.req_cons = ++cons; + queue->tx.req_cons = ++cons; } while (extra.flags & XEN_NETIF_EXTRA_FLAG_MORE); return work_to_do; @@ -1048,7 +1049,7 @@ static int xenvif_set_skb_gso(struct xenvif *vif, return 0; } -static int checksum_setup(struct xenvif *vif, struct sk_buff *skb) +static int checksum_setup(struct xenvif_queue *queue, struct sk_buff *skb) { bool recalculate_partial_csum = false; @@ -1058,7 +1059,7 @@ static int checksum_setup(struct xenvif *vif, struct sk_buff *skb) * recalculate the partial checksum. */ if (skb->ip_summed != CHECKSUM_PARTIAL && skb_is_gso(skb)) { - vif->rx_gso_checksum_fixup++; + queue->stats.rx_gso_checksum_fixup++; skb->ip_summed = CHECKSUM_PARTIAL; recalculate_partial_csum = true; } @@ -1070,31 +1071,31 @@ static int checksum_setup(struct xenvif *vif, struct sk_buff *skb) return skb_checksum_setup(skb, recalculate_partial_csum); } -static bool tx_credit_exceeded(struct xenvif *vif, unsigned size) +static bool tx_credit_exceeded(struct xenvif_queue *queue, unsigned size) { u64 now = get_jiffies_64(); - u64 next_credit = vif->credit_window_start + - msecs_to_jiffies(vif->credit_usec / 1000); + u64 next_credit = queue->credit_window_start + + msecs_to_jiffies(queue->credit_usec / 1000); /* Timer could already be pending in rare cases. */ - if (timer_pending(&vif->credit_timeout)) + if (timer_pending(&queue->credit_timeout)) return true; /* Passed the point where we can replenish credit? */ if (time_after_eq64(now, next_credit)) { - vif->credit_window_start = now; - tx_add_credit(vif); + queue->credit_window_start = now; + tx_add_credit(queue); } /* Still too big to send right now? Set a callback. */ - if (size > vif->remaining_credit) { - vif->credit_timeout.data = - (unsigned long)vif; - vif->credit_timeout.function = + if (size > queue->remaining_credit) { + queue->credit_timeout.data = + (unsigned long)queue; + queue->credit_timeout.function = tx_credit_callback; - mod_timer(&vif->credit_timeout, + mod_timer(&queue->credit_timeout, next_credit); - vif->credit_window_start = next_credit; + queue->credit_window_start = next_credit; return true; } @@ -1102,15 +1103,15 @@ static bool tx_credit_exceeded(struct xenvif *vif, unsigned size) return false; } -static unsigned xenvif_tx_build_gops(struct xenvif *vif, int budget) +static unsigned xenvif_tx_build_gops(struct xenvif_queue *queue, int budget) { - struct gnttab_copy *gop = vif->tx_copy_ops, *request_gop; + struct gnttab_copy *gop = queue->tx_copy_ops, *request_gop; struct sk_buff *skb; int ret; - while ((nr_pending_reqs(vif) + XEN_NETBK_LEGACY_SLOTS_MAX + while ((nr_pending_reqs(queue) + XEN_NETBK_LEGACY_SLOTS_MAX < MAX_PENDING_REQS) && - (skb_queue_len(&vif->tx_queue) < budget)) { + (skb_queue_len(&queue->tx_queue) < budget)) { struct xen_netif_tx_request txreq; struct xen_netif_tx_request txfrags[XEN_NETBK_LEGACY_SLOTS_MAX]; struct page *page; @@ -1121,69 +1122,69 @@ static unsigned xenvif_tx_build_gops(struct xenvif *vif, int budget) unsigned int data_len; pending_ring_idx_t index; - if (vif->tx.sring->req_prod - vif->tx.req_cons > + if (queue->tx.sring->req_prod - queue->tx.req_cons > XEN_NETIF_TX_RING_SIZE) { - netdev_err(vif->dev, + netdev_err(queue->vif->dev, "Impossible number of requests. " "req_prod %d, req_cons %d, size %ld\n", - vif->tx.sring->req_prod, vif->tx.req_cons, + queue->tx.sring->req_prod, queue->tx.req_cons, XEN_NETIF_TX_RING_SIZE); - xenvif_fatal_tx_err(vif); + xenvif_fatal_tx_err(queue->vif); continue; } - work_to_do = RING_HAS_UNCONSUMED_REQUESTS(&vif->tx); + work_to_do = RING_HAS_UNCONSUMED_REQUESTS(&queue->tx); if (!work_to_do) break; - idx = vif->tx.req_cons; + idx = queue->tx.req_cons; rmb(); /* Ensure that we see the request before we copy it. */ - memcpy(&txreq, RING_GET_REQUEST(&vif->tx, idx), sizeof(txreq)); + memcpy(&txreq, RING_GET_REQUEST(&queue->tx, idx), sizeof(txreq)); /* Credit-based scheduling. */ - if (txreq.size > vif->remaining_credit && - tx_credit_exceeded(vif, txreq.size)) + if (txreq.size > queue->remaining_credit && + tx_credit_exceeded(queue, txreq.size)) break; - vif->remaining_credit -= txreq.size; + queue->remaining_credit -= txreq.size; work_to_do--; - vif->tx.req_cons = ++idx; + queue->tx.req_cons = ++idx; memset(extras, 0, sizeof(extras)); if (txreq.flags & XEN_NETTXF_extra_info) { - work_to_do = xenvif_get_extras(vif, extras, + work_to_do = xenvif_get_extras(queue, extras, work_to_do); - idx = vif->tx.req_cons; + idx = queue->tx.req_cons; if (unlikely(work_to_do < 0)) break; } - ret = xenvif_count_requests(vif, &txreq, txfrags, work_to_do); + ret = xenvif_count_requests(queue, &txreq, txfrags, work_to_do); if (unlikely(ret < 0)) break; idx += ret; if (unlikely(txreq.size < ETH_HLEN)) { - netdev_dbg(vif->dev, + netdev_dbg(queue->vif->dev, "Bad packet size: %d\n", txreq.size); - xenvif_tx_err(vif, &txreq, idx); + xenvif_tx_err(queue, &txreq, idx); break; } /* No crossing a page as the payload mustn't fragment. */ if (unlikely((txreq.offset + txreq.size) > PAGE_SIZE)) { - netdev_err(vif->dev, + netdev_err(queue->vif->dev, "txreq.offset: %x, size: %u, end: %lu\n", txreq.offset, txreq.size, (txreq.offset&~PAGE_MASK) + txreq.size); - xenvif_fatal_tx_err(vif); + xenvif_fatal_tx_err(queue->vif); break; } - index = pending_index(vif->pending_cons); - pending_idx = vif->pending_ring[index]; + index = pending_index(queue->pending_cons); + pending_idx = queue->pending_ring[index]; data_len = (txreq.size > PKT_PROT_LEN && ret < XEN_NETBK_LEGACY_SLOTS_MAX) ? @@ -1192,9 +1193,9 @@ static unsigned xenvif_tx_build_gops(struct xenvif *vif, int budget) skb = alloc_skb(data_len + NET_SKB_PAD + NET_IP_ALIGN, GFP_ATOMIC | __GFP_NOWARN); if (unlikely(skb == NULL)) { - netdev_dbg(vif->dev, + netdev_dbg(queue->vif->dev, "Can't allocate a skb in start_xmit.\n"); - xenvif_tx_err(vif, &txreq, idx); + xenvif_tx_err(queue, &txreq, idx); break; } @@ -1205,7 +1206,7 @@ static unsigned xenvif_tx_build_gops(struct xenvif *vif, int budget) struct xen_netif_extra_info *gso; gso = &extras[XEN_NETIF_EXTRA_TYPE_GSO - 1]; - if (xenvif_set_skb_gso(vif, skb, gso)) { + if (xenvif_set_skb_gso(queue->vif, skb, gso)) { /* Failure in xenvif_set_skb_gso is fatal. */ kfree_skb(skb); break; @@ -1213,15 +1214,15 @@ static unsigned xenvif_tx_build_gops(struct xenvif *vif, int budget) } /* XXX could copy straight to head */ - page = xenvif_alloc_page(vif, pending_idx); + page = xenvif_alloc_page(queue, pending_idx); if (!page) { kfree_skb(skb); - xenvif_tx_err(vif, &txreq, idx); + xenvif_tx_err(queue, &txreq, idx); break; } gop->source.u.ref = txreq.gref; - gop->source.domid = vif->domid; + gop->source.domid = queue->vif->domid; gop->source.offset = txreq.offset; gop->dest.u.gmfn = virt_to_mfn(page_address(page)); @@ -1233,9 +1234,9 @@ static unsigned xenvif_tx_build_gops(struct xenvif *vif, int budget) gop++; - memcpy(&vif->pending_tx_info[pending_idx].req, + memcpy(&queue->pending_tx_info[pending_idx].req, &txreq, sizeof(txreq)); - vif->pending_tx_info[pending_idx].head = index; + queue->pending_tx_info[pending_idx].head = index; *((u16 *)skb->data) = pending_idx; __skb_put(skb, data_len); @@ -1250,45 +1251,45 @@ static unsigned xenvif_tx_build_gops(struct xenvif *vif, int budget) INVALID_PENDING_IDX); } - vif->pending_cons++; + queue->pending_cons++; - request_gop = xenvif_get_requests(vif, skb, txfrags, gop); + request_gop = xenvif_get_requests(queue, skb, txfrags, gop); if (request_gop == NULL) { kfree_skb(skb); - xenvif_tx_err(vif, &txreq, idx); + xenvif_tx_err(queue, &txreq, idx); break; } gop = request_gop; - __skb_queue_tail(&vif->tx_queue, skb); + __skb_queue_tail(&queue->tx_queue, skb); - vif->tx.req_cons = idx; + queue->tx.req_cons = idx; - if ((gop-vif->tx_copy_ops) >= ARRAY_SIZE(vif->tx_copy_ops)) + if ((gop - queue->tx_copy_ops) >= ARRAY_SIZE(queue->tx_copy_ops)) break; } - return gop - vif->tx_copy_ops; + return gop - queue->tx_copy_ops; } -static int xenvif_tx_submit(struct xenvif *vif) +static int xenvif_tx_submit(struct xenvif_queue *queue) { - struct gnttab_copy *gop = vif->tx_copy_ops; + struct gnttab_copy *gop = queue->tx_copy_ops; struct sk_buff *skb; int work_done = 0; - while ((skb = __skb_dequeue(&vif->tx_queue)) != NULL) { + while ((skb = __skb_dequeue(&queue->tx_queue)) != NULL) { struct xen_netif_tx_request *txp; u16 pending_idx; unsigned data_len; pending_idx = *((u16 *)skb->data); - txp = &vif->pending_tx_info[pending_idx].req; + txp = &queue->pending_tx_info[pending_idx].req; /* Check the remap error code. */ - if (unlikely(xenvif_tx_check_gop(vif, skb, &gop))) { - netdev_dbg(vif->dev, "netback grant failed.\n"); + if (unlikely(xenvif_tx_check_gop(queue, skb, &gop))) { + netdev_dbg(queue->vif->dev, "netback grant failed.\n"); skb_shinfo(skb)->nr_frags = 0; kfree_skb(skb); continue; @@ -1296,7 +1297,7 @@ static int xenvif_tx_submit(struct xenvif *vif) data_len = skb->len; memcpy(skb->data, - (void *)(idx_to_kaddr(vif, pending_idx)|txp->offset), + (void *)(idx_to_kaddr(queue, pending_idx)|txp->offset), data_len); if (data_len < txp->size) { /* Append the packet payload as a fragment. */ @@ -1304,7 +1305,7 @@ static int xenvif_tx_submit(struct xenvif *vif) txp->size -= data_len; } else { /* Schedule a response immediately. */ - xenvif_idx_release(vif, pending_idx, + xenvif_idx_release(queue, pending_idx, XEN_NETIF_RSP_OKAY); } @@ -1313,19 +1314,19 @@ static int xenvif_tx_submit(struct xenvif *vif) else if (txp->flags & XEN_NETTXF_data_validated) skb->ip_summed = CHECKSUM_UNNECESSARY; - xenvif_fill_frags(vif, skb); + xenvif_fill_frags(queue, skb); if (skb_is_nonlinear(skb) && skb_headlen(skb) < PKT_PROT_LEN) { int target = min_t(int, skb->len, PKT_PROT_LEN); __pskb_pull_tail(skb, target - skb_headlen(skb)); } - skb->dev = vif->dev; + skb->dev = queue->vif->dev; skb->protocol = eth_type_trans(skb, skb->dev); skb_reset_network_header(skb); - if (checksum_setup(vif, skb)) { - netdev_dbg(vif->dev, + if (checksum_setup(queue, skb)) { + netdev_dbg(queue->vif->dev, "Can't setup checksum in net_tx_action\n"); kfree_skb(skb); continue; @@ -1347,8 +1348,8 @@ static int xenvif_tx_submit(struct xenvif *vif) DIV_ROUND_UP(skb->len - hdrlen, mss); } - vif->dev->stats.rx_bytes += skb->len; - vif->dev->stats.rx_packets++; + queue->stats.rx_bytes += skb->len; + queue->stats.rx_packets++; work_done++; @@ -1359,53 +1360,53 @@ static int xenvif_tx_submit(struct xenvif *vif) } /* Called after netfront has transmitted */ -int xenvif_tx_action(struct xenvif *vif, int budget) +int xenvif_tx_action(struct xenvif_queue *queue, int budget) { unsigned nr_gops; int work_done; - if (unlikely(!tx_work_todo(vif))) + if (unlikely(!tx_work_todo(queue))) return 0; - nr_gops = xenvif_tx_build_gops(vif, budget); + nr_gops = xenvif_tx_build_gops(queue, budget); if (nr_gops == 0) return 0; - gnttab_batch_copy(vif->tx_copy_ops, nr_gops); + gnttab_batch_copy(queue->tx_copy_ops, nr_gops); - work_done = xenvif_tx_submit(vif); + work_done = xenvif_tx_submit(queue); return work_done; } -static void xenvif_idx_release(struct xenvif *vif, u16 pending_idx, +static void xenvif_idx_release(struct xenvif_queue *queue, u16 pending_idx, u8 status) { struct pending_tx_info *pending_tx_info; pending_ring_idx_t head; u16 peek; /* peek into next tx request */ - BUG_ON(vif->mmap_pages[pending_idx] == (void *)(~0UL)); + BUG_ON(queue->mmap_pages[pending_idx] == (void *)(~0UL)); /* Already complete? */ - if (vif->mmap_pages[pending_idx] == NULL) + if (queue->mmap_pages[pending_idx] == NULL) return; - pending_tx_info = &vif->pending_tx_info[pending_idx]; + pending_tx_info = &queue->pending_tx_info[pending_idx]; head = pending_tx_info->head; - BUG_ON(!pending_tx_is_head(vif, head)); - BUG_ON(vif->pending_ring[pending_index(head)] != pending_idx); + BUG_ON(!pending_tx_is_head(queue, head)); + BUG_ON(queue->pending_ring[pending_index(head)] != pending_idx); do { pending_ring_idx_t index; pending_ring_idx_t idx = pending_index(head); - u16 info_idx = vif->pending_ring[idx]; + u16 info_idx = queue->pending_ring[idx]; - pending_tx_info = &vif->pending_tx_info[info_idx]; - make_tx_response(vif, &pending_tx_info->req, status); + pending_tx_info = &queue->pending_tx_info[info_idx]; + make_tx_response(queue, &pending_tx_info->req, status); /* Setting any number other than * INVALID_PENDING_RING_IDX indicates this slot is @@ -1413,50 +1414,50 @@ static void xenvif_idx_release(struct xenvif *vif, u16 pending_idx, */ pending_tx_info->head = 0; - index = pending_index(vif->pending_prod++); - vif->pending_ring[index] = vif->pending_ring[info_idx]; + index = pending_index(queue->pending_prod++); + queue->pending_ring[index] = queue->pending_ring[info_idx]; - peek = vif->pending_ring[pending_index(++head)]; + peek = queue->pending_ring[pending_index(++head)]; - } while (!pending_tx_is_head(vif, peek)); + } while (!pending_tx_is_head(queue, peek)); - put_page(vif->mmap_pages[pending_idx]); - vif->mmap_pages[pending_idx] = NULL; + put_page(queue->mmap_pages[pending_idx]); + queue->mmap_pages[pending_idx] = NULL; } -static void make_tx_response(struct xenvif *vif, +static void make_tx_response(struct xenvif_queue *queue, struct xen_netif_tx_request *txp, s8 st) { - RING_IDX i = vif->tx.rsp_prod_pvt; + RING_IDX i = queue->tx.rsp_prod_pvt; struct xen_netif_tx_response *resp; int notify; - resp = RING_GET_RESPONSE(&vif->tx, i); + resp = RING_GET_RESPONSE(&queue->tx, i); resp->id = txp->id; resp->status = st; if (txp->flags & XEN_NETTXF_extra_info) - RING_GET_RESPONSE(&vif->tx, ++i)->status = XEN_NETIF_RSP_NULL; + RING_GET_RESPONSE(&queue->tx, ++i)->status = XEN_NETIF_RSP_NULL; - vif->tx.rsp_prod_pvt = ++i; - RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&vif->tx, notify); + queue->tx.rsp_prod_pvt = ++i; + RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&queue->tx, notify); if (notify) - notify_remote_via_irq(vif->tx_irq); + notify_remote_via_irq(queue->tx_irq); } -static struct xen_netif_rx_response *make_rx_response(struct xenvif *vif, +static struct xen_netif_rx_response *make_rx_response(struct xenvif_queue *queue, u16 id, s8 st, u16 offset, u16 size, u16 flags) { - RING_IDX i = vif->rx.rsp_prod_pvt; + RING_IDX i = queue->rx.rsp_prod_pvt; struct xen_netif_rx_response *resp; - resp = RING_GET_RESPONSE(&vif->rx, i); + resp = RING_GET_RESPONSE(&queue->rx, i); resp->offset = offset; resp->flags = flags; resp->id = id; @@ -1464,39 +1465,39 @@ static struct xen_netif_rx_response *make_rx_response(struct xenvif *vif, if (st < 0) resp->status = (s16)st; - vif->rx.rsp_prod_pvt = ++i; + queue->rx.rsp_prod_pvt = ++i; return resp; } -static inline int rx_work_todo(struct xenvif *vif) +static inline int rx_work_todo(struct xenvif_queue *queue) { - return !skb_queue_empty(&vif->rx_queue) && - xenvif_rx_ring_slots_available(vif, vif->rx_last_skb_slots); + return !skb_queue_empty(&queue->rx_queue) && + xenvif_rx_ring_slots_available(queue, queue->rx_last_skb_slots); } -static inline int tx_work_todo(struct xenvif *vif) +static inline int tx_work_todo(struct xenvif_queue *queue) { - if (likely(RING_HAS_UNCONSUMED_REQUESTS(&vif->tx)) && - (nr_pending_reqs(vif) + XEN_NETBK_LEGACY_SLOTS_MAX + if (likely(RING_HAS_UNCONSUMED_REQUESTS(&queue->tx)) && + (nr_pending_reqs(queue) + XEN_NETBK_LEGACY_SLOTS_MAX < MAX_PENDING_REQS)) return 1; return 0; } -void xenvif_unmap_frontend_rings(struct xenvif *vif) +void xenvif_unmap_frontend_rings(struct xenvif_queue *queue) { - if (vif->tx.sring) - xenbus_unmap_ring_vfree(xenvif_to_xenbus_device(vif), - vif->tx.sring); - if (vif->rx.sring) - xenbus_unmap_ring_vfree(xenvif_to_xenbus_device(vif), - vif->rx.sring); + if (queue->tx.sring) + xenbus_unmap_ring_vfree(xenvif_to_xenbus_device(queue->vif), + queue->tx.sring); + if (queue->rx.sring) + xenbus_unmap_ring_vfree(xenvif_to_xenbus_device(queue->vif), + queue->rx.sring); } -int xenvif_map_frontend_rings(struct xenvif *vif, +int xenvif_map_frontend_rings(struct xenvif_queue *queue, grant_ref_t tx_ring_ref, grant_ref_t rx_ring_ref) { @@ -1506,67 +1507,72 @@ int xenvif_map_frontend_rings(struct xenvif *vif, int err = -ENOMEM; - err = xenbus_map_ring_valloc(xenvif_to_xenbus_device(vif), + err = xenbus_map_ring_valloc(xenvif_to_xenbus_device(queue->vif), tx_ring_ref, &addr); if (err) goto err; txs = (struct xen_netif_tx_sring *)addr; - BACK_RING_INIT(&vif->tx, txs, PAGE_SIZE); + BACK_RING_INIT(&queue->tx, txs, PAGE_SIZE); - err = xenbus_map_ring_valloc(xenvif_to_xenbus_device(vif), + err = xenbus_map_ring_valloc(xenvif_to_xenbus_device(queue->vif), rx_ring_ref, &addr); if (err) goto err; rxs = (struct xen_netif_rx_sring *)addr; - BACK_RING_INIT(&vif->rx, rxs, PAGE_SIZE); + BACK_RING_INIT(&queue->rx, rxs, PAGE_SIZE); return 0; err: - xenvif_unmap_frontend_rings(vif); + xenvif_unmap_frontend_rings(queue); return err; } -void xenvif_stop_queue(struct xenvif *vif) +static inline void xenvif_wake_queue(struct xenvif_queue *queue) { - if (!vif->can_queue) - return; + struct net_device *dev = queue->vif->dev; + netif_tx_wake_queue(netdev_get_tx_queue(dev, queue->id)); +} - netif_stop_queue(vif->dev); +static void xenvif_start_queue(struct xenvif_queue *queue) +{ + if (xenvif_schedulable(queue->vif)) + xenvif_wake_queue(queue); } -static void xenvif_start_queue(struct xenvif *vif) +static int xenvif_queue_stopped(struct xenvif_queue *queue) { - if (xenvif_schedulable(vif)) - netif_wake_queue(vif->dev); + struct net_device *dev = queue->vif->dev; + unsigned int id = queue->id; + return netif_tx_queue_stopped(netdev_get_tx_queue(dev, id)); } int xenvif_kthread(void *data) { - struct xenvif *vif = data; + struct xenvif_queue *queue = data; struct sk_buff *skb; while (!kthread_should_stop()) { - wait_event_interruptible(vif->wq, - rx_work_todo(vif) || + wait_event_interruptible(queue->wq, + rx_work_todo(queue) || kthread_should_stop()); if (kthread_should_stop()) break; - if (!skb_queue_empty(&vif->rx_queue)) - xenvif_rx_action(vif); + if (!skb_queue_empty(&queue->rx_queue)) + xenvif_rx_action(queue); - if (skb_queue_empty(&vif->rx_queue) && - netif_queue_stopped(vif->dev)) - xenvif_start_queue(vif); + if (skb_queue_empty(&queue->rx_queue) && + xenvif_queue_stopped(queue)) + xenvif_start_queue(queue); cond_resched(); } /* Bin any remaining skbs */ - while ((skb = skb_dequeue(&vif->rx_queue)) != NULL) + while ((skb = skb_dequeue(&queue->rx_queue)) != NULL) dev_kfree_skb(skb); return 0; diff --git a/drivers/net/xen-netback/xenbus.c b/drivers/net/xen-netback/xenbus.c index 7a206cf..f23ea0a 100644 --- a/drivers/net/xen-netback/xenbus.c +++ b/drivers/net/xen-netback/xenbus.c @@ -19,6 +19,7 @@ */ #include "common.h" +#include struct backend_info { struct xenbus_device *dev; @@ -34,8 +35,9 @@ struct backend_info { u8 have_hotplug_status_watch:1; }; -static int connect_rings(struct backend_info *); -static void connect(struct backend_info *); +static int connect_rings(struct backend_info *be, struct xenvif_queue *queue); +static void connect(struct backend_info *be); +static int read_xenbus_vif_flags(struct backend_info *be); static void backend_create_xenvif(struct backend_info *be); static void unregister_hotplug_status_watch(struct backend_info *be); static void set_backend_state(struct backend_info *be, @@ -485,10 +487,9 @@ static void connect(struct backend_info *be) { int err; struct xenbus_device *dev = be->dev; - - err = connect_rings(be); - if (err) - return; + unsigned long credit_bytes, credit_usec; + unsigned int queue_index; + struct xenvif_queue *queue; err = xen_net_read_mac(dev, be->vif->fe_dev_addr); if (err) { @@ -496,9 +497,30 @@ static void connect(struct backend_info *be) return; } - xen_net_read_rate(dev, &be->vif->credit_bytes, - &be->vif->credit_usec); - be->vif->remaining_credit = be->vif->credit_bytes; + xen_net_read_rate(dev, &credit_bytes, &credit_usec); + read_xenbus_vif_flags(be); + + be->vif->num_queues = 1; + be->vif->queues = vzalloc(be->vif->num_queues * + sizeof(struct xenvif_queue)); + + for (queue_index = 0; queue_index < be->vif->num_queues; ++queue_index) { + queue = &be->vif->queues[queue_index]; + queue->vif = be->vif; + queue->id = queue_index; + snprintf(queue->name, sizeof(queue->name), "%s-q%u", + be->vif->dev->name, queue->id); + + xenvif_init_queue(queue); + + queue->remaining_credit = credit_bytes; + + err = connect_rings(be, queue); + if (err) + goto err; + } + + xenvif_carrier_on(be->vif); unregister_hotplug_status_watch(be); err = xenbus_watch_pathfmt(dev, &be->hotplug_status_watch, @@ -507,18 +529,24 @@ static void connect(struct backend_info *be) if (!err) be->have_hotplug_status_watch = 1; - netif_wake_queue(be->vif->dev); + netif_tx_wake_all_queues(be->vif->dev); + + return; + +err: + vfree(be->vif->queues); + be->vif->queues = NULL; + be->vif->num_queues = 0; + return; } -static int connect_rings(struct backend_info *be) +static int connect_rings(struct backend_info *be, struct xenvif_queue *queue) { - struct xenvif *vif = be->vif; struct xenbus_device *dev = be->dev; unsigned long tx_ring_ref, rx_ring_ref; - unsigned int tx_evtchn, rx_evtchn, rx_copy; + unsigned int tx_evtchn, rx_evtchn; int err; - int val; err = xenbus_gather(XBT_NIL, dev->otherend, "tx-ring-ref", "%lu", &tx_ring_ref, @@ -546,6 +574,27 @@ static int connect_rings(struct backend_info *be) rx_evtchn = tx_evtchn; } + /* Map the shared frame, irq etc. */ + err = xenvif_connect(queue, tx_ring_ref, rx_ring_ref, + tx_evtchn, rx_evtchn); + if (err) { + xenbus_dev_fatal(dev, err, + "mapping shared-frames %lu/%lu port tx %u rx %u", + tx_ring_ref, rx_ring_ref, + tx_evtchn, rx_evtchn); + return err; + } + + return 0; +} + +static int read_xenbus_vif_flags(struct backend_info *be) +{ + struct xenvif *vif = be->vif; + struct xenbus_device *dev = be->dev; + unsigned int rx_copy; + int err, val; + err = xenbus_scanf(XBT_NIL, dev->otherend, "request-rx-copy", "%u", &rx_copy); if (err == -ENOENT) { @@ -621,16 +670,6 @@ static int connect_rings(struct backend_info *be) val = 0; vif->ipv6_csum = !!val; - /* Map the shared frame, irq etc. */ - err = xenvif_connect(vif, tx_ring_ref, rx_ring_ref, - tx_evtchn, rx_evtchn); - if (err) { - xenbus_dev_fatal(dev, err, - "mapping shared-frames %lu/%lu port tx %u rx %u", - tx_ring_ref, rx_ring_ref, - tx_evtchn, rx_evtchn); - return err; - } return 0; } -- 1.7.10.4 _______________________________________________ Xen-devel mailing list Xen-devel@lists.xen.org http://lists.xen.org/xen-devel From xen-devel-bounces@lists.xen.org Tue Mar 04 12:06:23 2014 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Tue, 04 Mar 2014 12:06:23 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WKo6w-0003Lk-Ls; Tue, 04 Mar 2014 12:06:14 +0000 Received: from mail6.bemta14.messagelabs.com ([193.109.254.103]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WKo6t-0003LY-IY for xen-devel@lists.xen.org; Tue, 04 Mar 2014 12:06:13 +0000 Received: from [193.109.254.147:44536] by server-6.bemta-14.messagelabs.com id 2B/A3-03396-2B1C5135; Tue, 04 Mar 2014 12:06:10 +0000 X-Env-Sender: Andrew.Cooper3@citrix.com X-Msg-Ref: server-16.tower-27.messagelabs.com!1393934765!8241824!1 X-Originating-IP: [66.165.176.63] X-SpamReason: No, hits=0.0 required=7.0 tests=sa_preprocessor: VHJ1c3RlZCBJUDogNjYuMTY1LjE3Ni42MyA9PiAzMDYwNDg=\n X-StarScan-Received: X-StarScan-Version: 6.9.16; banners=-,-,- X-VirusChecked: Checked Received: (qmail 4294 invoked from network); 4 Mar 2014 12:06:06 -0000 Received: from smtp02.citrix.com (HELO SMTP02.CITRIX.COM) (66.165.176.63) by server-16.tower-27.messagelabs.com with RC4-SHA encrypted SMTP; 4 Mar 2014 12:06:06 -0000 X-IronPort-AV: E=Sophos;i="4.97,584,1389744000"; d="scan'208";a="106349606" Received: from accessns.citrite.net (HELO FTLPEX01CL03.citrite.net) ([10.9.154.239]) by FTLPIPO02.CITRIX.COM with ESMTP; 04 Mar 2014 12:06:04 +0000 Received: from ukmail1.uk.xensource.com (10.80.16.128) by smtprelay.citrix.com (10.13.107.80) with Microsoft SMTP Server id 14.2.342.4; Tue, 4 Mar 2014 07:06:03 -0500 Received: from andrewcoop.uk.xensource.com ([10.80.2.18]) by ukmail1.uk.xensource.com with esmtp (Exim 4.69) (envelope-from ) id 1WKo6l-00048c-8j; Tue, 04 Mar 2014 12:06:03 +0000 Message-ID: <5315C1AB.1010409@citrix.com> Date: Tue, 4 Mar 2014 12:06:03 +0000 From: Andrew Cooper User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:17.0) Gecko/20131103 Icedove/17.0.10 MIME-Version: 1.0 To: Paul Durrant References: <1393933235-6064-1-git-send-email-paul.durrant@citrix.com> <1393933235-6064-6-git-send-email-paul.durrant@citrix.com> In-Reply-To: <1393933235-6064-6-git-send-email-paul.durrant@citrix.com> X-Enigmail-Version: 1.6 X-DLP: MIA1 Cc: xen-devel@lists.xen.org Subject: Re: [Xen-devel] [PATCH v2 5/6] ioreq-server: add support for multiple servers X-BeenThere: xen-devel@lists.xen.org X-Mailman-Version: 2.1.13 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Sender: xen-devel-bounces@lists.xen.org Errors-To: xen-devel-bounces@lists.xen.org On 04/03/14 11:40, Paul Durrant wrote: > The legacy 'catch-all' server is always created with id 0. Secondary > servers will have an id ranging from 1 to a limit set by the toolstack > via the 'max_emulators' build info field. This defaults to 1 so ordinarily > no extra special pages are reserved for secondary emulators. It may be > increased using the secondary_device_emulators parameter in xl.cfg(5). > There's no clear limit to apply to the number of emulators so I've not > applied one. > > Because of the re-arrangement of the special pages in a previous patch we > only need the addition of parameter HVM_PARAM_NR_IOREQ_SERVERS to determine > the layout of the shared pages for multiple emulators. Guests migrated in > from hosts without this patch will be lacking the save record which stores > the new parameter and so the guest is assumed to only have had a single > emulator. > > Added some more emacs boilerplate to xenctrl.h and xenguest.h > > Signed-off-by: Paul Durrant How does the build param interact with the hvmparam? It appears not to. On migrate, the receiving side will have to know, out-of-band, what to set max_emulators to when building the domain. The setparam code needs to validate the hvmparam against the build param and return -EINVAL/-E2BIG in the case that the hvmparam is too large. xc_domain_restore() needs to detect this and abort the migration if the guest can't be restored with the expected number of emulators. ~Andrew > --- > docs/man/xl.cfg.pod.5 | 7 + > tools/libxc/xc_domain.c | 175 +++++++ > tools/libxc/xc_domain_restore.c | 20 + > tools/libxc/xc_domain_save.c | 12 + > tools/libxc/xc_hvm_build_x86.c | 24 +- > tools/libxc/xenctrl.h | 51 ++ > tools/libxc/xenguest.h | 12 + > tools/libxc/xg_save_restore.h | 1 + > tools/libxl/libxl.h | 8 + > tools/libxl/libxl_create.c | 3 + > tools/libxl/libxl_dom.c | 1 + > tools/libxl/libxl_types.idl | 1 + > tools/libxl/xl_cmdimpl.c | 3 + > xen/arch/x86/hvm/hvm.c | 951 +++++++++++++++++++++++++++++++++++--- > xen/arch/x86/hvm/io.c | 2 +- > xen/include/asm-x86/hvm/domain.h | 23 +- > xen/include/asm-x86/hvm/hvm.h | 1 + > xen/include/public/hvm/hvm_op.h | 70 +++ > xen/include/public/hvm/ioreq.h | 1 + > xen/include/public/hvm/params.h | 4 +- > 20 files changed, 1300 insertions(+), 70 deletions(-) > > diff --git a/docs/man/xl.cfg.pod.5 b/docs/man/xl.cfg.pod.5 > index e15a49f..0226c55 100644 > --- a/docs/man/xl.cfg.pod.5 > +++ b/docs/man/xl.cfg.pod.5 > @@ -1281,6 +1281,13 @@ specified, enabling the use of XenServer PV drivers in the guest. > This parameter only takes effect when device_model_version=qemu-xen. > See F for more information. > > +=item B > + > +If a number of secondary device emulators (i.e. in addition to > +qemu-xen or qemu-xen-traditional) are to be invoked to support the > +guest then this parameter can be set with the count of how many are > +to be used. The default value is zero. > + > =back > > =head2 Device-Model Options > diff --git a/tools/libxc/xc_domain.c b/tools/libxc/xc_domain.c > index 369c3f3..dfa905b 100644 > --- a/tools/libxc/xc_domain.c > +++ b/tools/libxc/xc_domain.c > @@ -1284,6 +1284,181 @@ int xc_get_hvm_param(xc_interface *handle, domid_t dom, int param, unsigned long > return rc; > } > > +int xc_hvm_create_ioreq_server(xc_interface *xch, > + domid_t domid, > + ioservid_t *id) > +{ > + DECLARE_HYPERCALL; > + DECLARE_HYPERCALL_BUFFER(xen_hvm_create_ioreq_server_t, arg); > + int rc; > + > + arg = xc_hypercall_buffer_alloc(xch, arg, sizeof(*arg)); > + if ( arg == NULL ) > + return -1; > + > + hypercall.op = __HYPERVISOR_hvm_op; > + hypercall.arg[0] = HVMOP_create_ioreq_server; > + hypercall.arg[1] = HYPERCALL_BUFFER_AS_ARG(arg); > + arg->domid = domid; > + rc = do_xen_hypercall(xch, &hypercall); > + *id = arg->id; > + xc_hypercall_buffer_free(xch, arg); > + return rc; > +} > + > +int xc_hvm_get_ioreq_server_info(xc_interface *xch, > + domid_t domid, > + ioservid_t id, > + xen_pfn_t *pfn, > + xen_pfn_t *buf_pfn, > + evtchn_port_t *buf_port) > +{ > + DECLARE_HYPERCALL; > + DECLARE_HYPERCALL_BUFFER(xen_hvm_get_ioreq_server_info_t, arg); > + int rc; > + > + arg = xc_hypercall_buffer_alloc(xch, arg, sizeof(*arg)); > + if ( arg == NULL ) > + return -1; > + > + hypercall.op = __HYPERVISOR_hvm_op; > + hypercall.arg[0] = HVMOP_get_ioreq_server_info; > + hypercall.arg[1] = HYPERCALL_BUFFER_AS_ARG(arg); > + arg->domid = domid; > + arg->id = id; > + rc = do_xen_hypercall(xch, &hypercall); > + if ( rc != 0 ) > + goto done; > + > + if ( pfn ) > + *pfn = arg->pfn; > + > + if ( buf_pfn ) > + *buf_pfn = arg->buf_pfn; > + > + if ( buf_port ) > + *buf_port = arg->buf_port; > + > +done: > + xc_hypercall_buffer_free(xch, arg); > + return rc; > +} > + > +int xc_hvm_map_io_range_to_ioreq_server(xc_interface *xch, domid_t domid, > + ioservid_t id, int is_mmio, > + uint64_t start, uint64_t end) > +{ > + DECLARE_HYPERCALL; > + DECLARE_HYPERCALL_BUFFER(xen_hvm_map_io_range_to_ioreq_server_t, arg); > + int rc; > + > + arg = xc_hypercall_buffer_alloc(xch, arg, sizeof(*arg)); > + if ( arg == NULL ) > + return -1; > + > + hypercall.op = __HYPERVISOR_hvm_op; > + hypercall.arg[0] = HVMOP_map_io_range_to_ioreq_server; > + hypercall.arg[1] = HYPERCALL_BUFFER_AS_ARG(arg); > + arg->domid = domid; > + arg->id = id; > + arg->is_mmio = is_mmio; > + arg->start = start; > + arg->end = end; > + rc = do_xen_hypercall(xch, &hypercall); > + xc_hypercall_buffer_free(xch, arg); > + return rc; > +} > + > +int xc_hvm_unmap_io_range_from_ioreq_server(xc_interface *xch, domid_t domid, > + ioservid_t id, int is_mmio, > + uint64_t start) > +{ > + DECLARE_HYPERCALL; > + DECLARE_HYPERCALL_BUFFER(xen_hvm_unmap_io_range_from_ioreq_server_t, arg); > + int rc; > + > + arg = xc_hypercall_buffer_alloc(xch, arg, sizeof(*arg)); > + if ( arg == NULL ) > + return -1; > + > + hypercall.op = __HYPERVISOR_hvm_op; > + hypercall.arg[0] = HVMOP_unmap_io_range_from_ioreq_server; > + hypercall.arg[1] = HYPERCALL_BUFFER_AS_ARG(arg); > + arg->domid = domid; > + arg->id = id; > + arg->is_mmio = is_mmio; > + arg->start = start; > + rc = do_xen_hypercall(xch, &hypercall); > + xc_hypercall_buffer_free(xch, arg); > + return rc; > +} > + > +int xc_hvm_map_pcidev_to_ioreq_server(xc_interface *xch, domid_t domid, > + ioservid_t id, uint16_t bdf) > +{ > + DECLARE_HYPERCALL; > + DECLARE_HYPERCALL_BUFFER(xen_hvm_map_pcidev_to_ioreq_server_t, arg); > + int rc; > + > + arg = xc_hypercall_buffer_alloc(xch, arg, sizeof(*arg)); > + if ( arg == NULL ) > + return -1; > + > + hypercall.op = __HYPERVISOR_hvm_op; > + hypercall.arg[0] = HVMOP_map_pcidev_to_ioreq_server; > + hypercall.arg[1] = HYPERCALL_BUFFER_AS_ARG(arg); > + arg->domid = domid; > + arg->id = id; > + arg->bdf = bdf; > + rc = do_xen_hypercall(xch, &hypercall); > + xc_hypercall_buffer_free(xch, arg); > + return rc; > +} > + > +int xc_hvm_unmap_pcidev_from_ioreq_server(xc_interface *xch, domid_t domid, > + ioservid_t id, uint16_t bdf) > +{ > + DECLARE_HYPERCALL; > + DECLARE_HYPERCALL_BUFFER(xen_hvm_unmap_pcidev_from_ioreq_server_t, arg); > + int rc; > + > + arg = xc_hypercall_buffer_alloc(xch, arg, sizeof(*arg)); > + if ( arg == NULL ) > + return -1; > + > + hypercall.op = __HYPERVISOR_hvm_op; > + hypercall.arg[0] = HVMOP_unmap_pcidev_from_ioreq_server; > + hypercall.arg[1] = HYPERCALL_BUFFER_AS_ARG(arg); > + arg->domid = domid; > + arg->id = id; > + arg->bdf = bdf; > + rc = do_xen_hypercall(xch, &hypercall); > + xc_hypercall_buffer_free(xch, arg); > + return rc; > +} > + > +int xc_hvm_destroy_ioreq_server(xc_interface *xch, > + domid_t domid, > + ioservid_t id) > +{ > + DECLARE_HYPERCALL; > + DECLARE_HYPERCALL_BUFFER(xen_hvm_destroy_ioreq_server_t, arg); > + int rc; > + > + arg = xc_hypercall_buffer_alloc(xch, arg, sizeof(*arg)); > + if ( arg == NULL ) > + return -1; > + > + hypercall.op = __HYPERVISOR_hvm_op; > + hypercall.arg[0] = HVMOP_destroy_ioreq_server; > + hypercall.arg[1] = HYPERCALL_BUFFER_AS_ARG(arg); > + arg->domid = domid; > + arg->id = id; > + rc = do_xen_hypercall(xch, &hypercall); > + xc_hypercall_buffer_free(xch, arg); > + return rc; > +} > + > int xc_domain_setdebugging(xc_interface *xch, > uint32_t domid, > unsigned int enable) > diff --git a/tools/libxc/xc_domain_restore.c b/tools/libxc/xc_domain_restore.c > index 1f6ce50..3116653 100644 > --- a/tools/libxc/xc_domain_restore.c > +++ b/tools/libxc/xc_domain_restore.c > @@ -746,6 +746,7 @@ typedef struct { > uint64_t acpi_ioport_location; > uint64_t viridian; > uint64_t vm_generationid_addr; > + uint64_t nr_ioreq_servers; > > struct toolstack_data_t tdata; > } pagebuf_t; > @@ -996,6 +997,16 @@ static int pagebuf_get_one(xc_interface *xch, struct restore_ctx *ctx, > DPRINTF("read generation id buffer address"); > return pagebuf_get_one(xch, ctx, buf, fd, dom); > > + case XC_SAVE_ID_HVM_NR_IOREQ_SERVERS: > + /* Skip padding 4 bytes then read the acpi ioport location. */ > + if ( RDEXACT(fd, &buf->nr_ioreq_servers, sizeof(uint32_t)) || > + RDEXACT(fd, &buf->nr_ioreq_servers, sizeof(uint64_t)) ) > + { > + PERROR("error reading the number of IOREQ servers"); > + return -1; > + } > + return pagebuf_get_one(xch, ctx, buf, fd, dom); > + > default: > if ( (count > MAX_BATCH_SIZE) || (count < 0) ) { > ERROR("Max batch size exceeded (%d). Giving up.", count); > @@ -1755,6 +1766,15 @@ int xc_domain_restore(xc_interface *xch, int io_fd, uint32_t dom, > if (pagebuf.viridian != 0) > xc_set_hvm_param(xch, dom, HVM_PARAM_VIRIDIAN, 1); > > + if ( hvm ) { > + int nr_ioreq_servers = pagebuf.nr_ioreq_servers; > + > + if ( nr_ioreq_servers == 0 ) > + nr_ioreq_servers = 1; > + > + xc_set_hvm_param(xch, dom, HVM_PARAM_NR_IOREQ_SERVERS, nr_ioreq_servers); > + } > + > if (pagebuf.acpi_ioport_location == 1) { > DBGPRINTF("Use new firmware ioport from the checkpoint\n"); > xc_set_hvm_param(xch, dom, HVM_PARAM_ACPI_IOPORTS_LOCATION, 1); > diff --git a/tools/libxc/xc_domain_save.c b/tools/libxc/xc_domain_save.c > index 42c4752..3293e29 100644 > --- a/tools/libxc/xc_domain_save.c > +++ b/tools/libxc/xc_domain_save.c > @@ -1731,6 +1731,18 @@ int xc_domain_save(xc_interface *xch, int io_fd, uint32_t dom, uint32_t max_iter > PERROR("Error when writing the viridian flag"); > goto out; > } > + > + chunk.id = XC_SAVE_ID_HVM_NR_IOREQ_SERVERS; > + chunk.data = 0; > + xc_get_hvm_param(xch, dom, HVM_PARAM_NR_IOREQ_SERVERS, > + (unsigned long *)&chunk.data); > + > + if ( (chunk.data != 0) && > + wrexact(io_fd, &chunk, sizeof(chunk)) ) > + { > + PERROR("Error when writing the number of IOREQ servers"); > + goto out; > + } > } > > if ( callbacks != NULL && callbacks->toolstack_save != NULL ) > diff --git a/tools/libxc/xc_hvm_build_x86.c b/tools/libxc/xc_hvm_build_x86.c > index b65e702..6d6328a 100644 > --- a/tools/libxc/xc_hvm_build_x86.c > +++ b/tools/libxc/xc_hvm_build_x86.c > @@ -45,7 +45,7 @@ > #define SPECIALPAGE_IDENT_PT 4 > #define SPECIALPAGE_CONSOLE 5 > #define SPECIALPAGE_IOREQ 6 > -#define NR_SPECIAL_PAGES SPECIALPAGE_IOREQ + 2 /* ioreq server needs 2 pages */ > +#define NR_SPECIAL_PAGES(n) SPECIALPAGE_IOREQ + (2 * n) /* ioreq server needs 2 pages */ > #define special_pfn(x) (0xff000u - 1 - (x)) > > #define VGA_HOLE_SIZE (0x20) > @@ -85,7 +85,8 @@ static int modules_init(struct xc_hvm_build_args *args, > } > > static void build_hvm_info(void *hvm_info_page, uint64_t mem_size, > - uint64_t mmio_start, uint64_t mmio_size) > + uint64_t mmio_start, uint64_t mmio_size, > + int max_emulators) > { > struct hvm_info_table *hvm_info = (struct hvm_info_table *) > (((unsigned char *)hvm_info_page) + HVM_INFO_OFFSET); > @@ -113,7 +114,7 @@ static void build_hvm_info(void *hvm_info_page, uint64_t mem_size, > /* Memory parameters. */ > hvm_info->low_mem_pgend = lowmem_end >> PAGE_SHIFT; > hvm_info->high_mem_pgend = highmem_end >> PAGE_SHIFT; > - hvm_info->reserved_mem_pgstart = special_pfn(0) - NR_SPECIAL_PAGES; > + hvm_info->reserved_mem_pgstart = special_pfn(0) - NR_SPECIAL_PAGES(max_emulators); > > /* Finish with the checksum. */ > for ( i = 0, sum = 0; i < hvm_info->length; i++ ) > @@ -256,6 +257,10 @@ static int setup_guest(xc_interface *xch, > stat_1gb_pages = 0; > int pod_mode = 0; > int claim_enabled = args->claim_enabled; > + int max_emulators = args->max_emulators; > + > + if ( max_emulators < 1 ) > + goto error_out; > > if ( nr_pages > target_pages ) > pod_mode = XENMEMF_populate_on_demand; > @@ -468,12 +473,13 @@ static int setup_guest(xc_interface *xch, > xch, dom, PAGE_SIZE, PROT_READ | PROT_WRITE, > HVM_INFO_PFN)) == NULL ) > goto error_out; > - build_hvm_info(hvm_info_page, v_end, mmio_start, mmio_size); > + build_hvm_info(hvm_info_page, v_end, mmio_start, mmio_size, > + max_emulators); > munmap(hvm_info_page, PAGE_SIZE); > > /* Allocate and clear special pages. */ > > - DPRINTF("%d SPECIAL PAGES:\n", NR_SPECIAL_PAGES); > + DPRINTF("%d SPECIAL PAGES:\n", NR_SPECIAL_PAGES(max_emulators)); > DPRINTF(" PAGING: %"PRI_xen_pfn"\n", > (xen_pfn_t)special_pfn(SPECIALPAGE_PAGING)); > DPRINTF(" ACCESS: %"PRI_xen_pfn"\n", > @@ -486,10 +492,10 @@ static int setup_guest(xc_interface *xch, > (xen_pfn_t)special_pfn(SPECIALPAGE_IDENT_PT)); > DPRINTF(" CONSOLE: %"PRI_xen_pfn"\n", > (xen_pfn_t)special_pfn(SPECIALPAGE_CONSOLE)); > - DPRINTF(" IOREQ: %"PRI_xen_pfn"\n", > + DPRINTF(" IOREQ(%02d): %"PRI_xen_pfn"\n", max_emulators * 2, > (xen_pfn_t)special_pfn(SPECIALPAGE_IOREQ)); > > - for ( i = 0; i < NR_SPECIAL_PAGES; i++ ) > + for ( i = 0; i < NR_SPECIAL_PAGES(max_emulators); i++ ) > { > xen_pfn_t pfn = special_pfn(i); > rc = xc_domain_populate_physmap_exact(xch, dom, 1, 0, 0, &pfn); > @@ -515,7 +521,9 @@ static int setup_guest(xc_interface *xch, > xc_set_hvm_param(xch, dom, HVM_PARAM_IOREQ_PFN, > special_pfn(SPECIALPAGE_IOREQ)); > xc_set_hvm_param(xch, dom, HVM_PARAM_BUFIOREQ_PFN, > - special_pfn(SPECIALPAGE_IOREQ) - 1); > + special_pfn(SPECIALPAGE_IOREQ) - max_emulators); > + xc_set_hvm_param(xch, dom, HVM_PARAM_NR_IOREQ_SERVERS, > + max_emulators); > > /* > * Identity-map page table is required for running with CR0.PG=0 when > diff --git a/tools/libxc/xenctrl.h b/tools/libxc/xenctrl.h > index 13f816b..84cab13 100644 > --- a/tools/libxc/xenctrl.h > +++ b/tools/libxc/xenctrl.h > @@ -1801,6 +1801,47 @@ void xc_clear_last_error(xc_interface *xch); > int xc_set_hvm_param(xc_interface *handle, domid_t dom, int param, unsigned long value); > int xc_get_hvm_param(xc_interface *handle, domid_t dom, int param, unsigned long *value); > > +/* > + * IOREQ server API > + */ > +int xc_hvm_create_ioreq_server(xc_interface *xch, > + domid_t domid, > + ioservid_t *id); > + > +int xc_hvm_get_ioreq_server_info(xc_interface *xch, > + domid_t domid, > + ioservid_t id, > + xen_pfn_t *pfn, > + xen_pfn_t *buf_pfn, > + evtchn_port_t *buf_port); > + > +int xc_hvm_map_io_range_to_ioreq_server(xc_interface *xch, > + domid_t domid, > + ioservid_t id, > + int is_mmio, > + uint64_t start, > + uint64_t end); > + > +int xc_hvm_unmap_io_range_from_ioreq_server(xc_interface *xch, > + domid_t domid, > + ioservid_t id, > + int is_mmio, > + uint64_t start); > + > +int xc_hvm_map_pcidev_to_ioreq_server(xc_interface *xch, > + domid_t domid, > + ioservid_t id, > + uint16_t bdf); > + > +int xc_hvm_unmap_pcidev_from_ioreq_server(xc_interface *xch, > + domid_t domid, > + ioservid_t id, > + uint16_t bdf); > + > +int xc_hvm_destroy_ioreq_server(xc_interface *xch, > + domid_t domid, > + ioservid_t id); > + > /* HVM guest pass-through */ > int xc_assign_device(xc_interface *xch, > uint32_t domid, > @@ -2428,3 +2469,13 @@ int xc_kexec_load(xc_interface *xch, uint8_t type, uint16_t arch, > int xc_kexec_unload(xc_interface *xch, int type); > > #endif /* XENCTRL_H */ > + > +/* > + * Local variables: > + * mode: C > + * c-file-style: "BSD" > + * c-basic-offset: 4 > + * tab-width: 4 > + * indent-tabs-mode: nil > + * End: > + */ > diff --git a/tools/libxc/xenguest.h b/tools/libxc/xenguest.h > index a0e30e1..1300933 100644 > --- a/tools/libxc/xenguest.h > +++ b/tools/libxc/xenguest.h > @@ -234,6 +234,8 @@ struct xc_hvm_build_args { > struct xc_hvm_firmware_module smbios_module; > /* Whether to use claim hypercall (1 - enable, 0 - disable). */ > int claim_enabled; > + /* Maximum number of emulators for VM */ > + int max_emulators; > }; > > /** > @@ -306,3 +308,13 @@ xen_pfn_t *xc_map_m2p(xc_interface *xch, > int prot, > unsigned long *mfn0); > #endif /* XENGUEST_H */ > + > +/* > + * Local variables: > + * mode: C > + * c-file-style: "BSD" > + * c-basic-offset: 4 > + * tab-width: 4 > + * indent-tabs-mode: nil > + * End: > + */ > diff --git a/tools/libxc/xg_save_restore.h b/tools/libxc/xg_save_restore.h > index f859621..5170b7f 100644 > --- a/tools/libxc/xg_save_restore.h > +++ b/tools/libxc/xg_save_restore.h > @@ -259,6 +259,7 @@ > #define XC_SAVE_ID_HVM_ACCESS_RING_PFN -16 > #define XC_SAVE_ID_HVM_SHARING_RING_PFN -17 > #define XC_SAVE_ID_TOOLSTACK -18 /* Optional toolstack specific info */ > +#define XC_SAVE_ID_HVM_NR_IOREQ_SERVERS -19 > > /* > ** We process save/restore/migrate in batches of pages; the below > diff --git a/tools/libxl/libxl.h b/tools/libxl/libxl.h > index 06bbca6..5a70b76 100644 > --- a/tools/libxl/libxl.h > +++ b/tools/libxl/libxl.h > @@ -95,6 +95,14 @@ > #define LIBXL_HAVE_BUILDINFO_EVENT_CHANNELS 1 > > /* > + * LIBXL_HAVE_BUILDINFO_HVM_MAX_EMULATORS indicates that the > + * max_emulators field is present in the hvm sections of > + * libxl_domain_build_info. This field can be used to reserve > + * extra special pages for secondary device emulators. > + */ > +#define LIBXL_HAVE_BUILDINFO_HVM_MAX_EMULATORS 1 > + > +/* > * libxl ABI compatibility > * > * The only guarantee which libxl makes regarding ABI compatibility > diff --git a/tools/libxl/libxl_create.c b/tools/libxl/libxl_create.c > index a604cd8..cce93d9 100644 > --- a/tools/libxl/libxl_create.c > +++ b/tools/libxl/libxl_create.c > @@ -330,6 +330,9 @@ int libxl__domain_build_info_setdefault(libxl__gc *gc, > > libxl_defbool_setdefault(&b_info->u.hvm.gfx_passthru, false); > > + if (b_info->u.hvm.max_emulators < 1) > + b_info->u.hvm.max_emulators = 1; > + > break; > case LIBXL_DOMAIN_TYPE_PV: > libxl_defbool_setdefault(&b_info->u.pv.e820_host, false); > diff --git a/tools/libxl/libxl_dom.c b/tools/libxl/libxl_dom.c > index 55f74b2..9de06f9 100644 > --- a/tools/libxl/libxl_dom.c > +++ b/tools/libxl/libxl_dom.c > @@ -637,6 +637,7 @@ int libxl__build_hvm(libxl__gc *gc, uint32_t domid, > args.mem_size = (uint64_t)(info->max_memkb - info->video_memkb) << 10; > args.mem_target = (uint64_t)(info->target_memkb - info->video_memkb) << 10; > args.claim_enabled = libxl_defbool_val(info->claim_mode); > + args.max_emulators = info->u.hvm.max_emulators; > if (libxl__domain_firmware(gc, info, &args)) { > LOG(ERROR, "initializing domain firmware failed"); > goto out; > diff --git a/tools/libxl/libxl_types.idl b/tools/libxl/libxl_types.idl > index 649ce50..b707159 100644 > --- a/tools/libxl/libxl_types.idl > +++ b/tools/libxl/libxl_types.idl > @@ -372,6 +372,7 @@ libxl_domain_build_info = Struct("domain_build_info",[ > ("xen_platform_pci", libxl_defbool), > ("usbdevice_list", libxl_string_list), > ("vendor_device", libxl_vendor_device), > + ("max_emulators", integer), > ])), > ("pv", Struct(None, [("kernel", string), > ("slack_memkb", MemKB), > diff --git a/tools/libxl/xl_cmdimpl.c b/tools/libxl/xl_cmdimpl.c > index 4fc46eb..cf9b67d 100644 > --- a/tools/libxl/xl_cmdimpl.c > +++ b/tools/libxl/xl_cmdimpl.c > @@ -1750,6 +1750,9 @@ skip_vfb: > > b_info->u.hvm.vendor_device = d; > } > + > + if (!xlu_cfg_get_long (config, "secondary_device_emulators", &l, 0)) > + b_info->u.hvm.max_emulators = l + 1; > } > > xlu_cfg_destroy(config); > diff --git a/xen/arch/x86/hvm/hvm.c b/xen/arch/x86/hvm/hvm.c > index fb2dd73..e8b73fa 100644 > --- a/xen/arch/x86/hvm/hvm.c > +++ b/xen/arch/x86/hvm/hvm.c > @@ -357,14 +357,21 @@ static ioreq_t *get_ioreq(struct hvm_ioreq_server *s, int id) > bool_t hvm_io_pending(struct vcpu *v) > { > struct domain *d = v->domain; > - struct hvm_ioreq_server *s = d->arch.hvm_domain.ioreq_server; > - ioreq_t *p; > + struct list_head *entry; > > - if ( !s ) > - return 0; > + list_for_each ( entry, &d->arch.hvm_domain.ioreq_server_list ) > + { > + struct hvm_ioreq_server *s = list_entry(entry, > + struct hvm_ioreq_server, > + list_entry); > + ioreq_t *p = get_ioreq(s, v->vcpu_id); > > - p = get_ioreq(s, v->vcpu_id); > - return ( p->state != STATE_IOREQ_NONE ); > + p = get_ioreq(s, v->vcpu_id); > + if ( p->state != STATE_IOREQ_NONE ) > + return 1; > + } > + > + return 0; > } > > static void hvm_wait_on_io(struct domain *d, ioreq_t *p) > @@ -394,18 +401,20 @@ static void hvm_wait_on_io(struct domain *d, ioreq_t *p) > void hvm_do_resume(struct vcpu *v) > { > struct domain *d = v->domain; > - struct hvm_ioreq_server *s = d->arch.hvm_domain.ioreq_server; > + struct list_head *entry; > > check_wakeup_from_wait(); > > if ( is_hvm_vcpu(v) ) > pt_restore_timer(v); > > - if ( s ) > + list_for_each ( entry, &d->arch.hvm_domain.ioreq_server_list ) > { > - ioreq_t *p = get_ioreq(s, v->vcpu_id); > + struct hvm_ioreq_server *s = list_entry(entry, > + struct hvm_ioreq_server, > + list_entry); > > - hvm_wait_on_io(d, p); > + hvm_wait_on_io(d, get_ioreq(s, v->vcpu_id)); > } > > /* Inject pending hw/sw trap */ > @@ -543,6 +552,83 @@ static int hvm_print_line( > return X86EMUL_OKAY; > } > > +static int hvm_access_cf8( > + int dir, uint32_t port, uint32_t bytes, uint32_t *val) > +{ > + struct vcpu *curr = current; > + struct hvm_domain *hd = &curr->domain->arch.hvm_domain; > + int rc; > + > + BUG_ON(port < 0xcf8); > + port -= 0xcf8; > + > + spin_lock(&hd->pci_lock); > + > + if ( dir == IOREQ_WRITE ) > + { > + switch ( bytes ) > + { > + case 4: > + hd->pci_cf8 = *val; > + break; > + > + case 2: > + { > + uint32_t mask = 0xffff << (port * 8); > + uint32_t subval = *val << (port * 8); > + > + hd->pci_cf8 = (hd->pci_cf8 & ~mask) | > + (subval & mask); > + break; > + } > + > + case 1: > + { > + uint32_t mask = 0xff << (port * 8); > + uint32_t subval = *val << (port * 8); > + > + hd->pci_cf8 = (hd->pci_cf8 & ~mask) | > + (subval & mask); > + break; > + } > + > + default: > + break; > + } > + > + /* We always need to fall through to the catch all emulator */ > + rc = X86EMUL_UNHANDLEABLE; > + } > + else > + { > + switch ( bytes ) > + { > + case 4: > + *val = hd->pci_cf8; > + rc = X86EMUL_OKAY; > + break; > + > + case 2: > + *val = (hd->pci_cf8 >> (port * 8)) & 0xffff; > + rc = X86EMUL_OKAY; > + break; > + > + case 1: > + *val = (hd->pci_cf8 >> (port * 8)) & 0xff; > + rc = X86EMUL_OKAY; > + break; > + > + default: > + rc = X86EMUL_UNHANDLEABLE; > + break; > + } > + } > + > + spin_unlock(&hd->pci_lock); > + > + return rc; > +} > + > static int handle_pvh_io( > int dir, uint32_t port, uint32_t bytes, uint32_t *val) > { > @@ -618,39 +704,53 @@ static void hvm_ioreq_server_remove_vcpu(struct hvm_ioreq_server *s, struct vcpu > } > } > > -static int hvm_create_ioreq_server(struct domain *d, domid_t domid) > +static int hvm_create_ioreq_server(struct domain *d, ioservid_t id, domid_t domid) > { > struct hvm_ioreq_server *s; > unsigned long pfn; > struct vcpu *v; > int i, rc; > > + if ( id >= d->arch.hvm_domain.params[HVM_PARAM_NR_IOREQ_SERVERS] ) > + return -EINVAL; > + > + spin_lock(&d->arch.hvm_domain.ioreq_server_lock); > + > rc = -EEXIST; > - if ( d->arch.hvm_domain.ioreq_server != NULL ) > - goto fail_exist; > + list_for_each_entry ( s, > + &d->arch.hvm_domain.ioreq_server_list, > + list_entry ) > + { > + if ( s->id == id ) > + goto fail_exist; > + } > > - gdprintk(XENLOG_INFO, "%s: %d\n", __func__, d->domain_id); > + gdprintk(XENLOG_INFO, "%s: %d:%d\n", __func__, d->domain_id, id); > > rc = -ENOMEM; > s = xzalloc(struct hvm_ioreq_server); > if ( !s ) > goto fail_alloc; > > + s->id = id; > s->domain = d; > s->domid = domid; > + INIT_LIST_HEAD(&s->mmio_range_list); > + INIT_LIST_HEAD(&s->portio_range_list); > + INIT_LIST_HEAD(&s->pcidev_list); > > for ( i = 0; i < MAX_HVM_VCPUS; i++ ) > s->ioreq_evtchn[i] = -1; > s->buf_ioreq_evtchn = -1; > > /* Initialize shared pages */ > - pfn = d->arch.hvm_domain.params[HVM_PARAM_IOREQ_PFN]; > + pfn = d->arch.hvm_domain.params[HVM_PARAM_IOREQ_PFN] - s->id; > > hvm_init_ioreq_page(s, 0); > if ( (rc = hvm_set_ioreq_page(s, 0, pfn)) < 0 ) > goto fail_set_ioreq; > > - pfn = d->arch.hvm_domain.params[HVM_PARAM_BUFIOREQ_PFN]; > + pfn = d->arch.hvm_domain.params[HVM_PARAM_BUFIOREQ_PFN] - s->id; > > hvm_init_ioreq_page(s, 1); > if ( (rc = hvm_set_ioreq_page(s, 1, pfn)) < 0 ) > @@ -664,10 +764,12 @@ static int hvm_create_ioreq_server(struct domain *d, domid_t domid) > goto fail_add_vcpu; > } > > - d->arch.hvm_domain.ioreq_server = s; > + list_add(&s->list_entry, > + &d->arch.hvm_domain.ioreq_server_list); > > domain_unpause(d); > > + spin_unlock(&d->arch.hvm_domain.ioreq_server_lock); > return 0; > > fail_add_vcpu: > @@ -681,23 +783,33 @@ fail_set_ioreq: > xfree(s); > fail_alloc: > fail_exist: > + spin_unlock(&d->arch.hvm_domain.ioreq_server_lock); > return rc; > } > > -static void hvm_destroy_ioreq_server(struct domain *d) > +static void hvm_destroy_ioreq_server(struct domain *d, ioservid_t id) > { > struct hvm_ioreq_server *s; > struct vcpu *v; > > - gdprintk(XENLOG_INFO, "%s: %d\n", __func__, d->domain_id); > + spin_lock(&d->arch.hvm_domain.ioreq_server_lock); > > - s = d->arch.hvm_domain.ioreq_server; > - if ( !s ) > - return; > + list_for_each_entry ( s, > + &d->arch.hvm_domain.ioreq_server_list, > + list_entry) > + { > + if ( s->id == id ) > + goto found; > + } > + > + goto done; > + > +found: > + gdprintk(XENLOG_INFO, "%s: %d:%d\n", __func__, d->domain_id, id); > > domain_pause(d); > > - d->arch.hvm_domain.ioreq_server = NULL; > + list_del_init(&s->list_entry); > > for_each_vcpu ( d, v ) > hvm_ioreq_server_remove_vcpu(s, v); > @@ -708,31 +820,373 @@ static void hvm_destroy_ioreq_server(struct domain *d) > hvm_destroy_ioreq_page(s, 0); > > xfree(s); > + > +done: > + spin_unlock(&d->arch.hvm_domain.ioreq_server_lock); > } > > -static int hvm_get_ioreq_server_buf_port(struct domain *d, evtchn_port_t *port) > +static int hvm_get_ioreq_server_buf_port(struct domain *d, ioservid_t id, > + evtchn_port_t *port) > { > - struct hvm_ioreq_server *s = d->arch.hvm_domain.ioreq_server; > + struct list_head *entry; > + int rc; > > - if ( !s ) > - return -ENOENT; > + if ( id >= d->arch.hvm_domain.params[HVM_PARAM_NR_IOREQ_SERVERS] ) > + return -EINVAL; > + > + spin_lock(&d->arch.hvm_domain.ioreq_server_lock); > + > + rc = -ENOENT; > + list_for_each ( entry, > + &d->arch.hvm_domain.ioreq_server_list ) > + { > + struct hvm_ioreq_server *s = list_entry(entry, > + struct hvm_ioreq_server, > + list_entry); > + > + if ( s->id == id ) > + { > + *port = s->buf_ioreq_evtchn; > + rc = 0; > + break; > + } > + } > + > + spin_unlock(&d->arch.hvm_domain.ioreq_server_lock); > + > + return rc; > +} > + > +static int hvm_get_ioreq_server_pfn(struct domain *d, ioservid_t id, int buf, > + xen_pfn_t *pfn) > +{ > + struct list_head *entry; > + int rc; > + > + if ( id >= d->arch.hvm_domain.params[HVM_PARAM_NR_IOREQ_SERVERS] ) > + return -EINVAL; > + > + spin_lock(&d->arch.hvm_domain.ioreq_server_lock); > + > + rc = -ENOENT; > + list_for_each ( entry, > + &d->arch.hvm_domain.ioreq_server_list ) > + { > + struct hvm_ioreq_server *s = list_entry(entry, > + struct hvm_ioreq_server, > + list_entry); > + > + if ( s->id == id ) > + { > + int i = ( buf ) ? HVM_PARAM_BUFIOREQ_PFN : HVM_PARAM_IOREQ_PFN; > + > + *pfn = d->arch.hvm_domain.params[i] - s->id; > + rc = 0; > + break; > + } > + } > + > + spin_unlock(&d->arch.hvm_domain.ioreq_server_lock); > + > + return rc; > +} > + > +static int hvm_map_io_range_to_ioreq_server(struct domain *d, ioservid_t id, > + int is_mmio, uint64_t start, uint64_t end) > +{ > + struct hvm_ioreq_server *s; > + struct hvm_io_range *x; > + struct list_head *list; > + int rc; > + > + if ( id >= d->arch.hvm_domain.params[HVM_PARAM_NR_IOREQ_SERVERS] ) > + return -EINVAL; > + > + x = xmalloc(struct hvm_io_range); > + if ( x == NULL ) > + return -ENOMEM; > + > + spin_lock(&d->arch.hvm_domain.ioreq_server_lock); > + > + rc = -ENOENT; > + list_for_each_entry ( s, > + &d->arch.hvm_domain.ioreq_server_list, > + list_entry ) > + { > + if ( s->id == id ) > + goto found; > + } > + > + goto fail; > + > +found: > + INIT_RCU_HEAD(&x->rcu); > + x->start = start; > + x->end = end; > + > + list = ( is_mmio ) ? &s->mmio_range_list : &s->portio_range_list; > + list_add_rcu(&x->list_entry, list); > + > + gdprintk(XENLOG_DEBUG, "%d:%d: +%s %"PRIX64" - %"PRIX64"\n", > + d->domain_id, > + s->id, > + ( is_mmio ) ? "MMIO" : "PORTIO", > + x->start, > + x->end); > + > + spin_unlock(&d->arch.hvm_domain.ioreq_server_lock); > > - *port = s->buf_ioreq_evtchn; > return 0; > + > +fail: > + xfree(x); > + > + spin_unlock(&d->arch.hvm_domain.ioreq_server_lock); > + > + return rc; > } > > -static int hvm_get_ioreq_server_pfn(struct domain *d, int buf, xen_pfn_t *pfn) > +static void free_io_range(struct rcu_head *rcu) > { > - struct hvm_ioreq_server *s = d->arch.hvm_domain.ioreq_server; > - int i; > + struct hvm_io_range *x; > > - if ( !s ) > - return -ENOENT; > + x = container_of (rcu, struct hvm_io_range, rcu); > + > + xfree(x); > +} > + > +static int hvm_unmap_io_range_from_ioreq_server(struct domain *d, ioservid_t id, > + int is_mmio, uint64_t start) > +{ > + struct hvm_ioreq_server *s; > + struct list_head *list, *entry; > + int rc; > + > + if ( id >= d->arch.hvm_domain.params[HVM_PARAM_NR_IOREQ_SERVERS] ) > + return -EINVAL; > + > + spin_lock(&d->arch.hvm_domain.ioreq_server_lock); > + > + rc = -ENOENT; > + list_for_each_entry ( s, > + &d->arch.hvm_domain.ioreq_server_list, > + list_entry ) > + { > + if ( s->id == id ) > + goto found; > + } > + > + goto done; > + > +found: > + list = ( is_mmio ) ? &s->mmio_range_list : &s->portio_range_list; > + > + list_for_each ( entry, > + list ) > + { > + struct hvm_io_range *x = list_entry(entry, > + struct hvm_io_range, > + list_entry); > + > + if ( start == x->start ) > + { > + gdprintk(XENLOG_DEBUG, "%d:%d: -%s %"PRIX64" - %"PRIX64"\n", > + d->domain_id, > + s->id, > + ( is_mmio ) ? "MMIO" : "PORTIO", > + x->start, > + x->end); > + > + list_del_rcu(&x->list_entry); > + call_rcu(&x->rcu, free_io_range); > > - i = ( buf ) ? HVM_PARAM_BUFIOREQ_PFN : HVM_PARAM_IOREQ_PFN; > - *pfn = d->arch.hvm_domain.params[i]; > + rc = 0; > + break; > + } > + } > + > +done: > + spin_unlock(&d->arch.hvm_domain.ioreq_server_lock); > + > + return rc; > +} > + > +static int hvm_map_pcidev_to_ioreq_server(struct domain *d, ioservid_t id, > + uint16_t bdf) > +{ > + struct hvm_ioreq_server *s; > + struct hvm_pcidev *x; > + int rc; > + > + if ( id >= d->arch.hvm_domain.params[HVM_PARAM_NR_IOREQ_SERVERS] ) > + return -EINVAL; > + > + x = xmalloc(struct hvm_pcidev); > + if ( x == NULL ) > + return -ENOMEM; > + > + spin_lock(&d->arch.hvm_domain.ioreq_server_lock); > + > + rc = -ENOENT; > + list_for_each_entry ( s, > + &d->arch.hvm_domain.ioreq_server_list, > + list_entry ) > + { > + if ( s->id == id ) > + goto found; > + } > + > + goto fail; > + > +found: > + INIT_RCU_HEAD(&x->rcu); > + x->bdf = bdf; > + > + list_add_rcu(&x->list_entry, &s->pcidev_list); > + > + gdprintk(XENLOG_DEBUG, "%d:%d: +PCIDEV %04X\n", > + d->domain_id, > + s->id, > + x->bdf); > + > + spin_unlock(&d->arch.hvm_domain.ioreq_server_lock); > > return 0; > + > +fail: > + xfree(x); > + > + spin_unlock(&d->arch.hvm_domain.ioreq_server_lock); > + > + return rc; > +} > + > +static void free_pcidev(struct rcu_head *rcu) > +{ > + struct hvm_pcidev *x; > + > + x = container_of (rcu, struct hvm_pcidev, rcu); > + > + xfree(x); > +} > + > +static int hvm_unmap_pcidev_from_ioreq_server(struct domain *d, ioservid_t id, > + uint16_t bdf) > +{ > + struct hvm_ioreq_server *s; > + struct list_head *entry; > + int rc; > + > + if ( id >= d->arch.hvm_domain.params[HVM_PARAM_NR_IOREQ_SERVERS] ) > + return -EINVAL; > + > + spin_lock(&d->arch.hvm_domain.ioreq_server_lock); > + > + rc = -ENOENT; > + list_for_each_entry ( s, > + &d->arch.hvm_domain.ioreq_server_list, > + list_entry ) > + { > + if ( s->id == id ) > + goto found; > + } > + > + goto done; > + > +found: > + list_for_each ( entry, > + &s->pcidev_list ) > + { > + struct hvm_pcidev *x = list_entry(entry, > + struct hvm_pcidev, > + list_entry); > + > + if ( bdf == x->bdf ) > + { > + gdprintk(XENLOG_DEBUG, "%d:%d: -PCIDEV %04X\n", > + d->domain_id, > + s->id, > + x->bdf); > + > + list_del_rcu(&x->list_entry); > + call_rcu(&x->rcu, free_pcidev); > + > + rc = 0; > + break; > + } > + } > + > +done: > + spin_unlock(&d->arch.hvm_domain.ioreq_server_lock); > + > + return rc; > +} > + > +static int hvm_all_ioreq_servers_add_vcpu(struct domain *d, struct vcpu *v) > +{ > + struct list_head *entry; > + int rc; > + > + spin_lock(&d->arch.hvm_domain.ioreq_server_lock); > + > + list_for_each ( entry, > + &d->arch.hvm_domain.ioreq_server_list ) > + { > + struct hvm_ioreq_server *s = list_entry(entry, > + struct hvm_ioreq_server, > + list_entry); > + > + if ( (rc = hvm_ioreq_server_add_vcpu(s, v)) < 0 ) > + goto fail; > + } > + > + spin_unlock(&d->arch.hvm_domain.ioreq_server_lock); > + > + return 0; > + > +fail: > + list_for_each ( entry, > + &d->arch.hvm_domain.ioreq_server_list ) > + { > + struct hvm_ioreq_server *s = list_entry(entry, > + struct hvm_ioreq_server, > + list_entry); > + > + hvm_ioreq_server_remove_vcpu(s, v); > + } > + > + spin_unlock(&d->arch.hvm_domain.ioreq_server_lock); > + > + return rc; > +} > + > +static void hvm_all_ioreq_servers_remove_vcpu(struct domain *d, struct vcpu *v) > +{ > + struct list_head *entry; > + > + spin_lock(&d->arch.hvm_domain.ioreq_server_lock); > + > + list_for_each ( entry, > + &d->arch.hvm_domain.ioreq_server_list ) > + { > + struct hvm_ioreq_server *s = list_entry(entry, > + struct hvm_ioreq_server, > + list_entry); > + > + hvm_ioreq_server_remove_vcpu(s, v); > + } > + > + spin_unlock(&d->arch.hvm_domain.ioreq_server_lock); > +} > + > +static void hvm_destroy_all_ioreq_servers(struct domain *d) > +{ > + ioservid_t id; > + > + for ( id = 0; > + id < d->arch.hvm_domain.params[HVM_PARAM_NR_IOREQ_SERVERS]; > + id++ ) > + hvm_destroy_ioreq_server(d, id); > } > > static int hvm_replace_event_channel(struct vcpu *v, domid_t remote_domid, > @@ -750,18 +1204,31 @@ static int hvm_replace_event_channel(struct vcpu *v, domid_t remote_domid, > return 0; > } > > -static int hvm_set_ioreq_server_domid(struct domain *d, domid_t domid) > +static int hvm_set_ioreq_server_domid(struct domain *d, ioservid_t id, domid_t domid) > { > - struct hvm_ioreq_server *s = d->arch.hvm_domain.ioreq_server; > + struct hvm_ioreq_server *s; > struct vcpu *v; > int rc = 0; > > + if ( id >= d->arch.hvm_domain.params[HVM_PARAM_NR_IOREQ_SERVERS] ) > + return -EINVAL; > + > + spin_lock(&d->arch.hvm_domain.ioreq_server_lock); > + > domain_pause(d); > > + list_for_each_entry ( s, > + &d->arch.hvm_domain.ioreq_server_list, > + list_entry ) > + { > + if ( s->id == id ) > + goto found; > + } > + > rc = -ENOENT; > - if ( !s ) > - goto done; > + goto done; > > +found: > rc = 0; > if ( s->domid == domid ) > goto done; > @@ -787,6 +1254,8 @@ static int hvm_set_ioreq_server_domid(struct domain *d, domid_t domid) > done: > domain_unpause(d); > > + spin_unlock(&d->arch.hvm_domain.ioreq_server_lock); > + > return rc; > } > > @@ -817,6 +1286,9 @@ int hvm_domain_initialise(struct domain *d) > > } > > + spin_lock_init(&d->arch.hvm_domain.ioreq_server_lock); > + INIT_LIST_HEAD(&d->arch.hvm_domain.ioreq_server_list); > + spin_lock_init(&d->arch.hvm_domain.pci_lock); > spin_lock_init(&d->arch.hvm_domain.irq_lock); > spin_lock_init(&d->arch.hvm_domain.uc_lock); > > @@ -858,6 +1330,7 @@ int hvm_domain_initialise(struct domain *d) > rtc_init(d); > > register_portio_handler(d, 0xe9, 1, hvm_print_line); > + register_portio_handler(d, 0xcf8, 4, hvm_access_cf8); > > rc = hvm_funcs.domain_initialise(d); > if ( rc != 0 ) > @@ -888,7 +1361,7 @@ void hvm_domain_relinquish_resources(struct domain *d) > if ( hvm_funcs.nhvm_domain_relinquish_resources ) > hvm_funcs.nhvm_domain_relinquish_resources(d); > > - hvm_destroy_ioreq_server(d); > + hvm_destroy_all_ioreq_servers(d); > > msixtbl_pt_cleanup(d); > > @@ -1520,7 +1993,6 @@ int hvm_vcpu_initialise(struct vcpu *v) > { > int rc; > struct domain *d = v->domain; > - struct hvm_ioreq_server *s = d->arch.hvm_domain.ioreq_server; > > hvm_asid_flush_vcpu(v); > > @@ -1563,12 +2035,9 @@ int hvm_vcpu_initialise(struct vcpu *v) > && (rc = nestedhvm_vcpu_initialise(v)) < 0 ) /* teardown: nestedhvm_vcpu_destroy */ > goto fail5; > > - if ( s ) > - { > - rc = hvm_ioreq_server_add_vcpu(s, v); > - if ( rc < 0 ) > - goto fail6; > - } > + rc = hvm_all_ioreq_servers_add_vcpu(d, v); > + if ( rc < 0 ) > + goto fail6; > > if ( v->vcpu_id == 0 ) > { > @@ -1604,10 +2073,8 @@ int hvm_vcpu_initialise(struct vcpu *v) > void hvm_vcpu_destroy(struct vcpu *v) > { > struct domain *d = v->domain; > - struct hvm_ioreq_server *s = d->arch.hvm_domain.ioreq_server; > > - if ( s ) > - hvm_ioreq_server_remove_vcpu(s, v); > + hvm_all_ioreq_servers_remove_vcpu(d, v); > > nestedhvm_vcpu_destroy(v); > > @@ -1646,11 +2113,112 @@ void hvm_vcpu_down(struct vcpu *v) > } > } > > +static DEFINE_RCU_READ_LOCK(ioreq_server_rcu_lock); > + > +static struct hvm_ioreq_server *hvm_select_ioreq_server(struct vcpu *v, ioreq_t *p) > +{ > +#define BDF(cf8) (((cf8) & 0x00ffff00) >> 8) > + > + struct domain *d = v->domain; > + struct hvm_ioreq_server *s; > + uint8_t type; > + uint64_t addr; > + > + if ( p->type == IOREQ_TYPE_PIO && > + (p->addr & ~3) == 0xcfc ) > + { > + /* PCI config data cycle */ > + type = IOREQ_TYPE_PCI_CONFIG; > + > + spin_lock(&d->arch.hvm_domain.pci_lock); > + addr = d->arch.hvm_domain.pci_cf8 + (p->addr & 3); > + spin_unlock(&d->arch.hvm_domain.pci_lock); > + } > + else > + { > + type = p->type; > + addr = p->addr; > + } > + > + rcu_read_lock(&ioreq_server_rcu_lock); > + > + switch ( type ) > + { > + case IOREQ_TYPE_COPY: > + case IOREQ_TYPE_PIO: > + case IOREQ_TYPE_PCI_CONFIG: > + break; > + default: > + goto done; > + } > + > + list_for_each_entry ( s, > + &d->arch.hvm_domain.ioreq_server_list, > + list_entry ) > + { > + switch ( type ) > + { > + case IOREQ_TYPE_COPY: > + case IOREQ_TYPE_PIO: { > + struct list_head *list; > + struct hvm_io_range *x; > + > + list = ( type == IOREQ_TYPE_COPY ) ? > + &s->mmio_range_list : > + &s->portio_range_list; > + > + list_for_each_entry ( x, > + list, > + list_entry ) > + { > + if ( (addr >= x->start) && (addr <= x->end) ) > + goto found; > + } > + break; > + } > + case IOREQ_TYPE_PCI_CONFIG: { > + struct hvm_pcidev *x; > + > + list_for_each_entry ( x, > + &s->pcidev_list, > + list_entry ) > + { > + if ( BDF(addr) == x->bdf ) { > + p->type = type; > + p->addr = addr; > + goto found; > + } > + } > + break; > + } > + } > + } > + > +done: > + /* The catch-all server has id 0 */ > + list_for_each_entry ( s, > + &d->arch.hvm_domain.ioreq_server_list, > + list_entry ) > + { > + if ( s->id == 0 ) > + goto found; > + } > + > + s = NULL; > + > +found: > + rcu_read_unlock(&ioreq_server_rcu_lock); > + > + return s; > + > +#undef BDF > +} > + > int hvm_buffered_io_send(ioreq_t *p) > { > struct vcpu *v = current; > struct domain *d = v->domain; > - struct hvm_ioreq_server *s = d->arch.hvm_domain.ioreq_server; > + struct hvm_ioreq_server *s; > struct hvm_ioreq_page *iorp; > buffered_iopage_t *pg; > buf_ioreq_t bp; > @@ -1660,6 +2228,7 @@ int hvm_buffered_io_send(ioreq_t *p) > /* Ensure buffered_iopage fits in a page */ > BUILD_BUG_ON(sizeof(buffered_iopage_t) > PAGE_SIZE); > > + s = hvm_select_ioreq_server(v, p); > if ( !s ) > return 0; > > @@ -1770,18 +2339,34 @@ static bool_t hvm_send_assist_req_to_server(struct hvm_ioreq_server *s, > > bool_t hvm_send_assist_req(struct vcpu *v, ioreq_t *p) > { > - struct domain *d = v->domain; > - struct hvm_ioreq_server *s = d->arch.hvm_domain.ioreq_server; > + struct hvm_ioreq_server *s; > > if ( unlikely(!vcpu_start_shutdown_deferral(v)) ) > return 0; > > + s = hvm_select_ioreq_server(v, p); > if ( !s ) > return 0; > > return hvm_send_assist_req_to_server(s, v, p); > } > > +void hvm_broadcast_assist_req(struct vcpu *v, ioreq_t *p) > +{ > + struct domain *d = v->domain; > + struct list_head *entry; > + > + list_for_each ( entry, > + &d->arch.hvm_domain.ioreq_server_list ) > + { > + struct hvm_ioreq_server *s = list_entry(entry, > + struct hvm_ioreq_server, > + list_entry); > + > + (void) hvm_send_assist_req_to_server(s, v, p); > + } > +} > + > void hvm_hlt(unsigned long rflags) > { > struct vcpu *curr = current; > @@ -4370,6 +4955,215 @@ static int hvmop_flush_tlb_all(void) > return 0; > } > > +static int hvmop_create_ioreq_server( > + XEN_GUEST_HANDLE_PARAM(xen_hvm_create_ioreq_server_t) uop) > +{ > + struct domain *curr_d = current->domain; > + xen_hvm_create_ioreq_server_t op; > + struct domain *d; > + ioservid_t id; > + int rc; > + > + if ( copy_from_guest(&op, uop, 1) ) > + return -EFAULT; > + > + rc = rcu_lock_remote_domain_by_id(op.domid, &d); > + if ( rc != 0 ) > + return rc; > + > + rc = -EINVAL; > + if ( !is_hvm_domain(d) ) > + goto out; > + > + rc = -ENOSPC; > + for ( id = 1; > + id < d->arch.hvm_domain.params[HVM_PARAM_NR_IOREQ_SERVERS]; > + id++ ) > + { > + rc = hvm_create_ioreq_server(d, id, curr_d->domain_id); > + if ( rc == -EEXIST ) > + continue; > + > + break; > + } > + > + if ( rc == -EEXIST ) > + rc = -ENOSPC; > + > + if ( rc < 0 ) > + goto out; > + > + op.id = id; > + > + rc = copy_to_guest(uop, &op, 1) ? -EFAULT : 0; > + > +out: > + rcu_unlock_domain(d); > + return rc; > +} > + > +static int hvmop_get_ioreq_server_info( > + XEN_GUEST_HANDLE_PARAM(xen_hvm_get_ioreq_server_info_t) uop) > +{ > + xen_hvm_get_ioreq_server_info_t op; > + struct domain *d; > + int rc; > + > + if ( copy_from_guest(&op, uop, 1) ) > + return -EFAULT; > + > + rc = rcu_lock_remote_domain_by_id(op.domid, &d); > + if ( rc != 0 ) > + return rc; > + > + rc = -EINVAL; > + if ( !is_hvm_domain(d) ) > + goto out; > + > + if ( (rc = hvm_get_ioreq_server_pfn(d, op.id, 0, &op.pfn)) < 0 ) > + goto out; > + > + if ( (rc = hvm_get_ioreq_server_pfn(d, op.id, 1, &op.buf_pfn)) < 0 ) > + goto out; > + > + if ( (rc = hvm_get_ioreq_server_buf_port(d, op.id, &op.buf_port)) < 0 ) > + goto out; > + > + rc = copy_to_guest(uop, &op, 1) ? -EFAULT : 0; > + > +out: > + rcu_unlock_domain(d); > + return rc; > +} > + > +static int hvmop_map_io_range_to_ioreq_server( > + XEN_GUEST_HANDLE_PARAM(xen_hvm_map_io_range_to_ioreq_server_t) uop) > +{ > + xen_hvm_map_io_range_to_ioreq_server_t op; > + struct domain *d; > + int rc; > + > + if ( copy_from_guest(&op, uop, 1) ) > + return -EFAULT; > + > + rc = rcu_lock_remote_domain_by_id(op.domid, &d); > + if ( rc != 0 ) > + return rc; > + > + rc = -EINVAL; > + if ( !is_hvm_domain(d) ) > + goto out; > + > + rc = hvm_map_io_range_to_ioreq_server(d, op.id, op.is_mmio, > + op.start, op.end); > + > +out: > + rcu_unlock_domain(d); > + return rc; > +} > + > +static int hvmop_unmap_io_range_from_ioreq_server( > + XEN_GUEST_HANDLE_PARAM(xen_hvm_unmap_io_range_from_ioreq_server_t) uop) > +{ > + xen_hvm_unmap_io_range_from_ioreq_server_t op; > + struct domain *d; > + int rc; > + > + if ( copy_from_guest(&op, uop, 1) ) > + return -EFAULT; > + > + rc = rcu_lock_remote_domain_by_id(op.domid, &d); > + if ( rc != 0 ) > + return rc; > + > + rc = -EINVAL; > + if ( !is_hvm_domain(d) ) > + goto out; > + > + rc = hvm_unmap_io_range_from_ioreq_server(d, op.id, op.is_mmio, > + op.start); > + > +out: > + rcu_unlock_domain(d); > + return rc; > +} > + > +static int hvmop_map_pcidev_to_ioreq_server( > + XEN_GUEST_HANDLE_PARAM(xen_hvm_map_pcidev_to_ioreq_server_t) uop) > +{ > + xen_hvm_map_pcidev_to_ioreq_server_t op; > + struct domain *d; > + int rc; > + > + if ( copy_from_guest(&op, uop, 1) ) > + return -EFAULT; > + > + rc = rcu_lock_remote_domain_by_id(op.domid, &d); > + if ( rc != 0 ) > + return rc; > + > + rc = -EINVAL; > + if ( !is_hvm_domain(d) ) > + goto out; > + > + rc = hvm_map_pcidev_to_ioreq_server(d, op.id, op.bdf); > + > +out: > + rcu_unlock_domain(d); > + return rc; > +} > + > +static int hvmop_unmap_pcidev_from_ioreq_server( > + XEN_GUEST_HANDLE_PARAM(xen_hvm_unmap_pcidev_from_ioreq_server_t) uop) > +{ > + xen_hvm_unmap_pcidev_from_ioreq_server_t op; > + struct domain *d; > + int rc; > + > + if ( copy_from_guest(&op, uop, 1) ) > + return -EFAULT; > + > + rc = rcu_lock_remote_domain_by_id(op.domid, &d); > + if ( rc != 0 ) > + return rc; > + > + rc = -EINVAL; > + if ( !is_hvm_domain(d) ) > + goto out; > + > + rc = hvm_unmap_pcidev_from_ioreq_server(d, op.id, op.bdf); > + > +out: > + rcu_unlock_domain(d); > + return rc; > +} > + > +static int hvmop_destroy_ioreq_server( > + XEN_GUEST_HANDLE_PARAM(xen_hvm_destroy_ioreq_server_t) uop) > +{ > + xen_hvm_destroy_ioreq_server_t op; > + struct domain *d; > + int rc; > + > + if ( copy_from_guest(&op, uop, 1) ) > + return -EFAULT; > + > + rc = rcu_lock_remote_domain_by_id(op.domid, &d); > + if ( rc != 0 ) > + return rc; > + > + rc = -EINVAL; > + if ( !is_hvm_domain(d) ) > + goto out; > + > + hvm_destroy_ioreq_server(d, op.id); > + rc = 0; > + > +out: > + rcu_unlock_domain(d); > + return rc; > +} > + > long do_hvm_op(unsigned long op, XEN_GUEST_HANDLE_PARAM(void) arg) > > { > @@ -4378,6 +5172,41 @@ long do_hvm_op(unsigned long op, XEN_GUEST_HANDLE_PARAM(void) arg) > > switch ( op ) > { > + case HVMOP_create_ioreq_server: > + rc = hvmop_create_ioreq_server( > + guest_handle_cast(arg, xen_hvm_create_ioreq_server_t)); > + break; > + > + case HVMOP_get_ioreq_server_info: > + rc = hvmop_get_ioreq_server_info( > + guest_handle_cast(arg, xen_hvm_get_ioreq_server_info_t)); > + break; > + > + case HVMOP_map_io_range_to_ioreq_server: > + rc = hvmop_map_io_range_to_ioreq_server( > + guest_handle_cast(arg, xen_hvm_map_io_range_to_ioreq_server_t)); > + break; > + > + case HVMOP_unmap_io_range_from_ioreq_server: > + rc = hvmop_unmap_io_range_from_ioreq_server( > + guest_handle_cast(arg, xen_hvm_unmap_io_range_from_ioreq_server_t)); > + break; > + > + case HVMOP_map_pcidev_to_ioreq_server: > + rc = hvmop_map_pcidev_to_ioreq_server( > + guest_handle_cast(arg, xen_hvm_map_pcidev_to_ioreq_server_t)); > + break; > + > + case HVMOP_unmap_pcidev_from_ioreq_server: > + rc = hvmop_unmap_pcidev_from_ioreq_server( > + guest_handle_cast(arg, xen_hvm_unmap_pcidev_from_ioreq_server_t)); > + break; > + > + case HVMOP_destroy_ioreq_server: > + rc = hvmop_destroy_ioreq_server( > + guest_handle_cast(arg, xen_hvm_destroy_ioreq_server_t)); > + break; > + > case HVMOP_set_param: > case HVMOP_get_param: > { > @@ -4466,9 +5295,9 @@ long do_hvm_op(unsigned long op, XEN_GUEST_HANDLE_PARAM(void) arg) > if ( a.value == DOMID_SELF ) > a.value = curr_d->domain_id; > > - rc = hvm_create_ioreq_server(d, a.value); > + rc = hvm_create_ioreq_server(d, 0, a.value); > if ( rc == -EEXIST ) > - rc = hvm_set_ioreq_server_domid(d, a.value); > + rc = hvm_set_ioreq_server_domid(d, 0, a.value); > break; > case HVM_PARAM_ACPI_S_STATE: > /* Not reflexive, as we must domain_pause(). */ > @@ -4533,6 +5362,10 @@ long do_hvm_op(unsigned long op, XEN_GUEST_HANDLE_PARAM(void) arg) > if ( a.value > SHUTDOWN_MAX ) > rc = -EINVAL; > break; > + case HVM_PARAM_NR_IOREQ_SERVERS: > + if ( d == current->domain ) > + rc = -EPERM; > + break; > } > > if ( rc == 0 ) > @@ -4567,7 +5400,7 @@ long do_hvm_op(unsigned long op, XEN_GUEST_HANDLE_PARAM(void) arg) > case HVM_PARAM_BUFIOREQ_PFN: > case HVM_PARAM_BUFIOREQ_EVTCHN: > /* May need to create server */ > - rc = hvm_create_ioreq_server(d, curr_d->domain_id); > + rc = hvm_create_ioreq_server(d, 0, curr_d->domain_id); > if ( rc != 0 && rc != -EEXIST ) > goto param_fail; > > @@ -4576,7 +5409,7 @@ long do_hvm_op(unsigned long op, XEN_GUEST_HANDLE_PARAM(void) arg) > case HVM_PARAM_IOREQ_PFN: { > xen_pfn_t pfn; > > - if ( (rc = hvm_get_ioreq_server_pfn(d, 0, &pfn)) < 0 ) > + if ( (rc = hvm_get_ioreq_server_pfn(d, 0, 0, &pfn)) < 0 ) > goto param_fail; > > a.value = pfn; > @@ -4585,7 +5418,7 @@ long do_hvm_op(unsigned long op, XEN_GUEST_HANDLE_PARAM(void) arg) > case HVM_PARAM_BUFIOREQ_PFN: { > xen_pfn_t pfn; > > - if ( (rc = hvm_get_ioreq_server_pfn(d, 1, &pfn)) < 0 ) > + if ( (rc = hvm_get_ioreq_server_pfn(d, 0, 1, &pfn)) < 0 ) > goto param_fail; > > a.value = pfn; > @@ -4594,7 +5427,7 @@ long do_hvm_op(unsigned long op, XEN_GUEST_HANDLE_PARAM(void) arg) > case HVM_PARAM_BUFIOREQ_EVTCHN: { > evtchn_port_t port; > > - if ( (rc = hvm_get_ioreq_server_buf_port(d, &port)) < 0 ) > + if ( (rc = hvm_get_ioreq_server_buf_port(d, 0, &port)) < 0 ) > goto param_fail; > > a.value = port; > diff --git a/xen/arch/x86/hvm/io.c b/xen/arch/x86/hvm/io.c > index c9adb94..ac0d867 100644 > --- a/xen/arch/x86/hvm/io.c > +++ b/xen/arch/x86/hvm/io.c > @@ -75,7 +75,7 @@ void send_invalidate_req(void) > .data = ~0UL, /* flush all */ > }; > > - (void)hvm_send_assist_req(v, &p); > + hvm_broadcast_assist_req(v, &p); > } > > int handle_mmio(void) > diff --git a/xen/include/asm-x86/hvm/domain.h b/xen/include/asm-x86/hvm/domain.h > index a77b83d..e9da543 100644 > --- a/xen/include/asm-x86/hvm/domain.h > +++ b/xen/include/asm-x86/hvm/domain.h > @@ -41,17 +41,38 @@ struct hvm_ioreq_page { > void *va; > }; > > +struct hvm_io_range { > + struct list_head list_entry; > + uint64_t start, end; > + struct rcu_head rcu; > +}; > + > +struct hvm_pcidev { > + struct list_head list_entry; > + uint16_t bdf; > + struct rcu_head rcu; > +}; > + > struct hvm_ioreq_server { > + struct list_head list_entry; > + ioservid_t id; > struct domain *domain; > domid_t domid; > struct hvm_ioreq_page ioreq; > int ioreq_evtchn[MAX_HVM_VCPUS]; > struct hvm_ioreq_page buf_ioreq; > int buf_ioreq_evtchn; > + struct list_head mmio_range_list; > + struct list_head portio_range_list; > + struct list_head pcidev_list; > }; > > struct hvm_domain { > - struct hvm_ioreq_server *ioreq_server; > + struct list_head ioreq_server_list; > + spinlock_t ioreq_server_lock; > + uint32_t pci_cf8; > + spinlock_t pci_lock; > + > struct pl_time pl_time; > > struct hvm_io_handler *io_handler; > diff --git a/xen/include/asm-x86/hvm/hvm.h b/xen/include/asm-x86/hvm/hvm.h > index 40aeddf..4118669 100644 > --- a/xen/include/asm-x86/hvm/hvm.h > +++ b/xen/include/asm-x86/hvm/hvm.h > @@ -229,6 +229,7 @@ int prepare_ring_for_helper(struct domain *d, unsigned long gmfn, > void destroy_ring_for_helper(void **_va, struct page_info *page); > > bool_t hvm_send_assist_req(struct vcpu *v, ioreq_t *p); > +void hvm_broadcast_assist_req(struct vcpu *v, ioreq_t *p); > > void hvm_get_guest_pat(struct vcpu *v, u64 *guest_pat); > int hvm_set_guest_pat(struct vcpu *v, u64 guest_pat); > diff --git a/xen/include/public/hvm/hvm_op.h b/xen/include/public/hvm/hvm_op.h > index a9aab4b..6b31189 100644 > --- a/xen/include/public/hvm/hvm_op.h > +++ b/xen/include/public/hvm/hvm_op.h > @@ -23,6 +23,7 @@ > > #include "../xen.h" > #include "../trace.h" > +#include "../event_channel.h" > > /* Get/set subcommands: extra argument == pointer to xen_hvm_param struct. */ > #define HVMOP_set_param 0 > @@ -270,6 +271,75 @@ struct xen_hvm_inject_msi { > typedef struct xen_hvm_inject_msi xen_hvm_inject_msi_t; > DEFINE_XEN_GUEST_HANDLE(xen_hvm_inject_msi_t); > > +typedef uint32_t ioservid_t; > + > +DEFINE_XEN_GUEST_HANDLE(ioservid_t); > + > +#define HVMOP_create_ioreq_server 17 > +struct xen_hvm_create_ioreq_server { > + domid_t domid; /* IN - domain to be serviced */ > + ioservid_t id; /* OUT - server id */ > +}; > +typedef struct xen_hvm_create_ioreq_server xen_hvm_create_ioreq_server_t; > +DEFINE_XEN_GUEST_HANDLE(xen_hvm_create_ioreq_server_t); > + > +#define HVMOP_get_ioreq_server_info 18 > +struct xen_hvm_get_ioreq_server_info { > + domid_t domid; /* IN - domain to be serviced */ > + ioservid_t id; /* IN - server id */ > + xen_pfn_t pfn; /* OUT - ioreq pfn */ > + xen_pfn_t buf_pfn; /* OUT - buf ioreq pfn */ > + evtchn_port_t buf_port; /* OUT - buf ioreq port */ > +}; > +typedef struct xen_hvm_get_ioreq_server_info xen_hvm_get_ioreq_server_info_t; > +DEFINE_XEN_GUEST_HANDLE(xen_hvm_get_ioreq_server_info_t); > + > +#define HVMOP_map_io_range_to_ioreq_server 19 > +struct xen_hvm_map_io_range_to_ioreq_server { > + domid_t domid; /* IN - domain to be serviced */ > + ioservid_t id; /* IN - handle from HVMOP_register_ioreq_server */ > + int is_mmio; /* IN - MMIO or port IO? */ > + uint64_aligned_t start, end; /* IN - inclusive start and end of range */ > +}; > +typedef struct xen_hvm_map_io_range_to_ioreq_server xen_hvm_map_io_range_to_ioreq_server_t; > +DEFINE_XEN_GUEST_HANDLE(xen_hvm_map_io_range_to_ioreq_server_t); > + > +#define HVMOP_unmap_io_range_from_ioreq_server 20 > +struct xen_hvm_unmap_io_range_from_ioreq_server { > + domid_t domid; /* IN - domain to be serviced */ > + ioservid_t id; /* IN - handle from HVMOP_register_ioreq_server */ > + uint8_t is_mmio; /* IN - MMIO or port IO? */ > + uint64_aligned_t start; /* IN - start address of the range to remove */ > +}; > +typedef struct xen_hvm_unmap_io_range_from_ioreq_server xen_hvm_unmap_io_range_from_ioreq_server_t; > +DEFINE_XEN_GUEST_HANDLE(xen_hvm_unmap_io_range_from_ioreq_server_t); > + > +#define HVMOP_map_pcidev_to_ioreq_server 21 > +struct xen_hvm_map_pcidev_to_ioreq_server { > + domid_t domid; /* IN - domain to be serviced */ > + ioservid_t id; /* IN - handle from HVMOP_register_ioreq_server */ > + uint16_t bdf; /* IN - PCI bus/dev/func */ > +}; > +typedef struct xen_hvm_map_pcidev_to_ioreq_server xen_hvm_map_pcidev_to_ioreq_server_t; > +DEFINE_XEN_GUEST_HANDLE(xen_hvm_map_pcidev_to_ioreq_server_t); > + > +#define HVMOP_unmap_pcidev_from_ioreq_server 22 > +struct xen_hvm_unmap_pcidev_from_ioreq_server { > + domid_t domid; /* IN - domain to be serviced */ > + ioservid_t id; /* IN - handle from HVMOP_register_ioreq_server */ > + uint16_t bdf; /* IN - PCI bus/dev/func */ > +}; > +typedef struct xen_hvm_unmap_pcidev_from_ioreq_server xen_hvm_unmap_pcidev_from_ioreq_server_t; > +DEFINE_XEN_GUEST_HANDLE(xen_hvm_unmap_pcidev_from_ioreq_server_t); > + > +#define HVMOP_destroy_ioreq_server 23 > +struct xen_hvm_destroy_ioreq_server { > + domid_t domid; /* IN - domain to be serviced */ > + ioservid_t id; /* IN - server id */ > +}; > +typedef struct xen_hvm_destroy_ioreq_server xen_hvm_destroy_ioreq_server_t; > +DEFINE_XEN_GUEST_HANDLE(xen_hvm_destroy_ioreq_server_t); > + > #endif /* defined(__XEN__) || defined(__XEN_TOOLS__) */ > > #endif /* __XEN_PUBLIC_HVM_HVM_OP_H__ */ > diff --git a/xen/include/public/hvm/ioreq.h b/xen/include/public/hvm/ioreq.h > index f05d130..e84fa75 100644 > --- a/xen/include/public/hvm/ioreq.h > +++ b/xen/include/public/hvm/ioreq.h > @@ -34,6 +34,7 @@ > > #define IOREQ_TYPE_PIO 0 /* pio */ > #define IOREQ_TYPE_COPY 1 /* mmio ops */ > +#define IOREQ_TYPE_PCI_CONFIG 2 /* pci config ops */ > #define IOREQ_TYPE_TIMEOFFSET 7 > #define IOREQ_TYPE_INVALIDATE 8 /* mapcache */ > > diff --git a/xen/include/public/hvm/params.h b/xen/include/public/hvm/params.h > index 517a184..4109b11 100644 > --- a/xen/include/public/hvm/params.h > +++ b/xen/include/public/hvm/params.h > @@ -145,6 +145,8 @@ > /* SHUTDOWN_* action in case of a triple fault */ > #define HVM_PARAM_TRIPLE_FAULT_REASON 31 > > -#define HVM_NR_PARAMS 32 > +#define HVM_PARAM_NR_IOREQ_SERVERS 32 > + > +#define HVM_NR_PARAMS 33 > > #endif /* __XEN_PUBLIC_HVM_PARAMS_H__ */ _______________________________________________ Xen-devel mailing list Xen-devel@lists.xen.org http://lists.xen.org/xen-devel From xen-devel-bounces@lists.xen.org Tue Mar 04 23:33:42 2014 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Tue, 04 Mar 2014 23:33:42 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WKypr-0000Mv-TR; Tue, 04 Mar 2014 23:33:19 +0000 Received: from mail6.bemta14.messagelabs.com ([193.109.254.103]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WKypo-0000Mq-OZ for xen-devel@lists.xen.org; Tue, 04 Mar 2014 23:33:18 +0000 Received: from [193.109.254.147:55235] by server-13.bemta-14.messagelabs.com id 61/90-01226-BB266135; Tue, 04 Mar 2014 23:33:15 +0000 X-Env-Sender: dgdegra@tycho.nsa.gov X-Msg-Ref: server-16.tower-27.messagelabs.com!1393975986!8389995!1 X-Originating-IP: [63.239.67.9] X-SpamReason: No, hits=0.0 required=7.0 tests= X-StarScan-Received: X-StarScan-Version: 6.9.16; banners=-,-,- X-VirusChecked: Checked Received: (qmail 31832 invoked from network); 4 Mar 2014 23:33:06 -0000 Received: from emvm-gh1-uea08.nsa.gov (HELO nsa.gov) (63.239.67.9) by server-16.tower-27.messagelabs.com with SMTP; 4 Mar 2014 23:33:06 -0000 X-TM-IMSS-Message-ID: <0b870442001553b8@nsa.gov> Received: from tarius.tycho.ncsc.mil ([144.51.242.1]) by nsa.gov ([63.239.67.9]) with ESMTP (TREND IMSS SMTP Service 7.1; TLSv1/SSLv3 DHE-RSA-AES256-SHA (256/256)) id 0b870442001553b8 ; Tue, 4 Mar 2014 18:32:37 -0500 Received: from moss-nexus.epoch.ncsc.mil (moss-nexus [192.168.25.48]) by tarius.tycho.ncsc.mil (8.14.4/8.14.4) with ESMTP id s24NWk6o005131 for ; Tue, 4 Mar 2014 18:32:57 -0500 Message-ID: <53166294.5090308@tycho.nsa.gov> Date: Tue, 04 Mar 2014 18:32:36 -0500 From: Daniel De Graaf Organization: National Security Agency User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:24.0) Gecko/20100101 Thunderbird/24.2.0 MIME-Version: 1.0 To: xen-devel@lists.xen.org References: <1393973494-29411-1-git-send-email-dgdegra@tycho.nsa.gov> In-Reply-To: <1393973494-29411-1-git-send-email-dgdegra@tycho.nsa.gov> Content-Type: multipart/mixed; boundary="------------070900010608010204080109" Subject: [Xen-devel] Domain Builder X-BeenThere: xen-devel@lists.xen.org X-Mailman-Version: 2.1.13 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Sender: xen-devel-bounces@lists.xen.org Errors-To: xen-devel-bounces@lists.xen.org This is a multi-part message in MIME format. --------------070900010608010204080109 Content-Type: text/plain; charset=ISO-8859-1; format=flowed Content-Transfer-Encoding: 7bit A domain builder suitable for creating a disaggregated Xen system is attached. Using this domain builder requires the patch series that this email is in reply to, and requires that the hypervisor be built with XSM enabled (with the XSM policy loaded from the bootloader). The executable passed to Xen from GRUB is called db-boot. It takes a CPIO archive containing specification files (with extension .cfg.db) and their dependencies (kernels and initrds). The specification files are built using compile-db-spec. Example contents of the ramdisk: control - control domain kernel (in tarball) control.cpio - configuration for control domain control.cfg.db - spec file for control domain xenstore - mini-os version of the C xenstore xenstore.cfg.db - spec file for Xenstore vtpmmgr - mini-os TPM manager vtpmmgr.cfg.db - spec file for TPM Manager vmlinuz - Kernel for both Linux domains initramfs.img - Common initrd for Linux domains hardware.cfg.db - spec file for hardware domain toolstack.cfg.db - spec file for toolstack domain control.cfg: vcpus=1 memory=4 kernel="control" ramdisk="control.cpio" extra="SVP xenstore=2 hs=3 drivers=3 tpm=4 self=1 schema=platform.ctl" domid=1 access_control="system_u:system_r:control_t" xenstore.cfg: vcpus=1 memory=20 kernel="xenstore" extra="--priv-domid 5 --internal-db" domid=2 access_control="system_u:system_r:xenstore_t" hardware.cfg: memory=2000 vcpus=1 domid=3 dom_flags=['INITDOMAIN'] access_control="system_u:system_r:hardware_t" kernel="vmlinuz" ramdisk="initramfs.img" extra="ro root=/dev/lvm_foo/hardware_root console=hvc0 earlyprintk=xen" iomem=['enable 0(0xfed40)', 'enable 0xfed45(0xff012bb)'] ioports=[ # This is derived from "xl debug-key q" output for dom0 'enable 0(0x20)', 'enable 0x22(0x1e)', 'enable 0x44(0x1c)', 'enable 0x68(0x38)', 'enable 0xA2(0x356)', 'enable 0x400(8)', 'enable 0x40C(0x8EC)', 'enable 0xD00(0xF300)', ] vtpmmgr.cfg: vcpus=1 memory=5 kernel="boot/vtpmmgr" extra="tpmlocality=2" domid=4 access_control="system_u:system_r:vtpm_mgr_t" iomem=['enable 0xfed42(1)'] toolstack.cfg: memory=2000 vcpus=1 domid=5 access_control="system_u:system_r:toolstack_t" kernel="vmlinuz" ramdisk="initramfs.img" extra="ro root=/dev/lvm_foo/toolstack_root console=hvc0 earlyprintk=xen" control.cpio: platform.ctl - compiled with compile-control-schema from svp.schema svp.schema should be an empty file. Its contents describe additional domains to build from disk, but this support requires using the domain builder server which was removed due to its dependency on IVC which is not available in upstream Xen. --------------070900010608010204080109 Content-Type: application/x-compressed-tar; name="domain_builder.tgz" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="domain_builder.tgz" H4sIALRQFlMAA+w8e3/bRo79d/kp5lS7kRyJtuRHWmvVKy3Jtn7VwyfJbnNplqXIkcQ1RWpJ yo53N9/9gHnwqUeaddPb35pJbGmAATAABgPMcLI0Pugzx5sYjj6nhkX9r57/OYLn7OyM/YYn +xuAJ19Va8dHpyenR7XTE2ivnpxWa1/NfgdZcs8qCA0fWPqeF27D2wXPDu7f5DmtEdNbLKgb Nr6bVs/M76rf1szvJoZR+/akNqUnb749OjUmp8d0cnxMrZphVGvKHy3zy/N8j+UtDNvVJyvb gcl/+LvwwPnw5s3p5vkPn7Pz/+j4+KvT30WazPMfPv8z9ldndmjPXM+nz8iDx/+Tjfav1nLx /+yoBvBnlGHj8x9u/0NmeeVwYrvK4eL+0PTcqT1THHtyoBrKgeopoTEL4MNfaRDYFD6Y05lq TeSHhaIeqMHjUjm0PDPg1P7oMb08n/5k5n+302z3R+3n5bFj/teOT46z8//06KT2Mv+/wNP0 lk++PZuH5MpwPDsok45rqqR2dPRtpQaRWVGG1LKD0Lcnq9D2XGK4FlkFlNguCbyVb1LWAuHD 8J/I1PMXQOLRDufE89lvbxUqC8+yp7ZpIIEyMXxKltRf2GFILbL0vQfbgg/h3AjhBwUijuM9 2u4MMlPXsrFToGCnBQ3PlapK0hIFxJtKUUzPAjQwKfFpCH7N6BkT7wFBYqAKIcT1QtukZQDb AXGAGNKIubEhpUUBjqZj2Avqq0otLwKwSqhAigBjs1Yg1u8gBeGDQzIQeFeYwBvSPoegeg+A PlkYIfVtwwliNTPbINXkAFRFGV93RmQ0uBz/pA3bBD7fDAd3nVa7RS7eEu12fD0YEq3fIs1B fzzsXNyOB8MR+fVXbQS4r14hSNH6b0n755thezQigN3p3XQ70B8IDrX+uNMegXP1m93bVqd/ VSZAgvQHY9Lt9DpjQBsPymR83Vby3cjgkvTaw+Y1fNUuOt3O+C0T5bIz7iOvSxSN3GjDcad5 29WG5OZ2eDMYtRUcSaszana1Tq/dUgmwB5akfdfuj8noWut25cjgb2pgF22QS7vothVGHAbW 6gzbzTGOIP7UBP2ASN0yGd20mx380P65DfJrw7dlQXPU/p9bQAKg0tJ62hUMp7hDC6D55u2w 3UMpYeij24vRuDO+HbfJ1WDQGilAeNQe3kGoHtVJdzBiCrodtcukpY01xhhIgHYADJ8vbkcd pqdOf9weDm9vxp1Bv6RcD34CRYCMGnRtMYUO+myoYIXB8C0SRR0wfZfJT9dtaB+iCpmmNFTB CDTWHCsJNOAHChwnxkj67atu56rdb7YROkAqP3VG7RLRhp0RInQ425+0t8rglg0ZcHBA/GPC L8vMdqRzSbTWXQfFFshg7lFHuMbgUhndNq8JV7f6Uq5uezLrf8+4p1Pbec7sf+f6Xz07y9V/ pydvzl7W/y/wqDfXg/7bc2I61IDFw3GIOVmYijJoVCquV1n6thtWLNunZuj5T4rS+7HxAzXn HilcoMvgorRXLdTJXrGn/Qhzeq84KJFKExoVBaidK3/aK5pItvdjGYqKQ7OUbfk7/KhU1Zp6 mgMFc6N2epZrNpe2l8ddwJfBKI8MK6nn0Hz73HBzjdSZptpCz3OCQ1g7Q8/0nEqwpHn5rcmm 9ryMUFob4cqneSapFiA5AXdLtcE4Qh9k4BO2pCgKMxkoGPKNyhTTj8MD5U8/SENwg0pzpHtv RBOMN8JTg9iIxQa0lYbQ2Q6crWAw1VY42nc7AneM7WPlTrWdDnjjdiLMi7eixHNgOyvl2Rez TPwftrVW75nLv13x//jNaX7/783L/s8XeRoNMnig/oNNH0mjAWUA1iJRvGdxA/wjYBVDssiC MocYhHsPEd5D7noqEADE1SRaM2wasIrPCEQdE5wrULVUZKw5xxIG0veC59JKMPfCQooqLjB3 vTKWnFAMeQS7AOOlY4RYaamsNxc6LYvpUyh+eBGFJg7hI4juOCAV1klQat31AtZ96nsLYgPC UOthWXQPFezcNufExj7Nm84ARmDO7QeqRqIHoDPqS+HverG0HIK6gHojJI8GUkZ1+fRvKxqE XCSGHkQigEAWXQBAcMDZfiCpp6UGkG8wtUY6QVq8pstpLhAE0wtAQm5WdpsQaJiSYOAQEyP1 yt5yBQx4xwtZ6i586BwsTRqV90IqHC+eK61c0U4mNHyk1GX9UdQHGIO3ChBrCaZ3Q8mLrR6c z53ACVbLpQfCMZBKLoH4wgOfsrDId6CAhqwVLOV43j0Rmwg8kHHzQj4rymXyKyPxa+zhkika Js00jGxFPxiLpUOFgIt7jtdkO6Urnw8PB4wMuC2CpyCk4JwKTC+Jx7cBWNZEbnzPpEHAZ5xH zBQKJ7EUKJIwTgIQwgiocG3mzgkRFDZO11iA+gvRTm5BRTsHNg4AfPEJ/UX0Z9sOXDkBNrNd mieF7Thga0xEFRpAYmMJjkKD7aKriN2HCe73IAnHE4YHl8XvP1OX8BNmrlRpf+G8zLIKU9hF 5M7gnqghbRrihBaDRb+WCnnyVgRixgrwJ7jFAmJF88EOYarc82FCyPmeLMBLRIBjExtm6ZPU jKx7SJFpRdAEG0wMZ/KExKf2B1DseaWksBnD+j0RfwUKQMKEIrnHOfUxSHSm/DsQA2lnHsYh 0/R8NilBQphfbkr6qQ0quae+Sx1iL4wZDRRp+PDRy8Q2tt1UEPGzwLRZiEJSgXvdcOW6yAwm dpsbT4R3mojuBebjh5xvUIhNKo0j7C4kC0RYhGihgEZYwACdgH6ysYf64CnXoAvU9Nx7ZEPF IBMCVzAMOElkEpYxsrm2oDCrnx4N514FvQpTYRTBEVqoxNRuGE7DqsrdBX0qkhaXIUJqKrMq C/uQonG1MuUb5j1+tENEO1ZJUy4V5G90sWIrgMDGzTI+2yFGaNyHn5a4XAa4/nGBuHLKEm2c 0wUpyoS+jH1a3uIohc3EE7qPvftVIIQoGhAGBIVX8SJV4sKPWNhmgkdbezNYqtzEONTNeWMm /0svE890HIz50G88/z17c3b0cv77BZ7t9n+e4+Ad+T9k+9nzn9rRm5OX/Z8v8UiLK4e2azor i2ZcoGIs7Y2wwJxD0qpEGySBksFQl9b0Zf/1//Ozff4/z3bwrvr/uHaWm/8ntZOX+f8FnvHg pqGqipjgZK8IDaXEiyDK+GpM4qchw4XSutDxEEq/0cbX0C57Rnmo0u1cNBMdJQLfxwLgqKd1 u4NRDij33LD/tdZf2x/39pDEtVY7PcvDxY4bYLQu8GQujyE3IJEJ1vfrmOC+Xqund7XbfhNP vhJwvi9sLSqOsXIhCPoKUtJbneFIUNorImncD4+HKr7hqMRHLl5JaV52tSvRlbxuVILQaszc 1XffKfwYrS1IN6SdflFI+hH8ZKQONmBISbbi/dzu69dQP7eHIPIGTjiGXczE6LaiJd1ot/TM 3jvR0KI7uMZmTSEq8jjEolNj5YSK+H2Ohr8al5Q1E8VfOVCtZdqjFfFwiGB1ca/sFemD4RC5 o6/92NZvhoPxoDnolvNrblkQLEeUSqXfQoIvzWupKE39stNtjxqxkHn+ukVxn081E+rbik/d T8fnwq1jsVd8hIXINHyLHKgmyMr1jvpfGmGwmgQh2VfN8r7qlfeKYiClEhFBQ8fdJCNUvYhk wlthUmPgUI00UHopgEVUyGJItwMMHllyCHJWIQaXJIvCfRJFgLCSA3JIqllOfD7C6CTIXFjl bouFjxYLGvkZuleEJRt3TFBJZO8v6zAiZQLffdUok4qzX072NFjPfNeKR/Z+UJR8mnee2WJU F4Z/b3mPLop+o/VbA4iGrDcQlodXZGIEtqmzL/wgy5/GbkM2p6SbQCIj/aNX1X+fZ3v+B97m 2C7EL/Nf4bE9/6sC8E2+/qu91H9f4vlaLlx/xrfB3Jk6/15JtlkQrbJNsCim26jvuwwticfj 4OGCLjIEBIC9WnCf7lWIHG5egGZgBF/I6O5G7w0gFmrDK1KAb4UI1BwPu3pr0OOggDrTGCZS i/aQA+Md0gjjeqRfDAZjDp8Hia7DDvQbiY6+Db0SUMiPRuPBUMjzgbpB6Pk0ht+Nb3p6T+tr V5J3uFzE4E5/PBwI2jZOtwTpEaQkPU2MhsWyAuYcIWHR2g5XIdWFjoqwmPnkgIDdyrjhaFt6 SMzQd3T4UiL/gMCNR9zQxvFC7566kMIWYCXhs7xUqCOSABv+jIYAB3rwt8jIsj6lOpFoQFkH wLuz90gIugPAnpKi6PxfDdK/7XY584iyTwOkK3BeIwOHukVBm2HiCKGNrTAggct8Y1oU7Mok sP9Oveh7qUwK+/NVoUyKwRzPhVYuvpRArVI8fk4XkM3lkxCvLMUXQN76ugGM2UAIbm87lJAi /DkQ0NcgzwGO4PXrEo7v1S9Hrwgj8BH++TRc+S45qisfFUUJ8BVMUwlQWrDF0vADqnMLp4wl DKh7yzAAvAP8jToDgo7nzvgPZtF6qgnPwLBF0Pem04BZ7AgbUYUgp/yIpl8tqMVGxseFJn3H O71nQ4E///wnybbCAIUwOL4A7RGYhjstfpPALKfTgsK+49hl/FHfdwsZ4DdsKGXyDcoPv6Ro JaF1dCBkBMxr0nUi1XJ+3GAfOT4PHMXCu+a4+550UL9c1/zYEaX4xUXniDRXYhJIfkJvrxtp JXFB0BaV75nRdHe1II0G5Nk/63zOlqRUlXbtonMl6cVdgneZ/u9VxhqUGNlzV4fF1GWz4OhT kNmxKCBL10jhI8rr19xXlZxGP0YOi/6CU8Na6EyP0llhBgRxaDkQZuTAA0DGnSFuMKTAzn0T zsj7AY1EkDFXPh6cNBhppj7hWxyA89pCBxI+g73hM1JmU050B8thUxR9DiRZ8N7yqyj6sEY+ fkKkvMCbA1JTPiKRmADcDbP0SQIGVCUTwvvVI8jEp8a9/PpR/E6L9FEa5iDlI0xl5PCQBBSs wQ56Awxv+Io3Hl/Jw3DTgAXBnSUsK8SsCO1+TKyg42Gnf9W5fFv8UCJff4jaxwMdQNiYxGAO 4XiGlV1quENsCl+xG0SWgYjhmotlMbmClwUZsQwkQVBvgI6PpIa5KwcPS32Br5w0SJUrDvuj E6yjEHm7NCxDzpg16aqRb97TJzw8J3wNS4QETiJrfGyUlmQrLRhjRVOBKqbIDRLJzkQ3536R a+JV45VcB4Gd5JZcSXNR78LA4+KnyoPhrChEP9vHV0jEWSlap0wWNrgNBECgDuGwFLmmDGHV lKwHfDyRH0fiHKEsKC6YMZltleXwSrGQQq+pWMKH+A23pVyeMw1yuf5IqINXSzJss/nUZ7F+ gBxMB+0YM+qnREgDdoiSyik/Sw5rkuKOX3fwTGSpn8Vx7gWhzlJUnZd1ayG7Bh5nxJ83bJ5E p8cu2xaRd6a9vMUQkCoEw3C1PCf7FlvaczS3C59M2D9LepnjZxUYt++QIM75t/BPJYycP4ut UjlIlKH+GWNkdh6vZxwXFOsYi9WX8yrsF+SCIHrh3lNf67X1Ued/2yWoSPZj5Ys9PFxTkWhy mc4bckTDkL0bxzoR2QmXs/3gl41ES6kQlSZ5y3UmHELwVlJqSq4l6wKoCJcVjJcYmNktqnMh EeokGs36mCnXIb7kieY4ieQzHaWoVKUYGf9OvyYi3hpxPXynjpr21KZWHLpTMmRYybi6jVmT F32SSxGL5dKnM0uXOn/0tsXL80zPJ+7/zf8VHjvOf2u1s1p+/++4+rL/9wWer+2pC8UAafZa XbwlqF/He2txU3r/z7En+W1CN0y3wdJ4CP/W7/3Rh9Ccu3zvL73zlVpyyMlRBI+rcBI/1TNF CZ+WFEcAC97KDFnokyUrf6LKGyrrqJF9w0Yuio4lFe7ZsDr6I+H1M3xcR57tx4mqpE52PVDJ aT4lj5S9u46rIBQseDv69u7mv2VpnFn43q3Txuvqe1YXQvdD6KskBsqXmnqWr8SMEXO5YH0D YiK3qm+lmEmN6jFiAkmuT/Vd8mWz9HpMLd5FYDnzRlICKZXb1jcgxRlofTOlRJJXJ6nhyV0N XsTUt8qTKTPqiWHJ7Uu+yxdt3SRUeY6vnjIhONhasesAgcq9EV2ViC2ieJ5wb7kNVjDnnvCW Ob6Pi1cxPNd5IifixeyAquDv6Zoe3B569gzXXq4cg/nsDK8uvIpfx+XLwmdtTdeVz9lgqCtf U9eyX14ne95nx/rPv/5rx3871v/jk2r1NLf+n1Vf7n99iWfbuVweFsxXIZ7pr4eytys29IO4 Y+l4U2Q9wsw3XFh/8QbHpoyBXRHakU38huNH8HAzdNbDPgQbzjfjJvmqSLbRWNqH4r2WTIqU P11lr4J8wnlrPt/ib6Hk8i3bA9H1R9unmcPY/AsUa4VcgyZe60miiQPRpU+X/Jh2Q/+ttHnC k5AiQd/xZkh4x6kwLnStQU/r9EfkuJY+XW3dNtkrc6RwKNdLmuh6NdYvh5BWYSpZTbYO25d6 /7ZHSDFGOSA32pXIRw/lSST3V3BJ/0l/qOlhqSQOU0gWQhKu/S5m8Z5T1bqdq367xRdcqNBd cc8v9OJLhsoKxvAtz/LAnd9F4mRpCAlwGmKeC+j4cR1tzEBlRiG7SS6Y2UYpD5+4m1iS/gDG M2qP9bvOcFxXwPkEc0aEfyMN8g+ismtbDVJ88GzroLSGB/nIBcULMfL6IZF3tIWIUSrBm0XK SRpsnyKVQqYgObKgxQmkfZIsZiMSpguYzi/JiWMCgZhBYvEs1/NdwjHfS+b8zpm8sDnHTXoa XQhVE5bzZYal+zRYwjh/qw22kdrsOiilJi5gYY5oEHaVDasWvLa1MJb8YpHIAvldUT58SGix N2jbxMuJ0MOlfJjxtUYbPMJbUH5rs0jVmVomhsWQ8HZsMqksqVmHZEx1xpJp/FM1wdx+5fsw F3n+mzYCT6dxVFhxsf9FysL9URvfs3tim3Ihv0ALdAqtGFQog+WmeA0PqACCQDXYLcUw6Wdz A4CU8h2+kBFid1fpgqKnyKuRET7o7q/4P0fdU7qEUhTGL7gAlu0LOcVNVh5A1Sg4xP+J71IP loZJ350kQ9cGVdUV1iHVHTSXycDxF2lArQETOTqOix+YIgArE1XseJIUrFLlwFzpmQQmys18 z0yJmQZGW5/reGbLSQmMxU1LKw7/8gIv8uC4dlzbO1E1rgOLmnET70y1mABzePyCQsYKGEW5 5xvgIBaxjNBQCRnxa6a424sxeUaJFd+kdewpTAQb5qdwSDO1VRxNyHgKYlVmWok5GcUdjO+E AX0DwrAd3Ecg8dpKAqRjU11JxmHcI9HlhCiKF5i4OML8Ovf8AzEDSnH/tHwYtPRs7CiCzVmt E8VEiFaPoixNiLFy1/bG0ZXSAkf5hS5WpaJciAThMvsfAWyT8uXi4P/Ye9flNo5kYfD8FZ6i TOsCUAAIgBQlk6LGFAlJOMPbIShZHlkH0wQaZA8BNAYN8GJbX3wR30bs2b/7BruxEbvPdZ5k 81LXvgAgRdOeGfZ4xEZXVVZWVlVWVlZWJmRz6zIQ1JiZD4RDcnQz0AKatfSohaGj8XWykijd 6oXhkNNFq+WN2RWc32rl83jdD3X9hYLbq3QEZ/pGwcYm8BXYvN0Bi1Z3YLalRbEJHB9axMu4 ZGvG751cb7mTySvCoTxywKPtaNLG6/DW54F/Arid+wKkc2CqMBeAp2LWrhf00D2NWFyyLVxg vWnF1mpNZ8e0hU6eWNHXFflMweDVhi2CqjOX+uGhOnA5CkMYg4MrWiOAbWk2j9YuuCpB2/uw MsKa9KhToGMsG6B7ECMNjthqJCFyZCGZYn50jbJ0RAdl8S8Wffo0K+96/IAIGNCOP1bMBKeF GsLibBBesJ8A4dFw+LBr3G0c+3RMyDfLy3b3JeeZiM2SnEh70uaO1uKOpcVcJzRnsfB9GeX2 8aWy1xICRFkezWMQ5iOP5Oj8Y0vILYrHmJ86zZSRck0s58dm64fDxlG9SFUUia3Lf3UTFpbQ f0JvSephHvUmyl/RErLtEgggaOHmaA4Lml0YMFAwJR+AKr3qdwcmIxmbrP/GmKNy/WuxJhvC 66ONUuFB/XC3eRdEH6Tjn8h4Z9jPTfg/GuZfg3QlFd0xm7QCjj5sjLKnM2NbZXsyZUzGhUGC rG++BR7NBgfuwbg2Av4qWSSH3MgFYctazLxg3SMEdvbfqiVn1xsONQM1+zN1rg8loO2ICzBx H4jVwtS8rLU8Ke//uSyFLGx9HOGYXa98nNIWzshfRIt2HegSFp2Z/ip/H/5A6ODyiih9Y9lp WOvnG1jHeauG289Yk0RerZkAwV0r2XyPV0qDDyofHPmkkGif3Z32V9dSdppoOLXf5sIgs2vf Y7WzO5exc7oXBIrGNszEnTdFVya7Rg8Q2Gv0ATUgxUY+dUG/jtjLlumJRdos5jliSBp4bFpr yHoJNMsKT2ctClx/zb/tdZPI8RUL5jS2/Vsw7fnxlSzbYtELo+u24atJntKC8/4cKCxAtqX5 sL1Fgt8Y2wSt5yX1/JS+Gf63iXwG7ney5Fs8jbfIhrN1gpHcY6sdh+LseK6PmYU5oJAqU9K8 XJyGpHh1Ej/6gyZp7BWzt/pEJDpl98/bjcMiavqODjf3mptb6Pbb6Rr3rKRoOnzuZUF6kluI n7oYQ8KlpfiKkEE/owqxubcyblikJculonCXByAdHzXgBZoNWqUkh+dbMuoT/fgSX14bssqA r16hmvHRBBa4b3uXRXgr2PT/SV9xypubZwxcKhLi49pCJlHELD3cqSnrogP7MWt/TC+9NJ2U oPW3kKnCLRVGkhh6E7oa8GjCF6VSW+EIFVhC6V/z8UwpiMBoEWlSBMHRBGbb3Ti4ZDOk5UeK kmEvJEeGHioOx6d0roUHCe/hr6vEjMSpd05OIoPBmdQ95di4hty68WlAFOowFFc0/8grW3vs eKw89UadC4pHwfrZqJxkAfYBVwYHyBDGHWkteUyWLoM7utjSKy5wXQHcpjpOLsNP1ARKrYZP 31P4IlD348ePa6LRla4mYRxEZIc0wJMO28fice9KKNsC6sAOyMWj8Er1UvzkrlwuJ5TGgG8a pRPmVRbx01SCeNYRP3EoWrd8ZxMuOdd85QGT2IcckXG53ZliaVjcbK5NqTmFX7jY/+AFY7pT Sb0+Gbooj/y2H5zjAPAH43wFls6iswqVJWe7BtIXqkKNcazmVJQZnbS1d3ZnYWX5gE55RQAI EuEtE7ynTwP3OrNShvIQC6LT8z7/tHTJAM7AiT4FUg1r3U+QtvqUi0/NCvZ8VspIeX1soeNc FFiwL4RoEH37YiIaZ3g4cviQKs97HnPyUkwcwxQNMnhDhxqmVTx8gdG6YmLjnzjYKyTwxyzM YpO4u5eQbqMNDsTrtcW+UpTsBekIIEl+c5HpVvpAg7se8u7lfxtzuRYmMVf3724DbQnrejjH T2iTuGOO/knKoI9f3LuNNsRgTm9LHFOQo/BwY1BYcK4JWVLmSHrlZcbA19VZCEJJtyDMTTZL FnS0GS5fsa6NxvhrnFFqbJYWcVUWY78P7Bm9eONB/yj4WTtrJqfsbCOs1hAt8Ug+tLiUyshS GcGD+YVPbv2DjCVRp8Za++DBdYRNCeWBTZ0HSJwHkj4zJIMYSy8K655a9kKj7iSnHtKm7Cmh k44S5/BkVxM5yyQu7pq3okZO5kQn2Ghf5HWuELNjv6tsXbRVmbgIej3ba7Y0SsIDS2mYVCYk bPgITFZBIc6OfWPkwwv4KBhzRWzwCPt1RGJBnfai0AYi9JlPeElTFiXnrMWVBA+DzhKXWKDO ITuq7mTAdmzUgGEI/9hA0Le0jKMGckngD9p+mfzwSy/hCMcbgtQ5HAXkBT0ENKASAOMBYUGW Ldsnx7MO11kfSaIBavE/VSvoGuWXyhdXmWh559D+O/DyOsotbFGIpZXGwpWsqspPbgUVIY5q Q2s2MlUz6Ac/oQTQHCIaAodDPNSnFC2T7IDkpjZ9zitIlupLOfjgCWvuyvOk+GK5JyFnAYyW HDhF8azAE4omxjzGBrb8jzp3F+2Yut/Z0iCyG8JVx1sLBTdMGzHGdkP9UP6OlaLlJbl5wuzK 84xi9jDKdlbYMmOaHiaF2ZHwK3ZWMAbCME0vr3ZX+ea790fb+z/stdojLzo1/hKodjT/yj+2 bMGKSbsy7Y0nkVIoxFtj2X3n5zt6yGybtBKlbrpJ++xNgmWSm7fei8Yw+EYoWqBuhCJsdF/P qcVo2+a8XBSZIJZUjLCY1GaQu33nAhGfrqG4Q3eJbCI5Kowb0cO2Mr4pQYyCB/ARZHhIfB8t 2TAGgY8HcuOgxyoGZUgaRCp+ht/5RrfLuXFkz0X41mKnGY/1hfv5G4tg9fXx6EYNjZlW8Sbb mGkVjFBgL4AqxA32PE63wOsZTYkTb4KsTGUEUMRI3sP3InP3Gy2n2FxH+xChQagDh8rFGtga 8cLYEplmHEZUk7bXtomvrjTS5rcJU1jLUwB2BgVCkJck+YdZZA2rxygadIeyhVcr8tMl/lRF GtoL0bqWdG9g155Rdq6Bs6UtMWngWA290dBJNY4UyjqyNRzTjLZwLx9fjeVBKVMNFybbIWue 17fFwmMDo+iCQPrN1dgmo3Pu9YKODJTD8+bmLNy1EDUozoXP5nE4ovuMnQmJftJW0ESNkWbV afgtLU3H0Bxvp5tZWrOBJGjKQAt2mVPQQwOxkJHfD8/RFpKR7HntM5wgjQ9b2vsTlJ8MQWLy vb4VkoQVWvn19QJhfAzC3JnkHraOem4jWz2OGHspuAaOmYLxN4dXMoLLIt/ACC7XczEPhCqP pZUgI59ERgJg7/8X1JlZo4uqY09uZmCBMfpkdeuAjRRIYY8BfsjDLBeWx0UY9GgEleXNSql3 RUXa7pSkiF8o5yx9g7J8V+PK3tbW0VRf3e3GTEZhaY1aVFGn7hXVnj1jNaUWKchpQ3P65JGu xmylhV3RXjgoaeC49QtQWLcGW5G4lXcOCKFso5qWPMr7vS8z3j/Xfqbf/7Vu+n3FFeDp939r zyE1fv+3ulxdvr//ewfPdCceKfdRU+7Cptxjnd/5r3uD9fS8j/9vwZqYmoYeEftR5lXcjDuj WVdXE1dO7UNFjCYIIm2nb25HSDcFKKsV1WLIFmR67Trzr9Q9AvLNp/PBLyk12bcOpZ76/LgT pV9GcOvKLB0vrHUe1ODBpH8deLDgZmAjOn0HQKff8zOAnPioVm6DTIlrbt6x2DNOIY5BtLF/ d0eoHOq4NAUQ6IXFbpV/Dm1yK4YdSAuHDg0RG/2iMRekNP69usKdgjoL/xJW74FIvb66rlJT 7sTptJS7p+uue1Uf8vWxOJ0nyIGUSk1Lo0gj6FNNaxTtvU7a8FTwCFBRLLz7sAtigjUOw26e fhVoATcaanKVJh4/Vl7jZJGF6gJ75ITGSOVbysmKPUxI8l1EhtBymkZf+JzF9OyidgSXbtWA 9S0GEfVqOBmzda0td9JGMOifxI15dmBjRUI++w9sJyJ14qmFffCijE/0JiO2k7QaZLXE2hwC ElNOujN0Btu7vO17ZCkNDMxsm1q16aWhhHd7YoMLkOFNXhGJYzZrFi1RQcdH1xJpPuaSKKdM paKAwdQ62Dzc3G1t78pLSvHzSnl65UiaSRbHWKUhqKifZETTysREaZtcxsdulhXyxcgbDv1O K4Nt2XwqxqWKhjsVqTv4ACVp6KMPAWJWy1aDr2VrPKvFKYSMtYp5MLdJtoVaIVswbYcypxVl Je46MX4MeSPD3QcpxxPYCsBo6VFEPx9NliaTNCtk2YPYzFiKpAA3His59p6DGHrcKVUr3mpp pfZ8uXTcrbRL3eOVzqPKi95lymGIBGIfzuiuvYHZqeTJjtXpzF7PGuM3Xddtuxdeip59NqYv aniLayxIRwdTFyTTRtd1J/P2zfHYa1NAXWjQGIgqAJzgIc17UpWdEZoxteOsq6hIwhoHewxn zAXF3CVbp/CrdBlV+6m1d+jKduC6NPtwU6LhZ8cZhu0b1GC/F1LACnWuSxYMjsPomLVDsjtg PTsHCG4fzNkLFoLTOmBKF1yvE4wzdqc7lpb0CQtrQCh2Mg0waQ1CSid57OLr28uSaFqLroCl KNM5Ou+wv/GSmvlKZUXVi1F7M6D29efV7tvDG4+SVEucWeNlV9Llq8aNBehGwycV899zIGXx 4N9oN8mbBaWXVT7t5e+/We8ASZobsNN8+F2wY4ME4qnK81Jo1o9K6VO/fYZEM5fWB6jAHrdP /UhZivgdZdLhOKCm43xqw2Ns5afgc1FWUsDNBn/TFX8mH/sbT1KS4KXKyQsmOAnPnrNgKKNw X9F51QbHQyeqwXqLbn5kv6OrZg2utm4B2QqHV9LEG93pQ3/x7AZBeQiy8vGk2/VHMjsZjP7N GIwODLocP2XhSfwLhoyBT3+D3LLfoOjTp0XxNwwqY0Ygr7F/+0z7DypuzM4MsuRFYYJWLyT0 e2NACIiOFkHBWDe2i0i+tMaJDZ1c/Ov5qcZsbd2ppz6I6GREniDrE05x4WGo9O4EveT8fRJi 57Oxj1V3gjK678wMSSBQXU8w5c3OuTfg2y+Iw7F/ErAFnTwvHMAGnEYkFaCxnKyb+mCQ1i2I D/SEqjcTcyjtZLXuNS6rs9ldtJPKAwhSlvd6UiYsoXCKwie+KIejeHyDtw5gQnX8n8/xVsH4 dBROTk4RDw81/gOMgTgEZuFTzBYcuUsm2oN2A6QMpcvu2TCCMcfDYSRLlcUmeim6QNhepxNg VvJ2FLGD9ojMBPBcHWHimS8ComNfP5r06ORsPPJ920TqzrU+loIEAXX740+rFUtHQikEMpaE 3FCFlpIl9VIpfxeKItUIKrHLePQoxSRKt0uhnrbTkBlYf2VhpDDWKKkPGO4q5bIlUZgQksjQ M6VGRklXnZtrE4ZPYiMmDK4LijQLAs/ONVkXFqz7ZLdZT4k2d+k3XhX9b7diHOb+AmUkldht w+eN54KE/wjbxZ1kbydvev0yu6sy/CboEZNx0/JaNL4uZrJz/0iYub3/R8LMGjd/MNQWLJn6 tjD7mtlmuNIS1arngI3zbUzrlIqm8StNglut2RqxzLDEbXRvdgXp3au6L+u2+fXaPi9qdvf+ cbHDMfFHRPC2kYrrJEFK3uIb4yhSoo9ctAEc+G0/wpsouLXyxAkeWIoPr7flmxc7vyERGsVS 6fENt3ueVAOSDUsvfuADgnyZdhSpDuVcL3Fzn6m2sg9VOfYqpoDQ/mm58llLpYAl3hDQv9Eq iBwD18w3bIJUtNJvFNucQtzUxGfYK5zCB+vLeTAaT7we51d59U0EW/akPboUO1EzgGrH19ut 7fqHT48mn1EgUU2WB4dRhmKKKTGgbb7UtqvYrf55QR+RyXCf5pbMvBgd/XhQ/yqUWAiWgPHH LSCFwQe/Cinscg2YTMy+Hik6qmt+FVo4ojRo/HELaGEku83XO19HLzVtzO5NfrgFBGHMN7bq Xz/QzCy1p4D8dAt4oo/j95s7Et+vQtXhE0Z5bH+dA2Hr/L3JvJVVRDI0LzJ0yfG1pje+hy86 23Znd5y9X5+yWwcmztt12CTjFtnW9Sa2yomz7OT6powcHMrcwiae8JwHxwwEctmHzPjpmqfL dkdiMVb66JLiUUcpxEd4Gi9LUtGp581TDtyOUUb2xmGQHHWqBdc+LbbkGsUeSBBHVYlhIHN6 aJqjEkBZ78WoElr9bg8+8o0FGz7zlturAO/CqAoqC7cJGZc0B3Ve8G6vgshvj8NRCecc9vGz au1W8WerQz16eF20j/pvBN/afMpRX+JhryuKMeavbZBVIYMs0ZiyxqtesVIvmd7AjiHhPUs4 ywbvCeoRTsYgOlX+gtXVNnXFmTcC8qCRdgm9njwBQAxhaYnIj7S5pSRL3P6mYD4zTbMD4FOX 6qore1tOaQLnF7HHSO6cZq7eJAjsvZ9qHuCu2b8wd98LZU20FNtdwmcvnIhnacSTCVqquxSJ L56MGB9UkWV5pPdRRchTZfu2Ihqe4umOMoALBh3/0ldhJbyxqOrjmHRxI82oS12PC/B0Kgr6 QwDMp8d4dh9OYJtI1+XxskwJAzmwZxsZmdbDGvFIhuY6GtThePAGaPam/eDHhsVNLU6JUJf+ wBRGC8l+h0IsUJCFjvHanWO+WSYacZBgT3/kA6ENhMoHZ9YEewcS7OGHRnP/kI3+hnloyv5B C7GWWD2GSul20O9thX7//F7P3Pc/viIC7Iz4r5XlaiV5/6Py7P7+xx08Kv4rx3c/OKwfWBFg nY+zYpI5sdN+S1txXEYXlVue+6iQX/dMn/+yd5e+rg6cD8+fP8uc//gej/+4Uln+t2e308Tp z7/4/J+v/+OB/a5Xxyz+j30e6/9leLvn/3fw6Pjf+3tH+4c78mKHiQHufp4/5ve0sNwdFYuG dkjwSKeKX1ID7N3z+N/ymT7/6VrkV9cxa/5XV+P3f6vPn1fv5b+7eOz5f7i/09rZf+tMfvVN f0T9AYbpLpfLBcHXeOl3QedAK+r0HNqR8+/d6vtHPdPnvxTqUdc49MY39QEwc/1feR5f/0EA XLmf/3fwTI/xre43Z7jdE4tRgHsw2slxegsdUSUziV+MhxIFKCgUUN1oF7a95Ug9Fmkk7xnG b/XE5n/nuIRnY1+54Ys919//VZ8tr1bv93938GT0f/kkGAcnGAn0FuqYxf8rtTj/rz6HDeA9 /7+Dhzo+p/odTzfaZ+Xont/+qzwZ83/XO/NR4XordcyY/7XlZ88S879SW72f/3fwHO0fbJTL OSUFPszDh8JS/2yJj8tzuaO3RxuKO+TKB+/2935cE7DT8ya9cU7+XcNyb49gg7fTeL2lbJcA 7lIvOF5q49fm7ubOzn7TfJXiJpU4aOy7JYZBiAn1nTcuKL/Xxe/br2NVdI75c/OgvuV8Js9Q mPaXOFY/wz+larlWfkbovdusPVu1kqNTDz5QgzCkVZOKPswjpIKgv1vqL2AvX2Uj5S/AviB+ cuy56Pv2a5WdKi2or4g8kLCxt7XzfrvOtW7EAKiqlWY2Sk9HlKZnUahOz4VNmJ4DGjMrA7Vr eqa/xAnlEGhK2Y/1vda7+uZ2/bAJpEsZxqNJz49yubEfjddyD/z2aQiJNomhGA9eHMSwyY0m x9FYPCq3i4/KYfFh/gIYYxvvSy6W2wWDpuoHGCvtsmeTHb+gQzQvRmj4Lsc8JDlg/kKJP+sS stVYgEZhPL8iKWRQvs9iOajfIBnmSwkVsp7pLPi6TTz/NbP8spd78DBP9hDtfqe4s03jcfvN zuZbGsiwCqAxBBJDPPzPgigBAb+3O6LUk0jA28/wf8YZXpxq4LdExi0rSQJvSDT8k8u1e743 WGPPnS36kTOsp33cb+fwH+hO/CO3jmWovhHrWVEqDcMAPXOW2niL/V6qST4Z6z+GDdit31Id s+T/5Vo1vv6vglBwv/7fwYOuD0bByelYvPV6YRAVRWPQLotapfJdDs2heBILNYs3h8Ne0GYT Oh4judzr942dbdHYax4dvqf4Es21XO7fMTwIhl9ZQKfz6NhM2vL1Q3QiUM5tRtGkT7fTpX8B YEwjbxSoT8HY+KJF1ytejwJCkJtmKJ472hdbO/XNPajrFTu2Z07xexP0H+zJmP/HP7Oj768/ /Pm32fL/yvJyQv6vPrs//72LJ6cOgF7/pbGLoSGN9Y/5MuPYF75BEdIXS5cQbLejXI2js0N/ pOKgVC6r3cq6mxPNI1+gYwgedi1ZAs+QoUSVfGnSMTKHGTj1MRljP6mC6pGhK/w2Ouek1Oqq ScY+bHV73olKJBNNVfQqItcsKcW8fisj6TzokE/wrMo6/nlK0rHCIyXtb5P+MAU7bvK67px3 24ct6J2G3m3JZ+FdZ9RcSGZrNWkHtJLSBH8UATs3oD+AMA1cPH9a7FFQwnw+f1p4+fJFQfwq 8r1CIYkccOYeUqEVXYzbpymN4vMAoHBKmlT9azQSfYqjoBV25aBIyYAJdq86NdOAQHf6dhfa yGPIA/gtQ/ck28bxLjjwwZT0DOjY1TgcW2cwV07SxgnFz0HT+uF4lJLcGnqdahraMmaJVcxO xmOYUafldTqjVt+7TMkh6e71gpMBLskphB35eGOJbsq0OHtKJkSw9mn5czqOhGIGbVRYuRbs ubyRHjhkJ52RpdUBdFJADb0riu4SdrvQ41My9PzByfgUbU1axqK+1crD1q995ncK/2omhRnr v82Gv8b1Oz0z1v9nK9W4/F+rVJfv9X938RgX6Frks/yiv/w5aedLrr5meXVX6zUHB+Ogf7Bc Swtf/Cp5AhsB0xeYlNppNhkHD7uif4Wgw7YMUiK/hkPv7xNtHjxpoC/ksd+PnC/KP94DqDaJ zKLMKn9uSJiAkfzOmJLHYXSWjOAxGoqNNfvEglS8LWW5LpQ2LwuMOsW67DAkujVJb8BnADG8 4cJVvNyQqJReKepwcEtdiZ2MESzj2UVpQ8jQPm4i+r1TCV9yD8w9GoBruSlke+z+VXfkc2xD i9DyJ64mfhQhYqaYvrtE1nzUZIoG96lWWayCcP9Zy3op3UD4beCVF90MHRHRgCoUOR0vJOmP OFgo8gyqdqRImJfDSY5l696NJmiaILl42qEYLVxKPE1IrU9JBn0gneVCpqDdkgEuN4T041gQ jwEMkZzEFD0csJMJyssUuLKtKVgVsNaCpfDUXvLUyFEeFrWQV3RQKzrSX0ENJw3ki4JDaEv5 Cz2XX9Yq33HupaWuvNgMMr4/GuFd2p8bRKRaufKdgD39CTn0GKnNeocvd0+pSEtreK8rReDP rHkP/eoJWf/MalCOxlmF243uVJgSYpFEbzEOQ0H8LL0G58oZDj/ULLf8XlcOvaG+xiA9KBNG 7FbzWWoXqO515xHwJ7zsBXm0D07qW+n1hMG2P1XIlWG19lz8+qtof6qyZ8P6E/5Z45878ucy /3zzRDudfPBA8ardIKKovHjkwhUxX8LL3m3+j5gXVlmkmopUQZHgpnXF0iLhfgT0UUoevp23 ulI6DsYCz3KoFbDBkDLlYmFY+LRCWNZSaLW4hD2c6AH/coyePltyLMmO0CxAcXI50vhiCecJ J2OdDu+qx76GSTzQdzwfmE0wX09WG+Bn1RpN4Z9bMn4X/OmvU6X98s/E4B482NBLn05BxswJ +KY+M4vG74/lykCfKVpTKxjAd5oOcfmXc6H7TM5kmsXTx9pIP60WcOWz2vDUhamFbqtmICdA ZaI6tekEzcYcBq67ze6vgnbWO40lPYlk3EnZYSCehKMRoB2bySWHWchgrjY5kC3bNBSv7F53 8MrAiKjUDyJyk5tZPd+UDQbADcd+AzZstfxjrLgoqqtPdzc/tn543ThqWu6b5WXYv7T2/5xZ tQ1uzXLUMAcKqva/tJo/7m213uy8b77DYk7VzaPD+uZuq763nYlC/XLITrLR42lIVwBgmH8z Hx3qdKUd8EjUPLvRUFbGF5xSF32g/h2HY49G6r/wFdh59n9fqwS+/vnP/f7vrp6pml17T3hd WXt9tnS0fvvL9/q/6jy+6ZMx/9Wh+q3UMX3+154tL9eS9l/V+/Ofu3gw5vjm3l79sHm0eXiU g58lYc6Ea5XKi6JzMsw53pebZfE2hD0jqY7FwSiEJdkHSl4VxRvYFe53u0Eb41G/j3yxP+hd YbnNyfgUwyk0vHPIAhC2A5SPzgLxsiPfvj+husrtsP8qp3EDYSNnH0LBoFUjNl0RBRna494t xCRUaRSrN0pPsy9MJFNBMIlcoAvu4rqQHspwanjFNB3clFCN+mgHhUr0wNf6sNsUYrnmJPBp 3+5xJGor9h2wN423reb7N28aH8VCud09KXeOFzK0P5MB3hQaUdx1eWLwyQW9KFAnJP8Y1ZA6 VNCuyujuyBDo9OkAizYbf6l/FoLeN3cab/fq2+Kwjm5N0Q9eAsw0GGI2GBg+ldb5idfSUY3l TZbTC/VpfeoNV6n4oUuu/jmM7EELA+lyA/ENDyBwFDNgo/Y039jQQYbGiT7ZPQdky7iPh17g nCt368oVU76ScUFvehFyqyM9JFUpzMQAI2KAYB9xhJRoAjP9sug6Uhqf+qOLIPLjUQKwWAuL 5W1H/wTS9f3PUE0oNcrScgKY0KeC8qrEBdwcEojthtbK9nLDQJU6mMePhYpcgmq1x5T+ydRd ssp/LgoNn50PNcb+iF3bUiAHsmlBE+qIQmtDJxrvVGTwisdZ0pMturDFiIMmpAV6SrzCbmif WsR2JmOcuBSykK1288Koy9nDhuW9Fh0JktTk2lLqp+gUXkR0ijLUIkpcslNw344Gexus/dbu mUr1vf363pFyFoWhyFUYMQsqanJP/DEfquYZQZbsQtmpXMUQ4csdOuz/E5Wk5cOYRTpfY+/D 5o4V/0gPQKin9IrdiThULZiALNR0VsI5CtiKCmSH/yrN+xBGB7aD04g0qihFhpeBW+yQHdhr oxD+ZQYSAH1UnBPp241j7chQJ/JqZk6HqqK1OGFGxT60kIcIZH2x0sqJWhCJPgVWwhAfAIYD vIy8K+Edw7JeFk0fTa6iEKOZAHgZz4qD1eNo8zqdFuEfuS4qxWl4gbGYrpiOblqgL/0vyqNh VJ87twUXC/kY8y4USq/UYbcV0Ih1YDz7MfS730l1UIZ88+37evOotbW7vdPYq+Msl5XLQDCQ 8+nTgEadweqxyYMJWBt8TUIrYaNyFKtmOxw8IcKg2zC/PxxfcQ9HOnSOnDiKRIBerWCNKkjm liAPUx5FJR5FQqEoFiTMjQXt3U2WebVBWazBX3vdeLuek9jRQCFXnjhSzBiMJKMaRTDNccwl Rwr1vBeNyzZ9q0xf3ZYSfkE6yvlDFIMH5obqHsskAM+krF7TDRd200W87Y++7fUui/Tv+kIG +xLotlXuRAuxRTT4XA46Nysn1+2swhbPmtEdaa7rpl+gxVPHWFRRl5tGPplGgGgmscEzKZ2+ WIiC0qt+2FEmLvFZKYsTJ+MOkPlJdRvPrTqcBPCxijhGszBsXUb2h753yXXyRx6HzckQCSnG FyE5ZoyQQ+GeE8bmGmehMmiQXnIZIQzFhcUFzgMDS2z21CiNuMN4lRyE6FyPIhi5eT/sRtCY oTdBf8QeBkKiYh0OXYUVYzSzQRtSkzV7dAvaP6FAYBLokZo51mTxiCFTgMBjP4EIltoz+BGf HvXZnhbjCOputwts2aicekAFUSrRjgSPZ0qlPsxNf1Rip4GPOgsCOfugQ9EIreaTWKYJduqd ++l4RP5YCirBSC4nyIfdZiM/UK1m2ifanlx27EY1xlEGGSLkoQxFZ7B7YwZpJH8MOkUStNVf EHYNYZCNGTCC3Rv3uH6o9qPBC2B1eHEWsMxGQIfIEGJb0pKGXQOdkEIWZLADa+yj8bIadVRU zoMA45pJCmJZzDf2zkDO7I7CPq/lMhokIVZUwgOjZlMUSIZBx9QRrKS/1w+J3cPbZBwiddsU 60tPATkUyiq4LM57tdLiySJGPlvUh4VqelfZwSuFbksrBYzvCQe8i6eAyP3kOw3P5g7xnCUE YdWTLFHTnBTazx6rt1+T7uozx5igpQ4t10gKivDyycjv+iOc32UVp5JjTCLHbe2ssPcBJ4y3 EyMSY+JZASKByBxhzQIOsHUkbytapHZ90Hz3/mh7/4e9VnvkRacF3YZYA8jttt/RaJptp9Bi bhSQ9QDQjVPQZ2ilTCtG2O3qgMHUa6oJsWoOJxxLTzEeZLnIknW9DvWzC2MgIqiTyq4zKIq+ jvyILFseUVOKpgNNy9UIkusNndi7kdN1jeqI+nBzV6DJ5Tcm2uhMAvOGNrZ2vXT0IapW3urw Rmrd+qKWZ7YDNd9jBqKY0Dlm9VSLrkXhP+Y7mv7S50X2Kr2e2BzRKSQvytq2iKozqz//6By3 uy0ThhknQhieyTAqae6OMZcV315uFo34ULRlgaJ4bGGCzmIpezKarNyNgdAE0+EsJZk2YWZf Fe9Wr4fMH2aU6tiyHUb2JISJ1gkHvrPrskQWEDDzNslKwjSosC4c4WhDWDkl2WLj+g15Cua2 EtnWxCO22+JvZdw0an/31IU4Ke2uXSyovNLsivueOwu9+lp5W+deL+jQ4SsD0/XEItzr8m7c WifppRvRNpPQybEhFNtSsDT9E1F8rwc1IqhZYnPicUhD0XdbEcxa3cSCwWvq+EAlKt0fxM6R lC294pmoZ8sbVLnwtOa5HJ8g2IYW7uXzrkAtHIm6aAvMmS0tCoWFZCSsfHhss5XY3HJ7Okb3 PzPePy3A6Fyg5b+LI5dGakpN2fNJUWPbV7pbIY/eMJYpxmbC4EwaMX2iZyPOA73o8EgewLFw 06mTrb7zxp7x1HnMW+nZEMmqknmVdU0CBdlOI7A4h5i31wrHMC0Lu/hhZ0rT5p0rKXjOXzRF UT9/YWmzmALDTE9a1+PN37C32G5s8djoNjKWpFgaeROD2XCFWA/VGYjfcS1xYwimjcCNNFI5 Qypjfr72XN4ydU1zOJJaBmkCgrSip56a1kriwHmNTIIVsAqP34h/2RzMRgBYmCMBCWcIpAVa jxHqkEtP52R2jdP73+5CvLhFsOnZcEW1FEai8qvZ6uZPMJNfptVl5LYM4JV456PJFh6Zopqi Q4pX3qSTLEcivlnbLKEfREaA9j8quj40uowrJnhHOGWjruNImzrU5ltHI4jLz8gU0bJU7jH+ NPcqrx5CWqzFtG0V1NJJAcse9pHfnoyC8RXKrWNSzceHfmxkNWUBoQogSeWeWpmIpY4j2Sf6 DlGkIinJuYVHugqL1hidlXfy8tApC9mCGcvxJJhBkQ6+NNfab+1AgTVNYAvabGxrYz9besvk NHvhRZG1XzC+PuymScJNGRpjMlSjiPQcj3q9yZ9fo9au7/fD0VXZsFKWuEqvyG4VZNrW2XFU sCnHG+bWeT+f0CPiWPpTyvnv/INqLX7sm1YUiQ2oFq09NfK/VK1wwRqECfE6s0vYBpUpdr0+ UROuQ9pwmKUUjIbPhGDSfmgc/ofGJ4V86q4ABvg4D0Z/b3GA4FHe6RvpfB+BoVfnVv3jVsFs IA9BCBx1SNMJK96YN/hGN+cdhxM+ZqJqlT9wKu1OYhc/nNGo5kkgYlH4mxn8xZDe9S55MkGJ NArivac1JY9jw0L1w3SEpcIfDyplBTBzsXdafKDvdN7Tp25xR72hVTCsrNoNO76orgnykMDq LP/cH13BgADpGki7EPY6C8CXgfkH4Yh7NeUcLXnWFcPBPo2xnG+jDXvyVEQRJcYD3pOuUGpz NAsgNXO5zDO/owc2z3GpXpTg852EPEDTKKZJk4VULUphpAp/sWlXW6OjVEc3S+edxA9tfTOp TAfqSJTOr5ylG69WJE673LVRnXvFu6AN7L4VYECe2KAtsYI0pcuy5u5LvuyQylZi6NmaNss9 BppToj4ez1RkrxqHGzCaOD/SFz88Ucq+J7iSncxeB7lfrRNftwE3W7nQsywpWiwFvjonjUSa FjUDu19i/ACXkMCa/cklRYtJO/7YPZE/G4QX2KHEx4e+d2YO5O1+KEuE4kfZVLV7Wk2UGZC9 a9r5scoiw6UpWLa4LD89fWrEXgBWKsW3PMkTY8hWnHVWlFDN5AFGwWUQcqxrnnitMoEzh5Xs IeckklaW+M04GmnIxCtL+WxIi+GqBxP/j878iHg48PGANIbktjmDw0svKBD2/LHR4UtqqRtN 7VPYxSp1uaB/6PolCGZRiO8VDiIGjxVAjIuFw3xz6119G4OISQggTuEfqWhPSuCqIr6VARIn CIZnQFGFHevltSaAkvNOHFINazKgVL8jzybw4DzLd/S9y+h5nwz7b9Ty3ZoTaLSHvqb/59Xl lcq9/+c7eKb1P6l6yfr46+4BzLj/U609T4n/9Pze/9tdPFMNyKOraAnFs+RXtDt1v3bbg5jF /QIbrsurQ7QeSvacY5moi3xcLUwAUETKckgec8qrQEpPx/rFoH/Cln7ktMEf5BdwnJaxsoXi futwe39v50d9it+Vu3YxpNOk/EJXL7tYmI6prBCoXRkAVSp6EKt8F3UGjllAJsgTf8wHX1gw suBigxiy8igBdB3mK0URlWlzieetB4f7Ry30qlcEQfGg1Xy3eViHd6i/oqvPUxxw6TMiCw0A HW8Yi2hEScZDCosL9K2yJh4NHecUcetdhbax2uXDksfQHdYGwEbvlVFJqMqoJNZVFI96E1Mh Ghg7J560SdPnySkWc7/3vPlneWL8H10f33odN1j/V1Yr9/Ef7uJJ6f/XXuS/86LT7ebO7YyF m8h/q7Xaff/fwTOj/28lDsgM+Q9TE/LfauX+/vddPEudIBrfr6b/ss+M+W+9l9vesde7SR0z 5n9tpRb3/1urri7fx/+5i2fP64NAbh6rw3Mf2CWYTq6Uqzl1h1s9fDecr4bvwkiii44yPeVS d27LG/sn4ehKQcB6mleDcBgFkfq2ORB1+E7a4C064CbPVMqrzK7vRZORTxfPEVU/ym37UXsU DPEoCFWk1IjIw0YIvvMaCQ/e2j0PrRPP8VhncDLB3STWwSYBV1jJKcArHXtsqt8PB8E4JC9v w7AXtAO+rIJu0c+D0Xji9WCn1T5F8GUhb0VIsMNReB50yJir77dPvUEQ9SN5qoB1kebbVy1C p6ZoSH3ujYJwEqGlwDiSN/cAghev7kmkXPEJcoXHtfNtLj6YRZNuedGGrzpchCPUu7IKG518 0dXUovAiceH3evh3+4fNwzdApePJyQkpvQGroryDig7WsTHBGEgRRcEx7HGhNRejYBy7phDR 3RF/1KcGoNco+ohnPNFV/zjsRbT59CN/oK6ZiCicjNo+eeJV9xUl7YE4QMqTkdcvCug6vMBC R3oj7wJJy+RQxEh2A9ADAwnTdRKoC0bLGTRWN8r36NzB3J10G0LWN3Q7Lhz1ETFZXqEUSUDY RQOvd/Uz2uqcwPAayGvSSOfjYOCNrpBYQzqu9Ol2oOp5HG94nGJ1g6eKkCKBjxzMFVEasPKE auSTURemUCvoBswpHgeOJoNx0PfLuRw57i/hVXWeXc0AzwdgGgIvL52rCf5qQ1TLtdxO0PYH EeR83dxezsFP9MiP9mcw90KYE6U+tACGzZrDJoTYx44xiUJ82C2K7eMmxt4RHDug1PHx6k20 xtoEKI4O8YqkBilib3sdqK4omu82i+gaDlGqlGvLRdH20b20VBSwY8OcOrwhZgPdgD6Cu1uk PCLdU6kTjJidlMsqCpCOIgPZ3r7bKoXELiTTKe3XROkHr9f7V1MtXGP9P41uWMfU9b+Kwf4S 8V+rter9+n8Xzy+lb8XO5t7b95tv6+KtD9PJ6wU/+509/wKZxrY/Cs5xMfi29CXHEzw29/Oi VBKL+DFoiyMowrx+Kxy0/eGYj3Wb4z5yqCKdTgJXs99/AAbXHHv9Ier4CBTCxiqbcu2g3MjZ 6CUc9K4OgOHjpU1ZYlFlRYaDtg5o3zficlYK/ZYLEoMiv4X0OggBpsZgJ1RLADZlU60ulFOl 5cvlAn3ohW3MYZA59E802vyODvjwb5PNbfnHDnliVL/qg46B0LDMr3bJyM4BeuKPD3YPFGj4 xXcBrA8fdq0fVGtj0A35mwYBC+QRXpCLrLzSGFfmVPSQODRhYBgMTq8i+H4gb0TGQOqi7wfS z4DJOJGfdJ6/+KNQbOIJNKX/DD9f++ML3x/EfysqqJJbMHvDvhENP3i9CdVSKnGWX8V+u+3h IodXH4valgOFD1jQPUl9Y82o7lK6EgoDC4//BtXwugwrOEqE4x5GpBnD4s3SAhqQ9PwOiB5s KheMI1Ufw/DQh23fkmApQpWUW7qTQdvIUGjzJ4evkieh7IV3xZBQEOiQ3HuM4ySaoKsQIgSP XbrWWZSfrNemEhjcD/tdnLzOZzlszLjcCS9KPf/c7+GIGIUwIiBjZNcD3+kX/DVTDobNfjen OmRrMhpBw7E3LtCISVG6P+mNgxKu8iAHYzciEXrBeIzUHsBegmSfvkfmWEXl6odfMGBCUdvr Gld0BnXYRwCZrAnFqBN+1H74exYYJlS/9EhQop8Pff6F+Qsg88HkzOVAkELx+sOuepO2WmUd IwnGQ976UYhn3EWpR+QBHky+n4MhssLdFllu7bZ07m0Qw8vbwQkech3AqCmDiCTyeCuKPwLi FHHNLVDvddXvv8POgSyeOaUpL7mjrAnvTqnXOF7z+fLjcgHBBt3xoQv2Tdjr4AQX+XG4E0Rj NxXdrucbSHr3O+YUebySUERZ1h+NX18hH+gCtJGbdde7OgboeAWaXt3U/VEHbzL0YYMEXemm HY08lGcZu24Yg9uEhYxWNliwQDo+QI9D8PetT/wYZSDymE2/ITFu4SQf4nI/hKPOC/1WXUUL YvljuWb9WF3pZfvYge2BhCPfGI78wXDkj1lwdryfr17DtGmScJyR06UGghV5iQDXzn+Xa/zX 6sG9SR9o1+Yh986/1AnNq2js98tb8ioCkG5/OI4l1gewdQ3ZSVwe6LKJHqZieRr7In8KNAf8 dwY4HdGpazJTeXfXG4o8bhjeAAc2LY5nrV8G47wP/6CFFUyYQsZEMBCYRDgfZmYtI7Ux687s rFun3ugFgX2hMu/KjQ6MwkO6gHZUxNveYx/+NpJG6CBdwBzcraUkeHhBCMSXqEUDjt5TssEY 1xXBu6oLXlOrmwzQhUEiIcaMcLdV3kIeg/cdIh9eXtOeNTWfZpVyR5grsQsJ1M6UbuPJEchf xabamCu9gtYD4D4ZeFDEa75y84G/yJKBVuJoqYxgdnEZGsojfE4Qfe8KbYGNexC2CpTqgCeR eNIJnwi9GV8DOAjqFV7j0WCq/EkI86mW/LQsy9Y9WM71V3Jt4VEkJKUgIZ3E9yhZi9H3RcGr kvh+9L302INA7Py0pqr7IngJTnmL4hrKgschNZjKolLEvYYkT+AZErqrQNBYBaORL3xflthj 90JBT2ssBp70PZSGiGc1NIgc6qG5bmsw6YuXpYTQmaBdBoXxa0PKU3IhL7qNF9/HYH+v8GPn R9LnPoqAXTGEfOhJg3CLlK8NeeOlo82uYyo72kng7TVJXF8G4BDfqyZ+L4VApo/5LNog+RyT +TZ56yqhG7pjHotja5SCvDfgTRvtt4CqG/yS30aVHnMBkZfcgOQflO5EnnmCOPQuaP/U6BQK wiukrCMdtRnMv0FBNRwVmZ8VhSPl5HKkz9QVbOhXNEfFtgO/QBYOINfWBEoqyHrge/OqD9sH wd+bpC2k7QSld463+FK+TGdJYVt+pSzyvp5wszTLzur4xbAL7ld2Ua4ne5x34F0c1rZ1UfsY ip7aHSIYmdtRx+opFxsCrHVEHa2PVJS7gE5ZzRjquydqg/lEK5EFbGjJc8kYpf/IIGP0nkxy VTSHt182pRtKXs6tboTa/hN17GoLg2SgFV6CQ/n6V/G2Fx4D7sJeIU3xI6vNxFNPODureBlC Y8CdLCEYQOkQuKjU19NIT45AFw3WebLClR1cyJ59K+36JUhyA4P3OsJ2QHOUlKqYQSnCdRc4 JfAyiN6Tkb882mhxFprL8npAMDK0A0DWDgcr0YtShJtCdOyCplIXiNGZZhcppEBQesgk96QO rtD0yMwXmj409SXRS6+0VGdnUwzCTL2/dqGZf0XMCpKWW/KGYQJJNQ3KOakBwVrVCMQaCTZX q7PAX7EBHdtGBTD+CLvUzTBYL62+faXWmktKlWPxUqf2zkAS7IXh2WT4wRuJy4LMKIcc7dAv kxkb0i2FzM8bORpKb9D3zbHXPlOeDm3iQhaE0xd43QcWpf4xLkeSdKMrYq+in+CY1EbIK5vo PIfkXtmzWppH4u53Uznvjt8dixZkTpsSJfIoRsc2dA0KBh1sb2P4Jx5oBqRhOyKHz6Y9CkMs AOJ/biRXCuhvWE/kD2iJfC3ozs8XdF451Mosssqx1dSHYR6pUGCHMel1aKy7LquGXofkNp6J NH0r5Rwp7WisW+o/rNvS+XEetFyM8KYQpODvDexw6J0v0xFBjYDFY8xywY4aaH76A9JNKulG 4ghruRYksQnEKVjfiNc6J/0Jxqso5+SnWBtkt/4n4ZVYNli/2VGXkMzkdsbEf6IPboStvYkd +ycB+2yS65PC1QJkk07iBtPdop4EumH/iMRTyOPSUgWJZuRP6ZiWTr4G42BkVQ1FlJ5Xi5N7 +xj3hCRMmK49xbArmkvTMZfinGZU4BT2cax0dBG8vAyU99gX6jH6FYBtSjmnChGjdBY4Ih2e ilvHl3pexCikoJAjhg2trGNK7fFH9pHgkK5StAbi0WjiG5mkIW2n6WIUqXeUjs/I7DwYVd3O maUlkSCNyjmilDu6crolcopSHgRHHg94uj4UP0VyNtHfX8xJ7oZ5paSm//fyr68YgG7HEQrb Rr6GtdfHI2190uocgKrppgzHUeFbGkodP+pMyVVjsumoeLVYRmDRTmWRulc9ciRUeftQ+9vt hiC/X9BBvztOlFhg7U9QEO9Oemw5oChxcRpGRrMs12tUBrO8PtacjJXFT/DC4xkdodOVQ6LL IGRDgJ8WUD3uYSy1Be7Q0jGrv3V9wDjMMUhsEDPjsEamw9WtfrdB8AjO0bqAp69mfTPSui0b EKyez7E+cOiXObAUDBwoLmtHJQB8QL2fjQ9F/iIA1Pl5Zxb9lbnOX4lt4TkIiE49jigih9Y2 mXH4TDNPOzk26ns9tnhrpo4b5Ll4iQ/GZcdquZ2HEbEPVN736OpuOacLp8k2QEOdrgQboB/C RAJaMg83l1Wf9Us8GKPb9Ji6F45P6SxLbUo6xpbF2bujhYBsGy0msIoMYZ0P+z7Zi1gOGXgz YFTwG/SOa5mUxlA6h098bBLfH1HSvw9UeQ0nKQ7G1kPc/AwGcT4l+8VhU8B/6UyA9miyGr2K qbQ8o3EprigK9YY8R4APT9XrlZ2XGjiQeQd2imzncVTAOx32uMrrcQuJuVxf4gJo5Uk2O0B/ 5/CXfihCqFxd2mIb+HnWK+OdE68A0LivXhNpAOKnPLevKHYsghc+28PJLrKBO47dFrJikg2L fDUDs6cOpDw5FOBMeOXGzQIISCEBW0L7YhsNG4lU6P3j15G7Pgi5QOSEWiJ8VYTDebGe39LX 432aAgu6RQIIP6wyEcmOsIRgG1Q/JIYHvmlSJig5fc+on3xWZxjtt0aCfTjSdeWfI7N5oc9S tFejr6VYbP7nqCjL6MFKzVPZ9ZDk7HnpiGmnjMNz63QyOIvEp+Poc0GsiVmweJKoqpEp5y+j IpWo4ojXLbmUYK6m+BjLX0VFWBnlNNJFr7hoFZBJLwtSB9aKRSWnOJBHlm0+o5U8jHmyZtFS HGBWYXaU+jDR4bu8tP1Aik7yIMC80DLckrWULRzNxBUaANRq0JFgMjBJXTkNesj2gR/MZP32 xH6I8wD+1cRFAFTy02ezDNhKaq/zN69NZ6QpzDSSixkH14yCfgDLIwu9Kqi5umQHnbRVVqGZ kSVJyny22ZtM/vTZWjcq6it5AKZju6oaelEuR/skl8MoYJii4UDr2njKvGv4LP50JzcRWZV3 so+vxLnaSD5kgqNJghjQNpZmBoEbX0kZl9d4ebX94vQKV9AOeekP6DzAjUvq4TW1fjCWQTmo PO1HaOvVpiv6FzIqAr4HZFuJlpWdEtbekWSW/qCPgzFs03odNRqJawwsbUDV2v0/1KFr+OxT r1DnWh1QS2THU+/M7CuJ7OTKKiv7i0R2CuWWlR2VEaRDuBwj8flgHolPux7VAeahK4oiv9AY kL9TQ2nBpokL4ulTFMIuECJwkDYbJahRYkaHGi+fpGpLM2xnHbWL08yCodOlE381U7uRkXEx diTI7W+otyCrbCUdw6tiuAp3ixcFa42hDv0k8mERVrVfRX5QlDs8+oBUAcY9QC9GXfHZ0QJx kTWmomEm+c0xr464ny4A6375UrgTQFwYILEukE2Jd0SKNkn1BZHSITy+L9BZE+xFaPBa6V3U 7DOyW6h0c7qFNXSkYuuGSVZJBaDn2U+P7AJaQQFzp4n5EwWJ0MP8BSxpdhzEWIlKG0Jnpo/S b75mt4qmmLlA1eVyJ/5YahPNrkmh6zTCynmpFaW2ytGC1SD5CjdJBx7MfII3D2Stj0xWYFSV uZzUDEIVCTJLkVnmQM8pmkSXSfrgAnCZUHlZyzGfPZF6d4us0Vm3DAV+oOAvZxPWh9kHiyaj UTVpI3Lev1oOxNAM3Ld1APydD1RJxzwcUjA5CqUE1agjxUaXGbXWx8M7bqnZstuzjjPkno6d P6nTNrsyKPm3SWSv9zIkNTVfSR/xLV9shdJjGxf573GYtWCgyim2IVwRQbs9RRYqi+XV6EoW 4+lC898ahbqgo+Wm0tMK6pEU63i30yOtT+NFSx5EEBt1D6jU+TNnA1p2fDT3p0MbujmhVOh2 bmlj5RxphMcyKhYNG3PvwBovqi+aWmQxwqAlmaFUpxMsxFWHOuwvffFgIB/SSJEs7w4AiRz2 czfKOt1gVk+cd8EpJscwiQzeQA3eUqnUhs10ODbUJXoupJ+HECuNDxdMSxyIJHOa8aGMCCgP c2phr6TqiIKZciqn7kZ/tFEmD1F17LUIL010tKsxd4RJAfJWxpk1WmInqArUkQwgSIovUicy NGZ76cDmHboSVOoInjqOJQlw9KLQpAWmsTTBOCKr8K6W8TK3PEkZjEZHzoKRXILJBtXKoTTr 1uJoJ8X3mmmjTQ2hgQmPVnLCo3kII3ZWb4aFNIJlDY6kfZrIGc9vKKcoZJtio5UJWY0TqVLo b+SWBdu93QLTUG0WpAz2wt5yqbQNoRRVytaQy9GuQRasrsZLUmqiKBoncmnaRMjSy7V4aUpN lEZrRi5NS2DqRlGnJkqT+WOOB440T1enzfYJcyz1urpsdcY5QtU/9s77oZDO4TGqPMBBlZ5V C+08M3GgVImDfVysLFQS9ScPi1mdFzn7Mmc39lBY2ktVSqqTHVUY4dCU0jbjoY1pEojIR+LT tLRc5jGVaK8siqvpMHOwg9DxPMpxBsS+T7X+0H2oakko2sVEqUhkIJKSi2prCWsFpmZJJ7sa zQVWvnz8+HHNaQZpW4DeGAlR8tcAWCrfwsgYiipFDoGRJxmANUTluIvclKZ24586IgHQUyhT 4N0H1OIMQ63UVEpMK891J0T/eK7hIsdJOz5w1emhasWwPyQ0sH6jvbS6MKN7kGd/2HVjiyxQ 4xO8NKUbknkkGYaqQ2RHMTZ5MukrUvDVgskwo0+G2CdsDLjIgVtV9+jrMFmjxM2g9sXe9NVC IRFhvctQJ9bdpDAVNAVNBNCidildVD7kczHM1NqWPX7crNcdRujjVRLSaazblOHYO96b9BXH bbJXZOC5FLIVfeoS982pfM4SYt4S+Kv80s3yAA/c0U+kWLHMf9DFr94xd4JzkccjpnzlcoVu 8nHtQv9cFHYKXhghiFhVJPffA/+iznUp0NSMp7qnsNMo/1PxrFqT0bDTTC45WxVDyXJT3oQj vgQl28RVxUqiI+OuwmhDwaCL00Rq1EtRuQI72jINqBoim5oyqC3HcQZiTOwIOzWCrUyP4xpX xSexXBS1Irx9LugdR+8c0uV+ZgPp/1e+fPJXkQfyPIW0RfEddEL5cRkIVtXNJZjDkX+OejZJ yjz9xk6DggyYxxC/q5MUbCkLj3W8IQ7rANqjWwbk0robrXKvhnx6X3RVELTPUOfGE96T9K4E 3nwsKnmTzBkD+zBXKzC+x1snZDIt3kcThu9igQJvJC0FTm3LaGlQb9/ExO+cSP5gN9T9SvFQ WkWn26KnGaMnrdGPtL2yZfeu0bQNlK2YBLhNK1HARoBgXXmLeMMPhbT5JWxU2cbdNcZwoj6i IYjyD60o8T1USh7lAFLrTWOnLvbfH9ELporSiMDTJgI4o5QpNsw3tfRz7sjJjauUlRUedrVb Uq52E5Y331vU4ugbCmEVRXcg7YqstsudqjZAQAAj33MombCY0Z4OwskYHQ2QsQ15Swi0xktu dLEO5fBAXpmP3JjTassou2gkuDXSyUAmDurOIrYh2XWswkE4+eTFPjTfcG72FUyHyo3rL9Ql wpxE0MKKBvHrMoU/jKVFWfRJZ/hMOb4QZi3GozVelxWM5Z7brUbXwtdBVaTc1DQUuU/Hsg6J xHq8+zUtZb+Spcs4hGUQXVj4HnmfoLO8kbx8K/kF8FS+aRAo2zn4eiXYIkhlUibLmE9eicVR VRFyOyDvayjBFf1cYHRdwbACIHmbI9Xzoac1PzXC6lR0YOxn2DLGVpvaRs9NvH86kshgB1sm WVr5okzepXUaXt1RbErLIGThgHfCCjotMuyMTBfovriWHD9FnzUYfZs8rr39JIF/TkA3RXoZ FbFlRa8gIl2PlarvGcxXnVUStnuRfSYVDse0G5BU2lfX55W05UshS0pJ9I5llCjePZFncUZg N3kE3dTSlyVQ+OoInV+yRjbY5/z5n2hqA/7JK3c862UHWNZgGMOiz0bSaKuefo2yRW1MTTKH cicZhbXwC4QDXHxYfmhLUcgZLPLRuD+ki/Vk8UPX3vokTxKNRpkhwPF5SAsl94M33KUmUS/N NC2JSEU2zeo740nuYpVR2LwQeIDSFopepRiudXIzAWmyjotRnJZI5Ej5KYiIpJPBz8GQCCw3 i2SplB/KS5xo5q3vJ9MPuqAsJCwJXt94hqE2ECNEXgPIL5SAp5jDxwEfTcLHhYJ4RYemPVjJ FPMbFcSn6tpagwN0i3JZfNb4ytqaZXJWxBOIl01rcuRHGBd6pODhADINpmNPuzrUBfK7jD9t TfM4ZvLvRrzN5BKXcx14AUxBFOSkBF2B/62pogX1Ym1Z4oWP/S6Gr+D7CTnVdypW8shGlfdW lzoTysYingl3LwxT58MAFmSFR+VLWI7SyAI+j6no7xemj+7Dh3LUYQdKtrGA9iBrP40XIB8s iLQpwn59KntaqAh0ZiAMh3QGCp+GDo3ILnBDLOBKQhAZwGUM4JUsqfxQ4C4UD82gJC1sU4rC DrCKuzzobRhYhAPl4j0e2v7JG9HwbWHBTDFY6xYqlwRl5PO9OBhyqGpV67NXoBDZkMGjTcjt PryvMT4L5twxYDNpBE/bRCBz1AIB6qgrBQsOPa5R7wLbPrfQt9eCse5l0hZmFkNL1oUp2WiV SeayTZsX0HupzpUNCq3OW5RzIdGm2MnrQue41O+X2wtiATebrTYa7AFjypeqhd+kQ7XeADoJ 9Rkw+F7B2NGfN8RK5bvVXM7WS6ERq9YVe0UuV6CCZNLqZHZVHxouqz5srYV8VZc8D/X1HvmW E/ZdAb7I6f8dnU4kXPFYpp/IUI32JmmeWhCfcxi7Sd9AbcLMU/v3/e4YHWhcyHshCRcv+rqA fWyoXO5J8dfaiW6KJxamT9gyLGaUDXOrja5faI8EO3My8tcm5BipBbe08sSJPK5FY5IMCE0y PtC4ujdiENIxOqcIHb81gX3zAHdlZFSJfUIaCfQZh1e434S0d9C3nC982pwrp4OB5ZDPoFtR V2bkZQhUqiAU5ypEkUw3ePpG1lmqvOSDShx1DYohU0PwxpE0R3fuN6XeldGPPhacKrY4l2pM SW3iPqskXr9x6nwdhtMFpS8ZqbFRqeRNvtts7K3VVWXzpZlmga1mpyW1do7bKK3n6UO/YGwM 0KRKCpp5uiToj0ZFNETRunT4l5PljcOikMleTmvfRt6FMDOY5qvfH46v0B5VtTFI3OSOPc7F 7g1zx8MlvLlpukE+Ja1L3tTSPH0kguiPKXpR+zY4xlNvp2Uxt8E3UmV+053HtNbBloM8VvCt eNexhYsHkn2DfWiAIKPdahAhH1ouN5hq9MW+g4/V9YF70WJjbXzlB3Xcje/5tE5BXfgvpRzf lFYmkjcZarzXVpzbgne7g64Fg44vLkRzDbrE9ud+8N324CvhTT1rD20GkHWfN28vwcX4lqeQ i+3B2Sfrr2Iw6fVwCEQUMhgWhQY5Qz3vV4vwz5F0Q0c+oeBbgcqEqBe7CCLqPbZPnQx65LgX IemTAvibP+9XivxV2aKjIsrcV8kP/At0QAoTxblfAvghHKhTCraou/qwi8fqBATNm9SyRGdP UJHyc4X7FbVyEpycUyXKWlOkl4QBWZ7w49TPheQXF7p7Y+a8b1qfJ6ISrWEzgX+rMVLJZLoI wldysI42G5dIubYKLc0J/WND6TBeR1OP/vkOi3bwV43ltOwX6tbth+OIaKcIbQZe7BI3dAz9 m3N7RRqw0Y3wsmzR/rk/6nlDKZ2QxoNfqUaLHvKSq30hMa/FD75+xKxD3mo0VxlJ/I3YkR7t mO1EqpFg8wUdyANjREbMIaoQQU0BsvChApq+zXdHrYPD/bd08xka7t4Eit2pxKKfrYLywrTg gtam073sltIcPNiUgMZ252lWnl9QlOJtsU2tudVT2qx8MpBeqVHajBv+48i1+g1IvFPujMJh vBn2zXPss4KmtgbAx+lZXeSWJ92C1+EAnTEDG3snRLei/toPO3+1dkFUFPiXEihpdD5+rAAu YTzFjdgwxfGTt7tJZtbRkmx2KHCoBZ2cPK2UCwKfaqzxAcULef3SmP6hclndbIU9aREF/wFs SgpuAdjISPeXbZDyx5yolE18yGLnlRBTUlitIQ8k8NEnESOtBlPOS5zjhMiU2YRFI3E8VOLj oTIJS7aCTivdrUuBsfWJrfPsu61TdHy8ouLtzYesQbOMzyxvhLTDp5KFtDxmjLrNR3sddZ9E 1/hQ/KSoI42g0C5lXpAFvaiw7hUKOs3X/ZhLpADt3A980TWZ0Va3tVC5J3g4SiudeP41duQq 8TRlF6ZDpoUICuEKZTefvr965XxD9WASmKPbY6NJMQewipxTP8Rd46MUCYSTrrSMOLiBesC4 RS8Z3+56w0hvjtHLP2WIJIiYxx3XI48DQnrIp9t72utwTp37xO6YNPbJd5ZK7bLsq0RHdQYw 4/AGSGAvh45FrlyY65qL5tKu8it5AdOQ/+xjHHPDeSOWpaYdh1gyhVp0doOIboRIoUuuE2zy mwmHDc/YIF7vMyRGcuk3ePEqRl/ZSYdl/feD9gCDVlPope1D4/Co9XqzWRePxcHm9vZha//N m2b9iIwCo3LOtlsyIo3URdiJsPMIBkF/0gfpJV9ZK8AfjNZHeJ2gqcCHYMTLV9n6GH09bnWe +WmYsa1S37tM4hVx/ZjDxUffFTAZIkVftx1o5GQ+o70vCR84+eL7LUsYNF8TuXDMBbRrwBDR FfHrr5YhLAdGjC3kgWFaaM+JJ9U80xYSm4/mizKGY26fxYYZGtuOAZEfOFA3LuzxkYhZUuSV oCDdBWmaqViKMakub8+uhTLwkLF3vMCbP0kr18VXklb00/LnlLbLZbhmO89ecHG/NQ56ddqC o+0hlSroNZ7ayrt9e54eex3H1ZScqHKW8vb/kvYAP9H1E2slZRAP8RyGHKUoOATgsqDM/cUl ACjkLCl+TvJd9Q35hGmSOSIjBvayREecSJGyM2gKioFarn2pGF3yZ5NGtr2HZSXlnUzmMSvf qTMFtDtfivqZlqAOY8l1EBUvKF33ISeled9Ae1nL/+TB7oGy0nCtZ0mRi9scZZJrRpKtNkra UloWvHiMvqHMZdkIhgxQ7SNKMoiFTMo15p9hL4jl2NjRNoYkW72/doJzS7IWBqpaYKDiXelJ EXGQY7K+2/r4YrXFMuAL9Wn5xSotzq8Eq4LtjYc1fN9bn5WXxvi+xCoquwEWDFifYBe6kctZ swbvZ/pSf4svn7zPdvJQjTy6rq59TucocCpdE67I2Dbcx58+S+NM8gAs8sCTh84sHRbUrgDK bjldjJhZViTybE8af9gJ0vIEr0CfQE/KoEBEnkhZQENGGHd/nwRQBq2ThIycYk0QdOvM3JAd CMPYlUoggvNQGQhoN8/Ky7PMgvNmEJ5IzZ4UJ3q+rX/4xGtVEU3eUJ757FyMQEa3L9HijCqf oKYpKK2E0FDSNauRiz/ZhiWOLpAfzQ1JR7eQZXm4oOjjrg+WQ2rotNA6+AK8KX6V7J83gO9n nQE76JPgpolPT0ZPPotPC1K5uPAZ3bn+HYgv5O0BLCsWlNHiAmOwYF1wQNWkBhYRMNyyWpAU D0gHNc0EEhfTz+pg0ALCal6Dn5JhUwS5X93qdc6c3b8xMdh+/2SREH+rEZ89OiwNosh3/K4H EpVkgm5Om7dRZrtJ3WGBrbfEBv/9RdgWVRssmnaHpPal0k47dXFd2rHfsou79BVq4tOxq2UW JoRNJup2y+YlJdUxADPbayePg1RqHsDPpeGUvpKIT6N5ZvM25I94wzZUyUSbNqxDhWKcvCbp i2aoc9lZ8Bm4vRvN4RCwdrdyk6fUFCVKk4e2UkOjrhQBExtcCaXI+lU421rLw6Py9jKUEc5M PJWkoU8xadeTtv2X24EUQyF7p86mP62CsgJKze9gTdky8tdjegCGLhUBykofN/zJUlPqsOQK coI19tCHDh7MxlqtdcKQFB2M8L5hploC8xx4I7o+IV6B/DJlE+psCGzTJ9u+63JhLgBlbWEk +KLtNUqpam9WGdthObTJ0LLcCm0c2DenTs6cNsEo5xME+yDGSs9D6jmearqa9ocgZ+G50UOj DmTRxZtc8imJXgPgQx7FiWL8IIQmiJLhCyorn+G4JyGFFHs9QJMjQ5FFDo/fo3DPvxy/lqYY RnB2N5rUJxoYeuO6igqKWNjOaNgLxpuJeuTlUSzEQrswhWDvtibaTBtdrfQfxoTp+R6aWZHq j1W6OeF8pFtRVisVYoyRBzTa2KgUbCwGFs5yX3/JqdZ15FjjBwWVwQ2Hgsjy1ukJN+MJ2jmR V3VPPDH5nohgQD6zenjaB5uq7wffC+nVaXIs9XnaRQHe6wLpnF2ChtIzCZXs05aXDPC7/gW5 LYUmIjBi7OWcJCYbFfKuJe6I75P94bNQRQZkeCvFlcllbCxK+v0K0Ej2JrLbB+munoMkirwZ EwP2gMiUSh93T+SglldZwkEJTebUPpQvK1xIlyvaoOj74Hv2zCvDHaCvFg71hK6Rmc7lXMZA ZyLJ0W0s19h8JaPMgLQ9A9hUBvK0ZpDLxY6dNXOIHRnE8xkmwWejKlHmj8iRhsMVMvJlzX7q mE/xVSem+N+xfFQWPs9ZieZGA12Nw2SVnynPuT/6q6C7p58qaEI9KFU/fzY7XicOHe0w8bo3 mdrBxhPD1sZjqZVt+Qg3ASkiUc4OK1H/eyF90U5frVMFhxssR+5adJ012ixBLODMWeB6a7Op BFdlOUff8P0yKULSrGLyl3NWrEEj7CWkPE6PEdGS7biavZiSSRr+uVXJdSS7LplB1dXizhJk ST3QHqOd+AJjfYeOLo4F/b6P4aT93pXlDtpFwxFuEzjU9ZmYNnZnEsiPT52wjPKHhZtRt8UC wCRDv3zYtVwyWs6v0I+gY4Oa3EyzWwErEk3arXE7eYOcSRpNjLqunoo4TnxS06ZjLeimKhqc lt2b31OvridRcG6M5yxUEsEW5YVE5ftrGPmTTljSBIb1Ixbima6qcSAOef9QwlTBffkKrrzx hsayyhSY4u+EygG4ct9gbjhT+2TcSydNCi88QeJOA5Iq0ITbACUJOhMt7/gLoIKFaxBKdpTT o9iPnhl7X0eZWGzQNALFs6TRKX7ln6+kxxOziUTZrQXqOjQ63NwtkQnebRLGiY+aQhU3PYUk rgMQOgFIdQCSShDbDfp1honUqqTxJ39A7pnxoBl5guiFHgd4lAd7mhknQuV8BRXteLUpRHSS JQ3nczhh33qKuZLIHGSOkx8h3WdMH2maTwopZMll8cPuk0h7kqJQUIbQ2tJGXsGmy750G1ha amRlZd+GXnsc4+TsgkZF+k0ho06SJOyEaiDwgLPJzFJIvlXULisKiWlqTG+Tl8uYzFopJ7KI rR1ilLS6pjqd1pZVk/RqQq1PUAsdCg6k+/58FOKNCU1r6SSfBmCh7DiGyaRePEfKXE56l8ka ZJqBKZcTfJ8I90+RkWfYUYUj/HDjijKMibyskhbIJdTiTTmXDJjsykXmTRmep5SQVwoZuQ07 CDNellQSFecqqE88DKiMPrJ02ionCh9MjrzBia+WcXw3zMRQQHnzlBdj6Fr5WG3BtatP6PDv bRS1D5LvpYcOeYOrIq/WM3cENNGa+pOQ7teR/AWHfpbvE3zIUscVvWPRJiquq6vSq0RxGU6c bwExeWW3q/6LAUjppFjv5FwH45/ynFycYgz6UJYt6S6swN4SrxVQp22ygwq0IClj/0Qc8FE7 mTDW0IA3m6Ae1YvuooG2TwecIneCwLT30InWhnojvb7P72QUKx/7Hk9RZbAvCeF1HTdshc62 bV3VSmb74mw3i7jHVJOSoq4PR9I7rXOFjFx/qdtOFPflhJ1HKmsrrDiyTtJfx1U6Ms/nWAlc cpQ9gzTEIGc8+VgkAMzy2T6Cgq6TRsgqsCO8kh2ENHggf/eUYQumCtWkfRXR4SbeUkNGFkR0 nOyMuqDLye55dOpWlc6oOU4oizJ2AxELf7rWmoyU2IFkOJyaU5tFIOA1LljIOQSVPcAtZtM1 SR55Jq/GnYtkr9tqM5G0Ey4K7/ezYA8J9sRxrUIYYbwdOHfmgRrrxvJDJqjxzQnWAGJkOBd5 1M9fSMOJfthRqF4oCwyJUDooRtUs40MKQoVgHJiyRQyT/0gkVW/EbBiEugnutB+hv0QVVJ7Q hp+uu0XVA6lMYEOTKnVYpPKFjWTEo0R+m0FsUEtT838xBlt52U9FRRBjkSIHzixvD8BMt3Y2 m03pp0xb/MCIK4oXM3RUqjD728xPGWGQAwGu0OKLZ5n/NuthHURL6iCWesHxknVHfIlDNpdP o/ZMSNkP+kpbXV2hv/DE/z5//nz136q15cqzlWeV2jPMV6vA279VvqLOuZ8Jrv1Q5SgMx9Py zUqPN+4f5Pml9K3Y2dx7+37zbV3QQoCLCMbYisS3MISc9EOQM0edH2CobHmjDmfIAbuY9HwZ 3FuuTyri9xYsoqOwV6YwwXSlC6U1ZBRupHCLQeVTArtnB27H4Ooc5iQZ4F59eAMyS3AyKB+M R3n4f3HYm0TwtxBP34U14dTrlTdHI+8qntgEyQd3Qfmh758hAvvd7tQY9ejmg8wdxhQmuePn y2Xc6XyrwtS97ByTj7Hy6StpSLAd9skcZEM0ogMUUnr+iQ+Lg5FYWFwhyQoyN5B1SzlJQjjW diFWYORfUNPY6MS4igmhjIkkQfW9yw/t4SSKZbNEMduYLz0HwLATU3J0uJlTapG+Kmehq5xb zsgWRO/O+8nGy+veReVlbgfVjFa6JVmC5DcZBeMrHM7ocTCZg3e+2dfYi45D2wSyCUhkJZLM F5N4JUwnc3reL8lRlLMcQqVcLdDjx84m7xjExjd/RkFrH3VAypwfQ6YMYfST1orvuHRCHTQQ 7xnmvyUFWOe4xRaqreMAZAU+9bNlCjaU5WJ4Nt/1gp7QsWSkdas3wgWdUMlXC/JchQ9utaVt /lucvm6FRXVbo8WIAspcVpky8mXADQfWU4mMWrgzcJLmmIxUTSGFOEiCYmXk2NR8guYjTbUf NNMRTjFzqA7zKdCTO7ORTi5+qK3SNtRymwAzuHWu2EAmPCfXVHiKZ7TOWPebDs/JNRM/nekW 4AFlWl3FkKbRz+SaCs/hXpnwUnhcBjyHzWXCS2GGGfCCqHWqGWImPCdXJjzZYGKgLbyvPa3B JleL70plIKjYbas9vpwya3Uu5soKZipI5qot3mJlgrRySWhZNJSct6XvEKTCs3NNb7KsmZzC zMQPc82JHwGciZ8FMKtLLBY5HyOdPgZZg8y5mZnhv3+VotlfAb5sX3oNBRupih7JiBNJb7FN ksvg7XoZsU90eeNzHDO6FDVEFwD1AV2MQqD4qmFUcnrnFg7HUiYFzK393K/4W7zacImzkeLi L3btVz7SVOehcG8fPfmp8mQ+SztBPg2T95IALd0O04xItwFqTqnyOrBo8P1G1GiWUeiXZBHL tVsjBd4KxYxSQ2GJ0fgkRekNVpbh4mqucCgRiJRjhDHlkECSgvaGWU51nrioveEsaTpbXJre MCuVzhNfawhn9XED5TD8AVun162t/b03jbetvf29eiGrLcqVvAIfX3oIvP54ffiqqK4gLsFv qNUJr+HZRHV2HhtKUrDo4Er6ahg6a5POHZf6dW57fdK54zsAndtaVHTm+GZgw2If9qIRg24E /Q2eXNaCEIet88qsNq+Xeb/kZup/dhpb9b1m/et0DDP0P7Xnq3H9T/X56sq9/ucunq1weDUi m9V8uyBqlWqlBP9Ui+Kt1wuDqAhbsXY5h84ZKFdEfn1H5xgbPXfoow3mKDie6HuFFBd1IKJw Mmr79OXYeKwAaHTHHoOmwt9wMkblkb4/VKQjpiFG+RrjgZqO3KX8VDue4QedgA+goFCu74/X mG0vChcrOoqS6KAPStGf0LEqnaxTvMHj8ByTJBnk1BiE4wC9+BvD3rDrVMp33S2MoNJ2zwv6 /qichQnUaFFDYQLN7EzavkFGoqBRuj4yEoJBSUcjCNvkj15fBF2CvmArhD4sLKPA65mIaRIK dRkVthqj27jnB1Tc9m5vDx1A3iRSZ1B1uo0DBol3APsgt1lhBPxBB76iR3TEqI/HBEyqccS6 DI2hDDuJTvDD7vgCR5EcXyYw9HAU4LAb4dAa8CCLIm7I0btGUzT33xz9sHlYF/B+cLj/obFd 3xavfxRH7+pia//gx8PG23dH4t3+znb9sCk297bh697RYeP1+6P9w2ZuYbMJJRcoYXPvR1H/ eHBYbzbF/qFo7B7sNAAYQD/c3Dtq1JtAmb2tnffbjb23RQEAxN7+UW6nsds4gmxH+0WqNFlM 7L8Ru/XDrXfwc/N1Y6dx9CPV96ZxtId1vdk/zG2Kg83Do8bW+53NQ3Hw/vBgv1kX2KztRnNr Z7OxW98uQ+1Qo6h/qO8diea7zZ0dt5W5/R/26oeIut1E8boudhqbr3fqWBE1crtxWN86wtaY ty0gHKC3U8w1D+pbDXgBWtShLZuHPxYlzGb9P95DJkgU25u7m2+hafkZFIEu2Xp/WN9FlIEM zfevm0eNo/dHdfF2f3+b6NysH36A1aq5Lnb2m0Ss9816Mbe9ebRJFQMIoBQkw/vr980G0ayx d1Q/PHx/cNTY3ytA9/4AVAEcN6HoNhF3fw+bCmOkvn/4IwJFGhDti+KHd3X4foj0JEptIgma QLGtIzsb1AcEPMqZNoq9+tudxtv63lYdU/cRyg+NJkhEm4eNJmZoULXQ+T/ivVKsF7sIsMrR qzVgi9SRovFGbG5/aCDaMjN0fbMhhwmRbOudJHfZOhaasf7vgnSN2quvWmNmrP+V1ZVK4vyn tnq//t/FUz54t7/345oYdrqCBoFo93xvkMtt72+1YFpvINdfgnVj6XTc79ljg3Lghee1Detr 6WE+OsXgMLCm296my20Po5L+Kk5gxRNP/vODP0L2u/YE7xxcnIknv5BPc/HwYe0LbGxzhMta 7gEXozsBALRU8gd4ClNyFrJcDrBfc2qDD7lc7MOaBqe0s776cOp1AOIZwJdvJb5/vVEq9WBd vIR8HfEwL2lSIA9fnS4lyc9IiEKZsw6trEt2MhL54fewwSQaG3SI4g9KIBMk2vBb9/+M+f9h t3wafW0dM+b/SjVF/n9WeX4//+/gkae3H3bxshMeUaoLRPwuXWnaniOLrju7ouVKsxA7/s08 ty3jJT06vE2c2irHI4X5vZ5L4zK28Ntwblnh03QtwMzza/yulG2rRw/e1w4v+GJ2zHFdDjVX +926jhUu38y9EydDPn73S8S9DeataJ6F1MLOnS6KiWa5Y4eeonNh6ElIhH8/aQ8uXBojBWOD muTKpEgX+ELuwyE5AqO+5rtx8p3h4B0wAl0fjbQDM7qnZbyJOiHiDCX4lh37NoXSnwtuKdiW yVvjySu0dK3uV5PF9bzInhVVVA12ivppIQZFmWiiySgMxJOB37EduyjQnwu5DLSU23+6Blgp CI78kPeKx9KdKrmIhb0V5vCK4ti20AMo7FhLg+NDQ92rDB03Ugjp02fhPBsi/ymvihZ92YXk 1VaWOO9/n8+z5eo5+itaE3005Mzx0Na1vtpQgQ8Rd+0RVrUAy1ATXFAmn4GHzXm5oS2/8wn0 qJxCMU2Fu6F6SjKPhc8y1gzbWcmYgWnEArRyqpuUI01n0MUdXGv/sTEfsbClZrocRxW7Z5ED Ij3cDJho9SllUIQ95k7bEFY/xa94fk4pNL3fmvr6riLZeT+zSyUYIeHEa+orJWpaT9BN6/Bi xx+oLzE3qzLQiwI4/bQhD6CKKBCNkJhNc6+YazjODp+EYy+dflAWW+XQaoaeHylA/lVTXbHx +Y/EkogTG3yx0WdVJs8pUsak5Ula3yuGYWd9NteI8Yf2NyPN8GEMQWLO8S4jk/A+RnzduIwS A2WDP1rlvGqsYLUA09Wrxb7WkLyXeop7VWh31pqEHqQ3hFcjl14x8JANOS5q+6oIlcE6KKEX N0SUU35vqef+UU+K/N9euuU62MjzWeb+H99j8j+8LP/bs1vGI/X5F5f/U/v/VrQ+5pmp/1le jvf/6srqs/v93x08R/sHG+XyUrmcU3apD/PwrbDUP1tiNUkux3rLOuozmrBEqktauaO3R9bS uwFjp132cl6vt4ZA3h6RXJ0EShHFcrn91//e3HiYH3pjcrAiolF76VG5XaShCG9hEUpdwHvb g10hpi6W22hBy7CxDgRRyD14mMfozKLd7xQ3Dwti1I7Ew+8hGYYwXnFiUP+plEoIek3VBrlU 61BFQ9D+Az7u/pn0PCVU5XSCEcBz69naKkDK1sHBm53Nt016l28lgPlSlEJS9Cg9z8P8IWyO S6OuJIxUtY3xkD6XUzo4Ao4lRPu4376bRTJ1/h/WN7d3v/LQ13pmzf/as+cJ/v/8Xv9zJ88B uoJCDSsGDDNHg+jUH6czHvJGtCumk0YZIUyFMNf3OSHvyBtdoXS+KPYwRCAMpt4VbsX2m6Lj o2zoD9oBXlqWWU564TGZZtHdxKDsl4synB/5M1igX+gdwRuM4Yc/bpcLv7069F/uSZ3/isPf kiB4A/lvdXW5ei//3cEzvf/p3umFNyyffk0ds/j/8+qzxPnf6sryPf+/g2dpSbze3NurHzaP Ng+PcvBTWwStZZoDQa6doO0PIr+E24Q1Ic3EMGFzMj4NR2ui4Z2HI9Esi+3AG7dPzwKR78i3 708IWBlEwUJOI1Df2859G3RhoeiKVuv1j0f15g+bB613rVbuWw5NF/9s3aWKxp1gMKarVDkO HQtLE9mjT+B7dbWF+jAYyK3qal5/uSzkfsmZe8WX4uVL8QKdoMHrq1fwup77kgZuuabBLdfy +osEpwG2aFaNcXZhXsh6mQVxdUVDXF3J6y8zIEJWCfFbjJPTvcnqOH3+t1Hv/3WT/9/msP+D OR+f/9Xl1fv5fwfPjPlf+U5sBSD/Xco7jsqqK9UgMMEWMNTJfrNkcQcz1c1c3zr68aDeemdm ufqQW1rMobC4f1T/hn290HgUndDnQ51Tb9Dp+aK+/wYk0DNf+YlBR5AdsYVlpWAqyE8MubBH 2zIQQheXcqbC9w8ql5Xqg6VFMRkOYccIiTptB9NqmNYLL2Jp25i2gmmd4CQYO2lbmPYC09og xPactIMHGP8a04YoSTtpTUirUdrFaYBeJ9CNkMjTn6Vedwmk44JT4CMUWKECp/5lCiJNrO0F Z6CdNAPEWggQRreHbTL5G4owPldEJ2WiDblFiyj+6fO6Ra1WEPW96CyPMTpkeh44ViHvFC1A Op7uqGJB5PUGk36+XXiQz2sY7cLjfOv9r62dX1vbhYL4hsKq2EWGp15WkZT8ROq0/FspmYlU aZnTMDkZecPTtMwHv07Bn4ZMWqk05MkAZnoVv0JvppXEUZRaMiUz9X9a5mZKZpoPqR2Qkvky m6K/tj7qAnb/Ru0gQMPjfD4+etqFwsuNyuXzrqlhHE7P/5izx9dXd0C3xiH3ivu9jUvtg6AL W1Hd6ELuwYO2KG2IJ5tPSk+8J+u5B3Ihbqet44l6GE52PWp0mHo8qGczUY9pvyphNaNt00dh blXfLkwVD6av//5oNAh/6/V/5dlq7X79/50eI3HXDw/39mPitvmmP9YP6oe79pFrlf/A8rIP 443VR7g4G0N+azWq7+2jCa95arr0nozMRZelYevQgcW6PUYXcHb55uHWO7v25UT54Shso9WH Xaqxd3Rol1rRpcjp02gyRDwjEnEEKXmd0vvuIfMzU3ppX8YSctr40S2xmsCx45+DoIStVDYq dvna68Zbu/xzXX5zdEJmj3wLYByGIJQMTuIE/ljfMoVf6ML1S78tI4emIP16c/uNXel3utxr r8OdIv0P2qW23jV2tq2xULGb2j5FJbfsD99t4+bbzcaeVdCMoiPoce8Er2e4zdqtW8OuasbN /mRsuQt06tjaqjetMmasHGj7f+iKQRAbo2823+9YY7RqRguSIq3HQER9vfNnU8KMkNc9tCuV /a1FUIfw75s/WnSvmtGyrUcJVMhXWI4nkdvG+sdG08bVjBVyj+lfwkBxcf24Xf9g12cGyNYo jKKSxBXWtLNYG52CVTNAYqM6Rpjthpl6NXt8YKis9EneaNqFRM0MjkaUXWjvw+aOVciMEOWU wVOzx8GQgjeZYmaQEAFJGS3QTq4L661TcjdW0gyTozBkm8Fw6A9kJKsYVY6sPq+Z4cJUQZka r6rEJtvRx6PX1lipmZFyhPcTaY4mBsgbl5nUYgOEeAgQJt5tzQOLh9TMGMG+pg1ED2MB0vxJ dHrzoHFgE8aMlEav55+g1h8vj9tFDvffWDNVLJtxgm5FSuRbltonebTTDzuNvT9bZS1WovoB B7PbBS6KYtmMltej8AyvCAVDt1Xb+86yt2wGyi56TdGDK2R+xIIVvuFpidvYzb23VuXLKy4k GSkB11AdNplGYayHfrQotmx66I08nCEA+lgnsQwf1XcP9CBcNl20rScXlvcp0lyMETetAbXi LOB9YIzogBXb70e8276K0bGx06z/hwHwwlqL5eggj+8R8Ep/0Eb/oC5r2NrfMwtHtbKqO3vk DSKyJQZpdxjiZQIMstQbwQAiz8gD9tPpzCi8EIUXbCQ0uX4hL+T8SMdx0Eef7ROXbxzWd4GG eqGvKibFY5auqzUs4UDJ4H+0I6zp8v+p7w2//hDoBuc/z5+trN6f/9zBM0f/9/tfuQOcsf+r 1hL9X6ss16r3+787eGbpf1dL8M+L2zj/yTrpeVffPGjt7sZ2nvZX95wHstA5TzQeTdog9Yx8 v3WMUvY63VJAoIkk67U1Nvnsr4vEvHHAY47ceYjestDRewu/QVKe08Qi/i0KzLDIslCRzIJb HKokKqzLwpQfdUSRKSy4sMy/OA7HLUTCfEGXFfhFQlkE+QW9frSCQRKF1FqpTQHbdKegLBaH 45EGDmujhp6VObWeRdolT8cLnV5M+vZPBeEPuxr+6z3T+T8IUThXot/2/H/5WdL/6+q9/eed PL8//2/sHeF5XzO2ADif00/6VeaDw8ZkdUUs9HqTBfvjJX+8XPiaA/J/8mf6/O8F/WD8lbN/ jvlfjdt/gvxXWbmf/3fwzLT/+S2nPnn4iE9866P+Csygtbv5UW/783zg/D8q71+9ovgxSp74 vcn5D/dMn//AbL3RyW89/5/V4vc/0P/H/fnfXTy///rfPNrePHwbYwLWR71bM9Zv516LDsDk X8s4Bb7QBc78ebFXcEuY73Zu4Bv5c46S7OTm73ZOmAgMNZZTff/HFDJmzv/jMOz9tvofmO3J 9X9l5f7+x108ah7ChHu9v79jmeGZL/oTjgXRIsf52uZkNPFFVf/seujFs2LNZCzTwlwtSoPp 4rc4sQPl/iHnzD/TM3P+k7rt6+qYNf+fp+h/a88q9/P/Dp4/xPq/XX+TXP/VR8wqJMfIt1pt 9BGO/zeL8977nR3kOehB2P2Yz7Mas4B2inKLoMQJbZdHJjSspDSqYf4Y/6rLRKd40HiBJn2p 6VSc/kFj/uGYcmnc2Ld52M1H46LoozUjVwRvIk9mgouFx+gjBP7mK4VC6VVflHRKRRRuT9iY Of9J2fJ1ddxk/t/v/+/m+UPMf9zeJ+a/+picXDQPBM2sF/bsk9/1o9Kzpq++G2SdHHGCDYIz JGGggYHEAq//GBgywYbBGaaxCX0NKMaCONGGxZnubv7/5va/1cpqNWn/W7v3/3kXzx9j/sft js231LNf5xspqF6Rc7CxOI8GdI2iKxfL40lXH0Din6K85cKp3T75zmJlAsDBs0mEEgMi5oBS Lpdl4fMoicFclabUObWaqO0NILuVJVlIZNY2f2mu836n9k/5zOT/8OU3lv9qq7Xk/c/a6r3+ 5y6eu7v/DYnJ5WUZ9jWHYa8r9vzJiX/sTSgkOV7K6IlDP/K9UftUbHn941HQOfEzb5i+Gfn+ 6+Z2KQWPOPT8gN9H33faUfmk55W9dnlyRhfRt04xCn20Jt6OfvZPwtHPYjfohZHIn/RrL6rf t72+zCymLGY7jdfJ1Ux9tJYubVsHa1d8L4pWu61oPBqHk57Do9vDIr8sopFr0ZVGj70I7YYS MK4PIkVAdZHqZfphnFZXJrZJlKfinAYHX71xGDjlyNYI+6p0mw8C3CXzJwq90R0FgFWk79FK Yyh2cEPWY+v2SWbjqPV2Z//15g7ZuPHF3oKxNMs/tgoWbQMz1BdQ5vgVR8dSTIi8Y68lLBcH 2pYsVomyy4rfabRMyqhrjQEZQZWmZjFgbF+WCkobnFmgYuZlNrrGOi1ZxQyklX2aoUaWNZpd YTujPlXWMmH7cvuj6nc5xJ61/pO37t90/a8+qz5P0f9U7/U/d/EsLYrSYklQhOq1rXXRLgE/ DdolVlGurazjDajSRdAZn66tYNYcMOHbe9BHQ36rcANR4LbRQEzk84ZECzX2dcK1JQpZUEsV VhX8WB+2vTHUuTk5IVJgAv6/PjgPRuEAL/CsiY/+AOSRQQBcXOw3MXnbj9qjgCJVAFqwFoV9 DJ/UnfS04wvtqo12dhj1CqMk9X1i3sdRB5o5wQiNi7ffrw8bnTVxWmL/2+XT4rmollewebWl anWp8kJUV9cqy2vPnglgvfXLoXj4W3QqDljhRjmrfvcdSLTw77LugKNTDGB9AnSmGFXoSOT9 IDjHICXjK/yyhZEMwtEg8Moi3fsJD6FbiIkGUL4+LBpCwXIUGQ3eq+WvDoxGpPq6wGgAo5ZE ZM64aLeKi/RcKCFdKy5aVkQ0ALXMnnG8DoyccRBhlaY8VgAZ8WPX90DgwHhoIxoeNOSs+GUS LaIEVDLseVexlnjts0F40fOBFRJ3sEZyEKlAaUIt5CYwWsc/93shRkc4vkoOcw3FDPeieO2P zvyef0X0DGDM21HbqNkr5dQ4cDHwiUhwcViq1deOA5cSAU7CukYcOJ6/M4PBHdbf1veOkiHg xF//SjHgnjzBJAR1ozhwIhYHDgHdKBScSAsFR2jFosFlhINT7cwMA4ew5ooEJ+aJBEfLWXYw OHGNYHAIKjMenLhGPDgElBkSTlw3JBxCS0aFEzeLCkdtdALDiRsGhkNITmw4SxT6Pv9tQWnY 8feLclXkFTsoiNWlamWJF9GHUgPDjpWjq2gpWH6xqjYS2o6UZIBqBdfe70ACWKq9EJXK2srK Wm0V5iLed1dywJLlIAzpt4fGgJZTK/0p/XLY0uL3yttCJH6i6/+tEYphedKvLxZEG1beCgpF k8G4VHWCW/z3f/2/GWXGTpl1Dh/hRaiNgGoGHMlYfj72T71zZDY9P4pU3ArIO0Hu99//9b/E f/9v/484WxcV8d//B7yIlww3TbGCCCkk2lHh09lnyK0/jPFDVrH//q//SRUFqqIAip6J//7f /08HYvAZEv8vB2bweV2F8vYHEa1WP8mr6S9FJd5IH2M9JVv5PzNamUDgLInAGSCQXj/mTGBw MvJxqb11Sr/6PSn9SrcT/ab3YIroBkdMHRAP/kaX3Z3v38MEwo99v9/uD6VOjHUu7Ugd8sjf Y60UIbKQzmzm/AGhIj4ZEJupZYA1iLQJlNa9CH/dSU2lb3IwYcEElaFmJjNThtVai0ic4ZVU RXGDbMJAoRTK5OTxPkh+A0NaqaaM3POzVNK6tGUy8V4z346IjJnJY5mcYC3fzxrwAKHnD7AC mTsxfNsRs5X2mMd4aqYpYxzKS6IDBElqCSaVfajkJAdxG5PgIPivas64oOo+03Uz27gGkGgq EIW8XSXkMYXjGWNMKtFOi0/N3W3jGd326i667ZVsjmQtPAdmT4EkP3EGNU7N2KB3eAfNy0pR UgJzFwySCkUXJLGAdTdDGm/BlrDN0CK2BFgB42yzAv7CSH51M+L8cjp+DnaDGejdhIdHQNcs +adUBdkMh0qb/q3WnseY9Zzs2Kx47Zxbg93iiJtr+HLkjyVfjoo42Ga2z+2Mgrt02FXhiWF/ 0seoYjyiCkUNk4eEMvQAotPkswl9a2jo2jGLU2mizrlqsVKtrnuJffNf/x/8+9LuSDV9kpJr gltFk3bbLDLzMCtkp9C9hptKBqmosGiToW2zLCzmNE3mLKTg1fWCHoBL4JUyKC28YGBKfvd/ J/Cy0foJQ6ulsIjTUXw40OCcta5/RRfdd4TsiERnzOgNkxH+c/NVY9yzhiWye89aTubm/bKp VBSDCZrVCzv8sht75lgAp4F8Kqopi+KsNXGOJdEbK3O05KIj5KLIbBplad0finMLl3UP7s3I /nDP9PPfySCIxp3f2v6/Wkna/y5X7u//3MWjlGzv9xrNo23r+p/+kHEl5n4i/1M8qfO/xzZ2 v2/8p8q9/787eKb3v7Sn/Mo6Ztn/Pl+N+3+qPl+9v/95J49rGYEBX9IMflMNHnK3YOvw9YYO WChHVg60145bYFzfzIGerzNzyMBkTjsHiYJG6frISAgJa4fr2TlIKBnWDrKNaef+9tBJnvpT dbqN5vT/Buf+Ekry9P865/65mUf+W/sHPx423r47Eu/2d7brh8nD/9wCnf0vUMKNzv1zsXP/ mx3659IO/RMn/ukH/rqVuf0f9uqH2Qf/85365+Y59Z925J+7xpF/9nl/7hrn/dmH/bnrHvan nPTnbnbSHzvmz93wmN894zf8f/r6n3694rprzIz1f3l1OeH/sVZ7du//9y6epGlkTZlG8nMb lpE5tkoz3NmLkoZoW2F/OEETEBlpTtQHJ7AR9VF9JU5G4WSYEyAH7HgXI/QLb8zSdmDVHHnk sp7iDsMoPzzY5LXFa4/F67fiu2ppdRXXu5xZcniVUVAIy9sw3rwN001juHkLZptfLc3cksnm V+KhDTbFbZlr3p6xprimqaaaWV9lqcnPdQw1b81MU9yakaa4nolm7vbsM2/JOvM2bTNvzzLz Nu0yb80q85ZsMm/TIvMW7TFvyxozQ077rZ655L+vVAPN0v+sJP3/VOHlXv67gyep/7lGwN8/ hgYop8WlW5GWvk5Yui1Z6ZZEpVuRlKZrSDbfH72j5Wbqens7y+0trrZzLLayZdnr7C0us7e1 yt7OInuLa+ztLbG3tMI6C+y//PFl6vqPdzhusY4bnP89W63W7s//7uDJ7H8K7F5u30Yds/R/ y9W4/Uf1efXe/uNOnln+364jDmZ557G88hifOfgLo1CusR4E/mOXGwKdeWAcUwrfGIGM2Oug puGwvomL0M6PZevGFw9SvPDFhmexGOyU/Omz2BC/5FpbxdT/4vby6llaFJXSczTNpXy/tppT /nUAQckXpeozXfR6lVZXS7XlG5atrZSWq1S2CXgdFFtp/2WUXa6Vlr+jstcoJ8uuVEorTKrt Yup/08q+KD17ZpW9Tr3PVkurywrn97+2Ps78t6jLrq6UnjOt3hdT/5tS7/Na6fl3Nyz7olJ6 8dwtO3d7X7woffdMtXeHWjTjX9Pe71ZL1QoTa6eY+t+UiquVlVK1Wr1p6WoNSn/nlrYbPX1C 1Cqlao1IVilO/19qaZiLK8s3Lb0C7X723awpNWXK0IyGBjx/Nm1uzZhzCOQ59N93UwfsjMGI QL6rlWqV59lADjKA7FhAapUXpVpt6kiaMUYQCLCq2vJ32UAOsoB8WTdAgO/UmHncC/I3fDLl P+0r7OtlwBny3/NntVpC/nt+H//1Tp5Z/h9vxfWjyHfk2/cnBKzcDvuFuA9Fc42fHS+9ynCW mIzuii7cLPe86wlOvoQqsckg4DNs6UzPjv6K99+ScBcH/uV4PfdlnaTVTbGAaCxQWHGtkyPn eJQ9ktSJuBYrgdSafDWGTstAnI3C0ZiP9rxOB0RoKBxzY2c1qIUzlCCl+PZT+X4GMTetZXit Q/q3y1MxvDzyM/4jfQrK0AMlUS2IJUgil3rYXhXRHnNgo1GRiQDK6s6HdpeXGv8V/1iOAiU+ YrE9GRXF4nDkn69L9CXmsWby9fAuDKW8wNyQC4M6FAUAgHeqTB6DrtO3bziD/iYLUX1cBv4t vcJOlXkQPXoNuiJPiYTOS4k7nnoGg4m/npbpldVAfNxGDvwLrk8SWrkygO+yvMSG3kvJPIil jbFKRCS4YdzaAhMCskKxdYExMKjhGgJ+VuZ2usINp0I5PB7HKvuS1uyNjVi7sxEy4FLQSjQs EwmJiEzHKmiE0hCV1814ui7J/k/xYYkuEvJuD9FL2viUCNJvhUmO28n1PFVpiiCYRxHETnrK Sfxr3U6mOoRKVq39Qu0ihJVvzbSg064DTo03krdI02s9kcaIbwiHBouFPICSg89wgoJuLqbq XmX633BOiseP6edLJsB1pijVaJON8mATqVO5Gw3KzkjkLlHjUUYJN4NtXY0tZ2TqbAQfkwqK JTZjnFAyQstR6awg2llM8ZodpNl+OBm12CX9wPc7yY53B4Xk2+E5Zs3uZOFydkaeasUCatRX oB3OOJW+X52ZyvSdyuSFboSZdTxhcrR074Wozhmgz0enflVKYw21qzLbfhs6BXgOZrDLvbSK 8ehI49tqnpt5a/Ntja7Nth2WYH13CfRY8/aCPRAZdTkYAf2j0RVb1fS80QmfEap5M+fcy1uT r4CzL29Nv8K15x8OLtksaLUigKJ2A2bEWAzDKAqOez5hfjn2yQhJm/fAoAOp7k85vZ5gFyo6 a4oColTVS2t1zOwo5QEoznF5HqQsXJhkFi69RDvLDS9Vdh5+1GJuwGcv5ok86Wuetb7ebEVP Hzw/+E96PXHqnVNP4GQXdLsfxdBwMkCDTPqKHTp1ostMMd7ACzDCYPc5lEv6ZNb9uJgqiqZz shQWYq33klnphXGxPV3q7FvXjW35mEVfaDHgNjC8cJhCBOXjWXZNggLDdW49OqkYklMPU8Jk +SIRNp6909YGy793qlgvNxAbEv+lTBFfiyeR5s1qGDEjlkseDxOVRNVj8Tx9KejhzKCcFDn6 jABGLaBGocQVqfY53bE4DsctRNZ86XuX9MVpJ2QD2EBKSMWX5EpGS5higMyryLe6EjMq63EO pqY6wn5qzdA07vAKKy7I2p2cTC/VDEiFV3LaodpBI+iSSfIPp4jK1P9w6Kc7OP9bfv78eTz+ c/V59V7/cyfPrPO/f44AHZYmqRf0g3Hkapf0MaLjS5Ii38S+YTS0V6m6Kkt9A1L+WTBsJaJR LEaFHHMkzBNsKNd+F6dAKpEPok5wEozzmM/4YwqAvQSL1QqIHov5PCQ9fYrr6JPKE0cGCIj/ qMv7f6kf7h9sbouqcJ8l2Dx60s7rZ38Uoupcx/ttvN3DPLVkGXWsumRHBbGKHuy8b2LWlWTR 6DS8EBiu06nqYHOrDukvUvLjgoS8OV5mp/7mCPNUVxNlen53LP4GEznoBoCdUxGZXonlWqJQ 5dKBvnn4FjFaXUlkRIPGJ5uvt7brb55Ax0VjHygYdsUT77gNpZ/Q8YPse+kZZTDpH/sjN5IX v4NQXLSCqlBUCRXEhN94M4dvIPO1g4jMIvEnjlE1fghau4jdURz3h59WV6WvTHu40WiKEt8j FHdanEhn4wsVYL4rz1afv/iOm3RyGvztrNcfhMO/j6Lx5Pzi8urnhQQc2ppkwGFyvX3X+Pc/ 7+zu7R/8B7CX9x9++PjjXyQcmgBy+DMI3PtiE8Vj7oyC+JNThVhzMDdruCoE48PMGv64If6H nAkmO1Ia9kE18euvRHVY+ZdXTUE5naDPZIMtvCQsxAymHyD0RMhJiB2hpBYHK5xUZsfBSdDp 6ATI/mzBeFJ6su58x+wbogR/1mP5f/ZLJfNN7lysynFaZtXy9Ml1odGkzQInZoHLmX8dmDQ/ 4xSifgEptrpaSEAVpQ1RM4A1lqrMi2QRhYis3u0oIi8KzGbswIQKnj79vKF5LFVCbwZP4Awf P34Uf958s4YiKTAtbXzSDztkn9sJzsvIHVSRlKhKUHttI59MKDjdnYh3ZJeBbwX8ZrLL9QRh k2CMewHVKGi8nLKY/IiAfV4nPFB/Sr/XE90VwCzR7MhQSn/CNUrNBO4inWQo/Q31+uO8nEZP acYW7L4nxPPcZa8SE4R6edJF3QCwUbeb8cFQi2lj8elTPZtNq0zbkIyJAZhRjawCixiAFvzr DPCNjRc3bWFlRgvdWbGxAfPot6npGqDkqFte/nyt3vnG4e+JwSLkaEHnpDdsY3tufJScBtxb D+9S6ZpjxyFpYuioKpItmgM0zfHPs6Gnk2we3MU03O2lE9Xli4u5RROQFWTWN+Go742FJ0Pr EI8c9kjewwuQkABlu/4Iin0Pb2t095g/oSaLs6IuVDquA7Ah5sX2cGbiPvJKIxcsypuVWB9+ HY+8oBcQ5+31WNpEEN3+mCF0GUeJIdQK4h9mwNCpa/pINCItxDieP4ct3gIhha9tqNg7SNqr cMKnwL0RyI9XouN7hAaJ4p6K0FqG8j9CzuEoPPaOe1fiwrPC0Srps0zOUm8j3K21Hen5kqWl r1KW2FYUZrmRHhRR97dIsm07KYdG6vgUCnd73klknc/DKkqfkNJSai6QQK0LBH6v06L4U+uy AP0gTyKT8XAis6h11hGcY4YAUBa2o2XxLRaWUiX2I5TxT/wR4NX3LhNsIuVhTOlGDrSQgdDt VjlsLFzQqTVuS0ZJXJ6cPimKJz34B4o/2Xli48KNimzpIetBSD8/EdFkOMTY5V4Hb/LUlpee L2GUBdEsvyvTFJ4bEh+2kKHCk788EaVSxzsPOn1RXao9W/ruO909ER4cGUkZ9f30U56boEGB dXCOyS8pmQwNDN/hcnnp7hf2tsqXPNXB2kjMU5Kwq47ynLSB6zS2xTrwJPgbZ2qUBnLQk0dP 0pYIbEbmEsFtRAjxVSJipbt5jLGA+vIlp19x4z0K0YGrHO9Wd/AHLZSO/KHvmVvi3CZ3yhB3 8XpRSIoGABnAPg3bZ4ONgLW0T7n5drvbKCjDLmNNVvzrBq2t6+IkhB7n2tdjuZ/auXFbMTW3 sHPTtmFq9m/d7CQwTS1QsQuoDV56AbcLTnzFLZiH2J1g+AzutqrrzhDSqhmkpTtM3IJG8fMY s6bsU2g0wobjyWJiNHJPO58A6WD8JOIL+ah/95RRTmw+u2gAk4eMeeTxpDworCeGvV0gZTea QhObFSfzOmPJSf4ypTewXWYXYbXJ3lrEe0OTsDwPCWf0X7yyzB7EZ55ezEDDfebu1zh6M3r2 S6LppvBLe5ObBrsybd4gpsDiyEsE5Nbrmo2w+Til006foOpF/+y5P3fsn7D8xKlrV5HGllO7 3yrENT5+bCOQ1oN2PYBUsi9TqrIHemrT/z61OYlqYlW4fdLxux4KwaT3sPqA9SCiqpTL+Exf CtpP1hIU+ybPEzpl36UeuZko2XwhbRtmg5221qpHrrmJbbyhSmLpZepk/yIlnnM3qDAPi5xD MkhsHhO4XYdM85BoGnlSqo8RwjVopE80BqLYGIjirEbH047j+02UxBNLL7zEg+JXC1ZV+MA2 A5msjK0AgI1aKZbzesMQ4b60Vyx3Yx4H/DsNRJJWWQFJHvFx0wVwgq8cDItR1ljAP9MGxPWo 9/uNz2EKj3LEE1xwZsswtUVpPiE3G1PkGOfgIB1bbqncttIeGLfA2au+q+eNsSCJ0ZTi1dWi 3ZyifUBEaMeaYxEzRs1BCjXja2QaMfncTwTDOHfghBRyLlJeGjS0f4uLK0aicutPLvxEcGlB koKBSroxDimjfZBeFX2/QT3zjfRHKX0zx0IE5a6xQ03sMaTWQSo2WKkVobkWSH6TIWu6aGag zm7heOR7Zwu21MG4hzHcpSzywkWDSifa/TFW1mwo8DQwvgW8TK+pujpPVR2rMH8JsirH87t4 3ZN43bFKpGT2m3WjEim/dtFI3aKkseisCQIyTbYIjE+aSsTG1J3zO09cfPngM8lniHmm7Kxn cbAUeC5DTtkkS+mDjnET7WeAeYenO+d212BvKchJG8k5wJ1mgDMLTnQajsZzCb3XabKEmtbm +Un/9WgghBgS1t4ndZFmywuyukhfcOdZaK0zxJQpp2b0T84psjZEf2XvxnE/Fw6ejMnroY+K beHxCQWafWIheaKh72Ip6x1dG6tRTW2kJoyfdxC0TuhHWBcHaxuHF96ow5qIcTj2egxy0eEE siJ5wgPfS/YpD1r73uCUR1znmEfcwjmPmHnQgznK5fLsgx51ABM7fxFzHMAAfHXuYp/FWAcs ci2BVLRNHMsJY7RRwYY598EKqSKETWc666owjIi89cUxFJPddh7dQbfNJvl8h2scmPrrjtdE 6vla9vFa8nRtrgM1SWu3m0Tl8o183u9QfxaF7B+6ziZn0h+iR643CVLmwG807C1y3nDAR21v gNR9P+gq+kqSIXmsi71KIxtp+j4IBnjeaFEdCflAwoEiVgoN6Qc2DDWkCAHHLjRJMZE6sh44 p6rm9O0Bf+GLJfyD1N3wA6vkxbIif5kDSf7NZ7kP4met/CWIWsa0LfeA7XNInYka1IjvIT54 gHabZ7D78QZXqFGANUaacQ7UiIHWU7b01D5eDo+ouNenVSnsQn7h5Lc5/CAc0G8alNQrZcqP tbC+n4pIfT/h+EBb2dpJmPBA6llT8mALVR5aDR88gLFELQFk6VYN+6YEdjQIcSxZKnJy9EhN E/6l1x4Du9EIWmeSShkt0VSpT59iOmLw9CmjIPcZ8GbkaokP6coISM7OqBtm9RGxToMl0w2d YHvoVP04BH7J05vP5PFswuoEh8qxQxBDv28cIusGUiuoaeupmWk8qYFFman16U1OP84D+ImD PDUknCOgB/GciXMfU0fWsceDB/EDjxhd5jjqQIKigKU+/sXN87OibPzcQ5IlsRewRlIyUW4U MM0B+OTdk3X+aiA/yNxt9DKA7KQBycl/8P/W0QQg57IWM4Sx/d/oIaA21zAW6BBDzg3GwJxf PHhAGEnWiHsDqbB2Nh0cklgTLqlA5BHqjAvq1QedUDZ5MYKJqeYlJX3JVPHrsUz5gA1zCSSF PZyNBn6+VhhdPLVjvmY09o5au5sfqQwa3aDFQJE5Qg9kHpKVXN4sV0Ua51MYoySEhDsIL8iP LWzvxkEvwT5caLSGAY2SHCChic4gfY4+633PbCoPiMqIqZQOXFMe4NIw0QXKkCIKRdeT7WfO jHo/VN7nWQNo9wl8kR1CObQOMBuTkDExKjKbcRsll3r/6GRHPVcyf1yLZT+yYMXk7jBEMw+r Jm0ia3PhP9LE64XhGYVGQMulR0/I4fNYjRVigdRJ2uqG+s9QPMHRtcqMwQcDil0rxYN1gB0O xak/UuPHhaSWA7rxGoV9dq5CkQukWjOx3NnDP3XYG3Eic+SbgU8LixyZZrlhssJglslk2k8l dX7SG3DwXsUBKS21F4EtWobxct5c8qJG/6YYNiTKVWS56xV7QRfIY8UwB7fklXjy/MkcYFIr d2Qbw+b1ymJz+ndP1h6QXsND24knp6dP4iKmTXvFN2yXkMxVnS8uc3WT1iXjiRUqwN6+P+z5 GFx5HPZIrfQYeV0Rm1qQy4LUgyEE1y8lw4t9K2Sox1IwiZ1k27hMGBnB2AgLnZT5fCo5QArJ ULGniMXvMTLJjw6BWBt4U9LYdcY/ZhEnDY24zvPG5OllkoePu3pYmzz5cvDTp2GEVI8uDNyM JlZFzrdYhbG0jIonGTWnNH1netPj7U9BycqXSYhrUyKLHDNpMosw81PmL9aa/LMR2dTxo+QU +CPBWPjjupZZtOet2Z1E0rNCxF4sU3ooLqYklP6aDirTzeesqcv+lDldE5U7hwDXH6z4Swp8 av2ke/9OJnkAwMoR14Zqczz2+0PUgYPwMOj0fFJBaNXxo4EYepBlNHDsdZX0ylvaX1JkBL3F lBvw1GM6vcd7RFJB8nhN7aPSllV8rA2R7Hselos8eefZjNtbNVseM9Lyg1ws23VF53nl5oTg LBJIfYnNBBT8bFHQOo74rbR8YxwXrqYPVaUPWMNKWtqEyu8aGj+pJH3gakgfKPXoA1c3ynqK B0g3pVaMKUYfuFrRB45KlO7/T/P/gBfgb8MBxAz/n+j2IeH/obayfO//4Q6efxH/D6k+4xWz cJYdaB1vF62TF+QYA9dYgKZ+eyiPI3FOqvNIfTgivoepBzk2xTDEnSgdymAOPKqVmYfeCCPo yXouAjyj9fnkpkM7XmZLwI25JslzaUelj2uWcq6wE1tHbTbTHhalLwrErZi4WKyOaFyA8vwI /fPAxtzxh/kNlbKO+y0ln7PatcmP0pNKwlQh3UioPYwvfQhFg7l8QiuZ3gC3h5+qn1PtQ5OA bCxj9kJxC278F4ZOF0QusfV6d0ueNAEJUKQIBx1/3KKfeXnm1Nzd3NnZ2d8/AEy+RYmJvmr5 QGILrUD0narzCqxWVGOmP2GXldjbAHTmcOiPKKH0ZPPJ02oFVnEo+lKoTvgWejXQsSFNv/HL IrX6qZB9mKSQMWjA0WGZMuBPSx3ZHjonbAzdWX9teTJrRok/7HRKzKKbTaKgi321sUF6H9Mn RLNSfJIOn1aLBE4Ku1beRFYnYzrV0ephPk72B6R/yq4vvl/7eqb2r87Z5uJrNcXYQPwl8d0y Xq/BHz6JmcnpBPGpWSyOMgGjg+K98EJyOv4Iz58cBgjZbD74R+eBczHBP+BMTJ+AN5x/1+CH 12GIaRwRq07436IzRcdAh7QfSeUHd/LiYqFShOlOEH9vOf23eqbs/8iz2W+//6vWnkNaYv/3 fPV+/3cHz+3v/2LxIyD39AASySBhN9kZqjL1UdAWu8BmoQac6Hm/zz+yI0/k0v35IQtBF7f9 oWQifENHtKOi+3ssdbtsUKs4DD7ye7Buax2/x9PTISxAowCND9kKt6T8J/Ej8+A5KOf67//6 n+K//7f/R/xtXVTEf/8f8AIrXiD++3//P0F0YLOGdlT49LfPkPh/mU9j/OQARp1c/BYao4BH fBao4DOKIzak4LNa8F0rfg3CFVJIqnEBvozB0x517cvC0lBaplgJKZblMpNzcVn53V1UDorl r44fjZ2eAy6X6DlpezHu20s9FbVkBXtJQZ3lyLoFeiddjo5+ZFdHc3cwd56Vld0FYQPIa5DW DnJr5SKKNzXNFJC6Sj0F1O/kFABgJ0GEsokTka818iPHmhCIrIYOa/DzKs9iGy8gLbbJ2gfd mLFhUDvC3+ZUBkujgzdbG0wg7CbM0QKet6r7JI4pnQfQ8OZqm7xZyx5M9B2ZL7SYmUBWkDeD wlxZo2lZAxoGBoG5skVZ2aaMr3akhld7rMfX93QEYg+tNg4ciuwwVi+R5Bv0Re8P5IUM8rjs 5Cg4M9ikv1TJLoMwPAHgyZ7D3oVJLn9Zk1xO0FHb7dmpvYq5p3RrgJc8rKwzKHumKHumKYv4 fTpD2v7fimtNHxGPoR6kRFYfcLJziZjq4InNiTne1SwtfY9BiHALElAYF7chVvL8DcjZ1anL JxYkWQfmKWCdgdWNms+YnhzM6Mo7WGmd2WM6mR/bYUzWIopUQH6lekbPAfWk9Y9avK6HvRkN 0/h8vIPiWy/dD2bZRM/28hed0QlN+YFNddlTl7QKXm8NHMy9/qUMQiVFgFRxJvlUfA3M6iZ5 397WjVwyS0IYcdLwIqLu80inBc7CYa4eW2NyOq+J9eSMETidy3OPX5sNRWoKm/tiSdaSPqod MTAXu2Vh8WRv7Exk97BTc2Urjs0YjRNkF2TxZ+YjGIBEy2OJZuPluZeictmNPVMLWBSnOjIz pxKVIMSYo6GsGZBEXcxM9KXc8AvoCf8SRRUHmLU+DTLxCwZZ/Cst69PrUyuVANQokFwGhfnp EAysFWzAS9igCP8CLMMwFZEgTXPMwWelqsulZLGYXJzBmYmcnMfTZu515+Y1Z156V9uCiJqb amqmzUaRnI7YgJH/90mAErUjVjDqVmqpWnvBHAWHA7Tg/4N/Yf7Tt2rtOWWnIrCyg0QfiZ8G IV2AMSnH/ql3HkDfRpM2urpbo68y8GEEMP9Xkiqmtf/9X/+voo7k59+jc8Bogugt/iT1uJTI afxgMadpMmchBa+uF/QAXAIv7q1A4RW4eFGvBdxrcbxstH7Cq6aUDt1lccLTUWLJoCXVXkkz J3xh6hqZ0qcmb9ftCZOQHK7X7Bi3DouqVh1Zc2JuKmtYckeLXh4jHPR5Nnttk3MbZyVny3M6 RvkJj2OciEUqk1L9ys19FFu45usvOwNvV91KbHxppsdxNaiq5rj20ww0ykRbbXAN4vBfDO+q u8eNaikSc69aFL2aJfn0asJsDWrWkKIzsV4taeYdwwzqNYV6VQua7dhTOR6qilcbUGeqt5mq 7UHeQUPq5aCFUa0IpbOdOE1DTpOiah+kfYmTXAc8ktHzoG49RKQmSY6QjNBTgYlb5Eqi1tYA mwVyrWPaTQKu1MPFbL7bhmCqhdKBEGkQzFHWl1yyHbb+N03/f+oNlm5Tx0xBnp8/y7L/oveY /v/Zs2rt357dJhJZz7+4/j+r/6U6/lbqmGH/V3u+uhrv/9Vny7X78587ePRpDbDIAh74fFdK ifq92esJyoUGvpE/Ovc75Vzu0O8EKHscT8gNA/onwGA5eBksnGBEDPxyHAy80RVd0gFo5I8B GKGMCpnrh52gG8BmkZyroAeHoT/qB2OMjT0checBOrOmG9bsfqDXCy/wQBu4byfAQhRbO9f3 x2u8hC0KFysO+M3otMOOz7eygSN68va4d4wBEtuKDJKpgmwb4JVzui2tbIXtSgedGEZQabvn BX28O5aBCd4uM9RQmEAzOxPpqIGQkSholK6PjNo7aZTUVflO2CbjZE912BL0BYjxkKPvjX2Q 1HqRpruEQl1Gha3G6Dbu+QEVJ0e2Xp+8sthDB5A3idQZVJ1u44BBhqMIMLhCG4VJxL7H/UEH vvo4WgCjfjhGT8FIKhiEwKqCc40huV4n4kRhd3yBo0hFHY2GfhsHGBTFDQC61xn7Ax5kEV8I zB29azRFc//N0Q+bh3UB7weH+x8a2/Vt8fpHcfSuLrb2D348bLx9dyTe7e9s1w+bYnNvG77u HR02Xr8/2j9s5hY2m1BygRI2934U9Y8Hh/VmU+wfisbuwU4DgAH0w829o0a9CZTZ29p5v93Y e1sUAEDs7R/ldhq7jSPIdrRfpEqTxcT+G7FbP9x6Bz83Xzd2Gkc/Un1vGkd7WNeb/cPcpjjY PDxqbL3f2TwUB+8PD/abdYHN2m40t3Y2G7v17TLUDjWK+of63pFovtvc2XFbmdv/Ya9+iKjb TRSv62Knsfl6p44VUSO3G4f1rSNsjXnbAsIBejvFnPTkXQRa1KEtm4c/FiXMZv0/3kMmDMy1 vbm7+Raalp9BEeiSrfeH9V1EGcjQfP+6edQ4en9UF2/397eJzs364QdYtJrrYme/ScR636wX c9ubR5tUMYAASkEyvL9+32wQzRp7R/XDw/cHR439vQJ07w9AFcBxE4puE3H397CpMEbq+4c/ IlCkAdG+KH54V4fvh0hPotQmkqAJFNs6srNBfUDAo5xpo9irv91pvK3vbdUxdR+h/NBo1gvQ VY0mZmhQtdD5UOd7ajJ2EWCVo1drwBapI0Xjjdjc/tBAtGVm6PpmQw4TItnWO0nusiUBZq3/ u96Zj+fzt7HGzFj/q9VntWT8x2f38R/v4vnWMf/4Nm69EZMDvo3ZbiijjW+1/UXDOwc+2yyL 7QA9n5wFIt+Rb44Fxre2AcbR/sFGubxULueUIcbDPHwrLPXPlmCJ6AYnkOft0QaMThycZS/n 9XprmOntUSEHjOL1ltqzIZw2fiFL7P0mf6HIcfvNXI6nYL0FDKu5ISuLAJApUFhyP285Hz7W 91rv6pu4CBRyqdj2h0CZXG7/9b83Nx7mh944mhzDio0mVY/K7SJNNHgLiw/zF/Da9kYdSlws t2Ebm+M2YdsQQiH34GEeAx6Ldr9T3DwsiFEb0PgekqED8HQdIYmH/wklNeQ1VRnkUu1909ip E7T/gI+7f4bmF0RpKKiMU8fWVgFybB0cvNnZfNukd/lWAngvRSmE6nO58sG7/b0f1wQV6/ne IEf/ruUelB7mD3ch96gr+0dW8k9rQfeP/WTxfzXmb0MRcIP9//PlWuV+/38Hz8z+l6zza8bB 9fu/Vll9fq//uYtn7v6nhff0RnXM0v9UVxL9X31+L//dyTPD/jchASbMd1PsdueVAeMhursD vI/SaklJrIU73da7VktHaU5Jsm135Uj1z6GqQSxOt0w7GXmDcWvsHff4CijeBcVKo/Fo0h6T Tp2LtzCYWmss8A9q07ngyO+2UGeDvm8pTlqrH5208IZ/GqTzsOeN8ZhDnhKceiO/s472UWLo naCzUlLpZ9ZJYflCEM3o/GAyQJ0Na/0ZG/ZZAAX4ZR0Bk/YkHPSu4B/p+7PtB+cB3eDo+FZp qy1CfNENosbQaUY4GPjtcQu/5gXwiaAD+eGvc3YCVQaDxIlK0SKOWIQ/M/PbJJobPsBux1Ig P+oV4wUKqlUD/0K2iKngD8ajq9Z5DWCdwLD49Dm7Yn26gxmpYOBHUxAtZhItK38WEbLyayLA 35T8cUJk90pGAaQaEg0NKEbhFRMuQTcim0amTaSWl7Dupf4/+pO1/uMW8rbquIH8v7pcqd7L f3fwTOt/Evlu4QLYDPlvOU3/t/zs+b38dwfPH0n+iwtrvOWYQ4ybJgNeY9W/X/JhyQcJU4qe /mgUl3yjXkiSaZq8mmMjFqtrWiC0d1pYJsojAYsOGYviMSYVMRrwNxv4r3XXA+sYkYNzBDEZ HIeTQScPRC0+xtoK6roIZsK7QbowIa2xZjTQmp3r5woRjGCSw+g+etPiM+eWR7ZyHIcOyVZ6 RRGVBaChRHL+LLtrQwIxCSStC/alqr4B5QTBYOLBd+gGCdoApm+Y1cpn7sZ8SZPJraGW6GZ3 YFnDhu2GEt1rthJTupd7pO8NW3pMUJdo5A1VH586XfQypYes/qVL7LwSWQCxXoCU6G8rWu1k YLDhJkT5x6cGDWVxZlct7Ybbab2b3rVWv1bkB+kubgPpFe+p60vMdp8Aw4V/a4pEaD8Hwx+o lG+XJSkkLdplQqvg7AnlxBv5fp5GfLsM/SKpgHBVG5zLlDIhlZrtMr8W2cJssQBfXPLadseM MV7W+xNDXaNP/8w36P+xnzT5LxxEYc+/PRPAm8j/6P/tXv7/7Z8p/X9rJoCz9L8p9n/Pa6v3 /v/u4rm3/7u3/7u3/7u3/7u3/7u3/4ut/7dmAjhj/a9WnyX9Pz2vrNyv/3fw/MPZ//Hg/Cc2 Aby3ALx/7u6Zwv9vzQTw+vt/2Ic8uz//u4tnnv5XPPdm1l9z2H89j+//a1W0/7tf/3/75490 /sf2X7hB2N+pt95psy/zJeWk79IflFRwt9SjwL7fd0y9fIyH+4s47nntsyL8mcDO+mTk+4Oi aF958C+ptvveCe6Ti+LKx011UYaJ+wJb1l44IiupFIuvSTAYv2iNTUAU1I9b6SZH96RFkIRY W153Uo550w/PWjWWklmm2/OiU2HKkDlX1MZW4REE46vpebj/Q1PUnln03WmKF5XUFjlAZNiT Twjg8ycsRp5YdKsno9Zl/MPVegIKfLZzDb0Oxp/89F3tM1mhMbdhlOkUC760AIJyO0yJYpFh FmNevQeFdVMIj3170MJkMTvXadifkQODB03P0e5F0zMMJ3RqN0prAfkmaMdzK5eAGfkXI7tA 5I9bx+mZeby68DF7d2Z2eeLYCgYBqgenNg/jcqfDS4kDvq7sw35v7nf/TFn/b80E7PryX/V5 Zfne/v8unhn9r0S/r7ICmyH/rdRW4vqfWmV15V7/cxfPH0n+u6loZ7vv7gSh+0lvXl7dSJpg sc75GBTF34xQU3oF4kxZC3zogE48SXX4Q2JXyfFAKT1Ui8cKlhSwgs+WUVYxkYyO+2JZ0E4t 7OYdQYslNNs3UsFFzGCk8LNwQxdWf2Ps0TMwwsLUvyl4CZTRZ/CGTRXjNGmGMGZJmlSwdanM VNDOxU64MnSsFtCnlp22zjYtVgfLXq0WXFQyJL5sNFwUNqShzyz5kM16Yi24lLRMawEJz7oN mmBa3LLrTJc4qcokAZBkZKujW2/DvJaUqhvVZj9rAx32Jh1nY36VMDvKmkDS/VtsgDl98Ii3 IA7xHtFwjw9Bgxn0kYXVl2TLZ0vchLh0uCu9u1XYtZtFA01EWXoxSqtwHok9PiDLegdIRPqS u55EnwDXjYObKfLHrQf7XbRgk1wHfuDcuHz9gq4i/SLKuNXmL7glzamgAA4/LXBp8UgcbL6t t5qNv9QLrk2nYxCKJmrQAz4AaOEtqvz2/m5ju9Ws77wpCtVmg1AxcRVo1tMiNPD4Fg8bf5W/ D3+YbXOanFzC7mqFHGkenMSuSSQ1QyFpVHjDnZZ0+EdfBW7fP1UrtRXpP1VFGeWHY43K71aU UcFhRjGBLAAL59GAkOBoo2rlgfdCkaOYymijwtS4/FlxUhGfbZoqE2Wm6MYs/XJ/bvBbPmny /zAIf3//f8v39n938WT1/+/u/+/Zvf3fXTz39n/39n/39n/39n/39n/39n/2+n+X/v8qK8tJ /3/P7/2/3MXzj2T/Z23SyRQQxuk0O0BlCWgb/MG3TNu+mcZ8FmA2tSMMwrt22vcQKDoCeIWb mO0pI70sG70Uu77fe4jeP7/hk8X/f3f/fyv39n938czsf+JxN7X842fW/n/5WcL+r7Ly7N7+ 7y6eP9L5r/L/tnXQ2I/5fdOfUq3unONZ1EdL7wujRb1i4/YTv9Iddv31+GpMcXREgPZ+aHAG OB3BBh32nyc+RimkBIqSBltXTyAeAhtOlDgkDX20hu9iOB5hMTxnEnTXv4inBTIAU3fSo0zy Dn2laGQJyIQ7Ytiz4j+DUPRD+Ev1RnaZfKlaKJoyF7jfn8DO34ONcw8VCkAAqjdnQtMsYita BMsNWDNqx4+6kWxF2dxFDMG2TsR4E1AVeh/NGYKBpAWRoUlRwEGiArnEb497V0rdgDmKei9O WgCfN/d92F4ID8gLXX6ZpKUQMQoZMvoyQ6m+t4+7QUOODrRsEI4Feh1hfUhg5W7sfYD9psxt KS280QmpRCKmPwas6gWdoiwXe6Qug0bBhRcZytPBGbk7wUpbyDTzYg6Kp5xO2Sc5izRuUzOZ nkpJLsih/BrZuqZz6jAOKBIgpN4Y6aKZJOjVws3f9y6Vw5dcEkc9wAbxgaVGhmymJq0T4gqJ M7X2ARHi3htd9pO1/v/u/t9q9/Z/d/FM638S/X57/2/PapXnCfl/pXZv/3cXzx9J/pPalwXe ciw4dn1oK+Aa9vmj0SDMcuJL6wOsCwH6h/20+lkJhKLjn9PqY38LQOiKf+vjWVHs2yToJPKd pHwb9ILBWezbSFbs1DEO+ljJp2rVKoznJLDI2hmR0vSNMn4RSKBW2Gm3Tn2vg5dMchEe6YB0 hlX70gMVHnflbVmi4+GFljSxT39b1MF3YzaP6/YnadaTauVI4rcdjl6X6gQnwVhGmkQ7GkQH wxu+FE8qT8Svvwr14dWGePLChO+UspssSVCEFRGxoAGVEJA0ImEU8/hnUbwoiKeqeumvapHD MEP6etzU5nbEZ2WJh9R3u0ssnrrUxB7/2flEHf7zuoGgxR3zjVHBtmvLKkRCdkHYzceqLRTE SQiid/3wkAqcakmMwiojYDrAM5+AaBmgdI1ylJ2WXqlxW1wtPuYWKSsuU2u8jBrXRWAzj7nN yUJztQ1Q5UrhRQFyQCCdVNOomU813VUF49EAg4oCXsQ4imKh8hz/t1BczWoKV8UOzx4/VijA z2oVfitDWQmYpNWFo8PNxk798JtvvlmAZheobMEJ4gnbQ0IKRlHpFTUbcDYjgj5zT8ngsYsF NTIojTa1mMbA9AhR0bCREk81wBw0Zy0nYhgI3G1qb3Z3sz+QrifddOVz07YHHpHpKYYzNSZ4 nI3aKUPLqpIv43UgTnYr0GaVYFqznVrGc/ox4i2Lf5bcBdHQxTSlS9Ukz0rJzYjTE8cevz19 6vykAVDaEApASU1WQVOUxjMnMW9LAsVO/MpdVNaKMDum7TcYAVsNfgIffC7jj0Iigu1jTk2N XWsmhrJSnbbZxi832G27pFBcXI46mnGy93CxovUjNgqtXicLaUAjJQ/pLdTamV9fzxqTXNxe gqhZPCpZQ2OPLlXbnIPRRc7uB42hyi67UDOeIvWfy7kqydFKNZRo9ZOWn/hBmERjFX2/Mf+9 npT9X+e4hOq+39f/Y7W6er//v4NnSv+XQV4GBhqOvtYIZMb+HwZH3P4DNp6V1fv9/x085qAP ut0bBjnS/PA7CE0oqZfbzkcW3+Hj7436/XMLz5T5/7v6f60u38//u3ju7b/v7b/v7b/v7b/v 7b/v7b9j6/+d+X999jzp//XZ6rP79f8Onhn235KX/+7W32ipbfy6vtskj66nXu3Zam5u++64 79akRbkc+XGj8q/y8SrSnLyKn3jpepjHq+xe+1QERd5syXM7CUBuuR4G5bDgmGbnXAz/gQzQ 7f0mEft0TcT2oEty33maSJB7z9NZduxi7J1E8dKK6PJJ2eeKtG1uov9BChmH7bAXLR1Oen5U 7p8B/f1zryckNXY3/4wOBPaP9rf2d4oMr6iQKUIdhULuj6L0nML/f0f/r9Xnz2sr9/q/O3jm 6X89U29Yx6z1f3nlWcL/60r1fv2/i0dZXYvt1y2U2FsfNncaIDPb/ldTkiw7HMma0Qgnci10 Ytw85oMVmPEvonPc7rYGYcsfjULcFBb1l/Zw4vzu+/1wdGU+HXudVt+7jH+GlbkP+1pyQtQa h2ELD/8cQGf+aOD3nE8jrw+b2zM8joJvrWPo6haOeEaL7VQPPNyM4labDIRhtyw8weLJZOTx ntiYMUPawD+Bz+c+2pgc4xYcDW/ZRAkK9MSQAFINImy3JyPYzwKAfAD7elSIDE7EiTc6xqNI p5pCEbfEnhiGUUDwAWPOIKmIYSOpLh8ogVZBXAfaK3f8sd9G3YpdC5kHt8MR2m7HqmLzYIck qvV5+6tYXCSrAx0vE/9ID6KYD7lLa+T/feJHYxeCnZIFhc9mU3qmFZ2GF/nkd2wx2qgou9/f e5L9gZ8p/P/39P+5+rzy7H79v4NnRv9LYVhN2ZtZA89Y/5dry/H4z7Va5dm9/v8uHme1Zikv ZQlX+664r83B2P126Q/Qa2c8ozLe1RIF7OBh6956t9l8Rw7fxHItJ9n8Nbk8G+hEF8EYNtF5 +YVUy17k28LEmmv3I81WFvZ4cQ67YuvgfUT3h6TO2O8srCchsbyxlgJpsx9OBqSa5zwzYDny y1o2LO8y6E/6CiZINKIXXqRhxnJNGmZ/phRp1jSzhVIYWkvC2UWVOQgMh5u7eBiA3vMnY3GK rueHeCw0GCfgpYpjaxriFicLTBZBJJs3OJFwYLR4k9441nUJvN4PzgbhxYDlnAXLqght0jt8 SgICl5aHJDcjkY0Np3Mpo8uIVZA/Ju30oxM58qCKH3ygAchh3lj0fA9PZ9Cn/sF7aQVGsYxp ZqEd4jkMxcg1nbIG6XoMZBT2faFFXBea18Pwv2O/dXacAZALxmHS9UJAZS64r4SLPnxzq3GG sarK7lYJ34Jjjwm0q0ULNOrux49RPu75g3x65gJahu9ufmy9fV9vHrW2drd3Gnt15Y/Wxip1 2MUJ4Qm9FdAU4C8t29gvQVbO45jU2rsYY6J4U7nZdbKZU54vHXDSiJqN/RYLFpTZfio11vYA Z0QKLvZfI7dTK0xVLqyp6H/5w2jH/vmfVPnvVr0/3sz/Y3X13v7vLp70/r810z96Zsj/uANI 2v88u/f/dBcPbvJO/IE/AsbeyS2Wh1dtPhO657//Ek/6/L9N72+z9//V1bj+H7j/8r3/17t4 rhF6dZuGymseKTcPwArf6ztvTE6/18Vv26/xjEF+k7qIrw3W6h74UjJUHS/BNf9WMV5dJNQJ fAmN0x6VifMGsMtJNxP4qpP93Obh1rvWu20gnMPkly5frLaWa+VTkfy8ulI+zZWb9a39ve3N wx+xWg1FGwsAy8CtpTIZUD/bzi/dMqvQ8PQqgs3i0C6pv7WTn9JgwGixi+PPtvMrrZDkbnZB 9amd+JKKuXcC+xrvGI/7JZ3sNiRT27Gxl/akFZ+n8uXa0POn1c8Z5kFhJhYZBiJmUPyGEYZv EGPYHdKivERfS+MQrTVYuEF3MKJ0q08ud/Bj62h/f6e54dbYP+PryVBxDBc+B4wgIZdzp+Ej NIh5mFcQC04vupwJVa1L6HqpBL1O0ZKg8HXyz85NmRJd6gqNdtce/Hj0Di0poRcfLsYY02mR +dL91v4P9KTLf4cwBnZvx/n/v83e/61Wk/7/K/f7vzt5zP0Px2ofL4LkPvoDwUKfkFKf4IEB IiFa2wdo5sADiNkvHg7ACBrhFQdlag9pW+VcY4x2/Xh74RhkHfhXSoNFwXriY1y6c7m9/aP6 mhBv5J2BfoiXFYr0ruD6lyAYjiO+FAIwR1EOBKeeurUAGJ30wmOvJ869UYDLmUDmBIvBwnDc wk5coCA77VP084G3QCICfx6MxhMo5XU6Iz+iiwr4eRwOS/0wwiC1J/AL4eWId0/GIx8Qfv2+ sbMtGnvNo8P3W2hE3lzL5f4dL3bgTZgFdHMH9XWd9uCVg32xtVPf3IPMr9gX3u/lajd9/ttL 1dfXcQP93/OV2n38l7t4Zvf/168Fs/h/NWH/X6vAr3v+fwfP0amPZm0jugIXoOuhUdjP5bjr 5caXREsZcw13w8TLcHEAHogsUnjktALWAn/oDzr+oH0lQs7F58JtX/FTLMW38cr3YuAf4Zk9 /61NzA3rmD7/q5WVamL+V589u5//d/F8+83SJBotHQeDpeHV+DTECd4fhqOxiK5AGBz56zm6 Xik3rEImTgZ487SoPhcFG/agA6ZvRdu26tD+dXO48ySlH4Iuw/fzT+jOLpyMUdVsf659RtNR 8lBlf15e+4zuXL+9vYeQtQxexbe1NYF4BmgnOyF/wHhXlxLpWJzMnAGpX76s56Q7N/7RhfGh fwBcVsToIp8W+MMCRkJkC6UFx0HRgliDL5B9udYCGZVzcIJ+UnIAa24NMQjnQkoOjaNT+8LC guVZO1iGlFbrI6WLau7b4cg76Xsg8LbP8iuFHORWjUtCsfPKrLLpqyuxpq+uTG96q+X14NOL VktgC1ZXplFhSuYkQdIzx2gj0aNWBV05nDv5Vuvt3vutVquAxinfmK98y7O1uddsQCK0WdNz u7610zqsv82zkySaKOIXXbMYiW+/Fexnylev6+KLDUKjC69jvh/tt1r5PH1H4+0XqBr+FiPp Tqs5UWNqHW8aH2FDJy2lzbBgmsiBsboCA0P1buA5fYs//1g9qyHD3nQCG7YFJ3MVRrvocUp8 IOi2uFNkzv5w81M9WQWqq1hC3YbQJCMLSI3bpyq6AGWy3zLTwzUf2dlwMhbUXGLDQ3KJSfMd WC9IdBvA/8vR5Di/8KlUXvoMO9mFFv3TerN/WG+83Ws9ilqtBfFISCZengyH/ihfION7KOx1 BFciWSWx9Bxuh8nCKkD1AH1bo17rQo0hiJDSW9zCaEH5OCMgTzdEt4xA8/Jzt9zuhZGf5+pg 6y7rUY15yj25tJgTi2IIVA3aAkaRWqxI9yCdxiJOjyLMZ9THx1fwSZRKYnsfL6SL+nbjCHIs mVgFUEJ1O+Ss5rC3gBp5XEKKZuGqfC4KJqn6i6dKXVppkAiMNdPAoC5HJWaSTvGsZv00WNCN Vs0BSZxzEIXZpnKAXYi+8rxeL78gkf30nz8NPj+FniS6FiTx0eaR2xJoEq1p9fDIP/ExHrqC 8VP09FH000/H2F7+sq7z9vHKrxw9FBsgT6WLhFPB5AMS7KGx5MYGF1lzDixQPxMMJr6Tn6tS 4wwoi4VlqyqfXQAjf9jz2ihZyHY9xfEL/yJKCoSBjvz0GgDWk6QBcmTSxPSdnFOSJLIOSRus gbo2pas7fs8f+6pniiRmoWAFC0l/OL4iAJGc1GbmOl0OoGBa6Y5ft3PLM838wtJPi/ny4p8K Py0uLSB+5WaBQelyqcV+GvwULVIFVhH6rSqTw5Vlx9ho5XUSBh6ncj9owtJHHnFQxy+M3uCn L+tIaUpkQmcOPEJBYqb8GmYMPYvyZm63Tr0ILTxxlkObzBynyuUgcgeQBYcbB1Cg+C/QhsGX dQmEUoqCYREi5ZNROBnmq4XC1Dmv5HGXipKZoQceTo/Rkb9mEZJTfy9Kcu2zSClbmEZLTppK zBiwmONwBkr/tsbpUO1f0zuIRWaby/OXOJeXovUULm+TkcQ0sbSIy83iEqPIK4pccYmZrCkm kZvC1K/BTK/BSN2Om4OBarlDMawkE7WYJOcuuI1llpHNRtKqyBuWUpCVybkIqVUYAfiF+zy1 TjX/nqrBI8dSNG0epiJizUmFiRpl2ahkQgMgrXE6GBScp7YJRGiY4yNqCi4k9As3u1rap1Fa PvOvojzf7qQc5SgcjfM9r3/c8YRXFMdrAv3FoiH/caGIf7wCzkA6BgE4LPdx2WzC6EGARYox HD7h+2e3HcMRmq2P/GjSG0M3KFlSiqZAhgsUJ7tlPJny87qkFCLX/zX1kbP1f8ZU4aZ1zND/ 154vJ/x/Vp9V789/7+KJKcDWxAWeq2KYLpAtRt4g6kndl5TaYFZ9Egt4i6nVHrVAJojkjls9 nObJNPGZglMwr6SiSO5xC9Vq8YJQ3TA1YThudYcALv4dK8IT4FQ0UFuA+3m+MzP0Rl4/noWS xyPyDX+V2ozxlCae0EUW3KT4l+M5s8VzIC+jK2Gp7WYUgr6fnZqWQECjU2/kd1LT7STqH7V/ pP5RGsF4KaMSghQ36c3O5lHrsLH3ttraasbLWYnb0xKbzWy4ywB3dSWz8DJAnprczEr+c/1w r76TDV2mZ4KX6RL+tAqmg58OPA6aNay/LNeKqytfYr304e3WG+zB53xdKw54RrIsPpB33NJL Z6Vy4a4X9CKv67c6QUTWhC3/HHepqbDmzcygo6sIbTnmgjxnXgYcUticVDg6KdYDpAVNZq9/ PDrcRCVsSqehjRzOTTcQnlFrhsBRl+NIoEXeTv3t5taPLbz5+GHr4H1itCSuRPK0nov/p6// txn994b+H57f+3+6i2dG/9uG0TcOAjxL/lt5Fo//VquurNzH/72LJxn/rWR8QKIZ4AvpCrpt AsCVxPtysyzehuewDqAKUhyMQth9+UDJqyJZ7+13u0E78HrifeSL/UHvanp8uJcpXiJfxeLD aaX79v5ui+zu6oe2kyrnq+1+gi0NyYgFECanv65/CpnBPwcUMtLwSsNsTxdxV1iuwyvxi3iL wuDqSpFfyE6fXU6xlIjR0dLiG6uTPDS2DDrryPSBNo29NfmFfFz7o3PyEg2k/R8VDFJDxyzh wC87IPD4niAgiP33R05ivzvgNJVIyEnQhF4afpiFLrMfe1HQjtZF/AFgkZ/iP1G7HMlJKKoi ioUT9kh97nwHkkfjEK0SOEXSTci/gNt6rGJoxZr4ATc1qKVASlFeDBiMjG1MnqzlvXV2kdFS EaTJqgmeRRUd2mSE3QSKFmfJvCoFsn8x996xmTImb9MfT4ZkDBUMgjHOEfRB4VN3KXNa9rvV Hvnoh+G8nyCobNtIOhtDAJOIbvwDELxZj6rZvIrSpXdcCQA/UOBpisc8FCYfW6x2JyNy7Y1o 4hgqus0BwPivA6+xt0T0bkJKREBoSLB1cHmO6ygIw472XGQXGNJ6rBv4vU48jnAGGDRp6wZk +Yv0JPTDfqV1fuK15OiitkJvLp5eqE+UT1lQQG+ji3GKISwPyH9vdn3rT/r6f5vRf292///5 s3v/X3fxZPd/51jfA7ux5MfPDPnvWWU53v+1SvU+/u+dPEqowht9wORoAVmwu15Ep+Gk1yG/ USo6QydAX5G9qwXtYXFpcVG89TlKR99rn6JE1h2hjQcvayfBOYZdiPxJJyzhBc8Adueco4wW FX3cANO1wgIFvMMNMXzjL3kScoAfw9+i0PtlAf9SEPnFRe12E+Sd0s/+KMTTrXO8y4GXVBB1 j70+Je554KkYL7mIBge7pJwtzNnCbBIJDs+HGyJeNhYFL5VUjUaefn01ViNvcOLPwo0yTUdu +lKZgvmMEq5fTpRmVKfvvtnjKzlyuBx77TMh5Rzu/FgbaSdxRDFJzAUikDbompDHxh8nkxDE mmqpivLJEJ3IJQYKUSJjpMTaB6KIn9ldiM2ux/gOpc9VvB2EV5pMG1h0lC2gMyk8fh+JaIin kwhDRqrJEwxp71XQ/bpwHvgXCyzdQZMI+/kxp4jECCGzFSQ1wu4Nr2BzGsmB6aODpS1j34rR ZyaMPhVA+R4nO/UPCUZurR2khRK38EcwYDh56M4khCcRDYEyE6uQM7E3Ud56gVhxQFMGKGP2 ICyksBo9VmFrMMaFP/pmAv/g8EIPU1q6e4FSH1LSLfbBrgTFYrzE1SWRenjFcXXksH+DV848 NKzABhuff/JyRLL1HEYHTWVH46A96XkjnPoTvyyDmfZ6c/aZkZNTe26+3tq+UW8pyqGr+xjB 6QodtsdlApYIfitdRrPqK7osUh1krvPpy3lJGnDf0HGxfT3e6qRrd89cE4s2YgrOprmQWJX3 ECOJuctkmFJOzNvFIWRssa9txR4i3H7ax0NucxQP4u4yuTRyi9ZHytRn3J2EVt8zhN+UDgWZ 8GrtlxPG3vUC9rgCaBqhpqZBSJNPQrnZB2YfpeMcH1KkZFGwaSsXJxD1KqpmMPu78AIaM7hi GlNuS9boA9HsfsGl6wAWPb01HalbonKIHeweJMiO/CIa+6P0MSQWNVFTBkSC4jIR+9iqqBd6 HXSE0Yp8oqCpKmW84tcYR8RPAOv3lkvvn7t5pu7/vnLfp57p+7/qcu1Z3P6juvqs+vx+/3cH zz+g/r/V2n7detdqWTcu5IebaP0Tmn2VQOZkZ3No/YHZljBBejFwTwTs8zMrYSHpd2khMxWd NS3QUrod0rZRtptCHpKpPwkIZNBWtqN2fKgfvt5v1nPG8fbB/s6P+cviVSG2sbv89tvWt99e OflghUnklPng37EB6i5W5pFAeGPJq5Aq0p9epJ9WxNr5iZQi3UGsQJr0YhWwkuMF9XLrVqgK Gj05lzNuzd8f1A8PNt/WW7Xd163mu8YbjDD2XUb63mELBIimyFff74iXL9NKF1KKVt8a0NUX GRmyYeviBeswR58Aqa7kQQlyQCJHf3YO6iid7mQgtbpdCZ2BzaonLRNBMlWpLDm5GVldKR0H UBVPfdS3dPx2D3sc5TPt60yfZlljhcHhNsUZQLdRixlYphJ7sDl15FJ3EVpYpo0W1Agbnu6k JzqTkQyMa4Tn1MM6Iy8nD+qUYMtHis5+UgvOKGQquXndKmc86e++2YuEF8n8sCcjRqUhpR/b xatA6za7BkEKmksVTUc67M/RoRy3DoVeGV8XXtdjTUKfgyb6rtW2sguBfaGN+hH9IrtBPNEE KAiBfvsowfPplvR6U8azPi1b8/jY5Q3O7TgY49BC7G2bncLbStZIN4nVVPb2dRgOJz08RsSd V98bxjdNfGxpaLV/MWDyqm1y5O6bECb0QYs3ojP3TbAFHTnw9ZEj3wywa1FbGO2BPpoM/ZFK /e2xdnKHI9yLKvi32kY6lkXHGGPt65Acoav2n573W/rsNx/fHyaOYSU/2gr7sP5zbbgxtRXv SucqxF449lVAbZiUmFHGXQa2deKPJGeTsbHPvaBHqgYz6/QGnkmJESAucCqRYNI+9dtnDBlJ oMIrAEEpFIAhmVbdws98bNEhxVPL1dbqJNJ02q7luTTIpLpUQbx6JWite43xftGdPDRqB/bF 0iVJeAKTRqj9MYeP9gY0v/mmAN4L5fBc6K8EGsaRq/HOApBxXHY22qmKIK22orUsiFrQp7Fv ZGrQCX7mM2c+qqePSS2l0aUc+b0eteIUeOboPIho3ntj3dOoh9eOrTxbzxV21aqlw3+A4Hju 95Q6enTW8iJL0ZWqEhqOW1SoNebCsakAC7JB1lg6HPun3jkG4Ga23dimKi/bGPMCwHvDYe+q NQx7QfsqOdNT9DYWQREQLyOrK7AW628BNsW3fw4gk9/hcrS+8qwZjEdhr0ch3Ilt6pOJyLec igFNz4NB4NMhDAyDrlQ3suJzFOBBBQ4W6he0PI3KSu/Djcw7bdKqb5vlLPLduulHMGnl0Phc RlvD+pB/0ELlHipoqYnSirbQ15v4VnnJLci2JQOEFd8NS8jV6JolJY9jssfpYwpEAQDtWl+6 Pe8kKupBsggvEiKyFSm10cIYB+qIpki3yGmEDM+SiQrkiOVHnX1KbinB2rn5ygRfA8isADMp XtAeX45leT2oWmiLM71RfT4UNTpHE+s+crtEnjAcU46INLjAGHhm8Gnj6O+clsBXj77R361f uG5fSJQDEFL66aUT+MZnNyw2mVDRfG0GUpjF+pkOTfcLDJdOeNGSMgdQKbv3jyO6aCY3XIlj antDmrdSY7vLjPNlWS6ROq20dQKcUppSi8ItnzwzjWOtUmMVu8eKFkOigio1Vsg914oXUqkJ 3YB9MBovpFJjhTJOaWShRGqsdPr5gqoynhpXF6SfqMjCidTU0rGDAd3aWGqsbIauX5ZNpMbV FfhTOesxuifb+GMh9+3EmIckC9Jedb6yvCcKonZZTMZBLxgHIA/nlGg9aZ+iDAmSJF49I59y HfqzcLlQZAPFMxj8KOf0J71xMCSBRixcLdBqXb/0+kMMST+EJoPMka8uF6uVgtgQzzXSnJS/ LApbp5XP568KpWoBBMh8/hL9L8Bv+AFfHuFrweCI4v8E+G8ka44j3G6H/ZADww4Qb+FRFDdC 8OBw/2BNXIlFKUm3wm6LYLGKbUNcQs1nRSEq4uWGOBMvxZXTrnip58UVLFXTrUsFi61z27Qk 22RrCeuHh/uHeZD+o3K5XOBrtGf5hU/brz+LBfTfFRVI+Uq210apKIQFY7v++v3bBAwuy46K pmTXVkRWjs1ms354lB8W/oltL/8Iz5TzH9tL/lfVMeP8p/ZsJWn/t1Kt3J//3MEz9/lP9Huf /7AXJ+V4mg0Ng4Ggy7sg85EZjdSCSV/RZSzQGBt3TwLDV6LJx2RAK6J2Da21Lco5tNybkIso hCJN9WHvEmWa7g/8C9QEkzmK3BAhBspjlD4uGo0G4XynRPosCjK0x730NNgNRWdZEVedpRkP kZCo7GX7jfZTMRn50p+2VON02brp4jTsseaqKEk+wrUNQbAXbtZLU8kLWmCJNiO6XoHmTpU/ CbE5dlx5a10RjaQffNI+XXjQebCEQkowLloeZdtt2H0PxkDQnu+1z1CZQXoYrRQvc4veo1Wq hz28cBEMQJ5fUFYYJLVJYyZjJ3R8pTbtWDruwlwNj0jrr7TlU+BffCLVEkat/SwO6836UetD 4/CIFU6bO423e/Vta5egR1ZreJ48vGLZ2cqSLlry9Zd0edjJoiS8dBFPfvvho3AFvrTgJ1p6 ++HjfDKgAb5cuzFwFY6V1LX+RUufGeTNttrSCbn3NLSix1YNoRpoFJyr+x9aYYA6IDfOpogp GEC8qqzbByboY0ewjz65j//0rPLZKYjKjeUa+iyFl7Cbl/nIYQsH8aTZ2ooQYqjVAY+5XFHB RUO5DhXSshKLY1uoX5XHPJiROE+z2dheE+gKaUFDKPAFKfLhpza0BXl9LMfhQfOKogXM9s0G 5lbBk7VUuNDgHSUVHYjGtlAxP/OPer1JgeoksNIpjdTKluqNvQ+bOxyLN8dBYWmYSz6pOxYx 4S4rSLL/uiHw0vP2/u7W0U5ra/sN6bNoHlvBUGO6I9yoR+ReT+uGUuKguo0T+YU3XtBj6Z3h KVaQf9ThpmFAaadhcqh8SekbgqDtPZnqgKkCJdVURnNdkZFOnateqfe2WrB59OTZwsePH9fE gT869YYR74oooC/51SH1u9/Juqv1VZegONyxdRiBf9bNBCJaVal9sKUHrpR/zKcVlaKaDaZw oaCC8e5icAXcT7E7Clzc9VJLZwhUQzcsa1O9jcReB9tWesWXD0uvnPjFi6Jaqa0UhebZPCoQ oDxgxMnqlNdqQEIx1skH3ohCYNd33qxBr1oTW+228+KxsqxznmKsmvN+eeydoMMtZlfpuc2F xOlZUlKVMZ/zzAgOPK296G9wiB4IO2VuuexBPKJGtVIE62avd2X1X0ceAikSGY6ejxFD8fSU NmZ9vwYxk/lxJDK3eSyqqfmpE8vpbMSlmBaoNrvoAJoOv1gctZQDIx8mBZ6goZQDnGwUXrnH 6wAl6NLRLgAAgp+EIJNdjEI8W052S9MfjzEXhvHmiOIA99GkLN0tmtFtDVBXxa2al5LdbexJ CKDpXlALZTrsQJoYv8hQ2qin8YAYl+ORBzP/xEOzbXUyIsOM0zKlcoy9jjf29IEoNT3vl0/K RbFAJ1Neb0EeLgIbffdhl90MStNxqXRPnbU44Z/ShF/PKU6fRrXJ0Ip/TpTriD+/ZuJJ+Mqb nUM5VGQaurk55yCaXAqzkaKTMcHHYIxNNmcrWGth1jmaevJCYZ2zh/h8U0gOEGOpgVnkPXYn WwXdEvKpG+540pL0CRxk4AbMN9Yi+AV7snwaxnJhAsHMg60mwFbeB2N0fq2ke48GFW8MFAs3 fe2evcslTJ6LcL5jSD1bt+ocnq85IJLHLmbQPE40YVIenmvY85GDpoMkSaxzlIyjkZM9Zfu1 jREG5vCpd46CmbRmSlDGNM3ZzcgTnLwRHCTbZIIVRUyAceBJKiZxpe3EWqLmzFNGQ9vlVaeG NNHPIoGUb4kERgyEarRpjbq0RTdTIA0EeyUXTj+ivd5jREz1ZHAP9XzJzdOZy7VZnZk46rVI WbsdUk4hYbLdM5sdb0BiNLLpXOaA/Mpem2M46y+wpfUmvXFs2tmEej84G4QX6kohMVZNmvik Tvadtb9iynyZn5uq62tSQ8IOM8kKLimTCfL+ycNiXWexFgOhc7i2fGaPk8u5OKw5a6AcL9j0 opKMjC2G+PZRBylC+wtHIuuEchziroP8y1JRJV86eb+gTg/vS3FepN7m283GnrMEVeN7RBdB S27jrbA9jqsFtSe0RcMv/wihLufT/2vNzY3qmK7/r9Wqy/H4j7UavNzr/+/g+cfR/yc13ycj bzDmA33UdUtdLSnoOpN+/6p17tnKWltDa2lu1x2tY4rGNcUC073xQGYarp+ixUhqF1G9leFQ gEGRQSNmfhBbypXmTa2h5FeaK6DtES/qD5TCrapYkH0hklkz8XJyUpS8Vq6zGGvnsrakZG2O de8C3qFA+r37orqnLi+ja90es3/Mi7ZJSQ5Lra2T54kTuRmyI3KiReOjzkIR8aCzEwbjaOXc NL3VYo9eLbIZGrPnK6OwgoYcB4NOazI4DicDNBiDbh6H3BS1/oEAgcUydYl2MzrHqhmRbAaF yrL7jUxNH3XknhOQF7y+idwDeGI1WwJSUvkI2Qj6hm4WboKhe+ALevFK3WjiJlOhQteVXXwI IPxFMJXLR5ck6aYgxgZW0tAsps60plLy6CMnbTvnUkCm3ovN0mqmXNlZdG7Nym2ire13bwLL m9LUIneeKBttvv/r1CW/YOGIfySn2YAU+sc9b3CGk4BmDtXC9neJywuL+A69+DivJyYNg0R2 fVNhUfCFBaeMnMxa0YqOOrTttuIpNPKlBTTWSjF8koyC5nowSGEhlOJdkpaJ6sRUhpr/4WMh Dx9hCikA+pUsI5X6kI2qaWvOaJFeSBmAYMtgo6xYkni1IeQ3U2HY7cKUK2Tgx6lClzOwSlmg EJLErz6guzBxDy10jphBqjN/gIp/u/KnDqnwNIQs5ZE34Cra7YUXps0GyKsNkSBYk26hA0po xI6e5pJYGO90lHfDWvoMcCIXDk50u+8U0GIxS/uOrzvxyjC/xOJme6Th1c0FrHRODkRcEURC Z6NWP9VIewvrLHnW9ocaYz9PnZan1Y0Q3PnNOxoEtT4HTJ5u+mxiUR11WIsmL1VxpuFUIjWp vQvvKsKT7nNf+7NAbjvGI3DYsV1R9KheicNm6bCE7O5OXg47HXmdCw7nSqy0PLsNCuckDy2I p3Psmc3pThpfLwgeuS4DtKmcRBDwqwEtteyGd7lw1xqOVLPEY+0KkvTjFgeWMCzyxg/q+KIM Gyt0QzQIJl06q4N73hVQUh/umLISLoyfEo6fNXh/NOR4R84gTy92sHuwpponi7njLr0Ytwgp uaaKxUdSekEiN93E0wXdHkgvZtNRoWk+xcosFFJWSyVVxpmtGuh0fsncLzbxKJw8z3qcUOVk z0lPIiRaxfyI5B9xqchoUMy8tE5B0i1980ZOnjHg46BnZs/HWlliCrmXlGZAucaxTIxieOtJ nd8pM+CMg8uYEbFk4HiK+PXVH27uEhfXVf8uq4tUnVXVOpKpcPwS26HAD3mbUzp8ejQslXB6 QEIT0X40YW9FMAwnZhg6vRrHdmoihhVKtiVWZHaO9INyp0TRnIw7hZ0DMNf2P69dx2QM+SkN ndaCuTOmn4eb3Kkn37GGzXdeR+Gs5HhMCFWV9cQw2Qv1UFcjPe3Mr6GOyAPpg4iv6MVnZsad Bjn4Lb6Mu1S5f0nbqaY2DxHLCTU5XB6u7xtlagd0jvX0uZpQc+gCBXOAcI35SH8cz49o2GTw TOWqMpJdqv7CdTCpuX9ROZV0ezZ+UqtvYFLl2ENrRkC1B8SHxuEa7qV5KTVESOY8eLNn5bSw yNKiKPLFdB9ZnR2vb9epr2/qk+eg7pUzi0BKw3KdM+/Z4yMh1RSMft8aJNMqWVqyZAuo0VZT CYo0kiJSWJ1qZC2WP9zJiCs4yNx+cDKgKTmPyFB0PXdlZUrRp1n0llq1BIGmAGzRFDhAHefe kfhV/j78YTpTnJdrzNOdttA4HZY0FrOdj1fi9lomkXRcrV6gfBluxITIeO7BSF3559yu8JaA HXasPURyW5zM3fMHQsFOWaTiRYZS8aCRdxVHcczHLeneQWZNw5nNmEQMi4Sh07olfW+OyEtA hJvEEXry/RNed75CH/19EMHx2HjkdyaDjjfgc0G7OvRz1xrW+i3Jg+cRb9PaBhBk4xCIte0o xTdGCVCJIVN61e5DX1CoSBg8iXg4MZFTEQcD6HoDLoijfu/9zo40NhqPBu3hVUYV2VBS6i5V C2mSsc13TqXDmDjjUZ4VbT80+Mmx6cpw5pjxzLXRgU1Liu+kxcJ0wQqN5uKYZme+xp5CG9jF oeOOcXkVA16w5UqRvFHg2iyNH5RfnrCb015KrWgIFE6AgHD2i6CDvRuK03DokzFjUZXDvany GB2Jl2Ll7Wt1fr5cO9iskwFLfK5Y+NICgr0JMzgfb4e0pcweIfr+Z2xNSr07mneIThzV+ZJQ Xzupc61FNne39TTX6FQzG5WiStpLb3D0koxjovdkjQr0c5RcRvZyJqwBXClTe8NuVxjj/BR9 1zxAaJ+6MUvrJWVPv++yEbRPBDnQMlCZXVkhsRVJJYrSUCsNGaImyEjftiV0qB23ckycfPJ6 HFPdPTUdrg3aJNjrCIaZdH5fpnMss5ipNHmuNaUgH/glCqojsi/uyNMaRB5630wfetZ8/OgP mlgwg8Yu3BsRWRNWwbo5Zal4S5JUk0bjmEpULiOpmSyj6TllUMJWWJGpnD4/44j9j8psRCop 3egyENWL4tdfU7sj0c3uOeCJpgdbF9D1wtZ5FU8hTwZjYHwor5Ar9oIyMohv5uLDhSDxFt8i xQlvRhUP74ew1+c6z6uG51r9zgVwL6QW+Mz+z9iyWJxc4V4kPLK3DO64m1nxrF4xm38m5qfK 57K6bfX26A1bzcJ+guL/rCeyqjs1KVUkM3P8iUwm8iWG8IxhoiFX58e4GsfYrSOZ20U5OUe/ yBE7T89map8+7FoBlnpXMgyWGpg3MNyTFnp2cWkA93tbN90/s57p9n/oz/br7v7jMyP+z3Ll +bO4/+fnz5aX7+3/7uD5x7H/sx0A9MPOpOcbR3fqxrbXC8bs33M4CpHDqbMvNGyJyB/AD74A lo2n5+xIczTpBNgGdAxKGi2+1B7y5g7LnvoeTI0iuQHA2+hB90oEfZSBvMHYPom34jwoYVze JcCy+Qid3HjsP0A5m1IuK1HJ6qFJtnbeWpSXpsgBTIFqR7eEPeXGsBN0u/4IiW+f7cn4M8FI eMMhdQrealW1RSn+CKRjgPncWWvfBdIhKYc3QnSMg0i7+RygQt6LQxeTEftNhIXDwnqqP0U2 /sJlD93oYPQUohN8Sg16MofPxcj2ubhIQkDC7aLxu8h2Y0kXs4vpVlqZ9lkeGWhJyTHLTsuY JmIKad7JgooQLFr4Ozvtl/FLiTm2xiK3c/7oOIz8POMnC32jblzbKnaJS+QbxLlyjaC9AUnU aV30JgU83haFQXeMrp6uFLJQBXlpJHT0QS+Rwr5gpm4tmT2GBWC5pgCIpcXHjyV6Zbx2BsLx 8uISXjY7DtAVE4aP9MkdCHbW4tKsGun+SNrGRl7cEOITDFu8uxFNhsgAYBzHLtik3X+PmUhO 882A32hnnXTRgJMx6UFBF7iWlwZTTcJZw3Wq+b0Xr/vnq5/Z8t/X3f3AZ5b8t1qtJeJ/V1fu 5b+7eP5x5D/pgY4DVUo+Bty4dbDZPKofosO74s8FcSm+/VZc4T8t/OdnJ2sdWPL7zaN9nTtR 3nDOeq97BEsDSG3QlMtCrHwdF0bNFGGZ4Vy2GxzDMsnzYdhhl8vmTEIs4HJGYg/LFAvlGRGc UuSiuYUix5m0XNnmlmq+zvr89qyyWf2hxLk2uldkyaX0angK+ejLupsr4N8oTedFQDpE+POS S8Pr06fCuTVNDVW9fwBQC9BC+KNEJKzn+Ap6oeNfGhv3wLqkSSKWzguyFvYoav8oO34suEd0 FOxyMPENCI09bVx+pnPuzgha2eIPKTnxVNTOSL9NPmlbLuG95OyqfxQgHYURJFX1u8D0JdlT PNXgjaE8PynRBjdE3vlaEHnXJl7BGqpTMAUMj/zKr8vmOnNvBJuwK+Xghl2OYVP4ZjHsCNlu FP3BwQA2/t8MvCYIgjQ5A7Xvwh4igDqbnX9LurJHr2hWtERdlQ5javf6DHtFBFSUlLfsEqWQ GbN8x4ZYNbs3uGMm8Ph8STbDbCdiFnw2OtDdRTnMLHNP06b0i99pF2SxEmxd/Lq5u01Q2OpX 6RjLcRVsYQjjRGFXkcQDFnErCJOfu7kRttC25fmEKzPJO/RPe+GwP/LC8zu7N50u/8Em8TfX /y1Xn9eeJ/V/q/fxv+/imSMgGiqDYCAs+S9qlfQUuQVPTUOHKiyxqHu6U11hTtE+JTRVmI/N /0klxbdoOqGQXoSkE6FecEZxPJ7g6/Fle82EzDqobzU2d9i26P2bxv5h/T9EJTX5Y32vCdO3 LqqpyVwUnlp68nZ976h1cCSWdfLeYUvmoJO2JvEYoweQTaDwKCB85iuX3S6MqglwvkTJpwKy 2E4fP7zdbJE4jzHAROVys+Ik7dT3KEFAUq1iim29e7/3Zwkzv/s6X0N30ZZ5OBGYvGvaF+Lk /QuKCw8s1fLeJrsm7kOzfToZnM3nRNOJHqM9QAWDvHz1dEThYycmjAfyzbH4E/xdE8ekc9Ex G/w+np31gn4yjoIERWlsNegq/9D8WB26cdvQSA2bSX835HKjj/wYLH/DDHh+/YsoD0Z0qByQ 5VuVb6+R6KMlOZxofPD8afkzFoJ1z3hrtPCzbW9u7t2kigqzOtRJtuuLSxIdJBc2mdVkp96g AwKsbCy2p3w8QQ100ULXuQ/87seD+uGHRnP/UFErHOZhHu3Wd1uyKyQJi+KxhFvgaD2LpOl3 4gbTqLFUye3JiJTf4cAvC30ogFusSHxLmaU5oXTgq75JRzTsoE16KaPrZ1yBLsOCJUh46Oc2 OPd7V1J3Ln5Siz85bNMHqRw1aBAOSj/7I3k4DhIR8CnIRv5uUe9uXY/mm0jQ8Fx6xBs5HKW/ TeQEUUrn2c7pDzDumnQ6l4uFqELVO5lspoLYf3+0Jt4PkSAX5OX3wtdRuDrlXNr1acsfW3Qa dFHaTwkyiDkNFtwHeO3qk8VsPq9rPN5LLqLq5hKRAwS9CDpXMFwDDqRwJOcNCoz4nxzR0guM Q1HrwpFs0TjsgOQZFNFhHYywCMNgQ/uKQtkSs0zoIgQinNy+4JXmLtEPnSWPZfijk2AwwLMo YJyeOCXDL4qyFZ0FQ7oBLIJxWSvYrSZuuNxc7RtNjqcbNlOX5h+ovE4Aevdht/W6vrP/Q2vl bWt3t7HPYF0mnwI+WQ4qe3v0zi7oNN7M12joURgq2eLRZEC9GtDUwwvOx343ZGtkysMkkASV HiPVhSi729ZTSPXSpVSSHT5+HFsZX26oquytgqndyS0NMNJo+3Ie0mayZ0BrjuIzkZ0Dhm1D gqNcaJAgVujmWM6rm+/23+9stzaPjuq7B0d5CsfHs70gfkK2ZWb/qw1hJVMqtoyqgTQVhzQB AjNZpHyUnnMDt3OWcu5ov7VX/3jUer3/fm978/DHPA4KEJPkX6s1CJE+FvQI/QEnHk7Qzt8m EU/QBcRzgQNhUdJ47PeHY2ZFwFzYcnhyHOEYHIwVJBM0iHIKHa+QHSuQCkKP1Bgx0yKy2j07 g6nGzqh0h6J0xBwsQaPUCLEFo3aZiqQJSTsdSZ1P7ZxjaF4PUStMbsHWD6l6K7qWnNqeyw22 2xD1NV4Vl9KXREAek4MP4UteyquAhTFMKVWiaAvNCkHSNFqKRglhXTx9GigGa62EwecYowsw Soxea6wT2pS4mHnlKya2Vhn49jUyfXCresMcbRqliF57pWSPzSFwKS4YtIbkS7wSiZCpSvvw 5BltKVxR55syytcyZAszwlKdSKZkdCFVUsLexiFNdd+3GaEKEsnyqIPX6JpFtIdUnnx0T8T9 G+qT4b19EIHNwLXIR7KL+KSGd+rkh21NTdiIibTsJv70n0C+d7PPeCriM676ypDAFgaEkCnO COXGWTJVKS1PzBIRNrt/5g36mnjUm+BV6tpu7EP1rfPhWm43WQysfC7Kt6p+q33mKWFE4g17 8Uv1Z6QCmMogI2oL2B7OF65yfDLGPZYsyd5xVfw96et91LaFfrpMbsRu6+IrLi6AMEF0V3ZZ VCrXVaZHMRlNysB8W92+bW8ke0cSVs5jSAYpCVvrj5Od4bykrAVVgD46nCthryrZFvGVogwx Mp8JcooPbkqWVy1Y7nwqEZXabcKOoTDCMELxm2ztqI3D2nzQR1NyeXn6FBHUg3j+8YE7wa8Y IPeD4SsGA94QjA+GyqyhcJ2ed4Lw4UlWlL+Q58Qm/B59LwpIyE2Nv4KK9tTwKFMDq2SXsvQM kKFlcBEJrVfqGbCjTnPNthQT/pPdcvQDrUQRK8+anWe55uRhB6nu/DE6Qr99Fk36eX1yfTzp 6glBBnCEoEoeh7rTZB469Y1LYnQl14hhWAomPoAGIczi/CVISMOO4skMgnHLudWdNrutgMh+ HzdYqSoUk6sXXrRkTqmkiW3oDjd3W/W97cQ0585zdezSMkAbG4rHrHJFgI29N/ut/TdvmvWj z5YH+RlTUpcEQXzG1Jw6MeW01Le89UW8lFZIeV/dxJXXgQBBD+NVFcUCOnFHpEDmeqGjepRe 9fzByfjUvuWXBlxdLN3s9aTNKoiO0Wk46aFOgm0K/TFMrJ/9zp84K4P32sMAugmB4K67air2 hkG71UeFH3WflQJiEAdp0CmSULLLcW8fGwGupaJKHJ7wXl9mXLeynAYnp1YefVXK3n2lA4vV PB2oVTPfwqJ8GMt+dO53ZF6lnbMPMSrKwBXzUyzkkCYViGhEEmGupx/hkCET7B4HyaA75xgd 4U8GhOIQeLatmIVlssBDzB4Rmb4q7dmNeulE5GwTrZtcyy4OYGjY0bTtSNqJmFK2xIszkP1w PqKAHZXLR70eedkUDPM8Fq4jFsi7iHWdzwxIEgsvlMLDyIp9fGW5lnHba5grtXBx2AlGFj8h rpDUvAbrdtPn5C2uSG+PmLQDtMK1uE/cfNfscfE4xvjQ5Q1MwpQ5vnoY0WdJMReiTIGXFFkd fuE9PZR9+VLUagWNpcLaQhuLqF/vm/XDzC2OyrS5tVVvNuvb+sN24/DoR/2LtoBEfcvuODas gXnSEGgNxwvM3A82cYFRVJ61z5rZS3JtJ++ewBnG4t93D8TLkd9brr2y7zigflxdq69cVjhQ jtc+tYM6lv9/9t79L44jyRe9v6o/94+oYdYySA3qelcJy7MIWhI7vJZGDx+PzWmgEb0Gmtvd SOKMPX/7jVdWZVZHdRfya73H7KwFVZGRWRmRkZHfjIzUh+ntjRzNJKKaaVj3bcq5uNxxo/ok koz+KK43IpP0tpgcbsYjPDN3WkYHcdnhhG5O/MqLvf7lZLTGhc1tlfgK96ExhSPmKPg4+BIm HphoEPrHNE+c9Bj+O+FrgNaMMhNzW53LmJ4Fk3bn5zrR7DWQfe58GuRc5tFyaRZWxLHwkYRb uurFTddJLERzxnHGL1Uy/c4Y12pCqDrFNLv3bF5nkkLzZNmacxi0PiuBserWcecZo1IeWm62 AFp4HreaqWeeiatcuGGL2UnAU2qNnc6haHNdqmxaQihdtihxtnOognpw5i6+4pQ9yajBlXzq dGu4POVE4jdtSXN9yZBSMalBr98DXjI/uDHvTIL4nxWv+PTZg7wYoclelnKo3rPSec/YbFJh dMEdo108bdPsI8m56kp33xxtvtIY8Iu2aXnT4TscWRpsuUsVR4mMbJ9v5LyZGcaNRoU9tm9W Pifa4TcaUgtGVP2kzN3Vr36qulCekcBE8+Bm+lgRGqgGRS+JYtnugHn8uaElMxFSi1eI85pp QrRmW2q/+SUaa/gtbq/raxOWewZrzMFkJrrImqvaFjznCKrB3LBoZrgW6GOBJ7yxvQMu5NG+ t7tx4B11exx6Veas1Czpv4P1fPLF7dPSaEJr8BM0qCWzcBab1Red4NOSfM63mI/nsTf8rpJX mJtRWh3pLVJzvDb36sQEgMFaU1w5OZ9gU+L+8RWm69h9vuyvzEQriOiWHeJVz8e4dGT7xGFj R5Fxyq0zWDeXG8Azl4Rwp5dRMhThdELnHcrPUNIUF+7V1cnEhOHj3yt2QUXHl70gTuimcloe y+WmT+QrSD647C6v/FZ4PLYaWv44PA6CXdTR+xfGG8Go0zCoipYf5oy2wsuZgdBQzva3nZGS rkMU+TgX+OG64B73SNRGOdGQcga051ytYrz9AWXc5is/8HA5RWTRjeV8ycGa47QaO0/bwNWw zu8qCGG5WdVZ1z0dk3FGurnsKy1pmN6hn+WuIWI+U+dn+2tWjm/egHZbX0TNGcPoDiFwO01P LTbes5WbfNWgme/x5gE++l9Nu+Yi6qYhD90jU3NrZuSRt9mdaOW2CRkb8LUT+Ov2vtmKf9+/ WZvXaRVmRbNBH23bXFU1y1Q7Kkkohu2MDO0Vwc3o5vYShxmmawSTYPqhyr3tMJ09uF6P0hQR iNaoAlbwnr9vLnpT1lFtkF7lmufs64s0eGO/qE77uhn9tnb4a3S8h0PQzjdLGJyrZJWNBtO7 P0e7uVqD/tmJpytV1+GDn1+pBeho1siCcj5nONmszHrKXpx+lt85afrNJV7rrrgONrpLbZnQ Sl8Vnh539zaeg/8FL/3PZ/9hOB6eDfvXriv8Zvtwe2t7g1eDXufz2b866B6Z5pfs8WnZ/J/B fjq8GoyFf8n+aHu3e3i8u7/VOJwdyh4c7R5fj47PBpf9O/Sdj/He3QHM1MPTHyY/o39vpscU /Oeslt8cHPEBBW56A/k56wGOR15ZV55/8jt179z9t8o+nrJav8e1k4vPf/3q5//9IPFnz/8n f97/+Fv8WIEClkuD55TVHbB50QK4UvGT+eeyCxp1f16OZFu7KcVpbDyIjc1qeha7ALgXHcS2 Dl9TmQKuokPJnnWg+sbkXp45dK2fui6IyqPuytnpxSe9i0/hyr4SypXS35BcM0xox+7I0Von Yq3YS+RrK53D3SZQRmpotE0wUwdGPTmVWCd43eO7CytQdhJ+7wHzP+xngf3HWyB+9gng+fY/ 6MRhNf9f0PH9P8///hY/f5z8L03y/014S9Yk+CP1XcVbTCaS0A85nAwu+pfnZnXNA8CTAQCG aO39WttsQfUxMriazI9z8blR8mDZ+uMf7CUVWNbp6dqKHBrc4FX91Qi7q80J5eUjbieDCR8U pGs4r2DhtzoivMx8hrTb/pplzGtGDz4MJ6Px2sVKmdrPvil5Oh5ev1+7+NrG43DW5S0K5U7l 4t4X91i2eQ29dTqld3XnsCu1IGzBTsOk5nD46AZLSQl4QDBEtYSc/S6CdE5vbmmPX9v1Z5+h 2JbDIo+G1ze309q348F7E2CLtSPqxh/KfOEXnqhkY+chP7NC2AhlhEcmg7x0k+iWHAV2XhEi eN4/HRybhEDPvHfdveOt/d3Nox3w74+6hy82NrvHb2Bobu/vOYVPr85c8qJLHLLbNXq2Rh/P G/nm1zl0fknn63SD/icgwU6r4zQ4KSjqeJwWFEENxVlBEX637uTdsI4WcyEjEtkrM1pSiZ9i adqhW/jODt/qX7IOoAYUhdGjvaKeNfKHP+34RfiTBQ+/2Ke/zSNyTznTUb94yGfNnmGd1qag 9WU8NpZhtbd/cFwsT9se1r7iHmpnu3QsoTR0yLnmi8vQWUfJ5Q4T5xv5kfOd/EgiM+UvUsbq z4xyak1ct5jMDgevwYAwpWWcVZpgJCBEt2t25WvWNQ41p9aNapnPlqW16fX/xr39x+9lyi5L R4pwDi5yyxY4ME6mMHG6kzinT9Nx6XIh65h+YG1O8lmH5W+m45WWEZvkKeAYV9rboFP5xV/1 yRIsojU+FlZeGG6ypZcUmBdCzhrS7bWmZVU64TQao7tCu0F/hQXUMQY5zcrv+BhP33Y+UZrt oJNXeOF2nUlmj4wk1apNYsR5MpwWVJSvyCVjs2drxfCsaTaIqsTAxlmsJSeEvWOCW2vUN2Ui BfdYZI1noIt+9pXdxa1KIgUQHboKfxT1sP/8v0NTSCfQGz/uT2oinLGHjy8HHwZojelf58iG Cb+/urqF7oPq0VWARbIccmSJ0nHWZSpcgFV4/nTHf2oTi6+2u/sazx0fbO8d7/jHR4ifO8dX uWiwqGhQWzRcVDSsLRotKhopRSsnZJ18dITZ2Cz74/e+xL7JVRaKrE1nLz+0irbxuiS8l62N cisnh017fcbWv+3hRRVe/9rr305HmJEdlzF3Xn8iI1vmL3AtSUUkSODMpMlUDUYxk0+GoNzn 7kMaD/TIlHx0RveqzZ/z7RD5ZvP/vOnfmb/5m/iT5k/8P2fat9Yz5bRvV70m3YUzP/82h9ZY FbmmsNiRmesjlKAhpYagjsejIE6bLUWT+0hId14OeDFu37vHF6+gZ9H33g8/DK4Ll8LKc4/a 9r6P2YA4vU8br57rILIgaYCIGqNAwCjB4MDI75s+7kWZu+JgINwSYLIEFJLu9T2Ht+CNcNSK qr9C99c+QpYN1eoX1ypoIfcGdtVvolb30gAlFT2s6CeWOtyuOZ+wZl/AR31uaUqn0JOe6MlV /9Oa5YNuHryegO9JJ+1O7mbcT17tfJITXzPOZxHd1f/0S6wMGsuwaNJvbBaKevE3IoJ/9Rmg diXgCKJ/RbtLIAhBl5ahFX9/vtJAJFBAFQjv5PwOAgGWv4M4MMGj/PvDyc8SCOKvmDuN7eYb GBmFBZwM4OVZafDAFC5R0OiSdzI47ePa7SMv4ejiTZi4iwtNkAXeyjDB/K836EJi4iw2oHRb A8ieHGkGeyXVFgG4CHYWIqdThtLE2nGIROYmkNPpp+mvrQOzq3VsgbTyN1irVxXCqp1+RzL8 d71u1aIXxa5rcwd+hi6VEW50m9pkwnfVUDDziM6UDvA2Em1i9Oj2OvcMBsUBFo9wefjxNxZr 2Wr+mN9BsNUmrPHNzcXVmuKIzylwTdfNF1dny93TcwpQT8tNeBKq+fEe2lAqAx2FUVSBzmyp ulBIG0msP/87qELR6t9RFyptEGWgfqZC5tTRvDKYzQcezVOIahFHI36GShz+p6IO4/9vgS4A xe8tfGnj7yd5pwFrN/C3VQD+mkv+Mwe0BOSbHUW6z2rGAbtyMZffyPtyG/UbO2Fu5WvvFyAj et8aL0c9iaIvOU4mc3c46U1li7PTLu+5lv1Nhn/Kjcg5vSxtG938clufc7vY2kMsql4b3cy0 q/dqY2v/7fH+wTFmnt7Y2dnf3Diq1mTz4CMtz7AL77MT+XsHdzT4OZsb/4NLhV/9/k8/iZT8 /1HyZ/zPb/Dzh47/uRmPPgzPBnb8D4Wd9K+HtE/AWRUGdhAPspDN6C8nJkW9VyRq4CCdCU09 N5eDT7hnP9VDhcxtonRBjRuA9BRfedBP03H/eoIbFrDonX4cDK6LWCLZLMFF7s1kcHs2WsUt DYSsBYtkwGniLWPW5zYz9CjHuDS/SrdL2aG5Xqs5ci3LWX/a5wAjwiEl6cbkBsxwTSQUmOmR qba2TCU0ak1tgHUnAJaxgqQMGyXKSmdViJZZledjmOt8dk5s1MxtEkWslHrfqXppo5OMDW2l fnFi/XWMjRn8auN/sf3/teP/fS3+0/fjP+P/f4ufP479t+//a0kuvprbtjjG76w4+Munohcc KarcUUfR8fNLzKQjrLCg2+zYcaxejLdWXHe3PlMOURXOTYk5pJzjrZhQijMUbB/1VmaLWvfk 4e4IvfS+4pbMHnvk11/cmCz83ODlL2744C53gRRet71e53bblpU2kzmucpmiGfL662flp9U0 ZpXPRGIT5K4POQdrsP4vbtrSvPmiMY03BxrKiud+SNn1q8+qnUmhTAu+AYSKEYu4pqEvQQek P8UuPhsNOA3U+RAV13zQkvsZS8vkTWCWGrzEw6uIoqia177zv2VmP4uT66GjMxnAKo8vRup7 J0NycGi7Ha9Qx00UM+e2DViP5RGlH92+v+CZl+7dm5rkVqeXg/7Y+2jh8ZQhi/B4KPridgyF xvDJAwl+noyMX8VH1k3mRXPD30dJ0g9D+QNmEANfBBPuX2MI2NoaIkBWSk7LDGBHzbcC2kB3 0p0uuMRPZOEbjMPaUcYMQ7QnUX6PuRfppH/6w+1NsbtccQOdbeZVv40K95HussLOJZ0YXFPf UwQcno0+BRM5OuMgCDnCNLqdYG6GG9kFoQ4ieEU+FXea6aPgoXySHRSzYERp1u2+Zcq+ll7D jAa0e1TeplhN6rXsGJUV7+uvSxNoASb4cVjM+ba2JERiKPE5y4AufMB7A5d448lIzt79r8gH dIJ2pUovGZ2zMQeTSzI7WEXsjcgvBQUYnjs+s4wSOk46OENWmPzOc66KkBthhrgVeUd2Dw9r 87YXCOnsktzbL7HhXzr6YkcgePQNbpiCM1gwvwx+nCJ/VcCyNYa1zhk59dK09Y9xLl0L20V9 cheoXKg5OaZvIGIECWczsJX5AoBzIUgwuUUGCmM9oSnk0DOjJsZTy8bTls64WpCmjXVu0118 jW7HlYUULrNIxrTLBmtS57WEKjm3d7YwVkk3bnwDzzWeGuEsHOp1wMpVrfQDZbesq05xY71Q 8CJ+ClqI0lvj9q20rDMV9gWyhmEPvhi+EnnNfDsXtrwox3RgYXw2wnyIxAQXp5ILvXKnsVts o1gMmmHMXQ0djRvOdKEF9CiYyZbkfBHfcvNVd/Pv3a3j56+3d7aMBja50pVmY0wbVsbBgR5J +GPLSR3jJo7Rfcb5/iKPt7cDXtiTbFG/RteytMakmh6er8fxJyne2XmpyfA+c4EWJaIjvfii entQJW895nj33Kzw5hIhqgY6kK8AEi9ZksIX8eB28jfXLJUGgUYbtmbRcVFbB/ZvrRgRCtTC qGH2NsAafxyPcJI0kDceiyU9euxJCK59bwCjwnQVbfXegMoT7GUrobyVgrVjDMILvHO2b7zE 0rUVSz874CSskZCo4entJfhZdHaETYN7be5/P9Nghik0uTq639AJGGtQ4reQ77LALBQX3rGr Lhf5rs2ahT/w8N6Db7TDW8R1aLNPLON+POhPpn8O/J8x8HGvyx34oA4LB/7MMK+O89/1Sud7 /czH/8rw+cnPwAEXnP8OAn8m/0eQhOmf+N9v8PMHxf/QQu4fdZ/yJgROJLz1Y+8tyIy6VJ71 WCJT6ntra160JunJp4M+IUywyKbtIkxBDoYBg30pBdnH/t0Er/6bjvunU89vExLCkYt41GA8 hsUazdCxN7gcXPHdX7hNA0RgMBFX4+RXnTU5ujC6urmV/YvpaAp9VMYWW82v5j137W85MBEW XHZOLxWPv42/k8wsFduNlcoFEdZBGDcly45POVmeeaj4UtXlh0v3+hTg8/hZJQXySlm/c6sK kRsv6PXNmdnDUb+e5z6UFuJgGL0zLdbmfGCH1uMODsJp86awWivPCJYsudjE5Ne7GQ8+DBEw oce162kW5aqPj2QxPZuI95Y+pok43INHHy4r4qFjaQO6WIR75Xh0fnx7PZxOlksuUAzTlAKv A0zFdXS4ba4e5FtJB3SfiEP/3Yo1PXmVd1gZFLIktYxVfFUR/IpnsJ6/zX5w8Vsbiz72fOsG IDwTJAjkBsIbgzFjE6c0DorbM8/wupUr3CS7MO6drQ8fCYKkr5tBvwZjzAJhRYa7d5NjwWXe aaOskoyQaTpC+7/gE1x+GExWSCeWRohbLnEKw/Mh1O60rrhuuS3o6FSWmhVb5OiXM/BnNF8O lTCAhDcx9wk7QgYCARaL2Yruy5EpcLwIYC0gSLDSd94YxtJfVubaFBaILdaK98q7rdjWRbBf NSKXevEeharj5r71PUIhD86K851zf3gQugPTHSYHr77pfcdpqtDFvL1GVNcYS9R4Npc0bDSD ScNnZtT5xtffvy73hNv21dtG4juBbcgQ6RrJ3eXMwEoW6iAe5haJIR6ELDaAyobsBNiOCAMV 6BnveCzvhG1L1vYl8yuFuyvLC98wdftful/ON1TfYlIoGIHaK2OJTOav2VlvEu1Smx95fico /pm55djV3OKypLJhuHohtcR8z+5sWvwm6w66+0h+ntk983jmQ0EYu/SoyH3Cw5AkhJBvtPvc rOWsS4KlKN81ckG3iQDh3/72N887GIwv+jdsNTBy7poMJloF3FUYmFuHV7FBfyNG0r3SXPjr +PZmeXB91jb9t1K0tXs9uR0LZM3mRm4tv6SVZewHf2fzxBzL3LTFesy8+gqJFWmsFIUfPzP1 l5eFH5H55fdDCVa55pw3DIqC5WNPbunT4HrtYmmtKhDiaqmTK2C+2rqUGNPQLFLIszrTlhxm Z9i6OXbH/6680tYxPrzEdXSkmGcXqN1P1dHq23M1N2XOTLwTrDhH4+QWEtqzqvqhBpY1UyLf uGXZHJG85YBVHSF3wGFRbgp1PuFSymTSWmT1qw5Ty5jropDsXYs7W54DAP+u8GfxD6AQ32Sd XuqWGt+w7yJ8H9tixrffOanJ5cpmIX5kWyH11oyTy/71DzWn0tV5St2VaURpOlijnDkvo9Jp dxPUYDX0Me2iPzBUoTptzMvyJ0gMc+m0rYKeWIoecaaF1gAdGgZ0bq95cK3VXFhSQqTsXLXk mHeBjHqCjXqmni05JI7HRKv6Bz+oQhb1Dr5xHTgFRr2ZlvcnF59ihlxl3UMDbSjLktasrIAX dq5pwCvNVz4boROBu8YtN3kF/vD1kgWDbY7N84roQ2mXUjVjfkrVlaJ8WS0lyGiAsN5YWS+O q3ozG2Kxzdxs20Q8xTQJFnzsprXW8hP8opit5wlqq65lizzmazNrcfjm4SdjvNAV5FAZujJA BFMwmi1NRR3XDfSzjNgRASxLx/JJ+R9/BJF8gjEq8GzZ6+Vcp3X75JYgnQFnTlG+Ei0tLr+H 8/u98v1jurl12dlH/dHsov7oXnn3Y3lNXmFRcED+Bd3vFeb14zP7Wrz1lmPANOtbmDBHEYef Hj9enNqZJpd105OwOlhd5buP/2kcnCJnDYakUvWitMCXkY21Yi4HqXz9zBZD4VF8dusN6zq7 S+8L/SvuoZft/CvZzgeTwa3UN/Nroy6KD1M28YsddmdTft20gD7w2+Gn79YuhnzKC11ZFDCF f2xtHRbxHzaxc5LGfnE5crjw68ePh5/Mb3In10+yJNukeCYM2AEDNx5w5oD3qpFeKxWBR/NX MqbIn8AnRpD3F+PnJMhVvI7xABYBeJ3q8c20OgfKbcHOD8n/ejAG88MHrYt7UxQXwy13ZKKy 0TyA4bNNhMLh0j+2Z8cZDjv+DIP6+XDenFhOiNVLXn6NDbyZGCb+oNoYphmzXrXrO35bij7m 6+NmWgY9CSXQy7W69DFZlSeOUXnkLpWxsurPF7YZKuaRujg7nse5fmXq8DwzZ0sTxU2YN0k0 9Tel0qaGWpRFTDX/VWyMzrXA0vTHz6o4w2d0zX27Z6aL2FLbU8O9eur+k4JtSx8/tqzpw2fe v8xkrRsjHGZ4wenA3ku0ghWqYQq1VkYukipi6BTQ7wa4o0gxGZs10BfKhyqYq7kT22Wfp7if 4zrWgayUioE4VNCtGYNBOFaBN4ixcUCYKghSu+aetUYVNKMzU9x0u/esUNdZKLmsvm03t11W 3vYe2lWt6DbOBClUAIZlmTUtbjv+yrpj6GcxXtEO5vnVHDGpufYJ/iq+veayrNnbjAyoa81O f5lVqcodQpT+3xbE15WLr3TttZz2N7sGkkRjaFYXshlSDUP3JA798tZchMTh6ObvJhH49k/1 kq6KoGs/vOXeKHRgTejMgqPr1yjMk4fxeqXMLn8htR0ciuITyiCRtXt+DP/Yn1C9hWymEdvm BBy1xF69Tp5S240elXcpNtxWMEIvqvK8nS9un3pf3JqtJ+JP68LKnmBxxTWFpDm7VcWtDuVa elmi53f8+q5qFyPUrmzHn7N/Qwf5m+3WzE/6Vf2Us+F4cDod4XJ0rdKnwaKtGh5KNSBOE9uD XLR9iBuefZBH6aJVNoYeVV2MSnC18OAV2YyjaWqodTUV0XpGtgyw1v/Y6xO31YuKYaw0/TjF VudphpH43ERvlrfoLHLsmd3WSmuctYo4O1gbTAegN+8QQKKYOwm8+6/bCXovGNVfXDVgD12j c2PaqcLrgZfozZLMcR+HnObqtH/9JaUQ9YbTv9D0ORNYXl5nSRxWGA+iDaFNumuerTa7I1e8 IG8UW2/dkykeobGTtqM9ky3VKuYOEgp8XzgUHV+M1J3/tKIMzFVVf5xYuf+JP83j/4ot6ntH AC7I/xCkcTAb/wfP/oz/+/V//jjxf3/mf/D+zP/wu+V/qEvhQHrtLX0cXp+NPi7NnDkC1dqm Q7LmHKjVF1qwJ/hXfBeqgVUZdikhqe883CM5wns++c52vo2yu7VuWHDgjLXUdedvRBV2wgo1 rpHlh2OFSh+M45Rq4sYcjNJdXVdRHEHBOW86ueIzadPFMYCP3X63vOMf915tvzhqGxC8SJHu kgUqWVglCy0yonMTmJfL5n+wCzeRr/KWC1mv/GMJgY/bG8xyh+gIbf5+cWYWWAZcm4m3cNN8 qDH1Sy0n3wca2V/yp/5K0PvN/0n0OWlAFsz/YcePZuZ/P/H/nP9/g58/5/8/5/8/5//Pmf+T qPUHnf2j+8z+nf9ps39JFlXJop/lJCTR/0gP4c+f/8k/C/w/3OX9le//7cTK+U/MCven//cb /Pxx/D9lVi4fobIav2zBxbWz784v+5MfKq9mnQFzBa0dWjygdFmc7t/NpSNJGE6O8eQYh716 j+gfJ6p63cD44sowjE90q1/LgXrca6S5tIi3esZlRsf0YrkoumITm0MSdcTeY1PPxejjMQVM rVJWKzpfsYab2o/xQrjz8/PXOzvOrj8lAvfKhnI38C1u5V7kFxPM5S+JLjqfvri8/LS6yv/W 7rgS5795S13iuOQ99Za2hhPZU5E9nIHc/8N7F5ULItplR7ar39eWHPCz4ULVvfNy137ORxQJ huZ+yaD8kjPlS9r4GXKsava2Kk3V0Lf4bF0rRCiqNKtr9tUJrD6VXnSIRMmeOZH/q57/2erC NwxAB3M3/7Ka4t4fUZDRlu3nqka1wb+BVkjq99sbK1f/pEYl6GsxyhN1w1GH9rD9X+vyJ14L wK4+f/5fSmr72/EpHT3DG/mUmBU3h1bBaPVrvFfgZDjFHdKHD73qs+NqkpKyRqtg43r50ojb m+q1EY62fbv1/LuSbAJyMKEXdPq9Q4ff9ZbyEXhpKhb4Ly7wX1Agw5f/VUb6mXQ0VzDDIJSK CTz/yw7Cq9bw7fA77yGR2+GCosD2jRdtvt7Ct4IENcX1KiuXUn1ZBamTvjgrk6URV6N95mc2 QBD62sM7QO0BfOZx+aKo/GNiFeHV48dlTOFPjkBYrI74tFuBWk63oe3Hz0W9mM0MZ2RMOJDN sFShIt2BK3CaU07xOLkjbCOI6rTf9h5aBUGEDeMsf5pV2dnLbypfTK/v88lkoBZ/MdnGBp9s ph/rm/HRZ3y0GwfwezvC/5f+LFj/XdxNYNK/+XlLwAXrvwiWfjPrvzj9M//Pb/Hzx1n/fT50 +yuAZcDxwOD1MJfuCiS/C37K8sHuwQoQULI/SscaJquYZLkA+AkbpnSv3mV//B4P2EAZ7wIc nOD75TBBBzpYAaMbeN97QcSpP+hgHQLK12XCNw4to5TSwfd+p6CijCfWNYv9yeT2auBFfzfR vLiNEEn6vJsBn9u744wnvZHJaYKxtbQXAryjIvEwJjJelSy60Oo16V0viegjf4nefWKFruOy AeoP8CGC4N/wU3wY4jN/97lxSPBZ0PFM6nT64wkVpr8ybzmIEz6azl3UPTiwywIdkof0R+4t xygE6VLqJSy5JpLdIJFRtOA53nc+vOZu4thiFqWP6SmQFTUmdMRDG06no/F4MLkZXZ9R1xJR EZxcqItsUhWlhhOmfEIfRS2PPeiGZ14YvHyuFG3bReUi1eEVLNTe7HIuO5NoUJDrtV9hwJjt E+i1Y1ClHp8a2Xu9C40uXqKbCjJZLqX/xFzyVQS6rqwU+xFW8OvVDd9V+O0s/0fC1uyd/K/u 4b6+d2KcdeTGWzrH/fGg7wFX06DFGzDWPfJlVLO3t39MBek8OyVfkOQ8V/0zui4aXDY6PW7u Ty12vZ7QVahASotoTM+BZvdy1D9jN/7jaMzBocX9qUB0elHeRX3VPx2PCgbS06gFFp/iSi5w 3Nber4GB8F7BEgSDYk8vwXqAaSiEhMsg7KHJgBooGzyed7C/881y5WWbD/qYonQEosxWWiwv qGjxslKIkh8Dz0oZLmReVsoYfVDLmJdKGZa6W6oowy+llOld2Z/xhrhdjHNhn/cqUVCSgO4c M+UsiTtF3pS1qYNzHEmGEv8MYdXev54Ozf6mzt0kR3FuzEWhD6fQ7bcYcbs8XBus0RQz4Zwu lAmP2Z8OJktmp7R/MsJUXCTjJpfcFA7hz7rpZiGXP5cDv9VPQ///Z10CtMD/TyO/ev9bAD/R n/7/b/Dzx/H/3ft/jJ2xfDjrR/MgrNMSK6XV3914d4w+gwRYmPLiiTya9VdK98M+fvFoZvZ4 5tk1PlqpehXrNIXsovkVV9rjt95kJHdITMtTJ+y18Uk2k6SJM54cvNizUjFN9enZBYedQ0Pl taulK1VcN/SMjhWRp7yuHENEhOdfHYR03VLPbN/HTUBFhyZt4q+fVWWgH7Z0shDN3slQ7f92 4QN8a1f33YKDfnPuc6gceKki1ecFsIpgtTSQl2lf3MohP7VFLphtn2uye/qZ08Uzx2jsVCPW Mc8DXLTZNxEt0R9LCA1OR7QuOLmd0t0kRYLMtrd0Pfg0XVqzd58qnludPskORvkAOc1oGKfa KB8w85Pb82/RTS8P7PORNt6ZIkX8ivitew2SmROS2eactmqic867g1y/KNTbPk6vjqFqZpO6 409u7hdMQF5IBUPw3g2uSyyWm4qAbKGa62UTH8vrr8jS4Ugr+sEif/xYvpcSmRQvVqyuJYLv +JOdj70ZcUAdTfbw5cuygUT8ivKNPrqKLWtwcnWgfmt96vC7itm0P4CTCUvf0sG4bfKvR3x1 Di6nMWchZTE8peUVDsm2uYqHGwsqANa85FO9lisMEMWYmIjQj8QHE6sOMS9iEXr5cXgxLZng tVZ8eU9EIIi2fPeW/eRoRQBwd1+vM7PX6y55Fgw2JTF0cR68Muj0gVVYYhSbns+TBTlnKK27 4/GXHUuVYdJWB3CzwWN9a+3waWNuECG0htI8xS0HV2HioV2SdOG7dVXetoWgsNiKwvB1VPXX TW1bhpmy9Fgr3pak1iiS2tg/eJ6YsvoI76GWTKPoqZmMOpyFx3UYZhL4wMRjlphWLklZEMNc 3zIZ4iq1ynqDTo5SZUp2HLNpzfrFm9buVPmvjtlJ5LOz/fH7W8rMbjkg3OSvn1kjppqCoOWa cUbmjPfFHzHbYCWjaJn3ANSw8CSUol/PcYXKNlWtrNJpbHILZRwa1TRRGsMyKkI3/7M8S/el yTn8PQQ0DGvTX22TA4PScLOW9yk103tMj2Eu5uB2KR4H5QooPkOJ1Xg/wkTio2tOwsR8Zm2p xUP70IZ81fbZfax2oZ0gor4O/OfpbODHk0ePnKyt1UvrcCmAUe7VO/9mErTNXQq4nvYC0z3X JX7huMS4whFOjFey9fnirE3W4osb8pErE0PZA5I+blUJjJmxzMWk8B3fxsLQEk4S8mtlmP1f fAp9Pv4zHrz/+eG/C/d/Ez+p4D9+mgZ/7v/+Fj9/JPynPv7XxOaqh3TKcDkM45xMB2M9ARln QmzVJCA7Ll5eVVK69E9aM1mpT29uKbUX/CvOGUI5sGg75lYd0z3Bk3W5dBgP0DzEB+1OW+Aq /GtlRZJNwyg8B06n00/TtU/fdr5D04ixuZ1wXXnvF+/TFyWD0+n4En6R0kKQsbb6r3dmCcOS ED+yrOmy/35iO5TPvDcvN19ABx3/AAoxuDx+R9/o/cjPR3RsSB6W1dxOwEei38aTIbMpO3pd oRreMJWepou2sLVi3FyJvcu1+k8n8hkvdjaOjv/ePdzr7hxv9ooWzxSYaAV6cwoMtAJbcwqc 3bfA+X0LvF9QwDiaoMHsauIvJkcaqrVkOIVfK3AMChLz0CCRaL2dTgYetz1SdjW7qcEJKjFt pS+B5602D15/+8Xtd56wL6MXibkdvahHn1Wva3P2nupO+v/3syNh8N/NjlRiukl0hzBz0ueh w/rUOHo3nI6SlwuvYLbxCDl5P+IbcXGv2g/42fISfDD4Z9gf43DJG1yfjhCpXJljsZaLS5hW KEnfClij6jPMjRUGK07vNLJtYaDYtjDQbMugkW0bfJ5tG/w824YtvpdtUwvMs21qgXm2TS0w z7apBebZNhHT72Lbqhj/TC6s397/m+//Ty7648EZae3PWAYs8P87sT+T/wn+/NP//y1+/oD+ /zxn340zsdX3ZwWsNGH0e0vy836aj/9f6/7XTpAk4Wz+N3j25/j/9X/+SOPfiv8ofXFLRfW9 D/K1LaoyZsN6WOzzQJ3fe2/sJB4GvyT3+8uJsPKKpCNrdlkPU7VOinuJvP75FC+S5d1Jc0e5 OaFrN+D4qu+Z+6tvbqetyu1L1jlhuwzvpNOWIXoeQwufRuBXaClRjDmz4xZfiOXPi7mweLWr 7bp/QuX7BF9o6f3tM0289HGvpfUe8em8Yi/aajG43B9A/+DjEAa+fs87JpL/HoTydsAn+PCC z/L6qTXa6oK1yIBvFh9OYZVCm1wfYZk6HdxMTHlM//1hNAR98D72x9d0/ejZLanWBxgzuB9C gdijc++Sbki9nKzVthFbgg30vLKNC+n+NYeiCDjRnOJ33b3jne7Ljc1vjhE1fwNL717FN3Zr J98Yf/0WfvluTaq6vUH9N/1bNvweZUkCnmSka1pWKjyeDC6dDitWy/N4TIdXA9p0EoWi1/hQ DMlKeR9mdSxXT90rw06UWEkGXB1dK/al8r+so1E//386PYbPPR/0MaJ47eJn1DF//vfTJJ2J //Q7f+b/+E1+rKRqIPsxGCO0ZefjAYYtnU/BWg3WvbvRLR00An0c4lmrE9yBHE7xGNGT0ZhS qo1ANe/wGUcq0B3HdEWIRAG83Hvt7WDCs3FxtdDB7cnl8BRL7wxPB9cYqD7xbvDh5AIvdryj gi+wKT1pCvgWeGUq7iGuY0EwxXhG1gvWfFOR8MJ8X9qXlR9wZsIRLkY3gyLi8iMmkD+h+93P by8p7xpGyL3dPnq1//rI29j7xnu7cXi4sXf0zXpx5/OArp7DC1qvbi7xkuiPeC/89fQOGoUc drvgcECRjefbO9tH3+ANzy+2j/a6vZ73Yv8QzxKB77W9+Xpn49A7eH14sN/rrnlebzAwXUed pPVe0XWU9w7jkM7ACxvS9EHf/w2ITu6gpUR148HpYPgBPRPOC3cv8VD8Bd3BOLW6dZ0uMxtN 23zRizmd4AgO2ZSyY1ey7cU+UPWvf7gESfSmQA88XgzPgf+Ly9Fo3PaejyZTJN/d8DwwCn5n 1Q87vue97m1wPjdwCmkJdny8s/383eYxzE4vuhtHrw+7x6+KpZ36svXkEbRiOrhcZaozBJU9 MXfg7MJf21uSwavzSUa1Dz7I2acVrNowR0zJcH0BHIqfjgc17F+fjPrjMw/f1BR6s9stC/lY yLifu+hZdBH6pIPgdQy2rPJegAy2Bie379/jPLu49EHPKh5iabplo4fuyOLSR73NsnSEpY9g esQrLq9u8JATniuqK7vbOyzLxlgWP/hytcd3rZ96hwZmb3uHW0Dd9t4eYqG6L9mwviShLzEh VRuSu3DxB+1uWkxSapTE/HEo0YZ1zKaOx+a7rOSRIY/N3YN3m69eZnTARwK46kpvHGyXfZrb SkRvakr1umUcvE9a1PsG3eju4RP85d32Ue0XHx0WcvBJfXY5NOfoDuziIWWTKSRR2/cvy27z Sy16eTk6ge7nHC31Xb5Rlo0+s8t3998UPGLucnjSoLsPNo7K2pOi5RtTM88dzWs7jJ4wMaVJ XeSwL7yo76w9a8CTfsD6+RT0E2w4WGBcNssVm3Vfu/Nip/dKGJCK9PjkJh8UwNev4X2Dr9/q lU0J/MJ2wAAe1Xf2xubBdlGINIaefBj2vTnDc3f3XVkVqcju7SU607D2bzAwX7wrzUVAWgJP Nt506Szzi3eHvSOYSa0vrmX0bne3bAepCk49/Ss0l73t3a0GbQEWQcEimctiNagfsTsvenv7 +zhuA1IdnIBgnXLuTa5Ho5u6cq9KffUC0p5Xd3gB/NEF3oCCTagVW2lXAtKajdspuP+UCPRy BCMNdzTGo8s6BtsbSWQYhDS9bW+swqObQnvrFP55aR1C0rIDWQc+hzb/YNkHnJU3drcazclm zxHLoeKO8JKVs1vwwChcU4p5vEf28WJ4ekEnIcGJRT/kWm6TJh/gL7VC+qa3ubGz45pVfIJW 9bBbb1StU0k8QuHJZv+G7vGtK7RXDhAvoP7tfhqcog2SzFZzhlb33ZEzIEEJccANFo8ra2Dx cOAntvEY3cA4Hf6f/txxhWCN//K5NSj8lyec4ICjf+V0eV35wy1wJqTbeDzIkxr6nV2rt6iL d9A9JacJ87GCZtY6auHW3v5b6TLWZOwweDr6+JcGfUbFHX2WoqLBn+VXntb7lWBvwuJbO/Pt TVgrn82d3dc7/7n1n6STZG9glXK3eomO0RWaYh4582aLo26vMAGkZ5L1ocGksft2Y7uwXGz+ R9dDKPFk92MfWCzQji3QhB1TPGJrueP9J7jJ4CpCJzdowRsYJUUvxo6jLf7GYsvfs3mw5e+f w0Td0FXv9izjTTrevb7AE9lnHni9g7PedFBr94/KOUe8yqMLWGHTOoE60qufanrgppiihb8g J8ovFWWao0aboL2FZSNd3JQgHHhRZ2N2LQ+P9OYFZcTeZa27Q/+83pn2k6JsaDnTfvK8drwc HZQuLSlLDxMVHiGAeDAejmCZegde7mRCUfd142Vrs7Aw7FIeDMbnT1jRyJQPL4nPnBWJ1Vns HYqj16DPtmyvmMS9RTfaQdWn4ONtnBKfWoF3o2NfCufzfZxozZ/LRrQumG93gE2t+r0LyjUN O5mfgnlrGfDcC4eBp7Or0YeTQSNvfv9gc8/MhLwO4ScNysJkA2vpja2d7b2uuJhL07PpkoeL 3C3wrTDUh9a3tY7ORrf0p3kyxSd9kNXlYMymtZGLSo6tsCErQ0+esJf75F2ve/T8zZN3L/Gf 2qa8sdxt0p+Nsw9sat7QxYhNfG4/KVxGnmJf9S/PV29AD4eEu4HD+GEwnjbp3cOtw409GQ08 5W4N3w/R/MASE48o7fGSh+Gnab0z+eqbg+7hm+0euPsy+R7eXtPt7Aw90mnLC3SJPwzFJ8U5 +c32xpPNu/Hw05NNtHq340bz86blY+qSAoEUosLGjK5XkeHh3kvwiwcT3B1d/jSheQl66bp+ jidOx11aG4YVTpIxtbbs5uE3B2ZmSayyp+O7m+kIGkC/LGgAMZEGpLNMFrRhY7Nbzk+uvm0S g/fj/s3FHUx477Hoh1prgYykFTJZwROkX9CAg1cWBNHhhfzZDi5rXvUnF6be+sJFneznI7tF NVorSZ7WTI0wI0/fgx6O78wcN6w3GsCmrJttFjC26m6RswQKVIRBordK65qnNWuitgf+ZK3n vPHqReE+U0/hkyc9+A9i4nzrMzo0tWDLgWwJeuJJbp97dzCT0kK0XIfiuVq+sLJufnlj+/A8 T5/imq1yeUetO/XuqJxZQl4wmR7C57x/X/cVh1n5FexRHmblGeC5PbDx3Gp47Cg7FS0uoKm3 hzi3FjM8e5K97io8qpsUt3uUaqqHeC0Dk7Ao5MvQsejc9tKC5eCw+6J7tPmKRyetWNBEnQ/w So4m09J+783b4qsZmeyBDz0Z4tL07Wj8Q3+MEH8tfPC8nBx5gG5b08bzPnqEvT7uoNRjGO/2 qzBnOSZgwmvyFb2/b++ZlQiPWn7ypHf0crsRh7dbFmRIavcWo1fORu+96TzvYOet1XjSmh2K snk7oH/ANzwfzvt4cKML/IWhygiW5jBbYv643Y3NRo3f29/qbm8x+M6u4R4ozvbZPD/2yFJ3 duCm4z43taru9TsF+wf7BqRgp246uhldjt7f2QtuY83655PPXkynTzuwnD6Zs03Te9l7viH7 HqSI/zzcar89/OmfL3rtl72f6F2TvkSPcWPrP17Tqo765Why6k3JAHpyNUxN0ee7237Rp6RD /mTqvYcBdDNrQhYjEq92rG2LiD218RltmdKE1L1kh63eWSwnb7Zn+KTRcNq1dh5SWVsa30uW xQhiYe0HeJXyXC8RuqXiRQRgUD67W7qHu6XNyZ319iE0GxYavecw7vd7tUvJ7b03xSrOGC2a 0xBibL6aOzyyXAV2Wge4EX2K+9BHeEtYn/oFV/O8+0K7mxTxgdTaFiaS/Oz9/0XxH8MzPGny a+b/jf145vxn0InCP/N//RY/mCl2d39r+8V2d8s72vfe7h/+naIdvK393Y3tPe/56+2dre4h ZrT19vaPuk+951Zi2bEkl+Wb9jiLKIHssiTDRCleX2BCZFEuzNpWZloqivu3w4nXv/zYv4N/ PsAM0z/BMBQkPCN0/wboOdkhORow5sZ9doTXPO8VzIXnt5eXdxydAP/b/3sbYy1oRXg+/MQN urzk7LbTEaU/ItaDNTpd/0v+YMSDO4Q8CckwR/jpFQZgmCwfawWBib9dPl2RGNzNIViLT17v bjIdXJlYXD3E5c/gnT+Dd/4gwTv1Cb3PoH3uEe9KPKJN/mlwrV7whM8vPlw9kbN0mAzcTM50 28bkh9H58hADeuhn2b/Fc3T0xMo/C97oGG/nwOdt72wyXfGWl+mfh8+8fzmFylJ4Sswt45lS Pz7zKoXKBMjdFxRlSx5o4dCe3c4QbO8ddXfInS7W/Nks1cbulrjchso/vaWLVK2EgaVFPh5O jpMIWw19XaYEfvTp9IKT9XBCqVODfQ8HE3PkVZ7jWcSlJSd1xzIyk6EOv160MaL4TffQYdP2 HhoOK5g+sAN9+9CJIF+GkQ//WzZkbVAIOvKztFLchkFhsqhY8nUUcU1WdpnvwykCwvG7Hw2v wQy3Kw/p7F6rkgOLc3Jx+qllKoZnY6GdGBxNaxAQyMHro+PXe6973a0V72+wrHjqGcp1c3bh +HgYQqOPOSz8ER2OkGtMwUcvgsShDZLqqY81YxozSupLg5cms/enp7KvDZ+LzPqTK2+56LCl m9vJhffFF7AIWvfM72ef/nH9j+lSSUQ9U3l2NfrA5drR8hfRiv4WVNoPlNc3oxt+ve7JryeV Op96S8/6Sx4dSv62890KSPHZqfk7+G7FJuwsmb5mQh/+JiHgHz0p5JTglEJLHujBX/FuGq1n 6KPnN+jE/O3PNhD/PjN/h/MbHBQN5hZR9Dal8cFDIpLS8/oWxhhatLF3ggt57xov9RXDfoHZ 94voCoobsFW7cC+o5PH7wXT59KI/9h6B5qg6zK0L8GzDPzGsveP9tD5LRd8WfSfJ13j8yFiR k6304tEy5kunI+iPVnB4eo9x3D7zpO/Wa6migiqcQ5UVVIFQwfNvfWr9l//ofEkx8XZ39K/A 0TJdcjOC+e+uehZIUp3VWoOWkwitMAj0mDqQrsctfr+GNdzgDGaYlklnVl5x6xlV8FhJ+C1d PFsY9uCp8jB6WiiVaGXZp2WPWCcZ4OcEw2iMwJibzAqdkhueoClYfl2dJEpVdmt2yZpU6T+1 7p6SnqJphQ6qP3mkTzgXK4+eYIo+7mJhXDT7L3IxsdvKcmquxIG2jXqtWIxw23l4iQGpfXAT RzDAxgWUhHt0ozGh1miGMVxoOgBfdrpmLGzRK9D3DzG/QPFVf7OcCQVmXwHbAOPiR/VAlF6y BNjryi3b2lfbgt6bz6q9AMbvV27j+e79ChAEfr8iFgp+v4IOAn6/ogh736/Eu/2D+xVAZPd+ JY7u29k7bw9WrDvdZHyQKoPp8bPwPDw/937EUVIMCjnqSH5HGav0tLv1zh4V9s+yjNM6jdx7 N1chGwyqz9Foidm7p6rdU4YchHdPuWOo3Wco8mcUwbatzJhv/PUnzYhnTy27Wdb1yOtuvvvW j5/iPAyryI2b4en22SasXfHAwFN6mz7t0Dve0N8/x7cTb/lqeH07wbuLVtZsfq9vCEoFqzse nF9igMuHHdy8O97egvniA3jX+NsjL7BLzZpktMiFecZba+EbblfAjfA584vz7hzewPKLXvm3 Tea0vjOn4cWWtgF2L1tcNG+boefM4BWZiFzMgg4MeTmEDo7sQlYMIe7lUJM43pIulNHi6mxu O88P32jcaIcGXpqtWIn+XMQOft/R2HEQ1ptdD+OMcZbF3aYFvPYOtw96Cq+MP/TT1AMCb4LA CDTszW71kIPN66i3ebhx1DVHTgwvRvQxvoeic5q06s3u5vPNne7GntsqDo/Cl+SVXHPmogW8 KEz/+TcbPd5gMLwibtXOc1jj4eLt5M4jkgXctrqb+1vdjV5vu3fUK7llHGwzoHPK/ckEnJqF DTvYgHXsi+2do+6h1bCoI2EViP4SPnA6uMHU2Zdyysd2tQ6gKg9cQTz8T7jt9GI8un1/QVpQ zDBFWLZtEgT6vaSEwRcfKcK/jN8u7sIZnNVbBJnZquPmx1nd/9H7hzMIZzXwx9qumVfWkUbF DaW+CZ56Gwx1y02sesd4gytKonumfeOPz2p088ca7Z83AfxUXVChiC9/myWV/efPXVX59tRF M1JM85GoFUdtwgr7za7jxqBVd4y6I1qD51UDitvGsM/OrfPXdpVZdePdt6H/NEiopbtyPxvP nAcwuA76pz+gTf81Z9EOz6IGC6GpMj3lhlsTJnxMJA91L8RhEOJkq/ud/PKXWcQWeOiiZawh /NkL2XuvYzFcBm1hHwb5R2vhiVtoZxhFOZzwtgYFPHw5sdpRuwj9Rdag1k/9wk5fOfze7v5i BoXr/7O48EkUZnIPJzr+RaEcxyUHGzH5geIAJW4WDBqbC0Tkx1fkral6o9XGX2A5nBRvvF96 msuUYbCz0uJ4//Ph+1s7HhFnDfjz+vbKhDmDD/QBvf7C9G3RLtcndNdWaoHMU2J9TFQ1Ew0C hZQ/95MMIcoL8rlzkJlfyKw4HGkbwpllFotR9ex5H8TRksps5muz2VPPljbMD08pJ2YYmAtG itZKpCi3WjXq7oehWX4hP+tOJVtQyQWm4rxvLfTNy241nFxzTm2bUNtV/xNnvpE7VmjnGOG5 V29LE2nV5q6zHJEe2+h259NZG2eqn9recYFn20XV0YA/fNnIcbnL4wXr1p9feUlk/f34cWXG cRtI4iQA/VgQ9GMrOaT9Qwq4fGxk9lia7X+3ArOcaezKTDH3U5Tibk0/tWZ/Q1E8rxOFiUI2 slgrtdLsz5tkuOVlZX3v7O66f4Wju395O2iLM/uhTzfpfsSLcvqcTsvhxnVNPLrLdMK/v+sd geNaqsIyHjL+BM7YyYcVTr8EBqt/eznlpjurCEq9RVerok8VpwmaQ89VXBJw7AfQYyhXhIgP nmA07WM2gWuvuhtb3UNbBS2TSSMVvAQohiGLnq8NP5gnjTVdVypfYD2qtQXe2tqal4RU6eT2 ZFUMbcWR9f6yXB30y/7rnR204kZ3V1Yshfp1AAxLx/h47nR0C5oA1qyNSrcGK6DJiBfMtzdo EWitV8EXm/fQzAqmmFjAn/9d1y+0L0fbdN/6ZtPLvdamKCUv1WnOXC6G63mKpISC7wbX4CzC N08x5mE6+tgfn01Y5fhkNBUx6a44TMJOasVPjFsjYRSnV2ceb29v7e9uHu3g5iJmv4IZn+Z6 h1hu8njG3WleHfNb3vOXeqWSykRr+Nyu2VWsVb5cNKJatrOuzqlzV4iL1xMUgLFoLYFETVZ9 fu2q7/m7b4Pwqe+u+nZG7ylpSZEUwlkC/uLLPhrcZsObpmts8/k5oaQFdFq8Ss/t9aC1vrHX JTXbIru74f2Q6+LM8n03lnrde9b0YveeO1F4LvW+H7O9df8NsmP/M8oE99y6wAOXK979vobO Vd5zhxBvtLqXVPxk834l+Jhh7UqvMityWu6/6cviGi3eePOufiVdo/hojFeK5ePMkPmxdsiU hx3vuT1onWW9594lHc2dbWY4b2S/OHh9v1re7N6zWVv3pD+47wYx9Ng9B819d+4ONu7ZpN3N exbYfJfdc0CiqO9nXrr33RY9OrxvP728dz/d13aDwbuv7O5p6jhF0711NrznnLK7W2uMakbq vTecYda+d4F7zj+vnK1p/LFXDm8H5kyA2bWilGUw/iazABdvisxRxdrIosoSqFFsUYMCKFOt SLk4qncc06fe3ANwM6s+Oza1M/NJhSNXa8fLA23zwGK9LJ5ou3+pVzv1jkd9KTyddv+68Kja Z33XZ9SFJ8/uX0pOm92/4OHR7md0ozkIaY++n7widNb8lMuETgXB6DRHMBT1PnMAbRUE5tUj rSvb7tKv7TkxqQpCY9c4u5Ek27BmVxqWUJjv+sPg+gxPDJkUlOe31+Xxx8X8/ac/x7jsvfst bEtmbEvNovTvg8GNN8KdKrAGeNhxPOxfT9cY7Lvq3+EBG2pPecyn3AmzGZ0NTLbv0bXAfRhp gQjP1fC97BNMBlNEMSaL9iUX7JpYLqp/+9VX2T33Uyyszlr+1sJ1zVU8KC04vMHEPXRvwPLZ 7dUN9x9u4TAytWK+vLpn/LNZ9ImFlUcT0YXBmPaJrk8HRQKpF5V5xe0v/pYyVSVFquOBLD6x PluAQUrEKxEaHl7fQnMrQnYLRPctED81udt2fO6cJxg2U+0g7jy9i4RTUnIKnoRVXuvCYicQ EVRn4JloMWFmxXRwRJBG758W9Jd47O8j5wO4sfMBaKom0HfTTcbF6CkDbLOnCug360YrTw7j 0PO2twQtX7LBZCUSf1lsuGW022U4vR12wdU4k5AaiHIfjrW48M2HXwkW5sv6aFe5ZW0zXvNR qUZRBIL6a8jxPHB4jvw+EwzW8d1anPi4z9mWj5FnAzTY6ipEIgsw2GazRts74NUm0QpBwVTy Txx8FgfnjcQCBKcgnnP+4aN1ZbxodXNb9zLe7KpLnlqX5B7EL+9BvLt5L+KNexDDsvBeXzjr dOn7+k2j1NhVLO3Cjz8uMrD1zet1D5p/y1avOe3G5uY9Oum5fgSnphmUVlSLpKsRGKYSbU5O qUObk9dF9dX0972ou717tPtoN9CIWVtso9lEL3C7opZbbeBLqbzzuZOV1djP0ac377QCPy3o FEzt2bwLMYfnPahh6X0PtSpsjEOsBYqWKP79wkXTio2owDv3BHf++wM0vyXU8sshJv+D8ZKZ SUo3O01MxM7u/cANiVytMyrcnAbTZH0NEho6H0BxhOt+pzbSG/Gsg5Ypf3rzSZaDUu8xz8Ji tLl5w1OPzam3n/fuMWdSvr3m9G+37kG88/agOXGZDO8e0zInsrufJWegYncfvnv/8AnnQv81 oBrhcvLUSYZ5ZDLtda0I3TnIBaIW48EHThmHeN1cuMM/ebo4meNsKQY96jMgzpYYuF9V5A8c D3BXqAKU/FwspEQMaNH+6x2CccPAhpNjjhzTYIT7RJzJcRbnIIsSDvezcJlZGEVlZ32EMVLO vedOB/dvbi7v5nfzr9Rji1JlyIiPquF7SH4CigrT7Kc2xsTjL/XgDaXYOIV+YAolvQbpojAs YrNAlb9yQ88wzYx59VQJSisWoc+sDZD12loXgUdGqRatTaUDahrOaST0ptspJhw9m8/SHOnR mZYHfmY6xe4msg96Oh8m47jwdfi/GdikRoTuCJk72kARnWFSD2Qaxk7c4o8/FkbO/BqUv4bf 1cf5nsJXox/D3zDbOs3rgkKzLpYMaFRs8+gn5+yTvYFxNpicjoc3OI9x+PJazU52h5Y6UW37 yzB8t50mYfZ0BGbjbxgnjmmtRzfeD4PBDU4UX3wx6H969qzcZHFaULTCOcrmn1OqqerCi1RA tivqPp5RSOtkThtjtyV0u7OahLMdsGz3QOfTGWbEKpNPPX6MJxHCGUyoaEfJTNjYXSQR4g5I aAzErV0RxcQWpqham2pgbmfqXji09G/GhBg/uo/S2UfUM1qzzPqrrob53ywWp8p6drfEmch+ 2at5f5MfJf/r4PL8yS9aB0EZaVyT/5V/d/O/+nEYpf9P/Iu2oubn//L8rzXy39ne7O71ur9M HbS/Wpv/Nwr90K/KPwnj5M/8v7/Bz4MHaMUwg+jL7l73cGPHO3j9HKTviQa0mAB+3ph0rW3v P26vB56f5z7YQCtZ7eYKPMzyNr2qzf1qctfqP3HuHQ0ww4N3cNk/BQeod4tpScOwM5tQ1MeE oqkkFO1+GIzvRtCu4cS7GYyvhtMprRE5UyouYq30t0B7Ao25wpfDAazDKOEeZUXlbKlno9Nb zDHRpgSy4MZf03W6QzpKhvda9C8vRx8HZ2st6CDqoQO8GAmmdJwW8FyacJpIcldYF5qUvHTk G1wgXj1gwtX+D/DwY/8Oc/WOW5i/Fy/EgTeUgIkaT03AvL1rnvf8jm9q7E+gfSYBbCXzq0n7 iomQr4sFM/iYfcxtC5LBqrx5VeG7lmnz6iqQXGE7JxjKQEkrzeeYlMP4oXh0E8McbiegLWse BQ21arLe4koPDwQiZ+wfSXropp4t9ebLidWD1/Q1/es7yeN2M8b7Za68jxcj5Hw7vcBjM6ej K9ADzPR8O2HxQZOWe5hBk4vV6ajzcacjUBcKJGkV2XYlJ3HNl2He/EH/bG3FoxS+mH2ZlrUe N4a6XloM/v90NFpDrXmLXurHAQaf9X/A3nASObeL1NqD88F4LJnqRIBt1MnWzRjqhy/cv63L NDyZ0T1bpv0pakWLUg3jl1raYY0dHjIz7fOWRXfwvkdQhRaNpwnGNpwO0PnCPNQfh5OLlXZR lScJjYHJ7fgUWZ8N8Pgndth7PLY5bZmCeF/ncGoVRRrRVEcboTimp4E2nnIrkcm1d405F7C9 pt/XWYkMux+uRx8LvmeUBJmSs3JsGo7pERZFTI6HDtm8CUlF0olzX44lrz8FDRJ76IyT4VkL lBXNE3bm4JqGulTCnLDhqNKTH/jVCKUyHhQJuZlqrXXEZZxa8P6ASzkIdjoY4ylcpLiBl0OT YpeGJ3LmHm2pErV7klKnS/cXGcKpK17Ai8EnBPdwgcoUKrsJHvbsmy7Hc8ADHHYtCv6jLyab 4Z0PgBHVc4uXYAxF//CaMWB1PZ2QXSl7gfoVhxGlxV7jUUZlK+oMRe5ogLULVbPUC962LM0D PhugEkU7JhegEkBzZZSBUqJPSDfuWGHgt+G4ZUSDY3igaYmk3f4IMp0ObiZPvWV/heYlnjjd Xge1bC0HK3h/yGAsamLNTHyWGvtoQi8vB+9hmNOMN6H5Waa8ti1hzvVuxGjXR63GU7htksWg jxIj8wn29qa8rwMHC3wQKzyNRqPwonAt6vCBmYUpkzy4Vng1jREFm9PrUZlhHaukr3MmGxDE 9vnMHEONH3JAHyZBxloQJaKmYYIpeIXewcdBS6zFxNYgaK6IDG8pMMrBedVlTscaRyCS4XX/ EhboI/4knGSgI2Bqv6K5dDw6uz3lZtAkMpE7BUbT4hDm6Nrh1ZL56EtEqm+nfE8OjyR8fXnX pkps84RNontkYOqGughYho+CKYS+XibHG3w9xXkW9A5ta5lDGus/Q+s45i+2sv/jzEi3DlCn FzMnfsTw+mz4YXh2i43yRidkSLiSwp9BeMgbgG6e0mjjix9KNvAvTEMD8Knv1sRoYoL9KYmZ lId6/Kp/RpcQ0BaLZ/pZPoiH30nhQ52xaopqfSnuBlp5jEIdTUu6Pjlma8YH44sKzcil+WkE X8hWE3niQIEvaJfmS3S9xdom1+Gej9DbW2v9v62F7jK8PaJbZ/Cyw839va3to+39Pb4qYHP/ 4JvtvZdtb2u7d3S4/fw1viJCvoFjcwMfYOM7Em6tuEqijtTZ8AXsx3wcjX8Qy2CyMLT62DU4 996gI13Eapdm52J0Sfcl9u/EtZXgbuuWhZZ6IQQ0THcv1rjblw64fUvgPQ+g49ot8lmK5tO0 YH0Dtp7sHujkEn3KSZ9HM9VsuLWuBjDPeYMhfbL1BnkgX2jq8ANIDPSLuHDjyw++7H98ymN6 SG2BL29jrl+klW4TdXY4e7S7hNdgozPRbkkDijUEfgHad1tlJsbkFnMz7RPg95PEWpcwNm/x ODc4pK/AMoIhwHwV7aIA3RWKBofuMjgrrqu4HIJLa64SbRnJYG72svYl9Dy7aMplZJCJk3hK HCYTbwnmjiUYKBtg3j+wgzCSfkXHqm5cOB9JziQ6nqWHzNoh6rDOJpa8stvpZEhDHmZQ4G5U pY/W8rxlrouxu16M8ri4J6ktHhtxAzsKZmB0ZRdpWc46HWAYnlOFKFuaA8iMDqc0I3ozitYy NS+DGaSzC2iLQOhgseiqswH452S44DuVFq+std6yg+MVSja+Hcg5CEzaVsw7xUeejQY8E/hr 7MT075osWI2vJmy+nNh+DIrXdq5pO+GaRsgVzAK34IjB4AMzPyj93xZ2zc3w9HZ0O7nk2sHm kC0H3cUMjny1C34E+QjSSJuqVY40sTzyEaeXfboWDxptZv51QuJxSKAGiHfX4mITM2Oh/0P3 kdiWkFd++PH9k8kAt8RxLoNvK1i3kIacyHJ9aDkCbtc5V6mU9bSc61IKahBVISVe6ZDzKn4M mNqLuwnlbmC95sFslmtcEzt4d8KlL37i6EYsDH5z4R5Z/hdOup/Mytw4zaQ5Qak54t8RR/6q sa4wxmKKZWuxZQOKW5oXr7i5taa4LXMp66ntaJJpdw2hGHjtbqGefJzf6p/AuFX0ElQDHO6r wYCVhL9iMrDm8aeMw/dXykUAX09F9ysYn/F8eMnT5yneeY/1wDfi8BaVIx60328usqK1IPU3 2xzmYCwQpd0QxWOqNW7HyUw7SDexAwq2Vn9B58jIkqUt2HRk8xEmZ3pLDth4WiZXwmcTnurw uyomUARLPKgcud2jc1wEOR5Vf0JZ7rGWPvaC0Wecomg0DsdnBRdUoDpPoLiyiTeWV4zrXnS9 meivce8L/Uq8HZGxGVodUCJZvP3uA9gZ+XgwtGBgrTUhdyXqKL1EzBanVGOFcUSg6pkNdsPQ 40y10iDEmDDHPyI3H/u0MITW4X48p5wCRwkVmvXp+np0C9YFQUCZhGlQOBbPUy1enxjIg/q1 zzL6tLB+aRsPrNAPGQXcjqLASglYELpGI9651IsskPQ2iYs4VAeMTKODy0szfyE7jxa7I+/D cPCxYhOJS+nhLXc/YdpfYPUUJ1hnyp5OBpfnBnM0Mjih+BeP5jqa0gtN4M5nlODa6fI2GzHH ApmvmfUQJF9ZIc4Ks7UV8NwNbkK0VwwqECYns0mhr1RnOTxoMdoaoi8A7zml9kCAF+ogXE5S EXaGaodmm+YlxB5OsB39yQjznRGUi67RmDzE0u9A4skAb66asjs7EX/vCvr4A67Dphd0cVk5 Blmy6PHQEMU4UMaqy+8cwdRWNJ+GUsUgEd7Rn1SqRtD5dloUaFWUbkInAQ1bvAgOTQ+tMdnE 8NJkOHEmlVZ1UiHDajucMmkxD7MolFLGCrXcHmAAuIRDeJ3HToBxhieSuFJE30LRjqUa42Te 0mzBcAjeNIiLT/6s8eB9f3x2ifd+okNzAUMap2kGx46gYNvaJqB75cj7LAym9BNNRugYWfgf OaqTacuGjoCMV3dj3NEAL4Aay0AA0K1j5vILWjiUVdHypjX4NBjz8tcAZ4wNIYRxqXa2tYAa jcGdu0Q0wyynJqorAN+8fY1LiyHv7Vyhpeu/f4+9ZNjKmoe/A3tFY9Sq+lpkIOnhHE9kBf/u ex9Gl7d0bRKseifT0RhTJbNNL7+Pfd/SCp2Mjf2zWsdmk3QaVynqLBfOd9Wrn1BtPS4heTI1 7k+wgnPU6OS/EFMxGPiAbs0le4MemTL/tnpmxPnUhsAjL6rOiQJjgJCZjCmGNKAHSv9p4xTm 5Bt0V+gqRZEGPrsc0Fw3ZkyZJkK5mX0VJ3NsJDtQ5SLEJH00o9a+urHeE+S5xv0cErAI7xS4 ja764yHo/60BhkqQkFLSkze2Dl3YLjyy2S/rF+OJXO623FNPnvUUg5ImU8Lf+LvuBv0xbdSU ywpykMgg3LXFIRcP6nrEdznSQpo29Mgxkh0us0LA2Y/DerE3peNsfW3TLMx9TxyqPe5cAekK x5EDOX48ATeTQX3/85d8hgxO67TLComy16zkn8rETALiub+yD1XzyeijEHrWx3sJrtmeiRsj 27YMD5wTfHiNnihaSli2zcAdBkbASY/DfaR9tq+1ePDyzX3GQe0XWofLcrp4iil6tydmdjjh 3gfXBT0XZ4PsvDQqjIhxW2hbkMVxVcycSISbcYLUuisz6E/aEX1Biwa70YzIFUOfa29R7Vyl 2Y+ZaRc8h0puca00LFctsLK7vJ3QyqQ/mYxOhwYQkysmKbnNkLFWXGcJPdthjBScsKrBrGbm L2zcUHAycnsQIb+87NuOQ/lFdD3wR5zF2+TbtSjDB0h8YJzZ9sz32MOFtvhw1hA8DnfzaHOw gHoKp9YutozLdoYLhTP00QmtQFoop5VyJFz1/4s8gCvQaPJOl/kLscU/gBoPLtk1maAZX5Ev bMEcNeZF64RuBmaQCQ2v+/24Uppg5DT5LdTmoqqWuO19GaEENLu9B5P8+Yy3YHFHF8saAZQo hHEyUnRoXwu4U9USkEHecV+2okkbbjjeg7xaU8pDdx1MM7aywmBG+4y7Tc4oMeM7O9EhbWlu pWMl5RZgzgVT2Pah7JgzyHl1A4smK6jEYlKBi6zOwF0Dz4tKnwG1iIEghms4FNT4r7bX4vgS LdZU1N7BpxsEcmkBJVO9MeeWq4K7mQgwgVbcTFvk43wkb3BUW3197Wg/cV+JdZD2ivq3OA1M ZTLDWWSIgnT2PZVmtYpxaDoYXWj3emPGrKgzzDY7iRdnCOOhWZhgsf9mIheG4zL8pmgYDR0S Ey5v0BabBsB6EDe64H94fTibvSGetiF3L2bRmeWdvdpElbyZVtZgkyGCkmZzmlTHHBSY2mYI nWJScdzDfI9LfIZt3a1cgfTAhNcIBvGg6aS698GxN7ji7ZtV2Zg26S6GJ8MpQ/WX/Y/F7r0s FGe/h/nA5DLCvemTO94YI7zCcbAr4P2yAIy1IPsKgzu44XhaaA3X3xdQ15ExRXJ7uE2NiKMJ M7rPxh63uGh+q9KJlSWOhDoka7yPMh1eDcRBmefqL/jiqR3UUBlAovy4RDaj0Zi0ltlIljcc KcKD2MUSrQ1+0y4Y3WSLpridPajZDDUhFGKehjAzCHJ5fjum/Son4ETWYCWo/qVXLDbFuIoB IL2GrrigLa61ljuSJEKFvSRY2cJ/T1FO5QiULSXLHNN3VFZk6Zq3fc4TO8EpMESLnQGcBGDV /l+3Z+8Jy2MnxVqd8p5zCzxRnHEGhuhc5Gn2DxCv8ZZ5t/lqKLGFsl8Nw/V2MFlptywtlKuq RqIIqDvLEv+CH8WtAs+PPBJYLpuKS0u9YuZpDPWDYTIVT7+oojJG2rzdxmMZpwsEP7HeYmqs L8shFxL/hMVtTH8k3vgEo3ZAvSbDq9tLGKYD3iziDQyYQ96LX1la/Za9bWNF6+FtNwS/W8Vk 6p8RIrreRjFrxp5s+89GJvWNdIvomdHtJTtyHCPqjUd3sEy4W6WQAmtwW36CqQWMH7u9IwrD GRUbbLLFcgbTwimGaBBsX/xlMszBd/AnkuWhhYWEfKIyQKtM955AJ6HzzECUPc8R2QkaQ9xR x9vBSziIhDyn+ezDWZs+M4AU/HoxuERPmhfDGEl3zYNyQF4eT73EAgfj6e1lHyztcHx6ezUh q80W7qR/WZrwgc3eikRtMShp9lMMkbUtUYlclQDKa1ahll0t7qBuO5Dbze2YLJiCuYFkbmV+ pr941FvRJ5MyrAKBflDVO0HPCK4zgXqC1TFwIDeKIRNCs5ly3a38oi8rGvw6q4Vml08iafCj 34+F41TCMMsFtiNidvrbBb7asi7HQytzw+EZRvtvCJLHDvO8XZLjYISh1kVITus9xnXAsGar I9UUS/GPuIU/pj1IjO6badLgrFXkU0TTJWsSikYUez66ZsB7QoaT4lpOrTVbH5wlKrQuIOrt TbHdS0FUT85G1yyAM5h9ziiylEKtvMkF6Qw6gzS9O2BB0VbTvtIYSSM5/KSIlxAzKDMhG+KL 0ZB8wqPKqLHVlELisKFYC6L7FOD0URaJJ9ANgw88AE4Gs7MVz6qT6Yx5pkVEtmY216o4xROJ eq1YLLqdxYRP4PaBCQ6lhRHdxiKrU9SVUvtP7sqdLXudzja6dEdmYonQKtLSa+K0Y3YZQBa9 f3bGuAMqAYj7/QDJby5oB935RCvoBeY13otrsSEuPqXNoZn9qVvUOQ7AcM41OQFXsBRolR3B puN2IhUMznBKvObNKTyG3nZtMTj5IxjBuEUyIYNuNRHGOWilARhl+/FkdDYTZUDOS8732NSG omNPmegLOpSP6BiLHIOaP/CxjElLZF8Tks4+AHqxOJzgX/i8Hn6bzYMGDyomzPBDNO7Q9snN cExh6wZmmuDAlRJ8PAJbCH4nhi5AgbMBqNglmXgOOKIqighK3uYARaQQSHKuhRmKCvFVxBtR hCDjW/hotIuG4pruOivjQ83aWPK1kvfs0s4sJORizTKgTmbaJTTeGKg1NhyW2uUqjqZsE6NR gucWgOo61CZIzOwQmkaNxiZqwKnKCLgM00N1aCnqMPPt5YYGd8Kd1gWVTbK7IoZlZPx8UwTX pnprtDMZHLrUWTPOo4lBtUYH+Qoz8ScUC8f2145Cncj+nTOCK041axrtEeMQG7jzQ0ti6NF9 L1fS4hoWs0CxH2mbuQU9X6mubryu0xGO0dUAB9mkRfNBATJOiohnOaaBkxj1O2EYMPJA5c/K tmDI+PtR/5JGN4298QejduwWgMm55XBeKF+CAPTInPBxzs0wp9HVqFiz48kfjm04AwMj00hR 5D3bk8u78qjT3r73duPwcGPv6BuSv7/mPe9u4r243tGrrndwuP/ycGPX2+6ZqNgt78Vht+vt v/A2X20cYtY/oDvsIoXNC2NkLQZAtU9/d98ddfeOvIPu4e720RFwe/6Nt3FwAMw3nu90vZ2N t9Cb3Xeb3YMj7+2r7l5rH9m/3Yb20PVhW972nvf2cPtoe+8lMcRA3MPtl6+OvFf7O1vdQ4rW fQK1U0HvYOPwaLvba0E73mxvuR+1tNGDZi95b7ePXu2/Pioajx+3sfeN9/ftva22190mRt13 B4fdHnx/C3hv70KLu/Bye29z5/UWBQI/Bw57+0fQT/Bl0M6jfeoaQ2u4Q2OAf2u3ewj9t3e0 8Xx7ZxuqxMjhF9tHe1AFxRdvcMs3X+9swEe8PjzY73URv8EuBCbQ4Yfbvb97G72WdOx/vt4o GEHvAo/djb1NElRFkPi53jf7r3HWgO/e2UKCliHAjupixoXu5tE2JoIDSqim93q3K/3dO6IO 2tnx9rqb0N6Nw2+8HuZE28R+aB12Dza2ofsxRvrwELns77FtCdZQeKAl3TeoA6/3dvBrD7v/ +Rq+R9EE5LHxErQNO9OSe+vtNlSOEqoKv01F4EUp/G9Ajfa93Y1vODD7G1EPaGYRue1qBShF qZ0bz/exD55De7apWdAQ7BAU0dbG7sbLbq/dKpSAqpZg8rbXO+hubuMv8B5UD2S9w70Co+g/ X6MU4YEw8TZAnPhpqIciMhyDqGt7Rkeg7uq4XC7rrugf6sXOfg+VDSo52vCoxfDv8y5SH3b3 oL9oOG1sbr7GK6WRAktAa3qvYbBt75FQWvi9NJq3D7fMeKJ+9l5sbO+8PpzRMah5H7oQWZKu FQIxStZbaZMOeNsvoKrNVyI9zxm133ivQBTPu0C2sfVmGy0P19OCsdDblj7ZFw7Sj2TY6PAp fB/RKwH8GPuPJK84TGqDVqOMsB7R/A8Pv0GDuwfOjsxyE9RgmRnPYGK9HN3A5CzeUBlHaZ1v kyg9mSzf0/mPybQFaxCGyW4nxfzDSztZceOSAcEEwqQvcInBTg/HudMcNJy23LmA58DiwA4G JjngpnUUtNgsNvChORFnINnptC9bTqVrVATzGs+RYQjoEVoKTfrn+GnY4qL0lSGm+D7aY8I3 sseCO4PFYVE+gcIxg+AgfBjcyZ4VOO8TcdPKYGMK4UFWxGNyQUAKOXZmt598+KXCHVgCf/5a YCvvZkQrIArFoUg++tBb3nSg0404r0MnSRDkV9ifVN5EDFgd8OWEE6cz6xNYe5x7MOX3OZio T1pAUeFfEy/3ePVXGInwNdRALHDWJ6fna66X1qXWASJH3uvF6UZHyuz9lofDOIJyqod7aieN y8jsieM3FtF69Y5SeZCCD5abSnbKzTDisuxGSa/M+s9regfYW7GyDLvAqJ6p9LNxumBYgTjb HC4CCxozuaMRMhP8enECQ7YKCd69pIhBE9IJjjayqM7TmK5t8TTdG5CetIoDRjULORIVneLF ddZEPh2BdVuvy0AKJ06knrGER1jbmGVfruN6FnR9ngtM5aun/NuffZ6/1aKrQREisGNEEEZj C0yhBXzMki6qxVC18egaPojPA4LzD4ZveMm4pxOu4YSnto15NKdK+tiP4yKi93L4AxvTFkU/ Ah0ZpwkfqXACXWEEDSSc6uU1eNiSQM/od5K3K8MZR7PnDuWZ0qewlJADpBvPe/s74HrsfGO7 zeukEqIN3vQO9Pt/09HVj1+ulaOiag7KqYfmgsEl1sMXSTrWQVKd0UGqAjwy67F1u7rTL+2G rHHcysXdDa7yaJOrDPk27aM2FKVFfc2xW+doibOIrD18tn9O+yqyFVLWR/vGE4Q47xDdwA03 2g6GRRrBC9bJJ7VpcpCJYXoa/ieD1tUIWK6eQgt+IFTjanB9Cx02uJqsrqIhp5X05HbI27rF gX85QiIfS5F5eBaZSHCgjO6g2LI59l7EIkvpq8F4xeOD3OPWBNfvl7zRcc3h7LjTjKfoSmSu PH+zVB5TMe7H8Lx1jefkJ3xc85WEqfcxiALG7DqHUFEZVFM+bPHN6G50dnc9MEMcp8STu6Ii Dg4qG0AjBB0UscBSOTD635aef4m7YxQwCKNxwud5MZu/Z6JgJisFogaV/Qe2xnvVP/1hMCYL +BXHkeDJb9CSozsYaaPrr9ueD67aeHhJiUnQZ+EXbUzXMRmaA15vQIME1q2xugXIIttGJcCB +mPLl6CNlnUMtsg4UOyxjW1T1Mcd2vEIN6jR2FBeiQKhaZngcDqeiVafpyrae+SWgJ9BoV12 jRasPimCUlrC3CBIbBQ+mhhRc6b7DPw5c3xGSXXR0lNdzCKbv3dimz9/Gv3U5H/ahVGIvvIv Usf8/E+dIErCav6ntONHf+Z/+g1+/uo939jb6x7C2v3wqPXX0kF56gUd3/degksIw5pSNv3V jO5VVI2nxZl3wwOWz2BF9w+era09WVtrSaik92/L8GzlydUPTzhTOdC8PKL19jM0eKBuq58G 12t93F1/itQvj1bA/9vZfr7JVMDutNXb3djZ2e/xnxMMtdzvtQRG6R5vbR/2nkmFE+Ah1CtP rGfI0HmAOQlfdTcQAFxpqc2lqafV6h1KS+AlrBnOTvtjcB/Gp08erZ2utPaf/0fxFvxVjMQd foLfn7/e3tlaedKmp5Pbc3y6NoI/MTqIvL5/w3iSs+EYG3y4uYI/rRYVI3Y0KKEnuEuwa6Cq ldaDf1s+pSn26qy9cbjijU/hY/7dvG0VFX+xNnpKrfxi7RTemq56sb3T7SGX/4SHu3+Hnlvx Vm+K9jrsN8FJ/bflzYODFzsbL3v0u/y2Ciy/8lZHUHOrtXbwan/vm6c88cNyGnzEk6vTVmvz +e4mVOs9W90uun11W5MOPq3IBx85EkKeT0HZRGcuR32wWGunRYOxtjZ+b4UAelwasuL9A1Gc 1dXb649D8O+SNqwbzo8x9Hjl57DxmA8mUsWD2qPJ4JdgBz7vZHB8Mjmb3F1NVuDDwU34Adwf 8cahN7xwLYfn96sK6JXKkNau65fgKR9A4c6/FE9up7D8+X18ORr9cHtDN1ahzSHlfdp6sPpv y4e7oOTjc7FH5fD4Iyb5nPNTM/8fwqDb/YXSPy6a/30/msn/mQRB+Of8/xv8HHFuKfbxi0Pm xXkOXIAODSSEQ4uOZ6xhuNXH/oQj36yjru/wbDajtdOx5Ce4GOBgnDw1GR5hri+M/BP4A0iK qKU+HytGEly8j65lRDuHYGTpfIKRZuYslaA0A+/4GOeMY+cUzE1/etFaHq4N1jDq2rscvScc mAJGP+La7vpLiR3nQ/4mYgO5e4PrD8Px6Bpbt7LW2iekgGHxIjkLXpLyyDsc4FoW+ur2ms6q 0LkCerMhpyNhWUnRYn0Ti2bus74ZYejNkL4EPBtsOzDo7rzwpLtbjpgqyCbPBy8PdqBLTm/7 tCgbCrehLacWyQlkJMl2Jt55fyydUObr4nWcOccxU5EEu8iymBJ5n5TwqriE1G5o9v8wY/k/ 8KfG/hcD9Jeo4zPyP6d+HP+Z//k3+Fkkf1md/Sw9uL/8g07sh3/K/zf4aSp/+Jev95msXdy3 jvn+X5SEs/IPO0n8p//3G/z8dXgOs/q5+E3gcvSODl9vHvWOXx0ft/5K53IH+ku8UPeRvaF1 ium/85jSfydedzz8AQMkhpMBht9twDJNzgRxGBvmzvaIxeFg5ti1pO0xhyvhCS/5yK3DNJLo jkp6iBGml3nkHG1u06ZWGfbrZkRwwxSsmE3gguWuBnil9iNMyeY2jXPaWmdOKbnBeEC7YrRj RQfmi60PZFJkApL44cshR3fbQY1yBqJsU7lng32EGb6qDYEKrR4xDbnh3KS/UlvExxNOJkN6 345B5420K9yaB/9zUnZ8cTLW/gz6uJDDn80uaBnJWZxG4w16iq4fXJ+NxnxOlWMYaTvpDM2S aZabfWdoJQ03+/cSLHyKyYJQh2RXqYwWFb08erXd83r7L47ebnCsosQDUtQZxi5tvD56tX/o /e//TTGBX35JIUMYMyBxf97+IfKZDeb7zBhAZLb/Yia8oEkYoIefsLXd29zZ2N7tblHP23F1 vVcYm2d9VBm99kLC47a2MTAPmy6/MQ8TpmbFrnXfdaHtG4fftOtj15bdHkBe1U6A7t58fdjd xfZRyNbz3tH2EYbevdzf36JwMg4h7PbWi7C1170uNQzD1qh64AKdAxT4Ua9729RNeCnU4eHr AwztWvFe7b+FXoCWYgjrFvUn5WX9hrWgu39IMWPYH9TjbYwypZgz6EL4vKPDDewYjAzcPLLJ MAJu/5A+zgq62+u+3Nl+2aVASwlew1jVFRPPh1w58gSqrYT2vZhRzDIqzo148+oj3lD6T1ot 3LtH04+3yWfH0wcPupfnx8/v8FJz510YwEt4B//CSna8/uDJI++1ufzM7GSaWH9gXFN2//zc LUqxWKPz88lgahczpaRY7+NofEYFe3LpG2VZoVNSYGvq63tryhUVzi3pJ0XJV7AEd0tK+hmr qFM2ibgs/Es9VPcSu0D9TnjXu8BaW7WvqRvUb4W39K1OWarVlP00W9hq1buPbukKb+oNtavg 5X/eYiI++GJxBwbHtKn+7XeeyZh2anLVng0+DchKY6DTxXR68/TJk48fP66d9tHz7K+djq6e SJTkYDx58r5/MnwSgCe12klX/fTJ6UW0NmAsae1ienXpkRIbD6W7fQya3XnwAP4HgiPV2t6a pfAfPPDnUwQPHgTzKcIHD8I5FGBie70HUUkB0ycPDIsIzdODBzERnfWnfZjZwKOQKywtOjBL PbBRDxKiRESIu6AIKnLJ93tgex6kRLzfewJ/zLYPHhquGREilc7uYGPrwYOciIqIzJs+RvdN B9Uv2qN54IHPLe0N/w9N56U+4Jh5YivIVf89zMFyRKXk9QA+UkT5KT0nZqaMCPm7WWqQ6Zfd LxViXyEG8X65oxEHCjFI+ssXGnGoED94sPQPP03hjyUswF9oUfUMGWvHRDqpoHM7SFUerIk0 bG9/ryvabg7sKlRhIPoeBqt4Z/Po5L9UbkkkWp9Ec+n2Xu+K8pfHq6iJrA/uB9Qr9s4LHABz P8EQBTu95/INO+CoXQ5Wu+Ct9q810l0g5c94PnxfT6d9RNlWyUakfdB+kW2nR4dGaYC5/GkE 4jXQb9AW4Ryyt/1OyL03Xl2BVwev36FpggKvDlZfv/NmEvtopfa6R897W2iwoNzeYAp/qHQ7 23vIPkSyl3uvn+wMr28/6e14fbiF6imEr27HVZkwXZbsH3T30IIBJfxxM6BIxSswIdsbYVD7 nb39HfRywJ6hkRjBjDycqIS7++iidb8BY0aXOVIQ2Z1Kun24DR+XIR3+qtLg+SPsqhypMG61 rqtggQtj4YFPsqM/WIJ6G7e6vaP9Bz7JbQ/WW7DI3QUNmsBSRSuAfYat8Elg2Gl1zdg43AXL S98Ov+pdCYq8tbGDYyiISQ49hO8xhHfgLQ9Asc9g5bXinLF2Ndpmu93D9f3y4OJsvOIt879r M4b32TNPzDNemPiPmku81NK+Vdq/d+nAKh3cu3RolQ5XqAtwKn3FU6nlCDLEhRtdwMX7Z+tB cckvJvd7YHHl6e67dU94bbvuDvC0nEkoiDWsk82R3FB8mgHDZ2doJdPfOs8h9LtFhL4eEMmM vV5lac3kltMOBaB94zsi/zAcT28x9xk+4dMNFjk4qUB9czESf914+OJ4SMKvwm13Sk2KUkXS g7ml5FvOL/vvJ6YyDEcdjVeLVTq9nO2kwQVOn+sVt4im1Bnamws82W7IKx/EvVBXEGaIdXem UIoPB0oDJ06llf6YV+lEqVQpXlMpqPD12adaGXw58ZbkOR7npINPpu+mnBEVyZakhaXEfvK4 ou4FLnCqI6bJUCEDbTmP7hKiHCOF42yPDoewGCD2CKlQS4cUw4QU3z0XXRK7Q4ScvdmxwQu4 cmwgmTnPjObC1e6CelJSm4SvKrU0WMaCMOfB4I4BpyvMMDD+JPrcyF6jtYaB0/Y6lawUJq2k ma5mLOgtnLi19hYNhEphpVZXr+tqNQOBZ8ZStXkpWqg0lBKVponRaFEx3R4dk5sqfureyFVN i+ywu2MWl2NYxMJEwPk/kdyl7L7rbppVpp0pdJZy65s9s9ik+xnPHFPv0m7uH3bNyuIUQ8UV GvR8ZdVppUeAb5lUCHf2EX2DJdj5eacj38SoveR/OWcIVvTTLfxquyh8ziu4EnMte5j725rf Cg671S7fVYl2YXEjHb5x9PDIe9uFVY7f6VTIegcbh5vS2/R75X2YJaaP+Y7yrAOPKkRJ9nfT t7uj6WgMnquX4PXRFboM6WKXLlPoIqw0cSqFR96qBI/8rco2gb5IHXJ4VO2P7YPeA1nT4+/e YYgVW0shSn8ChRir2aK4F7oUbXhuGBwf9qLj54yhms5Lojb+foCe+ya9AZHjg4NN2jBBZ9+k bJu2lFYJU/Sqy8ZFlcYpUgNP3PctwX3Izfr09hrsJx0qcotxGx/4LIJXBwcbGt8wONh53Xvg c191ry8wNRGnkMXZjDIrgW3WtAW+GYYuf8fB6ONgfKBQ4Grad0ik2S4lOfkR89o4+8CNwPYb hZ/MOP9QaOfg1caDiNlvdTc9eqB95Zv8QRTavSezX65xBKN0ACM27wTJXM7bG8fwdXHH0sXd wRgb7tK9yxIkTHjcbexueZ+yZBVWU/0xfBrmu8KjOm6ZNxuwjkvjon742xiKNwo+9cYxE9sK gvDmePP14SHBUkSzSTdqTqtc0CgGFaNYpMSRBphpq3bN8E/Hp51cHOOOFntxuLW1KtMOJT5x J7DCD7MdsIKm4iwDY3aTgHFl9WDel9501XUmNwco+gbGt1B7y48HCvZO1gtXTPfcgXDGwa34 tIYOjynVLwy4b5BGKYrnP9d5rpyO+85x0Fli/CLQg/fXzvfRk6vBtfYFmpfueiXG9e3Vub6W A2cL3nAjBag4erYci+x0rgdLuLwrUENZ9QdnBGuWeBUBi1O6UMB27XMlbH1OIWESY3nVnUJa SPRqODklgWoVu6K8GlyN8GhbVZJ2CVuUrFiKIGmvxTh8PUkDbob3Nm9T2Bai92rv+PXeVveF GBqMgsQXZ1WiHXDAcEOya7tNmG5+7J3guWgKHyjcqKFe0+c7Xlja8rx88bxK16vIWKfXvPG8 94B9NjaW/ZPJ6JLunutf3g6q1Jv7u7v7e0wfiM9J8N/k7upkdDnbMLtvxCu8vblZ2Dctcn1n 3PLeK3Rmd3YK+FiOYFdIMHfI8+2jnth/s1wxAqyYErtk75vdow2DJss3zRhmp8DRIRYQZ73G ktsFYL2wIS6lrBfY72BivqXi7AxvDqwUfLXReyU+pjTsoo9pt+ZVBguJjd3tTXE5z+7AJFka Ue3Y/aOueJvXGGJRS0ZdmwkhKBrmXK//WrOVBF87+60YmCGfO9Ozr3a2nxvfsdCR1SKF5u01 +rDaJ4MQjQNZfHIDUZJD4Fc9AttKz7SxGLapxH/db+Raa6b0nH/cZVN11tTb8BqGGLDI5reh Agi7rRAW52orKuOyZ81vVRT/+HmvV4CyS2snk8mSWE8JTgeTfMa7LpWClHCoKIgUSzLGF5Tr Pn/9siw3OLl9T7tw9NsMMY8HQ8zKsWQrijlXXWMjhAmMeq9kAsPe4eGYAaXwN7t24burpVpN rRR+sb23XfYR3p3BfWSS3XPiiLOZci/3jyyhvB9Nudj7y9FJ/9L4AGqNaHTKkmhwlmosUKUg tPSoLIhCrIizvrVgMwptWFoDsyHa4FpMTRewpOkjLsl95JZc1FvIxTSfuXDzXS5NP+SbPc/6 kLtri88lf4ileYVTVGVzuM89wmzGI61H8IagVVrr1/XNUfed9VVTcKyrPNTP2C/H5pJb97wK e694buRiBMyBpiwpi4F546XkQVwsHvMK0SxeFLq7KgrNGVymc7gQdw47ONwlju3bmJpcKS/I J1/1jMPu2tYXx5iIDt0fno/ejoczlSMVHozFaYBnn9Hp6S3lFhfvt0KMQOI22iAoEFXhxArt 7kbv78Y51OaHE0xUMjNF0dJUnYn65sPL6YD79Ihq75LjPbtMHtBKCrq/umCezl0wV2TsrGen x+ShrltyLVzWShXlWobpiqWMu3kBlMUShTxPiUA2cQyz5LTSIfoOtPx6VLiYeF2SKWXt1GBb Lmr2aVx8Gtedd1cLl51W94kcqBdNH2Ipt/so0m/2S58U34kCnsxQlx8qx9xmwXf127gh6EYV 6wN39WZLkcU3l7iUpATRlKTFKo+6reyQCvpfDI6jOes72ipG2OF0amogywzDnHuuYjxQWkfH z7f3tpY/rTxYhv94X3/tRSuzNEffHHSZZrnQJtD1FQ+KPPRgkCpltvde7C+ftKdU6mTF++or YO099paXp6bQSssuhr2wqDlMc7/mcJlmzSkF8Fw0a9XtKb0ze0fPwaPd3DBLvB2cJ7XVJdC9 3Nl/DoRsWV+yM6NTvu1u/F0WdXRkVDyfVVmn32DatDPKxl4pSGuCatCQ1CEjZjLbfDK4fni/ dTyUlNWAwNiW8Z2t0FZwHMCrrorVdS6t8uC99G6ZP3pYATaAcv/5f3Q3DYZKM7zsQlXoXrze Mxst57fXs0srIOlxblezTFbWX8hne6drB1BWG65tYk3KLphUC3yuHI4WyaGoDYVwWDpPjDrR Ep5yBGJye17czgOOaTYb28icOOQEjRTMK7PaWAz4jFfDho4OdAh4YuYTaOn6nCYX+fj/GzTZ DgKHctyidftL+uuOkXYcczLU4xo7fYje4fJw5QFYryHZxaxqcg/ZLDKNM+evePB0lpws4gQs oocmcUImMSOT6JYGA7lSP6O/k6+1ulXyjlLG1eEs9mn3KHfiQ+7CGTmYyZF14PdogROUXsqU 4fr/up1MCd0tPDirwShqKyAVH7IMoWacg+hfFGQYrMwQsiQdSpyiXshPdXrTZQmMSZjHEiIv gnxSBlM03B+6sQLCJgO+maqi8wjU39gSMHQzezE0Cm/Af6pD/wm9el/Z/5BSN0UpczVtUQxc 8PfXo7FsR7vNp8QE/6cSpcShPUO+xJPvhR28X5stDKuZ+rLwcm1O2frdLSGYv2VgLMdBg70c W0hsH7UYo9omyWbLjWIeKzs382Q3QzpHYNVB6YiJUx+7ezeGrBSI9FkN3UzfPmS2s10MhQ7K XRZLw1Gtbmbw/AOB8wsf3KwtLIKdfTyO4Mu2ilyCbOm1RWrg7sDBfg2kp7gdB+jNHnUPD8Qz wWOIh0c7W9U2IjIurkn/9tPwckj5OHSI8MBA13E9cq1sJUGxg1dbhyY8pBJuWO2zXRMXYodH 2b1d7cOfgVMfNICpK1Xb0j8XgORmFh85eHH87kGBjXRVEANo3j4okBENPwGKwwcFFHJo7sl2 KX45HMT+KvnUrRL4vS0iHOomAnZqzo6n/ffrAjDR1caTAjTAcwm4LBbMAfULStvmjl7TgNy9 vZwOMc+yFCYoajDwiD9/gmX3z45vpmMnGlazOz9B6dvr0t2Cz1voNHze9xjzxu0qnhmW+JGV 5sBbbo7V7Rvjcf/OO2I1Kz7cCH/LtTFXfbzwEx1caFaxIdAnFpVS3e5Wd0ssjwNFld4uXhCN RwyHJ5XCBztHh92d3v8yW4kCV4xd13vIcx8QzxZ/uX8kVsnIBh4+QSjfJaV9QWOcrJl/HkK/ VWxcxjPlanDVrWJzNKmpSitCu51iqqwSNhpfUwq6LqvruroyGPKTz+vvqoihE6Ae2WMsIKW5 PUBhRb5bwP5+rRrcTSi2Fq1uqOwh4Op5rVIUtzMemDWsVdTexNBW3djYfdDt7gM/mqfAZXxp tT8PNo5emSVwTWHJTFVGMg0wzIsSb8123PP9HZia5aAgnytEPFjKIFZZNKXaCRxjq2nRmjc9 gf981DaRuSDK11Ukft5An0jU+YKymrx58BfxgjC6xwO6vAoD5haUpf1ME0d4cvv+vTv7AwVu VBB7CbLDlA3cF1ejszVcq91efzTzJMxXleL/sXtApQuVWsMPg0Z+OdHMk1sYgTtwh94+CFir ENvzrqn+9/3x2aVIZnD9AUMpp5UDgFviugSx7bugz1eV+M9yWLYWOizGNWSzP7Wmcj5MNeY0 bGg88RPsAWbDpJRLEomWMWE3hqdaq33vEULxK8UZ6T2MqdjCFhZ5R+avFnmD/f+sO88w9Vr1 GS1Xitka61mwxHE4m2c2Z/PM4gyPhHPrr8Nzs9GxjNlhtv9Xt1xHb+7vbW4cLX9q3608OD62 /rJX2miYEHaW19CNbflV+Jk/j9ufVlZmigbMvmBuiOfxuVtRGHUZIVcZmS9zCm11X+xVGg9P FzQeDNPwXO82PNNm/sDDahaEgZ1OZxQelCdwnHcH5buD6rte+a438+7uqsiycHflvDocXJpX 8Gv11Ub5qu+8A0fMFINfnVfkrpa66jbkY/mSfnfekmNY+q7OO1xgl3iJ82qv/PK96pejApt3 8KuzZ8Kg0gMLJKy8JdjcBggr7xE4emAjgvZ7zg5QHs92q5YdkQfO/kiVwqpf/qpSWC2Qv8pq Nm4/bcN69cED+CUM8FfQy8sGGplEukbKARpVIwUFUDVS4jBVjeTdO1UjGQpUNVJQQlUjebmg aqTkz9A10qTeUDVSVi2qRjL6o2okWtA6jRTrWqORBvKs0cgC6KzRyALXrNfIJKrVyHIzsU4j y63EOo0sNw51jUwi0UixlPQvnrHVUpDhvPl750/7o/80zf/HeXjX6DbQ4en9cgDOz//XCcI0 mMn/F0edP/P//QY/w2u6qA7vkR2etth7BTOEVnv57buVR5zIHf46Prk7po0dfCxubhnTIynZ vUfoMJFHTLQr4G56mCHvdnztLc9yX/HQ5Vv9mirgpeBjz3pCKLSwAvcTL2mwm2s8byIeTo4N Kmw10fmWG8pugE0yKZAMFP2M3kG1DPm7FAzxlSSM91sfZpg8MzA1T56mJPyK4KX3I+GcKyve X555HfqcJ48kAyLymXiwkB9e3fJd9Ff9T5hyyuxh8GIXlmEGMT65K0Fw6IPyWiXZq1ijpcba 8zVvYzK5vaIb2ekS+8HpD9xhZmF3gRdMXWIM3513MsBEHnw/FqwfJV31wOT9w4o4tTPaXlcY H0bDM0n7f4bqQmH985SF2LVr8jjgD8gOp1eWHfTNMXRBc/r+J6QvxY1Zq7zhuv3XKejPM0vf 6DZ4pLA4YcVAtOrPPO9/8kiOHi1Al4f0lzdE6QLjde/x4yHX7nk1usiVK8OLR9HKOt/GeE6j RNdyUmlTjdtAkoOltrxxpBAiBvpMyB8X5LwnJORPnnibqDn0qaMPg/E5Yg3LFPNZ3E4KDUUF QX3ivI2oS1hqcLayJozAxegeHi1zZV89w7pXTCX4odjbX3NbTNc77SYa6PmvqKQIgWIC8O1P Lf7/R6It8A5+W6cnrA/4pP8JB9/vbXn/e/zcc/6/d+5f/Jk///t+GkXV+T/wwz/n/9/iB2ag X/IHJwmjKpJG9aDIq4r3Cchlge/xwtTBWZsvpcQkYheYnLHN5wbvMBnrBK/7PMHcuhSNSqls 6ez5eSWvK99lMBmd4k2RZ5XEtHyjwzLd7muuKl1awXqQ19mgf2muLuhV88TipYXg63JCYR4Q 5ioMfH05vBpKJTI7Sn5jxF3xCkpscFuu1YV/B/R9ckVu27pYoY03AF6aO285ky6ymwz4HkWc oyUzbs+5vbO8BJC7a8I3FMtdHMX3DCnr4jl4GHw377S4txnqpTg+uc9VS4r81CTDnU0pbG5I Le6MKDPomleTiz7fsCv2BMFSSrNsfRleknmCN0/gDoiH92GYVMv2V6wVSXm7ek7eJUrCu9Qu Lu8196PSxfN733h/h4VrW0/Na+XjVdLxUp1lFl4lBS/lRFicgndvCzjvweL3ECqivLZrehJe ZMd5eHucQde9sb6nZOelxL7tIr2uSSyLnPS8tRvwP4rFxO8pk9hivlonLW27uGYev/FwHyqR pLT7Jv/tHgd18sXtjoDoCvjiVvqiRVvdjR3giHl4HXp2K1tuTvKd7ed0AGkmH7n1AotwidOb y9sJ/n9r8Gk6AOd8aXMJvCMBElzs9fh4GGbJ8fGK9+OP1sNPlLpg5vGwTw+LRggeAc04Otrp Hnf3trY39hBLmwzgv+Mx3YVLlFbKA8q6hekursGbtwBhuXvuq8n0DAqtXXztPgOHFZ+VD5cG Vj7+JYtYcvXjuU2XC744H9ANqRPi9eSRt/oL/cieCQiWsihyKKZJwg2epslVDmSzS0Z2XZ/w 4qIkLN1mnBpgEXjVf4+bDvQcd1WQBaWeXC+fYXCy0ODaUC5jkyfYQCt1Efrf1tY7Tlmm3mKB 4K4KmMUB5oQiU1vmRLV4rWmNL9e3JZ8iRSreS48ETvW89DSLYPULJk2+YNLsCyaLvmCy6Asm 6hdMlC/go0Fm+xYXFKXkZzlwTq7W3MZbm9J64+m02EzzpyNcEGi7/cqHCAv6lJ/WXZD0YH/n G9qJslejn/761zv3XBlGoN7A5P3xU3tye87E8Pdf//oRaI//+ld4WPItVnwkvOWPnwzzokKX AriuzBYuVpVSfrawodDL28tNZDFb3qIgFi4PGwown+DysCjc8maFaqql7kN5tD3oQG/q7Ebg DoRL2cUlNBLiK4f2oJ72oErbq6ftEW2JYvPC9sR69PadFwauzVaxVLDfFAkIBZzCSXTfwr+w TcewgFPcVseBQUt7DkI8Hw4uzyb1QIz2QxO7pRphcDKcogqs0C6TbIchhkYPV78u7Lurlkk0 Wy6J9HK/Qn98Oj1mCRxPR6PLydrp/XrB7Y9fs3nmDsyf0TwDr2KgwnINfDc7R7fJoqLJhH9W 1ktc0LoetYYbx0j8en1yNrrCWN3P7RRbhV/v9bpHxxtbW4fl++VlM12srPqgfYPr2yu8yxDr xctQryY4BU1vJ+LzoAcJ64Td3vHrPYwM2wav+H/hauTJE++gP+5fDaaY3vAjHrxAQM3KgLBW YYDmCYOTe2phO3UC+2Q7Lyi1x6TCBn97+brbO2rE5XLwvn96B043fuP72wGCvBxavUZTJGIL 3hYBTN5NyQxnfLwokqGntYpXWPSVdFJ9J/I/hWvg0XWzZ8X8j/4gD4Jv/eQ7y0mklh6PJurj DzPkWLfzFIfFTX+w7joIGD97jDc7a8/FiZl9cXEHi2bE29WXH9hlgbH8sfL+JrjSKitnVDlz ULzG0yoejEG+cXJw9i2I+kV34+h47/C49/r57sZB77sZ6vHg/7sdjuuIUcSM/XuyE1AMdewz WWzgsF/GLrset0veHL5ncGv8/dvrMR7dib/zfnzm+XjYZhmePPRCf8XeKjlAIYvqOEqFCln6 kTZgw2sxAqLhzzV7w6WDePLklua489tLgjKuQaspl5CcTRkSEEE4Crxnbmb/w/Q43nNc6Odn 7ndoY4CU+moCPaAscH+yVrWVffJyabxoj7wG/8XLlH8xjBHx0Hve/5j4YfLn/X+/wc8c+ctl 2sWk+dl1LMD/oyCKq/i/76fJn/j/b/AD8/zzjb297mHvaOPwqIX7fAbffcqzdHElz98qb4OO 73sv+5cjMIzb16dr+HqHYWy6JvqpuQ24VVTS3dsyUbBkNHFyXbXSSxXnqCYeQuwj3lD8YTC+ HlyyZUd8wqCEZmkkinozHn7oI+y19Kt4kdAXBj/7PPfR8iJLp9l7JB50ddqkyNxvv/OeyRxZ zMEmohtmiPfgZuOvEyRb0l4stWsK883NN9PRWGUx87rKqH87HR1Px/3rySXuuhzjWcSr/g1x qXlXZQG+yGD8YTiBOq5GZ4NjFjNx0F9VGYATdnzz/mw4PqadiePo/QmVVp4vobfCHW1mbauz J96zFidPX1bFsOI98ea9/7bz3UrhDLXsCtg1MNUs23I3D+dFNFgOU+G5NaQ3vttK65+lLyt1 fptEti87mrTBl8dNLoOdnnvLpbLD0hrPTXkrRcUS99IRcgp/QDYcAWEKfgtPvsNoiC//0fly nd4/foYVeWW8gocBLughSqG212mbrpZHK0V8gKkJWWBN6/jb48dWw/7p9A19BhJ//azKc9W3 Spmfk/Gg/8P6LAv7g7zHyJHuE8HP+gW4/Fhl8s8ZlvSZ601q+sn5y4ib69JaUJb+qVXp5SKe 5auZ4QJPF3X7X/SBMvxO6TE8Jzi8vh0onbZs1Bj1CLWQI6vMh/GVNF/+5cuVhX1Ix0aElywR ZxsNPvjp1Y1hD33kt2sM8/C7apV6tfijrohw91VG9MqsaOcUKwa2XkpRCvz5aY6a0JbV/M/A k0+muU2773fsunt2QvkbfccQlWpminCbLCaQw8KK0VMaxp9+DR9EQVq0r1/8gz5I7WzFQAg6 Y/PDPOfNQ/py1ntE/ywoaSOKF0UEHU5fqD/fhsF3bU4P8q0fZNY8BvbMgEFPLihuDOpa/br8 HCb9eIEZC5YfXZSzkMxByN6egOjYVqFhQkQ121T0oCRTp6i2d4EG01JyVDR3aqLaEDcse6Ki xuBGH+JeGwxBObbMe1Zrrvo+uihnp8UssFq1fPtLp8EefsJ6feN+sutglIZ6RuX9rMp7hvv8 jlxgrZSJn6WkTvvKx9T25+cWbmtldZM30xELqvlp5gkPDpn0H13M8xBqhUhDbYaFeY+j+mry nuNUl76YPPW+mDz7B/zyj6V/XC+1wVBhLjAMCjk+bns8rlgC68bNKA4TT8r5xJlFuNQShlN3 D5fsKWPSP4eZAKhu7pZlkDPQW1YidTzROBLAfbzfs3iCyup8DVZc5VzP902lsXPYfphtscYX Ab1GXAWpbsLzYKOL/BwVdOjEzC3dwYSNkTTXZ4Oz1dNx+N3S7OQt1cOyC5QloFAOKXEMJUC8 tgais1FWdV2pC3QnXFCBjxXc0YHkqlpqX/q8tyX5CiofjDo8GI8tHe4eHu4fPsXzuV4fsY9V 3CahPa2n3tLMKFvaG5X7KBjG9qU1PX9ZXtWAW9trOCpmONijxHJkKq6F5ZpT4puFI+bN9uHR 8fONXrciKunFYqMC+hKjGka3l5dGBOhhw9w2V3WIfXfv6PCbOfz5QPvnVUDxAbizdrz/4kWv e6RXU93q+MzKXn1z0D3c3NjZgSpfzuuxYqcGKlquqwm3LfxAnyXsn8czwrDtYnFtRn2zEf94 fdjtVRpMpDXYgzRVKra2gha4Y9XeKLeFZgfqjFdsPWSn2N7Kn0j8CX7TbHSJ/RYjLtwwABx1 NQWLVzWlENuqKYWv6uq6vcKAi7rq+G1dWbCHdQXh1WypUnxINFvUfb+o/GQRg4nOgUYXqLzy 0c7rOfXPqdkt1b0837M/1Y21wVcr9bExlZ0KiY2pC6txYnIaFP3l13HvMbchJtgEazIdvR/Q eF9bW2s2Dq0fO0rjF9mFnLcJaZ/lozNTRaSN3K5rDhALr79VVCGJ5GATszNkTytkYeCQ/XlU 51f9ab7/J0PjM+qYv/8XhnE4c/43CNM/z//8Fj+/y/6fe+q1kv6echC/H34YyMVp4FnT9gP4 Ntcj584gPtHKAAauOYaTqWwOVo8z95zjzI7fsfA0c0PvyMWtCMwhg1mJQ+btNHPqtBqYjP6b RWQgbzG6+IdzNLmIri74leHWagy4QydR4ZU2jvsfqYNclqaB7kFa99zrV3awOe4QzJx+LcUg NSzPvlopWlCAeXyM2dy4IXHapBt41NQ+Zoph4ScYuYMTqyRGo0NHRRzjWqsqqglxemYJ5zE1 Dz+dL1VghBFEY5zwCXuXjA+KfoiMrIYXPfn4mecI5qdyHmWR/iSxcmZE0K1byH1tRpm5za4H 7Jx2Jy+K+hgJtAP4xGLFW6ZaHntlfFWlAWYPGOP5ZtqBoV6PKj71wnYg+ojLYRYeKS4I7HrQ x6N2Xsg5gNeY8Gh/a/8pCH0gAVjwenIBa64zFHDfSz1QBYoFNheAU0EKNKOcVqhdWPPq1/L3 Y0QWHnr/CtcVjacPfqb0KzV+faYP6fOhD4uyj6VarTN5bVDeajGvd51QPmfhsbB3y5Z5j5C7 /T2FfIrvwZ7iTF9Axx1lEn+RADCa9Kn3doBHK6EFYmux5WDuLwf9yXQVc5xh4EYfWKHovPPh eEIjbALm+fTCW2aOhR1A0MF/arry0bLJlgZtyY6n0J9IL8t1Ig50YrRACnWkU+N+uEKd6dTY +S41rAP6t5fTp9ZCFsdwVcx0VzzezTbibuqf0194MHJ0rYxkR4ruUvFzBhKGLlo69XsNLEet lm29+mUHoN0x2jiEX0T5ZmAHToEhY+vy8ricKHjdwcYdTD1FRax4/4DK/1mdx+cMLipQzOXf On2w6vkUEtEBOQqdAkR+MRFjMeRMCtjM1bKZKsBe1GuBMPLkJ6/SAzCkYehy46GJ9mdDO6dt 0bTP/PB79rHdP07nOR33tdnIwQauWL23oPumo5F3iUfLF3Sa1mvl51T3OqATanc7+KNs5jZU z/0Lf8BbY0E2ptPB1Q0fauOwOHS8MfKNVJpbhj5PJVzZtimz27jXMjw+O/3KZ2/hzjVdbCIk 6Q6LmFPucFfJxIGPnGlDTtvirHTMW0JPLfmrCm22jgrM02wSFSYFf6wdsJmKzE7R4qqKPaW2 N7NzdM/q3sBaDFSpaZ1CXq34w70+VLaYmtVrEZe1FntPjes82Oge7+5vdU2F5c5Mc4vjbOYs sjlLpsYl1fIUvBy8nQhpZ6q6XXaPXa+frF0vYIhdyXxPhlejs/7lfN4h8hZKja1d8MkTnt53 Ru/FlJz3h5e3lD/BlKpsms2TUbl59t9SSoqQ3H6s3ePbLk6HwCdWLiHiObdvBTzJHoq+i1e7 j6fs5Kkym51gpJGb5JVhY1iUJ5Mzt6k8y30xadIwmXQ+Sw2KHUWjBcpWorpeceQ/+50FX4QQ Pn2x5B0cbn9KIk+ZVvUd4aIBjSwObVpqn2B2Kz/nG4jp4vbP1teoyXgs8Pgg2K202hz/+sw2 G66f2+2m+oZ2vtzKrXyGsof7OZ9j1/C5n1RtSqNPczePNc2yd40/59PcGn7WMCma0uzT3hwT IgzO1lv1w6yziZ/7bVYVP+/LrLY0+jize/7fclKr27+ncsru/eJ9eSWgZKaPDMhRK63b6x+u Rx+v6RxMsTRZBqF9WlFmH9f2kTdvKrdRFDVEgNZEB+Z4kMTXDK9xRpbTxeW6x6tZ+MxNPNkA 17dBTtKt5uTgAra9udRz1lXsvuA34fcMOJEPn6sogXqux0JNCnheYluLV5IlsQLDu8syKG/o S8T99Q2l/YQXTIMr0xEt3BBW+sRIIPuUKnpjUCxrrKBuF7Rf2w2b46d1i0XwLUJsfTwoxXGr J7fn54PxXMWrqlwlWNtp0FfPvGUGde2lauOWnQzOR+OBd3o7HuOlUPji5zQNJND7YXhDvihd 48w+6bvB9ZqNLaHvW4OY4TptcG2FBzmHLAomNZBBuf8uC7qVKrREf9s6ylGr1H5k7Kjv14h3 iZmSw/vPtOQFpH9Sh82gMAu4z7fZvzy9xYNlEysrLigEiGEwtY+EIyJKhnnCeWyH0zu+Hs2m cvYLbVtSBr/8LAyldsA7URV81qXOK/rLMyvdBB6AMRUuz/rhLmkTPa5E22H/tC3PnLp1gYXX tZl0AZau25w3ghIscPaHsr1DOYM/nBodN7fPXt6Z3GuSjIn6aNEHm89VFiidJusQ+tq2d0sZ b2Y8krmTnLokkT7AgtAR595HzAY3EP4Ivtfn0MDX1xLZg5rAPGSeJqxQ3B6cG0fjM956wGgO zJkJ4/3qBpT6ZHiJeo/b5cxghHEeHjmDdMBygpMG5u+iYXF2ZtJh0rU3vCOPuTKxaPFpZITm fBSe2QQ1KKNjaWfkvH864I9CGvkQZoJqwEyNpGtXCJq8rQLGvKj2ZcXVDmX5IUpinYiqp50N 4dS1a2aE3UPJVBVT1yqF5Z1R/a9qy5kUK65t6FGTiwsBzTilK52mF/1relJxz8UCzI5/N6NJ bd/htZB6I2lO6Lr5uNerjzCjszebcayYyh5CIfxv/xMfQCgzTeMjvRscE0nTJwwrtFFl3nX3 bk6CYRzpuX3kvGrYYT/wCKc01t5juxPXZ2k5jzemxJ6hLPJ3S45uzC5PmebNJWqS0pv3+qB3 lpetDl4pK1gBdaI+s1quKJ4gKtpgrQFeQPImSQ71w+w4Kmb7pzOrw5X1mRJYVale8qOtMlW7 PctLMxZ1vNQBWtM84VbbPItoHhtRlPlsmGguG9ShOZ1V6sEcJizVZj1eQmGzzAqUq4H4LEiq Vh2/cnqhyaiXFJNlmk2c5yQzBduYmTFPP0vFuP3i0z+uZWDir47WFw/EQ8G/GxsQR6TqG6i1 8nymS+a8xzY1s1iO81rIbKHTWlB+/cyVyxzSr2xDtFCCB6tf7wpSbiaxGdnVT7e13+uAFTPw w2cvFxYvElRUgJ+PT0nv5YyqrNzKM6oCLtAnKa5xKagqgVHVegob4ZxD5cKFKqEFaqvvFQts 0/Fi4wXeQ4krP94yMUiVSWrLGuNGMdoXgthBktXkvzNpEcpIR2uh9bOu+hDLZV1Fg+NILh63 Qb1yNS8PeY2BP4+83uhqgLmPJyaROmjf7XR4OcG877jGOh2Nx7DIgCUWef2mP88x77xhQtiG XHI9KXYPnUNJpp2law7L/JmWOWGxKIpjYxupl+l8nXXtiJ24TivMttRmVJaV2+6lrGRktUm/ KpmUJ1HHJlJOgxBJPBaLdsmhPKFQdgnywstiqv4R/jhj9/EzGrP4/KfqOvEFJc3vg7cmtyH0 XrEGmKXhRIKhCdZwJcUcKF8jnzx0VlUV+wEC8+yoDBkO+Ou8cOHmAcOfM24+K0hYIDETtmuu YzIdh9UUo6ehQhbMXI1sqpNFcSv79S+jbQWrRQpXK/OHD7EZiMpZJkWB/GmByuUov2JVDzU/ vOBYp+7l9oMdID2YCV+3B8YTtOswKu68c3tsII6gZh9VMEi2ThUkfEbXBtrxAO4Rq6IlC9Ke XJR5LF3d4ECc++hWsZ6TohzZX9EklZTTJOCBavht2aq5bfGyDt+b5SBF9VKMahH2cN7/YeDt 7R8/3z7qmR5dPMaQev7pag3iGvI9H8ipZINuWbPj0OYrLHaV0P81q+VWTz2ze+VzWm2iMu2q mjV6dphZVTytDyu0ZOrMOH9xbYmVvMUG8e3S9gfXg/JFKmB31Npjkjuft6+qGYLNGJwDyzlJ jxc683uLT+X/vBP5jXx/8DCtgcMBhfhVS+bgKFZrQv/oxSU4Q5+WyinYJD2oxCQWDNpeWlhl sNMV8jKqUBi3vXhlYd+9HYKm0l1tWB133sTDM3/k9JEdlfqrXSqfCEQ7WJ+UbYr+KR9cBAou Ye7HcK1DX7zwEzAi9uOcz6g02+SY/gAV6GhR7UpW3wAqBxNf3+hVzv0wF3tp+Huf7Gv2s/j8 p0kk//l1zD//2Qk7Sv7XTif+8/znb/DzO+d/xZU6DeaBSd09xKT0v3V+19nzIbOJC+ixe0VJ TR4CGTGfkYZgTsn5lzHIxbt2flHlMoYCRhpO0DH2ODsWAnDd7eO97a3u3pFjRmH+IS6SZxG6 Y3fjZUcn8S0SXycJLJJAJwktEj5PhC4ON3feZja5rrzjyB1SZ/TVLZdrDHMfnFXulYLu4UZB 51Bqg+9Mg0qSv5SJD8IAP0N9lUT185u0HErDlMXnrhZ/RZNvwLuw7E/Y2jjacL6ACLiV+C7Y 6T2vbyYRi+M77/Rf8xZbC6Jn5nYvbyaxRNmhxVv5MPMJxXO5W6QIlio81IHcWkzWpvRRaYv8 FuO7i52ltRkBP9OkSGNxbNaLbC8wu4U15Cj5pX2B73hcLNHhd+oFOxRcY4mZMO7Jcgafbnb7 CpkP/rpKV/p/HFfmz5/P+Gns/31++o9F+f/DKJjx/4KgE/zp//0GP79P/g+PAvk4Ng8Xnxgf 9H4sAXr4AE02mT66ruVgjA2YDs0l9rgLazI+iAuF99TC/70BHT2/Y6rBxRlGTCOwh4bfuS6R OHBIx6AIeSordBkRC5pAaOppXK4MT8S7auzqZR+muEjdhGFMbvqnfLkvcvOsSqGPcbq6HEwH sP7FPP1TEA7028gtrDRj4jafONV+AU/I2HVMSBtFNP2s2Vfe8ARVbnXW3f/VrtkELY6xS1QK 1frPf/7TdyZu8k7x2h3xOYq7GrF9Zq6mZ1+Znc6u3AWIUSv13gx9X3mNPbH44pIj2aunphg4 rYGDChcDGUL7gzJK22rJI35vb2V0y60M8X3wZlpYFoDDQSm0aIYnrHVwLAfxyVnbPX5H99Mu REy2r3l7yBQ+J/9y1TiYLPKG7hrdauvNbVWYJZ/VpDD43Cbx3bk2EomdXBziA9WW2gZXo/Ed qot1sSoi7+hsybfcXMDfJqSKLlAAEtxPk+Q6BZk8M6RyS+zxKW+WFWTXt1fG1bYY2Vp6sFhL C5NxV4yEMgjPDAUk+gwsU6K8pCO+lvXhjz867X1kPo3fY5Ae0S9qczmy8PI2K2IH0zRN4D/W E2FtRl/tZ7QtibSlXU1H50TM2TyVmFRVYjKjEhNNJSaqSkyqKjGxVWKiq0RvsUpMfn2VMM1i SZNKiPCli76yLzq0OmUF76yn7170AQv044vPUo+JpR6TJupRCms6Ph6efXKkhaj12af1olOE 5C+437V3/Hpvq/uCr6IQSX/1zLCZ+/HM1opEGvevYeb7RfuBm9GwE1zjafwTmsnqomWqm/8S 3lIGchzLwKkmCIPO43G77j1+PGwSMrM8+2qlqLPYzSzGMDo5VoyxGlHiEstgrgaQVDcYyY9y XKjh9WR4Jo6Tt3wywJ3yU/Aq8RZBdO3ALzNabnYKUJHKSr/mffhivFltdwad/U1flY1eWZm/ b0kdaBoLukatxdK/RB5qA5HMXBGNDiE+dBrXtSK1by7uaGPF6nMK6SprLeQDNroqHgxv+z9W iEEhH9SzwqiAlWf7zm6r3g7a3cFQ6Wdlmx4XdZbN4T1MQ/xVQbwoz4AMp7NKDpqmfa/nDlC+ nDTThOrTCqBE6cy8QIrr9gUFwJsOttWqyWdZvetOQFTROTz+2R9a+eDCzDx+ZrkBs1Ei1nQv MfmFU97Mlk1cWzaZZ8smpS1rV5L9lVPiLxXeVGPjFgWS2EZOj0haGNMxG2r4i1vFz7aBv5cJ tHVuuwSUEbWgnBzFDFoJJPWKGdB5V5g5W7Ot1xJCNDvDVqLzvEIpnXeF/GfYTzT2E5d9cUZD fCM5pqF+/MTN0clrMekKDuI6U2mKtbzxxBw3q3Cn3ISp3rMiI2rlLX9vZwZk1wYh1MgDkSWs jsZlt2vglzkesHiBSqSknf614Cj1zwzicmEyLSVoE1ujeCYQSvoWunt4KmgXLXzWfk0j+AsY u4r1kgSstu3ihKxVS2S+mw9LY2w1jnnrk0v1Kpc3ZY7eOgvisDUWhPILrtXtLt4rXq04260H rS3OUmvlp7U9p/6nMiDwuFy82cQmMgfDBSWdrRRbwdFX/N64e/RUhZ/VT/pcamb7WmNQdE2t RTDdYa9+fvrpp6C6a/Z7g/K/4c/i/Z8i7OKz61gQ/+PHfjgT/xP40Z/7P7/Bz++w//PX4fk1 32Uv19QfHG6/2cCcQ8fHRYCM8tIKCfqKEtp+7N+sXXxtPZXr8CrPzkCRK8+u+peX+70noNrX 0x/cd58G108kaNx9gWMBX/KwwHdFYxGlCQNv6ezTkv3slp7dLjmEZwjnXF6eOZSf+GGlOD+0 yzvBw+dX0zZM7e8ndHUIp2s1S/NiCx+WuvSRy0T9179yAfe2lsKqqxz18gWD4iokyk9EBxXo HCYsD3G76rjuvcXBTo/anqxUfXPz84/W2cj7J0fEAuny2Up7ebLSFvwU/sTbE9fdEuzTna18 61DhpXZ8KfFsHT+ZJDodaCIortln4H89uoVzRjUphuz3Hsqf9aPY/8lFP4iTJ79cHWgP0zSu s//0u2v//Tjx/f8n/uWaUP/zf7n9r5e/GO9foI4F83+QJklV/kkS+n/O/7/BTzGfw9JsBab0 Tr6K83pbJvY2z+wbsD4hqgn4yZPB+AMuUlqHg7MhTrknt7QMwCCLWzxmDevP0e34lOPtJMAM Fo54DoWubRnxJS+woGpdjc4ohhAZtGmdeoNrhylG5d2MRx9gwXVmDinhfvHl5egjgUojsMZ8 FBIKta4G06e8MMB8/Har6ICRNOd0BPP4FQgcnf2+hD70T0Yf8JV0gyxBYPofYiQGHY26BH7I xq70+qzSIqj09LI/vBqM1+paAjVavWFaAp95dsuZcbgxxerPSObejREOZZNMnMfZ6PQWj4n2 jcCeIHBO149dgY8/HvYvJ0W/Cxe5aWfg2R9TfOPeYEjFkYCXyeeO6kDjy5ckDKquXOEyS8xD dNW/wysIQIXoHheYb0cYIg7loUVXeMiVuwqUEEzV8EPRQjqbSJ0zGZ1PP6IWiX55k5vBKSoY ejGodhI3Q0o2mfCHHL3a7nm9/RdHbzcOux78fnC4/2Z7q7vlPf/GO3rV9Tb3D7453H756sh7 tb+zBa6yt7G3BU/3jg63n78+2j/stZY2elByiV5s7H3jdd8dHHZ7PW//0NvePdjZBmbA/XBj 72i724Oe2dvceb21vfey7QEDb2//qLWzvbt9BGRH+22qdLaYt//C2+0ebr6CPzeeb+9sH31D 9b3YPtrDul7sH7Y2vANw47c3X+9sHHoHrw8P9ntdDz9ra7u3ubOxvdvdWoPaoUav+6a7d+T1 Xm3s7Lhf2dp/C646Nt3+RO95F/z5jec7XayIPnJr+7C7eYRfU/62SVHkGzvtVu+gu7kNv0Bf dOFbNg6/aQvPXvc/XwMRvPS2NnY3XsKnLS/oERDJ5uvD7i42Gbqh9/p572j76PVR13u5v79F /dzrHr6BKau37u3s96izXve67RaGNlPFwAJ6Cl7D789f97apz7b3jrqHh68PEJ1YAfG+hV6B Nm5A0S3q3P09/FTQke7+4TfIFPuA+r7tvX3VheeH2J/UUxvYBT3osc0jmwzqgw48apXf6O11 X+5sv+zubXbx7T5yebvd666AqLZ7SLBN1YLwoc7X9MkoImhVi361FLZNgvS2X3gbW2+2sdlC DKLvbYuaUJdtvpLuXrNc1fr5f7f/wwCXcT9/jlm0/g9m7n/z0yBK/5z/f4OfvzrL/79W1/cV P+CvNQv8v3obt2Bwx0+97f4HsLO9NW9r2J+eXvwwhNWX/Pbv74nV2unoCtafNiJwtH/wbG3t ydpay6y2/20Znq08ufrhCUwR58P3rRas2J/C5HfC2rnWb7V4OHWPwfj0nklBXLk+OX1i/mqp DK9uoPGt1uaLnY2XvcfPVvdDb3Vrb6v7/PVLb/V8BO7H6jnmh1yVK31arZbUOsIYDvrt1ASe TmS8rF2UT56/gb9OLkenP6ydth782zKlRzm9Omtvbq5ASzYPDqhq+l1+Wz0tOa+OvH/791bL +tii2pHDbuNwxRufToAaOIFE8MKhL9ZGbe/fvofFa2s6mEy3cKIEuZS/q023O7ZZgx2Gqztr 3uolczDNb60dvNoHG/aUrjk9vRz0r1st+udp6wG4P6vn3qO1kcXHle4fczn9h/upt/+iv79A HXPtf+jHfsefsf+d+M/7P3+LHzzQXl0CZhWrj1cUgYt+hTlyKQkHnQWh7R1viyPZYaUz/QsQ Im3v+RuMP0fv+ikdwMaHRxhZwD9PveVvs+++DYPv2t/6Cf0C9u9rTx4i9ZvNiVdQdzCXUbFK tBY+LeeYKCK9w9FC8HcJjfNSC48h/LsnGdMn3j9or3AZlgx8Xbz6yq9/FdS/CutfRfWv4vpX Sf2rdGXd+/cyOfrw+hIBVjoDRsNZtl/fjsZnYeBNOghnYp97j544MREumd+MLGhGFjYji5qR xc3IkmZkaTOyrBlZ3rB7m4qhoRz8hoLwG0rCbygKv6Es/IbC8BtKw28oDr+hPIKG8giajouG 8ghq5cE/QvcIjVRjyto2zlDWtnKGsnk7azVnhrJWd2Yoa7VnhtLWn5UWZwCrdHmEMSlga77+ 2lvGh9mKl6x4P9Kzr74qngVsc6ul49nSvq8V99XiCYYkQBO+R1YaQTrLP4gV/qnKPiP2CbFP NYIcCVIMJAky5X3YwfeR9xCsrPbah9f/gpZolcP/P0Or+xDptPchvocavkdajSCi1ufYujDU CGLiEGEwFj/DzveTMA6iTvZ6RytCHZ4RS/WLUmJJ7xPtfUbyALJZdYGHC/UlzJXyRmEqDFSN iUgi0AzstVwj8JUajMq4Nag6E5HYIhJLpMktClmuj5FWex8VOhNqOhfFrDShXj0JKMbSkSag iAQU0YiJNAlFpPMRiTBS6yedjzJHa7I8j6I0inxVa2LqdFLESOvz2CdNxfdxR3sfkEyAbFZr 4OFCrYlDpbzRmgoDVWtikgk043tkphHESg1Ga9waVLHFLDYSS6zJLU5ZrthFmthiEhvoJ5oa Te3inNUmVj8wsQyVJqGEJBTTsEk0ESWk9jGZwkSrP2G1D2y1CTtRHgZhlOpqk1Cvg2+HPLVe T8iA+fQ+0t4nJBUgm9UbeLhQb5JUKW/0psJA71aSSkITSKINpiRXajB649ag6k1KcktYLprg Up8F+xhptfcsNx8ln2iKl4asN0ms1h+VapdqIkpJRCmNnFSTUUqan5IQU7UBpPlp4ihOjumt 8jgNVcVJqdt95ql1e0o2jBQr1ebtrENi6ThSYaF0bJmEHa1TMn+2tB8qxf1cLU4iyWgGybSh lIVK67Tm+XrzSGYZiSTTZJbF3DsgU7X6pHitzV8ZyQt4IHvNVGUsndryJBvgguU14eSk8xnp dKbpfE46H9IUm2tKn/N8kvuKfHN/sYDzUClvJOwy0EWckwhyEkGuiSCPtRaqTdSFnJOQcppQ cm1Y5WkhxVyTcl5KSX9PYspJTLkmJhigpSLkmpz8DgkqJ0EBuUrC9qnDJFpD/A5LA0lnxYlP F8rT70QaCyPRCg9dpH6HJyNozffEUaVJ1KbqbdUF63dSrifmerQR5ndIeDlJD7iqJHk5yHUK v8MVZVyRKkHfL7UACqgkAbMh1wAKqDTsHERMoreGRQSWe3Yuh4cL53LfjxUGZjKvcFAnc1gZ 8bQS8ddqo8r3U6UWM6G7tagTuu/L3JVwJdrs5fu5zLrUXergC9gxoIVAqooukMVnqqtzYDkG QKuSkNSwqu+pgErDPpxPzj+UUGl45ATOQjRP/DxLYTGqzvA+r/z9gNmqoqC1Pw4CIlHHScDL USSd1Sp8ulitglxjYfSqykNXLIYJsDXUkaq4Ql+rx2hWpR5dtRhR8Bky8FVQwWdUIeZOU2EF n3EF0GXSDFVBQ1mjwmu9JUmpnb4KJPiMJGBl1FhVfCGPlTDk1upNyZnGXa/GnSxPO3leo12M EvjCV5UH4QRksh9TAZWG/QykVdQrarBy9aNQY1GoV9Rg8eozooCt+Z44qjSxVk+hXtHiJazP 0IPP2IKvog8+ww9JzJ2mCpUBCFToh9TNKo0sZuG12hQGHERFVcjBZ8wBa/ueCqg0PGAiNrTq stqP2QjGzsI2iOIwCeM00lE0PxaJMF9VIDEbRdHBWHUnYnEnYm2Bi08X61ecaiwK/YobLHJ9 xh6wNdSV6jCMc62eQr/ixUtdnzEKPxaJqVJlnCLl2UYFKvxEhMozmwq2+IkseuG13pTI1lEV m/AFnEh41Kn4hJ/wkEnY3Krrbz9hQ5g4C+AgSztpEgaBjpz4iYiE+aoSEegBNUxxm+HpYrc5 7WgsCrfZ5VHjNjNAga35njiqNIHaVL2tNW5zyuMUqqN61JktjYxNf0hDT6WJLde6hoSlmrIh VEENP01t5zpVLaHAGCmbABXI8BnJSDMmUV1BATP8ik8qnef6pDWCFkSjwqIQtMujRtAMa/iM a/gqsOELslFtqt7WGkEzvOEzvuGrAIefFcb1IfWhSpPYylBDw1LkNa6voh2+wB2iDZkqRcY8 fMY0fBX18HNxEnm1rAIffi5yyjXkCp8uFrVgIxUWhajzBgCWn/NYy3ms5epYyyO1qXpba0Sd sxhzXnLnqonNZTCyL6DCQT5jIUYdamhYjDlPcrkqxjy31UFFRQJGRbDpj6mESiO+CaEegQqM BB2WE9LOihqfLhR1IMBJhYURdYWHLuqgw5uMHRptwFGlidWm6m3VRR10eKe3w1u9HXWvV5CR nKFJFSwKOpmlDnU0OdeVcl2qGAUcYXUIVHAkYHAEm/6YSqg0bBXjiGnU9vgiJ18DuPDpYlEL elJhUYjabwBwBQSgUGu+J44qTaI2VW9rjagJQqHqqB7NqAaMkqDqPKROVGlyWx10GoZJkB3V pYox8G11CFQxMlqCTX9MJVQatopJxjR6eyKLRp90AomZQNpZrx+fLo66CBKNhfH6qzz00AuG V7A11C2qmARfqdRjvP5KPXoIBodYYG1UjToYDX4iva/2Wsg2NSbMAWpWaQJ2++G12hYGR2Tp EKjoSCBRFyHNfYEadxFw4AU2+zGVUGnY4IWxs++VBFGYgdfYUd3+QEATNjgqZhIIZpJL3WpU i0RZIK2iYfB0sYZFHY1FoWEVHrqGMcSCrfmeOKo0gVZPoWFuPbqGcUAG1kbVqFI1EAot1AIV QgkilmoQsXaomkoYyb+oYXpbUltLVYAkYIAEq6P2qhLkIA1sNrVXbQuDJEhqa5jfifMs6ujr ykBQEx5oKmgSMGiCpploVFMoARlIqyhYHDRQsDjSWBQKVuGhKxhjLNgaih9Tx6FgLJV6CgVz 69EVjGM3sDaqRhWqwVBi7jVVqDELFXT6IfWzRkMgyb+oYXrAnG8rqYqQBIyQYHXfUwmVhgdN zJNZoreFTWES2gqWdFKYM4JUR8YCQU2ErSoRBk0Cxv4DFTQJJHIDaRUFg6eLFSzJNBaFglV4 1IQnssQSnrwSdRgKiFKpp1Awtx5dwRhDCRhDCVQMJeBAjyBgi5CqQk1FqAErh6qohJH8ixqm tyW2lVQN+QgYIMHqqL164CYPmpSlrAIkAQMkSGpj+xF0dIabR7qGpeIWMl9VJBlbxiBkGtWf EEgEiRSnPGgAnwVZoLEonPKgAXwWZCyyjCevTB2HWaQ2VW9rjVPOiAlWR/WoYs2KgUkuljpJ MmJiHPcaGhZrxmsrFTEJGDExjruKmASMmGDTKT5XFWMuPgbPaOrSPxBIJFDjRYImASOBRIwE eshI0CRmJMglnpeX2mrYSCBxI9Wm6m2tETUjJgHHjgRq8EiQp2aEPKROVGkyWx1qaFiMHEAQ qIhJ2OnY6qAiJiEjJgGHkoQqYhJ2ZFrzmUaNqRZIJFRjScImsSShxJKEeixJ2CSWJORYkpBj SUI1liSUWJJqU/W26qIOGTEJOZYkVGNJQkZMAka8QzVUJBTEhNWhhoYRk5AR71BFTEJBTFgd QhUxCRkxCTmeJFQRk5DjSQLeZwzVpX9oIJGso7kIWWexixBKSEmFReEiVHioLkLIQSXYGvpk /ZhAqtVTuAhuPaqLEDJgEnJYSaiGlYR+4V9Sr6mDUQCThM4lQM0qjUSWwGv9YENguRmhCpaE DJaEgRxvUCXIYEnIU3moziUhx5aEbmyJn8PaJc3CrOaQgxwr6TBfVSSCfnB0SaiiH6GgH6Ea XRI2iS4JJbok1KNLqjx0DWN0JOToklBFR0KJLgn16JKwQXRJGPK4lAMpNUdWCgeTzqSoUhUA JeuwdqiaauJLQj2+JBTwhLU01E+qyFEVDjAJ9dMqDJaEHGASqmBJyAEmoRtgEvhJABoWdBJd wyLBHZmvKhJGP0IOMAlV9CMU9CNUA0zCJgEmoQSYhHqASZWHrmGMjoQcYBKq6EgoASahHmAS NggwCTnAJOQAk1ANMAkZQAkSdgRUACVkACXk3ftQjTAJTYRJqEeYhAKeiJaqISYhgyUhh5iE KloSMloScohJqKIlIYeYhJUQk8SPMljndPQQppBDTALWHjXEJGT4I+QQk1CFP0KBP0I1xCRs EmISSohJqIeYVHnUdDeLjENMQhUeCSXEJNRDTMIGISYhh5iEsUhMlaogKBnPDiqCEiYiVfaZ 1BiT0MSYhHqMScjoidFSNcYkZLQk5BiTUIVLQoZLQo4xCVW4JOQYk9CNMYFJMwuCIK4Bm0OO MQnksJ8qEokxCdUYk7BJjEko8Eiox5iETWJMwlQOBBA+Eqr4SCgxJtWm6m2tcacZPwk5xiRU Y0xCOTHDYQWhGkASCoYiLncNDYuVwwpCFUMJ09R2uVUMJUzl4BiLUQ0yCRkyCTisKlQxk1Ci TEI1yiRsEmUSZr7GohB1kyiTkKNMQo4yCdUok1CiTKpN1dtaI2qOMgk5yiRUo0zCrLCvdJZT tSaMmRh1qKFhMXJYQahGmYRZZquDipmEjJmEHGUSqphJmIuzyPOnipmEEmUSqlEmYZMok1Ag lVCPMgmbRJmEHGUScpRJqEaZhBJlUm2q3tYaUXOUSchRJqEaZRLmMhoprCBUYaSQMROjDjU0 LEYOKwjVKJMwz211UDGTiDGTkKNMQhUziTrintBEFqmYSSRRJpEaZRI1iTKJBFKJ9CiTqEmU ScRRJhFHmURqlEkkUSbVpupt1UUdcZRJxFEmkRplEglmwmEFkQojRZ3MUoc6Gj5HzWEFkRpl EglmwuoQqZhJxJhJxFEmkYqZRIKZcJRJpGImkUSZRGqUSdQkyiQSSCXSo0yiJlEmEUeZRBxl EqlRJpFEmVSbqre1RtQcZRJxlEmkRplEDJpEDFZHKowUyVkcUQedhkGTiMHqSI0yiQLfVgc1 yiRi4CTi7ddIBU4iAU44giRSgZNIgBOm0SedyGTmUKNMoiZRJpFEmUR6lEmVh56ugXGWiKNM IhVniQRnifQok6hBlEnEUSZRIL2vDkaDo0jvq73GUSYh799HapRJFEqUSaRHmUSS2IMXD5EK kkQMkkQcZRKpUSYRR5lEHGUSqVEmEQMlUSXKJIMFY96pCwKIQl7QOd5TKkdTHZGqC5tIcoC4 Tl6mlPdr+odlFbKs1DiLKJKME1YVah8xyBJxiEmkgiwRZ/Tg8aRn9IgktpxJ9KQeZg/O+erU bME5n613WxRrHHKVQ6hzYGFL8g89PYjgJ24lerewcYx4btJThUiuEMkmooahRIykRHxcO1KR lEiQFA5ailQkJZIkIZGaJSRqkiYkkrCUSE8UUuWhGyzGXSLOFRKpwEsk2UIiPV1I1CBfSMQJ QyLOGBKpCEPEcSchBy1FatxJxMBKxPEgkYo/RSZ1SKTnDokMaiJZZ1QJMmoSMbISqahJxKhJ xElEIjXuJOK4k8jNIwKOIfxEaRrpBisxx7sVi+V3GpisJFYYGJvlcqgxWozCYEvo+1V5yUmf zkKrxchLxHlFIhV6iTj0hHPuqIEnEecO4VCbSE0eEqUS5BCqVitsYLXSQOOQqxx0q8WgSsSg SqSCKlEqQZeLrRZDKxGHnkRqeErE0Ar2D+VA0tMosV+SSJ4kdWylhftINKqYUkbIkFaxWmmD UMtIkJcKi8JqpQ1CLaOMh2fK86C6rRdJuEqlnsJqpYtDLSOOVok4WiVSo1UiQVY4Ei5SkZWI kZWIT6dHKiAVZRJqCa/1tqS25VNRlYhRlYiX2pGKqkSZ5MPitZWKqkSMqiCpg+CDU5Z2aiLh InOWx9eMlt/AaJmTPL5qtPwGRosRlogRlkhFWKJcDvgvNFoMo0QMo0QqjBLJYR0eeGrkSSRn dSSZmCq1XNYDUa6ZLXy82G7lucoj13molitmEAabQ1+sZj5jEKZajZoEzaRCIWgzVkGFuCMS SzmXmiaxWMAUdqZiFUyJO7IKl5xsmrBiCUBBWiUtW6fB1lDcSTUWRWa2ToOtoZixFmwNdYs2 RuNOrtVT5GfrLN4aihmKiRlLj1UoJhYohmMsY12KDMWgtXxI/azSyNYQvNbbElnmL1b3B2LG UbC676mESsNZ5zhRVqzGnsSMk8S+szWUdGCOSJNAN12xb9JqaKYrWGy6Yj9XGBSmK1hsumKG XGKGXGIVcokZcnErUftScqFwMEqs4i6xnO7hrlRhlziQs3JMotckK4M0UU1Xmiw2XbGBXSo8 cp2HbroYdokZdolV2CXm7KjVavT8jTmzS5mdNkfGDK/EMnhUeCVmeCXmlTaUUGl4gPG+ZKzG ocShLPTU4N2oSfBuHEYaiwLrbBK8GzNCg635njiqNInaVL2tOtYZc6gLVkf1qNLkUJeIozUj XTsFeRE8VKdh5CXmDKuxGtoSC+oig1NFXWJGXWIOzI1V3CVm3CXi7GCxCrzEArwg7ayo8eli UQvyUmFhRF3hUSNqycvK2EusYi9xlKpN1dtaI2pGZWJGZWIVlYkFleFozVgN14kFlWF1qKPh 0RjRoiHWM7fGga0OemZSjm+JKaUsllBpeMpLWR1qcrCKnOJIE3UcNRC1hLtUWBSidnnUiFpS tfJxn1jP1hpnalP1ttaImo8DYXVUj2pUGZpB1XlInajS+LY61NCwGBOeAVVoJk5CWx3UI0Ex B7Vg0ymRrSpGDmpBN5Vo9PaInELtABk+Xex7yhGhCovC9wwbHCCLGYiJGYiJVSAmlhiYSj2F 7xkuPkAWM1ITc5rXWIVqYkn0ytHtsRrjEkuy1w4BdbG6sxCbfK/wWm9LZPuvas7XmEGWmLO+ xirIEjPIEqfSXj3nMY8kN/drmnYCUKBMj3uLU/E9Q833DBv4noLIVOKNMo1Dje/Jx4ewJfT5 qrgYcHErUfuSA1piDmiJ1YCWOJNEfNSVKqoSM6rCAaexCqrEmZjPjor24ePFvmeWqDxynYfu ezIwEzPoEqvATJzJom8x4hczPhNzQtlYxWdixmdixnBiNeol5pNCscxAavhGnAfG3BKNnodb kpHnqunKm5guiWqpsChMV97EdDEcEzMcE6twTJwnWj2F6cobmC6Ga7A2qkYVZp4Zk0K9plpR DnpBa0kpyjUdTzpy9hVea21JGGsR85eoAS+JgCw5TWKJCrIkDLJgsx9TCZWGxhuS2ucOgij3 444fBHq+845JwqfZrmix7UpMftlItV3RYtuVcHRLwieCEvVEUCI5VKJFtivhEJeEYxoSNcQl 8a1Ui4kKqyRyKojMW6IO8sSXGwLCjmq7ws5i25VIAEyVR67zUG1XwshMwqhLoiIziSAzlWr0 z+I8mX7E7LRJMmGAJmHkIVEDWRIOZEnYpUrU0z+JL+6k0KjCCnirAWlnbRc+XWi7ksDXWBRJ 9f0GiXgTxmMSxmMSFY9JglCrp0it7y9OxZswXoO1UTWqMIPY2JTHVEKlYVcnJ9uVqFhUQoDL v6hhelsyy/4l6qmYhFGWhO+rSVSUJWGUBZtN7VXbwihLQoEjpe2CBU0n85O8xnaFstsQa7Yr bmC7BJNxGRS2K25guzgoBlvyPfFTaTi/QLzQdkmKWj4elKhHiBJJt8IjRoVVktAKkk/UA0SJ ZFuJc9125U1sl6RbqfLIdR667YpE7Dz1qahMIqhM3sB2yT03nFYlUcGZJBKJ8UyqogwJp1VB pSQadYQJusLnPRMVXUkEXUFaxXZFDVJCJFGmsShsV9QgJUTC4Au2hrpFHaRxR6unsF3R4pQQ CWMzCS/GExWbSQw2wxOris0kjM2guXxI/azSSEoIeK23JbbtnwowJLFkhA65vaoEY0keLO3V 28IzXeymhMhzcGWiPNNP4yUmOW2i2a6kge1KOgqDwnYlDWwXgzAJ51xJ9Ct2JHNtstB2yV07 CQ89FYlJJIUtjxj9dh0GYiJKEIQFVBq5YsdPNeOFjxcbL3PNToVHrvPQjZe5aYfnPv2uHQ6J qVajdrXcqyMX66iIS8KISyJGR0VcEkZcEk6Tk6hZV5JU/M7KJUBiut1LgHTYMkkjjUUBW7o8 ajwMBm0SjoxJVNAmSRO1qXpbddgyYVAHq6N61FHMkTPoiz4ks67S5Da0qdMwEpMwEpOoSEzC SIxAm4ka+pIwCJPw2j9RQZiEQZhY5ikVhUkkEwvSzooany4WtaA0FRZG1BUeNaLmQ0fYGvpk vetStal6W2tEzShNwpk7EjV8JhF4hu8CSFRkKhF4htWhjoZHY8YGVIVnkjyw1UGFZxKOecGm P6YSKg2j2Hz4P1EzsSSSiQVpFVHnDTYjEoFfKiwKUecNNiMSxl8Sxl8SFX9JJF6m2lS9rTWi Znwm4cwdiXooKe3IZWU0YhMVckoFoxF1qKEhMaYcCJOqGE3aCS11SFWMJhWMJqf5LVUDYVIO hEk4SjJVA2FSQV3SjmbA004DA55KIEyFhRF1hYcu6pRhmZQDYVI1ECaVQJhqU/W26qJOGbFJ ORImVSGblCEbVJ2H1IkqTWCpQx0NiRHZfU8lVJrIVgcVc0kZc0k5sixVo2FSAVuimGn09oic XCfMdJ/r6dWIWoJjKiwKUVe8RV3UjNVga+iT1dEmWE21qXpba0TNETJY3ffEUaWR0chXDan4 U8rBMUYdamhYjIy2pCrakgaxrQ4q2pIy2pLyVkeqZm9JA/FBAqbR25NZNPqkk0p6FqSdXVPi 04VryjTsaCyKe6mCBtG7KQM22JrviaNKE2j1FDdTBYujd1M+mJTyoaNU3T5Mw8is9R5TCZWG bWpE2VlSFadKQ4nehdd6W1JrXZqq2EvK2EvKYS+pCr6kHNKShnxDpnqYKOWQFiS1o3fBHQmC TpbpeFgamSsTtDVlunhNmZrLg1J1TZkuXlOmjMCkjMCkKgKTSmLbdNGaMmUYBnkSM3XoyQ1A dJInVVGYVO4fToVGlVsBs0TqmjKKFq8p0yhXeeQ6D3VNmcotQpy/JVVPJqUGZ4kWrilThluQ 6/dUUKURkdFCI1VDYVIOhUn53HaqhsKkDLmgwSUaVVoS65KqqV3SJqldUkntkuqpXao8dOPF iE3KqV1SNbVLKgBNqqd2SRukdkk5EiblA0ipekgpFRCGg8tTFYRJGYRBe/mQ+lmlkRiKVE/t kjL2YgygCr6kDL6knNolVcGXlA8VpZzaJdWv703k+tzK9UGBn4VRGOW68ZLct36mGa+sgfEy lwtlqvHKGhgvRmBSRmBS/W5juTsoW2i8GIZBnt9TMZXGOsSZqseMUo59iWlTFwuoNLLuS33V eKV+A+MlMEuVR67z0I2XXJvMMEuqwixpKi6Ov9h4yT1DKXuc6omblNEW7CXqHlVkjLagVj6m EipN4VESjSotyeGCtIrxyhpEUaQCxlRYFMYraxBFkfJBpJTT4qZqWtxUYmIq9RTGK1scRZFy SEzKITGpGhKTCtgS8cyqgi0pgy0pn9RMVYwqzSWKAl6rbcl92wCqQEvKQEsqq28VaEkZaEkZ aElVoCXN5apJJ4oiyOMgz5Oso58+SAV58bXz6X6DA+qp4C6+ekLdb3BEPWXUJWXUJVVRl9Rc KLTQeDG0kjK0kqrQStaxznKm6kmjTJAVTgeQqdEvmaR7QTdEMV74eKHxyiTfS5VHrvNQjVfG yEzG+V4yFZnJGJmpVqN/VsLsImanzZMZB75kfFgzUwNfMkFY2KvKVIQl68jSPGEaVVo+r/mQ dtZ44dOFxivzfY2FMV5VHqrxyhiAwdZ8TxxVmlCrxxivSj2q8coYn8k4JiZT8ZlM8JmAFDhT 8ZmM8Rm0lw+pn1UaCaOA13pbMssAZmogTMbgSsapcjMVXMn4eFHG22eZGtKRMXiSBU4YRRj4 ndAPYc5VjVcWmGu9FOMVNDiqngWhwsAYr6DBUfWMgZiMgZhMBWIyBmKChUfVM0ZjkCcxU4de YB3pzFQwJpPwFz6zmKnhL5kBYzI1jiLNGsRRZAaNydQ4iioP3XiFInea/DIVjclCmSAXx1Fk jLpkjLpkKuqShSIyHj4q6pIx6pIxLpaph42yULCzlGlUaUn2l7SSKtjgSOliCDSTDDAVFgUE 6vLQIdCMgZuMs8BkKnCTRR21qXpbdQg046iYjKNiMjUqJuOoGLT5BGip2ilgjMCkNTQsRs6j m6nhMJngMDI6VRwmYxwm48QfmQrEZAzEpBzul6lATCZADNLOihqfLha14DAVFkbUFR41omYc JmMcJlNxmCz21abqba0RNQM0GQM0mQrQZALQcFbWTD1flQlAw+pQR8OjkeNdMhWgyeLEVgcV asg4JibjmJhMjYnJBGHJWB1UhCUThAVpFVHHWQNRSxBMhUUhapdHjagZgck4DCZTEZgsCdSm 6m2tETVHyGQcIZOpETJZIqORRa2er8oEpQnm0rAYOfVLpqI0WZLa6qDevJNxiEvGKUcyNcQl 4xAXdFSJRm2PZNRFY694n2GDQLhM8sJUWBTeZ9ggEC5jTCZjTCZTMZlMQmMq9RTeZ7g4EC5j zCbjs0iZitlkaWy8wsdUQqWRNQRtOGTqhkOWGu8zrOm2zPZg1YQwGQMtWB21V5UgAy3YbGqv ahAZaMky1/sMwyRO/Syv8T7NjURazpGgQc6RLAsVBoX32SDnSMYHlTJOrJup226ZXEa0MOdI xoEuGQe6ZGqgS2ZuJKK+VKGVTKAVxgYzFVrJMjGgHTUQDh8v9j7zjsoj13no3mcucmcLqsIz GcMz1Wp0UjaUnAImU1GaLBeRsdFRw2EyPm6UyRykxnVkeWIMLtGo0srZ+0RaxXjlTYyXhLtU WBTGK29ivBiTyRiTyVRMJu90tHoK45UvNl45YzYZn0bKVcwml2iYjDyAXI2GyTuyhmCPRMWj 8o5E8cJrvS2xZQBzNRImZ6Al53uLchVoyRloyTvSXr0tGdM4UbxhDK5sADOFbrxyiW0JtKwj QYOsI7nAMoGadSRokHUk57AXbMn3xE+lkYv4FhmvnGNfcg52yNXYl9y3jnXmKrSS+7LbHjGN KjdJqIvrSM14hQ12XHMJjanyyHUeqvHKGZ7JGXrJVXgmF3gmXLzjmjNKk3OeiVxFaXJGaXJG cnI1xCXnEJecvapcPW+Uc4hLFguNKq2AdxxyN5eHGK/cTeWhG69cEsRUWBjjVeWhGq+cMZmc MZlcxWTyINXqMcarUo9uvBizyfk4Uq6uePMgN0aFek21o3xkCe3lQ+pnlUaunILXalsYbxED mKtJYXIGWnK+wChXgZacgRZs9mMqodLEzMe9csoPoSfyXD+1nkuWl0A7tR40OLWeCyoTqKfW gwan1nOOlsGW0Oer4grlhrCFtkvy73Laj1zNApNH1rHOXAVW8kgCdtm+qUlgcrnAKMt125U3 sV2SJKbKI9d56CrGwEzOATK5CszkAszkDWwX4zM53/Kcq/hMzslesJeoe1SR8XmjPGT7pp43 ygVgSVirVYAlF4AFaRXbFTe4Li+XDL0VFoXtihtcl5cz/oKt+Z44qjSRVk9hu+LF1+XlDM/k vB7PVXgmF3iGExfnKjyTMzyTc26VXD2GlRM88y9qmN6W3LZ/KsaQc3RLzrlgcjW6JWdsBZv9 mEqoNDzTUUSJtWrMgggWjbFuuxJJphVpG66VTIk11ksS9FbTIGZ6tkXdfjEUg635njiqNJIB e+Gma86ADDIlburwsy9AylU8Jk9kw11oVNkJHpMHasRIHjSIGMkFkKnyyHUeugFjQCZnQCZX AZmcg2Sq1aiqxMBLzsBLrgIveSoyY8OjAi85Ay95wkZOTRSTp+J7JtrlQ/h0IXqZS96YCosC vUwaXD6UM3aTc5BMrmI3uWTrrTZVb6uOXuaM7eScrTdXg2jyLDD+6EMy7SpNaCOcNTQsRsZj chWPyRmPEYQzV6NgcoZicgYAchWKyRmKyWSuUrGYPJPbAzJtTwKfLha1QDUVFkbUFR41ouYj Sdga+mS16ySDb7WpeltrRM1QDVb3PXFUaUIzfT+kTlRpIksd6mh4NHJKmFzFaPI8sdVBxWhy jn7JOQY819EGjn7J+IKiXM35kksOXqRVRJ032JPwOwLCVHgUss4bbEoAEx5vDMMgT50qUJur t1cXNzDhKESskuvSPBx4LKOSRm6u4k9AFNt6UUckKZc5OAYL6WSppRtYSqfKhBnNd1hKJ2M7 ya4/llKpBI4h8ln50+MGCiCBMlUuRgOqbOpUgFEbatT3zFYnC/U21zS6TgsY1qFauTbN7MJj GbA0qJG3TpVYulJPJZcP8IVIWEony1x1UTEaeJwLt4hFrEbR+B0BaPiEOZbSqYwIA+3COXrc QBEksqbKpVSEoMGlc0AlAzSQAaoiPfA40ttc0+g6ReA4G6qVa9OMMjw2gzhnGaswFjxOHX2p oxIRM3CDpXSy3FUYFbzxO4ze0Jc85mI6mbg0CVOpUTPwOLCo9FkMiMwYDLXYYHq8cK0KVJHK xaxWZ9ioy1WgEgGGIkA17gYeJ2ptZs1arU1dtAKRjOFQRKLuUsLjzCwoua9rupGNdNxhZVHx ML8TSbQwEuiNYphHlsBYQKcS+xrKHKtiPfBYRh9njMFiOpnYz8gJHE6SJOykQUdfxwK1mnxb z72tL2SBh558O1OZ6CtZYCJyjESOKvoDj7UE3PpMEclg5bQzWFQlk6y/xh6rSBBQcQQ434CM hXQqcYeiTF3WRtniZS0wCVUmuc5EXdcCE9GGWGZT9cgUPBYAL1u4tgVaMbixTIMq+gOPRZCc lRWL6WRicSOZLdUQHXicG/PNVLoMTS4aJNfMX9wgvBi4+CqX0vzFDSKMgY0M60TcJjVzMDwO 1dpK8xcvjjMGLiLnROSsHqyCx7ExSI+5lE4lEg4DtlsqpgZkqbF/cY3DwChRYUdVnAgeywBN ZNJVoSK/I3c2dRKZTdU1O5DxwahO6kR/pGmIJyd8/cQqUEsSxY62C1HJ3Vpn/0wym466EVFN AFtj/1IRZCqCVMEjeCy59xZuRwCpSDOV8arCSPDYPp2KpXQqnj9pd5oK6VSyek1j1f6lcRP7 J2hRlUmuM6mxf5nRBplbVcAIHotzFTewf5JxuJOJF6weJYLHRpBislT4CB6Lk5SKmVQRJHhc erlMpgtRMtcQvWYAswZBIkCVqVxKA5g1iBMBKhnXmUy8av5hv5N31NpKA5gtjhYBLiLoTASt Rv/A48BYpMdcSqcSEceyplDhOCCLjAHManoyj11LqgJL8FikayAGFVuCxzKl5gIeqPASPJYp NXcTwQV5lMZpmNaZwNwka9fOX1RSwNaYQF8gp2qC10xlUmMC/Y6IUjAnX8ecfElXHC48iAGk ckGNIEu+jiz5HfuMK5bSqRha4rQJWEinMquaWA2Ko+eLjaDfSXU2eQ0b3Qz6Ak75nCAH2epk MmLjxdFxvi/Zi31OhoOFdTJfyHja9uu4ibckHp6vg0y+byCIjpDpkvRlBev7WrgJPV5sB30/ VrkUdrDKRreDPoNQ1Kjvma1Olqq1FXawUptuB30BqXxfJK2DVL4BqcJA+lG1zX4gPldGG7DY BJ1MQlCQQG9WEDgW1VcDieCxDFROb4zFdDK5eI/PTWExnSwWbm44SpgnfhYENYHAQG5Sv6uG MG9kCCWGqJotNlOZ1BlCQaN8QaN8HY3y5YapvIEhFEQKOTNHfcyG9nlZLKVT8TZbLoZQjSyC x2Z9k6lBKvS8gSEsMKlMjVOZYVOjh4JJ+YJJ+Tom5YcyIWeLo1WAOBWesfBUp2U/FGmaIadj Tz5jT6S8TKaPzEhGJudcxGI6mVnLhu59ywW25jfAj32Tj6fCpcSPXTY1+LEvCJYfyTSsI1h+ FOltrml0DX7sRyLqSESthiXB46SYURjs09XY4FIGZq4jEyFHMmTVwCR4nDs4s69jUn4swzUS XdBBKT8WhymWuVNHpfzYXIoaq7rgx410QWCpKpdCFyps6nRBgClfgClfB6b8ONbbXNPoOl0Q zMoXzMrXMSvfYFahz7OUeg4OHmeOytSSyUjmyCQsppIlHVdldLTFT8SP4hgmLKaTyUSbicro qJNvUCek13QhCZrogrlcvMKl1AWXTZ0uJDJSExmpOizlS77lmTbXNLpOF+SqcT8Rc60GOMFj Gcmx6IJ6UA4e567K1JAJeOUnMvHq4JWf+q7KqJmV4XEg3BiG8dWAJXgs9taXGUfN7AOPjRQj Lb6RHjdwltNY5VI6y1GDGEdgIyNV0CpfR6v8NFVrK53laHGkI3ARGacy9HQ4y0/NskjcTTW6 CVxokbHP2z2+vt3jZ4WzHNVoaGbGsHjdahogeCzizcRZ1oEoX4Ao/IrHXEwnk0GYuc5yksdQ Iu10apzlTE2CrudAr3OWTb5lPd9fNQl6jbOciSwzkaW+Q+pnWiJ0vUdykWcmY1aNdAIy37jf j7mUTsXAUyDumg48+bkxy74aEEnPGzjLeaSzyWvY1DjLgl75Akv5Onrl52Z9uzgyEojF+uZi fXUMyxcMyxeoy1ejpOCxTLFmttMDfQJJEeTHpvdVSQYdcZaRXjGE+HixIQwkFqrKpTCEVTa6 IQwEswoEswp0zCroRGpthSGs1KYbwoAxLaqUK1MlHZiAqYx9kEAPmAo6IuOI/aNAB/CCjgR/ I0FNs3LHogZ6tFQgSFTAl21hMZ1M7rzuSOt1DQ0EiQp8JxAcVCtJEtzO1A1hIOFPlXSYeuLO GkMYCGxVTamZqUxqDGHgiyx9kaV67A0eS8rnhVeZAWkqHGPhqI7ZwLePCmMpnYp3cvnGWyyk UkkGZ1o1q4YwbLKHHpjwqSqbvIaNbggDQa8CgaUCHb0KDHoVNthGDwTDCjibCRbWyYw0efYO 9CioQKKgAnH1AvVkGzw2vq8h0yUZmEvs3ewxhSF0s8fUGcIgV7mUhrDCpsYQCmYVCGYV6JhV EPpqbaUhdGurMYShSDoUSevL/CAMC8P0mIvpZCLjjhhCHcALCJT6F7explmJa1HV9ETwWAYq 39yFxXSyTMhM62ualQtZ5qQg9PEW2iSMazzCQDIPVVJr6klA6wyhwFbV9JyZyqTOEEpcFTbo e2aqk3GC9nRhSgUgFXlGMmbVNEXw2D52jKV0Ko5N5UwWWEinMgudvMYQ5o0MoaQzmmGT17Cp MYSCWwUSSxXouFVgcKu8iSEU9Crg+7qwsE5mpCmztw66BLG4TaHYS/WYHDw2iyIZAjr8FBj4 KXAvKy8MoXtZeZ0hlGzTVS6lIaywqTGEgk4FsUzDekRVEGdqbaUhdGursTgCXgWCRAQ6eBUU 4FVH+lE3zgJeBZwsCJugkwXGEMY1YzoJXYuqwy2BhEMFiTjPejhUIMATfsVjLqaTyeRKkUel IYxiWBwnnTCtMYSJyRCuxRRVkoHWGULJRl1N9ZnpGUXrOk1kmYgs9QCrQNJOx4tjigLBqZDz 91xUJ7PPMGMpncpEW4jjqMNUgYGp0CXSLCE+b2AJDU5VZZPXsKmxhIJTBYJTBTpOFaQyZoMG kUWBwFGBwFGBDkcFAkcFxnbpcFQgcFSQiMFUcyUBmXGRU+1iLnq8GAkOskDlUiLBaYPLuYCN DG+JrQp0SCvIIr3NNY2uQYIDgbyCTFZKeuxVILFX6DQ/5DlDJ0tdwLiOTIQsOFWg41SBBE8Z wDjQg6cCwagCAUACHaMKJDrKN7OiDlIFuYEucnWHCB830AUDYlW4FLpQYVOnC7nY8FycLTW5 EjyO9TbXNLpOFwTEwlq5Nn08G/gqFURCx/ECA1+JytSSyUjOxTDr8FXY6bgqo8NXocRNBXK4 IdRhl7Ajmwd89xcW08lEikiv6AI+XqwLoYGnKlwKXaiwqdGFUPCpUPCpUMenQhN0VW1zTaNr dCEU/Crkm+CRrU4mIznnAR/qCF1oQCxRmToycxm8hFOFOogVGhBLVCbUp5JQQKxQAnVDPZwq lHAqhA+YrKZtRoq+OkeEfpM5IjThVBUupS74TeaIUMKpsFHcA+pIDU04VbXNNY2u0wWJpwol nirUUa1Q4qlQwR5yx6pkEk9VqEwdmS+VsnsV6qfVwiBwVUaHpUKBpUJOkY/FdDKxt5ywAYvp ZEaKgXa7Iz1uoAtBonIpdSFocMMjUMlIDWSk6nhWaPCsaptrGl2nC3LsD2vl2nRzLYBVKKh1 qEN2Yei7KlNHJkIWRCrUEakwDF2V0RGpUBCpMBDjr6ZxgsfGM+oIWU3bEoesZpoLQzMU1bSr 9HjxKjoMM5VLsYqustFX0aGgWmEoQtTjq0JBsaq1FavosEECVuAiMpajfaG+JRwapKoj3a0j VaHETwV8GSw2QSczYemhnosVKGJnOR7qCFUooVGhRFCFOkQVSmhUyLmYsJhOJpY0csLSYRXT ibI4D2r2VcJITW2vZ7avWUWHsZ7aPlOZ1KyiQ8GpQsGpQh2nCmMtvb0+ygSrCjmjExbVySKz Ln/MpXQqOWqQRUKmy7TEogJ9FR0HDVbRodx+NsMmr2Gjr6JDiaQKY5ld9dN/YQFGBYtX0aFA UmEss6IOSYUCSYWc+RiL6WRifmW/KtTjqULBpcKOjAEdlwpNwBTSa5YwaRKXHiaxyqW0hEmT uPRQYK0wEUdKTc+N93WotZWWMGkQlx5KOFUoh/xC/SxgaKCqQPxWHaoKJZwq5KSG2ASdzITa AIHeLImkKkyqDlGFAlGFqUzCOkQVyuG9MJHZVYcAwlRWM6kTahNkQQf0J6rJ8Qrkkqm0o4Xa VDIk11lCky2qo4baVNMs11hCwalCwalCHacKJZ13Z3GoTShYVZjKmNWxqjBzTl+H+mG+UMKn fN8XMl2mmYEp0ly3hGnexBIaLKrKJq9hU6OIgkWFgkWFOhYVZgZ2zBtYQkGkwky8Y/0YWyiI VJiJ7dIRqVAQqVA2rEIdkQrz0vtlMl2UkiCK6DVLmDeJtQkNYFXhUlrCvEmsTSjn/cJcJmI1 1zc8jtTaSkuYN4i1CSWqKpSoqlCPqgoNIBXLfK4DUqEAUmiEH3L362Qm1gYIapqVuyZVx6Ii waJCgz/oWFQkWFQoWFSkY1GRYFFRx026GMQ5uIVZXdBh1DF3I2ixNpV0yzWWMBJkqppMOVOZ 1FjCSHCpSHCpSMelIrmELVwcaxMJ9hQJ9hTp2FPUcc5hR/p5vshAT5IyJNLjpyKTbQp9Is0S 4vPFljAy6aaqbPIaNroljAS6iiTdVKRDV5FAV9XKdD3zI+EZCE+9830jTp6/Iz10KhIEKhJn L9IRqMg34EQkZLoofVnXRr4abBP5TYJtIj9XuRSWsMpGt4SRAFQR5w1HtjqZr9ZWWMJKbbol jAS/iiSsKtLxq8jgV6HYEh2/igS/QiP8kLtfJzPBNkBQ06zEMamRHksVCfYUcS5xLKaTZUIW SutrmpULmRNsE8KaO02itObKPD8KzUULqiXMG1lCiZyqpmbOVCZ1llBgqkhgqkiHqSK50S1v YAkFqkLOzLGGzDmOHelIVWQCqOR4caQHUEUFUpXp0Tb4vIElLKCqTI+2qbKpsYQCVUUCVUU6 VBXJUcBqZbolFEQqEkQq0hGpKDLilDGnI1KRIFKRwImRfqIvkripkLObYjGdzKxrQ/eu8wJy ixtAy1GUqFxKaNllUwMtR4JqRZKIKtJRrSjK9DbXNLoGWo4ksCqSwKpID6yKJLAKpxRGAHU1 NlCVQaDryETIsYxZPaQqMjCVGdo6TBVJSJXJoBXpOFUkOFUoIaiRjlNFBqeKYlUXoriRLhiY qsKl0IUKmzpdEJgqEpgq0mGqKM71Ntc0uk4XBMCKBMCKdAArMgBWGPM0pZ9pjAyAJSpTSyYj WSKmIh3AiiSwqlAZHXiJJLAqksCqSA+sigwClYnK6AhUZBAopNd0IUma6EKSqVxKXXDZ1OmC IFSRBFNFOkIVSWbzmTbXNLpOFyTQKpJAq0gPtIpSM5JFF/QzjZGBscIFZCJkyUEV6TBWlMau yqg5zP1IIqUiiQKL9EipSCKlIl9mHD0BVZQaKUZqRGYUNYnIjNJc5VJ6y1GTiMxIYKtIYKtI h60iE2JVqa30lqMGEZmRwFqRHPeLdFgrysy6SPxNPYQqysyKiLeAIn0LKMoKbzmqcfwEkSrc bj0zVSRYVJSJt6xjUZFgUfgV3Hrd0goWFWWutxz7SSeJM78mIjPK1esG9NsG6rxlk9lcv+ev et1ATaflIstcZKlvnEa5duWAPhglWiqSaKlIj5aK5C46ydkR6dhTZLAnyUER6dhTlBu77OsR mfi8gbecZzqbvIZNjbcsAFYkyFSkA1hxx6xwG0RkxgJjRZKKKtZhrNjAWIJ2xXpIVSxH+iKZ 7mI9EijuRIUxZzJVlHFHvGWkVywhPl5sCWMTMlXhUljCKhvdEsYCW8UCW8U6bBV3MrW2whJW atMtYSywVizn/WId1opNRJWczI31iKpYIqrQCD/k7tfJTGw6EOjNEkTKmNRYD6aKBYuK+XI7 LKaTxUImrdexqFiwqNh3YtPDpNMJ4yDrRLoljCU6qpLxVU9QW2MJYwGuqlljM5VJjSWMJXAK G8S9ocvSZEvPFlrCWIKnYomEifXgqThwDmTHOvYUBybkIhAyXaYm5Tmum1VLGDXZVY9NbFWV TV7DRreEsQBYsSBTsQ5gxQbAihrsqscCY8WSsSbWYaxYYKxY0K5YD5GKJUQqFmcv1s/0xaHx foVMT0QVh7ILFLsJgwpL6OYLqrOEJlFVhUtpCStsaiyhwFaxwFaxDlvFYazWVlpCt7YaSyiw ViwH/mJ9oR+HaWGZuB916yznAtEIP+Tu18lyYwnDmj4QRKowqXpyqliwqJivysNiOlkgZNJ6 HYuKBYuKKQypsIRRJ4flup938hpLKNmmKrlf9VS1dZZQgKtq/thMZVJnCSXaChvEvaHLUi7H c6vSdUwirmLJLBTryajiyDmRHevQUyzQUyBpRGI9F1Usd+WRT6RZwrjTyBKaXFVVNnkNmxpL KNBVLBFWsQ5dxQJdVSvT1VEArJgvyMPCOpmIU1LNxjruEsuhvjgSg6kf6osNApXKGNARqNgg UEivWcI4a2IJTRr1CpfSElbY1FgBAaiwUd8zW50sUGsrLaFbW40lFPwqFjAi1vGr2OBXcjY3 1vGrWPCrWLI6xfrpx5jwq39xG2ualbomVUdcYomOiiUnVaxHR8WCPeFXcOv1Zkl0VExhSGV8 UQqmMQyjOpcwLdLea/FF1UyzdaYwDVQuxhbOJKytMYaCVGGjvme2Opm53mBxjFEscBWyZpb6 uE2dY9mxjlbFqQm7EPdRR6tig1ahX6Raw6BJjFFs4Koqm7yGTY01FLgqFrgq1uGqWHKmVyvT R6+gUrGgUrGOSsWZkafYLx2VigWVilMxmnquqjgzfnKq3YRHjxcDwnGWqFxKQDhtcBsesJEh LlFWsY5sxSaperXNNY2uAYRjQb5iSaoe61FYsURhoef8kOcNncx3ceM6MhGywFWxDlfFEkZl cONYD6OKBaqKDQyiQ1WxxElFZmbUsao4NwBGrm4U4eMGumCgrAqXQhcqbOp0Qc79YaO4B2r6 M9fbXNPoGl1IBMrCWrk2dTwnBsRKBZfQ0bzEgFiiMrVkLORE8lIlOoiVCIhlVCbRQaxEAqgS OfmQ6OBLIomnTGr2RE88lZhs6Uiv6AI+XqwLiQGpKlwKXaiwqdGFRFCqRFCqREepEhN8VW1z TaPrdEFQLKz1e2ark5mRzAM+0XG6xEBZojK1ZCzkRMKqEh3KSvzYVRkdykoEykokbjfRw6oS Casy2akTPawqMWFVlVR/Rbf6TeaIxIRVVXMThjqbOl2QsKpEwqoSPawqMWFV1TbXNLpOFySu KpG4qkTHtpLAjGQe8IkeMJUEkasydWQiZLmuL9GPsyVB4qqMjk0lgk0lck9mogdXJQaVktQR iY5KJSYTFdJruhA0uU81CTsql1IXgiY3qiYCamGjvme2Olmgt7mm0XW6IOcCsVauTTfXoRnJ MuB13C4JY1dl6shEyAJLJToslYSpqzI6LJUILJVIuqpET1eVhMYzioRMb5tgU4asbpozidMT PSlu0igpbmISpyc1SXGrbPSVdCLQViKJ0xM9zCoxidOTmqS4SZOkuIkcDkzk1F+i7wwnBq7q SHfrcFUiYVQx376MTdDJTHx6UpMUN5EIKbMkT3SYKhGYKpFAqkSHqRKJkEokm1SiH+ZLJEIq iZ349CjsBEGahjUr6cSkSK9cH1Bz40HNSjqJa248yHQ2NSvpROCqROCqRIerEnOrX7Y4MjMR zCqRRFSJjlklJk26Mc46ZpXI4b4wy4RMF2wJSiX6UjpOGiylE3O5X5VNXsNGX0onElWVyOV+ iX4sMDGoVKUyXdkEm0rkDr9Ex6aSxAiUl0+JHluVSGxVIjtXiR5blQhAlUhS1EQHqBITPIX0 mjlMmgSpJ0mucinNYdIkSD0RfCuR3DiJnkw9MYBWpbbSHCYNgtQTCa1K5Ohfop8QTAxgJfdx JDpglQhglUgix0QH+pLUhN0AQU2zEteu6jhVIjhVImmqEh2nSuREXyIppRIdB0gk81SSOmE3 cSfJowz88BpzmJlcrr4WdlNNRl1nDos8Vb4aeDOT07rGHApelQheleh4VWJyq/uLQ28SAa2Q NbOsIXMPaCf6Cb9E4qkiPxYyXbDmpj9E1lRzmIVNzKFBpaps8ho2NeZQUKlEUKlER6WS3Phe YQNzKNhUIjf6JfrJtiQ3AhUDpmNTiWBTiWxfJTo2leSlH8xkuixN0qkkV2NvkrxJ7E1ioKsK l9Ic5k1ibxI5AphISvVET6memDCrSm2lOcwbxN4kEmWVSJRVokdZpQaakitpEh2aSgWaQkv8 kLtfJzOxN0CgNis1qJTY1VRHpVJBpVJBIlIdlUoFlUoFlUp1VCoVVCrtOLE3MDF3kg5M+bo5 TA1IVUkTXZPZusYcpgakqiabznQ2NeYwFZAqFZAq1UGq1Nz1Fy6Ov0kFiUoFiUr14Z367int VD/mlxokSpKLpHpQVeqbpU+ihyLi88XmMDUpqqps8ho2ujlMBcnCVnEXqDY8FSSrWllNf2XC MxGe6hSdSjxVKsevUz2eKhVAKhW3L9UBqTQwWAUP41SPpUoDWeamgRqAkwZNAnDSIFS5FOaw ykY3h6ngVakkVk/1PFapibWq1FaYw0ptujlMBc5KJdQq1eGs1MBZkiY31eGsVOAstMQPuft1 MhOAk9b1Qdhx7Gqqx1elAkWlklo91aGoNAyEjCfFVI8LSgVqQnLLHGZZmOdpltbEZKfmYr9K suia/NZ15tCEU1VTTmc6mzpzKMBVKsBVqgNXqbnxL29gDgW9QtbMUh+35to/Oaqd6uhVatAr OXqc6pFVaYFe5XoUDj5vYA4L+CrXo3CqbGrMocBXqcBXqQ5fpXJKsFqZrpOCUqWCUqU6SpUK SpWagaejVKmgVKlAjKl+2C+NDBKZC5kuy8gsc0NnB71AbsO8Adycxh2VSwk3u2xq4OZUkK5U 0lalOtKVmoCraptrGl0DN6cScJVKwFWqB1ylEnCF88pD7lCdLHZR6ToyEbLc7pfqoVapga3M 4NZhq1RgK5NvK9Vhq1Rgq0RiU1MdtkoNbIX0ii7g4wa6YFCrCpdCFyps6nRBUKtUUKtUR61S czlgtc01ja7TBcGzUsGzUh3PSg2eFfLNmql+3DE1eJaoTC2ZjGSJpEp1PCtNMldldBwmlYCr VAKuUj3gKjWAVC4qowNSqQGkkF7ThbTTRBdMhFWFS6kLLps6XRDAKpUIq1QHrFKTdb3a5ppG 1+mCBF+lEnyV6sFXaWpGsuiCftwxNahWuIBMhCx5qlId1UrT3FUZPZ96KtFTqUSGpXr0VJoZ n0pmHD1JVWoSpqeRGqmZRk0iNVOTw6rCpXSZoyaRmqkgWKkgWKmOYKUm7KpSW+kyRw0iNVMB uFI5CZjqAFeamcWROJ16WFUqBwbRW3/IU7ROVrjMkR6pmeZmDIvvreetSgWVSuVSwFRHpVJB pfArHv//7P3pdhtHljCK9t/iU0TRtgxIIASAEyBZrqJISGKZUxOkJ1mNLwEkybQAJJwJcHCV +/e99y3uWmet817nKe7Pu6cYMjOSg+1SubuEZYtAZsyxY0+xB67mLyaHsJNhmTvrbYz3VBb0 Y1PHocplFShJhFDGMpvA6S2v1XohEUIJyyy+gpsSOH3Tf5+62fEmQvDDmVhRbYoV1abfimpT J/+TmB6bflVUW6uiJEbFpl8V1dbJ/1CC9rHM+Pxulrmts//lm+mUNONnmduiz2qLoqrt12e1 tT6reQ9TzbZotdoSrKrt12q1RavVFuVX229r1RaPv02heW2/iVC70TYYnYt597LdEJYZy3vQ IT6+Gx22tS1VrhWDDvPN+NFhWzRYbdFgtUvWs9ny9mbQYa43Pzpsi4KrLe6Abb+Cq91cM+jp CVfzF9NiEXNJbb8+r93UhutQoGRYmxm82vZbWbVFK9WW1IBtv1aqLVopnAWP3j8s0Uq1mxnD dYxY3m61Ws22Hx+2tdlULj5sSUjbEnzY1kqsfJTZtr+ZEnzYFqsqHNR/cbP+YjraeutOfNgW 06q22Mm0/aZVbZ0DULy2235dVLulLTI2pJh/Z3XMdBShvfhw7T737W1tepVvplPSTAk+FIVW WzRVbb9Cq60VWmv3uG9vi1qrLXFt2n61VntVbyiT8rbfgqotFlRt4fvafr+/9qpmhHUx/16u ytVQOxtWyODDbFShMnyow1nlWrH4MNdMCT4UFVZbVFhtvwqrvdrx9mbxYba3EnwoGq62OAW2 /TJ/e61p8NMTruYvJnvcEHzoV+i1SUP13zzGkmGtZRGrP4RVW9RSbckQ2ParpdqilsJZ8OhL hrUpxTYy+HAd83G3GhurJfhQx6TKRYktCWxbhg+1Fisfa7btb6YMH4pBFg6KV8S/nzoLYLYz /yKLVVZbghC1/XGr2joVoFjAtP26qLZ2/pOQI21/3Kq2TgXYbvjxYbtxL3yo41rlm+mUNFOC D0WX1RYTrLZfl9UWXVa+M/9ZEY1WW1L+tf0arbaEp2pLYNq2XxHTFu+/9pqgTb/3X1urpNpy EvwqqbZWSWF5Hz7caN0HH+rw67lWLD7MNVOCD0VjhYP6L27WX2zD25vFh9neSvChKLTaop1o +xVaba3QEi/etl+h1RaFVlsiQLX9bpJtUmj9N4/RP6zNZhax+lUwbbGeakv8qrbfeqotyiic xROu5i8mNJbMlCw+3FwDOXt1c7PExbutU/7lYsWWhLctw4ebG95WDD7Mh7ctwYeiu8JB8Yr4 91PHWN+42wCpLQosbJqb9B9cnRBQTGDafgVWu61tMoSN9Cuw2lqBhfyRFx+u3scAqa01WPlm OiXNlOBD0WC1RYPV9muw2mKDle+sZIZCpEVR1fYrqtqiqGprDOZXVLVFUdXeFLTpj2zVbmt+ ue1NwYeP79YRtzsNbytWR9y+Twq+tii72mKC1fYru9o6Cnt+zCWDLtERt0UZ1pYo7G2/iVZb TLSQg2ZFnR+liPugUSWXFZNNFvVV26++aov6SquS234bq7ZortpaKeLXXLVFc7WpaaNfc9Vp aHVGx3t3hI/vhoWOVmzlWjGwkGumBBY64h6Ig/ovbtZfbNU/5pJBl8BCRxRb2Cv35j3PHW2o 1RYthV+319GGWgIypcU2pdN16dS7yZ1GOwMyHb9KqyOmVR1xkOj4VTEdMa3Sodw7/ihVHR1c Hct7YAEf3wMWtMoq14qBhVwzZbAgOquO6Kw6fp1Vp7nmH3PJoMtgQXRa2Cv35mW3Ok19kvnA d/xYvaMVWwIypcXa0umGdOrf5GYnCzJ+xVZHFFsdMert+M2tOmJupYNZd/zmVh2tqcoFBjTL 2roPjehoc6t8JMNVfzNlsCCKrI6YW3X85lYdbW6VH3PJoMtgQXRcHbG36vh1XB3RcSGAPeKF 9RdrZ0GmrJhssuT96/i93jqrjSzI+HVUHdFRdSTnZsdvdNXR2imJMNHxa6c6OmoVlvfBwup9 0rR2tBFWrhULC6v3SdPaEeUWDuq/uFl/sQ3/mEsGXQYLYoWFvXJvfnQt2quOaLI7fv1dRwyw DMiUFBP1VEfUUx2/eqqz1syCjF891RH1VEdCW3X8oa06YkDVFhepjt+AqrO2lilWRuZ0mPWO P4Ru514hdDs6zHqnJIRuvhm/LN0RFVdHwqx3/JZXHa3S6pSE0O3cJ4RuR3wIO2t6V/wHWaus Gnq5/esoKqu2JHnu+HV9nXVtvN4pCaHbEUWVFso7fkVVRxRVHbGt6vgVVR0xmupI4KmO3+Gv I0ZTnfWM8Tr+Xt9owccvS3d0RPVctoGSBAklsnRnvSRBQtvfTIks3RGNVUc0Vh2/xqqjMwK2 7zbX7IjaqiNBqzp+tVVHR1XX2NmvtuqI/99GpyXF/Dtr9VINvyy90biHLN3ReQHzzXRKmvHL 0h2xtOpIXsCO33OwYxRTjbtl6Y6opzqS/q/jV091RD3VkeDVHb+9VUfsrTpyhdXx21t1REfV kRCqHb+OqqMNqrC8Dx9u3sd6vbO56m3F4sPN+1ivd0TF1ZEYOh1/7PWOVmnlerP4cPMe1usd MbfqiHdgx+9E2NEqK0nf0fGrrDqisupI1MeOX9fX2dSmOFDAPyxRVBnE6ldUdURR1ZFwVh2/ oqojHn8dCT3V8SsCOuLx12lnTHFamJCxsdZurpfgQ53+LxdPuiQEdhk+NAGtmn5bnHwI7BJ8 KBqrjmisOn6NVUfHYm/ebYvTEbUVNs1N+g+uTg6oORS/A2BHjKw2mx0p5t9ZnRwQdWtefNje vA8+1HqpfDOdkmZK8KHopTqil+r49VKdjua+Nu+BD0U71ZEkgB2/41tHtFMdCWHd8WunOqKd 6sgVVsevnep0LCfMxfx7qaNTdTpeW5xO5x62OK2GVl7lWrH4sHMPWxxoRg45R2DHZv3FWt7e LD7s3G2LA63QTlOn3Jlvp+HxmsFPT7iav5js8aYIHl4tHxTTtjhQoGRYmy5ixRr+Ym0Z/bqM 3re98LgjxdZk9P5hsV6Kirv4kAJfNNbW/fwhVDO5Lry2OLkI1n58CK20vK1YfLh2D1scaEb2 syn76dVTwWMdFPROWxwouy5NrkqTvoMLjzNe3FjNX0yUURyGBKv5i2npZ8Nvm4jP78SH0EzH 30ynpBkvPgSKKJDBwaywWX8xObkbd9smQuEWt8khq7Cyv5je0E1eL69xFdJsKdaQYv69bGl1 hZxjr10VPGZJl8oX8SE9vgc+bG16W9H4sNBMCT5sySHnOOzYrL9Yx9ubxof53krw4arsdEt2 2qvRgmJNg5+ecDV/MWHEOm1GY17dHRQTWxwsUDKsNRexYg1/MTmqqy0evVcbBY83pFhTRl8y rE0plrHFaYEE2F5vrbX8sYCguMl44cWHuTjWpTPueFsx+DAfDrsEH67Jfq7KfnqVV1BMAsA2 7oEP1+TgrsnB9Wqw4HHGjRur+YsJZW0IPvRaWcFjLf10/LY4+Pwe+NCosDp+W5x8MyX4cE0g Y03orleFBY+F++rcbYsDhYVIs6YKK3uLrcuG6pPn1VRBsabsu6BNrw8gPJYDyhFXsZq/mJZ0 1zK36EZ7u7Z6t8oZWlnztmJVztlm/CpnaEYO+brQY6+2Cx5v+MdcMmi/yrnVWJetXpet9ppd weO2ISysGfSDsVZfac10SbEN2eR1ObVegyso1nQ101jNX0wO7LrAgldzhcaFgmOFhHo1V/B4 TejMhg8W6PE9YEEUV/lWNCzkmymDhQ3B5Ky4wmb9xTb9Yy4ZdBksbAgl3hBK7FVpweOOOVSP eGG9xbRKi0GmvJic5A0Rh7wqLXjcyoKMVxUDj4WdYrMrrOYvJvS2IyDj1UnBY72Lm2teWNhc uw8sbG54W7GwkG2mDBY25aRuykn16qzgcds/5pJBl8HCpqDrTUHXXgusVqMtJ3lDYMHrBQnF mlmQKSsmm9wW0utVbMHj1SzIeEOvtxpt4ZnZOgyr+YsJvm0JxfFGsYLHehfXffaa9PgePHN7 09uK5ZnX72GvCc3ISW3LSfXqsOBxx9ub5ZnX77bXbDU6ssdtOXpeFRcU08pL4Tq9plXwWMtF 6wwK3qshKGZ45nWvvSaU0GdYmG9vYCt4LNvbEZ7Zq5eCx4JpO3r0fkzbkUPYyfLMa6322urG 2mYZz6wjVeUyEJQkTSjjmU2Q9Zbffj2fNMHPMzcbsp8d2U/vpSoU8yZN8C5yk02pqOn/4rr+ YquGDX/C1fzFhGfm2BVYzV9MY+eW116Tnt/NMzcbG/5mOiXN+HnmJqu0aFS8BF703NQqrdbd 9ppQuCNtbkqbXiTcFMVWU/RfTa/BVavZFEorRK9Z0mmzZVA6F/PvZZN5ZirvwYf4+G582Gyu eVsx+DDfjB8fNkWH1RQdVtOvw2o2N7y9GXyY682PD5tN2emm7LRfxdXU9lbszIvV/MWE0K4z m9T0a/SaLbFfxwL+YbWaGcTa9JpawWM5qpxMEKv5i61KMRm9Xy/VFL1Us5WxX29trm9srq41 2/4QSVBc54rLhpEtiXxbgg+brQ1vKxYf5iLfluDDluxnS/bT6z4Ij3Vk9o278WFLDm5LDq7X vqrV1EkD2ZEbq/mLabMMllyafm1Uc7Wlqb33zp2e3wMfiv1VoZlOSTMl+HBVIEN0VU2/Squp VVrrd9+5Q+ENaXNN2vQS6aYotpqi/2p6zahaTTajIhjmYv4Duqo5YV3Mv5drDcEt2XBDBh9m ow2V4UMJc5VvxeLDXDMl+FB0WE3RYTX9Oqzm2qq3N4sPs72V4MM12ek12Wm/0N9cWzf46QlX 8xeTPW4KPvRr9JqkovpvHmPJsNpZxOoNbQWP5ahySkGs5i0meimcBY/ePyzRSzXJVMngw1XU Jq5iNvUSfGiSA2bjyJaEvi3Dh1qNlY9G2/Y3U4YP12U/12U/vVZZ8Fiyj2U7Kykrm7ouB9cb zwoeZxy5sZq/mBi5toWR8cazgscdTe39+LDZvBc+3Gj4m+mUNFOCDzc0ZAjd9SuzmhuaPN8H H24IkeYUgVjZX0xvqNByvyamuSFM1LqgTa8TIDwWSaktJ8Gvk2pqnRSW9+HDjY374EOJ0p5v xeLDXDMl+HBDDvmG0GOvFVarudnw9mbxYba3EnwoGq2mqCeafo1W02i0RBjya7SaotFqcmQo HIK/2JrGhxslS7m5nkWsfh1Mc1OO6qaw0l4LKngsNHZTj75kWEJjyVTJ4sPVVme1BWyPP/4F FDdh9b02SLmgtWX4UIdpz4ejbfubKcOHbdnPTdlPr1UWPNYJFO60QYKysqltObh+DVZTJw9s iyjm12A1xQewsyFspF+D1dQaLOSPvPhw9R42SNDMpr+ZTkkzJfhQVFhNUWE1/SqsZltO7urd NkitpmiqmqKpavo1Vc2ObKjGYH5NVVM0Vc1NQZveiFfwWPPLbV+6Pnp8t5K42VnztmKVxO17 pOuDZuSQd+T0+rVdzc6Gf8wlgy5REjdFG9bsiOTktdJqNTttw0E/YsrhL9bJ6pL9xVqivmqK +qrpV1+1Gs2MLrnlN7Nqac2VKEVafs1VS9tRCW1s+TVXrYbsIpb3wAI+vhsWWlqxlWvFwEKu mRJYaLGPIA2KV6BkPTf9Yy4ZdAkstESxhb1yb97z3NK2Wm3WUrT8ur2WttUSkCkt1pROGTW3 /Hih1WxlQKblV2m1xLiqxV4SWM1fTNippsCCN3AVPNa72PReHuHje8CCVlnlWrGw0LzP5VFL dFYt0Vm1/DqrlphlFcZcMugyWBCdFvbKvXnZrZaYXSGAPeKF9RdrZkGmrBhvcksMrlp+xVar tZoFGb9iqyWKrRbb9WI1fzHBt6sCMn6Dq5Y2uMoFCzTL2roPjWhpg6t8fMNVfzNlsCAGVy0x uGr5Da5a2uAqP+aSQZfBglhctcTiquXXcbVW5SQ35cD7Talaq60syJQVk03mHIFYzV9sLQsy fh1VS3RULc7PidX8xYRz5jATWM1fTO/iqi+lKz2+Byystr2tWFhYvUdKVyglJ3VVTqpfudXS yq38mEsGXQYLa7LJq3L2vD6E8FifZDnwfv1da201CzJlxWSTRT3V8qunWmvrWZDxq6daop5q rQny98a5gseaM2pJsZKx0VEUsPIrqFri4icw5W9HtFOCg/xDYtXUqtAs/+zWW9lhl5Bddu9j fWjLf4HbYi2S1hGUDJvWXJQ9fkVfi1VH+soK+sJCj+PFXPCK6OvwiUCXqObwiQCSWIfhE4EZ MQTDJwIeouXCJwIJYniFT2TTRW2FT4SeooYKHyXhfJFMny/9svQfHz//kz+jeBJE0/5gEY1H YfJ0HA2ephcB7PPTaDocL0Zh+vQ399GAz+bmOv2FT/4vfW8CtVlfW28AFMJzzDSx+R/rv8P8 7vws0nmQQJdJHM9vK3fX+/zk/od87rH/L7+uX/ymPnA9NjbWSvd/fa2Z2390fdn8jw+yiP/m +//0qXq5dXDQPe6dbB2fLMHP7Xh2k0TnF/NnCv1uaup1MI6jtKZ2p8M6FtiLhuE0DVfOonH4 TO3tbncPel18sbWYX8TJM7UbXMaJ6tXVThTMhxfvI1UZybe/nlNj9WE8qS6ZvrsHO0tLTx/b rlVliJ6bjXa2d/X4KRaDfgBq59EwGI9v1Hk4DZNgHo6gv1hN47kKR9H8z1h26ZPobDoKz1S/ //Lr/pv+7sH23ulOd6ffX/oEHkfT0PMGKjHkqy/S+SiazusXXy4tzW9mIba0gAft/lwRxQZS 7D5fbfU1JQcq+Uk4HUVnf3T6eI/zz79/Aw644/yvNlY3Cud/o9H6eP4/wOePc/7tWWWAKzuv vrf2zC4jtVpeMuV7b7ao9FbvTb+3+31XrbbsYRau++U4Hr5/29x499y+SufJYjhXfwdm1xzt N2/b757LA8QBg8XZWZi8TaOfw/isQq1UqQA+Me/7+Mt5Oo/nwVge/qJkNgCEc3j5HNHgX9Us ARQ2hCfqPI5H/LKSLakep1VkxOHzQv1wGYyjUcU8+X/+X/+3Sle+dPpXX6iNNect1+gnwfQc Wl758k1NNWpqs3pLEW6Nym3wHcdfEcUu8ZCT8KdFlIRpttokPa81auNwutLUTfvbh5pQUNqF Zi/jaCRrA7SARCS96o+xUb2Y0HTNvoFWoAHvgCrpnGV0BbC7wOfpPLtC/8//+/+rGkvZMWIZ u1+Ky7BMlBljP5pGQLQKWzQvDsfd0XlhUXIdPsEJQq//l2pcn+U+t66nu/AssZl5lw7A0z/O 94d4jKvnPq/ywEQ2za7EYjZCwPWsRU3dvpF3rRWBXAmgMfysNg1cukMCRBClF/4h5WGnHJZH UJy6oGGULTzgDQvIOBBoX49jFiRpWDE9juySDC+CBMeTlIFvZgzQurp9EMmwfDXSi/iqwh2O PJsCdaHa/wzm5ePnN3/K+b9xOJkE6W8U/ehzp/y3vlqQ/1trqx/5vw/w+ePwf4j1CObUYppG 59Nw1A+mI/VM/XAWJyDpKcBQ4XmYqOvnhUc3z1VDffFCXatHj/jbjXrx4kv+WoGn6sbgQn8/ rd/WkfRhXjm/b3TH/+qt9n7Kz7+IfcPf3sft57+5urneyp//DdIX/vau7/58PP9/mPOvvkmC 2QxO2TAGSW4eA/+nrqL5hZpfhGo7uZnN4zFynEbjI9KdGqDopc4W0+E8iqf1JVb9ZCVCV6uT RNNz1OpkND0A+oVnWvtjG6Ou6sNl95lWkDidLGvquXwrOxcSP8dMuqJrFV+xNF4kw9ApiNgE udhoqIizm4STIeyaZS0VtZxn7ZQ0pHnuaZXkW/kVYctPnwJyjOOZugySKADWdapW8A0I5ygV b7/c34ZSvf2tvb29w8MjqP9JOE5DeAaIUlUiEEYbz1UE4uYU/jx5UqUSxEvi/HBYb6N3eJdE Q4Hv2OsvS+6N0v0XzLMO/TScF9ZB//5VU79tatk5hZ65yPCi6Ri1EZriID1RvW8qmd/X3CJX Vn3CyXPEzelVMFttVa6rt7U4jqfn/E/vm421iuf5dbW8eaghzZcvfjS1kk0ZqF5AkU3v3gSj EWlI8tI8TKRmVSyPL3ARsAP7aIJ38frn42o0fZ55H4tWJrOZKB8xWqioi7eq8a6Gf5r8p8V/ VvnPGv9Z5z8b/GfznRGMa7hRE2yjqr827deW/bpqv67Zr+v264b9uvmuWuigbV93zNem7bZp u23abpu226bttrnudAB4dhiPx+FwTpg0Xsxni7nT/aP4LS4Q/Gnynxb/WX2XLbTGj9f5zwb/ 2XynRMNAjJV7gNp0gAgSsvijcKKaDrJgdFIo0vbhE9gqOnmxIBI4fQDCecWMR/CHL4IB8OvK l29gBbCv642g0Qk3NjZPn7svm/xyMNjYDML2evZli1+uDjfCs9XNVvblKr8M1tfOztZXg+zL NX653myE663Ns+zLdX7ZGTTWN9rtYfblBr9snrVXR51gkH25Kc0OwsZw1Oy4L12F1wtWZckb R+tDL2AdPXod/1IWKU1etcOHGrFcEiLDiRSA1aaZgVUBYoojdZSnEYFacchPXhiFVHSmKqg1 +0K60ngaTsHuGR6AJFRRyhdF03hxfoGcxiR4H6pAXV3E45DxBgw/uAwJDMfQW8JKtAKMY09C JvDjgXVLLS1wF6AbB0/wnYHu7Fq8La7ME4J+WGyC/6VClcLi/KJwCIJiaak85UFu0oumly2N J6ECAAhw6YJxEgajG9hOwidaMbyAhucXwVydRUk6X5L6mjd5dNdcAJ0Q1Miu6RWFZzgBfqof 0qrbh/LUkJhM4zVzMKTNX8q30mwjv4mm+l25ctW75bC9BIMvEG3hly9pp7HKSgbLAcQBF80A +6U5E3yVkMd1uBVbI6CkII/GBMkuvKbqLIkn9DSaAn6n3SqsDJ/L7HqYNc70/txcyJhZmXXP F7SD1Gv7VPXw9OBoeJOA41aDmznwCxmooYMwDa+BMkUTXhENMLlNpJGzlrgEzF/oHfylgLxY A1yGvAzaAsrIgJ9FZ3D6J9E0mMNQEa+yP0y2yCwYGXyawVT8wwFUg4b0ClwFsHUL1DHM1VW8 GI/UBS7dIIS1vgimo3E40icuj8d9GOEJYgQ7YurzV+FcQaVSFwiwH5FOPzd4NJ0FKF2cjRfp BXIZUAawhUwTdTkoas8BzU7DKxVPzXYTz54ZAlq/FYZUw1V28MPSPc98Obw0NCt72/IwRC39 6pHi8nK7RZ68ysPzMOuDaL4dLwDzIO9brFekgI8B1SwVAGSdGAXT2JdfKvYxzZXazJdiK8Nc qXahVMNTqpMvxcbI2VIbjXwptiTPlWrmSzU9o99o5Ut5Br+x6hailboXuSiDGz7Jh4sEzmh6 gdiNlBZwAgATr60gqlNBkgQ3iPCAwVhtrQzogCejVI2j9yEdjmfczF7vpQL5Qf1DteD/Jvzf UO/Ufu8ldZOnU4Ur7acGwEQmqlrGu8hq3KP6c/XkSWRZgMeO9FXBc/1ErT2G9y9Q1jBcZ/Su apCvg3sL8l759a0y+DeHqFPeMJelfyQXglnu9BFK+xlKkSUA9B57cSTpJboLG0Xn0bw/j/sX 4bXRH8D3Pr1wqYItnqLNAKzCcqPZWl1b39hsAys+BJK5bLCnaQGFnI2qlr6lunlLwgtxZlLg 8798bqRxfXH7A/yzGHNL6h//ML9fvFBiqWtl7iV3CjAr6oVv/YYPn4yn9Gmx+NbL7Z3uq+UC DSwoVpobK169ChxuV7GC6ydDQzb3hRrirHX38sgsaZRVvtCFOUsxcMC61zOQflNVaQGU5Q9A leYVDIFopoi0Z7Cu4XSOZzrQGkY85Mi5wHKSDvQE6DcqfpDIRvEUwMxSbiKDNLnCUSMOqP6g O+FkmFdV+Za00FOJ6ipfLnPS9SiA1+1fRDX6O46FgPJDaCkDUTC8txGsaeud8GW4abroC9oE s0MrbIMuzZa2BNilmW8Ni3taY/2bVr/pfr/4Qq2hhYIefhYsnuc1BPe4D/9QG4BTaT2GyaBR TwYj0eq8I5orSyNlnxCJ9JV9hOtlUXLJ9VP5/Q9A6nwniS7D5LfeAd1x/7vRahTt/5rNtY/3 Px/g88e5/8levMT5u5jCnY1z7bIkZxNK9YHwV1wEig+zB9gwcCJ7QwE6W+rzHxqfV5ECidCk 6covREN60WQGxfFYqBGdCzrcKMkJkbD3UoMbc1+FxAKrDIMUaHgAMtM8eA+iHUrrz/CtGsKB rQN7Mq+fx5dPZ4vBGG3/gKqkT8+iGf/TbDdWWvYb3orB9KbQYwzUPqzPRmc0SDSJ1l074xFL OiRUtJDqHMYPrBcKZVhtliBJYmkdeQosApNCFLoIb7kSCImuhqOstRG1BXPO7EMa0uVclrpd gFQbJo6W2X1JfFwOG+sOq0vEw2A5YfDziPVxC1Cja60Jgy8UekcWX0tKW4KiFZjDNbr8p4Gf H0t5UYQsWF+EQBh71aD/Hxn9/4iUrdEAIgC8+Y9PXsB3jfj9XCyU/7GGVaqaiN1WLgKS8yOV xG16UeR84R0ZbKqc4arIuStESfAMOBOsaNbkcVVUR3zCcH7IK6UswBL8nFWWf5g+Bv4KpXyE oLmGe1ZN9RgC1GfpD9NlaIp/0oh1fWPy+VkK4sUPU1wbKMpgwl05u4OEWwttPBTbknRiZPh7 VlMawJ5x59yM2woCd/weta7hZDiZ2SOAbdU8zOUL0TNk1ohQgowRWvuLWj4K0jQcLatnavlV AHhptCx7SVgofk9oCDtHel1BBobPgG72eDGdyrHFFaS1v4SRxQlrBmFCy9mpXszns2dPn94f /Sybg6qWb0VFha6OgvMwfaZWV1fWGvzSXcmmFqdpVTKw8rLedI6wXuvmWwTVv+ONTFCDfzfb +G9zA/8dnOG/bfq30cR/h/Q9pJJrTeffBv47CvHf9RH+G9D3Vov+XbWzzX2oG6rcWMV/N6i5 gL53aBDNTRoWddkZUvk1ek61zs5srTPqrEHPm+vUzkj9gotHS0NodBlWAeBk+YdlkMh+WMav 8AX+mPWoos0Rwkj5OrY869gy69ii4bVpFTYCO7wRD48mtUqrPKB/QxrqkIbdorcdmn6DJrtK 67hBb1c7t64jr9oqVQtpEOsdqrxmV6pFQ9mgNT2jzkIuT8Md8cpSrdHADnfYzK+jgoVsLS9l h8CrOkJRF6Vd+O8c/ruA/4AHin6E/97Df2P4bwL/TeG/GP6bwX8/wVbkGlPqVzeWb8rs0T32 dlXTwnga7kfjMTzdAnmezavePcdqoxgVtUCOzkMm9OH1PAkU66nkyXT0Zw+QrBogGdJ6D2kf NvjY0D50aO2bvGO0Ax0Cmzafi6atFfJzKjnadEBl81YgOaMm2gRPHT7HBIUBNdShhlp8IKm5 Bj3fGDH8UfdDO4gmtdaiJ6MGA0nGECSvcBM66S5u1V76Fe6KGmSwj8KeryJX0po5VzT0lQYp lwXEzM6SuPt58DmBd+EFM7cZ9LGKOOOLpppwSbX1efolUh6nroW4VeWCHIrg8fuqQ762gMXE hlM1I5pV/2G6Ay3VNdYnPZYtfkJFz4im1Q3yF7r2ZyZs/2op6N/345P/o/NpALsT/nbPb/4g Gnqg//cG+v999P/+539u3f99kFRRyv+Nfdyh/8G4pwX9T2tt46P+5wN8Tg6PXtTrT+uolGa9 yqcVeFZ9Onn/FGTvs+h8aenk9ckLAIyehot6sBSMx8+w5OuT6tLS3u7LbU2usbEhPiGrl8Me P0knUOGwh8+7e69syXB8hs92XvaOutvybDRYSYEQLS2Jf2d/Z/e490J7I0OntvHq0+zjbefB DxmOgl5D1/ka3HPm6bfdg/6b7tZO97hXXfKuymQGZ2Jp6fDl33ovPq3Mgnm6GABTBnLU08/q wxqdJfgW17KD+LQCZ2keJit4hfZZnbQz0RAqwJsrqDIMkhE18rg+rFahb15fXGfsqrr0p08r pN8ZTka1reOqSoYw3r+adhV1+el/Qc0lHoM5yfUY5Eps2j4ZSplJPOoD5Tcl9O+hbgRafabn Bn1tHW+/6b/ZgcWBH3qLXu3udWmA/wkP97+CHQMGaaaogcywt7ex2vbR0au9rdfUxLZ8W4HG v1ArMcxoaal+9Obw4LtnZOoyHIfBdIn+fbb0p5VPK8f7UDo5E/DjTmiAVt9Vf0pPV+ZxPE5h PWc3Q3RU/USt/K6fpaWj7/onh4d7vRfZHifvWWUBHefGwn7FKbxYWsqMGZb3Ardat1jNAE8W LJ9eh9OnQTK8WLlub+CPFaj8kPJ3l6ZChQ3NjDizsUffncCWVXEPP32cg8qLGgNl2R3Ex8+/ 7nMr/f+dQgA9nP/DLJSNj/zfB/jcb/8t2fg17qB38H+N1dW8/ycGGmt+5P8+wEcbefZ2Xx9s nZwed/tvbOwM5xmpnocX4fB93wBDwbQHrSSMbQ/+wLuCmle1U3BN0o2a+ubJXY3IPR9rrqv/ YyLv/DE+t55/JPe/Qx+/Qv7fXN1sfsT/H+Bz5/4beeDX93E7/sdYT5t5/N9sfvT//SAfbU6B RhcDkFBcEwvHA9ZjnGFCJfX7UKjZoqho+ttz5+3CvF7Y1+TuG4PAOw4vw7GKZyhT4KWj+vvf /96k4G0ZR8clYwQ9iOb9IRrxWrvoq2HGdfJqiDZgG0VvySWcoYpHI7rV3ljrzx/nvC4r1+gI 9kg1q+rP2g3K00SU9n8Ok9gdwVT8TLlVMTlxHgBNUi8U2otjWWMb8Bwe/fkFvUZNf+IaPz6m Vw1j8nYWjNOcj6kCcTJ0TNrC+T9vYI8T4xlmOlug/cOdnRkvV1b9s69dM2Me1+Q7EBqCaxKX mDsN17Q4SLHFWzp2f1x7R5E1zIOZlnV9bZyUoXfdKkDD8J7d33i7t4diqKd394hM7wkWS7TT o31+g89vzPMhevWwCQf1BZAUoWXkjVxdyQzNaaiq4XMaz1ChqSEnRHKALVNQ7BGo31H4wNXQ FQd68g/enYeuhVlvto6pVOyiDHBN3Ae4Siu3rBJaCdHQqRI/wxBUvGjVam7ZBmLKrY7pd0qH Fk/4NXrTjcM0Rb+5qbqhAJeEYMbhT+ULen0reKkX5iCLgVskaIQXbmUlssa1CNz4FtfJ4Bl6 +IVZOx+2gcmwS8+1mgQ3KhhHQYrWNnMVX4bJOJjN0BYFZgfjWsxmcULxOW0kquRe4KKGQZLc +M6yKYDAioWe/7o1MA1dR85Rt3vOlISDzEMR9ECp6rMF5SODGJ6i3VOMMHANsgj5RgIEQ+fD CzVZoJQST+foDTS/iobsGDddTAZhgq587BUSpArGXLXLNFmM74viPBCBblqAnSPYm59DGAxF 0hjHVyvQGXSLN/91KGZPEx8P48fmLk6DFqehj5ge049igp21cnNO64/WiWTEuMhFRtewHzDc tz9qc29c9x9zZw2oDw5pZBESQySWxW4KxZfEXcvFKHlCU4ZQblmCLHzYxnHaUXFdbl+WGnac XxyAOZj8k/wiRZ5Fih6ySp7CGmpB+lcNBja6sO8DTN6Cd25BNcburtHcGI+vl2uwWHDKeNDe M2iMw7xVcHgix+PZ2o9HizGI+UECUDwJkR/zsYx8bEBieQB5dn/MYHBKjB6wCa4J5W+YH0QH FETN/HwGr6pVIn6m4KxqGSQcyAMoY9lAMu3LQKoqM7yZjt3xWG0Ra4RoCENRPVUtVYFxQAkH r8C4LoLx2T0pzMzikzPCAojXgYnWxiHATl9XDd86ZaRsh3fNw8OXiPfNwyH8y1utfdILRRqm iMOH23M6CdL3lOuxcf0q9znd23tuHLzMpJNwdE+645m/APFQfYn5Pux0eSwDB2f8GvQIqzvB RUvCSQiEAgNbp0xPhnD8z5N4Mesz4pYKzjKoHJM3RIwxA4yhEcaAca/D4CA6ARanMgFZh5fx FhQ8sO3A84FwOVydv2uEYyijU7vidjxEVmtgGCRnTc2SEtNaOFMu949b+Wtpo2djjdAkHVZ/ BS+xJHt4FCaw2xMA4+hsjm4ArS++ABA9i8dAedkxAIBwIXGqsNLfnf00LA2TNljhptnDPHFx wArLoqHYjyyzwogcwDIbCn9WbHO/mN1uvLOgq8wxMYs/tMfXOvdjGALgZa4jIU2WWDJI5qil d46Ne8zslgOTPwG5sWQLJD96zsiTDPjDzyRTu3gOkh/t2wKQQxdyLp7Yc1HNL/ftyytLbGJC PITQpLcIDOXnQY6APlGm9WuDt420DyVYFZjrxyyJu+y631tepre+jKaXt70f3fZydtvLi9te zsPJzAioyI2zz7jom3C62pVAU6kLolIj2kKmkBfqixVk6IBws7xAItEZnP+0wFlcYNUMNhHN htmItEgi0e8coy9cRfCIQyoQb4/qmSYjFaOacVFalivGE5FFaz/m0NqPeVYXajCQC74zx3mC /orNPZSVfsy/Y5/Ronj+Hp+PxKmxaSXSCL1kRBNkTzuU/gccOCiPDo+knyPB7Dm+dJGTHAWe N26nOSymhwoMCY69cHQYrPO9PHjxwo18UzgU3FzqnFjelkyjL/KN/vlejSK859vVdfIwQVDq 4gxm/ZaU5f6SAHcE2L8bRdxfHV/esMPXjLzQFlP22hjRq5fk4ZKyqDoI1ShC3+ahWJqHAUix McIcCqlX4XiMf69rukFq4hCg/ArYc2BZ5k0YZItfzlsCnfADmsKoNFj8qcurX96KUhx8EpS+ uil9k8cG9k15a4PyIQwklpVsihJkG9SUbF+enQjoaa74AIrfmOLuUR0wqJIWCCPzzUIU7Izq V87qn7UGWpoz/DfjIObOLX9u3/OzP1vaEri1c9gQOg4syUOQGtifyAzOTewlRaUTpziBYOJU SKSG/m1n92f5aqml5YoHiE4HwAoFWlY2VBAWMTAUFoomVDbBwkngnDeHbg5wQ7Ik1+0FUVFO DBkQgh9IBdMLyU+wWQbp0APby8yiXIqyxROs5s7yQODjlyy4wcdRKA3Uf6FtvpbjSLWEwpyy R6hIlRXUPzAKpo01J/oI1GeHtrTOfgh+QEdvlqcaM2CMNJJHxEEUGrmt8kBXRue/8mIwbBpo 93oWT0HsuaXoTHGLR0k0CXHOi/EiLZRnOF6ikieAJeMkSG70bLm0IUDzJuuPnmcetvRD9+kA UJQtrHGWwAdh7gExaRrvMb11OCaDuge6Ak3dVNHiu9qPp/PzeBLCqD36DdnvKTIk4S3ie+IV 308Odw6fIYUIE+ZtMJSbmsbTFcQkqG2cR+jhTPBSZ35GSs9E5K+7HEQJe+S96uDFhR1xlpeb h5KWc/HwLZmC2AIy3jMUjaqo3ahnuDEmpg1D8PPXSwWdn1lBVFkIb5N5Qeo9iqWw+srhIRCp Ehm2mBNkNhaz4M8/tBKPpQPmVn6sGmyZEYQsO8jDnxmclp/YMEv7s1yCZxV8jAKr/CLtSIpf guQcWkYzmseP8cdlTs93xTvdypyUa3sgchSPVTbXOqLmahYIZrbeTBfpNLNlEgdKNMPUzMkl juerhMFRjtMpKTKbBEFqyfW9Ffcje4iajorht7RoBx+mb1uMKGTY6Bdc6IP8+JSnj5Z4Jd/e yx3Yy3246kNp17egtGvCUNcZlDZfzYwei3hHb1soXfkMA4xrc627nBX7ID/msm7usU5hOZyG DKihgdT1PTNCB2nLCMMC3JXu4F2Dc0PR/Ktt1e5t//Mb8oDcZf9ZzP/Rarbw/e83zfLPv739 D9t/7h/udL896m8b40/z4P6WJc+XPnKkBY70D26Peuf5dzyGfm0ft5//Jhp7Fs7/+trH/K8f 4uNLd3FXWgxv+gwxCrThmQzhwFwZC0IyO92Xp6+XdLRk/mUrjAYr4/ic0mjIxa/c+GVtxTmM C+CZt00MNbqk/g48JoeaIMd+/t4gDbGOBdHo2IAU7Q1+wyEEOETIxrpE8+A6FD6g0bLvG+vy pmHDC7Qavzxns3iW6fuD6LyPAw/gK8b5K0OV6vFVzTLXA3qXM4cfeG3GUPDA4upLZskf65AB j6+MHGKj47FaA6MLz+I5xjOkS8V5HKsx8Pih1k7kmKKrnOAksQkGJDk5wRllwGaGwD6OwmsS lp5y/NVCmYEpM+DLLYxYpKP4Xb2VJt7RXaWRnQZvB/o5iFCVNkwaxvWZamsrqxw/5fgpjMIh BsIKR+UeCwBFxt8AvpOnQX4vHuDUYD/5IIK3ezf44pNxpCN+NAtoaOfzC4zr5NZUK2ZI8FWm AN9WTYQdHSRUwkKQMirTwhe2hSemhSdqNQ9RLbPeeeCwwyvE7zRdvcW4jmxrxmEcjdisx6fD Q5prsGz9xjtjgWEfNulhM/sQe7JDepdRwOd6M/1wMCdVeWSbWc02U1MELLJA1d+nVbvimHaE AE1vxt09yMbwK3tRt5hiEGKNgiI3sKjFQJgh0oBiMiwCYUaP82NWoAwns+e2KLTc51j30pAJ RZ2HE3mfARLR6HDMSgaA7O0vZf740VbgyJe6U0QijynRyI90W04xT3h4pvUvv3yhMZLWglA4 P9kSdRkm0ZnEvAJhLR6GaUrB9Jp19TW+u+G0BuxgpN6HNwqDInBM2AnGNQxTdXK0Tw+wXquu jjCsa6FGhJGgNadINydcINTcJpsEptjIal3tMAKzoM3xY/HtWl1tx5NZoJ8hNwxDv4xG4YgH JqFmtQ0MogKKNdvnPvswqD4OClYkE6ePkgcQejOwIyM2AKMfcKxzXZQBS0+Fg5NJBV1+kYbG ti6yGRcIZXNYbv4BY5NXNCbMD2DCH7FmdJqmY9ifBgILbMESpyYAOEqHwfSswpNQy0c015Wv wptnqvIZ+Q5Uf5ju83CefYbR1x5xZ/CFhsCB/CSFCOIW52LF7btR79Tbse2+ZADSlem8vM9i rxk2ieF57/B1ZfktRkgIEwDbd4pDxdHu5yFOwxl+Z2zzTGEWAQVDAQZggXZGHICOY2Vnsjho JEaZJIAgD03UdO80VaMhM3MWsVh3FDukIQMUcEQzUEXmb/dZADpoIzPZ8HoYhiBRToLraLKY EACiuPnZiGaa7eN5Nr1GLkzxL+W7+tnFxfVnQ56wtPjWnc6TJ5gbCcHWrojK73Hr99vje29s ySTzW4W6ZScxCQYYxyttytMBPz5/9jlyiVAss56wTu4ilEOLFq6fqc/G4wXHsWOk4Tt8hSV6 yAKFpqt7rlBmfYrcpdaOvNx9fXC6T4GeK81Ga+3pxlr1f4yLLF9gG5xtW5G4oHZyFPmt8UuG /Fu2+l7FNUjcq7DerltKL1nCpJue2aHTXrSdpnMUCIsKFRLZqdhIVZOhMEmED4dvUMNLPyv8 u+YZjcUOpl94lJ9j450Be+xGc32/BexNrE+ppeOYWh/pIsTLZH+xtg1FgdZuRy23rxinr7DG vjVRjjXE7R3kwbKWk3wU9mlZI/OpZpT4bot5yPX1kdud/DwF72V4bN/GF7uyAyGVYHZ3aZd2 dB07rGdyt0AsMQMhMMX45Yvb4BdLWI6ZGv+s0brGULqZlJNVzwmCqtoCX6oyMGmdjAGYciHb aGhqJqOOflLNizl3CdK+xS2fOd+j5+84cz5DRIY4qCXqdxqtxmpjrbGObsgN1gl1GkFj0Bg2 Ro2wcXZ2ZnAUIh3Onvi2TUkPHAwjd90uYHDRmhK61/KrVnTYRypczQhH1qmitayOjnev28Bq Ldf0GCK7UblLpvvfK/n0vxys6/eK/vfr4v8111c/+v9/gM8t+y+R/X97H3fc/7U2N/Lx/5qb zc3Vj/r/D/Ax2R5UBRjDVqPRWfFkfcCQr1QqRXUT8h+j+tLScYhmokk0WJDqBBUamAMymkp2 Z3oyiKZog4WCMrRGpqAxOyMCFlsCHG50LzWyS51h6ro5UkGjzyDtC3pMshsFJ9sC9MbGUVBp aRLOn7EeGZ1s3VGlKP3JcChDF1m4AgkLJA9hMIgv8ZUsg5AjjmVe4wx2Y2gPm3E7RcvWzIig 0+E4iCZhUi8bCV5z2tXQI4FpjhbiEkqDWdKcu96ZBw9GK8rMkHTSxVE8JOEn0Bv2FPaCDXsn mOQ0CsapWXdpxWRgdydj5ngQRlSdHFqDCQnbLujA4O1L2gzqzsxxyk1ilHp0JB6EilhHYGqB gMXI1kJ9GNEknmNQYVwqAEJAVdGlGaEkvoTFSeOz+RVCkcCXwkiSCGBIHxHsEgStKQMZ8KA0 kZM3uz3VO3x18s3WcVfB96Pjw693d7o76uV36uRNV20fHn13vPv6zYl6c7iHIfLU1sEOPD04 Od59eXpyeNxbWt7qQc1lerF18J3qfnt03O311OGx2t0/2tuFxqD1462Dk91uD1aG4ibuHrwG vvD0RB0cnizt7e7vnkCxk8MadVqspg5fqf3u8fYb+Ln1cndv9+Q76u/V7skB9vXq8HhpSx1t HZ/sbp/ubR2ro9Pjo8NeV+G0dnZ723tbu/vdnTr0Dj2q7tfdgxNMF7C3l53l0uE3B91jHLo7 RfWyq/Z2t17udbEjmuTO7nF3+wRnY79tw8LB8PZqSxhYcxe+wFp0YS5bx9/VpM1e9z9PoRC8 VDtb+1uvYWqVO1YEtmT79Li7j0OGZeidvuyd7J6cnnTV68PDHVrnXvf4a6BYvefAtfZosU57 3drSztbJFnUMTcBKwWv4/vK0t0trtntw0j0+Pj062cXghW8Ov4FVgTFuQdUdWtzDA5wqwEj3 8Pg7bBTXgNa+pr5504Xnx7ietFJbuAQ9WLHtE7cY9AcLeLJk56gOuq/3dl93D7a7+PYQW/lm t9etwlbt9rDALnULmw99ntKUcYtgVEv01QHYGm2k2n2ltna+3sVhS2HY+t6ugAkt2fYbWe66 wxbeQv9/p+i/d9L/ZjH+T3Nzo/nx/v9DfD7JpH/65I7sT5+UJH/65MG5nz5xUz/dMwhxz4qF L8jvqR4DORwIvGaiEvdyYYl1YOJMUGF4WB4/+IGBgJ2OMCbqAKRAGF14iZpG+gJLMK3HLKfh q/MkmM7782Awxui8AdlZw5cf8vIwiM5JiNaZZzG8xizJ8OdsHKTYyCScwL9oj7HCEjD+CvFK /zLyN3cNo1laclcNVywYjUCKPouuOZru05qEHH5IzGFvtOA7AgR/CsCRQHvVXxMkuNBh75/c ocDcM1kk+Sl9bB9x8Fsop2MV50IV9yRWsS+88b/s/N+C/3+n6K+/Lv4fEICP8v8H+Nxn/3+r Qujh+99qYkzYj/v/z/88ZP+FSD3YEvwO/q+xvlGw/14F3uMj//cBPpiAMpcA9O4MoOUpQH9N DtBsElA2R+/3JcVDf6sHgt1J/02/by5fvS9NYEAA0f7ZYjyusFmJaEmyqSXJHGfpT39S+ceL 6bDGpinQEV3USJ/cMF7nshOn6QWf1GBIyHD0+/Tt9GAb5Un+tQeCZr9fNVbgf7Ag+A85/1B2 OB//7ucfjvxaIf735kf97wf5/OHP/87h/vbJXsn5d1661ugCr5gY4zJMSM2XMVfHBBcamL/0 VLy4mYUJSgcllu8iS8HY8TIPhDCQuMhi8HQ6C1AFHig+V/Vc8FjELAsu0+cSsCzxJBqhXQX+ 5Zs/GF+fx4cuovFkEkzJN557qjySR+TjKdeH8oitouVHHWSbwoXqC4VyrSycjIWH4taEgYbJ WTAM+7KA+ZqkOHu1td3tfw2gA9jOrS1Ty/VLE3xuL5DffHeEKrve4bFM1kxMrnFhQXdCWPT4 RgVTFV5TTIrzW5Z2xKX/NUubWR4ZyX0W9rcs68MXNbNoROlEW/BT/wIKjcMku2pMDfE9W3R+ oPXLD+qDLKEutKjnu6/jDyiKfx6w2H9kxy/5PIT+izbrd+f/N1vrHv5/7SP9/wCfPzz9p2uq Xgn9d14+hP7fQedN/qsviQYdHJ50nzmxdFPRya6gTlbNgnO+6I7lHhRIVFoncoTJ4ft8aCqk LCQtLvsDVZ/nA8tjjcE4Hr7n5N7q7x4skw4vwlE/nlV622+6O4dHfaoAyLb6XJHh04MRzsPO Pymxf+/z39zYKPh/rjYaH/M/fIjP/4Dzf7L95qD0/JuX/5zzn31IZ7mPcdOmoacOnU7CGnSW o+mImAhywlpt9ZmNqsldUB+DoiMuwL+ADUyVWabKjKrgy6toPO4T5rmzicV0EC/gLxpG9Oex 4ejwd03pX/P4vg2ZBmbB+M46xJ4xWrmtXhKiSQf9cm1Ac40DegvGfeliSeQn7KaSLahLMEML o6Ct8hdir8hhGF2GUsy6tkWTMF54Ylq6H2NBO45BGiEfKFXsKH2L1plFFH8ThePRQ1A8VTAo /vdmKR+C//nW8eGBQO7A/2sNT/63jcZH/u9DfP7w+P/V3lbvqxL0b98t+eIYYOPd63kSYFZ7 thITELYp7rrb29BIrw8C5G1n3nyaxaogd27t3qN2q6xq686qq8Wqb77ev9eA14pV9/dP71V1 vVj1uNs7PD3e7t5VdaNYtfdma+fwm7t73SxWZVO1uz/tYtXXaDx3j6odz4C726fHaD11x6fZ KNbd/Xr7rmpc1wNPeJNwr7qlAPXydBftFG+ru2qvNvjm4ri7tXNXjxgAg1n2071c9W9gpe4a taneKlTfhu7vqm+qrxWqd7+FvbqjvqneLlQ/Pj3Y6t1a2VZvNqC6qZ9Z736fvtzRvbt2vur7 3a3e6XF3p6Q6rh0xEoTK+mhBG14D0xH302hk+UZmS/haa5Kes+8/vQHhcyRcEDeRIosW65Yq bsGyNrgJp41giF7zTvcpqg7Nzzn+LDBVFI59A18PoZHUKZ+EP/mL88ACjqbvTmoUDtFm+dZa i1E0p6q1/NNROM0HEM5UTcOfpnF2xufhfBaGSeTjRIur7e5YEgbz8Palcn7ml+bxNLySNgvr D1s5mY3v03bpsv/R41V9/Py+n4fw/67J4kOkgDv4/1W09crrfzY/5v/8IJ8/PP9PDFz/BB0P SqSAfIlfowlCQ9qCPicD7yBO5AR/EN1nfVFjcNHLpkW9fOf4XDQSWNRprsLfw+k8uelfElq/ DGo5zQJqljGeqDSymE4C3QhfS6UV9xfFE6DHb9/VFFnDPA5Go4R+ipPqNNMW6iSC5Fc02cg0 6FNk26Em4VlO/2SeE8U50w3jAuQ6f3xhk3GIf3p2iXAwlIjFfVq9pCj059M5rHU/MxL038Vw Q39X9Ys4nfepPka5h793OCLXVB1I7XnKv16o1wcn+1tHfWoG+ri7NnSvf2Fa1bO7a2C+BFMD 1+6OKr/oOAIVmtcjdbT1utvfBxlZB5PS0S06FIKHHcod3ZMDoaiBginCqTo8yq5hTT2KZzXJ g5iNWpANJUBxsmd13k31hVPAPHWKIQwtUmwIuu2d9OP3wY1bgd+TB/VjDIOWaSMTo0NA053M GSom03E8TyuqcPSgiHNE+AUcu9sXuwDGdER0I/j0ziaKV0B0ENxxA+JQ5SPOjcDfm9X3jvDw 8VnjCyyHFSTQ9jfARxC7hD7e1dHorY+oqX4xSurUNt+hP/eXOkvQK/AFnMz4PSBBSYMZJv3J 2bQi4zh6812PEwVOBpVqSUPYHZ/AFzxcNhIp4p7MxidheO8FlKkWcXNI8c8f6UHpcAB25eAt lFn50oxRAza/faQqr09e9TEETTQ9/wd+R09E+F6tZiPOUHKOfj+9mQ77mAKkP+QoX/0AAfgq mFUeZTuqKfnTcJpqFc6ENT/M0f+H8H/OdcmDeIy79L+bzeL9/9rmxkf+7wN8/vD8H5GnbfjO 3J+87/V7R3u7wPb1PAxhtspDDQO9N3/mai/7eHZxk47CS08j6YSvS/pIp1gV3VwKr+chHElE UpkrnxDQVQI0lnlD+qotBegRoESpSlxPvip6eCO9zl9j2Wr5Hs9mC+gsfZ9eRbAlFeFRy7s5 h25G4WBxnoTnFb4/Oy9vXVYFh8Tkxj4or5TepGhAleXvbqsgFlfYw+NbC8Je4FDQck1vCcV+ pRwhGK7xtn05H81zY3pMFK2Pfvh8MYuUIsJg/6XtzDEmjKx1TohI81x/mN62SPpykGzbJyOM Vf7XKZDIvz5+qvnz5Jadubic/IbaqQcK8sO/DMaLsLyJxWwUgLgEVGWYRLN5nOTWY1KQgjBC fHl7ILfFQKbjWSauEU/uHjOinDdI0QRQ8auzs9Okj09u2dqMRUBmabnBW+ESAFKwUL7arYOG PcT4WencM+fMkznQa4TxW7YzDc8nFO0qSMO7trSsnekkymyAnNx8MzwnCm1624i092yeG5Ud ogXXy3QWROM0OAsNWws4BKrfMlaBv8sAZZqZDZVheslP3QmaOw2voOI4Py/iv8p3C/1LYuBE o9husgl4qrXr6TwpbyErlZUOOAdCi8wOmB5vAashEAUXgsnwFx5Gps0QL1P7sJEpif0UiNZt zj1Zk4UsNgy4Yn8h5kXtvrsGDhaKOKz5gtXZ8j5rxl2+udALXoXQGlVgSRfDuTLP8Cze2uuv 7LQAUX0yBGS+eunXQ5RnBMLDY9IJy/9gxokS3v4+n4fw/6Qk+xV93M7/N1utQvynVqu1+dH/ 70N8/vD8/353v0Tvq988SN87H0E792T6g2R4sXLd3uhvrP06P6Ele1FMqriXuyf5a2bnEp+K UEjZHIpvnu5Rbl3TRjVbBzV8+Tq2McyU5wxkr9nvvdl9VbCJMI3bki1/yYpp4ok6Ounvfpsb 095qWb3W7fXWyuqteuvZRcCHlfHluHYZVN2KmIQvoxmuQIEqpvmDwlVUkFJzpCFlcnZyEaL7 FsYhC87DFSK6ahxNIg6ZldbV9iJJUB+0fXSaAqGa4X2viqfjG7XWoJRGKOzUzdi+3trZOfZs fMXM1r8YRyX11lu5IsXNrzgAoxuprjSruTHdVvHrbEW71F+9rFxXOeQx0Olr2+Z+5gUVsy9f Z17u88vc2dja2319QIrrqh0P/35igBkG86jy31atXfU1kjWd6PeDOccYC/t9VI2PCR7sAali K7D1XwdJFC9S4popUNn5OB4EY6DYSYRggMH0odjfMGobuv2hZm4czsMpJoij6GPncUhB3uqD NDXjOu72uif977vHh0u5ZweHB/ScgrTkh5mGQwS4ynIdMyZ/slx153pw2Kcmbq85jSkUTO2H 5eDqh+VcEzyEr3ePuZHyVjCQzCIY99224M80BlhPC83qkdmW72w4O8zypmnD6JaP2s3s960d 0T0aneS0tBPhZtnVI55C613AYxills92C6P3pzmU4zmeHThAbqEuBlDr5s++OZ++g29QUq6S 0xqgdGgBho2wiuQynC4m6u8K9egYWLYGWB7+b8H/q/D/mvpFzTBfxiXIqBiJ/+ljU3MxRQc6 ytXADLMkRtUsanx2hpcQzyx9eJ4tQP4vCgo4mG7lltLk9vdMNSnRqo3nzfzwgm4RRGk0T+Dt L3D+AAfQsHOXJfwcZpag+RL91PomNK3W7wG6nuM/dSiIQbyfO4lT0KQa+Ge7Gnokk7Opp0t6 itdbMV9f2LjlScJ3B9K02eGN1ar6B1+I5Z0v2UUo7dvmuHn4N9tWprFH/P5L1YCHJY1iO9Dq NC5p8b+LLfIlgV4GDQrZnUEokmW5L/SM4z6GWkxxw1s5UIBeGbKfAeXMvbuIcvWyYeIJTgim +ZbGHZJ/IFJj4oclZ1BUgIG+IqX5YWYF6UkdD90jVfExaHhElc/jNtcTbXtpNxXbD/AsTuuZ XitH3pNXvfcgMGfpPebqgTZb633Ypx8Vd39reTzCDWf6eq4f0DRfKITZ3Fr+Q2o/zw3qtgEh oMYyJP8pcMZMQ22I17mwgZLaBRmBZYLFZY7O+sxKIjREjPOZtU42G9Oo5soeF8yfTdlmvuxp L2/Aa8q28mWPvskzzabsaqHsdt5A1ZRdy5fd2t7u9nouP2XKrufL7gDB/87f7kZhDFul493M l+2dHuUWorzs673Dl1t73rLtnAx0dHx4oiqZLfyH3qR/ZGf/D7sh1XwTfWDfvK3cXrn1K/qn BfY3t/r7Nrf2uzQHH9Rwz/Thw/M4y1C550uuiwZFCd5/dcCOGgEzFiyAEZbPBXzgJoEGhHTQ oWFLDvBp5qzD77qhcsY1FyY6juWSCgfDLXoNFayJUkR5q4CTwhoOoctVEhKi6wGWqTk8GMmf zzWuAdEBAw9RTGaUKhaY0GsSDC+gpRRtk8IkxZhD8TAK5uEIK1FQ5kAJD032SyHeJQUYG3mO 0Y0p4+INLeoy9bqMaUKCyRwDVEMLu2f0jp5hDWBFiH9EWSacqqtQrx2WksFgPenKGY+NEJ0b Tmk/e4+9vaDkjLcxuj5Wj3X1LDAoiQg+jEEaT2cY5Wl6zvuiq4g6tm5oAo7OEgW7o+626I2l ndnmAJ8cNjpUgyBJojAx5wRtVTCVyQQY1jFAJqZLWp6chdNhuKyePXumlvl2atkerYTq5KqM b61y5auSeqtog/BFetGfjwdmitb+HN/gFZd+q9+wPSBQvBDTsuBiVzxWQ7alQmlXWa1seUwB o4+7crgBIqgmX/QoRKiPMbdOTN6jMnLMP69TzqlodG2zkPyrtab/ez4P0f9L7Nrf3f+/UYz/ tdpotj7q/z/A5w+v/z863j04KXMAdV7+GqtvHdAir/iP4qdybctKfER5DPyZVJlnk3lN1ev1 ql/8lK/QIFZiv3gMW6Qeo0qPDHALnkMopBKd0tfGKKsyliSWxX1XiClSy1VVj+GrWHzT8IcV T4FsCER3Tr/hWvHj53/I5yH4PwnPf0X0p7vx/9pq8f4Xvn7E/x/g84fH/8fd12XRn8yrIvaF Zgchuno+A8wnGYtUMExikFzIpKumBgvKrIMXNuL6Wi/4lyTN9aLTSdJc8z1c9T1seR4OZr6H 18/dQePA/AP3dNLwtNfxPGt7ngXXnocj38M08pX0PRz6qjebeoI4v+FsQbl6ZyT0kkVlsUrk WahhWnwWGpP7/JA9DaQpjWMezygzFJpmknTJ+mREcf9WlO9B+N/JM/E7+n+uNzYL8d9XNz/G //sgnz8o/jcofvfgdf/l6atX3eP+Gxvuwvv2DjOfItOPnX8Tfj7C3NDj8Y0aR+9DzDw2CIEX H99M4mR2QfpGut4HphgrvAIufZFMg3k4vqmpAMjIdHihdU7fhlOFOBuWJ1UV4bNrKAKk8zgJ abocH9j65APpqqk0Rl1YMIa/+J7MCS7CJKxnribZSR9tDOEU9qNrlg60z5l+jm5G/Wk85eCA aIKYrUNcf9qfzZNa7gXmV1tSRn+jX9asPj3fF/52asSLea6CriFvOFE4a9hwMY4xK/f/cV/+ H0XJU3VStzCT3cYqFJNQRen0c7S+jxfnFwpFKlEqzjMKVQyb9ozATKlmXfUwS+2YdYpouVOZ Y8acnxYhSEDYRlWKturqJS4fGgNkCl8FEerL5tGYyqM6M7gMojH5aeAAHaWnntj/MVnHsfjB 6d6eGWpoWqEE5WbWPGGimMCnRFQRmQKCI+AIpjdXDB/cIV1Y6SmzSjVVDRy8mLXWMI9eMOXL a8qEyDEqM1DjgRXzMUDDP5+i1ewovFY0DARekkZJllxM2LC6ZlWWOQBEQNMNm5YWMzx8pr1h MOU1qQCjMK5XLZgVPwZUTZMO1PAKB9DWEqeMJoDMfzIgTU3QFzjY5U2VjUa23U5wNka5nyrT 9CoIA2rlSwXQSHjhloFlTg61dhFfqQlAgJwUWKtpGPLBzWoUzAd7podmRAbLIL4jQL9CgAwn s/nNkpITmj/tpAe/FbXg9uexCu02Qk4parkDqxB/YpCKzrc8dYvqy5RvSFP/f5yXGp/APO+P TdJZwAk3fw06GYd0NzFR76ewUfDtRqUX8WI8YnAO0JToIWiGBlPEMxJpBkPPUmG0SUvjSSjl mY6h/+uo/vtgCNp92vOyY427f/eh5tsU91SXoRyLJsrQjbjR/g/CDQya+ic0dR4y5WHcj9O7 bSgOZCsHGyyGTAI1MqBFl/367VgBnbDlkP37SEb/Hp+HyH9uKsLfUf5rbnrufz7mf/kwnz+o /GeVfL03W8fdnf7uwavDEjVgvsQ9L3pKQ//oFwsgcSnJieL6pcneknMQ+hmvN+fFvQzPlTY1 2A9mRP+5AWUjywMFjo1dhbAlSPInQfoeWUPKISmJGaxlizOOe0SeJ1KFeSiTPi+UL24yX2nd gLDb56LAxVSYBXnkX4G6biUk6wyPISINeHgRDt/f1bFYiXD/wM7Nf5fuaeK4kvebN7qn3rtb bLa0T7S3uG+vD1xt2++9Eo49DP8v5qP46sEZAO68/y/e/6yurn/M//whPv8D8P/pyc7hNwf3 D/+RqfE7pwWwIf4z6L1SQTEeUVS16jvv+uRkvbVBVEhjMUrmyA66nBOnjAtRyDD6Qpbwt8WL 121QnC4KphSkk8ryYtRa5hhLF7BplaaLI0o9iv/V0Pnx88/+PAT/U/Lxf8r9fzH+/9raR/7/ Q3z+8Pj/ZHe/LPCnefUrQzxZ8+1pMI37GP8CQbxi1FuX+pENxwQ/igy0aScNMR0sGRlH43Fk nWHSqrLZPlL1WDUBRk73KKXHPdoaJvEdbT2gOZxstjVvc3e2SFOkwOPUdOkAn95jsjTFe7d1 Z3O0nyWteZuzLf6bqbgegv9FIH5wH3fg/81GMf5za+Oj/dcH+fzh8H8ekVuh80sPdTg92d0r Mw+z75yX0ZRCETxWFYvmOaxbFaMSuF5i18OL8wrekl9CBY8q337Q/bzS7+NVfXwG0sBjrIbq nX6fGskHKK5Aiz/cFV/WXLVm+7m1jmRclf7vU6fqe/jDUrWAWjNGVDKv7MNr575XO3CgjQFF F4SBcQJZ/nAwPFWh5+rvhTEOgzRUzWelY3f9YSrLOJiB+mzQqH3WXL4jSLJSz5Zf/LSsYLfv UXKyjBsbTXlBa2q5ce+a4pXzvLTsACS698XXNPXWQ6Z+pT67uvfUkz/61NceMvWx+uz9/56p tx8y9Z/UZ/+jZ/6L+Sbs2DVpJJ4+frwEmKPfPztL1YrCyN3wT5JidkEy1sWAkHUs8lf89owu tvEb3lmmIcZsgpf4/nTKiHyEUZWnMdWnJOIp2VvhDbe+mCcdtArOgRWCjhrcIXbyNO85n0OD MMgcFqR4lYTpsj57NNvlQXoG+9asfdbgfXumeHO4ljxJJs6TquP1js/ESd2nZMooqTl+ZREl W/9+3/jozncwT8f5QRrAoPpmqLs4+GlifgsU8LiL4bmdcVq19m8aafJPGikRLR4oesfYOwc9 WnaaKR+zG72DojRMMSL/ahPI8qPMEalUKrm2MkrCx1Vu9C3U//JLtf6uysH8S25TeMyXsLSF EZePFUvE4xEUfl4Gt3NY5xagmx+mP8zTwWBMyCcHxNyEXeHsRtQye+CCte76F4f5yt30wPh5 uD8sQZsorcxBaqF1w+CYM2xV/QWZHe+m4euajAOGZopl1sktVOB/7NpSeQrHfu+Tll9h7xpn T1/ZWhdWu1YC8kWgz4G97IFvFwQHm5maswoIeRu/sxETXURK7WieYgscLJaw8xSkgJcRppnl u0V6iAN8prbEhxxfYbRNSW5BnZI7fDwLEwq4RmZP83gCG4GdDYMpGkEO0G0ccGGYhEwKdudk WWSf0ys0buKs3EgVonk4hKFibC/J1A01rtsbugEyvsX8WRE63SteKO307aMFFGK3sERFcMiF j37guUsEGOAXwgPv3LIFi8zzPGz8OmzoPZgfrwT+V34eov/J6FQf0Med979rnvxf6x/zf32I zx9O/5PX8HzbPeh/DaPbPSxLAp8vwW4dahRbNwqgDMMAjRvRQeMiDHRElcUE7R0DNKsHJB4k FFsFHbXPE7TqpUiQFAw0CUWWqPszDdtR4WhODg/3ejIS6jFIhWLGZwptNKOEmDvxB0eb/htV ScMQPUVWKOULNFslk94kPIMJTIdk6i8hSTDWCQVd6euuVDilAIdsAUxxuo21bzCO5jd47Tu8 MLbi0FQlrJ/Xa1yBcymYGtX6R3z/b/J5EP7/Vd7fd+P/1aL9Z6u59lH//yE+HoRbpk//tlee ar0QP+M67V9FSVh+93prwAzycuoLbDqBM9DcvjxwBvSJmTjIKw5Z62sKupHEo8UwrNi36vF1 MdVZLtx+PiQ/BzPMpmdEOz3bE5tZAt6dpgEHns326KbwnV+DgCjJMLog1ji1FL4jBxMgAxOg GC9A1n+mkpizYrhFKTwWijJXEVA24OKlhltEBhfize99hoa96ywJ1BjZ/NvgvifHWwe9re0T oLWqYeaOZYF+km9IfplrHJz2OgWBGcTbSXpO9yRKf6Eimf5dN6HUCQEFP6xnEHpj4u1FMerv dA5jHVc/JjK+1+cW/A9sxvv6eJT+5j7uwP8bqxt5/N/c3Gh95P8/xOfp4wz7r+7i/lUZ868e zvsrh/VH9crS4enJ0elJ/9Xh8f7WSSUcn22sYf6FlY01EBQeK3m9dbz9phKttjeeyTusi6Gx v6swFq4uLR292Tnuqb8Dpg5GGFJ773Br5zk60FKAbQzzTcYevS6hsh7p69EIkmOGKx2cfBn1 TyA30OUCJ60aoPd2Ep5jMeDmtWk+K1Akhzzz2uKxi2ibYzGa+IZcuK5Y2SWNcU9nizG3gby/ hDDUuigJjCmB92zXHJyRXQXiRWJCNJK7QH1JaJ0kLkCvdeM+N3f6Bymo+Zo2GLdCqXqeRJrP C4WR/PeREPd1FHduL1OoTrG8s1HeVeXgEPeiivTq7+pxJfe+StdCt3XNeQLWvqpmuqfK7iBy 3ec7z3f/oM5b+9XnBC5bE9ZeRnN0QsTLqb2mRKmENXSGB3Qo31QdXT+ola9d7w6GNgncmcIR WDECIAciwPis3EedN5ZgaJiEAcB2ANuYJMENhTZBF8H1Zuu1gKPEJk3JY8TG00zzMMtAKCkO ppdhQnPTwAYglg/TiZkRqIkeCLCoSawPl3GsQkeopVE4x1xdGrxgafbW4FAeHlFM++/yi0O5 UG3cft9W5Bp4jFMl4zWCzFv3Eas3rtHyi2DofZhg8rYCBJttol3C68Jn8Ci8DocLGlWNHCgx Vs90xT7lpWBN8TPy+F3BDAL8mMDsmeLH5J/JcYjkGpL01wioEvAHW6W0I7ifGKrWOZ7cQ59u Me2h4GEzbNcxphHAdHH6zxAt2jbIcbSkDeCeMSqC/Vp/zMeETxxXLalrao75G1aTc84VvdUc TKBPyMqKOrIACz9/1YcB76lcMUh6COdYjEYRq0vc08HqIUCYEySJpDwRaN+CY0QSy2KOlwp2 CylzjHh76ZNBkg1dPqA6icKtzjCMwxlFxJ1Cx1DhZ7rysGfESVyRXypZK6cErRcTMcIjeOoI WzT1THDsTMkm4m2mD7WmABjfvM59a8y119QjyJ0KB7vpMhhI3hSpVDLYbyVHKqrqqUI8evtB ffJCrX2F1gC+rp5b6Pg+TGI9i98EHf2foSUvKjDTphIMxLj8ma3hXRmkKb1iiLflPQeRDwpU 4HMiX7YP9/cPD/Db3tbx625f/76dPBWpI3VdoD2ZPRTk5yvk0ihYn4N4/lvPXp9yXp5TsJXi QsB0nQJZxPUMWTdO0+IyaqmEORhF6TBIELr5jO/s9ra3jneeupiwHl5H86rGS/YXfiFnH/vk ok8RyZwjBUCHkbUHi/NzpIaCPNK6nFTMTj9QjeLO4nPZN/wK+MKWcopg/kdbqo6hEXQ5pxQ9 z5fTTebL5Zrk6AmNQpP0vFBQGi0UtI2iyI/xbPKzkedYCvH3Vq/XPT6puGD2RQ4T1NTyV/RW AfZJzsbxFVs+WLdXjKlQR8si3ZoX8XzxAlkAaO0kjjk8inGbNdiXWvmoD3A+t8j/aTJ8+rv0 QUbem+tl8j99z8n/G5trrf9Y/116v+Pzby7/37H/AbD3ybw+/E193KH/aWw2C/6/jbXmR/+v D/H5w93/5u3/BQK9jro6IL3vnes3wHaH3FIfg9moiui4p8zzZ2NgK5zW0p/+pPKPF9OhJACJ pmK2Hp1RnD9upiqGMyS9crzw5S3qlaKcggRMpI3aV5/BgpqATPgj4HbVZ6MfpstL2DuWq0m3 1CU2bHyJjZ/zMAnSC7JifPj+33H+dTbueu83wNgd5x8OffH8f9T/fpjPJ5nT/8kdZ/+TkpP/ yYPP/SfuqTe3cZ+wbB5xrGOrCCOP/MsohaYpIBWGKcOYJyoeDheJ1j9RA5zC8ZswY95xxTld WUuDDDwcua+3j05Vo247r0vCT9uZSUa/5HlmbfXTxeAn9WmliclN29Wa+ixJZ1YS+IQyjZF0 mqK0b7hRZ9A4H7LZSMcxWUzCGkMJ1dxYweh1EqaYdArIXbsLVholmj+T+PInGFBzvaZUE8en Kji8aqHAGhRo3VZgFQqs3lYAeG+1dkuBwQwKrN9W4BoKbLgFnHneGhE7O5AGNLN5Sz8dDCXY vqVAGwt0bikQwEibjVsKjLDAbeuN2Rqat633CAtk1nup+YxLjMPgJ9XmpzUqqheJHSXcYKOS UYecIwqAV/b5RKXvI756oICQFvIIQO224PqrUdz3HRln73ZiTGTEWaJwTAFGG8TgiCGNbYhB /FChLGK1uxQD9WmDIz+WhFl6oprSC5ngqsUMR0BhcICdYH2Fetl9vXvwTG3nOnqwNmPpE2iS P99gGI0iYkFshU4kuNSkoOCI7nTnMgluUFmBNgnJYoaZvHRjgOaCKZsl8/hxvy6C6Qi6mMTY gUR4sv1T4Eo0b0NNIqovFeyMTas1RG0kjHgWz/FGHOMbwy80gVvM8AbAtEP3DIhe6DoqVG+C va/3xWLtLLrG+I2AQWuYsgm6SvnyiHWd0Npf7DajKTTu1vWrV7WyzbIgwR43EpvJtPHj9GfV MsER7wJS4L1uMPnyecyuOy7IfcMbMwLIq5EuFMCtnj1jGXxYIySZK9DKF1jLFVjNF1jNFVjL F2jlCqznCgxmuQIb+QLXS7kSm/k+GrkC7VyBTu59J/e+nX2fQXQ1wn65AvmFHOUL5BcyjXIF 8gs5yhfIL+Qw30V+IZtNu07BaEQEesMh0M5bOGZKffrfjeu2MG+1zM4ri1wO9nc5NTMw8d1X e1uve6aV2SK9gE7s2v84mWWQVgSywdJS65kZNByWZulJsWgNFcdepAas0++A0gCpZYbcHNwR Mezj53/T5w75T+jOP1X/s7rZLNj/N9Y+5n/4IJ8/mP4HTffj5L0xcGf4IyaFBb4BOpqJIUQ+ WCaN7WWQsufXfjSNDnt1n06pJMCbN87trZFBi684R9aXHNWT7zU+T4WVS4gRASFvFg6js2jI U6rb8KLRSEr26Y0vMCQbjaJSaTIY092xNo4VXRKtDl2s1Hu5potMukkCSqHQ+Rp6fOPEFCUm CneCQo2aeaAv3ihK8e5lZKOOcpViwFHj6xYmCV/aPjVX0Pk9ROPeJFEvPHFMI1J/ocINS6AP rNa3mYa5qktSw7mZbFpRNN/HVc9K1FSDU4DbHr7wdAAjfx3/ealMGqlTxCj89rbxTkfkdIi3 IsfdJeNgx168Ojx7wLt6o/SgWL7NR6BHQ50anQFookamwlRs2YWd5brkVvUKZxVJdaQe47+8 QVnr5jEc+3EzygcbvN9Uha2n2dKaQZd/luUbgxQb0PbzMbihs07GRzOAm9Rk/DWiAebAiOZY AwUosdcwEhGIw03oiOKRPKo8YKzSAYDIuMpbvyTBEVUF20QAU9p/N7c4LVicVsTus7BKaI5E oQDGTbQM4w8Mm4IXkE1WGOiB43T1+gwWc9FdQX+PXqj/1s7i0CY3hJtLnCflBJEo/wQPdCnK rBuDT8oSj0GVaUb1dR6TdGqkSo7yHk3wbbyYiqEKe07ZHvVAJTvB9tFpTZx+gX/lvuKpNpLB bhDItdXLuGX25V4Ret/CrN/hTmh+9BEsyN3Bbqka757ZP+ia8YOOLONzGOA3sI9K2Q1s6Q00 2wdzStCAEytpCZKD5r+gvX/MUWzis1yQH5I1gI83gKKyyF3QuR5Fdv9b+f2HveelB2FXbITo Ip6v2X89y34n/0eBs/+p/N9GY3W9yP81mh/5vw/w+ePxf9todDqNyOJVE71UzKGJMSR6tiKk kUw9otlijOavzCKi+wmwXemvYf04xOmDmEJ0aqKO+9LxbVGDcYK9kNDKNJ4jE8hhDgTBnkfQ EGHXeSgIx40/gW48pZwh4Tp5TiVtDGFCVy8Ya/3i+Pc7yDUzAwwn3P36ZPvNAcYThrZ0LOFf DK+CC4U8IdmPY8yCy5B4Eoy8yFEXU5NfxxZt2LxXlHIHw/LI68xMk3AYQosy2UxYxzTvh4XI N5/iBP+kb9+5oZVnMea9hyWhO1RgC42lWZ/RciWe0UJBB/SHcDM8mybUagoLiF3JUz2pFzwo ctNSf1HwzzN58sSjZs/GGS0jixluRSKO+vasEPoZ5+hsFYlDTMO0KdTu8X9mFnoAr9Gc6qeK ccHCX/n1fGwhzPDxBthMGw7E4U/4xm3RhJAZRODzcenlwGfattGsNXv+ggj8Y4Ft2TxnoWiQ vyxllsGYrnvXYZZZhxn1ii8x5xNv0MPXZZZdlxmvC/655RYGloxSmkJJ2zdA18vdg53+EYy9 3/9md2+PM18AwDVuaYvO+0NXfParVtw80au+LV4JahpeMfYRyX0ZXVmWFTMfNe2gwBFcBsiO moLzeBlb4pJ0M3qNoz4HVjNMU7K/HYTzq1CS6c2vYvX1PqOe4/CnRYQm17MkugRCdR4S7hij a4wMADDQ8s7h/u5Ov9fde7VcBInFlIbTx+L9eVzRTqL427qMzuMHAQYQlHhomrbAAc3BF46F c+unhmHhkUb0uco8vqPCQ4EgM8LfcPTKYQBW/pbdl2t/nuQd+1+6aWazZsH4lv2RMXu328JG jVsRpl3PLYaVG9KFfcBzS+EbcSW4glcsjOkBx2cZmp/qG1H0GBgXZ0GaHZ73bTMRQKDcIA4U 5KYL2xmM6RfHpivBVk6fmRQEDqzBEO68P3YAVGDE+XV37V+FspyhlwKsXQUGW/u7BHhPp9i2 w5oxTwZv2MxkJw7ZyW8UY0pOAGutuLyvxtLZ9QV15mHtRAsh7vHyfjgGPkvRvzh4+uIyeg9l 86gBWDn6KyD+rxZOPn7+6Z875H9gQ9L3v1H8v1P+b24U7f9azY/5fz7E5w8m/z8oGc91OmEA BUSWfQs4fJq/u5mPosIjjCfCcjkiYG4L9bTh9ZzSB0QjKw+wnMmmwJP03I3nAeUKvB6Kl3pw Ru5EekR+uV/oUN26kaq5aljZ3FwnMQkmZW53+hJ3jejjC4VBpl7tbfW+6u8enHSPX21td3UI LJFPhxO/1xfX2j6Eat+e9E8O+73dHamyqMM89PTrOsOolXrLhOZsPflbgyWq+qU92DakPHka 7b3QwaVlWp0f3cghcHyNYrcQS8L2SeGKu1Fle2i2MLOJnm1c0isJjNGv2B7D/QCLdPsewcbg /shWufXKNuqxREcpLThSekdHptgvPM9fubl3b2+eCdMaeRqsf2sZ3BR73xX4MrvNAeUtdk7o EC35bSwZ/FngNvF1c4Nej8kO0ZRPwp/8xRl2iKMPR+65H4XDaASPbqu1GEXzgE0Ac09H4fTm tqpp+NM0Rnb9jwSVW9vb3V4vC2S8D/U0zWQ8fkH74S05z5ecl5akTcqUxAfesrB/2RHDAxfM Hwiu2QskFwipPW5OQ4X0SMAsw5E3z6WcgYN8MXxBAveVWxSBo9AiFcU3UpIgxEzXLUpvuJQz 7UrFM0D1CBeqiscT//6FVJgrXVig/ee3n7/zcD4LwyTyySxe8vivBNzX3ZP+Ubd7jHg1Cz44 Bxii3CnqWhlRVUOPHMJfi/AMKdNdChm7G9VxfA8H1aWRi4nmuZ951PZ4Gl7hLiz9q3dh+7i7 ddLNrj8FJiP/KYtCXtAMS8vNbbn5reU0+iggjt9lR3lV9aY6/fKL27a2QMaAaZnMxvfZ4lLq pbfXPDMkSxMq5ZIjS4SUgy5knBkKy0PhEeiOkVqqR6aHR6aLR24fj5xOHjFB+3V+ah8//5zP HfL/eYLh9Tnc0K/WAtzl/7fR2szL/821Ruuj/P8BPn94+d+FwNvyt+cyVIE8s5j1Re3MbVw2 LXIlhTriyz8ZvvpP2QYoAgg8PZ/OofM+t8fRJlia/xMgfVaJU2P8YJpw6JCUg1j9qUysokL9 cZRiQm8ONsINYEimRSp2gn8qUCZnNZBCvT44Odl6SZf0Znik/a4pTPD7J69svdKUN7Y7eA9N 9U768fvgJlNw6U+aIPB6/CImDNAdh47mGDhonuGMjS/g0E5g+TJYNk5o2RhJSmIkraysRGQd cEVWAaRsx6Y4bhE25NQbA2NCt4OXbtQ0050JSWbiHzlNmSBNwRgDcJEzFlpDwlTgv8ENNuKG fqpM0RFznmBCCI7tlugrRTSIPb+oLoldBi6+M/0Kf8e6N/1LYsAug0L8WIzdNF1MmJ8oBTP3 lebI8Jaev+H7yRk+kA9t01vd9jt6P1n0F7MR8I999CQBxin73rXMRbAAMSFryXYZgIxwtPW6 S74vVW0ZqaGk3aGqOjOA5hpfqJb3HucWENbzAxA235p3K4nkIGpO017aWQsOcyj1zG9TaLmH M7sUj6v6rD5wZp7Decek7nNAzXuq8XfaSTE25Pi5M/6BZ6GCVqqNmsI7vcvguYrUF3Yx1JMn Eb568oL3ubf7fdfyuQAzb6N3dUxI+EJN8IhhJYqdSOlp8UllVttrVo09o1S5hAP6Ag5O/+j4 8ET9Q1UYPKN3aOTYbFU1h8z/FxbUQm4F/tTMeGvq4HRvr+bsdPW5csyq3Ss8d1PQoLOPHqyp ZApz8AS7zv4V31I4ocWULsGDOUfLZzTiYIO/YsQnmwCHfRSg4oBTy6DhbYJR2Mi2VkIY+8dS UQV0AUXevjORj/kFtH371WlN2knCM5IHzlKnDT2v25uQi0auEtXIfZJgy4UgfMim3QhDZnDq 0SN+9YXpjODKqFUBoHFeABYXo0QbuABcn7zqR1OAFKslUDx6bO3Jk3foDOACit1nHp4IyhRU T84gn+W04v6CGcljXBY+Hwi57ipNrRo/clCv2zSvbjxL307f5ZaGF2SamTUWxBmz1bVGUXog 0bvnmVIxZhOCMXGpHBrmweaqjMJLYN5TrkVcAyyRexbugZ9y06th2zVYi9zS4kV1kPyKFW7k 1zdLCP+YK91QTywuVI81CH6gZf9g/P8d8h9Fc/2tfdwu/zWbq6uF+F+bGxsf5b8P8fnDy39a vIOCrzD+tY5Kr13bZppwzp14qW+PTigu8G639+4+35/n0/0JvsrEGGZnOTaz5r5RnGxDsWws 4rfvtOtGdsA2JyS3Xs1Ws34nB/GcvIZYlvmzsbrmyDgU1LXlCCqGhcmIRBIOta4n5qyTCZ/Y Kq4W4zxAUHvd59rYOw3VKkdT0PlU2ZoJZ4ZS3TCJZvNnng0pBJF9m1117zLl1zYTLFLWtvgp NOPfUF/kyFv21Vcch3CPvfVGrC3dX3HWCzH3U5yioRxJzBWdR9tmwVDR6FqoKBQBnhyFOiJh +meVTQ1G128b7+gF5g0FUOu92X11UgVRrnHdPDvTZZpOmdWSMi2nTKukzKpTpllSZg3LLHI7 h2XOsAwuA8uy4zgGobwvHnNh0ofHshQoR1MEtvAyHGfZ1Wkf+1gnQi/P4sW8zx3nHzIri3WM T6Zn9YOaNMsSn85a7nQumZv31p6Zzugv861Z/AFCytPH6q9ngNjmFwkqEP7K4WN1I6u/RyOt 36OR5u/QyNGb73rPbNbnX4x/ZYV34Au1Zni3Yl+ynfgHHpgG5JjNUJkRE1w4WF8303j3znxv Ot9bzvfVd++YwTXeJQWoi8/OQHQ3gAfHtYbYjXYfy1/mANBAnw+SqDZDkgakimkhs2I6o6qB W2dTlPsWjtxjsSNSFYt2q8+z0JCp07pHndVcneY96qzl6jRurQOEJFiM506dlSZvMWwIaxgY V1v9gj3+7hbYgyjtYKw1qVGCRqAFruYThWvlUGDqVZ272UV60Z+PB2Z0PJbJZIEWZHS5ymXQ NoFuV/F69IXa3z9F86vdg6/3jl7Dmdre2rtFMK+pepCcN+sigInMUVDS3dlCCzVh5BmMCjzK dCiB56GRxZQyT7Dvlgkhdkubvzz3iztm8pVHZu411dQ6G23LXnWVN9kFRRdyvagPW9CTvZf9 V3unvTf9rb3bVvT3Hjt9cAIo0Ul+lr6EM6i4mcWcMWD2risAMPQLcDPDJDEmi9Dy82WQGTg6 0MfiMwhcWCHbC9VkIgr/5qvmEtAs6dRbhP5mYTJJpRx8jdKUnBQqg3h+oS4ioNN0o8u8X4TJ QZIEnR9IJZ9STm9Ftkp5fTN8oeXmr3eoEeGYaT2ilGcdYgWn88UXzJ6+3D3pVdU/eMjUNsOK cx6DEp85R6X4iP86+wsblFd6uJtZcTbS7k8O/RSrQFHAHQ3qocHto9Z5pncJJw8/Kmbbci1S dh8qBNvXl5xAb6HcO4E95nRtHA7DMSNEOKdI0ynfpQBtknKZd/pLiwvQQhgwJzZQyAyrLn7u 0dB42e1qRm1jgfVFCcIuCBEYJQBJpRCTgjgTvauPYbUInl8gx4ra5/Ky3Df8W17kIjLNNbhU fk0ygyusi/JBk+tc5Gunapge2orMnFbNnPidOex3LaLZO7OA3EB2hvc9rflI/nurfHRhdYaz G33C8AjX1CPqqKYNn+lXtaqjqnz77bfP1DYFBQyTJE7+Yg71vZdOpvZrDn4Bn5uzBCwvJt5x aZGwJ6gQeu78xj+3nCz3li2b6X2ZI35+NkxWa+qzxrLJ4o49yAoJzXe4G+4W95aK1fLMuWG/ XO6retvWUoZ4D+LNdlRAwn36dXTc7UHP/ouxW9feT1TvuB3TnGYR3X10XXrQ5w79r0RY/+fG f2s2C/Y/jbWP/j8f5PPH1f/e5q/z4Lget2UKEA2zJ5Yb9LYyWJydhQmpoBGFS1h/Ny/A2WRO +Wi1+SU9hWpvMRedCPCXAdkToFyVikmpa88Pr4mCVvB9TUGLwjYw3blMp9TvWQWaNRQUvlep bI2alRoF5ItDjYH1iuLK9uFB73Cvu3vYl9xzsKLjcCot4b9mOOF0VHFazV2sE+9rkK/uohD5 jYmzGQE8G8ZTv6bVTcL3lhYNiq58SWniXui4bdlUfU9c5jmNVr6UftAY5BQ5Iq+E/4DPY8vF mQGJh22hOzYep8XJKp5pqWi5+8OLxfR9xbMk7JIEBNuoeWFXRArAEGWwM7xjFfXILMvKl6jK woZqhaezJB4VJl9T2VIGkLKPi6tWw4HBiMpa9Hp1W0GKQHdYMm/fOaKJF09R/gxJrSTmTHAl Z+hhJwhlmISM+uAdqfJi5Zzqx/MYN3+eDC+SCseA+PyH6eeOlTgUAIYFORtrzODuPs2aa0LR FfpqrGYKBZd/SH6YLtdUyxSR0c0pQrBYRahwnIZ39SZHnfozrRnlrNhW6Phpzape0gweECzg xCEy+/+R7fqf+bmD/+M8h3h0fwMPeAf/19ws3P+3mq3Nj/lfPsTnj8v/5e7/y65mnczPeLus CTZQjLIagL1yJSXmmAZ1bhZvzx2xXzdTecz5S50GAB/7huNcOZKRNLAqI5sCQbm1OENqvhZG yaFIYdb6yW3JX18w+3O35JcmQlTm8coL24W8FxWuV4vhu7r/RpLZKgp9kqrW/kvMYxUo06ar dMxqQZTtHeZiG3eIqXn/pTPuaqaefS6N5nWQdhVdtaPWctxt2KpVW1nrVqnKOpKGfkFlnzzJ OH7dYdVKyhAzRq9CSi9HqTbEvRltPIwQ34X/HRHon+X/s9lYWy3g/9VW4yP+/wCfPy7+9wn7 Hp2AX1Z/gJRvEwxKZPXFRCIaP6PRtf5LpAWx7FGfWaGMYxjAkVzKmhmZAuhn0p/GcMDG8fA9 3Qaad9G1iEFpHzBQLfdCRDh9z6Rf1iz9yPcl0R90DZQDsxVcAxgzesH48gpHg5Ek9KgcakQG 8iAHBqlLo+jSWDCgJlsaF0tuRLLyxulULY4i4kG5pVgfjltQyS4rYTq6VCLL/Bc8ttzi43sc EXlsQxfF93ogVOqLF9yapgJCR7Mdr3AZV6YjGuouW1VXdR/aGvLUEQX1lYjZFd0nyHGyskTb nqvJAG/IfmFaJlMXAkOLTdKfoXZmp9B3g58LPZAB0rydKZVMCIpg6955yTtd+87JwZSw/L3m 6B0/zfOJM0+BGx6FqBUyZ+z2k2XuWnIlfo8z5p6v3BkzhbPhEVDToiPhsc5Q6hjHCicSvXhU 6OY04BY5xDw/VY6CCp+Kskv12Ks6UjgLuzz55fAUpti4DCDqL/SLLMoAEjgll54QwBY+8DWi I8xkOcGsC36Wn9TMlqOgMIttmLdbOSnbRjYEcYMurB49uLWcboZ288mL/L7l/VoaNoTq70yP WDl0G0FihaLnoCB8lB6WO84JcZjmXFmDTado5iQQKn9h+/1NZOifSV0YAKQNQbaPHnFjf/ZT Pcw/vJSp+AVXvIMo6RlnULizhgZ1O88ECgU9O+gYG6spvS2Mlamonq6X4uCTK8LdTHv09pTR Hp6eHbp/4HnSU3zlmBSUzMGQHDMVM07vKO+kMFkSQ8eGDksZKeFj83ACkzkR9zs+xXrZk/R7 0JsMXJWRnHKak0MzsG6yQGXUpfh5EL3xVTeAwQQnC1VlNKf4cXX7/5ZE6KNO/3/z5w79j5uW 4J+l/2muNQv5X5qrmx/1Px/i8wfT//zG/H+/OddfwdOO36+YPki9DCOfLKYUx92N920TrWHy NeYTlpwOgHqWZHs9OOyj/dxJ/+vd4xO2Otja23190N157tgiZrLhlSbZi/LWhvfJtueMS7T+ l4E2NXboZCXvdVCWw8Q1Iqgpss5w36p/qM1MidOv91+JO4TzvGrUSKXUDbbDVfYfHPe7X3cP TvrbbxCo9nqs9GcuGCOaMWtUiaqeNHz/jpTuLvzPiSR/Wx+34//mWmOjoP9vtFof7f8+xOeT DPb/5A7c/0kJ5v/kwXj/k4zWnx2LVb+/1et191/ufdfvOw8x8mQh5mS/L2/2tk66vRNfgaV8 vPBw6kndNT6bxnOKLUaZtdW34RRTOoTpr0ilnc+srRFZXWfn7tuAQ7Xl5doydrRsFwCzSlTm QEYwZGM6tN+Q58dE5D/YJgcUPkutlcgtz52iFGajdQZyT/MMfj99rKYYDuln9fipt+gaFl2V oth9eVGFYywbQFOSndeDdBj9rJZhaZdLiuq86PeY1qoU1StkFqhYdC3f6pJNdo5rrSoIQd29 V/ij//oUAemwZwRtHjf+XO4hUvx6f7l6S338LsBXy9eHbV9ZrTdurY/Ev/9yq9fVA6Alph+N 6yYgldsqH23t7Bz3D1+9Ajai9tDK5DPg6hdsZbZluK0ycQDbW3t75AlQcysb5ovcNm5rZO9w a6d77AzBWbvzcBom0RDWzu4eYKLgBhXKki6WLUOf2fdOSeybAKHBT/6hmraff6iWU5SCkE8B +Yk75D/sFFL4wb1AqVG4xOji9/xIk+qN7fK3N2nn9gYDUl3pKA6I5zAztemr7hStLFJKF3sF bGISzpIYw8DGSfpndwvqGK69gI8Y2JayO//MwYQUnIJLqeznE5W+j2aWlaa8xsynGgz5Zrty XbUr1EXHFnVdA8TqMKKffHLtDHMSDJM4XwURYE25AbHq5+MY5uCywj9gKReJzwtvazkYV0/U aks9Vj9kmg6no4kdEcwBjYTmSSBR4ar5V+ejefbZPBi+77PXeKGwyW+deXOGWQaB4/VVkryB hZZQGZT4XozCweI8Cc8zL87LXogEgWgZI4PESeYt+57me5ksxnN0TR1nnubTFWVeIiWVMIGZ 59bgPfMYvScxbFOulYvLSf5RNmCTb2pWOMq8haaCNI3S7OZROkfPoqbhObpY9wdBmoWA6SQq lL8BWpddG+Dc848ikGeq7pH/trefWbGU58pohrPTs//fb0Q0zmkbOEG29ZHqM/ySpVhN/6K0 ovzdrZ7BIm7Fu3DIJ0ran8eUZw1KUG0VA5CcjeOrdMn2XGhsvYmnFm3NpTF48BUSl2QxXSGd L4+Um3jmLvKrCLBUoCqAJgETjG8orin0UZUQPNjKxtoKZu++ipNR6lQ1qoPLYLwIUa/xWRJc W0wsuOvnMIk31qzduHlPnoOf/sDPoe4oUp7PJ2yXRrlzgQb8mK+O6QsVVh9e+6vjixdk2y4G 6+qpaptW0sXgJ+r7jlbqdTux9CKBnleF3t+vDhAimEic/uQr6tQ5j/9chnkNHz6NyVCzthxc LS+J0eYwXmCsDgc0floEI9UsJ3kOeKOJoGv8ucR/nqnh2F54jMPgJwF5zel8lqQzGnXKIXUJ Yhnfm3BLbMgKuPGmmt06qBxZlumzZHDNTQWXIW85a3pQZRWg5syF2lMy26TrPqJbwkdxz7DT o3BO3v0x8kMRzNIco7pvPvpwIxzk4KvhMpY4ZOr/ILwS1FOJ6mG9xqc3N8FPW9m6I56goy3C ix2KHYlJJn8EYZ5zS1LLubZu03HV6OCZCsR4PKZHzpLtmnAZwggC/zRDApTiGuHSgRx52+Sz gJbfy8G1u5cjXqYZ5i9w9jJIi7E5aLTiGoWKQnfMXQq8zMk0oW+KFyZcLPo115dcoLWgDyLy T2XDpe581tLK/XyijrHIMyWO26iDnAEwzzhnpy52HSc/0drzDij/R5AsocuGRaCMF1Uf/5pD 6IBjbiS22MoKlVqhUoXmXPpEddC8ujgxU0xae/CcpB1cPICgJM03MKAGBuUNuNhR6gypjh+d ltUZUZ3Rg+og4pGzfP9+olopjfo9+xkQHhrMHlKnTfSzXVLFX6dDdToPqtNs1OjfB9VpUp3m g+q0qE7rQXVWqc7qg+qsUZ0ydY2/zjrVWb9XnQzNFGp5V53ZIr1Qn7qYzV/nmNX/QO0od3Q8 01SQUaMu+ONkptErvigd9utYiv1ZS/KVb7/9tqrWDMp2tQm/QZI/iBNUR93UaLBrgBRNB0D7 kGRwkEZCBIPF3KmK2s3wegakPVUR5WL+lGAyjVE1EIw0CUVnDmQWXaXAJKCQ+SkwAVF6QR7P bssYweObUA05xD5ZrhAtHtwoVicQDwJL7FRiMzUKiAHjxOkk0EEYTiiJMnaGOQZSdLqFrQmc mldhlOAkAXEGzNPpPODnw6FaOaTY3NCuOwF8s1Zfqzerd6gH1h6iH8g/sFRUCDvj5GYjA1D3 VxtY1cdaUfexdrvyA+tYf5Nq/jkHu8o+LvBG/Ri3hS+Kqv+et2T/ez933P+h5PubA0DfYf/R amwU/D8bjbWP8Z8/xOcPZv9RNNAgCMTLuUxYBRu2DrWQyWieDis6bBpz07YEvAO6jbSgsgzs +LK4svuKXURSbETFlgqhmqinZfXs2TNFbdWUU1asCaShL75AlP4P6d5kzrmBXifkHgmC7xTo zDSWoItpVSR1TjW/fXRat8FJsVwfFYlYs2JGdKkfGVMQ/OGLsp/eaA9DWMgJcMiwf0OKo2CS IpmcK6iMFSsSdHlNL6KzOYfIxWgIn0RnQJHU9sv9bSIcTtaR3v7W3h5GoTLGhjYbDHa+8qXO W8NpKX9Z+gRNE+k7tl1e3IQm0CUeURKVT4BERpqh0FM0tVNabMfGUfHk8Ysug9uD3+iFKYUz zpeSZRDSDkukCu2AeMldwmsyhpaAt3rQf87Ni+GGdgIackD5uXm88kKZoVH6aBral2QLwyW+ +OKFbBHbefLTL6HIihkyP3v8wmytLbTasr+fvDCL6MR7EEj5dzWR+V/9uYP+X6e/Pf3DXfY/ jeZGPv5XcxO+f6T/H+CTca4FtF5wuAXJ8h5RuHzBukYATNlnYZJM2czy93TgZZM+/zuAX47c Rd5QSKmuUyCV8yQeLYZhBX/h7SISzmurf9Ofmhu6l9KvZkjq5GxaSOqGZvnsUSvIE3uIJxOQ RivXKaf7/raH1krHhzun210MFkoP2e+f/qXfy5+NF8v5/GNVGYhbAkfh/qbsy6ZJG4YJBsJG o5SnlmXm3AK4GYPn1yC/O6GYkjAF0vG2RTkF/t74xfG0GodTColFXmlcrqqNUGEV4J1nEewH luPkeOugt7V9gmZbxIfW0CTWeZqvw73U1CPoO/9ueTn/RBaCCSiOiMknz/GFCuZx5I5bdg7+ uIuH7hz3WjpslZMU4JyjubK2udpq1QludcdyclC2JW2n+5CFBIa6xoPJlSOfGt/KyXj/opZP KArpq7KVXMqkRF4B5n3/8KS7e4i+bxgdazKrLHe3Xm/tHixzXLmMx4wO+c4l2GmsEGIuG0VN 9oCDoOUWnn2kTFwvZFiN25LeyoxjkqqoR9fpypeEcr5Mwp90FLXsw1t9lWoqU9iEFMs8LQ9A V1NmvHd04Q2upj/V8qVCt9/fslJUP7Mk6cyzTvDwlnXKrFI6861SOitbpbvX6M4VkqhkxQUa xX3nKBXIQE2FmNHuOh3103j4fpKe98nSUH9Z0pHTzYGnJybaTxJMyNNMLzk9WXIcAVMnowuu oXaCZdLBUfHc1N59QlSbbckgEySDCHARXXHCeVsM5+5YaZgXsH9yaUdx8mn8L9wZ8ArWTev8 xb6YX/NzmZ48ZexkpyhvOKK+9mMcXva1p6WL9gwO0+cYYMmO1UCHfVS9OxKwp00aXM0Z431b cVz2NGDdXVUigWcm0iiZizteOaC/dQn4nS2v9/PPekNtotbuwbe7hwJBcUKqddL049UJYgDZ NYESaQ722+B7Dan5EIf0Ttf+0kJ01W3TPH3uxkVyF4JOha5xZ9yjnF+j01PD+CHDRHfoYmMa AgeF9zzJYoo5PeHUAKv5l9tmrVaycJydoyFmxWkwJ/eQechQ+TrqGf9QjWdZXIa37ucxoVp8 bYkul/u2hwYyALEw0WDKQdTrUjb/qcziNI0G4xuzHph7ah5EY+NbNQtuxnEwqpreWi93X9sR TWPFubW5oxrd3sA6XwTZZcamJmlKzlnY0pIN9r4f3AzIHpUvjICKXEaj3IXPMi6qmsRJuKy2 jnZhcOmco30gCJ/pfshW1Q76L6XgamDQA+M244J9wUjzBXJW3ePjw2NgjRxmx170KBcy8qv9 F1k9+vFMOxsJmS4lQVk6dyc5yhbPk6bs29tpULase63KHwZ8E4x1ZkKxwmjefts96J0cHqM5 +ndo0t3f3/pWR/M1gV4x4qo3dsOSG8V1RghB4+8l46GuKlCdkhj3QTalcm7j1WoeO0k3F2gV BVvpGaETZsAQLOzBBI1FFP0Wi7yrUTs6aOwsd7q/KB5u+/LLF1TXwccIFYKPvwkVyBZKLNol qTnW1pEKsAUM+aq4fNNk/fuhgRH3yEMSUw0LOtGhW2eWWzdgwwD9zfHuSbdK7a+scGiKUTz9 HKWWxXSum55jKpgpSEiETEze3X5WEDGQKAKHBGOApxqr2538qEb8I308+r+f4Z+VZr1VX3/6 +/RBQf4wnqv//o++5/R/G61G6z/Wf5/ub//8m+v/bt//7f3gfbgHeD4FaeDW6d/2uUP/u9ra aBXufzfXNj7qfz/AZ8gpZaJpNFlMMN3ZIkrCUUXc2FSrvlZfqy6hgLO9v/UVuqXvHX6DiWZ6 XU43gzkFTo5Pt0966vCgurQEfNyP4XBeQShS2/AgOqscHJ6one6r3YPujnp5uru30++92Tru 7vT3dl/2WPyPZ6RUK7xVyy8RNFWgfdehWRR8kfxNkFRiP8vUNV0FVrBH1gJXKJ3QCVClHlKe 7ONXwDhij91rhO7cy13+8Soa56tt9+JFMgy348kMXqbYKbmJzMMUuVDsfYjl+lKrjzfk6L3x FKljWr9Qb7a+7vZ73/X6J98ddXv9N1VvhfkI+A4oDR+ucLKze3BSXpo0925pWG4svfQJ+vRS WqU53jOHyAkQnw7M0Bj4p1BhEypdzEiN8omz1cfd/zzdxX2grdtFnWJPrcC2bB2/hid73Y21 fu/w9Hi7+6KJDr3foP0Y2nxhwmCyGWIL9mhOieTItGsQDgPgDVRma+oEhEtoDaYI4xDYXQOb EaboyqGCxRzQFPsH3eBFcRqTeRdM5CqYwqhRczmDAoNoHM1v2E7YaamOQFhceFwvZGIrW0dH 3YMddeu0i9U1vJm2zR79ioZNXU+rspe/qlWpq1tl6EFYJHasEp+dkXnB4atX8PfEdmseKEo+ 1Xd2slIKA7qX22Goin6W4xCY9csgifD4uGCKbO0ZAOr7GB7ycM/krPZDOqwVfs2g/qrX7X51 WNVYJvNMecd+cGgKGIyR7X4xhW5G9QszgMxp02/V933q7fRgF9aZDhs0tt/7ept7touw0315 +rp/dNg7ebX7rVoeLZcNrb99fNLvdbdPQTyBYe50j46721vApd9W/gAR8M52roJFhrwwPBJo +RijY/CW9Xd2jxUgb9ijrb1ciZe7B1vH32EJ7vwTtYuI43PMAh6TMacVVgglqgHj6SlhABQA EsAyKSDun0E8A+wkzZj8kVJtnoShFjJhrN1vYTV76tO/lw34l6fSnuMqEpKGofJq62RrjwX1 jMy6/F28UBM0bEWdBSC+e7SulrNNUN4NcpBxhq04VAxhUAwZw2AyYvxDBDDXCmpJGC+RT3Mw p8iOugmEvRsYahbd5ZoQ/Qyv9ijCFJxxclMnmNKbbjYf5xKdLxIB3XvMm3FxVMj1kq9q4cMu 2V8PD/a+MwSzrwcXhWmhZ6c6mpR+8uJ3/MBZxrX/nRslpPY9sCT9o9OXe7vb/Tc7x72ley4N lfuZ7sOXqk5Lx7tfb6EHvW5qmAxXW1IcjvoYHYr41/nP5wvgwi9ERXF2FqRz51d0HY7sT6ce /EJQ1TXd7z8v5tE4O6De8XZPcM04TGAoQx4WUFfMMat/0iiHmVEOZZTDcZzaXzhj/R1VeeYH Kevllx6w+YXOzPYXD3mYmfjQmQx/BxKBg5RfPDX+fhVNV1sk1DTryXCJvF9nQZKychKjcRqr s+liMgC0RWedd4vwmbYqgKNHq/TqdG9PB3pYooN13N3auR2rcGt9/Nu/6EuYAeAf2ZoCGnjd /VYdd4/2tra7arn+WIy+36of5u+eUK/SIT/5YbnytrHS2Vr5Plj5uf7uSfUHqMOYYvmHH5rL xYHC8PK9/yIka/fg9TcayxNCOw/nKWBwtbO3hzftjPHQwDCZcOrhq4twSlAB/BbQAniyH01f f1M3dGoI2DaeGBXR4enJ0enJ7ScFNygZ1uPBj3ncoz/bh/v7W8D4wI5iyuN6eH17DMeVHfV6 e7v/ze7BznG3d3vR3du276FVnXndXjX+rUvCzUS3wl72AFjmxJx4qG2+/3LfEWkqI9CzhLsu shnLfrlG86jTPnOQ4C+Ei/pzFEwoi9ksTOZIP6jFo+PDo+7xyW63J9Ik8OP7Lw/3GNgBWKtL 96zeO9SnoumwSN+9BlDJHARp4kaR1JJmZVBoGCF/L5ourlG6Ipkqj1OktXCKMUPIXyUW/geO dzAmwo9OI8BLgPw0ilLy0CSeANrevjmH3dNSk+ag5no4w5vzn1dkGd2z/kt9BCNgB5oh4F28 3+EjCxXwnbTkOtrgwAHnBIvxnI/xJ+5CICc3jVV4doZOwcTfIKdbw0FiaGrMAj4nkZy82QWf au9jaQlfIUoBrACDNxyVwTDEBOXQtQDrPfbU4rniemT5YeDYv9XbfDhFdv96ZRwBU6YnwaH/ tKYBph+MJzFedoyvgpuUHGAZCn5euvfwGAX2D7b2u+pnGM84DWEoRX0HIjgAw9WWHuE2bWCq eElwY2kriQFE5JvTi7hwd8/DcPqK5BJqfLkoOvS+2j3q74KQgSF+YIzHW5ilhwZaeA3/q6qQ 6nQO61Q5QUkROHpiyTTGOj49ONmFhdjp9k4AvaBYqAYO07l1vP1m9+vse7c+j+K7/HuVEZ8L g3vTxRhD9x45irc9L+ZyuxXm4PaeuakH9Uscw2qmK9rpp0BQ8f9VV3z9XTndT1T3OpjM4CzC lhCa+71ZaaQVQLyHC/JHr4TSnfytA40SqAXu4n3fYFtTENemSq2g3i1fv1roANWb5z9HM6W/ lHdhinIfXn2I8o9/Y82dAZa7dRZQnPsoP6m2pHNcgQs6Agjpv9rbet1Tyys7BF0S+Yuycr/Y WHNUDO4S2SFurIkPZMlSQUl3scpn41S4azpO0V8xHw3t/2qN+f+uzx33PxfB9Dzci89/Ux+3 3v80N5uba/n4z83Nzc3Vj/c/H+BTECzMlludFJHuJX5BBkIEHPUzVWluoBkPeQlWl1bUcQgc 1FCUW9FQoRF+PHx6BnK60krclLnHAI02gDedg2CJ+Aid10m2rEM7Jxdh2WuO8bLMLafLzEUG ihQgSuw8gyQJburFEcN4O2prluB4GzjeHWG3L6NUXx0EcxDIB4s5SfvMi6K+Dteiju7jb18G ycpeePkOqzO7jAw0rNAIePpAiwjyO0IpWVRw6u1BFMIZw5qn5GMN78TREnM0sDQxiQHLRTgX yxOntoaoPIRnZ1khNspEW1vreVaAlkdzZxC4nySr11S6OD/nayvPRAurt0br186sXy+c3zbf kziJ37+Tcns7jOChiOkHvrvruUWGSZP32BJImKlKEJjQNZI03sWq8dWY13NrNGIhkKLAHmzt YVkAjSkpqClIAApb9GUFFmkxdgGSIgUgzKS8qehfmm0NpbuINEDSkq8yre3rg1O1jc2QKQ1e dUHFEfDrFrCIfY8oVEOgroJkijsgW4i5K2H966oXj4G+plXPPqwV9uFVdK22jw97PRCmu8jL W4Ku5GayprbfHPZOMJYUxkuoIXU/v3rsbNLpVAfcLV7uYOdayxudyeAxNA4b/uEdHTzmfG5w fEEMgRXDyQ+C9AJtTd/DnyQ8D5IRgHOKm6JXMKBjBw+eArf5NL2Q6Vgwiqaey72DcP6yt6Oo +DEr9WGBcQDYc7JAqQ7OWqb/FFqSm89BOEffX2kFkIf06jnw5sBkQXWEyvfgfApiISI6voFI eW852kVmQ9yDwdXhkK6sZA4PX4Hj+J0z9E0YnYfjOW2QBSYvwqK+g8sgGtPGv32V3OBA8IQU gWgVgKiRAaLD6fiG9qx04OyenBDIJ8EUBa6I4qXcKLqZkzFm6mOV6SS7dpTSygtmOuIZRvD6 aRFdBmOMacIGpaHBEDhIAJjFVBdPbyaDmG1XP8H7bYSQR49onP/4B1SjG5fHwHYCMzqP6SYe y2qdOtkPShAvqmtOt+z0ipax42Ckt8nCRRbpWaS0j1D5c19fscIsZovBmPwQAPjOALeRnZw2 asUpSVkL1H9mApdehKjQgaOc7a2CJw8v7jUlMGhjRQi5etJQHOEEa5OyZ6VBgzc2wBES2gDN DLklgisPyLRUJUs+cWmcpRsCGowwlglbCVJfqPSfhGg89Dm1NAnSyXV7g7aGvm+s0WTppkub ADu7hAPFjXO4h4zyA7cLryH3XvU0CAsWW6Czx/tKlXo1kgwCrLnAJbQld3aWxKIuf79L2xVH DH2oMIdD9vQynS9GEcbEJRsXQ5xpp+Vh+vRyuIGV4vHoKR8V3krzHiqIgYnSTpK5QeKsQYQC QhXCBOydryC1b6Lpdhd3eBwG8GxGGc4mAAEJL0zq4V0mKfAux/FV+M7t3rFLYXgGQEnjszn9 AmBEz0fTu+BIjt+KcZneI8NC9t98mvog6U0rxBjQgUQ7azj7wBR9erCfOyY5vEYh3Pd2WBHm ngjzjJis6Xs+BLCW50kwSTPtIDgCtEPBggRJ+9AHIIHTZdAOjShAh/l4rjGPzHGwOOcpoS9G lRAQohDS3gZDNpCVCNHRdLbgHFsGP0U6TiBzrHhFTj46MHHhfrXhA+3UbHF2Vh8aABzJ1jEc rpAuEA+Q3r7iwWyqSqsNSM6eTMEechGPI3gbrPz8jg2lcSipwNgoty3AhszjWK02G63W+jvb 0qcV3gbgiqqMkkhZmefItoHtHF5wvRSYmVAtYz8UJfgczusyuRgisoB1ScW4uspLzXeFpsez EUITg+XXPe7TXIKuqCNkO8IrVVglDfoW2glNGeMOQaUukeU7vsv4PX5lwyUuBcgCHUcsWEQg FQUY6REgEdGPgRO0SIGJ0BHVt6WwuBpByJwukRc7x2Car/qHR90DQGyCrZC/kutYZpdxTDxo Gx4WttFCryaZDNkFUmqAkc4niRbTeLoCR0BxiArBpMFsNqZENohbZTBYiGhGKoPpfkv4cBlv 3JaLLAFdAam3XwUXY1rwfYzzwrfEvLlyYYy6p+F8fKMDrhk8T9NnRPi2B8ufROOx3jlYSuDP OO0OjChd4WvHQEsEfFgmZTIaNoF3DqJcvU8NkCyv+FbnMbKOY/5GALjAq5o8wc9XHY/4rQhp wDhormaaA7pSQQghtjBZXokwzXGITj1eeFpRvdSMmJFxoa24jIdm5cyVvLcimlYOScrmPZQr dexcX43jSzLOwvP4cNpN9xBZAm6lppXxkIuP5ajlrjn0lbM9XBJcQE5NYa3t2aOCFMPfPXYF tAoM8loGqSIG+Lp7vKplKFnG7FmY4oXXIgEcny4G+i7G8Bas1K+RneQoHtJWukAAPxEuVX02 OtPmVdFcIIIr0yuMzxulzPhzB7xyGKGeCbKeHpAw/I17eKYjAxJfA0gOuGz0k8HmAQsg54SI jeHDWBYpA3NZY3D1di++mgRTw+l+QpZDDOufU4WAMDTLjdHUWBZZ4qBFSlw44VzoMnFkwMAu Ls6JzES18JXOh8T/4FosJpMbs5CSomt6GU6jEEQ+u/yE6CfIZoZq92Cn+21N6EeNXr3a+k9b Njdb7W0jHjB0OnjwzjoYtU6GXQSGsMMgOASR6+3X8XgcTIljERYdLxLx7q0eqIFEX8ZH/MSr hjJbNuZAXMJnIq+NblAExw7fCoz2BjDdb4+DaM6yiRg74moRSgM563x+IdoMlHiGWs7JcqZv 9yLPRIPJCM45kSx5Inz+08x0M9LbMrBWy+yjGxIwTl3lFrJkcOJHiE71xaY2FjXdk+n65YQi idEGEaeNoarZLBxgETnbt98D8s/o3Sy/TMeE9ibL2qdysnEymTkIsoGzybxaril3/hsi5zi7 sN7ecNoYI0hsCmi0mcLkYMeOucjPMxrRtkH93unL4+7Xu3QHbnifHMMuYi8ZafURKWDf+vdV pVpjkCDePsfSi7BHgwMI7J9fToI5YnckkTFC3Lw/ITLC7BTZdPXRWsu3flm6QDO3F/91DC9W Qb0CmpsiKEj4/BtMb5Dh0BGiVvhMIpG4tDwlcfY0B21rxhUJ3PmMcL/GXs7Z8qfyECCYTc7a G9QAHxtUeoQTEJbJDyGim0dEFEDtMdg1gyEOhwReB0YdSKSNYZmCGRNcNZBM5ReuKoWVRu0S n0SptEglWnt/v7eNG5/RZGArQtHU25NkMQ8csLfCuDtVEcOtSN4m8VUDdoEwrtY7IG801atw YEhj93q2wAUFLBEzQ0EauXSt0RBLVdd6jIVjPZ8Z677dEQG+wStY9/DY86C1DiSZGxdNj3IE J0EYR3SsWWlxJxzj7YLG4pVJAMd3cGPrVzPFBVUbYnZBjJDYzKIQF2qaQ1PMVtWyB1JbDGoh WxbO0wpLa+wwiupTxQaBVFwXYZmRAi+8UCDska3KGb/T50EnWxGB01S1nDW2iMHK4zMK28h+ 6kLPHJwqaw+za4JgWUTfaPYDB56VuJR1yyyvw1PWMufuIJ67PD7ReMuYpBfkAD4I2ddVeBto cRGlF3xGu4evLO4QAmKcc6taONQSZEaCZ8mslDgTEiXUkSHSXy2m8MqZPLapYUV09UIdy9mi XWE1ROZNXS36FbnDmPsaF/A8J64NzOhq5sQZ3Q9mpGA5E1BmMEhrQEYDNsu8uoANIFfimgrn wzpA9OEgTC4WE6GGqaufZHyPSn1DF/qYj4n1H4zaKcXBypf42AAEaeeTKCUJJQaMMWHGXSJZ wBZR9B/5afpjwAcOeZ5ngmk3ed4bCOyXoc2TMhwvUHOvoX4SpaRrZ55XeDOayNl4kV4gQQs0 50z6Ps0+ZumPlmkwZcBbkKWiqd5yjr311AThcibL64UPGLxgMXt8xUXTl3sXK7ewGFO8CAA8 D4Oxyv/60wwKI2FoAiVoDZj3w5G5xVZWLsLxjDm+BPn2MSe4klZRjH+D1x5EcM4AOpCEBYwy zyjqg501byoHYqOcH3iZUiQXT4X+1zFA6tsecNWwJg6Bt3xRPLC60gyP44HzTaAsa+pvANlG x8wmd+c/MyPCq3DoKvHO7J2HLM35zyy9MORexQmQbDiBGH82xPQ8Z8hvmhYJ0Y4Mn8PeGbYF DD6BovcwSuWKRdKkzC2rzZEJEPNhulx78AXuQNJb2AtsYgqmN4quynFrtuloCZdGQjUXxJ3h C7AMI4a+h0S6iGtTaF0jDZ+hQSdRGkDJI5fVu0IkiRttqc336ChzcKhxp2UJoRn64auCzkJb +xILw9HSAn4WiqWrDkKEdhE4RcqUZhDFSGmO2VPVSiqDZ/TCWaJmq680Ufg//3m2IALHR//2 miQ9Zyh3QJoa2FWE8BsDlnKeGC3LNriknFACM2VaLJlhgIQ0JTySV4e6yuksJ5JlVPhmBqki 3TJnr0bzKu7HeGWJ+HknCc7j6SvWp7EVsmZ6ixrdZmt1fbOZEzpZwhRxs36LvGmaabXbrWbL TigYDuU+F3lXnR5nxIwBufJFCfFlxE5TwpMWJ5B5+xqtgLGlr8JwlsUSMIZ0MXD8h/gqCUM2 ulSAYsVcwbJZtCMWzFYXQAyxkQVF85JRF8iyoqpCJ1rKkobv5S6zpm9yRgvWmYZAbIFi9tXK l/DXDsKRPYdyWMeYYY3h6sbepEs0myIeBLrX3MziQVpujtyigALNL0BsprtEw3MJ0bZsF6Ey 1iCGCdpwz2YRrBqh0Gw8FjqMfT5Kcpdt5XW+57CSujZZiKaO644uzXRyxUcwS+rtTkd4IfDJ DMB5EnzOekPgYdjoAzZjOy/5AIsMIGr0WrACxPnVtFiHFjHAu7ilCG8SaQQ2GwkgwAHq6IsK PNaOO5TTp2zQapLMQ0fhornoourB8hkvk/jK8BkZ/gcDp/M9rmo2mGjDrK0JJ0lq3AP8shYc rBJCPUm8SO+jtzM3I3Q/gAKGASfDAwqKltIZENEKTyKRSSxKmPOfURScDyvV7IkwXgFGQes2 vhOekQTFVydGijEsPofnBGAE2VZH8xKuyxEEqFGh5XnOQIZy2uv29/e3jsy2i74z1JFu8Fcl FmMI4sy1/suZkGxG+nQGb+DoVazdRRriUcEj70gdpvz5YsoarmZ9w3Pw11WlnT33sOicoZDZ FrRvsFprhliMmGWOuQBUEuKtwSUiHjjjE7K6EZlIXPZINwPL9LZ7DRzqZfr+xlA4ZB01L+9U wMQvBhKcG8Gvic/yXggaICedrbSTjIm5QOoQUAz+7/vHwMnBgYW35zeUcpEVkuw3w0yV28IF sKf5Jt6cvnq1v3XQRydUt57QO+aHz9QywdyyUScKOmK3Qqsz0OR9CCJglAoqwMUB+AROA7EF MT3MPcmJIfBDDYgzcRKyEPw5pBg5rwHrQUHIyFYFf76MUDpMVcNBjphtruUeIn04XsaL6Yg0 XHyfZVww3dGztGEcN+Mla50p8jNfg9CQH+fMXmo6HgSbGqi3W+NLptX6micYE6VECCNLCQcZ 5+wY8i3YK56+Vd4g9glwGwVHEEdBmoYctmLnaVYpMYcn6ka8hCeCX66Oz6s2epfhNE0x34Ej 56PiCpgBvCCBjRml7kWII7uQoOasqWy7mLYiL4FXMZg+NIaTOtX3/iQ6ICBmWDyZ2/nPLHWh 1ArSydkZOunRd8Oc1zIcfYC5niQz0gDGfdeUB/Y0OJYNIjU3XGMOw9gDs41AdY4WvMar3XNb tor3Za0moPEhoK5GR0vEMe3TRRyPVZ39jLoFJIFQ8go6QL42Y+rnzsdqUMqvUNnUgBlAbVsn p5ZE3ZWfP8+18HY/SH5awAHBredAMxpTXxgyi8CcXrDsh8pokeztYqJ487mwivI9cywZQrNq IF5GEhXxnGnrWOMUF04voySeck6vrM4gax5JdkqzBXZl9A+4UaMoJeEGoHmbH1uWZmsUwMHJ My/YLUJuBoFbBkZfQbYC4O304cMl337yRLn31JlFxVo+hw7eEX3fST8qrkECZcXm6lv7O8j0 ZC9anGsHkfws+wUsEVJz1mdoWyeZPa/wp66mhuNZfKotjaAOqjPGyKnLvYMbIgcZAh1Anm6x rYEfRmIUrlu0PnmphqyaLUbR2okgQZROh6W3gM0e6tODXMj8As7GCh30vJ86rMFOgFyu7k+4 AG23mAwdvVKQ+A4erYCrS0IIBwKsdVPf7NZWEjiSF7U6EXkNp1D1sPdKNdXXa4+XtIW3eAd+ d7Da6h9tnbxhVvb1rto93v02N0YmJpRjNjgPEOV4zLZYi6DtJ3Je5+SWgCiYSHvmGp1cj9Bt cyzSOgY/EucAZN3hOQ8Gn7t4wikkJXztsmEHUO4QOE2UXlzxwlVFGi20qG8QeACrs2KQVEiW UUCLJuL0zD3S8+d5fEUX5Wy7nF4UkCWZywg/ijzoeByO8+4TxFUDK4tzMEypM3ySCwNBOmK2 A0VP90hFCM1cBGNW8xFkT8NzZgL0BbKuhorRAeya4RczKgDk3YQCmkNAtxpSqosMztMCI1Rm t+gzJbYLq6cGNYjfGcXDp8H4PCYhmkUi4Lij95r9lU2TEBh2IoAMLxbvrMKOdc8rcqcyGMfD 9yuEm4xJJDNoNIlUUwG09iOnGzSDTkLR+yTwlu4ikY+Zx7qWoiVfkHUsS0C0wjq+75K2JA+n 8eL8AvcdmMLhYmz2untwePqaz6GNBFLYfKGyUpgGSgEgAhamE6BkuIAOSRkgwtIssb3K0cBP iDLWV1oud5YRCDBN5zBIeVLO7T8zsbNwBIAIpzFBqW8i66o71bspCj9rdkcWs/Yy7O1xGDEp 0nAga4sctKbIRDHZP4H61wF4NNPOybC1GlI0TagU5oV2jBq/B8R3fLK7tdd/tXfae6MqESWG viGTbG20qPE4HcZxfA6sU71BzLPeFR4RmekkC56IVlbqgw5wpHGpg+VJHYlzpKTYdJMWTIfh yjyOV86ABICQFQaT1G0EbW+VROrQZLKmxA5cG3EDYplpa1dB3Wy6h1xD9jbFbgoh7CJWf/FC YTZ7TkzqO7tFg9zv2Z+f15T9AeBIhEkgYVxmaGcwuOG01IxeV76EuXIudn1FSvsOpGonYuY7 uWEWGKURPKurra/Y8nkxR4g1tu3DG1fyxyQgIWpYdGLO/d0DjIX41RY6mGdZv4rz60Lf2wEO vyGMQBK9vMacs+8DhDd7AoyjQ161annPAPAmb7g94No9jPQylLIEqIE4UmwjDOG+HiWEW5Zy BibG/oIAMLyWiOLaw8IJjeOcqHQWjsf2Hs6x5vwmAiI0sbaR3/df7h1uf6VZdTmHc7oPQB0H HQ9CpaaKITGDiBGFnN+jBDPhVTlXPV2IkBUGmeXCgrAsJXD+ff/kuAuSB90KOqfFogIrCAE2 xnzfFF08NKyUlATW9n2m9HCRJCb5e8bKgQySGK2zllxaypipHYigudPL8K/bccqWG8SDXWWZ AH3ojUMHA0s6W7Diz5o7vAwXw7G1N0GU6R5Pg/6c3cidDqmJqg6DAxlZW6gy6g9g/COft9Eq ehu11CEwvci2gny4YW7atJzmxh/RBnw8X9bZBx5zGLYE+W0YUPYVnd9Q/Re6nMnVRQR0PkqV DotKdJMCfhqBO2uTsIyBWxzdEnGmroxk3dgKUpK+MEYFd9bWVcyIqESNrvmy71Edop2vAKXA qRHtLQdKzKlCXfGeSruFace1kmd+FWcUMmSYZG9GkG9ZCP4lKUhkIIn4QsEjbnKzXlnBM07p qw0VJI5ci1qs9jCpKKEdtKzBLvYoWinGZAUhiUWx7jUcntQEpPI6LmIsfaElz81wpTMzucGN gT0/zcIQ6qkRRBi9kuvSlsAmWYa/8PrwMUxeBDOMgTqeyf2LY96NyoTimWmpyirIVbN5OHFP zQmbnwIQRMgVvoyTMYVCNYf+TXCj9Y5aMsUCtzh30pSRd2J64BpWaAlnSBbXNtJcTpTEgxCd K9ciwQpYrK0bxGgTzQ9JvOLDDKI6GsinQVRTxl5N3xrYK1tmnhluOaKRti62d21ymSfqEVf/ 9XQxZYUkukDAZJKbGdluEv21vzPGTiN2oqbB168nY1XB6LkX8/ns2dOn9s0EyMA1EMynrrlY cTOb5Cu/tThH73W9ldjHFcgSQCGsToANHGDVv+E3bLNBCoS3OyCmhGNnhT4hH0g8m6+2jq15 ES2Z9px5+yoczd+HjkK0zCYRQWbl7Gh3WxxlaK+0+V7Gsdvu2QGgSGAMYqPrJp3FJPgxTnzq CrpoTmMEJtIJ4L4e9l41iU2fQkujOUChbutMX+WQn2Nf/2TF/y4yx7DXzm3I25f/n+F7vXt0 LfJq6z9hg+d0hwwom1PMGzprVt2uDb7GVUPUbIjdRSi24eJSY1lApHyakUMi6bsBKHBJSCjS BfEEGCrsZtmtdhwgKUpXjsKLRJZV6BzTasf/guZjhS+W12y/qJOhoQLbE2jzvGimZRr6KetL srflxzDwsr0/Nhb4okEjtlKj9bHohUfxAr6vjALSS2g7SES+GVNIbbXm6gvZqVHfePYW0x6b Yg/FY7Gm8rBBt8HGVpa1MoWrJ4NNSNB5fy5OOVqNl/dA/LSCoZYw3q34y+bbcwdRU05tfQeA QW+QOafwytpUKeDlAg5wQREamIvKlKO4V8K518i9MCGLRFHJzq/nlykQU9JUaFMiZ3q9q2BG BaEamludqWJeTjpn5vEyA9Ay98yAV7OxizKKbwRJ29UFABz6m06n8Q0O8ese4LJ1S3wYJJHh GqEovZ2RknkzoUduj/S9SfgXzWPKNi6TV8eyaxNutmEAx96OhgOjoa/MgIZcBwE2OiObNq1v zbl6kRPs91F4PsZUW9pG3rmZV1dXV+oCEYdjH8CN7KD4ufWfrC/KW1bn3R74QnG1RdZxiKxk oTSFqamv4Rx8gzptgKlLGkaXGcsBHN+UJQmNe5Z30H9ymSa5vNXbV/I7c4OdChxB+a+jdIF2 E8BzbmiHBvZwQdaqgkQQWqnadlPD/Tzk1JigG+h9sL/1t8PjmvN79+DwmPo0j4x3gpFAEBgo 4HbqhFvRof/U26MYxbVoylvl8AfMdJmzQJwoiKpjVCObawwyjLVCSzq8CCfIjCE/GA+fZo5V dtrJ2bDZWW/gm5r8aFIx8rKh3+xriqInNOVUZ7v3jHKRnIZzxXo30+FFEk/xEhhJFKGKq3CQ RnPLwmRue2twyFKF8rC58ketfDyOzzFONFl+pUjr4SiOQ+IATwouy1dJMEN2muQTo6wRvC8d GcIh6sGfUfGDjvOkxCMVEWtHkLNjFn+iL2S+octsx2jGtkKRZ+Or+sUcWCmaLnFv0nglABYC F0DhCmiMQLN0TeasFQVqzQRT2T6AKJPKZc6BLek0oKU5EBKMoIlLFg3fR0z71urGvsLY5OAc yJDuGZwzoCwFrcdKs96sr6EdWECnbTFdESYH0x2xIopcYEbAFcgbDpA7vhHrIh2pQlIQj/jY mphbDXI5xbvwulK7GHIyRf3GEIgjsjAIArjdsPNo+SKtsaAKJZaU6M7E+ooFFa3FqS87dr6y Q9q4jTILZDlIFrxXVn4WF1yPbEP3+RJHQWuo1Pk4HsAQhcF3RCur5NUyPcxpBlCI4z447GOC gP7rvcOXW3v9o0MKvtNjLY1pG5Z4Yt2ys0K0tSxAEd+xDmPOyomdoN5+F7yPgIPOVtMepA5H WVaJz3lyvrAKFGDAcayu4lxbmSJ/QDHzExpxbNAnhRZErPhyd2/35DvYi63X+1s+Rj7+GcS9 wMseamtj57pERPrsBUrWDtlceElkArZI0Zpsx0bvwiobLS9IgqyOhIKnY2Xl4jEFF2FT9Lc9 oHJx6hGFKHjR31B7ixSRjiCZraUhcEioIrhcjNG9QhQGrsez9sxCJ8kOnoUrYKhdrpIQhusQ kQ9J4jhH0FWbY6GFyhU8hTVlPEPE1L2WcY2KfH6B+Vmy+3AzN0+rbtK6S6NqItyAumo2kDwT 1hiwF+kyETUHrPpnXR9OVJP5DIq08dhNPK2YNheVBd4axhZTg4xWIuOYWFGypJxbW4OZs1rf NGPi8PZlOJ/7bl00LGauSQsG8kbDTOiZ8bqO8hmfGdqoDY0zalb3cgtpvZbxauhodJVqVV12 JzTRxWsEinKUIgY1EheckgneJ7COt7hkErFe3IRg8JIg6BUKXgX/eRxBc8+YMMC4ojNcs4xz zj5fMiHiF1KNt0VnraxtMkePY/nDubHNNkXyY5C6CFjNRWtsI5Dl6lg4c4HlLJoPxu/JvwsN GdEe6ccYfbszl1c5N6PbtQ67FruLexEn6bbrTHfG6ChGAbyG8SziYAqukylt4Uu580AfuuGc NVZD4y6BXEoaZu4Q+hz0VGNLjoMEQOPchO5vfbuDaksKyQ2oPIgSjNsm0ZPCUrxFOlCthNbX ucREUdqQYPqeNvAkuIR2DxO8fLsRi6bk/QIe6SWUpvTlq851mu0OK3L4JHqPQhBxhHWNd4KN NcPEZ7STCIVvjlZOvwWcPQG+TANM5oCSRbVo+cnokm45kFWJnsZS1GEt0lBCPwr1Ouw9bam3 ByEO6b0PW+L9wKaEkmRkqYXq5qkxSbgvtnJwFWaY4jMtg5f5UDwVrREhtUvRRTlLKVTWshF4 YOJ6K1+TZj9AFmIUBsLaRsZNGQ6k2DsbUxBtXS1eSNpYWr19E6K5ulE+XhiNzMkiey+BnMWI 4mCaeISu4bSx1Nd3HAEZybLyBzCKFMWsvXKIHYypKln8+BIwm2ODGvCRYpSO4muiUXZeYJC+ cXm02MHbR9QblXXAeAVRmrO6kG634xnezbJ9Vsi2vBLkE88xziznVAq4XU0Ww4uya95gKHYU GDl/KWMOvrO7fdL33N1ekV8qGrsjc2HO8BkZhmuK3qfQQ/1vtrt8E0ladnqWY+Pe9mYYjSKx PGdko4DBEapToELNg5JZi23aVXI67bDZqPFVcyEERLGIUzA7V3WkrvSoLbS7Qs7h1dXSobev WRoO5IIa/a3e/tcSPKNHhgR+0mMNg1wLD3tpUayU8053h5aPPkFxFYBLo5ALNc2p1Yos3a0c G963NNCA1dy3rLmIyDLKLm/gsfM0a0TmspNwMpzdsNqBJ022hUNAU/IKzbhTTMltYu+JX8WK tUE32yBWUESnnABa4q7JRuWuD4QRQojZoBs01sZr3LB78GoPs2/0To7hFBBpIHSlr01TY53n GLE7QgeLRmxLDis6GnNuMEdh/ZZW2kGsWsZgZeE0zmiloVVk4sRPSLTudIOPtsM71knASqOy AZqzNMYEjC7cS/yFBFjLsiLb8fkFAMW7mryXmDBWw8g3Tcsawy27PCXN6PxnRHBT9MHC6GFy ZS2IkJRclm0izcXb4cU7yzvVjJeaUZFouq3vL26ya5oBO1KhuxYi2pXUtTrQ6vWO+BPNjPrH udd5HY0BNObWXMMRpFmotRSTTDtPdrRz1o6hKy85voE+nSMQBy+ip9/vAZaegcwGAvB0+yJM T3KRkG9RoJIjEroby+8MLkjt5TMx7gWrPVq4rEmitlbUdxxSCb19kYKISwnJZMjHYHHp6rDX 3z7c6TobwAEaSb/hwLEHvzQBvzRdI4i1qllnwRp5mjXUoUCSwJSR9dbUSI5Nls9gx0uxP0gz oLOUcaSBDt9QA9blXxq06I6MMSidkzvBnP3E63B+oRti45gkCulkFGrk94J96fK7lg/BaoON 1ZCZC+VrNJUvgErom+uwSTotDSNs9jGzRl0SHU3Yh4qWCCgCk+ndYX1enx58v0tuYxKOmvQe TnBOyzT1JxJ9y83FZrwA/BFm5vWeKIhraot0PPbyTzPupGYia/hbGsJQNeqt24ScMROAlPFb 3YQ6EuFBopeSjmC4UbzkuO0eJOPeLFqzg8P+6+8xu8Nxt9ezmOM5ImY237T1d+SeCBWSW73t 3V221fi+f9L99sTc/DtDSjVaNsp2HTVVjKtRYDe3bK7k63QaO5aGZFR7TaqzbFxCkdsXU/Kh o1yejnHisQnuKlXIU5OaYa0xV3eu12r+uzXnktcBS5zT95jaky0frROupXtGeSGuAHxhb1Iw oXm648x+RIIBwkUBQ6G9SR49uV6rjsFYLFfJ0XRFiI2l23KBQEeaHI88kjyqVASm/xZcSiSK dIFi/9tv0G49zfOBo5hYOVSAXk7vCZT34HL3mSGRkDAE+iuDII2G+n6HovjaJnGdfdF2C8fH Vsqvc5MDKWcse9y1psB0rjGLY9QpDEoeuitTtKgga3FkHOfRMBz9ORcpS8ICSoAAw6bWrPqq 5mqzOhkTBtyJ5csYedBxuExcIhAcjjqNxgWuokpVyC/lu4Ot/d3t/vbxdv9k6+VeV8tLZK6K TApQzGgepOSnOGNPEGHoCnWlKhwD6zJIt6r7vYxkJFpyK2HJxUmGjyHchDXd4u7p841Aq+0w ow1M3eiNMrcTHtFkFCAqjtJo8p4vDu4teTnWY4ikLoJkRBosNyqC4wDkHGxtlE9smlQXvQcD gTHMF7OijCd6RA4ttJPPNbzZfG6lbB2ADmmJ+S08Ad6Fbv3gK/N9+WM5eQ+8XH0QFIORtT3E RxdYTOfnP+evqcsIm7cY36f0Mrfk9Yb3EINsEIyicHHt3D3fH+/QjRqQA8OOOGHqTfDI3H1O 0QgObzam0xCRK8qCVvikU7hItFqlSN5wzqR5I/VO6GArh+U/iscATMF7p0cAEgmRkYnOqE26 v4qg85/HnkjU6FULmO1vwXSBQ83htULcBSNm9RBvYVBkEHYkHJxGtSbkslUPGXRIaQfZih0v ArSWiDSuqDC9Ae4XLyDRmlwcKugedoxBMIMx8z3T2Ii6rFlSKytLroJ2+Q0cn+5ksWxCgOJQ xMWFbCr4WsIJJRJQpCmy+6TQ3hx8Od8PouJikpomRf44gH3QtGHVVb8hznXPi5Y8n1oR1K44 ae9NsoFMSEvSMIj5ZIbXdo1hcvZ76GbIoQa4DbGrk0nL3b/SWRwic681myejiAS0DK7OWHxq i15fgs03i4RNRr/SXsJZjGWcDjAD+u7XuyCexSYQnk1knF/pBkZVWysu9elDcN4tGE/r0a9n Id4xAU4dOyPUviPW0UzSFa+oI52YQeTQWNZdWCy8aquMQ9QfqfdTFB4lIYsb5ET7WWTRP26I G49HQgicIXSiktbeCWfYi9jwC1aDnok1ZnSN3cOXWQHTe9HJkCoqHjxRk2g04pu9gFxjcryf hm2uPHVvAm1TqOkS2/77YWkJAHmySAax2nZ5b8kAYYtqZZccqFHmqlJj8gyPCOuFR4C8ema4 gINARynI4F9xo367fbFIOHC+ONTFOr4FlMWlnZLiiphuodp/iy+mjoyoF8W5Ki/ws2/3o+FF EI7Vy7pxLqHgAJRz6fNiAKvLUeDlSDipH4WMJg9eNh4fhmy8AgI0bI3m03KC/FYPg4Iae7L9 eErBFK1ZF6DnOcxDUt9aw7No7BVbGhQ0rpnlp1fds0C7RikI5N4qE2xU87tYAW9JAqUlv0Aq 0a2khg2dc9zYRKRhkEjQ20RUxYAniMnN5cMiefAzXL5P8H48HISl/A2UaYCYYHJF2Hg+WfIu gTBc9cAkOg8w1dh7106cl8DhHGFg6G3OMcc4IxImLhL9KIWLaOmTfIO0wERtJ+4pGAJnoXLZ gXLhGGzv2JMbrhxWFP0OaT2cKFzl+VecA1wzsZccp0s9Hpf3mr53mYwi1GxQSM0i1OxHU4xH kWFFbouq0Wh4Lw9D5v1gLzOOkdbIlq5QXn/fNwoS7VxS4COPDjEFrMVQdNPZbmw07Da72NIY yLBdNuNhyjQhDFJlMRWI4VusV+IoIBQpI2VxVGJ5gz4Gby8BAb9cJNF7y1Zj3C7WOXLODtwR dDxwihbXnyIdFZefmNZXjm8eXkCSO3hGxnRtRGDJuQ0yoHFTcMk9iI/MaJhLnaRurEUmU8kw kdvhx1l7C4P46K4jpICLCCFHwGNh9msOhRWdxwkeWZt1pOCFFjlRh8wVh/hG5pwUheK6warJ MAj5Wtc0iLLxFUm3p7owGruabJNnJcd5I/+yQuuiGiDF/phcbcVF09yOgfjbl+xZGX5P7vxq TkITpmqCm1lsFvgVxWpKahdilrp0O6VBMwXecUzRAlJpJRsAwZ5acebWxhKaOcVMIA5ZJ00L V3hGOOWn6TVft5hYf0EkT9x64nggKZrJxBbtN6LEkqmcaokud0bjseFDMOpBnjkx8raL5DFS C3nYUbo1zcy78Vo4pboJPX2+iJAATTPEYlfbm7I59je7B1tHuzoxmL4jpLgz1+y77xBuPkxi Wy41kXHkAFO63xprZFiofoksh2PtXpD901HM/DPn6mE2KBVDO6YI7vC7PCotQA84vG2NeFv4 QQ4TwRh1WXk35ryCtUwvIwHLJ544tU4eh81Gf7XlslhQYzWjrpBoJLn3bmjAjIYjE3sqf++9 kWkZmTD2jszzL6z+9+ZfcO/R0Ben2GmOtrGM8xzAn+bhDJwlnOd0TjSz+Tavrcg203oudr4I ptlXhbsDMobQUREItNnshxxJvmAtM3qyuFOPmd+vye3KmbZMnITzi3jk5qLJLiM2//32cb/X 7e60bMiTol2Cq5liom8W0Y7cybKFhDcdow9U5Yeqp3ZBz0e3dBTcwlyeO7WIGTRYwXcwSjOO OJA6QfNaE35MYwyLJnBKRQ6m2GRzvd/cyBXNAPst58R5VRy9qO1s9CaLtTg++IVrdGH9nCju E11YsiJm5UtUB72t1+vvFFnV7x70uscnZNtw8Nr1HKKgpCD7HR72kamhxVltbW5sKsc5Gh+0 axYqmhtkXaaBIwMJukUj50qOHdE7NRhVcepSDLvP1zqnGXLE0QWde6T0ZjoU8SJj+eZD61u9 /d2DVxajo9k/ORSNXIYIGDL0H8rGBIKJOFeXnLHDTkxCnFlaDI1nb/Zc7xeKb4vMbx/1z1mO dy5Z9AI05DwXlRm7yKMyBV29jb7RRf3RXCiTbkiy/yE/wh6MOoh5BtfTKrLtkcTXAmwhMU5t W0UMFrAbPl5RUch6lbH8e67OI1LEMSfIQb+UJsfG8Z/D3lIuP9hyjnzX3+seFIHfKsvIwhdN Kgia8Uun49cwuO5DJqGAe8BdfsfyDNnr0953vebGy90TF+T7cGzhUb9P94tOFoZBOL8CCRFm CqeAxrfaotMA7N8cOd801zryuNmQ5mIizhYVcpakBF6Xj1MxdNUKmexukj+c9eAVfIvWZzUN +8bZTHgU41jjGmO7oM0ahgsAPivwOAzc7lSvY3OjZi0/UjzNAetKejuHvcxxlEYzxVdV5XQa XVcZBzSbqiLNrraqt+k11jhFr/EZLxVPc2bPHCYNWW3rTMDWUZ+nbrxRc9oyx9yYOeTjatCh hzeE1S+dwDXWEYPNEYHMaYtPv5GWICM7lKWsedZ/HnyrksU4F8kctxf5c+sq//YlKo/OYvJ2 2w9s+LCiuCVRjjPi2ZLjOYJUwFg4WUsbbb6YQQgZr6Ksr6xnF1cp67x2BFk1vm3kkOEkTzV2 wLmAbbcYPt6SJ6fAaNhb0wnfuBkU6GjKhihiG3VSznw1yy4XwLA48xZpWDIzd11GD073c4YO UzQAJW9GoONG261sCHECFJvm28OsiYUp5zfmdO+oQyIxRefiIy3k7rcZM/iMvOdCWPD+vTVK 5euPQMLuONvu5HrR547tu9HLYUiKXmOriYER3DRV47FjjvwJsGRnn2v5g2djjydAK4baCwbh WDQkfX5U7pNi1glwobUnhbKAKZx+9cExNuIkOlvfvZUVujqT4Df5UtB2OguHmFwRQ+WE4kTD +IiysA/fU0oKX8RCj7uMa8es4yxlsn6aKEvEdKBOWgz9hYH2hEQ2bJuZ85jzdbBFQDqMtYq2 vx3MIrytkTuavPSQ0YRTTuJcPB43/4sLOc4VmTi7sxm/2MnuB5HDh+gLIjouTMctJ5ATGkUR 8fY4Hp3DVFzW+tW2Oj3ey64Jh8DMBECUvnVjeVVFkTXHkqd7hBTlTlB8NIr3/A6W8mGnQm7c A5DK+jun+/vf9Y+7J6fHB2JJZXARKwRINclsAHKnVH6nu71ntxwZDb7ItvmXl3TIRC08rmbm 1xteIKBm4jokIVIqHdBBwiS5sa2L90RihSZ5CDXWdZ00xuElHGIKzCHauGO+Uubk7BjgfBJw bKRkHGqz50isOcmam1p48UKRy3Az20rLuhybcph6UDKka0eVjbWvJH4cRze2ZgbGi4alU2fj SVWkJSdJUUzyBp5TjHl7dnZb9REnHASxBoife9bf9uLFz04ZQxB1CQ+J4dvyfRKRMjQmG1Ce TGiLQeXNsHjpvsEl4JqCxVAdChvGbBVJm+yLam7y46nWpWYM5VwTv5qJslJz7PLZru+YTJs0 9dUeFC6qM7o5u9su23JF/u2oEZLlZtCQlogjBbyGmQqdbEXzOEPXzVHUAERoxwZOACDWLDnl XSB1Np0qcarNVjT4ypmG0TezvwtmXJPcHmJtTJIg9IVmWRSA0QQTA6wF0zjhYMm5qPGcQw3d /YFjGRP20ZS1gCId0p1TvXenuDDDXJo25kooshhdkeE9c8oSp6Hdc0lNA9Njl0UOuAitqbVG Z12iPEowX+fwW6QnuVXYsdTV0JtbD1uWrEobYlbqwpfLyb0GopJEIx2tjcMEjAK8sA8Gms9e plO7rInQPJeDmDPwhqmNVj+/II4mVctI1ZZ1MxNAoeMbiddCwUkwLMI8QDe2FXnshEzO3g3m eFmrxvSZLutS1qMnx+/WCkxxHgDyKmf3NpRwoU+9RryFBtfUzR9sXIN1cKgCckJTqCxmOkBz ZduEdQtFgyA5I1sk4rYan4n1hzzewf1A8VGE6ZBilUouCTFN5rs6nR8lHOkWdTBb8n7jc51K SDjjSJ0yT6djI8qJtl4HaCFC4dYTajxlMwyMLcWoAEFdImfqbpnKWnDOXyiogJhfsrc3OoqV FbTncueu+EBJQzXEAWeLsXVxQHsi2B70XMQp1BQlavGMQVwKs7wlxlrSxy8fr1MJ4lImLxSs n+R+DI2Fi14zVQnr53WRDMVIQ49jn7PCBiPRDaHj6K66AFrgBQvi+yvVDESsG4io0YKwcVq6 OD/nOGUiMgAHOA1vFNlH6fv7THgX7QySySTi2mjkMgY7nKONw33EITY1mzMyPivGWUUvDtkC m1jk8tQ4x1IOKvdaN5MVbslNncp6fZ2PXlLjOR68S7m0nzq531SUjSsEoQQxjevmWb64OOVS LGfH3obKswYXKjmhYSW6LN87TDHihLjgIeKkTOx8F81V24MlHbTMiVJthZvv+ztbJ1uSVg9B E5iVIQ1Ax1tGyzejTzOjcDG/UIn9rW9d2zJtLFnRMp9WSdJ6GjM7o5XgmC20MbksFjUTKMzm GH7LJks7YmVttodYVOg5oymJRLmZDe5sfcWpsNFEDu0z44JB989zMgnlgOfUN02VWib7l91v Be5Bkn8qMdhmcLCC4YW5Mxa/7qzUButuK7NHvGtYU7BMdJVT2nABgO70YPdhFSn43HDoTh4j FpnAmdlhak2XxOSxqgobFIdYeQmOJ3lKhMPcxzA08xhzm6CAxCzsmeaz1Msb8ahmMdOpqBnA YpJKvlwgm3qKnCQTojiPgTunlfHPrnmZqgQU/16LcIZ/lXlmM/ZaeduaENjkQYmjv7VEBoEQ iHOEp9R1+6+RKgDoFoVS4BzcZ/Z+xGhsjNiRl/pNllvOo0fjXiExB80xYQ6cpY5i+wA0AGj2 3xBXxUFkx8A18bKZ+L4UlGS0sgKIIR6ziVSUWgggQ12zJzvZYCkuO1IxnGv1mWEcJEiai5Ud R+Ws+HL8ajtFfYGxRMXzxjr3QDyA2U0wmhlbOjz5aO8Rooe5VCTffKrzff/l6SudMJRZmLMA IDM/PEl7zcIokwHDZ5N/mo634WSmPQPByO1QwjRrqzCKeNzH0dNqn3EwuXO3BseKRqQoESHQ 7oHMb+xVlL0bM7ksdGhRWHGKQIYsSzBNr4Btrbo8YcEwSxz1aIJoBCAWvjmFs5QfoKUNlz36 6htc5h0MdrPtaBH2BIIsJ+dGxpZ7e1iwp0AF6cJes3NOxG+tnXBTpmaZ2aZEMzLcbAsX4vtX x90uRaVLwllI1AqpLV3nWfygjZfF/Ujb+KR1MrIHiOBovhhSxURS0QeMRzTQMdIk9u7V1VWd gDxOzp8Go8soBZS0gqNaaayuNClS35LOFkt1h5nULJXv+/tdyWFbNeMz4cI5ur6b3dTKcMJv czaNbHhxk7GB15RLos6VIhIhBwsMO3p1s2+6cw3zpWo7KivNknAOKGQV2RE5cBPH8Y1ta32D Rcy6qmwpE+cGycIV2kkNwkzQb9rI9Wre5aCJNxRyQdHsdNq4tdjEsmW6xXBZTh4OkI62hFMi 8+YEwXMAhWaoZif3WhzkECRu3O1lVcGwNrpt5rcElWAI8qKlcx0tJzmI1040wph9e6F6Gc9B pLOtkCquXq/XVK/b/arf654Qv6CF8VEoJa13NGvlA7SwDt+ryitg+N+rV8EC3d51uyhBUsBo m+6ZbN7YDIwMgzWHjygN9jAcnzkPYeKVv8HRHI/PidUNXMMjilWRubERQ5/KyySCJT8OIspv rlTPhptGkJ8ASxHC9AcUteDpfw9wCQfx9dM0PpsDRQufil/iDQUQkH5dRmSHDW9WXQsTMcap vIwH+H4cDIOqp+r2kyeUHQ3WbpVzD5e21YINCyh8PEo9ICBgeyN2Q0AVhk2gyP7XbPAMFLiB jC2zzchgk/0hQM35dJGqN/F4cg70BdtaEMeIZg7db0+6xwcuk8GCmuteipoonMHL8LCnKr2A Yw3P4/epzBPjgNNFFm3dknVF0cajYl9Mx3s/nINkFaL9YeVvQUoYeAr8GcHOjva1EPab2Cmp DbsLIzzC9ZirR6pQV6oQGHcPdhTmWkaGWcBak05tI1zZokANIB9F05Wtle9Ajjun+XiidtHA dZj4bVU5ATHxJECrew3wgZvsMx863WZylDt7vvSuvMbMHqm2JMOmwglnoVvMxecDNeQ6EE7W vt1XnfWcqfiC2diKmWhVlZNoAoAVg5BbA6EoBsDai+PoxyBIRho4MCJ8lOiQXqhxxJ851wan IayX3uJ/RPHJv17LV0m0aX1fEzvCqMvEUYr2K1+H0Au8R7GsPsxoeoU4vR6H02lNaWx5dDO/ oBsvx+6T2DBy/Jnq9000p/4bcGCTG/XmZjznQDGZZH4Jxg8DsD3GUKHfBOP3vP9RNvoaCH+a DxB7DTe+FppZ04nRWr3KQQSnlOKG6dVfPovjlfOfl7NmNlj7eLe3DZCD+4J63lzdQGJekcei CeCcUUzCmahsTUcJTOv7YBCP4/nUrKqYnmPjF8R+MI5gO+H9CL8CngT4R19POgN7wTT07InR uNMWZraIOUGdASFD0Sy7aLIbC3uFaifYVoD7C4yJEL0fYx1qHEiniYeKS2fDGvbHhHgYQ7IX Cocb275I0CoHBtabReGY93A/mALT5MQPmslVxeBGFSqgYFC3YQnEH++ZoMJlEv3Z1xFjFz2m 0vtOvJxnEleHY21iRhlPEVK22rjdj5/JaRnZxMWorRLPHJNiAj1mublcA5N0qJtQyzrcSjIf 8/WryFHLbCRELceDHxmIfK3BcIiIoNXRisnhZ5O1sJNnNBaJR0venpbCyXVNTee3PABRnkUx Oo1Gx1yT83QN1BIg/rDXqtbw56MkvZ7OtVXJ+RUgT20tpDrX6qk6ONEHzSh5DPXTcjzROyA+ Zxw9mP2dt9ny6ukEsOFikj0C2nGp30dbGSIY9M1JN+iCVxEKayp/oubaCMAJqptD4wfhFaDb SbXAkLbIZIalDWZIGTgd0kSaXiRRSl8tM8c2CFKWQ2jnClSmwFUBUx1NgvOQeKqfQZzagSXi bCHCRcGJzMYfNlwxxQBIRRNtItORwSin67kwmn3NnEs6zwC9hs9Ci0I4nipnHY00MSGb1jEF +ExnYThaWcy0cOleHORZazRZJIfj6YoTJ1V46S1cCNUbXiSLica6K+l81NSmWlmPNYrd+Ipy AHPjomXBLueInuP3Sfhj6oAknUwSphEi176Sm86Xp696u993PXwEQsI34TmwI+qJIupnNzxO neD/CNkUfjx1zPu99IC4V0PIM4wsauf6va/X6q39I5jF1knv9PR4C0OlB9M4cXlVNGHT/OTy 9rKxIb2B4zbRjEWaPUcTccEg4BtEU+Mwd7JNJhji2saDBsH5q8VMa1+FE0XvPTvl2WLmOPXN kPM8PVK9rd7TbXV0tO00NKbYkQ4fxWyITpHB2sIXICoti7aC5CDnQNLKq1w0Aqc5W3RlRXSP n7453O8ul7BFnrDtYnki6uDyHlmPrdcgDTjHWXZl4GkBbTQpiOircKCsFCtMQH+e9HEhbvqP XaX2hehBDH29ZVQyL5ZLREGPe30RLggZDiUK+0VAwXcwB05yjl4pKgSxWcJOUMpa6IVQcYjp cOZ9EKtTRi0kcbNyDW8Q16pyS3cOskPouMYCBhCcovVAdH1idBl01uusXiEKQHuI6wTkEkHS LIeY3GrTBrs0/RRq1A1c5sgekiXL3VvuygmpQRIliNc/R8ij5LcKWLDWmrNVo4ybeu8EDso+ yUE5YVHjvQo6P4NQcyUcEEaB4MC2xlWqSQ7+BldrBQu+R/V6q96GUeDGa7755eJCWtOmK0QI V3a0XQYGwQ2zVjyEfxFzTijwHqmlEVUT70bctbmpx9DjABSTYPa59kpz8qKyW35lH45YOFYg 3SXh8GLODLqO9ohAAjh19+mhqGLSrGl65nTRXTFdlZxzqgIYLeaWRh0NelIQnWE96Zuj6pJg zUBbTXLMECdyAZNXJyOdxmVFQc4hl8Ye/pwuOFyEQzyEehMmA8DNF3kQadQ7ZNqDIKK1UgyK QIMWcn99/jMJIe7tpQAS2RepkLS5gVzxpaTxQVqpdqLwPfSWZjVJ5k5Z5B4bNnViyGymqnSG FxkTUXcb+xOxjWGLfI6fgVoNsghB/dQckDBAHpT4Ciq8z7Bh3W+PDo9PGPy+lx8GgPVFngQ0 IalCHCJSh1NiGHVi0F7UlKaa+htle6MYaumEQZl45+yOusI7e7Mhv6ITpJcwI8Dy1o393Pdb e3uH23ydeLE4Q4wXjY09nfiCcCHnjPc5bksfxodX4XVdgtRxbMelU1aYYN4oTPWJF8teJvLl DpDC4ftcS8ypwC4H2uzODq+8AZMfHqOSHuz23lipz14VGC2yRTfWkpkwj0Ho5vqE+MNg6mAw RiI27E1Ng8FQrRxSK3SCVeVVkKQX8KI7Di4iPobGXpRd0i8c4yz2wIdDMo74sEvKZdYDsdJI PD7d+3lJNGcO/aFz6JnTkARvj8WmBkFic31dVcLrcLggjjmzsBtrawQyQ7UXXkyCqZDaYIRk EdFc9iKGfHpItHmcuSwGZu8M09DrcLs2BDZdT2Vrsh8G10FKkoazC9WbA383z9AiHTxsMSUp M4trLfnL0yJSOJtbShsZ4ywfgCHDogEftYspoWBhMZJLHhu2ibf5G5RwdPRsbJl3COVD+tQN mOpB0oz20MJSUClgVZ4VX6+PULpjZjflQ+3GpK8WMY0bbFgbhrAElDN6ZZpWyOMu1JUt/zQn 4w7AgIh6pP4TWt+LWefJmhNx4QySJLhJjRQvKi06O64yy4UdGN9ibhycJ6iFBu6O7VYr1tTm qxDZQmAVk6k0D+TL2t9Ugd+K5TLLpHO7qGV5idfdA05E3OfcAtjPskntuoz8FkOOMXofhY6d hwUaKs7cYZQCltXZ4VFeBXJkAFXptN7o6GmC/pI0Nw77emschM4+3SM3Ajw6m1kMIcgMMc+S ozfd3n6xjK9WviFYzpD6Fdg/d8P0TRdftA4DMoEc3HAyWmu9Q6tsr3JUxdmBgpYhZ8vhZDrQ VJO2IXHdAIgIIqJd+VIIInfPzC49SYa+s2NP9wkmUz3pH/b6+1tEvLStINk7bqG609X8O+hl YdJbsn7GXix4bgyq5hqJ3ZjkfnyRPbw5p56id4zjsuREuffJkOZMmZO0fbwt8R49+xCOBC5N UsZlr+mLtHySAFtw6R5CeiKEjug+zSAjOvKQxE/J6jWEFaBhotsp+swKXFKcuSeX05i9TnJO 3Zn0F6ffCsc8vkL04YRHySNiDDbUyCNizUCyBIhX4oMkfs+uppnLyEwYRt5FqohhunSa82BA RiAhmjxEYoByljFAwYpkbINc9GK6gv+co63cNCswILsi2Su0DtBRt2DZTDhL1ywEDz1bfyAF ZB4U752Kh0HUkFzk662M7Yb3mocFygDzVJyH2nUFryXeK/FfqfI1efbOqGYU9UBGdcYW8bcw QYTM4ZR1zax/4YBoU1o2ZJXrbY4iHNJBHN+wxTe3ldocEmidRuZrcuFG2dZgnJJ2zfFYc1e8 przLUVzzjA0WTluHktSZ3LJBhabzp5qhZ83xKNUIDM3n8yC8wR6JDgjjIGyLevdqglhqwijU 5LK+xkrGmixMja7z0TpBgoDi4zlxYKlLQI9juoF8HaGFAOcI+AozxqjjxVj7tBDRp/gPaBkC e6YNEwNjrUIsL2ZTTUxiPWOIlXWuaTi9w7C2MMHOy8Xw/Vh2+UwUdNRZPA2rSH93XYmdaKkj CI5vWJ+CCJEldrYqhcbq34vaxZ7yjOmTxXXf9w+/QrCSNIoa7BZMfFwLUQPNRsxwVSB2ZYk5 6g0vxosZH+td7UKavYSyNbZGwURtxykliyedG2Jv4Zbs5Wc2d5/jLMmJAQW9M1tRN5o70uvG JhskuwaeQcMsW5P/jLZaJFrr4muO/KGFjRmqmYOxsArkgZsRPOVWFFVqA/EM5xgxGHR16/hk d2tPImfDFr8PZ/Ni2CCGHjwXa1V3IAAUNELZH06uxIxKMMMMHsZBp3xMBFlnISmwiCxQpkS9 OZQI/QYIjj6Ya3xpez3vR3yTyRZsyJKgC/ggdFQrI+NXIpF4HD9vJbmnrNW2nHHRJWDrAG0e ZFI5c/YN5ESLsI3uD4DKAaTeHISnUOQWOPC2Annp20BjpEFGbO5kz6CLsZzYguubU0B8gdd6 f3Vvar4Uu3ylMLiO0V7YRIvkqgDcACk2K9W625F2/KOuMhjoi/f4668JOofVr2DJx/VwtLCd bZFmE/Vv2ua/EI+JBPdM1DBf162nCjs/uQECuPf/u8SsvF/gj/pejD/+Opwk9WnsdDxlPU9p 924nRC25g+WjcJTAaa+rLfRsCNRrkHR+iICJ+nlZfTELgvO/zqNRPUzdOZLyWswF50GiDbGY SuK+iTZEdNnWEycfbRJvn4NkHKfqGCauvhj2E/j7V6CKo6A+HNs+32DsqThzBY7echljebHm zUVkI33V1y/rWu4RqrMCnAeMeY5p6smiD1pbuVAV7VWJVAMf0cXWSget4631pGLyUXUFfhfk 7YVPgVFOUNpiFw8nZZngYHsytNAijIVjBpfnUEYUfU9sZJ2TWmAZYIUqF4FIJUeAsVGGeA98 ZqCPZElDP3eJF2UjG1Kia0vNEQE12+UiMiN5B3gZstgQLo2dQXM2EhT5RXTn2bgxVgWfV6Lj Dp46N4iix8E+ezewZfNwKIRFS3I6Q47gtPfhzRX68hB+R6LJ2UAqYhPvx2sUP5vIpCFIMMq9 nf7e7svjrePvgIacvKG6jtiNVFnyAtHdCtsgkKct677qTbPV7tXjq9O/7Z70TtXpt0dPd3pZ iEovouB9pA7iySIJtAD2aaX3Zuu4uwODyejMpJuCRZMWZSwOXoGzpo0aWGDI6+Az0kMNK1Kc JZ0kSqM1P99pb2FLlhetc4dukjY2KEjnEmvD5hTLZL6B2hjjT1+5GtldtJ1bgJUizO2aznUQ JZwWkjQMmrTyJe3/mXN76QIoAebWQW9Xg4ww+jpaEoE5ujuQPM8ps8hSxHD7yxJKokdHY/lt 4x3edrF9HQxRT97jxo52GVxQttjcj/zcv8SbkFQMUBImYznjn726oij/aidczNPhBTGsJTPc 3jay2ch6x5BxFdtnYkwJGMoMh8tW99rLTbIGwda3SUsqNlRf42X9RTwBNmYPtqWavd7SNkw6 67NcUBkvdLn0F4WeiDXp4iyrLV02CHcFdyIG4rNcuB4MXAEaobPF3lDzK0JiaEZOgvT5z8Q2 Imp8FY6hn70w1Gerf6Yjg5pj5WpjQFL+8oWYivGUX4EQMA4WrgT7PhwPh5TAgA7/cLjCnqVk EtCbwy5NOSi3e1BHP7a0sdfsRlQxY3cYWpFO+sGJNlHGXIkXMQ2fLxVCCoAA4/h0d/RpnXDn cjIE0vceOCxcyeElyKsjWE9+ZLDvrtRNhWe3i7+A4c5HBVMd44/t3ILDBMiwnStn0gTkrm/Q DcycHF3NDeZmTyyFNGFjau81kAUEEQeuBLlgPAE8On5tLQ+b8OCrw6PuAfoxv+rTN6sepJh9 dHCeLtLkqSion6KCmrbtQuAG6BkIdPDvG3fPQopcYwggBgYLOA2R6K+pZbGEymE3ON4YoYBn gIHjopkYFb05enr6raNjJd4SL2/YovfweG/rYId4wvW6K+uqUhuGrBoJZNDtbVJrjPHGBVDg T3h7j4r4YT6SEcXrXSWlAasM3BxkSCTQkWZKEWRQlYfSrMRBOSN9SJIsZuQh4nhOsKfF6T04 KOsf00VURf04PqqkM807mGTrHYv5ISkYbKiRYTZP15INHB8OPKkq8muyRmYMfwNuq7NRZeUB cc/kDWGHUjOpmuCrluWrUADTi6Irq0QWpkB+sMLdw1fAcAG6rClRNrhZW6WefSSe/lY9Sjmx UR6+EjcMjiMhgZMcXyHM3U26r/MgGSBBxpracISsVkIb3Qrtb+uiNv9akiMw65pJFcx7iXTj cYb7ErZAq+XFGBgzFzHixVs5TgqEgsconqf0hC/f6CsexGmsMfjPfZ3MRigMZ+aqZC4y+ahA 154rNcw57Owdt6mzxDmHWz9Uj2ui4CVj/CtKq2vCTBGSRwYVYyFNNAIXY0uOb/ecNU1IOFjP Ya0ptEZCXxRhHEsM+g6NCbNh7rS04Sp6/RzE2rgoy6ooWhcxDhAcVK9azRQqoOwEHS3VmenZ 6NuIr0q0M5XcC1vXOkCmsP+xEvVLEoqrwoWETBvFlmICTz9hg7YpWqMgU6J5u9RqkrPBfLA0 hdXAOxFTWlWQmSR1EiDec9fLa3zjaKVtPMOIghu2N+Ar4iDUG0Sp9aeYDeq88t8Ec0wKShEY tw+xKTGAtXRSxy5E3EE6dQK5NAtzWmopwh0wCK1VynXNgMeL40ZsFIRv3gWOuOYcvormf5w6 9kImkzqeJXa2CWZ0Jy7VMHHxbCHhyoVXbEpq6IUiG468ufHnI3sGjZuJIfmJCbLlyVCaE3e1 +aS1LiKbGqNXEUdFOX7Hr7abnXUMh6PjBrpMll08E+gKxN/CZjTpOkc2Q71Fy7T0fTSbcRIE a3FDkYnfCQmlS2byQB0HN46EX9c2gEhl8P44Nbebgb0pDw3pO3NoKHL5zCVQZi7UPWI9CbOO JYs75L1vatQ7Hamhc7CQUoSyaWNxJh82joVnbHXP1o98W49Hx2VmimIQKTmzOe0yhvCMuv/2 +gjNcZ39q9Z0hFHdpn09WIXXgIXkrNoXV8Ec6rG1LFvJVlyLUdLvknneYqaz7giCGaGZ7yQY XlC8N9wIQm6LebxC92kImlasRu6ZKu4e72aTYGAPJAH1Edz7ozgbhiFK2cV8blGUWJcEuNDs vxlTejrvrd9/HnyrNRfmOdCQqcQ2AIxFmAu1AOYETtA7xFx+ViTkkJY8iTlBX0yb1Lqmwvmw XieCYcizcaLTN+8YC57Xn9xv4C0spsGLFSdlBEyNgNrKDyPtJGcSp77U9yj7X33TPf6ql2OS YdH2v/kKX7DJpvXpJfSvwx1popBFungijPmM4FwSmsk2Z+6GL5EbDYl2qxymKxsvJ04yknfh 3mkau8+1RiBzHq1W5Jm0pBOWcZwubZuStZ1RmfgtnEuFg5zhmSXNIvMBWgB3Lvttv3kdI9/g AD9szbyXbfgBdvsnD+18KApzW2KO2U/Tay3fGjmD8YZDmawP+saaqxZAsJkz1wkz2wYsa+lZ Vh68s/LWeHYRMCfAVlzfa0XkjqOPqpiwAlaGdVzj6e6E4YXsAjwXeyTj2FTQF0GR+3Eac6/Y +XcSEjETO3VjQaWzj+lwoksrOuIHwvn5OB7grVg21gUFuues832tf9W5B/UV3xn7xjn+KICZ pnjFOacUyIKo7LKTPIM46j0VDoaOYEOYb953EB5Ww0g10ZRNslGk1dHanaAAMM2LcDwz4Z+D KQgfiWbCYWtWgBA/zZj44VN+gq7FiH34bkJPjIBUsNwKjYFWgI2SDlfZMAn+JXOAFdZqp/Bb R4kNEuZsV76xsWLhB8f+W3EyCax8M4lIdHIeLhtsIJ7t+ThCxpvdgkOXkg9eGUPhTAwgTumG hN0YwNuaSEXOIg5HVflLVbGwjcCPMjj7IiAG0lb9g/AmxigVU9EvzRbiriyhN77v97472OZ7 UnNXoNVQju5qyY3H1O8PZ+MF/OcgMuQamFkmRMTQARzfueQBdC9zDXkClDIhpZAhURlG8smT pYxFORwwCfnv8l2mNZ2BGmNJMd2qsNVTVVQqZDi7FSw5RojzkVVOF4QSXUq7sZE3PCAmfHU+ RcFEYjifYfAwBEIdASq85uzjLEDxO1ZZYRsH4bcnvZPukQA9msf25YQ7UC9PzOVCYHRZI1zb x4iW0ZnjcZl9uHNVjbNhu/ifV76cpDqdpo3KLRfKyC64En12/eNZ8NMia0pjI0NlQ8yaiMQG mVDSb8cuudJ/fXC6DSLZiy8BoPh71sDO+I/rKjb41FDL+iCFcwQpLCdM40RsR0yqcYFj7aIK wtOn82Q6nk7Q+u/sU3QkuNFm02ccfAqVDtgyTttI+Wfsh/Gl2lhfB8mBDPpJMYlbTgpwCYQs jbicURaosTCBWyb+/uvD1RaH39fyExMw1tWgSkgPjpk0aQhI0u7B1vF3GbmentDg5KSTOKW1 pewCpqMcUMQQfsHWLXTexfkrWEZA0zZUbJ5Zl9UVvZsNNy840NQmeQpfIRIkddPKWRSOR0bZ afhqAHa0gufb9COQrpz79cjJFzsTUw+bgxreIqdJiq/KLhrFIsFixQHpYTgwZ5gVn545XiWu IZwjeI/Q/yW1kVi1gXHFBlQYBrj1lDWMLmSQb82JQ9s6qkvOll7zNOQ4iipu9cg8w9BA0Nr5 AuNmB+jEAyjV6Mcy2XIe41ESY3MTR0siq7I1KU5UuPVtLAV0aZRK2F7XOZ41V7w65CdIJ8qw 9fUMpKO5GwrzsiQGZDm0vUHngxvHL0x8oTWa3l7bXNt4pj7Xk54E6fvP1bNs0yg9ERUFGFSf k4/y59xMBYOzYlKDJJ6K+IwqOQIDPMcBi3bjv9DGiEiCynqKaeVsgFwycCBIGwGgcKkGBzcn WayrSnMDkzSozrpGOCyp+7WASJmv/v/s/WdjG0eWKIDer4+/okcTTEgg1LnRSjO0RMkcK/hK 8gR7vNwO1SRWIMBBEE3P+v32d2J1dQMgJafZfdfcHYsEuiucOnVy8Eyx1LwLbvA1J7KrjIfp 0JRMU0s4qpOSmySo4kXc39u/dzDwpKullQ0YCOQf2ZcIMxQjVF0q12gQpvyHVgSkx0nEZsu1 LdujYCOXvFN/CCWQpTqWXWWkqyVxNMX+BI8Id03uvmoivatR9Xpx+LeTv356/PaNQ+JpUkSk CyTN9Asn/uKvs/ZDRnk0N1O9oerKyYjCCHw2UbBsXBoyxOgQGoo1M9yJzzGd9uojwQnH1Mag PWF1x2zaY7pml85RsNGltQup+YWsL3xOg+7rr0k33Se5Vu7yJXUdadvuqvbFbRw3Iw7YisC4 XGxRVCdtoUykNOwupZOirgReo5La060INpTNMaGgJsJEZ6XN7dLGzI1aDxzs5hQLA8JOrEDT RuhPzbfonNRVsoBCxBELcywmp6AlINnQcoSYhNAzFHStsCj9qzJI1fE6HaEGHXLGF84NhusM RZ4jHE8N8q0dgfYm9d7RkAEK8DF2vWMOza9LTc7RhqTKPW3ELDOwgoYIY7YeElPCrTKvNojd DPUfukJaG1o/bFtOawGQdjS0iSzQREPhNJ8AU/rEsWD1Lwc6URLvz2sAHN8O9DHNMXwUVZLJ UrhzF7KqsylKdVQXxET03nOFT+yf/K4geZ8im9yYzj1ueVlOyHRD0gnFEK/qyewu/HfOzZZ7 SVsYAmHPnVCXpDYJ3D4rXCc2JwVw6YupLknvqT7jFsvl4PFTje5cVGcTNElQ44Ee5EL0p5Lh OWnx0E0l5bUsdWkWG9F18uwY33lM0jwyZwlSJWMEoQzXV+5ZkfGCclzVHCsHLQBpa8eIw0YW VN0IHZy0ZmDoJ0z+hyR8dcIr7fFiRFvVfVNhRHaqdi0UJQ3yUlFi2CyyyeV8vag46MSG00oV mz7g0GTvAO6JsCes6ff86C9HzxFmYz65nGs+YPMlMrC28W+uzvqkFY/taTqlJJcOb7Jktpu7 JxiBuSfaD3o6P51UDiq94bwUtRR9dfL0y+eCxwMiudzVVGlpNzgcKx8tz8Ql1DgVI3HUoeDO skLefWHmF+pFxN4i3q3pHMee1re28ggyvfdBDBzvWtT8TqxIiH/sytRcCuva2cdPJY4KybRH 3AvzCEEYoORXrsQ3FTEcG9qTlKsmFIqPaUNAxTOBn9BS0fGAjacAaqJ2+KMsGOwC8VAhxmy1 l+lizXBsSnEitB1VQFs6u+/1HVhk226FGttp4cxKIPC/BebnYVWXS2k6KQZfBO3IVdeAFYLy PpGsYAX7fhp/TnUrRQDBQ9bIqFZjxUQM5SX75KHlVNHNiO6NEllD5a/DnsYq1Uq1PHkXaTBD NfcOL4DyC97wNNRP0NJT23ihd1ISEtE1iDl1INjMOgcGCnoMsbl75E3nkrq7Heit+1x7sbAT zDq0MRtDtbZWiBDE7UQe7rOjTLhM6T14gI3glmTtZHfqGRYY2rdJQnRmKmoWncH4PQBagPz/ vWH5i/C+LbSPf1JiiiYoSXnmyiywxwJ2syDl+ZjZPRZuWy3mVxg6zVe21acLMsvWbR+cHd4h Dn57Ql6eNliXbZKSWGFDIDRt88UbdV73MCLD7ixxByWekhmI/flONC+rWDb5/N6+91ZDCbjl c2H9o9og8LErtPdl9mxjYu4EIEk2UrefqSAevuTzTyRtQRC8tT5gSAyV3D7QWsSrA2sFl/Do ObnHWYrF2ztQP7X4AMluLSMDEh++fgkSKCOxx3h8MxLfJ7RxYmm13yOF0/ahkCL8ww4YHNsE vm6rzTJIRzbR2O1qZ7mTpTkbE1F14M2r32mQptU72NxEte+5Yh9nF7RVB5FTn373dOLYYdxa HBpQMG+oxBWOb8tbWe4xsibHToV/b18vRkFdFkgowPSA/uNylVrjsX1RHEAOaeJIfjKdDVoD iU0uxHR6sZBMZpqUjqVN7V1TgZI0jN3Xogf05B7NhXuZdnQ7V0cYbcuDanNyWmvAlUE/QMsw R46i21HoKdBHKxPaTq7AF1gfr4ikCjm35ydG43n5X7YQEksQZM1F0tSWGuqovw6fpg8cdtyG TmO/MvXY9E0CapdsVVC+4p9wesgn3fISnSaVgBufqHP1E8wgYhqCu3v+9uj10RNuOHry2ZdP n744fHny6uXzv7dhi/07Et+zJPUWoCyV4VpcUQejoXV7dRxekwu8566T9auTT5+/evw5n9CQ yRMa8zYOGQNCqE4VK/AeSpTuGUp/7IcPvXELeA2IIAcz0ikHZAKYV1JAoFh2QDWU4HssMcA0 iSPPEFWoQzv82d7ls7Y/906fa7uqXhYbKwcUUkoUdQEocHWthxV7xc9XisxMrFEIO7AZfd1M Pwl/7NyTthKnsxivP1XYP/PoXtdty1WLObqei/ucWPO9TfC0COD4Calgwwz78Dqn2MKoi4MO rSXbPEhq/2f3Tz3Hnk1c88Ys7qKXVRyw4Si5+/Tw/17z7of++PCTpjH9Cz+9f2M/SML/E4SR n8SJHyb4XJAmUfp//J9g7ht/1qgvw5SL+Xx13XM3fd/f3P+SH5uEpz9Pqfcd5TofLt8BGv3f tXYYYlMV5f3t7R033hUo7d4/5WstUb1ikgZSBNYgkMB+jeA7QxaHef97UoOTZJmZWd0VufIc tM4z7GjKnXpNZSgdvtF+n6O9t1KOHbUxGhNrd2Nc1crrj0mcoSn+yaU89/a8YOQdL/mtv4ef U3nM6QSo9R/3CAx/x6p537k+XLjN9ZTCojGze88LR9glkLJuZ94xFawpOqGbwodkwLe6bzVv 4Gul8ayTRgPNVAN0wsBxuBHXK+V6f552I5pF4d0nyKilP6eIFbzwCUYslNRDBN7+QrvQcx4X jeI6iXDJ1LaeREJ3IAyAX064qdfGWSEoom2gEEfPp5gD6m0UrRaowJYs1t3Wwc+LxbuZwVbY o/XybpDn2V0/wP8namRmp5OZueu89uFggEnjkZNY6iiYNoxnxCujzjrUlYZ0N7HBkkog2WVu fqpTiYxKFrgFnGk4sd4ActrMCrKV2KYMWtKv+66+R62l5txSBTV4OE80xLswHtoLRnGyk6Wb i7OknFhW0qwqSKPt38JwrtnVLelJDg9wITT6AtXPW+gH8ZKRE9o0t1ana2H4KQPtvHhnK0AV WDPivAtbm9re5rlTxCUZYla8XxqPunK6BaUcqYHdDwpbZaJDTszsTkhjtfMAcNo2Uq3HT5pO k/UUy6YarhBBHg0Af9vWpqDxdjW3OTgoJGOb8KZtf94HI9MDGuu8qI0WTbNOFIzjZ0sglXEZ YX62O+k5+wTgkq10nPWMezuVUy2tLfEwZ5hlfeY6OApuv1QPUYyvqJMm74LphIbGUXrPFDV/ Q3ui+H0n2p/WK8vU+dBeQ6PAPTwftXBXvOEwNUZqpyRzl3TDiol0s65Kw52Z4j26FooZLIHs jWp/A+xLhSR9snQoQadb0r7WnZEg14GQpGPpdiaqNSzqiIdt7UacsVosjBIaVjk7tW35IJ2M SPc89dEl088MF3sl2iJwUpIDn738koKO0WjocdDPaj6nfI7RaPRHvWFsSryE/ye3IsU6wCm9 M6CFtdGanMhvvdCS0g949I6MBURWSOlYYv3YM1vkW/R/5YHU9PV8TZHjHNIpnHgPtAeg/I3Y zER1JhAKOZ2zxZSi9SbnIBUscRhr56HOUWt2uM9az2abHMxj4VBfsDix4gxt6g5PbJIIguum K2THUhKTd264eACNRJMsL+aMp8yYufqAJy2u/kSnN1+cIh5IUw8agqIvDs7NaYGmOBqNbNKM CcrLLxYTRNdT0GoR8RAWuZ61MMpb2DCNM086MS9cb+eWImXTqfYmW16yF/mMu2W9M3vKFBUT 5/ujlfl2dcf/NkjiwT1vx1z/yZN9wu87bARxkbGSBLH5VK0r5LCl+smUI0ltWPm3OZA5/JsL j3j86d+C4HWKn460NyGaGnE4NWcRC0Wzbs+dAiALfEQtQr1Cm81syBMjK08IB+30tHFa4+0S kGAeEAkfa8FNkfZGVFIefXfvzVLO4iVzSU5PRabZimbORP0etM7EjC29ycMtk0sdITsv5gAu Flcw39/hYOhI0El2UVxSJnTrIUEiccplepfrUjjZED+lGBMaTkvSU01T580Zy/LzS1oWiHaf URAACnZ0MgU50Xrx37LEtt8J/Tm661b+s0/AsDEPS7fAZjnrmG6nBVwPzicTHJKniCQntJUz 1txzJpfB+BOYAk0rQ7ZsA6N9j41MYL+0g4pa4wihcGbWFFgZCmMWHGHmdC7x3ETJFvM10kjb tFB8rTyaGqKUbShXAMolY9jI2tWQ7hry8NYTRGVkMfr3kzYvlzjtb4ggwAt8X+FsfquxqQ+Y bT0a8mv0+Ii1D+y6KJX9KcIPaSWZTCjphOpiefCWYBeO2mpsuhVJwVrNLyxNPkO0IjAqWaXK sn85ev3m+NVLdRUo3XEYK6BBgjeb8LholUdWLV+tVvMvnjyVe/1XY8VBOvw10Fc+Sn2OtkgG UP7So0Je3EaGH0E9huUQ0GXueX+em6n3WTGZTbF/0H+d8W9/Or+a1e8WV+dUXAjXmDoXE82f AOSnHKogoWXw5WE9B1UO58AL66qQvR4TF3WDu8cOEx5VCT2f1+jfpldBsV2SN4jFG36LuRJ8 B3wapSE4NbScLu+iAQlfQaGAxIhAxAjgdMRaVrag2a2FOUUr6OKkQXn5hHqjkISK/PqWp9mz 3ps5hpcuO5et7R6qpYixB2D7MCjC6RDLl3IIixNk3CsOZAOdlm3ZBhICiuU9y7m8aU1lU+55 iwvsL4MiNLZ7sfkC9N491n+7HOeuFEO5Z8cS3Ds52bL/ey0LrPVBC5JWZb9uCJXzLyQuh7uR s+Ts5NRdWXLreBH3MRqJgiQGcuHEeatFYq8DpHYXoErOE5ttOpI2iraDl1NvDetz8XmNWq3b Qczleoa2d2weRzHRFAAvB7zhNyU9zY0mJ2XDrhFxcaxijrYTp0Aee+5z6+wRrtKp23dXVCTH dNImuM+crCGrvqgMqHeylycq2dpM4ZZtjW1tDNZztnFxKdvXVOhnt9zUZNZKzUJnWM07ow40 EjvdHeXTuQy+tXuqQJFfpJDKfsCDJr3OtAX5kOzqhAjtnjhCkIejZKBFwYnS4u3rWRg4yXMv AMH01TuqMnCJRISNHfjfy7kzuKzVORlnC+Thro1EKXFP60JOwxXBrAlPaH0hZJn8R4gVQyUM 7NWkPqJYuRjjB4hiask9tMaNHOMaj0zDbR5KZ3UNKd8H2sWYM+nO1zMdGc1wM8O9aV1cH0pf MdSqSBMilY4wqFLYu2D3BB2Wskvb5nVlTqnDqRW3ud0HHEUIAu9fDRVyoJBmWJORk1aZSSQx 216egttoK8p8hIWTBXcp4f42bpPqoPbw0/U3dCRV+Zrvd7f/uyMrkJ2lM5s614VpqnTgTslj un4TGvM1LsNxbROIa8SlKZpeQ8d2yy2UDrCFkst2VfQjPUNFSazqTjm9bQdjPhjKKu3UcjwQ 86i4hTZ7XduxiGzT5kvjrmbEtOETJH+3GY6WdnBxpHoy31jaUFIUlpahfLLsvahw1FevWVtb s7NdzW0Ec68moVi8NIqgV9NSoOBVsFPgDLvnE1ntFQrD68XSsEy7PCPDBPnNuBoOxQAiwJEn iGRFjnNUV7i+BhXz65AF6ZWF9jYyICAeiM507DpNvXOKnT83C0q9cfbSwQ8xItCYXH+jMrOl U58Mx49aPOO25vgk2mXkaauYfeiAMYup+t2SciXIhigFCsUGYTmuFvu8dTFF+ZQ6Cb0z9S0Q LOciChQYHFZQEDiRBlKUKd+Uuo8ZI9fRCWN0aIQ+bePOTFd8J7+2fPDyyxcau+xYyGDvx8wL KamvWoPQMHRSE1R1kM4nOKGmm2j4Hvx1q7k1lIvIXBrb8LV0XlqCCy6VhKOGal6hsddZMKzm L50JGcG/HeH/NcTWbFSzpPs7bda0oyZcHOIb0q65Qw7RR4pcDb4VK7xYW4aorLnKkhBS7EPH w+J1wBXQaWv7cZTP0cMajeJbYgVplSTnAskJuYcBy/W/DcKoGVrdsnN4aBzoGIh0pubguwJj iq8OYP/Lg/fRrR4lZ1mE6x+5W9Jk2U6hC/F9S1i4UAEETA+rXZPHskMciH7O5jLZfDE5ZW8A jTTjmrnqG2m96gyjIYoJl8guKSXCY7f78zmXleZEMXQDzAXeVsIjT54OS0tlLBB5QlYhK1T9 Gi4SXnQyjS1kedgcAnZLZhMSBGZXyLXh84HitGfOsbaTlpHiEpurQiJgKAFa7GWT5XKtMQFO YaCRtT2J16EFJpkcrBuvYzyhXYuBnRFKgaqxqLYt2LZD4tXDtxtouIlrfUIhHqv+iW4/Td65 xXo4SJyRLdocnEbheluWiFQ1GVHNYXFWSnQaNbw6kOYlZD7H9jr6gRuOz7skCxetw3wrV60v fmspCFj4ectM6O0r4n5hun0lUpxAaop0+NDximTJksYF0YkrFnRfcGTO2bztkapstDU+c1Z6 afi6n09WTB85D5YuB/soR2o/EtuLjjHBnCw0bOOU4rVX7l/YLDGrXy6MVvDqmMoBDpkLB6c6 GWsxyNvx8L/4/K9IDZ/gh4+dkKTnHZsicde3zuOPn4vY5uattRrKDqUJCTnvElXSLz7/6vgL Djkjq3RrKrwSKojJJoqSFMzJ5twSdRCBlio0jKHWR0YtG0R2Ipqg6jkAZqwSS1FVFiBYj3l+ rmF0zvpZGHLMv9SMUnwLFCIIT15IEikfKgVHu0XdcD/Yuw34XEWhyAA7cVi2IX4YtbXQSn2k HGgdOXXi0UIJjJgWTNHky5brkLeJ/Da1+ZbvNj5mm2ELX1PYciZTN5ZQxxZ/I47fs3OjwMCr pB4Z0jjF3QYlR8ybFVaQUzemNZE6ne4oTIw6KXaCqDzvcEqaNZYMReXarpfYIp+6qFAip87V W6M5fAqEoVapnonQTgoRQqcRQs+nLoggLgTrFvwOvgXOiigDevkTRNkOTXnxlzdDTF+Kcn/o PT5+/IZ9mNaFScRCNO8LwNih1ABkYCLsQFNdkK6HgrgE1xi86bNKNOoFn8UlGgE0twIvfGsH YlMgdh3A5XDZNzr3CVafbKPX8e2R+rEQqO8wjnjeyLyk7SMU8Gg7di+diHV5rCCi5TRZNeBq L5ZWYeLIekmj0xawCCaAMPJJjmdzRtteF297m3xLgrsjuan2etxSA0RRkYyonOZKC5E7VWyA 1MghPKWmEPOm6Ug6NM3rp4+9IE8COnUMHh8SA/Gwf71DdMRHyYTnApu0WZqDuwpcxIDlomRm VasLrDdi7TSHS0qAJkGJwCNuq2OOFxi2+QnMqSVnAc79bD6V6w73D5hRba1eulyCqm3YIQ5u a+ERy65jaVQ2cfe3TfHPIICNuK4vQnDO16RM7wVL4LH37FMKhAQy1OGfbfyEYxikfoLs4ajY ZohWcczK1zE8mznLeHlUoE9bAnvaMdtQ1H2K4XeYKgdlUBNiDneoztaAbmx6YuHmvPh2cr4+ l3gaTuTjoC9JgJMLqkZhYDO3bN8YgPgtNhwDUx/2aypKmWZxQ7VNJXkRGp5yJkYQLZ3XRmGs 5qvChtzgJyf8CQWgIaAoM6m4wsU6m8ZjYOKwVA+6PEv5ZmouKZg5z0C7n3DOCQrB4r9Zc3Kh mjDVPr4d6ML6XYsEghCvLSY9432/QE8suivtYhzlpZbcMvMB50tC+ZoQnYrk0GZll53eA51m BNuBpPwHgN5aPSazrkkD1zPypPS/jM3F/3eOuxHG0wndUCXAcUjjV4/546fT4hRX7DQOaE0T OAxCmjJ9b8Hkt0jFxpy+JeIQhlVRtjr5XdvdMUIWvDhGSup3S0fabKA3xZNxA0Z4jctJLFly ufZRGi+N6XERJlg5Omd3S5Ai76QKLEgaI5c0qozrYTVwMrm+X0+RXVPTl4lxjdlspZrJbb1k r2NxKY0j0bcyR7o6IcylXBLuj0SYetzoSVisIZVM+lks9VFEu/f2r3Y79nJjNSlDZ8TWOan4 YftSYbnJZsosFG7D+HNrH6EGX6iMstlbWpou6abIRTv9jkfZH8DU/Jg1clTcipoaN9jVYrbn gn2J4v5liifa9JT9ZqA1oSlp/DkA4lXf9E6mkT6WClz4Rsy6wJm10JEymsw+OadxesXGVkN5 bz0AslI+7xzyldARNyCBc4x4A9o5sU2bb6whiorIL6Q+v1Zrac+S3i+NTYHrYMShdIiyt3TX VaRRJKPI9Y/gV9RLGCcn9sXgstM7yXfOzHuusOUE8OwEM9EeJ4IMroAVf9l4PeGKChoVZvNi tfP5wjhOXIfdT/5rOVpO7mI6KV6juzrn3b5BwxGSCJwa40nGcBFQexEVrbGPTx3l0UiKfFCw BsmuyzXnGmFoGQADAza4KlwHQ1hgf98dLhwF9DH+Fm6ONlM1DpFfIiu4BqCjgQkWcaHzTb9b FDvCaeH9uXhf9Lcp9OkLjde4VHBRqMhkqQRGLeA4xshetzachSxYLMAVS+u1RhjTrG+efK4S yX/hCJTHijZ5DRNUhMIoiykHqvBgG5Eu2tVahqPhp8XsdA3DDFmYnjtOWkwFEAvyqZEKZyDG 3NsabR5R0MipkSDnuYg31rNOkijaiQ7I7YS626xt9skHBEI9tVIQ9XB9QaZyFNdwZwcXpoa9 TSqSSyUk83R9tRTdGMjzheG2OH/UYHFgL1fELYtT0NOBcZzifcPaslxqXQJ+eo04MZ6BQjN1 9WoIW1HHrAmVTWQrESXwn85XogkXKK2v2I5G4ZRsqTtveeiy1d5qkI4WlGbO9ZgcgympFwWW PcX4WZSSiGqjBIE69iXthdSlqzbIqg3dtkFkUhWTKhfgIaUj7y/F9HSBZGNflQMYZzLFQkzi QuLLQw5Qsxg47pC2uiGjBbC7+eJcLZ2SbAsiyX+tzy/0jQuqYzWXSDi3wjRxQdE/KYyVXS4Y pdq1MXFBaZRNZzIBVdLi2QuUeLCbpnUCt6zQydFSmz4lekvdfA3MIOmCjB9o3AHpjaphXwh1 w+9IrBLdOhx9qyEBKItTvv/A7cNHdqepY2ShFEIssSu9vK0baa1pCJUMo2wVw66XVAFrtaVy A8Y+vyfWyqHxetiAeiLhkBI1bCfCVcfiq19JmSLHy0Phs4Cv66k4FlSNYBQgzOnYDq07bR/5 8GLFqtyMC0fh9hdwvVXxJi406GdeOEbAPiGF5Yyszq3y58i1SmFCEeGAkzwjNXYc37i4kJfL eTUh8Cm3w/2M3QhK0IYWVxeru8Ah8F9P/ffL1kgvi+zkHmn6rbzOxqrWSQGIygbN9nuP43au hAgU76yRuzRaIZzLNwEnRJJgE1EkWprcINyHG/OfhY+1E3Cm6rPZ+otnw456P1tfnJJ+7ymS 9TjQsvWlda1v6DLifTgBObfaKW8N1Q7TtymgyHSgdgWAOQVZFxIAaW3DcLUcE75365SSbxEu t+Ty3vI+e/v2C5QjcKfY++9UtQN5erLsx00MeyNMnIwDN37oSqQbjSxgFCSxjFvIctwP2YNI BbmFQ9yyYRmbNei1CAIHly2Ky7ZRw1Yb+AgzaCZTlpztRtEYFaZB6t5oWBibYDu9DDWYrLCV +dmO5dvIAQsFXhWm6qO+orAciphDmyaXB7sQyNBHTlmpUg0IerkU9+tKeKKzNAn2ItfrBQpj 7t5pwxfirHeJMi4fa871lx8MWcbELBI8Elv+hJmg6VJARgZ72ht7dCRXt1HBpQq2LNKKbdXY InigbC/myH732ZvKeTzq2L/c1vvADWdSYoStEu38grKbS5QYQdqtJFdOOYGeUzAkdAzYKAy5 WlOPnepsjvVqsdQCOjznaltuhUiLURKdq0lg8xWGjWBdqHvb4uK4GG//2sHLse9q8baNu5S5 uPWEjyCNbzlxcYwZpA6xu6gTosEOJIrdurBdfIEUTySQgNwYJBzIiCjpLSYGOPaVWHT0ul21 lnS3lNRKYtbka1u1w+UpwjPauAkq96iKbLd+Aze15tJTBVmvqcrJkuVdijKHdbOibbFKWhgo Spml2Hel+CIi40K8y4CA4sKzCh1CHgOsPjnHPbDM1UmrITzE4+v3/xsSfyG3opletFaVhQZv b39N3DxiQWSsZCTW3AmxXDybOK1gnQY8nYxVsZc77rlWWTzuJrU5YbutLRwriVj39HKFVndu 6kCjTpb91946Cbnqclm00epOgY2r9gbrDenF4HBIgKXoTpQ7EXiDFIza2cly2M2oEQR4cCEH GFExtpFthtvdQDeU6Rl5rkCAAL14UnnPOTSJpeU34kP7ZNmLcVa5hNDq3JD1iKKYplYFbKhs pJ2LDxDn++J537FrQaeLVOBtgvqKFRq7/za+mu+AgkwNzrtN0sLYsPwDofW1+TniIADl79xd JznZxPg8VcDtxU7YmGMt4L6Z/O58uvyjRyIKKRwwxNHjxy9dyU80iN3v29gMtKhNsWUH1SyC FR0dvs5zXEfMfhXyALODjPp5sieNIwGwVuEpnL7SMIZcU1Bt2XOvLLgVn0i7ZMxiuyjedCTm 5OBWcRdhIw5vIMMr55yfzdGKCgrFmzPsHPbvrnTw68+2n+vrf1Dfnh89x/X1P/woioKN+h9Z Fv9a/+MX+HmMNQ+eA91bUhEFryJjDzd+oSLwbWidmHmlWg45HjmQCxVm9+fDSohwT6j2hyx7 NKVWJtRv6vX5+ZWtVyhGKIOsBskckCrHxG9fxpbINKwBIUfbzVAOoO1nIU3G7M/pmvpQoPrR ugz4Z8OFoKPtnbtdBTzPdrayFZgxRJLgOfr2fAoP/O3Fc1vtTD0LHOMmhdAk1GsCkJWIvRGd itMFobMp+tI+Ktve8agFE7HXqN37C0mM5+pceD78BGav9Z6AGTR1DSBFj50XFzoQ95mWFCrH rcEPXlR2gW/dhV28Oz3gxTmV4OiVkJpt8c8F9gSQA3A6ljvg4xKG2BPVKaG2t1dgS7C77W67 7cdswzDv8R4wRec5r1c/AJ/umH+0udxy73xZz5c7p+CiijMyM9bzWh7s4MpL+dJ78mZvPq07 q+gOpgWfO/WFbWBbd8l7Xu+Hh6E7ZLUZrP5Gqrk60BUJxCL5z9m31ywHm5JdUnOBuzueeAUo ze0H9rhuy66hbCHJ/qppMRcsrkq+Db+1LyHutTZJoRhYkFIG9/RKMOadbQ4Kat57iuty8Yc8 a7b3lZXeZeR7e7Z09p4qbfgr1kuz/57ttUW69bezPakRCJ+dfne6BnqLH1Fi6J4ULcRfyNsA v2G17gKLde/Zkqn2tzP6DesV8q8ylf5Gn2m9bvvr2Z5+pH9LSAN8ojXA+d8tkNq4YUuuE6l2 w3t7bRlcp+pjJ7yNqe1I/7ZJPpuzrWetBtXRekidmixqzjoA+ogTaLCUjC9//ipuftjP9fKf ssofN8cN8p+fZWlf/svS5Ff575f4efvqi4ej0d3RaE+zHX63D58N7p6/E6Fqb+/ts7ft5Xw4 5b4NoOrfw2efvR3s7T0//vSx8wgMWIF89/j5l0+OTp4cv34Dn/1uHx8aaGt1oPHbJiQ35t7e q0///MYZT2lu21URfyVaa0srjTA8j2km/UaUcq5xX/wbU765p/8qBZxLF4T53h7vCHdW1LXU bqTLcXf4u31c1mCw9//53T6FlVXn9fDw9cBbVEvvd3+CV7ioqPf70Xzo/e4/AC78Jvx9Dz6s 4AkFytPj50dvcKT/Cx+++BxgNPAOLuD3erKAsbpzPH48gG8ef/HF0+eHz97Q7/LbAYz5wDuY wyt7e1SD4x6++foFfLVo5Hh4/Xt7e6MvPnv18u/UblIKdtx0/5mm/lgcu/7+B2EQ+hv3309+ rf/4S/xg+o6HnQe9x69efPH66A0l9sCHr7F32J4VAhMO+TsVy+HFenGBUd8SV+t0lpHUJYyD 0q70NTn1JZlT8mTfnplOqoYGNPUFLu5AjDJ/yQ+8fvp4ubf/WpKOSdrHzM/ZajlgvxTIbvBv 2CnTtef6Dc2qIZ/hoqnwf/gS6b77jqNlMPT4q4C/6kZ7D/ZQ2OYHQn7AcW5gKBZuvjV690r8 OXDiGlidvhS6aG1Qsf9+PsUYVw5Z52gUW8YMYzqwps3Q5pZ10nIoHk3qaYngtSeLceDLKbnu 1G1VM/XmohkQAL5sQ0BkgL1J24WhDbCGaaUCnpYU3zpPKyuKVX0biLjokkYRzhFRpN9vRyzl eKxeQTZnAuBjcw2Uobf5NTrJNa+JioqKTDuE06QMafwC/bFYOZ9Ok7cBqu+qrYrjWB3YrUDt OrxbjmXivtcW82JDLsXKYke+OWAoBucMe4WwNDaOAuRZXkac79Y0Eie6qE7sop/P7DlrP8JW 0ZrMpHqmxxYBkp7fL1frejLHCjVcZfLFGxqqY98AGG4z5TghfEtp7vWgg4aPqAwVfPxsMnXc OXsP0D7wJ1jM5BxjzWCGR9atvKWqqlv0wVaSRdKyGTJmSzexs7nj0dooTktNdqjx2x7MhKV5 bHCi1FsxFNqy3AhGvM8uiMsJjMbRafrknq2ehCEYNJHWTyQfqjjXuL0BtQpdSmFFAPIXz48O 3xy1gTC0Y7SyXVvh1jbwXNJldFxE2HbFe0nVVb0HVGn1TxNjDB0NNs/jHCbK5J4a92D1MP5c IPCxKuse5ari/p8sqDxeiZlyf4aLOCum98nfcnFlE2xlRGQdNtYELs7H1HzF8L+3Tg4w1ckE FFb4MnO6hoxaAyYM9KWjWbaa5FVHy+zlNWDW80aBN1yUjbW0O5MwTMcbvzWmcuiutIUGPbtc z6hQVI0N2jDi8O7KVGdYoGR6yMBc3v2CCRSGxt116CUt6rDfN1Oz2zU6E53kxXqKnXj+SebO Bxfn/1z+qbqAEyZ0cHe0B7fg8ReHL719TtU8w16YcCFojkOukAd4tUL6NKA7tBxKxA8GwWo1 K+qINNIp7v5/cca7x68ONP/z4KupwBSWf7U6o0iNazZwOHox8j5fV2dUoOpBcf7uT/C/UVXg 6vc65yHDBYgiNkCtrT+IdbfcSl30NC0S7YC4qvN5vZ6aA+bFeMmck0ehmSIQgDdWUxu5ejl5 NxnBB6PVu7txGvi0sRmFrSwmZJibKirYJDQKxSbWbmn0yA030t1ThunFnjpcARhdkuptIanD DSxdEaft1irc9J2DxoCR2ss20WuFLVdWWLnrwOU5Lo1uE/OWZkuxan1Tkp2PF5Nv3bbBWvpi o0A2lY7ktmKS+PpX6df9akiBU7DgC7x0JBRSzRjiFfQ3t9bqtjL19m1cwwGscc+mbmBZ4QIF p7dObgoVN7U528xT2Ez45tnxCDfVCd1zEtqqCmuljSJOCn9y9NiLQDu4C/95/jfxlL968/Ru 4GHY+UTWuue1Ob0WDF5V0UyvZt6TyekEsYjcGfHIf0K9N84xpo8GG9imh28owEqCTCotBXiw XNUBB9rODMbjFlxXFVmYZhRsE+q0MwK1tCmvWnfCDhDAVJ99cfDl37x85CdOG0W3uNjdcjK7 C1vDQA0+KIlwkwLKGtk88r4EpHILotp6ibYIAz5IS9E2M9aj3nZy8F4fv3n86g0y20+PqJcN Y+QXxfT8FZMEvcgX8BHdhH49PrgZhxWmVMLZULM/Lmb3diMt1Ko1TMK4bwbVREQ6fDaZep8X q+9G3Vc5wXoz+m4pabktIcQC8V9QKewnZr1aVmc2A1bbFXMUhjaFO5u3uNtW4cWQgvXpKRci UN9CJwpJgnbuU5QTjEeFwuZzzEE0C3wajwKJF1We3Nt7DDIAx54D9CcVZYnsP0b9LE8OQh9I 4p9NMTuYztcX3rOCw9NnNXWH8w7R1sPQRLnMRhm07US9T4rlwWT5ybBDHaRvKNXX5h4he9Rn eAFU8Ypl8hkH9kn+jxttU+LSKQ+GSCQFWcOYdYFEdEk7nhBTt3UMSMpuRHhsI3/xPBbnE4nk Al0Bp2dKAQNSktlcAuLc3emEolYP97yWje6obKTx6HMuY+JJ65OFsUEskgnPwb5DN6yEZCPS bnD8BTY7mrByQ3gcjNxiKP1dMpGmsvGowC2xGLNZkjRznwuayvds16+mxeS8FahZ2ly5YcwW fJprsgEfHokqJUiYyZATcdw7aFPf+Yme505jMXkoDJMzErddrjVCTMslUfHXcMSVAa4p0NSt z0QpdyCUSDmvFkg8ZRdS1KLHqJi4CQp4JxJ6y1eIckMF6AvDjQadajtcOwvzHbeWS/E2L5z8 OHfO8/4LH2jLXztOOnzgT8V0fT6bgJw1RaF0ZOq1tgGxMZ5d003nwGy58hb43m3Y0W1KhZhg 1OHergAlagt6qgqgdtPoyOnkmsUMLyp6wIRhT++/1jwAhlbLILpIy9Ux/2NhpBiGEFgLtb2t ZOo+3jqqLYIno/ZsUiwOVLHArul7NonKuZxchcqi13I7hOzF0dEns71N1cZGZbh5hAo+qQiy UBWqW7iMRtOUh34mv4b8uuiEsOyt3V6NX6O8/rf9XG//t87uHzXHDfb/IM027f+pn/1q//8F fu7ebpuBewcHJEavhUMTjTsApYnE7OX6nMgom+25Fs6ed9trhT1HxPOzDme5TSK2zeIjwb9D U6RgKovfVU98bIsWwEggfMOa/7T/24H3u+P6d/SBrYR+SyIYbsFnLGlTPaIpJuBhb/E9/mv9 HEukyb5PYMugg5iTfefjYOg+FA69707mTZPGJ1gKbhYO7rcTfIqmujRJwuDL58gsYXXUmpRM yRPMgDznDHvKuIcHoxQXra+/fHH4Ny+B13Fb9IckE+kgM66LS4wgTJLZ/uxOMLgbenc8+m0f 5z8Ale/BQy/8jyg8CBgkMvyTV8F+uW6Gk4Hn/Ys249156OFHg68n39yHsc9D/IS+uv+9815o 32vHuN/+DlPfd56OnadD52n5/U7YeXrsPB07T8vvd+LO00FK6/U8+6ZPT/PvYzwMgB2KIC9f nTw5/svxkyO0rWsdLlRwseiH8ukaaxu/n2izzLNiUZNci4cyaWDWdpi933qisXkvXj3ZLwbe PzhQfO79S34lybTx9gvvEcCVkOHBAy9IBwO4Kgfdj+5f/06y+U5y0zvx5jvxTe9Em+9EN70T br4T3vROsPlOcNM7/uY7/g3v5Buv5De8Md54Y3zDG9nGG9kNb2wiwE3nv3n8N53+5uHfdPab R3/TyW8e/I3nvnmE29/Ar+VR/FWf+R6djiDd7vuD7v2LP+IC/j8AGjNdmk0CVXi/53e2wM75 DgsKNUQ3H/5UP0hAmWl+dfS3L169fqscdp/+xXpWzRDZ54BT3Fv+el/yULHgzadXK6DAt+FZ /nR9PCOee3/vX/y3FsuiMqfIvu53P4cn6QPY2vJiCgqaFWPIUk8+5BnaC+DdJa4ZHyY2CMfC HPLRI6TW3h88/9sGfngC/uoPD+2HOou0Yue0IqykggZS9jhSy3ZbvnrIyYaTFRWE16nxzGF/ 2I0XuPi/LC5YZg2g+Nr/5n4XSXidgiidCEr+ShHHftVl9J3B6KutY9E3G0NJzRqe6L/lfeFw jKYObKgkQ3sG0mewxj4caLhgCy7F7goM0Ohp6oELHoAAfvXVycsvnz8f9NcRPN88C3a/szmh ayhoDwFN0ZRku+00aDfOaci9g68ODtzPOyeFWHvnzv1NEG7C/fsfeZx0pXFsoB/uD8CAKk5w C2Bqgzi7onc/scj+kWcItFbaXJJ4Sp2ll6griLlsyXVK0LhJ3rK5VmwE+UpmbKGHm8RhXBji xwf8cbtBQAae7y6s6X5ngyolsxSHBtvyCquBOdtD/tABo5Uiu0PBW0QG1rPFnPLxnTHwBzEP Dg9W0J6c7ubgYDboHAgfY+8zPqNNkC6wOjRVp6EKZgicpZQex/0NJTSgB9pBD08BjN7GD+p0 VDWA36HKVpTh2s7pbLN7Nl2sd07HBUEXoDcC7Be4RB8FfcF96rtTkjfGZQXX3ozvf3qWea1K qsqoqqGkfPbZZ3C//4nwxK7SupOD6vs3cVZAn5bScqUFyqCwde8pL3uBlV6ocKZpKDUeazd+ iw6MpbEBJQvO4bAgP0fmqxMNEENC7/dMDe8rgw48QYCgx5mFeeMot5399M6fRrijPD60YwxA kyZp7MALnPHwSQF/Xx7AN/Z1mC3fyWgELhxPeGzQCnb0V4emf8Qz4YZIqWzalSo33rCj9ji6 4DtN9wug+1YJURH+p8D3Hra71/nGm0U7vnaFafyz3MmPXuVPZf+73v7bpjj9mDluyP+Is6hv /w3h/5Jf7b+/wA9c7/aQ1QDMTde0ZBuXDt1t6k02nIujn9/iK5otdZ84fvn26PXLw+euHZhe vvXTkq+HD1m20Lg1w4Za8YFpt/eZONixYstkxtyRv5NGQBjahwO1jczPpOkZNYDD0hqkPbod V7CB00jz8J5zZAu+oY2Iu33oOysaeV9ezMm9iQVtcFXO+1QB2u1Dj4NtrlwLr6jn23ZE8UfB 79lSLfbtdoUXU64gEYQs4eo6vsXGp71lFNVq3V2HW85K9iGJgvpF6DShf/U5sjqpKD+ED14c vdC+7I1UZ7ks2PzLPd9xLMbvYbeN+/bHPbj+5xphIPX/BDQ40lcnb96+Pjrszskn7Rwz1Rmk mqCjPUBirK+uXKbd1D6CxgJoKAAdtoAd8rjMccRagk87DEc+eY5WEwaZY1nhgVz2ZIcWoYEM LjCFMqfvTqTzAf/TPgUqvAiE/M1oZr5dYYVxFEVwttsDdzZ5iLvB81No3Rk484sBHhSgN0fP TtL4cxU3H1s7gSD3Iw++Rf90kLp9U+65ChJ7dAb9eX/zsN3yQFmvgwT31TzW3xnGGj30WmB3 BuYveUdd8O9aCr4Ba9GHty/Fneg7KtZIdir85QQzTAZ+Zy3fUQwEPIH/bntgflH8c01PoIp4 0eDX9D0cJm3O0pv9P/ArinDtZvDR3zyke2cX3eJCZ6B2kK9Onh6/PH7z2bZx9Pa8fOKqhTLE 0azWURztrp2WTUNAAv7Yucn3eEms+uF/Fc6wOIGFrX+/beWb07o7/YklY2QtO0jCzRTh5yEF HcHU0qcPIE9fnTw5enr45fO3J05K2U+vTCg3ljLyWiAViPpzorvUoRrjkz/FWktNW/afcJuq aEuVUi4mjqOxCqsFut22dVIZYbS3qcMobD6lkmT7vWO5Hq4tu7zjvElKZTjY/CyGz1zDSPfr MMFXguhj9IMb5H+ua/AjZczr5f8oTNKN+j9ZmAW/yv+/wA/K/3zI/eiPx68fo8H+w0M+0qFH sb0/U+AHDtYGN7+e1zNz5X26wDpsDxZYPHSWxn+qlhUlqhVrziQ7myw7yT04P3fjpX28fuxh q8R5vbyH+YMgsU7em4M5dT6QRhW2e4zjxsFFw5U/YHBRvffbHtXIZ0JDxEKDO5dnkwZDS7mV OJVLm2GVQXOhpRUXVCajnX2JwzmdeRuqtwYvSMVg+rvzghabBjIENJAUB9tl+TaVOJxThwfs 6ww60oKi/7DRIbpaODXhi/klrO6Lx96z2Nv/4ovHWZwAOeFUJsxiOHgVjXYoY3ex1y0V9Zdw QQmOfvL3l4cvjh+fAJhP3h5++vzonsjW3PHiHDDtWyrdbs6LizOuZNm2wdDBOHSHuyGUboUW qYonmV6L5epgTWl4M3E+7NmmPIDhcjza5QoT5YYSJOLZSJP+et0uTnseT8IdZU7N6gRGPaFR uY9MW32cNSterObkabA1RVhKXzruObKQQr+4eLqK2MtBwppEGP78CJb0GTp0VcF9QK2ER2eP 6MNmhs9tLB+/sz7grd+SmIvi9W82vqZwGPu9rmFHuBVzI3iOWsi/ffKYrsjTw9c8u9x9V3Hv hmXBm0+52QTi9gG5TalbNqqV2A2GilchcE64p6N0r+CPyskpdt7g+J0ZB/B8+venr758zdDB T2hR7Q9MSBU4D1++OfYec0+ZJVbLwnoSKwzhxzsKZ0mr/i0rPAJ6ffhRB77thCzbfnn88u0J OqoeqscYf75s3Ze4L1yZ2/3JW8f3eQh17tvhnr96+eza8baMSIZ8O2R3UBn2zWevr1/m1oHZ veqM3B+b26U1AhUFeUWdFZrrTvo3Ft40KKlhv934w/5qEZTOt4Oyv1EkUKL1xEFFEgfnSqKR PhBR5Zaf5I9rm047gWHtIcupvz76y/7lANS7ffjn0aMwHvwBoTi4Ix+M+W/fH9xxwjys+IYP 6QMPHozlNR7iwQMYjY5BPESdU3Uvg/fq6f5+5+vhxlT6w/K/fRgbAtM9vT20Hw5Y3dk9K9y3 n2HKFqhvP33+xhtvBLjQx4Fzwt3jfU7rbYsuCMnA6bG/wcw6pLdt7LQJT84LEBO+PeGWVxv7 825jIubOTW78dF9+byrcI09NvllnxuU/1xihsGVK/mboba6kHY0VDD6ZXigrfGgDWeH3rWGs itqb/MGuFqvoUeLoyrM87wQbnFyBthzc3wpQPGD78Nd4dN98DYL+Nx0YUG0B+xQBAD8nbOjx PouQ3EwFU2Wdt7CcDuJTD9XsSm7TkFu5GQkvz7SVpyPEMSE4oNx+7qZL8iKsAduduxLKxXx6 NZufA/O/B2N9+x9ReOfb/whT/E+E/8E/A/wzoN8C/I8P/xnD/zL4XwL/i/HBO9/eCTiJzI64 pMZf3rOn+6APcifzNokIJDg4bipUThmZsERuUmNrzCPCtm2lQcTDqGSU9GynUCop4fRJxVFY SkJ3VM0NQO1q9qjPCQUluAKo5jxNV5OL6ZVUW7BvYXjGt1w/RjrSkEhMRZxh3dLEllsisDmY +s05A1wMJblN9m5Dq5aa4dg++88hlyvZuu3rdo3atAxHg/vfloEaqJ3x+cwiPCunjxvhBjy8 /8/biAADjL2AZe953KAFvSnwQUnW/aW4wFHzRi84tyvEaJZaw8a8cmRzIF2M0+TbtsQAwfLA qheszlCOjnsalFK6Kt7pW3ZyyYZq1ZOl57bRwex7s5gz+PFWYLugPW7NQL15SrTm447pfCno iHauaYbtwCyKl9y7ryCE3b+UjrM0AL+HiZ536O+HHt2i0WhEkNbuO+5SZY8TOyvh1Lc4sNSJ J/BQliNhXsmd/qh2JyO3O3W7RHqNUkjn63bBWE7nr0ZaGVv8OoORWwTbZ8dID7cG3MXtn4rG prCtfDzDKxNd858jTSVmdUNary2lIZPFNSmBYztQ21E4xM6qhJTlrRfLTe1C+ZdP2DYyhnGp mxLru73oRV3vHrlgSnEQ0ZpxPfZYeHoucGOxhB1AgmoahMTElpc3v6TxsRXlQbE6KA5oyj7B xUfKOcDd6fNOdR240fseC4TwYdtFXa8fNbnkxgELWc+eFQa2cKP9wdZwmar1fsyG3rttkTNI K+5vyAPAdhwi4hJP7NuLnVHVc4HBNaCBEGSdV1iTovuLRAEkm30peUQExzo+VF922TajEjJr uxiscoCHz+00UUhaL6iX+jlTie5o22S4i6+/gSH/5Q+DYTiMh8kwG46HAfwZDINwGKTDMByG 0TBMv2+jhrBgJ/VZlCaUxfKd269ORXIkpOh8Y+34AGuGcTvc0qxW0jHN89jjiEPhWwcHvXbf C4N9QYBgrhc2RqnT/g9zKVVGLSSBtajfo+GJrSebSjFeqNMZNvLtROIRfF3XhQJcnSuyfape sPXsKYHXOe19/1tTl+NxFPqgjLnxevgQjvzl89YZgvdif0bzeRi7iprrvNm/GNyV3zonN4CH 7tzphpnSqP8NGPLlc4z+2Y8C7wBOePbNoLuDtum5aE0L6WY3PrC0x11tf2UgA/LsvfC/yg0A o3s0mHVjAGmkdzzSOxhpDP/0d6EjVd4fvMD7I+/qP7z9iqznA++ex791R27lVP8b2DG+78YY 9pS/bcCwoMCOEQwDzq/nSg/UWXN1OVcmhgY/6sLW0Sds83h17AMGY2JtMWU7Ftbbc7r4rXos 4gcCvbf5XZCJBTKo8FaDHScT8MnEfDK9ybZOWEng3Df2lMa9wbvLeLd5QFse8u541633e+dw t2qTG0Nabcd3HYqon2r8LRqU5kponaOAzy+LycoGPjLdO11TvRUk6MszJnWtyE6EblFgW7vN MN3ekrrobwNdt2hPtBKqMISUDRmr6DorLaV6ptO158Z6VesgxR/2czdYX2X/lrx5a+jdurzl gBmJIj340KOYffF3ORRLutDCQ/Cu9UKcIRl3lLBFcQGcuScG/GPmTtUdybttlbkay3vMUdqp pOm4ujr+gbz2H9eOw3LBLn1y93vbdF7v4T9m/4I5vX91Z3S0WH7bvRpsEdlKebozdqhTb0u9 izneejF7APS+H25Z6w3rfffNwCWZO1ZKd43HdW137c3buaR/zL6/39sbVVPHJ2x893YFf8t1 2G5J4NnoV75WDvbjnzuNC/SKOnZJMpTrspMO79jo75f+t7/3x9Nvv3z++yXcqZn3ey8BNnbr FnAuMrLfkgUCcdu0RVH+TJjQGwAseGefR4CPY/xwyJ/ibR2QQ36XgZ8o2063wE/oxSenHl93 1iMOonBpy3uCWAdSPbFC1iqGXP6vvNoQ1tll0nomlDA5W9y6l580JIFdlG4IgTTf1DJQ2J3L LX4l/h5a+070soEGPacTINxO253S4J3sog+/+zcBCl+SoIX93WY2O+LPEjvupISTyNUTJvb3 4S7hElCY4DSSwaAjYCxExHBT0XG0+zf/52eIhO/Az0aTEErAfzfyJfuW+K1UqbWu78yg3Myo 04MlneKXRKotojWlLLDSQgT69gAXqgrNaoGNXU9WA5eJrWNR+x0pRewAD11ZH4e+vd/VhWD8 /T/ww4NBV5rS0CfX7dg9l3ZoclXsfBkdlNve3C5+0qkqdgPaum45fq+bsjV2YQEI3a5KUrfG rtBqE8c6KXKI5fxQm93WrrPdzMZyNtSjn/HSPz9+G4MK8R+cIxbfueOmTnepQdRVLdovQiAT QgSc77uuufbpQJ9uU3y6w5EKg6FX8TfdhUahLPj+D/z3Z0s02+lG/GmJjn3RjXkTEyFc2Op+ 9yMZMbbDxHKZ2TAQD9q54YP/b7VxEf7wB2/foQ9I4P5AOf3/2oEiPp3tf0i+4eBaRZQyFjtp hLhCXFl33QP5mygXf2Ih0r206CJwrx+hzMbN1Y++3zJCvDFAvPF+7L5ONH+DebdnN3Cgvp1K /DAAbiUp7imqWNE1/1Q/swjx6fEzpSZ37tDWd1KTeBc1ST6KmqQ3UZNsKzWBhRI1wQXf/4H/ /pLUZJPb/Q8iJWgPEnKyBRN/DD2J9XRDuJl6K+Q2cIWZn5Sc4Bs6yPWkhfDnx5AWQqSbSEus Ods/NZn5QLj+QCqzzwZCDk/fagzUi/jsaXjy5PgFxoXSD6bxYzlv7QfALvr3VESb0vk1Iwsk 3sFPrmp+aCDLPpUPx/CTLZcQA0m2ebDg8Z3J4pqRsj5vzaECeZzFOUY8XPgITfEbVUWI7NrZ 8QeffPSoI6/D94pU37tHSKv42TLxt0fn7GsoDrV/2QJK/n4bNHmfN1uHBMF6FiIel43Z2w8X /sN+mp+5OEEvxIiDizisqJ8Cjd/d7/59bfqzgGUTdov55baPsYzz1wKvb+7LbcQPD8gJfzBv DjDUmXwsUo1kbqsNdIea13V3JCqhUtc3jbSnNMC0XiB0Iu5T8Ek9WbJTe2ZOC2rfLrVo+gU8 Qqzb52/UtGEA6hyYbWjnRrTBGAZcEodTzHC9Oi7ux0dkcR2I3aInEtnveBvVvgMLtjfQomew BT2da44TEnbas9KhHjywg32/ey8KXo6AgM3gOeqKNu8hfjvESQfXwIec/J1BHQhtjglfDmla Z0wstX1FSCqHz36SQJy9ci+5lDjOT86d3hkpNHglVysgHxymYZc21A1bvOhwQruOHv6xNwlb UMD5A4uhZTr28+vBpk9ZFNyg0LTRLfSGR8Fvu9JMqKTbXTlVneGAdzqFpVlJvBSFMDnLtQt5 2LkL+FMuTPGuO64GD0xWZuEUH8FAr7nkVOBpozuVUGl5CTDslva5HgV+OHxolJ8UPN87olmI yZK+g6Ntch6XsUEDTWtACpDJtpS3Q1l+9sIeHWbxY3jF9kIZN/GiLYU8Oq+k8U/Kvz5iVf/u hK/ez4fk/539yDmuz//LoiTZrP8c+b/m//0SPx/ned/7IPc6Zy9d70Hf7ien68RXyv9WIAni yxD+yjLAFD9P+S9jfJMGYcV/5bmfJ0FZ8F9+ltZVHOTwl4yU+WnRxONG3s3TqEiiRN4FWpAn RSTviswkc+Z1VY6LuB3J+HVi8sDIu1kd1vl4LO/mZRpXYSnvmjLIqrKWObNyHNZ+1o6U+2UT 1HnA3wd1mQV+GvNfaVH6od/IKpqozLMgllnGcWnioDbtSEFRF3WcyUxpXdcmNrKKJq7jMklk lnFUR+OkymTOKK3ycZK2I6VxWhbjSiDe1GnY5JlAdVykSZUbgXgQ+0FSxQLRNIL7XdUOxJvC b6I6FaiOa3/s141APCpTE/qV7Ceu0jzwE4FonaR+HBgH4kWYZlmQCSyiyo9MXMt+4tKH/cWy nzr063HSCByKxC/KJC3bkaKkTIpxI/uJwzLMx6nspy7Lssprwa6iKqsmjwUOUVjDcyZqR4oT 2EyVyX7qqk79uhJYFGUdRHWS819hWueRX8gsCZyb70dFO1I1rrMkGMtMZVP7aRDIKsKgjBs4 PXk3LaMqDgWiVVMWeZI7EC/HZQ17llWEYz8sx7lANWn8ZDz2BeJV6sNZlQLRMvBLk4cOxMMm bbJqLFBNxuk4rgKBeBXA+upCsKtM0zSsI4G4XDu/HckXtJbbMq7D0C8FFqapk8AP5TSyoAzG yVig5qdlWiZB49yWpmxMXAgszLgc13EksMjGflblhezHb3y/ySO5SXnq58V47NwWE/gmHwcC i6xJCx8OX94dp7CbUPaTB3AfqlzgYNI0Sio/cG4LL1JmCqq0SoNUVgHXKokAHeUmhWno+7Gc Rlr5aZ6Y2rnBpR8USSarGIf+uAGQy7twplWcyCrSpPTrvBKIBmGZmTxxID4uS1OOjUC1qUqg TplAHI6qDupaMCRI6iKsY4H4uKqjrGocHG9KuFlVKhCP6zJMg0T2ExVIUyrZTxGVFbBxgQPQ mzLyTejclqJuiiSW/UR1Pc6TWvZTwF2u4lQgDsBPm7gROMRRmgOtdm5LFKemzhvZT1Gn2Xgc CyzqIvUBK+QmxbEfh3UmGBJFfgRXL3GoSuEXcZUILOrar7OqElgkvp9kQSSzhJkfxkEhEC2N DxcmcCBe5X4FByarSLJ0XCahQC3002aclLKKMk/TOvZllgr4l4lzB8cTzLHMfYFqmMM557lA HE7dz8ehYFeV1VkxLgXiSV5GUR04vCU0ZQzIJxAvs7JOqkigWvllkVaF8iVrIiCML8qmBPLs 3GAh1nJb4jKow1xgYYo6ibNI9pPXdZhlhUDUF4RpR8qiGojHWGBhIuAZZSD7yeM0jsqx7Mev 0zotIoFDVqRFUhRj5wbHvqkaX/YD5DVvmlz24xe+X5hQsCsDjpsDH5bbwITBoXTjzB8XcOHl Rhg/gJsqEE9zP63CRlbRZGmYZInMMvbTJAXm7tzgPK2iNJOZUpOWfmpkFY2p46DMBEPGeR2F gEYyp18XGezPoSpZXcdFJRBv8jKvgR7Lu6Y0BjYr72ZwsiYWiAL2+2NTOxAXMMp+iqAO8iiT /UTjelyFlUA8buqmCROBQx2UZZo1DqUr0rICzJb9RE2Z+CBmyLvjMozSWE6jBj4fAiOSORu/ ACZWOTc49aO4aAQWceDHcL4CC9inb5pK9lOMARJNojJDkJox7N2hKmmalybT21SmQRmNBWpl lQKmBbIKEC2bOixklgRO2MCKnRtc+VWW5TJTWfplnPmyCmBYYZCWShkSH14P5TSqpATSVzq8 pYSt+2UoEA/LMk6KXKCaVGUEvEYgXgFxappCIFomtQ/E14F4CBw6BzYn75a1KUygfInFTNmP qdKoCUOBaJakRRHlDsR9EUHk3coHvC5kP6b08SLKfrIQJOdsLHDwhQy2I+VJ2cTFWPZjQL7I ikD2k5VwmctCsMuX45A5wzocm9y5LSapE7gCKjdUdWWaUmDhl3VZN6FKrMyQZRYQmGMTxg5v Scd1XUaNzBQ0dTGOUlnFOChNAGKpvAunGAL7lNvSlH6WGQfiwbjM4iyTVaC0lBRGoNo0PsgJ mUA8Tf0UWJ5ANEB2UCYOxMdNmuSmEag24zSEgQTiICGUTVMLdgUgNVdNLBAX0uVQujrzgaoa 2U9s/HgcJQKLKAfaHFVyGgWcXJimAjWQIv0AhDjntuRpHmexwCIyQJyyWmBRmDpIi1j2U4MU nBS13CRgI0BpU+e2RFk9jspGYFHkAAiTyH5qU5agIqjMkJVh1WQCByD3SdMYV2Llg5aZqqIs qnAsq0hgbzmwbblJcRkXUSGnURa1D3TEoXRVDZBKc1lFEgOrz0KVwKM6T7NSVgF3MM2KUCAK kkcQF6UD8aROAW18gWpYpE1Y5gJx4Klw2yPBkCoCFcYUAvGk8EEnCBwcB20vNM0YIL4R5Pb9 cKeWG+RwbwIrKwGdSkO9caCw1Emk9BFl0yrxHW4GQkHWxLHVF4BrZiqXgCKBLErXPgattVB9 ACQwJFUd7c00ZqxnYSLQIvNKsaUqk7hRiQA0KpMZxSugWKgsORRxnIGsXaluBHwtDELVRhM4 mTAKVL8HmRfQXXcXGFyxc9NDoICgKyk/yMoEBCgre+cgdalMCbpONI7VUjAGNQq0XGd3eQkX LQ+sZBWCeGrvQg5KcWklHFA9gVQpBWlAwq8C56aDhBxEjUrUVQ1YYFTnypNxHMaqlYyrvAkS o7wNbkacho4UWZoizzK9v00AzC5QfDdjUKV9Y/GuRiirtF0AFwpT5y7geguj8mocx2neGEv1 gJFXyp+AZPig4+dKT4DHMgVXiIN2BserEh0QTD9Xi0sA9zYaW7m9idMobVQ3TYGdZaVzdnBw PoiKursYNKdE73ZZhkUTNaoPAEIANlpZCU42yJzd5aBoFL5qd0EGemGl+oJvxvG4Li3XL/La ygdRVcJtjJybnkVNBK+rBaPAl0ultEGVgMQmu0vGtQkL1QcaECkB/501gY4Swh2wnD1u4A6o TQIuC+C/asAxqFCFr7wNDhXunYMFRRqCvKYycgnrhXunlg94Ee67rAmQGphxLGsCdAb2NHak owBfTVVDSyqQcXzVPGK4KZG1J6WmgWlV0kCeCDTGkUfLooSrpVwHqDCIxUGiXHJcA/7r7oDC AP7rzuHQ4d65mhKoWHDvZPemMgHcO7VxJQ0QFqXgwMpAPkpUby1BiE8DR1+OAZtgUbo7OI8x a1LEU30DNEZtcnDrAKWUF8QRiPy1q1HWYQR0Ru9HApspVSrLQEVrZYAE5H3Af+VtBnjQOHWo rw+kG+6dcnagnnDv9OyiAvauMk1YAM7WKvUCCGK4687ZlTHA1FeuD3QjRKoqEE/9HO678sw8 HgONUdnbTyKgMc7uQKgyQGdU2gM6ATRGpVO8dLlK4lEaxoD/ahkEZRPw391dHIRwB3T3JfDn Su2TSRgDHqiWm+Vw/Y2VlfwMpHZXsgV2AZTC6lWmqeG+qx6e4MRqrwCkLeGu687hAgCNcXaX AzIBnVFbVAA6SpyptjMGiShR3RR0yygfq44ShsD8ct8ZCWCK+Kd6FYhhValW3QSWmNRq6YxT oF6V6uigBOVRUzmYmYFkDnRIaUWUFEGoGpopYvRyqA4Pomnmq5UHCEYWsx1Qd5dFaZ2pbRNU ltqkakkrQDYHkVM1lioA3Vm15wykh3ERuBolSLJwh61VBe74WO0KSYF221p3noCo3QRWigeN 1iQOZoZZADJILruLjO8HleqBZZ6P4W+VR/1xBMio9l/gK4CG7u7CMgH+r7sHBgIUV3ZXxSA8 W4sXaIRhkakM1oAyk6eullsYwIHKyA7KLADhplDNo0KzT6p2tQQE8UYtjlVBdMU5uzrKQMBW W20zTkARVs3bBHCPrNyYpjXoTUZWnzVAl7PC2V0Sm3ESq/U7rpsoTdR244MY10RGzi4oC6Dw hcr0PtCxIHUtOXneFL5qdwagVJhSrYp1bXJrDajhVlVVpLsD+a2pM0ceHSOTKEvrMSmBQaqt vAzzxs/V4gICMdJJtSSDxAPyt7O7CHYbJI16LoA3wlZ1d8BZQInSnQO1NYG1U4F8UfuNaxOC NwFPZHdplNRlqBpYVQJ3yNRmClpQAPivOlUOpCGpHEkMlMkMub/soMlTuHdqswMlEe6d2ovq AgSZqvWmlHBfHOnQB6Eb7rtaWAug8pWvlo8AULpRq0k49g3cdTnJNIsboDGO1AN3JwY6o1pJ AtS2UN9KXKUh0BiVBIBdV2zvxhWOQ5C4E9euEPkG7oDurggSuANqR0+SGO6d+nuqGKhtorpc lgIndb0EFUhEcO/U95IDXjeBWvr9poA1qyWhrDO467q7sAI8qF0vQT2ugc6ohTVG5FILUtCA ojRW35aPJvZcLbMJMADAf+fsYqDUcAfUf1XF8Kbq8CDwg8ShFpcIqCncO+VgkZ/DvXPPDrgh 3DurmUegias/DiUkuO9ydmOQG+Guq+YNty7oaLkl7A3uu1rw4KyAxqjFBbAYaIx6RHy8h2r3 r0FSARrjWE2CGN4M1A+I5j64A2pbTscF4L/urgGmG6qFDuQUH+6ds7sUdDC4d3p2oQEVMLIW IrjtmfrqahDB8ThkhQmcatG4XkzQ2OG+6+6yGJir2ifLsZ8X1mZaBAHQBtX2gQM3QGNcmxBo IjAz7P56vRYYRZgWOiOITjFcMeUzoAuVRj1mqGUU49q1YIFGVoWqwwCJrkEUU3oDumiQWpuV CSIQ3K3sVwfA+R3+BWiYAVlPlb8lCei5iqUgvgHZUBs0IHceKf8C0gn8tyMxAPmJM5VNZHOq w9dAp3Pl3CDkAk1TnopEDE3oDn4AO/BL5TogQtaplUeBkZd1oxoAiNcopyjnADIFeOloNAEK dGPVaAChA1iV0jEgzLAopdkg4ifWdgckwIBY4uJsCuKPUWwCgl6AeqO2Iz469Y3ChGGlmjcI hXkeuvo/XN6yGav9FMhabExk5Qd0LSpdBublR4VSEFB4w8R39VpgoQZUQfVAZXmV1cqdgWAX leUjEQpAuWpZQA0zWIKD/YD6aH9UyhXWEaCf7BWElgAOSLUsRky1QoFGOWabrZWHULZVWRaV lqSsrN0JROpaNTQQnn1AA5VAfZMCoFzrBrArJNzyPShzZezYkYvaKHeA61ilvvInUA2MX2Su 5bjOgqBSryQQrihL1WYEKnBSjdW6AWJIVli6K9fO4fPA5AEJVDMHxg6gUAsvsAYAeC57BcIa hYla8oCcA0qFjuwBom3WWB8+mlTyUu1UKIzWVWb9scCQU5W2gVQCqQ0cugxqVJOGqkkBuvtZ rNITCABhYKwOWfgxaMzqXy6rtGJ5R6kpExXVU2rU4FVrB1EKDlr1S9SQc18lTKSr4zR16BMy FlNZy/IYjjFUKT/NmygaR5aLFk3WqN0tBQEf5QlnJLShMx/Cv2BOULXVpwSiep2pJRxIf1zW ak9KASR+VHa8SMZP87H10RDJVNkjBwEhUK6PulzQqJwFAgtcssyhT0DeTRopxwJVtfKtLRDF URCiZa9xDRPWylNBTYpBQ3PoU5z5aeOrhxAYtQ+CvtonQZENrc87BlEDGIt6p3wQGseZG38R guSSqiQPwmo5rtQ7IgxBpY0kAtKmnitQf+GCRg59AjYJZEQtI3AY48pX7S0Jo6IoVL8EobcK YtXogcuAHOPqISCYh1GuskkC0AY5S/YK4lpqausjHheAacphQVku8yBy6BMIQ3lTWrkR1OU4 UYkuQZNJo3Y3YXcql/gNMJrSoU8mLIEUqCXBRBkQWNX14FCBNqiNBe65qXPVlExSjtMsci14 Mdyn2tf4iyZM40L9O8aYOPRVNjdVEeZWigRu5oPG7Or/47AxocphBjQwNCLJX4D9UWrtzkWa JzaCSpi5Q59A8QZWWlkvaw6ETq2vTZMkrZ+rAX048NV22YBwlxWurb7Jc1PFsdqixklVGI3u aSIf7qFay4DZAclV3QiuchzVoUOfGtATkyywlk4/jwOru8Jm4H7LXptsDNK1RiM1QPOajiVB RBX1jYIKHWWqE9dFA2RcrRB1GQFTVVtHbbKgSUrXSt2UUd6ohQ907SQM1O4GVDyLS9VGQV8o /Uq1gxrgB3jr0KcaLiysRCMukhD0tXHrcwJFUP2bdQC012iETh2ZFGPwnJFCDKpQy7oIYrJX oBsgPqnsXaU1MCmViqssAJHB9VVU6JdP1V9eRaDeWIswEIVoHKoNvvKDAJiNSsVlDGB04wqq YgyavNoRq3GVI9eQv3K/DALVeStAFj/TiBcAGAZ2OPSpaiq/tv5nUBzCMm+jikjM1IgLPwUB T3VeEAmA7YcOfQKlHAQqtV+CDpPCB6rDZykQUbX+5Qm8WKhNLo+NP/Yr13IOGk+VqfaQA/Uq bMxaXkWggqrHJK9ByMlVv0HPStq48WF5nmV+oppfXkYB6NDqXy4aDEVRmx0L0ao9VMBrGjcG cgxquwk09g+gD1iq/gjQjPy81nhDFIca67EE3I/jfOzQp/EYFOpINZ5xlBdprBa8cZiApq42 xrEfoNtbPQxBXdVF7dCncZyDKKr27nGSBEVq4xizAPBPbSzjtE6yUC3yoiK41vxxCIK92sML GMaPbcxUWYAQrbabwpgys3FacIg5iIMOfSpA0i0qa1ur4ORStUQXIFmNA/VmAX5EplR9uYhB f04yhz4VSZmBFK7and+Mw1ztGaDMF3GkXpwC48Fq9SMVYQn0NXfokyhA6sWJfVBb1EcFEhwI pepNga2BiqCxfSX8Xpe+Q5/KyG/KILJ23Dj3G9WnSx8wIlGvX4k2CRuhUxZBEo9d+2Q5Bg5u raRlngdoAZS/qtqAOqW+3DqAa9l6WpIiMa5fAHY7jmK0Dl6v15ZjIBGZRskVBchGY6W0IMyB 2m0sdqdhzhS89aSbxlfLWQiiSNKoVSev6yyyehMIl6ANmFYqHsfN2JX2gKUZGz1cZ34wzlT/ iQF5ysbaDEElrMeq38D1A5HB1edBtI0CX7l34gc5mq3k6XEBd9lyLOCoeaM6ZBwWcHldPQRG LitrZ0uzKisyq2vgvRmrXRzDP4DCKPVJihqUDucehXUA+K26UdQUcZkphYcpx7WvXD8o0O4Z Wl8igLBxLXKAdmloo3F9kALiTPW1Ak4CiJeOBPpvNVaZ3i+iMs1Kh5oC38t8X7E/bBL0BimV Rm3AesiBguSNbz1BNShR2djBghQDbLPWEh4VxlcsBZA2caOyH54UCB96GqCTBxx3qGcHdA40 EbW9+qbGaKwvVaYJykZvTgMMCRBIMWQMN5utmlaWDdFRoXIYynOZ1cmaOE8blduBoyT+WHWu OsF7n7laFnA34LuqtQMoahsHi1bZMrP2ObTZjtWnEWbA8xuXmpagvcWZckKMyQx9pZiBj9H9 qocU43hsxqq35kBQknHkrAnEeoCitSQEQQ3M3XqciwD4jHrxYhApG7UnFlVVAFNy6Q2IzX5m LUgYAuirHyYxaGdWOcukQYXxegJ/ULPKTkwCqD5J3ahlBCMyjI3ESgGh0NQs8C8rtBipPBSB GDJ2o9wrDBVtVObJohK0IZWR0wA4kI2MqWENoCSrZhenTT52rfMgjkZNo9YPY9IUdCD1uYJU FmVqdQbumoc2uqhMfcCD0JGs4MZiZJ/aopAsjFUOBg5cYviznEaeUhiLYEFZhxnbka08lJqg UetGVIZpY2P1kOuDPGW90ejhVBkgzEEQGbvenhJDI3zl8z5cNfRdyAoNyIZj1d6KtAkw3l7O DgSyuunYr9PQlGPlb0kMGGdjJU0VgrCk1gCQzP14rBolCLlV2LiZHHUJR+CrvJRGcWJsxEta AuXzVfYDuTaCu6f8IYjSdOxGAGcY39OoxcXECYZ3qyZbgczlqyUnNqAxNyqPNin6BsOOfw20 67F6dII0ykyjnjof3c++ypSoWYfWS4GmmKAnN4IsMlbZY4wBgDZeOAJNtLTWGoMGota2nZik Dlx/CIg1gIlqu2ngNIK8tjYWwIrA5nUU4yy2+n01jkLDUorCyQdSYWyEFWAIKKSaOwBCbpOr nj4GnTVJE+uJAJoSuJkcGH/h5ypRBE0EmKpSpo8JJIHafcokQmFQb0sNlDpwc4z8BLS7VG0h QRbnYW4lOlBsY6PSdhSGYWbjbsYgggZB7nAEOMkSaJTeAT/P6lztJBhvBRhoo8LjcWFC620D Mh24tsC0iIM0VdtOg05+o/a+uAmLKNdIm6RGSm6zJpIwaoLGzQYAcSTI1ZLQJHDbjWq5JkuB 2Y9t1kptylTt/hUsf2wS179WlImxXox07PtxqtaN2i+rMFBv5xjuchRYG6+fRknq+gXCEATs XKOvQHcASKom62dlXaRqhSgbgEugGnJRlyDFu7HEcLFAbVG/QQDiamzU3lrAxQttxFGZZeU4 VUuBD0qgCdyIizwMMNNDb1NRVKVRvzZoa3kQqA147Bcg42tmUA2aUJq6MVMpOqcDG2cXVhTe J1AtsqjK1d+QgEDUBOqphns+Bk3VuS2gD9RIZOXckwBuZWWtvnFtjMreFb+sa0LjSjp25QIM 2QnUWgasG1Aqsda/HA5LY7ySKASE0YhyYDQkzzp0PGryKlXrrI8h14Fa8AKQvHzrmysCzDWz vtwqL9GK1440jkOMubD+wpyYhsAf7kZj1KoYpkkM2oXKe8aMQZJ3I4CrBK3wKvPFcC1T1fEx wjA0qgeCYFvEuerwfhQ1Jo1dObMcw2Gr5dZEBuNjVDoHFaxJVQ+Pc5OjeCUQDZIkMq71Na1A HU3Vcl7HEYZPqpyZghpjYwZBhMyKXG0DdQoSX+BGzqWmgjNR2w0I9uk4V29KFVegzKqHLQFq U6dtDEURlIHrRWsw1NWoLTAuCwoXFchEVZnmNk8IrgtIGaoVYsxE4MZc+0GGgfB6IhUGX6ld FETFJM/VxoVB+CCmqf5gMNQvdbEAbk+QagxYBFphFqgHLqxSoEk26zSuozLXDCo/BxIauPbJ MijHJlV7UxH5dZyrByjAeHmjXkE0IkbG2hiB6CVsL1KbaQ6SgfXiwHqz3EaHVsA3i1y9Q1ns V5X13KVpCVQtd6gKqImJn6Id63q9Fq6u79toeNh34BvVZMsiAdVPsR9UbCC7HasOiBNttHwE qjUarRQKeZLGqq+BOjOuS5VlQUoc15XrewDcAL6uki88m9ehcpawjAFBlLOX6OAIVDr1s7AG 2LvZtiDll1aWTUFzKjPlhA1mJfoq5cegUpa58tQalKzSuN5DTM+pi8DSIxAVa+XlQE8wVExv FRpwI5UIkhSzTd18isovQHJXrT1Ds2Co9xfIKrBYtYSDDojGS9Xvc8wgTJ2R0igCmd9q5gl6 zdT3Q9feWFnKBH6aq8xvYuDqvuvFwL67GCAvM4EgDDRJ+XwGokqsEkNTjxPMThCIliWIlIWr PYCuVNosa8w0LkO1sNfwZ1kqpQUJErMIdE1RWtVj1/cAInBV2yyJqvER4OqjyaO6DpR+FhVc slwtCVEBGrpJXNseSHSAKJotAhcd5ATlx0kTl7GN0YyquIzUDgLInpRF5UYSNEUCG7DW1HLs h+qvBdjDRCopYsCcbyOAURzwy9JdU5YBVVH5LkAeNVbdtADGh4qj7KcGMSVVTRXITQC3xc3V SwGlS9/au0LQPjXOD8glZq6rDTQfJ3BblNI2ZVKy1cxaCU0Mt8XK5jXcTJtHFlbAQ1WmjGK4 VNb3MzZotHUlUBACQHVVDRkUvRoog2p3mO5Zq1SM3hugDCoPAXUHquF6VmKMH1MPVRoCka5U AgV88eG22NhcHxidWsJBok/8jr82AwIGt8n6CED5GasGkGQVoKPGWFQgT5a+WvcS3+RANVyv WFGCGmNjp9H0Z7NT6wZ4X62yB8jwNVAN61PKQLceuz7kJK5qm/magGAIt0VvsEG6olZnoPAg 26r2bDCwrXTjssit0thsHhCr6rHGqWCCdh2ov7wpGxDGbcZFYTBHyM0AroDSWDksTsfj1Frw 4N6MU1+lsiwKa6AM6tODSwZUw7UqgqoB1EH9IXlWwR3WeJIqC+C2aDQ06BlwkzR2xg98v5Nh N8ZEapupG4IIBLdFrc7RGD0VGnGU13FqM/dAHIhTzljW22KaHKiDRlmPqxwoh44L9wZ2aG3b BfrPdU1ZVANlcLjUGK4WUA7laSX6LNXSA8JqVdqov9AfRyVbIXBcUOnhlrlRRaAgwE1Uz0pR h2WgXqYoB/qbqA5TNFkGt1vjj5IQ5FY3FwiUUzhsq7UDg4PbpHpiHAHXUa8kXLICbqF6McYJ aD9ZJ9IJKK6V0fK6AS1X7X1hVsBd09xCUOuMn6nvJ47zyG9ceagGNRFumtXX4KgClYBAhQc2 lVodEhUateABm8/gdnciUyK40WoLNJmPZFEjU+DqwE1Sn7cflnDTdFw0QRed7O0qLuCW2riP uoEbrF7j3DRwu62MVhq4/eqBTcYGKIMzksFM4lQl3wwUU7hp6i+MqxBuocYGAG2CG6o+ZOC3 cIPdugJZksENVy9r7adlolZfYEopUAb10BYhUFQbzVkFIAq6mQRNGoOwa+NrUQ+M1f5SRaaB G6wRCkAz4HarR78BwdW4UftZXoIoazVOzGUN1J4UYM5lqrp2AVwHbqGVtg0ofq7WnicgyVeq NfpRnMENV99PDuJIqPongCn1W98PyDBwkxwJIxwj6VOdIA+TAm6hjRJMiza6AVhOAzdY9bGg auB2OyMB2QY2YXOb6sIAZdA1+VUIt0Ujt9BREalXEvQMUCdcXdtH9a5Wex+aI+G2aLxbA3qH UXsG0KoMbovG9kVJBjfJXRMmdjSqPQRxBrxGvQgFkAmgDBo5N8aEbfU35EhgQjdzDqiTAcqh cMww5UIt52FQN0A5NDYgBhEjsjmDoPRiOoCDT+MSxC2bIW+AsRSqeVQ1sGej2hsmpZU2u8QE WQa3xcHMLIszuE2Kb2lSoNQkdwcDhhu1kwCI4VW16oIcDBJO4K4JrilQB83jyjHTQC2SaL8G yqB2BVSXK7VdZgBNuC3uDTZYQUY1ziQGoSJWX0UVlpFvYyzSIMQ0Uhs/C5Ik+4KsjSvOUqsZ AjPI4DbZCKu0AMqglrYqARahVisYpqwbNyOs8aMSKIeuKSoMUAbrFQS5s9QotaypGqAManfL G5DqImckQPoQM24F+wrYUVFZi1gelTbaFRYYwU1S+1eCCO3GlgFdT+E2qWUKLjTcFvWrAhXB rE75DjRRoAzqZR3D3gPXz+SHQQnUQSMj4PamNj8jyrDWhnrCimBsgGooPwMo+YlbNQENMEA5 bvTXxkGEgbEaYxCmYWRzFyqAQFi3FKRKUCJ1ThXEmMzytzFe/CKxfrAclEql6YDLRZ3bCkeg 6wD9d2X+AtiK1ddAXMibWLmzX4EYmKg2FNeZgTPXuAaDbCR3pJiqwdxXW6snCMLK5j2AIBXV 1haJ2S2NzY/KwzgA+u+sCThA1lqAg9gg11Ful5UJ5vHKu+kY74ZKxTl8U7qxGBR96yvFBLW7 AG3cVhihMggtnyfzr8yJFXSqxo03ajBWwdrjjW8AMCqphMAGY6WPwKySvFG7XwjkvwzdSN0U g5hzjUgoUhOYsUbzGIzIt3UyYNSoNjbLGghZlbiRASDGmjYn2ACRi1OVfMMxKHo2ZyjNgen4 aq0DulRGQeTIjaZJMMdAZUOszJApJQaxHOCtFkR0JsRpbTVKP0vqyo2KDRJgoypXoi6UlmqF aLImCm0UY5lWYRRY72CSB0HlZr9EIDD4mdpJGiyKZfNDShCDx7FaazKQngubDxkBPpdh5Gg0 DWYXRiqBlgZ9smpjyWpK1lO9FpM/jM3YTGJ806WmMaBIqBakcYZMSXl5BQQlidWS4GPmW6KS Labr+8a1Oo/hlENbRwDuZB6NVf/3kRT7kZWlMBDZVqHAgKjUtVxWoCyNa7W9wskBcVJpAxAo qDO1V4xL4EdFau3tSYTc0Ll3cYLFx/TOAs0pfNXu6jRqAOZWQ/ZRRVMO64OOknXqwAVFDoKV rYbWFIDlemcjzKdSvTapMDPIyh61SbPc9SHXQHGS2MaoNeM4bjQ/I0FztFEuGmAGv606VhcZ QLDj8ysx51H1zyIDvKxVn+bsWiuJJBhXbOtcxdFYIgX03gHvywO1bqAjBc5a72xQoSPDVsIB kaYKraZkMBXMtaZi7m6jnAUpKua4yLsYJp2rBFSUmBWr2qYp0Kju8vkQJGIQp2zkN/D5RGU0 YIR5ZO06ZYauUpXEsxgk9dzNaI6SsAC46p0N4XpEamkDvbaOx5oZkflwXInNawcqLv4zvXeY XWVrD5UNuphVG8oqmNRXTykIb35V2kpDRUTZSO1IcHuyPFDvVTZO4rJSb2iUp6hM6W3BMmOR 2hhBqsqlVpXelrwpykRttWNQHwob7QmYBbxbrWW+AQ4Qq56BAQh1nro3uPLRpa43HE4uKdRW C/w/iq2XrwpAjqzUdjb2Y7h1dScavc4i66f0UyAxtep6VQKr9dXbibm1gc2cBG2niAM30imB 6wtas95SoHMg3eoNztFaqxE8gcHaAGoFSuDkotSNhMtRTCjV+lHXQeX7NiIpBJ5qI8KSKMJA xDaKNCzYDqU3OEgi4Nl6w2EJTawWlyQDacNmMeZxAZqRWgZrzCxkud36HsoKFEflnGOgepVa N1JMQQhUv+HsWrXCYfp/WrqVBIoK80GtvalBY7lK6iFlkaqd0IB+D1iutxA4UpVkbp5ExBm2 8m6YJk2k1jIDv5c2/6IAzbvI1daHfpNx7ErFIagaeaN2nxIEsypRW0eT51i3RblqUVVY0lJu A9AxM3YtwiVw/iJXn1NTgzYaqo8E3XZ5o5oqMOTx2MbtlhjKVIUu5wyAomZqOY+wUkihdpIs yrIoUB9mGQMv8a3fKCFTgYOZcKMjoFA2fqwME1uTM4YDwpoLgv8N0AwbFc7ZtY1r4wLOD6Ko 3lmgVXlqa70B4x/Xapeu4IwBpiol53h1XP9JnCaYjat3FpOTxjZSOo4aQFy9swnm16pVPQ7z cdy4udF+VOQg9+idxezVXK0FIDwB31U/R9AAOR1b3dQ0cRi5vtEcGZdRPaWu8jRI1FoJlBpE EtWekyICKV9tvHmeUqUK596NE0xN0zubxcB9VA9MkFcUaunMkxB0zcxq3sDCqtSVoiOgxrYW ZQIKf57aqpYgvZalat5A0XO4I6prA5Zmxo2WKeoKHdZ6Z4GLxrbuKQgJoOBprgMo9KDaqqW5 yKnii+tnKhLQC9ViH2IVl8bW84izHKUkeRfU57KyWnkalHknxgXj+zC5Ud71gQ2VarEHtl5j aRR5N8Q7aC2okQFMdSvNAgkCYVJ9Y01V+3CWemcbrBpha6MZuJGBWtJKUIFq340zbcZBUtn4 8whDO1L1WIGyn8Gd1jubYAUb9UE1MbBC41qmQNUCvctYi2QELEStmSXo/qAc2UhMrO+hdsII M/g7kb0ZcO8wRnvr9XptlKWg0at0lBoQGGKbQQR6T5wqRawr9NG4/loDwlJV2qjpMKtQ9NI7 GKRS7YboI2iYkWoAYyC0deDGQ9agzOcW+iB9YhaOVnGJG0CBNtMqj2pbkdYHDRG0u05dljhD W49AECTiMLXxRiDGYAlk5amg2YVtdmRQp37gYj+MEjbKAfIyDUxt6Q2WfioDSz/hXHO1DQDy hlHiensajI/MAmslwbgUxX64U1Vma1kFgBGRrZID8q+PZMA51WJsyrHK0HGN2VWqZRnQXeNa 9ZA6C2Ehancamzys8sjh86B+jv1Sb2xUGRPHkaXLgHapyg+YzVb56stN4WDQPNCOBHJ9lhhr K26yOq9U/4+ASNe2+osfYPUspUXjuGySzLUVl1j+2GZ9GAyeitTGAhcbYKaSeg4KPZqzBaIZ 6Fm5G3vYGJRvbSZQDsp4rbc5ruI6DdXSBKwtK3xrOQbOazr1tQKQCsLWuzsu42ysGkKAcWaF 2n3iFPSHSiWCLADUM24sawOUOguULgOIQK23ESEFHFaiNpSiLsIos9Ui/TGQ6Q69yUyWjNUL WxhQxo3qy3kOSlNlNbQqTPLIRmOUIDMHrucXJgkCm48Uw4WvE6Xp2bgGDV+5ZNyUKYbPy7gp 1uV247XDIMWafWo3j0Ft8VXXwKisOFQLUlUAz4lVtgAKXVSpW28E5BqDSbeCJRlp8eo9BD4Y jW1cUJ77rYacVuO0W7c7KU0FmpVWdw+xoJNK2xHw9SZSmu2PQaSxuSMoS6R1J04iBaHM2oOT oApAodYMO5BvitTqpkDaMMdW6B4mB4RufYhxnQLBUr9RCHoUaPwaVwCXOUiU64OI1rS6XJaj zSV2Y6CqNAICoFiCemGlVuc8LLOkUCmmSOoaZCC1lo4B21hTUkrXNCAFKJ9v0tjEvo2aAB14 3GbUxoCytdpfQNQc+x2rMxasjPPY2gfGFVwY5SZ+OgbAah5yBlQkslX54MSzxM1xAUEwhT1Y vxFIaWO1SJZlUbQZ/yYMgLCrdAT4a8pO7IZBw2doK5sATENf+fEYGB4cnUrxASZ22Pj+GK5V mTg4jsp/mKu1BuCbpI36gVM0m9SqjY79oIwSG72QZUHDMrC1JFRNGajGD9cbCKHacbHeK9Bj pado4zWqlQMzy8qxW4/aTzAYWjUPkBdAarGV95rQN7FKE8CiTBGqXScNGmDtblw7PBmGjbEe kPHY1NZ2hu6qUiUrrAqNgwm+ALvAYobtSBV2NwisrGuwFrpaEtCzlSTqowmrAJhCYyXmrKjH jXOD47CKc5vtBihtksrWMQGm5vuqw2cgsVU2diOEqwFCv0vHgySLU7Xc5nGMSUi2Nl1YghSp MRagHIxr60OumyZuXL029ZMaU3AFqqBYlYV6Un0zzkGStDkJJoqM2hjLCthdp/8CBn2UNte7 DkEYSWyGVRKXUaaSIkg8oCWqh8k0QI+454DSzLQeg7CrnDUoQ9ARlOvGoCCHmnGEqFX4mjWE 0XaGIzmUZoKMA/Kt3mCQPxLT5tbkcV6p/p+B5l0XGp8Et94POF/EesiTNLG+U9gosGFbozkc h3WkNpY8MeMgUEkdxPsmrt0a2QDSZNyozwm5RWV9JMC/At/WzshiH/iFWqbiKMX4ebdefgGz +hqhGtZl7oeqc8U+aqZqJQWpHYN4VHsA/oWpuM5IWK7ExjOAxINJ59b6lwAHUAtRE8K1C232 MKaU+m5kZQNQQ2u5fI/Fq9paoCmIPGO1kxRYtrKweRKAzuhdcdYU+UmWqe0gLsoyshVhshpu ZJRbvx2Qblvlwc8whM2NKkqMCXxr1UpzUMka2wWlylEAV3paNllsq0ACp8BoVlfLAqZbpTaj dgxwKdrsSRDjbAQVlj4PbOxtHdSgfo5daxmcax5pllQaFWkSqM0oAtUvyNSb5WMBqsTaYn3Q CUO32lMONzb01QZZoeCcqtbe5KkprI0lqzIQuG3GSxnAQbpxEqCBVWmjsU0hkEW8EnJ3xuOg CdTXC5QVyLp6EDKggcigHUoHJBTIn2JJTGZqtQlFMbyqul5RYEiCWvrzGnZjCgczQTfFGESV R7IAKK7NXjUFXJE2Z62qx6Gtn13VZVW71VejsgQCoNYNEIub2Ga1JHC5x6WtgjIGgmMrKgI2 gUbsen79tAGVX3VXtPzlgVoky3hcgByt8l5k/MDWbqiLxCSFG7VvauDLVG/1er0W6+wDUVe8 KyusTqWxt6aAm6M+sgREqzR0szqisPFrW6+5rpIGdA3VZAEFa5urBDoGCDhKH8cFsJxxJ4sx Nn5pqw1xdq1S8XKMLg0bb1cDqbJZ+BHI7HXjSgxJGmD2idqKkZXkKvOATOwDoFSKjPMmsNm2 IHmMQdxzberjClNTNC+oLjAQX2u6RLD+UDUAEFybyqjfNPNBRua6blY3wgRy1WiaEvDX6pC5 AYXN+pfDDG2eqj0DvWiyyMVZNEEAg9M6DnkMqrnq+EBZ0RGpdVngJMfG1mCGU45KV/+vAQPG mVpMUzitxFaB8+EkTduXBU4ZyKeeHWCBSVy9tobTGlu5voSTjAprCYeTxqoDskLAgshqWWMM eY/daqqASqCvqbyKcVemju3NAcEjUJmmgN9CWyMdZJ8mZ+3AytcR6Koqy4I2l+Wm9RulcD9V Q8vhJBvbsSmr8d678drAq33kcDISnFbe2JwVOEm0zCrHwoQc5U8FYIHUt7OcMM4aWz0ZGL6P kZiyihBj+tW6ATLwGC67niuQ6CB2q/sn46gpxqqZl2kOl0VtunXUgHak8XhpAbqmreINyD4G rdKt6hj4wMDVaz8GSbeK1E5Vh2hnVrkdI/MCK20nmNmauxXvIhAAQWmxOdkmk4gMnAWU4MxW 6Acm01Sl2mWB5GKAtiNZAcsBsqJ2c0x+KQPV2sO8yvzYxhtVBXak0WhCQFI4Wdc36mMnAJWv AW39NFUpP0Cp0UaXgCCXlW1nmHHsg+rjdrAAXQGuj5WDxyBnBtZfVfq1rTQJRwxUwubJALMF edWthBMHTWpraIGmlIU2DzOFk2y5/niM3k2VswxgQR65de1AdsJkAdVo4CSbsdoCazjpuFaf BkbWN221czipnPuuqHwNpwmSm2pScNJ5afN2sT1PptpQCafV+GpRqeEkY44VViyAk25yleQT wALQ/azsB0p+o/HlDZwkdksTGMIpR5yRaS0uoMgWbfeRKEtq1d5Au/FNYKMBMJzcxpGFCfoH XT0kg9MaW9kkgJOMMrUMNnDSY+sVzgELIsthQzgpk4fOmmI4zSRRuRHFC8BsxVPAgqRSuxtI BNiiQqmggaPgOEtru0FstH3VkiA3la2UXoVBVKqNBURgrF6gHBnDXjs1Ccch5tdm1saSY5Cd Uv2gyZNAZfOkSVITqxQZFVGQjN382nHka/U9j7pxgVKmVl9/XAUYji4rrIsUO1QJHGITgKzk 6rXwbFOpTRuUTVCHbDU0eLxJ1LMFR4EmRqWCaQCA6FjnQYIBfUI5dl3neWarrKEyYOOtsHtB bDvrVb4fNJw7o1QlSdM4sJVLq8Tkqa28l0d5WKiFKM+QitueBGEThFHXkhDkQLUUFnCSdaY6 8Rg7fYRqhTCABbVRW0cCJ+VztXnrxTBw0WxNUThp37e1Vyi7trY23iioba49MKw0jVwvawon jcZaOS0s3laoDsPZterRrMdoStCYnAhOuezEbmDdUt/WAsnhtLLQ5nHBSYJWrBGzcMogyioM sXBd5voqKjitwG9rRoBMbWNGgITDUasNPkTnSqIaTQabA4br6mvYr9R2MWrgpCubeZ8DFmSR 6rwhnFZhK1vHGVa8cOtrFXDSRa0eZ9C8TRCoBc8H3hDXGk2WgjrZ2A5sQMTTOHZrpgKHBhlE 7ZcJkMzQVorGIIk8UutfXWCdUGuTw4YQhXF79eSgGtn8TmDQsCIbpRb6pvFtTQ6Mea1Uv0Hr Hbzm1iErozTMVPOLgFLloeraiY9F4dRynudlnsRq6W+q2pixG/UYhFmQ1BrtlwG9NIH6IyoY pY0wLEpQMwr10sQJljL0HW4eAjKNI9V4YAOB8dWCR+WDbV3HpgaKaWN6c1BwksSNjQ5BsB/b yvwxoFBkKwmAUGPGbS0xUP6xCLvAYYzFMV0rUAKnWdkuRiWcdGajpGrAgqpQ200K7wW216QP J1kEbk8jAycdxLY+AGBBYavgAyphPWE9dzhJENZthYgCu3C4nBOwANiJjaYBLLdx7QZOMkhs vHDJGbayQsCCoHIrwhYYLZ2qVl/BSda211sIJ5026k2JsfdZZKvnwUn53D1P5Sc4TdC+VLKB k/Zr238BsKC0OV4xnFZt6/CHGORiXPtkBSddlzZHNcUa7JqNHsBplb7NcoeT9Cv1tABJDLCr XzsSqGxoWES99rdmVk8aVG/3vr//P63ts/25vv9zbZppsTKj6kfNcW3/59AHzS7d6P+cJdmv /Z9/gZ+7tz17yNgBupqfXyzMcunVxarw1svJ7BSb0stDk/nMK6an88VkdXaOzaAfzy+uFpPT s5W3/3jgBXmeHIR+4Ht/NsXsYDpfX3jPigl2hy5mtfeiWLzzDuupWeCrT+cL7A5dT3DUpTdv vHqyXC0m5ZqngRfWSzP0lsbAczrNbL6aVMabzDxE09EZ95q+extH9A6fP3v1+vjtZy/gL/oA f97C6m/Z5d/yLhbzijZoLuCGwsQzrzS4TexG7a3m3qQ2s9WkufIu5gtamx0K1oiwmMwu1itv Zb5deZdnk+rMKxZG3sKW1zCEKRbTiVnIk/uXAC5YcWEHWk4nNU55OZnV80tvtQAg4d+lgedq Z5JqvVjAuNhem9Yoizf1YNTf4/l8ufKWOBTAqZkvLosFjGSqs9nkn2vY2HqBUMaFz2EwmqMp lisDb8HTdigahidvJlOzvAerg+ObTgEcy+UEYXRerKozs6QjWpqpqVY0Gvb2htFGnVW9M1ce MAuY3TD4JssWgzz4Y3VW4HxLw7CGX2F9OBziwuzUDlZPKnygwMXAWO8N/LKcnF/AegoC2XpJ +xnSnzUsi8fDh4v3czie2o6FSA7fm+nVyDtup8ZHL8wCoHGO3c1XcIxwuHIQZ8WiqFZmMYQz NwtTtFjBC22h0hllPoOzgzdmtCe4Wu8nc1gpPewh/o28N4ByKzsagASeasxC0XGJaArHAsOu JueE+joVfAsHAwhE0MDd96HmABbBQoBogTNixMHR6ALYc8EG8MtzGLu3ySUuD8a8mCxgb81i fs7nByf7uihhZX/wPi8WFyPv0CsX65XBgeC2FheAtwBLd5Nwt2vcQIMIT6izsJMQvApegYDq rFgC1sLHzXw9q1scO0QkmEyLRReraHRYD5z0pPL2yyvvz0CQiAD9tThfDggazcKY74wdCp96 buYzgNCni/n6HaDqoJ2I5rLnBwBfIpVSlMarwpMWfFTL+QV8jgRhhR+6NNNO9nRSTAtayTNY ycwMhJzAeKdrQLfZyjCMFusZbgZIhMGNniNd+s7BZ8SLoQeEk8BUeAAOBGcBqyxOkXritYDV LXlt5wb+YZKM2AYrhJkcmH42vzTwKmHs0z88cyB7XiAhYrqxYCyZA0qeAckBNAecgLOBZduR iIJ4EyabF7Clc4MvnhffnsCFArljamanqzNvvzbLCkg/bLc0gNADogzzOe/EkrrDx5+/fPXX 50dPnh29OHr59k2fBMIlL/BIpsV3V555X0zXzLLgI70yMG69pnvVQQiiGnasY8YyuJYI9k8Y Tz7xLgEIACtvE09cmlfM3tHNPC9mwELMHCkUQqpcnwKEkKfwXUTKC9huN/f66OnR66OXj486 23pi1qtldTb0no++GA1vPTl6+vzw7RHwXWbTALAnyKiBmcIOvTcXppo0iHTI6pxb8h4YDBEU 2M/ZanVx7+7dy8vL0cSsmtF8cXp30VT4vyBPgtHq25W7gkOPD+diZRHeyG3HbeB9796908l7 Q/iKD5bz+Tv3Dt061EeXtxCQr4H+mfrUXE6qd0MQDkAGmM8O/mqWU3M19C7CJOwwOroyw6PR 69HQuTjDJ6PPOjeVYKIwwmUjB4aXZxOgSX8lpgtHDg+cjw4fvxh6UTiMvf0gH+cDD9SIgyRP eFaSLbw/7f924P3uuP4dffDbyayarmsrVZjR2a29PRBllswmVKA6sVLL1994D1FBuKVfeSRe O9LTB0tO3q37JO14x413NV/jrSY4ozQEBKJcIIPEo0FRoV5XxA+9ono3m19OAdDncNfxkC7N FGgjED89qHperfFLe2Ng9IUOMsLp7HVH7gfP4PRVMQOJjEZhmCzXKA/1ZxzClbqcr6c1sQLA UYQBcQ4c5J0xF0RG9zxH0hO2Kssz35pqvSIU7q/NHtPDn+6HkOnpekYyB860mq+uLsySJ8Nf saOrma3PxXE5A1J9gtR1yBgIyymn8+odCqxW3qiH9BxTYZYrAKb0Fwhm+CcMjm/Tqyf1fCbD 2dGa6Xp55ogX8jww0cny7ARVGZoFnuePPPsRTUzSiDsfnMAM5VjFy+54uACdX8bjNRVVZS5Q GO9tpd3F97IHmH9l7u9ZkDmfevu3Vds4aQDUA+/V0/19vTz8yG24piAR8r4HA8T9zr1u5IhG 3mvDEi4RHYIVj1A0K2FlIJtPR4Qr8DXI6SQLAYeanogYDj/bVoDT8hvu4tun5igLfcDSd49B ktv2yXtj/HbSzBCMTw/fvD168/a6dU1pRx8yJhsqdg+1mJpdsPngLZ6tm+ZjxqDDmZ6fIMlW qn794dAbgH1vzoDFvnjz6e4lr49hvrL3Js1/grI2Uh168zt4B2jd+QXSovP2eVwufF6flOvG XVv3+aH36dUKjuo2PAVzzpaT0xkgyhIkNzlJPMjDNy/+ssdD0DJITuFd45D4GTyNF7BYngMh qfG2gcpcTCffMamWK+vxtkQJO2GpeQcAjr+YL1G15KcYB6ZLI9v7ceMQLununhx9+uUzGZb3 B0IY4AaPes2gRLbkd3p4uOdd84MnwqKku4ifniU8p52gaYSZzm9h+SCUey+Pn3s+zvcWeDYy KJDDzzwScZciM/C9ffvq1cnTw9d7v/U8eVU+8TBuTVcOA70QeRWlWZaRI9IsQT6qQLFH7YYk scmCzCbFrEIeWQGRX9ohhS3+BeRgGAnZNwreKBzzAQy90/m8lsNAMaMvlw/FSII3Yj5DALAp aEnq3wXweFjcezP19v3RKB+wOvmep2MpkKR5gMZ7w9rbaj0jlQbHguWSyHA5X6DkVCyt3ky7 wfWCbnI2n85Pya5CysTI+9SskKLLNKyR4HAsspOQIlKwvNFh2XAzQWZAw1MzOT1ZMvdGnkqg 4G3TdUNlBlZBqsQS1C4EUTl/b1jfY5jJyfANxEEUvveFadZz4v+yrY8cbDapjLuif66BKHzU Uugs7+MnHUZLXPM+sGiGwn17XbtcRSRaekb+WS+I5pyQIPZ1CGItAPCuyN0IQd4irpyxHxcE 3/vwr/cvn4QZ/K/9rctFvx8S1OgPllX49YBej+kl/O9Yf3MZ6PffE5Rg34gAJPLMeTmq+8Fg Lp27cX+B/z9rg8Ob9wcPhM5YydALUvpt3B8LH42cR1PSguAX/G/vUXw27i6Rh8X/ugKH7G/L qhJ6fawvbU7Fr+OjaffRIBzLfzYfzdpHcSx6Kkw2FoWPjulR5ykc1Q/jbc/m9ll6jP6D9Ln3 bItwlSOSEpZZBvRyvjL3HAu62R8wF18YuM8LomBMM7xHD70Xxy9PXhy+ffxZlxzjV7HazN2z gcH2iQIvvQcPvWjAKIo2utMZiaU4DA3OhiFYVWPQoIyDnYOmKQYIh5Ud/d8vD4WZwerWUzLu nZvzCsQaJK6wbLg7aqlzedvLVydPvnzx4u8nT44eP98TQot8fVKdgFxkTtCOgCQXuXW9Pj+/ us8QFOvI6RXBEWj2YtmD4k/Mxr+8qEk1YDZNnIQtBHhOar5ARaYECQ5fOH7pgfwlptR7ZA1H bYLsPPD/X37x5PDt0clnh28+IyZ9XtQyINIYVFxhTLFP9MzJIPAs56wKF2jnwxPhZaHlHNRr tLchWNar1uKqY1lzJD4LosYKhFI8LtU34QRhmdVaPDdkzkZbIR+5nriz+v3l8GwIitj+GRC+ /f39s8GDB8uDR7iek+XZpFkNvP/w9qvBwPuDp5+fF8t3g72f45jYNK+GAPjH2iocXwD5IFYi N58hAMR/YIGDH+JwYrpqRTNvf6V+EwAUGkZkKjq6ZXFu7EkMVMFUIciOLox3Y3CyRx275mH4 V/C75hkOngjDHbJ+6hARFqsmSzag0/JhWwEbvYDuu/IlYxxcKvifmHFvwNfjl2+OXr89efP2 9fHLZx+NseJvAQltgoJbS7PwtpDEikdFThrQUtSquo/S6QX5mthbVLjvHgTt2633C8E2EGTt SiiKu52d7ONlWi2GDjIMvH+g+LPfxXHEXYDcyRn9xtr/1/vw6sC74+07ixp8MxjyCC6CPSTc h9++1nG+0ac2vsB7BErMgEYfiPzx7189oq+8Qzf5kq7xNz9uaz8XuT5Whde0d4xNgfvk0MIr m8afeyASLxrUNxDHgtQrUV6+Aqp4Lo4c2vU3gOdwH0pHkSbLGKP09KpLHB8/Pzp8LZAfbEKC KSOMcBAgPEAPvC8PfQc88zuzmO/vixlgIK8NvX01BgDoOkMMbuO/82b/tjyL2uxPClDcGrLf r47+9sWr129VmEAIn+yz1YJIz1A9XISTpjinFQ54Zx0zB6kXooDDi/ynYwy/LQO1zzkD3t9j 6+mCaKu7mrC3nK9OxPXxZOi9OPzbyV8/PX77ZujBhycvjl6cPD/6y9Hza2wE9Prhl8/pssEo z/6+Y4e8TNTk56C93RNBinZ68AhNpSfAN0D1viR3H3qIQLAS+yGaPX+x4+oD6NyAqgzIxWv5 dLJa4mfnz/lbjAtYmdOrbSD6+JN2j5r+5smdD9pVdJ7i5Tgf6bp+GNr0jUftw5eL4gLuY8Cf sBDqDn9+dSIToG/G++r58acnfzl6/eb41Uu4cfgO6NBwaZGkTIsrixV/NZ585IlhhIyAFHKA v92Z4n/REII+lvni3dJbTtCagcRF/LF8BLfVWI4bIoq1L0YXteewokAuSxDuwxjpGVoz6O27 vErAxH31RQO6fHXy8svnz73//m891K9Bhf3NQ3e78MF//7fFAgeo+JyQHz13kPP+ZR+VO/qV wunk6PXrV68ZMt/bxSCitCsZtG/BvTs6fKEvybHgpTpfnnr6/P3OOAePvsPwhgrH26ff2E/g u8uCQ3mDcQKv3pAAVaDU8K27P2cY77uKfrvf+35+UWCIDMyC7OSiGfj2CVAE7RaQ0OzcNMyC fmJaK/6iS92zy1xuLNPrr5NHgGXiL7qGHUvoi0S6GBYd4TABTPw73QOWPLoP0TkpYXz86sUX r4/e4NG2L6atNVVfba+29wDn+BftbX3BYWPkh8Tbd2EWrWna0wvZAtYhEfD5QZ9gfK/be/bV 8Rf0Ca6/v4BHXpC4yCCzhPdb5ECnPSh1300u7LJUU3KX1455AOBK7SI0iJP3rhQMdh7gLbN/ PyKmZDkRf4c0EQ+i5V3u1evAcYxv9DaGH01lNr/945GX924wUVB9yP79COZ9evy3oydbL3H3 OnbR2T2Zh9540D2q/D7BdT1bTaZobDlAwV1ZIAY5AGK3nkl8o2/kH3hfHT5//uqxMDDQaoTu dJ4bDBxqsJWk9O4j3yGe4yFdSjRAADcwi1kxlcnJLj4QJFvi40ivhL/ph4JG+I998PQ7kZ5d SkWSc8lw6WMwfUeEFRDKe/Cgfdj5HqVuFrrl2QO8q1bKRNFQhreodsfL7nce6M1hX+o+1c7U vnRgGaSr48NToPu7I91xlYq79o+BAzE+fgC7SrvdM7YbHHqhCrn4pB6yqCTwGysVNMLOIWQA VD7a9+l4rn/f7rw/hB1jcnp2clmgfwFplSUis/mKIuQ0AgjD8uymr8zK8mP4dAqiNMgA7qns O4eXsjcvSD8HimYwOGKJcTBYEgeNbTqQShmwHZZENgHqTGT3gz7UO6EDVEdIwaEqHqoj1nQf U3TaX09PB73t3IZb5c7zXEFHd7TFAlcQ0ZPtf8i3yfmwpWi9Zbc3/1/uM3if13gznh6/PH7z GVA0oLB9zs7CxT7KfLcHQCtOXrx5tu9QjkH7ghCfIxDlCMbOV9dLALCWWgCsp3andz53HbBZ oE/lpd5+QYcP7jjPD253x2qxVZm0I40zRWMG8LAnXcN3wpPkmg5UbN+ig702S7NSOPwyWs0b s3rSGvYEz1tTH//+nL28O9UTlvGFCLUv85fk2XaGuV6PYD84m/cedt6y34p6Qm5qIi7CI3z3 XnQkYmHRLaNyv3DsmttvRvuiMikQdtwn9rc+Enh/+EP3Zbk8IJzA5XnLd2cw2ET4bVK7sEsZ 636HAMCEg95yCwpbe+jRv1G473y683gd8MkBPGhthY4E8Orz+/0HH7WMwiUY9hztt87Nb8F+ xz1o4I+O+1Uj7Vbi4u8ZokXe+d4af6qLq5Ymdnc61V22V5YCHugutygG39hQGvpyH6MyBvqI 6qRiJkcjr43Snm1YyraZX1eXcza7DlStJLIyn78rCJFh3qulN1tPp+SlUMufNaAtjPVMFJwD gBYSHQp1LQSUE2LVaq+yPx7voWPI9L/hzX+AzTP4RkBI2vOMWfYMleWpnp9FGvjizh0XITZs r7Nhe4UHfZG4/aZ3z+kEKNr3nbHuK3jm4sKiRAdbfxlSStRb2NhWUrmL7v0AqrVD1+6p7O0I 29XkD9VRHEl/NV+BWD+ZWXrEH2CKi1U0t5gY9C7zOtiUR+HutFzcHT5eX82Kcww7mdpz5LEw +OcEo0loxC9fYkT6S4c0big7G7Sy5ffOOlsZgNffFQp6YhaSdda9XYFItJYD+ZU2elks2bcz M6cF+nRE1iRP9Gg0GpKSiPITiKUdEuZKWDr4Hx1u4d3zPv3yzd9dsatD7zf0984qkW390asW FTAE//lQzmaIe7rnKt34o4yj+1wrRgElO+G4WDrjVydPn3/55jMB2clqQdF0+0t5Q2IK6e9/ 1/UESeczICAAJpFyiLLslGlOvyN6YxYX9KDe3o+4pjvtcO44XbEBRIPw2tc6r1jtmBf4b4Lr FwtMkBKYlmQCJ+f+9dbssmOlphd+ahB3YFVOTsgxCtBy1PTeE6qwgQKwzwEKfwClnLRJfGmA ursqv/8OSGMuz7LrgVBt44O9RGLVFxXlOlF8W/iajmAWC7r4uPmf9tD6gu4vbHHtvrnFBvhT 2/4IuA+3hsKptvnNiIFvF7dv5/zNw472Ccuh8X6zfUBntAFoJz0hwrJ2BmrH2v+USL2VYeGi NGZxzzXmMkYol2Mc/erk0+evHn++IdhZNfo3okf3mOoWHVu+6cbSet4OyMlGbWSoO4QTfss/ 1w7hRqi6o1Cc6AeP4kaV9rfTycm7cTttdKkrMuwwPgjywdH8UiTq7Xqmh+9Abmjj7YZugO2w Dba7nnxtHAJ+2D1c/GQDyvqYAO2nkr8/joBtot3DzQ1tovbD3ga7OPdwc7Pb0amHMz8n19JY SYm7JMuq48QApTRIOMRSDbPw0XgowVqa9sUrpETvwqum8yXljZpvC8qqoxy6Kf5Ljr2htybn Uklh6BJOUrVpmmhyoCCUt2eGU9jRu1vj+2SzKtAQjJnlpM0WkmR3cCDJsxKP8gmFe+EwAMnZ KUYBrzi53F34jNIAOM9fntP1jjhTdmGD2Vi4oIgZBslYctbJec3mAtw5bRtD7TBpdalJmQhk zHOVz705rAbfKGbymkCfR3KOwAX+UIPqeC28NkNxrAXHoy3es/LipAqoIQOwanK+Pof1XRQz 9HDjYBy5iguiiEkuY8F+KbKoLN1oScng4i+GkoMtV5MgDZsx55MVHqpzoFQgw+ZEwhflZFbY WhadhGcLrredY6ooI7I02zLG4fAuFvP3E1DdCPMWLnottWKDocR/Z26cegeU4eQ/BdXSvDeK my1gcawO+jaYYQBPB/HvW8h69dwsKaFhacw5gMMsMAKyaRP/mBnThWFlGlPzKJ5q/XwOR9Aj 0Z/iZOrQmK8XlXlurqG/PIZ98AbrLT3MkbCzIfnypkZIj5iHYeTWitbBMxcWDdUp6R67CBsy OpJZXZR3xzJV/gEJqf3Oywbeo0cYqH2n90Ua0TcpfpO0q4LbD+j3CfAds3LwaajUs7NqXu8F yEdb3fAfw1b6QqPu9A7Kpy3IyPhn5+nkoOzgPpcT5BnWVizCFt1o/5530w8GpReX/WxV/JHz 7YYYlIBB7+63MwQfNMN1IQw8RYrH59pt/+jF3j1rlNg2dfhBU3fCFLZOHYzbOUR+Fd37N46f rDPoGjDkAAM0phPAX5qCzQnuDBvjHTwy34IE5wzbQ+x2VXfQmnPH6796Yu+b/mBc8EP3uRng 8/3NNcBj10xbzx0Rfct67ty5v/H190jW0QyOl/7OncEN6wLMRs/s/4Cl9c7krFpU1x9E+/r3 25BR+PGN2ChpGR2LNsgfy+WOG9GxzzLhQkahwteHkS6XUNnICgA3x8J0AiLg0zHR092UypJ8 XZMuRoWYe/rOigoOtOSe0jHo2nZN+C7Bdqg30O0gHGx+Fg+63KD7dZjgK0HkHRA9sav9GUTh LzDT31tiYrS6htQCzRybMzeD9ABDplkKw8owa3occ6nnC6AXmlrgZBZIoSZg1JJuT0kOiwXW hJI0gQV9aGbz9emZt5iDODYhGc0xb7OIsCONG30z5eA6Tk/p3CoNwKsn6NPC19jLvV8iuMdq Ldv6wB+ofujgp/d1k5BMFgu0xGNxDJtQKxUYlraw1sg7BIWizROTJ05B6mIJeUEw7Mr66JdD AbRA+l6JAIpZsZdYrgE9U/Mai5lxiSmsGEUQVvkMyz5xlR03xnluZTk6RSzKwbU4sDwaV/ja f2Ng0ilMr6nw+4PBxkF2supv9EfZJHkRqlybqIzR9Qyjt5edDljgBpc96LxrP+64iVHO8VVz lgGtx7YDhOHWNfA3MJA6IbqAQzJsWd+u97c91fqvNr+zO/EwQPHa4TsPbBj3reupZ1nbudDt 58BeKab5v4w9R+36XCjiWiMNPWJt+PDBfFqzi4icYkzg0DPN1VSQN3G6uSZ16ZTkwhYe8NM6 S3nqR2qXJHMpfdTz691otN20UneP3aLl1mW4D03cEHIbMMKIZ02xnXdbF2E3Cgvf5t2QrCQO RndbGIr1+ujtl69fWvusu8FNM23vEjD2bhnl0y+f2iEco6SN8cTz/681lTjscHiLISwItk7F 7X5G+Uoli79SkDGFXHQka5FkWig50TYAjW0uUtfH+5B8cF2JshtUs82D2hUgXXYXBdd8GUT5 Nd+Or5NLt8fobRumv7r/ad+3Fv+HXg5qXejd2yrP68++a/N+hFD47MunT18cvjx59fL530Vq VQdO6P3x2sFEibxhia/enDx+9eRoy1Ouy77vm9ef7zt/UUz99Sfmah9U8vSPXkDL3LB0bELG 1VoYmB/3HmugLVH6o+fDEH2x+tohUMPcGGH8MSOILrgxSJBuKmL6c8MRitjpQhYd160Q+gEv b7xNMu6PHwO29eMHCeMPHeR/wYVz9jdf6rY2X7nBerLDMLBjImtA2T1f/+2Nyen1DlZsMT7c tI3tBgf82caIOrGd3RCm6ws4dQa2722ncaffTWa1+bZr6nO+tzTw6G9vXx9eTwTb3zgxuxt5 1D0y0jOFvz/09p2snjucL8EGi4Px4MGDGKSdBw+88f3NEQg5QZAoTlWE1B8rLXwoem8ejDP4 JnxsBpUzxhYi1h0juGkMuLg3DhJuDnLDG1H3DQH7fz+UcAh57gFuYKtgYk2zLLa272PExdHb kyfHj99unQJUryjwDrx9+fv3LDV1ZbAPYLSOCQNvJ4/WHwiTF4v3kh3KYW7WebSgGM42bPje DnNtb6dbubm7kn3EwoF7VYXsbyeDN7zKlGWTzncJy/ZI8F1i6/ci/PfF4w1p2rng7sY/jhKz +cicdoIu70udJoQrHAjXpljNvTVXjkF5RjN19EesuA6BerCDJrcw23JasnhHTd+Sn7OLm2wh 3qTJteM9wq3uFlw+kqgD5YPhPpy00xSOoYIWs521bbEcbX9w4+iug8wNYN25EceC7v5sss/r +PnXLW58cy1r67sJvt927z/+kH/Gw73hUO2ShXM/3CrrbMPqj+H3Lw9fHH0Uu//Qgb7fTn7a x66hPqSA/BzEpwNfDlztcZet3qhf6Qv//Fvoyw6w4g8c36a01VnHdhKEP5tkaPMTHr+HmF+7 NOeb69UgGKDP45Xn4dgkfdzou/zfQKgIUjtkqY8hR49fvcAuBT8JRdoy1g6i1HnyGrqkZo1f SZOC+1fStOPnFydNgpu/UqfrqNO1tOezx68f9wnPB5Ka/qs76Ez72DVEhqxHPczqoeMdL+Sc 3ZuF8RvvxZahH3wwtm8z0G4ouh9sE+1q19caZj/Wo9M/sJtN/R948v2Bvu/U/rn74YEMPfeX Ptg3UFx7nru9ft2jQxMKVdhqH5ssncrLNlkZfbkYB32KlT+x1GUXqLc7fTGWF0UlLZVkU1dc HrOcr9qdU8+g7iDWXcp1coE1YhFAiq9ZYPwyxnKW2LLsiiuKrLDM3LA/Cs5LYR4TjrctKHMC Y40nK+lptJSc4yV2Vrs0/RHEb/zqczfS2TpHbd8PzdEWYPVs7z1W3neCHvRYwkZaPiORYs8L u1wbFYSRKw4c3B5law5nMd2CpLw5WgDWgsfw84W5MBQyLR0DpxikxtVO6cTU/zzERF9sNaOj 8HJx8tb5/PKJCy/HndzNXP/esYN2veSIoq37G6hP61h2spzcC9DxkV/vIned213YfokR4ufo 16Z68xI57jRnadugcNVWnu/eTkd1352/NRjgBy72DYmPBWDgpbRq4VaQq8lszbZQaXuIIeZd wG+BOC5FDeO2coF8aNe374BaM4SF27elMNw9d2xzbkOT0g2zoC+14pRrun+4Ybr/Y6cVCvIK DmTZ4e/a3xjt9fMjZ5DF1Nw4Bo1ze//mfL7BoB3LNVEjtEsbxNJtMoQg3/gOuwNtBCzcWKrn +x0T2p5KW+eSdWwVLz6Ab8jS+gSNOq0QBWqJpaWU3IyUey/0aOP3N1NC/LlLNaF3IGN3wUNb UIPm7hP4lmhjYCcmkmiBEipc7YQ2Ucu9lcMu+kNRuCtXv8WXpE41FhCn5pSX2BwM+Ra18YCB lOHP+gOZ84vVlVxpJPGSUKUcmNpJuZxH6mRiFOHGUDNcqbQH5YwobvlJPSE76SZE2ClBBx7F at4boJoZd2mjnUxuFyK27bi2YZtgD57mF4ev3x4fPucj3YZxWI6gmE5OZ7YegZ27ZSkOenDS KtdYfArSoCALwOPN318+lr96qKjzcF7TCS2eZFOuggWI5e+QKu9KQpfXrAHItAw5Qvdk3eov pzNuRNn/wXZFGHKMnVgK7OG5eIcJNVilXqLormbV/mC05c3NzfSA3MJhl9LaKdp8v/MVx7Vj Ng0mW83bwj3bJu2wlF1ERH9cV9xW25DzYLesj//8h+nO3b8+TDv6IMr4gXTRvcrXkMZryGFf ReH/HlJ8+cZaHyFNvFWuT8NbboGoLULU1vpQGlT3wAn+7Uh+28L5qDMzx/Pt8EZuDdT7aF3y h+qQH/De9oCeD3hxexDPzq3ZnP2Pmcy+9PEbdF/92D26725uk7GwHxDSOd2Pdah/vCNdSjLs utQsSHR0XlQ0WWhwcgGYWpOap+ICacCqBGEHZltQYcHtu+mbuxtI/gjvzXJHnaGNG0NJxHNQ zH/TT6LpGgRApsV76t3r3cVfJqi8rfZIS9yelsB1SlCE/QkT9GmgtsLSZnE+h3JtKdbXrZmh 3zsBEdsfaF2W27/veA+2P9Ia/rZ/31qRtn/f0bLsrbq56BdgwxNja3RNMD0fa5obzk2ilGWb c7y0iu3b138/efr66EizjHekMsituu5ppy7ctYPCsj7gMU7SVj721fbHOvklqmZq/eHOnbJ6 uwN9vFhPDt8eCre+9/OVWsA+xqx6UIKbpIJJH56a+lyL0Qq/4CoIc2zcDmSqcd8cdqxemLM6 J12TG3pQdtqLN09evfH2KUsfB8KcdKucSJaZbXB+dVlckWnJsSa1TXZoNUtJWtpCHGhb2Jp8 penpfSqB393vUw56EmmHSAwvDv/25ujZSRp/vncNprfVgnqJJrVQgn7+iWa/dfsUOASKz6Jb YBTW2yNa9NQWstWyuw+ox7e0KfDdNBTNqnJhONzsMiBP19cWC+cxPqBYeP1B1cJxuA+sFu7p EdjtYHDP8vqV1EubeMJYYj/dXSubt0jPXFcsGx/YXS17c5DNctn47e562e0IOwtm4yC7S1S3 A9xYo7ruOcu2Fal2TnZ7jWkLkI1Pd1eZ3ph4G+q7UgJu6oNrQpOaCezoEsUcQRvtBoqVVTYp mvCrFsXa0rFL5/f2XD1q9ehtwQ93DAQLj8C/dd7fPFP3VW5WtLS/dRDixrfd0G+e3/2ABeDe c9qBZwMxOA2xf2KYb9176KA/k4NlmzW6ewi6WaSbHpDXtszeK9PdG87Zx5RaH47qqxk1QpTR 8M/pyjb64DXuerDuPlhuHxI+5ue6nAbZPmsy5Iex/Ohn6FjEAsFrvHZi4Oc0Yu1caE377JZg DjDU+BEnDpqKyGAGOapq3mx9XrKQxyEnmHM88nr50jwkpktrrjSnTf+wdGmbK+2Ws9meLg3C 6JZsadryRrZ0V6Prpky7jcW1iiVdn2s7MrVtxkUicFuNX5tarT6UzaRq8pHLo7ZW9rb0aVvq vOeVsUnIHYVpszL5ZgrytfXCO0B3c7Cv6RezdeJw98TbIjqumba1ECj54zPb9UoXb3amgU9m 9iv3Mu8Djgx+jjoRW1vt3ZI28Nw/8JYHl2qFVUDEIo/3m6rlMFL2k/+l1C6cwK7yDXwElr11 ek+Ez28v21rt9GDXrtv6E82qU+mt4/BySo/c65g2lh9cwrF1lm3UwfvACo7tCNvK7X1gAcd2 kA8suHfzXqQcn46xab/eaavumsadx7nTpFtuHwWP9gOnlUzvHaIdVKzeHU8rxMMn2mjYNgHl G3/45sVf6Gkehqo7c5OVSRebi+U5915umwvLP9/vbQz+09+tN7ZNLQNT9OPOFePQSmIzK6cb 8ZL70lK8iY3twDI4DNaR90KabVONF2SUizYAxYU/1h2sJ8uqWNSmprp7GAxDFe8oG16sgHiL 0OuzdQjqTN1uY0LFSU6LRVmcmo0SMct7yPEFuydLmyO/pRuvVvQTCYH7xsrO9xU1BzQ/bl3b 5El/POy/9eQYe+niA+6CHwGbwcFeffm2X7qGlyXPidXhdIHhJFLE0EVz24h2ZrFOHGZj/9tx SvOm8KuPS/DmF6vJObUW1f586jeT6IwaQU8LGCFickE//vsN1+MhXNW3VIKhivTYO/x9Aete ueIDpxcyOjHE0dZswX9dDR3qYGKf7LrM+j9Y+U2EOIYfLKAnZPQI0RbydF86pzvn3y0ftzCn cMBwDlqsD8swOo0iuOCYosV9d1WCMzsGunaHd+UIUHraPgrXsJ5dByIYpO0KvQEqfILKjuMp iYjVIZL3N0YrW/ogA6MgWSzc4ToVWTtMZcMBulzNL1AykhGxTqIYzmQ8wobpBF3qDzt84ZG3 j98N9LJhT9w2xdp98mDLk/eoP67l2riKSyxe2hKIEhuKGLrPNP1ow06Id2KozotL7sNtwWuW bRt3OT5bD9PjqH2/699g0wfbDvQYRIrGy3Tp9mfD39si4F++PHx+/Ozl0RPQrnRLj7GzI8a3 aV8Vj9q6U8t17+V8Ze51o/qml9hfpTQz00zQT267sLxdSLgh0hT8hZTbJ+6cSJZhxzacYde1 AclsVu++OPAXdS6kBt62H5wdBT1DePMs/79Ntp7bA/xw17M4oec8u4+f3lF8P8B02tba+WMW fH9zBLuCAFeAf3zdTvzNdS94Gy98c78fAGupMpxgS+CRcaFQeoI9iZHdjOnc7DIPQu8cy9Fe TKnqUJDacz5mNlssyUqNUQmLibDGdgYWY7GgnqnMclksrrpHru5ytzweLeIPf3DOFnWeZDz0 bj3G9a/mgD0oCC5uOYL0EzFQFcsVP0JxvlTUgfukFFNUT6/Y2F5Q7Wi+ef1Awh7/7UjKrubV YRSPHtlM8e97S0ImTHDWe16aq7m0oTezutM2XqKK8JIpwBTeGgWlrtAa9YJzjCdbTapNzydb qRzK+qgjEAw2iK79SmAqR6O99CwOP3jYU3oOUCx+/urV54efHR0+gVPC2DfPDmcPqZM3I6O3 5POBe1FwEOASa5AVzS3HcOks196vlvO3wX9Iot9NLhBmFOUhIlyzKTjBncEzmswqLFrthJfd Rjl02xsTlFyXS5axwpFHxLGNQyO6hmc8nV+6oyECgD6wbpBcmtmqBZC4myvYCP63WKqkRGW9 zAL+OUdh0R2NK2wvuSL2wjQYaLieuU3hxY+kIlhRVVQDeNgN/KbawfWEhTPvv9bnF23IG/Xe oX3V5sJoYXAsjE1FyLSdMw/z2fySGhGRVmAFiBZ4E2HKXB6adQfZPzpX3KHwSwmScwIFle80 jalwlJJ5anfTmwsjoZccM6D71/suFxpsIzIDF4foLhLNBNl7jcxdjabWTIU6y4DeHel9X3fR qMP4YC1X87VTmxQexmAzINSNYQGQa607G9BfcR+WLRFUXb5EPSyUHTi+AhpE3uKj0AdFJ9Hg 5e71YeqO27GEiLi2SAnEa8JvWoUK/7Ddwq+40HsLA5EWWCe7PJMq3lxwnYUNGmQoKqO9TCRh vzNXy85gMD+PxFU64dkuBxtZYSbsizLwmzuU0ps70dC7kwy90WjkrYls2G/CJBth63S61xu3 2B2sd6G5vnmMNIZWM4ELe592FYRj/JQGdC9bZ5Or3hKOmw5T1uvQ4c7AIies1LYDdY4P7xQF JZ+uQYtugdNjReqwQb3OuZcitEmySYPNZHdTte04rPxe0OfhQ4s9QPLl0z+6FJ/ErztDfsyt LdDhJm0d4o7Y9jCkq9m7NPjpZj6D5/1vfJc0ywceC54O2ETeA8V7duXdQlh9fwtktJnBqHzk TiuUIYm0AVXHwGNLkpad6iAw0GcUDc0zaavoOy5y7jjgjqRwx9LMwX5PfAgGcPZwD2qawz18 onisPD8U5XcgGOFQK9ZD9zuqAPaYInPzPoPmAN/qoRW7EhDtD5y3ScRnGZ+SU1zq7QKGWqoT 7lqRGz51iXCfCnefBonefTrYoNmuUZV+4GkGBv70n75zp/e8jI2NJvmD7XT+rYosSAbatVHj CIqTPp+/R25rqgJj9Cer3RSLktOQVy9G3j6xzjOzXpB42tMaC8Si0cB9+8fxmz57+AH8pi+B WNbzAfxmK6mjo8Kq5luIl9ySHm7DNdC9/dFKzXJOOznQdrYz7rKd/ubCJN3KgXpsZ8fOdpDe O3fsdhQbQcDa/vEWKvi/+fU+Gf5pyWGP0rmEzqVxGEFwPZVzjA+OT/1aEsc+VSUMW/KjXHP6 Q1cZc59z7IUbjRXsLA8dlXSgefm7LFbuFk/Y6PJBJpv+e9eYWjamuMbIos9KKoDeCUe/fUjm vq/bD/7AFjogz49YNeqiFWDfwUHHxCB1AHoavgXtg4c9BV+9rp3H1Iqk4cyO1v+9gxPoISBc sIxQfEv0Ifx58NP9kH9jw+OAdE7nRML2P8lX8P/X9v0fZ9T8f8Ha+JNbxj7OGNb6i2+whN3F YCa66E0xmWLy+s32rG6cQSvk+lZaxV//+79FCmuFWBI0ha50/OQdjPiRkuYPlzJ/GgnzR0qX P1Sy1KiPnkTp9Mz5CIHyJxImf5Agqe0IVID8KYTH/3WvbhUWfzpB8UOFRHvBSXho7+zmLWbf GqPgDQJfR+bYIpV4f3S+u7chgDgSiCtviBD45OjTL5/9DMEtjwl9rdGRT63oBrygU2ZWI/ku JNChHzFGl6AVR4R0yz1kWnujZOK+JHGLzNIpWupfen+rbQveWKFLxCm87/xi32UXvLQNZabD 5nk9snrK0vq/Xx52wsybCxBFVhjyWZvFAjBSKqz9fq1UCn8TXvP7+h+zW1um3AarHaa+rXP+ vvp9dWvYLv1r0bi/cT9jYnTHLV9q6c/BQVfI1ge+O6HaNfu3JjPue87BhBs9Pr47AUpZom/k UTcutLfUW//4x9e/r4e/r7+5JShycN2u0WBb7W9uAd/F8Qb3r9/C9yTUUzIo4d1kZj4MT9t7 SJdOpf6f+OI9RY7RGpxbXtrSC42qcLkUBWp9SVHXS8tliIV24p02O361wzK9s6LZRojV8p7n inU7ZToO9PIO8ZJiR28s14AiADJ5WLuZUUw0WtK9Tpmd+/S5bYgLP+LoEyG50AHbcIz9BUZO LUxtg82wG+JqUcyWRE7MfCpDoTQMcvDBQS8TDT2FW9pcwSGc8AZvCnZtwyXU/zUDzOkFJkhY Si+eG30G94V8HZ7P1zNy7jUY/k/1qnZ6IUZKxjioRaJs+9G1HRJB/gmMxN3BOb0DFd1bhDjo S/M9+xumb3JYy2/+9Nvf/d7DDATS2u/1XXTiIkSei6iz0QSHZGpaoZRb6gSvtp/dXL1B9nnp wKElbDaEXOdywAGiw7bxYJt/QXlvPZtO3pnpVaeGGDkKgtTDrJ/zojpDUuIYPuxP61Szm+ns JEBxBP1QXFGFbwse/uR8Ww3rLRUucEMHB7uLMbjHduyiEjVlnpKzg4qEdJr8bReDHV6FRdak 3D232D0rpk3rzL6kvHFjwzSkW2Dv+d2e3U6omhzqHScCDQ+ss2Xb9c1JtrJS4yVnrbVnfin5 Se4IPWHuwKJS7yG7Ls9rH6LMeQMU5pIjatzF67K3FGFzI7IPsCPCfHY62IrCGMMxndSm1Zko Ctzbt62nKcPFcJCZF4WebQC57OOMEpdvL8xsSaYFCY9YL4tToImoES1pMmoxTXzIdojw+6PB EWMttv7CsNgbkkBMEKKII2kYXBYorM1lwEeb46k2+yW1+ubHfGQI58UMRgM9rC2lR5YOtIHh wmEj/bEwpQEDKtrKRxWprNQRm2wlF8XqbD6dn06QA2Dg9Kh37XqHJpYtmz3XRQ+spvAHSbP7 etaznG6tlItZpbcPDi4268bcvpCMzsH+ub0DoDGcH/BvFIO5q1LqwcFs0MOgWUsc+xHy27ZA 9tl/wxbwh0nVTA8aSC12pm8DjIeerA6fkHh1pM7b6C9atbhNIGnkM4rLgeuyXhrXK29fuHsd QHv2bdo9MpQ7G8Ti+y3krF9dsNe4st05k+HLArdPNxFuwj2X9npeRyD765vjr44seTwIumzm wcOueIcKbEcNv2338bAj3MGDjkhgZ3RffPiIX3zUf3G/MyUs6Q6vUuyjvM7BBw0V3tY3Q/f5 Y+Ymnx4/w8RdlClfvDj8gpMf9hFtrowj7g2G3f120pQecrgh/3WnB60NUDmm3o5g8qAzjLOd znidOLFXeNKXkyUwp96CdNNYHFSGCTuvdtBEcGRon6WXqeYb4FoxZdK2HG4fayNewT6FJjP8 /YEXdlxvSEva9EZG7uE1JnEXTrwI1y/nAhFuUv8+dFN/iArwhUZuS2r/pRGui/mgdAabcqg7 yaOHroFnw4mniUqOptnupkcRv/ziyeHbI8lkG9q3h9tfvhOgvo0xeK05CRTUqDPkYzwvd9yB Y0KO+AhRPlxud7cp2ETWA+6mlUNRC2uN2+0KSKMaerztlqJ2bky/ju3kHO9VQSF6aBUmA+l0 Aqwb+CiraGoBxYJ+K9MLgeoaPLv3qHcBrVKwUba0teHKbv8KL2JlHY3lsqVSHUVK3TygMBeM NsoTjK2lhEWQQHShGkwzKscksZ48LszPpWpsE2YRoNgUtTAIm6WVR9g4vGZRqxuiuT9fOJ8s 0Vy19P68nk7ggKgS03Igc5ZX7mDdVDNN5hx5YgjgmzI5PQPqgCDAqn1WUcYYYDsWRgFqO2ok JzCEBSKW9TWU3dbaT60PoLsEHc+mlWKa9SUZV2dSFHibhwyQ7nQ2J+9dP1SuG4WOeznhvTzo uZXcCwxaK51vL9nlDuehdtDMIUD4Fh5Br15qf1oceEvN6i+01XAf3hT03EW3gwNGJgVxT9SU o0acoLBLwVpVaCi7j3BVvFS761/SHmaa9dPlp7iizaADevqRXdmm8inD6QPdEVD9wp11TKo4 kat14QibSpcD44d8eHfkNPShbtHzrWdD5ysv2y1sntVnvSMC3oHmJap16B4U6/qbB9g/r4sp nLu9L3q6pFzMuyffeXLIR9wf7ac68W3AQPnNhdlOBNhAl85rO9Hi+tc+AFk6z38U1tx5uBVf fvJu5mKltTX29HxJiR+y3s0+TgyxnDcHDfI2bG+4kUvr2FNbIruDTzn+ld+K0ZpKpnJFWSpJ jZIHlvnE8rL/wM1j0VguT9HWjO2ZGx5hBjjoYv/Y1IE8LjCLpXv+0Iox7Yl0R/oG1LjrB5Fq PMMtjzFdZrtHN+mwO8n2l2nPg/v81UaCeyfohB7p1WBkoULff7soKvN+3/omviYof3OLJ2Bc eoMFmZE0AC+tKGURTgdDCcy3k1U31GLHeW0c1c6zlGVtUR/bcq/qYOQR/9gv7H2vLbzd7uEn vg9UWk0TG92abNpcwu0mYWvHdGvG8Db2RLbp3Cu30Fyn/AtWi2NJdIaXiipYcCDQUg2NbcdN FltwEHhd14gLItqMZqDFvCywNYSkrDRrLWltJ4Tf0WawR2WoJR+J83vem+lDv7N39jnQql++ ent0r1+65kyNdm0wkBUlucmlW3oGhxE6iVkLbeki13vhVrZvPRZYN7qtCL/DncFkfMUPOY7V N/Q6j8zhGU7SEtc4Vd3BrafUJjdZKbOzailDhvZmU1ChhHYa0lEKLxG3EbVa7QbhoLCGKeiy X3aA8GLudx7gi9869nsvbe1UA3QnccWGjYl2vNOpoXdXLsXOC8DIb8uvW10VMWr//n13AXc3 3YJbhr1e230gxXk69LMN/moNSa0fyTW194Pr5WeTnVgqrtXqbrERGWPGEONu9S2SXV/bpkSy 4fZp23E8dCvuWzrYUrut7Zj7PiQOqqUKb9uZ+vaK8i3oNvgpVrWmF0/ns+5+O+pIP8PUeahX isVFhCMqjN+9LrAz9+q1JSam0w5S2AvBOOwu/E4Py+/3Manrwfrv//Y2Qv0ePWwn2CJ1dweY ONeBXAtYyKkAxZFzKqWUnjrVtjSucSCk1Zc7kkO7lN2+G33VIRTuoz2GvdnSWHbGwiD7N7D0 mPZVIMQfchAcmvc8F+D4IDvyXQPLzJwW2BlH/XDMmvRAEZ9cC/Bub9mB7GwTPXvus4/aL/+3 95hbyZ/rtXfCnja+bgUU8nbec7ox/ExFsB4LT/54YaRfv+YDhRGJW/CwtJRn0EzJUbjzxua7 U9Ubklmo3M71couVNNazbrQzWQnwC8q5tQVn0AbEoZ0oq3QFlaZYrrZIKcubpAh874fJEBTF Ra4yonPtvdlRN8itqcID9QiJISG7S6OpV1IpLU9gz2pc3M5N3dZVbDmW+FW36rBjqzbfVuai 4/LYDM1g/EFtj1ynFNbcWsxIQnIHcO1wGmlE5oGeRRYJiQi38Lg7ggS8t3VJu8Nd61bfaWft 04SP4s5bbLZbGfWm93CTdbvfbu2X/SP5eNe5oPBVoNrYMqGno5ETuvuNXFH3MNrbyjItIqnF edXrtyP8dorevvywLbOzdfvX+TGOX745eo3l318fv3wmrok2ht7O0aH0XbFT+FDHzjvUmmOM dWgSf/DQrdHV8VEdqpN9jldavTRy4Trl5ZyI253I28LlNwSYfrTQgQO5B9eyu7ubVcupGtEH lCHq2+w2qhKhIQ0rFa4m1XpaLOyurX5XuBbzzkAdLMRchNXSTBslOEtt1dslOf3OO5sCU6+O XydVyEPM2IYMAqZuXtEAkVtPjtezs+dSf+LrcLUfhOliajcsZ9jfUF+nQMvXCuuFnGBVud5o bFZyh9um2ewC3UG7gaHwp/7s3SC6h/0hNmN6jncaL5xQGuLiW5JV+igkrjnWtxanRiwYS0C/ JXt60HRVm9MFqNVLVxTYxKHrQkS2He8DWxuOWZZ+viU/9INJ2JZDODi4LxqFVFZsA16loBGC r3A6l7o/W8NXZBZL5O/c3/rIx9PT3lHblbK7EQULUy/ZU3/geMSWc3HsF/3+bvZ4lIT2BYZ+ qYnOS5vgcIJb+se5pcvyDXD6fqPNjv5sPdSeMty9JVue7xGx7Q3bP8Zxjz8/g/Mef36wA19/ 2KHdl67UY9p309OtnqysErJ5/qQcoKuEvbdOMhl2fjsHVoKOZ+kBpiWGqK3flrF2dUuUINsN TvtyrqKDdhvsxAn0B2QzvGOH7+UyuCfa78HcEv8pFSve9Z5DvnsYZGHeD6ndgfm9PoPSxHOH Ov2LKNG/QPVbdIKgmRbdpox9aKwx791SKi1rQZUIYx8KUopxAEcvdgrB3bOZOqhZT7joV1GD kqqK7ERDnrhQ7Wyu09kcJasHiUwGuv5ELfHXGsqnqOT8dCqu19FyP1TD9T5eyaX4g3nFQT0q FnJvzOutyr/qwb/qwQ46/KoH/4x6sFMFp19DvSfZDO0TTka7o690XAU9kWgzzVxhtUNxdlfy YEsR/Z7o/quq/e9XtT9EDUvweDebjj89fv726PXRExJg374CSnT4Gh+PwizNNqgRenk29uPg 2Na6PxtI0kupeaTzDnYJvpt5PQIcEIedayGdpl2puJedLLLxNlEY5ZVLyQag6MNuo3qRJajh 3M3i7/Zz3+iMoD/9Lrnt7tpY7qIrzlxoeOFyZS6sc8h6Jtp9WdCgDYAFIytydwaiB691JvVq /rqnvrHbB/2i530KQJmKrWFgIzSzazNpJ9u4IFJQVIZxzCWOqcQWE54sRxsXZreZ6SDoUd5h f1MfZ2YKGPmd8W4wNLkQ/wA7U8uxu9tHxVMBwyGkPRGtLxcx6rRgYM5tbSoL49hVcD5Tj1ps nWxRN29vkR2Je2r6ri4Px26Pk3oo9EfqmsFuJL59y5sD0/497EPcVg7Rn62WIrwdd+50QiYe Opi9q6X4D7cc9ZqEd8w17vq3WGvsNd3Si2XjmZsJV0/93eBD12i+fQNBh23Z1W2RG/qJUNvJ oqp4rXlhA7sB36ZGjQ6j7dS2FCrZYQNbDKzEpYGwrhbrWaWR9l3SSvJHf9ZrkfcjbB4HwfVW j51GD3hxh9nDPb9NDN4Wn9hHtu+vw5XeVzstLB8S6LhFO9pldnrbkqgt56N1jlD4A1m0mFBI 5zYCROok8V7sPmuqSX0zJdq8eddfpw8BkRuHwRFI3j6reb9xVUspj4Vf2MrBN9+4H46APwb5 rqNRv4StbHt5nZ8hZHy+gCW9fn40ZEXoqm2CAFRkaXshDm1NYqsScTH8xrZI4uhTzNIRaegc 1OcVWpYKl1V63v6xa+TVcWu2ocGtgIkpP+m2tfdyfjZ6EbDVMgXH0KIxIfpa49lian6Y7WyX FewjjGD4OAmY1O7F6w+j5RRshylbk8CpCOSULRxqgb/7sgwsQEVtKG0ddBSm8OTauoEIyv81 QSdqxTAzUMPpysHyP9xQphP8WCOZXej/FgMZdv08m18C5syu2HnT5fyEaQtzYYrVsmfx2e26 utaQ1Q9veLRZ9uT6SpttEyD9ke5It9uWP+5KtO+yVm2D+W/+aKvP9qMb/7g/W0VvK/t+0CJ3 K1v/q1/fVd7efr8pz39wcWT92Rq60RFKtpSl2Tr39hBn/NlVnoYCnMWM0TBtZDblXAqkvCKC k9yHycXWn7hJvH6qEBT3Tv2AGJTNd36SaJLewx/sU7+WKP3qx/0f4cf9ucTQz758+vTF4UvS 5YbayL7flOsm+ZIaYX+QhHmdePnZummAn94oYJ7Bc/82CfOjxDrppqb3AiRGSuIfXStWbSto 9tGpMdv4MD64TbjaSsCvF6/wR6Qn3f0HiFDdm9Ul9q9uIiLXEqkfSl1+BGXZRVV2UJT/IXTk //z68//ITz1HWn1SridTuBJ3p5PyLpY/OwhG4Si5KwRzdPaj5vDhJ01j+hd+ev9Gfgq/B2Hk J3Hihwk+F2RZkv4f/yfa47U/a7yDMOViPl9d99xN3/c397/k56415YzOsBQF8D6zwD6GbsoP 8UtN215MTs+ACD4eeEGeJwehH/jen00xO5jO1xfeswJ40JUKDrYx4lLNUYtJuaYYLnQZrbGE 1dIYylvmcUF6mGCw4Yyq8I3O9tS69tfD1y+PXz7TpGhU6yQh+ja8c1uLs2FPw+LiYjqpCk5T 4sQmJIYXrnv+/GJqzoH92EQrjjFo9wyzLzCXihKv6P3luvwvU3GRjrNihpHSh85MuhwyvmHo Gm9gZHfwp/3fDrzfHde/03rcMy7I/fQ5hXzavP/2E3hoVk3XtfFufQdQm47ObtFI8iCw5mdf HX8hTZSp9RiGJnB/RO8Syyyh9XmyJIvNKZa65dxo7V+5WhTUQBH7dhIcAHiCDfsD7MqpE2ji OUHYBkrAbO9oQvLBEQAXlXQtxyVNnG4BpkYnICHF8qzAVFQG8IQMmLg0si1JAEeb6j41DZqd cAf1yA0xl7U5RZn5T2nY+9MLwsc7b4YcsZ7f86OXz95+dvL41ZOjN16Y41Jm6/MSa5s2tmUq AAk2jrCpsJCvhqEtLww2gvaOXj5h5s7g7Ax//Pbo9eHzNx42DugN3qmk5Y9GYZJ035VV7esg d4I77nIH3fGey3hwaM8762a01EVfs9gnMqHnRX53bGtcpSE7L32qywQK032Jn1UspLrNjdTq wvRfBm53sM+ODr84oaJ4++FtGfhOQBs9L76dnK/P8VJcUM/QzotoBaEmEkGCDx9iOTyansR9 PDkOxm8fpF4o7hBYQufkzVu4zCiLxaH94uhvb18f2m/S3H7x8vDFUftGFtkvHr968eLopY6W B+3+Hr9+bN8I/PaNT7988/f2i6D9giVA+SpNCYfeUBorofOa94CfPsFkYqDZ64rKlcDmK6Df lEOhnkquqUdEciV9XtlXT5d1dXVh8LLyGF61OsH85JOlqB3rGd6hVgVBIRXrWf/TSfrEP9dA G674oriyPj2OUzqPIxp0O/t87zXV/d3T1U78LU5XUAuSGbXdmamyCahmzMbUbpugu25PoG2L qKcgWHsYPiVQuN/iyVPYI6xyhHttTxyXAB/iBtv7BIobDDWCVbeXGkgtfgbz7/Uhjgc6qU5w +Sd4fAD6jc/ub7zlPs7gkjV7t+urGb3Zy7GlBOSrWXE+qTqwQlUafzDewT0pCzPMOKIE45rd qgB5KZ3XHry2bumtG70uxYq3oGuo5qBULi/mVNxA3rALYvBv2zce5xfz5X37AcZn48NYiL39 1FZiP6aHiSzQoxhaNpMAQ8nEwjJGRYVx5lqDXSLaKfUaA1hWEtU6IT6NLGZJ5SiplLuM8h44 JDoKyICCwozM1s3TBsmmOMdW5vDbEi+mcKTesapsJ/YPPtnvTjiF/QKfOm8Vdcq+xAKHUnmZ xC4UaSTlvXvCTDjc21Cwq2OGYf8Ux2msh0NcZ04Jivv0ilgIlyu0D8m3bgEXb6MeDKd1IeWe d0tabJ8JJuCZyD2vM5AJwdZV0fCn7i7JW2jnb6E0K60fVo/MDrvGdtRdMGHRim60P5IKH+NC DJ0kl57GD4P2QxKPZJzT705YhrvA3yV7AMZxpbvJjNqdk0SnxqTeRuBxRNZ2I5cc+DDjQkJD OjcqOAfSDsrJLkThOpvV2bxDN9+8ffX66Im3T5uApSBuDvB9kWafdAGBgV0nrYkNBmBGgv0M yFZBKM3Irc4yN8VoI0pPRlEVQHWa6p59kncuHQ+cV55/lWUaIkyotB+Fn8sYxXq6GnRBd0kt zzp0f34a7mtVSW9/PBoF6cZL2KbQfclWvAvsAgVZeSnMse5y/fY2sh4oACdrcObewlBBXQSq YK1BlYvL6ncbUTO0bnNvrjnHO1N9h8liueIXqIa6rcxedCpKNG07jcs3sHIdjhYCtI2DsLGN 3OK0mEkbuWFbvqJbBqpwfOu23CmNe9DzRg/bGrJmhlbTJZtNj19xPC86xHWAtv0HcZJCObLb Do9ERa7KgU3iQaxbzqnjN63ODuVUTqJzgjWn8edSWhFn/ucaLxXX/MICNC/ePHn1RouQYvB6 Pb9H5F6KuC40y4apQlt9WQ9WXlVknZ66tZ0tNhyCJAYCuZI8fuSeF94m4GkMQNsEZmNmXSFs oZ4sQJ1lZbW+cUXSkgQDJnQxz0H/I8KJpqNOYPwSqT5Z/onMjBAgBGBGUlk9nqpFy8WiuLJg pvNG9RLXqc6EfmUSCg7FuyrBoRb6hx1WjGhCg08QddbS065NCDif1+vpHAfaumMmsXexhTc2 m9nIQqGSKi+Pn496hIYSLnuZXRYgOIzAa4X5aG08a4dstP0C7BitLmTYgNGPZd4cwKFXSq3s wIMtzzukShYtvdJ6O+RvzibNymLES7s60oWAiMqFoexT9ZPQO5w7SqXcCD/18DBojow29mms wEN3ngszt15dfHTJgcKIgsuVS5Qwgo99vgCYd2bJ5h83Tf6duRrywJOlVovz3G3Bn+1kjx62 0OziCc7ilmqy0PhrN51Qw3FKczrh+sa9mp0igEgi3jPTkiNb5sle7LYbi7R8BDHtsljUyz4h OdawVPXptijZU1raytCCEyRsttHoG86wXoCkw+B7AXr33bfEhdZ72XwLDGHZwca2DKfXn9mm 2rSXSAL83QHcFKhdA9AzrCu4+pq0x9VAhI0FtNeQW5o5mfSIY3I6nUNwQq9bCmqhz4hhT6BY dVM4Rt4L4aRoeDhFex3ZPYpZj4oaTTFDc9lbKb1OBF5Qn2pMCcxtRu12pAGVzemdbBeNmVkX aPhYX4icRazeJYkUpk8FC5amWFABKifHQlcrOW8eKFFYmBeeZh4B6sJi/r5ba8Jb4DTdUhQ2 lfA2L2jXLtrstJaPrlbm/IKE/QZT9YpuUjDxGXvXukk+E+qXNkHOaWc/B5HUPQ+WZuUAzg2a iyfL803FzdlgC5T3ZkotdeN2P7/1rJVzs1hGb4+6xR9VJKSTpXF7E+Hs2X1krZDbW9Z/HVQU HJhy1jte7uoI36oGsfGatx+MRvnAJUya3cbhfMV7mI0rooEkqrYeNkN3sOh0Pq97GPQlJadj lTOL5S3G9IibzQBwAOhuo+3Zfl8qqF7IkCRRkXm/g4NaBqQzUo9EqSqE9o6lKELy1ZNJjV2N UDxVw46aCrh6OQatrrkGHvsV0IxRLGYOhdww6aFlaIqTfW1Nrt9IQKzapam9IB+6ayTaOlRN Q4W3n6jJ9huCjdUbrh2gnJ7I658+d94nMc616CG29Q3HzoCuHWwqhqYNOOPHIw7u1QCOzaW5 I9U3j3TdLt2hyq2r6gzVbs8OxngNNABeJ6Pq12rCRigpkvSt7iqtOQNSl8W2n1ZnfMRrNKx/ 7Vjdv3HESrS5qyGfvM90cdzTWboXF58/2dKXfadILHnjFxuDAAHaMoi8Sl4UsUluGCA5P8Rb ijuTdjf7hpid7HTGva/1L9jxiP/wv1FXmNNBSoYjXQlXatWULlzQ3MGXuMff4DBq0PbOuiC2 lxy/IqhQueR1Scejut5qYjg0x3BBSAY4Pk29tO3eN6YElWgqJjsHfKLWOreA9KL+vWLFAZ7A ETqK7RvRCTWvamO4uzIWiAtvtdCRF6P5g87D5uHcZiGCmoO084hm6Yj5B3aPaJmUBurvUHme 2B6NdDnMYum+hdFfDqORUwUlBctpoDHAFs4kw4qU+ccz7Kg5+KNlxNngOekI9tx9DpfF35ot ZXwxD94dj52upOxzw1eKl0NKUoNAyN9gkgfxbBya0qFLw20kHQjiD65YanhPmg4oJ1uEUNSe Bx8NpkL8+K74xGYW2rq7HOop2AUCvevY0XvQ2QepBLGAq4IvByN3OJWMJVTAikJqvqRWYGRT FaOs+/qBOMxhcJSuujSLWiUJaqFxBev2Uo1XEGmxrjVKDB0418XFytpqObDAEjDp8sluOHgI cKGCG7D/FmMIewdmvi0wqAFF2QnZ7Ag+ZI65mM8X0yuvU8OePC5cA4XkhM6aSB7vv6G6FsVy Drw3cmpyVxE1ltTJwh2Jqsc6WyypodR7w2xlvRADGUj7C1vkA7262PzJFnPgoRi8VAarBW/n VI4RaT6Rayv9WeItOgEZnwGjW260WLNCbs1GU/UiKK+EP6hvmSVYn7YkSrn1crSjagW9ydIP /YYQcC2NxAI22RgNh0JaPcG5jG1jvsRaKVLyHzuFdI1oNlqjbSuxaVwEnn3S8186jH3eD3El NHL5fKuqT9XP1o73IYM5vrnlptZurIW9w+AFBdWqPJltjyKd6CGbeamr2ljT0atP9RIs2JZo x8AgE47N+fTLZ3aXehlMzWOiy3G+wnCL7l7tY3wDz+e1F/5HFLoAQyPSyRLWfX8X9NtB+PaT 7O+MpHEugp7wegc7JU6W7+aIrXHFwrEzkgFEqiGS7WG+WgGz2CcTv9VrJ6ezSQP0EQEMQwxa RFIww7xkAdliAhTLyITlMV4gKvvTqayn1F7ABH37uGvMkIw3dAhvQeJ+q6C7m72a5k1DBidr k8HTdnupseXm4EBNOLio9m5OGGzSa4f80je0cRM1aUnc2IokWxuveQVxQ5n5gmodKNEftTxq 5Qy0pkZttjASsp9eAzEHTOzv7gS9s9PaRlGToXQ+cxyeo82mQ7Zsg6QcalfmjZYiGpCA3Sxx ZAxMrgbev5ad9hdft3/eufMN1tSvBve/33MCbzq1sPatQ+iONcZK/M4LOEeM3ylsL/SNbMjr UyCpLp0xrbdQzQ+sRWjDX+M5M/eCvdyWF94+/FcbWXR73NN6jx3M2cIl2ppEmL3bbxS+HGp1 gVYJ3vCr2abRjljETT27q7b9vSxw97rWe6cRooCOhVV7jcjialtsbtwJREL3WuA4i8V8ITLp jvvgWjJgPZOZGi/wG7pqXz0//hRW/vbo9cvD5xSXT53EXj3d3+8nd2AAP1KozVcolH/rO8M2 xANh7Pw5rXC8HWtwmmbtGFaaWgH6767pwpwUJVjkL0PLxa6ZGKB/Otu5+x0vyRw/53ItotUU 9bOPwBxwZ6p9+eMBhi96f/Qo242e+hp/w75gzkfwzB1549GjbPAN33uQ2rXLketK7jqW8f0R /SlEtP0Kve4UAnu7DebjVrDUvhx4ZoXSV3cdrNp3Psu+aS3d1CaKdftueC+KEHT5pwgQeHKp 8dAtLlJLBjRh39OXxdxb7z87enny9vXR0ZuTz7Cpjvcb/eLN2yePUeUCMdAsZmQN6J01ixO8 WLIL7H603dU32K8aa/Lax7En++pjxt/5Qm8WlmB+q5btjaIQlSZvEeb8i0asKuEY0tkNmEmt XEXl+m8o66d9YNp/gPlOVbmDWOtlVX0zwoC8O3f0a8me4fwpGQKTafDPVi8+CHRR32/bkyZ1 KhIOPS3et7FH+AJn0zRRWQWugbAZvtJBbgQDPngzJEic5YfwBSyXvQUwnfOG37+500YR90Em L7IR1yUCPxK23wtyfgjS6ND2EcqiQpHkB5+P+7N1+P7bgxbNbdkQG9+Pd/3fnf9xQ/7PvLr7 4+fAfJgsS3bk//DvvfyfNIuz/5P8+Klv/vl/PP/n5vMvpqfzBWjs56PVt9dCYOfP9flfYRhk /fMPgwS//4n3uvXn//HzD0a23RWFqOhheyoVDvb20EthHf3OI+phJDvpPhmT8TcUk8hkSgZW CmHWLKs9Crbcf27OL8z04KvJey/Is4xzwBaGbFyVYR/kgIKA0Dm/9Oo1p1k5fawms72ugZT9 AhoAOa/YMEQBhmQZJsMRJpibi2lRSaLYnkY5iz7txFzg80O1w1J3LhroopgsWv473BMyj6nv u5QyDielWMbWAdp5ag+eCpOxDaZEO75ds+0SRnuiGqMaq+suec+ZhhOv0Fq+Ym8PGpDI12E2 0oSo6pNEkXCCxwXHc/wnz/+JDcTCMCpq0IqegwWoppQf5w7M0+9xyhytGfCKYiUYEhcLjOQj 67NGxy9HgGDPHZeRG4XAQHJsYWyGnHX9hATWPX6vqxn33yxm1FuP3hoRurD5kUw8pMrsUc0C qvNWrfjY+9V92QnKMVpvNZqU/SmcyD+72uM4YjFBUIiZm16oRj2U+nEzThWBBo9utteWNmMl GvDrUHs3gi5jFueTGV0HcvnYlD34jb+TKNk97Nng5O6h34XqUVGZTgGGY5NtYHVnonOLmwiw Yjk/N5e4hyVgK1ZMlstSGtjvZM6ZYl/99aAscGcnussTPNknmzcXgd1Q38b1klOJ3BJkh+oo azvWNXLJvKhrwtyIZkEgOTGWEw5eoDYV6CuxdfkixfzjjV5y7LzDfesQlOh1frG6IifeXi+U ht9SXKO8RluPWk3T7nYYVzcKg3M/76nBizJigtsPp7KBVNZyayc6ny/xplVmZqE2xIwSjm8h 75p7MSgKi3JK3gG21u8LuJOnNjhab5amY462rwazv64oRJcDzdQjO8Nyh1PDGbHaK3HPeZ3j NVsmIrXtJGptaW37HPG54Eaw8ymBpa3QfTlfgJ5SFZhPM1mtJQQNlOsrDsfsr1fp1WR6tadF OCkAFS47YBMeoor79g4xi0DfEEU2cd9DVMvem+lem3LTVis5xp7zI+/N3L2RSr3Fkt30CsPv 2caSbUVRropCdgFif1pt1Aaf0xbZGgtgaScjFlwjH11KNgCiVK+TpMbGd3tN7tkoNbhFZPfT Wduk1ZfUZ7k0ZsYXeOjsU9CTHfGFhjttttiY2PQFun69JzGzm0dGrNmMomqPjmw9rb8Eyeg+ YfXFYl6vKzdHcc/ldwNbDPtCOmBQxEe37yZF6ALcTwEvRt6rlfRjHdLFBbw9xT4j7aowamBo x207SWhYGIpBHG+oUW4v9yh2mTMu5MJvDcy0Rcud5PMWJS0SIiz3toYqOqjiHhcQqnVlFEto leyQ5+PYk5pNBFEyTCFAsZohRiiczacWfHSKm3GaE/bU7sHlnsP1mq3YuU9DuesQuCyF6QLh sCKcLIsc/xPeHYdUONXcuch09zpcC0un2ypzBRbvMIqv2+Z075yCnvi2Owl2AUl0cMuf8rtL 6ZB6LgndbbTl3vXMyokxtVWKsbSw4D/cIhtN2KnRTn3a5phfS/zZDYbdPIc9JCdOdCZ3clpZ al3OkeubS0oSEYcPcwj+UG81gHUvHHlPTLVdV5jMVFcIRwFmytMlJLpC5/HOXHkgJi71GM7Y gwCyOAyG+Fq40ZdwlSmw7AqF22byLX0GJGa+R0wBixugtFUbdt8C+EX4J0bYopwVMilugq3A KMZgAibguIS1ARioyS9FFqDvh/xhML5QJkl5hzt4UVwRws40WoNWIFnwe5zXyYPimlTaX1ly L18S39V4UBnEAIQFiNrEYX1B8TGI8YyEjDa0hQoDJuBmzjtxA+RVBXGJaeyU2/sUEvZtSaUK HmwfRyXrFKejcalOJQ1jWbc2OKbNzOcYDrTCtQlCa+XYt/o7V/daGZTjGksQCdj2BNppKEZs ySinhTJ5LniZ1JihbTyGY+5xUux0baSSn37JzUKtW/TbLtDwomsmigB5D+5NKfEk7I5G+o31 KNpDadmTHNFnWsuT3qCSsO+ME+2FAELYID1b4b2cNxhSu7o0cpXpFk5We5yS4kwkzEO+9+z3 bWikQhroLX2oeCdogbXYgJDQAPsCQLwpZ5SRgMWeVlabIPY6EzpwaauW7JVmO8rNGeE4EhE5 AKdquWKsYBMACJ0hwz13iTKMQVkGeUjxjtnzlGrIEXypipw9CiZT3KO6vaWouYsu4dRTBTyk DKHCAuivlNIz60hgqMawoOkeWu/qqLJPAJDWCGy+gF8ZK9kZjzqUEcVOv7fMRKtKSErC3lMK OKDVaP4gilHhOG2bigvV0MQ2llfuOmG7Q5s4tydyurtKZA1ozcZdUIQFd4PshhFL3eDIt9Pu 0UVatqJLm5i3Mf4SyLAM/3K+EjKECyZ1eI78GdsZoUQuIr49dM4Umc+kRkcnEN54//mfsKoF KCCffEJg2FM5fDKCw1TvuEO/0PpwAdIHQBlAikLytNACAgRdq/EWKPmtKASHq+2BVkNFhpjC weLxEJZX5+V8yvef6srhGy3xbDDtipK+8AWAnjzPLDH0XsypMgaoEGi/0LA9zlRmEDBR2Nt7 9W7YKczzbgbU5JKNA6ir4pUj13/ZrJeM53YgDN0tKPcTrimT4enkHWL732FE1j8XCxIQCftX n4jW0bGUMLmn06S7UOwJwVp1MJiOHj0YOMqyAIJssYuNYDomg4Kp/x7/gcF3Av2llDoolvbw 55T5SrwQ/g0SRaljNq1p/IOONVkqs+azsMuwBAzZOT37yZIDB6dW1GuNhmTUIdKFKArsm6k8 vUymENGk3cFkYXh5JbByKPzMWRzIagt3PQR2x1gZhS2RKmj1B+Vk5VLywhmtBTICiPgeIDpI YMsOswVgVsiLxHjRvu/erK2Qwp1fdccitrlEgqbmIGvk6aDEwqCbgMoaCI1B3WjoiJIOuBXC 2IBDCz+hfDCpTdHKACirCa0hpuVsRguEMgcQ6rQQ0YLk5lKKstsLBiSGQ5sLPANWUWi+0pyh yo0Gt71ORLJL7MkkPBp4KtV3o3gZYeXey573dI3YnYZvkSCyMt2iI45zxQTGNBCoplNWW/bs qCTV0t1hK+KSmZzkP0lsE0yC36Bxt2km1QQWx0i6ZzkMrsfGagGavJkra5TzNxM6Zz55zzl5 fgi7ozEdJetKi5RiceeoPRtsDKdyOi+xOteAykVQ1Dyla7NK4l5KRSbe855VmLtcGFbEIzLW zAgyYrJEpGvtXiRYrmcyP74N+0V6eE5RsMB5FvdgLxx//V/rpYYez5QmO0iOwiclLDriHdx1 FW/sLfsjozKnHVhkFlmrntOffJgYNwVTLCXWbc828KUyrRxt3N4ancGhTjMdUwm/1TdGe4da jIHij1mdBry3jbuKle0KsSSllCUAQxayJf5TTL3A/4T0hXfqCPi7aFbAWU/x3JnJt6stvPA/ gGgzHrWwK4CSH3C+BPBvZr+k5KiuKvD5ZCFar9WbdCVwN9ZLaiIlzBUIDPftZNTEUGeDBUna W0JCXMF7syvh/ZUTm+itSg4gH0BxSAokbBqN8DMMXkMm2GeRn3LQnyAeHh9thJREPL89wGkK 41HpFpkzF5rXjQ3ZbEFhPcQDW6HhzXwb0neTRjrY2SoTXXI532uIHEqIIj/8fjlqH8G182BO oK9YV1i+J5mHLvScLSxSqHnvMwn5pDBzYX8gk+A1q+eXs3us1pPQVRryUpEeUw/5dgZ+Sy5J kySzSdpyNxjg8J7n7316D57dewz/DXx/7wn9Cx8c8S/B3lP8Bb96xr8Ee5/RL/DMMf8Cv/1Z fgv29p6TzNLTylRxxnOyK/D2WRaUCzeAFfm+f887HAbwSyC/BPpJIJ8E+MynwxB+CeQXfObg kczyN2+f6RF6GTBkGr4PnO//vvH93hFK0MKblyoQykpVPexqyEqfClGQUVKG7/Y6qqkloq8Y tXiGHWR/6FBVxcy97khcxalq75arLSjevBUgIGEERtRC21qeOhpjz5kBoOQ2zipyC6ogzB/T KfC/CPEnBPp73hH8K9P+nelx95g/cOJAlJw9F0UJIZ7CBIQQ9AtO/Yx+CfgXQojPFCE+U4Q4 HkZ88n+GX/DSX7rFvq3UxKvl6l5qmeekAgBs6HeF1TPqiItaOkXYYTaoyFZE1KwHinLd7KtM oaVcn4qerxZ77uNB2nu8kyW7j8ofHqdD+BkhOW9svdhzvkFf+OFyuT5n+mh9nzULZEhyrd1P 26HMy6KcgOp1pXTIUg9rCxHVSpRFLxiFiRWJLlBubXWRDjRQtnU4vpVBHHiQ4BKM0nTLgPrC XodJEPlbwIvHqLthFRziuBM0tCLXAGVmwjUTsUgPL+h0TiU/ZqJVtAIbDH5uCi0I4upBjnA/ b1bAUFpFlsQZ9ICsyPyPep3kMBZ7FNW/X3i3xJBwqxXN+BERAVsHysINnCXpDwTKmgQT5D7o 2XUqPRZbRLbGkKenWUk5TjpvoVB7RV23OQvtYEybMMSdtXLRAaQEKvDdg3lzwO5p4eOoZ9ad opRLzsVjCzvAVAPGCR3n7MU0ov2xWUhLo+2Jl3/aVYlIse/XM9aYvxeYUnJYT81i77/w6z9h 6MtovjhtwwLPC/z6T7C/89lkBCxzZaqzkanXMOxrDXFZAnH5GmNhvvEwCObPo6HHMTHeIfz6 n/956H05m6CMAXA4tGZ2RMU3rJIggLA6554TvDP85BPv+OjoCMvcz5ZFJXWXZyD9tPXgAIJz 7LX9F7wrYTT0Xs5HXjTcuwD1KYqygyiOAAD/+Z8SpGiDgwDAVA30KY3kvcFDaqT0MczbBiyA mnC2Wl3cu3v38vJyNDGrBuFzd9FU+L8gTwKMI/u3xz3++sM/N8f/8an5Pzj676b4v8T3w7Qf /+enfvxr/N8v8LNHPy8NsHcgbX+F/yAferZA2vehP1+gZ3C9WgLXeG3IzUek6rHkUYF0Dvhz zfuHU2AQQIOPMBTvYjFZmuXeYyzTApTqnku9gOh90M+fD56PbCX6H/mD0x9gZfEfO9CL4gor 5qd7TrUWzI/4IBKreSNeNEJxkss0A/slH/ALcz6nQaXc0Plcs82XnVqgKvtwJXND/u7z9QzE rpHzLg5ko1aIGTdYBb99yxYUIGP8lQcYU0v8o63uz1UdV3Y9WNRiJtGOaLs8evOM/Aj3ZN2w KPyIRT3svao10+ZaBxdrE66udE5czBSDW9bFFEf4YjEHmQ2+f42ixJLrsnMWn5ij1AePluF5 tcbvYCEvqd3AklbhNDeoqLlB6gEafUFuf8FvEn9IOHjuNDugBWDMkK11cAocWKJUsLUBvWa7 H5juKqSKCmHqxXpxgTZqfB61AVTu0Yt9ajo111ub2pJLf5ImhwNMi9npujgV8RxemcOAC7GJ z6SF7UTeHSqa1FZOxzE2mjEUUrfL/r2gsNOlWbxHjZ+/xlgq3sRyXSKKUL06rWdAVqp+WFgb SkMOjKnBzEfKHAQxi/DEw9pgvRhdlJoxXVguhNSRpFUszJREQQWt7hvH+ezti+ce3wUVgzkK URSUL18/x8ceNCS7wH9H6/UI0P0unOUFSMTLuxez07s68pK45N3v4O8DLnF5tjqfPoIlH5ZY Y6patRdy2bnInHiyJPfncjnVEku9uFBYpYi7ntQJkTVzeBPGEVF3DVCz8AistckJzZ2oiRmP xEqN0ytPdC9Td8tLsJufYzLJSodjYcgunBKOUSK0MGjOZtv+/9j797Y2jmxRHN7/Hp73Q3SY k0QykqwL4mJsz8YYO0ww+ACeZOJ48zSoBdoRakYtGZOJv/u7rnXrbknYONmzf9GMA6i7VlWt WrVq1brSskD/A9JfTlK8mImqXxAtXXGO0YxZgilwUaQfR38VvaTEGU4BY8pGcn2YUlgaU3tB 68y7B5kSH0mPkuQOWNBHt7bRiHcLl18ASmJfv+t4wmkXitZNfevEuTaJtp/v7x7VO23aMhjj CmuBlncecaY1TiSZnSYXwpYvhnhZwilIsypFWZI7PetzJ9Ztjxc/HY+n4peNQA17j103HEkI wk6vpLJFFgcf5V7fBNcZc8DNOV/fvqYr97ul/9/S0Ysd9zhf/ADLn4KstIEp7gCHRsTTlmk1 PP+hqHH3T9SWE7bVAGivhad+HqA2DYspMQY2TC7viwPqGECdRnQMHPaTxuMBWuXIjeEgvtNQ 8oC6eHgn5CGikam4r5mlAo95zw5PkpZqBqA1GJHwe2Lxxn/TBL3OHxF5maExHT2dPQK6+9Ta uPyHZGEYehO5OyAclmXNd8W2ZqEBQJ3PW7V1BAQwrCbhE+mIAK2is/J0LMHSnwQp2kBAQELH yfl0jBIa7GYMox7Hd8K1AAIS2j5HxwhY/wsR4D5pROsAaAqHwjj7Ntru9Yg93REUA9qgKk9o w/vwKDoSNnk3XEWbCGjTBXTM5tM7or3VXFoK+KPwTMvn9HaBp7CKkyoj+RtqIA5oFAhrxRFp XyyUkKD3yM03+SDa42gJnJoccjuv31BCyVqEUjlnyspuM5DIa5Lxi//w7lTEbUzRjCwRB8pL 4rRyppsjkkQPFi63/NHsfI6cZD6fLDB5UFh4WlByCqbrAdKpo8WY5QG6uGnlsdS6bTiKUXaL yzxAb0aDD7gEGHlVgLgpJTV1izRp4qkCaasY8XPErkDm8tHF8lfBul8jVQxwOfvjJMG0Xw6V u+QpyREo72mB7G2CMUz6X4ETYx60CO5VPUwpwWl55LbkbAKWpu5NoGrfs0AVlQkqFltFTGCg r+PGQAoA5JlVxJQtmHgr7U9u4JYmgBzUaGIYTI+E1WFkIQCTD0mU9d8juQDfE0By1XGXc4LO uyIpByI4WpXUIDE4p5znF2O6xA10v8C+hwvb1ZVj8WZTt9oqyGzFHjBjShT5nilI2hvTlJQP FKyq1OYO1B+c/JVkjuNPAe8UihYwDj+ra7ocZ6Nx6KoTYGnDLtllQ0bniYI6xDcjulzSXDF6 JVKLTo8DbGsaczFAf0S7UOiJyxGfujfEBxi3xfWEdRl2WVEbIynKdIYpbQA2Mg+HSjIhxjKH r6IxbcsbTzAau7rI1U2HmdejdDizKwGEHSr27iT/KnYR/4+iDfFX5ryTlEZVkhdq3C2q1zAV 5ZUY8aMUjreJJlKLKi804NAbcE1zc6En1wc2Um2IPx+dYZov3GSHEp8tGgki0hyk6ShvrzNs XXch7soNzOmYJEocqizkpmKcpNaomCKOTlFcgsS5sr8i7u9GkdmieBfHCW96NoRdPU7Qs6lE aFG87bka0XaNIyE4bi8dphe3BJrlg55xbybDndzY4ZM5Mhi+Pk6wUtJEJIRzOE1ZM+r11amp mgwhTK8x1kRs5kRjE7dqDkIdiLBmNWWmtcc/aMBIbGNRHOLBkE1uya2i9Fa0xHem4nvOkkUW e4PHyBozu/3P0g/kRkyIdqW6lXq9vmL//I3+Pa7XWReLcUJUdR1dU43tltSfrhjFQO7vuOzc /3EZRa4vAnkpA01vzUSNXxk0wJLz+W1Gm3zfNtDA3ayWyUdcH8rwGrMJJcR5jI6CJo9VHC2z uzXcw7DCOfrAWD5866ZWnIj53HArJ4pDudC5XOnoNT0VSKGcoMexBrg0icCx5igJWjISdPSt SyxUDL8q9fu5JXlzsLPOTSI1yxgTmR/pXASgN7jA6WqoU39CKYRJZceQOKHdXDhnPpRG6d65 Mctk97P1jyekZewMKhXeJAUZoyA3d/TgqjkHpcnXyZ0kvXBz0selvfW17mqn3Wr+VviefPlD SDQ1ezagzyxmmLi+tfWy1C9025zi9KjO9XVkcZwUGSSAU41QOdOdzAqEfGeKrw6PT3xEIFA+ CSoquaUYhCiCUcy3eHN0eq75tEaw3TE9rUyo225ycu2U6da7tcKHWUirCF9FCGazLiCYfzSL MV3QMvov84vzpWEWvxV9ucIO6Dn0PGGdhHmL/IEK3mpHH6g6MJ8OvvJK0bDtVXO81KOYMkJL QRy+SfqIa+aRFp4WO69e/PZi/yXOpoIjrNefVota3O9tavWLHA+VQT+CuTRePN/bOUGRs5rH BiIZ/nUK5liAHfovQtt7rn/PwpLFln1WWKN6Vp+NRiO8yjYaNBKyYnTa9Nbde1BS0jsAC6HI SjhyRRzCtBNOEDHxKrE7l0HNQCt/AhlFFTc50Su2EVF48jC+yBx00c1WJebegI2adCmNo1Xx Tc8Zm9iXbbVuwbDnuGMxHyRDvO1oTc9UvcpDWA2fuRD/blKoOM6Dp5NrlG+yik3W4d29gxeH fhMclsWMjxgGF6JjgOo4vpIWD9qrC0UJcRGyx2MARDoRAMsSZ7BcGthiKuuRa/D02sLhNEh+ UmNvFJpGCtfk9cFLuDIliW0+turuty1OxPm2/Q6HDpeOayQxkMuDi4tp48xGrbfoo0pTbXU5 JxTbstl+aCRaRQ9wzikyQgsoND77ojzlxuW7tvi3opAnN3hHsScJ3InGzpI++3bm0gTZ/UBE UQmJwll2PBJ5BWvytmAafS7rbaz9F7OpUDafU/vUQsmokiTcpOD2xj7yFQL2ZD1ynUIx35Sz 3IDSv1M4qQWEmmAaBYcYrJv9H0vVAXXI8NDpoNm/+kV2TghEVX0KxF8DUxxB9gul8aHSJrA6 GwanwNrhDr4fv8wxE+QwOY5C+Rlw8KE0YTf8KgDd+W5353tg65wR3AR4IEND0oVOq2HrKOrq ItJJA61z98lcoyxaE4bxYn/377v72GVYBMs9r1BrJYNjb958jUVnjDXOTvF+kNy4gn+E9SFa a8RUTXpkvQqItDXAgqjPJCd0BWA+wGS/KzRzR+tPoS1uddZO6z4N1t0vIhHw+lRez1idvb68 RWmd8G5DB76rGjDMeYwvyTXQwcyVWAfQrGCcqpFaOXUO6b0daEGKN+dE44sPncuckGQgVo2+ dcl2lG3idWQBOPl0Rrcub+JYs0akE3U1LMazwWMGvE3DfHHE6kWAVyUcPhShwZmKpAXkybv6 ynMxXUy8Y0+ya0g2JwuHkeFgz2Q1MiXTPJw4zII2mceBZY+5WwxTwqB4wrds4xjtaNeVVeXr /+HHOrOceKeuHJcV5vBV1X86/TlbtJhNNbF2jcUbq58l+Y3xI/FatEpalLzeLnhd6miXtOgU tNAUCg56alGGZ4bXsc/YXLkN+I8slhwWHIcs3jUO2K1oMPH4EQcauyc4XADGXt4bIx/cpOPJ JQX+GRIJzm7/aC4QmzZqRUe+c29l6cwVyKQIerGJIc6cG7hIdir1WCDLd/HuX0aKVUdIC0NY dCOqHHvJO992CuUy9xg69Py3/BlkRkhQg0pOTAh4SiL3WF9NrDcTuXlUcpwpPO9N1HJsvblM TXrsZToqXVzM9Ci+mWQOsawF36vaNITx+TmciVKxNlBHR5ElbUnuZF27Bixx0aFb6l+WQ4xx NDOAap7Mv3fypn4S/dhot1ejh9He8WG00Vx3rrHq6duIvDUGIXxVhPDu3MU2iJd0jCmdHX2K JwMcUxGUKcgApITEuCu2rGQYkOfcH9CkM+UcrMOh5jnN2nrwOM+gJec1aUTPML0VduKgeCzl zqTs91q32241uDuvLgxGxVEPUvfFumMG8zLU4iqboOEDAN1BoQdhjzyVY+RpHeuu5mvEnvhV lp0a96wjWbt/iShwabLapVJbnrHi8X1f1LKavwSExRoKOkbN3NNNXCPvUOTkUkuOjS+hmDwg leUPkuBIwBCLcBmlVlmMM6ONMBkw1L/ded9VzrrTicmzld0/CgYSmSyWhpsZ+yHzNO7Sd/vd 67vPVLGqvgss6OjE8kanfhLjZbWWG6tWusgkJRmJqGoBBAGiUbR2ebswX2p0mWr+ClFVDRkY 17tDh1is/KIHKh3P7MTPXCqTmFhyVicSkO270Ggw5rKsDxCUDA+hBMojw8y5izl3yAotq8U1 HwcbJLCjUDmZ5A+nqlhbDDVxI8pZIGBKdQOYy0BWTyiHcymcx7jm6FbPXkkCh+v2UgHHAUfO JDwgwePwtjEHewJoFg7dewwttWguNRuhQY4jdpMNBJ34RnnypCH5A4nVCwhYIupARHIje9BE sqyYSThbO7epFUwmOQl0g8flW1x2t+t6oNjNkZoyHHUxKNrvVmgxvk0U6ODs5IadwMwNLvB1 OAUbfLb/xjihhKESlBGpejUy+V0MD2BdB68xMAHPvZR4Aurc5ACqgSj4ulFbfvnT3uvFxEdz 33djRKNcmMX19OwhVbzGop0Pfx1cU/Ahd99+B2dvegVL+QxunclwWIuWSUn4GjM9IkQNYHsp wRpVfysvOoiSWA8eRSeHhDuJ0feAB5C6VKSrRX9rRC8bgIjtUbRNsl2CSS53VBrhYOHxIFbT HYcFS5BSVlsujhXe8TwLJU545/BVvdM0E8CQYZCN/haPpkiPrc0N4PwYQNxeXa+3u20+SFA2 ZAHzKOGSaj3mKiRv1qLt0Sj5ED2HGZgxm1BnGJ7tDITbM5wwyBwd7qe1Cu1bq124fGzb+/U4 NTfLi/QacASIxUthYzCZNs4xR7+Rd1dXTWJdkh7FPUcl4Hv281u/Z6nLd9smZLtu3OyNsmNi wawzn5ZhQP8AZJ7LPteDb8aqTTJoxQxA82mUoqEAbeWO4BLMxQlNxny89SlpHpW9RZnCRNW4 UrUoKuNbcUhzEiGjV+2EcqaHUTIwkgJPcg7Jwkw6GGAG15GBe4CbeLx4rPxXYgpZZhjQ5ReW 6xqDczBlzs0I6xcQ1DAmkE4vmy0AL+WsKDXnlvWTjG7G6YTmxmYLvgqpx2V4n895REXRy2Ey olvxUYw5r7L66+RyjOmpHH8ib4biXYR9O2FxMJNCr3maYBgJSatZELcLX7ebnegYk8ojAsjg EEfb7xOS514lI7h0vQbE1KKd7WhztdnucvzkJUhnj6LKaqtbhYtuu95sAZjK9iuSremy/mL7 x0fww77SWu9QYMXuK8D5o+jxxSXcsf4z5lGhwfPpUuHiLHmNgHz/E3bhdSMeNECmw1QNT+mN /ycJi91CkJjMYUTOT+cctFRiArJenpTeGKR9TKCHxodicikehorTDiE9Ls0vwYPe7Q3gDjqg AUoZy7RQuBXP6sLh5cJeC1CrYyPiy1HeY3SlTi50mOPrgQzxHtnqxj2z1eJID0LIBgVY5OU9 e2PK38MU46Rst8U3jOMsJwZzisIb1XjG+v1AwV1crsF2aDSQI/KgtslPJpdaJ4f98FOtVnE+ Eaf8hqPayCnWzxJPL2J8qCgJ6/V4wNpI7tQIve8HYydnnag9Kemvo0TzzX75qWgEtG+CULuD OKmxs6bUcMjr043my8RDqKmB1KhWw8Y37ms5rnw3bfSxhb5sTLbJyCe55I3mz1UUe17tDlLV HTUvsqPkr+6+Kpfk5P+c8YfPxqg/+MA+yPL3OWY7HWHQCQ5OqUMQZX0MYQB6C3Ypu+brKnE0 GOcvYCiExVZeKjTIGMtLocFF1SBodpGR5gwv+A3JAZppL0ch9tKp6fD1iMtlMGDQHGhqLWSl s7dpw7TquXfPs6EQsA2GQQzAOQhBBTqkTGKFiNLkEmdHUqzIVoUZfJUltJv6nJgxUSN6SB8D 9RjdQL+vE9col7OcFD+l4g24V8gy5KRq3jna8d67NbdTvqe7UcmSsZFiq26CDF+u4MZVgb2t IppZmLytvks0rIpijEkRztQDaelWDDvdbld16aofTsXbkwGazc1Z1jEx5sVwcDEw2XjJVQKb 6tqiAa8WnVFVyYlNnija3k4crUTtM/jPOfzriAsrJbvQ/BWOFpON4Rmq7lF8rFFCDC9PIYCt 2SIvnOFL962Iw5LfjNXWbDmWuTiVNmyZHJPpm6EMMZMEerZz2RO4MrPuWUozk0w+TGKpys5C +XQkbvQmZOGkKISdAvzR99eZAbl60fhIymUbNNy5BNAV57jPQaNSFIIlLpVNqdrYE1liDJrR 4/pTgQOdNqouAeFwihX6bl1sKubuZoPnZGiWw/GCi7VaNUhZu2Y8e20jy25IlUlKOXflUJ5P sIgIGvTx1jryC6fhWMhjGpVVio1g6fU9nOu9ylGb9yxHlQW6mlQv1sd0h2+sYh8r8SHgCysx 0rMpBq4QJXIi84KIjRqtg6morHUBnWCPQeaYVbcPjvdgHG7cmF6cG9EBakSQtDHQIeZ6TJiw DnNTsH8BhjgiGBWLUJuNGTaN4f0b/vFsMKEgrO2D58KI0rHuqKdPvVc490p2OehP7KtSFBAP G6blIELU8sp/TjH3CtUryyLOUuhC5DovGZP/GdbM9d2KbNRcf6IDfPzYGyA+yo1v337pduHD 5v60CxqW9rGyQj+WRysry6jDHkv0N2vrNTRC3/6af3icPR0/Ajr5OjpToyAnLe+pRlqduECq ODMHjhYqf7Z9vCtc9eEDZpSZci+qoKYHIVv1bKX6hw/sFN9c90ioxAJNlM8xT8tGfGbfFyzH 3Gw0gIvUW++MgpBS2YB4wMfulKD2nDPgpHCbwIWCU+8rnJD7WSfVNxlufPGed31EghOXrpxP ota+G+vLqY4rSPmnvCEr/MMUPY6+ehLtHr6oRv9yl1+h8XxO6c9Ou0I/a1EAYsu2/Gh/HfQj fh970OxBDKnKp1jFtIQlKppT0HvBhGsF6MB4uugBjFHq3Ccj3TV2ij4oOICeyJS/iZof+vDZ Knu1jQWw+V3gBa21akET7HbkLAMyuMqIK53DfZtreMPm8ZFOo6jAf1eI1EbvqrBBkNa33Jeo f/gv2qqr9FX4kl0DIUx8HdgCjhVb6Zsf7baIjiwJC7b1VC2gfdpRn3+kSaaa5hfx/CugFZeC FqERwV5AhK19on8i/qqDyrt97gd1lOXnj85K+Ofn9/osmv+z9aXyf2JS93au/nezi/Xi73Wm JZ8/83/+Lvk/WzPa33v+z6gw2+ZdrLVGN9n6M9/mH5hv88/Umn+m1vwCqTUJp7we8ljS00yt keIMK6w71gkKlbK6T7KdckkABsRlX+h6p7WZzm+lCoFmUCHZl0pQcJletBOroR2hSOHnutJq cYrLE815lE8JykNZJNvVzAxXxJLmZwWdk9iKCLYoK+hiCTpxS/B8cgk6cyJv4eeTElu2PuGs CA+cPxNbfsKI/hcntiQnhXbDJSY/zVSEJI5xdrNny4A695AhsytT63xuhkwFpMCQLGM22NGZ yDf9O43IRxSX/1g87Wa05o2IUuMc347S64yKqGhFaYd9C+8OgecAwbjecFqioKEEU9hALX+0 nGrTAWQWkAa0+AQ5jaQDaJUU1PXzAFtZVHl28o/Xu0+azWoRRLjjB4C6eZRT6XMybaiARbuR CtUq1DygtYYXs06nIdul3fLedoAtBhW12gGg9QJAvdtRfDU4LwbVorlGrY6ho8/KtBq1aK+t +sOwx78WfF0UUPezU7ZGLSLItc/OtCqA1j8796sA2vjslK0CaFOdz77N1PnszoDW/4ckSLXU /D8gP6o7mP8N6VE9IO7M75Ie1Z+PuAb56VE9vAU3hcUEfX+keaF/EYk/TwUwTadGmCbnAnjo 9zPxXDaWFeBygHmydhaSxu+SwHXr/qT39j1L7y5K9qSO3ISqtBvbHe1RU+JAdpK6L/Eqe3i5 gfVhJ8AeZzmZTsgXpsayg81gqZU01QMqC8BwMIxSGa4OU2M4iOQDHNgIDHvziTAf1m7uk5+a QzfIB729UC7d4u2lLpNks6RBVZLGRaMG4MgX6cLEd8BuvUlMXjL+iHNf2RXbA24dA524N6qL TtFaI0JfPL5gRVJ2md6Ig8wozasXCvwNifKNsycXplV3HI9RJlLC2YmlChaCjfg4s5sU/YSo MHPy4ToeqVKsK4I2xs922t9rnCm5zJA4JynmqBDkrwnb1yXJZrPRbHW/JrbP/kEmuaoa23dH F8NBdsmZeacZez46qpMzLKKL9XVTsrSDPEn5fnSFkw8gsEiN3gFWjgxBUPbOG3Y+yrItXWT0 ubNh1sqihRCwRHHCThkGDDmtoXurJiX9A3Mh524DMxIiC6Cwyf/grMhAsCCKg2hNcqjhi+wd /89pwS1JAA3QJWV4jb7QFMybYpzaP6eDseok75pqWfIo4HKZQbIOT/2rBIxJN0I+VhWlQfLC Ru8BLy/JQA8xtwPFZWwdUocxHbcYlW/a23vvn+mZoz8qPfOz+0nP/MnZmU1e5vuTczpfRM75 pLTRrAVLXPetT80cjU0n+NKjxVKdL5xn+oQSuZA7JjmZw7HtBO8ICBHVNRpAWLWbLtfaAVsl Gam9BNEtTUat26o4JXXD5sEGhsfZPThYK58HLZdbLkgMPV+rKMae8MKakUUSZIhM89ZmCTm3 q1YKyJlCybPrdKQ8HP1xpyTTUZFuVhUF4QDEslmvhdKGJELS9aT7TPKBmJUIVFaHRdKRQMVW YsKkktbdWrfTdamBCqdzPwPP1LOwGQeh5FWB7GDnFnzm/G2J7Y9TaZlL/VIkHsN4h8NXDVni 3dME7svMtooMShIGzxU4bDodymDZm3KMAWp8J7yjzlG+Fe1jbLtjYY8AXUvSRVka8bmiNIM5 9LlkgIlZ8HqZPaLA+cE4OMwTwYja0DQ+UVwufQrseyEdSnkIXs5XzwrnPG6Io7m/CgDsKkuG 74WmbENGHeJDG1DwEy5m1Q/AscGihZRPxDkUNZZgA1U1gA2ppq1Zy1ASpMUw1dnfc+IiZDeM GIlxwKRMdgWFCUqEPy9bsExVk0hDDLSsiAqpIKMMfcS41ZBLySztwY1nGoHBZXzMCt0aSYg3 FJwiat2nsmeD1XNSBSGQnEhLmzMzUDIlOJGzKOM39kgP2l1KKyqRGSj8mZskwWGxAC8nnEKb by3CJ0T6simYHD5Rc7LbKbuICTD+gpknHXLHpcQOOKq4IksKMMwkau7Aq870C3J0uahWnuPu FKv+Eg94ZKBAyHzZkr49RLHMqbECdrtx5jIdY0OdOJztGDIozr9rsn1jsB8JYf/NwiOygaUo KtyefIDHwq4aBS6GnyfJrN6zJFNqEVtie1mJjeuPLYvAf/xZfeDP6gN/Vh/4/asPFGDiDyk/ EN2xAgEVHjClCBZs+WkVCObVFrCNZlUrMObYEt8AL4lnYQCvIJ7D2LPMJmTkgEpNZ2ThBDuB 0nk493662cI7dWvEitDWNHXtbTb8t09edL5+3CMySTxfj+DEvhTby/2dld0vZd1ADMDVg4QX l+neJL5EH3oX+Lm2IgxMMSdnkIWYseZK03jK0DXFzboqsg/H7cX5BMGY8ktSVSOCOVG6OMpa KJfpDYqZqJ2TODy/d8cdBX5hfZQur4XizpbYqAwm3L0PGOUGOvltxhTo6XQEqGEidTMyK9ZI A4+bAVm0MA3nboAQVGuPLuqTQWCDjWzQYTFjd6NtGrOHnxrKDbwr7LzCvnVMCw7CT5jKH+k+ N7ayIRT0GWTVlKEVDwHBuXUa4HDled/AIgH5Dfokg91IAuDrMUbxaOKXUEb206HnaLZWMFY+ XJgnuZnzcM7kFPwAvXMvBiMt8X2eJG7+hQcoFDyolU6+YNp8IcAeHbkC9ympv2s83yBq0GqU 4RKS6bU+wwzOpHFj/2V4LJKO8fGp3wx6E4cPO1tPUMjpHV8dP6tP0vq+SRAfaGBo4/iMaoy8 iRLHckZ53hYhZv2lzqVOJhdm1Fphz+rwXm3IJaHc7cyeYYt7kzlk9prfEWcxR+jObq/O0qHo MV23Wkqd6CzH8PoyBimXAlcdS0OG2f57pC3QC6a9BTLwmodJY8K36f6tSldHI9lD3Kst9+sQ mhmAVyLW8HG83MdMPZwKRIR9+sYZjihprFZrOoqvzgYXUzgi0DRDIwJxr86/uXv3h8T65Vwb BPOak3GAz/8BpRuhC7Sb9tDCQfUOui1x2myp8sLabcQiqiaBrfXhlx5LEkNYCbxnNp1UpxGm SRfHDJta0bTLHC0qrlQdFqlOOw/ptxK7hUUUPD6qskpE1kUoW4mBdIgjS+zkteMsEbUy2ZEd 9tT8lrUMrW8zZQqMgCH6esjsHQTh7k/TiQkRwFm5o2Q6khXyxOJHRcGJhZ9Pyl98v74e4efh z/7fx4zQCMNWekl5wybXg7Iflsb1t9KGD/E/P4ffbgvQZlk7Geaz4Gv9u1XSLjdK+ezw01ZJ u+JBwue5tCse57YMdTbW5qCm7DF3He24Kcdd3sMJB9kghTZ02RnKdJUDuXm4IpMr9QytNkO6 svQwnS0ZuUkdp3E2uDdqeJ4z150kjrvN+WWaZmoqxk3mm1N0S9GwRPs7mLhc7uUArYnEQOUI oB3HqXXNRHhzU9aiidWYu+eHCVqhmhDCNEbsC6cZIUcm0ZHDTy2QSmoSOblHmCjAhRGg9SM/ LAtkarDRT6iWg7mqjRznGKf/zOgi88chVgI5JqcQk9XjHPM09AIlLFoSjguLSVFeWyd9fbfm 5rgnjtrrDZgrufcdG+GXBvJyw818j/F2zB1LPMS99fLm65aakiuTTjuzibxROY5x55LTy1bN 6GlemsyRrbXKAcZQDcSEP5RqTnyyKJn0pVbFlORXnw5UUU0bIL/WqK65APAg/8IusYgtwH4m 1TjIkbrhCll39bQPCoH4CDUusbRBzUYKQVkQcsvnRD4gHlgaiMbTYZJT5JDDm3RGUscF7VqU 1MSDnkANkw+D89S4Ng1vQ4aGS4OOUiihcnrymo6S/BNEVs5cqSCEQepVsz+3ciM9Zm8XGW1u SJRoLEHqSUcX+pqr/7+vc3z9S53jP0iqdSrZImxfxBGpQkaXf/JQJFs+LmlR4Zwa+1UxvxJ9 oN7lPUEM+c72s53nAVmovJCTFlQeyEkDctZHwSGqR7n/7Y6+HLz93Hzfcm+6dF1q6vJm0Ifw cvtN6wMrwQGi/GxFvmiaoxaHYvOnlsEuqZT4JDa56zxzsjqcC0ItIDZV3eKG0nPD7qrMvetl 4cXH07j4yyU6mS0eIapop+LGPfEKRvlsmDM+yo5g3cE0UACbUwgZazKx6fqce4L45wbOZmZK lXYNM2t34P/VRpAsq+hAZ/dx5eCiL8nUNEIMRPwZuU6AZqviD/FwNpDQdb5AfdNw7IzGRulS ha0nNmAj/du9d419zEXjjGjsBBy4F1J9fyfQzGASmh0KBrB+RIiqYKmdUcE49xPf6Rru8Kfk yPv24F0kyswQFPwiPPqgFh1ET5+4SZKiqA3jeDGQdJ3QNhmTgc8rC8TJodAr171/+yNxBhqe HvoU8/jknpgZNN8Vv0BJgEiIgpFvsTj1+En0avvH02d7J8f8TZgTKNczqREwQ5B2h63qrXdV yvCT7xU/KLSeYjt6GYeHf+Tf/ejMtwPo3M6QwkJkqjMiL4uazR3+4sOVNsQ43LPXnJWyqDbZ VpwVgzC7nYLVUXznQM2eW7tlRHlmp1moBK0wDxVLo3PgS6a+qhXV0Gs/kzxBccFIGnmycBM8 YYanJyjgEcoL8jzZDwwB2tDOGvFOLHwNM2nhq18B/DJQ+FFAO0wqdtmh8bti0Pjx31tZKX7z 4/1JFBtfWDPg0vFuPm+ahuL5Zw3KBbsvXn4nqkqP03eYzeP/nR1Si+AEWIX/I/vfpsKPRJQt OkWR0gIGcsA/HF7nSxvyw368x23+4d+9O/yj6325Kg2c3o9pt/jJG21qR0MBstWKx23pZO7A /ZHLGjeLptMsmk67aDqt1XA+HT2pwvmUT0VEvX3e++Uin9EElYp+Hf0i1KQ8y7/gr9lO+EKr WSwYOi/4EHZzLwRjeCE/2+aboIuX8nPVAAggfJd/oeXe+8oDo93NZ32c6Bj3zTJnyQXW8KPt 1okuQdxh93xHwJf8NEYTYVYYAQRLaw0L/Hn2Yu9ge997hbQ3bT566RUMRy7UAmBvzojUZWaU oDctB1rS8MVCfTtxqIhiJNF5VqtLCQqMldyFIo4U6iMzdrUXefee++PBm1+KBzPatQoVVQ/r cUzpoG/EeI7HyCaWOPJ2Ry5wZOHiWjnhJGRD1mg438G0Vl77uYlVVUc2CmiQ+qlZm24NVdWa F0TF+/ytWdCoMALeb4Z9af6gqEIpMcMK0IQ4NducJ8aBipSbN16gHkaaEXIFMxZQodZKfRof FqUOsAos7wIhV6TAMEtiHXZufGtYA+Qrqeiw5YuZumTOr4HbC3LSRhxHyVQj+5NuRqySZU1w I2wz6LueRbOWnz/ZL1Tc/laS0ordn2yjEqnIMb1FmiH+kEHYeCYUvEPT2N89ILQf4C9UWZm1 3glpeqsFzSiLFr7NPgvqtoGpr6jSQtjERCwVwBr0P4Fm/QnkPcgdJ1ecUKnMSX72rNCWKqT5 d4Zpeh1VMLpzGCWjnj1nqBNUGsH199ekV9Q2itSYEJA53wdzNFMMYqDOx48DLyr/Q6vieynT AlXtwszsZtYqBQN54mOiAsMqmT5/zqDXX3i6iM7SV21oW0U7anfXG432RncmfEGyYRx5xM5q fYVKPvVwt87p1iOHNHmFlO1+NH8BB5nBWshaMxgx/wxKCJk/Jqee2Hm8VcsxFPjgMuQwytmW yU3eHG6F4kVRmIg1daBZn/7iiBJ+7qpxclEkW+J8xPfnIGKAA2/HaUZ+yxYOxgOiexaTkkgt bBfQei2xk00mHnEEKI7rOnbzJVCvKA2NJIAsj8EI8+h79TfEB/8eJJqCPML3KtHkywWxwzig 5hzxrOUGcrPectUHLiLt6hI1lALAQ+gmvq0GJCS18DQzu9KNoSRy0IXlG8bXrNkL0xwotW+x DkwVo4O+Fczasnt4g/dYccJXKgvnR9py/6gZInWImA4UCWMBbtK1YRvIW55aIHEPtv6PtX/U 6F/JBvSsBiMQcDT5pigXc8XakXlMxyPPVrVADibXMj26NTZP5mgcpmXMwByxL8I+R5lRUdSe Z8gjhyzr35cP4fLuNY7BMqd9RC9kJGy81OHNb7XR8DnTivgUm39P5nxWvOa/RSRawM8D/olZ ejxhQw83Ch1sNH773N5te+xG7gX21sO3RPcs4CCXiAfI7zv8bJR8qxr9K8neA+95JHDX7Fku PXhxSjXjjcCjZEhlRk8DRFaeUhO4nlnqOdQbxzcjPbLQeQEaYFTV1Jc1e5QyBCvGqqD+KEoG 5CDpRb7VrPODUXS51hYiYVGvVppw3He76KE2M/6MAtTcTDcc18YOR4THgTePSgfhblRtLS1F sXskuw1ajUanXVtf26iy9QbTVdTcO4sThuVaWpw7C7CB8YU6+MZalsbggOa6gXOlwVsgggtG hZVvQ6ziWFhOAgHMZANwpgPiQT3t1yUyDocrkFWqcmEz1gJhuyI+FmSsASr47+mI5WXOZvRh Mo6ZPVnmYY3NLsH1kqp/Hy5JRV/4uVsq+i/p7bVLM17wO1/fhhLqM0QVq/2wqkn4XVb8Xk41 GPnawfyX9aLv/NkACUQaU6IavPYafoeIa3VrrTX+bh2/QwXc2np9ox0C2TBAVg2QDQWyXmtt CJANeWOjU9/cCIFsGiBdAwS/wzOmtVlvtwXIpgDZ3Ky3OEueA2WtaaCs6XfrTYHS7tTbMp+N JkNptbr1VqcZQmkZKOsGip537fV6pylQWjzaVqdVb62FaFlrGygbBkpboECLzqpAaQuUtU69 tZmbUcdA2TRQ8Dv6162vCl42OgJlswu4WguhrCqUVtNAWRUoq516V2e0ylDabSzJvB5CwZVp IdZqrbZC6QqUbqvelYXe6GpvEr7rwlgTGJ1aS60D62sKY7O+thbonRz+YkrVeJXrKX5EEmeo DdvR3TnqFuP9Hvq8k8IWzlHKGUVd+VpoyyEtu22tFljf8oxgMcbg7HhM0O7+Hck3uZfiMKdd sNuj8FfrT+qxhJx3qdlDzD1bsldwjTr1VVrjNj3fpKdt2ELdTk4nYfYQU0qrZaCswirTb+2W gdLtAME1VzdCKGYPMXtqyV6Bz1q3vkm7mTgDDRIAbMLmXG+HUMwe4gG0OgbK5nq91cYptTsK BQDANJubuRmtyqy6NeqXyJd/awMv2qStvWqm2gTQa63V1RCK7KFovUaYbHUNlE3gT138td1V KACgW98A2CGUNcENdEzTx7+JV8GurXdoGxOvw6cbCLnVbm/ksLvOUFrwmF5eVyidjW6922J2 x1CwPXS2BrBDKBuM4RasIE1/Q74DltCpr9NJQCgGtGN74E+r3fUcdjcZClBTh1m+QFlfg26b BLm9yVCwPcwS+MaGK1HfPY3sTBdAVRWTN58n0RFQyUQxTjTjOH/cCIjkAyoZBhNxcxETQSPf mdp3XSV0sWpcxUbot8AnBD77wM7+TgwqipSB0GenTINqLKX6h/egWFWFZobWascsv36NdVng gzeGdHpxWdy45NNqtuhT1Aj2EfSIgjB+Np0HLY5u/cQu9VPUCvdiXQQOKwhEOMvmJ/eIoy3r bwOx2t7gnhysMk4/eYpULad1f/L1F8ucWeQyFrjZqeeaa8Nh5x/n9pU5sbZ0Q95CL4hMzXQa K8abmxMMstO266kjZSEbtKNyanu4PW2s1XGtKLsmu/poeWdHD4D5dmwgm2d05oAnzsg6wBSo 9j3XEcD1uHcFjueediBq1jvkeBlGYFU4xk4r7HXrXkiW+E0RpzSO9I7nMof0k+B1M/JQ5ghY +ux1PI7Jz5PVGzXJouIqm32VBpy0DnuB8RfgciYKPX3Kp+T+/hT+bzKkGC2Qow+/kvTDmD+0 PxHHHtd6j2cGp1FxSNhdkIBG2JWg4CSgjSJ6jCBi0cNyQ3wf1M3USdPqB6AWOuyT/Rq1y9NM svr4q9y2q0whXO8Tx4p5QVk6xppIZgTzclxeZR5W9zTxsjQV4qQoW44cp+Zk5DCEojOV7Lwl 5t1IzrTuo+jICPseM8IgOHqj8Hxae0SFiWh6xiDizrMDbdeohHRWZMQxNOg6hqg2Bzd1Ek9y eqaiT6UZPUGHMNSY1qDXJ9FMs5w6pYl8EG3UUJasrLT1GlStLXTceI2aVd7KlGwWnYgXA9HO IXwjqmANyjX4V2z8a63TeiVkyHLRTauFpIB4B7F+NuIrHaNfF05Z2NnGvM7Ij6LV2eDuSntb z/Xm6HbzkI1Sz1pa/IgwDdt0faTzHMNJBeVGhiHLTScen3W0slZrKJdvqs6dP7TcHVl8eLn+ 5+Tqj8WlBsmYa6iTdwkGi/VyN1vlXFPypxlQ6IRqvG2iLEpJg4PTCsXZVoAQivTiyHTOv2GU sQHGAZyciQh4OvJdeIXnHDpjZQBaHJzW9iqJR3a9JKnMKC1h0hJvhIQFy1ExzkQ4SPhCc35V A+sT2u/QAuWESEgYkmvjyXO6Ll0MHkXf7e+d1KK/kHVCaGXf0QCTxL2Olv11EkzzjMQAer53 rJACwaRuQ0YruDs67RyUVYWys797IFBI1REMhi/vFbwJtDar9yfQfpkUqeZToXkBC1utRh8i 5jSPfFanoobzZQHzMJuW9w/FuYgFSB0UMETlETDjGupdgWEVMe9mDbk8PN6sRfgi/A3CWqtF HsStNnkXt9iluLVKgSVw5hXAOaF0KTmBPVDNdVDiNKElBWAqzfp6dYu0eDyXAt6qu6nILaWQ FVZm8D6fRZmPishcVY82ZF7BhzsGVhJ3ROECllzXi5bBZ2GhWOTx09wocLvBMFrFg8hx+Xvu /sS9e/mOtC7fWazXWb5/uZhkZ9F7XhIoO7AAntAD3uUr4q+EAy2UauYOrgQrwb1VpTVmW5TP nzxeyKLoEBAb8C2Y4lVt5DPOaPCKu/COP5c51lzpXvrVPtBmwxdZTWTSKco2brP/ppxsjXNu 9qfjyaVcbsZSTrKvF2P1i3VitjyhWJ3tSKaYSG0KkyI89AOZaIZb+NiEn9Qp+Z6pTdjNeIqJ lEVJz2FWkl2LoXTa32MIOFd2Gd5qwvTcJMmEKYlFxaYuvi5Liud8WlG4r7F3Jqd/a/iILEvK LjnY6fyeAkLM9PROLlBM9FHfFkrNY5bFNRewybesIzdJsnGCMMh5BatoGj+QSxnLX9gvBQlO THprk4LNFj/yHBCWotLiR1pY1c9fjMH9pl6N29obYs0Veyi5KlccFfcYP9cvv5Z5hU8ooXJl P7m6Tob1nwbv4RRfX+dAdCfkv/1OvEMpJIm96a9wiJQB06SY5+zMlHpqQjoYFVhBDE5hUxIp o78o1jh2y7y65SI4HtwhEhN5bCr/IBi7Sn7Kfc1sC71yyocR52E5s6Oiih9ZYhLCXuE9HTPa ae1d3aRyGLpuYT2TVF8Tjt+bIHbfGV6jMA06T1trNDgYHmFGBJypoHpgI37l+uoyqYYph+yA 4IhAuqZpmMUNqmYGExsuKDcCk+SLjICj5EbfJ4sFwLsUx2VNsoXSCHAG8oe50QQ+NlU6kTZw 0oz8wrxhfZupU+UUPfcLRz7NaMznl1x/+TLG/jWbVx8DWQtySCMcVcdQi756hdAUuUJZQsmC OnUvKR5lezC1iVmWJfYN3Yw5Zsrs8xqccZPox3/8ZEJxUT3S8ZKTm/XBU4NmUAlDW/DENBmn aqztmo6zBL16XrDtd+Kna5ZDSNYs4SkShuiAghHxvZWwTV/jrfTqesKJ6v1F4AJBt5zWNaPk cD+y2dp15mGq7L3npNjiH8sFI0bCcGHStltnSLJNuX/VF2gSAh2PEQcQnZV0TF6WN3wznY6G 0/NfbrkIgUgbnSABLW0nDJP1l5sOpSp+KenlqaLAORVRqgWIUAxDl3yz1UwwklIKR+ZMyxjt Rdq01QJoLDofu50mrpMpE5UoLxKsQi7RPpilgp2GgYWcXxbuiSyJx+eXucXPSpIJyoxpWJpk HTdP/B5hXTH9ab5z1trCgY111HnFJ/GFhoYjjFw2eh6fOw6yjaCch/LKCItzS+0Kq2goqO/t QNgSXzw9RIRGxZU4Y9ywEsuENE/SNEqHmPjzBA7o9+kA2ShVl6qTaiUbwDqxDEKVq6hkNPZJ C28H7lYJnIyBkjibM+nVJC2Nev05odaosqbzczqqo4INjyWgx4lhaymeomP05E9N4m6HlQSb EhMX4YnECRdIdhQiJ2KRA07QEFWWh/Gvt/wnoH25+kg0/DF/5yYFwCkzT6LCiNNRL9e5oS8y PWnmFIbk0LPuXTfZE+blJCZAjiujXha0J5FDsWomZaRE7oN8ET2VF6qdpioaSS0kvkcIk1J2 VLVmh4Qy+ZtNJQNA7dhEgjhoMOY1BGFKzMtg4xFHyQU2u5plher2a9PPYzDmYDTFnUErf5Sj iIxd0/HFcTpkocZZwWWOi4IDh3EZipdUHBXZKm1uoKoUqHI0yS2jVLPLbEUKTOGB4lNKXAcX GXjDBewortvUd71T1eeabDzCiyKTvnuEIg7HsxmHeGVtvIg0J9xiyQjtwstFpxiwYxOWLOPJ k1yN+REIS5w6dHqthCfhY0xw9HwBrMA2h12coWTjcEQ9xhz5grS+JNCMUpnTDZloaMs4wo5h 1nrULSMrwiksNzQFNIas9kxOk3AtzzhwJ4vRvkS0YpI1C9M8S1H6Sm4SnQCxTqR1/lK37P0E v4rIe9+Jmr2KwbQ3MFuZnCe16Hkj2m7UouXt6JWtgIYI2wkSu70CGf9qarQKR0BFo16MJUvJ TgSk9tpkmjVkvQcw4ASY0FF2FPcGRt+9O4I9n1BumWO4kSbkVw9Tbteiv6dDuDdGq81adMD+ 9pu16Pq6EbWamxv1VqspuVXwCobXs7/B+Pm2plN5MxpgnldA9LYX53lsM3U/d+J5nZsuTGNv d3c3OsFE3/G5XONG7vLhqZpiBPXfMVFl26ZdOEgbqCnFkXY66/XOakfG2XkXvYRLM0o/f2vU 9xssgWwDAwCR6xX8+dP+3jNzXY6tMoTqKltPBluAEoXOyfWjhw/hv43ptDFKJg+vp2cPkR4p ydHDXwfXDwHiQx7B6rwRvPxp7/WdRgCbEmuC1h80Jmz85vEAHq8b8aAB/L0BFEKDuhhNZRjd d9Hx+eUNHGa/1qLdRnQsA/keztwBmpWeNaLll+zRIZWX4lHKpbY4m58OxMhBy7h6V0DEO69Q hd2JKq/iMZDK5tpqVahmba3eWtuUtVgD2gfuen4JdHVBne/D4X6DeFjeNY4lJk7Y5uZlz4hl h2a0106ntlqLtq9BeMFN1+RuV1c366td7La81DYX1NLKeoWRQu9Tsn+Tjivp2e04tvuPtWqO Mxl2wpRO2qzRLanEp9duKSW1JmF1EJS5UoqiYmEHa/JiTWISkNk/gS5LqHiZcJ1KysDcwOqD jgYHa0tiDmEdDt8aLuk8J7MinB1nVF7YqPkwVJfoCZB7PRA3HtZesMWP6mReJToDiVoWJeWe KHgC7QlXvc6M2naQecolFAhhDUx5NbYlsL5y0NNrkngO06oVl59qULU61t8YtVDnXc1VWMI4 /QLpNG63YDqfvTvRMB5dTPEEMHofE7gcO0E7RuUQnOp+ucaUKjjZ3erkg/91ODijPOjYF8uT C7ASbPUQJlNQpJ0lbTxpr+LxL1l0PpioKtJVAsZjXVzUBBikDsaMQFTLUMrC9Aa2v6zv60vY Ut/Hk1+RPDjpkSicnDJ7sAx/gxWs76fTa+FyhA3gA+SIQ1wObtrpRHOQsz5Qy686cqZRdnmF +RDISxDQRnCCAZGNs/rr5HKcpRT6gtV6aFiBwhNPcErnffJq39ZhvS8h4b7zF2/Csk6B46B2 aJvrZNAC7Dei1yg8RzJswucQ/cFGcIKTWQ9EerratJud6BjvrYj4C3SVi6Pt96xRfJWMhik6 CgGL39mONleb7a4sMNwzHkWV1Va3GnXa7XqzBWAq269IECS78IvtHx9FkfNKa71DDse7r2Ct H0WPLy5B9vzPmEfVgB3wlED/vylc6VlgO9Pk+07hxtTXVftaQS42zsyQipBEmGxhaEpU5+jt MZ6F/xkcfk81tTdSopDh46sYf8Jwp1ejQQOGgmOit7m4WG8wSUnxyjxtIpqQkiGWjC9ctiIk 6eCKKfsxlt1OLnSc4+uBjHHm536Im5J6/sefn3+rTy/FdCSnZ9PBEAjpIR4XeGbUsXh2lyTR cf8c5fvG5MPkE/tAl+e1tdX/EHfr4Odac73V/Y9Wu9PsrnaBweB77eZaC37e60xLPlNU0kCX mMh71nvznoeT+zf5MAM4SCY3KTC7H+A/KEa9HCOTXPTzumHOmSOUXzP23dwRTviI7ocz2hed TDtw1sMV8PbRIumnCj7lXjx0ZcJC9Kbcr8egtQbvaqOztHQMwtyUZEzSTLxKrlLRMaPuBP5S oTTz0oLrXRyLz49HVGb36gqr2902nLak2dX8XZp7IB7ZVqhm7qFNXDKkw9Kgxhb9skDumYqY yVK7jgfd60ZSBhMEl73d45fktv3I6MbpK1RYY8c2SYko7kmWFtkZ+8TBDFGLKt7Nr1UMPMJ8 FaRFn0iZF0msViBEwkBgDANVZKB/LVeRqZxXaZXyAgv1hfpivlcBsAs42sQeTAlZ1MGEUJEE khznFCa71PV0fI2J6fF9tU9jnesL8rY6H045Fz8qDoZi/6UIb7oFIQCV8DOp8QFXmuuUb4L8 JkrvA2lbU4qwFmGW+HXKI0KEaF5ZB0Z/j+X+hIm7avI4NsY1zG2EGjqUtLV4NWVPzxkGjFaW 8pcN0TfzlpVu41/UEWrb1IvVqh6oYJ5EXv3pAc9XxW5fycB3V0dIVsGGNH5qv3lzRLnyHucu KpJFOnt4DfcUhZzxbeVX+LuOtZU/NC4nV8OnMOTtM0xafz6xe8/fs+ylwOrzLCP9bImDAqfj z4z5ajLQaxYN+AYWDsRC8uEkPgGbbKjb1jonENUkqiu+PR8Ozt2L/fllcv6LZoXiHPd4SZIU g86lnsFafwa1//MQWHug9wPRLDg5DynR1XTiSL1YUAzawnXeJH3GetJ8n8+rKTJ/WhaOucqS BTDuDTjuzdQPQoZ1jpYZtuWwM4KXKP5+Egq6CQD8A4QW5wUy8fJ7Uv4kOGFdNTql0jUik6Ly yOXIWkKNG3f/mOyiXOVQOM7nAWrTsHghY2BSpKdYHFDHAOo0omPgP580Hg/QqutZdmdoDqAu CgzqfMJKZyraxMm2bIVe2oezAGGgqHBDYoDGNiacLJs5SgbULqsefAdkayRtu6zW8N0BwbBe OELKwmMRQF0DCJb/FavpPwWUlwYYgbUMOImGoqNqjPgbzwIdhXHCDAzAcWB9f5AMCxa7AFAY /MyA2ncmzmhTAHVcU8sn7BIDaLVUY7zYgEymgm5eXXeXcVlAa3kF0acBWgdA19dYIO3Do5we 5Vs2KuhpWdBDZCJlN1xAx1yZY+doh+MEFhlRa2kp4NjCxS3nVZkfDzcV/4o1RoPM8XK04oO0 nyFEeLEYD6I9ivFKcF6intp5/YaqzdfEg4p92lHBXePbh/zhETMxQJBNQdYhO6U4vVwmmuSN PcjY2kcSHAuDW95gdsizmYfOUqL5K+aJSCq4Crr6XCN6SFbwM1mgJim9QqXs+bm6xuLAq1wc k/wuYXQsXDhQ/RlpXA8pd22JQ0pxhgfbFZV5oHRoeAZw0KUHAfN+xBdJGSZALlErDF6xztWF c+wDYS/hiE2jU/RaoiKIgIA3o8EHnBj6GgR41OUXOwRnSRJjE8p55ACl/nXkyZdkflZJMfPj 7I1SXzw/60qZBYJZnipgmtaHNtKS6GSUOUsmE63eSo66CnDZgwJLhkXE86RyltxR4PPBsvBX sDzXSMYDdM7tjxMQq7fCHVMkgbsXc9e51/GZ8Lp3JXaXB0kkDXnvk7hJ4rdjaMkCMGzX0sWk VLS06OEgkg+UJ+2CevPX2sBu3KMM3L5nGZi/OFFToqlpbYKJC7ikrcXNXjJGYW1W87XY5php CMuIJmnIQos3GHcXDzHzLg+rwhl8xnGGpK3XRUo6dpPAUsX+8uneK9xvLnDjJSeWqmIx22Kp 6MAwNXX67HKLSHOcvjn3nhipBJCDCLHgot6A6FUWAPD20GfVvDwo1TqUZixSdhnRemuKn3hj pQpW7MUMF8NzirG4GNMF3UR0CFe4crwuh8n7ZCiViVgmZx4PrPtqQBoIJ6m6n67ZYFXvHO5A /cHZrOuFFnR27Ha4gQCqiLqCHPa0QhcdL5IEl5ogB6J8UX5ovMCwURNkk6aMgJMiVZwbt8AH VD+mmAYF5J7kEauc0GB7IbYr7yino1j9H5R8K1jD75r1VQRrFF8lehFi9alGAaA+Rz0dq4rn 1aJgnzcjdlFT1z0Td9wzldpnRrGYWtDKDSX6xLdVE35ozC6bNZV8bESUt+5ZEOOw5Y0lHIkw XyV+6CzzenM6m92N1bREURAkkVAmCMQQp7oPwySKAg8UP6OethgnsG3i0US3Oq+ILtNdLry6 ikibj6INSZjGyc9Qr4yKStiHJmEa6pWjCvlz49+jKAWKm1Q1RL7ygpTRISOrSYkJ8nb/AEQK O4j7qlHyh8hksZeEbJmQoW4rS9tUrsKpK0G1LdRHX5cO+dhGo0quF0yFRkvOTcVrh1qL20Ms pesZh3Pv+g6vGXOtHPbbHaWuAVlAiMDmsmByIxQY1grQKr45cDSffa1dM34pyO/J0zkdphe3 5AfJvRq9LlWp0osPeZPgS+MEwwom5Gms0qskr+F2aZSgZn8UG4+If04H48QovElGkjC5FMuL AIrqDqleY8Y89GclMmRv9L9bcwdH0rNvhFUDF+5i9ZTIJrfkK3Nfwk7nnoWdUt3OEmt+irU1 SkjivgtXEjwiM8s8z9IP5IBFdOFKQpSj2P75G/17XK+zaQU9UZEGz2IQEjjfN4icZOJwc7Ez kPB8zTg5AmyIrZkjKM3G/JuP8N9mtMn3HXN4HJ4H+Qoy/PYzcu12sjTSDpbqUGOtdiPF0pYx lpyispZr3sabYAVTiizgmvETSj3jsDqbSd6wML0N0WuG3jVU3dQ34bqWmHqMjnoZCdc/5OS/ WABRyd1PLCnBJ+RofJNw/I9gIgtSUhYA6A0ucLojEa/6E6rmRX7tDMmPzymFc+ZDaZSS6I1Z JruBTa1lRpqme0eYTVM/p6gGZI0LAdgFEsFwrJ0kvXAP0MelvfW17mqn3Wr+VvieK24bE569 dIjeinz7QOQzpRc5qg/Di/BkKp4mua85RybXVhrAJK1PMWodplc5OgwuSOpspklHEHwdfdIv 9fKNYOF2QVKH2RY/hDuhZk9LSqrPxZqupsPJAI8E3lRoFNdsUvSII++U4kRwKR4bBRTZbehM qGB5ESqHLVRU/E/RR57DnhX3Rpp4kQZFT0EepKLhMqNuu8lBsinvxjBlieasdUvOWUIoohx0 psDMd7+xX0UJCRW0jP7L/OJ8abjgb0VfrnD1ihyGnkTt6ENQr2UlIim74N2N+zsQV+//9h+a FmxkOwtDdH9yigngDQpLeODvy1ek+s+WsWaod7FXbgX3nKpvVoRmVFCBm0YDP7GA0LFf41aC lgWO9KlxbZK3DU9DidsSHaQCgwkos9LaTE4mPNdPg+OQanpCUKCKyfYmFSLyBhRF2K4zq8s4 rBdoNI05+WCRf84G2Hvegn/t33ZeRb+92H/JtPrqZO8VV+z77ccX+78dHgMNV5B26/Wn1U/p T28Lg34EnTRe7P54crSNy1ktGv68Mgy+3PGjKf3wo1f6YTmxlp9leDp7Cgv0GU7iYBuQFM5h LpyiOcDojGOFuafXKE1U3cSL90rncIc+wznsHL56tXtw8inTCCYgO5u0Cvc69Pygv8OLTRnx uKQB77XWot+K3po/hmB+uRosd53TindY5UqjRJzymRI032GLhRI4TLnTdv7eO977SbbyXaDe 3xnT/SIa5nm2Yrfe3/NWVNl7jtKYgd2qus/buedB8rETSmFFIj2fAZgsWrKsIPgnmJW00vzQ 6tein5ud9WqNoD6JWp1NDxC8s3EG77RbnSpFfg961O+ttU7EKGZzYR1Xf+DmmAJeXXHzsHCM Xjhk1CUz9EFBtKMoQtXIpd1jnNArD9CTqFlfl5Sx7D9G76AgAuIZ1pdh4F4CF/PJd+mkHSEp e4SWF5DorjjMe5rljUCEBnKw05YqxmPy7GGWUEkUF0PAJqLKi/34ZVaAFRjmhdFO9QbsTkcq c9Rkwp9TJ6VtaRpQvtlAVydwmBU9xN1NrKroIe4EPgWLniJDoOOl6CFyCuXbRc+Ri+hSFT1f m/N83X3uvbDX59lKqdSaJdpBZqO4to939vbIbqDuqEEhO1QiXht5qWdUhry6QYwwXmKwlllA EuQEJ9HnlDbBmnonmgLDVJrEHD1AIiTGicej+YzSUZ1HbFSOmXWXHMktmLIWYE6wdHoG886v OSaNRG9IyuRj82qcDaj6GseF4e1Gg9BsbXcPjFFsurYJCf7PzgcDNsdQ8J2FXHOu4QLGVbqj tQLtSLx0qEC+TNMsUd30OL3GzEQmbsoD9ANewYZw+RtzsmJRs6gNw88MMRVDPyyXB4TUm3TT 1+rCboQaK2JUwk01HNGDAJh9TyxxolgWC4430UJQHhx0BMCCZwKL1TITdp6wCU3EaEUhikNR CmQhHPEKUG1mI79TSErRnRKLLKKKVGJpcmwNjDnBN8y7WaKdXNC5eEO8xTB0vViFg6Uop5uU b+i5O6WJy2bZgYhtOPRgeK+5Y+cCc4hIpAvH4VnH5NPTWxwrYwZZDeqlOY83b3HrWAddsb39 OkwLjDbVVbEioLv1xWUkkJxDgW5mcc5OwB+M7HQPWILYeJdfQb6l6BIanuXcKzxWUQvtxl4I Yeze3hLN035fUtbaF5GyLCrormOIeRTlryulZGxvAZxMnJPfcnYSJAdqTPY4p9Tc3vGhB2Rj o7tZBxlrf/tk76Deqjrcegu1bqEXlIT5ejB2n+0839sRQ6q6Lbs21MBOyucb/uqTDxsxjU+/ TSIHg45kgD5gOQjDE8NzqCc0mEwfqKpL3CRXSU9yDYcHWG+AQdeoTcNXQZxChfo4wUK1Pcma MgihFoponLKDNJiu3Zk6pfMPs12MMrbRM4I8OIC8c8YF6/iwjSYbIjNmIdH084cXOUPFnpM9 meRiSTwgS0dK0ZjA9AjiVjicXJ1QaY/AswnGBNFsyUVLnecmfnU9XqhRaodcwOn1Em2ZfXD9 jdzLcSgOWUGDhCX7lrBUkyZ3S3IEoj+CP0LXZeRyyqlHR9n0ygkDMHCDneZPBgh4xk6jIhdo JsISzU6ZrYDpcc1JLhygmYGgVR+TwthtUWk1Vb1bDXB6pBXmUYznNNmy5xCv7susqKq8SnuW o+FXBVI/JpDLjP1DEnHB705LSvditP9Mqz5NFe1LwS81Jv8d8fkjbutbN/jDWX8ykYaazUf0 /+jlq5Na9LcY1wtzKW+uN7EGsS2KkSsITUWSYxTtUPYeItNDAnh1XH9+eOx41ihHJCjToGb3 MEWboWtnsGlScEpoVN8rTHQQcKGeuPFdJbpbSVUqS8RbQxkl4QoTejqWFf6490XKb0X4ZRhP TIZntLlTap4J7O/c9UJds1xC+fHFflRJfsSDG66FF7lrId7v8V4oeceMd5fjhKUWXneMgVzh hr3Y5Axy1a7wpbnK3joTt8ss4FwlV06cBNoK6kFWxh6QwgdMw+PlMQtbOwSIDBrTvqroXtzR akFHfXSZ85ratkB0lUNzDh8T1c1XSqAXM246z9dJjG6lqJ6k6S/R9TA+T0zIY3xrE2CS264k hBtQ3iuqbYpsKKA2tcqzYI6XK3IDUp5p/P3Ug1GUPnFwRuSrld6PWLf+BcU6+mCpkhfbJzxr Rn6FGUgN1vNhuxYdnDz8YTAqSMeP+st6tH01uIjzj5BI//7qGPNHRkATI/i9AAAW3UBmmX+y Su0f7rw6zj/rYrfAGwbRyWHBY6zG9d3rF8fenHQuBYPAogWv4nNUAGUF6fQ34PFPdabm/NNN eLrz+uGr3JMWYvbk8PVxvd3MP0TMHZwEYywaXQsR+f+eF8yzhcjbPk/Ho+ho73gn/wa6ItSj 6YiS+7qsEK0kwgvh11wVkz3PRmNVPd4Z6mem06uRB8e5JjVCxyzJF+0pNenyWYEf9ZDYRC6i +F901NjhmEg32ZgTE5nmRcrpKDi71FzeQ+fDdMxX1jTizkv4oqsqRUGp02lu2iBq8aLXhMgb FHy01mjnRKyTN/UTm5yId+vfG6ttPOwRSZcTCme9ublpDLK0wXn4/As9OibgiHEUJry1QSi+ SK/hIIf2aIhsDCbThibyCzQhI5LJHF8sHhiNxLWrsP2gskcKNfx91tKQjC250L3LTcVdgSqr 5/JCPwhj02Eatf+r0274in4/jssdHnfkEOyZJNKWi6pnBXTuqLkqOKzQkEvWJJ3AqIXIrVmR XXk987UFYu3Y2fSMtQM1tk3rrQ4YdXCo37kCvWeWgs9vx3st+Nf+jQvSk6Uq8sygOhhGMRqt Pn8EFgJ0T6QPQzAZtGLb597zGh7w6JeGPtQ3qWiHhxRU4og9hHXSwV2N4O46gu1Nu7kgjZNt VJJfh6SBAZEka4jHyQVG8t+66HDtP9kWyBIJJabF2g+XgyvSEDiziG7TKYwxu5SgZ2RoRYB4 HogMFFZdownrFqZoshcAJwWuCQKFgutD2ePR/YkVG19QrECKsL9b6M/DK4OpJ1rP/+692Pyw CvfRb7e/reLv6034/TX+vn2N2BMncZQiHecLZ0y4G8oOLm9zwG794OovnQK25Fst+bezgDe1 i5zkI7+WQ4nnufics4qFs+ehPbHmUgOILZhOkI5H9hMklsxlIdU6ol7qfOET1WTI4dwSj54P uuhyOVQxxmx+IuZWUIbwjh+UC5uqIubujEdOOEkdWN7YRHd66C68zs8uf8GJDxA/jBbEBaJG UlbxxzChUZSMxxTHqBYm1AKR5q8vty8y6FLGDcS8hSEVT4jZU8+S4l00wg9/pPpTpBOtWe0P Diew91EtPlK5p2S7wLiRXwbXlHbaE5zMkvWNi6o7JWOJmtgKBDomq8ssWFJ36cQyvuUH+9VC KwqSFBlJ1GKE83KlS7K8sKlFyViMUel0Aud6raRkC3odWiizFhp364wFtEAMc5VDH415SFNq aeIgTHp6TroqUynRkxA1syT7o2GdBWYKpDDh2gqsZ8E8KezYaWyLrvbLLWllyGqI1V06hel2 l938sa85gzIyn3q0QdWwWHtWFy9kVPBJqJp2GUQA1TGZ3iRqPYr28Q5uC4EdpI3WMghxRr33 qLW5sW7cLjlxj6v7w+ae7o82M9fCm8IVH/8CZK27ZWLpZGffP6k9Y/Js+mB8DYtVfoC4e8oj aDwozGVbktfFpP1Vqdzk1y0Vtk3+WzlPa9F+43WjtnyXdInL95CBt5vLwJtPuVubkV9XR7BI mt21d9FxPL4B6sf8zn/HnMg7dAsyGUVL7lVZ9H4QRyduOd/9NP2l/uZ6uUZpuNzAaGY/nAG3 VdngbLutZnOj3mq2OvcZurp5/0LM23VJRYzu/sAaf2g8JzRhAoF4iPySF17S+m50o9c70UkC U/lbOh3DeA1J4KRbMOeOZnveeOdQBsAfxnBK4So1Yl6oMfqUpX2glxg32MPz8fnp+w7mxTNA xZ7o2FfxLoLBc1yb6c98wv8L8wnXTCoBdoHJxGGBkzmIF4yQAyovnPRQDcrz/jtm5s1lQPUS 9AYByZx8Vy7cNhmqqYtz54y8krUU2392St6CzCZ/pr5l8vsz9W2Q+vZ+8ts27/k4u0tKHZO9 kUyjbtKLfNpxaufVy5GoU+KjqvDz8/kZe05xjpyzmN0bxPJ+LkF5sIoL0hUVauQqHWwMDIZN gitmVQchNDU6WwpkuxL7D+ue8NaDTmLsQtWHcVAyF4nx3r6IB1IfaMFKeMrLysvL+SPNiirM lRWW+wGLnpiVwABnN8MDq77YBktrpvkfnVI/6URLQTIXvxxcS1XInFk8nkgqTFOEiyzHhCYn 35BXLYU9J+ggzNTGZqI+cXx2BAjH6ULU7DZkSHMjTrJk2HeW20vpQitvsifmJ1GzQL1Lp8my qtV5rsgzEG/XGZxORLd4ZmV4mKkPQYggkyLTRAi5RnWDsHKPA9cPZ0T3aF54iYOzT/maLWn3 y5JdmS3teJ3xGxQR7gXfSiodpOZwu+sAEGyl5H5QbbDlgiJOjWWENFXGpkB0QjUN+lyuyD+6 q2a47iAHhhC2D473oh0vnYjmTW3A7XYEz4BdsUIZFRhUjRArSsXZgDVblHJHQ2BR9zPA3MGq e/qGfzwbTCijxfbBc/Eow2w7/Oy//FdIVZiBAFQ/PMq9+/Sp9y6nZoXd1Z/YV3n7xtewoyU/ VlDAeDoS2emfU0zNikmH4kwqd7oQtYoSKj58CHA5r2BWG0280jfevV/xj/30gpb94PAkN4eV FfqxPFpZWcZdNZZEcQjKRmvr280PBwcH+APlWdYKIWVdJh9ijeGsIJuPWmtVMqBMiI15wz2e 9rGkyr7R0mjFMjHsVYw6DcRcVCFav6GHDyKbffNoh00zIPuzHuUKCzxeoEbvwcOlALkEH+9a VGnqbbu79m7LgfpiGF88Mi7FXI2K0j6oAfGvcMKTbhgOpz7sgMTpBGtVGtCnxuT4JGq6XbyK f0kc6LJLcJowEwcaldG7gpdPDcwKfqcGuX8ZbAaT27o/IeW+U6bqV4gpOIV+sS58iIbKiHAV gfSF0bHwy8pK1Zkn8Gp4oeJNtxqNXD9AAvMLg/kFwGzAjxBIhHrFyjkwgVb4gHtofkh6Zxsb nXZzH9gAvAn7u1X13Q0/UiBKYXN+P3h9qfh3S4mjd9jUtrJvFZKUgf/RkpaF++a6h1rPGGsi kloOYNiEAFI2b9p/22w0QPqtt95JcmYQfwxXwjenBKeHzdnvHOEYP0A1k1AuLFXvR6/HSd3V 0efyhEQVuPN8m0lZPOQyVTLUJmOkSpvuwXWAM2VFWbPOQxh9S06CPU5lwYcqJSxpRG+QAag/ qGuEzTECXO/9LeeNG6pnXcED5JSr41b4R02MSdXoqyfR7uGLgHgYFmMMt2wF/tWioKlDFQ4Z ED1Cc4CrEjVCqLJGvGJalbAzp8/c9MrcwsyLqKuNHsAwa7QrYZxzGQwSKoz2v2Cj9OWzv+Xv bQehOLmv8jTs+hUEXK5azhZgeCVswe6kCg4NqXv0rgqbHAf5zuzjjWrRFmPKj0rm5GwxEIbo TZWRRJYr2FGzDp/KnbAvg3NWublPhEVUVXVGeW98v/2JxVfm1/+YfJi8z87gCv7JBUBm1/9o tVutVlj/o9VZ6/5Z/+N3+GxHL1CQcYpI7knAK/L910Os4HuCXpdkNVqa73vifoC6vTy9deez tPSSCobHxvUeO2TH5JE6xUk8QE386lEFgBcyqjE7oMyrS1rZHBVmGkKovjyxaMviiQ2CpBlJ 7OP2kOOTlibqoCrJJSi1UswZJ1Dsy35BK2x/OuR0uFMMttO0/jZRlvVzkMxceBmI39/We9MJ egFc4S3hHKYXD2+zgbmma8YNSaJPyuxadKlJjuA05uS7WJPijEoqZ8AQMlKVjG9R0zsdTjJW qV0PU1y4JZT/MTfaZTIdY77Sc9T/vs5lR4eBv/7+J4ndZTU9Gq+cxKyuMWKSpsNsCZVApmD8 +Riu8g4mgJGBfPAIj5ArDoeDxdxofh1VVh92qx7zXepLJkqnVjSfvaTZdkrfjTF5WvR2vdFo tdffeUGtS8P4LBlyfii7tDU39yFRjvMam8IbVAVjjFSH0WdUMSW2i4nERlPRKCDAwWQ8ONfk Z2x/JbWYMeICig85glW/qDEhvRwnCaqRb8cDrJeJWqDtbIBVXPEY5XINeFHlYg39JXs+5ZHQ am80Gu1u951o9aCxNXDgtdl0voRYJHVh2sekcleDzDh2O4leaZbkcsDrf5OOexJYhVS+hI7f eGuKRslFPCEvHW8nYvneS7jsanQwW1G09gkaZTBUEZcgvUGkS7KWmyT+ZWQKKXvojqXUcQ8V YucDVmH2ppR3k5aehsOFa95rQkhNpSSVhsXfgb13xPuRdRLji2SJQ5ElD+MHqkgfxBb7yPKI C6vqiEqRfDSGlBEMjTBUZQa9E2rKOcKNIbxItJZLcXSFliO6uxMpmQlL9OwImFG91YT9w3hU X3qDrCVrv0kjKuEEbcnOX0O/bVLS2L1ND+rom/repdvaUszKGI6nzTy3BpOxlLwT6mj+r6E3 9lFKdYi/P9zbqEXJ5LxRJSiqeKhndMcIWreb7TYM7ORFXRs1MEMWOsLYzKiVNzvH9fZDfKu1 RqPHL1bpi067yonHUh1tz7BKNF3jjcfUDvbOmzo/tMHQiC3impRRQG104jeBU6fKsRHKh7jf OP/A5BL28tI5F6caJNmjpTrdsoD2JxhFxbGRSlQGyqMldESvnGw/q9bQ8byy/wJ/6aA3NfyC btXHr7d3dim3OvTWELAXYyBrAzUdUpR3z4e7HlWe7e4DlA345RjBtqLK30/wFwD7AjtqrwH8 N9h3G97ePd6pagdnw/j8F9MD5mSHcxVxio46hdOAwR+82aeBrkEXq/hLBys77/XtWa6O4KoO 0tSFTP/oZY4kIbFGDu7wEjpKy1+1wyUONXKPgkhX5VfOA2h37JY9DlSS8N+1Z0KFkIIHE7IP qti+dBN2hCmwUdc3xZwYE3GdBa40zJRITIpi6ecW9adLRyLHJ0sBUcIGiGGqlwMtCmWpdJwM B6LRv8HzHw0EJtUyaY8peZvzgE8sDGyLRbzhwU/R0Y8OEfUL4trIS0jheLBKjgi41Q9vnRxd ck9nt2BrmaGTBVd6nA6XHO7pH1cAuoO6Ctmy6qGvqeHFL5HiJdmoVZ+SpSkeEvypRrrBA6pR fybkBZ3y6Am0bq0l2VrENGR3NTQhLDk1YQV4lkx8KGw+GCdL6ERwMSK6oNBTPYoM5oCsJpzo WM/f6P0AC1FnDxOyhMIuucOW5JyUsiu3yGWUzvElO7sx/AdWBJMrIZurMhZj2Bhim0fRl2Me MVYCRLcRr9sSmcyux+hpTQIkS72774WeR1w/2yCWo6sko4X4NCz9+Go/ikmzyVKGwZtdcugf T0ume9zGYrLT3MtMqBxUWUSpKqXwFndPboyaZUcT4ihL+c7hGJH87oAi4U12job60yH5z8IE l8IzOZMh+T4nOBwn8wgthjEgETEsubKYNJXDW1aMlNIpYJKE2oEIOtNrtC4yPfkCrPBbzEfH 3ozKdCx9YvGIKYismHCCESUoWhIUAfMiV+XcInGqaW8azkgAZYdEFEuus07wEpk+M/apjGaN ezBBgU8SBcH2GONjvDoBC2KEisyLbIzSt7juroQlgx9T7kQFBFoWdp9Eb5NrKjx2nDNqnqOI x0kkyHeqV3Oj0iWXIK+8nP1Ldu35ChmfGVKgnUTHErseM24smxY/22xJQk/Qx0EuZjWMbgCW Sdkib2gd1evTTGmgKaVwto2lyl7fjp/uW3YSxlP2LCm6GtqEGnovJDZGW5u6QxhZDMcXb2eV 6VDUQlYLt0MSz/DAOlF0oqcvBenocSaMUM7XkEaX0e0fNYbLnIAUT3/0HEa2Syd4HblEIvQI O3hACwOkAmI3VqbEt7GuXAIUMYjH4qS0dO45zTHhEJvCcxorkHhStopLmclA1KdTJx3hnSY/ DvEjdtzTrVzO0jew4AbsFL7YjqdAMHoHqYpg7lzbofF0XHiZIedyAKcJZ8P7DN/bxonjkydq iUFwsdFU+MQb6WoDO346+sW72Ygz4IvpGLF8RQkvnRVylpF19EvkjocU68pGuB5h4RpqlGOn hg0sFb5/bb2obTEOyYaNIsJZwibXcw4QfzMixn3JcWFXjgiXxX0ifCBmRkQ6HTujEc9J9RxY KrhMLS3tfgDmNmCzqU0YP56SQ8yVFjjIPO2UqlaMIED3HhmzUuYPSCF4Coe7pKYR1MP0Av/g fBdIgLUlPnopSzE6WSY2dLAmNUbx0dl/YxAKtaArFItQsttxj4BEeGViF65I+8OlMq5D57Lz +Do+Q/+iQWIu4ktmVfA+BRLqTppdoRJwPJ3ES/sozYuN6VHUbjbX6q/i23p748/C3/+en9n6 /8Goj0VjGuef1cds/T8mBu8E+v/W+nq3/af+/3f4PMRADlnkqF7HP9Cp1yp4gVHW8bGtf7NE lZtMCecdKuHcrQMz2HT8RvEtzKdn7MjEYXpu7Wrkm1Nk6Jj+L1chGXgOUmLjcgntcktsLJdo ZnY9ohNviF7t1wNNQSTjbyBfPCBHJiyIywKGTjSVqCt9N5Wj/4zy4PyiuSbjkcvV63U6nUCG FI7r4EOiYwEeeoUAIskbXYpha6J95sascMiSKzjdxnWOGXLU8c6wThFWpeoVu+MKdGY2PNMo tVM7bzC2/iJedtHyr+hB2rhcdr6ClyfjJMly3xK88EuaEnwJK2CN+ugXmKKpI8Pu2G+OLokU wkjXySw6fFGpcBpsMycqFx692D6KHtCv1eqWLi28eWUd/TT//BBhc/4P6ZtUDL/SA6KgX7G6 XE2W9KdTuADua+FjvpCeUamnGQDZSelmMOqlN88w8HEQqDHgmtfq1qSCOL7Famp0aKtnU3YQ syBY4UougGrQkLLTUfvBA6cbiWBADKIp+afdH18fHp0orp7BeqLn0ini8KrmjE9/rynl1KT0 4ikqXatLv57yn9eE0y0CbltvLfm2bFoMfrxFIvZEbNwCnNs7HWwtsaV7ztKKQwE6E2gSgydP dIF++03H/rb5Dr0oftrfe3b6992j473DA/zqNxsE73SNb1ZgONUK/pX2KzrVarUaWt9/UnCn u0dHh0dbZjREaN5QZN3c7ww0Z70eRxv2bfrmadTqFnR8fHK0u/3K7Rf7rD+9yi4i7WMrZ8kn VsyJ3G4SBWaCLMU3QSdQfypbAAZdod9OkZ6rTcfPAgAeIwM8PJZSiy5KHQjRr+f021bwPL2O /znFggbkxXbdrzbNGw8e2tm+2vWm+jEcJ+5PGib+oqOcO0avMYwQf1mkeybDJ9EMzlP9aXt/ /3BH9lVrRh6m4o/QXlEH1apLZzQSXfBq6ZBP4F6avEdeCSIYXB2VFT9SbpX0fh4tK2hGTH6a cBqhF5I7T9mHBi31p72r+AMmw26vr2288Z7cUMj3E49RuI9p+z2JWm+ix49LX5J9FCk7cZ+N 8A5EnpXut3TrMt8aDB1+v7X0UU8G8eDhmdERKCHyVJAOVQaopUEPbDbj8OnD+V56yQdaL81u xu7wH+TSbxq50gLrn6jPTN4VkCph0JeNS/KO3etHz97s7T9/sffj7nPKV83JIMRAMQB+io7N DBROBUrPh9K247BqHP5Zmc+J6ibocIfOcVI2TEcE19rMbec2Eic+0oNRIQs1GLISIp//hZCA iQDpTtj+ns+kmsQSJh+4cJm4vMJFcTJEe3VyPjXO8W49JgcR4nLIN3qEZfR4aEKLSbfgXJmd sASpgyb14BwckXlxML7gsaHBV/QFDLGOCgE+TYvlEd6Q1aW559a/QADqwzI68zE0C3dpPA55 HNarUx4ROh8AdUK3tegB0ib8ln+FRvW2u7qqrszABokohN4uQWzAJJEy80FfFpm1ULmpky6k 6h4RPL5qkUdgdgtM78xs3dzocZ86zoAwMlh31OM8lF3HxgLjKxchRLuF8SMOmfj946i1ulrV 7Q4Qsrfw9coK+s5ulLRod9dKWmyWtdholrRYL22xMX9UwrJoTey3vLzwPWNKvxb+6QxRKYx9 JPd3D45rbpc1HEQt+qaCcKr4C7nMm3fQQF31V8IwuzuuAZrNCyfbtQ2EWMvm1S2b1/O945Nw YpgI5U7zSplB/veUjMXn3tTMXmuqgPEX8uSGdl85HAda/CUy4UV8dWE+DRcaDMHpYwu/gRI/ D5zo/4ms71bw0F9ePU4BZ9Iqt9flsUUfnWfoOjFOMyngbgT9SvWR3HKj/TRWZo+7lbiTe7XV eyHOVwrX7x9uP4dvfqa+AZf/kl/xg7eQJyI04IKcAqPfcp5j0Il5gfIYhG/ILnBADEbucznC XQjBC+mwRy8QUvAv96kgSJ4SY5KnH5WIQVxEzBwnExcfnDQKbVsOMguwc7R7fHJ4tFuGIB81 MJJrf/oBZohA+gVvCGZ0/5RAoBcQY/4LBjP4NECQgxl4OgtBO5h6P+KYdbp9Ygr98/PpFeZF 4DuEImXvYO/k2d7JcRlWZCzNgpVqlnW/nWXTsVhfyGDGo8C7ssn4SgKT+R79JBM0wXCypF6C lmuNLx+ZOxAIhM/evGCR2dsLvHUa7sReg6hdNik8GZlaYRZV75FDyIMRXDFPMZYdeBfxsK3g xTlwnE2jd738CzA3em4mVvTSRUo1T/qnWF8hCd/46Pz9sWRNXmI6F7Zcpgbx6qQS0AfVPxOc 57Fs1Fw270/fs7gycGepg1V59o+T0k3IqxZylXo9x0ZWcuFEFZJYMMAALibu7jAku4KH+gI0 O7F+Iuq4NGIIog0K8NXQ7IaEAgRPaZ9G5HXgppxBvHBFXnbMcYk7j2hTtVER7WHyYHf3OW3c UQkqZX5nrLEwyKpCg2pAQHZVytDjBE9grPPIlNcsQAeGfTym8EFnuP5QK3Y4tJrfwDd8o6TR 1aNWVfvF9Pjan/FYmMHQnh8dvp6JF+rw6dMn2FWOROpPfEyV44PGRRUSqJDK+2RkKhGhewR7 Yl7QU9l3xp3MRQtgfS77xcES7G9AjC0YcfhsLj8WpWR2jVXsXbZcwzuguXWJdZAv8aSR7vN1 FH3IDNFL6do+pomtzaFmjtt2mJ1H0keHh69msWwWUQpZrUo3jvoh5JJGwLF6jPCVQBkRnu86 DkAM/pOjgQLA8dVq8Qnw+zD4pSjUnFPw+wztuaPFFu00emJRPDszHWs094plSrTCdDQ1AfD4 HS98g0vD/nT6fPtkm6e7FKk+J6vxECn3D8Wg53IASgAwa+LhAK6qEr1SNXluXFMUnTRWzW5V +Zx0gaG4VMiuS+RWIbH7A75OZ9SdtAsaXXLqs/4AtTDOnmCa1mR6qficDyYSIGlqOXNypZFq d1Rrb3rm+U20CrRuPPHYIHdlqyPhzHtwwiAo0cuw21mqBdIQFeg1NGQUDlSBFMWYFyMKrxzO Cs3ozu2LZ/DQN25Qj3mMK+SyJZWhaSGghJ25UsqSGF9RLhhnaopDvw/XJ942E4tZbGuwMg90 t4jAMtQtETs9c05zTipaXFwcCu2/SZCAM3sEsdmnYJfkKFRTRFHe4szmhtJUlhZLojkThkon De5fYLNTynHCGPTf0rSKknTLvgys2pgLoRXMhpsL1yZfuMJlK+DYwT1HsEyzENWetb65Bd04 ASGWdPHHwN5LsZu1W8Sd6ND6a5eSrGNnwWQQ5AqGnkU1jwtJau1Iaj04eUioL9q9jkKejzrx sKPi46KBV5aq5cHoyGgUUeSIWVyhMUjL3DB5GIolLqM+0pJUjeuSMOMcZIpat3cuzkUVaExQ 90xrohg8MEOOueCkxMHkUCsyHZLBBt7fWiJ9KulJpfXWEjak56gycF5QgAubCvGlArMk36Qj 0hHRjYoRJ5qbggZ0d3cbyPYLW+BJX5ODXj7QIpTZnf0bAqDAYL6pOwBQPhWuGDbgm4n34QYZ u/WVNkTHiHxDqbeOrqlca50Sw2ImHI4cI6fp69sZqEJRTXFL5TlNGxcOCXQChDRd+GbedolA JB92YIiB+9BkfOuBGMLNqhgE7AhK+pZvaBGP8eS5hqqalhlIHqMkRmO55jLujdNroyMn/9yi URA4jS4nhbhVE5KOfERxCapMv0wxjRTm+3/b2kSNKs4iGV85STt5zjTAzNVr/quFATTr8G+j FjVrEfwX/tisUVwN/N3FuIFatIpRA7Wog/FCtaiNMTc1qj/U/WiNB1xewUTdEddIPlAOfE7+ ZR4o43AzQQS2Zd847tkbjTHTzGKm0Xu+KdaBbmeD5aXc8ZolyBnRXW3rFStiT/7xetdX3uJF fo7hsVDHSU/kPXrhK4OXv4ZKvUcKySjO6C+jMqO/im4r9KDojmKwsacuWSTZobs/+S+nsOCY H5K9dGmSgidKwbC1ZddIcmRVHES5piFyOUC0PfJuH6iXlxI9iZpar5k1UOcU6ezQsyUhg/Z8 tpbIufpu5Z75K/n88GA3/w7VNivP1RJZDUkn6MGnB3olTBJjtAjhA0UhPWxXw4kRCpuPwrF6 H8Cn8GrGX4A6/JR7AvD4beuvs5+d/Ma5jzvVv0bLcIfG1VgGMl02jgQF7wviSV/+fCHU08Rb cyfOZs3SeeettPnOZ+PG2vSz3wFB+7sH+SOZzr1ExlAwyTLstedir3c7iq/g8PlEutHmvxd2 Traf7S+2cWn+nUcF8Cynr7A3WhXmRIl5He6zPG8kz7afz+IUZre3gznJUH0OybsixyMvEhYU 3ydjrLjsbXERS4IVczhgOHwPMCkRcypE9y3L6sIZICOuiI6VE+RQEiT5DtNdrVVN7pwcO5u7 BgWzzO6+Gg6q3a/8RbImWESlq6f1pueDmL0hDCsVoF9PS3eD13tI+taI5qajilgaRjnUQ5Po RsUY4N8r9KNWe2/OX7HqMzc+6uKJP8Q8gsW0kvueta757ym1FUJ+SrJPVbsho+Wst0kXqm/T 1Sr39q9wiz6/vq2Q3mxEmTrw/YJRkNhVf8K3n9xTksZWyp6SNFXaFrFe2tRHfCGMj59CaCC1 OS58QW85wVU/hWyIuGshF1I+b69PA06Vo5q1Mu7RWi0e2AjwoJJStxqtRO3uuv+i4aDdEgjo AuGBaN0RgLhX0DurCGC1BADO4S+D/ggdt15//9Pe69Nnb16e/nB49P320eGbg+dlcipN8mnU 3ljj244z7qdRp3DjFbJGTIRCIWNawGhs3XWy26uzdHifHJI9Wu5EikwW7AyZ/iLkWERHzoXV v7xWSCOGR29aDYlJfRi8a5V+fLZG7zz2VrgIy6VyvNMdeTPx9dsBvrLy7p2Xd5Ku6dVSYIaG wocf58+itZmvCbnI4JrF5K73UPqLBLbiO4zxVqqI0IlqCb5SVxxYJTcg484UbGe2Wfn+XTuH z3dD/67WJrp1uf3Md6L+puL3nnMIc1/G/QmDubNc4pFrlky+kEwyb6t5w5i514o8mc01okhr 5EzhE/Ya8roVj8kVoVgVCAWP8EPKwicBKb6lDRQs8bs8bvFDwqk1t1OSCHo/esxW7WrREujH 8VrIPf+Y+4Z8dbADIBBxTyielWE3djjF/RtuMe9Fz+PSYwAoTsmYFplDYeLaguk9eTJjfsVz xEO9ZPh3mquOxSPNErnV/cy+6Q3MBmFtbsF29oHN3druZwaN4Se/Dvphscih4JKVRoeWdzMQ JrJyBxah8BrqfkrvqrOHS6STI5L1OxNJ0bGZG9oiRMK4ay6OlIV6LntpBlLuiID13xsBrZZi YKGuy14qxkC4VVciucTd7aDQz73t4jvs4Bm7t3jOcjDiROv1gjLj/hCKuXYoUqI1ag4D/5g7 9zlxnXi+0DTIBsjjK1eoM1IIK9Xc1VBAs08Bp8vp1dN+nVUPJExUzqimL1+t01GSE+Fd5T3O HlPtlzLx+WJYvY75XCiO3B3MPYpk4ew5hIY6l8gZGAPcWUAu66WhL4sKwXJPO5OSMu5HiqyS vFPhghlrVZNyC/1DNG2gKX00IH8KCa8O4VEtuPFIG+0eHL55+Z0ptpBpCs1eck1WnpHEeskw ioXA3/vGsOk/L7oxFES6OGzlf+jNwQ9y+pKXh3zsyKesiBNbsjZ/SfJBOg53p0VxWf3sJQmW z/6tQ/oi66O3oz/6Wufc58q7R/tQoLaDr3JKO8qV5setAHpupO6xOJKXuaK4CKX3nwIlRN98 w+pP+KPd3SjCsgmHKVbmevZxc3G84cwCYQNn5jcmDMg2APm3WA/sTZq9kryO8i04xOkTzwUy 0egO18oO5PqVPyUD7M64Cn/WNfjTr8Bl19+PeapAoOk10oT9Hc0lcKCXHetiHCcvn/vRCyBE uniszOQqbFmnl0Xipt/T6ypaq8z3C6oUXDhfVL1g5G87woUsjmU3hRnWLqMwCMlbUqopgRcy CFn+smVnzuewPnNdfIrVddpNJCJHjdL8sN6P/lq6oCHjjMzYvv36/Ftgn1He5ju/bfPD1832 BzTVmaEUGaPLDFvoHLiy4gnxeMhUfWtbQUPkYfX6vCOHeH74ykLsSdfPc+2ZsYjfUDzvAouY R6XbRcEplp9V3ii18LS8y8DM6aytfqa4Rn18wYuFawyBKwWeJ5wQ84zS8XDV+xIBnV/01EUy c6x10+pu5RDjNSwz/holhfv2TEMJzmBFLGlzGhk2NeO9ItFpJu15xva8Yb3o0PZV4p96NKuk 7Z3NRlj9gw7nP+BENnj480guer3sSP5sXuVR8Ze9VKb9fkbXv0XkBm+H/ZvxM5noF+Nnzril q6fh1WbWVWmGbFT2oWvbI0DOp9MXuiD04RkGyX3RK/JMPm+G43N6RmMRp3eCDshHSoLsSp2k MER0YanPd5LStfPGVHwAUMPH4tVUzF5ptE/Yo6jEocgZArsllbx3J6Of0+/cqQQDWNRk6psD tIziYh5nCzhR4We2m1bhIuPHiPEUwbKyUjAjVfXX6wXeZR9nONn5bxa6X6FTek6Ro1lTOXgq Yqf5eEJZv6WgBoiNHOWJ08YM4CXErWHDNrYtz1AJc4FupgBb+ZhlbSGBqAW6mmqxkicfzDyD RwRBzQECge88KpyxDdrbWgxcL+nH0+Ek5z6NLCXGUqOXmDd9xLlFsNRWpmm0xxk9yx1xIfLn D8ZiYEm6lpQJXpw0dWNa8fQLs8Y4T8J8MUsyQASOoUuYT6gk0G931COtWj6ej4nkDoE+9sHs PI6z4oB+enG0u2vUfKaTwnyGblxPuTrWd6cMsgb+0SmV/60+c/N/c0bjz+pjdv7vTru1vh7W /8SyoH/m//4dPnx4SdpqOKOorLlGcJZn+t6oRe1mq/kF831/iQzW6h68ffxq7+AF50gZYl6b q/j8EqPc2PKKIaiSrVuSZ2BWAiyKTRVBrug5ZidI7BcUCv6MioWg3TbJKJUKRp3CiMie9tp9 HRv3galx4DwdCPXodXqTjF/vRC87UYVwWuXvX+29Po6OukBVUeUoxoIYWf11cjnOUq49/Nof WhHoUTqilAcHKRZozKZUO9UUizlPdARYuGl6Fe3t7cEQqCfpA0axttFcwwpLg1+GVVojyZL5 +vD4ZO9gB7PvSUKXwxcvoqbz9+s3rytxNXoA/1lZ4ex9wdutgrdXVuCHOjpLqpPnHGOVM+Xk /Cclz4mXV4NrZBBdW6UyvuYGPEuUJSdNcPI5ScITI7Zxwicngw7mMnGtSVgobkRVfBKqqEcp VCkjiGTP8p4T/VAKEq7jUmb84yBxLhKjqccjFkmQ9ivVGq46ApNS6lgWp7X2vWaEkwKrVF1y bfV7H2zNKdq62f1a69pGxmAX5H6lMizXSHNS/F0z3HI6i10K4HZKjzhl3QOflv3dA+eRJ/6g WbPwGS4rmzldqGP6Mngv7FaSY23QeA41iU3NGxUV6MWsac6oYZjIJMeAH+wd8CPr5GVWIrti URIwAwe16gQoAcbD4SFW88+lXcyC8uoCkVyjdEruHvSeAQYCNcISqhoJFKS0Jd7yk0Qxz0Uf r+IPg6upxiIRLrRWVyw76qHZTNfxgGi11ZVcXJyCQnp3FOO1yH9Dn5GupRa293erOhxI3b7i FwmQZnuRPCqrG6KygpezwQeTUp+xjHqpPqX86RdRla0hyTnsvD2H+bswoYXAIscqqgGE+zjI E8EXSpNLugjXkpWBSmRJfdViVJ8zbUmCREvckpiZPYSkKLEC1+wHnFCF07JgZYlGWExiSWV1 KU9dvJ3YfwwoMxqm6bXBhIcDgeTSPeceoTcpm//ewcnu0cH2fom1fzzJX0+sdx0+91JrmP3w bcZPcSDkGUXDDWcCI/mXXi8+KfXIQNNMoPmH8kn7F7byxBomvQUl1qCaoZgYD7+uBXzd0FE5 tNTJaJIbRzozGcpZcrFVhD5J/bA4IGBPBhDPCN9/jGzLzIhZnzcjkQ9A1NrfPtnFi+Hezonf B+ajz0dSK12bnUEKL5QOsaB6j5OkOBFQBpxkdwvAiT6R856POaXSoC8FSanEHr8QIuCG87QG 0MSplfazpC0qa2/S1xSMhkUTTlBfjnlNaUfZabQYQJQNuWCxSSjW55mTEmvBVDUuLVEg7WIJ a9xmxKbdxC6OB9sQvyjeQeqJWNKyV97SuMzlpngVZ7/kMI1fEnPg5OnD5H0yxGPWObSyHKje nUAFMudiiXLgHB8PkvdaV6Ak0U16nWtNuvJeokfetZRCrHnGm3ycZ9EHQCklcuVBBKNpAWdm ECpOwMMitIrjovxiQDkMD3LpfwwAg89Pz1ukGYtUHyeB2Mj24UUpDSBVys3gVP20cKoabES6 Of9UqONthp+K3XaAfvSVQPqoRxrumhak53ahAA+H5/xlhcXbenjYCSgUIvnVoENu3e6uc4Rs CU+W0iBqK0bG7PJYLQDi6oy539Dzz2orb3zn5Bur4jSVQjyNND8rSBfOqMgnCmdEixet73fG z3r+M2Ug0pB2NSw6p6ANnPYweGdLMVPwnnEg4BeV3HreDZWvoYGgl9lUPva6mLq3Td2+LCbQ pdHePPmkFcL1zCSo15WrTasbWgTK0ifjdXuA2Xc1fbJvAzEJlL8MMGs5EF8FWs23ktqBVsi4 F/RSQKS1HaA7W84KHdjvTR5d4KbmS82f635XCCy9dkCRNcV40EWlH1swI+TD9+hk96kOdp/l XIeLi+ymwIXONClaWRODRg4UFKFYijk+ms/QUBRgLxd0V9AnfrCTJ+iHUNiH6ckm0LOHZ5GX Gro1FJvWZKcVv4CfT9sk+inZefjJm2wpXKsgN4qm18ZBYnbtPKzCHeKNoZ5/9pm+X/BXSFsz WdfnIXMGIu8dqI8YYWk9l6X1PJaGn16KB8OjkIjn8jYzgaLVK1u5+XwOPwtsVq8cTdF+palx 9o/5m1aGNnPjLrhpdfx/3PZceASfP4oFRpJnFvlvaJ0W4x/lAmQ4fUmhgpJkGQLuxa2JAS0U N1riY1iYTgU/n8Qc8fMJblIUY1u8LbwdxNI83AuqRieDkrsBNxiVeJbgx1kXIsvwOeYoTOiw 5jyqjjtWyaWShkcg67krq88iKHH7HGjCeJ7ypWLWvnEc9LJ4NPNV/DiUNvdu/FmUaDtciCL1 MzcXQbDvsILlD6d7B3/f3t97forhfdsHO7unJ4eHcFk93T46OpqJOZQXHiPpwqrNRTV+St2x 3I8jIM6Ib6f5WBctFAZmv3yewnVpNC1wfzbgSp/gROvuRMuBzJ3iYtNzpuZQcvn7/r1i5gDE 7485AKlR7nXN8FfsYs5y3PvalTBfflj0reBBWImjLQk/iFtRQuSubajKTca3FLqdSt3dGYoz 6hOOSHWWK+L6brewpI9J0HU6Re6KdVgWYKv6MfT7Ry91TkYMP3niFGUnHA30rPxUMt3dgQbM pZLX97F7nqFmcBxfR/EY82YugGl/cVdEcTV7kZGlPIkcnVbRZyFKEOvv/1KCmL9L9eOupuLL QxTrPxdGFX5IPJmzSPpZELX4WQi9+Lk7ivFzFzTjp2jv4eeO+4+6vr/dWX5xpFPhYppOs/ki IX7M/lxgX/7JfL8885WBSebMWWLL3ab9Jd+WxewsekvGj4jK9zdBlb2fwl16UVlzDthF7vfz Y0lyrAM/aj3rDbAizSKERNXbSj54UR2MXIcVcmNBr/IZZPlvQ0DhpiiXSP/dKcr/ywhiFRMf mRO2YenbZAdDs/nMoF78+GpTtYesRJUSpVRRACrFabBmdZaGtmRj/KHhnAWGkxmozaHXjVUP kOub2O6OWEGql/SszMxDKQrCeetoPcvnPCvZnbMYzMtgEGA/mMG/AliflYRgDi0UjsRwEuM2 hnZB43FVtbbmsRdqxN4WlXTEDiVS+Ogx1hXKUpKzUgyKorICVo1lssCxfY3aPH2qXG5ALM8s uKo8SX30WF9i6jH28QKj+PS6x+Fx+F+0iMvIvcI+NhSKfCbMdSFXoJtdHILnTriUoyy1KPxr 1EVKp9/r0EM1egTf1AnLdXpFyShf8DvQvtIyLBLh2+6uY5/4dj0i3vuIvqtHosXF5TS9GneH SGqAu9+71b/pe8agVJVfikJPT/TLTnrTa/E5lWry2Gs2xDADopPYDTlY7zZ3fkyqEgnwhhzj MHVjf5AMe+yOSzzFFFXkF59LDAGGTLAH/4D9w9Vr9Bt2J7X2mgoICfwluz8RvTCwE5IGsgQr 402sRy3wnDq6ovIoWBqpGe83cvQ3Sh4GdHydnKOLI2l1+m4qdjgnUagZsIcTDAVjMYcYKIiW l7hH4ChrP8k+DG73A9bFxBptYwByiSEWvYHUU62cadQHR1bgTtS30rP4bABcAnqTGT6n2Ayc E3srkXyFXZKLNyzamKIGJ1JAVBGQTc8yrJU+4uzsmczyBsaNjwNGRAEW/htSuVMkOfvCPkYb YA3PcUrlOGk8jOsKy2ZYJ/iM8h1itI4Gg6TvqV8RiZhKrzgSANB6Nehhhkv0tQNQEtBDWj7k Bl9x/A1++0eHP/1//rNY/N/lZ/UxO/4PnnU7BfF/rT/j/36HjxP/d4lRJOJfDXtYkhNyaGB5 JGDni0cCwhB/2D462Dt4+YiDjPooHUkB3AfQ5gEGPJgIFlvCOGtEexqodS2aQ6q+inFRyKxM iUZJ4QpsPcvwK+h9jOWWiDFTe2DA/42cE31NKYdsI9p2etLhpKPhLWGOJ8AhEfNiIkCUqVT8 UIiaU2KSQiVASvgi6z9//2Nhtc9jALP3f2u108zH/7bw531Nctbn/+P7XwR0u9DIBFguI7FJ BRCnvh7LvQ+il8kIHdCx/uR0kmL9ayzHfYubEJMtUItKVYKxHIfsz9jMKnJzue9P29AOjE/e 1O6MUPQxhWG1agdM/m231caU4fY++a/Ntdp6rfmx9q9mbaO2ob+01uCXNv3W6sKvrQ14q9PS p622/La68dEm5oVvNmutTXzWQqgthba5Jr90uB28tabPTI/tANRGbW1V3m63VxWmQtrYkF/a +lJrlV7ahJe6myGoVlv76a4p0CaCaK3jQNd1EM1VnVhTwa6vhcC061ZHR7Ou82pTOxqpQtrQ X3AIFlC7hV+113XMqx2DXIXaNVCbTTNU81qzGY6rs2awq0NcNUPVFZNHALRjFiqH+U19u61v t2gwQBHwthlCW8GvKbbaLQ9bRDZtO2QzLLNoBjuGpFqrulQh5hG9GzpmBbph2uEjwmprraNY 7XQNVlfDSXbNEhN9MnqVxDd1qB0z1DWzkDnq6uiQ1wx1tc1Ilbg29aW2WSd/+xB21wwttnVm XbNkhCRCamvTIFXJZbWd24t2P5tfOjqxdbO7Vs3uUmxt5GieBrO2KhuWd5llBwqza2DSRmKU dnPoaurMOoa81g19moEqutcNcXV84sIRKxo29e2OWdXumlLspkFWW8Gv5ZDVJhbBFGvWwOBt 1ayZ4TwtQ7oh5gGGWTLaNz6TNXhbNxRLrNUw2QBdZs+vbhqKNUtmmawOutMxFJunVIMIRcla 11DsWo7J6kvtbo60CCGG2wpQBd9dNxRrOZdlsjmKWG0ZOlDsGqAdbbeu82qvGs6V29QbSsI0 FngHB79RwGQVatdAbXrYCrmtTq2zboZqjhQzVH19bTNHXR2zYmaG+nbbLCvtn5DJ5rC11jLY 3TAka0eqmFvVlW1t2E2VI4hVndi6WbOuOcMMkzXQNw3JbnrjCrmt/tY1K7tpj1vDZHWonTx9 rRmZwYxdm62ZkXbMSA2TzW2ftlkwmlfIZBV8d9MgddVlsiHr0parZpfZE8jsro5ObN3srtU8 7zLcVmHSYEqZrMLs5pDVbtoDzCxBU2fWMeS1bliqGWiOuNYNcXXMCWaYrALvmFWlvWWYbCh0 aT9rZpO1zQnmMFmd46pZqs2ccGMnZjbxulky2jflkqx3xC4i0sogOnkmmzsYHZFWYXkiLc/f SrJdh8kGrKtApO0WMNkCSXYzz7lmirT6sFiSDWWulsNtuZkr0s6RZAOZy4q0LUOynkjLSLWS rOFmeaGrQKQ1K2aYbIEk28kJXbNF2vUCJutKsqHQZSi1WKQVrG7mmGz+tJ4v0jJWrSS77jLZ QKgvEGnNaWkIoUCS3cxxrlki7WYBk3Ul2YC6aPVnibSCVLNRPUk24F1WpDXbzBVpeajFkmwo cxWItN0CJlsgyebO2Jki7XqOybqSbEBaJFfNEmllxYw06UuygdBlRVoDzBNpeahWku04TDZg XXNFWhlEgSTbzVHXTJHWbEEzf1eSDUV6g91CkVYo1nAuX5INOJcVaS3n8kRanpiVZM2C5jlX gUhrOJdhsiWSbCBzzRZpOwVM1pVkA/paNwK8IVlXpBWSNXvLlWQDocuKtN2PhSItA7WS7KbL ZEOhq0CktSKMIdkCSbaVI655Iu1MSTZUdW263JZR4Yq0QrKGis2Qc9TliLTmtHVFWkaqlWRb LpMNpa4CkdYIPA6TLZBk86ifKdKa3VUoyVpIC4m0QrH2APMk2UDosiKtvuWJtPyNlWTNWZvb i0UirTnBHCZbIMl6o1pApDXTLpZkA9YFKGHPm60ylS5ar1Cn2wlVujDTLvHHdgd+aXeFv3WF O8MKgCyokkKXFq/dxcdN/64Jm6LL+oE2tV7rbMjW7xItt1exNW1AQFeXuXQbVhPOg80QO106 4NrYtt1kIaGNQIlTrCGkpsJu69CpP4/fdZlv0xzWRDzG39fNHLodOYK6fHzQ0EEeWF8PWEGX OC3NYX1tU+fAI9ugkbU3hCl1mcvQ4DtN/4DnWWx27Cx02f5oM8q/7Weu/Y8yqn7B/L8gEjS7 7bz9v/mn/f/3+NjUcJz/l5KsodXP2M5KTf9f2OhP/XK51ssBOmTdPoKv8FukzbNkEjdx87dX o4P0fQQU08Zn9egFZeh6n4zJ8Fevkx1wmEww/6vkg+2bfKaTNMrQejjo30oSS0n6+ABAn48T Y1DUrG2YMBLz9IySpIdZXcmjHYPG0D4YvDdg5wMEZV6Pf3G8KqLkPbyGv2PuVWPFjC5+HVwb 0ys7uE1SBgQvjdP34juNFWjZwexW3NZu0esKiwugARRW8P0AY2xoUXXK2DJAZIsQ2Q0Q+QZm dJ2yX1ph2ksnLa1JDcn1b63TSD06Sq5wwPkmnPo2K2giy+7giTPJoo8zZqSkQAQ3lec6LiQn inW6nI5GCRZWQ8NvliBlko9sdD0dDhmGm6K0YBxvyCtOwx/INQ76Ybc48SG8BlzTmILWLnrb iN5VzF3sYFfmCF0n41E81My50Si+YtfEcdKbYlLQdIJJmdGXMYUVHJxPMgGQjjkqYwCzgEaS BVjN+Jys7oMmmVM0805nCK+QGC/Ppv2374JEa+jCR+6J6Ih5lWDV6MntdVIAQ6bh++i+rXtF Sd4hvAeVXJIzvzAM07dxGx0lF7z50IsS9gU6WG4Pry/jLKqsraLTaDUcjovzDpF0O0D6dq9n SzUDQNe5Ns6yZEw95gkhbIc0iG6xYbln5j8forMp7YRxIlzBpm4U/hD3Eacy+KME5l+perRr PW/rdUqdAIgh4jXut5z2FL18vYZBQSd0iZWq4BZb4iNcr5Nnw2UyFM9aqX3srayf95wo00t8 nuXh1qLXr3dgBugX+1cPgVh7gzNHp9ecclCSh9fU4yzsbgAiOHC5qLIHzGL416pDua+2T3a+ 411ph1CpRldTzAJITJVmxbzY947m3J+KOuR0nBhQdnXa11Iu5FdM6bKR3UgpbmDJWXSTAGuA n9wQ1osJ2MmwjWtIXM4bX71uFm7e0FyCXkWCbkV/i0dIzx0e+DGcXJPoejLm/H7WDddbFS4B XXUS+UoVlOgmpmrksuKvkH5iJXSiczc7OCVQzZhxWtZsc48XbhZ3L0km63FKjI0cd/ypCw9U eo7HYyJB2TOyNjlysxuBD0E+z8WJx2Pk5PzPiU2QLhgsM7oc1HLKkHY2h+SMETGU13jgpHTm Ua4B661uHdR5AiXDIHoHpiPJBAt6NPyb/fThL6D/0fmtXRJMYokJMElyoHz5fLNNzofxWBye Sro/FpSiU1bsBkAV8xXTJ03IVKXZGw2IOThf4Z/s/O7VriHOPkpueEdl6XSMOYA5k3IfuSHT EkpCgx6RLDDYumSYgW3fj88ThzA5XzWCghYXcKBhqVxAKIlZJJWO8DcQFWHfZYZFZwH524zg CMoS5S1XynA3a7dos+6x6NbzEeCPOKZyFOS9Br9ypzpNSdssciCJU4MRnbwNc/IkErvQ4+Co TE8ir8tgsGssnviD5dUr3sYYYQQYOZ8MQHzFwrWpLQJBjU9AVgDCphTdMXJJzsNghZoSBsRH Tk/iDzhQm0OhWlVMgInRpR+drwCgFsAEOrqIMR2zyMkkaAfVnvxOSKCx29lHEtMqHUqeYPQg wN06iRnrAfK0iyusooj9ZB6kdOx4916mY5tsPsCHt4XwDoasZTo6F8amA2mqgmQTL2QF45hB cEpcJuYmvY7/OUW2kJ2PB9dAS3KD0XT8gxGAEDHeGU42q8d4fDGlI4X3OtWOIrxgRiO8gt3E 107JAO6QTlA5THs9vIxq1Bgfws6IcCs4eKFxIGfSiDIEZeRObCa1rTRUziugIYjF5P1y76Qm cqHMRHRjvGMVDoDPs95PL/QW6118G1+0oA2i8NX297sv9n7cfY5VVKTGzbM3e/vPzZemuIr/ NSfesSVWDBaRLiYpky4MXrImI4XSnUKuFOi3Pie/Pjquc2usVcZxgLLjZnq9Y7SczTbnjBqm QuMwLsYEB7+i93kq3KPdZLej8wzECTjn8WXzPQ0T0zPVCtPnT/tW91j8cZNiU2XLgoJsLN3P Ksc2t0QBvXWHom3VWdXYPinVNX9BRTdOnbTX/IXmsKa7FH1lM2S58bNubTcJskTVETxpmaQD QIPIEKbX18gXB3CsgzBzngzw3PwbyOBUWgmeox7Hzd1tYmy/29UgW83nzHm4m36YJSw6RvDl HkgW7E57fW3jjd8EryHhJJz6iSEkTYsdfCspsZtFUZ/NopBP/0tNnp9LaW2/8ZNuk8u+BwLT 5RHOvc5QeHoS1eXb8tJ7YyTn8uJ7pTugLZU/ePM/o5jPcDtgW/vcVCvEb8fx9dYdNotUN8bj gd8QWvnDNpGOim7l5zwhqsNiMrTYiTtaF2fYzvPHfqo4guXlpHPehTV1UYpP2WoSBLsLELeb p0+j1Wq0gpQifPjlm4Of9l6bNrlhrW74OSich5za1c31ZktmYnllm9pVqxBQNQMqOqkiWt9U LJuUYOabb4IRbeD6unPC9MILVa10EkxK/18ZmoFu9BHt0q/cGHGHwh38+kUwHbBO8gK/O5/X fJwVTJ8lpsIZBcUMJgFzlNV1t5Ez/OLRe/s7f5iV7XYUndunud1eUwmqJqqVUypbO5cHiBGW hG+BwC85UFxOMU4md2EUuMpqK/B4gnz5tvmO1h2D9/6+e3S8d3iAX/32m7NoZhxEBzCIagX/ SvtGvKkWkZyAy9Ocy57mcKHc4RqFHzLwsJrhJlFgWKuOyoUFbLH+9FdSVVKZV/pN67w6lAwQ j6/g4eExXbDiyUBMEHCiTiIXLw686Ndz+m0reC7XDegORbjrftXhYk5iEIOEV7seBj6Gw59d pHbm0MORMygYOP6ytchoFjkVPP74E6Zx3ZG90qpFQjZFzfW8NWypkEaCAZUf40Yj7RzlfiVe Owq2UARnmyMaljMtrqc8Rwyw88LXickefj+TdVZDKiqqHvzRZV8zCiYjv1J2tRiLugtL8tmn xxuf7744/eHZ3slxSb9lA349HlwlAoMPSboQF7NSThiCv9FL/0ZXDieDusd+CkVm54EvNnvb FUVUn2uciUywxhOzAFYkEw7lMZoxNa5AR8lv9oPkN+FgV57I27aGjE3n4vWdz/Ni5WtO9iJF xhmBlCpETJleIVQTvSv3dVa/YMUxVuWT2JAiPBvea8sYYunI8RWF9HJtT+oz862KxhrAZkeK jd1zL+wYZ8u6h57UW1STjlswNCIHFK5qKJClyCQX3OJqo5NvM9aL9mpOFiF8Nc3cdm4jifil Io+kutEKkqyK5Pe5NJyGDWOFrVtJetL+XisvDkYIJ/nAkcJsEMfEK5NhWBYVevguvUneo1Hf QYREE6N954ymRlHOrMVCSz7aL5zoYzwNRmInYc8FXEkZpLOg7wfjCx7bVXwr0AViPYv7Upax WIPDJ0l1aS47+FexJkY95Yi/0Dj8iyU50WEeMg6JrkUPxJEu/wqN6m13dfWdvSwRUQi9XU77 /SuQW9Sa3ZdFRnqIKrmpRzj1qivf8PhcTuLoh4SV+szEjJ7Tx7pSRJBwZ+IWcaTmt1fBjYyV 1vj946i1Cvcqe6HP3sLXKyvoWbhR0qLdXStpsVnWYqNZ0mK9tMXG/FGJcoHWxH7Lywvf+4l2 hRU7Q/RNkvu7B8c1t8saDqIWfVNBOFX8hfipvTGl41+q/krY3Px3WwPk64WT7doGQqxl8+qW zQvT8YcT67TvOK+UGeR/T/FK55TEw4/Za0090KioNiVXcjgOVsmkwTmqY+bTy046Jr+BEr+n a+L1DRVR/vLm9VG5ve5UTWP0fSxSYetwH4PUOkgbl0/10PvBq+bt+LpQijPAlTb9tofc+z0y 4ueUkQwYp+kARN+Mzjw+lTJn/pQoz2WvYz6YyBZO58rwthG52S24jGfGJ4x7CKUw4R4MVSv2 3hDvB/Z0Pbg2Fbv10Iyi7SjDk1YNlAgPC/mSLfuWeZxVeHPeMqQOKevsK8RZGa4iHHBm9PDk L+krywCdieSkJUNZ+OOE6yTb8sLDwegX8mYB5kcGD0YT/W0xLec+n9XTkYw2blCpYQcBtnCw MyKRVJ2yODd8QZpxvXeFV/eY+8a9NlxPJ1llWbbZXRKfLOcALJ4FpajtQ//L/CufkSyloL+I syHNzZwyyIL8R4WwPjF3yh3wIFp1TiopTOZ6DATd54aliVe+npKT/jKTi0Ab0uVUqFqtxkHt xAq+9HW0rmlWtbefR/rWsrNR9Om/vp7W8P+9j8vC0BvCOd8CvHeN9Lrwa7q6edoA5ZL+e36x LBzmygpN5glPL0wiCkjEq2nl29q3Vfe6w8jlqXzcKkRy10cyv1seDPG5eF77bDzrYRMi2v9+ Bqb9F78cqj86563lj+roHEVvWKfrFJMmVko2cbRfsYmpMtILWaf9fVUSvuIJNEmQK2OpewTG HJyvcHtGn95L4WUqMfoBqzXdJnA2kYczXqz0UjTIeMfyLQuBkYtabFTwcCgOUb4mnzvy5lYP O3GWQQfNswT+1nH1ppTuEvkKwjNuyNADCN1ymEtGX/wVDo0h83JywEN4LNknqMaJzy+B28Hg +aY54RHBsc0jJnbEkzJj5vSfZNZGnkbVVGVW9msaWkYZQOEwoBPkNblG0KXL9QOClzhnJpyH I1wIz3tA+Z71TRI/MDj3eu9jYLQXid7sCNNmiRESoED6grGQx1mPPY6ToOY3XR+v05Ge1noN 50HUxBEOO4mHNuO2Oi/YKzJ3itCk35sB+kZjI6ltLt8j1sh93Utdih5xJKOIxyN7XTZEZLAz pqvpGa7tNay0OBeGF29AGXprp2O45dMineNiZ+79NfQhEC0YOgvktF+uK8HCai98yboCpNe3 Namz9Gl6LL3IDsgkA6SMCZiJknvpKNGtVDPaWKntq54tfpWKvEHK0b7l9GNGH1spcG0ozxTv a6Tdesc3hWw0/IgG2y8PGzDV0kkIMbdCi9fAMDHkBMx4mIGJTxxSUQGW+HB7Uqg/vPFOPneO eXucb7N3n/g2fjtiW3RceyL36sz6FBLvpmS5pHQajM+nwFeCJScwWpwhyEtttaT01lO/NLc7 41+vkqvz61sf77Uwr3bda1/zoX0CTtz2M+zOUiLUw1Xd68UnHqleiHOuamP8Y2v2dKMVD2bB 7O1ud2ZLqK0/CYqtKdLDKg6LIpq7IghbHoAAuf68FsKxxXMBrnNdrIQz09n5AwlJq5wGwvY0 zsclzelhbggfHVqxd1HSfEev4vNxyp5/5rB7pEli2RvZeLBJQAG5GHXa4pRNd1X0kB6fm+/I DRhVJZ6Pw1+My9yb18+3T3YrBB4llj4XMI5+piHqVGE0F1n0V4Gce/mRGUj4qMq6mwU6LIPg OvAxEq4sniShLwxr1hx3jnYM3Jt03NPZUT2Xn83aULBQ813uVKlWqNFW+Gqr6FV+F71LNrwW PPQnPgYvaZZt86Jx/21Wl/zxr/7R46cW7dktWmv5Jp3ZTdqri2JptRBLDnHsY377cXKBsQHj jK8YLLt4ATQ2HAEpRjC8f7j9vFKC1mtxAHTZnDvmYdK3L9gDzHnD+Kw5hSA8RCm/c0s9eC+w OdCxt7lPRePoWt2K6AlQdJRw7n9GC4nVFmEelhzcHO0enxwe7ZahJ1fA4tqffL7gBCIs/4Yt kEHHYgkEeoEqnXovuEbTED2+5XQWenaGSex6XWOIU3x+Pr0C4WXC/iSKlL2DvRO0bpdhxRhw 8+vULOv+ZQLdcRwcBfFyDITIUMFY6GZaeD2iu16fTYJ40RqlAsoEuDbcibwG2fTZP05KlxfP O6ZPkjSpSA70dQqo8hcBX6rXc1RbUPybLE4rK7b4d4gjKvddgqTtDKtQSN0PmiPqseEPGBCI SyOGINe7AGmsMVDMIHjSGIzS6cVlLv5X9dDxRCy7hdj2cHmwu/uciGJUgkyZihj+ncIrWArd voYfuy7lm5nGQ1dsvDzwzOW6GZJuBUvFYL17Z7j+UCul5dFpdFQxSfqlUEzpj9BR1KPT0fOj w9cz8WIqkcMbOWqoP/ExVY4PGtevyTglCwWFn0vwq4So4/dUIUj32RmG7qDexEULYH3u1sbB EuxvovWiEYfP8oNFrxjWieltCQbVadcRj+xJ4fFg9KfbrfzTrlYF/+ATFDpqfuj30ZvVfL2h 3zab+L2MkB/bB7C6G7aZgoFvAWo1qL2DcXgYQRbL8QFi2CWOjeNsULmBiKb4VN5BpOZAxcmF WBHgOcKjVxzNCza7TrNsQPVySNHnaflOjJ+zdilVCzRYuIeOFheXw1uE1E8xykyNR0ZHm4E8 AN2KT4BcGxoNTndODoTHJyCXjh55nM/hD86cAKYMnzUaFFD+S8L2LcCDr4DQWkb6N3Tqv26G EUVWC0OjuXKsslY5q6/zhTxLvUBbDIFSPxKOGquxLgqD6GmeqFOcTJKr64l9Q/xI+NxAW8s4 vR4PYkorwRGKbC8UxR87u5jloOVPeplo84ixosjDWmheQMMbqyy/4zCm2VQccJLoJr51HNoT 3AGx2B5hesizUcmEBjrpDVdB1JGMYXTpsZ2QQpi9S9hHjfSA/AX5pSc9YQ4wLVxm53ikAU9u rwcUZ5MZHR6CltsHa1QfWaO2w/v9pQbugZVZJ5es3wShVFmhu+wOi2TF2g2dUu6JkgwIC8ZR yTuH3CMf1XBMtLx7kVBJSMUAWRSSzSEpskUoV1BkN1c2zwAbMgAEdjF4L2h1jhw5bP2D9odL 0QPWPPbfA8LKdCW8Y6tfAMSRss5RNsvCd0jzjNrgZMLPrKO9Pc+pA5gqngw4Hcvf4W5+Ho97 7IeAsGSva4trUeC75xpVFvMOD7Rwk+bZQtZxxXYFN6oiR8hfYjQf21Oc9gxBFoyyypf19S4l EBt2BDc81VB2HLmTdsVIWlUKUMXOFpEQaQsYMzHA0YBwtwJjRiNZ8qQVyScyJBMK3PIkyhdj xMnZQzFMZx7KWAlZ3XT+CExS1WBYIzBWOA0YA8dY35jYQ8ZJSaZAokNseUvTd/m0UeZbYdHu CL0U9tHexDkxMnIjmMRk0Ecri5C/kCl0xvtxIDsJyFWw6LAc3ZmDkWkGiHxB9eFiNCPA7T0e wdhQGOEJ/pIk17TbiRbQMEGyNgoocLKxqT3xbNoZxnbZey1xdDuGJXPeKG+yR9uNPdpEFsHR gFiIwwmVfYXsDD844rfYkP2JCt/xmJl+afV23hEnDjR2mB944NtkZL8Zsa9LTY8me64Y25j5 GmHIHiOxCk9M5tNReoXmOjF9bRtp4pYhmCPC3ROGoLyj3m4wdi016ZeIxuyBh94yQquxFNsj cuTwdbY3qddjjIDE5442BtOGtonZIsXN0drIs/jB3kk4j1K07F/OlvmIZYKeWhMsxzBqgiKy eThPWQNDAigPo4ehWld4zOs5jHHfRnYxFtGruEcnv7GIxhPneDoXo5vhCA7fQ2HDHGy0++lc fK1dWB9blO9i8chAaHIkBgqCdBwqHRoGYWaB1YBaC660bCOczrZYIzg1KbIhmK+WcQgshYNj bDiCLRwY5CDjw8JlyJqAYTrGeLDhbfEwxRhM1jahGGdocro7hmJnq2DOjr5zjyWa2huxh4zv OFMT77Bp5qZMcluzsTemtAnGt9lZz6iCC8xOMnBldhrGQxD8MnE0M/cH90LA+8zXMtVIEJFD MtiXgkkjqvKBUK+TIZ5GSFSanlPQPmcl4ZHhlH46Pf7Hwc7pi/03x98h856OcVXwEKrlR93D cpdGmhEzp3gauTuYBK04MHLL8WWSeIkvHUKTobNEw2MuHjBH+78AMen4O74FsLvBZDAWNYbg Dn0N3NP9mElDbPS8X/NLbM4gEqZR3I3EZYLfHKiTvRlEzdvyI+Sijos/bhJxj+eAJCJi88Kz Ny84+MBalCOGwH4RgSuFSkdkISmIJBEzLw21OHyEHn2i9dxYm1lbGZFhlPYWy1Ji4yxoQPpR t4FfdN604NB9VpbKB1rMSFMXAkBtm2hDHQCoX5DME2EDVsZ5H25AHGxGQ7xCptPJlt8QRRU8 BMd8yi0+cLIM5sZhRXs5RYH42VfDCJNk0CzHPF6ZdKlYntM2Lhy6WBkTNTAvfDMfekiGcGbP QSiKpN1wQeChUQwCdhtCKGjopl8I26KTvjjnpzbn0zi5hvMgq5n7C962jOuAhI/mR+FW29bC 6vmQaB+fZNtZfbdlqYQpw5gcHcscHDZo/ifOiKBtkLTnfRdkjSFJ4W1rE6VMxBNw4al15FSP SMzo5vqOYz7eqLUO/zZqUbOG5cHhj81ahF/D31340apFq/CjXYs68ANLfMKPVQpRbHU/3j06 zD6wVhDnmRlbJTB0+AHXngjzFSrb5wZyGxx+UviZ2EU4swRXkjfWa6e6/PNDu8jZL7CyLCEK ztlwJkCNbYb+dIw9SzKJ6IkTp6aqOXsvcFV0PAb3WkJXBEyAYe8xwVQ4DjzwiDHQi2aWeyvw gcTPR+8vczFCY2dJ5gAdljeub6J2FVeaLUMwyA8bZ60+jJTzOTh7xiHnYPC+ebS5XxMKAlKv 5udCZm+3ZY06L3jT6lnyz3y8vdjffnn8CWjz/AjIBmY/lDjiGoUccmAoxoKzzJSrxKQryHt7 Oa/Vn5Irmk394YL7KlifVhV3MjN2zv3W90ZE6cvEbqw1xj2ALmtzP5WK6nyMvl2MCPBXNfo6 6rSKKdYGwFc4ILe6PBidS2pU5bA41OV56/ZM88a4n7mrhpOioa9WGeHPd4EATnafLzzc6eiX Ed7i3XKlqAxNe19oyEb3sBrQMmYWFH0F5f3YyBOE6yfHfKRsiJpZAo9m7x3ySUJY2N1T7/U7 LDFcvwcmmyq6FX0hZGnYEqcFYmtfbkrlYfaRtz3SX5xoe3+CmgkpYGPq8jOLkfnTFMtk80O7 2Yz+Gj3f2znZex49InbutytjaYKTYsZNRwyxOP+M8Zl+wfCUr3F+jAIu6x4H/LIa2/5N9pWz P+z4k2az5KydMWQhF4YC98cvP+A7HRgTdtbhlXT4NB0QpTzD4gTT+1cXPHvLiDSQVfZeOcRN NIpflZBop10+yrshAgPMxZ3mDtNeva9pHx4Hkz5ceFeWT7lcMORJf8jvZN2ppWTKLdOgFXvQ 3XVH3T/17P64v3sQYJK+KxWjndGsFu/vcsw7/csF1fPeKJE/70CiObxTzrFTPt19F5aZ/Xwa ymeh3V9dIwh8ytaT7OZexpfgRbO6J0fbudWF7z5jdcUv31vGYlyybz7d+arazF4Ai94u6i8Y oI8puDIVNijB2cydrh8mlhIqqs+buH4Cf3h3FCvYRY20e3NjSmg0K5GgsmBQKJz9dS6UkoZ1 Av+oyB1fPx/nLUiwVeYth39J9bcURyfMGAyZP+tFwQH6Udf+8jd8/lMKLD9vZ87cOOfvOF+W NlyvOWvbHmznjnT8apFNu1G8aWf7aZbt8Wb+CXq7FaI1ZLGU7uEtAlpZeVeynJ+0rR10MTlT AZC7NpWFeJwHhRtjLhXb1996ANnsnbsk4cf4+CGmvvmGcfyYueNdzqJZRP3Jm2v2xpq9qeQ+ e5fd8FnHH633zNNvsV22c/jq1e7BSbDR5NsF9lqr5Hrzv3mvaX2M+9luCO0O2006/3PH/d47 Tld9EZHzOxCVgy2FXy1ydrU/5TpBuw1vVF89iTz8y8UMrmZlwl6hHsKxTF0NMrL8Fagg8vMu VEPgp0AVgZ+8fLHYzeHTL6+XOCejuvDQD7fRzSIVRg6G6Mtbs0Y4U6k33zaRt8QUq+h8ZToR Giv8FtV8zBynutR/8sUax7KVH17pPrBZ2UssVCbQKr9ExgCIkz31e8bPHdbn7kpXf4VY/wRf 5SfKXiFk13y2f7jzPZpTnO9OjnZ3j8tZmgH8/LAUh2hHL0Kd9bydp0zc+W535/vPsft1inEl ifiZjZX5Q4YP1OJJD9s5NkYYaT4Kx+p90Crr1MQpMh7OUuBHXuuvs59Hy+U3Vneqf42W4YjC 5ViG6+VyTvHvvC+YJ+JeTJNLE2/NnThnryqddz4VZL7z2bhx0mP9Dgja3z049d0zMFMe+0fz GAomGew72WPFx6Ghw5BR6meeJJs/0soWrz138Xq3IOYPzj+VbLX577U4J9vP9ncXJ97OowJ4 M2x9jAUsSXN3c0iJATRc5GCo4nGNe9Ifq8NL80iUD3ospKZqoxtF57412ybhKtfFEGbtLRiq +F+zxLuZ2PQ4ongJfVkTaoGy25ueD2I2aRueLEC/npbSta+t+iQxZufw9T9O86tzx3OboDya 001BG7/JfM3zLD3yp2mk4W30UTJvW4elwrcXu/KrbphCUb7YLZFCUUrbomdladMFdaRzyX9B SgZRvtA5YKGLgP7JAiLy4TI7YOjzIR2MHN+PLvp+tLvr/ouGaXZLIEguHguidUcAkjXW+p+s lgBYZbcyKnP2+vuf9l6fPnvz8vSHw6Pvt48O3xw8LxONR+xx0t5ws72PJKFQZ3Ez/SRNubSf 0Abll8s4C3F2e3WWDu+TlRZ4TM0jKXaV5RzvJT4n5r41T0MIIhemaQ5oTL71qUzzKzvAH3ur O1OzEd4anKFQgmb2dnWAr6y88zOnkFdstRSYoZ/w4cf5s2htlqqHZg6uGLWlFbryoGVTVETE RS9gdlitOLBK7lsmQ3Owlb2qHJKyeufw+W6Ysrq1iZmq3X7mm+q+qfi953Jcuy9LzY87Cy+e a/OX84+Zt828YXzuPsMFKNho+vUddhpbS132VoTggtSs7od8/58EhPiWtk+wwO/Kde2uWwPA a7CP3+MnUiWjRCuIHye3xwJXLNJ/YgdAHpLEo3hWhtnY4RT3b3jFvBddJuBvfxSrZEyLzKEg VVvh9EC6Kp9f8RzxOC8Z/p3mqmPxqLpEU+d+Zl/rKGCYzlEOzijRNFtgC2mc9TODxvBTbNnH j+cBES4v5nopoXv8iJzcAcTPVCbgZ67GoXiIxpbhEcb6nQmj6KDMDW0RwmB8FVjw9BMiZaGe y16agZQ7ImD990ZAq6UYWKjrspfm+qRwdsXAa2bBw0E/97Zz77BrZ+zY4jnLYYgTrdfnmlGL OXUoRBbbUgNZwfvz4QO4qI4weJkr69E0KCqQx1cerKHhRYAVcyaGoCW3JSZKGPXqab/OihuO HD5LJhiLSguejmzVm4K+aPbt7tq7GUFA8wSveh2tghkG87mDuUchLJw91wHiLBhcXwPGMEpR EuulFAArAe9SQ5zzpfCtDH8Pe5UC4iTjVDYpzhKOVIxfx4gszMms8b5i9dXUf1KjO4RHJYop yQA12j04fPPyO5bW4xFGG3INEM5+zamvMfuBDCNYrT/ojrDpPy+6IxSU63HYyv/Qu4JfqelL XhcEhlMA51NWxCmQszZ/SfKVhhzuTovisvrZSxIsn/1bh/RF1sfmpv9jL3Kzb3Cu/Sk37Tsq ghHILD1w3hm90BWd2P1ToBJ06yE9J/zR7m7c0W6u9ISp+510+vkX3TjWcCzBSUaBsrOuS0G1 cfez6DYTEIG8NeNW+1k32k+/zZbdZPMeLQQ0vaYa1uZ3NI40q6WntdjUKf7+fq74CJHuEysz mQUb5OllEaTp9/SaUiua7xfUDrhwvqimwIjVdoSlLIcobOWJncysBZx7VQiAmtfKjuWcraxQ l0B45IgapphyUmEm6HBBc3N8+oTCBSn02mpRmh/W+zO86kMeavMzffv1+bfASaO8fXd+2+aH r5vtD2jMM0NZwCtg7+QT+Ii35agc4AI4y49c0q2QCFxwfjijncH05pl5PmFCa6ufKSrRqfhl RSUN4gk5K5LxN1GrW7g37Cm5+2PoXcZflvpGUX8zjRDei7PsEYigFTFWzWlkWMNiwJVDuG/P F25m0qhnJZ9tEVcBL86imVbm0NHvOO/odxwsxMJnsynK5WLNCKF/0On8BxzJtjjZn2fyH3gm fzZfNcbhL89R034/o2viPMHhHjgw7vA8C5ZvvzgPlpn+cTxY8iPsHVBeAsw7tLdzUjZrGa3R w2I+iU+nI3RA6MMzHObv4Wkw83Axo/KPF57x7Ov0q+2Tne8C+qHv8tTDJUTmehZ5BbPyfkpF KyK+UuYdrd5FSc78clwFPfnQ6jOCVXxF/A37XxUfA84ws3hU+hoj9B4IxgK7Hy19sDWwpNwP p3sHf9/e30PX/OOT7YOd3dOTw8MX20en20dHR4VwiPbylNc41+mUiNv40bpdLrbLTz1/aTSw dbEg7wDGAo5y+Jntl4YfX9Sc+WppjBx+MJniykq5ZcoEiNXrM4KOc3G/shdnaK7cT3G8ihnC IvuFlJIl8wxX268a535oU9sXtTScXzGwXuaJWGy1/6SOSL1f2tHnEGVBzNu/opkfj+P5CScL pnTt1gpkvpefwF2HufgOKt85C+yYwp1idghlv1xZCcY5c3984r4octvc3ysQmhY89swUwjJi PvXkMVmvz7ljzx83hQvNTDg42+2vyO+Bzu8y/slHHuXopkySK08iUw6zYC6czLvsJRwqlY8N H9ieiqPEShmuVO9z367JpqG8zMXa9TAVZDjGyoxEiuGMtRQhudc/KuO69PFC/CjAwB33nYJG bdo9Lt5bknTPGecXjxrFzyzbjxZLnGCd4QhkfNjoRVLFxxnIz+2YlyehSMtfzs7JSQlO7erd fcsUxQAz6WuABX7e7N8tEtguqioF/w2WVYa60Lrm90ZwyT08CCM78St/MTVvq+aePQhmPtMc +CxM16rQgI1sax7bhaG92n2Vg8ZxsfAkhMYBTv84cCLTgcrj6XBSAsNPrmvRSL9yKSz8HBUX JaeSAeok4dRYyExGeqe0gin8Y+rR3VCyc1tXwZRRSIIqCjUdcCw5lxUUeeY0omgnNgUMpI54 1S0cP+o9TMcFBQ6IMsy4Dsj/JI6ukqt0fCteP2HJIRzxqA4bKH2fjCmzPDcn8cqsIWM7MNLm Cln/9ptvaH3MRy+yDjw9vsoV2HTSIyOwksLpIT8Irui7r7YWpifewoMRy+JeqU56Isd6YSFr 91QHCCvo6ZB/Ep73pWd8AX/1jvmFj/bC4zxX0Tk42fk5noOnGLBoexB9qhusDQf12mr0CEW8 MvVukX0dmrXaG3drh54HTuiLfk2RaQCv3V0jeBaDaFsk8VOJjEVRP2id6xpQ5mZiXZzB2kvN TfzMFC9g+EJImHAdqzsXlCfYHfWITvOlCf6lWJ5fj+CTspT/2h8n9KCCv5xiTelqc26ycUOQ 0afnGhdW42S0+OnF0e6u7FfvJVkn/7mB7FGijspNXVJ+gvqhaE51irKFOk4mzwdUdTse38pQ euYL/n2fryC5pWTvqGe3ExCvHthGW0vTPSwbYFp+WhEKKvAw6G3pCSUnDLfStP+LU0j1iy49 8qmvZLO5W/QrzqSxWLJ7z1nUSOQGr4AMf94eJ6BunPNg0FsgHYb30qBXuvROC+h50MvdNorP mVAM+mjniToCZ2qTNNDXlpx6uWPSmfGM06/s5Pto+rKTdRRXXPPe9hAkRdQaS848VhysWVUL Acp78HndbIXzuDGFs+1b7qgDj/nCsVmPQlWP2eF5i50bW+HiByNzd7gdl7xkE8JoNOksud9B YZZM7sbCXiaT7yjrkdAIpvrJM6uLX085NxJXIliYJ/1P5j5Biv+2WrbnMBkqXSOJokyZWZ2U Lh8mZ3oiqMLvvQRKzeLF4WvEcRKPsd7MtP+22WjAja7eemcKdF1jddbx6BGWL8H/w/WW/9sw dw+uwYRZFxAatKMvUITRio9agZMLwdaiB0SQg7BIpvTFlW8QFgG1hdoyMkVgVacIBtoBqIem ELYByUyop/XGRsnNkmKJy6KlQZvkn9N4iJV6p2OnXp+O5YaK+OIw5OK0ZPHIhZGhz0vYuRSl zDV7bhKqGYyFpUbnw6nxcCcRVEthCijph4dmJjHES9fkMh6VDUurUVGxO4P722Ri7nfhGIdc Fk6qQRIYqVGY3Y7OM6IBrpMFQBGYW7WXC85h4TFbRxnh8IAVuWb4g9FgMoiHwMF6UjGN6mAr TfUH44yrvnG9LKxUNnQq7tjxcNUpoEwsPTWqLpl3aJOxpamgtBI0cL6nAJN/+cIKXOwD8YUN GfQdPEQVtTVkSYCA7CJRUtOXVKEAhQhs8zjyHBaswyBuLXz9HW34Cr/bhmtAEy8BmM7bP5Dh BVc3bgLQLJzwdd/olDOV8BurcJ6Yieu8tCM+DB7IUWFeEzJi7JSIpLBeMy8Pc2pHWQZgSmcN 0/SXKMayS/QrkmFJRTG/2BdAw1rS6VhklIzrl8pFl6jW3G0LK3N5haQIHBaHpLwRbskxzTXD JTAtK77T2WRK22X/Yw6ooPDTE19Cphs11YzJV8mzkwM4vMExZT/do8aTiPdzceG2UDgGWRUV ZeWiIj7NCTmkkH382L/+f+PG47sP6jPey0UX+iHg1ODpkyjn/Y+0A23DKDfPOlSQ388d/1OE W/hYR+08/ZhDQS723WGlJsSEvCEcphqK+rJUYYU8WSyJ1S2H65UV8y8Ag5F3UzZkVncSqvpV yVZyT1ytFT3SYSujSqP/Tm+p6iochtNr3cBIhG6F0ChG0cDP9xVGdAIhrlbLb0cDjlp2R7Wl 1qVAkaYNqP+jBIbGDLNwZqSOy+vi8qq4nA9zsXx3JJWggRfQMSLDwIPaVHRF/upUtIwFMRfJ KBmTOHVGtVzdgqQRl/sEXqQFSk+wWisqcLSMNdX7PbulkrCvX5Mxxy/mStW4ub4oFQzv9QZ0 rRgC5+4nk1vmlA1sbKp7e2M4oyDCq9QUguebHB8kUpoTln86JGU4HA0Ak7MAISiaZEOqw9si uFjAGHukzjMuHuzjh7fEdXz+S8KRXg5Ob2IupCzSTuYPiiWeklP0dQoPPk8P98efIwIvUHdw brfwMHlC3KpYrNhJ4Xbcg60LTASE4PPExQl+v+XiiN64k+Kq/CXrzFAgW/JFPXgsl33/fPf4 JukskmwSLAkNu+i7Io2pZevyyq9U5ZdkSvpNtKculC+sXnXHaucvxYe1HLKpPUp+JrPguSff T+jLtlPhLqgeJiI57Re2rzqadM2MliPwQJkkKhdfVTtTP2zPe9O2UkAiBR4O4WSouJn2g1vB zM6XGwJNnnZbloRZFNTSS4ETzXyTUqDz8xQoqrNyd6UZuG5GHbO+jGBEnb7wElpfGgrrfeoH Z7tJ4IM3HwdvrmiEeD3yqhpSBgMnoJv/1jZh/3UPqINSbuaEIRfDMS8UAvq4ZEHJTbMYjDiy FYBwaKOYXEmb+KSA7uxcdL1USxooTV2tpztisxNcxogEYk0hdrlRdwHijLvlLbNdQHX4ZtRL xleDkZbTzqZn75PxpLigtjz8Nzo6BeXoiAxNvzIT+DQnXw+ftkao30krwL0r5IrHBiwFXbWD tXgVj3/5g2SVemsf6bi19vliSqWCczP3M/TarjJs19YbGm/QjBv9NXCD9B05wibkbG/boF6x HgLAMstI+v/x5+d/4aeXXsWD0SllWEnGD4eDs4dYsbTearQb3Yfqcn/5WX004bO2tko/4RP8 bK121tf/o9XuNLur3Wa7i++14evWfzTvaY4zP1O8hkOX4zSdzHpv3vNwcv8mH9SN6SJjVh09 Ds3lkfkVcHrSn6cjuCpGeAsaDy4uJ1Flpxq1Nje7dVixzQi5b7SNlmB86wUZoEd8e6aLL4oc 4wFcj/GWjYrPKan6k4SObYY4SieDc9TvUOVczLUDct4SDPOH7aODvYOXj+D+ijd61H5ll+l0 2IseQJsH0Vlirvbx9fVwcE6X+awR7QHzzdisMZ7o/Tu48su3bq1Y6J00tjhObg9H33+jNR1d xSjfUCPadnrS4aSj4S0ORSbQMDMgJCbRweHpy5/2XrNFCnscDPFqDmfObTqFm/qIegBckaLL LXses0VFHBo58T02hSkbNVIjsh3QcBQvADN+n1KY9+gX6nBEwHDaY84Sz0MaTNhvDdYiSXpJ DyDiUmYg+qOCm9AySOByQEPTQRCCLrVH8ltPRjgDaI/lwCVfr4xt6S+RokN8auVcRzy9TmEF WMnHNHjFGeyTyQ1alnxnP9JTo5MVQk9G0yuRML/b3X5ek2MPifyRpwO5ii8G50EddapqXCtt QaWDiRrYv7qC0ze5trDc7IzuAEV9oRNSQQetD7XfwtYcpMm9Yv/pNeq/8Gl2m02SqwAYlS4t nQcDk8M9bHhytD2nISux/HZYl6987qKdog1LZcv8xlJrrDazsRZf8ptiTaXyfp0iRn4zrpBT K2nmOBE43qhuW6dLt2GhLxTTqBtNg4rR8kGTtyBfva2ZFk20dVx+slMEsJ4fujPJ4iuyTcJF 4xfYnDwD2PnJh4ERQVHRnFMz44fVYWWIkTzldGmrCP0gNSIHY1bqJZ4jp0KHmB6mPLoIZEyS VM+SIV7hcKzEMa19Bpl/AMnFGELyEY8qLfhFQpeQPbOWoLjoC+VHLyVzv+gGZ9LW3GEOEEmA XUK2TmZgP0uwNy3O7FsrhMANQB5j47kXQl4ETcZ06pOWIhyeLI5vAWU40qzBPUzSMx5THgCw kzJaEtQIS0Gla9Ac74/lu8THRkFT7XpG0/K+6VJk6SOgNiEyViJaUnNNrgYHeycuEucAuhkP YG9qIhzljujhXUqrnXYdOUIBn+KQkzL0S7vCQwCjGxzMo9iXXZLmjzyfyXcH5MRxgvcGTlgx HU0GQ7RoJIY7PbOHL1dCATJmLw32k58P4dXuqxwE9+z33O7ng0PzjAMODfiGsd2Ozi/H6Wjw K5/PxuCfN9EBsI/mJo9SyZbas6JjkpOBpkaZCLwqr8Rn6XuVYeqsX6hcpbD3+Ct0buFKMYA0 ZGMwc2TRZmYoiYFkdTNi1jIE6WtyW2VAr8fpObrl8GFnL/so/UT1p7q2mHUEpVH+bRzfWG2w vAHvkvyDv6Asgz8P6S8SJ/gXEA/wFzzv8acc3fBrXrdMhzMBgzPKdsaDgK/5EMbheC/I1/JC vj0OXb99fkjfH6FPEwh/dLQR1858pQd5y5s2+JvYfbBzPAvwF3KNh5+04bzm8jLNF/3k5Zfc 2KgrAgdP5Hjgl5nPy9enOZYtD/KTYVUrEDUX2QoPp3x+LVko5r00q72THIqdl/EtQvWx+Slf sWLIGZjXcu/EfaQ0KNcSOywOT+E3gRtRF8BdzH2Ir5a4bSfwD4/qYgkfLiBwzxqnHwZX8C0c Xa3m92K4RFCFCrZ/ucZt2qq03RxPHzQmsKXZu2cY2xh8j4JXUYUndMERu/U1T17FtMB2DzDQ rbIEBvLgJkPCnY17o0ZftuyXdMdywKlHbIHLkg7JkWDFjN1zIdA9omBEyGSdu2b+vtNE4LyB QzclTGeylQOH7xpw8Qd79lb8pCl5eKTapRNny4EHs5nA/ZvqzcGhi/eC/MnnwyBPhdkw5Bym SDQFEvr5BhO7oVNGXblcrAElpeMrPkccaQCJfTggYd73ULfGWrJ7hBgcpiDzU7E4HOk4+ecU jiR8WwLSUBbPQSKzbwjJbYG0hq6PsJx4tkyzWeMih8MQmiQAp4NyMHJj5HLtyUmvZDQs8sDv yYdizzfXuO0ZcXsBPms0GVJXBHjH/RSfn0+vprDF03ExmaCf05Y7QL5TzGubX7PAdXDAmaOX B6PlYFh8oyKpEbeYd1dBynTESddTEd3kQxoRidGK1ahpQ1FLpdMQjiRtCOCY3UnJjwLJluIa 8zPg6xHfAnuJVUiFPXICpRBRjgheuHR87NH1xyllqCnAjQHfT7Es5tEtgUESHPk601D92wvh zasbGUJTI+lWKTTvLpIVrVlIJUReSPI0cxmRe5OxbFVy3m3NamzsuD7yFGU8UtLvF62MRVYx Cc+7yVpAeT9aD9BCMHAuMwYz8xZsoOQ5VumUaHdSTvx3HgXQ2hdyLjJ3WzdEvr0NRrz6Fopf ToC76LSb74SOrD8wbvz4Igm1BvlZMSBMvP22vbGhgPDvKB4nsQVQvOC2ROpbdj545/E7nocP w3oAo906HoVINfTYj/rxEDX5yJ1votLsUw445DHlUlHGPAipBmWq6UikLMMDSS+SO2rinFhD u4Xc/h3eSHkB6Cq39adRc679j0senH9OH7Ptf532equVs/+11v+0//0eH7b/ySKjtkG9a6Pv pv3+VQzCHT5jZXy/Pzgf4IXJGn1KjIGt5hc0Bv6FVeNJtPwrtB42Lpedr2yVjmV4U2xMr7Z/ xEQiUau7JAHHJF7q9dB0CAycov+XzZWQ9oEzx6L5RctbrAXaYxMe2v5QJKb7j5oRMdQDbx89 uKvWyK/4/JdRejNMehdk2kAn3WR4nl6hQ4zI1L0UZE/XRgnQxwqkgd2RGAltMLIrg3ew+/N4 BHgjKIyTbIqu82GPtWhPLIQxXK6T8wHpr9CtGIH8kiTXZGldipz1EGlQhpd8SM6nfNyEY9M7 PiLzGVVvicn3He2sfLagiZMLd1MImV5UYfDpaIChV0p/+A5lzTi5DA5+OPf4ZG02GnS01Vvv Gvweu1ezvJZRnA51S27RN1R8BaSoAVadQCDQvv1feO4A24v4TIXliOl+whLueBzTZTHGsxzO JIRD1TboWDYVXtS9PKbWejYDTLLrSGwh/S5yCFlgU7SYGq/2WiS1GNk4AAtMRT7cwMKa3N8y XFo8GGle9RaNehS51XpqtLVWWnCfj0fiNi7eh4Ns9C0aadPpxWVDioYiHBuLeI2u35mNWvRE HyCh8e23GfrHo8kcIPB1J7MBiXpdRd4pcokVXnlktjM2O2NH8flkCgSArQg/QUOMGARJaDAc Ag+hmJ2B+tRThwjmglK5jDlcUcaDNz18TDSUUivu0wY2IhRaUX3P8Yzf33t2undwsnt0sL0f VGHBFaW4lazGMlaNB12TiVK5lCV8QmuP/3FCAVmy08tL5gYPctUfK5Lyfwn2VhB3yH6TRUCx 9wWj3mLq8ttMpSUOjSoQRm+vCkUtXCKVsKUSbq7tFUbg+PoiaAvfDq6mV0QT8JB+nykPI3XM kvKDW5JDgjlNw3Q8vgMkVRoWA+uN01DdR17LPTbrEtuDV5hxT8/qHhTSOWIKuGLJ2AlKHsO5 9kGunHZLhoNBXlQyGNy9A9HeUFviW7mrFPDgPACXM+eawKFTgE22056PyU6MRwjzpmLVTx+2 dh4Ev0trmYjTDVUg43nk1To3BRSK15PcQhJpEDfL02qchdcUpFX4lu/tAI5au5uEsELZ3wsX cWKZJ1/fp8aD6DOvoB4psZRTxA5Qn7ilsEi5yPpTbg70ieLLXChWo+MrcoqgIFkno5ASzXzw TRoH7n3xdSGzHPKP6Cn5gBTfhkln+1aEu5XWOx2Pf9cnaTOJ4XgWrlYMDLViISwy25K2zNkp JArnwaHdgVRUBSgb4vzedloYhPkvBLpvtSEZ1loHAWSjy1hw1DidWrRai7q1aK0WrdeijVq0 WYtaTfjXgn/wtAXPWutcqbkNf7fh907LJuLowPNV+L4L73fhnTWEAn9vIhxq3EFIawhqE/5s I4B2d4PTKnzcmj8xWK/58+JFdSbWWqvN/rce/Nvw/lk4mzXvX7sZ/Gv5/xD2Ok92gcn1eNXa ZnbPfV0fio2buUXDrmp26dZ50To8kTZ808FnuBjw+yZOrk2j79hpAeLgtY0uLhy8vL5Gy45t W90OQmli+04Tp7LaRBhrrdWubb+B0ABue2OTVhchtVe76+sLr2uP1nXOzOcva7h84TLp0rTp n51/R8h5Vf515d+a/Funf/Z9gE3/Nvnf2ir++7gV5iVUS6W5i3gShpMBsOwaQpcLhbbIXWTX 4ROUjCm7hkuwitQKSUUl21auMd5Ji2KtE/oqDjxZOtaciiE4eEe6JvU9rywlMsBgUuS2IHrH A1O3Ujgu5TVRWKoSzDjbBuUl0UnzIEfiOdtL9LpFb6LbG91S3AKcQbINEsT7vtQ9lLxCJiUk yzjjhFyTL+zIjDiRGbDk7uQCwAFwY7jjwjnCVzMbk+vBgn2cia8rXb7FCs8GvZqEzdIhhwDV YgOX6pt43LNTRFTDu4MxpyYZxXC7IX9qGr0dNuN5oEuRpex966yjMafIlRm7RUXdRC/gw3h8 kaAvy7V6d3EyTO6JMKewGIHStTvuhqm2SpHS43Q6QY1JnGXTK7zIoL9YL00yKbNKTkAcfAwL LItnhUmFJTp17pUvZ1SgFShcjlihcEroAqiawtJjn2hXhXE0FFDLNOAcLnCpA+F3ogsZT9xt 2JCcLs5dF//j7ws7m/QcREAeH4ad03XPIsMlPdxkvOnQ23FKGy4Wk7GRMgK5wLAnYirGiMa4 i4zaxJiUVCERihcDjyZkJHK9lE0ywhVIxv4+zmyOIlkCbquQCISsgguVNFFoZnhX451MI2Yp 8yzBPoyyhuPvCZhZSh+FhvVxmtex3DPI/w2zukbX0/F1miGaSf81hDtBA0bVR2ywU7mCL7oh OkYlINUe5i25Yn420KyxtPlHty7TJoUQ5YklelY/sFjM2nI2CJNjJKu/WIx2frOnJsH8SKfF Y0ic2x0a3TPe3cYsU77NhfRRf4Y/8VauJmh73Fi2XJGdarbccCi5qGTfGO8Kqj2leUQoZ8bj J6oZpb9XVqxbGIvW8OU7m7yDAABxMQD85bGoKPCPwtbZW3jy7h3m89HZnFHiKvfwrCFkoC6+ o5M2DAlPrGqhBoDeeqIKDzMudDBxpoN/PsVIQvzNLQvOwdg4PHjwjvIterWsqI4tdvE0oho9 0h0qLMxz6ovLf0VFH7yCpGYbkikdc0kwz3TkJa0qlcvMsraqVxmv8vZVPP7FxisYCFIuOIDh lBk0VR3zhc6dvCwPKqxZqlIlgfwNlm6+vySGeU1SWbdYnRWdgRUAs89kwM4IRQfYNLcuiz8+ gtB9le/LZregg+Y1ijRe5x8dkqC8JUgC8Mtj1jnBry6hOtQwGM2ihsfY0lLDYFSUbhMQgXme 67D1s/Px4Iyd9jCHOrrIYzCVx1ps+pq+k+HQ2aatsm3qRFFTY0wx5GDT1sjQTexH7HMbJ8lf veX6SIVz8DBr2j/lNEwVTnD8hLXWGCaLuwMQ2armMjo43fgfInQPSw77MxYpexOfKHWUXMnZ LMLnqoyervetkJv5eC7lhtQYX1mJCIT+/Q6+cJGsQ8a+82J4DX91hWxlcwXahMV5LS+IcFqh YDq/dZCGB78r2P+oyQ2vSTsmDzqp4vA4Cc8oSdqHynOQPlnuFMeDxDm3sTnqBOnEZb3VqEd5 AlH55uv0jXmHhQySEzCNIVyBFByJI4InTh14YiRAkuBGGJousW4jBX9LGtdrBIq/KDBiQoAj FWLP0skkvZILgFx5SILAdfesBKTAXaEpGCFvQkalCTxwnlINspG9M7gC+ORyjIYXOhJIAZdJ VkLFm4NTmrdqPdGdiuVtK2oRW8qlrgwU1ySFGzW4pr/EASYfzpPEXmHwpZqVX3jsfDXusU2I UQyYNTBZock3P8G8ghP8+spS+BJXtiHXDjRloWcr+ePAixRiqWyVJKdYwWHokiNbmZBDEqQp WpFWACDSXUAvVZ4RykyVaY3JlCU9bUyvU+MAEW4TuwKEyzgY3EAd22oaVJmg/kHyAHI+wUtO yekKhKFWwsqUNySKow9nQScNV+S2sPKSN+5bc+lk9vUOwcAmN+QZZ/b6o7DokpHoaI24qo8J PtqNyRWc/XdMElKr9saLImUyozSh1qFTL84KzvouT6yem21/uNeROmQ+5F2P0yFHdl0qTBGa Tez+FL++GNHBFtBT01D+JkMrYvxiCldjBSHBvu71lq/Z7Fjk0BWtjOmlgVlsE40rZk3FYGTd LcwacYQo8QfjPWzRirzf0XW4fMNISKosIVUAE0s8kTuHua0M1dfReuPBUS0XLvO05iyOcbuS bWoZBCsJrrEnmpU5uwVGhgyYb3g0prjP1lhYOQwgwt1joKmCALU/witCzQfxlQJRuOCyJBn2 rCsbiieqogc4cNKSyKIyFNewQtnFBi6QSvdJpMVRyYAq4HvTq6tbZtj1OntP+36raK0AiWLT SlyOOKnlgPJ9kYVgy/8WJLh218kBqeMZeuXt+NvcuzSMdnetcBxa5SVyPqjlJfp3JiOD6/mD 03H0/HFQj1rd3GZssnl3JeCDLWepCWvAc4DFnPzH9bl1zY1GMlqkjYhcRtoeiQS/QFNfKJNE SGKAzzX1LcN4PRLpSa1pKBI8KbJcFzR3Dm9pTidTOZ60uW9mRqZKM2ELrGNuHfqpwqqVeqvq 5pgdDy5Qi+ifaDcqMjxlvqemNNwEmskpmJ9Y+Bw2GdhsyZz6hGHUI/+K4FpbkcfEpOQacqCB fwGzFlHnvDAmSEx7rDcVYvtwdaEenz5xT4Oqm9HONOB9kW9B3+evOS17EbhWi4Nhvqy++iUp xkVBfXCcIAvkrul4MR0A3W/qRApB0jbOAU33BLwdVOF6ARs4TN1WqqAIiok6CgYDsignrEka nev+6Z26rxALemvav6uWjodsePbF0lEt2nOnDcL92mrVkikawDlNQS7UPBhL0+3dXWAj24t8 5jqo8aUHKN5cJdgIA1ucOKfTHYoJZhsWrz2xJH2FPF/MI1aXFDhf8Bgp1knqHEPfxAs9lwP8 5ApsUn/1J+wW4j1BAG8rNIWnT3mYgFl8/11OY2SKcBI4uuNueQg05gzHviJmHg6RJqeMBdDV cnAlfVKzb+htP4kitX/61FO9UGkT/J4v4gFVESRGBrG6/NOVEFU+meYbEFW5qOBYYloePvhq WsqMRH3yU3OxQOoEfwL1esVqNbQehD8V0TrgM1KTFhT144OWFBDF+6+AxQX3p6KYLu1ZTiBU QckK4UlBNSxht4TjfZjLAW5DtSmSz17ygv1LSVLp6EU0eI/wI6cyHXpLuS4NMV5jIANFM+T2 DH5ouVbyYgnAIB0E7k2QnVu6a83x57xor4k21qF4l+JHhBHLJMLFI50k82nTbcBmZYMQqBXG xOOopLK9r5N0mrzbyr1rdZShPjacQVit1/QUaETx8zGHMatiYC9YX2bQDx36K8U8U0d7Z9lC P3eWMfQTyBrOrEhDI2ICkI0jeLl0Hs6SxUFnJ/mTVHX+W3jvXeHJmEeM36ZYQuF9U96q2GpR kayj8mppulj9/oUI4uaOabTG4dVVFVJ0QUGt1OAKpMpx4LDBd1rK60A3esexkTBoYyPlFDd6 C7bW9Ty7tCgYzbHubA66SbMhk3Jycc/CFKkMqHRtNROsHrgcXFz6+tUfjKuGXBQ8FZKqwFSL oPBwEJkJCQ30aM4VB3U8nILD9cqkkds7Ov6YZ/MKiHmG/etOcu98E5h72oeHN8d8jzj7CQlk Bnk15nuKobyfMX7MGaLl3RY5ssx9r+BUzW8b/26al0CLEWUKGTjbRiaMAdBF2A89TbXzt64o Z0W4P6U0I6U5OBZFlcZZ5IquiM5zha/F3FTNpnbtjdX009OzLhj/91kJQGfH/zW73bVmLv6v jc8/p9NFP3/G/9lFxvg/SWQhHtw2NrA87yc6Zn7ZgL+H/xuyfx6bInm+G4MaVMlVlKU2MX2A SDAgFbpIHm5yESsC9PhYlqSQFE+lcVdioJMoOxY4SCYQAcTVKFGkGfBg03cspr4xW1NJmY8A 5OjH5gwrY+OFmvW0R5gSilAo/6gtwoC4VDXWoLgf49+m2S3oV7nVEAgNLqdQymTUq6f9Oqlf aB5BEJwYdWMb4yZdqrxzQyXtzBRY9Cs1pqZ9nkRsTakM3ozQGV5JB7QUYR9uHEUaXWDhPLGb GJRKjJ1iMZ9rxPgy4jBcmmcqEL1wykZ1NX2b8lfQAwpJfiAeVRWDlpIpR+w1aMsQGM4yEbjY 1pfxcCFGaFEioW5a55FTnZuAQ8Wwsz0GmWDTpIDS/K+SCiqIdaNYXz8sC71cdMPUHLzX1Iuh KOqNi7F5+Tg0X4EiPofw4liT905SIhtjYkUrNV6ZzEYf6W/KNofUKQ4DcUZShE3/K/GIVTYv yVHURDcEXh/z9QQ+8LWktxyM0KkXvyL5NEeXoUVCwbQS+LCTQ26t6dEMCmcYrZaO0FWhyjMz encvG376SnxAOaWR2A3dpCdiD1df0SABiKlZqtuptbq66sTxksMsNIP3N7ptNloxEh+6Xqd0 QHQ3214uGARnb5OJhlhJEU6u3AmLlny4jEH8GGC1SqpblmSSjElCoi9ALERYyYcYD6zsoQTr ntsipCbOXE7XCR2vMvV4fDEVq3FqDgCBSy4B/uIYc/IM87axNSMoRa2TTJK4gfCqZdGqtDfW os2o1V0uxeKSEWYz8xOwzp0pmE4zWjNQgrQ72ghWwsSKlxnoK5tIqWtV4SMWj/1BH91XBGlO PdRgd0ne6YFJVAcLQnLCqI83nMY5F04NLsvUN5Mayw89W0I1s2QqzsLq1YLnvPjEjhPo95z8 gHuaClwKy3KKbUl24Do3ABLD71nRBIgKHkQVp+GKp32i/XbihK3TiCis38l8bNDzoDAhN0e1 068U2U6/EXzhbhwWPS/YOjp8Ual4odS1wgBFisbOac28jx9nXXPiLp0460VhmCDs4uFQCHj1 f17Cmdn3P3z2eblf8DPn/tdsra4F97/Wenu98+f973f4OLlU6L6yzBsQF77CihHZfXvATdsV DB8k3Yum6Ay/2B31KvzFPSgn/vx88c+c/Q9nKKa3/JL5n9rd9XaR/qf95/7/HT6SeoMXGfU/ 2UBCjSitqRVHScgs0JCU64XWRC/0tyQe1Yfp9Dp6GQ+Gw9vG/auHEKJOg3UKFC2GN9lCTQ/P bTIAWfS2oR7ICIS0N6hRYIkb32cU0PRZGYRZczDCcCIhKENK4I6S4oOoPx0O6/0EYz7h/Ces RgdphJXtr67JAHQVyzU8gdGRKYGVWVTJg8YwHFxxqnaslkGie2sVJdaNlQ5dQeFWnoxBzEgm 541GI9ql6BcTycbzeJ/APZkAoXB4zMo8gyHO/4+38STDnrboMT0SR3GEMcYRYnzCRQNTD706 fo5lSvBNap+ObE0P9lLBgsBwwQPBS+oEkWwYXQ+uObWy1YX9Z+Uv1ej/7vX+b5jPS84g883j bNIbpI3Lp0tab+745PkOVo9x3kCfMHzF/7ZHsJ6awjLS/s3x7umrV9uv/bdvs4coSmY5MPDg 6ioeFX2P3oxBB1LTplchZKHB13xzeNz2/v5h76Djf3N6uvOPl/D16WnV66t/PpoMwwEwUvAb ntXB892j051d/KYYC+SgCcO0hXeOd09On+0dbB/94/QVyOboW5NUUaGAa0V/jVL+shYdyptV qdk3B0qI9L+/OnaaTEeocYC/0OzqVgL66fT4zYsXez9Gy/WLX5cViMA42jveOSwAw5WWZ4Ex T9w50R/1p6en+NPpylmOVz/sHn1/DMuBFrvTU6wfeZpmqCM5PT1L8Nf89zeDUacNf3mLNR0N PsAiaCIcHgZd2RzS+Uo7/un0u+2/756+OYC70fPT76h38/B0f/vo5e6Lvf3dtdXT48M3Rzu7 VVNciWiKHC4ZNfEQ9nCPvABkH1H//BpppnC7Yu6t0UTb8PXKpMh7gJcWxU4BoSvh+STLSZl1 Nwn2rylOr5JVo2t4rn+ILuea+PIP3E4i+kQzAaOn2o+kH44wXAAWrpdQPP9Iov9IG4GhFReJ m1ZZZFBPxTyYoHbk9hqzOwxvWdnB6hkEgvjh3jAVH/vPvkwm+3E2IUbLfvkUM83dOPEw2SW6 eaJT+FkiJZ+sEt6xStCVEoMar+JbfBXj7TDV3AQd/G4xO8X0LEMlPsyOygch7MlYkeaOQL+z Fc6dWH2KuPcs/slkItFZcLB502Ifek0JQivvgq/QDzGsPv/h8Og5492W1bQNz6b9t61me1Xj 4W7w29NJ9OAqu4BnbLpkGOgQlZAfkjuYStV9B1uj2fMF2T5e8SJXXhwevdo+OX21e3y8/XL3 9MXR4avT438cn+y+Mvf136LgJSp3jGnnnwF72D2yN3us42n/oonZP+GGg67x7DEPIx5dTJHK HAt1Zf/13w/3nle/4Qm6Tb0u3HLQNKkCN4M9jVvnVH4/j38emdwVtehX2CdEv4FvAYN7+iRq e9oKYBw8pLf8Qj3CjC5Pom9/Hn9b8LAlD0ffhiZxeQPg+8ZwF8C7UgdXZ4RSazmqQLNqWP/Y 9vQk996n9Htznk3Sq7MMgdSkTU16WPF8CPaRqbwYJ0mF3/JKCgfuwdk17PtJn4EuT0eYU3MU Ed8XvlX5etirLtf4r6pn9z92yVyov+oZ82mHfDRbkSr2Xdt9mPEedDl0ppuQqtbiuj7IrAtE X4YLBwCAgBF/nT2Kvs5+HsEAMVDHbvKKuwejSlVrX3seDQXgGNRsODAhPj2QxvXMEOGPzy5z ahef5A1XIFDRg56hvhLmzTW8TYtqvVW1+V9hw+Nb9MF8SKtuZthTrGdDUJBrGZkFnhzvvjxd W/3eGRGdPsLtlnjHHrAlllOWkRAvLtsofcutA89fdBDCUbKuNpCiCK45YHldUVEPLJQogFff +YTHNNAt4plevvj1VC9q9mUUGeDXB5h98eLXFyi5g7xOp3sgGKMw4MI4BQH4eh4MHrl2Px25 A8Cm8jq2VCjSlNqgSHQatqGZRQ/wWU2nCaKp38jtKmiEL9JkqDJUiD18Eo8vzhU0/P7+7Tts gxLJk/v74E3o+SCDe6KWq1JJhRPeDSZ0L7LrjEwov83hS93os/Y0Ug0xO929AL/S4i14//Pa UdxzwQxrJCbLxvkQAxnOUrnkZnIBDIm0glSB1EADtkTGE7CEptPnTWhkDd7c4kbMKTRH9o8E vVJzNB7x3j0Z35pcVKLZoJIiGBoJRE8plon6+/FgmFFGiYHoRTgOVqKSH9Alt1ozqZ9HKKwM QXzE6F70p/SdIJFThzvMYIFrix9+r9kZzO6ipc8HCLFHIHlqU398MrVqcobSEYqpNoMIoD7T GnwfnsEiqC8TtOXA59vQk37x0YMqMQHWa9t7evErlXypwDQxrQcM08afQUv2hMSfPIKLX/kn vf4NHpXewdwn+qqYmXEP/CUh8itFpE4IC1Qh6dE7y3Iu+aSBZEE/QSjPyDvg1eBimgyj7SHM 6PxyEj2GlaVf/zPJ0kY6vniqag0kJ5eQ2I6K24E0JTFWXjxPRKPEBHakNe4Pv49wiSlMQbM6 w9dwFzk45FxJN4PMyUdcSj4LbqLijaJ/AE44FgjvywbB55jr+ZR8RTQeFrv+Fm855D5i8gyg M/TYm7xNw8EATjkDMSZlNZbjAF8msSY5deChG2VnNrbuuYl3IFu94wbAJ8bIHsw4ykfu5usj tArMEugqO6t6yVAE6TxlGSlKpGcNuOdTcSUDRp9ynELYXgd6kN6ol5Z41HjjASAYkIprWBEM V/HWIcBr0eujw5PTI6pnDIR5evzdNpVppdFXCKHVZtUbFG5BAwsDO8sHZzg4Du/mMh0mHrGa UTISvA1cEQ1BsJFl3BqhpVzhK+FR+njWHqeGV9MR4oSgW5j3tPGx2djuPeQEjoCqvED29T0f mm+syHKHYzMvW/lb3khYWx4H+Lxzc+aRc/ErHTc4Clok57wJzhrOrtOs6gVJFx2bunx9sVOE jzomRD3rvHNEzlE9TPzTzScJBrOcO89ssqO+pauQnvqGnHJkOBgtePx8SaGMTB2D9wlr6h85 6U1NKlI8ieBuJXueVGaoTlUbQDoeXAxG8dAhQU9UrzCrJbGcjwgrfm+5X3Cx1BwdAlbx1bfu NeydS8CFJ5i97U7GsMKi0F2J5E97CUSViFCl9OQJO4VyNB16mEgUyxZhqlQjVjtE4klBcreH 3s+vb7WjGgGSN/ARnDfmkR2hToZCb9NrmQwMZXy27HC3Ae0HUiI54xdBzemoYGz4X7TM4H6l DswoaNVsH/RSvpNCJJ3HaAVjgP7NQ/E8czxFwr9ggtXQOqcvs0EcBuxvkWAHlJK/w4PZ3pEj /UKOW0DlfIQORrwiDwR73g4gkne2gO4IJOzTifBidycEB+/sfUHc+kvvCeLSRWN76ipxvvmG 3r+6pmmsYFSQfepumlxEMuNPJFY7IsEmZgFQvbPzNUY31zuoPvz25+a3MuxQ22dB+KBNjx5k 2ee6nO42t8Q/GNm9qG8utN3vuBMZ9iKMoe/zheUbbzAlfGEh5qO7vUBo8fe7GewX2vGob3kU WRP42/r5O/hPD//Tx/9c4n/G+J8WymP1TfiVpa9G4x2CiKL6efRIapaSRQaYBaaJYtFNXunB KxjbwZOVL/vwpeE4pF346RQ298kuyPHyymXBK98B7bzaPjg9PNj/h7w2LnjtaH9XnsrInXfI USN5nwxZ82Jcu1jxhSqvqpH48DuXKbFCzL0voiMGU0zTCoqytPZLYVOBCPDgDBkILT2eO2+x GGJ4bl5RURAgv7XICFVIywCbBtMUpkmgmOmNzy/HFXlYi759+K17EcLXVBNOf2i4uKPSVlhe B4iKep0RZHLXIsivhEHJZJYvpiOgpmUTn22R0bI9Fbb8FRiFbWcx60GgpxLgiGPCpJt2D4oE hFBpsQBq/Xy5GiQqsKCNEcUMKmzdy7XOTWhG636utS42c9n+t3NBXM4BcTkfxHgOiKM8CG5c heUnA1idjGP6ZesdnpbftsIv4c7/7SZ+6d0uosi8w7a2gnFQWQULyR2OedfLeRCSI35nLyju 9GBM0bclM2/anUG0FB6ioScHugy4SsOC58zH9QWELPQSXrrksLz4tWdk3FEqPXinnwuLG+nJ I5coPe8IELk1jMK2/nnDZ1pusLmTfuYwsa3hXZ88VGhfMFYzUpqMd2+wC50bLmcupq0dInvu QlmVbS5fz4w1nNNrDoeEQt2W+RUuRV/hWwT5bvIPb7DiTnNR2u5nIfrRTyEdubhwYZUN6aP3 TSnIBbBPd4YH7n3SX4HSJSgWOcOPCH2zUDsTIfj5pE0WDvdOG27WSntyabD1vGnlocxfen/h Z80toACHTdnjH3h/LarXkXl7QvzneNrP9v/G2G961PhwNfxkH+M58R9rzfX1nP/3eqv7p//3 7/B5/FdYWbV1PVluNZrL0V+fLj2+js9/QRM1SqtPyC932X0LiGP5KRHfY42Ud9/sDYN34Rt5 Ds3+z2Ng0MBJJtqol2Cq+Wv0lVh+GuH1rCgU//FDbVYAQlwP6xMsiTOp9wbjZfbqe7L8fyv/ +Xp75/vtl7sPMZ1vPBzW5W14q7ocPXy6BPC+qtdhz364glsies8Zv/GkF90mE9h2BZ3iKGFz jh+eA2S4xiamz9skU8A6MuMs/UTdnKMMmDn8eT09Gw7Ol0kf92R5bXWVmha3PE9H/blNoW2W TrE0A7eKMSlDp904R+TTorH7ZDCch8VPtUsa00MG/DTsQhfsi/YxPr+XSeQfM+R5/Yvi/ouM 4OLXi+kkW2AI2MkfOgC0+fyxIyAVzB85BJHoviStS/WxLzJLrZpe8li7njdESQzzhw8w/4IW gJ89fu7li4+/tH8TPP77Y9Cm/Jnxxmwcwwv9OJssMksOiv/fPss/bDuE05w1SJrM/4Ax3udS 0KsPRUoE0fWhyK4gB6FUt7TzYn/75fGT+uHSX8yvUf05GuN+wGo/T1qr8uer3Ven+7t/391/ sm7fvYCHz3efvXnpNO9E9R8wMKP+A51FdY4FyeBvCTSBSxoq5+s/cE0akmN/5uAs+dR/wEbn kzrIlJOUgs/gu6sBeY45Xy5Bq8Nnf9uOnsAvkpWLPIkyTuz+iLOJ4ytPruLJ+WUjXfrLkvyG D/GX46X/838rO69fV/Xv6Gl0yr9m9GinitYN+9XVe/0jjRTq/xlfoSnDvIQi8R99ffnz85mf +ff/7LMTQMy8/7c6zfZ6O5f/YXX9z/v/7/GhSg+0yBj8LV5oImD1ol48icVd1SlFTCFkJVHf BfHe+C7mpj6fnCK8U2RrlaqNWDOFfvowkOEthsDtpBlmvD4ZTycxRpE3175MzHi0vf/y8Gjv 5LtX8BcbUSOOrRMhEzUSpojDFOuUZsl7TF9k8MHY40xT6TgxQLDkD8Z98AGsCbvGmMYHL8pS hfdWCh9TXrGIg/7O2ePPQKLMZ5x1Z8w5taT2MPqfG00Je7pe2QRWg0mWDMmjODaDBeCcdVBr ckmRKczaJBXHNDkWnWeVAcVxx9l5wq5iXLYOh+3Oq6r5pti71QMRjyWYnGIZ0JPXqfVkBiAZ mEQIUIzXMMMZK4fOsHDtA31PazNn18n5oC9hlQZpR7svdo92D3Z2j100Pk/gand+WYv2G68b teVvnzOMb427HIzrOdI7BxpGxy7s5YaBs23qjMBg+pPrxnTaGCWTRw+vp2cPMYvX4D1M/OGv g+uHvfT8oQwVGGqrAX+7IzrGZRzXor9RBP227YKGi0PZsWqwR1H0Kplcpj1OOQboTjFp4/V1 I1rdrHebfusdKlMMS3V8PkCKil6PCZ+tzY0NzE51/OwgatbXW2vr9Y1Wd63e9SjuOOldJDcD TKZ45MPdHl6kKNlcAazr9mbQ63YPNmQ6qv+QZMPklnrrNLQz4A11OAbW2/W1skQA8IXGZb3c PTg9OdrdPT79LsgRYG9/xndfxDMnAPkcmYwbnP8lvCylzhdPxg0oe7Z/ShWr17HbZwOnTDDm KqNa16hj5LJ7XgvNO+jk5noODw93vsdaTkthqRHJpWZSDZpmR7uvTzuna7wsLWoIfCeJMb9n 8n6QTjM3aVunvkZFEWDDt02OSnmf8vVXQ+A/AXRg9Qh83QEec809AxZeYbhRpbMo4FbrtNXZ AMAbpYBbrTq+oqDXZ4AWDzyKoyK3ZkxAeDrEBm/3dw9ennx3SonJ3lEZF5t/M6wo6iRzfBL9 q1nz/9eS/7Xlfx3536r8ryv/a37cKhtSj4b0fM5ovLR3+fHoGLRv7HMN/rcO/9uA/23C/1pN +n+L/t+m/3fg/+UjO2NsAYny2EqGdubTeTmywv/hcNfD7qcIcXhK543tWiC21mqt9VprAxpv wMw2YYYwpS7OaBUnhPMBsK1VREgXQGNsjn/cadpTP5cjlnrHQHlTOR1lDKyKGGci9MDJdBaf UeKYGiUkIKdQqiVyNaDoeu9cQ+xMR5yZOOit4fONZ9P+Kacn3IBu2g/EPZOytFdxAgd+qleC KfVjzwYgwPcbUYV/ia5I8DlLPCsGp2ShVL1UxbS1JtsGhZQrk4GmUV36QmEPFGRNImVDsmJy TVQtD9fTvDLnSYAbzBJIFEBuolG31eYE6gmHzw40tU88Hse3tEdOpZKsVgpzU1Y4RwvlXzG5 NTC1DKF6BOC2D473IjXwZJSqAXl2fH6eXE8iTZjtsBiWbiU2+HSIb7wVul1pvzM0KHHdyrnx tUZ0PBhxDiGHSqRk7NV1mkmqSC0CgcikvJAabSXdyLZkWib66E0pR8VlEl9HRv6i/KDfpTco yCIoLbybUaJOFC7aG+vUuU0yzckeY/S2SEeYOYNl0QquwelkfIqLgLAI41VZvkLE9AgxyudC tBj+xnipbJNEiTmZsCDd+4F2nBHCbFW1aUZSZpeLXQgJIw85NdTw1qMi7vm5l0WUpXiOB4XT VoV2GyyhiYl1lOTf2YkaDXh9Q1I9x/MaY43gDZtI+gF92aKRW8ANZwZMDjwH0lJtn+x8V3+1 d8C/rbR4Li7vNUyZ41Bpc5HaRt+qNNF5wsBwz0pk/JjBWfr1T0nq6QVhyAHtVN1OzGUFu5jT A07XJ4UcaEMQBcDNM9j6LZEkNK7eiIuqdnTCu0LZ0gkwBALFBpjT5/w00xKhHIUtdPzAeW9L S0Yi7RJhwijRJcWUfNSztB89kNPU5o8uOUg1ebcLh8LYo0hPZCzHacVuqqyRaYJmgmO6ygGA 8yALC61QlcUPbprmYWLq1RLN4tQCSNBCSGQrB8k565RH8T7FVNbmpA8RHhnmyX8+WfqXy01r rvAG17i9k92j7f3jlVZNGWCNZWkQpBfopBd20nM76XEnzZpzI/uETs7sVCoBGVWbNU/Aks6e +XPZNz19qQO5wkOtalVfm8wc/Q48Vi6yzqlMDpk+pVLA7zGEz3kLn53yJQU/+JZc3E65CuyD LGhx/c9eejOio6qsRc1ij9cKafGXAM5FMkLKx+iScjh2pR7gfwtAML0aEAUd4wY4J4/1aXYJ +xvWmi8ePjA6Ook0Pnk8GRy7FsLiqNERhuCAE94POOIFPEGYPYNcYKlpAHB4U4usZAAUkSqZ mfH3Hv9e6svHHzpbuFnQqYmWZ6qcM2vmOHM6M28T6wjQEqo85yDGJI0GGX6MolnGLcz3JFDU NFAXWGtIZwNMPtebXpevar5Ffwi0Gy3cArWqc3Y1p1PB7YAxX2b0GJW7wNJx9RkKARfdjnNY h1uUqOdUCta4fMhJVDfy9ENynyD6Qxqp4HB591X5W+TEFdmQb8/fNXZog+tf+8mI3JOxnAsq YmI5rPtOHCFLrpwRnnaE0fdQYfVsAA2Sfh9oI7MiC+UzwFFScqA5A/2ZEfkvcoT99RRo5Qzu CE/b1dBDevnn0Xkv+rrTi5ZrFWQq2jRadLJb0ccvqEI7ZHNDLInS94+fifSdstgBglkSX5GO ce8AS+cl4wmpQs1lSEoDjNP0ilKNspoa7tJ8bukFEno5pT5wtlhoTRCB32MVEfy6AsJ2tVKB p99EzQ/9vkVXwVuwa6r46tOn0Qa/+EXS6wiRcRkQNHEIjfllXwoQJMIXFsHkKx2D6EutEnms jR/6itSQU5McOWPD48Yt5E6FkBCL8ra8SUgOwdoAM3qZJW2eBQbfIWIcgVQFUby8+3oSeIml +JNxfJ68f18xmyMaRl+3ATPR16sfYIMIDBmcZiTYJpxWBGFPuXqfg91uLVrW8iT8tcY5ZPWn OIBTUiitYOW94UVVxmmyb+z1WRPskzGrcTibUIVgV+WOgHYTUfJIBQhMPlSBRa7j97l3DaJj NEpElZtBD90SsEXdvF9VOFZTRVRCjfOJi2hi3BQQQskYjPJKa8G4MQT8Pg75N8QC7BxexseP IweUdYn3Nqtp7PjMW4AePNiLFWcgDuxcWx78yhNdybpRv5WEAd91DoXdqM/+R8vzvzJM3/Cq GRsF2My/lNwjAxWZ1ELrAovys7urAATvrZ+XSucYztByxKIlCgE5cGatjtvMxZm7LviOLkvZ eCu8dYvHnAfPMH/2Ur/Y9UB2PvGK6Mw5yO+f/e8Z3ahkqR2T5ebbczE9favV44iHl97RKlVg gXfQgBK2WKeBlOJAOqUCqF74r61XjaUEUamJxd4wpS1LP0aV4HBrqwPh+llssLGVXV2O7qaI MuWw9CUqiqWA/IpZ+goqicwrRmPEqhItzpWRrYErU+vlfkUDM70jRewEk5zJo89V59LrCaWd V4WJZZoBEm1yN+0EvRtIEZ9AZz3Su1IsA+ywi2F6hksL688lykk5i1EKVnn+yDnGDw5P9w72 Tk5f7h8+294/fX1IpXSOnYUVFUvDUVxQPLXVtmwVvO2olZ64yhjv3d4MyL0c5F4p5F4O8ln5 MM5kHCqr6vHqb6Cr+Poaj0GjBG002t1uNao/9bSn9P1G1cl8hY8M1VM+JHoRv+ImjyNXTVpv 8dcrK+456CpV8em7yD8YDOwRA8aUSZXW48euyZLagbw58kHjx9MT8+8rKxRpjCIrl4/Td90c RyzhRCriPHmC6usaKk5dHmJEyq/ouQo5lN1sIuUgreELXulGFU/j3O5uYOGsEVeyMi4wKnqg zukmhQ2KaeRQYrqJbzG6E5Hb3liNVkS3b0rjtTe6VBz7JlEQmkZbB8GYgJG8c/0mz7AEuPrB PPKEmwIM1lsBBudQFjIYop9O+3uiK/rCUtWmoSp6UExTkSGq1lopIZHuXMmImNwCRNSbS0TW XIK/3YmAeEZl5ENPfeKhr7Ay8zoJ7iSwjtKbCJMuomnHWEOI3/UG7CV2dhu12huKRpqrRZjo aBfHGsoK67NRV8nhrr5enYs+tAGtRPeMRPh2RRHZbbVNbOtDcUchO4bVtoteosDk6KFPOClM mX6Da40egvwNztOcj/iFk01gZH+VQFXKhtha7VR9Uyhgi1QK8P5GzYLbeKcJDdzmxJXLmm86 zTeLm69vljdfd5qvFzffWL/r4GkBQhNqLxU3H1ixGiX8vxFtkFqnYHWuxMaiXIxWx7XVmlKw jvHVdT4Ezp2OLhJhMwoG9w+IGZoIXJbbKLYdhXbVt7Goybpl5+lQWZmplipmsoH2kUdbzl4y ezPYOJ5heKR47m6VvrDDfNIqSq2WtAqso+sFRxdIr5hYxVROcfWLiiJXsYjFCGzxFHNPWEyU JnvXl7gZvExGcEyirG0SnhqfBHGYVFcUxzrpK3vcmRM6fF2pX0bG1JtR1apTAOb19tH2yeFR ZVAj83ctIi2D0VNiwkZKyUIJ76t/jZZ/Hn3c+nn082g5eoTPjVKSXvxatBTchH+ttyJoVuMW y8AYq1VNI51bLlH3cCIEUQ5rLgRjDcYsQybHFTr8CIkrG5Z2X3GCAXh7h1ILUF4BhaHJSEXn yk18JfcyrLyA4tyLvSieTlKs4U3VRziFU/25b5Em1OimC8BHy66X1BynE/SV+tmkR6H9OOD9 OECJVd+DP/0dmevzX//6ujP9WKP/fvw6o3z/To8DUR3nFPzhW/uYm9MjGIfddG125zvP3Pcq mT1vw4cWmHWbZt0OZt1baNa98lk/13vCArO2/nB+VdRSz5Y5s3ffnY8DmDvN3Olt8C4/ZX92 bhc4x3Zz9iQNuPLJzneCmTnrwiZ3mL3b/dz5F3Q2Hwc+ec90wpmzrZ1XF5hhi2fodjZ3gv5d 95Pn5rn/3NOe/brrzIc6mE+udiKt3EQ4m6+YJf0s0aEb0RfX/5GgJVzPFC8nxVM0Sm64RKE1 mUm+0mAfia+e1pHJW10Yt6ECUVP11Z+KDqZ3OzK6nfpT/MvVGpnXEIh4wETfeMokC7FXBrHn QeyVQ+wFEM8KBykeClvhW0UQz8JBGoV207HuiDbZ/RJFnNMkPZOk8Rt0sxXzzjBNf4mRlNyq 2TnrmwCycT0CqrlfYFfir2drvdikylZ7kyAfv+Kk0EZXqg47QBtfqFqIMzAmWeovp732hjKT TEUBPV/zXIIaCd4qubDsK9PhG4tL53gNeTFO/hlocIpuO17j3mKNn+17dyVLvH5TszXMsEy4 iHmtZagmvZ5oKYP6U92LIWkR/Q4HE36LNHgJKweoVobK/K+29/d3j0+i1hIhFZXp4ouOaCUn LnbGBoIbJugT2x9LRbsR3t7kRe8eq0aXeya6I5vOObsCoZv0f0waNg6NR0zJnyVJuvkW58Wl YVGxmGXauBG9ue4RyZnG+AuiNHA++CdnlFZPC4wbuCZbHl980CGYsI3N3/7/2fsS+LiqqnGQ InRQdpBF4DWlbSaZTPJmJlvTlqZJ2oZmKUm6QjtMZt4k08zGLG3TUkBQZFFBWhBkUXYsUkAF ESuiKJuyCCiy44KyF5HlQ+Djf8+59753z3tv0haofv/vm/kxNHPfeedu55577rlnkUO7TFof OB4owOJfqLOmxnzDsqSzqpRv7zhbBXA5i+R4wtp8cRCXlk9JIMx3LyPLDjwRBpQweIxLtlpX DRtpaQgt3+R3bIxkeBYd9IuUqXoxty9bwiJnRQbz94ABLJdf6OjzOc9V8mFggnjKx1shzqeV ZFlN49YvKfGTHehdgNi5lEBNnswxMgBQH/G/U8u83h1Dzuj9adGnGZNqcFRjZIZaaMhIZ445 ODijY0pELL4RHyAyVmOGSHzAy/EwStYJW72gEQTNfB5cbpngkzbAMzMCvoesIaj1Bmwwhy5t YrOVM2oYqshgMpEfZuffSrw5i0fAhEdODndISaArnVmZ17EvuNH1yFjWI8SGkVuQmKOCuZv5 UCq3hSMuptE4Ngwc2QgOrWlTghfpynocUbJprGDlI6Be1mWam3gBOgaDOiLrFGrHFUA3ymK2 JYXsNwCd8B9QJwd7I8bL3MmxAXFEquK0R6qlC0P2YAU7SSm/+N98vdiV3Suk8pPLy0p7O1Yn IIUQGxpwVlbnGJOaICnZGktbs7JkE+z5QLA2kep0pQsFw4ArVVkTpczaCsY52ZRM11ZQxK1p sHhMs7VTNOia8slUqta0uE4vDhOjAXMbXudxtGLlDkzNVhQbmbyWVr2L+MEB1wJ6zuNmJjxU CgQWE5tLM36RStaU3JyWeUyuNJKxPLJtRB1jEi93rSv4kD8cizSZiqxexq2YqmBQIoOwviI5 5ayTRpV6Hhzk8d4nkZaueMqegIaECwasRuSVVqAVCRChUZAT5RwLn8x2gs1AsUWqvnH+I4k0 32pkpQnD1e/RdIa2fA01KXSxNvARjrVoiuwFWV6T+Yx8hsm/hD5dIoMrhHQxmXSwQ8vQHdgh mo2PwQttFuYyf5eyM/MYjJmcxd4I/5T0PB1BudBpnadU+3DNDiofCK5sd6fhJzQOah7GTBHV qsPhTKPWobyoONqYbUMHGfVT+j1wriF9ElNZ8j3FE8Z8b9i2kXBFcJYanuDxhUkkLRRQnGXE UUZO0NiGNObLik2KArjaBkldjxQ7mLiz3eZSUxFC2+LgXYlnFpuVjNlU5MdKizB9CFi1mGey bb6A5Gcgxx2kdbBjzIwfa7MRiHQQ3Qr7q+SBMlKRUXllZnZJHE5QpHS6CqMNNrWKRGnQLpMD e5OXWXV4RoUQMhIhEgMZhGFrR4J3QT05zHbwuR2Q8q1zaQf7SXVfaWULG15mbcViNLFRUm5t j8R4W6rVVMqYJAGgZyh07pUIrCKfOTbqlk/v69AAz1pzYloWGYpZhtIYK0xJmieUYYQjvE3l oMgGpkXr0PPE3I+5qS845ML5Ms6FNPVVB72oTV9tUpy9qunIKbwmBK6SY9M1UKqMcVwOsDgT EMtPyfOl0W8cTHQRXzXHa4uZnxf+B+RUTl7Oq2NNkSh5AMwlqWQjFCsEjZ8rFb8AhaDle6B9 tcx68KQ1jKnHxWa3OgLe5GCGnhlcEcCdPZuISoJuiySHIpj/MpctEp3L7AR4QliKKKtmTgRs jpIxubdbCikSmt5BkjUKGQsh2oVD8BRy7O+ampbSlMEemgSLQj4/6jOqogcpKkcSHExqhhkL tBAcFkcpGCk49UIvBnOYzbMUNquLy9RGi7t3+bIYdFsFIElA5XmsPV8wskywULTfVWiEgL59 sYyR5+sHLVg1t/qVF622mlVa2eDNGOXmM0hTQvNf5gzJkMEyQWHEPvRuS4NMx/huCQmPN36Y xz5KMARcMcAkOpM9+rXKzgICYNCDHD/gmYYUUK3EYwUdYkMUwXAq8cRqDG8EAQhQqZDL4E/u FA7RlGJGBI0cIiOgrOCIUH00JZKbglmBCmxtMiF1biRXHE6MZLTekWKqmIv4qQmGuuGpLrRY NMHcBGtqXFg9JVvHAsAcm3X2Y1pK2SZqatSNQjKOlDuHdcBZVham/qNLJPa0niBrcomJb+NA KCdOEr4Gk2I1MybFMHVDyqfi9nF0LvHybWwWbWBw+wHnBvyhoCmdUkKQN32DMnT5Ubvsut3B h4bxT6srWFp77Th7EHl+48Zf/Hxn+aQhwzaNrU0BCANJACMY5AkfuajkLXG0G+t0pDB23MfY So1iM6Ruz9YW10MatjqZpCKv84ynHvGQlMZ6HRZ4moc/gQ9GEsKXVH2hq/uvUEdYnr6mSZSr fkn52FRNkBIsJ257cDkpxyWnxI0isrQbRRkaIpJgux3COPU9brFh2gbLdfO0B+J/msk71iW7 tINHTOyJamLvFvdHOUdY9tH2zuWKnNu7m+vbTzTWe1CP8/TkAqtZ3gAmvCXVGDRooFgMoHbg 4gl6QKHJnW1FiYgekvfDtEBaLWgWN0PDNJH40Mnp9bGONgqfN4dfHnHEOHLb4GpqhlmjL/Ny BaMiCYIl4rARHbFMspU1D75lcu1Cl2F7ZKOBtxkDMnqJakaI1oqDhmlOSHsoraXsjZNdXFaj oxGXPm2aLPLW6DYTKbblm61Q2iotAbjbniq6mstzqqVxmAQursRB3XGvpqFtp7XobFaIlluV ImtTOT1pZiV27pGmmMM9t8W4EzVnafNFa9pZFcsgy0vSyp9tDkJ0JbIj2G+pyaYyNmn09p0U Fb6NUfRtrJy02suGh+5obG+tTOSHcpHscGXaqx3FhmcqJg/Dyn2ktT6NthASirfsyO3MMmYG QZbcEsLOwbYBJm3kraWJwTNlwMm09MTk+8aC0orN7ddqcqXm9u1VeaIVBSKKpMWuJbSipVWT plYS31CTNsP7/u3SNJq4SigcLU2jiIME/TVXGO+zY6+0olt8LCXkx9JAllBBuuoVt0mxiLHu IDAOWSFuGkKMnlNKd2dX3aGOx01tZw7qdA1chbZzx0+IS3RaM5hTpHnQMyQPYW6q7H3UQ0C4 jmEjfbxK20W9vCRPmOcdeg/NySQvQvHis/QyJGn8O1CVXmbeisMvJkn4Caa6ZZLqYNOlW4t6 cTUdIuMoqjFWYGnFnIweDChEmCM7j4/bbnLdzkvyrFRdXaneyC3Tpqvzlm6xv2ReARO1kmuO MKo5q3OeEVRxJTsCCZHiPCgtzE0CL9lhd48UxJwBl6ShIdHpQEZLqRLytv0VZJvDqH4ZFJEP DRDRE3ErwoKIyWdKBNkMY74Q/ZYzoP6MFQURo/FivmsmfzBOFwGXTkbGq1BahHhtonKJC64u TU8VJ8FTirC0PCZhTNMCRHriUzPGBFaaM8heZXtedbVZMBVVFnSGwNfHZkdDJ1s4EtWRZ4IR g1appHavZrqWV+ogooa8cmaDXwfubjq4uUFwOKmy4aYRDvX9OsF41RsXhWipE4fJlqz7ONau 2kC1DuHs5G++nCF6gOVNpATGqdLMm30w3KiB1xBOUeOIrZh62pnLVZmg2gAs3RkoK6dB/eF2 3Z/2lvJ4IkLC4KgIBWvEkqCSTA0m0lZoTiB/RnqWFkexTLJJuIKk3KKmyTMR5ntIM7JPK6Fg VH0hUWQ6jYEgyAoiA64iUBBObHF++KjqHMVWCNSOCgJsmQsWlU6FRqhS4ay4SLhB3YhhZLEr 9ktY11aNgS5FL9XbuHlVxNqwhC0ItBr5VMopNKsLkTDwamKJM8YSFXFbVD49Y7oFllqmHbUV JRFl8lPVd71wreLgHvyiw7IV4r9QcYTbt2n2uaB7PgR6A1tix1YFBw7L/M+RVtcR7yfNT0OV k2JeH9+b+Q/xj/0UID5pK/CPNdZoLaWONtHOQQFJKSuMUJWphslMpPGIiIQkJ1y1EnShIdXQ LY1unC3K8hnLtM1D1dHqVsEmO6BYMZciVufKMtlNq9CcY4YX39YMHfxw9QXuzunMKsloiEpB UYFTlkOv9SsVkdmL4jXl40SBBs6zaGSxitftqNAMwigrEmouxRvQrvFS1M47yiy4H9oaMf1T 2d5AfQtRf8aepcCez26HIRgudkTJEGC7sHWcW6yQehYhmeqDMU4wDpWfTdEHchTcZxixkqo+ uTIKeSr2u8pA1NastLqL2j87VaBKYyACPBer4fChIkH1jwFxrK2grmq0jWIOoqa41C6PoHHz JK2EAOctZxuSol6p4zIPfddSMZIQH0Vu5+7Qr6rB3k0yKFE9nwCOqbFFxQLnCYJJfSuRNt8K 0bcYmdnf4q/BNbLsK54u1Kr1YJOPYA1a5+JjJZHAOUm5ZIBYZPE4DtVQMZKzjnS2M88Yui0+ ccBOecta7NORFnVSfVd1NW/mNKUPkyeb2Ex09l3JqR0TpyCev1qglKPgcv6Sxu68JrnVT+dD 7Y6Vt8ntPEcfC+L3lqpG3WxsrRE5FZxwzt5NB0+i0v0yEyiUxDX2qzxFgsvL1oxbq8Za7mL9 kjmmtGq7OdwGynWfh9K0oeJs2BrG0q82+myL03GE3pHx+EruVIm0PR+PagHPN1ueUkfMp3Nf MmOzfqJ9aft3Ja28Mf2v3phqq0rtMjDYVbWatcFEkpDjdxQ100rcv+3b1v43b1FworfFZsUK fepRrcU6iNTUcJS4PSnH4U+0gTlNLLbeImyGapSArSC/RMBL3mB2agrieMptDYLSaGwTPKrC ZpNB6hY7pa1yEtiQtyTos05l7pPgupPa6uJ76TbVFnSpbWvI+W67dfS67tMaveXd+N+2G4+h AJQXeySdCrr3gVGkuAAB2wBzNzbz/ZhZPOwJjUTYWXXLRosFNfz5tjiswsgNJrF6rvnjLQG1 n1u19t1X5ejt5FisXmzaPBWkxIJaClVkMTdg80CMWgclOpDiXupTPLtNoaRlW16Pma/HHK/L zszCHDMuh3fTJJReNhLVSOXkSsul26vYscpr0TQadmNAm7waqU5V2Jpx6TDnX96HGdqy1nXF WCmk8tLCRlg21VfXV4eszB5c/ivyC2JEV2oWSfximp9KUqDjXki2sMT1UMiJStz3+LXKSDab zhQMf4HJOPnIqGngEhTGomZaR26rg/YxibwWcrNrVEib8QHpxQwChvoEdhVSQo0dZSxbceIx s4ApLywzLQ/rTJcwi93Umpf+cvLZwCkht+z0JW7Xi4o4Ss0Lg1Vqz6p10Pfi/LqaqEB8I0bz fHlN1eDPSckYDx4Df9l0sFZVPnpJZFqxCKal8o0deLwRqlnghtyEkEcO4McY1plIKhGl2U+n KtRt+lKVXCicAEW2JDUknVw5NAeUS2xzTsGg0a1nO0/M/Ikhy8xfIfezlZl2AliIzC8hckuY mSPGOGipaSlsr9nCj1tmmGgnJ6+ErI0gF0k7/E01QcByd7K2JskwzHid6jCgD7I1EPBTHQpG k0qYcSyXApwNHRO4ZDYxCyUrbLcKBy1QM1kNoegKcPNh1DFKa3JZJoNJQTZTNdP3gEhWvKoa nOh6r+n0UQ3xRSN5XFIiEa7CxeQaVhHxnkCMF80MEEcARK9q2FhpIaummuBW60HOB3PJJTz8 a5pFE/CbnnVKDQTc3ATQkM3kefDyMtX+mbTZjUviG8J4Okh8RNyr5Rss3v0jbyLxRUwWZKol xpQOxBDqfPjc4k26tAGCTXwqjRAyRow0gupnSrcCo2putRk7Uqkkkjojtx0rfA+Hk/FRIK5k 3Cde5psIRtkbS1Vk5mdRFD+JNGTi4KxemvEmhxS8NBI33vE73kDeGMkXiEYCDE3QoAS8KPKK eI1v8i0G4xeavJHQeGX/QG9fh4hqMm2a7q3mMQaDXnmZgrkgODbMs7OtAXUqnYXVTOqpZoc4 bTJ3vjqp0YqMYgcFBObosLdCaIsbbFEvQq18OeZMWa4S6pwJakUzLLH57qjQkUhuMClGKlsY leEhxfhl0Eh/zIBFfp4zUvjC5Nn5XOPpyxhNcJeCRsyWmTNSEfToMfd/1v+4kfObOSeFSkwG QkIGaEqwzWZSX7MVfkiXIcULYcSh7LJQjZXdGPtTyURDwVmzSVba0TvLq60ycryyGA/rokSW TmKSbNkg6AXa2qANVH110NkkadsfM6STAzbMrNYPjqlI+uhNuoqnd8CGO4ff9EjCdsVhkph8 PoCWWDziO6afRUNFbqJl76+VG551Jp5YbcQwF6Y2kOFuUYn4qKmJxltiJlYVU4Y9joo8ilqj hwGzzQGTtmMwLv6xeFUkyUh9a2distz7B1oHOtt4XDW22q09jOhlzDBHNBClt2VbVn416JS6 cL0FkXAs3uFjtAsljE6QjVgrWebKqsxbR8tePgdiAZg0yCcWkeIYIwlZOtW0eVqrZG/a07YI k16y8JxkpVUOGuyJFTSYQUCbM25UwSgeAu4MF/PU+g9XhHWmlbgEDkCHEKvgKCm7sQL8AXCD FGBOKqbWDHCY0xl3tIdGq9aw82oYtWlaMwkLvE1k8UlIY0zysNuzOAjADOVhC/nWuIPEBJuu Rw1j727HPtU8reF5R46HRwSZRoaH3MKHR68MT8aFk8pXu7UpQCFqG8yMkCUWPA7RDpRNfGZi VGCA7JiRScb+4/IKVCyO8IM+xeZ+sEVVQMEYq/b44CxaMBx24Zb6pO6TagcthRo5rmvFNMYx oyIn9BWtdGPq0gXyNlYaSfToZYvTowwUdzNKyIiCSbRYHUykwQsc6NGwjkgKunwhl2LyupkV cfp0bWl4Qc+8nt5FPdRP0w3YkVURlyNpFVEKb13viWt7a3pFm1oRPiVOMtAwV52Pqudx3ty4 6n22qWmxbWoaHm8+pbYpg22ziStB6mZMH5v7DU+ALT9VQjIxr885WUKjURGbLMZIKDmbstav YKolFFFSr2yyTR56CIQywSmhAxBz37wnUJupKmW27b5AaZj8ky51+x0CJekxOL+fhHniIyYH V3IYv1qv5FPi/CN+VgerG70zZih3PgoXE6BWiQU9Fskx1Iy6ipXs65W0Zv5CvsP+hgWqTSo6 vNOUlvqohtRql01dSjYaNyqWoS3J+lJyM2Ffp003K/aqg6VydWlmarsVEzenECYWXOJhK8Mk zxXJTB4PP+qdqTtq/KWcKet5YhTuPEHZtWn0L+Wa2b19bR1hflo2+betMZD50kRoR8dzp1uD IttRHVJHBTWADqyO8baoNzQVVxY7XsQsGVnSKBWyxRsgARcMPmYyBL/pimLGH4RWdnUOhGct mA2OQGyHWoRxINSl2guW5asS/OQVxRD+KMayY1SUM5kUj6XI9kZ8W0oJuDPnE2y3sDMoVRYA YYcJOUY0AtmFJOsCt+JV6FSDdQ0aMmAER5IvRqHueDGJ51m1C2yYsRU+cPcAe14DI0Bh0CRY 4hnSmFwknYfrH1NFz3hwxkYm7sxn29VILQ7yAjlcpX/7AprBr65VMrPyT1AyUzHgXs86OTTK JYLZnYs72iH+Jlkd6uJca6ccu9qInBgUtZFyLa9mhLYrFamLreNBbLtPFUF+DLI6RM4YzpST pDvtS3rG7IvzbsN5VQtJFpw3sNV6ycTM9NJrWweOqIRLqGk/zsCJqaejRu4wXLR804kOlzHj wUhMFTIgt6SSzGzAlAaiXLrNs0Fge3kqE9MCy4MBH3IwEHaFjZyIa1mvB7TuWfIIjfEUuyCC DMaiSWGmM1CcBAMy566yIm2Rt00OjAuQxEASCb4RbNuHr5GfI1AXA40A5qYNZorpGHBRyoFd bwogjTRgBXzmHs6lRlobkwkILTkAahqrsFc7TJUeWSnzsUHquUQ6nuHXiphsRXUdGJW38Vqf MAnJFYEVSTUeOUmbYRCQ4xvCBARObM4TMK8Kr5ww7VNyTIdoMz+6SFOp3lgw2ZLH344J33bz oGsmVTfDOKqp9qysE3AMK6YlEtittUpIA8pqmD69zqto3IErsB3gWEVMWiYN0K3kcshSbGBK djPWHJN4ZR4zIhzAeTwqD9W2hlFHICuieTJK7ZzdUvOKMOWqKTSraq6RwzspWSFJR1ijWaOk VA3NNsOBWahEsj6OwZygGk1X3xXynzlmkD4O/obQF5AShS1bewxe9kEQ1shpMoetS/aQku8J tRfU5pXViZtan6ZVmPQ4VQO2h82vUKVfMtI0/WF0WTUTTTr6WrsgBIzD1Fxl5seqzbDNlik/ DPQt6GlrHejgyjmT3zIOBJcORVBIJOJC7mHiWTyBqW3xEAUB0p1rEtXiiqqiUiFKTOGux+Nx TCKFObsVTUbARpPyCMX4eDGbZSwdmaNitmPuFtT0GNci6H6KBRkjVATtU5pS1dTVQqATaRuw CF7FRSAM1i0Uo9DNMBaoAQMhp60VTBU+eAEdsyLuxISHs5mCAAuc2QqVdldbDVemNWr5XVY5 ZITK+q5qNTMih3a1f1QqmjGDmBY6dxpzCicV4SaGqyog0M5J7C+29cQmTXIGMyHnO581xD6l ascrel1dFxtpC6IKSmrNl1Vdh5BRZT6EaWp9tQGgL6WP06wG1AZkIEYrSo+y3YpHhHS5yJIE maAYB/GkRrfkk0WG8LXHAHiJgsggpkCbxxG4jstFspEcEjM7fjeE5pk6ftacBlRYpCLR4URa 2K3JV9UTBI+NBKHSc4loAWMjSSwMYY0udAymRLNjDZMsnZC6LC0XCx5ijKg77VZATuFViKpc MB1LOS1F2aTpZOFm42CCxUwwhxXCWtfdX0zy1iUAboTk2KbIDld67xf7skOakEpnEqbLNETC nd/xkuI/Uis1eJbuS20v8gpbzBIrYrAVzUB5laih5frgRn/EqV5sz6YUk1ytRDlMRvmjpHjE BBa6rl1FFeQp6r1SMioIhd/U56knEMrUyrYAHxm0SUZZYpKgEqtJmzIpOgWkaFasMk03W+uP KcwgMfJdwb63j2G8j3uFtfU7e60Yz6reLPLDp5LkB+dZc2mdMPIc1M3nQUxczXRn1uwWB6DN YszHq/YqN0hmu3mNovX2AF04/uSXFAelCCh8rK0JKCULKkOvCke07SR8mrldizMqf41Ia65T JfmWW29pSJgx5yn28ecJR0bOlJVgeSvzxE9H1kw5Z8ls/djztE7lw4zp8YnJRhI57Sj7VYAt Mh64pCUhnqVRWGWwfSNrYGwtZHR4YwR/VXPGB/rHkamu8n5nuuAFFiVe9wrxQNmTq7VAVXK1 QwKpEG/MYvhl7Fxzxk3vIcaXibxBzOFcrr3lfTfCOK6nHXmi0Kdqx/hnqBeEuCXiJR4byYGO xQMwV7M6e1r7lqg+kvFMkg0CJqVJDmVyTLhJTQVcNfydhJXzJAqB0PDqh80fBB3GyAsQdzSe MGJTZVYJr0YMaNKZdE02k+OHC/ACy2WSuDtGmHCT46h4Uhx+7S2DprHJGkxG4HaFUWUFJnNv 8Gl6yO8P1Pu0QJPfH9R50FT2GZSVJuwmFxCug1ctqxyrRkYAkM2e19isrR1onbUOkhRqa7tm wx9BbW1bH/sjGIBm1PP6a8Soahmp/BbFA2R4s5AUCM6GYw4H1y/zJlUMQexX3hpcQnBBPpRG UTEhrJz49SxowOn0seNCo7Z2VkcXa20T+6Mfmq9raxcOwB8Bbe1s6FCgQVvbvwD6GGDQHf1t 60rFoRWRN/BowsQH8xBrht+wOem4XBuXEPTWSlEbpzuciuRH5J7L5eU8ZtHDpzUwGBgVp2AF BgWvSeRYlER4UnAgEwlYtzoejMejdY1xjAaJ9+Y6+9TV6cqnjn/EL6I4tCQ3UDUq7Z2u4F7Q Zdmtp5XgSbg24eQIKwLu6sHFo7JC7VeF13aB6HDnDOroyOlTK4cTnm7d5OPRXHk8mT2E81Jl 3i2dHu4x1AxAnJGWhjlZu3XBaj6umFLNF5KkVWuzUiveNagPpXc+PiUtckAG1dZ7HA0HztVC BzAYECkGhZzF/WHtx80S4+M+PLwWRZFtMT06q8B46UDxcZIhuvhK5olENSOBwZlYAbf0Yu8O gzVZJolu3TE25sAWbEMuLQMVYnVM4w7ZcvqU+Ks8ni/setJsMyIkJr7dwIVTYmi4wCZlFbg9 c8O6iBZn3NrAoNUpozCciYnLPDgYsx0MOKXXyZR0WA5QF3is1ivcx1ykSrxX3oqkDExuO0yJ cxR3t0LPpZUgJqpHP8vZHT3s867xnHPGEExKzsKfM5SkF+QEBU9OFNGGJ6ux7rBkBneuASA1 l5Xl3gwdn2EG0BNTDeAzZgD0Dpnq2aCLt9kW+zBsmch1l4Jr90Y++WCI7BK81LLpG3M3kB5p ZsJXNgYNqiicLRbC+WG2j0qvDMwWq17POTPIWsW2LLL0WtR8zuagyV4nLDa8fpvF/vCOXTFM YpN71TXmkx3kqes2VzySL15KoSzOzQ9BcqA3VC6TZl6DbdeszXCOX8k5KzUH9AS09SkwjUS3 mj/YzXBZzfNbqf6uRheFkxrNu9Ad5F+dHbXZE3ATATQ5Re6q6AJE6BCRKnVKHhVtMoRsHA37 DdgjHKvQxUkCDRBE0u2xFHJoLQp7jDQYFbyTW3FwLZxdVpK8U3BOqtIH7oofXrnIGcmvBs17 B3TPkFeCMvOHyXbJNa2klDHvX8Vsf6zU0Sali9EqReD8mgmjipd+fhIHKHW1bJEjpLqp0hts V/Fjk7C8YmB1TJtG3WTkQddIU09gdX3BFDMRyWJTO5U/n8InlgEvnTAaIBq52mRisBbyyNfo /oC/vhYV6P7hT1gHnF8aGkI7iaOM7d9AXShYt5MeCNbVh+rrAvUApzeGGtm/n0oPt/IpwgUb qxKSs40Ft7Xn9s79f/KprZIMTUYMjxQLjCYKiSgaMuD1Uk37nA5hfhRGDbNg3zTiumoxdaxw DK4OgHXAWs/ateyUv863VtOa1rHj/dq1eqhO/ak1Nqg/GU2QpyHrJ0OlN1JUdU3k3SBBxQ7d BLi+QUWlNRNUgQBtVQP5qTdRVAHSqkA9QaVptJFBG2bSSL2ZoNKCpPt6A8XcTPsboP3Vm8hY hejTJtpfnbaqnva3kaLSSasCIdoqikoPNtH5pWNVR9+lqPRGiqqO0kaQjhXtvl5PKae5jvaX tqqedrCJogrQsaKDo2kU2NYqWxfolGl0cHQbMSiDA2NloxzaKt3WKtqFgE5bRQdHp8Sg08EJ 2CiHotJts99I36VTplFUOiUGnVJOwEY5tPt6PX1KF06ADo5GF45OiUGnlBOop2Ol6RS4mWKu p5iDtM1B0sEGnba5ka7fejrO5KkeqietatLpONNWhZrpOFNUOmlVIERbpdF3g410foO0Xp20 iqLSGyiquno6v3SsAqSDej192kRQBejgaPW0g00UVYCOFR0cTaMzaGuV0gVARadMo4Oj24ih jtYbIKg02ird1qomOlY6bVU9pStKDDodnEDIRldBWi+dQUoqATplGkWlU2LQ60gHAzbKoQtH p1Om0YUTCNBW0YWjU2LQ6cIJ2ChH58DNolWN9eZP7H6j+jNUF1R/ak3kZzBIUek6ebeBoNLq ydNgHXmqNxJUoSBtlU5+BhsJqkCItCrUTFBptFUB2ipd6QJgbiYVacrgeKC/FBUdnFA9QaXR VgVoq3TahVCAtooOTrCBogqSVoWaCSqNogrQKdPrSQdDyuCg1EfniBJDQCcdDFHK0epJB4N0 yvQmSld0cNghh84vpStKOfV0cDSNNpKOlU7HKmgbKzoLQdssNNP+1hNUGqWcAKUcnZJZiHZQ VygHWkUpJ0DJLESHTqOoAnSsdDpWIdtYUVRBG4nqlK7o4GiUcoJ0WemUzEKUM+iUcoKUcgKU zOptPIe2KkBbpdMuBOmUaY20XkoMATo4IUo5Gm1VkLZKp5whRKdMp4MTpMQQoJQTarbRFWUy dMp0Siohuso0iipIiSFAKSdEB0ej3Q/SbUKnCydEB0enCydIiSFAF049HRxN48Jno2xGiPwM BsjP5gbzJ/L2BvK0iaIKNak/dZ2i0poIqkb6NERQ6XW0VQH6s4miqiet0gO0VRp9t6GJ9pd0 UK+j79pQNVFU9QHaXzpWGhVOglTKbaCSWzOVc4JUgGygEkUzlUUDJirPupYxVSLcnFrYd5kK EexjveSjyg8+Y/WSa6hPzB+4rlUEAfUdFYGmPtGbFAS6iiBAWqD+CBAEaguCKgJ+XpJgjeqT ZhVbvYJAq1efEARB9YmKQAuqXVCf6CqCAGmB+iMgEeC08QkrRoftvjxgfsbtJcF5A+cu3NXR w6cPMtLBlagWYN8ghIwT33rxbbB9G23fJvL12H4zrjH2F8Idj/H1bOW5BrGKt+PrcZQFPtHX 8wnfZ4cZ8vXYfn/S79bxhbbr69lO+P/5+OrH/Hq28nx7v//j8OH6h3UEFl6NDB9bs/ht5t9A ne2r276BMb+eAERGH+sb2q6vx1FW/4m+nkADWOt9at/tx9c45tezlefb+3Xia/pEX88nfP8/ j695u76e7YT/H45vbMFBdbVwceas1peVlCDqFWnBJgk4dm77jrq1HcrOxRrG/HoYV9PG/DZt 5dtMvh7bbyeH3L6vx8FRt/dr57hjc2Tnd2wOveM5+Cf7ej7hDuDcEbb3nU97R9hefJ/2jrA9 3ybHiREzSSiuTuykMWdgrnpihLXvA27BiIfNIRtC1guGrEnwhYBY59C3OjHPTeAbwMDZ7xD7 u56NQwMrb2K/m2Gdc+YBGBoARTPSNgOoK90+dPAhR1kwyAFmpnF+pnGWpnGupnHGpnG+pnGW pmFr4R9eCPQI8LwwxEEa+HvNCIKN1HgLGXw9FgabEKSeI2tsgHOUXgftZxwuCCCBOkQWrGsE kFAdImvQQwDShMj0QKAJ+4/IAqH6xgbs+3/aLuPf9Rnb/qfIA3/4o5+ojrHtf+qCjXrAZv8T YKVl+59/x6e2SjMnWaupwWDG3D9ai2gpI5XJjQp7XWkRmgObea2yzctWY3N9DUwVcBy9Tjva iKRrkpliVpsTSSR5aGBtdianumpluAtyLjFY5G5CabSs92l5w0BLUI4+nSkkophPD6jRP4w2 o2DiOrNyolc7sjN2JBZMjBlxiItHJDDPRJnro4K/XPHpG8fCp90cKpFRJp8pQsArYd6M0bjQ 883IFxJpjFIoQ2BrArYL8/YCOrSNBsNQmpaGoPRrC7IMh5Eu5EZ9iJa/bwVXBEzocChed1bt EzG6pfkqBjGSVqaswcMZHisRMLGKEjlD0gd3tQe1Jg9KTSpywPAKIAAaYIIYaFqe/YiZsYmT o5BMXI2vkeEm4RjXTKT6M0fQgkF0o2xgUgajz+hwJJ3Ip8B6PJ8Q2V3yjIxEwxJ5EpWNUUMu khvlmWv4WK6GeBG2oRT5btT+qWEpRRRzTgRWx4XbQ15bGu6dBya5ItCbjxV0d3SHO/r6evuE AyMbVYjJzKicjzOOPl9tAD5rwewS4BKWcaOUDK3OLedxXMQUs5FcGm5vHWglWFSraEAXzeRy xSxaZMtoRh2L5/f2DaidqoSxMUfIJwjSZ9Evt88G4/e4VgVgIrARhL8SJV0yzRkXJQQsx6BA WzilBf+asPBC4v9YjmxGLiedYPGJH/KbhRMY1R/RV3lV9AIospKxJQGFTrtKhcJI2/IpEytv BkS54PEyapR4GVNVn7JKbL7XXsuE6cooKf5PcnJdegBxTqZr1igSlPwhbzkd11KNgDdYKyTw 1huxJpJkQh/Ugn+E44wSvHWkLWvimJVeq4R/TQCEYLPCHgjj9M50olA5mb/ktZoJMBOm4xox m2PNJsEg3/ZhOMCezv65bnj6B/o6Wtnq6mknOaQ4io50zNYG9X0MNNjT0dEebu9sGwC3PqvY WoIQO8hOP2N4KVrLzqpQ7Sc3X4f/y2nBoJ9YAfJwmDW34XD2RUX7ce3hx5b/1rAVG9/B9t9B vbGx0WH/Xa/rZfnv3/BhPE9MMkh/8FdiqJjjEoPY+4Ae3LbRkgLhf0YUTMTT4H2ytK23Z3Z4 riUait/sDfTajGujmaJWBakUkqNVWtoAk3e24yVOKGLihHhiNQ/yDpmKR7MiMpLosgb8jucG BGQwKOC5Iozkl4bn93XM7lzMczhUQPSKWCQXq+AjmB9GN9JBQ74Ww/eAR3PXRK0DYhcNGoWC jCrJAcHbylaDcEkdRP9QHnuWT5yIvFPwSDferJFLRdJMkmPyFgyhmGvuAVvhr7VerKlZw7tf wT20hDePWaXYIVMYLwO93FlVDEiDEFCaiknMD4wga/wIRC8aTQ1mkjz8KzpzwcxYN6wqI10T tspVYEWrSoCVchVcJh/RbLhluQ1WyVtAYJVy2xsQtVNzwQ7lNlA11K4KqpbbXuFRJJ3YsVyB jcSSRi4Y0OwtEeVOSDZQqUH4bYOU5aXfaAi5v9EQUt4x5UZbe2S5C2igBGjABXYWxjJzwmK5 Cp+LOgYF4aHcDmcbEhPOZUhIuRgQBzwZEOG46GiJKHdC0i5akPYuimL00XQBh3IndIeKWoHu cEMNElwg7ATm5e7wYRfkWO4Enx/JRVJ5Jzgvd4HPJVKGC3osd4L3GcCinOBY7gTvNwrtCWTt wOYtcFLu+tpc7j5FazHLna8MFNMqOZivQLkTOmxthATaKlfeGTIKQIphHs7FqoGUq/Brwkx4 zOTsxCnLKSg7eEFOegcoL6ewbFtfxf5UkSOsUk5eEDoTB3KhelJBo0kjkgPJ2AYqy23Ambxz 8YlyJ2Q45w4ZdsEaXlUCdhWBjSVyRtSxU8hyCprJGnTDEqBQTiCNTFyzfwCSlVM45+xyOMcE 4EbnAonlBJIRU9Stbii3A+ZLAOYJYCYeJ2tVAvJyF1CT89pACedlhc7h5MD24YQCitMCtOHE CE5xJygvp6BF94GCcjug60BBOQGEFGJugFBuAwQXdDdAKCegTNgeccMJ5Q5At0Hi5TbQQpZy dwkqygl0wWCCoksLoNwB6NYCXk5Ai2knmQIoLyeg4MDvxiKwXIGUTvd2SFHuhJwViY64QUK5 O7SyPRNouj0rD5Qtl7xg33LFI4ewoJQ7oR3CglXuBJ5j3wjt5c5XHPIFKXeHD7u0p0RnuyM5 1+GHcie0Q7pQy53gDulCLS8BHigBHnDCO6QRt3KX10bTUbcuQ7k79PyMGfGCQGO585UF7IjN MxHRV8xy5ysOAcZR7vIOhGBy6QeWu4Db5R1SrsArem0yTFa5Arymw2XzZMC8XAWMcq2pA5CX E0hUnrpAQrkKmEwMtnEtwexkZChvAtrKba8sNHKooCG4rXLzVI76CFBusHfzlmYFNR1SQ0CO 6qBTtzcbkEO5DcxNMMFy9WRpKpcpnFWunrlkkBcbUixX4Ex9tA3OLCdcf3Yi6TIRvJyKssMK W1MARbkbbLYEbJaQrrOtnHTtbXXKGxKSyBsQf9yJcU1YlqvLoDNdcMMI5TYwt4HHchUOL29c 4KDcDudAKOBUhBAVKOuCEMvtcC4iFi+3A7rUzMvpsuDJA7dpVZgTG7YLOmY5nUcjl44kRQwj E5qWe2RcHNC/iVdjleFwd397b384jKETJ8hiLPQqdWCBxDARg1sLUPZywAtXHBbK3v4AQ0gx sjIVH/upYjPfXdTZ0967qJ++KwuV90VRKRxBW5OwKLyorcPWUl4eRsxCzYtF8Futi5eIulwG gY+Xihv6q/6WfXD0LBgQtVul4fCcngVt9jkJh2d3tQ44S4NNDaIHZh/6l/TrDbM6B3ih2RFa LLph65bQZrdRBXR36+L+jjlhuLEUV758Z5Jaa0iBBpfIWIoZrjGHcBXXNjeERkT0xkgBIh2C QFQJ+nGeuyg/mi9A5mmsS9yGMtr1Em2x2nZJk2ajlDkBWEGsJuCCntauzjk9He3h3nnqKgDY cLh/oL0tvLCjr7+ztyccVigBHhBCkAXmyCWc70M0Pb25ublO76JTwqCam+0TohS6T8dElS4A nIc4tWYfaw/byDoK+ZXh61XXDG/+NuKVFEjwzurt62rtwQo/JmLnQjFXPC1jy+JjVmFfeeHw XMajWjsXj9FqG0/s7Q/V1dlXGq9J4/Hd+o1cgtFzJYQxNnLJUa21v5a94/VTRm6vg9CV+Mlt FxhSsYbg1sXZPbMEwb2wbrojUVGbos5Om/ItpEHIFIyp8iYKExIOwYUNWP8k+dWYzHXjwga0 frCEgUrEtVIur7G+DuHa19iWxZOVJdJg7mFEC5AMiK9XdXdZ1NE3D7aXE0+UhZFsNmlElYKB uZ0988JtSgkj6zbB00THenrD7Qu6u5eE2zvautRGdkdWJ1LFlAhqCvdrKSPVhfl42EYbUxTL onE45mg939Ed7upY2NHF50IUmxxFGVUCrTXhYCW5lq8ETLPrgDrbCkqTzKpZIpAoaS1GPVTO rXiRt6i1r6ezZ85ULWfEilG4aYN6FzG+2K+lIiNsOthZKTEEGbWLaZnmCIPeRwuaf2gNnzO8 YRRBuQZHNQD3a5WzcTqVchMVI0wmvSTYrA8aEhuCACJ82+uxjy62iTJr0U6woQXiDAbmaV1L GxvFICj54jwiX56wEoQAj4kcxnvkeT7FOGEQ4kqZjNY7lZhNVOratGlapTXA1YyhaNXmA0kl 1c1gbyGijk8Fc+B5tpmZzpoLL5qPTAKbrjVpyHcixWSBzypEDsXk9hEtbqzSRhLJDN/50PIn BSsnM7iCrZa8H2+tjdURiGXpg60Ero9XRdJ4/Ynza3iEkRqvwHU4cpkUWC3Pg5eghT5yd8yH BChDa2PSw5z+6RU1vXw/57MxXQ+JnybxTm+s8Gi9wJeKPOBxArZm1nDGOyAVAmN2MWMoB8kL 1bv7SjQnmwLGZHhi0pJMNhj2cnO2sWZTqr/obGo4TdYsmHPkQ8JxThGdB6/rLHhcpsGjZnKw f4AQIbNAzIgmI9x4IU+MAnpnYz5SKQZlc5lChl/uc6YqhBe7JNE7uzKSG2K91OAfV4ZigVR6 XbkJjbqPbwn7B+jk7NY+HqRbills2qAcN2C2tFcbMQxEnYkxQmbNZhOaSgGiSjE8QOexBONW HASFM7SNjEdyUs6D2ngg/QGkEojfjaFYeX34Tnd/WwvWjFkDRP3WjgJEDzf/3KCzCsjYYvmM JtvmL8ETE9uukv5hvybtLGIZyLmLWxsmTYEO8aaiAcUKMBIViGAoGFrgXRBpvKRYqWxc3eHO pob+biJHYFl3t7DOAnbe36a5D5ZtV+7vbu3qYp1p71zQLYVClD0ZBpAcbVIhtDfMRlnIhSZh EADruU1uFKmHrJ0UK7dLcrwxKBGZhF7MDWa0T9olRUb8VLvlIqeVlhw9vEeMVND8DMgaklah aQqexSPAGtq7unyybrTzZgU8tLyg5wS3jE2BtU0BLWgH0aZGy8DdYZ5naQJxKmvkQBDEnDJM HmJbKObG0DTCBWQdcrxsjUYhVjnXKcI2WhCqJZgMeXV9XZ3XKwdRqcOyV5d8TPayYzE8gT3c yKXZZAFfy2eNaGUsmTRWQ74OE586QduGIJGiCOQM2icT50YOhjB3HXO2kI/AKmcD1Tq/s5b/ s1ADNSgAMal3JZiUZ0R69ioyqxxaTmxbpGgl+5CGVAio+9t5NvCe3gHLkoo3w4nIPq/8oboU GDnLoSimSYEyMtKhYBrfzPL+4RnmguzJcP4GzDPMZ8eHpwOo0N/eMZu9zZhtJGbmoYC3uC0c CBVsT13EsWIBY9eDCcjsx5HwBvuQwsPhfCEGo+m3r3NpuO3snqInsUMvbBXwC0uudQsSVn0b l+q3bd3jSuhAnVXptVVyLdj6pY29CBytHQO6dC8dtdhWylZqIdClx4cbKfIFqgjedMkqZ2gJ D3VSeF7iCriw1QkKZbZmCFK3GDuZSIXJdbe2DSyZ34GTKe4NlKwVkFsQdf8tSNpNZsIugc3x Br9zAj0yf4PnoszjbpbhJ13HO5jjhuuQW/i5xPGOKS2oux5fbrMyuSQc1dpq26qr8dCGQhI4 u4B8sJJfkMh8RkjtbNWiR4loiOM+JM5vRfioiZT2EpjflwAWhGyxjwQfMniOtxgt5gM+Mrz6 glLOVfZQjtp35QEq3/EBqtFbrFEAaVZpk4i1D5qHKq4hb3E8BjyaeBx3PuYf/rilRK9L1yCH q0QNyh2TVQNRAs5tXdgRXtDTyXoWniv46LaZoyqLIUywqJK6KSdAptMRQBeJMo7MBKsIBuxn u1uFtCoOd7X2zemY3dnV0RAK9/cu6GvrqACyAqF2LCBNrwCpRiRDgD2rIYSa1EzWEAcXn1bJ jq1prpblbll4hAANFpOnDS7tQPcgN5fwkOqa3c+eRYtwXvNyAQgmghEwJGsAXKL9fI8r1fyx 214HbQdccDZk5zduVaz0hZ0pHd2RYrxW44ayRqvRMZ0KTFHJtrnKlbaZpJKzEwffheQ+Xkwn 2F7KtnFBcXA6ZJykv6NjXrgKR4IJj+ECESAWdvfbpAGGZXUiI7EIHOqLirCPfVsTxqdk7xZl mvnEfcvApvV3qHuALJLSX53VmX6w6kGtw6AxlOCZXDNx1Cv5NZvyE7C0LeiTWHQ3LDL1djaT x9OrK5KOnnaJJKAiKWC97F286gKS7WAHcjz5V3DDrQpVrTTROVi2oUrixaKbTthl3kFgD7P1 wUrMpzV1dqzsKU4B/Cs4mxuE2aYxFdJUI7oyn5bWYe5Xewv7t+EdOMku7OcG9QofyBezIHYI uSGS1NKRFHuEbp3Ci6BJ3Oo4tb68Yk2bmM1FhlIRxkyzlYp2M+yraO/o7KkYAyQgYAKlgDrS MYBgpFEKAg2bAWaWC4xq4uOr6OxxaQ2xGuIwztZYpksA4dYaxfgFQPqXlIRQbXAQlAkaDmBi me6raOseo3fcTgVQDbTO6ioJBcYvADS7tSSIaVMDcG2986ETJtHxUx0c6rhLDBDEtvl/+aOg m0ykP6aP0Vb8vwJ6g8P/X9fryv7//47P/xn/r4lIw6YUyJ2a7KVUNiy7jJVdxsouY2WXsbLL mAt02WWs7DKmwpddxihk2WXMgiy7jJVdxuyAZZexsstY2WWs7DJWdhlTAcsuYwpY2WWs7DJW dhkru4ypOMouY2WXMQuw7DKmNL/sMuaCsuwyVnYZK7uMlV3Gyi5jZZcx9VN2GSu7jJGyssvY VrpUdhkru4wJBGWXMTkUZZexsstY2WWs7DJWdhn7v+cyNpEeAUyGnx/N1+JJQTgGOfyCyi5n ZZezsstZ2eWs7HJWdjn7P+hyVv78D/psm//fx3b9w8/W/P/qHPnfAnW6Xlf2//s3fP7P+P+V nfnKznxlZ76yM1/Zmc8FuuzMV3bmU+HLznwUsuzMZ0GWnfnKznx2wLIzX9mZr+zMV3bmKzvz qYBlZz4FrOzMV3bmKzvzlZ35VBxlZ76yM58FWHbmU5pfduZzQVl25is785Wd+crOfGVnvrIz n/opO/OVnflIWdmZbytdKjvzlZ35BIKyM58cirIzX9mZr+zMV3bmKzvzlZ35ys58ZWe+sjNf 2Zmv7MxXduYrO/OVnfn+t3624v8HFhDBT1rH2P5/el1AD9r8//TGQCBY9v/7N3z8A3PxBK4F tQq9WWvN5jRw4Kvw+Pvnaj2t3R0e1O0cV6PeItSyc6+LPyC80r+kp3d+f2e/59i8YXj8ndJp DySbeDGZZNtHPppLZIH/LcM32jv62/o65w909vZ4BobNdzzS5S4BGjxxqaFli7ksWPQzkTri 5pPoBxQaOomx9wrDaDGdj8QNHxM980VUneMNBdErObz7PMU8XMaCO52KIl+MDoP4Le5ILPW6 lssUmQTLTgmezgLo6VcyyRkuC2sEqNpUkA7pACpehVw2hGaCsDOUSxTYy8NGdCQv3TEtY0XW RBgH6DPrrDjDSjDZJ7HB57muP5Om10Epg50RYprYS1mJ1wOyP78EiCSHMqwBw6m8PGZFYnBL AVtFzmOq+/JMYgCzKSOS4kZO8UjU8Hv8XfM9bUpVcD3JUMQyaAvF5hRUdnDJXTCy0lyFu3vk ceRRBGHCLBxhPKAtU94fhGNDll+BgkLMHBy3UWVzkuZDEkHXymgkb/g8aB2TzSYTYgZTcBUh Zo5rFBLpLBsKNlu13G+VkY+BeNhcsyeeSg4Nc4XwvFjLZ1n3vaypcSg0IoxkUGeHAzKgzEwk mc9Y0wNkBqiAOsD0HP6WV/dsTfThDa5WqXs9lf6hNV480EUKfBbYyJgDz4Y1lWBjx092ERBK 2RDH2DHD0QBTCAQFJdwmRNKMXhJDIAYywQ/c/Ph6AmoFG0hBiHyg2emQTV06Omofe0GWPk8+ QymRO8Cm2emUocpF8sMaHFSBGPB1Ni2ACuwUitkCqonYePJmt7LWmavEbbLNQc0Z5kEWUfDT L1h1wiAKkz7RLdX7OJ8p5vi9AJzN8vLKFysr8pYpnfEoiPPAsgS4P+qBUzxUJe/l/VGfh/GM VeDlwP7lS8vEzvHgC7Ks1sN9gzLAznAVsckYYrA4o8pKH7OvGn+rKzPkQTJAXUQ2kgZ7GFy1 2F9egWS5wGpXRhj1gEkCQ3c0+yVU6/DKCvbTjzd8QIqMzEciQ8ZU9vZ8z3ChkJ1aW4sQ+WLa z+pim8RKIwkH+dqCER1Os4WWbM0VElHo4nzrKrNW3Vj4ZGvzjVxSIelCxpw8zeeB1VEAT+lR bX6kmNS6IznQIOS1ymzqhPzMKOukP5Mb8vpof9gYtM1v7dEqOVMaNhgBrzR4Va256DD86DEK qzK5ES9bBezEo3Bj0su8EWHwfllR7UlQb21nb41kdzVLQY6SfRllLDa9Lb1p9Xf7tXlsj8Hr kspIamRmKjKUNgownPbusOkRmHV/PfdRB7ZsqjJJi1etWuXPIjQ2mBENSnqpTKyYNGr4oiik knZiAKkQjfx4iwvRJMWaGEn4WaG/MFIbatDreIfTjJDZpCeAKmHH5mTCrSXYTir5m2FyNw3J ifMzazxYxwqZLFt2ZoPYCM1JJOGdhZlkEiww4NySmbmKLTQ2TobbKEUKjnFQwWvXdCUG25PJ WlissFZxFKCJyJzNxQnsDliFhLNWqOQLIEWbLRW8ROUvfpR1Kvo7OrTWrv7eCiLqrDIGkeLk HhdHH2Bb23GWGDHUmnwchSA+bhoKLGyEzIANivjERa5BDtA3u81T2cd1bqhvYkSLVh4QvqG+ Dg1UmusDKjdx0lLCKMSRknLxKHzhTX9hdQEt7aw2CNN5GM9CLgKWBKK5Xo9/MLcVhDpFKK2J bLvMdiAMUIS4n47VQjbK6EPUYzBaSDOizYD5C7BdZGJaZJDt+OYcSrRHM6YApqWNbOTzRdw3 tPacX2vPDA5OyWtHM9Jg+2uLJ4IhLiT5SJxjEW+KNSaNbfEX87VQRW2dDv/hgc1IDzEBtJaT WV8H3Ph09szR5vf1zurq6O6v8MziAgmTm5i8gZIGiDusnpTPw7Yd2H1xf5ckTymTkQXjLIn4 KBcqwLYDbEGkXAXEZAmgFn9r8eB+tyoBIldmsBBJpN1ewQsZw5BioGiXsGYzVrN1xCTr+byR yEXUNs5uPabkWoE/wvHICRZ7E3JZJD+CEhabtWEjmfV7+g3WBq6JBhHDFPv44oD+A66ZuKMz uvKBSGrSkrzAhatp0ScvvLJ1fsX5QuuCgbm9ff0e6cCDp2/PtgZX0SpXwC+zbV7kYEi7rSDE aZUpjNkwM5IsptIJP9uIYUf2G7GiV0qFjPDymXhhFcgUEDaEC8IxrSKSr0nkfRUeGasEZETG 4NGJCszCmMiSgFAmkVyOdXEUhe10BiW7AjdIQ/ousreZYM+YGxtuOHEhhWOgFYYwFoEByXsi uQRKG6gzxsOOlLyU9sFcccIjApzFklEmZg3MguM17juWLZtnKMMmCPXZOYMy6AGFy1Cuai2H SN683wbxYziR1OZFCmvoy1wCFFsBa0QiLg4ZIAWy8VW2/C4/E0Bg2243ioU8mxOGKJIeQXqL iLHLGpksGAoOZ8TiZZWLFcKD0+SLQ0PcnmslG8BMMe9hs8ImUFjvifODWI+ABg+2mYyWZqIj O7libVFY5WAbyCliQU/nYjCpKeIWPoRHrj7WWL/W5tf6MrEhRqk+zwJ/v1/rwb4xuC6x5bAJ 62ZjGwVddGWOw85MJ1P+dGLYz8YfiO64CrinAFBWCdZQ1iX+Jz7bov/zZ2PxT1LH2Pq/QF1j fYMj/lddOf7Xv+UzaX77bDbZIc+ke1495wpPvVYHJreeadNquzCwktbASvpqZ7ODAONStbOB wbWjOmDGDA9X+nhWX3L10qfOe/rWfdY9d+OdFzcvOORzO++9ubJ2+byz5p3l8z4ysPHPy47K Nj998NIv5n519sLrv3pi65ve9+4p/GV21n/eMu+3jn5z3+ROz1zb+53061P27Zs964OHPlj2 6o0Lt+z3g9dunPVm8IMnlq+7fXDFzvrJB6x989FDDrz6v057+8PzTzrnm19ef+R+oQfuXXPy pB9suP+M7x+x6dRw+OcfvNSw94/3+PN/37L4oz0/G6ibGTyzob3rDzfeeGrj4z/fvPiD5584 /Tu1B0955fOXjEutu+H6ljfDfT96v23RO+t+33B990sfHvGlvx+2dOiE2X8Z9+CuN/qbv973 9ppnv3nP+p99a9qG21beN/jtP//r+buOem7zunf/9MJuP3vrLd8vusMX/GvCHg/0Pzh8yNBF z/5j9mGFfb6y8zM1Jx3789uXnj5wbvFPS/6iH5C44OW3f7Hu7L81dfcdd/4je3/whYuGnpk+ Y4+3TwsV99owJ33qzZvuu+bVs9M3x847PVJx6st1p9Se1N/y0I33z5p9cPvw7a/88wtHXPaz k99Lf/jmaxef/fiyLT3pQ/v8T7/0e2Oo9ocb7v7b5WefccqiWSu9R/oun7DHT35yyOcnrvvp xinNT1zQ/UTN8wdOOPvP2o33Rb781Fl1TT9a19nw3rnr9/vc888s+fYj7cuf3OfUb8z4Sv5m 796F1y55oGL1XTNumuJZOenVW7zjv5j8Y9G4Y8K6TZ8ZNyG+73O/afr6z9798kk3njjrzfsK XVfvMu/hd/9yx4pb7z/j3opvH7nnW6Gzg2//66bf7PbHm4788NzGizc/1XRV2/3GCb/8+Z8e 74r99rK7n/zpERd/pvWR9TfXNh655f55j0dO7fd2hQ5+4e6dnr723S359Pqb//jNzVPezz23 8UrP1z7rO2fS+YnBGz+68H3/Fw7f/QftF33vlVvv/cdNV43cc/mKo2/Rb5t/9UBFoir11vKe a5o+f+1Ne7589D4PVQ5ddNfbl/cnvvrTJ2v28/7+su9U3+vtq5+35Y2+Fx8d2v+Kv/aEu47d OOlvb31pt7lnHHTRoxvyH/02MC96yB5rL5py/rfevenUJ7624qw1T+90/POr2753fDR6QL7q qtgFTZN3OW/yBRedPqfv1fsHfxH49tUBz4x3rvrZnOHEFfueMHdi9tR/7DPuuL+M3zP54F7Z X2y40nPiucf/9jMHPx649NZXDvvrPX/f9Zzj97psV+Pa9A3v/uPN4LjhJVNbdnlmQ+6+ybE9 PrztiL2+euvE095c9qvE/b/8yy7jUv1HnXerd2jzTbVfXfbTCT/+xTUf9N4xcMbzL968enns zo6bDrn/98+cOvGFe30H7fbIL+9rOe/xpw4888DXz//Hkded/szhb1x6/VOL34nPfO3gH79+ 0rjqzrPip/bd2L/zn86c893GX8R3WX7DP3e+dfVOV0599J/Tr2k58oXlHYe8fMpN+y/esEfH O0sOmX9Y4+SJ9//5zD8efP5x1z4UfGjXjmfPbfluV6F71zuPnP78dXen7t/le4XV+5+f3+d3 Dx8/+aAtB0zaaedrl9806Zz6/Qo/+/M5U7fcOsl78cqnX9993L3PvdJzz/r+A5/ccGLIO/7B zxzV9Mv1v607edHhR2fv/eyrj93y68rmb7UXbv7aXePOC4xf3nBI5L1TNvneXH7lIUf3Hpj4 8V23XNV91ZTTwkuuvuf48zrXeeouOGLPorH78JaND/9xr3Hv7XL5KYkvf7n1lKquQ064rfrC i/+yccWepxx5/GkH3L7bD05++lsvb5458l9/bbjpwH2OO36f9V9MPbnrhztXnHOvb8sX7jRW HDzDnz9+6VvrP3va3XeObJ7z/ZeSqUdf/2r1zvvWbHhu4137ndm8S+P84vsXvPjYsb4r5+/x 9cunLA6+ceG9J+z1w8fu/M5//3Shb8WGM9bv5Tt/Q/MVT510w55z3pxw5W8n1Nz2+YOefq/h u0/d+MaPTx381bS3f/TXjfsf/+Sqc79Wdd3zh31250s3ReZf/YM9Tnlp0sBBxoXzz/W876lL Du+dva99Zdfnao75ykF3/nGvizcuWzxn+OdfDe35aP6/v/FI5ictnYe9/ur7Fx/4wR9+tMsl +3lmVG7e/LvzZ31382dvy92/35/6vvfuyN6+f7z60tHHpQ49t7tl975lK29f84PFS847t+mR NU8uOmpm7SP3LbltzwNv+vzk82sOvyi2eFphYcO6Xb/4yP7nLL/C31115+DBk/MTtizad/6+ rw0ctP/vZh62+fvDg/sf1PCj24989cmbnz33mtD9X7l+xUHjD7l7Yfe478wLD7Yd0nv0xBc9 1aOPBR++99kfPj3xzNh5z93kvWjL3898NpNcuV/ogA3jzjW+t/u3f1E9/nOFKw+49/4X7g2/ +NAVr3XFJzz6td1iHb+edPr7oxtmPnDZbUdU3fbNnsd3urTz5Uv/NP/vufEf9p14TPUuXROn BKb8c+77F9+60yEjb120Yd3cf1258kutEw44bvnwNwZnLs09dtj4Q3onXHj2m76zapbvc8Ep LTc8NO7r7YO3nJOeq/3kkYcXXHLMMauf+8ayy3eZonkuP379H775tSXXzP76rs2Lb//2+5Oe O+LcB+4888o9f3Pcb361z19HP/h8zX5Xr+/RD911/T1rdpn06OSpj3fuXXnqU9UbwpN7d3r1 z+MHXi5sWvnwL+dvKlbufcC8Gy7wnLJbz6G3+yJ7nvjwOQNnXfCVBQd/5dbD3nz+vm8m7hs+ Y+OTy75+8Vm/W7/bIv+8v960/PrrlszZvP++j+0zMFR9f+2yY4ZuH3/qO0/t+q0vXfPDxT8d fuCgpYe9vfnM+9/4i5beuMl3+h++vO+Bv+7fcn2s7rrahzcu/8yKvabt8stnfplY8MSF4074 1fe1Oy45as6u6+86e89xT776ysqWozZ/edNZ3fvtvuC6Nz+zfnpmY99+t+x81Hkts79y+JYf /nX8Gzv982+7DK1d2/zePoe+1bzH0fMf2++Vv93x0boDv7x07bUX7/3GnBv++mL12Z/b9OKh L2x+4S7toxN/dd3hHX+/MvzRccd+/TPjaj98/4NT9vli9gdr3ztl//+64ppzx40b+NaKXW96 5OTf/viF/ok/aY21X77l+8/UffGyTQvnHDprl8NOHvrxKe9E2yYsvP6BzddULtiy4Vx/9bU3 9j5wzDOH35+u3/DrTTs/sDTc9p2BA3Z/a9Wld59dnZufrrh40hdGnj58t/2qT376GmPuVe93 n7LH3re8MS374YNHeLIvjX9g8YUrv/TYNa9847Xs5Lrc5yb+dvhvd7dfvuKrC549beahT058 ZN8zzl3v3dBy6W5LXjz52nOPGn1jbfz0V26Y2fJUcLeHu0Kx9MXzXj3vhl/P2fKH7A0DPfd+ /77a0XcT47Zcvvm5k18+2acdkXgqlflC772Jd36lb7h5y+UdL3xj45PLNz1z/IGtDx619sfH 337C5zc9d+c1D12y7377Hnbg2n+ek1t0au7iqw+8bvLaG3Ira16667XQhX/61ZmPL7v54kNf +OOC23bakDnxope+2dk87cKRjkf3+tKqo17+pr5I/+ET01/89ku37rQkMHrvoZdp1/ZW3Lln 72Urnv3Gd1ed8eBV2fDfsuNXRG/51xdOT7/95muPrHz0N+Gd01WHPv+y7/dX++44d/x1N69/ 7PPewqZnx51z16ZLb6n43JGXt/5rHz3acvCTJ93d+kzqw90u3/T4RxOuann0uPuCj6847v3L z35m/70y57907O/Cle9d/Pr3ZzZ97debZlfc8ZWz3v/HPevuSN2/85kPXv5c3x0zJrzz9ydW PfGm77+79xm9dvPLbx3W+1/H7Lfbvh3F69c8/Zn6J7oeKHa/Xv+T9y/ffPN3V69evXjuoysf Pe0bF/62cNABR3/3ghv3PvD9lcE/vPDIi8c9WvH66evW9WVaw1evvvGo47K/n3ti1SXRBdH1 qz0XVl7p3atm/ec6PiykC2dGnzly/2sfPvm6GQv3X/7du+5ZMK7quJ8G3nlqj/ruX7xzxe9q 9l502Dvjf3/yl5a2V+3f+JPB8ZXxw8+4eePLB8V7bm16tHHjw1fk+toSJ99+yvS9j/z5pTV7 L7hiyy27f+uPj/f46g/dY9ox4/bs/sNF62fc2bzP+yvGf/DY2394dNmE/q++s9PtH123+86n HTm+5cGu6sH4MV0/O7P9kpcu3XL4fQ/t+cL8D5quOysx8rNrNv5j40fzL1v4hR/99Ja3H+n6 3awPAoVxb03NZK8ZqH93z42v/T/2vjs+qip7XFBRB4QVC2J9opAEJ8lMGim0hCQQSUJIgoCI cTLzJhmZEuZNgKAUC+K6KBYWFRWVVVSsqKCiIqKIShNZRYprAay0tQCyot97zrn3vvumBFB/ +/k1P/5B5r13y7nnnl5mdnpw5wXtb2l3w/mTLux6fO3efg9t09IWtB3Z8lbTrftey5qz1l30 RO37Gzd++MkPS65wnX9d4CZb8I7rsp6NnOq97MzHXqg+UHXqgsede4tmFf409s0ZKV+XbOnw l/0FL66yF9ZXFf06uOHqNvbzg2nPPLTwtJSsEzPuX1dQNX33Dwvy2nU6ts678rOX7z542dJ7 544/uPXRQzN3n/NT7x9XT+93zOQ5Bz/NrXtV2/hMv1f7XDV16f71e077cudxX15ROOXudYUv 9fr8xN1f1lwcOuvWTYH5K73FJ7zoHzhj4fFdhjTfU1Cy8b7IQ5uf3Dn95Cm5a+f5qh7tq327 sL7tUzu7/+pwryguz1532dBP35/Rf/VLS55Ytu7Kp6+qvN779jGXPn3f8t3f3rn43DeXtTnQ 9f2WmuPe/sC3/61JFy2qm+r86x2naQ91fLjh067DN/z9zF+7P/nslGv2fBf5srRnrzfqHmjT 8Gr60Oc6vndowqSqPoO2Hdp13bPlN176oP3lORPfyfvIdfz+iZuuGDZ3T5d/LjhnfuMT4c2f dDlwwviH3+yyPWPKzqd2Xrxn14PFn63sesyJ26fN63bB9a8u+Hz6Ekf/C8vu/PqayxctvnxO d8N26PmvPHet/esD993o+9Hb44F9ka6Rlk0vDnn0rl+mPLrtrsrp/5h7Yfpze9+5VludtnrL mlOOzzn3vBXlxe3P/cvPj31wwqweDRuGz35rxpZ/zVr2ycm1B864Zta2yz0LTztzZVW7BVO6 /zy6oGPSA6cct/nOR++L/PjKGQfyCj/+/N6fR7e/8px31/7y3IpZj3fNuWDk9jXuOt/ck1uO Gd3moqLZ/T/cOfCcdnP23NP2x/l91v0QXNypcvnW8d9+lfmtcX5e6Lp9lbesrsr79NCV3288 a9Ch4ItTmv91Q5f7Fl5YccVvK+YWfXNKG0fYWKo9MOnVtWe+2Gnzmzuf2nTX658tfG3vR6+d cuGBvx86sOqkyYMyh5Z89s1jc6+69e7H68b+vGHDhaPOzKiZPLt/19ufazPSmPT1iZ0W3bGj 85Yz3A98PuSKJ5/5teNvhzp9fvGo9nrQw/Uz9i/Q6XK4bpeZ1StX/ObMilH4nNlHovFNGr4l vKW086SvhpfvOGlr54HGimP+1aXui5823x7KuL+i5JJA4fabiju0Pe2Ymx96/YL/rNvSp8vU h+8/7ZE7brrnm29WfbPhhE43DK08c/LyT1d4wy2Bdxbc6/jeNnn4ndNPGn/2oAPPf3zbV8bH sz6//udDbz2w7a0T68Nlz9+3utep9zTUXpzx6ZA76p65ot/rFdt3zerwW8VXrw+58j/l8z1L 71t9XMUjW5bs/s+uO1etqlh/R/qip5bMn//K7ju+evllzzlTll6645PVHz3x3OK7Grd/n39C euPT62/vOmd7ypr3kwdc3+vdn1Z12vPMo9cNfTuSMeXQ7tN/dlwz6bdfvt2xZciGT78M3Tqv zV3eyx+ctv3l11YWvDTvxsw2znkj53jv+WGRL9W3a7Fv7Mwvsj7scfb+M6dMqvvo4urbAlu2 vjzq5c/L9F5dPKM2zXves3Bx+6+mPtxzWubfTupy8/xuIy5Z+mPj/S8fXzntkh+efXZx32vW 1p++bLB7ec/5J21sGDEs9+raJ3/5+L1/jcxbcnbvht72fzVv++TmjFNuueu17pMGnPfJ0NLm +b8sH1G65Y7vf536XVHVmtUv+kZ26ZN3YMZjWb5xntEvZU19s2jbLXOGPqLvvbNm95AeM5t+ +nrYJYv69up4zwXD1m95ev95C2addcbJ1zZk3tXl+BZHj5mPfDmrbM/E4TnZvt3r7rj49L+X f9Ww6fgnjZbZV1SsufuNKTn/eOa6cOq2otcX71q6c+dfT/cln73uil9WbLp3+9Pp7835ceXY tt7vyy8+cd3Pdf8c/MHI9iVNW845qH3Wu6Ht+oFLlj7Zs37029PKfeelH/rHzonDm9/xP731 k7w1kRGPnH9rzbpZXyzsXX7w0v0PBgMLIyNn3zOvbf+uZy/47YxF7z/lmzx3RP/CcbOHX3ln 1r7PZtTsuHpv3bp3Vr6RtGzOMZtPWnzzr3/N7P5g5r9vvPbMYLdVL205rfra2096KrBn7i/7 J/ccWd37/ebXH+/d49zuN2x4d7R2fNkG58RvXLfMqorUPfvV+kuOGT/4o8Wb82vuvnT4mEEz XE7/wW+yngln2V91tT9+0seFTz205NzZ+zs/mTZnzdsfTZq+5qa5/UZPSn2x5vFDi17wDe9y 3OJPeqR1O9Bp4d4HnrsiZ+7Yu+dfpc2Z1GtfyRntz8j9ceUTF7919757vj/z2JzpY+ra3Oof OHnunK3HPvv4gnm7P1/73L6uy05ds2HSyLvurdcf7T3xhLWfVvp2tjxV9NrMTb9ctGtd35l5 H9Q+nPHc+l8+3fNMv0nnZ/VPL23bveTAIf/Md2vf/XhM/+Dqbe++2OkvqR9uL3m+2X1JTWr1 2MqxJzz40oebx96+vdbbo9/zzXdu7ZGuDXa8+mO5Y+/Xt6R+O/LDnYu3D2vTUtB/9uSVzzwU /Hi5Y9azwaYOow4E1rf7592rp/Xo8MIbuWfPveVzz7LZY3+5aNV7ix+aM+c9569bPDWfbd4w b3Pg2zvSbl7w4t+yF60696O2Q3d9MCn7jZuqZ9T/OvNez9K0gg+y9x+abDOW3T6oTf/p0/vb n55XvuNd98svDP5+wPo1763dtap47uW/9N+nvx4c1+e47fVDZz36+N+mtXlz1fsD3n3jvHVn ZV/U+2f3ls1PDzjnrnsDw5affvXWe3ac9sW5yQsbt6QMfGHHyLYHCm54Ycd7o3fkj9W6Htx8 y7SvT1h50umPH+rx+HePX2d/uMNZG+feepHjwg4zvefN7O2t7dj2gjYH9tx+xbGb2px01vQ9 H9fUzunfZUXH6g3jtq/tNsBeNuyMax/VO9bazrluv9GuQ857nXy1t51/d3Wvfi+Nq029aN+l D3//ZvjHIddNHep+7tlTry3Z/M2M6XPTClaODDw/9qKFx3YONY3rMG38rcf4yvrsHfPd8g1Z d/WcVTF5+rpjpg49/yLH7e8f7HzjjDeTVk+4x7v+qfB9Qwu25z1wzYrjpt004PsHf2v7Q/qq j9ImDrruzq62uQP/fewLj7/Wuf/Xbzi+XfzsqZsWLOpUkPtlmfHhcR/sXbHjkg8WXl80dtvm sklbJt6U9ug57So7dKr5ePMF+Y+kNFzvDRsnT73tgj4vNTj2P7J/w7TB7249tvTNF/qd91T+ T222/PbGC0nBA8vemZ1Rf0Z4nn7DW/ObZl0UnrPgx7PPrtrY/eX2S1IzB9x57tr54Y5Xpe/4 9NQ7D85yNXx8cdHea+v3TZv+8L9vKy7Me9//QerMey/veNtxb3d6cPGUj66fvr5du4LkN7bv /fzMUZe8M+K55pG3P3Dzr09scyb3OPvrNmvGNEy+9esfWo6b3Kf9Zq12UW77g8V5Y7puDHUu HvbzV/P2Xtiy55uVtwwcvG/hoqm3vrf0xewbtpcsXX/e0OVTv92w/qPPr+o5du3eDtln7P7x urfP+WH2rsJLf2scP+mEWbvuWdH0l2UTT1u4eWPXlFceez3XVTWhR7dRW5ZdfMKmZ+7d+0FG zbXpV79z4OWina/esPWpqclNh5zJ7Qqf33lN5+WvXLZp5xLHSSfPnNXxmk/m7jvzsX8WDv71 9EkdCy9aWrHq4JPlVZuz/nNvz/ttTf3aPXTucf2GZ99tu889acNtm/8+87vemwL+9uuv/PaM A/OOLTp32OAvHrmk1Dhl5RdfjX9myrWTC/Ivq/W0/+dZN5/c+U3H7hXttp4/duJL407u+Ubn mcGJrpNfefhLZ9bB5buOvX/52w0b//Fx80fbip6//Fq7UXrjqIdWfHjT3L+tWzlwx+1rhjy6 Mmy/dMTE/Ye+c7TfuvG89Z1cdX8fP3f9yclpOZ1rtO+6vZ816B370jEzSq/84NXjN1++rODQ Md9dc87dyQ9fdv5nG5Zsfn/J5TVaKMl52pDz/jFje7vt5w0q7X7BDQ+tPanDzoYtsx9s+0Na 41kNld32vrvq5+0XXvNrp4Zu+ckxAoFTWHudeb0yxY+KQAA1FdKrXA16OrhzXEWhCdooB3uc nZet5WZljLalV4ewlpmDvYXpHZkgOrCfdYqAMNggVeGQu0aPjEqvKi7V0mv1CRH2XcmEyMAa /NTppE9KQ+xzZwb+weSM9AHsb/ReZYufxKIz/8sLzFEX2Ct2gShCqSs0F6jhCjVcoqGlD/Z5 DG2Ujd530lJGa2ykZjZ0hrlYZbPWvbJ3XRGXP9QghuTbqdAjLgyGcOZFraVXFLDkvmzpQ6oq NGffvmImZarqXvhdtbKODOVpri0XJcRqp8PmdNA/82x5UV/ktDper6MdL9f8oMhl6HAa6YN0 /zg94nO7aG/wGzu5IBNVwb3rpFFrmushfw9fcSoryI2GDP8uvdgHMah6kGHHKLbxnPQIuMaY pOxI9/rSvX62+EyIA2o2RivDOVpbX+qQej/0F1HXmWBdea2OUxTye45gEGde1OYEgphfjKgo lwJ/Rm5e376cNPTuNwEitvQIJX71SdrzyutJms/TJ2l4doWjommA3ugbNDGs10ysrHVPHOPO 8yT168u+crGJ9dQJrqZULyoOhqYb7j7dBlSXl3aDFybkTwg0BdgytAkBf9DIn9AnCT/JZ/+G n9OTNHwlMqZP0oiKKnBP+8f42LVIy0tzpjoz7Zo37AroEJ2nOdNyktiQYY83v5rdWRqQ/dUn SQ3zysTwHyjylu7ISM/ISGVvpBotwYhrQmrQuDCJf+cbIT8LGmm4JowM841Id6Y50sVExWbY ugZ/Y/AP20NGrsebm5mbmpuV5U11OnVXKnj/UjOzcnJynFmezCzdKWZqUlZomYo9YHNlMhCw f+UzegRFhcJ9kgZWlWsDG0NGhKbWctNyMpPS/7wFsdOKvyD2gDavsX/lV7B74W0pZkSjTxLE n6Q6slKdebUZznxnZn5mVqqjV77DQa8OwLJUh3u1b2/5bihcyw66b0M45PXKaCBnmjMvLaN3 evRbvdOjNv6ngqKionVgBAIEj4qK/GIedFtWfISz/ImH5nHLZTY1h/0Uz+lO1/0U7cGW6mTr 9LjzKYSFDW4GuQOmMeizhxFfxK/3xTUV+iP0D78Ppsj3u4INfZImpPJCTUl9hwXxbQ+B3+/j 54DfpZtjxTmcdH5F4Z+SAPRNWMbpaP/78wYyqR6joH2SxgNNixGXFB4o7mhyvCuawoQDwFoG A7gJycX5cBUcWc68DKczE29BErsF7DV2sw7zBkf/5HgXJEUy7wlh3WtzaBkOm0P+p+VkZ2dm a16N/5bjyGIsGZ8ExW+98nrlRf+WndfLGfNbTlbMew4HiI/W3zKzczKjf8txOmPGy8kEgSLq t+ysrJjfsmLXkuPMjv3WmRvzW3auI2bNmdm5MevLzsnIjRkvIzN2joyc2N8y82J/y3Eqc/Cg UpQFa3wTdXZGGpPzQkyUBOlESy8LekMaib3pZcXaqN4ZRc5eeaUlmaXFGTnFvUryiouystjK B2QWOnIKix3Ovod/Y7QNLXWucAQRI5ehlK1795IhpXFCrI4g/qfxj8aYEFgSxP9kZGb2cjhj 8v8yM5z/P/7nv/Af9P+jnJjUVCVHgYclJ8GzpJjsu7jNABXqxFDHDqmEPj/TSCKNdkwphPJ9 RxzRag1ghU8Th6gmYYhqkl1rPUSVjSGDVDXtj0SpQjnAI4pTZW9WQV8EghR71ADTQy28EAwI mWy8f5/lQzkhhzeUyzLzAjEkOez2sfNQWLthpyB2CBsFu70PM9fUGFcGtAgbCIo++lsglxEr K4oCIGaJQgY2KGASoSQS9oWT+hmG2MH5gjG7pMQ5yCKrh/p+RlgHwGNGUgGVDeTPiVu7/S5f wIwhp6D6iByebUqCT9QQjIEPjYQ5hE3IiCN2jMt3jwmGxjNBpQEkIZHAwN+QiVKU7Sf6J9JQ DI5hnUEUy6VC7ThKi+Nxwx6oJZaRphUCYKGZIWV3yJpBuEG2+Sa2NcixhDh9yB41MF+UzkUB Ei/2aYEUvFyvizyrWFCwbzLT6ArwdpiQkMmBHtYDoXFQzDFMZw+1yAAvMZsvXiYKGy3mwvH/ lDunadaoclNcShhNbqOL+vszUwxNTU1BgnHY5BTtCPJS2EjJODdP7rBrlhwTa9R3Ct0cNWek wcxQSqFSpLLgFlQvU7qN0p/sMa/x0o13DuimlDKXdb9tvEBftwHdtKvNQgvqWLxiudYNqWqa N3WCHkz11KeOc3aLebFyWIXmmODMyPbGPKqrKLxkSDWUyYl5UFbJHmTEPqguubQMp86OfVYz rEg+pmL0YA5zuSP5WplrHBTCSdOK2X1yN47xMfDyf/VvcPlDPgPzHmRSo48zjDSvluzMYQjY AtzCmWJL1ap1dqXcOrEfn1sLYMJ1OpatNZNBKQMWMrTcYSimB+Relzc9jY1DKeFxH1MF0m40 stGNXxyGWFCnFBoysGmBabTQqUPVfY1QnLPGeDmoh8//tmkJM8C135UBzvnjn5UDrmlxs8DH 8+LSSho45fPB7zIdSMkHR8YlM8IRdn9WSjgwxT+UFY4ygJkWzobDxHDtjyeGM2JzlKnhEqvi Z7dJGiqKJ3NyauKXeR18IJ9IWsuzKrXxjT42GZZSoFqdYbZFrAOkpg8zCox01s6fe1DUoWRE md1CJ6sM6YsYut8bfyinsrejz3vnOe9qvrumHXnGu5K6bMIH30DlSIzVrWFitzRaokLnkT1x U3DEFPQUqLJv8H2Aqo3/m8PVHh8aGRKwicAqwcUGFfACFA81UY4N1kuzZNHitPQxgkzUpqCM cwX8yso1ymPilRWp6DJmh7tJasT2W16s7qqbYwIyBLEVCIigzUGZ1ORmpBwSE+MA0TIRVvXG G54KgijU9FJvJlxO+I03GrEzioLFe6kUFc/UxIpU1L8qhEm3kFII5FRmf/mCNDfUmRU9xWEc eZhM9mWirihnIMifHDgOxh5JoQQu+FgqJfCbeAS1ErTD1kpgY4lqCQkrJQCLUgs2NjGe2tNs qpUC1cqT+YNQk4sJWnaqLOkjgOO/Dd9EPSWlwBZV+TG5p2yklaLFG4j/yXgDbAxGsFEvpajO RwXmGvlzbAvL8LfOYFIQwF72EesZZBJSnS9IZULhD058oSKZKKcr21lh5qz5dnOgXodyeqKp jVoJgI8rhxAtrCIhdr5yCPxLC9bDIOa8RLPgxKDGuqhLH7VmRvEL5Jo5+cdFm23g4aeI6OwR ZyNiCCbfMxwndZNJPshE5B5A342/CfG5uglavuBG1g1QTVLYQMBoKCBJn33uB1pAfWQD7FyZ AmzXKodBCWYvatD4hK8g7nljyc+edPS824k2jqnPcBKMj6k6rFyL0iBuIv6bzgPZIGVGUv8i YoK8ch3NxpeidIObCP8u0CwjICQTf600DCP0pvmbwr5x8BayZupMoDW5DD4mrZTaheH4Yjei xSJ8Vge4T6PVg5rTgJUr0A9AKa0wNLyTr9X7sPsjpBgDEkWdMupg5jGJRvDUtCSRoBg9COif 4XGgqWuEafSnRtWaIlA9FVgA+2qSvKXK/RU/0RGLv5oKpKBsSbJXCLMCNeQ3wF2RqMs6ShoU j5R8E9iFKPTr0RnJB9mOpLcA02TZ3RCyngFaoe73UMeIKEKjNmy72nI0AGEOTLwz4WZMRo8G X73u9+njJM+Mdy7QNksZKQDOMyFKYkst/r6YeYIXGjkWiPexb4uGv2nJvM8QY/WNelBKRy7O YRmvTIkeLWSIuXE0XkaVfURMVbwuiFVPnE5OrlTY5OsAUAIGXlZn3vlgDMHCl+v8Oieb6rd+ 8jEnM7xkbIR9Tw8v6MOHTIk/VsA1gcaS1I6+S6aOFQAOITjSiabEbA0KWZr3Q9naRD0cSo1g v1JUFVDogLeVjUYtCp7yNVkWhV8dxZp4OYGCw66Jv5h4RfBCvBWJDw+/KIEyje6wOw7qE2cC +Q17uHDFT9xl9k30OKCCRY+D86NuJhahEgSJ36058lpF/UnmlVbIktm0E+mS2X9TIUy18bS8 5iYs1SyEA6wDw2UKWof8C0RTTzjEdSRxgqBTRmKHIpu0x2Tr6mDwZ8LR4q4SG8iw6zRR5yzH zvkNSufIrriKCYOJ7gvE7HwRVQGGqlqk5BPNRCUbSmlz/VKRzmEoqcBZDZp8r9LIpyyYy9Jk P6aVEYOSxvvYbySycR7hMritL2ygDRk7iGPNBC/q/1zPj+a+aVyL4gYChmbeZj99wpYeAtOE 0JUCriATa+DapFm1cEthsUiE6euoBwiew23nMJK6ObFpviKEVFhnzDSokFG6XtzQTBYNsRxR VIQEDGxkUeYl9sjeR36AxpJAsz/iS6UChQAnE4T2WFmEG6kRvcyShmKpQ4Kio6NUvqxac6Lx NNG9TIhkNiThLugzhx7oHJI5qaQ4nqy0WpNx3SLPIYNHTQwN/j4vrRd0wkB9yK+pDS7NShzJ UDqG21lT2BHK9mtsW9jIyC5ILWhk/CwI9/i+sO42dZoCXIqzASYVsx33lFYuXxiPHatPsy0x uQYupCfq7gp7jVIpUm1CpVwBNNtIZNODBpO9DIICbQ/rrrlhe7Wi71jcXl1EaJj8CuOBnqrM zbYGoOM7tWu8DibU6woKldLEfCzALhuViZMQSzRbjpotyqwHodx9Tl6EdsVdVVxLUa4otxGA 3dWI+NzIe7DrFbTmxqNDoxGQLi+WcjSXazdHbwzhZI06131Ao+XiIQwSKxUjQeONBFxC/uW2 jwjX6ukLKPrThMWamv2usB9sIsJQaXkJGsQZ1CVLthwHXb6FnShadq3GzpTD9jfDtgo4KHof ZDeDyiF1peXDagbRiw7lSVVhdW1ZYTl/rFj+62pGVg4wv1JM/3WljDqZTzLVJ2WVZWIWTctS nhSVDxkwWC5VcRbU1VaXlNTIJzlQgrwQvIwAYH+z0ch78RVg6SduB0tOUVsqJoOxlH3B+wmS 4G8FwBBz7igA1LD5CytEVXkVAJUlJcV1xWUDqPK9CoCS6urKIWKw5FRnSpzxqquHVLNnGeqz 4sLaQv4EvstUn0HLPvGIPctSnxUNK1WfZavPRLNaMWFOCkCwmjgJmJkMySoS1+aVJDxNq9Qb 2L0ax7kUNmIAfo8avGHnpfnlY3xmXkkoY8SuElBxonbkOzeoTZsVIQcMqaiqLqlB71C8gykq qamtq6lih2DBcmf0K7Hj5KkgLyktHFYe9RYeGV4XhYNDHcpotCktK68tqbauQF3AoGGlpRWF lXVDKstHiucqolSXl8RcU+t9GRG1PeutEatnSFVYWzJwJMEoauVMbWWXoKHFckOwUP0RXIyi ssrC6pFRoK8tGVEbs9fCmgFlZfCjfM5bUVj6UfHGz2kZadT1VGf0z6ej7cccaljl4MohwysB VmyMqpBBdh6OUtwsIe0gXEdM5n1KsAKcuPgpUdthACtnkAKY5oq+itE1AVVvFkpQwt3FvQ2i SKrpKYueBcUzaITBISBlbexypkrbdiHzqQNguTnhhIM/eEG3ZETKBCCVgQS9GXQdadgBt1Ve UO8yfG5FOIP3Rf8oar+DtryesrGVshJpuQUDLQejKnwDL8Y1hnXLZ3DiFoe0l/u+uGFbiKlS VMc1QAfaMLe8c5lSejWgRjd73oxODZJqDREnIqAkWpsLz0tao9AdUWlXQwtUrUOI/mCERw5t QGhPCGxPbpwuAG1RyZ8mrlR0J19O2Ji+KEALiq6AqPohQFTavuDOBuz4LtIdtIPjwZVJtc2I tjyiDY0MkAJHODqnqfITjJNQ4xMCuakdeoSjUWhz7FN0VJR5zZEUkV4of0xqoYtgt2yTtDxc e0CELXH5FkXNWBHXUEXAGIosVxyXlNtB9KvXI+N1pik7cJV52DrYqTUwJmWQ9ZSxJd1j1/LU 3ywyoYM/YUqbxQWPIjkMl0xHAfZwFAUhzAhCBABBm3zYkbuebWwMfoIGPBDB4y6ZBFSMXjHI sYeyP84bCvgMXe4Hl417srTm5U1ySKo0eyQBsAliOVKoVg+G9BmDZCEmjBrNbjcb0m4RPSwW HVPnNLVge7SEw76gWbmS6tLIhhdzkHBUNuQeVomFy8WWmB9BG5NVSpmCXuSgeelhNHnvZY1Q qN9v3nfCZi1ZJUpwNAGjAQ+REDnYTMds1bit/ow0Kzils4+3C0UlStl0PmlCPjMcQgQfSBGW pPnWCEdCooGCMdFmm3LQpiXawAYE0IiAVBcDBDfksuTtNCKhJoMMTBK1MZ4DaDBbLRsIqptD i11NGBq4e8r6CnRr4AYtF3hVIxTzzsai1nn0ESwO/JrJwsBHd0mEYlL0Hfn3W/g3KUzhdOtN ZAUjy76be2Vg84r/lQQbiMTRA0z3AYXQhbVbebiiYR6dOC0D+T3QDuhXJpU+M7zRpUQ2pspo FDWwA4MD8NWIxRTYinWQnFZudygMMPC3UANkvDV+Px+Wa7kMIm5SPZMZpF0U3GjagnAkbg8K h0IBoYJazijFHt9GiSI7N8ZRlJEm5oP9IL6y3UK4Cqr+EEUbQqzjmIDeSjc2Fvaq6IywqlJj YIQPMRpWwtbZqv0zDriQYdPZACQ4Toh6wKbJD/VGBFWQDC04Vil7HR2k+NiLVBiby/EW6Ea0 liSMGwYvqS9nID+m9NECGTEt6UEdQAl0DDqgIwOHJY+zSB8GUKEadkVwKA4nbl2QNh9y5XvV /URgMo78vFazoHOW04iNUOLLJaMRBbi4QPxwocEU7wOvMi1jhBSiUS8C1mS0Upz4JvHMJnZk N08Zj1+gIAShSru2csQFys+0XjYUhTcwuMBJCmlFbDqO+ZuEUzPeyrTjyHXRQfkiZIGxI2bz xgomUbQSPB/ROi1Zxc8+fTRHCgohLrQ0yWAt683Aey5IkIURU1xcBDgs7k4ObofVCdkHuRi7 GQ1QGJtmCriwMnXs5bdQcYVwBDCgvt56MZsgmDTYwPGpElV2f0ui22SKfdycJMK7XEhm5Q4j IYpcBDLQyLRPkw9Rt8vmQDO+x4/SpP4CaRBDMI4HRgq4JvgCYJxTJV5acVnCmy/Xapqx7Ehm +ZYFBNCiil8Rc4k9eLRCmr8CAfJTpBKIGxSuUQ9hWtCojZEKDOfhNlOLtQ/wskFXiT3xZhlx QqEWDFuSy4BXmBZE8+Kw2QlPEAnkzQePKXEDNYYQPUb1OrJP044cdX9StFLYPV5dlySF1mBI MO0QqbKIx2bIJ7XKBZQ1iSKqXXGoIifjfDDobM3pLm/+KLCIC9Tg+Cc2jveVh/WRZMKkGPAN 4JsC7Lyhk059f7H9o9eHQiD+wI8YWRgcnZ2PTiKjN9QcJks+hGc6HBr738vorzfFRLhYFLPY UBNgWRSOmZSIsIw8H1Y0I8FARt9FoZpwzAnZRcEoHrIj3bESwfjmVay0k5wUttwUGSn8h08I Q6TxqIG90gfimJwOOhLosyl5uyFcGi7p8OKBWWGFwkkCYfZ9UC4ayIhMwTVIM6BJFbRXVobr AooJ77R2xGi+tiuBmDSqAiLS1PQAFG332LGFbQxcD3fK8QgKMVCihAYKBNTQ2ms5En4UYZ6S RIEnooI8941KnCfqwcMO8dfEuxIB0OgjFYHPFmjzHBOAoiq68LODtVqlSIW4m73trebokJcv DtFZjsnxmmOxuQRT/wjqdFfGu3xWcVWcMYcMPyaBdSRKai7POFfQbXWSclQUA2OHl5CfL08X SVsmt6dpjNZwyXSfEK2IpREuQwgFUfyLsyKr9Rdm9RkYlhUhUdUViQIoYz02jOMCQVyEKZsn 4mUw1sdBT4CYWCbBQnhaG4b5oMM1zBYDWRBoReBZOpgGpWnDUI+w+Imgj0DIC8gIXNDQsQGB KXlbOYsJvGiZiYiLFBFB/LLTTqTDNJ7MZFMMBZh3YIl/oxMyZQj080XH42vJXGWyKYGXTPRr ZgqnXxlGuTtmxpBl+UwnSQUebhnIzDMQYbsuKwBjKAkTAMFizUV5dTBKIdRdEREIbfgmIAPB GF2Z+0DrxTS0MDu9Zi63WaELJIlWf+QSFzkB7ZIHEmeiXExSaiErIzGHpM6HcSBncdappiqb Fk/8KdB8CTAIRO8EeGPTrNI2f587NltHDeU8uQsMpFdTV6IYbsIYxSIXuzdM7CTzk3Bi20wb RiO2dufRCep3RJxR5BKKm9IiXYRCypwbbAxHY1Yj7UAnkehgzM9bbl11v/sCAaikFNEhBxcl UdU0xqAumpJYQ4N8Bie/cVN5YjiNiYkyjITrq1zkoVusBmqozZ4pzgD9X1EamLTd0adEZq1Q DCZWv9R8RFd9aJwIjzFd0wyWBhrrUvtiwK3gWCL6lsL+mwN4zaUyAKYxNJshk0vmUpISsIBy UErMbMD3uB2F5jQdZ+wkfGRSQmrh0hpCIY8aTMz5mCI74nfJ0i+IZAfcfZxCeULN9RG7yZuR 3AUNxp7DSBopGlnwVXLc+XhGGXnKlOheylsm7UGeiYuJw25xwnHVDcScIAZkBaH3ZBQ8Ygzd YIcU4SEmP0PnTrJ5O22aYnQTUcRCTSajpifFHkODzPNTlC1ufSBSprB4ObkYUA3AjCKkNvPu pcSzuptXmYsAYLIH8zh3tvEeZtyqYUPjtjAHst+lyQ0+40G2dkuoAUXuS8Ap1iDQjVSLSXyz DgwMfA4wp5LytxlGW2YQtkwv1Cuzq4SfnSMnOLHU2Gp9Ug8Krk8TNU9ESc0XbFZoENg5Dmdx Z4QvjtFdsbSj0uVpCboC3EkootK4vEQx5KjDkPzpM8QxYc4+00wxU5xfEMF9PD7D7QpDbCVD 7OagiYnmPuUNIUTBzH/ioTZpQYxy/JRgbn9Cv08clILPW8UquzWMxYqI8DLu0IYmZZ1ddAYJ aD2Gl5D2AkF03AgHtJQ2zu6WKQKR34WYQMDA7Ym4K4g6JRUqSMIr9cASSbiQvw5NMcksFZVO 79HlWQnfSwK/reLgTYANR+ustYjjMe5afi/t8ibZf6cHV4TfKU5ceem5rsmjFyweAUgjVJJm 0d0pQzQ5m/XogG1SiogNpkixW+Dm0SlQnUAj3PVR8RfWhEmlzaI4KQPJZ9TNsln9AgWa7B5I bNb0MUvfm+5lSGVa+HjsARlq0fNHKyeIHYnPW91qlM8boweNVsM6pc9bHebP89AeuYc1yqUq 1SQYr1WXqp1rJHG4ktQN0GhD0EWnsNka3YUuVzW1gVMROuG4Dlozzjehg9aCf/EctJZriGjU JBVizt1aZBJCNF6SmgylOPJ5SErseNHOXhmoBFbdmlB8hxwnbpQEBMajenJ+JUgLQP9dkHrP g3Eo6MYiCZ60FAqh4CYhawkD5BFeFUKMxZowIn6DMIqTh5WaKo124iYhkpMmI4MwUXIHbt0K n+VvH7FnW7xvQvr/Ed/2kXq2BYB+n2e72Aw8/j/Vtw3ZDqY3O9qTjaMduTfbvK//BW+2eXNk LRCB2XwqC25LUxOCCseDLBOrfQFle/4rycLxwKfoxlIR1OIZw1ISu5rl6v+3dDWLk63rqRxD Txm1HBVVAMO05kK2JAMc1oVs047cidyqC9mmWRhImQR6fCdyKy7kaLPWYZzIrbuQhVUrrhO5 No5FVcUWQQVUL7LVsiktiKgCc88LGSIgVSDNahU3g+mIRcl5uJpEF8r0tylXKq6/N01Ommhk oP/QdB60/6BH4kGDHuVetDpVFL/dcMx31KmStE2pw8I2qZTFsCvxY3QM5uawXzGG+Cu2OEBi 6RdWhGnF90WCL7m7xEJClDMZdo0XE9hVxKMFNDDEahQ1RYS4EDWi3SzzwxfHYcOGU6HDW/oi VPmHkAzD4RhuDmLxAXSqYNkiiVfiYKjOCQim0PMb7UFNwp7M5qDg2HqqhmCtnAKZCEyFBy9J iH8vgr3tpq07evPoWImyrUk/rllBggtl6POSHcwN7nOLuMaAkQckTRpKKn3oo87JIvnWKk2J UE+JLcqg5KoTqUfWqjtYNkyDmt1oAwxabWMJLLh8BrA8Bz2pIW8qTYEh2CEyQCuLkF4Ojmjo o6RCWbH4BgAQYf20VJuwM3Bl2DKlmgHoY8dK9hXify7p9LZQZZvGSyGRRikwyzS5CWcoW6QC f4ZnfAHyGG2a5SBJ9JPFLdmKrL4VcMnaVXkOPtN60UCKKRZ1GQxtIeME+nki6sSWaYUi4ad7 hv47HehvWuyoGqmC7FMk05hBRlUEok+e+zlRLCL6SFeJ14Vk10I182NiGtfiiV0HsAkBZAAq QcjS2skdPeShtlxbyvHi17Zeh/RIlHXEhQZFhJzjEGIP11M6RzgjRRcPkg1kkFbaKlQWrLni bkQVinAQUxu5rob26qBwl0lXNxXjkb5gHstkarqxYODVCqRwHXcxAGiqfcZTBK0OU+DX6AGx fIw1JLNzMMgIq6dxiin9ldFUiIhm9CkDHYm54AgacXslCdbjrj5NlCSRLg1eaUhEiJmG2Rh3 VqwnC86O+7IGhcZjNB+3nFu91NI/xHUZkcKs1ntLhiJa/IcoSZQLotGuSWuYpuKhRIOjTTNd TpbInVivpbTmJ3RdFlj8p8JSZzGtsfkh8VR6yGKr9GlaMlwaSEe1aYlrtABdwjRjpG6UkBqV kB8KSxs0eDfI3cKtBFRxSDgHyapnmqpNI6O0I+MtUPK3rXEgMhKBU1Ne6VZ6D0G1w4MXCd10 24na2DRJb8jqIMVcUh2w0hjIMk3sLOD2c4OJzDtE4xHihIWDKlXzpGvRahWxK2+7/ONdLeIo 42hiAMLWBEc7xw8cBauJIQOMWnpIUDPTBImBwKbrVicHWILgBF/cfZBzlZtmuQwjaYaiqElG gaqfVezi11fnCctC9JcylxTARX0BCVovlthFF7KHSgLzwq0QNQP3hgul3D5EyidfVY0eKZbf 4LTgr5XnclS+VERJdTB3I0P4YJxr4bI4RmSir2pJ9mGktUFyypF6cqP8hTHOXJtSdov7c6PW AoEJiWIBeDac4oAWAIMogUg0YRfCoHIhqEAorSZCkSrNaDih/SDI+I7YYbGryvimqJeYiMRY 12+uHDV9hs/cKqwODCXpsGhFFJcBcqCkwmPqE1bf031wLqgkpYraiFxZSjWLUEr/PpHRWlML EsIS8HE3blhN9LPDGrmyx8soIR1RkjpRvVaMpxmokBcGLYUE0efowmITXC6HBbKhTPmERx3g S5hXkCjUjGuccmgZDQ/FBUEPg7upqmxqXqwl+RdvOX9Q5HKPodx5jMAhw3gE6lRoofFB1XbG cUgtxIPRZ9SpIObkfqfT3WSuNu0onO5RiB4nZg0vBlU1cjcqrDueISfGK2+3JP+DqILBAa0Q ONWwGN9DqljoKGDJLMuYLIyuyHoBQ6A2RigcMIvHWMpy4nHyKySzV5HaHz5QgDtYDhsscASR Aof1SQmHFJlxjiCugGIL44+l2KhsUbHTxMJUUQO5U+tRB0rMgS2aBB1l1IGMOSBdiKIOFNEI o5vLvFFoYcZwxSkm7GohCSvIw/s5r2wJusn24w+FxpAqRyE9qhjGFRtkymCodoGyx3AlhGqh klyvBm0e1mHzf0lghLKbowuMsLj00dMXdYMShi8cLnaBQi5aD1+IF7ugJfgP6qeIQGZr9r9S l9z0B5mvwDFwgkaMO0hkXFT1UFmVLHR+mLT3jHiOvoRLt/yHFeModfgoPqDAgqP5gkHBExpf xOSho5snUH60axOFOswAEhF97gpSgTWlMrsaUWkSIEuUfBMv2cIdGKJ+kjQs/v4qABiuQTEk SnI+D9pQlJHYjEl6RylxV28py0GOQrW2RlQVenU+82Ri56xH89l4IIUNLgoL5APRV0J/ptR9 pbaTxubGCtDckUhLNY0EXHILg0tdy01Lc2arSnSiVWtaORWgVmuYqBmj6IP0k3VM55Xko4sN IPEwq2zxul3NPLiBHMIUUkK6HeTQZPOwCEsArqz/hqKiAKkCTuByaGZjG05lm0zluwSBko8U E46ban5PE6rxPSrU09RoTNE1R1hQI7o6CbIGipvAyHhLvAVAncRNxbFA4hGqLdjNRVXErIX1 EmzXYr3l2xZ100nc1XmPTxDwPRjo4MzBpBJzQPgL66q7qA5EQkFZVHCPCoESTFEI8xjvr5bc V4uk81HN9gkYV24WJLVjKAwWPqUIcypjEcBoPfQFRxeXTeaWMAzPtPPxzJqdZqJJTGVYYZbm A2RkZ2vJzUHoqBPkHko8TqXcPGAjNa3hFni7RaHGZgNszswMCzDkyVrpD9Fc5VYhb2J0zzAT Tfm1MW+05JwINW4ukqF68SxYYqI+TjLkMDT3BZjqyoeuF3mjWCJedFBimoNhGQ1NawXmYHl8 MEhnNQejDjaIglAvC4t+JLrtubzgMS+eR5vB4nUqrYDhMMZKClEMogryovjKF6WCV7AnK7EV lrlIc1CPofYyJhuzfnSB5rTgOOWrvBidgIXBCFWVElsYJsnzvch6AnW/OabDYpKxzJ8OGlgo jCqIpfwWRM9AHI02iBH2AHqxuLsKpZlkwnIuYgWg10wKdytDlS4Qqn0BcJjDE2yFBCIUXnUI WEgONwdTyfAPw4ixAelLfbyfEq6eS4QQT2OA5w6M9mAzF5yBN6IByWo8eSKEZ8DSfile2l2C aHgDz8bDIw+l9SQC0YjEa4SPTVoWFbCT0Z0ghyIGBx+NJZtuoB9KBR77R4FGzEbshS4V9zuI MjYwThxMwEpRlgNExzschS+m64TLD8AkGyy1nUBVVP2a7MlQxofvOSaDuapyoOaDHDbFPsQx IhrtEWEoESFBTQie3xMxCTuq40FsJhdjleB6oijn4JOJn+i8A9NwU5h8NWkELqoLB0l5WK0z YlrUuYYlkRwTa+3ktUJxHpVCYkph4tPUa0Ktz2eV5IkCWIT2/3XFglA7U+kLjw1lPEnEhgbF bzQSjy3Gm/oHSgfZUAqPVzLsd5UOQsyxBKfKyKzDlA7KiBuaGiUO5iuxH4lrB7WifFns6r9f CRP/UcE4qlDe07SBHeUoVJYcPqem4qr5IDqWXr1yitFNRozDVQ/yZhlYyMUtC0LFhl3G3MW0 aDuDNdcLkaW1JDe79UTNzDnMpLO4n928hpip00XVj+Y2dGtSNVYHN3RZZBi1GBeVi1HAkdCV Yimsq3zAxSLOpbhLGTsjJFtgaaRw5xs01PKNoegikT3NrlFzkHgeubhFGAqv8VGvUj+7edOQ ioNoCgQWxkPhQiyAvc8UMheEYGPTk9B4NPxEu6vlXmSmsSsKKD5ivqKat4zFi7s8ZGCNoTDZ kqRDUkgaOg+tQzMb1C4Ju9wtBeZwbqxCrQejBuU8iAdumBAQIh1FHyt74adVrEvnMs/WVDRX y5WIsqkZup88G5QEoqqDIQvmZti5YTAWoCLWhcsJPGtGJOhYq+T4Yj4WSSRctYqjistEfl+w tQXi9Wg2hNUNcQPPk/CQTpBjD5yvtVeOK8YPppArCkimNxgl4VY7FJg9/9PevzS3kWwLo9i5 Nzw5cMQND2wPHbnR3JuABEAESErdVEO7KZKSeJuvQ1Lq3Z9aF10ECmRt4tUogA916284wn/D M/+NL8KeO8L20BMPPLTXK19VhQdFNXs/UOfsFlGVuTJzZebKlevZilgjPJpoQ++6+RNlxg0K 0Khzdrx0NOC0wbUBhoEZoSWjjvhHaDSkp//twNqgaRGCJlGpe5McP64+knhMITb+0J8nFPYS uMFaqLBMhhh31+CFVi+JI52pNhoTN7SmF4+BTBhSvSK+IzR2gNcX/Y63hDSDxPwXJp8lt+SM pUbQvLCg6V4UWTPtihuuyXVaFH3i6CscnJ8aR/gzqyAlvwIP/X4sruxzdyIflek8Q3QsmzkK KyiOcFDAV2qdHUXbQLhuZ5blyVTyuM7xlEKtg/4Ltzyvov5ICOppYQ2NQjftzoVXfcA8hTPI xIfmfGigEwIn3pfzwezRCYYHWOTRfKyKwyRRTlyXQzkJhRVHcJiBhUUGrMIgMYY2iWxiF7QW nnPreon7EryHn3yCjis0KxympBN0UYlCgx06kodRkjbrA2+oPdcYFhmm9MmJqexoeo12kqg9 KSj5isrX7ooRDlDuQGIKzOTos0HTYH0SGifQs1uTWsQJLeCq5txZa435XpJwp0yKSsUzVcwo qcFfxiiNo/PHhuszNzv8W0tqmvpqy9b9nT4H0+EbS2IzU6c+6y7EMgJXCzpJreQujwk+tyTG 1tcjcU709r/1l+uE7ZH1CCNpM/oBSSsS7dFZvzN3E0eGmK7581czG444UWkdZ2Q31pbLTdNS GTtOe0ZjMTSKL2MyN1V0d+r5MNNCvQzDgeGfMyIMk20A+maRCiYYSSJ0Xut0B/VN7Tjzjcex +MuGcXY32m/XgtP9SY79ibUgyTDCxKKYNbVHeNLE97gbmvDVd6ngKsH0Atp21MbiRJU8YexU ZYW+txNPi2OAJjaaY7M1XXpAOE2znVHsXAG06DMGgggI13GZPTGcgCXPGJfsuxFfWMJrAZHH us0aexkxr+qYiLCVJPtl2IJmtAhuN30Km0DMsv1LTk+SUQaFPXCuLOaO0qeEbAiq4KQ8ERPX IjOSvfBayrCCJ7hkh3GRMBL/NpKSE4PFqmkhTHl1ltJ8jb6pi+G7yM+DrBCocL41Q5ehx24Z RDBizOY21woHJxTbjgfOElkbk9Gw4yl7Xx3gKUEVZLvd1exgTprAfFngsI9cRByvfQMcAef1 XofrmEk2TlER8LlEA+HhVbrBovT5K3WDm0Yn+DinxAlr9KJm+FnNwO6Jei55ekWG/zhsQcFy nH0IWc93TUyEL6IN4RAVOD9QaI68LVyC4MBuQZ1R0BNxhxXu69KURt5GWJVFH4fBkG36tVqL Yttr+bzcnlmdR3cr4s+4M7dGIsNC9R5ZoJAaCu6uqHq9FfuzGO5L4UeydmKdd+DEz2d/Fd0+ 57sSpVzToWiAj2PU7Y2sw0GlqdkSMmvVI9BZ02wmJjP13srx5ldyM8ncufPg70Fcu2kjr6Rw r1BMiiTIdpqZJ2//4hE0+Vhvs+2uvsT5TlqSOUJvNE4MmthqHMfqHsJbhspo3gu9Re024Rhw Qn/HlPOd/BWT0T6Q00fJhg4gKVDkpDXtsLzDNwKZiuyEyErj2y8N9683pKPGr0DsxMqP9tm1 G3VWTlvLOPYSBoNtM73EsDo+JphN0PhCaaDGGsZYycx/Gz0aosL9XkZQZ3czTWJL0PRMU0/Q r7AXh0O49LhuinppGg93xzMPKR3fQSK5/o2S/L5hlEYsV2xnATX8xZlYkOBdBY0SWaYf2BiU /kaRNJiug2eEcrvNmMKJlIxpjnefFoprfUQcMZCQC1mYTGITLovOghRHElmLQWKdJkX/ZBfO joPa/SfkrHQkFcVburaqrz7VhhYoQ6QbiBgVUYw71ICS3YYsAfxqJGn6Bs6TaQ3OM8NA8Rr8 3e4j8+iieOPeTw9lM7SSrUrGEncohA2pMCm5dFs7vwTaTN+xWLHeAImrXsGXbZnmhEu26qMU octcLNn+2U5gIjeIPO5GTCZdIisemLi45GZRLok1kFySKMGvM2C+HfkSaJsD15qGo8jIcZYd JcyQCpSKWksXz3sUgZsCxIReWmodM8mEWkjG7TU3lqK9vYnOlbYOh4Km3VFio3EdvIoH6o0T W3MSI0v0XDSqopwBt3rTs1+Fzi/thcQq8UeTpdrGnSZINog2ynnY1gmTIhNVHI4Rvocn+QQb pTNu+eboTA2slsGk9rJ6HiAHrXIH+U7H4JDAF9DR+mJIoiX5hvCqldXKDUb0Ybk0ZzJz+rIc e9759FX8gNgGK8+JYvGCk1PKZlDOUzUyrBgPHJev1N4WZI5jffHUui4XKyhppnzo7aATU5wB KkpWaY5RGve1Hzt2ZiVjI0gzpBc7+/p35YSSpO5p4znH3N5GQefuiejkNknGU3J9GefvTEdn h6S7r021NQWbyxDZDaplgrvT9jFs9mQT5M8LaEfiwKysZPc2DtbGdwlN3ZcxEubVPNm0eZoN r4dmYamYYrMNr2fPqlHm2bK6rMXIR5BhGwzht2JZfTRdX6A9qeO0wn5jloG3fEuGzTFBCCwF EFtQ7+KgRbKkXBBVcWIeMHI12XXQ1pBcIJ4psQ4soplJ6xiJQHwXG2tPai+z9lLgd2GG1TAd IxR0hfgC5UaEEfWpp+42hu5+CLm0aZivF5rTRNuJVvjZJtoJvJJkQMd1SVpoE3XBqUW/I2tl 5sWs4RGyhl1MvVl+6ZhmM1kX9YgHC3WAtlxsk2AOo9gxjk86t9pcIjqGP84FLQ7JWE/cj9xb 9DylsqWJ6SYXpsWoBezRgJrox6EBJXuIxR3kNun23Cx8kz5evPbIqhG4nT76ro6N5s1FtZR0 kztK10p8TLP8gc+7lvYS9TCsHCs6rdGmuWIT6zPxMzPWomRZmM50zQH9JUq3XsQlmmieQxul CEf8imkfG2k6toUluwFkbIn0MNSQpw6Uw5wV/BhdW4sgJIpGguYkLAq6AdyZRuNW6Js839sl QEe+sS4BgMyUS0DYIwaRxktMk1tVCJ/2O5b9orepWHhQEoqW+Buw5SbfZA0XLngsJBGrY90J fQw8UqhN87Pt8iUAStounzjy2ab5HmuyCGL6BYOYZpuKqkUUU9/N/e5hTIV74ZjAM8KYTuHG /+mNbP0ALpPNbL0jAu/FrH1gU9EZtrQZhrRWWecEnOOdF4j0w0lwYVzxKylr1kkBPliW0GPP WWGCnGjTvq2Xm0DCdsB2TrySP9NgN2mt6zDOCYNdOkf9mA6jLDuhaSbKiZ1hIz9kyJu0cbIf ApsdzIlkJa1tyabPdVMfU/Q8G+RTaK4zYjYXCmIrh00EfNI3ksRhMqcZ3cPb0GVHd+Bd0vIN 3XrL2ptopMOpD9hGlxyKbAwHbzkWKxOQMMl2ztvDE6znyJKSsp3SjMfJKZ9N6W57zRlWQCeX 0cBiO8lSSvA+Dn8qQY0oDC9ZsDOnp5cPRbcZpC1uOROPyYlk9HhtVFXRWW5CBPoiOxPLK4Y+ DkQY54TvmrQIcdDJtZcxBGMOKx1xlO1C1/w4vbgfdJPp9dTrZwLnq4Qe6GeG+TBBCuSSQ6el dTBLxKCgkD+epNJILE3+LElOQ1wDGeTpeI0Uum8YquzlQJkicDSZYRP0zSTZH527qnObiotR yo4ZjOFfCBoJzHl56HGjwMReKB1d9azN8C9hYcpOh3hwNLUlqIhEPPUfC/VQKYGqUSN5dlYb wh5gQreWWHDhDXXYEqRqTZ4+5I2jmiSj41B7XIpOELxqS3SMSf0cuTZ+iT3772yy6R719zPZ dMKkuCabDnfxmSabEyMGOtJxa7SZsMXMNsR0WZ7EYvhHN8R0u3kPqT7B9KX6E+fZsKU0Fs9l zYm+OkCWeSSGhBJIh0SIw2AgaiQr6tRhsivTBfPGMlMMNNyOjLT4btZkThEwPNBslkwGzKSU PYvrnDn3/wD2IYk1kmEeogm0G6jMsw4RRnke6xCGJekTAjIeG/TjSFviaJuvqNXqSB5MvG9K azaLtRsj2bXgQI7YJgzWWhS6+YnUInVd9W30GBoxm95VTAhxQoCZUt370Ucn3coc5nuK1cj8 JiNsTjPVamSiyQhNqqPY5YlHHd45zNNVaN2kvPmnmbNpDdChMdKRK3rO+LTZUVZgNRgRWWU5 S80E4dcaScegqwlDpORhkjda2w8xktth2PK4CYmE5l4nBsCmaGPsZHnypE/QnAe1nOm4FoDS gf1geHmno1z3FbWfrJEoKUeOj0f5EOXLbhJpkwbT1dKQNRHpULSyM+wGHFJfDASR7Kj+mUS8 xFvmRdQeOQyaF4i2hZoSabhizNcZlFGFlqumbe6p/oLg2DBg5Ee8jjKj5LtSP1gvmJ9SaImO sn3XDhirbr8HTOr1YeBSLTc3veMC7UKlbW2SlTjx54WCGXmVThCqJ4DSGw5uJ6IR2bFylXtK W3Gkj34bbJ4WwFkAG8Q0Y5KJp2mydKFvzj1STRQ60YhcyzDWOQkbn+jAKXAaRsOiMzd8iJr4 fcbxViRuoppLID3RZabr4qgoObzFcJj1dtgrvYU3uY9GzeGEDmy704e5wrUe0rk5OtnJmQHX wWTaZvzCCiB68ZZuM8GbwhwpyG2C9WTp2JEST4rNBQxSJRiNzYLh0gVe/fp0xUTOSieai/1p 09pNuUzRPUxImIQaZNl94M+9mAyNyKYolLsZTpW+28s+l6H0WeGP2ZJQdjBAgs9JTyJ2fvYj 4EuidOWK+1kv3AzSK8+5bGYIdY0SguSyOjo+jVNHvDaWrvY00CbnOsR1Mta2w5BmoN+S2gsd oJ9bErXlEInJt98izdM6JeFe6FyY4xI5k3l8/bsbViYbIktxNyvOJOtKdNBhCmiZumlmh5XM tjyrSmt1PkvKXZpqVumKPRXZEXuJuJqcY85oXHUYbexx+QUrxdlVxkn+brW5kUMISrijeIeR hZsPQtSC8EurZ0lPZ9SzbAXlaWjp6MmEAmuN7u0sfDPi+KHh+9iEY5o17OgCOs5Kbi9ybjL8 e9pBjqNHzchOJGyatO04IFtPNBJtJTQUXvaO2BEgWHHtacIulixUY2NDKDZpFGU2Yo2UY0Dk IIS7QRcapEvaulPHWRiOQys0IptJGcvW8ZYOeWDfkEQ0iEX+ic726WmnCAUTTFFDsbJrdIMb 3TE4/mOxc2AztuTZaM8RMZOEfh3iaawbJ0tV1kVoM1cPsGDbsSpWrosNv3drGFjaBllOY6kM 7fU4CLA2usXxsNhLX3BMVzRfRta9WQjhHEP4maA0L4BUN7WO3hot4wSxDNm3CNbmwONeR2ev klQuaHfmGoHoJmhjyupke+qJvcISv3OvdBM6c5eEjeq3J5nEckhfP+kvs/LoooWXO5uiXWuW 2DZAH5faqkuugGZe7ToW0Hi/h6tngKlgxHgndpXDTlodHcksbURvNqVWycoNSrQZaBOjIwQ4 vfPTyjCX4ux5k07diUitBbzmZutqGjjOaChCC1aBGKk0TCst+U4cMg8U9w2xvdXsCYVt49gk Etfa3K5TJ3fSbNrFu0ehEeVoDcHxfXTkBT/PASGa4jyQTZhwx0SCohHmOSBrdH3lsFQP6JVj GFJJCie06aXWCpv8b33dkeQhaPudoTdmvyqNYVeT4579WkQgN0lgIq/cWbfXFvIwdo7qBK/2 +h/DchtTL0xIKF5KCHDnZ93GPYmTiERHvdo8Vo8YTFaOcl8S7w0olaJcLBS9tBFsVNHpaJ5d 9thEw+6IdFfdGQbeI7HGqkxOve1R25FjQi2GYGW+oA2jK7O13aTbQ7ifkBGslgj6xtQJm3G+ gkyOKV1SaeNvA1DC2ZJxGatYxdpSBGU666HY4O5w1rhJoRnllmVMP9kjRqR/bkgjK7LkUKNO d/GKlzYcr64TPDTIUqu17zmMntQy/vVjYylKd0PJe+TkZ5GceI5Fiw4To7fgiY1OJ6lH9J2L ItUKejGTicxRYu+aTePafqc8b7OjTFpZBd3oAnMiO07xSW2guz1YJshZz3QwNHOCTItHmW39 bxVldKnXfUsU1rQt6oRMVPAeC8i1O73wKOo1UNxXJEpy1QfukjZ+KYsa8H+RGmhAZHPxCNA9 PxD7ksjKDCJ3j9gA1CWF3iK2R/AW7+zzgdDDUpT+1gLB9wgl42or65Jmx0uCaiL1OsnmxqIn xx9lFJ7xYQdrpo1iHBYY6LwUfqTJSDJsh+121IxIz3oRuJJMEQ5RWO/oSSIzkOQtJAUdDism ASCJmCQqCclrJVeZDTgedyIxPqa9jUJa4iF06l+HuAF9CDttF44ni6e+aSkzsGSxmCq4BztL iiT8SBoSmRCYEIXOZxviTqeJ9o0yZY7k/J5AI1Bc4Bse8q3fdfpIb3FNB+ny7J2UctRrlhRo 7LBsJBgan4yhXGo5oeBiJMGwiDqTdx0G58Irauzo2B2rjhIuvzQ15T6YvNAVr60d8t7nM8zE bcMrOR6esggs38sKdyMgdZ0PrFU4RaVw4/H7Lh5OXH6br0Xot2btnDSRkokAhgklOsCF8kJG GS75V2joeu1zfHK6xXIaYM/2lEroHIMCj9sUa3kZshOJ301WrKPyIzuN+o/rHsp1OEiMMwo2 1IuVDlPKx30KV95p6OxzG7HH8qiEEWZ7LoKrqO8nxdZyWN2w5DvLdLHRmsh0hoFUhIksQseZ Ca/7aBNoOCPLp3ixj00EWK1I0FEQbjNO9QzC5xdiy0O6SxFPrxt3MojimnCsnBL4TiwMmwmY ZFFJLxbHIDAa2Zi1sUmnp9lYIT7LROJcu3+TJIjyxzHzAF0isTMLeY2Imk8dGTz9oCniMzdO oUJyetPFp6BPOPUXICdFWQmiZ9bt8xiT4h4K5mdiqpK7HPN0nk8CearpzLzjtpFpjBwnhESQ KGRyNT2VLqCMolyG+qTyEr9vm06X9ALlMjafMVTjlSIHgcb/BKyIUqGgj200TmmXUCxS9FUl adclKPh+pVKBouXqhwqDKTqKe2c0yegtWsOH79uAiLF28yYYTm5dRxc4eazGVVaGeiB7mhDb 6w9tz3BZscHNSG7E9vzU4sjERcTx48xlnYSanpA8IGbHFEE9rQceEZMCjU+kVcbUXSRQWngF G56raCOCdNRbfafBnIgaPzQ6kzPaxts6cy05bgklmli9IulV7yrsRUiXkxgWAYu/6rWLmCPl ZxYjDkcjiYNkE667sVxFbaQVqXanAAm+uQjGNkwso9nBgLiIELqGfJX1m5mcZElT0tQNm/vh g4li//6b0QnqmyNoN9R4AryUBNPHBqkoKQKD+Mc5IzC2ARSn16+nQeudwUFfeDcLCGYJMFpc j89Gr2/vV1SlopJQywo2siPpF3JpiC39cMi2PVdlzaCBNzOegRFZa5NWk/GhzYgVoLTdtYwU Oq0jqt7SZnWnPvZM1vtDHT/QOBDq+MRo6xKIb5Ir1tPCQzlzy57YINEnm6tNC89atLejofp7 /0wj6VBbgWSSJ5ThzdoPQlaov2QiwMn3xjbvnvHrcPcx3XYDMoLS2ZeNbadrC5IxR4I0P/Ot d8VPmtRTG5qMWh8eTXEz/TTE2Fd7+nJJXp4Z/BO6aJgos7He3r5Pn6Nww2RMKKYWkfxIm7QX ZxvsazdITAQSDin1ntlxrBSRMFyBTqttsFHiCGNEBYcm0YiY0vckSC8SwXGEUQxZa5emiTxM TVZEpq/T9xKqUxg2fMRs+iJKdhOBEMfb4kDj7vSJoamJn6hwBvS6Fbm2vd2J/JAAUMzfZD88 kVmfzQaYeYsSZ7ptsuioPjOEnz3J36vFUDM19HJFmyN1pi+3TDHZcsNFUy9Xo5C6Cd4hPJ23 BnkiZ1sh+HHq8HqyBRwYXEReUdQfLU3i0aljRhVHBJK9gouvyXXKpBXXeQx5SKeYqlkkl3hN ITslvPyW1MqKqmsTMvhVhV+rtZKq4uuna/AHviGbtQ3GTrWysmHCeqBfJL9erdSc1zggfr9e WbPvcRSDtioIK13kIs8qT22Rj41+u90Ycb8FDZirDs6a7plJW9cKz8bnepDSsa831PbOy7ev +dc3G2rzZP8dThH8u3vwCj1VUUsGv0xoCxgNDIaS0fywe7B5tIuF4L7YJ1tOezLoIAdSSPMZ zFNpH1oAVt1QK6qAOp3hVdgq8iAOezInIxL3no2jDomPCiRXDodi9mSTH+GVrRwHbdaMD8dh UaMeUPzy7e7eNqcygr4SMCWZTrVppthJUXPi8MEpSAXKKiDqx4PN/d2txtbxVuN08+XejgWG aisYIMZj5bN0Epi1UnU9a7x7IpsVNhvpjfZe6kZsnaAxG6CswYwOVsHBYeP1f9s63D863jk5 wT6df3zkzIMQCyMsL6AciiSSMB+XkV5zmY8NUNGSaO4IikckC7H6THqwe4RtmxoBeh0yQ++o xMQYwpi6UimOO5DZDe3e2vKhpAdBYa6wnO7W1+XqN5krizMJ9pEFwFxXhKMC33RIvKnF5Jn4 rsHSP/oexgqHyOvGD4fH328eH749oHUVdzD4Moo0+/oiBTN3ZRQPAgHW+6vNk9Odk1MXXzbS KgcNwROv34MljoaITphTE6xMoNVKtdWsYSKDGg+GQDLaPNDeyMRwPf8oHwp0yyTDxHhkhriG 8OrqKn4ElAz+iB9hR6sUEDXm5HR8kNVWgAs9H1OYDDGqoduPiV4CwNYZ2KMeN8kQH0n7Dljd J7qTYj6LJhyXfxIgTxmIPlLEOBgh0RJwwACq2ZeeI87q66NR4xPAY7JfbRnqXHtWXk1SITUr tbEW+mVmNk6kNk6XJfWPjigQcnjT/kCza2dBHDWtsrcMK4OLGQDIz/ZZhB61b604GaX/Jc6W rHWTQvD1BV/HnyhkBzV38zdiII4AzSYzlJmuFD7WMQHdMLpGo5YevPCDOkCDOLHc9sd8m9Aa SHMcT2JtDEnDw15HK0D/RyUBZ+X3XtibQ2vjBT3gkZSmxa3d0gKf2NHQG0eEngnuZh0ojRrD xqfV7iohaz5lufr+lKYaJeWBhYAGIzIurTTm5Js6v5FOVJNq25jZikjAaDlGxnTUCUJArKaM ksPzWkSY7txwDjKvN2K85cQxc0EZLbTmHc08fjl3STfIuF9clx324dbvBSslobh0bNaSq32Z NTfXopsHjsmA8IVWKIve5Jix0omLwHHc0wGyUxkMEivcLG+yaLj/CneW1D/bCv+SYYk+Z4lr JCGk7EtYJ5HXeJIHoX/98nBIW2MK4fQR/tkRv/UHlr4YDOPPXnYE8Ossj7lgOiwS4iY1txlb ZiLFsJqBL0Qy7nxQbVtL5X/io4ojAsjKhh5f9DnNE7YSDbM1b9oY2g2omdbUUAuONzf8Rdc1 HQbcJilIxN0ZDYHltNoSHodTRpIr8LbFG0YUd40XGGGt2R+EJr+ex5BJpM5iBg0iOeEkMpSI kORRIWcp/qOctCIOSgeycfyFrsmlaTgcD4hTHiqOsYaKWd5209h0Ez5Ye/tM4tfRElxufhK0 ODahy7S+l67hZBoAw+EgyJXzj0Ub+k6CPfccUxzg0SNYu0YDSolOW1G/5MRetH1iozzyT9bQ 8ucf824gYSeMY1q970Tiq0jsZLIE1IYN6Dc/QLS3+s2x3D1gLMevtlT1m/VaSQq0tDI/SKny XVswEk0B7FeAk+cW52J2aVFvtRIqYZ/KdQ2xPP8IG6JHhJKpHNl+PRoEaPfvvuniTd+YlsKd vqdHqacEwZKnmcwhBlnnKRRkIgj/oAskyBLUw14U8sOzPNbLX5/liyRrMsEaJZq2E1jWXqMK UP6bvPauDky2pA213F6mPrW9RO3MP0Glp+18SS1fcBnJq13Wph9esiddo3qBNY65hk0MbzPO 25LHedpry6+W6epGvbhB6zpEQybwb17lKcxeaA49JxoSc19OgEDHa9HqlIIznaslTiU3B9q2 iajMB3mRaTtWOibKY/46nwp3O/I9opSbCpAXuSiLQ8nWYOkz2TPCnnqcN6bkeEcm5ZPW13Cy Jlk3vJ/t9tfBFZEBtgtcdA1COKxUXNazOzYaTNDitIahVY9jfU1VGIHPmWiKVxJqXM4/UlXq eSvCkF0SX9ESAAYquac9S+pEn/QJQAoWIbptjrxsTU0VFkVlq0vbeZPEY2M/KMKBJJcke5tD 7ui8UDYLDe0/ASeJelAsASWWh8uwqq+XecEGy65aSmJV4YfHy57ij53oYA57fePjL74Hbh5Z PVZAGwb0FWygmQVa0wUms4hoZ7MR4rN7KSLWMlQMOcF2K5t26bNHlw+AaWhGJPMNNExj9Zek o21U+77yXxoZj/GFp2XB5k6Ys5h6X0LfFegROvSU1CAakIsowgfEFZyVgNBMRDGHGWIUcNeI UhanUFRe01jKVZ17udjOPzY76NbS1+79cj0zKCClW4xhF/px6HXPQ0hJ/X0syZlVm8oW2oTZ An5jrDOMOAulNN8SLxxlUdcBhyCiAEDtluAOtRrwo45IBLgN/Fp8Dn2FVzKR2BzxfNjicx0r UvsLtdxO2yAexHUqI9UO8NZ6KbQo5ywSY7zNyGi3xO8bF3Bst3hr0h43sdhm7l9u1d3C2ft3 zs3LHPW0/atpRLvFARCMd4e/8q2LGNFT6/oq7jePiCKWWPcAGAzDS3ZF40Wmxf+kqRVE0aFB zlZ9rY2wHTFhG8UvTndvSjil849yt0ISIDjEYThG7ciyJyKuWSkuGgULBGLtbV5py6Uux740 WAtEWOjr1oY6X1e/qZmb8NQYqeZ6zZuWL8R6Yfv+zDZVqTaoFHNazWuFLhmV2ZSOpZ1jrMeY iYdrzuxhbADr853goVaW4LFA3XGKEBs3CmCmr6hmmRJWrsWWSg52WiJocJxd2g9EMrqOmqKb 92AJz4DGZzqovzsR/baXHrmknq6RP3O19vX3YkipzZRgIUITwRmZYCCpFsIH3Qpb7LTo8mwF abnoE9lrr3mioQElxvSdd4VpbNNMazWMpSUMwxHUrCT1+eWqY6po41Kzz7g1DRv1+4pjGEze OHE4Gth0sN7esVle1b3zt1JILZOyNYPFFdlEisUlvHmZAeMwI82fO5C7e/sxE2fpppy4becO MwWFtFNS2OO7GpmvGiLU8QVFx2T2TKwbhZG1Vr6psMtOTJiEUbxr1Su3eHc4CR63pPvb7A+i MLNxEhZQk0ZS5Ys1NknzOETTDH2hlnCaiTjzThiPksdLo9Y96nFmEuHPS4m0ELzxvTgMyHTA kuc2cShupHOMKunItxxEGMY9m0vnvctCLaeaOaLO+GqCS0WGYMKEuwbsvOSsbzv3SXKJiSDe LlaC44YRmTr1LHWSq0fJNiJgmcbxDPDaYxJBr8lga8ri5XMjuXpnikVpdTenL+8f2GJ/zvVt FltyffPhyP2cG2X6SgooWMGFKAZ0cmOZgpJ3m1Zdn9rT7q1C76dKpeLrgHpXGEavpLNklFzv BZIhGhV+9oA5KSyLIHqjYV/7OphMGjq3K/H6be4rCZ+k25lISslrE0tLEFZKYszzmJgFTWM9 8swWgBmqmuPe3yFMWOhGiicmL5NR3zkEdZggtkIS/t3JEKd5tG40cjjV8KZJNjN8u4jErpvf iWmiYwDheSqIWEIVVopGJIjUiJzpeHyp9DvM56OBu7acNg4PGKeu3elfG1jjHuAMA4aToRWu KImmHzu2+5LMITSWmCRnvJZYU3x1FnhM7dh+wxFsxmZ0GAfA/joLm4G2FJNKcU9/JQKKxc0b B+J1KDEljLOI5m3TsZlI1IrQknaC0yKOw4yMRxl8iLvr4hkEptMpO1E2xCgle59hCkUJiqDx qKtiJUraYUJ6WNJNfcymQ04AEHc7ASlO7ScPCTw0Bw/nYSYeqBiRXGbNMpiJ6byCHFjkI5MM V8JnC569tOLDa0pCaApxIr2gZRUx9tJAXaJTG4+hcr9d1icoTF0rMpGGtSeWyRJGyZ9SvZBr KZ5s9briaHZinMNRgzICqSRmi6PJ9DOhtwzf4fdXYtmpb6VJl0I54ZpHfeC2XYkjTZZeEOgm ZT1wJixInWDNFRdoIXGiQxmEeNezaDdS1JHrNBRolY/4veutOeMyAGu7mX0PaGbsu2aJjUuH QudRn+z6kJcmn+mykZp8iUtGUzM+BnfaRf5QYFZSQ0lvF86SID5QE3tKsGw3I95m3CnRYJh+ WTZMzcN+jXumo4TmkprQ3yOMUNf3diQ5aPQ1iq1rquZYAy12Gwr5pGpE43tWgDPkJIOb2m7D bwMdDaFlcnlXOpqP+Cbo3js3VcKgqYw1Rfjk3VgrXl19BcePuO+bLO7Rqd1vzYfAAW3lpNSG MUzG0ZBxWyg+UAbFOmJiOjCZiKSt3KXkWbEQwjxvdq3+lbYdIuNgSDQ5RjRFfqMVOmKRoUnW tZk7dICfhKsI0V8doNE5//HmG15qudEwRKe86acsRzvM3Ob0yV12r/AFxd7sKJ2HW6fPmLy5 aYA2miLCECV6kMw87rAYUtELHit6d2J/mC/j4xbBUQIRI1c7/8jfz0LAf5GWGA80Yndux9OS DKvNxZ4HKvFUk5EgyQnv1e7B7smbktzpdCxWHZhOM71O8IVEtjUbH9RP1i0LlO4GbvopjoCE eYXhGE7C0+uElNYZIPlyyeB06BYiByglkjMZhXakinZtvO2JxkiwsnLpFWHxWtwGI7pS90KU rHBKHeYrI+v61wrPh0FC2Yn7W4cq6MMeQm46GUNJvCs8IVV4efc7KrKfAgr+S6HuKdwS+f1b ZbbJvWHSUpgQuFoAJZJuzZzo26iQUeI9E+ZozkbgtnHzcpAt5gt8f24bKjNtLuNFXefO+wvU eKazOT2RgxoMT5ha3kgnOzvfk3PdJNXpriMKwy1jRWAiZkkmpaLY3+iAIeTXRofEoHRhFwls DHuxMg22lQb32H/1Gq2fcQgm/Z7p6XO9Eog5c2ysApORjJxzwiHqbDg4H88e55lNTq8rOwz9 qK6spmaZI82eEZsDkrtwMozFCd7y28ZYKzyPeo640p9RR5aVwdDgAiW9DfYUnVuGnoQyE3VG VI7i59QYSYyl97EbeEsiPltcTDovlDLHynR+Cku4lzHeAqk8FGY6zZQbMb4jHqNTjNpI5yhB Tqkoxx4fXSt7JV7gJzunxVnkhFqA47+TNRw9GLsUfheqwFf8SAK334swiIOPBKYV8sxdLlE8 QmKdBubwHjqKk4TA1jDBbjhzvjeS6ZRRS9mZQjxOmqfsKdp6ezxzioAj42031wzptSx1op7d MawRcXVkLL6hGeDyzMCTdZGA02ELJLIqXkYA782wpc0sHJm0o14yWikX2TwhCfR5i15CejpE NnR6ZtTPxgAqRt5W+2Qzb6mds00kGsciyDGF0VfMAFXA52SWKF5vdK88NFdJjX6HsS9Xp3GU YT8lLPVpg0wWBtItVIuaqLl3XdMTy9rjZHJyco0cvibACUfSOVIRXEdx6MUtngxYnLe1SG2k /dMDFGhIvLtzctZPJZ0WHQYfc10Mu4/s0XDkRoGg3jkWEYAUVOASdiQwlLC2PAS9N0dONBYy 6KLNrcNfolBGVjQFF7WDJId7USSwsRbnVmPiRNkos5Q6loH1wqy7pIlYzAtaxr55KCFUWxJH LH2gdkyQK+1QZS9KDn+hUTF01oMjamHDKitvdKSyLmpKTA1NzNyJk81hS8n/jhKIwOqWoAr+ iLTdzfkQM1WwNRqW0CY43qWePNjJYmFamljY6qR1uuuu0Me8aHJRR9dyFFjeZmB9WIfjUOB+ cOr7dN3GEjcBtGWmJdghhhjm0DOak+ElqoNfew0n14PdzBkqQMlcHjQvJDEw53uymcV4sXNy XpYup1V/CRbVbZvzz9yWDMYT4nxeYnZOqa5HWCWmtd9xb9EawLNECAnjDfcuxJcjbTwhgTWN x79YAl17KKYBJi3popHeetYa0gtFQ2pKY0EgPaYs8qn7nI1JY8c4gw9km54pi3qavKBtr4sl 1y4sKaQ2me80grhYoRUWs3LIWdLfx1nW64IagJHf9sc8AeyVjR3TogK2qCP2hFcIRhwwUadj x0fB9kWLvhgTZMwjloqC1S6z2Ji/iS4kTNvIfpWboiMi4HAOZLZ2JxjWgscyYdwXP1Jq0szB NZs1UVDh68Ehgg+01ZC119LMABlNeCElppE96kojZYiFS2Rahetpa+pEksVJYTxUkZCYxnid m9sEbrRrj6WSBWUam1RB36iQR9I8nI5i3boKgE5gcK4+m8LJNo1D13radJEFVzo6uO85D8QG 5Vnu3YBsvJORmCWsoSWNHO0Xe0p9dyzttdG6HoEbw0iLmZyeOTHHyWLLM0fXuy/VFZtHjFhR Pka98N4IUI8SaZoEfdCKQONl42u/HPWey1PSFs2UUj5Co+NxN/MwvdD5ZLtIac5DwxARuyT7 nhQ0/SZdHFpzXNi4PSf6T0oeqRVa8lLDFu2AIefxLSwVjmcotjkuAXQckUqpNhGU3rGah0mm yUVUojUiG2UjOytWjsylSXQgJ1XSaRKIpkXkK34rbJnYB7PyCs2gxxSVX6wQ+yz58Gwcg1tt xqlNwhx75jTAXUOfCP9CuQ1jKIq/LBDE3WlqTgallE0NtSMcAdXoqg21pNKwDxIJ/TikvQ6Y xLgSTarLYfJykkiWTnwByWON8bk5Fq4LzE2gxHMe6aD0EhjL3xJELlwaydzrNCK5hWXc9U9Z O9yOUyge8YYxrD4x8UGnf458LsvLeAoMv+zkh2RHKj9FH6YV5uzuZNIlO188LtzwroaSMTeq peYojdapwmZ7l5GDQQzbYmIUiDhMRH1grVBH81nuXsNTBIvoYDq0YHq318GtayZxq7oYZ8RJ o4zcohuj2TqWOdDJOCuL3vmevDoFvPXhpTfa6kG8TtnOajet9X/LRpcBOiPRpW4Ta5cBoEGV cWng+58XJ1NTexttVMw4W6Y+b08J/2mDe0VZqQf1jfqXccRCCQpmJhJoTYgNYG1O2MvoNCnS KNBkgBe5TkSqDArhtnW8BSWtxJmQPpbp66IpbBtIvTbZeEuHgIhoNrRjpkW0quspKKCISg9w xUia+O5DBr8N4au1KyXb8RbVn+pq5/BVUf2ql24Sskxpot5zLv6J/wEejcshuP4wOo9gXzbo TVEJzXqeFJxlrqUGIOQM7wuJNVUtuQOv3SFPmBHQQc9rVgi3Je1gtK7UFIpFHye5wuCeFHpY 2zoZ+Ro6DPxS5Z2Hgv9farxgGUdoddHjzIzYdCmrGbJL0sGgWDZOSgiKHMYD5+C4NOqKSqIp ob5Or0WWnmA3bR+1Eo2t33nFEy+GjJnGtuDZdH+qR/+wCW0qZ87gzWdTAdgjOIRZWz8RZVhv fa59t41vdj2zPFkb3xCAYRNgHw3DMofphl1eNoZCFHQMFs2ykxsMrSU5mmc4RMmmaL/FW8/J 59u391yMc3Um6a/Ym1xEs5pszyQPGOCqzvPyBUmDC5VmeCZRwBouSYDf8xIEaiaDHMB7Qwzg b1iisze4LCnaFTqa53w7PL17pu3wrHZwi/Ml3t3lssVxMFQfR1JR/qATm5uBEygLn1zE59/d jDxGmxyfdnNPY14wLBiyWRcB0BX0CMc1ilbvaqMobIzr/+AGbuPfZGPaHPZjKzCiYWjug24l klckB5cpfU0Qm9HhcqyuovCaIxiyoGuDAm9lXc2dnjQmpi5i95D5DhL3niedNI4lALahPbSm BNWc2JnfvweuY8pkfLj+MnADBb6/Ne8xm8gERb+7YXfvDhj23HRKmcO9G6A7TMs0pNw9wdUX WCs6durkfn1O3q3JibfuAOMeE6My5+YrNgFxF2mBx8kxqtRPBry7rQtUqFhSBS5WkjIUa1Qy HJVIidNvGwwWi6Y5Z/oZktOOu2NNO4ln3nbcveeOq6S3mLdxzKaxHmvZ46+ZjunxFxge/GEB 0luGWCz9NGGaCqYpd5CfgUc9Pqf9bKTWnNlzO3vXRk2I4WS7+u+M9s3WmtAF+QV/TcJX9jOr 63hAiveyerpWxozVovO3V37gmBp7m8evd17t7u08XWucHL493trRNlJ0Yj/BC8IjN9nCMDwn YxsnLkwfWuAQxAgRgTUOX7062TltvNw9PUFmFL4XMJLiI5ahUrYUrdD0hGrn2sDsEVQxTZiA +rp1hOSLLriHLaczRYy9qa2GWPqsM10i/0vSxRgBaV83juLEskc2vCkBfl6dAGYMlvyY/zgG Ygq+itoabYUMlBbVX/6SAlVeITHltGAzMJJkuBn/qCoyD+zZhkAbSXtAgcNtlGwxou1zwEDL FQ/GHHV4tU2rNfVCLhWpjLDfTsenQvKY2tlwvkLlRTtHc/gnPYm0vXYPEPrmHk9fcl2XV9Dl AuBnz+1XSlaEtpnWU+p9IWs6PUneF7K60qj3ofE+tih2vibFGimsOmX9G08Ca1guamMgpYz1 zJTqiyzdxCKaa+n6C3cahEkLd1qdyQv33ku3ke7zZy1dWbgY8QyX7lehWDbcLXLVbFIyzbA4 cy6mz8QMAjLdqO0uxGMm/u8kAsjEvRANOGXxikpX7LPx+fmtuUDG+lywNOXt6e5e4w1RE/Py 4LCx/XZ//8fG9s7WHscHZ626ibbRYMOTX5GXbY273dvnn7z2xz0nXpon68/QGipHb/hxh5Qf 9hHPmuRlweU6/HvDyW2veYSh//17gwuA29ahJO0EhyMUzjTYs1Pa1jkR5mv8Lbr+dvVMmcbN ckTkE/1qNAedcYz/y32y1J7+RVEDkfo3iK//uN/T6qO1WIOi7ofDJ53o7AlKGcrVSq2yTn9W usHgfm2swPP06Rr9C0/y3+qzWu0/qrXVlfW19ZXaOparPnu6tvofK/cc21zPGI1poclhvz+a Vm7W9+Tg/kkeWkg42Sskwjzv9M+CDodx98LK8gkglyvnjXNjSL3YyShE1wrv7VZ/cIsv0OxF WpZmGpgJdYi6Oa/CpNeoFfLf0EblVx+bZFijf6BtjvzdCIfDbnzOv87pZ39ofsG+7AY3/LPx 6HnuE6bJNTir1ETwa3W4uiZ7pUkbCSdpAKMsEB/i1wJRcHA0jLqhX75Sc2voHiROE27YOxy8 KTzRudM9jL22b70Wv/ZarKz6fTwda+Dazsyr7ne3siaVpcn0AAG+W2PVNJdiWTIGqV9qhk7/ YrZM/2IWyxu6ocyJvqz5fUn0/hhNUGseoP1geOnBWE2OZ90sGtYNmB4T++D/sn0WYyj/53Wi JSh9t/0/B/0fNO9JY2bQ/5W1lTT9X3taW9D/B3iAwrejm/qTcQyTjxQ4F96EzYa8XvqV//iU g4UAWxteOJ8/4XLJxcCihS3znf/4lNNGZPRSl5eXudxB0A032Epu28aI4jdZ5lK5dyxG3VC0 MHO5Y9ZGxhu5vegs3lDlPdM0/e32Ct50Pua2yEAGSu4u/Wo79+m+DNQ/+TPX/q9Evfu0MWv/ rz57mtj/tZXqSnWx/x/gkY3+Hf/7nbf7v3N+fKcpwHf873f+vv/O/fWdu/m/s39/d599/53I jb9b7P0v+czY/5hrqPL7nv/Vp7WVtdT5v15bWez/B3iePFIyyah5GKE2AQPoUZBvzHCWyjVl jHwyNqt6pLb03UwVtoqq+s036+Xaysp6SSFJV/9zGPTKnf54oF4HUQcNQqGKJIZm8yAyK0HT 2mF0Nh6JvTraZVLgWWWufhLQU9vaVy5y2sLiu8JXRbW021qiF19pv8o8D/MiTzKWHgpZPDFW LluCRY8nxkLxyyTJmchpPIt3/qGvme+rKx9UHS4AeUrNhXHCMCXe8DbPikWU7TQOdna2G9u7 W6ciRKophJ4XnytoJO9oIamGk1yXnirXyKdUsqbG4ff+yxWuQZokugKn2mDTdP0UytWi1yu/ jtcr8lGBGjWuQS5h2W04eSuojVWukRFdGapSDZtdg2uscQ03HX2iVzbBBtdY123gXAYjCssm Wvt8iWrI0SO1CuWnXCOPwoBcpnsDrkk5ugrFHF/3tOuOowSF21suNz3xqqnOxdosP6A3bPFd Vyt8J4yvo1HzQrE4tCDaVbQmLBa1fRqpFWsbNPAzmDaR2dDrNX7NQB/XVfV5ZrGvE8VqqWIS MnnDK7bK3z5N6SmO7zO7qr79Vndkni5PLJ7ddS4+q/+cVvYeA1i72wAyi08ewNrMARhNwWeP 4OndRpBZfPIInuoRiIzc5tn1e/G10TS4Gm7Mw1tUv/3mvtg9eFXMAPCNCwBbcnLzZhSvriTL 2/S4WcVryeKpPLhZtVaTtbwstYkae1TlaWaV3aPMws+ShbOysmbVrKWGL9lYMwtXk4VPTre3 rN4WemiCUxrTkiSMdVIj6ipvNk8aOv5lAzfhxHpPpZ60D3+gCjIFqvd5sHytZmaltefeSD9j oF9unPccJv2DX3TIA5Fr5/zdyeMlbguO1LO+7odo8+WdWrGgydLPNWQA1kkXq+sKcACyC1Wi oER27fKuluwgz+UAlUi6hXgEN51hSeX/HP8EJ7zqinobc4IVqsXnjsINTn+TiNua5FJMRHbp bDs+d1hCPNnaTtI7DkmAjK6N8FLgfLjZrANpOAsAtyhiZXLse+5zEcCKNPZPXlMxjXZrzQO0 arXW+GFrh0HAMNARcD9C2+J+e6S21PG4Vz7FfOA6UTZ2+Qcy64oV2lP1wxjNl9FFmlfHI/Y6 xHgmoZ6/aMQuO6w24rzIEpLMpNJF9FHwH4GyO4pt7DfJULDCptkXbmIYdNrTlZ64mOj1medx bGB6vKrf7SA7uHX0Y/byAMaxObgtcKpAnecPPS0IOvlgPKKccHJwWdeMR1KcP5CHBlbUc4JW /BLNdEXbo8tp1reeAZyU8PFjzNfM4B4/ptvEX//6V4kYMO4N++QgLiP+pF0QypiICr0EVni2 M3YJjq47KMRVGFvNGZc/jGrW2GoTxkUv/q65TdxZfyfUq7+rb6mc+vvjx47vAyEirr7/+wfs alyDPzQ6VO2RfHkhH8pVlyORUis0ugmThwGQZPYmz9r9JwfG93mzohekOdp+PKk+fbl76mj1 T98evzzcajSQspyOgZbBVoQrbPUpGTtSBhi6tRoKCbfT/7a1ubd3uJVz63RJmwmkxYS5YNrU 4nwNbh4QoFGYFoNcNbTTQDsYCgT45CQMhc1K91+JutvT5pcA42vK73KNpoNsT9iObtjxl6tU 1A/BEL17Nty3JhsKRddEo5MR+vBQR7TDC8U9Ryz0h62Q8vqhdlZhgkb00GRlLUauYNRoxGz+ rXF0egzcF+KluvIIB4mmbSvfUzlSZhDJwDBejcFoyFTD5NqT+z58YD1xI5bVwIw89OYcaz13 3/XCa373ydZ7rtsybxT997308MNzmjh0ZOKvOsoIudHCsj6TNO8+PjD8KOOQkDXqi6mnDjFC M1dRJ+gPqQuKPyzOLbD0JnYyBQ7jmSSBywnFwtg/2T48MUFZ0PkaI61EVyEH+xkFMfmdHJ6I U5jpPIVgJ0NdjpIjSbGMn68khpTQcGRppE+T6/7wUnvgiguLA0ec5ym60uHJk1pFvY39U0si MchSkElJEApW9KuCnkbKnegkMYjQhDaZOCjnTT36xNWlJlFoCukBU9ANLkNOBm/lPhhH6VaT hnHnXJ1R+Ni6KsCPIrX2CN8IGQVou23YRzY1lI2Y/3R9vbai3SavdWp5dqw2W1afo15Qe8wv j9Nj9i9FQHAPcaFldnUkzlagktzxb7kbey5dZ4RYqkEltVWg1H5UGMcXj4p/wbJ/cmgtVhZK T4zoLLDqMZDDvaJ7OFDnsGydM2/BLc5s6hd1TQpMg1iGq/NG1GU/VGRPQ6PUKT0hBxopHulC JiY831jRKHpUsCN8XC0il0xvivDfJryH12UYNXR/vahevNA3bhcvRlbjd+zx4w8VIS26a86Z SL8nnIpEG1NrXX4COL2wiQ4+zyXnChvkufqV8oye/R1jWn1LB4aMmo7+YEg0GAHaSXeP0k8a la8indhJUzONToFHbESPj1mMxa5xAL/SvIT0T7BlkFQ0CWae51KdNIVlsp0ey7H9+LHbsNum MzXoQWtbtjA+mb80gHJ5Gk54Tj+HlmzGcTgcFVbgpsLzvEHAkFy30QArL4y/MQq07AWRR811 7Dd2v36KZ5BPSedkOvBeUTCWn3Dn2ELhJUlSzC/1LRy8KyvofGJgNC6YDiv+1/tCixa+UIQk zTXdjZojl6cpOf7tUnHsMRcs6tS5tNyePDJ41yj3MS4bTrpeKGCkkaK0IhTvvvvwc7vGSJMd 6M06TS9PoHmnOU+zDuCGBa83e7f6kNX+IwEnZgs6fB5ZX2tWnvDNimQ0sNpDDGdCaa+EAWV7 Y4N/6JpfqpkolZoxvwbuYl4a2rJWsOcYL09fJhrz7qR5TB3vQz6rPY4g8Y5P7PSkUVkk/XRU lbkc4nb2snIl8nALqqm/6gVTlPOPgT/ibqsNjyylH1256VSec51qNNHKnIAei34jQPHPABct QvemIMJfs4bAfAET5sVzj2ce/f/FPduYof9ff/a0mtb/r64t9P8P8Bj9/wV7HkqyVPqjHTQ5 USdwW+3ofDw0AoW7GgA8kOr/h83jg92D1xsSNoScIlmm+AjqPDKhwM5uvfhOFbU7ktBkGJjd xATWoUlmDVsCdGP9eMws9Kgvzp0VtelGkpLuUJwJEm7QACoTjRf4/BUnHCP70L+ZOSs0Gq8P 3gLXh7cPFIXAFURe7e8eHB7jB7wmra6mvHje7f43l2fzD4tGIxjxXISNBhzHURydsTVIIX8R tVphL19Elk9rF7KAOEJaY4dBQ87n0gog9adChgQb+5xiP4uizhCg38Yj6E+7cvHC0VF4nykQ HX92K1FfXqREyWwJa8fEAh4JdiiFMVoZn3IsZylvi8iJsl1jrEe0EKFkvngHb+PFiCEAD9Y9 63c4tJkWR/lxBxTcKJ/bb3CXx0gE8G/7eboGRaqG5eTWiKVGnFkDGVsSVsD9SfivGTYrdLRj nqkb3j+1Ms6jKFxgHPC14Kf445iYcUTJB1k0GDOm3kXxGBC1hfc9V6Tn6jRs4445TJk+ffBr HO/AreeA3dupJvqkC8tFb8svAAzKY3Bwj4puKyVF/xRJQtc39MEmQpEEASMSfF32MH40y1E4 hTX2XrNjvB66fUFlgPH+3U28vfOq8QP64DrryrwjGYZ8NctL5562vvd0e06kNzU1OfLy0KNQ NBLpBZVEc5m9nXc7e0gRvk50xX78OrWt/e8+rIw+65AK3gSfnB4ew1S+BL7ve9T5mdebp7tb jdPjnZ0TVTWvt388kHfw1HKixBpdIAd7SbkoMAIRbLpLhQvclw7vHjT2N0+33ii16omM5WVt /WsNsBv1KGkzZ6PiBM7dAM0jdAAjFzBq23dO2Thr5aZG16oBByK3tlykDdXnk7ogj5rkWkmY 2jUxWa+eKE3uSETLV239Cuji9uEPJz4lJ2Lp3b4PTxpbh9s7Cvq4siLU1RBRIybw7CEajZeH x3ubB9v4QWuL4Y7fQALdaFCqPmrWEmn2sk7BQaOEza1TeF/M2QFvivIUSaaEk0VisHlwsqsu w9vr/rAlMXvDHkpdjLpF7iKqsQUrv2PkPPzyES8AK+Tht7asXK0StK/HAdOKWr1tFOTO8UAV 5cxIKNPpDnOyhZF5t//n10dHZPznVe66tT2luT73Nvd3X29OmLKq5+CvMftu829bHqrf7Z9M mvSa8/5V4/Bo56DQC7rASqG4x4T8aFMgc/qCtJC+lVS+e9asP13Jw1/N0U09HnXxz2G7W29H N/hndxjX16u1fDGzm5unm8e7Xj8DWOzA103q63oSNYcntQlFn1oDChZr3QXrdl9tbsm+0m9O cSGfNqAp+Dapn89SG2n/h53j709wA2A8hQaqEBv9GEWWjcZZiH+m3wM1B86mHye6Pu5FN9Bx bV3aphjzsq5c+w06S/irXrHSVX5ZaLdKPMckKifptv5UNOs0255D4//08OiktjIBC0GyNFEf x9ADCMCPr+El0Axsfuv2HIaMh9NbGGKJ5Jc/IA5MZzIaOZvYt0ZjfeVk53gXjgUATt6DT46O d/cPTwReBrTsVdB4uQOFvGVwvHuCK8MBMy9SHfiWPhphKVJNIyx9wbJSl4LDqIhj3v1bcok5 lhxffeZc62k5Oj3e3n31qgGn186r3QMxToNHs4eoJBiMhjCQdmP0PLG6MqpPMjJK9REbKCrV SLyZvkn980iprwbD4LwbEC+pyl+vrKxlvfw64+XTp65Bjw4whHrHPvbD2LTrMPEkDEHdJydl Fknp3quTVHSEzLA5sJ7SoVXI/IAQ/sXCcXyJaByCljQPK3ycz8LKnpqwy1apvugsca8nNgaB 4LNo+uGUdSoVU30lSulFiXZXDzIt33zj804u40N02ahLgBdeuVlfXyk6ZIzMid6dHABxOTh9 5a3s9CdvGfurWBPDLwZ7AgQ5FZFlzGn8GGNGitge3kQxx5FCrdP+SRkNAKzyqUCszF+LNlQd xmDGvdHD9OahTmxB8xuNtHa5kqTjng2ndx1PGsHcoRYfMnpcuz0+QkrOCNGaTAeD16lx871+ r4wcZl5Z6BWHMtqtbD6nhCT2i2ERXRLgacTSkgpaaUZPpqrrKyvKALLDt+Pw0eCR2PS5bZF6 snmyNQ9CPeNbYCCdrejXyCDJg9th0S8v5nYZC/9kf3NvD75v777d91Hqoca+bZwwoYfpRbMP FKHgddv3PIqRw+OrWtiK8KYGxKHDNwlkyL+tq/XKCpo2PFI/9se07LX1g4R75zQrOp4fQX3Z H3YQ5pYqYP7yeBS2igwDL4jcMwkoK3fsk9suXPDDJpV6MjdOgCj5o3ZsFlPrTl47wF0LR38i vS96UbhTwDcW3PCMQkqg4WAwsYfFVhKObP4j/bE7kI/dQepjwlCPC2K+OX63IvZ7WUyDbnhK s3M2OrFJ31B7sqEoHZ2OfWEpyyLUj9et2NIi0zLTCWVljDGTIGspcFNMIdP9c+s6HM92FJz3 +jFKHr0D07PUTghGoz7eohTlekXx4BSz7OdOsSlW2TR8tsiWQGAyeWLngHqAUjc+L6pfo3bh T/S7WNTVC/jl+Sen2ukwaIaFGyquCqY3L+orRW3qrW5UuspVRp1ZVbLqVKfXaRaapYyG6CrQ LM6oe5VZuTqhckJSl8RnBs6ycJI56OxRTeivNYCdqqR3dPsTjPMmKr59oz1YRZN13FnN+BYF Vp1CmmgJkOqq0f3wpoVHEg61/OIjjaRYNC90C6yFR66Ve2jbeHW8syNNBK3WsOjDwy5ngRMV f4GqWGinxz82GGBJDWSdwL//zb577unbRWGUoWxP6H+7l0++vI4R9aHPnq1PjP+Afyf0v2tr a7X/WP/yXUk//+b63/T8y4XgC7YxI/5Htbq2mpz/p7AEFvr/B3i+kgTeqMaUTJmxOg974TDo eML6PkXqiJ8Mx50QZZeGGweW8ixArdklMABwFFVyOvyHWiqcHh4VcVFRrTKUi5rwuR3+ogpL BTYRVbsHW3tvt3ca27vHJ0U8C4QHLuaWCsw6vNN+RW5RsqPXZSvuKWGpNo3NeCVxWb4Zdugq 3Jbcq9ATeO9UFFSgEEjUN4ihuFLMyRG3dXT0am/zNemm1ON6GfmrFowbxgy0mmOmqPJuaang Da+Y27LVqOKhKrd7/TKswuZlWWzhMXk8sIzImNeFSy+foyGf2g8uMS3HSIVBfMvJQweUmLVH GTm5r7H6ZRw1L9HGQjeOQqgTVV8qxBcY03Sp8Gr3YLuoEr1TZZS5qPyjykW+mMuNKGaKLUNA sNI1EItmMGypR5VmMfefS4WtUxgTVD9OQYTV8Ecv8cUz5cmi/2jsU5GUOV+ijRn0v1Z9lrb/ qj1dX9D/B3gy6b/QevEioUj1gKZ+lxII9iUBOCyYCpKkclltiX1YqP4W9uDFPR6EeGri3puk qGc6VWU8sinIoQdizixJdykJVXiNKUoxG1aIGudK7m87bEdQf3LR74ZPWkEvCjtP4mHzyU3Y o6+7ByencAcA8qjLFp+gIdoT9DcCuoqd2nP86chLZHzWgQs1DtgYy3Fbb3Y2t3eOT/4q4AR4 kULsmQB4aYAXt4NweBXFmJOXxkxaiTBm51mE9HL3IAX0DJYljqNy/nE60OVY/e1kXw360Ovb SS0cHe7tbv34Vw8Ro36/Ez9pd4L48gnXxvb4r0ptjVp1fIg1MigHJIrlEEOFsHJeKaluMBhQ os/gPIyL3CTc3U4acmb8ta6m4EyX1md0dulOdPYUOpWTpfmSVole0PdbmvbohnP7Bzxvyz8Q g5LaBoSz+7SW29qqnzebuf3N73fqaFGd2zyuB8Pc/vdwrNa7l8C2AAtSbw5yx/v1YTe3t13v tHJ0DNebeG7ntjZP67AWcnjQ19H4LId6lpOTvTpqV+K4k9OrXi/yo82D7cOt+iDA2Ny8DzkL KE4rs4SUe/h8jLswGDYvKuw80IZ9IJxHBaqdhMhenT1pnT2hPVpGbOSOfjx9c3hQH9yOLvq9 3IIr+Ad50uc/5nf+sm3Muv+tPkvd/9ZXa08X5/8DPJnnP94y6A1d22j/66zfcuUr85Xv3T5d 9/z7HErj5rjL6WKT73H3u8xl3+bYZDtyr3IZ/SfNyeEcI5CCX2AMuu+3bm+9ujzSHlyzFUfO 5KAZsHxHlb4zHDqMvuSTg+MlfdlF2wg//VP5FA5kB3tESiqdVpwo512R90pUR67HqZIuOBkq jLByBGfJjxuKBAoNDL3eyzl/b+T+s7xUON6HG+mwDZfUPkoiXp8WFZ6Miq7alXhxAuGTpv+0 579oGzPoPxwAyfi/1fX16rMF/X+A5yu0y3XovLF9CpjUl4G4sWCvkiHWE1lxxhfc+gsm7x// mbD/WVT7hdqYtf9hs6fk/+vPFvv/IR4tbfETE47jsD3uiDdJD7iSTkfnIA66/XGPuK3+eDQY j5B96jH/9K5YqhZzzW6r/l3YvOirPBzgVbX0Xf45EIYl+PRf9e9ypKzGMvqVkagTi2Fu1sBh 1M9742++yeX+XOlvqD9XmihpRh2yguqlrS2URGsxPP0tf5WbaulbVYZD/ztT9+Sz6t6lVWBV tvWfAoHeIQNT/Me97yb2PxnFNlHg8wXbwP1wR/3v05X1Zwv97wM8E+f/GI+BSvdLiAJm0P9a Bv/3bH1lof99iOfkaGercXp4iMJv4t3Oop5ZBWUU7+F9Esj4kbxTbKlNhpTwFW6+G0rZZbNU rVxghZraFZ6QL7bDPhrzLa2q1yxIRBseMqCzF9/cV1Bih9VOG/QDbtxXAWorif6iLLRxdHx4 erh1uFfCc2kIXeQFXA4GUUm40JLpDVrMaDkmHGmx5k9td9NQKheKY1pq0SbJ0ysCKNSCUOi/ VrZ2+v1LDlqGbucbYrUrnclo4Qk5HRCaZhQMexhX1JQMR81EP0LqSMJRXfdn5PVn2pgb0lBz nrLofkplc8at0pmX3FIN1oDpOcw4/DTwN9RSagpoxfzn0n8pkmqr8kARiMSrVfjtnMNm2cJp C8cttChIVeUIF1+5HF7U3X7Ai6judyYnfZUB6b7q8T1gX1vUV9MPeKH7apHNfR0Mw9Ho1vRV fj5kXwfUV9MPeKH7qjuDDF1Igqh/VKZn8Zhn4vmfRRk/s40Z53/12dOk/L9Wfba6yP/5EM+T J+rl5sHBzvHJ6ebxaQ5+mgAuG5izpapeB50+nJ9wnFfw817UDHtxWEb9wIba293aOTjZwQ+b 49FFf7ihdoMrdJCooNn5qHlxGalCS/767pxgVZr9bjFnWt452HbjgwAZwT8oREgiViuGoUK7 2sZIxc2LsBs02EUfLdDHUW/0tf2AOUbee4U+YNTWq0HDO9fT8WCxDTZTR0bnudMi1MtqD16/ d75xM91UMzBcPLZ5O6moVUIXjPJV6AQQr9hAHQCcUtMnATWGYZzd5/AKUNxrYLRtqIf/YC/P h0FvBJUwTzVGxcBIknilR0C/oB4XHT25b6zrvb4IRssxxi4gDo8yaUnGFad7PeQzJGRqAqOq SVxJA94Hw3NK8Syx1ZJjMSW7yZJ6WJ9Is9NgnKW+jShfJ7elM3DCfFyMR63+dQ/AJit0wyAe D7k4YQEJHLpKdlGRkgh3gxPSJDPxLGybCYK+RZTlloKLyDB55UATrQYNAEY2vHWm7fUOLPvN 050CsyJcCGZ23BmVFB/57rtizmnZrEcKcU3aLbcVWWDxe/hMS9HFIK8eb//PS/95K33eETBL /geX/ST9r60t7H8f5Pnnov9CmS/D2+fyJ2USeK7sdpYFLaR/4s6DTWOK4H4r2Re8Ab1NJ1uO oDV6Y6IsUxqkglEYvzcVPrgUx6vx/I9lkyfu/9bZvXg+95mx/9dWn6Xkf8/w3WL///6Pc/ST USWqfSgAfTDy9YFk6gGlKVSeMcqEVYIWiGSJAH/H4fAqHFbuwM6Zg5SU+8/dNxf96waczLfe S4kNhNupdUb8RGOIcfYmnNOycaM+sDBw0o971IRXkz++d4p8oKjSpiqxVBPr4tf3biG/9vCX xlk06gbAJVFEWcs42k/vE6U+yOgGwODExKDNwYL4FicwUe0IQ7XRR+I1V2g+g/GoD1f25mXF BdENbhpXzcE4fu6B2JdwWEDAMElBv622jt7GbkUdxL5xeWbqQsXBxS2so6AjnGMJ+cnvXyZb dOroijoA12wAMLAGJx3yAJzsvuJcRIaNF/6u0aHc7gjC4V4tc6guNMNoMa8GV/gK+XmoaVYc TghuhS9rZIOdB+CpvZVxeEE/8AsvRDm/vHcZR5j0HcfMQxD80POIVfwNfeVxvgyDbiuKL7M+ SaWLIL6YVnPS9zhsjofR6LaB52J4M5JVb0bx/HfCsqFTCvO5ZWMXqZ65IjkY9t5PZhT0fdDd 7wyl1fAujB8SFA+gxqM+3FH0job+/nARkkmxwnhxURdtpynlhlvzBngyrx5vhnA0HphvqoDh yl42tg4PXu2+bhwcHlB6KAMDXdH7HReEhSHfZoGQG1aLEfVcQBz0e2VyWKfoOlIGr3s6HOpZ iLTpOhi2OC0KnkTvTo/2gRz0YLhDWRgu8vnWutvjo4qCxZ5hlB4sNCoDtYjDK+BUY1WA4Zdp /CU9iuJUctpt91wU8g14/9UBjP26xzuTLKC9gdN921Q6wnic/BSgK1L8k8JlB51qRNDtLKbU GWQ8gL6GGUtPPui1Z4mZd0d0ySTyd3xHTR631JEGDxhZe8d5wH4na/2swdul7RCC96u1Dwzt 5M1mbf0p7QivsEsWuHRGYRdTetqep7/opc1U+vB7pu96jJSu9bm/eBh9zxeSaXkm8v8XcflL XQFmyX9Xq7UU///sWXXB/z/AM51RTwqqUEWkBVTwt3f0mW03irpAIYLuwOG2TjdfHx3vvNr9 WwGrJZgvMflldg3lCppZILJhQkNgCptxF4WZsf7oijfx/Xtd4IPOOITOLpIkJtGc6W+7pQs3 O5xbcp7SzitOraWBDMOglQXjE8Y2R9Fr2BwxvQJUIHUypz7QWcQqcfyTZmCIqaFkBuDvmTOQ ngCslT0B08aoby92ooB9azRHN3dAtIXhYcne7VASno26/iWjjASYCZTBO0TZH72T/jmfifTf kIP7tzFL/ru+tpai/0+fLfR/D/HoeIJAHNAD041zTb/NC7NLfaqM0ZS9Mqu1VBl46xX5Wpfw g96bMnKJSpZxwfjarswivurLK2Lj6BiqeFNMKoBGwTn7qMA3J/SOIcg3pdtUHVIa0ReoYcIh /dFzPO1J7H929v3CbeB+uKP953oV9v/C/vP3fzLnX/v/faE2ZtH/teqzlP3v09VF/IeHeLQn nTiBK/aly5HbODqHU9qSypNHT1S5G9y0wsHoQq2oMiVcaGGkH6q2kftPSvtV3lK+7eh/fseh ZtA9X5Ulal3+pVYq/Ln9Uy+f8PmTpxzehE1OJlYu9/pct2y9JKGpXz+Zbv8EbKN2/fOanAsK 1SQYf/R0PPiTuf+Pdza393e+WBsz9n/tWTXL/n/B/z3EQ8q/lO8x+yj3xzFuZ2CkKCIiC97g L0rLNcJUUBH8zHGUmEE4pLzVmDc6hntaJ7wC/kuHVtd2T7LOKrBb2XUQhUxIKTDZ4aZujdJn SW6lIwoYUY5Ht+yh7iQio5BcyND1c+wdfRb1JAwJqi/dwDGp5hVZY1EoYDv6oBP3LQoC0x2d VSciLyhR46NOhaGyIh894T3ix0PiUCCJEBpkWxUOI0w6HJhUZ63Qf4fcJF7gdagW1GTBbV6E tGfh6DoMe6y3Re0sD0lw4FlakTKM8SkYQXUvdIycvWAEPy+dHh7Zy9/PMBS8Ypflio0jOeKw +YgWvLuXKVOLTRMnUnvOuSYxefBrT0T6Z2YkGTPC+mVoFBYDhVnGBrco3jIFsQmDDhw76ODv qJixLM8EI3ov6o1v7JRhTvIYGXCA3Q3jmNQm0kurAXq3j8FGaeEGvT58G3JHtPXT57bgW0+p Ga3dxG5DJxidveO2JbGvJ7T1N63f4ca49ygwv0/vqf58vW91y51g3IOJG/q7mDqNegS95Fuk k9FaHQwl329G5MIgmerfMDrC3lnQvITOtTZko9pXqhWEXcq9B4sMY1X1NBJOCAm4kfDQH2N+ H46TEFM4+D7b7EiEnpaoh5h4IYTtYYSj3BYDzdgWbulw8tIF6OJo0C3LL91F55WOzyDSvlg9 geaeQAGN4GAAOAJeBBOLYXwkzBWILtZqd8S95GpXUeAPTu+yIUxsmZChp/xz6X/m+Z+gzfe9 D979/lejmACL+9/v/8w1/5VzOOrPe7ACP6uNWfe/laep+a9Va7UF//cAD8W5yz2Z4ITGnE3O cgb/fhekf/Fnrv3/MupttU7EAjy+c1iIGft/FbZ7av8/W13s/4d4fi1/pfY2D16/3Xy9g+mY Q6DzryQWxK7h7r8qf8p1+60xMPfOWlCFOLgK9a8imvcMQ8f289tMamJ8Ml/koi4K8HWziZ+V rdSLygnl8dXvT+ieUdk91C+2uL3Kfr8XtApobVT6GA1+AN5yv1E0tchd9vvw9h2ajhf4v5VK sbQ56nfxj2Iu1w1uTjCZ7caGAiSYn3W1tvLN01yuzR1SArFJ7pPjXhy08ZaTNC1HKEcjYHdV +QX9cYZ/bBFE+GP3UG1hIzkXmVjnFWzBowAzC79Q7ws89BJ1t/hBKhaKfi26fonxOfSWrTNf UqpLPYYl9dPZuA316f6qBurbsuK0iQaKAGCpHCX1hTKpUQ0UwingRQIXyjkGDJdGJO0nmXtx VuBv1UpRLWk5XzuIOtCR/KuAbqTA1eIo9KXJv1arQl49foyWYtfcF/iRL+YZ1AX2DDXPL+nW ixhjHPwwjEbhPt+fsdzRePQSenuR0efYdvhiCw0A1EUOV4CHEpiOSVOAM1qARZONRFVP4Znn o/AVjSbTJ0C60wnJywcmkl3L/IkpfDXoX04AULKuCkVo2h8wgoTxbL2FN0XJpzaopvqHxR5N 7SY7OxSd3g5GQ1x3gHt0kVeFnwedcQwI+nkuONALBmU2rcIh7pBLBYG+IwIiNHUYGLCSFHqQ y1mwsjcLRZxOf4btHnN6oQqXRCh0WXUF/ZY5ntYhHmMJM90WEd+q/u23qhdebwmYy9lj0iCu uHcpEFdOPxvqBuZB77O3vfAGznG8aPdIlsblEc6GstvrZuGz/W/3zMv/bZ+hcfrncH8z+b9n K7WU/3dtbXXh//MQz+fwf7wWmPvDvwznpzks1PzNydttB6Ogsh/cnoVprs7xImJTVMM65plb om4kOCV653FH9IYF0/gXEusJjFGfuQTijYiiixUaHo2XDdc3gUBpdib+iCUynDJ0fYErLelq 8zIvLvsikBIczEeTZ91yMIonRTms7AFmuVf1FyowCtckZzuDtc0a45zcbe6L+nGgK0e5THJX G7mOA/7j4XkVQt8DtYxTv8wHHemJ4N1WWU9KGyGwuHvIhuEkDGftUUkkw80ANS1GWQMn6DjW 4uytMqMA4eheVPDHweHpzgZ1zrQWxcJdoTS51yqp5hga7Y06cKBfo+i+tzxSlLgsGlWA/Uws N0Cyu7AJ4cVUqZncplta1gzDkOoF4D8AtFusRGXVQHOKwqF4RRzvoaIsrBR3op+CU1jFxclA XcejYgLowbhDeV418IJbeCrUpM9ScRpUp/BcXXWgzu7qTKhJ/6ipXU0WRshJrjejHqwrIr5K fsuOlXt2RoWD/uhCprOuQfegDKzIrOKF/xnzcsAeACbZXQ3wRi/y5Po2xIQpuLc+BwlWW76U yMuxqJxnAPQciSSPbgV+URkVJ/FN9Y3/Y9Gtb95OqOU6PxZNLfftlOZMHa+5yXWMv6PXRfN2 Qi3X+VF3MbExC24ZsyAB7Vdwybnq0rRAo5Y0EOCrLtMELgfT925/8gQipDfv9lG9x/wCdIKu dtB4EI+wwkCfI3haQGtfcWLUC2hHQzh6p8gvsyjDIEI3D5DBlTkfsx4AT3AZuirInRXvekw1 4eQo8lC5BDbybvJouZCzWPFmjNloP+Kegf8WyNc4Nrim8cBpC5/0d/rpFTij+lCgQCWMxzDO zWP1rKh+bkVXP6uvZddDAzhdqXPAF9dwpx45x4P1bdb3euwKgpoKSbo/HdIZd2k6JBynJl2A TAIQOyjTQ8sooZGmu6z7fxluDofBrbRfYLyd9qV1D5XpU05cgUuOf7jeSIS+qeVdkjTwOp5V wfqQyxJnrE6v4BERb+AZNXw/c9yHZ9OGYIqb85dQaJlLmHKUjAUkDCOBklmwtJi9ma2IGIt2 kswa1j7GPz9k7yUp9v6Daghcc+p4BQpDtaGGcVHTBf1FwTaesvctgGHWxk+uYtMg9pu6PaXX 2HT2ccXfS2QaITO9xIYSKjV1TnkdD6FI5fWvqVUkWkKRm4jaOnyCIqOsnqriQH7oD1tP1ygV t1pZCID+vZ555T9wQTUKwLu2MUP+U62uJO2/4cfqIv/PQzxWqmNmOCHNIQnNib7/Vo7GI+8L Ug8r+WF7gZyE8UCRxgDlMnW1+o1WpuVYmv0uHMZoxli3RGi1lssNglYrbNlbAnwfofV2IQny saoCh4clHj+GI2EQBiO1/NPKcjE3GI9eYewTDwgcYvsNIPHjEbb0NRxGo/5Ob9yFP/CQ2iFN SSHZOpB8qPHuSBAjGik4gsY9wAPx30B9BehqDW0mlTc8/up2p6DDLGhHV2V1PsmiJqpDdlmn 0QQTVRCFESbaiVAsEXQMjFgDIbaM8ZJseFq1dD/z+cWZ8c/6zEX/t/j3lmt9fYdzYDr9r60D sU/S/7Wn1YX/z0M8nvz/9HYQntz2+r1bICWAlx5ayKLs39cSdMKbCLhIv4gcJPuoufcPEG2V sTkYdMgg/QrIeeHbpWJJwX9fwD+bnVE47NEXssRQTlG2yMgy8FCFca8TxnHRO49eRiOUY1Z+ c6rRhy30Wi+M+nv963BYUlG8HZ1HI7/Mq36nRZnZCu3+sOF/28MkcwWyeG8GnWAUFtM6DCbD 9GdJQf/prxgbE7lZcfKpCncYOlX8IqfD4AqOEtOpkhrxm0TzeBaoArPy5svBuAstNAFyGLTe hDfFhI5lp3cVDfs9CsVTOA9Hm8Nz6Cz8cTTsnx+gHDNZ4SaCkjD9IzTdGA9TBfAKhNoKOBn2 eiU4QoGoDE2h0/BmVDkKoPNNPNB7t9USCkdGOB8DfI01SAOv4kHQDOUf6BP6B5dU2G+XtN9D SZK6Bh0D/pcxILMdwfWGVwLc7+WECmL1Ml3K7Q6UOJqjhME5mY+jjqZzAgOANmKDCcywvt09 RteHYbbRUZaizOjVrFot3Z8TDPHfJM8I3gLQKfqVy43Rgl+Gq7UAMIsobHEm1BMJL3EJNKhR uwdHb08pw/vB5v4Oxng6fHvqvXq/vZ989yGPrF7Uozt3joIdAWtQgkso5waCv7r8V1H3A1g3 XGXosHPDLt7wAZcnqb+oPny7vCKTowBupLQu+L+2CFXut52b/V7YHim6jrd5ZQJviDYNoSv6 O8awpqpAcKCJ9x/IxkOwcXk1oWRDkbNDXHShLykgPpi8MSFdKLjGFgGRUnSjIhVUvJFXG4oE Tdg1gYrSFJQQFii0RxcF5TSlFSAH2MslVSgB+pZe4GzBZoi3X6pvH9lf+wgAGGBYKW976GED qyxWXQrwhggEsBpVjKThMM4cCVqKbPkOVmyfdRY2AwBsel9YVssbRQLE4jLBVuus2T7HOYd/ ilqLynpUrYbVK0NRWYs7JLdmsaAqVrV72MlrVIWyZrSHGMI99ao/pD0mDeVyzrrSS/8mlgUn i00JMm5iZ9m8D0pnpeYHZw0U8A2pLJpFt1SqjCHnUqjhYhQF7M52zOVyqekZo5kUH1+qgPoT eJMppF5ShpwKNWWDHnKlugRQYsDjnEsqX4J34/heKldUY+5QZPKLoNciv7dO/xzOkvnqfn67 OY1FurfxbKZQEGsZp3MU3Xu4ROeHiWwqc2Txvt9wyZOaKbrZ+ftaHcenRc5ufLTb47J0dtgP dX6hlw2SC1j9+2cqT3qvvP3yyHwh3VZe/dwK28G4Mzrt/6yqXrlC9+y0//2ZhqbyHI0zX0xB C27gU/Itu1K9IvVU3miqUl1RedazZvZRtKX+Nxn2Fiuu9oB4ZVV1tLfTQE8uEDSxlYYY46WK sDLLzI7TG3eamARklKkrYM7OQ3eq8I6Rd3sA7McwyGtxO17XqQqWU/QNjS3dnQ//t2QZT/W+ QDDr+ceP+QjBXyWu+sGuq32nw9v7hqGxn+vu68Qae/dyG6c3NUn4afcVfLqK2pnoZRe8RheZ qFSB3fjNu/2sWnGr4y/ZVwFmFMwoORp05yx5NX9RKNk9H85ZGI17zufp7ruDrTR6nTGPWlfn wZyNsqlKJsZRjpP5Qa7/2d9oUbpN55vpmY5aYR82FB3GTA00U9g9k6MYgXXpU55eG9JCJzMU k5OZzt8b58S9odfa8gDew5EQ4foQwP5asU/UlmKk6yjIFnAJWar7aSDmIf2IWzlHg3WmTo/4 qtd0hgy/smcOugffqEnqYBt5Kxr8ku1H1spQHn0HGGNiB/xWTofj0KvxyK3B3rP5yQVgPw86 we2UEoMgjq9bUwqIoHPSsiV8DvCkl5lldMpMAC41JHnjw1nL6Ym3JS+uMndxztBqPUFZi8df LPSdcSxGC+44qetH78w0sDUANfTGtERD05VzphR8keKJuXzJOuh8NPwlfUYes5YyT1rlKV9J YywrUwACk6jH3YvtusTXLq7ef3AOgfcsSPiQc+6KxPn/HAJv9DMAKqr3K5WKDtddWNmAVx+4 XffYR7seY1kkwBl2siR3k+558JrfISM9qbeoKnDLshVMHW4SndZQkfxHrRBuUcSNon1bGlXR KAVCwlOUcOEeOIyGGV3BteMct5Vytc61/2WlmCgb9aIRy1FTZavJsl0YQEQ2XnDu5b2ytUTZ m1ib8OOl8rLXv+5p1xjssme5j9dIQr4sBWfSb6ZOeo7uXlgIL110MUxeu1nRXcC6JCogNwTd elHF/kXc3jLNlFfCm2Y4GOkbOQqE3PJ8e+RLqWBjqOeD25aRsDAI/tBabJQRMEdFC5UGyrHq uZ4p99sLNMvyXiIY6rhuMoyNXUNOabjQNBERWEgimiJWByHg4cFdMn84hze0iBQYd7cRVJG6 ikBwH7IgkDggvu2e9TsKaQXF2mwq2OfSAm7jjCEKipTYEZBYxaiE4FZD8gPE6AFVpqJkI7CD 4Qqojost+kQ2vOlvaP/akZnxvpIgIhsmXuRIEMAjWy4vC6owiIGar7vKXJgZ9rdYuagK4uXC HmL0hZZpFKteHx2oYgzeEPSc7YL1BKQhbzyeXwVCnf8tWTOLOnW1rFtQ1ZKDe/nrk8FABurq WnIJ/RcsFJaL9kdxWTzkEE1Y/c5oAXLH3myCkzz1ooscxRnGQ8RsW0PGBYZjz38GDhD8pIFP XBc8+3doZSJuk5vYXfa8s6AEH4/OhpzY8orXanlCs/e53pfLCi5BuncDljDMXffz283p29eX PAhwJH/MMYAto9WllsVrPXURsWuLCP/wLmpvjm8UWtvdwt/QSs59D/dRs25wNICUowppI0QZ gR+I7i7XiUxhDmKyWcQihaNKHIyiuH2rCj/RLeVGPamr5dKy+stf5G/YzGxIiHJdaG6z1VLA 7Nvh/mY1QrBXsQiKfVHQEPXg0PBKkpj4OopD885wBdtjVpOFNA5L39DJMKdhWKhoPMrjgs6+ eOEhK8NEFml9Ac5ILCoTcsVgaWFgk3rK8yjFIuYH8CEDhn9Qn4gvEeO/ui/qfM9BxH4SCCwG SEIgDYsLQb/IgEC321QfUOvh9UG/yOpD0CQAiT4ETeVB0C8yIJwNo9Y59sKD8JLeOhD0iwwI 0YC74EPYPVJ+H/SLDAgcfCjZhxMOSWQh6BdZo+AwRnlYfej+I6pSKuKPS8Id2XHJC4FJekes VtSg7eMubJGdq/xLKG7iPOlMmXLdaZiqurhli7OW/33IJ5Ltl9t/ENlGedoXJdswkj+IbEPL E8j2y21bJMnet0JS//FlKIovWdma00S5tOwWLlxB8dIVEqCiqfUuGo7GQWdmZSQ6XlPidQfz /4N2yorHA9LCBmKk4ORwjdVtOEpeJJZocIga2BJnLW6fCF8dR0ZfSvJFI7GurrxP2A3zqas9 AemTJqFcC4dN33B/6TusGbU+EFGBJnjIJV5o5B9V0G3cXFAouyMxiGRsJ6cfHn69fi88bKt8 ib7q26sDECsU9QJIzoMRkckc88F7GgGVOarAX2ykwVO1sYwt0BDtxJ7ygHW7zuTrJgXVMiBs WiVub5eOAoNOOSm71cKgeE7ZJr7IFx280sTU1THQtcNe59aaAVAb3O/hsrdBsAEsT16dTgVT /nr53sQKx0zqQNXp9y/HA+OOOINo3Y9YYSqmaBi2OFIjtq55mrpPOpaUIT8RxgblavkMAOwv dlO0gpEbDOwbwPWGdGFbQYyOneaWjj89GROVcoRNgcQo7sHasxDE5N0D01AFDuzAdyvVKzq9 KLi3sF5R18EuN5KjtbRWX70CubLjUsrojfQ+uzfaGNXtTXzn9nlFT2j/Pbfxwe8BTQf1oVGc MqG2DZQpc+oohEYyTAuIrKdu4iJJ6Mx5dWOtBLSC3j+PZC4aqdNo3h7oR6PROaZipJhZ6BDh 5xdCB0/9l0GHjOKO6HB6kMBrz7VrSCzxTNy8xKCxUxdq/jaM87RYSQAuaojsor0+ltRFtWog czeuFIty5s0u2/DLul3gDUPfZuyZZRjHMubNXO71l/NsZSIcWN3Y4LHrIQd1QWE1w+yevQ5H 30NBeI/VlJJqaXrnSbjvfQy81UGZ75g08X7HgOFHKRQDHjyAtTbGGWirAptFBmQ7RU5SbSDJ tkaX49QYR90bltjncqIeJP+Aldrao14uZ0T2bM6vxJRzYXt+n+cu9t+f6wA0y/9ntZaK/7la ffZsYf/9AM9ks20n0N8MK1ZrGzzZvnhizD7HxJZ1dJPMefdhywex2s82OZ1qZvrHmZhqG0+V fJxzd78ClAyPaigPR9B7VcjnS/0iSkgoQgyBUB8QiBfsT4wlL6/uZwGZtG10bBqloxPtGr+s zXHCuDifMAXMtAJE2aRnA/hH76d/tmcu+p9h7X6XU2AG/V+vpvL/1NZWF/T/QR6h/xkznOUG 6nuZ5FrwzrEMTJoJkvyLffzfvdxGUSUah7+L2nDz4re7r/RbpwM2KI2O6yVl3lx1FdfEa4i8 PGl10i9PBxkl343obark/vkw8fKQ7PaS1XtNgcmd8y2zqCtkppfsH5njJQPtyEfRRWR/fMl7 ctJXtAFVVvihezkMunCbMG79ORYNApzoimSvJ3Bk6anzbdf8Af2KxmliZ+4NCV7vkfVYdr/h 8zbbjk36fESGYxNrb0mqcdvmlAGQ0g91gMpXMGXCttqjCZ+1amhSbdH7TPislToTPmuNzYTP Wh0zCbhoRcxnjrWRiRqt+GTUGKHcZ/6rUU2CehZtJwXb0Cn+dXRxG4uENini9heqL+M29UX8 nhR0m+8Ce/KC8IoBOYpiDKz6myLR7oxa0niWdJdgZAhxZ0B00FFXjojcoWup6jjy/o4ED8a4 SoB3DAAtMjr/O/wgxus9Kb6cGSloBMK/RXc24B/6ma/mUcuBlmho5/BXemmB0OQU9CwZIFhA D0opKuA0mioGbD0mr8ku9iGXS3Sa5e91LXdPfmZRfl3bmue8zrgaCBLQkQrDKaX74pRrD0j+ NnA7QuPNEO8DwGE+q1xSrA8Fr6HZX8u57cP93e36UjX3t5PGSv0JRgXrPGF+68nKE1FzPgFs PFmioljuaPP0TaKofNzeeVcnUK+ODw9O60tS+Alb0QuYnXdY4uXm1vdUYIVf5eIxXggkmECZ fKrUkgale1KO2BJL5VfyM2pcsVqnLPl8VB6bmVWJC3PmQGpGz/I8nTP3pvySDDA/eVj4+Qnl yPGGxYic3KBXzW+Q+jKjZsvSOql50TqbUUdvP1unOqNG11JNqTGcUWNk6ajU4J0xtdKAd4tT 6clFvxs+CbvhENMuPbmOeq3+dVy+GcAVoVaJ4n4+V/60uH79sz13uP+xdP3Lx/9Zh/9Lx/9Z W+T/eIjHu/+J/sS/+DkCuox4CnDJSMdfoONPCEdrBf5/sKLUzVUroDeY8ExOEIVHuVpB2duI As7A34XrC2T/8YsRRbWqgxr9AUDOaplAqg6Qmqm3vvp0sPqM6o1+wT9S9aCEU3P1ma4at85W fXp+snWym25rVVe4aDVrfoXd7R0uX/P6BmRSmET4JtYK0C1ib35TJ804kj93W6EwsIZLRCbR YzHpylJ3fxiocEOQW0KiOm7vsWZaqI72tU2KQ50i+TyVcj3JSQ2pbwn4loWfZBTJenxtOeF2 tXnRR6bhPX+RwA9/k3/fyL8nxr9jUgEyLEqaFdmGdHUtJ2ZTixaaZuCU7LaMSYkxpcY54vds sI9rkasNrLkkl3ZNX5zB6VmUFhigNh/5m7FzEu0nrMl8ujubncFFkN0bv7t3bf9Nsv2LL928 rNfs5k+SzcdfunmzczLbF9pWZzc7MkzkECRQnOLA2PaVW4rfSNFCwvR3OVhW39ZhxZPpL/y1 /HEZ42rlbE3POgW3o/1UV+d9GFhFtJlkZJmzLijwMWg21fubD7i36qr2VD2iN4/JI1I+F242 2I4AfhecIlUsVlQ35DEiwDH6u0IRXqDK9C/039Dqqvr2W1X7GugO0Sz4gX9bwqXpb4m+x6ga Nx9jVX2q+r3rYNgiXUNtpaYBaGBrU4Ghq40DbYz4UNV1pq1fzwErng/UahLU0zSoCwNqpVKp llxg8OIpE/yaGWABy5ZrxQxoFlKtUlmdBEnwLuhTmc8wpCSsnAe4PR6hVmTMjpSciZUDjDje Lno69UkYDoZhk3KtPjHQ6CjyTwPeJe62GinAZ9EeD0YrpqkNYlO9qOMS+A2GL3+aRx8GS7TG fo4vovZo72fsWuW3iuKLlnnLLxMhW7Ns4LPg46ozkFQm/DUHvnPSAqWhPsM2ts+AX7r9//ou 8DU5BPgrSBtaBL+Ff1bxL4T/dM2DvzoL/tNs/NQS8Fez4dfS+Cm0cOlmwveO9z+aT108v88z 1/1vh4ykkG6dfsb1b9b9r7b69Gk6/+PaIv7rQzxy/3NmWBWcHyUMder9HvXjuKQ6QC52knl/ MgP9JUL5Scy/VES/zeGwfy30rDDEe0QivF6/14+sVK7Av4EtGwzQm/P+/h52kOp0GPRiTAMz j9PH/WzneuE1yedc/EeK0vSoHeA6YTIiOt8jFRBf6c0GMpfpmkC1/XrJWoUdDjPWdUw8td1e F+329I9CAnjR8KbEHrcNpB2ZM3hF9nuunbFMlYq8sI5U74X3ZnJrZMZ5w+3Q3wW5aVIIW+hD myIhwB9SyEbWkU/dG5YlaIg6ko4AahctSFQAsRFPW0ktKUuXXmS2+a9bYrvpT70O0brmNp5Q iaE2TKWbON2RRgbw29jBJof9o1mSIJgTsaYN6GV+5MLkYq4L19o6mmpigZAXjC5YocaLFJXS baKCyEJLoMR7nHOiCq4VKPVT1mRqoUrxLjfP/ZLVk8HmqRxSHgTurSJsIMoGT+Ujd9UQOiMY +h9Ndf9xnrnO/73drZ2Dk53PbWPm+b+aOv+r1bWF/c9DPFv9wS2T7tpKtapeB51+BOf7bq9Z yeWOQ8wOP4zOxnSfxZs1XDoV5ubtj4dAjfDNGYWOp7RpUPEaqAiKBvDf/niEYYGjNu3Wfq+k AtiFmF0kGuFFdDDsY3CfFl5YR5RRrd3HDG4oLGliNjbazjms1A1HG7lqRfk9isnZg7tCuejI eB8IGBqIIrzgrE95hWWMSFd6/VGEkWXhWhMbDwnbGg3J7wq02OwEEdDpSq6W7gI05aBAdwHG 1hpDt36HXigeHIJp9ZtjE6oQKz0B1LNAoIvBHqKgE1s009wgVHcAMM2nb3ZP1Mnhq9MfNo93 FPx9dHz4bnd7Z1u9/FFtvj19c3isNg+21dbhwenx7su3p4fHJ+rnnzdPoOzyMn7KbR78qHb+ dnS8c3KioPTu/tHeLtQHgMebB6e7OyewpA629t5u7x68LikAgTny1N7u/u4pFDs9LKnTNzu5 dDV1+Ert7xxvvYGfmy9393ZPf6SuvNo9PcC2XmHX1NHm8enu1tu9zWN19Pb46PBkJ4cj2d49 2drb3N3f2a7AbfwAmlQ773YOTtXJm829PT0y+H9vYC93oF+bL/d2cgQcBra9e7yzdYojsH9t AX6gS3sldXK0s7WLf+z8bQf6v3n8Y0lgnuz811soBB9z25v7m69hOIUZWADMb7093tnHXsLQ T96+PDndPX17uqNeHx5un+QA8MnO8TugxyfP1d7hCSHo7clOSW1vnm5SwwACsAOf4e+Xb092 CU+7B6c7x8dvj053Dw+KuTeHPwAioI+bUHWbEHp4QEOFWTg8/hGBIg4I3yX1w5sdeH+MKCRM bSIKTgBjW6c5pxi0Bwg8dcaoDnZe7+2+3jnY2sGvhwjlh90TuDhsHu+eYIFdbvaHzR9zh29p yFAGB8R/OuuyRHOndl+pze13u9htKQzTfbIrS+PwVe7k7dYbxeiuLM75mc9c5/9+cBmi0cBn tjHj/EcD4NT5v/5sdXH+P8BzenhUr1SeVCo5nWt3qQDvik+6l0+G404Yl8+COGomv8KZMuo3 ca0cY6FK9zKXy1WO3hwe/Lih6LLS6ahmJwx6Ofm1oWwdiaha5sVXNunNKblvM/efS/+lmsFZ 0DGQymU4YlvRkLv6BH7kckuFEANSLBUoRe3+5vc7DSB9p4dbh3ulzAZKMoaS6QjeqHPUy43c f37HTXKn/xNO8vKwraRKdo/tiP55s2bNtf8/O/MTP7P2f209Zf9fffpsIf97iEfkf37mJzb4 1VmP6uZPMv1NJyVSSeveVIqjdJHMDEPoE6DtXLOtfP9odP3LPfPt/3A0Hnz29p+5/1fW0/f/ xfn/MI+Wsbs3QnbzNG6W7KyNHqKL7fcv98y3/92UNl/c/xs2fYb/9/pC/vcQjz7/3RlOev5N znVkEmNl6OomJNbSoTMa09NnFf3Wxe5L3pHmYy86k+wZrwOSeNUV+WIMUcHVa/XVe4kzUuJ/ ih+KareVyxXqG0XfKsv+JZAKxRwF59igkHcYRmQkMAsYKKSEEe028PJQqP81Ccx13soA+VcN 0+CBY49gp+ADanra0Y1agRclLJ3LnTMAaMSAIoeg5Oh0QdSnUD6hQrFEuhrU1Oy2SJGjEdQt ohAxGAxoUG0Kp51IroM+V9az02ApWSy2/oM2jRCFCh/3muPh8FYFcRyd94rwWjooWTPz7443 9xv7L/OIZ3KkLxj3RQ21SOVebjcO3u475XR2S3IvNWW58O6rCYXF89Qv/vLw8LSxfUzFxadS F0C7uY/R4IdodLHfQKcldLq6Ve+rlcqHZNN+0ajtFU02jPZ4ZvKvek2DywI7mdqC2MM37/Y5 qjisnKhtvWAN4ilePVn4oE8XhaY3nntQ//QoUV98Y+epj/iU+qa6eNHOWR1q779G9Dqto7/t XL0X008OwC1Re2zyb/nKUbZ7bFvM/2yQG03ORS2mZKjrdXew1Xi1t/mahgVly/gx//ixjUKT JwcsTKyah5k2/q7wV/Hx4/yGX3aFy2inVyykW3l7gPJVWlyc7EH8abFBGji1rbM30ODzeV35 aPPk5Aeu7LTGjYkLrbSVM4szYo9AHigSgWB8o3EDl7JmMFLvaT/lS/S6pPLv8+yvh/r5/Ic8 XrywEmyk49O3m3uN7R2UNlM3ukyjQ0oLRbE6xQGMIq8WZb9l2ROivjhtdV6wPom0G6ldbq9x +uPRDq/bjVm+jbpa3tUWI+12PR6pEO52lOznbaEMP0gqun+4vZP34c3wjqRqptt+NeummOkK SVWPNoEenuSzqk7xo8wZahO5gY0nzj2Qx9lzb5GPx5UXx9fFz17eFnEC9eoiFMTDgeJE4jVQ Nrd4wBqKDbVr5ux4d/s1wpEiTixdXWT3SLAmRZxgubrIydbx7tGpheJEwzUNbW59v3OwzbSq bbL0Ffw4t4BxPtAofBcf5Tp2WF1C0ALBQWkFn+f2J+VzWM4vqw1JUhHGzQAQm/8JdjUZg2jL DfmAZaXWTz8tb8DPDSqmP//UW3Y/95Kff/I+43/c74Rp+t6UFYef/2h+dPE87DPf/c+L+3Tn C+D0+1+1trKa0v+sok3o4v73+z/6/ufNsCpwLsSS63RTshGyShTBgM05qYJkbR71u5Su+XPt QidmhJ6UADoYJG+RAww5OEimWYbbEPwnmRc5Ky3xRdQicXPh29+wH+j2MysgWTCYUADbhQLw z1yZhfHi11Fr6tulpRe5Lv1DtnltHRORLruSpbKecn4TsT1FHuNoE+pXPJresWcIBQ4Z+Ikl UzZ2JbjEIW/QUhKgB4t9SJfzRPOOT6IGW6e1QP+h0BkU3uw9/vzgCfV3fikpN2yGVKjrbhqF wW86YqkEKJ0E5T7WuGQGvBfehN07B9As388OuCw+arstzMStHRuHJnmk/YZXe+wgLNANTmfH KSvYyJVCdAfoWwbYosDT7L/YWM42qVTf/vWFykcIGVfl0IS6FvRn90QHfDNdcd4uE9OCLfsv f1peTjjiWdh6Sn03PQG+lOg4D2hlGTMiiXfmDf1gB72L8IY93Wj3SNrz5ezBCwqgr/phGP3m KAHjsDmaG4ZcUFdcjLvfU4/jhEhldaO5HDNqW3jHsNhCt2vnC+2WJHqA1cv5rcr75ez3ef2a WEoTmLxnX4+c1yP7OnBeB/b1mfP6zL5uO6/bM5scLidCqk/tyZXz+kq/dtcHrAzjPIrfYJa9 32QhLJjTfLipQ1eoMew/VZuwxPjXqL/TGyMFM9ApVi1M8IFanbCwvJoysy1yrqd8fAFlYkhP PhdBqUYvvEbBG8wmDHNss4/n4UMZv3g5Gh3E4AUBqniLyS8nwf7fN/0zgMiG+PEiqADaG+Y9 2rGc0fs0EVmmAZi8WJzsrKj/4Hbw4mVieucnEDJ8Ckz/PPTc0zGEjgQ/JzodrEdzZQT5EkcC NWd3P/50PiQzZ8SX0WAfsUBFdnqtk1EX7U05GCgjniVv6uc4ROnvy9ufTa1qshpKES6vyCW1 jnFJL0tXGJaUg/RfltQVxVsF4Hp5SKxSLMzBcKCwiPMSpZsYAvtVf2hSGMXkRKHaFAeVhKRe Vg2OqIq8XQWlYRIvNS6aCKu5DIiOPYGzDIFVyih7E1sX13bUa9ncSjZiqpOC1soh8YOkrHUy 07wLhhEpPGCbk7wgbHkJG6HDfivQ10PyzK6/UO+DD1aVECQK1klcAdNYoThvDrnC9zEm8qw7 Ilh+WbhRG5QlkiflRv2MALohkihYADphz418T/nbcqPIRFeiHiARRxuzd7m3quxKLbiKELkm FP3CJkFwZB39RQ/ksDyYGlFS5NU5Iwin4+JsH8Jw6ukAWCVKOKSzgdB1xvaKyzufhFM1ifWE A3VoIC01852UXT4hJNdrTf0Imm2PwNkPhrE18AyHaxuUgyOZ6y9n2nfgC09tP6WyDPYAb+/d PIMfJjCDhV5n1L+0WPAohAFVQj4up+nEYVunO7d7K/GtbtNf0hdMgS7TKiyenF8WKlKfbJj0 pa78JtzRUM6yIuVwkeE+XxbAuuE0YP1Fsm0uf0XHoqGlBZ3y5qdevshT3uQa+fsfLqf9S5gr gIc+BKP+cO6bxz0PF8G9RUbgUMhAf8YV26UdaJAhuFA/jfC2wGtmEhT+mgaSmL+czNUEfke+ mitBhaZJ1+rNqNfDmtyRiiyK+8+aCBDunnDhnrOmuc2S5R5h8HABVkEJO4WJFuquQjswVSSI Np1v8k4C+qj3hV4pny/SmdPLGciJCvAuu8K9sSmTdvfsFffEJjT9m1pGrvFgmddkrFYwWghc QzCwfLMzjqOrsKi09yX5Gy0Plis5qlTSrD3MAQZbcpa+8zcc5lxc9dTAkEM8pgtSHd4X3d5U bXeq83cHAK1QMiBmCyxsfc7eUDrZgWEHuVOFXrlapLf6DKWAMgtFwL/HM5/8H/7z+eafM/0/ n2X4f64+W1vI/x/g+bX8ldrbPHj9dvP1jtrH5PSkbEaN7xamXQMi81X5U06rCWAhTBDui0R+ GMo9ZT9h4IXhyNMWXxkGXwkh+svbkZY4oix9ZimKS/g1lf06XdhYjvmagIKciFoOTeOs0z9k 8w67xAk+gY+Jw23CrONpcNO4ag7GsVvK+R500K5kFDYuz+Ks71jffMr4Dr1otDvBeRZ8KnAZ Dnthp2FM7qmAF0QfphYDUjlFsoPtI4Mb9FoNESyppPm+tHQRxBdJhGS2Zwtml4vD5ngYjW4b 6GgT3mTEQadiV12aGR9D7/ZlnqbEid+XGX3zbh//R79+U0fv4P+lcnbFN25NvRymNsUAUT/z ziyfaPhL4ywaoXzDdvs9Rrfn9AdRH27icWJY7ylbuS6AqzWeVGBybzjjeZ3/pb5w7vNEW84i MwnRJ3zXGdK979MC9d+LSctm3BiXp33c9bHFJZlFYle//pAoAswWCqWSr4EP0saSQVw6o5Ab MdCv0eZIfa3jcyQf9L6m+khjNpQP8cyYcehC2AaCBea8IDaCahA1L/HDoH/t5AbCX/pvDBEG w1I19QgYOIyqhqwbFrCSWIJyC40OsHzUpr/JrGzAtmQrczBx853/6GDe5IyaSEDvyAvMOv9X 0/lfVp+uVRfn/wM83vn/OuyFQzgqP4atAw5MtK13s8cFJJaDKuxTnCg4wSTzIZAJCseiLQHu s9vhXkSyX4yuEIx0Mu4uNTy77ue3O8V6IWWHLr+dGDTTzRImWxI4enT8pK7Q/U5ybmhZ5hUR 4mRmlk+5XPfy3bbUMOXr6krK1sWSFuYxGF6+JUNU/AxF5TvZ0n7KsUEqTGNMspv3CkMksvAf qBCK4CVhWbeEgSxUgY1aix9yNqDVPlS6ojBW+5f7fpAiI5Iv4EIKTwk1ULzgjLqItvpFjF3l nigSVsgLJFXiWeDYWNrKAdtGAbp0Av7U8bBM40FJvb/8QLGxFKaqx25SLCs6DoZhDEzJaNma zy/hv7rDZB5I2I5HRf7kxUJKHxxwajBQB7kIHzNdSrZQ0QBcogTn0nZfBOlXxZybV1QQu8SR 2LRNfVdSr4nuhlvs0ihw2sYDWF3hHqWIxoMIYRV+4kCPJP/HULS8NIrUCA4kBkDdZUc+QIPn xQXw0SDyKog6yBXQqNxh8AgAz4kysiq47wwQ+3eJ36D7qLWTxKy+bwXPp/5m4FCkp/fxh4XU 4s7PXOd/4neFPOXnb2PW+V99lrr/r60s/D8f5EGj7I0ksUrMd+5dOIyBsvnlVirV3Mltrz+I o9j7ItlihxSruBOdPWmdKQRj4kAp9PiOc3tRM+zFidY3Ox2KBBcf6xjFUqyMlUxZiUiW2xyP LvrDxAB2UDS/z4lKcui3ivGgQreUTmPy3TnFu6rAgHNbQBrP+8NbDxinK81RKjZKXeN8FTfZ LdwM5SsfRS/q1UoNjsOdG7jYcoqXJFIVJV0tJ5CnsecZHQC/DcUP8QArMw9mKuEds4S5WrfP +M8Mb73SJJsJz+uvlDACLaX4vIlwXL5H6ZgZ5VY0tGPjwB28GpioSDGySL8ZDYMyfHTrpGq4 BYcB5r/ikvozfOd5aoUYi9G0fUYpo+tqrfKopAZwio1uy6iEF4PWJn5bhW+TRtcEDjbolNQZ 3vBEnY1iClpUeL4ab8Ss6daRQ2IdQWHarJtAG5Om20nKm5yv+YbvjhjNHZpl1ke4/SnHo1b9 vDf+5hssUeYAa16H5w7lMmE1yMvFcf2HP5nnv55e3qj3bgPPw2fP1ifHf1hJ+n9Xnz0DfmH9 C4xv5vNvfv7PMf+V82gUnff6w98r/hd8Tel/nq2vLPi/B3ieYCzIBR3+t33m2P/3jP77WfF/ +bz4csOc/Pyb738b/9cN/YvBgGuL+L+L+L+L+L+L+L+L+L//ws8c5/89o//O5v+rq6sp/n+t ttD/PsQzI2ivCYs7LRJvZgTdf9qIuP9ezxz7n6N/dn43+8+Vamb8z0X8h4d4vvrTk3E8xH38 ZDjuXQTxJYbLyr1QYuuB0mox4nihpgQLRQfsiPTvu4foWCO//fChC5LwD/fMsf+9X3fV/eIz Y//D9l9L2X+tL/L/PMiTqf/1ZnyS9reWrf3dVLiGSPfbDYbxBTANeH3dUmTYBIRj3MTstXEl tx3GFIXLgz1/9QdRH9NFfDe4gu6cVIDwBaPmxWU0S6kMW6rDOmV953ebYEELyVlKLGjJVD2j IdQXUTz7s5mlgNweRlcU2DdT7bh5Ate9LfQIiEtSFC6qpEfN1pmSxriEOs0uCn22Q5TNwP2t x/+SX1S2thZ1lb5ylfW1vt42s9FO0DsfB+dhufmivlJZK9GCKaPdudXQlpxS5V/G/VH4og4r ea2ymg0TSSPUaJW5dQRcq6yXyH5hwKbrb+LyCQmgjIIzHiKSX7/ZSmhWyz8Q/3xY+4c6Beeg /zCg++kAkR7eTf9XW1lfX13o/x7gmXP+gQb8bvH/11ae1dL8/8L++0EeYfNhfpNRv9Ew+Q2Q z3Ssb2Pkq2NS7WobTS8mF/p/lA6HaJpLIaZsUCmuZ2NKu58Lu5yD9WaCKxaeIU3yk0C/D4Vh a5rqAxHYsvpfxIR9RIL3mLUCTdVGu2HSJaDhNNu1NzvsOYLHU4cAUP3Ti1Bd9vrXPbE3B0aD vGIAEaFttUAjKCnET1FNd8HhHtb5XxoCW8dQOFSNDPbvCrPf0yA4BqvzfnKLNKI6/cPeaxJ5 1W9MgrrCS/xrKkApUIdTPyLXQDcw21EfeKFwqHSQWPsQQjfVQAqM+irud0MdmOQ3dRy2YcVh VttkXaq5F12GKjDV4b6J8YjKB2/39kg8T1HhKFgdjypH9Q76NPmiUOqhL9kaHNhhpxWT+gkl 7gKS5vY3vXYzHhnASnmEOqtegEqrOPxljH02dYEhhRXxClvgdejWbf09aOJa5w5wnbc9VNZI q6YmfdocDoNbxsZJ9DGcOCHyEcP83YQt/IUO6ATiXTDk37THdFea/TE0gtFkgBkasnVaJ7xR 4Q2wNjEykBPb4v7V+V9aT+30EuUQwTPWkklijNuGWFPuJPtLkYsg7H4MYcA/gowaNDYboAuL hbr8EgcrCHW4nuRjkXWDxIeTMGeW1EhUXFJyJgNbje3oob7HDUZOZ/QG/iVyaYognYnViOaJ OjayHTMbCSMqQM1RcK5WYAA0Dnini8naB1hKF6tKMbeNWylvdxRUkPK1KeV5+4gzaJmCCbIj AE44hh1ShZ8IA0xCbtBwEEsXGVAW7lA5Ca2uplstMMlpaY83b99BG1icvPfUmi2Bu4tc6Ci2 Ur/T6ixLtJRQFWyN9aJOO4DveMlSq0Xrxsf7DhF+E0+H9lT9LG9/NjMyJfDY7KZ5X8OcxB/N PD4z0/0x0VxypvRqx1qcz9t2tefUveH1yV3wFii/cleo008KMsq7j3d2uzi5QwXe6e2Fq8W/ xjMn/8/X/8+8Aszi/9efpuT/tdXVBf//EI/n//lf4yCO/gvlIhz1wft4FDQvg/Nwt8uu6I4/ KC+OxP0BbhTWgxIFQbm082M+KY7Jqz15U9mqnNz2RsENOkZu6arOV+pm5fXWVi7XdJkPpHJb FWJDmkK3bGA/+FuOYHMAj4ggv2+Obn8jEkeH4VLU2hip39jXWh/CI+UUXRrdbhSaR6MhAymq R7q4cwbPU5yP4Bt9CGZ0pOBej+BuBBVzzunYjrGiHDRcncWkqtEIRqyoCRuNQmGAWQxaxSJw cEtxCy9AGxRysclnQRsOrE8GOB+WeOK047uCT5yUOPawN+4itOeJb2Nq5nM6OvZBfZJfv2n/ eH1o4kOtKwoBQAOg3wAc/xXY+OeexYGtt0cH7vsm/v0bzwe9Ds7CDuEHZsRgTc55jFapWc1e MbkK9BJ4v9T7YGpiKDi6scYXxKoHnevgNsYUTWEwBDS1KKqUXFwqev4z7i3QmCRoeWtDwfaC S7y6cICUvNPVBnrdal63UZxW+yoYVlSMvuFwj4K6ACdnVnTG5jOLPXP/Tew8Y4oC8ck8GKQm eyqYpEKNJCgNTxMBCrD1GiOy0+7iKyIwN3RNjHGv4dhUAa+ZEYZmgFvRWecW52MIKC8qKdof RudwFewwdaH+TKA89O2LUZ+Gi56rftTKIDiNCSX+eBoTf5xMZBr3JzGyoU83XwP0u5KZRmN6 bydTmrvteV4P/xL73pJXgypa5jyBhMrUyM3NoZhecebiUXxOmAHKYm4x5u6yVaE/Xw/744H+ 3ibanGrwTo01SV6G+e7wX2poO4TLL5niytcWDQ9OAW4J904rbHst6tttVot8fYZvz3l0fzTX Z595+X9U6X2uBmAG/1+rrqTiv9SqtUX8t4d4PBafor2EEmXD4/Bx+jMYfA6kTbIGEuV50jCT ypsLUU69mfIwfcxpFsww37dynHuwJsm9skvxMdgw9NI0kpREuR/08Wdbf8XC5Pcf4L0nWmpw wSnlknIgKscvTWfhmw5mzgB87L6ntx/SCJbSMjyKAv7e/yRNFNobbQo79ZtIctvq57ATdn/W BaBivmXijZPomkOXE03j1H2ahmYkh/EfqObNhqHM5ovfO8JVRgRyenSqi/kg6k6qDSlaROg5 B+nZC5eOqxR+k9PknPeNIsWO9tdcdiV96sKpylMAf6ife/3RTnIGzgI5cJVkME1MAVT8kMIu rfUJ2KurSU8SRM62Mklbx6tgF1mdulokBv+nfeY9/0mE8/vI/9afrqbP/9X12uL8f4Bnkvyv NE3eR4shix2YZDvgBYkt0H+POuO41P0YDvvFqdK9zxYaTgoVm07bxrnYyMQL+BDUJE9I12aL VPbFNIxAHeVyv9I9Di6iV9Gw36N0Al1qKO43I0owQlIHvHDH5Ii3gQdntYK1oiFaSQNUVsOq WkVtKrZcu76Imhf6bngWcjnoD9pHskKGnfr6g3InvAo7YlswfMK2BENiPFYRnraBYMHHddTR ZaUouyIizJLqIyelo9W2KpoZ6nd5AFpv1Or3lkeqF+LNsHfLMX6CjrruDy9R2Y/d7fdCPYhI M0HXF7fcGHMW8IfOEFHJwSIz1iU7PQxPh/9Fk4krY7KBkcJwErX2edZTwJoliSb7htAqkWWd e14R4+fhLXdzNBpOOvm87xF0Lt9o2FNZuMgol4NjWwuGNC9xUtm5GZgPvqyAxIs3A7jA9vBC agppXgE4G+UUwtul15M2y2v6vc7tbpswpDcYxu8z6WQK8m9XnRXlX10HuEWMHE/bUb+LY8k+ GAPPFMW7vVZ4o2V9OCkOw0QRCN0iMF2zJF8kUYL/Cuv5XuXHPc6To2An5JUruerRPELxZBtL YsayhFHj6KKOb3spiSCqQDH2ISlI34SdASegk2GYaaZx2BII60ZfVnDVdShyHrwrmPUIfxQn 2RuQJr3QKDVK9BeLWTDGYmbptATT9lqPLqPPZOXjjV5SPic6Ta/n67d0vAUdhz6T+j+7nJMP iaVHhfzbniZRbLRsUx6R3QDuMbQ8wVF4Gmp44XxqxemdzyEMTfInkdpj5usWium0TEq/g/Ja 7FLCsSiTh0r+uG9qsMygoeWy2u21h4ExVCdKfcHryZihWZLIkTfPbtUZdAprC/1mw3NNxCs5 HY6aAdXlD7LGYeBAyZRy1oeWZaUpHduzSSUo5BO67IJkFM7ptJwCYjTH8svzPtDzYcyWaXgc Hhye7mxARwEH1yHFDcij/LwTfLzthUBcgFo2L/MyaT/DNP9s8MFjp2WEi2LcgbH3wv447txW FLQH5fCQieGIaQYImZzaYTABx0uLYfX3MDLpGYaobI6HmDejlIv7Cs7I4S0vWjoCnSP1LGyj ZVQ00t2oKDiNePyvgDbh8AX/iCg0S0Siut1vomn7VdEtOqDDEJegusLE62IgQpHNK5zWvagK Lm4HuE9IBM1/tONsg5MS7VxHAItb3j68awrpnQL/4zTxBWv+iH0s4jZQ9nOLoaAhkBAS2UQZ vcGYppxJHveXR2fEXpJaKDlLdED9bXGjBRpviQaLjY57H6MBhTJFgJZwQoFiMvSsT8mmcwE6 cKmz6AdAFRAsbCyrzfNijRqxs5z9vtIPT0b8N3H2G7EI5n2HSabD+EgYR87tFrj8BJXBIwYK sY+B+noFpg9+DYaYJO535//nvP+xD8fvcv+rVp+tpPJ/12rPFve/h3g+5/7Hi6HApxPQuxJv LJP2O8sEhExEZhqETLigpe6TE29sX/oKmROqbom/fjHpDK4rcw4kT9q6+qnlKjpFmRRTmE3k epm35xqiMSqQIrfk/PcRq62Sh3OdpdafdI8n3WGcr3KD4XnMvMiYoczHWdjiROVpzNAnuVAU SMyIogDsEZbgRKJsUKr1Z1AJVWjqp3h8xmoHwhiVXHJ0cKh7JMTlVCbqBCqiTD26CINBI+zB KcW/gSXQfz5CE/HDs79vtlpDrVjmL/IBkOSWYWWwUZ7jRawxon+es0Z3KR514w3de3rl1qeE vfSLIel80fhLTE+YJfKPX+Tyc2bHOdPB7gWGE4H/FJ1yiOUmTUJBEfexxNyHyattVqHGITCp LNsV9JyN26XUcOFlA/+0S9EDjkcKr3+XU5G3oig285jTzMTntA8TZs7+7DnRX/2FgJMKQNRj AypZEpaIFEp+sesCyzxWXz+3fYjaaEHCENW36uuint/yN8+9Qo+YEaP+jmHsT9cao0dFgvin uloao9vraKMQxJx6RV0ULagqLBbbJI0jsajwQVBZ73l9FnrhNbwOmyPAWzH5MbVT9U3PLeuu XHzYMIING/Qs2qfuM0qOr0sTQY6chDO6Al/+C9b9hUrqWzX9e1Fq6OD2wn96xZNs4u+Qi8bi 0TEDgmvSyaj7IecieYoVlD0T0Jhh1P2NbZHqaLnR64S9gkwiUnxZv2U9sXoL4lPS1XGFMYh6 VhWzktaeK5VRXa/wx3UB81hVi8+TEySPqZ6wh4k/Th7XUkELueKPaAuJr/vtQspWZvrgXkwd 2/rzjD5mDZF2/4TBTRtoY8q8ZY/ntmixOHVcUwf2NAspdxiPOw7a6KzlNgY3crCYCxAs5ped fvNydxR2P6RrtGKFi7lcxqB2TCT6olFE2UdPUqVqh5HfPCFey1Xf1g1pea+kTWI23jet1Y1L 4PG4wBAj/bO/l1/Q2dFpIW7EmcoqQevZLAg0rumaay+UZD3SD16opYOwzaGGTAKfGX9J9WdD OeyAPg5ZqMnTZUS59gIJNLTTUim6aS+YNBQyPEjOXNYlFulRqgogQC6zxFjxGJBCZZi5wvxs kJ2ccDfqbBgGl889ngV5MvjypdCdgdVxEp8oM9uM43GXFh6qNn6G8iRKsq6D9J5+xLg4gx4u GaLK8AEhXIfLV6jxQMpFfUYVSzSKJdQibcdKzhuNRTczwobPTp4BqbO0e0ZzmD4RktZ91hLF MY/hl65wXNsjKl9y3XPRaQjUr8RohUNEaYplLhYMo4wc8l/MEZO1C5BcIRxgV1YMcYIXGYUd k2plEpi5G1QG5Z8f+Hbi1cEwJBNWkDNg3+r6UV+zbhkdRdxEGe+RkBXwurTyHG5N37rnF1D0 x4+jtEkqP7x2scnHmYBV5n0hgb3Uu0+ps8gaKrlI6/eawYiST6WoNsn/Ue4G2KOPcTbuIiD6 aBUbbnCpot84/+va2tOlJYt64zR0b0/dCZjlbeDPYaJyGlPxdTRqXqgCUQoANmFShMftGrw4 FJEUV1izTXLY962w3Rl9yJAvpiZlBloIEBur4ogkKtaGOdRrFhm+A0kSF48KBREDABKKDoOf wRTQFcA+WWXJhMhhU82wtGVR5qbjjlrHmHQ36Y6je6qvNei6nT0pE0eVUXbiqDLKpi87WbLi mbeeVKXkDjR3XFijonsTMu/p2OjOMtHm37MZHhVdounp2qxLw/1NieeV/+oIQZ/Txgz579Nq NcP/bxH/60GeOV380NylgCulmBUmBFMuYxa2twNgJUpRvNkZXAQH424xFTtEFQbBcETSwlJv fDZHQkQpwImYKjvWvibxZfcwWfQmSpaBvR33O2HldTg6HCQ/6nzEqlD49smLYnGmrHmieJvl 4yYpZM/9JaJv+cWhsPQPasOAd4TUrniaMBiHW9jd4oyyFRna6y2oBjQQ/tVRHQ45NhUQK/mL 5NhRbzAeUbbNVOZoSdmzHQ3dT0ybUG/dHWCYLiD7qHeVdF9hi6r2GSbaRqMKuYA/SgZEUcTW 0q2QVbikySS7pN8EnxhqhDGUot9+pInSzi8Ydqa008MVqINYdEJ9XNBcvQkDdK35TckftuHf FKz/jn0xZ3PQksT7okECVim+nSpoTAPhlj9hxH2D/vf8Ek1w3ufDi/wHqrE5BOiCt/0zYNKk m4yTosq/2t3bySeOpbxg7ILLYpQykiLnnWIlt7nWrOYY85Oak3mZu7nBrOZ4fic1J1rUuZsL I2zuOPzFbQ4ao+mdC5Fkj2Lj68+B0GlNzoXMOzc5mNbkXAi9U5PL0fIHbNi0+NON6tOlg8iH oRF1daM+QcPbu8epdne5mGpFwxA9TW5RNR+w1csQnTGvyAhM4UFTdHthlSN6nG2FzdepdUNm 6qrQLt2gvMK86jsMu114bdFAQVkC4gLNKN4wTFgf6Ug/R4ZZh3bX7x4aaup8wFt+qw9DO48l PSsgTowhiVPksuooHHbHo1Bp2kAVLPtYaMfA2LerpXbtA/zxgazJ5PqwxMFMaDbaFNuEx9R2 Q7RImJ04QQI3SJwlP97Lyq9U1IcU4aNR61G5h0VdtauZd1u7fvy1kc/PKu5M5vvCBYy5+Ju6 QPRdxBk98x44jbRNEPn1aoIBd3hr/oPp/PQtrDIdnlk5hUZJ3cQG9zCnF0dj5Nf3MKxMC4Uh eTjRoU0MLrUxZYyA8f0GrPpE9eKknPP0jGM41J2+NEpQJWZTzknwsIR68ULq5ugfWamB/Kpn DcTvxRLX3+21+yoPl4NzWIed4Dz+oHYPjt6eInFRpz8e7Zy82dnc3jnO6yXsQgmBHXsVRJ0x Mo/EwpAJlctLoFnjIUd6swVYDcpbaBjSDrIMkOZqVP682cwXzf58ny/3+jASWHRAHRGEs90Q it1WFAWKJFCpySyQ3SJQbECg232pyVGhSObHQrw+dXg0yaxSWspsKpzQhvdIGCpn32NIKj/u to66jfQLZkFTHMvkkWGaRiJ1uGA3MtYg0yykwUI5EUgBYHBcPZdySDzZxIPx8dqYMJxOoP4A NXTQniXFAHDSIi9BTeowNyYQuA/ZraksaoBcX5/TXNOwZJE5LBgLx4W99cq2uTUjmhW1Ytuc rTwCYzybaQOrXag7t6obxTF+5/jD1hy2zacinT99WhRwngTjUf912PshGPYkVOJ2v5l8i10j q8L3rHXPP3mCGXMOdg9eb7BxJB3hKAGHil20kQg60BON1VbFUKaShXDUCXG4sMuQgQ9baAc5 MgaWt/3xEIMy9M5h/F1ah7CqADnxyEL7gCHeiMq/HgfDVnJvw1DkH78Y9bbVb6YH9lXURnPi vPr28QtWgyQ7/hVbb2aWAJCp4mGvFbWdDlvJTSSxLKkghxu5GlHfaEPgj4CUV/pyS8nt5c6r AimSMuKuq+XGci5HDg2vOK/viBuSa5B2MmTTDTq9CsM+ftEJcjkAZBGZjfQeRJtFMUV1wGcW ZZNU6GjBeYunWWmikSr8S/7vKCbuDxHIkkrYj9pu0W7F7O/mKuXvN93P905HP/i1L+xWZ50U UB7p/UWOJ7KQ/5Y2kbdp3WESBCiQf5FHFvCiAXiMpTKNk/mBHBMKAsnM8tQWCrobxWQDzVQD yFAb8O4aK3BnStKFktQtUQ2j/ySyc+GcIsKTudqxAhxx38LZ0YnOKhcv8g4NBOCtYez+fq+o KHotQdES/aKAEPBL+TVJFwSsLHbIgeEw8MxEitYoLpEawTF5i6WzFbGSyyLaBexgCVtgvxY2 +2V5PJu/i+VSUYw5tKWysXmRu9I/B0K06eznIcQz5ZqIELnJJRDiDSXDAH0SXvppRGTUXlJx D69pSDdfaeeymYhqxXbc9QQtmYYXHytsK41YQd+PFvIs7IGHh5/2sqAgp2NyvbsIKag8Et5+ m35eBcOoP+ajMq7kbNTYa/Z8u5ZKLfbg6MI1IRoQhxRqHwN2cTO3VX3fyBHIcrlsAECnyLXl VrFGLuRIsqM+HKEXSAbiPjYrXn7d4BL+RtcR0k6PCG14L+71mRludsi4ntwTcpZRI8priK1H ZIWzBvYwwdfVqfubnQ5MK94gMbdgHA5HaFTIXgQi1zN/ugZ9btl2CShZqYVeDXGpGWtihn4E bSN7M/OewXGZyf97DzjSuBQAqL/HpTOceviNBBd+wqG7tKTO7LIaD1oqARz7yl37AX0j/y4i jQJ3kGrCdEVtmBch6rQkoFkEdoHnLfQ/7MQhDYaaaDJbbGowc4veUdQku2k53xt+l8jpC763 MXIU+fbBCJtF893n8CZxxzDyBHvEHAJzP/RuDCzKGFno3vgM193EqzLAampGX4+pjfMnPboe RqPwlcabvrnzjeLJC829znrYIBT+8Rm+OesWev23PfTEQbzE2GWDv5a5pdBEqEmdb9su2Lo5 XRcXvl6vui4wwHybdjHjOJ5cTHDMMY+trbvm1KZ15A9LmHz/Zd1lyXBmiRnKfzUYBufdQOGV txUF53jJRdNxys7dUj/lyz+MCUpZU8GfSNRSuktVJI0Ya5mrfvgdbCahmdgzl+QYHPx+gt+o H4SRS9KXRLxF54u2JGmk6rhxXfD6bg0lqFCF41kXtfzMDe8yR3E3mI214UkGYbv5oLtiYs+I GQxz2p57JP8lX+qqf8NQNSWG3w2UymovAPjdv2QvSqTAhQAIKR2iRvsG73Dxi/dt/7IIo5DB tHgwrcQtHWhmQGQYgNMpzJbp8g4AnMWLMCD/dM+c+n/N1f8e+v+1Zyvraf1/dXWh/3+A53P8 v+Q+6hsC+CrwdPTfWdr0lI/XZJOA383Z69dyDoN4oF9RaDyzRxTWgxyx7d1iA32j2FRyQ2nT 0r+jLG8QxCOp09KXDVhhKC07G7fbGMRR7JUwL5Q1SsVyg07QDPVdQirxtcleD7iMyW3RP/t7 rjk2ach8eGLl6gPEfvNVJ0IHajx8eHitSg62ugcpG5BkXEdAJXtpGgqa8CKdIzwGnfM+cGIX XfHWBiRzPnNEX7WiMDuaY4yLDssufGnb6bYcSAUq+TN09mcs9LPg8+cipmc/CbUJMHzyBtEL r6dgpBBVwkrJBbZaUW8HLVwK5qWFGbTZsNgFW8mtVeDw7zfRvT0en+H9s98LcUJgIUinEF0U MkUjS7esk5IUOQrK7+94+MX8Dnn56GBpZMxxZydEhpHphPiFvRC5pc90Q3QcET1XRMcZ8cu7 I85ySJRCmYbE01wPky5cCVP+DAfEnJXPTfdA9OR4n+uBiEa/o9st9UgjJ+UI+Hv6H5rWgc6U /BlIOySmnBFT7obGQSfTL5EMms074wk0yYNwgvegXSBZDoS2uuMs9LXvMDjBX3CGu2B6S03x F+SRlZXxNXB8nIpZvoQ4Cf5Ttyawc7gaOum2HtLVUG8Wm/bMo1LeRze4sENNYFHCLIaGqDQa TTgyGyytLlCMdLs6Hz1Szl6Xd8aRTE/Dr/PREnF5eE7w0XR7+aeVZfWXv5il862BjP4P1InH j/U0OhfHR9TNR0WnPSicWOtpoL6VeBoIdse19zZt25efstt44bRhHGqdnTWVXmY7vVJM50w/ UHa7muYF6soAyCocrefNXFlfHX/qCd9/MdTIjMj3MZ7mncNB2D0xCTlsJnuQReju5MCZJmrT 3TZrtkY37DYHt8b5FQfNTudZhMylqs7gGvOPaYrT5h84iH83D03/LFm4aN7JRfPuHpr3RPdc Lpp+G3M7Tqa5iomekw4RxecLOk7+Lq6Td3KeTLhPTnWgxNe/lq01kAm/tnly8nZ/x+bFJJMv FACgsQ+6ZXECbBOWrjUOOvrefBZeBFcREAqRZkhUupIVTbx+u3m8eXC6s0NATCNXQWccuo1U lJeeE750wwA1qSSNIOgEQYtbIkqE0YlIWQpbuoM5WUnbir0vhJXzCmoEEbQ0hpCWWXAdjweD fsxVjRzAJCAtljzBDgWDi8Nzxx6UlMnS+XEv+mUsEokoppUHyO1z5Da5tztexlCQQGAIb6D/ aOFMDQSduK86YUB9Cmx7qMnF8tM9/6wXJPJkyaeOlwLH3y5jJSVvDYPR0AQdqSMXpJ48URd9 DJ3e6wOS2/0My9iE912iD5Nd8VLXiAw12uzrRNoRz7xIusTO9E5U87sn3hPxszGfUedzET0X pr8sqjNdtqeBXvhsq4XPNj3/Aj7buT/S/fe+PsBz6v/IUfH3yf9TrT2rpfV/1WcrC/3fAzxz +v/S/E+L78ic/iRdnvH/9V4Q/z/DhTVD17fZCzq3cWR0jRTtfC86m0NxGJM/7Dvg1shYcYOy pvsv66om5tr78PcxGQCdsg0PQjp5uwNcmjoNzrdDuBAXdm6aIVndneoLyC7aJlH8W7bhACxV jB0H/tD3HJOLORxK5F+82EhOaK9PGdmYdYVcbhjABWCT7lUHcOCSk453w9xXgSnUiygBdl3R C/FwKQCffNjGyvCdsujktacC5r3OiWMLNLB1OgR+vQPEl25sOxFxwNIUOe5I2XEOmZThuLfb UhX81+Ipp3SidngN8K4aqhDQlIaAHTV2wpKzxwy6MOGDbi9Or8n5SQqyZ0zhxvrFjXtm6s5h smIMpmsOEzTy6pD7QjPocPJaTHfeQXYR2P2XQAxHGNwYJ50yOMQIhWxV2wgpcbbckJcN2n0B X0/npwXslyRjnGZcajkWrUmXLyxzwX5vJn65XiWxm2YOTiRstxUnjPzkeKJ5+FWJwbDirFsj 2nNwg5niZ1ZyzHLrKTMgv6TEeSboF1NKfvInqlFSxnctPadoIWcmAVZdwdn8JC0oKZmMoona 705bxGVIXI+3twKlafg5io+GYTu6OWz/zAKb075WMpIIglY6SyOg0WSbevdy1gldEGM370qL BtwNQdIB+2f0fh+XGcpBSI1WUppcFDUIPRyppBpIJjCRZYy7NSc2iyNcCqM+LQ7Y5NZLnnYa C/vef0g4p73/4PiSFZxVHcZmZphoFPIvg9afJAUVXqtgfaNmHK3nobSp2j0j5zLq3mmfNYOM XXqli+kmobgdMSxWXvDoVsPo5aolyfIA79UnwK0HfcJUvUd53Yc0got+7QYnSpP+CJOVy+g+ waNBsF9uL2IRpj/z9L1eV3nadfmcSXXn+/KipV7m43r0ErPIXfhVOTosXHB5/j3Di3biU1JO +E2Cx78/H57VhCUmT2/891vvAhSvAcpLiv4m9H+Yc8gaJrz8MmPWAFvZToVfZtDZSYmVSmwu 3Fu4QsbdUIx3upeygBKLtUCrsAH/14s2iL6lwOgMt3E+l6O0t5tEKogTsVtC7DCcAu4+yOe9 L3db+nAVGxCdnbz8af7x5ujNf4KK4pUuC4+zcOe07wziDpgDxKGB0Va/OyCeB/7FSUa2j3Cn eThbquCWGRKNdkgz3/pukS626QLrqJCHeAoE8aVHra1Mmx6MY8KEPzF0/MDhVlDUORyFLWcD Y5ewlukb1L+MeiSQPKNQC4QXSkrj7oAWYRA762DPI97yeFwP38QFdKIgMjRN4qxpdNSJSZln 6GGZB3BtwsfCjymlSRKAhbG0EUokKuglhv24Ab6DpxiWobZQclln/drMNp/5bg1Af88u754d z0FfV3Vn6oDSfg3DX8bR0M6SBiYHZNx1pwLmYdzroCVZIYr17R/KwJ3DhbwZx4D0zq1kFvNX g8enahR4lIo4FaOc2qf5M6ZVrJsyBdp2wG074M1ev/cyEglVg/7PMHV5+MBZvpI9k8pOg5jt iv4geUiDVyfGLoESONJZqIFiGjUYYSQaReTtMZyKE8Y8bszE3JqIAfyM6L8TOCwHuYyFXyWv qugFS+wewOwL4ltn0XLXXMb91lwUHZJj27/5rrBN8VPoxRndevH2o6mOxhC9ryMjjAX/a0xp UAtJ4qfvzMPYIgj3LV8W5ZbITob2IkVL4czby6e3cKMOz4fQZsMl7Tbt12hYdIu/6vSDEc7f fMWJ3KJdJe12Q4DxjS025bhA53yzFiQADWfm8+67GsmFo9GQs3s7uC44g4QeXQTDIuGvSpfP qfPweRPhgqh+HgiDWFGK8BmbPVaY4y+/mHTDP+MR+LO/j9xOkCpBdyP++Dv0ZPpNCZp01/Pb 3mWvf92jXnGq3xQDonM6oxShS4ZiAcYSJqMB5zy2INAZkNdoAtIJG31x0l+yMpl0uFtg5HkI vQ5NGBL82z9etzDuHVyDt2DZ8p+RJKPTy0IrcJy8hGRkTescHeDOw9GW/hEVi74EhNg5JqWJ pHsavlVs2qZ0dsPEgZSAPYGFnrarHfzZcBuAFX+1y3Va72j6geybHkdjxla+1zYUc8PEyN3+ kSjQGyJ/cReEG05EU2c0V7qLPmBe+T9B/338f2rVjPxPq8+qC/n/Azyf4/8j0QY+y//nyydo MrEAJjkb+AXEqj3Pb9MOB8T65ZJhDTZUwbXeLfm5Y5PF2do94WdBdrdcUBV0rlNrwO6Z/xoD 4MxKqhUORheupjShA0+qvqk867xd2jpAB6x2Ia9UvuhZHVIEJRtjwfNE1beDqfhw4zNYDwyL EhoW6TzTk5NW3JqBl0in3BwPTyfgbU64CUxasIqiTyc10KJ8NiBf9lu37DjiOovkfPRZpTAB rs/U+LKHyCMGQFkd68rNiJrL9MjwO5VOzauN6dKdn2CL7LLeCGAweEeWVe0udlQnIab0SL9l Kc2lnFwUEYjDjOQF7WjOnXfO8vyfLy4c/ibvfXeLNZ1ClCY4q5ALqdPvnWdC6iRLqURRLuUV g5N2mGyTe++WMovLGYWMcZxVzBkHFcss5HSOOzaxlBSV7mcWc8bBHXNKZTJcTnCzscNpuSl+ 6eZEUFyPduUuofyf47xeQLJ+eMlpS63bZaqgxYSe2TY+ZLZF5jnZxlqyUYfBNfmWqvy3vXGn 8yJPAUtJE8QbStb/crFIzLhLcT5x4A8frvHRqaK1V8qQhY2V7PVpuajTh2GV51ldzNqOy14/ 5O/fPqSzAgCakkgyfh0TO3nXjt6ls26HnS4zl8sMdYaFUAadZka4IFQZibFYi1NdfdNadnNL vfet+wERdmM5I5piDfYx0xxMj33A9tU46vz7P48/bORVdBUMUyhw2qXu4yxU1WM5e31k+SWR olONRClvQjnVXNIczTWTmz6bc0+lYyRl/jR/aIov/7ABMKHDpKePzLYW+7YbxzqMzoQbN/wm 6cIm0Ij8txRy6EXesYSSWB7vU9ZujuFcnLSZuxETuJTlmts3DZIt0gqAQ22Q5lmfja3hGUJI ws/Fd3HVSPSU0grjxZWYLKCqCS8GWI1klYxWboPByfjsg+vfKB8xyoe7aP8cbxiMLrH/EHo9 nMC+apPwgyApZQ3d7rKU77akM5f2XwjV4oxxMqGGs9LbKBWeSre4xqQV33adEp3HNw+UPIbi LFgXGS6uW+jlrrxjTw9+d8LvXJYOS1KsIZlSasB3r5EOQUVnrk1ZWZeTnWsKnmsKtldkrDgI pYXJLbsON+gvMPZ8U6zJUHLVsm9KeunP7ZfiU8os2kqVaa12grOdjEm626qcdz1mrMRxqtBd Ft8dll3CHpXddZK02PPd4eXoLkZClqW+eoN7NwvjkUQ2pb9DPCc9kVn+TSeVnZtB5o3EmX24 NKASV0u9hH3Dt+/h9QcWmWZwcCgz0yeHt4BNq7Y1c42hljKbYWEqB2vLme8e4PcE+YO2O3L/ 1U15gEnzLRf4XkeCmmovBHpdWOJ/N7sj91ZLJeSGbmYVIQLxB2a5i9HMinBzxQY28D+6shfU VkNWujUmUrJaeG94dsYpKkElq+KJLe1ioV5HV6ir/E+9/BQY+XyO4zOe8NyRqw7H+m9F8aAT 3MI+hRMZZea9cyiATs+l3PUFRnBD1U4nvKF3UCJdB+NvUAUVmHiUYSsXqDNUPo6HZKIY9cjJ RhZP+ppMNmTyFVkMq4H69RNSVFoTztIr2DtL0dzTZVF65Vy2fXpJh1sueuVEyoAyeOIL8J2W GDtd9q5dfo9pRIYdK5L/CFyM0PTQLaHDnDWKNqah+535718/Kef7IuTXP/czh/x/FMaj+Mk9 2kB5+LNn6xPk//x3Qv5frdae/sf6FxvllOffXP4/9/wzIfisZfAZ819bqz5bzP8DPHedf85s cLdl8Bnzv/psZTH/D/F85vzju0p/PBqMpyKFn+n635Xq+mpK//u0ur7w/3qIp1xWOJdVnEyV vtqNoi58DbqDDaVgitZyzW5rQ2uN+oOwxzd7DLCNogko9WQQjC5gHT3Bd/SxN+42hmE7ho81 ekE/tNRt5QO+X9E/q/hzdSWno+NtqMNLVXhaU2e3I/QziIMreZsje2794w/r6Hw3ZEFzbQ40 r63WqrN7z5qNZLdXnG77GFxbuQsGv1Qf7oSc1TmQsw498zrW7PTjUHqGoTjXavca+Dzw5xvU H72x53zuQf+JZszTxgz6D8xBKv/v+vrKIv7vQzz/j3f/w//0//k//d/+9//9f2Xf/f/k+R+d vz1q+R//W/jyf/ijurx4vuBzj/1f+2L7fz3F/6+vPVtb7P8HePT+/7//b7K/6/3/sL1aPA/1 3GP/r/6++399sf8f4NH7/+v/Hf/+H+B/j/7QHi2eh3zuuv8p9F7l4k5tzJL/rACvn5L/1Rb2 /w/xSAJVE0VcebakOf35fBj0RnjDd0qYj6ebr4+Od17t/q1wU1SNhnGkbjQKBeONDd+KRVPl 9c7BzvHm6U7hpnSbqkO+7/SFfGJuByHUslUkVQDc0rVPP/5dFGMqsuIzozF3e4o4TQYsTnex mlj9OZXx4djaWtahjTJck10j8tAfXRTh+/e6wAcdXR+FKBL5OtGc6W+7pQuT4GHO0s6rfrsd hyMNZBgGVATAdeGPT+qiH48a8ag/DM4Jaw0o+kcvwcXzBz53pf9YutK8Wxsz6P9q9Wla/7O+ 8mxB/x/g0Tkklcn8mrOv2s3eqOO/AhIKBf13JnuufZcnf9jKRd55NRAfQvddKHnF3HetUL/L OSlqMFgYLES088U8ioY+lzJomnoklD0nlPxs3H4PbMYKxjj5deUTksSsWldReA0lCulvj4oA gqixdpoql9Wf47S0+qdevkRJw59TWfIxS4MrrJSwhx5AK7Zmb6x2uzOOLwqAbbhmcVHEQ/wR emiPwAIdg9C5ko5fD39zxHqKVf9RfYsRpvno0E3tkC/Hn1vYWbJ/F5E9OafGH/nEcPwgdD2U p/+5JfJ0t/IndyBazs7DIEM4TIDShMNoVKApA2rwlD5Sos5Cu1XCAQgsOvjgnWBQtwzN+fiy MnxuqBt24eTD4WOOlY+llZutWsnBiSqzqb/CKMevMBzzNaaHPQ+GZzAvktAJy1ek1xzp23IY hb/g+jBj9kN4T0EwFJqB4eQoDUInLx/sioehebQSP/U0fJvG4hM6O44oOU5BtgxtN+RgaLvU VkpqFfdM9qYhxgKnrduqGG7LGALWSRn3XL5TmcC4BtF3eMd8kS0yruCbiua+0ILQEz/nMwpr ZgvjN2Z8pk/cIPNsiAOhKHmjzIDJ+ovZl5MGhLqxew8IvZemj2Jl+igYQHIUtblHgYquGaMQ DtTtBb2qtFsGF7V0H1ZTfXAX2x993i0e/7kr/wdTTbYf8R1EAKTim2z/U115mrr/r609rS34 vwd4vvrTk7Oo9+QMY9HC8anKYS63dbh/tLu3U89XKk/4/1vA9D2hNZJYG94vYNi2turnzWbu 5Ghni6qLuCif297ZOtzeacBbYe+a5t2busPy7RzocsIaNs27N3WHXYQb/Onpj1hO2Mqmefem 7rCapz8e7ZzgK8OQ5k53Tk4bh29P67iQy2zElMt1L1vRUJUHakl/zw2A/2rZ3+qFetIKr56g 1UMutyRYUks4WCjFDamfcphpZxDVl3QX8eeF+alLhFBCDxZ/XpifukQLSmi04c8L81NKRKqC hvVLW/B5t6LKwCrWz3vjb75R5T4d6ApmgC9syvbGtmqg53JcLpcb9Actb5xfqWFXlYdtBy1/ 9JJdPF/wmZv+k+zs88zAZ9B/+jtl/7tWXdh/PsBz1/l/MPvf1cX8P8TzmfOv7X/namOG/K+6 8qyW1v+uLfQ/D/HMsP+9CobVDTT6HMYSyRNf1Yx55Nkw6DUvqmwgeSO2t+tPn339DZuB3pLN 7NOvV6qr68++wbqrG+i0aqD5xprr38wy1vzdOzSfdecMe975elnD7lVrtdXVtbX19QdDzsxm 50PBH71yF8+XeO5B/7+g/W/q/r++Xlvc/x/i+e//5//r/3vl0f/r/+La+f33//H/uPu/Ptv6 Vb9z6Ml/WDLxR/d88XyJ5x77/8vZ/2bu/4X9/0M8yf2P9n//36v/58vF/v/3eO66/38H+4/a Wlr+v7q++nSx/x/g+Rew/8D12aAY/nOYfTiFtbWHeXUvIw8DZR7bjoQhx8KI40GMOP4oAw53 afyedht2bbtGGSgUUN5TV3nnSDfWFCgq8O0A6lqc4hUZV+Rt5UYbeLCAZUKpWyxlZS5OqdVU vyx7kZ/XRmNyt2uZHaqJXYqRgMxjRvEva8Jw1/Nff7qLC8As/n8tHf8B5mUh/32I5w+14df2 +57tPh/tCsmWY7SfaaWPBPDmufPjVhu+G7qV058ckvAJgbPlkm1sFc3jDQX9t7GKv+v+/13s f6op/3/8a7H/H+CZw/7n84x/7EHxD2X8849itjPFaOduFjvDLtcyI3Hqmb47EExvbSdN//5d iN7iMc9d6f+dFD/yfIb8d622uqD/D/Es9D//3s/n7P+5FT/yfN7+X+h/HuJZ6H8Wz+JZPItn 8SyexbN4Fs/iWTyLZ/EsnsWzeBbP4lk8i2fxLJ7Fs3gWz+JZPItn8SyexbN4Fs/iWTyLZ/Es nsWzeP65nv8/rVLMmgDoFwA= --------------070900010608010204080109 Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Disposition: inline _______________________________________________ Xen-devel mailing list Xen-devel@lists.xen.org http://lists.xen.org/xen-devel --------------070900010608010204080109-- From xen-devel-bounces@lists.xen.org Wed Mar 05 06:36:38 2014 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Wed, 05 Mar 2014 06:36:38 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WL5R8-0000a9-83; Wed, 05 Mar 2014 06:36:14 +0000 Received: from mail6.bemta5.messagelabs.com ([195.245.231.135]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WKy9o-0006HE-0P for xen-devel@lists.xen.org; Tue, 04 Mar 2014 22:49:53 +0000 Received: from [85.158.139.211:25466] by server-15.bemta-5.messagelabs.com id 5E/19-24395-F8856135; Tue, 04 Mar 2014 22:49:51 +0000 X-Env-Sender: xisisu@gmail.com X-Msg-Ref: server-15.tower-206.messagelabs.com!1393973389!7676359!1 X-Originating-IP: [74.125.82.43] X-SpamReason: No, hits=1.2 required=7.0 tests=HTML_10_20,HTML_MESSAGE, ML_RADAR_SPEW_LINKS_14,RCVD_BY_IP,spamassassin: X-StarScan-Received: X-StarScan-Version: 6.9.16; banners=-,-,- X-VirusChecked: Checked Received: (qmail 20784 invoked from network); 4 Mar 2014 22:49:49 -0000 Received: from mail-wg0-f43.google.com (HELO mail-wg0-f43.google.com) (74.125.82.43) by server-15.tower-206.messagelabs.com with RC4-SHA encrypted SMTP; 4 Mar 2014 22:49:49 -0000 Received: by mail-wg0-f43.google.com with SMTP id x13so246903wgg.2 for ; Tue, 04 Mar 2014 14:49:49 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20120113; h=mime-version:from:date:message-id:subject:to:cc:content-type; bh=nFkF+lJYOvVMlLkJqP5IyAwx5E/I0QgIYdVJvNtDOWY=; b=roheP21X2YVP7jgauEDITzkCzK7ZeCQSZRx5zRaz/bSW/aYvMM7v522tnbaX71/lPU MV7ikOCBMZrZd2ZcYyecBF68phkqQmsMgCiBf2cvTe2Fetdsnb5iBuFlAXDYoA6E/jk3 aRuRE0GkBTlPrK/eZMjakknTqt7divS9Zxl7IAmdBXJ9ANe++Pw1CVXNQ8/R9EUhml58 XbEMVgSwmglN3nZN3TaNcPiuBzRfWKGLyQsQ6cnVS3zH6IX/WzQR5zEVyl+aLujMCJAK gJ0lEl2ngLGwgHctx0BBWJ4rA373ULKfSQwKOVnF79nggJPdQuVWVlh/Qp85HBhNFOyb FmQA== X-Received: by 10.194.109.68 with SMTP id hq4mr3397086wjb.12.1393973389271; Tue, 04 Mar 2014 14:49:49 -0800 (PST) MIME-Version: 1.0 Received: by 10.227.137.6 with HTTP; Tue, 4 Mar 2014 14:49:08 -0800 (PST) From: Sisu Xi Date: Tue, 4 Mar 2014 16:49:08 -0600 Message-ID: To: xen-devel Content-Type: multipart/mixed; boundary=089e0102e6dab1cc7204f3cfb87e X-Mailman-Approved-At: Wed, 05 Mar 2014 06:36:12 +0000 Cc: Meng Xu Subject: [Xen-devel] memory performance 20% degradation in DomU -- Sisu X-BeenThere: xen-devel@lists.xen.org X-Mailman-Version: 2.1.13 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Sender: xen-devel-bounces@lists.xen.org Errors-To: xen-devel-bounces@lists.xen.org --089e0102e6dab1cc7204f3cfb87e Content-Type: multipart/alternative; boundary=089e0102e6dab1cc6d04f3cfb87c --089e0102e6dab1cc6d04f3cfb87c Content-Type: text/plain; charset=UTF-8 Hi, all: I am trying to study the cache/memory performance under Xen, and has encountered some problems. My machine is has an Intel Core i7 X980 processor with 6 physical cores. I disabled hyper-threading, frequency scaling, so it should be running at constant speed. Dom0 was boot with 1 VCPU pinned to 1 core, with 2 GB of memory. After that, I boot up DomU with 1 VCPU pinned to a separate core, with 1 GB of memory. The credit scheduler is used, and no cap is set for them. So DomU should be able to access all resources. Each physical core has a 32KB dedicated L1 cache, 256KB dedicated L2 cache. And all cores share a 12MB L3 cache. I created a simple program to create an array of specified size. Load them once, and then randomly access every cache line once. (1 cache line is 64B on my machine). rdtsc is used to record the duration for the random access. I tried different data sizes, with 1000 repeat for each data sizes. Attached is the boxplot for average access time for one cache line. The x axis is the different Data Size, the y axis is the CPU cycle. The three vertical lines at 32KB, 256KB, and 12MB represents the size difference in L1, L2, and L3 cache on my machine. *The black box are the results I got when I run it in non-virtualized, while the blue box are the results I got in DomU.* For some reason, the results in DomU varies much more than the results in non-virtualized environment. I also repeated the same experiments in DomU with Run Level 1, the results are the same. Can anyone give some suggestions about what might be the reason for this? Thanks very much! Sisu -- Sisu Xi, PhD Candidate http://www.cse.wustl.edu/~xis/ Department of Computer Science and Engineering Campus Box 1045 Washington University in St. Louis One Brookings Drive St. Louis, MO 63130 --089e0102e6dab1cc6d04f3cfb87c Content-Type: text/html; charset=UTF-8 Content-Transfer-Encoding: quoted-printable
Hi, all:

I am trying to study the cache= /memory performance under Xen, and has encountered some problems.

My machine is has an Intel Core i7 X980 processor with 6 ph= ysical cores. I disabled hyper-threading, frequency scaling, so it should b= e running at constant speed.
Dom0 was boot with 1 VCPU pinned to 1 core, with 2 GB of memory.
=

After that, I boot up DomU with 1 VCPU pinned to a sepa= rate core, with 1 GB of memory. The credit scheduler is used, and no cap is= set for them. So DomU should be able to access all resources.

Each physical core has a 32KB dedicated L1 cache, 256KB= dedicated L2 cache. And all cores share a 12MB L3 cache.

I created a simple program to create an array of specified size. Lo= ad them once, and then randomly access every cache line once. (1 cache line= is 64B on my machine).
rdtsc is used to record the duration for the random access.
=
I tried different data sizes, with 1000 repeat for each data= sizes. Attached is the boxplot for average access time for one cache line.=

The x axis is the different Data Size, the y axis is th= e CPU cycle. The three vertical lines at 32KB, 256KB, and 12MB represents t= he size difference in L1, L2, and L3 cache on my machine.
The = black box are the results I got when I run it in non-virtualized, while the= blue box are the results I got in DomU.

For some reason, the results in DomU varies much more t= han the results in non-virtualized environment.
I also repeated t= he same experiments in DomU with Run Level 1, the results are the same.

Can anyone give some suggestions about what might be th= e reason for this?

Thanks very much!
Sisu

--
Sisu Xi, PhD Candidate

http://www= .cse.wustl.edu/~xis/
Department of Computer Science and Engineering<= br>Campus Box 1045
Washington University in St. Louis
One Brookings Drive
St. Louis, MO 63130
--089e0102e6dab1cc6d04f3cfb87c-- --089e0102e6dab1cc7204f3cfb87e Content-Type: image/jpeg; name="cache_latency_size_boxplot.jpg" Content-Disposition: attachment; filename="cache_latency_size_boxplot.jpg" Content-Transfer-Encoding: base64 X-Attachment-Id: f_hsdrq0we0 /9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0a HBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIy MjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAOqB1MDASIA AhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQA AAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3 ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWm p6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEA AwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSEx BhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElK U1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3 uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD3+iii gAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKA CiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK KKKACiiigAooooAKKKKACiiigAooooAKKK+dPiT8XvFFt411Kx8KXskGn6WgiuWW2SUGQNtd23xk qA7CPrgkAg/NQB9F0Vj+FfENv4r8L6drlquyO7iDlMk+W4OHTJAztYMM45xkcVsUAFFFFABRRRQA UUUUAFFFFABRRXn/AMU/iV/wrzTrPyNP+2X1/wCaIN77Y49gGWbHLcuvyjGRn5hxkA9AorL8NalN rPhXSNUuFjWe9sobiRYwQoZ0DEDJJxk+pry/4s6/8SNK8VWsHg+HUn09rJHkNrpouF83e4OWKNg7 QvGfT1oA9kooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoo ooAKKKKACiiigAooooAKKK8b1/X/AIkQfGWLTtOh1I+Fze2iM6aaHi8phH5v73YTjJfJ3cc9MUAe yUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAB RRRQAUUUUAFFFeP/AB08beIvB39g/wBgah9j+1faPO/cxybtvl7fvqcY3N09aAPYKKx/Cd9can4N 0O/vJPMurrT7eaZ9oG52jUscDgZJPStigAooooAKKKKACiiigAorH8WX1xpng3XL+zk8u6tdPuJo X2g7XWNipweDggda83+BfjbxF4x/t7+39Q+2fZfs/k/uY49u7zN33FGc7V6+lAHsFFeX/GDWfHOk f2N/whcV9J5vn/a/slgLnGPL2Zyjber+mefSu88NTX1z4V0ifVBINQksoXuhJHsYSlAXyuBtO7PG BigDUooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKK KKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooo oAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiig AooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAC iiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAw/ GOvr4W8HarrTNGHtbdmi8xWZWlPyxqQvOC5UduvUda8U+Efw9i8XeC/Euq6y87XWs77SG4mDkjBW QzZ3DzMyhSc94iM8sKt/tFa5NdXGi+D7O1kmnldb0hYyzOxLRRImDkknzMjH93B6ivYPB2gL4W8H aVoqrGHtbdVl8tmZWlPzSMC3OC5Y9uvQdKAPJ/2eNfuUTWPCGotJHPZP9ogt5lcPGN22ZTnhQrbD t4OXY88490r5o8bo/wAMfjzbeJls86bdy/axtDPuDqUuACxA8zLOwGcDenQHFfS9AHlc3xkax+Jo 8G6j4ckgLXq2i3KXiyEhyPKfZtAwwZCRuyoJ6kYr1SvnD9o/w79m1zTPEMMWI7yI21wUhwBInKsz jqzK2ADziLuBx7n4O19fFPg7StaVoy91bq0vlqyqso+WRQG5wHDDv06nrQBz/wATPiZD8OrfTmbS 5NQnvnkCIJhEqqgXcS2GOcuuBj15GOek8K6zceIfC+naxdaf9gkvYhMLfzhLtRjlDuAGcrtboMZw eRXzh8SZX+IPxyTRLNsxxSxaWksMDMyBWJlZlJGdjNLkjA2pnpzXr/xm1hPC/wAKrq1sk+z/AGzZ ptusMS7I0YHcuDwq+WjqMDjIxjqADk/HP7Qa6ZqkmneFLS0vhA4WS+uGZonPO5UVSCRnHz7sHBwC MMa/hT9o1ZrgW/ivTI4Ed8Ld2AYqgJUfNGxJwPmJYEnoAp61c/Z88F2cOht4tvLTdfzyyRWUrsGC Qj5WZQPusW3qSecLxgE7u8+I/gPTfGfhq+DadHLrEVuxsbhNqS+YoYom8/wFiQQePmJ4OCADD+HH xg/4WB4huNJ/sL7B5No1z5v2vzc4dF242L/fznPavUK+YP2cf+Sh6h/2CpP/AEbFX0/QAV8gfE34 m/8ACxv7L/4lH9n/AGDzf+Xnzd+/Z/sLjGz3619f184ftD6Fo+if8I5/ZOlWNh532nzPslukW/Hl YztAzjJ6+poA6/4NfE3/AISb7J4U/sj7N/ZmlJ/pX2nf5vl+XH9zYMZ3Z6nGMc1ofEf4wf8ACv8A xDb6T/YX2/zrRbnzftflYy7rtxsb+5nOe9dB8OtC0ex8G6BqNnpVjb30+lW/nXMNuiSSbo0ZtzAZ OSATnqa8Q/aO/wCSh6f/ANgqP/0bLQB9H67qf9ieHtT1byfO+w2ktz5W7bv2IW25wcZxjODXlel/ tAWN34a1nWL7RJLQ2Lww28CXPmm5llEhC52AIAIiSTnjOATgH0Tx3/yTzxL/ANgq6/8ARTV86fA3 wNY+LfEt3farFHcWGlojm3c8SyuTs3DGGQBHJGRk7QcgkUAaE/7SHipriVrfStGjgLkxpJHK7Kue AWDgE474GfQV63pnxh8LX3gaXxNcXP2b7PiO4sSwaZZiDtjUcb92DtbgEAk7drbes8Q+HtN8T6NP peqW0c0EqMFZkVmiYqV3puBCuAxwccV8mfCfwdb+NvHMNhfc2FvE11dIHKNIikAKCB3Zlz0+Xdgg 4oA7C+/aR8SSXkjWGjaVBanGyOcSSuvAzlgyg85/hHpz1r0/4X/Fi3+IHnWFzZ/YtXtohK6IS0cy DaGdTj5fmP3TnAIwW5x3k2k6bc6WNLn0+0l08IqC0eFWiCrjaNhGMDAwMcYFfMnwztf7B/aE/siy uJxaw3d7Znc/MsaJJtD4wDyinpjIBxxQB9N6rqtjoel3Gp6ncx21nbpvllfoo/mSTgADkkgDJNeC eIf2kbxrwL4a0aBLVesmpAs8nA/hRgEwd38TZ4PHSpP2k9fY3GjeHI2kCKhvp1KrtYklIyD1yMS5 HA+Yde2v4G8WfCHwLpccFjrUc1+UIuNQfTpxLMTgkZ8vKplRhAcDAzk5JAMTw9+0jeLeFfEujQPa t0k00FXj4P8AC7EPk7f4lxyeele96Vqtjrml2+p6Zcx3NncJvilTow/mCDkEHkEEHBFeR+MvGHwf 8a6dLFqOqQfbvKKW99/Z9x5kLYbachAWUFi2wnaTWJ+zZr7C41nw5I0hRkF9AoVdqkEJISeuTmLA 5Hynp3APoOiiigDh/iJ8TdL+H1nEJY/tupz4MNikmwlM4Ls2DtXggcHJ4A4Yjxyf9pDxU1xK1vpW jRwFyY0kjldlXPALBwCcd8DPoK6/X/ghqXiL4mtr2o6xaXWk3NwJrmNo2jlEanCwqF4I2Kib9ynq cZHPrEk+g+E9LhSWXTdG09X2RKzJbxBjlsL0GT8xwPc0AeN+Df2h/t2oxWHijToLfz5QiXlo2yOP cVA8xZG4UZYl93Ax8veveK+WPjpfeDr/AFyxl8MyWMt9+9Ooy2S/JIW2MjFh8jsS0mWBJ7MeAB7P d+J7jQfgRb+IJJ53vholuUnOJH8+SNFV23fe+dwTnPfg9KAMf4gfHHS/Cl5c6RpNt/aerQ5SRi2I IHweGI5ZlO3KjHUjcCCK88g/aQ8VLcRNcaVo0kAcGRI45UZlzyAxcgHHfBx6GrHwC8B6br76jr2t adHeW9s629qk+14mkKkyFkPUqpTGePmPUgFfoPWdD0vxDpz2Gr2EF7atk7JkztJBG5T1VsE4YYIz waAMfwL460vx5oYv7A+VcR4W6tHbL27nsfVTg4bvjsQQJPGfjnRfAulpfaxLITK+yG3gAaWY8Z2g kDABySSAOB1IB8/+Gnwd1rwN4xm1efXLR7QI8CxQwlmuYmz9/djyyGWNvlLdCM46+eeMfN+JHx+/ sdfPa1ju10/aNkbxwxEmcqehwRM4JyTkDHRaANC+/aR8SSXkjWGjaVBanGyOcSSuvAzlgyg85/hH pz1rt/hv8cbfxVqMWja/bQafqUvEE0TEQzuScJhslGxtAyTuOeQSFPqGjaHpfh7TksNIsILK1XB2 QpjcQANzHqzYAyxyTjk15H49+A6+IPEtrf8Ahx9N0mzkRUvIBEyhSDjzI0UbSSv8PyDK5zliQAe0 Tzw2tvLcXEscMESF5JJGCqigZJJPAAHOa8H8V/tGrDcG38KaZHOiPhru/DBXALD5Y1IOD8pDEg9Q VHWtD4+a1d6R8PtI8PT3klzeag6i6uRCiLOsIUuSP4CZGjYBfQjOODkfDDXvhV4M0a1u7vVo5vEE qCWe4lsJma3YqQY4yEIUAMVJB+bk5xgAAp6N+0jrCain9uaNYy2JwG+wh45E5GWG9mDYGfl+XJx8 wr3fwx4n0vxdocOr6RP5tvJwytw8TjqjjswyPzBBIIJ8/wDEPxD+D/iuzFrrl9Bexr9wvY3AePJB O1wgZc7RnBGcYPFeefAnWodF+Jt/oNteSXen6ikkUEywhBK0RZ45GDfMgKCTjnlhkcZAB7n468da X4D0M39+fNuJMra2iNh7hx2HooyMt2z3JAPhk/7SHipriVrfStGjgLkxpJHK7KueAWDgE474GfQV Y/aThvl8VaNPIZP7PeyKQAyZXzVcmTC54O1osnHPHXHHofgf4q/D06Hpel2t1BobLFtFjOGVICMl gZiNhyQTuLZbPPzHFAFP4ffHKx8WapDo+sWcemX8qKsMom3RXEvdRkAoSfugls9M5xu9YnnhtbeW 4uJY4YIkLySSMFVFAySSeAAOc15XqvwU8P6/4osvEekal/ZVgYo5BFpCKm9wCUmikBKp/AflXnbn q2a6T4tQ30/wr8QJpxkE4tw7bJNh8pXVpecjjyw+R3GRznFAHmHij9o25j1R4PC+mWklnE7L9pvg 7GccYZUUqUGd3UkkEcKciq+iftJ6klxt17Q7SaBnQb7BmiaNc/Mdrlg5xjAyvTrzxl/BHxz4R8If 2kmuxfZL6bBj1Ly3l3R8fucKCV5G7IGG742rn1vxJoHhD4v+H5Bpuo6bLfqkLR6hCqyz2yklgrqG VgCC42NjBJOMigDuNK1Wx1zS7fU9MuY7mzuE3xSp0YfzBByCDyCCDgivO9Z+MH9kfFCPwX/YXm77 u2tvtn2vbjzgh3bNh6b+m7nHaus8DeEIfA/hqPRoNQu71FcyF7hhhWIG4Io+4hYFtuTyx5Oa8E8Z f8nQ23/YV03/ANBhoA9/8beJ/wDhDvCF9r/2P7Z9l8v9x5vl7t0ip97Bxjdnp2rzdP2h9LHhJtUl 0nbqbXZgh0xLvcWQKjGVn2DYvzED5Tkjj+Ir1Hxt/wCSQ67/ANu//pRHXmn7Pngax1N7rxXqMUc5 srgQWUbHISUKGaQrjBIDJtOeDuOMhSADPg/aQ8VLcRNcaVo0kAcGRI45UZlzyAxcgHHfBx6Gvb/A Pj7TfiBo0l7ZRSW89u6x3NtK6lkYqDkYOShOQGIGdp4GK1PE/hjS/F2hzaRq8Hm28nKsvDxOOjoe zDJ/MgggkH58/ZvnmXx1qdussggfTGd4wx2syyxhSR0JAZgD23H1oA+g/E/ifS/COhzavq8/lW8f CqvLyueiIO7HB/IkkAEjwC+/aR8SSXkjWGjaVBanGyOcSSuvAzlgyg85/hHpz1qP47ald+JfibYe GLFZJHs0jt4oWCKGuJyrZVs9CpiHzEAFT06n6D8MeGNL8I6HDpGkQeVbx8szcvK56u57scD8gAAA AADyd/2kdL/sNbmPQpzqYlCSWb3G1Nh3/OsoU5xtTIKr9/jOCa9Q8E+J/wDhMfCFjr/2P7H9q8z9 x5vmbdsjJ97Aznbnp3rwz4++A9N0B9O17RdOjs7e5dre6SDakSyBQYyqDoWUPnHHyjoSS3qfwS/5 JDoX/bx/6USUAegUUVT1bUodG0a+1S4WRoLK3kuJFjALFUUsQMkDOB6igDh/iB8X9F8CXH9niCTU tW2BzbROFWIEjHmPztJUkgAE8DOAQT5J/wANHeMP+gbof/fib/47VP4Q+F2+IHxBvNZ1yOO7tLVz eXgkRds88hJVSoI4Lbn6Ffk2kYavqP7BZ/2d/Z32SD7D5XkfZvLHl+Xjbs29NuOMdMUAcH8P/i/o vju4/s8wSabq2wuLaVwyygE58t+NxCgEggHk4yASOk8beJ/+EO8IX2v/AGP7Z9l8v9x5vl7t0ip9 7Bxjdnp2r50+L3hdvh/8QbPWdDjjtLS6cXlmI0XbBPGQWUKSeA21+gX59oGFr1/4r6lDrPwIv9Ut 1kWC9t7S4jWQAMFeaJgDgkZwfU0AYaftD6WPCTapLpO3U2uzBDpiXe4sgVGMrPsGxfmIHynJHH8R XjIP2kPFS3ETXGlaNJAHBkSOOVGZc8gMXIBx3wcehrQ/Z88DWOpvdeK9RijnNlcCCyjY5CShQzSF cYJAZNpzwdxxkKR7n4n8MaX4u0ObSNXg823k5Vl4eJx0dD2YZP5kEEEggGX4B8fab8QNGkvbKKS3 nt3WO5tpXUsjFQcjByUJyAxAztPAxWp4n8T6X4R0ObV9Xn8q3j4VV5eVz0RB3Y4P5EkgAkfPn7N8 8y+OtTt1lkED6YzvGGO1mWWMKSOhIDMAe24+tHx21qHWvibYaDc3klpp+nJHFPM0IcRNKVeSRQvz OAhj445U4HOSAXNZ/aR1h9Rf+w9GsYrEZC/bg8kj8nDHYyhcjHy/Ng5+Y1p+FP2jVmuBb+K9MjgR 3wt3YBiqAlR80bEnA+YlgSegCnrXQeF/H/wh8HaWlho+qRwgIqyzmxnMs5GTukfy8scs3sM4AA4r m/iX4i+E/jDQ7+5ttQgXxCsRe2uksZ1eRxtwjHaobcECAvnbnIoA98gnhureK4t5Y5oJUDxyRsGV 1IyCCOCCOc1JXjf7OuvtqHg6+0WVpGfS7gNHlVCrFLlgoI5J3rKTn+8Oew9koAK87+IHxf0XwJcf 2eIJNS1bYHNtE4VYgSMeY/O0lSSAATwM4BBPcatqUOjaNfapcLI0FlbyXEixgFiqKWIGSBnA9RXz J8HfDCeP/H2o6x4gg+229tm7uN21UluZHyodB1U4kbAGPlAPBwQCx/w0d4w/6Buh/wDfib/47Xs/ w7+Jul/EGzlEUf2LU4MmaxeTeQmcB1bA3LyAeBg8EcqT1k2k6bc6WNLn0+0l08IqC0eFWiCrjaNh GMDAwMcYFeP6B8ENS8O/E1de07WLS10m2uDNbRrG0kpjY4aFg3AGxnTfuY9DjJ4APVPE/ifS/COh zavq8/lW8fCqvLyueiIO7HB/IkkAEjwTUv2k9eluFbS9D022g2AMl0zzsWyeQylABjHGOx5547/4 ufDHWvH9xp9xpurWkSWaFFtLqMqoLEl5BIoJJO2MbSMfKTkdD2HhfwvovgLw0lvbx2luILdTe3xQ RmYoCWkkYknGSxwSQoOBwKAPFNG/aR1hNRT+3NGsZbE4DfYQ8cicjLDezBsDPy/Lk4+YV7/oes2f iHQ7LV7B99rdxLKmSCVz1VsEgMDkEZ4IIrx/42654C1fwhKYb/Sr7Xz5YsprRxLIoWQblLpnC7Xc 7WOCckAkcan7Os803w5ukllkdIdTlSJWYkIvlxthfQbmY4Hck96AOo8ffEzRfAFvGt4JLrUJ0ZoL KEjcQAcM5P3ELDGeT1wDg48Yn/aQ8VNcStb6Vo0cBcmNJI5XZVzwCwcAnHfAz6Csvw7Yp8W/jbdX N9HPNpk0st1MpZYnW2QbYlbH/bJDtyeSc/xV9Rw6TpttpZ0uDT7SLTyjIbRIVWIq2dw2AYwcnIxz k0Aef/DP4v2Pjpzpl9BHp+tIgZYg+UuQF+Zo88gg5Ow5IHILYbHF/tNf8yt/29/+0a0NY+BF4/xF TW/Dup2OkaaJUuo1WEu9tMvPyRn5WXeAcFlA3EBcKAc/9pr/AJlb/t7/APaNABe/HG38K+DfD2ja BbQahqUWlWonmlYmGBxGmUwuC7Y3A4I2nHJIKiho37SOsJqKf25o1jLYnAb7CHjkTkZYb2YNgZ+X 5cnHzCu/+Dfw/wBL0DwlputzWsE+s38S3X2phvMKOp2LGSBs+Rvmx1JIyQBiv8e/DGl6h4EufEEs G3U9N8sQzpwWR5VUo395fnJHoeh5YEA9M0rVbHXNLt9T0y5jubO4TfFKnRh/MEHIIPIIIOCK5fx9 8TNF8AW8a3gkutQnRmgsoSNxABwzk/cQsMZ5PXAODjl/2dZ5pvhzdJLLI6Q6nKkSsxIRfLjbC+g3 MxwO5J7145Bq3hrxl8VdR1vxhqU9ro0srzIpgYvKikLFC3lA7fkAywz90jOTuoA6Sf8AaQ8VNcSt b6Vo0cBcmNJI5XZVzwCwcAnHfAz6CvQ/h/8AHHS/Fd5baRq1t/ZmrTYSNg2YJ3wOFJ5VmO7CnPQD cSQK0LH4vfDDTLOOzsNWgtLWPOyGDTpo0XJJOFEeBkkn8a8Y+LE/w41KK11DwXPBFfGUpdWsFpLC joVGHAYBF2lcYUfNvyelAH1fRXN+ANfbxR4D0bWJWkaee3Czu6qpeVCUkbC8AFlYjGOCOB0rpKAO f8d/8k88S/8AYKuv/RTV4/8Asy/8zT/26f8AtavYPHf/ACTzxL/2Crr/ANFNXj/7Mv8AzNP/AG6f +1qAPQPib8Tf+Fc/2X/xKP7Q+3+b/wAvPlbNmz/YbOd/t0rsNC1P+2/D2mat5Pk/brSK58rdu2b0 Dbc4GcZxnArw/wDaa/5lb/t7/wDaNeweBP8Aknnhr/sFWv8A6KWgDzfw/wDtD6XqUt8dX0n+y7e1 tGnV1u/OedwyqIkTYuWO4nrxgk4AJHIX37SPiSS8kaw0bSoLU42RziSV14GcsGUHnP8ACPTnrXH/ AAn8HW/jbxzDYX3NhbxNdXSByjSIpACggd2Zc9Pl3YIOK+v/ALBZ/wBnf2d9kg+w+V5H2byx5fl4 27NvTbjjHTFAHm/w1+Mdn45vF0i9svsGriIuNsgMM+0Lu2ZO4McsdmGwqk7jXpk88Nrby3FxLHDB EheSSRgqooGSSTwABzmvlS60e38H/tE2Ol6K88FrFqtoIx5pLKkvllk3dSuHZec5Xgk859L/AGit fbT/AAdY6LE0ivqlwWkwqlWiiwxUk8g72iIx/dPPYgGP4r/aNWG4Nv4U0yOdEfDXd+GCuAWHyxqQ cH5SGJB6gqOtZmjftI6wmop/bmjWMticBvsIeORORlhvZg2Bn5flycfMKufDDXvhV4M0a1u7vVo5 vEEqCWe4lsJma3YqQY4yEIUAMVJB+bk5xgDq/EPxD+D/AIrsxa65fQXsa/cL2NwHjyQTtcIGXO0Z wRnGDxQB6B4Y8T6X4u0OHV9In823k4ZW4eJx1Rx2YZH5ggkEE7FfMnwJ1qHRfibf6DbXkl3p+opJ FBMsIQStEWeORg3zICgk455YZHGR9N0AFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAU UUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRR RQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFF ABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUA FFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAV HPPDa28txcSxwwRIXkkkYKqKBkkk8AAc5qSvN/jd4nTw/wDDq7tY5/LvtV/0SFRtJKH/AFpIP8Oz KkgHBdemcgA8Mh0LWvjN8Qdev9LeNEZ2nE16pjVIshIo2MasA+wDjvsY5OCa3P8AhnHxh/0EtD/7 /wA3/wAar0P9nrQF03wHLrDLH5+q3DMHVmJ8qMlFVgeAQ3mnjswyew9coA+TPEfwN8VeGvD95rNx cabcwWiB5I7R5Xk25AJAMYGADuJzwAT2r2v4I+J08QfDq0tZJ/MvtK/0SZTtBCD/AFRAH8OzCgkD JRuuMn0C/sbfU9OubC8j8y1uonhmTcRuRgQwyORkE9K+bPgvqreDPilqXhfUrmNUunexYpt8trmJ yEO5sHB/eKAOSXUY9AD1f426A2vfDK+aJZGn051vkVWVQQgIctnqBGznAwcgdeh4/wCA/iuGx+HP iFLs3cqaI73rKMMBC0ZbZHk9d0chxwMtnPJx7hPBDdW8tvcRRzQSoUkjkUMrqRggg8EEcYr4k1e2 vPB2teIvDzLv3ZsZJJoijNGsySLIq543eWhHUbW9waAPRPgTpt34l+Jt/wCJ75pJHs0kuJZlKKGu Jyy4ZcdCplPygAFR06Hv/wBoqCab4c2rxRSOkOpxPKyqSEXy5Fy3oNzKMnuQO9WPgBokOnfDdNRX y2n1S4kldhGFZVRjGqFurAFGYdMbzx3PeeKvD1v4r8L6jod02yO7iKB8E+W4OUfAIztYKcZ5xg8U Acf8Cr63u/hRpsMEm+S0lnhnG0jY5kaQDnr8rqePX1zXoF/fW+madc395J5draxPNM+0naigljgc nAB6V8saD4n8U/A/xReaPqNn9ptH+eSzMpWObjCzRPg4zjBOOQCrAMo26mv/ABW8X/E5G8N+GtEk tYrlAtxHbO00rqW2ndJhQkR3KDkD3bBIoAj/AGcf+Sh6h/2CpP8A0bFX0/XzB+zj/wAlD1D/ALBU n/o2Kvp+gAr5/wD2mv8AmVv+3v8A9o19AV4X+0npV9daXoWpwW0klnZPOlzKvIiMnl7N3cAlSM9M 4HUjIB6p4E/5J54a/wCwVa/+ilrwD9o7/koen/8AYKj/APRstdn8HPiyusvpXg2+0+O3nt7Lybe5 SRiJzEowuzb8p8tSSS2CVOAMgVxn7R3/ACUPT/8AsFR/+jZaAPf/AB3/AMk88S/9gq6/9FNXj/7M v/M0/wDbp/7Wr2Dx3/yTzxL/ANgq6/8ARTV4/wDsy/8AM0/9un/tagD6Ar5g/Zx/5KHqH/YKk/8A RsVfT9fMH7OP/JQ9Q/7BUn/o2KgD6fr5g8G/8nQ3P/YV1L/0Gavp+vmDwb/ydDc/9hXUv/QZqAJP 2kIJl8daZcNFIIH0xUSQqdrMsshYA9CQGUkdtw9a7Ow/Z+8D6np1tf2era5Ja3USTQv5sQ3IwBU4 MWRkEda6T4v/AA/m8d+GoTp/l/2tp7tLbB2IEqsPnjznALYUgnuoGQCSPGPBnxY8R/DVH8P6vpMl xaW6YisbgfZZbZmYvnOwkht5OGB6rggcEA9L/wCGcfB//QS1z/v/AA//ABqtz4efDXwr4WvW8QeH NWu9QS5t3txI1xFLEy71JKlFGSGTHX1ryDxn8bNa8caWmgaPpUmnC7fyplgnM8tyGwBEuFUgEnBA BLcDpkH0v4HfD+48KaHcatq9r5GrajgLG4G+CAchTxlWY5LLnsmQCCKAPWKKKKAPmDxF4w8WfFnx zJoPha5nh0r95DGkErxRyQZw005wCVIx8pHAIUAsTu0NM/Zr1iXzf7W8QWNrjHl/ZIXuN3XOd2zH bpnOT0xzx6t4p+Cnjm4mhtv+ettFNd258m9hyp3DB/65thWypwD3B7i+/aXvJLORbDwxBBdHGySe 8MqLyM5UIpPGf4h689KAOL+KPw8034epotpb6rJf6hcpM91uCoFUMojKxjJUHLDJJyVOMYIr1/xZ BNc/sxW6QRSSuNHsHKopYhVMLMeOwUEk9gCa8M8df8JTq32Dxd4m+X+2fM+xRHK7IY9pG1P4Y/3n y85PLHO7c31H4Nhsdc+FGiWcpjubO40eK1nVJOGHlBJEypyCDuU4OQQehFAHB/s3X1vJ4N1awWTN 1DqHnSJtPyo8aBTnpyY3/L3Fe0V8oTW3jX4FeKLie1Xz9PmxGJ3iY2l2pDFNwBG2QYY7c7hg4JU5 bqL79pe8ks5FsPDEEF0cbJJ7wyovIzlQik8Z/iHrz0oA9nbxx4aj8USeGpdXgh1ePYDbzBo9xYKV VWYBWY71woJPPTg18+aBMujftOyvqIktg+sXaLvjbJMwkWLjGcMZEwemGB6c1sfBvwLq+ueMZPG/ iSzkWAO11A1xEE+03EnzCRUK4KAMWDDA3bducHGn8avhvrFxrkXjPwzDPNdDyxcw2m8zrIuAkyYO TgBAQoBXaG5yxAB7xWP4k8U6N4R06O/1y8+yWskohV/KeTLkEgYQE9FP5V4Ro37SOqWmnJDq+hQa hdJgfaIbj7PvAAGWXaw3E5JIwOeAMVzer6t4v+OXiW0t7XTI0t7V2SJYkbyrVZDndNLg87UA7Z2f KuTggHYftFzw6rpfhbVNOljvNPL3Sfa7dhJFuPl4G9cjPyPxn+FvQ1P4O+CHg3xT4O0rWl1TWS91 bq0vlyRqqyj5ZFAaLOA4Yd+nU9a9A8VfDOx1n4ZReEdOMdubJEaxllGAJUB+Z9mAS4Lhjg8uWwSK 8I8K+N/Ffwe1SXR9T0uT7GzvLLp9woiLucJ5qS7SSMxgZG5SAcc8gA9T/wCGcfB//QS1z/v/AA// ABqtDwZ8I/B+geI49c0TWL69utOllgdGuYZESQoUZHCoCGAfpkEcV5x4n/aH1TWNDmsNI0n+yLib 5Wu1u/NdE7hPkXax4+bnHOMHBHR/Aj4cX2j3Fz4m17T5LW4KGCxguE2yICcPIUYZQnAVTkEgvxgg kA9U8V2XhbWLO30XxQ9i0d5KPs0FzOInkkBAHlnIbd8wHy8/NjocHxzX/wBmyYO0nhzXI2QuAINR UqVXbyfMQHcd3QbBwevHJ8d/BOpW/iC28Z6Fb3bEoDeSWoYtbyRDKzEg5UbVAyAAvlgk5aqejftI 6paackOr6FBqF0mB9ohuPs+8AAZZdrDcTkkjA54AxQBxckPjf4M+JYXYyWhkfeu2Qva3yISvzAHD DDHg4ZQ4Pykg19Z2Gs2d94ettc3/AGexntEvN9wQnlxsgfLnOBgHnnA9a+XNX1bxf8cvEtpb2umR pb2rskSxI3lWqyHO6aXB52oB2zs+VcnB938b/D+HXPhaPDNl5kk+nW8Z05pGG5pIk2qDyq5Zcrk8 DfnHAoA5fXfgd4Q8XImreF9Tj09J3LF7Tbc2snzNu2qGG07uPlbaAuNteWeIfg7418F2Y1pDBcx2 n7959NnYvbbSCHwQrcdcrnG0k4AzUngz4oeJvhi76HqGnST2cb720+9DQywFlJ+QkZQEsrEFSD1G CxJ2PFHx31rxbpb6Do+hR2Z1BGtZcSG5llD4XZGNqgEgsvRid3GCM0Aej/A3xzfeLfDV3Y6rLJcX +luiG4ccyxODs3HOWcFHBOBkbSckk15p4y/5Ohtv+wrpv/oMNel/A3wNfeEvDV3farFJb3+qOjm3 c8xRIDs3DGVcl3JGTgbQcEEV5p4y/wCTobb/ALCum/8AoMNAHr/xt/5JDrv/AG7/APpRHXP/ALOP /JPNQ/7Csn/oqKug+Nv/ACSHXf8At3/9KI65/wDZx/5J5qH/AGFZP/RUVAHsFfMH7OP/ACUPUP8A sFSf+jYq+n6+YP2cf+Sh6h/2CpP/AEbFQBH8RZl0b9o2LU9QElvZpe2F0ZWjbBiRYtzrgZYAow4z ypHUV9R14/8AHH4b3niqzt9f0aHztSsIjHNbrkvPDncNgzjcpLHaBltx5JCg8R4Y/aH1TR9DhsNX 0n+17iH5Vu2u/Kd07B/kbcw5+bjPGcnJIB1/7SN9bx+DdJsGkxdTah50abT8yJG4Y56cGRPz9jXU fBL/AJJDoX/bx/6USV86eNdc8X+NreHxTrlrJHpauttamONo7dWIbIjDEliTG25snBABI+UV9F/B L/kkOhf9vH/pRJQB6BWH40gmuvAviG3t4pJp5dMuUjjjUszsYmAAA5JJ4xW5RQB88fs0X1vHqPiK waTF1NFBNGm0/MiFwxz04Mifn7GvoevljxZ4P8QfCPxyviXQrbzNKilaa1nETSRwIx2mGXJJHD7A xPzAgghsheg/4aXvP7O2f8IxB9u8rHnfbD5fmY+9s2Z25527s443d6AD9pe+t5NR8O2CyZuoYp5p E2n5UcoFOenJjf8AL3FdX45gmtf2Zo7e4ikhni0zT0kjkUqyMHhBBB5BB4xXmnhPwf4g+LnjlvEu u23l6VLKs11OYmjjnRTtEMWCCeE2FgflAJJLYDez/G3/AJJDrv8A27/+lEdAHP8A7OP/ACTzUP8A sKyf+ioq9grx/wDZx/5J5qH/AGFZP/RUVewUAfMH7OP/ACUPUP8AsFSf+jYqz/i3Z2//AAvS5Gsm e10y5ltDLOqHPkeXGrunBzja44B5UjBxitD9nH/koeof9gqT/wBGxV3/AMcfhveeKrO31/RofO1K wiMc1uuS88Odw2DONyksdoGW3HkkKCAH/DOPg/8A6CWuf9/4f/jVRz/s8eCbW3luLjV9ZhgiQvJJ JcwqqKBkkkx4AA5zXCeE/jnrvg/Tm0PWtI/tD7Htt4EdxayWyoNhjYBDnG0dQGBzknjGf43+KXiD 4n/ZtC0rSp7a1f5nsLRmuJLl1y2SQoJVQM7QOoJOcDaAe9/D74f6D4Jt7u40G+u7yDU0ifzJpkkV lUMVKFFAIIcnPOeK7SuD+E3gZvA/g5ILyKNdWvH8+8KlW2nose4DkKvbJG5nwSDXeUAYfjSCa68C +Ibe3ikmnl0y5SOONSzOxiYAADkknjFeKfs0X1vHqPiKwaTF1NFBNGm0/MiFwxz04Mifn7Gvoevl zxR4X8TfB3xq/iLw7HIdHLs8UsaM8SRMw/0efknGSoBJ+b5SCGHygH1HXP6t448NaDrkGjatq8Fl fTxedGs4ZE2fMMmQjYvKMOSP1FeMf8NL3n9nbP8AhGIPt3lY877YfL8zH3tmzO3PO3dnHG7vWP4F 8L678UviKPFviGx/4lRlFzPK0QSGfZ8qRRhgQ6goFbr8qnLbiMgHT/Gr4kaxb65F4M8MzTw3R8s3 M1pvE7SNgpCmBkZBQkqSW3BeMMDgWP7PPizVLyO71vWLG3+05luXLvcTq7Ak7hgKzbjgnf6nJ7nx s8O67oPxF/4TPT4p3tX8i5W7SEMlrNHsQK3UdVQgsADuwM4NaFj+0veR2ca3/hiCe6Gd8kF4Ykbk 4wpRiOMfxH146UAZfjX4Lab4G8EajrN34hku7xXhSzjESwKzM4DAgsxc7csACMbSeR07v9nH/knm of8AYVk/9FRV5R4p8SeNfib4cu9cv44LfQtF2b0gVo4Xmd1QYBLF5MOO+FX0LfN6n+zfPC3gXU7d ZYzOmps7xhhuVWijCkjqASrAHvtPpQBwHwAmXSvilc2F+JLe7msprVIZI2Dearo7IRj5SFjfrjpj rxX1HXzh8U/AviDwl40k8ceFhP8AZ5ZWune1Vne0lwTIzg5zG3zsSfl5KkAY3WLH9pe8js41v/DE E90M75ILwxI3JxhSjEcY/iPrx0oA9r1/xhoHha4sINb1KOye/cpbmRG2sQVBywBCgbl5Ygc+xrxj 9pOeG6t/CVxbyxzQSpdPHJGwZXUiEggjggjnNcnYWHin44+ObbUdRtPL09NkFxc28ZihghQhmRGO 7Mh3kgHccv2UcdZ+0nBDa2/hK3t4o4YIkukjjjUKqKBCAABwABxigD2PwJ/yTzw1/wBgq1/9FLXP /G3/AJJDrv8A27/+lEddB4E/5J54a/7BVr/6KWuf+Nv/ACSHXf8At3/9KI6AOf8A2cf+Seah/wBh WT/0VFXjHw28IaX4n8cv4c8Ry31jIYpRHHCNknnoQSjblbbhRITkDlcZzwfZ/wBnH/knmof9hWT/ ANFRVxnxZ+H2teGvGL+NfDsEkto9x9uZoYzI1nOvzs7g5yhZS+77oyVIA25AOz/4Zx8H/wDQS1z/ AL/w/wDxqq91+z/4DsfI+2a5qtv58qwQ+ddwJ5kjfdRcx8scHAHJrnNK/aTvrXS7eDU/D0d9eRpt luUu/JEp/vbPLIBxjODjOcADgcfqV54v+NvjFTbWkhgRxHDEu77PYRtk5d8YBIUksRliuAOFUAH1 H4W8N2fhHw5aaHYSTyWtrv2POwLnc7OckADqx7VsVn6Ho1n4e0Oy0iwTZa2kSxJkAFsdWbAALE5J OOSSa0KAOf8AHf8AyTzxL/2Crr/0U1eP/sy/8zT/ANun/tavYPHf/JPPEv8A2Crr/wBFNXj/AOzL /wAzT/26f+1qAD9pr/mVv+3v/wBo17B4E/5J54a/7BVr/wCilrx/9pr/AJlb/t7/APaNeweBP+Se eGv+wVa/+iloA8A/Zx/5KHqH/YKk/wDRsVfT9fMH7OP/ACUPUP8AsFSf+jYq+n6APmDxl/ydDbf9 hXTf/QYa6P8AaZgma38NXCxSGBHuUeQKdqswiKgnoCQrEDvtPpXOeMv+Tobb/sK6b/6DDXufxG8G L468HXGkLJHFdq6z2ksm7akq5xnB6FSy9DjdnBIFAHl/g74IeDfFPg7StaXVNZL3VurS+XJGqrKP lkUBos4Dhh36dT1rc/4Zx8H/APQS1z/v/D/8aryzwr438V/B7VJdH1PS5PsbO8sun3CiIu5wnmpL tJIzGBkblIBxzyNzxP8AtD6prGhzWGkaT/ZFxN8rXa3fmuidwnyLtY8fNzjnGDggA9H8GfCPwfoH iOPXNE1i+vbrTpZYHRrmGREkKFGRwqAhgH6ZBHFeoV4X8CPhxfaPcXPibXtPktbgoYLGC4TbIgJw 8hRhlCcBVOQSC/GCCfdKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAo oooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACii igAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKK ACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA KKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKz9T0LR9b8r+ 1tKsb/yc+X9rt0l2ZxnG4HGcDp6CtCigCOCCG1t4re3ijhgiQJHHGoVUUDAAA4AA4xUlFFABWXN4 a0G51QapPommy6gHVxdvao0oZcbTvIzkYGDnjArUooAKx77wn4b1O8kvL/w/pV3dSY3zT2UcjtgA DLEZOAAPwrYooAjgghtbeK3t4o4YIkCRxxqFVFAwAAOAAOMVz/j7XNS8NeCNT1nSbWO5vLREdY5I 2ddu9Q5IUg4ClmznjGTwK6SigDx/wn8WPCfxA05rDxjZ6VZXVttl2agUa2mIGC6GQYVslvlOSAeC 3zY0Nc8f/D/wHod7P4ck0M6lcRN5EGlxRuJZF4TzTFgBQXz8xBxu25PFZ/if9nvw/rF5NeaRfz6R NNL5jQrEssCDHIRPlK5OD94gcgADGM/Rv2btLtNRSbV9dn1C1TB+zw2/2feQQcM25jtIyCBg88EY oAzP2bNAY3Gs+I5FkCKgsYGDLtYkh5AR1yMRYPA+Y9e30HVPStKsdD0u30zTLaO2s7dNkUSdFH8y Sckk8kkk5Jq5QAVHPBDdW8tvcRRzQSoUkjkUMrqRggg8EEcYqSigDHsfCfhvTLyO8sPD+lWl1HnZ NBZRxuuQQcMBkZBI/GpNS8NaDrNwtxqmiabfTqgRZLq1SVguScAsCcZJOPc1qUUARzwQ3VvLb3EU c0EqFJI5FDK6kYIIPBBHGKp6ZoWj6J5v9k6VY2HnY8z7JbpFvxnGdoGcZPX1NaFFABWXpvhrQdGu GuNL0TTbGdkKNJa2qRMVyDglQDjIBx7CtSigArLh8NaDbaodUg0TTYtQLs5u0tUWUs2dx3gZycnJ zzk1qUUAFZ+p6Fo+t+V/a2lWN/5OfL+126S7M4zjcDjOB09BWhRQBl6b4a0HRrhrjS9E02xnZCjS WtqkTFcg4JUA4yAcewrUoooAKKKKAK99YWep2clnf2kF3ayY3wzxiRGwQRlTwcEA/hWfY+E/DemX kd5YeH9KtLqPOyaCyjjdcgg4YDIyCR+NbFFAFPUtJ03WbdbfVNPtL6BXDrHdQrKobBGQGBGcEjPu aksbCz0yzjs7C0gtLWPOyGCMRouSScKOBkkn8asUUARzwQ3VvLb3EUc0EqFJI5FDK6kYIIPBBHGK x4PBfhW1uIri38NaNDPE4eOSOwiVkYHIIIXIIPOa3KKACiiigDHvvCfhvU7yS8v/AA/pV3dSY3zT 2UcjtgADLEZOAAPwrQsbCz0yzjs7C0gtLWPOyGCMRouSScKOBkkn8asUUAFU9S0nTdZt1t9U0+0v oFcOsd1CsqhsEZAYEZwSM+5q5RQBj2PhPw3pl5HeWHh/SrS6jzsmgso43XIIOGAyMgkfjWxRRQAV hz+C/Ct1cS3Fx4a0aaeVy8kklhEzOxOSSSuSSec1uUUAV7Gws9Ms47OwtILS1jzshgjEaLkknCjg ZJJ/GrFFFAGfqehaPrflf2tpVjf+Tny/tdukuzOM43A4zgdPQVHpvhrQdGuGuNL0TTbGdkKNJa2q RMVyDglQDjIBx7CtSigArLm8NaDc6oNUn0TTZdQDq4u3tUaUMuNp3kZyMDBzxgVqUUAV76ws9Ts5 LO/tILu1kxvhnjEiNggjKng4IB/Co9N0nTdGt2t9L0+0sYGcu0drCsSlsAZIUAZwAM+wq5RQAVl6 b4a0HRrhrjS9E02xnZCjSWtqkTFcg4JUA4yAcewrUooA8n+JvxV1j4feLdPtk0eC80i4tPNZn3xu 8m5wVWTlRj92SNpPzdsg1qQa/wDCnxTbxa1eN4YNxdIGk/tNbdbhSBt2uH5yMY7jAGCRg11nifwx pfi7Q5tI1eDzbeTlWXh4nHR0PZhk/mQQQSD4/ffs0Wcl5I1h4nngtTjZHPZiV14GcsHUHnP8I9Oe tAGB8bvH+ha3p2m+F/DckE1jYymSWSGIrGjIDGiRngFQC3QFcbNp617n4A0BvC/gPRtHlWRZ4LcN OjsrFJXJeRcrwQGZgMZ4A5PWuX8E/BLw54SuINQumk1bVIXDxzzLsjiYFsFIwSM4I5YtgqCNtemU AFFFFABXP/8ACCeD/wDoVND/APBdD/8AE10FFABVe+sLPU7OSzv7SC7tZMb4Z4xIjYIIyp4OCAfw qxRQBT03SdN0a3a30vT7SxgZy7R2sKxKWwBkhQBnAAz7CrlFFAGXpvhrQdGuGuNL0TTbGdkKNJa2 qRMVyDglQDjIBx7CtSiigDL1Lw1oOs3C3GqaJpt9OqBFkurVJWC5JwCwJxkk49zUmmaFo+ieb/ZO lWNh52PM+yW6Rb8ZxnaBnGT19TWhRQAUUUUAFFFFAHP/APCCeD/+hU0P/wAF0P8A8TXQUUUAFc// AMIJ4P8A+hU0P/wXQ/8AxNdBRQBHPBDdW8tvcRRzQSoUkjkUMrqRggg8EEcYqnpmhaPonm/2TpVj YedjzPslukW/GcZ2gZxk9fU1oUUAFYc/gvwrdXEtxceGtGmnlcvJJJYRMzsTkkkrkknnNblFAEcE ENrbxW9vFHDBEgSOONQqooGAABwABxiqep6Fo+t+V/a2lWN/5OfL+126S7M4zjcDjOB09BWhRQBH BBDa28VvbxRwwRIEjjjUKqKBgAAcAAcYqO+sLPU7OSzv7SC7tZMb4Z4xIjYIIyp4OCAfwqxRQBT0 3SdN0a3a30vT7SxgZy7R2sKxKWwBkhQBnAAz7CrlFFAGHP4L8K3VxLcXHhrRpp5XLySSWETM7E5J JK5JJ5zWpY2FnplnHZ2FpBaWsedkMEYjRckk4UcDJJP41YooAKKKKAI54Ibq3lt7iKOaCVCkkcih ldSMEEHggjjFU9M0LR9E83+ydKsbDzseZ9kt0i34zjO0DOMnr6mtCigDP1PQtH1vyv7W0qxv/Jz5 f2u3SXZnGcbgcZwOnoKuQQQ2tvFb28UcMESBI441CqigYAAHAAHGKkooAy9N8NaDo1w1xpeiabYz shRpLW1SJiuQcEqAcZAOPYVqUUUAZc3hrQbnVBqk+iabLqAdXF29qjShlxtO8jORgYOeMCtSiigC nqWk6brNutvqmn2l9Arh1juoVlUNgjIDAjOCRn3NU7Hwn4b0y8jvLDw/pVpdR52TQWUcbrkEHDAZ GQSPxrYooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKK KKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooo oAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiig AooooAKKKKACuH+Jnjx/BWj2senW/wBr13UZRFp9qYWkWQhl35CkHowAAOSzLwRnHcUUAeJzn42+ HNGl8Q3+r6NfQWlubifTpI03bduWBKRoCUGT8r87eN3Q9Zf/ABES4+C9z41s4Z7SSS0cQphZGinL mFTzwyiTByRyozjPFc38V/DXxL1YatLpGrRyeHwitHplqxS4kXywsinagLgkudhc5GMAnAqNLZ/i j8ErXSvBcNjokKXYgurKZ2ZESMl9u/yyWYkxSFgOcnJJzkAj0nT/AI26zo1jqlv4w0ZYL23juI1k gQMFdQwBxbkZwfU13mgS+JfDHg3VL/xxqMGp3Vp5t1vsUUfuEjB2gbEBbKv19Rz6cXN8JvGz2Qe2 +It3YypbqkOn2nnR2sO1AqxK3m52DAG8qWIG4gknOHrfjfUfFPwV8X6Vrtr5Ou6JLbW166Fdkrfa FXcNpwGyjAgfL3HBwADQ0fUPi/4+s38R6HrGlaNpNzK4tbSZUchFO3OfKcnkEEkjJBIAGK7D4W+N 9R8U2epaVrtr5Ou6JKLa9dCuyVssu4bTgNlGBA+XuODgdB4E/wCSeeGv+wVa/wDopa8/8Pf8nQ+L P+wVH/6Da0AewUVj6trx0zUbSwg0q+1G6uopZlS0MI2pGYwxJlkQdZV6Z71X/wCEh1T/AKEzXP8A v9Zf/JFAHQUVy9/4vu9M065v7zwjrkdraxPNM/mWZ2ooJY4Fxk4APSrH/CQ6p/0Jmuf9/rL/AOSK AOgorn/+Eh1T/oTNc/7/AFl/8kUf8JDqn/Qma5/3+sv/AJIoA6Ciuf8A+Eh1T/oTNc/7/WX/AMkV XuPF93aT2kM/hHXEku5TDAPMszvcI0hHFxx8qMefT1xQB1FFc/8A8JDqn/Qma5/3+sv/AJIo/wCE h1T/AKEzXP8Av9Zf/JFAHQUVz/8AwkOqf9CZrn/f6y/+SKP+Eh1T/oTNc/7/AFl/8kUAdBRXLp4v u5NRmsF8I64bqGKOaRPMs/lRy4U5+0Y5Mb/l7irH/CQ6p/0Jmuf9/rL/AOSKAOgorn/+Eh1T/oTN c/7/AFl/8kUf8JDqn/Qma5/3+sv/AJIoA6Ciuf8A+Eh1T/oTNc/7/WX/AMkVXs/F93qEDTWvhHXJ I1lkhJ8yzGHjdo3HNx2ZWHvjjigDqKK5/wD4SHVP+hM1z/v9Zf8AyRR/wkOqf9CZrn/f6y/+SKAO gorn/wDhIdU/6EzXP+/1l/8AJFH/AAkOqf8AQma5/wB/rL/5IoA6CiuXsPF93qenW1/Z+Edcktbq JJoX8yzG5GAKnBuMjII61Y/4SHVP+hM1z/v9Zf8AyRQB0FFc/wD8JDqn/Qma5/3+sv8A5Io/4SHV P+hM1z/v9Zf/ACRQB0FFcve+L7vT4FmuvCOuRxtLHCD5lmcvI6xoOLjuzKPbPPFWP+Eh1T/oTNc/ 7/WX/wAkUAdBRXP/APCQ6p/0Jmuf9/rL/wCSKP8AhIdU/wChM1z/AL/WX/yRQB0FFc//AMJDqn/Q ma5/3+sv/kiq7+L7uPUYbBvCOuC6mikmjTzLP5kQoGOftGODIn5+xoA6iiuf/wCEh1T/AKEzXP8A v9Zf/JFH/CQ6p/0Jmuf9/rL/AOSKAOgorn/+Eh1T/oTNc/7/AFl/8kUf8JDqn/Qma5/3+sv/AJIo A6CiuXt/F93dz3cMHhHXHktJRDOPMsxscosgHNxz8rqePX1zVj/hIdU/6EzXP+/1l/8AJFAHQUVz /wDwkOqf9CZrn/f6y/8Akij/AISHVP8AoTNc/wC/1l/8kUAdBRXP/wDCQ6p/0Jmuf9/rL/5IqvZ+ L7vUIGmtfCOuSRrLJCT5lmMPG7RuObjsysPfHHFAHUUVz/8AwkOqf9CZrn/f6y/+SKP+Eh1T/oTN c/7/AFl/8kUAdBRXP/8ACQ6p/wBCZrn/AH+sv/kiq9/4vu9M065v7zwjrkdraxPNM/mWZ2ooJY4F xk4APSgDqKK5/wD4SHVP+hM1z/v9Zf8AyRR/wkOqf9CZrn/f6y/+SKAOgorh9H+JUOvajqlhpnhn XJ7rS5fJvEzar5T5YYy04B5RumelbH/CQ6p/0Jmuf9/rL/5IoA6CiuXuPF93aT2kM/hHXEku5TDA PMszvcI0hHFxx8qMefT1xVj/AISHVP8AoTNc/wC/1l/8kUAdBRXP/wDCQ6p/0Jmuf9/rL/5Io/4S HVP+hM1z/v8AWX/yRQB0FFc//wAJDqn/AEJmuf8Af6y/+SKrp4vu5NRmsF8I64bqGKOaRPMs/lRy 4U5+0Y5Mb/l7igDqKK5//hIdU/6EzXP+/wBZf/JFH/CQ6p/0Jmuf9/rL/wCSKAOgorn/APhIdU/6 EzXP+/1l/wDJFH/CQ6p/0Jmuf9/rL/5IoA6CiuXs/F93qEDTWvhHXJI1lkhJ8yzGHjdo3HNx2ZWH vjjirH/CQ6p/0Jmuf9/rL/5IoA6Ciuf/AOEh1T/oTNc/7/WX/wAkUf8ACQ6p/wBCZrn/AH+sv/ki gDoKK5//AISHVP8AoTNc/wC/1l/8kVXsPF93qenW1/Z+EdcktbqJJoX8yzG5GAKnBuMjII60AdRR XP8A/CQ6p/0Jmuf9/rL/AOSKP+Eh1T/oTNc/7/WX/wAkUAdBRXP/APCQ6p/0Jmuf9/rL/wCSKr3v i+70+BZrrwjrkcbSxwg+ZZnLyOsaDi47syj2zzxQB1FFc/8A8JDqn/Qma5/3+sv/AJIo/wCEh1T/ AKEzXP8Av9Zf/JFAHQUVz/8AwkOqf9CZrn/f6y/+SKP+Eh1T/oTNc/7/AFl/8kUAdBRXLv4vu49R hsG8I64LqaKSaNPMs/mRCgY5+0Y4Mifn7GrH/CQ6p/0Jmuf9/rL/AOSKAOgorn/+Eh1T/oTNc/7/ AFl/8kUf8JDqn/Qma5/3+sv/AJIoA6Ciuf8A+Eh1T/oTNc/7/WX/AMkVXt/F93dz3cMHhHXHktJR DOPMsxscosgHNxz8rqePX1zQB1FFc/8A8JDqn/Qma5/3+sv/AJIo/wCEh1T/AKEzXP8Av9Zf/JFA HQUVz/8AwkOqf9CZrn/f6y/+SKP+Eh1T/oTNc/7/AFl/8kUAdBRXL2fi+71CBprXwjrkkayyQk+Z ZjDxu0bjm47MrD3xxxVj/hIdU/6EzXP+/wBZf/JFAHQUVz//AAkOqf8AQma5/wB/rL/5Io/4SHVP +hM1z/v9Zf8AyRQB0FFcvf8Ai+70zTrm/vPCOuR2trE80z+ZZnaigljgXGTgA9Ksf8JDqn/Qma5/ 3+sv/kigDoKK5/8A4SHVP+hM1z/v9Zf/ACRR/wAJDqn/AEJmuf8Af6y/+SKAOgorn/8AhIdU/wCh M1z/AL/WX/yRVe48X3dpPaQz+EdcSS7lMMA8yzO9wjSEcXHHyox59PXFAHUUVz//AAkOqf8AQma5 /wB/rL/5Iqvf+L7vTNOub+88I65Ha2sTzTP5lmdqKCWOBcZOAD0oA6iiuP0Tx6/iPR4NW0nwrrlx Yz7vLl32ibtrFTw04I5BHIrQ/wCEh1T/AKEzXP8Av9Zf/JFAHQUVy6eL7uTUZrBfCOuG6hijmkTz LP5UcuFOftGOTG/5e4qx/wAJDqn/AEJmuf8Af6y/+SKAOgorn/8AhIdU/wChM1z/AL/WX/yRR/wk Oqf9CZrn/f6y/wDkigDoKK5//hIdU/6EzXP+/wBZf/JFV7fxfd3c93DB4R1x5LSUQzjzLMbHKLIB zcc/K6nj19c0AdRRXP8A/CQ6p/0Jmuf9/rL/AOSKP+Eh1T/oTNc/7/WX/wAkUAdBRXP/APCQ6p/0 Jmuf9/rL/wCSKP8AhIdU/wChM1z/AL/WX/yRQB0FFcvYeL7vU9Otr+z8I65Ja3USTQv5lmNyMAVO DcZGQR1qx/wkOqf9CZrn/f6y/wDkigDoKK5//hIdU/6EzXP+/wBZf/JFH/CQ6p/0Jmuf9/rL/wCS KAOgorl73xfd6fAs114R1yONpY4QfMszl5HWNBxcd2ZR7Z54qx/wkOqf9CZrn/f6y/8AkigDoKK5 /wD4SHVP+hM1z/v9Zf8AyRR/wkOqf9CZrn/f6y/+SKAOgorn/wDhIdU/6EzXP+/1l/8AJFV38X3c eow2DeEdcF1NFJNGnmWfzIhQMc/aMcGRPz9jQB1FFc//AMJDqn/Qma5/3+sv/kij/hIdU/6EzXP+ /wBZf/JFAHQUVz//AAkOqf8AQma5/wB/rL/5Io/4SHVP+hM1z/v9Zf8AyRQB0FFcuni+7k1GawXw jrhuoYo5pE8yz+VHLhTn7Rjkxv8Al7irH/CQ6p/0Jmuf9/rL/wCSKAOgorn/APhIdU/6EzXP+/1l /wDJFH/CQ6p/0Jmuf9/rL/5IoA6Ciuf/AOEh1T/oTNc/7/WX/wAkVXs/F93qEDTWvhHXJI1lkhJ8 yzGHjdo3HNx2ZWHvjjigDqKK5/8A4SHVP+hM1z/v9Zf/ACRR/wAJDqn/AEJmuf8Af6y/+SKAOgor n/8AhIdU/wChM1z/AL/WX/yRVe/8X3emadc3954R1yO1tYnmmfzLM7UUEscC4ycAHpQB1FFc/wD8 JDqn/Qma5/3+sv8A5Io/4SHVP+hM1z/v9Zf/ACRQB0FFc/8A8JDqn/Qma5/3+sv/AJIo/wCEh1T/ AKEzXP8Av9Zf/JFAHQUVy9x4vu7Se0hn8I64kl3KYYB5lmd7hGkI4uOPlRjz6euKsf8ACQ6p/wBC Zrn/AH+sv/kigDoKK5//AISHVP8AoTNc/wC/1l/8kUf8JDqn/Qma5/3+sv8A5IoA6Ciuf/4SHVP+ hM1z/v8AWX/yRVdPF93JqM1gvhHXDdQxRzSJ5ln8qOXCnP2jHJjf8vcUAdRRXP8A/CQ6p/0Jmuf9 /rL/AOSKP+Eh1T/oTNc/7/WX/wAkUAdBRXP/APCQ6p/0Jmuf9/rL/wCSKP8AhIdU/wChM1z/AL/W X/yRQB0FFcvb+L7u7nu4YPCOuPJaSiGceZZjY5RZAObjn5XU8evrmrH/AAkOqf8AQma5/wB/rL/5 IoA6Ciuf/wCEh1T/AKEzXP8Av9Zf/JFH/CQ6p/0Jmuf9/rL/AOSKAOgorn/+Eh1T/oTNc/7/AFl/ 8kVXsPF93qenW1/Z+EdcktbqJJoX8yzG5GAKnBuMjII60AdRRXP/APCQ6p/0Jmuf9/rL/wCSKP8A hIdU/wChM1z/AL/WX/yRQB0FFc//AMJDqn/Qma5/3+sv/kiq974vu9PgWa68I65HG0scIPmWZy8j rGg4uO7Mo9s88UAdRRXP/wDCQ6p/0Jmuf9/rL/5Io/4SHVP+hM1z/v8AWX/yRQB0FFc//wAJDqn/ AEJmuf8Af6y/+SKP+Eh1T/oTNc/7/WX/AMkUAdBRXLv4vu49RhsG8I64LqaKSaNPMs/mRCgY5+0Y 4Mifn7GrH/CQ6p/0Jmuf9/rL/wCSKAOgorn/APhIdU/6EzXP+/1l/wDJFH/CQ6p/0Jmuf9/rL/5I oA6Ciuf/AOEh1T/oTNc/7/WX/wAkVXTxfdyajNYL4R1w3UMUc0ieZZ/Kjlwpz9oxyY3/AC9xQB1F Fc//AMJDqn/Qma5/3+sv/kij/hIdU/6EzXP+/wBZf/JFAHQUVz//AAkOqf8AQma5/wB/rL/5Io/4 SHVP+hM1z/v9Zf8AyRQB0FFcvZ+L7vUIGmtfCOuSRrLJCT5lmMPG7RuObjsysPfHHFWP+Eh1T/oT Nc/7/WX/AMkUAdBRXD3HxKhtPFFp4an8M64mr3cRmgt82p3oAxJ3CfaPuN1Pb6Vsf8JDqn/Qma5/ 3+sv/kigDoKK5e/8X3emadc3954R1yO1tYnmmfzLM7UUEscC4ycAHpVj/hIdU/6EzXP+/wBZf/JF AHQUVz//AAkOqf8AQma5/wB/rL/5Io/4SHVP+hM1z/v9Zf8AyRQB0FFc/wD8JDqn/Qma5/3+sv8A 5IqvceL7u0ntIZ/COuJJdymGAeZZne4RpCOLjj5UY8+nrigDqKK5/wD4SHVP+hM1z/v9Zf8AyRR/ wkOqf9CZrn/f6y/+SKAOgorP0XVk1vTBex209t+9lheGfbvR45GjYHazL95D0JrQoAKKKKACiiig AooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAC iiigAooooAKKKKACiiigAooooAKKKKACuD+KF3400vS7DVfBxkne2uALywS1WY3EZxg/38AjBCc4 cnI25rvKKAPF/wDhoOz1PTvs2geG9VuvEMsX7m08oSR+ZjLco29lUbjwoJA/hzkSab4O8YeBfgs0 Ph+5kh8SC4OoXNvFHHcbwQFaJNwxkIFY43EshC5DCvZKKAPF7H9oOz+xx2N/4b1U+JRmB7KCIbGu ASoQZbeuWwMbSVzj5scyeFPhzqWqeA/F0+v20dtrHit2uRau7IluwLSQlgAWUiRixUluAoIzuFey UUAeD+GPjLB4H0OHwt4w0nVU1fSv9FbyY4mBjX/V/wAS9FwARkMAG3HdXQfCXS9U1bXNd+IWt2X2 abWtq6erv86W3oQAAVIWIBiMnZno2W9YooA5+8/5KHo3/YKv/wD0baV0Fc/ef8lD0b/sFX//AKNt K6CgDn/Hf/JPPEv/AGCrr/0U1dBWfrumf234e1PSfO8n7daS23m7d2zehXdjIzjOcZFaFABRRRQA Vz/iH/kOeE/+wrJ/6RXVdBWfqOmfb77SbnzvL/s+7a527c+ZmGWLbnPH+tznn7uO+QAaFYfjSea1 8C+Ibi3lkhni0y5eOSNirIwiYggjkEHnNblZ+u2tnfeHtTs9RuPs9jPaSxXE28J5cbIQzbjwMAk5 PAoAp+C55rrwL4euLiWSaeXTLZ5JJGLM7GJSSSeSSec1uVn6Fa2dj4e0yz064+0WMFpFFbzbw/mR qgCtuHByADkcGtCgDn7P/koes/8AYKsP/Rt3XQVnw6Z5XiG91bzs/abSC28rb93ynmbdnPOfOxjH G3vnjQoAKKKKACuf8G/8gO5/7Cupf+ls1dBWfo2mf2RYyW3nebvu7m53bduPOmeXbjJ6b8Z74zx0 oA0K4f7fef8AC9f7O+1z/Yf+Ea8/7N5h8vzPtO3ft6bscZ64ruK5/wDsrR/+Fh/2v9v/AOJ3/ZX2 X7F5yf8AHv5u7zNmN33+N2cdutAHQUUUUAc/4E/5J54a/wCwVa/+ilroKz9C0z+xPD2maT53nfYb SK283bt37EC7sZOM4zjJrQoAKKKKAOf8Zf8AIDtv+wrpv/pbDXQVn6zpn9r2Mdt53lbLu2ud23dn yZkl24yOuzGe2c89K0KACuH+EF/ean8LdGvL+7nu7qTz9808hkdsTyAZY8nAAH4V3Fc/4J0rR9E8 IWOnaBf/AG/TIfM8m585Jd+ZGZvmQBThiw49KAOgrn7z/koejf8AYKv/AP0baV0FZ82meb4hstW8 7H2a0ntvK2/e814W3ZzxjycYxzu7Y5ANCiiigAooooA5/wAPf8hzxZ/2FY//AEita6Cs/TtM+wX2 rXPneZ/aF2tzt248vEMUW3Oef9VnPH3sdsnQoA4fxPf3lv8AFLwFZw3c8drdf2h9ohSQhJdsCldy jhsHkZ6V3Fc/q+laPd+L/Dmo3t/5Op2P2n7Bbeci/aN8YWT5SNzbVwflxjvXQUAFc/4N/wCQHc/9 hXUv/S2augrP0bTP7IsZLbzvN33dzc7tu3HnTPLtxk9N+M98Z46UAaFFFFABXP8Ajv8A5J54l/7B V1/6KaugrP13TP7b8PanpPneT9utJbbzdu7ZvQruxkZxnOMigDQooooA8f8AhB/yUP4nf9hUf+jb ivYK8f8AhB/yUP4nf9hUf+jbivYKAOf8Q/8AIc8J/wDYVk/9IrqugrP1HTPt99pNz53l/wBn3bXO 3bnzMwyxbc54/wBbnPP3cd8jQoAKKKKACufs/wDkoes/9gqw/wDRt3XQVnw6Z5XiG91bzs/abSC2 8rb93ynmbdnPOfOxjHG3vngA0K4f4k395Y/8Ij9ju57fz/EtnBN5MhTzI237kbHVTgZB4NdxXP8A irStH1T+xP7Xv/sf2XVYLqz/AHyR+dcLu2R/MDuzk/KOTjigDoKKKKAOf8G/8gO5/wCwrqX/AKWz V0FZ+jaZ/ZFjJbed5u+7ubndt2486Z5duMnpvxnvjPHStCgAooooAK5/wJ/yTzw1/wBgq1/9FLXQ Vn6Fpn9ieHtM0nzvO+w2kVt5u3bv2IF3YycZxnGTQBoVw/hi/vLj4pePbOa7nktbX+z/ALPC8hKR boGLbVPC5PJx1ruK5/SNK0e08X+I9Rsr/wA7U777N9vtvORvs+yMrH8oG5dy5PzZz2oA6Cuf8Zf8 gO2/7Cum/wDpbDXQVn6zpn9r2Mdt53lbLu2ud23dnyZkl24yOuzGe2c89KANCiiigAooooA5+8/5 KHo3/YKv/wD0baV0FZ82meb4hstW87H2a0ntvK2/e814W3ZzxjycYxzu7Y50KAOH+L9/eaZ8LdZv LC7ntLqPyNk0Ehjdczxg4YcjIJH413Fc/wCNtK0fW/CF9p2v3/2DTJvL86585ItmJFZfmcFRlgo5 9a6CgArn/D3/ACHPFn/YVj/9IrWugrP07TPsF9q1z53mf2hdrc7duPLxDFFtznn/AFWc8fex2yQD QooooAKKKKAOf8G/8gO5/wCwrqX/AKWzV0FZ+jaZ/ZFjJbed5u+7ubndt2486Z5duMnpvxnvjPHS tCgDh/t95/wvX+zvtc/2H/hGvP8As3mHy/M+07d+3puxxnriu4rn/wCytH/4WH/a/wBv/wCJ3/ZX 2X7F5yf8e/m7vM2Y3ff43Zx2610FAHP+O/8AknniX/sFXX/opq6Cs/XdM/tvw9qek+d5P260ltvN 27tm9Cu7GRnGc4yK0KACiiigArn/ABD/AMhzwn/2FZP/AEiuq6Cs/UdM+332k3PneX/Z921zt258 zMMsW3OeP9bnPP3cd8gA0K5/x3/yTzxL/wBgq6/9FNXQVz/jv/knniX/ALBV1/6KagDn/gl/ySHQ v+3j/wBKJK9Arz/4Jf8AJIdC/wC3j/0okr0CgDn7P/koes/9gqw/9G3ddBWfDpnleIb3VvOz9ptI Lbytv3fKeZt2c8587GMcbe+eNCgAooooAK5/w9/yHPFn/YVj/wDSK1roKz9O0z7Bfatc+d5n9oXa 3O3bjy8QxRbc55/1Wc8fex2yQDQrh/E9/eW/xS8BWcN3PHa3X9ofaIUkISXbApXco4bB5GeldxXP 6vpWj3fi/wAOaje3/k6nY/afsFt5yL9o3xhZPlI3NtXB+XGO9AHQUUUUAc/4E/5J54a/7BVr/wCi lroKz9C0z+xPD2maT53nfYbSK283bt37EC7sZOM4zjJrQoAKKKKAOf8AGX/IDtv+wrpv/pbDXQVn 6zpn9r2Mdt53lbLu2ud23dnyZkl24yOuzGe2c89K0KACuH+EF/ean8LdGvL+7nu7qTz9808hkdsT yAZY8nAAH4V3Fc/4J0rR9E8IWOnaBf8A2/TIfM8m585Jd+ZGZvmQBThiw49KAOgrn7z/AJKHo3/Y Kv8A/wBG2ldBWfNpnm+IbLVvOx9mtJ7bytv3vNeFt2c8Y8nGMc7u2OQDQooooAKKKKAOfs/+Sh6z /wBgqw/9G3ddBWfDpnleIb3VvOz9ptILbytv3fKeZt2c8587GMcbe+eNCgDh/iTf3lj/AMIj9ju5 7fz/ABLZwTeTIU8yNt+5Gx1U4GQeDXcVz/irStH1T+xP7Xv/ALH9l1WC6s/3yR+dcLu2R/MDuzk/ KOTjiugoAK5/wb/yA7n/ALCupf8ApbNXQVn6Npn9kWMlt53m77u5ud23bjzpnl24yem/Ge+M8dKA NCiiigArn/Hf/JPPEv8A2Crr/wBFNXQVn67pn9t+HtT0nzvJ+3Wktt5u3ds3oV3YyM4znGRQBoUU UUAcP8Nr+8vv+Eu+2Xc9x5HiW8gh86Qv5ca7NqLnooycAcCu4rn/AArpWj6X/bf9kX/2z7Vqs91e fvkk8m4bbvj+UDbjA+U8jPNdBQBz/iH/AJDnhP8A7Csn/pFdV0FZ+o6Z9vvtJufO8v8As+7a527c +ZmGWLbnPH+tznn7uO+RoUAFFFFABXP2f/JQ9Z/7BVh/6Nu66Cs+HTPK8Q3uredn7TaQW3lbfu+U 8zbs55z52MY42988AGhXD/F+/vNM+Fus3lhdz2l1H5GyaCQxuuZ4wcMORkEj8a7iuf8AG2laPrfh C+07X7/7Bpk3l+dc+ckWzEisvzOCoywUc+tAHQUUUUAc/wCHv+Q54s/7Csf/AKRWtdBWfp2mfYL7 VrnzvM/tC7W527ceXiGKLbnPP+qznj72O2ToUAFFFFABXP8AgT/knnhr/sFWv/opa6Cs/QtM/sTw 9pmk+d532G0itvN27d+xAu7GTjOM4yaANCuH8MX95cfFLx7ZzXc8lra/2f8AZ4XkJSLdAxbap4XJ 5OOtdxXP6RpWj2ni/wAR6jZX/nanffZvt9t5yN9n2RlY/lA3LuXJ+bOe1AHQVz/jL/kB23/YV03/ ANLYa6Cs/WdM/texjtvO8rZd21zu27s+TMku3GR12Yz2znnpQBoUUUUAFFFFAHP3n/JQ9G/7BV// AOjbSugrPm0zzfENlq3nY+zWk9t5W373mvC27OeMeTjGOd3bHOhQBh+NJ5rXwL4huLeWSGeLTLl4 5I2KsjCJiCCOQQec0eC55rrwL4euLiWSaeXTLZ5JJGLM7GJSSSeSSec1c121s77w9qdnqNx9nsZ7 SWK4m3hPLjZCGbceBgEnJ4FGhWtnY+HtMs9OuPtFjBaRRW828P5kaoArbhwcgA5HBoA0K5+z/wCS h6z/ANgqw/8ARt3XQVnw6Z5XiG91bzs/abSC28rb93ynmbdnPOfOxjHG3vngA0KKKKACiiigDn/B v/IDuf8AsK6l/wCls1dBWfo2mf2RYyW3nebvu7m53bduPOmeXbjJ6b8Z74zx0rQoA8f8Q/8AJ0Ph P/sFSf8AoN1XsFeP+If+TofCf/YKk/8AQbqvYKAOf8d/8k88S/8AYKuv/RTV0FZ+u6Z/bfh7U9J8 7yft1pLbebt3bN6Fd2MjOM5xkVoUAFFFFABXP+If+Q54T/7Csn/pFdV0FZ+o6Z9vvtJufO8v+z7t rnbtz5mYZYtuc8f63Oefu475ABoUUUUAcH8GZ5rr4U6PcXEsk08r3LySSMWZ2NxISSTySTzmu8rj /hha2dj4CtbPTrj7RYwXd7Fbzbw/mRrdShW3Dg5AByODXYUAFFFFABRRRQAUUUUAFFFFABRRRQAU UUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRR RQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBz95/yUPRv+wVf/wDo20roK5+8/wCSh6N/2Cr/AP8A RtpXQUAFFFFABRRRQAUUUUAFc/47/wCSeeJf+wVdf+imroKz9durOx8Paneajb/aLGC0lluIdgfz I1Qll2ng5AIweDQBn+BP+SeeGv8AsFWv/opa6Cs/QrqzvvD2mXmnW/2exntIpbeHYE8uNkBVdo4G AQMDgVoUAFFFFABRRRQAUUUUAFef/wDNwv8A3Kn/ALd16BXP/wBq6P8A8LD/ALI+wf8AE7/sr7V9 t8lP+Pfzdvl787vv87cY79aAOgooooAKKKKACiiigAooooAK8/8Agl/ySHQv+3j/ANKJK9Arn/BO q6PrfhCx1HQLD7Bpk3meTbeSkWzEjK3yoSoywY8etAHQUUUUAFFFFABRRRQAUVUs777XdahD5e37 JOIc7s78xJJn2+/j8Kt0k7lSi4uz/q+p5/4t/wCSvfDr/uJ/+k616BXP6vquj2ni/wAOade2Hnan ffafsFz5KN9n2RhpPmJ3LuXA+XOe9dBTJCiiigAooooAKKKKACiiigDx/wCEH/JQ/id/2FR/6NuK 9grx/wCEH/JQ/id/2FR/6NuK9goAKKKKACiiigAooooAK8/+Kf8AzJX/AGNdj/7PXoFc/wCKtV0f S/7E/tew+2fatVgtbP8AcpJ5Nw27ZJ8xG3GD8w5GeKAOgooooAKKKKACiiigAooooAK8/wDCX/JX viL/ANwz/wBJ2r0Cuf0jVdHu/F/iPTrKw8nU7H7N9vufJRftG+MtH8wO5tq5HzYx2oA6CiiigAoo ooAKKKKACiiigDz/AONv/JIdd/7d/wD0ojr0Cuf8baro+ieEL7UdfsPt+mQ+X51t5KS78yKq/K5C nDFTz6V0FABRRRQAUUUUAFFFFABRRRQB5/8A83C/9yp/7d16BXP/ANq6P/wsP+yPsH/E7/sr7V9t 8lP+Pfzdvl787vv87cY79a6CgAooooAKKKKACiiigArn/Hf/ACTzxL/2Crr/ANFNXQVz/jv/AJJ5 4l/7BV1/6KagDn/gl/ySHQv+3j/0okr0CvP/AIJf8kh0L/t4/wDSiSvQKACiiigAooooAKKKKACv P/Fv/JXvh1/3E/8A0nWvQK5/V9V0e08X+HNOvbDztTvvtP2C58lG+z7Iw0nzE7l3LgfLnPegDoKK KKACiiigAooooAKKKKACvP8A4Jf8kh0L/t4/9KJK9Arn/BOq6PrfhCx1HQLD7Bpk3meTbeSkWzEj K3yoSoywY8etAHQUUUUAFFFFABRRRQAUUUUAef8AxT/5kr/sa7H/ANnr0Cuf8Varo+l/2J/a9h9s +1arBa2f7lJPJuG3bJPmI24wfmHIzxXQUAFFFFABRRRQAUUUUAFFFFAHn/ws/wCZ1/7Gu+/9kr0C uf8ACuq6Pqn9t/2RYfY/suqz2t5+5SPzrhdu+T5Sd2cj5jycc10FABRRRQAUUUUAFFFFABXn/wAb f+SQ67/27/8ApRHXoFc/421XR9E8IX2o6/Yfb9Mh8vzrbyUl35kVV+VyFOGKnn0oA6CiiigAoooo AKKKKACiiigArz/wl/yV74i/9wz/ANJ2r0Cuf0jVdHu/F/iPTrKw8nU7H7N9vufJRftG+MtH8wO5 tq5HzYx2oA6CiiigAooooAKKKKACiiigDn/Hf/JPPEv/AGCrr/0U1HgT/knnhr/sFWv/AKKWtDXb qzsfD2p3mo2/2ixgtJZbiHYH8yNUJZdp4OQCMHg0aFdWd94e0y8063+z2M9pFLbw7AnlxsgKrtHA wCBgcCgDQooooAKKKKACiiigAooooA8f8Q/8nQ+E/wDsFSf+g3VewV4/4h/5Oh8J/wDYKk/9Buq9 goAKKKKACiiigAooooAKKKKAPP8A4Jf8kh0L/t4/9KJK9Arj/hhdWd94CtbzTrf7PYz3d7Lbw7An lxtdSlV2jgYBAwOBXYUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRR RQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXJ+KPiT4U8IO8Gq6rH9sVGb7HADLLk KGCkLwhIYY3lQc9cZNed6p4s8a/FO8u9N8AJ/Z2gQSrHJrMjtA8jKC3DD5lU/L8qqW+7uKhitXNA /Z18Oae6y61qF3qzq5PlqPs8TKVwAwUl8g5OQ47cdcgGfqX7S2mxXCrpfhu7uYNgLPdXKwMGyeAq hwRjHOe5445rwftMwtcRLceFJI4C4Ejx34dlXPJCmMAnHbIz6ivUNN+GPgjSrdoLfwxprozlybqE XDZwBw0m4gcdM46+pqxP8PvBtzbywP4V0YJIhRjHZRowBGOGUAqfcEEdqAOf0D42+CNedYm1CTTJ 2cqseooIgQFzu3glAOoGWByMY5GfRK8r1v4AeC9Rt9unR3ekzqjhXhnaVWYj5S6yFiQCOilc5PPT HN2fh74k/COUtorf8JT4e+UNZqH3xjcCSkWSUYl3GU3jqzDgYAPeKKy/Dmv2Pinw/Z61prSG0ukL J5i7WUglWUj1DAjjI44JHNalABRRRQAUUUUAFFFFAHP3n/JQ9G/7BV//AOjbSugrn7z/AJKHo3/Y Kv8A/wBG2ldBQAUUUUAFFFFABRRRQAVh+NIJrrwL4ht7eKSaeXTLlI441LM7GJgAAOSSeMVuVl+J dSm0bwrq+qW6xtPZWU1xGsgJUsiFgDgg4yPUUAV/BcE1r4F8PW9xFJDPFplskkcilWRhEoIIPIIP GK3Ky/DWpTaz4V0jVLhY1nvbKG4kWMEKGdAxAyScZPqa1KACiiigAooooAKKKKACuH+wXn/C9f7R +yT/AGH/AIRryPtPlny/M+07tm7puxzjriu4rl/+EkvP+Fp/8Iv5cH2H+xP7Q8zafM8zz/LxnONu O2M570AdRRRRQAUUUUAFFFFABRRRQAVw/wAILC80z4W6NZ39pPaXUfn74Z4zG65nkIyp5GQQfxru K5f4d+JLzxd4E03XL+OCO6uvN3pApCDbK6DAJJ6KO9AHUUUUUAFFFFABVS+s57vy/J1K6stuc+Qs R35x13o3T2x1q3RSauVGTi7r/P8AM5XStKvG1HWwNf1FCt6oLLHb5c/Z4Tk5i68gcYGAO+SeniRo 4URpGlZVAMjgbmPqcADJ9gBQkUcbSMkaq0jbnKjBY4AyfU4AH0Ap9TGPKbV67qtaLZdEtkl0Rw/i ewvLj4peAryG0nktbX+0PtEyRkpFugULuYcLk8DPWu4rl9c8SXmmeO/CmhwxwNa6v9s+0O6kuvlR B12kHAyTzkH8K6irOcKKKKACiiigAooooAKKKKAPH/hB/wAlD+J3/YVH/o24r2CvH/hB/wAlD+J3 /YVH/o24r2CgAooooAKKKKACiiigArh/iTYXl9/wiP2O0nuPI8S2c83kxl/LjXfudsdFGRkngV3F cv408SXnhz/hHvsccD/2lrdtp83nKTtjk3biuCMNwME5HtQB1FFFFABRRRQAUUUUAFFFFABXD+GL C8t/il49vJrSeO1uv7P+zzPGQku2Bg21jw2DwcdK7iuX0PxJean478V6HNHAtrpH2P7O6KQ7ebEX bcScHBHGAPxoA6iiiigAooooAKKKKACiiigDh/i/YXmp/C3WbOwtJ7u6k8jZDBGZHbE8ZOFHJwAT +FdxXL/ETxJeeEfAmpa5YRwSXVr5WxJ1JQ7pUQ5AIPRj3rqKACiiigAooooAKKKKACiiigDh/sF5 /wAL1/tH7JP9h/4RryPtPlny/M+07tm7puxzjriu4rl/+EkvP+Fp/wDCL+XB9h/sT+0PM2nzPM8/ y8ZzjbjtjOe9dRQAUUUUAFFFFABRRRQAVz/jv/knniX/ALBV1/6Kaugrn/Hf/JPPEv8A2Crr/wBF NQBz/wAEv+SQ6F/28f8ApRJXoFef/BL/AJJDoX/bx/6USV6BQAUUUUAFFFFABRRRQAVw/iewvLj4 peAryG0nktbX+0PtEyRkpFugULuYcLk8DPWu4rl9c8SXmmeO/CmhwxwNa6v9s+0O6kuvlRB12kHA yTzkH8KAOoooooAKKKKACiiigAooooAK4f4QWF5pnwt0azv7Se0uo/P3wzxmN1zPIRlTyMgg/jXc Vy/w78SXni7wJpuuX8cEd1debvSBSEG2V0GAST0Ud6AOoooooAKKKKACiiigAooooA4f4k2F5ff8 Ij9jtJ7jyPEtnPN5MZfy4137nbHRRkZJ4FdxXL+NPEl54c/4R77HHA/9pa3bafN5yk7Y5N24rgjD cDBOR7V1FABRRRQAUUUUAFFFFABRRRQBw/w2sLyx/wCEu+2Wk9v5/iW8nh86Mp5kbbNrrnqpwcEc Gu4rl/BfiS88R/8ACQ/bI4E/s3W7nT4fJUjdHHt2lsk5bk5IwPauooAKKKKACiiigAooooAK4f4v 2F5qfwt1mzsLSe7upPI2QwRmR2xPGThRycAE/hXcVy/xE8SXnhHwJqWuWEcEl1a+VsSdSUO6VEOQ CD0Y96AOoooooAKKKKACiiigAooooAK4fwxYXlv8UvHt5NaTx2t1/Z/2eZ4yEl2wMG2seGweDjpX cVy+h+JLzU/HfivQ5o4FtdI+x/Z3RSHbzYi7biTg4I4wB+NAHUUUUUAFFFFABRRRQAUUUUAYfjSC a68C+Ibe3ikmnl0y5SOONSzOxiYAADkknjFHguCa18C+Hre4ikhni0y2SSORSrIwiUEEHkEHjFWP EupTaN4V1fVLdY2nsrKa4jWQEqWRCwBwQcZHqKPDWpTaz4V0jVLhY1nvbKG4kWMEKGdAxAyScZPq aANSiiigAooooAKKKKACiiigDx/xD/ydD4T/AOwVJ/6DdV7BXj/iH/k6Hwn/ANgqT/0G6r2CgAoo ooAKKKKACiiigAooooA4P4MwTWvwp0e3uIpIZ4nuUkjkUqyMLiQEEHkEHjFd5XF/CjUptZ+HVhql wsaz3txd3EixghQz3UrEDJJxk+prtKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKK KKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigCOCCG1t4re3ijhgiQJHH GoVUUDAAA4AA4xVPWdc0vw9pz3+r38Flarkb5nxuIBO1R1ZsA4UZJxwK0K+WPHU2o/Ez42nw7bXM 4tYbs2MCSBcW6oP38gXIB5R267mAUdgAAfT9hfW+p6dbX9nJ5lrdRJNC+0jcjAFTg8jII615vrPx 88FaRqL2cTX2pbMhprGJWjDAkEBnZd3TOVypBGCap/ESO2+GfwPk0HS5rtknc2MEsoR2xKzySBzg DBTzFBAyMj6jhPgj8M9G8XadqWs6/b/a7WOUWtvAs7x4cAM7NtwejIB83dsjoaAPd/CfjTQvGunN eaLd+b5W0TwupSSFmGQGU/iMjKkg4Jwa6Cvljw0lx8MPj8ui27+fby3a2DAsCXgnKmPc237y7o2O AMlSAcGvqegCOGCG2QpBFHEhdnKooUFmYsx47liST3JJqSiigAooooAKKKKACiiigDn7z/koejf9 gq//APRtpXQVz95/yUPRv+wVf/8Ao20roKACiiigAooooAKKKKACsvxLps2s+FdX0u3aNZ72ymt4 2kJChnQqCcAnGT6GtSsPxpPNa+BfENxbyyQzxaZcvHJGxVkYRMQQRyCDzmgCx4a02bRvCukaXcNG 09lZQ28jRklSyIFJGQDjI9BWpWH4LnmuvAvh64uJZJp5dMtnkkkYszsYlJJJ5JJ5zW5QAUUUUAFF FFABRRRQAVy//CN3n/C0/wDhKPMg+w/2J/Z/l7j5nmef5mcYxtx3znPauorh/t95/wAL1/s77XP9 h/4Rrz/s3mHy/M+07d+3puxxnrigDuKKKKACiiigAooooAKKKKACuX+Hfhu88I+BNN0O/kgkurXz d7wMSh3Su4wSAejDtXUVw/wgv7zU/hbo15f3c93dSefvmnkMjtieQDLHk4AA/CgDuKKKKACiiigA ooooAKKKKAOX1zw3ean478Ka5DJAtrpH2z7QjsQ7ebEEXaAMHBHOSPxrqK4fxPf3lv8AFLwFZw3c 8drdf2h9ohSQhJdsCldyjhsHkZ6V3FABRRRQAUUUUAFFFFABRRRQB4/8IP8AkofxO/7Co/8ARtxX sFeP/CD/AJKH8Tv+wqP/AEbcV7BQAUUUUAFFFFABRRRQAVy/jTw3eeI/+Ee+xyQJ/Zut22oTecxG 6OPduC4By3IwDge9dRXD/Em/vLH/AIRH7Hdz2/n+JbOCbyZCnmRtv3I2OqnAyDwaAO4ooooAKKKK ACiiigAooooAK5fQ/Dd5pnjvxXrk0kDWur/Y/s6IxLr5URRtwIwMk8YJ/Cuorh/DF/eXHxS8e2c1 3PJa2v8AZ/2eF5CUi3QMW2qeFyeTjrQB3FFFFABRRRQAUUUUAFFFFAHL/ETw3eeLvAmpaHYSQR3V 15Wx52IQbZUc5IBPRT2rqK4f4v395pnwt1m8sLue0uo/I2TQSGN1zPGDhhyMgkfjXcUAFFFFABRR RQAUUUUAFFFFAHL/APCN3n/C0/8AhKPMg+w/2J/Z/l7j5nmef5mcYxtx3znPauorh/t95/wvX+zv tc/2H/hGvP8As3mHy/M+07d+3puxxnriu4oAKKKKACiiigAooooAK5/x3/yTzxL/ANgq6/8ARTV0 Fc/47/5J54l/7BV1/wCimoA5/wCCX/JIdC/7eP8A0okr0CvP/gl/ySHQv+3j/wBKJK9AoAKKKKAC iiigAooooAK5fXPDd5qfjvwprkMkC2ukfbPtCOxDt5sQRdoAwcEc5I/Guorh/E9/eW/xS8BWcN3P Ha3X9ofaIUkISXbApXco4bB5GelAHcUUUUAFFFFABRRRQAUUUUAFcv8ADvw3eeEfAmm6HfyQSXVr 5u94GJQ7pXcYJAPRh2rqK4f4QX95qfwt0a8v7ue7upPP3zTyGR2xPIBljycAAfhQB3FFFFABRRRQ AUUUUAFFFFAHL+NPDd54j/4R77HJAn9m63bahN5zEbo4924LgHLcjAOB711FcP8AEm/vLH/hEfsd 3Pb+f4ls4JvJkKeZG2/cjY6qcDIPBruKACiiigAooooAKKKKACiiigDl/Bfhu88Of8JD9skgf+0t budQh8lidscm3aGyBhuDkDI966iuH+G1/eX3/CXfbLue48jxLeQQ+dIX8uNdm1Fz0UZOAOBXcUAF FFFABRRRQAUUUUAFcv8AETw3eeLvAmpaHYSQR3V15Wx52IQbZUc5IBPRT2rqK4f4v395pnwt1m8s Lue0uo/I2TQSGN1zPGDhhyMgkfjQB3FFFFABRRRQAUUUUAFFFFABXL6H4bvNM8d+K9cmkga11f7H 9nRGJdfKiKNuBGBknjBP4V1FcP4Yv7y4+KXj2zmu55LW1/s/7PC8hKRboGLbVPC5PJx1oA7iiiig AooooAKKKKACiiigDL8S6bNrPhXV9Lt2jWe9spreNpCQoZ0KgnAJxk+ho8NabNo3hXSNLuGjaeys obeRoySpZECkjIBxkegqv40nmtfAviG4t5ZIZ4tMuXjkjYqyMImIII5BB5zR4LnmuvAvh64uJZJp 5dMtnkkkYszsYlJJJ5JJ5zQBuUUUUAFFFFABRRRQAUUUUAeP+If+TofCf/YKk/8AQbqvYK8f8Q/8 nQ+E/wDsFSf+g3VewUAFFFFABRRRQAUUUUAFFFFAHF/CjTZtG+HVhpdw0bT2Vxd28jRklSyXUqkj IBxkegrtK4P4MzzXXwp0e4uJZJp5XuXkkkYszsbiQkknkknnNd5QAUUUUAFFFFABRRRQAUUUUAFF FFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUU UAFfKmqXk3w1/aButY1S0kmg+2zXaiLI8yGcP8yFgAxUOQR03IVz3r6rrn/FngvQvGunLZ61aeb5 W4wTIxSSFmGCVYfgcHKkgZBwKAPnT42fEDSPG2qaZb6L5k1ppySH7UylBK0mzIVWAIC7AMnGSTxg An2/wfZ6b8LvhlYQ69d2lg6I0t3I+1C0zAuU4J8x1UbBjJYIMDoKr+F/gr4Q8LaompQxXd/dxOrw PfSq4hYZ5VVVQTyDlgcFQRgitzx/4Lt/Hnhd9Hnn+zSCVJoLjYX8p1OCdoZd2VLLyf4s9QKAPnjR bq8+JHx+ttXsrfZGdQjvDuQgR28BXaXxuwxVFHXBdgMgGvq+uT8GfDnw54FR20i2ka7lTZLeXD75 XXcTjOAFHThQM7VzkjNdZQAUUUUAFFFFABRRRQAUUUUAc/ef8lD0b/sFX/8A6NtK6CufvP8Akoej f9gq/wD/AEbaV0FABRRRQAUUUUAFFFFABWfrtrZ33h7U7PUbj7PYz2ksVxNvCeXGyEM248DAJOTw K0K5/wAd/wDJPPEv/YKuv/RTUAaGhWtnY+HtMs9OuPtFjBaRRW828P5kaoArbhwcgA5HBrQrn/An /JPPDX/YKtf/AEUtdBQAUUUUAFFFFABRRRQAVz/9laP/AMLD/tf7f/xO/wCyvsv2Lzk/49/N3eZs xu+/xuzjt1roK8//AObhf+5U/wDbugD0CiiigAooooAKKKKACiiigArn/BOlaPonhCx07QL/AO36 ZD5nk3PnJLvzIzN8yAKcMWHHpXQV5/8ABL/kkOhf9vH/AKUSUAegUUUUAFFFFABRRRQAUUUUAc/q +laPd+L/AA5qN7f+Tqdj9p+wW3nIv2jfGFk+Ujc21cH5cY710Fef+Lf+SvfDr/uJ/wDpOtegUAFF FFABRRRQAUUUUAFFFFAHj/wg/wCSh/E7/sKj/wBG3FewV4/8IP8AkofxO/7Co/8ARtxXsFABRRRQ AUUUUAFFFFABXP8AirStH1T+xP7Xv/sf2XVYLqz/AHyR+dcLu2R/MDuzk/KOTjiugrz/AOKf/Mlf 9jXY/wDs9AHoFFFFABRRRQAUUUUAFFFFABXP6RpWj2ni/wAR6jZX/nanffZvt9t5yN9n2RlY/lA3 LuXJ+bOe1dBXn/hL/kr3xF/7hn/pO1AHoFFFFABRRRQAUUUUAFFFFAHP+NtK0fW/CF9p2v3/ANg0 yby/OufOSLZiRWX5nBUZYKOfWugrz/42/wDJIdd/7d//AEojr0CgAooooAKKKKACiiigAooooA5/ +ytH/wCFh/2v9v8A+J3/AGV9l+xecn/Hv5u7zNmN33+N2cdutdBXn/8AzcL/ANyp/wC3degUAFFF FABRRRQAUUUUAFc/47/5J54l/wCwVdf+imroK5/x3/yTzxL/ANgq6/8ARTUAc/8ABL/kkOhf9vH/ AKUSV6BXn/wS/wCSQ6F/28f+lElegUAFFFFABRRRQAUUUUAFc/q+laPd+L/Dmo3t/wCTqdj9p+wW 3nIv2jfGFk+Ujc21cH5cY710Fef+Lf8Akr3w6/7if/pOtAHoFFFFABRRRQAUUUUAFFFFABXP+CdK 0fRPCFjp2gX/ANv0yHzPJufOSXfmRmb5kAU4YsOPSugrz/4Jf8kh0L/t4/8ASiSgD0CiiigAoooo AKKKKACiiigDn/FWlaPqn9if2vf/AGP7LqsF1Z/vkj864Xdsj+YHdnJ+UcnHFdBXn/xT/wCZK/7G ux/9nr0CgAooooAKKKKACiiigAooooA5/wAK6Vo+l/23/ZF/9s+1arPdXn75JPJuG274/lA24wPl PIzzXQV5/wDCz/mdf+xrvv8A2SvQKACiiigAooooAKKKKACuf8baVo+t+EL7Ttfv/sGmTeX51z5y RbMSKy/M4KjLBRz610Fef/G3/kkOu/8Abv8A+lEdAHoFFFFABRRRQAUUUUAFFFFABXP6RpWj2ni/ xHqNlf8AnanffZvt9t5yN9n2RlY/lA3LuXJ+bOe1dBXn/hL/AJK98Rf+4Z/6TtQB6BRRRQAUUUUA FFFFABRRRQBn67a2d94e1Oz1G4+z2M9pLFcTbwnlxshDNuPAwCTk8CjQrWzsfD2mWenXH2ixgtIo rebeH8yNUAVtw4OQAcjg1n+O/wDknniX/sFXX/opqPAn/JPPDX/YKtf/AEUtAHQUUUUAFFFFABRR RQAUUUUAeP8AiH/k6Hwn/wBgqT/0G6r2CvH/ABD/AMnQ+E/+wVJ/6DdV7BQAUUUUAFFFFABRRRQA UUUUAcf8MLWzsfAVrZ6dcfaLGC7vYrebeH8yNbqUK24cHIAORwa7CvP/AIJf8kh0L/t4/wDSiSvQ KACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoooo AKKKKACiiigAooooAKKKKACiiigArwf4ieJfitp/jvUrXw1b6q+kJ5X2cwaSsyHMSFsOYzn5i3fj pXvFFAHzB/wmXxz/AOfXXP8AwRL/APGap6l8SPjDo1utxqk2pWMDOEWS60iOJS2CcAtEBnAJx7Gv quo54Ibq3lt7iKOaCVCkkcihldSMEEHggjjFAHzh4N8dfFnXNe0SWVtSudFuL2JJ500lPKaLzAsn 7xY8AAbgSDxg9MV9J182eHLpfhj+0Dd+H7R5H0m/uEtTCu75BMFeHgvyUZwu45O0ucZOK+k6ACii uH+Jnjx/BWj2senW/wBr13UZRFp9qYWkWQhl35CkHowAAOSzLwRnAB3FFeJzn42+HNGl8Q3+r6Nf QWlubifTpI03bduWBKRoCUGT8r87eN3Q9p/wsqz/AOFUf8J5/Z8/k+Vn7JvG7zPM8rbu/u7/AOLG dvO3Py0AdxRXh9inxv17Q49fs9d0q3hvIjdW9gIot+xssiqTEw5GMbn7jcQc12ngv4kw+JfhzeeK byzkgfTUlF7FDghmijDsY8noVIwCeDkZONxAO8orw/R9Q+L/AI+s38R6HrGlaNpNzK4tbSZUchFO 3OfKcnkEEkjJBIAGK7D4W+N9R8U2epaVrtr5Ou6JKLa9dCuyVssu4bTgNlGBA+XuODgAHQXn/JQ9 G/7BV/8A+jbSugrn7z/koejf9gq//wDRtpXQUAFFFFABRRRQAUUUUAFZ+u3VnY+HtTvNRt/tFjBa Sy3EOwP5kaoSy7TwcgEYPBrQrD8aQTXXgXxDb28Uk08umXKRxxqWZ2MTAAAckk8YoAuaFdWd94e0 y8063+z2M9pFLbw7AnlxsgKrtHAwCBgcCtCsPwXBNa+BfD1vcRSQzxaZbJJHIpVkYRKCCDyCDxit ygAooooAKKKKACiiigArn/7V0f8A4WH/AGR9g/4nf9lfavtvkp/x7+bt8vfnd9/nbjHfrXQVw/2C 8/4Xr/aP2Sf7D/wjXkfafLPl+Z9p3bN3TdjnHXFAHcUUUUAFFFFABRRRQAUUUUAFc/4J1XR9b8IW Oo6BYfYNMm8zybbyUi2YkZW+VCVGWDHj1roK4f4QWF5pnwt0azv7Se0uo/P3wzxmN1zPIRlTyMgg /jQB3FFFFABRRRQAUUVUvtK07U/L+32Frd+XnZ58Kybc4zjI4zgflSd+hUeVv3np/XoQ6bdTXF/q 8cr7kt7tY4hgDapgifHv8zMefWtGuY03wto32/V/P0Gw8v7Wvkb7NMbPIiztyOm7d07575rpIoo4 IUhhjWOKNQqIgwqgcAADoKmDlbU3xMaSkvZvoului82YWr6ro9p4v8Oade2HnanffafsFz5KN9n2 RhpPmJ3LuXA+XOe9dBXD+J7C8uPil4CvIbSeS1tf7Q+0TJGSkW6BQu5hwuTwM9a7irOYKKKKACii igAooooAKKKKAPH/AIQf8lD+J3/YVH/o24r2CvH/AIQf8lD+J3/YVH/o24r2CgAooooAKKKKACii igArn/FWq6Ppf9if2vYfbPtWqwWtn+5STybht2yT5iNuMH5hyM8V0FcP8SbC8vv+ER+x2k9x5HiW znm8mMv5ca79ztjooyMk8CgDuKKKKACiiigAooooAKKKKACuf0jVdHu/F/iPTrKw8nU7H7N9vufJ RftG+MtH8wO5tq5HzYx2roK4fwxYXlv8UvHt5NaTx2t1/Z/2eZ4yEl2wMG2seGweDjpQB3FFFFAB RRRQAUUUUAFFFFAHP+NtV0fRPCF9qOv2H2/TIfL8628lJd+ZFVflchThip59K6CuH+L9hean8LdZ s7C0nu7qTyNkMEZkdsTxk4UcnABP4V3FABRRRQAUUUUAFFFFABRRRQBz/wDauj/8LD/sj7B/xO/7 K+1fbfJT/j383b5e/O77/O3GO/Wugrh/sF5/wvX+0fsk/wBh/wCEa8j7T5Z8vzPtO7Zu6bsc464r uKACiiigAooooAKKKKACuf8AHf8AyTzxL/2Crr/0U1dBXP8Ajv8A5J54l/7BV1/6KagDn/gl/wAk h0L/ALeP/SiSvQK8/wDgl/ySHQv+3j/0okr0CgAooooAKKKKACiiigArn9X1XR7Txf4c069sPO1O ++0/YLnyUb7PsjDSfMTuXcuB8uc966CuH8T2F5cfFLwFeQ2k8lra/wBofaJkjJSLdAoXcw4XJ4Ge tAHcUUUUAFFFFABRRRQAUUUUAFc/4J1XR9b8IWOo6BYfYNMm8zybbyUi2YkZW+VCVGWDHj1roK4f 4QWF5pnwt0azv7Se0uo/P3wzxmN1zPIRlTyMgg/jQB3FFFFABRRRQAUUUUAFFFFAHP8AirVdH0v+ xP7XsPtn2rVYLWz/AHKSeTcNu2SfMRtxg/MORniugrh/iTYXl9/wiP2O0nuPI8S2c83kxl/LjXfu dsdFGRkngV3FABRRRQAUUUUAFFFFABRRRQBz/hXVdH1T+2/7IsPsf2XVZ7W8/cpH51wu3fJ8pO7O R8x5OOa6CuH+G1heWP8Awl32y0nt/P8AEt5PD50ZTzI22bXXPVTg4I4NdxQAUUUUAFFFFABRRRQA Vz/jbVdH0Twhfajr9h9v0yHy/OtvJSXfmRVX5XIU4YqefSugrh/i/YXmp/C3WbOwtJ7u6k8jZDBG ZHbE8ZOFHJwAT+FAHcUUUUAFFFFABRRRQAUUUUAFc/pGq6Pd+L/EenWVh5Op2P2b7fc+Si/aN8Za P5gdzbVyPmxjtXQVw/hiwvLf4pePbya0njtbr+z/ALPM8ZCS7YGDbWPDYPBx0oA7iiiigAooooAK KKKACiiigDP126s7Hw9qd5qNv9osYLSWW4h2B/MjVCWXaeDkAjB4NGhXVnfeHtMvNOt/s9jPaRS2 8OwJ5cbICq7RwMAgYHAqn40gmuvAviG3t4pJp5dMuUjjjUszsYmAAA5JJ4xR4LgmtfAvh63uIpIZ 4tMtkkjkUqyMIlBBB5BB4xQBuUUUUAFFFFABRRRQAUUUUAeP+If+TofCf/YKk/8AQbqvYK8f8Q/8 nQ+E/wDsFSf+g3VewUAFFFFABRRRQAUUUUAFFFFAHH/DC6s77wFa3mnW/wBnsZ7u9lt4dgTy42up Sq7RwMAgYHArsK4P4MwTWvwp0e3uIpIZ4nuUkjkUqyMLiQEEHkEHjFd5QAUUUUAFFFFABRRRQAUU UUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRR QAUUUUAFeP8Ajb46f8Id4vvtA/4Rz7Z9l8v9/wDbvL3bo1f7vlnGN2OvavYKx77wn4b1O8kvL/w/ pV3dSY3zT2UcjtgADLEZOAAPwoA8X/4aa/6lH/ypf/aqZP8AtMzNbyrb+FI45yhEbyX5dVbHBKiM EjPbIz6ivY/+EE8H/wDQqaH/AOC6H/4mj/hBPB//AEKmh/8Aguh/+JoA+dPhboWtePvibB4j1V7u aC2uPttzfMpCvLGVKRq20rnJj+TjCA4xgV9V1HBBDa28VvbxRwwRIEjjjUKqKBgAAcAAcYqSgAoo rg/ihd+NNL0uw1XwcZJ3trgC8sEtVmNxGcYP9/AIwQnOHJyNuaAOX+K/hr4l6sNWl0jVo5PD4RWj 0y1YpcSL5YWRTtQFwSXOwucjGATgVyHjvX9I8Q/ADRJtG06PTbe21gWzWSMXEDLHKcbyo3kqyuW7 ljkk5rq/+Gg7PU9O+zaB4b1W68QyxfubTyhJH5mMtyjb2VRuPCgkD+HORHH8Ib5PgVN4faGOTxA9 x/aSxNP8kc/C7FYYGfKBXnK7mJzjBAB7ZXzBff8AID+Nf/YVt/8A0tkrr7H9oaw0/Q47TW9H1VvE NtEYrlCkaI86ZB3HIKZIyRs+XJGDjm54O+HOpah8MvEy+IraNNe8TO9yxmdkKtjfCZFUYQiUs5UD owBHG0AHongT/knnhr/sFWv/AKKWvP8Aw9/ydD4s/wCwVH/6Da1j+GPjLB4H0OHwt4w0nVU1fSv9 FbyY4mBjX/V/xL0XABGQwAbcd1dB8JdL1TVtc134ha3ZfZpta2rp6u/zpbehAABUhYgGIydmejZY A6zXr2ex8daJLb6Zd6g50y+UxWrRKwHm2nzHzHQY4x1zyOOuLn/CQ6p/0Jmuf9/rL/5IovP+Sh6N /wBgq/8A/RtpXQUAY9jrN/d3kcE3hnVbKNs5nnktSiYBPISZm56cA9fTmi+1m/tLySCHwzqt7GuM TwSWoR8gHgPMrcdOQOnpzWxRQBn6ZqN1f+b9p0a+03Zjb9reBvMznOPKkfpjvjqMZ5xn/wDCQ6p/ 0Jmuf9/rL/5IroKKAM/+0br+x/tv9jX32j/nw3wed97HXzPL6fN9/p78Vn/8JDqn/Qma5/3+sv8A 5IroKKAM/U9RurDyvs2jX2pb87vsjwL5eMYz5sidc9s9DnHGcPV/Feq2Og6per4X1K1e1sp7hJru S2aIMkbOAwjnLkEqBwO/bqOsrL8S6bNrPhXV9Lt2jWe9spreNpCQoZ0KgnAJxk+hoAx9I8V6rfaD pd63hfUrp7qyguHmtJLZYizxq5CiScOACxHI7d+p3NM1G6v/ADftOjX2m7MbftbwN5mc5x5Uj9Md 8dRjPOI/DWmzaN4V0jS7ho2nsrKG3kaMkqWRApIyAcZHoK1KAOf/AOEh1T/oTNc/7/WX/wAkVof2 jdf2P9t/sa++0f8APhvg8772OvmeX0+b7/T34rQooA5//hIdU/6EzXP+/wBZf/JFaGp6jdWHlfZt GvtS353fZHgXy8YxnzZE657Z6HOOM6FFAGPY6zf3d5HBN4Z1WyjbOZ55LUomATyEmZuenAPX05ov tZv7S8kgh8M6rexrjE8ElqEfIB4DzK3HTkDp6c1sUUAZ+majdX/m/adGvtN2Y2/a3gbzM5zjypH6 Y746jGeccf8A8J7rf/Cw/wCwP+EVvvs/9lfbfI3232nd5uzdu8/y/LxxjO7PbFegVy//AAjd5/wt P/hKPMg+w/2J/Z/l7j5nmef5mcYxtx3znPagDY/tG6/sf7b/AGNffaP+fDfB533sdfM8vp833+nv xWf/AMJDqn/Qma5/3+sv/kiugooAz9T1G6sPK+zaNfalvzu+yPAvl4xjPmyJ1z2z0OccZr2Os393 eRwTeGdVso2zmeeS1KJgE8hJmbnpwD19Oa2KKAMe+1m/tLySCHwzqt7GuMTwSWoR8gHgPMrcdOQO npzVjTNRur/zftOjX2m7MbftbwN5mc5x5Uj9Md8dRjPONCigDn/+Eh1T/oTNc/7/AFl/8kVof2jd f2P9t/sa++0f8+G+DzvvY6+Z5fT5vv8AT34rQooA5/8A4SHVP+hM1z/v9Zf/ACRWP4O8aatr3gTS Ncm0Ge9ur3zvNTTTEiRbJWQcTSqeQOxPQ9OK7iuX+Hfhu88I+BNN0O/kgkurXzd7wMSh3Su4wSAe jDtQBoWOs393eRwTeGdVso2zmeeS1KJgE8hJmbnpwD19OaL7Wb+0vJIIfDOq3sa4xPBJahHyAeA8 ytx05A6enNbFFAGfpmo3V/5v2nRr7TdmNv2t4G8zOc48qR+mO+OoxnnGf/wkOqf9CZrn/f6y/wDk iugooAz/AO0br+x/tv8AY199o/58N8Hnfex18zy+nzff6e/FZ/8AwkOqf9CZrn/f6y/+SK6CigDP 1PUbqw8r7No19qW/O77I8C+XjGM+bInXPbPQ5xxmvY6zf3d5HBN4Z1WyjbOZ55LUomATyEmZuenA PX05rYooA4fxJ401bRvHegaHa6DPc2uofaN7gxb5/LiDjySZVC7Sfm8wDOPlzXUaZqN1f+b9p0a+ 03Zjb9reBvMznOPKkfpjvjqMZ5xj654bvNT8d+FNchkgW10j7Z9oR2IdvNiCLtAGDgjnJH411FAH P/8ACQ6p/wBCZrn/AH+sv/kitD+0br+x/tv9jX32j/nw3wed97HXzPL6fN9/p78VoUUAc/8A8JDq n/Qma5/3+sv/AJIrQ1PUbqw8r7No19qW/O77I8C+XjGM+bInXPbPQ5xxnQooAx7HWb+7vI4JvDOq 2UbZzPPJalEwCeQkzNz04B6+nNF9rN/aXkkEPhnVb2NcYngktQj5APAeZW46cgdPTmtiigDP0zUb q/8AN+06Nfabsxt+1vA3mZznHlSP0x3x1GM84z/+Eh1T/oTNc/7/AFl/8kV0FFAHifwmvZ4vF/xN u00y7mnOpo32JGiEoJmnyuWcJkZ5+bHBwTxn0z/hIdU/6EzXP+/1l/8AJFef/CD/AJKH8Tv+wqP/ AEbcV7BQBn6nqN1YeV9m0a+1Lfnd9keBfLxjGfNkTrntnoc44zXsdZv7u8jgm8M6rZRtnM88lqUT AJ5CTM3PTgHr6c1sUUAY99rN/aXkkEPhnVb2NcYngktQj5APAeZW46cgdPTmrGmajdX/AJv2nRr7 TdmNv2t4G8zOc48qR+mO+OoxnnGhRQBz/wDwkOqf9CZrn/f6y/8AkitD+0br+x/tv9jX32j/AJ8N 8Hnfex18zy+nzff6e/FaFFAHP/8ACQ6p/wBCZrn/AH+sv/kis/x74s1Hwr/wj/8AZ+nfbP7R1WGy lzt4Vs/KuXXEjfwk/KMHcRxnsK5fxp4bvPEf/CPfY5IE/s3W7bUJvOYjdHHu3BcA5bkYBwPegDQs dZv7u8jgm8M6rZRtnM88lqUTAJ5CTM3PTgHr6c0X2s39peSQQ+GdVvY1xieCS1CPkA8B5lbjpyB0 9Oa2KKAM/TNRur/zftOjX2m7MbftbwN5mc5x5Uj9Md8dRjPOM/8A4SHVP+hM1z/v9Zf/ACRXQUUA Z/8AaN1/Y/23+xr77R/z4b4PO+9jr5nl9Pm+/wBPfis//hIdU/6EzXP+/wBZf/JFdBRQBn6nqN1Y eV9m0a+1Lfnd9keBfLxjGfNkTrntnoc44zXsdZv7u8jgm8M6rZRtnM88lqUTAJ5CTM3PTgHr6c1s UUAY99rN/aXkkEPhnVb2NcYngktQj5APAeZW46cgdPTmsfwr4s1HXvF/ijSb3TvsMOlfZPJik2mb 97GzN5hR3Q8gEbT0PPNdhXL6H4bvNM8d+K9cmkga11f7H9nRGJdfKiKNuBGBknjBP4UAWP8AhIdU /wChM1z/AL/WX/yRWh/aN1/Y/wBt/sa++0f8+G+DzvvY6+Z5fT5vv9PfitCigDn/APhIdU/6EzXP +/1l/wDJFaGp6jdWHlfZtGvtS353fZHgXy8YxnzZE657Z6HOOM6FFAGPY6zf3d5HBN4Z1WyjbOZ5 5LUomATyEmZuenAPX05ovtZv7S8kgh8M6rexrjE8ElqEfIB4DzK3HTkDp6c1sUUAZ+majdX/AJv2 nRr7TdmNv2t4G8zOc48qR+mO+OoxnnGf/wAJDqn/AEJmuf8Af6y/+SK6CigDj/G3izUfDnw4vvEd tp32e+g8vba3+19u6ZUO7ynIPByMN6Z7itD/AISHVP8AoTNc/wC/1l/8kVX+Inhu88XeBNS0Owkg jurrytjzsQg2yo5yQCeintXUUAZ+p6jdWHlfZtGvtS353fZHgXy8YxnzZE657Z6HOOM17HWb+7vI 4JvDOq2UbZzPPJalEwCeQkzNz04B6+nNbFFAGPfazf2l5JBD4Z1W9jXGJ4JLUI+QDwHmVuOnIHT0 5qxpmo3V/wCb9p0a+03Zjb9reBvMznOPKkfpjvjqMZ5xoUUAc/8A8JDqn/Qma5/3+sv/AJIrQ/tG 6/sf7b/Y199o/wCfDfB533sdfM8vp833+nvxWhRQBz//AAkOqf8AQma5/wB/rL/5IrQ1PUbqw8r7 No19qW/O77I8C+XjGM+bInXPbPQ5xxnQooA4ex8aatd/E6Pw1NoM9lZtpRvSZzEZkYSFdxKSsvln 7uAC249NvNdBfazf2l5JBD4Z1W9jXGJ4JLUI+QDwHmVuOnIHT05rP/4Ru8/4Wn/wlHmQfYf7E/s/ y9x8zzPP8zOMY2475zntXUUAZ+majdX/AJv2nRr7TdmNv2t4G8zOc48qR+mO+OoxnnGf/wAJDqn/ AEJmuf8Af6y/+SK6CigDP/tG6/sf7b/Y199o/wCfDfB533sdfM8vp833+nvxWf8A8JDqn/Qma5/3 +sv/AJIroKKAM/U9RurDyvs2jX2pb87vsjwL5eMYz5sidc9s9DnHGa9jrN/d3kcE3hnVbKNs5nnk tSiYBPISZm56cA9fTmtiigDHvtZv7S8kgh8M6rexrjE8ElqEfIB4DzK3HTkDp6c1j+KNRur/AOHn iv7To19puzSrnb9reBvMzE+ceVI/THfHUYzzjsK5/wAd/wDJPPEv/YKuv/RTUAcP8INZv7T4W6NB D4Z1W9jXz8TwSWoR8zyHgPMrcdOQOnpzXpH9o3X9j/bf7GvvtH/Phvg8772OvmeX0+b7/T34rj/g l/ySHQv+3j/0okr0CgDn/wDhIdU/6EzXP+/1l/8AJFaGp6jdWHlfZtGvtS353fZHgXy8YxnzZE65 7Z6HOOM6FFAGPY6zf3d5HBN4Z1WyjbOZ55LUomATyEmZuenAPX05ovtZv7S8kgh8M6rexrjE8Elq EfIB4DzK3HTkDp6c1sUUAZ+majdX/m/adGvtN2Y2/a3gbzM5zjypH6Y746jGecZ//CQ6p/0Jmuf9 /rL/AOSK6CigDP8A7Ruv7H+2/wBjX32j/nw3wed97HXzPL6fN9/p78Vx+r+PdbsfF/hzSY/Ct8kO pfafMime2M0nlxhh5RWfYME5beRkdOa9Arl9c8N3mp+O/CmuQyQLa6R9s+0I7EO3mxBF2gDBwRzk j8aANjU9RurDyvs2jX2pb87vsjwL5eMYz5sidc9s9DnHGa9jrN/d3kcE3hnVbKNs5nnktSiYBPIS Zm56cA9fTmtiigDHvtZv7S8kgh8M6rexrjE8ElqEfIB4DzK3HTkDp6c1Y0zUbq/837To19puzG37 W8DeZnOceVI/THfHUYzzjQooA5//AISHVP8AoTNc/wC/1l/8kVof2jdf2P8Abf7GvvtH/Phvg877 2OvmeX0+b7/T34rQooA5/wD4SHVP+hM1z/v9Zf8AyRWhqeo3Vh5X2bRr7Ut+d32R4F8vGMZ82ROu e2ehzjjOhRQBj2Os393eRwTeGdVso2zmeeS1KJgE8hJmbnpwD19Oa5fwT491vxH4QsdWufCt9cTT +ZulsHtkhbbIyjaJZw44GDkdc44xXoFcv8O/Dd54R8Cabod/JBJdWvm73gYlDuldxgkA9GHagDY0 zUbq/wDN+06Nfabsxt+1vA3mZznHlSP0x3x1GM84z/8AhIdU/wChM1z/AL/WX/yRXQUUAZ/9o3X9 j/bf7GvvtH/Phvg8772OvmeX0+b7/T34rP8A+Eh1T/oTNc/7/WX/AMkV0FFAGfqeo3Vh5X2bRr7U t+d32R4F8vGMZ82ROue2ehzjjNex1m/u7yOCbwzqtlG2czzyWpRMAnkJMzc9OAevpzWxRQBj32s3 9peSQQ+GdVvY1xieCS1CPkA8B5lbjpyB09OasaZqN1f+b9p0a+03Zjb9reBvMznOPKkfpjvjqMZ5 xoUUAef+KvHut6J/YnkeFb6H7dqsFk/2t7Zt6vuysflznEhxwWwvXJrsP7Ruv7H+2/2NffaP+fDf B533sdfM8vp833+nvxWP408N3niP/hHvsckCf2brdtqE3nMRujj3bguActyMA4HvXUUAc/8A8JDq n/Qma5/3+sv/AJIrQ1PUbqw8r7No19qW/O77I8C+XjGM+bInXPbPQ5xxnQooAx7HWb+7vI4JvDOq 2UbZzPPJalEwCeQkzNz04B6+nNF9rN/aXkkEPhnVb2NcYngktQj5APAeZW46cgdPTmtiigDP0zUb q/8AN+06Nfabsxt+1vA3mZznHlSP0x3x1GM84z/+Eh1T/oTNc/7/AFl/8kV0FFAGf/aN1/Y/23+x r77R/wA+G+DzvvY6+Z5fT5vv9Pfis/8A4SHVP+hM1z/v9Zf/ACRXQUUAcP4e8aatqn9ub9BnvvsG t3Wnx/2eYk2xxbNpfzpVyx3HleOOg79BY6zf3d5HBN4Z1WyjbOZ55LUomATyEmZuenAPX05rP8F+ G7zw5/wkP2ySB/7S1u51CHyWJ2xybdobIGG4OQMj3rqKAMe+1m/tLySCHwzqt7GuMTwSWoR8gHgP MrcdOQOnpzVjTNRur/zftOjX2m7MbftbwN5mc5x5Uj9Md8dRjPONCigDn/8AhIdU/wChM1z/AL/W X/yRWh/aN1/Y/wBt/sa++0f8+G+DzvvY6+Z5fT5vv9PfitCigDn/APhIdU/6EzXP+/1l/wDJFaGp 6jdWHlfZtGvtS353fZHgXy8YxnzZE657Z6HOOM6FFAGPY6zf3d5HBN4Z1WyjbOZ55LUomATyEmZu enAPX05rn/iJ401bwj4c1K/sNBnka18rZeTmI2x3OgOVEol/iI+719ua7iuX+Inhu88XeBNS0Owk gjurrytjzsQg2yo5yQCeintQBsaZqN1f+b9p0a+03Zjb9reBvMznOPKkfpjvjqMZ5xn/APCQ6p/0 Jmuf9/rL/wCSK6CigDP/ALRuv7H+2/2NffaP+fDfB533sdfM8vp833+nvxWf/wAJDqn/AEJmuf8A f6y/+SK6CigDP1PUbqw8r7No19qW/O77I8C+XjGM+bInXPbPQ5xxmvY6zf3d5HBN4Z1WyjbOZ55L UomATyEmZuenAPX05rYooAx77Wb+0vJIIfDOq3sa4xPBJahHyAeA8ytx05A6enNWNM1G6v8AzftO jX2m7MbftbwN5mc5x5Uj9Md8dRjPONCigDn/APhIdU/6EzXP+/1l/wDJFY+h+NNW1PxH4rsJtBnV dI+x/Z7NDELlvNQltzGXyjjGRhhx6niu4rl9D8N3mmeO/FeuTSQNa6v9j+zojEuvlRFG3AjAyTxg n8KALH/CQ6p/0Jmuf9/rL/5IrQ1PUbqw8r7No19qW/O77I8C+XjGM+bInXPbPQ5xxnQooAx7HWb+ 7vI4JvDOq2UbZzPPJalEwCeQkzNz04B6+nNF9rN/aXkkEPhnVb2NcYngktQj5APAeZW46cgdPTmt iigDP0zUbq/837To19puzG37W8DeZnOceVI/THfHUYzzjP8A+Eh1T/oTNc/7/WX/AMkV0FFAGf8A 2jdf2P8Abf7GvvtH/Phvg8772OvmeX0+b7/T34rP/wCEh1T/AKEzXP8Av9Zf/JFdBRQBz/jHXr3w 74evr+x0qe9khtJpg6mPy4SiZBkDSKxX/cycA98Zr+FPE+pa9pOk3N34dvrf7ZaRzSXYe38jLRhs qBM0m0nplc8jOOa1PEumzaz4V1fS7do1nvbKa3jaQkKGdCoJwCcZPoaPDWmzaN4V0jS7ho2nsrKG 3kaMkqWRApIyAcZHoKAI77Wb+0vJIIfDOq3sa4xPBJahHyAeA8ytx05A6enNWNM1G6v/ADftOjX2 m7MbftbwN5mc5x5Uj9Md8dRjPONCigDn/wDhIdU/6EzXP+/1l/8AJFaH9o3X9j/bf7GvvtH/AD4b 4PO+9jr5nl9Pm+/09+K0KKAOf/4SHVP+hM1z/v8AWX/yRWhqeo3Vh5X2bRr7Ut+d32R4F8vGMZ82 ROue2ehzjjOhRQBj2Os393eRwTeGdVso2zmeeS1KJgE8hJmbnpwD19OaL7Wb+0vJIIfDOq3sa4xP BJahHyAeA8ytx05A6enNbFFAHieoXs99+0z4VluNMu9PcaZIoiumiZiNlz8w8t3GOcdc8Hjpn0z/ AISHVP8AoTNc/wC/1l/8kV5/4h/5Oh8J/wDYKk/9Buq9goAz/wC0br+x/tv9jX32j/nw3wed97HX zPL6fN9/p78Vn/8ACQ6p/wBCZrn/AH+sv/kiugooAz9T1G6sPK+zaNfalvzu+yPAvl4xjPmyJ1z2 z0OccZr2Os393eRwTeGdVso2zmeeS1KJgE8hJmbnpwD19Oa2KKAMe+1m/tLySCHwzqt7GuMTwSWo R8gHgPMrcdOQOnpzVjTNRur/AM37To19puzG37W8DeZnOceVI/THfHUYzzjQooA5/wD4SHVP+hM1 z/v9Zf8AyRR/wkOqf9CZrn/f6y/+SK6CigDi/hRqU2s/Dqw1S4WNZ724u7iRYwQoZ7qViBkk4yfU 12lcX8KNNm0b4dWGl3DRtPZXF3byNGSVLJdSqSMgHGR6Cu0oAKKKKACiiigAooooAKKKKACiiigA ooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACi iigAooooAKKKKACiiigAooooAKKKKACiiigDn7z/AJKHo3/YKv8A/wBG2ldBXP3n/JQ9G/7BV/8A +jbSugoAKKKKACiiigAooooAKw/Gk81r4F8Q3FvLJDPFply8ckbFWRhExBBHIIPOa3Kz9dtbO+8P anZ6jcfZ7Ge0liuJt4Ty42Qhm3HgYBJyeBQBT8FzzXXgXw9cXEsk08umWzySSMWZ2MSkkk8kk85r crP0K1s7Hw9plnp1x9osYLSKK3m3h/MjVAFbcODkAHI4NaFABRRRQAUUUUAFFFFABXD/AG+8/wCF 6/2d9rn+w/8ACNef9m8w+X5n2nbv29N2OM9cV3Fc/wD2Vo//AAsP+1/t/wDxO/7K+y/YvOT/AI9/ N3eZsxu+/wAbs47daAOgooooAKKKKACiiigAooooAK4f4QX95qfwt0a8v7ue7upPP3zTyGR2xPIB ljycAAfhXcVz/gnStH0TwhY6doF/9v0yHzPJufOSXfmRmb5kAU4YsOPSgDoKKKKACiiigAooooAK KKKAOH8T395b/FLwFZw3c8drdf2h9ohSQhJdsCldyjhsHkZ6V3Fc/q+laPd+L/Dmo3t/5Op2P2n7 Bbeci/aN8YWT5SNzbVwflxjvXQUAFFFFABRRRQAUUUUAFFFFAHj/AMIP+Sh/E7/sKj/0bcV7BXj/ AMIP+Sh/E7/sKj/0bcV7BQAUUUUAFFFFABRRRQAVw/xJv7yx/wCER+x3c9v5/iWzgm8mQp5kbb9y NjqpwMg8Gu4rn/FWlaPqn9if2vf/AGP7LqsF1Z/vkj864Xdsj+YHdnJ+UcnHFAHQUUUUAFFFFABR RRQAUUUUAFcP4Yv7y4+KXj2zmu55LW1/s/7PC8hKRboGLbVPC5PJx1ruK5/SNK0e08X+I9Rsr/zt Tvvs32+285G+z7Iysfygbl3Lk/NnPagDoKKKKACiiigAooooAKKKKAOH+L9/eaZ8LdZvLC7ntLqP yNk0Ehjdczxg4YcjIJH413Fc/wCNtK0fW/CF9p2v3/2DTJvL86585ItmJFZfmcFRlgo59a6CgAoo ooAKKKKACiiigAooooA4f7fef8L1/s77XP8AYf8AhGvP+zeYfL8z7Tt37em7HGeuK7iuf/srR/8A hYf9r/b/APid/wBlfZfsXnJ/x7+bu8zZjd9/jdnHbrXQUAFFFFABRRRQAUUUUAFc/wCO/wDknniX /sFXX/opq6Cuf8d/8k88S/8AYKuv/RTUAc/8Ev8AkkOhf9vH/pRJXoFef/BL/kkOhf8Abx/6USV6 BQAUUUUAFFFFABRRRQAVw/ie/vLf4peArOG7njtbr+0PtEKSEJLtgUruUcNg8jPSu4rn9X0rR7vx f4c1G9v/ACdTsftP2C285F+0b4wsnykbm2rg/LjHegDoKKKKACiiigAooooAKKKKACuH+EF/ean8 LdGvL+7nu7qTz9808hkdsTyAZY8nAAH4V3Fc/wCCdK0fRPCFjp2gX/2/TIfM8m585Jd+ZGZvmQBT hiw49KAOgooooAKKKKACiiigAooooA4f4k395Y/8Ij9ju57fz/EtnBN5MhTzI237kbHVTgZB4Ndx XP8AirStH1T+xP7Xv/sf2XVYLqz/AHyR+dcLu2R/MDuzk/KOTjiugoAKKKKACiiigAooooAKKKKA OH+G1/eX3/CXfbLue48jxLeQQ+dIX8uNdm1Fz0UZOAOBXcVz/hXStH0v+2/7Iv8A7Z9q1We6vP3y SeTcNt3x/KBtxgfKeRnmugoAKKKKACiiigAooooAK4f4v395pnwt1m8sLue0uo/I2TQSGN1zPGDh hyMgkfjXcVz/AI20rR9b8IX2na/f/YNMm8vzrnzki2YkVl+ZwVGWCjn1oA6CiiigAooooAKKKKAC iiigArh/DF/eXHxS8e2c13PJa2v9n/Z4XkJSLdAxbap4XJ5OOtdxXP6RpWj2ni/xHqNlf+dqd99m +323nI32fZGVj+UDcu5cn5s57UAdBRRRQAUUUUAFFFFABRRRQBh+NJ5rXwL4huLeWSGeLTLl45I2 KsjCJiCCOQQec0eC55rrwL4euLiWSaeXTLZ5JJGLM7GJSSSeSSec1c121s77w9qdnqNx9nsZ7SWK 4m3hPLjZCGbceBgEnJ4FGhWtnY+HtMs9OuPtFjBaRRW828P5kaoArbhwcgA5HBoA0KKKKACiiigA ooooAKKKKAPH/EP/ACdD4T/7BUn/AKDdV7BXj/iH/k6Hwn/2CpP/AEG6r2CgAooooAKKKKACiiig AooooA4P4MzzXXwp0e4uJZJp5XuXkkkYszsbiQkknkknnNd5XH/DC1s7HwFa2enXH2ixgu72K3m3 h/MjW6lCtuHByADkcGuwoAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAC iiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAPH/8Aho7wf/0Ddc/78Q//AB2j/ho7 wf8A9A3XP+/EP/x2s/4w/B7+1ftHibwzbf8AEw5kvbGNf+Pn1kQf89PVf4uo+b7+R8IfDXw88c6G 9tqWiQDXbPiZEvbhTPHxiYLvwMk4IXIB5+UMooA6f/ho7wf/ANA3XP8AvxD/APHaP+GjvB//AEDd c/78Q/8Ax2ug/wCFJfDz/oXv/J24/wDjlH/Ckvh5/wBC9/5O3H/xygDL0n4++FdZ1mx0u30/WVnv biO3jaSGIKGdgoJxITjJ9DXqlcPYfCDwJpmo21/Z6F5d1aypNC/2uc7XUgqcF8HBA613FABRRRQA UUUUAFFFFABRRRQBz95/yUPRv+wVf/8Ao20roK5+8/5KHo3/AGCr/wD9G2ldBQAUUUUAFFFFABRR RQAVz/jv/knniX/sFXX/AKKaugrP126s7Hw9qd5qNv8AaLGC0lluIdgfzI1Qll2ng5AIweDQBn+B P+SeeGv+wVa/+ilroKz9CurO+8PaZeadb/Z7Ge0ilt4dgTy42QFV2jgYBAwOBWhQAUUUUAFFFFAB RRRQAV5//wA3C/8Acqf+3degVz/9q6P/AMLD/sj7B/xO/wCyvtX23yU/49/N2+Xvzu+/ztxjv1oA 6CiiigAooooAKKKKACiiigArz/4Jf8kh0L/t4/8ASiSvQK5/wTquj634QsdR0Cw+waZN5nk23kpF sxIyt8qEqMsGPHrQB0FFFFABRRRQAUUUUAFFFFAHn/i3/kr3w6/7if8A6TrXoFc/q+q6PaeL/Dmn Xth52p332n7Bc+SjfZ9kYaT5idy7lwPlznvXQUAFFFFABRRRQAUUUUAFFFFAHj/wg/5KH8Tv+wqP /RtxXsFeP/CD/kofxO/7Co/9G3FewUAFFFFABRRRQAUUUUAFef8AxT/5kr/sa7H/ANnr0Cuf8Var o+l/2J/a9h9s+1arBa2f7lJPJuG3bJPmI24wfmHIzxQB0FFFFABRRRQAUUUUAFFFFABXn/hL/kr3 xF/7hn/pO1egVz+karo934v8R6dZWHk6nY/Zvt9z5KL9o3xlo/mB3NtXI+bGO1AHQUUUUAFFFFAB RRRQAUUUUAef/G3/AJJDrv8A27/+lEdegVz/AI21XR9E8IX2o6/Yfb9Mh8vzrbyUl35kVV+VyFOG Knn0roKACiiigAooooAKKKKACiiigDz/AP5uF/7lT/27r0Cuf/tXR/8AhYf9kfYP+J3/AGV9q+2+ Sn/Hv5u3y9+d33+duMd+tdBQAUUUUAFFFFABRRRQAVz/AI7/AOSeeJf+wVdf+imroK5/x3/yTzxL /wBgq6/9FNQBz/wS/wCSQ6F/28f+lElegV5/8Ev+SQ6F/wBvH/pRJXoFABRRRQAUUUUAFFFFABXn /i3/AJK98Ov+4n/6TrXoFc/q+q6PaeL/AA5p17Yedqd99p+wXPko32fZGGk+Yncu5cD5c570AdBR RRQAUUUUAFFFFABRRRQAV5/8Ev8AkkOhf9vH/pRJXoFc/wCCdV0fW/CFjqOgWH2DTJvM8m28lItm JGVvlQlRlgx49aAOgooooAKKKKACiiigAooooA8/+Kf/ADJX/Y12P/s9egVz/irVdH0v+xP7XsPt n2rVYLWz/cpJ5Nw27ZJ8xG3GD8w5GeK6CgAooooAKKKKACiiigAooooA8/8AhZ/zOv8A2Nd9/wCy V6BXP+FdV0fVP7b/ALIsPsf2XVZ7W8/cpH51wu3fJ8pO7OR8x5OOa6CgAooooAKKKKACiiigArz/ AONv/JIdd/7d/wD0ojr0Cuf8baro+ieEL7UdfsPt+mQ+X51t5KS78yKq/K5CnDFTz6UAdBRRRQAU UUUAFFFFABRRRQAV5/4S/wCSvfEX/uGf+k7V6BXP6Rquj3fi/wAR6dZWHk6nY/Zvt9z5KL9o3xlo /mB3NtXI+bGO1AHQUUUUAFFFFABRRRQAUUUUAc/47/5J54l/7BV1/wCimo8Cf8k88Nf9gq1/9FLW hrt1Z2Ph7U7zUbf7RYwWkstxDsD+ZGqEsu08HIBGDwaNCurO+8PaZeadb/Z7Ge0ilt4dgTy42QFV 2jgYBAwOBQBoUUUUAFFFFABRRRQAUUUUAeP+If8Ak6Hwn/2CpP8A0G6r2CvH/EP/ACdD4T/7BUn/ AKDdV7BQAUUUUAFFFFABRRRQAUUUUAef/BL/AJJDoX/bx/6USV6BXH/DC6s77wFa3mnW/wBnsZ7u 9lt4dgTy42upSq7RwMAgYHArsKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAC iiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigArh9H+FXh/w/40fxNpEt9ZTP vDWUMqrbEMMFdm3O3OGC5wCBgAAAdxRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBz95/wAlD0b/ ALBV/wD+jbSugrn7z/koejf9gq//APRtpXQUAFFFFABRRRQAUUUUAFYfjSCa68C+Ibe3ikmnl0y5 SOONSzOxiYAADkknjFblZfiXUptG8K6vqlusbT2VlNcRrICVLIhYA4IOMj1FAFfwXBNa+BfD1vcR SQzxaZbJJHIpVkYRKCCDyCDxitysvw1qU2s+FdI1S4WNZ72yhuJFjBChnQMQMknGT6mtSgAooooA KKKKACiiigArh/sF5/wvX+0fsk/2H/hGvI+0+WfL8z7Tu2bum7HOOuK7iuX/AOEkvP8Ahaf/AAi/ lwfYf7E/tDzNp8zzPP8ALxnONuO2M570AdRRRRQAUUUUAFFFFABRRRQAVw/wgsLzTPhbo1nf2k9p dR+fvhnjMbrmeQjKnkZBB/Gu4rl/h34kvPF3gTTdcv44I7q683ekCkINsroMAknoo70AdRRRRQAU UUUAFFFFABRRRQBw/iewvLj4peAryG0nktbX+0PtEyRkpFugULuYcLk8DPWu4rl9c8SXmmeO/Cmh wxwNa6v9s+0O6kuvlRB12kHAyTzkH8K6igAooooAKKKKACiiigAooooA8f8AhB/yUP4nf9hUf+jb ivYK8f8AhB/yUP4nf9hUf+jbivYKACiiigAooooAKKKKACuH+JNheX3/AAiP2O0nuPI8S2c83kxl /LjXfudsdFGRkngV3Fcv408SXnhz/hHvsccD/wBpa3bafN5yk7Y5N24rgjDcDBOR7UAdRRRRQAUU UUAFFFFABRRRQAVw/hiwvLf4pePbya0njtbr+z/s8zxkJLtgYNtY8Ng8HHSu4rl9D8SXmp+O/Feh zRwLa6R9j+zuikO3mxF23EnBwRxgD8aAOoooooAKKKKACiiigAooooA4f4v2F5qfwt1mzsLSe7up PI2QwRmR2xPGThRycAE/hXcVy/xE8SXnhHwJqWuWEcEl1a+VsSdSUO6VEOQCD0Y966igAooooAKK KKACiiigAooooA4f7Bef8L1/tH7JP9h/4RryPtPlny/M+07tm7puxzjriu4rl/8AhJLz/haf/CL+ XB9h/sT+0PM2nzPM8/y8ZzjbjtjOe9dRQAUUUUAFFFFABRRRQAVz/jv/AJJ54l/7BV1/6Kaugrn/ AB3/AMk88S/9gq6/9FNQBz/wS/5JDoX/AG8f+lElegV5/wDBL/kkOhf9vH/pRJXoFABRRRQAUUUU AFFFFABXD+J7C8uPil4CvIbSeS1tf7Q+0TJGSkW6BQu5hwuTwM9a7iuX1zxJeaZ478KaHDHA1rq/ 2z7Q7qS6+VEHXaQcDJPOQfwoA6iiiigAooooAKKKKACiiigArh/hBYXmmfC3RrO/tJ7S6j8/fDPG Y3XM8hGVPIyCD+NdxXL/AA78SXni7wJpuuX8cEd1debvSBSEG2V0GAST0Ud6AOoooooAKKKKACii igAooooA4f4k2F5ff8Ij9jtJ7jyPEtnPN5MZfy4137nbHRRkZJ4FdxXL+NPEl54c/wCEe+xxwP8A 2lrdtp83nKTtjk3biuCMNwME5HtXUUAFFFFABRRRQAUUUUAFFFFAHD/DawvLH/hLvtlpPb+f4lvJ 4fOjKeZG2za656qcHBHBruK5fwX4kvPEf/CQ/bI4E/s3W7nT4fJUjdHHt2lsk5bk5IwPauooAKKK KACiiigAooooAK4f4v2F5qfwt1mzsLSe7upPI2QwRmR2xPGThRycAE/hXcVy/wARPEl54R8Calrl hHBJdWvlbEnUlDulRDkAg9GPegDqKKKKACiiigAooooAKKKKACuH8MWF5b/FLx7eTWk8drdf2f8A Z5njISXbAwbax4bB4OOldxXL6H4kvNT8d+K9DmjgW10j7H9ndFIdvNiLtuJODgjjAH40AdRRRRQA UUUUAFFFFABRRRQBh+NIJrrwL4ht7eKSaeXTLlI441LM7GJgAAOSSeMUeC4JrXwL4et7iKSGeLTL ZJI5FKsjCJQQQeQQeMVY8S6lNo3hXV9Ut1jaeyspriNZASpZELAHBBxkeoo8NalNrPhXSNUuFjWe 9sobiRYwQoZ0DEDJJxk+poA1KKKKACiiigAooooAKKKKAPH/ABD/AMnQ+E/+wVJ/6DdV7BXj/iH/ AJOh8J/9gqT/ANBuq9goAKKKKACiiigAooqGa6ht5beOV9r3EhjiGCdzBWfHt8qsefSgaTexNRRR QI4P4MwTWvwp0e3uIpIZ4nuUkjkUqyMLiQEEHkEHjFd5XF/CjUptZ+HVhqlwsaz3txd3EixghQz3 UrEDJJxk+prtKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKK KACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoory/wCMHxH1j4f/ANjf2TbWM327z/M+1o7Y 2eXjG1l/vnrntQB6hRXL/wDCSXn/AAqz/hKPLg+3f2J/aHl7T5fmeR5mMZztz2znHeuX+D/xH1j4 gf2z/a1tYw/YfI8v7Ijrnf5mc7mb+4OmO9AHqFFFFABRRRQAUUUUAFFFFABRRRQBz95/yUPRv+wV f/8Ao20roK5+8/5KHo3/AGCr/wD9G2ldBQAUUUUAFFFFABRRRQAVl+JdNm1nwrq+l27RrPe2U1vG 0hIUM6FQTgE4yfQ1qVh+NJ5rXwL4huLeWSGeLTLl45I2KsjCJiCCOQQec0AWPDWmzaN4V0jS7ho2 nsrKG3kaMkqWRApIyAcZHoK1Kw/Bc8114F8PXFxLJNPLpls8kkjFmdjEpJJPJJPOa3KACiiigAoo ooAKKKKACuX/AOEbvP8Ahaf/AAlHmQfYf7E/s/y9x8zzPP8AMzjGNuO+c57V1FcP9vvP+F6/2d9r n+w/8I15/wBm8w+X5n2nbv29N2OM9cUAdxRRRQAUUUUAFFFFABRRRQAVy/w78N3nhHwJpuh38kEl 1a+bveBiUO6V3GCQD0Ydq6iuH+EF/ean8LdGvL+7nu7qTz9808hkdsTyAZY8nAAH4UAdxRRRQAUU UUAFFFFABRRRQBy+ueG7zU/HfhTXIZIFtdI+2faEdiHbzYgi7QBg4I5yR+NdRXD+J7+8t/il4Cs4 bueO1uv7Q+0QpIQku2BSu5Rw2DyM9K7igAooooAKKKKACiiigAooooA8f+EH/JQ/id/2FR/6NuK9 grx/4Qf8lD+J3/YVH/o24r2CgAooooAKKKKACiiigArl/Gnhu88R/wDCPfY5IE/s3W7bUJvOYjdH Hu3BcA5bkYBwPeuorh/iTf3lj/wiP2O7nt/P8S2cE3kyFPMjbfuRsdVOBkHg0AdxRRRQAUUUUAFF FFABRRRQAVy+h+G7zTPHfivXJpIGtdX+x/Z0RiXXyoijbgRgZJ4wT+FdRXD+GL+8uPil49s5rueS 1tf7P+zwvISkW6Bi21TwuTycdaAO4ooooAKKKKACiiigAooooA5f4ieG7zxd4E1LQ7CSCO6uvK2P OxCDbKjnJAJ6Ke1dRXD/ABfv7zTPhbrN5YXc9pdR+RsmgkMbrmeMHDDkZBI/Gu4oAKKKKACiiigA ooooAKKKKAOX/wCEbvP+Fp/8JR5kH2H+xP7P8vcfM8zz/MzjGNuO+c57V1FcP9vvP+F6/wBnfa5/ sP8AwjXn/ZvMPl+Z9p279vTdjjPXFdxQAUUUUAFFFFABRRRQAVz/AI7/AOSeeJf+wVdf+imroK5/ x3/yTzxL/wBgq6/9FNQBz/wS/wCSQ6F/28f+lElegV5/8Ev+SQ6F/wBvH/pRJXoFABRRRQAUUUUA FFFFABXL654bvNT8d+FNchkgW10j7Z9oR2IdvNiCLtAGDgjnJH411FcP4nv7y3+KXgKzhu547W6/ tD7RCkhCS7YFK7lHDYPIz0oA7iiiigAooooAKKKKACiiigArl/h34bvPCPgTTdDv5IJLq183e8DE od0ruMEgHow7V1FcP8IL+81P4W6NeX93Pd3Unn75p5DI7YnkAyx5OAAPwoA7iiiigAooooAKKKKA CiiigDl/Gnhu88R/8I99jkgT+zdbttQm85iN0ce7cFwDluRgHA966iuH+JN/eWP/AAiP2O7nt/P8 S2cE3kyFPMjbfuRsdVOBkHg13FABRRRQAUUUUAFFFFABRRRQBy/gvw3eeHP+Eh+2SQP/AGlrdzqE PksTtjk27Q2QMNwcgZHvXUVw/wANr+8vv+Eu+2Xc9x5HiW8gh86Qv5ca7NqLnooycAcCu4oAKKKK ACiiigAooooAK5f4ieG7zxd4E1LQ7CSCO6uvK2POxCDbKjnJAJ6Ke1dRXD/F+/vNM+Fus3lhdz2l 1H5GyaCQxuuZ4wcMORkEj8aAO4ooooAKKKKACiiigAooooAK5fQ/Dd5pnjvxXrk0kDWur/Y/s6Ix Lr5URRtwIwMk8YJ/Cuorh/DF/eXHxS8e2c13PJa2v9n/AGeF5CUi3QMW2qeFyeTjrQB3FFFFABRR RQAUUUUAFFFFAGX4l02bWfCur6XbtGs97ZTW8bSEhQzoVBOATjJ9DR4a02bRvCukaXcNG09lZQ28 jRklSyIFJGQDjI9BVfxpPNa+BfENxbyyQzxaZcvHJGxVkYRMQQRyCDzmjwXPNdeBfD1xcSyTTy6Z bPJJIxZnYxKSSTySTzmgDcooooAKKKKACiiigAooooA8f8Q/8nQ+E/8AsFSf+g3VewV4/wCIf+To fCf/AGCpP/QbqvYKACiiigAooooAhupWt7OeZE8x442dU+b5iBnHygn8gT6A9K4fUvE2oyX+kO2j 7TFds6jZefMfIlGObYHoSeATx0xkju5Yo54XhmjWSKRSro4yrA8EEHqK5jVfDehR6joipounKsl6 yuFtUAYfZ5jg8cjIB+oFY1VN25X/AFc9LL54eLftotuz/J+aNTRNWutU8/7TY/ZfL27flnG7Oc/6 2KP07Z6844zrVUsdK07TPM+wWFraeZjf5EKx7sZxnA5xk/nVutI3t725xV3TdRukrROL+FGmzaN8 OrDS7ho2nsri7t5GjJKlkupVJGQDjI9BXaVwfwZnmuvhTo9xcSyTTyvcvJJIxZnY3EhJJPJJPOa7 yqMgooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKK KACiiigAooooAKKKKACiiigAooooAK+f/wBpr/mVv+3v/wBo19AV8/8A7TX/ADK3/b3/AO0aAPQP +bev+5U/9tK8/wD2Zf8Amaf+3T/2tXoH/NvX/cqf+2lef/sy/wDM0/8Abp/7WoA+gKKKKACiiigA ooooAKKKKACiiigDn7z/AJKHo3/YKv8A/wBG2ldBXP3n/JQ9G/7BV/8A+jbSugoAKKKKACiiigAo oooAKz9dtbO+8PanZ6jcfZ7Ge0liuJt4Ty42Qhm3HgYBJyeBWhXP+O/+SeeJf+wVdf8AopqANDQr WzsfD2mWenXH2ixgtIorebeH8yNUAVtw4OQAcjg1oVz/AIE/5J54a/7BVr/6KWugoAKKKKACiiig AooooAK5/wDsrR/+Fh/2v9v/AOJ3/ZX2X7F5yf8AHv5u7zNmN33+N2cdutdBXn//ADcL/wByp/7d 0AegUUUUAFFFFABRRRQAUUUUAFc/4J0rR9E8IWOnaBf/AG/TIfM8m585Jd+ZGZvmQBThiw49K6Cv P/gl/wAkh0L/ALeP/SiSgD0CiiigAooooAKKKKACiiigDn9X0rR7vxf4c1G9v/J1Ox+0/YLbzkX7 RvjCyfKRubauD8uMd66CvP8Axb/yV74df9xP/wBJ1r0CgAooooAKKKKACiiigAooooA8f+EH/JQ/ id/2FR/6NuK9grx/4Qf8lD+J3/YVH/o24r2CgAooooAKKKKACiiigArn/FWlaPqn9if2vf8A2P7L qsF1Z/vkj864Xdsj+YHdnJ+UcnHFdBXn/wAU/wDmSv8Asa7H/wBnoA9AooooAKKKKACiiigAoooo AK5/SNK0e08X+I9Rsr/ztTvvs32+285G+z7Iysfygbl3Lk/NnPaugrz/AMJf8le+Iv8A3DP/AEna gD0CiiigAooooAKKKKACiiigDn/G2laPrfhC+07X7/7Bpk3l+dc+ckWzEisvzOCoywUc+tdBXn/x t/5JDrv/AG7/APpRHXoFABRRRQAUUUUAFFFFABRRRQBz/wDZWj/8LD/tf7f/AMTv+yvsv2Lzk/49 /N3eZsxu+/xuzjt1roK8/wD+bhf+5U/9u69AoAKKKKACiiigAooooAK5/wAd/wDJPPEv/YKuv/RT V0Fc/wCO/wDknniX/sFXX/opqAOf+CX/ACSHQv8At4/9KJK9Arz/AOCX/JIdC/7eP/SiSvQKACii igAooooAKKKKACuf1fStHu/F/hzUb2/8nU7H7T9gtvORftG+MLJ8pG5tq4Py4x3roK8/8W/8le+H X/cT/wDSdaAPQKKKKACiiigAooooAKKKKACuf8E6Vo+ieELHTtAv/t+mQ+Z5Nz5yS78yMzfMgCnD Fhx6V0Fef/BL/kkOhf8Abx/6USUAegUUUUAFFFFABRRRQAUUUUAc/wCKtK0fVP7E/te/+x/ZdVgu rP8AfJH51wu7ZH8wO7OT8o5OOK6CvP8A4p/8yV/2Ndj/AOz16BQAUUUUAFFFFABRRRQAUUUUAc/4 V0rR9L/tv+yL/wC2fatVnurz98knk3Dbd8fygbcYHynkZ5roK8/+Fn/M6/8AY133/slegUAFFFFA BRRRQAUUUUAFc/420rR9b8IX2na/f/YNMm8vzrnzki2YkVl+ZwVGWCjn1roK8/8Ajb/ySHXf+3f/ ANKI6APQKKKKACiiigAooooAKKKKACuf0jStHtPF/iPUbK/87U777N9vtvORvs+yMrH8oG5dy5Pz Zz2roK8/8Jf8le+Iv/cM/wDSdqAPQKKKKACiiigAooooAKKKKAM/XbWzvvD2p2eo3H2exntJYrib eE8uNkIZtx4GAScngUaFa2dj4e0yz064+0WMFpFFbzbw/mRqgCtuHByADkcGs/x3/wAk88S/9gq6 /wDRTUeBP+SeeGv+wVa/+iloA6CiiigAooooAK5Xxn4/0rwN9i/tO3vZvtnmeX9mRWxs25zuYf3h +tdVXHeP/Bvh/wAUWtrdeIdRmsLbT9+JknjiQeYVHzF1I6qoHTrXXgFQeIisTfk62320/GxMr20M bS/jd4a1bVrPTYLHVlmu50gjaSKMKGdgoJxITjJ9K9Kryfw18K/Aratb6loviG51CbT54p9sN7BK qsG3KG2pkAlT3GcGvWK6c1jgoVFHCJrvzbihzW948f8AEP8AydD4T/7BUn/oN1XsFeP+If8Ak6Hw n/2CpP8A0G6r2CvLLCiiigAooooAhuo/Os54vJin3xsvlTHCPkfdbg8HoeD9DXD6loWy/wBIX/hE /Dke+7ZdqS8SfuJTtb9wOOM9+VHHcdxdNMlnO1uu6cRsY12hstjgYLKDz/tD6jrXD6le+KWv9IMt lh1u2MQ+xxDLeRLx/wAfZz8u7qV6deMHCtbTQ9XLHL3rSS0e7a6PszqNE077B5//ABJtL03ft/48 H3eZjP3v3adM8dep6d9asnRLjWJ/P/tW38rG3y/3CR565+7NLnt6fj21q1h8Jw4m/tXdp+jbX3vU 4/4YWtnY+ArWz064+0WMF3exW828P5ka3UoVtw4OQAcjg12Fef8AwS/5JDoX/bx/6USV6BVGAUUU UAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQ AUUUUAFFFFABRRRQAUUUUAFeX/GD4cax8QP7G/sm5sYfsPn+Z9rd1zv8vGNqt/cPXHavUKKAOX/4 Ru8/4VZ/wi/mQfbv7E/s/wAzcfL8zyPLznGdue+M47Vy/wAH/hxrHw//ALZ/ta5sZvt3keX9kd2x s8zOdyr/AHx0z3r1CigAooooAK4f4k+N7zwjZ6XaaNawXmu6tdrbWUE5IQ8gMxIIHVkXBZfv55Ck V3FFAHhepXnxt8JaMviLUL/TdTtoED3NgsCM0SlTkvsRCQh6lHOMZ5UE13Gq/ECF/g1ceM7DzInl ssxBFDmG4Y+UB84AYJKcE4wQpIB4By/in438uKTwLoFr/aniLV4mtmgQ5FvHIpBZjnhipJAJAA+Z sAAMeIPhlqh+Edj4H8O6nB+6lU3M178gmTc0jAbVYr+8KkDsBgk85AMPSdP+Nus6NY6pb+MNGWC9 t47iNZIEDBXUMAcW5GcH1Nd5oEviXwx4N1S/8cajBqd1aebdb7FFH7hIwdoGxAWyr9fUc+nFzfCb xs9kHtviLd2MqW6pDp9p50drDtQKsSt5udgwBvKliBuIJJzh63431HxT8FfF+la7a+TruiS21teu hXZK32hV3DacBsowIHy9xwcAA0NH1D4v+PrN/Eeh6xpWjaTcyuLW0mVHIRTtznynJ5BBJIyQSABi uw+FvjfUfFNnqWla7a+TruiSi2vXQrslbLLuG04DZRgQPl7jg4HQeBP+SeeGv+wVa/8Aopa8/wDD 3/J0Piz/ALBUf/oNrQB6Bef8lD0b/sFX/wD6NtK6CuT169nsfHWiS2+mXeoOdMvlMVq0SsB5tp8x 8x0GOMdc8jjri5/wkOqf9CZrn/f6y/8AkigDoKKz7XUbq406e5l0a+tZo9220meAyS4GRtKSMnJ4 G5hyOcDms/8A4SHVP+hM1z/v9Zf/ACRQB0FFZ91qN1b6dBcxaNfXU0m3daQvAJIsjJ3F5FTg8Hax 5PGRzVODXdRmuIon8J6zAjuFaWSWzKoCfvHbOTgdeAT6A0AblFZepareWNwsVv4f1LUEKBjLayW6 qDk/KfMlQ54z0xyOeuDTdVvL64aK48P6lp6BCwlupLdlJyPlHlyuc856Y4PPTIBqVn67dWdj4e1O 81G3+0WMFpLLcQ7A/mRqhLLtPByARg8Gqc+u6jDcSxJ4T1mdEcqssctmFcA/eG6cHB68gH1Aqn4i lvdY+HniOP8Ase+tLqTT7mKK1m8uSSQmI42iJ3ByTgDOcjp0yAbGhXVnfeHtMvNOt/s9jPaRS28O wJ5cbICq7RwMAgYHArQrh/Ceravp/g3Q7KXwbrhkt9Pt4mO+0TJWNQflecMOnRgCO4BrqLrUbq30 6C5i0a+uppNu60heASRZGTuLyKnB4O1jyeMjmgDQorDg13UZriKJ/CeswI7hWlklsyqAn7x2zk4H XgE+gNWNS1W8sbhYrfw/qWoIUDGW1kt1UHJ+U+ZKhzxnpjkc9cAGpRWXpuq3l9cNFceH9S09AhYS 3Uluyk5Hyjy5XOec9McHnpmvPruow3EsSeE9ZnRHKrLHLZhXAP3hunBwevIB9QKANyis+11G6uNO nuZdGvrWaPdttJngMkuBkbSkjJyeBuYcjnA5rP8A+Eh1T/oTNc/7/WX/AMkUAdBXP/2ro/8AwsP+ yPsH/E7/ALK+1fbfJT/j383b5e/O77/O3GO/WtC61G6t9OguYtGvrqaTbutIXgEkWRk7i8ipweDt Y8njI5rg4JtYm+NkWqv4V1mC0fQhZNJIICqMbnduLrKUwB/CCX7hSOaAPTKKy9S1W8sbhYrfw/qW oIUDGW1kt1UHJ+U+ZKhzxnpjkc9cGm6reX1w0Vx4f1LT0CFhLdSW7KTkfKPLlc55z0xweemQDUor Dn13UYbiWJPCeszojlVljlswrgH7w3Tg4PXkA+oFXLXUbq406e5l0a+tZo9220meAyS4GRtKSMnJ 4G5hyOcDmgDQorn/APhIdU/6EzXP+/1l/wDJFaF1qN1b6dBcxaNfXU0m3daQvAJIsjJ3F5FTg8Ha x5PGRzQBoUVhwa7qM1xFE/hPWYEdwrSyS2ZVAT947ZycDrwCfQGrGpareWNwsVv4f1LUEKBjLayW 6qDk/KfMlQ54z0xyOeuADUrn/BOq6PrfhCx1HQLD7Bpk3meTbeSkWzEjK3yoSoywY8etXNN1W8vr horjw/qWnoELCW6kt2UnI+UeXK5zznpjg89M8H8LbrW9B+HGk6bc+DtcaaHztx/0aLrM7D5ZZkcc Huo9sjBoA9QorPtdRurjTp7mXRr61mj3bbSZ4DJLgZG0pIycngbmHI5wOaz/APhIdU/6EzXP+/1l /wDJFAHQUVn3Wo3Vvp0FzFo19dTSbd1pC8AkiyMncXkVODwdrHk8ZHNU4Nd1Ga4iifwnrMCO4VpZ JbMqgJ+8ds5OB14BPoDQBuUVl6lqt5Y3CxW/h/UtQQoGMtrJbqoOT8p8yVDnjPTHI564NN1W8vrh orjw/qWnoELCW6kt2UnI+UeXK5zznpjg89MgGpRWHPruow3EsSeE9ZnRHKrLHLZhXAP3hunBwevI B9QKuWuo3Vxp09zLo19azR7ttpM8BklwMjaUkZOTwNzDkc4HNAGfq+q6PaeL/DmnXth52p332n7B c+SjfZ9kYaT5idy7lwPlznvXQV5f4iutbvPiP4L1KPwdrghsPt3mD/RmzvhCj5lmKLyP42XPbJ4r 0C61G6t9OguYtGvrqaTbutIXgEkWRk7i8ipweDtY8njI5oA0KKw4Nd1Ga4iifwnrMCO4VpZJbMqg J+8ds5OB14BPoDVjUtVvLG4WK38P6lqCFAxltZLdVByflPmSoc8Z6Y5HPXABqUVl6bqt5fXDRXHh /UtPQIWEt1JbspOR8o8uVznnPTHB56Zrz67qMNxLEnhPWZ0Ryqyxy2YVwD94bpwcHryAfUCgDcor PtdRurjTp7mXRr61mj3bbSZ4DJLgZG0pIycngbmHI5wOaz/+Eh1T/oTNc/7/AFl/8kUAdBRWfdaj dW+nQXMWjX11NJt3WkLwCSLIydxeRU4PB2seTxkc1Tg13UZriKJ/CeswI7hWlklsyqAn7x2zk4HX gE+gNAHnfwg/5KH8Tv8AsKj/ANG3FewV4f8ADPUbqw+IfxJ+zaNfalv1U7vsjwL5eJZ8Z82ROue2 ehzjjPrmm6reX1w0Vx4f1LT0CFhLdSW7KTkfKPLlc55z0xweemQDUorDn13UYbiWJPCeszojlVlj lswrgH7w3Tg4PXkA+oFXLXUbq406e5l0a+tZo9220meAyS4GRtKSMnJ4G5hyOcDmgDQorn/+Eh1T /oTNc/7/AFl/8kVoXWo3Vvp0FzFo19dTSbd1pC8AkiyMncXkVODwdrHk8ZHNAGhRWHBruozXEUT+ E9ZgR3CtLJLZlUBP3jtnJwOvAJ9Aasalqt5Y3CxW/h/UtQQoGMtrJbqoOT8p8yVDnjPTHI564ANS uf8AFWq6Ppf9if2vYfbPtWqwWtn+5STybht2yT5iNuMH5hyM8Vc03Vby+uGiuPD+paegQsJbqS3Z Scj5R5crnPOemODz0zw/xGm1jUbjw5Fa+FdZlSx8R21y0sYgdZEQvyNspKg5By4UD+IrQB6ZRWfa 6jdXGnT3MujX1rNHu22kzwGSXAyNpSRk5PA3MORzgc1n/wDCQ6p/0Jmuf9/rL/5IoA6Cis+61G6t 9OguYtGvrqaTbutIXgEkWRk7i8ipweDtY8njI5qnBruozXEUT+E9ZgR3CtLJLZlUBP3jtnJwOvAJ 9AaANyisvUtVvLG4WK38P6lqCFAxltZLdVByflPmSoc8Z6Y5HPXBpuq3l9cNFceH9S09AhYS3Ulu yk5Hyjy5XOec9McHnpkA1KKw59d1GG4liTwnrM6I5VZY5bMK4B+8N04OD15APqBVy11G6uNOnuZd GvrWaPdttJngMkuBkbSkjJyeBuYcjnA5oA0K5/SNV0e78X+I9OsrDydTsfs32+58lF+0b4y0fzA7 m2rkfNjHaj/hIdU/6EzXP+/1l/8AJFcvoTatp/xC8baqfDeqyx339m+VGgiUnFu2/DPIsbbThTtZ sE9xzQB6RRWHBruozXEUT+E9ZgR3CtLJLZlUBP3jtnJwOvAJ9Aasalqt5Y3CxW/h/UtQQoGMtrJb qoOT8p8yVDnjPTHI564ANSisvTdVvL64aK48P6lp6BCwlupLdlJyPlHlyuc856Y4PPTNefXdRhuJ Yk8J6zOiOVWWOWzCuAfvDdODg9eQD6gUAblFZ9rqN1cadPcy6NfWs0e7baTPAZJcDI2lJGTk8Dcw 5HOBzWf/AMJDqn/Qma5/3+sv/kigDoKKz7rUbq306C5i0a+uppNu60heASRZGTuLyKnB4O1jyeMj mqcGu6jNcRRP4T1mBHcK0sktmVQE/eO2cnA68An0BoAj8baro+ieEL7UdfsPt+mQ+X51t5KS78yK q/K5CnDFTz6V0Fed/GNdT1DwDqmkadoOpX7zpCwmtVjdVImUlSm/zCcL/ChHI54OOw03Vby+uGiu PD+paegQsJbqS3ZScj5R5crnPOemODz0yAalFYc+u6jDcSxJ4T1mdEcqssctmFcA/eG6cHB68gH1 Aq5a6jdXGnT3MujX1rNHu22kzwGSXAyNpSRk5PA3MORzgc0AaFFc/wD8JDqn/Qma5/3+sv8A5IrQ utRurfToLmLRr66mk27rSF4BJFkZO4vIqcHg7WPJ4yOaANCisODXdRmuIon8J6zAjuFaWSWzKoCf vHbOTgdeAT6A1Y1LVbyxuFit/D+paghQMZbWS3VQcn5T5kqHPGemORz1wAalFZem6reX1w0Vx4f1 LT0CFhLdSW7KTkfKPLlc55z0xweema8+u6jDcSxJ4T1mdEcqssctmFcA/eG6cHB68gH1AoAj/tXR /wDhYf8AZH2D/id/2V9q+2+Sn/Hv5u3y9+d33+duMd+tdBXm9q2rXHxkn1qXw3qtrbx+GmgVZhEf NkFxvCK6SNHuI6BnB4ycDmuo/wCEh1T/AKEzXP8Av9Zf/JFAHQUVn3Wo3Vvp0FzFo19dTSbd1pC8 AkiyMncXkVODwdrHk8ZHNU4Nd1Ga4iifwnrMCO4VpZJbMqgJ+8ds5OB14BPoDQBuUVl6lqt5Y3Cx W/h/UtQQoGMtrJbqoOT8p8yVDnjPTHI564NN1W8vrhorjw/qWnoELCW6kt2UnI+UeXK5zznpjg89 MgGpRWHPruow3EsSeE9ZnRHKrLHLZhXAP3hunBwevIB9QKuWuo3Vxp09zLo19azR7ttpM8BklwMj aUkZOTwNzDkc4HNAGhXP+O/+SeeJf+wVdf8AopqP+Eh1T/oTNc/7/WX/AMkVT8fXs6/DTWpRpl27 z6ZOskStFutw0LZZ8vgheh2Fj6A0AZfwS/5JDoX/AG8f+lElegV5X8GNVvIvhroNonh/UpoC8q/b UktxEAZ3y2GlD4GeflzwcA8Z9A1LVbyxuFit/D+paghQMZbWS3VQcn5T5kqHPGemORz1wAalFZem 6reX1w0Vx4f1LT0CFhLdSW7KTkfKPLlc55z0xweema8+u6jDcSxJ4T1mdEcqssctmFcA/eG6cHB6 8gH1AoA3KKz7XUbq406e5l0a+tZo9220meAyS4GRtKSMnJ4G5hyOcDms/wD4SHVP+hM1z/v9Zf8A yRQB0FFZ91qN1b6dBcxaNfXU0m3daQvAJIsjJ3F5FTg8Hax5PGRzVODXdRmuIon8J6zAjuFaWSWz KoCfvHbOTgdeAT6A0Ablc/q+q6PaeL/DmnXth52p332n7Bc+SjfZ9kYaT5idy7lwPlznvVzUtVvL G4WK38P6lqCFAxltZLdVByflPmSoc8Z6Y5HPXHF6o2rav8UvA94/hvVbK1svt/nTTiJ0XfAAuWik cLyMfNjOeM84APSKKw59d1GG4liTwnrM6I5VZY5bMK4B+8N04OD15APqBVy11G6uNOnuZdGvrWaP dttJngMkuBkbSkjJyeBuYcjnA5oA0KK5/wD4SHVP+hM1z/v9Zf8AyRWhdajdW+nQXMWjX11NJt3W kLwCSLIydxeRU4PB2seTxkc0AaFFYcGu6jNcRRP4T1mBHcK0sktmVQE/eO2cnA68An0BqxqWq3lj cLFb+H9S1BCgYy2sluqg5PynzJUOeM9McjnrgA1KKy9N1W8vrhorjw/qWnoELCW6kt2UnI+UeXK5 zznpjg89M159d1GG4liTwnrM6I5VZY5bMK4B+8N04OD15APqBQBuVz/gnVdH1vwhY6joFh9g0ybz PJtvJSLZiRlb5UJUZYMePWtC11G6uNOnuZdGvrWaPdttJngMkuBkbSkjJyeBuYcjnA5rz/4W3Wt6 D8ONJ0258Ha400Pnbj/o0XWZ2HyyzI44PdR7ZGDQB6hRWfdajdW+nQXMWjX11NJt3WkLwCSLIydx eRU4PB2seTxkc1Tg13UZriKJ/CeswI7hWlklsyqAn7x2zk4HXgE+gNAG5RWXqWq3ljcLFb+H9S1B CgYy2sluqg5PynzJUOeM9Mcjnrg03Vby+uGiuPD+paegQsJbqS3ZScj5R5crnPOemODz0yAalFYc +u6jDcSxJ4T1mdEcqssctmFcA/eG6cHB68gH1Aq5a6jdXGnT3MujX1rNHu22kzwGSXAyNpSRk5PA 3MORzgc0AaFFc/8A8JDqn/Qma5/3+sv/AJIrQutRurfToLmLRr66mk27rSF4BJFkZO4vIqcHg7WP J4yOaAM/xVquj6X/AGJ/a9h9s+1arBa2f7lJPJuG3bJPmI24wfmHIzxXQV5n43m1jXLjwnEnhXWb dLbxHZ3MssggkVEUtknypXIAznJAA7npnuNS1W8sbhYrfw/qWoIUDGW1kt1UHJ+U+ZKhzxnpjkc9 cAGpRWXpuq3l9cNFceH9S09AhYS3Uluyk5Hyjy5XOec9McHnpmvPruow3EsSeE9ZnRHKrLHLZhXA P3hunBwevIB9QKANyis+11G6uNOnuZdGvrWaPdttJngMkuBkbSkjJyeBuYcjnA5rP/4SHVP+hM1z /v8AWX/yRQB0FFZ91qN1b6dBcxaNfXU0m3daQvAJIsjJ3F5FTg8Hax5PGRzVODXdRmuIon8J6zAj uFaWSWzKoCfvHbOTgdeAT6A0AblFZepareWNwsVv4f1LUEKBjLayW6qDk/KfMlQ54z0xyOeuDTdV vL64aK48P6lp6BCwlupLdlJyPlHlyuc856Y4PPTIBT8K6ro+qf23/ZFh9j+y6rPa3n7lI/OuF275 PlJ3ZyPmPJxzXQV5n4Im1jQ7jxZE/hXWbhLnxHeXMUsYgjV0YrgjzZUJBxnIBB7HrjvLXUbq406e 5l0a+tZo9220meAyS4GRtKSMnJ4G5hyOcDmgDQorn/8AhIdU/wChM1z/AL/WX/yRWhdajdW+nQXM WjX11NJt3WkLwCSLIydxeRU4PB2seTxkc0AaFFYcGu6jNcRRP4T1mBHcK0sktmVQE/eO2cnA68An 0BqxqWq3ljcLFb+H9S1BCgYy2sluqg5PynzJUOeM9McjnrgA1KKy9N1W8vrhorjw/qWnoELCW6kt 2UnI+UeXK5zznpjg89M159d1GG4liTwnrM6I5VZY5bMK4B+8N04OD15APqBQBuVz/jbVdH0Twhfa jr9h9v0yHy/OtvJSXfmRVX5XIU4YqefStC11G6uNOnuZdGvrWaPdttJngMkuBkbSkjJyeBuYcjnA 5rz/AOKV1revfDjVtNtvB2uLNN5O0/6NL0mRj8sUzueB2U++Bk0AeoUVn3Wo3Vvp0FzFo19dTSbd 1pC8AkiyMncXkVODwdrHk8ZHNU4Nd1Ga4iifwnrMCO4VpZJbMqgJ+8ds5OB14BPoDQBuUVl6lqt5 Y3CxW/h/UtQQoGMtrJbqoOT8p8yVDnjPTHI564NN1W8vrhorjw/qWnoELCW6kt2UnI+UeXK5zznp jg89MgGpRWHPruow3EsSeE9ZnRHKrLHLZhXAP3hunBwevIB9QKuWuo3Vxp09zLo19azR7ttpM8Bk lwMjaUkZOTwNzDkc4HNAGhRXP/8ACQ6p/wBCZrn/AH+sv/kitC61G6t9OguYtGvrqaTbutIXgEkW Rk7i8ipweDtY8njI5oA0K5/SNV0e78X+I9OsrDydTsfs32+58lF+0b4y0fzA7m2rkfNjHapINd1G a4iifwnrMCO4VpZJbMqgJ+8ds5OB14BPoDXJ6W2raR8UvHF4nhvVb21vfsHkzQCJEbZAQ2GlkQNy cfLnGOccZAPSKKy9N1W8vrhorjw/qWnoELCW6kt2UnI+UeXK5zznpjg89M159d1GG4liTwnrM6I5 VZY5bMK4B+8N04OD15APqBQBuUVn2uo3Vxp09zLo19azR7ttpM8BklwMjaUkZOTwNzDkc4HNZ/8A wkOqf9CZrn/f6y/+SKAOgorPutRurfToLmLRr66mk27rSF4BJFkZO4vIqcHg7WPJ4yOapwa7qM1x FE/hPWYEdwrSyS2ZVAT947ZycDrwCfQGgDcorL1LVbyxuFit/D+paghQMZbWS3VQcn5T5kqHPGem ORz1wabqt5fXDRXHh/UtPQIWEt1JbspOR8o8uVznnPTHB56ZAJNdurOx8Paneajb/aLGC0lluIdg fzI1Qll2ng5AIweDRoV1Z33h7TLzTrf7PYz2kUtvDsCeXGyAqu0cDAIGBwK5vxpqWq3XhXxDptv4 U1mYy2VzBHNG1syvlGUMFE28g9cbd3tnirngiW9t/h5pUd1o99bXVnp8MX2Wby1klKRL90b8Lk8A OVIP3gtAHUUVz/8AwkOqf9CZrn/f6y/+SK0LrUbq306C5i0a+uppNu60heASRZGTuLyKnB4O1jye MjmgDQorDg13UZriKJ/CeswI7hWlklsyqAn7x2zk4HXgE+gNWNS1W8sbhYrfw/qWoIUDGW1kt1UH J+U+ZKhzxnpjkc9cAGpXD/GH/kles/8AbD/0fHXSabqt5fXDRXHh/UtPQIWEt1JbspOR8o8uVznn PTHB56Zw/FXie20zSb59e8JalcaPC4WWV1tJYpBvAVthm3EFtpGVyOMgV14CbhiqUoq7Ulp31WhM tYs8+/Z2/wCZk/7df/ate41wfgLxT4X1y31eXwr4eks3tUjaaKO1ggackPsUbWwT8rD5iAM9etbn /CQ6p/0Jmuf9/rL/AOSK6s7qyrY+pOcHFu2j3WiJpq0Ujz/xD/ydD4T/AOwVJ/6DdV7BXifii9ni /aN8JXaaZdzTnRy32JGiEoJW5yuWcJkZ5+bHBwTxn1CDXdRmuIon8J6zAjuFaWSWzKoCfvHbOTgd eAT6A15RoblFZepareWNwsVv4f1LUEKBjLayW6qDk/KfMlQ54z0xyOeuDTdVvL64aK48P6lp6BCw lupLdlJyPlHlyuc856Y4PPTIBqUVhz67qMNxLEnhPWZ0Ryqyxy2YVwD94bpwcHryAfUCrlrqN1ca dPcy6NfWs0e7baTPAZJcDI2lJGTk8Dcw5HOBzQBLqr+XpF6+/ZtgkO7dtx8p5zuXH13L9R1ryW81 Pddaef7T3bZyc/2jnb+6cZz/AGgcdcZyvXGedrd9e+INRawuFfwrrNqhiYNcSXFmqxDB+YlboEAd eCDxwRXA3mp7rrTz/ae7bOTn+0c7f3TjOf7QOOuM5XrjPO1uPFbo+jyL4Z/P8juPBN39q+3f6X9o 2+X/AMvPnbfvf9PM2P8Ax38e3W1wXhzW7qL7T9msb7Wc7d32S8gk8rrjPm3r4z7Y6HOeMbv/AAkO qf8AQma5/wB/rL/5Irej8CPKzL/epfL8kZ/wwurO+8BWt5p1v9nsZ7u9lt4dgTy42upSq7RwMAgY HArsK4P4MwTWvwp0e3uIpIZ4nuUkjkUqyMLiQEEHkEHjFd5WpwhRRRQAUUUUAFFFFABRRRQAUUUU AFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQA UUV438WfjJN4Uv38PeH4421REzdXM0ZK2+5MqEHRnwytk5UcDDZIUA9korh7HxneaX8I4/FHiWxn tr+2tD9ot50MbyTKxjXICfJ5jbT93C7/AEGa8Es/EXxU+JWs3UujX+pM8KbnisLn7JBChY7V+8oJ 5IG4liF6nbwAfWdFeF/Bv4na1qHiCTwf4pkklu1RltZZ0Kzq8Y+aKTjk7VZtzYOVYEkkY90oAK87 +L/xAm8CeGoRp/l/2tqDtFbF1JESqPnkxjBK5UAHuwOCAQfRKKAPnjwd8VPh34Ps8xaZrl5q025r zVJ7aEz3DsQXJYykhSQDtz2ycnJPoeu+JNc8U/CtPE3gGS7trsuZUge2iklmjR2jdNpLAHgsMZJ2 gAZavRKKAPF7H9oOz+xx2N/4b1U+JRmB7KCIbGuASoQZbeuWwMbSVzj5scyeFPhzqWqeA/F0+v20 dtrHit2uRau7IluwLSQlgAWUiRixUluAoIzuFeyUUAeD+GPjLB4H0OHwt4w0nVU1fSv9FbyY4mBj X/V/xL0XABGQwAbcd1dB8JdL1TVtc134ha3ZfZpta2rp6u/zpbehAABUhYgGIydmejZb1iigDn7z /koejf8AYKv/AP0baV0Fc/ef8lD0b/sFX/8A6NtK6CgAooooAKKKKACiiigArL8S6lNo3hXV9Ut1 jaeyspriNZASpZELAHBBxkeorUrL8S6bNrPhXV9Lt2jWe9spreNpCQoZ0KgnAJxk+hoAPDWpTaz4 V0jVLhY1nvbKG4kWMEKGdAxAyScZPqa1Ky/DWmzaN4V0jS7ho2nsrKG3kaMkqWRApIyAcZHoK1KA CiiigAooooAKKKKACuX/AOEkvP8Ahaf/AAi/lwfYf7E/tDzNp8zzPP8ALxnONuO2M5711Fcv/wAI 3ef8LT/4SjzIPsP9if2f5e4+Z5nn+ZnGMbcd85z2oA6iiiigAooooAKKKKACiiigArl/h34kvPF3 gTTdcv44I7q683ekCkINsroMAknoo711Fcv8O/Dd54R8Cabod/JBJdWvm73gYlDuldxgkA9GHagD qKKKKACiiigAooooAKKKKAOX1zxJeaZ478KaHDHA1rq/2z7Q7qS6+VEHXaQcDJPOQfwrqK5fXPDd 5qfjvwprkMkC2ukfbPtCOxDt5sQRdoAwcEc5I/GuooAKKKKACiiigAooooAKKKKAPH/hB/yUP4nf 9hUf+jbivYK8f+EH/JQ/id/2FR/6NuK9goAKKKKACiiigAooooAK5fxp4kvPDn/CPfY44H/tLW7b T5vOUnbHJu3FcEYbgYJyPauorl/Gnhu88R/8I99jkgT+zdbttQm85iN0ce7cFwDluRgHA96AOooo ooAKKKKACiiigAooooAK5fQ/El5qfjvxXoc0cC2ukfY/s7opDt5sRdtxJwcEcYA/Guorl9D8N3mm eO/FeuTSQNa6v9j+zojEuvlRFG3AjAyTxgn8KAOoooooAKKKKACiiigAooooA5f4ieJLzwj4E1LX LCOCS6tfK2JOpKHdKiHIBB6Me9dRXL/ETw3eeLvAmpaHYSQR3V15Wx52IQbZUc5IBPRT2rqKACii igAooooAKKKKACiiigDl/wDhJLz/AIWn/wAIv5cH2H+xP7Q8zafM8zz/AC8ZzjbjtjOe9dRXL/8A CN3n/C0/+Eo8yD7D/Yn9n+XuPmeZ5/mZxjG3HfOc9q6igAooooAKKKKACiiigArn/Hf/ACTzxL/2 Crr/ANFNXQVz/jv/AJJ54l/7BV1/6KagDn/gl/ySHQv+3j/0okr0CvP/AIJf8kh0L/t4/wDSiSvQ KACiiigAooooAKKKKACuX1zxJeaZ478KaHDHA1rq/wBs+0O6kuvlRB12kHAyTzkH8K6iuX1zw3ea n478Ka5DJAtrpH2z7QjsQ7ebEEXaAMHBHOSPxoA6iiiigAooooAKKKKACiiigArl/h34kvPF3gTT dcv44I7q683ekCkINsroMAknoo711Fcv8O/Dd54R8Cabod/JBJdWvm73gYlDuldxgkA9GHagDqKK KKACiiigAooooAKKKKAOX8aeJLzw5/wj32OOB/7S1u20+bzlJ2xybtxXBGG4GCcj2rqK5fxp4bvP Ef8Awj32OSBP7N1u21CbzmI3Rx7twXAOW5GAcD3rqKACiiigAooooAKKKKACiiigDl/BfiS88R/8 JD9sjgT+zdbudPh8lSN0ce3aWyTluTkjA9q6iuX8F+G7zw5/wkP2ySB/7S1u51CHyWJ2xybdobIG G4OQMj3rqKACiiigAooooAKKKKACuX+IniS88I+BNS1ywjgkurXytiTqSh3SohyAQejHvXUVy/xE 8N3ni7wJqWh2EkEd1deVsediEG2VHOSAT0U9qAOoooooAKKKKACiiigAooooAK5fQ/El5qfjvxXo c0cC2ukfY/s7opDt5sRdtxJwcEcYA/Guorl9D8N3mmeO/FeuTSQNa6v9j+zojEuvlRFG3AjAyTxg n8KAOoooooAKKKKACiiobprhLd2tIopZxjakshjU885YKxHGexoGld2BrqFLyO0Z8TyxvIi4PKqV DHPTguv51NXKzz67/wAJTYE6bpwl+xXO1RfvtI3wZJPk8HpxjnJ5GOeis3vXhJvreCCXdwsE5lUj 1yUXnrxj8aiM7to6K2HdOEZXWq7p9Wuj8in4l1KbRvCur6pbrG09lZTXEayAlSyIWAOCDjI9RR4a 1KbWfCukapcLGs97ZQ3EixghQzoGIGSTjJ9TR4l02bWfCur6XbtGs97ZTW8bSEhQzoVBOATjJ9DR 4a02bRvCukaXcNG09lZQ28jRklSyIFJGQDjI9BVnMalFFFABRRRQAVx3xUsrvUfhtq1rY2s1zcye TshgjLu2JkJwByeAT+FdjXOePPEF34X8F6hrNjHDJc23l7FnUlDukVTkAg9GPeuvAOaxVJ01eXMr et1YmVuV3PP/AIEaLquj/wBv/wBp6Ze2Xm/Z/L+0wNHvx5ucbgM4yPzFex15x8KvH+q+Of7W/tO3 sofsfk+X9mRlzv35zuY/3R+tej11Z3KtLH1HXSUtLparZfoTTtyqx4/4h/5Oh8J/9gqT/wBBuq9g rx/xD/ydD4T/AOwVJ/6DdV7BXlGgUUUUAFFFFABXyR8QLKTSviB4kt53QvLcvMuzJGJGEqjp12sM +4PWvW/iB8YxoN/FY+G3sry5hlmhv0uYJf3ToQAAcqDzv6Z6D8fDvEniC78Ua/dazfRwx3Nzs3rA pCDaoUYBJPRR3r7nhrKsTTbrVVaEkvW6kmtO2n3GE6yi/d31X3q36n0x8MPCGoeCvDVzpupTW0s0 t406tbMzLtKIuPmUHOVPau1r5y/4X94q/wCgfo3/AH5l/wDjle/6PrFhr+lQ6npk/n2c+7y5NjLu 2sVPDAHqD2rwM4wGNoz+sYpL33utr/p5fMunOLVonM/CjUptZ+HVhqlwsaz3txd3EixghQz3UrED JJxk+prtK4v4UabNo3w6sNLuGjaeyuLu3kaMkqWS6lUkZAOMj0FdpXimgUUUUAFFFFABRRRQAUUU UAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQ AUUUUAFfLmgQrrP7TsqaiZLkJrF2675GyDCJGi5znCmNMDphQOnFfUdeB/Fn4TavJ4gfxd4RSR53 fz7m2tyI5YpVGfNixgsSVyQPn3nI3bvlAND9pDW5rTw1pGjReYqX9w8srrIVBWID5GX+IFpFbk8F Bx6an7Pmjf2f8Om1F0g8zUruSVZEHzmNP3YVjjsyyEDkDd6k15RbeBPiL8TPFC3XiC3vrb7kc97q Fv5Kwx4ONkZC7uh+VBjc2WI3E17f8SdW1TwD8NUm8K20CR2XlWpM3z/ZoNpjVl3N8zBvLAzu68gj NAHjHiX7H/w01B9h8jyf7bst3kY2+ZmLzM4/i37t3fdnPOa+p6+ePg/8Mddk8Wr4r8VWM8UcW+eA XpBmmuCxG90YFhj5my207tjDIzX0PQAUUUUAFFFFABRRRQAUUUUAc/ef8lD0b/sFX/8A6NtK6Cuf vP8Akoejf9gq/wD/AEbaV0FABRRRQAUUUUAFFFFABWH40nmtfAviG4t5ZIZ4tMuXjkjYqyMImIII 5BB5zW5WfrtrZ33h7U7PUbj7PYz2ksVxNvCeXGyEM248DAJOTwKAKfguea68C+Hri4lkmnl0y2eS SRizOxiUkknkknnNblZ+hWtnY+HtMs9OuPtFjBaRRW828P5kaoArbhwcgA5HBrQoAKKKKACiiigA ooooAK4f7fef8L1/s77XP9h/4Rrz/s3mHy/M+07d+3puxxnriu4rn/7K0f8A4WH/AGv9v/4nf9lf ZfsXnJ/x7+bu8zZjd9/jdnHbrQB0FFFFABRRRQAUUUUAFFFFABXD/CC/vNT+FujXl/dz3d1J5++a eQyO2J5AMseTgAD8K7iuf8E6Vo+ieELHTtAv/t+mQ+Z5Nz5yS78yMzfMgCnDFhx6UAdBRRRQAUUU UAFFFFABRRRQBw/ie/vLf4peArOG7njtbr+0PtEKSEJLtgUruUcNg8jPSu4rn9X0rR7vxf4c1G9v /J1Ox+0/YLbzkX7RvjCyfKRubauD8uMd66CgAooooAKKKKACiiigAooooA8f+EH/ACUP4nf9hUf+ jbivYK8f+EH/ACUP4nf9hUf+jbivYKACiiigAooooAKKKKACuH+JN/eWP/CI/Y7ue38/xLZwTeTI U8yNt+5Gx1U4GQeDXcVz/irStH1T+xP7Xv8A7H9l1WC6s/3yR+dcLu2R/MDuzk/KOTjigDoKKKKA CiiigAooooAKKKKACuH8MX95cfFLx7ZzXc8lra/2f9nheQlIt0DFtqnhcnk4613Fc/pGlaPaeL/E eo2V/wCdqd99m+323nI32fZGVj+UDcu5cn5s57UAdBRRRQAUUUUAFFFFABRRRQBw/wAX7+80z4W6 zeWF3PaXUfkbJoJDG65njBww5GQSPxruK5/xtpWj634QvtO1+/8AsGmTeX51z5yRbMSKy/M4KjLB Rz610FABRRRQAUUUUAFFFFABRRRQBw/2+8/4Xr/Z32uf7D/wjXn/AGbzD5fmfadu/b03Y4z1xXcV z/8AZWj/APCw/wC1/t//ABO/7K+y/YvOT/j383d5mzG77/G7OO3WugoAKKKKACiiigAooooAK5/x 3/yTzxL/ANgq6/8ARTV0Fc/47/5J54l/7BV1/wCimoA5/wCCX/JIdC/7eP8A0okr0CvP/gl/ySHQ v+3j/wBKJK9AoAKKKKACiiigAooooAK4fxPf3lv8UvAVnDdzx2t1/aH2iFJCEl2wKV3KOGweRnpX cVz+r6Vo934v8Oaje3/k6nY/afsFt5yL9o3xhZPlI3NtXB+XGO9AHQUUUUAFFFFABRRRQAUUUUAF cP8ACC/vNT+FujXl/dz3d1J5++aeQyO2J5AMseTgAD8K7iuf8E6Vo+ieELHTtAv/ALfpkPmeTc+c ku/MjM3zIApwxYcelAHQUUUUAFFFFABRRRQAUUUUAcP8Sb+8sf8AhEfsd3Pb+f4ls4JvJkKeZG2/ cjY6qcDIPBruK5/xVpWj6p/Yn9r3/wBj+y6rBdWf75I/OuF3bI/mB3ZyflHJxxXQUAFFFFABRRRQ AUUUUAFFFFAHD/Da/vL7/hLvtl3PceR4lvIIfOkL+XGuzai56KMnAHAruK5/wrpWj6X/AG3/AGRf /bPtWqz3V5++STybhtu+P5QNuMD5TyM810FABRRRQAUUUUAFFFFABXD/ABfv7zTPhbrN5YXc9pdR +RsmgkMbrmeMHDDkZBI/Gu4rn/G2laPrfhC+07X7/wCwaZN5fnXPnJFsxIrL8zgqMsFHPrQB0FFF FABRRRQAUUUUAFFFFABXD+GL+8uPil49s5rueS1tf7P+zwvISkW6Bi21TwuTycda7iuf0jStHtPF /iPUbK/87U777N9vtvORvs+yMrH8oG5dy5PzZz2oA6CiiigAooooAKKKKAK72cb6lBfFm82GGSFQ D8pDlCc+/wC7H61YooosNybST6GH40nmtfAviG4t5ZIZ4tMuXjkjYqyMImIII5BB5zR4LnmuvAvh 64uJZJp5dMtnkkkYszsYlJJJ5JJ5zVzXbWzvvD2p2eo3H2exntJYribeE8uNkIZtx4GAScngUaFa 2dj4e0yz064+0WMFpFFbzbw/mRqgCtuHByADkcGgRoUUUUAFFFFABXOePPD934o8F6ho1jJDHc3P l7GnYhBtkVjkgE9FPaujrjvipe3enfDbVrqxupra5j8nZNBIUdczIDgjkcEj8a68ApvFUlTdpcyt 63ViZW5XcyfhV4A1XwN/a39p3FlN9s8ny/szs2Nm/Odyj+8P1r0evHPgRrWq6x/b/wDaep3t75X2 fy/tM7SbM+bnG4nGcD8hXsddWdxrRx9RV2nLS7Wi2X6E07cqseP+If8Ak6Hwn/2CpP8A0G6r2CvH /EP/ACdD4T/7BUn/AKDdV7BXlGgUUUUAFFFFAHyJ4/0vULDxprM95Y3NvDdahcvbyTQsiyr5hOVJ GGGCOR6iuYr7U1HRdK1jy/7T0yyvfKz5f2mBZNmcZxuBxnA/IV8q/EkaanxD1iLSYYYbOGVYVjgi 8tFdEVXAXA/jDfXr3r9MyHOvr1qDhZxjq+mlkv69Tiq0+XU5WvrH4V2V3p3w20m1vrWa2uY/O3wz xlHXMzkZB5HBB/Gjw/p/w+8UWD32jaJo1zbRymFn/sxUw4AJGGQHow/Ouxr5zP8AO/rtNYf2bg4u 7vvtb9TalT5Xe5wfwZnmuvhTo9xcSyTTyvcvJJIxZnY3EhJJPJJPOa7yuP8Ahha2dj4CtbPTrj7R YwXd7Fbzbw/mRrdShW3Dg5AByODXYV8sbhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUA FFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVl6/4j0jwtpbalrV9 HaWgcJvYFizHoFVQSx6nAB4BPQGtSvlzx9dX3xQ+NMfhu0eSK3tbhtPiDf8ALMISZ5dpfBPyueCC yog60AdfqX7S2mxXCrpfhu7uYNgLPdXKwMGyeAqhwRjHOe54459E1b4gWei/Dqw8X3tvtjuorWUW izDefN2llQnG9lUs2OM7D0HI8Y+PPhXQvCln4YtdD0yCyjb7VvKAl5MGIjc5yzY3HGScZwOK9f0v wxpfi74QaBpGrwebbyaValWXh4nEK4dD2YZP5kEEEggGx4T8aaF4105rzRbvzfK2ieF1KSQswyAy n8RkZUkHBODXQV8qeE4774XfHWDRPOjuxJcR6fMyDaJYp9hQ8glSC0bEDupXODmvqugAooooAKKK KACiiigAooooA5+8/wCSh6N/2Cr/AP8ARtpXQVz95/yUPRv+wVf/APo20roKACiiigAooooAKKKK ACuf8d/8k88S/wDYKuv/AEU1dBWfrt1Z2Ph7U7zUbf7RYwWkstxDsD+ZGqEsu08HIBGDwaAM/wAC f8k88Nf9gq1/9FLXQVn6FdWd94e0y8063+z2M9pFLbw7AnlxsgKrtHAwCBgcCtCgAooooAKKKKAC iiigArz/AP5uF/7lT/27r0Cuf/tXR/8AhYf9kfYP+J3/AGV9q+2+Sn/Hv5u3y9+d33+duMd+tAHQ UUUUAFFFFABRRRQAUUUUAFef/BL/AJJDoX/bx/6USV6BXP8AgnVdH1vwhY6joFh9g0ybzPJtvJSL ZiRlb5UJUZYMePWgDoKKKKACiiigAooooAKKKKAPP/Fv/JXvh1/3E/8A0nWvQK5/V9V0e08X+HNO vbDztTvvtP2C58lG+z7Iw0nzE7l3LgfLnPeugoAKKKKACiiigAooooAKKKKAPH/hB/yUP4nf9hUf +jbivYK8f+EH/JQ/id/2FR/6NuK9goAKKKKACiiigAooooAK8/8Ain/zJX/Y12P/ALPXoFc/4q1X R9L/ALE/tew+2fatVgtbP9yknk3DbtknzEbcYPzDkZ4oA6CiiigAooooAKKKKACiiigArz/wl/yV 74i/9wz/ANJ2r0Cuf0jVdHu/F/iPTrKw8nU7H7N9vufJRftG+MtH8wO5tq5HzYx2oA6CiiigAooo oAKKKKACiiigDz/42/8AJIdd/wC3f/0ojr0Cuf8AG2q6PonhC+1HX7D7fpkPl+dbeSku/MiqvyuQ pwxU8+ldBQAUUUUAFFFFABRRRQAUUUUAef8A/Nwv/cqf+3degVz/APauj/8ACw/7I+wf8Tv+yvtX 23yU/wCPfzdvl787vv8AO3GO/WugoAKKKKACiiigAooooAK5/wAd/wDJPPEv/YKuv/RTV0Fc/wCO /wDknniX/sFXX/opqAOf+CX/ACSHQv8At4/9KJK9Arz/AOCX/JIdC/7eP/SiSvQKACiiigAooooA KKKKACvP/Fv/ACV74df9xP8A9J1r0Cuf1fVdHtPF/hzTr2w87U777T9gufJRvs+yMNJ8xO5dy4Hy 5z3oA6CiiigAooooAKKKKACiiigArz/4Jf8AJIdC/wC3j/0okr0Cuf8ABOq6PrfhCx1HQLD7Bpk3 meTbeSkWzEjK3yoSoywY8etAHQUUUUAFFFFABRRRQAUUUUAef/FP/mSv+xrsf/Z69Arn/FWq6Ppf 9if2vYfbPtWqwWtn+5STybht2yT5iNuMH5hyM8V0FABRRRQAUUUUAFFFFABRRRQB5/8ACz/mdf8A sa77/wBkr0Cuf8K6ro+qf23/AGRYfY/suqz2t5+5SPzrhdu+T5Sd2cj5jycc10FABRRRQAUUUUAF FFFABXn/AMbf+SQ67/27/wDpRHXoFc/421XR9E8IX2o6/Yfb9Mh8vzrbyUl35kVV+VyFOGKnn0oA 6CiiigAooooAKKKKACiiigArz/wl/wAle+Iv/cM/9J2r0Cuf0jVdHu/F/iPTrKw8nU7H7N9vufJR ftG+MtH8wO5tq5HzYx2oA6CiiigAooooAKKKKACiiigDn/Hf/JPPEv8A2Crr/wBFNR4E/wCSeeGv +wVa/wDopa0NdurOx8Paneajb/aLGC0lluIdgfzI1Qll2ng5AIweDRoV1Z33h7TLzTrf7PYz2kUt vDsCeXGyAqu0cDAIGBwKANCiioVuoXvJLRXzPFGkjrg8KxYKc9OSjflQNJvYmooooEFYfjDTdK1j wre2Gt3v2LTpdnnXHmrHsw6lfmYEDLADn1rcrh/jD/ySvWf+2H/o+OuvAQc8VSjF2bkte2q1JlpF h8O/DXhXw9/aX/CM63/afn+V9o/0qKby9u/b9wDGct164ruK8O/Z2/5mT/t1/wDate411Z3SlRx9 SE5uTVtXu9ETTd4pnj/iH/k6Hwn/ANgqT/0G6r2CvH/EP/J0PhP/ALBUn/oN1XsFeUaBRRRQAUUU UAFeOa18CP7Y17UdT/4STyftlzJceX9h3bN7FsZ8wZxnrivY6K7MHmGJwUnLDy5W99E/zTJlBS3O V8AeDP8AhBtBn0z7f9t825a48zyfLxlVXGNx/u9c966qiisK9epXqOrUd5PcaSSsjz/4Jf8AJIdC /wC3j/0okr0CuP8AhhdWd94CtbzTrf7PYz3d7Lbw7AnlxtdSlV2jgYBAwOBXYVkMKKKKACiiigAo oooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACii igAooooAKKKKACvli9uH+Hf7RMup6vF/or6hLc+YAwXyLjePMHy5bYJDkAHLIyg96+p64f4ifDLS /iDZxGWT7FqcGBDfJHvITOSjLkbl5JHIweQeWBAPNP2k54bq38JXFvLHNBKl08ckbBldSISCCOCC Oc1634Sv7PTPhj4dvL+7gtLWPSrTfNPII0XMaAZY8DJIH418+av8FPiRClpp6pHqtnbozQCC/HlQ FmyyqspQqSQCcDByOSekkPwc+J2vfZ7LVm8i1s4iLY6hqIljiHyjYioXK8AdgML16UAR6XeTfEr9 oG11jS7SSGD7bDdsJcny4YAnzOVBClggAHTc4XPevquuH+Hfwy0v4fWcpik+26nPkTXzx7CUzkIq 5O1eATycnknhQO4oAKKKKACiiigAooooAKKKKAOfvP8Akoejf9gq/wD/AEbaV0Fc/ef8lD0b/sFX /wD6NtK6CgAooooAKKKKACiiigArD8aQTXXgXxDb28Uk08umXKRxxqWZ2MTAAAckk8YrcrL8S6lN o3hXV9Ut1jaeyspriNZASpZELAHBBxkeooAr+C4JrXwL4et7iKSGeLTLZJI5FKsjCJQQQeQQeMVu Vl+GtSm1nwrpGqXCxrPe2UNxIsYIUM6BiBkk4yfU1qUAFFFFABRRRQAUUUUAFcP9gvP+F6/2j9kn +w/8I15H2nyz5fmfad2zd03Y5x1xXcVy/wDwkl5/wtP/AIRfy4PsP9if2h5m0+Z5nn+XjOcbcdsZ z3oA6iiiigAooooAKKKKACiiigArh/hBYXmmfC3RrO/tJ7S6j8/fDPGY3XM8hGVPIyCD+NdxXL/D vxJeeLvAmm65fxwR3V15u9IFIQbZXQYBJPRR3oA6iiiigAooooAKKKKACiiigDh/E9heXHxS8BXk NpPJa2v9ofaJkjJSLdAoXcw4XJ4GetdxXL654kvNM8d+FNDhjga11f7Z9od1JdfKiDrtIOBknnIP 4V1FABRRRQAUUUUAFFFFABRRRQB4/wDCD/kofxO/7Co/9G3FewV4/wDCD/kofxO/7Co/9G3FewUA FFFFABRRRQAUUUUAFcP8SbC8vv8AhEfsdpPceR4ls55vJjL+XGu/c7Y6KMjJPAruK5fxp4kvPDn/ AAj32OOB/wC0tbttPm85Sdscm7cVwRhuBgnI9qAOoooooAKKKKACiiigAooooAK4fwxYXlv8UvHt 5NaTx2t1/Z/2eZ4yEl2wMG2seGweDjpXcVy+h+JLzU/HfivQ5o4FtdI+x/Z3RSHbzYi7biTg4I4w B+NAHUUUUUAFFFFABRRRQAUUUUAcP8X7C81P4W6zZ2FpPd3UnkbIYIzI7YnjJwo5OACfwruK5f4i eJLzwj4E1LXLCOCS6tfK2JOpKHdKiHIBB6Me9dRQAUUUUAFFFFABRRRQAUUUUAcP9gvP+F6/2j9k n+w/8I15H2nyz5fmfad2zd03Y5x1xXcVy/8Awkl5/wALT/4Rfy4PsP8AYn9oeZtPmeZ5/l4znG3H bGc966igAooooAKKKKACiiigArn/AB3/AMk88S/9gq6/9FNXQVz/AI7/AOSeeJf+wVdf+imoA5/4 Jf8AJIdC/wC3j/0okr0CvP8A4Jf8kh0L/t4/9KJK9AoAKKKKACiiigAooooAK4fxPYXlx8UvAV5D aTyWtr/aH2iZIyUi3QKF3MOFyeBnrXcVy+ueJLzTPHfhTQ4Y4GtdX+2faHdSXXyog67SDgZJ5yD+ FAHUUUUUAFFFFABRRRQAUUUUAFcP8ILC80z4W6NZ39pPaXUfn74Z4zG65nkIyp5GQQfxruK5f4d+ JLzxd4E03XL+OCO6uvN3pApCDbK6DAJJ6KO9AHUUUUUAFFFFABRRRQAUUUUAcP8AEmwvL7/hEfsd pPceR4ls55vJjL+XGu/c7Y6KMjJPAruK5fxp4kvPDn/CPfY44H/tLW7bT5vOUnbHJu3FcEYbgYJy PauooAKKKKACiiigAooooAKKKKAOH+G1heWP/CXfbLSe38/xLeTw+dGU8yNtm11z1U4OCODXcVy/ gvxJeeI/+Eh+2RwJ/Zut3Onw+SpG6OPbtLZJy3JyRge1dRQAUUUUAFFFFABRRRQAVw/xfsLzU/hb rNnYWk93dSeRshgjMjtieMnCjk4AJ/Cu4rl/iJ4kvPCPgTUtcsI4JLq18rYk6kod0qIcgEHox70A dRRRRQAUUUUAFFFFABRRRQAVw/hiwvLf4pePbya0njtbr+z/ALPM8ZCS7YGDbWPDYPBx0ruK5fQ/ El5qfjvxXoc0cC2ukfY/s7opDt5sRdtxJwcEcYA/GgDqKKKKACiiigAooooAKKKKAMPxpBNdeBfE NvbxSTTy6ZcpHHGpZnYxMAABySTxijwXBNa+BfD1vcRSQzxaZbJJHIpVkYRKCCDyCDxirHiXUptG 8K6vqlusbT2VlNcRrICVLIhYA4IOMj1FHhrUptZ8K6Rqlwsaz3tlDcSLGCFDOgYgZJOMn1NAFy9e 9SEGxt4J5d3KzzmJQPXIRuenGPxrnYJ9d/4Sm/I03TjL9ittym/faBvnwQfJ5PXjHGByc8dVVdLO NNSnvgzebNDHCwJ+UBC5GPf94f0qJRbaaZ00a0IQlGUU7rz7p9GOtWuHt0a7iiinOdyRSGRRzxhi qk8Y7CpqKKs527u4Vh+MNS0rR/Ct7f63ZfbdOi2edb+Usm/LqF+ViAcMQefStieeK2gknnlSKGJS 8kkjBVRQMkkngADvXmvxU8T+H9R+G2rWtjrmmXNzJ5OyGC7jd2xMhOADk8An8K7suw8q+Jpxs7OS Ta6a9+hE3ZM1vh34l8K+If7S/wCEZ0T+zPI8r7R/osUPmbt+37hOcYbr0zXcV4B8CNa0rR/7f/tP U7Ky837P5f2mdY9+PNzjcRnGR+Yr3TT9U0/VoGn02+tryFW2NJbTLIobAOMqSM4I4966s7wbw2Mn GCfKrau76LqTSleKPKvEP/J0PhP/ALBUn/oN1XsFeP8AiH/k6Hwn/wBgqT/0G6r2CvHNAooooAKK KKACiiigAooooA4P4MwTWvwp0e3uIpIZ4nuUkjkUqyMLiQEEHkEHjFd5XF/CjUptZ+HVhqlwsaz3 txd3EixghQz3UrEDJJxk+prtKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACi iigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigD5g/4aO8Yf9A3Q/8AvxN/8do/ 4aO8Yf8AQN0P/vxN/wDHa+n6y9f8R6R4W0ttS1q+jtLQOE3sCxZj0CqoJY9TgA8AnoDQB86f8NHe MP8AoG6H/wB+Jv8A47R/w0d4w/6Buh/9+Jv/AI7X0H4S8V6b4z8PxazpZkEDuyNHLt8yNlOMOFJA OMMBnowPesf4h/Eax+Htvpkt3ayXT3txs8qNtrLEo/eSDIwSuUG0lc7uvBoA8o8NfH3xVrPirSNL uNP0ZYL29ht5GjhlDBXcKSMyEZwfQ19F1z/hPxpoXjXTmvNFu/N8raJ4XUpJCzDIDKfxGRlSQcE4 NdBQAUUUUAFFFFABRRRQAUUUUAc/ef8AJQ9G/wCwVf8A/o20roK5+8/5KHo3/YKv/wD0baV0FABR RRQAUUUUAFFFFABWX4l02bWfCur6XbtGs97ZTW8bSEhQzoVBOATjJ9DWpWH40nmtfAviG4t5ZIZ4 tMuXjkjYqyMImIII5BB5zQBY8NabNo3hXSNLuGjaeysobeRoySpZECkjIBxkegrUrD8FzzXXgXw9 cXEsk08umWzySSMWZ2MSkkk8kk85rcoAKKKKACiiigAooooAK5f/AIRu8/4Wn/wlHmQfYf7E/s/y 9x8zzPP8zOMY2475zntXUVw/2+8/4Xr/AGd9rn+w/wDCNef9m8w+X5n2nbv29N2OM9cUAdxRRRQA UUUUAFFFFABRRRQAVy/w78N3nhHwJpuh38kEl1a+bveBiUO6V3GCQD0Ydq6iuH+EF/ean8LdGvL+ 7nu7qTz9808hkdsTyAZY8nAAH4UAdxRRRQAUUUUAFFFFABRRRQBy+ueG7zU/HfhTXIZIFtdI+2fa EdiHbzYgi7QBg4I5yR+NdRXD+J7+8t/il4Cs4bueO1uv7Q+0QpIQku2BSu5Rw2DyM9K7igAooooA KKKKACiiigAooooA8f8AhB/yUP4nf9hUf+jbivYK8f8AhB/yUP4nf9hUf+jbivYKACiiigAooooA KKKKACuX8aeG7zxH/wAI99jkgT+zdbttQm85iN0ce7cFwDluRgHA966iuH+JN/eWP/CI/Y7ue38/ xLZwTeTIU8yNt+5Gx1U4GQeDQB3FFFFABRRRQAUUUUAFFFFABXL6H4bvNM8d+K9cmkga11f7H9nR GJdfKiKNuBGBknjBP4V1FcP4Yv7y4+KXj2zmu55LW1/s/wCzwvISkW6Bi21TwuTycdaAO4ooooAK KKKACiiigAooooA5f4ieG7zxd4E1LQ7CSCO6uvK2POxCDbKjnJAJ6Ke1dRXD/F+/vNM+Fus3lhdz 2l1H5GyaCQxuuZ4wcMORkEj8a7igAooooAKKKKACiiigAooooA5f/hG7z/haf/CUeZB9h/sT+z/L 3HzPM8/zM4xjbjvnOe1dRXD/AG+8/wCF6/2d9rn+w/8ACNef9m8w+X5n2nbv29N2OM9cV3FABRRR QAUUUUAFFFFABXP+O/8AknniX/sFXX/opq6Cuf8AHf8AyTzxL/2Crr/0U1AHP/BL/kkOhf8Abx/6 USV6BXn/AMEv+SQ6F/28f+lElegUAFFFFABRRRQAUUUUAFcvrnhu81Px34U1yGSBbXSPtn2hHYh2 82IIu0AYOCOckfjXUVw/ie/vLf4peArOG7njtbr+0PtEKSEJLtgUruUcNg8jPSgDuKKKKACiiigA ooooAKKKKACuX+Hfhu88I+BNN0O/kgkurXzd7wMSh3Su4wSAejDtXUVw/wAIL+81P4W6NeX93Pd3 Unn75p5DI7YnkAyx5OAAPwoA7iiiigAooooAKKKKACiiigDl/Gnhu88R/wDCPfY5IE/s3W7bUJvO YjdHHu3BcA5bkYBwPeuorh/iTf3lj/wiP2O7nt/P8S2cE3kyFPMjbfuRsdVOBkHg13FABRRRQAUU UUAFFFFABRRRQBy/gvw3eeHP+Eh+2SQP/aWt3OoQ+SxO2OTbtDZAw3ByBke9dRXD/Da/vL7/AIS7 7Zdz3HkeJbyCHzpC/lxrs2oueijJwBwK7igAooooAKKKKACiiigArl/iJ4bvPF3gTUtDsJII7q68 rY87EINsqOckAnop7V1FcP8AF+/vNM+Fus3lhdz2l1H5GyaCQxuuZ4wcMORkEj8aAO4ooooAKKKK ACiiigAooooAK5fQ/Dd5pnjvxXrk0kDWur/Y/s6IxLr5URRtwIwMk8YJ/Cuorh/DF/eXHxS8e2c1 3PJa2v8AZ/2eF5CUi3QMW2qeFyeTjrQB3FFFFABRRRQAUUUUAFFFFAGX4l02bWfCur6XbtGs97ZT W8bSEhQzoVBOATjJ9DR4a02bRvCukaXcNG09lZQ28jRklSyIFJGQDjI9BVfxpPNa+BfENxbyyQzx aZcvHJGxVkYRMQQRyCDzmjwXPNdeBfD1xcSyTTy6ZbPJJIxZnYxKSSTySTzmgDcooooAKKKKAPI/ jn4k1bRLDTLHTrvybbUormG7Ty0bzEwgxlgSOHbpjrXnPhv4QeIPFGgWus2N5pkdtc79izyyBxtY qcgIR1U967H9on/mW/8At6/9pV3Pwe/5JXo3/bf/ANHyV9rSxlTL8kpV8OkpSk03bfWX+SOZxU6r TPH9U+CPiXSdJvNSnvtJaG0geeRY5ZCxVFLEDMYGcD1rZ+AOsX/9vX2ief8A8S77NJd+TsX/AFu6 JN27Gfu8Yzj2r2Pxp/yIniH/ALBlz/6KavDvgD/yPd9/2DJP/RsVXTzCtmOU4iWIs3HbQHBQqKx1 viH/AJOh8J/9gqT/ANBuq9grx/xD/wAnQ+E/+wVJ/wCg3VewV8OdIUUUUAFFFFABRRRQAUUUUAcX 8KNNm0b4dWGl3DRtPZXF3byNGSVLJdSqSMgHGR6Cu0rg/gzPNdfCnR7i4lkmnle5eSSRizOxuJCS SeSSec13lABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABR RRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAV8qeNJ9X+J3xpbw6sskcEF69jbxlgy28cZIllA+U EkIzkdTgLk4FfVdfLHiV7j4YfH5tauE8+3lu2v1IUEvBOWEm1d33l3SKMkZKgkYNAH0P4O8HaX4H 0P8AsnSfPaFpWmkknfc8jnAycAAcBRwB09ck2PEPhXQvFdmLXXNMgvY1+4XBDx5IJ2uMMudozgjO MHipNE8SaL4jt/P0bVLS+QIjuIZQzRhhld69UJweGAPB9KNb8SaL4ct/P1nVLSxQo7oJpQrSBRlt i9XIyOFBPI9aAPmzw0lx8MPj8ui27+fby3a2DAsCXgnKmPc237y7o2OAMlSAcGvqevljw09x8T/j 8utW6eRbxXa37EqAUggKiPcu77zbY1OCcFiQMCvqegAoork/HvjiHwRpdrMtjJqWoXtwtvZ2EMgV 5mPUjgnA4HCnllHfNAHWUV4fdfEz4o+HNOg1zxH4LsV0Y7fM8lmjkXePl3fvHMfOM7k6/LwSK9Mm 8c6LB4DHjJ5ZDpZt1n+QB3yxCiPCkjfuOwjOAc5IwTQB0lFeJw+PfjBqmlnW9M8FaadLlRp7cPlp TFyR8vmqzkgcYQbuCByK9A8K/EDSPE/gqXxOvmWtvao5vo3UsbdkUM4yB84CkEEDkEcA5AAOsorx e1+InxO8VefqfhDwhYyaE0rR2sl8wWRwvBJzMoPOfuggHK5JUmu0+HPj1fG+l3KXVpJY61pziHUb RkZQj8gFc8gEq3ynlSCDngkA1Lz/AJKHo3/YKv8A/wBG2ldBXP3n/JQ9G/7BV/8A+jbSugoAKKKK ACiiigAooooAKz9dtbO+8PanZ6jcfZ7Ge0liuJt4Ty42Qhm3HgYBJyeBWhXP+O/+SeeJf+wVdf8A opqANDQrWzsfD2mWenXH2ixgtIorebeH8yNUAVtw4OQAcjg1oVz/AIE/5J54a/7BVr/6KWugoAKK KKACiiigAooooAK5/wDsrR/+Fh/2v9v/AOJ3/ZX2X7F5yf8AHv5u7zNmN33+N2cdutdBXn//ADcL /wByp/7d0AegUUUUAFFFFABRRRQAUUUUAFc/4J0rR9E8IWOnaBf/AG/TIfM8m585Jd+ZGZvmQBTh iw49K6CvP/gl/wAkh0L/ALeP/SiSgD0CiiigAooooAKKKKACiiigDn9X0rR7vxf4c1G9v/J1Ox+0 /YLbzkX7RvjCyfKRubauD8uMd66CvP8Axb/yV74df9xP/wBJ1r0CgAooooAKKKKACiiigAooooA8 f+EH/JQ/id/2FR/6NuK9grx/4Qf8lD+J3/YVH/o24r2CgAooooAKKKKACiiigArn/FWlaPqn9if2 vf8A2P7LqsF1Z/vkj864Xdsj+YHdnJ+UcnHFdBXn/wAU/wDmSv8Asa7H/wBnoA9AooooAKKKKACi iigAooooAK5/SNK0e08X+I9Rsr/ztTvvs32+285G+z7Iysfygbl3Lk/NnPaugrz/AMJf8le+Iv8A 3DP/AEnagD0CiiigAooooAKKKKACiiigDn/G2laPrfhC+07X7/7Bpk3l+dc+ckWzEisvzOCoywUc +tdBXn/xt/5JDrv/AG7/APpRHXoFABRRRQAUUUUAFFFFABRRRQBz/wDZWj/8LD/tf7f/AMTv+yvs v2Lzk/49/N3eZsxu+/xuzjt1roK8/wD+bhf+5U/9u69AoAKKKKACiiigAooooAK5/wAd/wDJPPEv /YKuv/RTV0Fc/wCO/wDknniX/sFXX/opqAOf+CX/ACSHQv8At4/9KJK9Arz/AOCX/JIdC/7eP/Si SvQKACiiigAooooAKKKKACuf1fStHu/F/hzUb2/8nU7H7T9gtvORftG+MLJ8pG5tq4Py4x3roK8/ 8W/8le+HX/cT/wDSdaAPQKKKKACiiigAooooAKKKKACuf8E6Vo+ieELHTtAv/t+mQ+Z5Nz5yS78y MzfMgCnDFhx6V0Fef/BL/kkOhf8Abx/6USUAegUUUUAFFFFABRRRQAUUUUAc/wCKtK0fVP7E/te/ +x/ZdVgurP8AfJH51wu7ZH8wO7OT8o5OOK6CvP8A4p/8yV/2Ndj/AOz16BQAUUUUAFFFFABRRRQA UUUUAc/4V0rR9L/tv+yL/wC2fatVnurz98knk3Dbd8fygbcYHynkZ5roK8/+Fn/M6/8AY133/sle gUAFFFFABRRRQAUUUUAFc/420rR9b8IX2na/f/YNMm8vzrnzki2YkVl+ZwVGWCjn1roK8/8Ajb/y SHXf+3f/ANKI6APQKKKKACiiigAooooAKKKKACuf0jStHtPF/iPUbK/87U777N9vtvORvs+yMrH8 oG5dy5PzZz2roK8/8Jf8le+Iv/cM/wDSdqAPQKKKKACiiigAooooAKKKKAM/XbWzvvD2p2eo3H2e xntJYribeE8uNkIZtx4GAScngUaFa2dj4e0yz064+0WMFpFFbzbw/mRqgCtuHByADkcGs/x3/wAk 88S/9gq6/wDRTUeBP+SeeGv+wVa/+iloA6CiiigAooooA8O/aJ/5lv8A7ev/AGlXc/B7/klejf8A bf8A9HyVw37RP/Mt/wDb1/7Srufg9/ySvRv+2/8A6Pkr6rF/8k9Q/wAb/OZhH+Mzc8af8iJ4h/7B lz/6KavDvgD/AMj3ff8AYMk/9GxV7j40/wCRE8Q/9gy5/wDRTV4d8Af+R7vv+wZJ/wCjYqMq/wCR PigqfxInW+If+TofCf8A2CpP/QbqvYK8f8Q/8nQ+E/8AsFSf+g3VewV8qblHWryTTtC1C+hVWltr aSZA4ypKqSM47cVermPFOi2v/COa1debf+Z9knkx/aE+zOxj9zftx/s4x2xita10W1tLhJ45b9nX OBLqE8i8jHKs5B/EVmnLmsdcoUVQUk3e76eS8zRooorQ5AooooAKKKKAOP8Ahha2dj4CtbPTrj7R YwXd7Fbzbw/mRrdShW3Dg5AByODXYV5/8Ev+SQ6F/wBvH/pRJXoFABRRRQAUUUUAFFFFABRRRQAU UUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRR RQAVzfjPwNovjrS0sdYikBiffDcQELLCeM7SQRggYIIIPB6gEdJXz/8AEnwz8RdL+IGqeKPCovjY 3P2aVv7Pm3MzIqoFeEHMmCCcbWXa3P8AEAAZmpfs2a9FcKul65ptzBsBZ7pXgYNk8BVDgjGOc9zx xyab+zZr0twy6prmm20GwlXtVedi2RwVYIAMZ5z2HHPEej/tB+KdFley8R6VBqEkG+OTcDaziQN/ HgFRjldoQHgZOQc+p6B8bfBGvOsTahJpk7OVWPUUEQIC53bwSgHUDLA5GMcjIB0HgzwNovgXS3sd HikJlffNcTkNLMecbiABgA4AAAHJ6kk9JRRQAVTvNJ03ULi1uL3T7S5ntH320k0Ku0LZByhIypyo OR6D0q5XF/Ezx9D4A8NC8WKO41C5cxWdu7gAtjJdhnJReM47lRkbsgAz/i34zsdD8NXOgJHJe61r Vu9pa2MHL4kBTeQATjJwBjLEYHcrwfxM0G88FfAHQvD8l75kiagqXLQkqkm4TSlcfxKGxjPXaDgH gWPB3ij4Z6Hef8JBrfif+1vFlxue51GSzuSELAApEvlgKoA2g4BxkfKp2jqPiVZ2/wAS/hG1/wCH DPqHlSi7s1hQoZijNG42uAxwpkwBgkgYz0IB6ZBBDa28VvbxRwwRIEjjjUKqKBgAAcAAcYr5oaeb TvC3xksrGWS1tINThSGCBiiRq908bhVHADIApA6gAHivR9K+PPg+Xw1b3ep30kOqC33XFlFaSEmU DlUPK4JHy5boRkjnHN+EPBeo+KPhf401PULSeDU/FErXlvAjLGkmwmWEqGyVVpGYfMeVwQRncQD1 T4fQQ23w58NpBFHEh0y3cqihQWaMMx47liST3JJrg/C3+iftK+MLO2/c2sunpPJDH8qPJiA7yo4L Zdznr87epqPwH8YPDeleDrDR/E93JperaYn2Ga3ezmPEfyqflDYO0AEHB3BuAMVJ8KEuPFPjnxR8 Q57Oe2tb7Fpp5YBVliUgElcklgIogSDt3FwM44AO017U4NK8daJPcR3bo2mXyAWtpLcNnzbQ8rGr EDjrjHT1FXP+Ey0v/n11z/wRXv8A8ZovP+Sh6N/2Cr//ANG2ldBQBhnxZpy26Tm21nY7sgA0W8LZ UAnK+VkD5hgkYPOM4OJLHxLYaheR2sNvqqSPnBn0m6hQYBPLvGFHTueenWtiigDHvvEthp95JazW +qvImMmDSbqZDkA8OkZU9ex46dasaZrNrq/m/Zor6PysbvtdhPbZznGPNRd3TtnHGeorQooA5/8A 4TLS/wDn11z/AMEV7/8AGa0P7Ztf7H/tTyr77P8A3PsE/nfe2/6nZ5nX/Z6c9Oa0KKAOf/4TLS/+ fXXP/BFe/wDxmpPFOu6ZoejXMurWl3dWjW8rSxQ2Mlwroq/Mr4UooIOPnKg884BxuVh+NIJrrwL4 ht7eKSaeXTLlI441LM7GJgAAOSSeMUAV/DfirR9WstNi0yx1K2gmt0a3jfSp4Yo02ZC79nlAAcDD YPABORVy+8S2Gn3klrNb6q8iYyYNJupkOQDw6RlT17Hjp1qPwXBNa+BfD1vcRSQzxaZbJJHIpVkY RKCCDyCDxitygDP0zWbXV/N+zRX0flY3fa7Ce2znOMeai7unbOOM9RWf/wAJlpf/AD665/4Ir3/4 zXQUUAZ/9s2v9j/2p5V99n/ufYJ/O+9t/wBTs8zr/s9OenNZ/wDwmWl/8+uuf+CK9/8AjNdBRQBn 6nrNrpHlfaYr6Tzc7fslhPc4xjOfKRtvXvjPOOhqvY+JbDULyO1ht9VSR84M+k3UKDAJ5d4wo6dz z061sUUAY994lsNPvJLWa31V5ExkwaTdTIcgHh0jKnr2PHTrWXpvijQNV8dNp9vpl2msLphnN5da c1u3keaF8sGQLIRuOcY29ecgiusrh/sF5/wvX+0fsk/2H/hGvI+0+WfL8z7Tu2bum7HOOuKANj/h MtL/AOfXXP8AwRXv/wAZrQ/tm1/sf+1PKvvs/wDc+wT+d97b/qdnmdf9npz05rQooA5//hMtL/59 dc/8EV7/APGa0NT1m10jyvtMV9J5udv2SwnucYxnPlI23r3xnnHQ1oUUAY9j4lsNQvI7WG31VJHz gz6TdQoMAnl3jCjp3PPTrRfeJbDT7yS1mt9VeRMZMGk3UyHIB4dIyp69jx061sUUAZ+maza6v5v2 aK+j8rG77XYT22c5xjzUXd07ZxxnqKz/APhMtL/59dc/8EV7/wDGa6CigDP/ALZtf7H/ALU8q++z /wBz7BP533tv+p2eZ1/2enPTmuX8LeOvDF34ctJ9H0jVbKwbf5UEGhzlEw7A4MKNHycn5SevPORX cVw/wgsLzTPhbo1nf2k9pdR+fvhnjMbrmeQjKnkZBB/GgDqNT1m10jyvtMV9J5udv2SwnucYxnPl I23r3xnnHQ1XsfEthqF5Haw2+qpI+cGfSbqFBgE8u8YUdO556da2KKAMe+8S2Gn3klrNb6q8iYyY NJupkOQDw6RlT17Hjp1qxpms2ur+b9mivo/Kxu+12E9tnOcY81F3dO2ccZ6itCigDn/+Ey0v/n11 z/wRXv8A8ZrQ/tm1/sf+1PKvvs/9z7BP533tv+p2eZ1/2enPTmtCigDn/wDhMtL/AOfXXP8AwRXv /wAZrQ1PWbXSPK+0xX0nm52/ZLCe5xjGc+UjbevfGecdDWhRQBx7+LvDt54v0HTpNLvn1O5+0fYr m70qSDyNse6TDTKrDcvHyZ7ZxkVsX3iWw0+8ktZrfVXkTGTBpN1MhyAeHSMqevY8dOtc/wCJ7C8u Pil4CvIbSeS1tf7Q+0TJGSkW6BQu5hwuTwM9a7igDP0zWbXV/N+zRX0flY3fa7Ce2znOMeai7unb OOM9RWf/AMJlpf8Az665/wCCK9/+M10FFAGf/bNr/Y/9qeVffZ/7n2Cfzvvbf9Ts8zr/ALPTnpzW f/wmWl/8+uuf+CK9/wDjNdBRQBn6nrNrpHlfaYr6Tzc7fslhPc4xjOfKRtvXvjPOOhqvY+JbDULy O1ht9VSR84M+k3UKDAJ5d4wo6dzz061sUUAY994lsNPvJLWa31V5ExkwaTdTIcgHh0jKnr2PHTrV jTNZtdX837NFfR+Vjd9rsJ7bOc4x5qLu6ds44z1FaFFAHhfws1+zsfHXxEnmh1JkudTDxiHTbiVg PNnPzqiEoeRwwB6+hx7J/bNr/Y/9qeVffZ/7n2Cfzvvbf9Ts8zr/ALPTnpzXl/wg/wCSh/E7/sKj /wBG3FewUAc//wAJlpf/AD665/4Ir3/4zWhqes2ukeV9pivpPNzt+yWE9zjGM58pG29e+M846GtC igDHsfEthqF5Haw2+qpI+cGfSbqFBgE8u8YUdO556daL7xLYafeSWs1vqryJjJg0m6mQ5APDpGVP XseOnWtiigDP0zWbXV/N+zRX0flY3fa7Ce2znOMeai7unbOOM9RWf/wmWl/8+uuf+CK9/wDjNdBR QBn/ANs2v9j/ANqeVffZ/wC59gn87723/U7PM6/7PTnpzXL6/wCOvDFv/Zf9p6Rqt15moRR23naH OPKnOdjr5qL8w5xsy/PAPNdxXD/EmwvL7/hEfsdpPceR4ls55vJjL+XGu/c7Y6KMjJPAoA6jU9Zt dI8r7TFfSebnb9ksJ7nGMZz5SNt698Z5x0NV7HxLYaheR2sNvqqSPnBn0m6hQYBPLvGFHTueenWt iigDHvvEthp95JazW+qvImMmDSbqZDkA8OkZU9ex46dasaZrNrq/m/Zor6PysbvtdhPbZznGPNRd 3TtnHGeorQooA5//AITLS/8An11z/wAEV7/8ZrQ/tm1/sf8AtTyr77P/AHPsE/nfe2/6nZ5nX/Z6 c9Oa0KKAOf8A+Ey0v/n11z/wRXv/AMZrQ1PWbXSPK+0xX0nm52/ZLCe5xjGc+UjbevfGecdDWhRQ Bj2PiWw1C8jtYbfVUkfODPpN1CgwCeXeMKOnc89OtY6eLvDtn4v17To9Lvk1O2+z/bbm00qSfz90 e6PLQqzHavHz474zg12FcP4YsLy3+KXj28mtJ47W6/s/7PM8ZCS7YGDbWPDYPBx0oA6jTNZtdX83 7NFfR+Vjd9rsJ7bOc4x5qLu6ds44z1FZ/wDwmWl/8+uuf+CK9/8AjNdBRQBn/wBs2v8AY/8AanlX 32f+59gn87723/U7PM6/7PTnpzWf/wAJlpf/AD665/4Ir3/4zXQUUAZ+p6za6R5X2mK+k83O37JY T3OMYznykbb174zzjoar2PiWw1C8jtYbfVUkfODPpN1CgwCeXeMKOnc89OtbFFAGPfeJbDT7yS1m t9VeRMZMGk3UyHIB4dIyp69jx061Y0zWbXV/N+zRX0flY3fa7Ce2znOMeai7unbOOM9RWhRQBw/i nx14YtPDl3PrGkare2C7PNgn0OcI+XUDJmRY+Dg/MR045wK6j+2bX+x/7U8q++z/ANz7BP533tv+ p2eZ1/2enPTmuX+L9hean8LdZs7C0nu7qTyNkMEZkdsTxk4UcnABP4V3FAHP/wDCZaX/AM+uuf8A givf/jNaGp6za6R5X2mK+k83O37JYT3OMYznykbb174zzjoa0KKAMex8S2GoXkdrDb6qkj5wZ9Ju oUGATy7xhR07nnp1ovvEthp95JazW+qvImMmDSbqZDkA8OkZU9ex46da2KKAM/TNZtdX837NFfR+ Vjd9rsJ7bOc4x5qLu6ds44z1FZ//AAmWl/8APrrn/givf/jNdBRQBn/2za/2P/anlX32f+59gn87 723/AFOzzOv+z056c1n/APCZaX/z665/4Ir3/wCM10FFAHJ6l4o0DSvHS6fcaZdvrDaYJxeWunNc N5HmlfLJjDSAbhnGNvTnJArUsfEthqF5Haw2+qpI+cGfSbqFBgE8u8YUdO556da5/wCwXn/C9f7R +yT/AGH/AIRryPtPlny/M+07tm7puxzjriu4oAx77xLYafeSWs1vqryJjJg0m6mQ5APDpGVPXseO nWrGmaza6v5v2aK+j8rG77XYT22c5xjzUXd07ZxxnqK0KKAOf/4TLS/+fXXP/BFe/wDxmtD+2bX+ x/7U8q++z/3PsE/nfe2/6nZ5nX/Z6c9Oa0KKAOf/AOEy0v8A59dc/wDBFe//ABmtDU9ZtdI8r7TF fSebnb9ksJ7nGMZz5SNt698Z5x0NaFFAGPY+JbDULyO1ht9VSR84M+k3UKDAJ5d4wo6dzz061h/E HX7ODwh4k054dSM50y4Temm3DxZaE4/eqhTHPJ3YHOcYNdpXP+O/+SeeJf8AsFXX/opqAOX+Bl7F P8LdLtUScSW/m7y8Doh3TyEbXICv77ScdDg11H/CZaX/AM+uuf8Agivf/jNc/wDBL/kkOhf9vH/p RJXoFAGf/bNr/Y/9qeVffZ/7n2Cfzvvbf9Ts8zr/ALPTnpzWf/wmWl/8+uuf+CK9/wDjNdBRQBn6 nrNrpHlfaYr6Tzc7fslhPc4xjOfKRtvXvjPOOhqvY+JbDULyO1ht9VSR84M+k3UKDAJ5d4wo6dzz 061sUUAY994lsNPvJLWa31V5ExkwaTdTIcgHh0jKnr2PHTrVjTNZtdX837NFfR+Vjd9rsJ7bOc4x 5qLu6ds44z1FaFFAHP8A/CZaX/z665/4Ir3/AOM1n6v4u8O2mseHHvdLvpru++0/YJv7Kkaa32KP M/dlfOXcMD5VORyfl5rsK4fxPYXlx8UvAV5DaTyWtr/aH2iZIyUi3QKF3MOFyeBnrQBsf8Jlpf8A z665/wCCK9/+M1oanrNrpHlfaYr6Tzc7fslhPc4xjOfKRtvXvjPOOhrQooAx7HxLYaheR2sNvqqS PnBn0m6hQYBPLvGFHTueenWi+8S2Gn3klrNb6q8iYyYNJupkOQDw6RlT17Hjp1rYooAz9M1m11fz fs0V9H5WN32uwnts5zjHmou7p2zjjPUVn/8ACZaX/wA+uuf+CK9/+M10FFAGf/bNr/Y/9qeVffZ/ 7n2Cfzvvbf8AU7PM6/7PTnpzWf8A8Jlpf/Prrn/givf/AIzXQUUAZ+p6za6R5X2mK+k83O37JYT3 OMYznykbb174zzjoa5/wT4u8O63o9imgaXfWFpN5nkw/2VJFCmGbd+8RTCMkMeG6nH3uK7CuH+EF heaZ8LdGs7+0ntLqPz98M8ZjdczyEZU8jIIP40AdBfeJbDT7yS1mt9VeRMZMGk3UyHIB4dIyp69j x061Y0zWbXV/N+zRX0flY3fa7Ce2znOMeai7unbOOM9RWhRQBz//AAmWl/8APrrn/givf/jNaH9s 2v8AY/8AanlX32f+59gn87723/U7PM6/7PTnpzWhRQBz/wDwmWl/8+uuf+CK9/8AjNaGp6za6R5X 2mK+k83O37JYT3OMYznykbb174zzjoa0KKAMex8S2GoXkdrDb6qkj5wZ9JuoUGATy7xhR07nnp1o vvEthp95JazW+qvImMmDSbqZDkA8OkZU9ex46da2KKAOP1bxd4db+yvt2l31x52q29ra/a9Kki8q 4fd5cg89U+7tb5kyRketaH/CZaX/AM+uuf8Agivf/jNY/wASbC8vv+ER+x2k9x5HiWznm8mMv5ca 79ztjooyMk8Cu4oAz/7Ztf7H/tTyr77P/c+wT+d97b/qdnmdf9npz05rP/4TLS/+fXXP/BFe/wDx mugooAz9T1m10jyvtMV9J5udv2SwnucYxnPlI23r3xnnHQ1XsfEthqF5Haw2+qpI+cGfSbqFBgE8 u8YUdO556da2KKAMe+8S2Gn3klrNb6q8iYyYNJupkOQDw6RlT17Hjp1qxpms2ur+b9mivo/Kxu+1 2E9tnOcY81F3dO2ccZ6itCigDn/+Ey0v/n11z/wRXv8A8ZrQ/tm1/sf+1PKvvs/9z7BP533tv+p2 eZ1/2enPTmtCigDh9A8deGLj+1P7M0jVbXy9QljufJ0Oc+bOMb3bykb5jxnfh+OQOK6jU9ZtdI8r 7TFfSebnb9ksJ7nGMZz5SNt698Z5x0Ncv8NrC8sf+Eu+2Wk9v5/iW8nh86Mp5kbbNrrnqpwcEcGu 4oAx7HxLYaheR2sNvqqSPnBn0m6hQYBPLvGFHTueenWi+8S2Gn3klrNb6q8iYyYNJupkOQDw6RlT 17Hjp1rYooAz9M1m11fzfs0V9H5WN32uwnts5zjHmou7p2zjjPUVn/8ACZaX/wA+uuf+CK9/+M10 FFAGf/bNr/Y/9qeVffZ/7n2Cfzvvbf8AU7PM6/7PTnpzWf8A8Jlpf/Prrn/givf/AIzXQUUAZ+p6 za6R5X2mK+k83O37JYT3OMYznykbb174zzjoa5fxT468MWnhy7n1jSNVvbBdnmwT6HOEfLqBkzIs fBwfmI6cc4FdxXD/ABfsLzU/hbrNnYWk93dSeRshgjMjtieMnCjk4AJ/CgDoL7xLYafeSWs1vqry JjJg0m6mQ5APDpGVPXseOnWrGmaza6v5v2aK+j8rG77XYT22c5xjzUXd07ZxxnqK0KKAOf8A+Ey0 v/n11z/wRXv/AMZrQ/tm1/sf+1PKvvs/9z7BP533tv8Aqdnmdf8AZ6c9Oa0KKAOf/wCEy0v/AJ9d c/8ABFe//Ga0NT1m10jyvtMV9J5udv2SwnucYxnPlI23r3xnnHQ1oUUAY9j4lsNQvI7WG31VJHzg z6TdQoMAnl3jCjp3PPTrRfeJbDT7yS1mt9VeRMZMGk3UyHIB4dIyp69jx061sUUAZ+maza6v5v2a K+j8rG77XYT22c5xjzUXd07ZxxnqK5fTvHXhiTxHrUFrpGqxX8XkfbJ00OcvNlCU3BEMgwOB5gX/ AGcjmu4rh/DFheW/xS8e3k1pPHa3X9n/AGeZ4yEl2wMG2seGweDjpQB1H9s2v9j/ANqeVffZ/wC5 9gn87723/U7PM6/7PTnpzWf/AMJlpf8Az665/wCCK9/+M10FFAGfqes2ukeV9pivpPNzt+yWE9zj GM58pG29e+M846Gq9j4lsNQvI7WG31VJHzgz6TdQoMAnl3jCjp3PPTrWxRQBj33iWw0+8ktZrfVX kTGTBpN1MhyAeHSMqevY8dOtOtfEVld29xPFBqapBt3iXS7mNjuOBtVowX99oOO+K1qKBq19TlZ9 fsz4psJfJ1HatlcqQdNuN2S8HQbMkcHkcDjPUVtHWrUabLfmK/8AJiYKyiwnMpPHSPZvYcjkAjr6 GnS2cj67aXwZfKhtp4WBPzEu0RGPb92f0q9URUk3c6a86UoQUE7pd/N+SOT1bxtoUOjX0t7p+sz2 iW8jTRSaFdBXQKdynfEEwRkfMQPUgVctfEek2/h7R7y3sr6KxvLSOW1htNNlm8qMopVSsKsEwGAx 04OM4qTxpBNdeBfENvbxSTTy6ZcpHHGpZnYxMAABySTxijwXBNa+BfD1vcRSQzxaZbJJHIpVkYRK CCDyCDxirOUksfEthqF5Haw2+qpI+cGfSbqFBgE8u8YUdO556dabe+KdNsL+WxlTUnuIgrOtvpdz OAGGQcxxkYPIznqGHUEDSvXvUhBsbeCeXdys85iUD1yEbnpxj8a52CfXf+EpvyNN04y/Yrbcpv32 gb58EHyeT14xxgcnPESnZpHTRw7qQlK60XdLql1fmbWmaza6v5v2aK+j8rG77XYT22c5xjzUXd07 ZxxnqKz/APhMtL/59dc/8EV7/wDGa2rVrh7dGu4oopznckUhkUc8YYqpPGOwqarOdqzseDfHu9i1 Cz8L3UKTpG/2vAngeFxgxDlHAYdO4569K6n4WeJbDT/hvpNrNb6q8iedkwaTdTIczOeHSMqevY8d Otc9+0T/AMy3/wBvX/tKu5+D3/JK9G/7b/8Ao+SvqsX/AMk9Q/xv85nPH+MzQ+IGpwWPgzV4Jo7t nudPuUjMNpLKoPlkfOyKQg5HLEDr6HHi3wFmWLx/cIwkJl0+RF2xswB3xt8xAwowp5OBnA6kA+6+ NP8AkRPEP/YMuf8A0U1eHfAH/ke77/sGSf8Ao2KjKv8AkT4oKn8SJ0PivU4LT9pnw5PJHdsltpjI 4itJZGJKXBGxVUlx8wyVBA5z9049c0zWbXV/N+zRX0flY3fa7Ce2znOMeai7unbOOM9RXl/iH/k6 Hwn/ANgqT/0G6r2CvlTc8y8Rarq9zperFJdSFnJDMVSS2lQCMqeCGsgV47Fxju3etOw1vVLW9jm1 GTVpbRc70WymlJ4IHyrYoTzjow/HocDxTp//ACGpv7P/AOe7eb9h/wB453/Yfxz5nvv/AIq1vDOn +R4htZP7P8rG/wCf7D5ePkP8X2GLH/fY/HoeCM5e03PrKtCksFflWz6Lsjo/+Ey0v/n11z/wRXv/ AMZrQ1PWbXSPK+0xX0nm52/ZLCe5xjGc+UjbevfGecdDWhRXefJmPY+JbDULyO1ht9VSR84M+k3U KDAJ5d4wo6dzz060X3iWw0+8ktZrfVXkTGTBpN1MhyAeHSMqevY8dOtbFFAHP/8ACZaX/wA+uuf+ CK9/+M0f8Jlpf/Prrn/givf/AIzXQUUAcf8ADC6s77wFa3mnW/2exnu72W3h2BPLja6lKrtHAwCB gcCuwrg/gzBNa/CnR7e4ikhnie5SSORSrIwuJAQQeQQeMV3lABRRRQAUUUUAFFFFABRRRQAUUUUA FFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAU UV4X8SPir4vsPG954Q8LWEfnxJGElit2uLh2KCVii8rjacEFW4BOR2APWPFGleGdR0t5fFFtpr2c SMnn321RCHwp2yNgoSdoyCDnHfFfNHxB034V2rzf8IvqupG83svk28fn2qFFxt3yFWwzc71aQYDc YK1oaf8ABz4h+M7iG+8RXclsmyMCbVLlpp/KJJIVMsQVyTscpy2OOcen+F/gL4U0NEl1VZNavFdX 3z5jiUqxIxEpwQRgEOWBx2BIoA+fPB2t+NdPvPI8I3GqvIm6drWzRpkOQELtFgqeqjJHHy98V6p4 R/aKmD2ll4q0+NkLhJdStiVKrtA3NFg7juyTtI4PC8YPvdjYWemWcdnYWkFpax52QwRiNFySThRw Mkk/jXlfx38HTeI9G0q40jR5LzWhepbCSFCWELK5Ic9AgbadzcLk8jJyAesQTw3VvFcW8sc0EqB4 5I2DK6kZBBHBBHOap6noWj635X9raVY3/k58v7XbpLszjONwOM4HT0Fc/wDC3RNR8OfDjSdJ1a3+ z30HneZFvV9u6Z2HKkg8EHg12FAHP/8ACCeD/wDoVND/APBdD/8AE1sWNhZ6ZZx2dhaQWlrHnZDB GI0XJJOFHAyST+NWKKAMOfwX4VuriW4uPDWjTTyuXkkksImZ2JySSVySTzmtyiigDHvvCfhvU7yS 8v8Aw/pV3dSY3zT2UcjtgADLEZOAAPwrUgghtbeK3t4o4YIkCRxxqFVFAwAAOAAOMVJRQBz95/yU PRv+wVf/APo20roK5+8/5KHo3/YKv/8A0baV0FABRRRQAUUUUAFFFFABWX4l1KbRvCur6pbrG09l ZTXEayAlSyIWAOCDjI9RWpWX4l02bWfCur6XbtGs97ZTW8bSEhQzoVBOATjJ9DQAeGtSm1nwrpGq XCxrPe2UNxIsYIUM6BiBkk4yfU1qVl+GtNm0bwrpGl3DRtPZWUNvI0ZJUsiBSRkA4yPQVqUAFFFF ABRRRQAUUUUAFcv/AMJJef8AC0/+EX8uD7D/AGJ/aHmbT5nmef5eM5xtx2xnPeuorl/+EbvP+Fp/ 8JR5kH2H+xP7P8vcfM8zz/MzjGNuO+c57UAdRRRRQAUUUUAFFFFABRRRQAVy/wAO/El54u8Cabrl /HBHdXXm70gUhBtldBgEk9FHeuorl/h34bvPCPgTTdDv5IJLq183e8DEod0ruMEgHow7UAdRRRRQ AUUUUAFFFFABRRRQBy+ueJLzTPHfhTQ4Y4GtdX+2faHdSXXyog67SDgZJ5yD+FdRXL654bvNT8d+ FNchkgW10j7Z9oR2IdvNiCLtAGDgjnJH411FABRRRQAUUUUAFFFFABRRRQB4/wDCD/kofxO/7Co/ 9G3FewV4/wDCD/kofxO/7Co/9G3FewUAFFFFABRRRQAUUUUAFcv408SXnhz/AIR77HHA/wDaWt22 nzecpO2OTduK4Iw3AwTke1dRXL+NPDd54j/4R77HJAn9m63bahN5zEbo4924LgHLcjAOB70AdRRR RQAUUUUAFFFFABRRRQAVy+h+JLzU/HfivQ5o4FtdI+x/Z3RSHbzYi7biTg4I4wB+NdRXL6H4bvNM 8d+K9cmkga11f7H9nRGJdfKiKNuBGBknjBP4UAdRRRRQAUUUUAFFFFABRRRQBy/xE8SXnhHwJqWu WEcEl1a+VsSdSUO6VEOQCD0Y966iuX+Inhu88XeBNS0OwkgjurrytjzsQg2yo5yQCeintXUUAFFF FABRRRQAUUUUAFFFFAHL/wDCSXn/AAtP/hF/Lg+w/wBif2h5m0+Z5nn+XjOcbcdsZz3rqK5f/hG7 z/haf/CUeZB9h/sT+z/L3HzPM8/zM4xjbjvnOe1dRQAUUUUAFFFFABRRRQAVz/jv/knniX/sFXX/ AKKaugrn/Hf/ACTzxL/2Crr/ANFNQBz/AMEv+SQ6F/28f+lElegV5/8ABL/kkOhf9vH/AKUSV6BQ AUUUUAFFFFABRRRQAVy+ueJLzTPHfhTQ4Y4GtdX+2faHdSXXyog67SDgZJ5yD+FdRXL654bvNT8d +FNchkgW10j7Z9oR2IdvNiCLtAGDgjnJH40AdRRRRQAUUUUAFFFFABRRRQAVy/w78SXni7wJpuuX 8cEd1debvSBSEG2V0GAST0Ud66iuX+Hfhu88I+BNN0O/kgkurXzd7wMSh3Su4wSAejDtQB1FFFFA BRRRQAUUUUAFFFFAHL+NPEl54c/4R77HHA/9pa3bafN5yk7Y5N24rgjDcDBOR7V1Fcv408N3niP/ AIR77HJAn9m63bahN5zEbo4924LgHLcjAOB711FABRRRQAUUUUAFFFFABRRRQBy/gvxJeeI/+Eh+ 2RwJ/Zut3Onw+SpG6OPbtLZJy3JyRge1dRXL+C/Dd54c/wCEh+2SQP8A2lrdzqEPksTtjk27Q2QM NwcgZHvXUUAFFFFABRRRQAUUUUAFcv8AETxJeeEfAmpa5YRwSXVr5WxJ1JQ7pUQ5AIPRj3rqK5f4 ieG7zxd4E1LQ7CSCO6uvK2POxCDbKjnJAJ6Ke1AHUUUUUAFFFFABRRRQAUUUUAFcvofiS81Px34r 0OaOBbXSPsf2d0Uh282Iu24k4OCOMAfjXUVy+h+G7zTPHfivXJpIGtdX+x/Z0RiXXyoijbgRgZJ4 wT+FAHUUUUUAFFFFABRRUN1dW9lbvcXdxFBAmN0krhFXJwMk8dSBQNJt2RNRXMTeKdG/4SOy269Y fZfslx5mLxNm/fDtzzjON+P+Be9b9nqFlqMJmsbuC6iVtpeCQOoPXGQevI/OojOMnZM2q4arSipS i0n5ebX6FPxLqU2jeFdX1S3WNp7KymuI1kBKlkQsAcEHGR6ijw1qU2s+FdI1S4WNZ72yhuJFjBCh nQMQMknGT6mjxLps2s+FdX0u3aNZ72ymt42kJChnQqCcAnGT6Gjw1ps2jeFdI0u4aNp7Kyht5GjJ KlkQKSMgHGR6CrMDUrJt/wDkb9S/68LT/wBGXFXr2yiv4RFM86qG3ZguJIWz9UIOOenSudg0CzPi m/i87Udq2VswI1K43ZLz9TvyRwODwOcdTWc73Vv60OzDqm6c+Zvbt/eXmjqqKhtbZLS3SCNpWRc4 MsrSNyc8sxJP4mpq0OR2voeefGey0+f4f3NzeK6zQMv2eWO1WZlYsPlLEZjViBlgV6AfNna3zroV 74gguja+HrrU47m56w6fJIHl2gnonLYG4+3NeuftE/8AMt/9vX/tKuq+C+jabbeANP1SGyhXULrz vOuduZGAlZdu48hcIvA4yM4zzX3OAxccuyWNaa5+eTsuiev4e7c5ZR56ljw7Vr3x/ZWDf2zdeJoL OfMLfbJJ1jk3A5Q7uDkA8ema7z9n06eNW1YG4f8AtIwDbCYF2+SGGWEnLZ3FQV+UdD838HrnjqCK 48A+IEmiSRBp87hXUEBlQsp57ggEHsQDXiXwB/5Hu+/7Bkn/AKNiq/r6zDKK8uRQt267PsLk5KiO t8Q/8nQ+E/8AsFSf+g3VewV4/wCIf+TofCf/AGCpP/QbqvYK+DOo8m8U6f8A8hqb+z/+e7eb9h/3 jnf9h/HPme+/+Ktbwzp/keIbWT+z/Kxv+f7D5ePkP8X2GLH/AH2Px6GHxTYaz9j1qbyb/wCy+XO2 7zX2bMMc4+2Yxjt5f/AP4a19CsNZh1m3ku4b9YBu3GWV2X7pxkG8kHXH8B/DqOCMJe02PrKtek8F bmWz6rsjsqKKK7z5MKKKKACiiigDi/hRqU2s/Dqw1S4WNZ724u7iRYwQoZ7qViBkk4yfU12lcX8K NNm0b4dWGl3DRtPZXF3byNGSVLJdSqSMgHGR6Cu0oAKKKKACiiigAooooAKKKKACiiigAooooAKK KKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACuD+IHxG0 X4cW+42sd1q164lFnEwjaQABTLI2DgbVCgkEnaAOASveV8oNpn/CdftE3mm6tNvhk1WeOT5cboYN 2I/lIxlIgm4HIznk9QD3v4XeNZvHng4apdwRw3kVw9vcLEhWMsMMCmWY42umcnrntisf4yeMvEfg 7S9LutAtJGQ3BlvLkw+ZEka7QI5OPlDs45DKflwDzx6JY2FnplnHZ2FpBaWsedkMEYjRckk4UcDJ JP41YoA83+F/xYt/iB51hc2f2LV7aISuiEtHMg2hnU4+X5j905wCMFucekV8sXdmnhD9pW3tdGP2 eH+1bcKoRcIlwE8xFGMBcSsowOBjnIzX1PQAUUUUAFFFFABRRRQAUUUUAc/ef8lD0b/sFX//AKNt K6CufvP+Sh6N/wBgq/8A/RtpXQUAFFFFABRRRQAUUUUAFYfjSea18C+Ibi3lkhni0y5eOSNirIwi YggjkEHnNblZ+u2tnfeHtTs9RuPs9jPaSxXE28J5cbIQzbjwMAk5PAoAp+C55rrwL4euLiWSaeXT LZ5JJGLM7GJSSSeSSec1uVn6Fa2dj4e0yz064+0WMFpFFbzbw/mRqgCtuHByADkcGtCgAooooAKK KKACiiigArh/t95/wvX+zvtc/wBh/wCEa8/7N5h8vzPtO3ft6bscZ64ruK5/+ytH/wCFh/2v9v8A +J3/AGV9l+xecn/Hv5u7zNmN33+N2cdutAHQUUUUAFFFFABRRRQAUUUUAFcP8IL+81P4W6NeX93P d3Unn75p5DI7YnkAyx5OAAPwruK5/wAE6Vo+ieELHTtAv/t+mQ+Z5Nz5yS78yMzfMgCnDFhx6UAd BRRRQAUUUUAFFFFABRRRQBw/ie/vLf4peArOG7njtbr+0PtEKSEJLtgUruUcNg8jPSu4rn9X0rR7 vxf4c1G9v/J1Ox+0/YLbzkX7RvjCyfKRubauD8uMd66CgAooooAKKKKACq+oXkenabdX0ys0VtC8 zhBliFBJxnvxViuY8Uw6z/wjmtN9vsPsv2Sc+X9iffs2Nxu83Gcd9vvjtUTk4xbR0YalGrVjGTsm 13/RM6eis61h1lLhGu7+wlgGdyRWTxseOMMZWA5x2NaNUncynFRdk7+l/wBUjx/4Qf8AJQ/id/2F R/6NuK9grx/4Qf8AJQ/id/2FR/6NuK9gpkBRRRQAUUUUAFFFFABXD/Em/vLH/hEfsd3Pb+f4ls4J vJkKeZG2/cjY6qcDIPBruK5/xVpWj6p/Yn9r3/2P7LqsF1Z/vkj864Xdsj+YHdnJ+UcnHFAHQUUU UAFFFFABRRRQAUUUUAFcP4Yv7y4+KXj2zmu55LW1/s/7PC8hKRboGLbVPC5PJx1ruK5/SNK0e08X +I9Rsr/ztTvvs32+285G+z7Iysfygbl3Lk/NnPagDoKKKKACiiigAooooAKKKKAOH+L9/eaZ8LdZ vLC7ntLqPyNk0Ehjdczxg4YcjIJH413Fc/420rR9b8IX2na/f/YNMm8vzrnzki2YkVl+ZwVGWCjn 1roKACiiigAooooAKKKKACiiigDh/t95/wAL1/s77XP9h/4Rrz/s3mHy/M+07d+3puxxnriu4rn/ AOytH/4WH/a/2/8A4nf9lfZfsXnJ/wAe/m7vM2Y3ff43Zx2610FABRRRQAUUUUAFFFFABXP+O/8A knniX/sFXX/opq6Cuf8AHf8AyTzxL/2Crr/0U1AHP/BL/kkOhf8Abx/6USV6BXn/AMEv+SQ6F/28 f+lElegUAFFFFABRRRQAUUUUAFcP4nv7y3+KXgKzhu547W6/tD7RCkhCS7YFK7lHDYPIz0ruK5/V 9K0e78X+HNRvb/ydTsftP2C285F+0b4wsnykbm2rg/LjHegDoKKKKACiiigAooooAKKKKACuH+EF /ean8LdGvL+7nu7qTz9808hkdsTyAZY8nAAH4V3Fc/4J0rR9E8IWOnaBf/b9Mh8zybnzkl35kZm+ ZAFOGLDj0oA6CiiigAooooAKKKKACiiigDh/iTf3lj/wiP2O7nt/P8S2cE3kyFPMjbfuRsdVOBkH g13Fc/4q0rR9U/sT+17/AOx/ZdVgurP98kfnXC7tkfzA7s5Pyjk44roKACiiigAooooAKKKKACii igDh/htf3l9/wl32y7nuPI8S3kEPnSF/LjXZtRc9FGTgDgV3Fc/4V0rR9L/tv+yL/wC2fatVnurz 98knk3Dbd8fygbcYHynkZ5roKACiiigAooooAKKKKACuH+L9/eaZ8LdZvLC7ntLqPyNk0Ehjdczx g4YcjIJH413Fc/420rR9b8IX2na/f/YNMm8vzrnzki2YkVl+ZwVGWCjn1oA6CiiigAooooAKKKKA CiiigArh/DF/eXHxS8e2c13PJa2v9n/Z4XkJSLdAxbap4XJ5OOtdxXP6RpWj2ni/xHqNlf8Ananf fZvt9t5yN9n2RlY/lA3LuXJ+bOe1AHQUUUUAFFFFABWdrt8+m6NcXcckUbx7cNLt2jLAc7pIx37s Px6HRrO12K4m0a4jtFlac7doiYq33hnBEkZ6Z/jH49DMr8rsa0OX2seba6/M8/l8ZXja7aXH23Tt yW06BgLfaAzRHn/TMZ+UdWB4OAeSvceGtVl1jTZLiaaCVlmKboBHtxgH+CWUZ5/vA+3c+XSa5bnV reX+2oiFglUv/aYOMtHxu/tDjOOm4Zx0bGV9K8GzNcaGbjzjPHJMxjl87zQwAA4bz5uMgj7w5B4H U5U6NeEm6kWl5p9j3MzeG+rx9ny38rd2SeNJ5rXwL4huLeWSGeLTLl45I2KsjCJiCCOQQec0eC55 rrwL4euLiWSaeXTLZ5JJGLM7GJSSSeSSec1c121s77w9qdnqNx9nsZ7SWK4m3hPLjZCGbceBgEnJ 4FGhWtnY+HtMs9OuPtFjBaRRW828P5kaoArbhwcgA5HBrc+eNCiiigAooooA8O/aJ/5lv/t6/wDa Vdz8Hv8Aklejf9t//R8lcN+0T/zLf/b1/wC0q6P4V+J/D+nfDbSbW+1zTLa5j87fDPdxo65mcjIJ yOCD+NfW4inOfD1BQV/ee3rMwTtVZ2XjT/kRPEP/AGDLn/0U1eHfAH/ke77/ALBkn/o2KvWPF3i7 w1c+C9dgg8Q6TLNLp9wkccd7GzOxjYAABskk9q8n+AP/ACPd9/2DJP8A0bFRltOcMoxSmmvUU2nU idb4h/5Oh8J/9gqT/wBBuq9grx/xD/ydD4T/AOwVJ/6DdV7BXyR0Hk3inUP+Q1D/AGh/z3Xyvt3+ 8MbPt34Y8v22fw1reGdQ8/xDax/2h5ud/wAn27zM/If4ft0uf++D+HUYvjDVora41mxn1VIpyJQL Z9QCsQwJUeWb7PIIwPK5BHyfw1r+EdWi1LxDDHbaql55aO8iR6gJtq4xkqL6XjJUZ2Hkjp1HBGEv abH1lWvSeCtzLZ9V2R6NRRRXefJhRRRQAUUUUAcH8GZ5rr4U6PcXEsk08r3LySSMWZ2NxISSTyST zmu8rj/hha2dj4CtbPTrj7RYwXd7Fbzbw/mRrdShW3Dg5AByODXYUAFFFFABRRRQAUUUUAFFFFAB RRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFF FFABXzJ8VtC1L4e/E2Dxjo8Ui2l1cC6ST5ti3BJMkTkNkh8MxHygh2UcKa+m6r31hZ6nZyWd/aQX drJjfDPGJEbBBGVPBwQD+FAHmeifH/wXqNvu1GS70mdUQsk0DSqzEfMEaMMSAR1YLnI464Nb+P8A 4L0633adJd6tOyOVSGBolVgPlDtIFIBJ6qGxg8dMmpfs++CL64WW3GpaegQKYrW5DKTk/MfMVznn HXHA465NN/Z98EWNw0twNS1BChURXVyFUHI+YeWqHPGOuOTx0wAecfCnQtS+IXxNn8Y6xFI1pa3B unk+bY1wCDHEhLZATKsB8wARVPDCvpuq9jYWemWcdnYWkFpax52QwRiNFySThRwMkk/jVigAoooo AKKKKACiiigAooooA5+8/wCSh6N/2Cr/AP8ARtpXQVz95/yUPRv+wVf/APo20roKACiiigAooooA KKKKACuf8d/8k88S/wDYKuv/AEU1dBWfrt1Z2Ph7U7zUbf7RYwWkstxDsD+ZGqEsu08HIBGDwaAM /wACf8k88Nf9gq1/9FLXQVn6FdWd94e0y8063+z2M9pFLbw7AnlxsgKrtHAwCBgcCtCgAooooAKK KKACiiigArz/AP5uF/7lT/27r0Cuf/tXR/8AhYf9kfYP+J3/AGV9q+2+Sn/Hv5u3y9+d33+duMd+ tAHQUUUUAFFFFABRRRQAUUUUAFef/BL/AJJDoX/bx/6USV6BXP8AgnVdH1vwhY6joFh9g0ybzPJt vJSLZiRlb5UJUZYMePWgDoKKKKACiiigAooooAKKKKAPP/Fv/JXvh1/3E/8A0nWvQK5/V9V0e08X +HNOvbDztTvvtP2C58lG+z7Iw0nzE7l3LgfLnPeugoAKKKKACiiigArh/FPg6w/sjWtS8z995E8+ Psdr97azfe8rf177t3vnmu4rzbxT4Vuvsetah9ksPL8ueffmDfjDNn/j03Z/4Hn/AGs81hX+Ha56 mUtqurT5du2uu2p0+meDrDStRivYZMyR5wPsdqnUEfeSJWHXsR+VdFXG6F4VutN1m3u5LSwjSPdl ojBuGVI422kZ79mH49D2VVS22sYY9t1FefPpureemh4/8IP+Sh/E7/sKj/0bcV7BXj/wg/5KH8Tv +wqP/RtxXsFanEFFFFABRRRQAUUUUAFef/FP/mSv+xrsf/Z69Arn/FWq6Ppf9if2vYfbPtWqwWtn +5STybht2yT5iNuMH5hyM8UAdBRRRQAUUUUAFFFFABRRRQAV5/4S/wCSvfEX/uGf+k7V6BXP6Rqu j3fi/wAR6dZWHk6nY/Zvt9z5KL9o3xlo/mB3NtXI+bGO1AHQUUUUAFFFFABRRRQAUUUUAef/ABt/ 5JDrv/bv/wClEdegVz/jbVdH0Twhfajr9h9v0yHy/OtvJSXfmRVX5XIU4YqefSugoAKKKKACiiig AooooAKKKKAPP/8Am4X/ALlT/wBu69Arn/7V0f8A4WH/AGR9g/4nf9lfavtvkp/x7+bt8vfnd9/n bjHfrXQUAFFFFABRRRQAUUUUAFc/47/5J54l/wCwVdf+imroK5/x3/yTzxL/ANgq6/8ARTUAc/8A BL/kkOhf9vH/AKUSV6BXn/wS/wCSQ6F/28f+lElegUAFFFFABRRRQAUUUUAFef8Ai3/kr3w6/wC4 n/6TrXoFc/q+q6PaeL/DmnXth52p332n7Bc+SjfZ9kYaT5idy7lwPlznvQB0FFFFABRRRQAUUUUA FFFFABXn/wAEv+SQ6F/28f8ApRJXoFc/4J1XR9b8IWOo6BYfYNMm8zybbyUi2YkZW+VCVGWDHj1o A6CiiigAooooAKKKKACiiigDz/4p/wDMlf8AY12P/s9egVz/AIq1XR9L/sT+17D7Z9q1WC1s/wBy knk3DbtknzEbcYPzDkZ4roKACiiigAooooAKKKKACiiigDz/AOFn/M6/9jXff+yV6BXP+FdV0fVP 7b/siw+x/ZdVntbz9ykfnXC7d8nyk7s5HzHk45roKACiiigAooooAKKKKACvP/jb/wAkh13/ALd/ /SiOvQK5/wAbaro+ieEL7UdfsPt+mQ+X51t5KS78yKq/K5CnDFTz6UAdBRRRQAUUUUAFFFFABRRR QAV5/wCEv+SvfEX/ALhn/pO1egVz+karo934v8R6dZWHk6nY/Zvt9z5KL9o3xlo/mB3NtXI+bGO1 AHQUUUUAFFFFABUN1a297bvb3dvFPA+N0cqB1bByMg8dQDU1FA02ndHzqfgr4xSZbU6jYF5FMgmE 82xQuAVJ8vgneCB32t6V7L4C8O3PhbwfaaXetBJeI0jTywElZCXJByQCTt2jkdsdBXiH/CT+IP8A hc/2D+3NT+x/8JD5P2f7XJ5fl/aMbNucbccY6Yr6Ur6DOqdajGEavL7/AL2kbW0tYf1mdWKi5Oy0 1bfVv9Tn/Hf/ACTzxL/2Crr/ANFNR4E/5J54a/7BVr/6KWtDXbqzsfD2p3mo2/2ixgtJZbiHYH8y NUJZdp4OQCMHg0aFdWd94e0y8063+z2M9pFLbw7AnlxsgKrtHAwCBgcCvnyTQooooAKKKKAOO+IH gC08c2EXmXE0N5ZxTfZNrhYzI4GPM+UnblV6c4zXh3iT4QeIPC+gXWs315pkltbbN6wSyFzuYKMA oB1Yd6+oq5X4kaPf6/4A1PTNMg8+8n8ry496ru2yox5YgdAe9fQZPnWJw06eH5kqfMr36JvXXp1M qlNSTfU+cfBngDVfHP23+zLiyh+x+X5n2l2XO/djG1T/AHT+le3fDD4YS+Cp7nUtSukl1KVWgVba QtD5JKNn5kDbtynvjFVPgz4P17wn/bf9t2H2X7T5Hk/vkfdt8zd91jj7w6+teq115/ndapWqYalN OnptZ30V9fUmlTSSk9zx/wAQ/wDJ0PhP/sFSf+g3VesX1/Z6ZZyXl/dwWlrHjfNPII0XJAGWPAyS B+NeT+If+TofCf8A2CpP/QbquY/aG8U6zaa1H4agvNmkXenxTT2/lId7iZyDuI3D7i9D2+tfKG5z XxVa2j+Ig1bS/EGl3WmajOrCHT7wP5O1Yw5lVflXcxY9Tnkmtz4JpZaVqS+JNd8V6EkE1pLFDaXW oqLiGTzANxR8Bcqr8g5ww9TXiFFR7ON72Oh4qs6apuTtr1fW2n4H3vY39nqdnHeWF3Bd2smdk0Eg kRsEg4YcHBBH4VYrw/8AZw1vUb7R9X0m5uN9jpvk/ZItijy/MaVn5AyckZ5Jx2r3CrOcKKKKACii igDz/wCCX/JIdC/7eP8A0okr0CuP+GF1Z33gK1vNOt/s9jPd3stvDsCeXG11KVXaOBgEDA4FdhQA UUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABR RRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRWHB408K3VxFb2/iXRpp5XCRxx38TM7E4AADZJJ4xQBu UUUUAFFFFABRRRQAUUUUAFFFFAHP3n/JQ9G/7BV//wCjbSugrn7z/koejf8AYKv/AP0baV0FABRR RQAUUUUAFFFFABWH40gmuvAviG3t4pJp5dMuUjjjUszsYmAAA5JJ4xW5WX4l1KbRvCur6pbrG09l ZTXEayAlSyIWAOCDjI9RQBX8FwTWvgXw9b3EUkM8WmWySRyKVZGESggg8gg8YrcrL8NalNrPhXSN UuFjWe9sobiRYwQoZ0DEDJJxk+prUoAKKKKACiiigAooooAK4f7Bef8AC9f7R+yT/Yf+Ea8j7T5Z 8vzPtO7Zu6bsc464ruK5f/hJLz/haf8Awi/lwfYf7E/tDzNp8zzPP8vGc4247YznvQB1FFFFABRR RQAUUUUAFFFFABXD/CCwvNM+FujWd/aT2l1H5++GeMxuuZ5CMqeRkEH8a7iuX+HfiS88XeBNN1y/ jgjurrzd6QKQg2yugwCSeijvQB1FFFFABRRRQAUUUUAFFFFAHD+J7C8uPil4CvIbSeS1tf7Q+0TJ GSkW6BQu5hwuTwM9a7iuX1zxJeaZ478KaHDHA1rq/wBs+0O6kuvlRB12kHAyTzkH8K6igAooooAK KKKACq+oWceo6bdWMzMsVzC8LlDhgGBBxnvzViihq+g4ycWpLdBRRRQI8f8AhB/yUP4nf9hUf+jb ivYK8f8AhB/yUP4nf9hUf+jbivYKACiiigAooooAKKKKACuH+JNheX3/AAiP2O0nuPI8S2c83kxl /LjXfudsdFGRkngV3Fcv408SXnhz/hHvsccD/wBpa3bafN5yk7Y5N24rgjDcDBOR7UAdRRRRQAUU UUAFFFFABRRRQAVw/hiwvLf4pePbya0njtbr+z/s8zxkJLtgYNtY8Ng8HHSu4rl9D8SXmp+O/Feh zRwLa6R9j+zuikO3mxF23EnBwRxgD8aAOoooooAKKKKACiiigAooooA4f4v2F5qfwt1mzsLSe7up PI2QwRmR2xPGThRycAE/hXcVy/xE8SXnhHwJqWuWEcEl1a+VsSdSUO6VEOQCD0Y966igAooooAKK KKACiiigAooooA4f7Bef8L1/tH7JP9h/4RryPtPlny/M+07tm7puxzjriu4rl/8AhJLz/haf/CL+ XB9h/sT+0PM2nzPM8/y8ZzjbjtjOe9dRQAUUUUAFFFFABRRRQAVz/jv/AJJ54l/7BV1/6Kaugrn/ AB3/AMk88S/9gq6/9FNQBz/wS/5JDoX/AG8f+lElegV5/wDBL/kkOhf9vH/pRJXoFABRRRQAUUUU AFFFFABXD+J7C8uPil4CvIbSeS1tf7Q+0TJGSkW6BQu5hwuTwM9a7iuX1zxJeaZ478KaHDHA1rq/ 2z7Q7qS6+VEHXaQcDJPOQfwoA6iiiigAooooAKKKKACiiigArh/hBYXmmfC3RrO/tJ7S6j8/fDPG Y3XM8hGVPIyCD+NdxXL/AA78SXni7wJpuuX8cEd1debvSBSEG2V0GAST0Ud6AOoooooAKKKKACii igAooooA4f4k2F5ff8Ij9jtJ7jyPEtnPN5MZfy4137nbHRRkZJ4FdxXL+NPEl54c/wCEe+xxwP8A 2lrdtp83nKTtjk3biuCMNwME5HtXUUAFFFFABRRRQAUUUUAFFFFAHD/DawvLH/hLvtlpPb+f4lvJ 4fOjKeZG2za656qcHBHBruK5fwX4kvPEf/CQ/bI4E/s3W7nT4fJUjdHHt2lsk5bk5IwPauooAKKK KACiiigAooooAK4f4v2F5qfwt1mzsLSe7upPI2QwRmR2xPGThRycAE/hXcVy/wARPEl54R8Calrl hHBJdWvlbEnUlDulRDkAg9GPegDqKKKKACiiigAooooAKKKKACuH8MWF5b/FLx7eTWk8drdf2f8A Z5njISXbAwbax4bB4OOldxXL6H4kvNT8d+K9DmjgW10j7H9ndFIdvNiLtuJODgjjAH40AdRRRVe9 vI7CBZpVYq00UICjnMjqg/DLDPtQ3bUcYuTUVuyxRRRQIKKKKAPKv+EI8Af8J3/av/CUf8Tj+0/t P2T+0IP9f5u7y9m3d97jbnPbrXqtfKv/ADXb/uZv/bmvqqvoM+w9Sj7HnqOd49enkZUmneyMPxpB NdeBfENvbxSTTy6ZcpHHGpZnYxMAABySTxijwXBNa+BfD1vcRSQzxaZbJJHIpVkYRKCCDyCDxirH iXUptG8K6vqlusbT2VlNcRrICVLIhYA4IOMj1FHhrUptZ8K6Rqlwsaz3tlDcSLGCFDOgYgZJOMn1 NfPmpqUwSxmZoRIplVQzID8wByASPQ7T+R9KivbmW1hDw2U94xbHlwNGGA9fnZRj8c81zsGq3g8U 37/2BqJY2VsDGJLfcoDz8n97jByehzwc44zEp2aR0UsO6kZSTWi7pdUur8zqqKhtZnuLdJZLaW2d s5ilKll577SR78HvU1WYNWdgrlfiRrF/oHgDU9T0yfyLyDyvLk2K23dKinhgR0J7V1VYfjDw7/wl nhW90T7V9l+07P33l79u11f7uRn7uOveunBypxxNOVX4VJX66X1066EyvZ2OG+DPjDXvFn9t/wBt 3/2r7N5Hk/uUTbu8zd91Rn7o6+leq1w/w7+Hf/CA/wBpf8TX7d9t8r/l38rZs3/7TZzv9uldxXTm 9TD1MZOeFtyO1rKy2V9LLrcmmmo+9ueP+If+TofCf/YKk/8AQbqu88W+BdB8Z2EtvqlnGJ3RUW9i iT7RGqvuwkjKSBnII9GPrXB+If8Ak6Hwn/2CpP8A0G6r2CvNLPkD4q+E/C3g3WLfSdA1G+ur6Pd9 viu8HysqjR4IRQchmPBPQdK6D4Z/D3wF440yC2uda1VfEKxSTXVpBhUjQSbQQWiIPBT+I9fy7/xt 8C/+Ex8X32v/APCR/Y/tXl/uPsPmbdsap97zBnO3PTvWh8OPg/8A8K/8Q3Grf279v860a28r7J5W Mujbs72/uYxjvQB2HhHwbo/grR107SYfXzLmRU86b5mYeYyqN2NxAz0FdBRRQAUUUUAFFFFAHB/B mCa1+FOj29xFJDPE9ykkcilWRhcSAgg8gg8YrvK4v4UalNrPw6sNUuFjWe9uLu4kWMEKGe6lYgZJ OMn1NdpQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUU UAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAfNnxN8feI/GXjGXwR4Ziu4YIriSzeGF9sl5IMo+8g4 EQG7gnGMs3YLl3HgPx78HpY/FlrcWMsNvxcPbTFk2MyrskRgpZWLD7ucYzlSAak/Z1nhh+I10kss aPNpkqRKzAF28yNsL6narHA7AntXv/xBnhtvhz4keeWOJDplwgZ2Cgs0ZVRz3LEADuSBQB4BrWt+ I/jx4sh0fR/Ls9PtrcXAtriTakTBVDu5GS53tsUgdCDtXLmty+/ZovI7ORrDxPBPdDGyOezMSNyM 5YOxHGf4T6cdak/ZmnhW48S27Sxid0tnSMsNzKplDEDqQCygntuHrX0HQB88fBXxlrul+NJfAmuz TzR/vIIY5GEptZoQcoG3cR7UYYGRkLjALE/Q9fMHiX/iY/tQwfYf9K26rZbvI+fHlrF5mcf3drbv Tac9DX0/QAUUUUAFFFFABRRRQAUUUUAc/ef8lD0b/sFX/wD6NtK6CufvP+Sh6N/2Cr//ANG2ldBQ AUUUUAFFFFABRRRQAVl+JdNm1nwrq+l27RrPe2U1vG0hIUM6FQTgE4yfQ1qVh+NJ5rXwL4huLeWS GeLTLl45I2KsjCJiCCOQQec0AWPDWmzaN4V0jS7ho2nsrKG3kaMkqWRApIyAcZHoK1Kw/Bc8114F 8PXFxLJNPLpls8kkjFmdjEpJJPJJPOa3KACiiigAooooAKKKKACuX/4Ru8/4Wn/wlHmQfYf7E/s/ y9x8zzPP8zOMY2475zntXUVw/wBvvP8Ahev9nfa5/sP/AAjXn/ZvMPl+Z9p279vTdjjPXFAHcUUU UAFFFFABRRRQAUUUUAFcv8O/Dd54R8Cabod/JBJdWvm73gYlDuldxgkA9GHauorh/hBf3mp/C3Rr y/u57u6k8/fNPIZHbE8gGWPJwAB+FAHcUUUUAFFFFABRRRQAUUUUAcvrnhu81Px34U1yGSBbXSPt n2hHYh282IIu0AYOCOckfjXUVw/ie/vLf4peArOG7njtbr+0PtEKSEJLtgUruUcNg8jPSu4oAKKK KACiiigAooooAKKKKAPH/hB/yUP4nf8AYVH/AKNuK9grx/4Qf8lD+J3/AGFR/wCjbivYKACiiigA ooooAKKKKACuX8aeG7zxH/wj32OSBP7N1u21CbzmI3Rx7twXAOW5GAcD3rqK4f4k395Y/wDCI/Y7 ue38/wAS2cE3kyFPMjbfuRsdVOBkHg0AdxRRRQAUUUUAFFFFABRRRQAVy+h+G7zTPHfivXJpIGtd X+x/Z0RiXXyoijbgRgZJ4wT+FdRXD+GL+8uPil49s5rueS1tf7P+zwvISkW6Bi21TwuTycdaAO4o oooAKKKKACiiigAooooA5f4ieG7zxd4E1LQ7CSCO6uvK2POxCDbKjnJAJ6Ke1dRXD/F+/vNM+Fus 3lhdz2l1H5GyaCQxuuZ4wcMORkEj8a7igAooooAKKKKACiiigAooooA5f/hG7z/haf8AwlHmQfYf 7E/s/wAvcfM8zz/MzjGNuO+c57V1FcP9vvP+F6/2d9rn+w/8I15/2bzD5fmfadu/b03Y4z1xXcUA FFFFABRRRQAUUUUAFc/47/5J54l/7BV1/wCimroK5/x3/wAk88S/9gq6/wDRTUAc/wDBL/kkOhf9 vH/pRJXoFef/AAS/5JDoX/bx/wClElegUAFFFFABRRRQAUUUUAFcvrnhu81Px34U1yGSBbXSPtn2 hHYh282IIu0AYOCOckfjXUVw/ie/vLf4peArOG7njtbr+0PtEKSEJLtgUruUcNg8jPSgDuKKKKAC iiigAooooAKKKKACuX+Hfhu88I+BNN0O/kgkurXzd7wMSh3Su4wSAejDtXUVw/wgv7zU/hbo15f3 c93dSefvmnkMjtieQDLHk4AA/CgDuKKKKACiiigAooooAKKKKAOX8aeG7zxH/wAI99jkgT+zdbtt Qm85iN0ce7cFwDluRgHA966iuH+JN/eWP/CI/Y7ue38/xLZwTeTIU8yNt+5Gx1U4GQeDXcUAFFFF ABRRRQAUUUUAFFFFAHL+C/Dd54c/4SH7ZJA/9pa3c6hD5LE7Y5Nu0NkDDcHIGR711FcP8Nr+8vv+ Eu+2Xc9x5HiW8gh86Qv5ca7NqLnooycAcCu4oAKKKKACiiigAooooAK5f4ieG7zxd4E1LQ7CSCO6 uvK2POxCDbKjnJAJ6Ke1dRXD/F+/vNM+Fus3lhdz2l1H5GyaCQxuuZ4wcMORkEj8aAO4ooooAKKK KACiiigAooooAK5fQ/Dd5pnjvxXrk0kDWur/AGP7OiMS6+VEUbcCMDJPGCfwrqK4fwxf3lx8UvHt nNdzyWtr/Z/2eF5CUi3QMW2qeFyeTjrQB3Fcrr8GujTovN1LTmX7baYC2Dqc/aI8HPnHgHBI7jjI 611VZPiP/kGQ/wDX/Z/+lMVRUV4s6sHUca8LW1a6J9fMsWcWqpMTfXtnPFt4WC0aJgfXJkbjrxj8 avUUVSVjnnNzd3+SX5BRRRTJPKv+E38Af8J3/ZX/AAi//E4/tP7N9r/s+D/X+bt8zfu3fe53Yz36 16rXzX/wjHiD/hc/2/8AsPU/sf8AwkPnfaPsknl+X9ozv3YxtxznpivpSvdzvD0aPsvZSveN3rfX 9DKm273MvxLps2s+FdX0u3aNZ72ymt42kJChnQqCcAnGT6Gjw1ps2jeFdI0u4aNp7Kyht5GjJKlk QKSMgHGR6Cq/jSea18C+Ibi3lkhni0y5eOSNirIwiYggjkEHnNHguea68C+Hri4lkmnl0y2eSSRi zOxiUkknkknnNeEaj/Et3ZWemxyXxnERmCjyL4WrZwf4zJHkcHjPvjjI4eLWtCGu3chOo+U1tAq4 8QIGyGlzl/tXI5HGTjk4G7J7jxKjPpsYW4ngPnD5oILiVjweMQOrY9yce2cVw8UEv9u3Y/tLUQfs 0HzCw1Tcfml4IE24D3JwcnABDZ5K1+dWt+B9Flns/q8ubm+XN3XbQ9A0Ke3utGt5rTzfIbdt825F w33iDmQO4bnP8Rx04xgaNZ2hKU0a3VpZZSN3zyxzRsfmPVZmZx+JPtxitGumHwo8Kvb2srd3+fnq FcP8Yf8Akles/wDbD/0fHXcVh+MP7B/4RW9/4Sb/AJA/yfaPv/312/c+b723p/Ku3AT9niqU7N2k nZbvVaLzMJK8Wjyr9nb/AJmT/t1/9q17jXD/AA7/AOED/wCJl/whP/TL7X/r/wDb2f63/gfT8e1d xXVndf2+PqVOVxvbSSs9luiaatFI8f8AEP8AydD4T/7BUn/oN1XsFeP+If8Ak6Hwn/2CpP8A0G6r 2CvKNAooooAKKKKACiiigAooooA4v4UabNo3w6sNLuGjaeyuLu3kaMkqWS6lUkZAOMj0FdpXB/Bm ea6+FOj3FxLJNPK9y8kkjFmdjcSEkk8kk85rvKACiiigAooooAKKKKACiiigAooooAKKKKACiiig AooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigD54+J3wf8QR+ KL3xV4UXzo5ZftZgt5GW5hlwWd0yfm+YbhtO7L4C4Gaw10X4qfFHVLLR/EY1K2sInMzz3lh9niiH ALYCqJHwcKOvJ5ALGu78MftD6XrGuQ2Gr6T/AGRbzfKt2135qI/YP8i7VPPzc44zgZI9kgnhureK 4t5Y5oJUDxyRsGV1IyCCOCCOc0AfOniv4c+Kfht4jt9c+H326a1kiFvi2iM80bbAG8xMEOrFd+cb Q3GFwucub4/+OtVQWFha6bBdzuqRPaWrvLuLDAVXZgSemNp68c4r6jooA8L+Dfwx1rT/ABBJ4w8U xyRXbIzWsU7lp2eQfNLJzwdrMu1snLMSAQM+6UUUAFFFZfiHQLHxRok2j6msjWc7xtKiNtLhHV9u eoBKgHGDgnBB5oA4O1+L1vrfxX07wpoSQXOmt5y3V8cnzHWNnAiwcbQVwWOd2TjgBm7Txjr6+FvB 2q60zRh7W3ZovMVmVpT8sakLzguVHbr1HWvL7zSrHQ/2jfBemaZbR21nb6O6RRJ0Ubbr8SSckk8k kk5JrsPi9pGv+IPAcuj+HrCO8nu7iNZ0aRUKxKd+5SzKM7kQd+CeO4AOTsPF/wAatT062v7Pwjoc lrdRJNC/mAbkYAqcG4yMgjrXeeGNa8RxeFb/AFTx5YWmlT2jySMtqd6i3VA287Xck538A54HHrwY 8PfGez0mFdI1jSrGztrRI7bTCY5ZkVIwqxtI0O1pOBltwUsSRhcYr+IfiI/i74IeJi8M+ma7p/kW 2pWwDJsLzKhxnnawDqVPI+ZTkYLAFi1+InxO8VefqfhDwhYyaE0rR2sl8wWRwvBJzMoPOfuggHK5 JUmu0+HPj1fG+l3KXVpJY61pziHUbRkZQj8gFc8gEq3ynlSCDngnQ+H0ENt8OfDaQRRxIdMt3Koo UFmjDMeO5Ykk9ySa4Pwt/on7SvjCztv3NrLp6TyQx/KjyYgO8qOC2Xc56/O3qaAPQLz/AJKHo3/Y Kv8A/wBG2ldBXJ69qcGleOtEnuI7t0bTL5ALW0luGz5toeVjViBx1xjp6irn/CZaX/z665/4Ir3/ AOM0AdBRXP8A/CZaX/z665/4Ir3/AOM1oWus2t5p099FFfLDDu3LNYTxSHAydsboHbg8bQcngZPF AGhRXP8A/CZaX/z665/4Ir3/AOM1oXWs2tnp0F9LFfNDNt2rDYTyyDIyN0aIXXgc7gMHg4PFAGhR WHB4s065uIoEttZDyOEUyaLeIoJOOWaIBR7kgDvVjUtfs9KuFguIdSd2QODa6bcXC4yRy0aMAeOm c9PUUAalZ+u2tnfeHtTs9RuPs9jPaSxXE28J5cbIQzbjwMAk5PAqPTdfs9VuGgt4dSR1QuTdabcW 64yBw0iKCeemc9fQ1zfjvxLYf8Ib4lsfs+q+d/Z91Du/sm68vd5bDPmeXs25/iztxznHNAHUaFa2 dj4e0yz064+0WMFpFFbzbw/mRqgCtuHByADkcGtCuT8A6nBJ8NNFnEd2EtNMgSQNaShmKwqTsUrm QehQEN2zVz/hMtL/AOfXXP8AwRXv/wAZoA6Cis+61m1s9OgvpYr5oZtu1YbCeWQZGRujRC68DncB g8HB4qnB4s065uIoEttZDyOEUyaLeIoJOOWaIBR7kgDvQBuUVl6lr9npVwsFxDqTuyBwbXTbi4XG SOWjRgDx0znp6ijTdfs9VuGgt4dSR1QuTdabcW64yBw0iKCeemc9fQ0AalFYc/izTra4lge21kvG 5RjHot46kg44ZYiGHuCQe1XLXWbW806e+iivlhh3blmsJ4pDgZO2N0DtweNoOTwMnigDQrn/AOyt H/4WH/a/2/8A4nf9lfZfsXnJ/wAe/m7vM2Y3ff43Zx260f8ACZaX/wA+uuf+CK9/+M1x91rNrZ/H WC+livmhm8KLtWGwnlkGbnI3RohdeBzuAweDg8UAeoUVhweLNOubiKBLbWQ8jhFMmi3iKCTjlmiA Ue5IA71Y1LX7PSrhYLiHUndkDg2um3FwuMkctGjAHjpnPT1FAGpRWXpuv2eq3DQW8OpI6oXJutNu LdcZA4aRFBPPTOevoarz+LNOtriWB7bWS8blGMei3jqSDjhliIYe4JB7UAblFZ9rrNreadPfRRXy ww7tyzWE8UhwMnbG6B24PG0HJ4GTxWf/AMJlpf8Az665/wCCK9/+M0AdBRWfdaza2enQX0sV80M2 3asNhPLIMjI3RohdeBzuAweDg8VTg8Wadc3EUCW2sh5HCKZNFvEUEnHLNEAo9yQB3oA3K5/wTpWj 6J4QsdO0C/8At+mQ+Z5Nz5yS78yMzfMgCnDFhx6Vc1LX7PSrhYLiHUndkDg2um3FwuMkctGjAHjp nPT1FcP8DtTgl+Gukacsd2J4kndna0lWIjz3+7KV2MfmHAYnr6HAB6ZRWHP4s062uJYHttZLxuUY x6LeOpIOOGWIhh7gkHtVy11m1vNOnvoor5YYd25ZrCeKQ4GTtjdA7cHjaDk8DJ4oA0KK5/8A4TLS /wDn11z/AMEV7/8AGa0LrWbWz06C+livmhm27VhsJ5ZBkZG6NELrwOdwGDwcHigDQorDg8Wadc3E UCW2sh5HCKZNFvEUEnHLNEAo9yQB3qxqWv2elXCwXEOpO7IHBtdNuLhcZI5aNGAPHTOenqKANSis vTdfs9VuGgt4dSR1QuTdabcW64yBw0iKCeemc9fQ1Xn8WadbXEsD22sl43KMY9FvHUkHHDLEQw9w SD2oAj1fStHu/F/hzUb2/wDJ1Ox+0/YLbzkX7RvjCyfKRubauD8uMd66CvL/ABHrNrefE7wBfRRX yww/2puWawnikOLZSdsboHbg8bQcngZPFdh/wmWl/wDPrrn/AIIr3/4zQB0FFZ91rNrZ6dBfSxXz Qzbdqw2E8sgyMjdGiF14HO4DB4ODxVODxZp1zcRQJbayHkcIpk0W8RQSccs0QCj3JAHegDcorL1L X7PSrhYLiHUndkDg2um3FwuMkctGjAHjpnPT1FGm6/Z6rcNBbw6kjqhcm6024t1xkDhpEUE89M56 +hoA1KKw5/FmnW1xLA9trJeNyjGPRbx1JBxwyxEMPcEg9quWus2t5p099FFfLDDu3LNYTxSHAyds boHbg8bQcngZPFAGhRXP/wDCZaX/AM+uuf8Agivf/jNaF1rNrZ6dBfSxXzQzbdqw2E8sgyMjdGiF 14HO4DB4ODxQB5f8IP8AkofxO/7Co/8ARtxXsFeH/CTWbWL4h/EDdFfH7dqq+VtsJ225ln/1mE/d feH39uOfQ49c1LX7PSrhYLiHUndkDg2um3FwuMkctGjAHjpnPT1FAGpRWXpuv2eq3DQW8OpI6oXJ utNuLdcZA4aRFBPPTOevoarz+LNOtriWB7bWS8blGMei3jqSDjhliIYe4JB7UAblFZ9rrNreadPf RRXyww7tyzWE8UhwMnbG6B24PG0HJ4GTxWf/AMJlpf8Az665/wCCK9/+M0AdBRWfdaza2enQX0sV 80M23asNhPLIMjI3RohdeBzuAweDg8VjWfi+2uvEctoItV8h4YBCr6RcptkZ5AxYmMFVICfM2F4O Dw2E3YuMHJNrpr+KX6nU1z/irStH1T+xP7Xv/sf2XVYLqz/fJH51wu7ZH8wO7OT8o5OOKualr9np VwsFxDqTuyBwbXTbi4XGSOWjRgDx0znp6ivP/iFr9nqtx4Mgt4dSR18UWLk3Wm3FuuMuOGkRQTz0 znr6GmQeqUVhz+LNOtriWB7bWS8blGMei3jqSDjhliIYe4JB7VctdZtbzTp76KK+WGHduWawnikO Bk7Y3QO3B42g5PAyeKANCiuf/wCEy0v/AJ9dc/8ABFe//Ga0LrWbWz06C+livmhm27VhsJ5ZBkZG 6NELrwOdwGDwcHigDQorDg8Wadc3EUCW2sh5HCKZNFvEUEnHLNEAo9yQB3qxqWv2elXCwXEOpO7I HBtdNuLhcZI5aNGAPHTOenqKANSisvTdfs9VuGgt4dSR1QuTdabcW64yBw0iKCeemc9fQ1Xn8Wad bXEsD22sl43KMY9FvHUkHHDLEQw9wSD2oA3K5/SNK0e08X+I9Rsr/wA7U777N9vtvORvs+yMrH8o G5dy5PzZz2rQtdZtbzTp76KK+WGHduWawnikOBk7Y3QO3B42g5PAyeK838MeJbCD4pePbp7fVTHc f2fsCaTdO42wMDuQRlk9twGeoyKAPWKKz7rWbWz06C+livmhm27VhsJ5ZBkZG6NELrwOdwGDwcHi qcHizTrm4igS21kPI4RTJot4igk45ZogFHuSAO9AG5RWXqWv2elXCwXEOpO7IHBtdNuLhcZI5aNG APHTOenqKNN1+z1W4aC3h1JHVC5N1ptxbrjIHDSIoJ56Zz19DQBqUVhz+LNOtriWB7bWS8blGMei 3jqSDjhliIYe4JB7VctdZtbzTp76KK+WGHduWawnikOBk7Y3QO3B42g5PAyeKANCiuf/AOEy0v8A 59dc/wDBFe//ABmtC61m1s9OgvpYr5oZtu1YbCeWQZGRujRC68DncBg8HB4oAz/G2laPrfhC+07X 7/7Bpk3l+dc+ckWzEisvzOCoywUc+tdBXk/xf8S2GofC3WbWG31VJH8jBn0m6hQYnjPLvGFHTuee nWvRNS1+z0q4WC4h1J3ZA4NrptxcLjJHLRowB46Zz09RQBqUVl6br9nqtw0FvDqSOqFybrTbi3XG QOGkRQTz0znr6Gq8/izTra4lge21kvG5RjHot46kg44ZYiGHuCQe1AG5RWfa6za3mnT30UV8sMO7 cs1hPFIcDJ2xugduDxtByeBk8Vn/APCZaX/z665/4Ir3/wCM0AdBRWfdaza2enQX0sV80M23asNh PLIMjI3RohdeBzuAweDg8VTg8Wadc3EUCW2sh5HCKZNFvEUEnHLNEAo9yQB3oA3KKy9S1+z0q4WC 4h1J3ZA4NrptxcLjJHLRowB46Zz09RRpuv2eq3DQW8OpI6oXJutNuLdcZA4aRFBPPTOevoaAKf8A ZWj/APCw/wC1/t//ABO/7K+y/YvOT/j383d5mzG77/G7OO3WugryufX7O2+Pss7w6kUj8OG2YR6b cOxcXWchVQlk/wBsAqexr0S11m1vNOnvoor5YYd25ZrCeKQ4GTtjdA7cHjaDk8DJ4oA0KK5//hMt L/59dc/8EV7/APGa0LrWbWz06C+livmhm27VhsJ5ZBkZG6NELrwOdwGDwcHigDQorDg8Wadc3EUC W2sh5HCKZNFvEUEnHLNEAo9yQB3qxqWv2elXCwXEOpO7IHBtdNuLhcZI5aNGAPHTOenqKANSisvT dfs9VuGgt4dSR1QuTdabcW64yBw0iKCeemc9fQ1Xn8WadbXEsD22sl43KMY9FvHUkHHDLEQw9wSD 2oA3K5/x3/yTzxL/ANgq6/8ARTVoWus2t5p099FFfLDDu3LNYTxSHAydsboHbg8bQcngZPFcn408 Wadc+BfEMCW2sh5NMuUUyaLeIoJiYcs0QCj3JAHegCP4Jf8AJIdC/wC3j/0okr0CvM/hJqcGlfBj QJ7iO7dGedALW0luGz58p5WNWIHHXGOnqK7CDxZp1zcRQJbayHkcIpk0W8RQSccs0QCj3JAHegDc orL1LX7PSrhYLiHUndkDg2um3FwuMkctGjAHjpnPT1FGm6/Z6rcNBbw6kjqhcm6024t1xkDhpEUE 89M56+hoA1KKw5/FmnW1xLA9trJeNyjGPRbx1JBxwyxEMPcEg9quWus2t5p099FFfLDDu3LNYTxS HAydsboHbg8bQcngZPFAGhRXP/8ACZaX/wA+uuf+CK9/+M1oXWs2tnp0F9LFfNDNt2rDYTyyDIyN 0aIXXgc7gMHg4PFAGhXP6vpWj3fi/wAOaje3/k6nY/afsFt5yL9o3xhZPlI3NtXB+XGO9SQeLNOu biKBLbWQ8jhFMmi3iKCTjlmiAUe5IA71x/jnU4LH4t+AHmju2EKag7eRaSzEhoQo2hFJY5ByFyVG CcAg0AemUVl6br9nqtw0FvDqSOqFybrTbi3XGQOGkRQTz0znr6Gq8/izTra4lge21kvG5RjHot46 kg44ZYiGHuCQe1AG5RWfa6za3mnT30UV8sMO7cs1hPFIcDJ2xugduDxtByeBk8Vn/wDCZaX/AM+u uf8Agivf/jNAHQUVn3Ws2tnp0F9LFfNDNt2rDYTyyDIyN0aIXXgc7gMHg4PFU4PFmnXNxFAltrIe RwimTRbxFBJxyzRAKPckAd6ANyisvUtfs9KuFguIdSd2QODa6bcXC4yRy0aMAeOmc9PUUabr9nqt w0FvDqSOqFybrTbi3XGQOGkRQTz0znr6GgDUrn/BOlaPonhCx07QL/7fpkPmeTc+cku/MjM3zIAp wxYcelST+LNOtriWB7bWS8blGMei3jqSDjhliIYe4JB7VyfwVvYo/g5pshScra/aPMCwOS2JXb5A BmTgj7uecjqCKAPSKK5//hMtL/59dc/8EV7/APGa0LrWbWz06C+livmhm27VhsJ5ZBkZG6NELrwO dwGDwcHigDQorDg8Wadc3EUCW2sh5HCKZNFvEUEnHLNEAo9yQB3qxqWv2elXCwXEOpO7IHBtdNuL hcZI5aNGAPHTOenqKANSisvTdfs9VuGgt4dSR1QuTdabcW64yBw0iKCeemc9fQ1Xn8WadbXEsD22 sl43KMY9FvHUkHHDLEQw9wSD2oA3KKz7XWbW806e+iivlhh3blmsJ4pDgZO2N0DtweNoOTwMnis/ /hMtL/59dc/8EV7/APGaADxVpWj6p/Yn9r3/ANj+y6rBdWf75I/OuF3bI/mB3ZyflHJxxXQV5v8A FO9i/s7wVfbJ/J/4SWxm2+Q/mbcOceXjfux/DjdnjGeK6yDxZp1zcRQJbayHkcIpk0W8RQSccs0Q Cj3JAHegDcorL1LX7PSrhYLiHUndkDg2um3FwuMkctGjAHjpnPT1FGm6/Z6rcNBbw6kjqhcm6024 t1xkDhpEUE89M56+hoA1KKw5/FmnW1xLA9trJeNyjGPRbx1JBxwyxEMPcEg9quWus2t5p099FFfL DDu3LNYTxSHAydsboHbg8bQcngZPFAGhRXP/APCZaX/z665/4Ir3/wCM1oXWs2tnp0F9LFfNDNt2 rDYTyyDIyN0aIXXgc7gMHg4PFAGhRWHB4s065uIoEttZDyOEUyaLeIoJOOWaIBR7kgDvVjUtfs9K uFguIdSd2QODa6bcXC4yRy0aMAeOmc9PUUAU/CulaPpf9t/2Rf8A2z7Vqs91efvkk8m4bbvj+UDb jA+U8jPNdBXmfwk1OC5uPGECR3YeTxHe3KmS0lRQhKDBZlAV/wDYJDDuK7CfxZp1tcSwPbayXjco xj0W8dSQccMsRDD3BIPagDcorPtdZtbzTp76KK+WGHduWawnikOBk7Y3QO3B42g5PAyeKz/+Ey0v /n11z/wRXv8A8ZoA6Cis+61m1s9OgvpYr5oZtu1YbCeWQZGRujRC68DncBg8HB4qnB4s065uIoEt tZDyOEUyaLeIoJOOWaIBR7kgDvQBuUVl6lr9npVwsFxDqTuyBwbXTbi4XGSOWjRgDx0znp6ijTdf s9VuGgt4dSR1QuTdabcW64yBw0iKCeemc9fQ0Aalc/420rR9b8IX2na/f/YNMm8vzrnzki2YkVl+ ZwVGWCjn1qSfxZp1tcSwPbayXjcoxj0W8dSQccMsRDD3BIPauP8Ai3qcGq/BjX57eO7RFeBCLq0l t2z58R4WRVJHPXGOvoaAPTKK5/8A4TLS/wDn11z/AMEV7/8AGa0LrWbWz06C+livmhm27VhsJ5ZB kZG6NELrwOdwGDwcHigDQorDg8Wadc3EUCW2sh5HCKZNFvEUEnHLNEAo9yQB3qxqWv2elXCwXEOp O7IHBtdNuLhcZI5aNGAPHTOenqKANSisvTdfs9VuGgt4dSR1QuTdabcW64yBw0iKCeemc9fQ1Xn8 WadbXEsD22sl43KMY9FvHUkHHDLEQw9wSD2oA3KKz7XWbW806e+iivlhh3blmsJ4pDgZO2N0Dtwe NoOTwMnis/8A4TLS/wDn11z/AMEV7/8AGaAOgrn9I0rR7Txf4j1Gyv8AztTvvs32+285G+z7Iysf ygbl3Lk/NnPatC61m1s9OgvpYr5oZtu1YbCeWQZGRujRC68DncBg8HB4rzvwhr9m3xb8cOIdSxev pyRZ024BUiEr+8GzMQyer7QRz05oA9UrmNa8LaN9gi+y6DYeZ9rts+VZpnZ56b+g6bd2fbOeK09S 1+z0q4WC4h1J3ZA4NrptxcLjJHLRowB46Zz09RRpuv2eq3DQW8OpI6oXJutNuLdcZA4aRFBPPTOe voamUVJWZtQrzozUoO23zsTWei6Vp0xmsdMs7WVl2l4IFRiOuMgdOB+VXqw5/FmnW1xLA9trJeNy jGPRbx1JBxwyxEMPcEg9quWus2t5p099FFfLDDu3LNYTxSHAydsboHbg8bQcngZPFNJLYznOU3eT uzQorn/+Ey0v/n11z/wRXv8A8ZrG8UfFXQvCd9a2l9aanI9zapdIYrcLhGLABldlZW+U5BGR9a6M PhquIn7OjG77ENpK7OO/4W/4g/4WV/wjn2PTPsf9sfYN/lSeZ5fnbM5343Y9sZ7V7VXyB/wkFp/w sr/hI/Lm+x/2x9v2bR5nl+dvxjON2PfGe9e42fx18MXt9b2kdhrQeeRY1P2ZH5Y4Hyq5Y9eigk9g TX0+dZLOKpyw1LRR963fzMKdRa8zO+121s77w9qdnqNx9nsZ7SWK4m3hPLjZCGbceBgEnJ4FGhWt nY+HtMs9OuPtFjBaRRW828P5kaoArbhwcgA5HBrm/FOv2eq+BfE8FvDqSOuj3bk3Wm3FuuPKYcNI ignnpnPX0NV/BfizTrbwL4ege21kvHplsjGPRbx1JESjhliIYe4JB7V8idB0fiW0srzTY474TmIT Bh5FiLps4P8AAY5MDk849s84PDxaLoR127jI1HyltoGXHh9C2S0ucp9l4HA5wM8jJ24HR+ILuDXv D8clvZ3ciJdBSl1psqNkIeQkltIcc/e2AdRu6g8RHpmdXuU/szOIIjt/s7plpOcf2fxnHXaM46tj C8VdrnWh9NlUJPDSak193dd0eqaFBb2ujW8Np5vkLu2+bbC3b7xJzGEQLzn+EZ685ydGud0u9g0P wtZvcW12qb2QR2unyyMCWY8xxwIQOOvlqOR1yCZoPFmnXNxFAltrIeRwimTRbxFBJxyzRAKPckAd 664fCj5/Eq1aa83+ZuVw/wAYf+SV6z/2w/8AR8ddJqWv2elXCwXEOpO7IHBtdNuLhcZI5aNGAPHT OenqKw9e+INnpHh6/wBUt9O1Kd7REcxXVjcWasGkROJJIgM/PnHJOD7kduAlKOKpSgrtSVltd3Wl +lznl8Lueffs7f8AMyf9uv8A7Vr3GvN/B3xdtfE/237Tot9afZ9m37JBPfbt27OfKi+TG3v1ycdD XcWus2t5p099FFfLDDu3LNYTxSHAydsboHbg8bQcngZPFdWd1KtTH1JVocktLq97aLqvvJppKKse X+If+TofCf8A2CpP/QbqvYK8L13X7OX9o3wxqKw6kIItMdGRtNuFlJ23H3Yim9h8w5CkdfQ49kut ZtbPToL6WK+aGbbtWGwnlkGRkbo0QuvA53AYPBweK8o0NCisODxZp1zcRQJbayHkcIpk0W8RQScc s0QCj3JAHerGpa/Z6VcLBcQ6k7sgcG1024uFxkjlo0YA8dM56eooA1KKy9N1+z1W4aC3h1JHVC5N 1ptxbrjIHDSIoJ56Zz19DVefxZp1tcSwPbayXjcoxj0W8dSQccMsRDD3BIPagDcorPtdZtbzTp76 KK+WGHduWawnikOBk7Y3QO3B42g5PAyeKz/+Ey0v/n11z/wRXv8A8ZoA6CisObxZp0DhHttZJKK/ yaLeOMMoYcrERnB5HUHIOCCKj/4TLS/+fXXP/BFe/wDxmgDP+GFrZ2PgK1s9OuPtFjBd3sVvNvD+ ZGt1KFbcODkAHI4NdhXn/wAEv+SQ6F/28f8ApRJXoFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAB RRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQB8kfBfwx pfi7xNq2kavB5tvJpUhVl4eJxLFh0PZhk/mQQQSD0l1Z/Ev4Jo09pdx6l4bR9o35kgXczhd0ZIeI kncdh2lmUFmPFU/2cf8Akoeof9gqT/0bFX0/QB5X4X+PXhTXESLVWk0W8Z1TZPmSJizEDEqjAAGC S4UDPcAmvTLG/s9Ts47ywu4Lu1kzsmgkEiNgkHDDg4II/CvO/FHwM8IeIXe4tIZNHuyjANYhViLb QFLREYwMZwm3OTk5OR5pffBDx74VvJLvwpq32rfiIPZ3Js5yhALbgWChdwAwHOflOPQA+l6K+dPD Wp/GXSPFWkaJqkesyaet7Cl1JJaLcr5TuC+bja2RtY87/l6cY4+i6ACiiigDx/xD/wAnQ+E/+wVJ /wCg3Vdp8Rtc17w14OuNZ8P2tpcz2jq88dzG7/ueQxUIQcglWJJwFDHtXQSaTps2qQ6pLp9o+oQp siu2hUyovPCvjIHzNwD3PrVygDy+x+PfgmfQ4727up7W+8ovJp4gkdw4z8iuF2HJHBJHUZ28gcv4 W8F6j4q+H/jvV7m0ntZvFUpvLGy3KGOxmmiO9v4WdtvIXKrkHDAj2D/hE/Df9o/2j/wj+lfbvN8/ 7T9ij8zzM7t+7Gd2ec9c1sUAeN+A/jB4b0rwdYaP4nu5NL1bTE+wzW72cx4j+VT8obB2gAg4O4Nw BipPhQlx4p8c+KPiHPZz21rfYtNPLAKssSkAkrkksBFECQdu4uBnHHpF94T8N6neSXl/4f0q7upM b5p7KOR2wABliMnAAH4VqQQQ2tvFb28UcMESBI441CqigYAAHAAHGKAMO8/5KHo3/YKv/wD0baV0 Fc/ef8lD0b/sFX//AKNtK6CgAooooAKKKKACiiigArP126s7Hw9qd5qNv9osYLSWW4h2B/MjVCWX aeDkAjB4NaFYfjSCa68C+Ibe3ikmnl0y5SOONSzOxiYAADkknjFAFzQrqzvvD2mXmnW/2exntIpb eHYE8uNkBVdo4GAQMDgVoVh+C4JrXwL4et7iKSGeLTLZJI5FKsjCJQQQeQQeMVuUAFFFFABRRRQA UUUUAFc//auj/wDCw/7I+wf8Tv8Asr7V9t8lP+Pfzdvl787vv87cY79a6CuH+wXn/C9f7R+yT/Yf +Ea8j7T5Z8vzPtO7Zu6bsc464oA7iiiigAooooAKKKKACiiigArn/BOq6PrfhCx1HQLD7Bpk3meT beSkWzEjK3yoSoywY8etdBXD/CCwvNM+FujWd/aT2l1H5++GeMxuuZ5CMqeRkEH8aAO4ooooAKKK KACiiigAooooA5/V9V0e08X+HNOvbDztTvvtP2C58lG+z7Iw0nzE7l3LgfLnPeugrh/E9heXHxS8 BXkNpPJa2v8AaH2iZIyUi3QKF3MOFyeBnrXcUAFFFFABRRRQAUUUUAFFFFAHj/wg/wCSh/E7/sKj /wBG3FewV4/8IP8AkofxO/7Co/8ARtxXsFABRRRQAUUUUAV73T7LUYRDfWkF1Erbgk8YdQemcEde T+dc7B4b0I+Kb+E6LpxiWytmVDaptBLzgkDHU7R+Q9K6K9sor+ERTPOqht2YLiSFs/VCDjnp0rnY NAsz4pv4vO1HatlbMCNSuN2S8/U78kcDg8DnHU1lON5LRHoYWry0prnktOn+JeaOktbW3srdLe0t 4oIEztjiQIq5OTgDjqSaxfFWq6Ppf9if2vYfbPtWqwWtn+5STybht2yT5iNuMH5hyM8VtWtslpbp BG0rIucGWVpG5OeWYkn8TXG/EmwvL7/hEfsdpPceR4ls55vJjL+XGu/c7Y6KMjJPArRbHDJ3k3e5 3FFFFMkKKKKACiiigAooooAK5/SNV0e78X+I9OsrDydTsfs32+58lF+0b4y0fzA7m2rkfNjHaugr h/DFheW/xS8e3k1pPHa3X9n/AGeZ4yEl2wMG2seGweDjpQB3FFFFABRRRQAUUUUAFFFFAHP+NtV0 fRPCF9qOv2H2/TIfL8628lJd+ZFVflchThip59K6CuH+L9hean8LdZs7C0nu7qTyNkMEZkdsTxk4 UcnABP4V3FABRRRQAUUUUAFFFFABRRRQBz/9q6P/AMLD/sj7B/xO/wCyvtX23yU/49/N2+Xvzu+/ ztxjv1roK4f7Bef8L1/tH7JP9h/4RryPtPlny/M+07tm7puxzjriu4oAKKKKACiiigAooooAK5/x 3/yTzxL/ANgq6/8ARTV0Fc/47/5J54l/7BV1/wCimoA5/wCCX/JIdC/7eP8A0okr0CvP/gl/ySHQ v+3j/wBKJK9AoAKKKKACiiigAooooAK5/V9V0e08X+HNOvbDztTvvtP2C58lG+z7Iw0nzE7l3Lgf LnPeugrh/E9heXHxS8BXkNpPJa2v9ofaJkjJSLdAoXcw4XJ4GetAHcUUUUAFFFFABRRRQAUUUUAF c/4J1XR9b8IWOo6BYfYNMm8zybbyUi2YkZW+VCVGWDHj1roK4f4QWF5pnwt0azv7Se0uo/P3wzxm N1zPIRlTyMgg/jQB3FFFFABRRRQAUUUUAFFFFAHP+KtV0fS/7E/tew+2fatVgtbP9yknk3Dbtknz EbcYPzDkZ4roK4f4k2F5ff8ACI/Y7Se48jxLZzzeTGX8uNd+52x0UZGSeBXcUAFFFFABRRRQAUUU UAFFFFAHP+FdV0fVP7b/ALIsPsf2XVZ7W8/cpH51wu3fJ8pO7OR8x5OOa6CuH+G1heWP/CXfbLSe 38/xLeTw+dGU8yNtm11z1U4OCODXcUAFFFFABRRRQAUUUUAFc/421XR9E8IX2o6/Yfb9Mh8vzrby Ul35kVV+VyFOGKnn0roK4f4v2F5qfwt1mzsLSe7upPI2QwRmR2xPGThRycAE/hQB3FFFFABRRRQA UUUUAFFFFABXP6Rquj3fi/xHp1lYeTqdj9m+33Pkov2jfGWj+YHc21cj5sY7V0FcP4YsLy3+KXj2 8mtJ47W6/s/7PM8ZCS7YGDbWPDYPBx0oA7iiiuY1rxTo32CL7Lr1h5n2u2z5V4mdnnpv6Hpt3Z9s 54qZSUVdm1ChOtNRgr7fK509FUbPWtK1GYw2Op2d1Kq7ikE6uwHTOAenI/Or1NNPYznCUHaSswr5 A8B+H7TxR400/Rr6SaO2ufM3tAwDjbGzDBII6qO1fX9fKvwe/wCSqaN/23/9ESV9dw5OVPCYycHZ qKa9bSOasryij1X/AIUD4V/6CGs/9/ov/jdeT/E/whp/grxLbabps1zLDLZrOzXLKzbi7rj5VAxh R2r6tr5y+P3/ACPdj/2DI/8A0bLWvDuZ4vEY5U61RtWegq0IqN0j2HSLqzsfhHY3mo2/2ixg0KOW 4h2B/MjWAFl2ng5AIweDW5oV1Z33h7TLzTrf7PYz2kUtvDsCeXGyAqu0cDAIGBwK5cQTXXwK+z28 Uk08vhrZHHGpZnY22AABySTxitzwXBNa+BfD1vcRSQzxaZbJJHIpVkYRKCCDyCDxivlMV/Hn6v8A M3jsij8QJ7O18OLcX726QRzqT5yq+SQQAqmGYseeyZxk5ABz5QmveHRfzSmW18lokVT9h43Avnj+ z+OCvO0Z9WxhfYfG3hj/AITHwhfaB9s+x/avL/f+V5m3bIr/AHcjOduOvevC7P8AZ28STSw2d/qm m29qjNI9xAXlPzAABUIXJBQZyQMMMEkEVwVaPPJO57OBzFUKMoON/n5ryPfvDMcUXh61SGS1kjG/ DWro8Z+c9CiIp/BRznqeTrUUVvFWSR5dWftJyn3dwrzj416xYWXgC60y4n2XmobPs0exj5nlyxs/ IGBgHuR7V6PXD/ET4d/8J9/Zv/E1+w/YvN/5d/N379n+0uMbPfrXo5VOhTxtOpiJWjF3v6aro+tj Cabi0jzH4GeJNJ0S/wBTsdRu/JudSltobRPLdvMfLjGVBA5deuOtfQ1eOaL8CP7H17TtT/4STzvs dzHceX9h279jBsZ8w4zjrivY67eIK+ExGK9vhp83Nvo1a1krXS6LzJpKSjaR4/4h/wCTofCf/YKk /wDQbqvYK8f8Q/8AJ0PhP/sFSf8AoN1XsFeEahRRRQAUUUUAFFFFABRRRQBx/wAMLqzvvAVreadb /Z7Ge7vZbeHYE8uNrqUqu0cDAIGBwK7CuD+DME1r8KdHt7iKSGeJ7lJI5FKsjC4kBBB5BB4xXeUA FFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAU UUUAFFFFABRRRQAUUUUAFFFFAHjfwm+E2veA/FV1qmqXemzQS2T26rayOzBi6Nk7kUYwh7+leyVx fj74maL4At41vBJdahOjNBZQkbiADhnJ+4hYYzyeuAcHHH+F/wBobRdZ1RLHWNNk0cTOqRXBuBLE Cc/6w7VKDO0ZwRzk7QM0AeyUV4v8U/jX/wAI5eSaF4YME+pR7kurtxvS2bBG1R0aQHk5yq4wQTkL wknxQ+Lnhx4b/WoLsWm/Zs1HSRDFIxU4G5UQ54JADD7vcZoA+o6K4P4Z/Eyx8f6WUcR22tW6A3Vo DwR08yPPJQnt1UnB6gt3lABRRRQAUUUUAFFFFABRRRQBz95/yUPRv+wVf/8Ao20roK5+8/5KHo3/ AGCr/wD9G2ldBQAUUUUAFFFFABRRRQAVl+JdSm0bwrq+qW6xtPZWU1xGsgJUsiFgDgg4yPUVqVl+ JdNm1nwrq+l27RrPe2U1vG0hIUM6FQTgE4yfQ0AHhrUptZ8K6Rqlwsaz3tlDcSLGCFDOgYgZJOMn 1NalZfhrTZtG8K6Rpdw0bT2VlDbyNGSVLIgUkZAOMj0FalABRRRQAUUUUAFFFFABXL/8JJef8LT/ AOEX8uD7D/Yn9oeZtPmeZ5/l4znG3HbGc966iuX/AOEbvP8Ahaf/AAlHmQfYf7E/s/y9x8zzPP8A MzjGNuO+c57UAdRRRRQAUUUUAFFFFABRRRQAVy/w78SXni7wJpuuX8cEd1debvSBSEG2V0GAST0U d66iuX+Hfhu88I+BNN0O/kgkurXzd7wMSh3Su4wSAejDtQB1FFFFABRRRQAUUUUAFFFFAHL654kv NM8d+FNDhjga11f7Z9od1JdfKiDrtIOBknnIP4V1Fcvrnhu81Px34U1yGSBbXSPtn2hHYh282IIu 0AYOCOckfjXUUAFFFFABRRRQAUUUUAFFFFAHj/wg/wCSh/E7/sKj/wBG3FewV4/8IP8AkofxO/7C o/8ARtxXsFABRRRQAUUUUAV73ULLToRNfXcFrEzbQ88gRSeuMk9eD+VYEPinRv8AhI73dr1h9l+y W/l5vE2b9827HOM42Z/4D7Vraz9l+xp9s+3+X5gx9h8/fnB6+T82OvXjp3xXJQ/2P/wkd7n/AISP y/slvtx/aG/O+bOcfNjpjPH3sc7qwqSkpKzR6mDoUp0puUZN26LTdbeZ3FrdW97bpcWlxFPA+dsk Th1bBwcEcdQRXO+NPEl54c/4R77HHA/9pa3bafN5yk7Y5N24rgjDcDBOR7Vu6Z5H9nRfZvtXk87f tXm+Z1Oc+b8/X17YxxisLxp4bvPEf/CPfY5IE/s3W7bUJvOYjdHHu3BcA5bkYBwPetlsedUSU2l+ O/zOoooopkBRRRQAUUUUAFFFFABXL6H4kvNT8d+K9DmjgW10j7H9ndFIdvNiLtuJODgjjAH411Fc vofhu80zx34r1yaSBrXV/sf2dEYl18qIo24EYGSeME/hQB1FFFFABRRRQAUUUUAFFFFAHL/ETxJe eEfAmpa5YRwSXVr5WxJ1JQ7pUQ5AIPRj3rqK5f4ieG7zxd4E1LQ7CSCO6uvK2POxCDbKjnJAJ6Ke 1dRQAUUUUAFFFFABRRRQAUUUUAcv/wAJJef8LT/4Rfy4PsP9if2h5m0+Z5nn+XjOcbcdsZz3rqK5 f/hG7z/haf8AwlHmQfYf7E/s/wAvcfM8zz/MzjGNuO+c57V1FABRRRQAUUUUAFFFFABXP+O/+See Jf8AsFXX/opq6Cuf8d/8k88S/wDYKuv/AEU1AHP/AAS/5JDoX/bx/wClElegV5/8Ev8AkkOhf9vH /pRJXoFABRRRQAUUUUAFFFFABXL654kvNM8d+FNDhjga11f7Z9od1JdfKiDrtIOBknnIP4V1Fcvr nhu81Px34U1yGSBbXSPtn2hHYh282IIu0AYOCOckfjQB1FFFFABRRRQAUUUUAFFFFABXL/DvxJee LvAmm65fxwR3V15u9IFIQbZXQYBJPRR3rqK5f4d+G7zwj4E03Q7+SCS6tfN3vAxKHdK7jBIB6MO1 AHUUUUUAFFFFABRRRQAUUUUAcv408SXnhz/hHvsccD/2lrdtp83nKTtjk3biuCMNwME5HtXUVy/j Tw3eeI/+Ee+xyQJ/Zut22oTecxG6OPduC4By3IwDge9dRQAUUUUAFFFFABRRRQAUUUUAcv4L8SXn iP8A4SH7ZHAn9m63c6fD5Kkbo49u0tknLcnJGB7V1Fcv4L8N3nhz/hIftkkD/wBpa3c6hD5LE7Y5 Nu0NkDDcHIGR711FABRRRQAUUUUAFFFFABXL/ETxJeeEfAmpa5YRwSXVr5WxJ1JQ7pUQ5AIPRj3r qK5f4ieG7zxd4E1LQ7CSCO6uvK2POxCDbKjnJAJ6Ke1AHUUUUUAFFFFABRRRQAUUUUAFcvofiS81 Px34r0OaOBbXSPsf2d0Uh282Iu24k4OCOMAfjXUVy+h+G7zTPHfivXJpIGtdX+x/Z0RiXXyoijbg RgZJ4wT+FAHUVna1azXdhFHAm91u7aQjIHypOjsefRVJ/CtGuV1/X7OXTolWHUQRe2jfNptwowLi Mnkp144HUngcmoqSSi7nThKVSdaPIr2a6X6nVUVRs9Wtr+YxQx3isF3ZnspoVx9XUDPPTrV6qTT2 MJwlB2krMK+Vfg9/yVTRv+2//oiSvqqvlX4Pf8lU0b/tv/6Ikr6vh/8A3HG/4P0mc1X4on1VXzl8 fv8Ake7H/sGR/wDo2Wvo2vnL4/f8j3Y/9gyP/wBGy1hwr/yMV6Mdf4D12w1KbRvg1a6pbrG09l4f S4jWQEqWS3DAHBBxkeorc8NalNrPhXSNUuFjWe9sobiRYwQoZ0DEDJJxk+prDsNNm1n4NWul27Rr Pe+H0t42kJChntwoJwCcZPoauWtzaeA/h9p7a9dRwwaXZW9vczxq8ihgFjyABuILY7d+1eHiv48/ V/max2R0lfLHwg8WeJNT+KWjWd/4g1W7tZPP3wz3skiNiCQjKk4OCAfwrU1b9orxDDrN9Fpdpo0+ npcSLayyW8wZ4gx2Mf3g5K4PQfQV5X4W8SXnhHxHaa5YRwSXVrv2JOpKHcjIcgEHox71gM+56K8L +Hfx0vfEPiqPS/EiabZwXCCO1a1t5d0lwzoqIfmYAEFuSAOByK90oAKKKKACiiigDx/xD/ydD4T/ AOwVJ/6DdV7BXj/iH/k6Hwn/ANgqT/0G6r2CgAooooAKKKKACiiigAooooA4v4UalNrPw6sNUuFj We9uLu4kWMEKGe6lYgZJOMn1NdpXF/CjTZtG+HVhpdw0bT2Vxd28jRklSyXUqkjIBxkegrtKACii igAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKK ACiiigAooooAKKKKACiiigD5M8F6QvxZ+L15dar5n2OR5dQuYWuGL+UGASJXxkgFo1/h+UHGDivW /it8MPD954Gvr/SdKsdNv9Mie6R7aJYVdFGZFcKvzfKDj0YDkAtnyTwvqU3wd+L1zZ6isctujmyu ZmBBFu7I6zKFLYO0I+3k4yvB5H03a3+heNPD0/2O7g1HTLyJoJvJkP3XT5kbGGRtrDIOGGe1AHin 7PGgNqOqax4v1FZLidH+zwXEzK5aV/mmY5y2/BQbuMiRhzk49/nghureW3uIo5oJUKSRyKGV1IwQ QeCCOMVh+GPBPh3wd9q/sDT/ALH9q2ed++kk3bc7fvscY3N09aj8V+PPDngy3L6zqMcc5TdHaR/P PJw2MIOQCVI3HC54JFAHz5ZW7/Dv9omLTNIl/wBFfUIrbyyWC+RcbD5Z+bLbBIMEk5ZFYjtX1PXy x4Fh1H4mfG0eIrm2nFrDdi+neMri3VB+4jLYAPKIvTcwDHsSPqegAooooAKKKKACiiigAooooA5+ 8/5KHo3/AGCr/wD9G2ldBXP3n/JQ9G/7BV//AOjbSugoAKKKKACiiigAooooAKw/Gk81r4F8Q3Fv LJDPFply8ckbFWRhExBBHIIPOa3Kz9dtbO+8PanZ6jcfZ7Ge0liuJt4Ty42Qhm3HgYBJyeBQBT8F zzXXgXw9cXEsk08umWzySSMWZ2MSkkk8kk85rcrP0K1s7Hw9plnp1x9osYLSKK3m3h/MjVAFbcOD kAHI4NaFABRRRQAUUUUAFFFFABXD/b7z/hev9nfa5/sP/CNef9m8w+X5n2nbv29N2OM9cV3Fc/8A 2Vo//Cw/7X+3/wDE7/sr7L9i85P+Pfzd3mbMbvv8bs47daAOgooooAKKKKACiiigAooooAK4f4QX 95qfwt0a8v7ue7upPP3zTyGR2xPIBljycAAfhXcVz/gnStH0TwhY6doF/wDb9Mh8zybnzkl35kZm +ZAFOGLDj0oA6CiiigAooooAKKKKACiiigDh/E9/eW/xS8BWcN3PHa3X9ofaIUkISXbApXco4bB5 GeldxXP6vpWj3fi/w5qN7f8Ak6nY/afsFt5yL9o3xhZPlI3NtXB+XGO9dBQAUUUUAFFFFABRRRQA UUUUAeP/AAg/5KH8Tv8AsKj/ANG3FewV4/8ACD/kofxO/wCwqP8A0bcV7BQAUUUUAFFFFAGN4l0q XWNNjt4YYJWWYPtnMe3GCP44pRnn+6D79jw8Xg28bXbu3+xaduS2gcqTb7QGaUcf6HjPynooPAyT wF9JvdPstRhEN9aQXUStuCTxh1B6ZwR15P51gQ+FtG/4SO93aDYfZfslv5ebNNm/fNuxxjONmf8A gPtXPVpc0k/6/I9jA472NGUL9O1+q/vI1tCsX03Rre0kjijePdlYtu0ZYnjbHGO/ZR+PU8x8Sb+8 sf8AhEfsd3Pb+f4ls4JvJkKeZG2/cjY6qcDIPBrsrW1t7K3S3tLeKCBM7Y4kCKuTk4A46kmsXxVp Wj6p/Yn9r3/2P7LqsF1Z/vkj864Xdsj+YHdnJ+UcnHFbxVkkeXVnzzlLuzoKKKKZmFFFFABRRRQA UUUUAFcP4Yv7y4+KXj2zmu55LW1/s/7PC8hKRboGLbVPC5PJx1ruK5/SNK0e08X+I9Rsr/ztTvvs 32+285G+z7Iysfygbl3Lk/NnPagDoKKKKACiiigAooooAKKKKAOH+L9/eaZ8LdZvLC7ntLqPyNk0 Ehjdczxg4YcjIJH413Fc/wCNtK0fW/CF9p2v3/2DTJvL86585ItmJFZfmcFRlgo59a6CgAooooAK KKKACiiigAooooA4f7fef8L1/s77XP8AYf8AhGvP+zeYfL8z7Tt37em7HGeuK7iuf/srR/8AhYf9 r/b/APid/wBlfZfsXnJ/x7+bu8zZjd9/jdnHbrXQUAFFFFABRRRQAUUUUAFc/wCO/wDknniX/sFX X/opq6Cuf8d/8k88S/8AYKuv/RTUAc/8Ev8AkkOhf9vH/pRJXoFef/BL/kkOhf8Abx/6USV6BQAU UUUAFFFFABRRRQAVw/ie/vLf4peArOG7njtbr+0PtEKSEJLtgUruUcNg8jPSu4rn9X0rR7vxf4c1 G9v/ACdTsftP2C285F+0b4wsnykbm2rg/LjHegDoKKKKACiiigAooooAKKKKACuH+EF/ean8LdGv L+7nu7qTz9808hkdsTyAZY8nAAH4V3Fc/wCCdK0fRPCFjp2gX/2/TIfM8m585Jd+ZGZvmQBThiw4 9KAOgooooAKKKKACiiigAooooA4f4k395Y/8Ij9ju57fz/EtnBN5MhTzI237kbHVTgZB4NdxXP8A irStH1T+xP7Xv/sf2XVYLqz/AHyR+dcLu2R/MDuzk/KOTjiugoAKKKKACiiigArO1+6msvDmqXdu +yeC0lkjbAO1lQkHB46itGub8SeG9Kn0LV5odFs5L6S2mZHS1UytIVJBBAyWz+Oaid+V2OjCqm60 VUel10v166o6Sis610DRrK4S4tNIsIJ0ztkitkRlyMHBAz0JFaNUr9TKagn7jv6q36s4f4bX95ff 8Jd9su57jyPEt5BD50hfy412bUXPRRk4A4FdxXP+FdK0fS/7b/si/wDtn2rVZ7q8/fJJ5Nw23fH8 oG3GB8p5Gea6CmQFFFFABRRRQAUUUwSxmZoRIplVQzID8wByASPQ7T+R9KAsPrh/i/f3mmfC3Wby wu57S6j8jZNBIY3XM8YOGHIyCR+NdxXP+NtK0fW/CF9p2v3/ANg0yby/OufOSLZiRWX5nBUZYKOf WgDoKKKKACiiigAooooA8n+J/wAT9a8FeJbbTdNtdPlhls1nZrmN2bcXdcfK4GMKO1ZvgP4v+IPF HjTT9GvrPTI7a58ze0EUgcbY2YYJcjqo7Ve+P1laf8InY3/2WH7Z9ujh+0eWPM8vy5Ts3dduecdM 0z4C6Xp8vha51KSxtnv4tQkSO6aFTKi+VHwHxkD5m4z3PrX2EKeBWS/WJUry1jfrfuc7cvaWuev1 w/hi/vLj4pePbOa7nktbX+z/ALPC8hKRboGLbVPC5PJx1ruK5/SNK0e08X+I9Rsr/wA7U777N9vt vORvs+yMrH8oG5dy5PzZz2r486DoK4HWrLxSthEZ73cn2u2AH2yI/MZ02ni0H8WO/Ho3Q99XK6/r 9nLp0SrDqIIvbRvm024UYFxGTyU68cDqTwOTWNZLl1dj0MtlNVlywUtV0vbX8C9o1rr0N47apdeb AYyFX7QknzZHOFt4z0z/ABH6dxuVRs9Wtr+YxQx3isF3ZnspoVx9XUDPPTrV6tIWto7nNiHJzvKP K+1rBXyP/wATX4XeP/8AlyuNR07/AHnibzIv+Ak/K/tzX1xXg/iD4A3f29P+Ec1CH7H5Q3/2jMfM 8zJzjZHjbjb75zX1HDeMw9CVWniZWjNWs1o9+vTR7db+RxVot2cTK/4X94q/6B+jf9+Zf/jlcV4v 8X6h411aLUtShtopooBAq2ysq7QzNn5mJzlj3qp/wj93/wAJZ/wjnmQ/bPt32DfuPl+Z5mzOcZ25 9s47V6PZfAHxB9vt/t+oaZ9j81fP8iaTzPLyN23MeN2M4zxmvrmspy6Sq2jBtaeaOf8AeT0PWNTt 7vw/8ILy2E/l3un6C8fnW7kbZI7cjcjcEcjIPBrkfHM811+zNHcXEsk08umae8kkjFmdi8JJJPJJ POa9ButF06DwRNoVzdPDpcemtZy3EkiqyQiPYXLEbQQvOSMe1ZWs6BeXnwvj0Pwhq/kTLaW0Vjf/ AGkrmNCmG8yMfxIp5UYOfQ1+X1Zc05Sve7O1bHzh8MvFXg/wz/an/CV6D/av2jyvs3+hwz+Vt37v 9YRjO5enXHtXf/8AC0/hB/0IX/lHtP8A4uvLNW8A+No9ZvkuNB1m+nW4kEl3HZzSrO245cOVywY8 575zXN2NheaneR2dhaT3d1JnZDBGZHbAJOFHJwAT+FZjOo0K6s774yaZeadb/Z7GfxBFLbw7Anlx tcAqu0cDAIGBwK+z6+VPhZ4F8bR+OrK4Sz1LRYLd0mupLqKa2WeFZULwg7cMWHO08HBz0r6roAKK KKACiiigDx/xD/ydD4T/AOwVJ/6DdV7BXj/iH/k6Hwn/ANgqT/0G6r2CgAooooAKKKKACiiigAoo ooA4P4MzzXXwp0e4uJZJp5XuXkkkYszsbiQkknkknnNd5XH/AAwtbOx8BWtnp1x9osYLu9it5t4f zI1upQrbhwcgA5HBrsKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoo ooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigDk/Gfw58OeOkRtXtpFu4k2RXlu+yVF3 A4zghh14YHG5sYJzUngDwXb+A/C6aPBP9pkMrzT3Gwp5rscA7SzbcKFXg/w56k15/wDFP41/8I5e SaF4YME+pR7kurtxvS2bBG1R0aQHk5yq4wQTkLymlfGLx/4T1S3PjbTrubT7l8EXVh9mlCr94xEK gYjcpIbPQDK5zQB9J1538Q/hNY/EDWdM1GbUJLJ7ZPJuPLj3tPFu3BQS2EIy/O0/e5BwBXmnjvxx 4l+JXiifwj4Jjnawg81JDbTKv2wAFXd5AdohOcAE4bcCckqq4958EviB4ViGr6XcQT3UG4j+yrqR Z0XadxXKqTxkYUljuwAaAPovwv4R0XwdpaWGj2UcICKss5UGWcjJ3SPjLHLN7DOAAOK3K8X+CnxT uPEePDGuy+ZqUMRe1u3cbrlFxlGyctIBzkZ3KCTypLe0UAFFFFABRRRQAUUUUAFFFFAHP3n/ACUP Rv8AsFX/AP6NtK6CufvP+Sh6N/2Cr/8A9G2ldBQAUUUUAFFFFABRRRQAVz/jv/knniX/ALBV1/6K augrP126s7Hw9qd5qNv9osYLSWW4h2B/MjVCWXaeDkAjB4NAGf4E/wCSeeGv+wVa/wDopa6Cs/Qr qzvvD2mXmnW/2exntIpbeHYE8uNkBVdo4GAQMDgVoUAFFFFABRRRQAUUUUAFef8A/Nwv/cqf+3de gVz/APauj/8ACw/7I+wf8Tv+yvtX23yU/wCPfzdvl787vv8AO3GO/WgDoKKKKACiiigAooooAKKK KACvP/gl/wAkh0L/ALeP/SiSvQK5/wAE6ro+t+ELHUdAsPsGmTeZ5Nt5KRbMSMrfKhKjLBjx60Ad BRRRQAUUUUAFFFFABRRRQB5/4t/5K98Ov+4n/wCk616BXP6vquj2ni/w5p17Yedqd99p+wXPko32 fZGGk+Yncu5cD5c5710FABRRRQAUUUUAFFFFABRRRQB4/wDCD/kofxO/7Co/9G3FewV4/wDCD/ko fxO/7Co/9G3FewUAFFFFABRRRQAUUUUAFef/ABT/AOZK/wCxrsf/AGevQK5/xVquj6X/AGJ/a9h9 s+1arBa2f7lJPJuG3bJPmI24wfmHIzxQB0FFFFABRRRQAUUUUAFFFUdFvJNR0LT76ZVWW5to5nCD CgsoJxntzSvrYpQbi5dF+t/8i9Xn/hL/AJK98Rf+4Z/6TtXoFc/pGq6Pd+L/ABHp1lYeTqdj9m+3 3Pkov2jfGWj+YHc21cj5sY7UyToKKKKACiiigAooooAKKKKAPP8A42/8kh13/t3/APSiOvQK5/xt quj6J4QvtR1+w+36ZD5fnW3kpLvzIqr8rkKcMVPPpXQUAFFFFABRRRQAUUVRvda0rTphDfanZ2sr LuCTzqjEdM4J6cH8qTaW5UISm7RV2XqK5jRfFOjfYJftWvWHmfa7nHm3iZ2ee+zqem3bj2xjiunp RkpK6NK9CdGbjNW3+djz/wD5uF/7lT/27r0Cuf8A7V0f/hYf9kfYP+J3/ZX2r7b5Kf8AHv5u3y9+ d33+duMd+tdBVGIUUUUAFFFFABRRRQAVz/jv/knniX/sFXX/AKKaugrn/Hf/ACTzxL/2Crr/ANFN QBz/AMEv+SQ6F/28f+lElegV5/8ABL/kkOhf9vH/AKUSV6BQAUUUUAFFFFABRRRQAV5/4t/5K98O v+4n/wCk616BXP6vquj2ni/w5p17Yedqd99p+wXPko32fZGGk+Yncu5cD5c570AdBRRRQAUUUUAF FFFAHMa14p0b7BF9l16w8z7XbZ8q8TOzz039D027s+2c8Vs2etaVqMxhsdTs7qVV3FIJ1dgOmcA9 OR+dM1q1mu7CKOBN7rd20hGQPlSdHY8+iqT+FaNZpS5tTrnKi6KUU73fVdl5BXn/AMEv+SQ6F/28 f+lElegVz/gnVdH1vwhY6joFh9g0ybzPJtvJSLZiRlb5UJUZYMePWtDkOgooooAKKKKACiiigAoo ooA8/wDin/zJX/Y12P8A7PXoFc/4q1XR9L/sT+17D7Z9q1WC1s/3KSeTcNu2SfMRtxg/MORniugo AKKKKACiiigAooooAKKKKAPP/hZ/zOv/AGNd9/7JXoFc/wCFdV0fVP7b/siw+x/ZdVntbz9ykfnX C7d8nyk7s5HzHk45roKACiiigAooooAr3tzLawh4bKe8Ytjy4GjDAevzsox+Oea52DVbweKb9/7A 1EsbK2BjElvuUB5+T+9xg5PQ54OccZ0fEuqy6PpsdxDNBEzTBN04j24wT/HLEM8f3ifbuOHi8ZXi 67d3H23Ttz20CFiLfaQrSnj/AEzGfmPRieRkDgtz1aijJK7/AAPZwGEnVoyklF3XW/ddj0u1me4t 0lktpbZ2zmKUqWXnvtJHvwe9cL8bf+SQ67/27/8ApRHXX6FfPqWjW93JJFI8m7LRbdpwxHG2SQdu zH8OgoeNtV0fRPCF9qOv2H2/TIfL8628lJd+ZFVflchThip59K3i7pM8qrFwnKL6M6CiiimZhRRR QAV5V8V/iXf+E7kaJplv5d5cW0dxHf71PlZkYEeWykNkIRnP8XtXqtfOXx+/5Hux/wCwZH/6Nlr3 OHcNSxOOjCtG6s3b0/rbYyrSajdHG+IPHniXxRYJY6zqX2m2jlEyp5EaYcAgHKqD0Y/nR4f8eeJf C9g9jo2pfZraSUzMnkRvlyACcspPRR+VfRXhHxd4atvBehQT+IdJimi0+3SSOS9jVkYRqCCC2QQe 1Hi7xd4aufBeuwQeIdJlml0+4SOOO9jZnYxsAAA2SSe1fQ/2xDm+q/Uvcv8ALfe3LYy9n9rmOY+E HxG1bxRf3WjayftNzHE90t58iYQGNRHsVQOrE7s98VueEv8Akr3xF/7hn/pO1eZfAH/ke77/ALBk n/o2KvbdI1XR7vxf4j06ysPJ1Ox+zfb7nyUX7RvjLR/MDubauR82Mdq+f4jw9LD4+UKUeVWTstjW i246nQVR1azkv7OOGJlDLc28xLHjEcyOfxwpx71eqjq15JYWcc0SqWa5t4SGHGJJkQ/jhjj3rwZW s7nTR5vaR5N7q3qXqKKKZmFFFFAHzX/wjHiD/hc/2/8AsPU/sf8AwkPnfaPsknl+X9ozv3Yxtxzn pivpSvFf+Fv+IP8AhZX/AAjn2PTPsf8AbH2Df5UnmeX52zOd+N2PbGe1e1V9Bn08TL2P1iKXu6Wd 7oypW1sc/wCO/wDknniX/sFXX/opqPAn/JPPDX/YKtf/AEUtaGu3VnY+HtTvNRt/tFjBaSy3EOwP 5kaoSy7TwcgEYPBo0K6s77w9pl5p1v8AZ7Ge0ilt4dgTy42QFV2jgYBAwOBXz5qGt63p3hzR59W1 a4+z2MG3zJdjPt3MFHCgk8kDgV8gfC3W9O8OfEfSdW1a4+z2MHneZLsZ9u6F1HCgk8kDgV9X+NvD H/CY+EL7QPtn2P7V5f7/AMrzNu2RX+7kZztx1714/wD8My/9Td/5Tf8A7bQB9AUUUUAFFFFABRRR QB4/4h/5Oh8J/wDYKk/9Buq9grx/xD/ydD4T/wCwVJ/6DdV7BQAUUUUAFFFFABRRRQAUUUUAef8A wS/5JDoX/bx/6USV6BXH/DC6s77wFa3mnW/2exnu72W3h2BPLja6lKrtHAwCBgcCuwoAKKKKACii igAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKK ACiiigAooooAKKKKAPlj4JWaeKvi1Pqmrn7RdQxTalkou15y6jcVxjgyFhjGGCkdK93+KWjWet/D XXYrxM/ZrSS8hcAbkkiUupBIOM4KnHO1mGRmvAPENjqnwY+Kov8ATY549MeXzbYBtqXNsSC8BY7s 7fuktkjCvgZWvofwF43s/H3h46tZ2s9r5cv2eaKYg4kCKzbSD8y/OACQCcdBQB5X+zTZWP2fX78S xvqAeKExmH5oYsMQQ/cOwOVH/PIE9RXvlFeZ/E/4uQ+AbhNLt9Nku9UntxPG0jBYEVi6gnHzMQyf dwMg/eFAHlGvwro37TsSacZLYPrFo7bJGyTMI2l5znDGR8jphiOnFfUdfNHwY8I6p4o8ct401ePN rDK915k9t8t5O5cbo+AvyOCxI+6wUAc5H0vQAUUUUAFFFFABRRRQAUUUUAc/ef8AJQ9G/wCwVf8A /o20roK5+8/5KHo3/YKv/wD0baV0FABRRRQAUUUUAFFFFABWH40gmuvAviG3t4pJp5dMuUjjjUsz sYmAAA5JJ4xW5WX4l1KbRvCur6pbrG09lZTXEayAlSyIWAOCDjI9RQBX8FwTWvgXw9b3EUkM8WmW ySRyKVZGESggg8gg8YrcrL8NalNrPhXSNUuFjWe9sobiRYwQoZ0DEDJJxk+prUoAKKKKACiiigAo oooAK4f7Bef8L1/tH7JP9h/4RryPtPlny/M+07tm7puxzjriu4rl/wDhJLz/AIWn/wAIv5cH2H+x P7Q8zafM8zz/AC8ZzjbjtjOe9AHUUUUUAFFFFABRRRQAUUUUAFcP8ILC80z4W6NZ39pPaXUfn74Z 4zG65nkIyp5GQQfxruK5f4d+JLzxd4E03XL+OCO6uvN3pApCDbK6DAJJ6KO9AHUUUUUAFFFFABRR RQAUUUUAcP4nsLy4+KXgK8htJ5LW1/tD7RMkZKRboFC7mHC5PAz1ruK5fXPEl5pnjvwpocMcDWur /bPtDupLr5UQddpBwMk85B/CuooAKKKqabff2havN5fl7Z5ocbs58uVo8/jtz7ZpX1sVytxcun9f 5FuiiimSFFFFABRRRQB4/wDCD/kofxO/7Co/9G3FewV4/wDCD/kofxO/7Co/9G3FewUAFFFFABRR RQAUUUUAFcP8SbC8vv8AhEfsdpPceR4ls55vJjL+XGu/c7Y6KMjJPAruK5fxp4kvPDn/AAj32OOB /wC0tbttPm85Sdscm7cVwRhuBgnI9qAOoooooAKKKKACiiigDOutFtbu4eeSW/V2xkRahPGvAxwq uAPwFZPhbRbX/hHNFuvNv/M+yQSY/tCfZnYp+5v24/2cY7YxVTXYZH1m4Zb+/iB2/JFZajIo+UdG hlVD+AHvzmsjwtDJ9j0Vvt9/t8uA+X9i1HZjC8bvN8rHvt2d8Y4rlclz7L8D3KdGf1Vv2kunSXZ6 en4HpNcP4YsLy3+KXj28mtJ47W6/s/7PM8ZCS7YGDbWPDYPBx0ruK5fQ/El5qfjvxXoc0cC2ukfY /s7opDt5sRdtxJwcEcYA/Guo8M6iiiigAooooAKKKKACiiigDh/i/YXmp/C3WbOwtJ7u6k8jZDBG ZHbE8ZOFHJwAT+FdxXL/ABE8SXnhHwJqWuWEcEl1a+VsSdSUO6VEOQCD0Y966igAooooAKKKKACi iigDO0W1mtLCWOdNjtd3MgGQfled3U8eqsD+NaNFFJKysXUm5zc311OH+wXn/C9f7R+yT/Yf+Ea8 j7T5Z8vzPtO7Zu6bsc464ruK5f8A4SS8/wCFp/8ACL+XB9h/sT+0PM2nzPM8/wAvGc4247YznvXU UyAooooAKKKKACiiigArn/Hf/JPPEv8A2Crr/wBFNXQVz/jv/knniX/sFXX/AKKagDn/AIJf8kh0 L/t4/wDSiSvQK8/+CX/JIdC/7eP/AEokr0CgAooooAKKKKACiioYbqG4luI4n3PbyCOUYI2sVV8e /wArKePWgaTexNXD+J7C8uPil4CvIbSeS1tf7Q+0TJGSkW6BQu5hwuTwM9a7iuX1zxJeaZ478KaH DHA1rq/2z7Q7qS6+VEHXaQcDJPOQfwoEdRRRRQAUUUUAFFFFABRXK6/r9nLp0SrDqIIvbRvm024U YFxGTyU68cDqTwOTW5Z6tbX8xihjvFYLuzPZTQrj6uoGeenWoVSLdkzpnhKsKaqOL69H0t/mXq4f 4QWF5pnwt0azv7Se0uo/P3wzxmN1zPIRlTyMgg/jXcVy/wAO/El54u8Cabrl/HBHdXXm70gUhBtl dBgEk9FHerOY6iiiigAooooAKKKKACiqkd95mr3Nh5ePJgim37uu9pBjHt5f6+1W6SdypRcXZ/1f U4f4k2F5ff8ACI/Y7Se48jxLZzzeTGX8uNd+52x0UZGSeBXcVy/jTxJeeHP+Ee+xxwP/AGlrdtp8 3nKTtjk3biuCMNwME5HtXUUyQooooAKKKKACiis7X7qay8Oapd277J4LSWSNsA7WVCQcHjqKTdlc unBzmoLroaNFFFMg4f4bWF5Y/wDCXfbLSe38/wAS3k8PnRlPMjbZtdc9VODgjg13Fcv4L8SXniP/ AISH7ZHAn9m63c6fD5Kkbo49u0tknLcnJGB7V1FABRRRQAVU1TUItJ0m81KdXaG0geeRYwCxVFLE DJAzgetW6KcWk03sB8v+N/iprHiHUryHS9Qu7fQpdojtXjjRseWFdWK5LAktwWI5H4cQ1w/2SM7Y sl2H+qX0X2r6P8Y/B3TPFms3Gsf2nd2t7cMnmfKskeFQJgLgEH5Qc7j349OTT4E28upz6Z/b8oFv DHcCT7KPm8wuuMbu3lfr7V9nTzfJ6caSVK1rX91P7LWr0vr167m2GVb2dS1W2neX8y7I5bwX8WdZ 0HUNPt9Vv7i40K2Vka2igiZ9u1ggDEA4DFeN3AGOnFey/F+wvNT+Fus2dhaT3d1J5GyGCMyO2J4y cKOTgAn8KpeEfg9pHhTV7PV01G+ub+234J2LE25WX7uCejf3uo/Ct34ieJLzwj4E1LXLCOCS6tfK 2JOpKHdKiHIBB6Me9eLneKwWIqxlg4cqtrpb8F+fX5HNFTTfO7nUUUUV4pYUUUUAFeefEf4YReNS dStrp4tXigSCBZZAsG0OWJbCFs4Zuh64969DorowuKq4WqqtF2aFKKkrM+cv+FA+Kv8AoIaN/wB/ pf8A43R/woHxV/0ENG/7/S//ABuvQ/jdqmoaT4Ls59NvrmzmbUERpLaZo2K+XIcZUg4yBx7UfBHV NQ1bwXeT6lfXN5MuoOiyXMzSMF8uM4yxJxknj3r67+18z+ofXeeNr2tbU5/Zw5uUPhh8MJfBU9zq WpXSS6lKrQKttIWh8klGz8yBt25T3xitLwxYXlv8UvHt5NaTx2t1/Z/2eZ4yEl2wMG2seGweDjpX cVy+h+JLzU/HfivQ5o4FtdI+x/Z3RSHbzYi7biTg4I4wB+NfJYvF1cXVdas7tm8YqKsjqK4HWvDO ow2ETvrG8G7tkxvvOrToAfmuSOCc9M8cEHBHfV5dq0Eos486lqLf6Tb8NYaoo/1yc5eYjI6gdSeF IbBrzsRbl1X4nsZRz+192TWq+ze/+R2ujaJeabePNcaj9pRoygTdcHByDn95PIO3pnnr1B3K5Xw1 FImpSFr28nHkn5Z7S+iUcjnM8jLn2Az74zXVVpTty6I5Mbze196V36W/AKKKK0OQ8V/4VB4g/wCF lf8ACR/bNM+x/wBsfb9nmyeZ5fnb8Y2Y3Y98Z717VXzX/wAJP4g/4XP9g/tzU/sf/CQ+T9n+1yeX 5f2jGzbnG3HGOmK+lK+gz6GJj7H6xJP3dLK1kZUra2MPxpBNdeBfENvbxSTTy6ZcpHHGpZnYxMAA BySTxijwXBNa+BfD1vcRSQzxaZbJJHIpVkYRKCCDyCDxirHiXUptG8K6vqlusbT2VlNcRrICVLIh YA4IOMj1FHhrUptZ8K6Rqlwsaz3tlDcSLGCFDOgYgZJOMn1NfPmpqUUUUAFFFFABRRRQAUUUUAeP +If+TofCf/YKk/8AQbqvYK8f8Q/8nQ+E/wDsFSf+g3VewUAFFFFABRRRQAUUUUAFFFFAHB/BmCa1 +FOj29xFJDPE9ykkcilWRhcSAgg8gg8YrvK4v4UalNrPw6sNUuFjWe9uLu4kWMEKGe6lYgZJOMn1 NdpQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFF FFABRRRQAUUUUAFFFFABRRRQAUUUUAY9nfeH/GmhmS3ksdX0ybaHRlWVM8OFdD0YZU7WAI44FWNE 0TTvDmjwaTpNv9nsYN3lxb2fbuYseWJJ5JPJryvxL8L9f8O6pc+IfhlqMljPO6tNpCFVic/MCy7z sIG7IRhhcsVI+Vax9N/aE1LS79tP8ZeGJLedHJlNqrRSRKUBUGGU5JJwclxww445APfKw9f8H6B4 puLCfW9NjvXsHL24kdtqklScqCAwO1eGBHHua4/Tfjz4Dvrdpbi+u9PcOVEV1aOzEYHzDy94xzjr ng8dM2J/jj8PobeWVNakndELLFHZzBnIH3RuQDJ6ckD1IoA9AgghtbeK3t4o4YIkCRxxqFVFAwAA OAAOMVJXhet/tJ6alvt0HQ7uadkcb79liWNsfKdqFi4znIyvTrzxHZ+GPiL8VpTL4xvJ9A0D5SLC GLyjNhhuXyydw+5uDS7sEgqpB4APbNL1Wx1qwW/025jurR3dEmj5VijlGwe43KeRweoyOauVT0rS rHQ9Lt9M0y2jtrO3TZFEnRR/MknJJPJJJOSauUAFFcPJ8TdLk+Jll4KsI/tlxJ5ourlJMJbuiM+w cHe3ykHkbc4yTkDrNV1Wx0PS7jU9TuY7azt03yyv0UfzJJwABySQBkmgC5RXi5+OmsT2c2pWHw51 W50hd7pfGVwhjUnLMREyrjBz8xAweeK9M0DxdoviTw0uv2F7GLAIWmaZghtyoyyyc4UqOTzjGCCQ QSAblFePv8br+/vLo+GPAeq65pkMpiS+hMgEhABPyiJtvXIBOcEEgZwO48C+OtL8eaGL+wPlXEeF urR2y9u57H1U4OG747EEAAsXn/JQ9G/7BV//AOjbSugrn7z/AJKHo3/YKv8A/wBG2ldBQAUUUUAF FFFABRRRQAVl+JdNm1nwrq+l27RrPe2U1vG0hIUM6FQTgE4yfQ1qVh+NJ5rXwL4huLeWSGeLTLl4 5I2KsjCJiCCOQQec0AWPDWmzaN4V0jS7ho2nsrKG3kaMkqWRApIyAcZHoK1Kw/Bc8114F8PXFxLJ NPLpls8kkjFmdjEpJJPJJPOa3KACiiigAooooAKKKKACuX/4Ru8/4Wn/AMJR5kH2H+xP7P8AL3Hz PM8/zM4xjbjvnOe1dRXD/b7z/hev9nfa5/sP/CNef9m8w+X5n2nbv29N2OM9cUAdxRRRQAUUUUAF FFFABRRRQAVy/wAO/Dd54R8Cabod/JBJdWvm73gYlDuldxgkA9GHauorh/hBf3mp/C3Rry/u57u6 k8/fNPIZHbE8gGWPJwAB+FAHcUUUUAFFFFABRRRQAUUUUAcvrnhu81Px34U1yGSBbXSPtn2hHYh2 82IIu0AYOCOckfjXUVw/ie/vLf4peArOG7njtbr+0PtEKSEJLtgUruUcNg8jPSu4oAo3thc3UweH VryzULjy4EhKk+vzxsc/jjisPQNKvH06Urr+oxj7bdjasdvgkXEgJ5iPJ6ntk8YHFdVTI4o4VKxR qilmYhRgZJJJ+pJJPuahwTlc6YYmUabgkt10XS/l5j6KKKs5gooooAKKKKAPH/hB/wAlD+J3/YVH /o24r2CvH/hB/wAlD+J3/YVH/o24r2CgAooooAKKKKACiiigArl/Gnhu88R/8I99jkgT+zdbttQm 85iN0ce7cFwDluRgHA966iuH+JN/eWP/AAiP2O7nt/P8S2cE3kyFPMjbfuRsdVOBkHg0AdxRRRQA UUUUAFFFFAHO6n4OsNV1GW9mkxJJjI+x2r9AB954mY9O5P5Vk+FvB1h/ZGi6l5n77yIJ8fY7X721 W+95W/r33bvfPNdxTIoo4IUhhjWOKNQqIgwqgcAADoKydGLlzWO+OY140XSUu3RbJND65fQ/Dd5p njvxXrk0kDWur/Y/s6IxLr5URRtwIwMk8YJ/Cuorh/DF/eXHxS8e2c13PJa2v9n/AGeF5CUi3QMW 2qeFyeTjrWpwHcUUUUAFFFFABRRRQAUUUUAcv8RPDd54u8CalodhJBHdXXlbHnYhBtlRzkgE9FPa uorh/i/f3mmfC3Wbywu57S6j8jZNBIY3XM8YOGHIyCR+NdxQAUUUUAFFFFABRRRQAUUUUAcv/wAI 3ef8LT/4SjzIPsP9if2f5e4+Z5nn+ZnGMbcd85z2rqK4f7fef8L1/s77XP8AYf8AhGvP+zeYfL8z 7Tt37em7HGeuK7igAooooAKKKKACiimPLHG0avIqtI21AxwWOCcD1OAT9AaASuPrn/Hf/JPPEv8A 2Crr/wBFNXQVz/jv/knniX/sFXX/AKKagDn/AIJf8kh0L/t4/wDSiSvQK8/+CX/JIdC/7eP/AEok r0CgAooooAKKKKAKl9JqMfl/YLW1nznf59y0WOmMYRs9/T8awNKn10ajrezTdOZjervDX7gKfs8P APknIxg545JGOMnqqy9KMZ1HW9iMrC9XeWbIY/Z4eQMDAxgY55BOecDOSd1r/VjsoVIqnNOCenn/ ADLzNGIyGFDMipKVG9UbcoPcAkDI98D6VzWueG7zU/HfhTXIZIFtdI+2faEdiHbzYgi7QBg4I5yR +NdRXD+J7+8t/il4Cs4bueO1uv7Q+0QpIQku2BSu5Rw2DyM9K0ONncUUUUAFFFFABRRRQBR1azkv 7OOGJlDLc28xLHjEcyOfxwpx71er5Z8b+IfF+k+NNXgfWNcs4WvJntozczRqYfMYKUGQNuBwRxxX p3wSn8S3MGrz6/Lq0sMq272kl+0jK6kSEmMvwQRt5Ht7V7+L4flhsJ9bdRNWWne7/S5CxDlanba/ 9fgesVy/w78N3nhHwJpuh38kEl1a+bveBiUO6V3GCQD0Ydq6iuH+EF/ean8LdGvL+7nu7qTz9808 hkdsTyAZY8nAAH4V4BZ3FFFFABRRRQAVj+JdRtNJ0n7Zfapc6ZbJIoe5ghEmM8ANlHABJHOBzgZ5 wdiuC+Id5ofiDwvqGhw+I9CttSEiBDdXyJ5Lo43ZxllOAy9M8ketbUKEq9RQWzau9dF30LpzjCSl Pb5froY0Xjjw0uuXVyfHV6sMltDGs/2aPLsrSkrjyMfKGU9B988nt6Xpj+Zp0TefdT5z+8uofKkP J6rtXH/fI4weetfIGkW8+sXlrYDVbayeV5M3F7cGOJAFBG5ucZwQPc19Z6Nq3hy5A0/Q9Q0qURKX FvYzRtsXPJ2oeBk9fU+9duPyepgbdb8193azsui31OvGYmhVsqd72j0ivs+Wv6Gd408N3niP/hHv sckCf2brdtqE3nMRujj3bguActyMA4HvXUVw/wASb+8sf+ER+x3c9v5/iWzgm8mQp5kbb9yNjqpw Mg8Gu4rzDhCiiigAooooAK828U+Fbr7HrWofZLDy/Lnn35g34wzZ/wCPTdn/AIHn/azzXU+L/F+n +CtJi1LUobmWGWcQKtsqs24qzZ+ZgMYU96+etb8e/wBr65etY21tFZ3czbFn023MwDHkmQDIPJOe SPUkZPR/ZeKxNF1YQbir6+nyZ6mUVo08RZyS239fVHueheFbrTdZt7uS0sI0j3ZaIwbhlSONtpGe /Zh+PQ9lXzN4T+JsWk+IIb3VrSGW2RWA+w6ZbQyBiMA5ABI5IwCvXqQMH6E8N+ILTxRoFrrNjHNH bXO/Ys6gONrFTkAkdVPeqq5XisHDmqwaV7X8/uRhmFaNWqrSUtOnq/NmZ4L8N3nhz/hIftkkD/2l rdzqEPksTtjk27Q2QMNwcgZHvXUVw/w2v7y+/wCEu+2Xc9x5HiW8gh86Qv5ca7NqLnooycAcCu4r lOIKKKKACiiigCve20t1CEhvZ7Ng2fMgWMsR6fOrDH4Z4rnYNKvD4pv0/t/UQwsrYmQR2+5gXn4P 7rGBg9Bnk5zxjqqYIoxM0wjUSsoVnA+YgZIBPoNx/M+tRKF2mdFLEOnGUUlquyfVPqvIZawvb26R SXMty65zLKFDNz32gD24Haud+Inhu88XeBNS0OwkgjurrytjzsQg2yo5yQCeintXUVw/xfv7zTPh brN5YXc9pdR+RsmgkMbrmeMHDDkZBI/GrMG7u53FFFVL6znu/L8nUrqy25z5CxHfnHXejdPbHWkx xSbs3b+vILO++13WoQ+Xt+yTiHO7O/MSSZ9vv4/CrdcrpWlXjajrYGv6ihW9UFljt8ufs8Jycxde QOMDAHfJPTxI0cKI0jSsqgGRwNzH1OABk+wAqYSbWqN8TShTkuWSei79l3Q+iiirOY8H+P3iC7+3 2Phzy4fsflR3+/afM8zMqYznG3HtnPeqXwc8W32n+J4fCUMFt/Z93dTzO7KxlUiI4AO7GP3a9Qe9 eheJtP8AP8Q3Un9n+bnZ8/2HzM/IP4vsMuf++z+HQZPhbT/+QLN/Z/8AzwbzfsP+6c7/ALD+OfM9 9/8AFXqLP6ccKsE6N0k1fm+07Wla26/pnrQyfmoOtz6uz28npues1y+h+G7zTPHfivXJpIGtdX+x /Z0RiXXyoijbgRgZJ4wT+FdRXD+GL+8uPil49s5rueS1tf7P+zwvISkW6Bi21TwuTycda8s8k7iv GtS0zZaof7M2/v4Rn+ztvWVRjP8AZ69emM89MN90+y15dqzWf2OPb4N06A/abf5lsrgEjzkyvNoO G+6RnJBwAx4PLiVdb9z3cjk41HaLese3n3aNnwbZfZtXlf7D5GYCN32Pys/MvGfskP5bj9D1HcVy vho2x1KTyfDdnpjeSf30FtNGzDI+XL28Yx3xknjp3HVVrRVoHDmUnKvdq2i7fpcKKKK1OA+Mv+Eg u/8AhLP+Ej8uH7Z9u+37Np8vzPM34xnO3PvnHevqrwH4gu/FHgvT9Zvo4Y7m58zesCkINsjKMAkn oo71P/whfhX/AKFnRv8AwAi/+JrVs7K0061S1sbWG2to87IYIwiLk5OAOBySfxr6LOc4w+PpRjTp 8so9fKz0/Ixp03B6speJdNm1nwrq+l27RrPe2U1vG0hIUM6FQTgE4yfQ0eGtNm0bwrpGl3DRtPZW UNvI0ZJUsiBSRkA4yPQVX8aTzWvgXxDcW8skM8WmXLxyRsVZGETEEEcgg85o8FzzXXgXw9cXEsk0 8umWzySSMWZ2MSkkk8kk85r502NyiiigAooooAKKKKACiiigDx/xD/ydD4T/AOwVJ/6DdV7BXj/i H/k6Hwn/ANgqT/0G6r2CgAooooAKKKKACiiigAooooA4v4UabNo3w6sNLuGjaeyuLu3kaMkqWS6l UkZAOMj0FdpXB/Bmea6+FOj3FxLJNPK9y8kkjFmdjcSEkk8kk85rvKACiiigAooooAKKKKACiiig AooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAC iiigArL1vw3oviO38jWdLtL5AjohmiDNGGGG2N1QnA5Ug8D0rUooA8r1L9n3wRfXCy241LT0CBTF a3IZScn5j5iuc84644HHXNeD9nXwbDcRSvd6zOiOGaKS4jCuAfunbGDg9OCD6EV65RQBzegeAPCn hd1l0fQ7SCdXLrOwMsqErtO2RyWAxxgHHJ9TXSUUUAFZfiHSZtc0SbToNTu9NeV4ybq0cpKiq6sw VgeCygrntu6HodSigDweLwxpfhH9oTwZpGkQeVbx6VIWZuXlcpc5dz3Y4H5AAAAAdB+0NfXFp8NY 4YJNkd3qEUM42g70CvIBz0+ZFPHp6Zqv4h/5Oh8J/wDYKk/9Buq1Pjvok2sfDK4mg8wvp1xHeGNI y5dQCjdOgCyFyecBT9QAeiWFjb6Zp1tYWcfl2trEkMKbidqKAFGTycADrXzha31xoHgn4u6Ppknk WFjqCQ28W0NsSWdoJBlsk5jRV5JxjIwea9j0r4p+EL/w1b6vc67ptm72/mzWj3SmWJgPmTZw7EEE DC/NwQDkV5Z4Z8O3njD4Z/EbXY4p7eTX7trm2tVhMhbyXMwVDxv3MxjyBwVPU8AA9f8AhxY2+n/D Xw5Dax+XG2nwzEbicvIokc8+rMx9s8cVw/g7/iV/tE+NdJs/3Vjc2iXssX3t0x8pt2TkjmaU4Bx8 3TgY1Php8RvDNz8PtHhvdZ03Truzt0s5be6u1jYGMBQw3bchlAbjIGSMkg1j/DGZfFvxZ8Y+NrUS Jp5RLC3JjbbOPkG8MQMHbCjFcZHmjPTkA7jXtW03RvHWiXGqahaWMDaZfIsl1MsSlvNtDgFiBnAJ x7Grn/Cd+D/+hr0P/wAGMP8A8VRef8lD0b/sFX//AKNtK6CgDn/+E78H/wDQ16H/AODGH/4qtDU9 d0fRPK/tbVbGw87Pl/a7hIt+MZxuIzjI6eorQooAx7HxZ4b1O8js7DxBpV3dSZ2QwXscjtgEnCg5 OACfwovvFnhvTLySzv8AxBpVpdR43wz3scbrkAjKk5GQQfxrYooAz9M13R9b83+ydVsb/wAnHmfZ LhJdmc4ztJxnB6+hrP8A+E78H/8AQ16H/wCDGH/4qugooAz/AO3dH/sf+1/7Vsf7M/5/ftCeT97b 9/O373HXrxWHq3inwTrOjX2l3Hi3RlgvbeS3kaPUoQwV1KkjJIzg+hrrK5/x3/yTzxL/ANgq6/8A RTUAFrqfhvwt4e0ezl12xgsVtI4rKa7u418+NEUBg2QG4KnI45HrVix8WeG9TvI7Ow8QaVd3Umdk MF7HI7YBJwoOTgAn8Kr+BP8Aknnhr/sFWv8A6KWugoAx77xZ4b0y8ks7/wAQaVaXUeN8M97HG65A IypORkEH8asaZruj635v9k6rY3/k48z7JcJLsznGdpOM4PX0NaFFAHP/APCd+D/+hr0P/wAGMP8A 8VWh/buj/wBj/wBr/wBq2P8AZn/P79oTyfvbfv52/e469eK0KKAOf/4Tvwf/ANDXof8A4MYf/iq0 NT13R9E8r+1tVsbDzs+X9ruEi34xnG4jOMjp6itCigDHsfFnhvU7yOzsPEGlXd1JnZDBexyO2ASc KDk4AJ/Cse+ufB+mePpNcv8AxLY2mrx6eNPe1nvoYwsZcSglD8wY5HOcYPTvXYV5/wD83C/9yp/7 d0Adhpmu6Prfm/2Tqtjf+TjzPslwkuzOcZ2k4zg9fQ1n/wDCd+D/APoa9D/8GMP/AMVXQUUAZ/8A buj/ANj/ANr/ANq2P9mf8/v2hPJ+9t+/nb97jr14rP8A+E78H/8AQ16H/wCDGH/4qugooAz9T13R 9E8r+1tVsbDzs+X9ruEi34xnG4jOMjp6iq9j4s8N6neR2dh4g0q7upM7IYL2OR2wCThQcnABP4Vs UUAY994s8N6ZeSWd/wCINKtLqPG+Ge9jjdcgEZUnIyCD+NWNM13R9b83+ydVsb/yceZ9kuEl2Zzj O0nGcHr6GtCigDn/APhO/B//AENeh/8Agxh/+Kqv4Wh8N+EfAlpFYa1BJoVrv2X891GUO6Vs5kGF ++xX9OtdRXn/AMEv+SQ6F/28f+lElAHQf8J34P8A+hr0P/wYw/8AxVaGp67o+ieV/a2q2Nh52fL+ 13CRb8YzjcRnGR09RWhRQBj2Pizw3qd5HZ2HiDSru6kzshgvY5HbAJOFBycAE/hRfeLPDemXklnf +INKtLqPG+Ge9jjdcgEZUnIyCD+NbFFAGfpmu6Prfm/2Tqtjf+TjzPslwkuzOcZ2k4zg9fQ1n/8A Cd+D/wDoa9D/APBjD/8AFV0FFAGf/buj/wBj/wBr/wBq2P8AZn/P79oTyfvbfv52/e469eKz/wDh O/B//Q16H/4MYf8A4qugooA5fxJD4bt/Eega5rmtQaddab9o+xpPdRwpL5iBHyH5bAx0IxnmtCx8 WeG9TvI7Ow8QaVd3UmdkMF7HI7YBJwoOTgAn8K5fxb/yV74df9xP/wBJ1r0CgDHvvFnhvTLySzv/ ABBpVpdR43wz3scbrkAjKk5GQQfxqxpmu6Prfm/2Tqtjf+TjzPslwkuzOcZ2k4zg9fQ1oUUAc/8A 8J34P/6GvQ//AAYw/wDxVaH9u6P/AGP/AGv/AGrY/wBmf8/v2hPJ+9t+/nb97jr14rQooA5//hO/ B/8A0Neh/wDgxh/+KrQ1PXdH0Tyv7W1WxsPOz5f2u4SLfjGcbiM4yOnqK0KKAMex8WeG9TvI7Ow8 QaVd3UmdkMF7HI7YBJwoOTgAn8KL7xZ4b0y8ks7/AMQaVaXUeN8M97HG65AIypORkEH8a2KKAPG/ gzPDdeOviTcW8sc0Eupq8ckbBldTLcEEEcEEc5r0T/hO/B//AENeh/8Agxh/+Krz/wCEH/JQ/id/ 2FR/6NuK9goAz/7d0f8Asf8Atf8AtWx/sz/n9+0J5P3tv387fvcdevFZ/wDwnfg//oa9D/8ABjD/ APFV0FFAGfqeu6Ponlf2tqtjYedny/tdwkW/GM43EZxkdPUVXsfFnhvU7yOzsPEGlXd1JnZDBexy O2AScKDk4AJ/CtiigDHvvFnhvTLySzv/ABBpVpdR43wz3scbrkAjKk5GQQfxqxpmu6Prfm/2Tqtj f+TjzPslwkuzOcZ2k4zg9fQ1oUUAc/8A8J34P/6GvQ//AAYw/wDxVU/EZ8K67pejapqGv2kGn2ep xXtpdpeRLFLNFuwm85DD72QDn5TyMGusrz/4p/8AMlf9jXY/+z0AdB/wnfg//oa9D/8ABjD/APFV oanruj6J5X9rarY2HnZ8v7XcJFvxjONxGcZHT1FaFFAGPY+LPDep3kdnYeINKu7qTOyGC9jkdsAk 4UHJwAT+FF94s8N6ZeSWd/4g0q0uo8b4Z72ON1yARlScjIIP41sUUAZ+ma7o+t+b/ZOq2N/5OPM+ yXCS7M5xnaTjOD19DWf/AMJ34P8A+hr0P/wYw/8AxVdBRQBn/wBu6P8A2P8A2v8A2rY/2Z/z+/aE 8n7237+dv3uOvXis/wD4Tvwf/wBDXof/AIMYf/iq6CigDP1PXdH0Tyv7W1WxsPOz5f2u4SLfjGcb iM4yOnqK5/QLnwf/AMJfq2o6T4lsb3U9b8nzLaO+hk/1MZUbFX5vu5Jznp2rsK8/8Jf8le+Iv/cM /wDSdqAOovvFnhvTLySzv/EGlWl1HjfDPexxuuQCMqTkZBB/GrGma7o+t+b/AGTqtjf+TjzPslwk uzOcZ2k4zg9fQ1oUUAc//wAJ34P/AOhr0P8A8GMP/wAVWh/buj/2P/a/9q2P9mf8/v2hPJ+9t+/n b97jr14rQooA5/8A4Tvwf/0Neh/+DGH/AOKrQ1PXdH0Tyv7W1WxsPOz5f2u4SLfjGcbiM4yOnqK0 KqanJeRadK9hH5l0MbF2B88jPBdAeM/xD8ehTdlcqMeaSje1zOs/GPh3UdVg07T9ZsLy4mR2UW11 HIMrg7Ths7iCSBjojHtUl94s8N6ZeSWd/wCINKtLqPG+Ge9jjdcgEZUnIyCD+NczNe+KT4jsmay/ fi0uAi/Y4uV3w7jj7XjqF/iHXoc5XrdGm1KazdtUh8qcSEKvlLH8uBzhZZB1z/EPp3OcKnM2rM7M RhFSpxmpxd10d+rMDxHc+D/GvhDU9OufEtj/AGZ+6+13NpfQ/uf3gZMscquWXHPXnFaH/Cd+D/8A oa9D/wDBjD/8VXP/ABt/5JDrv/bv/wClEdegVqcJn/27o/8AY/8Aa/8Aatj/AGZ/z+/aE8n7237+ dv3uOvXis/8A4Tvwf/0Neh/+DGH/AOKroKKAM/U9d0fRPK/tbVbGw87Pl/a7hIt+MZxuIzjI6eoq vY+LPDep3kdnYeINKu7qTOyGC9jkdsAk4UHJwAT+FbFFAGPfeLPDemXklnf+INKtLqPG+Ge9jjdc gEZUnIyCD+NWNM13R9b83+ydVsb/AMnHmfZLhJdmc4ztJxnB6+hrQooA5/8A4Tvwf/0Neh/+DGH/ AOKrQ/t3R/7H/tf+1bH+zP8An9+0J5P3tv387fvcdevFO0m8kv7OSaVVDLc3EICjjEczoPxwoz71 epJ3VypwcJOL3Rw/9r+A/wDhMv8AhKP+Ev0r7d/Z/wDZ/l/2lB5fl+Z5mcZzuz3zjHauo1PXdH0T yv7W1WxsPOz5f2u4SLfjGcbiM4yOnqK4/wD5uF/7lT/27r0CmSY9j4s8N6neR2dh4g0q7upM7IYL 2OR2wCThQcnABP4UX3izw3pl5JZ3/iDSrS6jxvhnvY43XIBGVJyMgg/jWxRQBn6Zruj635v9k6rY 3/k48z7JcJLsznGdpOM4PX0NZ/8Awnfg/wD6GvQ//BjD/wDFV0FFAGZL4g0mPQn1tdRs5dOVSRcp cx+UxztwJCwTJb5eSBniuM1D4kaDcXukypNAVtrppXxqVkcAwyp1E5A5ccnA7ZyQD32oTta6bdXC sqtFC7hnxtBAJ5yyjH1ZR7jrXm1/4yvJrzTHN7pxMNyzgqLfAPkyLzi8PHzHqVGcc5wpwrTUbI9X LMNKrzNJPR737PsdtN4p07T9v9uSR6Hv/wBT/aV1BH52PvbcSHOMjP8AvCsLxb4s8N6n4I8RWdh4 g0q7upNKu9kMF7HI7YhcnCg5OACfwrW8La5PrX2vzp7WXytmPIEQxnd12Ty+nfb+PZ3jv/knniX/ ALBV1/6KatYS5o3OHE0nSquDSVu17fjqcP8ACDxZ4b0z4W6NZ3/iDSrS6j8/fDPexxuuZ5CMqTkZ BB/GvSNM13R9b83+ydVsb/yceZ9kuEl2ZzjO0nGcHr6GuP8Agl/ySHQv+3j/ANKJK9AqjA5//hO/ B/8A0Neh/wDgxh/+KrQ/t3R/7H/tf+1bH+zP+f37Qnk/e2/fzt+9x168VoUUAc//AMJ34P8A+hr0 P/wYw/8AxVaGp67o+ieV/a2q2Nh52fL+13CRb8YzjcRnGR09RWhRQBx2q+MtEuPJ/szxJHLt3eZ/ Zt9Ytjpjd5zfXG33z2rn7DxJFHeamx1rUV8y5VgVutLBb9zGMnccE8Y+XjAH8W6uk8bXf2X7D/pf 2fd5n/Lz5O77v/TzDn/x78O/D2ep7brUD/ae3dODn+0cbv3SDOf7QGemM5bpjPG1eGtKSno/6sfU 5ZQpSwt5RTbXb+8eo6JremaxbbbHVLe9mgRBcCO4ikkjYj/lp5ZKhiQenGQcVzeo6v4D1PxHouuT eL9KW60jz/s6JqUARvNQI24E5OAOMEfjXW6U/maRZPv37oIzu3bs/KOc7mz9dzfU9a4rxb/yV74d f9xP/wBJ1rtWx8zUVptLudh/buj/ANj/ANr/ANq2P9mf8/v2hPJ+9t+/nb97jr14rP8A+E78H/8A Q16H/wCDGH/4qugopkGfqeu6Ponlf2tqtjYedny/tdwkW/GM43EZxkdPUVXsfFnhvU7yOzsPEGlX d1JnZDBexyO2AScKDk4AJ/CtiigDHvvFnhvTLySzv/EGlWl1HjfDPexxuuQCMqTkZBB/GvMPiN8Y orZDp3hPUG+2wzoz3sSwzW8kZQkqrEtk5K9hypGfX2evlX4w/wDJVNZ/7Yf+iI6+h4ZwdHFY1xrK 6UW7dL3S1+8yrScY6HOeIPEmreKL9L7Wbv7TcxxCFX8tEwgJIGFAHVj+dbll8VPGmnWFvY2us+Xb W0SwxJ9lhO1FAAGSmTwB1r3n/hcPgP8A6Dv/AJKT/wDxFef/ABf8eeGvFHhO1sdG1L7Tcx3yTMnk SJhBHICcsoHVh+dfS4fGzxM4YetgbQ81pH5ONjBx5U2pHdeDvih4e1fw3bS6prVpZX8SLDci/nhg aWQIpZ1Xd9wknBwOh4GKveHLnwf4K8IaZp1t4lsf7M/e/ZLm7vof337ws+GGFbDNjjpxmua+AP8A yIl9/wBhOT/0VFWr8Ev+SQ6F/wBvH/pRJXxOa0YUMbUp01ZJnTB3imzqLHxZ4b1O8js7DxBpV3dS Z2QwXscjtgEnCg5OACfwovvFnhvTLySzv/EGlWl1HjfDPexxuuQCMqTkZBB/GtiivPLM/TNd0fW/ N/snVbG/8nHmfZLhJdmc4ztJxnB6+hrP/wCE78H/APQ16H/4MYf/AIqugooA43x34nez+Guoa/4d 1KB2Ty/Iu4CkyHMyo2Dyp6sK+ZI0GvX97falrVlZ3M0pmd7mOX967kliBFGwHP06jHt9jXllaaja va31rDc20mN8M8YdGwcjIPB5AP4V4B4m+CPiR9T1TUNLXTJLaW5kkt7OCUxuI2c7VAZVQYB6bscc Z4r7HhnH4WhTnSqtQk3fm0200u1+empz1oSbujz/APsHTv8AobdG/wC/V5/8YrS+H+qXuhfELTo9 NvUKXN5FZTSxplZoWlXdjeuQDgHOA30q1/wp7x5/0Av/ACbg/wDi69L+HPwj1Dwv4lfUtc/sm8hW AiBY90jRzb0ZXG9AAQFPIORmvfx+Z4KGGmpVlUunpeL/ACX5mUYSbWljr/Ftz4P1C80+z1vxLY2N 1pOoQ6gkLX0MTiRASodW52kNnHBPHNdBpmu6Prfm/wBk6rY3/k48z7JcJLsznGdpOM4PX0Ncf8U/ +ZK/7Gux/wDZ69Ar8vO05/8A4Tvwf/0Neh/+DGH/AOKrQ/t3R/7H/tf+1bH+zP8An9+0J5P3tv38 7fvcdevFaFFAHP8A/Cd+D/8Aoa9D/wDBjD/8VWhqeu6Ponlf2tqtjYedny/tdwkW/GM43EZxkdPU VoUUAfPvxC8KWXi7xPNqvhfxLpWr6lfyoo0uC7gDqiRYLBjJ833M4A7+1eaXGi6hpGt/Yr23KT28 qrKEZZFU8ZG5SRx354OQeRX2bXm3ikWv2PWj/wAJXYeZ5c/+h/a59+cN+72/adue2NmP9nHFe5Hi fF0ML9XajKNra6O1rLy0Xlc7MtwdKriE530aemvX0Z8+aN4Z1jxBqAsdNszLclS6xvIsW4DrguQC e+BzgE9jXs3wjPh7wdpV5can4u0NLzUNnmWv9oQHyPLaQD51kIbcGB7Y6V2mhC1Gs2/l+K7C+f5s W8V3O7P8p6BrlwcdeVPTt1HZU8dxLiswoOjOMYxe9tXprvfuYYnCUsPUSp3266fojk/Dh8K6Fpes 6pp+v2k+n3mpy3t3dveRNFFNLtym8YCj7uATn5hycirn/Cd+D/8Aoa9D/wDBjD/8VXP/AAs/5nX/ ALGu+/8AZK9ArwjIz9T13R9E8r+1tVsbDzs+X9ruEi34xnG4jOMjp6iq9j4s8N6neR2dh4g0q7up M7IYL2OR2wCThQcnABP4VsUUAY994s8N6ZeSWd/4g0q0uo8b4Z72ON1yARlScjIIP41Y0zXdH1vz f7J1Wxv/ACceZ9kuEl2ZzjO0nGcHr6GtCigDDi8aeFZ2Kw+JtGkYDJCX8ROPwaqkPinRv+Ejvd2v WH2X7Jb+Xm8TZv3zbsc4zjZn/gPtW/e2UV/CIpnnVQ27MFxJC2fqhBxz06VzsGgWZ8U38XnajtWy tmBGpXG7Jefqd+SOBweBzjqaynz3VrHfhVhvZz9pzXt0t3Rdk8b+E4ZCkvijRUcdVa/iBH/j1VPH kPhvU/Dk2h+Jdag0u1v9uHe6jgdvLdX+UvwcELng9feuitbZLS3SCNpWRc4MsrSNyc8sxJP4muF+ Nv8AySHXf+3f/wBKI60V7anFLl5ny7HUWPizw3qd5HZ2HiDSru6kzshgvY5HbAJOFBycAE/hUtx4 j0K0vJbO51rTobqHHmQyXSK6ZGRlScjI55rTqpfarp2meX9vv7W08zOzz5lj3YxnGTzjI/OiTsiq UeaSVm/Jb/kzA0rxJoUeo62z61pyrJeqyFrpAGH2eEZHPIyCPqDVtvHPhFGKt4p0RWU4IOoRAg/9 9VU0rxJoUeo62z61pyrJeqyFrpAGH2eEZHPIyCPqDXTxSxzwpNDIskUihkdDlWB5BBHUVnSd1v8A 1c6sbT5ZJ8jWi3/wryRS/t3R/wCx/wC1/wC1bH+zP+f37Qnk/e2/fzt+9x168Vn/APCd+D/+hr0P /wAGMP8A8VXQUVqcJ554m/sL/hIbr7b/AMfHyb/+QX/cGP8AX/vOmPvfhxisnwt/YX/El/5+/wBx /wBAv7/y/wDbbr/wP8a1vE2oeR4huo/7Q8rGz5Pt3l4+Qfw/bosf98D8epyfC2of8gWH+0P+eC+V 9u/3RjZ9u/DHl+2z+GvOl/FPsaP+4r0X5M9BvvFnhvTLySzv/EGlWl1HjfDPexxuuQCMqTkZBB/G s/w3D4buPEev65oetQajdal9n+2JBdRzJF5aFEwE5XIz1Jzjiuorz/wl/wAle+Iv/cM/9J2r0T44 6D/hO/B//Q16H/4MYf8A4qvAtS8faKb+5srbTYGWCclZQbU71jbd/wAs7TbyF7Oy8/xjg+w/EP4o ab4EslaIWmpagLhIpdPW9WOWJWRm3suGIHC9R/EOfX5h8V+JNO1/xLPrGnaJ/Zf2lJDcRfa2n8yZ y5aTJAxnePlAx8vvWVWmpo78BjZYWpdWs2r/ACPcPhn8QPDV3qV9NdS6fpBjhVVeee1iWTcckZEE LE/KOm4euDtz61qeu6Ponlf2tqtjYedny/tdwkW/GM43EZxkdPUV80eCvi9o3gbTjDpngrF1NFEl 5cf2q/8ApDoCN+1kIXJZjgevtX0f4X8RWfinw9Z6tZywN50SNNFDMJfIkKKzRsR/Eu4AggH2FXCC irI58RXlXnzy3Cx8WeG9TvI7Ow8QaVd3UmdkMF7HI7YBJwoOTgAn8KL7xZ4b0y8ks7/xBpVpdR43 wz3scbrkAjKk5GQQfxrYoqjAz9M13R9b83+ydVsb/wAnHmfZLhJdmc4ztJxnB6+hrP8A+E78H/8A Q16H/wCDGH/4qugooAw9WvNB1nwdfPcaxaLot7byW8l9HcoIwr5jJEhyucnHfnis/SfFPgnRtGsd Lt/FujNBZW8dvG0mpQliqKFBOCBnA9BVzx3/AMk88S/9gq6/9FNR4E/5J54a/wCwVa/+iloA0NT1 3R9E8r+1tVsbDzs+X9ruEi34xnG4jOMjp6iq9j4s8N6neR2dh4g0q7upM7IYL2OR2wCThQcnABP4 VsUUAY994s8N6ZeSWd/4g0q0uo8b4Z72ON1yARlScjIIP41Y0zXdH1vzf7J1Wxv/ACceZ9kuEl2Z zjO0nGcHr6GtCigDn/8AhO/B/wD0Neh/+DGH/wCKrQ/t3R/7H/tf+1bH+zP+f37Qnk/e2/fzt+9x 168VoUUAc/8A8J34P/6GvQ//AAYw/wDxVaGp67o+ieV/a2q2Nh52fL+13CRb8YzjcRnGR09RWhRQ B4nqGrabrP7TPhW40vULS+gXTJEaS1mWVQ2y5OCVJGcEHHuK9UvvFnhvTLySzv8AxBpVpdR43wz3 scbrkAjKk5GQQfxrzfxD/wAnQ+E/+wVJ/wCg3VewUAZ+ma7o+t+b/ZOq2N/5OPM+yXCS7M5xnaTj OD19DWf/AMJ34P8A+hr0P/wYw/8AxVdBRQBn/wBu6P8A2P8A2v8A2rY/2Z/z+/aE8n7237+dv3uO vXis/wD4Tvwf/wBDXof/AIMYf/iq6CigDP1PXdH0Tyv7W1WxsPOz5f2u4SLfjGcbiM4yOnqKr2Pi zw3qd5HZ2HiDSru6kzshgvY5HbAJOFBycAE/hWxRQBj33izw3pl5JZ3/AIg0q0uo8b4Z72ON1yAR lScjIIP41X/4Tvwf/wBDXof/AIMYf/iq6CigDj/hha2dj4CtbPTrj7RYwXd7Fbzbw/mRrdShW3Dg 5AByODXYV5/8Ev8AkkOhf9vH/pRJXoFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUV84fGDx3ruu+NG8D 6BceXarKlowtbgA3k0gClHbIAUFyhQnGQS3YKAfR9ZepeJdB0a4W31TW9NsZ2QOsd1dJExXJGQGI OMgjPsa4fUtS1f4ZfA9RqV5aTa1Z24s7aSJwFLFisWwMo3FI8MQV58s57mvEPh58M9S+J1xqd/ca pJaQRPmS8mhaZp5mOSMkgE45Y7sjcvB3ZAB9bwTw3VvFcW8sc0EqB45I2DK6kZBBHBBHOakr5k+F Ou6l8PfibP4O1iWRbS6uDavH82xbgkCOVAVyQ+FUH5QQ6seFFfTdABRRRQBj3HhbRrvxRaeJZ7Pf q9pEYYLjzXGxCGBG0Hafvt1Hf6VsUUUAcHP8GPh9c3Es7+HYw8jl2EdzMigk54VXAUewAA7V3EEE NrbxW9vFHDBEgSOONQqooGAABwABxipKKAOL1X4TeB9a1S41K/0GN7u5ffK6Tyxhm7najAZPUnHJ yTyTXUaVpVjoel2+maZbR21nbpsiiToo/mSTkknkkknJNXKKAOfvP+Sh6N/2Cr//ANG2ldBXP3n/ ACUPRv8AsFX/AP6NtK6CgAooooAKKKKACiiigArP126s7Hw9qd5qNv8AaLGC0lluIdgfzI1Qll2n g5AIweDWhWH40gmuvAviG3t4pJp5dMuUjjjUszsYmAAA5JJ4xQBc0K6s77w9pl5p1v8AZ7Ge0ilt 4dgTy42QFV2jgYBAwOBWhWH4LgmtfAvh63uIpIZ4tMtkkjkUqyMIlBBB5BB4xW5QAUUUUAFFFFAB RRRQAVz/APauj/8ACw/7I+wf8Tv+yvtX23yU/wCPfzdvl787vv8AO3GO/Wugrh/sF5/wvX+0fsk/ 2H/hGvI+0+WfL8z7Tu2bum7HOOuKAO4ooooAKKKKACiiigAooooAK5/wTquj634QsdR0Cw+waZN5 nk23kpFsxIyt8qEqMsGPHrXQVw/wgsLzTPhbo1nf2k9pdR+fvhnjMbrmeQjKnkZBB/GgDuKha6hS 8jtGfE8sbyIuDyqlQxz04Lr+dF01wlu7WkUUs4xtSWQxqeecsFYjjPY1zc8+u/8ACU2BOm6cJfsV ztUX77SN8GST5PB6cY5yeRjmJz5Tow+HdVvVbPqlsr9TqqKr2b3rwk31vBBLu4WCcyqR65KLz14x +NWKtO5hKLi7MKKKKBBRRRQBz+r6ro9p4v8ADmnXth52p332n7Bc+SjfZ9kYaT5idy7lwPlznvXQ Vw/iewvLj4peAryG0nktbX+0PtEyRkpFugULuYcLk8DPWu4oAKKKKACiiigAooooAKKKKAPH/hB/ yUP4nf8AYVH/AKNuK9dlljgheaaRY4o1LO7nCqBySSegryL4Qf8AJQ/id/2FR/6NuK9goBeZzGpe KdG+36R5GvWHl/a28/ZeJjZ5EuN2D03bevfHfFbljqunan5n2C/tbvy8b/ImWTbnOM4PGcH8qh1K 1muL/SJIk3Jb3bSSnIG1TBKmff5mUcetaNZxUru511pUXCKgne3dd3voFFFFaHIFFFFABXP+KtV0 fS/7E/tew+2fatVgtbP9yknk3DbtknzEbcYPzDkZ4roK4f4k2F5ff8Ij9jtJ7jyPEtnPN5MZfy41 37nbHRRkZJ4FAHcUUUUAFFFFABRRRQAUUUUAFc/pGq6Pd+L/ABHp1lYeTqdj9m+33Pkov2jfGWj+ YHc21cj5sY7V0FcP4YsLy3+KXj28mtJ47W6/s/7PM8ZCS7YGDbWPDYPBx0oA7iiiigAooooAKhur q3srd7i7uIoIExuklcIq5OBknjqQKmqpqcEtzp0sUKb5GxhftT2+eQf9YgLL+A56dDSe2hdNJzSl t/XcwJ/EmhHxTYTDWtOMS2VyrOLpNoJeAgE56nafyPpXRWeoWWowmaxu4LqJW2l4JA6g9cZB68j8 64mbR9RHiOyjNp87WlwwH/CQ3hyA8Ofn2ZHUcDg5yfuiut0a1ntLN47iLy3MhYD7dLd8YH8cgBH0 6d+5rGnKTk7/AKno4ylQjSg4XvbvF9X2dyh421XR9E8IX2o6/Yfb9Mh8vzrbyUl35kVV+VyFOGKn n0roK4f4v2F5qfwt1mzsLSe7upPI2QwRmR2xPGThRycAE/hXcVueWFFFFABRRRQAVyviXU9Ks9Sj jvjeCUwhh5GrrarjJ/gM8eTwece2eMDqq5XxLLImpRhbK8nHkj5oLu+iUcnjEEbLn3Jz7YxWVX4T ty9XrbN+js/zRzGk61oUdnIsp1Hcbm4YbfECRjBmcjj7UOcEZOOTzk5yfUa8u0meUWcmNN1Fv9Ju OVv9UUf65+MJCRkdCepPLANkV6jWeG2O3OVaotGtXu7/AHav9Dn/AO1dH/4WH/ZH2D/id/2V9q+2 +Sn/AB7+bt8vfnd9/nbjHfrXQVw/2C8/4Xr/AGj9kn+w/wDCNeR9p8s+X5n2nds3dN2OcdcV3FdJ 4oUUUUAFFFFAFTVX8vSL19+zbBId27bj5TzncuPruX6jrXkt5qe6608/2nu2zk5/tHO3904zn+0D jrjOV64zztb13UCRpt0QjORC/wAqM6seDwCgLA+6gn0Ga82v55TeaZnTdRXFy2A1/qhLfuZOAWhB B75XJwCMbSxHJiVdrU+gyWbipWi3v27Pu0dJ4Ju/tX27/S/tG3y/+Xnztv3v+nmbH/jv49rvjv8A 5J54l/7BV1/6Kam+FpHk+177W6gxsx59zdy5+90+0IuP+A598cU7x3/yTzxL/wBgq6/9FNW9L4Ee XmDbxMm1bb8l2Of+CX/JIdC/7eP/AEokr0CvP/gl/wAkh0L/ALeP/SiSvQK0OMKKKKACiiigDkvG 139l+w/6X9n3eZ/y8+Tu+7/08w5/8e/Dvw9nqe261A/2nt3Tg5/tHG790gzn+0BnpjOW6YzxtXuf HGsWWiwWc9/IYoXZkEhvrm2XdgEAmFGBJAOA2OhxnnHC6d4u0R9Quo47sSSXdyvkImtahukzGiAD bES53KRk89sYAJ5atCcpcyWno+3ofUZZVccLblb08v5vU9b0p/M0iyffv3QRndu3Z+Uc53Nn67m+ p61lavquj2ni/wAOade2HnanffafsFz5KN9n2RhpPmJ3LuXA+XOe9bGnknTbUlGQmFPldnZhwOCX AYn3YA+ozXH+J7C8uPil4CvIbSeS1tf7Q+0TJGSkW6BQu5hwuTwM9a6VsfNVPjfqdxRRRTICiiig Aryf4i/B+XxTrD61pF+kV/cMouIrtiItqoFBQqpIPyjIOc56jGD6xRXXgsdWwVX2tB2e3yJlFSVm fIHjPwdd+CdTtdOvrmGe5mthcOYM7Ey7qACcE8IDnA647ZPXWvwO1rU9J03UtN1TT3hvLOK4Zbnf G0bOu7b8oYEAEc5GfQVnfGLxBaa/47k+yxzJ/Z8RsJfNUDdJHLJkrgn5eRjOD7V7N8K/F+n+I/DU Gm2cNyk2kWdtBcNMqhWbYVyuGJIyh6gdq+7zDMMww+X0sTH4vtaK2uxywhBzaNXwH4Qi8FeGk01J nlmlYT3LFgy+cUVWCfKDtyvGRmp/BOq6PrfhCx1HQLD7Bpk3meTbeSkWzEjK3yoSoywY8etdBXD/ AAgsLzTPhbo1nf2k9pdR+fvhnjMbrmeQjKnkZBB/Gvz6tWnXqOrUd29zrSSVkdxRRRWQwooooAKK KKACiiigDn/FWq6Ppf8AYn9r2H2z7VqsFrZ/uUk8m4bdsk+YjbjB+YcjPFdBXD/EmwvL7/hEfsdp PceR4ls55vJjL+XGu/c7Y6KMjJPAruKACiiigAooooAK5jxTqV1/wjmtQf2Jf+X9knTz98GzGxhu x5m7Hfpn2zxXT1k+Kf8AkUNa/wCvCf8A9FtUVFeLOrByUa8Lq+q79/JoltdSuri4SKTRL+2Rs5ll eAqvHfbIT7cDvWjRRVJWMJyUndK3pf8AVs5/wrquj6p/bf8AZFh9j+y6rPa3n7lI/OuF275PlJ3Z yPmPJxzXQVw/w2sLyx/4S77ZaT2/n+JbyeHzoynmRts2uueqnBwRwa7imQFFFFABRRRQBXvbKK/h EUzzqobdmC4khbP1Qg456dK52DQLM+Kb+LztR2rZWzAjUrjdkvP1O/JHA4PA5x1NdVUK3UL3klor 5nijSR1weFYsFOenJRvyqJQi2mzpo4irThKMG7W6N6arX9PmFrbJaW6QRtKyLnBllaRuTnlmJJ/E 1i+NtV0fRPCF9qOv2H2/TIfL8628lJd+ZFVflchThip59K6CuH+L9hean8LdZs7C0nu7qTyNkMEZ kdsTxk4UcnABP4VZzttu7O4rkvG139l+w/6X9n3eZ/y8+Tu+7/08w5/8e/Dv1tc74pkeP7Jstbqf O/PkXN3Fj7vX7OjZ/wCBY9s81nV+BnXl7axMWlff8n3PPLPU9t1qB/tPbunBz/aON37pBnP9oDPT Gct0xnjavrWlP5mkWT79+6CM7t27PyjnO5s/Xc31PWvObCeUXmp403UWzcrkLf6oCv7mPglYSSe+ WwcEDG0KT6Tp5J021JRkJhT5XZ2YcDglwGJ92APqM1hhla+p6mdTcoxvFrbt2XZssUUUV1nz5554 m1DyPEN1H/aHlY2fJ9u8vHyD+H7dFj/vgfj1OT4W1D/kCw/2h/zwXyvt3+6MbPt34Y8v22fw10+u zSJrNwq2F/KBt+eK91GNT8o6LDEyD8CffnNZHhaaT7Hoq/YL/b5cA8z7bqOzGF52+V5WPbds7Zxz XBJL2m59ZSqS+pW5Hsu3Z+Z6TXP6Rquj3fi/xHp1lYeTqdj9m+33Pkov2jfGWj+YHc21cj5sY7V0 FcP4YsLy3+KXj28mtJ47W6/s/wCzzPGQku2Bg21jw2DwcdK7z5M8Q+OvhbWbTxtqXiWez2aRdywQ wXHmod7iBQRtB3D7jdR2+leT19/18f8AxP8AEFz4o+JOqLfwwKNNNzYQ+SGXckTSlWbJOWyecYHt Sbsrl04Oc1BddDgK+r/gNomo6J8PG/tG38n7ddm9t/nVt8LxRbW4JxnB4OD7VT+BPjXUvFGjXel3 sFpHBotvaW9s0KMGddrrl8sQTiMdAOpr1ymQFFFFABRRRQBn67dWdj4e1O81G3+0WMFpLLcQ7A/m RqhLLtPByARg8GjQrqzvvD2mXmnW/wBnsZ7SKW3h2BPLjZAVXaOBgEDA4FU/GkE114F8Q29vFJNP LplykccalmdjEwAAHJJPGKPBcE1r4F8PW9xFJDPFplskkcilWRhEoIIPIIPGKANyiiigAooooAKK KKACiiigDx/xD/ydD4T/AOwVJ/6DdV7BXj/iH/k6Hwn/ANgqT/0G6r2CgAooooAKKKKACiiigAoo ooA4/wCGF1Z33gK1vNOt/s9jPd3stvDsCeXG11KVXaOBgEDA4FdhXB/BmCa1+FOj29xFJDPE9ykk cilWRhcSAgg8gg8YrvKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoo ooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAr5Y0e+t/Dn7St1d6zJ9ht11W8LSTqV CiUSCNj6Kd6nceMHOcc19T15n8TPhBY+OnGp2M8en60iFWlKZS5AX5VkxyCDgbxkgcENhcAHEftI eI4Zn0jw7bX0bvC73N7bKASjbQIixxwdrSfLnoQSOVNd/wDBLQG0H4ZWLSrIs+ou186sysAHACFc dAY1Q4OTknp0HAeF/wBnK5j1RJ/FGp2klnE6t9msS7Gcc5VnYKUGdvQEkE8qcGvS/ix4f13xJ4Gm svD1xPHfCVWMEMoj+1RkFHjZiyjbh9xByDtxjmgDwzUtSh8UftJW17pKyXMB1i1CtGA+9YfLV3G0 kFMRs2f7vJxX1XXk/wALfg5/whGotrWrXsF5qZiaKOOGPMdvk8srMNxYqAMgLgM45zmvWKACiiig AooooAKKKKACiiigDn7z/koejf8AYKv/AP0baV0Fc/ef8lD0b/sFX/8A6NtK6CgAooooAKKKKACi iigArL8S6lNo3hXV9Ut1jaeyspriNZASpZELAHBBxkeorUrL8S6bNrPhXV9Lt2jWe9spreNpCQoZ 0KgnAJxk+hoAPDWpTaz4V0jVLhY1nvbKG4kWMEKGdAxAyScZPqa1Ky/DWmzaN4V0jS7ho2nsrKG3 kaMkqWRApIyAcZHoK1KACiiigAooooAKKKKACuX/AOEkvP8Ahaf/AAi/lwfYf7E/tDzNp8zzPP8A LxnONuO2M5711Fcv/wAI3ef8LT/4SjzIPsP9if2f5e4+Z5nn+ZnGMbcd85z2oA6iiiigAooooAKK KKACiiigArl/h34kvPF3gTTdcv44I7q683ekCkINsroMAknoo711Fcv8O/Dd54R8Cabod/JBJdWv m73gYlDuldxgkA9GHagDqKrvZxvqUF8WbzYYZIVAPykOUJz7/ux+tWKKGrjjJxd0FFFFAgooooAK KKKAOX1zxJeaZ478KaHDHA1rq/2z7Q7qS6+VEHXaQcDJPOQfwrqK5fXPDd5qfjvwprkMkC2ukfbP tCOxDt5sQRdoAwcEc5I/GuooAKKKZHLHMpaKRXUMykqcjIJBH1BBB9xQFuo+iiigAooooAKKKKAP H/hB/wAlD+J3/YVH/o24r2CvH/hB/wAlD+J3/YVH/o24r2CgAooooAKKKKACiiigArl/GniS88Of 8I99jjgf+0tbttPm85Sdscm7cVwRhuBgnI9q6iuX8aeG7zxH/wAI99jkgT+zdbttQm85iN0ce7cF wDluRgHA96AOoooooAKKKKACiiigAooooAK5fQ/El5qfjvxXoc0cC2ukfY/s7opDt5sRdtxJwcEc YA/Guorl9D8N3mmeO/FeuTSQNa6v9j+zojEuvlRFG3AjAyTxgn8KAOoooooAKKKKACsnxNF5/h66 j8rzc7Pk8rzM/OP4fKlz/wB8H8Oo1qyfE0Xn+HrqPyvNzs+TyvMz84/h8qXP/fB/DqJn8LN8L/Hh 6r8zzCTTMavbJ/ZmMwSnb/Z3XDR84/s/nGeu04z1XOG9D8G2/wBm0iVPs/kZnJ2+R5WflXnHkQ/n tP1PQeeSaZjV7ZP7MxmCU7f7O64aPnH9n84z12nGeq5w3ofg23+zaRKn2fyMzk7fI8rPyrzjyIfz 2n6noOPD/GfR5x/uq/rqyH4ieJLzwj4E1LXLCOCS6tfK2JOpKHdKiHIBB6Me9dRXL/ETw3eeLvAm paHYSQR3V15Wx52IQbZUc5IBPRT2rqK7j5UKKKKACiiigArh/GVl9p1eJ/sPn4gA3fY/Nx8zcZ+y TfluH0HU9xXD+MrL7Tq8T/YfPxABu+x+bj5m4z9km/LcPoOpxr/AellX+8L0ZyWm6ZvtXP8AZm79 /MM/2du6SsMZ/s9unTGeOmF+6PZa8a03TN9q5/szd+/mGf7O3dJWGM/2e3TpjPHTC/dHstZYXZ/I 7s++OPrL9Dl/+EkvP+Fp/wDCL+XB9h/sT+0PM2nzPM8/y8ZzjbjtjOe9dRXL/wDCN3n/AAtP/hKP Mg+w/wBif2f5e4+Z5nn+ZnGMbcd85z2rqK6z58KKKKACiiigCpqqeZpF6mzfugkG3buz8p4xtbP0 2t9D0ryW80zbdaeP7M27pyMf2djd+6c4x/Z4z0zjDdM443L61qqeZpF6mzfugkG3buz8p4xtbP02 t9D0r50k8a6TNJDIujbRC+9xmw+YbSuOLcDqwPzZHHTOCMamHqVvgV7W/Fn0WRtKM7+f5HtPgm0+ y/bv9E+z7vL/AOXbyd33v+naHP8A49+He747/wCSeeJf+wVdf+imrnfhTqltrNhqV3a2X2WMSpER th+YgE9YoUU/eHBLEei5G7ovHf8AyTzxL/2Crr/0U1aQhKmuWW6PLzJ3xMvl+SOf+CX/ACSHQv8A t4/9KJK9Arz/AOCX/JIdC/7eP/SiSvQKo4QooooAKKKKAOG+KfhLUfFvhqGHSBAL+2n85TI+xmTY wKK2OCx2cEgcDJ4ry7wt8LfF8niTT5NTs1t7Ozmje6F1OGWYBwzIAu7flD/u8EEgjFe6+J7yfTvC es31rJ5dzbWM80T4B2usbEHB4PIHWvKvhB488S+KPFl1Y6zqX2m2jsXmVPIjTDiSMA5VQejH869/ ArESwE6kIwcYO7uve1TWnTr1KjialP3FJq6tvtqn+h7PFFHBCkMMaxxRqFREGFUDgAAdBXNa54kv NM8d+FNDhjga11f7Z9od1JdfKiDrtIOBknnIP4V1Fcvrnhu81Px34U1yGSBbXSPtn2hHYh282IIu 0AYOCOckfjXgEt31Z1FFFFABRRRQAUUUUAea6p8EfDWratealPfass13O88ixyxhQzsWIGYycZPr XQeDPAGleBvtv9mXF7N9s8vzPtLq2Nm7GNqj+8f0rqqK76uZ4urS9jUqNx7emxKhFO6QVy/w78SX ni7wJpuuX8cEd1debvSBSEG2V0GAST0Ud66iuX+Hfhu88I+BNN0O/kgkurXzd7wMSh3Su4wSAejD tXAUdRRRRQAUUUUAFFFFABRRRQBy/jTxJeeHP+Ee+xxwP/aWt22nzecpO2OTduK4Iw3AwTke1dRX L+NPDd54j/4R77HJAn9m63bahN5zEbo4924LgHLcjAOB711FABRRWdot1Nd2Esk773W7uYwcAfKk 7oo49FUD8KV9bFqDcHPtZfff/I0aKKKZAVw/im5/4lGtJ/auvf6iceT/AGZ+5+63y7/I+523bunO 7vXcVzHinTbr/hHNan/tu/8AL+yTv5GyDZjYx258vdjt1z755rKsnyu39fijvy6UFXjzd1+f+F/p 6kumXPmajEv9q69PnP7u60zyozwereQuP++hzgc9K6Ks61026t7hJZNbv7lFzmKVIArcd9sYPvwe 1aNVBNLX+vxZhiZQlO8Pw/8A2Y/l8zl/BfiS88R/8JD9sjgT+zdbudPh8lSN0ce3aWyTluTkjA9q 6iuX8F+G7zw5/wAJD9skgf8AtLW7nUIfJYnbHJt2hsgYbg5AyPeuiurdbuzntnOEmjaNjtVuCMdG BB+hBHqDVmCs3qVNSupre/0iOJ9qXF20cowDuUQSvj2+ZVPHpWjXA6l4G06G/wBIjWXie7aNv9Bs xx5ErdoQDyo4OR3xkAjqNE8P2uhef9mfd523d/o8EXTOP9VGmevfPtjmsoSm5O6/qx34mjh40ouF S7t2avq/6+RrUUUVqeeZ2s6hPptmk1va/aXaQIUxKcDBOf3cch7emOevQHkofE2or4jvZho+Xe0t 0KbLzgB5iD/x7Z53HqAOOCeQO2vbaW6hCQ3s9mwbPmQLGWI9PnVhj8M8VzsGlXh8U36f2/qIYWVs TII7fcwLz8H91jAwegzyc54xhU5+ZW/Q9TBvDqlP2iV7d5d12TN/TLuW+06K5mg8iR85jw4xgkfx ojdu6j8RzWF8RPEl54R8CalrlhHBJdWvlbEnUlDulRDkAg9GPeuitYXt7dIpLmW5dc5llChm577Q B7cDtXO/ETw3eeLvAmpaHYSQR3V15Wx52IQbZUc5IBPRT2rZXtqedU5ed8ux1Fcl42tPtX2H/RPt G3zP+Xbztv3f+nabH/jv49utrkvG1p9q+w/6J9o2+Z/y7edt+7/07TY/8d/HtnW+BnXlv+9R+f5M 4ez0zddagP7M3bZwMf2dnb+6Q4x/Z5x1zjC9c453N61pSeXpFkmzZtgjG3btx8o4xtXH02r9B0ry Wz0zddagP7M3bZwMf2dnb+6Q4x/Z5x1zjC9c453N61pSeXpFkmzZtgjG3btx8o4xtXH02r9B0rDC 7s9XPfhh8vyRbooorsPnDzzxNp/n+IbqT+z/ADc7Pn+w+Zn5B/F9hlz/AN9n8OgyfC2n/wDIFm/s /wD54N5v2H/dOd/2H8c+Z77/AOKtbxNp/n+IbqT+z/Nzs+f7D5mfkH8X2GXP/fZ/DoMnwtp//IFm /s//AJ4N5v2H/dOd/wBh/HPme+/+KvOl/FPsaP8AuK9F+TPWa5fQ/El5qfjvxXoc0cC2ukfY/s7o pDt5sRdtxJwcEcYA/Guorl9D8N3mmeO/FeuTSQNa6v8AY/s6IxLr5URRtwIwMk8YJ/CvRPjjqK4H WvA2nWthFIkuSbu2j/48bNeGnRT92EHoenQ9CCMg99TJIo5lCyxq6hlYBhkZBBB+oIBHuKipTU1Z nVhMXUw01KD0ur/IxtG8LWeiXj3Nu+52jMZH2W3j4JB6xxKe3TOPbpW5RRTjFRVkY1a06suabuwo oqG6tbe9t3t7u3ingfG6OVA6tg5GQeOoBqiFa+pUmupk8R2Vor4gltLiR1wOWV4Qpz14Dt+daNcx N4W0b/hI7LboNh9l+yXHmYs02b98O3PGM434/wCBe9b9np9lp0JhsbSC1iZtxSCMIpPTOAOvA/Ko i5XdzprxoqEORu9uyXV+bKfiXUptG8K6vqlusbT2VlNcRrICVLIhYA4IOMj1FHhrUptZ8K6Rqlws az3tlDcSLGCFDOgYgZJOMn1NHiXTZtZ8K6vpdu0az3tlNbxtISFDOhUE4BOMn0NHhrTZtG8K6Rpd w0bT2VlDbyNGSVLIgUkZAOMj0FWcpqUUUUAFFFFABRRRQAUUUUAeP+If+TofCf8A2CpP/QbqvYK8 f8Q/8nQ+E/8AsFSf+g3VewUAFFFFABRRRQAUUUUAFFFFAHF/CjUptZ+HVhqlwsaz3txd3EixghQz 3UrEDJJxk+prtK4v4UabNo3w6sNLuGjaeyuLu3kaMkqWS6lUkZAOMj0FdpQAUUUUAFFFFABRRRQA UUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABR RRQAUUUUAFcP8RPibpfw+s4hLH9t1OfBhsUk2EpnBdmwdq8EDg5PAHDEdxXyxe27/ET9omXTNXl/ 0VNQltvLBYr5FvvPlj5srvEZyQRhnZgO1AEer/Gv4kTJaagrx6VZ3CMsBgsB5U5VsMytKHLEEgHB wMDgHr6/4m8b6voPwW0nxLCslxqlxb2LvMIA0YZwjuZQMBUYBlyMcuoGMgji/wBpr/mVv+3v/wBo 1654Lghuvhp4et7iKOaCXR7ZJI5FDK6mFQQQeCCOMUAc38L/AIsW/wAQPOsLmz+xavbRCV0Qlo5k G0M6nHy/MfunOARgtzj0ivlSTTYfA/7Rtlp2hNJDbx6nbRoHIcrHOqb0yR02yMoJ5xjnPNfVdABR RRQAUUUUAFFFFABRRRQBz95/yUPRv+wVf/8Ao20roK5+8/5KHo3/AGCr/wD9G2ldBQAUUUUAFFFF ABRRRQAVh+NJ5rXwL4huLeWSGeLTLl45I2KsjCJiCCOQQec1uVn67a2d94e1Oz1G4+z2M9pLFcTb wnlxshDNuPAwCTk8CgCn4LnmuvAvh64uJZJp5dMtnkkkYszsYlJJJ5JJ5zW5WfoVrZ2Ph7TLPTrj 7RYwWkUVvNvD+ZGqAK24cHIAORwa0KACiiigAooooAKKKKACuH+33n/C9f7O+1z/AGH/AIRrz/s3 mHy/M+07d+3puxxnriu4rn/7K0f/AIWH/a/2/wD4nf8AZX2X7F5yf8e/m7vM2Y3ff43Zx260AdBR RRQAUUUUAFFFFABRRRQAVw/wgv7zU/hbo15f3c93dSefvmnkMjtieQDLHk4AA/Cu4rn/AATpWj6J 4QsdO0C/+36ZD5nk3PnJLvzIzN8yAKcMWHHpQB0FFFFABRRRQAUUUUAFFFFAHD+J7+8t/il4Cs4b ueO1uv7Q+0QpIQku2BSu5Rw2DyM9K7iuf1fStHu/F/hzUb2/8nU7H7T9gtvORftG+MLJ8pG5tq4P y4x3roKAKN7f3NrMEh0m8vFK58yB4QoPp88inP4Y5rD0DVbxNOlC6BqMg+23Z3LJb4BNxISOZRyO h7ZHGRzXVVU02x/s+1eHzPM3TzTZ24x5krSY/Ddj3xWbi3K9zrhWhGi4uKbuu/n5luiiitDkCiii gAooooA8f+EH/JQ/id/2FR/6NuK9grx/4Qf8lD+J3/YVH/o24r2CgAoqjf3klreaZCiqVurloXLD kAQyPx75Qfhmr1JO5UoOKTfX/O36BRRRTJCiiigArh/iTf3lj/wiP2O7nt/P8S2cE3kyFPMjbfuR sdVOBkHg13Fc/wCKtK0fVP7E/te/+x/ZdVgurP8AfJH51wu7ZH8wO7OT8o5OOKAOgooooAKKr2V5 HfwNNErBVmlhIYc5jdkP4ZU49qsUJ31HKLi3F7oKKKKBBRRRQAVw/hi/vLj4pePbOa7nktbX+z/s 8LyEpFugYttU8Lk8nHWu4rn9I0rR7Txf4j1Gyv8AztTvvs32+285G+z7Iysfygbl3Lk/NnPagDoK KKKACiiigArO12B7jRriKO0iu3bbiCWFZVb5geVZ0Bx15YdM89Do1DdTPb27yx20ty64xFEVDNz2 3ED35PalJXTTNKUnGcZR3TR5pLpF4NdtI/8AhF9ODNbTsIhpNuFYBovmK/asEjIGSQRuOAckjuPD VrLaabJHNp0FgxmLeVBbRwKRgfNtSSQE9s5B46cZOdPqt4fFNg/9gaiGFlcgRmS33MC8HI/e4wMD qc8jGecdFZ3Mt1CXmsp7Ng2PLnaMsR6/IzDH454rClCKk2rnq4/FVqlGMZ8trdGu782cf8X7+80z 4W6zeWF3PaXUfkbJoJDG65njBww5GQSPxruK5/xtpWj634QvtO1+/wDsGmTeX51z5yRbMSKy/M4K jLBRz610FdB4wUUUUAFFFFABXD+Mrqzh1eJbi10aVzACGvre3kfG5uAZLiM4/wCAkdeeoHcV5H8b vDmp6tFpV/p8ULQWqyrcy3NzFHHEGKBP9awUEnIyOTwD0FbYfCfXKsaHMo36vb+nsdOExMcNU9pJ NryK2m3unLauHsvDjHz5jmWzsycGVsD5rsHGOnGAMYLDBPstfOXw08J6peeNrO8dLd9Otgy3Mtnf RCSImJ1XmJ94BYcEcEdMrX0bSrYD6m4x51Lminp0v0fmdea4yGJqWimuVvc4f7fef8L1/s77XP8A Yf8AhGvP+zeYfL8z7Tt37em7HGeuK7iuf/srR/8AhYf9r/b/APid/wBlfZfsXnJ/x7+bu8zZjd9/ jdnHbrXQVkeWFFFFABRRRQAV8ieONDs/CnjHVdFspJ5LeFYljaYgudyI5yQAOpPb0r67ryrxh8Zv +ET8VXuif2B9q+zbP332zZu3Ir/d2HH3sde1e/w9WxEK8oUKfPdJtcyjs007vt28yJy5db23X3qx 2vhDwhp/grSZdN02a5lhlnM7NcsrNuKquPlUDGFHajx3/wAk88S/9gq6/wDRTV0Fc/47/wCSeeJf +wVdf+imrxKtWdabqVHdvdlJJKyOf+CX/JIdC/7eP/SiSvQK8/8Agl/ySHQv+3j/ANKJK9ArMYUU UUAFVNQ1TT9JgWfUr62s4WbYslzMsalsE4yxAzgHj2q3Xmvxu0vUNW8F2cGm2NzeTLqCO0dtC0jB fLkGcKCcZI59668DQhiMRClN2Te5MnZXRxWtfHf+2NB1HTP+Eb8n7ZbSW/mfbt2zepXOPLGcZ6Zr hvAHjP8A4QbXp9T+wfbfNtmt/L87y8ZZWznaf7vTHejw/q3g/TtBdNZ8MzavqpuSVb7Y9vGsO0YG VPLbgeNvQ9eMVpQeJ/h808Yn+HjpCWAkePWZnZVzyQpwCcdsjPqK/R44PD4enUw9LDScJb2a19Lz T/I4+ZtpuX9fcezeAPijaeN7q6tZrSHTbmLZ5EL3gke4yGLbQVUnaFycZ69qseJ7+8t/il4Cs4bu eO1uv7Q+0QpIQku2BSu5Rw2DyM9K8V+DNldz/EnTbqG1mktrbzfPmSMlIt0MgXcRwuTwM9a+gtX0 rR7vxf4c1G9v/J1Ox+0/YLbzkX7RvjCyfKRubauD8uMd6+J4hwNDBYz2dDSLSdt7br16X+Z00pOU bs6CiiivDNQopkUsc8KTQyLJFIoZHQ5VgeQQR1FPoBq2jCiiigAooooAK4f4QX95qfwt0a8v7ue7 upPP3zTyGR2xPIBljycAAfhXcVz/AIJ0rR9E8IWOnaBf/b9Mh8zybnzkl35kZm+ZAFOGLDj0oA6C iiq73kaalBYlW82aGSZSB8oCFAc+/wC8H60N2HGLk7IsUUUUCCiiigAooooA4f4k395Y/wDCI/Y7 ue38/wAS2cE3kyFPMjbfuRsdVOBkHg13Fc/4q0rR9U/sT+17/wCx/ZdVgurP98kfnXC7tkfzA7s5 Pyjk44roKAKN7oulajMJr7TLO6lVdoeeBXYDrjJHTk/nWNovhbRvsEv2rQbDzPtdzjzbNM7PPfZ1 HTbtx7YxxXT0VDpxbu0dEcVWhT9nGTtp1fS/+YUUUVZzhXMeKYdZ/wCEc1pvt9h9l+yTny/sT79m xuN3m4zjvt98dq6euY8U6/o3/COa1Z/2vYfavsk8Xk/aU379jDbtznOeMVnVtyu52YBVPbx5FfVd L9fTQ1rWHWUuEa7v7CWAZ3JFZPGx44wxlYDnHY1o1nWuv6Ne3CW9pq9hPO+dscVyjs2Bk4AOegJr Rqo2toYVlUUv3is/S36I4f4bX95ff8Jd9su57jyPEt5BD50hfy412bUXPRRk4A4FdxXP+FdK0fS/ 7b/si/8Atn2rVZ7q8/fJJ5Nw23fH8oG3GB8p5Gea5H4jfGKx8FvBbaZFZaveSmaOZY71c2kibQBI qgnkk8EqflP4UZI9DvJ7eG609J4t8k05SBtoOx/KdieenyqwyPXHQmrdfJX/AAuLxdd/v5dVnZ7P 99ETFb/Kx/d54hH8MjDnI56ZwRvaB+0TrGm280Wr6cdYdn3RytOkDIMcr8kWCO44zyeTxiIybbVj qrUYRhGSmnp5933R9L0VXsb+z1OzjvLC7gu7WTOyaCQSI2CQcMODggj8KsVZyle91Cy06ETX13Ba xM20PPIEUnrjJPXg/lXOweJNCHim/mOtacImsrZVc3SbSQ85IBz1G4fmPWuivdQstOhE19dwWsTN tDzyBFJ64yT14P5VzsHiTQh4pv5jrWnCJrK2VXN0m0kPOSAc9RuH5j1rKcrSWqPQwtLmpTfJJ6dP 8S8mdJa3Vve26XFpcRTwPnbJE4dWwcHBHHUEVxvxfv7zTPhbrN5YXc9pdR+RsmgkMbrmeMHDDkZB I/Guytbq3vbdLi0uIp4HztkicOrYODgjjqCKxfG2laPrfhC+07X7/wCwaZN5fnXPnJFsxIrL8zgq MsFHPrWi2OGStJq1jU1LVtN0a3W41TULSxgZwiyXUyxKWwTgFiBnAJx7Gvmnxb8dZ/ElvbRW/h+2 snhcsZZTFdMQR90eZEQo7njJwORg5+ivEnhbRvF2nR2GuWf2u1jlEyp5rx4cAgHKEHox/OvF/wDh mX/qbv8Aym//AG2iUVJWZVKrKlJTg7NHmz+PtRgSORYrXM6+Y2bCzPIJXjMBA4UcDA74yST758Lf itZ+NfN0yaxs9JuraOJLeBLoH7R8rbvLjIBAUJnA3YB9uePf9ml3VFbxhkIu1f8AiWdBkn/nr6k1 1vw9+C+neCNYfVrm/wD7Uvkx9kl8loPs+VdX4DkNuDY5HGOOtRCmobG+KxlTENcz0Vu29kmeoUUU Vochzup+Gv7Q1GW68jQW345utJ86Q4AHL+YM9PTgYFZPhbw1/wASjRb7yNB/1EE27+yf333VOfM8 z7/+1jrzjtXT3UOsvcO1pf2EUBxtSWyeRhxzlhKoPOewrJ8LQ6z/AMI5orfb7D7L9kgPl/Yn37Ni 8bvNxnHfb747VzuEef4f6+89eGJqrDNe1XRbPs9Ph/rudPXD+GL+8uPil49s5rueS1tf7P8As8Ly EpFugYttU8Lk8nHWu4rn9I0rR7Txf4j1Gyv/ADtTvvs32+285G+z7Iysfygbl3Lk/NnPaug8g6Ci iigAooooAKKKKACiiigDD8aTzWvgXxDcW8skM8WmXLxyRsVZGETEEEcgg85o8FzzXXgXw9cXEsk0 8umWzySSMWZ2MSkkk8kk85q5rtrZ33h7U7PUbj7PYz2ksVxNvCeXGyEM248DAJOTwKNCtbOx8PaZ Z6dcfaLGC0iit5t4fzI1QBW3Dg5AByODQBoUUUUAFFFFABRRRQAUUUUAeP8AiH/k6Hwn/wBgqT/0 G6r2CvH/ABD/AMnQ+E/+wVJ/6DdV7BQAUUUUAFFFFABRRRQAUUUUAcH8GZ5rr4U6PcXEsk08r3Ly SSMWZ2NxISSTySTzmu8rj/hha2dj4CtbPTrj7RYwXd7Fbzbw/mRrdShW3Dg5AByODXYUAFFFFABR RRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFF FABRRRQAUUUUAFFFFABXy54+tb74X/GmPxJaJJLb3Vw2oRFv+WgckTxbimAfmccAlVdD1r6jrL1/ w5pHinS203WrGO7tC4fYxKlWHQqykFT1GQRwSOhNAHzx8cvF2i+MdL8J3+j3scwKXLSwFgJYCfKG 2RM5U5VvY4yCRzXo+mfFXwh4T+HPh1bvVI7q7TTLdDZ2JWaUMsaBgwBwhGejlehxkjFc/qX7NOmy 3CtpfiS7toNgDJdWyzsWyeQylABjHGOx554NN/Zp02K4ZtU8SXdzBsIVLW2WBg2RyWYuCMZ4x3HP HIBxnw5s9U+J3xh/4SLUzhbSVL+5khTYilMCGNeCOqqME5Ko5ySM19T1l6B4c0jwtpa6botjHaWg cvsUlizHqWZiSx6DJJ4AHQCtSgAooooAKKKKACiiigAooooA5+8/5KHo3/YKv/8A0baV0Fc/ef8A JQ9G/wCwVf8A/o20roKACiiigAooooAKKKKACuf8d/8AJPPEv/YKuv8A0U1dBWfrt1Z2Ph7U7zUb f7RYwWkstxDsD+ZGqEsu08HIBGDwaAM/wJ/yTzw1/wBgq1/9FLXQVn6FdWd94e0y8063+z2M9pFL bw7AnlxsgKrtHAwCBgcCtCgAooooAKKKKACiiigArz//AJuF/wC5U/8AbuvQK5/+1dH/AOFh/wBk fYP+J3/ZX2r7b5Kf8e/m7fL353ff524x360AdBRRRQAUUUUAFFFFABRRRQAV5/8ABL/kkOhf9vH/ AKUSV6BXP+CdV0fW/CFjqOgWH2DTJvM8m28lItmJGVvlQlRlgx49aAOgooooAKKKKACiiigAoooo A8/8W/8AJXvh1/3E/wD0nWvQK5/V9V0e08X+HNOvbDztTvvtP2C58lG+z7Iw0nzE7l3LgfLnPeug oAKKKKACiiigAooooAKKKKAPH/hB/wAlD+J3/YVH/o24r12WNZoXiYsFdSpKOVbB9CMEH3HNeRfC D/kofxO/7Co/9G3FewUAnbVHK6roFmmo6Iom1EiS9ZTu1K4JA+zzHgl+DwORzjI6E1v2Omwaf5nk yXTb8Z8+6lmxjPTexx17dat0VEYRTukdFXFVakVCUnZLvvq2FFFFWc4UUUUAFef/ABT/AOZK/wCx rsf/AGevQK5/xVquj6X/AGJ/a9h9s+1arBa2f7lJPJuG3bJPmI24wfmHIzxQB0FUb2LVXmBsb2zg i28rPaNKxPrkSLx04x+NXqo3urW1hMIpo7xmK7swWU0y4+qKRnjp1qZWtqaUufm9xXfpf8NTD0CD XTp0vlalpyr9tu8hrB2OftEmTnzhwTkgdhxk9a6quV0DX7OLTpVaHUSTe3bfLptwwwbiQjkJ155H UHg8iuqqKVuVWZ049VPbS5421dtLdfTUKKKK1OIKKKKACvP/AAl/yV74i/8AcM/9J2r0Cuf0jVdH u/F/iPTrKw8nU7H7N9vufJRftG+MtH8wO5tq5HzYx2oA6CiiqmpX39n2qTeX5m6eGHG7GPMlWPP4 bs++KTdldlRi5yUY7st0UUUyQooooAqSWPmavbX/AJmPJglh2beu9oznPt5f6+1W6KKVrFOTaSfT /hzz/wCNv/JIdd/7d/8A0ojr0Cuf8baro+ieEL7UdfsPt+mQ+X51t5KS78yKq/K5CnDFTz6V0FMk KKKKACiiigArh/jD/wAkr1n/ALYf+j467isPxhqWlaP4Vvb/AFuy+26dFs8638pZN+XUL8rEA4Yg 8+ldeAm4YqlKKu1Jad9VoTLWLPKv2dv+Zk/7df8A2rXuNcP8O/EvhXxD/aX/AAjOif2Z5HlfaP8A RYofM3b9v3Cc4w3Xpmu4rqzurKtj6k5wcW7aPdaImmrRSPP/APm4X/uVP/buvQK5/wDtXR/+Fh/2 R9g/4nf9lfavtvkp/wAe/m7fL353ff524x3610FeUaBRRRQAUUUUAYfiLxhoPhP7N/bd/wDZftO7 yf3Lvu243fdU4+8OvrXzH8SNYsNf8f6nqemT+fZz+V5cmxl3bYkU8MAeoParfiV9Q8TfFG40W81O 5eFtaltLfzpGlW3V5tnyqTgADHAx0Fd5/wAM7f8AU0/+U/8A+2199l9DAZLy1sRVanOPZtWbT6Ly XU5ZuVTRLQ7n/hcPgP8A6Dv/AJKT/wDxFbHjv/knniX/ALBV1/6KavnX4ifDv/hAf7N/4mv277b5 v/Lv5WzZs/2mznf7dK9Z0W9u9R/Zzv7q+uprm5k0rUN808hd2wZgMk8ngAfhXh5rlWEoYSni8HNy jJ21+e2i7Pc0pzk5OMkaPwS/5JDoX/bx/wClElegV5/8Ev8AkkOhf9vH/pRJXoFfOmwUUUUAFef/ ABf8N6t4o8J2tjo1p9puY75JmTzETCCOQE5YgdWH516BRXRhcTPC1o1obx112FJcysz4dor7J8XT y23gvXZ4JXimi0+4eOSNirIwjYggjkEHvXjnwR8Q61q3jS8g1LWNQvIV093WO5uXkUN5kYzhiRnB PPvX6HhuIZ4jC1MUqVlDpzb/APkpySpWko33MD4KaPf3vj+11O3g32en7/tMm9R5fmRSKnBOTkjs D71634t/5K98Ov8AuJ/+k616BXP6vquj2ni/w5p17Yedqd99p+wXPko32fZGGk+Yncu5cD5c5718 Pm2ZyzHEe2ceWySS389/V9kdNOHIrHQVzup+MbDStRlspo8yR4yftlqnUA/deVWHXuB+VdFXG67N Ims3CrYX8oG354r3UY1PyjosMTIPwJ9+c15FWTS0dj0MBShUqNTjzadPl5oh8LeMbD+yNF03y/33 kQQZ+2Wv3tqr93zd/Xtt3e2eK7ivNvC00n2PRV+wX+3y4B5n23UdmMLzt8ryse27Z2zjmvSaihJu Orub5tShTrvljy3v89fVhRRRW55YUUUUAFef/BL/AJJDoX/bx/6USV6BXP8AgnVdH1vwhY6joFh9 g0ybzPJtvJSLZiRlb5UJUZYMePWgDV1OS8i06V7CPzLoY2LsD55GeC6A8Z/iH49Dxk174pPiOyZr L9+LS4CL9ji5XfDuOPteOoX+IdehzlfPPH/x5Kailn4Teyv9Mkt1aWaSO5hkWXe2VDK8bAYCdPUj PavL1+IPi97Z7pvEeom4jdY0kM53KrBiwB9CUX/vkVjVi3qvLr5np5fXpwvGSTdpfZv9nvdfcfYG jTalNZu2qQ+VOJCFXylj+XA5wssg65/iH07nRr5b8H/HXxDpc+n6fqklrcWLXS/bL26E0s4jLDeR h8cL0AXt0JJz9OWF9b6np1tf2cnmWt1Ek0L7SNyMAVODyMgjrWsVZWZwVZKU3KO3pb8NSxRRRTMw oqpHfeZq9zYeXjyYIpt+7rvaQYx7eX+vtVukncqUXF2f9X1PP/in/wAyV/2Ndj/7PXoFc/4q1XR9 L/sT+17D7Z9q1WC1s/3KSeTcNu2SfMRtxg/MORniuf8Aiv4r1jw14eki0nQ76++2Wlysl9aO6/2f hBiQlVOMbi2SV+4efRknReIPGegeF5oYdXvmhlmUsiRwSTNgcZIRWwPTOM4OOhrntE+J/hcoLW51 eb7RLdzbDLazhQjzMY8uU2qNhXqRtHBxjj5P1PXdY1vyv7W1W+v/ACc+X9ruHl2ZxnG4nGcDp6Co pLt4r+C6tJ5IpoViaOWNirI6qvIPUEEdR6Vm1Lm0OuEqKotSTvddV5+R96UV4n8AvF2vazb32m6p DqV9AryXC6vdTvKobES+QCwIzgl8bu54717ZWhyBWdr9rNe+HNUtLdN889pLHGuQNzMhAGTx1NaN VNVvv7M0i9v/AC/M+ywSTbN2N21ScZ7ZxSlazuaUXJVIuG91b1LdFFFMzPP/AIWf8zr/ANjXff8A slY/jX4E6N4n1EX+mXf9kXUsss14/lvcfaHcg5w0gCYO7p/e9q7jwrquj6p/bf8AZFh9j+y6rPa3 n7lI/OuF275PlJ3ZyPmPJxzXQUAeBL+zS6K6r4wwHXa3/Es6jIP/AD19QKZ/wzL/ANTd/wCU3/7b X0BRQNtvcz9E0TTvDmjwaTpNv9nsYN3lxb2fbuYseWJJ5JPJrQoooEV71L14QLG4ggl3ctPAZVI9 MB156c5/Cudgg13/AISm/A1LThL9ittzGwfaRvnwAPO4PXnPORwMc9VUK2sKXkl2qYnljSN2yeVU sVGOnBdvzqJQu0zpo4h04SjZarsn1T6ryC1W4S3RbuWKWcZ3PFGY1PPGFLMRxjua4X42/wDJIdd/ 7d//AEojr0Cuf8baro+ieEL7UdfsPt+mQ+X51t5KS78yKq/K5CnDFTz6VZzt3dzoKKKKBBRRRQAU UUUAFQ2trDZWcFpbpsggjWONck7VUYAyeegqaigd3awV5/4S/wCSvfEX/uGf+k7V6BXP6Rquj3fi /wAR6dZWHk6nY/Zvt9z5KL9o3xlo/mB3NtXI+bGO1AjoKKKKACiiigAooooAKKKKAOf8d/8AJPPE v/YKuv8A0U1HgT/knnhr/sFWv/opa0NdurOx8Paneajb/aLGC0lluIdgfzI1Qll2ng5AIweDRoV1 Z33h7TLzTrf7PYz2kUtvDsCeXGyAqu0cDAIGBwKANCiiigAooooAKKKKACiiigDx/wAQ/wDJ0PhP /sFSf+g3VewV4/4h/wCTofCf/YKk/wDQbqvYKACiiigAooooAKKKKACiiigDz/4Jf8kh0L/t4/8A SiSvQK4/4YXVnfeArW8063+z2M93ey28OwJ5cbXUpVdo4GAQMDgV2FABRRRQAUUUUAFFFFABRRRQ AUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAB RRRQB8wf8Ib8c/8An61z/wAHq/8Ax6j/AIQ345/8/Wuf+D1f/j1fT9cP8RPibpfw+s4hLH9t1OfB hsUk2EpnBdmwdq8EDg5PAHDEAHjH/CG/HP8A5+tc/wDB6v8A8eo/4Q345/8AP1rn/g9X/wCPV7X8 LvGs3jzwcNUu4I4byK4e3uFiQrGWGGBTLMcbXTOT1z2xWP8AGTxl4j8HaXpd1oFpIyG4Mt5cmHzI kjXaBHJx8odnHIZT8uAeeADgPDXhP4y23irSJ9UudZOnx3sL3Qk1pXUxBwXyvmncNueMHNfRdeb/ AAv+LFv8QPOsLmz+xavbRCV0Qlo5kG0M6nHy/MfunOARgtzj0igAooooAKKKKACiiigAooooA5+8 /wCSh6N/2Cr/AP8ARtpXQVz95/yUPRv+wVf/APo20roKACiiigAooooAKKKKACsPxpBNdeBfENvb xSTTy6ZcpHHGpZnYxMAABySTxitysvxLqU2jeFdX1S3WNp7KymuI1kBKlkQsAcEHGR6igCv4Lgmt fAvh63uIpIZ4tMtkkjkUqyMIlBBB5BB4xW5WX4a1KbWfCukapcLGs97ZQ3EixghQzoGIGSTjJ9TW pQAUUUUAFFFFABRRRQAVw/2C8/4Xr/aP2Sf7D/wjXkfafLPl+Z9p3bN3TdjnHXFdxXL/APCSXn/C 0/8AhF/Lg+w/2J/aHmbT5nmef5eM5xtx2xnPegDqKKKKACiiigAooooAKKKKACuH+EFheaZ8LdGs 7+0ntLqPz98M8ZjdczyEZU8jIIP413Fcv8O/El54u8Cabrl/HBHdXXm70gUhBtldBgEk9FHegDqK KKKACiiigAooooAKKKKAOH8T2F5cfFLwFeQ2k8lra/2h9omSMlIt0ChdzDhcngZ613FcvrniS80z x34U0OGOBrXV/tn2h3Ul18qIOu0g4GSecg/hXUUAFFFZ2i3U13YSyTvvdbu5jBwB8qTuijj0VQPw pX1sWoNwc+1l99/8jRooopkBRRRQAUUUUAeP/CD/AJKH8Tv+wqP/AEbcV7BXj/wg/wCSh/E7/sKj /wBG3FetXVut3Zz2znCTRtGx2q3BGOjAg/Qgj1BoGrN6lTUrqa3v9IjifalxdtHKMA7lEEr49vmV Tx6Vo1wOpeBtOhv9IjWXie7aNv8AQbMceRK3aEA8qODkd8ZAI6jRPD9roXn/AGZ93nbd3+jwRdM4 /wBVGmevfPtjmsoSm5O6/qx34mjh40ouFS7t2avq/wCvka1FFFannhRRRQAVw/xJsLy+/wCER+x2 k9x5HiWznm8mMv5ca79ztjooyMk8Cu4rl/GniS88Of8ACPfY44H/ALS1u20+bzlJ2xybtxXBGG4G Ccj2oA6iiiqN7oulajMJr7TLO6lVdoeeBXYDrjJHTk/nSd+hUFFv3nZff+qK/hz/AJBk3/X/AHn/ AKUy1rVzGi+FtG+wS/atBsPM+13OPNs0zs899nUdNu3HtjHFdPU078qudGM5PbScHfV9PP1YUUUV ZyhRRRQAVw/hiwvLf4pePbya0njtbr+z/s8zxkJLtgYNtY8Ng8HHSu4rl9D8SXmp+O/FehzRwLa6 R9j+zuikO3mxF23EnBwRxgD8aAOorldf0q8TToi2v6jIPttoNrR2+ATcRgHiIcjqO2RzkcV1VZev yNFp0TKFJN7aL8yBhg3EYPB788HqDyORUVEnF3OrB1JQrR5bbrdJ9fNOxNZ2FzazF5tWvLxSuPLn SEKD6/JGpz+OOavUUVSVjnnNzd3+SX5BRRUN01wlu7WkUUs4xtSWQxqeecsFYjjPY0xJXdga6hS8 jtGfE8sbyIuDyqlQxz04Lr+dTVys8+u/8JTYE6bpwl+xXO1RfvtI3wZJPk8HpxjnJ5GOeis3vXhJ vreCCXdwsE5lUj1yUXnrxj8aiM7to6K2HdOEZXWq7p9Wuj8jj/i/YXmp/C3WbOwtJ7u6k8jZDBGZ HbE8ZOFHJwAT+FdxXL/ETxJeeEfAmpa5YRwSXVr5WxJ1JQ7pUQ5AIPRj3rqKs5gooooAKKKKAI55 4raCSeeVIoYlLySSMFVFAySSeAAO9ea/FTxP4f1H4bata2OuaZc3Mnk7IYLuN3bEyE4AOTwCfwqj 8c/EmraJYaZY6dd+TbalFcw3aeWjeYmEGMsCRw7dMda858N/CDxB4o0C11mxvNMjtrnfsWeWQONr FTkBCOqnvX1WU5XQhSp5hiqvKuZW+Tej+77jCpNtuEUdH8CNa0rR/wC3/wC09TsrLzfs/l/aZ1j3 483ONxGcZH5ivdNP1TT9WgafTb62vIVbY0ltMsihsA4ypIzgjj3r5y1T4I+JdJ0m81Ke+0lobSB5 5FjlkLFUUsQMxgZwPWtn4A6xf/29faJ5/wDxLvs0l35Oxf8AW7ok3bsZ+7xjOPaurOcBhsbGrmGG q8zVrrpokiac3G0Gj0f7Bef8L1/tH7JP9h/4RryPtPlny/M+07tm7puxzjriu4rl/wDhJLz/AIWn /wAIv5cH2H+xP7Q8zafM8zz/AC8ZzjbjtjOe9dRXxZ0hRXMeKdatf+Ec1q18q/8AM+yTx5/s+fZn Yw+/s24/2s475xWta61a3dwkEcV+rtnBl0+eNeBnlmQAfiaj2kb2udLwlVU1U5X16PpbX8TRoooq zmPkfxw9pZ+O9UudMvr37Ymp3EkhaEQ+TIJSR5bq7FsHPOFPAOOeKP8Awmnir/oZtZ/8D5f/AIqv YPG3wRl1bVn1LQL5Fmu55p7tb+UhQzsGAj2Rk4yW6n0968Y8SeH7vwvr91o19JDJc22ze0DEodyh hgkA9GHav1bLMZgsbShCLUpJbNK6tp2OGcZRdyDUda1XWPL/ALT1O9vfKz5f2mdpNmcZxuJxnA/I V9B6Klon7Od+tjNNNbDStQ2STwiJzzNnKhmA5z/Ef6Vwf/CgfFX/AEENG/7/AEv/AMbr1jV/D9p4 X+DuuaNYyTSW1tpV7sadgXO5JGOSAB1Y9q+e4lzDB18LCjhpp2ley22f+f5mtGElJtlT4Jf8kh0L /t4/9KJK9Arz/wCCX/JIdC/7eP8A0okrp/EulS6xpsdvDDBKyzB9s5j24wR/HFKM8/3QffsfiZOy ujtpQU5qMnZPqWIbqZ/Ed7aM+YIrS3kRcDhmeYMc9eQi/lWjXl0Xg28bXbu3+xaduS2gcqTb7QGa Ucf6HjPynooPAyTwF9A0KxfTdGt7SSOKN492Vi27RlieNscY79lH49TlSnKWjR3Y/C0qKUoTT20X pvv/AFc0aKKK2PNPP/jF4gu9A8CSfZY4X/tCU2EvmqTtjkikyVwR83AxnI9q8O+F/iC70Dx3p/2W OF/7QljsJfNUnbHJKmSuCPm4GM5HtX1NqGl6fq0CwalY215Crb1juYVkUNgjOGBGcE8+9UYPCPhq 2njng8PaTFNEweOSOyjVkYHIIIXIIPevosvzjDYbBTw06d3K93+X3GM6blLmTNmuH8T2F5cfFLwF eQ2k8lra/wBofaJkjJSLdAoXcw4XJ4GetdxXL654kvNM8d+FNDhjga11f7Z9od1JdfKiDrtIOBkn nIP4V86bFf4pf2x/wrjVv7A+3f2n+58n7Bv87/XJu27Pm+7uzjtmvm0+HPiNfn7Td+H9du53+9Nd C48xscDOWB4AA+gFfYVcbrvhW61LWbi7jtLCRJNuGlMG44UDndaSHt3Y/h0GVZPl0Vz0MtlFVXzT 5dN9O67nzi/hzx15rXuneH9W8vd5tvc24nzjqrphuvQjAr6Q+Fv9sf8ACuNJ/t/7d/af77zvt+/z v9c+3dv+b7u3Ge2KxvC3hW6+x6LqH2Sw8vy4J9+YN+MK2f8Aj03Z/wCB5/2s816TUYdPl2sb5zKL r6T5t+2mvkFFFFdB5Byuv6/Zy6dEqw6iCL20b5tNuFGBcRk8lOvHA6k8Dk1uWerW1/MYoY7xWC7s z2U0K4+rqBnnp1o1azkv7OOGJlDLc28xLHjEcyOfxwpx71erNKXNdnXOdF0VGKd7vr5LyCuH+EFh eaZ8LdGs7+0ntLqPz98M8ZjdczyEZU8jIIP413Fcv8O/El54u8Cabrl/HBHdXXm70gUhBtldBgEk 9FHetDkOL8a/AnTfFGsw3ul3tpoUCW6xNbWumrtdgzHedrKMkMB0/hHNc3/wzL/1N3/lN/8AttfQ FFAHhek/s4w6drNje3HiOO8gt7iOWS2k00bZlVgShzIRggY6Hr0Ne4QQQ2tvFb28UcMESBI441Cq igYAAHAAHGKkooAKztZh1KazRdLm8qcSAs3mrH8uDxlopB1x/CPr2OjRSaurF058klK1/XY4GGy8 UnxHeqt7+/Fpbl2+2Rcrvm2jP2THUN/COvU5wvZ6ZHeRadEl/J5l0M723h88nHIRAeMfwj8epeln GmpT3wZvNmhjhYE/KAhcjHv+8P6VYqKdPl6nVi8Uq1kopbbKz0VvuOH+JNheX3/CI/Y7Se48jxLZ zzeTGX8uNd+52x0UZGSeBXYX9jb6np1zYXkfmWt1E8MybiNyMCGGRyMgnpXP+NPEl54c/wCEe+xx wP8A2lrdtp83nKTtjk3biuCMNwME5HtXUVocR5//AMKS+Hn/AEL3/k7cf/HKP+FJfDz/AKF7/wAn bj/45XoFFAGP4b8LaN4R06Sw0Oz+yWskpmZPNeTLkAE5ck9FH5VsUUUAFcx4p026/wCEc1qf+27/ AMv7JO/kbINmNjHbny92O3XPvnmunpksUc8LwzRrJFIpV0cZVgeCCD1FTOPMrG+HrOjUU7bNdE/z KNrpt1b3CSya3f3KLnMUqQBW477Ywffg9q0aKKaVjOc3N3f4JL8jh/htYXlj/wAJd9stJ7fz/Et5 PD50ZTzI22bXXPVTg4I4NdxXL+C/El54j/4SH7ZHAn9m63c6fD5Kkbo49u0tknLcnJGB7V1FMgKK KKACiiigAooooAK4f4v2F5qfwt1mzsLSe7upPI2QwRmR2xPGThRycAE/hXcVy/xE8SXnhHwJqWuW EcEl1a+VsSdSUO6VEOQCD0Y96AOoooooAKKKKACiiigAooooAK4fwxYXlv8AFLx7eTWk8drdf2f9 nmeMhJdsDBtrHhsHg46V3FcvofiS81Px34r0OaOBbXSPsf2d0Uh282Iu24k4OCOMAfjQB1FFFFAB RRRQAUUUUAFFFFAGH40gmuvAviG3t4pJp5dMuUjjjUszsYmAAA5JJ4xR4LgmtfAvh63uIpIZ4tMt kkjkUqyMIlBBB5BB4xVjxLqU2jeFdX1S3WNp7KymuI1kBKlkQsAcEHGR6ijw1qU2s+FdI1S4WNZ7 2yhuJFjBChnQMQMknGT6mgDUooooAKKKKACiiigAooooA8f8Q/8AJ0PhP/sFSf8AoN1XsFeP+If+ TofCf/YKk/8AQbqvYKACiiigAooooAKKKKACiiigDg/gzBNa/CnR7e4ikhnie5SSORSrIwuJAQQe QQeMV3lcX8KNSm1n4dWGqXCxrPe3F3cSLGCFDPdSsQMknGT6mu0oAKKKKACiiigAooooAKKKKACi iigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKK KACvlBtM/wCE6/aJvNN1abfDJqs8cny43QwbsR/KRjKRBNwORnPJ6/V9fMnxW0LUvh78TYPGOjxS LaXVwLpJPm2LcEkyROQ2SHwzEfKCHZRwpoA+k7Gws9Ms47OwtILS1jzshgjEaLkknCjgZJJ/GrFe V6J8f/Beo2+7UZLvSZ1RCyTQNKrMR8wRowxIBHVgucjjrg1v4/8AgvTrfdp0l3q07I5VIYGiVWA+ UO0gUgEnqobGDx0yAeWXdmnhD9pW3tdGP2eH+1bcKoRcIlwE8xFGMBcSsowOBjnIzX1PXzJ8KdC1 L4hfE2fxjrEUjWlrcG6eT5tjXAIMcSEtkBMqwHzABFU8MK+m6ACiiigArL8Sa3D4c8NalrM/llLO 3eUI8gjEjAfKm49CzYUcHkjg1qV538bE1K6+G9zp2l6Td6jPfXEUTLaxs7RKreZvKqCSMxhe33hz 2IBz8Hxm8VXVvFcW/wAK9ZmglQPHJG8rK6kZBBEGCCOc13nhHxXea94eu9W1zQ5/Dn2aV1aK+cr+ 7VFYyEuqYXkjOMfKea87ttc+LmjaDawaP4MtH0mxsoo4GuwPtUkccYG5olmyHbGfLAJBO35iMm54 m+JFn4s+Bevato032e8WKO3vLV8M8HmyKjqcjlWVmAYDn2YEAAH+N1/f3l0fDHgPVdc0yGUxJfQm QCQgAn5RE23rkAnOCCQM4HceBfHWl+PNDF/YHyriPC3Vo7Ze3c9j6qcHDd8diCAfDixt9P8Ahr4c htY/LjbT4ZiNxOXkUSOefVmY+2eOK4fwd/xK/wBonxrpNn+6sbm0S9li+9umPlNuyckczSnAOPm6 cDAB6Bef8lD0b/sFX/8A6NtK6CuT17VtN0bx1olxqmoWljA2mXyLJdTLEpbzbQ4BYgZwCcexq5/w nfg//oa9D/8ABjD/APFUAdBRWXpviXQdZuGt9L1vTb6dULtHa3SSsFyBkhSTjJAz7iq8/jTwra3E tvceJdGhnicpJHJfxKyMDgggtkEHjFAG5RWfa67o99p0+o2eq2NxYwbvOuYbhHjj2jc25gcDAIJz 0FZ//Cd+D/8Aoa9D/wDBjD/8VQB0FFZ91ruj2OnQajearY29jPt8m5muESOTcNy7WJwcgEjHUVTg 8aeFbq4it7fxLo008rhI447+JmdicAABskk8YoA3Ky/Eumzaz4V1fS7do1nvbKa3jaQkKGdCoJwC cZPoaNS8S6Do1wtvqmt6bYzsgdY7q6SJiuSMgMQcZBGfY1h+IvFmj33g3xH/AGH4gsbi+g0q5nX7 Deo8ke2M4cbDkYJHPY4oA3PDWmzaN4V0jS7ho2nsrKG3kaMkqWRApIyAcZHoK1K4fwn478N/8Ibo f9o+K9K+3f2fb/aPtGox+Z5nlru35bO7Oc55zXUWuu6PfadPqNnqtjcWMG7zrmG4R449o3NuYHAw CCc9BQBoUVz/APwnfg//AKGvQ/8AwYw//FVoXWu6PY6dBqN5qtjb2M+3ybma4RI5Nw3LtYnByASM dRQBoUVhweNPCt1cRW9v4l0aaeVwkccd/EzOxOAAA2SSeMVY1LxLoOjXC2+qa3ptjOyB1jurpImK 5IyAxBxkEZ9jQBqUVl6b4l0HWbhrfS9b02+nVC7R2t0krBcgZIUk4yQM+4qvP408K2txLb3HiXRo Z4nKSRyX8SsjA4IILZBB4xQBuVy//CN3n/C0/wDhKPMg+w/2J/Z/l7j5nmef5mcYxtx3znPati11 3R77Tp9Rs9Vsbixg3edcw3CPHHtG5tzA4GAQTnoK8/8A+E70f/hcn/I12P8AYn/CP/8AQRT7N9o+ 0f723zNn449qAPUKKz7rXdHsdOg1G81Wxt7Gfb5NzNcIkcm4bl2sTg5AJGOoqnB408K3VxFb2/iX Rpp5XCRxx38TM7E4AADZJJ4xQBuUVl6l4l0HRrhbfVNb02xnZA6x3V0kTFckZAYg4yCM+xo03xLo Os3DW+l63pt9OqF2jtbpJWC5AyQpJxkgZ9xQBqUVhz+NPCtrcS29x4l0aGeJykkcl/ErIwOCCC2Q QeMVctdd0e+06fUbPVbG4sYN3nXMNwjxx7RubcwOBgEE56CgDQorn/8AhO/B/wD0Neh/+DGH/wCK rQutd0ex06DUbzVbG3sZ9vk3M1wiRybhuXaxODkAkY6igDQrl/h34bvPCPgTTdDv5IJLq183e8DE od0ruMEgHow7Vcg8aeFbq4it7fxLo008rhI447+JmdicAABskk8Yrj/hj4002H4a6I/iPxLaJqEy TOW1G/USuvnyKD87ZI+XAPtjtQB6ZRWXpviXQdZuGt9L1vTb6dULtHa3SSsFyBkhSTjJAz7iq8/j Twra3EtvceJdGhnicpJHJfxKyMDgggtkEHjFAG5RWfa67o99p0+o2eq2NxYwbvOuYbhHjj2jc25g cDAIJz0FZ/8Awnfg/wD6GvQ//BjD/wDFUAdBRWfda7o9jp0Go3mq2NvYz7fJuZrhEjk3Dcu1icHI BIx1FU4PGnhW6uIre38S6NNPK4SOOO/iZnYnAAAbJJPGKANyisvUvEug6NcLb6prem2M7IHWO6uk iYrkjIDEHGQRn2NGm+JdB1m4a30vW9Nvp1Qu0drdJKwXIGSFJOMkDPuKAMvXPDd5qfjvwprkMkC2 ukfbPtCOxDt5sQRdoAwcEc5I/GuorzPxT40021+J/hC3j8S2kNnE9+mpxrfqsaMIgEEw3YBDZADd 845rvLXXdHvtOn1Gz1WxuLGDd51zDcI8ce0bm3MDgYBBOegoAde6LpWozCa+0yzupVXaHngV2A64 yR05P51jaL4W0b7BL9q0Gw8z7Xc482zTOzz32dR027ce2McVP/wnfg//AKGvQ/8AwYw//FVoXWu6 PY6dBqN5qtjb2M+3ybma4RI5Nw3LtYnByASMdRUOnFu7R0RxVaFP2cZO2nV9L/5mhRWHB408K3Vx Fb2/iXRpp5XCRxx38TM7E4AADZJJ4xVjUvEug6NcLb6prem2M7IHWO6ukiYrkjIDEHGQRn2NWc5q UVl6b4l0HWbhrfS9b02+nVC7R2t0krBcgZIUk4yQM+4qvP408K2txLb3HiXRoZ4nKSRyX8SsjA4I ILZBB4xQBuUVn2uu6PfadPqNnqtjcWMG7zrmG4R449o3NuYHAwCCc9BWf/wnfg//AKGvQ/8AwYw/ /FUAef8Awg/5KH8Tv+wqP/RtxXsFeH/CrXdHsfGXxH1G81Wxt7GfVU8m5muESOTdJcsu1icHIBIx 1FeqQeNPCt1cRW9v4l0aaeVwkccd/EzOxOAAA2SSeMUAbLxRyNGzxqzRtuQsMlTgjI9DgkfQmn1m aj4j0PSJ/I1PWdOsptgk8u5ukjbYTgNhiDjIxn1pNN8S6DrNw1vpet6bfTqhdo7W6SVguQMkKScZ IGfcUDd+pqUVhz+NPCtrcS29x4l0aGeJykkcl/ErIwOCCC2QQeMVctdd0e+06fUbPVbG4sYN3nXM Nwjxx7RubcwOBgEE56CgRoVXS8jfUp7EK3mwwxzMSPlIcuBj3/dn9K5+98ceHHhAsfGXhuCXdy09 1HKpHpgSrz05z+FZr6tLY6xc3934n8P21tPZWnl3c0BWGUM05QITOATgMc5OR0AxkxKTTSSOmjRh OEpSklZefdLojuq5fxp4bvPEf/CPfY5IE/s3W7bUJvOYjdHHu3BcA5bkYBwPep9O8ZeHrjyLVvFe g3d9K4RVtrqNfMYnChU3sc8gYycn8q5z4oeJYdGuPCtumtx2M7a7aPdRrdCJja5cOXGQfKyMEn5e Oas52rOx6JRWXpviXQdZuGt9L1vTb6dULtHa3SSsFyBkhSTjJAz7iq8/jTwra3EtvceJdGhnicpJ HJfxKyMDgggtkEHjFAjcorPtdd0e+06fUbPVbG4sYN3nXMNwjxx7RubcwOBgEE56Cs//AITvwf8A 9DXof/gxh/8AiqAOgorPutd0ex06DUbzVbG3sZ9vk3M1wiRybhuXaxODkAkY6iqcHjTwrdXEVvb+ JdGmnlcJHHHfxMzsTgAANkknjFAG5RWXqXiXQdGuFt9U1vTbGdkDrHdXSRMVyRkBiDjIIz7Gqvhv xVpfiCytUh1TTptSNsk1za21wrPEcDdlASygMcc9OlK+tilBuLl0X63/AMjerl9D8N3mmeO/FeuT SQNa6v8AY/s6IxLr5URRtwIwMk8YJ/Crk/jTwra3EtvceJdGhnicpJHJfxKyMDgggtkEHjFcv4R8 Sw6h4+8fXA1uO50W0SxeCT7UHt4V8ljIVOdqjKksR3HPSmSeiVzGteFtG+wRfZdBsPM+122fKs0z s89N/QdNu7PtnPFT/wDCd+D/APoa9D/8GMP/AMVWhda7o9jp0Go3mq2NvYz7fJuZrhEjk3Dcu1ic HIBIx1FTKKkrM2oV50ZqUHbb52HWei6Vp0xmsdMs7WVl2l4IFRiOuMgdOB+VXqw4PGnhW6uIre38 S6NNPK4SOOO/iZnYnAAAbJJPGKsal4l0HRrhbfVNb02xnZA6x3V0kTFckZAYg4yCM+xppJbGc5ym 7yd2alVNT1CLStOlvZhmOPGR5iJ1IH3nZVHXuR+dVtN8S6DrNw1vpet6bfTqhdo7W6SVguQMkKSc ZIGfcVUvfFugrJNZQeJ9Dt9QRyhSe5RyjKfmDIHU5GCMZGD9MUS2ZVJJzimr6r+tNTAm8c6c3iOy uRF8kdpcRkfbrPqzwkc+dgfdPBIJ7A4OOt0bWINbs3ubddqLIYyPOik5AB6xuw79M59ulclNrufE dlL/AMJZ4cO20uF80RfIuXh+U/v+pxkcj7rcHtsweMdBtEMeqeLvDzTk5Ux3CQjb/utIxPOec/hW FKTcnd/kerj6VONGLjC2n97u+6SGfETw3eeLvAmpaHYSQR3V15Wx52IQbZUc5IBPRT2rqK8/+Lmu /YfhRf6jpmq/Z5p/s/2O5trjY0m6RG/dsp5ygY8dVz2rpIPGnhW6uIre38S6NNPK4SOOO/iZnYnA AAbJJPGK6DxjcorL1LxLoOjXC2+qa3ptjOyB1jurpImK5IyAxBxkEZ9jRpviXQdZuGt9L1vTb6dU LtHa3SSsFyBkhSTjJAz7igDUorDn8aeFbW4lt7jxLo0M8TlJI5L+JWRgcEEFsgg8Yq5a67o99p0+ o2eq2NxYwbvOuYbhHjj2jc25gcDAIJz0FAHlPx+tILiDRJJdRtrV4lumSKZZC0xxH8q7EYA8AfMV HI5648q0P4h+K/DmmjTtK1d4LRWLrE0UcgUnrjepIGecDjJJ6k13Xx113R9b/sD+ydVsb/yftHmf ZLhJdmfKxnaTjOD19DWZ4K+LNp4M0CLTofC8M1yM+feJcCJ5/mZl3YjJO0NgZJr9FyuMnk9Plpe1 1fuvlSXvS11X+b1OSf8AEetjCvfip401GwuLG61nzLa5iaGVPssI3IwIIyEyOCeldP8AACNT401G QzIHXT2UREHcwMkeWHGMDAByQfmGAecT+IPjjFr/AIe1DSZvCyBLuBog73gcIxHyvtMfJU4YdOQO RWT8E9W03RvGd5capqFpYwNp7osl1MsSlvMjOAWIGcAnHsa0xUZLK6/NQVHTZOLv9yFH41rc9x/4 Ru8/4Wn/AMJR5kH2H+xP7P8AL3HzPM8/zM4xjbjvnOe1dRXnem+JYdZ+NjW+l63HfaWvhwu0drdC WATfaQMkKSu/aQM9cEV1E/jTwra3EtvceJdGhnicpJHJfxKyMDgggtkEHjFfmx2FTxTqV1/wjmtQ f2Jf+X9knTz98GzGxhux5m7Hfpn2zxWta6ldXFwkUmiX9sjZzLK8BVeO+2Qn24HevH/FHjfTXvNV sIr++n87zFjaBbiWBw4O3DrdGMrgj+DA7qMFa0vCvj7R7nXovP1W7toI0Z5JNR8+3iAxgfNNdspO SMDax+mMjkVV+0t/X5H0VTARWE5tNLvZ9l/e/rsev0Vn3Wu6PY6dBqN5qtjb2M+3ybma4RI5Nw3L tYnByASMdRVODxp4VuriK3t/EujTTyuEjjjv4mZ2JwAAGySTxius+dNyvKvGHxm/4RPxVe6J/YH2 r7Ns/ffbNm7civ8Ad2HH3sde1eg6l4l0HRrhbfVNb02xnZA6x3V0kTFckZAYg4yCM+xr5b+JGsWG v+P9T1PTJ/Ps5/K8uTYy7tsSKeGAPUHtX0XDeX0cbiZRrw5oqPmtbq2qt0uY1puK0Priuf8AHf8A yTzxL/2Crr/0U1VrH4k+C9QhaWLxNpsahtuLqYW7ZwDwsm0kc9cY6+hpninVtN1n4aeJ7jS9QtL6 BdMu0aS1mWVQ3kscEqSM4IOPcV4FSnOnJwmrNdHubJ32Mv4Jf8kh0L/t4/8ASiStvx5K9r4Uur1d OtL4WavcNHd26zRqERiWILrj6jcQCcKa4z4QeLPDemfC3RrO/wDEGlWl1H5++Ge9jjdczyEZUnIy CD+NegazqHh+Tw851fUbGPSNRiMPmzXSxxzJIh4V8jOVyRg9ORWclzKzNKVR0pqcd0fOQ+KcSSNe /wDCN+FSJgIvLNo/lrsycqNv3j5nPsq+lfRHgy5N74N0m8NpbWn2m3WcQ20QjjUP8w2qCeCDnnBO ckKSQPk74a2Oka5450XRtdijfT5ppg6vMYw7NEdi5BBB3qoGDySBX1k+r+GfCdvaaPcavpumpBbo kFvdXiowiUbVxvbJHy4z7GsqVJQ1O3HY+eJSi7W0772NyisvTfEug6zcNb6Xrem306oXaO1uklYL kDJCknGSBn3FV5/GnhW1uJbe48S6NDPE5SSOS/iVkYHBBBbIIPGK2PONyis+113R77Tp9Rs9Vsbi xg3edcw3CPHHtG5tzA4GAQTnoKxbX4geGpLm+W48SaJHFHOFt2N9GPMj8tCWyW5+cuuRx8uOoNJu xUYOSbXT/O36nVVy+ueG7zU/HfhTXIZIFtdI+2faEdiHbzYgi7QBg4I5yR+NbF1ruj2OnQajearY 29jPt8m5muESOTcNy7WJwcgEjHUVweteNNNuvif4Gt9K8S2k1nK96l3Ha36tG7GJREJArYJLcKD3 6c0yT0yisvUvEug6NcLb6prem2M7IHWO6ukiYrkjIDEHGQRn2NGm+JdB1m4a30vW9Nvp1Qu0drdJ KwXIGSFJOMkDPuKALmn2cenaba2MLM0VtCkKFzliFAAzjvxVisOfxp4VtbiW3uPEujQzxOUkjkv4 lZGBwQQWyCDxirlrruj32nT6jZ6rY3FjBu865huEeOPaNzbmBwMAgnPQUJW0HKTk3J7s0KK5/wD4 Tvwf/wBDXof/AIMYf/iq0LrXdHsdOg1G81Wxt7Gfb5NzNcIkcm4bl2sTg5AJGOooEaFFYcHjTwrd XEVvb+JdGmnlcJHHHfxMzsTgAANkknjFWNS8S6Do1wtvqmt6bYzsgdY7q6SJiuSMgMQcZBGfY0Aa lcv8O/Dd54R8Cabod/JBJdWvm73gYlDuldxgkA9GHatTTfEug6zcNb6Xrem306oXaO1uklYLkDJC knGSBn3FcH8LfHej/wDCuNJ/t/xXY/2n++877fqKed/rn27t7bvu7cZ7YoA9QorPtdd0e+06fUbP VbG4sYN3nXMNwjxx7RubcwOBgEE56Cs//hO/B/8A0Neh/wDgxh/+KoA6Cis+613R7HToNRvNVsbe xn2+TczXCJHJuG5drE4OQCRjqKpweNPCt1cRW9v4l0aaeVwkccd/EzOxOAAA2SSeMUAblFZepeJd B0a4W31TW9NsZ2QOsd1dJExXJGQGIOMgjPsaNN8S6DrNw1vpet6bfTqhdo7W6SVguQMkKScZIGfc UAalFYc/jTwra3EtvceJdGhnicpJHJfxKyMDgggtkEHjFXLXXdHvtOn1Gz1WxuLGDd51zDcI8ce0 bm3MDgYBBOegoAx/Gnhu88R/8I99jkgT+zdbttQm85iN0ce7cFwDluRgHA966ivL/H/jvR/+KX/s jxXY/wDIwWn2z7JqKf8AHv8ANv8AM2t/q+mc8dM16Bda7o9jp0Go3mq2NvYz7fJuZrhEjk3Dcu1i cHIBIx1FAGhRWHB408K3VxFb2/iXRpp5XCRxx38TM7E4AADZJJ4xVjUvEug6NcLb6prem2M7IHWO 6ukiYrkjIDEHGQRn2NAGpRWXpviXQdZuGt9L1vTb6dULtHa3SSsFyBkhSTjJAz7iq8/jTwra3Etv ceJdGhnicpJHJfxKyMDgggtkEHjFAG5RWfa67o99p0+o2eq2NxYwbvOuYbhHjj2jc25gcDAIJz0F Z/8Awnfg/wD6GvQ//BjD/wDFUAdBRWfda7o9jp0Go3mq2NvYz7fJuZrhEjk3Dcu1icHIBIx1FU4P GnhW6uIre38S6NNPK4SOOO/iZnYnAAAbJJPGKAKfgvw3eeHP+Eh+2SQP/aWt3OoQ+SxO2OTbtDZA w3ByBke9dRXmfgjxpptrceLLfxB4ltIZ4vEd4kEd/fqrJCCoUKHbIQHcABx1ruNN8S6DrNw1vpet 6bfTqhdo7W6SVguQMkKScZIGfcUAalFYc/jTwra3EtvceJdGhnicpJHJfxKyMDgggtkEHjFXLXXd HvtOn1Gz1WxuLGDd51zDcI8ce0bm3MDgYBBOegoA0KK5/wD4Tvwf/wBDXof/AIMYf/iq0LrXdHsd Og1G81Wxt7Gfb5NzNcIkcm4bl2sTg5AJGOooA0KKw4PGnhW6uIre38S6NNPK4SOOO/iZnYnAAAbJ JPGKsal4l0HRrhbfVNb02xnZA6x3V0kTFckZAYg4yCM+xoA1K5f4ieG7zxd4E1LQ7CSCO6uvK2PO xCDbKjnJAJ6Ke1amm+JdB1m4a30vW9Nvp1Qu0drdJKwXIGSFJOMkDPuK4f4s+NNNtfAOtW+k+JbS HWonjRY7S/VbhGEyBwArbgQNwI9M5oA9MorPtdd0e+06fUbPVbG4sYN3nXMNwjxx7RubcwOBgEE5 6Cs//hO/B/8A0Neh/wDgxh/+KoA6Cis+613R7HToNRvNVsbexn2+TczXCJHJuG5drE4OQCRjqKpw eNPCt1cRW9v4l0aaeVwkccd/EzOxOAAA2SSeMUAblFZepeJdB0a4W31TW9NsZ2QOsd1dJExXJGQG IOMgjPsaNN8S6DrNw1vpet6bfTqhdo7W6SVguQMkKScZIGfcUAalFYc/jTwra3EtvceJdGhnicpJ HJfxKyMDgggtkEHjFXLXXdHvtOn1Gz1WxuLGDd51zDcI8ce0bm3MDgYBBOegoA0K5fQ/Dd5pnjvx Xrk0kDWur/Y/s6IxLr5URRtwIwMk8YJ/CrH/AAnfg/8A6GvQ/wDwYw//ABVcvoXiyzg+IXjaXUvE EEekL/Zv2J7m9AgHmW7P+7LHb82N3y9cZoA9IorDg8aeFbq4it7fxLo008rhI447+JmdicAABskk 8YqxqXiXQdGuFt9U1vTbGdkDrHdXSRMVyRkBiDjIIz7GgDUorL03xLoOs3DW+l63pt9OqF2jtbpJ WC5AyQpJxkgZ9xVefxp4VtbiW3uPEujQzxOUkjkv4lZGBwQQWyCDxigDcorPtdd0e+06fUbPVbG4 sYN3nXMNwjxx7RubcwOBgEE56Cs//hO/B/8A0Neh/wDgxh/+KoA6Cis+613R7HToNRvNVsbexn2+ TczXCJHJuG5drE4OQCRjqKpweNPCt1cRW9v4l0aaeVwkccd/EzOxOAAA2SSeMUAWPEumzaz4V1fS 7do1nvbKa3jaQkKGdCoJwCcZPoaPDWmzaN4V0jS7ho2nsrKG3kaMkqWRApIyAcZHoKx/H3iXTdG8 K61bvrdpY6o2mTvaxtdLFOW2MEKDIbO4YBHccUeAfEum6z4V0W3TW7S+1RdMge6jW6WWcNsUOXGS 2dxwSe55oA6yisOfxp4VtbiW3uPEujQzxOUkjkv4lZGBwQQWyCDxirlrruj32nT6jZ6rY3FjBu86 5huEeOPaNzbmBwMAgnPQUAaFFc//AMJ34P8A+hr0P/wYw/8AxVaF1ruj2OnQajearY29jPt8m5mu ESOTcNy7WJwcgEjHUUAaFFYcHjTwrdXEVvb+JdGmnlcJHHHfxMzsTgAANkknjFWNS8S6Do1wtvqm t6bYzsgdY7q6SJiuSMgMQcZBGfY0AalFZem+JdB1m4a30vW9Nvp1Qu0drdJKwXIGSFJOMkDPuKrz +NPCtrcS29x4l0aGeJykkcl/ErIwOCCC2QQeMUAed+If+TofCf8A2CpP/QbqvYK8P1fXdHvv2kPD Oo2eq2NxYwaVL51zDcI8ce2O5ZtzA4GAQTnoK9Q/4Tvwf/0Neh/+DGH/AOKoA6Cis+613R7HToNR vNVsbexn2+TczXCJHJuG5drE4OQCRjqKpweNPCt1cRW9v4l0aaeVwkccd/EzOxOAAA2SSeMUAblF ZepeJdB0a4W31TW9NsZ2QOsd1dJExXJGQGIOMgjPsaNN8S6DrNw1vpet6bfTqhdo7W6SVguQMkKS cZIGfcUAalFYc/jTwra3EtvceJdGhnicpJHJfxKyMDgggtkEHjFXLXXdHvtOn1Gz1WxuLGDd51zD cI8ce0bm3MDgYBBOegoA0KK5/wD4Tvwf/wBDXof/AIMYf/iqP+E78H/9DXof/gxh/wDiqAMv4Uab No3w6sNLuGjaeyuLu3kaMkqWS6lUkZAOMj0FdpXB/Bmea6+FOj3FxLJNPK9y8kkjFmdjcSEkk8kk 85rvKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigA ooooAKKKKACiiigAooooAKKKKACiiigArm77xH4Q1HVLvwtql9pst2jxJLp98FAkZ8NGFVxiQ/dO Fzg46HFdJXjfxI+CE3i/xBeeINL1iOC8uEjDWt1GfLLKAmRIvKjao42tyDyAeADQ1L9n3wRfXCy2 41LT0CBTFa3IZScn5j5iuc84644HHXJpv7PvgixuGluBqWoIUKiK6uQqg5HzDy1Q54x1xyeOmPKH 034ufDFHFq2pJp8KShWtyLu1SNW3M+whhGD97LKpwW/2q6jQP2k5g6x+I9DjZC5Jn05ipVdvA8ty dx3dTvHB6ccgHvdjYWemWcdnYWkFpax52QwRiNFySThRwMkk/jViub0Dx/4U8UOsWj65aTzs5RYG Jilchdx2xuAxGOcgY4Poa6SgAooooAK5fx/4suPBPhd9cg0r+0o4ZUSdPtAh8tGOA+SDn5iowB/F noDXUVHPBDdW8tvcRRzQSoUkjkUMrqRggg8EEcYoA5Ox+KXgq90OPVj4hsbeNojK1vPMqzpjOVMW dxYYIwAc9sgjPlHh/wAO3ni/wJ8TdatYp4rXXbs3OnxmEtNL5MrzbQo4O4sEBUn5g3XHPp//AAp/ wD/aP27/AIRyDzvN87b5snl7s5x5e7Ztz/DjbjjGOK7SCCG1t4re3ijhgiQJHHGoVUUDAAA4AA4x QB5v8NPiN4Zufh9o8N7rOm6dd2dulnLb3V2sbAxgKGG7bkMoDcZAyRkkGsf4YzL4t+LPjHxtaiRN PKJYW5MbbZx8g3hiBg7YUYrjI80Z6c9hqvwm8D61qlxqV/oMb3dy++V0nljDN3O1GAyepOOTknkm uo0rSrHQ9Lt9M0y2jtrO3TZFEnRR/MknJJPJJJOSaAMu8/5KHo3/AGCr/wD9G2ldBXP3n/JQ9G/7 BV//AOjbSugoAKKKKACiiigAooryr/hf3hX/AKB+s/8AfmL/AOOV14XA4jFX9hBytvbzJlJR3PVa z9dtbO+8PanZ6jcfZ7Ge0liuJt4Ty42Qhm3HgYBJyeBWf4Q8X6f410mXUtNhuYoYpzAy3Kqrbgqt n5WIxhh3o8d/8k88S/8AYKuv/RTVhVpTozdOorNboaaaujQ0K1s7Hw9plnp1x9osYLSKK3m3h/Mj VAFbcODkAHI4NaFc/wCBP+SeeGv+wVa/+ilroKzGFFFFABRRRQAUUVDbXUN3E0kD70WR4ycEfMjF GHPoykfhQOztcmrn/wCytH/4WH/a/wBv/wCJ3/ZX2X7F5yf8e/m7vM2Y3ff43Zx2610Fef8A/Nwv /cqf+3dAj0CiiigAooooAKKKKACiiigArn/BOlaPonhCx07QL/7fpkPmeTc+cku/MjM3zIApwxYc eldBXn/wS/5JDoX/AG8f+lElAHoFFFFABRRRQAUUUUAFFFFAHP6vpWj3fi/w5qN7f+Tqdj9p+wW3 nIv2jfGFk+Ujc21cH5cY710Fef8Ai3/kr3w6/wC4n/6TrXoFABRRRQAUUUUAFFFQ3V1DZWc93cPs ggjaSRsE7VUZJwOegoGk27ImooooEeP/AAg/5KH8Tv8AsKj/ANG3Feuyu0cLusbSsqkiNCNzH0GS Bk+5AryL4Qf8lD+J3/YVH/o24r1q6O2znbzJY8Rsd8Kb3Xjqq4OT6DBz6GhjirtI5vVdVvG1HRCd A1FCt6xCtJb5c/Z5hgYl68k84GAe+Ad+xvJ7vzPO026stuMee0R35z02O3T3x1rjNSus3+kH+2fE bYu2OX0naV/cS8qPsw3Htjngk44yOo0SbzfP/wBO1S6xt/4/7PyNvX7v7pM+/XGB0zzhTleT1/Ls eri6DjRi+VKy7T/mffT7/wDI1qKKK3PJCoVtYUvJLtUxPLGkbtk8qpYqMdOC7fnVC88T+H9Ountb 7XNMtrmPG+Ge7jR1yMjIJyOCD+NZcXjfQDrl0j+JNJ+xC2hMTG8iCmQtLvAbPJwI8jPGR686+wqu z5Hrtoy4XalZ7LX71+tjqa5/xVpWj6p/Yn9r3/2P7LqsF1Z/vkj864Xdsj+YHdnJ+UcnHFW7PxP4 f1G6S1sdc0y5uZM7IYLuN3bAycAHJ4BP4VynxT/5kr/sa7H/ANnqZ05wdpq3qQnc9Aooqjey6qkw FjZWc8W3lp7tomB9MCNuOnOfwrNuxUIObsvzS/MsW11DdxNJA+9FkeMnBHzIxRhz6MpH4VNXK6BP ro06XytN05l+23eS1+6nP2iTIx5J4ByAe45wOldVUwlzK5riaHsajj0u+qe3oFFFQXl7aadavdX1 1DbW0eN808gRFycDJPA5IH41ok27IwKt1otrd3DzyS36u2MiLUJ414GOFVwB+ArJ8LaLa/8ACOaL debf+Z9kgkx/aE+zOxT9zftx/s4x2xisjU/irodjqMttDqWjTxpjEn2yU5yAf4IXXv2Y/geKzPDn xO0m20/SdMnvdJi8qKG3kaS7mVkwApJBg2gj/ex/tY5qXQl7RLkd9ej8vI9aFLFvCtpu2nXpZ+Z6 jXP6RpWj2ni/xHqNlf8AnanffZvt9t5yN9n2RlY/lA3LuXJ+bOe1bNne2mo2qXVjdQ3NtJnZNBIH RsHBwRweQR+FcN4S/wCSvfEX/uGf+k7VTTTszyT0Cobm6htIlknfYjSJGDgn5nYIo49WYD8amrld fn106dF5um6cq/bbTBW/djn7RHgY8kcE4BPYc4PSs5y5Vc6MNQ9tUUel11S39TqqKo2cuqvMRfWV nBFt4aC7aVifTBjXjrzn8KvVSdzGcHB2f5p/kFZPiaXyPD11J5vlY2fP5vl4+cfxebFj/vsfj0Ot XO+LPE2m6Hp0yT61aWN6VV40edUkKl8ZClJCRwRnYeh6dQ+SU01FX9DTDtqtC3dfmeeSannV7Z/7 TziCUbv7R6ZaPjP9ocZx03DOOjYyvofg24+06RK/2jz8TkbvP83Hyrxnz5vy3D6DqfN5PH9u+rW9 1/wlMREcEsZl88fLuaM7c/Yu+zP3T93qvRu48J+NdH1G18qfxJYXF3JceXEj3Sb2yFwqqYoick8Y U89z0GFDDVed+6/u8j381nN4aPMl9/m/JGl420rR9b8IX2na/f8A2DTJvL86585ItmJFZfmcFRlg o59a6CvP/jb/AMkh13/t3/8ASiOvQK3Pmjj/AIpa3qPhz4catq2k3H2e+g8ny5divt3TIp4YEHgk civnD/hdvxD/AOhh/wDJK3/+N19X67a2d94e1Oz1G4+z2M9pLFcTbwnlxshDNuPAwCTk8CvP/hx4 L8B+HPENxeeF/E39qXz2jRPD9vgn2xl0JbbGoI5CjPTn3oA9QooooAgvbODUbC4sbqPzLa5iaGVM kbkYEEZHI4J6V5x4k+H3w58L6BdazfeHppLa22b1gupi53MFGAZAOrDvXp1ef/Ga9tIPhtqVrNdQ x3Nz5XkQvIA8u2aMttB5bA5OOlenlVWv9Zp0ac5RUpK/K2uuu3kRNKzbOc8GeHvhd45+2/2Z4avY fsfl+Z9puJFzv3YxtlP90/pXp3h/w3pPhewex0a0+zW0kpmZPMd8uQATliT0UflXjn7Pd7aQXWuW s11DHc3P2fyIXkAeXaJS20HlsDk46V7xXXn8q1HFzw3tJOCtZOTfRd/O5NKzje2pz/8AZWj/APCw /wC1/t//ABO/7K+y/YvOT/j383d5mzG77/G7OO3Wugrz/wD5uF/7lT/27rc8a+NdN8B6NDqmqQXc 0Etwtuq2qKzBirNk7mUYwh7+leCanhfx28Opovj6x8Rve701aUM0PlY8gQpCn3sndnOegx711HwB 8C/YLGDxp/aPmf2haTW32PyMeXiYDdv3c/6rptH3vbngPjB8R9H+IH9jf2TbX0P2Hz/M+1oi53+X jG1m/uHrjtXUfDv41+G/CPgTTdDv7LVZLq183e8EUZQ7pXcYJkB6MO1K2ty3NuCh2u/vt/kfQ9FU 9J1KHWdGsdUt1kWC9t47iNZAAwV1DAHBIzg+pq5TICvDv+Gdv+pp/wDKf/8Aba9xqGa6ht5beOV9 r3EhjiGCdzBWfHt8qsefSu7B5nicDzfV58vNa+ie226fcTpqfS5zfgDwZ/wg2gz6Z9v+2+bctceZ 5Pl4yqrjG4/3eue9WvHf/JPPEv8A2Crr/wBFNXQVz/jv/knniX/sFXX/AKKauavXqV6jq1HeT3BJ JWRxfw31KbRv2d4tUt1jaeysr64jWQEqWSSZgDgg4yPUV82eKfEl54u8R3euX8cEd1dbN6QKQg2o qDAJJ6KO9fR/w+sbjU/2bxYWcfmXV1p9/DCm4Dc7STBRk8DJI6180a3omo+HNYn0nVrf7PfQbfMi 3q+3coYcqSDwQeDWQzPrY8LeJLzwj4jtNcsI4JLq137EnUlDuRkOQCD0Y96x60NE0TUfEesQaTpN v9ovp93lxb1TdtUseWIA4BPJoA+76KKKAOd8UiA/ZPO1210v7+PPnlj8z7vTZNHnHvnr278hYLZ/ bNTz4y06MfaVwzXtwBKPJj+YYuxkdVySxypGcAAd3rdvrE/kf2VceVjd5n79I89Mfehlz39Px7cv ptl4pa/1cRXuHW7USn7ZEMt5EXP/AB6HPy7egXp04yeSqlz7fh5ep7+AqSWHaU0tO6X2l/df5s7b T9v9m2u2dbhfJTEyMWWQYHzAlmJB65JJ9z1rH1fStHu/F/hzUb2/8nU7H7T9gtvORftG+MLJ8pG5 tq4Py4x3ratVmSzgW4bdOI1Ejbg2WxychVB5/wBkfQdK4Xxb/wAle+HX/cT/APSda6lseFP4megU UUUyQooooAKKKKACiiigArn/AATpWj6J4QsdO0C/+36ZD5nk3PnJLvzIzN8yAKcMWHHpXQV5/wDB L/kkOhf9vH/pRJQB6BRRRQAUUUUAFFFFABRRRQBz/irStH1T+xP7Xv8A7H9l1WC6s/3yR+dcLu2R /MDuzk/KOTjiugrz/wCKf/Mlf9jXY/8As9egUAFFFFABRRRQAUUUUAFFFFAHP+FdK0fS/wC2/wCy L/7Z9q1We6vP3ySeTcNt3x/KBtxgfKeRnmugrz/4Wf8AM6/9jXff+yV6BQAUUUUAFFFFABRRRQAV z/jbStH1vwhfadr9/wDYNMm8vzrnzki2YkVl+ZwVGWCjn1roK8/+Nv8AySHXf+3f/wBKI6APQKKK KACiiigAooooAKKKKACuf0jStHtPF/iPUbK/87U777N9vtvORvs+yMrH8oG5dy5PzZz2roK8/wDC X/JXviL/ANwz/wBJ2oA9AooooAKKKKACiiigAooooAz9dtbO+8PanZ6jcfZ7Ge0liuJt4Ty42Qhm 3HgYBJyeBRoVrZ2Ph7TLPTrj7RYwWkUVvNvD+ZGqAK24cHIAORwaz/Hf/JPPEv8A2Crr/wBFNR4E /wCSeeGv+wVa/wDopaAOgooooAKKKKACiiigAooooA8f8Q/8nQ+E/wDsFSf+g3VewV4/4h/5Oh8J /wDYKk/9Buq9goAKKKKACiiigAooooAKKKKAOP8Ahha2dj4CtbPTrj7RYwXd7Fbzbw/mRrdShW3D g5AByODXYV5/8Ev+SQ6F/wBvH/pRJXoFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUA FFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUV4P8RPB/wARfG/j vUrGwnnh8NDyoUM9z5VsdsSSElBzJ85I3bW54yNvAB3mv/GPwR4fRt2sR6hPsDrDp2JywLY++DsB HJILA4HuM+GeOviRp3ju8Nrpvgex+1XEpRLuRWe8mYjZER5W07gP4GMik7Rzt57/AMO/s4aXbeXN 4h1ae9kHlube0XyowRy6FjlnU9MjYcZ6E8eseHvCuheFLM2uh6ZBZRt98oCXkwSRuc5ZsbjjJOM4 HFAHy5oHwS8b68iytp8emQMhZZNRcxEkNjbsALg9SMqBgZzyM6lt4s+JXwjvNNsdcSdtNPzpZXTp KkkYAQoko3FNoAwoOF4JUg4P1PXD/FLwReePvD1jpNndQWvl6hHcTSzAnEYR1baAPmb5wQCQDjqK AOk8Oa/Y+KfD9nrWmtIbS6QsnmLtZSCVZSPUMCOMjjgkc1qVz/gnwx/wh3hCx0D7Z9s+y+Z+/wDK 8vdukZ/u5OMbsde1dBQAUUUUAFFFFABRRRQBz95/yUPRv+wVf/8Ao20roK5+8/5KHo3/AGCr/wD9 G2ldBQAUUUUAFFFFAHl2q/HbwzY6lbQ2UVzqNo6s09xChQxn+FVRwpY568gAEYJOQPnzWP7K/tWb +xPtv9nfL5P23b5v3Ru3bePvZxjtitXw3pEnjrxpa6bNcQ2cl5vzLBaIqJsjLcRptXnbjjHXPNe1 f8KB8K/9BDWf+/0X/wAbr9HhPLchmoNyUpLXd31dnsl3Stb0OP36upzHhT4n+E/BkFvpGi2OrS2F zeebd3OpSIrQBgillEatvACk44PHfPHsuoatpjeD7rWZo/tmkmwe6dPLB86DyyxG1sZyvZsdea+a fif4Q0/wV4lttN02a5lhls1nZrllZtxd1x8qgYwo7V7xMtxqXwRkWKHzbm58OEJFbxAbna24VEUY GScBQPYCvBz/AAuG9jSxlC7573be5rSlK7i+h0uhXVnfeHtMvNOt/s9jPaRS28OwJ5cbICq7RwMA gYHArQrD8FwTWvgXw9b3EUkM8WmWySRyKVZGESggg8gg8Yrcr5Y3CiiigAoorK8QeJNJ8L2CX2s3 f2a2klEKv5bvlyCQMKCein8quFOdSShBXb6LcG7bk97LqqTAWNlZzxbeWnu2iYH0wI246c5/CsPQ J9dGnS+VpunMv227yWv3U5+0SZGPJPAOQD3HOB0rwPXPi/4s1xURrpLGNcHZYF4ckZ5LBtx69M44 HGeayo/HPiTT7mJ7bWL5dhWYKbuUoWOHJKltrZJJOQc5Oc5Ne5/qvjfaKMt2ntbpbz8zspV6P1d3 5d1vz9pdv0Pruuf/ALV0f/hYf9kfYP8Aid/2V9q+2+Sn/Hv5u3y9+d33+duMd+tcV8NPivN4s1Wf TNbFlbXkm37FHbQyDzcK7SZJLAYCjqR361u/YLz/AIXr/aP2Sf7D/wAI15H2nyz5fmfad2zd03Y5 x1xXl43BVsFVdGsrP+tv63OGMlJXR3FFFFchQUUUUAFFFQXN7aWXk/arqGDz5Vhi82QL5kjdEXPV jg4A5ppNuyAnorzXVPjd4a0nVrzTZ7HVmmtJ3gkaOKMqWRipIzIDjI9K1fDnxT8NeI4LycTPpsNq 0aNJqTRwqzOHICneQThG4rvnlWNhT9rKm+Xv67EKcW7XO1rn/BOq6PrfhCx1HQLD7Bpk3meTbeSk WzEjK3yoSoywY8etdBXD/CCwvNM+FujWd/aT2l1H5++GeMxuuZ5CMqeRkEH8a88s7iiiigAooooA K4r4n+L9Q8FeGrbUtNhtpZpbxYGW5VmXaUds/KwOcqO9drXI+M59F1vwX4kgEun6hNp9nO7Rhkla 2mEbgEjkowIbB4PBrsy9Q+swdSPNG6uvXQme2h5B/wAL+8Vf9A/Rv+/Mv/xyvo2vmf4I6Xp+reNL yDUrG2vIV093WO5hWRQ3mRjOGBGcE8+9fSMV7aT3Vxaw3UMlzbbfPhSQF4twyu4DlcjkZ617PEtH DUa8aOHp8vKrtrre1vu/UzottXbMbV9V0e08X+HNOvbDztTvvtP2C58lG+z7Iw0nzE7l3LgfLnPe ugrh/E9heXHxS8BXkNpPJa2v9ofaJkjJSLdAoXcw4XJ4GetdxXzRsFFFFABRRRQAVzHimbWf+Ec1 pfsFh9l+yTjzPtr79mxudvlYzjtu9s966euH8U+IL/8AsjWrP+y/3PkTxedtuvu7WG7/AI99nTn7 +3/axzWVaSUXd2O/LqU6lePLHms18tfVHT2s2svcIt3YWEUBzueK9eRhxxhTEoPOO4rRrndM8QX9 9qMVtNpfkRvnMm26GMAn+O3Re3dh+J4roqqEk1o7mGJpTpztOPL6f8Ozx/4Qf8lD+J3/AGFR/wCj bivYK8f+EH/JQ/id/wBhUf8Ao24r2CrOco39nJdXmmTIyhbW5aZwx5IMMice+XH4Zq9RRSSsVKbk kn0/zv8AqFFFFMk8X8c/CTxH4k8bahrWnX+nQwXPlhRLNIrjbGqnO1COq+tc6Pgr4xeZrUajYB41 EhmM82xg2QFB8vkjYSR23L619FVnQ3Uz+I720Z8wRWlvIi4HDM8wY568hF/KvV/tqulTi4xfLZK8 U9k1r8jajKpGE1CTSt3fdbHlHgX4R+IvDXjaw1vUL7TZoLfzN4ilkZzujZBjKAdWHfpXpHirVdH0 v+xP7XsPtn2rVYLWz/cpJ5Nw27ZJ8xG3GD8w5GeK6CuH+JNheX3/AAiP2O0nuPI8S2c83kxl/LjX fudsdFGRkngVzY3HVcZNTq2ulZWVtF/w5gla77ncVh6zP5V4i/2lrNt+7B2WOn+eh5PJbyXwfbPY cc87lFcMldGtKahK7V/u/VP8jgdFutthKP7Z8Rp/pdycRaTuH+vfnP2Y8nqR2JIwMYHfVR0mzksL OSGVlLNc3EwKnjEkzuPxwwz71eqacXGOp0Y2tCrVbgur7a/cl+NwrnPHnh+78UeC9Q0axkhjubny 9jTsQg2yKxyQCeintXR0V0UasqNSNWG8WmvVanE1dWPnZPgT4xRQqatpSqOgFxMB/wCi6bH8FPGF /AtyuoafDHOokEM00yugYZ2svl8EZwRX0XRXqyzzEyqKq4xvr9ldbO/roaxq1FTdNSdtOr6X0/E5 zwH4fu/C/gvT9GvpIZLm28ze0DEod0jMMEgHow7U/SNV0e78X+I9OsrDydTsfs32+58lF+0b4y0f zA7m2rkfNjHaugrh/DFheW/xS8e3k1pPHa3X9n/Z5njISXbAwbax4bB4OOleVWqyrVJVZ7ybb9Xq ZJWVjuK4HWrrdYRD+2fEb/6XbHEuk7R/r05z9mHI6gdyAMHOD31cDrUPhYWEXkeH/Lf7XbZb+w5U yvnpuGTEOq5GO+cc5xXJXvy7nqZWo+1V4t6rZJ9et1p8jotGn828df7S1m5/dk7L7T/IQcjkN5KZ PtnueOONysPRo9BS8c6XpH2Ofyzuk/st7bK5HG5kUHnHGe3tW5WlPY5cVb2mia9Uk/uQV5V8Svhl rXjLxTa6npt7ZW8MVmsDec7h9wd2yAqkYww7+teq0V2YXFVcLNzpbtNbX38nocy3T7Hzu3wY8Sx3 sWnnWbIzTxvOr+ZJgLGVUj7ueTIv5GtHRfgp4l03xRpWpz6nps0NpdwzyfvZN5VHDEAFMdB6ivb3 s431KC+LN5sMMkKgH5SHKE59/wB2P1qxXRRzfGUpSaa97+7FdEuiTOrE4j21OMH0XeXdvq2c/wCN tV0fRPCF9qOv2H2/TIfL8628lJd+ZFVflchThip59K6CuH+L9hean8LdZs7C0nu7qTyNkMEZkdsT xk4UcnABP4VseNvE/wDwh3hC+1/7H9s+y+X+483y926RU+9g4xuz07V5xyh47/5J54l/7BV1/wCi mrwD9nH/AJKHqH/YKk/9GxVy914i8eeNdR1iXSZfEdzY3EsjSWNpNPPHDHIWxGQvG3GVwQAQDxVP TfDXxB0a4a40vRPE9jOyFGktbW4iYrkHBKgHGQDj2FAH2nRXyx8NPiJ4k0j4h2+na5darqP2yVdN a2vr2T/RpHlRS5V8/MuCMcHk8ivqegArzj4q+ANV8c/2T/ZlxZQ/Y/O8z7S7Lnfsxjap/un9K9Ho rpwmKqYSsq9L4l+qsKUVJWZ4r4D+EHiDwv400/Wb680yS2tvM3rBLIXO6NlGAUA6sO9e1VXsryO/ gaaJWCrNLCQw5zG7Ifwypx7VYrTHZhWx9RVazV0radtX+oKn7NuJz/8Aauj/APCw/wCyPsH/ABO/ 7K+1fbfJT/j383b5e/O77/O3GO/WvmD42/8AJXtd/wC3f/0njr6H+wXn/C9f7R+yT/Yf+Ea8j7T5 Z8vzPtO7Zu6bsc464rl/iZ8FP+Eu1OfXNGvfL1e6lj89LyXEAjWPZ8oWMtu+VOpx972riGfNF89n JeSNYQTwWpxsjnmErrwM5YKoPOf4R6c9ar12Hjr4cax8P/sH9rXNjN9u8zy/sju2Nm3Odyr/AHx0 z3rY8LfBTxJ4u8OWmuWF7pUdrdb9iTyyBxtdkOQIyOqnvQB6v+zj/wAk81D/ALCsn/oqKvYK5P4d +CofAfhWPS0nkmnlcXF0zOGUTFEVwnyqdmU4yM+tdZQAyUyCFzCivKFOxXbapPYEgHA98H6VzGqz 66dR0TfpunKwvW2Bb9yGP2ebgnyRgYyc88gDHOR08qNJC6LI0TMpAkQDcp9RkEZHuCK5jVdKvF1H RAdf1Fy16wDNHb5Q/Z5jkYi68Ec5GCe+CMqt7aeXbud2C5OZ81tnvzfyvsb9jJqMnmfb7W1gxjZ5 Fy0ueuc5RcdvX8KyvHf/ACTzxL/2Crr/ANFNWrY2c9p5nnaldXu7GPPWIbMZ6bEXr756VleO/wDk nniX/sFXX/opq0jtqctW3M+W1vK9vx1Of+CX/JIdC/7eP/SiSu8nnhtbeW4uJY4YIkLySSMFVFAy SSeAAOc1wfwS/wCSQ6F/28f+lEldR4q0+91fwxqOl2KwebfW0tsXnkKLGHRl3cK2SMjjjPqKbdiI xcnZHyl8Ibu20v4naJqGoXMFpZq1wrTzyqiKfIccknA5ZR+NfYME8N1bxXFvLHNBKgeOSNgyupGQ QRwQRzmvmkfs/wCuy3D6WNX04S2yrcM537SJCVAHy9R5R/MV9CeGNOuNH8K6Vpd2YjPZWkdszRMW VtihQwyAeQAcY4zjnrUQnzG+Iw7pNarZdU91foa1FFFWc4VXtrOO1nvJkZi11MJnDHgEIice2EH4 5qxRRYak0ml1Cuf1fVdHtPF/hzTr2w87U777T9gufJRvs+yMNJ8xO5dy4Hy5z3roK4fxPYXlx8Uv AV5DaTyWtr/aH2iZIyUi3QKF3MOFyeBnrQI7iiiigAooooAKKKKACiiigArn/BOq6PrfhCx1HQLD 7Bpk3meTbeSkWzEjK3yoSoywY8etdBXD/CCwvNM+FujWd/aT2l1H5++GeMxuuZ5CMqeRkEH8aAO4 ooooAKKKKACiiigAooooA5/xVquj6X/Yn9r2H2z7VqsFrZ/uUk8m4bdsk+YjbjB+YcjPFdBXD/Em wvL7/hEfsdpPceR4ls55vJjL+XGu/c7Y6KMjJPAruKACiiigAooooAKKKKACiiigDn/Cuq6Pqn9t /wBkWH2P7Lqs9refuUj864Xbvk+UndnI+Y8nHNdBXD/DawvLH/hLvtlpPb+f4lvJ4fOjKeZG2za6 56qcHBHBruKACiiigAooooAKKKKACuf8baro+ieEL7UdfsPt+mQ+X51t5KS78yKq/K5CnDFTz6V0 FcP8X7C81P4W6zZ2FpPd3UnkbIYIzI7YnjJwo5OACfwoA7iiiigAooooAKKKKACiiigArn9I1XR7 vxf4j06ysPJ1Ox+zfb7nyUX7RvjLR/MDubauR82Mdq6CuH8MWF5b/FLx7eTWk8drdf2f9nmeMhJd sDBtrHhsHg46UAdxRRRQAUUUUAFFFFABRRRQBn67dWdj4e1O81G3+0WMFpLLcQ7A/mRqhLLtPByA Rg8GjQrqzvvD2mXmnW/2exntIpbeHYE8uNkBVdo4GAQMDgVT8aQTXXgXxDb28Uk08umXKRxxqWZ2 MTAAAckk8Yo8FwTWvgXw9b3EUkM8WmWySRyKVZGESggg8gg8YoA3KKKKACiiigAooooAKKKKAPH/ ABD/AMnQ+E/+wVJ/6DdV7BXj/iH/AJOh8J/9gqT/ANBuq9goAKKKKACiiigAooooAKKKKAOP+GF1 Z33gK1vNOt/s9jPd3stvDsCeXG11KVXaOBgEDA4FdhXB/BmCa1+FOj29xFJDPE9ykkcilWRhcSAg g8gg8YrvKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACi iigAooooAKKKKACiiigAooooAKKKKACiiq9/fW+madc395J5draxPNM+0naigljgcnAB6UAY/izx poXgrTlvNau/K83cIIUUvJMyjJCqPwGThQSMkZFZ/wAPviBZ/EDTtQvLW3+y/ZbswiF5g8hjwCkj KPu7vmGORlTgnFeAaDpOqfHD4lXl5qNzPBYR/vZW+/8AZ4N3yQRnbtDHJwSBnDtgnIP0f4T8F6F4 K05rPRbTyvN2meZ2LyTMowCzH8TgYUEnAGTQB0FeL+I/jv8A8Iv8QNT0W40yDUNMtpYo0ntJtskf ygy5ByrsGJG35MFSCe49orn/ABP4J8P+LrOaHV9Nglmki8pbtY1E8QByNkmMjBJOOnJyCCQQCTwv 4u0XxjpaX+j3scwKK0sBYCWAnI2yJnKnKt7HGQSOa3K+VNEudS+CfxZ/s6/upG0uR0S6dVZY7i3b 7su3BJKEk/Lk5V0DcnP1XQAUUUUAFFFFABRRRQAUUUUAc/ef8lD0b/sFX/8A6NtK6CufvP8Akoej f9gq/wD/AEbaV0FABRRRQAUUUUAfKvwe/wCSqaN/23/9ESV9VV8q/B7/AJKpo3/bf/0RJX1VX1XF /wDv0P8AAvzkYYf4T5y+P3/I92P/AGDI/wD0bLXrthqU2jfBq11S3WNp7Lw+lxGsgJUsluGAOCDj I9RXkXx+/wCR7sf+wZH/AOjZa9dsNNm1n4NWul27RrPe+H0t42kJChntwoJwCcZPoaM1/wCRPhQh /EkbnhrUptZ8K6Rqlwsaz3tlDcSLGCFDOgYgZJOMn1NalZfhrTZtG8K6Rpdw0bT2VlDbyNGSVLIg UkZAOMj0FalfKm4UUUUAFZXiDw3pPiiwSx1m0+020comVPMdMOAQDlSD0Y/nWrRVwqTpyU4OzXVb g1fc8Vs/2ebRLpGvvEc01sM744LUROeOMMWYDnH8J/rV+9+AGgS2riz1fU4rngJJOY5UGCOqhVJ4 4+8MfpXrdFerLP8AMpSU3Vd15L/Iz9lG1rHnHgX4R2Hg7VX1O4vf7RvEx9mk8pofIyrK/Achtwbu OMcVv/8ACSXn/C0/+EX8uD7D/Yn9oeZtPmeZ5/l4znG3HbGc966iuX/4Ru8/4Wn/AMJR5kH2H+xP 7P8AL3HzPM8/zM4xjbjvnOe1cGKxdfF1Pa15c0v6+SLjFRVkdRRRRXMMKKKKACvkfxxe6rrHjvVL CS6vb3ytTuIbS3aRpNmZSAka84zhRgegr64r5V/5rt/3M3/tzX1nCjUKlapa7jG5hX2SD/hT3jz/ AKAX/k3B/wDF1h+IvB+veE/s39t2H2X7Tu8n98j7tuN33WOPvDr619jV4d+0T/zLf/b1/wC0q9DK OI8VjMZDD1IxSd9k76Jvu+xFSjGMbo9A+Fd7d6j8NtJur66mubmTzt808hd2xM4GSeTwAPwqz8O/ El54u8Cabrl/HBHdXXm70gUhBtldBgEk9FHes/4Pf8kr0b/tv/6PkrQ+Hfhu88I+BNN0O/kgkurX zd7wMSh3Su4wSAejDtXyGZJLG1kv5pfmzoh8KOooooriKCiiigDjvipe3enfDbVrqxupra5j8nZN BIUdczIDgjkcEj8a+btD8K+I/Gs97Ppdq9/NEwe5kkuEVtzliCS7Akkhuea+ivjD/wAkr1n/ALYf +j464b9nb/mZP+3X/wBq19pk2KlgsmrYmmk5KXXz5V5dzmqR5qiizhv+FPePP+gF/wCTcH/xdUfB 51LQfiVplj501pcrqcVndJFLjcPOUPGxU4Zcjkcg4r64r5V/5rt/3M3/ALc125XnNfMoVoV4xsot 6J/q2TOmoNNH0FrniS80zx34U0OGOBrXV/tn2h3Ul18qIOu0g4GSecg/hXUVy+ueG7zU/HfhTXIZ IFtdI+2faEdiHbzYgi7QBg4I5yR+NdRX58dYUUUyOWOZS0UiuoZlJU5GQSCPqCCD7igLdR9FFFAH n/xf8N6t4o8J2tjo1p9puY75JmTzETCCOQE5YgdWH514y3wm8Y6dCb+602OOC2XzpT9pjJVV5PAb ngHpX1NVTVbH+09IvbDzPL+1QSQ79udu5SM474zXq0c6xWHwjwtKyWvTXU0w/s4V41Jq+q76a+R8 yv8ABrxyqkjSY2PoLuLP6tX0h4Ys59O8J6NY3Ufl3NtYwQypkHa6xqCMjg8g9K1aKWPzjE46nGFe zs77WMuWCd4q33/rc8f+EH/JQ/id/wBhUf8Ao24r2CvH/hB/yUP4nf8AYVH/AKNuK9gryxhRRRQA UUUUAV73T7LUYRDfWkF1Erbgk8YdQemcEdeT+dYEPhbRv+Ejvd2g2H2X7Jb+XmzTZv3zbscYzjZn /gPtXT0VEoRk7tHRSxNWlFxjJpPz80/0IbW1t7K3S3tLeKCBM7Y4kCKuTk4A46kmud8aeJLzw5/w j32OOB/7S1u20+bzlJ2xybtxXBGG4GCcj2rqK5fxp4bvPEf/AAj32OSBP7N1u21CbzmI3Rx7twXA OW5GAcD3qzBtt3Z1FFFFAgooooAKKKKACiiigArl9D8SXmp+O/FehzRwLa6R9j+zuikO3mxF23En BwRxgD8a6iuX0Pw3eaZ478V65NJA1rq/2P7OiMS6+VEUbcCMDJPGCfwoA6ivGtSvdOa1QJZeHFPn wnMVnZg4Eq5Hy3ZOMdeMEZyVGSPZa8u1bWtCks41iOo7hc27Hd4gSQYEyE8fajzgHBxwecjGRy4l XW/c93I5ONR2i3rHt592jZ8G3VnNq8q29ro0TiAktY29vG+Ny8Ex3Ehx/wABA6c9Ae4rlfDWp6Ve alJHYm8MohLHz9XW6XGR/AJ5MHkc49s84PVVrRVoHDmUnKvdq2i7fpcKKKK1OAKKKKAOX+IniS88 I+BNS1ywjgkurXytiTqSh3SohyAQejHvWP8AG3/kkOu/9u//AKUR1sfETw3eeLvAmpaHYSQR3V15 Wx52IQbZUc5IBPRT2qv8UtE1HxH8ONW0nSbf7RfT+T5cW9U3bZkY8sQBwCeTQB8keHvCuu+K7w2u h6ZPeyL98oAEjyCRuc4Vc7TjJGcYHNdR/wAKS+If/Qvf+Ttv/wDHKx9H8U+Kvh3qOqWGmXn9n3Rl 8m8TyopfniLDGWDDglunX3rY/wCF2/EP/oYf/JK3/wDjdAGH4LgmtfiX4et7iKSGeLWLZJI5FKsj CZQQQeQQeMV9t18cfD6x1nxd8U7C/ij+13UeoR6nfPuSPCCdDI+OB1bovrwK+x6ACsPWdV+w3iRf 2/o2n5jDeVfR7nPJ+YfvU44x07Hmtyipkro0pTUJXav936p/kcDouu+VYSr/AMJZ4chzd3LbZYsk 5nc7v9eODnI9iOT1PfVnaLazWlhLHOmx2u7mQDIPyvO7qePVWB/GtGppRcYq50Y6tCpVbiur7a6+ SX6nL/8ACSXn/C0/+EX8uD7D/Yn9oeZtPmeZ5/l4znG3HbGc966iuX/4Ru8/4Wn/AMJR5kH2H+xP 7P8AL3HzPM8/zM4xjbjvnOe1dRWhxnzn+0Rq1hq2v6Jodpch9QsWlW5jKMBEZRCyckYORzxnHeu0 +BXinRrvwTpvhqC836vaRTzT2/lONiGdiDuI2n769D3+tcn488IaZqvjHV/EE+rOt4km4W6Pahcx KFVcG4L9EGflznPyjpWt8LfCGmeFvGS3On6s9zJc28lu8cj2rfLw+R5dwzZyg/hPGenUYKunLlPV nldSND2t11fXayfb1PbqKKK3PKCmPFHI0bPGrNG25CwyVOCMj0OCR9CafRQCdgrn/Hf/ACTzxL/2 Crr/ANFNXQVz/jv/AJJ54l/7BV1/6KagDn/gl/ySHQv+3j/0okr0CvP/AIJf8kh0L/t4/wDSiSvQ KAK6WcaalPfBm82aGOFgT8oCFyMe/wC8P6VYoooSsOUnJ3YUUUUCCiiigArl9c8SXmmeO/Cmhwxw Na6v9s+0O6kuvlRB12kHAyTzkH8K6iuX1zw3ean478Ka5DJAtrpH2z7QjsQ7ebEEXaAMHBHOSPxo A6iiiigAooooAKKKKACiiigArl/h34kvPF3gTTdcv44I7q683ekCkINsroMAknoo711Fcv8ADvw3 eeEfAmm6HfyQSXVr5u94GJQ7pXcYJAPRh2oA6iiiigAooooAKKKKACiiigDl/GniS88Of8I99jjg f+0tbttPm85Sdscm7cVwRhuBgnI9q6iuX8aeG7zxH/wj32OSBP7N1u21CbzmI3Rx7twXAOW5GAcD 3rqKACiiigAooooAKKKKACiiigDl/BfiS88R/wDCQ/bI4E/s3W7nT4fJUjdHHt2lsk5bk5IwPauo rl/Bfhu88Of8JD9skgf+0tbudQh8lidscm3aGyBhuDkDI966igAooooAKKKKACiiigArl/iJ4kvP CPgTUtcsI4JLq18rYk6kod0qIcgEHox711Fcv8RPDd54u8CalodhJBHdXXlbHnYhBtlRzkgE9FPa gDqKKKKACiiigAooooAKKKKACuX0PxJean478V6HNHAtrpH2P7O6KQ7ebEXbcScHBHGAPxrqK5fQ /Dd5pnjvxXrk0kDWur/Y/s6IxLr5URRtwIwMk8YJ/CgDqKKKKACiiigAooooAKKKKAMvxLqU2jeF dX1S3WNp7KymuI1kBKlkQsAcEHGR6ijw1qU2s+FdI1S4WNZ72yhuJFjBChnQMQMknGT6mjxLps2s +FdX0u3aNZ72ymt42kJChnQqCcAnGT6Gjw1ps2jeFdI0u4aNp7Kyht5GjJKlkQKSMgHGR6CgDUoo ooAKKKKACiiigAooooA8f8Q/8nQ+E/8AsFSf+g3VewV4/wCIf+TofCf/AGCpP/QbqvYKACiiigAo oooAKKKKACiiigDi/hRqU2s/Dqw1S4WNZ724u7iRYwQoZ7qViBkk4yfU12lcX8KNNm0b4dWGl3DR tPZXF3byNGSVLJdSqSMgHGR6Cu0oAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoooo AKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKw/GkE114F8Q29vFJNPLplykcca lmdjEwAAHJJPGK3KKAPnz9maeFbjxLbtLGJ3S2dIyw3MqmUMQOpALKCe24etfQdfLHizw94g+C/j lde0JtulTyt9lcBmj2E5NtKCcnAHGT8wUMCGB2+v+GPjd4O8QRQx3V7/AGRfPw0F78qAhdxIl+5t zkAsVJx0GRkA9Iorn/8AhO/B/wD0Neh/+DGH/wCKrh/GHx58NaLZ3EOhS/2tqY3xx7EYQRuCBlnO Ny8kjZndt6jINAHmnx/mXVfilbWFgJLi7hsobV4Y42Leazu6oBj5iVkTpnrjrxX1HXzZ8JvBmteN vGKePPEUkktpDceess2Q13Ov3dmCMIjAf7PyhACN236ToAKKKKACiiigAooooAKKKKAOfvP+Sh6N /wBgq/8A/RtpXQVz95/yUPRv+wVf/wDo20rU1LVtN0a3W41TULSxgZwiyXUyxKWwTgFiBnAJx7Gg Ca6uobKznu7h9kEEbSSNgnaqjJOBz0FTV5X4i+KmiXVhq2l2+o6NMZYpreMx3krM+QVGAIdpJ/3s f7WOa09M+Lfh6+1GK2m1bQ4I3zmT7dIMYBP8cKL27sPxPFZKtFy5bnfLLq0aKq8vfqtkk/8AM9Bo qOCeG6t4ri3ljmglQPHJGwZXUjIII4II5zUlanAfKvwe/wCSqaN/23/9ESV9VV8geA/EFp4X8aaf rN9HNJbW3mb1gUFzujZRgEgdWHevav8Ahf3hX/oH6z/35i/+OV9xxNl2KxWLjOjByXKlp3uzmozj GNmzh/j9/wAj3Y/9gyP/ANGy16qJ5rX4FfaLeWSGeLw1vjkjYqyMLbIII5BB5zXhXxP8X6f418S2 2pabDcxQxWawMtyqq24O7Z+ViMYYd6+gdItbO++EdjZ6jcfZ7GfQo4ribeE8uNoAGbceBgEnJ4Fc ud0p0crw1OorNbodNpzbRoeC55rrwL4euLiWSaeXTLZ5JJGLM7GJSSSeSSec1uVn6Fa2dj4e0yz0 64+0WMFpFFbzbw/mRqgCtuHByADkcGtCvkToCiqkd95mr3Nh5ePJgim37uu9pBjHt5f6+1W6Sdyp RcXZ/wBX1CiiimSFFFVNNvv7QtXm8vy9s80ON2c+XK0efx259s0r62K5W4uXT+v8i3XD/b7z/hev 9nfa5/sP/CNef9m8w+X5n2nbv29N2OM9cV3Fc/8A2Vo//Cw/7X+3/wDE7/sr7L9i85P+Pfzd3mbM bvv8bs47daZJ0FFFFABRRRQAV8q/812/7mb/ANua+qq+Vf8Amu3/AHM3/tzX1XDH/MR/gMK3Q+qq 8O/aJ/5lv/t6/wDaVe414d+0T/zLf/b1/wC0q4eG/wDkaUv+3v8A0llVvgZ3Pwe/5JXo3/bf/wBH yUfCC/vNT+FujXl/dz3d1J5++aeQyO2J5AMseTgAD8KPg9/ySvRv+2//AKPkrY8E6Vo+ieELHTtA v/t+mQ+Z5Nz5yS78yMzfMgCnDFhx6Vw5p/v1b/HL82XD4UdBULXUKXkdoz4nljeRFweVUqGOenBd fzoumuEt3a0iilnGNqSyGNTzzlgrEcZ7Gubnn13/AISmwJ03ThL9iudqi/faRvgySfJ4PTjHOTyM c+dOfKdWHw7qt6rZ9UtlfqdVRVeze9eEm+t4IJd3CwTmVSPXJReevGPxqxVp3MJRcXZnD/GH/kle s/8AbD/0fHXDfs7f8zJ/26/+1a7n4w/8kr1n/th/6Pjrhv2dv+Zk/wC3X/2rX1WE/wCSer/41+cD nl/GR7jXyr/zXb/uZv8A25r6qr5V/wCa7f8Aczf+3NHDH/MR/gCt0PcvE9/eW/xS8BWcN3PHa3X9 ofaIUkISXbApXco4bB5GeldxXP6vpWj3fi/w5qN7f+Tqdj9p+wW3nIv2jfGFk+Ujc21cH5cY710F fKm5Rvb+5tZgkOk3l4pXPmQPCFB9PnkU5/DHNYegareJp0oXQNRkH227O5ZLfAJuJCRzKOR0PbI4 yOa3L3VrawmEU0d4zFd2YLKaZcfVFIzx061h6Br9nFp0qtDqJJvbtvl024YYNxIRyE688jqDweRW Mmuf4vy8j0qUJvDu1K+q/m10l2Z1VFFFbHmhRRRQAUUUUAeP/CD/AJKH8Tv+wqP/AEbcV7BXj/wg /wCSh/E7/sKj/wBG3FY/xr/4Tz/hMrP/AIRf/hI/sP8AZ6b/AOzPP8vzPMkzny+N2NvvjFAHvFFf IH/F3/8Aqef/ACbo/wCLv/8AU8/+TdAH1/RRRQAUVXvb2KwhEsyTspbbiC3kmbP0QE4469K52DX7 MeKb+XydR2tZWygDTbjdkPP1GzIHI5PB5x0NRKai0mzopYapVjKUYvTy80v1Oqrh/iTf3lj/AMIj 9ju57fz/ABLZwTeTIU8yNt+5Gx1U4GQeDXZWtyl3bpPGsqo2cCWJo24OOVYAj8RWL4q0rR9U/sT+ 17/7H9l1WC6s/wB8kfnXC7tkfzA7s5Pyjk44qzBpp2Z0FUb3WtK06YQ32p2drKy7gk86oxHTOCen B/Kr1fJlonxfaIn7P4uk+brNPdofy3jj8Kmbsrm2HpqpPlf6/on+R9GaL4p0b7BL9q16w8z7Xc48 28TOzz32dT027ce2McV09fKQj+KZH+g2niMw5+YxXN0B5n/LTpJ137s985zk5r034F/8Jh/xPv8A hK/7c/5d/s39q+d/003bPM/4DnHtUUZOUdf6/E6cxoxpVXyq12+/fziv1PYKKKK1PPCiis7QLqa9 8OaXd3D7557SKSRsAbmZAScDjqaV9bFqDcHPtZfff/I0a4fwxf3lx8UvHtnNdzyWtr/Z/wBnheQl It0DFtqnhcnk4613Fc/pGlaPaeL/ABHqNlf+dqd99m+323nI32fZGVj+UDcu5cn5s57UyDoK8a1L U99qg/tPd+/hOP7R3dJVOcf2g3TrnHHXK/eEvx0/4TD/AIkP/CKf25/y8faf7K87/pnt3+X/AMCx n3rzIx/FMD/TrTxGIc/KZbm6I8z/AJZ9ZOu/bjvnGMHFc2Jimj2smqShUaSvdrv+if42PdfBt79p 1eVPt3n4gJ2/bPNx8y84+1zfntH1HQ9xXyZdp8X1iB+z+Lo/m6wz3bn8t54/CvrOtKStE4swm51r tW+/9UvyCiiitTiCis6a6mTxHZWiviCW0uJHXA5ZXhCnPXgO351o0k7lyg4pN9dfxa/Q4f4v395p nwt1m8sLue0uo/I2TQSGN1zPGDhhyMgkfjXcVz/jbStH1vwhfadr9/8AYNMm8vzrnzki2YkVl+Zw VGWCjn1roKZBz/jv/knniX/sFXX/AKKavAP2cf8Akoeof9gqT/0bFXtfxZg1K6+GGtW+kxXc15Kk aLHaKzSOplQOAF5IK7gR6ZzxXzBpvhr4g6NcNcaXoniexnZCjSWtrcRMVyDglQDjIBx7CgD7Tooo oAKKKKACiiigDh/t95/wvX+zvtc/2H/hGvP+zeYfL8z7Tt37em7HGeuK7iuf/srR/wDhYf8Aa/2/ /id/2V9l+xecn/Hv5u7zNmN33+N2cdutdBQBna/azXvhzVLS3TfPPaSxxrkDczIQBk8dTWjRRStr ctzbgodrv77f5BRRRTICiiigArn/AB3/AMk88S/9gq6/9FNXQVz/AI7/AOSeeJf+wVdf+imoA5/4 Jf8AJIdC/wC3j/0okr0CvP8A4Jf8kh0L/t4/9KJK9AoAKKKKACiiigAooooAK4fxPf3lv8UvAVnD dzx2t1/aH2iFJCEl2wKV3KOGweRnpXcVz+r6Vo934v8ADmo3t/5Op2P2n7Bbeci/aN8YWT5SNzbV wflxjvQB0FFFFABRRRQAUUUUAFFFFABXD/CC/vNT+FujXl/dz3d1J5++aeQyO2J5AMseTgAD8K7i uf8ABOlaPonhCx07QL/7fpkPmeTc+cku/MjM3zIApwxYcelAHQUUUUAFFFFABRRRQAUUUUAcP8Sb +8sf+ER+x3c9v5/iWzgm8mQp5kbb9yNjqpwMg8Gu4rn/ABVpWj6p/Yn9r3/2P7LqsF1Z/vkj864X dsj+YHdnJ+UcnHFdBQAUUUUAFFFFABRRRQAUUUUAcP8ADa/vL7/hLvtl3PceR4lvIIfOkL+XGuza i56KMnAHAruK5/wrpWj6X/bf9kX/ANs+1arPdXn75JPJuG274/lA24wPlPIzzXQUAFFFFABRRRQA UUUUAFcP8X7+80z4W6zeWF3PaXUfkbJoJDG65njBww5GQSPxruK5/wAbaVo+t+EL7Ttfv/sGmTeX 51z5yRbMSKy/M4KjLBRz60AdBRRRQAUUUUAFFFFABRRRQAVw/hi/vLj4pePbOa7nktbX+z/s8LyE pFugYttU8Lk8nHWu4rn9I0rR7Txf4j1Gyv8AztTvvs32+285G+z7Iysfygbl3Lk/NnPagDoKKKKA CiiigAooooAKKKKAMPxpPNa+BfENxbyyQzxaZcvHJGxVkYRMQQRyCDzmjwXPNdeBfD1xcSyTTy6Z bPJJIxZnYxKSSTySTzmrmu2tnfeHtTs9RuPs9jPaSxXE28J5cbIQzbjwMAk5PAo0K1s7Hw9plnp1 x9osYLSKK3m3h/MjVAFbcODkAHI4NAGhRRRQAUUUUAFFFFABRRRQB4/4h/5Oh8J/9gqT/wBBuq9g rx/xD/ydD4T/AOwVJ/6DdV7BQAUUUUAFFFFABRRRQAUUUUAcH8GZ5rr4U6PcXEsk08r3LySSMWZ2 NxISSTySTzmu8rj/AIYWtnY+ArWz064+0WMF3exW828P5ka3UoVtw4OQAcjg12FABRRRQAUUUUAF FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUU UUAFFFFABRRRQBXvrCz1Ozks7+0gu7WTG+GeMSI2CCMqeDggH8K8n1v9nbwtfefJpN5faXM+3y03 CeGPGM/K3znIB6vwT6DFewUUAfP/APwzL/1N3/lN/wDttdZ4e+AXhDRriC6vTd6tPGi7kumUQGQE HcEUA4yD8rMwwSDnrXqlFAEcEENrbxW9vFHDBEgSOONQqooGAABwABxipKKKACiiigAooooAKKKK ACiiigDn7z/koejf9gq//wDRtpWH8WfBWpePPCtrpelz2kM8V6lwzXTsqlQjrgbVY5y47etbl5/y UPRv+wVf/wDo20roKAPmuX4G+KtGsH1C41+zaCyiM8kMckpyqDcVGQB0GO1PuP2e/GEsDJ/wkWny 5x8kkswU89/lP8q+idQs49R026sZmZYrmF4XKHDAMCDjPfmrFZKkua/+R3yx0nRVP16y7Lz/AOAZ fhrTZtG8K6Rpdw0bT2VlDbyNGSVLIgUkZAOMj0FalFFanAef+IPg74V1+/S68ubTtkQj8nTlihjb BJ3EbD83OM+gFeZf8KB8Vf8AQQ0b/v8AS/8Axuvo2ivawuf4/DR5YzuvPUzlSizxzwl8CrSy8q68 R3Pn3kFyJEhtZA1vJGu0hXDx5OSGBHTGK9A8aQRW3w18QwQRJFDFo9ykccahVRRCwAAHAAHaujrP 126s7Hw9qd5qNv8AaLGC0lluIdgfzI1Qll2ng5AIweDXFjcwxGNnzV5X/JFRgo7Gf4E/5J54a/7B Vr/6KWvI/iX8YfEnh3xxqPh+we0tbW0MTJOtr5srbolYhtzbcZY9ADwPevbNCurO+8PaZeadb/Z7 Ge0ilt4dgTy42QFV2jgYBAwOBVe+8J+G9TvJLy/8P6Vd3UmN809lHI7YAAyxGTgAD8K4WrqxrTny SUrX9dj5q/4XL4pjY6gur4nnHkO/9nxcrH8yjG7AwZG5759q7L4a/GTxJ4l8baZ4dv1sZ7W483fc /ZzHMdsbuOj7RyoHTp7816uvw/8ACIuXm/4RvSSrIqiE2MXloQWJZV28MdwBPcKvpVyx8J+G9MvI 7yw8P6VaXUedk0FlHG65BBwwGRkEj8ainT5ep1YvFKtZKKW2ys9Fb7jYooorQ4jlfEt5qtvqUaWM t4kRhBIgiZlzk9xay89P4h9O55jSdR11LOQRT6iF+03BO2FyMmZyf+XBuc5zz17L90eo1R0mzksL OSGVlLNc3EwKnjEkzuPxwwz71hKlJzupHrUcdRhQ5JUk3ddtd9di9Xn/APzcL/3Kn/t3XoFc/wD2 ro//AAsP+yPsH/E7/sr7V9t8lP8Aj383b5e/O77/ADtxjv1rc8kseKfEln4R8OXeuX8c8lra7N6Q KC53OqDAJA6sO9efx/tB+FJYw62GrAH+99mU/kZs16B4p8N2fi7w5d6HfyTx2t1s3vAwDja6uMEg jqo7V5v/AMM4+D/+glrn/f8Ah/8AjVJ36FwcE/fV/R2/RjNM+OPhrRtEs9PuLLUmlsrZIZDGbcgs ihTgGUHt6A+1el+FvEln4u8OWmuWEc8drdb9iTqA42uyHIBI6qe9eax/s7eGp41mvtR1YXkgDTiC ePy/MPLbcxZ25zjPOK9K8LeG7Pwj4ctNDsJJ5LW137HnYFzudnOSAB1Y9qmmmopM1xUqc60pU9rv rfr6I2K+TvFceq+G/iVeazJp80O3WJrq0a5hZY59k24EHjcv3eh6EetfWNUdR0XStY8v+09Msr3y s+X9pgWTZnGcbgcZwPyFe3k+aLL6knOPNGSszjqQ50eAf8L+8Vf9A/Rv+/Mv/wAcrlPGfj/VfHP2 L+07eyh+x+Z5f2ZGXO/bnO5j/dH619Of8IX4V/6FnRv/AAAi/wDiaP8AhC/Cv/Qs6N/4ARf/ABNe xQzzLKFRVKWGtJdTN0ptWbMr4V2V3p3w20m1vrWa2uY/O3wzxlHXMzkZB5HBB/GqHwS/5JDoX/bx /wClElegVyfh99B8Z/DfZpNlJp2i6lb3FusEcSQtGrM8bkKuVBzuPfrk18riazr1p1mrczb+93N0 rKxh+KfjX4b8I+I7vQ7+y1WS6tdm94Ioyh3IrjBMgPRh2rn3/aC8FvqUF8dP1/zYYZIVAhh2kOUJ z+86/ux+tcB4p+BXie08R3cHhrS573SF2fZ557uAO+UUtkFl6NuHQdPxrH/4Ul8Q/wDoXv8Aydt/ /jlYtXKjJxd0e16T8ffCus6zY6Xb6frKz3txHbxtJDEFDOwUE4kJxk+hr1SvkzSfgd41m1mxi1TR ZINPe4jW6ljvLcskRYb2HznkLk9D9DX1PpOmw6No1jpdu0jQWVvHbxtIQWKooUE4AGcD0FAjmvip ZXeo/DbVrWxtZrm5k8nZDBGXdsTITgDk8An8K+fPCXjnWvh7PqUFnZW3nTsqXEd7E+6NoywxgMpB yxyD6V9aVyPib4beGvFEBSeySzmafz5LqxijjmkbByGcqSQS2T6kA19Fk+bYfD0JYTFQ5oSd/wAu nyMalNt80XqeQf8AC/vFX/QP0b/vzL/8crmPCr6h4j+KNhqSWjyzS6rHe3K20bMsSmZWZu5CgnqT x616/wD8KB8K/wDQQ1n/AL/Rf/G69D0/w9oukztPpuj6fZzMuxpLa2SNiuQcZUA4yBx7V6dXO8sw 1OSwVL3pJp9CFTnJ+8zkfFv/ACV74df9xP8A9J1rtNW1KHRtGvtUuFkaCyt5LiRYwCxVFLEDJAzg eorL1fVdHtPF/hzTr2w87U777T9gufJRvs+yMNJ8xO5dy4Hy5z3rU1bTYdZ0a+0u4aRYL23kt5Gj IDBXUqSMgjOD6GvijpPMYv2hfCcyll0/VwAcfOLdT+RmFV9N+OHhrTLV4JrLUWZ7iacFWt8bZZWk XrMOcOM9s9CRzTv+GcfB/wD0Etc/7/w//Gqan7O3hqZS15qOrCUEqvkzx7fLU4TOYvvbAue2c44r NqXNdHXCdFUXGSd7rqvPyO+8FeNdN8eaNNqmlwXcMEVw1uy3SKrFgqtkbWYYw47+tdJXN+CvBWm+ A9Gm0vS57uaCW4a4Zrp1ZgxVVwNqqMYQdvWukrQ5ArmPFOtWv/COa1a+Vf8AmfZJ48/2fPszsYff 2bcf7Wcd84rp65vxJ4b0qfQtXmh0WzkvpLaZkdLVTK0hUkEEDJbP45rOrzcr5TswLoqtF1b7ra3f rc07XWrW7uEgjiv1ds4MunzxrwM8syAD8TWjWda6Bo1lcJcWmkWEE6Z2yRWyIy5GDggZ6EitGqjz W94wrey5v3V7edv0PH/hB/yUP4nf9hUf+jbivYK8f+EH/JQ/id/2FR/6NuK9gqjIKKKKACiiigAq jFZyJrt3fFl8qa2ghUA/MCjSk59v3g/Wr1FJq5UZuKaXX/O/6BXn/wAU/wDmSv8Asa7H/wBnr0Cu f8Varo+l/wBif2vYfbPtWqwWtn+5STybht2yT5iNuMH5hyM8UyToKKKKAKOk2clhZyQyspZrm4mB U8Ykmdx+OGGfer1FFJKysVObnJye7CiiimSZ11oGjXtw9xd6RYTzvjdJLbI7NgYGSRnoAKzPDfhv SoNC0iabRbOO+jtoWd3tVEqyBQSSSMhs/jmukoqPZxvex0LFVlTdNSdtOr6X0/EK8/8ACX/JXviL /wBwz/0navQK5/SNV0e78X+I9OsrDydTsfs32+58lF+0b4y0fzA7m2rkfNjHarOc6CqOrWcl/Zxw xMoZbm3mJY8YjmRz+OFOPer1FJq6sVCbhJSW6CiiimSFQ3Vrb3tu9vd28U8D43RyoHVsHIyDx1AN TUUDTad0cxN4W0b/AISOy26DYfZfslx5mLNNm/fDtzxjON+P+Be9b9np9lp0JhsbSC1iZtxSCMIp PTOAOvA/KrFFRGEYu6RtVxNWrFRlJtLz82/1PP8A42/8kh13/t3/APSiOvQK5/xtquj6J4QvtR1+ w+36ZD5fnW3kpLvzIqr8rkKcMVPPpXQVZgFFFFABRRRQAUUUUAFFFFAHn/8AzcL/ANyp/wC3degV z/8Aauj/APCw/wCyPsH/ABO/7K+1fbfJT/j383b5e/O77/O3GO/WugoAKKKKACiiigAooooAK5/x 3/yTzxL/ANgq6/8ARTV0Fc/47/5J54l/7BV1/wCimoA5/wCCX/JIdC/7eP8A0okr0CvP/gl/ySHQ v+3j/wBKJK9AoAKKKKACiiigAooooAK8/wDFv/JXvh1/3E//AEnWvQK5/V9V0e08X+HNOvbDztTv vtP2C58lG+z7Iw0nzE7l3LgfLnPegDoKKKKACiiigAooooAKKKKACvP/AIJf8kh0L/t4/wDSiSvQ K5/wTquj634QsdR0Cw+waZN5nk23kpFsxIyt8qEqMsGPHrQB0FFFFABRRRQAUUUUAFFFFAHn/wAU /wDmSv8Asa7H/wBnr0Cuf8Varo+l/wBif2vYfbPtWqwWtn+5STybht2yT5iNuMH5hyM8V0FABRRR QAUUUUAFFFFABRRRQB5/8LP+Z1/7Gu+/9kr0Cuf8K6ro+qf23/ZFh9j+y6rPa3n7lI/OuF275PlJ 3ZyPmPJxzXQUAFFFFABRRRQAUUUUAFef/G3/AJJDrv8A27/+lEdegVz/AI21XR9E8IX2o6/Yfb9M h8vzrbyUl35kVV+VyFOGKnn0oA6CiiigAooooAKKKKACiiigArz/AMJf8le+Iv8A3DP/AEnavQK5 /SNV0e78X+I9OsrDydTsfs32+58lF+0b4y0fzA7m2rkfNjHagDoKKKKACiiigAooooAKKKKAOf8A Hf8AyTzxL/2Crr/0U1HgT/knnhr/ALBVr/6KWtDXbqzsfD2p3mo2/wBosYLSWW4h2B/MjVCWXaeD kAjB4NGhXVnfeHtMvNOt/s9jPaRS28OwJ5cbICq7RwMAgYHAoA0KKKKACiiigAooooAKKKKAPH/E P/J0PhP/ALBUn/oN1XsFeP8AiH/k6Hwn/wBgqT/0G6r2CgAooooAKKKKACiiigAooooA8/8Agl/y SHQv+3j/ANKJK9Arj/hhdWd94CtbzTrf7PYz3d7Lbw7AnlxtdSlV2jgYBAwOBXYUAFFFFABRRRQA UUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABR RRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRXleq/tAeDdM1S4sUj1K+ED7PtFpF G0TnvtLOCRnjOMHGRkYJ7zwx4n0vxdocOr6RP5tvJwytw8TjqjjswyPzBBIIJAK95/yUPRv+wVf/ APo20roK5+8/5KHo3/YKv/8A0baV0FABRWH40nmtfAviG4t5ZIZ4tMuXjkjYqyMImIII5BB5zW5Q AUUUUAFFFYeuzzQ6x4YSKWREm1N0lVWIDr9kuGw3qNyqcHuAe1AG5WH40gmuvAviG3t4pJp5dMuU jjjUszsYmAAA5JJ4xW5WX4l1KbRvCur6pbrG09lZTXEayAlSyIWAOCDjI9RQBX8FwTWvgXw9b3EU kM8WmWySRyKVZGESggg8gg8YrcrL8NalNrPhXSNUuFjWe9sobiRYwQoZ0DEDJJxk+prUoAKKw7We ZvHWrW7SyGBNMsnSMsdqs0t0GIHQEhVBPfaPStygAooooAKKKw/Cc81zo9w88skrjU79AzsWIVbu ZVHPYKAAOwAFAG5XD/YLz/hev9o/ZJ/sP/CNeR9p8s+X5n2nds3dN2OcdcV3Fcv/AMJJef8AC0/+ EX8uD7D/AGJ/aHmbT5nmef5eM5xtx2xnPegDqKKKKACisPwXPNdeBfD1xcSyTTy6ZbPJJIxZnYxK SSTySTzmtygAooooAKKw/Fk81to9u8EskTnU7BCyMVJVruFWHHYqSCO4JFblABXD/CCwvNM+FujW d/aT2l1H5++GeMxuuZ5CMqeRkEH8a7iuX+HfiS88XeBNN1y/jgjurrzd6QKQg2yugwCSeijvQB1F FFYd1PMvjrSbdZZBA+mXrvGGO1mWW1CkjoSAzAHtuPrQBuUUUUAFFFFABRWHoU802seJ0llkdIdT RIlZiQi/ZLdsL6DczHA7knvW5QBw/iewvLj4peAryG0nktbX+0PtEyRkpFugULuYcLk8DPWu4rl9 c8SXmmeO/CmhwxwNa6v9s+0O6kuvlRB12kHAyTzkH8K6igAoorD8JzzXOj3DzyySuNTv0DOxYhVu 5lUc9goAA7AAUAblFFFABRRWH40nmtfAviG4t5ZIZ4tMuXjkjYqyMImIII5BB5zQBuUUUUAeP/CD /kofxO/7Co/9G3FewV4/8IP+Sh/E7/sKj/0bcV7BQAUVh67PNDrHhhIpZESbU3SVVYgOv2S4bDeo 3Kpwe4B7VuUAFFFFABRRWHazzN461a3aWQwJplk6RljtVmlugxA6AkKoJ77R6UAblcP8SbC8vv8A hEfsdpPceR4ls55vJjL+XGu/c7Y6KMjJPAruK5fxp4kvPDn/AAj32OOB/wC0tbttPm85Sdscm7cV wRhuBgnI9qAOoooooAKKw/Cc81zo9w88skrjU79AzsWIVbuZVHPYKAAOwAFblABRRRQAUUVh+C55 rrwL4euLiWSaeXTLZ5JJGLM7GJSSSeSSec0AblcP4YsLy3+KXj28mtJ47W6/s/7PM8ZCS7YGDbWP DYPBx0ruK5fQ/El5qfjvxXoc0cC2ukfY/s7opDt5sRdtxJwcEcYA/GgDqKKKw/Fk81to9u8EskTn U7BCyMVJVruFWHHYqSCO4JFAG5RRRQAUUUUAFFYd1PMvjrSbdZZBA+mXrvGGO1mWW1CkjoSAzAHt uPrW5QBw/wAX7C81P4W6zZ2FpPd3UnkbIYIzI7YnjJwo5OACfwruK5f4ieJLzwj4E1LXLCOCS6tf K2JOpKHdKiHIBB6Me9dRQAUUVh6FPNNrHidJZZHSHU0SJWYkIv2S3bC+g3MxwO5J70AblFFFABRR RQAUVh+E55rnR7h55ZJXGp36BnYsQq3cyqOewUAAdgAK3KAOH+wXn/C9f7R+yT/Yf+Ea8j7T5Z8v zPtO7Zu6bsc464ruK5f/AISS8/4Wn/wi/lwfYf7E/tDzNp8zzPP8vGc4247YznvXUUAFFYfjSea1 8C+Ibi3lkhni0y5eOSNirIwiYggjkEHnNblABRRRQAUUVh67PNDrHhhIpZESbU3SVVYgOv2S4bDe o3Kpwe4B7UAblc/47/5J54l/7BV1/wCimroK5/x3/wAk88S/9gq6/wDRTUAc/wDBL/kkOhf9vH/p RJXoFef/AAS/5JDoX/bx/wClElegUAFFYdrPM3jrVrdpZDAmmWTpGWO1WaW6DEDoCQqgnvtHpW5Q AUUUUAFFFYehTzTax4nSWWR0h1NEiVmJCL9kt2wvoNzMcDuSe9AG5XD+J7C8uPil4CvIbSeS1tf7 Q+0TJGSkW6BQu5hwuTwM9a7iuX1zxJeaZ478KaHDHA1rq/2z7Q7qS6+VEHXaQcDJPOQfwoA6iiii gAorD8FzzXXgXw9cXEsk08umWzySSMWZ2MSkkk8kk85rcoAKKKKACisPxZPNbaPbvBLJE51OwQsj FSVa7hVhx2KkgjuCRW5QAVw/wgsLzTPhbo1nf2k9pdR+fvhnjMbrmeQjKnkZBB/Gu4rl/h34kvPF 3gTTdcv44I7q683ekCkINsroMAknoo70AdRRRWHdTzL460m3WWQQPpl67xhjtZlltQpI6EgMwB7b j60AblFFFABRRRQAUVh2s8zeOtWt2lkMCaZZOkZY7VZpboMQOgJCqCe+0elblAHD/EmwvL7/AIRH 7HaT3HkeJbOebyYy/lxrv3O2OijIyTwK7iuX8aeJLzw5/wAI99jjgf8AtLW7bT5vOUnbHJu3FcEY bgYJyPauooAKKKw/Cc81zo9w88skrjU79AzsWIVbuZVHPYKAAOwAFAG5RRRQAUUVh+NJ5rXwL4hu LeWSGeLTLl45I2KsjCJiCCOQQec0AblFFFAHD/DawvLH/hLvtlpPb+f4lvJ4fOjKeZG2za656qcH BHBruK5fwX4kvPEf/CQ/bI4E/s3W7nT4fJUjdHHt2lsk5bk5IwPauooAKKw9dnmh1jwwkUsiJNqb pKqsQHX7JcNhvUblU4PcA9q3KACiiigAoorDtZ5m8datbtLIYE0yydIyx2qzS3QYgdASFUE99o9K ANyuH+L9hean8LdZs7C0nu7qTyNkMEZkdsTxk4UcnABP4V3Fcv8AETxJeeEfAmpa5YRwSXVr5WxJ 1JQ7pUQ5AIPRj3oA6iiiigAorD0KeabWPE6SyyOkOpokSsxIRfslu2F9BuZjgdyT3rcoAKKKKACi isPwXPNdeBfD1xcSyTTy6ZbPJJIxZnYxKSSTySTzmgDcrh/DFheW/wAUvHt5NaTx2t1/Z/2eZ4yE l2wMG2seGweDjpXcVy+h+JLzU/HfivQ5o4FtdI+x/Z3RSHbzYi7biTg4I4wB+NAHUUUVh+LJ5rbR 7d4JZInOp2CFkYqSrXcKsOOxUkEdwSKANyiiigAooooAKKw7qeZfHWk26yyCB9MvXeMMdrMstqFJ HQkBmAPbcfWtygDD8aQTXXgXxDb28Uk08umXKRxxqWZ2MTAAAckk8Yo8FwTWvgXw9b3EUkM8WmWy SRyKVZGESggg8gg8Yqx4l1KbRvCur6pbrG09lZTXEayAlSyIWAOCDjI9RR4a1KbWfCukapcLGs97 ZQ3EixghQzoGIGSTjJ9TQBqUUVh2s8zeOtWt2lkMCaZZOkZY7VZpboMQOgJCqCe+0elAG5RRRQAU UUUAFFYfhOea50e4eeWSVxqd+gZ2LEKt3MqjnsFAAHYACtygDx/xD/ydD4T/AOwVJ/6DdV7BXj/i H/k6Hwn/ANgqT/0G6r2CgAorD8aTzWvgXxDcW8skM8WmXLxyRsVZGETEEEcgg85rcoAKKKKACiis PXZ5odY8MJFLIiTam6SqrEB1+yXDYb1G5VOD3APagDcooooA4P4MwTWvwp0e3uIpIZ4nuUkjkUqy MLiQEEHkEHjFd5XF/CjUptZ+HVhqlwsaz3txd3EixghQz3UrEDJJxk+prtKACiiigAooooAKKKKA CiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK KKKACiiigAooooAKKKKACiiigAooooAKKKKACuL+LWpTaV8K/EFxAsbO9uLchwSNsrrEx4I52uSP fHXpXaVxfxa02bVfhX4gt4GjV0txcEuSBtidZWHAPO1CB746daAJPhbo1nonw10KKzTH2m0jvJnI G55JVDsSQBnGQozztVRk4ri/h/BD4b+OvjTw3p0UaafNbx3u3aAY2+RgibcAIPtDgDHQLzwc9p8L dZs9b+GuhS2b5+zWkdnMhI3JJEoRgQCcZwGGedrKcDNcX8P54fEnx18aeJNOljfT4beOy3bgTI3y KHTbkFD9ncg56FeOTgA9EvP+Sh6N/wBgq/8A/RtpXQVn6noWj635X9raVY3/AJOfL+126S7M4zjc DjOB09BWf/wgng//AKFTQ/8AwXQ//E0AHjv/AJJ54l/7BV1/6Kaugrn/APhBPB//AEKmh/8Aguh/ +Jo/4QTwf/0Kmh/+C6H/AOJoA6Ciuf8A+EE8H/8AQqaH/wCC6H/4mj/hBPB//QqaH/4Lof8A4mgD oK5/xD/yHPCf/YVk/wDSK6o/4QTwf/0Kmh/+C6H/AOJo/wCEE8H/APQqaH/4Lof/AImgDoKy/Eum zaz4V1fS7do1nvbKa3jaQkKGdCoJwCcZPoap/wDCCeD/APoVND/8F0P/AMTR/wAIJ4P/AOhU0P8A 8F0P/wATQBc8NabNo3hXSNLuGjaeysobeRoySpZECkjIBxkegrUrn/8AhBPB/wD0Kmh/+C6H/wCJ o/4QTwf/ANCpof8A4Lof/iaACz/5KHrP/YKsP/Rt3XQVz/8Awgng/wD6FTQ//BdD/wDE0f8ACCeD /wDoVND/APBdD/8AE0AdBRXP/wDCCeD/APoVND/8F0P/AMTR/wAIJ4P/AOhU0P8A8F0P/wATQB0F c/4N/wCQHc/9hXUv/S2aj/hBPB//AEKmh/8Aguh/+Jo/4QTwf/0Kmh/+C6H/AOJoA6CuX/4Ru8/4 Wn/wlHmQfYf7E/s/y9x8zzPP8zOMY2475zntVj/hBPB//QqaH/4Lof8A4mj/AIQTwf8A9Cpof/gu h/8AiaAOgorn/wDhBPB//QqaH/4Lof8A4mj/AIQTwf8A9Cpof/guh/8AiaADwJ/yTzw1/wBgq1/9 FLXQVz//AAgng/8A6FTQ/wDwXQ//ABNH/CCeD/8AoVND/wDBdD/8TQB0FFc//wAIJ4P/AOhU0P8A 8F0P/wATR/wgng//AKFTQ/8AwXQ//E0AHjL/AJAdt/2FdN/9LYa6Cuf/AOEE8H/9Cpof/guh/wDi aP8AhBPB/wD0Kmh/+C6H/wCJoA6CuX+Hfhu88I+BNN0O/kgkurXzd7wMSh3Su4wSAejDtVj/AIQT wf8A9Cpof/guh/8AiaP+EE8H/wDQqaH/AOC6H/4mgDoK5+8/5KHo3/YKv/8A0baUf8IJ4P8A+hU0 P/wXQ/8AxNH/AAgng/8A6FTQ/wDwXQ//ABNAHQUVz/8Awgng/wD6FTQ//BdD/wDE0f8ACCeD/wDo VND/APBdD/8AE0AdBRXP/wDCCeD/APoVND/8F0P/AMTR/wAIJ4P/AOhU0P8A8F0P/wATQAeHv+Q5 4s/7Csf/AKRWtdBXP/8ACCeD/wDoVND/APBdD/8AE0f8IJ4P/wChU0P/AMF0P/xNAFfXPDd5qfjv wprkMkC2ukfbPtCOxDt5sQRdoAwcEc5I/Guorn/+EE8H/wDQqaH/AOC6H/4mj/hBPB//AEKmh/8A guh/+JoA6Cuf8G/8gO5/7Cupf+ls1H/CCeD/APoVND/8F0P/AMTR/wAIJ4P/AOhU0P8A8F0P/wAT QB0FFc//AMIJ4P8A+hU0P/wXQ/8AxNH/AAgng/8A6FTQ/wDwXQ//ABNAHQVz/jv/AJJ54l/7BV1/ 6Kaj/hBPB/8A0Kmh/wDguh/+Jo/4QTwf/wBCpof/AILof/iaAOgorn/+EE8H/wDQqaH/AOC6H/4m j/hBPB//AEKmh/8Aguh/+JoA8/8AhB/yUP4nf9hUf+jbivYK5/8A4QTwf/0Kmh/+C6H/AOJo/wCE E8H/APQqaH/4Lof/AImgA8Q/8hzwn/2FZP8A0iuq6Cuf/wCEE8H/APQqaH/4Lof/AImj/hBPB/8A 0Kmh/wDguh/+JoA6Ciuf/wCEE8H/APQqaH/4Lof/AImj/hBPB/8A0Kmh/wDguh/+JoA6Cufs/wDk oes/9gqw/wDRt3R/wgng/wD6FTQ//BdD/wDE0f8ACCeD/wDoVND/APBdD/8AE0AdBXL+NPDd54j/ AOEe+xyQJ/Zut22oTecxG6OPduC4By3IwDge9WP+EE8H/wDQqaH/AOC6H/4mj/hBPB//AEKmh/8A guh/+JoA6Ciuf/4QTwf/ANCpof8A4Lof/iaP+EE8H/8AQqaH/wCC6H/4mgA8G/8AIDuf+wrqX/pb NXQVz/8Awgng/wD6FTQ//BdD/wDE0f8ACCeD/wDoVND/APBdD/8AE0AdBRXP/wDCCeD/APoVND/8 F0P/AMTR/wAIJ4P/AOhU0P8A8F0P/wATQB0Fc/4E/wCSeeGv+wVa/wDopaP+EE8H/wDQqaH/AOC6 H/4mj/hBPB//AEKmh/8Aguh/+JoA6CuX0Pw3eaZ478V65NJA1rq/2P7OiMS6+VEUbcCMDJPGCfwq x/wgng//AKFTQ/8AwXQ//E0f8IJ4P/6FTQ//AAXQ/wDxNAHQVz/jL/kB23/YV03/ANLYaP8AhBPB /wD0Kmh/+C6H/wCJo/4QTwf/ANCpof8A4Lof/iaAOgorn/8AhBPB/wD0Kmh/+C6H/wCJo/4QTwf/ ANCpof8A4Lof/iaAOgorn/8AhBPB/wD0Kmh/+C6H/wCJo/4QTwf/ANCpof8A4Lof/iaAC8/5KHo3 /YKv/wD0baV0Fc//AMIJ4P8A+hU0P/wXQ/8AxNH/AAgng/8A6FTQ/wDwXQ//ABNAFf4ieG7zxd4E 1LQ7CSCO6uvK2POxCDbKjnJAJ6Ke1dRXP/8ACCeD/wDoVND/APBdD/8AE0f8IJ4P/wChU0P/AMF0 P/xNAHQVz/h7/kOeLP8AsKx/+kVrR/wgng//AKFTQ/8AwXQ//E0f8IJ4P/6FTQ//AAXQ/wDxNAHQ UVz/APwgng//AKFTQ/8AwXQ//E0f8IJ4P/6FTQ//AAXQ/wDxNAHQUVz/APwgng//AKFTQ/8AwXQ/ /E0f8IJ4P/6FTQ//AAXQ/wDxNAB4N/5Adz/2FdS/9LZq6Cuf/wCEE8H/APQqaH/4Lof/AImj/hBP B/8A0Kmh/wDguh/+JoAr/wDCN3n/AAtP/hKPMg+w/wBif2f5e4+Z5nn+ZnGMbcd85z2rqK5//hBP B/8A0Kmh/wDguh/+Jo/4QTwf/wBCpof/AILof/iaADx3/wAk88S/9gq6/wDRTV0Fc/8A8IJ4P/6F TQ//AAXQ/wDxNH/CCeD/APoVND/8F0P/AMTQB0FFc/8A8IJ4P/6FTQ//AAXQ/wDxNH/CCeD/APoV ND/8F0P/AMTQB0Fc/wCIf+Q54T/7Csn/AKRXVH/CCeD/APoVND/8F0P/AMTR/wAIJ4P/AOhU0P8A 8F0P/wATQB0Fc/47/wCSeeJf+wVdf+imo/4QTwf/ANCpof8A4Lof/iaP+EE8H/8AQqaH/wCC6H/4 mgDn/gl/ySHQv+3j/wBKJK9Arn/+EE8H/wDQqaH/AOC6H/4mj/hBPB//AEKmh/8Aguh/+JoALP8A 5KHrP/YKsP8A0bd10Fc//wAIJ4P/AOhU0P8A8F0P/wATR/wgng//AKFTQ/8AwXQ//E0AdBRXP/8A CCeD/wDoVND/APBdD/8AE0f8IJ4P/wChU0P/AMF0P/xNAHQVz/h7/kOeLP8AsKx/+kVrR/wgng// AKFTQ/8AwXQ//E0f8IJ4P/6FTQ//AAXQ/wDxNAHQVy+ueG7zU/HfhTXIZIFtdI+2faEdiHbzYgi7 QBg4I5yR+NWP+EE8H/8AQqaH/wCC6H/4mj/hBPB//QqaH/4Lof8A4mgDoKK5/wD4QTwf/wBCpof/ AILof/iaP+EE8H/9Cpof/guh/wDiaADwJ/yTzw1/2CrX/wBFLXQVz/8Awgng/wD6FTQ//BdD/wDE 0f8ACCeD/wDoVND/APBdD/8AE0AdBRXP/wDCCeD/APoVND/8F0P/AMTR/wAIJ4P/AOhU0P8A8F0P /wATQAeMv+QHbf8AYV03/wBLYa6Cuf8A+EE8H/8AQqaH/wCC6H/4mj/hBPB//QqaH/4Lof8A4mgD oK5f4d+G7zwj4E03Q7+SCS6tfN3vAxKHdK7jBIB6MO1WP+EE8H/9Cpof/guh/wDiaP8AhBPB/wD0 Kmh/+C6H/wCJoA6CufvP+Sh6N/2Cr/8A9G2lH/CCeD/+hU0P/wAF0P8A8TR/wgng/wD6FTQ//BdD /wDE0AdBRXP/APCCeD/+hU0P/wAF0P8A8TR/wgng/wD6FTQ//BdD/wDE0AdBRXP/APCCeD/+hU0P /wAF0P8A8TR/wgng/wD6FTQ//BdD/wDE0AFn/wAlD1n/ALBVh/6Nu66Cuf8A+EE8H/8AQqaH/wCC 6H/4mj/hBPB//QqaH/4Lof8A4mgCv408N3niP/hHvsckCf2brdtqE3nMRujj3bguActyMA4HvXUV z/8Awgng/wD6FTQ//BdD/wDE0f8ACCeD/wDoVND/APBdD/8AE0AdBXP+Df8AkB3P/YV1L/0tmo/4 QTwf/wBCpof/AILof/iaP+EE8H/9Cpof/guh/wDiaAOgorn/APhBPB//AEKmh/8Aguh/+Jo/4QTw f/0Kmh/+C6H/AOJoA6Cuf8d/8k88S/8AYKuv/RTUf8IJ4P8A+hU0P/wXQ/8AxNH/AAgng/8A6FTQ /wDwXQ//ABNAHQUVz/8Awgng/wD6FTQ//BdD/wDE0f8ACCeD/wDoVND/APBdD/8AE0AV/Bfhu88O f8JD9skgf+0tbudQh8lidscm3aGyBhuDkDI966iuf/4QTwf/ANCpof8A4Lof/iaP+EE8H/8AQqaH /wCC6H/4mgA8Q/8AIc8J/wDYVk/9Irqugrn/APhBPB//AEKmh/8Aguh/+Jo/4QTwf/0Kmh/+C6H/ AOJoA6Ciuf8A+EE8H/8AQqaH/wCC6H/4mj/hBPB//QqaH/4Lof8A4mgDoK5+z/5KHrP/AGCrD/0b d0f8IJ4P/wChU0P/AMF0P/xNH/CCeD/+hU0P/wAF0P8A8TQB0Fcv8RPDd54u8CalodhJBHdXXlbH nYhBtlRzkgE9FParH/CCeD/+hU0P/wAF0P8A8TR/wgng/wD6FTQ//BdD/wDE0AdBRXP/APCCeD/+ hU0P/wAF0P8A8TR/wgng/wD6FTQ//BdD/wDE0AHh7/kOeLP+wrH/AOkVrXQVz/8Awgng/wD6FTQ/ /BdD/wDE0f8ACCeD/wDoVND/APBdD/8AE0AdBRXP/wDCCeD/APoVND/8F0P/AMTR/wAIJ4P/AOhU 0P8A8F0P/wATQB0Fc/4E/wCSeeGv+wVa/wDopaP+EE8H/wDQqaH/AOC6H/4mj/hBPB//AEKmh/8A guh/+JoA6CuX0Pw3eaZ478V65NJA1rq/2P7OiMS6+VEUbcCMDJPGCfwqx/wgng//AKFTQ/8AwXQ/ /E0f8IJ4P/6FTQ//AAXQ/wDxNAHQVz/jL/kB23/YV03/ANLYaP8AhBPB/wD0Kmh/+C6H/wCJo/4Q Twf/ANCpof8A4Lof/iaAOgorn/8AhBPB/wD0Kmh/+C6H/wCJo/4QTwf/ANCpof8A4Lof/iaAOgor n/8AhBPB/wD0Kmh/+C6H/wCJo/4QTwf/ANCpof8A4Lof/iaAC8/5KHo3/YKv/wD0baV0Fc//AMIJ 4P8A+hU0P/wXQ/8AxNH/AAgng/8A6FTQ/wDwXQ//ABNAFzxLps2s+FdX0u3aNZ72ymt42kJChnQq CcAnGT6Gjw1ps2jeFdI0u4aNp7Kyht5GjJKlkQKSMgHGR6Cqf/CCeD/+hU0P/wAF0P8A8TR/wgng /wD6FTQ//BdD/wDE0AdBXP2f/JQ9Z/7BVh/6Nu6P+EE8H/8AQqaH/wCC6H/4mj/hBPB//QqaH/4L of8A4mgDoKK5/wD4QTwf/wBCpof/AILof/iaP+EE8H/9Cpof/guh/wDiaAOgorn/APhBPB//AEKm h/8Aguh/+Jo/4QTwf/0Kmh/+C6H/AOJoAPBv/IDuf+wrqX/pbNXQVz//AAgng/8A6FTQ/wDwXQ// ABNH/CCeD/8AoVND/wDBdD/8TQB5/wCIf+TofCf/AGCpP/QbqvYK5/8A4QTwf/0Kmh/+C6H/AOJo /wCEE8H/APQqaH/4Lof/AImgA8d/8k88S/8AYKuv/RTV0Fc//wAIJ4P/AOhU0P8A8F0P/wATR/wg ng//AKFTQ/8AwXQ//E0AdBRXP/8ACCeD/wDoVND/APBdD/8AE0f8IJ4P/wChU0P/AMF0P/xNAHQV z/iH/kOeE/8AsKyf+kV1R/wgng//AKFTQ/8AwXQ//E0f8IJ4P/6FTQ//AAXQ/wDxNAHQUVz/APwg ng//AKFTQ/8AwXQ//E0f8IJ4P/6FTQ//AAXQ/wDxNAGX8KNNm0b4dWGl3DRtPZXF3byNGSVLJdSq SMgHGR6Cu0qvY2FnplnHZ2FpBaWsedkMEYjRckk4UcDJJP41YoAKKKKACiiigAooooAKKKKACiii gAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKA CiiigAooooAKKKKACiiigAooooAKKKKAPK9V/Z/8G6nqlxfJJqViJ33/AGe0ljWJD32hkJAzzjOB nAwMAd54Y8MaX4R0OHSNIg8q3j5Zm5eVz1dz3Y4H5AAAAAbFFABRRRQAV5Xr3xoW18S3Wg+G/C+p eILyyd0u/IDIEKkKdoCOzAMSpJCjIGMgg16pWP4b8LaN4R06Sw0Oz+yWskpmZPNeTLkAE5ck9FH5 UAc34C+KFj42vbrSpNOu9L1qzRnuLOcbgoV9pw2AcglchlUgtgZwTXeV4vpn2Pxp+0IviHw75Emm 6JaeTqF2uFE8zJKilMcycEDceMRnBxt3e0UAFFFFABRRRQAUUUUAFcv468daX4D0M39+fNuJMra2 iNh7hx2HooyMt2z3JAO5quq2Oh6XcanqdzHbWdum+WV+ij+ZJOAAOSSAMk188eLdKvvGPgHXfiV4 jtpLW4KQQaNZD5VhtjMmJCerlt7gFgByWAwU2gH0HoWp/wBt+HtM1byfJ+3WkVz5W7ds3oG25wM4 zjOBWhXP+BP+SeeGv+wVa/8Aopa6CgAooooAKKKKACiiigDz/wAb/FK38LaxbaFpWlT69rsvzPYW jENEm0tkkKx3Ec7QPu5JwMZr+GPi5b6prkOheItDvvDerXPNtFeg7JgeFAZlUhmO4AbcHbgEkgVy /i/VYvBXxobWtAH9u6zqVoLe+0ONXMyLsUq6MikDiJSVbLAc4wwK0/8AhIT4/wDil4Zj8V2cnhM6 W4uLGyulk8+9mZwVAdkVVTMSjkAk5UZLfKAe+UUUUAFFFFABRRRQAVw8nxN0uT4mWXgqwj+2XEnm i6uUkwlu6Iz7Bwd7fKQeRtzjJOQOk8Q6TNrmiTadBqd3pryvGTdWjlJUVXVmCsDwWUFc9t3Q9D43 F4Y0vwj+0J4M0jSIPKt49KkLM3LyuUucu57scD8gAAAAAD3C/vrfTNOub+8k8u1tYnmmfaTtRQSx wOTgA9K8ju/jrcyvf3Wg+CdS1bRbR2U6kruiEKoLMwETBAAc8nOMEgZwND9oLUprH4ZG3iWMpf3s VvKWByFAaXK89d0ajnPBP1GPbfFNfDnh+2tfCPgTWdT8N2FuUXU3jaCOQIWDyZWIgg7SxY7TktlQ RQB6Z4O8Y6X440P+1tJ89YVlaGSOdNrxuMHBwSDwVPBPX1yB0FcH8Lz4L1DS7/XfB2myWCXtwUvI nDKVkTLAbdxRRiTICcYYDtgd5QAUUUUAFFFFAHnfjX4rQ+F/EEPh7S9Eu9d1p0WRra1cfIpDHB2h m3gKG27fusDmo/DHxct9U1yHQvEWh33hvVrnm2ivQdkwPCgMyqQzHcANuDtwCSQK6D/hG9G8Jf29 4l0bQvO1e4iluJQju8ly/Mmxc7tu5uyjk44OBXkD+Kp/Gvxa8NReMtPn8MQ6fKtxptq9vKZriZ3j CIzMo+Uumd20DClc5+YAHpfj34oWPgm9tdKj0671TWrxFe3s4BtDBn2jLYJySGwFViSuDjINY+g/ GhbrxLa6D4k8L6l4fvL10S088M4csSo3AojKCwCggMMk5wATXeW/hbRrTxRd+JYLPZq93EIZ7jzX O9AFAG0naPuL0Hb615f8avsfi/U9D8DaT5E/iV7vzstgC2h8tiwd+q5G19oySEBx93IB7RRRRQAU UUUAFFFRzzw2tvLcXEscMESF5JJGCqigZJJPAAHOaAMvxP4n0vwjoc2r6vP5VvHwqry8rnoiDuxw fyJJABIp+EPF0PifwRa+J7iGPToJUleRZJwyxLG7KSXIUYwmc4GK8n1yCb4q2XiTxXqMUkfhvQ7K 7XQkVSgu5Ajbp2Y4cgFEO3AGcL1V93WfDC1s779n+1s9RuPs9jPaXsVxNvCeXG0soZtx4GAScngU AZ7/ABuv7+8uj4Y8B6rrmmQymJL6EyASEAE/KIm29cgE5wQSBnA7zwZ450Xx1pb32jyyAxPsmt5w FlhPONwBIwQMggkHkdQQPIPBHxD1nwx4fOg6D4Vu/Fml2FxIltqlhFPEsisfMwymJiHBc5HGMjr9 5ur+CC6deWeveIItWgu9X1e7FxqNtAjIloxLuqAONx++/wA3KnGATtJIB6xRRRQAUUUUAFcP48+J mneCpYNOjtJ9T1268s22nQqwMiuxUHftI6qQAMsTjjByO4r5003xdY2Hxl8Y61eaTd6p4gS4ex0q wsIN5cRh0Z+QSpCwoCy84kfCkZwAdvoPxoW68S2ug+JPC+peH7y9dEtPPDOHLEqNwKIygsAoIDDJ OcAE16pXh8/jjw7461zTvDXxC8DX2l3Usqf2eZ2kB3PleSBG6qzBV4DKT1xtzXonxA8Zr4N8P+db xx3WsXbiDTbE7i1xKSBwqjJC5yemeFyCwoAp+J/ibpfh7xbo/hiKP7bqd/dwwTIkm0WqSMAGY4OW 5BCdxySMrnuK+bNZ8GN4X8X/AA5v9Qkkm8QaxrH2vVJW2gCUzQNsVVO0BS7cjqST0wB9J0AFFFFA BRRRQBw/xE+Jul/D6ziEsf23U58GGxSTYSmcF2bB2rwQODk8AcMR3FfOnxe8BWPhPwBb3z3d3qut XepwLdanfPvlcCCQbVJ5VMrnGSegJO0Y+g7+xt9T065sLyPzLW6ieGZNxG5GBDDI5GQT0oA8nm+O j6hqNxD4S8Garr9rb4ElxFuTBJYA7VRyFIXILbSeeBiuw+H/AMRNL+IOnTzWMM9tdWmwXVvMM7Cw JBVhwy5DAHg/LyBkVuaXpekeEvD62Vkkdjpdkjv+8lJWJcl2JZyTjJJyTxXl/wANIIfEHxZ8VeN9 Gijj8PzIbKJiojaab9yzuEHIBKliWwT5g4zuwAbHij4vLpXiV9A8OeH7vxLf26M14tmzYgIIG35U csQThuAFJAyTkDQ8GfFCx8Uao+h6hp13ofiCNN7afejBccn5CQCTt2sQVU4ORkAmvP8A/hIT4A+K XiaPwpZyeLDqjm4vrK1WTz7KZXJYF1RlZMysOASDhTgr81zwhqsXjX40LrWvj+wtZ020NvY6HIri Z12MWeRnUA8SsQq4YjnGFJYA9wooooAK4Px78ULHwTe2ulR6dd6prV4ivb2cA2hgz7RlsE5JDYCq xJXBxkGu8rHt/C2jWnii78SwWezV7uIQz3Hmud6AKANpO0fcXoO31oA4PQfjQt14ltdB8SeF9S8P 3l66JaeeGcOWJUbgURlBYBQQGGSc4AJr1SvF/jV9j8X6nofgbSfIn8Svd+dlsAW0PlsWDv1XI2vt GSQgOPu59M8XeKLHwd4au9Yv5IwIkIhiZ9pnlwdsa8E5JHXBwMk8A0AYfxE+Jul/D6ziEsf23U58 GGxSTYSmcF2bB2rwQODk8AcMR3FfLnxG8L3y+BYvHHiWORPE2s6nGJICnlraweVIEjCAnnaiElvm GADghi30vquq2Oh6XcanqdzHbWdum+WV+ij+ZJOAAOSSAMk0AYfjrx1pfgPQzf35824kytraI2Hu HHYeijIy3bPckA7Ghan/AG34e0zVvJ8n7daRXPlbt2zegbbnAzjOM4FfPni3Sr7xj4B134leI7aS 1uCkEGjWQ+VYbYzJiQnq5be4BYAclgMFNvufgT/knnhr/sFWv/opaAOgooooAK8fm+Oj6hqNxD4S 8Garr9rb4ElxFuTBJYA7VRyFIXILbSeeBivWL+xt9T065sLyPzLW6ieGZNxG5GBDDI5GQT0qnpel 6R4S8PrZWSR2Ol2SO/7yUlYlyXYlnJOMknJPFAGH8P8A4iaX8QdOnmsYZ7a6tNgureYZ2FgSCrDh lyGAPB+XkDIrm9d+LupWPizVdE0LwZd+IE050SW5sZ2cBmUEhgkTbSG3Lgnqp9CBn/DSCHxB8WfF XjfRoo4/D8yGyiYqI2mm/cs7hByASpYlsE+YOM7sc54Pm+Iun6j4n1bQfBc632sah9pmi1VPJjhj zIyqhd4zIxMjAkABQg67/lAO/wDC3xH8Sa94jtNMv/h5quk2s2/fezmTZFhGYZzEo5IA6jrWh48+ JmneCpYNOjtJ9T1268s22nQqwMiuxUHftI6qQAMsTjjByMfwn8TdU/4ShvCnj3TING1qXa9k0XEM 4YcJncw3E5wQxBOV4YYbhNN8XWNh8ZfGOtXmk3eqeIEuHsdKsLCDeXEYdGfkEqQsKAsvOJHwpGcA Hb6D8aFuvEtroPiTwvqXh+8vXRLTzwzhyxKjcCiMoLAKCAwyTnABNeqV4fP448O+Otc07w18QvA1 9pd1LKn9nmdpAdz5XkgRuqswVeAyk9cbc17hQAUUUUAcf8QPiJpfw+06Ca+hnubq73i1t4RjeVAJ LMeFXJUE8n5uAcGuPh+Oj6fqNvD4t8GaroFrcZEdxLufJBUE7WRCVAbJK7iOODmvSLjwto134otP Es9nv1e0iMMFx5rjYhDAjaDtP326jv8ASuD+OGpabc+GIfCarHc+INVuIBp1sApZG8wDeSxAQEbk BzzuI6BiADvPE/ifS/COhzavq8/lW8fCqvLyueiIO7HB/IkkAEjzOD45alFbxalq3w91mz0VkDtf xlpFCsPkI3RopDEqM7h14z0Nz4i+GdOj+CmmaTr+tQabNpkVskVxhnjkuEiMe3aFLspBb7oyAN2C FIrl9b+LfifWPA09teeCZ9OtdQtFgm1mdZjaRpKAjSgCPO0hjtwzdR97oQD2j/hKtC/4Rf8A4SX+ 04P7G8rzvteTt25xjHXdn5duN275cZ4rzOH45alcodRg+Husy6CHZjqKFmAhViGfAj2ZAByN+AQR u71qf8I/4W/4Z/8A7J/4SP8A4kH2TzP7W2j73m+ZnZ1/1ny+X97+DO7muP0T4t+J9H8DQW1n4Jn1 G10+0aCHWYFmFpIkQKLKQY87QFG7LL0P3egAPaPDHifS/F2hw6vpE/m28nDK3DxOOqOOzDI/MEEg gnYrzv4K6XpGlfD6NdI1iPVBPcPLczRqVVJsKrIFYBgAFX7wBOd2AGAHolABRRRQB5Xrvxd1Kx8W aromheDLvxAmnOiS3NjOzgMygkMEibaQ25cE9VPoQLnhb4j+JNe8R2mmX/w81XSbWbfvvZzJsiwj MM5iUckAdR1rgPB83xF0/UfE+raD4LnW+1jUPtM0Wqp5McMeZGVULvGZGJkYEgAKEHXf8vb+E/ib qn/CUN4U8e6ZBo2tS7Xsmi4hnDDhM7mG4nOCGIJyvDDDAHomq6rY6Hpdxqep3MdtZ26b5ZX6KP5k k4AA5JIAyTXP/D/xxD4+0a81S3sZLSCC9e1jWSQMzqqqwc4GFJD/AHcnGOpo1/wFY+KPEtpqesXd 3c2FokZi0kv/AKK8qmQ+ZInRjh1GOOFwdwOK4v8AZx/5J5qH/YVk/wDRUVAHSePfihY+Cb210qPT rvVNavEV7ezgG0MGfaMtgnJIbAVWJK4OMg1j6D8aFuvEtroPiTwvqXh+8vXRLTzwzhyxKjcCiMoL AKCAwyTnABNd5b+FtGtPFF34lgs9mr3cQhnuPNc70AUAbSdo+4vQdvrXl/xq+x+L9T0PwNpPkT+J Xu/Oy2ALaHy2LB36rkbX2jJIQHH3cgHtFFFFABRRRQBj+J/E+l+EdDm1fV5/Kt4+FVeXlc9EQd2O D+RJIAJFfwT4n/4THwhY6/8AY/sf2rzP3Hm+Zt2yMn3sDOdueneuT8f+ArG8tPE/ijVLu7v5YdMu WsLOZ829kfs4UsiHPz7kLZ4GSDjKhqufBL/kkOhf9vH/AKUSUAZfiH42WPhf4hzeGdT0qRbOB41l 1BJ9xQPGr7vK25IBYA4YnAJAJ4r1SvnDxf4d/wCEn+LnxDsY4vMuo9ES5tgsPmv5ka2rBUHXcwBT I5+c9eh9b8H+K4ZvhDYeJLo3cyWumM9yz4aWRoFKyHk8ktGxBJ5yM4oA5/UfjZY2/wARrfwlYaVJ dhr2OxmvGn8oRytJsYKm0lgpPXIyQccYJ9Ur5U03RJtPm+GOrX3mPqGta7JeTSzxkSsvnW6puY8u DgyAn/nocdcn6roAKKKKACsvxHr9j4W8P3mtak0gtLVAz+Wu5mJIVVA9SxA5wOeSBzWpWP4k8LaN 4u06Ow1yz+12scomVPNePDgEA5Qg9GP50AeX/wDC+rzyP7U/4QLVf+Ee83H9p7zt8vfs3f6vZuzx t343cbu9eiReM7G++H0/jDTY5Li0Symu0ik/dsTGG3IeDg7lK5GRxkZHWx4u1/RfDfhq7v8AX2jN gUMTQMoc3BYEeUqHhiwzweMZJwASPL/AugX2g/s7eImv1jU6jZXd9CqtuIie2AUt2BIXOOeCM4OQ ADqPht8WbH4hXF3YnT5NP1C3TzhCZPNWSLIBYPtGCGYAgjuCCecdh4j1+x8LeH7zWtSaQWlqgZ/L XczEkKqgepYgc4HPJA5r588BW3/CN3/w08TRrOtrqv2nSrsW0W0PIZ5VjMjZAbJdODyBBkZwAPQ/ jWJtZt/DXg+1ku459b1NQ7woXUQxj5y6ggsFLo+OnyEkjAoA1Phl8Tf+Fjf2p/xKP7P+weV/y8+b v37/APYXGNnv1r0CvG/gzBDa+OviTb28UcMEWpqkccahVRRLcAAAcAAcYr2SgAooooAKKK4P4k+M 77Qre00Pw1HHd+KdVfy7S3HzNEmDmYjGMDHG4gdSchGFAEknxN0uT4mWXgqwj+2XEnmi6uUkwlu6 Iz7Bwd7fKQeRtzjJOQMv4gfF+HwD4qs9IuNGku4J7dLiS4juArIrOykBCuGICZ+8M5xx1riNI8GW PgX4+eDtIsZJJidMkmuJ34M0pS5BbGcKMKAAOgAySck3/iLokPiP4+aJo0/lhLzQpog7xiQRsUut r7T1KthhyOQORQB7ZYX1vqenW1/ZyeZa3USTQvtI3IwBU4PIyCOteZ/ED42WPgnxB/YtvpUmpXcS BrrM/krEWAZVB2tuJU5PYZHJOQND4J6lNefDe2srtbtbzSriWwuFugQysrbgoycgKrouDjG0jGAK 8M8V239seDda8cyrO39r+JRHZG7i/eJbpHMRh8nK8qm0cAwgZOOAD63ooooAKKKKAI554bW3luLi WOGCJC8kkjBVRQMkkngADnNeRv8AG6/v7y6PhjwHquuaZDKYkvoTIBIQAT8oibb1yATnBBIGcD1D XbWzvvD2p2eo3H2exntJYribeE8uNkIZtx4GAScngV4Z4I+Ies+GPD50HQfCt34s0uwuJEttUsIp 4lkVj5mGUxMQ4LnI4xkdfvMAev8AgzxzovjrS3vtHlkBifZNbzgLLCecbgCRggZBBIPI6ggcf8P/ AI2WPjbxB/YtxpUmm3cqFrXE/nLKVBZlJ2rtIUZHY4PIOAY/ggunXlnr3iCLVoLvV9XuxcajbQIy JaMS7qgDjcfvv83KnGATtJPkHhS2/sfwbovjmJZ1/sjxKY702kX7x7d44ScvkYXhk2ngmYjIzyAf V9/fW+madc395J5draxPNM+0naigljgcnAB6V538P/i/D4+8VXmkW+jSWkEFu9xHcSXAZnVXVQCg XCkh8/eOMY561Y+NmpTWfw3ubK0W7a81W4isLdbUEszM24qcHJDKjrgZzuAxgmuP+HWiQ+HPj5re jQeWUs9ChiLpGIxIwS13PtHQs2WPJ5J5NAHulFFFABUc88Nrby3FxLHDBEheSSRgqooGSSTwABzm pK5fxd4Jt/GctjFqOo30WmW+43FhbSmNLwlo2USEdVGw8Yz82QVxyAU/A/xGsfHmqa7BplrItnpr xLFcu2DcB9/zbMZUZQ4ySSCMhTxVzx1460vwHoZv78+bcSZW1tEbD3DjsPRRkZbtnuSAeD+DMENr 46+JNvbxRwwRamqRxxqFVFEtwAABwABxipPGP/E0/aJ8FaTefvbG2tHvYovu7Zh5rbsjBPMMRwTj 5enJyACfG6/sLy1PifwHquh6ZNKInvpjIRGSCR8piXd0yQDnAJAOMHrPiB8QYfBPhWz163s49Vgu 7hIo/LuQisrIzhwwVgRhfxz1q58R7G31D4a+I4bqPzI10+aYDcRh41MiHj0ZVPvjnivEPF19cah+ zL4RmupPMkXUBCDtAwkYuI0HHoqqPfHPNAHufgbxnY+OvDUesWMckJDmG4gfkwygAlc4wwwwII6g jIByBn/Eb4jWPw80u2nntZLy8u3K21srbA4XG9mfBCgBh2JJI4xkjm/h5bf8Ir8VfGfhXbOtrc7N VsUWLy4EjJ+cIuccGREyowfKOcYArn/iLbf8JV8R9fRlnax8MeGriSRJot8JuJIXZdvOFbEiMGxk mHp8oIAPWPBPif8A4THwhY6/9j+x/avM/ceb5m3bIyfewM5256d66CvP/gl/ySHQv+3j/wBKJK9A oAK5fx1460vwHoZv78+bcSZW1tEbD3DjsPRRkZbtnuSAeorxP4q+ArHTfBXinxNeXd3qerTOgglu 33LZxNdqwjhU52gK23OT0ONoYigD1zQtT/tvw9pmreT5P260iufK3btm9A23OBnGcZwK871740La +JbrQfDfhfUvEF5ZO6XfkBkCFSFO0BHZgGJUkhRkDGQQa7TwJ/yTzw1/2CrX/wBFLVjw34W0bwjp 0lhodn9ktZJTMyea8mXIAJy5J6KPyoA5vwF8ULHxte3WlSadd6XrVmjPcWc43BQr7ThsA5BK5DKp BbAzgmsfxD8bLHwv8Q5vDOp6VItnA8ay6gk+4oHjV93lbckAsAcMTgEgE8Vl6Z9j8aftCL4h8O+R JpuiWnk6hdrhRPMySopTHMnBA3HjEZwcbd3MeL/Dv/CT/Fz4h2McXmXUeiJc2wWHzX8yNbVgqDru YApkc/OevQgH0fXleo/Gyxt/iNb+ErDSpLsNex2M140/lCOVpNjBU2ksFJ65GSDjjBPQeD/FcM3w hsPEl0buZLXTGe5Z8NLI0ClZDyeSWjYgk85GcV4RpuiTafN8MdWvvMfUNa12S8mlnjIlZfOt1Tcx 5cHBkBP/AD0OOuSAfVdFFFABXD+H/ibpfijx9feGtIj+0W9naNO2oLJ8kjq6qVRcfMvzj5884OAR hjseL/C//CXaTFpkmq32n2plLXJspNjzxmN1MZPTaSwJBBB24xzkeZ+CdKsdD/aN8SaZpltHbWdv o8aRRJ0Ubbb8SSckk8kkk5JoA9srl/HXjrS/Aehm/vz5txJlbW0RsPcOOw9FGRlu2e5IB3NV1Wx0 PS7jU9TuY7azt03yyv0UfzJJwABySQBkmvnjxbpV94x8A678SvEdtJa3BSCDRrIfKsNsZkxIT1ct vcAsAOSwGCm0A9j1nx1/ZHwvj8af2d5u+0trn7H5+3HnFBt37T039dvOO1R/Dn4jWPxD0u5ngtZL O8tHC3NszbwgbOxlfADAhT2BBB4xgnk/GX/Jr1t/2CtN/wDQoax/h1bf8Ir8R9ARVnWx8T+GreSN IYtkIuI4UZt3OGbEbsWxkGbp8xJAPVPHPjOx8C+GpNYvo5JiXENvAnBmlIJC5xhRhSST0AOATgGn 8OPHX/CwPD1xq39nfYPJu2tvK8/zc4RG3Z2r/fxjHauX+Idt/wAJV8VfBnhXbO1rbb9VvkaLzIHj B+QOuccmN0ywwPNGM5Iqv+zj/wAk81D/ALCsn/oqKgD2CiiigAooooAKKKKACiiigAooooAKKKKA CiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK KKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK8b8XeMrbxj4lu/BcGv2mhaHaOY9Z 1C4uUgluCCQ1vAHIOMghmxjr/DgSeyV5/wD8KS+Hn/Qvf+Ttx/8AHKANDwXL4H0PTrXw54Z1nSpm 5IjhvYpZp3xlnbacs2Bk8cAYAAAA7CuP0T4W+DfDmsQatpOjfZ76Dd5cv2qZ9u5Sp4ZyDwSORXYU AFFFFABRRRQAUUUUAeb/ABX8C+IPG39iDRL2xhjsJZJpYb5mMcj/ACbCU2Mr4w4+YdGI5BNcB8RN G+K1p4E1KfxL4m0q90hfK+0QQRqHfMqBcEQr0baeo6fhX0PWfreiad4j0efSdWt/tFjPt8yLeybt rBhypBHIB4NAHL/CW3123+Hmm/25ewXXmRRSWPkgDyrUxJ5aN8q/MOc9evU13FV7Cxt9M062sLOP y7W1iSGFNxO1FACjJ5OAB1qxQAUUUUAFFFFABRRRQB4f4T1mz8I/GbxjD4vf7DeanL5un3t6RsNu GchRKT8qldgAzj93tOGULUfxj8Q6b4rfw9oXhG5j1TxJ9tFxbT6c6uYFCsCPNU/ISwVjg8CPc2AF J9Y8S+D9A8YW8EGvabHeJA5eIl2RkJGDhlIODxkZwcD0FV/DXgHwv4QuJ7jQtJjtZ50CSSGR5G2g 5wC7EgZwSBjOBnoKAOkooooAKKKKACiiigArx/xD/wAnQ+E/+wVJ/wCg3VewVj3HhbRrvxRaeJZ7 Pfq9pEYYLjzXGxCGBG0Hafvt1Hf6UAcX8d9Em1j4ZXE0HmF9OuI7wxpGXLqAUbp0AWQuTzgKfqNj SviX4Ffw1b3tvrem2NolvlbN5EjlhVRjZ5IOcjGAFBzgbcgjPaVw998H/AOoXkl1N4cgSR8ZEEsk KDAA4RGCjp2HPXrQByfwKtGlvfGGvWunSWei6peq2nBkWMFFeUlVUHACh1XjjIIBODj2So4IIbW3 it7eKOGCJAkccahVRQMAADgADjFSUAFFFFABRRRQB53bfFrTYPHmqeFfENtHoktq5FvdT3StFOuN wLNgCMshVgCT1IJBwDx/xj1XRfHb+HvCvh25tNT1q4vQ6T22JkgiKsrbpEyQM4YgZwI8nGFz6p4k 8D+GvF3lnXNIgu5I8BZstHIAM4XehDbfmJ25xk5xmjw34H8NeEfMOh6RBaSSZDTZaSQg4yu9yW2/ KDtzjIzjNAHN/En4gt4duLTw5pM9pBr2pJuS6vpFit7KIkgyuzcE/K2F55HIPCtT8EWvw78Ffabq PxjpWoavec3eo3epQtJITgsB83yqWy2Mkk4yWwMdBrfwt8G+I9Yn1bVtG+0X0+3zJftUybtqhRwr gDgAcCs//hSXw8/6F7/yduP/AI5QB6BRRRQAUUUUAFcP8VfCOseNvCUekaNeQW0hu0ln8+V0SSNV b5TtU5+YocEY+XPUCu4ooA8H13w18X9P8G6nHeeJ9DOkW+nyia1t4ETMCxnciAW4x8oIGCMeoqh4 U0nxje/s86zFa3P2q1uolGl2lpxMiLcP9pU4UFtw3fLlsjIA5wff7+xt9T065sLyPzLW6ieGZNxG 5GBDDI5GQT0qvomiad4c0eDSdJt/s9jBu8uLez7dzFjyxJPJJ5NAHB/DTx74NX4faPajV9N02W0t 0t57e6mjt281QN7AEjcGYltw67jnnIGH8M7r+3/jD4u8R6Hbzx+GbiIReZs8qOa4Hl/Nt7scSvnG QJPmwXwe01X4TeB9a1S41K/0GN7u5ffK6Tyxhm7najAZPUnHJyTyTXUaVpVjoel2+maZbR21nbps iiToo/mSTkknkkknJNAFyiiigAooooAK8T8M3mi+AvjT4ws9euI7WXVnW7sb+6iEUexy0joJGPA3 MFznDGI9DgV7ZWP4h8K6F4rsxa65pkF7Gv3C4IePJBO1xhlztGcEZxg8UAeP/GrWdH8axaH4a8Mv BrWuy3fmxNZFJRHHtYMpkBwuTtYjOAI9zYABOx4p+Hvj28+Jl34r8O61pVtmJIbU3mZHgTYoYKrR OqZbefl/vN/eNd54a8A+F/CFxPcaFpMdrPOgSSQyPI20HOAXYkDOCQMZwM9BXSUAfMnjvSviRbeK vB0XiDxBpt3qE16V0qWGMBYJd8XzPiJcjcYz0boePX6P0mO+h0axi1SaOfUEt41upYxhXlCjew4H BbJ6D6CqeseFtG17UdLv9Ts/PutLl86zfzXXynypzhSAeUXrnpWxQAUUUUAFFFFAHj/7R3/JPNP/ AOwrH/6Klr2CsfxJ4W0bxdp0dhrln9rtY5RMqea8eHAIByhB6MfzrQv7G31PTrmwvI/MtbqJ4Zk3 EbkYEMMjkZBPSgDxPVfFGlfFjVLjT7zxNaaF4MtH2kPeRwXWpSjkNtflYlOCMjk44z/q/VPDGoeE 0s4dE8MajpUsNpFlLWyuklKIDyxAJJ5PLHqWyTk1z/8AwpL4ef8AQvf+Ttx/8crY8N/Dvwr4R1GS /wBD0r7JdSRGFn+0SyZQkEjDsR1UflQB5n8HPEOm+FH8Q6F4uuY9L8SfbTcXM+ouqGdSqgDzWPzk MWYZPIk3LkFiJPFms2fi74zeDofCD/brzTJfN1C9siNgtyyEqZQfmULvBGcfvNoyzFa9M8S+AfC/ i+4guNd0mO6ngQpHIJHjbaTnBKMCRnJAOcZOOpqx4a8H6B4Pt54NB02OzSdw8pDs7OQMDLMScDnA zgZPqaANyiiigArzv4k/EFvDtxaeHNJntINe1JNyXV9IsVvZREkGV2bgn5WwvPI5B4VvRK+SPi9Y 3Gp/G/U7Czj8y6upbWGFNwG52hiCjJ4GSR1oA9n8EWvw78FfabqPxjpWoavec3eo3epQtJITgsB8 3yqWy2Mkk4yWwMR/EXwD4v8AEfjXSte8PanptumnW4EKXxZxHNuYl1QxumcFOeuVH90GvFP+FJfE P/oXv/J23/8AjlbkmmfHDw08OotJ4gmKvsVFuxfjJU/eiDOCMZ5K4Bx3xQBY+LOlfEix8K2svjDx Bpuoaeb1FjitYwrCXY+GOIk42hh17jj07vxf8PfHvivw54Zt7rWtKn1PTpZ5r1ps+RO5cGI+WItr bUyDuXuRzk1z/g/4haN8UIrfwn8Q7SCS481JLKdHeFLiUKVw21hiQ7mxjCtuwACFDfQFAHzx8RNG +K1p4E1KfxL4m0q90hfK+0QQRqHfMqBcEQr0baeo6fhXp/wlt9dt/h5pv9uXsF15kUUlj5IA8q1M SeWjfKvzDnPXr1NdRreiad4j0efSdWt/tFjPt8yLeybtrBhypBHIB4NWLCxt9M062sLOPy7W1iSG FNxO1FACjJ5OAB1oAsUUVn67qf8AYnh7U9W8nzvsNpLc+Vu279iFtucHGcYzg0AaFeF6r4o0r4sa pcafeeJrTQvBlo+0h7yOC61KUchtr8rEpwRkcnHGf9XqfCjxjqnxPi8V23iTyHsTFBCtpAnloiSL IsgBzv8AmCjqxx2xXQf8KS+Hn/Qvf+Ttx/8AHKAOg8Mah4TSzh0TwxqOlSw2kWUtbK6SUogPLEAk nk8sepbJOTXL+F/jFo+rajqWleII4PDmp2ErRvFd3iNG+07WxLhV3Bsjb6YIJ5x0Hhv4d+FfCOoy X+h6V9kupIjCz/aJZMoSCRh2I6qPyo8Q/Drwj4qvBeaxokE90OsyM8TvwB8zIQWwFAG7OO2KAPO/ F2q2Pj34veC9M8OXMd8dGuDfXlzD88CJuifAdcgnEeM9NzqM5zg8M3mi+AvjT4ws9euI7WXVnW7s b+6iEUexy0joJGPA3MFznDGI9DgV6p4e8K6F4Usza6HpkFlG33ygJeTBJG5zlmxuOMk4zgcUeIfC uheK7MWuuaZBexr9wuCHjyQTtcYZc7RnBGcYPFAHj/xq1nR/GsWh+GvDLwa1rst35sTWRSURx7WD KZAcLk7WIzgCPc2AAT7xXN+GvAPhfwhcT3GhaTHazzoEkkMjyNtBzgF2JAzgkDGcDPQVz/xf+IE3 gTw1CNP8v+1tQdorYupIiVR88mMYJXKgA92BwQCCAeiUV8qWfw9+JfxMSDVNTuZDaTI9xbT6pdEJ 8zDIjjXcUDcEYUKQBjjbmxP8GviN4Qt5dU0a+jknCFZF0i8kSfy8bj1VCwyo+UEknGAaAPb/AIje PofA+l2yxRRz6tqDmKximcRxbhgF5HJAVF3LnJGcjkDLLy/gyx8E6Fqj+Jdc8b6Nq/im6TNxeS6j CUiY5BEK5G0bcLn0XACgla4zwHrnh34qa5Dpnj/Tft2viJo7O+SSSITRrukMbLEVVWXLENjBHBwQ N3f678EvBv8Awj2p/wBkeHv+Jn9kl+x/6bN/rth2fek2/ex149aAMv42yM6eDte8mTUfC9pei5vx AVlikQtGUJXO1gy+YoJ4+fGRu57DVfiX4FTw1cXtxrem31o9vlrNJEklmVhjZ5JOcnOCGAxk7sAH HN/B/wAL+LtI07WdO8aQzyWMsUEFpbXd2lzGIwJFdAoZgq4KDHAIx6VuQfBj4fW1xFOnh2MvG4dR JczOpIOeVZyGHsQQe9AHjn9ieKf+GbMfZ777P/av23yt5/48fLzu2Zz5fmfPjH+3jHzV7XpXxL8C v4at7231vTbG0S3ytm8iRywqoxs8kHORjACg5wNuQRntK4Of4MfD65uJZ38Oxh5HLsI7mZFBJzwq uAo9gAB2oA5v4FpcTy+LNWt7Oe08PahqHm6XC4CIBuk3bUBwMAxqSOPlwCdvHsFRwQQ2tvFb28Uc MESBI441CqigYAAHAAHGKkoAKKKKAPN/C/xi0fVtR1LSvEEcHhzU7CVo3iu7xGjfadrYlwq7g2Rt 9MEE845vxdqtj49+L3gvTPDlzHfHRrg315cw/PAibonwHXIJxHjPTc6jOc49E8Q/Drwj4qvBeaxo kE90OsyM8TvwB8zIQWwFAG7OO2K0PD3hXQvClmbXQ9Mgso2++UBLyYJI3Ocs2NxxknGcDigDYrx/ 9nH/AJJ5qH/YVk/9FRV7BWP4b8LaN4R06Sw0Oz+yWskpmZPNeTLkAE5ck9FH5UAcn8SfiC3h24tP Dmkz2kGvakm5Lq+kWK3soiSDK7NwT8rYXnkcg8K1PwRa/DvwV9puo/GOlahq95zd6jd6lC0khOCw HzfKpbLYySTjJbAx0Gt/C3wb4j1ifVtW0b7RfT7fMl+1TJu2qFHCuAOABwKz/wDhSXw8/wChe/8A J24/+OUAegUUUUAFFFFAHP8Ajv8A5J54l/7BV1/6Kauf+CX/ACSHQv8At4/9KJK7i/sbfU9OubC8 j8y1uonhmTcRuRgQwyORkE9Kr6JomneHNHg0nSbf7PYwbvLi3s+3cxY8sSTySeTQB5f4e/5Oh8Wf 9gqP/wBBta801KS+8OaX4m+FVpDG895rtutlHMcyyxPyrFwQgJ8u264/1jcf3fpO38LaNaeKLvxL BZ7NXu4hDPcea53oAoA2k7R9xeg7fWq914H8NX3iiDxLc6RBJq8O0pcEt1UYViudrMOzEEjC4Pyj AB5n8SdNh0bxV8I9Lt2kaCyvUt42kILFUe2UE4AGcD0Fe2Vj6x4W0bXtR0u/1Oz8+60uXzrN/Ndf KfKnOFIB5ReuelbFABRRRQAVl+I9fsfC3h+81rUmkFpaoGfy13MxJCqoHqWIHOBzyQOa1Kx/Enhb RvF2nR2GuWf2u1jlEyp5rx4cAgHKEHox/OgDyPSm8PePNUt/Fnj/AMTaNGEffp2gf2lD5VtF284E 5Z2O1iOPugNx8i+keKdW03Wfhp4nuNL1C0voF0y7RpLWZZVDeSxwSpIzgg49xWX/AMKS+Hn/AEL3 /k7cf/HK6DSvBPh3RPD17oGnaf5OmX3mfaIPOkbfvQI3zFiwyoA4IoA8c/sBte/ZUsWiWRp9Oea+ RVZVBCTyhy2eoEbOcDByB16G/wCAtSm+JHxgj8UyrH5Gi6PDHvtgUX7RJGdyMrksQGkuACOPkXk/ xewaX4c0jRvD66DZWMa6WqOn2aQmVSrklgd5JIJY8HPWq/hrwfoHg+3ng0HTY7NJ3DykOzs5AwMs xJwOcDOBk+poA87+EH/JQ/id/wBhUf8Ao24r2CsfR/C2jaDqOqX+mWfkXWqS+deP5rt5r5Y5wxIH Lt0x1rYoAKKKKACvE5vhz8S7HxrrviDQfEGjW76lcOVkuMyyiHcSiZeFtoC7RhTj5V67Rj2yigD5 k1XSviQnxl0O0u/EGmyeKHsmazvVjHlRxYmyrDygM4En8J+8OfTu/EP/ACdD4T/7BUn/AKDdV6Rc eFtGu/FFp4lns9+r2kRhguPNcbEIYEbQdp++3Ud/pRceFtGu/FFp4lns9+r2kRhguPNcbEIYEbQd p++3Ud/pQB4J4y1Kb4d+KviHparH5HiWyW4tmuAXaRpH2uF2EBQBJc43D/lmvX+LQ+J+gN4X+AHh fR5VkWeC9iadHZWKSvHM8i5XggMzAYzwByetex694H8NeJ9Rs7/WdIgvLq04idyw4znawBAdc/wt kcnjk5seJPC2jeLtOjsNcs/tdrHKJlTzXjw4BAOUIPRj+dAGxRRRQAUUUUAcf8U7HVNS+Get2mjR zy30kShY4Gw7oHUyKPXKBhtH3s4wc4rD+Gnj3wavw+0e1Gr6bpstpbpbz291NHbt5qgb2AJG4MxL bh13HPOQPTK4vVfhN4H1rVLjUr/QY3u7l98rpPLGGbudqMBk9SccnJPJNAHF/DO6/t/4w+LvEeh2 88fhm4iEXmbPKjmuB5fzbe7HEr5xkCT5sF8HE+GGgN4o+AHijR4lkaee9laBEZVLypHC8a5bgAsq g5xwTyOte76VpVjoel2+maZbR21nbpsiiToo/mSTkknkkknJNU/DfhbRvCOnSWGh2f2S1klMzJ5r yZcgAnLknoo/KgDwTwbqU3xE8VfDzS2WPyPDVk1xctbgo0bRvtQNvJDAiO2ztH/LRun8PZ+Hv+To fFn/AGCo/wD0G1r0DQfA/hrwxqN5f6NpEFndXfEroWPGc7VBJCLn+FcDgccDFi38LaNaeKLvxLBZ 7NXu4hDPcea53oAoA2k7R9xeg7fWgDYooooAKKKKAPH/AIQf8lD+J3/YVH/o24qP4nTL4S+LPg7x tdCR9PCPYXBEbbYB843lgDk7ZnYLjJ8o468emaP4W0bQdR1S/wBMs/IutUl868fzXbzXyxzhiQOX bpjrVzVdKsdc0u40zU7aO5s7hNksT9GH8wQcEEcggEYIoA8/+JfxG8M23w+1iGy1nTdRu7y3ezit 7W7WRiZAVLHbuwFUlucA4AyCRXAfELRJvD37OnhPTrjzPPW9jlkWSMxtG0kc8hQqeQVL7fw6DpXq +lfCbwPouqW+pWGgxpd2z74neeWQK3Y7XYjI6g44OCOQK3PEnhbRvF2nR2GuWf2u1jlEyp5rx4cA gHKEHox/OgDzf4qf8Ut8RfBvjs8WsUp0+9kk+ZIo23chV+Ytsec5GR8i8djj+BrG4ufhL8QfF17H 5d14givZtqMPLKKknKjkj53lHzHoo+p9k1/w5pHinS203WrGO7tC4fYxKlWHQqykFT1GQRwSOhNE PhzSLbw0fDsFjHFpJt2tjbISoMbAhhkHOTk5bOSSTnPNAHJ/BL/kkOhf9vH/AKUSV6BWfomiad4c 0eDSdJt/s9jBu8uLez7dzFjyxJPJJ5NaFABXn/xt/wCSQ67/ANu//pRHXoFZ+t6Jp3iPR59J1a3+ 0WM+3zIt7Ju2sGHKkEcgHg0AZ/gT/knnhr/sFWv/AKKWvO/F3jK28Y+JbvwXBr9poWh2jmPWdQuL lIJbggkNbwByDjIIZsY6/wAOBJ65YWNvpmnW1hZx+Xa2sSQwpuJ2ooAUZPJwAOtcP/wpL4ef9C9/ 5O3H/wAcoA0PBcvgfQ9OtfDnhnWdKmbkiOG9ilmnfGWdtpyzYGTxwBgAAADj/D3/ACdD4s/7BUf/ AKDa12GifC3wb4c1iDVtJ0b7PfQbvLl+1TPt3KVPDOQeCRyK2Lfwto1p4ou/EsFns1e7iEM9x5rn egCgDaTtH3F6Dt9aAPmzUpL7w5pfib4VWkMbz3mu262UcxzLLE/KsXBCAny7brj/AFjcf3e/+JOm w6N4q+Eel27SNBZXqW8bSEFiqPbKCcADOB6CvTLrwP4avvFEHiW50iCTV4dpS4JbqowrFc7WYdmI JGFwflGLGseFtG17UdLv9Ts/PutLl86zfzXXynypzhSAeUXrnpQBsUUUUAFeP+Hv+TofFn/YKj/9 Bta9grHt/C2jWnii78SwWezV7uIQz3Hmud6AKANpO0fcXoO31oA4/wCK/gXxB42/sQaJe2MMdhLJ NLDfMxjkf5NhKbGV8YcfMOjEcgmuA+ImjfFa08CalP4l8TaVe6QvlfaIII1DvmVAuCIV6NtPUdPw r6HrP1vRNO8R6PPpOrW/2ixn2+ZFvZN21gw5UgjkA8GgDxfU7fXbf9l67/ty9guvMis5LHyQB5Vq Wt/LRvlX5hznr16mjxzY3Ft8Jfh94uso/MuvD8VlNtdh5YRkj5YcE/OkQ+U9GP1HsF74W0bUPC6+ Grqz8zSFijhFv5rjCRlSg3A7uNq9+cc1JN4c0i58NDw7PYxy6SLdbYWzksBGoAUZJzkYGGzkEA5z zQB5n8K/+Kp+IvjLx2ObWWUafZSR/Kksa7eSrfMG2JAcnA+duOwP2cf+Seah/wBhWT/0VFXpmgeH NI8LaWum6LYx2loHL7FJYsx6lmYksegySeAB0AqPw34W0bwjp0lhodn9ktZJTMyea8mXIAJy5J6K PyoA2KKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACi iigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKK KACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoooo AKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigA ooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK+YPGX/ACdDbf8AYV03/wBB hr6fr5g8Zf8AJ0Nt/wBhXTf/AEGGgD6fooooA+bPj74XXw94l07xTo8clob12M0lujII7lCGEm8H Adgc4GDmNm5JJr3vwprP/CQ+EtJ1cvA8l3aRyy+QcoshUb1HJxhtwwTkYwea83/aO/5J5p//AGFY /wD0VLXQfBL/AJJDoX/bx/6USUAc38TPjevhbVBo/hyK0vr+ByLyWcM0UR/55jawJfPU5wuMcnO3 gIPHPxtureK4t4tZmglQPHJHoiMrqRkEERYII5zXo+m/B/QfCHjFvGOqeI5J7O3czKNU2cTNgeZL Mxwx3MSPlU7ivJI56zU/ip4G0jyvtPiaxk83O37IxucYxnPlBtvXvjPOOhoA8v8Ahp8c9U1HXLDQ PE0cE/2yUQx6gi+W4dt20Migq2WKIMBcdTnk1ofG/wCI+seHNRk8L2dtYvY6lpR86SZHMi+YZI22 kMAOAMZB5ryz4ueKtF8YeNTqehwyLAtusEsrxCMzurN+89SCuwAtg4ABAxX1H47/AOSeeJf+wVdf +imoA+UPAvxH1j4f/b/7JtrGb7d5fmfa0dsbN2MbWX++eue1fYeq6rY6Hpdxqep3MdtZ26b5ZX6K P5kk4AA5JIAyTXhf7Mv/ADNP/bp/7Wr1zxz4Qh8ceGpNGn1C7skZxIHt2GGYA7Q6n76BiG25HKjk YoA8M1n46+MfEesPp/hCy+zRvKTarDa/aLuRFU5DA7l55YhV4xjJAJOfdfEz4v6D5F7q/wBugtRK oxfaSkUcp67C3lqeQD0IOM4Ir2PwZonhX4S6W+k33iPTV1C6f7RNNdyxW7yLyqAKWzsGDjJPJcjG cCPXPjR8PbazvbaXUP7UxuhktILVpBMCdrAFgI2XBP8AFgjpnIyAXPhd8Rl+IWjXMs1rHa6hZOiX EUbMysGXiQZHAZg425YjbyeRXeV8wfs4/wDJQ9Q/7BUn/o2Kvp+gAr5o/aRsbiPxlpN+0eLWbT/J jfcPmdJHLDHXgSJ+fsa+l6x/E/hjS/F2hzaRq8Hm28nKsvDxOOjoezDJ/MgggkEAr+D/ABP4f8Ta HbzeHp4Ps8USA2ibUe1HIVGjH3MbSB2OOCRzXQV80ax+z54p0WVL3w5qsGoSQbJI9pNrOJA38GSV GOG3FweDgZAzlzeLfi58PHEeqzakLdbhSzahGLmKViobYJznIKr0Rxj5uhzQB6vN8GFX4mjxjp2v SWI+2reNaJbsSxyDKvmeZnDnfnjADkYxxXoHiXUptG8K6vqlusbT2VlNcRrICVLIhYA4IOMj1Fef /Dn41WPjS/t9Fv7GSx1iVGKeX88ExVAzYPVCcOdpyAF+8ScV2njv/knniX/sFXX/AKKagDj/AIP/ ABH1j4gf2z/a1tYw/YfI8v7Ijrnf5mc7mb+4OmO9cv8AET41+JPCPjvUtDsLLSpLW18rY88Uhc7o kc5IkA6se1V/2Zf+Zp/7dP8A2tX0BQB8wf8ADR3jD/oG6H/34m/+O0f8NHeMP+gbof8A34m/+O16 v8XviR/wg2hpbabNAddvOIUf5jBHzmYrjBwRgBsAnn5grCuL+CXw5murhvG3ie2kmnlcTad9pcsz sSS1w6kZJJwUJPq2PuNQB7hquq2Oh6XcanqdzHbWdum+WV+ij+ZJOAAOSSAMk188a78dvFfiTVE0 /wAF6dJaAuTEEgFzdTBdx+7gqBtwSoBIKn5iK6f9pDW5rTw1pGjReYqX9w8srrIVBWID5GX+IFpF bk8FBx6YHw++K3gHwL4ahsYNI1k38qK9/cCGJjNLjnBMgOwEkKMDA56kkgGXD8Xfid4U1G3m8TWk 8trNkC31DTxa+YAVLFGVFO4DjPzAbuQeK938C+OtL8eaGL+wPlXEeFurR2y9u57H1U4OG747EEDz ++/aA8B6nZyWd/oeq3drJjfDPaQSI2CCMqZMHBAP4VwnwP1uHTvizNp2m/a20vVEniiWeQKyqmZI 3kVflZwqFeMY3tg9iAfUdFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRR RQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFF ABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUA FFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAU UUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRR RQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFF ABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUA FFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXzB4y/5Ohtv+wrpv8A6DDX0/XyZ8V9Sm0b473+ qW6xtPZXFpcRrICVLJDEwBwQcZHqKAPrOivmD/ho7xh/0DdD/wC/E3/x2o5/jL8RvF9vLpejWMcc 5QtI2kWcjz+XjaerOVGWHzAAg4wRQBuftH+J0nvNM8MW0+77Pm7u0G0gORiME/eDBS5I44dTzxj1 vw5bQ+A/hbZrdWskI0vTDcXcEbCRhIEMkwBJwSW398c8YFeV/Cz4P6pJrkfivxis8U0cq3VtbSyZ mllOHEspzkYJztPzFgd2AMN7pq2mw6zo19pdw0iwXtvJbyNGQGCupUkZBGcH0NAHyxoGgeI/jl4x v9Q1DUY4I4EHnzldy26nd5cUce4HGQ3fsxJLH5vR9N/Zs0GK3ZdU1zUrmfeSr2qpAoXA4KsHJOc8 57jjjnzAQeP/AILay9wsUltBM6o8gXzbS7AYlQT0BIViB8sgUn7ua3P+F2fEnxP/AKFodhAl0n71 jplg80mwcHKuXAXLDnHXHPqAc38W9A0Dwt4xi0XQFkCWtlEt35jMzNOcsWJPGShjPy4XngDkV9R+ O/8AknniX/sFXX/opq+TPHfgzWvCF7Ytrskk15qVubuaQ5cCUu25DJkh3A2liO79xgn631aNfFng W+i0uaNk1bTJFtZZAyqRLEdjHjIHzA9M+1AHjf7Mv/M0/wDbp/7WrrPjl45vvCXhq0sdKlkt7/VH dBcIOYokA37TnKuS6AHBwNxGCAa8M8OeLvFPwk1zVLGOzgjun2xXVpexFgGXJVgVYHoxwQdpDZ54 I9r+KvhK7+J3grQdb8PQySXaItxDbTSJGXhnVSQc8bxhD94DAbqcUAcB4R/Z/vvEfhq01i/1uPTj doJoYFtvPPlMAVZjvUAkHOOcDGTnIHdn4D+AtBim1bUrnVbixs4nmnjnnGzYqkkny0V+Bz8p7d+l eWaJ8W/HXgO3/sG6hjkFsiJHbarbOJLdcZAGCrYIYYDZwAuMCtiC7+JfxnuItPuDJY+HbpxLJLHa mO1VUO04Y/NKdwzs3n5vQLlQCP8AZx/5KHqH/YKk/wDRsVfT9fLnwAmXSvilc2F+JLe7msprVIZI 2Dearo7IRj5SFjfrjpjrxX1HQAV4v4y+L+t+EfiguhXNnYw6EJbctdTW8pkMDBfMdSGw2DvAwp5X GCQa9orzP4v/AAzbx1pcN9phjTWrFGESsFUXKHnyy3UEHJUk4BLA43bgAemUV8qeF/i94v8Ah+6a HrNlJd2lqioLK+VoZ4F2kqFcjIHzKcMG+UALtFdJfftL3klnIth4YggujjZJPeGVF5GcqEUnjP8A EPXnpQBy/wAX9Gs/AnxOtLnw4n2Jmii1GNFAKQzCR/uKRgLlAdpyBkgcYA+j/Hf/ACTzxL/2Crr/ ANFNXhnwy8A+I/GXjGLxv4mlu4YIriO8SaZNsl5IMOmwEYEQG3kDGMKvcr7n47/5J54l/wCwVdf+ imoA8f8A2Zf+Zp/7dP8A2tXrHjrx1pfgPQzf35824kytraI2HuHHYeijIy3bPckA+T/sy/8AM0/9 un/tavNPitr994g+I2rtfNHixuJLG3VF2hYo5GAHqSTkknuTjAwAAdh8M/AOr/EXxKfGXieWSXTx cCVnnQMb6RT9wKRjyhjaeMYGxR12/TdfKmlfHnxDoel2+maZonh+2s7dNkUSQTYUf9/ckk5JJ5JJ JyTVz/ho7xh/0DdD/wC/E3/x2gDp/wBpexuJNO8O36x5tYZZ4ZH3D5XcIVGOvIjf8vcVofDz4c/D jxd4G0zVP7F866MQivCbyUMJ1GHyqyYXJ+YDj5WU4Ga7TUNEh+J3wtsYdU8uCfUbKC7WaKMN9nmK B9yBsnGSQRnJUkZGc14BDJ8Q/gnqhZ4ZFsHdl2uWlsbhmyA3ykAORHkfdfCjIwSCAe5/8KS+Hn/Q vf8Ak7cf/HKz/BmjfCSPxHHdeFZbE6vayywxBb+UuzBCHKI7/vF2lvmAK9SDxXkGs/F/xx4705/D ltZwI13kPHpVvKZpkAJZPvMdpHJwOQCCcZB9T+CvwxvvBqXmsa7HHFql0nkRwK+4wRBstuKkqSxC njOAo55IAB65RRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAB RRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFF FFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUU UAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQ AUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAB RRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFF FFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUU UAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQ BT1LSdN1m3W31TT7S+gVw6x3UKyqGwRkBgRnBIz7mqdj4T8N6ZeR3lh4f0q0uo87JoLKON1yCDhg MjIJH41sUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUU UUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRR QAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFA BRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUU UUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRR QAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFA BRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUU UUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRR QAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFA BRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUU UUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRR QAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFA BRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUU UUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRR QAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFA BRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUU UUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRR QAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFA BRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUU UUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRR QAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFA BRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAH//Z --089e0102e6dab1cc7204f3cfb87e Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Disposition: inline _______________________________________________ Xen-devel mailing list Xen-devel@lists.xen.org http://lists.xen.org/xen-devel --089e0102e6dab1cc7204f3cfb87e-- From xen-devel-bounces@lists.xen.org Wed Mar 05 06:36:38 2014 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Wed, 05 Mar 2014 06:36:38 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WL5R8-0000aG-QH; Wed, 05 Mar 2014 06:36:14 +0000 Received: from mail6.bemta5.messagelabs.com ([195.245.231.135]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WKyL3-0007Pn-0y for xen-devel@lists.xen.org; Tue, 04 Mar 2014 23:01:29 +0000 Received: from [85.158.139.211:32911] by server-2.bemta-5.messagelabs.com id CB/41-23037-84B56135; Tue, 04 Mar 2014 23:01:28 +0000 X-Env-Sender: xisisu@gmail.com X-Msg-Ref: server-16.tower-206.messagelabs.com!1393974086!7716848!1 X-Originating-IP: [74.125.82.47] X-SpamReason: No, hits=1.2 required=7.0 tests=HTML_20_30,HTML_MESSAGE, ML_RADAR_SPEW_LINKS_14,RCVD_BY_IP,spamassassin: X-StarScan-Received: X-StarScan-Version: 6.9.16; banners=-,-,- X-VirusChecked: Checked Received: (qmail 10889 invoked from network); 4 Mar 2014 23:01:26 -0000 Received: from mail-wg0-f47.google.com (HELO mail-wg0-f47.google.com) (74.125.82.47) by server-16.tower-206.messagelabs.com with RC4-SHA encrypted SMTP; 4 Mar 2014 23:01:26 -0000 Received: by mail-wg0-f47.google.com with SMTP id x12so254859wgg.18 for ; Tue, 04 Mar 2014 15:01:26 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20120113; h=mime-version:in-reply-to:references:from:date:message-id:subject:to :cc:content-type; bh=WQVTQKLAiqYw2LYHeQKp6njlGHaoJdnbpvzBSzZHXqo=; b=NUAgZYau5k6v7SCjjRZOSFtE/3PZbC/OXgERokKWvwhl9D5mxWR4uC/lrIyFJ23zw0 QvSFLW9ZkyBDJs05/58yjJ4fKZAKvk2zr/49VGATya45GSipjzBRmawAmRVRtbgIZhD/ ZfnAIE9yusEnDJzuGqDBkUIE4YZX3N/BwSDlIell09Jnp2yTM4nxbLtzaav8SdwyOuGi vyDvvV5H0JJLg5JYkiqMuBd28b8TwYXPCIS6wVe3EkvyeHZ4pGoqhkRPgfcr7ItEqjo9 YoJMlsnaBESAfLV9+ddfWP4W8W3wPeCKQbzHUB9dsQddn41pHqKn/ENduHIavkHNx3dc B4Nw== X-Received: by 10.195.13.103 with SMTP id ex7mr3202078wjd.3.1393974086342; Tue, 04 Mar 2014 15:01:26 -0800 (PST) MIME-Version: 1.0 Received: by 10.227.137.6 with HTTP; Tue, 4 Mar 2014 15:00:46 -0800 (PST) In-Reply-To: References: From: Sisu Xi Date: Tue, 4 Mar 2014 17:00:46 -0600 Message-ID: To: xen-devel Content-Type: multipart/mixed; boundary=047d7bfceb1a3e3aba04f3cfe2e9 X-Mailman-Approved-At: Wed, 05 Mar 2014 06:36:12 +0000 Cc: Meng Xu Subject: Re: [Xen-devel] memory performance 20% degradation in DomU -- Sisu X-BeenThere: xen-devel@lists.xen.org X-Mailman-Version: 2.1.13 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Sender: xen-devel-bounces@lists.xen.org Errors-To: xen-devel-bounces@lists.xen.org --047d7bfceb1a3e3aba04f3cfe2e9 Content-Type: multipart/alternative; boundary=047d7bfceb1a3e3aad04f3cfe2e7 --047d7bfceb1a3e3aad04f3cfe2e7 Content-Type: text/plain; charset=UTF-8 Hi, all: I also used the ramspeed to measure memory throughput. http://alasir.com/software/ramspeed/ I am using the v2.6, single core version. The command I used is ./ramspeed -b 3 (for int) and ./ramspeed -b 6 (for float). The benchmark measures four operations: add, copy, scale, and triad. And also gives an average number for all four operations. The results in DomU shows around 20% performance degradation compared to non-virt results. Attached is the results. The left part are results for int, while the right part is the results for float. The Y axis is the measured throughput. Each box contains 100 experiment repeats. The black boxes are the results in non-virtualized environment, while the blue ones are the results I got in DomU. The Xen version I am using is 4.3.0, 64bit. Thanks very much! Sisu On Tue, Mar 4, 2014 at 4:49 PM, Sisu Xi wrote: > Hi, all: > > I am trying to study the cache/memory performance under Xen, and has > encountered some problems. > > My machine is has an Intel Core i7 X980 processor with 6 physical cores. I > disabled hyper-threading, frequency scaling, so it should be running at > constant speed. > Dom0 was boot with 1 VCPU pinned to 1 core, with 2 GB of memory. > > After that, I boot up DomU with 1 VCPU pinned to a separate core, with 1 > GB of memory. The credit scheduler is used, and no cap is set for them. So > DomU should be able to access all resources. > > Each physical core has a 32KB dedicated L1 cache, 256KB dedicated L2 > cache. And all cores share a 12MB L3 cache. > > I created a simple program to create an array of specified size. Load them > once, and then randomly access every cache line once. (1 cache line is 64B > on my machine). > rdtsc is used to record the duration for the random access. > > I tried different data sizes, with 1000 repeat for each data sizes. > Attached is the boxplot for average access time for one cache line. > > The x axis is the different Data Size, the y axis is the CPU cycle. The > three vertical lines at 32KB, 256KB, and 12MB represents the size > difference in L1, L2, and L3 cache on my machine. > *The black box are the results I got when I run it in non-virtualized, > while the blue box are the results I got in DomU.* > > For some reason, the results in DomU varies much more than the results in > non-virtualized environment. > I also repeated the same experiments in DomU with Run Level 1, the results > are the same. > > Can anyone give some suggestions about what might be the reason for this? > > Thanks very much! > > Sisu > > -- > Sisu Xi, PhD Candidate > > http://www.cse.wustl.edu/~xis/ > Department of Computer Science and Engineering > Campus Box 1045 > Washington University in St. Louis > One Brookings Drive > St. Louis, MO 63130 > -- Sisu Xi, PhD Candidate http://www.cse.wustl.edu/~xis/ Department of Computer Science and Engineering Campus Box 1045 Washington University in St. Louis One Brookings Drive St. Louis, MO 63130 --047d7bfceb1a3e3aad04f3cfe2e7 Content-Type: text/html; charset=UTF-8 Content-Transfer-Encoding: quoted-printable
Hi, all:

I also used the ramspeed= to measure memory throughput.=C2=A0

<= /div>
I am using the v2.6, single core version. The command I used is ./ramspeed = -b 3 (for int) and ./ramspeed -b 6 (for float).
The benchmark mea= sures four operations: add, copy, scale, and triad. And also gives an avera= ge number for all four operations.

The results in DomU shows around 20% performance degrad= ation compared to non-virt results.

Attached is th= e results. The left part are results for int, while the right part is the r= esults for float. The Y axis is the measured throughput. Each box contains = 100 experiment repeats.
The black boxes are the results in non-virtualized environment, while = the blue ones are the results I got in DomU.

The X= en version I am using is 4.3.0, 64bit.=C2=A0

Thank= s very much!

Sisu



On Tue, Mar 4, 2014 at 4:49 PM, Sisu = Xi <xisisu@gmail.com> wrote:
Hi, all:

I am trying to study the cache/memory performance under Xen, and has encou= ntered some problems.

My machine is has an Intel Core i7 X980 processor with = 6 physical cores. I disabled hyper-threading, frequency scaling, so it shou= ld be running at constant speed.
Dom0 was boot with 1 VCPU pinned to 1 core, with 2 GB of memory.
=

After that, I boot up DomU with 1 VCPU pinned to a sepa= rate core, with 1 GB of memory. The credit scheduler is used, and no cap is= set for them. So DomU should be able to access all resources.

Each physical core has a 32KB dedicated L1 cache, 256KB= dedicated L2 cache. And all cores share a 12MB L3 cache.

I created a simple program to create an array of specified size. Lo= ad them once, and then randomly access every cache line once. (1 cache line= is 64B on my machine).
rdtsc is used to record the duration for the random access.
=
I tried different data sizes, with 1000 repeat for each data= sizes. Attached is the boxplot for average access time for one cache line.=

The x axis is the different Data Size, the y axis is th= e CPU cycle. The three vertical lines at 32KB, 256KB, and 12MB represents t= he size difference in L1, L2, and L3 cache on my machine.
The = black box are the results I got when I run it in non-virtualized, while the= blue box are the results I got in DomU.

For some reason, the results in DomU varies much more t= han the results in non-virtualized environment.
I also repeated t= he same experiments in DomU with Run Level 1, the results are the same.

Can anyone give some suggestions about what might be th= e reason for this?

Thanks very much!

Sisu

--
Sisu Xi, PhD Candidate

http://www= .cse.wustl.edu/~xis/
Department of Computer Science and Engineering<= br>Campus Box 1045
Washington University in St. Louis
One Brookings Drive
St. Louis, MO 63130



--
Sisu Xi, PhD= Candidate

http://www.cse.wustl.edu/~xis/
Department of Computer Science an= d Engineering
Campus Box 1045
Washington University in St. Louis
One Brookings Driv= e
St. Louis, MO 63130
--047d7bfceb1a3e3aad04f3cfe2e7-- --047d7bfceb1a3e3aba04f3cfe2e9 Content-Type: image/jpeg; name="cache_ramspeed.jpg" Content-Disposition: attachment; filename="cache_ramspeed.jpg" Content-Transfer-Encoding: base64 X-Attachment-Id: f_hsds3yrp1 /9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0a HBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIy MjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAOqB1MDASIA AhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQA AAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3 ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWm p6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEA AwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSEx BhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElK U1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3 uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD3+iii gAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKA CiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK KKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoo ooAKKK83+NfinWfCPg2zv9DvPsl1JqCQs/lJJlDHISMOCOqj8qAPSKK+WLH4g/GfU7OO8sDqt3ay Z2TQaNHIjYJBwwiwcEEfhVj/AITL45/8+uuf+CJf/jNAH0/RXgfw++Ps17qkOl+MBaQxSIscWoxK UAkHGZhnADf3lChT1GDlffKACiiigAooooAKKKKACiiigAooooAKKx/Fl9caZ4N1y/s5PLurXT7i aF9oO11jYqcHg4IHWvN/gX428ReMf7e/t/UPtn2X7P5P7mOPbu8zd9xRnO1evpQB7BRRRQAUUUUA FFeV+KPi5NpXxN07wZp+mxs73trBd3VwxI2ylchFGOdrqdxPXI2ng16pQAUUUUAFFFFABRRWP4q8 Q2/hTwvqOuXS747SIuEyR5jk4RMgHG5iozjjOTxQBsUV8sQ/Fj4reJby5n0MTvGm3fBpulrMkORg clHYZ2k8n1xxwPf/AId3uu6h4E0268SpOmrv5v2gTwCFxiVwuUAGPlC9uetAHUUUUUAFFcv468da X4D0M39+fNuJMra2iNh7hx2HooyMt2z3JAPF/BPx3r/je48Ry63dRypA8DW8UcKosIcy5UYGSPlU fMSeOvWgD1yiivN/ih8WLf4f+TYW1n9t1e5iMqI5KxwodwV2OPm+YfdGMgHJXjIB6RRXy5D8RfjL rKHUNMh1KSzndmiNpoyyRAbiNqt5bEgEEcknjk5rr/hx8d5tY1Sx0HxNaxi4uXWCG/twQHkO1VDx 9izZ+ZcAEj5QMkAHulFFeF/Ef47zaPql9oPhm1jNxbO0E1/cAkJINysEj7lWx8zZBIPykYJAPdKK +XJviL8ZdGQahqcOpR2cDq0pu9GWOIjcBtZvLUgEkDgg88HNet/C/wCLFv8AEDzrC5s/sWr20Qld EJaOZBtDOpx8vzH7pzgEYLc4APSKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK KKp6tqUOjaNfapcLI0FlbyXEixgFiqKWIGSBnA9RQBcorzf4WfEq8+Il5rrTafBZWtl9n+zxo5d/ nD7tzHAPKcYUYzjnrXpFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAU UUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRR RQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFF ABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUA FFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAU UUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRR RQAUUUUAFFFFABRRRQAV4/8AtHf8k80//sKx/wDoqWvYK8f/AGjv+Seaf/2FY/8A0VLQB0HwS/5J DoX/AG8f+lElegV8keFvEvxW0/w5aWvhq31V9ITf9nMGkrMhy7FsOYzn5i3fjpWx/wAJl8c/+fXX P/BEv/xmgDQ/aRsdLt9c0W6to4E1O5ilN2Ub53RdgjZl/wC+wGxztxk7Rj3fwn9s/wCEN0P+0fP+ 3f2fb/aPtGfM8zy13b887s5znnNfKHg6+0b/AIWL9q+JMl9MsO4Sm7V5T56YCrOpy5UBSNuDyFBG 3NfXeralDo2jX2qXCyNBZW8lxIsYBYqiliBkgZwPUUAcP8QPi/ovgS4/s8QSalq2wObaJwqxAkY8 x+dpKkkAAngZwCCfJP8Aho7xh/0DdD/78Tf/AB2qfwh8Lt8QPiDeazrkcd3aWrm8vBIi7Z55CSql QRwW3P0K/JtIw1fUf2Cz/s7+zvskH2HyvI+zeWPL8vG3Zt6bccY6YoA4P4f/ABf0Xx3cf2eYJNN1 bYXFtK4ZZQCc+W/G4hQCQQDycZAJGx8QPF194J8P/wBtW+jR6laROFus3nktEGIVWA2NuBY4PcZH BGSPAPi94Xb4f/EGz1nQ447S0unF5ZiNF2wTxkFlCkngNtfoF+faBha+m7C6s/Efh62vPs++x1K0 SXybhAd0ciA7XXkHg4I5FAHN/Dn4jWPxD0u5ngtZLO8tHC3NszbwgbOxlfADAhT2BBB4xgnQ8c+M 7HwL4ak1i+jkmJcQ28CcGaUgkLnGFGFJJPQA4BOAfny4ttR+BfxVjuIlnm0Wf5FmkiVjc2rFTIo5 A8xCB3XlVJAVsGPV9S1L46/E20sbFZLLT40ZIfMDOIIQcvK6g4DtwOMDOxS3G6gD3P4d+OtU8eWc uoy+G/7L0wZWG4e88wzuDghV8tflHOWz14GcNt5+1+N1vJ8QL7w1eaN9ltbKW7Sa/wDtRfalusjM /liPPIjPAJ6969M0rSrHQ9Lt9M0y2jtrO3TZFEnRR/MknJJPJJJOSa+RNR8PXHiv416rodq2yS71 u5QvgHy0Erl3wSM7VDHGecYHNAHcaz+0jrD6i/8AYejWMViMhftweSR+ThjsZQuRj5fmwc/Ma9D+ GfxfsfHTnTL6CPT9aRAyxB8pcgL8zR55BBydhyQOQWw2O80bQ9L8PaclhpFhBZWq4OyFMbiABuY9 WbAGWOSccmvmj4xeGE8AePtO1jw/B9it7nF3b7drJFcxvlgiHoozG2CMfMQOBgAH0P47/wCSeeJf +wVdf+imrx/9mX/maf8At0/9rV6p4l1KHWfhHq+qW6yLBe6FNcRrIAGCvAWAOCRnB9TXlf7Mv/M0 /wDbp/7WoA9o8T+J9L8I6HNq+rz+Vbx8Kq8vK56Ig7scH8iSQASPCNZ/aR1h9Rf+w9GsYrEZC/bg 8kj8nDHYyhcjHy/Ng5+Y1T+O2pXfiX4m2HhixWSR7NI7eKFgihricq2VbPQqYh8xABU9Op978H+D 9L8GaHb6fp9tAsyxIlzdJFte5cZy7HJJ5LEAk7c4HFAHkfhT9o1ZrgW/ivTI4Ed8Ld2AYqgJUfNG xJwPmJYEnoAp616x4v8AF0PhjwRdeJ7eGPUYIkieNY5wqyrI6qCHAYYw+c4Oa4v43eArPW/CV3r1 jZQJq9h/pMsyIFeeFVw6s2RnaoDAnJ+TaPvVl/ALUbbxH4D1HwzqltHewafcKwhuIEeLypCXVcH7 xEiSNyOMrg9gAeOaz46/tf4oR+NP7O8rZd21z9j8/dnyQg279o67Ou3jPevp/wCHHjr/AIWB4euN W/s77B5N21t5Xn+bnCI27O1f7+MY7V4J4s0nTbb9o230uDT7SLTzqdghtEhVYirLDuGwDGDk5GOc mvp/TdJ03RrdrfS9PtLGBnLtHawrEpbAGSFAGcADPsKALlFFc34/19vC/gPWdYiaRZ4LcrA6KrFJ XISNsNwQGZSc54B4PSgDi/iB8cdL8KXlzpGk239p6tDlJGLYggfB4YjlmU7cqMdSNwIIrzyD9pDx UtxE1xpWjSQBwZEjjlRmXPIDFyAcd8HHoak+AngKz1+8vtf1iygu7C1/0a3hnQOjzEAsxUn+FSOG Ug+ZkcrX0ffWFnqdnJZ39pBd2smN8M8YkRsEEZU8HBAP4UAcn4B+Jmi+P7eRbMSWuoQIrT2UxG4A gZZCPvoGOM8HpkDIz5n8bfib/wAh3wF/ZH/Pv/p32n/rnN/q9n/Afve/tXGa5YN8IvjTbXEAkTT4 rhbuDy1V2NpISroAzHkL5keWIJ27uMg17H8bdC0f/hXGu6v/AGVY/wBp/wCj/wCm/Z087/XRr9/G 77vHXpxQB5B8OPjB/wAK/wDD1xpP9hfb/Ou2ufN+1+VjKIu3Gxv7mc5719X14X8AvDWg6z4FvrjV NE02+nXU5EWS6tUlYL5URwCwJxkk49zXulABXN+PvEs3hDwRqeu29vHcT2yII45CQu53VATjkgFs 44zjGRnNdJRQB8wS/D3xj4v0nVvGvje7ng+y6fcSRQTJ5c7mKMlB5e0LHHuyTwCcE4+bfW/+zL/z NP8A26f+1q9g8d/8k88S/wDYKuv/AEU1eP8A7Mv/ADNP/bp/7WoA+gK+VNBih+JH7QMlxc+Zf6a9 7LcF1gG028QPkh1K4CELEh3DJ3YPJr6rr5g/Zx/5KHqH/YKk/wDRsVAH0/Xzp+0R4RttPuNN8R6f ZRwJcu9veNEqIrSkl1YgAFnbMmWOfujp3+i68f8A2jv+Seaf/wBhWP8A9FS0AdB/wm3/ABY3/hK/ 7Q/0v+yv+Pryf+Xzb5f3NuP9dx029/u15p+zf4ehudU1fxBcW0jPaIlvayMgKBnyZCpI++FCjg8C Q5+8Kt/82h/5/wCf+ug/Zx/5J5qH/YVk/wDRUVAHrk8EN1by29xFHNBKhSSORQyupGCCDwQRxivl zxFZp8Mvj9a3cB+w6Y13Fdo4RWC20p2zBUUcKMyoBjIAGOxP1PXzB+0d/wAlD0//ALBUf/o2WgD6 fooooA8/+JvxN/4Vz/Zf/Eo/tD7f5v8Ay8+Vs2bP9hs53+3SuH8dftAvpmuGw8JwWN7bwZWe7uVZ 0lf0j2svyjn5ud3bgAtX/aa/5lb/ALe//aNegfBvwxb+Hfh1pswggW+1KJbu5njyTIHy0YJP91GU YHAO7HUkgFj4X+PLj4geHpr+50v7FJbSi3d0kDRzOEUsVH3l69DnAIwzHOOL8bftB2OlXE+n+F7S PUbiJyjXszf6PkFfuBTmQfeGcqMgEbga6D4x6jbeE/hlqq6dbR2k+sXH2dmt4EAd5QTKz+paNHG7 k5I+o8w+E2ofDLw1YJq/iLUo5ded8rFNYyyLZhX+UphCC52ht+cjIAx82QCSx/aR8SR3kbX+jaVP ajO+OASRO3BxhizAc4/hPpx1r3PwZ450Xx1pb32jyyAxPsmt5wFlhPONwBIwQMggkHkdQQOT1n4o /CfxDpz2Gr6lBe2rZOyawnO0kEblPl5VsE4YYIzwa8k8Da1pHhn46xjw9eSXOg39wbOMpCVJjmxs TEnzAJIUBbqQhPfBAPe/iP46/wCFf+HrfVv7O+3+ddrbeV5/lYyjtuztb+5jGO9cPrXx+t7HwhpV /baPnV9TillS1eYtHboskkauz7Rvy0f3RjgHJHBNj9o7/knmn/8AYVj/APRUtY/wB8BWbaPJ4r1W yguJp5dun+cgfyljbmReThi4wCQGHl5Bw1AGRo37SOsJqKf25o1jLYnAb7CHjkTkZYb2YNgZ+X5c nHzCvoPStVsdc0u31PTLmO5s7hN8UqdGH8wQcgg8ggg4Irm/iT4Ls/GvhK7tpLTztSt4pJdPdGCO s23hQx42sQAQeO/BAI8s/Zs19hcaz4ckaQoyC+gUKu1SCEkJPXJzFgcj5T07gHr/AIz8c6L4F0tL 7WJZCZX2Q28ADSzHjO0EgYAOSSQBwOpAPhl9+0j4kkvJGsNG0qC1ONkc4kldeBnLBlB5z/CPTnrW P8QNW0vxZ8bbmLXdSnsNEs5TYvMINzxJEDuChQSd0m/DEHG8EjA216/o3xR+E/h7TksNI1KCytVw dkNhONxAA3MfLyzYAyxyTjk0AYfgn9oOx1W4g0/xRaR6dcSuEW9hb/R8kt98Mcxj7ozlhkknaBXt lfNHxY1T4YeJNHm1Lw9dwR+IRKrnybKaP7UpY7w2VVN2X3lyCx24716n8EtfbXvhlYrK0jT6c7WL syqoIQAoFx1AjZBk4OQevUgEfxE+MOl+A7yLTorX+1NTOGmt0m8sQIRkFm2t8x4wuOnJxld3lH/D R3jD/oG6H/34m/8Ajtdfo/wIvE+Ir634i1Ox1fTTK91IrQlHuZm5+eMfKq7yTgMwO0ArhiB65eat oPhq3tbe91DTdKg2bLaOaZIF2qAMICQMAEDA6ZFAHl/w8+OsPibVLXRNdsI7PULl9kVzA4EDt8xA Ic5QnCqAC25j24FSfGX4m/8ACM/a/Cn9kfaf7T0p/wDSvtOzyvM8yP7mw5xtz1Gc44ryD4q33hpP H0d34IkgghhiQySWCtEiXKOw3R4wBwEIZOD1BJJNfR/xF0LR77wbr+o3mlWNxfQaVceTczW6PJHt jdl2sRkYJJGOhoA+cPhl8Tf+Fc/2p/xKP7Q+3+V/y8+Vs2b/APYbOd/t0r6/r5w/Z40LR9b/AOEk /tbSrG/8n7N5f2u3SXZnzc43A4zgdPQV9H0AFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRR RQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFF ABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUA FFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAU UUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRR RQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFF ABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXj/wC0d/yTzT/+wrH/AOipa9grx/8AaO/5J5p//YVj /wDRUtAHQfBL/kkOhf8Abx/6USV6BXzB4J+On/CHeELHQP8AhHPtn2XzP3/27y926Rn+75Zxjdjr 2rf/AOGmv+pR/wDKl/8AaqAND9pHRrN/D2k65s230V39j3qAN8bo74Y4ycFOOcDc3HNbnhKa+1r9 m1lYSXV2+j3lrEkceWYJ5scaBVHJ2qo9T7mvINX1bxf8cvEtpb2umRpb2rskSxI3lWqyHO6aXB52 oB2zs+VcnB+o9D0az8PaHZaRYJstbSJYkyAC2OrNgAFicknHJJNAHhH7NF9bx6j4isGkxdTRQTRp tPzIhcMc9ODIn5+xr6Hr5Y8WeD/EHwj8cr4l0K28zSopWmtZxE0kcCMdphlySRw+wMT8wIIIbIXo P+Gl7z+ztn/CMQfbvKx532w+X5mPvbNmduedu7OON3egA/aXvreTUfDtgsmbqGKeaRNp+VHKBTnp yY3/AC9xXtfguCa18C+Hre4ikhni0y2SSORSrIwiUEEHkEHjFfOnhPwf4g+LnjlvEuu23l6VLKs1 1OYmjjnRTtEMWCCeE2FgflAJJLYDe3/FPx0ngXwlJcRHOp3m6CyUMuVcqf3pDZyqcE8HJKg43ZAB 5h+0H4it9X1jTPCOnWn2nUrWUPKy25MivIq7Ioz1O4MCwAOT5fOQQKfwC8S2nh3xLqPhrVbeOyu7 51VJpy6OZoyVEDKeAfmfH3TnKncSoFz4E+BX1jUZvHGuD7SqyuLQXKszyT5Ba43HhsHIB+b5tx4K DM/x98HPYXlr460jz4rjzUS9kidsxuoAilXA+TG0KTkc7MDJJIB9AV8ueE54bb9p24eeWOJDrF+g Z2CgswmVRz3LEADuSBXtfws8dJ468JR3EpxqdntgvVLLlnCj96AuMK/JHAwQwGduT84alo+qa98Z tbsNEfZqZ1W9ltmEvlnfG0kg2t/C3ycHjnHI60AfY9fPH7S99byaj4dsFkzdQxTzSJtPyo5QKc9O TG/5e4qOH9orWtN0s6dqfhyOTWrdGhluJZjEPNGRl4dmQQcblDDkHG3oMPwn4e8QfGjxy2va627S oJV+1OQyx7Aci2iAORkHnB+UMWJLEbgD2ueCa1+AUtvcRSQzxeFykkcilWRha4IIPIIPGK87/Zl/ 5mn/ALdP/a1eweO/+SeeJf8AsFXX/opq8f8A2Zf+Zp/7dP8A2tQBznxFmXRv2jYtT1ASW9ml7YXR laNsGJFi3OuBlgCjDjPKkdRX1HXj/wAcfhveeKrO31/RofO1KwiMc1uuS88Odw2DONyksdoGW3Hk kKDwnhf47614S0tNB1jQo7w6ei2sWZDbSxBMrskG1gSAFXopG3nJOaAPc/iPfW+n/DXxHNdSeXG2 nzQg7ScvIpjQcerMo9s88V5X+zNBMtv4luGikEDvbIkhU7WZRKWAPQkBlJHbcPWuM8V+O/FPxivL fQ9M0TbaxyieO0tgZXDYCb5JCAAoLnnCqN/zZwDX0H8OfBi+BfB1vpDSRy3bO093LHu2vK2M4yeg UKvQZ25wCTQB4Z4y/wCTobb/ALCum/8AoMNfT9fLHxhTVPDXxo/4SL7HiNpba7sZJRmOYxJGCOD2 ZcEZBwQehBPt/wANfiPb/ETTr6ZbL7DdWcqpJb+aZfkYZV921RyQ4x22+4oA7iuD+M8E1z8JNeSC KSVwkTlUUsQqzIzHjsFBJPYAmu8qvf2NvqenXNheR+Za3UTwzJuI3IwIYZHIyCelAHj/AOzdfW8n g3VrBZM3UOoedIm0/KjxoFOenJjf8vcV7RXyZPp/i/4GeMZb+3gjuLZkMEd5JAzW9zG/IUkHKvlM 7dwIK91OT1l9+0veSWci2HhiCC6ONkk94ZUXkZyoRSeM/wAQ9eelAGH8f5l1X4pW1hYCS4u4bKG1 eGONi3ms7uqAY+YlZE6Z6468V7H8bf8AkkOu/wDbv/6UR15Z8Jvh9rXiXxinjXxFBJFaJcfblaaM xteTt86ugGMIGYPu+6cBQCN2PU/jb/ySHXf+3f8A9KI6AOf/AGcf+Seah/2FZP8A0VFXsFeP/s4/ 8k81D/sKyf8AoqKvYKACiiigDn/Hf/JPPEv/AGCrr/0U1eP/ALMv/M0/9un/ALWr2Dx3/wAk88S/ 9gq6/wDRTV4/+zL/AMzT/wBun/tagD6Ar5k+DYh8LfG7UtBlkkuHKXWnRTKgUM0bh9zDPAKwt0zy R9a+m6+cPjV4N1Hw14ti8d6FDstWljnmkjVSLa6Vhhyu3G1iFOTnLls/eUEA+j68T/aT1KGLwro2 lssnn3F6bhGAG0LGhVgec5zKuOOx6d8DSv2k7610u3g1Pw9HfXkabZblLvyRKf72zyyAcYzg4znA A4HL6Vpniv42eNbe/wBTjkawR/KuLuKIRRW8CtvMSNtILgSfKDub5gTwCQAenw+Gpm/ZbOnT3EaP /ZjaiHQFht8w3SrzjkrhT6Enrjmv+zZqUMvhXWdLVZPPt70XDsQNpWRAqgc5zmJs8dx17eyfYLP+ zv7O+yQfYfK8j7N5Y8vy8bdm3ptxxjpivlDVrPxL8EfH0s2mnZbzbhazyosqXVtvVtjHAw3ChsbS OxAIJAPrevmD42f8VP8AGay0Oy/d3SxW2nl5uE8yRi6nIyduJlycZ4PHrqar+0nfXWl3EGmeHo7G 8kTbFcvd+cIj/e2eWATjOMnGcZBHBPg34F1fXPGMnjfxJZyLAHa6ga4iCfabiT5hIqFcFAGLBhgb tu3ODgA+i6KKKAPn/wDaa/5lb/t7/wDaNeweBP8Aknnhr/sFWv8A6KWvH/2mv+ZW/wC3v/2jXsHg T/knnhr/ALBVr/6KWgDg/wBoqCab4c2rxRSOkOpxPKyqSEXy5Fy3oNzKMnuQO9cZ8M/hF4T8ceC4 NWudR1Vb5ZZIbqOCRFSNwcgDdGc/IUPU9fwHu/irw9b+K/C+o6HdNsju4igfBPluDlHwCM7WCnGe cYPFfMGmal4x+CHiiWG5s8Ws0oE8bR/ub5EBwY5SueBJnI6EjcOCtAHq/wDwzj4P/wCglrn/AH/h /wDjVSaH8EfBOneJYriw1rUp9Q0m4huHtzdQsY2BDoJFEeQGxntkdK5DVf2k7660u4g0zw9HY3ki bYrl7vzhEf72zywCcZxk4zjII4MfwU+H+qap4oHjDxBaz/ZYsz2z3gy91O4BEuHBLKAxbfkfNtIJ wcAHX/tHf8k80/8A7Csf/oqWtz4HTwzfCTSEiljd4XnSVVYEo3nO2G9DtZTg9iD3rD/aO/5J5p// AGFY/wD0VLXmHgnxP4p+F2j2Ov8A2P7f4Z1nzP3HmlUEyMyfewfLk+TPQhl9SvyAH1Pf31vpmnXN /eSeXa2sTzTPtJ2ooJY4HJwAelfNn7N8EzeOtTuFikMCaYyPIFO1WaWMqCegJCsQO+0+lU/GPxr8 QeN7P+wtJ03+zre82wyRQO009wSSPLDAD5Wyo2hcnGMkEivY/hB8P5vAnhqY6h5f9rag6y3IRiRE qj5I85wSuWJI7sRkgAkA8IutCsdV+PWoaN4ge7srS91i4QtGu2TMjMYcZU8MzR84xhs9Oa9b/wCG cfB//QS1z/v/AA//ABqsP44/DDUtS1T/AISrQbSS7eVEivbWBWeUsPlWRV53DbtUhQMbQcHLEZGg ftG6vp+lrb61pEerXauT9qWcW5ZT0DKsZGRyMjHGOM5JAOrvv2f/AAHplnJeX+uaraWseN8093BG i5IAyxjwMkgfjXeeGPC+i/DHwrfxW93dnT43kvp5boh2QBBuI2KMgKmcYJ6186eK/GPin4xa5b6d pumTi1iw0OnWzGQKxwplkfAHVsbmwqg9ssT9B6D4Bh0b4WyeEUljinurKWK6uUQNmaVCHfopYAnA zg7VUE8UAeENqHjr43+Jb21sJ5LXTNgL2xndbS3jBJQSYHzuWHXaSSMgBV+XoNN/Zp1KW3ZtU8SW ltPvIVLW2adSuByWYoQc54x2HPPHF+GPFHin4OeIbq2udK8v7RsF1Z3cZXzVRyA8bj/gYDDcpyTh sCu01L9pbUpbdV0vw3aW0+8Fnurlp1K4PAVQhBzjnPY8c8AHn/xN8Iab4H8S22jafqEl662Ucl27 suVmJbI2j7gKhWCkk4YcnIr6r8d/8k88S/8AYKuv/RTV8ieNdN8R2Wsw3nilpDqmqW63ziU/vFVm ZVDjGFOE4UfdGBgYwPr/AMSwtrvgXV4NLMd09/pkyWpjkXbKXiITDZxg5HOcc0AeN/sy/wDM0/8A bp/7Wr6Ar5A+HfxEvPhfqOrQT6N9q+07Y54JZDBJFJGWA5KnGNzAqRnOORgg/W9hfW+p6dbX9nJ5 lrdRJNC+0jcjAFTg8jII60AWKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKK ACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA KKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAo oooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACii igAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKK ACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA KKKKACiiigAooooAKKKKACqepaTpus262+qafaX0CuHWO6hWVQ2CMgMCM4JGfc1cooA5/wD4QTwf /wBCpof/AILof/iaP+EE8H/9Cpof/guh/wDia6CigCOCCG1t4re3ijhgiQJHHGoVUUDAAA4AA4xU lFFABXP/APCCeD/+hU0P/wAF0P8A8TXQUUAFZepeGtB1m4W41TRNNvp1QIsl1apKwXJOAWBOMknH ua1KKAI4IIbW3it7eKOGCJAkccahVRQMAADgADjFE8EN1by29xFHNBKhSSORQyupGCCDwQRxipKK AMvTfDWg6NcNcaXomm2M7IUaS1tUiYrkHBKgHGQDj2FfOng3/k6G5/7Cupf+gzV9P15fo3wf/sj4 oSeNP7d83fd3Nz9j+ybcecHG3fvPTf12847UAdxfeE/Dep3kl5f+H9Ku7qTG+aeyjkdsAAZYjJwA B+FbFFFAEc8EN1by29xFHNBKhSSORQyupGCCDwQRxiqemaFo+ieb/ZOlWNh52PM+yW6Rb8ZxnaBn GT19TWhRQAVl6l4a0HWbhbjVNE02+nVAiyXVqkrBck4BYE4ySce5rUooAp6bpOm6Nbtb6Xp9pYwM 5do7WFYlLYAyQoAzgAZ9hVyiigCnqWk6brNutvqmn2l9Arh1juoVlUNgjIDAjOCRn3NR6ZoWj6J5 v9k6VY2HnY8z7JbpFvxnGdoGcZPX1NaFFABRRRQBHPBDdW8tvcRRzQSoUkjkUMrqRggg8EEcYrHg 8F+FbW4iuLfw1o0M8Th45I7CJWRgcgghcgg85rcooAKr31hZ6nZyWd/aQXdrJjfDPGJEbBBGVPBw QD+FWKKAKem6TpujW7W+l6faWMDOXaO1hWJS2AMkKAM4AGfYVcoooAKKKKAI54Ibq3lt7iKOaCVC kkcihldSMEEHggjjFU9M0LR9E83+ydKsbDzseZ9kt0i34zjO0DOMnr6mtCigAooooAw5/BfhW6uJ bi48NaNNPK5eSSSwiZnYnJJJXJJPOa2IIIbW3it7eKOGCJAkccahVRQMAADgADjFSUUAFRzwQ3Vv Lb3EUc0EqFJI5FDK6kYIIPBBHGKkooAw4PBfhW1uIri38NaNDPE4eOSOwiVkYHIIIXIIPOa3KKKA CiiigDP1PQtH1vyv7W0qxv8Ayc+X9rt0l2ZxnG4HGcDp6CrkEENrbxW9vFHDBEgSOONQqooGAABw ABxipKKACq99YWep2clnf2kF3ayY3wzxiRGwQRlTwcEA/hViigDDg8F+FbW4iuLfw1o0M8Th45I7 CJWRgcgghcgg85rcoooA8f8A2jv+Seaf/wBhWP8A9FS1sfCCws9T+CujWd/aQXdrJ5++GeMSI2Li QjKng4IB/Ctj4j+Bf+FgeHrfSf7R+weTdrc+b5Hm5wjrtxuX+/nOe1aHgnwx/wAId4QsdA+2fbPs vmfv/K8vdukZ/u5OMbsde1AGhpmhaPonm/2TpVjYedjzPslukW/GcZ2gZxk9fU1oUUUAFY994T8N 6neSXl/4f0q7upMb5p7KOR2wABliMnAAH4VsUUAU9N0nTdGt2t9L0+0sYGcu0drCsSlsAZIUAZwA M+wq5RRQBT1LSdN1m3W31TT7S+gVw6x3UKyqGwRkBgRnBIz7mq+m+GtB0a4a40vRNNsZ2Qo0lrap ExXIOCVAOMgHHsK1KKAM/U9C0fW/K/tbSrG/8nPl/a7dJdmcZxuBxnA6egq5BBDa28VvbxRwwRIE jjjUKqKBgAAcAAcYqSigDHvvCfhvU7yS8v8Aw/pV3dSY3zT2UcjtgADLEZOAAPwrUgghtbeK3t4o 4YIkCRxxqFVFAwAAOAAOMVJRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUU UUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRR QAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFA BRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF FFFABRRRQAUUUUAFFFFABRWPq2vHTNRtLCDSr7Ubq6ilmVLQwjakZjDEmWRB1lXpnvVf/hIdU/6E zXP+/wBZf/JFAHQUVz//AAkOqf8AQma5/wB/rL/5Io/4SHVP+hM1z/v9Zf8AyRQB0FFc/wD8JDqn /Qma5/3+sv8A5IqvYeL7vU9Otr+z8I65Ja3USTQv5lmNyMAVODcZGQR1oA6iiuf/AOEh1T/oTNc/ 7/WX/wAkUf8ACQ6p/wBCZrn/AH+sv/kigDoKK5//AISHVP8AoTNc/wC/1l/8kUf8JDqn/Qma5/3+ sv8A5IoA6Ciuf/4SHVP+hM1z/v8AWX/yRR/wkOqf9CZrn/f6y/8AkigDoKK5/wD4SHVP+hM1z/v9 Zf8AyRR/wkOqf9CZrn/f6y/+SKAOgorl7Dxfd6np1tf2fhHXJLW6iSaF/MsxuRgCpwbjIyCOtWP+ Eh1T/oTNc/7/AFl/8kUAdBRXP/8ACQ6p/wBCZrn/AH+sv/kij/hIdU/6EzXP+/1l/wDJFAHQUVz/ APwkOqf9CZrn/f6y/wDkij/hIdU/6EzXP+/1l/8AJFAHQUVz/wDwkOqf9CZrn/f6y/8Akij/AISH VP8AoTNc/wC/1l/8kUAdBRXP/wDCQ6p/0Jmuf9/rL/5IqvZ+L7vUIGmtfCOuSRrLJCT5lmMPG7Ru ObjsysPfHHFAHUUVz/8AwkOqf9CZrn/f6y/+SKP+Eh1T/oTNc/7/AFl/8kUAdBRXP/8ACQ6p/wBC Zrn/AH+sv/kij/hIdU/6EzXP+/1l/wDJFAHQUVz/APwkOqf9CZrn/f6y/wDkij/hIdU/6EzXP+/1 l/8AJFAHQUVz/wDwkOqf9CZrn/f6y/8Akij/AISHVP8AoTNc/wC/1l/8kUAdBRXL2/i+7u57uGDw jrjyWkohnHmWY2OUWQDm45+V1PHr65qx/wAJDqn/AEJmuf8Af6y/+SKAOgorn/8AhIdU/wChM1z/ AL/WX/yRR/wkOqf9CZrn/f6y/wDkigDoKK5//hIdU/6EzXP+/wBZf/JFH/CQ6p/0Jmuf9/rL/wCS KAOgorn/APhIdU/6EzXP+/1l/wDJFH/CQ6p/0Jmuf9/rL/5IoA6Ciuf/AOEh1T/oTNc/7/WX/wAk VXt/F93dz3cMHhHXHktJRDOPMsxscosgHNxz8rqePX1zQB1FFc//AMJDqn/Qma5/3+sv/kij/hId U/6EzXP+/wBZf/JFAHQUVz//AAkOqf8AQma5/wB/rL/5Io/4SHVP+hM1z/v9Zf8AyRQB0FFc/wD8 JDqn/Qma5/3+sv8A5Io/4SHVP+hM1z/v9Zf/ACRQB0FFc/8A8JDqn/Qma5/3+sv/AJIo/wCEh1T/ AKEzXP8Av9Zf/JFAHQUVy6eL7uTUZrBfCOuG6hijmkTzLP5UcuFOftGOTG/5e4qx/wAJDqn/AEJm uf8Af6y/+SKAOgorn/8AhIdU/wChM1z/AL/WX/yRR/wkOqf9CZrn/f6y/wDkigDoKK5//hIdU/6E zXP+/wBZf/JFH/CQ6p/0Jmuf9/rL/wCSKAOgorn/APhIdU/6EzXP+/1l/wDJFH/CQ6p/0Jmuf9/r L/5IoA6Ciuf/AOEh1T/oTNc/7/WX/wAkVXfxfdx6jDYN4R1wXU0Uk0aeZZ/MiFAxz9oxwZE/P2NA HUUVz/8AwkOqf9CZrn/f6y/+SKP+Eh1T/oTNc/7/AFl/8kUAdBRXP/8ACQ6p/wBCZrn/AH+sv/ki j/hIdU/6EzXP+/1l/wDJFAHQUVz/APwkOqf9CZrn/f6y/wDkij/hIdU/6EzXP+/1l/8AJFAHQUVz /wDwkOqf9CZrn/f6y/8Akij/AISHVP8AoTNc/wC/1l/8kUAdBRXLv4vu49RhsG8I64LqaKSaNPMs /mRCgY5+0Y4Mifn7GrH/AAkOqf8AQma5/wB/rL/5IoA6Ciuf/wCEh1T/AKEzXP8Av9Zf/JFH/CQ6 p/0Jmuf9/rL/AOSKAOgorn/+Eh1T/oTNc/7/AFl/8kUf8JDqn/Qma5/3+sv/AJIoA6Ciuf8A+Eh1 T/oTNc/7/WX/AMkUf8JDqn/Qma5/3+sv/kigDoKK5/8A4SHVP+hM1z/v9Zf/ACRVe48X3dpPaQz+ EdcSS7lMMA8yzO9wjSEcXHHyox59PXFAHUUVz/8AwkOqf9CZrn/f6y/+SKP+Eh1T/oTNc/7/AFl/ 8kUAdBRXP/8ACQ6p/wBCZrn/AH+sv/kij/hIdU/6EzXP+/1l/wDJFAHQUVz/APwkOqf9CZrn/f6y /wDkij/hIdU/6EzXP+/1l/8AJFAHQUVz/wDwkOqf9CZrn/f6y/8Akij/AISHVP8AoTNc/wC/1l/8 kUAdBRXL3vi+70+BZrrwjrkcbSxwg+ZZnLyOsaDi47syj2zzxVj/AISHVP8AoTNc/wC/1l/8kUAd BRXP/wDCQ6p/0Jmuf9/rL/5Io/4SHVP+hM1z/v8AWX/yRQB0FFcvf+L7vTNOub+88I65Ha2sTzTP 5lmdqKCWOBcZOAD0rn/Dfxl0nxdqMlhoeg65d3UcRmZNtvHhAQCcvMB1YfnQB6RRXP8A/CQ6p/0J muf9/rL/AOSKP+Eh1T/oTNc/7/WX/wAkUAdBRXP/APCQ6p/0Jmuf9/rL/wCSKr3vi+70+BZrrwjr kcbSxwg+ZZnLyOsaDi47syj2zzxQB1FFc/8A8JDqn/Qma5/3+sv/AJIo/wCEh1T/AKEzXP8Av9Zf /JFAHQUVz/8AwkOqf9CZrn/f6y/+SKP+Eh1T/oTNc/7/AFl/8kUAdBRXP/8ACQ6p/wBCZrn/AH+s v/kij/hIdU/6EzXP+/1l/wDJFAHQUVz/APwkOqf9CZrn/f6y/wDkij/hIdU/6EzXP+/1l/8AJFAH QUVy9/4vu9M065v7zwjrkdraxPNM/mWZ2ooJY4Fxk4APSrH/AAkOqf8AQma5/wB/rL/5IoA6Ciuf /wCEh1T/AKEzXP8Av9Zf/JFH/CQ6p/0Jmuf9/rL/AOSKAOgorn/+Eh1T/oTNc/7/AFl/8kUf8JDq n/Qma5/3+sv/AJIoA6Ciuf8A+Eh1T/oTNc/7/WX/AMkUf8JDqn/Qma5/3+sv/kigDoKK5/8A4SHV P+hM1z/v9Zf/ACRR/wAJDqn/AEJmuf8Af6y/+SKAOgorl7Dxfd6np1tf2fhHXJLW6iSaF/MsxuRg CpwbjIyCOtWP+Eh1T/oTNc/7/WX/AMkUAdBRXP8A/CQ6p/0Jmuf9/rL/AOSKP+Eh1T/oTNc/7/WX /wAkUAdBRXP/APCQ6p/0Jmuf9/rL/wCSKP8AhIdU/wChM1z/AL/WX/yRQB0FFc//AMJDqn/Qma5/ 3+sv/kij/hIdU/6EzXP+/wBZf/JFAHQUVz//AAkOqf8AQma5/wB/rL/5IqvYeL7vU9Otr+z8I65J a3USTQv5lmNyMAVODcZGQR1oA6iiuf8A+Eh1T/oTNc/7/WX/AMkUf8JDqn/Qma5/3+sv/kigDoKK 5/8A4SHVP+hM1z/v9Zf/ACRR/wAJDqn/AEJmuf8Af6y/+SKAOgorn/8AhIdU/wChM1z/AL/WX/yR R/wkOqf9CZrn/f6y/wDkigDoKK5//hIdU/6EzXP+/wBZf/JFH/CQ6p/0Jmuf9/rL/wCSKAOgorl7 Pxfd6hA01r4R1ySNZZISfMsxh43aNxzcdmVh7444qx/wkOqf9CZrn/f6y/8AkigDoKK5/wD4SHVP +hM1z/v9Zf8AyRR/wkOqf9CZrn/f6y/+SKAOgorn/wDhIdU/6EzXP+/1l/8AJFH/AAkOqf8AQma5 /wB/rL/5IoA6Ciuf/wCEh1T/AKEzXP8Av9Zf/JFH/CQ6p/0Jmuf9/rL/AOSKAOgorn/+Eh1T/oTN c/7/AFl/8kVXt/F93dz3cMHhHXHktJRDOPMsxscosgHNxz8rqePX1zQB1FFc/wD8JDqn/Qma5/3+ sv8A5Io/4SHVP+hM1z/v9Zf/ACRQB0FFc/8A8JDqn/Qma5/3+sv/AJIo/wCEh1T/AKEzXP8Av9Zf /JFAHQUVz/8AwkOqf9CZrn/f6y/+SKP+Eh1T/oTNc/7/AFl/8kUAdBRXP/8ACQ6p/wBCZrn/AH+s v/kij/hIdU/6EzXP+/1l/wDJFAHQUVy9v4vu7ue7hg8I648lpKIZx5lmNjlFkA5uOfldTx6+uasf 8JDqn/Qma5/3+sv/AJIoA6Ciuf8A+Eh1T/oTNc/7/WX/AMkUf8JDqn/Qma5/3+sv/kigDoKK5/8A 4SHVP+hM1z/v9Zf/ACRR/wAJDqn/AEJmuf8Af6y/+SKAOgorn/8AhIdU/wChM1z/AL/WX/yRR/wk Oqf9CZrn/f6y/wDkigDoKK5//hIdU/6EzXP+/wBZf/JFV08X3cmozWC+EdcN1DFHNInmWfyo5cKc /aMcmN/y9xQB1FFc/wD8JDqn/Qma5/3+sv8A5Io/4SHVP+hM1z/v9Zf/ACRQB0FFc/8A8JDqn/Qm a5/3+sv/AJIo/wCEh1T/AKEzXP8Av9Zf/JFAHQUVz/8AwkOqf9CZrn/f6y/+SKP+Eh1T/oTNc/7/ AFl/8kUAdBRXP/8ACQ6p/wBCZrn/AH+sv/kij/hIdU/6EzXP+/1l/wDJFAHQUVy7+L7uPUYbBvCO uC6mikmjTzLP5kQoGOftGODIn5+xqx/wkOqf9CZrn/f6y/8AkigDoKK5/wD4SHVP+hM1z/v9Zf8A yRR/wkOqf9CZrn/f6y/+SKAOgorn/wDhIdU/6EzXP+/1l/8AJFH/AAkOqf8AQma5/wB/rL/5IoA6 Ciuf/wCEh1T/AKEzXP8Av9Zf/JFH/CQ6p/0Jmuf9/rL/AOSKAOgorn/+Eh1T/oTNc/7/AFl/8kVX fxfdx6jDYN4R1wXU0Uk0aeZZ/MiFAxz9oxwZE/P2NAHUUVz/APwkOqf9CZrn/f6y/wDkij/hIdU/ 6EzXP+/1l/8AJFAHQUVz/wDwkOqf9CZrn/f6y/8Akij/AISHVP8AoTNc/wC/1l/8kUAdBRWfourJ remC9jtp7b97LC8M+3ejxyNGwO1mX7yHoTWhQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUU UUAFFFFABRRRQAUUUUAFFFFAHP3n/JQ9G/7BV/8A+jbSugrn7z/koejf9gq//wDRtpXQUAFFFFAB XP8AgT/knnhr/sFWv/opa6Cs/QtM/sTw9pmk+d532G0itvN27d+xAu7GTjOM4yaANCiiigAooooA KKKKACiiigDn/An/ACTzw1/2CrX/ANFLXQVn6Fpn9ieHtM0nzvO+w2kVt5u3bv2IF3YycZxnGTWh QAUUUUAeV/FPVtS0/wAdfDu3stQu7aC71MpcxwzMizL5sAw4BwwwxGD6n1r1SuP8YaB4b1fxD4Yv Nb1f7FfWF35unQ/aY4/tMm+M7drAl+VQYXB+b3FdhQAUUUUAFc/4N/5Adz/2FdS/9LZq6Cs/RtM/ sixktvO83fd3Nzu27cedM8u3GT034z3xnjpQBoUUUUAFFFFABRRRQAUUUUAc/wCHv+Q54s/7Csf/ AKRWtdBWfp2mfYL7VrnzvM/tC7W527ceXiGKLbnPP+qznj72O2ToUAFFFFAHlfx91bUtG8C2Nxpe oXdjO2pxo0lrM0TFfKlOCVIOMgHHsK9Urj/iPoHhvxH4et7PxRq/9l2KXaypN9pjg3SBHAXdICDw WOOvHtXYUAFFFFABXP8Ah7/kOeLP+wrH/wCkVrXQVn6dpn2C+1a587zP7Qu1udu3Hl4hii25zz/q s54+9jtkgGhRRRQAUUUUAFFFFABRRRQBz9n/AMlD1n/sFWH/AKNu66Cs+HTPK8Q3uredn7TaQW3l bfu+U8zbs55z52MY42988aFABRRRQBw/xfv7zTPhbrN5YXc9pdR+RsmgkMbrmeMHDDkZBI/GtzwX PNdeBfD1xcSyTTy6ZbPJJIxZnYxKSSTySTzmo/G2laPrfhC+07X7/wCwaZN5fnXPnJFsxIrL8zgq MsFHPrWhoVrZ2Ph7TLPTrj7RYwWkUVvNvD+ZGqAK24cHIAORwaANCiiigArn7z/koejf9gq//wDR tpXQVnzaZ5viGy1bzsfZrSe28rb97zXhbdnPGPJxjHO7tjkA0KKKKACiiigAooooAKKKKAOfvP8A koejf9gq/wD/AEbaV0FZ82meb4hstW87H2a0ntvK2/e814W3ZzxjycYxzu7Y50KACiiigAryv4Ba tqWs+Bb641TULu+nXU5EWS6maVgvlRHALEnGSTj3NeqVx/w40Dw34c8PXFn4X1f+1LF7tpXm+0xz 7ZCiArujAA4CnHXn3oA7CiiigArn/EP/ACHPCf8A2FZP/SK6roKz9R0z7ffaTc+d5f8AZ921zt25 8zMMsW3OeP8AW5zz93HfIANCiiigAooooAKKKKACiiigDn/GX/IDtv8AsK6b/wClsNdBWfrOmf2v Yx23neVsu7a53bd2fJmSXbjI67MZ7Zzz0rQoAKKKKAOf8d/8k88S/wDYKuv/AEU1eAfs4/8AJQ9Q /wCwVJ/6Nir3/wAd/wDJPPEv/YKuv/RTV4B+zj/yUPUP+wVJ/wCjYqAPp+iiigArn/GX/IDtv+wr pv8A6Ww10FZ+s6Z/a9jHbed5Wy7trndt3Z8mZJduMjrsxntnPPSgDQooooAKKKKACiiigAooooA5 /wAd/wDJPPEv/YKuv/RTV0FZ+u6Z/bfh7U9J87yft1pLbebt3bN6Fd2MjOM5xkVoUAFFFFABXleh atqU37RvifS5dQu30+HTEeK0aZjEjbbflUzgH5m5A7n1r1SuP07QPDdv8UNW1y21fzfENzaLFdWH 2mNvKjAiw3lgb14ROScfN7igDsKKKKACiiigDn/An/JPPDX/AGCrX/0UtdBWfoWmf2J4e0zSfO87 7DaRW3m7du/YgXdjJxnGcZNaFABRRRQAUUUUAFFFFABXP+BP+SeeGv8AsFWv/opa6Cs/QtM/sTw9 pmk+d532G0itvN27d+xAu7GTjOM4yaANCiiigAryv4p6tqWn+Ovh3b2WoXdtBd6mUuY4ZmRZl82A YcA4YYYjB9T616pXH+MNA8N6v4h8MXmt6v8AYr6wu/N06H7THH9pk3xnbtYEvyqDC4Pze4oA7Cii igAooooA5/wb/wAgO5/7Cupf+ls1dBWfo2mf2RYyW3nebvu7m53bduPOmeXbjJ6b8Z74zx0rQoAK KKKACiiigAooooAK5/w9/wAhzxZ/2FY//SK1roKz9O0z7Bfatc+d5n9oXa3O3bjy8QxRbc55/wBV nPH3sdskA0KKKKACvK/j7q2paN4FsbjS9Qu7GdtTjRpLWZomK+VKcEqQcZAOPYV6pXH/ABH0Dw34 j8PW9n4o1f8AsuxS7WVJvtMcG6QI4C7pAQeCxx149qAOwooooAKKKKAOf8Pf8hzxZ/2FY/8A0ita 6Cs/TtM+wX2rXPneZ/aF2tzt248vEMUW3Oef9VnPH3sdsnQoAKKKKACiiigAooooAK5+z/5KHrP/ AGCrD/0bd10FZ8OmeV4hvdW87P2m0gtvK2/d8p5m3ZzznzsYxxt754ANCiiigArh/i/f3mmfC3Wb ywu57S6j8jZNBIY3XM8YOGHIyCR+NdxXP+NtK0fW/CF9p2v3/wBg0yby/OufOSLZiRWX5nBUZYKO fWgCTwXPNdeBfD1xcSyTTy6ZbPJJIxZnYxKSSTySTzmtys/QrWzsfD2mWenXH2ixgtIorebeH8yN UAVtw4OQAcjg1oUAFFFFAHP3n/JQ9G/7BV//AOjbSugrPm0zzfENlq3nY+zWk9t5W373mvC27OeM eTjGOd3bHOhQAUUUUAFFFFABRRRQAVz95/yUPRv+wVf/APo20roKz5tM83xDZat52Ps1pPbeVt+9 5rwtuznjHk4xjnd2xyAaFFFFABRRRQBwfwZnmuvhTo9xcSyTTyvcvJJIxZnY3EhJJPJJPOa7yuP+ GFrZ2PgK1s9OuPtFjBd3sVvNvD+ZGt1KFbcODkAHI4NdhQAUUUUAFFFFABRRRQAUUUUAFFFFABRR RQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFF ABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAHP3n/JQ9G/7BV//AOjbSugrn7z/AJKHo3/YKv8A/wBG 2ldBQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAHj/xf/5KH8Mf+wqf/RtvXsFcf4w1 /wAN6R4h8MWet6R9tvr+78rTpvs0cn2aTfGN25iCnLIcrk/L7CuwoAKKKKACiiigAooooAKKKKAC iiigAooooAKKKKACiiigDx/9o7/knmn/APYVj/8ARUtewVx/xH1/w34c8PW954o0j+1LF7tYkh+z Rz7ZCjkNtkIA4DDPXn3rsKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA8/+Nv/ACSH Xf8At3/9KI66DwJ/yTzw1/2CrX/0UtHjbVdH0Twhfajr9h9v0yHy/OtvJSXfmRVX5XIU4YqefStD QrqzvvD2mXmnW/2exntIpbeHYE8uNkBVdo4GAQMDgUAaFFFFABRRRQAUUUUAFFFFABRRRQAUUUUA FFFFABRRRQAV4/8As4/8k81D/sKyf+ioq9grj/hxr/hvxH4euLzwvpH9l2KXbRPD9mjg3SBEJbbG SDwVGevHtQB2FFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBz/jv/AJJ54l/7BV1/6Kav AP2cf+Sh6h/2CpP/AEbFXv8A47/5J54l/wCwVdf+imrwD9nH/koeof8AYKk/9GxUAfT9FFFABRXB /FnxrqXgPwra6ppcFpNPLepbst0jMoUo7ZG1lOcoO/rXjn/DR3jD/oG6H/34m/8AjtAH0/RXzB/w 0d4w/wCgbof/AH4m/wDjtfT9ABRRRQAUUUUAFFFFABRRRQAUUUUAFeP+Hv8Ak6HxZ/2Co/8A0G1r 2CuP07X/AA3cfFDVtDttI8rxDbWiy3V/9mjXzYyIsL5gO9uHTgjHy+woA7CiiigAooooAKKKKACi iigAooooAKKKKACiiigAooooAK8f+L//ACUP4Y/9hU/+jbevYK4/xhr/AIb0jxD4Ys9b0j7bfX93 5WnTfZo5Ps0m+MbtzEFOWQ5XJ+X2FAHYUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABX j/7R3/JPNP8A+wrH/wCipa9grj/iPr/hvw54et7zxRpH9qWL3axJD9mjn2yFHIbbIQBwGGevPvQB 2FFFFABRRWHP408K2txLb3HiXRoZ4nKSRyX8SsjA4IILZBB4xQBuUVz/APwnfg//AKGvQ/8AwYw/ /FVoaZruj635v9k6rY3/AJOPM+yXCS7M5xnaTjOD19DQBoUUUUAFFFFABRRRQAUUUUAFFFFABXn/ AMbf+SQ67/27/wDpRHXoFc/421XR9E8IX2o6/Yfb9Mh8vzrbyUl35kVV+VyFOGKnn0oAPAn/ACTz w1/2CrX/ANFLXQVn6FdWd94e0y8063+z2M9pFLbw7AnlxsgKrtHAwCBgcCtCgAooooAKKKKACiii gAooooAKKKKACiiigAooooAKKKKAPP8A4Jf8kh0L/t4/9KJK9Arj/hhdWd94CtbzTrf7PYz3d7Lb w7AnlxtdSlV2jgYBAwOBXYUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFF ABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUA FFFFABRRRQBz95/yUPRv+wVf/wDo20roK5+8/wCSh6N/2Cr/AP8ARtpXQUAFFFFABRRRQAUUUUAF FFFABRRRQAUUUUAFFFFABRRRQB5X8U9J1LUPHXw7uLLT7u5gtNTL3MkMLOsK+bAcuQMKMKTk+h9K 9Urg/HfjXUvC/irwdpdlBaSQa1em3uWmRiyLviXKYYAHEh6g9BXeUAFFFFABRRRQAUUUUAFFFFAB RRRQAUUUUAFFFFABRRRQB5X8fdJ1LWfAtjb6Xp93fTrqcbtHawtKwXypRkhQTjJAz7ivVK4P4s+N dS8B+FbXVNLgtJp5b1LdlukZlClHbI2spzlB39a7ygAooooAKKKKACiiigAooooAKKKKACiiigAo oooAKKKKAOH+L9hean8LdZs7C0nu7qTyNkMEZkdsTxk4UcnABP4VueC4JrXwL4et7iKSGeLTLZJI 5FKsjCJQQQeQQeMVT+IniS88I+BNS1ywjgkurXytiTqSh3SohyAQejHvWp4a1KbWfCukapcLGs97 ZQ3EixghQzoGIGSTjJ9TQBqUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXlfwC0nUtG 8C31vqmn3djO2pyOsd1C0TFfKiGQGAOMgjPsa9Urg/hN411Lx54VutU1SC0hnivXt1W1RlUqERsn czHOXPf0oA7yiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA5/x3/yTzxL/wBgq6/9FNXg H7OP/JQ9Q/7BUn/o2Kvf/Hf/ACTzxL/2Crr/ANFNXgH7OP8AyUPUP+wVJ/6NioA+n64/x18R9H+H /wBg/ta2vpvt3meX9kRGxs25zuZf746Z712FfHHxT/4Rv/hMtS/sT+1ft39oXX9o/bfL8vzPM/5Y 7edud/3ucbfegD1vUvjx8PtZt1t9U8O6lfQK4dY7qyt5VDYIyA0hGcEjPua8c+I+v+G/EfiG3vPC +kf2XYpaLE8P2aODdIHcltsZIPBUZ68e1cfRQB7hoXxJ+Flj4e0yz1HwV9ovoLSKK4m/sq1fzJFQ Bm3FsnJBOTya6/8A4aO8H/8AQN1z/vxD/wDHa+YKKAPvPSdSh1nRrHVLdZFgvbeO4jWQAMFdQwBw SM4PqauV5P8As8/Y/wDhWsn2bz/O/tCX7V5uNvmbUxsx/Ds2ded27tivWKACiiigAooooAKKKKAC iiigAryvQtJ1KH9o3xPqkun3aafNpiJFdtCwidttvwr4wT8rcA9j6V6pXB6V411K++MuueD5YLQa fYWS3EUio3mliIThjuxj943QDoPxAO8ooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACvK /inpOpah46+HdxZafd3MFpqZe5khhZ1hXzYDlyBhRhScn0PpXqlcH478a6l4X8VeDtLsoLSSDWr0 29y0yMWRd8S5TDAA4kPUHoKAO8ooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACvK/j7pO paz4FsbfS9Pu76ddTjdo7WFpWC+VKMkKCcZIGfcV6pXB/FnxrqXgPwra6ppcFpNPLepbst0jMoUo 7ZG1lOcoO/rQB3lFFcf8R9f8SeHPD1veeF9I/tS+e7WJ4fs0k+2Mo5LbYyCOQoz0596AOwr5o8d/ BTxJ/aPiXxR9t0r7D5t1qHl+bJ5nl5aTGPLxux2zjPevF6KAOk8FeCtS8eazNpelz2kM8Vu1wzXT sqlQyrgbVY5y47etfRfwf+HGsfD/APtn+1rmxm+3eR5f2R3bGzzM53Kv98dM96+UKKAPv+ivkD4N arrGl/EO0/siw+2fatlrefuXk8m3aWPfJ8pG3GB8x4Gea+v6ACiiigAooooAKKKKACiiigArh/i/ YXmp/C3WbOwtJ7u6k8jZDBGZHbE8ZOFHJwAT+FdxXL/ETxJeeEfAmpa5YRwSXVr5WxJ1JQ7pUQ5A IPRj3oAueC4JrXwL4et7iKSGeLTLZJI5FKsjCJQQQeQQeMVuVl+GtSm1nwrpGqXCxrPe2UNxIsYI UM6BiBkk4yfU1qUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBwfwZgmtfhTo9vcRSQ zxPcpJHIpVkYXEgIIPIIPGK7yuL+FGpTaz8OrDVLhY1nvbi7uJFjBChnupWIGSTjJ9TXaUAFFFFA BRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBz95/yUPRv+wVf/APo2 0roK5+8/5KHo3/YKv/8A0baV0FABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAcH478F al4o8VeDtUsp7SODRb03FyszsGdd8TYTCkE4jPUjqK7yvK/inq2paf46+HdvZahd20F3qZS5jhmZ FmXzYBhwDhhhiMH1PrXqlABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAcH8WfBWpePP Ctrpelz2kM8V6lwzXTsqlQjrgbVY5y47etd5Xlfx91bUtG8C2NxpeoXdjO2pxo0lrM0TFfKlOCVI OMgHHsK9UoAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigDl/iJ4bvPF3gTUtDsJII7q6 8rY87EINsqOckAnop7VqeGtNm0bwrpGl3DRtPZWUNvI0ZJUsiBSRkA4yPQVzfxfv7zTPhbrN5YXc 9pdR+RsmgkMbrmeMHDDkZBI/GtzwXPNdeBfD1xcSyTTy6ZbPJJIxZnYxKSSTySTzmgDcooooAKKK KACiiigAooooAKKKKACiiigAooooAKKKKACuD+E3grUvAfhW60vVJ7SaeW9e4VrV2ZQpRFwdyqc5 Q9vSu8ryv4BatqWs+Bb641TULu+nXU5EWS6maVgvlRHALEnGSTj3NAHqlFFFABRRRQAUUUUAFFFF ABRRRQAUUUUAFFFFABRRRQBz/jv/AJJ54l/7BV1/6KavAP2cf+Sh6h/2CpP/AEbFXv8A47/5J54l /wCwVdf+imrwD9nH/koeof8AYKk/9GxUAfT9c/4n8E+HfGP2X+39P+2fZd/k/vpI9u7G77jDOdq9 fSugooA8P+I/gz4efD/w9b6t/wAIb9v867W28r+1LiLGUdt2dzf3MYx3rwjxJqOjanqMc2h6D/Yt qsQRrf7Y9zufJJfc4yMggY9vevs/xJ4W0bxdp0dhrln9rtY5RMqea8eHAIByhB6Mfzrl/wDhSXw8 /wChe/8AJ24/+OUAfPFh4n8CW+nW0N58Ovtd1HEiTXH9tzx+a4ADPtAwuTk4HTNfQ/8AwpL4ef8A Qvf+Ttx/8co/4Ul8PP8AoXv/ACduP/jlegUAV7Cxt9M062sLOPy7W1iSGFNxO1FACjJ5OAB1qxRR QAUUUUAFFFFABRRRQAUUUUAFcHpXgrUrH4y654wlntDp9/ZLbxRq7eaGAhGWG3GP3bdCeo/DvK8r 0LVtSm/aN8T6XLqF2+nw6YjxWjTMYkbbb8qmcA/M3IHc+tAHqlFFFABRRRQAUUUUAFFFFABRRRQA UUUUAFFFFABRRRQAVwfjvwVqXijxV4O1SyntI4NFvTcXKzOwZ13xNhMKQTiM9SOorvK8r+Keralp /jr4d29lqF3bQXeplLmOGZkWZfNgGHAOGGGIwfU+tAHqlFFFABRRRQAUUUUAFFFFABRRRQAUUUUA FFFFABRRRQAVwfxZ8Fal488K2ul6XPaQzxXqXDNdOyqVCOuBtVjnLjt613leV/H3VtS0bwLY3Gl6 hd2M7anGjSWszRMV8qU4JUg4yAcewoA9Urj/AIj+Bf8AhYHh630n+0fsHk3a3Pm+R5ucI67cbl/v 5zntXYUUAfIH/CkviH/0L3/k7b//AByq9/8ACDx3pmnXN/eaF5draxPNM/2uA7UUEscB8nAB6V9j 18qeNIPibdeKvENvbxeLptLlvblI441uWgeEuwAAHylCvGOmKAOD8N+FtZ8XajJYaHZ/a7qOIzMn mpHhAQCcuQOrD866j/hSXxD/AOhe/wDJ23/+OVl6b4a+IOjXDXGl6J4nsZ2Qo0lra3ETFcg4JUA4 yAcewr3P4F/8Jh/xPv8AhK/7c/5d/s39q+d/003bPM/4DnHtQBxHw++Cniq38ZWF/rlt/ZdrYSx3 avvin8145EIjwkmVyM/NzjHTmvpeiigAooooAKKKKACiiigAooooAK5f4ieG7zxd4E1LQ7CSCO6u vK2POxCDbKjnJAJ6Ke1dRXD/ABfv7zTPhbrN5YXc9pdR+RsmgkMbrmeMHDDkZBI/GgDpPDWmzaN4 V0jS7ho2nsrKG3kaMkqWRApIyAcZHoK1Kw/Bc8114F8PXFxLJNPLpls8kkjFmdjEpJJPJJPOa3KA CiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA4v4UabNo3w6sNLuGjaeyuLu3kaMkqWS6l UkZAOMj0FdpXB/Bmea6+FOj3FxLJNPK9y8kkjFmdjcSEkk8kk85rvKACiiigAooooAKKKKACiiig AooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAC iiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA5+8/5KHo3/AGCr/wD9G2ldBXP3n/JQ9G/7 BV//AOjbSugoAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigDj/GGgeG9X8Q+GLzW9X+x X1hd+bp0P2mOP7TJvjO3awJflUGFwfm9xXYV4/8AF/8A5KH8Mf8AsKn/ANG29ewUAFFFFABRRRQA UUUUAFFFFABRRRQAUUUUAFFFFABRRRQBx/xH0Dw34j8PW9n4o1f+y7FLtZUm+0xwbpAjgLukBB4L HHXj2rsK8f8A2jv+Seaf/wBhWP8A9FS17BQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFF FAHP+NtK0fW/CF9p2v3/ANg0yby/OufOSLZiRWX5nBUZYKOfWtDQrWzsfD2mWenXH2ixgtIorebe H8yNUAVtw4OQAcjg1x/xt/5JDrv/AG7/APpRHXQeBP8Aknnhr/sFWv8A6KWgDoKKKKACiiigAooo oAKKKKACiiigAooooAKKKKACiiigArj/AIcaB4b8OeHriz8L6v8A2pYvdtK832mOfbIUQFd0YAHA U468+9dhXj/7OP8AyTzUP+wrJ/6KioA9gooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAO f8d/8k88S/8AYKuv/RTV4B+zj/yUPUP+wVJ/6Nir3/x3/wAk88S/9gq6/wDRTV4B+zj/AMlD1D/s FSf+jYqAPp+iiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK4/TtA8N2/xQ1bXLbV/N8Q3 NosV1YfaY28qMCLDeWBvXhE5Jx83uK7CvH/D3/J0Piz/ALBUf/oNrQB7BRRRQAUUUUAFFFFABRRR QAUUUUAFFFFABRRRQAUUUUAFcf4w0Dw3q/iHwxea3q/2K+sLvzdOh+0xx/aZN8Z27WBL8qgwuD83 uK7CvH/i/wD8lD+GP/YVP/o23oA9gooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACuP8A iPoHhvxH4et7PxRq/wDZdil2sqTfaY4N0gRwF3SAg8Fjjrx7V2FeP/tHf8k80/8A7Csf/oqWgD2C iiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK5/wAbaVo+t+EL7Ttfv/sGmTeX51z5yRbM SKy/M4KjLBRz610Fef8Axt/5JDrv/bv/AOlEdAHYaFa2dj4e0yz064+0WMFpFFbzbw/mRqgCtuHB yADkcGtCuf8AAn/JPPDX/YKtf/RS10FABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAc f8MLWzsfAVrZ6dcfaLGC7vYrebeH8yNbqUK24cHIAORwa7CvP/gl/wAkh0L/ALeP/SiSvQKACiii gAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKA CiiigAooooAKKKKACiiigAooooAKKKp6rqtjoel3Gp6ncx21nbpvllfoo/mSTgADkkgDJNAFyivO /hp8SZviFqniIrZx2un2LwizBz5rK+/JkOSM/IDgdM4y3WvQJ54bW3luLiWOGCJC8kkjBVRQMkkn gADnNAElFeZ+Dfisvjf4jaho2mW8Y0W2smmiuHVhLM6yIu7GcKhDnAIzwCSM7R1HjnxnY+BfDUms X0ckxLiG3gTgzSkEhc4wowpJJ6AHAJwCAdJRXic3j34waXpY1vU/BWmjS4kWe4CZWURcE/L5rMhA POUO3kkcGvRP+E/0L/hX/wDwmnmT/wBk+V5mPKPmbt2zZt/vb/l67c85xzQB1FFeJw+PfjBqmlnW 9M8FaadLlRp7cPlpTFyR8vmqzkgcYQbuCByK9A8K/EDSPE/gqXxOvmWtvao5vo3UsbdkUM4yB84C kEEDkEcA5AAOsorxe1+InxO8VefqfhDwhYyaE0rR2sl8wWRwvBJzMoPOfuggHK5JUmu0+HPj1fG+ l3KXVpJY61pziHUbRkZQj8gFc8gEq3ynlSCDngkA1Lz/AJKHo3/YKv8A/wBG2ldBXP3n/JQ9G/7B V/8A+jbSugoAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigDj/GGv+G9I8Q+GLPW9I+23 1/d+Vp032aOT7NJvjG7cxBTlkOVyfl9hXYV5X8U9J1LUPHXw7uLLT7u5gtNTL3MkMLOsK+bAcuQM KMKTk+h9K9UoAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigDj/iPr/hvw54et7zxRpH9 qWL3axJD9mjn2yFHIbbIQBwGGevPvXYV5X8fdJ1LWfAtjb6Xp93fTrqcbtHawtKwXypRkhQTjJAz 7ivVKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA5/xtquj6J4QvtR1+w+36ZD5fnW3 kpLvzIqr8rkKcMVPPpWhoV1Z33h7TLzTrf7PYz2kUtvDsCeXGyAqu0cDAIGBwK5f4v2F5qfwt1mz sLSe7upPI2QwRmR2xPGThRycAE/hW54LgmtfAvh63uIpIZ4tMtkkjkUqyMIlBBB5BB4xQBuUUUUA FFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXH/DjX/DfiPw9cXnhfSP7LsUu2ieH7NHBukCIS 22MkHgqM9ePauwryv4BaTqWjeBb631TT7uxnbU5HWO6haJivlRDIDAHGQRn2NAHqlFFFABRRRQAU UUUAFFFFABRRRQAUUUUAFFFFABRRRQBz/jv/AJJ54l/7BV1/6KavAP2cf+Sh6h/2CpP/AEbFXv8A 47/5J54l/wCwVdf+imrwD9nH/koeof8AYKk/9GxUAfT9FFFABRRRQAUUUUAFFFFABRRRQAUUUUAF FFFABRRRQAVx+na/4buPihq2h22keV4htrRZbq/+zRr5sZEWF8wHe3DpwRj5fYV2FeV6FpOpQ/tG +J9Ul0+7TT5tMRIrtoWETttt+FfGCflbgHsfSgD1SiiigAooooAKKKKACiiigAooooAKKKKACiii gAooooAK4/xhr/hvSPEPhiz1vSPtt9f3fladN9mjk+zSb4xu3MQU5ZDlcn5fYV2FeV/FPSdS1Dx1 8O7iy0+7uYLTUy9zJDCzrCvmwHLkDCjCk5PofSgD1SiiigAooooAKKKKACiiigAooooAKKKKACii igAooooAK4/4j6/4b8OeHre88UaR/ali92sSQ/Zo59shRyG2yEAcBhnrz712FeV/H3SdS1nwLY2+ l6fd3066nG7R2sLSsF8qUZIUE4yQM+4oA9UooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKK ACuf8baro+ieEL7UdfsPt+mQ+X51t5KS78yKq/K5CnDFTz6V0FcP8X7C81P4W6zZ2FpPd3UnkbIY IzI7YnjJwo5OACfwoA6jQrqzvvD2mXmnW/2exntIpbeHYE8uNkBVdo4GAQMDgVoVh+C4JrXwL4et 7iKSGeLTLZJI5FKsjCJQQQeQQeMVuUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBx/ wwurO+8BWt5p1v8AZ7Ge7vZbeHYE8uNrqUqu0cDAIGBwK7CuD+DME1r8KdHt7iKSGeJ7lJI5FKsj C4kBBB5BB4xXeUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUU UUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVz/iHwXoXirUdNvNatPtn9nbzBC7Hy yzFCSyj73+rAwflIJyDxjoKKAPH/AIQf8lD+J3/YVH/o24r0TxR4S0jxjZW1lrUMk9pBcC48lZCg dgjoAxXBx85PBHIHbIPnfwg/5KH8Tv8AsKj/ANG3FewUAeN+FoIbX9pnxRb28UcMEWjxJHHGoVUU JagAAcAAcYqT4y/6R4y+HOnT/vbG51X9/bP80cuJIVG5Tw3DsOezH1NHh7/k6HxZ/wBgqP8A9Bta ufG7Sr7+y9E8V6XbSXN54evRdGPqgi4ZndRhiA0cecHgFieBkAHqE8EN1by29xFHNBKhSSORQyup GCCDwQRxivkz7fef8M5+R9rn8n/hJfI8vzDt8vyPM2Y/u7/mx03c9a9j1X48+D4vDVxd6ZfSTaob fdb2UtpICJSOFc8LgE/NhugOCeM8n/wrHUf+GdvsX2G+/tv7X/a32LK793+r27cZ/wBT82z727jr 8tAHvkEENrbxW9vFHDBEgSOONQqooGAABwABxivmhp5tO8LfGSysZZLW0g1OFIYIGKJGr3TxuFUc AMgCkDqAAeK9H0r48+D5fDVvd6nfSQ6oLfdcWUVpISZQOVQ8rgkfLluhGSOcc34Q8F6j4o+F/jTU 9QtJ4NT8USteW8CMsaSbCZYSobJVWkZh8x5XBBGdxAPVPh9BDbfDnw2kEUcSHTLdyqKFBZowzHju WJJPckmuD8Lf6J+0r4ws7b9zay6ek8kMfyo8mIDvKjgtl3Oevzt6mo/Afxg8N6V4OsNH8T3cml6t pifYZrd7OY8R/Kp+UNg7QAQcHcG4AxUnwoS48U+OfFHxDns57a1vsWmnlgFWWJSASVySWAiiBIO3 cXAzjgA7TXtTg0rx1ok9xHdujaZfIBa2ktw2fNtDysasQOOuMdPUVc/4TLS/+fXXP/BFe/8Axmi8 /wCSh6N/2Cr/AP8ARtpXQUAZ9rrNreadPfRRXyww7tyzWE8UhwMnbG6B24PG0HJ4GTxWf/wmWl/8 +uuf+CK9/wDjNdBRQBn3Ws2tnp0F9LFfNDNt2rDYTyyDIyN0aIXXgc7gMHg4PFU4PFmnXNxFAltr IeRwimTRbxFBJxyzRAKPckAd63KKAMvUtfs9KuFguIdSd2QODa6bcXC4yRy0aMAeOmc9PUUabr9n qtw0FvDqSOqFybrTbi3XGQOGkRQTz0znr6GtSigDDn8WadbXEsD22sl43KMY9FvHUkHHDLEQw9wS D2q5a6za3mnT30UV8sMO7cs1hPFIcDJ2xugduDxtByeBk8VoUUAc/wD8Jlpf/Prrn/givf8A4zWh daza2enQX0sV80M23asNhPLIMjI3RohdeBzuAweDg8VoUUAYcHizTrm4igS21kPI4RTJot4igk45 ZogFHuSAO9WNS1+z0q4WC4h1J3ZA4NrptxcLjJHLRowB46Zz09RWpRQBl6br9nqtw0FvDqSOqFyb rTbi3XGQOGkRQTz0znr6Gq8/izTra4lge21kvG5RjHot46kg44ZYiGHuCQe1blFAGfa6za3mnT30 UV8sMO7cs1hPFIcDJ2xugduDxtByeBk8Vn/8Jlpf/Prrn/givf8A4zXQUUAed+O/iFe+F9Z8HQ2V tHJZ61cFbnzrWUzpHuiHyRjDB8SH5SpOQBjPFdRB4s065uIoEttZDyOEUyaLeIoJOOWaIBR7kgDv XP8AjvwVqXijxV4O1SyntI4NFvTcXKzOwZ13xNhMKQTiM9SOorvKAMvUtfs9KuFguIdSd2QODa6b cXC4yRy0aMAeOmc9PUUabr9nqtw0FvDqSOqFybrTbi3XGQOGkRQTz0znr6GtSigDDn8WadbXEsD2 2sl43KMY9FvHUkHHDLEQw9wSD2q5a6za3mnT30UV8sMO7cs1hPFIcDJ2xugduDxtByeBk8VoUUAc /wD8Jlpf/Prrn/givf8A4zWhdaza2enQX0sV80M23asNhPLIMjI3RohdeBzuAweDg8VoUUAYcHiz Trm4igS21kPI4RTJot4igk45ZogFHuSAO9WNS1+z0q4WC4h1J3ZA4NrptxcLjJHLRowB46Zz09RW pRQBl6br9nqtw0FvDqSOqFybrTbi3XGQOGkRQTz0znr6Gq8/izTra4lge21kvG5RjHot46kg44ZY iGHuCQe1blFAGfa6za3mnT30UV8sMO7cs1hPFIcDJ2xugduDxtByeBk8Vn/8Jlpf/Prrn/givf8A 4zXQUUAZ91rNrZ6dBfSxXzQzbdqw2E8sgyMjdGiF14HO4DB4ODxVODxZp1zcRQJbayHkcIpk0W8R QSccs0QCj3JAHetyigDL1LX7PSrhYLiHUndkDg2um3FwuMkctGjAHjpnPT1FGm6/Z6rcNBbw6kjq hcm6024t1xkDhpEUE89M56+hrUooA8z+J/xOuPCGjJNo1nJJeC9FvJ9v065SDbtckrIQiscqMYY5 GSMjmu8tdZtbzTp76KK+WGHduWawnikOBk7Y3QO3B42g5PAyeK5P4s+CtS8eeFbXS9LntIZ4r1Lh munZVKhHXA2qxzlx29a7ygDn/wDhMtL/AOfXXP8AwRXv/wAZrQutZtbPToL6WK+aGbbtWGwnlkGR kbo0QuvA53AYPBweK0KKAMODxZp1zcRQJbayHkcIpk0W8RQSccs0QCj3JAHerGpa/Z6VcLBcQ6k7 sgcG1024uFxkjlo0YA8dM56eorUooAy9N1+z1W4aC3h1JHVC5N1ptxbrjIHDSIoJ56Zz19DVefxZ p1tcSwPbayXjcoxj0W8dSQccMsRDD3BIPatyigDPtdZtbzTp76KK+WGHduWawnikOBk7Y3QO3B42 g5PAyeKz/wDhMtL/AOfXXP8AwRXv/wAZroKKAM+61m1s9OgvpYr5oZtu1YbCeWQZGRujRC68DncB g8HB4qnB4s065uIoEttZDyOEUyaLeIoJOOWaIBR7kgDvW5RQBl6lr9npVwsFxDqTuyBwbXTbi4XG SOWjRgDx0znp6ijTdfs9VuGgt4dSR1QuTdabcW64yBw0iKCeemc9fQ1qUUAYc/izTra4lge21kvG 5RjHot46kg44ZYiGHuCQe1XLXWbW806e+iivlhh3blmsJ4pDgZO2N0DtweNoOTwMnitCigDn/wDh MtL/AOfXXP8AwRXv/wAZrQutZtbPToL6WK+aGbbtWGwnlkGRkbo0QuvA53AYPBweK0KKAPP/ABt8 SU0HwhfalpNnfNfQ+X5Yv9Hu4oeZFU7mZEA4Jxlhzjr0rY0zxjDJ4e0a91G2vjdX2nwXbix0y5nj UugJAaNGA5zwTnGPWj4ieG7zxd4E1LQ7CSCO6uvK2POxCDbKjnJAJ6Ke1anhrTZtG8K6Rpdw0bT2 VlDbyNGSVLIgUkZAOMj0FABpuv2eq3DQW8OpI6oXJutNuLdcZA4aRFBPPTOevoarz+LNOtriWB7b WS8blGMei3jqSDjhliIYe4JB7VuUUAZ9rrNreadPfRRXyww7tyzWE8UhwMnbG6B24PG0HJ4GTxWf /wAJlpf/AD665/4Ir3/4zXQUUAZ91rNrZ6dBfSxXzQzbdqw2E8sgyMjdGiF14HO4DB4ODxVODxZp 1zcRQJbayHkcIpk0W8RQSccs0QCj3JAHetyigDL1LX7PSrhYLiHUndkDg2um3FwuMkctGjAHjpnP T1FGm6/Z6rcNBbw6kjqhcm6024t1xkDhpEUE89M56+hrUooAw5/FmnW1xLA9trJeNyjGPRbx1JBx wyxEMPcEg9quWus2t5p099FFfLDDu3LNYTxSHAydsboHbg8bQcngZPFaFFAHP/8ACZaX/wA+uuf+ CK9/+M1oXWs2tnp0F9LFfNDNt2rDYTyyDIyN0aIXXgc7gMHg4PFaFFAGHB4s065uIoEttZDyOEUy aLeIoJOOWaIBR7kgDvVjUtfs9KuFguIdSd2QODa6bcXC4yRy0aMAeOmc9PUVqUUAZem6/Z6rcNBb w6kjqhcm6024t1xkDhpEUE89M56+hqvP4s062uJYHttZLxuUYx6LeOpIOOGWIhh7gkHtW5RQBn2u s2t5p099FFfLDDu3LNYTxSHAydsboHbg8bQcngZPFef/AA4+Ks3ifw9cXuuWU6XSXbRKNM0q6mj2 BEIyyK4DZY8Z6Y49fUK4P4TeCtS8B+FbrS9UntJp5b17hWtXZlClEXB3KpzlD29KAOsutZtbPToL 6WK+aGbbtWGwnlkGRkbo0QuvA53AYPBweKpweLNOubiKBLbWQ8jhFMmi3iKCTjlmiAUe5IA71uUU AZepa/Z6VcLBcQ6k7sgcG1024uFxkjlo0YA8dM56eoo03X7PVbhoLeHUkdULk3Wm3FuuMgcNIign npnPX0NalFAGHP4s062uJYHttZLxuUYx6LeOpIOOGWIhh7gkHtVy11m1vNOnvoor5YYd25ZrCeKQ 4GTtjdA7cHjaDk8DJ4rQooA5/wD4TLS/+fXXP/BFe/8AxmtC61m1s9OgvpYr5oZtu1YbCeWQZGRu jRC68DncBg8HB4rQooAw4PFmnXNxFAltrIeRwimTRbxFBJxyzRAKPckAd6salr9npVwsFxDqTuyB wbXTbi4XGSOWjRgDx0znp6itSigDL03X7PVbhoLeHUkdULk3Wm3FuuMgcNIignnpnPX0NV5/FmnW 1xLA9trJeNyjGPRbx1JBxwyxEMPcEg9q3KKAM+11m1vNOnvoor5YYd25ZrCeKQ4GTtjdA7cHjaDk 8DJ4rP8A+Ey0v/n11z/wRXv/AMZroKKAM+61m1s9OgvpYr5oZtu1YbCeWQZGRujRC68DncBg8HB4 qnB4s065uIoEttZDyOEUyaLeIoJOOWaIBR7kgDvW5RQBx/xF1m1s/Buv2MsV8002lXG1obCeWMZj cDdIiFF5HO4jA5OBzXiH7OP/ACUPUP8AsFSf+jYq9/8AHf8AyTzxL/2Crr/0U1eAfs4/8lD1D/sF Sf8Ao2KgD6Dn8WadbXEsD22sl43KMY9FvHUkHHDLEQw9wSD2q5a6za3mnT30UV8sMO7cs1hPFIcD J2xugduDxtByeBk8VoUUAc//AMJlpf8Az665/wCCK9/+M1oXWs2tnp0F9LFfNDNt2rDYTyyDIyN0 aIXXgc7gMHg4PFaFFAGHB4s065uIoEttZDyOEUyaLeIoJOOWaIBR7kgDvVjUtfs9KuFguIdSd2QO Da6bcXC4yRy0aMAeOmc9PUVqUUAZem6/Z6rcNBbw6kjqhcm6024t1xkDhpEUE89M56+hqvP4s062 uJYHttZLxuUYx6LeOpIOOGWIhh7gkHtW5RQBn2us2t5p099FFfLDDu3LNYTxSHAydsboHbg8bQcn gZPFZ/8AwmWl/wDPrrn/AIIr3/4zXQUUAZ91rNrZ6dBfSxXzQzbdqw2E8sgyMjdGiF14HO4DB4OD xVODxZp1zcRQJbayHkcIpk0W8RQSccs0QCj3JAHetyigDL1LX7PSrhYLiHUndkDg2um3FwuMkctG jAHjpnPT1FGm6/Z6rcNBbw6kjqhcm6024t1xkDhpEUE89M56+hrUooAw5/FmnW1xLA9trJeNyjGP Rbx1JBxwyxEMPcEg9quWus2t5p099FFfLDDu3LNYTxSHAydsboHbg8bQcngZPFaFFAHP/wDCZaX/ AM+uuf8Agivf/jNcna/E64b4qar4durOQ6TbWUdxA1vp1zJdbmSFsOiglR+8bqgwcA89fTK4PSvB WpWPxl1zxhLPaHT7+yW3ijV280MBCMsNuMfu26E9R+AB0EHizTrm4igS21kPI4RTJot4igk45Zog FHuSAO9WNS1+z0q4WC4h1J3ZA4NrptxcLjJHLRowB46Zz09RWpRQBl6br9nqtw0FvDqSOqFybrTb i3XGQOGkRQTz0znr6Gq8/izTra4lge21kvG5RjHot46kg44ZYiGHuCQe1blFAGfa6za3mnT30UV8 sMO7cs1hPFIcDJ2xugduDxtByeBk8Vn/APCZaX/z665/4Ir3/wCM10FFAGfdaza2enQX0sV80M23 asNhPLIMjI3RohdeBzuAweDg8VTg8Wadc3EUCW2sh5HCKZNFvEUEnHLNEAo9yQB3rcooAy9S1+z0 q4WC4h1J3ZA4NrptxcLjJHLRowB46Zz09RRpuv2eq3DQW8OpI6oXJutNuLdcZA4aRFBPPTOevoa1 KKAMOfxZp1tcSwPbayXjcoxj0W8dSQccMsRDD3BIParlrrNreadPfRRXyww7tyzWE8UhwMnbG6B2 4PG0HJ4GTxWhRQBz/wDwmWl/8+uuf+CK9/8AjNaF1rNrZ6dBfSxXzQzbdqw2E8sgyMjdGiF14HO4 DB4ODxWhRQBhweLNOubiKBLbWQ8jhFMmi3iKCTjlmiAUe5IA71Y1LX7PSrhYLiHUndkDg2um3Fwu MkctGjAHjpnPT1FalFAGXpuv2eq3DQW8OpI6oXJutNuLdcZA4aRFBPPTOevoa4fxv8Trjw54q8O6 XYWcjwXt61vfNc6dchtoeNcwcASHDN90Pn5cdRn0yuD8d+CtS8UeKvB2qWU9pHBot6bi5WZ2DOu+ JsJhSCcRnqR1FAHWWus2t5p099FFfLDDu3LNYTxSHAydsboHbg8bQcngZPFZ/wDwmWl/8+uuf+CK 9/8AjNdBRQBn3Ws2tnp0F9LFfNDNt2rDYTyyDIyN0aIXXgc7gMHg4PFU4PFmnXNxFAltrIeRwimT RbxFBJxyzRAKPckAd63KKAMvUtfs9KuFguIdSd2QODa6bcXC4yRy0aMAeOmc9PUUabr9nqtw0FvD qSOqFybrTbi3XGQOGkRQTz0znr6GtSigDDn8WadbXEsD22sl43KMY9FvHUkHHDLEQw9wSD2q5a6z a3mnT30UV8sMO7cs1hPFIcDJ2xugduDxtByeBk8VoUUAc/8A8Jlpf/Prrn/givf/AIzWhdaza2en QX0sV80M23asNhPLIMjI3RohdeBzuAweDg8VoUUAYcHizTrm4igS21kPI4RTJot4igk45ZogFHuS AO9WNS1+z0q4WC4h1J3ZA4NrptxcLjJHLRowB46Zz09RWpRQBl6br9nqtw0FvDqSOqFybrTbi3XG QOGkRQTz0znr6Gq8/izTra4lge21kvG5RjHot46kg44ZYiGHuCQe1blFAGfa6za3mnT30UV8sMO7 cs1hPFIcDJ2xugduDxtByeBk8Vn/APCZaX/z665/4Ir3/wCM10FFAGfdaza2enQX0sV80M23asNh PLIMjI3RohdeBzuAweDg8V5/8R/irN4Y8PW97odlO9092sTDU9KuoY9hRycM6oC2VHGemePT1CuD +LPgrUvHnhW10vS57SGeK9S4Zrp2VSoR1wNqsc5cdvWgDqNS1+z0q4WC4h1J3ZA4NrptxcLjJHLR owB46Zz09RRpuv2eq3DQW8OpI6oXJutNuLdcZA4aRFBPPTOevoa1KKAMOfxZp1tcSwPbayXjcoxj 0W8dSQccMsRDD3BIParlrrNreadPfRRXyww7tyzWE8UhwMnbG6B24PG0HJ4GTxWhRQBz/wDwmWl/ 8+uuf+CK9/8AjNaF1rNrZ6dBfSxXzQzbdqw2E8sgyMjdGiF14HO4DB4ODxWhRQBhweLNOubiKBLb WQ8jhFMmi3iKCTjlmiAUe5IA71Y1LX7PSrhYLiHUndkDg2um3FwuMkctGjAHjpnPT1FalFAGXpuv 2eq3DQW8OpI6oXJutNuLdcZA4aRFBPPTOevoarz+LNOtriWB7bWS8blGMei3jqSDjhliIYe4JB7V uUUAZ9rrNreadPfRRXyww7tyzWE8UhwMnbG6B24PG0HJ4GTxWf8A8Jlpf/Prrn/givf/AIzXQUUA Z91rNrZ6dBfSxXzQzbdqw2E8sgyMjdGiF14HO4DB4ODxVODxZp1zcRQJbayHkcIpk0W8RQSccs0Q Cj3JAHetyigDL1LX7PSrhYLiHUndkDg2um3FwuMkctGjAHjpnPT1FGm6/Z6rcNBbw6kjqhcm6024 t1xkDhpEUE89M56+hrUooAw5/FmnW1xLA9trJeNyjGPRbx1JBxwyxEMPcEg9qx/GXjaXRvh5qniP R7eQz2jxoseo2U0AJaRFPyOEYjD8EcZ+hFdpXL/ETw3eeLvAmpaHYSQR3V15Wx52IQbZUc5IBPRT 2oAr6F4+tNQ8PaZe3lpqouri0ilmFvol48YdkBbYwjIK5JwQTkdzXQXWs2tnp0F9LFfNDNt2rDYT yyDIyN0aIXXgc7gMHg4PFR+GtNm0bwrpGl3DRtPZWUNvI0ZJUsiBSRkA4yPQVqUAYcHizTrm4igS 21kPI4RTJot4igk45ZogFHuSAO9WNS1+z0q4WC4h1J3ZA4NrptxcLjJHLRowB46Zz09RWpRQBl6b r9nqtw0FvDqSOqFybrTbi3XGQOGkRQTz0znr6Gq8/izTra4lge21kvG5RjHot46kg44ZYiGHuCQe 1blFAGfa6za3mnT30UV8sMO7cs1hPFIcDJ2xugduDxtByeBk8Vn/APCZaX/z665/4Ir3/wCM10FF AGfdaza2enQX0sV80M23asNhPLIMjI3RohdeBzuAweDg8VTg8Wadc3EUCW2sh5HCKZNFvEUEnHLN EAo9yQB3rcooAy9S1+z0q4WC4h1J3ZA4NrptxcLjJHLRowB46Zz09RRpuv2eq3DQW8OpI6oXJutN uLdcZA4aRFBPPTOevoa1KKAMOfxZp1tcSwPbayXjcoxj0W8dSQccMsRDD3BIParlrrNreadPfRRX yww7tyzWE8UhwMnbG6B24PG0HJ4GTxWhRQBz/wDwmWl/8+uuf+CK9/8AjNaF1rNrZ6dBfSxXzQzb dqw2E8sgyMjdGiF14HO4DB4ODxWhRQBz/wDwmWl/8+uuf+CK9/8AjNH/AAmWl/8APrrn/givf/jN dBRQBxfwo1KbWfh1YapcLGs97cXdxIsYIUM91KxAyScZPqa7SuL+FGmzaN8OrDS7ho2nsri7t5Gj JKlkupVJGQDjI9BXaUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRR QAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAU7PSdN0+4uriy0+0tp7t9 9zJDCqNM2ScuQMscsTk+p9auUUUAU49J02HVJtUi0+0TUJk2S3awqJXXjhnxkj5V4J7D0q5RRQBh weC/CtrcRXFv4a0aGeJw8ckdhErIwOQQQuQQec1uUUUAYc/gvwrdXEtxceGtGmnlcvJJJYRMzsTk kkrkknnNblFFAGPfeE/Dep3kl5f+H9Ku7qTG+aeyjkdsAAZYjJwAB+FakEENrbxW9vFHDBEgSOON QqooGAABwABxipKKAOfvP+Sh6N/2Cr//ANG2ldBXP3n/ACUPRv8AsFX/AP6NtK6CgAoorL8S6lNo 3hXV9Ut1jaeyspriNZASpZELAHBBxkeooA1KK+Z4/wBoPxpLGHWw8OAH+9vU/kZs0yL44+LtGtU0 +3stAa3skEMZkLGQog2jIEo5wPQc9qh1I3tc6VhKrpupyvp0fW+v4H03RXL/AA78SXni7wJpuuX8 cEd1debvSBSEG2V0GAST0Ud66irOYKKKKACiiigAooooAKKKKACiiigDyv4p6tqWn+Ovh3b2WoXd tBd6mUuY4ZmRZl82AYcA4YYYjB9T616pXH+MNA8N6v4h8MXmt6v9ivrC783ToftMcf2mTfGdu1gS /KoMLg/N7iuwoAKKKKACivmD/ho7xh/0DdD/AO/E3/x2j/ho7xh/0DdD/wC/E3/x2gD6forg/hN4 11Lx54VutU1SC0hnivXt1W1RlUqERsnczHOXPf0rvKACiiigAooooAKKKKACiiigAooooA8r+Pur alo3gWxuNL1C7sZ21ONGktZmiYr5UpwSpBxkA49hXqlcf8R9A8N+I/D1vZ+KNX/suxS7WVJvtMcG 6QI4C7pAQeCxx149q7CgAooooAKKqX2q6dpnl/b7+1tPMzs8+ZY92MZxk84yPzrD03xTo32/V/P1 6w8v7Wvkb7xMbPIiztyem7d07575qHOKdmzop4WrUi5Ri7Lyfex09FMiljnhSaGRZIpFDI6HKsDy CCOop9Wc7VtGFFFFABRRRQAUUUUAFFFFABRRRQBw/wAX7+80z4W6zeWF3PaXUfkbJoJDG65njBww 5GQSPxrc8FzzXXgXw9cXEsk08umWzySSMWZ2MSkkk8kk85qPxtpWj634QvtO1+/+waZN5fnXPnJF sxIrL8zgqMsFHPrWhoVrZ2Ph7TLPTrj7RYwWkUVvNvD+ZGqAK24cHIAORwaANCiiigAorhvGPxV0 XwTrsGkX9jqlzdTW4uE+xwo42lmXHLg5+Q9q5l/jloz6lBeLpHiNbWKGSKSH7MgLu5QqwXzMEAI4 z23D1NTKajub0cNUrfAm9+nZXPX6K878N/GTQfE3ia00C203WLa8ug5jN1BGigKjMc4cnop7da9E qk77GMouLtJWYUUUUCCiiigAooooAKKKKACiiigAryv4BatqWs+Bb641TULu+nXU5EWS6maVgvlR HALEnGSTj3NeqVx/w40Dw34c8PXFn4X1f+1LF7tpXm+0xz7ZCiArujAA4CnHXn3oA7CiiigAoooo AKKKKACiiigAooooAKKKKACiiigAooooA5/x3/yTzxL/ANgq6/8ARTV4B+zj/wAlD1D/ALBUn/o2 Kvf/AB3/AMk88S/9gq6/9FNXgH7OP/JQ9Q/7BUn/AKNioA+n6KKKACiiigAooooAKKKKACiiigAo oooAKKKKACiiigAryvQtW1Kb9o3xPpcuoXb6fDpiPFaNMxiRttvyqZwD8zcgdz616pXH6doHhu3+ KGra5bav5viG5tFiurD7TG3lRgRYbywN68InJOPm9xQB2FFFFABRRRQAUUUUAFFFFABRRRQAUUUU AFFFFABRRRQAV5X8U9W1LT/HXw7t7LULu2gu9TKXMcMzIsy+bAMOAcMMMRg+p9a9Urj/ABhoHhvV /EPhi81vV/sV9YXfm6dD9pjj+0yb4zt2sCX5VBhcH5vcUAdhRRRQAUUUUAFFFFABRRRQAUUUUAFF FFABRRRQAUUUUAFeV/H3VtS0bwLY3Gl6hd2M7anGjSWszRMV8qU4JUg4yAcewr1SuP8AiPoHhvxH 4et7PxRq/wDZdil2sqTfaY4N0gRwF3SAg8Fjjrx7UAdhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAB RRRQAUUUUAFcP8X7+80z4W6zeWF3PaXUfkbJoJDG65njBww5GQSPxruK5/xtpWj634QvtO1+/wDs GmTeX51z5yRbMSKy/M4KjLBRz60ASeC55rrwL4euLiWSaeXTLZ5JJGLM7GJSSSeSSec1uVn6Fa2d j4e0yz064+0WMFpFFbzbw/mRqgCtuHByADkcGtCgAooooAKKKKACiiigAooooAKKKKACiiigAooo oAKKKKAOD+DM8118KdHuLiWSaeV7l5JJGLM7G4kJJJ5JJ5zXeVx/wwtbOx8BWtnp1x9osYLu9it5 t4fzI1upQrbhwcgA5HBrsKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiig AooooAKKKKACiiigAooooAKKKKACiiigAooooAKK8f8AFnxwii1FdF8DWH9v6m+4GREd41ZTyFVR ul+VWOVIUDBBbkDiJfhz8WviBE1z4gv/ALPC3lzRwajclEJ2kArDGCI2A65VT8x75oA97n8aeFbW 4lt7jxLo0M8TlJI5L+JWRgcEEFsgg8YqxpviXQdZuGt9L1vTb6dULtHa3SSsFyBkhSTjJAz7ivEI P2Zpmt4muPFccc5QGRI7AuqtjkBjICRnvgZ9BVfUv2adSit1bS/Elpcz7wGS6tmgULg8hlLknOOM dzzxyAfRdFfOFtY/Gb4aTqLaOfWtNTZCkKM17CQEO0KnEsarnHAUZUA5GM+n+APi3oXjrZZ/8g/W W3n7BK5bcq85R8ANwc44YYbjAyQD0CiiigAooooAKKKKACiiigAooooAKKKKAOfvP+Sh6N/2Cr// ANG2ldBXP3n/ACUPRv8AsFX/AP6NtK6CgDz/AOJnxMsvA+mT21tcQN4haKOa1tJ4JGSRDJtJJXAH Af8AiHT8/HJ/2h/FV1by29xpHh+aCVCkkcltKyupGCCDJggjjFdf8dPh3r3iHUk8SaXHHcwWllFb taRK73Ejea3KIqkEASAnnoD6V4hP4L8VWtvLcXHhrWYYIkLySSWEqqigZJJK4AA5zQBc8SeNP+Ej 06Oz/wCEZ8OaXslEvnaZYeRI2ARtLbjlec49QPSptG8crocd3Cvhjw7qaz3LzibVbDzpVDYG0NuG F4zj1JrkaVlZGKspVlOCCMEGlZXuWpPkcemn6nq9j+0B4k0yzjs7DQ/Dlpax52QwWkkaLkknCiTA yST+Net/Cb4onx5b3VpqjWkOtRO8i21rDIqm3AQbyWLDO5yMZz04718yWPhPxJqdnHeWHh/Vbu1k zsmgspJEbBIOGAwcEEfhXtfwC8C69o2s33iDVLOSxga3kslt7qJ4py26J94VlA2YBGc9QeKZB75R RRQAUUUUAFFFFABRRRQAUUUUAeP/ABf/AOSh/DH/ALCp/wDRtvXsFcf4w1/w3pHiHwxZ63pH22+v 7vytOm+zRyfZpN8Y3bmIKcshyuT8vsK7CgDg/ih8Q7bwJowiZLsahqNvcLYywxo6xSqo2s+4jjc6 noeh49fnz/hdvxD/AOhh/wDJK3/+N17H8dtJ8Q6ho1pcaPp9pc2dpb3b6hJNDbu0Me1DlDKNynCu cx88DuBXy5QBsX3iW/1CzktZrfSkjfGTBpNrC4wQeHSMMOnY89OlV9M1m60jzfs0VjJ5uN32uwgu cYzjHmo23r2xnjPQVn0UAdppvxX8Y6Nbtb6XqNpYwM5do7XTLWJS2AMkLGBnAAz7CvU/g58WtW17 xHJofiW8nvbq9x9hdLeJEi2JI8m4qFPIC44PTtXzxXrHwBsNWuPHaXlnaQSaba5+3TPHEXi3RSiP azfOuWyDs6/xcUAfU9FFFABRRRQAUUUUAFFFFABRRRQB4/8AtHf8k80//sKx/wDoqWvYK4/4j6/4 b8OeHre88UaR/ali92sSQ/Zo59shRyG2yEAcBhnrz712FABXP/8ACd+D/wDoa9D/APBjD/8AFVh/ FnXNS8P+FbW70vX7TRJ3vUja5uoGlVlKOdgCxyHJIBzgfdPPY/HlAHqniX4z+NbbxVq8Gl+Iozp8 d7MlqY7a3dTEHITDbDuG3HOTmsofGPxxbkyW2vbZbg+Zcn7HAd0g+QHlOPkVBxxx65rgKKTVy4zc U0uun4p/oe+fCb4taxqviq6g8YeJbRNPWyd4zdLBbr5u9AMMFXJ2luM+vpXtdj4s8N6neR2dh4g0 q7upM7IYL2OR2wCThQcnABP4V8MVseFtTvNH8R2l/YarBpV1Fv2Xk8RkSPKMDlQjk5BI+6evbqGQ fc9FFFABRRRQAUUUUAFFFFABRRRQB5/8bf8AkkOu/wDbv/6UR10HgT/knnhr/sFWv/opaPG2q6Po nhC+1HX7D7fpkPl+dbeSku/MiqvyuQpwxU8+laGhXVnfeHtMvNOt/s9jPaRS28OwJ5cbICq7RwMA gYHAoA0Kx77xZ4b0y8ks7/xBpVpdR43wz3scbrkAjKk5GQQfxqxrv9o/8I9qf9kf8hP7JL9j+7/r th2fe+X72OvHrXxR4qvtZ1DxRqM3iGTzNXWUw3R2oMPGPLx8ny8bccdcUAfRfjXQfhl481mHVNU8 bWkM8Vutuq2uq2yqVDM2TuDHOXPf0rwNNO0UeNJtDOof8SdtaS3F55q/8ewkdDJ5mNn3SDuxjvjF cxRSauXCbg7rzX3qx9L+FvB/ws8I+I7TXLDxxBJdWu/Yk+rWpQ7kZDkBQejHvXpkHjTwrdXEVvb+ JdGmnlcJHHHfxMzsTgAANkknjFfDlaGhf2j/AMJDpn9kf8hP7XF9j+7/AK7eNn3vl+9jrx60yD7v orP0L+0f+Ee0z+1/+Qn9ki+2fd/12wb/ALvy/ez049K0KACiiigAooooAKKKKACiiigArx/9nH/k nmof9hWT/wBFRV7BXH/DjX/DfiPw9cXnhfSP7LsUu2ieH7NHBukCIS22MkHgqM9ePagDsK5fxJ8R PCvhHUY7DXNV+yXUkQmVPs8smUJIByikdVP5V1FfEnjXTPFelazDB4wku31BrdXjN1di4bytzAYY M2BuDcZ9fWgD0z4wfFS11f8Asb/hC/E19H5Xn/a/sjT22c+XszkLu6P6459a8v8A+E78Yf8AQ165 /wCDGb/4qufooA7Tw18QfENt4q0ifVPFWsnT472F7oSXszqYg4L5XJ3DbnjBzX0X/wALt+Hn/Qw/ +SVx/wDG6+QKKAPv+iuX+Hdlrun+BNNtfErzvq6eb9oM84mc5lcrlwTn5SvfjpXUUAFFFFABRRRQ AUUUUAFFFFAHP+O/+SeeJf8AsFXX/opq8A/Zx/5KHqH/AGCpP/RsVe/+O/8AknniX/sFXX/opq8A /Zx/5KHqH/YKk/8ARsVAH0/RRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFeP+Hv+TofF n/YKj/8AQbWvYK4/Ttf8N3HxQ1bQ7bSPK8Q21ost1f8A2aNfNjIiwvmA724dOCMfL7CgDsKKKKAC iiigAooooAKKKKACiiigAooooAKKKKACiiigArx/4v8A/JQ/hj/2FT/6Nt69grj/ABhr/hvSPEPh iz1vSPtt9f3fladN9mjk+zSb4xu3MQU5ZDlcn5fYUAdhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAB RRRQAUUUUAFeP/tHf8k80/8A7Csf/oqWvYK4/wCI+v8Ahvw54et7zxRpH9qWL3axJD9mjn2yFHIb bIQBwGGevPvQB2FFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAV5/8bf+SQ67/wBu/wD6 UR16BXP+NtV0fRPCF9qOv2H2/TIfL8628lJd+ZFVflchThip59KADwJ/yTzw1/2CrX/0UtdBWfoV 1Z33h7TLzTrf7PYz2kUtvDsCeXGyAqu0cDAIGBwK0KACiiigAoqu95GmpQWJVvNmhkmUgfKAhQHP v+8H61YouNxaSb6hRRRQIKKKKACiiigAooooAKKKKACiiigDz/4Jf8kh0L/t4/8ASiSvQK4/4YXV nfeArW8063+z2M93ey28OwJ5cbXUpVdo4GAQMDgV2FABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAB RRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVj+KdB/4Sfw5d6Mb2eyju9i SzQHD+WHUuo/3lDLzkfNyCODsVHPPDa28txcSxwwRIXkkkYKqKBkkk8AAc5oAx/C/hHRfB2lpYaP ZRwgIqyzlQZZyMndI+Mscs3sM4AA4rcr508W/HzWtQ1mXS/BVvGtu7rDbXLW5kuJn3dUQ8AN90KV Jwc8E4X3fw1NfXPhXSJ9UEg1CSyhe6EkexhKUBfK4G07s8YGKANSivnj4nfGDxBJ4ovfCvhRvJji l+yGe3jZrmaXBV0TI+X5jtG0bspkNg4rn75vjP4Cs5Nav73VY7XiF5J7yO9RNxGCVLOF5AG7A64z 82CAfU9cf4u+G+heLN14YfsGtph7fVbTKTRSDbtY4I342KOeQM7Sp5qv8MviJb/EHQ5JTD9n1Oz2 pewqDsBbO10J/hba3BORgg54Y9xQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBz95/wAlD0b/ALBV /wD+jbSugrn7z/koejf9gq//APRtpXQUAFZ+u6Z/bfh7U9J87yft1pLbebt3bN6Fd2MjOM5xkVoU UAfN91+zvdW9w8UeqX9yi4xLFYQBW47brkH25HaoLP4FXWtrb3/26/hjvgs2/wCxQMiB+c5+0hiB n+6D7Z4r6XqppVj/AGZpFlYeZ5n2WCOHftxu2qBnHbOKzcXzXudca0FRcOVXuu/Z67mV4J8Mf8Id 4QsdA+2fbPsvmfv/ACvL3bpGf7uTjG7HXtXQUUVocgUUUUAFFFFABRRRQAUUUUAFFFFAHlfxT0nU tQ8dfDu4stPu7mC01MvcyQws6wr5sBy5AwowpOT6H0r1SuD8d+NdS8L+KvB2l2UFpJBrV6be5aZG LIu+JcphgAcSHqD0Fd5QAUUUUAfMHjb46f8ACY+EL7QP+Ec+x/avL/f/AG7zNu2RX+75Yznbjr3r F+HfxIX4Zy6mq6QdRGoR2zc3PleWVVif4GznzPbGO9e/xfBv4fwqVXw5EQTn555WP5lzVPR/hb4J vrKSW50CCSRbq5iDF34RJnRB97sqqPwrNuXNZHXCFF0XKTd7rovPzNb4ceOv+FgeHrjVv7O+weTd tbeV5/m5wiNuztX+/jGO1dhWP4b8LaN4R06Sw0Oz+yWskpmZPNeTLkAE5ck9FH5VsVocgUUUUAFF FFABRRRQAUUUUAFFFFAHlfx90nUtZ8C2Nvpen3d9Oupxu0drC0rBfKlGSFBOMkDPuK9Urg/iz411 LwH4VtdU0uC0mnlvUt2W6RmUKUdsjaynOUHf1rvKAKepaTpus262+qafaX0CuHWO6hWVQ2CMgMCM 4JGfc15X/wAM4+D/APoJa5/3/h/+NV7BRQB8ueJfCnwj0a31e0t/FGstrVkk0cdtJGSpuEBAQkQA Y3DGcge/euI8F2Hha81iSPxlqN5p2nG2Z4ZrZCWaTcoA4R+Mb+3Uda9f8V/ASfUPEN/q0Or3U39o Xc1yYoLGI+TvcttJedM/exkDt2rAj+Bt5evLbi61EGxb7OdtnbkkkCTnN0MH94OASMY5ySBEppNI 6aWGlUhKV1ou67pdzT8N/DX4S+LtRksND8Ta5d3UcRmZMCPCAgE5eADqw/Ou30T4DeD9E1iDUd99 f+Tu/wBGvzDLC+VK/MvljOM5HuBTfhn8Im8B63JrLay101xZm3Ns9oImjLMjcsJGBI2YwOOetepV ZzNWCiiigAooooAKKKKACiiigAooooA4f4v2F5qfwt1mzsLSe7upPI2QwRmR2xPGThRycAE/hW54 LgmtfAvh63uIpIZ4tMtkkjkUqyMIlBBB5BB4xVP4ieJLzwj4E1LXLCOCS6tfK2JOpKHdKiHIBB6M e9anhrUptZ8K6Rqlwsaz3tlDcSLGCFDOgYgZJOMn1NAFy/sbfU9OubC8j8y1uonhmTcRuRgQwyOR kE9K8X1v9nDTr7WJ7nSdb/suxfb5dn9lafy8KAfnaXJyQTz0zjtXuFFAHxh8R/Av/Cv/ABDb6T/a P2/zrRbnzfI8rGXdduNzf3M5z3rj6+1/Enw78K+LtRjv9c0r7XdRxCFX+0Sx4QEkDCMB1Y/nWP8A 8KS+Hn/Qvf8Ak7cf/HKAPmDwT4Y/4THxfY6B9s+x/avM/f8AleZt2xs/3cjOduOvevZ7D9mu3t9R tprzxJ9rtY5Uea3+wmPzUBBZNwlyuRkZHTNekaJ8LfBvhzWINW0nRvs99Bu8uX7VM+3cpU8M5B4J HIrsKAK9hY2+madbWFnH5draxJDCm4naigBRk8nAA61YoooAKKKKACiiigAooooAKKKKACvK/gFp OpaN4FvrfVNPu7GdtTkdY7qFomK+VEMgMAcZBGfY16pXB/CbxrqXjzwrdapqkFpDPFevbqtqjKpU IjZO5mOcue/pQB3lFFFAHl/xg+HGsfED+xv7JubGH7D5/mfa3dc7/Lxjarf3D1x2rzD/AIZx8Yf9 BLQ/+/8AN/8AGq+n6KAPnTw18AvFWjeKtI1S41DRmgsr2G4kWOaUsVRwxAzGBnA9RX0XRRQAUUUU AFFFFABRRRQAUUUUAFFFFAHP+O/+SeeJf+wVdf8Aopq8A/Zx/wCSh6h/2CpP/RsVe/8Ajv8A5J54 l/7BV1/6KavAP2cf+Sh6h/2CpP8A0bFQB9P0UUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFF ABXlehaTqUP7RvifVJdPu00+bTESK7aFhE7bbfhXxgn5W4B7H0r1SuD0rxrqV98Zdc8HywWg0+ws luIpFRvNLEQnDHdjH7xugHQfiAd5RRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFeV/FP SdS1Dx18O7iy0+7uYLTUy9zJDCzrCvmwHLkDCjCk5PofSvVK4Px3411Lwv4q8HaXZQWkkGtXpt7l pkYsi74lymGABxIeoPQUAd5RRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFeV/H3SdS1n wLY2+l6fd3066nG7R2sLSsF8qUZIUE4yQM+4r1SuD+LPjXUvAfhW11TS4LSaeW9S3ZbpGZQpR2yN rKc5Qd/WgDvKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigArh/i/YXmp/C3WbOwtJ7u6k 8jZDBGZHbE8ZOFHJwAT+FdxXL/ETxJeeEfAmpa5YRwSXVr5WxJ1JQ7pUQ5AIPRj3oAueC4JrXwL4 et7iKSGeLTLZJI5FKsjCJQQQeQQeMVuVl+GtSm1nwrpGqXCxrPe2UNxIsYIUM6BiBkk4yfU1T8be GP8AhMfCF9oH2z7H9q8v9/5Xmbdsiv8AdyM524696AOL1b4++FdG1m+0u40/WWnsriS3kaOGIqWR ipIzIDjI9BXl3iX47eI7rxPdT+H9SubXRW2eRbS21v5i/IA2SVfq249Twe3bNv8A4GeO7fUbmGz0 j7XaxyukNx9pgj81ASFfaZMrkYOD0zXD63omo+HNYn0nVrf7PfQbfMi3q+3coYcqSDwQeDQNOzud 1/wuLxdIP7QbVZzcQfuUfyrfIV/mYf6nHJjXqM8cEc50fDfx38Q23ia0n1/Ubq60ZQ/2i3itrcyO djBcEInRip6joevSvJhI4iaIH5GYMR7jOP5mr2iaJqPiPWINJ0m3+0X0+7y4t6pu2qWPLEAcAnk1 EYWbZ0VsQ6kIxstF2S6t9F5n03pPx98K6zrNjpdvp+srPe3EdvG0kMQUM7BQTiQnGT6GvVK+SLD4 GeO7jUbaG80j7JaySok1x9pgk8pCQGfaJMtgZOB1xX1PoWmf2J4e0zSfO877DaRW3m7du/YgXdjJ xnGcZNWcxoUUUUAFFFFABRRRQAUUUUAFFFFAHB/BmCa1+FOj29xFJDPE9ykkcilWRhcSAgg8gg8Y rvK4v4UalNrPw6sNUuFjWe9uLu4kWMEKGe6lYgZJOMn1NdpQAUUUUAFFFFABRRRQAUUUUAFFFFAB RRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFeZ/HfW5tH+GVxDB5g fUbiOzMiSFCikF26dQVjKEcZDH6H0yvK/wBoLTZr74ZG4iaMJYXsVxKGJyVIaLC8dd0innHAP0IB X+AHhex07wQniARxyahqbyAzFMNHEjlBGDk8bkLEjGcgHO0Gu88c63/wjngbWtWW4+zzQWj+RLs3 7ZmG2PjBz85UcjHrxmuL+AGtw6j8N005fLWfS7iSJ1EgZmV2MiuV6qCXZR1zsPPYZf7RPidLHwva eHIJ8XWoSiWeNdp/cIcjdnlcvtIIHOxhngggHMfs4eHftOuan4hmizHZxC2ty8OQZH5Zlc9GVVwQ OcS9gefoueCG6t5be4ijmglQpJHIoZXUjBBB4II4xXn/AMEtAbQfhlYtKsiz6i7XzqzKwAcAIVx0 BjVDg5OSenQdprms2fh7Q73V799lraRNK+CAWx0VckAsTgAZ5JAoA+cPhV/xTHx+u9Dsv3lq0t7p 5ebl/LjLOpyMDdmFcnGOTx6fT9fMHwWtrzxV8YbvxLOvleR9ovpzFETGZJtyiPJPy/6xmGSSQh9y Pp+gAooooAKKKKACiiigAooooAKKKKACiiigDn7z/koejf8AYKv/AP0baV0Fc/ef8lD0b/sFX/8A 6NtK6CgAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAOD8d+CtS8UeKvB2qWU9pHBot6b i5WZ2DOu+JsJhSCcRnqR1Fd5XlfxT1bUtP8AHXw7t7LULu2gu9TKXMcMzIsy+bAMOAcMMMRg+p9a 9UoAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigDg/iz4K1Lx54VtdL0ue0hnivUuGa6d lUqEdcDarHOXHb1rvK8r+Puralo3gWxuNL1C7sZ21ONGktZmiYr5UpwSpBxkA49hXqlABRRRQAVU s7H7JdahN5m77XOJsbcbMRJHj3+5n8at0UrFKTSaXX/hwooopkhRRRQAUUUUAFFFFABRRRQAUUUU Acv8RPDd54u8CalodhJBHdXXlbHnYhBtlRzkgE9FPatTw1ps2jeFdI0u4aNp7Kyht5GjJKlkQKSM gHGR6Cub+L9/eaZ8LdZvLC7ntLqPyNk0Ehjdczxg4YcjIJH41ueC55rrwL4euLiWSaeXTLZ5JJGL M7GJSSSeSSec0AblFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVwfwm8Fal4D8K3Wl6p PaTTy3r3CtauzKFKIuDuVTnKHt6V3leV/ALVtS1nwLfXGqahd3066nIiyXUzSsF8qI4BYk4ySce5 oA9UooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAOf8d/8k88S/wDYKuv/AEU1eAfs4/8A JQ9Q/wCwVJ/6Nir3/wAd/wDJPPEv/YKuv/RTV4B+zj/yUPUP+wVJ/wCjYqAPp+iiigAooooAKKKK ACiiigAooooAKKKKACiiigAooooAK4PSvBWpWPxl1zxhLPaHT7+yW3ijV280MBCMsNuMfu26E9R+ HeV5XoWralN+0b4n0uXULt9Ph0xHitGmYxI2235VM4B+ZuQO59aAPVKKKKACiiigAooooAKKKKAC iiigAooooAKKKKACiiigArg/HfgrUvFHirwdqllPaRwaLem4uVmdgzrvibCYUgnEZ6kdRXeV5X8U 9W1LT/HXw7t7LULu2gu9TKXMcMzIsy+bAMOAcMMMRg+p9aAPVKKKKACiiigAooooAKKKKACiiigA ooooAKKKKACiiigArg/iz4K1Lx54VtdL0ue0hnivUuGa6dlUqEdcDarHOXHb1rvK8r+Puralo3gW xuNL1C7sZ21ONGktZmiYr5UpwSpBxkA49hQB6pRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAU UUUAFcv8RPDd54u8CalodhJBHdXXlbHnYhBtlRzkgE9FPauorh/i/f3mmfC3Wbywu57S6j8jZNBI Y3XM8YOGHIyCR+NAHSeGtNm0bwrpGl3DRtPZWUNvI0ZJUsiBSRkA4yPQVqVh+C55rrwL4euLiWSa eXTLZ5JJGLM7GJSSSeSSec1uUAFeb+Kfgp4b8XeI7vXL+91WO6utm9IJYwg2oqDAMZPRR3r0iigD x/8A4Zx8H/8AQS1z/v8Aw/8Axqtjwt8FPDfhHxHaa5YXuqyXVrv2JPLGUO5GQ5AjB6Me9ekUUAFF FFABRRRQAUUUUAFFFFABRRRQAUUUUAcX8KNNm0b4dWGl3DRtPZXF3byNGSVLJdSqSMgHGR6Cu0rg /gzPNdfCnR7i4lkmnle5eSSRizOxuJCSSeSSec13lABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABR RRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVXv7G31PTrmwvI/MtbqJ4Zk3 EbkYEMMjkZBPSrFc/wCNv+Ei/wCEQvv+EU/5Df7v7N/q/wDnou7/AFny/c3df50AeGa78CfFfhvV E1DwXqMl2A5ERScW11CG3D72QpG3ALAgksflAqx4U+B/iPXPEA1bx9PIIA+ZopLvzri52hQoLqSA mOM7t2FwAMhhbtvj74k0PUVtfGXhL7P5mx1EUcltIkeSGbZLu39OOVGVIz6d5oHxt8Ea86xNqEmm Ts5VY9RQRAgLndvBKAdQMsDkYxyMgHoEEENrbxW9vFHDBEgSOONQqooGAABwABxivlx/DXxa+J94 tvrS30VvBgltSjNpAhw5VvLCjc3LDcqsRuAJAr6fsb+z1OzjvLC7gu7WTOyaCQSI2CQcMODggj8K sUAcv4F8C6X4D0MWFgPNuJMNdXbrh7hx3PooycL2z3JJPUUUUAFFFFABRRRQAUUUUAFFFFABRRRQ AUUUUAc/ef8AJQ9G/wCwVf8A/o20roK5+8/5KHo3/YKv/wD0baV0FABRRRQAUUUUAFFFFABRRRQA UUUUAFFFFABRRRQAUUUUAcf4w0Dw3q/iHwxea3q/2K+sLvzdOh+0xx/aZN8Z27WBL8qgwuD83uK7 CvH/AIv/APJQ/hj/ANhU/wDo23r2CgAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAOP+ I+geG/Efh63s/FGr/wBl2KXaypN9pjg3SBHAXdICDwWOOvHtXYV4/wDtHf8AJPNP/wCwrH/6Klr2 CgAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAOf8baVo+t+EL7Ttfv8A7Bpk3l+dc+ck WzEisvzOCoywUc+taGhWtnY+HtMs9OuPtFjBaRRW828P5kaoArbhwcgA5HBrj/jb/wAkh13/ALd/ /SiOug8Cf8k88Nf9gq1/9FLQB0FFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVx/w40D w34c8PXFn4X1f+1LF7tpXm+0xz7ZCiArujAA4CnHXn3rsK8f/Zx/5J5qH/YVk/8ARUVAHsFFFFAB RRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBz/jv/knniX/ALBV1/6KavAP2cf+Sh6h/wBgqT/0 bFXv/jv/AJJ54l/7BV1/6KavAP2cf+Sh6h/2CpP/AEbFQB9P0UUUAFFFFABRRRQAUUUUAFFFFABR RRQAUUUUAFFFFABXH6doHhu3+KGra5bav5viG5tFiurD7TG3lRgRYbywN68InJOPm9xXYV4/4e/5 Oh8Wf9gqP/0G1oA9gooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACuP8AGGgeG9X8Q+GL zW9X+xX1hd+bp0P2mOP7TJvjO3awJflUGFwfm9xXYV4/8X/+Sh/DH/sKn/0bb0AewUUUUAFFFFAB RRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXH/EfQPDfiPw9b2fijV/7LsUu1lSb7THBukCOAu6QEHg scdePauwrx/9o7/knmn/APYVj/8ARUtAHsFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQ AVz/AI20rR9b8IX2na/f/YNMm8vzrnzki2YkVl+ZwVGWCjn1roK8/wDjb/ySHXf+3f8A9KI6AOw0 K1s7Hw9plnp1x9osYLSKK3m3h/MjVAFbcODkAHI4NaFc/wCBP+SeeGv+wVa/+ilroKACiiigAooo oAKKKKACiiigAooooAKKKKACiiigAooooA4/4YWtnY+ArWz064+0WMF3exW828P5ka3UoVtw4OQA cjg12Fef/BL/AJJDoX/bx/6USV6BQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRR QAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAEc8EN1by29xFHNBKhSSORQyupGCCDwQR xiuD1v4LeBtb89/7I+wXE2399YSGLZjH3Y+YxkDB+XuT15qx4x+LHhbwTefYb+ee5vxtL2lnGHeN WBILEkKOg4zu+ZTjBzR4O+LHhbxtefYbCee2vzuKWl5GEeRVAJKkEqep4zu+VjjAzQB53P8AAHXt DuJbzwf4wkt55HKBZC9sywk5wZYySxyF42gHrxgCoDrfxw8GXCQXWnya5bhGghItRdKwQgCQtFiT JHQyEE5ORkcd348+MuheCbybTEt59R1eLbvtkzGkeQrDdIR3VsjaG6YOK5fRv2kdLu9RSHV9Cn0+ 1fA+0Q3H2jYSQMsu1TtAySRk8cA5oA6T4bfF+H4g6zd6W2jSafPDb/aEYXAmV1DBWB+VSDllxwc8 9Mc+mVl6VNouuJb+I9MFpcm4t/LivkjG9ot2dm7G4ANnKnoQcgEVqUAFFFcn421LxXAlrpnhLSo5 7y+SQNqE8gWKwAZBvYEYY4ckL1+UnawBFAHSQ39ncXlzZw3cEl1a7ftEKSAvFuGV3KOVyORnrUk8 8Nrby3FxLHDBEheSSRgqooGSSTwABzmvF/gVZzad4q+IFlcXcl5Pb3sUUlzJndMyvOC5ySckjPU9 epq58V3uPFPjnwv8PILye2tb7N3qAUhVliUkgBsElgIpSARt3FCc44APSLHxZ4b1O8js7DxBpV3d SZ2QwXscjtgEnCg5OACfwrYrxvx58H/DeleDr/WPDFpJperaYn26G4S8mPEfzMPmLYO0EgjB3BeQ M1l+L/Gmo+KPhf4L0zT7ueDU/FEq2dxO6rGkmwiKYMVyVVpGU/KOVyCBnaQD1yDxp4VuriK3t/Eu jTTyuEjjjv4mZ2JwAAGySTxityvK9V+A3g+Xw1cWmmWMkOqC32297LdyEmUDhnHK4JHzYXoTgDjH J/8ACztR/wCGdvtv26+/tv7X/ZP23C793+s3bs5/1Py7/vbuevzUAeyT+NPCtrcS29x4l0aGeJyk kcl/ErIwOCCC2QQeMVuV5XpXwG8HxeGre01Oxkm1Q2+24vYruQESkcsg4XAJ+XK9AMg855vwh401 Hwv8L/Gmmahdzz6n4Xlazt50VZEj3kxQhS2CyrIrH5hwuAAcbQAewX3izw3pl5JZ3/iDSrS6jxvh nvY43XIBGVJyMgg/jWpBPDdW8VxbyxzQSoHjkjYMrqRkEEcEEc5rx/wH8H/Deq+DrDWPE9pJqmra mn26a4e8mHEnzKPlK5O0gknJ3FuSMVJ8KHuPC3jnxR8PJ7ye5tbHF3p4YhliiYgkFsAhiJYiQBt3 ByMZ5APQLz/koejf9gq//wDRtpXQVz95/wAlD0b/ALBV/wD+jbSugoAKKKKACiiigAooooAKKKKA CiiigAooooAKKKKACiiigDj/ABhr/hvSPEPhiz1vSPtt9f3fladN9mjk+zSb4xu3MQU5ZDlcn5fY V2FeV/FPSdS1Dx18O7iy0+7uYLTUy9zJDCzrCvmwHLkDCjCk5PofSvVKACiiigAooooAKKKKACii igAooooAKKKKACiiigAooooA4/4j6/4b8OeHre88UaR/ali92sSQ/Zo59shRyG2yEAcBhnrz712F eV/H3SdS1nwLY2+l6fd3066nG7R2sLSsF8qUZIUE4yQM+4r1SgAooooAKKKKACiiigAooooAKKKK ACiiigAooooAKKKKAOf8baro+ieEL7UdfsPt+mQ+X51t5KS78yKq/K5CnDFTz6VoaFdWd94e0y80 63+z2M9pFLbw7AnlxsgKrtHAwCBgcCuX+L9hean8LdZs7C0nu7qTyNkMEZkdsTxk4UcnABP4VueC 4JrXwL4et7iKSGeLTLZJI5FKsjCJQQQeQQeMUAblFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFA BRRRQAVx/wAONf8ADfiPw9cXnhfSP7LsUu2ieH7NHBukCIS22MkHgqM9ePauwryv4BaTqWjeBb63 1TT7uxnbU5HWO6haJivlRDIDAHGQRn2NAHqlFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRR QBz/AI7/AOSeeJf+wVdf+imrwD9nH/koeof9gqT/ANGxV7/47/5J54l/7BV1/wCimrwD9nH/AJKH qH/YKk/9GxUAfT9FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVx+na/4buPihq2h22ke V4htrRZbq/8As0a+bGRFhfMB3tw6cEY+X2FdhXlehaTqUP7RvifVJdPu00+bTESK7aFhE7bbfhXx gn5W4B7H0oA9UooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACuP8AGGv+G9I8Q+GLPW9I +231/d+Vp032aOT7NJvjG7cxBTlkOVyfl9hXYV5X8U9J1LUPHXw7uLLT7u5gtNTL3MkMLOsK+bAc uQMKMKTk+h9KAPVKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigArj/iPr/hvw54et7zxR pH9qWL3axJD9mjn2yFHIbbIQBwGGevPvXYV5X8fdJ1LWfAtjb6Xp93fTrqcbtHawtKwXypRkhQTj JAz7igD1SiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK5/xtquj6J4QvtR1+w+36ZD5f nW3kpLvzIqr8rkKcMVPPpXQVw/xfsLzU/hbrNnYWk93dSeRshgjMjtieMnCjk4AJ/CgDqNCurO+8 PaZeadb/AGexntIpbeHYE8uNkBVdo4GAQMDgVoVh+C4JrXwL4et7iKSGeLTLZJI5FKsjCJQQQeQQ eMVuUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBx/wwurO+8BWt5p1v9nsZ7u9lt4d gTy42upSq7RwMAgYHArsK4P4MwTWvwp0e3uIpIZ4nuUkjkUqyMLiQEEHkEHjFd5QAUUUUAFFFFAB RRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFc 34/19vC/gPWdYiaRZ4LcrA6KrFJXISNsNwQGZSc54B4PSukrz/42/wDJIdd/7d//AEojoA8g+Dvw 4t/Ht5qPiDxKZ7qxilMexpSDdTsNzl3Db/lDKe24sOeCDsfF34V6d4S0e38U+EknsPsUqC4jSdjs y3yTKzNuDByq4GeoIxgk9P8As4/8k81D/sKyf+ioq6D42/8AJIdd/wC3f/0ojoA8w+CPgDTvF/8A aXijxJH/AGlsuxHFHNKzb5hiR3kH8edy9SQcvuB4r0/xh8I/C3iHQ7iCx0ax0/Ukif7JPaoLcLIc Ebwgwy5AByCQCcYJzXP/ALOP/JPNQ/7Csn/oqKvYKAPnz9mzX2FxrPhyRpCjIL6BQq7VIISQk9cn MWByPlPTv9B18wfs4/8AJQ9Q/wCwVJ/6Nir6foAKKKKAPH/hB/yUP4nf9hUf+jbijxT/AKJ+0r4P vLn9zay6e8Ec0nyo8mJxsDHgtl0GOvzr6iuk8CeCtS8L+KvGOqXs9pJBrV6Li2WF2LIu+VsPlQAc SDoT0NWPiN4CXxvpds9rdyWOtac5m067V2UI/BIbHIBKr8w5UgEZ5BAND4gzw23w58SPPLHEh0y4 QM7BQWaMqo57liAB3JArwhYJtO8LfBu9vopLW0g1OZ5p51KJGr3SSIWY8AMgLAnqASOK7O6+HfxO 8VeRpni/xfYyaE0qyXUdioWRwvIAxCoPOPvEgHDYJUCu88VfD/SPE/gqLww3mWtvaogsZEYsbdkU qhwT84CkggnkE8g4IAOonnhtbeW4uJY4YIkLySSMFVFAySSeAAOc18mfYLz/AIZz8/7JP5P/AAkv n+Z5Z2+X5Hl78/3d/wAuem7jrXpc3gL4wappY0TU/GumnS5UWC4KZaUxcA/N5Ss5IHOXG7kE8mvR P+EA0L/hX/8Awhflz/2T5Xl580+Zu3b9+7+9v+bptzxjHFAHSQTw3VvFcW8sc0EqB45I2DK6kZBB HBBHOa+aGgm1Hwt8ZL2xikurSfU4XhngUukipdPI5VhwQqEMSOgIJ4rr4fAXxg0vSzommeNdNGlx I0FuXysoi5A+bymZCAeMOdvAB4FegeFfh/pHhjwVL4YXzLq3ukcX0jsVNwzqFc4B+QFQAADwAOSc kgFj4fTw3Pw58NvBLHKg0y3QsjBgGWMKw47hgQR2IIrg/C3+l/tK+MLy2/fWsWnpBJNH8yJJiAbC w4DZRxjr8jehqva/Dv4neFfP0zwh4vsY9CWVpLWO+UNIgbkg5hYDnP3SATlsAsRXafDnwEvgjS7l 7q7kvta1FxNqN2zswd+SAueSAWb5jyxJJxwAAWNesp77x1okVvqd3p7jTL5jLarEzEebafKfMRxj nPTPA565uf8ACPap/wBDnrn/AH5sv/kei8/5KHo3/YKv/wD0baV0FAGGdC1E26RDxZrIdXZjKIrP cwIGFP7jGBgkYAPzHJPGJLHRr+0vI55vE2q3sa5zBPHahHyCOSkKtx14I6enFbFFAGPfaNf3d5JP D4m1WyjbGIII7UomABwXhZuevJPX04qxpmnXVh5v2nWb7Ut+Nv2tIF8vGc48qNOue+egxjnOhRQB z/8Awj2qf9Dnrn/fmy/+R60P7Ouv7H+xf2zffaP+f/ZB533s9PL8vp8v3OnvzWhRQBz/APwj2qf9 Dnrn/fmy/wDketDU9Our/wAr7NrN9puzO77IkDeZnGM+bG/THbHU5zxjQooAx7HRr+0vI55vE2q3 sa5zBPHahHyCOSkKtx14I6enFF9o1/d3kk8PibVbKNsYggjtSiYAHBeFm568k9fTitiigDP0zTrq w837TrN9qW/G37WkC+XjOceVGnXPfPQYxznP/wCEe1T/AKHPXP8AvzZf/I9dBRQBn/2ddf2P9i/t m++0f8/+yDzvvZ6eX5fT5fudPfms/wD4R7VP+hz1z/vzZf8AyPXQUUAZ+p6ddX/lfZtZvtN2Z3fZ EgbzM4xnzY36Y7Y6nOeMV7HRr+0vI55vE2q3sa5zBPHahHyCOSkKtx14I6enFbFFAHlfxJ1zxDoX jXwlZaXr93bWmuXv2eeEQW7iJQ0KZjLRkgnex+Ytz7cV6JpmnXVh5v2nWb7Ut+Nv2tIF8vGc48qN Oue+egxjnPJ+O/BWpeKPFXg7VLKe0jg0W9NxcrM7BnXfE2EwpBOIz1I6iu8oA5//AIR7VP8Aoc9c /wC/Nl/8j1of2ddf2P8AYv7ZvvtH/P8A7IPO+9np5fl9Pl+509+a0KKAOf8A+Ee1T/oc9c/782X/ AMj1oanp11f+V9m1m+03Znd9kSBvMzjGfNjfpjtjqc54xoUUAY9jo1/aXkc83ibVb2Nc5gnjtQj5 BHJSFW468EdPTii+0a/u7ySeHxNqtlG2MQQR2pRMADgvCzc9eSevpxWxRQBn6Zp11Yeb9p1m+1Lf jb9rSBfLxnOPKjTrnvnoMY5zn/8ACPap/wBDnrn/AH5sv/keugooAz/7Ouv7H+xf2zffaP8An/2Q ed97PTy/L6fL9zp781n/APCPap/0Oeuf9+bL/wCR66CigDP1PTrq/wDK+zazfabszu+yJA3mZxjP mxv0x2x1Oc8Yr2OjX9peRzzeJtVvY1zmCeO1CPkEclIVbjrwR09OK2KKAMe+0a/u7ySeHxNqtlG2 MQQR2pRMADgvCzc9eSevpxVjTNOurDzftOs32pb8bftaQL5eM5x5Uadc989BjHOdCigDn/8AhHtU /wChz1z/AL82X/yPWh/Z11/Y/wBi/tm++0f8/wDsg8772enl+X0+X7nT35rQooA8j+LOqeJvAfhW 11TS/FmpTTy3qW7LdW9oyhSjtkbYFOcoO/rXpmp6ddX/AJX2bWb7Tdmd32RIG8zOMZ82N+mO2Opz njHJ/FnwVqXjzwra6Xpc9pDPFepcM107KpUI64G1WOcuO3rXeUAY9jo1/aXkc83ibVb2Nc5gnjtQ j5BHJSFW468EdPTii+0a/u7ySeHxNqtlG2MQQR2pRMADgvCzc9eSevpxWxRQBn6Zp11Yeb9p1m+1 Lfjb9rSBfLxnOPKjTrnvnoMY5zn/APCPap/0Oeuf9+bL/wCR66CigDP/ALOuv7H+xf2zffaP+f8A 2Qed97PTy/L6fL9zp781n/8ACPap/wBDnrn/AH5sv/keugooAz9T066v/K+zazfabszu+yJA3mZx jPmxv0x2x1Oc8Yr2OjX9peRzzeJtVvY1zmCeO1CPkEclIVbjrwR09OK2KKAMe+0a/u7ySeHxNqtl G2MQQR2pRMADgvCzc9eSevpxVjTNOurDzftOs32pb8bftaQL5eM5x5Uadc989BjHOdCigDn/APhH tU/6HPXP+/Nl/wDI9aH9nXX9j/Yv7ZvvtH/P/sg8772enl+X0+X7nT35rQooA5//AIR7VP8Aoc9c /wC/Nl/8j1oanp11f+V9m1m+03Znd9kSBvMzjGfNjfpjtjqc54xoUUAY9jo1/aXkc83ibVb2Nc5g njtQj5BHJSFW468EdPTii+0a/u7ySeHxNqtlG2MQQR2pRMADgvCzc9eSevpxWxRQBw/jHU9W8BeB NX1yHVZ9WuofJ8pNSii2JmVUPEKRk5D9yeg98yeGtP1rWfCukapceMNZWe9sobiRY4LIKGdAxAzb k4yfU1c+Inhu88XeBNS0OwkgjurrytjzsQg2yo5yQCeintWp4a02bRvCukaXcNG09lZQ28jRklSy IFJGQDjI9BQBJ/Z11/Y/2L+2b77R/wA/+yDzvvZ6eX5fT5fudPfms/8A4R7VP+hz1z/vzZf/ACPX QUUAZ+p6ddX/AJX2bWb7Tdmd32RIG8zOMZ82N+mO2OpznjFex0a/tLyOebxNqt7GucwTx2oR8gjk pCrcdeCOnpxWxRQBj32jX93eSTw+JtVso2xiCCO1KJgAcF4WbnryT19OKsaZp11Yeb9p1m+1Lfjb 9rSBfLxnOPKjTrnvnoMY5zoUUAc//wAI9qn/AEOeuf8Afmy/+R60P7Ouv7H+xf2zffaP+f8A2Qed 97PTy/L6fL9zp781oUUAc/8A8I9qn/Q565/35sv/AJHrQ1PTrq/8r7NrN9puzO77IkDeZnGM+bG/ THbHU5zxjQooAx7HRr+0vI55vE2q3sa5zBPHahHyCOSkKtx14I6enFF9o1/d3kk8PibVbKNsYggj tSiYAHBeFm568k9fTitiigDP0zTrqw837TrN9qW/G37WkC+XjOceVGnXPfPQYxznP/4R7VP+hz1z /vzZf/I9dBRQBn/2ddf2P9i/tm++0f8AP/sg8772enl+X0+X7nT35rP/AOEe1T/oc9c/782X/wAj 10FFAGfqenXV/wCV9m1m+03Znd9kSBvMzjGfNjfpjtjqc54x538GNc8Q+MdBm1vWtfu53gvZLf7M sFukTqI0ILbYw+cuTww6D3z6pXB/CbwVqXgPwrdaXqk9pNPLevcK1q7MoUoi4O5VOcoe3pQB0l9o 1/d3kk8PibVbKNsYggjtSiYAHBeFm568k9fTirGmaddWHm/adZvtS342/a0gXy8Zzjyo065756DG Oc6FFAHP/wDCPap/0Oeuf9+bL/5HrQ/s66/sf7F/bN99o/5/9kHnfez08vy+ny/c6e/NaFFAHP8A /CPap/0Oeuf9+bL/AOR60NT066v/ACvs2s32m7M7vsiQN5mcYz5sb9MdsdTnPGNCigDHsdGv7S8j nm8TarexrnME8dqEfII5KQq3HXgjp6cUX2jX93eSTw+JtVso2xiCCO1KJgAcF4WbnryT19OK2KKA M/TNOurDzftOs32pb8bftaQL5eM5x5Uadc989BjHOc//AIR7VP8Aoc9c/wC/Nl/8j10FFAGf/Z11 /Y/2L+2b77R/z/7IPO+9np5fl9Pl+509+az/APhHtU/6HPXP+/Nl/wDI9dBRQBn6np11f+V9m1m+ 03Znd9kSBvMzjGfNjfpjtjqc54xXsdGv7S8jnm8TarexrnME8dqEfII5KQq3HXgjp6cVsUUAY99o 1/d3kk8PibVbKNsYggjtSiYAHBeFm568k9fTirGmaddWHm/adZvtS342/a0gXy8Zzjyo065756DG Oc6FFAHB+NNC1GHwL4hlfxZrM6JplyzRSRWYVwIm+U7YAcHpwQfQivFP2freW78b6nBDez2UjaU+ J4AhdMTQngOrLz05B6+vNfQ/jv8A5J54l/7BV1/6KavAP2cf+Sh6h/2CpP8A0bFQB7//AMI9qn/Q 565/35sv/ketDU9Our/yvs2s32m7M7vsiQN5mcYz5sb9MdsdTnPGNCigDHsdGv7S8jnm8Tarexrn ME8dqEfII5KQq3HXgjp6cUX2jX93eSTw+JtVso2xiCCO1KJgAcF4WbnryT19OK2KKAM/TNOurDzf tOs32pb8bftaQL5eM5x5Uadc989BjHOc/wD4R7VP+hz1z/vzZf8AyPXQUUAZ/wDZ11/Y/wBi/tm+ +0f8/wDsg8772enl+X0+X7nT35rP/wCEe1T/AKHPXP8AvzZf/I9dBRQBn6np11f+V9m1m+03Znd9 kSBvMzjGfNjfpjtjqc54xXsdGv7S8jnm8TarexrnME8dqEfII5KQq3HXgjp6cVsUUAY99o1/d3kk 8PibVbKNsYggjtSiYAHBeFm568k9fTirGmaddWHm/adZvtS342/a0gXy8Zzjyo065756DGOc6FFA HP8A/CPap/0Oeuf9+bL/AOR60P7Ouv7H+xf2zffaP+f/AGQed97PTy/L6fL9zp781oUUAc//AMI9 qn/Q565/35sv/ketDU9Our/yvs2s32m7M7vsiQN5mcYz5sb9MdsdTnPGNCigDHsdGv7S8jnm8Tar exrnME8dqEfII5KQq3HXgjp6cVwcGueIdZ+OGv8AhZdfu7HS7KyS4hS1gtywYrBkFpI2JBMjH8q9 Urg9K8FalY/GXXPGEs9odPv7JbeKNXbzQwEIyw24x+7boT1H4AHWaZp11Yeb9p1m+1Lfjb9rSBfL xnOPKjTrnvnoMY5zn/8ACPap/wBDnrn/AH5sv/keugooAz/7Ouv7H+xf2zffaP8An/2Qed97PTy/ L6fL9zp781n/APCPap/0Oeuf9+bL/wCR66CigDP1PTrq/wDK+zazfabszu+yJA3mZxjPmxv0x2x1 Oc8Yr2OjX9peRzzeJtVvY1zmCeO1CPkEclIVbjrwR09OK2KKAMe+0a/u7ySeHxNqtlG2MQQR2pRM ADgvCzc9eSevpxVjTNOurDzftOs32pb8bftaQL5eM5x5Uadc989BjHOdCigDn/8AhHtU/wChz1z/ AL82X/yPWh/Z11/Y/wBi/tm++0f8/wDsg8772enl+X0+X7nT35rQooA5/wD4R7VP+hz1z/vzZf8A yPWhqenXV/5X2bWb7Tdmd32RIG8zOMZ82N+mO2OpznjGhRQBj2OjX9peRzzeJtVvY1zmCeO1CPkE clIVbjrwR09OKL7Rr+7vJJ4fE2q2UbYxBBHalEwAOC8LNz15J6+nFbFFAGfpmnXVh5v2nWb7Ut+N v2tIF8vGc48qNOue+egxjnOf/wAI9qn/AEOeuf8Afmy/+R66CigDP/s66/sf7F/bN99o/wCf/ZB5 33s9PL8vp8v3OnvzXmfjvVPE3hfxV4O0uy8WalJBrV6be5aa3tCyLviXKYgABxIeoPQV65XB+O/B WpeKPFXg7VLKe0jg0W9NxcrM7BnXfE2EwpBOIz1I6igDrNT066v/ACvs2s32m7M7vsiQN5mcYz5s b9MdsdTnPGK9jo1/aXkc83ibVb2Nc5gnjtQj5BHJSFW468EdPTitiigDHvtGv7u8knh8TarZRtjE EEdqUTAA4Lws3PXknr6cVY0zTrqw837TrN9qW/G37WkC+XjOceVGnXPfPQYxznQooA5//hHtU/6H PXP+/Nl/8j1of2ddf2P9i/tm++0f8/8Asg8772enl+X0+X7nT35rQooA5/8A4R7VP+hz1z/vzZf/ ACPWhqenXV/5X2bWb7Tdmd32RIG8zOMZ82N+mO2OpznjGhRQBj2OjX9peRzzeJtVvY1zmCeO1CPk EclIVbjrwR09OKL7Rr+7vJJ4fE2q2UbYxBBHalEwAOC8LNz15J6+nFbFFAGfpmnXVh5v2nWb7Ut+ Nv2tIF8vGc48qNOue+egxjnOf/wj2qf9Dnrn/fmy/wDkeugooAz/AOzrr+x/sX9s332j/n/2Qed9 7PTy/L6fL9zp781n/wDCPap/0Oeuf9+bL/5HroKKAM/U9Our/wAr7NrN9puzO77IkDeZnGM+bG/T HbHU5zxivY6Nf2l5HPN4m1W9jXOYJ47UI+QRyUhVuOvBHT04rYooAx77Rr+7vJJ4fE2q2UbYxBBH alEwAOC8LNz15J6+nFcX8RvEuufDTwrFqlpqcmsT3F7Hb7dUhi2xrskYlfIWI5JUdSenavTK4P4s +CtS8eeFbXS9LntIZ4r1LhmunZVKhHXA2qxzlx29aANz/hHtU/6HPXP+/Nl/8j1of2ddf2P9i/tm ++0f8/8Asg8772enl+X0+X7nT35rQooA5/8A4R7VP+hz1z/vzZf/ACPWhqenXV/5X2bWb7Tdmd32 RIG8zOMZ82N+mO2OpznjGhRQBj2OjX9peRzzeJtVvY1zmCeO1CPkEclIVbjrwR09OKL7Rr+7vJJ4 fE2q2UbYxBBHalEwAOC8LNz15J6+nFbFFAGfpmnXVh5v2nWb7Ut+Nv2tIF8vGc48qNOue+egxjnO f/wj2qf9Dnrn/fmy/wDkeugooAz/AOzrr+x/sX9s332j/n/2Qed97PTy/L6fL9zp781n/wDCPap/ 0Oeuf9+bL/5HroKKAM/U9Our/wAr7NrN9puzO77IkDeZnGM+bG/THbHU5zxivY6Nf2l5HPN4m1W9 jXOYJ47UI+QRyUhVuOvBHT04rYooAx77Rr+7vJJ4fE2q2UbYxBBHalEwAOC8LNz15J6+nFWNM066 sPN+06zfalvxt+1pAvl4znHlRp1z3z0GMc50KKAOf/4R7VP+hz1z/vzZf/I9aH9nXX9j/Yv7Zvvt H/P/ALIPO+9np5fl9Pl+509+a0KKAOf/AOEe1T/oc9c/782X/wAj1j/FfU9W0HwJe65o+qz2V1Zb MIkUTpLvlRPmDox4BONpHXnNdxXL/ETw3eeLvAmpaHYSQR3V15Wx52IQbZUc5IBPRT2oAj8Gwarf aDomt3/iTUrp7qyiuJbZ4rZYizxgkfJCHABbI+bsM55zqX2jX93eSTw+JtVso2xiCCO1KJgAcF4W bnryT19OKk8NabNo3hXSNLuGjaeysobeRoySpZECkjIBxkegrUoAz9M066sPN+06zfalvxt+1pAv l4znHlRp1z3z0GMc5z/+Ee1T/oc9c/782X/yPXQUUAZ/9nXX9j/Yv7ZvvtH/AD/7IPO+9np5fl9P l+509+az/wDhHtU/6HPXP+/Nl/8AI9dBRQBn6np11f8AlfZtZvtN2Z3fZEgbzM4xnzY36Y7Y6nOe MV7HRr+0vI55vE2q3sa5zBPHahHyCOSkKtx14I6enFbFFAGPfaNf3d5JPD4m1WyjbGIII7UomABw XhZuevJPX04qxpmnXVh5v2nWb7Ut+Nv2tIF8vGc48qNOue+egxjnOhRQBz//AAj2qf8AQ565/wB+ bL/5HrQ/s66/sf7F/bN99o/5/wDZB533s9PL8vp8v3OnvzWhRQBz/wDwj2qf9Dnrn/fmy/8AketD U9Our/yvs2s32m7M7vsiQN5mcYz5sb9MdsdTnPGNCigDHsdGv7S8jnm8TarexrnME8dqEfII5KQq 3HXgjp6cUX2jX93eSTw+JtVso2xiCCO1KJgAcF4WbnryT19OK2KKAOf/AOEe1T/oc9c/782X/wAj 0f8ACPap/wBDnrn/AH5sv/keugooA4f4Q31xqfwx0y/vJPMurqW6mmfaBudrmUscDgZJPSu4ri/h Rps2jfDqw0u4aNp7K4u7eRoySpZLqVSRkA4yPQV2lABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABR RRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAV5/8bf8AkkOu/wDbv/6UR16B Ve+sLPU7OSzv7SC7tZMb4Z4xIjYIIyp4OCAfwoA+WPhx8YP+Ff8Ah640n+wvt/nXbXPm/a/KxlEX bjY39zOc960PG3x0/wCEx8IX2gf8I59j+1eX+/8At3mbdsiv93yxnO3HXvXv/wDwgng//oVND/8A BdD/APE0f8IJ4P8A+hU0P/wXQ/8AxNAHzh8OPjB/wr/w9caT/YX2/wA67a5837X5WMoi7cbG/uZz nvXX/wDDTX/Uo/8AlS/+1V7B/wAIJ4P/AOhU0P8A8F0P/wATR/wgng//AKFTQ/8AwXQ//E0AeAfs 4/8AJQ9Q/wCwVJ/6Nir6frL03w1oOjXDXGl6JptjOyFGktbVImK5BwSoBxkA49hWpQAUUUUAFFFF ABRRRQAUUUUAFFFFABRRRQBz95/yUPRv+wVf/wDo20roK5+8/wCSh6N/2Cr/AP8ARtpXQUAFFFFA BRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQB5X8U9W1LT/AB18O7ey1C7toLvUylzHDMyLMvmw DDgHDDDEYPqfWvVK4/xhoHhvV/EPhi81vV/sV9YXfm6dD9pjj+0yb4zt2sCX5VBhcH5vcV2FABRR RQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAeV/H3VtS0bwLY3Gl6hd2M7anGjSWszRMV8qU 4JUg4yAcewr1SuP+I+geG/Efh63s/FGr/wBl2KXaypN9pjg3SBHAXdICDwWOOvHtXYUAFFFFABRR RQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBw/wAX7+80z4W6zeWF3PaXUfkbJoJDG65njBww5GQS Pxrc8FzzXXgXw9cXEsk08umWzySSMWZ2MSkkk8kk85qPxtpWj634QvtO1+/+waZN5fnXPnJFsxIr L8zgqMsFHPrWhoVrZ2Ph7TLPTrj7RYwWkUVvNvD+ZGqAK24cHIAORwaANCiiigAooooAKKKKACii igAooooAKKKKACiiigAooooAK8r+AWralrPgW+uNU1C7vp11ORFkupmlYL5URwCxJxkk49zXqlcf 8ONA8N+HPD1xZ+F9X/tSxe7aV5vtMc+2QogK7owAOApx1596AOwooooAKKKKACiiigAooooAKKKK ACiiigAooooAKKKKAOf8d/8AJPPEv/YKuv8A0U1eAfs4/wDJQ9Q/7BUn/o2Kvf8Ax3/yTzxL/wBg q6/9FNXgH7OP/JQ9Q/7BUn/o2KgD6fooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACvK9 C1bUpv2jfE+ly6hdvp8OmI8Vo0zGJG22/KpnAPzNyB3PrXqlcfp2geG7f4oatrltq/m+Ibm0WK6s PtMbeVGBFhvLA3rwick4+b3FAHYUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXlfxT1 bUtP8dfDu3stQu7aC71MpcxwzMizL5sAw4BwwwxGD6n1r1SuP8YaB4b1fxD4YvNb1f7FfWF35unQ /aY4/tMm+M7drAl+VQYXB+b3FAHYUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXlfx9 1bUtG8C2NxpeoXdjO2pxo0lrM0TFfKlOCVIOMgHHsK9Urj/iPoHhvxH4et7PxRq/9l2KXaypN9pj g3SBHAXdICDwWOOvHtQB2FFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVw/xfv7zTPhb rN5YXc9pdR+RsmgkMbrmeMHDDkZBI/Gu4rn/ABtpWj634QvtO1+/+waZN5fnXPnJFsxIrL8zgqMs FHPrQBJ4LnmuvAvh64uJZJp5dMtnkkkYszsYlJJJ5JJ5zW5WfoVrZ2Ph7TLPTrj7RYwWkUVvNvD+ ZGqAK24cHIAORwa0KACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA4P4MzzXXwp0e4uJ ZJp5XuXkkkYszsbiQkknkknnNd5XH/DC1s7HwFa2enXH2ixgu72K3m3h/MjW6lCtuHByADkcGuwo AKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigA ooooAKKKKACuH+L9/eaZ8LdZvLC7ntLqPyNk0Ehjdczxg4YcjIJH413FZ+t6Jp3iPR59J1a3+0WM +3zIt7Ju2sGHKkEcgHg0AfHmm+KPG+q3DQW/i/UkdULk3WuG3XGQOGkkUE89M56+hrtP+EN+Of8A z9a5/wCD1f8A49Xb6z+zh4fu976Rq19p8jyl9syrcRohz8ij5W44wSx4HOSc1wk3w9+K/gBBJo1z dzWkbrcMukXTOhkLBcGA4Lnhc/Iwx14BwASf8Ib8c/8An61z/wAHq/8Ax6j/AIQ345/8/Wuf+D1f /j1XNN+Pni/w5cNp3inRI7ueFCHWVGs7jcxDKX+UrjaeAEGRg59fQ/Dvx58Ha15cV9LPpF03lqVu 0zGXbggSLkBQf4nCcEH1wAZfwm0D4kaV4qup/GE2pPp7WTpGLrUhcL5u9CMKHbB2hucevrXslU9N 1bTdZt2uNL1C0voFco0lrMsqhsA4JUkZwQce4q5QAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBz95 /wAlD0b/ALBV/wD+jbSugrn7z/koejf9gq//APRtpXQUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUU AFFFFABRRRQB4/8AF/8A5KH8Mf8AsKn/ANG29ewVx/jDX/DekeIfDFnrekfbb6/u/K06b7NHJ9mk 3xjduYgpyyHK5Py+wrsKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA8f8A2jv+Seaf /wBhWP8A9FS17BXH/EfX/Dfhzw9b3nijSP7UsXu1iSH7NHPtkKOQ22QgDgMM9efeuwoAKKKKACii igAooooAKKKKACiiigAooooAKKKKACiiigDz/wCNv/JIdd/7d/8A0ojroPAn/JPPDX/YKtf/AEUt HjbVdH0Twhfajr9h9v0yHy/OtvJSXfmRVX5XIU4YqefStDQrqzvvD2mXmnW/2exntIpbeHYE8uNk BVdo4GAQMDgUAaFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAV4/+zj/AMk81D/sKyf+ ioq9grj/AIca/wCG/Efh64vPC+kf2XYpdtE8P2aODdIEQltsZIPBUZ68e1AHYUUUUAFFFFABRRRQ AUUUUAFFFFABRRRQAUUUUAFFFFAHP+O/+SeeJf8AsFXX/opq8A/Zx/5KHqH/AGCpP/RsVe/+O/8A knniX/sFXX/opq8A/Zx/5KHqH/YKk/8ARsVAH0/RRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQA UUUUAFeP+Hv+TofFn/YKj/8AQbWvYK4/Ttf8N3HxQ1bQ7bSPK8Q21ost1f8A2aNfNjIiwvmA724d OCMfL7CgDsKKKx/EninRvCOnR3+uXn2S1klEKv5TyZcgkDCAnop/KgDYoryfxZ8X/Amp+DdcsLPX fMurrT7iGFPsk43O0bBRkpgZJHWvligD7/or4Ar6P+FvxS8G+HPhxpOk6trP2e+g87zIvssz7d0z sOVQg8EHg0Ae4UVj+G/FOjeLtOkv9DvPtdrHKYWfynjw4AJGHAPRh+dbFABRRRQAUUUUAFFFFABR RRQAV4/8X/8Akofwx/7Cp/8ARtvXsFcf4w1/w3pHiHwxZ63pH22+v7vytOm+zRyfZpN8Y3bmIKcs hyuT8vsKAOwooooAKKK8/wD+F2/Dz/oYf/JK4/8AjdAHoFFef/8AC7fh5/0MP/klcf8Axuuo8N+K dG8XadJf6Hefa7WOUws/lPHhwASMOAejD86ANiiiigAooooAKKKKACiiigAooooAK8f/AGjv+Sea f/2FY/8A0VLXsFcf8R9f8N+HPD1veeKNI/tSxe7WJIfs0c+2Qo5DbZCAOAwz1596AOwooooAKKKK ACiiigAooooAKKKKACiiigAooooAKKKKACvP/jb/AMkh13/t3/8ASiOvQK5/xtquj6J4QvtR1+w+ 36ZD5fnW3kpLvzIqr8rkKcMVPPpQAeBP+SeeGv8AsFWv/opa6Cs/QrqzvvD2mXmnW/2exntIpbeH YE8uNkBVdo4GAQMDgVoUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQB5/8ABL/kkOhf 9vH/AKUSV6BXH/DC6s77wFa3mnW/2exnu72W3h2BPLja6lKrtHAwCBgcCuwoAKKKKACiiigAoooo AKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiisfx T4ks/CPhy71y/jnktbXZvSBQXO51QYBIHVh3oA2KK+eNZ/aUvH3pofh+CLEp2zX0xk3x84zGm3ax 4P3mA5HPWsObQPjL8Q0C6mupJZu628qXbLZxABg25oflLAEg7gjHjAyVwAD3Pxj4p8BWEX2LxXea VP5cqk2c8QuXjcqSrGIBmX5SfmI/i688/Nni7VfhpeW8S+GPDes2c4SQM8l4EXcQNhKt5pcA54BT 6nPHo+gfs2QhFk8R65IzlCDBpyhQrbuD5jg7ht6jYOT1459M8O/C7wd4Y8uSx0WCW6TyyLq7HnSb 06OC2QjZ5+QLzjjgYAPGP2cbC8/4TLUNR+yT/Yf7Pkg+0+WfL8zzIm2bum7HOOuK+l6KKACiiigA ooooAKKKKACiiigAooooAKKKKAOfvP8Akoejf9gq/wD/AEbaV0Fc/ef8lD0b/sFX/wD6NtK6CgAo oooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAPK/inpOpah46+HdxZafd3MFpqZe5khhZ1hX zYDlyBhRhScn0PpXqlcH478a6l4X8VeDtLsoLSSDWr029y0yMWRd8S5TDAA4kPUHoK7ygAooooAK KKKACiiigAooooAKKKKACiiigAooooAKKKKAPK/j7pOpaz4FsbfS9Pu76ddTjdo7WFpWC+VKMkKC cZIGfcV6pXB/FnxrqXgPwra6ppcFpNPLepbst0jMoUo7ZG1lOcoO/rXeUAFFFFABRRRQAUUUUAFF FFABRRRQAUUUUAFFFFABRRRQBw/xfsLzU/hbrNnYWk93dSeRshgjMjtieMnCjk4AJ/CtzwXBNa+B fD1vcRSQzxaZbJJHIpVkYRKCCDyCDxiqfxE8SXnhHwJqWuWEcEl1a+VsSdSUO6VEOQCD0Y961PDW pTaz4V0jVLhY1nvbKG4kWMEKGdAxAyScZPqaANSiiigAooooAKKKKACiiigAooooAKKKKACiiigA ooooAK8r+AWk6lo3gW+t9U0+7sZ21OR1juoWiYr5UQyAwBxkEZ9jXqlcH8JvGupePPCt1qmqQWkM 8V69uq2qMqlQiNk7mY5y57+lAHeUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAHP+O/8A knniX/sFXX/opq8A/Zx/5KHqH/YKk/8ARsVe/wDjv/knniX/ALBV1/6KavAP2cf+Sh6h/wBgqT/0 bFQB9P0UUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXlehaTqUP7RvifVJdPu00+bTESK 7aFhE7bbfhXxgn5W4B7H0r1SuD0rxrqV98Zdc8HywWg0+wsluIpFRvNLEQnDHdjH7xugHQfiAd5X yx8df+Ek/wCE21L7T/av/CPebB9l83zPsnmeQudmfk3Z39Ofve9fU9U9S0nTdZt1t9U0+0voFcOs d1CsqhsEZAYEZwSM+5oA+DKK+x/FngTw3/whuuf2d4U0r7d/Z9x9n+z6dH5nmeW23Zhc7s4xjnNf L8fgHxKYwZfDfiNX7hdJkYfnx/Kk3YuEHN2X4tL8zmpI3hleJxh0Yqw9CKbXW3XgnX7qea5t9A1+ ZJWaSN49LkZHBOQQw6g+vpX0F8LfAmj/APCuNJ/t/wAKWP8Aaf77zvt+nJ53+ufbu3ru+7txntil CXMkzTE0fY1HDs31T/I4D9nH+2P+Eh1D/j+/sT7JJ/f+zfaN8X/AfM2fjj2r6Pqnpuk6bo1u1vpe n2ljAzl2jtYViUtgDJCgDOABn2FXKowCiiigAooooAKKKKACiiigAryv4p6TqWoeOvh3cWWn3dzB aamXuZIYWdYV82A5cgYUYUnJ9D6V6pXB+O/GupeF/FXg7S7KC0kg1q9NvctMjFkXfEuUwwAOJD1B 6CgDvK4/4ieLbjwr4euZLPTNVubqa0uDDdWVqJo7R1T5XmJOFXJB5B4VuOK7CuX8a+A9G8c6cIdT gzdQxSpZ3G9/9HdwBv2qwDYKqcH096APmj/hdvxD/wChh/8AJK3/APjdef17/wD8My/9Td/5Tf8A 7bXgFABXUeG/iJ4q8I6dJYaHqv2S1klMzJ9niky5ABOXUnoo/KuXr1D4cfB//hYHh641b+3fsHk3 bW3lfZPNzhEbdnev9/GMdqAO/wDgv8S/EXibWL3TtfN9qW/y/JuYbONYbXCyM3msgXbu2qFznJHa vcK8v+HvwX07wRrD6tc3/wDal8mPskvktB9nyrq/AchtwbHI4xx1r1CgAooooAKKKKACiiigAooo oAK8r+Puk6lrPgWxt9L0+7vp11ON2jtYWlYL5UoyQoJxkgZ9xXqlcH8WfGupeA/CtrqmlwWk08t6 luy3SMyhSjtkbWU5yg7+tAHeUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXD/F+wvNT +Fus2dhaT3d1J5GyGCMyO2J4ycKOTgAn8K7iuX+IniS88I+BNS1ywjgkurXytiTqSh3SohyAQejH vQBc8FwTWvgXw9b3EUkM8WmWySRyKVZGESggg8gg8YrcrL8NalNrPhXSNUuFjWe9sobiRYwQoZ0D EDJJxk+prUoAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigDg/gzBNa/CnR7e4ikhnie5 SSORSrIwuJAQQeQQeMV3lcX8KNSm1n4dWGqXCxrPe3F3cSLGCFDPdSsQMknGT6mu0oAKKKKACiii gAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKA CuP+KWiaj4j+HGraTpNv9ovp/J8uLeqbtsyMeWIA4BPJrsKx/FOvf8Ix4cu9ZNlPex2mx5YYBl/L LqHYf7qlm5wPl5IHIAPmTTfhR8VdGuGuNL067sZ2Qo0lrqcMTFcg4JWQHGQDj2Fan/CG/HP/AJ+t c/8AB6v/AMer6D8L+LtF8Y6Wl/o97HMCitLAWAlgJyNsiZypyrexxkEjmtygD5g/4Q345/8AP1rn /g9X/wCPUf8ACG/HP/n61z/wer/8er6fooA8b+E2gfEjSvFV1P4wm1J9PaydIxdakLhfN3oRhQ7Y O0Nzj19a9korj/F3xI0LwnuszN9v1t8Jb6VaZeaWQ7dqnAOzO9TzyRnaGPFAHYUUUUAFFFFABRRR QAUUUUAFFFFABRRRQBz95/yUPRv+wVf/APo20roK5+8/5KHo3/YKv/8A0baV0FABRRRQAUUUUAFF FFABRRRQAUUUUAFFFFABRRRQAUUUUAcH478Fal4o8VeDtUsp7SODRb03FyszsGdd8TYTCkE4jPUj qK7yvK/inq2paf46+HdvZahd20F3qZS5jhmZFmXzYBhwDhhhiMH1PrXqlABRRRQAUUUUAFFFFABR RRQAUUUUAFFFFABRRRQAUUUUAcH8WfBWpePPCtrpelz2kM8V6lwzXTsqlQjrgbVY5y47etd5Xlfx 91bUtG8C2NxpeoXdjO2pxo0lrM0TFfKlOCVIOMgHHsK9UoAKKKKACiiigAooooAKKKKACiiigAoo ooAKKKKACiiigDl/iJ4bvPF3gTUtDsJII7q68rY87EINsqOckAnop7VqeGtNm0bwrpGl3DRtPZWU NvI0ZJUsiBSRkA4yPQVzfxfv7zTPhbrN5YXc9pdR+RsmgkMbrmeMHDDkZBI/GtzwXPNdeBfD1xcS yTTy6ZbPJJIxZnYxKSSTySTzmgDcooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACuD+E3 grUvAfhW60vVJ7SaeW9e4VrV2ZQpRFwdyqc5Q9vSu8ryv4BatqWs+Bb641TULu+nXU5EWS6maVgv lRHALEnGSTj3NAHqlFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBz/jv/AJJ54l/7BV1/ 6KavAP2cf+Sh6h/2CpP/AEbFXv8A47/5J54l/wCwVdf+imrwD9nH/koeof8AYKk/9GxUAfT9FFFA BRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVweleCtSsfjLrnjCWe0On39ktvFGrt5oYCEZYb cY/dt0J6j8O8ryvQtW1Kb9o3xPpcuoXb6fDpiPFaNMxiRttvyqZwD8zcgdz60AeqUUUUAFFFFAFf T7OPTtNtbGFmaK2hSFC5yxCgAZx34qxRRQlbQcpOTcnuwooooEFFFFABRRRQAUUUUAFFFFABXB+O /BWpeKPFXg7VLKe0jg0W9NxcrM7BnXfE2EwpBOIz1I6iu8ryv4p6tqWn+Ovh3b2WoXdtBd6mUuY4 ZmRZl82AYcA4YYYjB9T60AeqUUUUAFef/wDCkvh5/wBC9/5O3H/xyvQKKAPP/wDhSXw8/wChe/8A J24/+OV1Hhvwto3hHTpLDQ7P7JaySmZk815MuQATlyT0UflWxRQAUUUUAFFFFABRRRQAUUUUAFFF FABXB/FnwVqXjzwra6Xpc9pDPFepcM107KpUI64G1WOcuO3rXeV5X8fdW1LRvAtjcaXqF3Yztqca NJazNExXypTglSDjIBx7CgD1SiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK5f4ieG7z xd4E1LQ7CSCO6uvK2POxCDbKjnJAJ6Ke1dRXD/F+/vNM+Fus3lhdz2l1H5GyaCQxuuZ4wcMORkEj 8aAOk8NabNo3hXSNLuGjaeysobeRoySpZECkjIBxkegrUrD8FzzXXgXw9cXEsk08umWzySSMWZ2M Skkk8kk85rcoAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigDi/hRps2jfDqw0u4aNp7K 4u7eRoySpZLqVSRkA4yPQV2lcH8GZ5rr4U6PcXEsk08r3LySSMWZ2NxISSTySTzmu8oAKKKKACii igAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKK ACiiigDx/wAWfA+KXUV1rwNf/wBgamm4mNHdI2ZjyVZTui+VmGFBUjAAXkniJfiN8Wvh/E1t4gsP tEK+XDHPqNsXQHaSAs0ZAkYjrlmPynvmvpeigD58g/aZmW3iW48KRyThAJHjvyis2OSFMZIGe2Tj 1NV9S/aW1KW3VdL8N2ltPvBZ7q5adSuDwFUIQc45z2PHPHt8/gvwrdXEtxceGtGmnlcvJJJYRMzs TkkkrkknnNWNN8NaDo1w1xpeiabYzshRpLW1SJiuQcEqAcZAOPYUAeCW198ZviXOptpJ9F019kyT IrWUIBQ7Sr8yyK2M8FhlgTgYx6f4A+EmheBdl5/yENZXePt8qFdqtxhEyQvAxnljlucHA9AooAKK KKACiiigAooooAKKKKACiiigAooooA5+8/5KHo3/AGCr/wD9G2ldBXP3n/JQ9G/7BV//AOjbSugo AKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigDj/GGgeG9X8Q+GLzW9X+xX1hd+bp0P2mO P7TJvjO3awJflUGFwfm9xXYV4/8AF/8A5KH8Mf8AsKn/ANG29ewUAFFFFABRRRQAUUUUAFFFFABR RRQAUUUUAFFFFABRRRQBx/xH0Dw34j8PW9n4o1f+y7FLtZUm+0xwbpAjgLukBB4LHHXj2rsK8f8A 2jv+Seaf/wBhWP8A9FS17BQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAHP+NtK0fW/ CF9p2v3/ANg0yby/OufOSLZiRWX5nBUZYKOfWtDQrWzsfD2mWenXH2ixgtIorebeH8yNUAVtw4OQ Acjg1x/xt/5JDrv/AG7/APpRHXQeBP8Aknnhr/sFWv8A6KWgDoKKKKACiiigAooooAKKKKACiiig AooooAKKKKACiiigArj/AIcaB4b8OeHriz8L6v8A2pYvdtK832mOfbIUQFd0YAHAU468+9dhXj/7 OP8AyTzUP+wrJ/6KioA9gooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAOf8d/8k88S/8A YKuv/RTV4B+zj/yUPUP+wVJ/6Nir3/x3/wAk88S/9gq6/wDRTV4B+zj/AMlD1D/sFSf+jYqAPp+i iigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK4/TtA8N2/xQ1bXLbV/N8Q3NosV1YfaY28q MCLDeWBvXhE5Jx83uK7CvH/D3/J0Piz/ALBUf/oNrQB7BRRRQAUUUUAFFFFABRRRQAUUUUAFFFFA BRRRQAUUUUAFcf4w0Dw3q/iHwxea3q/2K+sLvzdOh+0xx/aZN8Z27WBL8qgwuD83uK7CvH/i/wD8 lD+GP/YVP/o23oA9gooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACuP8AiPoHhvxH4et7 PxRq/wDZdil2sqTfaY4N0gRwF3SAg8Fjjrx7V2FeP/tHf8k80/8A7Csf/oqWgD2CiiigAooooAKK KKACiiigAooooAKKKKACiiigAooooAK5/wAbaVo+t+EL7Ttfv/sGmTeX51z5yRbMSKy/M4KjLBRz 610Fef8Axt/5JDrv/bv/AOlEdAHYaFa2dj4e0yz064+0WMFpFFbzbw/mRqgCtuHByADkcGtCuf8A An/JPPDX/YKtf/RS10FABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAcf8MLWzsfAVrZ 6dcfaLGC7vYrebeH8yNbqUK24cHIAORwa7CvP/gl/wAkh0L/ALeP/SiSvQKACiiigAooooAKKKKA CiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK KK4PwV8WdB8eazNpel2mpQzxW7XDNdRoqlQyrgbXY5y47etAHeUUUUAFFeb+Bfi7Z+PfFt3o9hpM 9vaw2huUuZ5RvfDIpUxgEDlzzuPT349IoAKKKKACuH+InxEt/BVnFaWkP2/xDfYSxsEBYsSdodgO dueAByx4Hcr3FeJ/FO8m8G/Fnwt45uLSS50uO3azkEOdyt+8zyRtztlyoz82xhxjNAFib4jfEjwo g1Pxp4MtF0UOscsunygvEWYfMf3jgjGRg7QSVG4Z57jxV8QNI8MeCovE7eZdW90iGxjRSpuGdSyD JHyAqCSSOADwTgHi/G/xi8K6l4N1XTdAnn1a/vbSaAQw20qeWhjbfKxZB8qKGY4z07DLDhFnm1Hw t8G7K+lkurSfU5kmgnYukipdJGgZTwQqEqAegJA4oA6+bx78YNL0sa3qfgrTRpcSLPcBMrKIuCfl 81mQgHnKHbySODXon/Cf6F/wr/8A4TTzJ/7J8rzMeUfM3btmzb/e3/L1255zjmuknghureW3uIo5 oJUKSRyKGV1IwQQeCCOMV8mfb7z/AIZz8j7XP5P/AAkvkeX5h2+X5HmbMf3d/wA2Om7nrQB6XD49 +MGqaWdb0zwVpp0uVGntw+WlMXJHy+arOSBxhBu4IHIr0Dwr8QNI8T+CpfE6+Za29qjm+jdSxt2R QzjIHzgKQQQOQRwDkDqIIIbW3it7eKOGCJAkccahVRQMAADgADjFfNDTzad4W+MllYyyWtpBqcKQ wQMUSNXunjcKo4AZAFIHUAA8UAdna/ET4neKvP1Pwh4QsZNCaVo7WS+YLI4Xgk5mUHnP3QQDlckq TXafDnx6vjfS7lLq0ksda05xDqNoyMoR+QCueQCVb5TypBBzwTofD6CG2+HPhtIIo4kOmW7lUUKC zRhmPHcsSSe5JNcH4W/0T9pXxhZ237m1l09J5IY/lR5MQHeVHBbLuc9fnb1NAHoF5/yUPRv+wVf/ APo20roK5PXtTg0rx1ok9xHdujaZfIBa2ktw2fNtDysasQOOuMdPUVc/4TLS/wDn11z/AMEV7/8A GaAOgorn/wDhMtL/AOfXXP8AwRXv/wAZrQtdZtbzTp76KK+WGHduWawnikOBk7Y3QO3B42g5PAye KANCiuf/AOEy0v8A59dc/wDBFe//ABmtC61m1s9OgvpYr5oZtu1YbCeWQZGRujRC68DncBg8HB4o A0KKw4PFmnXNxFAltrIeRwimTRbxFBJxyzRAKPckAd6salr9npVwsFxDqTuyBwbXTbi4XGSOWjRg Dx0znp6igDUorL03X7PVbhoLeHUkdULk3Wm3FuuMgcNIignnpnPX0NV5/FmnW1xLA9trJeNyjGPR bx1JBxwyxEMPcEg9qANyis+11m1vNOnvoor5YYd25ZrCeKQ4GTtjdA7cHjaDk8DJ4rP/AOEy0v8A 59dc/wDBFe//ABmgDoKKz7rWbWz06C+livmhm27VhsJ5ZBkZG6NELrwOdwGDwcHiqcHizTrm4igS 21kPI4RTJot4igk45ZogFHuSAO9AG5RWXqWv2elXCwXEOpO7IHBtdNuLhcZI5aNGAPHTOenqKNN1 +z1W4aC3h1JHVC5N1ptxbrjIHDSIoJ56Zz19DQBqUVhz+LNOtriWB7bWS8blGMei3jqSDjhliIYe 4JB7VctdZtbzTp76KK+WGHduWawnikOBk7Y3QO3B42g5PAyeKAOf8Ya/4b0jxD4Ys9b0j7bfX935 WnTfZo5Ps0m+MbtzEFOWQ5XJ+X2FdhXi/wAR7mbXvGXgS/0zSdcntdL1AzXj/wBjXS+UnmQnOGjB PCN0z0r1i61m1s9OgvpYr5oZtu1YbCeWQZGRujRC68DncBg8HB4oA0KKw4PFmnXNxFAltrIeRwim TRbxFBJxyzRAKPckAd6salr9npVwsFxDqTuyBwbXTbi4XGSOWjRgDx0znp6igDUorL03X7PVbhoL eHUkdULk3Wm3FuuMgcNIignnpnPX0NV5/FmnW1xLA9trJeNyjGPRbx1JBxwyxEMPcEg9qANyis+1 1m1vNOnvoor5YYd25ZrCeKQ4GTtjdA7cHjaDk8DJ4rP/AOEy0v8A59dc/wDBFe//ABmgDoKKz7rW bWz06C+livmhm27VhsJ5ZBkZG6NELrwOdwGDwcHiqcHizTrm4igS21kPI4RTJot4igk45ZogFHuS AO9AG5RWXqWv2elXCwXEOpO7IHBtdNuLhcZI5aNGAPHTOenqKNN1+z1W4aC3h1JHVC5N1ptxbrjI HDSIoJ56Zz19DQBqUVhz+LNOtriWB7bWS8blGMei3jqSDjhliIYe4JB7VctdZtbzTp76KK+WGHdu WawnikOBk7Y3QO3B42g5PAyeKANCiuf/AOEy0v8A59dc/wDBFe//ABmtC61m1s9OgvpYr5oZtu1Y bCeWQZGRujRC68DncBg8HB4oA0KKw4PFmnXNxFAltrIeRwimTRbxFBJxyzRAKPckAd6salr9npVw sFxDqTuyBwbXTbi4XGSOWjRgDx0znp6igDD+I+v+G/Dnh63vPFGkf2pYvdrEkP2aOfbIUchtshAH AYZ68+9dhXi/xruZvF3g2zsND0nXLu6j1BJmT+xrqPCCOQE5eMDqw/OvTJ/FmnW1xLA9trJeNyjG PRbx1JBxwyxEMPcEg9qANyis+11m1vNOnvoor5YYd25ZrCeKQ4GTtjdA7cHjaDk8DJ4rP/4TLS/+ fXXP/BFe/wDxmgDoKKz7rWbWz06C+livmhm27VhsJ5ZBkZG6NELrwOdwGDwcHiqcHizTrm4igS21 kPI4RTJot4igk45ZogFHuSAO9AG5RWXqWv2elXCwXEOpO7IHBtdNuLhcZI5aNGAPHTOenqKNN1+z 1W4aC3h1JHVC5N1ptxbrjIHDSIoJ56Zz19DQBqUVhz+LNOtriWB7bWS8blGMei3jqSDjhliIYe4J B7VctdZtbzTp76KK+WGHduWawnikOBk7Y3QO3B42g5PAyeKANCiuf/4TLS/+fXXP/BFe/wDxmtC6 1m1s9OgvpYr5oZtu1YbCeWQZGRujRC68DncBg8HB4oA0KKw4PFmnXNxFAltrIeRwimTRbxFBJxyz RAKPckAd6salr9npVwsFxDqTuyBwbXTbi4XGSOWjRgDx0znp6igDUorL03X7PVbhoLeHUkdULk3W m3FuuMgcNIignnpnPX0NV5/FmnW1xLA9trJeNyjGPRbx1JBxwyxEMPcEg9qANyis+11m1vNOnvoo r5YYd25ZrCeKQ4GTtjdA7cHjaDk8DJ4rP/4TLS/+fXXP/BFe/wDxmgA8baro+ieEL7UdfsPt+mQ+ X51t5KS78yKq/K5CnDFTz6VoaFdWd94e0y8063+z2M9pFLbw7AnlxsgKrtHAwCBgcCuP+Liz6v8A Ci/t9Osr66uL77P5EENnK0h/eI53IF3JhVOdwGDweSBVzwXr1ta+FfD2k3FlrMN5FZW1tIsmj3aq kgRVILmPaAD/ABZx3zigDtKKy9S1+z0q4WC4h1J3ZA4NrptxcLjJHLRowB46Zz09RRpuv2eq3DQW 8OpI6oXJutNuLdcZA4aRFBPPTOevoaANSisOfxZp1tcSwPbayXjcoxj0W8dSQccMsRDD3BIParlr rNreadPfRRXyww7tyzWE8UhwMnbG6B24PG0HJ4GTxQBoUVz/APwmWl/8+uuf+CK9/wDjNaF1rNrZ 6dBfSxXzQzbdqw2E8sgyMjdGiF14HO4DB4ODxQBoUVhweLNOubiKBLbWQ8jhFMmi3iKCTjlmiAUe 5IA71Y1LX7PSrhYLiHUndkDg2um3FwuMkctGjAHjpnPT1FAGpRWXpuv2eq3DQW8OpI6oXJutNuLd cZA4aRFBPPTOevoarz+LNOtriWB7bWS8blGMei3jqSDjhliIYe4JB7UAblFZ9rrNreadPfRRXyww 7tyzWE8UhwMnbG6B24PG0HJ4GTxWf/wmWl/8+uuf+CK9/wDjNAHQUVn3Ws2tnp0F9LFfNDNt2rDY TyyDIyN0aIXXgc7gMHg4PFU4PFmnXNxFAltrIeRwimTRbxFBJxyzRAKPckAd6ANyisvUtfs9KuFg uIdSd2QODa6bcXC4yRy0aMAeOmc9PUUabr9nqtw0FvDqSOqFybrTbi3XGQOGkRQTz0znr6GgDUrj /hxr/hvxH4euLzwvpH9l2KXbRPD9mjg3SBEJbbGSDwVGevHtWpP4s062uJYHttZLxuUYx6LeOpIO OGWIhh7gkHtXB/ArT7/w98PNSGr6dfWUi6hLN5M1rIJGQRRcqmNzdCBgHJGBzQB6xRXP/wDCZaX/ AM+uuf8Agivf/jNaF1rNrZ6dBfSxXzQzbdqw2E8sgyMjdGiF14HO4DB4ODxQBoUVhweLNOubiKBL bWQ8jhFMmi3iKCTjlmiAUe5IA71Y1LX7PSrhYLiHUndkDg2um3FwuMkctGjAHjpnPT1FAGpRWXpu v2eq3DQW8OpI6oXJutNuLdcZA4aRFBPPTOevoarz+LNOtriWB7bWS8blGMei3jqSDjhliIYe4JB7 UAblFZ9rrNreadPfRRXyww7tyzWE8UhwMnbG6B24PG0HJ4GTxWf/AMJlpf8Az665/wCCK9/+M0Ad BRWfdaza2enQX0sV80M23asNhPLIMjI3RohdeBzuAweDg8VTg8Wadc3EUCW2sh5HCKZNFvEUEnHL NEAo9yQB3oA3KKy9S1+z0q4WC4h1J3ZA4NrptxcLjJHLRowB46Zz09RRpuv2eq3DQW8OpI6oXJut NuLdcZA4aRFBPPTOevoaANSisOfxZp1tcSwPbayXjcoxj0W8dSQccMsRDD3BIParlrrNreadPfRR Xyww7tyzWE8UhwMnbG6B24PG0HJ4GTxQBoUVz/8AwmWl/wDPrrn/AIIr3/4zWhdaza2enQX0sV80 M23asNhPLIMjI3RohdeBzuAweDg8UAZ/jv8A5J54l/7BV1/6KavAP2cf+Sh6h/2CpP8A0bFXsfjT xZp1z4F8QwJbayHk0y5RTJot4igmJhyzRAKPckAd68Q+AWpwaV46vp7iO7dG0yRALW0luGz5sR5W NWIHHXGOnqKAPquisvTdfs9VuGgt4dSR1QuTdabcW64yBw0iKCeemc9fQ1Xn8WadbXEsD22sl43K MY9FvHUkHHDLEQw9wSD2oA3KKz7XWbW806e+iivlhh3blmsJ4pDgZO2N0DtweNoOTwMnis//AITL S/8An11z/wAEV7/8ZoA6Cis+61m1s9OgvpYr5oZtu1YbCeWQZGRujRC68DncBg8HB4qnB4s065uI oEttZDyOEUyaLeIoJOOWaIBR7kgDvQBuUVl6lr9npVwsFxDqTuyBwbXTbi4XGSOWjRgDx0znp6ij Tdfs9VuGgt4dSR1QuTdabcW64yBw0iKCeemc9fQ0AalFYc/izTra4lge21kvG5RjHot46kg44ZYi GHuCQe1XLXWbW806e+iivlhh3blmsJ4pDgZO2N0DtweNoOTwMnigDQorn/8AhMtL/wCfXXP/AARX v/xmtC61m1s9OgvpYr5oZtu1YbCeWQZGRujRC68DncBg8HB4oA0KKw4PFmnXNxFAltrIeRwimTRb xFBJxyzRAKPckAd6salr9npVwsFxDqTuyBwbXTbi4XGSOWjRgDx0znp6igDUorL03X7PVbhoLeHU kdULk3Wm3FuuMgcNIignnpnPX0NV5/FmnW1xLA9trJeNyjGPRbx1JBxwyxEMPcEg9qANyuP07X/D dx8UNW0O20jyvENtaLLdX/2aNfNjIiwvmA724dOCMfL7CugtdZtbzTp76KK+WGHduWawnikOBk7Y 3QO3B42g5PAyeK8n0a5mtPjz4h8Sz6TriaRd6ekMFx/Y10d7hYARtEe4fcbqO30oA9oorPutZtbP ToL6WK+aGbbtWGwnlkGRkbo0QuvA53AYPBweKpweLNOubiKBLbWQ8jhFMmi3iKCTjlmiAUe5IA70 AblFZepa/Z6VcLBcQ6k7sgcG1024uFxkjlo0YA8dM56eoo03X7PVbhoLeHUkdULk3Wm3FuuMgcNI ignnpnPX0NAGpRWHP4s062uJYHttZLxuUYx6LeOpIOOGWIhh7gkHtVy11m1vNOnvoor5YYd25ZrC eKQ4GTtjdA7cHjaDk8DJ4oA0KK5//hMtL/59dc/8EV7/APGa0LrWbWz06C+livmhm27VhsJ5ZBkZ G6NELrwOdwGDwcHigDQorDg8Wadc3EUCW2sh5HCKZNFvEUEnHLNEAo9yQB3qxqWv2elXCwXEOpO7 IHBtdNuLhcZI5aNGAPHTOenqKANSisvTdfs9VuGgt4dSR1QuTdabcW64yBw0iKCeemc9fQ1Xn8Wa dbXEsD22sl43KMY9FvHUkHHDLEQw9wSD2oA3KKz7XWbW806e+iivlhh3blmsJ4pDgZO2N0DtweNo OTwMnis//hMtL/59dc/8EV7/APGaAOgorPutZtbPToL6WK+aGbbtWGwnlkGRkbo0QuvA53AYPBwe KpweLNOubiKBLbWQ8jhFMmi3iKCTjlmiAUe5IA70Ablcf4w1/wAN6R4h8MWet6R9tvr+78rTpvs0 cn2aTfGN25iCnLIcrk/L7CtzUtfs9KuFguIdSd2QODa6bcXC4yRy0aMAeOmc9PUV5f8AEB7jxP46 8AXGk6VrM0Gn6mHupJNKuYViUywkEmSNRjCMc9sc0AeyUVhz+LNOtriWB7bWS8blGMei3jqSDjhl iIYe4JB7VctdZtbzTp76KK+WGHduWawnikOBk7Y3QO3B42g5PAyeKANCiuf/AOEy0v8A59dc/wDB Fe//ABmtC61m1s9OgvpYr5oZtu1YbCeWQZGRujRC68DncBg8HB4oA0KKw4PFmnXNxFAltrIeRwim TRbxFBJxyzRAKPckAd6salr9npVwsFxDqTuyBwbXTbi4XGSOWjRgDx0znp6igDUorL03X7PVbhoL eHUkdULk3Wm3FuuMgcNIignnpnPX0NV5/FmnW1xLA9trJeNyjGPRbx1JBxwyxEMPcEg9qANyis+1 1m1vNOnvoor5YYd25ZrCeKQ4GTtjdA7cHjaDk8DJ4rP/AOEy0v8A59dc/wDBFe//ABmgDoKKz7rW bWz06C+livmhm27VhsJ5ZBkZG6NELrwOdwGDwcHiqcHizTrm4igS21kPI4RTJot4igk45ZogFHuS AO9AG5RWXqWv2elXCwXEOpO7IHBtdNuLhcZI5aNGAPHTOenqKNN1+z1W4aC3h1JHVC5N1ptxbrjI HDSIoJ56Zz19DQBqUVhz+LNOtriWB7bWS8blGMei3jqSDjhliIYe4JB7VctdZtbzTp76KK+WGHdu WawnikOBk7Y3QO3B42g5PAyeKANCuP8AiPr/AIb8OeHre88UaR/ali92sSQ/Zo59shRyG2yEAcBh nrz71of8Jlpf/Prrn/givf8A4zXD/HXT7/xD8PNNGkadfXsjahFN5MNrIZFQxS8smNy9QDkDBODz QB6xRWHB4s065uIoEttZDyOEUyaLeIoJOOWaIBR7kgDvVjUtfs9KuFguIdSd2QODa6bcXC4yRy0a MAeOmc9PUUAalFZem6/Z6rcNBbw6kjqhcm6024t1xkDhpEUE89M56+hqvP4s062uJYHttZLxuUYx 6LeOpIOOGWIhh7gkHtQBuUVn2us2t5p099FFfLDDu3LNYTxSHAydsboHbg8bQcngZPFZ/wDwmWl/ 8+uuf+CK9/8AjNAHQUVn3Ws2tnp0F9LFfNDNt2rDYTyyDIyN0aIXXgc7gMHg4PFU4PFmnXNxFAlt rIeRwimTRbxFBJxyzRAKPckAd6ANyisvUtfs9KuFguIdSd2QODa6bcXC4yRy0aMAeOmc9PUUabr9 nqtw0FvDqSOqFybrTbi3XGQOGkRQTz0znr6GgDUorDn8WadbXEsD22sl43KMY9FvHUkHHDLEQw9w SD2q5a6za3mnT30UV8sMO7cs1hPFIcDJ2xugduDxtByeBk8UAaFFc/8A8Jlpf/Prrn/givf/AIzW hdaza2enQX0sV80M23asNhPLIMjI3RohdeBzuAweDg8UAaFFYcHizTrm4igS21kPI4RTJot4igk4 5ZogFHuSAO9WNS1+z0q4WC4h1J3ZA4NrptxcLjJHLRowB46Zz09RQBqVz/jbVdH0Twhfajr9h9v0 yHy/OtvJSXfmRVX5XIU4YqefSrmm6/Z6rcNBbw6kjqhcm6024t1xkDhpEUE89M56+hrh/izqP9te Ada0LTdO1m61B3jRI49IuirFJkLYfy9hGFJyDg9s0Ad5oV1Z33h7TLzTrf7PYz2kUtvDsCeXGyAq u0cDAIGBwK0K5fwRdiD4eaUJ7a+hk0/T4YbiGaymSQPHEu4KhUM/oNoOTwMmrH/CZaX/AM+uuf8A givf/jNAHQUVn3Ws2tnp0F9LFfNDNt2rDYTyyDIyN0aIXXgc7gMHg4PFU4PFmnXNxFAltrIeRwim TRbxFBJxyzRAKPckAd6ANyisvUtfs9KuFguIdSd2QODa6bcXC4yRy0aMAeOmc9PUUabr9nqtw0Fv DqSOqFybrTbi3XGQOGkRQTz0znr6GgDUorDn8WadbXEsD22sl43KMY9FvHUkHHDLEQw9wSD2q5a6 za3mnT30UV8sMO7cs1hPFIcDJ2xugduDxtByeBk8UAaFFc//AMJlpf8Az665/wCCK9/+M1oXWs2t np0F9LFfNDNt2rDYTyyDIyN0aIXXgc7gMHg4PFAGhRWHB4s065uIoEttZDyOEUyaLeIoJOOWaIBR 7kgDvVjUtfs9KuFguIdSd2QODa6bcXC4yRy0aMAeOmc9PUUAalFZem6/Z6rcNBbw6kjqhcm6024t 1xkDhpEUE89M56+hqvP4s062uJYHttZLxuUYx6LeOpIOOGWIhh7gkHtQBuUVn2us2t5p099FFfLD Du3LNYTxSHAydsboHbg8bQcngZPFZ/8AwmWl/wDPrrn/AIIr3/4zQB0FFYc3izToHCPbaySUV/k0 W8cYZQw5WIjODyOoOQcEEVH/AMJlpf8Az665/wCCK9/+M0AZ/wAMLqzvvAVreadb/Z7Ge7vZbeHY E8uNrqUqu0cDAIGBwK7CuD+DME1r8KdHt7iKSGeJ7lJI5FKsjC4kBBB5BB4xXeUAFFFFABRRRQAU UUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABVe /tft2nXNn9ont/PieLzrd9kke4EbkbswzkHsasUUAfMk/gn44Q3EsSahrM6I5VZY9dAVwD94bpQc HryAfUCvP/BWmeK9V1maDwfJdpqC27PIbW7Fu3lblByxZcjcV4z6elfbdeL+G/FPwS8I6jJf6Hef ZLqSIws/lXsmUJBIw4I6qPyoA4j/AIQ345/8/Wuf+D1f/j1Rz+BvjbdW8tvcS6zNBKhSSOTW0ZXU jBBBlwQRxivY/wDhdvw8/wChh/8AJK4/+N0f8Lt+Hn/Qw/8Aklcf/G6AOf8Agv8AC3UfB0tzrmuN 5OpXETWyWaOriOPcCWZhkFiUGADgDrknC+wVy/hv4ieFfF2oyWGh6r9ruo4jMyfZ5Y8ICATl1A6s PzrqKACiiigArzP4neOtS8E6ppZvNItNQ8J6gjQXoMTNKG53Lkny8FSCFP3trjgcj0yo54Ibq3lt 7iKOaCVCkkcihldSMEEHggjjFAHhfirx34On8L6j4d+HGn+bq+sxGErpWk7MoD84cFFLZjMoG0Nj k/L1qx498F3nhb4deD9R0m0+0X/hOVLiaONi8POJJpCDhyvmop4xhWbgAfL65pvhrQdGuGuNL0TT bGdkKNJa2qRMVyDglQDjIBx7CtSgDyvVfjz4Pi8NXF3pl9JNqht91vZS2kgIlI4VzwuAT82G6A4J 4zyf/CsdR/4Z2+xfYb7+2/tf9rfYsrv3f6vbtxn/AFPzbPvbuOvy17JB4L8K2txFcW/hrRoZ4nDx yR2ESsjA5BBC5BB5zW5QB5XpXx58Hy+Gre71O+kh1QW+64sorSQkygcqh5XBI+XLdCMkc45vwh4L 1HxR8L/Gmp6haTwan4ola8t4EZY0k2EywlQ2SqtIzD5jyuCCM7j65P4L8K3VxLcXHhrRpp5XLySS WETM7E5JJK5JJ5zW5QB434D+MHhvSvB1ho/ie7k0vVtMT7DNbvZzHiP5VPyhsHaACDg7g3AGKk+F CXHinxz4o+Ic9nPbWt9i008sAqyxKQCSuSSwEUQJB27i4GccekX3hPw3qd5JeX/h/Sru6kxvmnso 5HbAAGWIycAAfhWpBBDa28VvbxRwwRIEjjjUKqKBgAAcAAcYoAw7z/koejf9gq//APRtpXQVz95/ yUPRv+wVf/8Ao20roKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA4Px3411Lwv4q8H aXZQWkkGtXpt7lpkYsi74lymGABxIeoPQV3lcH478Fal4o8VeDtUsp7SODRb03FyszsGdd8TYTCk E4jPUjqK7ygAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAOD+LPjXUvAfhW11TS4LSae W9S3ZbpGZQpR2yNrKc5Qd/Wu8rg/iz4K1Lx54VtdL0ue0hnivUuGa6dlUqEdcDarHOXHb1rvKACi iigAooooAKKKKACiiigAooooAKKKKACiiigAooooA5f4ieJLzwj4E1LXLCOCS6tfK2JOpKHdKiHI BB6Me9anhrUptZ8K6Rqlwsaz3tlDcSLGCFDOgYgZJOMn1NZfxE8N3ni7wJqWh2EkEd1deVsediEG 2VHOSAT0U9q1PDWmzaN4V0jS7ho2nsrKG3kaMkqWRApIyAcZHoKANSiiigAooooAKKKKACiiigAo oooAKKKKACiiigAooooAK4P4TeNdS8eeFbrVNUgtIZ4r17dVtUZVKhEbJ3Mxzlz39K7yuD+E3grU vAfhW60vVJ7SaeW9e4VrV2ZQpRFwdyqc5Q9vSgDvKKKKACiiigAooooAKKKKACiiigAooooAKKKK ACiiigDn/Hf/ACTzxL/2Crr/ANFNXgH7OP8AyUPUP+wVJ/6Nir3/AMd/8k88S/8AYKuv/RTV4B+z j/yUPUP+wVJ/6NioA+n6KKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigArg9K8a6lffGXXP B8sFoNPsLJbiKRUbzSxEJwx3Yx+8boB0H495XB6V4K1Kx+MuueMJZ7Q6ff2S28Uau3mhgIRlhtxj 923QnqPwAO8ooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACuD8d+NdS8L+KvB2l2UFpJB rV6be5aZGLIu+JcphgAcSHqD0Fd5XB+O/BWpeKPFXg7VLKe0jg0W9NxcrM7BnXfE2EwpBOIz1I6i gDvKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigArg/iz411LwH4VtdU0uC0mnlvUt2W6R mUKUdsjaynOUHf1rvK4P4s+CtS8eeFbXS9LntIZ4r1LhmunZVKhHXA2qxzlx29aAO8ooooAKKKKA CiiigAooooAKKKKACiiigAooooAKKKKACuX+IniS88I+BNS1ywjgkurXytiTqSh3SohyAQejHvXU Vy/xE8N3ni7wJqWh2EkEd1deVsediEG2VHOSAT0U9qANTw1qU2s+FdI1S4WNZ72yhuJFjBChnQMQ MknGT6mtSsvw1ps2jeFdI0u4aNp7Kyht5GjJKlkQKSMgHGR6CtSgAooooAKKKKACiiigAooooAKK KKACiiigAooooAKKKKAOL+FGpTaz8OrDVLhY1nvbi7uJFjBChnupWIGSTjJ9TXaVxfwo02bRvh1Y aXcNG09lcXdvI0ZJUsl1KpIyAcZHoK7SgAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKA CiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACvH/APhnHwf/ANBLXP8Av/D/APGq 9gooA8f/AOGcfB//AEEtc/7/AMP/AMarkPiB8BE0HQ7nWfDmoT3ENnEZbi1vCu/YuS7q4CjgYO0j s2CTha+j6x/E/ifS/COhzavq8/lW8fCqvLyueiIO7HB/IkkAEgA8r+AujeFZku/EWivqUOoIjWVz Z3d1FMEVmV1cbUU4O0YJA5DjBxmvbK+aP2bvtn/CZats8/7D/Z/73bny/M8xNm7tux5mM843Y719 L0AFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAc/ef8lD0b/sFX/wD6NtK6CufvP+Sh6N/2Cr//ANG2 ldBQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAHlfxT1bUtP8dfDu3stQu7aC71Mpcx wzMizL5sAw4BwwwxGD6n1r1SuP8AGGgeG9X8Q+GLzW9X+xX1hd+bp0P2mOP7TJvjO3awJflUGFwf m9xXYUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQB5X8fdW1LRvAtjcaXqF3YztqcaN JazNExXypTglSDjIBx7CvVK4/wCI+geG/Efh63s/FGr/ANl2KXaypN9pjg3SBHAXdICDwWOOvHtX YUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBw/xfv7zTPhbrN5YXc9pdR+RsmgkMbr meMHDDkZBI/GtzwXPNdeBfD1xcSyTTy6ZbPJJIxZnYxKSSTySTzmo/G2laPrfhC+07X7/wCwaZN5 fnXPnJFsxIrL8zgqMsFHPrWhoVrZ2Ph7TLPTrj7RYwWkUVvNvD+ZGqAK24cHIAORwaANCiiigAoo ooAKKKKACiiigAooooAKKKKACiiigAooooAK8r+AWralrPgW+uNU1C7vp11ORFkupmlYL5URwCxJ xkk49zXqlcf8ONA8N+HPD1xZ+F9X/tSxe7aV5vtMc+2QogK7owAOApx1596AOwooooAKKKKACiii gAooooAKKKKACiiigAooooAKKKKAOf8AHf8AyTzxL/2Crr/0U1eAfs4/8lD1D/sFSf8Ao2Kvf/Hf /JPPEv8A2Crr/wBFNXgH7OP/ACUPUP8AsFSf+jYqAPp+iiigAooooAKKKKACiiigAooooAKKKKAC iiigAooooAK8r0LVtSm/aN8T6XLqF2+nw6YjxWjTMYkbbb8qmcA/M3IHc+teqVx+naB4bt/ihq2u W2r+b4hubRYrqw+0xt5UYEWG8sDevCJyTj5vcUAdhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRR QAUUUUAFeV/FPVtS0/x18O7ey1C7toLvUylzHDMyLMvmwDDgHDDDEYPqfWvVK4/xhoHhvV/EPhi8 1vV/sV9YXfm6dD9pjj+0yb4zt2sCX5VBhcH5vcUAdhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRR RQAUUUUAFeV/H3VtS0bwLY3Gl6hd2M7anGjSWszRMV8qU4JUg4yAcewr1SuP+I+geG/Efh63s/FG r/2XYpdrKk32mODdIEcBd0gIPBY468e1AHYUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFF ABXD/F+/vNM+Fus3lhdz2l1H5GyaCQxuuZ4wcMORkEj8a7iuf8baVo+t+EL7Ttfv/sGmTeX51z5y RbMSKy/M4KjLBRz60ASeC55rrwL4euLiWSaeXTLZ5JJGLM7GJSSSeSSec1uVn6Fa2dj4e0yz064+ 0WMFpFFbzbw/mRqgCtuHByADkcGtCgAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAOD+ DM8118KdHuLiWSaeV7l5JJGLM7G4kJJJ5JJ5zXeVx/wwtbOx8BWtnp1x9osYLu9it5t4fzI1upQr bhwcgA5HBrsKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKK ACiiigAooooAKKKKACiiigAooooAK+YP+GcfGH/QS0P/AL/zf/Gq+n68f+JHxxt/Cuoy6NoFtBqG pRcTzSsTDA4IymFwXbG4HBG045JBUAHAf8M4+MP+glof/f8Am/8AjVSQfs3+KmuIluNV0aOAuBI8 ckrsq55IUoATjtkZ9RVeH4i/GXWUOoaZDqUlnO7NEbTRlkiA3EbVby2JAII5JPHJzVjTfjt438NX 7WPifTo7143LTRXUBtLhQUG1RtACjo3KEkE88jAB7f4B8A6b8P8ARpLKylkuJ7h1kubmVFDOwUDA wMhAckKScbjyc11lY/hjxPpfi7Q4dX0ifzbeThlbh4nHVHHZhkfmCCQQTsUAFFFFABRRRQAUUUUA FFFFABRRRQAUUUUAc/ef8lD0b/sFX/8A6NtK6CufvP8Akoejf9gq/wD/AEbaV0FABRRRQAUUUUAF FFFABRRRQAUUUUAFFFFABRRRQAUUUUAeP/F//kofwx/7Cp/9G29ewVx/jDX/AA3pHiHwxZ63pH22 +v7vytOm+zRyfZpN8Y3bmIKcshyuT8vsK7CgAooooAKKKKACiiigAooooAKKKKACiiigAooooAKK KKAPH/2jv+Seaf8A9hWP/wBFS17BXH/EfX/Dfhzw9b3nijSP7UsXu1iSH7NHPtkKOQ22QgDgMM9e feuwoAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigDz/42/8AJIdd/wC3f/0ojroPAn/J PPDX/YKtf/RS0eNtV0fRPCF9qOv2H2/TIfL8628lJd+ZFVflchThip59K0NCurO+8PaZeadb/Z7G e0ilt4dgTy42QFV2jgYBAwOBQBoUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXj/wCz j/yTzUP+wrJ/6Kir2CuP+HGv+G/Efh64vPC+kf2XYpdtE8P2aODdIEQltsZIPBUZ68e1AHYUUUUA FFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAHP+O/8AknniX/sFXX/opq8A/Zx/5KHqH/YKk/8A RsVe/wDjv/knniX/ALBV1/6KavAP2cf+Sh6h/wBgqT/0bFQB9P0UUUAFFFFABRRRQAUUUUAFFFFA BRRRQAUUUUAFFFFABXj/AIe/5Oh8Wf8AYKj/APQbWvYK4/Ttf8N3HxQ1bQ7bSPK8Q21ost1f/Zo1 82MiLC+YDvbh04Ix8vsKAOwooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACvH/i//AMlD +GP/AGFT/wCjbevYK4/xhr/hvSPEPhiz1vSPtt9f3fladN9mjk+zSb4xu3MQU5ZDlcn5fYUAdhRR RQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFeP/ALR3/JPNP/7Csf8A6Klr2CuP+I+v+G/D nh63vPFGkf2pYvdrEkP2aOfbIUchtshAHAYZ68+9AHYUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAU UUUAFFFFABXn/wAbf+SQ67/27/8ApRHXoFc/421XR9E8IX2o6/Yfb9Mh8vzrbyUl35kVV+VyFOGK nn0oAPAn/JPPDX/YKtf/AEUtdBWfoV1Z33h7TLzTrf7PYz2kUtvDsCeXGyAqu0cDAIGBwK0KACii igAooooAKKKKACiiigAooooAKKKKACiiigAooooA8/8Agl/ySHQv+3j/ANKJK9Arj/hhdWd94Ctb zTrf7PYz3d7Lbw7AnlxtdSlV2jgYBAwOBXYUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABR RRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBj+LL640zwbrl/ZyeXdWun3E0 L7QdrrGxU4PBwQOtfPn7PPhex1nxLqGsX0ccx0lIjbxOmQJXLYk64yojOAQeWBGCor6br48tvGWm +C/GMmu+ATdrBOkkb2Wq2ylY422kIHWQsw3DIPykbVBLZOQD7DrD8XeF7Hxj4au9Hv44yJUJhlZN xglwdsi8g5BPTIyMg8E15nY/tI+G5LONr/RtVgujnfHAI5UXk4wxZSeMfwj0561znjn9oNtT0uTT vClpd2JnQLJfXDKsqDncqKpIBxj592Rk4AOGABX/AGbNSmi8VazparH5FxZC4diDuDRuFUDnGMSt njsOnf6Tr5k+GfxD8A+ANLLvp2s3OtXCAXV2LeLAHXy48yZCA9+rEZPQBe7/AOGjvB//AEDdc/78 Q/8Ax2gD2CiiigAooooAKKKKACiiigAooooAKKKKAOfvP+Sh6N/2Cr//ANG2ldBXP3n/ACUPRv8A sFX/AP6NtK6CgAooooAKKKKACiiigAooooAKKKo6xrFhoGlTanqc/kWcG3zJNjNt3MFHCgnqR2qo xlOSjFXbAvUV5j4n+KngvUfCes2NrrPmXNzYzwxJ9lmG52jYAZKYHJHWvmuvpMt4arYuEpVm6duj i9fvaMZ1lHbU+4qK+Ha9q+EHjzw14X8J3VjrOpfZrmS+eZU8iR8oY4wDlVI6qfyrXMOFqmFo+0pT c32Udfwb/IUK6k7PQ94orD8O+MNB8Wfaf7Ev/tX2bb537l027s7fvKM/dPT0rcr5irSnSk4VItNd GrM2TT1R5X8U9J1LUPHXw7uLLT7u5gtNTL3MkMLOsK+bAcuQMKMKTk+h9K9Urg/HfjXUvC/irwdp dlBaSQa1em3uWmRiyLviXKYYAHEh6g9BXeVmMKKKKACiiigAooooAKKKKACiiigArxzWvjv/AGPr 2o6Z/wAI3532O5kt/M+3bd+xiuceWcZx0zXsdeceNPhv4S/sHxDrf9k/8TH7Nc3fnfaJf9btZ923 dj73OMY9q9XKZYFVXHGQck7JW739UZ1Oa3us5X/hon/qVv8Ayof/AGqu5+HfxE/4T7+0v+JV9h+x eV/y8ebv37/9lcY2e/WvFfhB4b0nxR4surHWbT7TbR2LzKnmOmHEkYBypB6Mfzr6G8O+D9B8J/af 7EsPsv2nb537533bc7fvMcfePT1r2M9o5VhFLD0qTVTRp3bW/nLtfoRSc5at6G5RRRXyRueV/H3S dS1nwLY2+l6fd3066nG7R2sLSsF8qUZIUE4yQM+4r1SuD+LPjXUvAfhW11TS4LSaeW9S3ZbpGZQp R2yNrKc5Qd/Wu8oAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigDh/i/YXmp/C3WbOwtJ 7u6k8jZDBGZHbE8ZOFHJwAT+FbnguCa18C+Hre4ikhni0y2SSORSrIwiUEEHkEHjFU/iJ4kvPCPg TUtcsI4JLq18rYk6kod0qIcgEHox71qeGtSm1nwrpGqXCxrPe2UNxIsYIUM6BiBkk4yfU0AalFFF ABRRRQAUUUUAFFFFABRRRQAUUVxXi/4n6L4K1aLTdStdQlmlgE6tbRoy7SzLj5nBzlT2rfD4ariJ +zoxu+wm0ldna0V5V/wv7wr/ANA/Wf8AvzF/8crV8N/F/wAP+KNftdGsbPU47m537GnijCDapY5I cnop7V2VMnx9ODnOk0lq/QlVIvS56BRRRXmFhXlfwC0nUtG8C31vqmn3djO2pyOsd1C0TFfKiGQG AOMgjPsa9Urg/hN411Lx54VutU1SC0hnivXt1W1RlUqERsnczHOXPf0oA7yiiigAooooAKKKKACi iigAooooAKKK5/xf4v0/wVpMWpalDcywyziBVtlVm3FWbPzMBjCnvWlKlOtNU6au3shNpK7Ogory r/hf3hX/AKB+s/8AfmL/AOOUf8L+8K/9A/Wf+/MX/wAcr0f7DzH/AJ9Mj2sO56rRRRXlGhz/AI7/ AOSeeJf+wVdf+imrwD9nH/koeof9gqT/ANGxV7/47/5J54l/7BV1/wCimrwD9nH/AJKHqH/YKk/9 GxUAfT9FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAV5XoWk6lD+0b4n1SXT7tNPm0xEi u2hYRO2234V8YJ+VuAex9K9Urg9K8a6lffGXXPB8sFoNPsLJbiKRUbzSxEJwx3Yx+8boB0H4gHeU UUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXlfxT0nUtQ8dfDu4stPu7mC01MvcyQws6w r5sBy5AwowpOT6H0r1SuD8d+NdS8L+KvB2l2UFpJBrV6be5aZGLIu+JcphgAcSHqD0FAHeUUUUAF FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXlfx90nUtZ8C2Nvpen3d9Oupxu0drC0rBfKlGSF BOMkDPuK9Urg/iz411LwH4VtdU0uC0mnlvUt2W6RmUKUdsjaynOUHf1oA7yiiigAooooAKKKKACi iigAooooAKKKKACiiigAooooAK4f4v2F5qfwt1mzsLSe7upPI2QwRmR2xPGThRycAE/hXcVy/wAR PEl54R8CalrlhHBJdWvlbEnUlDulRDkAg9GPegC54LgmtfAvh63uIpIZ4tMtkkjkUqyMIlBBB5BB 4xW5WX4a1KbWfCukapcLGs97ZQ3EixghQzoGIGSTjJ9TWpQAUUUUAFFFFABRRRQAUUUUAFFFFABR RRQAUUUUAFFFFAHB/BmCa1+FOj29xFJDPE9ykkcilWRhcSAgg8gg8YrvK4v4UalNrPw6sNUuFjWe 9uLu4kWMEKGe6lYgZJOMn1NdpQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAU UUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXn/wDwpL4ef9C9/wCTtx/8cr0CvnDxj8eN d1TXP7N8EDybXzVjgnFsJZ7puR8qMCArEjC7d3A5GSoAPT/+FJfDz/oXv/J24/8AjlH/AApL4ef9 C9/5O3H/AMcryD/hMvjn/wA+uuf+CJf/AIzR/wAJl8c/+fXXP/BEv/xmgD1//hSXw8/6F7/yduP/ AI5R/wAKS+Hn/Qvf+Ttx/wDHK5v4Ta/8SNV8VXUHjCHUk09bJ3jN1pot183egGGCLk7S3GfX0r2S gAooooAKKKKACiiigAooooAKKKKACiiigDn7z/koejf9gq//APRtpXQVz95/yUPRv+wVf/8Ao20r oKACiiigAooooAKKKKACiiigAr58+PWqahF4pttNjvrlLCXT43ktVmYRO3myclM4J+Vecdh6V9B1 85fH7/ke7H/sGR/+jZa+i4XipZgrrozGv8Be0X4Ef2xoOnan/wAJJ5P2y2juPL+w7tm9Q2M+YM4z 1xV7/hnb/qaf/Kf/APba9V8F/wDIieHv+wZbf+ilrcpV+IsyhVlGNTRN9I9/QFRhbY8O/wCGdv8A qaf/ACn/AP22j/hnb/qaf/Kf/wDba9xorL/WTNP+fv8A5LH/ACH7GHY+Xfgze3cHxJ021hupo7a5 83z4UkISXbDIV3AcNg8jPSvqKvlX4Pf8lU0b/tv/AOiJK+qq7eL0ljo2/lX5yJw/wnB+O/BWpeKP FXg7VLKe0jg0W9NxcrM7BnXfE2EwpBOIz1I6iu8ryv4p6tqWn+Ovh3b2WoXdtBd6mUuY4ZmRZl82 AYcA4YYYjB9T616pXyxuFFFFABRRRQAUUUUAFFFFABXP+L/F+n+CtJi1LUobmWGWcQKtsqs24qzZ +ZgMYU966CvKvj9/yIlj/wBhOP8A9FS135Zh4YjF06NTZvUmbai2jyr/AIXD48/6Dv8A5KQf/EVB e/FTxpqNhcWN1rPmW1zE0MqfZYRuRgQRkJkcE9K9c+AP/IiX3/YTk/8ARUVeq19Pjc3wWDxMqKwk XyvfRf8AtphGnKUb8x8ZeH/EmreF7977Rrv7NcyRGFn8tHyhIJGGBHVR+VdH/wALh8ef9B3/AMlI P/iK+qqKwq8TYWtLnq4SMn3bTf4xGqMltI8A+Hnxc1u58WQWPiO+mvLa8220CRW0K7ZnkQKzEBTt A3Z69ehr3+vlX/mu3/czf+3NfVVcvEuHo0qlKpRgo80b2WxVFtppnB/FnwVqXjzwra6Xpc9pDPFe pcM107KpUI64G1WOcuO3rXeV5X8fdW1LRvAtjcaXqF3YztqcaNJazNExXypTglSDjIBx7CvVK+aN gooooAKKKKACiiigAooooAKKKo6xrFhoGlTanqc/kWcG3zJNjNt3MFHCgnqR2qoxlOSjFXbAvV4r 48+L/iDwv401DRrGz0yS2tvL2NPFIXO6NWOSHA6se1Y2qfHrXYtWvI9NtdJmsEndbaWSCUM8YY7W PzjkjB6D6CsC8+K93qN091feE/CdzcyY3zT6cXdsDAyS+TwAPwr7DK+H8RRqe0xNJTi1tfroc86q asmav/C/vFX/AED9G/78y/8Axyu1+GHxP1rxr4ludN1K10+KGKzadWto3VtwdFx8zkYwx7V4Ho+p f2PqsN/9isr3yt3+j3sXmRPlSPmXIzjOR7gV2un/ABd1DSZ2n03wx4Ws5mXY0ltYNGxXIOMq4OMg ce1ezmGSUZUpU8NQV2tHe1mZwqO95M+n6K8H8N/HfUbnX7WHxDFplppTb/PngglLr8pK4AZurbR0 PWveK+Dx+W4jATUK631Xb7/66HVCalscv8RPDd54u8CalodhJBHdXXlbHnYhBtlRzkgE9FPatTw1 ps2jeFdI0u4aNp7Kyht5GjJKlkQKSMgHGR6Cub+L9/eaZ8LdZvLC7ntLqPyNk0Ehjdczxg4YcjIJ H41ueC55rrwL4euLiWSaeXTLZ5JJGLM7GJSSSeSSec1wFG5RRRQAUUUUAFFFFABRRRQAVU1TUItJ 0m81KdXaG0geeRYwCxVFLEDJAzgetW6w/Gn/ACIniH/sGXP/AKKataEFOrGL2bQnseD+JPjR4iud fupvD2pTWmlNs8iCe1hLr8oDZJDdW3HqetcN4g8Sat4ov0vtZu/tNzHEIVfy0TCAkgYUAdWP516B 8Af+R7vv+wZJ/wCjYq+ja+5xmZ4XJsQqFLDptJe9dJ/+kt+uupzRhKortnw7V7R9Yv8AQNVh1PTJ /IvIN3lybFbbuUqeGBHQntX2pRWEuMYzi4yw90/73/2o/q/mfKv/AAuHx5/0Hf8AyUg/+Ir6V8N+ ILTxRoFrrNjHNHbXO/Ys6gONrFTkAkdVPevI/wBon/mW/wDt6/8AaVdz8Hv+SV6N/wBt/wD0fJXL nEcNXyyljaVJU25NWVttd7JX+H5FU7qbi3c7iuD+E3grUvAfhW60vVJ7SaeW9e4VrV2ZQpRFwdyq c5Q9vSu8ryv4BatqWs+Bb641TULu+nXU5EWS6maVgvlRHALEnGSTj3NfJG56pRRRQAUUUUAFFFFA BRRRQAUUUUAeR/ED4xjQb+Kx8NvZXlzDLNDfpcwS/unQgAA5UHnf0z0H4+XeL/ifrXjXSYtN1K10 +KGKcTq1tG6tuCsuPmcjGGPaieCK5+N8kE8SSwy+IykkcihldTc4IIPBBHavpH/hC/Cv/Qs6N/4A Rf8AxNfdTnl+TRot0uaTV79f6/Q5Up1L6nxzRX2N/wAIX4V/6FnRv/ACL/4mj/hC/Cv/AELOjf8A gBF/8TW3+uND/n0/vQvq77nh3/C/vFX/AED9G/78y/8AxyvbfBnii18XeGrbUoJUeYKsd2scbIsc +xWdRu5IBbrkj3Nec/G7w9ouk+C7OfTdH0+zmbUERpLa2SNivlyHGVAOMgce1aPwB/5ES+/7Ccn/ AKKirzMxo4LEZYsZh6fI1K3/AA5pByU+Vu52vjv/AJJ54l/7BV1/6KavAP2cf+Sh6h/2CpP/AEbF Xv8A47/5J54l/wCwVdf+imrwD9nH/koeof8AYKk/9GxV8kbn0/RRRQAUUUUAFFFFABRRRQAUUUUA FFFFABRRRQAUUUUAFcHpXgrUrH4y654wlntDp9/ZLbxRq7eaGAhGWG3GP3bdCeo/DvK8r0LVtSm/ aN8T6XLqF2+nw6YjxWjTMYkbbb8qmcA/M3IHc+tAHqlFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFF FFABRRRQAVwfjvwVqXijxV4O1SyntI4NFvTcXKzOwZ13xNhMKQTiM9SOorvK8r+Keralp/jr4d29 lqF3bQXeplLmOGZkWZfNgGHAOGGGIwfU+tAHqlFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABR RRQAVwfxZ8Fal488K2ul6XPaQzxXqXDNdOyqVCOuBtVjnLjt613leV/H3VtS0bwLY3Gl6hd2M7an GjSWszRMV8qU4JUg4yAcewoA9UooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACuX+Inhu 88XeBNS0OwkgjurrytjzsQg2yo5yQCeintXUVw/xfv7zTPhbrN5YXc9pdR+RsmgkMbrmeMHDDkZB I/GgDpPDWmzaN4V0jS7ho2nsrKG3kaMkqWRApIyAcZHoK1Kw/Bc8114F8PXFxLJNPLpls8kkjFmd jEpJJPJJPOa3KACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA4v4UabNo3w6sNLuGjae yuLu3kaMkqWS6lUkZAOMj0FdpXB/Bmea6+FOj3FxLJNPK9y8kkjFmdjcSEkk8kk85rvKACiiigAo oooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACii igAoorn/ABt4n/4Q7whfa/8AY/tn2Xy/3Hm+Xu3SKn3sHGN2enagCTxpBNdeBfENvbxSTTy6ZcpH HGpZnYxMAABySTxivDP2brHS7jXNaurmOB9TtoojaF2+dEbeJGVf++AWxxuxkbjm/wD8NNf9Sj/5 Uv8A7VXmH/Cdf2T45/4Sbwjp39h7uZLHz/OhfJ+dMBVxG3Hy9jypGF2gH2fRXz5B+0zMtvEtx4Uj knCASPHflFZsckKYyQM9snHqaf8A8NNf9Sj/AOVL/wC1UAfQFFeX/Dj4wf8ACwPENxpP9hfYPJtG ufN+1+bnDou3Gxf7+c57V6hQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBz95/wAlD0b/ALBV/wD+ jbSugrn7z/koejf9gq//APRtpXQUAFFFFABRRRQAUUUUAFFFFABXzl8fv+R7sf8AsGR/+jZa+ja+ cvj9/wAj3Y/9gyP/ANGy19Hwr/yMV6Mxr/Ae4+C/+RE8Pf8AYMtv/RS1uVh+C/8AkRPD3/YMtv8A 0UtbleHiv48/V/max2QUUUVgM+Vfg9/yVTRv+2//AKIkr6qr5V+D3/JVNG/7b/8AoiSvqqvquL/9 +h/gX5yMMP8ACcf4w0Dw3q/iHwxea3q/2K+sLvzdOh+0xx/aZN8Z27WBL8qgwuD83uK7CvH/AIv/ APJQ/hj/ANhU/wDo23r2CvlTcKKKKACiiigAooooAKKKKACvKvj9/wAiJY/9hOP/ANFS16rXlXx+ /wCREsf+wnH/AOipa9XI/wDkY0fUzq/Aw+AP/IiX3/YTk/8ARUVeq15V8Af+REvv+wnJ/wCioq9V ozz/AJGNX1HS+BBRRRXlFnyr/wA12/7mb/25r6qr5V/5rt/3M3/tzX1VX1XE/wDzD/4DCh1OP+I+ geG/Efh63s/FGr/2XYpdrKk32mODdIEcBd0gIPBY468e1dhXj/7R3/JPNP8A+wrH/wCipa9gr5U3 CiiigAooooAKKKKACiiigArh/jD/AMkr1n/th/6PjruK4f4w/wDJK9Z/7Yf+j467sr/36j/jj+aJ n8LPOPgRoulax/b/APaemWV75X2fy/tMCybM+bnG4HGcD8hXsf8AwhfhX/oWdG/8AIv/AImvKv2d v+Zk/wC3X/2rXuNepxFXqwzKpGMmlp1f8qM6KXIjD/4Qvwr/ANCzo3/gBF/8TR/whfhX/oWdG/8A ACL/AOJrcorxPrVf+d/ezXlXY+TvipZWmnfEnVrWxtYba2j8nZDBGERcwoTgDgckn8a+sa+VfjD/ AMlU1n/th/6Ijr6qr6TiFt4LBN/y/pExpfFI5/xtpWj634QvtO1+/wDsGmTeX51z5yRbMSKy/M4K jLBRz61oaFa2dj4e0yz064+0WMFpFFbzbw/mRqgCtuHByADkcGuP+Nv/ACSHXf8At3/9KI66DwJ/ yTzw1/2CrX/0UtfKG50FFFFABRRRQAUUUUAFFFFABWH40/5ETxD/ANgy5/8ARTVuVh+NP+RE8Q/9 gy5/9FNW+F/jw9V+YpbHh3wB/wCR7vv+wZJ/6Nir6Nr5y+AP/I933/YMk/8ARsVfRte5xV/yMX6I yofAFFFFfOGx4d+0T/zLf/b1/wC0q7n4Pf8AJK9G/wC2/wD6Pkrhv2if+Zb/AO3r/wBpV3Pwe/5J Xo3/AG3/APR8lfVYv/knqH+N/nMwj/GZ3Fcf8ONA8N+HPD1xZ+F9X/tSxe7aV5vtMc+2QogK7owA OApx15967CvH/wBnH/knmof9hWT/ANFRV8qbnsFFFFABRRRQAUUUUAFFFFABRRRQB8q/812/7mb/ ANua+qq+Vf8Amu3/AHM3/tzX1VX1XE//ADD/AOAwodQooor5U3PKvj9/yIlj/wBhOP8A9FS0fAH/ AJES+/7Ccn/oqKj4/f8AIiWP/YTj/wDRUtHwB/5ES+/7Ccn/AKKir6r/AJp7/t/9TD/l8dr47/5J 54l/7BV1/wCimrwD9nH/AJKHqH/YKk/9GxV7/wCO/wDknniX/sFXX/opq8A/Zx/5KHqH/YKk/wDR sVfKm59P0UUUAFFFFABRRRQAUUUUAFFFFABRRXK/EjR7/X/AGp6ZpkHn3k/leXHvVd22VGPLEDoD 3rWhTjUqxpylyptK/a73+Qm7K51VFfHPiLwfr3hP7N/bdh9l+07vJ/fI+7bjd91jj7w6+tXtH+G/ i3X9Kh1PTNJ8+zn3eXJ9oiXdtYqeGYHqD2r6t8MYaNNVXi48r2dlZ/Pmt0MPbO9uU+uKKyvDFnPp 3hPRrG6j8u5trGCGVMg7XWNQRkcHkHpWrXyVSKjNxTvbqdCCuP07QPDdv8UNW1y21fzfENzaLFdW H2mNvKjAiw3lgb14ROScfN7iuwrx/wAPf8nQ+LP+wVH/AOg2tQB7BRRRQAUUUUAFFFFABRRRQAUU UUAFFFFABRRRQAUUUUAFcf4w0Dw3q/iHwxea3q/2K+sLvzdOh+0xx/aZN8Z27WBL8qgwuD83uK7C vH/i/wD8lD+GP/YVP/o23oA9gooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACuP8AiPoH hvxH4et7PxRq/wDZdil2sqTfaY4N0gRwF3SAg8Fjjrx7V2FeP/tHf8k80/8A7Csf/oqWgD2Ciiig AooooAKKKKACiiigAooooAKKKKACivAPiR/wn/8Awn+p/wBif8JN/Z37ryfsXn+V/qk3bdvH3s5x 3zXn9n4n8a6jdJa2Oua/c3MmdkMF3M7tgZOADk8An8K+ow3DM8RRjWjWjqk35XV9TCVaztY+v6K8 V+EH/Ca/8JZdf8JH/b/2P7C+z+0fO8vzPMjxjfxuxu98Zr2qvEzDB/U63suZS81sawlzK4Vz/jbS tH1vwhfadr9/9g0yby/OufOSLZiRWX5nBUZYKOfWugrz/wCNv/JIdd/7d/8A0ojriKOw0K1s7Hw9 plnp1x9osYLSKK3m3h/MjVAFbcODkAHI4NaFc/4E/wCSeeGv+wVa/wDopa6CgAooooAKKKKACiii gAooooAKKKKACiiigAooooAKKKKAOP8Ahha2dj4CtbPTrj7RYwXd7Fbzbw/mRrdShW3Dg5AByODX YV5/8Ev+SQ6F/wBvH/pRJXoFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRR RQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVXvrCz1Ozks7+0gu7WTG+GeMSI2CCMqeDggH8KsUU Ac//AMIJ4P8A+hU0P/wXQ/8AxNH/AAgng/8A6FTQ/wDwXQ//ABNdBXw5P4U1JfGMvhayEeo6klwb bFpu2tIv3gC4U4Ug5YgAbSc45oA+w/8AhBPB/wD0Kmh/+C6H/wCJo/4QTwf/ANCpof8A4Lof/ia+ eLH9nnxrd2cc80ulWUjZzBPcMXTBI5KIy89eCevrxXN+LfhX4r8GW8t5qNlHLp8bqhvbWQPHlhxk cOoz8uWUDOB3GQD6303w1oOjXDXGl6JptjOyFGktbVImK5BwSoBxkA49hWpXyB4O+FviTxRof/CR +HdQsRJaysFiE0kU6TJhgFOzaGOVIO7HIyQQcdx8N/iR4p0HxzF4M8ZzTyrLL9lBvMvNbzMSU+cA mRXLAZJIwVIYKOQD6HooooAK8n+N+qapDZ6Dodte/wBm6TrV2bXUdQKcQoSgCs2QApDOSMjcEIzj dn1ivJ/ilqWo694o0b4baXNBa/2vE899PcW6yr5IDEBQc/MPLdugO4R4ZeTQBy/jP4b2Hwr8OSeK fDHiXVbHU4JYkRZp4yLkFxmPAVd3TeQdwIQ5XuOo+IvjHxBaeAfDdlp/+heKfEfkwmFUaN4yyDzA hY/u2Dui/McjcccjcMPxD8FbLwbo0/ifwtq12mqaSjXif2isU8ZVFJbC+XgOBypIOCB0+8KfijxJ /wAJdf8Awd1wx+XJdagfNQLgCRZ4EfaMn5dytjJzjGeaANC+/Z5sNP0OS70TWNVbxDbRCW2cPGiP OmCNowCmSMA7/lyDk45sf8LavP8AhQ3/AAkX2yD/AISHzf7P3fZzt+0bs5xjbu8n95n7m7jH8Ne0 V8gf829f9zX/AO2lAHp9j+zzYahocd3resaqviG5iMty5eN0Sd8k7hgl8E4J3/NgnIzxc8HfEbUt P+GXiZvEVzG+veGXe2YTIzlmxshEjKcOTKGQsD0UEnncfZK+YL7/AJAfxr/7Ctv/AOlslAHT+GPg 1B440OHxT4w1bVX1fVf9KbyZIlAjb/V/wt1XBAGAoIXaNtdB8JdU1TSdc134e63e/aZtF2tp7Onz vbepIJAUBoiFJyN+Oi4XuPAn/JPPDX/YKtf/AEUtef8Ah7/k6HxZ/wBgqP8A9BtaAPQLz/koejf9 gq//APRtpXQVyevR6lL460RdLu7S2n/sy+LPdWzTqV8204CrIhBzjnPY8c8XPsfjD/oO6H/4Jpv/ AJKoA6Ciuf8AsfjD/oO6H/4Jpv8A5KrQ1OHWJfK/sm+sbXGfM+12b3G7pjG2VMd+uc5HTHIBoUVj 2Nt4kjvI2v8AVdKntRnfHBpkkTtwcYYzsBzj+E+nHWi+tvEkl5I1hqulQWpxsjn0ySV14GcsJ1B5 z/CPTnrQBsUVn6ZDrEXm/wBrX1jdZx5f2Sze329c53Svnt0xjB654z/sfjD/AKDuh/8Agmm/+SqA OgorP8nWP7H8r7dY/wBp/wDPx9jfyfvf88vN3fd4+/159qz/ALH4w/6Duh/+Cab/AOSqAOgr5y+P 3/I92P8A2DI//Rste+6nDrEvlf2TfWNrjPmfa7N7jd0xjbKmO/XOcjpjnzv4neGNT1Xwq1z4g8T6 bb2lg3mq0GmTopdvkUMBPJwSwG7YSMnHBIPs5Bio4bHwlJXT008/LqZ1Y80Trfh5qdlqfgHRXsrh JhBZxW0u3rHIiKGUjqCD+YII4INdPXxt4b8U6v4U1JL3Sbt4iGDSQliYpgM/K65wwwT7jOQQea9I 0z9oPWIvN/tbRLG6zjy/skj2+3rnO7fnt0xjB6549PMuGMWq7lhlzxd3uk163a/D8CIVo21PoGo5 54raCSeeVIoYlLySSMFVFAySSeAAO9fOX/C/fGH/AD56H/4DTf8Ax2ub8V/EjxH4xjSHULiOC1Vd rWtmGjikO7O5wWJY8LjJwMcAEnPPheFsfUqKNaPJHq7p/gmOVeKWhb+D3/JVNG/7b/8AoiSvqqvA vhD4WEk51rQvFNodShgCXVrLp87xw+YTgEiSMOcIeOVBHfCtXtupw6xL5X9k31ja4z5n2uze43dM Y2ypjv1znI6Y5XFGIjWx9o391Jaq3Vvr6/PpoFBWic/4w1/w3pHiHwxZ63pH22+v7vytOm+zRyfZ pN8Y3bmIKcshyuT8vsK7CvG/iBofiq78deALi4WPU4LXUw8kmnaZLGtuvmwkmQmSQYIGQflxtPXt 6ZfW3iSS8kaw1XSoLU42Rz6ZJK68DOWE6g85/hHpz1r5w2Niis/TIdYi83+1r6xus48v7JZvb7eu c7pXz26Yxg9c8Z/2Pxh/0HdD/wDBNN/8lUAdBRWf5Osf2P5X26x/tP8A5+Psb+T97/nl5u77vH3+ vPtWf9j8Yf8AQd0P/wAE03/yVQB0FFZ+pw6xL5X9k31ja4z5n2uze43dMY2ypjv1znI6Y5r2Nt4k jvI2v9V0qe1Gd8cGmSRO3BxhjOwHOP4T6cdaANiise+tvEkl5I1hqulQWpxsjn0ySV14GcsJ1B5z /CPTnrVjTIdYi83+1r6xus48v7JZvb7euc7pXz26Yxg9c8AGhXlXx+/5ESx/7Ccf/oqWu1+x+MP+ g7of/gmm/wDkqsb4geENT8WeAW0954LjV7eUXMRhQ28UrjcNu1mcj5GIGW+9gkgZFejlNaFHHUql R2SZFRXi0jD+AP8AyIl9/wBhOT/0VFXqtfKvhfxz4l+HlzLpRjFtA0oe4tbyzLNGzBMuF3IxbYBg FgDn3zXr178XvDt1BbSaZ4mtNPcrumivtIuLhgSBhf3bqARyDywPY8c+rnmU4t4uVanByjPVOKb/ ACIpVI8tmz0yivL7H4saPHeRtf8AjPSp7UZ3xwaDdxO3BxhjIwHOP4T6cdawPGXxrkt5pI/CupWl 1FKoCs+myK0OVIJ8x5BuYMAQPK24IyTg58yjk2PqzUFSkr9Wml97LdSKV7nCf812/wC5m/8Abmvq qvl34daHrPiv4g2mtyWk08Ed99su7ziKMSKwc/NtI3bip2AZIP8ACPmH0F9j8Yf9B3Q//BNN/wDJ VetxTKKq0qSd3GNnYzobNmf8R9f8N+HPD1veeKNI/tSxe7WJIfs0c+2Qo5DbZCAOAwz15967CvI/ jfo2var8OdOtIraTVdQTU0eX+zrJwNvlyjPl7nIAyoJJPPpnFd59j8Yf9B3Q/wDwTTf/ACVXyxud BRWfqcOsS+V/ZN9Y2uM+Z9rs3uN3TGNsqY79c5yOmOa9jbeJI7yNr/VdKntRnfHBpkkTtwcYYzsB zj+E+nHWgDYorHvrbxJJeSNYarpUFqcbI59MkldeBnLCdQec/wAI9OetWNMh1iLzf7WvrG6zjy/s lm9vt65zulfPbpjGD1zwAaFFc/8AY/GH/Qd0P/wTTf8AyVWh5Osf2P5X26x/tP8A5+Psb+T97/nl 5u77vH3+vPtQBoUVz/2Pxh/0HdD/APBNN/8AJVaGpw6xL5X9k31ja4z5n2uze43dMY2ypjv1znI6 Y5ANCuH+MP8AySvWf+2H/o+OugsbbxJHeRtf6rpU9qM744NMkiduDjDGdgOcfwn0461x/wAYYdY/ 4QPWZft1j/Zn7j/R/sb+d/rY/wDlr5u373P3OnHvXdlf+/Uf8cfzRM/hZy37O3/Myf8Abr/7Vr3G vDv2dv8AmZP+3X/2rXqP2Pxh/wBB3Q//AATTf/JVd3En/I0q/wDbv/pKIo/AjoKKz/J1j+x/K+3W P9p/8/H2N/J+9/zy83d93j7/AF59qz/sfjD/AKDuh/8Agmm/+Sq8M1PnX4w/8lU1n/th/wCiI6+q q+VfjD/yVTWf+2H/AKIjr6SsbbxJHeRtf6rpU9qM744NMkiduDjDGdgOcfwn04619VxB/uOC/wAH 6QMKXxSK/jbVdH0Twhfajr9h9v0yHy/OtvJSXfmRVX5XIU4YqefStDQrqzvvD2mXmnW/2exntIpb eHYE8uNkBVdo4GAQMDgVw/xf0rxJqfgTWYLCSC7tZPI2WEGnSSXLYljJw4kwcEFv9X0GPeug8AWe sWPg3SINWlg+TT7ZI4FtHgkgxGAVkLO25hwOAvIPHOB8qbnUUVz/ANj8Yf8AQd0P/wAE03/yVWh5 Osf2P5X26x/tP/n4+xv5P3v+eXm7vu8ff68+1AGhRXP/AGPxh/0HdD/8E03/AMlVoanDrEvlf2Tf WNrjPmfa7N7jd0xjbKmO/XOcjpjkA0KKx7G28SR3kbX+q6VPajO+ODTJInbg4wxnYDnH8J9OOtF9 beJJLyRrDVdKgtTjZHPpkkrrwM5YTqDzn+EenPWgDYorP0yHWIvN/ta+sbrOPL+yWb2+3rnO6V89 umMYPXPGf9j8Yf8AQd0P/wAE03/yVQB0FYfjT/kRPEP/AGDLn/0U1XPJ1j+x/K+3WP8Aaf8Az8fY 38n73/PLzd33ePv9efasHWdF8X6poWoaedb0NhdW0kGP7KljzuUr977Q23r12tj0PStsPJRrQk9k 1+YnseQfAH/ke77/ALBkn/o2Kvo2vkbwx4jv/h94rupLcQNKu6ynaa3d9qeYu5ljLRtu+TgMV9Dj t9H+FtW1DxBDFqVv4h0fUdM3MjrbaXLBJuA6Zedtpzg4K8j6g19JxVhqv1pYjl9xpa9P+AY0GuWx 1VFY99beJJLyRrDVdKgtTjZHPpkkrrwM5YTqDzn+EenPWpbI6nYwXM+u6np0sKLvEkFo1ssSgEsX LyuCMY54xg9e3yqV9EbnkP7RP/Mt/wDb1/7Srufg9/ySvRv+2/8A6Pkrw/4m+M5PFepWkC31pf2t irGO5t7GS1Ds+3cNryOSBtXn5ec8EYJ928B6Nq2j/DDStOWSC11IRGTNxA8ix75DJtZNyNuCtgjI wfXHP1uZU50MioUaqtLmbs9/tf5o54O9VtHZVx/w41/w34j8PXF54X0j+y7FLtonh+zRwbpAiEtt jJB4KjPXj2rQ+x+MP+g7of8A4Jpv/kqvO/gtofirTPAtzbqsejznU5XePVNMldnUxQhSo8yMgZDD POfbHPyR0HslFY9jbeJI7yNr/VdKntRnfHBpkkTtwcYYzsBzj+E+nHWi+tvEkl5I1hqulQWpxsjn 0ySV14GcsJ1B5z/CPTnrQBsUVn6ZDrEXm/2tfWN1nHl/ZLN7fb1zndK+e3TGMHrnjP8AsfjD/oO6 H/4Jpv8A5KoA6Cis/wAnWP7H8r7dY/2n/wA/H2N/J+9/zy83d93j7/Xn2rP+x+MP+g7of/gmm/8A kqgDoKKz9Th1iXyv7JvrG1xnzPtdm9xu6YxtlTHfrnOR0xzXsbbxJHeRtf6rpU9qM744NMkiduDj DGdgOcfwn0460AbFFY99beJJLyRrDVdKgtTjZHPpkkrrwM5YTqDzn+EenPWrGmQ6xF5v9rX1jdZx 5f2Sze329c53Svnt0xjB654APmX/AJrt/wBzN/7c19VV8la+b7w38Vbu51Boxd22qi7Z44dytlxK GEe/oQQdpcHnBYHmvpDw7rs3inwdDqGl6rYyXknDTNZMEicNko8Pm7gwU4/1nXDDIIB+t4mpzlSw 9aKvHlSv0Oei9WjpaK5/7H4w/wCg7of/AIJpv/kqtDU4dYl8r+yb6xtcZ8z7XZvcbumMbZUx365z kdMc/JHQedfH7/kRLH/sJx/+ipaPgD/yIl9/2E5P/RUVcZ8X/Fc14g8N3GrWGoTWlysspstOaFY3 CupUu075YbuQF7/eBBFdH8FrLxAfBM8mm6npVtbyX0jbLiza5fOxASSk6ben3SM9+jCvrqtKdLh9 KorNyur9mc6d6uh6L47/AOSeeJf+wVdf+imrwD9nH/koeof9gqT/ANGxV7f4oh1iL4eeK/7WvrG6 zpVz5f2Sze32/unzndK+e3TGMHrnjwT4BR6lL46vl0u7tLaf+zJCz3Vs06lfNi4CrIhBzjnPY8c8 fInQfVdFZ/k6x/Y/lfbrH+0/+fj7G/k/e/55ebu+7x9/rz7Vn/Y/GH/Qd0P/AME03/yVQB0FFZ+p w6xL5X9k31ja4z5n2uze43dMY2ypjv1znI6Y5r2Nt4kjvI2v9V0qe1Gd8cGmSRO3BxhjOwHOP4T6 cdaANiise+tvEkl5I1hqulQWpxsjn0ySV14GcsJ1B5z/AAj0561Y0yHWIvN/ta+sbrOPL+yWb2+3 rnO6V89umMYPXPABoUVz/wBj8Yf9B3Q//BNN/wDJVaHk6x/Y/lfbrH+0/wDn4+xv5P3v+eXm7vu8 ff68+1AGhRXP/Y/GH/Qd0P8A8E03/wAlVoanDrEvlf2TfWNrjPmfa7N7jd0xjbKmO/XOcjpjkA8a +MHxH1C31S48MaaLnT5rOeKVr62vGRpFMWdm1QCBlx/Efu9PTiv+Lqf9Tl/5NVB8U0vI/iRqy388 E90PJ3yQQmJG/cpjClmI4x/EfXjpX0zfW3iSS8kaw1XSoLU42Rz6ZJK68DOWE6g85/hHpz1r7mti 6WVYLDezpRlzxu797Rf43OZRc5O72Pl/UdF8f6x5f9p6Z4mvfKz5f2mCeTZnGcbgcZwPyFT2dl8S tOtUtbG18WW1tHnZDBHcoi5OTgDgckn8a+odMh1iLzf7WvrG6zjy/slm9vt65zulfPbpjGD1zxn/ AGPxh/0HdD/8E03/AMlVxviubjyOhG3boV7DzPm68vfiVp1q91fXXiy2to8b5p5LlEXJwMk8Dkgf jXsfwX8X3fiPQLjTr4TS3Ombd95PcGV5/MaRhnIyNoAHU/hV74ppeR/CDVlv54J7oeTvkghMSN/p CYwpZiOMfxH146V598CodYl/t/8Asm+sbXH2fzPtdm9xu/1uMbZUx365zkdMc9GJxFPMMmq4iVNR lGSSt/27+kmTFOFRK59A1x+na/4buPihq2h22keV4htrRZbq/wDs0a+bGRFhfMB3tw6cEY+X2FdB qcOsS+V/ZN9Y2uM+Z9rs3uN3TGNsqY79c5yOmOfL/DGieJLf9oTXtSv4t1rJp6o98mnyRQT/ACQY WMl2CsCBn5mzsbgZ+X4o6T2Cise+tvEkl5I1hqulQWpxsjn0ySV14GcsJ1B5z/CPTnrVjTIdYi83 +1r6xus48v7JZvb7euc7pXz26Yxg9c8AGhRXP/Y/GH/Qd0P/AME03/yVWh5Osf2P5X26x/tP/n4+ xv5P3v8Anl5u77vH3+vPtQBoUVz/ANj8Yf8AQd0P/wAE03/yVWhqcOsS+V/ZN9Y2uM+Z9rs3uN3T GNsqY79c5yOmOQDQorHsbbxJHeRtf6rpU9qM744NMkiduDjDGdgOcfwn0460X1t4kkvJGsNV0qC1 ONkc+mSSuvAzlhOoPOf4R6c9aANiis/TIdYi83+1r6xus48v7JZvb7euc7pXz26Yxg9c8Z/2Pxh/ 0HdD/wDBNN/8lUAdBRWf5Osf2P5X26x/tP8A5+Psb+T97/nl5u77vH3+vPtWf9j8Yf8AQd0P/wAE 03/yVQB0FFZ+pw6xL5X9k31ja4z5n2uze43dMY2ypjv1znI6Y5r2Nt4kjvI2v9V0qe1Gd8cGmSRO 3BxhjOwHOP4T6cdaANiise+tvEkl5I1hqulQWpxsjn0ySV14GcsJ1B5z/CPTnrVjTIdYi83+1r6x us48v7JZvb7euc7pXz26Yxg9c8AGhXH+MNf8N6R4h8MWet6R9tvr+78rTpvs0cn2aTfGN25iCnLI crk/L7CtD7H4w/6Duh/+Cab/AOSq8/8AiboniS/8TfDySGL7bdWmoO9xeWunyGCDMsJVnQOxVQBz lxnaeR2APYKK5/7H4w/6Duh/+Cab/wCSq0NTh1iXyv7JvrG1xnzPtdm9xu6YxtlTHfrnOR0xyAaF FY9jbeJI7yNr/VdKntRnfHBpkkTtwcYYzsBzj+E+nHWi+tvEkl5I1hqulQWpxsjn0ySV14GcsJ1B 5z/CPTnrQBsUVn6ZDrEXm/2tfWN1nHl/ZLN7fb1zndK+e3TGMHrnjP8AsfjD/oO6H/4Jpv8A5KoA 6Cis/wAnWP7H8r7dY/2n/wA/H2N/J+9/zy83d93j7/Xn2rP+x+MP+g7of/gmm/8AkqgDoKKz9Th1 iXyv7JvrG1xnzPtdm9xu6YxtlTHfrnOR0xzXsbbxJHeRtf6rpU9qM744NMkiduDjDGdgOcfwn046 0AbFFY99beJJLyRrDVdKgtTjZHPpkkrrwM5YTqDzn+EenPWrGmQ6xF5v9rX1jdZx5f2Sze329c53 Svnt0xjB654ANCiuf+x+MP8AoO6H/wCCab/5KrQ8nWP7H8r7dY/2n/z8fY38n73/ADy83d93j7/X n2oA0KK5/wCx+MP+g7of/gmm/wDkqtDU4dYl8r+yb6xtcZ8z7XZvcbumMbZUx365zkdMcgGhXH/E fX/Dfhzw9b3nijSP7UsXu1iSH7NHPtkKOQ22QgDgMM9efetixtvEkd5G1/qulT2ozvjg0ySJ24OM MZ2A5x/CfTjrXm/x40TxJrHhm3jsIv7QtRqEbpZ2enyPPHiKQFmcOQVyT/APvLzxyAewUVn6ZDrE Xm/2tfWN1nHl/ZLN7fb1zndK+e3TGMHrnjP+x+MP+g7of/gmm/8AkqgDoKKz/J1j+x/K+3WP9p/8 /H2N/J+9/wA8vN3fd4+/159qz/sfjD/oO6H/AOCab/5KoA6Cis/U4dYl8r+yb6xtcZ8z7XZvcbum MbZUx365zkdMc17G28SR3kbX+q6VPajO+ODTJInbg4wxnYDnH8J9OOtAGxRWPfW3iSS8kaw1XSoL U42Rz6ZJK68DOWE6g85/hHpz1qxpkOsReb/a19Y3WceX9ks3t9vXOd0r57dMYweueADQorn/ALH4 w/6Duh/+Cab/AOSq0PJ1j+x/K+3WP9p/8/H2N/J+9/zy83d93j7/AF59qAKfjDxF/wAIn4Vvdb+y /avs2z9z5mzdudU+9g4+9np2r5ufxL468TatqN5otz4jeFp2l+z2VxPKtursSqfLwABkDgdOleu/ FO28SR/DfVmv9V0qe1Hk744NMkidv3yYwxnYDnH8J9OOtcd8CodYl/t/+yb6xtcfZ/M+12b3G7/W 4xtlTHfrnOR0xz9dk7pYXK6uN5FKSlbXt7v+bOepeU1G5y3/ABdT/qcv/Jqsqz8MeNdOukurHQ9f trmPOyaC0mR1yMHBAyOCR+NfU9jbeJI7yNr/AFXSp7UZ3xwaZJE7cHGGM7Ac4/hPpx1ovrbxJJeS NYarpUFqcbI59MkldeBnLCdQec/wj0560o8Vzimo0Iq+4/YeZ82/8XU/6nL/AMmqNH8eeKvCfiqG bW7nWbr7Nu87Tr27lTduQhdwbOPvBhkdh9a+mtMh1iLzf7WvrG6zjy/slm9vt65zulfPbpjGD1zx 8vfFNLyP4kast/PBPdDyd8kEJiRv3KYwpZiOMfxH146V6WUZlTzWrPDVaMUuVvT1S/UzqQcFdM+s a5/xtquj6J4QvtR1+w+36ZD5fnW3kpLvzIqr8rkKcMVPPpWh5Osf2P5X26x/tP8A5+Psb+T97/nl 5u77vH3+vPtXn/xS0fxhf/DjVrb7XY6lv8n/AESw0iZZpMTIflPnv0xk/KeAenUfAHWegaFdWd94 e0y8063+z2M9pFLbw7AnlxsgKrtHAwCBgcCtCuT8P2WvReBfDNvZXNpp88OmQJcx39g8zBhEgxgS xlSCCCDn8Mc6ljbeJI7yNr/VdKntRnfHBpkkTtwcYYzsBzj+E+nHWgDYorHvrbxJJeSNYarpUFqc bI59MkldeBnLCdQec/wj0561Y0yHWIvN/ta+sbrOPL+yWb2+3rnO6V89umMYPXPABoUVz/2Pxh/0 HdD/APBNN/8AJVaHk6x/Y/lfbrH+0/8An4+xv5P3v+eXm7vu8ff68+1AGhRXP/Y/GH/Qd0P/AME0 3/yVWhqcOsS+V/ZN9Y2uM+Z9rs3uN3TGNsqY79c5yOmOQDQorHsbbxJHeRtf6rpU9qM744NMkidu DjDGdgOcfwn0460X1t4kkvJGsNV0qC1ONkc+mSSuvAzlhOoPOf4R6c9aANiis/TIdYi83+1r6xus 48v7JZvb7euc7pXz26Yxg9c8Z/2Pxh/0HdD/APBNN/8AJVAHQUVn+TrH9j+V9usf7T/5+Psb+T97 /nl5u77vH3+vPtWf9j8Yf9B3Q/8AwTTf/JVAHQUVn6nDrEvlf2TfWNrjPmfa7N7jd0xjbKmO/XOc jpjmvY23iSO8ja/1XSp7UZ3xwaZJE7cHGGM7Ac4/hPpx1oA2KKx7628SSXkjWGq6VBanGyOfTJJX XgZywnUHnP8ACPTnrVf7H4w/6Duh/wDgmm/+SqAM/wCGF1Z33gK1vNOt/s9jPd3stvDsCeXG11KV XaOBgEDA4FdhXB/BmCa1+FOj29xFJDPE9ykkcilWRhcSAgg8gg8YrvKACiiigAooooAKKKKACiii gAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAx/Fl9 caZ4N1y/s5PLurXT7iaF9oO11jYqcHg4IHWvCP2a/wCzv+Eh1zzf+Qn9kT7P97/U7/3v+z97yevP p3r6Pr5s8Z/CbxH4J8Sp4i8BpdzWkb+bElud89oxIGzbyZEO70b5dwYYGWAPpOqerQ2Nzo19Bqhj GnyW8iXRkk2KIipD5bI2jbnnIxXzRD8f/HWlIbC/tdNnu4HZJXu7V0l3BjkMqMoBHTG0dOec1Tvv EXxO+LcUljbWk82mTSgNBZ24itldFDbWlb8G2u55K4H3aANT9m+eZfHWp26yyCB9MZ3jDHazLLGF JHQkBmAPbcfWq/7RUEMPxGtXiijR5tMieVlUAu3mSLlvU7VUZPYAdq9f8EeBl+FvgrUriCKTVNae 3NxcpCWxO8asUhjGCcZJAOMksTjoo80+HPw58U+KPHP/AAl3i77dZ/ZbtLkm7iMc1zMpDKoVgNsY wvOMYAVe5UA+j6KKKACvO/iT4CvtduLTxP4Zu5LPxTpaYtmD4WdASfLOeAfmbBPB3FW4OV9EooA8 T1K2+MvjW3XQNV03TdB0y7cLd3trIpYRYO5SBMxIPTAAzwCQpauo8UfCmx1X4ZW3hDSbiS1GnuJ7 OSZt4eUB8+YcZwxkcnbjBIIGBtPolFAHh98/xv17Q5NAvNC0q3hvIha3F+ZYt+xsK7MBKw5Gc7U7 naAcV3H/AArWz/4VR/wgf9oT+T5WPtewbvM8zzd23+7v/hznbxuz81dxRQB4fYv8b9B0OPQLPQtK uIbOI2tvfiWLfsXKoygyqOBjG5Ow3AnNdp4L+G0Phr4c3nha8vJJ31JJTeyw4AVpYwjCPI6BQMEj k5OBnaO8ooA8P0fT/i/4Bs38OaHo+lazpNtK5tbuZkQlGO7GPNQjkkkEHBJAJGK7D4W+CNR8LWep arrt152u63KLm9RAuyJss20bRgtl2JI+XsOBk+gUUAc/ef8AJQ9G/wCwVf8A/o20roK5+8/5KHo3 /YKv/wD0baV0FABRRRQAUUUUAFFFFABRRRQAV8+fHrVNQi8U22mx31ylhLp8byWqzMInbzZOSmcE /KvOOw9K+g6jngiuYJIJ4klhlUpJHIoZXUjBBB4II7V6OV46OBxKryhzW6frsyJx5lY+T/Cfw51/ xdBcXVpavFaRQPJHPKu1Z3AIWOMnAJLDBOcLznnANr/hT3jz/oBf+TcH/wAXX1NBBFbQRwQRJFDE oSOONQqooGAABwAB2qSvbqcX4v2jdOEeXond2+aaM1h421PlX/hT3jz/AKAX/k3B/wDF1Je/CHxd YeHv7Tk053nWcxyWUJWWUJhdsi7CdwyWBHUYB5BJH1NRU/63Y1tXjG3o/wDNh9XifLvwZvbuD4k6 baw3U0dtc+b58KSEJLthkK7gOGweRnpX1FUFtZWll532W1hg8+VppfKjC+ZI3V2x1Y4GSeanrys4 zKOYYhVow5dEu999dl3t8i6cORWOD8d+NdS8L+KvB2l2UFpJBrV6be5aZGLIu+JcphgAcSHqD0Fd 5XB+O/BWpeKPFXg7VLKe0jg0W9NxcrM7BnXfE2EwpBOIz1I6iu8ryjQKKKKACiiigAooooAKKKKA CuK+J/i/UPBXhq21LTYbaWaW8WBluVZl2lHbPysDnKjvXa1U1DS9P1aBYNSsba8hVt6x3MKyKGwR nDAjOCefeujC1KdOtGdWPNFbruKSbWh8Z6Zpl7rGpQadp1u9xdztsjiTqT/IADJJPAAJPFR3tnPp 1/cWN1H5dzbStDKmQdrqSCMjg8g9K+u/DXgrQPCSSDSbBI5ZGctO/wA8u1jnZvPO0YUAf7IJyck+ ea18CP7Y17UdT/4STyftlzJceX9h3bN7FsZ8wZxnrivv6HFeFqVpKp7sEtG022/lexyOhJLTc8Aq 3Dpl7cabdajDbvJaWjRpcSryIy+due4BKkZ6ZwOpGfZv+Gdv+pp/8p//ANtrtfAPw0i8FQatBPqC apDqSxpJHJahF2qHBBBZgwIfp7e9bYrifAwpOVCXNLTS0lfVX1a7XFGhJvU8K+F/iC70Dx3p/wBl jhf+0JY7CXzVJ2xySpkrgj5uBjOR7V9Y1yOlfDTwto/iG51q201DPMyvHHIA0VswOcxLj5SSAc84 6LtHFddXx2e5jQx9eNWjFrTW/wDXTY6KUHFWZwfxZ8a6l4D8K2uqaXBaTTy3qW7LdIzKFKO2RtZT nKDv613lcH8WfBWpePPCtrpelz2kM8V6lwzXTsqlQjrgbVY5y47etd5XhmoUUUUAFFFFABRRRQAU UUUAFY3ivQYvE/hi+0eYuEuFBGyQRksrB1G4q2ASoBO08Z4rZrK8SeILTwvoF1rN9HNJbW2zesCg udzBRgEgdWHetsP7T20PZfFdW9b6fiJ2tqfNXhTxXrPwr8SX9rdadu3YjvLKUhGLLkoyuAcfeJBG Qwb6EfQemfEPwnqemwXqa9p9uJl3eTdXKRSxnurKTkEH8D1BIwa+a/GfjO+8Xatcyzuj2gnY2nmW sSTRw7mKIXVdxADdNxGeeTzXMV+kYvIaeYxjWrrkqaX5db6ef9dLs441XDRbH2N/wmnhX/oZtG/8 D4v/AIqsrxF8TvDGg6NNfQ6pZajOPlitbO5SR5HPQHaTtX1Y9Pc4B+TqK46fB+GjJOVRtdtNSniH 2Oxb+0vil8R5LiDTv3l5KrywxSbVihUKuWkIOMKBltpyTwpyFr6xr5V+H3xDufCGq26XB/4k/wA3 2mK2tIfNm+V9mXIDNhmzy3AyBxxX1VXkcVRq06lKk4pU4q0bNvsnf0sv82aULNN9Tl/iJ4kvPCPg TUtcsI4JLq18rYk6kod0qIcgEHox71qeGtSm1nwrpGqXCxrPe2UNxIsYIUM6BiBkk4yfU1l/ETw3 eeLvAmpaHYSQR3V15Wx52IQbZUc5IBPRT2rU8NabNo3hXSNLuGjaeysobeRoySpZECkjIBxkegr5 Q3NSiiigAooooAKKKKACiiigAqpqmoRaTpN5qU6u0NpA88ixgFiqKWIGSBnA9at1R1rTv7Y0HUdM 83yftltJb+Zt3bN6lc4yM4z0zV0+XnXPtfX0Bnyr8QfFcPi7xVcahaQ+VZnb5Ikt445fuIrb2XJb lTjcxwOmOlcrXsy/s/3sfiGzhfV0n0hlL3NwsflyqQfuKhLDLA8NnAw2RwA3a6n8EfCGoyQNCt7Y RwxeWI7SVcN8zNuYurMzfNjJPQAdq/SI8QZZhIU6NKTcbdFtbvs7v/gs4/ZTk22fMlFfRv8AwoHw r/0ENZ/7/Rf/AButLQfg14a0DWItShn1C5eNZEMN08bxOroyMGUIMjDHjNE+K8Aotxu32sCoSPm7 SdXvNDv1vrAwrcpjY8tvHNsIIIZQ6kBgQMEcj1r6/wDDfiC08UaBa6zYxzR21zv2LOoDjaxU5AJH VT3ryfxV8CVuNcs5PDUqWunTsEuopnL/AGYAcuuTlwcY2k53Ec7SdvqPg/w7/wAIn4VstE+1favs 2/8AfeXs3bnZ/u5OPvY69q8LiLH4HHUKdWi/3l9ra21vf0aVtfTRmlGMotp7G5XB/CbxrqXjzwrd apqkFpDPFevbqtqjKpUIjZO5mOcue/pXeVwfwm8Fal4D8K3Wl6pPaTTy3r3CtauzKFKIuDuVTnKH t6V8idB3lFFFABRRRQAUUUUAFFFFABRRRQB8+fG3xL4f1W8t7PT4ra61K1aa2urhopUltyjrhQfl VhnzByGA5xjOT5Xp+qahpM7T6bfXNnMy7GktpmjYrkHGVIOMgce1ezeKPgfqWpeKH1Cx1WF4NRvp ZrnzIthtUdi+QNx8zuP4edvYkr2umfCHwjaeHoNLvdOS/lRvNlu3LRyyPjB+ZSCF9EzjoTk8n9Bw +c5bgMFToxk5rqt2u+9lvsvn5nI6c5Sb2PnX/hNPFX/Qzaz/AOB8v/xVMn8XeJbmCSCfxDq0sMql JI5L2RldSMEEFsEEdq+kf+FPeA/+gF/5Nz//ABdH/CnvAf8A0Av/ACbn/wDi6S4mytaqi/8AwGP+ Yexn3PlmCRYp45HhSZEYM0UhIVwD907SDg9OCD7ivrT4c6rpOq+CNPOjpDFFbxJDPDBG6JFNsVnU buTy2d2TnOck5NeeePvgm1xPPqvhQIHkZS2mcIoJJ3GNiQAOh2HAHzYPRa7/AOHPg2XwR4afTZ7x Lqaac3EjRoVVGKIpUZOWAK9cDOegrjz/ADHBY/BQnTn71/h/O68uj+65VKEoysy947/5J54l/wCw Vdf+imrwD9nH/koeof8AYKk/9GxV7/47/wCSeeJf+wVdf+imrwD9nH/koeof9gqT/wBGxV8WdJ9P 0UUUAFFFFABRRRQAUUUUAFFFFAHyr8Yf+Sqaz/2w/wDREdfVVfKvxh/5KprP/bD/ANER19VV9VxB /uOC/wAH6QMKXxSCiiivlTc4f4w/8kr1n/th/wCj464b9nb/AJmT/t1/9q13Pxh/5JXrP/bD/wBH x1w37O3/ADMn/br/AO1a+qwn/JPV/wDGvzgYS/jI9xrg9K8a6lffGXXPB8sFoNPsLJbiKRUbzSxE Jwx3Yx+8boB0H495XB6V4K1Kx+MuueMJZ7Q6ff2S28Uau3mhgIRlhtxj923QnqPw+VNzvKKKKACi iigAooooAKKKKACiiigAooooAKKKKACiiigArg/HfjXUvC/irwdpdlBaSQa1em3uWmRiyLviXKYY AHEh6g9BXeVwfjvwVqXijxV4O1SyntI4NFvTcXKzOwZ13xNhMKQTiM9SOooA7yiiigAooooAKKKK ACiiigAooooAKKKKACiiigAooooAK4P4s+NdS8B+FbXVNLgtJp5b1LdlukZlClHbI2spzlB39a7y uD+LPgrUvHnhW10vS57SGeK9S4Zrp2VSoR1wNqsc5cdvWgDvKKKKACiiigAooooAKKKKACiiigDh /jD/AMkr1n/th/6Pjrhv2dv+Zk/7df8A2rXc/GH/AJJXrP8A2w/9Hx1w37O3/Myf9uv/ALVr6rCf 8k9X/wAa/OBhL+Mj3GiiivlTcK+VfjD/AMlU1n/th/6Ijr6qr5V+MP8AyVTWf+2H/oiOvquEP9+n /gf5xMMR8J9VVy/xE8SXnhHwJqWuWEcEl1a+VsSdSUO6VEOQCD0Y966iuX+Inhu88XeBNS0Owkgj urrytjzsQg2yo5yQCeintXypuanhrUptZ8K6Rqlwsaz3tlDcSLGCFDOgYgZJOMn1NalZfhrTZtG8 K6Rpdw0bT2VlDbyNGSVLIgUkZAOMj0FalABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUU AcX8KNSm1n4dWGqXCxrPe3F3cSLGCFDPdSsQMknGT6mu0ri/hRps2jfDqw0u4aNp7K4u7eRoySpZ LqVSRkA4yPQV2lABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFF FFABRRRQAUUUUAFFFFABRRRQAUUUUAFef/8AC7fh5/0MP/klcf8AxuvQK8f/AOGcfB//AEEtc/7/ AMP/AMaoA6D/AIXb8PP+hh/8krj/AON0f8Lt+Hn/AEMP/klcf/G65/8A4Zx8H/8AQS1z/v8Aw/8A xquQ+IHwETQdDudZ8OahPcQ2cRluLW8K79i5LurgKOBg7SOzYJOFoA9n8N/ETwr4u1GSw0PVftd1 HEZmT7PLHhAQCcuoHVh+ddRXifwF0bwrMl34i0V9Sh1BEayubO7uopgisyurjainB2jBIHIcYOM1 7ZQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBz95/yUPRv+wVf/8Ao20roK5+8/5KHo3/AGCr/wD9 G2ldBQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAHlfxT1bUtP8dfDu3stQu7aC71Mp cxwzMizL5sAw4BwwwxGD6n1r1SuP8YaB4b1fxD4YvNb1f7FfWF35unQ/aY4/tMm+M7drAl+VQYXB +b3FdhQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAHlfx91bUtG8C2NxpeoXdjO2pxo 0lrM0TFfKlOCVIOMgHHsK9Urj/iPoHhvxH4et7PxRq/9l2KXaypN9pjg3SBHAXdICDwWOOvHtXYU AFFFFABRRRQAUUUUAFFFFABVHWNHsNf0qbTNTg8+zn2+ZHvZd21gw5Ug9QO9XqKqMpQkpRdmgOD8 PfCTwz4e1ybVY4HuZROJbNJ2JW0GOgGfmIJJDNkjC45BY43jD4zf8In4qvdE/sD7V9m2fvvtmzdu RX+7sOPvY69q9VrldY+G/hLX9Vm1PU9J8+8n2+ZJ9olXdtUKOFYDoB2r1cLjqNWu6mZ81RWsteun mul/nqZyi0rQ0PmPwf4i/wCET8VWWt/ZftX2bf8AufM2btyMn3sHH3s9O1e/+APir/wnOvT6Z/Yv 2LyrZrjzPtXmZwyrjGwf3uue1X/+FPeA/wDoBf8Ak3P/APF1q+H/AAH4a8L3732jab9muZIjCz+f I+UJBIwzEdVH5V62bZvlePg5+zl7S1k3svul5voRTpzj10OfvPgx4Ru/EMepfZXitdr+dYROyxSO TkMCDlAMn5VIHC4wAQ3odFFfNV8XXxCiq03Ll2ubKKWxw/xfv7zTPhbrN5YXc9pdR+RsmgkMbrme MHDDkZBI/GtzwXPNdeBfD1xcSyTTy6ZbPJJIxZnYxKSSTySTzmo/G2laPrfhC+07X7/7Bpk3l+dc +ckWzEisvzOCoywUc+taGhWtnY+HtMs9OuPtFjBaRRW828P5kaoArbhwcgA5HBrnGaFFFFABRRRQ AUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAV5X8AtW1LWfAt9capqF3fTrqciLJdTNKwXyojgFiTjJ Jx7mvVK4/wCHGgeG/Dnh64s/C+r/ANqWL3bSvN9pjn2yFEBXdGABwFOOvPvQB2FFFFABRRRQAUUU UAFFFFABRRRQAUUUUAFFFFABRRRQBz/jv/knniX/ALBV1/6KavAP2cf+Sh6h/wBgqT/0bFXv/jv/ AJJ54l/7BV1/6KavAP2cf+Sh6h/2CpP/AEbFQB9P0UUUAFFFFABRRRQAUUUUAFFFFAHyr8Yf+Sqa z/2w/wDREdfVVfKvxh/5KprP/bD/ANER19VV9VxB/uOC/wAH6QMKXxSCiiivlTc4f4w/8kr1n/th /wCj464b9nb/AJmT/t1/9q13Pxh/5JXrP/bD/wBHx1w37O3/ADMn/br/AO1a+qwn/JPV/wDGvzgY S/jI9xryvQtW1Kb9o3xPpcuoXb6fDpiPFaNMxiRttvyqZwD8zcgdz616pXH6doHhu3+KGra5bav5 viG5tFiurD7TG3lRgRYbywN68InJOPm9xXypudhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQA UUUUAFeV/FPVtS0/x18O7ey1C7toLvUylzHDMyLMvmwDDgHDDDEYPqfWvVK4/wAYaB4b1fxD4YvN b1f7FfWF35unQ/aY4/tMm+M7drAl+VQYXB+b3FAHYUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUU UAFFFFABXlfx91bUtG8C2NxpeoXdjO2pxo0lrM0TFfKlOCVIOMgHHsK9Urj/AIj6B4b8R+Hrez8U av8A2XYpdrKk32mODdIEcBd0gIPBY468e1AHYUUUUAFFFFABRRRQAUUUUAFFFFAHD/GH/kles/8A bD/0fHXDfs7f8zJ/26/+1a7n4w/8kr1n/th/6Pjrhv2dv+Zk/wC3X/2rX1WE/wCSer/41+cDCX8Z HuNFFFfKm4V8q/GH/kqms/8AbD/0RHX1VXyr8Yf+Sqaz/wBsP/REdfVcIf79P/A/ziYYj4T6qrh/ i/f3mmfC3Wbywu57S6j8jZNBIY3XM8YOGHIyCR+NdxXP+NtK0fW/CF9p2v3/ANg0yby/OufOSLZi RWX5nBUZYKOfWvlTck8FzzXXgXw9cXEsk08umWzySSMWZ2MSkkk8kk85rcrP0K1s7Hw9plnp1x9o sYLSKK3m3h/MjVAFbcODkAHI4NaFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAcH8G Z5rr4U6PcXEsk08r3LySSMWZ2NxISSTySTzmu8rj/hha2dj4CtbPTrj7RYwXd7Fbzbw/mRrdShW3 Dg5AByODXYUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUA FFFFABRRRQAUUUUAFFFFABRRRQAUUV8wf8M4+MP+glof/f8Am/8AjVAH0/WP4n8T6X4R0ObV9Xn8 q3j4VV5eVz0RB3Y4P5EkgAkfPH/DOPjD/oJaH/3/AJv/AI1UkH7N/ipriJbjVdGjgLgSPHJK7Kue SFKAE47ZGfUUASfs3fbP+Ey1bZ5/2H+z/wB7tz5fmeYmzd23Y8zGecbsd6+l65PwD4B034f6NJZW UslxPcOslzcyooZ2CgYGBkIDkhSTjceTmusoAKKKKACiiigAooooAKKKKACiiigAooooA5+8/wCS h6N/2Cr/AP8ARtpXQVz95/yUPRv+wVf/APo20roKACiiigAooooAKKKKACiiigAooooAKKKKACii igAooooA8f8Ai/8A8lD+GP8A2FT/AOjbevYK4/xhr/hvSPEPhiz1vSPtt9f3fladN9mjk+zSb4xu 3MQU5ZDlcn5fYV2FABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAeP8A7R3/ACTzT/8A sKx/+ipa9grj/iPr/hvw54et7zxRpH9qWL3axJD9mjn2yFHIbbIQBwGGevPvXYUAFFFFABRRRQAU UUUAFFFFABRRRQAUUUUAFFFFABRRRQB5/wDG3/kkOu/9u/8A6UR10HgT/knnhr/sFWv/AKKWjxtq uj6J4QvtR1+w+36ZD5fnW3kpLvzIqr8rkKcMVPPpWhoV1Z33h7TLzTrf7PYz2kUtvDsCeXGyAqu0 cDAIGBwKANCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK8f/Zx/5J5qH/YVk/8ARUVe wVx/w41/w34j8PXF54X0j+y7FLtonh+zRwbpAiEttjJB4KjPXj2oA7CiiigAooooAKKKKACiiigA ooooAKKKKACiiigAooooA5/x3/yTzxL/ANgq6/8ARTV4B+zj/wAlD1D/ALBUn/o2Kvf/AB3/AMk8 8S/9gq6/9FNXgH7OP/JQ9Q/7BUn/AKNioA+n6KKKACiiigAooooAKKKKACiiigD5V+MP/JVNZ/7Y f+iI6+qq+VfjD/yVTWf+2H/oiOvqqvquIP8AccF/g/SBhS+KQUUUV8qbnD/GH/kles/9sP8A0fHX Dfs7f8zJ/wBuv/tWu5+MP/JK9Z/7Yf8Ao+OuG/Z2/wCZk/7df/atfVYT/knq/wDjX5wMJfxke414 /wCHv+TofFn/AGCo/wD0G1r2CuP07X/Ddx8UNW0O20jyvENtaLLdX/2aNfNjIiwvmA724dOCMfL7 CvlTc7CiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK8f+L//ACUP4Y/9hU/+jbevYK4/ xhr/AIb0jxD4Ys9b0j7bfX935WnTfZo5Ps0m+MbtzEFOWQ5XJ+X2FAHYUUUUAFFFFABRRRQAUUUU AFFFFABRRRQAUUUUAFFFFABXj/7R3/JPNP8A+wrH/wCipa9grj/iPr/hvw54et7zxRpH9qWL3axJ D9mjn2yFHIbbIQBwGGevPvQB2FFFFABRRRQAUUUUAFFFFABRRRQBw/xh/wCSV6z/ANsP/R8dcN+z t/zMn/br/wC1a7n4w/8AJK9Z/wC2H/o+OuG/Z2/5mT/t1/8AatfVYT/knq/+NfnAwl/GR7jRRRXy puFfKvxh/wCSqaz/ANsP/REdfVVfKvxh/wCSqaz/ANsP/REdfVcIf79P/A/ziYYj4T6qrz/42/8A JIdd/wC3f/0ojr0Cuf8AG2q6PonhC+1HX7D7fpkPl+dbeSku/MiqvyuQpwxU8+lfKm4eBP8Aknnh r/sFWv8A6KWugrP0K6s77w9pl5p1v9nsZ7SKW3h2BPLjZAVXaOBgEDA4FaFABRRRQAUUUUAFFFFA BRRRQAUUUUAFFFFABRRRQAUUUUAef/BL/kkOhf8Abx/6USV6BXH/AAwurO+8BWt5p1v9nsZ7u9lt 4dgTy42upSq7RwMAgYHArsKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiii gAooooAKKKKACiiigAooooAKKKKACiiigAooooAK8f8AiR8cbfwrqMujaBbQahqUXE80rEwwOCMp hcF2xuBwRtOOSQVHpniXUptG8K6vqlusbT2VlNcRrICVLIhYA4IOMj1FfPHwI8L2Pi3xLrOsa9HH qRtEU+Vdp5ollmLZkbccMQEbhgcl88ECgCvD8RfjLrKHUNMh1KSzndmiNpoyyRAbiNqt5bEgEEck njk5qxpvx28b+Gr9rHxPp0d68blporqA2lwoKDao2gBR0blCSCeeRj6brn/GHg/S/Geh3Gn6hbQN M0TpbXTxbntnOMOpyCOQpIBG7GDxQBY8MeJ9L8XaHDq+kT+bbycMrcPE46o47MMj8wQSCCdivnD9 m7WbxPEOraHv3WMtp9s2MSdkiOiZUZwMh+eMnavPFfR9ABRRRQAUUUUAFFFFABRRRQAUUUUAFFFF AHP3n/JQ9G/7BV//AOjbSugrn7z/AJKHo3/YKv8A/wBG2ldBQAUUUUAFFFFABRRRQAUUUUAFFFFA BRRRQAUUUUAFFFFAHlfxT0nUtQ8dfDu4stPu7mC01MvcyQws6wr5sBy5AwowpOT6H0r1SuD8d+Nd S8L+KvB2l2UFpJBrV6be5aZGLIu+JcphgAcSHqD0Fd5QAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQ AUUUUAFFFFAHlfx90nUtZ8C2Nvpen3d9Oupxu0drC0rBfKlGSFBOMkDPuK9Urg/iz411LwH4VtdU 0uC0mnlvUt2W6RmUKUdsjaynOUHf1rvKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA 4f4v2F5qfwt1mzsLSe7upPI2QwRmR2xPGThRycAE/hW54LgmtfAvh63uIpIZ4tMtkkjkUqyMIlBB B5BB4xVP4ieJLzwj4E1LXLCOCS6tfK2JOpKHdKiHIBB6Me9anhrUptZ8K6Rqlwsaz3tlDcSLGCFD OgYgZJOMn1NAGpRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFeV/ALSdS0bwLfW+qafd 2M7anI6x3ULRMV8qIZAYA4yCM+xr1SuD+E3jXUvHnhW61TVILSGeK9e3VbVGVSoRGydzMc5c9/Sg DvKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigDn/Hf/JPPEv/AGCrr/0U1eAfs4/8lD1D /sFSf+jYq9/8d/8AJPPEv/YKuv8A0U1eAfs4/wDJQ9Q/7BUn/o2KgD6fooooAKKKKACiiigAoooo AKKKKAPlX4w/8lU1n/th/wCiI6+nNG1a017RrTVbF91tdRCRMkErnqpwSAwOQRnggivPPjH4Bl8S 6bHrWlW7zatZrseNXOZYBuJCr3YE5AGCQWHJ2ivPPhB8QP8AhGdVGi6jLDHo97KWM0ny/Z5SuA2c fdO1VOeBwcgA5+0r0VmuU050PjoqzXXZJ/fa6+7c5k/Z1HfqfSlFYf8AwmnhX/oZtG/8D4v/AIqj /hNPCv8A0M2jf+B8X/xVfJfVa/8AI/uZ0cy7nP8Axknii+F+qpJKiPK0KRqzAF281GwPU4Vjj0BP auG/Z4niWfxDAZUEzrbusZYbmVTICQOpALLk9sj1riviL4yu/H3ihILSLzLG2laDT4oUJeXcwG/p uLPhcLjjgYzkn3z4eeCIvA/h42jSJPf3DCW6nVQAWxgIpxkqvOM9yxwM4H1WJpLLcleGrP36rvbt t+VlfzdvMwT56nMtkddXlehaTqUP7RvifVJdPu00+bTESK7aFhE7bbfhXxgn5W4B7H0r1SuD0rxr qV98Zdc8HywWg0+wsluIpFRvNLEQnDHdjH7xugHQfj8cdB3lFFFABRRRQAUUUUAFFFFABRRRQAUU UUAFFFFABRRRQAV5X8U9J1LUPHXw7uLLT7u5gtNTL3MkMLOsK+bAcuQMKMKTk+h9K9Urg/HfjXUv C/irwdpdlBaSQa1em3uWmRiyLviXKYYAHEh6g9BQB3lFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFF FFABRRRQAV5X8fdJ1LWfAtjb6Xp93fTrqcbtHawtKwXypRkhQTjJAz7ivVK4P4s+NdS8B+FbXVNL gtJp5b1LdlukZlClHbI2spzlB39aAO8ooooAKKKKACiiigAooooAKKKKAOK+LcEtx8L9aSGJ5HCx OVRSSFWVGY8dgAST2AJryr4E+JLLSfEN9pN46RHU1jEErtgGRC2I+mMsHOMkcqByWFfQ08EVzBJB PEksMqlJI5FDK6kYIIPBBHavk/x1oEXhDxfKNI1O2kgE7SWxtLkGW0ZW/wBW4DFlZDgAnrjPXIH1 /D7pYvCVctno5ap/d+TSfnqc9W8ZKaPrSivKvCPxo0Gfw3bf8JLqX2bVo8pNi1crJjo42AjkYz05 zgAYrd/4XD4D/wCg7/5KT/8AxFeFVyjHU5uHspO3VRbXydjVVItXudxXyd8SLyDxB8TdTm0iT7dH PLFDCYAW81xGiYXH3vmBAx17ZzXpfxD+MWnSeHhZ+EdTd725YpLcLA6GGPHO0sAQxOACAcDd0ODX P/BTw1pVxrMesanfaZJcruFhp7Tq05kXkylM5G0BsAgn+LjCk/RZLhp5XQqZhiItO1lG2vfVfL7r sxqSU2oI+hq4f4v2F5qfwt1mzsLSe7upPI2QwRmR2xPGThRycAE/hXcVy/xE8SXnhHwJqWuWEcEl 1a+VsSdSUO6VEOQCD0Y96+LOkueC4JrXwL4et7iKSGeLTLZJI5FKsjCJQQQeQQeMVuVl+GtSm1nw rpGqXCxrPe2UNxIsYIUM6BiBkk4yfU1qUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQ BwfwZgmtfhTo9vcRSQzxPcpJHIpVkYXEgIIPIIPGK7yuL+FGpTaz8OrDVLhY1nvbi7uJFjBChnup WIGSTjJ9TXaUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUU AFFFFABRRRQAUUUUAFFFFABRRRQBT1bTYdZ0a+0u4aRYL23kt5GjIDBXUqSMgjOD6GvlzwJ4ruPg 7451fTNctp5bVswXUduo3F0JMcqbwpZSCccrlZN3OAK+r68nuW+Gvxtums0lnfVraJyk0UbwzJCs oGdxUoykkEBskBzwpJwAdhY/EfwVqFnHdQ+KNKSN84E9ysLjBI5RyGHTuOevSuP8e/G7w/omnXdj oN7/AGjq7xMkM1pteGByBtcucq2N2cKG5Uqdtc3P+zNC1xK1v4rkjgLkxpJYB2Vc8AsJACcd8DPo K2NA/Z18Oae6y61qF3qzq5PlqPs8TKVwAwUl8g5OQ47cdcgGP+zl4UmhTUPFdwJESZDZWqnIDruD SPyORuVVBB6hwRwK98qOCCG1t4re3ijhgiQJHHGoVUUDAAA4AA4xUlABRRRQAUUUUAFFFFABRRRQ AUUUUAFFFFAHP3n/ACUPRv8AsFX/AP6NtK6CufvP+Sh6N/2Cr/8A9G2ldBQAUUUUAFFFFABRRRQA UUUUAFFFFABRRRQAUUUUAFFFFAHB+O/BWpeKPFXg7VLKe0jg0W9NxcrM7BnXfE2EwpBOIz1I6iu8 ryv4p6tqWn+Ovh3b2WoXdtBd6mUuY4ZmRZl82AYcA4YYYjB9T616pQAUUUUAFFFFABRRRQAUUUUA FFFFABRRRQAUUUUAFFFFAHB/FnwVqXjzwra6Xpc9pDPFepcM107KpUI64G1WOcuO3rXeV5X8fdW1 LRvAtjcaXqF3YztqcaNJazNExXypTglSDjIBx7CvVKACiiigAooooAKKKKACiiigAooooAKKKKAC iiigAooooA5f4ieG7zxd4E1LQ7CSCO6uvK2POxCDbKjnJAJ6Ke1anhrTZtG8K6Rpdw0bT2VlDbyN GSVLIgUkZAOMj0Fc38X7+80z4W6zeWF3PaXUfkbJoJDG65njBww5GQSPxrc8FzzXXgXw9cXEsk08 umWzySSMWZ2MSkkk8kk85oA3KKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigArg/hN4K1L wH4VutL1Se0mnlvXuFa1dmUKURcHcqnOUPb0rvK8r+AWralrPgW+uNU1C7vp11ORFkupmlYL5URw CxJxkk49zQB6pRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAc/wCO/wDknniX/sFXX/op q8A/Zx/5KHqH/YKk/wDRsVe/+O/+SeeJf+wVdf8Aopq8A/Zx/wCSh6h/2CpP/RsVAH0/RRRQAUUU UAFFFFABRRRQAUUUUAfOvxs8X6hea9d+FJIbYWFlPDPHIqt5pYwg4J3Yx+8bsOgryeu4+MP/ACVT Wf8Ath/6Ijr0D4QfDS0OlDxFrtrDdfbYittZ3NuHVI93+sIcfeO35ccbTnJ3cfqFHF4fK8qpVWt4 x0XVtJv/ADOJxc5tHg9FfY3/AAhfhX/oWdG/8AIv/iaP+EL8K/8AQs6N/wCAEX/xNef/AK40P+fT +9FfV33Pjmvob4C+ILvUdAvdGmjhW20rZ5DIpDt5rSs24k4PI4wB+Ncx8Zfh3Fo7/wDCS6REkVhK yRXFpDCFW3bGA6hRgKcAHP8AERyd2Be/Z4kYT+IYxC5Rlt2MoI2qQZMKec5OSRgEfKckcZ3zfE0M wyaWIh0s/R3Sf4NoVOLhUsz3WuD0rwVqVj8Zdc8YSz2h0+/slt4o1dvNDAQjLDbjH7tuhPUfh3le V6Fq2pTftG+J9Ll1C7fT4dMR4rRpmMSNtt+VTOAfmbkDufWvzg7D1SiiigAooooAKKKKACiiigAo oooAKKKKACiiigAooooAK4Px34K1LxR4q8HapZT2kcGi3puLlZnYM674mwmFIJxGepHUV3leV/FP VtS0/wAdfDu3stQu7aC71MpcxwzMizL5sAw4BwwwxGD6n1oA9UooooAKKKKACiiigAooooAKKKKA CiiigAooooAKKKKACuD+LPgrUvHnhW10vS57SGeK9S4Zrp2VSoR1wNqsc5cdvWu8ryv4+6tqWjeB bG40vULuxnbU40aS1maJivlSnBKkHGQDj2FAHqlFFFABRRRQAUUUUAFFFFABRRRQByvxI1i/0DwB qep6ZP5F5B5XlybFbbulRTwwI6E9q+Tr28n1G/uL66k8y5uZWmlfAG52JJOBwOSelfWPxI0e/wBf 8AanpmmQefeT+V5ce9V3bZUY8sQOgPevnzwl8OdU13xq+haja3NnFZtnUJAozCuCQATxl+ApGeDu AIBr7zhavhqGCq1ajSkm29r8tl87X28/M5a6k5JI5+z8MeINRtUurHQ9TubaTOyaC0kdGwcHBAwe QR+FT/8ACF+Kv+hZ1n/wAl/+Jr6/srODTrC3sbWPy7a2iWGJMk7UUAAZPJ4A61PXNLjGrzPlpK3q yvq67nxfqHh7WtJgWfUtH1CzhZtiyXNs8alsE4ywAzgHj2qPR9Yv9A1WHU9Mn8i8g3eXJsVtu5Sp 4YEdCe1fYWv6HZeJNDu9I1BXNrcqFby22spBBDA+oIB5yOOQRxXyze/D3xDB4yuPDNrYTXN3Huki bARZYQTiXJO1VPHU8E7evFe3lWe0cwpzhiEotbp7OPz/ABMp0nBqx9cVy/xE8N3ni7wJqWh2EkEd 1deVsediEG2VHOSAT0U9q6iuH+L9/eaZ8LdZvLC7ntLqPyNk0Ehjdczxg4YcjIJH41+YnadJ4a02 bRvCukaXcNG09lZQ28jRklSyIFJGQDjI9BWpWH4LnmuvAvh64uJZJp5dMtnkkkYszsYlJJJ5JJ5z W5QAUUUUAFFFFABRRRQAUUUUAFFFcrrHxI8JaBqs2manq3kXkG3zI/s8rbdyhhyqkdCO9a0aFWvL lpRcn5Jv8hNpbmxqHiHRdJnWDUtY0+zmZd6x3NykbFckZwxBxkHn2qr/AMJp4V/6GbRv/A+L/wCK rwr4n6l4e8a+JbbUtN8T6fFDFZrAy3MF0rbg7tn5YSMYYd6818iP7f8AZ/tcPlebs+04fy9ucb8b d23v93OO2eK+uwXC9OvRjOpKUZW1XLa33owlXaeh9jWfifw/qN0lrY65plzcyZ2QwXcbu2Bk4AOT wCfwrVr5d8Btofhfxpp+s33inTJLa28zesEF2XO6NlGAYQOrDvXuNl8VPBeo39vY2us+Zc3MqwxJ 9lmG52IAGSmByR1ryczyWphqiWHjKcbXb5Xo9fIuFRNanY0UUV4RqcX8KNNm0b4dWGl3DRtPZXF3 byNGSVLJdSqSMgHGR6Cu0rg/gzPNdfCnR7i4lkmnle5eSSRizOxuJCSSeSSec13lABRRRQAUUUUA FFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAU UUUAZfiXTZtZ8K6vpdu0az3tlNbxtISFDOhUE4BOMn0NeCfBTWbPwD4o8QeHvFT/ANk30/lBTdEJ GrRhyQzk4GQ4Kn7rDoeVz9H182al8B/iDrNwtxqniLTb6dUCLJdXtxKwXJOAWjJxkk49zQB9HwTw 3VvFcW8sc0EqB45I2DK6kZBBHBBHOakr5g/4Zx8Yf9BLQ/8Av/N/8ao/4Zx8Yf8AQS0P/v8Azf8A xqgD6forxv4TfCbXvAfiq61TVLvTZoJbJ7dVtZHZgxdGydyKMYQ9/SvZKACiiigAoorj/HXjDWPC n2D+yfCV9r/2nzPM+yF/3G3bjO2N/vbj1x909aAOworxuf4zeKrW3luLj4V6zDBEheSSR5VVFAyS SYMAAc5rsLb4jWMPw3tvGWvWsmlRToWS0Zt8jncwRUyF3F1AYcAYOc4BNAHaUV4uPjprEFnDqV/8 OdVttIbY73wlcoI2IwykxKrZyMfMAcjnmvUP+Eq0L/hF/wDhJf7Tg/sbyvO+15O3bnGMdd2fl243 bvlxnigDYorxc/HTWJ7ObUrD4c6rc6Qu90vjK4QxqTlmIiZVxg5+YgYPPFemaB4u0XxJ4aXX7C9j FgELTNMwQ25UZZZOcKVHJ5xjBBIIJANyivH3+N1/f3l0fDHgPVdc0yGUxJfQmQCQgAn5RE23rkAn OCCQM4HceBfHWl+PNDF/YHyriPC3Vo7Ze3c9j6qcHDd8diCAAWLz/koejf8AYKv/AP0baV0Fc/ef 8lD0b/sFX/8A6NtK6CgAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAOP8YaB4b1fxD4Y vNb1f7FfWF35unQ/aY4/tMm+M7drAl+VQYXB+b3FdhXj/wAX/wDkofwx/wCwqf8A0bb17BQAUUUU AFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAHH/EfQPDfiPw9b2fijV/7LsUu1lSb7THBukCOA u6QEHgscdePauwrx/wDaO/5J5p//AGFY/wD0VLXsFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABR RRQAUUUUAc/420rR9b8IX2na/f8A2DTJvL86585ItmJFZfmcFRlgo59a0NCtbOx8PaZZ6dcfaLGC 0iit5t4fzI1QBW3Dg5AByODXH/G3/kkOu/8Abv8A+lEddB4E/wCSeeGv+wVa/wDopaAOgooooAKK KKACiiigAooooAKKKKACiiigAooooAKKKKACuP8AhxoHhvw54euLPwvq/wDali920rzfaY59shRA V3RgAcBTjrz712FeP/s4/wDJPNQ/7Csn/oqKgD2CiiigAooooAKKKKACiiigAooooAKKKKACiiig AooooA5/x3/yTzxL/wBgq6/9FNXgH7OP/JQ9Q/7BUn/o2Kvf/Hf/ACTzxL/2Crr/ANFNXgH7OP8A yUPUP+wVJ/6NioA+n6KKKACiiigAooooAKKKKACiiigCC8srTUbV7W+tYbm2kxvhnjDo2DkZB4PI B/Cp6KKd3awBRRRSAjngiuYJIJ4klhlUpJHIoZXUjBBB4II7UQQRW0EcEESRQxKEjjjUKqKBgAAc AAdqkop3drAFcfp2geG7f4oatrltq/m+Ibm0WK6sPtMbeVGBFhvLA3rwick4+b3FdhXj/h7/AJOh 8Wf9gqP/ANBtaQHsFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVx/jDQPDer+IfDF5r er/Yr6wu/N06H7THH9pk3xnbtYEvyqDC4Pze4rsK8f8Ai/8A8lD+GP8A2FT/AOjbegD2CiiigAoo ooAKKKKACiiigAooooAKKKKACiiigAooooAK4/4j6B4b8R+Hrez8Uav/AGXYpdrKk32mODdIEcBd 0gIPBY468e1dhXj/AO0d/wAk80//ALCsf/oqWgD2CiiigAooooAKKKKACiiigAooooAKKKKACiii gAooooAK5/xtpWj634QvtO1+/wDsGmTeX51z5yRbMSKy/M4KjLBRz610Fef/ABt/5JDrv/bv/wCl EdAHYaFa2dj4e0yz064+0WMFpFFbzbw/mRqgCtuHByADkcGtCuf8Cf8AJPPDX/YKtf8A0UtdBQAU UUUAFFFFABRRRQAUUUUAY3i6eW28F67PBK8U0Wn3DxyRsVZGEbEEEcgg96+Z/Bnhm7+JXii6tr7W Zo7kWxuHup1Nw77WRADlgejDnPbFfSvjT/kRPEP/AGDLn/0U1eHfAH/ke77/ALBkn/o2Kvrsjqyo Zbia9PSS2Zz1VeaTNz/hnb/qaf8Ayn//AG2j/hnb/qaf/Kf/APba9xorzf8AWTNP+fv/AJLH/Iv2 MOx4d/wzt/1NP/lP/wDtteeeOfCUvw98S2lnBqj3E3kJdx3EcZhaNt7AYwxOQUznNfWlfOXx+/5H ux/7Bkf/AKNlr2sgzjG4zGKlXneNnpZfojOrTjGN0j3TwjPLc+C9CnnleWaXT7d5JJGLM7GNSSSe SSe9bNYfgv8A5ETw9/2DLb/0UtblfIYlWrTS7v8AM6I7I4/4YWtnY+ArWz064+0WMF3exW828P5k a3UoVtw4OQAcjg12Fef/AAS/5JDoX/bx/wClElegVgMKKKKACiiigAooooAKKKKACiiigAooooAK KKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAryvxz8ctF8JapJpVjZ yavfwOFuAkwjiiPOV34YlwQMgLgZIJyCK7zxZfXGmeDdcv7OTy7q10+4mhfaDtdY2KnB4OCB1r5w +BfgXS/F2uX1/q48+30rymW0ZcpM778F/VRsPy98jPAIIB0//DTX/Uo/+VL/AO1Uf8NNf9Sj/wCV L/7VXsH/AAgng/8A6FTQ/wDwXQ//ABNH/CCeD/8AoVND/wDBdD/8TQBx/wAOPjB/wsDxDcaT/YX2 DybRrnzftfm5w6LtxsX+/nOe1eoVl6b4a0HRrhrjS9E02xnZCjSWtqkTFcg4JUA4yAcewrUoAKKK KACiiq9/fW+madc395J5draxPNM+0naigljgcnAB6UAeX+M3fx98SrPwDBeeVpWnxLqGtR5YfaQG QrDwAejKchsfPn7yAVX+Nf8Ap/iHwDoFz+80zUNV/wBKg6eZh4kHzD5h8srjgj73sMWPgLY3Enhf VPEuoR5v9b1CSZ7jcP3yKcZ2jhf3hm7D8sVH8c4JtPTwt4viikuE0LU1eW3VSAysyNln52DdEq5I PMg+hAPVL+xt9T065sLyPzLW6ieGZNxG5GBDDI5GQT0r5Y/tvUf+GbPsX2j/AEf/AISD7Fs2L/qf L8/bnGf9Z82evbOOK971X4p+ELDw1cavba7pt46W/mw2iXSiWViPlTZy6kkgHK/LySBg145/whV5 /wAMy/a8z+d/aH9s/Z/sx3eXjyfX7uz97vxjb2x81AH0fYWNvpmnW1hZx+Xa2sSQwpuJ2ooAUZPJ wAOtfOFrfXGgeCfi7o+mSeRYWOoJDbxbQ2xJZ2gkGWyTmNFXknGMjB5r2PSvin4Qv/DVvq9zrum2 bvb+bNaPdKZYmA+ZNnDsQQQML83BAORXlnhnw7eeMPhn8Rtdjint5Nfu2uba1WEyFvJczBUPG/cz GPIHBU9TwAD1/wCHFjb6f8NfDkNrH5cbafDMRuJy8iiRzz6szH2zxxXD+Dv+JX+0T410mz/dWNza Jeyxfe3THym3ZOSOZpTgHHzdOBjU+GnxG8M3Pw+0eG91nTdOu7O3Szlt7q7WNgYwFDDdtyGUBuMg ZIySDWP8MZl8W/Fnxj42tRImnlEsLcmNts4+QbwxAwdsKMVxkeaM9OQDuNe1bTdG8daJcapqFpYw Npl8iyXUyxKW820OAWIGcAnHsauf8J34P/6GvQ//AAYw/wDxVF5/yUPRv+wVf/8Ao20roKAMvTfE ug6zcNb6Xrem306oXaO1uklYLkDJCknGSBn3FV5/GnhW1uJbe48S6NDPE5SSOS/iVkYHBBBbIIPG K3KKAM+113R77Tp9Rs9Vsbixg3edcw3CPHHtG5tzA4GAQTnoKz/+E78H/wDQ16H/AODGH/4qugoo Az7rXdHsdOg1G81Wxt7Gfb5NzNcIkcm4bl2sTg5AJGOoqnB408K3VxFb2/iXRpp5XCRxx38TM7E4 AADZJJ4xW5RQBl6l4l0HRrhbfVNb02xnZA6x3V0kTFckZAYg4yCM+xo03xLoOs3DW+l63pt9OqF2 jtbpJWC5AyQpJxkgZ9xWpRQBhz+NPCtrcS29x4l0aGeJykkcl/ErIwOCCC2QQeMVctdd0e+06fUb PVbG4sYN3nXMNwjxx7RubcwOBgEE56CtCigDn/8AhO/B/wD0Neh/+DGH/wCKrQutd0ex06DUbzVb G3sZ9vk3M1wiRybhuXaxODkAkY6itCigDDg8aeFbq4it7fxLo008rhI447+JmdicAABskk8YqxqX iXQdGuFt9U1vTbGdkDrHdXSRMVyRkBiDjIIz7GtSigDL03xLoOs3DW+l63pt9OqF2jtbpJWC5AyQ pJxkgZ9xVefxp4VtbiW3uPEujQzxOUkjkv4lZGBwQQWyCDxityigDz/xL498B22o+H5b8WOq/aLt orS/hEE8dlIpi3M0hb93jfGxI5wM9hXQf8J34P8A+hr0P/wYw/8AxVcX8U9J1LUPHXw7uLLT7u5g tNTL3MkMLOsK+bAcuQMKMKTk+h9K9UoAz7rXdHsdOg1G81Wxt7Gfb5NzNcIkcm4bl2sTg5AJGOoq nB408K3VxFb2/iXRpp5XCRxx38TM7E4AADZJJ4xW5RQBl6l4l0HRrhbfVNb02xnZA6x3V0kTFckZ AYg4yCM+xo03xLoOs3DW+l63pt9OqF2jtbpJWC5AyQpJxkgZ9xWpRQBhz+NPCtrcS29x4l0aGeJy kkcl/ErIwOCCC2QQeMVctdd0e+06fUbPVbG4sYN3nXMNwjxx7RubcwOBgEE56CtCigDn/wDhO/B/ /Q16H/4MYf8A4qtC613R7HToNRvNVsbexn2+TczXCJHJuG5drE4OQCRjqK0KKAMODxp4VuriK3t/ EujTTyuEjjjv4mZ2JwAAGySTxirGpeJdB0a4W31TW9NsZ2QOsd1dJExXJGQGIOMgjPsa1KKAMvTf Eug6zcNb6Xrem306oXaO1uklYLkDJCknGSBn3FV5/GnhW1uJbe48S6NDPE5SSOS/iVkYHBBBbIIP GK3KKAM+113R77Tp9Rs9Vsbixg3edcw3CPHHtG5tzA4GAQTnoKz/APhO/B//AENeh/8Agxh/+Kro KKAM+613R7HToNRvNVsbexn2+TczXCJHJuG5drE4OQCRjqKpweNPCt1cRW9v4l0aaeVwkccd/EzO xOAAA2SSeMVuUUAcP8R/F3g/w5p1vF4os4NU3yqyWHlQzyLkPiXy5GGF4Zd3qcd66TTfEug6zcNb 6Xrem306oXaO1uklYLkDJCknGSBn3Fef/H3SdS1nwLY2+l6fd3066nG7R2sLSsF8qUZIUE4yQM+4 r1SgDDn8aeFbW4lt7jxLo0M8TlJI5L+JWRgcEEFsgg8Yq5a67o99p0+o2eq2NxYwbvOuYbhHjj2j c25gcDAIJz0FaFFAHP8A/Cd+D/8Aoa9D/wDBjD/8VWhda7o9jp0Go3mq2NvYz7fJuZrhEjk3Dcu1 icHIBIx1FaFFAGHB408K3VxFb2/iXRpp5XCRxx38TM7E4AADZJJ4xVjUvEug6NcLb6prem2M7IHW O6ukiYrkjIDEHGQRn2NalFAGXpviXQdZuGt9L1vTb6dULtHa3SSsFyBkhSTjJAz7iq8/jTwra3Et vceJdGhnicpJHJfxKyMDgggtkEHjFblFAGfa67o99p0+o2eq2NxYwbvOuYbhHjj2jc25gcDAIJz0 FZ//AAnfg/8A6GvQ/wDwYw//ABVdBRQBn3Wu6PY6dBqN5qtjb2M+3ybma4RI5Nw3LtYnByASMdRV ODxp4VuriK3t/EujTTyuEjjjv4mZ2JwAAGySTxityigDL1LxLoOjXC2+qa3ptjOyB1jurpImK5Iy AxBxkEZ9jRpviXQdZuGt9L1vTb6dULtHa3SSsFyBkhSTjJAz7itSigDDn8aeFbW4lt7jxLo0M8Tl JI5L+JWRgcEEFsgg8Yq5a67o99p0+o2eq2NxYwbvOuYbhHjj2jc25gcDAIJz0FaFFAHD+KfiD4Dt /Dl3Lf6jpWtWq7N9hBPBcvL864xGWw2DhvbGe1bln4h0G18K6Vqj3NppOl3VvCbVbp0gVFZNyIOd oIXsD2OOlYfxfsLzU/hbrNnYWk93dSeRshgjMjtieMnCjk4AJ/CtzwXBNa+BfD1vcRSQzxaZbJJH IpVkYRKCCDyCDxigAg8aeFbq4it7fxLo008rhI447+JmdicAABskk8YqxqXiXQdGuFt9U1vTbGdk DrHdXSRMVyRkBiDjIIz7GtSigDL03xLoOs3DW+l63pt9OqF2jtbpJWC5AyQpJxkgZ9xVefxp4Vtb iW3uPEujQzxOUkjkv4lZGBwQQWyCDxityigDPtdd0e+06fUbPVbG4sYN3nXMNwjxx7RubcwOBgEE 56Cs/wD4Tvwf/wBDXof/AIMYf/iq6CigDPutd0ex06DUbzVbG3sZ9vk3M1wiRybhuXaxODkAkY6i qcHjTwrdXEVvb+JdGmnlcJHHHfxMzsTgAANkknjFblFAGXqXiXQdGuFt9U1vTbGdkDrHdXSRMVyR kBiDjIIz7GjTfEug6zcNb6Xrem306oXaO1uklYLkDJCknGSBn3FalFAGHP408K2txLb3HiXRoZ4n KSRyX8SsjA4IILZBB4xVy113R77Tp9Rs9Vsbixg3edcw3CPHHtG5tzA4GAQTnoK0KKAOf/4Tvwf/ ANDXof8A4MYf/iq0LrXdHsdOg1G81Wxt7Gfb5NzNcIkcm4bl2sTg5AJGOorQooAw4PGnhW6uIre3 8S6NNPK4SOOO/iZnYnAAAbJJPGKsal4l0HRrhbfVNb02xnZA6x3V0kTFckZAYg4yCM+xrUooAy9N 8S6DrNw1vpet6bfTqhdo7W6SVguQMkKScZIGfcVx/gr4ifD660aZ9Lk03w7ALhg1pdNb2jO21fnC K2CCMDP+yR2r0SvK/gFpOpaN4FvrfVNPu7GdtTkdY7qFomK+VEMgMAcZBGfY0AeiWuu6PfadPqNn qtjcWMG7zrmG4R449o3NuYHAwCCc9BWf/wAJ34P/AOhr0P8A8GMP/wAVXQUUAZ91ruj2OnQajear Y29jPt8m5muESOTcNy7WJwcgEjHUVTg8aeFbq4it7fxLo008rhI447+JmdicAABskk8YrcooAy9S 8S6Do1wtvqmt6bYzsgdY7q6SJiuSMgMQcZBGfY0ab4l0HWbhrfS9b02+nVC7R2t0krBcgZIUk4yQ M+4rUooAw5/GnhW1uJbe48S6NDPE5SSOS/iVkYHBBBbIIPGKuWuu6PfadPqNnqtjcWMG7zrmG4R4 49o3NuYHAwCCc9BWhRQBz/8Awnfg/wD6GvQ//BjD/wDFVoXWu6PY6dBqN5qtjb2M+3ybma4RI5Nw 3LtYnByASMdRWhRQBhweNPCt1cRW9v4l0aaeVwkccd/EzOxOAAA2SSeMVY1LxLoOjXC2+qa3ptjO yB1jurpImK5IyAxBxkEZ9jWpRQBl6b4l0HWbhrfS9b02+nVC7R2t0krBcgZIUk4yQM+4qvP408K2 txLb3HiXRoZ4nKSRyX8SsjA4IILZBB4xW5RQBn2uu6PfadPqNnqtjcWMG7zrmG4R449o3NuYHAwC Cc9BWf8A8J34P/6GvQ//AAYw/wDxVdBRQByfj7VtNj+GmtXD6haLBe6ZOlrI0yhZ2eFigQ5wxYcg DOe1eCfs939nY/EO5+2XcFv5+ntBD50gTzJGli2ouerHBwBya+h/Hf8AyTzxL/2Crr/0U1eAfs4/ 8lD1D/sFSf8Ao2KgD6L1LxLoOjXC2+qa3ptjOyB1jurpImK5IyAxBxkEZ9jRpviXQdZuGt9L1vTb 6dULtHa3SSsFyBkhSTjJAz7itSigDDn8aeFbW4lt7jxLo0M8TlJI5L+JWRgcEEFsgg8Yq5a67o99 p0+o2eq2NxYwbvOuYbhHjj2jc25gcDAIJz0FaFFAHP8A/Cd+D/8Aoa9D/wDBjD/8VWhda7o9jp0G o3mq2NvYz7fJuZrhEjk3Dcu1icHIBIx1FaFFAGHB408K3VxFb2/iXRpp5XCRxx38TM7E4AADZJJ4 xVjUvEug6NcLb6prem2M7IHWO6ukiYrkjIDEHGQRn2NalFAGXpviXQdZuGt9L1vTb6dULtHa3SSs FyBkhSTjJAz7iq8/jTwra3EtvceJdGhnicpJHJfxKyMDgggtkEHjFblFAGfa67o99p0+o2eq2NxY wbvOuYbhHjj2jc25gcDAIJz0FZ//AAnfg/8A6GvQ/wDwYw//ABVdBRQBn3Wu6PY6dBqN5qtjb2M+ 3ybma4RI5Nw3LtYnByASMdRVODxp4VuriK3t/EujTTyuEjjjv4mZ2JwAAGySTxityigDL1LxLoOj XC2+qa3ptjOyB1jurpImK5IyAxBxkEZ9jRpviXQdZuGt9L1vTb6dULtHa3SSsFyBkhSTjJAz7itS igDDn8aeFbW4lt7jxLo0M8TlJI5L+JWRgcEEFsgg8Yrn9I8a+CdR8eavb6fBaf2ha2X2i71pEh8q SFRHkeeGyQuVBzwNh9BXeV5XoWk6lD+0b4n1SXT7tNPm0xEiu2hYRO2234V8YJ+VuAex9KAO0/4T vwf/ANDXof8A4MYf/iq0LrXdHsdOg1G81Wxt7Gfb5NzNcIkcm4bl2sTg5AJGOorQooAw4PGnhW6u Ire38S6NNPK4SOOO/iZnYnAAAbJJPGKsal4l0HRrhbfVNb02xnZA6x3V0kTFckZAYg4yCM+xrUoo Ay9N8S6DrNw1vpet6bfTqhdo7W6SVguQMkKScZIGfcVXn8aeFbW4lt7jxLo0M8TlJI5L+JWRgcEE Fsgg8YrcooAz7XXdHvtOn1Gz1WxuLGDd51zDcI8ce0bm3MDgYBBOegrP/wCE78H/APQ16H/4MYf/ AIqugooAz7rXdHsdOg1G81Wxt7Gfb5NzNcIkcm4bl2sTg5AJGOoqnB408K3VxFb2/iXRpp5XCRxx 38TM7E4AADZJJ4xW5RQBl6l4l0HRrhbfVNb02xnZA6x3V0kTFckZAYg4yCM+xo03xLoOs3DW+l63 pt9OqF2jtbpJWC5AyQpJxkgZ9xWpRQBhz+NPCtrcS29x4l0aGeJykkcl/ErIwOCCC2QQeMVctdd0 e+06fUbPVbG4sYN3nXMNwjxx7RubcwOBgEE56CtCigDn/wDhO/B//Q16H/4MYf8A4qtC613R7HTo NRvNVsbexn2+TczXCJHJuG5drE4OQCRjqK0KKAMODxp4VuriK3t/EujTTyuEjjjv4mZ2JwAAGyST xisPxr4u8H+H/EOgWfiGzgub6eXdazPFC/2H51HmszsDGuedw/55n+7XcV5X8U9J1LUPHXw7uLLT 7u5gtNTL3MkMLOsK+bAcuQMKMKTk+h9KAPQNN8S6DrNw1vpet6bfTqhdo7W6SVguQMkKScZIGfcV Xn8aeFbW4lt7jxLo0M8TlJI5L+JWRgcEEFsgg8YrcooAz7XXdHvtOn1Gz1WxuLGDd51zDcI8ce0b m3MDgYBBOegrP/4Tvwf/ANDXof8A4MYf/iq6CigDPutd0ex06DUbzVbG3sZ9vk3M1wiRybhuXaxO DkAkY6iqcHjTwrdXEVvb+JdGmnlcJHHHfxMzsTgAANkknjFblFAGXqXiXQdGuFt9U1vTbGdkDrHd XSRMVyRkBiDjIIz7GjTfEug6zcNb6Xrem306oXaO1uklYLkDJCknGSBn3FalFAGHP408K2txLb3H iXRoZ4nKSRyX8SsjA4IILZBB4xVy113R77Tp9Rs9Vsbixg3edcw3CPHHtG5tzA4GAQTnoK0KKAOf /wCE78H/APQ16H/4MYf/AIqtC613R7HToNRvNVsbexn2+TczXCJHJuG5drE4OQCRjqK0KKAMODxp 4VuriK3t/EujTTyuEjjjv4mZ2JwAAGySTxirGpeJdB0a4W31TW9NsZ2QOsd1dJExXJGQGIOMgjPs a1KKAMvTfEug6zcNb6Xrem306oXaO1uklYLkDJCknGSBn3FV5/GnhW1uJbe48S6NDPE5SSOS/iVk YHBBBbIIPGK3KKAM+113R77Tp9Rs9Vsbixg3edcw3CPHHtG5tzA4GAQTnoK4vxr8RPh9a6NC+qSa b4igNwoW0tWt7tkba3zlGbAAGRn/AGgO9eiV5X8fdJ1LWfAtjb6Xp93fTrqcbtHawtKwXypRkhQT jJAz7igD0S613R7HToNRvNVsbexn2+TczXCJHJuG5drE4OQCRjqKpweNPCt1cRW9v4l0aaeVwkcc d/EzOxOAAA2SSeMVuUUAZepeJdB0a4W31TW9NsZ2QOsd1dJExXJGQGIOMgjPsaNN8S6DrNw1vpet 6bfTqhdo7W6SVguQMkKScZIGfcVqUUAYc/jTwra3EtvceJdGhnicpJHJfxKyMDgggtkEHjFXLXXd HvtOn1Gz1WxuLGDd51zDcI8ce0bm3MDgYBBOegrQooA5/wD4Tvwf/wBDXof/AIMYf/iq0LrXdHsd Og1G81Wxt7Gfb5NzNcIkcm4bl2sTg5AJGOorQooAw4PGnhW6uIre38S6NNPK4SOOO/iZnYnAAAbJ JPGKsal4l0HRrhbfVNb02xnZA6x3V0kTFckZAYg4yCM+xrUooAy9N8S6DrNw1vpet6bfTqhdo7W6 SVguQMkKScZIGfcVXn8aeFbW4lt7jxLo0M8TlJI5L+JWRgcEEFsgg8YrcooAz7XXdHvtOn1Gz1Wx uLGDd51zDcI8ce0bm3MDgYBBOegrP/4Tvwf/ANDXof8A4MYf/iq6CigDPutd0ex06DUbzVbG3sZ9 vk3M1wiRybhuXaxODkAkY6iqcHjTwrdXEVvb+JdGmnlcJHHHfxMzsTgAANkknjFblFAGXqXiXQdG uFt9U1vTbGdkDrHdXSRMVyRkBiDjIIz7Guf8S+OvBK+GNQuLu803XbO3RHuLK1lhumZTIigmMtgg MyHJ6cd8V2lcP8X7C81P4W6zZ2FpPd3UnkbIYIzI7YnjJwo5OACfwoAuaT4+8EyaNYvb69o1jA1v GY7SS8hiaBdowhQNhSo4x2xity113R77Tp9Rs9Vsbixg3edcw3CPHHtG5tzA4GAQTnoKp+C4JrXw L4et7iKSGeLTLZJI5FKsjCJQQQeQQeMVuUAc/wD8J34P/wChr0P/AMGMP/xVaF1ruj2OnQajearY 29jPt8m5muESOTcNy7WJwcgEjHUVoUUAYcHjTwrdXEVvb+JdGmnlcJHHHfxMzsTgAANkknjFWNS8 S6Do1wtvqmt6bYzsgdY7q6SJiuSMgMQcZBGfY1qUUAZem+JdB1m4a30vW9Nvp1Qu0drdJKwXIGSF JOMkDPuKrz+NPCtrcS29x4l0aGeJykkcl/ErIwOCCC2QQeMVuUUAZ9rruj32nT6jZ6rY3FjBu865 huEeOPaNzbmBwMAgnPQVn/8ACd+D/wDoa9D/APBjD/8AFV0FFAHL+N9W02P4eatcPqFosF7p8yWs jTKFnZ4mKBDnDFhyAM57V4l8C7+zsfHc/wBsu4Lfz7FoIfOkCeZI0se1Fz1Y4OAOTXvPjT/kRPEP /YMuf/RTV4d8Af8Ake77/sGSf+jYq+qyr/kT4owqfxInvOpeJdB0a4W31TW9NsZ2QOsd1dJExXJG QGIOMgjPsaNN8S6DrNw1vpet6bfTqhdo7W6SVguQMkKScZIGfcVqUV8qbmHP408K2txLb3HiXRoZ 4nKSRyX8SsjA4IILZBB4xXgXxs1bTdZ8Z2dxpeoWl9AunojSWsyyqG8yQ4JUkZwQce4r6Zr5y+P3 /I92P/YMj/8ARstfR8K/8jFejMa/wHqvhLxp4VtfBmhW9x4l0aGeLT7dJI5L+JWRhGoIILZBB4xW x/wnfg//AKGvQ/8AwYw//FVJ4L/5ETw9/wBgy2/9FLW5Xh4r+PP1f5msdkcf8MLqzvvAVreadb/Z 7Ge7vZbeHYE8uNrqUqu0cDAIGBwK7CuD+DME1r8KdHt7iKSGeJ7lJI5FKsjC4kBBB5BB4xXeVgMK KKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoo ooAKKKKACs/W9b07w5o8+ratcfZ7GDb5kuxn27mCjhQSeSBwK0K5/wAbaVo+t+EL7Ttfv/sGmTeX 51z5yRbMSKy/M4KjLBRz60Ac3P8AGb4bXVvLb3GtxzQSoUkjksJ2V1IwQQY8EEcYrxDw14w0z4Yf EGefQdSk1zw3dIElASSKQITkZVgoMqc4OMEMfuljt9H034D/AA+1m3a40vxFqV9ArlGktb23lUNg HBKxkZwQce4q5/wzj4P/AOglrn/f+H/41QBuQfHH4fTW8Ur61JA7oGaKSzmLISPunahGR04JHoTU n/C7fh5/0MP/AJJXH/xuuf8A+GcfB/8A0Etc/wC/8P8A8ao/4Zx8H/8AQS1z/v8Aw/8AxqgDuPDf xE8K+LtRksND1X7XdRxGZk+zyx4QEAnLqB1YfnXUVwfgr4TaD4D1mbVNLu9Smnlt2t2W6kRlCllb I2opzlB39a7ygAooooAKr39jb6np1zYXkfmWt1E8MybiNyMCGGRyMgnpViigDP0TRNO8OaPBpOk2 /wBnsYN3lxb2fbuYseWJJ5JPJq5PBDdW8tvcRRzQSoUkjkUMrqRggg8EEcYqSigDg4Pgx8Pra4in Tw7GXjcOokuZnUkHPKs5DD2IIPeu8oooA4Of4MfD65uJZ38Oxh5HLsI7mZFBJzwquAo9gAB2ruII IbW3it7eKOGCJAkccahVRQMAADgADjFSUUAcXqvwm8D61qlxqV/oMb3dy++V0nljDN3O1GAyepOO Tknkmuo0rSrHQ9Lt9M0y2jtrO3TZFEnRR/MknJJPJJJOSauUUAc/ef8AJQ9G/wCwVf8A/o20roK5 +8/5KHo3/YKv/wD0baV0FABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAcH478a6l4X8 VeDtLsoLSSDWr029y0yMWRd8S5TDAA4kPUHoK7yuD8d+CtS8UeKvB2qWU9pHBot6bi5WZ2DOu+Js JhSCcRnqR1Fd5QAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAHB/FnxrqXgPwra6ppcF pNPLepbst0jMoUo7ZG1lOcoO/rXeVwfxZ8Fal488K2ul6XPaQzxXqXDNdOyqVCOuBtVjnLjt613l ABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAcv8AETxJeeEfAmpa5YRwSXVr5WxJ1JQ7 pUQ5AIPRj3rU8NalNrPhXSNUuFjWe9sobiRYwQoZ0DEDJJxk+prL+Inhu88XeBNS0Owkgjurrytj zsQg2yo5yQCeintWp4a02bRvCukaXcNG09lZQ28jRklSyIFJGQDjI9BQBqUUUUAFFFFABRRRQAUU UUAFFFFABRRRQAUUUUAFFFFABXB/CbxrqXjzwrdapqkFpDPFevbqtqjKpUIjZO5mOcue/pXeVwfw m8Fal4D8K3Wl6pPaTTy3r3CtauzKFKIuDuVTnKHt6UAd5RRRQAUUUUAFFFFABRRRQAUUUUAFFFFA BRRRQAUUUUAc/wCO/wDknniX/sFXX/opq8A/Zx/5KHqH/YKk/wDRsVe/+O/+SeeJf+wVdf8Aopq8 A/Zx/wCSh6h/2CpP/RsVAH0/RRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFcHpXjXUr7 4y654PlgtBp9hZLcRSKjeaWIhOGO7GP3jdAOg/HvK4PSvBWpWPxl1zxhLPaHT7+yW3ijV280MBCM sNuMfu26E9R+AB3lFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVwfjvxrqXhfxV4O0uy gtJINavTb3LTIxZF3xLlMMADiQ9QegrvK4Px34K1LxR4q8HapZT2kcGi3puLlZnYM674mwmFIJxG epHUUAd5RRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFcH8WfGupeA/CtrqmlwWk08t6l uy3SMyhSjtkbWU5yg7+td5XB/FnwVqXjzwra6Xpc9pDPFepcM107KpUI64G1WOcuO3rQB3lFFFAB RRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVy/xE8SXnhHwJqWuWEcEl1a+VsSdSUO6VEOQCD0 Y966iuX+Inhu88XeBNS0OwkgjurrytjzsQg2yo5yQCeintQBqeGtSm1nwrpGqXCxrPe2UNxIsYIU M6BiBkk4yfU1qVl+GtNm0bwrpGl3DRtPZWUNvI0ZJUsiBSRkA4yPQVqUAFFFFABRRRQAUUUUAFFF FAGH40/5ETxD/wBgy5/9FNXh3wB/5Hu+/wCwZJ/6Nir3Hxp/yIniH/sGXP8A6KavDvgD/wAj3ff9 gyT/ANGxV9VlX/InxRhU/iRPo2iiivlTcK+cvj9/yPdj/wBgyP8A9Gy19G185fH7/ke7H/sGR/8A o2Wvo+Ff+RivRmNf4D3HwX/yInh7/sGW3/opa3Kw/Bf/ACInh7/sGW3/AKKWtyvDxX8efq/zNY7I 4v4UalNrPw6sNUuFjWe9uLu4kWMEKGe6lYgZJOMn1NdpXF/CjTZtG+HVhpdw0bT2Vxd28jRklSyX UqkjIBxkegrtKwGFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUU UUAFFFFABRRRQAUUUUAFFFFABXn/AMbf+SQ67/27/wDpRHXoFef/ABt/5JDrv/bv/wClEdAHP/s4 /wDJPNQ/7Csn/oqKvYK+UPhx8YP+Ff8Ah640n+wvt/nXbXPm/a/KxlEXbjY39zOc966//hpr/qUf /Kl/9qoA+gKK+f8A/hpr/qUf/Kl/9qo/4aa/6lH/AMqX/wBqoA+gKK8v+HHxg/4WB4huNJ/sL7B5 No1z5v2vzc4dF242L/fznPavUKACiiigAooooAKKKKACiiigAooooAKKKKAOfvP+Sh6N/wBgq/8A /RtpXQVz95/yUPRv+wVf/wDo20roKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA8r+ Keralp/jr4d29lqF3bQXeplLmOGZkWZfNgGHAOGGGIwfU+teqVx/jDQPDer+IfDF5rer/Yr6wu/N 06H7THH9pk3xnbtYEvyqDC4Pze4rsKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA8r +Puralo3gWxuNL1C7sZ21ONGktZmiYr5UpwSpBxkA49hXqlcf8R9A8N+I/D1vZ+KNX/suxS7WVJv tMcG6QI4C7pAQeCxx149q7CgAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAOH+L9/eaZ 8LdZvLC7ntLqPyNk0Ehjdczxg4YcjIJH41ueC55rrwL4euLiWSaeXTLZ5JJGLM7GJSSSeSSec1H4 20rR9b8IX2na/f8A2DTJvL86585ItmJFZfmcFRlgo59a0NCtbOx8PaZZ6dcfaLGC0iit5t4fzI1Q BW3Dg5AByODQBoUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXlfwC1bUtZ8C31xqmoX d9OupyIsl1M0rBfKiOAWJOMknHua9Urj/hxoHhvw54euLPwvq/8Aali920rzfaY59shRAV3RgAcB Tjrz70AdhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAc/wCO/wDknniX/sFXX/opq8A/ Zx/5KHqH/YKk/wDRsVe/+O/+SeeJf+wVdf8Aopq8A/Zx/wCSh6h/2CpP/RsVAH0/RRRQAUUUUAFF FFABRRRQAUUUUAFFFFABRRRQAUUUUAFeV6Fq2pTftG+J9Ll1C7fT4dMR4rRpmMSNtt+VTOAfmbkD ufWvVK4/TtA8N2/xQ1bXLbV/N8Q3NosV1YfaY28qMCLDeWBvXhE5Jx83uKAOwooooAKKKKACiiig AooooAKKKKACiiigAooooAKKKKACvK/inq2paf46+HdvZahd20F3qZS5jhmZFmXzYBhwDhhhiMH1 PrXqlcf4w0Dw3q/iHwxea3q/2K+sLvzdOh+0xx/aZN8Z27WBL8qgwuD83uKAOwooooAKKKKACiii gAooooAKKKKACiiigAooooAKKKKACvK/j7q2paN4FsbjS9Qu7GdtTjRpLWZomK+VKcEqQcZAOPYV 6pXH/EfQPDfiPw9b2fijV/7LsUu1lSb7THBukCOAu6QEHgscdePagDsKKKKACiiigAooooAKKKKA CiiigAooooAKKKKACiiigArh/i/f3mmfC3Wbywu57S6j8jZNBIY3XM8YOGHIyCR+NdxXP+NtK0fW /CF9p2v3/wBg0yby/OufOSLZiRWX5nBUZYKOfWgCTwXPNdeBfD1xcSyTTy6ZbPJJIxZnYxKSSTyS Tzmtys/QrWzsfD2mWenXH2ixgtIorebeH8yNUAVtw4OQAcjg1oUAFFFFABRRRQAUUUUAFFFFAGH4 0/5ETxD/ANgy5/8ARTV4d8Af+R7vv+wZJ/6Nir3Hxp/yIniH/sGXP/opq8O+AP8AyPd9/wBgyT/0 bFX1WVf8ifFGFT+JE+jaKKK+VNwr5y+P3/I92P8A2DI//RstfRtfOXx+/wCR7sf+wZH/AOjZa+j4 V/5GK9GY1/gPcfBf/IieHv8AsGW3/opa3Kw/Bf8AyInh7/sGW3/opa3K8PFfx5+r/M1jsjg/gzPN dfCnR7i4lkmnle5eSSRizOxuJCSSeSSec13lcf8ADC1s7HwFa2enXH2ixgu72K3m3h/MjW6lCtuH ByADkcGuwrAYUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQA UUUUAFFFFABRRRQAUUUUAFef/G3/AJJDrv8A27/+lEdegVx/xS0TUfEfw41bSdJt/tF9P5Plxb1T dtmRjyxAHAJ5NAHnfwC8NaDrPgW+uNU0TTb6ddTkRZLq1SVgvlRHALAnGSTj3Neqf8IJ4P8A+hU0 P/wXQ/8AxNcv8FPC2s+EfBt5Ya5Z/ZLqTUHmVPNSTKGOMA5QkdVP5V6RQBz/APwgng//AKFTQ/8A wXQ//E0f8IJ4P/6FTQ//AAXQ/wDxNdBRQBl6b4a0HRrhrjS9E02xnZCjSWtqkTFcg4JUA4yAcewr UoooAKKKKACiiigAooooAKKKKACiiigAooooA5+8/wCSh6N/2Cr/AP8ARtpXQVz95/yUPRv+wVf/ APo20roKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA8f8Ai/8A8lD+GP8A2FT/AOjb evYK4/xhr/hvSPEPhiz1vSPtt9f3fladN9mjk+zSb4xu3MQU5ZDlcn5fYV2FABRRRQAUUUUAFFFF ABRRRQAUUUUAFFFFABRRRQAUUUUAeP8A7R3/ACTzT/8AsKx/+ipa9grj/iPr/hvw54et7zxRpH9q WL3axJD9mjn2yFHIbbIQBwGGevPvXYUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQB5 /wDG3/kkOu/9u/8A6UR10HgT/knnhr/sFWv/AKKWjxtquj6J4QvtR1+w+36ZD5fnW3kpLvzIqr8r kKcMVPPpWhoV1Z33h7TLzTrf7PYz2kUtvDsCeXGyAqu0cDAIGBwKANCiiigAooooAKKKKACiiigA ooooAKKKKACiiigAooooAK8f/Zx/5J5qH/YVk/8ARUVewVx/w41/w34j8PXF54X0j+y7FLtonh+z RwbpAiEttjJB4KjPXj2oA7CiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA5/x3/yTzxL/ ANgq6/8ARTV4B+zj/wAlD1D/ALBUn/o2Kvf/AB3/AMk88S/9gq6/9FNXgH7OP/JQ9Q/7BUn/AKNi oA+n6KKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigArx/w9/wAnQ+LP+wVH/wCg2tewVx+n a/4buPihq2h22keV4htrRZbq/wDs0a+bGRFhfMB3tw6cEY+X2FAHYUUUUAFFFFABRRRQAUUUUAFF FFABRRVTVNQi0nSbzUp1dobSB55FjALFUUsQMkDOB604xcmordgW6K8q/wCF/eFf+gfrP/fmL/45 R/wv7wr/ANA/Wf8AvzF/8cr1P7DzH/n0zP2sO56rRWV4b8QWnijQLXWbGOaO2ud+xZ1AcbWKnIBI 6qe9atebUhKnNwmrNaP1NE76hXj/AMX/APkofwx/7Cp/9G29ewVx/jDX/DekeIfDFnrekfbb6/u/ K06b7NHJ9mk3xjduYgpyyHK5Py+wqAOwooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACv H/2jv+Seaf8A9hWP/wBFS17BXH/EfX/Dfhzw9b3nijSP7UsXu1iSH7NHPtkKOQ22QgDgMM9efegD sKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigArz/42/8AJIdd/wC3f/0ojr0Cuf8AG2q6 PonhC+1HX7D7fpkPl+dbeSku/MiqvyuQpwxU8+lAB4E/5J54a/7BVr/6KWugrP0K6s77w9pl5p1v 9nsZ7SKW3h2BPLjZAVXaOBgEDA4FaFABRRRQAUUUUAFFFFABRRRQBBe2cGo2FxY3UfmW1zE0MqZI 3IwIIyORwT0r5cM+q/Cr4mSzfZNohlfbACyR3NsxIGDuY7SMEZLbWUZyVNfUd7eQadYXF9dSeXbW 0TTSvgnaigknA5PAPSvmf4reO4PF+sC1sltp9Ns2DWd2sciSkMi+YpDEDG4f3QflGD1z9XwsqtSp Oi4c1KS97t/w/wCNtehhXskn1PpHRtWtNe0a01WxfdbXUQkTJBK56qcEgMDkEZ4IIq9Xx74e8b+I /CsE0Gi6m9tDMwd4zGki7gMZAcEA46kYzgZ6Ctj/AIXD48/6Dv8A5KQf/EVpW4QxPtH7GceXpe9/ yYliI21PqaeeK2gknnlSKGJS8kkjBVRQMkkngADvXyf478VS+P8Axet3a2Lom1bSzgUFpXXcSuQM 5YljwPUDnGTBrnxD8V+I9NOnarq7z2jMHaJYo4wxHTOxQSM84PGQD1AqPwH4gj8M+MtO1OaOExJK EkklV28mNjtd1CkZYIWxkEc9CcV6+U5HUyyM8RO06lnZK9v6fpp0M6lVTslsfU3hKyvdN8IaPY6j sF3b2cUUioMBSqgbepBIGASDgkEjAOBs1BZXkGo2FvfWsnmW1zEs0T4I3IwBBweRwR1qevz2rKU6 kpSVm27nWtjz/wCCX/JIdC/7eP8A0okr0CuP+GF1Z33gK1vNOt/s9jPd3stvDsCeXG11KVXaOBgE DA4FdhWYwooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooo oAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAOfvP+ Sh6N/wBgq/8A/RtpXQVz95/yUPRv+wVf/wDo20roKACiiigAooooAKKKKACiiigAooooAKKKKACi iigAooooA8r+Kek6lqHjr4d3Flp93cwWmpl7mSGFnWFfNgOXIGFGFJyfQ+leqVwfjvxrqXhfxV4O 0uygtJINavTb3LTIxZF3xLlMMADiQ9QegrvKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAo oooA8r+Puk6lrPgWxt9L0+7vp11ON2jtYWlYL5UoyQoJxkgZ9xXqlcH8WfGupeA/CtrqmlwWk08t 6luy3SMyhSjtkbWU5yg7+td5QAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAHD/F+wvN T+Fus2dhaT3d1J5GyGCMyO2J4ycKOTgAn8K3PBcE1r4F8PW9xFJDPFplskkcilWRhEoIIPIIPGKp /ETxJeeEfAmpa5YRwSXVr5WxJ1JQ7pUQ5AIPRj3rU8NalNrPhXSNUuFjWe9sobiRYwQoZ0DEDJJx k+poA1KKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAryv4BaTqWjeBb631TT7uxnbU5HW O6haJivlRDIDAHGQRn2NeqVwfwm8a6l488K3WqapBaQzxXr26raoyqVCI2TuZjnLnv6UAd5RRRQA UUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAc/47/5J54l/7BV1/wCimrwD9nH/AJKHqH/YKk/9 GxV7/wCO/wDknniX/sFXX/opq8A/Zx/5KHqH/YKk/wDRsVAH0/RRRQAUUUUAFFFFABRRRQAUUUUA FFFFABRRRQAUUUUAFeV6FpOpQ/tG+J9Ul0+7TT5tMRIrtoWETttt+FfGCflbgHsfSvVK4PSvGupX 3xl1zwfLBaDT7CyW4ikVG80sRCcMd2MfvG6AdB+IB3lFFFABRRRQAUUUUAFFFFABRRRQAVU1TT4t W0m802dnWG7geCRoyAwV1KkjIIzg+leXfGP4gXegq/huxhmhubu2juE1CC6MbxfvTkAAZ5EZGdw+ 9+fl0E/xPuYI54JfF8sMqh45I2uWV1IyCCOCCO9fRYDh+tWoxxMqihfa/XzMZVUna1zo/if8MNF8 FeGrbUtNutQlmlvFgZbmRGXaUds/KgOcqO9Hww+GGi+NfDVzqWpXWoRTRXjQKttIirtCI2fmQnOW PeuV1DS/iLq0CwalY+KbyFW3rHcw3EihsEZwwIzgnn3o0/S/iLpMDQabY+KbOFm3tHbQ3EalsAZw oAzgDn2r632eI+pex+sr2l/iv07GF1zX5dD6f8N+H7TwvoFro1jJNJbW2/Y07AudzFjkgAdWPatW vlKef4n20Ek88vi+KGJS8kkjXKqigZJJPAAHevR/gj421DVp7zQNSkubyZVe9W8ubppGC5jTy8Nk 4ySc579O9fK4/IK1OlPFe1U7au3nuzeFVNqNrHs1eV/FPSdS1Dx18O7iy0+7uYLTUy9zJDCzrCvm wHLkDCjCk5PofSvVK4Px3411Lwv4q8HaXZQWkkGtXpt7lpkYsi74lymGABxIeoPQV80bHeUUUUAF FFFABRRRQAUUUUAFFFFABRWN4l8S6f4Z0m4vLy5tkmWCWW3t5rhYmuGRc7FzySTgcA9RxXk//DRP /Urf+VD/AO1V6OEynGYyDnQhdeqX5tESqRjo2eq/8Jp4V/6GbRv/AAPi/wDiqP8AhNPCv/QzaN/4 Hxf/ABVfHNFfX/6nUP8An6/uRz/WH2PtTTta0rWPN/szU7K98rHmfZp1k2ZzjO0nGcH8jV6vlX4d /ET/AIQH+0v+JV9u+2+V/wAvHlbNm/8A2Wznf7dK9c8E/GK08Wa8dMutPh0rdFuiklvg3myblURq Cq5Y7jjBzx0rwMx4dxWGnOVOPNTj1uu2ul77+RtCtGW+56dXlfx90nUtZ8C2Nvpen3d9Oupxu0dr C0rBfKlGSFBOMkDPuK9Urg/iz411LwH4VtdU0uC0mnlvUt2W6RmUKUdsjaynOUHf1r541O8ooooA KKKKACiiigAooooAKKKKACiiigAooooAKKKKACuH+L9hean8LdZs7C0nu7qTyNkMEZkdsTxk4Ucn ABP4V3Fcv8RPEl54R8CalrlhHBJdWvlbEnUlDulRDkAg9GPegC54LgmtfAvh63uIpIZ4tMtkkjkU qyMIlBBB5BB4xW5WX4a1KbWfCukapcLGs97ZQ3EixghQzoGIGSTjJ9TWpQAUUUUAFFFFABRRRQAU UUUAYfjT/kRPEP8A2DLn/wBFNXxzX23e2cGo2FxY3UfmW1zE0MqZI3IwIIyORwT0rhrf4PeF7LxR p+s2MU1vHZ/OLQSsyPKGBRyzEsMc8ZwcL0wQ31OQZzh8vpVIVU7vVW20W3z9DCrTc2rHOfD/AODe kv4bjvfFWnzS6hdfOLaSR4vs6c4GEYEsRgnPTIGAQc9X/wAKe8B/9AL/AMm5/wD4uu4orya+c46t UlU9rJX6JtJeSVzRU4pWseXeKfgt4cufD10NAsHtNUjUyQFZ3cSsAf3ZEjYAbpnjBwegIPzlPBLb TyQTxPFNExSSORSrIwOCCDyCD2r7erz/AMTfCXRvFHi6DXbmeaMHH222XOLnaAFw2cpwADjqBxtO SfbyTiOVDmp4yTlHdPVu/b5/g/XTKpRvrE6TwX/yInh7/sGW3/opa3KqaZpllo+mwadp1ulvaQLs jiToB/MknJJPJJJPNW6+WrzU6spx2bbN1ojg/gzBNa/CnR7e4ikhnie5SSORSrIwuJAQQeQQeMV3 lcX8KNSm1n4dWGqXCxrPe3F3cSLGCFDPdSsQMknGT6mu0rIYUUUUAFFFFABRRRQAUUUUAFFFFABR RRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFF FABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAHP3n/JQ9G/7BV//wCjbSugrn7z/koejf8AYKv/AP0b aV0FABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAcH478Fal4o8VeDtUsp7SODRb03Fy szsGdd8TYTCkE4jPUjqK7yvK/inq2paf46+HdvZahd20F3qZS5jhmZFmXzYBhwDhhhiMH1PrXqlA BRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAcH8WfBWpePPCtrpelz2kM8V6lwzXTsqlQ jrgbVY5y47etd5Xlfx91bUtG8C2NxpeoXdjO2pxo0lrM0TFfKlOCVIOMgHHsK9UoAKKKKACiiigA ooooAKKKKACiiigAooooAKKKKACiiigDl/iJ4bvPF3gTUtDsJII7q68rY87EINsqOckAnop7VqeG tNm0bwrpGl3DRtPZWUNvI0ZJUsiBSRkA4yPQVzfxfv7zTPhbrN5YXc9pdR+RsmgkMbrmeMHDDkZB I/GtzwXPNdeBfD1xcSyTTy6ZbPJJIxZnYxKSSTySTzmgDcooooAKKKKACiiigAooooAKKKKACiii gAooooAKKKKACuD+E3grUvAfhW60vVJ7SaeW9e4VrV2ZQpRFwdyqc5Q9vSu8ryv4BatqWs+Bb641 TULu+nXU5EWS6maVgvlRHALEnGSTj3NAHqlFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQ Bz/jv/knniX/ALBV1/6KavAP2cf+Sh6h/wBgqT/0bFXv/jv/AJJ54l/7BV1/6KavAP2cf+Sh6h/2 CpP/AEbFQB9P0UUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXB6V4K1Kx+MuueMJZ7Q6f f2S28Uau3mhgIRlhtxj923QnqPw7yvK9C1bUpv2jfE+ly6hdvp8OmI8Vo0zGJG22/KpnAPzNyB3P rQB6pRRRQAUUUUAFFFFABRRRQAUUUUAfOXx+/wCR7sf+wZH/AOjZa9x8F/8AIieHv+wZbf8Aopa8 O+P3/I92P/YMj/8ARste4+C/+RE8Pf8AYMtv/RS19Vmv/InwphD+JI3KKKK+VNzD8af8iJ4h/wCw Zc/+imrw74A/8j3ff9gyT/0bFXuPjT/kRPEP/YMuf/RTV4d8Af8Ake77/sGSf+jYq+qyr/kT4owq fxIn0bXB+O/BWpeKPFXg7VLKe0jg0W9NxcrM7BnXfE2EwpBOIz1I6iu8ryv4p6tqWn+Ovh3b2WoX dtBd6mUuY4ZmRZl82AYcA4YYYjB9T618qbnqlFFFABRRRQAUUUUAFFFFABRRRQB4d+0T/wAy3/29 f+0qvfDf4b+Etf8AAGmanqek+feT+b5kn2iVd22V1HCsB0A7VR/aJ/5lv/t6/wDaVdz8Hv8Aklej f9t//R8lfYVa9Whw/QlSk4vmeza6z7HOknVdw/4U94D/AOgF/wCTc/8A8XR/wp7wH/0Av/Juf/4u u4or53+1Md/z+n/4E/8AM25I9jh/+FPeA/8AoBf+Tc//AMXXg1lZwad8Z7extY/LtrbxCsMSZJ2o twABk8ngDrX1jXyr/wA12/7mb/25r6Th7F4iuq6rVHK0erb/ADMasUrWR9VVwfxZ8Fal488K2ul6 XPaQzxXqXDNdOyqVCOuBtVjnLjt613leV/H3VtS0bwLY3Gl6hd2M7anGjSWszRMV8qU4JUg4yAce wr406D1SiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK5f4ieG7zxd4E1LQ7CSCO6uvK2 POxCDbKjnJAJ6Ke1dRXD/F+/vNM+Fus3lhdz2l1H5GyaCQxuuZ4wcMORkEj8aAOk8NabNo3hXSNL uGjaeysobeRoySpZECkjIBxkegrUrD8FzzXXgXw9cXEsk08umWzySSMWZ2MSkkk8kk85rcoAKKKK ACiiigAooooAKKKKACiiigAooooAKKKKACiiigDi/hRps2jfDqw0u4aNp7K4u7eRoySpZLqVSRkA 4yPQV2lcH8GZ5rr4U6PcXEsk08r3LySSMWZ2NxISSTySTzmu8oAKKKKACiiigAooooAKKKKACiii gAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKA CiiigAooooAKKK8v+LXiTXYLzQvCXhW68jV9ZlZZJY2BeGHG3JAUsqnczeYMFfKbHfAB6hRXhepf AFtF0Zb/AMI67qS+JLZAyu0yxLKdpDqhUAxlsnGWI7E4O4anjjxZ4u034deHdJKfYfGWtyrYvGro znHyNIki4jRmJjPX5fMOOV3AA9gorw++/Z5sNP0OS70TWNVbxDbRCW2cPGiPOmCNowCmSMA7/lyD k45sf8LavP8AhQ3/AAkX2yD/AISHzf7P3fZzt+0bs5xjbu8n95n7m7jH8NAHtFFeH2P7PNhqGhx3 et6xqq+IbmIy3Ll43RJ3yTuGCXwTgnf82CcjPFzwd8RtS0/4ZeJm8RXMb694Zd7ZhMjOWbGyESMp w5MoZCwPRQSedxAPZKK8H8MfBqDxxocPinxhq2qvq+q/6U3kyRKBG3+r/hbquCAMBQQu0ba6D4S6 pqmk65rvw91u9+0zaLtbT2dPne29SQSAoDREKTkb8dFwoB3F5/yUPRv+wVf/APo20roK5+8/5KHo 3/YKv/8A0baV0FABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAcf4w0Dw3q/iHwxea3q /wBivrC783ToftMcf2mTfGdu1gS/KoMLg/N7iuwrx/4v/wDJQ/hj/wBhU/8Ao23r2CgAooooAKKK KACiiigAooooAKKKKACiiigAooooAKKKKAOP+I+geG/Efh63s/FGr/2XYpdrKk32mODdIEcBd0gI PBY468e1dhXj/wC0d/yTzT/+wrH/AOipa9goAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACi iigDn/G2laPrfhC+07X7/wCwaZN5fnXPnJFsxIrL8zgqMsFHPrWhoVrZ2Ph7TLPTrj7RYwWkUVvN vD+ZGqAK24cHIAORwa4/42/8kh13/t3/APSiOug8Cf8AJPPDX/YKtf8A0UtAHQUUUUAFFFFABRRR QAUUUUAFFFFABRRRQAUUUUAFFFFABXH/AA40Dw34c8PXFn4X1f8AtSxe7aV5vtMc+2QogK7owAOA px15967CvH/2cf8Aknmof9hWT/0VFQB7BRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAc /wCO/wDknniX/sFXX/opq8A/Zx/5KHqH/YKk/wDRsVe/+O/+SeeJf+wVdf8Aopq8A/Zx/wCSh6h/ 2CpP/RsVAH0/RRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFcfp2geG7f4oatrltq/m+I bm0WK6sPtMbeVGBFhvLA3rwick4+b3FdhXj/AIe/5Oh8Wf8AYKj/APQbWgD2CiiigAooooAKKKKA CiiigAooooA+cvj9/wAj3Y/9gyP/ANGy17j4L/5ETw9/2DLb/wBFLXh3x+/5Hux/7Bkf/o2WvcfB f/IieHv+wZbf+ilr6rNf+RPhTCH8SRuUUUV8qbmH40/5ETxD/wBgy5/9FNXh3wB/5Hu+/wCwZJ/6 Nir3Hxp/yIniH/sGXP8A6KavDvgD/wAj3ff9gyT/ANGxV9VlX/InxRhU/iRPo2uP8YaB4b1fxD4Y vNb1f7FfWF35unQ/aY4/tMm+M7drAl+VQYXB+b3FdhXj/wAX/wDkofwx/wCwqf8A0bb18qbnsFFF FABRRRQAUUUUAFFFFABRRRQB4d+0T/zLf/b1/wC0q7n4Pf8AJK9G/wC2/wD6Pkrhv2if+Zb/AO3r /wBpV3Pwe/5JXo3/AG3/APR8lfVYv/knqH+N/nMwj/GZ3FFFFfKm4V8q/wDNdv8AuZv/AG5r6qr5 V/5rt/3M3/tzX1XDH/MR/gMK3Q+qq4/4j6B4b8R+Hrez8Uav/Zdil2sqTfaY4N0gRwF3SAg8Fjjr x7V2FeP/ALR3/JPNP/7Csf8A6Klr5U3PYKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigA rn/G2laPrfhC+07X7/7Bpk3l+dc+ckWzEisvzOCoywUc+tdBXn/xt/5JDrv/AG7/APpRHQB2GhWt nY+HtMs9OuPtFjBaRRW828P5kaoArbhwcgA5HBrQrn/An/JPPDX/AGCrX/0UtdBQAUUUUAFFFFAB RRRQAUUUUAFFFFABRRRQAUUUUAFFFFAHH/DC1s7HwFa2enXH2ixgu72K3m3h/MjW6lCtuHByADkc Guwrz/4Jf8kh0L/t4/8ASiSvQKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAC iiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACvB/iVp+qar8f vD1ho2o/2bfXGlGNbsDJiQm48wr/ALWzdjGOccr1HvFcP8RPBeqeJv7J1Pw/q39m67pErSWkjnEb B9ocNgE9FHYgjKkENkAHB+L/AILw+H9G1HxT4d8R6zFrVkkl5JcXVyC0ihWMmHRVYOQTzk55B65G ZrXiG48VP8GdYvFxdTagyTHI+d0uII2fgADcVLYA4zjtW3qVt8ZfGtuugarpum6Dpl24W7vbWRSw iwdykCZiQemABngEhS1dR4o+FNjqvwytvCGk3ElqNPcT2ckzbw8oD58w4zhjI5O3GCQQMDaQD0Sv kD/m3r/ua/8A20r0++f4369ocmgXmhaVbw3kQtbi/MsW/Y2FdmAlYcjOdqdztAOK7j/hWtn/AMKo /wCED/tCfyfKx9r2Dd5nmebu2/3d/wDDnO3jdn5qAO4r5gvv+QH8a/8AsK2//pbJXX2L/G/QdDj0 Cz0LSriGziNrb34li37FyqMoMqjgYxuTsNwJzXaeC/htD4a+HN54WvLySd9SSU3ssOAFaWMIwjyO gUDBI5OTgZ2gA3PAn/JPPDX/AGCrX/0Utef+Hv8Ak6HxZ/2Co/8A0G1rP0fT/i/4Bs38OaHo+laz pNtK5tbuZkQlGO7GPNQjkkkEHBJAJGK7D4W+CNR8LWeparrt152u63KLm9RAuyJss20bRgtl2JI+ XsOBkgGpr0epS+OtEXS7u0tp/wCzL4s91bNOpXzbTgKsiEHOOc9jxzxc+x+MP+g7of8A4Jpv/kqi 8/5KHo3/AGCr/wD9G2ldBQBlxwa8NLmjl1LTW1AvmKddPdYlXjho/OJY/e5DjqOOOaf2Pxh/0HdD /wDBNN/8lV0FFAGfqcOsS+V/ZN9Y2uM+Z9rs3uN3TGNsqY79c5yOmOa9jbeJI7yNr/VdKntRnfHB pkkTtwcYYzsBzj+E+nHWtiigDHvrbxJJeSNYarpUFqcbI59MkldeBnLCdQec/wAI9OetWNMh1iLz f7WvrG6zjy/slm9vt65zulfPbpjGD1zxoUUAc/8AY/GH/Qd0P/wTTf8AyVWh5Osf2P5X26x/tP8A 5+Psb+T97/nl5u77vH3+vPtWhRQBz/2Pxh/0HdD/APBNN/8AJVaGpw6xL5X9k31ja4z5n2uze43d MY2ypjv1znI6Y50KKAMextvEkd5G1/qulT2ozvjg0ySJ24OMMZ2A5x/CfTjrRfW3iSS8kaw1XSoL U42Rz6ZJK68DOWE6g85/hHpz1rYooAz9Mh1iLzf7WvrG6zjy/slm9vt65zulfPbpjGD1zxn/AGPx h/0HdD/8E03/AMlV0FFAGf5Osf2P5X26x/tP/n4+xv5P3v8Anl5u77vH3+vPtWf9j8Yf9B3Q/wDw TTf/ACVXQUUAef8AxD1mz03xD4Ts5bexe+vrtorKa70oXnkSb4gGDedGY+WU5G4nA6Y56ixtvEkd 5G1/qulT2ozvjg0ySJ24OMMZ2A5x/CfTjrXB/FPSdS1Dx18O7iy0+7uYLTUy9zJDCzrCvmwHLkDC jCk5PofSvVKAMe+tvEkl5I1hqulQWpxsjn0ySV14GcsJ1B5z/CPTnrVjTIdYi83+1r6xus48v7JZ vb7euc7pXz26Yxg9c8aFFAHP/Y/GH/Qd0P8A8E03/wAlVoeTrH9j+V9usf7T/wCfj7G/k/e/55eb u+7x9/rz7VoUUAc/9j8Yf9B3Q/8AwTTf/JVaGpw6xL5X9k31ja4z5n2uze43dMY2ypjv1znI6Y50 KKAMextvEkd5G1/qulT2ozvjg0ySJ24OMMZ2A5x/CfTjrRfW3iSS8kaw1XSoLU42Rz6ZJK68DOWE 6g85/hHpz1rYooAz9Mh1iLzf7WvrG6zjy/slm9vt65zulfPbpjGD1zxn/Y/GH/Qd0P8A8E03/wAl V0FFAGf5Osf2P5X26x/tP/n4+xv5P3v+eXm7vu8ff68+1Z/2Pxh/0HdD/wDBNN/8lV0FFAGfqcOs S+V/ZN9Y2uM+Z9rs3uN3TGNsqY79c5yOmOa9jbeJI7yNr/VdKntRnfHBpkkTtwcYYzsBzj+E+nHW tiigDHvrbxJJeSNYarpUFqcbI59MkldeBnLCdQec/wAI9OetWNMh1iLzf7WvrG6zjy/slm9vt65z ulfPbpjGD1zxoUUAeX/EfVLzw54et7zxRNoeqWL3axJD/wAI6Z9shRyG2yXYA4DDPXn3r0DydY/s fyvt1j/af/Px9jfyfvf88vN3fd4+/wBefavO/j7pOpaz4FsbfS9Pu76ddTjdo7WFpWC+VKMkKCcZ IGfcV6pQBz/2Pxh/0HdD/wDBNN/8lVoanDrEvlf2TfWNrjPmfa7N7jd0xjbKmO/XOcjpjnQooAx7 G28SR3kbX+q6VPajO+ODTJInbg4wxnYDnH8J9OOtF9beJJLyRrDVdKgtTjZHPpkkrrwM5YTqDzn+ EenPWtiigDP0yHWIvN/ta+sbrOPL+yWb2+3rnO6V89umMYPXPGf9j8Yf9B3Q/wDwTTf/ACVXQUUA Z/k6x/Y/lfbrH+0/+fj7G/k/e/55ebu+7x9/rz7Vn/Y/GH/Qd0P/AME03/yVXQUUAZ+pw6xL5X9k 31ja4z5n2uze43dMY2ypjv1znI6Y5r2Nt4kjvI2v9V0qe1Gd8cGmSRO3BxhjOwHOP4T6cda2KKAM e+tvEkl5I1hqulQWpxsjn0ySV14GcsJ1B5z/AAj0561Y0yHWIvN/ta+sbrOPL+yWb2+3rnO6V89u mMYPXPGhRQBz/wBj8Yf9B3Q//BNN/wDJVaHk6x/Y/lfbrH+0/wDn4+xv5P3v+eXm7vu8ff68+1aF FAHP/Y/GH/Qd0P8A8E03/wAlVoanDrEvlf2TfWNrjPmfa7N7jd0xjbKmO/XOcjpjnQooA4fxTeXm g+HLvU/F02latoUOz7TZQaMd8uXVUx5lwy8OVPIPTjnFaGntrGpaTYX3h++0qw0i4tIZbS0n0l3e GNo1IUlLhV49AAB05xk5/wAX7C81P4W6zZ2FpPd3UnkbIYIzI7YnjJwo5OACfwrc8FwTWvgXw9b3 EUkM8WmWySRyKVZGESggg8gg8YoAuaZDrEXm/wBrX1jdZx5f2Sze329c53Svnt0xjB654z/sfjD/ AKDuh/8Agmm/+Sq6CigDP8nWP7H8r7dY/wBp/wDPx9jfyfvf88vN3fd4+/159qz/ALH4w/6Duh/+ Cab/AOSq6CigDP1OHWJfK/sm+sbXGfM+12b3G7pjG2VMd+uc5HTHNextvEkd5G1/qulT2ozvjg0y SJ24OMMZ2A5x/CfTjrWxRQBj31t4kkvJGsNV0qC1ONkc+mSSuvAzlhOoPOf4R6c9asaZDrEXm/2t fWN1nHl/ZLN7fb1zndK+e3TGMHrnjQooA5/7H4w/6Duh/wDgmm/+Sq0PJ1j+x/K+3WP9p/8APx9j fyfvf88vN3fd4+/159q0KKAOf+x+MP8AoO6H/wCCab/5KrQ1OHWJfK/sm+sbXGfM+12b3G7pjG2V Md+uc5HTHOhRQBj2Nt4kjvI2v9V0qe1Gd8cGmSRO3BxhjOwHOP4T6cdaL628SSXkjWGq6VBanGyO fTJJXXgZywnUHnP8I9OetbFFAGfpkOsReb/a19Y3WceX9ks3t9vXOd0r57dMYweueM/7H4w/6Duh /wDgmm/+Sq6CigDP8nWP7H8r7dY/2n/z8fY38n73/PLzd33ePv8AXn2rz/4capeeI/D1xeeF5tD0 uxS7aJ4f+EdMG6QIhLbY7sg8FRnrx7V6hXlfwC0nUtG8C31vqmn3djO2pyOsd1C0TFfKiGQGAOMg jPsaAPRNTh1iXyv7JvrG1xnzPtdm9xu6YxtlTHfrnOR0xzXsbbxJHeRtf6rpU9qM744NMkiduDjD GdgOcfwn0461sUUAY99beJJLyRrDVdKgtTjZHPpkkrrwM5YTqDzn+EenPWrGmQ6xF5v9rX1jdZx5 f2Sze329c53Svnt0xjB6540KKAOf+x+MP+g7of8A4Jpv/kqtDydY/sfyvt1j/af/AD8fY38n73/P Lzd33ePv9efatCigDn/sfjD/AKDuh/8Agmm/+Sq0NTh1iXyv7JvrG1xnzPtdm9xu6YxtlTHfrnOR 0xzoUUAY9jbeJI7yNr/VdKntRnfHBpkkTtwcYYzsBzj+E+nHWi+tvEkl5I1hqulQWpxsjn0ySV14 GcsJ1B5z/CPTnrWxRQBn6ZDrEXm/2tfWN1nHl/ZLN7fb1zndK+e3TGMHrnjP+x+MP+g7of8A4Jpv /kqugooAz/J1j+x/K+3WP9p/8/H2N/J+9/zy83d93j7/AF59qz/sfjD/AKDuh/8Agmm/+Sq6CigD P1OHWJfK/sm+sbXGfM+12b3G7pjG2VMd+uc5HTHNextvEkd5G1/qulT2ozvjg0ySJ24OMMZ2A5x/ CfTjrWxRQBxfxBg15vCHiSSDUtNTT/7MuCYH092l2+Sdw8wTAZPODs4yODjnxT9nH/koeof9gqT/ ANGxV7/47/5J54l/7BV1/wCimrwD9nH/AJKHqH/YKk/9GxUAe/8A2Pxh/wBB3Q//AATTf/JVaHk6 x/Y/lfbrH+0/+fj7G/k/e/55ebu+7x9/rz7VoUUAc/8AY/GH/Qd0P/wTTf8AyVWhqcOsS+V/ZN9Y 2uM+Z9rs3uN3TGNsqY79c5yOmOdCigDHsbbxJHeRtf6rpU9qM744NMkiduDjDGdgOcfwn0460X1t 4kkvJGsNV0qC1ONkc+mSSuvAzlhOoPOf4R6c9a2KKAM/TIdYi83+1r6xus48v7JZvb7euc7pXz26 Yxg9c8Z/2Pxh/wBB3Q//AATTf/JVdBRQBn+TrH9j+V9usf7T/wCfj7G/k/e/55ebu+7x9/rz7Vn/ AGPxh/0HdD/8E03/AMlV0FFAGfqcOsS+V/ZN9Y2uM+Z9rs3uN3TGNsqY79c5yOmOa9jbeJI7yNr/ AFXSp7UZ3xwaZJE7cHGGM7Ac4/hPpx1rYooAx7628SSXkjWGq6VBanGyOfTJJXXgZywnUHnP8I9O etWNMh1iLzf7WvrG6zjy/slm9vt65zulfPbpjGD1zxoUUAc/9j8Yf9B3Q/8AwTTf/JVaHk6x/Y/l fbrH+0/+fj7G/k/e/wCeXm7vu8ff68+1aFFAHP8A2Pxh/wBB3Q//AATTf/JVc++s2d98UNR0PQLe xsPENraebfX93pQm8+MiHaokSZH4DLwwI4HTAz6BXlehaTqUP7RvifVJdPu00+bTESK7aFhE7bbf hXxgn5W4B7H0oA7yxtvEkd5G1/qulT2ozvjg0ySJ24OMMZ2A5x/CfTjrRfW3iSS8kaw1XSoLU42R z6ZJK68DOWE6g85/hHpz1rYooAz9Mh1iLzf7WvrG6zjy/slm9vt65zulfPbpjGD1zxn/AGPxh/0H dD/8E03/AMlV0FFAGf5Osf2P5X26x/tP/n4+xv5P3v8Anl5u77vH3+vPtWf9j8Yf9B3Q/wDwTTf/ ACVXQUUAZ+pw6xL5X9k31ja4z5n2uze43dMY2ypjv1znI6Y5r2Nt4kjvI2v9V0qe1Gd8cGmSRO3B xhjOwHOP4T6cda2KKAMe+tvEkl5I1hqulQWpxsjn0ySV14GcsJ1B5z/CPTnrVjTIdYi83+1r6xus 48v7JZvb7euc7pXz26Yxg9c8aFFAHzN8bI9Si8Z2a6pd2lzP/Z6FXtbZoFC+ZJwVaRyTnPOe4445 9x8JR6k3w10JLe7tI7w6fbmOWS2Z41XapAKCQEnbxncMnnAHy1418fv+R7sf+wZH/wCjZa9x8F/8 iJ4e/wCwZbf+ilr6rNf+RPhTCH8SRH9j8Yf9B3Q//BNN/wDJVaGpw6xL5X9k31ja4z5n2uze43dM Y2ypjv1znI6Y50KK+VNzi/E9t4kj8Ia81/qulT2o0y63xwaZJE7fuXxhjOwHOP4T6cda8a+CcepS +M7xdLu7S2n/ALPcs91bNOpXzI+AqyIQc45z2PHPHvvjT/kRPEP/AGDLn/0U1eHfAH/ke77/ALBk n/o2Kvqsq/5E+KMKn8SJ77pkOsReb/a19Y3WceX9ks3t9vXOd0r57dMYweuePP8Axhql5pHiHwxZ 63Nod7fX935WnTf8I6ZPs0m+MbtzXYKcshyuT8vsK9Qryv4p6TqWoeOvh3cWWn3dzBaamXuZIYWd YV82A5cgYUYUnJ9D6V8qbnonk6x/Y/lfbrH+0/8An4+xv5P3v+eXm7vu8ff68+1Z/wBj8Yf9B3Q/ /BNN/wDJVdBRQBn6nDrEvlf2TfWNrjPmfa7N7jd0xjbKmO/XOcjpjmvY23iSO8ja/wBV0qe1Gd8c GmSRO3BxhjOwHOP4T6cda2KKAMe+tvEkl5I1hqulQWpxsjn0ySV14GcsJ1B5z/CPTnrVjTIdYi83 +1r6xus48v7JZvb7euc7pXz26Yxg9c8aFFAHP/Y/GH/Qd0P/AME03/yVWh5Osf2P5X26x/tP/n4+ xv5P3v8Anl5u77vH3+vPtWhRQBz/ANj8Yf8AQd0P/wAE03/yVWhqcOsS+V/ZN9Y2uM+Z9rs3uN3T GNsqY79c5yOmOdCigD5++OsOsRf2B/a19Y3WftHl/ZLN7fb/AKrOd0r57dMYweueOx+Flt4kk+G+ ktYarpUFqfO2Rz6ZJK6/vnzlhOoPOf4R6c9a579on/mW/wDt6/8AaVdz8Hv+SV6N/wBt/wD0fJX1 WL/5J6h/jf5zMI/xmdRpkOsReb/a19Y3WceX9ks3t9vXOd0r57dMYweueM/7H4w/6Duh/wDgmm/+ Sq6CivlTcz/J1j+x/K+3WP8Aaf8Az8fY38n73/PLzd33ePv9efavl7Zef8Ll2efB9u/4SDHneSfL 8z7R97Zuztzzt3Zxxu719Y18q/8ANdv+5m/9ua+q4Y/5iP8AAYVuh9NanDrEvlf2TfWNrjPmfa7N 7jd0xjbKmO/XOcjpjnh/HWrf8IxpNpfeNxpWt6Q12IvskGh5fzDG5VgZbhlXGDzgnnHfI9Iryv4+ 6TqWs+BbG30vT7u+nXU43aO1haVgvlSjJCgnGSBn3FfKm53l9beJJLyRrDVdKgtTjZHPpkkrrwM5 YTqDzn+EenPWrGmQ6xF5v9rX1jdZx5f2Sze329c53Svnt0xjB6540KKAOf8AsfjD/oO6H/4Jpv8A 5KrQ8nWP7H8r7dY/2n/z8fY38n73/PLzd33ePv8AXn2rQooA5/7H4w/6Duh/+Cab/wCSq0NTh1iX yv7JvrG1xnzPtdm9xu6YxtlTHfrnOR0xzoUUAY9jbeJI7yNr/VdKntRnfHBpkkTtwcYYzsBzj+E+ nHWi+tvEkl5I1hqulQWpxsjn0ySV14GcsJ1B5z/CPTnrWxRQBn6ZDrEXm/2tfWN1nHl/ZLN7fb1z ndK+e3TGMHrnjP8AsfjD/oO6H/4Jpv8A5KroKKAM/wAnWP7H8r7dY/2n/wA/H2N/J+9/zy83d93j 7/Xn2rP+x+MP+g7of/gmm/8AkqugooAz9Th1iXyv7JvrG1xnzPtdm9xu6YxtlTHfrnOR0xzXsbbx JHeRtf6rpU9qM744NMkiduDjDGdgOcfwn0461sUUAY99beJJLyRrDVdKgtTjZHPpkkrrwM5YTqDz n+EenPWrGmQ6xF5v9rX1jdZx5f2Sze329c53Svnt0xjB6540KKAOf+x+MP8AoO6H/wCCab/5KrP8 bX/9ifDi+vNfFjf+T5fnf8S3zYXzMoX9w8wzjK9ZOoz7V2FcP8X7C81P4W6zZ2FpPd3UnkbIYIzI 7YnjJwo5OACfwoAsaEPEl94e0y807VdDt7Ge0ilt4f7DkTy42QFV2i6wMAgYHAroNTh1iXyv7Jvr G1xnzPtdm9xu6YxtlTHfrnOR0xzT8FwTWvgXw9b3EUkM8WmWySRyKVZGESggg8gg8YrcoAx7G28S R3kbX+q6VPajO+ODTJInbg4wxnYDnH8J9OOtF9beJJLyRrDVdKgtTjZHPpkkrrwM5YTqDzn+EenP WtiigDP0yHWIvN/ta+sbrOPL+yWb2+3rnO6V89umMYPXPGf9j8Yf9B3Q/wDwTTf/ACVXQUUAZ/k6 x/Y/lfbrH+0/+fj7G/k/e/55ebu+7x9/rz7Vn/Y/GH/Qd0P/AME03/yVXQUUAZ+pw6xL5X9k31ja 4z5n2uze43dMY2ypjv1znI6Y5r2Nt4kjvI2v9V0qe1Gd8cGmSRO3BxhjOwHOP4T6cda2KKAMe+tv Ekl5I1hqulQWpxsjn0ySV14GcsJ1B5z/AAj0561Y0yHWIvN/ta+sbrOPL+yWb2+3rnO6V89umMYP XPGhRQBz/wBj8Yf9B3Q//BNN/wDJVaHk6x/Y/lfbrH+0/wDn4+xv5P3v+eXm7vu8ff68+1aFFAHP /Y/GH/Qd0P8A8E03/wAlVoanDrEvlf2TfWNrjPmfa7N7jd0xjbKmO/XOcjpjnQooA5/7H4w/6Duh /wDgmm/+SqPsfjD/AKDuh/8Agmm/+Sq6CigDi/hRcw3nw6sLq3jjjgmuLuSNI4RCqqbqUgBAzBAA fu7jjpk9a7SuD+DME1r8KdHt7iKSGeJ7lJI5FKsjC4kBBB5BB4xXeUAFFFFABRRRQAUUUUAFFFFA BRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBz95/yUPRv+wVf/APo20roK5+8/5KHo3/YK v/8A0baV0FABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAcH478a6l4X8VeDtLsoLSSD Wr029y0yMWRd8S5TDAA4kPUHoK7yuD8d+CtS8UeKvB2qWU9pHBot6bi5WZ2DOu+JsJhSCcRnqR1F d5QAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAHB/FnxrqXgPwra6ppcFpNPLepbst0j MoUo7ZG1lOcoO/rXeVwfxZ8Fal488K2ul6XPaQzxXqXDNdOyqVCOuBtVjnLjt613lABRRRQAUUUU AFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAcv8RPEl54R8CalrlhHBJdWvlbEnUlDulRDkAg9GPetT w1qU2s+FdI1S4WNZ72yhuJFjBChnQMQMknGT6msv4ieG7zxd4E1LQ7CSCO6uvK2POxCDbKjnJAJ6 Ke1anhrTZtG8K6Rpdw0bT2VlDbyNGSVLIgUkZAOMj0FAGpRRRQAUUUUAFFFFABRRRQAUUUUAFFFF ABRRRQAUUUUAFcH8JvGupePPCt1qmqQWkM8V69uq2qMqlQiNk7mY5y57+ld5XB/CbwVqXgPwrdaX qk9pNPLevcK1q7MoUoi4O5VOcoe3pQB3lFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBz /jv/AJJ54l/7BV1/6KavAP2cf+Sh6h/2CpP/AEbFXv8A47/5J54l/wCwVdf+imrwD9nH/koeof8A YKk/9GxUAfT9FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVweleNdSvvjLrng+WC0Gn2 FktxFIqN5pYiE4Y7sY/eN0A6D8e8rg9K8FalY/GXXPGEs9odPv7JbeKNXbzQwEIyw24x+7boT1H4 AHeUUUUAFFFFABRRRQAUUUUAFFFFAHzl8fv+R7sf+wZH/wCjZa9x8F/8iJ4e/wCwZbf+ilryr4+e GLuWSz8UQt5ltFEtnPGEOY/mdlckcbSW284wdvXdx0HwZ8cxa7ocXh653jUtNgwrFRtlgUhVIwAA VBVSDyeDk5OPrcdTeIyShUpaqHxeX9fr2OeLtVafU9Rooor5I6DD8af8iJ4h/wCwZc/+imrw74A/ 8j3ff9gyT/0bFXqPxY8W2Xhvwhc2UyPLd6tBNa28a8AArtZyegChhx1JIHTJHl3wDiuz43vJ4bff bLYtHPKSQI9zoVxgEFiV6EjgMc/Lg/XZZSnHJcROSspbedv+Dp6nPN/vEj6Nrg/HfjXUvC/irwdp dlBaSQa1em3uWmRiyLviXKYYAHEh6g9BXeVwfjvwVqXijxV4O1SyntI4NFvTcXKzOwZ13xNhMKQT iM9SOor5E6DvKKKKACiiigAooooAKKKKACiiigDw79on/mW/+3r/ANpV3Pwe/wCSV6N/23/9HyVx v7Qlldz2uh3UNrNJbW32jz5kjJSLcYgu4jhcngZ611XwXvILn4ZafDDJuktZZoZhgja5kZ8c9fld Tx619Vive4eo26Td/LWf+ZhH+Mz0CiiivlTcK+Vf+a7f9zN/7c19VV8swwS3Hx5KQxPI48Rs5VFJ IVbgsx47AAknsATX1XDDt9Yb/kMK3Q+pq4P4s+NdS8B+FbXVNLgtJp5b1LdlukZlClHbI2spzlB3 9a7yuD+LPgrUvHnhW10vS57SGeK9S4Zrp2VSoR1wNqsc5cdvWvlTc7yiiigAooooAKKKKACiiigA ooooAKKKKACiiigAooooAK5f4ieJLzwj4E1LXLCOCS6tfK2JOpKHdKiHIBB6Me9dRXL/ABE8N3ni 7wJqWh2EkEd1deVsediEG2VHOSAT0U9qANTw1qU2s+FdI1S4WNZ72yhuJFjBChnQMQMknGT6mtSs vw1ps2jeFdI0u4aNp7Kyht5GjJKlkQKSMgHGR6CtSgAooooAKKKKACiiigAooooAKKKKACiiigAo oooAKKKKAOL+FGpTaz8OrDVLhY1nvbi7uJFjBChnupWIGSTjJ9TXaVxfwo02bRvh1YaXcNG09lcX dvI0ZJUsl1KpIyAcZHoK7SgAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoooo AKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigA ooooAKKKKAOfvP8Akoejf9gq/wD/AEbaV0Fc/ef8lD0b/sFX/wD6NtK6CgAooooAKKKKACiiigAo oooAKKKKACiiigAooooAKKKKAPK/inq2paf46+HdvZahd20F3qZS5jhmZFmXzYBhwDhhhiMH1PrX qlcf4w0Dw3q/iHwxea3q/wBivrC783ToftMcf2mTfGdu1gS/KoMLg/N7iuwoAKKKKACiiigAoooo AKKKKACiiigAooooAKKKKACiiigDyv4+6tqWjeBbG40vULuxnbU40aS1maJivlSnBKkHGQDj2Feq Vx/xH0Dw34j8PW9n4o1f+y7FLtZUm+0xwbpAjgLukBB4LHHXj2rsKACiiigAooooAKKKKACiiigA ooooAKKKKACiiigAooooA4f4v395pnwt1m8sLue0uo/I2TQSGN1zPGDhhyMgkfjW54LnmuvAvh64 uJZJp5dMtnkkkYszsYlJJJ5JJ5zUfjbStH1vwhfadr9/9g0yby/OufOSLZiRWX5nBUZYKOfWtDQr WzsfD2mWenXH2ixgtIorebeH8yNUAVtw4OQAcjg0AaFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFF FFABRRRQAV5X8AtW1LWfAt9capqF3fTrqciLJdTNKwXyojgFiTjJJx7mvVK4/wCHGgeG/Dnh64s/ C+r/ANqWL3bSvN9pjn2yFEBXdGABwFOOvPvQB2FFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAB RRRQBz/jv/knniX/ALBV1/6KavAP2cf+Sh6h/wBgqT/0bFXv/jv/AJJ54l/7BV1/6KavAP2cf+Sh 6h/2CpP/AEbFQB9P0UUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXlehatqU37RvifS5d Qu30+HTEeK0aZjEjbbflUzgH5m5A7n1r1SuP07QPDdv8UNW1y21fzfENzaLFdWH2mNvKjAiw3lgb 14ROScfN7igDsKKKKACiiigAooooAKKKKACiiigDlfHfi/SvC+gXjXYsry5MS40ua4VHuI3YIflI JK4LZ+Uj5TXyrZ6pPpGspqWjyzWcsEpe3YuGdB2BOAG44PAB54wcV6P8fv8Ake7H/sGR/wDo2WuG 8I+GLvxf4kttItW8vzMtLOULLDGOSxA/ADOASQMjNfpWQ4ShhMvdeb0mryvtbtb7+l3c46snKdkd z/wv7xV/0D9G/wC/Mv8A8co/4X94q/6B+jf9+Zf/AI5Xcf8ACgfCv/QQ1n/v9F/8bo/4UD4V/wCg hrP/AH+i/wDjdeb9e4e/59/gy+Wt3PB/EXiLUvFOszapqk3mTycKq8JEg6Ig7KM/zJySSff/AII6 zpV14NXTLWOG2vLaVzLCZ1aWfhSZiAAduWCjIOAoGTivGfiH4Il8D+IRaLI89hcKZbWdlIJXOCjH GCy8Zx2KnAzgdP8AAH/ke77/ALBkn/o2KvTzilh8VlHPR+CKTjby0tYzptxqWZ9G15X8U9W1LT/H Xw7t7LULu2gu9TKXMcMzIsy+bAMOAcMMMRg+p9a9Urj/ABhoHhvV/EPhi81vV/sV9YXfm6dD9pjj +0yb4zt2sCX5VBhcH5vcV+aHadhRRRQAUUUUAFFFFABRRRQAUUUUAYfi7wxaeL/DdzpF03l+Zhop wgZoZByGAP4g4wSCRkZr5x8M67qXws8ez298sxgilMF/bRHAmQZ2uoYDOMh1PGQcZAY16z8afF+o eHNJtdNs4bZ4dXguYLhplYsq7UXK4YAHDnqD2r5ur7/hrA1KmCmq7vSney/Bu/Tb8mjlrSSlpuj7 Cg8deE7iCOZPEukhJFDqJLxEYAjPKsQQfYgEVJ/wmnhX/oZtG/8AA+L/AOKr45opvg6h0qv7kL6w +x9FfE/4p6fp+hvpnh3U0uNSu1x9qsplZbZM8neMjcQCAByM7sj5c8x8FPAP2+6j8Wah/wAe1tKy 2cDR582QDHmEkY2qTxjncvUbefHK7H4X+ILvQPHen/ZY4X/tCWOwl81SdsckqZK4I+bgYzke1dtX KHg8tqUMJK0nq2935eWn9XdyVU5ppyPrGvK/j7q2paN4FsbjS9Qu7GdtTjRpLWZomK+VKcEqQcZA OPYV6pXH/EfQPDfiPw9b2fijV/7LsUu1lSb7THBukCOAu6QEHgscdePavzI7TsKKKKACiiigAooo oAKKKKACiiigAooooAKKKKACiiigArh/i/f3mmfC3Wbywu57S6j8jZNBIY3XM8YOGHIyCR+NdxXP +NtK0fW/CF9p2v3/ANg0yby/OufOSLZiRWX5nBUZYKOfWgCTwXPNdeBfD1xcSyTTy6ZbPJJIxZnY xKSSTySTzmtys/QrWzsfD2mWenXH2ixgtIorebeH8yNUAVtw4OQAcjg1oUAFFFFABRRRQAUUUUAF FFFABRRRQAUUUUAFFFFABRRRQBwfwZnmuvhTo9xcSyTTyvcvJJIxZnY3EhJJPJJPOa7yuP8Ahha2 dj4CtbPTrj7RYwXd7Fbzbw/mRrdShW3Dg5AByODXYUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUU UUAFFFFABRRRQAUUUUAFFFFABRRRQBz95/yUPRv+wVf/APo20roK5+8/5KHo3/YKv/8A0baV0FAB RRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAeP/F//AJKH8Mf+wqf/AEbb17BXH+MNf8N6 R4h8MWet6R9tvr+78rTpvs0cn2aTfGN25iCnLIcrk/L7CuwoAKKKKACiiigAooooAKKKKACiiigA ooooAKKKKACiiigDx/8AaO/5J5p//YVj/wDRUtewVx/xH1/w34c8PW954o0j+1LF7tYkh+zRz7ZC jkNtkIA4DDPXn3rsKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA8/+Nv8AySHXf+3f /wBKI66DwJ/yTzw1/wBgq1/9FLR421XR9E8IX2o6/Yfb9Mh8vzrbyUl35kVV+VyFOGKnn0rQ0K6s 77w9pl5p1v8AZ7Ge0ilt4dgTy42QFV2jgYBAwOBQBoUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUU UUAFFFFABXj/AOzj/wAk81D/ALCsn/oqKvYK4/4ca/4b8R+Hri88L6R/Zdil20Tw/Zo4N0gRCW2x kg8FRnrx7UAdhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAc/wCO/wDknniX/sFXX/op q8A/Zx/5KHqH/YKk/wDRsVe/+O/+SeeJf+wVdf8Aopq8A/Zx/wCSh6h/2CpP/RsVAH0/RRRQAUUU UAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFeP+Hv+TofFn/YKj/9Bta9grj9O1/w3cfFDVtDttI8 rxDbWiy3V/8AZo182MiLC+YDvbh04Ix8vsKAOwooooAKKKKACiiigAooooAKKKKAOH8bfC/SvG9+ NQur29tryO2+zxGIqYxgswLKVyeWOQGGR6datfDzwRF4H8PG0aRJ7+4YS3U6qAC2MBFOMlV5xnuW OBnA66iu2WYYmWH+qyn7nb0J5I35uoUUUVxFGH4u8MWni/w3c6RdN5fmYaKcIGaGQchgD+IOMEgk ZGa5H4cfClfB041W/vnm1Yq8ZS2kIgVCRgYwC54zzxk9MqGr0qiu2lmGJpYeWGhK0Jbr+u5Lgm+Y K8f+L/8AyUP4Y/8AYVP/AKNt69grj/GGv+G9I8Q+GLPW9I+231/d+Vp032aOT7NJvjG7cxBTlkOV yfl9hXEUdhRRRQAUUUUAFFFFABRRRQAUUUUAeOfHfRdV1j+wP7M0y9vfK+0eZ9mgaTZnysZ2g4zg /ka4f4SeAf8AhLNZOpX3GladKjOjR7hcydRHyNpXgFu+CBj5sj6bqOGCK3QpDEkaFmcqigAsxLMe O5JJJ7kk19Bh+IKtDAfU6cbPpL1bb/OyMnSTnzM8S/4Z2/6mn/yn/wD22j/hnb/qaf8Ayn//AG2v caKz/wBZM0/5+/8Aksf8g9jDseMj4CRQ+HtRtF1lJ7+Vo5bWdrURiNkDgox3MdrbxnGMFVODjFeW +B9F1Wbx3pfl6Zev9h1O3+17YGP2fEoz5nHyY2t1x0PpX1xUccEUTyvHEiPK2+RlUAu2AuT6nCqM +gA7V0YfibFQp1I1vfctulunRdvx9WJ0Y3ViSvH/ANo7/knmn/8AYVj/APRUtewVx/xH1/w34c8P W954o0j+1LF7tYkh+zRz7ZCjkNtkIA4DDPXn3r5s2OwooooAKKKKACiiigAooooAKKKKACiiigAo oooAKKKKACvP/jb/AMkh13/t3/8ASiOvQK5/xtquj6J4QvtR1+w+36ZD5fnW3kpLvzIqr8rkKcMV PPpQAeBP+SeeGv8AsFWv/opa6Cs/QrqzvvD2mXmnW/2exntIpbeHYE8uNkBVdo4GAQMDgVoUAFFF FABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQB5/8ABL/kkOhf9vH/AKUSV6BXH/DC6s77wFa3 mnW/2exnu72W3h2BPLja6lKrtHAwCBgcCuwoAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACi iigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKK KACiiigAooooAKKKKACiiigDn7z/AJKHo3/YKv8A/wBG2ldBXP3n/JQ9G/7BV/8A+jbSugoAKKKK ACiisPwXPNdeBfD1xcSyTTy6ZbPJJIxZnYxKSSTySTzmgDcooooAKKKKACiiigAooooAKKw/Bc81 14F8PXFxLJNPLpls8kkjFmdjEpJJPJJPOa3KACiiigDyv4p6TqWoeOvh3cWWn3dzBaamXuZIYWdY V82A5cgYUYUnJ9D6V6pXB+O/GupeF/FXg7S7KC0kg1q9NvctMjFkXfEuUwwAOJD1B6Cu8oAKKKKA CiisPwnPNc6PcPPLJK41O/QM7FiFW7mVRz2CgADsABQBuUUUUAFFFFABRRRQAUUUUAFFYehTzTax 4nSWWR0h1NEiVmJCL9kt2wvoNzMcDuSe9blABRRRQB5X8fdJ1LWfAtjb6Xp93fTrqcbtHawtKwXy pRkhQTjJAz7ivVK4P4s+NdS8B+FbXVNLgtJp5b1LdlukZlClHbI2spzlB39a7ygAooooAKKKw9Cn mm1jxOkssjpDqaJErMSEX7JbthfQbmY4Hck96ANyiiigAooooAKKKKACiiigAorDtZ5m8datbtLI YE0yydIyx2qzS3QYgdASFUE99o9K3KACiiigDh/i/YXmp/C3WbOwtJ7u6k8jZDBGZHbE8ZOFHJwA T+FbnguCa18C+Hre4ikhni0y2SSORSrIwiUEEHkEHjFU/iJ4kvPCPgTUtcsI4JLq18rYk6kod0qI cgEHox71qeGtSm1nwrpGqXCxrPe2UNxIsYIUM6BiBkk4yfU0AalFFFABRRWHdTzL460m3WWQQPpl 67xhjtZlltQpI6EgMwB7bj60AblFFFABRRRQAUUUUAFFFFABRWHdTzL460m3WWQQPpl67xhjtZll tQpI6EgMwB7bj61uUAFFFFABXlfwC0nUtG8C31vqmn3djO2pyOsd1C0TFfKiGQGAOMgjPsa9Urg/ hN411Lx54VutU1SC0hnivXt1W1RlUqERsnczHOXPf0oA7yiiigAoorD12eaHWPDCRSyIk2pukqqx Adfslw2G9RuVTg9wD2oA3KKKKACiiigAooooAKKKKACisPxZPNbaPbvBLJE51OwQsjFSVa7hVhx2 KkgjuCRW5QAUUUUAc/47/wCSeeJf+wVdf+imrwD9nH/koeof9gqT/wBGxV7/AOO/+SeeJf8AsFXX /opq8A/Zx/5KHqH/AGCpP/RsVAH0/RRRQAUUVh+LJ5rbR7d4JZInOp2CFkYqSrXcKsOOxUkEdwSK ANyiiigAooooAKKKKACiiigAorD8aTzWvgXxDcW8skM8WmXLxyRsVZGETEEEcgg85rcoAKKKKACv K9C0nUof2jfE+qS6fdpp82mIkV20LCJ222/CvjBPytwD2PpXqlcHpXjXUr74y654PlgtBp9hZLcR SKjeaWIhOGO7GP3jdAOg/EA7yiiigAooooAKKw/Bc8114F8PXFxLJNPLpls8kkjFmdjEpJJPJJPO a3KACiiigAooooAKKKKACiisPwXPNdeBfD1xcSyTTy6ZbPJJIxZnYxKSSTySTzmgDcooooAK8r+K ek6lqHjr4d3Flp93cwWmpl7mSGFnWFfNgOXIGFGFJyfQ+leqVwfjvxrqXhfxV4O0uygtJINavTb3 LTIxZF3xLlMMADiQ9QegoA7yiiigAooooAKKw/Cc81zo9w88skrjU79AzsWIVbuZVHPYKAAOwAFb lABRRRQAUUUUAFFFFABRRWHoU802seJ0llkdIdTRIlZiQi/ZLdsL6DczHA7knvQBuUUUUAFeV/H3 SdS1nwLY2+l6fd3066nG7R2sLSsF8qUZIUE4yQM+4r1SuD+LPjXUvAfhW11TS4LSaeW9S3ZbpGZQ pR2yNrKc5Qd/WgDvKKKKACiiigAorD0KeabWPE6SyyOkOpokSsxIRfslu2F9BuZjgdyT3rcoAKKK KACiiigAooooAKKKw7WeZvHWrW7SyGBNMsnSMsdqs0t0GIHQEhVBPfaPSgDcooooAK4f4v2F5qfw t1mzsLSe7upPI2QwRmR2xPGThRycAE/hXcVy/wARPEl54R8CalrlhHBJdWvlbEnUlDulRDkAg9GP egC54LgmtfAvh63uIpIZ4tMtkkjkUqyMIlBBB5BB4xW5WX4a1KbWfCukapcLGs97ZQ3EixghQzoG IGSTjJ9TWpQAUUUUAFFYd1PMvjrSbdZZBA+mXrvGGO1mWW1CkjoSAzAHtuPrW5QAUUUUAFFFFABR RRQAUUVh3U8y+OtJt1lkED6Zeu8YY7WZZbUKSOhIDMAe24+tAG5RRRQAUUUUAcH8GYJrX4U6Pb3E UkM8T3KSRyKVZGFxICCDyCDxiu8ri/hRqU2s/Dqw1S4WNZ724u7iRYwQoZ7qViBkk4yfU12lABRR RQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFF ABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAc/ef8lD0b/sFX/8A 6NtK6Cs/U9C0fW/K/tbSrG/8nPl/a7dJdmcZxuBxnA6egrP/AOEE8H/9Cpof/guh/wDiaAOgorn/ APhBPB//AEKmh/8Aguh/+Jo/4QTwf/0Kmh/+C6H/AOJoA6Cuf8Cf8k88Nf8AYKtf/RS0f8IJ4P8A +hU0P/wXQ/8AxNH/AAgng/8A6FTQ/wDwXQ//ABNAHQUVz/8Awgng/wD6FTQ//BdD/wDE0f8ACCeD /wDoVND/APBdD/8AE0AdBRXP/wDCCeD/APoVND/8F0P/AMTR/wAIJ4P/AOhU0P8A8F0P/wATQB0F Fc//AMIJ4P8A+hU0P/wXQ/8AxNH/AAgng/8A6FTQ/wDwXQ//ABNAHQUVz/8Awgng/wD6FTQ//BdD /wDE0f8ACCeD/wDoVND/APBdD/8AE0AHgT/knnhr/sFWv/opa6Cuf/4QTwf/ANCpof8A4Lof/iaP +EE8H/8AQqaH/wCC6H/4mgDoKK5//hBPB/8A0Kmh/wDguh/+Jo/4QTwf/wBCpof/AILof/iaAMPx 34K1LxR4q8HapZT2kcGi3puLlZnYM674mwmFIJxGepHUV3lc/wD8IJ4P/wChU0P/AMF0P/xNH/CC eD/+hU0P/wAF0P8A8TQB0FFc/wD8IJ4P/wChU0P/AMF0P/xNH/CCeD/+hU0P/wAF0P8A8TQB0Fc/ 4N/5Adz/ANhXUv8A0tmo/wCEE8H/APQqaH/4Lof/AImj/hBPB/8A0Kmh/wDguh/+JoA6Ciuf/wCE E8H/APQqaH/4Lof/AImj/hBPB/8A0Kmh/wDguh/+JoA6Ciuf/wCEE8H/APQqaH/4Lof/AImj/hBP B/8A0Kmh/wDguh/+JoA6Ciuf/wCEE8H/APQqaH/4Lof/AImj/hBPB/8A0Kmh/wDguh/+JoA6Ciuf /wCEE8H/APQqaH/4Lof/AImj/hBPB/8A0Kmh/wDguh/+JoAPD3/Ic8Wf9hWP/wBIrWugrn/+EE8H /wDQqaH/AOC6H/4mj/hBPB//AEKmh/8Aguh/+JoA6Ciuf/4QTwf/ANCpof8A4Lof/iaP+EE8H/8A QqaH/wCC6H/4mgDD+LPgrUvHnhW10vS57SGeK9S4Zrp2VSoR1wNqsc5cdvWu8rn/APhBPB//AEKm h/8Aguh/+Jo/4QTwf/0Kmh/+C6H/AOJoA6Ciuf8A+EE8H/8AQqaH/wCC6H/4mj/hBPB//QqaH/4L of8A4mgDoK5/w9/yHPFn/YVj/wDSK1o/4QTwf/0Kmh/+C6H/AOJo/wCEE8H/APQqaH/4Lof/AImg DoKK5/8A4QTwf/0Kmh/+C6H/AOJo/wCEE8H/APQqaH/4Lof/AImgDoKK5/8A4QTwf/0Kmh/+C6H/ AOJo/wCEE8H/APQqaH/4Lof/AImgDoKK5/8A4QTwf/0Kmh/+C6H/AOJo/wCEE8H/APQqaH/4Lof/ AImgDoKK5/8A4QTwf/0Kmh/+C6H/AOJo/wCEE8H/APQqaH/4Lof/AImgAs/+Sh6z/wBgqw/9G3dd BXP/APCCeD/+hU0P/wAF0P8A8TR/wgng/wD6FTQ//BdD/wDE0AdBRXP/APCCeD/+hU0P/wAF0P8A 8TR/wgng/wD6FTQ//BdD/wDE0AV/iJ4bvPF3gTUtDsJII7q68rY87EINsqOckAnop7VqeGtNm0bw rpGl3DRtPZWUNvI0ZJUsiBSRkA4yPQVT/wCEE8H/APQqaH/4Lof/AImj/hBPB/8A0Kmh/wDguh/+ JoA6Ciuf/wCEE8H/APQqaH/4Lof/AImj/hBPB/8A0Kmh/wDguh/+JoA6CufvP+Sh6N/2Cr//ANG2 lH/CCeD/APoVND/8F0P/AMTR/wAIJ4P/AOhU0P8A8F0P/wATQB0FFc//AMIJ4P8A+hU0P/wXQ/8A xNH/AAgng/8A6FTQ/wDwXQ//ABNAHQUVz/8Awgng/wD6FTQ//BdD/wDE0f8ACCeD/wDoVND/APBd D/8AE0AdBRXP/wDCCeD/APoVND/8F0P/AMTR/wAIJ4P/AOhU0P8A8F0P/wATQB0FFc//AMIJ4P8A +hU0P/wXQ/8AxNH/AAgng/8A6FTQ/wDwXQ//ABNABef8lD0b/sFX/wD6NtK6Cuf/AOEE8H/9Cpof /guh/wDiaP8AhBPB/wD0Kmh/+C6H/wCJoA6Ciuf/AOEE8H/9Cpof/guh/wDiaP8AhBPB/wD0Kmh/ +C6H/wCJoA6CuD+E3grUvAfhW60vVJ7SaeW9e4VrV2ZQpRFwdyqc5Q9vStz/AIQTwf8A9Cpof/gu h/8AiaP+EE8H/wDQqaH/AOC6H/4mgDoKK5//AIQTwf8A9Cpof/guh/8AiaP+EE8H/wDQqaH/AOC6 H/4mgDoK5/xD/wAhzwn/ANhWT/0iuqP+EE8H/wDQqaH/AOC6H/4mj/hBPB//AEKmh/8Aguh/+JoA 6Ciuf/4QTwf/ANCpof8A4Lof/iaP+EE8H/8AQqaH/wCC6H/4mgDoKK5//hBPB/8A0Kmh/wDguh/+ Jo/4QTwf/wBCpof/AILof/iaAOgorn/+EE8H/wDQqaH/AOC6H/4mj/hBPB//AEKmh/8Aguh/+JoA 6Ciuf/4QTwf/ANCpof8A4Lof/iaP+EE8H/8AQqaH/wCC6H/4mgA8Zf8AIDtv+wrpv/pbDXQVz/8A wgng/wD6FTQ//BdD/wDE0f8ACCeD/wDoVND/APBdD/8AE0AdBRXP/wDCCeD/APoVND/8F0P/AMTR /wAIJ4P/AOhU0P8A8F0P/wATQAeO/wDknniX/sFXX/opq8A/Zx/5KHqH/YKk/wDRsVe//wDCCeD/ APoVND/8F0P/AMTR/wAIJ4P/AOhU0P8A8F0P/wATQB0FFc//AMIJ4P8A+hU0P/wXQ/8AxNH/AAgn g/8A6FTQ/wDwXQ//ABNAHQVz/jL/AJAdt/2FdN/9LYaP+EE8H/8AQqaH/wCC6H/4mj/hBPB//Qqa H/4Lof8A4mgDoKK5/wD4QTwf/wBCpof/AILof/iaP+EE8H/9Cpof/guh/wDiaAOgorn/APhBPB// AEKmh/8Aguh/+Jo/4QTwf/0Kmh/+C6H/AOJoA6Ciuf8A+EE8H/8AQqaH/wCC6H/4mj/hBPB//Qqa H/4Lof8A4mgDoKK5/wD4QTwf/wBCpof/AILof/iaP+EE8H/9Cpof/guh/wDiaADx3/yTzxL/ANgq 6/8ARTV0Fc//AMIJ4P8A+hU0P/wXQ/8AxNH/AAgng/8A6FTQ/wDwXQ//ABNAHQUVz/8Awgng/wD6 FTQ//BdD/wDE0f8ACCeD/wDoVND/APBdD/8AE0AdBXB6V4K1Kx+MuueMJZ7Q6ff2S28Uau3mhgIR lhtxj923QnqPw3P+EE8H/wDQqaH/AOC6H/4mj/hBPB//AEKmh/8Aguh/+JoA6Ciuf/4QTwf/ANCp of8A4Lof/iaP+EE8H/8AQqaH/wCC6H/4mgDoKK5//hBPB/8A0Kmh/wDguh/+Jo/4QTwf/wBCpof/ AILof/iaADwJ/wAk88Nf9gq1/wDRS10Fc/8A8IJ4P/6FTQ//AAXQ/wDxNH/CCeD/APoVND/8F0P/ AMTQB0FFc/8A8IJ4P/6FTQ//AAXQ/wDxNH/CCeD/APoVND/8F0P/AMTQB0FFc/8A8IJ4P/6FTQ// AAXQ/wDxNH/CCeD/APoVND/8F0P/AMTQB0FFc/8A8IJ4P/6FTQ//AAXQ/wDxNH/CCeD/APoVND/8 F0P/AMTQB0Fc/wCBP+SeeGv+wVa/+ilo/wCEE8H/APQqaH/4Lof/AImj/hBPB/8A0Kmh/wDguh/+ JoA6Ciuf/wCEE8H/APQqaH/4Lof/AImj/hBPB/8A0Kmh/wDguh/+JoA6CuD8d+CtS8UeKvB2qWU9 pHBot6bi5WZ2DOu+JsJhSCcRnqR1Fbn/AAgng/8A6FTQ/wDwXQ//ABNH/CCeD/8AoVND/wDBdD/8 TQB0FFc//wAIJ4P/AOhU0P8A8F0P/wATR/wgng//AKFTQ/8AwXQ//E0AdBRXP/8ACCeD/wDoVND/ APBdD/8AE0f8IJ4P/wChU0P/AMF0P/xNAB4N/wCQHc/9hXUv/S2augrn/wDhBPB//QqaH/4Lof8A 4mj/AIQTwf8A9Cpof/guh/8AiaAOgorn/wDhBPB//QqaH/4Lof8A4mj/AIQTwf8A9Cpof/guh/8A iaAOgorn/wDhBPB//QqaH/4Lof8A4mj/AIQTwf8A9Cpof/guh/8AiaAOgorn/wDhBPB//QqaH/4L of8A4mj/AIQTwf8A9Cpof/guh/8AiaAOgrn/AA9/yHPFn/YVj/8ASK1o/wCEE8H/APQqaH/4Lof/ AImj/hBPB/8A0Kmh/wDguh/+JoA6Ciuf/wCEE8H/APQqaH/4Lof/AImj/hBPB/8A0Kmh/wDguh/+ JoA6CuD+LPgrUvHnhW10vS57SGeK9S4Zrp2VSoR1wNqsc5cdvWtz/hBPB/8A0Kmh/wDguh/+Jo/4 QTwf/wBCpof/AILof/iaAOgorn/+EE8H/wDQqaH/AOC6H/4mj/hBPB//AEKmh/8Aguh/+JoA6Ciu f/4QTwf/ANCpof8A4Lof/iaP+EE8H/8AQqaH/wCC6H/4mgA8Pf8AIc8Wf9hWP/0ita6Cuf8A+EE8 H/8AQqaH/wCC6H/4mj/hBPB//QqaH/4Lof8A4mgDoKK5/wD4QTwf/wBCpof/AILof/iaP+EE8H/9 Cpof/guh/wDiaAOgorn/APhBPB//AEKmh/8Aguh/+Jo/4QTwf/0Kmh/+C6H/AOJoA6Ciuf8A+EE8 H/8AQqaH/wCC6H/4mj/hBPB//QqaH/4Lof8A4mgDoK5+z/5KHrP/AGCrD/0bd0f8IJ4P/wChU0P/ AMF0P/xNH/CCeD/+hU0P/wAF0P8A8TQB0FFc/wD8IJ4P/wChU0P/AMF0P/xNH/CCeD/+hU0P/wAF 0P8A8TQB0Fcv8RPDd54u8CalodhJBHdXXlbHnYhBtlRzkgE9FParH/CCeD/+hU0P/wAF0P8A8TR/ wgng/wD6FTQ//BdD/wDE0AXPDWmzaN4V0jS7ho2nsrKG3kaMkqWRApIyAcZHoK1K5/8A4QTwf/0K mh/+C6H/AOJo/wCEE8H/APQqaH/4Lof/AImgDoKK5/8A4QTwf/0Kmh/+C6H/AOJo/wCEE8H/APQq aH/4Lof/AImgAvP+Sh6N/wBgq/8A/RtpXQVz/wDwgng//oVND/8ABdD/APE0f8IJ4P8A+hU0P/wX Q/8AxNAHQUVz/wDwgng//oVND/8ABdD/APE0f8IJ4P8A+hU0P/wXQ/8AxNAHQUVz/wDwgng//oVN D/8ABdD/APE0f8IJ4P8A+hU0P/wXQ/8AxNAHQUVz/wDwgng//oVND/8ABdD/APE0f8IJ4P8A+hU0 P/wXQ/8AxNAHQVz95/yUPRv+wVf/APo20o/4QTwf/wBCpof/AILof/iaP+EE8H/9Cpof/guh/wDi aAOgorn/APhBPB//AEKmh/8Aguh/+Jo/4QTwf/0Kmh/+C6H/AOJoA6Ciuf8A+EE8H/8AQqaH/wCC 6H/4mj/hBPB//QqaH/4Lof8A4mgDL+FGmzaN8OrDS7ho2nsri7t5GjJKlkupVJGQDjI9BXaVXsbC z0yzjs7C0gtLWPOyGCMRouSScKOBkkn8asUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRR RQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFF ABRRRQAUUUUAFFFFABRRRQAUUUUAFFFePvqnxa8a3l1ceH4IPCumW8pjgXVbcrPcAgcsGR+mM8AD 58ZfaSAD2CivL/hx4x8S3Hi3WPBXjDyJdW02ITJdW6KBKm4ZLEEDkSRFcKvGd3NY83in4hePvFGq W/gO8sdP0LTJWhXUJ4lZLlwFBAYiQNyGZdoHysN3JWgDuNR8dfYPihpPgv8As7zP7QtGuftnn48v AlO3Zt5/1XXcPve3PYV8+aXeeI7j9ojwzb+KbSOHVLGyltnni/1d2ojuGWZOAMMGwcdweF+6vT+J fFvjTxH48ufCngCa0t4tORTf6lNGrpHLhsoWO8Y5VcbN+5W7KTQB1njDx1/winiHwxpP9nfav7cu /s3m+fs8j5413Y2nd/rM4yOnvXYV84eJbjxjH8Q/AGk+MooJrq01VJINTthiO7SSWHIwFUBkK4PA 4K8dGb6PoAKKKKACiiigAooooAKKKKACiiigAorzv4neNdX0J9L8P+FYI7rxJqrsIoygcxRBSN+N w2ndggsCmEfPArn11D4ueC9UsrzXxH4p0mZzFcW+k2waWHoQ4Cxoc8HGcqcEEqSpoA9korzPx74z 19/Etr4J8ERxtrkyLPdXr7XSyiz/ABAggHGCdw6Mu0MzjGXbeLvHPgHXNNsviA1jqOkalL5S6tag ILaRsAK52ooUYLHKg4JIY7StAHsFFeP/ABC8c+LtB+Kuk6J4di+3x3Wn7104xpiWZjMoZnxuCrtV j8yjCHJAyaz9S134rfDqW01fxPe2Ot6E0qxXn2S3Um3UsuW4SMhiMhSSVycHkrQB7hRXmes+MNT0 T4s+HIDqUc3hPxBb7ISUjkUTnhfLZBvwSYeWLL+9bsPlsfFvxbq/h3S9J07w3NGmvaverb2waMMS vG4qW+QHc0a/N2c+mQAeiUVHBG0NvFE80k7ogVpZAoZyB947QBk9eAB6AVJQAUUUUAFFFFABRRRQ AUUUUAFFePjxT4u8c/EXWdA8N6/Y6DYaNK0UjSWqS3M+PkZgjZDKsikZBTAkXOTgV1Hgib4hW+o3 Ol+MrWxurWKLfBq9pIo818glCgwejYzsXHln72QaAO4orxebxT8QvH3ijVLfwHeWOn6FpkrQrqE8 Ssly4CggMRIG5DMu0D5WG7krXQeDPE/jGz/tnSPGeh311eaXFJcRajZW2Y75BzsTAVWkORtAxkcM FZTkA9IorxuGb40eLkOq2E+m+GLRnZIrC7h/e7Qxwzb4nOecfw525CgEE9B8KfGur+KLfWNL8QwR x61otwtvcNEgCvwVycMQX3RyZ2gL0xQBqfDjx1/wsDw9cat/Z32DybtrbyvP83OERt2dq/38Yx2r sK8P+Bus2fh74Qa5q9++y1tNQmlfBALYhiwq5IBYnAAzySBUkOo/GXxlpZ8RaLNpuiWEiM1pp7op lnQZKtmRGGWBABJQHAOADkgHtlFcf8O/G/8AwmuhyyXVr9h1exlNtqFmTgxyD+IKTuVTzgNyCrDn bk9hQAUUUUAFFFFABRRRQAUUUUAFc/oXjHS/Eeua5pOn+e02jSpDcyOm1Gc7gQvOTgowOQOnGRzW pq0d9No19Fpc0cGoPbyLayyDKpKVOxjweA2D0P0NfPnwt07xzJ8Q/Ef2PWbGP7Nqsf8Ab25B/peJ ZN/l/uzjOJemz7w6dgD6Prm73xJqVt4807w/F4eu59Purcyy6spbyoGAkOxvkIz8i9WH3xx6+V2P ij4leKfGXivw9oGqQQf2fqDmK7uYEEcEKSSJ5PETZZsqQW5xE3qa6i68R+ItM+NHhTwpLq32ixn0 rzL3/Ro0+0TKk+ZOmUyY1O0HA6UAeoUV5XresfEvxL4l1DSfCdjHoOn6e+3+0tUgIN0wJU+XuVgU PUYU8KCWG4LVfwl4t8aaN8SIvBHjea0vpL23a4tLy1jUZ+XIBI2gIBHKOU3bsfw4NAHrlcf4w8df 8Ip4h8MaT/Z32r+3Lv7N5vn7PI+eNd2Np3f6zOMjp71yfiXxb408R+PLnwp4AmtLeLTkU3+pTRq6 Ry4bKFjvGOVXGzfuVuyk1xniW48Yx/EPwBpPjKKCa6tNVSSDU7YYju0klhyMBVAZCuDwOCvHRmAP o+iiigAooooAKKKKACiiigAooooAKKKy/EerTaF4fvNSt9Mu9TngQGOztELSSsSAAAATjJyTg4AJ wcYoA1KK8X8n456xp39swalpWl+dF5qaV5KrImBwv7yNsM2M4Z+C2DtxgWIPH/iLxZ8EtR8S6RJ9 h13TZX88QRR+UyoQz4Eu/wCUROG6hty8ccEA9gorm/Dni201b4fWfim6mjSA2RuLt443CxsgPnAK cthWVx3zjjNef+HviNrln8JtX8ceI7mOSe5uHTSbXZEsX91AqghyN+/cGYtsiyO5IB7JRXicNx8c ItLPid5NNmjKNcf2C9uBKEOcLtVQ2QDuC+Zu4AOWyp6T4KeKdZ8XeDby/wBcvPtd1HqDwq/lJHhB HGQMIAOrH86APSKKKKACiiigAooooAKKKKACiiigAoorL8R6tNoXh+81K30y71OeBAY7O0QtJKxI AAABOMnJODgAnBxigDUorxfyfjnrGnf2zBqWlaX50XmppXkqsiYHC/vI2wzYzhn4LYO3GB0ngv4n w618MrzxXrUcdu+nPKl2sICIzKAyiPc5yWV0UAkZYkelAHolcf4P8df8JX4h8T6T/Z32X+w7v7N5 vn7/AD/nkXdjaNv+rzjJ6+1ef6NqHxq8T6cnieyudKs7OTEsGlzQhPtCKARt3KWCvg4LSL1yCFIN HwR1PzvEPxF1bUYf7N33aXNxFcNt+zZe4ZlckDG3kEkDp2oA9wrj9O8dfb/ihq3gv+zvL/s+0W5+ 2efnzMiI7dm3j/W9dx+778ef6brvxW+Ist3q/hi9sdE0JZWis/tduoNwoZsNykhLAYDEELkYHIaq /wANdQ1TVPj94hutb07+ztTOlCO5tgchXQ26Er/stt3Dk8MOT1IB7xRRRQAUUUUAFFFFABRRRQAU UUUAFFFeX+P/ABj4lfxbZeCvA3kHVpYvOvbp0VxZoWXaSSSF4BLblPDptyWFAHqFFeT6HqnxO8M+ LbLTvFsH/CQaZqW2Nb3TLcEWb7sZcqiYXkbtw6cqflZSeJ/F3i7xJ40m8JfD5oLZtN+bUdVmCPEj EcR/dYDngjBYsCMAIxIB6xRXlfhzxn4r8PeMbPwh4/jtJXvkP2DV7bCRzvySjZCgnkIAFUg7eG3h qx9c8a+PG+MGt+EvDhjuEa3jS1EsSCOxLRxM1w7bckLl8AkjLjhuFIB7ZRXi8Pin4heAfFGl2/jy 8sdQ0LU5VhbUIIlVLZyGABYCMLyVZtwPyqdvIaug0/xTrOnfG2/8Kaveebpl9aC60kSRJvyBllDR gYXiYfPz+7Xnn5gD0iivN/H3inWYfHPhXwj4dvPs91qEpmvmSJDIlsDyVMgKfdWY9CcoPXDekUAF FFFABRRRQAUUUUAFFFFABRRXifh7xL48+J1xq+oeHPEum6Jp9o7xW1m1qkk7nO6JpQwbYGU4LKSM ocKeTQB7ZRXH+DtR8XQ6dqKeO7SxtPsGPL1KGdBHcxgHdIwz8mNu4khRh/urtNef6brvxW+Ist3q /hi9sdE0JZWis/tduoNwoZsNykhLAYDEELkYHIagD3CivN/DnjfxTH4L1SbxF4S1WTXdI2xGOC2I GoMSVVo8DBwRlygKgfMuQdo5/wAn456xp39swalpWl+dF5qaV5KrImBwv7yNsM2M4Z+C2DtxgAHr Gu6n/Ynh7U9W8nzvsNpLc+Vu279iFtucHGcYzg1n+CfE/wDwmPhCx1/7H9j+1eZ+483zNu2Rk+9g Zztz071xek+NZvHnwM8SapdwRw3kVle29wsSFYywiLAplmONrpnJ657Yqn4G8WWfgr9nnTNavE83 yvOSGAOEaaRriQKoJ/EnGSFDHBxigD2CivE5rj44S6WPE6SabDGEW4/sFLcGUoMZXaylskDcV8zd yQMNhR6Z4L8WWfjXwva61Zp5Xm5SaAuHaGRThlJH4EZwSpU4GcUAdBRRRQAUUUUAFFFFABRRRQAV Xv7630zTrm/vJPLtbWJ5pn2k7UUEscDk4APSrFcP8WrfXbj4eal/Yd7Ba+XFLJfecAfNtRE/mIvy t8x4x06dRQB0HhbxJZ+LvDlprlhHPHa3W/Yk6gONrshyASOqnvWxXgfwyPjTSfhXqGt/2vaDQYdH vpNOtljUyw3CuxDtmPkblkOCxHI49NT4dar8SvG0Gj6zLrUFno0EpivRLbIZL7a7MWQeUAFIZYsh uCjHrxQB6J4b8Salres67ZXvh670yDTrjyra5mLbb1dzjemUUYwgPBb7459ekry/wN4z1nUPEPxE j1OWe/tdEu2Fna29unmBFef5ECgF2IjUDJOT35rLhm+NHi5DqthPpvhi0Z2SKwu4f3u0McM2+Jzn nH8OduQoBBIB7JRXm/ww8e6jr2na5Z+KhBa6noEoivZgFSPaAQWZtxXcGjkLEYXGMVy+m678VviL Ld6v4YvbHRNCWVorP7XbqDcKGbDcpISwGAxBC5GByGoA9A07x19v+KGreC/7O8v+z7Rbn7Z5+fMy Ijt2beP9b13H7vvx2FeD/DXUNU1T4/eIbrW9O/s7UzpQjubYHIV0NuhK/wCy23cOTww5PU+8UAFF FFABRRRQAUUUUAFFFFABRRRQAUVzfjnxDqXhrw1JeaPot3q+oO4igt7eFpArEE73C87Bjt1JAyM5 Hm+qn426Ppdx4kudX0Y29sn2ybS0jQlIx8zR58vkKuQcSEkA4YnGQD2yivH/ABL4/wDEU3wj0Lx3 oEnkSJKn9o27xRmF13GN8hsvt81QBtYNtfJ55XvPEfi200n4fXnim1mjeAWQuLR5I3KyM4HkgqMN hmZB2xnnFAHSUV4+fH/iLw38I9G1XUJP7T8Va3Kv2G1kijYOrtlcRxbSV8vaeMsHkUHrgZeq3nxt 8KeGrjXL+/03UIvs/wC9t0gRpbPcMmXCIoJToeXUZJIIBIAPdKK4/wCFut6j4j+HGk6tq1x9ovp/ O8yXYqbtszqOFAA4AHArsKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiig AooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAC iiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK+fPCviHTfiLcarqHjHx1d6VALjy4dEXUF tIGtSS2x2womBBKEjDYXk/MuPoOuL1X4TeB9a1S41K/0GN7u5ffK6Tyxhm7najAZPUnHJyTyTQB5 h8IZNAl+N2vt4Xhkh0UaY62yuWJIDwBm+YlsFgxGecEcDoNP4O65pfgaLXvBviS/g03U7TUHm33T +VDKhVEBR3xnO0MMgZVgRnnHqkHg/QLTxBFrtppsdrqEduLUSWztEpiAwEZFIRgAABkHG1f7oxX8 S+AfC/i+4guNd0mO6ngQpHIJHjbaTnBKMCRnJAOcZOOpoA8rPifS/FH7TmgzaRP9ot7O0ltGnX7k jrHOxKH+JfnAz3wcZGCbnhHVbHwF8XvGmmeI7mOxOs3AvrO5m+SB03Svgu2ADiTGem5GGc4z6RZe AfC+nappmpWekxwXel25trN0kcCOM78jbuwxPmOSzAkliSc1Y8S+D9A8YW8EGvabHeJA5eIl2RkJ GDhlIODxkZwcD0FAHj/xF8XaL4j+K/gKw0e9jvTp+pxNNPAweLMksJCq4OGICc44GQM5yB75XJ2/ w08H2qaUkGixxjSrhrqz2zSApKWVi7HdlzlE+9nhQOnFdZQAUUUUAFFFFABRRRQAUUUUAFFFFAHi fxG1KHwn8dfCfifVVkTSfsT25mQBiG/eqx2g5wvnRk8dCcZIxXWeKPivo+kf2bbaBJY+ItT1C7W2 is7S/QYzxuLgMq/MVGGxncT2NdhrOh6X4h057DV7CC9tWydkyZ2kgjcp6q2CcMMEZ4NY/h74deEf Ct4bzR9Egguj0mdnldOCPlZySuQxB24z3zQB5/e31v4H/aJutX12T7PpuvaesNrdbT5aOPKUiRjg DBi5xnAdCcAkiv8AGLXNL8cxaD4N8N38Gpand6gk2+1fzYYkCuhLumcY3FjgHCqSccZ9g1nQ9L8Q 6c9hq9hBe2rZOyZM7SQRuU9VbBOGGCM8Gs/w34H8NeEfMOh6RBaSSZDTZaSQg4yu9yW2/KDtzjIz jNAHlfxD1+x8L/tDeGdY1NpFs4NMCyui7igc3CbsdSAWBOMnAOATxWp8YvG3h/U/Ak3h/SNSg1XU 9Vliit4NOkW4OVlRvm2k4zgADqSRgHBIj8UwQ3X7TPhe3uIo5oJdHlSSORQyupS6BBB4II4xXcaB 8NPB/hfVF1PR9FjgvFQosrTSSlAeu3exAOOMjnBI6E0Acn8SPB1xL8CLbTX/AHt9oNpbzHyXARjD HskOWAyoQyMOhOB9Dh+CtSm+KfxUt9evljm0/QdMgaNIwREl5Iilso5JyH83DLj/AFMfJwCe8+JP xHs/h/p0Pm20819fRT/YtqBoxIgXHmfMp25demTjNU/gx4Rbwr4Dha8spLbVL9zcXSzKodRkiNTg ZAC4O08gu3TJAAPRKKKKACiiigAooooAKKKKACiiigDx/wAQXHwu8ZeKNX0jxLZf2RrNjuja9vSt m0vAUOjhsSYAQr5gPykEAjdWX4J1SbRPjBB4V8OeJrvxF4aeyBm86Q3C2WyNioSRflAB2DK4X94F ILKCPUPEvgHwv4vuILjXdJjup4EKRyCR422k5wSjAkZyQDnGTjqaseGvB+geD7eeDQdNjs0ncPKQ 7OzkDAyzEnA5wM4GT6mgDyP4IeKNH8K6drXhXxBfQaXqdtqEkri7lRIzgJGyh87SwZDxnkEEZwcd pa/FSHUr/wAWjS9NjvdL8PWT3J1CO7AW4kCbhGF25AJWQbxuHyZ/iFbniH4deEfFV4LzWNEgnuh1 mRnid+APmZCC2AoA3Zx2xWxo2h6X4e05LDSLCCytVwdkKY3EADcx6s2AMsck45NAHhnhW+8OeLvD UutfEHx/d3ErO5u9Fe++zQbUA2DyEwXPCuDHjLYGCQc3/wBnuSxm1nxvLpcMkGnvcQNaxSHLJEWn 2KeTyFwOp+prvP8AhT/gH+0ft3/COQed5vnbfNk8vdnOPL3bNuf4cbccYxxXQaf4W0bStcv9ZsLP 7Nfahg3TRyuElPXcY87N2cndjPzNz8xyAeEeA9GvNf8A2cfFenWCeZdNqDSpGASX8tbeQqoAJLEI QB3JFX/BMXhPVfCWnyzfFLxHpNxFEsM1lLrqWwidVAIjRh/q/wC7gnjA6gge0eG/C2jeEdOksNDs /slrJKZmTzXky5ABOXJPRR+VY+s/CzwTr+ovf6joED3T5LvDJJDvJJJZhGyhmJJyx5PrQBz/AMHb Xw2f+Ei1Pw3ca5eQ3N2sU97qrxt9okTcxZNuH5EgJLgE7h3zj1Cq9jYWemWcdnYWkFpax52QwRiN FySThRwMkk/jVigAooooAKKKKACiiigAooooAK8T+Fmrabp/xL+Ilve6haW093rAS2jmmVGmbzpx hATljlgMD1HrXtlcnN8NPB8/iUeIX0WMaoLhbrzkmkQeapBD7FYLnIyeOTknOTQBxfwg/wCSh/E7 /sKj/wBG3FHiH/k6Hwn/ANgqT/0G6r0jR/C2jaDqOqX+mWfkXWqS+deP5rt5r5Y5wxIHLt0x1ouP C2jXfii08Sz2e/V7SIwwXHmuNiEMCNoO0/fbqO/0oA8fbxOni/4leI9N17xxfeGNN0qV4LK2tLxb XzSrBHYzEAHlN2xsn94cHCnOR4cXwjF+0Xott4Mi2abbxTRSOsjyJLMIZtzIzMSVwVGeh2kjIwT7 Hr/w08H+KNUbU9Y0WOe8ZAjSrNJEXA6btjAE44yecADoBViLwD4Xt7jR7i30mO3n0dNllJbyPE0a 5yQxVgXBJYkPnO5s53NkA838I6rY+Avi9400zxHcx2J1m4F9Z3M3yQOm6V8F2wAcSYz03IwznGc/ 4i+LtF8R/FfwFYaPex3p0/U4mmngYPFmSWEhVcHDEBOccDIGc5A9g8S+D9A8YW8EGvabHeJA5eIl 2RkJGDhlIODxkZwcD0FZ9v8ADTwfappSQaLHGNKuGurPbNICkpZWLsd2XOUT72eFA6cUAdZRRRQA UUUUAFFFFABRRRQAUUUUAFcv8RfENx4V+H+saxZrm6hiCQnI+R3ZY1fkEHaWDYI5xjvXUVHPBDdW 8tvcRRzQSoUkjkUMrqRggg8EEcYoA8DsZPA2peC4/EHjfxrfeIJ5Ijcz6RJqBQR3BJ+WK2UqysuS gOQmCW4UjHQfs4/8k81D/sKyf+ioq6zSvhN4H0XVLfUrDQY0u7Z98TvPLIFbsdrsRkdQccHBHIFb mg+FtG8MfbBo1n9jju5fOlhSVzHv9VQkqnp8oHAA6AYAPBNSu77wt4a8TfC2xlkuLybWLe105vt2 1zBcjeEAIUYwgV8YXM5zx97t/jL4UmX4OWdhpYkmg0J4HYPlpGhjjaLPyjBIDBieAAGPbFeiXHhb RrvxRaeJZ7Pfq9pEYYLjzXGxCGBG0Hafvt1Hf6Vl/Ea917T/AAdcXHh/SrTVZ96pPZXNu8/nQtlW Cxpyxyykg8bQ1AFP/hbngr/hF/7d/tmDb5XmfYt6/a92cbPKzndnj+73zt+auX/Zx/5J5qH/AGFZ P/RUVcB/wmHwxf8A0vRfh5PN4luOILScGW08+TgqIxIQygsdqiMZwAAvBHrfwV8L33hb4fRw6lHJ Dd3tw949vIm1oQwVVU8nnagbnBG7BGRQB6JRRRQAUUUUAFFFFABRRRQAUUUUAFcv8RfENx4V+H+s axZrm6hiCQnI+R3ZY1fkEHaWDYI5xjvXUVHPBDdW8tvcRRzQSoUkjkUMrqRggg8EEcYoA8DsZPA2 peC4/EHjfxrfeIJ5Ijcz6RJqBQR3BJ+WK2UqysuSgOQmCW4UjFDwHo15r/7OPivTrBPMum1BpUjA JL+WtvIVUAEliEIA7kivW9K+E3gfRdUt9SsNBjS7tn3xO88sgVux2uxGR1BxwcEcgVuaD4W0bwx9 sGjWf2OO7l86WFJXMe/1VCSqenygcADoBgA4vwF8S/CC/DnSzda3aWcunWUdvcW9zIqS7oowCVTO XBxkbc5zjrkDi/hf/wAVj/wtf+zv3X9s7vs/2j5dvnfadu/GcY3DOM/jXqF98LPBOpa5JrN3oEEt 9JKJpGMkgR3GDlow2w5Iycj5snOcmtjR/C2jaDqOqX+mWfkXWqS+deP5rt5r5Y5wxIHLt0x1oA83 +Dvjbw/pngSHw/q+pQaVqelSyxXEGoyLbnLSu3y7iM4yQR1BByBkE5fw81+x8UftDeJtY0xpGs59 MKxO67S4Q26bsdQCVJGcHBGQDxXpGv8Aw08H+KNUbU9Y0WOe8ZAjSrNJEXA6btjAE44yecADoBWh p/g/QNK8QTa7YabHb6hNbravJG7BfKUIFQJnYoAjQcAdKANyiiigAooooAKKKKACiiigAooooAK8 Pn1mz8GftK6ne66/2Sz1fT44ra4YgoMiJQznPyruhdcnpwThea9wrH8Q+FdC8V2Ytdc0yC9jX7hc EPHkgna4wy52jOCM4weKAObvvihpp8Y6F4c8Pi012fUXbz5LW9XbaxjksSAVY7RI23IPyD+8K4/w jqtj4C+L3jTTPEdzHYnWbgX1nczfJA6bpXwXbABxJjPTcjDOcZ9M8N+B/DXhHzDoekQWkkmQ02Wk kIOMrvcltvyg7c4yM4zVjxD4V0LxXZi11zTIL2NfuFwQ8eSCdrjDLnaM4IzjB4oA8r8XarY+Pfi9 4L0zw5cx3x0a4N9eXMPzwIm6J8B1yCcR4z03OoznOKY8T6X4X/ac16bV5/s9veWkVos7fcjdo4GB c/wr8hGe2RnAyR7B4e8K6F4Usza6HpkFlG33ygJeTBJG5zlmxuOMk4zgcV5XZ6VY65+0b400zU7a O5s7jR0SWJ+jDba/iCDggjkEAjBFAEfxi1zS/HMWg+DfDd/BqWp3eoJNvtX82GJAroS7pnGNxY4B wqknHGdj46WNxbaPofi6yj8y68P6gk212HlhGZeWHBPzpEPlPRj9R2nhrwD4X8IXE9xoWkx2s86B JJDI8jbQc4BdiQM4JAxnAz0Fcf8AF/4gQ6NYXfg+0sbu51rV7IJbhIQ8ZWV2iI4YNvwHwADyV68i gCn8NP8AitfiL4n8d3P+kWtvL/Z+kSfwLGM5Kq2WRtmw5+UfvZOOSB7BXL/DzwwnhHwNpml+R5N0 IhLeA7SxnYZfLLw2D8oPPyqoycV1FABRRRQAUUUUAFFFFABRRRQAV4fcr8IviJLqUupRf8I3q8Mv lTm7kSxn3bizNtLGN2J3KxILDvj5TXuFcnr/AMNPB/ijVG1PWNFjnvGQI0qzSRFwOm7YwBOOMnnA A6AUAeX+FtQ1rV7/AOIHg/TNau/E2j/2ZcCyvrpi7eeyBFjErHGDlhnO1vLLLgE52Pgt498M23w8 tNHv9XtNPvNPeRZEvZlhDh5HdWQscMMNg9wRyMEE+oaB4c0jwtpa6botjHaWgcvsUlizHqWZiSx6 DJJ4AHQCsPWfhZ4J1/UXv9R0CB7p8l3hkkh3kkkswjZQzEk5Y8n1oA5e6+LdxqPw/wDF/iHStM8m 10yUWlhe+eG892YIJNjJldoeN9rA53Yzwa5exk8Dal4Lj8QeN/Gt94gnkiNzPpEmoFBHcEn5YrZS rKy5KA5CYJbhSMe6Q6TpttpZ0uDT7SLTyjIbRIVWIq2dw2AYwcnIxzk1y+lfCbwPouqW+pWGgxpd 2z74neeWQK3Y7XYjI6g44OCOQKAPM/hZ/wAm9eNf+37/ANJEqhf6Neav+yvoktmnmf2fdyXkyAEs YxLOjEAA9N4Y5wAqsc8V7fYeCfDul6dqunWOn+RY6rv+12yTSCNt4KttXdiPIOPk28AegxoaJomn eHNHg0nSbf7PYwbvLi3s+3cxY8sSTySeTQB4/Yr4KvdDj1Y/F3xXbxtEZWt59eVZ0xnKmLbuLDBG ADntkEZ7D4O2OiWngYzeHo9VTTbu7kmQ6m0RkcgLGSPL4C5THPOQe2KuTfCXwHPqg1F/DVoJw6vs RnSLK4x+6VgmOORtwec5ya7CCCG1t4re3ijhgiQJHHGoVUUDAAA4AA4xQBJRRRQAUUUUAFFFFABR RRQAVz/jv/knniX/ALBV1/6KaugqOeCG6t5be4ijmglQpJHIoZXUjBBB4II4xQB4v4J1bTZv2cr7 S4tQtH1CHR9ReW0WZTKi7peWTOQPmXkjuPWus+CX/JIdC/7eP/SiStDSvhb4N0T7b/Z2jeT9utJL K4/0qZt8L43Ly5xnA5GD710GiaJp3hzR4NJ0m3+z2MG7y4t7Pt3MWPLEk8knk0AeP/D3U/7E8Q/G HVvJ877DdyXPlbtu/Y9y23ODjOMZwazPCt94c8XeGpda+IPj+7uJWdzd6K999mg2oBsHkJgueFcG PGWwMEg59r0fwto2g6jql/pln5F1qkvnXj+a7ea+WOcMSBy7dMda5/8A4U/4B/tH7d/wjkHneb52 3zZPL3Zzjy92zbn+HG3HGMcUAeYfCCxt9e074nWGhx/ZrXUIhDYpcMf3SSC4EYc/MeARnr0710/w d8beH9M8CQ+H9X1KDStT0qWWK4g1GRbc5aV2+XcRnGSCOoIOQMgn0jT/AAto2la5f6zYWf2a+1DB umjlcJKeu4x52bs5O7Gfmbn5jnL1/wCGng/xRqjanrGixz3jIEaVZpIi4HTdsYAnHGTzgAdAKAPN /h5r9j4o/aG8TaxpjSNZz6YVid12lwht03Y6gEqSM4OCMgHivdKw9P8AB+gaV4gm12w02O31Ca3W 1eSN2C+UoQKgTOxQBGg4A6VuUAFFFFABRRRQAUUUUAFFFFABRRRQB5/8YvF2o+DfAwvdJbyr65u4 7aOfCt5WQzltrKQ2QhXB/vZ7V5x4ntfh7b+AZr7UfGN94s1Z7TZp4uNSaV4J3T76whgY1ztZhJnG wDk8H3vVdKsdc0u40zU7aO5s7hNksT9GH8wQcEEcggEYIrm9H+FngnQbx7qw0CBZnieFjNJJONjj DDbIzDkZB46EjoTQBh/CjTYdZ+BFhpdw0iwXtvd28jRkBgrzSqSMgjOD6GvOI7u+1/w/4d+FU8sk l3b67PY6hLb33zNbW53EhWA+Ta7bA3H+jjAJ4X3/AEDw9pnhfS10zR4JILNXLrE08koQnrt3sSBn nA4ySepNR2/hbRrTxRd+JYLPZq93EIZ7jzXO9AFAG0naPuL0Hb60Aed/G2CaxvfB3itopJdP0TUw 94sKlnCs8bAjtj92VySOWUd+NDx78S/CDfDnVDa63aXkuo2Ulvb29tIry7pYyAWTOUAzk7sYxjrg G58WNZ1jQ9Dtbq08P2OuaQZSNUtLm3eU+WuHDjGVVRsbLMCAdhwea8Yv9c+Ht3p1zp3gTwFfXGu3 0T28f2tGn8pCCWeNPMc+YAOCAMcnOAQQD2f4Jf8AJIdC/wC3j/0okr0CuX+HXh648K/D/R9HvGzd QxF5hgfI7s0jJwSDtLFcg84z3rqKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKK ACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA KKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAo oooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACii igAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKK ACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA KKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAo oooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACii igAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKK ACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA KKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAo oooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACii igAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKK ACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA KKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAo oooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACii igAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKK ACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA KKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAo oooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACii igAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKK ACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA KKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAo oooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACii igAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKK ACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA KKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAo oooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACii igAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKK ACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA KKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAo oooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACii igAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKK ACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA KKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAo oooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACii igAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKK ACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA KKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAo oooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACii igAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKK ACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA KKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAo oooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACii igAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKK ACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA KKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAo oooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACii igAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKK ACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA KKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAo oooAKKKKACiiigD/2Q== --047d7bfceb1a3e3aba04f3cfe2e9 Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Disposition: inline _______________________________________________ Xen-devel mailing list Xen-devel@lists.xen.org http://lists.xen.org/xen-devel --047d7bfceb1a3e3aba04f3cfe2e9-- From xen-devel-bounces@lists.xen.org Wed Mar 05 14:45:05 2014 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Wed, 05 Mar 2014 14:45:05 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WLD46-0007ki-5T; Wed, 05 Mar 2014 14:44:58 +0000 Received: from mail6.bemta5.messagelabs.com ([195.245.231.135]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WLD45-0007ip-1Q for xen-devel@lists.xen.org; Wed, 05 Mar 2014 14:44:57 +0000 Received: from [85.158.139.211:16042] by server-15.bemta-5.messagelabs.com id 4A/26-24395-86837135; Wed, 05 Mar 2014 14:44:56 +0000 X-Env-Sender: Paul.Durrant@citrix.com X-Msg-Ref: server-8.tower-206.messagelabs.com!1394030693!7904541!1 X-Originating-IP: [185.25.65.24] X-SpamReason: No, hits=0.5 required=7.0 tests=BODY_RANDOM_LONG X-StarScan-Received: X-StarScan-Version: 6.9.16; banners=-,-,- X-VirusChecked: Checked Received: (qmail 12674 invoked from network); 5 Mar 2014 14:44:53 -0000 Received: from smtp.eu.citrix.com (HELO SMTP.EU.CITRIX.COM) (185.25.65.24) by server-8.tower-206.messagelabs.com with RC4-SHA encrypted SMTP; 5 Mar 2014 14:44:53 -0000 X-IronPort-AV: E=Sophos;i="4.97,593,1389744000"; d="scan'208";a="10406125" Received: from unknown (HELO AMSPEX01CL03.citrite.net) ([10.69.60.9]) by AMSPIP01.EU.Citrix.com with ESMTP; 05 Mar 2014 14:44:43 +0000 Received: from AMSPEX01CL01.citrite.net ([169.254.6.60]) by AMSPEX01CL03.citrite.net ([169.254.8.48]) with mapi id 14.02.0342.004; Wed, 5 Mar 2014 15:44:42 +0100 From: Paul Durrant To: Andrew Cooper Thread-Topic: [Xen-devel] [PATCH v2 5/6] ioreq-server: add support for multiple servers Thread-Index: AQHPN56Wy5IdaTYGXE+fbEp/ZmSbm5rQxDmAgAHNzDA= Date: Wed, 5 Mar 2014 14:44:42 +0000 Message-ID: <9AAE0902D5BC7E449B7C8E4E778ABCD0264420@AMSPEX01CL01.citrite.net> References: <1393933235-6064-1-git-send-email-paul.durrant@citrix.com> <1393933235-6064-6-git-send-email-paul.durrant@citrix.com> <5315C1AB.1010409@citrix.com> In-Reply-To: <5315C1AB.1010409@citrix.com> Accept-Language: en-GB, en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-originating-ip: [10.80.2.29] MIME-Version: 1.0 X-DLP: AMS1 Cc: "xen-devel@lists.xen.org" Subject: Re: [Xen-devel] [PATCH v2 5/6] ioreq-server: add support for multiple servers X-BeenThere: xen-devel@lists.xen.org X-Mailman-Version: 2.1.13 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Sender: xen-devel-bounces@lists.xen.org Errors-To: xen-devel-bounces@lists.xen.org > -----Original Message----- > From: Andrew Cooper [mailto:andrew.cooper3@citrix.com] > Sent: 04 March 2014 12:06 > To: Paul Durrant > Cc: xen-devel@lists.xen.org > Subject: Re: [Xen-devel] [PATCH v2 5/6] ioreq-server: add support for > multiple servers > > On 04/03/14 11:40, Paul Durrant wrote: > > The legacy 'catch-all' server is always created with id 0. Secondary > > servers will have an id ranging from 1 to a limit set by the toolstack > > via the 'max_emulators' build info field. This defaults to 1 so ordinarily > > no extra special pages are reserved for secondary emulators. It may be > > increased using the secondary_device_emulators parameter in xl.cfg(5). > > There's no clear limit to apply to the number of emulators so I've not > > applied one. > > > > Because of the re-arrangement of the special pages in a previous patch we > > only need the addition of parameter HVM_PARAM_NR_IOREQ_SERVERS > to determine > > the layout of the shared pages for multiple emulators. Guests migrated in > > from hosts without this patch will be lacking the save record which stores > > the new parameter and so the guest is assumed to only have had a single > > emulator. > > > > Added some more emacs boilerplate to xenctrl.h and xenguest.h > > > > Signed-off-by: Paul Durrant > > How does the build param interact with the hvmparam? It appears not to. > The build param is the value used to set the HVM param on domain create. (See setup_guest() just below where all the special PFNs are set). > On migrate, the receiving side will have to know, out-of-band, what to > set max_emulators to when building the domain. The setparam code needs > to validate the hvmparam against the build param and return > -EINVAL/-E2BIG in the case that the hvmparam is too large. > xc_domain_restore() needs to detect this and abort the migration if the > guest can't be restored with the expected number of emulators. > I don't think we need any of this. The HVM param is in the save record and so will be preserved. Migration in from a prior version of Xen will initialize the value to 1, which is correct for that case. The only need for max_emulators is to reserve the correct number of special pages when a new domain is built, so this is irrelevant for a domain restore; the only important thing is that the maximum number of emulators should never exceed the value of max_emulators when the domain was originally built, and the preservation of the HVM param ensures this. Paul > ~Andrew > > > --- > > docs/man/xl.cfg.pod.5 | 7 + > > tools/libxc/xc_domain.c | 175 +++++++ > > tools/libxc/xc_domain_restore.c | 20 + > > tools/libxc/xc_domain_save.c | 12 + > > tools/libxc/xc_hvm_build_x86.c | 24 +- > > tools/libxc/xenctrl.h | 51 ++ > > tools/libxc/xenguest.h | 12 + > > tools/libxc/xg_save_restore.h | 1 + > > tools/libxl/libxl.h | 8 + > > tools/libxl/libxl_create.c | 3 + > > tools/libxl/libxl_dom.c | 1 + > > tools/libxl/libxl_types.idl | 1 + > > tools/libxl/xl_cmdimpl.c | 3 + > > xen/arch/x86/hvm/hvm.c | 951 > +++++++++++++++++++++++++++++++++++--- > > xen/arch/x86/hvm/io.c | 2 +- > > xen/include/asm-x86/hvm/domain.h | 23 +- > > xen/include/asm-x86/hvm/hvm.h | 1 + > > xen/include/public/hvm/hvm_op.h | 70 +++ > > xen/include/public/hvm/ioreq.h | 1 + > > xen/include/public/hvm/params.h | 4 +- > > 20 files changed, 1300 insertions(+), 70 deletions(-) > > > > diff --git a/docs/man/xl.cfg.pod.5 b/docs/man/xl.cfg.pod.5 > > index e15a49f..0226c55 100644 > > --- a/docs/man/xl.cfg.pod.5 > > +++ b/docs/man/xl.cfg.pod.5 > > @@ -1281,6 +1281,13 @@ specified, enabling the use of XenServer PV > drivers in the guest. > > This parameter only takes effect when device_model_version=qemu-xen. > > See F for more information. > > > > +=item B > > + > > +If a number of secondary device emulators (i.e. in addition to > > +qemu-xen or qemu-xen-traditional) are to be invoked to support the > > +guest then this parameter can be set with the count of how many are > > +to be used. The default value is zero. > > + > > =back > > > > =head2 Device-Model Options > > diff --git a/tools/libxc/xc_domain.c b/tools/libxc/xc_domain.c > > index 369c3f3..dfa905b 100644 > > --- a/tools/libxc/xc_domain.c > > +++ b/tools/libxc/xc_domain.c > > @@ -1284,6 +1284,181 @@ int xc_get_hvm_param(xc_interface *handle, > domid_t dom, int param, unsigned long > > return rc; > > } > > > > +int xc_hvm_create_ioreq_server(xc_interface *xch, > > + domid_t domid, > > + ioservid_t *id) > > +{ > > + DECLARE_HYPERCALL; > > + DECLARE_HYPERCALL_BUFFER(xen_hvm_create_ioreq_server_t, arg); > > + int rc; > > + > > + arg = xc_hypercall_buffer_alloc(xch, arg, sizeof(*arg)); > > + if ( arg == NULL ) > > + return -1; > > + > > + hypercall.op = __HYPERVISOR_hvm_op; > > + hypercall.arg[0] = HVMOP_create_ioreq_server; > > + hypercall.arg[1] = HYPERCALL_BUFFER_AS_ARG(arg); > > + arg->domid = domid; > > + rc = do_xen_hypercall(xch, &hypercall); > > + *id = arg->id; > > + xc_hypercall_buffer_free(xch, arg); > > + return rc; > > +} > > + > > +int xc_hvm_get_ioreq_server_info(xc_interface *xch, > > + domid_t domid, > > + ioservid_t id, > > + xen_pfn_t *pfn, > > + xen_pfn_t *buf_pfn, > > + evtchn_port_t *buf_port) > > +{ > > + DECLARE_HYPERCALL; > > + DECLARE_HYPERCALL_BUFFER(xen_hvm_get_ioreq_server_info_t, > arg); > > + int rc; > > + > > + arg = xc_hypercall_buffer_alloc(xch, arg, sizeof(*arg)); > > + if ( arg == NULL ) > > + return -1; > > + > > + hypercall.op = __HYPERVISOR_hvm_op; > > + hypercall.arg[0] = HVMOP_get_ioreq_server_info; > > + hypercall.arg[1] = HYPERCALL_BUFFER_AS_ARG(arg); > > + arg->domid = domid; > > + arg->id = id; > > + rc = do_xen_hypercall(xch, &hypercall); > > + if ( rc != 0 ) > > + goto done; > > + > > + if ( pfn ) > > + *pfn = arg->pfn; > > + > > + if ( buf_pfn ) > > + *buf_pfn = arg->buf_pfn; > > + > > + if ( buf_port ) > > + *buf_port = arg->buf_port; > > + > > +done: > > + xc_hypercall_buffer_free(xch, arg); > > + return rc; > > +} > > + > > +int xc_hvm_map_io_range_to_ioreq_server(xc_interface *xch, domid_t > domid, > > + ioservid_t id, int is_mmio, > > + uint64_t start, uint64_t end) > > +{ > > + DECLARE_HYPERCALL; > > + > DECLARE_HYPERCALL_BUFFER(xen_hvm_map_io_range_to_ioreq_server_t, > arg); > > + int rc; > > + > > + arg = xc_hypercall_buffer_alloc(xch, arg, sizeof(*arg)); > > + if ( arg == NULL ) > > + return -1; > > + > > + hypercall.op = __HYPERVISOR_hvm_op; > > + hypercall.arg[0] = HVMOP_map_io_range_to_ioreq_server; > > + hypercall.arg[1] = HYPERCALL_BUFFER_AS_ARG(arg); > > + arg->domid = domid; > > + arg->id = id; > > + arg->is_mmio = is_mmio; > > + arg->start = start; > > + arg->end = end; > > + rc = do_xen_hypercall(xch, &hypercall); > > + xc_hypercall_buffer_free(xch, arg); > > + return rc; > > +} > > + > > +int xc_hvm_unmap_io_range_from_ioreq_server(xc_interface *xch, > domid_t domid, > > + ioservid_t id, int is_mmio, > > + uint64_t start) > > +{ > > + DECLARE_HYPERCALL; > > + > DECLARE_HYPERCALL_BUFFER(xen_hvm_unmap_io_range_from_ioreq_ser > ver_t, arg); > > + int rc; > > + > > + arg = xc_hypercall_buffer_alloc(xch, arg, sizeof(*arg)); > > + if ( arg == NULL ) > > + return -1; > > + > > + hypercall.op = __HYPERVISOR_hvm_op; > > + hypercall.arg[0] = HVMOP_unmap_io_range_from_ioreq_server; > > + hypercall.arg[1] = HYPERCALL_BUFFER_AS_ARG(arg); > > + arg->domid = domid; > > + arg->id = id; > > + arg->is_mmio = is_mmio; > > + arg->start = start; > > + rc = do_xen_hypercall(xch, &hypercall); > > + xc_hypercall_buffer_free(xch, arg); > > + return rc; > > +} > > + > > +int xc_hvm_map_pcidev_to_ioreq_server(xc_interface *xch, domid_t > domid, > > + ioservid_t id, uint16_t bdf) > > +{ > > + DECLARE_HYPERCALL; > > + > DECLARE_HYPERCALL_BUFFER(xen_hvm_map_pcidev_to_ioreq_server_t, > arg); > > + int rc; > > + > > + arg = xc_hypercall_buffer_alloc(xch, arg, sizeof(*arg)); > > + if ( arg == NULL ) > > + return -1; > > + > > + hypercall.op = __HYPERVISOR_hvm_op; > > + hypercall.arg[0] = HVMOP_map_pcidev_to_ioreq_server; > > + hypercall.arg[1] = HYPERCALL_BUFFER_AS_ARG(arg); > > + arg->domid = domid; > > + arg->id = id; > > + arg->bdf = bdf; > > + rc = do_xen_hypercall(xch, &hypercall); > > + xc_hypercall_buffer_free(xch, arg); > > + return rc; > > +} > > + > > +int xc_hvm_unmap_pcidev_from_ioreq_server(xc_interface *xch, > domid_t domid, > > + ioservid_t id, uint16_t bdf) > > +{ > > + DECLARE_HYPERCALL; > > + > DECLARE_HYPERCALL_BUFFER(xen_hvm_unmap_pcidev_from_ioreq_serve > r_t, arg); > > + int rc; > > + > > + arg = xc_hypercall_buffer_alloc(xch, arg, sizeof(*arg)); > > + if ( arg == NULL ) > > + return -1; > > + > > + hypercall.op = __HYPERVISOR_hvm_op; > > + hypercall.arg[0] = HVMOP_unmap_pcidev_from_ioreq_server; > > + hypercall.arg[1] = HYPERCALL_BUFFER_AS_ARG(arg); > > + arg->domid = domid; > > + arg->id = id; > > + arg->bdf = bdf; > > + rc = do_xen_hypercall(xch, &hypercall); > > + xc_hypercall_buffer_free(xch, arg); > > + return rc; > > +} > > + > > +int xc_hvm_destroy_ioreq_server(xc_interface *xch, > > + domid_t domid, > > + ioservid_t id) > > +{ > > + DECLARE_HYPERCALL; > > + DECLARE_HYPERCALL_BUFFER(xen_hvm_destroy_ioreq_server_t, arg); > > + int rc; > > + > > + arg = xc_hypercall_buffer_alloc(xch, arg, sizeof(*arg)); > > + if ( arg == NULL ) > > + return -1; > > + > > + hypercall.op = __HYPERVISOR_hvm_op; > > + hypercall.arg[0] = HVMOP_destroy_ioreq_server; > > + hypercall.arg[1] = HYPERCALL_BUFFER_AS_ARG(arg); > > + arg->domid = domid; > > + arg->id = id; > > + rc = do_xen_hypercall(xch, &hypercall); > > + xc_hypercall_buffer_free(xch, arg); > > + return rc; > > +} > > + > > int xc_domain_setdebugging(xc_interface *xch, > > uint32_t domid, > > unsigned int enable) > > diff --git a/tools/libxc/xc_domain_restore.c > b/tools/libxc/xc_domain_restore.c > > index 1f6ce50..3116653 100644 > > --- a/tools/libxc/xc_domain_restore.c > > +++ b/tools/libxc/xc_domain_restore.c > > @@ -746,6 +746,7 @@ typedef struct { > > uint64_t acpi_ioport_location; > > uint64_t viridian; > > uint64_t vm_generationid_addr; > > + uint64_t nr_ioreq_servers; > > > > struct toolstack_data_t tdata; > > } pagebuf_t; > > @@ -996,6 +997,16 @@ static int pagebuf_get_one(xc_interface *xch, > struct restore_ctx *ctx, > > DPRINTF("read generation id buffer address"); > > return pagebuf_get_one(xch, ctx, buf, fd, dom); > > > > + case XC_SAVE_ID_HVM_NR_IOREQ_SERVERS: > > + /* Skip padding 4 bytes then read the acpi ioport location. */ > > + if ( RDEXACT(fd, &buf->nr_ioreq_servers, sizeof(uint32_t)) || > > + RDEXACT(fd, &buf->nr_ioreq_servers, sizeof(uint64_t)) ) > > + { > > + PERROR("error reading the number of IOREQ servers"); > > + return -1; > > + } > > + return pagebuf_get_one(xch, ctx, buf, fd, dom); > > + > > default: > > if ( (count > MAX_BATCH_SIZE) || (count < 0) ) { > > ERROR("Max batch size exceeded (%d). Giving up.", count); > > @@ -1755,6 +1766,15 @@ int xc_domain_restore(xc_interface *xch, int > io_fd, uint32_t dom, > > if (pagebuf.viridian != 0) > > xc_set_hvm_param(xch, dom, HVM_PARAM_VIRIDIAN, 1); > > > > + if ( hvm ) { > > + int nr_ioreq_servers = pagebuf.nr_ioreq_servers; > > + > > + if ( nr_ioreq_servers == 0 ) > > + nr_ioreq_servers = 1; > > + > > + xc_set_hvm_param(xch, dom, HVM_PARAM_NR_IOREQ_SERVERS, > nr_ioreq_servers); > > + } > > + > > if (pagebuf.acpi_ioport_location == 1) { > > DBGPRINTF("Use new firmware ioport from the checkpoint\n"); > > xc_set_hvm_param(xch, dom, > HVM_PARAM_ACPI_IOPORTS_LOCATION, 1); > > diff --git a/tools/libxc/xc_domain_save.c b/tools/libxc/xc_domain_save.c > > index 42c4752..3293e29 100644 > > --- a/tools/libxc/xc_domain_save.c > > +++ b/tools/libxc/xc_domain_save.c > > @@ -1731,6 +1731,18 @@ int xc_domain_save(xc_interface *xch, int io_fd, > uint32_t dom, uint32_t max_iter > > PERROR("Error when writing the viridian flag"); > > goto out; > > } > > + > > + chunk.id = XC_SAVE_ID_HVM_NR_IOREQ_SERVERS; > > + chunk.data = 0; > > + xc_get_hvm_param(xch, dom, HVM_PARAM_NR_IOREQ_SERVERS, > > + (unsigned long *)&chunk.data); > > + > > + if ( (chunk.data != 0) && > > + wrexact(io_fd, &chunk, sizeof(chunk)) ) > > + { > > + PERROR("Error when writing the number of IOREQ servers"); > > + goto out; > > + } > > } > > > > if ( callbacks != NULL && callbacks->toolstack_save != NULL ) > > diff --git a/tools/libxc/xc_hvm_build_x86.c > b/tools/libxc/xc_hvm_build_x86.c > > index b65e702..6d6328a 100644 > > --- a/tools/libxc/xc_hvm_build_x86.c > > +++ b/tools/libxc/xc_hvm_build_x86.c > > @@ -45,7 +45,7 @@ > > #define SPECIALPAGE_IDENT_PT 4 > > #define SPECIALPAGE_CONSOLE 5 > > #define SPECIALPAGE_IOREQ 6 > > -#define NR_SPECIAL_PAGES SPECIALPAGE_IOREQ + 2 /* ioreq server > needs 2 pages */ > > +#define NR_SPECIAL_PAGES(n) SPECIALPAGE_IOREQ + (2 * n) /* ioreq > server needs 2 pages */ > > #define special_pfn(x) (0xff000u - 1 - (x)) > > > > #define VGA_HOLE_SIZE (0x20) > > @@ -85,7 +85,8 @@ static int modules_init(struct xc_hvm_build_args > *args, > > } > > > > static void build_hvm_info(void *hvm_info_page, uint64_t mem_size, > > - uint64_t mmio_start, uint64_t mmio_size) > > + uint64_t mmio_start, uint64_t mmio_size, > > + int max_emulators) > > { > > struct hvm_info_table *hvm_info = (struct hvm_info_table *) > > (((unsigned char *)hvm_info_page) + HVM_INFO_OFFSET); > > @@ -113,7 +114,7 @@ static void build_hvm_info(void *hvm_info_page, > uint64_t mem_size, > > /* Memory parameters. */ > > hvm_info->low_mem_pgend = lowmem_end >> PAGE_SHIFT; > > hvm_info->high_mem_pgend = highmem_end >> PAGE_SHIFT; > > - hvm_info->reserved_mem_pgstart = special_pfn(0) - > NR_SPECIAL_PAGES; > > + hvm_info->reserved_mem_pgstart = special_pfn(0) - > NR_SPECIAL_PAGES(max_emulators); > > > > /* Finish with the checksum. */ > > for ( i = 0, sum = 0; i < hvm_info->length; i++ ) > > @@ -256,6 +257,10 @@ static int setup_guest(xc_interface *xch, > > stat_1gb_pages = 0; > > int pod_mode = 0; > > int claim_enabled = args->claim_enabled; > > + int max_emulators = args->max_emulators; > > + > > + if ( max_emulators < 1 ) > > + goto error_out; > > > > if ( nr_pages > target_pages ) > > pod_mode = XENMEMF_populate_on_demand; > > @@ -468,12 +473,13 @@ static int setup_guest(xc_interface *xch, > > xch, dom, PAGE_SIZE, PROT_READ | PROT_WRITE, > > HVM_INFO_PFN)) == NULL ) > > goto error_out; > > - build_hvm_info(hvm_info_page, v_end, mmio_start, mmio_size); > > + build_hvm_info(hvm_info_page, v_end, mmio_start, mmio_size, > > + max_emulators); > > munmap(hvm_info_page, PAGE_SIZE); > > > > /* Allocate and clear special pages. */ > > > > - DPRINTF("%d SPECIAL PAGES:\n", NR_SPECIAL_PAGES); > > + DPRINTF("%d SPECIAL PAGES:\n", > NR_SPECIAL_PAGES(max_emulators)); > > DPRINTF(" PAGING: %"PRI_xen_pfn"\n", > > (xen_pfn_t)special_pfn(SPECIALPAGE_PAGING)); > > DPRINTF(" ACCESS: %"PRI_xen_pfn"\n", > > @@ -486,10 +492,10 @@ static int setup_guest(xc_interface *xch, > > (xen_pfn_t)special_pfn(SPECIALPAGE_IDENT_PT)); > > DPRINTF(" CONSOLE: %"PRI_xen_pfn"\n", > > (xen_pfn_t)special_pfn(SPECIALPAGE_CONSOLE)); > > - DPRINTF(" IOREQ: %"PRI_xen_pfn"\n", > > + DPRINTF(" IOREQ(%02d): %"PRI_xen_pfn"\n", max_emulators * 2, > > (xen_pfn_t)special_pfn(SPECIALPAGE_IOREQ)); > > > > - for ( i = 0; i < NR_SPECIAL_PAGES; i++ ) > > + for ( i = 0; i < NR_SPECIAL_PAGES(max_emulators); i++ ) > > { > > xen_pfn_t pfn = special_pfn(i); > > rc = xc_domain_populate_physmap_exact(xch, dom, 1, 0, 0, &pfn); > > @@ -515,7 +521,9 @@ static int setup_guest(xc_interface *xch, > > xc_set_hvm_param(xch, dom, HVM_PARAM_IOREQ_PFN, > > special_pfn(SPECIALPAGE_IOREQ)); > > xc_set_hvm_param(xch, dom, HVM_PARAM_BUFIOREQ_PFN, > > - special_pfn(SPECIALPAGE_IOREQ) - 1); > > + special_pfn(SPECIALPAGE_IOREQ) - max_emulators); > > + xc_set_hvm_param(xch, dom, HVM_PARAM_NR_IOREQ_SERVERS, > > + max_emulators); > > > > /* > > * Identity-map page table is required for running with CR0.PG=0 when > > diff --git a/tools/libxc/xenctrl.h b/tools/libxc/xenctrl.h > > index 13f816b..84cab13 100644 > > --- a/tools/libxc/xenctrl.h > > +++ b/tools/libxc/xenctrl.h > > @@ -1801,6 +1801,47 @@ void xc_clear_last_error(xc_interface *xch); > > int xc_set_hvm_param(xc_interface *handle, domid_t dom, int param, > unsigned long value); > > int xc_get_hvm_param(xc_interface *handle, domid_t dom, int param, > unsigned long *value); > > > > +/* > > + * IOREQ server API > > + */ > > +int xc_hvm_create_ioreq_server(xc_interface *xch, > > + domid_t domid, > > + ioservid_t *id); > > + > > +int xc_hvm_get_ioreq_server_info(xc_interface *xch, > > + domid_t domid, > > + ioservid_t id, > > + xen_pfn_t *pfn, > > + xen_pfn_t *buf_pfn, > > + evtchn_port_t *buf_port); > > + > > +int xc_hvm_map_io_range_to_ioreq_server(xc_interface *xch, > > + domid_t domid, > > + ioservid_t id, > > + int is_mmio, > > + uint64_t start, > > + uint64_t end); > > + > > +int xc_hvm_unmap_io_range_from_ioreq_server(xc_interface *xch, > > + domid_t domid, > > + ioservid_t id, > > + int is_mmio, > > + uint64_t start); > > + > > +int xc_hvm_map_pcidev_to_ioreq_server(xc_interface *xch, > > + domid_t domid, > > + ioservid_t id, > > + uint16_t bdf); > > + > > +int xc_hvm_unmap_pcidev_from_ioreq_server(xc_interface *xch, > > + domid_t domid, > > + ioservid_t id, > > + uint16_t bdf); > > + > > +int xc_hvm_destroy_ioreq_server(xc_interface *xch, > > + domid_t domid, > > + ioservid_t id); > > + > > /* HVM guest pass-through */ > > int xc_assign_device(xc_interface *xch, > > uint32_t domid, > > @@ -2428,3 +2469,13 @@ int xc_kexec_load(xc_interface *xch, uint8_t > type, uint16_t arch, > > int xc_kexec_unload(xc_interface *xch, int type); > > > > #endif /* XENCTRL_H */ > > + > > +/* > > + * Local variables: > > + * mode: C > > + * c-file-style: "BSD" > > + * c-basic-offset: 4 > > + * tab-width: 4 > > + * indent-tabs-mode: nil > > + * End: > > + */ > > diff --git a/tools/libxc/xenguest.h b/tools/libxc/xenguest.h > > index a0e30e1..1300933 100644 > > --- a/tools/libxc/xenguest.h > > +++ b/tools/libxc/xenguest.h > > @@ -234,6 +234,8 @@ struct xc_hvm_build_args { > > struct xc_hvm_firmware_module smbios_module; > > /* Whether to use claim hypercall (1 - enable, 0 - disable). */ > > int claim_enabled; > > + /* Maximum number of emulators for VM */ > > + int max_emulators; > > }; > > > > /** > > @@ -306,3 +308,13 @@ xen_pfn_t *xc_map_m2p(xc_interface *xch, > > int prot, > > unsigned long *mfn0); > > #endif /* XENGUEST_H */ > > + > > +/* > > + * Local variables: > > + * mode: C > > + * c-file-style: "BSD" > > + * c-basic-offset: 4 > > + * tab-width: 4 > > + * indent-tabs-mode: nil > > + * End: > > + */ > > diff --git a/tools/libxc/xg_save_restore.h b/tools/libxc/xg_save_restore.h > > index f859621..5170b7f 100644 > > --- a/tools/libxc/xg_save_restore.h > > +++ b/tools/libxc/xg_save_restore.h > > @@ -259,6 +259,7 @@ > > #define XC_SAVE_ID_HVM_ACCESS_RING_PFN -16 > > #define XC_SAVE_ID_HVM_SHARING_RING_PFN -17 > > #define XC_SAVE_ID_TOOLSTACK -18 /* Optional toolstack specific > info */ > > +#define XC_SAVE_ID_HVM_NR_IOREQ_SERVERS -19 > > > > /* > > ** We process save/restore/migrate in batches of pages; the below > > diff --git a/tools/libxl/libxl.h b/tools/libxl/libxl.h > > index 06bbca6..5a70b76 100644 > > --- a/tools/libxl/libxl.h > > +++ b/tools/libxl/libxl.h > > @@ -95,6 +95,14 @@ > > #define LIBXL_HAVE_BUILDINFO_EVENT_CHANNELS 1 > > > > /* > > + * LIBXL_HAVE_BUILDINFO_HVM_MAX_EMULATORS indicates that the > > + * max_emulators field is present in the hvm sections of > > + * libxl_domain_build_info. This field can be used to reserve > > + * extra special pages for secondary device emulators. > > + */ > > +#define LIBXL_HAVE_BUILDINFO_HVM_MAX_EMULATORS 1 > > + > > +/* > > * libxl ABI compatibility > > * > > * The only guarantee which libxl makes regarding ABI compatibility > > diff --git a/tools/libxl/libxl_create.c b/tools/libxl/libxl_create.c > > index a604cd8..cce93d9 100644 > > --- a/tools/libxl/libxl_create.c > > +++ b/tools/libxl/libxl_create.c > > @@ -330,6 +330,9 @@ int libxl__domain_build_info_setdefault(libxl__gc > *gc, > > > > libxl_defbool_setdefault(&b_info->u.hvm.gfx_passthru, false); > > > > + if (b_info->u.hvm.max_emulators < 1) > > + b_info->u.hvm.max_emulators = 1; > > + > > break; > > case LIBXL_DOMAIN_TYPE_PV: > > libxl_defbool_setdefault(&b_info->u.pv.e820_host, false); > > diff --git a/tools/libxl/libxl_dom.c b/tools/libxl/libxl_dom.c > > index 55f74b2..9de06f9 100644 > > --- a/tools/libxl/libxl_dom.c > > +++ b/tools/libxl/libxl_dom.c > > @@ -637,6 +637,7 @@ int libxl__build_hvm(libxl__gc *gc, uint32_t domid, > > args.mem_size = (uint64_t)(info->max_memkb - info->video_memkb) > << 10; > > args.mem_target = (uint64_t)(info->target_memkb - info- > >video_memkb) << 10; > > args.claim_enabled = libxl_defbool_val(info->claim_mode); > > + args.max_emulators = info->u.hvm.max_emulators; > > if (libxl__domain_firmware(gc, info, &args)) { > > LOG(ERROR, "initializing domain firmware failed"); > > goto out; > > diff --git a/tools/libxl/libxl_types.idl b/tools/libxl/libxl_types.idl > > index 649ce50..b707159 100644 > > --- a/tools/libxl/libxl_types.idl > > +++ b/tools/libxl/libxl_types.idl > > @@ -372,6 +372,7 @@ libxl_domain_build_info = > Struct("domain_build_info",[ > > ("xen_platform_pci", libxl_defbool), > > ("usbdevice_list", libxl_string_list), > > ("vendor_device", libxl_vendor_device), > > + ("max_emulators", integer), > > ])), > > ("pv", Struct(None, [("kernel", string), > > ("slack_memkb", MemKB), > > diff --git a/tools/libxl/xl_cmdimpl.c b/tools/libxl/xl_cmdimpl.c > > index 4fc46eb..cf9b67d 100644 > > --- a/tools/libxl/xl_cmdimpl.c > > +++ b/tools/libxl/xl_cmdimpl.c > > @@ -1750,6 +1750,9 @@ skip_vfb: > > > > b_info->u.hvm.vendor_device = d; > > } > > + > > + if (!xlu_cfg_get_long (config, "secondary_device_emulators", &l, 0)) > > + b_info->u.hvm.max_emulators = l + 1; > > } > > > > xlu_cfg_destroy(config); > > diff --git a/xen/arch/x86/hvm/hvm.c b/xen/arch/x86/hvm/hvm.c > > index fb2dd73..e8b73fa 100644 > > --- a/xen/arch/x86/hvm/hvm.c > > +++ b/xen/arch/x86/hvm/hvm.c > > @@ -357,14 +357,21 @@ static ioreq_t *get_ioreq(struct > hvm_ioreq_server *s, int id) > > bool_t hvm_io_pending(struct vcpu *v) > > { > > struct domain *d = v->domain; > > - struct hvm_ioreq_server *s = d->arch.hvm_domain.ioreq_server; > > - ioreq_t *p; > > + struct list_head *entry; > > > > - if ( !s ) > > - return 0; > > + list_for_each ( entry, &d->arch.hvm_domain.ioreq_server_list ) > > + { > > + struct hvm_ioreq_server *s = list_entry(entry, > > + struct hvm_ioreq_server, > > + list_entry); > > + ioreq_t *p = get_ioreq(s, v->vcpu_id); > > > > - p = get_ioreq(s, v->vcpu_id); > > - return ( p->state != STATE_IOREQ_NONE ); > > + p = get_ioreq(s, v->vcpu_id); > > + if ( p->state != STATE_IOREQ_NONE ) > > + return 1; > > + } > > + > > + return 0; > > } > > > > static void hvm_wait_on_io(struct domain *d, ioreq_t *p) > > @@ -394,18 +401,20 @@ static void hvm_wait_on_io(struct domain *d, > ioreq_t *p) > > void hvm_do_resume(struct vcpu *v) > > { > > struct domain *d = v->domain; > > - struct hvm_ioreq_server *s = d->arch.hvm_domain.ioreq_server; > > + struct list_head *entry; > > > > check_wakeup_from_wait(); > > > > if ( is_hvm_vcpu(v) ) > > pt_restore_timer(v); > > > > - if ( s ) > > + list_for_each ( entry, &d->arch.hvm_domain.ioreq_server_list ) > > { > > - ioreq_t *p = get_ioreq(s, v->vcpu_id); > > + struct hvm_ioreq_server *s = list_entry(entry, > > + struct hvm_ioreq_server, > > + list_entry); > > > > - hvm_wait_on_io(d, p); > > + hvm_wait_on_io(d, get_ioreq(s, v->vcpu_id)); > > } > > > > /* Inject pending hw/sw trap */ > > @@ -543,6 +552,83 @@ static int hvm_print_line( > > return X86EMUL_OKAY; > > } > > > > +static int hvm_access_cf8( > > + int dir, uint32_t port, uint32_t bytes, uint32_t *val) > > +{ > > + struct vcpu *curr = current; > > + struct hvm_domain *hd = &curr->domain->arch.hvm_domain; > > + int rc; > > + > > + BUG_ON(port < 0xcf8); > > + port -= 0xcf8; > > + > > + spin_lock(&hd->pci_lock); > > + > > + if ( dir == IOREQ_WRITE ) > > + { > > + switch ( bytes ) > > + { > > + case 4: > > + hd->pci_cf8 = *val; > > + break; > > + > > + case 2: > > + { > > + uint32_t mask = 0xffff << (port * 8); > > + uint32_t subval = *val << (port * 8); > > + > > + hd->pci_cf8 = (hd->pci_cf8 & ~mask) | > > + (subval & mask); > > + break; > > + } > > + > > + case 1: > > + { > > + uint32_t mask = 0xff << (port * 8); > > + uint32_t subval = *val << (port * 8); > > + > > + hd->pci_cf8 = (hd->pci_cf8 & ~mask) | > > + (subval & mask); > > + break; > > + } > > + > > + default: > > + break; > > + } > > + > > + /* We always need to fall through to the catch all emulator */ > > + rc = X86EMUL_UNHANDLEABLE; > > + } > > + else > > + { > > + switch ( bytes ) > > + { > > + case 4: > > + *val = hd->pci_cf8; > > + rc = X86EMUL_OKAY; > > + break; > > + > > + case 2: > > + *val = (hd->pci_cf8 >> (port * 8)) & 0xffff; > > + rc = X86EMUL_OKAY; > > + break; > > + > > + case 1: > > + *val = (hd->pci_cf8 >> (port * 8)) & 0xff; > > + rc = X86EMUL_OKAY; > > + break; > > + > > + default: > > + rc = X86EMUL_UNHANDLEABLE; > > + break; > > + } > > + } > > + > > + spin_unlock(&hd->pci_lock); > > + > > + return rc; > > +} > > + > > static int handle_pvh_io( > > int dir, uint32_t port, uint32_t bytes, uint32_t *val) > > { > > @@ -618,39 +704,53 @@ static void > hvm_ioreq_server_remove_vcpu(struct hvm_ioreq_server *s, struct vcpu > > } > > } > > > > -static int hvm_create_ioreq_server(struct domain *d, domid_t domid) > > +static int hvm_create_ioreq_server(struct domain *d, ioservid_t id, > domid_t domid) > > { > > struct hvm_ioreq_server *s; > > unsigned long pfn; > > struct vcpu *v; > > int i, rc; > > > > + if ( id >= d- > >arch.hvm_domain.params[HVM_PARAM_NR_IOREQ_SERVERS] ) > > + return -EINVAL; > > + > > + spin_lock(&d->arch.hvm_domain.ioreq_server_lock); > > + > > rc = -EEXIST; > > - if ( d->arch.hvm_domain.ioreq_server != NULL ) > > - goto fail_exist; > > + list_for_each_entry ( s, > > + &d->arch.hvm_domain.ioreq_server_list, > > + list_entry ) > > + { > > + if ( s->id == id ) > > + goto fail_exist; > > + } > > > > - gdprintk(XENLOG_INFO, "%s: %d\n", __func__, d->domain_id); > > + gdprintk(XENLOG_INFO, "%s: %d:%d\n", __func__, d->domain_id, id); > > > > rc = -ENOMEM; > > s = xzalloc(struct hvm_ioreq_server); > > if ( !s ) > > goto fail_alloc; > > > > + s->id = id; > > s->domain = d; > > s->domid = domid; > > + INIT_LIST_HEAD(&s->mmio_range_list); > > + INIT_LIST_HEAD(&s->portio_range_list); > > + INIT_LIST_HEAD(&s->pcidev_list); > > > > for ( i = 0; i < MAX_HVM_VCPUS; i++ ) > > s->ioreq_evtchn[i] = -1; > > s->buf_ioreq_evtchn = -1; > > > > /* Initialize shared pages */ > > - pfn = d->arch.hvm_domain.params[HVM_PARAM_IOREQ_PFN]; > > + pfn = d->arch.hvm_domain.params[HVM_PARAM_IOREQ_PFN] - s->id; > > > > hvm_init_ioreq_page(s, 0); > > if ( (rc = hvm_set_ioreq_page(s, 0, pfn)) < 0 ) > > goto fail_set_ioreq; > > > > - pfn = d->arch.hvm_domain.params[HVM_PARAM_BUFIOREQ_PFN]; > > + pfn = d->arch.hvm_domain.params[HVM_PARAM_BUFIOREQ_PFN] - s- > >id; > > > > hvm_init_ioreq_page(s, 1); > > if ( (rc = hvm_set_ioreq_page(s, 1, pfn)) < 0 ) > > @@ -664,10 +764,12 @@ static int hvm_create_ioreq_server(struct domain > *d, domid_t domid) > > goto fail_add_vcpu; > > } > > > > - d->arch.hvm_domain.ioreq_server = s; > > + list_add(&s->list_entry, > > + &d->arch.hvm_domain.ioreq_server_list); > > > > domain_unpause(d); > > > > + spin_unlock(&d->arch.hvm_domain.ioreq_server_lock); > > return 0; > > > > fail_add_vcpu: > > @@ -681,23 +783,33 @@ fail_set_ioreq: > > xfree(s); > > fail_alloc: > > fail_exist: > > + spin_unlock(&d->arch.hvm_domain.ioreq_server_lock); > > return rc; > > } > > > > -static void hvm_destroy_ioreq_server(struct domain *d) > > +static void hvm_destroy_ioreq_server(struct domain *d, ioservid_t id) > > { > > struct hvm_ioreq_server *s; > > struct vcpu *v; > > > > - gdprintk(XENLOG_INFO, "%s: %d\n", __func__, d->domain_id); > > + spin_lock(&d->arch.hvm_domain.ioreq_server_lock); > > > > - s = d->arch.hvm_domain.ioreq_server; > > - if ( !s ) > > - return; > > + list_for_each_entry ( s, > > + &d->arch.hvm_domain.ioreq_server_list, > > + list_entry) > > + { > > + if ( s->id == id ) > > + goto found; > > + } > > + > > + goto done; > > + > > +found: > > + gdprintk(XENLOG_INFO, "%s: %d:%d\n", __func__, d->domain_id, id); > > > > domain_pause(d); > > > > - d->arch.hvm_domain.ioreq_server = NULL; > > + list_del_init(&s->list_entry); > > > > for_each_vcpu ( d, v ) > > hvm_ioreq_server_remove_vcpu(s, v); > > @@ -708,31 +820,373 @@ static void hvm_destroy_ioreq_server(struct > domain *d) > > hvm_destroy_ioreq_page(s, 0); > > > > xfree(s); > > + > > +done: > > + spin_unlock(&d->arch.hvm_domain.ioreq_server_lock); > > } > > > > -static int hvm_get_ioreq_server_buf_port(struct domain *d, > evtchn_port_t *port) > > +static int hvm_get_ioreq_server_buf_port(struct domain *d, ioservid_t > id, > > + evtchn_port_t *port) > > { > > - struct hvm_ioreq_server *s = d->arch.hvm_domain.ioreq_server; > > + struct list_head *entry; > > + int rc; > > > > - if ( !s ) > > - return -ENOENT; > > + if ( id >= d- > >arch.hvm_domain.params[HVM_PARAM_NR_IOREQ_SERVERS] ) > > + return -EINVAL; > > + > > + spin_lock(&d->arch.hvm_domain.ioreq_server_lock); > > + > > + rc = -ENOENT; > > + list_for_each ( entry, > > + &d->arch.hvm_domain.ioreq_server_list ) > > + { > > + struct hvm_ioreq_server *s = list_entry(entry, > > + struct hvm_ioreq_server, > > + list_entry); > > + > > + if ( s->id == id ) > > + { > > + *port = s->buf_ioreq_evtchn; > > + rc = 0; > > + break; > > + } > > + } > > + > > + spin_unlock(&d->arch.hvm_domain.ioreq_server_lock); > > + > > + return rc; > > +} > > + > > +static int hvm_get_ioreq_server_pfn(struct domain *d, ioservid_t id, int > buf, > > + xen_pfn_t *pfn) > > +{ > > + struct list_head *entry; > > + int rc; > > + > > + if ( id >= d- > >arch.hvm_domain.params[HVM_PARAM_NR_IOREQ_SERVERS] ) > > + return -EINVAL; > > + > > + spin_lock(&d->arch.hvm_domain.ioreq_server_lock); > > + > > + rc = -ENOENT; > > + list_for_each ( entry, > > + &d->arch.hvm_domain.ioreq_server_list ) > > + { > > + struct hvm_ioreq_server *s = list_entry(entry, > > + struct hvm_ioreq_server, > > + list_entry); > > + > > + if ( s->id == id ) > > + { > > + int i = ( buf ) ? HVM_PARAM_BUFIOREQ_PFN : > HVM_PARAM_IOREQ_PFN; > > + > > + *pfn = d->arch.hvm_domain.params[i] - s->id; > > + rc = 0; > > + break; > > + } > > + } > > + > > + spin_unlock(&d->arch.hvm_domain.ioreq_server_lock); > > + > > + return rc; > > +} > > + > > +static int hvm_map_io_range_to_ioreq_server(struct domain *d, > ioservid_t id, > > + int is_mmio, uint64_t start, uint64_t end) > > +{ > > + struct hvm_ioreq_server *s; > > + struct hvm_io_range *x; > > + struct list_head *list; > > + int rc; > > + > > + if ( id >= d- > >arch.hvm_domain.params[HVM_PARAM_NR_IOREQ_SERVERS] ) > > + return -EINVAL; > > + > > + x = xmalloc(struct hvm_io_range); > > + if ( x == NULL ) > > + return -ENOMEM; > > + > > + spin_lock(&d->arch.hvm_domain.ioreq_server_lock); > > + > > + rc = -ENOENT; > > + list_for_each_entry ( s, > > + &d->arch.hvm_domain.ioreq_server_list, > > + list_entry ) > > + { > > + if ( s->id == id ) > > + goto found; > > + } > > + > > + goto fail; > > + > > +found: > > + INIT_RCU_HEAD(&x->rcu); > > + x->start = start; > > + x->end = end; > > + > > + list = ( is_mmio ) ? &s->mmio_range_list : &s->portio_range_list; > > + list_add_rcu(&x->list_entry, list); > > + > > + gdprintk(XENLOG_DEBUG, "%d:%d: +%s %"PRIX64" - %"PRIX64"\n", > > + d->domain_id, > > + s->id, > > + ( is_mmio ) ? "MMIO" : "PORTIO", > > + x->start, > > + x->end); > > + > > + spin_unlock(&d->arch.hvm_domain.ioreq_server_lock); > > > > - *port = s->buf_ioreq_evtchn; > > return 0; > > + > > +fail: > > + xfree(x); > > + > > + spin_unlock(&d->arch.hvm_domain.ioreq_server_lock); > > + > > + return rc; > > } > > > > -static int hvm_get_ioreq_server_pfn(struct domain *d, int buf, xen_pfn_t > *pfn) > > +static void free_io_range(struct rcu_head *rcu) > > { > > - struct hvm_ioreq_server *s = d->arch.hvm_domain.ioreq_server; > > - int i; > > + struct hvm_io_range *x; > > > > - if ( !s ) > > - return -ENOENT; > > + x = container_of (rcu, struct hvm_io_range, rcu); > > + > > + xfree(x); > > +} > > + > > +static int hvm_unmap_io_range_from_ioreq_server(struct domain *d, > ioservid_t id, > > + int is_mmio, uint64_t start) > > +{ > > + struct hvm_ioreq_server *s; > > + struct list_head *list, *entry; > > + int rc; > > + > > + if ( id >= d- > >arch.hvm_domain.params[HVM_PARAM_NR_IOREQ_SERVERS] ) > > + return -EINVAL; > > + > > + spin_lock(&d->arch.hvm_domain.ioreq_server_lock); > > + > > + rc = -ENOENT; > > + list_for_each_entry ( s, > > + &d->arch.hvm_domain.ioreq_server_list, > > + list_entry ) > > + { > > + if ( s->id == id ) > > + goto found; > > + } > > + > > + goto done; > > + > > +found: > > + list = ( is_mmio ) ? &s->mmio_range_list : &s->portio_range_list; > > + > > + list_for_each ( entry, > > + list ) > > + { > > + struct hvm_io_range *x = list_entry(entry, > > + struct hvm_io_range, > > + list_entry); > > + > > + if ( start == x->start ) > > + { > > + gdprintk(XENLOG_DEBUG, "%d:%d: -%s %"PRIX64" - %"PRIX64"\n", > > + d->domain_id, > > + s->id, > > + ( is_mmio ) ? "MMIO" : "PORTIO", > > + x->start, > > + x->end); > > + > > + list_del_rcu(&x->list_entry); > > + call_rcu(&x->rcu, free_io_range); > > > > - i = ( buf ) ? HVM_PARAM_BUFIOREQ_PFN : HVM_PARAM_IOREQ_PFN; > > - *pfn = d->arch.hvm_domain.params[i]; > > + rc = 0; > > + break; > > + } > > + } > > + > > +done: > > + spin_unlock(&d->arch.hvm_domain.ioreq_server_lock); > > + > > + return rc; > > +} > > + > > +static int hvm_map_pcidev_to_ioreq_server(struct domain *d, ioservid_t > id, > > + uint16_t bdf) > > +{ > > + struct hvm_ioreq_server *s; > > + struct hvm_pcidev *x; > > + int rc; > > + > > + if ( id >= d- > >arch.hvm_domain.params[HVM_PARAM_NR_IOREQ_SERVERS] ) > > + return -EINVAL; > > + > > + x = xmalloc(struct hvm_pcidev); > > + if ( x == NULL ) > > + return -ENOMEM; > > + > > + spin_lock(&d->arch.hvm_domain.ioreq_server_lock); > > + > > + rc = -ENOENT; > > + list_for_each_entry ( s, > > + &d->arch.hvm_domain.ioreq_server_list, > > + list_entry ) > > + { > > + if ( s->id == id ) > > + goto found; > > + } > > + > > + goto fail; > > + > > +found: > > + INIT_RCU_HEAD(&x->rcu); > > + x->bdf = bdf; > > + > > + list_add_rcu(&x->list_entry, &s->pcidev_list); > > + > > + gdprintk(XENLOG_DEBUG, "%d:%d: +PCIDEV %04X\n", > > + d->domain_id, > > + s->id, > > + x->bdf); > > + > > + spin_unlock(&d->arch.hvm_domain.ioreq_server_lock); > > > > return 0; > > + > > +fail: > > + xfree(x); > > + > > + spin_unlock(&d->arch.hvm_domain.ioreq_server_lock); > > + > > + return rc; > > +} > > + > > +static void free_pcidev(struct rcu_head *rcu) > > +{ > > + struct hvm_pcidev *x; > > + > > + x = container_of (rcu, struct hvm_pcidev, rcu); > > + > > + xfree(x); > > +} > > + > > +static int hvm_unmap_pcidev_from_ioreq_server(struct domain *d, > ioservid_t id, > > + uint16_t bdf) > > +{ > > + struct hvm_ioreq_server *s; > > + struct list_head *entry; > > + int rc; > > + > > + if ( id >= d- > >arch.hvm_domain.params[HVM_PARAM_NR_IOREQ_SERVERS] ) > > + return -EINVAL; > > + > > + spin_lock(&d->arch.hvm_domain.ioreq_server_lock); > > + > > + rc = -ENOENT; > > + list_for_each_entry ( s, > > + &d->arch.hvm_domain.ioreq_server_list, > > + list_entry ) > > + { > > + if ( s->id == id ) > > + goto found; > > + } > > + > > + goto done; > > + > > +found: > > + list_for_each ( entry, > > + &s->pcidev_list ) > > + { > > + struct hvm_pcidev *x = list_entry(entry, > > + struct hvm_pcidev, > > + list_entry); > > + > > + if ( bdf == x->bdf ) > > + { > > + gdprintk(XENLOG_DEBUG, "%d:%d: -PCIDEV %04X\n", > > + d->domain_id, > > + s->id, > > + x->bdf); > > + > > + list_del_rcu(&x->list_entry); > > + call_rcu(&x->rcu, free_pcidev); > > + > > + rc = 0; > > + break; > > + } > > + } > > + > > +done: > > + spin_unlock(&d->arch.hvm_domain.ioreq_server_lock); > > + > > + return rc; > > +} > > + > > +static int hvm_all_ioreq_servers_add_vcpu(struct domain *d, struct vcpu > *v) > > +{ > > + struct list_head *entry; > > + int rc; > > + > > + spin_lock(&d->arch.hvm_domain.ioreq_server_lock); > > + > > + list_for_each ( entry, > > + &d->arch.hvm_domain.ioreq_server_list ) > > + { > > + struct hvm_ioreq_server *s = list_entry(entry, > > + struct hvm_ioreq_server, > > + list_entry); > > + > > + if ( (rc = hvm_ioreq_server_add_vcpu(s, v)) < 0 ) > > + goto fail; > > + } > > + > > + spin_unlock(&d->arch.hvm_domain.ioreq_server_lock); > > + > > + return 0; > > + > > +fail: > > + list_for_each ( entry, > > + &d->arch.hvm_domain.ioreq_server_list ) > > + { > > + struct hvm_ioreq_server *s = list_entry(entry, > > + struct hvm_ioreq_server, > > + list_entry); > > + > > + hvm_ioreq_server_remove_vcpu(s, v); > > + } > > + > > + spin_unlock(&d->arch.hvm_domain.ioreq_server_lock); > > + > > + return rc; > > +} > > + > > +static void hvm_all_ioreq_servers_remove_vcpu(struct domain *d, struct > vcpu *v) > > +{ > > + struct list_head *entry; > > + > > + spin_lock(&d->arch.hvm_domain.ioreq_server_lock); > > + > > + list_for_each ( entry, > > + &d->arch.hvm_domain.ioreq_server_list ) > > + { > > + struct hvm_ioreq_server *s = list_entry(entry, > > + struct hvm_ioreq_server, > > + list_entry); > > + > > + hvm_ioreq_server_remove_vcpu(s, v); > > + } > > + > > + spin_unlock(&d->arch.hvm_domain.ioreq_server_lock); > > +} > > + > > +static void hvm_destroy_all_ioreq_servers(struct domain *d) > > +{ > > + ioservid_t id; > > + > > + for ( id = 0; > > + id < d- > >arch.hvm_domain.params[HVM_PARAM_NR_IOREQ_SERVERS]; > > + id++ ) > > + hvm_destroy_ioreq_server(d, id); > > } > > > > static int hvm_replace_event_channel(struct vcpu *v, domid_t > remote_domid, > > @@ -750,18 +1204,31 @@ static int hvm_replace_event_channel(struct > vcpu *v, domid_t remote_domid, > > return 0; > > } > > > > -static int hvm_set_ioreq_server_domid(struct domain *d, domid_t > domid) > > +static int hvm_set_ioreq_server_domid(struct domain *d, ioservid_t id, > domid_t domid) > > { > > - struct hvm_ioreq_server *s = d->arch.hvm_domain.ioreq_server; > > + struct hvm_ioreq_server *s; > > struct vcpu *v; > > int rc = 0; > > > > + if ( id >= d- > >arch.hvm_domain.params[HVM_PARAM_NR_IOREQ_SERVERS] ) > > + return -EINVAL; > > + > > + spin_lock(&d->arch.hvm_domain.ioreq_server_lock); > > + > > domain_pause(d); > > > > + list_for_each_entry ( s, > > + &d->arch.hvm_domain.ioreq_server_list, > > + list_entry ) > > + { > > + if ( s->id == id ) > > + goto found; > > + } > > + > > rc = -ENOENT; > > - if ( !s ) > > - goto done; > > + goto done; > > > > +found: > > rc = 0; > > if ( s->domid == domid ) > > goto done; > > @@ -787,6 +1254,8 @@ static int hvm_set_ioreq_server_domid(struct > domain *d, domid_t domid) > > done: > > domain_unpause(d); > > > > + spin_unlock(&d->arch.hvm_domain.ioreq_server_lock); > > + > > return rc; > > } > > > > @@ -817,6 +1286,9 @@ int hvm_domain_initialise(struct domain *d) > > > > } > > > > + spin_lock_init(&d->arch.hvm_domain.ioreq_server_lock); > > + INIT_LIST_HEAD(&d->arch.hvm_domain.ioreq_server_list); > > + spin_lock_init(&d->arch.hvm_domain.pci_lock); > > spin_lock_init(&d->arch.hvm_domain.irq_lock); > > spin_lock_init(&d->arch.hvm_domain.uc_lock); > > > > @@ -858,6 +1330,7 @@ int hvm_domain_initialise(struct domain *d) > > rtc_init(d); > > > > register_portio_handler(d, 0xe9, 1, hvm_print_line); > > + register_portio_handler(d, 0xcf8, 4, hvm_access_cf8); > > > > rc = hvm_funcs.domain_initialise(d); > > if ( rc != 0 ) > > @@ -888,7 +1361,7 @@ void hvm_domain_relinquish_resources(struct > domain *d) > > if ( hvm_funcs.nhvm_domain_relinquish_resources ) > > hvm_funcs.nhvm_domain_relinquish_resources(d); > > > > - hvm_destroy_ioreq_server(d); > > + hvm_destroy_all_ioreq_servers(d); > > > > msixtbl_pt_cleanup(d); > > > > @@ -1520,7 +1993,6 @@ int hvm_vcpu_initialise(struct vcpu *v) > > { > > int rc; > > struct domain *d = v->domain; > > - struct hvm_ioreq_server *s = d->arch.hvm_domain.ioreq_server; > > > > hvm_asid_flush_vcpu(v); > > > > @@ -1563,12 +2035,9 @@ int hvm_vcpu_initialise(struct vcpu *v) > > && (rc = nestedhvm_vcpu_initialise(v)) < 0 ) /* teardown: > nestedhvm_vcpu_destroy */ > > goto fail5; > > > > - if ( s ) > > - { > > - rc = hvm_ioreq_server_add_vcpu(s, v); > > - if ( rc < 0 ) > > - goto fail6; > > - } > > + rc = hvm_all_ioreq_servers_add_vcpu(d, v); > > + if ( rc < 0 ) > > + goto fail6; > > > > if ( v->vcpu_id == 0 ) > > { > > @@ -1604,10 +2073,8 @@ int hvm_vcpu_initialise(struct vcpu *v) > > void hvm_vcpu_destroy(struct vcpu *v) > > { > > struct domain *d = v->domain; > > - struct hvm_ioreq_server *s = d->arch.hvm_domain.ioreq_server; > > > > - if ( s ) > > - hvm_ioreq_server_remove_vcpu(s, v); > > + hvm_all_ioreq_servers_remove_vcpu(d, v); > > > > nestedhvm_vcpu_destroy(v); > > > > @@ -1646,11 +2113,112 @@ void hvm_vcpu_down(struct vcpu *v) > > } > > } > > > > +static DEFINE_RCU_READ_LOCK(ioreq_server_rcu_lock); > > + > > +static struct hvm_ioreq_server *hvm_select_ioreq_server(struct vcpu *v, > ioreq_t *p) > > +{ > > +#define BDF(cf8) (((cf8) & 0x00ffff00) >> 8) > > + > > + struct domain *d = v->domain; > > + struct hvm_ioreq_server *s; > > + uint8_t type; > > + uint64_t addr; > > + > > + if ( p->type == IOREQ_TYPE_PIO && > > + (p->addr & ~3) == 0xcfc ) > > + { > > + /* PCI config data cycle */ > > + type = IOREQ_TYPE_PCI_CONFIG; > > + > > + spin_lock(&d->arch.hvm_domain.pci_lock); > > + addr = d->arch.hvm_domain.pci_cf8 + (p->addr & 3); > > + spin_unlock(&d->arch.hvm_domain.pci_lock); > > + } > > + else > > + { > > + type = p->type; > > + addr = p->addr; > > + } > > + > > + rcu_read_lock(&ioreq_server_rcu_lock); > > + > > + switch ( type ) > > + { > > + case IOREQ_TYPE_COPY: > > + case IOREQ_TYPE_PIO: > > + case IOREQ_TYPE_PCI_CONFIG: > > + break; > > + default: > > + goto done; > > + } > > + > > + list_for_each_entry ( s, > > + &d->arch.hvm_domain.ioreq_server_list, > > + list_entry ) > > + { > > + switch ( type ) > > + { > > + case IOREQ_TYPE_COPY: > > + case IOREQ_TYPE_PIO: { > > + struct list_head *list; > > + struct hvm_io_range *x; > > + > > + list = ( type == IOREQ_TYPE_COPY ) ? > > + &s->mmio_range_list : > > + &s->portio_range_list; > > + > > + list_for_each_entry ( x, > > + list, > > + list_entry ) > > + { > > + if ( (addr >= x->start) && (addr <= x->end) ) > > + goto found; > > + } > > + break; > > + } > > + case IOREQ_TYPE_PCI_CONFIG: { > > + struct hvm_pcidev *x; > > + > > + list_for_each_entry ( x, > > + &s->pcidev_list, > > + list_entry ) > > + { > > + if ( BDF(addr) == x->bdf ) { > > + p->type = type; > > + p->addr = addr; > > + goto found; > > + } > > + } > > + break; > > + } > > + } > > + } > > + > > +done: > > + /* The catch-all server has id 0 */ > > + list_for_each_entry ( s, > > + &d->arch.hvm_domain.ioreq_server_list, > > + list_entry ) > > + { > > + if ( s->id == 0 ) > > + goto found; > > + } > > + > > + s = NULL; > > + > > +found: > > + rcu_read_unlock(&ioreq_server_rcu_lock); > > + > > + return s; > > + > > +#undef BDF > > +} > > + > > int hvm_buffered_io_send(ioreq_t *p) > > { > > struct vcpu *v = current; > > struct domain *d = v->domain; > > - struct hvm_ioreq_server *s = d->arch.hvm_domain.ioreq_server; > > + struct hvm_ioreq_server *s; > > struct hvm_ioreq_page *iorp; > > buffered_iopage_t *pg; > > buf_ioreq_t bp; > > @@ -1660,6 +2228,7 @@ int hvm_buffered_io_send(ioreq_t *p) > > /* Ensure buffered_iopage fits in a page */ > > BUILD_BUG_ON(sizeof(buffered_iopage_t) > PAGE_SIZE); > > > > + s = hvm_select_ioreq_server(v, p); > > if ( !s ) > > return 0; > > > > @@ -1770,18 +2339,34 @@ static bool_t > hvm_send_assist_req_to_server(struct hvm_ioreq_server *s, > > > > bool_t hvm_send_assist_req(struct vcpu *v, ioreq_t *p) > > { > > - struct domain *d = v->domain; > > - struct hvm_ioreq_server *s = d->arch.hvm_domain.ioreq_server; > > + struct hvm_ioreq_server *s; > > > > if ( unlikely(!vcpu_start_shutdown_deferral(v)) ) > > return 0; > > > > + s = hvm_select_ioreq_server(v, p); > > if ( !s ) > > return 0; > > > > return hvm_send_assist_req_to_server(s, v, p); > > } > > > > +void hvm_broadcast_assist_req(struct vcpu *v, ioreq_t *p) > > +{ > > + struct domain *d = v->domain; > > + struct list_head *entry; > > + > > + list_for_each ( entry, > > + &d->arch.hvm_domain.ioreq_server_list ) > > + { > > + struct hvm_ioreq_server *s = list_entry(entry, > > + struct hvm_ioreq_server, > > + list_entry); > > + > > + (void) hvm_send_assist_req_to_server(s, v, p); > > + } > > +} > > + > > void hvm_hlt(unsigned long rflags) > > { > > struct vcpu *curr = current; > > @@ -4370,6 +4955,215 @@ static int hvmop_flush_tlb_all(void) > > return 0; > > } > > > > +static int hvmop_create_ioreq_server( > > + XEN_GUEST_HANDLE_PARAM(xen_hvm_create_ioreq_server_t) uop) > > +{ > > + struct domain *curr_d = current->domain; > > + xen_hvm_create_ioreq_server_t op; > > + struct domain *d; > > + ioservid_t id; > > + int rc; > > + > > + if ( copy_from_guest(&op, uop, 1) ) > > + return -EFAULT; > > + > > + rc = rcu_lock_remote_domain_by_id(op.domid, &d); > > + if ( rc != 0 ) > > + return rc; > > + > > + rc = -EINVAL; > > + if ( !is_hvm_domain(d) ) > > + goto out; > > + > > + rc = -ENOSPC; > > + for ( id = 1; > > + id < d- > >arch.hvm_domain.params[HVM_PARAM_NR_IOREQ_SERVERS]; > > + id++ ) > > + { > > + rc = hvm_create_ioreq_server(d, id, curr_d->domain_id); > > + if ( rc == -EEXIST ) > > + continue; > > + > > + break; > > + } > > + > > + if ( rc == -EEXIST ) > > + rc = -ENOSPC; > > + > > + if ( rc < 0 ) > > + goto out; > > + > > + op.id = id; > > + > > + rc = copy_to_guest(uop, &op, 1) ? -EFAULT : 0; > > + > > +out: > > + rcu_unlock_domain(d); > > + return rc; > > +} > > + > > +static int hvmop_get_ioreq_server_info( > > + XEN_GUEST_HANDLE_PARAM(xen_hvm_get_ioreq_server_info_t) > uop) > > +{ > > + xen_hvm_get_ioreq_server_info_t op; > > + struct domain *d; > > + int rc; > > + > > + if ( copy_from_guest(&op, uop, 1) ) > > + return -EFAULT; > > + > > + rc = rcu_lock_remote_domain_by_id(op.domid, &d); > > + if ( rc != 0 ) > > + return rc; > > + > > + rc = -EINVAL; > > + if ( !is_hvm_domain(d) ) > > + goto out; > > + > > + if ( (rc = hvm_get_ioreq_server_pfn(d, op.id, 0, &op.pfn)) < 0 ) > > + goto out; > > + > > + if ( (rc = hvm_get_ioreq_server_pfn(d, op.id, 1, &op.buf_pfn)) < 0 ) > > + goto out; > > + > > + if ( (rc = hvm_get_ioreq_server_buf_port(d, op.id, &op.buf_port)) < 0 ) > > + goto out; > > + > > + rc = copy_to_guest(uop, &op, 1) ? -EFAULT : 0; > > + > > +out: > > + rcu_unlock_domain(d); > > + return rc; > > +} > > + > > +static int hvmop_map_io_range_to_ioreq_server( > > + > XEN_GUEST_HANDLE_PARAM(xen_hvm_map_io_range_to_ioreq_server_t > ) uop) > > +{ > > + xen_hvm_map_io_range_to_ioreq_server_t op; > > + struct domain *d; > > + int rc; > > + > > + if ( copy_from_guest(&op, uop, 1) ) > > + return -EFAULT; > > + > > + rc = rcu_lock_remote_domain_by_id(op.domid, &d); > > + if ( rc != 0 ) > > + return rc; > > + > > + rc = -EINVAL; > > + if ( !is_hvm_domain(d) ) > > + goto out; > > + > > + rc = hvm_map_io_range_to_ioreq_server(d, op.id, op.is_mmio, > > + op.start, op.end); > > + > > +out: > > + rcu_unlock_domain(d); > > + return rc; > > +} > > + > > +static int hvmop_unmap_io_range_from_ioreq_server( > > + > XEN_GUEST_HANDLE_PARAM(xen_hvm_unmap_io_range_from_ioreq_ser > ver_t) uop) > > +{ > > + xen_hvm_unmap_io_range_from_ioreq_server_t op; > > + struct domain *d; > > + int rc; > > + > > + if ( copy_from_guest(&op, uop, 1) ) > > + return -EFAULT; > > + > > + rc = rcu_lock_remote_domain_by_id(op.domid, &d); > > + if ( rc != 0 ) > > + return rc; > > + > > + rc = -EINVAL; > > + if ( !is_hvm_domain(d) ) > > + goto out; > > + > > + rc = hvm_unmap_io_range_from_ioreq_server(d, op.id, op.is_mmio, > > + op.start); > > + > > +out: > > + rcu_unlock_domain(d); > > + return rc; > > +} > > + > > +static int hvmop_map_pcidev_to_ioreq_server( > > + > XEN_GUEST_HANDLE_PARAM(xen_hvm_map_pcidev_to_ioreq_server_t) > uop) > > +{ > > + xen_hvm_map_pcidev_to_ioreq_server_t op; > > + struct domain *d; > > + int rc; > > + > > + if ( copy_from_guest(&op, uop, 1) ) > > + return -EFAULT; > > + > > + rc = rcu_lock_remote_domain_by_id(op.domid, &d); > > + if ( rc != 0 ) > > + return rc; > > + > > + rc = -EINVAL; > > + if ( !is_hvm_domain(d) ) > > + goto out; > > + > > + rc = hvm_map_pcidev_to_ioreq_server(d, op.id, op.bdf); > > + > > +out: > > + rcu_unlock_domain(d); > > + return rc; > > +} > > + > > +static int hvmop_unmap_pcidev_from_ioreq_server( > > + > XEN_GUEST_HANDLE_PARAM(xen_hvm_unmap_pcidev_from_ioreq_serve > r_t) uop) > > +{ > > + xen_hvm_unmap_pcidev_from_ioreq_server_t op; > > + struct domain *d; > > + int rc; > > + > > + if ( copy_from_guest(&op, uop, 1) ) > > + return -EFAULT; > > + > > + rc = rcu_lock_remote_domain_by_id(op.domid, &d); > > + if ( rc != 0 ) > > + return rc; > > + > > + rc = -EINVAL; > > + if ( !is_hvm_domain(d) ) > > + goto out; > > + > > + rc = hvm_unmap_pcidev_from_ioreq_server(d, op.id, op.bdf); > > + > > +out: > > + rcu_unlock_domain(d); > > + return rc; > > +} > > + > > +static int hvmop_destroy_ioreq_server( > > + XEN_GUEST_HANDLE_PARAM(xen_hvm_destroy_ioreq_server_t) > uop) > > +{ > > + xen_hvm_destroy_ioreq_server_t op; > > + struct domain *d; > > + int rc; > > + > > + if ( copy_from_guest(&op, uop, 1) ) > > + return -EFAULT; > > + > > + rc = rcu_lock_remote_domain_by_id(op.domid, &d); > > + if ( rc != 0 ) > > + return rc; > > + > > + rc = -EINVAL; > > + if ( !is_hvm_domain(d) ) > > + goto out; > > + > > + hvm_destroy_ioreq_server(d, op.id); > > + rc = 0; > > + > > +out: > > + rcu_unlock_domain(d); > > + return rc; > > +} > > + > > long do_hvm_op(unsigned long op, XEN_GUEST_HANDLE_PARAM(void) > arg) > > > > { > > @@ -4378,6 +5172,41 @@ long do_hvm_op(unsigned long op, > XEN_GUEST_HANDLE_PARAM(void) arg) > > > > switch ( op ) > > { > > + case HVMOP_create_ioreq_server: > > + rc = hvmop_create_ioreq_server( > > + guest_handle_cast(arg, xen_hvm_create_ioreq_server_t)); > > + break; > > + > > + case HVMOP_get_ioreq_server_info: > > + rc = hvmop_get_ioreq_server_info( > > + guest_handle_cast(arg, xen_hvm_get_ioreq_server_info_t)); > > + break; > > + > > + case HVMOP_map_io_range_to_ioreq_server: > > + rc = hvmop_map_io_range_to_ioreq_server( > > + guest_handle_cast(arg, > xen_hvm_map_io_range_to_ioreq_server_t)); > > + break; > > + > > + case HVMOP_unmap_io_range_from_ioreq_server: > > + rc = hvmop_unmap_io_range_from_ioreq_server( > > + guest_handle_cast(arg, > xen_hvm_unmap_io_range_from_ioreq_server_t)); > > + break; > > + > > + case HVMOP_map_pcidev_to_ioreq_server: > > + rc = hvmop_map_pcidev_to_ioreq_server( > > + guest_handle_cast(arg, > xen_hvm_map_pcidev_to_ioreq_server_t)); > > + break; > > + > > + case HVMOP_unmap_pcidev_from_ioreq_server: > > + rc = hvmop_unmap_pcidev_from_ioreq_server( > > + guest_handle_cast(arg, > xen_hvm_unmap_pcidev_from_ioreq_server_t)); > > + break; > > + > > + case HVMOP_destroy_ioreq_server: > > + rc = hvmop_destroy_ioreq_server( > > + guest_handle_cast(arg, xen_hvm_destroy_ioreq_server_t)); > > + break; > > + > > case HVMOP_set_param: > > case HVMOP_get_param: > > { > > @@ -4466,9 +5295,9 @@ long do_hvm_op(unsigned long op, > XEN_GUEST_HANDLE_PARAM(void) arg) > > if ( a.value == DOMID_SELF ) > > a.value = curr_d->domain_id; > > > > - rc = hvm_create_ioreq_server(d, a.value); > > + rc = hvm_create_ioreq_server(d, 0, a.value); > > if ( rc == -EEXIST ) > > - rc = hvm_set_ioreq_server_domid(d, a.value); > > + rc = hvm_set_ioreq_server_domid(d, 0, a.value); > > break; > > case HVM_PARAM_ACPI_S_STATE: > > /* Not reflexive, as we must domain_pause(). */ > > @@ -4533,6 +5362,10 @@ long do_hvm_op(unsigned long op, > XEN_GUEST_HANDLE_PARAM(void) arg) > > if ( a.value > SHUTDOWN_MAX ) > > rc = -EINVAL; > > break; > > + case HVM_PARAM_NR_IOREQ_SERVERS: > > + if ( d == current->domain ) > > + rc = -EPERM; > > + break; > > } > > > > if ( rc == 0 ) > > @@ -4567,7 +5400,7 @@ long do_hvm_op(unsigned long op, > XEN_GUEST_HANDLE_PARAM(void) arg) > > case HVM_PARAM_BUFIOREQ_PFN: > > case HVM_PARAM_BUFIOREQ_EVTCHN: > > /* May need to create server */ > > - rc = hvm_create_ioreq_server(d, curr_d->domain_id); > > + rc = hvm_create_ioreq_server(d, 0, curr_d->domain_id); > > if ( rc != 0 && rc != -EEXIST ) > > goto param_fail; > > > > @@ -4576,7 +5409,7 @@ long do_hvm_op(unsigned long op, > XEN_GUEST_HANDLE_PARAM(void) arg) > > case HVM_PARAM_IOREQ_PFN: { > > xen_pfn_t pfn; > > > > - if ( (rc = hvm_get_ioreq_server_pfn(d, 0, &pfn)) < 0 ) > > + if ( (rc = hvm_get_ioreq_server_pfn(d, 0, 0, &pfn)) < 0 ) > > goto param_fail; > > > > a.value = pfn; > > @@ -4585,7 +5418,7 @@ long do_hvm_op(unsigned long op, > XEN_GUEST_HANDLE_PARAM(void) arg) > > case HVM_PARAM_BUFIOREQ_PFN: { > > xen_pfn_t pfn; > > > > - if ( (rc = hvm_get_ioreq_server_pfn(d, 1, &pfn)) < 0 ) > > + if ( (rc = hvm_get_ioreq_server_pfn(d, 0, 1, &pfn)) < 0 ) > > goto param_fail; > > > > a.value = pfn; > > @@ -4594,7 +5427,7 @@ long do_hvm_op(unsigned long op, > XEN_GUEST_HANDLE_PARAM(void) arg) > > case HVM_PARAM_BUFIOREQ_EVTCHN: { > > evtchn_port_t port; > > > > - if ( (rc = hvm_get_ioreq_server_buf_port(d, &port)) < 0 ) > > + if ( (rc = hvm_get_ioreq_server_buf_port(d, 0, &port)) < 0 ) > > goto param_fail; > > > > a.value = port; > > diff --git a/xen/arch/x86/hvm/io.c b/xen/arch/x86/hvm/io.c > > index c9adb94..ac0d867 100644 > > --- a/xen/arch/x86/hvm/io.c > > +++ b/xen/arch/x86/hvm/io.c > > @@ -75,7 +75,7 @@ void send_invalidate_req(void) > > .data = ~0UL, /* flush all */ > > }; > > > > - (void)hvm_send_assist_req(v, &p); > > + hvm_broadcast_assist_req(v, &p); > > } > > > > int handle_mmio(void) > > diff --git a/xen/include/asm-x86/hvm/domain.h b/xen/include/asm- > x86/hvm/domain.h > > index a77b83d..e9da543 100644 > > --- a/xen/include/asm-x86/hvm/domain.h > > +++ b/xen/include/asm-x86/hvm/domain.h > > @@ -41,17 +41,38 @@ struct hvm_ioreq_page { > > void *va; > > }; > > > > +struct hvm_io_range { > > + struct list_head list_entry; > > + uint64_t start, end; > > + struct rcu_head rcu; > > +}; > > + > > +struct hvm_pcidev { > > + struct list_head list_entry; > > + uint16_t bdf; > > + struct rcu_head rcu; > > +}; > > + > > struct hvm_ioreq_server { > > + struct list_head list_entry; > > + ioservid_t id; > > struct domain *domain; > > domid_t domid; > > struct hvm_ioreq_page ioreq; > > int ioreq_evtchn[MAX_HVM_VCPUS]; > > struct hvm_ioreq_page buf_ioreq; > > int buf_ioreq_evtchn; > > + struct list_head mmio_range_list; > > + struct list_head portio_range_list; > > + struct list_head pcidev_list; > > }; > > > > struct hvm_domain { > > - struct hvm_ioreq_server *ioreq_server; > > + struct list_head ioreq_server_list; > > + spinlock_t ioreq_server_lock; > > + uint32_t pci_cf8; > > + spinlock_t pci_lock; > > + > > struct pl_time pl_time; > > > > struct hvm_io_handler *io_handler; > > diff --git a/xen/include/asm-x86/hvm/hvm.h b/xen/include/asm- > x86/hvm/hvm.h > > index 40aeddf..4118669 100644 > > --- a/xen/include/asm-x86/hvm/hvm.h > > +++ b/xen/include/asm-x86/hvm/hvm.h > > @@ -229,6 +229,7 @@ int prepare_ring_for_helper(struct domain *d, > unsigned long gmfn, > > void destroy_ring_for_helper(void **_va, struct page_info *page); > > > > bool_t hvm_send_assist_req(struct vcpu *v, ioreq_t *p); > > +void hvm_broadcast_assist_req(struct vcpu *v, ioreq_t *p); > > > > void hvm_get_guest_pat(struct vcpu *v, u64 *guest_pat); > > int hvm_set_guest_pat(struct vcpu *v, u64 guest_pat); > > diff --git a/xen/include/public/hvm/hvm_op.h > b/xen/include/public/hvm/hvm_op.h > > index a9aab4b..6b31189 100644 > > --- a/xen/include/public/hvm/hvm_op.h > > +++ b/xen/include/public/hvm/hvm_op.h > > @@ -23,6 +23,7 @@ > > > > #include "../xen.h" > > #include "../trace.h" > > +#include "../event_channel.h" > > > > /* Get/set subcommands: extra argument == pointer to xen_hvm_param > struct. */ > > #define HVMOP_set_param 0 > > @@ -270,6 +271,75 @@ struct xen_hvm_inject_msi { > > typedef struct xen_hvm_inject_msi xen_hvm_inject_msi_t; > > DEFINE_XEN_GUEST_HANDLE(xen_hvm_inject_msi_t); > > > > +typedef uint32_t ioservid_t; > > + > > +DEFINE_XEN_GUEST_HANDLE(ioservid_t); > > + > > +#define HVMOP_create_ioreq_server 17 > > +struct xen_hvm_create_ioreq_server { > > + domid_t domid; /* IN - domain to be serviced */ > > + ioservid_t id; /* OUT - server id */ > > +}; > > +typedef struct xen_hvm_create_ioreq_server > xen_hvm_create_ioreq_server_t; > > +DEFINE_XEN_GUEST_HANDLE(xen_hvm_create_ioreq_server_t); > > + > > +#define HVMOP_get_ioreq_server_info 18 > > +struct xen_hvm_get_ioreq_server_info { > > + domid_t domid; /* IN - domain to be serviced */ > > + ioservid_t id; /* IN - server id */ > > + xen_pfn_t pfn; /* OUT - ioreq pfn */ > > + xen_pfn_t buf_pfn; /* OUT - buf ioreq pfn */ > > + evtchn_port_t buf_port; /* OUT - buf ioreq port */ > > +}; > > +typedef struct xen_hvm_get_ioreq_server_info > xen_hvm_get_ioreq_server_info_t; > > +DEFINE_XEN_GUEST_HANDLE(xen_hvm_get_ioreq_server_info_t); > > + > > +#define HVMOP_map_io_range_to_ioreq_server 19 > > +struct xen_hvm_map_io_range_to_ioreq_server { > > + domid_t domid; /* IN - domain to be serviced */ > > + ioservid_t id; /* IN - handle from > HVMOP_register_ioreq_server */ > > + int is_mmio; /* IN - MMIO or port IO? */ > > + uint64_aligned_t start, end; /* IN - inclusive start and end of range */ > > +}; > > +typedef struct xen_hvm_map_io_range_to_ioreq_server > xen_hvm_map_io_range_to_ioreq_server_t; > > > +DEFINE_XEN_GUEST_HANDLE(xen_hvm_map_io_range_to_ioreq_server_ > t); > > + > > +#define HVMOP_unmap_io_range_from_ioreq_server 20 > > +struct xen_hvm_unmap_io_range_from_ioreq_server { > > + domid_t domid; /* IN - domain to be serviced */ > > + ioservid_t id; /* IN - handle from HVMOP_register_ioreq_server */ > > + uint8_t is_mmio; /* IN - MMIO or port IO? */ > > + uint64_aligned_t start; /* IN - start address of the range to remove */ > > +}; > > +typedef struct xen_hvm_unmap_io_range_from_ioreq_server > xen_hvm_unmap_io_range_from_ioreq_server_t; > > > +DEFINE_XEN_GUEST_HANDLE(xen_hvm_unmap_io_range_from_ioreq_se > rver_t); > > + > > +#define HVMOP_map_pcidev_to_ioreq_server 21 > > +struct xen_hvm_map_pcidev_to_ioreq_server { > > + domid_t domid; /* IN - domain to be serviced */ > > + ioservid_t id; /* IN - handle from HVMOP_register_ioreq_server */ > > + uint16_t bdf; /* IN - PCI bus/dev/func */ > > +}; > > +typedef struct xen_hvm_map_pcidev_to_ioreq_server > xen_hvm_map_pcidev_to_ioreq_server_t; > > > +DEFINE_XEN_GUEST_HANDLE(xen_hvm_map_pcidev_to_ioreq_server_t); > > + > > +#define HVMOP_unmap_pcidev_from_ioreq_server 22 > > +struct xen_hvm_unmap_pcidev_from_ioreq_server { > > + domid_t domid; /* IN - domain to be serviced */ > > + ioservid_t id; /* IN - handle from HVMOP_register_ioreq_server */ > > + uint16_t bdf; /* IN - PCI bus/dev/func */ > > +}; > > +typedef struct xen_hvm_unmap_pcidev_from_ioreq_server > xen_hvm_unmap_pcidev_from_ioreq_server_t; > > > +DEFINE_XEN_GUEST_HANDLE(xen_hvm_unmap_pcidev_from_ioreq_serv > er_t); > > + > > +#define HVMOP_destroy_ioreq_server 23 > > +struct xen_hvm_destroy_ioreq_server { > > + domid_t domid; /* IN - domain to be serviced */ > > + ioservid_t id; /* IN - server id */ > > +}; > > +typedef struct xen_hvm_destroy_ioreq_server > xen_hvm_destroy_ioreq_server_t; > > +DEFINE_XEN_GUEST_HANDLE(xen_hvm_destroy_ioreq_server_t); > > + > > #endif /* defined(__XEN__) || defined(__XEN_TOOLS__) */ > > > > #endif /* __XEN_PUBLIC_HVM_HVM_OP_H__ */ > > diff --git a/xen/include/public/hvm/ioreq.h > b/xen/include/public/hvm/ioreq.h > > index f05d130..e84fa75 100644 > > --- a/xen/include/public/hvm/ioreq.h > > +++ b/xen/include/public/hvm/ioreq.h > > @@ -34,6 +34,7 @@ > > > > #define IOREQ_TYPE_PIO 0 /* pio */ > > #define IOREQ_TYPE_COPY 1 /* mmio ops */ > > +#define IOREQ_TYPE_PCI_CONFIG 2 /* pci config ops */ > > #define IOREQ_TYPE_TIMEOFFSET 7 > > #define IOREQ_TYPE_INVALIDATE 8 /* mapcache */ > > > > diff --git a/xen/include/public/hvm/params.h > b/xen/include/public/hvm/params.h > > index 517a184..4109b11 100644 > > --- a/xen/include/public/hvm/params.h > > +++ b/xen/include/public/hvm/params.h > > @@ -145,6 +145,8 @@ > > /* SHUTDOWN_* action in case of a triple fault */ > > #define HVM_PARAM_TRIPLE_FAULT_REASON 31 > > > > -#define HVM_NR_PARAMS 32 > > +#define HVM_PARAM_NR_IOREQ_SERVERS 32 > > + > > +#define HVM_NR_PARAMS 33 > > > > #endif /* __XEN_PUBLIC_HVM_PARAMS_H__ */ _______________________________________________ Xen-devel mailing list Xen-devel@lists.xen.org http://lists.xen.org/xen-devel From advisory-board-bounces@lists.xenproject.org Fri Mar 07 05:32:10 2014 Return-path: Envelope-to: archives@lists.xenproject.org Delivery-date: Fri, 07 Mar 2014 05:32:10 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WLnOE-00016Q-9J; Fri, 07 Mar 2014 05:32:10 +0000 Received: from mail6.bemta14.messagelabs.com ([193.109.254.103]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WLnOC-00016L-KD for advisory-board@lists.xenproject.org; Fri, 07 Mar 2014 05:32:09 +0000 Received: from [193.109.254.147:42585] by server-16.bemta-14.messagelabs.com id 68/2E-21945-7D959135; Fri, 07 Mar 2014 05:32:07 +0000 X-Env-Sender: Mark.Hinkle@citrix.com X-Msg-Ref: server-16.tower-27.messagelabs.com!1394170323!8988891!1 X-Originating-IP: [66.165.176.89] X-SpamReason: No, hits=0.0 required=7.0 tests=sa_preprocessor: VHJ1c3RlZCBJUDogNjYuMTY1LjE3Ni44OSA9PiAyMDMwMDc=\n X-StarScan-Received: X-StarScan-Version: 6.9.16; banners=-,-,- X-VirusChecked: Checked Received: (qmail 18570 invoked from network); 7 Mar 2014 05:32:05 -0000 Received: from smtp.citrix.com (HELO SMTP.CITRIX.COM) (66.165.176.89) by server-16.tower-27.messagelabs.com with RC4-SHA encrypted SMTP; 7 Mar 2014 05:32:05 -0000 X-IronPort-AV: E=Sophos;i="4.97,605,1389744000"; d="scan'208,217";a="109012577" Received: from accessns.citrite.net (HELO FTLPEX01CL03.citrite.net) ([10.9.154.239]) by FTLPIPO01.CITRIX.COM with ESMTP; 07 Mar 2014 05:32:03 +0000 Received: from FTLPEX01CL02.citrite.net ([169.254.2.39]) by FTLPEX01CL03.citrite.net ([169.254.1.115]) with mapi id 14.02.0342.004; Fri, 7 Mar 2014 00:32:02 -0500 From: Mark Hinkle To: Advisory-board discussions Thread-Topic: [Advisory-board] Xen Project 4.4 Release Thread-Index: AQHPN+bebhn/+yG6rkWud7aYk4GwRJrRvd0AgAEhnwCAADajgIAAB6+AgAGNyACAAMWOAA== Date: Fri, 7 Mar 2014 05:32:02 +0000 Message-ID: <2BCAC582-CB61-4E16-96C4-6C1AEFAF81FB@citrix.com> References: <6848793A-A83B-40A1-A40C-2AA9DCC1E80A@citrix.com>, , In-Reply-To: Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-originating-ip: [10.9.154.239] MIME-Version: 1.0 X-DLP: MIA1 Subject: Re: [Advisory-board] Xen Project 4.4 Release X-BeenThere: advisory-board@lists.xenproject.org X-Mailman-Version: 2.1.13 Precedence: list Reply-To: Advisory-board discussions List-Id: Advisory-board discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: multipart/mixed; boundary="===============0760182873058475793==" Sender: advisory-board-bounces@lists.xenproject.org Errors-To: advisory-board-bounces@lists.xenproject.org --===============0760182873058475793== Content-Language: en-US Content-Type: multipart/alternative; boundary="_000_2BCAC582CB614E1696C46C1AEFAF81FBcitrixcom_" --_000_2BCAC582CB614E1696C46C1AEFAF81FBcitrixcom_ Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 TXkgYXBvbG9naWVzIGZvciB0aGUgc2xvdyByZXBseSBJIHdhcyBzdHVjayBvbiB0aGUgcm9hZCBh bmQgY291bGRu4oCZdCByZWFkIHRoZSByZWxlYXNlIG9uIG15IHBob25lIHRvIGZvcm11bGF0ZSBh IHByb3BlciByZXNwb25zZS4gSSBzaG91bGQgbW92ZSB0byBhIGhpZ2hseSBlbGFzdGljIFhlbiBQ cm9qZWN0LXBvd2VyZWQgY2xvdWQgdGhhdCBhbGxvd3MgbWUgdG8gYXV0b3NjYWxlIDspIChzb3Jy eSBiYWQgY2xvdWQgam9rZSkuDQoNCkkgYW0gZmluZSB3aXRob3V0IGRvaW5nIHRoZSBhY3Jvbnlt IGFuZCBJIHRoaW5rIHRoZSByZWFsaWduaW5nIGFuZCBicmFuZGluZyBkaXNjdXNzaW9uIHNob3Vs ZCBiZSBoYWQuIEnigJlkIGxpa2UgdG8gaGF2ZSB0aGF0IGRpc2N1c3Npb24gZHVyaW5nIG91ciBu ZXh0IGJvYXJkIG1lZXRpbmcuIEdpdmVuIHRpbWUgaXMgb2YgdGhlIGVzc2VuY2UgSSB0aGluayB3 ZSBzaG91bGQganVzdCB1cGRhdGUgdGhlIGxpbmtzIHRvIHZlcnNpb24gdmVyc3VzIFhlbiA0LjMu MS4NCg0KQWxzbyBJIHRvb2sgYSBzaG90IGF0IHRoZSB3b3JkaW5nIG9mIHRoZSBwcmVzcyByZWxl YXNlLiBJdOKAmXMgcHJvYmFibHkgbm90IHBlcmZlY3QgYnV0IG1ha2VzIGl0IHJlYWQgYSBiaXQg YmV0dGVyLiBBdHRhY2hlZCBhcmUgbXkgcHJvcG9zZWQgZWRpdHMuIFNhcmFoLCBJIHNlbnQgeW91 IHRoZSB3b3JkIGRvYyB3aXRoIHRyYWNrIGNoYW5nZXMgYXNzdW1pbmcgd2UgaGF2ZSBzb21lIGVk aXRzIHRvIGFncmVlIG9uLg0KDQoNClJlZ2FyZHMsIE1hcmsNCg0KDQpYZW4gUHJvamVjdCBSZWxl YXNlcyBVcGRhdGUgdG8gRW50ZXJwcmlzZSBIeXBlcnZpc29yIFNvZnR3YXJlDQoNCk9wZW4gU291 cmNlIFZpcnR1YWxpemF0aW9uIFNvZnR3YXJlIFJlbGVhc2UgSW5jbHVkZXMgQWRkaXRpb25hbCBB Uk0gU3VwcG9ydCBhbmQgU2NhbGFiaWxpdHkgZm9yIENsb3VkIGFuZCBNb2JpbGUgRW52aXJvbm1l bnRzDQoNCg0KDQpTQU4gRlJBTkNJU0NPLCBNYXJjaCAxMCwgMjAxNCDigJMgWGVuIFByb2plY3Qs IGEgQ29sbGFib3JhdGl2ZSBQcm9qZWN0IGhvc3RlZCBhdCBUaGUgTGludXggRm91bmRhdGlvbiwg dG9kYXkgYW5ub3VuY2VkIGF2YWlsYWJpbGl0eSBvZiB0aGUgWGVuIFByb2plY3QgNC40IHdpdGgg ZW5oYW5jZWQgQVJNIHN1cHBvcnQuIFRoZSBsYXRlc3QgcmVsZWFzZSBhbHNvIGluY2x1ZGVzIG1h am9yIHBlcmZvcm1hbmNlIGFuZCBzeXN0ZW0gc2NhbGFiaWxpdHkgaW1wcm92ZW1lbnRzIGZvciBl bnRlcnByaXNlIGNvbXB1dGluZywgc3VjaCBhcyBtb2JpbGUgYW5kIGNsb3VkIGVudmlyb25tZW50 cywgd2hlcmUgdmlydHVhbGl6YXRpb24gdGVjaG5vbG9neSBpcyBpbmNyZWFzaW5nbHkgaW4gZGVt YW5kLg0KDQpUaGlzIHJlbGVhc2UgZnVydGhlciBhZHZhbmNlcyB0aGUgUHJvamVjdOKAmXMgcG9z aXRpb24gYXMgYSBmYXN0LCBzY2FsYWJsZSwgc2VjdXJlIHZpcnR1YWxpemF0aW9uIGVuZ2luZSBm b3IgdGhlIGluZHVzdHJ54oCZcyBicm9hZGVzdCByYW5nZSBvZiBzZXJ2ZXIsIFBDIGNoaXBzZXRz IGFuZCBuZXh0LWdlbmVyYXRpb24gbG93LXBvd2VyIHN5c3RlbXMgb24gY2hpcHMgKFNvQykuDQoN Ck1ham9yIGNvbnRyaWJ1dGlvbnMgZnJvbSBBTUQsIENpdHJpeCwgSW50ZWwsIE9yYWNsZSBhbmQg U1VTRSBhcmUgcHVzaGluZyB0aGUgWGVuIFByb2plY3Qgc29mdHdhcmUgdG8gdGFrZSBhZHZhbnRh Z2Ugb2YgdGhlIGxhdGVzdCBoYXJkd2FyZS4gQWRkaXRpb25hbGx5LCBkZXZlbG9wZXJzIGNyZWF0 aW5nIHNlcnZpY2VzIGFuZCBhcHBzIHdpdGggZW1iZWRkZWQsIG1vYmlsZSBhbmQgY2xvdWQgc3lz dGVtcyB3aWxsIGJlbmVmaXQgZnJvbSBuZXcgZmVhdHVyZXMgc3VjaCBhcyBldmVudCBjaGFubmVs aW5nIHdoZW4gc2NhbGluZyBvdXQgdGhlaXIgSW5mcmFzdHJ1Y3R1cmUgYXMgYSBTZXJ2aWNlIG9m ZmVyaW5ncy4NCg0K4oCcVmlydHVhbGl6YXRpb24gYW5kIGxvdy1wb3dlcmVkIHNlcnZlcnMgYXJl IGxlYWRpbmcgY29tcGFuaWVzIHRvIHJldGhpbmsgdGhlIGRhdGEgY2VudGVyIGFuZCBpdHMgcG90 ZW50aWFsIGZvciBlZmZpY2llbmN5LOKAnSBzYWlkIExhcnMgS3VydGgsIENoYWlybWFuIG9mIHRo ZSBYZW4gUHJvamVjdCBhZHZpc29yeSBib2FyZC4g4oCcT3VyIHNvbHV0aW9uIGNvbnRhaW5zIElU LXJlbGF0ZWQgY29zdHMsIHBsdXMgbWVldHMgdGhlIHNlY3VyaXR5IGFuZCBzY2FsYWJpbGl0eSBu ZWVkcyBvZiB0b2RheeKAmXMgZWxhc3RpYyBjbG91ZCwgbW9iaWxlIGFuZCBzb2NpYWwgbmV0d29y a2luZyBjb21wYW5pZXMuIFRoZSBsYXRlc3QgdXBkYXRlcyBjb250aW51ZSB0aGUgUHJvamVjdOKA mXMgdHJhY2sgcmVjb3JkIG9mIHJpY2ggY29sbGFib3JhdGlvbiBhbmQgd2lkZXNwcmVhZCBkZXZl bG9wbWVudCBmcm9tIG1hbnkgb2YgdGhlIHdvcmxk4oCZcyB0ZWNobm9sb2d5IGxlYWRlcnMuIFRo aXMgY2VydGFpbmx5IGV4cGxhaW5zIHRoZSBzaWduaWZpY2FudCBncm93dGggb2YgQVJNIHN1cHBv cnQsIHdoaWNoIHdl4oCZcmUgcGxlYXNlZCB0byBzZWUgYWR2YW5jZSBzbyBxdWlja2x5LuKAnQ0K DQpTdXBwb3J0IGZvciBBUk0gb24gWGVuIFByb2plY3QgQXJjaGl0ZWN0dXJlIEdyb3dzIFF1aWNr bHkNCg0KVGhlIG5ldyByZWxlYXNlIGludHJvZHVjZXMgc2lnbmlmaWNhbnQgc3RhYmlsaXR5LCB1 c2FiaWxpdHkgYW5kIHBlcmZvcm1hbmNlIGltcHJvdmVtZW50cyBmb3IgdGhlIEFSTSBhcmNoaXRl Y3R1cmUgYW5kIGV4dGVuZGVkIGhhcmR3YXJlIGNvbXBhdGliaWxpdHkuICBBcHBsaWVkTWljcm/i gJlzIFgtR2VuZSwgdGhlIEFybmRhbGUgQm9hcmQsIENhbHhlZGEgRUNYLTIwMDAsIFRJIE9NQVA1 IGFuZCB0aGUgQWxsd2lubmVyIFN1blhpIGJvYXJkcyBhcmUgYWxsIHN1cHBvcnRlZC4gVGhlIHN1 YnN0YW50aWFsbHkgaW1wcm92ZWQgbXVsdGlwbGF0Zm9ybSBjYXBhYmlsaXRpZXMgb2YgdGhlIGh5 cGVydmlzb3IgYWxsb3cgaGFyZHdhcmUgYW5kIGVtYmVkZGVkIHZlbmRvcnMgdG8gcG9ydCB0aGUg WGVuIFByb2plY3QgdGVjaG5vbG9neSB0byBuZXcgQVJNIFNvQ3MgZWFzaWx5LCBzaG9ydGVuaW5n IHRoZWlyIHRpbWUgdG8gbWFya2V0Lg0KDQoNCg0KQWRkaXRpb25hbCBlbmhhbmNlbWVudHMgaW4g dGhpcyByZWxlYXNlIGluY2x1ZGVkIDY0LWJpdCBndWVzdCBzdXBwb3J0IG9uIEFSTXY4IHBsYXRm b3Jtcy4gQWxsIHRoZSB1c2Vyc3BhY2UgdG9vbHMsIHN1Y2ggYXMgdGhlIHhsIG1hbmFnZW1lbnQg dG9vbCwgYXJlIDY0LWJpdCByZWFkeSBhbmQgY2FuIGJlIHVzZWQgdG8gY3JlYXRlIDY0LWJpdCB2 aXJ0dWFsIG1hY2hpbmVzIG91dCBvZiB0aGUgYm94Lg0KDQoNCg0KVGhlIFhlbiBQcm9qZWN0IGh5 cGVyY2FsbCBBQkkgaXMgbm93IHN0YWJsZSBhbmQgd2lsbCBiZSBtYWludGFpbmVkIGZvciBiYWNr d2FyZCBjb21wYXRpYmlsaXR5LCBzbyB1c2VycyBjYW4gdHJ1c3QgZnV0dXJlIHJlbGVhc2VzIHRv IGJvb3Qgb2xkZXIgb3BlcmF0aW5nIHN5c3RlbXMuDQoNCkFkZGl0aW9uYWwgaW1wcm92ZW1lbnRz IGluY2x1ZGUgZXh0ZW5kZWQgc3VwcG9ydCBmb3IgQVJNIHNwZWNpZmljIGJvb3Rsb2FkZXJzIGFu ZCBmaXJtd2FyZSBpbnRlcmZhY2VzLCBhbmQgc3VwcG9ydCBmb3IgcGh5c2ljYWwgcGFydGl0aW9u cyBhbmQgTFZNIHZvbHVtZXMgdG8gc3RvcmUgZGlza3Mgb2YgdmlydHVhbCBtYWNoaW5lcy4NCg0K DQoNCkltcHJvdmVkIEV2ZW50IENoYW5uZWwgU2NhbGFiaWxpdHkgRm9yIENsb3VkIENvbXB1dGlu Zw0KDQpYZW4gUHJvamVjdCBkZXZlbG9wZXJzIGNvbnRpbnVlcyB0byBkcml2ZSBpbm5vdmF0aW9u IGFuZCBjb2xsYWJvcmF0aW9uIGFyb3VuZCBzZXJ2ZXIgdmlydHVhbGl6YXRpb24gYW5kIHRoZSBj bG91ZC4gUG93ZXJpbmcgbWFueSBvZiB0aGUgbGFyZ2VzdCBjbG91ZHMgaW4gcHJvZHVjdGlvbiB0 b2RheSwgaW5jbHVkaW5nIEFtYXpvbiBFQzIsIFJhY2tzcGFjZSBDbG91ZCBhbmQgb3RoZXJzLCB0 aGUgY29tbXVuaXR5IHVuZGVyc3RhbmRzIHRoZSBuZWVkIHRvIHJ1biBtb3JlIHZpcnR1YWwgbWFj aGluZXMgb24gYSBzaW5nbGUgaG9zdC4NCg0KWWV0IGRlbWFuZHMgb24gaHlwZXJ2aXNvciBzY2Fs YWJpbGl0eSBjb250aW51ZSB0byBpbmNyZWFzZSwgYm90aCBmcm9tIGxhcmdlciBtYWNoaW5lcywg bmV3IHdvcmtsb2FkcyBzdWNoIGFzIHZpcnR1YWxpemF0aW9uIGRlc2t0b3AgaW5mcmFzdHJ1Y3R1 cmVzIChWREkpIGFuZCBuZXcgY2xvdWQgT1MgdGVjaG5vbG9naWVzLCBpbmNsdWRpbmcgTWlyYWdl T1MsIEVybGFuZ09uWGVuLCBPU3YsIGFuZCBIYWxWTS4gUmVjb2duaXppbmcgdGhhdCBoaWdoLWF2 YWlsYWJpbGl0eSBhbmQgc3RhYmlsaXR5IGFyZSBjcml0aWNhbCB0byBWRElzIGFuZCBjbG91ZCBk ZXBsb3ltZW50czsgdGhlIFhlblNlcnZlciB0ZWFtIGF0IENpdHJpeCBjb250cmlidXRlZCB0aGUg bmV3IGV2ZW50IGNoYW5uZWwgaW1wbGVtZW50YXRpb24gdG8gdGhlIFhlbiBQcm9qZWN0LiBUbyBo ZWxwIGVsaW1pbmF0ZSB3b3JrbG9hZCBsaW1pdGF0aW9ucyBmb3IgdXNlcnMsIHRoaXMgZW5hYmxl cyB0aGUgaHlwZXJ2aXNvciB0byBydW4gdGhvdXNhbmRzIG9mIGd1ZXN0cyBvbiBhIHNpbmdsZSBw aHlzaWNhbCBtYWNoaW5lLg0KDQpFeHBlcmltZW50YWwgU3VwcG9ydCBmb3IgUFZIIE1vZGUgZm9y IEd1ZXN0DQoNCk9yYWNsZSBoYXMgY29udHJpYnV0ZWQgYSBmdW5jdGlvbmFsIHByZXZpZXcgb2Yg YSBuZXcgdmlydHVhbGl6YXRpb24gbW9kZSBjYWxsZWQgUFZIIGN1cnJlbnRseSBhdmFpbGFibGUg dG8gdmlydHVhbGl6ZWQgZ3Vlc3RzLiA8aHR0cDovL2Jsb2cueGVuLm9yZy9pbmRleC5waHAvMjAx NC8wMS8zMS9saW51eC0zLTE0LWFuZC1wdmgvPiBQVkggaXMgYW4gZXh0ZW5zaW9uIHRvIHRoZSBj bGFzc2ljIFhlbiBQcm9qZWN0IFBhcmF2aXJ0dWFsaXphdGlvbiAoUFYpIHRoYXQgdXNlcyB0aGUg aGFyZHdhcmUgdmlydHVhbGl6YXRpb24gZXh0ZW5zaW9ucyBhdmFpbGFibGUgb24gbW9kZXJuIHg4 NiBwcm9jZXNzb3JzLiBQVkggdXNlcyBQViBkcml2ZXJzIGZvciBib290IGFuZCBJL08gYW5kIElu dGVsIGhhcmR3YXJlIHZpcnR1YWxpemF0aW9uIGV4dGVuc2lvbnMgZm9yIHBhZ2UgdGFibGUgb3Bl cmF0aW9ucywgc3lzdGVtIGNhbGxzIGFuZCBvdGhlciBwcml2aWxlZ2VkIG9wZXJhdGlvbnMuIFRo aXMgbm90IG9ubHkgaW1wcm92ZXMgcGVyZm9ybWFuY2UgYW5kIHNlY3VyaXR5LCBidXQgYWxzbyBz aW1wbGlmaWVzIHRoZSBhcmNoaXRlY3R1cmUgYW5kIFhlbiBQcm9qZWN0IEh5cGVydmlzb3ItTGlu dXggaW50ZXJmYWNlIHNpZ25pZmljYW50bHkuDQoNCuKAnFBWSCBpcyBhIG1ham9yIGRldmVsb3Bt ZW50IGZvciBYZW4gUHJvamVjdCBzb2Z0d2FyZSBvbiB4ODYgYW5kIGhhcyB0aGUgcG90ZW50aWFs IHRvIGdyZWF0bHkgc2ltcGxpZnkgdGhlIExpbnV4IGludGVyZmFjZSBpbiBkdWUgdGltZSwg4oCc IHNhaWQgS29ucmFkIFJ6ZXN6dXRlayBXaWxrLCBTb2Z0d2FyZSBEZXZlbG9wbWVudCBNYW5hZ2Vy IGF0IE9yYWNsZSwgYSBYZW4gUHJvamVjdCBhZHZpc29yeSBib2FyZCBtZW1iZXIuIOKAnFdlIGV4 cGVjdCBQVkggdG8gaGF2ZSB0aGUgYmVzdCBjaGFyYWN0ZXJpc3RpY3Mgb2YgYWxsIHZpcnR1YWxp emF0aW9uIG1vZGVzIC0tIGEgc2ltcGxlLCBmYXN0LCBzZWN1cmUgaW50ZXJmYWNlLCB3aXRoIGxv dyBtZW1vcnkgb3ZlcmhlYWQsIHRoYXQgYWxzbyB0YWtlcyBmdWxsIGFkdmFudGFnZSBvZiB0aGUg bGF0ZXN0IGhhcmR3YXJlLuKAnQ0KDQoNCg0KQWRkaXRpb25hbCBrZXkgdXBkYXRlcyBpbmNsdWRl Og0KDQrilqAgICAgIEJldHRlciBwZXJmb3JtYW5jZSB3aXRoIG1vZGVybiBzdG9yYWdlIGRldmlj ZXMgYW5kIGJpZyBkYXRhIC0tIEluZGlyZWN0IGRlc2NyaXB0b3JzIGZvciBibG9jayBQViBwcm90 b2NvbCAoTGludXgpIGFsbG93IGVhY2ggaW5kaXZpZHVhbCByZXF1ZXN0IHRvIHRyaXBsZSBpbiBz aXplLCBncmVhdGx5IGltcHJvdmluZyBJL08gcGVyZm9ybWFuY2Ugd2hlbiBydW5uaW5nIG9uIGZh c3Qgc3RvcmFnZSB0ZWNobm9sb2dpZXMgc3VjaCBhcyBzb2xpZC1zdGF0ZSBkcml2ZSBhbmQgUkFJ RC4gQXZhaWxhYmxlIGluIGFueSBndWVzdCBydW5uaW5nIExpbnV4IDMuMTEgb3IgaGlnaGVyIChy ZWdhcmRsZXNzIG9mIFhlbiBQcm9qZWN0IHZlcnNpb24pLg0KDQoNCg0K4pagICAgICBNb3JlIHBv d2VyZnVsIGRyaXZlciBkb21haW5zIC0tIERpc2sgZHJpdmVyIGRvbWFpbnMgY2FuIG5vdyB1bmlm b3JtbHkgcnVuIGJsb2NrIHNjcmlwdHMgYW5kIHVzZXItc3BhY2UgYmFja2VuZHMsIHN1Y2ggYXMg cWRpc2ssIGJyaW5naW5nIHRoZW0gdXAgdG8gZmVhdHVyZSBwYXJpdHkgd2l0aCBkb21haW4gMC4g VGhpcyBtZWFucyBob3N0IGFkbWluaXN0cmF0b3JzIGNhbiB0YWtlIGFkdmFudGFnZSBvZiB0aGUg ZW5oYW5jZWQgc2VjdXJpdHksIHNjYWxhYmlsaXR5LCBhbmQgcm9idXN0bmVzcyBwcm92aWRlZCBi eSBkcml2ZXIgZG9tYWlucyB3aXRob3V0IHNhY3JpZmljaW5nIHRoZSB3aWRlIGFycmF5IG9mIGRp c2sgY29uZmlndXJhdGlvbiBvcHRpb25zIHByb3ZpZGVkIGJ5IFhlbiBpbiBkb20wLg0KDQrilqAg ICAgIE5ldyBTUElDRSBwcm90b2NvbCBzdXBwb3J0IC0tIEZ1bmN0aW9uYWxpdHkgc3VjaCBhcyBj bGlwYm9hcmQgc2hhcmluZyBhbmQgVVNCIHJlZGlyZWN0aW9uIGNyZWF0ZXMgYSBtdWNoIHJpY2hl ciBjb25uZWN0aW9uIGZvciB2aXJ0dWFsIGRlc2t0b3BzIGFuZCBiZXR0ZXIgZ3JhcGhpY3MgcGVy Zm9ybWFuY2UuDQoNCuKWoCAgICAgRW5oYW5jZWQgZGlhZ25vc3RpY3MgYW5kIGtleGVjIGRlYnVn IHN1cHBvcnQgLS0gV2hlbiBhIGNyYXNoIGhhcHBlbnMsIGEgc3BlY2lhbCBrZXJuZWwgaXMgYWxs b3dlZCBpbW1lZGlhdGUgdG8gY29sbGVjdCBpbmZvcm1hdGlvbiBhYm91dCB0aGUgcm9vdCBjYXVz ZSwgb2ZmZXJpbmcgZGV2ZWxvcGVycyBiZXR0ZXIgZGlhZ25vc2lzIGFuZCByZXBhaXIgYWJpbGl0 aWVzLg0KDQpUaGUgNC40IHJlbGVhc2UgaXMgdGhlIHJlc3VsdCBvZiBhIGJyb2FkLCBjb2xsYWJv cmF0aXZlIGRldmVsb3BtZW50IGVmZm9ydCByZXByZXNlbnRpbmcgZW5naW5lZXJzIGZyb20gbW9y ZSB0aGFuIDEzIGxlYWRpbmcgaGFyZHdhcmUsIHNvZnR3YXJlIGFuZCBzZWN1cml0eSB2ZW5kb3Jz LiBUb3AgY29udHJpYnV0b3JzIGluY2x1ZGUgQW1hem9uLCBBTUQsIEFuYWxvZyBEZXZpY2VzLCBC cm9hZGNvbSwgQ2l0cml4LCBGdWppdHN1LCBJbnRlbCwgTGluYXJvLCBOU0EsIE9yYWNsZSwgU3Vz ZSwgVmVyaXpvbi9UZXJyZW1hcmssIHBsdXMgbnVtZXJvdXMgaW5kaXZpZHVhbCBhbmQgYWNhZGVt aWMgY29udHJpYnV0b3JzLiBUaGUgZnJlZWx5IGF2YWlsYWJsZSBkb3dubG9hZCBjYW4gYmUgZm91 bmQgb24gdGhlIFhlblByb2plY3Qub3JnPGh0dHA6Ly9YZW5Qcm9qZWN0Lm9yZz4gd2Vic2l0ZSAo aW5zZXJ0IHVybCkuDQoNCg0KDQpBYm91dCBYZW4gUHJvamVjdA0KDQpUaGUgWGVuIFByb2plY3Qg c29mdHdhcmUgaXMgYW4gb3BlbiBzb3VyY2UgdmlydHVhbGl6YXRpb24gcGxhdGZvcm0gbGljZW5z ZWQgdW5kZXIgdGhlIEdQTHYyIHdpdGggYSBzaW1pbGFyIGdvdmVybmFuY2Ugc3RydWN0dXJlIHRv IHRoZSBMaW51eCBrZXJuZWwuIERlc2lnbmVkIGZyb20gdGhlIHN0YXJ0IGZvciBjbG91ZCBjb21w dXRpbmcsIHRoZSBQcm9qZWN0IGhhcyBtb3JlIHRoYW4gYSBkZWNhZGUgb2YgZGV2ZWxvcG1lbnQg YW5kIGlzIGJlaW5nIHVzZWQgYnkgbW9yZSB0aGFuIDEwIG1pbGxpb24gdXNlcnMuIEEgQ29sbGFi b3JhdGl2ZSBQcm9qZWN0IGF0IFRoZSBMaW51eCBGb3VuZGF0aW9uLCB0aGUgWGVuIFByb2plY3Qg dGVhbSBpcyBmb2N1c2VkIG9uIGFkdmFuY2luZyB2aXJ0dWFsaXphdGlvbiBpbiBhIG51bWJlciBv ZiBkaWZmZXJlbnQgY29tbWVyY2lhbCBhbmQgb3BlbiBzb3VyY2UgYXBwbGljYXRpb25zIGluY2x1 ZGluZyBzZXJ2ZXIgdmlydHVhbGl6YXRpb24sIEluZnJhc3RydWN0dXJlIGFzIGEgU2VydmljZSAo SWFhUyksIGRlc2t0b3AgdmlydHVhbGl6YXRpb24sIHNlY3VyaXR5IGFwcGxpY2F0aW9ucywgZW1i ZWRkZWQgYW5kIGhhcmR3YXJlIGFwcGxpYW5jZXMuIEl0IGNvdW50cyBtYW55IGluZHVzdHJ5IGFu ZCBvcGVuIHNvdXJjZSBjb21tdW5pdHkgbGVhZGVycyBhbW9uZyBpdHMgbWVtYmVycyBpbmNsdWRp bmc6IEFtYXpvbiBXZWIgU2VydmljZXMsIEFNRCwgQVJNLCBCcm9taXVtLCBDYWx4ZWRhLCBDQSBU ZWNobm9sb2dpZXMsIENpc2NvLCBDaXRyaXgsIEdvb2dsZSwgSW50ZWwsIE9yYWNsZSwgU2Ftc3Vu ZyBhbmQgVmVyaXpvbi4gRm9yIG1vcmUgaW5mb3JtYXRpb24gYWJvdXQgdGhlIFhlbiBQcm9qZWN0 IGh5cGVydmlzb3IgYW5kIHRvIHBhcnRpY2lwYXRlLCBwbGVhc2UgdmlzaXQgaHR0cDovL3hlbnBy b2plY3QuPGh0dHA6Ly94ZW5wcm9qZWN0Lm9yZy8+b3JnPGh0dHA6Ly94ZW5wcm9qZWN0Lm9yZy8+ Lg0KDQojIyMNCg0KU2FyYWggQ29ud2F5DQoNClRoZSBYZW4gUHJvamVjdA0KDQpNZWRpYSBDb250 YWN0DQoNCnB1YmxpY2l0eUBsaXN0cy54ZW5wcm9qZWN0Lm9yZzxtYWlsdG86cHVibGljaXR5QGxp c3RzLnhlbnByb2plY3Qub3JnPg0KDQoNCk9uIE1hciA2LCAyMDE0LCBhdCAxMjo0NCBQTSwgV2ls c29uLCBNYXR0IDxtc3dAYW1hem9uLmNvbTxtYWlsdG86bXN3QGFtYXpvbi5jb20+PiB3cm90ZToN Cg0KTWFyaywgdGhvdWdodHM/DQoNCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fDQpG cm9tOiBXaWxzb24sIE1hdHQNClNlbnQ6IFdlZG5lc2RheSwgTWFyY2ggMDUsIDIwMTQgMTA6MDEg QU0NClRvOiBBZHZpc29yeS1ib2FyZCBkaXNjdXNzaW9ucw0KU3ViamVjdDogUkU6IFtBZHZpc29y eS1ib2FyZF0gWGVuIFByb2plY3QgNC40IFJlbGVhc2UNCg0KSSdkIHJhdGhlciB1c2UgIlhlbiBQ cm9qZWN0IEh5cGVydmlzb3IiIHRoYW4gaW50cm9kdWNlIGFuIGFjcm9ueW0uIEkgdGhpbmsgaXQn cyBpbXBvcnRhbnQgdGhhdCAiWGVuIFByb2plY3QiIG5vdCBiZSBzcGxpdCBmcm9tICJIeXBlcnZp c29yLiINCg0KVGhpcyBzdGlsbCBkb2Vzbid0IGFkZHJlc3MgaG93IHRoZSB1bWJyZWxsYSBwcm9q ZWN0IGlzIGNhbGxlZC4gVGhpcyBuZXcgcmVsZWFzZSBkb2Vzbid0IG9ubHkgaW5jbHVkZSB0aGUg aHlwZXJ2aXNvciwgYnV0IGFsc28gdGhlIGFzc29jaWF0ZWQgdG9vbHN0YWNrIGFuZCB1dGlsaXRp ZXMuIE1heWJlIHdlJ3JlIE9LIGNhbGxpbmcgYWxsIG9mIHRoYXQgdGhlICJIeXBlcnZpc29yLCIg ZXZlbiBpZiB3ZSBpZGVudGlmeSB0aGUgZGV2ZWxvcG1lbnQgdGVhbXMgZGlmZmVyZW50bHkuDQoN CkhvdyBzaG91bGQgd2UgcmUtYWxpZ24gYWxsIG9mIHRoZSBicmFuZGluZz8gRm9yIGV4YW1wbGU6 IGh0dHA6Ly94ZW5wcm9qZWN0Lm9yZy9kZXZlbG9wZXJzL3RlYW1zL2h5cGVydmlzb3IuaHRtbA0K DQpTaG91bGQgdGhlIGxpbmtzIHVuZGVyICJIeXBlcnZpc29yIERvd25sb2FkcyIgYmUgInZlcnNp b24gNC4zLjEiIGluc3RlYWQgb2YgIlhlbiA0LjMuMSIgdG8gcmVzb2x2ZSB0aGUgdHJhZGVtYXJr IGNvbmNlcm5zPw0KDQotLW1zdw0KDQpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXw0K RnJvbTogYWR2aXNvcnktYm9hcmQtYm91bmNlc0BsaXN0cy54ZW5wcm9qZWN0Lm9yZzxtYWlsdG86 YWR2aXNvcnktYm9hcmQtYm91bmNlc0BsaXN0cy54ZW5wcm9qZWN0Lm9yZz4gW2Fkdmlzb3J5LWJv YXJkLWJvdW5jZXNAbGlzdHMueGVucHJvamVjdC5vcmc8bWFpbHRvOmFkdmlzb3J5LWJvYXJkLWJv dW5jZXNAbGlzdHMueGVucHJvamVjdC5vcmc+XSBvbiBiZWhhbGYgb2YgU2FyYWggQ29ud2F5IFtz Y29ud2F5QGxpbnV4Zm91bmRhdGlvbi5vcmc8bWFpbHRvOnNjb253YXlAbGludXhmb3VuZGF0aW9u Lm9yZz5dDQpTZW50OiBXZWRuZXNkYXksIE1hcmNoIDA1LCAyMDE0IDk6MzMgQU0NClRvOiBBZHZp c29yeS1ib2FyZCBkaXNjdXNzaW9ucw0KU3ViamVjdDogUmU6IFtBZHZpc29yeS1ib2FyZF0gWGVu IFByb2plY3QgNC40IFJlbGVhc2UNCg0KTWFyayBldCBhbGwsDQoNCkkgYWdyZWUgdGhhdCB1c2lu ZyBYZW4gUHJvamVjdCBpcyBhIG1vdXRoZnVsLiBHaXZlbiB0aGF0IHRoZXJlIGlzIGNsb3NlIG92 ZXJsYXAgYW5kIG9jY2FzaW9uYWwgYnJhbmRpbmcgY29uZnVzaW9uIHdpdGggQ2l0cml4IHByb2R1 Y3RzLCBpZiB3ZSBhZGQgYW5vdGhlciBuZXcgdGVybSBvciBhY3JvbnltIGludG8gdGhlIG1peCwg d2UnbGwgd2FudCB0byBiZSBkaWxpZ2VudCBhYm91dCBiZWluZyBjb25zaXN0ZW50IGluIGJsb2dz LCBwcmVzZW50YXRpb25zLCBuZXdzIHJlbGVhc2VzLCB3ZWIgc2l0ZSBjb3B5LCBjdXN0b21lciB0 ZXN0aW1vbmlhbHMgZXRjLg0KDQpGb3IgdGhlIHNha2Ugb2Ygc2ltcGxpY2l0eSwgaG93IGFib3V0 IHVzaW5nIFhQSCAtIGFsbCB1cHBlcmNhc2UgLSBvbiBzZWNvbmQgcmVmZXJlbmNlPyBUaG91Z2h0 cz8NCg0KVGhhbmtzLA0KDQoNCg0KDQoNCg0KT24gV2VkLCBNYXIgNSwgMjAxNCBhdCA5OjE4IEFN LCBNYXJrIEhpbmtsZSA8TWFyay5IaW5rbGVAY2l0cml4LmNvbTxtYWlsdG86TWFyay5IaW5rbGVA Y2l0cml4LmNvbT4+IHdyb3RlOg0KSG93IGFib3V0IHRoaXMgY29udmVudGlvbiBvbmx5IHNheSBY ZW4gUHJvamVjdCBhbmQgWGVuIFByb2plY3QgaHlwZXJ2aXNvciBvbmNlIHRoZW4uIFVzZSB0aGUg YWJicmV2aWF0aW9uIFhQaCB0aHJvdWdob3V0IHRoZSByZWxlYXNlLiBKdXN0IHNuaXBwaW5nIE1h dHTigJlzIGV4YW1wbGUgdG8gbWFrZSB0aGUgcG9pbnQuIEkgd291bGQgZ3Vlc3MgdGhhdCB0aGUg YXBwcm9wcmlhdGUgY2FwaXRhbGl6YXRpb24gd291bGQgYmUgbG93ZXIgY2FzZSBmb3IgdGhlIHdv cmQgaHlwZXJ2aXNvci4NCg0KTWFyaw0KDQoNClRoZSBYZW4gUHJvamVjdCwgYSBDb2xsYWJvcmF0 aXZlIFByb2plY3QgaG9zdGVkIGF0IFRoZSBMaW51eCBGb3VuZGF0aW9uLCB0b2RheSBhbm5vdW5j ZWQgYXZhaWxhYmlsaXR5IG9mIHRoZSBYZW4gUHJvamVjdCBoeXBlcnZpc29yKFhQaCkgNC40IHdp dGggZW5oYW5jZWQgQVJNIHN1cHBvcnQuDQoNClhQaCA0LjQgZnVydGhlciBhZHZhbmNlcyB0aGUg UHJvamVjdOKAmXMgcG9zaXRpb24gYXMgYSBmYXN0LCBzY2FsYWJsZSwgc2VjdXJlIHZpcnR1YWxp emF0aW9uIGVuZ2luZSBmb3IgdGhlIGluZHVzdHJ54oCZcyBicm9hZGVzdCByYW5nZSBvZiBzZXJ2 ZXIsIFBDIGNoaXBzZXRzIGFuZCBuZXh0LWdlbmVyYXRpb24gbG93LXBvd2VyIHN5c3RlbXMgb24g Y2hpcHMgKFNvQykuDQoNCk9uIE1hciA0LCAyMDE0LCBhdCA0OjAxIFBNLCBXaWxzb24sIE1hdHQg PG1zd0BhbWF6b24uY29tPG1haWx0bzptc3dAYW1hem9uLmNvbT4+IHdyb3RlOg0KDQpUaGUgIlhl biBQcm9qZWN0IiB0ZXJtaW5vbG9neSBtYWtlcyB0aGUgbWVzc2FnZSBleHRyZW1lbHkgY3VtYmVy c29tZS4NCg0KDQpUaGUgWGVuIFByb2plY3QsIGEgQ29sbGFib3JhdGl2ZSBQcm9qZWN0IGhvc3Rl ZCBhdCBUaGUgTGludXggRm91bmRhdGlvbiwgdG9kYXkgYW5ub3VuY2VkIGF2YWlsYWJpbGl0eSBv ZiB0aGUgWGVuIFByb2plY3QgNC40IEh5cGVydmlzb3Igd2l0aCBlbmhhbmNlZCBYZW4gUHJvamVj dC1vbi1BUk0gc3VwcG9ydC4NCg0KV2h5IG5vdCBqdXN0IHNheSAiZW5oYW5jZWQgQVJNIHN1cHBv cnQiPyBXZSBzaG91bGQgYWRvcHQgc29tZSB1c2FnZSBndWlkZWxpbmVzIGZvciBzdWItcHJvamVj dCBicmFuZGluZy4gV2Ugc2hvdWxkbid0IGluc2VydCB3b3Jkcy9udW1iZXJzIGJldHdlZW4gIlhl biBQcm9qZWN0IiBhbmQgYSBzdWItcHJvamVjdCBuYW1lLg0KDQpUaGUgWGVuIFByb2plY3QsIGEg Q29sbGFib3JhdGl2ZSBQcm9qZWN0IGhvc3RlZCBhdCBUaGUgTGludXggRm91bmRhdGlvbiwgdG9k YXkgYW5ub3VuY2VkIHZlcnNpb24gNC40IG9mIHRoZSBYZW4gUHJvamVjdCBIeXBlcnZpc29yIHdp dGggZW5oYW5jZWQgQVJNIHN1cHBvcnQuDQoNCm9yDQpUaGUgWGVuIFByb2plY3QsIGEgQ29sbGFi b3JhdGl2ZSBQcm9qZWN0IGhvc3RlZCBhdCBUaGUgTGludXggRm91bmRhdGlvbiwgdG9kYXkgYW5u b3VuY2VkIHRoZSByZWxlYXNlIG9mIFhlbiBQcm9qZWN0IEh5cGVydmlzb3IgNC40IHdpdGggZW5o YW5jZWQgQVJNIHN1cHBvcnQuDQoNCkxhdGVyIG9uLCB0aGlzIHJlbGVhc2UgaXMgY2FsbGVkICJY ZW4gUHJvamVjdCA0LjQiDQoNCg0KVGhlIFhlbiBQcm9qZWN0IDQuNCByZWxlYXNlIGZ1cnRoZXIg YWR2YW5jZXMgdGhlIFByb2plY3TigJlzIHBvc2l0aW9uIGFzIGEgZmFzdCwgc2NhbGFibGUsIHNl Y3VyZSB2aXJ0dWFsaXphdGlvbiBlbmdpbmUgZm9yIHRoZSBpbmR1c3RyeeKAmXMgYnJvYWRlc3Qg cmFuZ2Ugb2Ygc2VydmVyLCBQQyBjaGlwc2V0cyBhbmQgbmV4dC1nZW5lcmF0aW9uIGxvdy1wb3dl ciBzeXN0ZW1zIG9uIGNoaXBzIChTb0MpLg0KDQpUaGF0IGRvZXNuJ3QgZmxvdyB3ZWxsLiBIb3cg YXJlIHdlIHJlbGVhc2luZyB2ZXJzaW9uIDQuNCBvZiBhIHByb2plY3Q/IERvIHdlIHdhbnQgdG8g Y2FsbCB0aGUgb3ZlcmFsbCByZWxlYXNlICJYZW4gUHJvamVjdCBBcmNoaXRlY3R1cmUgNC40Ij8g T3IgZG8gd2UgbmVlZCB0byBjb21lIHVwIHdpdGggc29tZSBvdGhlciBwcm9qZWN0IGJyYW5kaW5n Pw0KDQotLW1zdw0KDQpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXw0KRnJvbTogYWR2 aXNvcnktYm9hcmQtYm91bmNlc0BsaXN0cy54ZW5wcm9qZWN0Lm9yZzxtYWlsdG86YWR2aXNvcnkt Ym9hcmQtYm91bmNlc0BsaXN0cy54ZW5wcm9qZWN0Lm9yZz4gW2Fkdmlzb3J5LWJvYXJkLWJvdW5j ZXNAbGlzdHMueGVucHJvamVjdC5vcmc8bWFpbHRvOmFkdmlzb3J5LWJvYXJkLWJvdW5jZXNAbGlz dHMueGVucHJvamVjdC5vcmc+XSBvbiBiZWhhbGYgb2YgU2FyYWggQ29ud2F5IFtzY29ud2F5QGxp bnV4Zm91bmRhdGlvbi5vcmc8bWFpbHRvOnNjb253YXlAbGludXhmb3VuZGF0aW9uLm9yZz5dDQpT ZW50OiBUdWVzZGF5LCBNYXJjaCAwNCwgMjAxNCAxMjoxNiBQTQ0KDQpUbzogYWR2aXNvcnktYm9h cmRAbGlzdHMueGVucHJvamVjdC5vcmc8bWFpbHRvOmFkdmlzb3J5LWJvYXJkQGxpc3RzLnhlbnBy b2plY3Qub3JnPg0KU3ViamVjdDogW0Fkdmlzb3J5LWJvYXJkXSBYZW4gUHJvamVjdCA0LjQgUmVs ZWFzZQ0KDQpIaSBldmVyeW9uZS4NCg0KQXR0YWNoZWQgaXMgdGhlIFhlbiBQcm9qZWN0IDQuNCBu ZXdzIHJlbGVhc2UgYW5ub3VjZW1lbnQgdGhhdCB3aWxsIGdvIG91dCBhdCA4IGEubS4gRVQgb24g TW9uZGF5LCBNYXJjaCAxMC4NCg0KSWYgeW91IGhhdmUgYW55IGFkZGl0aW9uYWwgY29tbWVudHMg b3IgZWRpdHMsIHBsZWFzZSBnZXQgYmFjayB0byBtZSBieSBUaHVyc2RheSBtb3JuaW5nIGF0IHRo ZSBsYXRlc3QuDQoNClRoYW5rcywNCg0KDQotLQ0KU2FyYWggQ29ud2F5DQpQUiBNYW5hZ2VyDQpU aGUgTGludXggRm91bmRhdGlvbg0Kc2NvbndheUBsaW51eGZvdW5kYXRpb24ub3JnPG1haWx0bzpz Y29ud2F5QGxpbnV4Zm91bmRhdGlvbi5vcmc+DQooOTc4KSA1NzgtNTMwMDx0ZWw6JTI4OTc4JTI5 JTIwNTc4LTUzMDA+ICBDZWxsDQpTa3lwZTogIHNhcmFoLmsuY29ud2F5DQpfX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXw0KQWR2aXNvcnktYm9hcmQgbWFpbGlu ZyBsaXN0DQpBZHZpc29yeS1ib2FyZEBsaXN0cy54ZW5wcm9qZWN0Lm9yZzxtYWlsdG86QWR2aXNv cnktYm9hcmRAbGlzdHMueGVucHJvamVjdC5vcmc+DQpodHRwOi8vbGlzdHMueGVucHJvamVjdC5v cmcvY2dpLWJpbi9tYWlsbWFuL2xpc3RpbmZvL2Fkdmlzb3J5LWJvYXJkDQoNCg0KX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18NCkFkdmlzb3J5LWJvYXJkIG1h aWxpbmcgbGlzdA0KQWR2aXNvcnktYm9hcmRAbGlzdHMueGVucHJvamVjdC5vcmc8bWFpbHRvOkFk dmlzb3J5LWJvYXJkQGxpc3RzLnhlbnByb2plY3Qub3JnPg0KaHR0cDovL2xpc3RzLnhlbnByb2pl Y3Qub3JnL2NnaS1iaW4vbWFpbG1hbi9saXN0aW5mby9hZHZpc29yeS1ib2FyZA0KDQoNCg0KDQot LQ0KU2FyYWggQ29ud2F5DQpQUiBNYW5hZ2VyDQpUaGUgTGludXggRm91bmRhdGlvbg0Kc2Nvbndh eUBsaW51eGZvdW5kYXRpb24ub3JnPG1haWx0bzpzY29ud2F5QGxpbnV4Zm91bmRhdGlvbi5vcmc+ DQooOTc4KSA1NzgtNTMwMCAgQ2VsbA0KU2t5cGU6ICBzYXJhaC5rLmNvbndheQ0KX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18NCkFkdmlzb3J5LWJvYXJkIG1h aWxpbmcgbGlzdA0KQWR2aXNvcnktYm9hcmRAbGlzdHMueGVucHJvamVjdC5vcmc8bWFpbHRvOkFk dmlzb3J5LWJvYXJkQGxpc3RzLnhlbnByb2plY3Qub3JnPg0KaHR0cDovL2xpc3RzLnhlbnByb2pl Y3Qub3JnL2NnaS1iaW4vbWFpbG1hbi9saXN0aW5mby9hZHZpc29yeS1ib2FyZA0KDQo= --_000_2BCAC582CB614E1696C46C1AEFAF81FBcitrixcom_ Content-Type: text/html; charset="utf-8" Content-ID: Content-Transfer-Encoding: base64 PGh0bWw+DQo8aGVhZD4NCjxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0i dGV4dC9odG1sOyBjaGFyc2V0PXV0Zi04Ij4NCjwvaGVhZD4NCjxib2R5IHN0eWxlPSJ3b3JkLXdy YXA6IGJyZWFrLXdvcmQ7IC13ZWJraXQtbmJzcC1tb2RlOiBzcGFjZTsgLXdlYmtpdC1saW5lLWJy ZWFrOiBhZnRlci13aGl0ZS1zcGFjZTsiPg0KTXkgYXBvbG9naWVzIGZvciB0aGUgc2xvdyByZXBs eSBJIHdhcyBzdHVjayBvbiB0aGUgcm9hZCBhbmQgY291bGRu4oCZdCByZWFkIHRoZSByZWxlYXNl IG9uIG15IHBob25lIHRvIGZvcm11bGF0ZSBhIHByb3BlciByZXNwb25zZS4gSSBzaG91bGQgbW92 ZSB0byBhIGhpZ2hseSBlbGFzdGljIFhlbiBQcm9qZWN0LXBvd2VyZWQgY2xvdWQgdGhhdCBhbGxv d3MgbWUgdG8gYXV0b3NjYWxlIDspIChzb3JyeSBiYWQgY2xvdWQgam9rZSkuJm5ic3A7DQo8ZGl2 Pjxicj4NCjwvZGl2Pg0KPGRpdj5JIGFtIGZpbmUgd2l0aG91dCBkb2luZyB0aGUgYWNyb255bSBh bmQgSSB0aGluayB0aGUgcmVhbGlnbmluZyBhbmQgYnJhbmRpbmcgZGlzY3Vzc2lvbiBzaG91bGQg YmUgaGFkLiBJ4oCZZCBsaWtlIHRvIGhhdmUgdGhhdCBkaXNjdXNzaW9uIGR1cmluZyBvdXIgbmV4 dCBib2FyZCBtZWV0aW5nLiBHaXZlbiB0aW1lIGlzIG9mIHRoZSBlc3NlbmNlIEkgdGhpbmsgd2Ug c2hvdWxkIGp1c3QgdXBkYXRlIHRoZSBsaW5rcyB0byB2ZXJzaW9uIHZlcnN1cw0KIFhlbiA0LjMu MS4mbmJzcDs8L2Rpdj4NCjxkaXY+PGJyPg0KPC9kaXY+DQo8ZGl2PkFsc28gSSB0b29rIGEgc2hv dCBhdCB0aGUgd29yZGluZyBvZiB0aGUgcHJlc3MgcmVsZWFzZS4gSXTigJlzIHByb2JhYmx5IG5v dCBwZXJmZWN0IGJ1dCBtYWtlcyBpdCByZWFkIGEgYml0IGJldHRlci4gQXR0YWNoZWQgYXJlIG15 IHByb3Bvc2VkIGVkaXRzLiBTYXJhaCwgSSBzZW50IHlvdSB0aGUgd29yZCBkb2Mgd2l0aCB0cmFj ayBjaGFuZ2VzIGFzc3VtaW5nIHdlIGhhdmUgc29tZSBlZGl0cyB0byBhZ3JlZSBvbi4mbmJzcDs8 L2Rpdj4NCjxkaXY+PGJyPg0KPC9kaXY+DQo8ZGl2Pjxicj4NCjwvZGl2Pg0KPGRpdj5SZWdhcmRz LCBNYXJrJm5ic3A7PC9kaXY+DQo8ZGl2Pjxicj4NCjwvZGl2Pg0KPGRpdj48IS0tW2lmIGd0ZSBt c28gOV0+PHhtbD4NCiA8dzpXb3JkRG9jdW1lbnQ+DQogIDx3OlZpZXc+Tm9ybWFsPC93OlZpZXc+ DQogIDx3Olpvb20+MDwvdzpab29tPg0KICA8dzpUcmFja01vdmVzLz4NCiAgPHc6VHJhY2tGb3Jt YXR0aW5nLz4NCiAgPHc6UHVuY3R1YXRpb25LZXJuaW5nLz4NCiAgPHc6VmFsaWRhdGVBZ2FpbnN0 U2NoZW1hcy8+DQogIDx3OlNhdmVJZlhNTEludmFsaWQ+ZmFsc2U8L3c6U2F2ZUlmWE1MSW52YWxp ZD4NCiAgPHc6SWdub3JlTWl4ZWRDb250ZW50PmZhbHNlPC93Oklnbm9yZU1peGVkQ29udGVudD4N CiAgPHc6QWx3YXlzU2hvd1BsYWNlaG9sZGVyVGV4dD5mYWxzZTwvdzpBbHdheXNTaG93UGxhY2Vo b2xkZXJUZXh0Pg0KICA8dzpEb05vdFByb21vdGVRRi8+DQogIDx3OkxpZFRoZW1lT3RoZXI+RU4t VVM8L3c6TGlkVGhlbWVPdGhlcj4NCiAgPHc6TGlkVGhlbWVBc2lhbj5KQTwvdzpMaWRUaGVtZUFz aWFuPg0KICA8dzpMaWRUaGVtZUNvbXBsZXhTY3JpcHQ+WC1OT05FPC93OkxpZFRoZW1lQ29tcGxl eFNjcmlwdD4NCiAgPHc6Q29tcGF0aWJpbGl0eT4NCiAgIDx3OkJyZWFrV3JhcHBlZFRhYmxlcy8+ DQogICA8dzpTbmFwVG9HcmlkSW5DZWxsLz4NCiAgIDx3OldyYXBUZXh0V2l0aFB1bmN0Lz4NCiAg IDx3OlVzZUFzaWFuQnJlYWtSdWxlcy8+DQogICA8dzpEb250R3Jvd0F1dG9maXQvPg0KICAgPHc6 U3BsaXRQZ0JyZWFrQW5kUGFyYU1hcmsvPg0KICAgPHc6RW5hYmxlT3BlblR5cGVLZXJuaW5nLz4N CiAgIDx3OkRvbnRGbGlwTWlycm9ySW5kZW50cy8+DQogICA8dzpPdmVycmlkZVRhYmxlU3R5bGVI cHMvPg0KICA8L3c6Q29tcGF0aWJpbGl0eT4NCiAgPG06bWF0aFByPg0KICAgPG06bWF0aEZvbnQg bTp2YWw9IkNhbWJyaWEgTWF0aCIvPg0KICAgPG06YnJrQmluIG06dmFsPSJiZWZvcmUiLz4NCiAg IDxtOmJya0JpblN1YiBtOnZhbD0iJiM0NTstIi8+DQogICA8bTpzbWFsbEZyYWMgbTp2YWw9Im9m ZiIvPg0KICAgPG06ZGlzcERlZi8+DQogICA8bTpsTWFyZ2luIG06dmFsPSIwIi8+DQogICA8bTpy TWFyZ2luIG06dmFsPSIwIi8+DQogICA8bTpkZWZKYyBtOnZhbD0iY2VudGVyR3JvdXAiLz4NCiAg IDxtOndyYXBJbmRlbnQgbTp2YWw9IjE0NDAiLz4NCiAgIDxtOmludExpbSBtOnZhbD0ic3ViU3Vw Ii8+DQogICA8bTpuYXJ5TGltIG06dmFsPSJ1bmRPdnIiLz4NCiAgPC9tOm1hdGhQcj48L3c6V29y ZERvY3VtZW50Pg0KPC94bWw+PCFbZW5kaWZdLS0+PCEtLVtpZiBndGUgbXNvIDldPjx4bWw+DQog PHc6TGF0ZW50U3R5bGVzIERlZkxvY2tlZFN0YXRlPSJmYWxzZSIgRGVmVW5oaWRlV2hlblVzZWQ9 InRydWUiDQogIERlZlNlbWlIaWRkZW49InRydWUiIERlZlFGb3JtYXQ9ImZhbHNlIiBEZWZQcmlv cml0eT0iOTkiDQogIExhdGVudFN0eWxlQ291bnQ9IjI3NiI+DQogIDx3OkxzZEV4Y2VwdGlvbiBM b2NrZWQ9ImZhbHNlIiBQcmlvcml0eT0iMCIgU2VtaUhpZGRlbj0iZmFsc2UiDQogICBVbmhpZGVX aGVuVXNlZD0iZmFsc2UiIFFGb3JtYXQ9InRydWUiIE5hbWU9Ik5vcm1hbCIvPg0KICA8dzpMc2RF eGNlcHRpb24gTG9ja2VkPSJmYWxzZSIgUHJpb3JpdHk9IjkiIFNlbWlIaWRkZW49ImZhbHNlIg0K ICAgVW5oaWRlV2hlblVzZWQ9ImZhbHNlIiBRRm9ybWF0PSJ0cnVlIiBOYW1lPSJoZWFkaW5nIDEi Lz4NCiAgPHc6THNkRXhjZXB0aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSI5IiBRRm9ybWF0 PSJ0cnVlIiBOYW1lPSJoZWFkaW5nIDIiLz4NCiAgPHc6THNkRXhjZXB0aW9uIExvY2tlZD0iZmFs c2UiIFByaW9yaXR5PSI5IiBRRm9ybWF0PSJ0cnVlIiBOYW1lPSJoZWFkaW5nIDMiLz4NCiAgPHc6 THNkRXhjZXB0aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSI5IiBRRm9ybWF0PSJ0cnVlIiBO YW1lPSJoZWFkaW5nIDQiLz4NCiAgPHc6THNkRXhjZXB0aW9uIExvY2tlZD0iZmFsc2UiIFByaW9y aXR5PSI5IiBRRm9ybWF0PSJ0cnVlIiBOYW1lPSJoZWFkaW5nIDUiLz4NCiAgPHc6THNkRXhjZXB0 aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSI5IiBRRm9ybWF0PSJ0cnVlIiBOYW1lPSJoZWFk aW5nIDYiLz4NCiAgPHc6THNkRXhjZXB0aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSI5IiBR Rm9ybWF0PSJ0cnVlIiBOYW1lPSJoZWFkaW5nIDciLz4NCiAgPHc6THNkRXhjZXB0aW9uIExvY2tl ZD0iZmFsc2UiIFByaW9yaXR5PSI5IiBRRm9ybWF0PSJ0cnVlIiBOYW1lPSJoZWFkaW5nIDgiLz4N CiAgPHc6THNkRXhjZXB0aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSI5IiBRRm9ybWF0PSJ0 cnVlIiBOYW1lPSJoZWFkaW5nIDkiLz4NCiAgPHc6THNkRXhjZXB0aW9uIExvY2tlZD0iZmFsc2Ui IFByaW9yaXR5PSIzOSIgTmFtZT0idG9jIDEiLz4NCiAgPHc6THNkRXhjZXB0aW9uIExvY2tlZD0i ZmFsc2UiIFByaW9yaXR5PSIzOSIgTmFtZT0idG9jIDIiLz4NCiAgPHc6THNkRXhjZXB0aW9uIExv Y2tlZD0iZmFsc2UiIFByaW9yaXR5PSIzOSIgTmFtZT0idG9jIDMiLz4NCiAgPHc6THNkRXhjZXB0 aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSIzOSIgTmFtZT0idG9jIDQiLz4NCiAgPHc6THNk RXhjZXB0aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSIzOSIgTmFtZT0idG9jIDUiLz4NCiAg PHc6THNkRXhjZXB0aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSIzOSIgTmFtZT0idG9jIDYi Lz4NCiAgPHc6THNkRXhjZXB0aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSIzOSIgTmFtZT0i dG9jIDciLz4NCiAgPHc6THNkRXhjZXB0aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSIzOSIg TmFtZT0idG9jIDgiLz4NCiAgPHc6THNkRXhjZXB0aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5 PSIzOSIgTmFtZT0idG9jIDkiLz4NCiAgPHc6THNkRXhjZXB0aW9uIExvY2tlZD0iZmFsc2UiIFBy aW9yaXR5PSIzNSIgUUZvcm1hdD0idHJ1ZSIgTmFtZT0iY2FwdGlvbiIvPg0KICA8dzpMc2RFeGNl cHRpb24gTG9ja2VkPSJmYWxzZSIgUHJpb3JpdHk9IjEwIiBTZW1pSGlkZGVuPSJmYWxzZSINCiAg IFVuaGlkZVdoZW5Vc2VkPSJmYWxzZSIgUUZvcm1hdD0idHJ1ZSIgTmFtZT0iVGl0bGUiLz4NCiAg PHc6THNkRXhjZXB0aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSIxIiBOYW1lPSJEZWZhdWx0 IFBhcmFncmFwaCBGb250Ii8+DQogIDx3OkxzZEV4Y2VwdGlvbiBMb2NrZWQ9ImZhbHNlIiBQcmlv cml0eT0iMTEiIFNlbWlIaWRkZW49ImZhbHNlIg0KICAgVW5oaWRlV2hlblVzZWQ9ImZhbHNlIiBR Rm9ybWF0PSJ0cnVlIiBOYW1lPSJTdWJ0aXRsZSIvPg0KICA8dzpMc2RFeGNlcHRpb24gTG9ja2Vk PSJmYWxzZSIgUHJpb3JpdHk9IjIyIiBTZW1pSGlkZGVuPSJmYWxzZSINCiAgIFVuaGlkZVdoZW5V c2VkPSJmYWxzZSIgUUZvcm1hdD0idHJ1ZSIgTmFtZT0iU3Ryb25nIi8+DQogIDx3OkxzZEV4Y2Vw dGlvbiBMb2NrZWQ9ImZhbHNlIiBQcmlvcml0eT0iMjAiIFNlbWlIaWRkZW49ImZhbHNlIg0KICAg VW5oaWRlV2hlblVzZWQ9ImZhbHNlIiBRRm9ybWF0PSJ0cnVlIiBOYW1lPSJFbXBoYXNpcyIvPg0K ICA8dzpMc2RFeGNlcHRpb24gTG9ja2VkPSJmYWxzZSIgUHJpb3JpdHk9IjU5IiBTZW1pSGlkZGVu PSJmYWxzZSINCiAgIFVuaGlkZVdoZW5Vc2VkPSJmYWxzZSIgTmFtZT0iVGFibGUgR3JpZCIvPg0K ICA8dzpMc2RFeGNlcHRpb24gTG9ja2VkPSJmYWxzZSIgVW5oaWRlV2hlblVzZWQ9ImZhbHNlIiBO YW1lPSJQbGFjZWhvbGRlciBUZXh0Ii8+DQogIDx3OkxzZEV4Y2VwdGlvbiBMb2NrZWQ9ImZhbHNl IiBQcmlvcml0eT0iMSIgU2VtaUhpZGRlbj0iZmFsc2UiDQogICBVbmhpZGVXaGVuVXNlZD0iZmFs c2UiIFFGb3JtYXQ9InRydWUiIE5hbWU9Ik5vIFNwYWNpbmciLz4NCiAgPHc6THNkRXhjZXB0aW9u IExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSI2MCIgU2VtaUhpZGRlbj0iZmFsc2UiDQogICBVbmhp ZGVXaGVuVXNlZD0iZmFsc2UiIE5hbWU9IkxpZ2h0IFNoYWRpbmciLz4NCiAgPHc6THNkRXhjZXB0 aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSI2MSIgU2VtaUhpZGRlbj0iZmFsc2UiDQogICBV bmhpZGVXaGVuVXNlZD0iZmFsc2UiIE5hbWU9IkxpZ2h0IExpc3QiLz4NCiAgPHc6THNkRXhjZXB0 aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSI2MiIgU2VtaUhpZGRlbj0iZmFsc2UiDQogICBV bmhpZGVXaGVuVXNlZD0iZmFsc2UiIE5hbWU9IkxpZ2h0IEdyaWQiLz4NCiAgPHc6THNkRXhjZXB0 aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSI2MyIgU2VtaUhpZGRlbj0iZmFsc2UiDQogICBV bmhpZGVXaGVuVXNlZD0iZmFsc2UiIE5hbWU9Ik1lZGl1bSBTaGFkaW5nIDEiLz4NCiAgPHc6THNk RXhjZXB0aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSI2NCIgU2VtaUhpZGRlbj0iZmFsc2Ui DQogICBVbmhpZGVXaGVuVXNlZD0iZmFsc2UiIE5hbWU9Ik1lZGl1bSBTaGFkaW5nIDIiLz4NCiAg PHc6THNkRXhjZXB0aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSI2NSIgU2VtaUhpZGRlbj0i ZmFsc2UiDQogICBVbmhpZGVXaGVuVXNlZD0iZmFsc2UiIE5hbWU9Ik1lZGl1bSBMaXN0IDEiLz4N CiAgPHc6THNkRXhjZXB0aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSI2NiIgU2VtaUhpZGRl bj0iZmFsc2UiDQogICBVbmhpZGVXaGVuVXNlZD0iZmFsc2UiIE5hbWU9Ik1lZGl1bSBMaXN0IDIi Lz4NCiAgPHc6THNkRXhjZXB0aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSI2NyIgU2VtaUhp ZGRlbj0iZmFsc2UiDQogICBVbmhpZGVXaGVuVXNlZD0iZmFsc2UiIE5hbWU9Ik1lZGl1bSBHcmlk IDEiLz4NCiAgPHc6THNkRXhjZXB0aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSI2OCIgU2Vt aUhpZGRlbj0iZmFsc2UiDQogICBVbmhpZGVXaGVuVXNlZD0iZmFsc2UiIE5hbWU9Ik1lZGl1bSBH cmlkIDIiLz4NCiAgPHc6THNkRXhjZXB0aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSI2OSIg U2VtaUhpZGRlbj0iZmFsc2UiDQogICBVbmhpZGVXaGVuVXNlZD0iZmFsc2UiIE5hbWU9Ik1lZGl1 bSBHcmlkIDMiLz4NCiAgPHc6THNkRXhjZXB0aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSI3 MCIgU2VtaUhpZGRlbj0iZmFsc2UiDQogICBVbmhpZGVXaGVuVXNlZD0iZmFsc2UiIE5hbWU9IkRh cmsgTGlzdCIvPg0KICA8dzpMc2RFeGNlcHRpb24gTG9ja2VkPSJmYWxzZSIgUHJpb3JpdHk9Ijcx IiBTZW1pSGlkZGVuPSJmYWxzZSINCiAgIFVuaGlkZVdoZW5Vc2VkPSJmYWxzZSIgTmFtZT0iQ29s b3JmdWwgU2hhZGluZyIvPg0KICA8dzpMc2RFeGNlcHRpb24gTG9ja2VkPSJmYWxzZSIgUHJpb3Jp dHk9IjcyIiBTZW1pSGlkZGVuPSJmYWxzZSINCiAgIFVuaGlkZVdoZW5Vc2VkPSJmYWxzZSIgTmFt ZT0iQ29sb3JmdWwgTGlzdCIvPg0KICA8dzpMc2RFeGNlcHRpb24gTG9ja2VkPSJmYWxzZSIgUHJp b3JpdHk9IjczIiBTZW1pSGlkZGVuPSJmYWxzZSINCiAgIFVuaGlkZVdoZW5Vc2VkPSJmYWxzZSIg TmFtZT0iQ29sb3JmdWwgR3JpZCIvPg0KICA8dzpMc2RFeGNlcHRpb24gTG9ja2VkPSJmYWxzZSIg UHJpb3JpdHk9IjYwIiBTZW1pSGlkZGVuPSJmYWxzZSINCiAgIFVuaGlkZVdoZW5Vc2VkPSJmYWxz ZSIgTmFtZT0iTGlnaHQgU2hhZGluZyBBY2NlbnQgMSIvPg0KICA8dzpMc2RFeGNlcHRpb24gTG9j a2VkPSJmYWxzZSIgUHJpb3JpdHk9IjYxIiBTZW1pSGlkZGVuPSJmYWxzZSINCiAgIFVuaGlkZVdo ZW5Vc2VkPSJmYWxzZSIgTmFtZT0iTGlnaHQgTGlzdCBBY2NlbnQgMSIvPg0KICA8dzpMc2RFeGNl cHRpb24gTG9ja2VkPSJmYWxzZSIgUHJpb3JpdHk9IjYyIiBTZW1pSGlkZGVuPSJmYWxzZSINCiAg IFVuaGlkZVdoZW5Vc2VkPSJmYWxzZSIgTmFtZT0iTGlnaHQgR3JpZCBBY2NlbnQgMSIvPg0KICA8 dzpMc2RFeGNlcHRpb24gTG9ja2VkPSJmYWxzZSIgUHJpb3JpdHk9IjYzIiBTZW1pSGlkZGVuPSJm YWxzZSINCiAgIFVuaGlkZVdoZW5Vc2VkPSJmYWxzZSIgTmFtZT0iTWVkaXVtIFNoYWRpbmcgMSBB Y2NlbnQgMSIvPg0KICA8dzpMc2RFeGNlcHRpb24gTG9ja2VkPSJmYWxzZSIgUHJpb3JpdHk9IjY0 IiBTZW1pSGlkZGVuPSJmYWxzZSINCiAgIFVuaGlkZVdoZW5Vc2VkPSJmYWxzZSIgTmFtZT0iTWVk aXVtIFNoYWRpbmcgMiBBY2NlbnQgMSIvPg0KICA8dzpMc2RFeGNlcHRpb24gTG9ja2VkPSJmYWxz ZSIgUHJpb3JpdHk9IjY1IiBTZW1pSGlkZGVuPSJmYWxzZSINCiAgIFVuaGlkZVdoZW5Vc2VkPSJm YWxzZSIgTmFtZT0iTWVkaXVtIExpc3QgMSBBY2NlbnQgMSIvPg0KICA8dzpMc2RFeGNlcHRpb24g TG9ja2VkPSJmYWxzZSIgVW5oaWRlV2hlblVzZWQ9ImZhbHNlIiBOYW1lPSJSZXZpc2lvbiIvPg0K ICA8dzpMc2RFeGNlcHRpb24gTG9ja2VkPSJmYWxzZSIgUHJpb3JpdHk9IjM0IiBTZW1pSGlkZGVu PSJmYWxzZSINCiAgIFVuaGlkZVdoZW5Vc2VkPSJmYWxzZSIgUUZvcm1hdD0idHJ1ZSIgTmFtZT0i TGlzdCBQYXJhZ3JhcGgiLz4NCiAgPHc6THNkRXhjZXB0aW9uIExvY2tlZD0iZmFsc2UiIFByaW9y aXR5PSIyOSIgU2VtaUhpZGRlbj0iZmFsc2UiDQogICBVbmhpZGVXaGVuVXNlZD0iZmFsc2UiIFFG b3JtYXQ9InRydWUiIE5hbWU9IlF1b3RlIi8+DQogIDx3OkxzZEV4Y2VwdGlvbiBMb2NrZWQ9ImZh bHNlIiBQcmlvcml0eT0iMzAiIFNlbWlIaWRkZW49ImZhbHNlIg0KICAgVW5oaWRlV2hlblVzZWQ9 ImZhbHNlIiBRRm9ybWF0PSJ0cnVlIiBOYW1lPSJJbnRlbnNlIFF1b3RlIi8+DQogIDx3OkxzZEV4 Y2VwdGlvbiBMb2NrZWQ9ImZhbHNlIiBQcmlvcml0eT0iNjYiIFNlbWlIaWRkZW49ImZhbHNlIg0K ICAgVW5oaWRlV2hlblVzZWQ9ImZhbHNlIiBOYW1lPSJNZWRpdW0gTGlzdCAyIEFjY2VudCAxIi8+ DQogIDx3OkxzZEV4Y2VwdGlvbiBMb2NrZWQ9ImZhbHNlIiBQcmlvcml0eT0iNjciIFNlbWlIaWRk ZW49ImZhbHNlIg0KICAgVW5oaWRlV2hlblVzZWQ9ImZhbHNlIiBOYW1lPSJNZWRpdW0gR3JpZCAx IEFjY2VudCAxIi8+DQogIDx3OkxzZEV4Y2VwdGlvbiBMb2NrZWQ9ImZhbHNlIiBQcmlvcml0eT0i NjgiIFNlbWlIaWRkZW49ImZhbHNlIg0KICAgVW5oaWRlV2hlblVzZWQ9ImZhbHNlIiBOYW1lPSJN ZWRpdW0gR3JpZCAyIEFjY2VudCAxIi8+DQogIDx3OkxzZEV4Y2VwdGlvbiBMb2NrZWQ9ImZhbHNl IiBQcmlvcml0eT0iNjkiIFNlbWlIaWRkZW49ImZhbHNlIg0KICAgVW5oaWRlV2hlblVzZWQ9ImZh bHNlIiBOYW1lPSJNZWRpdW0gR3JpZCAzIEFjY2VudCAxIi8+DQogIDx3OkxzZEV4Y2VwdGlvbiBM b2NrZWQ9ImZhbHNlIiBQcmlvcml0eT0iNzAiIFNlbWlIaWRkZW49ImZhbHNlIg0KICAgVW5oaWRl V2hlblVzZWQ9ImZhbHNlIiBOYW1lPSJEYXJrIExpc3QgQWNjZW50IDEiLz4NCiAgPHc6THNkRXhj ZXB0aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSI3MSIgU2VtaUhpZGRlbj0iZmFsc2UiDQog ICBVbmhpZGVXaGVuVXNlZD0iZmFsc2UiIE5hbWU9IkNvbG9yZnVsIFNoYWRpbmcgQWNjZW50IDEi Lz4NCiAgPHc6THNkRXhjZXB0aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSI3MiIgU2VtaUhp ZGRlbj0iZmFsc2UiDQogICBVbmhpZGVXaGVuVXNlZD0iZmFsc2UiIE5hbWU9IkNvbG9yZnVsIExp c3QgQWNjZW50IDEiLz4NCiAgPHc6THNkRXhjZXB0aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5 PSI3MyIgU2VtaUhpZGRlbj0iZmFsc2UiDQogICBVbmhpZGVXaGVuVXNlZD0iZmFsc2UiIE5hbWU9 IkNvbG9yZnVsIEdyaWQgQWNjZW50IDEiLz4NCiAgPHc6THNkRXhjZXB0aW9uIExvY2tlZD0iZmFs c2UiIFByaW9yaXR5PSI2MCIgU2VtaUhpZGRlbj0iZmFsc2UiDQogICBVbmhpZGVXaGVuVXNlZD0i ZmFsc2UiIE5hbWU9IkxpZ2h0IFNoYWRpbmcgQWNjZW50IDIiLz4NCiAgPHc6THNkRXhjZXB0aW9u IExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSI2MSIgU2VtaUhpZGRlbj0iZmFsc2UiDQogICBVbmhp ZGVXaGVuVXNlZD0iZmFsc2UiIE5hbWU9IkxpZ2h0IExpc3QgQWNjZW50IDIiLz4NCiAgPHc6THNk RXhjZXB0aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSI2MiIgU2VtaUhpZGRlbj0iZmFsc2Ui DQogICBVbmhpZGVXaGVuVXNlZD0iZmFsc2UiIE5hbWU9IkxpZ2h0IEdyaWQgQWNjZW50IDIiLz4N CiAgPHc6THNkRXhjZXB0aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSI2MyIgU2VtaUhpZGRl bj0iZmFsc2UiDQogICBVbmhpZGVXaGVuVXNlZD0iZmFsc2UiIE5hbWU9Ik1lZGl1bSBTaGFkaW5n IDEgQWNjZW50IDIiLz4NCiAgPHc6THNkRXhjZXB0aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5 PSI2NCIgU2VtaUhpZGRlbj0iZmFsc2UiDQogICBVbmhpZGVXaGVuVXNlZD0iZmFsc2UiIE5hbWU9 Ik1lZGl1bSBTaGFkaW5nIDIgQWNjZW50IDIiLz4NCiAgPHc6THNkRXhjZXB0aW9uIExvY2tlZD0i ZmFsc2UiIFByaW9yaXR5PSI2NSIgU2VtaUhpZGRlbj0iZmFsc2UiDQogICBVbmhpZGVXaGVuVXNl ZD0iZmFsc2UiIE5hbWU9Ik1lZGl1bSBMaXN0IDEgQWNjZW50IDIiLz4NCiAgPHc6THNkRXhjZXB0 aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSI2NiIgU2VtaUhpZGRlbj0iZmFsc2UiDQogICBV bmhpZGVXaGVuVXNlZD0iZmFsc2UiIE5hbWU9Ik1lZGl1bSBMaXN0IDIgQWNjZW50IDIiLz4NCiAg PHc6THNkRXhjZXB0aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSI2NyIgU2VtaUhpZGRlbj0i ZmFsc2UiDQogICBVbmhpZGVXaGVuVXNlZD0iZmFsc2UiIE5hbWU9Ik1lZGl1bSBHcmlkIDEgQWNj ZW50IDIiLz4NCiAgPHc6THNkRXhjZXB0aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSI2OCIg U2VtaUhpZGRlbj0iZmFsc2UiDQogICBVbmhpZGVXaGVuVXNlZD0iZmFsc2UiIE5hbWU9Ik1lZGl1 bSBHcmlkIDIgQWNjZW50IDIiLz4NCiAgPHc6THNkRXhjZXB0aW9uIExvY2tlZD0iZmFsc2UiIFBy aW9yaXR5PSI2OSIgU2VtaUhpZGRlbj0iZmFsc2UiDQogICBVbmhpZGVXaGVuVXNlZD0iZmFsc2Ui IE5hbWU9Ik1lZGl1bSBHcmlkIDMgQWNjZW50IDIiLz4NCiAgPHc6THNkRXhjZXB0aW9uIExvY2tl ZD0iZmFsc2UiIFByaW9yaXR5PSI3MCIgU2VtaUhpZGRlbj0iZmFsc2UiDQogICBVbmhpZGVXaGVu VXNlZD0iZmFsc2UiIE5hbWU9IkRhcmsgTGlzdCBBY2NlbnQgMiIvPg0KICA8dzpMc2RFeGNlcHRp b24gTG9ja2VkPSJmYWxzZSIgUHJpb3JpdHk9IjcxIiBTZW1pSGlkZGVuPSJmYWxzZSINCiAgIFVu aGlkZVdoZW5Vc2VkPSJmYWxzZSIgTmFtZT0iQ29sb3JmdWwgU2hhZGluZyBBY2NlbnQgMiIvPg0K ICA8dzpMc2RFeGNlcHRpb24gTG9ja2VkPSJmYWxzZSIgUHJpb3JpdHk9IjcyIiBTZW1pSGlkZGVu PSJmYWxzZSINCiAgIFVuaGlkZVdoZW5Vc2VkPSJmYWxzZSIgTmFtZT0iQ29sb3JmdWwgTGlzdCBB Y2NlbnQgMiIvPg0KICA8dzpMc2RFeGNlcHRpb24gTG9ja2VkPSJmYWxzZSIgUHJpb3JpdHk9Ijcz IiBTZW1pSGlkZGVuPSJmYWxzZSINCiAgIFVuaGlkZVdoZW5Vc2VkPSJmYWxzZSIgTmFtZT0iQ29s b3JmdWwgR3JpZCBBY2NlbnQgMiIvPg0KICA8dzpMc2RFeGNlcHRpb24gTG9ja2VkPSJmYWxzZSIg UHJpb3JpdHk9IjYwIiBTZW1pSGlkZGVuPSJmYWxzZSINCiAgIFVuaGlkZVdoZW5Vc2VkPSJmYWxz ZSIgTmFtZT0iTGlnaHQgU2hhZGluZyBBY2NlbnQgMyIvPg0KICA8dzpMc2RFeGNlcHRpb24gTG9j a2VkPSJmYWxzZSIgUHJpb3JpdHk9IjYxIiBTZW1pSGlkZGVuPSJmYWxzZSINCiAgIFVuaGlkZVdo ZW5Vc2VkPSJmYWxzZSIgTmFtZT0iTGlnaHQgTGlzdCBBY2NlbnQgMyIvPg0KICA8dzpMc2RFeGNl cHRpb24gTG9ja2VkPSJmYWxzZSIgUHJpb3JpdHk9IjYyIiBTZW1pSGlkZGVuPSJmYWxzZSINCiAg IFVuaGlkZVdoZW5Vc2VkPSJmYWxzZSIgTmFtZT0iTGlnaHQgR3JpZCBBY2NlbnQgMyIvPg0KICA8 dzpMc2RFeGNlcHRpb24gTG9ja2VkPSJmYWxzZSIgUHJpb3JpdHk9IjYzIiBTZW1pSGlkZGVuPSJm YWxzZSINCiAgIFVuaGlkZVdoZW5Vc2VkPSJmYWxzZSIgTmFtZT0iTWVkaXVtIFNoYWRpbmcgMSBB Y2NlbnQgMyIvPg0KICA8dzpMc2RFeGNlcHRpb24gTG9ja2VkPSJmYWxzZSIgUHJpb3JpdHk9IjY0 IiBTZW1pSGlkZGVuPSJmYWxzZSINCiAgIFVuaGlkZVdoZW5Vc2VkPSJmYWxzZSIgTmFtZT0iTWVk aXVtIFNoYWRpbmcgMiBBY2NlbnQgMyIvPg0KICA8dzpMc2RFeGNlcHRpb24gTG9ja2VkPSJmYWxz ZSIgUHJpb3JpdHk9IjY1IiBTZW1pSGlkZGVuPSJmYWxzZSINCiAgIFVuaGlkZVdoZW5Vc2VkPSJm YWxzZSIgTmFtZT0iTWVkaXVtIExpc3QgMSBBY2NlbnQgMyIvPg0KICA8dzpMc2RFeGNlcHRpb24g TG9ja2VkPSJmYWxzZSIgUHJpb3JpdHk9IjY2IiBTZW1pSGlkZGVuPSJmYWxzZSINCiAgIFVuaGlk ZVdoZW5Vc2VkPSJmYWxzZSIgTmFtZT0iTWVkaXVtIExpc3QgMiBBY2NlbnQgMyIvPg0KICA8dzpM c2RFeGNlcHRpb24gTG9ja2VkPSJmYWxzZSIgUHJpb3JpdHk9IjY3IiBTZW1pSGlkZGVuPSJmYWxz ZSINCiAgIFVuaGlkZVdoZW5Vc2VkPSJmYWxzZSIgTmFtZT0iTWVkaXVtIEdyaWQgMSBBY2NlbnQg MyIvPg0KICA8dzpMc2RFeGNlcHRpb24gTG9ja2VkPSJmYWxzZSIgUHJpb3JpdHk9IjY4IiBTZW1p SGlkZGVuPSJmYWxzZSINCiAgIFVuaGlkZVdoZW5Vc2VkPSJmYWxzZSIgTmFtZT0iTWVkaXVtIEdy aWQgMiBBY2NlbnQgMyIvPg0KICA8dzpMc2RFeGNlcHRpb24gTG9ja2VkPSJmYWxzZSIgUHJpb3Jp dHk9IjY5IiBTZW1pSGlkZGVuPSJmYWxzZSINCiAgIFVuaGlkZVdoZW5Vc2VkPSJmYWxzZSIgTmFt ZT0iTWVkaXVtIEdyaWQgMyBBY2NlbnQgMyIvPg0KICA8dzpMc2RFeGNlcHRpb24gTG9ja2VkPSJm YWxzZSIgUHJpb3JpdHk9IjcwIiBTZW1pSGlkZGVuPSJmYWxzZSINCiAgIFVuaGlkZVdoZW5Vc2Vk PSJmYWxzZSIgTmFtZT0iRGFyayBMaXN0IEFjY2VudCAzIi8+DQogIDx3OkxzZEV4Y2VwdGlvbiBM b2NrZWQ9ImZhbHNlIiBQcmlvcml0eT0iNzEiIFNlbWlIaWRkZW49ImZhbHNlIg0KICAgVW5oaWRl V2hlblVzZWQ9ImZhbHNlIiBOYW1lPSJDb2xvcmZ1bCBTaGFkaW5nIEFjY2VudCAzIi8+DQogIDx3 OkxzZEV4Y2VwdGlvbiBMb2NrZWQ9ImZhbHNlIiBQcmlvcml0eT0iNzIiIFNlbWlIaWRkZW49ImZh bHNlIg0KICAgVW5oaWRlV2hlblVzZWQ9ImZhbHNlIiBOYW1lPSJDb2xvcmZ1bCBMaXN0IEFjY2Vu dCAzIi8+DQogIDx3OkxzZEV4Y2VwdGlvbiBMb2NrZWQ9ImZhbHNlIiBQcmlvcml0eT0iNzMiIFNl bWlIaWRkZW49ImZhbHNlIg0KICAgVW5oaWRlV2hlblVzZWQ9ImZhbHNlIiBOYW1lPSJDb2xvcmZ1 bCBHcmlkIEFjY2VudCAzIi8+DQogIDx3OkxzZEV4Y2VwdGlvbiBMb2NrZWQ9ImZhbHNlIiBQcmlv cml0eT0iNjAiIFNlbWlIaWRkZW49ImZhbHNlIg0KICAgVW5oaWRlV2hlblVzZWQ9ImZhbHNlIiBO YW1lPSJMaWdodCBTaGFkaW5nIEFjY2VudCA0Ii8+DQogIDx3OkxzZEV4Y2VwdGlvbiBMb2NrZWQ9 ImZhbHNlIiBQcmlvcml0eT0iNjEiIFNlbWlIaWRkZW49ImZhbHNlIg0KICAgVW5oaWRlV2hlblVz ZWQ9ImZhbHNlIiBOYW1lPSJMaWdodCBMaXN0IEFjY2VudCA0Ii8+DQogIDx3OkxzZEV4Y2VwdGlv biBMb2NrZWQ9ImZhbHNlIiBQcmlvcml0eT0iNjIiIFNlbWlIaWRkZW49ImZhbHNlIg0KICAgVW5o aWRlV2hlblVzZWQ9ImZhbHNlIiBOYW1lPSJMaWdodCBHcmlkIEFjY2VudCA0Ii8+DQogIDx3Okxz ZEV4Y2VwdGlvbiBMb2NrZWQ9ImZhbHNlIiBQcmlvcml0eT0iNjMiIFNlbWlIaWRkZW49ImZhbHNl Ig0KICAgVW5oaWRlV2hlblVzZWQ9ImZhbHNlIiBOYW1lPSJNZWRpdW0gU2hhZGluZyAxIEFjY2Vu dCA0Ii8+DQogIDx3OkxzZEV4Y2VwdGlvbiBMb2NrZWQ9ImZhbHNlIiBQcmlvcml0eT0iNjQiIFNl bWlIaWRkZW49ImZhbHNlIg0KICAgVW5oaWRlV2hlblVzZWQ9ImZhbHNlIiBOYW1lPSJNZWRpdW0g U2hhZGluZyAyIEFjY2VudCA0Ii8+DQogIDx3OkxzZEV4Y2VwdGlvbiBMb2NrZWQ9ImZhbHNlIiBQ cmlvcml0eT0iNjUiIFNlbWlIaWRkZW49ImZhbHNlIg0KICAgVW5oaWRlV2hlblVzZWQ9ImZhbHNl IiBOYW1lPSJNZWRpdW0gTGlzdCAxIEFjY2VudCA0Ii8+DQogIDx3OkxzZEV4Y2VwdGlvbiBMb2Nr ZWQ9ImZhbHNlIiBQcmlvcml0eT0iNjYiIFNlbWlIaWRkZW49ImZhbHNlIg0KICAgVW5oaWRlV2hl blVzZWQ9ImZhbHNlIiBOYW1lPSJNZWRpdW0gTGlzdCAyIEFjY2VudCA0Ii8+DQogIDx3OkxzZEV4 Y2VwdGlvbiBMb2NrZWQ9ImZhbHNlIiBQcmlvcml0eT0iNjciIFNlbWlIaWRkZW49ImZhbHNlIg0K ICAgVW5oaWRlV2hlblVzZWQ9ImZhbHNlIiBOYW1lPSJNZWRpdW0gR3JpZCAxIEFjY2VudCA0Ii8+ DQogIDx3OkxzZEV4Y2VwdGlvbiBMb2NrZWQ9ImZhbHNlIiBQcmlvcml0eT0iNjgiIFNlbWlIaWRk ZW49ImZhbHNlIg0KICAgVW5oaWRlV2hlblVzZWQ9ImZhbHNlIiBOYW1lPSJNZWRpdW0gR3JpZCAy IEFjY2VudCA0Ii8+DQogIDx3OkxzZEV4Y2VwdGlvbiBMb2NrZWQ9ImZhbHNlIiBQcmlvcml0eT0i NjkiIFNlbWlIaWRkZW49ImZhbHNlIg0KICAgVW5oaWRlV2hlblVzZWQ9ImZhbHNlIiBOYW1lPSJN ZWRpdW0gR3JpZCAzIEFjY2VudCA0Ii8+DQogIDx3OkxzZEV4Y2VwdGlvbiBMb2NrZWQ9ImZhbHNl IiBQcmlvcml0eT0iNzAiIFNlbWlIaWRkZW49ImZhbHNlIg0KICAgVW5oaWRlV2hlblVzZWQ9ImZh bHNlIiBOYW1lPSJEYXJrIExpc3QgQWNjZW50IDQiLz4NCiAgPHc6THNkRXhjZXB0aW9uIExvY2tl ZD0iZmFsc2UiIFByaW9yaXR5PSI3MSIgU2VtaUhpZGRlbj0iZmFsc2UiDQogICBVbmhpZGVXaGVu VXNlZD0iZmFsc2UiIE5hbWU9IkNvbG9yZnVsIFNoYWRpbmcgQWNjZW50IDQiLz4NCiAgPHc6THNk RXhjZXB0aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSI3MiIgU2VtaUhpZGRlbj0iZmFsc2Ui DQogICBVbmhpZGVXaGVuVXNlZD0iZmFsc2UiIE5hbWU9IkNvbG9yZnVsIExpc3QgQWNjZW50IDQi Lz4NCiAgPHc6THNkRXhjZXB0aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSI3MyIgU2VtaUhp ZGRlbj0iZmFsc2UiDQogICBVbmhpZGVXaGVuVXNlZD0iZmFsc2UiIE5hbWU9IkNvbG9yZnVsIEdy aWQgQWNjZW50IDQiLz4NCiAgPHc6THNkRXhjZXB0aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5 PSI2MCIgU2VtaUhpZGRlbj0iZmFsc2UiDQogICBVbmhpZGVXaGVuVXNlZD0iZmFsc2UiIE5hbWU9 IkxpZ2h0IFNoYWRpbmcgQWNjZW50IDUiLz4NCiAgPHc6THNkRXhjZXB0aW9uIExvY2tlZD0iZmFs c2UiIFByaW9yaXR5PSI2MSIgU2VtaUhpZGRlbj0iZmFsc2UiDQogICBVbmhpZGVXaGVuVXNlZD0i ZmFsc2UiIE5hbWU9IkxpZ2h0IExpc3QgQWNjZW50IDUiLz4NCiAgPHc6THNkRXhjZXB0aW9uIExv Y2tlZD0iZmFsc2UiIFByaW9yaXR5PSI2MiIgU2VtaUhpZGRlbj0iZmFsc2UiDQogICBVbmhpZGVX aGVuVXNlZD0iZmFsc2UiIE5hbWU9IkxpZ2h0IEdyaWQgQWNjZW50IDUiLz4NCiAgPHc6THNkRXhj ZXB0aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSI2MyIgU2VtaUhpZGRlbj0iZmFsc2UiDQog ICBVbmhpZGVXaGVuVXNlZD0iZmFsc2UiIE5hbWU9Ik1lZGl1bSBTaGFkaW5nIDEgQWNjZW50IDUi Lz4NCiAgPHc6THNkRXhjZXB0aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSI2NCIgU2VtaUhp ZGRlbj0iZmFsc2UiDQogICBVbmhpZGVXaGVuVXNlZD0iZmFsc2UiIE5hbWU9Ik1lZGl1bSBTaGFk aW5nIDIgQWNjZW50IDUiLz4NCiAgPHc6THNkRXhjZXB0aW9uIExvY2tlZD0iZmFsc2UiIFByaW9y aXR5PSI2NSIgU2VtaUhpZGRlbj0iZmFsc2UiDQogICBVbmhpZGVXaGVuVXNlZD0iZmFsc2UiIE5h bWU9Ik1lZGl1bSBMaXN0IDEgQWNjZW50IDUiLz4NCiAgPHc6THNkRXhjZXB0aW9uIExvY2tlZD0i ZmFsc2UiIFByaW9yaXR5PSI2NiIgU2VtaUhpZGRlbj0iZmFsc2UiDQogICBVbmhpZGVXaGVuVXNl ZD0iZmFsc2UiIE5hbWU9Ik1lZGl1bSBMaXN0IDIgQWNjZW50IDUiLz4NCiAgPHc6THNkRXhjZXB0 aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSI2NyIgU2VtaUhpZGRlbj0iZmFsc2UiDQogICBV bmhpZGVXaGVuVXNlZD0iZmFsc2UiIE5hbWU9Ik1lZGl1bSBHcmlkIDEgQWNjZW50IDUiLz4NCiAg PHc6THNkRXhjZXB0aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSI2OCIgU2VtaUhpZGRlbj0i ZmFsc2UiDQogICBVbmhpZGVXaGVuVXNlZD0iZmFsc2UiIE5hbWU9Ik1lZGl1bSBHcmlkIDIgQWNj ZW50IDUiLz4NCiAgPHc6THNkRXhjZXB0aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSI2OSIg U2VtaUhpZGRlbj0iZmFsc2UiDQogICBVbmhpZGVXaGVuVXNlZD0iZmFsc2UiIE5hbWU9Ik1lZGl1 bSBHcmlkIDMgQWNjZW50IDUiLz4NCiAgPHc6THNkRXhjZXB0aW9uIExvY2tlZD0iZmFsc2UiIFBy aW9yaXR5PSI3MCIgU2VtaUhpZGRlbj0iZmFsc2UiDQogICBVbmhpZGVXaGVuVXNlZD0iZmFsc2Ui IE5hbWU9IkRhcmsgTGlzdCBBY2NlbnQgNSIvPg0KICA8dzpMc2RFeGNlcHRpb24gTG9ja2VkPSJm YWxzZSIgUHJpb3JpdHk9IjcxIiBTZW1pSGlkZGVuPSJmYWxzZSINCiAgIFVuaGlkZVdoZW5Vc2Vk PSJmYWxzZSIgTmFtZT0iQ29sb3JmdWwgU2hhZGluZyBBY2NlbnQgNSIvPg0KICA8dzpMc2RFeGNl cHRpb24gTG9ja2VkPSJmYWxzZSIgUHJpb3JpdHk9IjcyIiBTZW1pSGlkZGVuPSJmYWxzZSINCiAg IFVuaGlkZVdoZW5Vc2VkPSJmYWxzZSIgTmFtZT0iQ29sb3JmdWwgTGlzdCBBY2NlbnQgNSIvPg0K ICA8dzpMc2RFeGNlcHRpb24gTG9ja2VkPSJmYWxzZSIgUHJpb3JpdHk9IjczIiBTZW1pSGlkZGVu PSJmYWxzZSINCiAgIFVuaGlkZVdoZW5Vc2VkPSJmYWxzZSIgTmFtZT0iQ29sb3JmdWwgR3JpZCBB Y2NlbnQgNSIvPg0KICA8dzpMc2RFeGNlcHRpb24gTG9ja2VkPSJmYWxzZSIgUHJpb3JpdHk9IjYw IiBTZW1pSGlkZGVuPSJmYWxzZSINCiAgIFVuaGlkZVdoZW5Vc2VkPSJmYWxzZSIgTmFtZT0iTGln aHQgU2hhZGluZyBBY2NlbnQgNiIvPg0KICA8dzpMc2RFeGNlcHRpb24gTG9ja2VkPSJmYWxzZSIg UHJpb3JpdHk9IjYxIiBTZW1pSGlkZGVuPSJmYWxzZSINCiAgIFVuaGlkZVdoZW5Vc2VkPSJmYWxz ZSIgTmFtZT0iTGlnaHQgTGlzdCBBY2NlbnQgNiIvPg0KICA8dzpMc2RFeGNlcHRpb24gTG9ja2Vk PSJmYWxzZSIgUHJpb3JpdHk9IjYyIiBTZW1pSGlkZGVuPSJmYWxzZSINCiAgIFVuaGlkZVdoZW5V c2VkPSJmYWxzZSIgTmFtZT0iTGlnaHQgR3JpZCBBY2NlbnQgNiIvPg0KICA8dzpMc2RFeGNlcHRp b24gTG9ja2VkPSJmYWxzZSIgUHJpb3JpdHk9IjYzIiBTZW1pSGlkZGVuPSJmYWxzZSINCiAgIFVu aGlkZVdoZW5Vc2VkPSJmYWxzZSIgTmFtZT0iTWVkaXVtIFNoYWRpbmcgMSBBY2NlbnQgNiIvPg0K ICA8dzpMc2RFeGNlcHRpb24gTG9ja2VkPSJmYWxzZSIgUHJpb3JpdHk9IjY0IiBTZW1pSGlkZGVu PSJmYWxzZSINCiAgIFVuaGlkZVdoZW5Vc2VkPSJmYWxzZSIgTmFtZT0iTWVkaXVtIFNoYWRpbmcg MiBBY2NlbnQgNiIvPg0KICA8dzpMc2RFeGNlcHRpb24gTG9ja2VkPSJmYWxzZSIgUHJpb3JpdHk9 IjY1IiBTZW1pSGlkZGVuPSJmYWxzZSINCiAgIFVuaGlkZVdoZW5Vc2VkPSJmYWxzZSIgTmFtZT0i TWVkaXVtIExpc3QgMSBBY2NlbnQgNiIvPg0KICA8dzpMc2RFeGNlcHRpb24gTG9ja2VkPSJmYWxz ZSIgUHJpb3JpdHk9IjY2IiBTZW1pSGlkZGVuPSJmYWxzZSINCiAgIFVuaGlkZVdoZW5Vc2VkPSJm YWxzZSIgTmFtZT0iTWVkaXVtIExpc3QgMiBBY2NlbnQgNiIvPg0KICA8dzpMc2RFeGNlcHRpb24g TG9ja2VkPSJmYWxzZSIgUHJpb3JpdHk9IjY3IiBTZW1pSGlkZGVuPSJmYWxzZSINCiAgIFVuaGlk ZVdoZW5Vc2VkPSJmYWxzZSIgTmFtZT0iTWVkaXVtIEdyaWQgMSBBY2NlbnQgNiIvPg0KICA8dzpM c2RFeGNlcHRpb24gTG9ja2VkPSJmYWxzZSIgUHJpb3JpdHk9IjY4IiBTZW1pSGlkZGVuPSJmYWxz ZSINCiAgIFVuaGlkZVdoZW5Vc2VkPSJmYWxzZSIgTmFtZT0iTWVkaXVtIEdyaWQgMiBBY2NlbnQg NiIvPg0KICA8dzpMc2RFeGNlcHRpb24gTG9ja2VkPSJmYWxzZSIgUHJpb3JpdHk9IjY5IiBTZW1p SGlkZGVuPSJmYWxzZSINCiAgIFVuaGlkZVdoZW5Vc2VkPSJmYWxzZSIgTmFtZT0iTWVkaXVtIEdy aWQgMyBBY2NlbnQgNiIvPg0KICA8dzpMc2RFeGNlcHRpb24gTG9ja2VkPSJmYWxzZSIgUHJpb3Jp dHk9IjcwIiBTZW1pSGlkZGVuPSJmYWxzZSINCiAgIFVuaGlkZVdoZW5Vc2VkPSJmYWxzZSIgTmFt ZT0iRGFyayBMaXN0IEFjY2VudCA2Ii8+DQogIDx3OkxzZEV4Y2VwdGlvbiBMb2NrZWQ9ImZhbHNl IiBQcmlvcml0eT0iNzEiIFNlbWlIaWRkZW49ImZhbHNlIg0KICAgVW5oaWRlV2hlblVzZWQ9ImZh bHNlIiBOYW1lPSJDb2xvcmZ1bCBTaGFkaW5nIEFjY2VudCA2Ii8+DQogIDx3OkxzZEV4Y2VwdGlv biBMb2NrZWQ9ImZhbHNlIiBQcmlvcml0eT0iNzIiIFNlbWlIaWRkZW49ImZhbHNlIg0KICAgVW5o aWRlV2hlblVzZWQ9ImZhbHNlIiBOYW1lPSJDb2xvcmZ1bCBMaXN0IEFjY2VudCA2Ii8+DQogIDx3 OkxzZEV4Y2VwdGlvbiBMb2NrZWQ9ImZhbHNlIiBQcmlvcml0eT0iNzMiIFNlbWlIaWRkZW49ImZh bHNlIg0KICAgVW5oaWRlV2hlblVzZWQ9ImZhbHNlIiBOYW1lPSJDb2xvcmZ1bCBHcmlkIEFjY2Vu dCA2Ii8+DQogIDx3OkxzZEV4Y2VwdGlvbiBMb2NrZWQ9ImZhbHNlIiBQcmlvcml0eT0iMTkiIFNl bWlIaWRkZW49ImZhbHNlIg0KICAgVW5oaWRlV2hlblVzZWQ9ImZhbHNlIiBRRm9ybWF0PSJ0cnVl IiBOYW1lPSJTdWJ0bGUgRW1waGFzaXMiLz4NCiAgPHc6THNkRXhjZXB0aW9uIExvY2tlZD0iZmFs c2UiIFByaW9yaXR5PSIyMSIgU2VtaUhpZGRlbj0iZmFsc2UiDQogICBVbmhpZGVXaGVuVXNlZD0i ZmFsc2UiIFFGb3JtYXQ9InRydWUiIE5hbWU9IkludGVuc2UgRW1waGFzaXMiLz4NCiAgPHc6THNk RXhjZXB0aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSIzMSIgU2VtaUhpZGRlbj0iZmFsc2Ui DQogICBVbmhpZGVXaGVuVXNlZD0iZmFsc2UiIFFGb3JtYXQ9InRydWUiIE5hbWU9IlN1YnRsZSBS ZWZlcmVuY2UiLz4NCiAgPHc6THNkRXhjZXB0aW9uIExvY2tlZD0iZmFsc2UiIFByaW9yaXR5PSIz MiIgU2VtaUhpZGRlbj0iZmFsc2UiDQogICBVbmhpZGVXaGVuVXNlZD0iZmFsc2UiIFFGb3JtYXQ9 InRydWUiIE5hbWU9IkludGVuc2UgUmVmZXJlbmNlIi8+DQogIDx3OkxzZEV4Y2VwdGlvbiBMb2Nr ZWQ9ImZhbHNlIiBQcmlvcml0eT0iMzMiIFNlbWlIaWRkZW49ImZhbHNlIg0KICAgVW5oaWRlV2hl blVzZWQ9ImZhbHNlIiBRRm9ybWF0PSJ0cnVlIiBOYW1lPSJCb29rIFRpdGxlIi8+DQogIDx3Okxz ZEV4Y2VwdGlvbiBMb2NrZWQ9ImZhbHNlIiBQcmlvcml0eT0iMzciIE5hbWU9IkJpYmxpb2dyYXBo eSIvPg0KICA8dzpMc2RFeGNlcHRpb24gTG9ja2VkPSJmYWxzZSIgUHJpb3JpdHk9IjM5IiBRRm9y bWF0PSJ0cnVlIiBOYW1lPSJUT0MgSGVhZGluZyIvPg0KIDwvdzpMYXRlbnRTdHlsZXM+DQo8L3ht bD48IVtlbmRpZl0tLT48IS0tW2lmIGd0ZSBtc28gMTBdPg0KPHN0eWxlPg0KIC8qIFN0eWxlIERl ZmluaXRpb25zICovDQp0YWJsZS5Nc29Ob3JtYWxUYWJsZQ0KCXttc28tc3R5bGUtbmFtZToiVGFi bGUgTm9ybWFsIjsNCgltc28tdHN0eWxlLXJvd2JhbmQtc2l6ZTowOw0KCW1zby10c3R5bGUtY29s YmFuZC1zaXplOjA7DQoJbXNvLXN0eWxlLW5vc2hvdzp5ZXM7DQoJbXNvLXN0eWxlLXByaW9yaXR5 Ojk5Ow0KCW1zby1zdHlsZS1wYXJlbnQ6IiI7DQoJbXNvLXBhZGRpbmctYWx0OjBpbiA1LjRwdCAw aW4gNS40cHQ7DQoJbXNvLXBhcmEtbWFyZ2luOjBpbjsNCgltc28tcGFyYS1tYXJnaW4tYm90dG9t Oi4wMDAxcHQ7DQoJbXNvLXBhZ2luYXRpb246d2lkb3ctb3JwaGFuOw0KCWZvbnQtc2l6ZToxMC4w cHQ7DQoJZm9udC1mYW1pbHk6IlRpbWVzIE5ldyBSb21hbiI7DQoJYm9yZGVyOm5vbmU7fQ0KPC9z dHlsZT4NCjwhW2VuZGlmXS0tPjwhLS1TdGFydEZyYWdtZW50LS0+DQo8cCBjbGFzcz0iSGVhZGlu ZyIgYWxpZ249ImNlbnRlciIgc3R5bGU9Im1hcmdpbi1ib3R0b206MTEuMHB0O3RleHQtYWxpZ246 Y2VudGVyIj4NCjxzcGFuIHN0eWxlPSJmb250LXNpemU6MTIuMHB0O2ZvbnQtZmFtaWx5OiZxdW90 O0FyaWFsIEJvbGQmcXVvdDs7bXNvLWhhbnNpLWZvbnQtZmFtaWx5OiZxdW90O0FyaWFsIFVuaWNv ZGUgTVMmcXVvdDs7DQpiYWNrZ3JvdW5kOndoaXRlIj5YZW4gUHJvamVjdCBSZWxlYXNlcyBVcGRh dGUgdG8gRW50ZXJwcmlzZSBIeXBlcnZpc29yIFNvZnR3YXJlPC9zcGFuPjxzcGFuIHN0eWxlPSJm b250LXNpemU6MTIuMHB0O2ZvbnQtZmFtaWx5OiZxdW90O0FyaWFsIEJvbGQmcXVvdDs7bXNvLWZh cmVhc3QtZm9udC1mYW1pbHk6JnF1b3Q7QXJpYWwgQm9sZCZxdW90OzsNCm1zby1iaWRpLWZvbnQt ZmFtaWx5OiZxdW90O0FyaWFsIEJvbGQmcXVvdDs7YmFja2dyb3VuZDp3aGl0ZSI+PG86cD48L286 cD48L3NwYW4+PC9wPg0KPHAgY2xhc3M9IkJvZHkiIGFsaWduPSJjZW50ZXIiIHN0eWxlPSJtYXJn aW4tYm90dG9tOiAxMXB0OyB0ZXh0LWFsaWduOiBjZW50ZXI7Ij48Yj48aT48c3BhbiBzdHlsZT0i Zm9udC1zaXplOjEyLjBwdDtiYWNrZ3JvdW5kOndoaXRlIj5PcGVuIFNvdXJjZSBWaXJ0dWFsaXph dGlvbiBTb2Z0d2FyZSBSZWxlYXNlIEluY2x1ZGVzIEFkZGl0aW9uYWwgQVJNIFN1cHBvcnQgYW5k IFNjYWxhYmlsaXR5IGZvciBDbG91ZCBhbmQgTW9iaWxlIEVudmlyb25tZW50cyZuYnNwOw0KPG86 cD48L286cD48L3NwYW4+PC9pPjwvYj48L3A+DQo8cCBjbGFzcz0iQm9keSIgYWxpZ249ImNlbnRl ciIgc3R5bGU9Im1hcmdpbi1ib3R0b206IDExcHQ7IHRleHQtYWxpZ246IGNlbnRlcjsiPjxiPjxp PjxzcGFuIHN0eWxlPSJmb250LXNpemU6MTIuMHB0O2JhY2tncm91bmQ6d2hpdGUiPjxvOnA+Jm5i c3A7PC9vOnA+PC9zcGFuPjwvaT48L2I+PC9wPg0KPHAgY2xhc3M9IkJvZHkiIHN0eWxlPSJtYXJn aW4tYm90dG9tOiAxMXB0OyI+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZToxMi4wcHQ7Zm9udC1mYW1p bHk6JnF1b3Q7QXJpYWwgQm9sZCZxdW90Ozttc28taGFuc2ktZm9udC1mYW1pbHk6JnF1b3Q7QXJp YWwgVW5pY29kZSBNUyZxdW90OzsNCmJhY2tncm91bmQ6d2hpdGUiPlNBTiBGUkFOQ0lTQ08sIE1h cmNoIDEwLCAyMDE0PC9zcGFuPjxzcGFuIHN0eWxlPSJmb250LXNpemU6DQoxMi4wcHQ7bXNvLWhh bnNpLWZvbnQtZmFtaWx5OkFyaWFsO2JhY2tncm91bmQ6d2hpdGUiPg0KIOKAkzwvc3Bhbj48c3Bh biBzdHlsZT0iZm9udC1zaXplOjEyLjBwdDtiYWNrZ3JvdW5kOndoaXRlIj4gWGVuIFByb2plY3Qs IGEgQ29sbGFib3JhdGl2ZSBQcm9qZWN0IGhvc3RlZCBhdCBUaGUgTGludXggRm91bmRhdGlvbiwg dG9kYXkgYW5ub3VuY2VkIGF2YWlsYWJpbGl0eSBvZiB0aGUgWGVuIFByb2plY3QgNC40IHdpdGgg ZW5oYW5jZWQgQVJNIHN1cHBvcnQuIFRoZSBsYXRlc3QgcmVsZWFzZSBhbHNvIGluY2x1ZGVzIG1h am9yIHBlcmZvcm1hbmNlDQogYW5kIHN5c3RlbSBzY2FsYWJpbGl0eSBpbXByb3ZlbWVudHMgZm9y IGVudGVycHJpc2UgY29tcHV0aW5nLCBzdWNoIGFzIG1vYmlsZSBhbmQgY2xvdWQgZW52aXJvbm1l bnRzLCB3aGVyZSB2aXJ0dWFsaXphdGlvbiB0ZWNobm9sb2d5IGlzIGluY3JlYXNpbmdseSBpbiBk ZW1hbmQuDQo8bzpwPjwvbzpwPjwvc3Bhbj48L3A+DQo8cCBjbGFzcz0iQm9keSIgc3R5bGU9Im1h cmdpbi1ib3R0b206IDExcHQ7Ij48c3BhbiBzdHlsZT0iZm9udC1zaXplOjEyLjBwdDtiYWNrZ3Jv dW5kOndoaXRlIj5UaGlzIHJlbGVhc2UgZnVydGhlciBhZHZhbmNlcyB0aGUgUHJvamVjdDwvc3Bh bj48c3BhbiBsYW5nPSJGUiIgc3R5bGU9ImZvbnQtc2l6ZToxMi4wcHQ7bXNvLWhhbnNpLWZvbnQt ZmFtaWx5OkFyaWFsOw0KYmFja2dyb3VuZDp3aGl0ZTttc28tYW5zaS1sYW5ndWFnZTpGUiI+4oCZ PC9zcGFuPjxzcGFuIHN0eWxlPSJmb250LXNpemU6MTIuMHB0Ow0KYmFja2dyb3VuZDp3aGl0ZSI+ cw0KIHBvc2l0aW9uIGFzIGEgZmFzdCwgc2NhbGFibGUsIHNlY3VyZSB2aXJ0dWFsaXphdGlvbiBl bmdpbmUgZm9yIHRoZSBpbmR1c3RyeTwvc3Bhbj48c3BhbiBsYW5nPSJGUiIgc3R5bGU9ImZvbnQt c2l6ZToxMi4wcHQ7bXNvLWhhbnNpLWZvbnQtZmFtaWx5Og0KQXJpYWw7YmFja2dyb3VuZDp3aGl0 ZTttc28tYW5zaS1sYW5ndWFnZTpGUiI+4oCZPC9zcGFuPjxzcGFuIHN0eWxlPSJmb250LXNpemU6 DQoxMi4wcHQ7YmFja2dyb3VuZDp3aGl0ZSI+cyBicm9hZGVzdA0KIHJhbmdlIG9mIHNlcnZlciwg UEMgY2hpcHNldHMgYW5kIG5leHQtZ2VuZXJhdGlvbiBsb3ctcG93ZXIgc3lzdGVtcyBvbiBjaGlw cyAoU29DKS4NCjxvOnA+PC9vOnA+PC9zcGFuPjwvcD4NCjxwIGNsYXNzPSJCb2R5IiBzdHlsZT0i bWFyZ2luLWJvdHRvbTogMTFwdDsiPjxzcGFuIHN0eWxlPSJmb250LXNpemU6MTIuMHB0O2JhY2tn cm91bmQ6d2hpdGUiPk1ham9yIGNvbnRyaWJ1dGlvbnMgZnJvbSBBTUQsIENpdHJpeCwgSW50ZWws IE9yYWNsZSBhbmQgU1VTRSBhcmUgcHVzaGluZyB0aGUgWGVuIFByb2plY3Qgc29mdHdhcmUgdG8g dGFrZSBhZHZhbnRhZ2Ugb2YgdGhlIGxhdGVzdCBoYXJkd2FyZS4gQWRkaXRpb25hbGx5LCBkZXZl bG9wZXJzDQogY3JlYXRpbmcgc2VydmljZXMgYW5kIGFwcHMgd2l0aCBlbWJlZGRlZCwgbW9iaWxl IGFuZCBjbG91ZCBzeXN0ZW1zIHdpbGwgYmVuZWZpdCBmcm9tIG5ldyBmZWF0dXJlcyBzdWNoIGFz IGV2ZW50IGNoYW5uZWxpbmcgd2hlbiBzY2FsaW5nIG91dCB0aGVpciBJbmZyYXN0cnVjdHVyZSBh cyBhIFNlcnZpY2Ugb2ZmZXJpbmdzLjxvOnA+PC9vOnA+PC9zcGFuPjwvcD4NCjxwIGNsYXNzPSJC b2R5IiBzdHlsZT0ibWFyZ2luLWJvdHRvbTogMTFwdDsiPjxzcGFuIHN0eWxlPSJmb250LXNpemU6 MTIuMHB0O21zby1oYW5zaS1mb250LWZhbWlseTpBcmlhbDtiYWNrZ3JvdW5kOndoaXRlIj7igJw8 L3NwYW4+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZToxMi4wcHQ7YmFja2dyb3VuZDp3aGl0ZSI+Vmly dHVhbGl6YXRpb24gYW5kIGxvdy1wb3dlcmVkIHNlcnZlcnMgYXJlIGxlYWRpbmcgY29tcGFuaWVz IHRvIHJldGhpbmsgdGhlIGRhdGENCiBjZW50ZXIgYW5kIGl0cyBwb3RlbnRpYWwgZm9yIGVmZmlj aWVuY3ksPC9zcGFuPjxzcGFuIHN0eWxlPSJmb250LXNpemU6MTIuMHB0O21zby1oYW5zaS1mb250 LWZhbWlseTpBcmlhbDsNCmJhY2tncm91bmQ6d2hpdGUiPuKAnQ0KPC9zcGFuPjxzcGFuIHN0eWxl PSJmb250LXNpemU6MTIuMHB0O2JhY2tncm91bmQ6d2hpdGUiPnNhaWQgTGFycyBLdXJ0aCwgQ2hh aXJtYW4gb2YgdGhlIFhlbiBQcm9qZWN0IGFkdmlzb3J5IGJvYXJkLg0KPC9zcGFuPjxzcGFuIHN0 eWxlPSJmb250LXNpemU6MTIuMHB0O21zby1oYW5zaS1mb250LWZhbWlseTpBcmlhbDtiYWNrZ3Jv dW5kOndoaXRlIj7igJw8L3NwYW4+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZToxMi4wcHQ7YmFja2dy b3VuZDp3aGl0ZSI+T3VyIHNvbHV0aW9uIGNvbnRhaW5zIElULXJlbGF0ZWQgY29zdHMsIHBsdXMg bWVldHMgdGhlIHNlY3VyaXR5IGFuZCBzY2FsYWJpbGl0eSBuZWVkcyBvZiB0b2RheTwvc3Bhbj48 c3BhbiBsYW5nPSJGUiIgc3R5bGU9ImZvbnQtc2l6ZToxMi4wcHQ7bXNvLWhhbnNpLWZvbnQtZmFt aWx5OkFyaWFsO2JhY2tncm91bmQ6d2hpdGU7DQptc28tYW5zaS1sYW5ndWFnZTpGUiI+4oCZPC9z cGFuPjxzcGFuIHN0eWxlPSJmb250LXNpemU6MTIuMHB0O2JhY2tncm91bmQ6d2hpdGUiPnMNCiBl bGFzdGljIGNsb3VkLCBtb2JpbGUgYW5kIHNvY2lhbCBuZXR3b3JraW5nIGNvbXBhbmllcy4gVGhl IGxhdGVzdCB1cGRhdGVzIGNvbnRpbnVlIHRoZSBQcm9qZWN0PC9zcGFuPjxzcGFuIGxhbmc9IkZS IiBzdHlsZT0iZm9udC1zaXplOjEyLjBwdDttc28taGFuc2ktZm9udC1mYW1pbHk6DQpBcmlhbDti YWNrZ3JvdW5kOndoaXRlO21zby1hbnNpLWxhbmd1YWdlOkZSIj7igJk8L3NwYW4+PHNwYW4gc3R5 bGU9ImZvbnQtc2l6ZToNCjEyLjBwdDtiYWNrZ3JvdW5kOndoaXRlIj5zDQogdHJhY2sgcmVjb3Jk IG9mIHJpY2ggY29sbGFib3JhdGlvbiBhbmQgd2lkZXNwcmVhZCBkZXZlbG9wbWVudCBmcm9tIG1h bnkgb2YgdGhlIHdvcmxkPC9zcGFuPjxzcGFuIGxhbmc9IkZSIiBzdHlsZT0iZm9udC1zaXplOjEy LjBwdDsNCm1zby1oYW5zaS1mb250LWZhbWlseTpBcmlhbDtiYWNrZ3JvdW5kOndoaXRlO21zby1h bnNpLWxhbmd1YWdlOkZSIj7igJk8L3NwYW4+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZToxMi4wcHQ7 YmFja2dyb3VuZDp3aGl0ZSI+cw0KIHRlY2hub2xvZ3kgbGVhZGVycy4gVGhpcyBjZXJ0YWlubHkg ZXhwbGFpbnMgdGhlIHNpZ25pZmljYW50IGdyb3d0aCBvZiBBUk0gc3VwcG9ydCwgd2hpY2ggd2U8 L3NwYW4+PHNwYW4gbGFuZz0iRlIiIHN0eWxlPSJmb250LXNpemU6MTIuMHB0O21zby1oYW5zaS1m b250LWZhbWlseTpBcmlhbDtiYWNrZ3JvdW5kOndoaXRlOw0KbXNvLWFuc2ktbGFuZ3VhZ2U6RlIi PuKAmTwvc3Bhbj48c3BhbiBzdHlsZT0iZm9udC1zaXplOjEyLjBwdDtiYWNrZ3JvdW5kOndoaXRl Ij5yZQ0KIHBsZWFzZWQgdG8gc2VlIGFkdmFuY2Ugc28gcXVpY2tseS48L3NwYW4+PHNwYW4gc3R5 bGU9ImZvbnQtc2l6ZToxMi4wcHQ7DQptc28taGFuc2ktZm9udC1mYW1pbHk6QXJpYWw7YmFja2dy b3VuZDp3aGl0ZSI+4oCdPC9zcGFuPjxzcGFuIHN0eWxlPSJmb250LXNpemU6DQoxMi4wcHQ7YmFj a2dyb3VuZDp3aGl0ZSI+PG86cD48L286cD48L3NwYW4+PC9wPg0KPHAgY2xhc3M9IkJvZHkiIHN0 eWxlPSJtYXJnaW4tYm90dG9tOiAxMXB0OyI+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZToxMi4wcHQ7 Zm9udC1mYW1pbHk6JnF1b3Q7QXJpYWwgQm9sZCZxdW90Ozttc28taGFuc2ktZm9udC1mYW1pbHk6 JnF1b3Q7QXJpYWwgVW5pY29kZSBNUyZxdW90OzsNCmJhY2tncm91bmQ6d2hpdGUiPlN1cHBvcnQg Zm9yIEFSTSBvbiBYZW4gUHJvamVjdCBBcmNoaXRlY3R1cmUgR3Jvd3MgUXVpY2tseQ0KPC9zcGFu PjxzcGFuIHN0eWxlPSJmb250LXNpemU6MTIuMHB0O2ZvbnQtZmFtaWx5OiZxdW90O0FyaWFsIEJv bGQmcXVvdDs7bXNvLWZhcmVhc3QtZm9udC1mYW1pbHk6JnF1b3Q7QXJpYWwgQm9sZCZxdW90OzsN Cm1zby1iaWRpLWZvbnQtZmFtaWx5OiZxdW90O0FyaWFsIEJvbGQmcXVvdDs7YmFja2dyb3VuZDp3 aGl0ZSI+PG86cD48L286cD48L3NwYW4+PC9wPg0KPHAgY2xhc3M9IkJvZHkiPjxzcGFuIHN0eWxl PSJmb250LXNpemU6MTIuMHB0Ow0KYmFja2dyb3VuZDp3aGl0ZSI+VGhlIG5ldyByZWxlYXNlIGlu dHJvZHVjZXMgc2lnbmlmaWNhbnQgc3RhYmlsaXR5LCB1c2FiaWxpdHkgYW5kIHBlcmZvcm1hbmNl IGltcHJvdmVtZW50cyBmb3IgdGhlIEFSTSBhcmNoaXRlY3R1cmUgYW5kIGV4dGVuZGVkIGhhcmR3 YXJlIGNvbXBhdGliaWxpdHkuJm5ic3A7IEFwcGxpZWRNaWNybzwvc3Bhbj48c3BhbiBsYW5nPSJG UiIgc3R5bGU9ImZvbnQtc2l6ZToxMi4wcHQ7bXNvLWhhbnNpLWZvbnQtZmFtaWx5OkFyaWFsO2Jh Y2tncm91bmQ6d2hpdGU7DQptc28tYW5zaS1sYW5ndWFnZTpGUiI+4oCZPC9zcGFuPjxzcGFuIHN0 eWxlPSJmb250LXNpemU6MTIuMHB0O2JhY2tncm91bmQ6d2hpdGUiPnMNCiBYLUdlbmUsIHRoZSBB cm5kYWxlIEJvYXJkLCBDYWx4ZWRhIEVDWC0yMDAwLCBUSSBPTUFQNSBhbmQgdGhlIEFsbHdpbm5l ciBTdW5YaSBib2FyZHMgYXJlIGFsbCBzdXBwb3J0ZWQuIFRoZSBzdWJzdGFudGlhbGx5IGltcHJv dmVkIG11bHRpcGxhdGZvcm0gY2FwYWJpbGl0aWVzIG9mIHRoZSBoeXBlcnZpc29yIGFsbG93IGhh cmR3YXJlIGFuZCBlbWJlZGRlZCB2ZW5kb3JzIHRvIHBvcnQgdGhlIFhlbiBQcm9qZWN0IHRlY2hu b2xvZ3kgdG8gbmV3IEFSTQ0KIFNvQ3MgZWFzaWx5LCBzaG9ydGVuaW5nIHRoZWlyIHRpbWUgdG8g bWFya2V0LjxvOnA+PC9vOnA+PC9zcGFuPjwvcD4NCjxwIGNsYXNzPSJCb2R5Ij48c3BhbiBzdHls ZT0iZm9udC1zaXplOjEyLjBwdDsNCmJhY2tncm91bmQ6d2hpdGUiPjxvOnA+Jm5ic3A7PC9vOnA+ PC9zcGFuPjwvcD4NCjxwIGNsYXNzPSJCb2R5Ij48c3BhbiBzdHlsZT0iZm9udC1zaXplOjEyLjBw dDsNCmJhY2tncm91bmQ6d2hpdGUiPkFkZGl0aW9uYWwgZW5oYW5jZW1lbnRzIGluIHRoaXMgcmVs ZWFzZSBpbmNsdWRlZCA2NC1iaXQgZ3Vlc3Qgc3VwcG9ydCBvbiBBUk12OCBwbGF0Zm9ybXMuIEFs bCB0aGUgdXNlcnNwYWNlIHRvb2xzLCBzdWNoIGFzIHRoZSB4bCBtYW5hZ2VtZW50IHRvb2wsIGFy ZSA2NC1iaXQgcmVhZHkgYW5kIGNhbiBiZSB1c2VkIHRvIGNyZWF0ZSA2NC1iaXQNCiB2aXJ0dWFs IG1hY2hpbmVzIG91dCBvZiB0aGUgYm94LjxvOnA+PC9vOnA+PC9zcGFuPjwvcD4NCjxwIGNsYXNz PSJCb2R5Ij48c3BhbiBzdHlsZT0iZm9udC1zaXplOjEyLjBwdDsNCmJhY2tncm91bmQ6d2hpdGUi PjxvOnA+Jm5ic3A7PC9vOnA+PC9zcGFuPjwvcD4NCjxwIGNsYXNzPSJCb2R5Ij48c3BhbiBzdHls ZT0iZm9udC1zaXplOjEyLjBwdDsNCmJhY2tncm91bmQ6d2hpdGUiPlRoZSBYZW4gUHJvamVjdCBo eXBlcmNhbGwgQUJJIGlzIG5vdyBzdGFibGUgYW5kIHdpbGwgYmUgbWFpbnRhaW5lZCBmb3IgYmFj a3dhcmQgY29tcGF0aWJpbGl0eSwgc28gdXNlcnMgY2FuIHRydXN0IGZ1dHVyZSByZWxlYXNlcyB0 byBib290IG9sZGVyIG9wZXJhdGluZyBzeXN0ZW1zLjwvc3Bhbj48c3BhbiBzdHlsZT0iZm9udC1z aXplOjEyLjBwdDtmb250LWZhbWlseToNCiZxdW90O0FyaWFsIEJvbGQmcXVvdDs7bXNvLWhhbnNp LWZvbnQtZmFtaWx5OiZxdW90O0FyaWFsIFVuaWNvZGUgTVMmcXVvdDs7YmFja2dyb3VuZDp3aGl0 ZSI+DQo8L3NwYW4+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZToxMi4wcHQ7Zm9udC1mYW1pbHk6JnF1 b3Q7QXJpYWwgQm9sZCZxdW90Ozttc28tZmFyZWFzdC1mb250LWZhbWlseTomcXVvdDtBcmlhbCBC b2xkJnF1b3Q7Ow0KbXNvLWJpZGktZm9udC1mYW1pbHk6JnF1b3Q7QXJpYWwgQm9sZCZxdW90Ozti YWNrZ3JvdW5kOndoaXRlIj48bzpwPjwvbzpwPjwvc3Bhbj48L3A+DQo8cCBjbGFzcz0iQm9keSI+ PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZToxMi4wcHQ7DQpiYWNrZ3JvdW5kOndoaXRlIj5BZGRpdGlv bmFsIGltcHJvdmVtZW50cyBpbmNsdWRlIGV4dGVuZGVkIHN1cHBvcnQgZm9yIEFSTSBzcGVjaWZp YyBib290bG9hZGVycyBhbmQgZmlybXdhcmUgaW50ZXJmYWNlcywgYW5kIHN1cHBvcnQgZm9yIHBo eXNpY2FsIHBhcnRpdGlvbnMgYW5kIExWTSB2b2x1bWVzIHRvIHN0b3JlIGRpc2tzIG9mIHZpcnR1 YWwgbWFjaGluZXMuDQo8bzpwPjwvbzpwPjwvc3Bhbj48L3A+DQo8cCBjbGFzcz0iQm9keSI+PHNw YW4gc3R5bGU9ImZvbnQtc2l6ZToxMi4wcHQ7DQpiYWNrZ3JvdW5kOndoaXRlIj48bzpwPiZuYnNw OzwvbzpwPjwvc3Bhbj48L3A+DQo8cCBjbGFzcz0iQm9keSIgc3R5bGU9Im1hcmdpbi1ib3R0b206 IDExcHQ7Ij48c3BhbiBzdHlsZT0iZm9udC1zaXplOjEyLjBwdDtmb250LWZhbWlseTomcXVvdDtB cmlhbCBCb2xkJnF1b3Q7O21zby1oYW5zaS1mb250LWZhbWlseTomcXVvdDtBcmlhbCBVbmljb2Rl IE1TJnF1b3Q7Ow0KYmFja2dyb3VuZDp3aGl0ZSI+SW1wcm92ZWQgRXZlbnQgQ2hhbm5lbCBTY2Fs YWJpbGl0eSBGb3IgQ2xvdWQgQ29tcHV0aW5nPC9zcGFuPjxzcGFuIHN0eWxlPSJmb250LXNpemU6 MTIuMHB0O2ZvbnQtZmFtaWx5OiZxdW90O0FyaWFsIEJvbGQmcXVvdDs7bXNvLWZhcmVhc3QtZm9u dC1mYW1pbHk6JnF1b3Q7QXJpYWwgQm9sZCZxdW90OzsNCm1zby1iaWRpLWZvbnQtZmFtaWx5OiZx dW90O0FyaWFsIEJvbGQmcXVvdDs7YmFja2dyb3VuZDp3aGl0ZSI+PG86cD48L286cD48L3NwYW4+ PC9wPg0KPHAgY2xhc3M9IkJvZHkiIHN0eWxlPSJtYXJnaW4tYm90dG9tOiAxMXB0OyI+PHNwYW4g c3R5bGU9ImZvbnQtc2l6ZToxMi4wcHQ7YmFja2dyb3VuZDp3aGl0ZSI+WGVuIFByb2plY3QgZGV2 ZWxvcGVycyBjb250aW51ZXMgdG8gZHJpdmUgaW5ub3ZhdGlvbiBhbmQgY29sbGFib3JhdGlvbiBh cm91bmQgc2VydmVyIHZpcnR1YWxpemF0aW9uIGFuZCB0aGUgY2xvdWQuIFBvd2VyaW5nIG1hbnkg b2YgdGhlIGxhcmdlc3QgY2xvdWRzIGluIHByb2R1Y3Rpb24NCiB0b2RheSwgaW5jbHVkaW5nIEFt YXpvbiBFQzIsIFJhY2tzcGFjZSBDbG91ZCBhbmQgb3RoZXJzLCB0aGUgY29tbXVuaXR5IHVuZGVy c3RhbmRzIHRoZSBuZWVkIHRvIHJ1biBtb3JlIHZpcnR1YWwgbWFjaGluZXMgb24gYSBzaW5nbGUg aG9zdC4NCjxvOnA+PC9vOnA+PC9zcGFuPjwvcD4NCjxwIGNsYXNzPSJCb2R5IiBzdHlsZT0ibWFy Z2luLWJvdHRvbTogMTFwdDsiPjxzcGFuIHN0eWxlPSJmb250LXNpemU6MTIuMHB0O2JhY2tncm91 bmQ6d2hpdGUiPllldCBkZW1hbmRzIG9uIGh5cGVydmlzb3Igc2NhbGFiaWxpdHkgY29udGludWUg dG8gaW5jcmVhc2UsIGJvdGggZnJvbSBsYXJnZXIgbWFjaGluZXMsIG5ldyB3b3JrbG9hZHMgc3Vj aCBhcyB2aXJ0dWFsaXphdGlvbiBkZXNrdG9wIGluZnJhc3RydWN0dXJlcyAoVkRJKSBhbmQgbmV3 IGNsb3VkDQogT1MgdGVjaG5vbG9naWVzLCBpbmNsdWRpbmcgTWlyYWdlT1MsIEVybGFuZ09uWGVu LCBPU3YsIGFuZCBIYWxWTS4gUmVjb2duaXppbmcgdGhhdCBoaWdoLWF2YWlsYWJpbGl0eSBhbmQg c3RhYmlsaXR5IGFyZSBjcml0aWNhbCB0byBWRElzIGFuZCBjbG91ZCBkZXBsb3ltZW50czsgdGhl IFhlblNlcnZlciB0ZWFtIGF0IENpdHJpeCBjb250cmlidXRlZCB0aGUgbmV3IGV2ZW50IGNoYW5u ZWwgaW1wbGVtZW50YXRpb24gdG8gdGhlIFhlbiBQcm9qZWN0Lg0KIFRvIGhlbHAgZWxpbWluYXRl IHdvcmtsb2FkIGxpbWl0YXRpb25zIGZvciB1c2VycywgdGhpcyBlbmFibGVzIHRoZSBoeXBlcnZp c29yIHRvIHJ1biB0aG91c2FuZHMgb2YgZ3Vlc3RzIG9uIGEgc2luZ2xlIHBoeXNpY2FsIG1hY2hp bmUuJm5ic3A7Jm5ic3A7Jm5ic3A7DQo8bzpwPjwvbzpwPjwvc3Bhbj48L3A+DQo8cCBjbGFzcz0i Qm9keSIgc3R5bGU9Im1hcmdpbi1ib3R0b206IDExcHQ7Ij48c3BhbiBzdHlsZT0iZm9udC1zaXpl OjEyLjBwdDtmb250LWZhbWlseTomcXVvdDtBcmlhbCBCb2xkJnF1b3Q7O21zby1oYW5zaS1mb250 LWZhbWlseTomcXVvdDtBcmlhbCBVbmljb2RlIE1TJnF1b3Q7Ow0KYmFja2dyb3VuZDp3aGl0ZSI+ RXhwZXJpbWVudGFsIFN1cHBvcnQgZm9yIFBWSCBNb2RlIGZvciBHdWVzdA0KPC9zcGFuPjxzcGFu IHN0eWxlPSJmb250LXNpemU6MTIuMHB0O2ZvbnQtZmFtaWx5OiZxdW90O0FyaWFsIEJvbGQmcXVv dDs7bXNvLWZhcmVhc3QtZm9udC1mYW1pbHk6JnF1b3Q7QXJpYWwgQm9sZCZxdW90OzsNCm1zby1i aWRpLWZvbnQtZmFtaWx5OiZxdW90O0FyaWFsIEJvbGQmcXVvdDs7YmFja2dyb3VuZDp3aGl0ZSI+ PG86cD48L286cD48L3NwYW4+PC9wPg0KPHAgY2xhc3M9IkJvZHkiIHN0eWxlPSJtYXJnaW4tYm90 dG9tOiAxMXB0OyI+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZToxMi4wcHQ7YmFja2dyb3VuZDp3aGl0 ZSI+T3JhY2xlIGhhcyBjb250cmlidXRlZCBhIGZ1bmN0aW9uYWwgcHJldmlldyBvZiBhDQo8L3Nw YW4+PGEgaHJlZj0iaHR0cDovL2Jsb2cueGVuLm9yZy9pbmRleC5waHAvMjAxNC8wMS8zMS9saW51 eC0zLTE0LWFuZC1wdmgvIj48c3BhbiBjbGFzcz0iSHlwZXJsaW5rMCI+PHNwYW4gc3R5bGU9ImZv bnQtc2l6ZToxMi4wcHQ7Y29sb3I6YmxhY2siPm5ldyB2aXJ0dWFsaXphdGlvbiBtb2RlIGNhbGxl ZCBQVkggY3VycmVudGx5IGF2YWlsYWJsZSB0byB2aXJ0dWFsaXplZCBndWVzdHMuDQo8L3NwYW4+ PC9zcGFuPjwvYT48c3BhbiBzdHlsZT0iZm9udC1zaXplOjEyLjBwdDtiYWNrZ3JvdW5kOndoaXRl Ij5QVkggaXMgYW4gZXh0ZW5zaW9uIHRvIHRoZSBjbGFzc2ljIFhlbiBQcm9qZWN0IFBhcmF2aXJ0 dWFsaXphdGlvbiAoUFYpIHRoYXQgdXNlcyB0aGUgaGFyZHdhcmUgdmlydHVhbGl6YXRpb24gZXh0 ZW5zaW9ucyBhdmFpbGFibGUgb24gbW9kZXJuIHg4NiBwcm9jZXNzb3JzLiBQVkggdXNlcyBQViBk cml2ZXJzIGZvciBib290IGFuZCBJL08NCiBhbmQgSW50ZWwgaGFyZHdhcmUgdmlydHVhbGl6YXRp b24gZXh0ZW5zaW9ucyBmb3IgcGFnZSB0YWJsZSBvcGVyYXRpb25zLCBzeXN0ZW0gY2FsbHMgYW5k IG90aGVyIHByaXZpbGVnZWQgb3BlcmF0aW9ucy4gVGhpcyBub3Qgb25seSBpbXByb3ZlcyBwZXJm b3JtYW5jZSBhbmQgc2VjdXJpdHksIGJ1dCBhbHNvIHNpbXBsaWZpZXMgdGhlIGFyY2hpdGVjdHVy ZSBhbmQgWGVuIFByb2plY3QgSHlwZXJ2aXNvci1MaW51eCBpbnRlcmZhY2Ugc2lnbmlmaWNhbnRs eS4NCjxvOnA+PC9vOnA+PC9zcGFuPjwvcD4NCjxwIGNsYXNzPSJIZWFkaW5nIiBzdHlsZT0ibGlu ZS1oZWlnaHQ6MTA4JSI+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZToxMi4wcHQ7DQpsaW5lLWhlaWdo dDoxMDglO21zby1oYW5zaS1mb250LWZhbWlseTomcXVvdDtUcmVidWNoZXQgTVMmcXVvdDs7YmFj a2dyb3VuZDp3aGl0ZSI+4oCcPC9zcGFuPjxzcGFuIHN0eWxlPSJmb250LXNpemU6MTIuMHB0O2xp bmUtaGVpZ2h0OjEwOCU7Zm9udC1mYW1pbHk6QXJpYWw7bXNvLWhhbnNpLWZvbnQtZmFtaWx5Og0K JnF1b3Q7QXJpYWwgVW5pY29kZSBNUyZxdW90OztiYWNrZ3JvdW5kOndoaXRlIj5QVkgNCiBpcyBh IG1ham9yIGRldmVsb3BtZW50IGZvciBYZW4gUHJvamVjdCBzb2Z0d2FyZSBvbiB4ODYgYW5kIGhh cyB0aGUgcG90ZW50aWFsIHRvIGdyZWF0bHkgc2ltcGxpZnkgdGhlIExpbnV4IGludGVyZmFjZSBp biBkdWUgdGltZSwNCjwvc3Bhbj48c3BhbiBzdHlsZT0iZm9udC1zaXplOjEyLjBwdDtsaW5lLWhl aWdodDoxMDglO21zby1oYW5zaS1mb250LWZhbWlseToNCiZxdW90O1RyZWJ1Y2hldCBNUyZxdW90 OztiYWNrZ3JvdW5kOndoaXRlIj7igJwNCjwvc3Bhbj48c3BhbiBzdHlsZT0iZm9udC1zaXplOjEy LjBwdDsNCmxpbmUtaGVpZ2h0OjEwOCU7Zm9udC1mYW1pbHk6QXJpYWw7bXNvLWhhbnNpLWZvbnQt ZmFtaWx5OiZxdW90O0FyaWFsIFVuaWNvZGUgTVMmcXVvdDs7DQpiYWNrZ3JvdW5kOndoaXRlIj5z YWlkIEtvbnJhZCBSemVzenV0ZWsgV2lsaywgU29mdHdhcmUgRGV2ZWxvcG1lbnQgTWFuYWdlciBh dCBPcmFjbGUsIGEgWGVuIFByb2plY3QgYWR2aXNvcnkgYm9hcmQgbWVtYmVyLg0KPC9zcGFuPjxz cGFuIHN0eWxlPSJmb250LXNpemU6DQoxMi4wcHQ7bGluZS1oZWlnaHQ6MTA4JTttc28taGFuc2kt Zm9udC1mYW1pbHk6JnF1b3Q7VHJlYnVjaGV0IE1TJnF1b3Q7O2JhY2tncm91bmQ6d2hpdGUiPuKA nDwvc3Bhbj48c3BhbiBzdHlsZT0iZm9udC1zaXplOjEyLjBwdDtsaW5lLWhlaWdodDoxMDglO2Zv bnQtZmFtaWx5OkFyaWFsO21zby1oYW5zaS1mb250LWZhbWlseToNCiZxdW90O0FyaWFsIFVuaWNv ZGUgTVMmcXVvdDs7YmFja2dyb3VuZDp3aGl0ZSI+V2UgZXhwZWN0IFBWSA0KIHRvIGhhdmUgdGhl IGJlc3QgY2hhcmFjdGVyaXN0aWNzIG9mIGFsbCB2aXJ0dWFsaXphdGlvbiBtb2RlcyAtLSBhIHNp bXBsZSwgZmFzdCwgc2VjdXJlIGludGVyZmFjZSwgd2l0aCBsb3cgbWVtb3J5IG92ZXJoZWFkLCB0 aGF0IGFsc28gdGFrZXMgZnVsbCBhZHZhbnRhZ2Ugb2YgdGhlIGxhdGVzdCBoYXJkd2FyZS48L3Nw YW4+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZToxMi4wcHQ7bGluZS1oZWlnaHQ6MTA4JTsNCm1zby1o YW5zaS1mb250LWZhbWlseTomcXVvdDtUcmVidWNoZXQgTVMmcXVvdDs7YmFja2dyb3VuZDp3aGl0 ZSI+4oCdPC9zcGFuPjxzcGFuIHN0eWxlPSJmb250LXNpemU6MTIuMHB0O2xpbmUtaGVpZ2h0OjEw OCU7Zm9udC1mYW1pbHk6QXJpYWw7bXNvLWZhcmVhc3QtZm9udC1mYW1pbHk6DQpBcmlhbDttc28t YmlkaS1mb250LWZhbWlseTpBcmlhbDtiYWNrZ3JvdW5kOndoaXRlIj48bzpwPjwvbzpwPjwvc3Bh bj48L3A+DQo8cCBjbGFzcz0iQm9keSI+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZToxMi4wcHQ7bGlu ZS1oZWlnaHQ6MTE1JTtiYWNrZ3JvdW5kOndoaXRlIj48bzpwPiZuYnNwOzwvbzpwPjwvc3Bhbj48 L3A+DQo8cCBjbGFzcz0iQm9keSIgc3R5bGU9Im1hcmdpbi1ib3R0b206IDExcHQ7Ij48c3BhbiBz dHlsZT0iZm9udC1zaXplOjEyLjBwdDtiYWNrZ3JvdW5kOndoaXRlIj5BZGRpdGlvbmFsIGtleSB1 cGRhdGVzIGluY2x1ZGU6PG86cD48L286cD48L3NwYW4+PC9wPg0KPHAgY2xhc3M9IkJvZHkiIHN0 eWxlPSJtYXJnaW46IDBpbiAwaW4gMTFwdCAzNC41cHQ7IHRleHQtaW5kZW50OiAtMTYuNDVwdDsi PjwhLS1baWYgIXN1cHBvcnRMaXN0c10tLT7ilqA8c3BhbiBzdHlsZT0iZm9udC1zaXplOiA3cHQ7 IGZvbnQtZmFtaWx5OiAnVGltZXMgTmV3IFJvbWFuJzsiPiZuYnNwOyZuYnNwOyZuYnNwOyZuYnNw Ow0KPC9zcGFuPjwhLS1bZW5kaWZdLS0+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZToxMi4wcHQ7YmFj a2dyb3VuZDp3aGl0ZSI+QmV0dGVyIHBlcmZvcm1hbmNlIHdpdGggbW9kZXJuIHN0b3JhZ2UgZGV2 aWNlcyBhbmQgYmlnIGRhdGEgLS0gSW5kaXJlY3QgZGVzY3JpcHRvcnMgZm9yIGJsb2NrIFBWIHBy b3RvY29sIChMaW51eCkgYWxsb3cgZWFjaCBpbmRpdmlkdWFsIHJlcXVlc3QgdG8gdHJpcGxlIGlu IHNpemUsIGdyZWF0bHkgaW1wcm92aW5nIEkvTyBwZXJmb3JtYW5jZQ0KIHdoZW4gcnVubmluZyBv biBmYXN0IHN0b3JhZ2UgdGVjaG5vbG9naWVzIHN1Y2ggYXMgc29saWQtc3RhdGUgZHJpdmUgYW5k IFJBSUQuIEF2YWlsYWJsZSBpbiBhbnkgZ3Vlc3QgcnVubmluZyBMaW51eCAzLjExIG9yIGhpZ2hl ciAocmVnYXJkbGVzcyBvZiBYZW4gUHJvamVjdCB2ZXJzaW9uKS48L3NwYW4+PHNwYW4gc3R5bGU9 ImJhY2tncm91bmQ6d2hpdGUiPjxvOnA+PC9vOnA+PC9zcGFuPjwvcD4NCjxwIGNsYXNzPSJCb2R5 IiBzdHlsZT0ibWFyZ2luLWJvdHRvbTogMTFwdDsiPjxzcGFuIHN0eWxlPSJmb250LXNpemU6MTIu MHB0O2JhY2tncm91bmQ6d2hpdGUiPjxvOnA+Jm5ic3A7PC9vOnA+PC9zcGFuPjwvcD4NCjxwIGNs YXNzPSJCb2R5IiBzdHlsZT0ibWFyZ2luOiAwaW4gMGluIDExcHQgMzQuNXB0OyB0ZXh0LWluZGVu dDogLTE2LjQ1cHQ7Ij48IS0tW2lmICFzdXBwb3J0TGlzdHNdLS0+4pagPHNwYW4gc3R5bGU9ImZv bnQtc2l6ZTogN3B0OyBmb250LWZhbWlseTogJ1RpbWVzIE5ldyBSb21hbic7Ij4mbmJzcDsmbmJz cDsmbmJzcDsmbmJzcDsNCjwvc3Bhbj48IS0tW2VuZGlmXS0tPjxzcGFuIHN0eWxlPSJmb250LXNp emU6MTIuMHB0O2JhY2tncm91bmQ6d2hpdGUiPk1vcmUgcG93ZXJmdWwgZHJpdmVyIGRvbWFpbnMg LS0NCjwvc3Bhbj48c3BhbiBzdHlsZT0iZm9udC1zaXplOjEyLjBwdDtjb2xvcjojMjIyMjIyO2Jh Y2tncm91bmQ6d2hpdGUiPkRpc2sgZHJpdmVyIGRvbWFpbnMgY2FuIG5vdyB1bmlmb3JtbHkgcnVu IGJsb2NrIHNjcmlwdHMgYW5kIHVzZXItc3BhY2UgYmFja2VuZHMsIHN1Y2ggYXMgcWRpc2ssIGJy aW5naW5nIHRoZW0gdXAgdG8gZmVhdHVyZSBwYXJpdHkgd2l0aCBkb21haW4gMC4gVGhpcyBtZWFu cyBob3N0IGFkbWluaXN0cmF0b3JzIGNhbiB0YWtlIGFkdmFudGFnZQ0KIG9mIHRoZSBlbmhhbmNl ZCBzZWN1cml0eSwgc2NhbGFiaWxpdHksIGFuZCByb2J1c3RuZXNzIHByb3ZpZGVkIGJ5IGRyaXZl ciBkb21haW5zIHdpdGhvdXQgc2FjcmlmaWNpbmcgdGhlIHdpZGUgYXJyYXkgb2YgZGlzayBjb25m aWd1cmF0aW9uIG9wdGlvbnMgcHJvdmlkZWQgYnkgWGVuIGluIGRvbTAuPC9zcGFuPjxzcGFuIHN0 eWxlPSJiYWNrZ3JvdW5kOg0Kd2hpdGUiPjxvOnA+PC9vOnA+PC9zcGFuPjwvcD4NCjxwIGNsYXNz PSJCb2R5IiBzdHlsZT0ibWFyZ2luOiAwaW4gMGluIDExcHQgMzQuNXB0OyB0ZXh0LWluZGVudDog LTE2LjQ1cHQ7Ij48IS0tW2lmICFzdXBwb3J0TGlzdHNdLS0+4pagPHNwYW4gc3R5bGU9ImZvbnQt c2l6ZTogN3B0OyBmb250LWZhbWlseTogJ1RpbWVzIE5ldyBSb21hbic7Ij4mbmJzcDsmbmJzcDsm bmJzcDsmbmJzcDsNCjwvc3Bhbj48IS0tW2VuZGlmXS0tPjxzcGFuIHN0eWxlPSJmb250LXNpemU6 MTIuMHB0O2JhY2tncm91bmQ6d2hpdGUiPk5ldyBTUElDRSBwcm90b2NvbCBzdXBwb3J0IC0tIEZ1 bmN0aW9uYWxpdHkgc3VjaCBhcyBjbGlwYm9hcmQgc2hhcmluZyBhbmQgVVNCIHJlZGlyZWN0aW9u IGNyZWF0ZXMgYSBtdWNoIHJpY2hlciBjb25uZWN0aW9uIGZvciB2aXJ0dWFsIGRlc2t0b3BzIGFu ZCBiZXR0ZXIgZ3JhcGhpY3MgcGVyZm9ybWFuY2UuDQo8L3NwYW4+PHNwYW4gc3R5bGU9ImJhY2tn cm91bmQ6d2hpdGUiPjxvOnA+PC9vOnA+PC9zcGFuPjwvcD4NCjxwIGNsYXNzPSJCb2R5IiBzdHls ZT0ibWFyZ2luOiAwaW4gMGluIDExcHQgMzQuNXB0OyB0ZXh0LWluZGVudDogLTE2LjQ1cHQ7Ij48 IS0tW2lmICFzdXBwb3J0TGlzdHNdLS0+4pagPHNwYW4gc3R5bGU9ImZvbnQtc2l6ZTogN3B0OyBm b250LWZhbWlseTogJ1RpbWVzIE5ldyBSb21hbic7Ij4mbmJzcDsmbmJzcDsmbmJzcDsmbmJzcDsN Cjwvc3Bhbj48IS0tW2VuZGlmXS0tPjxzcGFuIHN0eWxlPSJmb250LXNpemU6MTIuMHB0O2JhY2tn cm91bmQ6d2hpdGUiPkVuaGFuY2VkIGRpYWdub3N0aWNzIGFuZCBrZXhlYyBkZWJ1ZyBzdXBwb3J0 IC0tIFdoZW4gYSBjcmFzaCBoYXBwZW5zLCBhIHNwZWNpYWwga2VybmVsIGlzIGFsbG93ZWQgaW1t ZWRpYXRlIHRvIGNvbGxlY3QgaW5mb3JtYXRpb24gYWJvdXQgdGhlIHJvb3QgY2F1c2UsIG9mZmVy aW5nIGRldmVsb3BlcnMgYmV0dGVyIGRpYWdub3Npcw0KIGFuZCByZXBhaXIgYWJpbGl0aWVzLiA8 L3NwYW4+PHNwYW4gc3R5bGU9ImJhY2tncm91bmQ6d2hpdGUiPjxvOnA+PC9vOnA+PC9zcGFuPjwv cD4NCjxwIGNsYXNzPSJCb2R5Ij48c3BhbiBzdHlsZT0iZm9udC1zaXplOjEyLjBwdCI+VGhlIDQu NCByZWxlYXNlIGlzIHRoZSByZXN1bHQgb2YgYSBicm9hZCwgY29sbGFib3JhdGl2ZSBkZXZlbG9w bWVudCBlZmZvcnQgcmVwcmVzZW50aW5nIGVuZ2luZWVycyBmcm9tIG1vcmUgdGhhbiAxMyBsZWFk aW5nIGhhcmR3YXJlLCBzb2Z0d2FyZSBhbmQgc2VjdXJpdHkgdmVuZG9ycy4gVG9wIGNvbnRyaWJ1 dG9ycyBpbmNsdWRlIEFtYXpvbiwgQU1ELCBBbmFsb2cNCiBEZXZpY2VzLCBCcm9hZGNvbSwgQ2l0 cml4LCBGdWppdHN1LCBJbnRlbCwgTGluYXJvLCBOU0EsIE9yYWNsZSwgU3VzZSwgVmVyaXpvbi9U ZXJyZW1hcmssIHBsdXMgbnVtZXJvdXMgaW5kaXZpZHVhbCBhbmQgYWNhZGVtaWMgY29udHJpYnV0 b3JzLiBUaGUgZnJlZWx5IGF2YWlsYWJsZSBkb3dubG9hZCBjYW4gYmUgZm91bmQgb24gdGhlDQo8 YSBocmVmPSJodHRwOi8vWGVuUHJvamVjdC5vcmciPlhlblByb2plY3Qub3JnPC9hPiB3ZWJzaXRl IChpbnNlcnQgdXJsKS48bzpwPjwvbzpwPjwvc3Bhbj48L3A+DQo8cCBjbGFzcz0iQm9keSI+PHNw YW4gc3R5bGU9ImZvbnQtc2l6ZToxMi4wcHQiPiZuYnNwOzwvc3Bhbj48L3A+DQo8cCBjbGFzcz0i Qm9keSIgc3R5bGU9Im1hcmdpbi1ib3R0b206IDExcHQ7Ij48dT48c3BhbiBzdHlsZT0iZm9udC1z aXplOjEyLjBwdDtmb250LWZhbWlseTomcXVvdDtBcmlhbCBCb2xkJnF1b3Q7O21zby1oYW5zaS1m b250LWZhbWlseTomcXVvdDtBcmlhbCBVbmljb2RlIE1TJnF1b3Q7Ow0KYmFja2dyb3VuZDp3aGl0 ZSI+QWJvdXQgWGVuIFByb2plY3Q8L3NwYW4+PC91Pjx1PjxzcGFuIHN0eWxlPSJmb250LXNpemU6 MTIuMHB0Ow0KZm9udC1mYW1pbHk6JnF1b3Q7QXJpYWwgQm9sZCZxdW90Ozttc28tZmFyZWFzdC1m b250LWZhbWlseTomcXVvdDtBcmlhbCBCb2xkJnF1b3Q7O21zby1iaWRpLWZvbnQtZmFtaWx5Og0K JnF1b3Q7QXJpYWwgQm9sZCZxdW90OztiYWNrZ3JvdW5kOndoaXRlIj48bzpwPjwvbzpwPjwvc3Bh bj48L3U+PC9wPg0KPHAgY2xhc3M9IkJvZHkiIHN0eWxlPSJtYXJnaW4tYm90dG9tOiAxMXB0OyI+ PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZToxMi4wcHQ7YmFja2dyb3VuZDp3aGl0ZSI+VGhlIFhlbiBQ cm9qZWN0IHNvZnR3YXJlIGlzIGFuIG9wZW4gc291cmNlIHZpcnR1YWxpemF0aW9uIHBsYXRmb3Jt IGxpY2Vuc2VkIHVuZGVyIHRoZSBHUEx2MiB3aXRoIGEgc2ltaWxhciBnb3Zlcm5hbmNlIHN0cnVj dHVyZSB0byB0aGUgTGludXgga2VybmVsLiBEZXNpZ25lZCBmcm9tIHRoZQ0KIHN0YXJ0IGZvciBj bG91ZCBjb21wdXRpbmcsIHRoZSBQcm9qZWN0IGhhcyBtb3JlIHRoYW4gYSBkZWNhZGUgb2YgZGV2 ZWxvcG1lbnQgYW5kIGlzIGJlaW5nIHVzZWQgYnkgbW9yZSB0aGFuIDEwIG1pbGxpb24gdXNlcnMu IEEgQ29sbGFib3JhdGl2ZSBQcm9qZWN0IGF0IFRoZSBMaW51eCBGb3VuZGF0aW9uLCB0aGUgWGVu IFByb2plY3QgdGVhbSBpcyBmb2N1c2VkIG9uIGFkdmFuY2luZyB2aXJ0dWFsaXphdGlvbiBpbiBh IG51bWJlciBvZiBkaWZmZXJlbnQNCiBjb21tZXJjaWFsIGFuZCBvcGVuIHNvdXJjZSBhcHBsaWNh dGlvbnMgaW5jbHVkaW5nIHNlcnZlciB2aXJ0dWFsaXphdGlvbiwgSW5mcmFzdHJ1Y3R1cmUgYXMg YSBTZXJ2aWNlIChJYWFTKSwgZGVza3RvcCB2aXJ0dWFsaXphdGlvbiwgc2VjdXJpdHkgYXBwbGlj YXRpb25zLCBlbWJlZGRlZCBhbmQgaGFyZHdhcmUgYXBwbGlhbmNlcy4gSXQgY291bnRzIG1hbnkg aW5kdXN0cnkgYW5kIG9wZW4gc291cmNlIGNvbW11bml0eSBsZWFkZXJzIGFtb25nIGl0cw0KIG1l bWJlcnMgaW5jbHVkaW5nOiBBbWF6b24gV2ViIFNlcnZpY2VzLCBBTUQsIEFSTSwgQnJvbWl1bSwg Q2FseGVkYSwgQ0EgVGVjaG5vbG9naWVzLCBDaXNjbywgQ2l0cml4LCBHb29nbGUsIEludGVsLCBP cmFjbGUsIFNhbXN1bmcgYW5kIFZlcml6b24uIEZvciBtb3JlIGluZm9ybWF0aW9uIGFib3V0IHRo ZSBYZW4gUHJvamVjdCBoeXBlcnZpc29yIGFuZCB0byBwYXJ0aWNpcGF0ZSwgcGxlYXNlIHZpc2l0 DQo8L3NwYW4+PGEgaHJlZj0iaHR0cDovL3hlbnByb2plY3Qub3JnLyI+PHNwYW4gY2xhc3M9Ikh5 cGVybGluazEiPjxzcGFuIHN0eWxlPSJmb250LXNpemU6DQoxMi4wcHQ7Y29sb3I6YmxhY2s7dGV4 dC1kZWNvcmF0aW9uOm5vbmU7dGV4dC11bmRlcmxpbmU6bm9uZSI+aHR0cDovL3hlbnByb2plY3Qu PC9zcGFuPjwvc3Bhbj48L2E+PGEgaHJlZj0iaHR0cDovL3hlbnByb2plY3Qub3JnLyI+PHNwYW4g Y2xhc3M9Ikh5cGVybGluazEiPjxzcGFuIHN0eWxlPSJmb250LXNpemU6DQoxMi4wcHQ7Y29sb3I6 YmxhY2s7dGV4dC1kZWNvcmF0aW9uOm5vbmU7dGV4dC11bmRlcmxpbmU6bm9uZSI+b3JnPC9zcGFu Pjwvc3Bhbj48L2E+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZToxMi4wcHQ7YmFja2dyb3VuZDp3aGl0 ZSI+LjxvOnA+PC9vOnA+PC9zcGFuPjwvcD4NCjxwIGNsYXNzPSJCb2R5IiBhbGlnbj0iY2VudGVy IiBzdHlsZT0ibWFyZ2luLWJvdHRvbToxMS4wcHQ7dGV4dC1hbGlnbjpjZW50ZXIiPjxzcGFuIHN0 eWxlPSJmb250LXNpemU6MTIuMHB0O2xpbmUtaGVpZ2h0OjExNSU7YmFja2dyb3VuZDp3aGl0ZSI+ IyMjPG86cD48L286cD48L3NwYW4+PC9wPg0KPHAgY2xhc3M9IkJvZHkiIHN0eWxlPSJtYXJnaW4t Ym90dG9tOiAxMXB0OyI+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZToxMi4wcHQ7YmFja2dyb3VuZDp3 aGl0ZSI+U2FyYWggQ29ud2F5DQo8bzpwPjwvbzpwPjwvc3Bhbj48L3A+DQo8cCBjbGFzcz0iQm9k eSIgc3R5bGU9Im1hcmdpbi1ib3R0b206IDExcHQ7Ij48c3BhbiBzdHlsZT0iZm9udC1zaXplOjEy LjBwdDtiYWNrZ3JvdW5kOndoaXRlIj5UaGUgWGVuIFByb2plY3Q8bzpwPjwvbzpwPjwvc3Bhbj48 L3A+DQo8cCBjbGFzcz0iQm9keSIgc3R5bGU9Im1hcmdpbi1ib3R0b206IDExcHQ7Ij48c3BhbiBz dHlsZT0iZm9udC1zaXplOjEyLjBwdDtiYWNrZ3JvdW5kOndoaXRlIj5NZWRpYSBDb250YWN0PG86 cD48L286cD48L3NwYW4+PC9wPg0KPHAgY2xhc3M9IkJvZHkiIHN0eWxlPSJtYXJnaW4tYm90dG9t OiAxMXB0OyI+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZToxMi4wcHQ7YmFja2dyb3VuZDp3aGl0ZSI+ PGEgaHJlZj0ibWFpbHRvOnB1YmxpY2l0eUBsaXN0cy54ZW5wcm9qZWN0Lm9yZyI+cHVibGljaXR5 QGxpc3RzLnhlbnByb2plY3Qub3JnPC9hPjxvOnA+PC9vOnA+PC9zcGFuPjwvcD4NCjwhLS1FbmRG cmFnbWVudC0tPjwvZGl2Pg0KPGRpdj48YnI+DQo8L2Rpdj4NCjxkaXY+PGJyPg0KPGRpdj4NCjxk aXY+T24gTWFyIDYsIDIwMTQsIGF0IDEyOjQ0IFBNLCBXaWxzb24sIE1hdHQgJmx0OzxhIGhyZWY9 Im1haWx0bzptc3dAYW1hem9uLmNvbSI+bXN3QGFtYXpvbi5jb208L2E+Jmd0OyB3cm90ZTo8L2Rp dj4NCjxiciBjbGFzcz0iQXBwbGUtaW50ZXJjaGFuZ2UtbmV3bGluZSI+DQo8YmxvY2txdW90ZSB0 eXBlPSJjaXRlIj4NCjxkaXYgZnBzdHlsZT0iMSIgb2NzaT0iMCIgc3R5bGU9ImZvbnQtZmFtaWx5 OiBIZWx2ZXRpY2E7IGZvbnQtc2l6ZTogMTJweDsgZm9udC1zdHlsZTogbm9ybWFsOyBmb250LXZh cmlhbnQ6IG5vcm1hbDsgZm9udC13ZWlnaHQ6IG5vcm1hbDsgbGV0dGVyLXNwYWNpbmc6IG5vcm1h bDsgbGluZS1oZWlnaHQ6IG5vcm1hbDsgb3JwaGFuczogYXV0bzsgdGV4dC1hbGlnbjogc3RhcnQ7 IHRleHQtaW5kZW50OiAwcHg7IHRleHQtdHJhbnNmb3JtOiBub25lOyB3aGl0ZS1zcGFjZTogbm9y bWFsOyB3aWRvd3M6IGF1dG87IHdvcmQtc3BhY2luZzogMHB4OyAtd2Via2l0LXRleHQtc3Ryb2tl LXdpZHRoOiAwcHg7Ij4NCjxkaXYgc3R5bGU9ImRpcmVjdGlvbjogbHRyOyBmb250LWZhbWlseTog VmVyZGFuYTsgZm9udC1zaXplOiAxMHB0OyI+TWFyaywgdGhvdWdodHM/DQo8ZGl2Pjxicj4NCjwv ZGl2Pg0KPGRpdj4NCjxkaXYgc3R5bGU9ImZvbnQtZmFtaWx5OiAnVGltZXMgTmV3IFJvbWFuJzsg Zm9udC1zaXplOiAxNnB4OyI+DQo8aHIgdGFiaW5kZXg9Ii0xIj4NCjxkaXYgaWQ9ImRpdlJwRjk3 NjgzMCIgc3R5bGU9ImRpcmVjdGlvbjogbHRyOyI+PGZvbnQgZmFjZT0iVGFob21hIiBzaXplPSIy Ij48Yj5Gcm9tOjwvYj48c3BhbiBjbGFzcz0iQXBwbGUtY29udmVydGVkLXNwYWNlIj4mbmJzcDs8 L3NwYW4+V2lsc29uLCBNYXR0PGJyPg0KPGI+U2VudDo8L2I+PHNwYW4gY2xhc3M9IkFwcGxlLWNv bnZlcnRlZC1zcGFjZSI+Jm5ic3A7PC9zcGFuPldlZG5lc2RheSwgTWFyY2ggMDUsIDIwMTQgMTA6 MDEgQU08YnI+DQo8Yj5Ubzo8L2I+PHNwYW4gY2xhc3M9IkFwcGxlLWNvbnZlcnRlZC1zcGFjZSI+ Jm5ic3A7PC9zcGFuPkFkdmlzb3J5LWJvYXJkIGRpc2N1c3Npb25zPGJyPg0KPGI+U3ViamVjdDo8 L2I+PHNwYW4gY2xhc3M9IkFwcGxlLWNvbnZlcnRlZC1zcGFjZSI+Jm5ic3A7PC9zcGFuPlJFOiBb QWR2aXNvcnktYm9hcmRdIFhlbiBQcm9qZWN0IDQuNCBSZWxlYXNlPGJyPg0KPC9mb250Pjxicj4N CjwvZGl2Pg0KPGRpdj48L2Rpdj4NCjxkaXY+DQo8ZGl2IHN0eWxlPSJkaXJlY3Rpb246IGx0cjsg Zm9udC1mYW1pbHk6IFZlcmRhbmE7IGZvbnQtc2l6ZTogMTBwdDsiPkknZCByYXRoZXIgdXNlICZx dW90O1hlbiBQcm9qZWN0IEh5cGVydmlzb3ImcXVvdDsgdGhhbiBpbnRyb2R1Y2UgYW4gYWNyb255 bS4gSSB0aGluayBpdCdzIGltcG9ydGFudCB0aGF0ICZxdW90O1hlbiBQcm9qZWN0JnF1b3Q7IG5v dCBiZSBzcGxpdCBmcm9tICZxdW90O0h5cGVydmlzb3IuJnF1b3Q7DQo8ZGl2Pjxicj4NClRoaXMg c3RpbGwgZG9lc24ndCBhZGRyZXNzIGhvdyB0aGUgdW1icmVsbGEgcHJvamVjdCBpcyBjYWxsZWQu IFRoaXMgbmV3IHJlbGVhc2UgZG9lc24ndCBvbmx5IGluY2x1ZGUgdGhlIGh5cGVydmlzb3IsIGJ1 dCBhbHNvIHRoZSBhc3NvY2lhdGVkIHRvb2xzdGFjayBhbmQgdXRpbGl0aWVzLiBNYXliZSB3ZSdy ZSBPSyBjYWxsaW5nIGFsbCBvZiB0aGF0IHRoZSAmcXVvdDtIeXBlcnZpc29yLCZxdW90OyBldmVu IGlmIHdlIGlkZW50aWZ5IHRoZSBkZXZlbG9wbWVudCB0ZWFtcw0KIGRpZmZlcmVudGx5LjwvZGl2 Pg0KPGRpdj48YnI+DQo8L2Rpdj4NCjxkaXY+SG93IHNob3VsZCB3ZSByZS1hbGlnbiBhbGwgb2Yg dGhlIGJyYW5kaW5nPyBGb3IgZXhhbXBsZTombmJzcDs8YSBocmVmPSJodHRwOi8veGVucHJvamVj dC5vcmcvZGV2ZWxvcGVycy90ZWFtcy9oeXBlcnZpc29yLmh0bWwiIHRhcmdldD0iX2JsYW5rIiBz dHlsZT0iZm9udC1zaXplOiAxMHB0OyI+aHR0cDovL3hlbnByb2plY3Qub3JnL2RldmVsb3BlcnMv dGVhbXMvaHlwZXJ2aXNvci5odG1sPC9hPjwvZGl2Pg0KPGRpdj48YnI+DQo8L2Rpdj4NCjxkaXY+ U2hvdWxkIHRoZSBsaW5rcyB1bmRlciAmcXVvdDtIeXBlcnZpc29yIERvd25sb2FkcyZxdW90OyBi ZSAmcXVvdDt2ZXJzaW9uIDQuMy4xJnF1b3Q7IGluc3RlYWQgb2YgJnF1b3Q7WGVuIDQuMy4xJnF1 b3Q7IHRvIHJlc29sdmUgdGhlIHRyYWRlbWFyayBjb25jZXJucz88L2Rpdj4NCjxkaXY+PGJyPg0K PC9kaXY+DQo8ZGl2Pi0tbXN3PC9kaXY+DQo8ZGl2Pjxicj4NCjwvZGl2Pg0KPGRpdj4NCjxkaXYg c3R5bGU9ImZvbnQtZmFtaWx5OiAnVGltZXMgTmV3IFJvbWFuJzsgZm9udC1zaXplOiAxNnB4OyI+ DQo8aHIgdGFiaW5kZXg9Ii0xIj4NCjxkaXYgaWQ9ImRpdlJwRjkyMjQ0OSIgc3R5bGU9ImRpcmVj dGlvbjogbHRyOyI+PGZvbnQgZmFjZT0iVGFob21hIiBzaXplPSIyIj48Yj5Gcm9tOjwvYj48c3Bh biBjbGFzcz0iQXBwbGUtY29udmVydGVkLXNwYWNlIj4mbmJzcDs8L3NwYW4+PGEgaHJlZj0ibWFp bHRvOmFkdmlzb3J5LWJvYXJkLWJvdW5jZXNAbGlzdHMueGVucHJvamVjdC5vcmciPmFkdmlzb3J5 LWJvYXJkLWJvdW5jZXNAbGlzdHMueGVucHJvamVjdC5vcmc8L2E+IFs8YSBocmVmPSJtYWlsdG86 YWR2aXNvcnktYm9hcmQtYm91bmNlc0BsaXN0cy54ZW5wcm9qZWN0Lm9yZyI+YWR2aXNvcnktYm9h cmQtYm91bmNlc0BsaXN0cy54ZW5wcm9qZWN0Lm9yZzwvYT5dDQogb24gYmVoYWxmIG9mIFNhcmFo IENvbndheSBbPGEgaHJlZj0ibWFpbHRvOnNjb253YXlAbGludXhmb3VuZGF0aW9uLm9yZyI+c2Nv bndheUBsaW51eGZvdW5kYXRpb24ub3JnPC9hPl08YnI+DQo8Yj5TZW50OjwvYj48c3BhbiBjbGFz cz0iQXBwbGUtY29udmVydGVkLXNwYWNlIj4mbmJzcDs8L3NwYW4+V2VkbmVzZGF5LCBNYXJjaCAw NSwgMjAxNCA5OjMzIEFNPGJyPg0KPGI+VG86PC9iPjxzcGFuIGNsYXNzPSJBcHBsZS1jb252ZXJ0 ZWQtc3BhY2UiPiZuYnNwOzwvc3Bhbj5BZHZpc29yeS1ib2FyZCBkaXNjdXNzaW9uczxicj4NCjxi PlN1YmplY3Q6PC9iPjxzcGFuIGNsYXNzPSJBcHBsZS1jb252ZXJ0ZWQtc3BhY2UiPiZuYnNwOzwv c3Bhbj5SZTogW0Fkdmlzb3J5LWJvYXJkXSBYZW4gUHJvamVjdCA0LjQgUmVsZWFzZTxicj4NCjwv Zm9udD48YnI+DQo8L2Rpdj4NCjxkaXY+PC9kaXY+DQo8ZGl2Pg0KPGRpdiBkaXI9Imx0ciI+TWFy ayBldCBhbGwsJm5ic3A7DQo8ZGl2Pjxicj4NCjwvZGl2Pg0KPGRpdj48c3BhbiBzdHlsZT0iZm9u dC1mYW1pbHk6IGFyaWFsLCBzYW5zLXNlcmlmOyBmb250LXNpemU6IDEzcHg7Ij5JIGFncmVlIHRo YXQgdXNpbmcgWGVuIFByb2plY3QgaXMgYSBtb3V0aGZ1bC4gRzwvc3Bhbj48Zm9udCBmYWNlPSJh cmlhbCwgc2Fucy1zZXJpZiI+aXZlbiB0aGF0IHRoZXJlIGlzIGNsb3NlIG92ZXJsYXAgYW5kJm5i c3A7b2NjYXNpb25hbCZuYnNwO2JyYW5kaW5nIGNvbmZ1c2lvbiB3aXRoIENpdHJpeCBwcm9kdWN0 cywgaWYgd2UgYWRkIGFub3RoZXINCiBuZXcgdGVybSBvcjwvZm9udD48c3BhbiBzdHlsZT0iY29s b3I6IHJnYig2OCwgNjgsIDY4KTsgZm9udC1mYW1pbHk6IGFyaWFsLCBzYW5zLXNlcmlmOyBmb250 LXdlaWdodDogYm9sZDsgbGluZS1oZWlnaHQ6IDE2cHg7Ij4mbmJzcDs8L3NwYW4+YWNyb255bTxz cGFuIHN0eWxlPSJmb250LWZhbWlseTogYXJpYWwsIHNhbnMtc2VyaWY7Ij4mbmJzcDtpbnRvIHRo ZSBtaXgsIHdlJ2xsIHdhbnQgdG8gYmUgZGlsaWdlbnQgYWJvdXQgYmVpbmcgY29uc2lzdGVudCBp biBibG9ncywNCiBwcmVzZW50YXRpb25zLCBuZXdzIHJlbGVhc2VzLCB3ZWIgc2l0ZSBjb3B5LCBj dXN0b21lciB0ZXN0aW1vbmlhbHMgZXRjLiZuYnNwOzwvc3Bhbj48L2Rpdj4NCjxkaXY+PHNwYW4g c3R5bGU9ImZvbnQtZmFtaWx5OiBhcmlhbCwgc2Fucy1zZXJpZjsiPjxicj4NCjwvc3Bhbj48L2Rp dj4NCjxkaXY+PHNwYW4gc3R5bGU9ImZvbnQtZmFtaWx5OiBhcmlhbCwgc2Fucy1zZXJpZjsiPkZv ciB0aGUgc2FrZSBvZiZuYnNwOzwvc3Bhbj48Zm9udCBmYWNlPSJhcmlhbCwgc2Fucy1zZXJpZiI+ c2ltcGxpY2l0eSwgaG93IGFib3V0IHVzaW5nIFhQSCAtIGFsbCB1cHBlcmNhc2UgLSBvbiBzZWNv bmQgcmVmZXJlbmNlPyBUaG91Z2h0cz88L2ZvbnQ+PC9kaXY+DQo8ZGl2Pjxmb250IGZhY2U9ImFy aWFsLCBzYW5zLXNlcmlmIj48YnI+DQo8L2ZvbnQ+PC9kaXY+DQo8ZGl2Pjxmb250IGZhY2U9ImFy aWFsLCBzYW5zLXNlcmlmIj5UaGFua3MsPC9mb250PjwvZGl2Pg0KPGRpdj48Zm9udCBmYWNlPSJh cmlhbCwgc2Fucy1zZXJpZiI+PGJyPg0KPC9mb250PjwvZGl2Pg0KPGRpdj48Zm9udCBmYWNlPSJh cmlhbCwgc2Fucy1zZXJpZiI+PGJyPg0KPC9mb250PjwvZGl2Pg0KPGRpdj48c3BhbiBzdHlsZT0i Zm9udC1mYW1pbHk6IGFyaWFsLCBzYW5zLXNlcmlmOyBmb250LXNpemU6IDEzcHg7Ij48YnI+DQo8 L3NwYW4+PC9kaXY+DQo8ZGl2PjxzcGFuIHN0eWxlPSJmb250LWZhbWlseTogYXJpYWwsIHNhbnMt c2VyaWY7IGZvbnQtc2l6ZTogMTNweDsiPjxicj4NCjwvc3Bhbj48L2Rpdj4NCjwvZGl2Pg0KPGRp diBjbGFzcz0iZ21haWxfZXh0cmEiPjxicj4NCjxicj4NCjxkaXYgY2xhc3M9ImdtYWlsX3F1b3Rl Ij5PbiBXZWQsIE1hciA1LCAyMDE0IGF0IDk6MTggQU0sIE1hcmsgSGlua2xlPHNwYW4gY2xhc3M9 IkFwcGxlLWNvbnZlcnRlZC1zcGFjZSI+Jm5ic3A7PC9zcGFuPjxzcGFuIGRpcj0ibHRyIj4mbHQ7 PGEgaHJlZj0ibWFpbHRvOk1hcmsuSGlua2xlQGNpdHJpeC5jb20iIHRhcmdldD0iX2JsYW5rIj5N YXJrLkhpbmtsZUBjaXRyaXguY29tPC9hPiZndDs8L3NwYW4+PHNwYW4gY2xhc3M9IkFwcGxlLWNv bnZlcnRlZC1zcGFjZSI+Jm5ic3A7PC9zcGFuPndyb3RlOjxicj4NCjxibG9ja3F1b3RlIGNsYXNz PSJnbWFpbF9xdW90ZSIgc3R5bGU9Im1hcmdpbjogMHB4IDBweCAwcHggMC44ZXg7IGJvcmRlci1s ZWZ0LXdpZHRoOiAxcHg7IGJvcmRlci1sZWZ0LWNvbG9yOiByZ2IoMjA0LCAyMDQsIDIwNCk7IGJv cmRlci1sZWZ0LXN0eWxlOiBzb2xpZDsgcGFkZGluZy1sZWZ0OiAxZXg7Ij4NCjxkaXYgc3R5bGU9 IndvcmQtd3JhcDogYnJlYWstd29yZDsiPkhvdyBhYm91dCB0aGlzIGNvbnZlbnRpb24gb25seSBz YXkgWGVuIFByb2plY3QgYW5kIFhlbiBQcm9qZWN0IGh5cGVydmlzb3Igb25jZSB0aGVuLiBVc2Ug dGhlIGFiYnJldmlhdGlvbiBYUGggdGhyb3VnaG91dCB0aGUgcmVsZWFzZS4gSnVzdCBzbmlwcGlu ZyBNYXR04oCZcyBleGFtcGxlIHRvIG1ha2UgdGhlIHBvaW50LiBJIHdvdWxkIGd1ZXNzIHRoYXQg dGhlIGFwcHJvcHJpYXRlIGNhcGl0YWxpemF0aW9uDQogd291bGQgYmUgbG93ZXIgY2FzZSBmb3Ig dGhlIHdvcmQgaHlwZXJ2aXNvci4mbmJzcDsNCjxkaXY+PGJyPg0KPC9kaXY+DQo8ZGl2Pk1hcmsm bmJzcDs8YnI+DQo8ZGl2Pjxicj4NCjwvZGl2Pg0KPGRpdj4NCjxibG9ja3F1b3RlIHR5cGU9ImNp dGUiPg0KPGRpdiBzdHlsZT0iZGlyZWN0aW9uOiBsdHI7IGZvbnQtZmFtaWx5OiBWZXJkYW5hOyBm b250LXNpemU6IDEwcHQ7Ij4NCjxibG9ja3F1b3RlIHN0eWxlPSJtYXJnaW46IDBweCAwcHggMHB4 IDQwcHg7IGJvcmRlcjogbm9uZTsgcGFkZGluZzogMHB4OyI+DQo8cCBhbGlnbj0iTEVGVCIgc3R5 bGU9Im1hcmdpbi1ib3R0b206IDAuMTVpbjsiPjxzcGFuIGxhbmc9ImVuLVVTIj5UaGUmbmJzcDs8 c3BhbiBzdHlsZT0iYmFja2dyb3VuZC1jb2xvcjogcmdiKDI1NSwgMjU1LCAwKTsiPlhlbiBQcm9q ZWN0PC9zcGFuPiwgYSBDb2xsYWJvcmF0aXZlIFByb2plY3QgaG9zdGVkIGF0IFRoZSBMaW51eCBG b3VuZGF0aW9uLCB0b2RheSBhbm5vdW5jZWQgYXZhaWxhYmlsaXR5IG9mIHRoZSZuYnNwOzxzcGFu IHN0eWxlPSJiYWNrZ3JvdW5kLWNvbG9yOiByZ2IoMjU1LCAyNTUsIDApOyI+WGVuDQogUHJvamVj dDwvc3Bhbj4mbmJzcDtoeXBlcnZpc29yKFhQaCkgNC40IHdpdGggZW5oYW5jZWQmbmJzcDtBUk0g c3VwcG9ydC48L3NwYW4+PC9wPg0KPC9ibG9ja3F1b3RlPg0KPC9kaXY+DQo8L2Jsb2NrcXVvdGU+ DQo8ZGl2Pg0KPGJsb2NrcXVvdGUgdHlwZT0iY2l0ZSI+DQo8ZGl2IHN0eWxlPSJkaXJlY3Rpb246 IGx0cjsgZm9udC1mYW1pbHk6IFZlcmRhbmE7IGZvbnQtc2l6ZTogMTBwdDsiPg0KPGJsb2NrcXVv dGUgc3R5bGU9Im1hcmdpbjogMHB4IDBweCAwcHggNDBweDsgYm9yZGVyOiBub25lOyBwYWRkaW5n OiAwcHg7Ij4NCjxwIGFsaWduPSJMRUZUIiBzdHlsZT0ibWFyZ2luLWJvdHRvbTogMC4xNWluOyI+ PHNwYW4gbGFuZz0iZW4tVVMiPlhQaCA0LjQgZnVydGhlciBhZHZhbmNlcyB0aGUgUHJvamVjdDwv c3Bhbj48c3BhbiBsYW5nPSJmci1GUiI+4oCZPC9zcGFuPjxzcGFuIGxhbmc9ImVuLVVTIj5zIHBv c2l0aW9uIGFzIGEgZmFzdCwgc2NhbGFibGUsIHNlY3VyZSB2aXJ0dWFsaXphdGlvbiBlbmdpbmUg Zm9yIHRoZSBpbmR1c3RyeTwvc3Bhbj48c3BhbiBsYW5nPSJmci1GUiI+4oCZPC9zcGFuPjxzcGFu IGxhbmc9ImVuLVVTIj5zDQogYnJvYWRlc3QgcmFuZ2Ugb2Ygc2VydmVyLCBQQyBjaGlwc2V0cyBh bmQgbmV4dC1nZW5lcmF0aW9uIGxvdy1wb3dlciBzeXN0ZW1zIG9uIGNoaXBzIChTb0MpLjwvc3Bh bj48L3A+DQo8L2Jsb2NrcXVvdGU+DQo8L2Rpdj4NCjwvYmxvY2txdW90ZT4NCjwvZGl2Pg0KPGRp dj48YnI+DQo8ZGl2Pg0KPGRpdj5PbiBNYXIgNCwgMjAxNCwgYXQgNDowMSBQTSwgV2lsc29uLCBN YXR0ICZsdDs8YSBocmVmPSJtYWlsdG86bXN3QGFtYXpvbi5jb20iIHRhcmdldD0iX2JsYW5rIj5t c3dAYW1hem9uLmNvbTwvYT4mZ3Q7IHdyb3RlOjwvZGl2Pg0KPGJyPg0KPGJsb2NrcXVvdGUgdHlw ZT0iY2l0ZSI+DQo8ZGl2IHN0eWxlPSJmb250LWZhbWlseTogSGVsdmV0aWNhOyBmb250LXNpemU6 IDEycHg7IGZvbnQtc3R5bGU6IG5vcm1hbDsgZm9udC12YXJpYW50OiBub3JtYWw7IGZvbnQtd2Vp Z2h0OiBub3JtYWw7IGxldHRlci1zcGFjaW5nOiBub3JtYWw7IGxpbmUtaGVpZ2h0OiBub3JtYWw7 IHRleHQtYWxpZ246IHN0YXJ0OyB0ZXh0LWluZGVudDogMHB4OyB0ZXh0LXRyYW5zZm9ybTogbm9u ZTsgd2hpdGUtc3BhY2U6IG5vcm1hbDsgd29yZC1zcGFjaW5nOiAwcHg7Ij4NCjxkaXYgc3R5bGU9 ImRpcmVjdGlvbjogbHRyOyBmb250LWZhbWlseTogVmVyZGFuYTsgZm9udC1zaXplOiAxMHB0OyI+ VGhlICZxdW90O1hlbiBQcm9qZWN0JnF1b3Q7IHRlcm1pbm9sb2d5IG1ha2VzIHRoZSBtZXNzYWdl IGV4dHJlbWVseSBjdW1iZXJzb21lLg0KPGRpdj48YnI+DQo8L2Rpdj4NCjxibG9ja3F1b3RlIHN0 eWxlPSJtYXJnaW46IDBweCAwcHggMHB4IDQwcHg7IGJvcmRlcjogbm9uZTsgcGFkZGluZzogMHB4 OyI+DQo8cCBhbGlnbj0iTEVGVCIgc3R5bGU9Im1hcmdpbi1ib3R0b206IDAuMTVpbjsiPjxzcGFu IGxhbmc9ImVuLVVTIj5UaGU8c3Bhbj4mbmJzcDs8L3NwYW4+PHNwYW4gc3R5bGU9ImJhY2tncm91 bmQtY29sb3I6IHJnYigyNTUsIDI1NSwgMCk7Ij5YZW4gUHJvamVjdDwvc3Bhbj4sIGEgQ29sbGFi b3JhdGl2ZSBQcm9qZWN0IGhvc3RlZCBhdCBUaGUgTGludXggRm91bmRhdGlvbiwgdG9kYXkgYW5u b3VuY2VkIGF2YWlsYWJpbGl0eSBvZiB0aGU8c3Bhbj4mbmJzcDs8L3NwYW4+PHNwYW4gc3R5bGU9 ImJhY2tncm91bmQtY29sb3I6IHJnYigyNTUsIDI1NSwgMCk7Ij5YZW4NCiBQcm9qZWN0PC9zcGFu PjxzcGFuPiZuYnNwOzwvc3Bhbj40LjQgSHlwZXJ2aXNvciB3aXRoIGVuaGFuY2VkPHNwYW4+Jm5i c3A7PC9zcGFuPjxzcGFuIHN0eWxlPSJiYWNrZ3JvdW5kLWNvbG9yOiByZ2IoMjU1LCAyNTUsIDAp OyI+WGVuIFByb2plY3Q8L3NwYW4+LW9uLUFSTSBzdXBwb3J0Ljwvc3Bhbj48L3A+DQo8L2Jsb2Nr cXVvdGU+DQpXaHkgbm90IGp1c3Qgc2F5ICZxdW90O2VuaGFuY2VkIEFSTSBzdXBwb3J0JnF1b3Q7 PyBXZSBzaG91bGQgYWRvcHQgc29tZSB1c2FnZSBndWlkZWxpbmVzIGZvciBzdWItcHJvamVjdCBi cmFuZGluZy4gV2Ugc2hvdWxkbid0IGluc2VydCB3b3Jkcy9udW1iZXJzIGJldHdlZW4gJnF1b3Q7 WGVuIFByb2plY3QmcXVvdDsgYW5kIGEgc3ViLXByb2plY3QgbmFtZS4NCjxkaXY+PGJyPg0KPC9k aXY+DQo8YmxvY2txdW90ZSBzdHlsZT0ibWFyZ2luOiAwcHggMHB4IDBweCA0MHB4OyBib3JkZXI6 IG5vbmU7IHBhZGRpbmc6IDBweDsiPlRoZSBYZW4gUHJvamVjdCwgYSBDb2xsYWJvcmF0aXZlIFBy b2plY3QgaG9zdGVkIGF0IFRoZSBMaW51eCBGb3VuZGF0aW9uLCB0b2RheSBhbm5vdW5jZWQgdmVy c2lvbiA0LjQgb2YgdGhlIFhlbiBQcm9qZWN0IEh5cGVydmlzb3Igd2l0aCBlbmhhbmNlZCBBUk0g c3VwcG9ydC48L2Jsb2NrcXVvdGU+DQo8ZGl2Pjxicj4NCjwvZGl2Pg0KPGRpdj5vcjwvZGl2Pg0K PGRpdj4NCjxibG9ja3F1b3RlIHN0eWxlPSJtYXJnaW46IDBweCAwcHggMHB4IDQwcHg7IGJvcmRl cjogbm9uZTsgcGFkZGluZzogMHB4OyI+VGhlIFhlbiBQcm9qZWN0LCBhIENvbGxhYm9yYXRpdmUg UHJvamVjdCBob3N0ZWQgYXQgVGhlIExpbnV4IEZvdW5kYXRpb24sIHRvZGF5IGFubm91bmNlZCB0 aGUgcmVsZWFzZSBvZiBYZW4gUHJvamVjdCBIeXBlcnZpc29yIDQuNCB3aXRoIGVuaGFuY2VkIEFS TSBzdXBwb3J0LjwvYmxvY2txdW90ZT4NCjxibG9ja3F1b3RlIHN0eWxlPSJtYXJnaW46IDBweCAw cHggMHB4IDQwcHg7IGJvcmRlcjogbm9uZTsgcGFkZGluZzogMHB4OyI+PGJyPg0KPC9ibG9ja3F1 b3RlPg0KTGF0ZXIgb24sIHRoaXMgcmVsZWFzZSBpcyBjYWxsZWQgJnF1b3Q7WGVuIFByb2plY3Qg NC40JnF1b3Q7DQo8ZGl2PjwvZGl2Pg0KPC9kaXY+DQo8ZGl2Pjxicj4NCjwvZGl2Pg0KPGJsb2Nr cXVvdGUgc3R5bGU9Im1hcmdpbjogMHB4IDBweCAwcHggNDBweDsgYm9yZGVyOiBub25lOyBwYWRk aW5nOiAwcHg7Ij4NCjxwIGFsaWduPSJMRUZUIiBzdHlsZT0ibWFyZ2luLWJvdHRvbTogMC4xNWlu OyI+PHNwYW4gbGFuZz0iZW4tVVMiPlRoZSBYZW4gUHJvamVjdCA0LjQgcmVsZWFzZSBmdXJ0aGVy IGFkdmFuY2VzIHRoZSBQcm9qZWN0PC9zcGFuPjxzcGFuIGxhbmc9ImZyLUZSIj7igJk8L3NwYW4+ PHNwYW4gbGFuZz0iZW4tVVMiPnMgcG9zaXRpb24gYXMgYSBmYXN0LCBzY2FsYWJsZSwgc2VjdXJl IHZpcnR1YWxpemF0aW9uIGVuZ2luZSBmb3IgdGhlIGluZHVzdHJ5PC9zcGFuPjxzcGFuIGxhbmc9 ImZyLUZSIj7igJk8L3NwYW4+PHNwYW4gbGFuZz0iZW4tVVMiPnMNCiBicm9hZGVzdCByYW5nZSBv ZiBzZXJ2ZXIsIFBDIGNoaXBzZXRzIGFuZCBuZXh0LWdlbmVyYXRpb24gbG93LXBvd2VyIHN5c3Rl bXMgb24gY2hpcHMgKFNvQykuPC9zcGFuPjwvcD4NCjwvYmxvY2txdW90ZT4NCjxkaXY+VGhhdCBk b2Vzbid0IGZsb3cgd2VsbC4gSG93IGFyZSB3ZSByZWxlYXNpbmcgdmVyc2lvbiA0LjQgb2YgYSBw cm9qZWN0PyBEbyB3ZSB3YW50IHRvIGNhbGwgdGhlIG92ZXJhbGwgcmVsZWFzZSAmcXVvdDtYZW4g UHJvamVjdCBBcmNoaXRlY3R1cmUgNC40JnF1b3Q7PyBPciBkbyB3ZSBuZWVkIHRvIGNvbWUgdXAg d2l0aCBzb21lIG90aGVyIHByb2plY3QgYnJhbmRpbmc/PC9kaXY+DQo8ZGl2Pjxicj4NCjwvZGl2 Pg0KPGRpdj4tLW1zdzwvZGl2Pg0KPGRpdj48YnI+DQo8ZGl2Pg0KPGRpdiBzdHlsZT0iZm9udC1m YW1pbHk6ICdUaW1lcyBOZXcgUm9tYW4nOyBmb250LXNpemU6IDE2cHg7Ij4NCjxocj4NCjxkaXYg c3R5bGU9ImRpcmVjdGlvbjogbHRyOyI+PGZvbnQgZmFjZT0iVGFob21hIj48Yj5Gcm9tOjwvYj48 c3Bhbj4mbmJzcDs8L3NwYW4+PGEgaHJlZj0ibWFpbHRvOmFkdmlzb3J5LWJvYXJkLWJvdW5jZXNA bGlzdHMueGVucHJvamVjdC5vcmciIHRhcmdldD0iX2JsYW5rIj5hZHZpc29yeS1ib2FyZC1ib3Vu Y2VzQGxpc3RzLnhlbnByb2plY3Qub3JnPC9hPjxzcGFuIGNsYXNzPSJBcHBsZS1jb252ZXJ0ZWQt c3BhY2UiPiZuYnNwOzwvc3Bhbj5bPGEgaHJlZj0ibWFpbHRvOmFkdmlzb3J5LWJvYXJkLWJvdW5j ZXNAbGlzdHMueGVucHJvamVjdC5vcmciIHRhcmdldD0iX2JsYW5rIj5hZHZpc29yeS1ib2FyZC1i b3VuY2VzQGxpc3RzLnhlbnByb2plY3Qub3JnPC9hPl0NCiBvbiBiZWhhbGYgb2YgU2FyYWggQ29u d2F5IFs8YSBocmVmPSJtYWlsdG86c2NvbndheUBsaW51eGZvdW5kYXRpb24ub3JnIiB0YXJnZXQ9 Il9ibGFuayI+c2NvbndheUBsaW51eGZvdW5kYXRpb24ub3JnPC9hPl08YnI+DQo8Yj5TZW50Ojwv Yj48c3Bhbj4mbmJzcDs8L3NwYW4+VHVlc2RheSwgTWFyY2ggMDQsIDIwMTQgMTI6MTYgUE0NCjxk aXYgY2xhc3M9IiI+PGJyPg0KPGI+VG86PC9iPjxzcGFuPiZuYnNwOzwvc3Bhbj48YSBocmVmPSJt YWlsdG86YWR2aXNvcnktYm9hcmRAbGlzdHMueGVucHJvamVjdC5vcmciIHRhcmdldD0iX2JsYW5r Ij5hZHZpc29yeS1ib2FyZEBsaXN0cy54ZW5wcm9qZWN0Lm9yZzwvYT48YnI+DQo8Yj5TdWJqZWN0 OjwvYj48c3Bhbj4mbmJzcDs8L3NwYW4+W0Fkdmlzb3J5LWJvYXJkXSBYZW4gUHJvamVjdCA0LjQg UmVsZWFzZTxicj4NCjwvZGl2Pg0KPC9mb250Pjxicj4NCjwvZGl2Pg0KPGRpdj4NCjxkaXYgY2xh c3M9Img1Ij4NCjxkaXY+PC9kaXY+DQo8ZGl2Pg0KPGRpdiBkaXI9Imx0ciI+SGkgZXZlcnlvbmUu DQo8ZGl2Pjxicj4NCjwvZGl2Pg0KPGRpdj5BdHRhY2hlZCBpcyB0aGUgWGVuIFByb2plY3QgNC40 IG5ld3MgcmVsZWFzZSBhbm5vdWNlbWVudCB0aGF0IHdpbGwgZ28gb3V0IGF0IDggYS5tLiBFVCBv biBNb25kYXksIE1hcmNoIDEwLiZuYnNwOzwvZGl2Pg0KPGRpdj48YnI+DQo8L2Rpdj4NCjxkaXY+ SWYgeW91IGhhdmUgYW55IGFkZGl0aW9uYWwgY29tbWVudHMgb3IgZWRpdHMsIHBsZWFzZSBnZXQg YmFjayB0byBtZSBieSBUaHVyc2RheSBtb3JuaW5nIGF0IHRoZSBsYXRlc3QuJm5ic3A7PC9kaXY+ DQo8ZGl2Pjxicj4NCjwvZGl2Pg0KPGRpdj5UaGFua3MsJm5ic3A7PC9kaXY+DQo8ZGl2PjxiciBj bGVhcj0iYWxsIj4NCjxkaXY+PGJyPg0KPC9kaXY+DQotLTxzcGFuPiZuYnNwOzwvc3Bhbj48YnI+ DQo8ZGl2IGRpcj0ibHRyIj4NCjxkaXY+U2FyYWggQ29ud2F5PGJyPg0KPC9kaXY+DQo8ZGl2PlBS IE1hbmFnZXI8L2Rpdj4NCjxkaXY+VGhlIExpbnV4IEZvdW5kYXRpb248YnI+DQo8YSBocmVmPSJt YWlsdG86c2NvbndheUBsaW51eGZvdW5kYXRpb24ub3JnIiB0YXJnZXQ9Il9ibGFuayI+c2Nvbndh eUBsaW51eGZvdW5kYXRpb24ub3JnPC9hPjwvZGl2Pg0KPGRpdj48YSBocmVmPSJ0ZWw6JTI4OTc4 JTI5JTIwNTc4LTUzMDAiIHZhbHVlPSImIzQzOzE5Nzg1Nzg1MzAwIiB0YXJnZXQ9Il9ibGFuayI+ KDk3OCkgNTc4LTUzMDA8L2E+PHNwYW4gY2xhc3M9IkFwcGxlLWNvbnZlcnRlZC1zcGFjZSI+Jm5i c3A7PC9zcGFuPiZuYnNwO0NlbGw8L2Rpdj4NCjxkaXY+U2t5cGU6ICZuYnNwO3NhcmFoLmsuY29u d2F5PC9kaXY+DQo8L2Rpdj4NCjwvZGl2Pg0KPC9kaXY+DQo8L2Rpdj4NCjwvZGl2Pg0KPC9kaXY+ DQo8L2Rpdj4NCjwvZGl2Pg0KPC9kaXY+DQo8L2Rpdj4NCl9fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fPGJyPg0KQWR2aXNvcnktYm9hcmQgbWFpbGluZyBsaXN0 PGJyPg0KPGEgaHJlZj0ibWFpbHRvOkFkdmlzb3J5LWJvYXJkQGxpc3RzLnhlbnByb2plY3Qub3Jn IiB0YXJnZXQ9Il9ibGFuayI+QWR2aXNvcnktYm9hcmRAbGlzdHMueGVucHJvamVjdC5vcmc8L2E+ PGJyPg0KPGEgaHJlZj0iaHR0cDovL2xpc3RzLnhlbnByb2plY3Qub3JnL2NnaS1iaW4vbWFpbG1h bi9saXN0aW5mby9hZHZpc29yeS1ib2FyZCIgdGFyZ2V0PSJfYmxhbmsiPmh0dHA6Ly9saXN0cy54 ZW5wcm9qZWN0Lm9yZy9jZ2ktYmluL21haWxtYW4vbGlzdGluZm8vYWR2aXNvcnktYm9hcmQ8L2E+ PC9kaXY+DQo8L2Jsb2NrcXVvdGU+DQo8L2Rpdj4NCjxicj4NCjwvZGl2Pg0KPC9kaXY+DQo8L2Rp dj4NCjwvZGl2Pg0KPGJyPg0KX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX188YnI+DQpBZHZpc29yeS1ib2FyZCBtYWlsaW5nIGxpc3Q8YnI+DQo8YSBocmVmPSJt YWlsdG86QWR2aXNvcnktYm9hcmRAbGlzdHMueGVucHJvamVjdC5vcmciIHRhcmdldD0iX2JsYW5r Ij5BZHZpc29yeS1ib2FyZEBsaXN0cy54ZW5wcm9qZWN0Lm9yZzwvYT48YnI+DQo8YSBocmVmPSJo dHRwOi8vbGlzdHMueGVucHJvamVjdC5vcmcvY2dpLWJpbi9tYWlsbWFuL2xpc3RpbmZvL2Fkdmlz b3J5LWJvYXJkIiB0YXJnZXQ9Il9ibGFuayI+aHR0cDovL2xpc3RzLnhlbnByb2plY3Qub3JnL2Nn aS1iaW4vbWFpbG1hbi9saXN0aW5mby9hZHZpc29yeS1ib2FyZDwvYT48YnI+DQo8YnI+DQo8L2Js b2NrcXVvdGU+DQo8L2Rpdj4NCjxicj4NCjxiciBjbGVhcj0iYWxsIj4NCjxkaXY+PGJyPg0KPC9k aXY+DQotLTxzcGFuIGNsYXNzPSJBcHBsZS1jb252ZXJ0ZWQtc3BhY2UiPiZuYnNwOzwvc3Bhbj48 YnI+DQo8ZGl2IGRpcj0ibHRyIj4NCjxkaXY+U2FyYWggQ29ud2F5PGJyPg0KPC9kaXY+DQo8ZGl2 PlBSIE1hbmFnZXI8L2Rpdj4NCjxkaXY+VGhlIExpbnV4IEZvdW5kYXRpb248YnI+DQo8YSBocmVm PSJtYWlsdG86c2NvbndheUBsaW51eGZvdW5kYXRpb24ub3JnIiB0YXJnZXQ9Il9ibGFuayI+c2Nv bndheUBsaW51eGZvdW5kYXRpb24ub3JnPC9hPjwvZGl2Pg0KPGRpdj4oOTc4KSA1NzgtNTMwMCAm bmJzcDtDZWxsPC9kaXY+DQo8ZGl2PlNreXBlOiAmbmJzcDtzYXJhaC5rLmNvbndheTwvZGl2Pg0K PC9kaXY+DQo8L2Rpdj4NCjwvZGl2Pg0KPC9kaXY+DQo8L2Rpdj4NCjwvZGl2Pg0KPC9kaXY+DQo8 L2Rpdj4NCjwvZGl2Pg0KPC9kaXY+DQpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fXzxicj4NCkFkdmlzb3J5LWJvYXJkIG1haWxpbmcgbGlzdDxicj4NCjxhIGhy ZWY9Im1haWx0bzpBZHZpc29yeS1ib2FyZEBsaXN0cy54ZW5wcm9qZWN0Lm9yZyI+QWR2aXNvcnkt Ym9hcmRAbGlzdHMueGVucHJvamVjdC5vcmc8L2E+PGJyPg0KaHR0cDovL2xpc3RzLnhlbnByb2pl Y3Qub3JnL2NnaS1iaW4vbWFpbG1hbi9saXN0aW5mby9hZHZpc29yeS1ib2FyZDwvZGl2Pg0KPC9i bG9ja3F1b3RlPg0KPC9kaXY+DQo8YnI+DQo8L2Rpdj4NCjwvYm9keT4NCjwvaHRtbD4NCg== --_000_2BCAC582CB614E1696C46C1AEFAF81FBcitrixcom_-- --===============0760182873058475793== Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Disposition: inline _______________________________________________ Advisory-board mailing list Advisory-board@lists.xenproject.org http://lists.xenproject.org/cgi-bin/mailman/listinfo/advisory-board --===============0760182873058475793==-- From advisory-board-bounces@lists.xenproject.org Fri Mar 07 13:13:11 2014 Return-path: Envelope-to: archives@lists.xenproject.org Delivery-date: Fri, 07 Mar 2014 13:13:11 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WLuaN-0000Ao-SH; Fri, 07 Mar 2014 13:13:11 +0000 Received: from mail6.bemta4.messagelabs.com ([85.158.143.247]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WLuaM-0000Aj-84 for advisory-board@lists.xenproject.org; Fri, 07 Mar 2014 13:13:10 +0000 Received: from [85.158.143.35:28486] by server-2.bemta-4.messagelabs.com id 8F/AE-06539-5E5C9135; Fri, 07 Mar 2014 13:13:09 +0000 X-Env-Sender: richard.phelan@arm.com X-Msg-Ref: server-9.tower-21.messagelabs.com!1394197988!415344!1 X-Originating-IP: [195.130.217.12] X-SpamReason: No, hits=0.0 required=7.0 tests=sa_preprocessor: VHJ1c3RlZCBJUDogMTk1LjEzMC4yMTcuMTIgPT4gMzg5OTY3\n X-StarScan-Received: X-StarScan-Version: 6.11.1; banners=-,-,- X-VirusChecked: Checked Received: (qmail 21278 invoked from network); 7 Mar 2014 13:13:08 -0000 Received: from service88.mimecast.com (HELO service88.mimecast.com) (195.130.217.12) by server-9.tower-21.messagelabs.com with SMTP; 7 Mar 2014 13:13:08 -0000 Received: from emea-cam-gw2.Emea.Arm.com (fw-tnat.cambridge.arm.com [217.140.96.21]) (Using TLS) by service88.mimecast.com; Fri, 07 Mar 2014 13:13:07 +0000 Received: from bungle.Emea.Arm.com ([fe80::6ccb:73b1:f5c3:796]) by emea-cam-gw2.Emea.Arm.com ([::1]) with mapi; Fri, 7 Mar 2014 13:13:16 +0000 From: Richard Phelan To: Advisory-board discussions Date: Fri, 7 Mar 2014 13:13:01 +0000 Thread-Topic: [Advisory-board] Xen Project 4.4 Release Thread-Index: Ac86BwAcM3ytMhNUTl2oDne9kOB9xQ== Message-ID: References: <6848793A-A83B-40A1-A40C-2AA9DCC1E80A@citrix.com> <2BCAC582-CB61-4E16-96C4-6C1AEFAF81FB@citrix.com> In-Reply-To: <2BCAC582-CB61-4E16-96C4-6C1AEFAF81FB@citrix.com> Accept-Language: en-US, en-GB Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: user-agent: Microsoft-MacOutlook/14.3.9.131030 acceptlanguage: en-US, en-GB MIME-Version: 1.0 X-MC-Unique: 114030713130800202 Subject: Re: [Advisory-board] Xen Project 4.4 Release X-BeenThere: advisory-board@lists.xenproject.org X-Mailman-Version: 2.1.13 Precedence: list Reply-To: Advisory-board discussions List-Id: Advisory-board discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: multipart/mixed; boundary="===============5604124858703328888==" Sender: advisory-board-bounces@lists.xenproject.org Errors-To: advisory-board-bounces@lists.xenproject.org --===============5604124858703328888== Content-Language: en-US Content-Type: multipart/alternative; boundary="_000_CF3F6FFA248DDrichardphelanarmcom_" --_000_CF3F6FFA248DDrichardphelanarmcom_ Content-Type: text/plain; charset=BIG5 Content-Transfer-Encoding: base64 SGksDQoNCkkgYWdyZWUgd2l0aCBNYXJrIGFzIHRoZSBjdXJyZW50IHByZXNzIHJlbGVhc2UgaXMg aGlnaGxpZ2h0aW5nIGlzc3VlcyB0aGF0IHNlZW0gdG8gbWFrZSB0aGUgYXJ0aWN1bGF0aW9uIG9m IGJyYW5kIGFuZCBicmFuZCB2YWx1ZXMgbW9yZSBjdW1iZXJzb21lIHRoYW4gaXMgZGVzaXJhYmxl Lg0KDQpJJ20gaGFwcHkgdG8gZ28gd2l0aCB0aGUgcHJvcG9zZWQgY2hhbmdlcyBmb3IgdGhlIHJl YXNvbnMgc3RhdGVkLg0KDQpPbmUgbWlub3IgcG9pbnQsIEknZCBwcmVmZXIgIj+mU3lzdGVtIG9u IENoaXAgKFNvQykgZGV2aWNlcy4iLCB0d28gc2V0cyBvZiBwbHVyYWxzIG1ha2UgaXQgdW5jbGVh ciBob3cgbWFueSBzeXN0ZW1zIGFyZSBvbiBlYWNoIGNoaXAgYW5kIHRoZSBwbHVyYWxzIGdldCBz dWJtZXJnZWQgaW50byB0aGUgYWNyb255bTsgY29tbW9uIHVzYWdlIHNlZW1zIHRvIGJlIFNvQ3Mu DQoNClRoYW5rcywNCg0KUmljaGFyZC4NCg0KRnJvbTogTWFyayBIaW5rbGUgPE1hcmsuSGlua2xl QGNpdHJpeC5jb208bWFpbHRvOk1hcmsuSGlua2xlQGNpdHJpeC5jb20+Pg0KUmVwbHktVG86IEFk dmlzb3J5LWJvYXJkIGRpc2N1c3Npb25zIDxhZHZpc29yeS1ib2FyZEBsaXN0cy54ZW5wcm9qZWN0 Lm9yZzxtYWlsdG86YWR2aXNvcnktYm9hcmRAbGlzdHMueGVucHJvamVjdC5vcmc+Pg0KRGF0ZTog RnJpZGF5LCA3IE1hcmNoIDIwMTQgMDU6MzINClRvOiBBZHZpc29yeS1ib2FyZCBkaXNjdXNzaW9u cyA8YWR2aXNvcnktYm9hcmRAbGlzdHMueGVucHJvamVjdC5vcmc8bWFpbHRvOmFkdmlzb3J5LWJv YXJkQGxpc3RzLnhlbnByb2plY3Qub3JnPj4NClN1YmplY3Q6IFJlOiBbQWR2aXNvcnktYm9hcmRd IFhlbiBQcm9qZWN0IDQuNCBSZWxlYXNlDQoNCk15IGFwb2xvZ2llcyBmb3IgdGhlIHNsb3cgcmVw bHkgSSB3YXMgc3R1Y2sgb24gdGhlIHJvYWQgYW5kIGNvdWxkbj8/IHJlYWQgdGhlIHJlbGVhc2Ug b24gbXkgcGhvbmUgdG8gZm9ybXVsYXRlIGEgcHJvcGVyIHJlc3BvbnNlLiBJIHNob3VsZCBtb3Zl IHRvIGEgaGlnaGx5IGVsYXN0aWMgWGVuIFByb2plY3QtcG93ZXJlZCBjbG91ZCB0aGF0IGFsbG93 cyBtZSB0byBhdXRvc2NhbGUgOykgKHNvcnJ5IGJhZCBjbG91ZCBqb2tlKS4NCg0KSSBhbSBmaW5l IHdpdGhvdXQgZG9pbmcgdGhlIGFjcm9ueW0gYW5kIEkgdGhpbmsgdGhlIHJlYWxpZ25pbmcgYW5k IGJyYW5kaW5nIGRpc2N1c3Npb24gc2hvdWxkIGJlIGhhZC4gST8/IGxpa2UgdG8gaGF2ZSB0aGF0 IGRpc2N1c3Npb24gZHVyaW5nIG91ciBuZXh0IGJvYXJkIG1lZXRpbmcuIEdpdmVuIHRpbWUgaXMg b2YgdGhlIGVzc2VuY2UgSSB0aGluayB3ZSBzaG91bGQganVzdCB1cGRhdGUgdGhlIGxpbmtzIHRv IHZlcnNpb24gdmVyc3VzIFhlbiA0LjMuMS4NCg0KQWxzbyBJIHRvb2sgYSBzaG90IGF0IHRoZSB3 b3JkaW5nIG9mIHRoZSBwcmVzcyByZWxlYXNlLiBJdD8/IHByb2JhYmx5IG5vdCBwZXJmZWN0IGJ1 dCBtYWtlcyBpdCByZWFkIGEgYml0IGJldHRlci4gQXR0YWNoZWQgYXJlIG15IHByb3Bvc2VkIGVk aXRzLiBTYXJhaCwgSSBzZW50IHlvdSB0aGUgd29yZCBkb2Mgd2l0aCB0cmFjayBjaGFuZ2VzIGFz c3VtaW5nIHdlIGhhdmUgc29tZSBlZGl0cyB0byBhZ3JlZSBvbi4NCg0KDQpSZWdhcmRzLCBNYXJr DQoNCg0KWGVuIFByb2plY3QgUmVsZWFzZXMgVXBkYXRlIHRvIEVudGVycHJpc2UgSHlwZXJ2aXNv ciBTb2Z0d2FyZQ0KDQpPcGVuIFNvdXJjZSBWaXJ0dWFsaXphdGlvbiBTb2Z0d2FyZSBSZWxlYXNl IEluY2x1ZGVzIEFkZGl0aW9uYWwgQVJNIFN1cHBvcnQgYW5kIFNjYWxhYmlsaXR5IGZvciBDbG91 ZCBhbmQgTW9iaWxlIEVudmlyb25tZW50cw0KDQoNCg0KU0FOIEZSQU5DSVNDTywgTWFyY2ggMTAs IDIwMTQgPz8vc3Bhbj4gWGVuIFByb2plY3QsIGEgQ29sbGFib3JhdGl2ZSBQcm9qZWN0IGhvc3Rl ZCBhdCBUaGUgTGludXggRm91bmRhdGlvbiwgdG9kYXkgYW5ub3VuY2VkIGF2YWlsYWJpbGl0eSBv ZiB0aGUgWGVuIFByb2plY3QgNC40IHdpdGggZW5oYW5jZWQgQVJNIHN1cHBvcnQuIFRoZSBsYXRl c3QgcmVsZWFzZSBhbHNvIGluY2x1ZGVzIG1ham9yIHBlcmZvcm1hbmNlIGFuZCBzeXN0ZW0gc2Nh bGFiaWxpdHkgaW1wcm92ZW1lbnRzIGZvciBlbnRlcnByaXNlIGNvbXB1dGluZywgc3VjaCBhcyBt b2JpbGUgYW5kIGNsb3VkIGVudmlyb25tZW50cywgd2hlcmUgdmlydHVhbGl6YXRpb24gdGVjaG5v bG9neSBpcyBpbmNyZWFzaW5nbHkgaW4gZGVtYW5kLg0KDQpUaGlzIHJlbGVhc2UgZnVydGhlciBh ZHZhbmNlcyB0aGUgUHJvamVjdD8/L3NwYW4+cyBwb3NpdGlvbiBhcyBhIGZhc3QsIHNjYWxhYmxl LCBzZWN1cmUgdmlydHVhbGl6YXRpb24gZW5naW5lIGZvciB0aGUgaW5kdXN0cnk/Py9zcGFuPnMg YnJvYWRlc3QgcmFuZ2Ugb2Ygc2VydmVyLCBQQyBjaGlwc2V0cyBhbmQgbmV4dC1nZW5lcmF0aW9u IGxvdy1wb3dlciBzeXN0ZW1zIG9uIGNoaXBzIChTb0MpLg0KDQpNYWpvciBjb250cmlidXRpb25z IGZyb20gQU1ELCBDaXRyaXgsIEludGVsLCBPcmFjbGUgYW5kIFNVU0UgYXJlIHB1c2hpbmcgdGhl IFhlbiBQcm9qZWN0IHNvZnR3YXJlIHRvIHRha2UgYWR2YW50YWdlIG9mIHRoZSBsYXRlc3QgaGFy ZHdhcmUuIEFkZGl0aW9uYWxseSwgZGV2ZWxvcGVycyBjcmVhdGluZyBzZXJ2aWNlcyBhbmQgYXBw cyB3aXRoIGVtYmVkZGVkLCBtb2JpbGUgYW5kIGNsb3VkIHN5c3RlbXMgd2lsbCBiZW5lZml0IGZy b20gbmV3IGZlYXR1cmVzIHN1Y2ggYXMgZXZlbnQgY2hhbm5lbGluZyB3aGVuIHNjYWxpbmcgb3V0 IHRoZWlyIEluZnJhc3RydWN0dXJlIGFzIGEgU2VydmljZSBvZmZlcmluZ3MuDQoNCj8/L3NwYW4+ VmlydHVhbGl6YXRpb24gYW5kIGxvdy1wb3dlcmVkIHNlcnZlcnMgYXJlIGxlYWRpbmcgY29tcGFu aWVzIHRvIHJldGhpbmsgdGhlIGRhdGEgY2VudGVyIGFuZCBpdHMgcG90ZW50aWFsIGZvciBlZmZp Y2llbmN5LD8/IHNhaWQgTGFycyBLdXJ0aCwgQ2hhaXJtYW4gb2YgdGhlIFhlbiBQcm9qZWN0IGFk dmlzb3J5IGJvYXJkLiA/Py9zcGFuPk91ciBzb2x1dGlvbiBjb250YWlucyBJVC1yZWxhdGVkIGNv c3RzLCBwbHVzIG1lZXRzIHRoZSBzZWN1cml0eSBhbmQgc2NhbGFiaWxpdHkgbmVlZHMgb2YgdG9k YXk/Py9zcGFuPnMgZWxhc3RpYyBjbG91ZCwgbW9iaWxlIGFuZCBzb2NpYWwgbmV0d29ya2luZyBj b21wYW5pZXMuIFRoZSBsYXRlc3QgdXBkYXRlcyBjb250aW51ZSB0aGUgUHJvamVjdD8/L3NwYW4+ cyB0cmFjayByZWNvcmQgb2YgcmljaCBjb2xsYWJvcmF0aW9uIGFuZCB3aWRlc3ByZWFkIGRldmVs b3BtZW50IGZyb20gbWFueSBvZiB0aGUgd29ybGQ/Py9zcGFuPnMgdGVjaG5vbG9neSBsZWFkZXJz LiBUaGlzIGNlcnRhaW5seSBleHBsYWlucyB0aGUgc2lnbmlmaWNhbnQgZ3Jvd3RoIG9mIEFSTSBz dXBwb3J0LCB3aGljaCB3ZT8/L3NwYW4+cmUgcGxlYXNlZCB0byBzZWUgYWR2YW5jZSBzbyBxdWlj a2x5Lj8/L3NwYW4+DQoNClN1cHBvcnQgZm9yIEFSTSBvbiBYZW4gUHJvamVjdCBBcmNoaXRlY3R1 cmUgR3Jvd3MgUXVpY2tseQ0KDQpUaGUgbmV3IHJlbGVhc2UgaW50cm9kdWNlcyBzaWduaWZpY2Fu dCBzdGFiaWxpdHksIHVzYWJpbGl0eSBhbmQgcGVyZm9ybWFuY2UgaW1wcm92ZW1lbnRzIGZvciB0 aGUgQVJNIGFyY2hpdGVjdHVyZSBhbmQgZXh0ZW5kZWQgaGFyZHdhcmUgY29tcGF0aWJpbGl0eS4g IEFwcGxpZWRNaWNybz8/L3NwYW4+cyBYLUdlbmUsIHRoZSBBcm5kYWxlIEJvYXJkLCBDYWx4ZWRh IEVDWC0yMDAwLCBUSSBPTUFQNSBhbmQgdGhlIEFsbHdpbm5lciBTdW5YaSBib2FyZHMgYXJlIGFs bCBzdXBwb3J0ZWQuIFRoZSBzdWJzdGFudGlhbGx5IGltcHJvdmVkIG11bHRpcGxhdGZvcm0gY2Fw YWJpbGl0aWVzIG9mIHRoZSBoeXBlcnZpc29yIGFsbG93IGhhcmR3YXJlIGFuZCBlbWJlZGRlZCB2 ZW5kb3JzIHRvIHBvcnQgdGhlIFhlbiBQcm9qZWN0IHRlY2hub2xvZ3kgdG8gbmV3IEFSTSBTb0Nz IGVhc2lseSwgc2hvcnRlbmluZyB0aGVpciB0aW1lIHRvIG1hcmtldC4NCg0KDQoNCkFkZGl0aW9u YWwgZW5oYW5jZW1lbnRzIGluIHRoaXMgcmVsZWFzZSBpbmNsdWRlZCA2NC1iaXQgZ3Vlc3Qgc3Vw cG9ydCBvbiBBUk12OCBwbGF0Zm9ybXMuIEFsbCB0aGUgdXNlcnNwYWNlIHRvb2xzLCBzdWNoIGFz IHRoZSB4bCBtYW5hZ2VtZW50IHRvb2wsIGFyZSA2NC1iaXQgcmVhZHkgYW5kIGNhbiBiZSB1c2Vk IHRvIGNyZWF0ZSA2NC1iaXQgdmlydHVhbCBtYWNoaW5lcyBvdXQgb2YgdGhlIGJveC4NCg0KDQoN ClRoZSBYZW4gUHJvamVjdCBoeXBlcmNhbGwgQUJJIGlzIG5vdyBzdGFibGUgYW5kIHdpbGwgYmUg bWFpbnRhaW5lZCBmb3IgYmFja3dhcmQgY29tcGF0aWJpbGl0eSwgc28gdXNlcnMgY2FuIHRydXN0 IGZ1dHVyZSByZWxlYXNlcyB0byBib290IG9sZGVyIG9wZXJhdGluZyBzeXN0ZW1zLg0KDQpBZGRp dGlvbmFsIGltcHJvdmVtZW50cyBpbmNsdWRlIGV4dGVuZGVkIHN1cHBvcnQgZm9yIEFSTSBzcGVj aWZpYyBib290bG9hZGVycyBhbmQgZmlybXdhcmUgaW50ZXJmYWNlcywgYW5kIHN1cHBvcnQgZm9y IHBoeXNpY2FsIHBhcnRpdGlvbnMgYW5kIExWTSB2b2x1bWVzIHRvIHN0b3JlIGRpc2tzIG9mIHZp cnR1YWwgbWFjaGluZXMuDQoNCg0KDQpJbXByb3ZlZCBFdmVudCBDaGFubmVsIFNjYWxhYmlsaXR5 IEZvciBDbG91ZCBDb21wdXRpbmcNCg0KWGVuIFByb2plY3QgZGV2ZWxvcGVycyBjb250aW51ZXMg dG8gZHJpdmUgaW5ub3ZhdGlvbiBhbmQgY29sbGFib3JhdGlvbiBhcm91bmQgc2VydmVyIHZpcnR1 YWxpemF0aW9uIGFuZCB0aGUgY2xvdWQuIFBvd2VyaW5nIG1hbnkgb2YgdGhlIGxhcmdlc3QgY2xv dWRzIGluIHByb2R1Y3Rpb24gdG9kYXksIGluY2x1ZGluZyBBbWF6b24gRUMyLCBSYWNrc3BhY2Ug Q2xvdWQgYW5kIG90aGVycywgdGhlIGNvbW11bml0eSB1bmRlcnN0YW5kcyB0aGUgbmVlZCB0byBy dW4gbW9yZSB2aXJ0dWFsIG1hY2hpbmVzIG9uIGEgc2luZ2xlIGhvc3QuDQoNCllldCBkZW1hbmRz IG9uIGh5cGVydmlzb3Igc2NhbGFiaWxpdHkgY29udGludWUgdG8gaW5jcmVhc2UsIGJvdGggZnJv bSBsYXJnZXIgbWFjaGluZXMsIG5ldyB3b3JrbG9hZHMgc3VjaCBhcyB2aXJ0dWFsaXphdGlvbiBk ZXNrdG9wIGluZnJhc3RydWN0dXJlcyAoVkRJKSBhbmQgbmV3IGNsb3VkIE9TIHRlY2hub2xvZ2ll cywgaW5jbHVkaW5nIE1pcmFnZU9TLCBFcmxhbmdPblhlbiwgT1N2LCBhbmQgSGFsVk0uIFJlY29n bml6aW5nIHRoYXQgaGlnaC1hdmFpbGFiaWxpdHkgYW5kIHN0YWJpbGl0eSBhcmUgY3JpdGljYWwg dG8gVkRJcyBhbmQgY2xvdWQgZGVwbG95bWVudHM7IHRoZSBYZW5TZXJ2ZXIgdGVhbSBhdCBDaXRy aXggY29udHJpYnV0ZWQgdGhlIG5ldyBldmVudCBjaGFubmVsIGltcGxlbWVudGF0aW9uIHRvIHRo ZSBYZW4gUHJvamVjdC4gVG8gaGVscCBlbGltaW5hdGUgd29ya2xvYWQgbGltaXRhdGlvbnMgZm9y IHVzZXJzLCB0aGlzIGVuYWJsZXMgdGhlIGh5cGVydmlzb3IgdG8gcnVuIHRob3VzYW5kcyBvZiBn dWVzdHMgb24gYSBzaW5nbGUgcGh5c2ljYWwgbWFjaGluZS4NCg0KRXhwZXJpbWVudGFsIFN1cHBv cnQgZm9yIFBWSCBNb2RlIGZvciBHdWVzdA0KDQpPcmFjbGUgaGFzIGNvbnRyaWJ1dGVkIGEgZnVu Y3Rpb25hbCBwcmV2aWV3IG9mIGEgbmV3IHZpcnR1YWxpemF0aW9uIG1vZGUgY2FsbGVkIFBWSCBj dXJyZW50bHkgYXZhaWxhYmxlIHRvIHZpcnR1YWxpemVkIGd1ZXN0cy4gPGh0dHA6Ly9ibG9nLnhl bi5vcmcvaW5kZXgucGhwLzIwMTQvMDEvMzEvbGludXgtMy0xNC1hbmQtcHZoLz4gUFZIIGlzIGFu IGV4dGVuc2lvbiB0byB0aGUgY2xhc3NpYyBYZW4gUHJvamVjdCBQYXJhdmlydHVhbGl6YXRpb24g KFBWKSB0aGF0IHVzZXMgdGhlIGhhcmR3YXJlIHZpcnR1YWxpemF0aW9uIGV4dGVuc2lvbnMgYXZh aWxhYmxlIG9uIG1vZGVybiB4ODYgcHJvY2Vzc29ycy4gUFZIIHVzZXMgUFYgZHJpdmVycyBmb3Ig Ym9vdCBhbmQgSS9PIGFuZCBJbnRlbCBoYXJkd2FyZSB2aXJ0dWFsaXphdGlvbiBleHRlbnNpb25z IGZvciBwYWdlIHRhYmxlIG9wZXJhdGlvbnMsIHN5c3RlbSBjYWxscyBhbmQgb3RoZXIgcHJpdmls ZWdlZCBvcGVyYXRpb25zLiBUaGlzIG5vdCBvbmx5IGltcHJvdmVzIHBlcmZvcm1hbmNlIGFuZCBz ZWN1cml0eSwgYnV0IGFsc28gc2ltcGxpZmllcyB0aGUgYXJjaGl0ZWN0dXJlIGFuZCBYZW4gUHJv amVjdCBIeXBlcnZpc29yLUxpbnV4IGludGVyZmFjZSBzaWduaWZpY2FudGx5Lg0KDQo/Py9zcGFu PlBWSCBpcyBhIG1ham9yIGRldmVsb3BtZW50IGZvciBYZW4gUHJvamVjdCBzb2Z0d2FyZSBvbiB4 ODYgYW5kIGhhcyB0aGUgcG90ZW50aWFsIHRvIGdyZWF0bHkgc2ltcGxpZnkgdGhlIExpbnV4IGlu dGVyZmFjZSBpbiBkdWUgdGltZSwgPz8gc2FpZCBLb25yYWQgUnplc3p1dGVrIFdpbGssIFNvZnR3 YXJlIERldmVsb3BtZW50IE1hbmFnZXIgYXQgT3JhY2xlLCBhIFhlbiBQcm9qZWN0IGFkdmlzb3J5 IGJvYXJkIG1lbWJlci4gPz8vc3Bhbj5XZSBleHBlY3QgUFZIIHRvIGhhdmUgdGhlIGJlc3QgY2hh cmFjdGVyaXN0aWNzIG9mIGFsbCB2aXJ0dWFsaXphdGlvbiBtb2RlcyAtLSBhIHNpbXBsZSwgZmFz dCwgc2VjdXJlIGludGVyZmFjZSwgd2l0aCBsb3cgbWVtb3J5IG92ZXJoZWFkLCB0aGF0IGFsc28g dGFrZXMgZnVsbCBhZHZhbnRhZ2Ugb2YgdGhlIGxhdGVzdCBoYXJkd2FyZS4/Py9zcGFuPg0KDQoN Cg0KQWRkaXRpb25hbCBrZXkgdXBkYXRlcyBpbmNsdWRlOg0KDQrvv73vv70gICAgIEJldHRlciBw ZXJmb3JtYW5jZSB3aXRoIG1vZGVybiBzdG9yYWdlIGRldmljZXMgYW5kIGJpZyBkYXRhIC0tIElu ZGlyZWN0IGRlc2NyaXB0b3JzIGZvciBibG9jayBQViBwcm90b2NvbCAoTGludXgpIGFsbG93IGVh Y2ggaW5kaXZpZHVhbCByZXF1ZXN0IHRvIHRyaXBsZSBpbiBzaXplLCBncmVhdGx5IGltcHJvdmlu ZyBJL08gcGVyZm9ybWFuY2Ugd2hlbiBydW5uaW5nIG9uIGZhc3Qgc3RvcmFnZSB0ZWNobm9sb2dp ZXMgc3VjaCBhcyBzb2xpZC1zdGF0ZSBkcml2ZSBhbmQgUkFJRC4gQXZhaWxhYmxlIGluIGFueSBn dWVzdCBydW5uaW5nIExpbnV4IDMuMTEgb3IgaGlnaGVyIChyZWdhcmRsZXNzIG9mIFhlbiBQcm9q ZWN0IHZlcnNpb24pLg0KDQoNCg0K77+977+9ICAgICBNb3JlIHBvd2VyZnVsIGRyaXZlciBkb21h aW5zIC0tIERpc2sgZHJpdmVyIGRvbWFpbnMgY2FuIG5vdyB1bmlmb3JtbHkgcnVuIGJsb2NrIHNj cmlwdHMgYW5kIHVzZXItc3BhY2UgYmFja2VuZHMsIHN1Y2ggYXMgcWRpc2ssIGJyaW5naW5nIHRo ZW0gdXAgdG8gZmVhdHVyZSBwYXJpdHkgd2l0aCBkb21haW4gMC4gVGhpcyBtZWFucyBob3N0IGFk bWluaXN0cmF0b3JzIGNhbiB0YWtlIGFkdmFudGFnZSBvZiB0aGUgZW5oYW5jZWQgc2VjdXJpdHks IHNjYWxhYmlsaXR5LCBhbmQgcm9idXN0bmVzcyBwcm92aWRlZCBieSBkcml2ZXIgZG9tYWlucyB3 aXRob3V0IHNhY3JpZmljaW5nIHRoZSB3aWRlIGFycmF5IG9mIGRpc2sgY29uZmlndXJhdGlvbiBv cHRpb25zIHByb3ZpZGVkIGJ5IFhlbiBpbiBkb20wLg0KDQrvv73vv70gICAgIE5ldyBTUElDRSBw cm90b2NvbCBzdXBwb3J0IC0tIEZ1bmN0aW9uYWxpdHkgc3VjaCBhcyBjbGlwYm9hcmQgc2hhcmlu ZyBhbmQgVVNCIHJlZGlyZWN0aW9uIGNyZWF0ZXMgYSBtdWNoIHJpY2hlciBjb25uZWN0aW9uIGZv ciB2aXJ0dWFsIGRlc2t0b3BzIGFuZCBiZXR0ZXIgZ3JhcGhpY3MgcGVyZm9ybWFuY2UuDQoNCu+/ ve+/vSAgICAgRW5oYW5jZWQgZGlhZ25vc3RpY3MgYW5kIGtleGVjIGRlYnVnIHN1cHBvcnQgLS0g V2hlbiBhIGNyYXNoIGhhcHBlbnMsIGEgc3BlY2lhbCBrZXJuZWwgaXMgYWxsb3dlZCBpbW1lZGlh dGUgdG8gY29sbGVjdCBpbmZvcm1hdGlvbiBhYm91dCB0aGUgcm9vdCBjYXVzZSwgb2ZmZXJpbmcg ZGV2ZWxvcGVycyBiZXR0ZXIgZGlhZ25vc2lzIGFuZCByZXBhaXIgYWJpbGl0aWVzLg0KDQpUaGUg NC40IHJlbGVhc2UgaXMgdGhlIHJlc3VsdCBvZiBhIGJyb2FkLCBjb2xsYWJvcmF0aXZlIGRldmVs b3BtZW50IGVmZm9ydCByZXByZXNlbnRpbmcgZW5naW5lZXJzIGZyb20gbW9yZSB0aGFuIDEzIGxl YWRpbmcgaGFyZHdhcmUsIHNvZnR3YXJlIGFuZCBzZWN1cml0eSB2ZW5kb3JzLiBUb3AgY29udHJp YnV0b3JzIGluY2x1ZGUgQW1hem9uLCBBTUQsIEFuYWxvZyBEZXZpY2VzLCBCcm9hZGNvbSwgQ2l0 cml4LCBGdWppdHN1LCBJbnRlbCwgTGluYXJvLCBOU0EsIE9yYWNsZSwgU3VzZSwgVmVyaXpvbi9U ZXJyZW1hcmssIHBsdXMgbnVtZXJvdXMgaW5kaXZpZHVhbCBhbmQgYWNhZGVtaWMgY29udHJpYnV0 b3JzLiBUaGUgZnJlZWx5IGF2YWlsYWJsZSBkb3dubG9hZCBjYW4gYmUgZm91bmQgb24gdGhlIFhl blByb2plY3Qub3JnPGh0dHA6Ly9YZW5Qcm9qZWN0Lm9yZz4gd2Vic2l0ZSAoaW5zZXJ0IHVybCku DQoNCg0KDQpBYm91dCBYZW4gUHJvamVjdA0KDQpUaGUgWGVuIFByb2plY3Qgc29mdHdhcmUgaXMg YW4gb3BlbiBzb3VyY2UgdmlydHVhbGl6YXRpb24gcGxhdGZvcm0gbGljZW5zZWQgdW5kZXIgdGhl IEdQTHYyIHdpdGggYSBzaW1pbGFyIGdvdmVybmFuY2Ugc3RydWN0dXJlIHRvIHRoZSBMaW51eCBr ZXJuZWwuIERlc2lnbmVkIGZyb20gdGhlIHN0YXJ0IGZvciBjbG91ZCBjb21wdXRpbmcsIHRoZSBQ cm9qZWN0IGhhcyBtb3JlIHRoYW4gYSBkZWNhZGUgb2YgZGV2ZWxvcG1lbnQgYW5kIGlzIGJlaW5n IHVzZWQgYnkgbW9yZSB0aGFuIDEwIG1pbGxpb24gdXNlcnMuIEEgQ29sbGFib3JhdGl2ZSBQcm9q ZWN0IGF0IFRoZSBMaW51eCBGb3VuZGF0aW9uLCB0aGUgWGVuIFByb2plY3QgdGVhbSBpcyBmb2N1 c2VkIG9uIGFkdmFuY2luZyB2aXJ0dWFsaXphdGlvbiBpbiBhIG51bWJlciBvZiBkaWZmZXJlbnQg Y29tbWVyY2lhbCBhbmQgb3BlbiBzb3VyY2UgYXBwbGljYXRpb25zIGluY2x1ZGluZyBzZXJ2ZXIg dmlydHVhbGl6YXRpb24sIEluZnJhc3RydWN0dXJlIGFzIGEgU2VydmljZSAoSWFhUyksIGRlc2t0 b3AgdmlydHVhbGl6YXRpb24sIHNlY3VyaXR5IGFwcGxpY2F0aW9ucywgZW1iZWRkZWQgYW5kIGhh cmR3YXJlIGFwcGxpYW5jZXMuIEl0IGNvdW50cyBtYW55IGluZHVzdHJ5IGFuZCBvcGVuIHNvdXJj ZSBjb21tdW5pdHkgbGVhZGVycyBhbW9uZyBpdHMgbWVtYmVycyBpbmNsdWRpbmc6IEFtYXpvbiBX ZWIgU2VydmljZXMsIEFNRCwgQVJNLCBCcm9taXVtLCBDYWx4ZWRhLCBDQSBUZWNobm9sb2dpZXMs IENpc2NvLCBDaXRyaXgsIEdvb2dsZSwgSW50ZWwsIE9yYWNsZSwgU2Ftc3VuZyBhbmQgVmVyaXpv bi4gRm9yIG1vcmUgaW5mb3JtYXRpb24gYWJvdXQgdGhlIFhlbiBQcm9qZWN0IGh5cGVydmlzb3Ig YW5kIHRvIHBhcnRpY2lwYXRlLCBwbGVhc2UgdmlzaXQgaHR0cDovL3hlbnByb2plY3QuPGh0dHA6 Ly94ZW5wcm9qZWN0Lm9yZy8+b3JnPGh0dHA6Ly94ZW5wcm9qZWN0Lm9yZy8+Lg0KDQojIyMNCg0K U2FyYWggQ29ud2F5DQoNClRoZSBYZW4gUHJvamVjdA0KDQpNZWRpYSBDb250YWN0DQoNCnB1Ymxp Y2l0eUBsaXN0cy54ZW5wcm9qZWN0Lm9yZzxtYWlsdG86cHVibGljaXR5QGxpc3RzLnhlbnByb2pl Y3Qub3JnPg0KDQoNCk9uIE1hciA2LCAyMDE0LCBhdCAxMjo0NCBQTSwgV2lsc29uLCBNYXR0IDxt c3dAYW1hem9uLmNvbTxtYWlsdG86bXN3QGFtYXpvbi5jb20+PiB3cm90ZToNCg0KTWFyaywgdGhv dWdodHM/DQoNCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fDQpGcm9tOiBXaWxzb24s IE1hdHQNClNlbnQ6IFdlZG5lc2RheSwgTWFyY2ggMDUsIDIwMTQgMTA6MDEgQU0NClRvOiBBZHZp c29yeS1ib2FyZCBkaXNjdXNzaW9ucw0KU3ViamVjdDogUkU6IFtBZHZpc29yeS1ib2FyZF0gWGVu IFByb2plY3QgNC40IFJlbGVhc2UNCg0KSSdkIHJhdGhlciB1c2UgIlhlbiBQcm9qZWN0IEh5cGVy dmlzb3IiIHRoYW4gaW50cm9kdWNlIGFuIGFjcm9ueW0uIEkgdGhpbmsgaXQncyBpbXBvcnRhbnQg dGhhdCAiWGVuIFByb2plY3QiIG5vdCBiZSBzcGxpdCBmcm9tICJIeXBlcnZpc29yLiINCg0KVGhp cyBzdGlsbCBkb2Vzbid0IGFkZHJlc3MgaG93IHRoZSB1bWJyZWxsYSBwcm9qZWN0IGlzIGNhbGxl ZC4gVGhpcyBuZXcgcmVsZWFzZSBkb2Vzbid0IG9ubHkgaW5jbHVkZSB0aGUgaHlwZXJ2aXNvciwg YnV0IGFsc28gdGhlIGFzc29jaWF0ZWQgdG9vbHN0YWNrIGFuZCB1dGlsaXRpZXMuIE1heWJlIHdl J3JlIE9LIGNhbGxpbmcgYWxsIG9mIHRoYXQgdGhlICJIeXBlcnZpc29yLCIgZXZlbiBpZiB3ZSBp ZGVudGlmeSB0aGUgZGV2ZWxvcG1lbnQgdGVhbXMgZGlmZmVyZW50bHkuDQoNCkhvdyBzaG91bGQg d2UgcmUtYWxpZ24gYWxsIG9mIHRoZSBicmFuZGluZz8gRm9yIGV4YW1wbGU6IGh0dHA6Ly94ZW5w cm9qZWN0Lm9yZy9kZXZlbG9wZXJzL3RlYW1zL2h5cGVydmlzb3IuaHRtbA0KDQpTaG91bGQgdGhl IGxpbmtzIHVuZGVyICJIeXBlcnZpc29yIERvd25sb2FkcyIgYmUgInZlcnNpb24gNC4zLjEiIGlu c3RlYWQgb2YgIlhlbiA0LjMuMSIgdG8gcmVzb2x2ZSB0aGUgdHJhZGVtYXJrIGNvbmNlcm5zPw0K DQotLW1zdw0KDQpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXw0KRnJvbTogYWR2aXNv cnktYm9hcmQtYm91bmNlc0BsaXN0cy54ZW5wcm9qZWN0Lm9yZzxtYWlsdG86YWR2aXNvcnktYm9h cmQtYm91bmNlc0BsaXN0cy54ZW5wcm9qZWN0Lm9yZz4gW2Fkdmlzb3J5LWJvYXJkLWJvdW5jZXNA bGlzdHMueGVucHJvamVjdC5vcmc8bWFpbHRvOmFkdmlzb3J5LWJvYXJkLWJvdW5jZXNAbGlzdHMu eGVucHJvamVjdC5vcmc+XSBvbiBiZWhhbGYgb2YgU2FyYWggQ29ud2F5IFtzY29ud2F5QGxpbnV4 Zm91bmRhdGlvbi5vcmc8bWFpbHRvOnNjb253YXlAbGludXhmb3VuZGF0aW9uLm9yZz5dDQpTZW50 OiBXZWRuZXNkYXksIE1hcmNoIDA1LCAyMDE0IDk6MzMgQU0NClRvOiBBZHZpc29yeS1ib2FyZCBk aXNjdXNzaW9ucw0KU3ViamVjdDogUmU6IFtBZHZpc29yeS1ib2FyZF0gWGVuIFByb2plY3QgNC40 IFJlbGVhc2UNCg0KTWFyayBldCBhbGwsDQoNCkkgYWdyZWUgdGhhdCB1c2luZyBYZW4gUHJvamVj dCBpcyBhIG1vdXRoZnVsLiBHaXZlbiB0aGF0IHRoZXJlIGlzIGNsb3NlIG92ZXJsYXAgYW5kIG9j Y2FzaW9uYWwgYnJhbmRpbmcgY29uZnVzaW9uIHdpdGggQ2l0cml4IHByb2R1Y3RzLCBpZiB3ZSBh ZGQgYW5vdGhlciBuZXcgdGVybSBvciBhY3JvbnltIGludG8gdGhlIG1peCwgd2UnbGwgd2FudCB0 byBiZSBkaWxpZ2VudCBhYm91dCBiZWluZyBjb25zaXN0ZW50IGluIGJsb2dzLCBwcmVzZW50YXRp b25zLCBuZXdzIHJlbGVhc2VzLCB3ZWIgc2l0ZSBjb3B5LCBjdXN0b21lciB0ZXN0aW1vbmlhbHMg ZXRjLg0KDQpGb3IgdGhlIHNha2Ugb2Ygc2ltcGxpY2l0eSwgaG93IGFib3V0IHVzaW5nIFhQSCAt IGFsbCB1cHBlcmNhc2UgLSBvbiBzZWNvbmQgcmVmZXJlbmNlPyBUaG91Z2h0cz8NCg0KVGhhbmtz LA0KDQoNCg0KDQoNCg0KT24gV2VkLCBNYXIgNSwgMjAxNCBhdCA5OjE4IEFNLCBNYXJrIEhpbmts ZSA8TWFyay5IaW5rbGVAY2l0cml4LmNvbTxtYWlsdG86TWFyay5IaW5rbGVAY2l0cml4LmNvbT4+ IHdyb3RlOg0KSG93IGFib3V0IHRoaXMgY29udmVudGlvbiBvbmx5IHNheSBYZW4gUHJvamVjdCBh bmQgWGVuIFByb2plY3QgaHlwZXJ2aXNvciBvbmNlIHRoZW4uIFVzZSB0aGUgYWJicmV2aWF0aW9u IFhQaCB0aHJvdWdob3V0IHRoZSByZWxlYXNlLiBKdXN0IHNuaXBwaW5nIE1hdHQ/PyBleGFtcGxl IHRvIG1ha2UgdGhlIHBvaW50LiBJIHdvdWxkIGd1ZXNzIHRoYXQgdGhlIGFwcHJvcHJpYXRlIGNh cGl0YWxpemF0aW9uIHdvdWxkIGJlIGxvd2VyIGNhc2UgZm9yIHRoZSB3b3JkIGh5cGVydmlzb3Iu DQoNCk1hcmsNCg0KDQpUaGUgWGVuIFByb2plY3QsIGEgQ29sbGFib3JhdGl2ZSBQcm9qZWN0IGhv c3RlZCBhdCBUaGUgTGludXggRm91bmRhdGlvbiwgdG9kYXkgYW5ub3VuY2VkIGF2YWlsYWJpbGl0 eSBvZiB0aGUgWGVuIFByb2plY3QgaHlwZXJ2aXNvcihYUGgpIDQuNCB3aXRoIGVuaGFuY2VkIEFS TSBzdXBwb3J0Lg0KDQpYUGggNC40IGZ1cnRoZXIgYWR2YW5jZXMgdGhlIFByb2plY3Q/Py9zcGFu PnMgcG9zaXRpb24gYXMgYSBmYXN0LCBzY2FsYWJsZSwgc2VjdXJlIHZpcnR1YWxpemF0aW9uIGVu Z2luZSBmb3IgdGhlIGluZHVzdHJ5Pz8vc3Bhbj5zIGJyb2FkZXN0IHJhbmdlIG9mIHNlcnZlciwg UEMgY2hpcHNldHMgYW5kIG5leHQtZ2VuZXJhdGlvbiBsb3ctcG93ZXIgc3lzdGVtcyBvbiBjaGlw cyAoU29DKS4NCg0KT24gTWFyIDQsIDIwMTQsIGF0IDQ6MDEgUE0sIFdpbHNvbiwgTWF0dCA8bXN3 QGFtYXpvbi5jb208bWFpbHRvOm1zd0BhbWF6b24uY29tPj4gd3JvdGU6DQoNClRoZSAiWGVuIFBy b2plY3QiIHRlcm1pbm9sb2d5IG1ha2VzIHRoZSBtZXNzYWdlIGV4dHJlbWVseSBjdW1iZXJzb21l Lg0KDQoNClRoZSBYZW4gUHJvamVjdCwgYSBDb2xsYWJvcmF0aXZlIFByb2plY3QgaG9zdGVkIGF0 IFRoZSBMaW51eCBGb3VuZGF0aW9uLCB0b2RheSBhbm5vdW5jZWQgYXZhaWxhYmlsaXR5IG9mIHRo ZSBYZW4gUHJvamVjdCA0LjQgSHlwZXJ2aXNvciB3aXRoIGVuaGFuY2VkIFhlbiBQcm9qZWN0LW9u LUFSTSBzdXBwb3J0Lg0KDQpXaHkgbm90IGp1c3Qgc2F5ICJlbmhhbmNlZCBBUk0gc3VwcG9ydCI/ IFdlIHNob3VsZCBhZG9wdCBzb21lIHVzYWdlIGd1aWRlbGluZXMgZm9yIHN1Yi1wcm9qZWN0IGJy YW5kaW5nLiBXZSBzaG91bGRuJ3QgaW5zZXJ0IHdvcmRzL251bWJlcnMgYmV0d2VlbiAiWGVuIFBy b2plY3QiIGFuZCBhIHN1Yi1wcm9qZWN0IG5hbWUuDQoNClRoZSBYZW4gUHJvamVjdCwgYSBDb2xs YWJvcmF0aXZlIFByb2plY3QgaG9zdGVkIGF0IFRoZSBMaW51eCBGb3VuZGF0aW9uLCB0b2RheSBh bm5vdW5jZWQgdmVyc2lvbiA0LjQgb2YgdGhlIFhlbiBQcm9qZWN0IEh5cGVydmlzb3Igd2l0aCBl bmhhbmNlZCBBUk0gc3VwcG9ydC4NCg0Kb3INClRoZSBYZW4gUHJvamVjdCwgYSBDb2xsYWJvcmF0 aXZlIFByb2plY3QgaG9zdGVkIGF0IFRoZSBMaW51eCBGb3VuZGF0aW9uLCB0b2RheSBhbm5vdW5j ZWQgdGhlIHJlbGVhc2Ugb2YgWGVuIFByb2plY3QgSHlwZXJ2aXNvciA0LjQgd2l0aCBlbmhhbmNl ZCBBUk0gc3VwcG9ydC4NCg0KTGF0ZXIgb24sIHRoaXMgcmVsZWFzZSBpcyBjYWxsZWQgIlhlbiBQ cm9qZWN0IDQuNCINCg0KDQpUaGUgWGVuIFByb2plY3QgNC40IHJlbGVhc2UgZnVydGhlciBhZHZh bmNlcyB0aGUgUHJvamVjdD8/L3NwYW4+cyBwb3NpdGlvbiBhcyBhIGZhc3QsIHNjYWxhYmxlLCBz ZWN1cmUgdmlydHVhbGl6YXRpb24gZW5naW5lIGZvciB0aGUgaW5kdXN0cnk/Py9zcGFuPnMgYnJv YWRlc3QgcmFuZ2Ugb2Ygc2VydmVyLCBQQyBjaGlwc2V0cyBhbmQgbmV4dC1nZW5lcmF0aW9uIGxv dy1wb3dlciBzeXN0ZW1zIG9uIGNoaXBzIChTb0MpLg0KDQpUaGF0IGRvZXNuJ3QgZmxvdyB3ZWxs LiBIb3cgYXJlIHdlIHJlbGVhc2luZyB2ZXJzaW9uIDQuNCBvZiBhIHByb2plY3Q/IERvIHdlIHdh bnQgdG8gY2FsbCB0aGUgb3ZlcmFsbCByZWxlYXNlICJYZW4gUHJvamVjdCBBcmNoaXRlY3R1cmUg NC40Ij8gT3IgZG8gd2UgbmVlZCB0byBjb21lIHVwIHdpdGggc29tZSBvdGhlciBwcm9qZWN0IGJy YW5kaW5nPw0KDQotLW1zdw0KDQpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXw0KRnJv bTogYWR2aXNvcnktYm9hcmQtYm91bmNlc0BsaXN0cy54ZW5wcm9qZWN0Lm9yZzxtYWlsdG86YWR2 aXNvcnktYm9hcmQtYm91bmNlc0BsaXN0cy54ZW5wcm9qZWN0Lm9yZz4gW2Fkdmlzb3J5LWJvYXJk LWJvdW5jZXNAbGlzdHMueGVucHJvamVjdC5vcmc8bWFpbHRvOmFkdmlzb3J5LWJvYXJkLWJvdW5j ZXNAbGlzdHMueGVucHJvamVjdC5vcmc+XSBvbiBiZWhhbGYgb2YgU2FyYWggQ29ud2F5IFtzY29u d2F5QGxpbnV4Zm91bmRhdGlvbi5vcmc8bWFpbHRvOnNjb253YXlAbGludXhmb3VuZGF0aW9uLm9y Zz5dDQpTZW50OiBUdWVzZGF5LCBNYXJjaCAwNCwgMjAxNCAxMjoxNiBQTQ0KDQpUbzogYWR2aXNv cnktYm9hcmRAbGlzdHMueGVucHJvamVjdC5vcmc8bWFpbHRvOmFkdmlzb3J5LWJvYXJkQGxpc3Rz LnhlbnByb2plY3Qub3JnPg0KU3ViamVjdDogW0Fkdmlzb3J5LWJvYXJkXSBYZW4gUHJvamVjdCA0 LjQgUmVsZWFzZQ0KDQpIaSBldmVyeW9uZS4NCg0KQXR0YWNoZWQgaXMgdGhlIFhlbiBQcm9qZWN0 IDQuNCBuZXdzIHJlbGVhc2UgYW5ub3VjZW1lbnQgdGhhdCB3aWxsIGdvIG91dCBhdCA4IGEubS4g RVQgb24gTW9uZGF5LCBNYXJjaCAxMC4NCg0KSWYgeW91IGhhdmUgYW55IGFkZGl0aW9uYWwgY29t bWVudHMgb3IgZWRpdHMsIHBsZWFzZSBnZXQgYmFjayB0byBtZSBieSBUaHVyc2RheSBtb3JuaW5n IGF0IHRoZSBsYXRlc3QuDQoNClRoYW5rcywNCg0KDQotLQ0KU2FyYWggQ29ud2F5DQpQUiBNYW5h Z2VyDQpUaGUgTGludXggRm91bmRhdGlvbg0Kc2NvbndheUBsaW51eGZvdW5kYXRpb24ub3JnPG1h aWx0bzpzY29ud2F5QGxpbnV4Zm91bmRhdGlvbi5vcmc+DQooOTc4KSA1NzgtNTMwMDx0ZWw6JTI4 OTc4JTI5JTIwNTc4LTUzMDA+ICBDZWxsDQpTa3lwZTogIHNhcmFoLmsuY29ud2F5DQpfX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXw0KQWR2aXNvcnktYm9hcmQg bWFpbGluZyBsaXN0DQpBZHZpc29yeS1ib2FyZEBsaXN0cy54ZW5wcm9qZWN0Lm9yZzxtYWlsdG86 QWR2aXNvcnktYm9hcmRAbGlzdHMueGVucHJvamVjdC5vcmc+DQpodHRwOi8vbGlzdHMueGVucHJv amVjdC5vcmcvY2dpLWJpbi9tYWlsbWFuL2xpc3RpbmZvL2Fkdmlzb3J5LWJvYXJkDQoNCg0KX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18NCkFkdmlzb3J5LWJv YXJkIG1haWxpbmcgbGlzdA0KQWR2aXNvcnktYm9hcmRAbGlzdHMueGVucHJvamVjdC5vcmc8bWFp bHRvOkFkdmlzb3J5LWJvYXJkQGxpc3RzLnhlbnByb2plY3Qub3JnPg0KaHR0cDovL2xpc3RzLnhl bnByb2plY3Qub3JnL2NnaS1iaW4vbWFpbG1hbi9saXN0aW5mby9hZHZpc29yeS1ib2FyZA0KDQoN Cg0KDQotLQ0KU2FyYWggQ29ud2F5DQpQUiBNYW5hZ2VyDQpUaGUgTGludXggRm91bmRhdGlvbg0K c2NvbndheUBsaW51eGZvdW5kYXRpb24ub3JnPG1haWx0bzpzY29ud2F5QGxpbnV4Zm91bmRhdGlv bi5vcmc+DQooOTc4KSA1NzgtNTMwMCAgQ2VsbA0KU2t5cGU6ICBzYXJhaC5rLmNvbndheQ0KX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18NCkFkdmlzb3J5LWJv YXJkIG1haWxpbmcgbGlzdA0KQWR2aXNvcnktYm9hcmRAbGlzdHMueGVucHJvamVjdC5vcmc8bWFp bHRvOkFkdmlzb3J5LWJvYXJkQGxpc3RzLnhlbnByb2plY3Qub3JnPg0KaHR0cDovL2xpc3RzLnhl bnByb2plY3Qub3JnL2NnaS1iaW4vbWFpbG1hbi9saXN0aW5mby9hZHZpc29yeS1ib2FyZA0KDQoN Ci0tIElNUE9SVEFOVCBOT1RJQ0U6IFRoZSBjb250ZW50cyBvZiB0aGlzIGVtYWlsIGFuZCBhbnkg YXR0YWNobWVudHMgYXJlIGNvbmZpZGVudGlhbCBhbmQgbWF5IGFsc28gYmUgcHJpdmlsZWdlZC4g SWYgeW91IGFyZSBub3QgdGhlIGludGVuZGVkIHJlY2lwaWVudCwgcGxlYXNlIG5vdGlmeSB0aGUg c2VuZGVyIGltbWVkaWF0ZWx5IGFuZCBkbyBub3QgZGlzY2xvc2UgdGhlIGNvbnRlbnRzIHRvIGFu eSBvdGhlciBwZXJzb24sIHVzZSBpdCBmb3IgYW55IHB1cnBvc2UsIG9yIHN0b3JlIG9yIGNvcHkg dGhlIGluZm9ybWF0aW9uIGluIGFueSBtZWRpdW0uIFRoYW5rIHlvdS4NCg0KQVJNIExpbWl0ZWQs IFJlZ2lzdGVyZWQgb2ZmaWNlIDExMCBGdWxib3VybiBSb2FkLCBDYW1icmlkZ2UgQ0IxIDlOSiwg UmVnaXN0ZXJlZCBpbiBFbmdsYW5kICYgV2FsZXMsIENvbXBhbnkgTm86IDI1NTc1OTANCkFSTSBI b2xkaW5ncyBwbGMsIFJlZ2lzdGVyZWQgb2ZmaWNlIDExMCBGdWxib3VybiBSb2FkLCBDYW1icmlk Z2UgQ0IxIDlOSiwgUmVnaXN0ZXJlZCBpbiBFbmdsYW5kICYgV2FsZXMsIENvbXBhbnkgTm86IDI1 NDg3ODINCg== --_000_CF3F6FFA248DDrichardphelanarmcom_ Content-Type: text/html; charset=BIG5 Content-Transfer-Encoding: quoted-printable
Hi,

I agree with Mark as the current press release is highlighting issues = that seem to make the articulation of brand and brand values more cumbersom= e than is desirable.

I'm happy to go with the proposed changes for the reasons stated.

One minor point, I'd prefer "?=A6System on Chip (SoC) devices.&qu= ot;, two sets of plurals make it unclear how many systems are on each chip = and the plurals get submerged into the acronym; common usage seems to be So= Cs.

Thanks,

Richar= d.

From: Mark Hinkle <Mark.Hinkle@citrix.com>
Reply-To: Advisory-board discussion= s <advisory-board= @lists.xenproject.org>
Date: Friday, 7 March 2014 05:32 To: Advisory-board discussions <= advisory-board@lists= .xenproject.org>
Subject: Re: [Advisory-board] Xen P= roject 4.4 Release

My apologies for the slow reply I was stuck on the road and couldn?? read t= he release on my phone to formulate a proper response. I should move to a h= ighly elastic Xen Project-powered cloud that allows me to autoscale ;) (sor= ry bad cloud joke). 

I am fine without doing the acronym and I think the realigning and bra= nding discussion should be had. I?? like to have that discussion during our= next board meeting. Given time is of the essence I think we should just up= date the links to version versus Xen 4.3.1. 

Also I took a shot at the wording of the press release. It?? probably = not perfect but makes it read a bit better. Attached are my proposed edits.= Sarah, I sent you the word doc with track changes assuming we have some ed= its to agree on. 


Regards, Mark 

Xen Project Releases Update to Enterprise Hypervisor Software

Open Sou= rce Virtualization Software Release Includes Additional ARM Support and Sca= lability for Cloud and Mobile Environments 

&nb= sp;

SAN FRANCISCO, M= arch 10, 2014 ??/span> Xen Project, a = Collaborative Project hosted at The Linux Foundation, today announced avail= ability of the Xen Project 4.4 with enhanced ARM support. The latest releas= e also includes major performance and system scalability improvements for enterprise computing, such as mobi= le and cloud environments, where virtualization technology is increasingly = in demand.

This release further advances the Project??/span>s position as a fast, scalable, secure virtualization engine for the industr= y??/span>s broadest range of server, PC chipsets and next-generation low-power systems on chip= s (SoC).

Major contributions from AMD, Citrix, Intel, Oracle= and SUSE are pushing the Xen Project software to take advantage of the lat= est hardware. Additionally, developers creating services and apps with embedded, mobile and cloud systems will be= nefit from new features such as event channeling when scaling out their Inf= rastructure as a Service offerings.

??/span>Virtualization and low-powered servers a= re leading companies to rethink the data center and its potential for efficiency,??=0Asaid Lars Kurth, Chairman of the Xen Project advisory board. ??/span>Our sol= ution contains IT-related costs, plus meets the security and scalability ne= eds of today??/span>s elastic cloud, mobile and social networking companies. The latest updates = continue the Project??/span>s track record of rich collaboration and widespread development from many of= the world??/span>= s technology leaders. This certainly explains the significant growth of ARM = support, which we??/span>re pleased to see advance so quickly.??/span>

Support for ARM = on Xen Project Architecture Grows Quickly

The new release introduces significant stability, usabili= ty and performance improvements for the ARM architecture and extended hardw= are compatibility.  AppliedMicro??/span>s X-Gene, the Arndale Board, Calxeda ECX-2000, TI OMAP5 and the Allwinner Su= nXi boards are all supported. The substantially improved multiplatform capa= bilities of the hypervisor allow hardware and embedded vendors to port the = Xen Project technology to new ARM SoCs easily, shortening their time to market.

 

Additional enhancements in this release included 64-bit g= uest support on ARMv8 platforms. All the userspace tools, such as the xl ma= nagement tool, are 64-bit ready and can be used to create 64-bit virtual machines out of the box.

 

The Xen Project hypercall ABI is now stable and will be m= aintained for backward compatibility, so users can trust future releases to= boot older operating systems.=

Additional improvements include extended support for ARM = specific bootloaders and firmware interfaces, and support for physical part= itions and LVM volumes to store disks of virtual machines.

 

Improved Event C= hannel Scalability For Cloud Computing

Xen Project developers continues to drive innovatio= n and collaboration around server virtualization and the cloud. Powering ma= ny of the largest clouds in production today, including Amazon EC2, Rackspace Cloud and others, the community und= erstands the need to run more virtual machines on a single host.

Yet demands on hypervisor scalability continue to i= ncrease, both from larger machines, new workloads such as virtualization de= sktop infrastructures (VDI) and new cloud OS technologies, including MirageOS, ErlangOnXen, OSv, and HalVM. Recogniz= ing that high-availability and stability are critical to VDIs and cloud dep= loyments; the XenServer team at Citrix contributed the new event channel im= plementation to the Xen Project. To help eliminate workload limitations for users, this enables the hypervi= sor to run thousands of guests on a single physical machine.  &nb= sp;

Experimental Sup= port for PVH Mode for Guest

Oracle has contributed a functional preview of a new virtualization mode called PVH currently available to virtualized gue= sts. PVH is = an extension to the classic Xen Project Paravirtualization (PV) that uses t= he hardware virtualization extensions available on modern x86 processors. P= VH uses PV drivers for boot and I/O and Intel hardware virtualization extensions for page table operations, sy= stem calls and other privileged operations. This not only improves performa= nce and security, but also simplifies the architecture and Xen Project Hype= rvisor-Linux interface significantly.

??/span>PVH is a major development for Xen Project software on x86 and has the potenti= al to greatly simplify the Linux interface in due time, ??=0Asaid Konrad Rzeszutek Wilk, Software Development Manager = at Oracle, a Xen Project advisory board member. ??/span>We expect PVH to have the best characteristics of all virtualization modes -- a simple, = fast, secure interface, with low memory overhead, that also takes full adva= ntage of the latest hardware.??/span>

 

Additional key updates include:

=EF=BF=BD=EF=BF=BD     Bett= er performance with modern storage devices and big data -- Indirect descrip= tors for block PV protocol (Linux) allow each individual request to triple = in size, greatly improving I/O performance when running on fast storage technologies such as solid-state drive and RA= ID. Available in any guest running Linux 3.11 or higher (regardless of Xen = Project version).=

 

=EF=BF=BD=EF=BF=BD     More= powerful driver domains -- Disk= driver domains can now uniformly run block scripts and user-space backends= , such as qdisk, bringing them up to feature parity with domain 0. This mea= ns host administrators can take advantage of the enhanced security, scalability, and robustness provided by driver d= omains without sacrificing the wide array of disk configuration options pro= vided by Xen in dom0.

=EF=BF=BD=EF=BF=BD     New = SPICE protocol support -- Functionality such as clipboard sharing and USB r= edirection creates a much richer connection for virtual desktops and better= graphics performance.

=EF=BF=BD=EF=BF=BD     Enha= nced diagnostics and kexec debug support -- When a crash happens, a special= kernel is allowed immediate to collect information about the root cause, o= ffering developers better diagnosis and repair abilities. <= /span>

The 4.4 release is the r= esult of a broad, collaborative development effort representing engineers f= rom more than 13 leading hardware, software and security vendors. Top contr= ibutors include Amazon, AMD, Analog Devices, Broadcom, Citrix, Fujitsu, Intel, Linaro, NSA, Oracle, Suse, Veri= zon/Terremark, plus numerous individual and academic contributors. The free= ly available download can be found on the XenProject.org website (insert url).<= o:p>

 

About Xen Pro= ject

The Xen Project software is an open source virtuali= zation platform licensed under the GPLv2 with a similar governance structur= e to the Linux kernel. Designed from the start for cloud computing, the Project has more than a decade of developme= nt and is being used by more than 10 million users. A Collaborative Project= at The Linux Foundation, the Xen Project team is focused on advancing virt= ualization in a number of different commercial and open source applications including server virtualization, I= nfrastructure as a Service (IaaS), desktop virtualization, security applica= tions, embedded and hardware appliances. It counts many industry and open s= ource community leaders among its members including: Amazon Web Services, AMD, ARM, Bromium, Calxeda, CA Tec= hnologies, Cisco, Citrix, Google, Intel, Oracle, Samsung and Verizon. For m= ore information about the Xen Project hypervisor and to participate, please= visit http://xenproj= ect.org.

###

Sarah Conway

The Xen Project

Media Contact

p= ublicity@lists.xenproject.org



On Mar 6, 2014, at 12:44 PM, Wilson, Matt <msw@amazon.com> wrote:

Mark,= thoughts?

From: Wil= son, Matt
Sent: Wednesday, M= arch 05, 2014 10:01 AM
To: Advisory-board= discussions
Subject: RE: [Advi= sory-board] Xen Project 4.4 Release

I'd r= ather use "Xen Project Hypervisor" than introduce an acronym. I t= hink it's important that "Xen Project" not be split from "Hy= pervisor."

This still doesn't address how the umbrella project is called. This new rel= ease doesn't only include the hypervisor, but also the associated toolstack= and utilities. Maybe we're OK calling all of that the "Hypervisor,&qu= ot; even if we identify the development teams differently.

How should we re-align all of the branding? For example: http://xenproject.org/developers/teams/hyperv= isor.html

Should the links under "Hypervisor Downloads" be "versi= on 4.3.1" instead of "Xen 4.3.1" to resolve the trademark co= ncerns?

--msw

From: advisory-board-= bounces@lists.xenproject.org [advisory-board-bounces@lists.xenproject.org] on behalf of Sarah Conway [= sconway@linuxfoundation.org]
Sent: Wednesday, M= arch 05, 2014 9:33 AM
To: Advisory-board= discussions
Subject: Re: [Advi= sory-board] Xen Project 4.4 Release

Mark et all, 

I ag= ree that using Xen Project is a mouthful. Given that there is close overlap and occasional branding c= onfusion with Citrix products, if we add another new term or acronym=  into the mix, we'll = want to be diligent about being consistent in blogs, presentations, news releases, web site copy, customer testimonials = etc. 

For the sake of = simplicity, how about using XPH - al= l uppercase - on second reference? Thoughts?

Thanks,






On Wed, Mar 5, 2014 at 9:18 AM, Mark Hinkle <Mark.Hinkle@citrix.com= > wrote:
How about this convention only say Xe= n Project and Xen Project hypervisor once then. Use the abbreviation XPh th= roughout the release. Just snipping Matt?? example to make the point. I wou= ld guess that the appropriate capitalization would be lower case for the word hypervisor. 

Mark 

The=  Xen Project, a Collaborative Project hosted at The Linux Foundation, today announced = availability of the 

XPh= 4.4 further advances the Project??/span>s position as a fast, scalable, secure virtualization engine= for the industry??/span>s broadest range of server, PC chipsets and next-generation low-power system= s on chips (SoC).


On Mar 4, 2014, at 4:01 PM, Wilson, Matt <msw@amazon.com> wrote:

The &= quot;Xen Project" terminology makes the message extremely cumbersome.

The=  Xen = Project, a Collaborative Project hosted at The Linux Foundation, tod= ay announced availability of the Xen Project 4.4 Hypervisor with enhanced <= /span>Xen Project-on-ARM support.

Why not just say "enhanced ARM support"? We should adopt some usa= ge guidelines for sub-project branding. We shouldn't insert words/numbers b= etween "Xen Project" and a sub-project name.

The Xen Project, a Collaborative Project hosted at The Linux Foundation, t= oday announced version 4.4 of the Xen Project Hypervisor with enhanced ARM = support.

or
The Xen Project, a Collaborative Project hosted at The Linux Foundation, t= oday announced the release of Xen Project Hypervisor 4.4 with enhanced ARM = support.

Later on, this release is called "Xen Project 4.4"

The= Xen Project 4.4 release further advances the Project??/span>s position as a fast, scalable, secure v= irtualization engine for the industry??/span>s broadest range of server, PC chipsets and next-generation low-power system= s on chips (SoC).

That doesn't flow well. How are we releasing version 4.4 of a project?= Do we want to call the overall release "Xen Project Architecture 4.4&= quot;? Or do we need to come up with some other project branding?

--msw

From:&nbs= p;advisory-board-bounces@lists.xenproject.org [advisory-board-bounces@lists= .xenproject.org] on behalf of Sarah Conway [sconway@linuxfoundation.org]
Sent: Tuesday, March 04, 2014 12:16 PM

To: advisory-board@lists.xenproject.org
Subject: [Advisory-board] Xen Project 4.4 Release<= br>

Hi everyone.

Attached is the Xen Project 4.4 news release annoucement that will go = out at 8 a.m. ET on Monday, March 10. 

If you have any additional comments or edits, please get back to me by= Thursday morning at the latest. 

Thanks, 


-- 
Sarah Conway
PR Manager
The Linux Foundation
sconway@li= nuxfoundation.org
(978) 578-5300 <= /span> Cell
Skype:  sarah.k.conway
_______________________________________________
Advisory-board mailing list
Ad= visory-board@lists.xenproject.org
http://lists.xenproject.org/cgi-bin/mailman/listinfo= /advisory-board


_______________________________________________
Advisory-board mailing list
Ad= visory-board@lists.xenproject.org
http://lists.xenproject.org/cgi-bin/mailman/listinfo= /advisory-board




-- 
Sarah Conway
PR Manager
The Linux Foundation
sconway@li= nuxfoundation.org
(978) 578-5300  Cell
Skype:  sarah.k.conway
_______________________________________________
Advisory-board mailing list
Advisory-board@lists= .xenproject.org
http://lists.xenproject.org/cgi-bin/mailman/listinfo/advisory-board


-- IMPORTANT NOTICE: The co= ntents of this email and any attachments are confidential and may also be p= rivileged. If you are not the intended recipient, please notify the sender = immediately and do not disclose the contents to any other person, use it for any purpose, or store or copy the informat= ion in any medium. Thank you.

ARM Limited, Registered office 110 Fulbourn Road, Cambridge CB1 9NJ, Regist= ered in England & Wales, Company No: 2557590
ARM Holdings plc, Registered office 110 Fulbourn Road, Cambridge CB1 9NJ, R= egistered in England & Wales, Company No: 2548782
 --_000_CF3F6FFA248DDrichardphelanarmcom_-- --===============5604124858703328888== Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Disposition: inline _______________________________________________ Advisory-board mailing list Advisory-board@lists.xenproject.org http://lists.xenproject.org/cgi-bin/mailman/listinfo/advisory-board --===============5604124858703328888==-- From advisory-board-bounces@lists.xenproject.org Fri Mar 07 17:04:41 2014 Return-path: Envelope-to: archives@lists.xenproject.org Delivery-date: Fri, 07 Mar 2014 17:04:41 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WLyCP-00006E-As; Fri, 07 Mar 2014 17:04:41 +0000 Received: from mail6.bemta5.messagelabs.com ([195.245.231.135]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WLyCN-0008Tb-Bq for advisory-board@lists.xenproject.org; Fri, 07 Mar 2014 17:04:40 +0000 Received: from [85.158.139.211:44063] by server-15.bemta-5.messagelabs.com id B2/77-24395-62CF9135; Fri, 07 Mar 2014 17:04:38 +0000 X-Env-Sender: Mark.Hinkle@citrix.com X-Msg-Ref: server-7.tower-206.messagelabs.com!1394211873!8475199!1 X-Originating-IP: [66.165.176.89] X-SpamReason: No, hits=0.0 required=7.0 tests=sa_preprocessor: VHJ1c3RlZCBJUDogNjYuMTY1LjE3Ni44OSA9PiAyMDMwMDc=\n X-StarScan-Received: X-StarScan-Version: 6.9.16; banners=-,-,- X-VirusChecked: Checked Received: (qmail 4573 invoked from network); 7 Mar 2014 17:04:34 -0000 Received: from smtp.citrix.com (HELO SMTP.CITRIX.COM) (66.165.176.89) by server-7.tower-206.messagelabs.com with RC4-SHA encrypted SMTP; 7 Mar 2014 17:04:34 -0000 X-IronPort-AV: E=Sophos;i="4.97,608,1389744000"; d="xml'?rels'?docx'72,48?scan'72,48,208,217,72,48";a="109184202" Received: from accessns.citrite.net (HELO FTLPEX01CL01.citrite.net) ([10.9.154.239]) by FTLPIPO01.CITRIX.COM with ESMTP; 07 Mar 2014 17:04:32 +0000 Received: from FTLPEX01CL02.citrite.net ([169.254.2.39]) by FTLPEX01CL01.citrite.net ([169.254.4.56]) with mapi id 14.02.0342.004; Fri, 7 Mar 2014 12:04:32 -0500 From: Mark Hinkle To: Advisory-board discussions Thread-Topic: [Advisory-board] Xen Project 4.4 Release Thread-Index: AQHPN+bebhn/+yG6rkWud7aYk4GwRJrRvd0AgAEhnwCAADajgIAAB6+AgAGNyACAAMWOAIAAgM6AgAAhlACAAB8ZAA== Date: Fri, 7 Mar 2014 17:04:31 +0000 Message-ID: <545D5AEE-789B-4534-9983-A9EA3FD1ECC1@citrix.com> References: <6848793A-A83B-40A1-A40C-2AA9DCC1E80A@citrix.com> <2BCAC582-CB61-4E16-96C4-6C1AEFAF81FB@citrix.com> In-Reply-To: Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: yes X-MS-TNEF-Correlator: x-originating-ip: [10.9.154.239] Content-Type: multipart/mixed; boundary="_004_545D5AEE789B45349983A9EA3FD1ECC1citrixcom_" MIME-Version: 1.0 X-DLP: MIA1 Cc: Jennifer Cloer Subject: Re: [Advisory-board] Xen Project 4.4 Release X-BeenThere: advisory-board@lists.xenproject.org X-Mailman-Version: 2.1.13 Precedence: list Reply-To: Advisory-board discussions List-Id: Advisory-board discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: advisory-board-bounces@lists.xenproject.org Errors-To: advisory-board-bounces@lists.xenproject.org --_004_545D5AEE789B45349983A9EA3FD1ECC1citrixcom_ Content-Type: multipart/alternative; boundary="_000_545D5AEE789B45349983A9EA3FD1ECC1citrixcom_" --_000_545D5AEE789B45349983A9EA3FD1ECC1citrixcom_ Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 U2FyYWgsDQoNCkJyYW5kaW5nIHNlZW1zIHRvIGJlIGFwcGxpZWQgYXBwcm9wcmlhdGVseSB0aG91 Z2ggSSB0aGluayB0aGVyZSB3ZXJlIGEgY291cGxlIG9mIHNwZWxsaW5nIGlzc3VlcyBJIGNhdWdo dC4gQXR0YWNoZWQgaXMgZmluZSBieSBtZSB0aG91Z2ggdGhlIGJyYW5kaW5nIGFuZCBmbG93IGlz IHN0aWxsIGEgYml0IGNoYWxsZW5naW5nLg0KDQpNYXJrDQoNCg0KT24gTWFyIDcsIDIwMTQsIGF0 IDEwOjEzIEFNLCBTYXJhaCBDb253YXkgPHNjb253YXlAbGludXhmb3VuZGF0aW9uLm9yZzxtYWls dG86c2NvbndheUBsaW51eGZvdW5kYXRpb24ub3JnPj4gd3JvdGU6DQoNCkhpIGV2ZXJ5b25lLg0K DQpJJ3ZlIGluY29ycG9yYXRlZCBldmVyeW9uZSdzIGVkaXRzLiBJIHRyaWVkIHRvIHJlY29uY2ls ZSB0aGUgVE0tcmVsYXRlZCBpc3N1ZXMgb2YgYnJhbmQgY29uZnVzaW9uIGFuZCBmbG93IGFzIGJl c3QgSSBjb3VsZC4gQXMgeW91IGNhbiBpbWFnaW5lLCBJIGdvdCB2YXJ5aW5nIGVkaXRzLCB3aGlj aCBzdGFydGVkIHRvIGNvbmZsaWN0IHdpdGggb25lIGFub3RoZXIuDQoNClRoaXMgd291bGQgYmVu ZWZpdCBmcm9tIGFub3RoZXIgVE0gcmV2aWV3L2ZpbmFsIGFwcHJvdmFsLiBDYW4gc29tZW9uZSBz dGVwIHVwIHRvIGRvIHRoaXMgYW5kIG1ha2UgYSBmaW5hbCBjYWxsPw0KDQpNaWtlIEQuLCBDaXRy aXggaXMgb24gdGhlIGZ1bGwgQUIgZW1haWwgbGlzdCBzbyB0aGV5J3ZlIGJlZW4gaW52b2x2ZWQg aW4gcmV2aWV3cy4NCg0KUGxlYXNlIGFkdmlzZSBzb29uZXN0Lg0KDQpUaGFua3MsDQoNCg0KDQoN Ck9uIEZyaSwgTWFyIDcsIDIwMTQgYXQgODoxMyBBTSwgUmljaGFyZCBQaGVsYW4gPFJpY2hhcmQu UGhlbGFuQGFybS5jb208bWFpbHRvOlJpY2hhcmQuUGhlbGFuQGFybS5jb20+PiB3cm90ZToNCkhp LA0KDQpJIGFncmVlIHdpdGggTWFyayBhcyB0aGUgY3VycmVudCBwcmVzcyByZWxlYXNlIGlzIGhp Z2hsaWdodGluZyBpc3N1ZXMgdGhhdCBzZWVtIHRvIG1ha2UgdGhlIGFydGljdWxhdGlvbiBvZiBi cmFuZCBhbmQgYnJhbmQgdmFsdWVzIG1vcmUgY3VtYmVyc29tZSB0aGFuIGlzIGRlc2lyYWJsZS4N Cg0KSSdtIGhhcHB5IHRvIGdvIHdpdGggdGhlIHByb3Bvc2VkIGNoYW5nZXMgZm9yIHRoZSByZWFz b25zIHN0YXRlZC4NCg0KT25lIG1pbm9yIHBvaW50LCBJJ2QgcHJlZmVyICI/5ZCBeXN0ZW0gb24g Q2hpcCAoU29DKSBkZXZpY2VzLiIsIHR3byBzZXRzIG9mIHBsdXJhbHMgbWFrZSBpdCB1bmNsZWFy IGhvdyBtYW55IHN5c3RlbXMgYXJlIG9uIGVhY2ggY2hpcCBhbmQgdGhlIHBsdXJhbHMgZ2V0IHN1 Ym1lcmdlZCBpbnRvIHRoZSBhY3JvbnltOyBjb21tb24gdXNhZ2Ugc2VlbXMgdG8gYmUgU29Dcy4N Cg0KVGhhbmtzLA0KDQpSaWNoYXJkLg0KDQpGcm9tOiBNYXJrIEhpbmtsZSA8TWFyay5IaW5rbGVA Y2l0cml4LmNvbTxtYWlsdG86TWFyay5IaW5rbGVAY2l0cml4LmNvbT4+DQpSZXBseS1UbzogQWR2 aXNvcnktYm9hcmQgZGlzY3Vzc2lvbnMgPGFkdmlzb3J5LWJvYXJkQGxpc3RzLnhlbnByb2plY3Qu b3JnPG1haWx0bzphZHZpc29yeS1ib2FyZEBsaXN0cy54ZW5wcm9qZWN0Lm9yZz4+DQpEYXRlOiBG cmlkYXksIDcgTWFyY2ggMjAxNCAwNTozMg0KVG86IEFkdmlzb3J5LWJvYXJkIGRpc2N1c3Npb25z IDxhZHZpc29yeS1ib2FyZEBsaXN0cy54ZW5wcm9qZWN0Lm9yZzxtYWlsdG86YWR2aXNvcnktYm9h cmRAbGlzdHMueGVucHJvamVjdC5vcmc+Pg0KDQpTdWJqZWN0OiBSZTogW0Fkdmlzb3J5LWJvYXJk XSBYZW4gUHJvamVjdCA0LjQgUmVsZWFzZQ0KDQpNeSBhcG9sb2dpZXMgZm9yIHRoZSBzbG93IHJl cGx5IEkgd2FzIHN0dWNrIG9uIHRoZSByb2FkIGFuZCBjb3VsZG4/PyByZWFkIHRoZSByZWxlYXNl IG9uIG15IHBob25lIHRvIGZvcm11bGF0ZSBhIHByb3BlciByZXNwb25zZS4gSSBzaG91bGQgbW92 ZSB0byBhIGhpZ2hseSBlbGFzdGljIFhlbiBQcm9qZWN0LXBvd2VyZWQgY2xvdWQgdGhhdCBhbGxv d3MgbWUgdG8gYXV0b3NjYWxlIDspIChzb3JyeSBiYWQgY2xvdWQgam9rZSkuDQoNCkkgYW0gZmlu ZSB3aXRob3V0IGRvaW5nIHRoZSBhY3JvbnltIGFuZCBJIHRoaW5rIHRoZSByZWFsaWduaW5nIGFu ZCBicmFuZGluZyBkaXNjdXNzaW9uIHNob3VsZCBiZSBoYWQuIEk/PyBsaWtlIHRvIGhhdmUgdGhh dCBkaXNjdXNzaW9uIGR1cmluZyBvdXIgbmV4dCBib2FyZCBtZWV0aW5nLiBHaXZlbiB0aW1lIGlz IG9mIHRoZSBlc3NlbmNlIEkgdGhpbmsgd2Ugc2hvdWxkIGp1c3QgdXBkYXRlIHRoZSBsaW5rcyB0 byB2ZXJzaW9uIHZlcnN1cyBYZW4gNC4zLjEuDQoNCkFsc28gSSB0b29rIGEgc2hvdCBhdCB0aGUg d29yZGluZyBvZiB0aGUgcHJlc3MgcmVsZWFzZS4gSXQ/PyBwcm9iYWJseSBub3QgcGVyZmVjdCBi dXQgbWFrZXMgaXQgcmVhZCBhIGJpdCBiZXR0ZXIuIEF0dGFjaGVkIGFyZSBteSBwcm9wb3NlZCBl ZGl0cy4gU2FyYWgsIEkgc2VudCB5b3UgdGhlIHdvcmQgZG9jIHdpdGggdHJhY2sgY2hhbmdlcyBh c3N1bWluZyB3ZSBoYXZlIHNvbWUgZWRpdHMgdG8gYWdyZWUgb24uDQoNCg0KUmVnYXJkcywgTWFy aw0KDQoNClhlbiBQcm9qZWN0IFJlbGVhc2VzIFVwZGF0ZSB0byBFbnRlcnByaXNlIEh5cGVydmlz b3IgU29mdHdhcmUNCg0KT3BlbiBTb3VyY2UgVmlydHVhbGl6YXRpb24gU29mdHdhcmUgUmVsZWFz ZSBJbmNsdWRlcyBBZGRpdGlvbmFsIEFSTSBTdXBwb3J0IGFuZCBTY2FsYWJpbGl0eSBmb3IgQ2xv dWQgYW5kIE1vYmlsZSBFbnZpcm9ubWVudHMNCg0KDQoNClNBTiBGUkFOQ0lTQ08sIE1hcmNoIDEw LCAyMDE0ID8/L3NwYW4+IFhlbiBQcm9qZWN0LCBhIENvbGxhYm9yYXRpdmUgUHJvamVjdCBob3N0 ZWQgYXQgVGhlIExpbnV4IEZvdW5kYXRpb24sIHRvZGF5IGFubm91bmNlZCBhdmFpbGFiaWxpdHkg b2YgdGhlIFhlbiBQcm9qZWN0IDQuNCB3aXRoIGVuaGFuY2VkIEFSTSBzdXBwb3J0LiBUaGUgbGF0 ZXN0IHJlbGVhc2UgYWxzbyBpbmNsdWRlcyBtYWpvciBwZXJmb3JtYW5jZSBhbmQgc3lzdGVtIHNj YWxhYmlsaXR5IGltcHJvdmVtZW50cyBmb3IgZW50ZXJwcmlzZSBjb21wdXRpbmcsIHN1Y2ggYXMg bW9iaWxlIGFuZCBjbG91ZCBlbnZpcm9ubWVudHMsIHdoZXJlIHZpcnR1YWxpemF0aW9uIHRlY2hu b2xvZ3kgaXMgaW5jcmVhc2luZ2x5IGluIGRlbWFuZC4NCg0KVGhpcyByZWxlYXNlIGZ1cnRoZXIg YWR2YW5jZXMgdGhlIFByb2plY3Q/Py9zcGFuPnMgcG9zaXRpb24gYXMgYSBmYXN0LCBzY2FsYWJs ZSwgc2VjdXJlIHZpcnR1YWxpemF0aW9uIGVuZ2luZSBmb3IgdGhlIGluZHVzdHJ5Pz8vc3Bhbj5z IGJyb2FkZXN0IHJhbmdlIG9mIHNlcnZlciwgUEMgY2hpcHNldHMgYW5kIG5leHQtZ2VuZXJhdGlv biBsb3ctcG93ZXIgc3lzdGVtcyBvbiBjaGlwcyAoU29DKS4NCg0KTWFqb3IgY29udHJpYnV0aW9u cyBmcm9tIEFNRCwgQ2l0cml4LCBJbnRlbCwgT3JhY2xlIGFuZCBTVVNFIGFyZSBwdXNoaW5nIHRo ZSBYZW4gUHJvamVjdCBzb2Z0d2FyZSB0byB0YWtlIGFkdmFudGFnZSBvZiB0aGUgbGF0ZXN0IGhh cmR3YXJlLiBBZGRpdGlvbmFsbHksIGRldmVsb3BlcnMgY3JlYXRpbmcgc2VydmljZXMgYW5kIGFw cHMgd2l0aCBlbWJlZGRlZCwgbW9iaWxlIGFuZCBjbG91ZCBzeXN0ZW1zIHdpbGwgYmVuZWZpdCBm cm9tIG5ldyBmZWF0dXJlcyBzdWNoIGFzIGV2ZW50IGNoYW5uZWxpbmcgd2hlbiBzY2FsaW5nIG91 dCB0aGVpciBJbmZyYXN0cnVjdHVyZSBhcyBhIFNlcnZpY2Ugb2ZmZXJpbmdzLg0KDQo/Py9zcGFu PlZpcnR1YWxpemF0aW9uIGFuZCBsb3ctcG93ZXJlZCBzZXJ2ZXJzIGFyZSBsZWFkaW5nIGNvbXBh bmllcyB0byByZXRoaW5rIHRoZSBkYXRhIGNlbnRlciBhbmQgaXRzIHBvdGVudGlhbCBmb3IgZWZm aWNpZW5jeSw/PyBzYWlkIExhcnMgS3VydGgsIENoYWlybWFuIG9mIHRoZSBYZW4gUHJvamVjdCBh ZHZpc29yeSBib2FyZC4gPz8vc3Bhbj5PdXIgc29sdXRpb24gY29udGFpbnMgSVQtcmVsYXRlZCBj b3N0cywgcGx1cyBtZWV0cyB0aGUgc2VjdXJpdHkgYW5kIHNjYWxhYmlsaXR5IG5lZWRzIG9mIHRv ZGF5Pz8vc3Bhbj5zIGVsYXN0aWMgY2xvdWQsIG1vYmlsZSBhbmQgc29jaWFsIG5ldHdvcmtpbmcg Y29tcGFuaWVzLiBUaGUgbGF0ZXN0IHVwZGF0ZXMgY29udGludWUgdGhlIFByb2plY3Q/Py9zcGFu PnMgdHJhY2sgcmVjb3JkIG9mIHJpY2ggY29sbGFib3JhdGlvbiBhbmQgd2lkZXNwcmVhZCBkZXZl bG9wbWVudCBmcm9tIG1hbnkgb2YgdGhlIHdvcmxkPz8vc3Bhbj5zIHRlY2hub2xvZ3kgbGVhZGVy cy4gVGhpcyBjZXJ0YWlubHkgZXhwbGFpbnMgdGhlIHNpZ25pZmljYW50IGdyb3d0aCBvZiBBUk0g c3VwcG9ydCwgd2hpY2ggd2U/Py9zcGFuPnJlIHBsZWFzZWQgdG8gc2VlIGFkdmFuY2Ugc28gcXVp Y2tseS4/Py9zcGFuPg0KDQpTdXBwb3J0IGZvciBBUk0gb24gWGVuIFByb2plY3QgQXJjaGl0ZWN0 dXJlIEdyb3dzIFF1aWNrbHkNCg0KVGhlIG5ldyByZWxlYXNlIGludHJvZHVjZXMgc2lnbmlmaWNh bnQgc3RhYmlsaXR5LCB1c2FiaWxpdHkgYW5kIHBlcmZvcm1hbmNlIGltcHJvdmVtZW50cyBmb3Ig dGhlIEFSTSBhcmNoaXRlY3R1cmUgYW5kIGV4dGVuZGVkIGhhcmR3YXJlIGNvbXBhdGliaWxpdHku ICBBcHBsaWVkTWljcm8/Py9zcGFuPnMgWC1HZW5lLCB0aGUgQXJuZGFsZSBCb2FyZCwgQ2FseGVk YSBFQ1gtMjAwMCwgVEkgT01BUDUgYW5kIHRoZSBBbGx3aW5uZXIgU3VuWGkgYm9hcmRzIGFyZSBh bGwgc3VwcG9ydGVkLiBUaGUgc3Vic3RhbnRpYWxseSBpbXByb3ZlZCBtdWx0aXBsYXRmb3JtIGNh cGFiaWxpdGllcyBvZiB0aGUgaHlwZXJ2aXNvciBhbGxvdyBoYXJkd2FyZSBhbmQgZW1iZWRkZWQg dmVuZG9ycyB0byBwb3J0IHRoZSBYZW4gUHJvamVjdCB0ZWNobm9sb2d5IHRvIG5ldyBBUk0gU29D cyBlYXNpbHksIHNob3J0ZW5pbmcgdGhlaXIgdGltZSB0byBtYXJrZXQuDQoNCg0KDQpBZGRpdGlv bmFsIGVuaGFuY2VtZW50cyBpbiB0aGlzIHJlbGVhc2UgaW5jbHVkZWQgNjQtYml0IGd1ZXN0IHN1 cHBvcnQgb24gQVJNdjggcGxhdGZvcm1zLiBBbGwgdGhlIHVzZXJzcGFjZSB0b29scywgc3VjaCBh cyB0aGUgeGwgbWFuYWdlbWVudCB0b29sLCBhcmUgNjQtYml0IHJlYWR5IGFuZCBjYW4gYmUgdXNl ZCB0byBjcmVhdGUgNjQtYml0IHZpcnR1YWwgbWFjaGluZXMgb3V0IG9mIHRoZSBib3guDQoNCg0K DQpUaGUgWGVuIFByb2plY3QgaHlwZXJjYWxsIEFCSSBpcyBub3cgc3RhYmxlIGFuZCB3aWxsIGJl IG1haW50YWluZWQgZm9yIGJhY2t3YXJkIGNvbXBhdGliaWxpdHksIHNvIHVzZXJzIGNhbiB0cnVz dCBmdXR1cmUgcmVsZWFzZXMgdG8gYm9vdCBvbGRlciBvcGVyYXRpbmcgc3lzdGVtcy4NCg0KQWRk aXRpb25hbCBpbXByb3ZlbWVudHMgaW5jbHVkZSBleHRlbmRlZCBzdXBwb3J0IGZvciBBUk0gc3Bl Y2lmaWMgYm9vdGxvYWRlcnMgYW5kIGZpcm13YXJlIGludGVyZmFjZXMsIGFuZCBzdXBwb3J0IGZv ciBwaHlzaWNhbCBwYXJ0aXRpb25zIGFuZCBMVk0gdm9sdW1lcyB0byBzdG9yZSBkaXNrcyBvZiB2 aXJ0dWFsIG1hY2hpbmVzLg0KDQoNCg0KSW1wcm92ZWQgRXZlbnQgQ2hhbm5lbCBTY2FsYWJpbGl0 eSBGb3IgQ2xvdWQgQ29tcHV0aW5nDQoNClhlbiBQcm9qZWN0IGRldmVsb3BlcnMgY29udGludWVz IHRvIGRyaXZlIGlubm92YXRpb24gYW5kIGNvbGxhYm9yYXRpb24gYXJvdW5kIHNlcnZlciB2aXJ0 dWFsaXphdGlvbiBhbmQgdGhlIGNsb3VkLiBQb3dlcmluZyBtYW55IG9mIHRoZSBsYXJnZXN0IGNs b3VkcyBpbiBwcm9kdWN0aW9uIHRvZGF5LCBpbmNsdWRpbmcgQW1hem9uIEVDMiwgUmFja3NwYWNl IENsb3VkIGFuZCBvdGhlcnMsIHRoZSBjb21tdW5pdHkgdW5kZXJzdGFuZHMgdGhlIG5lZWQgdG8g cnVuIG1vcmUgdmlydHVhbCBtYWNoaW5lcyBvbiBhIHNpbmdsZSBob3N0Lg0KDQpZZXQgZGVtYW5k cyBvbiBoeXBlcnZpc29yIHNjYWxhYmlsaXR5IGNvbnRpbnVlIHRvIGluY3JlYXNlLCBib3RoIGZy b20gbGFyZ2VyIG1hY2hpbmVzLCBuZXcgd29ya2xvYWRzIHN1Y2ggYXMgdmlydHVhbGl6YXRpb24g ZGVza3RvcCBpbmZyYXN0cnVjdHVyZXMgKFZESSkgYW5kIG5ldyBjbG91ZCBPUyB0ZWNobm9sb2dp ZXMsIGluY2x1ZGluZyBNaXJhZ2VPUywgRXJsYW5nT25YZW4sIE9TdiwgYW5kIEhhbFZNLiBSZWNv Z25pemluZyB0aGF0IGhpZ2gtYXZhaWxhYmlsaXR5IGFuZCBzdGFiaWxpdHkgYXJlIGNyaXRpY2Fs IHRvIFZESXMgYW5kIGNsb3VkIGRlcGxveW1lbnRzOyB0aGUgWGVuU2VydmVyIHRlYW0gYXQgQ2l0 cml4IGNvbnRyaWJ1dGVkIHRoZSBuZXcgZXZlbnQgY2hhbm5lbCBpbXBsZW1lbnRhdGlvbiB0byB0 aGUgWGVuIFByb2plY3QuIFRvIGhlbHAgZWxpbWluYXRlIHdvcmtsb2FkIGxpbWl0YXRpb25zIGZv ciB1c2VycywgdGhpcyBlbmFibGVzIHRoZSBoeXBlcnZpc29yIHRvIHJ1biB0aG91c2FuZHMgb2Yg Z3Vlc3RzIG9uIGEgc2luZ2xlIHBoeXNpY2FsIG1hY2hpbmUuDQoNCkV4cGVyaW1lbnRhbCBTdXBw b3J0IGZvciBQVkggTW9kZSBmb3IgR3Vlc3QNCg0KT3JhY2xlIGhhcyBjb250cmlidXRlZCBhIGZ1 bmN0aW9uYWwgcHJldmlldyBvZiBhIG5ldyB2aXJ0dWFsaXphdGlvbiBtb2RlIGNhbGxlZCBQVkgg Y3VycmVudGx5IGF2YWlsYWJsZSB0byB2aXJ0dWFsaXplZCBndWVzdHMuIDxodHRwOi8vYmxvZy54 ZW4ub3JnL2luZGV4LnBocC8yMDE0LzAxLzMxL2xpbnV4LTMtMTQtYW5kLXB2aC8+IFBWSCBpcyBh biBleHRlbnNpb24gdG8gdGhlIGNsYXNzaWMgWGVuIFByb2plY3QgUGFyYXZpcnR1YWxpemF0aW9u IChQVikgdGhhdCB1c2VzIHRoZSBoYXJkd2FyZSB2aXJ0dWFsaXphdGlvbiBleHRlbnNpb25zIGF2 YWlsYWJsZSBvbiBtb2Rlcm4geDg2IHByb2Nlc3NvcnMuIFBWSCB1c2VzIFBWIGRyaXZlcnMgZm9y IGJvb3QgYW5kIEkvTyBhbmQgSW50ZWwgaGFyZHdhcmUgdmlydHVhbGl6YXRpb24gZXh0ZW5zaW9u cyBmb3IgcGFnZSB0YWJsZSBvcGVyYXRpb25zLCBzeXN0ZW0gY2FsbHMgYW5kIG90aGVyIHByaXZp bGVnZWQgb3BlcmF0aW9ucy4gVGhpcyBub3Qgb25seSBpbXByb3ZlcyBwZXJmb3JtYW5jZSBhbmQg c2VjdXJpdHksIGJ1dCBhbHNvIHNpbXBsaWZpZXMgdGhlIGFyY2hpdGVjdHVyZSBhbmQgWGVuIFBy b2plY3QgSHlwZXJ2aXNvci1MaW51eCBpbnRlcmZhY2Ugc2lnbmlmaWNhbnRseS4NCg0KPz8vc3Bh bj5QVkggaXMgYSBtYWpvciBkZXZlbG9wbWVudCBmb3IgWGVuIFByb2plY3Qgc29mdHdhcmUgb24g eDg2IGFuZCBoYXMgdGhlIHBvdGVudGlhbCB0byBncmVhdGx5IHNpbXBsaWZ5IHRoZSBMaW51eCBp bnRlcmZhY2UgaW4gZHVlIHRpbWUsID8/IHNhaWQgS29ucmFkIFJ6ZXN6dXRlayBXaWxrLCBTb2Z0 d2FyZSBEZXZlbG9wbWVudCBNYW5hZ2VyIGF0IE9yYWNsZSwgYSBYZW4gUHJvamVjdCBhZHZpc29y eSBib2FyZCBtZW1iZXIuID8/L3NwYW4+V2UgZXhwZWN0IFBWSCB0byBoYXZlIHRoZSBiZXN0IGNo YXJhY3RlcmlzdGljcyBvZiBhbGwgdmlydHVhbGl6YXRpb24gbW9kZXMgLS0gYSBzaW1wbGUsIGZh c3QsIHNlY3VyZSBpbnRlcmZhY2UsIHdpdGggbG93IG1lbW9yeSBvdmVyaGVhZCwgdGhhdCBhbHNv IHRha2VzIGZ1bGwgYWR2YW50YWdlIG9mIHRoZSBsYXRlc3QgaGFyZHdhcmUuPz8vc3Bhbj4NCg0K DQoNCkFkZGl0aW9uYWwga2V5IHVwZGF0ZXMgaW5jbHVkZToNCg0K5ZqZ6Lid6JWtICAgICBCZXR0 ZXIgcGVyZm9ybWFuY2Ugd2l0aCBtb2Rlcm4gc3RvcmFnZSBkZXZpY2VzIGFuZCBiaWcgZGF0YSAt LSBJbmRpcmVjdCBkZXNjcmlwdG9ycyBmb3IgYmxvY2sgUFYgcHJvdG9jb2wgKExpbnV4KSBhbGxv dyBlYWNoIGluZGl2aWR1YWwgcmVxdWVzdCB0byB0cmlwbGUgaW4gc2l6ZSwgZ3JlYXRseSBpbXBy b3ZpbmcgSS9PIHBlcmZvcm1hbmNlIHdoZW4gcnVubmluZyBvbiBmYXN0IHN0b3JhZ2UgdGVjaG5v bG9naWVzIHN1Y2ggYXMgc29saWQtc3RhdGUgZHJpdmUgYW5kIFJBSUQuIEF2YWlsYWJsZSBpbiBh bnkgZ3Vlc3QgcnVubmluZyBMaW51eCAzLjExIG9yIGhpZ2hlciAocmVnYXJkbGVzcyBvZiBYZW4g UHJvamVjdCB2ZXJzaW9uKS4NCg0KDQoNCuWamei4neiVrSAgICAgTW9yZSBwb3dlcmZ1bCBkcml2 ZXIgZG9tYWlucyAtLSBEaXNrIGRyaXZlciBkb21haW5zIGNhbiBub3cgdW5pZm9ybWx5IHJ1biBi bG9jayBzY3JpcHRzIGFuZCB1c2VyLXNwYWNlIGJhY2tlbmRzLCBzdWNoIGFzIHFkaXNrLCBicmlu Z2luZyB0aGVtIHVwIHRvIGZlYXR1cmUgcGFyaXR5IHdpdGggZG9tYWluIDAuIFRoaXMgbWVhbnMg aG9zdCBhZG1pbmlzdHJhdG9ycyBjYW4gdGFrZSBhZHZhbnRhZ2Ugb2YgdGhlIGVuaGFuY2VkIHNl Y3VyaXR5LCBzY2FsYWJpbGl0eSwgYW5kIHJvYnVzdG5lc3MgcHJvdmlkZWQgYnkgZHJpdmVyIGRv bWFpbnMgd2l0aG91dCBzYWNyaWZpY2luZyB0aGUgd2lkZSBhcnJheSBvZiBkaXNrIGNvbmZpZ3Vy YXRpb24gb3B0aW9ucyBwcm92aWRlZCBieSBYZW4gaW4gZG9tMC4NCg0K5ZqZ6Lid6JWtICAgICBO ZXcgU1BJQ0UgcHJvdG9jb2wgc3VwcG9ydCAtLSBGdW5jdGlvbmFsaXR5IHN1Y2ggYXMgY2xpcGJv YXJkIHNoYXJpbmcgYW5kIFVTQiByZWRpcmVjdGlvbiBjcmVhdGVzIGEgbXVjaCByaWNoZXIgY29u bmVjdGlvbiBmb3IgdmlydHVhbCBkZXNrdG9wcyBhbmQgYmV0dGVyIGdyYXBoaWNzIHBlcmZvcm1h bmNlLg0KDQrlmpnouJ3ola0gICAgIEVuaGFuY2VkIGRpYWdub3N0aWNzIGFuZCBrZXhlYyBkZWJ1 ZyBzdXBwb3J0IC0tIFdoZW4gYSBjcmFzaCBoYXBwZW5zLCBhIHNwZWNpYWwga2VybmVsIGlzIGFs bG93ZWQgaW1tZWRpYXRlIHRvIGNvbGxlY3QgaW5mb3JtYXRpb24gYWJvdXQgdGhlIHJvb3QgY2F1 c2UsIG9mZmVyaW5nIGRldmVsb3BlcnMgYmV0dGVyIGRpYWdub3NpcyBhbmQgcmVwYWlyIGFiaWxp dGllcy4NCg0KVGhlIDQuNCByZWxlYXNlIGlzIHRoZSByZXN1bHQgb2YgYSBicm9hZCwgY29sbGFi b3JhdGl2ZSBkZXZlbG9wbWVudCBlZmZvcnQgcmVwcmVzZW50aW5nIGVuZ2luZWVycyBmcm9tIG1v cmUgdGhhbiAxMyBsZWFkaW5nIGhhcmR3YXJlLCBzb2Z0d2FyZSBhbmQgc2VjdXJpdHkgdmVuZG9y cy4gVG9wIGNvbnRyaWJ1dG9ycyBpbmNsdWRlIEFtYXpvbiwgQU1ELCBBbmFsb2cgRGV2aWNlcywg QnJvYWRjb20sIENpdHJpeCwgRnVqaXRzdSwgSW50ZWwsIExpbmFybywgTlNBLCBPcmFjbGUsIFN1 c2UsIFZlcml6b24vVGVycmVtYXJrLCBwbHVzIG51bWVyb3VzIGluZGl2aWR1YWwgYW5kIGFjYWRl bWljIGNvbnRyaWJ1dG9ycy4gVGhlIGZyZWVseSBhdmFpbGFibGUgZG93bmxvYWQgY2FuIGJlIGZv dW5kIG9uIHRoZSBYZW5Qcm9qZWN0Lm9yZzxodHRwOi8veGVucHJvamVjdC5vcmcvPiB3ZWJzaXRl IChpbnNlcnQgdXJsKS4NCg0KDQoNCkFib3V0IFhlbiBQcm9qZWN0DQoNClRoZSBYZW4gUHJvamVj dCBzb2Z0d2FyZSBpcyBhbiBvcGVuIHNvdXJjZSB2aXJ0dWFsaXphdGlvbiBwbGF0Zm9ybSBsaWNl bnNlZCB1bmRlciB0aGUgR1BMdjIgd2l0aCBhIHNpbWlsYXIgZ292ZXJuYW5jZSBzdHJ1Y3R1cmUg dG8gdGhlIExpbnV4IGtlcm5lbC4gRGVzaWduZWQgZnJvbSB0aGUgc3RhcnQgZm9yIGNsb3VkIGNv bXB1dGluZywgdGhlIFByb2plY3QgaGFzIG1vcmUgdGhhbiBhIGRlY2FkZSBvZiBkZXZlbG9wbWVu dCBhbmQgaXMgYmVpbmcgdXNlZCBieSBtb3JlIHRoYW4gMTAgbWlsbGlvbiB1c2Vycy4gQSBDb2xs YWJvcmF0aXZlIFByb2plY3QgYXQgVGhlIExpbnV4IEZvdW5kYXRpb24sIHRoZSBYZW4gUHJvamVj dCB0ZWFtIGlzIGZvY3VzZWQgb24gYWR2YW5jaW5nIHZpcnR1YWxpemF0aW9uIGluIGEgbnVtYmVy IG9mIGRpZmZlcmVudCBjb21tZXJjaWFsIGFuZCBvcGVuIHNvdXJjZSBhcHBsaWNhdGlvbnMgaW5j bHVkaW5nIHNlcnZlciB2aXJ0dWFsaXphdGlvbiwgSW5mcmFzdHJ1Y3R1cmUgYXMgYSBTZXJ2aWNl IChJYWFTKSwgZGVza3RvcCB2aXJ0dWFsaXphdGlvbiwgc2VjdXJpdHkgYXBwbGljYXRpb25zLCBl bWJlZGRlZCBhbmQgaGFyZHdhcmUgYXBwbGlhbmNlcy4gSXQgY291bnRzIG1hbnkgaW5kdXN0cnkg YW5kIG9wZW4gc291cmNlIGNvbW11bml0eSBsZWFkZXJzIGFtb25nIGl0cyBtZW1iZXJzIGluY2x1 ZGluZzogQW1hem9uIFdlYiBTZXJ2aWNlcywgQU1ELCBBUk0sIEJyb21pdW0sIENhbHhlZGEsIENB IFRlY2hub2xvZ2llcywgQ2lzY28sIENpdHJpeCwgR29vZ2xlLCBJbnRlbCwgT3JhY2xlLCBTYW1z dW5nIGFuZCBWZXJpem9uLiBGb3IgbW9yZSBpbmZvcm1hdGlvbiBhYm91dCB0aGUgWGVuIFByb2pl Y3QgaHlwZXJ2aXNvciBhbmQgdG8gcGFydGljaXBhdGUsIHBsZWFzZSB2aXNpdCBodHRwOi8veGVu cHJvamVjdC48aHR0cDovL3hlbnByb2plY3Qub3JnLz5vcmc8aHR0cDovL3hlbnByb2plY3Qub3Jn Lz4uDQoNCiMjIw0KDQpTYXJhaCBDb253YXkNCg0KVGhlIFhlbiBQcm9qZWN0DQoNCk1lZGlhIENv bnRhY3QNCg0KcHVibGljaXR5QGxpc3RzLnhlbnByb2plY3Qub3JnPG1haWx0bzpwdWJsaWNpdHlA bGlzdHMueGVucHJvamVjdC5vcmc+DQoNCg0KT24gTWFyIDYsIDIwMTQsIGF0IDEyOjQ0IFBNLCBX aWxzb24sIE1hdHQgPG1zd0BhbWF6b24uY29tPG1haWx0bzptc3dAYW1hem9uLmNvbT4+IHdyb3Rl Og0KDQpNYXJrLCB0aG91Z2h0cz8NCg0KX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18N CkZyb206IFdpbHNvbiwgTWF0dA0KU2VudDogV2VkbmVzZGF5LCBNYXJjaCAwNSwgMjAxNCAxMDow MSBBTQ0KVG86IEFkdmlzb3J5LWJvYXJkIGRpc2N1c3Npb25zDQpTdWJqZWN0OiBSRTogW0Fkdmlz b3J5LWJvYXJkXSBYZW4gUHJvamVjdCA0LjQgUmVsZWFzZQ0KDQpJJ2QgcmF0aGVyIHVzZSAiWGVu IFByb2plY3QgSHlwZXJ2aXNvciIgdGhhbiBpbnRyb2R1Y2UgYW4gYWNyb255bS4gSSB0aGluayBp dCdzIGltcG9ydGFudCB0aGF0ICJYZW4gUHJvamVjdCIgbm90IGJlIHNwbGl0IGZyb20gIkh5cGVy dmlzb3IuIg0KDQpUaGlzIHN0aWxsIGRvZXNuJ3QgYWRkcmVzcyBob3cgdGhlIHVtYnJlbGxhIHBy b2plY3QgaXMgY2FsbGVkLiBUaGlzIG5ldyByZWxlYXNlIGRvZXNuJ3Qgb25seSBpbmNsdWRlIHRo ZSBoeXBlcnZpc29yLCBidXQgYWxzbyB0aGUgYXNzb2NpYXRlZCB0b29sc3RhY2sgYW5kIHV0aWxp dGllcy4gTWF5YmUgd2UncmUgT0sgY2FsbGluZyBhbGwgb2YgdGhhdCB0aGUgIkh5cGVydmlzb3Is IiBldmVuIGlmIHdlIGlkZW50aWZ5IHRoZSBkZXZlbG9wbWVudCB0ZWFtcyBkaWZmZXJlbnRseS4N Cg0KSG93IHNob3VsZCB3ZSByZS1hbGlnbiBhbGwgb2YgdGhlIGJyYW5kaW5nPyBGb3IgZXhhbXBs ZTogaHR0cDovL3hlbnByb2plY3Qub3JnL2RldmVsb3BlcnMvdGVhbXMvaHlwZXJ2aXNvci5odG1s DQoNClNob3VsZCB0aGUgbGlua3MgdW5kZXIgIkh5cGVydmlzb3IgRG93bmxvYWRzIiBiZSAidmVy c2lvbiA0LjMuMSIgaW5zdGVhZCBvZiAiWGVuIDQuMy4xIiB0byByZXNvbHZlIHRoZSB0cmFkZW1h cmsgY29uY2VybnM/DQoNCi0tbXN3DQoNCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f DQpGcm9tOiBhZHZpc29yeS1ib2FyZC1ib3VuY2VzQGxpc3RzLnhlbnByb2plY3Qub3JnPG1haWx0 bzphZHZpc29yeS1ib2FyZC1ib3VuY2VzQGxpc3RzLnhlbnByb2plY3Qub3JnPiBbYWR2aXNvcnkt Ym9hcmQtYm91bmNlc0BsaXN0cy54ZW5wcm9qZWN0Lm9yZzxtYWlsdG86YWR2aXNvcnktYm9hcmQt Ym91bmNlc0BsaXN0cy54ZW5wcm9qZWN0Lm9yZz5dIG9uIGJlaGFsZiBvZiBTYXJhaCBDb253YXkg W3Njb253YXlAbGludXhmb3VuZGF0aW9uLm9yZzxtYWlsdG86c2NvbndheUBsaW51eGZvdW5kYXRp b24ub3JnPl0NClNlbnQ6IFdlZG5lc2RheSwgTWFyY2ggMDUsIDIwMTQgOTozMyBBTQ0KVG86IEFk dmlzb3J5LWJvYXJkIGRpc2N1c3Npb25zDQpTdWJqZWN0OiBSZTogW0Fkdmlzb3J5LWJvYXJkXSBY ZW4gUHJvamVjdCA0LjQgUmVsZWFzZQ0KDQpNYXJrIGV0IGFsbCwNCg0KSSBhZ3JlZSB0aGF0IHVz aW5nIFhlbiBQcm9qZWN0IGlzIGEgbW91dGhmdWwuIEdpdmVuIHRoYXQgdGhlcmUgaXMgY2xvc2Ug b3ZlcmxhcCBhbmQgb2NjYXNpb25hbCBicmFuZGluZyBjb25mdXNpb24gd2l0aCBDaXRyaXggcHJv ZHVjdHMsIGlmIHdlIGFkZCBhbm90aGVyIG5ldyB0ZXJtIG9yIGFjcm9ueW0gaW50byB0aGUgbWl4 LCB3ZSdsbCB3YW50IHRvIGJlIGRpbGlnZW50IGFib3V0IGJlaW5nIGNvbnNpc3RlbnQgaW4gYmxv Z3MsIHByZXNlbnRhdGlvbnMsIG5ld3MgcmVsZWFzZXMsIHdlYiBzaXRlIGNvcHksIGN1c3RvbWVy IHRlc3RpbW9uaWFscyBldGMuDQoNCkZvciB0aGUgc2FrZSBvZiBzaW1wbGljaXR5LCBob3cgYWJv dXQgdXNpbmcgWFBIIC0gYWxsIHVwcGVyY2FzZSAtIG9uIHNlY29uZCByZWZlcmVuY2U/IFRob3Vn aHRzPw0KDQpUaGFua3MsDQoNCg0KDQoNCg0KDQpPbiBXZWQsIE1hciA1LCAyMDE0IGF0IDk6MTgg QU0sIE1hcmsgSGlua2xlIDxNYXJrLkhpbmtsZUBjaXRyaXguY29tPG1haWx0bzpNYXJrLkhpbmts ZUBjaXRyaXguY29tPj4gd3JvdGU6DQpIb3cgYWJvdXQgdGhpcyBjb252ZW50aW9uIG9ubHkgc2F5 IFhlbiBQcm9qZWN0IGFuZCBYZW4gUHJvamVjdCBoeXBlcnZpc29yIG9uY2UgdGhlbi4gVXNlIHRo ZSBhYmJyZXZpYXRpb24gWFBoIHRocm91Z2hvdXQgdGhlIHJlbGVhc2UuIEp1c3Qgc25pcHBpbmcg TWF0dD8/IGV4YW1wbGUgdG8gbWFrZSB0aGUgcG9pbnQuIEkgd291bGQgZ3Vlc3MgdGhhdCB0aGUg YXBwcm9wcmlhdGUgY2FwaXRhbGl6YXRpb24gd291bGQgYmUgbG93ZXIgY2FzZSBmb3IgdGhlIHdv cmQgaHlwZXJ2aXNvci4NCg0KTWFyaw0KDQoNClRoZSBYZW4gUHJvamVjdCwgYSBDb2xsYWJvcmF0 aXZlIFByb2plY3QgaG9zdGVkIGF0IFRoZSBMaW51eCBGb3VuZGF0aW9uLCB0b2RheSBhbm5vdW5j ZWQgYXZhaWxhYmlsaXR5IG9mIHRoZSBYZW4gUHJvamVjdCBoeXBlcnZpc29yKFhQaCkgNC40IHdp dGggZW5oYW5jZWQgQVJNIHN1cHBvcnQuDQoNClhQaCA0LjQgZnVydGhlciBhZHZhbmNlcyB0aGUg UHJvamVjdD8/L3NwYW4+cyBwb3NpdGlvbiBhcyBhIGZhc3QsIHNjYWxhYmxlLCBzZWN1cmUgdmly dHVhbGl6YXRpb24gZW5naW5lIGZvciB0aGUgaW5kdXN0cnk/Py9zcGFuPnMgYnJvYWRlc3QgcmFu Z2Ugb2Ygc2VydmVyLCBQQyBjaGlwc2V0cyBhbmQgbmV4dC1nZW5lcmF0aW9uIGxvdy1wb3dlciBz eXN0ZW1zIG9uIGNoaXBzIChTb0MpLg0KDQpPbiBNYXIgNCwgMjAxNCwgYXQgNDowMSBQTSwgV2ls c29uLCBNYXR0IDxtc3dAYW1hem9uLmNvbTxtYWlsdG86bXN3QGFtYXpvbi5jb20+PiB3cm90ZToN Cg0KVGhlICJYZW4gUHJvamVjdCIgdGVybWlub2xvZ3kgbWFrZXMgdGhlIG1lc3NhZ2UgZXh0cmVt ZWx5IGN1bWJlcnNvbWUuDQoNCg0KVGhlIFhlbiBQcm9qZWN0LCBhIENvbGxhYm9yYXRpdmUgUHJv amVjdCBob3N0ZWQgYXQgVGhlIExpbnV4IEZvdW5kYXRpb24sIHRvZGF5IGFubm91bmNlZCBhdmFp bGFiaWxpdHkgb2YgdGhlIFhlbiBQcm9qZWN0IDQuNCBIeXBlcnZpc29yIHdpdGggZW5oYW5jZWQg WGVuIFByb2plY3Qtb24tQVJNIHN1cHBvcnQuDQoNCldoeSBub3QganVzdCBzYXkgImVuaGFuY2Vk IEFSTSBzdXBwb3J0Ij8gV2Ugc2hvdWxkIGFkb3B0IHNvbWUgdXNhZ2UgZ3VpZGVsaW5lcyBmb3Ig c3ViLXByb2plY3QgYnJhbmRpbmcuIFdlIHNob3VsZG4ndCBpbnNlcnQgd29yZHMvbnVtYmVycyBi ZXR3ZWVuICJYZW4gUHJvamVjdCIgYW5kIGEgc3ViLXByb2plY3QgbmFtZS4NCg0KVGhlIFhlbiBQ cm9qZWN0LCBhIENvbGxhYm9yYXRpdmUgUHJvamVjdCBob3N0ZWQgYXQgVGhlIExpbnV4IEZvdW5k YXRpb24sIHRvZGF5IGFubm91bmNlZCB2ZXJzaW9uIDQuNCBvZiB0aGUgWGVuIFByb2plY3QgSHlw ZXJ2aXNvciB3aXRoIGVuaGFuY2VkIEFSTSBzdXBwb3J0Lg0KDQpvcg0KVGhlIFhlbiBQcm9qZWN0 LCBhIENvbGxhYm9yYXRpdmUgUHJvamVjdCBob3N0ZWQgYXQgVGhlIExpbnV4IEZvdW5kYXRpb24s IHRvZGF5IGFubm91bmNlZCB0aGUgcmVsZWFzZSBvZiBYZW4gUHJvamVjdCBIeXBlcnZpc29yIDQu NCB3aXRoIGVuaGFuY2VkIEFSTSBzdXBwb3J0Lg0KDQpMYXRlciBvbiwgdGhpcyByZWxlYXNlIGlz IGNhbGxlZCAiWGVuIFByb2plY3QgNC40Ig0KDQoNClRoZSBYZW4gUHJvamVjdCA0LjQgcmVsZWFz ZSBmdXJ0aGVyIGFkdmFuY2VzIHRoZSBQcm9qZWN0Pz8vc3Bhbj5zIHBvc2l0aW9uIGFzIGEgZmFz dCwgc2NhbGFibGUsIHNlY3VyZSB2aXJ0dWFsaXphdGlvbiBlbmdpbmUgZm9yIHRoZSBpbmR1c3Ry eT8/L3NwYW4+cyBicm9hZGVzdCByYW5nZSBvZiBzZXJ2ZXIsIFBDIGNoaXBzZXRzIGFuZCBuZXh0 LWdlbmVyYXRpb24gbG93LXBvd2VyIHN5c3RlbXMgb24gY2hpcHMgKFNvQykuDQoNClRoYXQgZG9l c24ndCBmbG93IHdlbGwuIEhvdyBhcmUgd2UgcmVsZWFzaW5nIHZlcnNpb24gNC40IG9mIGEgcHJv amVjdD8gRG8gd2Ugd2FudCB0byBjYWxsIHRoZSBvdmVyYWxsIHJlbGVhc2UgIlhlbiBQcm9qZWN0 IEFyY2hpdGVjdHVyZSA0LjQiPyBPciBkbyB3ZSBuZWVkIHRvIGNvbWUgdXAgd2l0aCBzb21lIG90 aGVyIHByb2plY3QgYnJhbmRpbmc/DQoNCi0tbXN3DQoNCl9fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fDQpGcm9tOiBhZHZpc29yeS1ib2FyZC1ib3VuY2VzQGxpc3RzLnhlbnByb2plY3Qu b3JnPG1haWx0bzphZHZpc29yeS1ib2FyZC1ib3VuY2VzQGxpc3RzLnhlbnByb2plY3Qub3JnPiBb YWR2aXNvcnktYm9hcmQtYm91bmNlc0BsaXN0cy54ZW5wcm9qZWN0Lm9yZzxtYWlsdG86YWR2aXNv cnktYm9hcmQtYm91bmNlc0BsaXN0cy54ZW5wcm9qZWN0Lm9yZz5dIG9uIGJlaGFsZiBvZiBTYXJh aCBDb253YXkgW3Njb253YXlAbGludXhmb3VuZGF0aW9uLm9yZzxtYWlsdG86c2NvbndheUBsaW51 eGZvdW5kYXRpb24ub3JnPl0NClNlbnQ6IFR1ZXNkYXksIE1hcmNoIDA0LCAyMDE0IDEyOjE2IFBN DQoNClRvOiBhZHZpc29yeS1ib2FyZEBsaXN0cy54ZW5wcm9qZWN0Lm9yZzxtYWlsdG86YWR2aXNv cnktYm9hcmRAbGlzdHMueGVucHJvamVjdC5vcmc+DQpTdWJqZWN0OiBbQWR2aXNvcnktYm9hcmRd IFhlbiBQcm9qZWN0IDQuNCBSZWxlYXNlDQoNCkhpIGV2ZXJ5b25lLg0KDQpBdHRhY2hlZCBpcyB0 aGUgWGVuIFByb2plY3QgNC40IG5ld3MgcmVsZWFzZSBhbm5vdWNlbWVudCB0aGF0IHdpbGwgZ28g b3V0IGF0IDggYS5tLiBFVCBvbiBNb25kYXksIE1hcmNoIDEwLg0KDQpJZiB5b3UgaGF2ZSBhbnkg YWRkaXRpb25hbCBjb21tZW50cyBvciBlZGl0cywgcGxlYXNlIGdldCBiYWNrIHRvIG1lIGJ5IFRo dXJzZGF5IG1vcm5pbmcgYXQgdGhlIGxhdGVzdC4NCg0KVGhhbmtzLA0KDQoNCi0tDQpTYXJhaCBD b253YXkNClBSIE1hbmFnZXINClRoZSBMaW51eCBGb3VuZGF0aW9uDQpzY29ud2F5QGxpbnV4Zm91 bmRhdGlvbi5vcmc8bWFpbHRvOnNjb253YXlAbGludXhmb3VuZGF0aW9uLm9yZz4NCig5NzgpIDU3 OC01MzAwPHRlbDolMjg5NzglMjklMjA1NzgtNTMwMD4gIENlbGwNClNreXBlOiAgc2FyYWguay5j b253YXkNCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fDQpB ZHZpc29yeS1ib2FyZCBtYWlsaW5nIGxpc3QNCkFkdmlzb3J5LWJvYXJkQGxpc3RzLnhlbnByb2pl Y3Qub3JnPG1haWx0bzpBZHZpc29yeS1ib2FyZEBsaXN0cy54ZW5wcm9qZWN0Lm9yZz4NCmh0dHA6 Ly9saXN0cy54ZW5wcm9qZWN0Lm9yZy9jZ2ktYmluL21haWxtYW4vbGlzdGluZm8vYWR2aXNvcnkt Ym9hcmQNCg0KDQpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f Xw0KQWR2aXNvcnktYm9hcmQgbWFpbGluZyBsaXN0DQpBZHZpc29yeS1ib2FyZEBsaXN0cy54ZW5w cm9qZWN0Lm9yZzxtYWlsdG86QWR2aXNvcnktYm9hcmRAbGlzdHMueGVucHJvamVjdC5vcmc+DQpo dHRwOi8vbGlzdHMueGVucHJvamVjdC5vcmcvY2dpLWJpbi9tYWlsbWFuL2xpc3RpbmZvL2Fkdmlz b3J5LWJvYXJkDQoNCg0KDQoNCi0tDQpTYXJhaCBDb253YXkNClBSIE1hbmFnZXINClRoZSBMaW51 eCBGb3VuZGF0aW9uDQpzY29ud2F5QGxpbnV4Zm91bmRhdGlvbi5vcmc8bWFpbHRvOnNjb253YXlA bGludXhmb3VuZGF0aW9uLm9yZz4NCig5NzgpIDU3OC01MzAwPHRlbDolMjg5NzglMjklMjA1Nzgt NTMwMD4gIENlbGwNClNreXBlOiAgc2FyYWguay5jb253YXkNCl9fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fDQpBZHZpc29yeS1ib2FyZCBtYWlsaW5nIGxpc3QN CkFkdmlzb3J5LWJvYXJkQGxpc3RzLnhlbnByb2plY3Qub3JnPG1haWx0bzpBZHZpc29yeS1ib2Fy ZEBsaXN0cy54ZW5wcm9qZWN0Lm9yZz4NCmh0dHA6Ly9saXN0cy54ZW5wcm9qZWN0Lm9yZy9jZ2kt YmluL21haWxtYW4vbGlzdGluZm8vYWR2aXNvcnktYm9hcmQNCg0KDQotLSBJTVBPUlRBTlQgTk9U SUNFOiBUaGUgY29udGVudHMgb2YgdGhpcyBlbWFpbCBhbmQgYW55IGF0dGFjaG1lbnRzIGFyZSBj b25maWRlbnRpYWwgYW5kIG1heSBhbHNvIGJlIHByaXZpbGVnZWQuIElmIHlvdSBhcmUgbm90IHRo ZSBpbnRlbmRlZCByZWNpcGllbnQsIHBsZWFzZSBub3RpZnkgdGhlIHNlbmRlciBpbW1lZGlhdGVs eSBhbmQgZG8gbm90IGRpc2Nsb3NlIHRoZSBjb250ZW50cyB0byBhbnkgb3RoZXIgcGVyc29uLCB1 c2UgaXQgZm9yIGFueSBwdXJwb3NlLCBvciBzdG9yZSBvciBjb3B5IHRoZSBpbmZvcm1hdGlvbiBp biBhbnkgbWVkaXVtLiBUaGFuayB5b3UuDQoNCkFSTSBMaW1pdGVkLCBSZWdpc3RlcmVkIG9mZmlj ZSAxMTAgRnVsYm91cm4gUm9hZCwgQ2FtYnJpZGdlIENCMSA5TkosIFJlZ2lzdGVyZWQgaW4gRW5n bGFuZCAmIFdhbGVzLCBDb21wYW55IE5vOiAyNTU3NTkwDQpBUk0gSG9sZGluZ3MgcGxjLCBSZWdp c3RlcmVkIG9mZmljZSAxMTAgRnVsYm91cm4gUm9hZCwgQ2FtYnJpZGdlIENCMSA5TkosIFJlZ2lz dGVyZWQgaW4gRW5nbGFuZCAmIFdhbGVzLCBDb21wYW55IE5vOiAyNTQ4NzgyDQoNCl9fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fDQpBZHZpc29yeS1ib2FyZCBt YWlsaW5nIGxpc3QNCkFkdmlzb3J5LWJvYXJkQGxpc3RzLnhlbnByb2plY3Qub3JnPG1haWx0bzpB ZHZpc29yeS1ib2FyZEBsaXN0cy54ZW5wcm9qZWN0Lm9yZz4NCmh0dHA6Ly9saXN0cy54ZW5wcm9q ZWN0Lm9yZy9jZ2ktYmluL21haWxtYW4vbGlzdGluZm8vYWR2aXNvcnktYm9hcmQNCg0KDQoNCg0K LS0NClNhcmFoIENvbndheQ0KUFIgTWFuYWdlcg0KVGhlIExpbnV4IEZvdW5kYXRpb24NCnNjb253 YXlAbGludXhmb3VuZGF0aW9uLm9yZzxtYWlsdG86c2NvbndheUBsaW51eGZvdW5kYXRpb24ub3Jn Pg0KKDk3OCkgNTc4LTUzMDAgIENlbGwNClNreXBlOiAgc2FyYWguay5jb253YXkNCjxYZW5Qcm9q ZWN0VXBkYXRlNC40My42LjIwMTQoMilkb2N4Pl9fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fDQpBZHZpc29yeS1ib2FyZCBtYWlsaW5nIGxpc3QNCkFkdmlzb3J5 LWJvYXJkQGxpc3RzLnhlbnByb2plY3Qub3JnPG1haWx0bzpBZHZpc29yeS1ib2FyZEBsaXN0cy54 ZW5wcm9qZWN0Lm9yZz4NCmh0dHA6Ly9saXN0cy54ZW5wcm9qZWN0Lm9yZy9jZ2ktYmluL21haWxt YW4vbGlzdGluZm8vYWR2aXNvcnktYm9hcmQNCg0K --_000_545D5AEE789B45349983A9EA3FD1ECC1citrixcom_ Content-Type: text/html; charset="utf-8" Content-ID: Content-Transfer-Encoding: base64 PGh0bWw+DQo8aGVhZD4NCjxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0i dGV4dC9odG1sOyBjaGFyc2V0PXV0Zi04Ij4NCjwvaGVhZD4NCjxib2R5Pg0KPGRpdiBzdHlsZT0i d29yZC13cmFwOmJyZWFrLXdvcmQiPlNhcmFoLCZuYnNwOw0KPGRpdj48YnI+DQo8L2Rpdj4NCjxk aXY+QnJhbmRpbmcgc2VlbXMgdG8gYmUgYXBwbGllZCBhcHByb3ByaWF0ZWx5IHRob3VnaCBJIHRo aW5rIHRoZXJlIHdlcmUgYSBjb3VwbGUgb2Ygc3BlbGxpbmcgaXNzdWVzIEkgY2F1Z2h0LiBBdHRh Y2hlZCBpcyBmaW5lIGJ5IG1lIHRob3VnaCB0aGUgYnJhbmRpbmcgYW5kIGZsb3cgaXMgc3RpbGwg YSBiaXQgY2hhbGxlbmdpbmcuJm5ic3A7PC9kaXY+DQo8ZGl2Pjxicj4NCjwvZGl2Pg0KPGRpdj5N YXJrJm5ic3A7PC9kaXY+DQo8ZGl2Pjxicj4NCjwvZGl2Pg0KPGRpdj48L2Rpdj4NCjwvZGl2Pg0K PGRpdiBzdHlsZT0id29yZC13cmFwOmJyZWFrLXdvcmQiPg0KPGRpdj48L2Rpdj4NCjxkaXY+PGJy Pg0KPC9kaXY+DQo8ZGl2Pg0KPGRpdj4NCjxkaXY+T24gTWFyIDcsIDIwMTQsIGF0IDEwOjEzIEFN LCBTYXJhaCBDb253YXkgJmx0OzxhIGhyZWY9Im1haWx0bzpzY29ud2F5QGxpbnV4Zm91bmRhdGlv bi5vcmciPnNjb253YXlAbGludXhmb3VuZGF0aW9uLm9yZzwvYT4mZ3Q7IHdyb3RlOjwvZGl2Pg0K PGJyIGNsYXNzPSJ4X0FwcGxlLWludGVyY2hhbmdlLW5ld2xpbmUiPg0KPGJsb2NrcXVvdGUgdHlw ZT0iY2l0ZSI+DQo8ZGl2IGRpcj0ibHRyIj5IaSBldmVyeW9uZS4NCjxkaXY+PGJyPg0KPC9kaXY+ DQo8ZGl2PkkndmUgaW5jb3Jwb3JhdGVkIGV2ZXJ5b25lJ3MgZWRpdHMuIEkgdHJpZWQgdG8gcmVj b25jaWxlIHRoZSBUTS1yZWxhdGVkIGlzc3VlcyBvZiBicmFuZCBjb25mdXNpb24gYW5kIGZsb3cg YXMgYmVzdCBJIGNvdWxkLiBBcyB5b3UgY2FuIGltYWdpbmUsIEkgZ290IHZhcnlpbmcgZWRpdHMs IHdoaWNoIHN0YXJ0ZWQgdG8gY29uZmxpY3Qgd2l0aCBvbmUgYW5vdGhlci48L2Rpdj4NCjxkaXY+ PGJyPg0KPC9kaXY+DQo8ZGl2PlRoaXMgd291bGQgYmVuZWZpdCBmcm9tIGFub3RoZXIgVE0gcmV2 aWV3L2ZpbmFsIGFwcHJvdmFsLiBDYW4gc29tZW9uZSBzdGVwIHVwIHRvIGRvIHRoaXMgYW5kIG1h a2UgYSBmaW5hbCBjYWxsPyZuYnNwOzwvZGl2Pg0KPGRpdj48YnI+DQo8L2Rpdj4NCjxkaXY+TWlr ZSBELiwgQ2l0cml4IGlzIG9uIHRoZSBmdWxsIEFCIGVtYWlsIGxpc3Qgc28gdGhleSd2ZSBiZWVu IGludm9sdmVkIGluIHJldmlld3MuJm5ic3A7PC9kaXY+DQo8ZGl2Pjxicj4NCjwvZGl2Pg0KPGRp dj5QbGVhc2UgYWR2aXNlIHNvb25lc3QuJm5ic3A7PC9kaXY+DQo8ZGl2Pjxicj4NCjwvZGl2Pg0K PGRpdj5UaGFua3MsPC9kaXY+DQo8ZGl2Pjxicj4NCjwvZGl2Pg0KPGRpdj48YnI+DQo8L2Rpdj4N CjwvZGl2Pg0KPGRpdiBjbGFzcz0ieF9nbWFpbF9leHRyYSI+PGJyPg0KPGJyPg0KPGRpdiBjbGFz cz0ieF9nbWFpbF9xdW90ZSI+T24gRnJpLCBNYXIgNywgMjAxNCBhdCA4OjEzIEFNLCBSaWNoYXJk IFBoZWxhbiA8c3BhbiBkaXI9Imx0ciI+DQombHQ7PGEgaHJlZj0ibWFpbHRvOlJpY2hhcmQuUGhl bGFuQGFybS5jb20iIHRhcmdldD0iX2JsYW5rIj5SaWNoYXJkLlBoZWxhbkBhcm0uY29tPC9hPiZn dDs8L3NwYW4+IHdyb3RlOjxicj4NCjxibG9ja3F1b3RlIGNsYXNzPSJ4X2dtYWlsX3F1b3RlIiBz dHlsZT0ibWFyZ2luOjAgMCAwIC44ZXg7IGJvcmRlci1sZWZ0OjFweCAjY2NjIHNvbGlkOyBwYWRk aW5nLWxlZnQ6MWV4Ij4NCjxkaXYgc3R5bGU9ImZvbnQtc2l6ZToxNHB4OyBmb250LWZhbWlseTpD YWxpYnJpLHNhbnMtc2VyaWY7IHdvcmQtd3JhcDpicmVhay13b3JkIj4NCjxkaXY+SGksPC9kaXY+ DQo8ZGl2Pjxicj4NCjwvZGl2Pg0KPGRpdj5JIGFncmVlIHdpdGggTWFyayBhcyB0aGUgY3VycmVu dCBwcmVzcyByZWxlYXNlIGlzIGhpZ2hsaWdodGluZyBpc3N1ZXMgdGhhdCBzZWVtIHRvIG1ha2Ug dGhlIGFydGljdWxhdGlvbiBvZiBicmFuZCBhbmQgYnJhbmQgdmFsdWVzIG1vcmUgY3VtYmVyc29t ZSB0aGFuIGlzIGRlc2lyYWJsZS48L2Rpdj4NCjxkaXY+PGJyPg0KPC9kaXY+DQo8ZGl2PkknbSBo YXBweSB0byBnbyB3aXRoIHRoZSBwcm9wb3NlZCBjaGFuZ2VzIGZvciB0aGUgcmVhc29ucyBzdGF0 ZWQuPC9kaXY+DQo8ZGl2Pjxicj4NCjwvZGl2Pg0KPGRpdj5PbmUgbWlub3IgcG9pbnQsIEknZCBw cmVmZXIgJnF1b3Q7P+WQgXlzdGVtIG9uIENoaXAgKFNvQykgZGV2aWNlcy4mcXVvdDssIHR3byBz ZXRzIG9mIHBsdXJhbHMgbWFrZSBpdCB1bmNsZWFyIGhvdyBtYW55IHN5c3RlbXMgYXJlIG9uIGVh Y2ggY2hpcCBhbmQgdGhlIHBsdXJhbHMgZ2V0IHN1Ym1lcmdlZCBpbnRvIHRoZSBhY3JvbnltOyBj b21tb24gdXNhZ2Ugc2VlbXMgdG8gYmUgU29Dcy48L2Rpdj4NCjxkaXY+PGJyPg0KPC9kaXY+DQo8 ZGl2PlRoYW5rcyw8L2Rpdj4NCjxkaXY+PGJyPg0KPC9kaXY+DQo8ZGl2PjxzcGFuIHN0eWxlPSJ3 aGl0ZS1zcGFjZTpwcmUtd3JhcCI+PC9zcGFuPlJpY2hhcmQuPC9kaXY+DQo8ZGl2Pjxicj4NCjwv ZGl2Pg0KPHNwYW4+DQo8ZGl2IHN0eWxlPSJib3JkZXItcmlnaHQ6bWVkaXVtIG5vbmU7IHBhZGRp bmctcmlnaHQ6MGluOyBwYWRkaW5nLWxlZnQ6MGluOyBwYWRkaW5nLXRvcDozcHQ7IHRleHQtYWxp Z246bGVmdDsgZm9udC1zaXplOjExcHQ7IGJvcmRlci1ib3R0b206bWVkaXVtIG5vbmU7IGZvbnQt ZmFtaWx5OkNhbGlicmk7IGJvcmRlci10b3A6I2I1YzRkZiAxcHQgc29saWQ7IHBhZGRpbmctYm90 dG9tOjBpbjsgYm9yZGVyLWxlZnQ6bWVkaXVtIG5vbmUiPg0KPHNwYW4gc3R5bGU9ImZvbnQtd2Vp Z2h0OmJvbGQiPkZyb206IDwvc3Bhbj5NYXJrIEhpbmtsZSAmbHQ7PGEgaHJlZj0ibWFpbHRvOk1h cmsuSGlua2xlQGNpdHJpeC5jb20iIHRhcmdldD0iX2JsYW5rIj5NYXJrLkhpbmtsZUBjaXRyaXgu Y29tPC9hPiZndDs8YnI+DQo8c3BhbiBzdHlsZT0iZm9udC13ZWlnaHQ6Ym9sZCI+UmVwbHktVG86 IDwvc3Bhbj5BZHZpc29yeS1ib2FyZCBkaXNjdXNzaW9ucyAmbHQ7PGEgaHJlZj0ibWFpbHRvOmFk dmlzb3J5LWJvYXJkQGxpc3RzLnhlbnByb2plY3Qub3JnIiB0YXJnZXQ9Il9ibGFuayI+YWR2aXNv cnktYm9hcmRAbGlzdHMueGVucHJvamVjdC5vcmc8L2E+Jmd0Ozxicj4NCjxzcGFuIHN0eWxlPSJm b250LXdlaWdodDpib2xkIj5EYXRlOiA8L3NwYW4+RnJpZGF5LCA3IE1hcmNoIDIwMTQgMDU6MzI8 YnI+DQo8c3BhbiBzdHlsZT0iZm9udC13ZWlnaHQ6Ym9sZCI+VG86IDwvc3Bhbj5BZHZpc29yeS1i b2FyZCBkaXNjdXNzaW9ucyAmbHQ7PGEgaHJlZj0ibWFpbHRvOmFkdmlzb3J5LWJvYXJkQGxpc3Rz LnhlbnByb2plY3Qub3JnIiB0YXJnZXQ9Il9ibGFuayI+YWR2aXNvcnktYm9hcmRAbGlzdHMueGVu cHJvamVjdC5vcmc8L2E+Jmd0Ow0KPGRpdiBjbGFzcz0iIj48YnI+DQo8c3BhbiBzdHlsZT0iZm9u dC13ZWlnaHQ6Ym9sZCI+U3ViamVjdDogPC9zcGFuPlJlOiBbQWR2aXNvcnktYm9hcmRdIFhlbiBQ cm9qZWN0IDQuNCBSZWxlYXNlPGJyPg0KPC9kaXY+DQo8L2Rpdj4NCjxkaXY+PGJyPg0KPC9kaXY+ DQo8YmxvY2txdW90ZSBzdHlsZT0iYm9yZGVyLWxlZnQ6I2I1YzRkZiA1IHNvbGlkOyBwYWRkaW5n OjAgMCAwIDU7IG1hcmdpbjowIDAgMCA1Ij4NCjxkaXY+DQo8ZGl2IHN0eWxlPSJ3b3JkLXdyYXA6 YnJlYWstd29yZCI+TXkgYXBvbG9naWVzIGZvciB0aGUgc2xvdyByZXBseSBJIHdhcyBzdHVjayBv biB0aGUgcm9hZCBhbmQgY291bGRuPz8gcmVhZCB0aGUgcmVsZWFzZSBvbiBteSBwaG9uZSB0byBm b3JtdWxhdGUgYSBwcm9wZXIgcmVzcG9uc2UuIEkgc2hvdWxkIG1vdmUgdG8gYSBoaWdobHkgZWxh c3RpYyBYZW4gUHJvamVjdC1wb3dlcmVkIGNsb3VkIHRoYXQgYWxsb3dzIG1lIHRvIGF1dG9zY2Fs ZSA7KSAoc29ycnkNCiBiYWQgY2xvdWQgam9rZSkuJm5ic3A7DQo8ZGl2Pjxicj4NCjwvZGl2Pg0K PGRpdj5JIGFtIGZpbmUgd2l0aG91dCBkb2luZyB0aGUgYWNyb255bSBhbmQgSSB0aGluayB0aGUg cmVhbGlnbmluZyBhbmQgYnJhbmRpbmcgZGlzY3Vzc2lvbiBzaG91bGQgYmUgaGFkLiBJPz8gbGlr ZSB0byBoYXZlIHRoYXQgZGlzY3Vzc2lvbiBkdXJpbmcgb3VyIG5leHQgYm9hcmQgbWVldGluZy4g R2l2ZW4gdGltZSBpcyBvZiB0aGUgZXNzZW5jZSBJIHRoaW5rIHdlIHNob3VsZCBqdXN0IHVwZGF0 ZSB0aGUgbGlua3MgdG8gdmVyc2lvbiB2ZXJzdXMNCiBYZW4gNC4zLjEuJm5ic3A7PC9kaXY+DQo8 ZGl2Pjxicj4NCjwvZGl2Pg0KPGRpdj5BbHNvIEkgdG9vayBhIHNob3QgYXQgdGhlIHdvcmRpbmcg b2YgdGhlIHByZXNzIHJlbGVhc2UuIEl0Pz8gcHJvYmFibHkgbm90IHBlcmZlY3QgYnV0IG1ha2Vz IGl0IHJlYWQgYSBiaXQgYmV0dGVyLiBBdHRhY2hlZCBhcmUgbXkgcHJvcG9zZWQgZWRpdHMuIFNh cmFoLCBJIHNlbnQgeW91IHRoZSB3b3JkIGRvYyB3aXRoIHRyYWNrIGNoYW5nZXMgYXNzdW1pbmcg d2UgaGF2ZSBzb21lIGVkaXRzIHRvIGFncmVlIG9uLiZuYnNwOzwvZGl2Pg0KPGRpdj48YnI+DQo8 L2Rpdj4NCjxkaXY+PGJyPg0KPC9kaXY+DQo8ZGl2PlJlZ2FyZHMsIE1hcmsmbmJzcDs8L2Rpdj4N CjxkaXY+PGJyPg0KPC9kaXY+DQo8ZGl2Pg0KPGRpdiBjbGFzcz0iIj4NCjxwIGFsaWduPSJjZW50 ZXIiIHN0eWxlPSJtYXJnaW4tYm90dG9tOjExLjBwdDsgdGV4dC1hbGlnbjpjZW50ZXIiPjxzcGFu IHN0eWxlPSJmb250LXNpemU6MTJwdDsgZm9udC1mYW1pbHk6J0FyaWFsIEJvbGQnIj5YZW4gUHJv amVjdCBSZWxlYXNlcyBVcGRhdGUgdG8gRW50ZXJwcmlzZSBIeXBlcnZpc29yIFNvZnR3YXJlPC9z cGFuPjxzcGFuIHN0eWxlPSJmb250LXNpemU6MTJwdDsgZm9udC1mYW1pbHk6J0FyaWFsIEJvbGQn Ij48dT48L3U+PHU+PC91Pjwvc3Bhbj48L3A+DQo8cCBhbGlnbj0iY2VudGVyIiBzdHlsZT0ibWFy Z2luLWJvdHRvbToxMXB0OyB0ZXh0LWFsaWduOmNlbnRlciI+PGI+PGk+PHNwYW4gc3R5bGU9ImZv bnQtc2l6ZToxMi4wcHQ7IGJhY2tncm91bmQ6d2hpdGUiPk9wZW4gU291cmNlIFZpcnR1YWxpemF0 aW9uIFNvZnR3YXJlIFJlbGVhc2UgSW5jbHVkZXMgQWRkaXRpb25hbCBBUk0gU3VwcG9ydCBhbmQg U2NhbGFiaWxpdHkgZm9yIENsb3VkIGFuZCBNb2JpbGUgRW52aXJvbm1lbnRzJm5ic3A7DQo8dT48 L3U+PHU+PC91Pjwvc3Bhbj48L2k+PC9iPjwvcD4NCjxwIGFsaWduPSJjZW50ZXIiIHN0eWxlPSJt YXJnaW4tYm90dG9tOjExcHQ7IHRleHQtYWxpZ246Y2VudGVyIj48Yj48aT48c3BhbiBzdHlsZT0i Zm9udC1zaXplOjEyLjBwdDsgYmFja2dyb3VuZDp3aGl0ZSI+PHU+PC91PiZuYnNwOzx1PjwvdT48 L3NwYW4+PC9pPjwvYj48L3A+DQo8L2Rpdj4NCjxwIHN0eWxlPSJtYXJnaW4tYm90dG9tOjExcHQi PjxzcGFuIHN0eWxlPSJmb250LXNpemU6MTJwdDsgZm9udC1mYW1pbHk6J0FyaWFsIEJvbGQnIj5T QU4gRlJBTkNJU0NPLCBNYXJjaCAxMCwgMjAxNDwvc3Bhbj48c3BhbiBzdHlsZT0iZm9udC1zaXpl OjEyLjBwdDsgYmFja2dyb3VuZDp3aGl0ZSI+ID8/L3NwYW4mZ3Q7PHNwYW4gc3R5bGU9ImZvbnQt c2l6ZToxMi4wcHQ7IGJhY2tncm91bmQ6d2hpdGUiPiBYZW4gUHJvamVjdCwgYSBDb2xsYWJvcmF0 aXZlDQogUHJvamVjdCBob3N0ZWQgYXQgVGhlIExpbnV4IEZvdW5kYXRpb24sIHRvZGF5IGFubm91 bmNlZCBhdmFpbGFiaWxpdHkgb2YgdGhlIFhlbiBQcm9qZWN0IDQuNCB3aXRoIGVuaGFuY2VkIEFS TSBzdXBwb3J0LiBUaGUgbGF0ZXN0IHJlbGVhc2UgYWxzbyBpbmNsdWRlcyBtYWpvciBwZXJmb3Jt YW5jZSBhbmQgc3lzdGVtIHNjYWxhYmlsaXR5IGltcHJvdmVtZW50cyBmb3IgZW50ZXJwcmlzZSBj b21wdXRpbmcsIHN1Y2ggYXMgbW9iaWxlIGFuZCBjbG91ZA0KIGVudmlyb25tZW50cywgd2hlcmUg dmlydHVhbGl6YXRpb24gdGVjaG5vbG9neSBpcyBpbmNyZWFzaW5nbHkgaW4gZGVtYW5kLiA8dT48 L3U+PHU+PC91Pjwvc3Bhbj48L3NwYW4+PC9wPg0KPHAgc3R5bGU9Im1hcmdpbi1ib3R0b206MTFw dCI+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZToxMi4wcHQ7IGJhY2tncm91bmQ6d2hpdGUiPlRoaXMg cmVsZWFzZSBmdXJ0aGVyIGFkdmFuY2VzIHRoZSBQcm9qZWN0PC9zcGFuPjxzcGFuIGxhbmc9IkZS IiBzdHlsZT0iZm9udC1zaXplOjEyLjBwdDsgYmFja2dyb3VuZDp3aGl0ZSI+Pz8vc3BhbiZndDs8 c3BhbiBzdHlsZT0iZm9udC1zaXplOjEyLjBwdDsgYmFja2dyb3VuZDp3aGl0ZSI+cyBwb3NpdGlv biBhcw0KIGEgZmFzdCwgc2NhbGFibGUsIHNlY3VyZSB2aXJ0dWFsaXphdGlvbiBlbmdpbmUgZm9y IHRoZSBpbmR1c3RyeTwvc3Bhbj48c3BhbiBsYW5nPSJGUiI+Pz8vc3BhbiZndDs8c3BhbiBzdHls ZT0iZm9udC1zaXplOjEyLjBwdDsgYmFja2dyb3VuZDp3aGl0ZSI+cyBicm9hZGVzdCByYW5nZSBv ZiBzZXJ2ZXIsIFBDIGNoaXBzZXRzIGFuZCBuZXh0LWdlbmVyYXRpb24gbG93LXBvd2VyIHN5c3Rl bXMgb24gY2hpcHMgKFNvQykuDQo8dT48L3U+PHU+PC91Pjwvc3Bhbj48L3NwYW4+PC9zcGFuPjwv cD4NCjxkaXYgY2xhc3M9IiI+DQo8cCBzdHlsZT0ibWFyZ2luLWJvdHRvbToxMXB0Ij48c3BhbiBz dHlsZT0iZm9udC1zaXplOjEyLjBwdDsgYmFja2dyb3VuZDp3aGl0ZSI+TWFqb3IgY29udHJpYnV0 aW9ucyBmcm9tIEFNRCwgQ2l0cml4LCBJbnRlbCwgT3JhY2xlIGFuZCBTVVNFIGFyZSBwdXNoaW5n IHRoZSBYZW4gUHJvamVjdCBzb2Z0d2FyZSB0byB0YWtlIGFkdmFudGFnZSBvZiB0aGUgbGF0ZXN0 IGhhcmR3YXJlLiBBZGRpdGlvbmFsbHksIGRldmVsb3BlcnMgY3JlYXRpbmcgc2VydmljZXMNCiBh bmQgYXBwcyB3aXRoIGVtYmVkZGVkLCBtb2JpbGUgYW5kIGNsb3VkIHN5c3RlbXMgd2lsbCBiZW5l Zml0IGZyb20gbmV3IGZlYXR1cmVzIHN1Y2ggYXMgZXZlbnQgY2hhbm5lbGluZyB3aGVuIHNjYWxp bmcgb3V0IHRoZWlyIEluZnJhc3RydWN0dXJlIGFzIGEgU2VydmljZSBvZmZlcmluZ3MuPHU+PC91 Pjx1PjwvdT48L3NwYW4+PC9wPg0KPC9kaXY+DQo8cCBzdHlsZT0ibWFyZ2luLWJvdHRvbToxMXB0 Ij48c3BhbiBzdHlsZT0iZm9udC1zaXplOjEyLjBwdDsgYmFja2dyb3VuZDp3aGl0ZSI+Pz8vc3Bh biZndDs8c3BhbiBzdHlsZT0iZm9udC1zaXplOjEyLjBwdDsgYmFja2dyb3VuZDp3aGl0ZSI+Vmly dHVhbGl6YXRpb24gYW5kIGxvdy1wb3dlcmVkIHNlcnZlcnMgYXJlIGxlYWRpbmcgY29tcGFuaWVz IHRvIHJldGhpbmsgdGhlIGRhdGEgY2VudGVyIGFuZCBpdHMgcG90ZW50aWFsIGZvciBlZmZpY2ll bmN5LDwvc3Bhbj48c3BhbiBzdHlsZT0iZm9udC1zaXplOjEyLjBwdDsgYmFja2dyb3VuZDp3aGl0 ZSI+Pz8NCjwvc3Bhbj48c3BhbiBzdHlsZT0iZm9udC1zaXplOjEyLjBwdDsgYmFja2dyb3VuZDp3 aGl0ZSI+c2FpZCBMYXJzIEt1cnRoLCBDaGFpcm1hbiBvZiB0aGUgWGVuIFByb2plY3QgYWR2aXNv cnkgYm9hcmQuDQo8L3NwYW4+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZToxMi4wcHQ7IGJhY2tncm91 bmQ6d2hpdGUiPj8/L3NwYW4mZ3Q7PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZToxMi4wcHQ7IGJhY2tn cm91bmQ6d2hpdGUiPk91ciBzb2x1dGlvbiBjb250YWlucyBJVC1yZWxhdGVkIGNvc3RzLCBwbHVz IG1lZXRzIHRoZSBzZWN1cml0eSBhbmQgc2NhbGFiaWxpdHkgbmVlZHMgb2YgdG9kYXk8L3NwYW4+ PHNwYW4gbGFuZz0iRlIiIHN0eWxlPSJmb250LXNpemU6MTIuMHB0OyBiYWNrZ3JvdW5kOndoaXRl Ij4/Py9zcGFuJmd0OzxzcGFuIHN0eWxlPSJmb250LXNpemU6MTIuMHB0OyBiYWNrZ3JvdW5kOndo aXRlIj5zDQogZWxhc3RpYyBjbG91ZCwgbW9iaWxlIGFuZCBzb2NpYWwgbmV0d29ya2luZyBjb21w YW5pZXMuIFRoZSBsYXRlc3QgdXBkYXRlcyBjb250aW51ZSB0aGUgUHJvamVjdDwvc3Bhbj48c3Bh biBsYW5nPSJGUiI+Pz8vc3BhbiZndDs8c3BhbiBzdHlsZT0iZm9udC1zaXplOjEyLjBwdDsgYmFj a2dyb3VuZDp3aGl0ZSI+cyB0cmFjayByZWNvcmQgb2YgcmljaCBjb2xsYWJvcmF0aW9uIGFuZCB3 aWRlc3ByZWFkIGRldmVsb3BtZW50IGZyb20gbWFueSBvZiB0aGUgd29ybGQ8L3NwYW4+PHNwYW4g bGFuZz0iRlIiIHN0eWxlPSJmb250LXNpemU6MTIuMHB0OyBiYWNrZ3JvdW5kOndoaXRlIj4/Py9z cGFuJmd0OzxzcGFuIHN0eWxlPSJmb250LXNpemU6MTIuMHB0OyBiYWNrZ3JvdW5kOndoaXRlIj5z DQogdGVjaG5vbG9neSBsZWFkZXJzLiBUaGlzIGNlcnRhaW5seSBleHBsYWlucyB0aGUgc2lnbmlm aWNhbnQgZ3Jvd3RoIG9mIEFSTSBzdXBwb3J0LCB3aGljaCB3ZTwvc3Bhbj48c3BhbiBsYW5nPSJG UiIgc3R5bGU9ImZvbnQtc2l6ZToxMi4wcHQ7IGJhY2tncm91bmQ6d2hpdGUiPj8/L3NwYW4mZ3Q7 PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZToxMi4wcHQ7IGJhY2tncm91bmQ6d2hpdGUiPnJlIHBsZWFz ZWQgdG8gc2VlIGFkdmFuY2Ugc28gcXVpY2tseS48L3NwYW4+PHNwYW4gc3R5bGU9ImZvbnQtc2l6 ZToxMi4wcHQ7IGJhY2tncm91bmQ6d2hpdGUiPj8/L3NwYW4mZ3Q7PHNwYW4gc3R5bGU9ImZvbnQt c2l6ZToxMi4wcHQ7IGJhY2tncm91bmQ6d2hpdGUiPjx1PjwvdT48dT48L3U+PC9zcGFuPjwvc3Bh bj48L3NwYW4+PC9zcGFuPjwvc3Bhbj48L3NwYW4+PC9zcGFuPjwvc3Bhbj48L3A+DQo8ZGl2IGNs YXNzPSIiPg0KPHAgc3R5bGU9Im1hcmdpbi1ib3R0b206MTFwdCI+PHNwYW4gc3R5bGU9ImZvbnQt c2l6ZToxMnB0OyBmb250LWZhbWlseTonQXJpYWwgQm9sZCciPlN1cHBvcnQgZm9yIEFSTSBvbiBY ZW4gUHJvamVjdCBBcmNoaXRlY3R1cmUgR3Jvd3MgUXVpY2tseQ0KPC9zcGFuPjxzcGFuIHN0eWxl PSJmb250LXNpemU6MTJwdDsgZm9udC1mYW1pbHk6J0FyaWFsIEJvbGQnIj48dT48L3U+PHU+PC91 Pjwvc3Bhbj48L3A+DQo8L2Rpdj4NCjxwPjxzcGFuIHN0eWxlPSJmb250LXNpemU6MTIuMHB0OyBi YWNrZ3JvdW5kOndoaXRlIj5UaGUgbmV3IHJlbGVhc2UgaW50cm9kdWNlcyBzaWduaWZpY2FudCBz dGFiaWxpdHksIHVzYWJpbGl0eSBhbmQgcGVyZm9ybWFuY2UgaW1wcm92ZW1lbnRzIGZvciB0aGUg QVJNIGFyY2hpdGVjdHVyZSBhbmQgZXh0ZW5kZWQgaGFyZHdhcmUgY29tcGF0aWJpbGl0eS4mbmJz cDsgQXBwbGllZE1pY3JvPC9zcGFuPjxzcGFuIGxhbmc9IkZSIiBzdHlsZT0iZm9udC1zaXplOjEy LjBwdDsgYmFja2dyb3VuZDp3aGl0ZSI+Pz8vc3BhbiZndDs8c3BhbiBzdHlsZT0iZm9udC1zaXpl OjEyLjBwdDsgYmFja2dyb3VuZDp3aGl0ZSI+cw0KIFgtR2VuZSwgdGhlIEFybmRhbGUgQm9hcmQs IENhbHhlZGEgRUNYLTIwMDAsIFRJIE9NQVA1IGFuZCB0aGUgQWxsd2lubmVyIFN1blhpIGJvYXJk cyBhcmUgYWxsIHN1cHBvcnRlZC4gVGhlIHN1YnN0YW50aWFsbHkgaW1wcm92ZWQgbXVsdGlwbGF0 Zm9ybSBjYXBhYmlsaXRpZXMgb2YgdGhlIGh5cGVydmlzb3IgYWxsb3cgaGFyZHdhcmUgYW5kIGVt YmVkZGVkIHZlbmRvcnMgdG8gcG9ydCB0aGUgWGVuIFByb2plY3QgdGVjaG5vbG9neSB0byBuZXcg QVJNDQogU29DcyBlYXNpbHksIHNob3J0ZW5pbmcgdGhlaXIgdGltZSB0byBtYXJrZXQuPHU+PC91 Pjx1PjwvdT48L3NwYW4+PC9zcGFuPjwvcD4NCjxkaXYgY2xhc3M9IiI+DQo8cD48c3BhbiBzdHls ZT0iZm9udC1zaXplOjEyLjBwdDsgYmFja2dyb3VuZDp3aGl0ZSI+PHU+PC91PiZuYnNwOzx1Pjwv dT48L3NwYW4+PC9wPg0KPHA+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZToxMi4wcHQ7IGJhY2tncm91 bmQ6d2hpdGUiPkFkZGl0aW9uYWwgZW5oYW5jZW1lbnRzIGluIHRoaXMgcmVsZWFzZSBpbmNsdWRl ZCA2NC1iaXQgZ3Vlc3Qgc3VwcG9ydCBvbiBBUk12OCBwbGF0Zm9ybXMuIEFsbCB0aGUgdXNlcnNw YWNlIHRvb2xzLCBzdWNoIGFzIHRoZSB4bCBtYW5hZ2VtZW50IHRvb2wsIGFyZSA2NC1iaXQgcmVh ZHkgYW5kIGNhbiBiZSB1c2VkIHRvIGNyZWF0ZSA2NC1iaXQgdmlydHVhbA0KIG1hY2hpbmVzIG91 dCBvZiB0aGUgYm94Ljx1PjwvdT48dT48L3U+PC9zcGFuPjwvcD4NCjxwPjxzcGFuIHN0eWxlPSJm b250LXNpemU6MTIuMHB0OyBiYWNrZ3JvdW5kOndoaXRlIj48dT48L3U+Jm5ic3A7PHU+PC91Pjwv c3Bhbj48L3A+DQo8cD48c3BhbiBzdHlsZT0iZm9udC1zaXplOjEyLjBwdDsgYmFja2dyb3VuZDp3 aGl0ZSI+VGhlIFhlbiBQcm9qZWN0IGh5cGVyY2FsbCBBQkkgaXMgbm93IHN0YWJsZSBhbmQgd2ls bCBiZSBtYWludGFpbmVkIGZvciBiYWNrd2FyZCBjb21wYXRpYmlsaXR5LCBzbyB1c2VycyBjYW4g dHJ1c3QgZnV0dXJlIHJlbGVhc2VzIHRvIGJvb3Qgb2xkZXIgb3BlcmF0aW5nIHN5c3RlbXMuPC9z cGFuPjxzcGFuIHN0eWxlPSJmb250LXNpemU6MTJwdDsgZm9udC1mYW1pbHk6J0FyaWFsIEJvbGQn Ij48L3NwYW4+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZToxMnB0OyBmb250LWZhbWlseTonQXJpYWwg Qm9sZCciPjx1PjwvdT48dT48L3U+PC9zcGFuPjwvcD4NCjxwPjxzcGFuIHN0eWxlPSJmb250LXNp emU6MTIuMHB0OyBiYWNrZ3JvdW5kOndoaXRlIj5BZGRpdGlvbmFsIGltcHJvdmVtZW50cyBpbmNs dWRlIGV4dGVuZGVkIHN1cHBvcnQgZm9yIEFSTSBzcGVjaWZpYyBib290bG9hZGVycyBhbmQgZmly bXdhcmUgaW50ZXJmYWNlcywgYW5kIHN1cHBvcnQgZm9yIHBoeXNpY2FsIHBhcnRpdGlvbnMgYW5k IExWTSB2b2x1bWVzIHRvIHN0b3JlIGRpc2tzIG9mIHZpcnR1YWwgbWFjaGluZXMuDQo8dT48L3U+ PHU+PC91Pjwvc3Bhbj48L3A+DQo8cD48c3BhbiBzdHlsZT0iZm9udC1zaXplOjEyLjBwdDsgYmFj a2dyb3VuZDp3aGl0ZSI+PHU+PC91PiZuYnNwOzx1PjwvdT48L3NwYW4+PC9wPg0KPHAgc3R5bGU9 Im1hcmdpbi1ib3R0b206MTFwdCI+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZToxMnB0OyBmb250LWZh bWlseTonQXJpYWwgQm9sZCciPkltcHJvdmVkIEV2ZW50IENoYW5uZWwgU2NhbGFiaWxpdHkgRm9y IENsb3VkIENvbXB1dGluZzwvc3Bhbj48c3BhbiBzdHlsZT0iZm9udC1zaXplOjEycHQ7IGZvbnQt ZmFtaWx5OidBcmlhbCBCb2xkJyI+PHU+PC91Pjx1PjwvdT48L3NwYW4+PC9wPg0KPHAgc3R5bGU9 Im1hcmdpbi1ib3R0b206MTFwdCI+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZToxMi4wcHQ7IGJhY2tn cm91bmQ6d2hpdGUiPlhlbiBQcm9qZWN0IGRldmVsb3BlcnMgY29udGludWVzIHRvIGRyaXZlIGlu bm92YXRpb24gYW5kIGNvbGxhYm9yYXRpb24gYXJvdW5kIHNlcnZlciB2aXJ0dWFsaXphdGlvbiBh bmQgdGhlIGNsb3VkLiBQb3dlcmluZyBtYW55IG9mIHRoZSBsYXJnZXN0IGNsb3VkcyBpbiBwcm9k dWN0aW9uIHRvZGF5LCBpbmNsdWRpbmcNCiBBbWF6b24gRUMyLCBSYWNrc3BhY2UgQ2xvdWQgYW5k IG90aGVycywgdGhlIGNvbW11bml0eSB1bmRlcnN0YW5kcyB0aGUgbmVlZCB0byBydW4gbW9yZSB2 aXJ0dWFsIG1hY2hpbmVzIG9uIGEgc2luZ2xlIGhvc3QuDQo8dT48L3U+PHU+PC91Pjwvc3Bhbj48 L3A+DQo8cCBzdHlsZT0ibWFyZ2luLWJvdHRvbToxMXB0Ij48c3BhbiBzdHlsZT0iZm9udC1zaXpl OjEyLjBwdDsgYmFja2dyb3VuZDp3aGl0ZSI+WWV0IGRlbWFuZHMgb24gaHlwZXJ2aXNvciBzY2Fs YWJpbGl0eSBjb250aW51ZSB0byBpbmNyZWFzZSwgYm90aCBmcm9tIGxhcmdlciBtYWNoaW5lcywg bmV3IHdvcmtsb2FkcyBzdWNoIGFzIHZpcnR1YWxpemF0aW9uIGRlc2t0b3AgaW5mcmFzdHJ1Y3R1 cmVzIChWREkpIGFuZCBuZXcgY2xvdWQgT1MgdGVjaG5vbG9naWVzLA0KIGluY2x1ZGluZyBNaXJh Z2VPUywgRXJsYW5nT25YZW4sIE9TdiwgYW5kIEhhbFZNLiBSZWNvZ25pemluZyB0aGF0IGhpZ2gt YXZhaWxhYmlsaXR5IGFuZCBzdGFiaWxpdHkgYXJlIGNyaXRpY2FsIHRvIFZESXMgYW5kIGNsb3Vk IGRlcGxveW1lbnRzOyB0aGUgWGVuU2VydmVyIHRlYW0gYXQgQ2l0cml4IGNvbnRyaWJ1dGVkIHRo ZSBuZXcgZXZlbnQgY2hhbm5lbCBpbXBsZW1lbnRhdGlvbiB0byB0aGUgWGVuIFByb2plY3QuIFRv IGhlbHAgZWxpbWluYXRlDQogd29ya2xvYWQgbGltaXRhdGlvbnMgZm9yIHVzZXJzLCB0aGlzIGVu YWJsZXMgdGhlIGh5cGVydmlzb3IgdG8gcnVuIHRob3VzYW5kcyBvZiBndWVzdHMgb24gYSBzaW5n bGUgcGh5c2ljYWwgbWFjaGluZS4mbmJzcDsmbmJzcDsmbmJzcDsNCjx1PjwvdT48dT48L3U+PC9z cGFuPjwvcD4NCjxwIHN0eWxlPSJtYXJnaW4tYm90dG9tOjExcHQiPjxzcGFuIHN0eWxlPSJmb250 LXNpemU6MTJwdDsgZm9udC1mYW1pbHk6J0FyaWFsIEJvbGQnIj5FeHBlcmltZW50YWwgU3VwcG9y dCBmb3IgUFZIIE1vZGUgZm9yIEd1ZXN0DQo8L3NwYW4+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZTox MnB0OyBmb250LWZhbWlseTonQXJpYWwgQm9sZCciPjx1PjwvdT48dT48L3U+PC9zcGFuPjwvcD4N CjxwIHN0eWxlPSJtYXJnaW4tYm90dG9tOjExcHQiPjxzcGFuIHN0eWxlPSJmb250LXNpemU6MTIu MHB0OyBiYWNrZ3JvdW5kOndoaXRlIj5PcmFjbGUgaGFzIGNvbnRyaWJ1dGVkIGEgZnVuY3Rpb25h bCBwcmV2aWV3IG9mIGENCjwvc3Bhbj48YSBocmVmPSJodHRwOi8vYmxvZy54ZW4ub3JnL2luZGV4 LnBocC8yMDE0LzAxLzMxL2xpbnV4LTMtMTQtYW5kLXB2aC8iIHRhcmdldD0iX2JsYW5rIj48c3Bh bj48c3BhbiBzdHlsZT0iZm9udC1zaXplOjEyLjBwdCI+bmV3IHZpcnR1YWxpemF0aW9uIG1vZGUg Y2FsbGVkIFBWSCBjdXJyZW50bHkgYXZhaWxhYmxlIHRvIHZpcnR1YWxpemVkIGd1ZXN0cy4NCjwv c3Bhbj48L3NwYW4+PC9hPjxzcGFuIHN0eWxlPSJmb250LXNpemU6MTIuMHB0OyBiYWNrZ3JvdW5k OndoaXRlIj5QVkggaXMgYW4gZXh0ZW5zaW9uIHRvIHRoZSBjbGFzc2ljIFhlbiBQcm9qZWN0IFBh cmF2aXJ0dWFsaXphdGlvbiAoUFYpIHRoYXQgdXNlcyB0aGUgaGFyZHdhcmUgdmlydHVhbGl6YXRp b24gZXh0ZW5zaW9ucyBhdmFpbGFibGUgb24gbW9kZXJuIHg4NiBwcm9jZXNzb3JzLiBQVkggdXNl cyBQViBkcml2ZXJzIGZvciBib290IGFuZCBJL08NCiBhbmQgSW50ZWwgaGFyZHdhcmUgdmlydHVh bGl6YXRpb24gZXh0ZW5zaW9ucyBmb3IgcGFnZSB0YWJsZSBvcGVyYXRpb25zLCBzeXN0ZW0gY2Fs bHMgYW5kIG90aGVyIHByaXZpbGVnZWQgb3BlcmF0aW9ucy4gVGhpcyBub3Qgb25seSBpbXByb3Zl cyBwZXJmb3JtYW5jZSBhbmQgc2VjdXJpdHksIGJ1dCBhbHNvIHNpbXBsaWZpZXMgdGhlIGFyY2hp dGVjdHVyZSBhbmQgWGVuIFByb2plY3QgSHlwZXJ2aXNvci1MaW51eCBpbnRlcmZhY2Ugc2lnbmlm aWNhbnRseS4NCjx1PjwvdT48dT48L3U+PC9zcGFuPjwvcD4NCjwvZGl2Pg0KPHAgc3R5bGU9Imxp bmUtaGVpZ2h0OjEwOCUiPjxzcGFuIHN0eWxlPSJmb250LXNpemU6MTIuMHB0OyBsaW5lLWhlaWdo dDoxMDglOyBiYWNrZ3JvdW5kOndoaXRlIj4/Py9zcGFuJmd0OzxzcGFuIHN0eWxlPSJmb250LXNp emU6MTIuMHB0OyBsaW5lLWhlaWdodDoxMDglOyBmb250LWZhbWlseTpBcmlhbDsgYmFja2dyb3Vu ZDp3aGl0ZSI+UFZIIGlzIGEgbWFqb3IgZGV2ZWxvcG1lbnQgZm9yIFhlbiBQcm9qZWN0IHNvZnR3 YXJlIG9uIHg4NiBhbmQgaGFzIHRoZQ0KIHBvdGVudGlhbCB0byBncmVhdGx5IHNpbXBsaWZ5IHRo ZSBMaW51eCBpbnRlcmZhY2UgaW4gZHVlIHRpbWUsIDwvc3Bhbj48c3BhbiBzdHlsZT0iZm9udC1z aXplOjEyLjBwdDsgbGluZS1oZWlnaHQ6MTA4JTsgYmFja2dyb3VuZDp3aGl0ZSI+Pz8NCjwvc3Bh bj48c3BhbiBzdHlsZT0iZm9udC1zaXplOjEyLjBwdDsgbGluZS1oZWlnaHQ6MTA4JTsgZm9udC1m YW1pbHk6QXJpYWw7IGJhY2tncm91bmQ6d2hpdGUiPnNhaWQgS29ucmFkIFJ6ZXN6dXRlayBXaWxr LCBTb2Z0d2FyZSBEZXZlbG9wbWVudCBNYW5hZ2VyIGF0IE9yYWNsZSwgYSBYZW4gUHJvamVjdCBh ZHZpc29yeSBib2FyZCBtZW1iZXIuDQo8L3NwYW4+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZToxMi4w cHQ7IGxpbmUtaGVpZ2h0OjEwOCU7IGJhY2tncm91bmQ6d2hpdGUiPj8/L3NwYW4mZ3Q7PHNwYW4g c3R5bGU9ImZvbnQtc2l6ZToxMi4wcHQ7IGxpbmUtaGVpZ2h0OjEwOCU7IGZvbnQtZmFtaWx5OkFy aWFsOyBiYWNrZ3JvdW5kOndoaXRlIj5XZSBleHBlY3QgUFZIIHRvIGhhdmUgdGhlIGJlc3QgY2hh cmFjdGVyaXN0aWNzIG9mIGFsbCB2aXJ0dWFsaXphdGlvbiBtb2RlcyAtLSBhIHNpbXBsZSwgZmFz dCwNCiBzZWN1cmUgaW50ZXJmYWNlLCB3aXRoIGxvdyBtZW1vcnkgb3ZlcmhlYWQsIHRoYXQgYWxz byB0YWtlcyBmdWxsIGFkdmFudGFnZSBvZiB0aGUgbGF0ZXN0IGhhcmR3YXJlLjwvc3Bhbj48c3Bh biBzdHlsZT0iZm9udC1zaXplOjEyLjBwdDsgbGluZS1oZWlnaHQ6MTA4JTsgYmFja2dyb3VuZDp3 aGl0ZSI+Pz8vc3BhbiZndDs8c3Bhbj48dT48L3U+PHU+PC91Pjwvc3Bhbj48L3NwYW4+PC9zcGFu Pjwvc3Bhbj48L3A+DQo8cD48c3BhbiBzdHlsZT0iZm9udC1zaXplOjEyLjBwdDsgbGluZS1oZWln aHQ6MTE1JTsgYmFja2dyb3VuZDp3aGl0ZSI+PHU+PC91PiZuYnNwOzx1PjwvdT48L3NwYW4+PC9w Pg0KPHAgc3R5bGU9Im1hcmdpbi1ib3R0b206MTFwdCI+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZTox Mi4wcHQ7IGJhY2tncm91bmQ6d2hpdGUiPkFkZGl0aW9uYWwga2V5IHVwZGF0ZXMgaW5jbHVkZTo8 dT48L3U+PHU+PC91Pjwvc3Bhbj48L3A+DQo8cCBzdHlsZT0ibWFyZ2luOjBpbiAwaW4gMTFwdCAz NC41cHQiPuWamei4neiVrTxzcGFuIHN0eWxlPSJmb250LXNpemU6N3B0OyBmb250LWZhbWlseTon VGltZXMgTmV3IFJvbWFuJyI+Jm5ic3A7Jm5ic3A7Jm5ic3A7Jm5ic3A7DQo8L3NwYW4+PHNwYW4g c3R5bGU9ImZvbnQtc2l6ZToxMi4wcHQ7IGJhY2tncm91bmQ6d2hpdGUiPkJldHRlciBwZXJmb3Jt YW5jZSB3aXRoIG1vZGVybiBzdG9yYWdlIGRldmljZXMgYW5kIGJpZyBkYXRhIC0tIEluZGlyZWN0 IGRlc2NyaXB0b3JzIGZvciBibG9jayBQViBwcm90b2NvbCAoTGludXgpIGFsbG93IGVhY2ggaW5k aXZpZHVhbCByZXF1ZXN0IHRvIHRyaXBsZSBpbiBzaXplLCBncmVhdGx5IGltcHJvdmluZyBJL08g cGVyZm9ybWFuY2Ugd2hlbg0KIHJ1bm5pbmcgb24gZmFzdCBzdG9yYWdlIHRlY2hub2xvZ2llcyBz dWNoIGFzIHNvbGlkLXN0YXRlIGRyaXZlIGFuZCBSQUlELiBBdmFpbGFibGUgaW4gYW55IGd1ZXN0 IHJ1bm5pbmcgTGludXggMy4xMSBvciBoaWdoZXIgKHJlZ2FyZGxlc3Mgb2YgWGVuIFByb2plY3Qg dmVyc2lvbikuPC9zcGFuPjxzcGFuIHN0eWxlPSJiYWNrZ3JvdW5kOndoaXRlIj48dT48L3U+PHU+ PC91Pjwvc3Bhbj48L3A+DQo8cCBzdHlsZT0ibWFyZ2luLWJvdHRvbToxMXB0Ij48c3BhbiBzdHls ZT0iZm9udC1zaXplOjEyLjBwdDsgYmFja2dyb3VuZDp3aGl0ZSI+PHU+PC91PiZuYnNwOzx1Pjwv dT48L3NwYW4+PC9wPg0KPHAgc3R5bGU9Im1hcmdpbjowaW4gMGluIDExcHQgMzQuNXB0Ij7lmpno uJ3ola08c3BhbiBzdHlsZT0iZm9udC1zaXplOjdwdDsgZm9udC1mYW1pbHk6J1RpbWVzIE5ldyBS b21hbiciPiZuYnNwOyZuYnNwOyZuYnNwOyZuYnNwOw0KPC9zcGFuPjxzcGFuIHN0eWxlPSJmb250 LXNpemU6MTIuMHB0OyBiYWNrZ3JvdW5kOndoaXRlIj5Nb3JlIHBvd2VyZnVsIGRyaXZlciBkb21h aW5zIC0tDQo8L3NwYW4+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZToxMi4wcHQ7IGNvbG9yOiMyMjIy MjI7IGJhY2tncm91bmQ6d2hpdGUiPkRpc2sgZHJpdmVyIGRvbWFpbnMgY2FuIG5vdyB1bmlmb3Jt bHkgcnVuIGJsb2NrIHNjcmlwdHMgYW5kIHVzZXItc3BhY2UgYmFja2VuZHMsIHN1Y2ggYXMgcWRp c2ssIGJyaW5naW5nIHRoZW0gdXAgdG8gZmVhdHVyZSBwYXJpdHkgd2l0aCBkb21haW4gMC4gVGhp cyBtZWFucyBob3N0IGFkbWluaXN0cmF0b3JzIGNhbiB0YWtlDQogYWR2YW50YWdlIG9mIHRoZSBl bmhhbmNlZCBzZWN1cml0eSwgc2NhbGFiaWxpdHksIGFuZCByb2J1c3RuZXNzIHByb3ZpZGVkIGJ5 IGRyaXZlciBkb21haW5zIHdpdGhvdXQgc2FjcmlmaWNpbmcgdGhlIHdpZGUgYXJyYXkgb2YgZGlz ayBjb25maWd1cmF0aW9uIG9wdGlvbnMgcHJvdmlkZWQgYnkgWGVuIGluIGRvbTAuPC9zcGFuPjxz cGFuIHN0eWxlPSJiYWNrZ3JvdW5kOndoaXRlIj48dT48L3U+PHU+PC91Pjwvc3Bhbj48L3A+DQo8 cCBzdHlsZT0ibWFyZ2luOjBpbiAwaW4gMTFwdCAzNC41cHQiPuWamei4neiVrTxzcGFuIHN0eWxl PSJmb250LXNpemU6N3B0OyBmb250LWZhbWlseTonVGltZXMgTmV3IFJvbWFuJyI+Jm5ic3A7Jm5i c3A7Jm5ic3A7Jm5ic3A7DQo8L3NwYW4+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZToxMi4wcHQ7IGJh Y2tncm91bmQ6d2hpdGUiPk5ldyBTUElDRSBwcm90b2NvbCBzdXBwb3J0IC0tIEZ1bmN0aW9uYWxp dHkgc3VjaCBhcyBjbGlwYm9hcmQgc2hhcmluZyBhbmQgVVNCIHJlZGlyZWN0aW9uIGNyZWF0ZXMg YSBtdWNoIHJpY2hlciBjb25uZWN0aW9uIGZvciB2aXJ0dWFsIGRlc2t0b3BzIGFuZCBiZXR0ZXIg Z3JhcGhpY3MgcGVyZm9ybWFuY2UuDQo8L3NwYW4+PHNwYW4gc3R5bGU9ImJhY2tncm91bmQ6d2hp dGUiPjx1PjwvdT48dT48L3U+PC9zcGFuPjwvcD4NCjxwIHN0eWxlPSJtYXJnaW46MGluIDBpbiAx MXB0IDM0LjVwdCI+5ZqZ6Lid6JWtPHNwYW4gc3R5bGU9ImZvbnQtc2l6ZTo3cHQ7IGZvbnQtZmFt aWx5OidUaW1lcyBOZXcgUm9tYW4nIj4mbmJzcDsmbmJzcDsmbmJzcDsmbmJzcDsNCjwvc3Bhbj48 c3BhbiBzdHlsZT0iZm9udC1zaXplOjEyLjBwdDsgYmFja2dyb3VuZDp3aGl0ZSI+RW5oYW5jZWQg ZGlhZ25vc3RpY3MgYW5kIGtleGVjIGRlYnVnIHN1cHBvcnQgLS0gV2hlbiBhIGNyYXNoIGhhcHBl bnMsIGEgc3BlY2lhbCBrZXJuZWwgaXMgYWxsb3dlZCBpbW1lZGlhdGUgdG8gY29sbGVjdCBpbmZv cm1hdGlvbiBhYm91dCB0aGUgcm9vdCBjYXVzZSwgb2ZmZXJpbmcgZGV2ZWxvcGVycyBiZXR0ZXIg ZGlhZ25vc2lzIGFuZCByZXBhaXINCiBhYmlsaXRpZXMuIDwvc3Bhbj48c3BhbiBzdHlsZT0iYmFj a2dyb3VuZDp3aGl0ZSI+PHU+PC91Pjx1PjwvdT48L3NwYW4+PC9wPg0KPGRpdj4NCjxkaXYgY2xh c3M9InhfaDUiPg0KPHA+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZToxMi4wcHQiPlRoZSA0LjQgcmVs ZWFzZSBpcyB0aGUgcmVzdWx0IG9mIGEgYnJvYWQsIGNvbGxhYm9yYXRpdmUgZGV2ZWxvcG1lbnQg ZWZmb3J0IHJlcHJlc2VudGluZyBlbmdpbmVlcnMgZnJvbSBtb3JlIHRoYW4gMTMgbGVhZGluZyBo YXJkd2FyZSwgc29mdHdhcmUgYW5kIHNlY3VyaXR5IHZlbmRvcnMuIFRvcCBjb250cmlidXRvcnMg aW5jbHVkZSBBbWF6b24sIEFNRCwgQW5hbG9nIERldmljZXMsIEJyb2FkY29tLA0KIENpdHJpeCwg RnVqaXRzdSwgSW50ZWwsIExpbmFybywgTlNBLCBPcmFjbGUsIFN1c2UsIFZlcml6b24vVGVycmVt YXJrLCBwbHVzIG51bWVyb3VzIGluZGl2aWR1YWwgYW5kIGFjYWRlbWljIGNvbnRyaWJ1dG9ycy4g VGhlIGZyZWVseSBhdmFpbGFibGUgZG93bmxvYWQgY2FuIGJlIGZvdW5kIG9uIHRoZQ0KPGEgaHJl Zj0iaHR0cDovL3hlbnByb2plY3Qub3JnLyIgdGFyZ2V0PSJfYmxhbmsiPlhlblByb2plY3Qub3Jn PC9hPiB3ZWJzaXRlIChpbnNlcnQgdXJsKS48dT48L3U+PHU+PC91Pjwvc3Bhbj48L3A+DQo8ZGl2 PjxzcGFuIHN0eWxlPSJmb250LXNpemU6MTIuMHB0Ij4mbmJzcDs8L3NwYW4+PGJyIGNsYXNzPSJ4 X3dlYmtpdC1ibG9jay1wbGFjZWhvbGRlciI+DQo8L2Rpdj4NCjxwIHN0eWxlPSJtYXJnaW4tYm90 dG9tOjExcHQiPjx1PjxzcGFuIHN0eWxlPSJmb250LXNpemU6MTJwdDsgZm9udC1mYW1pbHk6J0Fy aWFsIEJvbGQnIj5BYm91dCBYZW4gUHJvamVjdDwvc3Bhbj48L3U+PHU+PHNwYW4gc3R5bGU9ImZv bnQtc2l6ZToxMnB0OyBmb250LWZhbWlseTonQXJpYWwgQm9sZCciPjx1PjwvdT48dT48L3U+PC9z cGFuPjwvdT48L3A+DQo8cCBzdHlsZT0ibWFyZ2luLWJvdHRvbToxMXB0Ij48c3BhbiBzdHlsZT0i Zm9udC1zaXplOjEyLjBwdDsgYmFja2dyb3VuZDp3aGl0ZSI+VGhlIFhlbiBQcm9qZWN0IHNvZnR3 YXJlIGlzIGFuIG9wZW4gc291cmNlIHZpcnR1YWxpemF0aW9uIHBsYXRmb3JtIGxpY2Vuc2VkIHVu ZGVyIHRoZSBHUEx2MiB3aXRoIGEgc2ltaWxhciBnb3Zlcm5hbmNlIHN0cnVjdHVyZSB0byB0aGUg TGludXgga2VybmVsLiBEZXNpZ25lZCBmcm9tIHRoZSBzdGFydCBmb3IgY2xvdWQNCiBjb21wdXRp bmcsIHRoZSBQcm9qZWN0IGhhcyBtb3JlIHRoYW4gYSBkZWNhZGUgb2YgZGV2ZWxvcG1lbnQgYW5k IGlzIGJlaW5nIHVzZWQgYnkgbW9yZSB0aGFuIDEwIG1pbGxpb24gdXNlcnMuIEEgQ29sbGFib3Jh dGl2ZSBQcm9qZWN0IGF0IFRoZSBMaW51eCBGb3VuZGF0aW9uLCB0aGUgWGVuIFByb2plY3QgdGVh bSBpcyBmb2N1c2VkIG9uIGFkdmFuY2luZyB2aXJ0dWFsaXphdGlvbiBpbiBhIG51bWJlciBvZiBk aWZmZXJlbnQgY29tbWVyY2lhbCBhbmQNCiBvcGVuIHNvdXJjZSBhcHBsaWNhdGlvbnMgaW5jbHVk aW5nIHNlcnZlciB2aXJ0dWFsaXphdGlvbiwgSW5mcmFzdHJ1Y3R1cmUgYXMgYSBTZXJ2aWNlIChJ YWFTKSwgZGVza3RvcCB2aXJ0dWFsaXphdGlvbiwgc2VjdXJpdHkgYXBwbGljYXRpb25zLCBlbWJl ZGRlZCBhbmQgaGFyZHdhcmUgYXBwbGlhbmNlcy4gSXQgY291bnRzIG1hbnkgaW5kdXN0cnkgYW5k IG9wZW4gc291cmNlIGNvbW11bml0eSBsZWFkZXJzIGFtb25nIGl0cyBtZW1iZXJzIGluY2x1ZGlu ZzoNCiBBbWF6b24gV2ViIFNlcnZpY2VzLCBBTUQsIEFSTSwgQnJvbWl1bSwgQ2FseGVkYSwgQ0Eg VGVjaG5vbG9naWVzLCBDaXNjbywgQ2l0cml4LCBHb29nbGUsIEludGVsLCBPcmFjbGUsIFNhbXN1 bmcgYW5kIFZlcml6b24uIEZvciBtb3JlIGluZm9ybWF0aW9uIGFib3V0IHRoZSBYZW4gUHJvamVj dCBoeXBlcnZpc29yIGFuZCB0byBwYXJ0aWNpcGF0ZSwgcGxlYXNlIHZpc2l0DQo8L3NwYW4+PGEg aHJlZj0iaHR0cDovL3hlbnByb2plY3Qub3JnLyIgdGFyZ2V0PSJfYmxhbmsiPjxzcGFuPjxzcGFu IHN0eWxlPSJmb250LXNpemU6MTIuMHB0OyB0ZXh0LWRlY29yYXRpb246bm9uZSI+aHR0cDovL3hl bnByb2plY3QuPC9zcGFuPjwvc3Bhbj48L2E+PGEgaHJlZj0iaHR0cDovL3hlbnByb2plY3Qub3Jn LyIgdGFyZ2V0PSJfYmxhbmsiPjxzcGFuPjxzcGFuIHN0eWxlPSJmb250LXNpemU6MTIuMHB0OyB0 ZXh0LWRlY29yYXRpb246bm9uZSI+b3JnPC9zcGFuPjwvc3Bhbj48L2E+PHNwYW4gc3R5bGU9ImZv bnQtc2l6ZToxMi4wcHQ7IGJhY2tncm91bmQ6d2hpdGUiPi48dT48L3U+PHU+PC91Pjwvc3Bhbj48 L3A+DQo8cCBhbGlnbj0iY2VudGVyIiBzdHlsZT0ibWFyZ2luLWJvdHRvbToxMS4wcHQ7IHRleHQt YWxpZ246Y2VudGVyIj48c3BhbiBzdHlsZT0iZm9udC1zaXplOjEyLjBwdDsgbGluZS1oZWlnaHQ6 MTE1JTsgYmFja2dyb3VuZDp3aGl0ZSI+IyMjPHU+PC91Pjx1PjwvdT48L3NwYW4+PC9wPg0KPHAg c3R5bGU9Im1hcmdpbi1ib3R0b206MTFwdCI+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZToxMi4wcHQ7 IGJhY2tncm91bmQ6d2hpdGUiPlNhcmFoIENvbndheQ0KPHU+PC91Pjx1PjwvdT48L3NwYW4+PC9w Pg0KPHAgc3R5bGU9Im1hcmdpbi1ib3R0b206MTFwdCI+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZTox Mi4wcHQ7IGJhY2tncm91bmQ6d2hpdGUiPlRoZSBYZW4gUHJvamVjdDx1PjwvdT48dT48L3U+PC9z cGFuPjwvcD4NCjxwIHN0eWxlPSJtYXJnaW4tYm90dG9tOjExcHQiPjxzcGFuIHN0eWxlPSJmb250 LXNpemU6MTIuMHB0OyBiYWNrZ3JvdW5kOndoaXRlIj5NZWRpYSBDb250YWN0PHU+PC91Pjx1Pjwv dT48L3NwYW4+PC9wPg0KPHAgc3R5bGU9Im1hcmdpbi1ib3R0b206MTFwdCI+PHNwYW4gc3R5bGU9 ImZvbnQtc2l6ZToxMi4wcHQ7IGJhY2tncm91bmQ6d2hpdGUiPjxhIGhyZWY9Im1haWx0bzpwdWJs aWNpdHlAbGlzdHMueGVucHJvamVjdC5vcmciIHRhcmdldD0iX2JsYW5rIj5wdWJsaWNpdHlAbGlz dHMueGVucHJvamVjdC5vcmc8L2E+PHU+PC91Pjx1PjwvdT48L3NwYW4+PC9wPg0KPC9kaXY+DQo8 L2Rpdj4NCjwvZGl2Pg0KPGRpdj48YnI+DQo8L2Rpdj4NCjxkaXY+PGJyPg0KPGRpdj4NCjxkaXY+ DQo8ZGl2IGNsYXNzPSJ4X2g1Ij4NCjxkaXY+T24gTWFyIDYsIDIwMTQsIGF0IDEyOjQ0IFBNLCBX aWxzb24sIE1hdHQgJmx0OzxhIGhyZWY9Im1haWx0bzptc3dAYW1hem9uLmNvbSIgdGFyZ2V0PSJf YmxhbmsiPm1zd0BhbWF6b24uY29tPC9hPiZndDsgd3JvdGU6PC9kaXY+DQo8YnI+DQo8L2Rpdj4N CjwvZGl2Pg0KPGJsb2NrcXVvdGUgdHlwZT0iY2l0ZSI+DQo8ZGl2IHN0eWxlPSJmb250LWZhbWls eTpIZWx2ZXRpY2E7IGZvbnQtc2l6ZToxMnB4OyBmb250LXN0eWxlOm5vcm1hbDsgZm9udC12YXJp YW50Om5vcm1hbDsgZm9udC13ZWlnaHQ6bm9ybWFsOyBsZXR0ZXItc3BhY2luZzpub3JtYWw7IGxp bmUtaGVpZ2h0Om5vcm1hbDsgdGV4dC1hbGlnbjpzdGFydDsgdGV4dC1pbmRlbnQ6MHB4OyB0ZXh0 LXRyYW5zZm9ybTpub25lOyB3aGl0ZS1zcGFjZTpub3JtYWw7IHdvcmQtc3BhY2luZzowcHgiPg0K PGRpdiBzdHlsZT0iZGlyZWN0aW9uOmx0cjsgZm9udC1mYW1pbHk6VmVyZGFuYTsgZm9udC1zaXpl OjEwcHQiPk1hcmssIHRob3VnaHRzPw0KPGRpdj48YnI+DQo8L2Rpdj4NCjxkaXY+DQo8ZGl2IHN0 eWxlPSJmb250LWZhbWlseTonVGltZXMgTmV3IFJvbWFuJzsgZm9udC1zaXplOjE2cHgiPg0KPGRp dj4NCjxkaXYgY2xhc3M9InhfaDUiPg0KPGhyPg0KPGRpdiBzdHlsZT0iZGlyZWN0aW9uOmx0ciI+ PGZvbnQgZmFjZT0iVGFob21hIj48Yj5Gcm9tOjwvYj48c3Bhbj4mbmJzcDs8L3NwYW4+V2lsc29u LCBNYXR0PGJyPg0KPGI+U2VudDo8L2I+PHNwYW4+Jm5ic3A7PC9zcGFuPldlZG5lc2RheSwgTWFy Y2ggMDUsIDIwMTQgMTA6MDEgQU08YnI+DQo8Yj5Ubzo8L2I+PHNwYW4+Jm5ic3A7PC9zcGFuPkFk dmlzb3J5LWJvYXJkIGRpc2N1c3Npb25zPGJyPg0KPGI+U3ViamVjdDo8L2I+PHNwYW4+Jm5ic3A7 PC9zcGFuPlJFOiBbQWR2aXNvcnktYm9hcmRdIFhlbiBQcm9qZWN0IDQuNCBSZWxlYXNlPGJyPg0K PC9mb250Pjxicj4NCjwvZGl2Pg0KPGRpdj48L2Rpdj4NCjwvZGl2Pg0KPC9kaXY+DQo8ZGl2Pg0K PGRpdiBzdHlsZT0iZGlyZWN0aW9uOmx0cjsgZm9udC1mYW1pbHk6VmVyZGFuYTsgZm9udC1zaXpl OjEwcHQiPg0KPGRpdj4NCjxkaXYgY2xhc3M9InhfaDUiPkknZCByYXRoZXIgdXNlICZxdW90O1hl biBQcm9qZWN0IEh5cGVydmlzb3ImcXVvdDsgdGhhbiBpbnRyb2R1Y2UgYW4gYWNyb255bS4gSSB0 aGluayBpdCdzIGltcG9ydGFudCB0aGF0ICZxdW90O1hlbiBQcm9qZWN0JnF1b3Q7IG5vdCBiZSBz cGxpdCBmcm9tICZxdW90O0h5cGVydmlzb3IuJnF1b3Q7DQo8ZGl2Pjxicj4NClRoaXMgc3RpbGwg ZG9lc24ndCBhZGRyZXNzIGhvdyB0aGUgdW1icmVsbGEgcHJvamVjdCBpcyBjYWxsZWQuIFRoaXMg bmV3IHJlbGVhc2UgZG9lc24ndCBvbmx5IGluY2x1ZGUgdGhlIGh5cGVydmlzb3IsIGJ1dCBhbHNv IHRoZSBhc3NvY2lhdGVkIHRvb2xzdGFjayBhbmQgdXRpbGl0aWVzLiBNYXliZSB3ZSdyZSBPSyBj YWxsaW5nIGFsbCBvZiB0aGF0IHRoZSAmcXVvdDtIeXBlcnZpc29yLCZxdW90OyBldmVuIGlmIHdl IGlkZW50aWZ5IHRoZSBkZXZlbG9wbWVudCB0ZWFtcw0KIGRpZmZlcmVudGx5LjwvZGl2Pg0KPGRp dj48YnI+DQo8L2Rpdj4NCjxkaXY+SG93IHNob3VsZCB3ZSByZS1hbGlnbiBhbGwgb2YgdGhlIGJy YW5kaW5nPyBGb3IgZXhhbXBsZTombmJzcDs8YSBocmVmPSJodHRwOi8veGVucHJvamVjdC5vcmcv ZGV2ZWxvcGVycy90ZWFtcy9oeXBlcnZpc29yLmh0bWwiIHRhcmdldD0iX2JsYW5rIiBzdHlsZT0i Zm9udC1zaXplOjEwcHQiPmh0dHA6Ly94ZW5wcm9qZWN0Lm9yZy9kZXZlbG9wZXJzL3RlYW1zL2h5 cGVydmlzb3IuaHRtbDwvYT48L2Rpdj4NCjxkaXY+PGJyPg0KPC9kaXY+DQo8ZGl2PlNob3VsZCB0 aGUgbGlua3MgdW5kZXIgJnF1b3Q7SHlwZXJ2aXNvciBEb3dubG9hZHMmcXVvdDsgYmUgJnF1b3Q7 dmVyc2lvbiA0LjMuMSZxdW90OyBpbnN0ZWFkIG9mICZxdW90O1hlbiA0LjMuMSZxdW90OyB0byBy ZXNvbHZlIHRoZSB0cmFkZW1hcmsgY29uY2VybnM/PC9kaXY+DQo8ZGl2Pjxicj4NCjwvZGl2Pg0K PGRpdj4tLW1zdzwvZGl2Pg0KPGRpdj48YnI+DQo8L2Rpdj4NCjwvZGl2Pg0KPC9kaXY+DQo8ZGl2 Pg0KPGRpdiBzdHlsZT0iZm9udC1mYW1pbHk6J1RpbWVzIE5ldyBSb21hbic7IGZvbnQtc2l6ZTox NnB4Ij4NCjxkaXY+DQo8ZGl2IGNsYXNzPSJ4X2g1Ij4NCjxocj4NCjxkaXYgc3R5bGU9ImRpcmVj dGlvbjpsdHIiPjxmb250IGZhY2U9IlRhaG9tYSI+PGI+RnJvbTo8L2I+PHNwYW4+Jm5ic3A7PC9z cGFuPjxhIGhyZWY9Im1haWx0bzphZHZpc29yeS1ib2FyZC1ib3VuY2VzQGxpc3RzLnhlbnByb2pl Y3Qub3JnIiB0YXJnZXQ9Il9ibGFuayI+YWR2aXNvcnktYm9hcmQtYm91bmNlc0BsaXN0cy54ZW5w cm9qZWN0Lm9yZzwvYT4gWzxhIGhyZWY9Im1haWx0bzphZHZpc29yeS1ib2FyZC1ib3VuY2VzQGxp c3RzLnhlbnByb2plY3Qub3JnIiB0YXJnZXQ9Il9ibGFuayI+YWR2aXNvcnktYm9hcmQtYm91bmNl c0BsaXN0cy54ZW5wcm9qZWN0Lm9yZzwvYT5dDQogb24gYmVoYWxmIG9mIFNhcmFoIENvbndheSBb PGEgaHJlZj0ibWFpbHRvOnNjb253YXlAbGludXhmb3VuZGF0aW9uLm9yZyIgdGFyZ2V0PSJfYmxh bmsiPnNjb253YXlAbGludXhmb3VuZGF0aW9uLm9yZzwvYT5dPGJyPg0KPGI+U2VudDo8L2I+PHNw YW4+Jm5ic3A7PC9zcGFuPldlZG5lc2RheSwgTWFyY2ggMDUsIDIwMTQgOTozMyBBTTxicj4NCjxi PlRvOjwvYj48c3Bhbj4mbmJzcDs8L3NwYW4+QWR2aXNvcnktYm9hcmQgZGlzY3Vzc2lvbnM8YnI+ DQo8Yj5TdWJqZWN0OjwvYj48c3Bhbj4mbmJzcDs8L3NwYW4+UmU6IFtBZHZpc29yeS1ib2FyZF0g WGVuIFByb2plY3QgNC40IFJlbGVhc2U8YnI+DQo8L2ZvbnQ+PGJyPg0KPC9kaXY+DQo8ZGl2Pjwv ZGl2Pg0KPC9kaXY+DQo8L2Rpdj4NCjxkaXY+DQo8ZGl2Pg0KPGRpdiBjbGFzcz0ieF9oNSI+DQo8 ZGl2IGRpcj0ibHRyIj5NYXJrIGV0IGFsbCwmbmJzcDsNCjxkaXY+PGJyPg0KPC9kaXY+DQo8ZGl2 PjxzcGFuIHN0eWxlPSJmb250LWZhbWlseTphcmlhbCxzYW5zLXNlcmlmOyBmb250LXNpemU6MTNw eCI+SSBhZ3JlZSB0aGF0IHVzaW5nIFhlbiBQcm9qZWN0IGlzIGEgbW91dGhmdWwuIEc8L3NwYW4+ PGZvbnQgZmFjZT0iYXJpYWwsc2Fucy1zZXJpZiI+aXZlbiB0aGF0IHRoZXJlIGlzIGNsb3NlIG92 ZXJsYXAgYW5kJm5ic3A7b2NjYXNpb25hbCZuYnNwO2JyYW5kaW5nIGNvbmZ1c2lvbiB3aXRoIENp dHJpeCBwcm9kdWN0cywgaWYgd2UgYWRkIGFub3RoZXIgbmV3DQogdGVybSBvcjwvZm9udD48c3Bh biBzdHlsZT0iY29sb3I6cmdiKDY4LDY4LDY4KTsgZm9udC1mYW1pbHk6YXJpYWwsc2Fucy1zZXJp ZjsgZm9udC13ZWlnaHQ6Ym9sZDsgbGluZS1oZWlnaHQ6MTZweCI+Jm5ic3A7PC9zcGFuPmFjcm9u eW08c3BhbiBzdHlsZT0iZm9udC1mYW1pbHk6YXJpYWwsc2Fucy1zZXJpZiI+Jm5ic3A7aW50byB0 aGUgbWl4LCB3ZSdsbCB3YW50IHRvIGJlIGRpbGlnZW50IGFib3V0IGJlaW5nIGNvbnNpc3RlbnQg aW4gYmxvZ3MsIHByZXNlbnRhdGlvbnMsDQogbmV3cyByZWxlYXNlcywgd2ViIHNpdGUgY29weSwg Y3VzdG9tZXIgdGVzdGltb25pYWxzIGV0Yy4mbmJzcDs8L3NwYW4+PC9kaXY+DQo8ZGl2PjxzcGFu IHN0eWxlPSJmb250LWZhbWlseTphcmlhbCxzYW5zLXNlcmlmIj48YnI+DQo8L3NwYW4+PC9kaXY+ DQo8ZGl2PjxzcGFuIHN0eWxlPSJmb250LWZhbWlseTphcmlhbCxzYW5zLXNlcmlmIj5Gb3IgdGhl IHNha2Ugb2YmbmJzcDs8L3NwYW4+PGZvbnQgZmFjZT0iYXJpYWwsc2Fucy1zZXJpZiI+c2ltcGxp Y2l0eSwgaG93IGFib3V0IHVzaW5nIFhQSCAtIGFsbCB1cHBlcmNhc2UgLSBvbiBzZWNvbmQgcmVm ZXJlbmNlPyBUaG91Z2h0cz88L2ZvbnQ+PC9kaXY+DQo8ZGl2Pjxmb250IGZhY2U9ImFyaWFsLHNh bnMtc2VyaWYiPjxicj4NCjwvZm9udD48L2Rpdj4NCjxkaXY+PGZvbnQgZmFjZT0iYXJpYWwsc2Fu cy1zZXJpZiI+VGhhbmtzLDwvZm9udD48L2Rpdj4NCjxkaXY+PGZvbnQgZmFjZT0iYXJpYWwsc2Fu cy1zZXJpZiI+PGJyPg0KPC9mb250PjwvZGl2Pg0KPGRpdj48Zm9udCBmYWNlPSJhcmlhbCxzYW5z LXNlcmlmIj48YnI+DQo8L2ZvbnQ+PC9kaXY+DQo8ZGl2PjxzcGFuIHN0eWxlPSJmb250LWZhbWls eTphcmlhbCxzYW5zLXNlcmlmOyBmb250LXNpemU6MTNweCI+PGJyPg0KPC9zcGFuPjwvZGl2Pg0K PGRpdj48c3BhbiBzdHlsZT0iZm9udC1mYW1pbHk6YXJpYWwsc2Fucy1zZXJpZjsgZm9udC1zaXpl OjEzcHgiPjxicj4NCjwvc3Bhbj48L2Rpdj4NCjwvZGl2Pg0KPC9kaXY+DQo8L2Rpdj4NCjxkaXYg Y2xhc3M9InhfZ21haWxfZXh0cmEiPjxicj4NCjxicj4NCjxkaXYgY2xhc3M9InhfZ21haWxfcXVv dGUiPg0KPGRpdj4NCjxkaXYgY2xhc3M9InhfaDUiPk9uIFdlZCwgTWFyIDUsIDIwMTQgYXQgOTox OCBBTSwgTWFyayBIaW5rbGU8c3Bhbj4mbmJzcDs8L3NwYW4+PHNwYW4gZGlyPSJsdHIiPiZsdDs8 YSBocmVmPSJtYWlsdG86TWFyay5IaW5rbGVAY2l0cml4LmNvbSIgdGFyZ2V0PSJfYmxhbmsiPk1h cmsuSGlua2xlQGNpdHJpeC5jb208L2E+Jmd0Ozwvc3Bhbj48c3Bhbj4mbmJzcDs8L3NwYW4+d3Jv dGU6PGJyPg0KPC9kaXY+DQo8L2Rpdj4NCjxibG9ja3F1b3RlIGNsYXNzPSJ4X2dtYWlsX3F1b3Rl IiBzdHlsZT0ibWFyZ2luOjBweCAwcHggMHB4IDAuOGV4OyBib3JkZXItbGVmdC13aWR0aDoxcHg7 IGJvcmRlci1sZWZ0LWNvbG9yOnJnYigyMDQsMjA0LDIwNCk7IGJvcmRlci1sZWZ0LXN0eWxlOnNv bGlkOyBwYWRkaW5nLWxlZnQ6MWV4Ij4NCjxkaXYgc3R5bGU9IndvcmQtd3JhcDpicmVhay13b3Jk Ij5Ib3cgYWJvdXQgdGhpcyBjb252ZW50aW9uIG9ubHkgc2F5IFhlbiBQcm9qZWN0IGFuZCBYZW4g UHJvamVjdCBoeXBlcnZpc29yIG9uY2UgdGhlbi4gVXNlIHRoZSBhYmJyZXZpYXRpb24gWFBoIHRo cm91Z2hvdXQgdGhlIHJlbGVhc2UuIEp1c3Qgc25pcHBpbmcgTWF0dD8/IGV4YW1wbGUgdG8gbWFr ZSB0aGUgcG9pbnQuIEkgd291bGQgZ3Vlc3MgdGhhdCB0aGUgYXBwcm9wcmlhdGUgY2FwaXRhbGl6 YXRpb24NCiB3b3VsZCBiZSBsb3dlciBjYXNlIGZvciB0aGUgd29yZCBoeXBlcnZpc29yLiZuYnNw Ow0KPGRpdj48YnI+DQo8L2Rpdj4NCjxkaXY+TWFyayZuYnNwOzxicj4NCjxkaXY+PGJyPg0KPC9k aXY+DQo8ZGl2Pg0KPGRpdiBjbGFzcz0iIj4NCjxibG9ja3F1b3RlIHR5cGU9ImNpdGUiPg0KPGRp diBzdHlsZT0iZGlyZWN0aW9uOmx0cjsgZm9udC1mYW1pbHk6VmVyZGFuYTsgZm9udC1zaXplOjEw cHQiPg0KPGJsb2NrcXVvdGUgc3R5bGU9Im1hcmdpbjowcHggMHB4IDBweCA0MHB4OyBib3JkZXI6 bm9uZTsgcGFkZGluZzowcHgiPg0KPHAgYWxpZ249IkxFRlQiIHN0eWxlPSJtYXJnaW4tYm90dG9t OjAuMTVpbiI+PHNwYW4gbGFuZz0iZW4tVVMiPlRoZSZuYnNwOzxzcGFuIHN0eWxlPSJiYWNrZ3Jv dW5kLWNvbG9yOnJnYigyNTUsMjU1LDApIj5YZW4gUHJvamVjdDwvc3Bhbj4sIGEgQ29sbGFib3Jh dGl2ZSBQcm9qZWN0IGhvc3RlZCBhdCBUaGUgTGludXggRm91bmRhdGlvbiwgdG9kYXkgYW5ub3Vu Y2VkIGF2YWlsYWJpbGl0eSBvZiB0aGUmbmJzcDs8c3BhbiBzdHlsZT0iYmFja2dyb3VuZC1jb2xv cjpyZ2IoMjU1LDI1NSwwKSI+WGVuDQogUHJvamVjdDwvc3Bhbj4mbmJzcDtoeXBlcnZpc29yKFhQ aCkgNC40IHdpdGggZW5oYW5jZWQmbmJzcDtBUk0gc3VwcG9ydC48L3NwYW4+PC9wPg0KPC9ibG9j a3F1b3RlPg0KPC9kaXY+DQo8L2Jsb2NrcXVvdGU+DQo8L2Rpdj4NCjxkaXY+DQo8YmxvY2txdW90 ZSB0eXBlPSJjaXRlIj4NCjxkaXYgc3R5bGU9ImRpcmVjdGlvbjpsdHI7IGZvbnQtZmFtaWx5OlZl cmRhbmE7IGZvbnQtc2l6ZToxMHB0Ij4NCjxibG9ja3F1b3RlIHN0eWxlPSJtYXJnaW46MHB4IDBw eCAwcHggNDBweDsgYm9yZGVyOm5vbmU7IHBhZGRpbmc6MHB4Ij4NCjxwIGFsaWduPSJMRUZUIiBz dHlsZT0ibWFyZ2luLWJvdHRvbTowLjE1aW4iPjxzcGFuIGxhbmc9ImVuLVVTIj5YUGggNC40IGZ1 cnRoZXIgYWR2YW5jZXMgdGhlIFByb2plY3Q8L3NwYW4+PHNwYW4gbGFuZz0iZnItRlIiPj8/L3Nw YW4mZ3Q7PHNwYW4gbGFuZz0iZW4tVVMiPnMgcG9zaXRpb24gYXMgYSBmYXN0LCBzY2FsYWJsZSwg c2VjdXJlIHZpcnR1YWxpemF0aW9uIGVuZ2luZSBmb3IgdGhlIGluZHVzdHJ5PC9zcGFuPjxzcGFu IGxhbmc9ImZyLUZSIj4/Py9zcGFuJmd0OzxzcGFuIGxhbmc9ImVuLVVTIj5zDQogYnJvYWRlc3Qg cmFuZ2Ugb2Ygc2VydmVyLCBQQyBjaGlwc2V0cyBhbmQgbmV4dC1nZW5lcmF0aW9uIGxvdy1wb3dl ciBzeXN0ZW1zIG9uIGNoaXBzIChTb0MpLjwvc3Bhbj48L3NwYW4+PC9zcGFuPjwvcD4NCjwvYmxv Y2txdW90ZT4NCjwvZGl2Pg0KPC9ibG9ja3F1b3RlPg0KPC9kaXY+DQo8ZGl2Pjxicj4NCjxkaXY+ DQo8ZGl2IGNsYXNzPSIiPg0KPGRpdj5PbiBNYXIgNCwgMjAxNCwgYXQgNDowMSBQTSwgV2lsc29u LCBNYXR0ICZsdDs8YSBocmVmPSJtYWlsdG86bXN3QGFtYXpvbi5jb20iIHRhcmdldD0iX2JsYW5r Ij5tc3dAYW1hem9uLmNvbTwvYT4mZ3Q7IHdyb3RlOjwvZGl2Pg0KPGJyPg0KPC9kaXY+DQo8Ymxv Y2txdW90ZSB0eXBlPSJjaXRlIj4NCjxkaXYgc3R5bGU9ImZvbnQtZmFtaWx5OkhlbHZldGljYTsg Zm9udC1zaXplOjEycHg7IGZvbnQtc3R5bGU6bm9ybWFsOyBmb250LXZhcmlhbnQ6bm9ybWFsOyBm b250LXdlaWdodDpub3JtYWw7IGxldHRlci1zcGFjaW5nOm5vcm1hbDsgbGluZS1oZWlnaHQ6bm9y bWFsOyB0ZXh0LWFsaWduOnN0YXJ0OyB0ZXh0LWluZGVudDowcHg7IHRleHQtdHJhbnNmb3JtOm5v bmU7IHdoaXRlLXNwYWNlOm5vcm1hbDsgd29yZC1zcGFjaW5nOjBweCI+DQo8ZGl2IHN0eWxlPSJk aXJlY3Rpb246bHRyOyBmb250LWZhbWlseTpWZXJkYW5hOyBmb250LXNpemU6MTBwdCI+DQo8ZGl2 IGNsYXNzPSIiPlRoZSAmcXVvdDtYZW4gUHJvamVjdCZxdW90OyB0ZXJtaW5vbG9neSBtYWtlcyB0 aGUgbWVzc2FnZSBleHRyZW1lbHkgY3VtYmVyc29tZS4NCjxkaXY+PGJyPg0KPC9kaXY+DQo8Ymxv Y2txdW90ZSBzdHlsZT0ibWFyZ2luOjBweCAwcHggMHB4IDQwcHg7IGJvcmRlcjpub25lOyBwYWRk aW5nOjBweCI+DQo8cCBhbGlnbj0iTEVGVCIgc3R5bGU9Im1hcmdpbi1ib3R0b206MC4xNWluIj48 c3BhbiBsYW5nPSJlbi1VUyI+VGhlPHNwYW4+Jm5ic3A7PC9zcGFuPjxzcGFuIHN0eWxlPSJiYWNr Z3JvdW5kLWNvbG9yOnJnYigyNTUsMjU1LDApIj5YZW4gUHJvamVjdDwvc3Bhbj4sIGEgQ29sbGFi b3JhdGl2ZSBQcm9qZWN0IGhvc3RlZCBhdCBUaGUgTGludXggRm91bmRhdGlvbiwgdG9kYXkgYW5u b3VuY2VkIGF2YWlsYWJpbGl0eSBvZiB0aGU8c3Bhbj4mbmJzcDs8L3NwYW4+PHNwYW4gc3R5bGU9 ImJhY2tncm91bmQtY29sb3I6cmdiKDI1NSwyNTUsMCkiPlhlbg0KIFByb2plY3Q8L3NwYW4+PHNw YW4+Jm5ic3A7PC9zcGFuPjQuNCBIeXBlcnZpc29yIHdpdGggZW5oYW5jZWQ8c3Bhbj4mbmJzcDs8 L3NwYW4+PHNwYW4gc3R5bGU9ImJhY2tncm91bmQtY29sb3I6cmdiKDI1NSwyNTUsMCkiPlhlbiBQ cm9qZWN0PC9zcGFuPi1vbi1BUk0gc3VwcG9ydC48L3NwYW4+PC9wPg0KPC9ibG9ja3F1b3RlPg0K V2h5IG5vdCBqdXN0IHNheSAmcXVvdDtlbmhhbmNlZCBBUk0gc3VwcG9ydCZxdW90Oz8gV2Ugc2hv dWxkIGFkb3B0IHNvbWUgdXNhZ2UgZ3VpZGVsaW5lcyBmb3Igc3ViLXByb2plY3QgYnJhbmRpbmcu IFdlIHNob3VsZG4ndCBpbnNlcnQgd29yZHMvbnVtYmVycyBiZXR3ZWVuICZxdW90O1hlbiBQcm9q ZWN0JnF1b3Q7IGFuZCBhIHN1Yi1wcm9qZWN0IG5hbWUuDQo8ZGl2Pjxicj4NCjwvZGl2Pg0KPGJs b2NrcXVvdGUgc3R5bGU9Im1hcmdpbjowcHggMHB4IDBweCA0MHB4OyBib3JkZXI6bm9uZTsgcGFk ZGluZzowcHgiPlRoZSBYZW4gUHJvamVjdCwgYSBDb2xsYWJvcmF0aXZlIFByb2plY3QgaG9zdGVk IGF0IFRoZSBMaW51eCBGb3VuZGF0aW9uLCB0b2RheSBhbm5vdW5jZWQgdmVyc2lvbiA0LjQgb2Yg dGhlIFhlbiBQcm9qZWN0IEh5cGVydmlzb3Igd2l0aCBlbmhhbmNlZCBBUk0gc3VwcG9ydC48L2Js b2NrcXVvdGU+DQo8ZGl2Pjxicj4NCjwvZGl2Pg0KPGRpdj5vcjwvZGl2Pg0KPGRpdj4NCjxibG9j a3F1b3RlIHN0eWxlPSJtYXJnaW46MHB4IDBweCAwcHggNDBweDsgYm9yZGVyOm5vbmU7IHBhZGRp bmc6MHB4Ij5UaGUgWGVuIFByb2plY3QsIGEgQ29sbGFib3JhdGl2ZSBQcm9qZWN0IGhvc3RlZCBh dCBUaGUgTGludXggRm91bmRhdGlvbiwgdG9kYXkgYW5ub3VuY2VkIHRoZSByZWxlYXNlIG9mIFhl biBQcm9qZWN0IEh5cGVydmlzb3IgNC40IHdpdGggZW5oYW5jZWQgQVJNIHN1cHBvcnQuPC9ibG9j a3F1b3RlPg0KPGJsb2NrcXVvdGUgc3R5bGU9Im1hcmdpbjowcHggMHB4IDBweCA0MHB4OyBib3Jk ZXI6bm9uZTsgcGFkZGluZzowcHgiPjxicj4NCjwvYmxvY2txdW90ZT4NCkxhdGVyIG9uLCB0aGlz IHJlbGVhc2UgaXMgY2FsbGVkICZxdW90O1hlbiBQcm9qZWN0IDQuNCZxdW90Ow0KPGRpdj48L2Rp dj4NCjwvZGl2Pg0KPGRpdj48YnI+DQo8L2Rpdj4NCjwvZGl2Pg0KPGJsb2NrcXVvdGUgc3R5bGU9 Im1hcmdpbjowcHggMHB4IDBweCA0MHB4OyBib3JkZXI6bm9uZTsgcGFkZGluZzowcHgiPg0KPHAg YWxpZ249IkxFRlQiIHN0eWxlPSJtYXJnaW4tYm90dG9tOjAuMTVpbiI+PHNwYW4gbGFuZz0iZW4t VVMiPlRoZSBYZW4gUHJvamVjdCA0LjQgcmVsZWFzZSBmdXJ0aGVyIGFkdmFuY2VzIHRoZSBQcm9q ZWN0PC9zcGFuPjxzcGFuIGxhbmc9ImZyLUZSIj4/Py9zcGFuJmd0OzxzcGFuIGxhbmc9ImVuLVVT Ij5zIHBvc2l0aW9uIGFzIGEgZmFzdCwgc2NhbGFibGUsIHNlY3VyZSB2aXJ0dWFsaXphdGlvbiBl bmdpbmUgZm9yIHRoZSBpbmR1c3RyeTwvc3Bhbj48c3BhbiBsYW5nPSJmci1GUiI+Pz8vc3BhbiZn dDs8c3BhbiBsYW5nPSJlbi1VUyI+cw0KIGJyb2FkZXN0IHJhbmdlIG9mIHNlcnZlciwgUEMgY2hp cHNldHMgYW5kIG5leHQtZ2VuZXJhdGlvbiBsb3ctcG93ZXIgc3lzdGVtcyBvbiBjaGlwcyAoU29D KS48L3NwYW4+PC9zcGFuPjwvc3Bhbj48L3A+DQo8L2Jsb2NrcXVvdGU+DQo8ZGl2Pg0KPGRpdiBj bGFzcz0ieF9oNSI+DQo8ZGl2PlRoYXQgZG9lc24ndCBmbG93IHdlbGwuIEhvdyBhcmUgd2UgcmVs ZWFzaW5nIHZlcnNpb24gNC40IG9mIGEgcHJvamVjdD8gRG8gd2Ugd2FudCB0byBjYWxsIHRoZSBv dmVyYWxsIHJlbGVhc2UgJnF1b3Q7WGVuIFByb2plY3QgQXJjaGl0ZWN0dXJlIDQuNCZxdW90Oz8g T3IgZG8gd2UgbmVlZCB0byBjb21lIHVwIHdpdGggc29tZSBvdGhlciBwcm9qZWN0IGJyYW5kaW5n PzwvZGl2Pg0KPGRpdj48YnI+DQo8L2Rpdj4NCjxkaXY+LS1tc3c8L2Rpdj4NCjxkaXY+PGJyPg0K PGRpdj4NCjxkaXYgc3R5bGU9ImZvbnQtZmFtaWx5OidUaW1lcyBOZXcgUm9tYW4nOyBmb250LXNp emU6MTZweCI+DQo8aHI+DQo8ZGl2IHN0eWxlPSJkaXJlY3Rpb246bHRyIj48Zm9udCBmYWNlPSJU YWhvbWEiPjxiPkZyb206PC9iPjxzcGFuPiZuYnNwOzwvc3Bhbj48YSBocmVmPSJtYWlsdG86YWR2 aXNvcnktYm9hcmQtYm91bmNlc0BsaXN0cy54ZW5wcm9qZWN0Lm9yZyIgdGFyZ2V0PSJfYmxhbmsi PmFkdmlzb3J5LWJvYXJkLWJvdW5jZXNAbGlzdHMueGVucHJvamVjdC5vcmc8L2E+PHNwYW4+Jm5i c3A7PC9zcGFuPls8YSBocmVmPSJtYWlsdG86YWR2aXNvcnktYm9hcmQtYm91bmNlc0BsaXN0cy54 ZW5wcm9qZWN0Lm9yZyIgdGFyZ2V0PSJfYmxhbmsiPmFkdmlzb3J5LWJvYXJkLWJvdW5jZXNAbGlz dHMueGVucHJvamVjdC5vcmc8L2E+XQ0KIG9uIGJlaGFsZiBvZiBTYXJhaCBDb253YXkgWzxhIGhy ZWY9Im1haWx0bzpzY29ud2F5QGxpbnV4Zm91bmRhdGlvbi5vcmciIHRhcmdldD0iX2JsYW5rIj5z Y29ud2F5QGxpbnV4Zm91bmRhdGlvbi5vcmc8L2E+XTxicj4NCjxiPlNlbnQ6PC9iPjxzcGFuPiZu YnNwOzwvc3Bhbj5UdWVzZGF5LCBNYXJjaCAwNCwgMjAxNCAxMjoxNiBQTQ0KPGRpdj48YnI+DQo8 Yj5Ubzo8L2I+PHNwYW4+Jm5ic3A7PC9zcGFuPjxhIGhyZWY9Im1haWx0bzphZHZpc29yeS1ib2Fy ZEBsaXN0cy54ZW5wcm9qZWN0Lm9yZyIgdGFyZ2V0PSJfYmxhbmsiPmFkdmlzb3J5LWJvYXJkQGxp c3RzLnhlbnByb2plY3Qub3JnPC9hPjxicj4NCjxiPlN1YmplY3Q6PC9iPjxzcGFuPiZuYnNwOzwv c3Bhbj5bQWR2aXNvcnktYm9hcmRdIFhlbiBQcm9qZWN0IDQuNCBSZWxlYXNlPGJyPg0KPC9kaXY+ DQo8L2ZvbnQ+PGJyPg0KPC9kaXY+DQo8ZGl2Pg0KPGRpdj4NCjxkaXY+PC9kaXY+DQo8ZGl2Pg0K PGRpdiBkaXI9Imx0ciI+SGkgZXZlcnlvbmUuDQo8ZGl2Pjxicj4NCjwvZGl2Pg0KPGRpdj5BdHRh Y2hlZCBpcyB0aGUgWGVuIFByb2plY3QgNC40IG5ld3MgcmVsZWFzZSBhbm5vdWNlbWVudCB0aGF0 IHdpbGwgZ28gb3V0IGF0IDggYS5tLiBFVCBvbiBNb25kYXksIE1hcmNoIDEwLiZuYnNwOzwvZGl2 Pg0KPGRpdj48YnI+DQo8L2Rpdj4NCjxkaXY+SWYgeW91IGhhdmUgYW55IGFkZGl0aW9uYWwgY29t bWVudHMgb3IgZWRpdHMsIHBsZWFzZSBnZXQgYmFjayB0byBtZSBieSBUaHVyc2RheSBtb3JuaW5n IGF0IHRoZSBsYXRlc3QuJm5ic3A7PC9kaXY+DQo8ZGl2Pjxicj4NCjwvZGl2Pg0KPGRpdj5UaGFu a3MsJm5ic3A7PC9kaXY+DQo8ZGl2PjxiciBjbGVhcj0iYWxsIj4NCjxkaXY+PGJyPg0KPC9kaXY+ DQotLTxzcGFuPiZuYnNwOzwvc3Bhbj48YnI+DQo8ZGl2IGRpcj0ibHRyIj4NCjxkaXY+U2FyYWgg Q29ud2F5PGJyPg0KPC9kaXY+DQo8ZGl2PlBSIE1hbmFnZXI8L2Rpdj4NCjxkaXY+VGhlIExpbnV4 IEZvdW5kYXRpb248YnI+DQo8YSBocmVmPSJtYWlsdG86c2NvbndheUBsaW51eGZvdW5kYXRpb24u b3JnIiB0YXJnZXQ9Il9ibGFuayI+c2NvbndheUBsaW51eGZvdW5kYXRpb24ub3JnPC9hPjwvZGl2 Pg0KPGRpdj48YSBocmVmPSJ0ZWw6JTI4OTc4JTI5JTIwNTc4LTUzMDAiIHZhbHVlPSImIzQzOzE5 Nzg1Nzg1MzAwIiB0YXJnZXQ9Il9ibGFuayI+KDk3OCkgNTc4LTUzMDA8L2E+PHNwYW4+Jm5ic3A7 PC9zcGFuPiZuYnNwO0NlbGw8L2Rpdj4NCjxkaXY+U2t5cGU6ICZuYnNwO3NhcmFoLmsuY29ud2F5 PC9kaXY+DQo8L2Rpdj4NCjwvZGl2Pg0KPC9kaXY+DQo8L2Rpdj4NCjwvZGl2Pg0KPC9kaXY+DQo8 L2Rpdj4NCjwvZGl2Pg0KPC9kaXY+DQo8L2Rpdj4NCjwvZGl2Pg0KPC9kaXY+DQo8ZGl2Pg0KPGRp diBjbGFzcz0ieF9oNSI+X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX188YnI+DQpBZHZpc29yeS1ib2FyZCBtYWlsaW5nIGxpc3Q8YnI+DQo8YSBocmVmPSJtYWls dG86QWR2aXNvcnktYm9hcmRAbGlzdHMueGVucHJvamVjdC5vcmciIHRhcmdldD0iX2JsYW5rIj5B ZHZpc29yeS1ib2FyZEBsaXN0cy54ZW5wcm9qZWN0Lm9yZzwvYT48YnI+DQo8YSBocmVmPSJodHRw Oi8vbGlzdHMueGVucHJvamVjdC5vcmcvY2dpLWJpbi9tYWlsbWFuL2xpc3RpbmZvL2Fkdmlzb3J5 LWJvYXJkIiB0YXJnZXQ9Il9ibGFuayI+aHR0cDovL2xpc3RzLnhlbnByb2plY3Qub3JnL2NnaS1i aW4vbWFpbG1hbi9saXN0aW5mby9hZHZpc29yeS1ib2FyZDwvYT48L2Rpdj4NCjwvZGl2Pg0KPC9k aXY+DQo8L2Jsb2NrcXVvdGU+DQo8L2Rpdj4NCjxicj4NCjwvZGl2Pg0KPC9kaXY+DQo8L2Rpdj4N CjwvZGl2Pg0KPGRpdj4NCjxkaXYgY2xhc3M9InhfaDUiPjxicj4NCl9fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fPGJyPg0KQWR2aXNvcnktYm9hcmQgbWFpbGlu ZyBsaXN0PGJyPg0KPGEgaHJlZj0ibWFpbHRvOkFkdmlzb3J5LWJvYXJkQGxpc3RzLnhlbnByb2pl Y3Qub3JnIiB0YXJnZXQ9Il9ibGFuayI+QWR2aXNvcnktYm9hcmRAbGlzdHMueGVucHJvamVjdC5v cmc8L2E+PGJyPg0KPGEgaHJlZj0iaHR0cDovL2xpc3RzLnhlbnByb2plY3Qub3JnL2NnaS1iaW4v bWFpbG1hbi9saXN0aW5mby9hZHZpc29yeS1ib2FyZCIgdGFyZ2V0PSJfYmxhbmsiPmh0dHA6Ly9s aXN0cy54ZW5wcm9qZWN0Lm9yZy9jZ2ktYmluL21haWxtYW4vbGlzdGluZm8vYWR2aXNvcnktYm9h cmQ8L2E+PGJyPg0KPGJyPg0KPC9kaXY+DQo8L2Rpdj4NCjwvYmxvY2txdW90ZT4NCjwvZGl2Pg0K PGRpdj4NCjxkaXYgY2xhc3M9InhfaDUiPjxicj4NCjxiciBjbGVhcj0iYWxsIj4NCjxkaXY+PGJy Pg0KPC9kaXY+DQotLTxzcGFuPiZuYnNwOzwvc3Bhbj48YnI+DQo8ZGl2IGRpcj0ibHRyIj4NCjxk aXY+U2FyYWggQ29ud2F5PGJyPg0KPC9kaXY+DQo8ZGl2PlBSIE1hbmFnZXI8L2Rpdj4NCjxkaXY+ VGhlIExpbnV4IEZvdW5kYXRpb248YnI+DQo8YSBocmVmPSJtYWlsdG86c2NvbndheUBsaW51eGZv dW5kYXRpb24ub3JnIiB0YXJnZXQ9Il9ibGFuayI+c2NvbndheUBsaW51eGZvdW5kYXRpb24ub3Jn PC9hPjwvZGl2Pg0KPGRpdj48YSBocmVmPSJ0ZWw6JTI4OTc4JTI5JTIwNTc4LTUzMDAiIHZhbHVl PSImIzQzOzE5Nzg1Nzg1MzAwIiB0YXJnZXQ9Il9ibGFuayI+KDk3OCkgNTc4LTUzMDA8L2E+ICZu YnNwO0NlbGw8L2Rpdj4NCjxkaXY+U2t5cGU6ICZuYnNwO3NhcmFoLmsuY29ud2F5PC9kaXY+DQo8 L2Rpdj4NCjwvZGl2Pg0KPC9kaXY+DQo8L2Rpdj4NCjwvZGl2Pg0KPC9kaXY+DQo8L2Rpdj4NCjwv ZGl2Pg0KPC9kaXY+DQo8L2Rpdj4NCjwvZGl2Pg0KPC9kaXY+DQo8ZGl2Pg0KPGRpdiBjbGFzcz0i eF9oNSI+X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX188YnI+ DQpBZHZpc29yeS1ib2FyZCBtYWlsaW5nIGxpc3Q8YnI+DQo8YSBocmVmPSJtYWlsdG86QWR2aXNv cnktYm9hcmRAbGlzdHMueGVucHJvamVjdC5vcmciIHRhcmdldD0iX2JsYW5rIj5BZHZpc29yeS1i b2FyZEBsaXN0cy54ZW5wcm9qZWN0Lm9yZzwvYT48YnI+DQo8YSBocmVmPSJodHRwOi8vbGlzdHMu eGVucHJvamVjdC5vcmcvY2dpLWJpbi9tYWlsbWFuL2xpc3RpbmZvL2Fkdmlzb3J5LWJvYXJkIiB0 YXJnZXQ9Il9ibGFuayI+aHR0cDovL2xpc3RzLnhlbnByb2plY3Qub3JnL2NnaS1iaW4vbWFpbG1h bi9saXN0aW5mby9hZHZpc29yeS1ib2FyZDwvYT48L2Rpdj4NCjwvZGl2Pg0KPC9kaXY+DQo8L2Js b2NrcXVvdGU+DQo8L2Rpdj4NCjxicj4NCjwvZGl2Pg0KPC9kaXY+DQo8L2Rpdj4NCjwvYmxvY2tx dW90ZT4NCjwvc3Bhbj48YnI+DQo8Zm9udCBmYWNlPSJBcmlhbCI+LS0gSU1QT1JUQU5UIE5PVElD RTogVGhlIGNvbnRlbnRzIG9mIHRoaXMgZW1haWwgYW5kIGFueSBhdHRhY2htZW50cyBhcmUgY29u ZmlkZW50aWFsIGFuZCBtYXkgYWxzbyBiZSBwcml2aWxlZ2VkLiBJZiB5b3UgYXJlIG5vdCB0aGUg aW50ZW5kZWQgcmVjaXBpZW50LCBwbGVhc2Ugbm90aWZ5IHRoZSBzZW5kZXIgaW1tZWRpYXRlbHkg YW5kIGRvIG5vdCBkaXNjbG9zZSB0aGUgY29udGVudHMgdG8gYW55IG90aGVyIHBlcnNvbiwNCiB1 c2UgaXQgZm9yIGFueSBwdXJwb3NlLCBvciBzdG9yZSBvciBjb3B5IHRoZSBpbmZvcm1hdGlvbiBp biBhbnkgbWVkaXVtLiBUaGFuayB5b3UuPGJyPg0KPGJyPg0KQVJNIExpbWl0ZWQsIFJlZ2lzdGVy ZWQgb2ZmaWNlIDExMCBGdWxib3VybiBSb2FkLCBDYW1icmlkZ2UgQ0IxIDlOSiwgUmVnaXN0ZXJl ZCBpbiBFbmdsYW5kICZhbXA7IFdhbGVzLCBDb21wYW55IE5vOiAyNTU3NTkwPGJyPg0KQVJNIEhv bGRpbmdzIHBsYywgUmVnaXN0ZXJlZCBvZmZpY2UgMTEwIEZ1bGJvdXJuIFJvYWQsIENhbWJyaWRn ZSBDQjEgOU5KLCBSZWdpc3RlcmVkIGluIEVuZ2xhbmQgJmFtcDsgV2FsZXMsIENvbXBhbnkgTm86 IDI1NDg3ODI8YnI+DQo8L2ZvbnQ+PC9kaXY+DQo8YnI+DQpfX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fXzxicj4NCkFkdmlzb3J5LWJvYXJkIG1haWxpbmcgbGlz dDxicj4NCjxhIGhyZWY9Im1haWx0bzpBZHZpc29yeS1ib2FyZEBsaXN0cy54ZW5wcm9qZWN0Lm9y ZyI+QWR2aXNvcnktYm9hcmRAbGlzdHMueGVucHJvamVjdC5vcmc8L2E+PGJyPg0KPGEgaHJlZj0i aHR0cDovL2xpc3RzLnhlbnByb2plY3Qub3JnL2NnaS1iaW4vbWFpbG1hbi9saXN0aW5mby9hZHZp c29yeS1ib2FyZCIgdGFyZ2V0PSJfYmxhbmsiPmh0dHA6Ly9saXN0cy54ZW5wcm9qZWN0Lm9yZy9j Z2ktYmluL21haWxtYW4vbGlzdGluZm8vYWR2aXNvcnktYm9hcmQ8L2E+PGJyPg0KPGJyPg0KPC9i bG9ja3F1b3RlPg0KPC9kaXY+DQo8YnI+DQo8YnIgY2xlYXI9ImFsbCI+DQo8ZGl2Pjxicj4NCjwv ZGl2Pg0KLS0gPGJyPg0KPGRpdiBkaXI9Imx0ciI+DQo8ZGl2PlNhcmFoIENvbndheTxicj4NCjwv ZGl2Pg0KPGRpdj5QUiBNYW5hZ2VyPC9kaXY+DQo8ZGl2PlRoZSBMaW51eCBGb3VuZGF0aW9uPGJy Pg0KPGEgaHJlZj0ibWFpbHRvOnNjb253YXlAbGludXhmb3VuZGF0aW9uLm9yZyIgdGFyZ2V0PSJf YmxhbmsiPnNjb253YXlAbGludXhmb3VuZGF0aW9uLm9yZzwvYT48L2Rpdj4NCjxkaXY+KDk3OCkg NTc4LTUzMDAgJm5ic3A7Q2VsbDwvZGl2Pg0KPGRpdj5Ta3lwZTogJm5ic3A7c2FyYWguay5jb253 YXk8L2Rpdj4NCjwvZGl2Pg0KPC9kaXY+DQo8c3Bhbj4mbHQ7WGVuUHJvamVjdFVwZGF0ZTQuNDMu Ni4yMDE0KDIpZG9jeCZndDs8L3NwYW4+X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX188YnI+DQpBZHZpc29yeS1ib2FyZCBtYWlsaW5nIGxpc3Q8YnI+DQo8YSBo cmVmPSJtYWlsdG86QWR2aXNvcnktYm9hcmRAbGlzdHMueGVucHJvamVjdC5vcmciPkFkdmlzb3J5 LWJvYXJkQGxpc3RzLnhlbnByb2plY3Qub3JnPC9hPjxicj4NCmh0dHA6Ly9saXN0cy54ZW5wcm9q ZWN0Lm9yZy9jZ2ktYmluL21haWxtYW4vbGlzdGluZm8vYWR2aXNvcnktYm9hcmQ8YnI+DQo8L2Js b2NrcXVvdGU+DQo8L2Rpdj4NCjxicj4NCjwvZGl2Pg0KPC9kaXY+DQo8L2JvZHk+DQo8L2h0bWw+ DQo= --_000_545D5AEE789B45349983A9EA3FD1ECC1citrixcom_-- --_004_545D5AEE789B45349983A9EA3FD1ECC1citrixcom_ Content-Type: application/vnd.openxmlformats-officedocument.wordprocessingml.document; name="XenProjectUpdate4.43.6-mark.docx" Content-Description: XenProjectUpdate4.43.6-mark.docx Content-Disposition: attachment; filename="XenProjectUpdate4.43.6-mark.docx"; size=21802; creation-date="Fri, 07 Mar 2014 17:04:31 GMT"; modification-date="Fri, 07 Mar 2014 17:04:31 GMT" Content-ID: <2212A524537E594CA3D673E619BAAD56@citrix.com> Content-Transfer-Encoding: base64 UEsDBBQABgAIAAAAIQBTrJavlAEAAJYGAAATAAgCW0NvbnRlbnRfVHlwZXNdLnhtbCCiBAIooAAC AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC0 lUtPwzAQhO9I/IfIV5S45YAQatoDlCNUooiz62wai/ghr/v692z6iABVdaHtJVLizszndTLtDZa6 TubgUVmTs27WYQkYaQtlpjl7Hz+n9yzBIEwhamsgZytANuhfX/XGKweYkNpgzqoQ3APnKCvQAjPr wNBKab0WgW79lDshP8UU+G2nc8elNQFMSEPjwfq9JyjFrA7JcEmPNyQkZ8nj5ndNVM6Ec7WSIhAo b1b5Xp2HGg8I56b4RZduyTJSrs2xUg5vtgmvNBqvCkhGwocXoYmDL6wveGHlTNMessOge/JsWSoJ rb5xc95KQKSZ6zprV7RQJsphZnoCnpTnB2mtoxAYVjXg+Qk2vkfGf6hQDcsSJL1x8UPRmDaTzzYR 37TxNAiB5n1MyM/vII2dPG6dowgLmLxdjOKbeRREWt18BBeYxc45ilBSR4zFpIYjDv2P59FaRyEC 9R7w9bV7Msfa5lAkNcTIW4fUo/4f294VXqNOqXoc+KDgYOW1iVTCJ+8PmpYvoNiTzdf/Kv0vAAAA //8DAFBLAwQUAAYACAAAACEAwmCa8/QAAABOAgAACwAIAl9yZWxzLy5yZWxzIKIEAiigAAIAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIySwUoD MRCG74LvEObenW0FEWm2FxF6E6kPMCTT3aW7SUhGbd/eQVRcWGuPSWa++eYn681xHMwb59LHYGFZ 1WA4uOj70Fp42T0u7sAUoeBpiIEtnLjAprm+Wj/zQKJNpetTMUoJxUInku4Ri+t4pFLFxEFf9jGP JHrMLSZyB2oZV3V9i/k3A5oJ02y9hbz1SzC7U9LJ/7Pjft87fojudeQgMyNwWqFkyi2LhfeYPfqv xkqVAedtVpfb/L0pjizkSQhdzLxIWXPK0muyP0Lq8qTX5bPinNDN5ULT5efi4aNw8OzPK1FK30Y4 +QXNBwAAAP//AwBQSwMEFAAGAAgAAAAhAISJ6uGjAQAA1QYAABwACAF3b3JkL19yZWxzL2RvY3Vt ZW50LnhtbC5yZWxzIKIEASigAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1JU9b8IwEIb3 Sv0PkffEGCj9EIGlVGLo0lJ1dpLLR0lsyzY0/PteA4FQIFKrLF0i3Vl+/dz59WU8LYvcWYM2mRQ+ YV6POCBCGWUi8cnb4sm9I46xXEQ8lwJ8sgFDppPrq/EL5NziJpNmyjioIoxPUmvVA6UmTKHgxpMK BK7EUhfcYqgTqni45AnQfq83orqpQSZHms488omeRwPiLDYKT/6hXWShlkbG1gtlQWUcZ2Glenus So3d5GDeM5vO4hhCa1CP6wSsT06WPIQl9DzH8ALHmRq3MI8yXBUg7JlSqQFrscNNll2mDeGmS4RP CF5PKBrJNpBRlyB4fd9tavSizrQh3HaJkKLBdJ6JJYruvLFzW5DLxCtBVN7NRASlp1KFV8qGtMfo gFHctirdgcuGLr4SV61TWqs8ywh9OystaMEvGgsf2FmD/8lYlyvBIpSWH/gCqlp+x3j/DxgZjq7u GhlLYRc8yKFulE/2qTZfMtYlhcU52iCoQlp9WStElwxiVQSgcVodOrFPtUH0u4TYjuoDwTauj6dH P6PJFwAAAP//AwBQSwMEFAAGAAgAAAAhAG1uiQUCFwAAQnUAABEAAAB3b3JkL2RvY3VtZW50Lnht bOxd3XLbRpa+36p9hy7lxqmifu3YjnbMWVqWHdVYllZUnOxlE2iSHYFopAGQoq/yGlO183J5kv3O 6QYIQLRESRDlsZOqlG2SALpPn9/v/OBvf7+cRGKqbKpN/Gpjd2tnQ6g4MKGOR682fj5/u/lyQ6SZ jEMZmVi92pirdOPv3f/8j7/N9kMT5BMVZwK3iNP9WRK82hhnWbK/vZ0GYzWR6dZEB9akZphtBWay bYZDHajtmbHh9t7O7g7/LbEmUGmK5x3IeCrTDX+7iVntbhMZFDfe29l5uT2ROi7vcXVFJlEx1js0 diKzdMvYEa6wF3myiRUmMtMDHelsjvXtPC9vM321kdt43+9qs9wVXbOPBexPJ1HxYyz78791FNh3 fxRX2CsbXbJId8kbT3Je3rZVERZs4nSskwXd7no30GNcLOnaDVc2O0t2n115XkmeVQ79jZUznH3x 4Fly5XZLiBG6iyaRowMx1IKNmnfc3VnhROgW5RpWWUL9mcVKqsw3uxtpFpw0SyCC9xGod9bkSbmr RN/vbkfxRXkv0gS3WNnOcxb16tbSW93giq7oj2WiNsQk2D8axcbKQYQVgeKCOHKjC+00kMHFCASI QzHbD0xkIGZv+b+Nbf7ehHP6M8HX0H7h2auNnZ0XL1788Awq0H/0Rg1lHmWVb/iKU8t/9LN5pPDT qYxebWARExntuHv/FhQfB9CPytKn23gUXUh//hs8d2/3ee/HH5mSvGys+vP7TRMZQIixaTnEdl9t 7O2tQAkQmQhhHTkHfCrpp4Jye88cLcd6NI7wf1Z8MRvrTHmK+muz7q8qFqfW/KaCTByYySSPocTF mYqUTFUqfk5CmSmRGXFI55FYnSrx0zxRdqpTY0UfJmomraLTyfiMbn9Sj0QxfR+6ka3dp9OD9CRW paCH2uiewEaCJLkNlPiobZbLSH9iS1MSShzFQZSHIG0vDDUZIRmJ3tmx6OdJYmwm4DGIfiAj6eyp gMEVB5HJQ/7m2OBjhcOYamticiJS8ei0LyS0zpd35MjllO33Poi3Z70PB0f9g5OOOJY2GIvdnY6A O/Rsc/N8rESVk+FeOE7uCFmnTytr7B6YCAcE9ZnpqSrlZ2zSTOGcMkHrea/j/FK8JUXKLNCBFIVy jmOM8VlAP5xKXZ6zGYqssYtnW8+qsjbT2Rg+5ljyxcQzqeOZLX4eXBqVZgK+DYmukFFqhC6YbSJ/ Ax9BbNl/ww2Ym9I5FjwRaYXd9AQOwVQ5ziLeYz3s5J4cvTyDvurUWK4Vki4/duwQ5yxTMXF8T8IR sDCoigR0xGysrBKQiarIZSoYx7Bfo7nQKZHCgjBYfYR/xyKEnx2HW7Wd3NLEtKK4WhWe7vkYWy1Y YJhbsJQVMpwSz6TMYF7Z//nHP1ORmJRVEFFYiqFMs45nhkjhbyrIr1JVxSMdK1ZLxK86DvM0s3O+ 38AaCdUGJpTxSAmwNCtG2xGnByIgZ7tuKFrhnC5UIPFFrC6zzZGKFUmliUVkZpuJmWH/ns3xGa9B PKkdOgy0NWZ4aC0MZQbT9mojTVQU9TNpM2dKq+b2jmqt2zcHKz32MA7be+j3YPMpQsf0K+Pz5dri mJVcYOLM6gEUFQI8MbRmInrHbzriQOPjyw4McKaijjixMoAlZXP7c/9QwIkRSY6IEO5YUxFTIE5e DvlBmbzAVSRRmXQ8Tr/2yncsbUg/3KpY92jeoVNQEeIxmwrSQqRDWTToaHgJMkkahrwd2XA2YzJQ YajCzlU16kQjFTMdRWIA4RnqzNGMdpWz9xcKrB5oRQDLE6tIwEREbCCcnEH3xqw1aFMmz4h62oLM QwuFYvMgIy3CGqZPbiNsD2JyZfHzr40tu3/+8X8Nv4/4q9REsPlOIeLQQRMYaoKLBNlVGWtS0AbK OwMPXjAPwnGQwkVCzCU6a6iQNhQTmYEM56vhiLLBJ7BJA8uad/78418ilToU7yU49x9kTiBHY6kR ssWk3puCArmgsGAuBgaSsCVAj5McCthELI7YKaRGQyyPzjcZhAFFAnhNaUckUQ4zrxS0Od2VjQ+F IkTAqoMSKxWm/GzyptjsAM1JMx04z6DG5KkJaFuxygA7XNRoXXOa8qR9wi7XURROQQmADnAPoVCw 1apFzqCVLsADAWAV2qTV8H8QhBfeJmwYEWSmYWYTaJKwUC2MJ7Kyw9HMi7PBrqOQaVRxhojtoImI AHAWAmXpSOAUqcsk4sNh+utRrMEIUHMCaMAMrieWU3E6yemixTUIR543mOmMHAC2oDCqOgQQ4Iza zaYWv2dU4RTR8M5OxcXyIesK9ncO621mzUh3pkCIpv9RXS4s7yqLXWqgbS3GP/BEUFBzECQOurGt tzh1qNp9mQZanwPohasx0QBAfurFqSbwBA5q1ku1rH556D+j78f0w+qX5ZVBilMrb/hah9oRnAEc XMlYi8wzUydLsf9ipfhleVrwTJ1+qYANK1B/GcywXBYg89gwVADUXqq8VYV5QODye66Di2i+BQ1U Y7Avx0Mf3Ac+6BbR/tDUtldQvA1kx7K0QmFUA+Me4magQM4mA+acpeJ/HKlr63g4Mrca7ixnK8gH NP6sDIM0/EET5uRqpRWthuSMg1g6Ik8LtIWUazVKvhIOQ8qYrgRAlISkqxB9qBhOlih8QKjtSl5k SzQ15c2q8P5y1+0lSaRVeEzpJLIDtVP+XOSzVMO1K/m/br6DswlIBORcaU0tR2M9S4m5pjVYfiRr IMdrcpc6j0KJAxldqlCudAhroMThwa+bezuN1bTg5i5XFTtAEM+PxMlx7/QHdqwejR+jCNk8YBeN nT8aR660jpaFsp/Hv+qVHrwGRuQIxsVpErGxh1oVghqyL2k+gP3goIngRAeahmKCpJeGF50RzCoC mTi7QqGdj5bGi9wJbmtmC3PBRsRH6igsiEODmAueEWcFiC+rdrzizuMnZO3INV+Jdm0fmjn4YqwK vElNcEs6RiZFxRTvgXAAIzI9YfBm0qBQC4qliyIIla0LX1uD+1Tnon9rT7CSYvN5E5fXAPwPkCWt eIickwvF82ebAwBgo5xAbC/yAi40hGv6EuGKE2yEzj2ohMeyFTkwJE49Npj50WxFZkwEBKfI1axC l5GVk5YV0WV0Ez3ooWuwHABggAwzIEOUQQoSWJ/nLIJsHKbVWOz9NRGBYGcwG4AcwlMs4DWedcFB atYFjAN0F3GOC7YZgy7X5NNmAvVYQB7JVAHE9eZqYC7/Um2ukKUCRd1U2NGqlkZOr2b7W2ccrkO8 WsxQtwOfixVbFmJ2j5COvlGWOUW3BmHuvT6i7HEMTw0OH6qlPP7K6RKIDMAF/A+xIuicSqeQ/iFM uxL6QzMaEj1K/kAOkRKBcRnmnBbxqVp29AbGQO4iCLCgVJHPEnGKfm2JklY5d3nMdVgAJYV9Jcox sJyogCDnJuMVGGUTUt5zCOdys1flS4CaDwMp04lFlPK2TRe4umZwqYdVr13xUmb+ynBlJgB47IFx ZQqlhkhScc4WEoqyF1RqwUWhL6psl4znKXIckUiQ6+dSCER861KwWMv7j8diiuTYBFaXQPDMwFUI dXrB8eIVw+wVUWOBVV5jtvfc9vTR5YMKnGQEpXnNihfSce16vwXpYAK0KB3dv1y3W7tuM3aECDlo 1uQuN433SwMdFcDRIVdYILXOFRbV+s+3sI6u/vOgKL+rSRMt6xZl0bfwYm9LijtmCJr+rciUBHbm M+SsF0NLZZbAR83U1ZyQHm9kxV3FuiuvaFYC0s8pKuXSwS1xSlVhdMRlqrxG0cI8uSTcXXeFx0XS jghI4MdSBaKAr4JEFJencTFoBx8S9ECL6U3kJ0ANhwd7HXEGR5JD/Erpr8EOLGwYb6SobxU5BXzw TGMURdA3VB7BZSR5jGofWJMrRoRKCJAIQx2kElSxui4lsS52+l+V+eJOGNFYVADXahlJwV9EK18a inTUAER25U98draMidtnkOXOcYexXCpWIb8SCUtf/1qcIso+LjKTYMnV6qpUPPn45uh7dm8IC3Yl sid9iJIvgQUCXeW1xnZudqFbSEUeawtU4qS/0rOXmvs7iuLnKL3SQqpxRAtEOLQRwpiTGFj+So// Wulw0p9+Mfsn67DSYlrmhZ9k9PF4pQe3yQXdLXGG8jJUd30iq5ON0a5ArUKbtW4Eogmsiu9BIQAz sIiPKFSCwoSycWWrTtGEKonMnKH1/2IjBO7uU0cMEi9ky+UDlC0uF2pf5MveA9cAkzFkqzi7vogV m6LfVVJsyPMZMVZRIlSkUaVFbVCFXhb0ScauCCqM4aAxukOmGRGaigkmcta4YnzwBAubnI0Nqk3I WgNh5TwDW6nSIpcRqUdjUTdSZ84vx9+7n+t7eAmMC2k54GdR2fxEtDz9+JM4NqFrMXiXN2PHKlB+ vxWkdbb8cgjbqp3zde5jFGCTz1NIBdo90ITk+89QSTrV8BvAklfapZiFI6pItlwaaI/CFxtsCe9o Dmf7OWIrrkd0XijBFCB+0ZK4XLLJrfFOUNFSNyEmIawYQk5Mg24VVFtmyMd7VQYHF1JXXoWfOYHb uiJR5Sbvs7HKHrq0HugCwL1cF0ZDAmgt7LsjUQPQqaprGkagyuKt8kJ932uC9E+lleUZsM5sbHe5 99mmzVvOUuLJ6cfvcSQwgNDfXmH7Bo4F17iAszxFnKnr2gNz4UyJB20sLl8+p9gOGCOq35EepuPn e55+FBy8Avsn3cYQP9nWo+0T9ta5GWVRA1Kn04J33NUJNZy4JIRPEKDDBdkF18VHkuCsMkeKWI+e old0BLbHrxs0b4HFuq7PCrvlOvKYkhdURu6LYdBW0Ow2pH4ylPQjzEKCkfsTU/w4AubvqX+lqLJi jyudkJuutbIEdqtlnagZrm11PVod+hG13HvPXlCRNv3jLKe++kq9tU8ZtkF3NFUU6gXxKfV1+vYi TjkTm1XJVvYugVuJTYn7yBiQKlo0fkA3jagxCefnz2Qu6uaxFVRkuSBiJc0TpQZNao+Ag8BdKLUz fcClcLdL42HL9VPLwcA/TGxluNKT16AZV1pHyxQ4+6TST3mmLlZ6+FdKhF909KXsv7OYWfDGtS+y fjnm6hY0FWe+hZJa7KsKp94DhpYu1DRaagX71y+Keoxo0gTpr8Yxt6AZl2sXqLaxBHxMCm/AcCwq 9GWApKCmrjEOxGA6mxafLHsqNjcZLKWOx07RIO3aokvrg0Yoasxf13aoZhQ0pSY79OnbMQqKKPDE cbBFpfZUeAs5NnRjkyq1912z7PtFV73T07OTj733on9+9P69OD388Obow7va4x7ONtOdHXz/YGxV p9zDbWVdsHmlVvJCzX3rL49NoHEl+2s6uNl+nE/cyeloGhWBou8exHdHVEvBweOujxvLCz4/TAdD CnAVkmsYXYDRUE9/+JGupelGqA24pJkRfTeIhz9dvdHwSqtbq3zXfa0yaKmaH82qxgcdVC1AEYFv 8WfPbqBHgruGobiO4lCjk5SyISnQuwQ/91FIZNBkitAEnk1mkEcTT9j/QgKBS9LV2kog0D+Ks0Gc EuIMUI77OxfeUqCM9SLCghtYY7w2PL/r6iRT/Ql6vvCEXSRDKCmFa9VwhnveAedxiTkcaxqdwdUb HKFVki5lAic1kQ43AakCRnTpTHLEz3pHb1BMXEaU2C9177r64+L+zjd+urW7K+DbE1YLpnhi1Qix KoBGNmBVAwyrQHjD9+sLhEoR/OZldrkLAjwTCDoPI4Fl9oiACA2VD7KP8QYlP82PqVYwhrHHRC7E dBNEZoQfD1h2nTy7aJ+w502XLG7IyloCF6p5VMCzV3r2w3vtizL0lRbUcgzzO9VurfTgNinRBaJC 9Qwun4OBTnlCYOMQ8TyN3kBtGw1SYNPheE7seNBmoiQYkKoA4C0iyQGPGKgO2QmuVF066qScQFWM aADJG1tuwelCyXoxGsuV7VkzQN0sytMBLGFCFQYghGIwbwoNbZLK11MJi0dzLDjFhcwNfo86fIv5 WwC56ZQIDR/qUe6nBZnEzYup3puUKgERZrLzly6Fu3TzRMFW/Z/luvQDEgH906ODw4X3UlR0wud5 WyY1iOWL6okg0gn386EzDMIAniDj+3P/NVwO5yMRPu+6IqBU0cYHx4RGb8DQPgRrG1R5uSogQus8 6EtuGtV2OK0+cL4fWlYSjNmogal/8eKXwouHxTC+UEtMU3VwArFWg2nWYogv1KUKVnpwm7ZnuZCC lwc5Rlz5mZYQzF/GUKYYZoSZUGPgMQkmZSJ1gbQ3Ff3D979AGoVmS4H7KQaBctcYJAO6wl+GLaNi PwplUPfEA6hJXjGAEZqeYB3Mb0OVnYQn1IF6x9AVEvHKzC0vTP6U6BkNOrVhsHDsViWYjYSF0Shs JDXWJ6mL2JeyD0hFvMT48QdPRSw//HOcCI2ubND4ihA8QA+gb6dZ5clrEAIwGnOnStEW7pLrPCGx w+y8mB9aTd+oIRicpngmNFWWpkSNUFFCIxcR1bnSRC7rBOIXi92n5QyxYuoINRv5YXWkiAofrWgo p6qWZFEIQJ6enxHq6087blheD2NpzUgA+KURdR3x2qIcEY0GxRi9BoVbkJ/lvNSBRf9NZ2lezu1D NCyt6YgP/V4xxO9xBmf0oW4aZLjC4q13qcHV/wj1hkLh7ZWe3XJ8c65QYkFj/1d6+MOLmB8bB/xB of6beLkEk4j7ZYDeLEzVrzE8hT4oLrJK1SpFQjOLqeaWI58BVR/luAPMDIkwIoFTNySbXnwgZmqA walKPEH4jvFpN2q6h5gnmtv190h274cp+SHxhLze1EFbRb1XtGhrh+C9fX1QY3tTsVS3x05QBf6r SeZXSRNsqqgVu9I7Uho/V3z1MIUvGHfqZrw3ynWK+RAoD8XQTuq1hwqhIlhokHen76d7DoOhWs8J Bn9bMaIMXkyzmQEeF5NSCf3GBQ71dW7xFgwxjS7DHXnEI30PKBmah+JHV4QL4+yHc/PlXl1xqcfC YZDwikknMghSSeqSsgTFBorcDdg1hlYWl+3uCCw4IqcbXzZnFLVg/LuoIurh/QPlnMvKVHVkNs9L etTGqePTCuO7WmPsYoh3vdAWKETgyde0qcZREdAuYDaQmnaAEEUNcLdgKRB2WA5JiChgoPK0EbTg YH3V76JvBwTBKTYeQO5KtUOjPv/2UQZQH0m5/t6L7vc0/Nj1rEybs51aYJzlXmN1DDwcYl93JqoH 2BFUl0BTkX1FlBvc7H7D09K3xBGxQ04zO7lRDM4FEEjk3ZuMQTzj3pvhR6sKOTHgOfitvvyh8LLB iftFo9cvaiD6biAyHGweUY0u+MfxZeHeT3TenI708O7s8uN7HBocPNIgPLj0Bz1xXkkaUpCVBohx ipHl74xBt14ZAp08hAamaego+ZGTNAfrEov7QGML77BAIxxlsJajL1UdXGl4oFvAlnFnfaDxhjDc 3g18ha6E+1xzVAAu02A0uHqVOvOXGy2VYy9ns7rbDq+iXAI9tvzHou7dvdXnrlrrRlfOvxfqUsUQ PHohD8UaNSo113jXpVQ9qMfAqCovOyqd6KdPd5cjVrP9694K1UZFQNb97rvvmoReb1N1SYb1AHfd PkrgxnC44pmcf0s7v674g7zMii77lsiSdY8JayeGyFAa+W1tPckH8OuRL/zvCPnvdOt6BXwbvXAL wAMqmTER+pPMD5zW7NRCLfDkouaL9EZ9et3bDO8d3dtzr90b4+8/vMTfuYQtGeENWfgF0on4/Jl/ Mx+9DG7xT/S6Z2ay+HekhpVvqa6UXkj3Ai+kw42GyLBU/jnKqTKtnOqP7AzNteciFHeJa+lym+gS Ow34rYH4S/Hy0+7/CwAAAP//AwBQSwMEFAAGAAgAAAAhAOZpBAK+AgAAUAkAABEAAAB3b3JkL2Nv bW1lbnRzLnhtbORV3U7bMBi9n7R3sHzfximMgUWKNtiAC6SJspvdTG7iEquObdlOAnd7B95wT7LP +WuhDLVwt0lVEyXnOz7f8eeT45O7QqKKWye0SnA8JhhxlepMqNsEf7/5OjrEyHmmMia14gm+5w6f TN+/O65pqouCK+8QUChHa5MmOPfe0Chyac4L5saFSK12euHHAI70YiFSHtXaZtGExKS5M1an3DlY 75Spijnc0RV6O7aCpT3xhJDDqGBCDRybirThCvQutC2Yd2Ntb6HCLkszAoWGeTEXUvh70EcOBpoq waVVtOtqNHQVaigIoFUhezDI/ju2dYC2l77CbjT6jMi25EynZfC8kRdZLkGwVi4XZuXba9nAj7yX 9GLDa83WJt7fWG+wZ5tNP7Oshr3vF67NBt0zZmRtUSFbH8JArcboKWNMttiRQDFo2EbC4zV7JevD V7/OmtUk1QaO4FsO1LnVpRm6MuJtbJdqOXCFJNhBGTlojvp6a24ngo2smOXMcIyKlF7eKm3ZXIIi cByFicTTVTqhmooswRBrNWWlzzWctis48Oh6jC6EWkpgqWnGPNRDJu2PyN6IfLyJJ5QQ+P0Ib4US XjAJkq8uGm4DDyExs2sgJpP44NPRUcA1j874gpXSr70Jasw321xm/l5ygFZMJvi0DdAbfudxND2O BliDtW2Jfa7kmi+4hZzmXV2HZUpp30QCAFrGliqs7UOwUmdYCq0ayx23FcfTS+Rz8AH+mUcu16XM 0BwkcsQsR8CHXGn5GAV5vhHZUM61XobgnHlmffAITI6DCYoVwP/zXH9m6TLIq2mP/aKyAdn12xBC ioZQC9DutoNNAuEuuxbTD0f/1a6BtR5JzTL4giPhkK81CtHknmxYmK2Xvd7b1et/8IRMZ4ZLCZ8j 9PvXA2IVEzIky6PR33QSnnRj66Z/AAAA//8DAFBLAwQUAAYACAAAACEAIVqihCEHAADbHQAAFQAA AHdvcmQvdGhlbWUvdGhlbWUxLnhtbOxZT28bRRS/I/EdRnsvsRMnTaI6VezYDbRpo9gt6nG8O/ZO M7uzmhkn8Q21RyQkREEcqMSNAwIqtRKX8mkCRVCkfgXezOyud+Jxk5QAFTSH1jv7e2/e+70/82ev XD1KGDogQlKeNoP6e7UAkTTkEU1HzeB2v3tpNUBS4TTCjKekGUyIDK5uvPvOFbyuYpIQBPKpXMfN IFYqW19YkCEMY/kez0gK74ZcJFjBoxgtRAIfgt6ELSzWaisLCaZpgFKcgNpbwyENCeprlcFGobzD 4DFVUg+ETPS0auJIGGy0X9cIOZFtJtABZs0A5on4YZ8cqQAxLBW8aAY18xcsbFxZwOu5EFNzZCty XfOXy+UC0f6imVOMBuWk9W5j7fJWqd8AmJrFdTqddqde6jMAHIbgqbWlqrPRXa23Cp0VkP05q7td W641XHxF/9KMzWutVmt5LbfFKjUg+7Mxg1+trTQ2Fx28AVn88gy+0dpst1ccvAFZ/MoMvnt5baXh 4g0oZjTdn0HrgHa7ufYSMuRs2wtfBfhqLYdPUZANZXbpKYY8VfNyLcH3uOgCQAMZVjRFapKRIQ4h i9uY0YGgegK8TnDljR0K5cyQngvJUNBMNYMPMgwVMdX38tl3L589Qcf3nx7f//H4wYPj+z9YRY7U Nk5HVakX33z6x6OP0O9Pvn7x8HM/Xlbxv3z/8c8/feYHQvlMzXn+xeNfnz5+/uUnv3370APfFHhQ hfdpQiS6SQ7RHk/AMcOKazkZiPNJ9GNMqxKb6UjiFOtZPPo7KnbQNyeYYQ+uRVwG7whoHz7gtfE9 x+BeLMYqj7fj2fU4cYA7nLMWF14Wruu5KjT3x+nIP7kYV3F7GB/45m7j1IlvZ5xB36Q+le2YOGbu MpwqPCIpUUi/4/uEePi6S6nD6w4NBZd8qNBdilqYeinp04GTTVOhbZpAXCY+AyHeDjc7d1CLM5/X W+TARUJVYOYxvk+YQ+M1PFY48ans44RVCb+BVewzsjcRYRXXkQoiPSKMo05EpPTJ3BLgbyXo16F1 +MO+wyaJixSK7vt03sCcV5FbfL8d4yTzYXs0javY9+U+pChGu1z54DvcrRD9DHHA6dxw36HECffp 3eA2HTkmTRNEvxkLTyyvEe7kb2/ChpiYVgNN3enVCU1f1bgT6Nu54xfXuKFVPv/qkcfuN7VlbwIJ vprZPtGo5+FOtuc2FxF987vzFh6nuwQKYnaJetuc3zbn4D/fnOfV88W35GkXhgatt0x2o2223cnc XfeQMtZTE0ZuSLPxlrD2RF0Y1HLmxEnKU1gWw09dyTCBgxsJbGSQ4OpDquJejDPYtNcDrWQkc9Uj iTIu4bBohr26NR42/soeNZf1IcR2DonVDo/s8JIeLs4apRpj1cgcaIuJlrSCs062dDlXCr69zmR1 bdSZZ6sb00xTdGYrXdYUm0M5UF66BoMlm7CpQbAVApZX4Myvp4bDDmYk0rzbGBVhMVH4e0KUe20d iXFEbIic4QqbdRO7IoVm/NPu2Rw5H5sla0Da6UaYtJifP2ckuVAwJRkET1YTS6u1xVJ02AzWlheX AxTirBkM4ZgLP5MMgib1NhCzEdwVhUrYrD21Fk2RTj1e82dVHW4u5hSMU8aZkGoLy9jG0LzKQ8VS PZO1f3G5oZPtYhzwNJOzWbG0Cinyr1kBoXZDS4ZDEqpqsCsjmjv7mHdCPlZE9OLoEA3YWOxhCD9w qv2JqITbClPQ+gGu1jTb5pXbW/NOU73QMjg7jlkW47xb6quZouIs3PST0gbzVDEPfPPabpw7vyu6 4i/KlWoa/89c0csBXB4sRToCIdzsCox0pTQDLlTMoQtlMQ27AtZ90zsgW+B6Fl4D+XC/bP4X5ED/ b2vO6jBlDWdAtUdHSFBYTlQsCNmFtmSy7xRl9XzpsSpZrshkVMVcmVmzB+SAsL7ugSu6BwcohlQ3 3SRvAwZ3Mv/c57yCBiO9R6nWm9PJyqXT1sA/vXGxxQxOndhL6Pwt+C9NLFf36epn5Y14sUZWHdEv prukRlEVzuK3tpZP9ZomnGUBrqy1tmPNeLy4XBgHUZz1GAbL/UwGV0BI/wPrHxUhsx8r9ILa53vQ WxF8e7D8IcjqS7qrQQbpBml/DWDfYwdtMmlVltp856NZKxbrC96olvOeIFtbdpZ4n5PschPlTufU 4kWSnTPscG3H5lINkT1ZojA0LM4hJjDmK1f1QxQf3INAb8GV/5jZT1MygydTB9muMNk14NEk/8mk XXBt1ukzjEaydI8MEY2OivNHyYQtIft5pNgiG7QW04lWCi75Dg2uYI7Xona1LIUXTxcuJczM0LJL YXOX5lMAH8fyxq2PdoC3TdZ6rYurYIqlf4WyMxjvp8x78jkrZfag+MpAvQZl6ujVlOVMAXmziQef NwWGo1fP9F9YdGymm5Td+BMAAP//AwBQSwMEFAAGAAgAAAAhANNI92xzAwAAqAcAABEAAAB3b3Jk L3NldHRpbmdzLnhtbJxV227cNhB9L9B/WOi5a0mbtbcRLAeO020T2I1RJR8woigta95AUitvv75D UrTiOA2CPomcy5nhzJnR5ZtHwVdHaixTss7KsyJbUUlUx+RQZ58/7de/ZivrQHbAlaR1dqI2e3P1 80+XU2Wpc2hmVwghbSVInR2c01WeW3KgAuyZ0lSisldGgMOrGXIB5mHUa6KEBsdaxpk75ZuiuMhm GFVno5HVDLEWjBhlVe+8S6X6nhE6f5KH+ZG40fOdIqOg0oWIuaEcc1DSHpi2CU38XzR84iGBHL/3 iKPgyW4qi+9Zzs+dlOmePH4kPe+gjSLUWmyQ4PG5Aph8gim3L4CeSn2Gpc5j7NxDoXtZhNOSueUv /L/R7djFW9YaMLHNSACfhSDV+0EqAy1HUk3lNrtCRv2jlFhN1REQvKXW7ZnL8K6pIdi0OtuUZZZ7 w45ZzeH0FsjDYNQou+YAmgYVvlv1jQNH0dNqynmgMuEUMO5UDQYEkrDOoiTC0R5G7j5B2zilUwa7 TRGjkQMYII6aRgNBtBslnVE82XXqT+VukNAG6z17BHr7TEdL97/dwkmNLoSKxG/i6CCCBIEFiNJ5 HO5UR32mo2EvavyfPfIOoW5YSgyUT1XE9DngcHc2Hf5SyiXbotjtdufb+ZnebNFsyovr16/jc55r Fh+MMmOLytP/3lxdxtMeS7QSMaMbEK1hsLrzA4K5iao1D2+ZTPqW4oKgX2qasU3K9ToqrADO99iG pAhJi8CEd7QPsPwOzLDgzhbmm9KO9h+esDy7qPkdmaRjtMmAfi87FKdw5TaWSVRMulsmktyObZO8 JJL8CxXS8uPReMB8Kc9UOdyN1NfnFuSQ6k3l+nPje0jBumvLoM7+hvWHe++NreSm8SuV3oHWSEC0 a4eyzjgbDq70bg5vHa7WcGmHzazbBB3evC5cgPjHovV88AbxiFbzYZG9SrJXiwwXR7TbLrLzJDtf ZBdJhqt9qg4nnGIcxQekdDp6ea84VxPt/kjCOnshikUIY3Y9OpVG7Z4RN+LMhRJZvwCQCH6Okeuq CgLschCsjhV9xAVCO79RrGadgEf83RWbnQefrXGj4Jg+s/U6b6yfSVcdOOxQWEb5M+cweV/lguuK Eob8bU6iXdbGWXwWZ9Y1VOOGccpgQcIQ/+J1OF3pF3v1LwAAAP//AwBQSwMEFAAGAAgAAAAhAEIH jgpPAgAAjwkAABIAAAB3b3JkL2ZvbnRUYWJsZS54bWzcVc1u00AQviPxDtbeG6+dUKKoSQVFRUjA AcIDbNbrZMX+WLvrpLmmd84c6CMgDiBx6dtE6rWvwKzXidLGqYLUA8RWZPvbnS/jb74Zn5xeSBFN mbFcqz5KWhhFTFGdcTXuo0/D86MuiqwjKiNCK9ZHc2bR6eDpk5NZL9fK2Qjile1J2kcT54peHFs6 YZLYli6YgsVcG0kcPJpxLIn5XBZHVMuCOD7igrt5nGJ8jGoasw+LznNO2StNS8mUq+JjwwQwamUn vLArttk+bDNtssJoyqyFd5Yi8EnC1Zom6WwRSU6Ntjp3LXiZOGQUeyoIT3B1JwWKJO29GSttyEiA drOkgwa1cNGsp4gEcMgls9F7Nos+aElUtaEgSluWwJ4pEX2EUziPcRs/wx34pXDXQbFnohNiLHPr jTjAOZFczFcoKZ0OeMEdnazgKTHc5xWWLB/DQmlHGP4vHG0UkGSNgDmqPekW0r6L0E2exEcBsskD 2cfBQVuCnBE5gsx2COEFCEJ4QdJDFuL2+vvt9c/o5uuXm29XjXLUhdq8NPqi2+gLU/mt8pHSbmhK NpwXrHq+Y5ScX7Bsp0uq6oJvfHW7+LnP5b5LkhWyyyUwAkLU/i4ZGjYqYdK46N3HRm1S/LLqGd87 4XyEnslYTkrhvBi77PsCvCseyKizzuegzfu2pDwj0WsDnw72gBy4Hmm+RI9QoH91qNW9vFz8Wi5+ Ly8vl4sfjaL4Rrh3/EVHS50xo0LA/9fSZ0RwmPyNuqT4vPryVTY5uMFfzxI7+AMAAP//AwBQSwME FAAGAAgAAAAhAHD2w7UACgAAWE8AAA8AAAB3b3JkL3N0eWxlcy54bWzMXFtz27YSfu9M/wOH7451 ceTGU6XjOEnjM07rRs6cZ4qELDQkofISx+fXn8UCBClSEBcmfXzyYgkk9sNe8O1SwfLX334ksfed ZTkX6dKfvpr4HktDEfH0ful/vft48ovv5UWQRkEsUrb0H1nu//b2559+fbjIi8eY5R4ISPOLJFz6 26LYXZye5uGWJUH+SuxYChc3IkuCAr5m96dJkH0rdyehSHZBwdc85sXj6WwyWfhaTEaRIjYbHrL3 IiwTlhY4/zRjMUgUab7lu7yS9kCR9iCyaJeJkOU5KJ3ESl4S8NSImZ51BCU8zEQuNsUrUOZUrehU ioLp0wl+SmLfS8KL6/tUZME6BuM9TM/8t2C5SITv2SYo4yKXX7PbTH/V3/DPR5EWufdwEeQh53dg UhCQcJD16TLNuQ9XWJAXlzkPmhc/6DF5fStvbF40M8O8aAh8xyPun0rQ/D8w7XsQL/3ZWTVyJRex NxYH6X01xtKTr6vmYpb+38HJv27l0BrkLv0gO1ldSmGnqGn1t6Hxzuiv7mqZBxwLbl6paAPjsc2N CL+xaFXAhaUPEYuDX69vMy4yiKil/+aNHlyxhH/iUcRkcFc3plsesX9vWfo1Z1E9/tdHjFQtMRRl WoAdzhfosjiPPvwI2U7GGOClgXTHH3ICeBkM18DBBZW8Xo0aaKHi4D8V5FRZ+yDKlgVyO3q4/qNA qHU5GGgmNWoqgHKd1jofLuJsuIjXw0UAMw21xflwEUDCQ1ehYqMRlXSnFiJUwdeMifmbIyErZ3Si qHdGJ2h6Z3RipHdGJyR6Z3QioHdGx+G9Mzr+7Z3RcefRGWGAxNWOojlag7Sx73gRMzn/KAFNB1Kd TgrebZAF91mw23oyC7aXfYwsV+W6oC0V6fTpZLkqMpHe91pkprbBkzn5Q7LbBjmHkqbH9LOBpr+T JYr3e8ajXqjXKvg6OmEJcTCF3cZByLYijljm3bEfyqMO8/8Q3moXhJAFexc30K03/H5beKstptxe sIXF6HZLKPk3PEcbHN1MC4sqfcJJPlxY4tIu/DOLeJlUpiFUIwvF5w5ubkHgEo+b6Ey6qLuJe7WQ DqCooNKFuwoon7B+lVzc5UsfU9avUtET5RPWrxLXE+VjfBz3rzPTvIcnTI+0vc6d9+6ViEW2KeNq D/TSw7nzDjYQNBWcN7GRTyKJc+cdvEef3mUYwpMbJU6dfVHzqAOKszsUCm42ui7OTmnR3tRBI2cH tbBmDljDuNYByJl0v7DvXP6A5ZoMkKVNrdm7necWC0AKItXQf5Wi6K+hZxbOo6Jcp/BzSc48Gtrc svOoaDqeVL5z8PGwxOcANCwDOgANS4UOQJb4sNc8JifSQYYnRwcsZ1o2WQzDjszM587MbIDcUsBI eZNQf1l2rz0WunmTgOLsoG7eJKA4e6eVy0zeJGCNljcJWJasYfdRk1NdlHLOm00gUwkQNBqHvAlA 45A3AWgc8iYADSfvfpDxyJuA5cwNhlOb5E0AwltcHvUNUJO8CUDO3KDYTv9mVOU9lHL84XYE8iag ODuoS94EFGfv2MibgIW3uERCC8tQHQFrHPImAI1D3gSgccibADQOeROAxiFvAtBw8u4HGY+8CVjO 3GA4tUneBCBnejBATfImAOEtLtxwkLxx1z87eRNQnB3UJW8CirN3WoRqilQClrODWliGvAlYeItL MGgsDG4XpcYhb4JG45A3AWgc8iYAjUPeBKDh5N0PMh55E7CcucFwapO8CUDO9GCAmuRNAHLmhoPk jZvx2cmbgOLsoC55E1CcvdMiVMNzBCxnB7WwDHkTsDBeBpM3AQhveSqQi0bjkDdBo3HImwA0DnkT gIaTdz/IeORNwHLmBsOpTfImADnTgwFqkjcByJkbDpI37pFnJ28CirODuuRNQHH2TotQDXkTsJwd 1MIyVEfAGoe8CUAYmIPJmwCEtzwBCHeRi5vGIW+CRuOQNwFoOHn3g4xH3gQsZ24wnNokbwKQMz0Y oCZ5E4CcuUGes4XzouTjqVNLEFDPGVSnGsiAM4uTqIBawS9swzLoiGL9p0MGAlYaOiBawoOq4jsh vnm0g91zS4CQofg65gKPdD/iKZ1GI8L8/Egnwd2fV94n1QDTmYchtX/yBnqMmu1C2NMkG4dgncXj Dlp2dtXJcikNWolkE5ZuAcJ+tmtoCNJtPXKy7POBG7H9SQ/j/9tqVPgMiDixB8oI18pMsauoKb5u 80GEdQDNSX/KXiMEh74vaDWaKEulcIT64AXopMJ1qLPScMuaQfsdqA09dmpqCOfpYXYZxPpANYKJ soh5ym6+x5VYvB100xKhRU0Kzvaa0pb+XcbWJbT7Fd7nlTRo1ZHWvYK9aN3hMG+N4XLqNrT5TC67 0Tn2FFvPrLZG6WCll7U19jO8lK3XLYvPFiNYfG61+FyF4bgWn8I5fFSDGt1VVL1IdCuLh/IwcbXb FvhP6VAHv+rBHBj8quP0ENHoDs8XdgUGxEsFv9UJZeUZ2RMMjU/DSei1dUu8Vn5/YT9gNPyf+WFg 6KvO3UOhjxw3Nu87sxA6/qVMzjVhHmShfsOHWyikwoJlR+oo3c1nDlhjL1+7qrK0/OHq6n7Tajvq 1r/6ByJ1314DitqrlkKhkG1uR9aMbXBHC0APb1F7trtA6DzHJfWtEOrRdayKKvhwnUagIbyuAI8E qUo1+hEoUXD9isXx5wBLsELs7LfGbCMLQxA0neDjfUvUWhSFSOzzM+x+swqAsGguRn2VSsAni73T MlmzTDfuWett+Vjc4Udo+sNxSyhQLW1f296zQFjmYJqVfFhoPw9UtXc7dNW4cpKuJB54JB6uoMbO xH4pDQYyRbkstdWbBcAT8suXUoIGZSGkMFjw8brkMuPqrQN1uW2GdJ1tvssCW31BM+4lvAn+0/Fa v/mhKo6w5idaD70vn53U42TbUmoUVzAkzR0q73qt9ezPKGeDDGYalts2MxcGm62OvGADjN3zNPhS Bj2akGD71AFKfELZS1EmQK9EIt8aU//K0rZ7kKYC3iwi3/ORmR9/DvngYHrDG4ekBXgTj8wF+NA/ mcymi8uK6PQzeG2I6S/V3q3f0aLGwIdP2r3aONiifcQu8hcEBd3azTpxohGA2L5VijTkXkHhoOY+ h5XsdLUXDUfIvr3Uthn0dWxj92plWoawx4bFLI4msUWJXf+9ZNfeDcA1f7Owm4IbeyHXtxzaCQ2b KT2aP1B1Lh6wgMavzfkcsaH3BJT9SoerHP/W+wleoaBH6v2kxvr3k2N4NRW2RZi+xx5kDcvWlrNb d6QQe1YzHo7Sd0EcC5EepCV9Tb1W4lBw2jipIbS23rPGXfvX05sy5FEA79yA16vhM4ku3vbHW0E6 hPSpQdo2TTtCmza3hyeNAxtYYwfo/9zeFfvmb/8LAAD//wMAUEsDBBQABgAIAAAAIQDdeRbopwoA ALpSAAAaAAAAd29yZC9zdHlsZXNXaXRoRWZmZWN0cy54bWzMXFt3m0gSft9z9j9weHesiyMnOqPM cZxk4j3OjCdyzj4j1LIYI5rlYsXz67e6umkQ0KJa4PXmRRbQ9dWtvyoIpV9+/bkLnSeWpAGPFu74 zch1WOTzdRA9LNwf91/O3rlOmnnR2gt5xBbuM0vdXz/88x+/7Odp9hyy1AEBUTrfx/7C3WZZPD8/ T/0t23npm13gJzzlm+yNz3fnfLMJfHa+58n6fDIaj/CvOOE+S1NAu/aiJy91lbgdp0nbeX4heDIa vTvfeUGkZTQ14jGLQN8NT3Zelr7hyQOsSB7z+Aw0jL0sWAVhkD2DfqOZFvO0cPMkmiurzrRVYs0c FJg/7cLiYlDbfK30wFx+FCuShqEtSsoln7if71iUoXrnCQtBYR6l2yAu/XaqNPDHtlDpqMEVY/fx +KKBp91DCfqnxNtD7AvgfdwQ1+KMtVy0C6UfREKVaVSXOB4RIiJEaB0oKhxiFppUk29/mmvKTNrH sAH7bKjfEp7H2qo46CftJnrUsgQPWGg2muFWr5qWWglocMVy68XMdXb+/OYh4om3CkEj8LgjMtL9 ANy05v4ntvHyMEvF1+QuUV/VN/z4wqMsdfZzL/WD4B44C6TsAhD49SpKAxfOMC/NrtLAq578rI6J 81txYfWkXumnWUXgx2AduOcCNP0blj154cKdXBRHroUSB8dCL3oojrHo7MeyqszC/cs7+9edOLQC uQvXS86WV0LYOVpafFYsjrX98qqae4BIgFaWks/BeWxzy/1Htl5mcGLhQk3Agz9u7pKAJ0CQC/f9 e3VwyXbB12C9ZqJ8FBdG22DN/r1l0Y+Urcvjf35B4lUSfZ5HGfjhcoYhC9P1558+iwWnAV7kiXD8 LhYAu4LjKjioUB6U2sgDNVQ8+J8Cciy93YqyZZ4oeA7qfxQIrc57A02ERVUDUK6VrtP+Ii76i3jb XwQU2r6+uOwvAtqcvlrI3KhkJT2oGfdl8lVzYvr+SMqKFY0s6lzRSJrOFY0c6VzRSInOFY0M6FzR CHjnikZ8O1c0wnl0he8hcdWzaIreIG3s+yALoah1MN24J9WpouDceYn3kHjx1hFVsK72MbJc5quM pirS6elkucwSLnrDDo9M5DY4mZM/7+KtlwbQQncB9XT9vehTnN+SAHrNDqi3MvkaNmEL0VrC7kLP Z1serlni3LOfMqIW63/nzjL2fGzGO5TrGdbb4GGbOdDCiZLb6YmZwelmT0j5t0GKPjhazWcGU7qE k2I4M+SlWfg3tg7yXeEaQjcyk3xuEeYaBKp43EUXIkTNTdxphQgAxQRZLuxNQPkE/WVxsZcvYkzR X5aiE+UT9JeF60T5mB/H42vNNJ/ggYlD2l6X1nv3moc82eRhsQc66eHSegdrCJoJ1ptYyyeRxKX1 Dj6gT+fK9+HOjZKn1rEoedQCxTocEgU3G90W66DUaG9sYZF1gGpYEwusflxrAWRNut/ZUyAeEdsW A2Rp3Wt2buepwQNQgkg99J85z7p76ImB86goNxE8LkmZQ0ObGnYeFU3lk6x3FjHuV/gsgPpVQAug fqXQAsiQH+aeR9dEOkj/4miBZU3Luoph2pGZ+dKamTWQXQkYqG4S+i/D7jXnQrNuElCsA9SsmwQU 6+jUapmumwSsweomActQNcwxqnKqjVHWdbMKpDsBgkXDkDcBaBjyJgANQ94EoP7k3Q0yHHkTsKy5 QXNqlbwJQHiJza2+BqqSNwHImhsk26lnRkXdQynHb24HIG8CinWAmuRNQLGOjom8CVh4iU0m1LA0 1RGwhiFvAtAw5E0AGoa8CUDDkDcBaBjyJgD1J+9ukOHIm4BlzQ2aU6vkTQCypgcNVCVvAhBeYsMN reSNu/7FyZuAYh2gJnkTUKyjUyNU3aQSsKwDVMPS5E3AwktskkFhYXLbGDUMeRMsGoa8CUDDkDcB aBjyJgD1J+9ukOHIm4BlzQ2aU6vkTQCypgcNVCVvApA1N7SSN27GFydvAop1gJrkTUCxjk6NUDXP EbCsA1TD0uRNwMJ86U3eBCC85FQgG4uGIW+CRcOQNwFoGPImAPUn726Q4cibgGXNDZpTq+RNALKm Bw1UJW8CkDU3tJI37pEXJ28CinWAmuRNQLGOTo1QNXkTsKwDVMPSVEfAGoa8CUCYmL3JmwCEl5wA hLvIJkzDkDfBomHImwDUn7y7QYYjbwKWNTdoTq2SNwHImh40UJW8CUDW3CDes4X3Rcmvp44NSUB9 z6B4q4EMODEEiQqoDPzONiyBmUPW/XZIT8DCQgtEQ3pQTfzI+aNDe7F7akgQMlSwCgOOr3Q/41s6 lUGE6eWRSYL7P66dr3IAprEOU+rwzRuYMaqOC+FMkxgcAj2z5xhGduLizXIhDUaJxBCWGgHCidEb GAhSYz1isZjzgQtx/Ekdxv+3VajwNyDiwg4oLVwZM8apoqr4cswHEVYeDCf9IWaNEBzmvmDUaCQ9 FcEr1K0nYJIK9ZDvSsMlKwbTpGA2jIzKpT68Tw+rcy9UL1QjGM+zMIjY7VNYiMXLwTYlEUbUhODk YCht4d4nbJXDPG3mfFsKhxYTac0zOIvWPOzDrN2BEFSnHEObToTalcmxU3w9MfoapYOXXtfXOM/w Wr5e1Tw+mQ3g8anR41OZhsN6fAzv4aMZ1OwusupVslt63BcvExe7bYb/pA1l8ssZzJ7JLydO24hG TXi+cigwIV4r+Y1ByIvIiOF/GHzqT0JvjVvirYz7K8cBs+H/LA49U19O7ralPnLc0LxvzUIY+Ndy eaAIs5WFuh3vb6GR8jOWHOmj1DSffsEaZ/nqXZVh5A+1K+dNi+2oRv/KB0TyuoMBFLlXDY1CJsbc juiMY3BHG0AHL5F7tqkgTJ6jSl0aQj+6CmVTBX/cRGuwcK9Gz2Wnuv7pSVFw/pqF4TcPW7CMx+ZL Q7YRjSEIGo/w9r4masWzjO/M6xOcfjMKgLSoKiO/CiPgL4O/o3y3YomapTP22+K2uMGPMPSHxw2p QPW0WbeDewE/T8E1S3GzUL8fKHrveurK4zJIqpPYB2u+v4YeO+GHrTQ4SDflotWWvywAkRBfvucC 1MszLoSBwsf7kqskkL86ULbb+pDqs/V30WDLL+jGg4I3wn8qX8tffiiaI+z5id7D6It7J3k7WfeU PIoa9Clzbe1dp7cObi/A4aXT6mdOvEe56OUwPbBc95k+0dttZeZ5G2DsjrvB13Lo0YIE26dMUOId ykGJ0gl6zXfiV4rKpyx1v3tRxOGXRcTvfCT64U9bDFrLG17YpyzAb12JWoA3/aPRZDy7KohO3YOX jhi/K/Zu+Rst8hjE8KTdq5yDI9pH/CKeIEjo2m5WhROdAMT2WBhSkXsNjYNc+xJeMtPVQTYcIfu6 qnU3qPM4xu6UxtQcYc4Ng1ssXWLKErP9B8WuvhuAa/5ifrMEV/ZCqi5p2wkVn0k7qg+oGidbPKDw S3e+RG6oPQFtv7ThOsXPcj9N1FOE9O9yP8lj3fvJMr2qBpsyTF1jTrKKZ0vPmb07UIq9qBvbs/Sj F4acR620pM7Jn5VoS04TJ1WElt570byrPz29zf1g7cFvbsAPGOI9iWpADo/XkrQP6VOTtO6aeoZW fW5OTxoHVrCGTtD/ub8L9k0//BcAAP//AwBQSwMEFAAGAAgAAAAhAMLSRxyFAQAA0wIAABAACAFk b2NQcm9wcy9hcHAueG1sIKIEASigAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnFLBTuMw EL0j7T9EuVOnLC0smhqtilYcACE1wNmyJ4mFY1v2gOjfMyE0zWpv69PMm/GbN8+G64/eFe+Ysg1+ Uy4XVVmg18FY327Kp/rP6WVZZFLeKBc8bso95vJa/jiBxxQiJrKYC6bweVN2RPFKiKw77FVecNlz pQmpV8RpakVoGqvxJui3Hj2Js6paC/wg9AbNaZwIy5Hx6p3+l9QEPejLz/U+smAJNfbRKUL5MMhx CxOoBzGhUAdSrrY9yp8MTwk8qhazPAcxBvASkslyuVxVIMYYtp1KShNbKNerNeMzAH7H6KxWxO7K e6tTyKGh4l5p6ynkrhg4QMy7gO3ZoX5LlvaS2eYp3FnPclasZ4xYX1JtUrFjUatB5ZTCTiuHW3ZB NsplBHEEYBv6qPxesthDxISv+SnW4Waw6fvK3+Bs1RdL3S4qzWou1r948nHpWQl27A0aXuFAeATg lp8muWEq3/UtmkPPv4XBxufxj8rl+aLi82XaAePFp88jPwEAAP//AwBQSwMEFAAGAAgAAAAhAMPr kfNkAQAAlwIAABEACAFkb2NQcm9wcy9jb3JlLnhtbCCiBAEooAABAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAJySUU/CMBSF3038D0vf13aMgFm2kqghPkhiFCLxrWkvUNm6pq0M/r3dgAnRJx9v 77lfz7ltPtlXZbQD61StC5RgiiLQopZKrwu0mE/jOxQ5z7XkZa2hQAdwaMJub3JhMlFbeLG1AesV uCiQtMuEKdDGe5MR4sQGKu5wUOjQXNW24j6Udk0MF1u+BjKgdEQq8Fxyz0kLjE1PRCekFD3SfNmy A0hBoIQKtHckwQn50XqwlftzoOtcKCvlDyZkOtm9ZEtxbPbqvVO9sGka3KSdjeA/IcvZ81sXNVa6 3ZUAxHIpMq98CWwJOizpE4RfmJAShniY4hEe0GSIZS32Oeml7VJL7vws7H+lQN4f2IzbbfSKoyel tyXk5LeiHbKwU+0LskGn6MvgogudCQvhahmFGNkx9Lnznj48zqeItX5imsZ0PE/GGU0ySj9aa1fz bazjQXWy+G/iGcA6x9dfiX0DAAD//wMAUEsDBBQABgAIAAAAIQCOnC1o/QAAAKIBAAAUAAAAd29y ZC93ZWJTZXR0aW5ncy54bWyM0MFKxDAQBuC74DuU3LdpZREpbRdBFrx4qT5Amk7bYCYTMtmN+/bG XRXEy94SMvNl5m93H2iLIwQ25DpRl5UowGmajFs68fa63zyIgqNyk7LkoBMnYLHrb2/a1CQYB4gx V3KRFccN6k6sMfpGStYroOKSPLj8OFNAFfM1LBJVeD/4jSb0KprRWBNP8q6q7sU3E65RaJ6NhifS BwQXz/0ygM0iOV6N5x8tXaMlCpMPpIE574P24qEy7pept/8gNDoQ0xzLvIy8TCS/qNxeV+cTWlGg bp4XR0GNNieY6q3oc3wTvVAc1BEeech/WtgbC7Jv5Z9k+08AAAD//wMAUEsDBBQABgAIAAAAIQBv 4pwUYQQAADEVAAASAAAAd29yZC9udW1iZXJpbmcueG1sxFjdjqM2FL6v1HeIkHo5iW0wP9FmViQh 1VTbqlKnD0AImaAFgwxJdp6hF73r3vbZ+iQ9hhicQLMwg9SbIeDj4++zz8/n+fDxSxJPTiHPo5Qt NDxF2iRkQbqL2MtC+/1582Brk7zw2c6PUxYutNcw1z4+fv/dh/OcHZNtyMFwAj5YPj9nwUI7FEU2 n83y4BAmfj5NooCnebovpkGazNL9PgrC2TnluxlBGJW/Mp4GYZ6Dn5XPTn6uXdwlaT9viR9IxwQh e5b4Eat9tBGlWcgA7z7liV/k05S/wAz++Zg9AMLML6JtFEfFK+BDZu3mtNCOnM0vrB5qVmLOHADM T0ksjQH2f9tWOzCvHnIGbxHtAFlNWafBMQlZUcKb8TAGwCnLD1HW7NtbvcF+HCSku4QVsucMG631 6u3pc+hr7p/h7OXC56zlrmMzdtWkJK72QQRUE0a3HjHqcSLCRY2hD4TrNSUSNfjOb9uaJpLOGeTg exLqR54es5pVFr3P2xP7XPsSpWAAMmSWqa5Sywc5aNWK3w5+FmqTJJg/vbCU+9sYEMGOT0REao9Q nvxtXnA/KH45JpOrt6fdQkOlCcujHYyd/HihEbpE2F462kxMTo5xEX0KT2H8/JqF0ubwuuXR7mcx FouxyrZIslhamHRpkA1dVSPxSQxE8BArws8ii6EiUROZYGaXGKC48kJOx9U8qKybpP64PcZxWNQe n8Mv9dA/X/+sv/8USC9xuL+YZ79ywSZigqb4vNAsUiLZRzwvPkXiHHUTCSez8/xizqtZR+mPQeW/ WJRDYAmUhGOVIG4IYsM1DErMMQj+MZQgNoxbhhjZo1AkDUXD9JBFdG8Ein/9PZQiwXBkcDrKIWIb jUJRbyjqxPZWrkVGoDg8TIkNR3ZNkVAI3REC1WgoYg9CY7kcJRMHByrk3S1FnUDsjkCRNhTdtYc8 B7SMyNf3FZvhgWro7WrjjFNuQJzJekoMF1GX/D+BSlGr3BjmOOXGUijSjWshxx3hFL8ODlRqtcoN NcYpN3C7kKdoWgTOEI1BcXigmkar3Jj4reUG+qMiPkTeKa/AV3kTWgSXh3qlRcwlIdSmVV94qxbB UL6tDfXq7gJLt7SIYyHiem7f3NmFQZT4F+ED3V8VIz/gab3UMDFy8NlLeeG8kSLfFBob4njY0lc9 0+IuejIYvVQaNfxbndGNX1ERznrpUm/Vt//cxa8Pxi9lRIPfuS5c3fgVibDUdde07b45exe/MRz/ RSPU+G8VQjd+pf97G2oajlVdGL7dHO/ip4PxSwFQ479t/934leaub6ht6Zu+zf0ufnMwftnda/wG vpYv3fiVzo08G65LeJT8tQbjl627wX/TuLvxK215TQ3X8yBp+omru/tvD8d/6cs1/tuu3I1f7bmg m5YmHgW/Mxi/bLo1flO/VhUSPzyVnin2Gm7I0M3gb9NAFYsncd0tb/VSTYNla1rV8zqnlfdwWLWc Vj2rf3U+/gsAAP//AwBQSwECLQAUAAYACAAAACEAU6yWr5QBAACWBgAAEwAAAAAAAAAAAAAAAAAA AAAAW0NvbnRlbnRfVHlwZXNdLnhtbFBLAQItABQABgAIAAAAIQDCYJrz9AAAAE4CAAALAAAAAAAA AAAAAAAAAM0DAABfcmVscy8ucmVsc1BLAQItABQABgAIAAAAIQCEierhowEAANUGAAAcAAAAAAAA AAAAAAAAAPIGAAB3b3JkL19yZWxzL2RvY3VtZW50LnhtbC5yZWxzUEsBAi0AFAAGAAgAAAAhAG1u iQUCFwAAQnUAABEAAAAAAAAAAAAAAAAA1wkAAHdvcmQvZG9jdW1lbnQueG1sUEsBAi0AFAAGAAgA AAAhAOZpBAK+AgAAUAkAABEAAAAAAAAAAAAAAAAACCEAAHdvcmQvY29tbWVudHMueG1sUEsBAi0A FAAGAAgAAAAhACFaooQhBwAA2x0AABUAAAAAAAAAAAAAAAAA9SMAAHdvcmQvdGhlbWUvdGhlbWUx LnhtbFBLAQItABQABgAIAAAAIQDTSPdscwMAAKgHAAARAAAAAAAAAAAAAAAAAEkrAAB3b3JkL3Nl dHRpbmdzLnhtbFBLAQItABQABgAIAAAAIQBCB44KTwIAAI8JAAASAAAAAAAAAAAAAAAAAOsuAAB3 b3JkL2ZvbnRUYWJsZS54bWxQSwECLQAUAAYACAAAACEAcPbDtQAKAABYTwAADwAAAAAAAAAAAAAA AABqMQAAd29yZC9zdHlsZXMueG1sUEsBAi0AFAAGAAgAAAAhAN15FuinCgAAulIAABoAAAAAAAAA AAAAAAAAlzsAAHdvcmQvc3R5bGVzV2l0aEVmZmVjdHMueG1sUEsBAi0AFAAGAAgAAAAhAMLSRxyF AQAA0wIAABAAAAAAAAAAAAAAAAAAdkYAAGRvY1Byb3BzL2FwcC54bWxQSwECLQAUAAYACAAAACEA w+uR82QBAACXAgAAEQAAAAAAAAAAAAAAAAAxSQAAZG9jUHJvcHMvY29yZS54bWxQSwECLQAUAAYA CAAAACEAjpwtaP0AAACiAQAAFAAAAAAAAAAAAAAAAADMSwAAd29yZC93ZWJTZXR0aW5ncy54bWxQ SwECLQAUAAYACAAAACEAb+KcFGEEAAAxFQAAEgAAAAAAAAAAAAAAAAD7TAAAd29yZC9udW1iZXJp bmcueG1sUEsFBgAAAAAOAA4AiAMAAIxRAAAAAA== --_004_545D5AEE789B45349983A9EA3FD1ECC1citrixcom_ Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Disposition: inline _______________________________________________ Advisory-board mailing list Advisory-board@lists.xenproject.org http://lists.xenproject.org/cgi-bin/mailman/listinfo/advisory-board --_004_545D5AEE789B45349983A9EA3FD1ECC1citrixcom_-- From advisory-board-bounces@lists.xenproject.org Fri Mar 07 18:28:05 2014 Return-path: Envelope-to: archives@lists.xenproject.org Delivery-date: Fri, 07 Mar 2014 18:28:05 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WLzV6-00074j-Nk; Fri, 07 Mar 2014 18:28:04 +0000 Received: from mail6.bemta5.messagelabs.com ([195.245.231.135]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WLzV2-00074e-Lo for advisory-board@lists.xenproject.org; Fri, 07 Mar 2014 18:28:01 +0000 Received: from [85.158.139.211:14880] by server-6.bemta-5.messagelabs.com id AB/01-14342-FAF0A135; Fri, 07 Mar 2014 18:27:59 +0000 X-Env-Sender: Mark.Hinkle@citrix.com X-Msg-Ref: server-10.tower-206.messagelabs.com!1394216875!4511702!1 X-Originating-IP: [66.165.176.89] X-SpamReason: No, hits=0.0 required=7.0 tests=sa_preprocessor: VHJ1c3RlZCBJUDogNjYuMTY1LjE3Ni44OSA9PiAyMDMwMDc=\n X-StarScan-Received: X-StarScan-Version: 6.9.16; banners=-,-,- X-VirusChecked: Checked Received: (qmail 24475 invoked from network); 7 Mar 2014 18:27:56 -0000 Received: from smtp.citrix.com (HELO SMTP.CITRIX.COM) (66.165.176.89) by server-10.tower-206.messagelabs.com with RC4-SHA encrypted SMTP; 7 Mar 2014 18:27:56 -0000 X-IronPort-AV: E=Sophos;i="4.97,609,1389744000"; d="scan'208,217";a="109212588" Received: from accessns.citrite.net (HELO FTLPEX01CL03.citrite.net) ([10.9.154.239]) by FTLPIPO01.CITRIX.COM with ESMTP; 07 Mar 2014 18:27:54 +0000 Received: from FTLPEX01CL02.citrite.net ([169.254.2.39]) by FTLPEX01CL03.citrite.net ([169.254.1.115]) with mapi id 14.02.0342.004; Fri, 7 Mar 2014 13:27:54 -0500 From: Mark Hinkle To: Advisory-board discussions Thread-Topic: [Advisory-board] Xen Project 4.4 Release Thread-Index: AQHPN+bebhn/+yG6rkWud7aYk4GwRJrRvd0AgAEhnwCAADajgIAAB6+AgAGNyACAAMWOAIAAgM6AgAAhlACAAB8ZAIAAA7iAgAATkwA= Date: Fri, 7 Mar 2014 18:27:54 +0000 Message-ID: <25264475-F9F3-401F-A7E8-579896CD2D0B@citrix.com> References: <6848793A-A83B-40A1-A40C-2AA9DCC1E80A@citrix.com> <2BCAC582-CB61-4E16-96C4-6C1AEFAF81FB@citrix.com> , <545D5AEE-789B-4534-9983-A9EA3FD1ECC1@citrix.com> In-Reply-To: Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-originating-ip: [10.9.154.239] MIME-Version: 1.0 X-DLP: MIA1 Cc: Jennifer Cloer Subject: Re: [Advisory-board] Xen Project 4.4 Release X-BeenThere: advisory-board@lists.xenproject.org X-Mailman-Version: 2.1.13 Precedence: list Reply-To: Advisory-board discussions List-Id: Advisory-board discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: multipart/mixed; boundary="===============1108833969430764246==" Sender: advisory-board-bounces@lists.xenproject.org Errors-To: advisory-board-bounces@lists.xenproject.org --===============1108833969430764246== Content-Language: en-US Content-Type: multipart/alternative; boundary="_000_25264475F9F3401FA7E8579896CD2D0Bcitrixcom_" --_000_25264475F9F3401FA7E8579896CD2D0Bcitrixcom_ Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 SSBkb27igJl0IGRpc2FncmVlIHdpdGggTWF0dCB0aGUgdGV4dCBpcyAgYXdrd2FyZCBwYXJ0aWN1 bGFybHkgYmVjYXVzZSBvZiBpdOKAmXMgaGlnaGx5IHRlY2huaWNhbCBuYXR1cmUuIERvIHlvdSBo YXZlIGFueSBzcGVjaWZpYyBmZWVkYmFjayBmb3IgU2FyYWggdG8gaW5jb3Jwb3JhdGUuIEkgZGlk buKAmXQgd2FudCB0byBwdXNoIHRvbyBoYXJkIHNpbmNlIHRoZSBjbG9jayBpcyB0aWNraW5nIGJ1 dCB3ZSBzaG91bGQgZ2V0IHRoaXMgcmlnaHQuDQoNCkdvaW5nIGZvcndhcmQgSSB3b3VsZCBsaWtl IHRvIHN1Z2dlc3QgdXNpbmcgT3JhY2xl4oCZcyBidWxsZXRlZCBsaXN0IGZvcm1hdCBmb3IgdGhl aXIgcHJlc3MgcmVsZWFzZXMgc2luY2UgdHlpbmcgdG9nZXRoZXIgdGhlIGFjdHVhbCBuZXdzIGFu ZCB0ZWNoIGNvbnRlbnQgaW50byBhIGNvbXBlbGxpbmcgbmFycmF0aXZlIGlzIHByZXR0eSB0b3Vn aC4gSGVyZSBhbiBleGFtcGxlIG9mIHdoYXQgSeKAmWQgcHJvcG9zZS4NCg0KaHR0cDovL3d3dy5v cmFjbGUuY29tL3VzL2NvcnBvcmF0ZS9wcmVzcy8yMDMzMzc2DQoNClJlZ2FyZHMsIE1hcmsNCg0K DQpPbiBNYXIgNywgMjAxNCwgYXQgMTI6MTcgUE0sIFdpbHNvbiwgTWF0dCA8bXN3QGFtYXpvbi5j b20+IHdyb3RlOg0KDQpJJ20gbm90IHNhdGlzZmllZCB3aXRoIHRoZSBxdWFsaXR5IG9mIHRoaXMg dGV4dCAodHlwb3MsIGV0Yy4pIGdpdmVuIHRoZSBwbGFuIHRvIHB1dCBpdCBvbiB0aGUgd2lyZSBN b25kYXkuIFdlIHN0aWxsIGRvbid0IGhhdmUgYSBzdHJvbmcgbWVzc2FnZSBhbmQgYSBwbGFuIG9u IGhvdyB3ZSBwbGFuIHRvIGJyYW5kIHRoZSB0ZWNobm9sb2dpZXMgdGhhdCBhcmUgcHJvZHVjZWQg YnkgdGhlIGNvbW11bml0eS4NCg0KLS1tc3cNCg0KX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX18NCkZyb206IGFkdmlzb3J5LWJvYXJkLWJvdW5jZXNAbGlzdHMueGVucHJvamVjdC5vcmcg W2Fkdmlzb3J5LWJvYXJkLWJvdW5jZXNAbGlzdHMueGVucHJvamVjdC5vcmddIG9uIGJlaGFsZiBv ZiBNYXJrIEhpbmtsZSBbTWFyay5IaW5rbGVAY2l0cml4LmNvbV0NClNlbnQ6IEZyaWRheSwgTWFy Y2ggMDcsIDIwMTQgOTowNCBBTQ0KVG86IEFkdmlzb3J5LWJvYXJkIGRpc2N1c3Npb25zDQpDYzog SmVubmlmZXIgQ2xvZXINClN1YmplY3Q6IFJlOiBbQWR2aXNvcnktYm9hcmRdIFhlbiBQcm9qZWN0 IDQuNCBSZWxlYXNlDQoNClNhcmFoLA0KDQpCcmFuZGluZyBzZWVtcyB0byBiZSBhcHBsaWVkIGFw cHJvcHJpYXRlbHkgdGhvdWdoIEkgdGhpbmsgdGhlcmUgd2VyZSBhIGNvdXBsZSBvZiBzcGVsbGlu ZyBpc3N1ZXMgSSBjYXVnaHQuIEF0dGFjaGVkIGlzIGZpbmUgYnkgbWUgdGhvdWdoIHRoZSBicmFu ZGluZyBhbmQgZmxvdyBpcyBzdGlsbCBhIGJpdCBjaGFsbGVuZ2luZy4NCg0KTWFyaw0KDQoNCk9u IE1hciA3LCAyMDE0LCBhdCAxMDoxMyBBTSwgU2FyYWggQ29ud2F5IDxzY29ud2F5QGxpbnV4Zm91 bmRhdGlvbi5vcmc8bWFpbHRvOnNjb253YXlAbGludXhmb3VuZGF0aW9uLm9yZz4+IHdyb3RlOg0K DQpIaSBldmVyeW9uZS4NCg0KSSd2ZSBpbmNvcnBvcmF0ZWQgZXZlcnlvbmUncyBlZGl0cy4gSSB0 cmllZCB0byByZWNvbmNpbGUgdGhlIFRNLXJlbGF0ZWQgaXNzdWVzIG9mIGJyYW5kIGNvbmZ1c2lv biBhbmQgZmxvdyBhcyBiZXN0IEkgY291bGQuIEFzIHlvdSBjYW4gaW1hZ2luZSwgSSBnb3QgdmFy eWluZyBlZGl0cywgd2hpY2ggc3RhcnRlZCB0byBjb25mbGljdCB3aXRoIG9uZSBhbm90aGVyLg0K DQpUaGlzIHdvdWxkIGJlbmVmaXQgZnJvbSBhbm90aGVyIFRNIHJldmlldy9maW5hbCBhcHByb3Zh bC4gQ2FuIHNvbWVvbmUgc3RlcCB1cCB0byBkbyB0aGlzIGFuZCBtYWtlIGEgZmluYWwgY2FsbD8N Cg0KTWlrZSBELiwgQ2l0cml4IGlzIG9uIHRoZSBmdWxsIEFCIGVtYWlsIGxpc3Qgc28gdGhleSd2 ZSBiZWVuIGludm9sdmVkIGluIHJldmlld3MuDQoNClBsZWFzZSBhZHZpc2Ugc29vbmVzdC4NCg0K VGhhbmtzLA0KDQoNCg0KDQpPbiBGcmksIE1hciA3LCAyMDE0IGF0IDg6MTMgQU0sIFJpY2hhcmQg UGhlbGFuIDxSaWNoYXJkLlBoZWxhbkBhcm0uY29tPG1haWx0bzpSaWNoYXJkLlBoZWxhbkBhcm0u Y29tPj4gd3JvdGU6DQpIaSwNCg0KSSBhZ3JlZSB3aXRoIE1hcmsgYXMgdGhlIGN1cnJlbnQgcHJl c3MgcmVsZWFzZSBpcyBoaWdobGlnaHRpbmcgaXNzdWVzIHRoYXQgc2VlbSB0byBtYWtlIHRoZSBh cnRpY3VsYXRpb24gb2YgYnJhbmQgYW5kIGJyYW5kIHZhbHVlcyBtb3JlIGN1bWJlcnNvbWUgdGhh biBpcyBkZXNpcmFibGUuDQoNCkknbSBoYXBweSB0byBnbyB3aXRoIHRoZSBwcm9wb3NlZCBjaGFu Z2VzIGZvciB0aGUgcmVhc29ucyBzdGF0ZWQuDQoNCk9uZSBtaW5vciBwb2ludCwgSSdkIHByZWZl ciAiP+WQgXlzdGVtIG9uIENoaXAgKFNvQykgZGV2aWNlcy4iLCB0d28gc2V0cyBvZiBwbHVyYWxz IG1ha2UgaXQgdW5jbGVhciBob3cgbWFueSBzeXN0ZW1zIGFyZSBvbiBlYWNoIGNoaXAgYW5kIHRo ZSBwbHVyYWxzIGdldCBzdWJtZXJnZWQgaW50byB0aGUgYWNyb255bTsgY29tbW9uIHVzYWdlIHNl ZW1zIHRvIGJlIFNvQ3MuDQoNClRoYW5rcywNCg0KUmljaGFyZC4NCg0KRnJvbTogTWFyayBIaW5r bGUgPE1hcmsuSGlua2xlQGNpdHJpeC5jb208bWFpbHRvOk1hcmsuSGlua2xlQGNpdHJpeC5jb20+ Pg0KUmVwbHktVG86IEFkdmlzb3J5LWJvYXJkIGRpc2N1c3Npb25zIDxhZHZpc29yeS1ib2FyZEBs aXN0cy54ZW5wcm9qZWN0Lm9yZzxtYWlsdG86YWR2aXNvcnktYm9hcmRAbGlzdHMueGVucHJvamVj dC5vcmc+Pg0KRGF0ZTogRnJpZGF5LCA3IE1hcmNoIDIwMTQgMDU6MzINClRvOiBBZHZpc29yeS1i b2FyZCBkaXNjdXNzaW9ucyA8YWR2aXNvcnktYm9hcmRAbGlzdHMueGVucHJvamVjdC5vcmc8bWFp bHRvOmFkdmlzb3J5LWJvYXJkQGxpc3RzLnhlbnByb2plY3Qub3JnPj4NCg0KU3ViamVjdDogUmU6 IFtBZHZpc29yeS1ib2FyZF0gWGVuIFByb2plY3QgNC40IFJlbGVhc2UNCg0KTXkgYXBvbG9naWVz IGZvciB0aGUgc2xvdyByZXBseSBJIHdhcyBzdHVjayBvbiB0aGUgcm9hZCBhbmQgY291bGRuPz8g cmVhZCB0aGUgcmVsZWFzZSBvbiBteSBwaG9uZSB0byBmb3JtdWxhdGUgYSBwcm9wZXIgcmVzcG9u c2UuIEkgc2hvdWxkIG1vdmUgdG8gYSBoaWdobHkgZWxhc3RpYyBYZW4gUHJvamVjdC1wb3dlcmVk IGNsb3VkIHRoYXQgYWxsb3dzIG1lIHRvIGF1dG9zY2FsZSA7KSAoc29ycnkgYmFkIGNsb3VkIGpv a2UpLg0KDQpJIGFtIGZpbmUgd2l0aG91dCBkb2luZyB0aGUgYWNyb255bSBhbmQgSSB0aGluayB0 aGUgcmVhbGlnbmluZyBhbmQgYnJhbmRpbmcgZGlzY3Vzc2lvbiBzaG91bGQgYmUgaGFkLiBJPz8g bGlrZSB0byBoYXZlIHRoYXQgZGlzY3Vzc2lvbiBkdXJpbmcgb3VyIG5leHQgYm9hcmQgbWVldGlu Zy4gR2l2ZW4gdGltZSBpcyBvZiB0aGUgZXNzZW5jZSBJIHRoaW5rIHdlIHNob3VsZCBqdXN0IHVw ZGF0ZSB0aGUgbGlua3MgdG8gdmVyc2lvbiB2ZXJzdXMgWGVuIDQuMy4xLg0KDQpBbHNvIEkgdG9v ayBhIHNob3QgYXQgdGhlIHdvcmRpbmcgb2YgdGhlIHByZXNzIHJlbGVhc2UuIEl0Pz8gcHJvYmFi bHkgbm90IHBlcmZlY3QgYnV0IG1ha2VzIGl0IHJlYWQgYSBiaXQgYmV0dGVyLiBBdHRhY2hlZCBh cmUgbXkgcHJvcG9zZWQgZWRpdHMuIFNhcmFoLCBJIHNlbnQgeW91IHRoZSB3b3JkIGRvYyB3aXRo IHRyYWNrIGNoYW5nZXMgYXNzdW1pbmcgd2UgaGF2ZSBzb21lIGVkaXRzIHRvIGFncmVlIG9uLg0K DQoNClJlZ2FyZHMsIE1hcmsNCg0KDQpYZW4gUHJvamVjdCBSZWxlYXNlcyBVcGRhdGUgdG8gRW50 ZXJwcmlzZSBIeXBlcnZpc29yIFNvZnR3YXJlDQoNCk9wZW4gU291cmNlIFZpcnR1YWxpemF0aW9u IFNvZnR3YXJlIFJlbGVhc2UgSW5jbHVkZXMgQWRkaXRpb25hbCBBUk0gU3VwcG9ydCBhbmQgU2Nh bGFiaWxpdHkgZm9yIENsb3VkIGFuZCBNb2JpbGUgRW52aXJvbm1lbnRzDQoNCg0KDQpTQU4gRlJB TkNJU0NPLCBNYXJjaCAxMCwgMjAxNCA/Py9zcGFuPiBYZW4gUHJvamVjdCwgYSBDb2xsYWJvcmF0 aXZlIFByb2plY3QgaG9zdGVkIGF0IFRoZSBMaW51eCBGb3VuZGF0aW9uLCB0b2RheSBhbm5vdW5j ZWQgYXZhaWxhYmlsaXR5IG9mIHRoZSBYZW4gUHJvamVjdCA0LjQgd2l0aCBlbmhhbmNlZCBBUk0g c3VwcG9ydC4gVGhlIGxhdGVzdCByZWxlYXNlIGFsc28gaW5jbHVkZXMgbWFqb3IgcGVyZm9ybWFu Y2UgYW5kIHN5c3RlbSBzY2FsYWJpbGl0eSBpbXByb3ZlbWVudHMgZm9yIGVudGVycHJpc2UgY29t cHV0aW5nLCBzdWNoIGFzIG1vYmlsZSBhbmQgY2xvdWQgZW52aXJvbm1lbnRzLCB3aGVyZSB2aXJ0 dWFsaXphdGlvbiB0ZWNobm9sb2d5IGlzIGluY3JlYXNpbmdseSBpbiBkZW1hbmQuDQoNClRoaXMg cmVsZWFzZSBmdXJ0aGVyIGFkdmFuY2VzIHRoZSBQcm9qZWN0Pz8vc3Bhbj5zIHBvc2l0aW9uIGFz IGEgZmFzdCwgc2NhbGFibGUsIHNlY3VyZSB2aXJ0dWFsaXphdGlvbiBlbmdpbmUgZm9yIHRoZSBp bmR1c3RyeT8/L3NwYW4+cyBicm9hZGVzdCByYW5nZSBvZiBzZXJ2ZXIsIFBDIGNoaXBzZXRzIGFu ZCBuZXh0LWdlbmVyYXRpb24gbG93LXBvd2VyIHN5c3RlbXMgb24gY2hpcHMgKFNvQykuDQoNCk1h am9yIGNvbnRyaWJ1dGlvbnMgZnJvbSBBTUQsIENpdHJpeCwgSW50ZWwsIE9yYWNsZSBhbmQgU1VT RSBhcmUgcHVzaGluZyB0aGUgWGVuIFByb2plY3Qgc29mdHdhcmUgdG8gdGFrZSBhZHZhbnRhZ2Ug b2YgdGhlIGxhdGVzdCBoYXJkd2FyZS4gQWRkaXRpb25hbGx5LCBkZXZlbG9wZXJzIGNyZWF0aW5n IHNlcnZpY2VzIGFuZCBhcHBzIHdpdGggZW1iZWRkZWQsIG1vYmlsZSBhbmQgY2xvdWQgc3lzdGVt cyB3aWxsIGJlbmVmaXQgZnJvbSBuZXcgZmVhdHVyZXMgc3VjaCBhcyBldmVudCBjaGFubmVsaW5n IHdoZW4gc2NhbGluZyBvdXQgdGhlaXIgSW5mcmFzdHJ1Y3R1cmUgYXMgYSBTZXJ2aWNlIG9mZmVy aW5ncy4NCg0KPz8vc3Bhbj5WaXJ0dWFsaXphdGlvbiBhbmQgbG93LXBvd2VyZWQgc2VydmVycyBh cmUgbGVhZGluZyBjb21wYW5pZXMgdG8gcmV0aGluayB0aGUgZGF0YSBjZW50ZXIgYW5kIGl0cyBw b3RlbnRpYWwgZm9yIGVmZmljaWVuY3ksPz8gc2FpZCBMYXJzIEt1cnRoLCBDaGFpcm1hbiBvZiB0 aGUgWGVuIFByb2plY3QgYWR2aXNvcnkgYm9hcmQuID8/L3NwYW4+T3VyIHNvbHV0aW9uIGNvbnRh aW5zIElULXJlbGF0ZWQgY29zdHMsIHBsdXMgbWVldHMgdGhlIHNlY3VyaXR5IGFuZCBzY2FsYWJp bGl0eSBuZWVkcyBvZiB0b2RheT8/L3NwYW4+cyBlbGFzdGljIGNsb3VkLCBtb2JpbGUgYW5kIHNv Y2lhbCBuZXR3b3JraW5nIGNvbXBhbmllcy4gVGhlIGxhdGVzdCB1cGRhdGVzIGNvbnRpbnVlIHRo ZSBQcm9qZWN0Pz8vc3Bhbj5zIHRyYWNrIHJlY29yZCBvZiByaWNoIGNvbGxhYm9yYXRpb24gYW5k IHdpZGVzcHJlYWQgZGV2ZWxvcG1lbnQgZnJvbSBtYW55IG9mIHRoZSB3b3JsZD8/L3NwYW4+cyB0 ZWNobm9sb2d5IGxlYWRlcnMuIFRoaXMgY2VydGFpbmx5IGV4cGxhaW5zIHRoZSBzaWduaWZpY2Fu dCBncm93dGggb2YgQVJNIHN1cHBvcnQsIHdoaWNoIHdlPz8vc3Bhbj5yZSBwbGVhc2VkIHRvIHNl ZSBhZHZhbmNlIHNvIHF1aWNrbHkuPz8vc3Bhbj4NCg0KU3VwcG9ydCBmb3IgQVJNIG9uIFhlbiBQ cm9qZWN0IEFyY2hpdGVjdHVyZSBHcm93cyBRdWlja2x5DQoNClRoZSBuZXcgcmVsZWFzZSBpbnRy b2R1Y2VzIHNpZ25pZmljYW50IHN0YWJpbGl0eSwgdXNhYmlsaXR5IGFuZCBwZXJmb3JtYW5jZSBp bXByb3ZlbWVudHMgZm9yIHRoZSBBUk0gYXJjaGl0ZWN0dXJlIGFuZCBleHRlbmRlZCBoYXJkd2Fy ZSBjb21wYXRpYmlsaXR5LiAgQXBwbGllZE1pY3JvPz8vc3Bhbj5zIFgtR2VuZSwgdGhlIEFybmRh bGUgQm9hcmQsIENhbHhlZGEgRUNYLTIwMDAsIFRJIE9NQVA1IGFuZCB0aGUgQWxsd2lubmVyIFN1 blhpIGJvYXJkcyBhcmUgYWxsIHN1cHBvcnRlZC4gVGhlIHN1YnN0YW50aWFsbHkgaW1wcm92ZWQg bXVsdGlwbGF0Zm9ybSBjYXBhYmlsaXRpZXMgb2YgdGhlIGh5cGVydmlzb3IgYWxsb3cgaGFyZHdh cmUgYW5kIGVtYmVkZGVkIHZlbmRvcnMgdG8gcG9ydCB0aGUgWGVuIFByb2plY3QgdGVjaG5vbG9n eSB0byBuZXcgQVJNIFNvQ3MgZWFzaWx5LCBzaG9ydGVuaW5nIHRoZWlyIHRpbWUgdG8gbWFya2V0 Lg0KDQoNCg0KQWRkaXRpb25hbCBlbmhhbmNlbWVudHMgaW4gdGhpcyByZWxlYXNlIGluY2x1ZGVk IDY0LWJpdCBndWVzdCBzdXBwb3J0IG9uIEFSTXY4IHBsYXRmb3Jtcy4gQWxsIHRoZSB1c2Vyc3Bh Y2UgdG9vbHMsIHN1Y2ggYXMgdGhlIHhsIG1hbmFnZW1lbnQgdG9vbCwgYXJlIDY0LWJpdCByZWFk eSBhbmQgY2FuIGJlIHVzZWQgdG8gY3JlYXRlIDY0LWJpdCB2aXJ0dWFsIG1hY2hpbmVzIG91dCBv ZiB0aGUgYm94Lg0KDQoNCg0KVGhlIFhlbiBQcm9qZWN0IGh5cGVyY2FsbCBBQkkgaXMgbm93IHN0 YWJsZSBhbmQgd2lsbCBiZSBtYWludGFpbmVkIGZvciBiYWNrd2FyZCBjb21wYXRpYmlsaXR5LCBz byB1c2VycyBjYW4gdHJ1c3QgZnV0dXJlIHJlbGVhc2VzIHRvIGJvb3Qgb2xkZXIgb3BlcmF0aW5n IHN5c3RlbXMuDQoNCkFkZGl0aW9uYWwgaW1wcm92ZW1lbnRzIGluY2x1ZGUgZXh0ZW5kZWQgc3Vw cG9ydCBmb3IgQVJNIHNwZWNpZmljIGJvb3Rsb2FkZXJzIGFuZCBmaXJtd2FyZSBpbnRlcmZhY2Vz LCBhbmQgc3VwcG9ydCBmb3IgcGh5c2ljYWwgcGFydGl0aW9ucyBhbmQgTFZNIHZvbHVtZXMgdG8g c3RvcmUgZGlza3Mgb2YgdmlydHVhbCBtYWNoaW5lcy4NCg0KDQoNCkltcHJvdmVkIEV2ZW50IENo YW5uZWwgU2NhbGFiaWxpdHkgRm9yIENsb3VkIENvbXB1dGluZw0KDQpYZW4gUHJvamVjdCBkZXZl bG9wZXJzIGNvbnRpbnVlcyB0byBkcml2ZSBpbm5vdmF0aW9uIGFuZCBjb2xsYWJvcmF0aW9uIGFy b3VuZCBzZXJ2ZXIgdmlydHVhbGl6YXRpb24gYW5kIHRoZSBjbG91ZC4gUG93ZXJpbmcgbWFueSBv ZiB0aGUgbGFyZ2VzdCBjbG91ZHMgaW4gcHJvZHVjdGlvbiB0b2RheSwgaW5jbHVkaW5nIEFtYXpv biBFQzIsIFJhY2tzcGFjZSBDbG91ZCBhbmQgb3RoZXJzLCB0aGUgY29tbXVuaXR5IHVuZGVyc3Rh bmRzIHRoZSBuZWVkIHRvIHJ1biBtb3JlIHZpcnR1YWwgbWFjaGluZXMgb24gYSBzaW5nbGUgaG9z dC4NCg0KWWV0IGRlbWFuZHMgb24gaHlwZXJ2aXNvciBzY2FsYWJpbGl0eSBjb250aW51ZSB0byBp bmNyZWFzZSwgYm90aCBmcm9tIGxhcmdlciBtYWNoaW5lcywgbmV3IHdvcmtsb2FkcyBzdWNoIGFz IHZpcnR1YWxpemF0aW9uIGRlc2t0b3AgaW5mcmFzdHJ1Y3R1cmVzIChWREkpIGFuZCBuZXcgY2xv dWQgT1MgdGVjaG5vbG9naWVzLCBpbmNsdWRpbmcgTWlyYWdlT1MsIEVybGFuZ09uWGVuLCBPU3Ys IGFuZCBIYWxWTS4gUmVjb2duaXppbmcgdGhhdCBoaWdoLWF2YWlsYWJpbGl0eSBhbmQgc3RhYmls aXR5IGFyZSBjcml0aWNhbCB0byBWRElzIGFuZCBjbG91ZCBkZXBsb3ltZW50czsgdGhlIFhlblNl cnZlciB0ZWFtIGF0IENpdHJpeCBjb250cmlidXRlZCB0aGUgbmV3IGV2ZW50IGNoYW5uZWwgaW1w bGVtZW50YXRpb24gdG8gdGhlIFhlbiBQcm9qZWN0LiBUbyBoZWxwIGVsaW1pbmF0ZSB3b3JrbG9h ZCBsaW1pdGF0aW9ucyBmb3IgdXNlcnMsIHRoaXMgZW5hYmxlcyB0aGUgaHlwZXJ2aXNvciB0byBy dW4gdGhvdXNhbmRzIG9mIGd1ZXN0cyBvbiBhIHNpbmdsZSBwaHlzaWNhbCBtYWNoaW5lLg0KDQpF eHBlcmltZW50YWwgU3VwcG9ydCBmb3IgUFZIIE1vZGUgZm9yIEd1ZXN0DQoNCk9yYWNsZSBoYXMg Y29udHJpYnV0ZWQgYSBmdW5jdGlvbmFsIHByZXZpZXcgb2YgYSBuZXcgdmlydHVhbGl6YXRpb24g bW9kZSBjYWxsZWQgUFZIIGN1cnJlbnRseSBhdmFpbGFibGUgdG8gdmlydHVhbGl6ZWQgZ3Vlc3Rz LiA8aHR0cDovL2Jsb2cueGVuLm9yZy9pbmRleC5waHAvMjAxNC8wMS8zMS9saW51eC0zLTE0LWFu ZC1wdmgvPiBQVkggaXMgYW4gZXh0ZW5zaW9uIHRvIHRoZSBjbGFzc2ljIFhlbiBQcm9qZWN0IFBh cmF2aXJ0dWFsaXphdGlvbiAoUFYpIHRoYXQgdXNlcyB0aGUgaGFyZHdhcmUgdmlydHVhbGl6YXRp b24gZXh0ZW5zaW9ucyBhdmFpbGFibGUgb24gbW9kZXJuIHg4NiBwcm9jZXNzb3JzLiBQVkggdXNl cyBQViBkcml2ZXJzIGZvciBib290IGFuZCBJL08gYW5kIEludGVsIGhhcmR3YXJlIHZpcnR1YWxp emF0aW9uIGV4dGVuc2lvbnMgZm9yIHBhZ2UgdGFibGUgb3BlcmF0aW9ucywgc3lzdGVtIGNhbGxz IGFuZCBvdGhlciBwcml2aWxlZ2VkIG9wZXJhdGlvbnMuIFRoaXMgbm90IG9ubHkgaW1wcm92ZXMg cGVyZm9ybWFuY2UgYW5kIHNlY3VyaXR5LCBidXQgYWxzbyBzaW1wbGlmaWVzIHRoZSBhcmNoaXRl Y3R1cmUgYW5kIFhlbiBQcm9qZWN0IEh5cGVydmlzb3ItTGludXggaW50ZXJmYWNlIHNpZ25pZmlj YW50bHkuDQoNCj8/L3NwYW4+UFZIIGlzIGEgbWFqb3IgZGV2ZWxvcG1lbnQgZm9yIFhlbiBQcm9q ZWN0IHNvZnR3YXJlIG9uIHg4NiBhbmQgaGFzIHRoZSBwb3RlbnRpYWwgdG8gZ3JlYXRseSBzaW1w bGlmeSB0aGUgTGludXggaW50ZXJmYWNlIGluIGR1ZSB0aW1lLCA/PyBzYWlkIEtvbnJhZCBSemVz enV0ZWsgV2lsaywgU29mdHdhcmUgRGV2ZWxvcG1lbnQgTWFuYWdlciBhdCBPcmFjbGUsIGEgWGVu IFByb2plY3QgYWR2aXNvcnkgYm9hcmQgbWVtYmVyLiA/Py9zcGFuPldlIGV4cGVjdCBQVkggdG8g aGF2ZSB0aGUgYmVzdCBjaGFyYWN0ZXJpc3RpY3Mgb2YgYWxsIHZpcnR1YWxpemF0aW9uIG1vZGVz IC0tIGEgc2ltcGxlLCBmYXN0LCBzZWN1cmUgaW50ZXJmYWNlLCB3aXRoIGxvdyBtZW1vcnkgb3Zl cmhlYWQsIHRoYXQgYWxzbyB0YWtlcyBmdWxsIGFkdmFudGFnZSBvZiB0aGUgbGF0ZXN0IGhhcmR3 YXJlLj8/L3NwYW4+DQoNCg0KDQpBZGRpdGlvbmFsIGtleSB1cGRhdGVzIGluY2x1ZGU6DQoNCuWa mei4neiVrSAgICAgQmV0dGVyIHBlcmZvcm1hbmNlIHdpdGggbW9kZXJuIHN0b3JhZ2UgZGV2aWNl cyBhbmQgYmlnIGRhdGEgLS0gSW5kaXJlY3QgZGVzY3JpcHRvcnMgZm9yIGJsb2NrIFBWIHByb3Rv Y29sIChMaW51eCkgYWxsb3cgZWFjaCBpbmRpdmlkdWFsIHJlcXVlc3QgdG8gdHJpcGxlIGluIHNp emUsIGdyZWF0bHkgaW1wcm92aW5nIEkvTyBwZXJmb3JtYW5jZSB3aGVuIHJ1bm5pbmcgb24gZmFz dCBzdG9yYWdlIHRlY2hub2xvZ2llcyBzdWNoIGFzIHNvbGlkLXN0YXRlIGRyaXZlIGFuZCBSQUlE LiBBdmFpbGFibGUgaW4gYW55IGd1ZXN0IHJ1bm5pbmcgTGludXggMy4xMSBvciBoaWdoZXIgKHJl Z2FyZGxlc3Mgb2YgWGVuIFByb2plY3QgdmVyc2lvbikuDQoNCg0KDQrlmpnouJ3ola0gICAgIE1v cmUgcG93ZXJmdWwgZHJpdmVyIGRvbWFpbnMgLS0gRGlzayBkcml2ZXIgZG9tYWlucyBjYW4gbm93 IHVuaWZvcm1seSBydW4gYmxvY2sgc2NyaXB0cyBhbmQgdXNlci1zcGFjZSBiYWNrZW5kcywgc3Vj aCBhcyBxZGlzaywgYnJpbmdpbmcgdGhlbSB1cCB0byBmZWF0dXJlIHBhcml0eSB3aXRoIGRvbWFp biAwLiBUaGlzIG1lYW5zIGhvc3QgYWRtaW5pc3RyYXRvcnMgY2FuIHRha2UgYWR2YW50YWdlIG9m IHRoZSBlbmhhbmNlZCBzZWN1cml0eSwgc2NhbGFiaWxpdHksIGFuZCByb2J1c3RuZXNzIHByb3Zp ZGVkIGJ5IGRyaXZlciBkb21haW5zIHdpdGhvdXQgc2FjcmlmaWNpbmcgdGhlIHdpZGUgYXJyYXkg b2YgZGlzayBjb25maWd1cmF0aW9uIG9wdGlvbnMgcHJvdmlkZWQgYnkgWGVuIGluIGRvbTAuDQoN CuWamei4neiVrSAgICAgTmV3IFNQSUNFIHByb3RvY29sIHN1cHBvcnQgLS0gRnVuY3Rpb25hbGl0 eSBzdWNoIGFzIGNsaXBib2FyZCBzaGFyaW5nIGFuZCBVU0IgcmVkaXJlY3Rpb24gY3JlYXRlcyBh IG11Y2ggcmljaGVyIGNvbm5lY3Rpb24gZm9yIHZpcnR1YWwgZGVza3RvcHMgYW5kIGJldHRlciBn cmFwaGljcyBwZXJmb3JtYW5jZS4NCg0K5ZqZ6Lid6JWtICAgICBFbmhhbmNlZCBkaWFnbm9zdGlj cyBhbmQga2V4ZWMgZGVidWcgc3VwcG9ydCAtLSBXaGVuIGEgY3Jhc2ggaGFwcGVucywgYSBzcGVj aWFsIGtlcm5lbCBpcyBhbGxvd2VkIGltbWVkaWF0ZSB0byBjb2xsZWN0IGluZm9ybWF0aW9uIGFi b3V0IHRoZSByb290IGNhdXNlLCBvZmZlcmluZyBkZXZlbG9wZXJzIGJldHRlciBkaWFnbm9zaXMg YW5kIHJlcGFpciBhYmlsaXRpZXMuDQoNClRoZSA0LjQgcmVsZWFzZSBpcyB0aGUgcmVzdWx0IG9m IGEgYnJvYWQsIGNvbGxhYm9yYXRpdmUgZGV2ZWxvcG1lbnQgZWZmb3J0IHJlcHJlc2VudGluZyBl bmdpbmVlcnMgZnJvbSBtb3JlIHRoYW4gMTMgbGVhZGluZyBoYXJkd2FyZSwgc29mdHdhcmUgYW5k IHNlY3VyaXR5IHZlbmRvcnMuIFRvcCBjb250cmlidXRvcnMgaW5jbHVkZSBBbWF6b24sIEFNRCwg QW5hbG9nIERldmljZXMsIEJyb2FkY29tLCBDaXRyaXgsIEZ1aml0c3UsIEludGVsLCBMaW5hcm8s IE5TQSwgT3JhY2xlLCBTdXNlLCBWZXJpem9uL1RlcnJlbWFyaywgcGx1cyBudW1lcm91cyBpbmRp dmlkdWFsIGFuZCBhY2FkZW1pYyBjb250cmlidXRvcnMuIFRoZSBmcmVlbHkgYXZhaWxhYmxlIGRv d25sb2FkIGNhbiBiZSBmb3VuZCBvbiB0aGUgWGVuUHJvamVjdC5vcmc8aHR0cDovL3hlbnByb2pl Y3Qub3JnLz4gd2Vic2l0ZSAoaW5zZXJ0IHVybCkuDQoNCg0KDQpBYm91dCBYZW4gUHJvamVjdA0K DQpUaGUgWGVuIFByb2plY3Qgc29mdHdhcmUgaXMgYW4gb3BlbiBzb3VyY2UgdmlydHVhbGl6YXRp b24gcGxhdGZvcm0gbGljZW5zZWQgdW5kZXIgdGhlIEdQTHYyIHdpdGggYSBzaW1pbGFyIGdvdmVy bmFuY2Ugc3RydWN0dXJlIHRvIHRoZSBMaW51eCBrZXJuZWwuIERlc2lnbmVkIGZyb20gdGhlIHN0 YXJ0IGZvciBjbG91ZCBjb21wdXRpbmcsIHRoZSBQcm9qZWN0IGhhcyBtb3JlIHRoYW4gYSBkZWNh ZGUgb2YgZGV2ZWxvcG1lbnQgYW5kIGlzIGJlaW5nIHVzZWQgYnkgbW9yZSB0aGFuIDEwIG1pbGxp b24gdXNlcnMuIEEgQ29sbGFib3JhdGl2ZSBQcm9qZWN0IGF0IFRoZSBMaW51eCBGb3VuZGF0aW9u LCB0aGUgWGVuIFByb2plY3QgdGVhbSBpcyBmb2N1c2VkIG9uIGFkdmFuY2luZyB2aXJ0dWFsaXph dGlvbiBpbiBhIG51bWJlciBvZiBkaWZmZXJlbnQgY29tbWVyY2lhbCBhbmQgb3BlbiBzb3VyY2Ug YXBwbGljYXRpb25zIGluY2x1ZGluZyBzZXJ2ZXIgdmlydHVhbGl6YXRpb24sIEluZnJhc3RydWN0 dXJlIGFzIGEgU2VydmljZSAoSWFhUyksIGRlc2t0b3AgdmlydHVhbGl6YXRpb24sIHNlY3VyaXR5 IGFwcGxpY2F0aW9ucywgZW1iZWRkZWQgYW5kIGhhcmR3YXJlIGFwcGxpYW5jZXMuIEl0IGNvdW50 cyBtYW55IGluZHVzdHJ5IGFuZCBvcGVuIHNvdXJjZSBjb21tdW5pdHkgbGVhZGVycyBhbW9uZyBp dHMgbWVtYmVycyBpbmNsdWRpbmc6IEFtYXpvbiBXZWIgU2VydmljZXMsIEFNRCwgQVJNLCBCcm9t aXVtLCBDYWx4ZWRhLCBDQSBUZWNobm9sb2dpZXMsIENpc2NvLCBDaXRyaXgsIEdvb2dsZSwgSW50 ZWwsIE9yYWNsZSwgU2Ftc3VuZyBhbmQgVmVyaXpvbi4gRm9yIG1vcmUgaW5mb3JtYXRpb24gYWJv dXQgdGhlIFhlbiBQcm9qZWN0IGh5cGVydmlzb3IgYW5kIHRvIHBhcnRpY2lwYXRlLCBwbGVhc2Ug dmlzaXRodHRwOi8veGVucHJvamVjdC48aHR0cDovL3hlbnByb2plY3Qub3JnLz5vcmc8aHR0cDov L3hlbnByb2plY3Qub3JnLz4uDQoNCiMjIw0KDQpTYXJhaCBDb253YXkNCg0KVGhlIFhlbiBQcm9q ZWN0DQoNCk1lZGlhIENvbnRhY3QNCg0KcHVibGljaXR5QGxpc3RzLnhlbnByb2plY3Qub3JnPG1h aWx0bzpwdWJsaWNpdHlAbGlzdHMueGVucHJvamVjdC5vcmc+DQoNCg0KT24gTWFyIDYsIDIwMTQs IGF0IDEyOjQ0IFBNLCBXaWxzb24sIE1hdHQgPG1zd0BhbWF6b24uY29tPG1haWx0bzptc3dAYW1h em9uLmNvbT4+IHdyb3RlOg0KDQpNYXJrLCB0aG91Z2h0cz8NCg0KX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX18NCkZyb206IFdpbHNvbiwgTWF0dA0KU2VudDogV2VkbmVzZGF5LCBNYXJj aCAwNSwgMjAxNCAxMDowMSBBTQ0KVG86IEFkdmlzb3J5LWJvYXJkIGRpc2N1c3Npb25zDQpTdWJq ZWN0OiBSRTogW0Fkdmlzb3J5LWJvYXJkXSBYZW4gUHJvamVjdCA0LjQgUmVsZWFzZQ0KDQpJJ2Qg cmF0aGVyIHVzZSAiWGVuIFByb2plY3QgSHlwZXJ2aXNvciIgdGhhbiBpbnRyb2R1Y2UgYW4gYWNy b255bS4gSSB0aGluayBpdCdzIGltcG9ydGFudCB0aGF0ICJYZW4gUHJvamVjdCIgbm90IGJlIHNw bGl0IGZyb20gIkh5cGVydmlzb3IuIg0KDQpUaGlzIHN0aWxsIGRvZXNuJ3QgYWRkcmVzcyBob3cg dGhlIHVtYnJlbGxhIHByb2plY3QgaXMgY2FsbGVkLiBUaGlzIG5ldyByZWxlYXNlIGRvZXNuJ3Qg b25seSBpbmNsdWRlIHRoZSBoeXBlcnZpc29yLCBidXQgYWxzbyB0aGUgYXNzb2NpYXRlZCB0b29s c3RhY2sgYW5kIHV0aWxpdGllcy4gTWF5YmUgd2UncmUgT0sgY2FsbGluZyBhbGwgb2YgdGhhdCB0 aGUgIkh5cGVydmlzb3IsIiBldmVuIGlmIHdlIGlkZW50aWZ5IHRoZSBkZXZlbG9wbWVudCB0ZWFt cyBkaWZmZXJlbnRseS4NCg0KSG93IHNob3VsZCB3ZSByZS1hbGlnbiBhbGwgb2YgdGhlIGJyYW5k aW5nPyBGb3IgZXhhbXBsZTogaHR0cDovL3hlbnByb2plY3Qub3JnL2RldmVsb3BlcnMvdGVhbXMv aHlwZXJ2aXNvci5odG1sDQoNClNob3VsZCB0aGUgbGlua3MgdW5kZXIgIkh5cGVydmlzb3IgRG93 bmxvYWRzIiBiZSAidmVyc2lvbiA0LjMuMSIgaW5zdGVhZCBvZiAiWGVuIDQuMy4xIiB0byByZXNv bHZlIHRoZSB0cmFkZW1hcmsgY29uY2VybnM/DQoNCi0tbXN3DQoNCl9fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fDQpGcm9tOiBhZHZpc29yeS1ib2FyZC1ib3VuY2VzQGxpc3RzLnhlbnBy b2plY3Qub3JnPG1haWx0bzphZHZpc29yeS1ib2FyZC1ib3VuY2VzQGxpc3RzLnhlbnByb2plY3Qu b3JnPiBbYWR2aXNvcnktYm9hcmQtYm91bmNlc0BsaXN0cy54ZW5wcm9qZWN0Lm9yZzxtYWlsdG86 YWR2aXNvcnktYm9hcmQtYm91bmNlc0BsaXN0cy54ZW5wcm9qZWN0Lm9yZz5dIG9uIGJlaGFsZiBv ZiBTYXJhaCBDb253YXkgW3Njb253YXlAbGludXhmb3VuZGF0aW9uLm9yZzxtYWlsdG86c2Nvbndh eUBsaW51eGZvdW5kYXRpb24ub3JnPl0NClNlbnQ6IFdlZG5lc2RheSwgTWFyY2ggMDUsIDIwMTQg OTozMyBBTQ0KVG86IEFkdmlzb3J5LWJvYXJkIGRpc2N1c3Npb25zDQpTdWJqZWN0OiBSZTogW0Fk dmlzb3J5LWJvYXJkXSBYZW4gUHJvamVjdCA0LjQgUmVsZWFzZQ0KDQpNYXJrIGV0IGFsbCwNCg0K SSBhZ3JlZSB0aGF0IHVzaW5nIFhlbiBQcm9qZWN0IGlzIGEgbW91dGhmdWwuIEdpdmVuIHRoYXQg dGhlcmUgaXMgY2xvc2Ugb3ZlcmxhcCBhbmQgb2NjYXNpb25hbCBicmFuZGluZyBjb25mdXNpb24g d2l0aCBDaXRyaXggcHJvZHVjdHMsIGlmIHdlIGFkZCBhbm90aGVyIG5ldyB0ZXJtIG9yIGFjcm9u eW0gaW50byB0aGUgbWl4LCB3ZSdsbCB3YW50IHRvIGJlIGRpbGlnZW50IGFib3V0IGJlaW5nIGNv bnNpc3RlbnQgaW4gYmxvZ3MsIHByZXNlbnRhdGlvbnMsIG5ld3MgcmVsZWFzZXMsIHdlYiBzaXRl IGNvcHksIGN1c3RvbWVyIHRlc3RpbW9uaWFscyBldGMuDQoNCkZvciB0aGUgc2FrZSBvZiBzaW1w bGljaXR5LCBob3cgYWJvdXQgdXNpbmcgWFBIIC0gYWxsIHVwcGVyY2FzZSAtIG9uIHNlY29uZCBy ZWZlcmVuY2U/IFRob3VnaHRzPw0KDQpUaGFua3MsDQoNCg0KDQoNCg0KDQpPbiBXZWQsIE1hciA1 LCAyMDE0IGF0IDk6MTggQU0sIE1hcmsgSGlua2xlIDxNYXJrLkhpbmtsZUBjaXRyaXguY29tPG1h aWx0bzpNYXJrLkhpbmtsZUBjaXRyaXguY29tPj4gd3JvdGU6DQpIb3cgYWJvdXQgdGhpcyBjb252 ZW50aW9uIG9ubHkgc2F5IFhlbiBQcm9qZWN0IGFuZCBYZW4gUHJvamVjdCBoeXBlcnZpc29yIG9u Y2UgdGhlbi4gVXNlIHRoZSBhYmJyZXZpYXRpb24gWFBoIHRocm91Z2hvdXQgdGhlIHJlbGVhc2Uu IEp1c3Qgc25pcHBpbmcgTWF0dD8/IGV4YW1wbGUgdG8gbWFrZSB0aGUgcG9pbnQuIEkgd291bGQg Z3Vlc3MgdGhhdCB0aGUgYXBwcm9wcmlhdGUgY2FwaXRhbGl6YXRpb24gd291bGQgYmUgbG93ZXIg Y2FzZSBmb3IgdGhlIHdvcmQgaHlwZXJ2aXNvci4NCg0KTWFyaw0KDQoNClRoZSBYZW4gUHJvamVj dCwgYSBDb2xsYWJvcmF0aXZlIFByb2plY3QgaG9zdGVkIGF0IFRoZSBMaW51eCBGb3VuZGF0aW9u LCB0b2RheSBhbm5vdW5jZWQgYXZhaWxhYmlsaXR5IG9mIHRoZSBYZW4gUHJvamVjdCBoeXBlcnZp c29yKFhQaCkgNC40IHdpdGggZW5oYW5jZWQgQVJNIHN1cHBvcnQuDQoNClhQaCA0LjQgZnVydGhl ciBhZHZhbmNlcyB0aGUgUHJvamVjdD8/L3NwYW4+cyBwb3NpdGlvbiBhcyBhIGZhc3QsIHNjYWxh YmxlLCBzZWN1cmUgdmlydHVhbGl6YXRpb24gZW5naW5lIGZvciB0aGUgaW5kdXN0cnk/Py9zcGFu PnMgYnJvYWRlc3QgcmFuZ2Ugb2Ygc2VydmVyLCBQQyBjaGlwc2V0cyBhbmQgbmV4dC1nZW5lcmF0 aW9uIGxvdy1wb3dlciBzeXN0ZW1zIG9uIGNoaXBzIChTb0MpLg0KDQpPbiBNYXIgNCwgMjAxNCwg YXQgNDowMSBQTSwgV2lsc29uLCBNYXR0IDxtc3dAYW1hem9uLmNvbTxtYWlsdG86bXN3QGFtYXpv bi5jb20+PiB3cm90ZToNCg0KVGhlICJYZW4gUHJvamVjdCIgdGVybWlub2xvZ3kgbWFrZXMgdGhl IG1lc3NhZ2UgZXh0cmVtZWx5IGN1bWJlcnNvbWUuDQoNCg0KVGhlIFhlbiBQcm9qZWN0LCBhIENv bGxhYm9yYXRpdmUgUHJvamVjdCBob3N0ZWQgYXQgVGhlIExpbnV4IEZvdW5kYXRpb24sIHRvZGF5 IGFubm91bmNlZCBhdmFpbGFiaWxpdHkgb2YgdGhlIFhlbiBQcm9qZWN0IDQuNCBIeXBlcnZpc29y IHdpdGggZW5oYW5jZWQgWGVuIFByb2plY3Qtb24tQVJNIHN1cHBvcnQuDQoNCldoeSBub3QganVz dCBzYXkgImVuaGFuY2VkIEFSTSBzdXBwb3J0Ij8gV2Ugc2hvdWxkIGFkb3B0IHNvbWUgdXNhZ2Ug Z3VpZGVsaW5lcyBmb3Igc3ViLXByb2plY3QgYnJhbmRpbmcuIFdlIHNob3VsZG4ndCBpbnNlcnQg d29yZHMvbnVtYmVycyBiZXR3ZWVuICJYZW4gUHJvamVjdCIgYW5kIGEgc3ViLXByb2plY3QgbmFt ZS4NCg0KVGhlIFhlbiBQcm9qZWN0LCBhIENvbGxhYm9yYXRpdmUgUHJvamVjdCBob3N0ZWQgYXQg VGhlIExpbnV4IEZvdW5kYXRpb24sIHRvZGF5IGFubm91bmNlZCB2ZXJzaW9uIDQuNCBvZiB0aGUg WGVuIFByb2plY3QgSHlwZXJ2aXNvciB3aXRoIGVuaGFuY2VkIEFSTSBzdXBwb3J0Lg0KDQpvcg0K VGhlIFhlbiBQcm9qZWN0LCBhIENvbGxhYm9yYXRpdmUgUHJvamVjdCBob3N0ZWQgYXQgVGhlIExp bnV4IEZvdW5kYXRpb24sIHRvZGF5IGFubm91bmNlZCB0aGUgcmVsZWFzZSBvZiBYZW4gUHJvamVj dCBIeXBlcnZpc29yIDQuNCB3aXRoIGVuaGFuY2VkIEFSTSBzdXBwb3J0Lg0KDQpMYXRlciBvbiwg dGhpcyByZWxlYXNlIGlzIGNhbGxlZCAiWGVuIFByb2plY3QgNC40Ig0KDQoNClRoZSBYZW4gUHJv amVjdCA0LjQgcmVsZWFzZSBmdXJ0aGVyIGFkdmFuY2VzIHRoZSBQcm9qZWN0Pz8vc3Bhbj5zIHBv c2l0aW9uIGFzIGEgZmFzdCwgc2NhbGFibGUsIHNlY3VyZSB2aXJ0dWFsaXphdGlvbiBlbmdpbmUg Zm9yIHRoZSBpbmR1c3RyeT8/L3NwYW4+cyBicm9hZGVzdCByYW5nZSBvZiBzZXJ2ZXIsIFBDIGNo aXBzZXRzIGFuZCBuZXh0LWdlbmVyYXRpb24gbG93LXBvd2VyIHN5c3RlbXMgb24gY2hpcHMgKFNv QykuDQoNClRoYXQgZG9lc24ndCBmbG93IHdlbGwuIEhvdyBhcmUgd2UgcmVsZWFzaW5nIHZlcnNp b24gNC40IG9mIGEgcHJvamVjdD8gRG8gd2Ugd2FudCB0byBjYWxsIHRoZSBvdmVyYWxsIHJlbGVh c2UgIlhlbiBQcm9qZWN0IEFyY2hpdGVjdHVyZSA0LjQiPyBPciBkbyB3ZSBuZWVkIHRvIGNvbWUg dXAgd2l0aCBzb21lIG90aGVyIHByb2plY3QgYnJhbmRpbmc/DQoNCi0tbXN3DQoNCl9fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fDQpGcm9tOiBhZHZpc29yeS1ib2FyZC1ib3VuY2VzQGxp c3RzLnhlbnByb2plY3Qub3JnPG1haWx0bzphZHZpc29yeS1ib2FyZC1ib3VuY2VzQGxpc3RzLnhl bnByb2plY3Qub3JnPiBbYWR2aXNvcnktYm9hcmQtYm91bmNlc0BsaXN0cy54ZW5wcm9qZWN0Lm9y ZzxtYWlsdG86YWR2aXNvcnktYm9hcmQtYm91bmNlc0BsaXN0cy54ZW5wcm9qZWN0Lm9yZz5dIG9u IGJlaGFsZiBvZiBTYXJhaCBDb253YXkgW3Njb253YXlAbGludXhmb3VuZGF0aW9uLm9yZzxtYWls dG86c2NvbndheUBsaW51eGZvdW5kYXRpb24ub3JnPl0NClNlbnQ6IFR1ZXNkYXksIE1hcmNoIDA0 LCAyMDE0IDEyOjE2IFBNDQoNClRvOiBhZHZpc29yeS1ib2FyZEBsaXN0cy54ZW5wcm9qZWN0Lm9y ZzxtYWlsdG86YWR2aXNvcnktYm9hcmRAbGlzdHMueGVucHJvamVjdC5vcmc+DQpTdWJqZWN0OiBb QWR2aXNvcnktYm9hcmRdIFhlbiBQcm9qZWN0IDQuNCBSZWxlYXNlDQoNCkhpIGV2ZXJ5b25lLg0K DQpBdHRhY2hlZCBpcyB0aGUgWGVuIFByb2plY3QgNC40IG5ld3MgcmVsZWFzZSBhbm5vdWNlbWVu dCB0aGF0IHdpbGwgZ28gb3V0IGF0IDggYS5tLiBFVCBvbiBNb25kYXksIE1hcmNoIDEwLg0KDQpJ ZiB5b3UgaGF2ZSBhbnkgYWRkaXRpb25hbCBjb21tZW50cyBvciBlZGl0cywgcGxlYXNlIGdldCBi YWNrIHRvIG1lIGJ5IFRodXJzZGF5IG1vcm5pbmcgYXQgdGhlIGxhdGVzdC4NCg0KVGhhbmtzLA0K DQoNCi0tDQpTYXJhaCBDb253YXkNClBSIE1hbmFnZXINClRoZSBMaW51eCBGb3VuZGF0aW9uDQpz Y29ud2F5QGxpbnV4Zm91bmRhdGlvbi5vcmc8bWFpbHRvOnNjb253YXlAbGludXhmb3VuZGF0aW9u Lm9yZz4NCig5NzgpIDU3OC01MzAwPHRlbDolMjg5NzglMjklMjA1NzgtNTMwMD4gIENlbGwNClNr eXBlOiAgc2FyYWguay5jb253YXkNCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fDQpBZHZpc29yeS1ib2FyZCBtYWlsaW5nIGxpc3QNCkFkdmlzb3J5LWJvYXJk QGxpc3RzLnhlbnByb2plY3Qub3JnPG1haWx0bzpBZHZpc29yeS1ib2FyZEBsaXN0cy54ZW5wcm9q ZWN0Lm9yZz4NCmh0dHA6Ly9saXN0cy54ZW5wcm9qZWN0Lm9yZy9jZ2ktYmluL21haWxtYW4vbGlz dGluZm8vYWR2aXNvcnktYm9hcmQNCg0KDQpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fXw0KQWR2aXNvcnktYm9hcmQgbWFpbGluZyBsaXN0DQpBZHZpc29yeS1i b2FyZEBsaXN0cy54ZW5wcm9qZWN0Lm9yZzxtYWlsdG86QWR2aXNvcnktYm9hcmRAbGlzdHMueGVu cHJvamVjdC5vcmc+DQpodHRwOi8vbGlzdHMueGVucHJvamVjdC5vcmcvY2dpLWJpbi9tYWlsbWFu L2xpc3RpbmZvL2Fkdmlzb3J5LWJvYXJkDQoNCg0KDQoNCi0tDQpTYXJhaCBDb253YXkNClBSIE1h bmFnZXINClRoZSBMaW51eCBGb3VuZGF0aW9uDQpzY29ud2F5QGxpbnV4Zm91bmRhdGlvbi5vcmc8 bWFpbHRvOnNjb253YXlAbGludXhmb3VuZGF0aW9uLm9yZz4NCig5NzgpIDU3OC01MzAwPHRlbDol Mjg5NzglMjklMjA1NzgtNTMwMD4gIENlbGwNClNreXBlOiAgc2FyYWguay5jb253YXkNCl9fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fDQpBZHZpc29yeS1ib2Fy ZCBtYWlsaW5nIGxpc3QNCkFkdmlzb3J5LWJvYXJkQGxpc3RzLnhlbnByb2plY3Qub3JnPG1haWx0 bzpBZHZpc29yeS1ib2FyZEBsaXN0cy54ZW5wcm9qZWN0Lm9yZz4NCmh0dHA6Ly9saXN0cy54ZW5w cm9qZWN0Lm9yZy9jZ2ktYmluL21haWxtYW4vbGlzdGluZm8vYWR2aXNvcnktYm9hcmQNCg0KDQot LSBJTVBPUlRBTlQgTk9USUNFOiBUaGUgY29udGVudHMgb2YgdGhpcyBlbWFpbCBhbmQgYW55IGF0 dGFjaG1lbnRzIGFyZSBjb25maWRlbnRpYWwgYW5kIG1heSBhbHNvIGJlIHByaXZpbGVnZWQuIElm IHlvdSBhcmUgbm90IHRoZSBpbnRlbmRlZCByZWNpcGllbnQsIHBsZWFzZSBub3RpZnkgdGhlIHNl bmRlciBpbW1lZGlhdGVseSBhbmQgZG8gbm90IGRpc2Nsb3NlIHRoZSBjb250ZW50cyB0byBhbnkg b3RoZXIgcGVyc29uLCB1c2UgaXQgZm9yIGFueSBwdXJwb3NlLCBvciBzdG9yZSBvciBjb3B5IHRo ZSBpbmZvcm1hdGlvbiBpbiBhbnkgbWVkaXVtLiBUaGFuayB5b3UuDQoNCkFSTSBMaW1pdGVkLCBS ZWdpc3RlcmVkIG9mZmljZSAxMTAgRnVsYm91cm4gUm9hZCwgQ2FtYnJpZGdlIENCMSA5TkosIFJl Z2lzdGVyZWQgaW4gRW5nbGFuZCAmIFdhbGVzLCBDb21wYW55IE5vOiAyNTU3NTkwDQpBUk0gSG9s ZGluZ3MgcGxjLCBSZWdpc3RlcmVkIG9mZmljZSAxMTAgRnVsYm91cm4gUm9hZCwgQ2FtYnJpZGdl IENCMSA5TkosIFJlZ2lzdGVyZWQgaW4gRW5nbGFuZCAmIFdhbGVzLCBDb21wYW55IE5vOiAyNTQ4 NzgyDQoNCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fDQpB ZHZpc29yeS1ib2FyZCBtYWlsaW5nIGxpc3QNCkFkdmlzb3J5LWJvYXJkQGxpc3RzLnhlbnByb2pl Y3Qub3JnPG1haWx0bzpBZHZpc29yeS1ib2FyZEBsaXN0cy54ZW5wcm9qZWN0Lm9yZz4NCmh0dHA6 Ly9saXN0cy54ZW5wcm9qZWN0Lm9yZy9jZ2ktYmluL21haWxtYW4vbGlzdGluZm8vYWR2aXNvcnkt Ym9hcmQNCg0KDQoNCg0KLS0NClNhcmFoIENvbndheQ0KUFIgTWFuYWdlcg0KVGhlIExpbnV4IEZv dW5kYXRpb24NCnNjb253YXlAbGludXhmb3VuZGF0aW9uLm9yZzxtYWlsdG86c2NvbndheUBsaW51 eGZvdW5kYXRpb24ub3JnPg0KKDk3OCkgNTc4LTUzMDAgIENlbGwNClNreXBlOiAgc2FyYWguay5j b253YXkNCjxYZW5Qcm9qZWN0VXBkYXRlNC40My42LjIwMTQoMilkb2N4Pl9fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fDQpBZHZpc29yeS1ib2FyZCBtYWlsaW5n IGxpc3QNCkFkdmlzb3J5LWJvYXJkQGxpc3RzLnhlbnByb2plY3Qub3JnPG1haWx0bzpBZHZpc29y eS1ib2FyZEBsaXN0cy54ZW5wcm9qZWN0Lm9yZz4NCmh0dHA6Ly9saXN0cy54ZW5wcm9qZWN0Lm9y Zy9jZ2ktYmluL21haWxtYW4vbGlzdGluZm8vYWR2aXNvcnktYm9hcmQNCg0KX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18NCkFkdmlzb3J5LWJvYXJkIG1haWxp bmcgbGlzdA0KQWR2aXNvcnktYm9hcmRAbGlzdHMueGVucHJvamVjdC5vcmcNCmh0dHA6Ly9saXN0 cy54ZW5wcm9qZWN0Lm9yZy9jZ2ktYmluL21haWxtYW4vbGlzdGluZm8vYWR2aXNvcnktYm9hcmQN Cg0K --_000_25264475F9F3401FA7E8579896CD2D0Bcitrixcom_ Content-Type: text/html; charset="utf-8" Content-ID: <08DB235C2748254AB4938277B53C27BC@citrix.com> Content-Transfer-Encoding: base64 PGh0bWw+DQo8aGVhZD4NCjxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0i dGV4dC9odG1sOyBjaGFyc2V0PXV0Zi04Ij4NCjwvaGVhZD4NCjxib2R5IHN0eWxlPSJ3b3JkLXdy YXA6IGJyZWFrLXdvcmQ7IC13ZWJraXQtbmJzcC1tb2RlOiBzcGFjZTsgLXdlYmtpdC1saW5lLWJy ZWFrOiBhZnRlci13aGl0ZS1zcGFjZTsiPg0KSSBkb27igJl0IGRpc2FncmVlIHdpdGggTWF0dCB0 aGUgdGV4dCBpcyAmbmJzcDthd2t3YXJkJm5ic3A7cGFydGljdWxhcmx5IGJlY2F1c2Ugb2YgaXTi gJlzIGhpZ2hseSB0ZWNobmljYWwgbmF0dXJlLiBEbyB5b3UgaGF2ZSBhbnkgc3BlY2lmaWMgZmVl ZGJhY2sgZm9yIFNhcmFoIHRvIGluY29ycG9yYXRlLiBJIGRpZG7igJl0IHdhbnQgdG8gcHVzaCB0 b28gaGFyZCBzaW5jZSB0aGUgY2xvY2sgaXMgdGlja2luZyBidXQgd2Ugc2hvdWxkIGdldCB0aGlz IHJpZ2h0LiZuYnNwOw0KPGRpdj48YnI+DQo8L2Rpdj4NCjxkaXY+R29pbmcgZm9yd2FyZCBJIHdv dWxkIGxpa2UgdG8gc3VnZ2VzdCB1c2luZyBPcmFjbGXigJlzIGJ1bGxldGVkIGxpc3QgZm9ybWF0 IGZvciB0aGVpciBwcmVzcyByZWxlYXNlcyBzaW5jZSB0eWluZyB0b2dldGhlciB0aGUgYWN0dWFs IG5ld3MgYW5kIHRlY2ggY29udGVudCBpbnRvIGEgY29tcGVsbGluZyBuYXJyYXRpdmUgaXMgcHJl dHR5IHRvdWdoLiBIZXJlIGFuIGV4YW1wbGUgb2Ygd2hhdCBJ4oCZZCBwcm9wb3NlLiAmbmJzcDs8 L2Rpdj4NCjxkaXY+DQo8ZGl2Pjxicj4NCjwvZGl2Pg0KPGRpdj48YSBocmVmPSJodHRwOi8vd3d3 Lm9yYWNsZS5jb20vdXMvY29ycG9yYXRlL3ByZXNzLzIwMzMzNzYiPmh0dHA6Ly93d3cub3JhY2xl LmNvbS91cy9jb3Jwb3JhdGUvcHJlc3MvMjAzMzM3NjwvYT48YnI+DQo8ZGl2Pjxicj4NCjwvZGl2 Pg0KPGRpdj5SZWdhcmRzLCBNYXJrJm5ic3A7PC9kaXY+DQo8ZGl2Pjxicj4NCjwvZGl2Pg0KPGRp dj48YnI+DQo8ZGl2Pg0KPGRpdj5PbiBNYXIgNywgMjAxNCwgYXQgMTI6MTcgUE0sIFdpbHNvbiwg TWF0dCAmbHQ7bXN3QGFtYXpvbi5jb20mZ3Q7IHdyb3RlOjwvZGl2Pg0KPGJyIGNsYXNzPSJBcHBs ZS1pbnRlcmNoYW5nZS1uZXdsaW5lIj4NCjxibG9ja3F1b3RlIHR5cGU9ImNpdGUiPg0KPGRpdiBm cHN0eWxlPSIxIiBvY3NpPSIwIiBzdHlsZT0iZm9udC1mYW1pbHk6IEhlbHZldGljYTsgZm9udC1z aXplOiAxMnB4OyBmb250LXN0eWxlOiBub3JtYWw7IGZvbnQtdmFyaWFudDogbm9ybWFsOyBmb250 LXdlaWdodDogbm9ybWFsOyBsZXR0ZXItc3BhY2luZzogbm9ybWFsOyBsaW5lLWhlaWdodDogbm9y bWFsOyBvcnBoYW5zOiBhdXRvOyB0ZXh0LWFsaWduOiBzdGFydDsgdGV4dC1pbmRlbnQ6IDBweDsg dGV4dC10cmFuc2Zvcm06IG5vbmU7IHdoaXRlLXNwYWNlOiBub3JtYWw7IHdpZG93czogYXV0bzsg d29yZC1zcGFjaW5nOiAwcHg7IC13ZWJraXQtdGV4dC1zdHJva2Utd2lkdGg6IDBweDsiPg0KPGRp diBzdHlsZT0iZGlyZWN0aW9uOiBsdHI7IGZvbnQtZmFtaWx5OiBWZXJkYW5hOyBmb250LXNpemU6 IDEwcHQ7Ij5JJ20gbm90IHNhdGlzZmllZCB3aXRoIHRoZSBxdWFsaXR5IG9mIHRoaXMgdGV4dCAo dHlwb3MsIGV0Yy4pIGdpdmVuIHRoZSBwbGFuIHRvIHB1dCBpdCBvbiB0aGUgd2lyZSBNb25kYXku IFdlIHN0aWxsIGRvbid0IGhhdmUgYSBzdHJvbmcgbWVzc2FnZSBhbmQgYSBwbGFuIG9uIGhvdyB3 ZSBwbGFuIHRvIGJyYW5kIHRoZSB0ZWNobm9sb2dpZXMNCiB0aGF0IGFyZSBwcm9kdWNlZCBieSB0 aGUgY29tbXVuaXR5Lg0KPGRpdj48YnI+DQo8L2Rpdj4NCjxkaXY+LS1tc3c8L2Rpdj4NCjxkaXY+ PGJyPg0KPC9kaXY+DQo8ZGl2Pg0KPGRpdiBzdHlsZT0iZm9udC1mYW1pbHk6ICdUaW1lcyBOZXcg Um9tYW4nOyBmb250LXNpemU6IDE2cHg7Ij4NCjxociB0YWJpbmRleD0iLTEiPg0KPGRpdiBpZD0i ZGl2UnBGMzQ0NzQiIHN0eWxlPSJkaXJlY3Rpb246IGx0cjsiPjxmb250IGZhY2U9IlRhaG9tYSIg c2l6ZT0iMiI+PGI+RnJvbTo8L2I+PHNwYW4gY2xhc3M9IkFwcGxlLWNvbnZlcnRlZC1zcGFjZSI+ Jm5ic3A7PC9zcGFuPmFkdmlzb3J5LWJvYXJkLWJvdW5jZXNAbGlzdHMueGVucHJvamVjdC5vcmcg W2Fkdmlzb3J5LWJvYXJkLWJvdW5jZXNAbGlzdHMueGVucHJvamVjdC5vcmddIG9uIGJlaGFsZiBv ZiBNYXJrIEhpbmtsZSBbTWFyay5IaW5rbGVAY2l0cml4LmNvbV08YnI+DQo8Yj5TZW50OjwvYj48 c3BhbiBjbGFzcz0iQXBwbGUtY29udmVydGVkLXNwYWNlIj4mbmJzcDs8L3NwYW4+RnJpZGF5LCBN YXJjaCAwNywgMjAxNCA5OjA0IEFNPGJyPg0KPGI+VG86PC9iPjxzcGFuIGNsYXNzPSJBcHBsZS1j b252ZXJ0ZWQtc3BhY2UiPiZuYnNwOzwvc3Bhbj5BZHZpc29yeS1ib2FyZCBkaXNjdXNzaW9uczxi cj4NCjxiPkNjOjwvYj48c3BhbiBjbGFzcz0iQXBwbGUtY29udmVydGVkLXNwYWNlIj4mbmJzcDs8 L3NwYW4+SmVubmlmZXIgQ2xvZXI8YnI+DQo8Yj5TdWJqZWN0OjwvYj48c3BhbiBjbGFzcz0iQXBw bGUtY29udmVydGVkLXNwYWNlIj4mbmJzcDs8L3NwYW4+UmU6IFtBZHZpc29yeS1ib2FyZF0gWGVu IFByb2plY3QgNC40IFJlbGVhc2U8YnI+DQo8L2ZvbnQ+PGJyPg0KPC9kaXY+DQo8ZGl2PjwvZGl2 Pg0KPGRpdj4NCjxkaXYgc3R5bGU9IndvcmQtd3JhcDogYnJlYWstd29yZDsiPlNhcmFoLCZuYnNw Ow0KPGRpdj48YnI+DQo8L2Rpdj4NCjxkaXY+QnJhbmRpbmcgc2VlbXMgdG8gYmUgYXBwbGllZCBh cHByb3ByaWF0ZWx5IHRob3VnaCBJIHRoaW5rIHRoZXJlIHdlcmUgYSBjb3VwbGUgb2Ygc3BlbGxp bmcgaXNzdWVzIEkgY2F1Z2h0LiBBdHRhY2hlZCBpcyBmaW5lIGJ5IG1lIHRob3VnaCB0aGUgYnJh bmRpbmcgYW5kIGZsb3cgaXMgc3RpbGwgYSBiaXQgY2hhbGxlbmdpbmcuJm5ic3A7PC9kaXY+DQo8 ZGl2Pjxicj4NCjwvZGl2Pg0KPGRpdj5NYXJrJm5ic3A7PC9kaXY+DQo8ZGl2Pjxicj4NCjwvZGl2 Pg0KPGRpdj48L2Rpdj4NCjwvZGl2Pg0KPGRpdiBzdHlsZT0id29yZC13cmFwOiBicmVhay13b3Jk OyI+DQo8ZGl2PjwvZGl2Pg0KPGRpdj48YnI+DQo8L2Rpdj4NCjxkaXY+DQo8ZGl2Pg0KPGRpdj5P biBNYXIgNywgMjAxNCwgYXQgMTA6MTMgQU0sIFNhcmFoIENvbndheSAmbHQ7PGEgaHJlZj0ibWFp bHRvOnNjb253YXlAbGludXhmb3VuZGF0aW9uLm9yZyIgdGFyZ2V0PSJfYmxhbmsiPnNjb253YXlA bGludXhmb3VuZGF0aW9uLm9yZzwvYT4mZ3Q7IHdyb3RlOjwvZGl2Pg0KPGJyIGNsYXNzPSJ4X0Fw cGxlLWludGVyY2hhbmdlLW5ld2xpbmUiPg0KPGJsb2NrcXVvdGUgdHlwZT0iY2l0ZSI+DQo8ZGl2 IGRpcj0ibHRyIj5IaSBldmVyeW9uZS4NCjxkaXY+PGJyPg0KPC9kaXY+DQo8ZGl2PkkndmUgaW5j b3Jwb3JhdGVkIGV2ZXJ5b25lJ3MgZWRpdHMuIEkgdHJpZWQgdG8gcmVjb25jaWxlIHRoZSBUTS1y ZWxhdGVkIGlzc3VlcyBvZiBicmFuZCBjb25mdXNpb24gYW5kIGZsb3cgYXMgYmVzdCBJIGNvdWxk LiBBcyB5b3UgY2FuIGltYWdpbmUsIEkgZ290IHZhcnlpbmcgZWRpdHMsIHdoaWNoIHN0YXJ0ZWQg dG8gY29uZmxpY3Qgd2l0aCBvbmUgYW5vdGhlci48L2Rpdj4NCjxkaXY+PGJyPg0KPC9kaXY+DQo8 ZGl2PlRoaXMgd291bGQgYmVuZWZpdCBmcm9tIGFub3RoZXIgVE0gcmV2aWV3L2ZpbmFsIGFwcHJv dmFsLiBDYW4gc29tZW9uZSBzdGVwIHVwIHRvIGRvIHRoaXMgYW5kIG1ha2UgYSBmaW5hbCBjYWxs PyZuYnNwOzwvZGl2Pg0KPGRpdj48YnI+DQo8L2Rpdj4NCjxkaXY+TWlrZSBELiwgQ2l0cml4IGlz IG9uIHRoZSBmdWxsIEFCIGVtYWlsIGxpc3Qgc28gdGhleSd2ZSBiZWVuIGludm9sdmVkIGluIHJl dmlld3MuJm5ic3A7PC9kaXY+DQo8ZGl2Pjxicj4NCjwvZGl2Pg0KPGRpdj5QbGVhc2UgYWR2aXNl IHNvb25lc3QuJm5ic3A7PC9kaXY+DQo8ZGl2Pjxicj4NCjwvZGl2Pg0KPGRpdj5UaGFua3MsPC9k aXY+DQo8ZGl2Pjxicj4NCjwvZGl2Pg0KPGRpdj48YnI+DQo8L2Rpdj4NCjwvZGl2Pg0KPGRpdiBj bGFzcz0ieF9nbWFpbF9leHRyYSI+PGJyPg0KPGJyPg0KPGRpdiBjbGFzcz0ieF9nbWFpbF9xdW90 ZSI+T24gRnJpLCBNYXIgNywgMjAxNCBhdCA4OjEzIEFNLCBSaWNoYXJkIFBoZWxhbjxzcGFuIGNs YXNzPSJBcHBsZS1jb252ZXJ0ZWQtc3BhY2UiPiZuYnNwOzwvc3Bhbj48c3BhbiBkaXI9Imx0ciI+ Jmx0OzxhIGhyZWY9Im1haWx0bzpSaWNoYXJkLlBoZWxhbkBhcm0uY29tIiB0YXJnZXQ9Il9ibGFu ayI+UmljaGFyZC5QaGVsYW5AYXJtLmNvbTwvYT4mZ3Q7PC9zcGFuPjxzcGFuIGNsYXNzPSJBcHBs ZS1jb252ZXJ0ZWQtc3BhY2UiPiZuYnNwOzwvc3Bhbj53cm90ZTo8YnI+DQo8YmxvY2txdW90ZSBj bGFzcz0ieF9nbWFpbF9xdW90ZSIgc3R5bGU9Im1hcmdpbjogMHB4IDBweCAwcHggMC44ZXg7IGJv cmRlci1sZWZ0LXdpZHRoOiAxcHg7IGJvcmRlci1sZWZ0LWNvbG9yOiByZ2IoMjA0LCAyMDQsIDIw NCk7IGJvcmRlci1sZWZ0LXN0eWxlOiBzb2xpZDsgcGFkZGluZy1sZWZ0OiAxZXg7Ij4NCjxkaXYg c3R5bGU9ImZvbnQtc2l6ZTogMTRweDsgZm9udC1mYW1pbHk6IENhbGlicmksIHNhbnMtc2VyaWY7 IHdvcmQtd3JhcDogYnJlYWstd29yZDsiPg0KPGRpdj5IaSw8L2Rpdj4NCjxkaXY+PGJyPg0KPC9k aXY+DQo8ZGl2PkkgYWdyZWUgd2l0aCBNYXJrIGFzIHRoZSBjdXJyZW50IHByZXNzIHJlbGVhc2Ug aXMgaGlnaGxpZ2h0aW5nIGlzc3VlcyB0aGF0IHNlZW0gdG8gbWFrZSB0aGUgYXJ0aWN1bGF0aW9u IG9mIGJyYW5kIGFuZCBicmFuZCB2YWx1ZXMgbW9yZSBjdW1iZXJzb21lIHRoYW4gaXMgZGVzaXJh YmxlLjwvZGl2Pg0KPGRpdj48YnI+DQo8L2Rpdj4NCjxkaXY+SSdtIGhhcHB5IHRvIGdvIHdpdGgg dGhlIHByb3Bvc2VkIGNoYW5nZXMgZm9yIHRoZSByZWFzb25zIHN0YXRlZC48L2Rpdj4NCjxkaXY+ PGJyPg0KPC9kaXY+DQo8ZGl2Pk9uZSBtaW5vciBwb2ludCwgSSdkIHByZWZlciAmcXVvdDs/5ZCB eXN0ZW0gb24gQ2hpcCAoU29DKSBkZXZpY2VzLiZxdW90OywgdHdvIHNldHMgb2YgcGx1cmFscyBt YWtlIGl0IHVuY2xlYXIgaG93IG1hbnkgc3lzdGVtcyBhcmUgb24gZWFjaCBjaGlwIGFuZCB0aGUg cGx1cmFscyBnZXQgc3VibWVyZ2VkIGludG8gdGhlIGFjcm9ueW07IGNvbW1vbiB1c2FnZSBzZWVt cyB0byBiZSBTb0NzLjwvZGl2Pg0KPGRpdj48YnI+DQo8L2Rpdj4NCjxkaXY+VGhhbmtzLDwvZGl2 Pg0KPGRpdj48YnI+DQo8L2Rpdj4NCjxkaXY+PHNwYW4gc3R5bGU9IndoaXRlLXNwYWNlOiBwcmUt d3JhcDsiPjwvc3Bhbj5SaWNoYXJkLjwvZGl2Pg0KPGRpdj48YnI+DQo8L2Rpdj4NCjxzcGFuPg0K PGRpdiBzdHlsZT0iYm9yZGVyLXdpZHRoOiAxcHQgbWVkaXVtIG1lZGl1bTsgYm9yZGVyLXN0eWxl OiBzb2xpZCBub25lIG5vbmU7IHBhZGRpbmc6IDNwdCAwaW4gMGluOyB0ZXh0LWFsaWduOiBsZWZ0 OyBmb250LXNpemU6IDExcHQ7IGZvbnQtZmFtaWx5OiBDYWxpYnJpOyBib3JkZXItdG9wLWNvbG9y OiByZ2IoMTgxLCAxOTYsIDIyMyk7Ij4NCjxzcGFuIHN0eWxlPSJmb250LXdlaWdodDogYm9sZDsi PkZyb206PHNwYW4gY2xhc3M9IkFwcGxlLWNvbnZlcnRlZC1zcGFjZSI+Jm5ic3A7PC9zcGFuPjwv c3Bhbj5NYXJrIEhpbmtsZSAmbHQ7PGEgaHJlZj0ibWFpbHRvOk1hcmsuSGlua2xlQGNpdHJpeC5j b20iIHRhcmdldD0iX2JsYW5rIj5NYXJrLkhpbmtsZUBjaXRyaXguY29tPC9hPiZndDs8YnI+DQo8 c3BhbiBzdHlsZT0iZm9udC13ZWlnaHQ6IGJvbGQ7Ij5SZXBseS1Ubzo8c3BhbiBjbGFzcz0iQXBw bGUtY29udmVydGVkLXNwYWNlIj4mbmJzcDs8L3NwYW4+PC9zcGFuPkFkdmlzb3J5LWJvYXJkIGRp c2N1c3Npb25zICZsdDs8YSBocmVmPSJtYWlsdG86YWR2aXNvcnktYm9hcmRAbGlzdHMueGVucHJv amVjdC5vcmciIHRhcmdldD0iX2JsYW5rIj5hZHZpc29yeS1ib2FyZEBsaXN0cy54ZW5wcm9qZWN0 Lm9yZzwvYT4mZ3Q7PGJyPg0KPHNwYW4gc3R5bGU9ImZvbnQtd2VpZ2h0OiBib2xkOyI+RGF0ZTo8 c3BhbiBjbGFzcz0iQXBwbGUtY29udmVydGVkLXNwYWNlIj4mbmJzcDs8L3NwYW4+PC9zcGFuPkZy aWRheSwgNyBNYXJjaCAyMDE0IDA1OjMyPGJyPg0KPHNwYW4gc3R5bGU9ImZvbnQtd2VpZ2h0OiBi b2xkOyI+VG86PHNwYW4gY2xhc3M9IkFwcGxlLWNvbnZlcnRlZC1zcGFjZSI+Jm5ic3A7PC9zcGFu Pjwvc3Bhbj5BZHZpc29yeS1ib2FyZCBkaXNjdXNzaW9ucyAmbHQ7PGEgaHJlZj0ibWFpbHRvOmFk dmlzb3J5LWJvYXJkQGxpc3RzLnhlbnByb2plY3Qub3JnIiB0YXJnZXQ9Il9ibGFuayI+YWR2aXNv cnktYm9hcmRAbGlzdHMueGVucHJvamVjdC5vcmc8L2E+Jmd0Ow0KPGRpdiBjbGFzcz0iIj48YnI+ DQo8c3BhbiBzdHlsZT0iZm9udC13ZWlnaHQ6IGJvbGQ7Ij5TdWJqZWN0OjxzcGFuIGNsYXNzPSJB cHBsZS1jb252ZXJ0ZWQtc3BhY2UiPiZuYnNwOzwvc3Bhbj48L3NwYW4+UmU6IFtBZHZpc29yeS1i b2FyZF0gWGVuIFByb2plY3QgNC40IFJlbGVhc2U8YnI+DQo8L2Rpdj4NCjwvZGl2Pg0KPGRpdj48 YnI+DQo8L2Rpdj4NCjxibG9ja3F1b3RlIHN0eWxlPSJib3JkZXItbGVmdC1jb2xvcjogcmdiKDE4 MSwgMTk2LCAyMjMpOyBib3JkZXItbGVmdC13aWR0aDogNXB4OyBib3JkZXItbGVmdC1zdHlsZTog c29saWQ7IHBhZGRpbmc6IDBweCAwcHggMHB4IDVweDsgbWFyZ2luOiAwcHggMHB4IDBweCA1cHg7 Ij4NCjxkaXYgc3R5bGU9IndvcmQtd3JhcDogYnJlYWstd29yZDsiPk15IGFwb2xvZ2llcyBmb3Ig dGhlIHNsb3cgcmVwbHkgSSB3YXMgc3R1Y2sgb24gdGhlIHJvYWQgYW5kIGNvdWxkbj8/IHJlYWQg dGhlIHJlbGVhc2Ugb24gbXkgcGhvbmUgdG8gZm9ybXVsYXRlIGEgcHJvcGVyIHJlc3BvbnNlLiBJ IHNob3VsZCBtb3ZlIHRvIGEgaGlnaGx5IGVsYXN0aWMgWGVuIFByb2plY3QtcG93ZXJlZCBjbG91 ZCB0aGF0IGFsbG93cyBtZSB0byBhdXRvc2NhbGUgOykNCiAoc29ycnkgYmFkIGNsb3VkIGpva2Up LiZuYnNwOw0KPGRpdj48YnI+DQo8L2Rpdj4NCjxkaXY+SSBhbSBmaW5lIHdpdGhvdXQgZG9pbmcg dGhlIGFjcm9ueW0gYW5kIEkgdGhpbmsgdGhlIHJlYWxpZ25pbmcgYW5kIGJyYW5kaW5nIGRpc2N1 c3Npb24gc2hvdWxkIGJlIGhhZC4gST8/IGxpa2UgdG8gaGF2ZSB0aGF0IGRpc2N1c3Npb24gZHVy aW5nIG91ciBuZXh0IGJvYXJkIG1lZXRpbmcuIEdpdmVuIHRpbWUgaXMgb2YgdGhlIGVzc2VuY2Ug SSB0aGluayB3ZSBzaG91bGQganVzdCB1cGRhdGUgdGhlIGxpbmtzIHRvIHZlcnNpb24gdmVyc3Vz DQogWGVuIDQuMy4xLiZuYnNwOzwvZGl2Pg0KPGRpdj48YnI+DQo8L2Rpdj4NCjxkaXY+QWxzbyBJ IHRvb2sgYSBzaG90IGF0IHRoZSB3b3JkaW5nIG9mIHRoZSBwcmVzcyByZWxlYXNlLiBJdD8/IHBy b2JhYmx5IG5vdCBwZXJmZWN0IGJ1dCBtYWtlcyBpdCByZWFkIGEgYml0IGJldHRlci4gQXR0YWNo ZWQgYXJlIG15IHByb3Bvc2VkIGVkaXRzLiBTYXJhaCwgSSBzZW50IHlvdSB0aGUgd29yZCBkb2Mg d2l0aCB0cmFjayBjaGFuZ2VzIGFzc3VtaW5nIHdlIGhhdmUgc29tZSBlZGl0cyB0byBhZ3JlZSBv bi4mbmJzcDs8L2Rpdj4NCjxkaXY+PGJyPg0KPC9kaXY+DQo8ZGl2Pjxicj4NCjwvZGl2Pg0KPGRp dj5SZWdhcmRzLCBNYXJrJm5ic3A7PC9kaXY+DQo8ZGl2Pjxicj4NCjwvZGl2Pg0KPGRpdj4NCjxk aXYgY2xhc3M9IiI+DQo8cCBhbGlnbj0iY2VudGVyIiBzdHlsZT0ibWFyZ2luLWJvdHRvbTogMTFw dDsgdGV4dC1hbGlnbjogY2VudGVyOyI+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZTogMTJwdDsgZm9u dC1mYW1pbHk6ICdBcmlhbCBCb2xkJzsiPlhlbiBQcm9qZWN0IFJlbGVhc2VzIFVwZGF0ZSB0byBF bnRlcnByaXNlIEh5cGVydmlzb3IgU29mdHdhcmU8L3NwYW4+PHNwYW4gc3R5bGU9ImZvbnQtc2l6 ZTogMTJwdDsgZm9udC1mYW1pbHk6ICdBcmlhbCBCb2xkJzsiPjx1PjwvdT48dT48L3U+PC9zcGFu PjwvcD4NCjxwIGFsaWduPSJjZW50ZXIiIHN0eWxlPSJtYXJnaW4tYm90dG9tOiAxMXB0OyB0ZXh0 LWFsaWduOiBjZW50ZXI7Ij48Yj48aT48c3BhbiBzdHlsZT0iZm9udC1zaXplOiAxMnB0OyBiYWNr Z3JvdW5kLWNvbG9yOiB3aGl0ZTsgYmFja2dyb3VuZC1wb3NpdGlvbjogaW5pdGlhbCBpbml0aWFs OyBiYWNrZ3JvdW5kLXJlcGVhdDogaW5pdGlhbCBpbml0aWFsOyI+T3BlbiBTb3VyY2UgVmlydHVh bGl6YXRpb24gU29mdHdhcmUgUmVsZWFzZSBJbmNsdWRlcyBBZGRpdGlvbmFsDQogQVJNIFN1cHBv cnQgYW5kIFNjYWxhYmlsaXR5IGZvciBDbG91ZCBhbmQgTW9iaWxlIEVudmlyb25tZW50cyZuYnNw Ozx1PjwvdT48dT48L3U+PC9zcGFuPjwvaT48L2I+PC9wPg0KPHAgYWxpZ249ImNlbnRlciIgc3R5 bGU9Im1hcmdpbi1ib3R0b206IDExcHQ7IHRleHQtYWxpZ246IGNlbnRlcjsiPjxiPjxpPjxzcGFu IHN0eWxlPSJmb250LXNpemU6IDEycHQ7IGJhY2tncm91bmQtY29sb3I6IHdoaXRlOyBiYWNrZ3Jv dW5kLXBvc2l0aW9uOiBpbml0aWFsIGluaXRpYWw7IGJhY2tncm91bmQtcmVwZWF0OiBpbml0aWFs IGluaXRpYWw7Ij48dT48L3U+Jm5ic3A7PHU+PC91Pjwvc3Bhbj48L2k+PC9iPjwvcD4NCjwvZGl2 Pg0KPHAgc3R5bGU9Im1hcmdpbi1ib3R0b206IDExcHQ7Ij48c3BhbiBzdHlsZT0iZm9udC1zaXpl OiAxMnB0OyBmb250LWZhbWlseTogJ0FyaWFsIEJvbGQnOyI+U0FOIEZSQU5DSVNDTywgTWFyY2gg MTAsIDIwMTQ8L3NwYW4+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZTogMTJwdDsgYmFja2dyb3VuZC1j b2xvcjogd2hpdGU7IGJhY2tncm91bmQtcG9zaXRpb246IGluaXRpYWwgaW5pdGlhbDsgYmFja2dy b3VuZC1yZXBlYXQ6IGluaXRpYWwgaW5pdGlhbDsiPjxzcGFuIGNsYXNzPSJBcHBsZS1jb252ZXJ0 ZWQtc3BhY2UiPiZuYnNwOzwvc3Bhbj4/Py9zcGFuJmd0OzxzcGFuIHN0eWxlPSJmb250LXNpemU6 IDEycHQ7IGJhY2tncm91bmQtY29sb3I6IHdoaXRlOyBiYWNrZ3JvdW5kLXBvc2l0aW9uOiBpbml0 aWFsIGluaXRpYWw7IGJhY2tncm91bmQtcmVwZWF0OiBpbml0aWFsIGluaXRpYWw7Ij48c3BhbiBj bGFzcz0iQXBwbGUtY29udmVydGVkLXNwYWNlIj4mbmJzcDs8L3NwYW4+WGVuDQogUHJvamVjdCwg YSBDb2xsYWJvcmF0aXZlIFByb2plY3QgaG9zdGVkIGF0IFRoZSBMaW51eCBGb3VuZGF0aW9uLCB0 b2RheSBhbm5vdW5jZWQgYXZhaWxhYmlsaXR5IG9mIHRoZSBYZW4gUHJvamVjdCA0LjQgd2l0aCBl bmhhbmNlZCBBUk0gc3VwcG9ydC4gVGhlIGxhdGVzdCByZWxlYXNlIGFsc28gaW5jbHVkZXMgbWFq b3IgcGVyZm9ybWFuY2UgYW5kIHN5c3RlbSBzY2FsYWJpbGl0eSBpbXByb3ZlbWVudHMgZm9yIGVu dGVycHJpc2UgY29tcHV0aW5nLA0KIHN1Y2ggYXMgbW9iaWxlIGFuZCBjbG91ZCBlbnZpcm9ubWVu dHMsIHdoZXJlIHZpcnR1YWxpemF0aW9uIHRlY2hub2xvZ3kgaXMgaW5jcmVhc2luZ2x5IGluIGRl bWFuZC48dT48L3U+PHU+PC91Pjwvc3Bhbj48L3NwYW4+PC9wPg0KPHAgc3R5bGU9Im1hcmdpbi1i b3R0b206IDExcHQ7Ij48c3BhbiBzdHlsZT0iZm9udC1zaXplOiAxMnB0OyBiYWNrZ3JvdW5kLWNv bG9yOiB3aGl0ZTsgYmFja2dyb3VuZC1wb3NpdGlvbjogaW5pdGlhbCBpbml0aWFsOyBiYWNrZ3Jv dW5kLXJlcGVhdDogaW5pdGlhbCBpbml0aWFsOyI+VGhpcyByZWxlYXNlIGZ1cnRoZXIgYWR2YW5j ZXMgdGhlIFByb2plY3Q8L3NwYW4+PHNwYW4gbGFuZz0iRlIiIHN0eWxlPSJmb250LXNpemU6IDEy cHQ7IGJhY2tncm91bmQtY29sb3I6IHdoaXRlOyBiYWNrZ3JvdW5kLXBvc2l0aW9uOiBpbml0aWFs IGluaXRpYWw7IGJhY2tncm91bmQtcmVwZWF0OiBpbml0aWFsIGluaXRpYWw7Ij4/Py9zcGFuJmd0 OzxzcGFuIHN0eWxlPSJmb250LXNpemU6IDEycHQ7IGJhY2tncm91bmQtY29sb3I6IHdoaXRlOyBi YWNrZ3JvdW5kLXBvc2l0aW9uOiBpbml0aWFsIGluaXRpYWw7IGJhY2tncm91bmQtcmVwZWF0OiBp bml0aWFsIGluaXRpYWw7Ij5zDQogcG9zaXRpb24gYXMgYSBmYXN0LCBzY2FsYWJsZSwgc2VjdXJl IHZpcnR1YWxpemF0aW9uIGVuZ2luZSBmb3IgdGhlIGluZHVzdHJ5PC9zcGFuPjxzcGFuIGxhbmc9 IkZSIj4/Py9zcGFuJmd0OzxzcGFuIHN0eWxlPSJmb250LXNpemU6IDEycHQ7IGJhY2tncm91bmQt Y29sb3I6IHdoaXRlOyBiYWNrZ3JvdW5kLXBvc2l0aW9uOiBpbml0aWFsIGluaXRpYWw7IGJhY2tn cm91bmQtcmVwZWF0OiBpbml0aWFsIGluaXRpYWw7Ij5zIGJyb2FkZXN0IHJhbmdlIG9mDQogc2Vy dmVyLCBQQyBjaGlwc2V0cyBhbmQgbmV4dC1nZW5lcmF0aW9uIGxvdy1wb3dlciBzeXN0ZW1zIG9u IGNoaXBzIChTb0MpLjx1PjwvdT48dT48L3U+PC9zcGFuPjwvc3Bhbj48L3NwYW4+PC9wPg0KPGRp diBjbGFzcz0iIj4NCjxwIHN0eWxlPSJtYXJnaW4tYm90dG9tOiAxMXB0OyI+PHNwYW4gc3R5bGU9 ImZvbnQtc2l6ZTogMTJwdDsgYmFja2dyb3VuZC1jb2xvcjogd2hpdGU7IGJhY2tncm91bmQtcG9z aXRpb246IGluaXRpYWwgaW5pdGlhbDsgYmFja2dyb3VuZC1yZXBlYXQ6IGluaXRpYWwgaW5pdGlh bDsiPk1ham9yIGNvbnRyaWJ1dGlvbnMgZnJvbSBBTUQsIENpdHJpeCwgSW50ZWwsIE9yYWNsZSBh bmQgU1VTRSBhcmUgcHVzaGluZyB0aGUgWGVuIFByb2plY3Qgc29mdHdhcmUNCiB0byB0YWtlIGFk dmFudGFnZSBvZiB0aGUgbGF0ZXN0IGhhcmR3YXJlLiBBZGRpdGlvbmFsbHksIGRldmVsb3BlcnMg Y3JlYXRpbmcgc2VydmljZXMgYW5kIGFwcHMgd2l0aCBlbWJlZGRlZCwgbW9iaWxlIGFuZCBjbG91 ZCBzeXN0ZW1zIHdpbGwgYmVuZWZpdCBmcm9tIG5ldyBmZWF0dXJlcyBzdWNoIGFzIGV2ZW50IGNo YW5uZWxpbmcgd2hlbiBzY2FsaW5nIG91dCB0aGVpciBJbmZyYXN0cnVjdHVyZSBhcyBhIFNlcnZp Y2Ugb2ZmZXJpbmdzLjx1PjwvdT48dT48L3U+PC9zcGFuPjwvcD4NCjwvZGl2Pg0KPHAgc3R5bGU9 Im1hcmdpbi1ib3R0b206IDExcHQ7Ij48c3BhbiBzdHlsZT0iZm9udC1zaXplOiAxMnB0OyBiYWNr Z3JvdW5kLWNvbG9yOiB3aGl0ZTsgYmFja2dyb3VuZC1wb3NpdGlvbjogaW5pdGlhbCBpbml0aWFs OyBiYWNrZ3JvdW5kLXJlcGVhdDogaW5pdGlhbCBpbml0aWFsOyI+Pz8vc3BhbiZndDs8c3BhbiBz dHlsZT0iZm9udC1zaXplOiAxMnB0OyBiYWNrZ3JvdW5kLWNvbG9yOiB3aGl0ZTsgYmFja2dyb3Vu ZC1wb3NpdGlvbjogaW5pdGlhbCBpbml0aWFsOyBiYWNrZ3JvdW5kLXJlcGVhdDogaW5pdGlhbCBp bml0aWFsOyI+VmlydHVhbGl6YXRpb24NCiBhbmQgbG93LXBvd2VyZWQgc2VydmVycyBhcmUgbGVh ZGluZyBjb21wYW5pZXMgdG8gcmV0aGluayB0aGUgZGF0YSBjZW50ZXIgYW5kIGl0cyBwb3RlbnRp YWwgZm9yIGVmZmljaWVuY3ksPC9zcGFuPjxzcGFuIHN0eWxlPSJmb250LXNpemU6IDEycHQ7IGJh Y2tncm91bmQtY29sb3I6IHdoaXRlOyBiYWNrZ3JvdW5kLXBvc2l0aW9uOiBpbml0aWFsIGluaXRp YWw7IGJhY2tncm91bmQtcmVwZWF0OiBpbml0aWFsIGluaXRpYWw7Ij4/PzxzcGFuIGNsYXNzPSJB cHBsZS1jb252ZXJ0ZWQtc3BhY2UiPiZuYnNwOzwvc3Bhbj48L3NwYW4+PHNwYW4gc3R5bGU9ImZv bnQtc2l6ZTogMTJwdDsgYmFja2dyb3VuZC1jb2xvcjogd2hpdGU7IGJhY2tncm91bmQtcG9zaXRp b246IGluaXRpYWwgaW5pdGlhbDsgYmFja2dyb3VuZC1yZXBlYXQ6IGluaXRpYWwgaW5pdGlhbDsi PnNhaWQNCiBMYXJzIEt1cnRoLCBDaGFpcm1hbiBvZiB0aGUgWGVuIFByb2plY3QgYWR2aXNvcnkg Ym9hcmQuPHNwYW4gY2xhc3M9IkFwcGxlLWNvbnZlcnRlZC1zcGFjZSI+Jm5ic3A7PC9zcGFuPjwv c3Bhbj48c3BhbiBzdHlsZT0iZm9udC1zaXplOiAxMnB0OyBiYWNrZ3JvdW5kLWNvbG9yOiB3aGl0 ZTsgYmFja2dyb3VuZC1wb3NpdGlvbjogaW5pdGlhbCBpbml0aWFsOyBiYWNrZ3JvdW5kLXJlcGVh dDogaW5pdGlhbCBpbml0aWFsOyI+Pz8vc3BhbiZndDs8c3BhbiBzdHlsZT0iZm9udC1zaXplOiAx MnB0OyBiYWNrZ3JvdW5kLWNvbG9yOiB3aGl0ZTsgYmFja2dyb3VuZC1wb3NpdGlvbjogaW5pdGlh bCBpbml0aWFsOyBiYWNrZ3JvdW5kLXJlcGVhdDogaW5pdGlhbCBpbml0aWFsOyI+T3VyDQogc29s dXRpb24gY29udGFpbnMgSVQtcmVsYXRlZCBjb3N0cywgcGx1cyBtZWV0cyB0aGUgc2VjdXJpdHkg YW5kIHNjYWxhYmlsaXR5IG5lZWRzIG9mIHRvZGF5PC9zcGFuPjxzcGFuIGxhbmc9IkZSIiBzdHls ZT0iZm9udC1zaXplOiAxMnB0OyBiYWNrZ3JvdW5kLWNvbG9yOiB3aGl0ZTsgYmFja2dyb3VuZC1w b3NpdGlvbjogaW5pdGlhbCBpbml0aWFsOyBiYWNrZ3JvdW5kLXJlcGVhdDogaW5pdGlhbCBpbml0 aWFsOyI+Pz8vc3BhbiZndDs8c3BhbiBzdHlsZT0iZm9udC1zaXplOiAxMnB0OyBiYWNrZ3JvdW5k LWNvbG9yOiB3aGl0ZTsgYmFja2dyb3VuZC1wb3NpdGlvbjogaW5pdGlhbCBpbml0aWFsOyBiYWNr Z3JvdW5kLXJlcGVhdDogaW5pdGlhbCBpbml0aWFsOyI+cw0KIGVsYXN0aWMgY2xvdWQsIG1vYmls ZSBhbmQgc29jaWFsIG5ldHdvcmtpbmcgY29tcGFuaWVzLiBUaGUgbGF0ZXN0IHVwZGF0ZXMgY29u dGludWUgdGhlIFByb2plY3Q8L3NwYW4+PHNwYW4gbGFuZz0iRlIiPj8/L3NwYW4mZ3Q7PHNwYW4g c3R5bGU9ImZvbnQtc2l6ZTogMTJwdDsgYmFja2dyb3VuZC1jb2xvcjogd2hpdGU7IGJhY2tncm91 bmQtcG9zaXRpb246IGluaXRpYWwgaW5pdGlhbDsgYmFja2dyb3VuZC1yZXBlYXQ6IGluaXRpYWwg aW5pdGlhbDsiPnMNCiB0cmFjayByZWNvcmQgb2YgcmljaCBjb2xsYWJvcmF0aW9uIGFuZCB3aWRl c3ByZWFkIGRldmVsb3BtZW50IGZyb20gbWFueSBvZiB0aGUgd29ybGQ8L3NwYW4+PHNwYW4gbGFu Zz0iRlIiIHN0eWxlPSJmb250LXNpemU6IDEycHQ7IGJhY2tncm91bmQtY29sb3I6IHdoaXRlOyBi YWNrZ3JvdW5kLXBvc2l0aW9uOiBpbml0aWFsIGluaXRpYWw7IGJhY2tncm91bmQtcmVwZWF0OiBp bml0aWFsIGluaXRpYWw7Ij4/Py9zcGFuJmd0OzxzcGFuIHN0eWxlPSJmb250LXNpemU6IDEycHQ7 IGJhY2tncm91bmQtY29sb3I6IHdoaXRlOyBiYWNrZ3JvdW5kLXBvc2l0aW9uOiBpbml0aWFsIGlu aXRpYWw7IGJhY2tncm91bmQtcmVwZWF0OiBpbml0aWFsIGluaXRpYWw7Ij5zDQogdGVjaG5vbG9n eSBsZWFkZXJzLiBUaGlzIGNlcnRhaW5seSBleHBsYWlucyB0aGUgc2lnbmlmaWNhbnQgZ3Jvd3Ro IG9mIEFSTSBzdXBwb3J0LCB3aGljaCB3ZTwvc3Bhbj48c3BhbiBsYW5nPSJGUiIgc3R5bGU9ImZv bnQtc2l6ZTogMTJwdDsgYmFja2dyb3VuZC1jb2xvcjogd2hpdGU7IGJhY2tncm91bmQtcG9zaXRp b246IGluaXRpYWwgaW5pdGlhbDsgYmFja2dyb3VuZC1yZXBlYXQ6IGluaXRpYWwgaW5pdGlhbDsi Pj8/L3NwYW4mZ3Q7PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZTogMTJwdDsgYmFja2dyb3VuZC1jb2xv cjogd2hpdGU7IGJhY2tncm91bmQtcG9zaXRpb246IGluaXRpYWwgaW5pdGlhbDsgYmFja2dyb3Vu ZC1yZXBlYXQ6IGluaXRpYWwgaW5pdGlhbDsiPnJlDQogcGxlYXNlZCB0byBzZWUgYWR2YW5jZSBz byBxdWlja2x5Ljwvc3Bhbj48c3BhbiBzdHlsZT0iZm9udC1zaXplOiAxMnB0OyBiYWNrZ3JvdW5k LWNvbG9yOiB3aGl0ZTsgYmFja2dyb3VuZC1wb3NpdGlvbjogaW5pdGlhbCBpbml0aWFsOyBiYWNr Z3JvdW5kLXJlcGVhdDogaW5pdGlhbCBpbml0aWFsOyI+Pz8vc3BhbiZndDs8c3BhbiBzdHlsZT0i Zm9udC1zaXplOiAxMnB0OyBiYWNrZ3JvdW5kLWNvbG9yOiB3aGl0ZTsgYmFja2dyb3VuZC1wb3Np dGlvbjogaW5pdGlhbCBpbml0aWFsOyBiYWNrZ3JvdW5kLXJlcGVhdDogaW5pdGlhbCBpbml0aWFs OyI+PHU+PC91Pjx1PjwvdT48L3NwYW4+PC9zcGFuPjwvc3Bhbj48L3NwYW4+PC9zcGFuPjwvc3Bh bj48L3NwYW4+PC9zcGFuPjwvcD4NCjxkaXYgY2xhc3M9IiI+DQo8cCBzdHlsZT0ibWFyZ2luLWJv dHRvbTogMTFwdDsiPjxzcGFuIHN0eWxlPSJmb250LXNpemU6IDEycHQ7IGZvbnQtZmFtaWx5OiAn QXJpYWwgQm9sZCc7Ij5TdXBwb3J0IGZvciBBUk0gb24gWGVuIFByb2plY3QgQXJjaGl0ZWN0dXJl IEdyb3dzIFF1aWNrbHk8L3NwYW4+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZTogMTJwdDsgZm9udC1m YW1pbHk6ICdBcmlhbCBCb2xkJzsiPjx1PjwvdT48dT48L3U+PC9zcGFuPjwvcD4NCjwvZGl2Pg0K PHA+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZTogMTJwdDsgYmFja2dyb3VuZC1jb2xvcjogd2hpdGU7 IGJhY2tncm91bmQtcG9zaXRpb246IGluaXRpYWwgaW5pdGlhbDsgYmFja2dyb3VuZC1yZXBlYXQ6 IGluaXRpYWwgaW5pdGlhbDsiPlRoZSBuZXcgcmVsZWFzZSBpbnRyb2R1Y2VzIHNpZ25pZmljYW50 IHN0YWJpbGl0eSwgdXNhYmlsaXR5IGFuZCBwZXJmb3JtYW5jZSBpbXByb3ZlbWVudHMgZm9yIHRo ZSBBUk0gYXJjaGl0ZWN0dXJlIGFuZCBleHRlbmRlZA0KIGhhcmR3YXJlIGNvbXBhdGliaWxpdHku Jm5ic3A7IEFwcGxpZWRNaWNybzwvc3Bhbj48c3BhbiBsYW5nPSJGUiIgc3R5bGU9ImZvbnQtc2l6 ZTogMTJwdDsgYmFja2dyb3VuZC1jb2xvcjogd2hpdGU7IGJhY2tncm91bmQtcG9zaXRpb246IGlu aXRpYWwgaW5pdGlhbDsgYmFja2dyb3VuZC1yZXBlYXQ6IGluaXRpYWwgaW5pdGlhbDsiPj8/L3Nw YW4mZ3Q7PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZTogMTJwdDsgYmFja2dyb3VuZC1jb2xvcjogd2hp dGU7IGJhY2tncm91bmQtcG9zaXRpb246IGluaXRpYWwgaW5pdGlhbDsgYmFja2dyb3VuZC1yZXBl YXQ6IGluaXRpYWwgaW5pdGlhbDsiPnMNCiBYLUdlbmUsIHRoZSBBcm5kYWxlIEJvYXJkLCBDYWx4 ZWRhIEVDWC0yMDAwLCBUSSBPTUFQNSBhbmQgdGhlIEFsbHdpbm5lciBTdW5YaSBib2FyZHMgYXJl IGFsbCBzdXBwb3J0ZWQuIFRoZSBzdWJzdGFudGlhbGx5IGltcHJvdmVkIG11bHRpcGxhdGZvcm0g Y2FwYWJpbGl0aWVzIG9mIHRoZSBoeXBlcnZpc29yIGFsbG93IGhhcmR3YXJlIGFuZCBlbWJlZGRl ZCB2ZW5kb3JzIHRvIHBvcnQgdGhlIFhlbiBQcm9qZWN0IHRlY2hub2xvZ3kgdG8gbmV3IEFSTQ0K IFNvQ3MgZWFzaWx5LCBzaG9ydGVuaW5nIHRoZWlyIHRpbWUgdG8gbWFya2V0Ljx1PjwvdT48dT48 L3U+PC9zcGFuPjwvc3Bhbj48L3A+DQo8ZGl2IGNsYXNzPSIiPg0KPHA+PHNwYW4gc3R5bGU9ImZv bnQtc2l6ZTogMTJwdDsgYmFja2dyb3VuZC1jb2xvcjogd2hpdGU7IGJhY2tncm91bmQtcG9zaXRp b246IGluaXRpYWwgaW5pdGlhbDsgYmFja2dyb3VuZC1yZXBlYXQ6IGluaXRpYWwgaW5pdGlhbDsi Pjx1PjwvdT4mbmJzcDs8dT48L3U+PC9zcGFuPjwvcD4NCjxwPjxzcGFuIHN0eWxlPSJmb250LXNp emU6IDEycHQ7IGJhY2tncm91bmQtY29sb3I6IHdoaXRlOyBiYWNrZ3JvdW5kLXBvc2l0aW9uOiBp bml0aWFsIGluaXRpYWw7IGJhY2tncm91bmQtcmVwZWF0OiBpbml0aWFsIGluaXRpYWw7Ij5BZGRp dGlvbmFsIGVuaGFuY2VtZW50cyBpbiB0aGlzIHJlbGVhc2UgaW5jbHVkZWQgNjQtYml0IGd1ZXN0 IHN1cHBvcnQgb24gQVJNdjggcGxhdGZvcm1zLiBBbGwgdGhlIHVzZXJzcGFjZSB0b29scywgc3Vj aCBhcyB0aGUNCiB4bCBtYW5hZ2VtZW50IHRvb2wsIGFyZSA2NC1iaXQgcmVhZHkgYW5kIGNhbiBi ZSB1c2VkIHRvIGNyZWF0ZSA2NC1iaXQgdmlydHVhbCBtYWNoaW5lcyBvdXQgb2YgdGhlIGJveC48 dT48L3U+PHU+PC91Pjwvc3Bhbj48L3A+DQo8cD48c3BhbiBzdHlsZT0iZm9udC1zaXplOiAxMnB0 OyBiYWNrZ3JvdW5kLWNvbG9yOiB3aGl0ZTsgYmFja2dyb3VuZC1wb3NpdGlvbjogaW5pdGlhbCBp bml0aWFsOyBiYWNrZ3JvdW5kLXJlcGVhdDogaW5pdGlhbCBpbml0aWFsOyI+PHU+PC91PiZuYnNw Ozx1PjwvdT48L3NwYW4+PC9wPg0KPHA+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZTogMTJwdDsgYmFj a2dyb3VuZC1jb2xvcjogd2hpdGU7IGJhY2tncm91bmQtcG9zaXRpb246IGluaXRpYWwgaW5pdGlh bDsgYmFja2dyb3VuZC1yZXBlYXQ6IGluaXRpYWwgaW5pdGlhbDsiPlRoZSBYZW4gUHJvamVjdCBo eXBlcmNhbGwgQUJJIGlzIG5vdyBzdGFibGUgYW5kIHdpbGwgYmUgbWFpbnRhaW5lZCBmb3IgYmFj a3dhcmQgY29tcGF0aWJpbGl0eSwgc28gdXNlcnMgY2FuIHRydXN0IGZ1dHVyZSByZWxlYXNlcw0K IHRvIGJvb3Qgb2xkZXIgb3BlcmF0aW5nIHN5c3RlbXMuPC9zcGFuPjxzcGFuIHN0eWxlPSJmb250 LXNpemU6IDEycHQ7IGZvbnQtZmFtaWx5OiAnQXJpYWwgQm9sZCc7Ij48L3NwYW4+PHNwYW4gc3R5 bGU9ImZvbnQtc2l6ZTogMTJwdDsgZm9udC1mYW1pbHk6ICdBcmlhbCBCb2xkJzsiPjx1PjwvdT48 dT48L3U+PC9zcGFuPjwvcD4NCjxwPjxzcGFuIHN0eWxlPSJmb250LXNpemU6IDEycHQ7IGJhY2tn cm91bmQtY29sb3I6IHdoaXRlOyBiYWNrZ3JvdW5kLXBvc2l0aW9uOiBpbml0aWFsIGluaXRpYWw7 IGJhY2tncm91bmQtcmVwZWF0OiBpbml0aWFsIGluaXRpYWw7Ij5BZGRpdGlvbmFsIGltcHJvdmVt ZW50cyBpbmNsdWRlIGV4dGVuZGVkIHN1cHBvcnQgZm9yIEFSTSBzcGVjaWZpYyBib290bG9hZGVy cyBhbmQgZmlybXdhcmUgaW50ZXJmYWNlcywgYW5kIHN1cHBvcnQgZm9yIHBoeXNpY2FsDQogcGFy dGl0aW9ucyBhbmQgTFZNIHZvbHVtZXMgdG8gc3RvcmUgZGlza3Mgb2YgdmlydHVhbCBtYWNoaW5l cy48dT48L3U+PHU+PC91Pjwvc3Bhbj48L3A+DQo8cD48c3BhbiBzdHlsZT0iZm9udC1zaXplOiAx MnB0OyBiYWNrZ3JvdW5kLWNvbG9yOiB3aGl0ZTsgYmFja2dyb3VuZC1wb3NpdGlvbjogaW5pdGlh bCBpbml0aWFsOyBiYWNrZ3JvdW5kLXJlcGVhdDogaW5pdGlhbCBpbml0aWFsOyI+PHU+PC91PiZu YnNwOzx1PjwvdT48L3NwYW4+PC9wPg0KPHAgc3R5bGU9Im1hcmdpbi1ib3R0b206IDExcHQ7Ij48 c3BhbiBzdHlsZT0iZm9udC1zaXplOiAxMnB0OyBmb250LWZhbWlseTogJ0FyaWFsIEJvbGQnOyI+ SW1wcm92ZWQgRXZlbnQgQ2hhbm5lbCBTY2FsYWJpbGl0eSBGb3IgQ2xvdWQgQ29tcHV0aW5nPC9z cGFuPjxzcGFuIHN0eWxlPSJmb250LXNpemU6IDEycHQ7IGZvbnQtZmFtaWx5OiAnQXJpYWwgQm9s ZCc7Ij48dT48L3U+PHU+PC91Pjwvc3Bhbj48L3A+DQo8cCBzdHlsZT0ibWFyZ2luLWJvdHRvbTog MTFwdDsiPjxzcGFuIHN0eWxlPSJmb250LXNpemU6IDEycHQ7IGJhY2tncm91bmQtY29sb3I6IHdo aXRlOyBiYWNrZ3JvdW5kLXBvc2l0aW9uOiBpbml0aWFsIGluaXRpYWw7IGJhY2tncm91bmQtcmVw ZWF0OiBpbml0aWFsIGluaXRpYWw7Ij5YZW4gUHJvamVjdCBkZXZlbG9wZXJzIGNvbnRpbnVlcyB0 byBkcml2ZSBpbm5vdmF0aW9uIGFuZCBjb2xsYWJvcmF0aW9uIGFyb3VuZCBzZXJ2ZXIgdmlydHVh bGl6YXRpb24NCiBhbmQgdGhlIGNsb3VkLiBQb3dlcmluZyBtYW55IG9mIHRoZSBsYXJnZXN0IGNs b3VkcyBpbiBwcm9kdWN0aW9uIHRvZGF5LCBpbmNsdWRpbmcgQW1hem9uIEVDMiwgUmFja3NwYWNl IENsb3VkIGFuZCBvdGhlcnMsIHRoZSBjb21tdW5pdHkgdW5kZXJzdGFuZHMgdGhlIG5lZWQgdG8g cnVuIG1vcmUgdmlydHVhbCBtYWNoaW5lcyBvbiBhIHNpbmdsZSBob3N0Ljx1PjwvdT48dT48L3U+ PC9zcGFuPjwvcD4NCjxwIHN0eWxlPSJtYXJnaW4tYm90dG9tOiAxMXB0OyI+PHNwYW4gc3R5bGU9 ImZvbnQtc2l6ZTogMTJwdDsgYmFja2dyb3VuZC1jb2xvcjogd2hpdGU7IGJhY2tncm91bmQtcG9z aXRpb246IGluaXRpYWwgaW5pdGlhbDsgYmFja2dyb3VuZC1yZXBlYXQ6IGluaXRpYWwgaW5pdGlh bDsiPllldCBkZW1hbmRzIG9uIGh5cGVydmlzb3Igc2NhbGFiaWxpdHkgY29udGludWUgdG8gaW5j cmVhc2UsIGJvdGggZnJvbSBsYXJnZXIgbWFjaGluZXMsIG5ldyB3b3JrbG9hZHMNCiBzdWNoIGFz IHZpcnR1YWxpemF0aW9uIGRlc2t0b3AgaW5mcmFzdHJ1Y3R1cmVzIChWREkpIGFuZCBuZXcgY2xv dWQgT1MgdGVjaG5vbG9naWVzLCBpbmNsdWRpbmcgTWlyYWdlT1MsIEVybGFuZ09uWGVuLCBPU3Ys IGFuZCBIYWxWTS4gUmVjb2duaXppbmcgdGhhdCBoaWdoLWF2YWlsYWJpbGl0eSBhbmQgc3RhYmls aXR5IGFyZSBjcml0aWNhbCB0byBWRElzIGFuZCBjbG91ZCBkZXBsb3ltZW50czsgdGhlIFhlblNl cnZlciB0ZWFtIGF0IENpdHJpeCBjb250cmlidXRlZA0KIHRoZSBuZXcgZXZlbnQgY2hhbm5lbCBp bXBsZW1lbnRhdGlvbiB0byB0aGUgWGVuIFByb2plY3QuIFRvIGhlbHAgZWxpbWluYXRlIHdvcmts b2FkIGxpbWl0YXRpb25zIGZvciB1c2VycywgdGhpcyBlbmFibGVzIHRoZSBoeXBlcnZpc29yIHRv IHJ1biB0aG91c2FuZHMgb2YgZ3Vlc3RzIG9uIGEgc2luZ2xlIHBoeXNpY2FsIG1hY2hpbmUuJm5i c3A7Jm5ic3A7Jm5ic3A7PHU+PC91Pjx1PjwvdT48L3NwYW4+PC9wPg0KPHAgc3R5bGU9Im1hcmdp bi1ib3R0b206IDExcHQ7Ij48c3BhbiBzdHlsZT0iZm9udC1zaXplOiAxMnB0OyBmb250LWZhbWls eTogJ0FyaWFsIEJvbGQnOyI+RXhwZXJpbWVudGFsIFN1cHBvcnQgZm9yIFBWSCBNb2RlIGZvciBH dWVzdDwvc3Bhbj48c3BhbiBzdHlsZT0iZm9udC1zaXplOiAxMnB0OyBmb250LWZhbWlseTogJ0Fy aWFsIEJvbGQnOyI+PHU+PC91Pjx1PjwvdT48L3NwYW4+PC9wPg0KPHAgc3R5bGU9Im1hcmdpbi1i b3R0b206IDExcHQ7Ij48c3BhbiBzdHlsZT0iZm9udC1zaXplOiAxMnB0OyBiYWNrZ3JvdW5kLWNv bG9yOiB3aGl0ZTsgYmFja2dyb3VuZC1wb3NpdGlvbjogaW5pdGlhbCBpbml0aWFsOyBiYWNrZ3Jv dW5kLXJlcGVhdDogaW5pdGlhbCBpbml0aWFsOyI+T3JhY2xlIGhhcyBjb250cmlidXRlZCBhIGZ1 bmN0aW9uYWwgcHJldmlldyBvZiBhPHNwYW4gY2xhc3M9IkFwcGxlLWNvbnZlcnRlZC1zcGFjZSI+ Jm5ic3A7PC9zcGFuPjwvc3Bhbj48YSBocmVmPSJodHRwOi8vYmxvZy54ZW4ub3JnL2luZGV4LnBo cC8yMDE0LzAxLzMxL2xpbnV4LTMtMTQtYW5kLXB2aC8iIHRhcmdldD0iX2JsYW5rIj48c3Bhbj48 c3BhbiBzdHlsZT0iZm9udC1zaXplOiAxMnB0OyI+bmV3DQogdmlydHVhbGl6YXRpb24gbW9kZSBj YWxsZWQgUFZIIGN1cnJlbnRseSBhdmFpbGFibGUgdG8gdmlydHVhbGl6ZWQgZ3Vlc3RzLjxzcGFu IGNsYXNzPSJBcHBsZS1jb252ZXJ0ZWQtc3BhY2UiPiZuYnNwOzwvc3Bhbj48L3NwYW4+PC9zcGFu PjwvYT48c3BhbiBzdHlsZT0iZm9udC1zaXplOiAxMnB0OyBiYWNrZ3JvdW5kLWNvbG9yOiB3aGl0 ZTsgYmFja2dyb3VuZC1wb3NpdGlvbjogaW5pdGlhbCBpbml0aWFsOyBiYWNrZ3JvdW5kLXJlcGVh dDogaW5pdGlhbCBpbml0aWFsOyI+UFZIDQogaXMgYW4gZXh0ZW5zaW9uIHRvIHRoZSBjbGFzc2lj IFhlbiBQcm9qZWN0IFBhcmF2aXJ0dWFsaXphdGlvbiAoUFYpIHRoYXQgdXNlcyB0aGUgaGFyZHdh cmUgdmlydHVhbGl6YXRpb24gZXh0ZW5zaW9ucyBhdmFpbGFibGUgb24gbW9kZXJuIHg4NiBwcm9j ZXNzb3JzLiBQVkggdXNlcyBQViBkcml2ZXJzIGZvciBib290IGFuZCBJL08gYW5kIEludGVsIGhh cmR3YXJlIHZpcnR1YWxpemF0aW9uIGV4dGVuc2lvbnMgZm9yIHBhZ2UgdGFibGUgb3BlcmF0aW9u cywNCiBzeXN0ZW0gY2FsbHMgYW5kIG90aGVyIHByaXZpbGVnZWQgb3BlcmF0aW9ucy4gVGhpcyBu b3Qgb25seSBpbXByb3ZlcyBwZXJmb3JtYW5jZSBhbmQgc2VjdXJpdHksIGJ1dCBhbHNvIHNpbXBs aWZpZXMgdGhlIGFyY2hpdGVjdHVyZSBhbmQgWGVuIFByb2plY3QgSHlwZXJ2aXNvci1MaW51eCBp bnRlcmZhY2Ugc2lnbmlmaWNhbnRseS48dT48L3U+PHU+PC91Pjwvc3Bhbj48L3A+DQo8L2Rpdj4N CjxwIHN0eWxlPSJsaW5lLWhlaWdodDogMTVweDsiPjxzcGFuIHN0eWxlPSJmb250LXNpemU6IDEy cHQ7IGxpbmUtaGVpZ2h0OiAxN3B4OyBiYWNrZ3JvdW5kLWNvbG9yOiB3aGl0ZTsgYmFja2dyb3Vu ZC1wb3NpdGlvbjogaW5pdGlhbCBpbml0aWFsOyBiYWNrZ3JvdW5kLXJlcGVhdDogaW5pdGlhbCBp bml0aWFsOyI+Pz8vc3BhbiZndDs8c3BhbiBzdHlsZT0iZm9udC1zaXplOiAxMnB0OyBsaW5lLWhl aWdodDogMTdweDsgZm9udC1mYW1pbHk6IEFyaWFsOyBiYWNrZ3JvdW5kLWNvbG9yOiB3aGl0ZTsg YmFja2dyb3VuZC1wb3NpdGlvbjogaW5pdGlhbCBpbml0aWFsOyBiYWNrZ3JvdW5kLXJlcGVhdDog aW5pdGlhbCBpbml0aWFsOyI+UFZIDQogaXMgYSBtYWpvciBkZXZlbG9wbWVudCBmb3IgWGVuIFBy b2plY3Qgc29mdHdhcmUgb24geDg2IGFuZCBoYXMgdGhlIHBvdGVudGlhbCB0byBncmVhdGx5IHNp bXBsaWZ5IHRoZSBMaW51eCBpbnRlcmZhY2UgaW4gZHVlIHRpbWUsPHNwYW4gY2xhc3M9IkFwcGxl LWNvbnZlcnRlZC1zcGFjZSI+Jm5ic3A7PC9zcGFuPjwvc3Bhbj48c3BhbiBzdHlsZT0iZm9udC1z aXplOiAxMnB0OyBsaW5lLWhlaWdodDogMTdweDsgYmFja2dyb3VuZC1jb2xvcjogd2hpdGU7IGJh Y2tncm91bmQtcG9zaXRpb246IGluaXRpYWwgaW5pdGlhbDsgYmFja2dyb3VuZC1yZXBlYXQ6IGlu aXRpYWwgaW5pdGlhbDsiPj8/PHNwYW4gY2xhc3M9IkFwcGxlLWNvbnZlcnRlZC1zcGFjZSI+Jm5i c3A7PC9zcGFuPjwvc3Bhbj48c3BhbiBzdHlsZT0iZm9udC1zaXplOiAxMnB0OyBsaW5lLWhlaWdo dDogMTdweDsgZm9udC1mYW1pbHk6IEFyaWFsOyBiYWNrZ3JvdW5kLWNvbG9yOiB3aGl0ZTsgYmFj a2dyb3VuZC1wb3NpdGlvbjogaW5pdGlhbCBpbml0aWFsOyBiYWNrZ3JvdW5kLXJlcGVhdDogaW5p dGlhbCBpbml0aWFsOyI+c2FpZA0KIEtvbnJhZCBSemVzenV0ZWsgV2lsaywgU29mdHdhcmUgRGV2 ZWxvcG1lbnQgTWFuYWdlciBhdCBPcmFjbGUsIGEgWGVuIFByb2plY3QgYWR2aXNvcnkgYm9hcmQg bWVtYmVyLjxzcGFuIGNsYXNzPSJBcHBsZS1jb252ZXJ0ZWQtc3BhY2UiPiZuYnNwOzwvc3Bhbj48 L3NwYW4+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZTogMTJwdDsgbGluZS1oZWlnaHQ6IDE3cHg7IGJh Y2tncm91bmQtY29sb3I6IHdoaXRlOyBiYWNrZ3JvdW5kLXBvc2l0aW9uOiBpbml0aWFsIGluaXRp YWw7IGJhY2tncm91bmQtcmVwZWF0OiBpbml0aWFsIGluaXRpYWw7Ij4/Py9zcGFuJmd0OzxzcGFu IHN0eWxlPSJmb250LXNpemU6IDEycHQ7IGxpbmUtaGVpZ2h0OiAxN3B4OyBmb250LWZhbWlseTog QXJpYWw7IGJhY2tncm91bmQtY29sb3I6IHdoaXRlOyBiYWNrZ3JvdW5kLXBvc2l0aW9uOiBpbml0 aWFsIGluaXRpYWw7IGJhY2tncm91bmQtcmVwZWF0OiBpbml0aWFsIGluaXRpYWw7Ij5XZQ0KIGV4 cGVjdCBQVkggdG8gaGF2ZSB0aGUgYmVzdCBjaGFyYWN0ZXJpc3RpY3Mgb2YgYWxsIHZpcnR1YWxp emF0aW9uIG1vZGVzIC0tIGEgc2ltcGxlLCBmYXN0LCBzZWN1cmUgaW50ZXJmYWNlLCB3aXRoIGxv dyBtZW1vcnkgb3ZlcmhlYWQsIHRoYXQgYWxzbyB0YWtlcyBmdWxsIGFkdmFudGFnZSBvZiB0aGUg bGF0ZXN0IGhhcmR3YXJlLjwvc3Bhbj48c3BhbiBzdHlsZT0iZm9udC1zaXplOiAxMnB0OyBsaW5l LWhlaWdodDogMTdweDsgYmFja2dyb3VuZC1jb2xvcjogd2hpdGU7IGJhY2tncm91bmQtcG9zaXRp b246IGluaXRpYWwgaW5pdGlhbDsgYmFja2dyb3VuZC1yZXBlYXQ6IGluaXRpYWwgaW5pdGlhbDsi Pj8/L3NwYW4mZ3Q7PHNwYW4+PHU+PC91Pjx1PjwvdT48L3NwYW4+PC9zcGFuPjwvc3Bhbj48L3Nw YW4+PC9wPg0KPHA+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZTogMTJwdDsgbGluZS1oZWlnaHQ6IDE4 cHg7IGJhY2tncm91bmQtY29sb3I6IHdoaXRlOyBiYWNrZ3JvdW5kLXBvc2l0aW9uOiBpbml0aWFs IGluaXRpYWw7IGJhY2tncm91bmQtcmVwZWF0OiBpbml0aWFsIGluaXRpYWw7Ij48dT48L3U+Jm5i c3A7PHU+PC91Pjwvc3Bhbj48L3A+DQo8cCBzdHlsZT0ibWFyZ2luLWJvdHRvbTogMTFwdDsiPjxz cGFuIHN0eWxlPSJmb250LXNpemU6IDEycHQ7IGJhY2tncm91bmQtY29sb3I6IHdoaXRlOyBiYWNr Z3JvdW5kLXBvc2l0aW9uOiBpbml0aWFsIGluaXRpYWw7IGJhY2tncm91bmQtcmVwZWF0OiBpbml0 aWFsIGluaXRpYWw7Ij5BZGRpdGlvbmFsIGtleSB1cGRhdGVzIGluY2x1ZGU6PHU+PC91Pjx1Pjwv dT48L3NwYW4+PC9wPg0KPHAgc3R5bGU9Im1hcmdpbjogMGluIDBpbiAxMXB0IDM0LjVwdDsiPuWa mei4neiVrTxzcGFuIHN0eWxlPSJmb250LXNpemU6IDdwdDsgZm9udC1mYW1pbHk6ICdUaW1lcyBO ZXcgUm9tYW4nOyI+Jm5ic3A7Jm5ic3A7Jm5ic3A7Jm5ic3A7PHNwYW4gY2xhc3M9IkFwcGxlLWNv bnZlcnRlZC1zcGFjZSI+Jm5ic3A7PC9zcGFuPjwvc3Bhbj48c3BhbiBzdHlsZT0iZm9udC1zaXpl OiAxMnB0OyBiYWNrZ3JvdW5kLWNvbG9yOiB3aGl0ZTsgYmFja2dyb3VuZC1wb3NpdGlvbjogaW5p dGlhbCBpbml0aWFsOyBiYWNrZ3JvdW5kLXJlcGVhdDogaW5pdGlhbCBpbml0aWFsOyI+QmV0dGVy DQogcGVyZm9ybWFuY2Ugd2l0aCBtb2Rlcm4gc3RvcmFnZSBkZXZpY2VzIGFuZCBiaWcgZGF0YSAt LSBJbmRpcmVjdCBkZXNjcmlwdG9ycyBmb3IgYmxvY2sgUFYgcHJvdG9jb2wgKExpbnV4KSBhbGxv dyBlYWNoIGluZGl2aWR1YWwgcmVxdWVzdCB0byB0cmlwbGUgaW4gc2l6ZSwgZ3JlYXRseSBpbXBy b3ZpbmcgSS9PIHBlcmZvcm1hbmNlIHdoZW4gcnVubmluZyBvbiBmYXN0IHN0b3JhZ2UgdGVjaG5v bG9naWVzIHN1Y2ggYXMgc29saWQtc3RhdGUgZHJpdmUNCiBhbmQgUkFJRC4gQXZhaWxhYmxlIGlu IGFueSBndWVzdCBydW5uaW5nIExpbnV4IDMuMTEgb3IgaGlnaGVyIChyZWdhcmRsZXNzIG9mIFhl biBQcm9qZWN0IHZlcnNpb24pLjwvc3Bhbj48c3BhbiBzdHlsZT0iYmFja2dyb3VuZC1jb2xvcjog d2hpdGU7IGJhY2tncm91bmQtcG9zaXRpb246IGluaXRpYWwgaW5pdGlhbDsgYmFja2dyb3VuZC1y ZXBlYXQ6IGluaXRpYWwgaW5pdGlhbDsiPjx1PjwvdT48dT48L3U+PC9zcGFuPjwvcD4NCjxwIHN0 eWxlPSJtYXJnaW4tYm90dG9tOiAxMXB0OyI+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZTogMTJwdDsg YmFja2dyb3VuZC1jb2xvcjogd2hpdGU7IGJhY2tncm91bmQtcG9zaXRpb246IGluaXRpYWwgaW5p dGlhbDsgYmFja2dyb3VuZC1yZXBlYXQ6IGluaXRpYWwgaW5pdGlhbDsiPjx1PjwvdT4mbmJzcDs8 dT48L3U+PC9zcGFuPjwvcD4NCjxwIHN0eWxlPSJtYXJnaW46IDBpbiAwaW4gMTFwdCAzNC41cHQ7 Ij7lmpnouJ3ola08c3BhbiBzdHlsZT0iZm9udC1zaXplOiA3cHQ7IGZvbnQtZmFtaWx5OiAnVGlt ZXMgTmV3IFJvbWFuJzsiPiZuYnNwOyZuYnNwOyZuYnNwOyZuYnNwOzxzcGFuIGNsYXNzPSJBcHBs ZS1jb252ZXJ0ZWQtc3BhY2UiPiZuYnNwOzwvc3Bhbj48L3NwYW4+PHNwYW4gc3R5bGU9ImZvbnQt c2l6ZTogMTJwdDsgYmFja2dyb3VuZC1jb2xvcjogd2hpdGU7IGJhY2tncm91bmQtcG9zaXRpb246 IGluaXRpYWwgaW5pdGlhbDsgYmFja2dyb3VuZC1yZXBlYXQ6IGluaXRpYWwgaW5pdGlhbDsiPk1v cmUNCiBwb3dlcmZ1bCBkcml2ZXIgZG9tYWlucyAtLTxzcGFuIGNsYXNzPSJBcHBsZS1jb252ZXJ0 ZWQtc3BhY2UiPiZuYnNwOzwvc3Bhbj48L3NwYW4+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZTogMTJw dDsgY29sb3I6IHJnYigzNCwgMzQsIDM0KTsgYmFja2dyb3VuZC1jb2xvcjogd2hpdGU7IGJhY2tn cm91bmQtcG9zaXRpb246IGluaXRpYWwgaW5pdGlhbDsgYmFja2dyb3VuZC1yZXBlYXQ6IGluaXRp YWwgaW5pdGlhbDsiPkRpc2sgZHJpdmVyIGRvbWFpbnMgY2FuIG5vdw0KIHVuaWZvcm1seSBydW4g YmxvY2sgc2NyaXB0cyBhbmQgdXNlci1zcGFjZSBiYWNrZW5kcywgc3VjaCBhcyBxZGlzaywgYnJp bmdpbmcgdGhlbSB1cCB0byBmZWF0dXJlIHBhcml0eSB3aXRoIGRvbWFpbiAwLiBUaGlzIG1lYW5z IGhvc3QgYWRtaW5pc3RyYXRvcnMgY2FuIHRha2UgYWR2YW50YWdlIG9mIHRoZSBlbmhhbmNlZCBz ZWN1cml0eSwgc2NhbGFiaWxpdHksIGFuZCByb2J1c3RuZXNzIHByb3ZpZGVkIGJ5IGRyaXZlciBk b21haW5zIHdpdGhvdXQNCiBzYWNyaWZpY2luZyB0aGUgd2lkZSBhcnJheSBvZiBkaXNrIGNvbmZp Z3VyYXRpb24gb3B0aW9ucyBwcm92aWRlZCBieSBYZW4gaW4gZG9tMC48L3NwYW4+PHNwYW4gc3R5 bGU9ImJhY2tncm91bmQtY29sb3I6IHdoaXRlOyBiYWNrZ3JvdW5kLXBvc2l0aW9uOiBpbml0aWFs IGluaXRpYWw7IGJhY2tncm91bmQtcmVwZWF0OiBpbml0aWFsIGluaXRpYWw7Ij48dT48L3U+PHU+ PC91Pjwvc3Bhbj48L3A+DQo8cCBzdHlsZT0ibWFyZ2luOiAwaW4gMGluIDExcHQgMzQuNXB0OyI+ 5ZqZ6Lid6JWtPHNwYW4gc3R5bGU9ImZvbnQtc2l6ZTogN3B0OyBmb250LWZhbWlseTogJ1RpbWVz IE5ldyBSb21hbic7Ij4mbmJzcDsmbmJzcDsmbmJzcDsmbmJzcDs8c3BhbiBjbGFzcz0iQXBwbGUt Y29udmVydGVkLXNwYWNlIj4mbmJzcDs8L3NwYW4+PC9zcGFuPjxzcGFuIHN0eWxlPSJmb250LXNp emU6IDEycHQ7IGJhY2tncm91bmQtY29sb3I6IHdoaXRlOyBiYWNrZ3JvdW5kLXBvc2l0aW9uOiBp bml0aWFsIGluaXRpYWw7IGJhY2tncm91bmQtcmVwZWF0OiBpbml0aWFsIGluaXRpYWw7Ij5OZXcN CiBTUElDRSBwcm90b2NvbCBzdXBwb3J0IC0tIEZ1bmN0aW9uYWxpdHkgc3VjaCBhcyBjbGlwYm9h cmQgc2hhcmluZyBhbmQgVVNCIHJlZGlyZWN0aW9uIGNyZWF0ZXMgYSBtdWNoIHJpY2hlciBjb25u ZWN0aW9uIGZvciB2aXJ0dWFsIGRlc2t0b3BzIGFuZCBiZXR0ZXIgZ3JhcGhpY3MgcGVyZm9ybWFu Y2UuPC9zcGFuPjxzcGFuIHN0eWxlPSJiYWNrZ3JvdW5kLWNvbG9yOiB3aGl0ZTsgYmFja2dyb3Vu ZC1wb3NpdGlvbjogaW5pdGlhbCBpbml0aWFsOyBiYWNrZ3JvdW5kLXJlcGVhdDogaW5pdGlhbCBp bml0aWFsOyI+PHU+PC91Pjx1PjwvdT48L3NwYW4+PC9wPg0KPHAgc3R5bGU9Im1hcmdpbjogMGlu IDBpbiAxMXB0IDM0LjVwdDsiPuWamei4neiVrTxzcGFuIHN0eWxlPSJmb250LXNpemU6IDdwdDsg Zm9udC1mYW1pbHk6ICdUaW1lcyBOZXcgUm9tYW4nOyI+Jm5ic3A7Jm5ic3A7Jm5ic3A7Jm5ic3A7 PHNwYW4gY2xhc3M9IkFwcGxlLWNvbnZlcnRlZC1zcGFjZSI+Jm5ic3A7PC9zcGFuPjwvc3Bhbj48 c3BhbiBzdHlsZT0iZm9udC1zaXplOiAxMnB0OyBiYWNrZ3JvdW5kLWNvbG9yOiB3aGl0ZTsgYmFj a2dyb3VuZC1wb3NpdGlvbjogaW5pdGlhbCBpbml0aWFsOyBiYWNrZ3JvdW5kLXJlcGVhdDogaW5p dGlhbCBpbml0aWFsOyI+RW5oYW5jZWQNCiBkaWFnbm9zdGljcyBhbmQga2V4ZWMgZGVidWcgc3Vw cG9ydCAtLSBXaGVuIGEgY3Jhc2ggaGFwcGVucywgYSBzcGVjaWFsIGtlcm5lbCBpcyBhbGxvd2Vk IGltbWVkaWF0ZSB0byBjb2xsZWN0IGluZm9ybWF0aW9uIGFib3V0IHRoZSByb290IGNhdXNlLCBv ZmZlcmluZyBkZXZlbG9wZXJzIGJldHRlciBkaWFnbm9zaXMgYW5kIHJlcGFpciBhYmlsaXRpZXMu PC9zcGFuPjxzcGFuIHN0eWxlPSJiYWNrZ3JvdW5kLWNvbG9yOiB3aGl0ZTsgYmFja2dyb3VuZC1w b3NpdGlvbjogaW5pdGlhbCBpbml0aWFsOyBiYWNrZ3JvdW5kLXJlcGVhdDogaW5pdGlhbCBpbml0 aWFsOyI+PHU+PC91Pjx1PjwvdT48L3NwYW4+PC9wPg0KPGRpdj4NCjxkaXYgY2xhc3M9InhfaDUi Pg0KPHA+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZTogMTJwdDsiPlRoZSA0LjQgcmVsZWFzZSBpcyB0 aGUgcmVzdWx0IG9mIGEgYnJvYWQsIGNvbGxhYm9yYXRpdmUgZGV2ZWxvcG1lbnQgZWZmb3J0IHJl cHJlc2VudGluZyBlbmdpbmVlcnMgZnJvbSBtb3JlIHRoYW4gMTMgbGVhZGluZyBoYXJkd2FyZSwg c29mdHdhcmUgYW5kIHNlY3VyaXR5IHZlbmRvcnMuIFRvcCBjb250cmlidXRvcnMgaW5jbHVkZSBB bWF6b24sIEFNRCwgQW5hbG9nIERldmljZXMsIEJyb2FkY29tLA0KIENpdHJpeCwgRnVqaXRzdSwg SW50ZWwsIExpbmFybywgTlNBLCBPcmFjbGUsIFN1c2UsIFZlcml6b24vVGVycmVtYXJrLCBwbHVz IG51bWVyb3VzIGluZGl2aWR1YWwgYW5kIGFjYWRlbWljIGNvbnRyaWJ1dG9ycy4gVGhlIGZyZWVs eSBhdmFpbGFibGUgZG93bmxvYWQgY2FuIGJlIGZvdW5kIG9uIHRoZTxzcGFuIGNsYXNzPSJBcHBs ZS1jb252ZXJ0ZWQtc3BhY2UiPiZuYnNwOzwvc3Bhbj48YSBocmVmPSJodHRwOi8veGVucHJvamVj dC5vcmcvIiB0YXJnZXQ9Il9ibGFuayI+WGVuUHJvamVjdC5vcmc8L2E+PHNwYW4gY2xhc3M9IkFw cGxlLWNvbnZlcnRlZC1zcGFjZSI+Jm5ic3A7PC9zcGFuPndlYnNpdGUNCiAoaW5zZXJ0IHVybCku PHU+PC91Pjx1PjwvdT48L3NwYW4+PC9wPg0KPGRpdj48c3BhbiBzdHlsZT0iZm9udC1zaXplOiAx MnB0OyI+Jm5ic3A7PC9zcGFuPjxiciBjbGFzcz0ieF93ZWJraXQtYmxvY2stcGxhY2Vob2xkZXIi Pg0KPC9kaXY+DQo8cCBzdHlsZT0ibWFyZ2luLWJvdHRvbTogMTFwdDsiPjx1PjxzcGFuIHN0eWxl PSJmb250LXNpemU6IDEycHQ7IGZvbnQtZmFtaWx5OiAnQXJpYWwgQm9sZCc7Ij5BYm91dCBYZW4g UHJvamVjdDwvc3Bhbj48L3U+PHU+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZTogMTJwdDsgZm9udC1m YW1pbHk6ICdBcmlhbCBCb2xkJzsiPjx1PjwvdT48dT48L3U+PC9zcGFuPjwvdT48L3A+DQo8cCBz dHlsZT0ibWFyZ2luLWJvdHRvbTogMTFwdDsiPjxzcGFuIHN0eWxlPSJmb250LXNpemU6IDEycHQ7 IGJhY2tncm91bmQtY29sb3I6IHdoaXRlOyBiYWNrZ3JvdW5kLXBvc2l0aW9uOiBpbml0aWFsIGlu aXRpYWw7IGJhY2tncm91bmQtcmVwZWF0OiBpbml0aWFsIGluaXRpYWw7Ij5UaGUgWGVuIFByb2pl Y3Qgc29mdHdhcmUgaXMgYW4gb3BlbiBzb3VyY2UgdmlydHVhbGl6YXRpb24gcGxhdGZvcm0gbGlj ZW5zZWQgdW5kZXIgdGhlIEdQTHYyIHdpdGgNCiBhIHNpbWlsYXIgZ292ZXJuYW5jZSBzdHJ1Y3R1 cmUgdG8gdGhlIExpbnV4IGtlcm5lbC4gRGVzaWduZWQgZnJvbSB0aGUgc3RhcnQgZm9yIGNsb3Vk IGNvbXB1dGluZywgdGhlIFByb2plY3QgaGFzIG1vcmUgdGhhbiBhIGRlY2FkZSBvZiBkZXZlbG9w bWVudCBhbmQgaXMgYmVpbmcgdXNlZCBieSBtb3JlIHRoYW4gMTAgbWlsbGlvbiB1c2Vycy4gQSBD b2xsYWJvcmF0aXZlIFByb2plY3QgYXQgVGhlIExpbnV4IEZvdW5kYXRpb24sIHRoZSBYZW4gUHJv amVjdA0KIHRlYW0gaXMgZm9jdXNlZCBvbiBhZHZhbmNpbmcgdmlydHVhbGl6YXRpb24gaW4gYSBu dW1iZXIgb2YgZGlmZmVyZW50IGNvbW1lcmNpYWwgYW5kIG9wZW4gc291cmNlIGFwcGxpY2F0aW9u cyBpbmNsdWRpbmcgc2VydmVyIHZpcnR1YWxpemF0aW9uLCBJbmZyYXN0cnVjdHVyZSBhcyBhIFNl cnZpY2UgKElhYVMpLCBkZXNrdG9wIHZpcnR1YWxpemF0aW9uLCBzZWN1cml0eSBhcHBsaWNhdGlv bnMsIGVtYmVkZGVkIGFuZCBoYXJkd2FyZSBhcHBsaWFuY2VzLg0KIEl0IGNvdW50cyBtYW55IGlu ZHVzdHJ5IGFuZCBvcGVuIHNvdXJjZSBjb21tdW5pdHkgbGVhZGVycyBhbW9uZyBpdHMgbWVtYmVy cyBpbmNsdWRpbmc6IEFtYXpvbiBXZWIgU2VydmljZXMsIEFNRCwgQVJNLCBCcm9taXVtLCBDYWx4 ZWRhLCBDQSBUZWNobm9sb2dpZXMsIENpc2NvLCBDaXRyaXgsIEdvb2dsZSwgSW50ZWwsIE9yYWNs ZSwgU2Ftc3VuZyBhbmQgVmVyaXpvbi4gRm9yIG1vcmUgaW5mb3JtYXRpb24gYWJvdXQgdGhlIFhl biBQcm9qZWN0IGh5cGVydmlzb3INCiBhbmQgdG8gcGFydGljaXBhdGUsIHBsZWFzZSB2aXNpdDwv c3Bhbj48YSBocmVmPSJodHRwOi8veGVucHJvamVjdC5vcmcvIiB0YXJnZXQ9Il9ibGFuayI+PHNw YW4+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZTogMTJwdDsgdGV4dC1kZWNvcmF0aW9uOiBub25lOyI+ aHR0cDovL3hlbnByb2plY3QuPC9zcGFuPjwvc3Bhbj48L2E+PGEgaHJlZj0iaHR0cDovL3hlbnBy b2plY3Qub3JnLyIgdGFyZ2V0PSJfYmxhbmsiPjxzcGFuPjxzcGFuIHN0eWxlPSJmb250LXNpemU6 IDEycHQ7IHRleHQtZGVjb3JhdGlvbjogbm9uZTsiPm9yZzwvc3Bhbj48L3NwYW4+PC9hPjxzcGFu IHN0eWxlPSJmb250LXNpemU6IDEycHQ7IGJhY2tncm91bmQtY29sb3I6IHdoaXRlOyBiYWNrZ3Jv dW5kLXBvc2l0aW9uOiBpbml0aWFsIGluaXRpYWw7IGJhY2tncm91bmQtcmVwZWF0OiBpbml0aWFs IGluaXRpYWw7Ij4uPHU+PC91Pjx1PjwvdT48L3NwYW4+PC9wPg0KPHAgYWxpZ249ImNlbnRlciIg c3R5bGU9Im1hcmdpbi1ib3R0b206IDExcHQ7IHRleHQtYWxpZ246IGNlbnRlcjsiPjxzcGFuIHN0 eWxlPSJmb250LXNpemU6IDEycHQ7IGxpbmUtaGVpZ2h0OiAxOHB4OyBiYWNrZ3JvdW5kLWNvbG9y OiB3aGl0ZTsgYmFja2dyb3VuZC1wb3NpdGlvbjogaW5pdGlhbCBpbml0aWFsOyBiYWNrZ3JvdW5k LXJlcGVhdDogaW5pdGlhbCBpbml0aWFsOyI+IyMjPHU+PC91Pjx1PjwvdT48L3NwYW4+PC9wPg0K PHAgc3R5bGU9Im1hcmdpbi1ib3R0b206IDExcHQ7Ij48c3BhbiBzdHlsZT0iZm9udC1zaXplOiAx MnB0OyBiYWNrZ3JvdW5kLWNvbG9yOiB3aGl0ZTsgYmFja2dyb3VuZC1wb3NpdGlvbjogaW5pdGlh bCBpbml0aWFsOyBiYWNrZ3JvdW5kLXJlcGVhdDogaW5pdGlhbCBpbml0aWFsOyI+U2FyYWggQ29u d2F5PHU+PC91Pjx1PjwvdT48L3NwYW4+PC9wPg0KPHAgc3R5bGU9Im1hcmdpbi1ib3R0b206IDEx cHQ7Ij48c3BhbiBzdHlsZT0iZm9udC1zaXplOiAxMnB0OyBiYWNrZ3JvdW5kLWNvbG9yOiB3aGl0 ZTsgYmFja2dyb3VuZC1wb3NpdGlvbjogaW5pdGlhbCBpbml0aWFsOyBiYWNrZ3JvdW5kLXJlcGVh dDogaW5pdGlhbCBpbml0aWFsOyI+VGhlIFhlbiBQcm9qZWN0PHU+PC91Pjx1PjwvdT48L3NwYW4+ PC9wPg0KPHAgc3R5bGU9Im1hcmdpbi1ib3R0b206IDExcHQ7Ij48c3BhbiBzdHlsZT0iZm9udC1z aXplOiAxMnB0OyBiYWNrZ3JvdW5kLWNvbG9yOiB3aGl0ZTsgYmFja2dyb3VuZC1wb3NpdGlvbjog aW5pdGlhbCBpbml0aWFsOyBiYWNrZ3JvdW5kLXJlcGVhdDogaW5pdGlhbCBpbml0aWFsOyI+TWVk aWEgQ29udGFjdDx1PjwvdT48dT48L3U+PC9zcGFuPjwvcD4NCjxwIHN0eWxlPSJtYXJnaW4tYm90 dG9tOiAxMXB0OyI+PHNwYW4gc3R5bGU9ImZvbnQtc2l6ZTogMTJwdDsgYmFja2dyb3VuZC1jb2xv cjogd2hpdGU7IGJhY2tncm91bmQtcG9zaXRpb246IGluaXRpYWwgaW5pdGlhbDsgYmFja2dyb3Vu ZC1yZXBlYXQ6IGluaXRpYWwgaW5pdGlhbDsiPjxhIGhyZWY9Im1haWx0bzpwdWJsaWNpdHlAbGlz dHMueGVucHJvamVjdC5vcmciIHRhcmdldD0iX2JsYW5rIj5wdWJsaWNpdHlAbGlzdHMueGVucHJv amVjdC5vcmc8L2E+PHU+PC91Pjx1PjwvdT48L3NwYW4+PC9wPg0KPC9kaXY+DQo8L2Rpdj4NCjwv ZGl2Pg0KPGRpdj48YnI+DQo8L2Rpdj4NCjxkaXY+PGJyPg0KPGRpdj4NCjxkaXY+DQo8ZGl2IGNs YXNzPSJ4X2g1Ij4NCjxkaXY+T24gTWFyIDYsIDIwMTQsIGF0IDEyOjQ0IFBNLCBXaWxzb24sIE1h dHQgJmx0OzxhIGhyZWY9Im1haWx0bzptc3dAYW1hem9uLmNvbSIgdGFyZ2V0PSJfYmxhbmsiPm1z d0BhbWF6b24uY29tPC9hPiZndDsgd3JvdGU6PC9kaXY+DQo8YnI+DQo8L2Rpdj4NCjwvZGl2Pg0K PGJsb2NrcXVvdGUgdHlwZT0iY2l0ZSI+DQo8ZGl2IHN0eWxlPSJmb250LWZhbWlseTogSGVsdmV0 aWNhOyBmb250LXNpemU6IDEycHg7IGZvbnQtc3R5bGU6IG5vcm1hbDsgZm9udC12YXJpYW50OiBu b3JtYWw7IGZvbnQtd2VpZ2h0OiBub3JtYWw7IGxldHRlci1zcGFjaW5nOiBub3JtYWw7IGxpbmUt aGVpZ2h0OiBub3JtYWw7IHRleHQtYWxpZ246IHN0YXJ0OyB0ZXh0LWluZGVudDogMHB4OyB0ZXh0 LXRyYW5zZm9ybTogbm9uZTsgd2hpdGUtc3BhY2U6IG5vcm1hbDsgd29yZC1zcGFjaW5nOiAwcHg7 Ij4NCjxkaXYgc3R5bGU9ImRpcmVjdGlvbjogbHRyOyBmb250LWZhbWlseTogVmVyZGFuYTsgZm9u dC1zaXplOiAxMHB0OyI+TWFyaywgdGhvdWdodHM/DQo8ZGl2Pjxicj4NCjwvZGl2Pg0KPGRpdj4N CjxkaXYgc3R5bGU9ImZvbnQtZmFtaWx5OiAnVGltZXMgTmV3IFJvbWFuJzsgZm9udC1zaXplOiAx NnB4OyI+DQo8ZGl2Pg0KPGRpdiBjbGFzcz0ieF9oNSI+DQo8aHI+DQo8ZGl2IHN0eWxlPSJkaXJl Y3Rpb246IGx0cjsiPjxmb250IGZhY2U9IlRhaG9tYSI+PGI+RnJvbTo8L2I+PHNwYW4+Jm5ic3A7 PC9zcGFuPldpbHNvbiwgTWF0dDxicj4NCjxiPlNlbnQ6PC9iPjxzcGFuPiZuYnNwOzwvc3Bhbj5X ZWRuZXNkYXksIE1hcmNoIDA1LCAyMDE0IDEwOjAxIEFNPGJyPg0KPGI+VG86PC9iPjxzcGFuPiZu YnNwOzwvc3Bhbj5BZHZpc29yeS1ib2FyZCBkaXNjdXNzaW9uczxicj4NCjxiPlN1YmplY3Q6PC9i PjxzcGFuPiZuYnNwOzwvc3Bhbj5SRTogW0Fkdmlzb3J5LWJvYXJkXSBYZW4gUHJvamVjdCA0LjQg UmVsZWFzZTxicj4NCjwvZm9udD48YnI+DQo8L2Rpdj4NCjxkaXY+PC9kaXY+DQo8L2Rpdj4NCjwv ZGl2Pg0KPGRpdj4NCjxkaXYgc3R5bGU9ImRpcmVjdGlvbjogbHRyOyBmb250LWZhbWlseTogVmVy ZGFuYTsgZm9udC1zaXplOiAxMHB0OyI+DQo8ZGl2Pg0KPGRpdiBjbGFzcz0ieF9oNSI+SSdkIHJh dGhlciB1c2UgJnF1b3Q7WGVuIFByb2plY3QgSHlwZXJ2aXNvciZxdW90OyB0aGFuIGludHJvZHVj ZSBhbiBhY3JvbnltLiBJIHRoaW5rIGl0J3MgaW1wb3J0YW50IHRoYXQgJnF1b3Q7WGVuIFByb2pl Y3QmcXVvdDsgbm90IGJlIHNwbGl0IGZyb20gJnF1b3Q7SHlwZXJ2aXNvci4mcXVvdDsNCjxkaXY+ PGJyPg0KVGhpcyBzdGlsbCBkb2Vzbid0IGFkZHJlc3MgaG93IHRoZSB1bWJyZWxsYSBwcm9qZWN0 IGlzIGNhbGxlZC4gVGhpcyBuZXcgcmVsZWFzZSBkb2Vzbid0IG9ubHkgaW5jbHVkZSB0aGUgaHlw ZXJ2aXNvciwgYnV0IGFsc28gdGhlIGFzc29jaWF0ZWQgdG9vbHN0YWNrIGFuZCB1dGlsaXRpZXMu IE1heWJlIHdlJ3JlIE9LIGNhbGxpbmcgYWxsIG9mIHRoYXQgdGhlICZxdW90O0h5cGVydmlzb3Is JnF1b3Q7IGV2ZW4gaWYgd2UgaWRlbnRpZnkgdGhlIGRldmVsb3BtZW50IHRlYW1zDQogZGlmZmVy ZW50bHkuPC9kaXY+DQo8ZGl2Pjxicj4NCjwvZGl2Pg0KPGRpdj5Ib3cgc2hvdWxkIHdlIHJlLWFs aWduIGFsbCBvZiB0aGUgYnJhbmRpbmc/IEZvciBleGFtcGxlOiZuYnNwOzxhIGhyZWY9Imh0dHA6 Ly94ZW5wcm9qZWN0Lm9yZy9kZXZlbG9wZXJzL3RlYW1zL2h5cGVydmlzb3IuaHRtbCIgdGFyZ2V0 PSJfYmxhbmsiIHN0eWxlPSJmb250LXNpemU6IDEwcHQ7Ij5odHRwOi8veGVucHJvamVjdC5vcmcv ZGV2ZWxvcGVycy90ZWFtcy9oeXBlcnZpc29yLmh0bWw8L2E+PC9kaXY+DQo8ZGl2Pjxicj4NCjwv ZGl2Pg0KPGRpdj5TaG91bGQgdGhlIGxpbmtzIHVuZGVyICZxdW90O0h5cGVydmlzb3IgRG93bmxv YWRzJnF1b3Q7IGJlICZxdW90O3ZlcnNpb24gNC4zLjEmcXVvdDsgaW5zdGVhZCBvZiAmcXVvdDtY ZW4gNC4zLjEmcXVvdDsgdG8gcmVzb2x2ZSB0aGUgdHJhZGVtYXJrIGNvbmNlcm5zPzwvZGl2Pg0K PGRpdj48YnI+DQo8L2Rpdj4NCjxkaXY+LS1tc3c8L2Rpdj4NCjxkaXY+PGJyPg0KPC9kaXY+DQo8 L2Rpdj4NCjwvZGl2Pg0KPGRpdj4NCjxkaXYgc3R5bGU9ImZvbnQtZmFtaWx5OiAnVGltZXMgTmV3 IFJvbWFuJzsgZm9udC1zaXplOiAxNnB4OyI+DQo8ZGl2Pg0KPGRpdiBjbGFzcz0ieF9oNSI+DQo8 aHI+DQo8ZGl2IHN0eWxlPSJkaXJlY3Rpb246IGx0cjsiPjxmb250IGZhY2U9IlRhaG9tYSI+PGI+ RnJvbTo8L2I+PHNwYW4+Jm5ic3A7PC9zcGFuPjxhIGhyZWY9Im1haWx0bzphZHZpc29yeS1ib2Fy ZC1ib3VuY2VzQGxpc3RzLnhlbnByb2plY3Qub3JnIiB0YXJnZXQ9Il9ibGFuayI+YWR2aXNvcnkt Ym9hcmQtYm91bmNlc0BsaXN0cy54ZW5wcm9qZWN0Lm9yZzwvYT48c3BhbiBjbGFzcz0iQXBwbGUt Y29udmVydGVkLXNwYWNlIj4mbmJzcDs8L3NwYW4+WzxhIGhyZWY9Im1haWx0bzphZHZpc29yeS1i b2FyZC1ib3VuY2VzQGxpc3RzLnhlbnByb2plY3Qub3JnIiB0YXJnZXQ9Il9ibGFuayI+YWR2aXNv cnktYm9hcmQtYm91bmNlc0BsaXN0cy54ZW5wcm9qZWN0Lm9yZzwvYT5dDQogb24gYmVoYWxmIG9m IFNhcmFoIENvbndheSBbPGEgaHJlZj0ibWFpbHRvOnNjb253YXlAbGludXhmb3VuZGF0aW9uLm9y ZyIgdGFyZ2V0PSJfYmxhbmsiPnNjb253YXlAbGludXhmb3VuZGF0aW9uLm9yZzwvYT5dPGJyPg0K PGI+U2VudDo8L2I+PHNwYW4+Jm5ic3A7PC9zcGFuPldlZG5lc2RheSwgTWFyY2ggMDUsIDIwMTQg OTozMyBBTTxicj4NCjxiPlRvOjwvYj48c3Bhbj4mbmJzcDs8L3NwYW4+QWR2aXNvcnktYm9hcmQg ZGlzY3Vzc2lvbnM8YnI+DQo8Yj5TdWJqZWN0OjwvYj48c3Bhbj4mbmJzcDs8L3NwYW4+UmU6IFtB ZHZpc29yeS1ib2FyZF0gWGVuIFByb2plY3QgNC40IFJlbGVhc2U8YnI+DQo8L2ZvbnQ+PGJyPg0K PC9kaXY+DQo8ZGl2PjwvZGl2Pg0KPC9kaXY+DQo8L2Rpdj4NCjxkaXY+DQo8ZGl2Pg0KPGRpdiBj bGFzcz0ieF9oNSI+DQo8ZGl2IGRpcj0ibHRyIj5NYXJrIGV0IGFsbCwmbmJzcDsNCjxkaXY+PGJy Pg0KPC9kaXY+DQo8ZGl2PjxzcGFuIHN0eWxlPSJmb250LWZhbWlseTogYXJpYWwsIHNhbnMtc2Vy aWY7IGZvbnQtc2l6ZTogMTNweDsiPkkgYWdyZWUgdGhhdCB1c2luZyBYZW4gUHJvamVjdCBpcyBh IG1vdXRoZnVsLiBHPC9zcGFuPjxmb250IGZhY2U9ImFyaWFsLHNhbnMtc2VyaWYiPml2ZW4gdGhh dCB0aGVyZSBpcyBjbG9zZSBvdmVybGFwIGFuZCZuYnNwO29jY2FzaW9uYWwmbmJzcDticmFuZGlu ZyBjb25mdXNpb24gd2l0aCBDaXRyaXggcHJvZHVjdHMsIGlmIHdlIGFkZCBhbm90aGVyDQogbmV3 IHRlcm0gb3I8L2ZvbnQ+PHNwYW4gc3R5bGU9ImNvbG9yOiByZ2IoNjgsIDY4LCA2OCk7IGZvbnQt ZmFtaWx5OiBhcmlhbCwgc2Fucy1zZXJpZjsgZm9udC13ZWlnaHQ6IGJvbGQ7IGxpbmUtaGVpZ2h0 OiAxNnB4OyI+Jm5ic3A7PC9zcGFuPmFjcm9ueW08c3BhbiBzdHlsZT0iZm9udC1mYW1pbHk6IGFy aWFsLCBzYW5zLXNlcmlmOyI+Jm5ic3A7aW50byB0aGUgbWl4LCB3ZSdsbCB3YW50IHRvIGJlIGRp bGlnZW50IGFib3V0IGJlaW5nIGNvbnNpc3RlbnQgaW4gYmxvZ3MsDQogcHJlc2VudGF0aW9ucywg bmV3cyByZWxlYXNlcywgd2ViIHNpdGUgY29weSwgY3VzdG9tZXIgdGVzdGltb25pYWxzIGV0Yy4m bmJzcDs8L3NwYW4+PC9kaXY+DQo8ZGl2PjxzcGFuIHN0eWxlPSJmb250LWZhbWlseTogYXJpYWws IHNhbnMtc2VyaWY7Ij48YnI+DQo8L3NwYW4+PC9kaXY+DQo8ZGl2PjxzcGFuIHN0eWxlPSJmb250 LWZhbWlseTogYXJpYWwsIHNhbnMtc2VyaWY7Ij5Gb3IgdGhlIHNha2Ugb2YmbmJzcDs8L3NwYW4+ PGZvbnQgZmFjZT0iYXJpYWwsc2Fucy1zZXJpZiI+c2ltcGxpY2l0eSwgaG93IGFib3V0IHVzaW5n IFhQSCAtIGFsbCB1cHBlcmNhc2UgLSBvbiBzZWNvbmQgcmVmZXJlbmNlPyBUaG91Z2h0cz88L2Zv bnQ+PC9kaXY+DQo8ZGl2Pjxmb250IGZhY2U9ImFyaWFsLHNhbnMtc2VyaWYiPjxicj4NCjwvZm9u dD48L2Rpdj4NCjxkaXY+PGZvbnQgZmFjZT0iYXJpYWwsc2Fucy1zZXJpZiI+VGhhbmtzLDwvZm9u dD48L2Rpdj4NCjxkaXY+PGZvbnQgZmFjZT0iYXJpYWwsc2Fucy1zZXJpZiI+PGJyPg0KPC9mb250 PjwvZGl2Pg0KPGRpdj48Zm9udCBmYWNlPSJhcmlhbCxzYW5zLXNlcmlmIj48YnI+DQo8L2ZvbnQ+ PC9kaXY+DQo8ZGl2PjxzcGFuIHN0eWxlPSJmb250LWZhbWlseTogYXJpYWwsIHNhbnMtc2VyaWY7 IGZvbnQtc2l6ZTogMTNweDsiPjxicj4NCjwvc3Bhbj48L2Rpdj4NCjxkaXY+PHNwYW4gc3R5bGU9 ImZvbnQtZmFtaWx5OiBhcmlhbCwgc2Fucy1zZXJpZjsgZm9udC1zaXplOiAxM3B4OyI+PGJyPg0K PC9zcGFuPjwvZGl2Pg0KPC9kaXY+DQo8L2Rpdj4NCjwvZGl2Pg0KPGRpdiBjbGFzcz0ieF9nbWFp bF9leHRyYSI+PGJyPg0KPGJyPg0KPGRpdiBjbGFzcz0ieF9nbWFpbF9xdW90ZSI+DQo8ZGl2Pg0K PGRpdiBjbGFzcz0ieF9oNSI+T24gV2VkLCBNYXIgNSwgMjAxNCBhdCA5OjE4IEFNLCBNYXJrIEhp bmtsZTxzcGFuPiZuYnNwOzwvc3Bhbj48c3BhbiBkaXI9Imx0ciI+Jmx0OzxhIGhyZWY9Im1haWx0 bzpNYXJrLkhpbmtsZUBjaXRyaXguY29tIiB0YXJnZXQ9Il9ibGFuayI+TWFyay5IaW5rbGVAY2l0 cml4LmNvbTwvYT4mZ3Q7PC9zcGFuPjxzcGFuPiZuYnNwOzwvc3Bhbj53cm90ZTo8YnI+DQo8L2Rp dj4NCjwvZGl2Pg0KPGJsb2NrcXVvdGUgY2xhc3M9InhfZ21haWxfcXVvdGUiIHN0eWxlPSJtYXJn aW46IDBweCAwcHggMHB4IDAuOGV4OyBib3JkZXItbGVmdC13aWR0aDogMXB4OyBib3JkZXItbGVm dC1jb2xvcjogcmdiKDIwNCwgMjA0LCAyMDQpOyBib3JkZXItbGVmdC1zdHlsZTogc29saWQ7IHBh ZGRpbmctbGVmdDogMWV4OyI+DQo8ZGl2IHN0eWxlPSJ3b3JkLXdyYXA6IGJyZWFrLXdvcmQ7Ij5I b3cgYWJvdXQgdGhpcyBjb252ZW50aW9uIG9ubHkgc2F5IFhlbiBQcm9qZWN0IGFuZCBYZW4gUHJv amVjdCBoeXBlcnZpc29yIG9uY2UgdGhlbi4gVXNlIHRoZSBhYmJyZXZpYXRpb24gWFBoIHRocm91 Z2hvdXQgdGhlIHJlbGVhc2UuIEp1c3Qgc25pcHBpbmcgTWF0dD8/IGV4YW1wbGUgdG8gbWFrZSB0 aGUgcG9pbnQuIEkgd291bGQgZ3Vlc3MgdGhhdCB0aGUgYXBwcm9wcmlhdGUgY2FwaXRhbGl6YXRp b24NCiB3b3VsZCBiZSBsb3dlciBjYXNlIGZvciB0aGUgd29yZCBoeXBlcnZpc29yLiZuYnNwOw0K PGRpdj48YnI+DQo8L2Rpdj4NCjxkaXY+TWFyayZuYnNwOzxicj4NCjxkaXY+PGJyPg0KPC9kaXY+ DQo8ZGl2Pg0KPGRpdiBjbGFzcz0iIj4NCjxibG9ja3F1b3RlIHR5cGU9ImNpdGUiPg0KPGRpdiBz dHlsZT0iZGlyZWN0aW9uOiBsdHI7IGZvbnQtZmFtaWx5OiBWZXJkYW5hOyBmb250LXNpemU6IDEw cHQ7Ij4NCjxibG9ja3F1b3RlIHN0eWxlPSJtYXJnaW46IDBweCAwcHggMHB4IDQwcHg7IGJvcmRl cjogbm9uZTsgcGFkZGluZzogMHB4OyI+DQo8cCBhbGlnbj0iTEVGVCIgc3R5bGU9Im1hcmdpbi1i b3R0b206IDAuMTVpbjsiPjxzcGFuIGxhbmc9ImVuLVVTIj5UaGUmbmJzcDs8c3BhbiBzdHlsZT0i YmFja2dyb3VuZC1jb2xvcjogcmdiKDI1NSwgMjU1LCAwKTsiPlhlbiBQcm9qZWN0PC9zcGFuPiwg YSBDb2xsYWJvcmF0aXZlIFByb2plY3QgaG9zdGVkIGF0IFRoZSBMaW51eCBGb3VuZGF0aW9uLCB0 b2RheSBhbm5vdW5jZWQgYXZhaWxhYmlsaXR5IG9mIHRoZSZuYnNwOzxzcGFuIHN0eWxlPSJiYWNr Z3JvdW5kLWNvbG9yOiByZ2IoMjU1LCAyNTUsIDApOyI+WGVuDQogUHJvamVjdDwvc3Bhbj4mbmJz cDtoeXBlcnZpc29yKFhQaCkgNC40IHdpdGggZW5oYW5jZWQmbmJzcDtBUk0gc3VwcG9ydC48L3Nw YW4+PC9wPg0KPC9ibG9ja3F1b3RlPg0KPC9kaXY+DQo8L2Jsb2NrcXVvdGU+DQo8L2Rpdj4NCjxk aXY+DQo8YmxvY2txdW90ZSB0eXBlPSJjaXRlIj4NCjxkaXYgc3R5bGU9ImRpcmVjdGlvbjogbHRy OyBmb250LWZhbWlseTogVmVyZGFuYTsgZm9udC1zaXplOiAxMHB0OyI+DQo8YmxvY2txdW90ZSBz dHlsZT0ibWFyZ2luOiAwcHggMHB4IDBweCA0MHB4OyBib3JkZXI6IG5vbmU7IHBhZGRpbmc6IDBw eDsiPg0KPHAgYWxpZ249IkxFRlQiIHN0eWxlPSJtYXJnaW4tYm90dG9tOiAwLjE1aW47Ij48c3Bh biBsYW5nPSJlbi1VUyI+WFBoIDQuNCBmdXJ0aGVyIGFkdmFuY2VzIHRoZSBQcm9qZWN0PC9zcGFu PjxzcGFuIGxhbmc9ImZyLUZSIj4/Py9zcGFuJmd0OzxzcGFuIGxhbmc9ImVuLVVTIj5zIHBvc2l0 aW9uIGFzIGEgZmFzdCwgc2NhbGFibGUsIHNlY3VyZSB2aXJ0dWFsaXphdGlvbiBlbmdpbmUgZm9y IHRoZSBpbmR1c3RyeTwvc3Bhbj48c3BhbiBsYW5nPSJmci1GUiI+Pz8vc3BhbiZndDs8c3BhbiBs YW5nPSJlbi1VUyI+cw0KIGJyb2FkZXN0IHJhbmdlIG9mIHNlcnZlciwgUEMgY2hpcHNldHMgYW5k IG5leHQtZ2VuZXJhdGlvbiBsb3ctcG93ZXIgc3lzdGVtcyBvbiBjaGlwcyAoU29DKS48L3NwYW4+ PC9zcGFuPjwvc3Bhbj48L3A+DQo8L2Jsb2NrcXVvdGU+DQo8L2Rpdj4NCjwvYmxvY2txdW90ZT4N CjwvZGl2Pg0KPGRpdj48YnI+DQo8ZGl2Pg0KPGRpdiBjbGFzcz0iIj4NCjxkaXY+T24gTWFyIDQs IDIwMTQsIGF0IDQ6MDEgUE0sIFdpbHNvbiwgTWF0dCAmbHQ7PGEgaHJlZj0ibWFpbHRvOm1zd0Bh bWF6b24uY29tIiB0YXJnZXQ9Il9ibGFuayI+bXN3QGFtYXpvbi5jb208L2E+Jmd0OyB3cm90ZTo8 L2Rpdj4NCjxicj4NCjwvZGl2Pg0KPGJsb2NrcXVvdGUgdHlwZT0iY2l0ZSI+DQo8ZGl2IHN0eWxl PSJmb250LWZhbWlseTogSGVsdmV0aWNhOyBmb250LXNpemU6IDEycHg7IGZvbnQtc3R5bGU6IG5v cm1hbDsgZm9udC12YXJpYW50OiBub3JtYWw7IGZvbnQtd2VpZ2h0OiBub3JtYWw7IGxldHRlci1z cGFjaW5nOiBub3JtYWw7IGxpbmUtaGVpZ2h0OiBub3JtYWw7IHRleHQtYWxpZ246IHN0YXJ0OyB0 ZXh0LWluZGVudDogMHB4OyB0ZXh0LXRyYW5zZm9ybTogbm9uZTsgd2hpdGUtc3BhY2U6IG5vcm1h bDsgd29yZC1zcGFjaW5nOiAwcHg7Ij4NCjxkaXYgc3R5bGU9ImRpcmVjdGlvbjogbHRyOyBmb250 LWZhbWlseTogVmVyZGFuYTsgZm9udC1zaXplOiAxMHB0OyI+DQo8ZGl2IGNsYXNzPSIiPlRoZSAm cXVvdDtYZW4gUHJvamVjdCZxdW90OyB0ZXJtaW5vbG9neSBtYWtlcyB0aGUgbWVzc2FnZSBleHRy ZW1lbHkgY3VtYmVyc29tZS4NCjxkaXY+PGJyPg0KPC9kaXY+DQo8YmxvY2txdW90ZSBzdHlsZT0i bWFyZ2luOiAwcHggMHB4IDBweCA0MHB4OyBib3JkZXI6IG5vbmU7IHBhZGRpbmc6IDBweDsiPg0K PHAgYWxpZ249IkxFRlQiIHN0eWxlPSJtYXJnaW4tYm90dG9tOiAwLjE1aW47Ij48c3BhbiBsYW5n PSJlbi1VUyI+VGhlPHNwYW4+Jm5ic3A7PC9zcGFuPjxzcGFuIHN0eWxlPSJiYWNrZ3JvdW5kLWNv bG9yOiByZ2IoMjU1LCAyNTUsIDApOyI+WGVuIFByb2plY3Q8L3NwYW4+LCBhIENvbGxhYm9yYXRp dmUgUHJvamVjdCBob3N0ZWQgYXQgVGhlIExpbnV4IEZvdW5kYXRpb24sIHRvZGF5IGFubm91bmNl ZCBhdmFpbGFiaWxpdHkgb2YgdGhlPHNwYW4+Jm5ic3A7PC9zcGFuPjxzcGFuIHN0eWxlPSJiYWNr Z3JvdW5kLWNvbG9yOiByZ2IoMjU1LCAyNTUsIDApOyI+WGVuDQogUHJvamVjdDwvc3Bhbj48c3Bh bj4mbmJzcDs8L3NwYW4+NC40IEh5cGVydmlzb3Igd2l0aCBlbmhhbmNlZDxzcGFuPiZuYnNwOzwv c3Bhbj48c3BhbiBzdHlsZT0iYmFja2dyb3VuZC1jb2xvcjogcmdiKDI1NSwgMjU1LCAwKTsiPlhl biBQcm9qZWN0PC9zcGFuPi1vbi1BUk0gc3VwcG9ydC48L3NwYW4+PC9wPg0KPC9ibG9ja3F1b3Rl Pg0KV2h5IG5vdCBqdXN0IHNheSAmcXVvdDtlbmhhbmNlZCBBUk0gc3VwcG9ydCZxdW90Oz8gV2Ug c2hvdWxkIGFkb3B0IHNvbWUgdXNhZ2UgZ3VpZGVsaW5lcyBmb3Igc3ViLXByb2plY3QgYnJhbmRp bmcuIFdlIHNob3VsZG4ndCBpbnNlcnQgd29yZHMvbnVtYmVycyBiZXR3ZWVuICZxdW90O1hlbiBQ cm9qZWN0JnF1b3Q7IGFuZCBhIHN1Yi1wcm9qZWN0IG5hbWUuDQo8ZGl2Pjxicj4NCjwvZGl2Pg0K PGJsb2NrcXVvdGUgc3R5bGU9Im1hcmdpbjogMHB4IDBweCAwcHggNDBweDsgYm9yZGVyOiBub25l OyBwYWRkaW5nOiAwcHg7Ij5UaGUgWGVuIFByb2plY3QsIGEgQ29sbGFib3JhdGl2ZSBQcm9qZWN0 IGhvc3RlZCBhdCBUaGUgTGludXggRm91bmRhdGlvbiwgdG9kYXkgYW5ub3VuY2VkIHZlcnNpb24g NC40IG9mIHRoZSBYZW4gUHJvamVjdCBIeXBlcnZpc29yIHdpdGggZW5oYW5jZWQgQVJNIHN1cHBv cnQuPC9ibG9ja3F1b3RlPg0KPGRpdj48YnI+DQo8L2Rpdj4NCjxkaXY+b3I8L2Rpdj4NCjxkaXY+ DQo8YmxvY2txdW90ZSBzdHlsZT0ibWFyZ2luOiAwcHggMHB4IDBweCA0MHB4OyBib3JkZXI6IG5v bmU7IHBhZGRpbmc6IDBweDsiPlRoZSBYZW4gUHJvamVjdCwgYSBDb2xsYWJvcmF0aXZlIFByb2pl Y3QgaG9zdGVkIGF0IFRoZSBMaW51eCBGb3VuZGF0aW9uLCB0b2RheSBhbm5vdW5jZWQgdGhlIHJl bGVhc2Ugb2YgWGVuIFByb2plY3QgSHlwZXJ2aXNvciA0LjQgd2l0aCBlbmhhbmNlZCBBUk0gc3Vw cG9ydC48L2Jsb2NrcXVvdGU+DQo8YmxvY2txdW90ZSBzdHlsZT0ibWFyZ2luOiAwcHggMHB4IDBw eCA0MHB4OyBib3JkZXI6IG5vbmU7IHBhZGRpbmc6IDBweDsiPjxicj4NCjwvYmxvY2txdW90ZT4N CkxhdGVyIG9uLCB0aGlzIHJlbGVhc2UgaXMgY2FsbGVkICZxdW90O1hlbiBQcm9qZWN0IDQuNCZx dW90Ow0KPGRpdj48L2Rpdj4NCjwvZGl2Pg0KPGRpdj48YnI+DQo8L2Rpdj4NCjwvZGl2Pg0KPGJs b2NrcXVvdGUgc3R5bGU9Im1hcmdpbjogMHB4IDBweCAwcHggNDBweDsgYm9yZGVyOiBub25lOyBw YWRkaW5nOiAwcHg7Ij4NCjxwIGFsaWduPSJMRUZUIiBzdHlsZT0ibWFyZ2luLWJvdHRvbTogMC4x NWluOyI+PHNwYW4gbGFuZz0iZW4tVVMiPlRoZSBYZW4gUHJvamVjdCA0LjQgcmVsZWFzZSBmdXJ0 aGVyIGFkdmFuY2VzIHRoZSBQcm9qZWN0PC9zcGFuPjxzcGFuIGxhbmc9ImZyLUZSIj4/Py9zcGFu Jmd0OzxzcGFuIGxhbmc9ImVuLVVTIj5zIHBvc2l0aW9uIGFzIGEgZmFzdCwgc2NhbGFibGUsIHNl Y3VyZSB2aXJ0dWFsaXphdGlvbiBlbmdpbmUgZm9yIHRoZSBpbmR1c3RyeTwvc3Bhbj48c3BhbiBs YW5nPSJmci1GUiI+Pz8vc3BhbiZndDs8c3BhbiBsYW5nPSJlbi1VUyI+cw0KIGJyb2FkZXN0IHJh bmdlIG9mIHNlcnZlciwgUEMgY2hpcHNldHMgYW5kIG5leHQtZ2VuZXJhdGlvbiBsb3ctcG93ZXIg c3lzdGVtcyBvbiBjaGlwcyAoU29DKS48L3NwYW4+PC9zcGFuPjwvc3Bhbj48L3A+DQo8L2Jsb2Nr cXVvdGU+DQo8ZGl2Pg0KPGRpdiBjbGFzcz0ieF9oNSI+DQo8ZGl2PlRoYXQgZG9lc24ndCBmbG93 IHdlbGwuIEhvdyBhcmUgd2UgcmVsZWFzaW5nIHZlcnNpb24gNC40IG9mIGEgcHJvamVjdD8gRG8g d2Ugd2FudCB0byBjYWxsIHRoZSBvdmVyYWxsIHJlbGVhc2UgJnF1b3Q7WGVuIFByb2plY3QgQXJj aGl0ZWN0dXJlIDQuNCZxdW90Oz8gT3IgZG8gd2UgbmVlZCB0byBjb21lIHVwIHdpdGggc29tZSBv dGhlciBwcm9qZWN0IGJyYW5kaW5nPzwvZGl2Pg0KPGRpdj48YnI+DQo8L2Rpdj4NCjxkaXY+LS1t c3c8L2Rpdj4NCjxkaXY+PGJyPg0KPGRpdj4NCjxkaXYgc3R5bGU9ImZvbnQtZmFtaWx5OiAnVGlt ZXMgTmV3IFJvbWFuJzsgZm9udC1zaXplOiAxNnB4OyI+DQo8aHI+DQo8ZGl2IHN0eWxlPSJkaXJl Y3Rpb246IGx0cjsiPjxmb250IGZhY2U9IlRhaG9tYSI+PGI+RnJvbTo8L2I+PHNwYW4+Jm5ic3A7 PC9zcGFuPjxhIGhyZWY9Im1haWx0bzphZHZpc29yeS1ib2FyZC1ib3VuY2VzQGxpc3RzLnhlbnBy b2plY3Qub3JnIiB0YXJnZXQ9Il9ibGFuayI+YWR2aXNvcnktYm9hcmQtYm91bmNlc0BsaXN0cy54 ZW5wcm9qZWN0Lm9yZzwvYT48c3Bhbj4mbmJzcDs8L3NwYW4+WzxhIGhyZWY9Im1haWx0bzphZHZp c29yeS1ib2FyZC1ib3VuY2VzQGxpc3RzLnhlbnByb2plY3Qub3JnIiB0YXJnZXQ9Il9ibGFuayI+ YWR2aXNvcnktYm9hcmQtYm91bmNlc0BsaXN0cy54ZW5wcm9qZWN0Lm9yZzwvYT5dDQogb24gYmVo YWxmIG9mIFNhcmFoIENvbndheSBbPGEgaHJlZj0ibWFpbHRvOnNjb253YXlAbGludXhmb3VuZGF0 aW9uLm9yZyIgdGFyZ2V0PSJfYmxhbmsiPnNjb253YXlAbGludXhmb3VuZGF0aW9uLm9yZzwvYT5d PGJyPg0KPGI+U2VudDo8L2I+PHNwYW4+Jm5ic3A7PC9zcGFuPlR1ZXNkYXksIE1hcmNoIDA0LCAy MDE0IDEyOjE2IFBNDQo8ZGl2Pjxicj4NCjxiPlRvOjwvYj48c3Bhbj4mbmJzcDs8L3NwYW4+PGEg aHJlZj0ibWFpbHRvOmFkdmlzb3J5LWJvYXJkQGxpc3RzLnhlbnByb2plY3Qub3JnIiB0YXJnZXQ9 Il9ibGFuayI+YWR2aXNvcnktYm9hcmRAbGlzdHMueGVucHJvamVjdC5vcmc8L2E+PGJyPg0KPGI+ U3ViamVjdDo8L2I+PHNwYW4+Jm5ic3A7PC9zcGFuPltBZHZpc29yeS1ib2FyZF0gWGVuIFByb2pl Y3QgNC40IFJlbGVhc2U8YnI+DQo8L2Rpdj4NCjwvZm9udD48YnI+DQo8L2Rpdj4NCjxkaXY+DQo8 ZGl2PjwvZGl2Pg0KPGRpdj4NCjxkaXYgZGlyPSJsdHIiPkhpIGV2ZXJ5b25lLg0KPGRpdj48YnI+ DQo8L2Rpdj4NCjxkaXY+QXR0YWNoZWQgaXMgdGhlIFhlbiBQcm9qZWN0IDQuNCBuZXdzIHJlbGVh c2UgYW5ub3VjZW1lbnQgdGhhdCB3aWxsIGdvIG91dCBhdCA4IGEubS4gRVQgb24gTW9uZGF5LCBN YXJjaCAxMC4mbmJzcDs8L2Rpdj4NCjxkaXY+PGJyPg0KPC9kaXY+DQo8ZGl2PklmIHlvdSBoYXZl IGFueSBhZGRpdGlvbmFsIGNvbW1lbnRzIG9yIGVkaXRzLCBwbGVhc2UgZ2V0IGJhY2sgdG8gbWUg YnkgVGh1cnNkYXkgbW9ybmluZyBhdCB0aGUgbGF0ZXN0LiZuYnNwOzwvZGl2Pg0KPGRpdj48YnI+ DQo8L2Rpdj4NCjxkaXY+VGhhbmtzLCZuYnNwOzwvZGl2Pg0KPGRpdj48YnIgY2xlYXI9ImFsbCI+ DQo8ZGl2Pjxicj4NCjwvZGl2Pg0KLS08c3Bhbj4mbmJzcDs8L3NwYW4+PGJyPg0KPGRpdiBkaXI9 Imx0ciI+DQo8ZGl2PlNhcmFoIENvbndheTxicj4NCjwvZGl2Pg0KPGRpdj5QUiBNYW5hZ2VyPC9k aXY+DQo8ZGl2PlRoZSBMaW51eCBGb3VuZGF0aW9uPGJyPg0KPGEgaHJlZj0ibWFpbHRvOnNjb253 YXlAbGludXhmb3VuZGF0aW9uLm9yZyIgdGFyZ2V0PSJfYmxhbmsiPnNjb253YXlAbGludXhmb3Vu ZGF0aW9uLm9yZzwvYT48L2Rpdj4NCjxkaXY+PGEgaHJlZj0idGVsOiUyODk3OCUyOSUyMDU3OC01 MzAwIiB2YWx1ZT0iJiM0MzsxOTc4NTc4NTMwMCIgdGFyZ2V0PSJfYmxhbmsiPig5NzgpIDU3OC01 MzAwPC9hPjxzcGFuPiZuYnNwOzwvc3Bhbj4mbmJzcDtDZWxsPC9kaXY+DQo8ZGl2PlNreXBlOiAm bmJzcDtzYXJhaC5rLmNvbndheTwvZGl2Pg0KPC9kaXY+DQo8L2Rpdj4NCjwvZGl2Pg0KPC9kaXY+ DQo8L2Rpdj4NCjwvZGl2Pg0KPC9kaXY+DQo8L2Rpdj4NCjwvZGl2Pg0KPC9kaXY+DQo8L2Rpdj4N CjxkaXY+DQo8ZGl2IGNsYXNzPSJ4X2g1Ij5fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fXzxicj4NCkFkdmlzb3J5LWJvYXJkIG1haWxpbmcgbGlzdDxicj4NCjxh IGhyZWY9Im1haWx0bzpBZHZpc29yeS1ib2FyZEBsaXN0cy54ZW5wcm9qZWN0Lm9yZyIgdGFyZ2V0 PSJfYmxhbmsiPkFkdmlzb3J5LWJvYXJkQGxpc3RzLnhlbnByb2plY3Qub3JnPC9hPjxicj4NCjxh IGhyZWY9Imh0dHA6Ly9saXN0cy54ZW5wcm9qZWN0Lm9yZy9jZ2ktYmluL21haWxtYW4vbGlzdGlu Zm8vYWR2aXNvcnktYm9hcmQiIHRhcmdldD0iX2JsYW5rIj5odHRwOi8vbGlzdHMueGVucHJvamVj dC5vcmcvY2dpLWJpbi9tYWlsbWFuL2xpc3RpbmZvL2Fkdmlzb3J5LWJvYXJkPC9hPjwvZGl2Pg0K PC9kaXY+DQo8L2Rpdj4NCjwvYmxvY2txdW90ZT4NCjwvZGl2Pg0KPGJyPg0KPC9kaXY+DQo8L2Rp dj4NCjwvZGl2Pg0KPC9kaXY+DQo8ZGl2Pg0KPGRpdiBjbGFzcz0ieF9oNSI+PGJyPg0KX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX188YnI+DQpBZHZpc29yeS1i b2FyZCBtYWlsaW5nIGxpc3Q8YnI+DQo8YSBocmVmPSJtYWlsdG86QWR2aXNvcnktYm9hcmRAbGlz dHMueGVucHJvamVjdC5vcmciIHRhcmdldD0iX2JsYW5rIj5BZHZpc29yeS1ib2FyZEBsaXN0cy54 ZW5wcm9qZWN0Lm9yZzwvYT48YnI+DQo8YSBocmVmPSJodHRwOi8vbGlzdHMueGVucHJvamVjdC5v cmcvY2dpLWJpbi9tYWlsbWFuL2xpc3RpbmZvL2Fkdmlzb3J5LWJvYXJkIiB0YXJnZXQ9Il9ibGFu ayI+aHR0cDovL2xpc3RzLnhlbnByb2plY3Qub3JnL2NnaS1iaW4vbWFpbG1hbi9saXN0aW5mby9h ZHZpc29yeS1ib2FyZDwvYT48YnI+DQo8YnI+DQo8L2Rpdj4NCjwvZGl2Pg0KPC9ibG9ja3F1b3Rl Pg0KPC9kaXY+DQo8ZGl2Pg0KPGRpdiBjbGFzcz0ieF9oNSI+PGJyPg0KPGJyIGNsZWFyPSJhbGwi Pg0KPGRpdj48YnI+DQo8L2Rpdj4NCi0tPHNwYW4+Jm5ic3A7PC9zcGFuPjxicj4NCjxkaXYgZGly PSJsdHIiPg0KPGRpdj5TYXJhaCBDb253YXk8YnI+DQo8L2Rpdj4NCjxkaXY+UFIgTWFuYWdlcjwv ZGl2Pg0KPGRpdj5UaGUgTGludXggRm91bmRhdGlvbjxicj4NCjxhIGhyZWY9Im1haWx0bzpzY29u d2F5QGxpbnV4Zm91bmRhdGlvbi5vcmciIHRhcmdldD0iX2JsYW5rIj5zY29ud2F5QGxpbnV4Zm91 bmRhdGlvbi5vcmc8L2E+PC9kaXY+DQo8ZGl2PjxhIGhyZWY9InRlbDolMjg5NzglMjklMjA1Nzgt NTMwMCIgdmFsdWU9IiYjNDM7MTk3ODU3ODUzMDAiIHRhcmdldD0iX2JsYW5rIj4oOTc4KSA1Nzgt NTMwMDwvYT48c3BhbiBjbGFzcz0iQXBwbGUtY29udmVydGVkLXNwYWNlIj4mbmJzcDs8L3NwYW4+ Jm5ic3A7Q2VsbDwvZGl2Pg0KPGRpdj5Ta3lwZTogJm5ic3A7c2FyYWguay5jb253YXk8L2Rpdj4N CjwvZGl2Pg0KPC9kaXY+DQo8L2Rpdj4NCjwvZGl2Pg0KPC9kaXY+DQo8L2Rpdj4NCjwvZGl2Pg0K PC9kaXY+DQo8L2Rpdj4NCjwvZGl2Pg0KPC9kaXY+DQo8L2Rpdj4NCjxkaXY+DQo8ZGl2IGNsYXNz PSJ4X2g1Ij5fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXzxi cj4NCkFkdmlzb3J5LWJvYXJkIG1haWxpbmcgbGlzdDxicj4NCjxhIGhyZWY9Im1haWx0bzpBZHZp c29yeS1ib2FyZEBsaXN0cy54ZW5wcm9qZWN0Lm9yZyIgdGFyZ2V0PSJfYmxhbmsiPkFkdmlzb3J5 LWJvYXJkQGxpc3RzLnhlbnByb2plY3Qub3JnPC9hPjxicj4NCjxhIGhyZWY9Imh0dHA6Ly9saXN0 cy54ZW5wcm9qZWN0Lm9yZy9jZ2ktYmluL21haWxtYW4vbGlzdGluZm8vYWR2aXNvcnktYm9hcmQi IHRhcmdldD0iX2JsYW5rIj5odHRwOi8vbGlzdHMueGVucHJvamVjdC5vcmcvY2dpLWJpbi9tYWls bWFuL2xpc3RpbmZvL2Fkdmlzb3J5LWJvYXJkPC9hPjwvZGl2Pg0KPC9kaXY+DQo8L2Rpdj4NCjwv YmxvY2txdW90ZT4NCjwvZGl2Pg0KPGJyPg0KPC9kaXY+DQo8L2Rpdj4NCjwvYmxvY2txdW90ZT4N Cjwvc3Bhbj48YnI+DQo8Zm9udCBmYWNlPSJBcmlhbCI+LS0gSU1QT1JUQU5UIE5PVElDRTogVGhl IGNvbnRlbnRzIG9mIHRoaXMgZW1haWwgYW5kIGFueSBhdHRhY2htZW50cyBhcmUgY29uZmlkZW50 aWFsIGFuZCBtYXkgYWxzbyBiZSBwcml2aWxlZ2VkLiBJZiB5b3UgYXJlIG5vdCB0aGUgaW50ZW5k ZWQgcmVjaXBpZW50LCBwbGVhc2Ugbm90aWZ5IHRoZSBzZW5kZXIgaW1tZWRpYXRlbHkgYW5kIGRv IG5vdCBkaXNjbG9zZSB0aGUgY29udGVudHMgdG8gYW55IG90aGVyIHBlcnNvbiwNCiB1c2UgaXQg Zm9yIGFueSBwdXJwb3NlLCBvciBzdG9yZSBvciBjb3B5IHRoZSBpbmZvcm1hdGlvbiBpbiBhbnkg bWVkaXVtLiBUaGFuayB5b3UuPGJyPg0KPGJyPg0KQVJNIExpbWl0ZWQsIFJlZ2lzdGVyZWQgb2Zm aWNlIDExMCBGdWxib3VybiBSb2FkLCBDYW1icmlkZ2UgQ0IxIDlOSiwgUmVnaXN0ZXJlZCBpbiBF bmdsYW5kICZhbXA7IFdhbGVzLCBDb21wYW55IE5vOiAyNTU3NTkwPGJyPg0KQVJNIEhvbGRpbmdz IHBsYywgUmVnaXN0ZXJlZCBvZmZpY2UgMTEwIEZ1bGJvdXJuIFJvYWQsIENhbWJyaWRnZSBDQjEg OU5KLCBSZWdpc3RlcmVkIGluIEVuZ2xhbmQgJmFtcDsgV2FsZXMsIENvbXBhbnkgTm86IDI1NDg3 ODI8YnI+DQo8L2ZvbnQ+PC9kaXY+DQo8YnI+DQpfX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fXzxicj4NCkFkdmlzb3J5LWJvYXJkIG1haWxpbmcgbGlzdDxicj4N CjxhIGhyZWY9Im1haWx0bzpBZHZpc29yeS1ib2FyZEBsaXN0cy54ZW5wcm9qZWN0Lm9yZyIgdGFy Z2V0PSJfYmxhbmsiPkFkdmlzb3J5LWJvYXJkQGxpc3RzLnhlbnByb2plY3Qub3JnPC9hPjxicj4N CjxhIGhyZWY9Imh0dHA6Ly9saXN0cy54ZW5wcm9qZWN0Lm9yZy9jZ2ktYmluL21haWxtYW4vbGlz dGluZm8vYWR2aXNvcnktYm9hcmQiIHRhcmdldD0iX2JsYW5rIj5odHRwOi8vbGlzdHMueGVucHJv amVjdC5vcmcvY2dpLWJpbi9tYWlsbWFuL2xpc3RpbmZvL2Fkdmlzb3J5LWJvYXJkPC9hPjxicj4N Cjxicj4NCjwvYmxvY2txdW90ZT4NCjwvZGl2Pg0KPGJyPg0KPGJyIGNsZWFyPSJhbGwiPg0KPGRp dj48YnI+DQo8L2Rpdj4NCi0tPHNwYW4gY2xhc3M9IkFwcGxlLWNvbnZlcnRlZC1zcGFjZSI+Jm5i c3A7PC9zcGFuPjxicj4NCjxkaXYgZGlyPSJsdHIiPg0KPGRpdj5TYXJhaCBDb253YXk8YnI+DQo8 L2Rpdj4NCjxkaXY+UFIgTWFuYWdlcjwvZGl2Pg0KPGRpdj5UaGUgTGludXggRm91bmRhdGlvbjxi cj4NCjxhIGhyZWY9Im1haWx0bzpzY29ud2F5QGxpbnV4Zm91bmRhdGlvbi5vcmciIHRhcmdldD0i X2JsYW5rIj5zY29ud2F5QGxpbnV4Zm91bmRhdGlvbi5vcmc8L2E+PC9kaXY+DQo8ZGl2Pig5Nzgp IDU3OC01MzAwICZuYnNwO0NlbGw8L2Rpdj4NCjxkaXY+U2t5cGU6ICZuYnNwO3NhcmFoLmsuY29u d2F5PC9kaXY+DQo8L2Rpdj4NCjwvZGl2Pg0KPHNwYW4+Jmx0O1hlblByb2plY3RVcGRhdGU0LjQz LjYuMjAxNCgyKWRvY3gmZ3Q7PC9zcGFuPl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fPGJyPg0KQWR2aXNvcnktYm9hcmQgbWFpbGluZyBsaXN0PGJyPg0KPGEg aHJlZj0ibWFpbHRvOkFkdmlzb3J5LWJvYXJkQGxpc3RzLnhlbnByb2plY3Qub3JnIiB0YXJnZXQ9 Il9ibGFuayI+QWR2aXNvcnktYm9hcmRAbGlzdHMueGVucHJvamVjdC5vcmc8L2E+PGJyPg0KaHR0 cDovL2xpc3RzLnhlbnByb2plY3Qub3JnL2NnaS1iaW4vbWFpbG1hbi9saXN0aW5mby9hZHZpc29y eS1ib2FyZDxicj4NCjwvYmxvY2txdW90ZT4NCjwvZGl2Pg0KPGJyPg0KPC9kaXY+DQo8L2Rpdj4N CjwvZGl2Pg0KPC9kaXY+DQo8L2Rpdj4NCjwvZGl2Pg0KX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX188YnI+DQpBZHZpc29yeS1ib2FyZCBtYWlsaW5nIGxpc3Q8 YnI+DQpBZHZpc29yeS1ib2FyZEBsaXN0cy54ZW5wcm9qZWN0Lm9yZzxicj4NCmh0dHA6Ly9saXN0 cy54ZW5wcm9qZWN0Lm9yZy9jZ2ktYmluL21haWxtYW4vbGlzdGluZm8vYWR2aXNvcnktYm9hcmQ8 L2Rpdj4NCjwvYmxvY2txdW90ZT4NCjwvZGl2Pg0KPGJyPg0KPC9kaXY+DQo8L2Rpdj4NCjwvZGl2 Pg0KPC9ib2R5Pg0KPC9odG1sPg0K --_000_25264475F9F3401FA7E8579896CD2D0Bcitrixcom_-- --===============1108833969430764246== Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Disposition: inline _______________________________________________ Advisory-board mailing list Advisory-board@lists.xenproject.org http://lists.xenproject.org/cgi-bin/mailman/listinfo/advisory-board --===============1108833969430764246==-- From advisory-board-bounces@lists.xenproject.org Fri Mar 07 21:28:07 2014 Return-path: Envelope-to: archives@lists.xenproject.org Delivery-date: Fri, 07 Mar 2014 21:28:07 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WM2JL-0002yr-2z; Fri, 07 Mar 2014 21:28:07 +0000 Received: from mail6.bemta3.messagelabs.com ([195.245.230.39]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WM2JH-0002yk-N6 for advisory-board@lists.xenproject.org; Fri, 07 Mar 2014 21:28:05 +0000 Received: from [85.158.137.68:38138] by server-7.bemta-3.messagelabs.com id AA/75-13775-3E93A135; Fri, 07 Mar 2014 21:28:03 +0000 X-Env-Sender: prvs=1364b071c=msw@amazon.com X-Msg-Ref: server-11.tower-31.messagelabs.com!1394227676!6449328!1 X-Originating-IP: [207.171.178.25] X-SpamReason: No, hits=-1.1 required=7.0 tests=BODY_RANDOM_LONG, HTML_50_60,HTML_MESSAGE,MIME_BASE64_TEXT,ML_RADAR_FP_R_14, ML_RADAR_SPEW_LINKS_23,spamassassin: X-StarScan-Received: X-StarScan-Version: 6.9.16; banners=-,-,- X-VirusChecked: Checked Received: (qmail 14602 invoked from network); 7 Mar 2014 21:27:57 -0000 Received: from smtp-fw-31001.amazon.com (HELO smtp-fw-31001.amazon.com) (207.171.178.25) by server-11.tower-31.messagelabs.com with RC4-SHA encrypted SMTP; 7 Mar 2014 21:27:57 -0000 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=amazon.com; i=@amazon.com; q=dns/txt; s=amazon201209; t=1394227678; x=1425763678; h=from:to:cc:subject:date:message-id:references: in-reply-to:mime-version; bh=Km9yVO6Y0mXaGerugqAvJnZAtJki6ANf3IqGLBqqaqc=; b=Sox2gTSt7cPmOh797Z3EI92nRwlEjlFPgA/9bK4o+NbJEmDbyvFVcdQP RgbhaqFBhAEuLiCHMx+hQ13XDoN34OC2yTzKtTIcjKrXNaPFZJku85scb SEdvBBgTauPCdA/jW9c429dvCNPJ4zSnoT7EM+lpOmo4iR/JEcikBZdOY E=; X-IronPort-AV: E=Sophos;i="4.97,610,1389744000"; d="scan'208,217";a="53354491" Received: from email-inbound-relay-64002.pdx4.amazon.com ([10.220.169.156]) by smtp-border-fw-out-31001.sea31.amazon.com with ESMTP/TLS/DHE-RSA-AES256-SHA; 07 Mar 2014 21:27:54 +0000 Received: from ex10-hub-9001.ant.amazon.com (ex10-hub-9001.ant.amazon.com [10.185.137.58]) by email-inbound-relay-64002.pdx4.amazon.com (8.14.7/8.14.7) with ESMTP id s27LRs4S022407 (version=TLSv1/SSLv3 cipher=AES128-SHA bits=128 verify=OK); Fri, 7 Mar 2014 21:27:54 GMT Received: from EX10-MBX-31008.ant.amazon.com ([fe80::e5a8:b04f:7971:238d]) by ex10-hub-9001.ant.amazon.com ([::1]) with mapi id 14.02.0342.003; Fri, 7 Mar 2014 13:27:53 -0800 From: "Wilson, Matt" To: Advisory-board discussions Thread-Topic: [Advisory-board] Xen Project 4.4 Release Thread-Index: AQHPN+bxg8mQN7iqgUivXwefXJkpb5rRZE7wgAGteoCAADaigP//gIjhgAGOnkaAAUvgAIAAgMyAgAAhlQCAAB8agP//fSBagACaLAD//6cF6A== Date: Fri, 7 Mar 2014 21:27:52 +0000 Message-ID: References: <6848793A-A83B-40A1-A40C-2AA9DCC1E80A@citrix.com> <2BCAC582-CB61-4E16-96C4-6C1AEFAF81FB@citrix.com> , <545D5AEE-789B-4534-9983-A9EA3FD1ECC1@citrix.com> , <25264475-F9F3-401F-A7E8-579896CD2D0B@citrix.com> In-Reply-To: <25264475-F9F3-401F-A7E8-579896CD2D0B@citrix.com> Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-originating-ip: [172.17.1.118] MIME-Version: 1.0 Cc: Jennifer Cloer Subject: Re: [Advisory-board] Xen Project 4.4 Release X-BeenThere: advisory-board@lists.xenproject.org X-Mailman-Version: 2.1.13 Precedence: list Reply-To: Advisory-board discussions List-Id: Advisory-board discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: multipart/mixed; boundary="===============0251026595235440716==" Sender: advisory-board-bounces@lists.xenproject.org Errors-To: advisory-board-bounces@lists.xenproject.org --===============0251026595235440716== Content-Language: en-US Content-Type: multipart/alternative; boundary="_000_F19B6D5F90FBA84A8D266DC69D10BAD52B0AE92Dex10mbx31008ant_" --_000_F19B6D5F90FBA84A8D266DC69D10BAD52B0AE92Dex10mbx31008ant_ Content-Type: text/plain; charset="big5" Content-Transfer-Encoding: base64 SW4gcGFydGljdWxhcjoNCg0KIlhlbiBQcm9qZWN0IDQuNCBIeXBlcnZpc29yIiAtPiAiWGVuIFBy b2plY3QgSHlwZXJ2aXNvciB2ZXJzaW9uIDQuNCINCg0KIlRoaXMgcmVsZWFzZSBmdXJ0aGVyIGFk dmFuY2VzIHRoZSBQcm9qZWN0oaZzIHBvc2l0aW9uIGFzIGEgZmFzdCwgc2NhbGFibGUsIHNlY3Vy ZSB2aXJ0dWFsaXphdGlvbiBlbmdpbmUgZm9yIHRoZSBpbmR1c3RyeaGmcyBicm9hZGVzdCByYW5n ZSBvZiBzZXJ2ZXIsIFBDIGNoaXBzZXRzIGFuZCBuZXh0LWdlbmVyYXRpb24gbG93LXBvd2VyIHN5 c3RlbSBvbiBjaGlwcyAoU29DKSBkZXZpY2VzLiIgIFBDIGNoaXBzZXRzPyBXb3VsZG4ndCBpdCBt YWtlIG1vcmUgc2Vuc2UgdG8gc2F5IHNvbWV0aGluZyBsaWtlICJzZXJ2ZXIsIHdvcmtzdGF0aW9u IGFuZCBsb3ctcG93ZXIgc3lzdGVtIG9uIGEgY2hpcCAoU29DKSBkZXZpY2VzIj8gTm90ZSB0aGUg ZHJvcCBvZiAibmV4dC1nZW5lcmF0aW9uIiBzaW5jZSBTb0MgaXMgcXVpdGUgZXN0YWJsaXNoZWQg dG9kYXkuDQoNCiJBZGRpdGlvbmFsbHksIGRldmVsb3BlcnMgY3JlYXRpbmcgc2VydmljZXMgYW5k IGFwcHMgd2l0aCBlbWJlZGRlZCwgbW9iaWxlIGFuZCBjbG91ZCBzeXN0ZW1zIHdpbGwgYmVuZWZp dCBmcm9tIHRoZSB1cGRhdGVkIGV2ZW50IGNoYW5uZWwgaW1wbGVtZW50YXRpb24gd2hlbiBzY2Fs aW5nIG91dCB0aGVpciBJbmZyYXN0cnVjdHVyZSBhcyBhIFNlcnZpY2Ugb2ZmZXJpbmdzLiIgImFw cHMiIC0+ICJhcHBsaWNhdGlvbnMiLg0KDQpXZSBuZWVkIHRvIGhhdmUgYSBkZWxpYmVyYXRlIGRl Y2lzaW9uIHRvIGludHJvZHVjZSAiWGVuIFByb2plY3QgQXJjaGl0ZWN0dXJlIiBpbiBvdXIgbm9t ZW5jbGF0dXJlLiBJJ20gbm90IGF3YXJlIG9mIGEgdXNlIGxpa2UgdGhpcyBpbiB0aGUgcGFzdC4N Cg0KIkFsbCB0aGUgdXNlcnNwYWNlIHRvb2xzLCBzdWNoIGFzIHRoZSB4bCBtYW5hZ2VtZW50IHRv b2wsIGFyZSA2NC1iaXQgcmVhZHkgYW5kIGNhbiBiZSB1c2VkIHRvIGNyZWF0ZSA2NC1iaXQgdmly dHVhbCBtYWNoaW5lcyBvdXQgb2YgdGhlIGJveC4iIC0gd3JpdHRlbiBsaWtlIGEgZGV2ZWxvcGVy IChubyBvZmZlbnNlIHRvIGRldmVsb3BlcnMgb24gdGhpcyBsaXN0KS4NCg0KDQoiVG9wIGNvbnRy aWJ1dG9ycyBpbmNsdWRlIEFtYXpvbiwgQU1ELCBBbmFsb2cgRGV2aWNlcywgQnJvYWRjb20sIENp dHJpeCwgRnVqaXRzdSwgSW50ZWwsIExpbmFybywgTlNBLCBPcmFjbGUsIFN1c2UsIFZlcml6b24v VGVycmVtYXJrLCBwbHVzIG51bWVyb3VzIGluZGl2aWR1YWwgYW5kIGFjYWRlbWljIGNvbnRyaWJ1 dG9ycy4gIkFtYXpvbiIgbXVzdCBiZSAiQW1hem9uIFdlYiBTZXJ2aWNlcyIuICJTdXNlIiBzaG91 bGQgYmUgIlNVU0UiLiAicGx1cyIgc2hvdWxkIGJlIHNvbWV0aGluZyBsaWtlICJhbG9uZyB3aXRo Ii4gIlRvcCBjb250cmlidXRvcnMgLi4gYWNhZGVtaWMgY29udHJpYnV0b3JzIiBpcyBhIGJpdCBy ZWR1bmRhbnQuIFBlcmhhcHMgImFjYWRlbWljIGluc3RpdHV0aW9ucyI/DQoNCg0KDQpUaGVyZSdz IGEgbG90IG9mIHJvb20gZm9yIGltcHJvdmVtZW50IG9uIHRoaXMuIEluY29ycG9yYXRpbmcgYSBm ZXcga2V5IGNoYW5nZXMgaXNuJ3QgcmVhbGx5IGdvaW5nIHRvIG1ha2UgdGhpcyBhIHF1YWxpdHkg cmVsZWFzZSB3aXRoIGEgc3Ryb25nIHN0b3J5LiBPdmVyYWxsLCBJJ20gcXVpdGUgc3VycHJpc2Vk IGFuZCBkaXNhcHBvaW50ZWQgd2l0aCB0aGUgY3VycmVudCBzdGF0ZS4NCg0KLS1tc3cNCg0KX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX18NCkZyb206IGFkdmlzb3J5LWJvYXJkLWJvdW5j ZXNAbGlzdHMueGVucHJvamVjdC5vcmcgW2Fkdmlzb3J5LWJvYXJkLWJvdW5jZXNAbGlzdHMueGVu cHJvamVjdC5vcmddIG9uIGJlaGFsZiBvZiBNYXJrIEhpbmtsZSBbTWFyay5IaW5rbGVAY2l0cml4 LmNvbV0NClNlbnQ6IEZyaWRheSwgTWFyY2ggMDcsIDIwMTQgMTA6MjcgQU0NClRvOiBBZHZpc29y eS1ib2FyZCBkaXNjdXNzaW9ucw0KQ2M6IEplbm5pZmVyIENsb2VyDQpTdWJqZWN0OiBSZTogW0Fk dmlzb3J5LWJvYXJkXSBYZW4gUHJvamVjdCA0LjQgUmVsZWFzZQ0KDQpJIGRvbqGmdCBkaXNhZ3Jl ZSB3aXRoIE1hdHQgdGhlIHRleHQgaXMgIGF3a3dhcmQgcGFydGljdWxhcmx5IGJlY2F1c2Ugb2Yg aXShpnMgaGlnaGx5IHRlY2huaWNhbCBuYXR1cmUuIERvIHlvdSBoYXZlIGFueSBzcGVjaWZpYyBm ZWVkYmFjayBmb3IgU2FyYWggdG8gaW5jb3Jwb3JhdGUuIEkgZGlkbqGmdCB3YW50IHRvIHB1c2gg dG9vIGhhcmQgc2luY2UgdGhlIGNsb2NrIGlzIHRpY2tpbmcgYnV0IHdlIHNob3VsZCBnZXQgdGhp cyByaWdodC4NCg0KR29pbmcgZm9yd2FyZCBJIHdvdWxkIGxpa2UgdG8gc3VnZ2VzdCB1c2luZyBP cmFjbGWhpnMgYnVsbGV0ZWQgbGlzdCBmb3JtYXQgZm9yIHRoZWlyIHByZXNzIHJlbGVhc2VzIHNp bmNlIHR5aW5nIHRvZ2V0aGVyIHRoZSBhY3R1YWwgbmV3cyBhbmQgdGVjaCBjb250ZW50IGludG8g YSBjb21wZWxsaW5nIG5hcnJhdGl2ZSBpcyBwcmV0dHkgdG91Z2guIEhlcmUgYW4gZXhhbXBsZSBv ZiB3aGF0IEmhpmQgcHJvcG9zZS4NCg0KaHR0cDovL3d3dy5vcmFjbGUuY29tL3VzL2NvcnBvcmF0 ZS9wcmVzcy8yMDMzMzc2DQoNClJlZ2FyZHMsIE1hcmsNCg0KDQpPbiBNYXIgNywgMjAxNCwgYXQg MTI6MTcgUE0sIFdpbHNvbiwgTWF0dCA8bXN3QGFtYXpvbi5jb20+IHdyb3RlOg0KDQpJJ20gbm90 IHNhdGlzZmllZCB3aXRoIHRoZSBxdWFsaXR5IG9mIHRoaXMgdGV4dCAodHlwb3MsIGV0Yy4pIGdp dmVuIHRoZSBwbGFuIHRvIHB1dCBpdCBvbiB0aGUgd2lyZSBNb25kYXkuIFdlIHN0aWxsIGRvbid0 IGhhdmUgYSBzdHJvbmcgbWVzc2FnZSBhbmQgYSBwbGFuIG9uIGhvdyB3ZSBwbGFuIHRvIGJyYW5k IHRoZSB0ZWNobm9sb2dpZXMgdGhhdCBhcmUgcHJvZHVjZWQgYnkgdGhlIGNvbW11bml0eS4NCg0K LS1tc3cNCg0KX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18NCkZyb206IGFkdmlzb3J5 LWJvYXJkLWJvdW5jZXNAbGlzdHMueGVucHJvamVjdC5vcmcgW2Fkdmlzb3J5LWJvYXJkLWJvdW5j ZXNAbGlzdHMueGVucHJvamVjdC5vcmddIG9uIGJlaGFsZiBvZiBNYXJrIEhpbmtsZSBbTWFyay5I aW5rbGVAY2l0cml4LmNvbV0NClNlbnQ6IEZyaWRheSwgTWFyY2ggMDcsIDIwMTQgOTowNCBBTQ0K VG86IEFkdmlzb3J5LWJvYXJkIGRpc2N1c3Npb25zDQpDYzogSmVubmlmZXIgQ2xvZXINClN1Ympl Y3Q6IFJlOiBbQWR2aXNvcnktYm9hcmRdIFhlbiBQcm9qZWN0IDQuNCBSZWxlYXNlDQoNClNhcmFo LA0KDQpCcmFuZGluZyBzZWVtcyB0byBiZSBhcHBsaWVkIGFwcHJvcHJpYXRlbHkgdGhvdWdoIEkg dGhpbmsgdGhlcmUgd2VyZSBhIGNvdXBsZSBvZiBzcGVsbGluZyBpc3N1ZXMgSSBjYXVnaHQuIEF0 dGFjaGVkIGlzIGZpbmUgYnkgbWUgdGhvdWdoIHRoZSBicmFuZGluZyBhbmQgZmxvdyBpcyBzdGls bCBhIGJpdCBjaGFsbGVuZ2luZy4NCg0KTWFyaw0KDQoNCk9uIE1hciA3LCAyMDE0LCBhdCAxMDox MyBBTSwgU2FyYWggQ29ud2F5IDxzY29ud2F5QGxpbnV4Zm91bmRhdGlvbi5vcmc8bWFpbHRvOnNj b253YXlAbGludXhmb3VuZGF0aW9uLm9yZz4+IHdyb3RlOg0KDQpIaSBldmVyeW9uZS4NCg0KSSd2 ZSBpbmNvcnBvcmF0ZWQgZXZlcnlvbmUncyBlZGl0cy4gSSB0cmllZCB0byByZWNvbmNpbGUgdGhl IFRNLXJlbGF0ZWQgaXNzdWVzIG9mIGJyYW5kIGNvbmZ1c2lvbiBhbmQgZmxvdyBhcyBiZXN0IEkg Y291bGQuIEFzIHlvdSBjYW4gaW1hZ2luZSwgSSBnb3QgdmFyeWluZyBlZGl0cywgd2hpY2ggc3Rh cnRlZCB0byBjb25mbGljdCB3aXRoIG9uZSBhbm90aGVyLg0KDQpUaGlzIHdvdWxkIGJlbmVmaXQg ZnJvbSBhbm90aGVyIFRNIHJldmlldy9maW5hbCBhcHByb3ZhbC4gQ2FuIHNvbWVvbmUgc3RlcCB1 cCB0byBkbyB0aGlzIGFuZCBtYWtlIGEgZmluYWwgY2FsbD8NCg0KTWlrZSBELiwgQ2l0cml4IGlz IG9uIHRoZSBmdWxsIEFCIGVtYWlsIGxpc3Qgc28gdGhleSd2ZSBiZWVuIGludm9sdmVkIGluIHJl dmlld3MuDQoNClBsZWFzZSBhZHZpc2Ugc29vbmVzdC4NCg0KVGhhbmtzLA0KDQoNCg0KDQpPbiBG cmksIE1hciA3LCAyMDE0IGF0IDg6MTMgQU0sIFJpY2hhcmQgUGhlbGFuIDxSaWNoYXJkLlBoZWxh bkBhcm0uY29tPG1haWx0bzpSaWNoYXJkLlBoZWxhbkBhcm0uY29tPj4gd3JvdGU6DQpIaSwNCg0K SSBhZ3JlZSB3aXRoIE1hcmsgYXMgdGhlIGN1cnJlbnQgcHJlc3MgcmVsZWFzZSBpcyBoaWdobGln aHRpbmcgaXNzdWVzIHRoYXQgc2VlbSB0byBtYWtlIHRoZSBhcnRpY3VsYXRpb24gb2YgYnJhbmQg YW5kIGJyYW5kIHZhbHVlcyBtb3JlIGN1bWJlcnNvbWUgdGhhbiBpcyBkZXNpcmFibGUuDQoNCkkn bSBoYXBweSB0byBnbyB3aXRoIHRoZSBwcm9wb3NlZCBjaGFuZ2VzIGZvciB0aGUgcmVhc29ucyBz dGF0ZWQuDQoNCk9uZSBtaW5vciBwb2ludCwgSSdkIHByZWZlciAiP6ZTeXN0ZW0gb24gQ2hpcCAo U29DKSBkZXZpY2VzLiIsIHR3byBzZXRzIG9mIHBsdXJhbHMgbWFrZSBpdCB1bmNsZWFyIGhvdyBt YW55IHN5c3RlbXMgYXJlIG9uIGVhY2ggY2hpcCBhbmQgdGhlIHBsdXJhbHMgZ2V0IHN1Ym1lcmdl ZCBpbnRvIHRoZSBhY3JvbnltOyBjb21tb24gdXNhZ2Ugc2VlbXMgdG8gYmUgU29Dcy4NCg0KVGhh bmtzLA0KDQpSaWNoYXJkLg0KDQpGcm9tOiBNYXJrIEhpbmtsZSA8TWFyay5IaW5rbGVAY2l0cml4 LmNvbTxtYWlsdG86TWFyay5IaW5rbGVAY2l0cml4LmNvbT4+DQpSZXBseS1UbzogQWR2aXNvcnkt Ym9hcmQgZGlzY3Vzc2lvbnMgPGFkdmlzb3J5LWJvYXJkQGxpc3RzLnhlbnByb2plY3Qub3JnPG1h aWx0bzphZHZpc29yeS1ib2FyZEBsaXN0cy54ZW5wcm9qZWN0Lm9yZz4+DQpEYXRlOiBGcmlkYXks IDcgTWFyY2ggMjAxNCAwNTozMg0KVG86IEFkdmlzb3J5LWJvYXJkIGRpc2N1c3Npb25zIDxhZHZp c29yeS1ib2FyZEBsaXN0cy54ZW5wcm9qZWN0Lm9yZzxtYWlsdG86YWR2aXNvcnktYm9hcmRAbGlz dHMueGVucHJvamVjdC5vcmc+Pg0KDQpTdWJqZWN0OiBSZTogW0Fkdmlzb3J5LWJvYXJkXSBYZW4g UHJvamVjdCA0LjQgUmVsZWFzZQ0KDQpNeSBhcG9sb2dpZXMgZm9yIHRoZSBzbG93IHJlcGx5IEkg d2FzIHN0dWNrIG9uIHRoZSByb2FkIGFuZCBjb3VsZG4/PyByZWFkIHRoZSByZWxlYXNlIG9uIG15 IHBob25lIHRvIGZvcm11bGF0ZSBhIHByb3BlciByZXNwb25zZS4gSSBzaG91bGQgbW92ZSB0byBh IGhpZ2hseSBlbGFzdGljIFhlbiBQcm9qZWN0LXBvd2VyZWQgY2xvdWQgdGhhdCBhbGxvd3MgbWUg dG8gYXV0b3NjYWxlIDspIChzb3JyeSBiYWQgY2xvdWQgam9rZSkuDQoNCkkgYW0gZmluZSB3aXRo b3V0IGRvaW5nIHRoZSBhY3JvbnltIGFuZCBJIHRoaW5rIHRoZSByZWFsaWduaW5nIGFuZCBicmFu ZGluZyBkaXNjdXNzaW9uIHNob3VsZCBiZSBoYWQuIEk/PyBsaWtlIHRvIGhhdmUgdGhhdCBkaXNj dXNzaW9uIGR1cmluZyBvdXIgbmV4dCBib2FyZCBtZWV0aW5nLiBHaXZlbiB0aW1lIGlzIG9mIHRo ZSBlc3NlbmNlIEkgdGhpbmsgd2Ugc2hvdWxkIGp1c3QgdXBkYXRlIHRoZSBsaW5rcyB0byB2ZXJz aW9uIHZlcnN1cyBYZW4gNC4zLjEuDQoNCkFsc28gSSB0b29rIGEgc2hvdCBhdCB0aGUgd29yZGlu ZyBvZiB0aGUgcHJlc3MgcmVsZWFzZS4gSXQ/PyBwcm9iYWJseSBub3QgcGVyZmVjdCBidXQgbWFr ZXMgaXQgcmVhZCBhIGJpdCBiZXR0ZXIuIEF0dGFjaGVkIGFyZSBteSBwcm9wb3NlZCBlZGl0cy4g U2FyYWgsIEkgc2VudCB5b3UgdGhlIHdvcmQgZG9jIHdpdGggdHJhY2sgY2hhbmdlcyBhc3N1bWlu ZyB3ZSBoYXZlIHNvbWUgZWRpdHMgdG8gYWdyZWUgb24uDQoNCg0KUmVnYXJkcywgTWFyaw0KDQoN ClhlbiBQcm9qZWN0IFJlbGVhc2VzIFVwZGF0ZSB0byBFbnRlcnByaXNlIEh5cGVydmlzb3IgU29m dHdhcmUNCg0KT3BlbiBTb3VyY2UgVmlydHVhbGl6YXRpb24gU29mdHdhcmUgUmVsZWFzZSBJbmNs dWRlcyBBZGRpdGlvbmFsIEFSTSBTdXBwb3J0IGFuZCBTY2FsYWJpbGl0eSBmb3IgQ2xvdWQgYW5k IE1vYmlsZSBFbnZpcm9ubWVudHMNCg0KDQoNClNBTiBGUkFOQ0lTQ08sIE1hcmNoIDEwLCAyMDE0 ID8/L3NwYW4+IFhlbiBQcm9qZWN0LCBhIENvbGxhYm9yYXRpdmUgUHJvamVjdCBob3N0ZWQgYXQg VGhlIExpbnV4IEZvdW5kYXRpb24sIHRvZGF5IGFubm91bmNlZCBhdmFpbGFiaWxpdHkgb2YgdGhl IFhlbiBQcm9qZWN0IDQuNCB3aXRoIGVuaGFuY2VkIEFSTSBzdXBwb3J0LiBUaGUgbGF0ZXN0IHJl bGVhc2UgYWxzbyBpbmNsdWRlcyBtYWpvciBwZXJmb3JtYW5jZSBhbmQgc3lzdGVtIHNjYWxhYmls aXR5IGltcHJvdmVtZW50cyBmb3IgZW50ZXJwcmlzZSBjb21wdXRpbmcsIHN1Y2ggYXMgbW9iaWxl IGFuZCBjbG91ZCBlbnZpcm9ubWVudHMsIHdoZXJlIHZpcnR1YWxpemF0aW9uIHRlY2hub2xvZ3kg aXMgaW5jcmVhc2luZ2x5IGluIGRlbWFuZC4NCg0KVGhpcyByZWxlYXNlIGZ1cnRoZXIgYWR2YW5j ZXMgdGhlIFByb2plY3Q/Py9zcGFuPnMgcG9zaXRpb24gYXMgYSBmYXN0LCBzY2FsYWJsZSwgc2Vj dXJlIHZpcnR1YWxpemF0aW9uIGVuZ2luZSBmb3IgdGhlIGluZHVzdHJ5Pz8vc3Bhbj5zIGJyb2Fk ZXN0IHJhbmdlIG9mIHNlcnZlciwgUEMgY2hpcHNldHMgYW5kIG5leHQtZ2VuZXJhdGlvbiBsb3ct cG93ZXIgc3lzdGVtcyBvbiBjaGlwcyAoU29DKS4NCg0KTWFqb3IgY29udHJpYnV0aW9ucyBmcm9t IEFNRCwgQ2l0cml4LCBJbnRlbCwgT3JhY2xlIGFuZCBTVVNFIGFyZSBwdXNoaW5nIHRoZSBYZW4g UHJvamVjdCBzb2Z0d2FyZSB0byB0YWtlIGFkdmFudGFnZSBvZiB0aGUgbGF0ZXN0IGhhcmR3YXJl LiBBZGRpdGlvbmFsbHksIGRldmVsb3BlcnMgY3JlYXRpbmcgc2VydmljZXMgYW5kIGFwcHMgd2l0 aCBlbWJlZGRlZCwgbW9iaWxlIGFuZCBjbG91ZCBzeXN0ZW1zIHdpbGwgYmVuZWZpdCBmcm9tIG5l dyBmZWF0dXJlcyBzdWNoIGFzIGV2ZW50IGNoYW5uZWxpbmcgd2hlbiBzY2FsaW5nIG91dCB0aGVp ciBJbmZyYXN0cnVjdHVyZSBhcyBhIFNlcnZpY2Ugb2ZmZXJpbmdzLg0KDQo/Py9zcGFuPlZpcnR1 YWxpemF0aW9uIGFuZCBsb3ctcG93ZXJlZCBzZXJ2ZXJzIGFyZSBsZWFkaW5nIGNvbXBhbmllcyB0 byByZXRoaW5rIHRoZSBkYXRhIGNlbnRlciBhbmQgaXRzIHBvdGVudGlhbCBmb3IgZWZmaWNpZW5j eSw/PyBzYWlkIExhcnMgS3VydGgsIENoYWlybWFuIG9mIHRoZSBYZW4gUHJvamVjdCBhZHZpc29y eSBib2FyZC4gPz8vc3Bhbj5PdXIgc29sdXRpb24gY29udGFpbnMgSVQtcmVsYXRlZCBjb3N0cywg cGx1cyBtZWV0cyB0aGUgc2VjdXJpdHkgYW5kIHNjYWxhYmlsaXR5IG5lZWRzIG9mIHRvZGF5Pz8v c3Bhbj5zIGVsYXN0aWMgY2xvdWQsIG1vYmlsZSBhbmQgc29jaWFsIG5ldHdvcmtpbmcgY29tcGFu aWVzLiBUaGUgbGF0ZXN0IHVwZGF0ZXMgY29udGludWUgdGhlIFByb2plY3Q/Py9zcGFuPnMgdHJh Y2sgcmVjb3JkIG9mIHJpY2ggY29sbGFib3JhdGlvbiBhbmQgd2lkZXNwcmVhZCBkZXZlbG9wbWVu dCBmcm9tIG1hbnkgb2YgdGhlIHdvcmxkPz8vc3Bhbj5zIHRlY2hub2xvZ3kgbGVhZGVycy4gVGhp cyBjZXJ0YWlubHkgZXhwbGFpbnMgdGhlIHNpZ25pZmljYW50IGdyb3d0aCBvZiBBUk0gc3VwcG9y dCwgd2hpY2ggd2U/Py9zcGFuPnJlIHBsZWFzZWQgdG8gc2VlIGFkdmFuY2Ugc28gcXVpY2tseS4/ Py9zcGFuPg0KDQpTdXBwb3J0IGZvciBBUk0gb24gWGVuIFByb2plY3QgQXJjaGl0ZWN0dXJlIEdy b3dzIFF1aWNrbHkNCg0KVGhlIG5ldyByZWxlYXNlIGludHJvZHVjZXMgc2lnbmlmaWNhbnQgc3Rh YmlsaXR5LCB1c2FiaWxpdHkgYW5kIHBlcmZvcm1hbmNlIGltcHJvdmVtZW50cyBmb3IgdGhlIEFS TSBhcmNoaXRlY3R1cmUgYW5kIGV4dGVuZGVkIGhhcmR3YXJlIGNvbXBhdGliaWxpdHkuICBBcHBs aWVkTWljcm8/Py9zcGFuPnMgWC1HZW5lLCB0aGUgQXJuZGFsZSBCb2FyZCwgQ2FseGVkYSBFQ1gt MjAwMCwgVEkgT01BUDUgYW5kIHRoZSBBbGx3aW5uZXIgU3VuWGkgYm9hcmRzIGFyZSBhbGwgc3Vw cG9ydGVkLiBUaGUgc3Vic3RhbnRpYWxseSBpbXByb3ZlZCBtdWx0aXBsYXRmb3JtIGNhcGFiaWxp dGllcyBvZiB0aGUgaHlwZXJ2aXNvciBhbGxvdyBoYXJkd2FyZSBhbmQgZW1iZWRkZWQgdmVuZG9y cyB0byBwb3J0IHRoZSBYZW4gUHJvamVjdCB0ZWNobm9sb2d5IHRvIG5ldyBBUk0gU29DcyBlYXNp bHksIHNob3J0ZW5pbmcgdGhlaXIgdGltZSB0byBtYXJrZXQuDQoNCg0KDQpBZGRpdGlvbmFsIGVu aGFuY2VtZW50cyBpbiB0aGlzIHJlbGVhc2UgaW5jbHVkZWQgNjQtYml0IGd1ZXN0IHN1cHBvcnQg b24gQVJNdjggcGxhdGZvcm1zLiBBbGwgdGhlIHVzZXJzcGFjZSB0b29scywgc3VjaCBhcyB0aGUg eGwgbWFuYWdlbWVudCB0b29sLCBhcmUgNjQtYml0IHJlYWR5IGFuZCBjYW4gYmUgdXNlZCB0byBj cmVhdGUgNjQtYml0IHZpcnR1YWwgbWFjaGluZXMgb3V0IG9mIHRoZSBib3guDQoNCg0KDQpUaGUg WGVuIFByb2plY3QgaHlwZXJjYWxsIEFCSSBpcyBub3cgc3RhYmxlIGFuZCB3aWxsIGJlIG1haW50 YWluZWQgZm9yIGJhY2t3YXJkIGNvbXBhdGliaWxpdHksIHNvIHVzZXJzIGNhbiB0cnVzdCBmdXR1 cmUgcmVsZWFzZXMgdG8gYm9vdCBvbGRlciBvcGVyYXRpbmcgc3lzdGVtcy4NCg0KQWRkaXRpb25h bCBpbXByb3ZlbWVudHMgaW5jbHVkZSBleHRlbmRlZCBzdXBwb3J0IGZvciBBUk0gc3BlY2lmaWMg Ym9vdGxvYWRlcnMgYW5kIGZpcm13YXJlIGludGVyZmFjZXMsIGFuZCBzdXBwb3J0IGZvciBwaHlz aWNhbCBwYXJ0aXRpb25zIGFuZCBMVk0gdm9sdW1lcyB0byBzdG9yZSBkaXNrcyBvZiB2aXJ0dWFs IG1hY2hpbmVzLg0KDQoNCg0KSW1wcm92ZWQgRXZlbnQgQ2hhbm5lbCBTY2FsYWJpbGl0eSBGb3Ig Q2xvdWQgQ29tcHV0aW5nDQoNClhlbiBQcm9qZWN0IGRldmVsb3BlcnMgY29udGludWVzIHRvIGRy aXZlIGlubm92YXRpb24gYW5kIGNvbGxhYm9yYXRpb24gYXJvdW5kIHNlcnZlciB2aXJ0dWFsaXph dGlvbiBhbmQgdGhlIGNsb3VkLiBQb3dlcmluZyBtYW55IG9mIHRoZSBsYXJnZXN0IGNsb3VkcyBp biBwcm9kdWN0aW9uIHRvZGF5LCBpbmNsdWRpbmcgQW1hem9uIEVDMiwgUmFja3NwYWNlIENsb3Vk IGFuZCBvdGhlcnMsIHRoZSBjb21tdW5pdHkgdW5kZXJzdGFuZHMgdGhlIG5lZWQgdG8gcnVuIG1v cmUgdmlydHVhbCBtYWNoaW5lcyBvbiBhIHNpbmdsZSBob3N0Lg0KDQpZZXQgZGVtYW5kcyBvbiBo eXBlcnZpc29yIHNjYWxhYmlsaXR5IGNvbnRpbnVlIHRvIGluY3JlYXNlLCBib3RoIGZyb20gbGFy Z2VyIG1hY2hpbmVzLCBuZXcgd29ya2xvYWRzIHN1Y2ggYXMgdmlydHVhbGl6YXRpb24gZGVza3Rv cCBpbmZyYXN0cnVjdHVyZXMgKFZESSkgYW5kIG5ldyBjbG91ZCBPUyB0ZWNobm9sb2dpZXMsIGlu Y2x1ZGluZyBNaXJhZ2VPUywgRXJsYW5nT25YZW4sIE9TdiwgYW5kIEhhbFZNLiBSZWNvZ25pemlu ZyB0aGF0IGhpZ2gtYXZhaWxhYmlsaXR5IGFuZCBzdGFiaWxpdHkgYXJlIGNyaXRpY2FsIHRvIFZE SXMgYW5kIGNsb3VkIGRlcGxveW1lbnRzOyB0aGUgWGVuU2VydmVyIHRlYW0gYXQgQ2l0cml4IGNv bnRyaWJ1dGVkIHRoZSBuZXcgZXZlbnQgY2hhbm5lbCBpbXBsZW1lbnRhdGlvbiB0byB0aGUgWGVu IFByb2plY3QuIFRvIGhlbHAgZWxpbWluYXRlIHdvcmtsb2FkIGxpbWl0YXRpb25zIGZvciB1c2Vy cywgdGhpcyBlbmFibGVzIHRoZSBoeXBlcnZpc29yIHRvIHJ1biB0aG91c2FuZHMgb2YgZ3Vlc3Rz IG9uIGEgc2luZ2xlIHBoeXNpY2FsIG1hY2hpbmUuDQoNCkV4cGVyaW1lbnRhbCBTdXBwb3J0IGZv ciBQVkggTW9kZSBmb3IgR3Vlc3QNCg0KT3JhY2xlIGhhcyBjb250cmlidXRlZCBhIGZ1bmN0aW9u YWwgcHJldmlldyBvZiBhIG5ldyB2aXJ0dWFsaXphdGlvbiBtb2RlIGNhbGxlZCBQVkggY3VycmVu dGx5IGF2YWlsYWJsZSB0byB2aXJ0dWFsaXplZCBndWVzdHMuIDxodHRwOi8vYmxvZy54ZW4ub3Jn L2luZGV4LnBocC8yMDE0LzAxLzMxL2xpbnV4LTMtMTQtYW5kLXB2aC8+IFBWSCBpcyBhbiBleHRl bnNpb24gdG8gdGhlIGNsYXNzaWMgWGVuIFByb2plY3QgUGFyYXZpcnR1YWxpemF0aW9uIChQVikg dGhhdCB1c2VzIHRoZSBoYXJkd2FyZSB2aXJ0dWFsaXphdGlvbiBleHRlbnNpb25zIGF2YWlsYWJs ZSBvbiBtb2Rlcm4geDg2IHByb2Nlc3NvcnMuIFBWSCB1c2VzIFBWIGRyaXZlcnMgZm9yIGJvb3Qg YW5kIEkvTyBhbmQgSW50ZWwgaGFyZHdhcmUgdmlydHVhbGl6YXRpb24gZXh0ZW5zaW9ucyBmb3Ig cGFnZSB0YWJsZSBvcGVyYXRpb25zLCBzeXN0ZW0gY2FsbHMgYW5kIG90aGVyIHByaXZpbGVnZWQg b3BlcmF0aW9ucy4gVGhpcyBub3Qgb25seSBpbXByb3ZlcyBwZXJmb3JtYW5jZSBhbmQgc2VjdXJp dHksIGJ1dCBhbHNvIHNpbXBsaWZpZXMgdGhlIGFyY2hpdGVjdHVyZSBhbmQgWGVuIFByb2plY3Qg SHlwZXJ2aXNvci1MaW51eCBpbnRlcmZhY2Ugc2lnbmlmaWNhbnRseS4NCg0KPz8vc3Bhbj5QVkgg aXMgYSBtYWpvciBkZXZlbG9wbWVudCBmb3IgWGVuIFByb2plY3Qgc29mdHdhcmUgb24geDg2IGFu ZCBoYXMgdGhlIHBvdGVudGlhbCB0byBncmVhdGx5IHNpbXBsaWZ5IHRoZSBMaW51eCBpbnRlcmZh Y2UgaW4gZHVlIHRpbWUsID8/IHNhaWQgS29ucmFkIFJ6ZXN6dXRlayBXaWxrLCBTb2Z0d2FyZSBE ZXZlbG9wbWVudCBNYW5hZ2VyIGF0IE9yYWNsZSwgYSBYZW4gUHJvamVjdCBhZHZpc29yeSBib2Fy ZCBtZW1iZXIuID8/L3NwYW4+V2UgZXhwZWN0IFBWSCB0byBoYXZlIHRoZSBiZXN0IGNoYXJhY3Rl cmlzdGljcyBvZiBhbGwgdmlydHVhbGl6YXRpb24gbW9kZXMgLS0gYSBzaW1wbGUsIGZhc3QsIHNl Y3VyZSBpbnRlcmZhY2UsIHdpdGggbG93IG1lbW9yeSBvdmVyaGVhZCwgdGhhdCBhbHNvIHRha2Vz IGZ1bGwgYWR2YW50YWdlIG9mIHRoZSBsYXRlc3QgaGFyZHdhcmUuPz8vc3Bhbj4NCg0KDQoNCkFk ZGl0aW9uYWwga2V5IHVwZGF0ZXMgaW5jbHVkZToNCg0K77+977+9ICAgICBCZXR0ZXIgcGVyZm9y bWFuY2Ugd2l0aCBtb2Rlcm4gc3RvcmFnZSBkZXZpY2VzIGFuZCBiaWcgZGF0YSAtLSBJbmRpcmVj dCBkZXNjcmlwdG9ycyBmb3IgYmxvY2sgUFYgcHJvdG9jb2wgKExpbnV4KSBhbGxvdyBlYWNoIGlu ZGl2aWR1YWwgcmVxdWVzdCB0byB0cmlwbGUgaW4gc2l6ZSwgZ3JlYXRseSBpbXByb3ZpbmcgSS9P IHBlcmZvcm1hbmNlIHdoZW4gcnVubmluZyBvbiBmYXN0IHN0b3JhZ2UgdGVjaG5vbG9naWVzIHN1 Y2ggYXMgc29saWQtc3RhdGUgZHJpdmUgYW5kIFJBSUQuIEF2YWlsYWJsZSBpbiBhbnkgZ3Vlc3Qg cnVubmluZyBMaW51eCAzLjExIG9yIGhpZ2hlciAocmVnYXJkbGVzcyBvZiBYZW4gUHJvamVjdCB2 ZXJzaW9uKS4NCg0KDQoNCu+/ve+/vSAgICAgTW9yZSBwb3dlcmZ1bCBkcml2ZXIgZG9tYWlucyAt LSBEaXNrIGRyaXZlciBkb21haW5zIGNhbiBub3cgdW5pZm9ybWx5IHJ1biBibG9jayBzY3JpcHRz IGFuZCB1c2VyLXNwYWNlIGJhY2tlbmRzLCBzdWNoIGFzIHFkaXNrLCBicmluZ2luZyB0aGVtIHVw IHRvIGZlYXR1cmUgcGFyaXR5IHdpdGggZG9tYWluIDAuIFRoaXMgbWVhbnMgaG9zdCBhZG1pbmlz dHJhdG9ycyBjYW4gdGFrZSBhZHZhbnRhZ2Ugb2YgdGhlIGVuaGFuY2VkIHNlY3VyaXR5LCBzY2Fs YWJpbGl0eSwgYW5kIHJvYnVzdG5lc3MgcHJvdmlkZWQgYnkgZHJpdmVyIGRvbWFpbnMgd2l0aG91 dCBzYWNyaWZpY2luZyB0aGUgd2lkZSBhcnJheSBvZiBkaXNrIGNvbmZpZ3VyYXRpb24gb3B0aW9u cyBwcm92aWRlZCBieSBYZW4gaW4gZG9tMC4NCg0K77+977+9ICAgICBOZXcgU1BJQ0UgcHJvdG9j b2wgc3VwcG9ydCAtLSBGdW5jdGlvbmFsaXR5IHN1Y2ggYXMgY2xpcGJvYXJkIHNoYXJpbmcgYW5k IFVTQiByZWRpcmVjdGlvbiBjcmVhdGVzIGEgbXVjaCByaWNoZXIgY29ubmVjdGlvbiBmb3Igdmly dHVhbCBkZXNrdG9wcyBhbmQgYmV0dGVyIGdyYXBoaWNzIHBlcmZvcm1hbmNlLg0KDQrvv73vv70g ICAgIEVuaGFuY2VkIGRpYWdub3N0aWNzIGFuZCBrZXhlYyBkZWJ1ZyBzdXBwb3J0IC0tIFdoZW4g YSBjcmFzaCBoYXBwZW5zLCBhIHNwZWNpYWwga2VybmVsIGlzIGFsbG93ZWQgaW1tZWRpYXRlIHRv IGNvbGxlY3QgaW5mb3JtYXRpb24gYWJvdXQgdGhlIHJvb3QgY2F1c2UsIG9mZmVyaW5nIGRldmVs b3BlcnMgYmV0dGVyIGRpYWdub3NpcyBhbmQgcmVwYWlyIGFiaWxpdGllcy4NCg0KVGhlIDQuNCBy ZWxlYXNlIGlzIHRoZSByZXN1bHQgb2YgYSBicm9hZCwgY29sbGFib3JhdGl2ZSBkZXZlbG9wbWVu dCBlZmZvcnQgcmVwcmVzZW50aW5nIGVuZ2luZWVycyBmcm9tIG1vcmUgdGhhbiAxMyBsZWFkaW5n IGhhcmR3YXJlLCBzb2Z0d2FyZSBhbmQgc2VjdXJpdHkgdmVuZG9ycy4gVG9wIGNvbnRyaWJ1dG9y cyBpbmNsdWRlIEFtYXpvbiwgQU1ELCBBbmFsb2cgRGV2aWNlcywgQnJvYWRjb20sIENpdHJpeCwg RnVqaXRzdSwgSW50ZWwsIExpbmFybywgTlNBLCBPcmFjbGUsIFN1c2UsIFZlcml6b24vVGVycmVt YXJrLCBwbHVzIG51bWVyb3VzIGluZGl2aWR1YWwgYW5kIGFjYWRlbWljIGNvbnRyaWJ1dG9ycy4g VGhlIGZyZWVseSBhdmFpbGFibGUgZG93bmxvYWQgY2FuIGJlIGZvdW5kIG9uIHRoZSBYZW5Qcm9q ZWN0Lm9yZzxodHRwOi8veGVucHJvamVjdC5vcmcvPiB3ZWJzaXRlIChpbnNlcnQgdXJsKS4NCg0K DQoNCkFib3V0IFhlbiBQcm9qZWN0DQoNClRoZSBYZW4gUHJvamVjdCBzb2Z0d2FyZSBpcyBhbiBv cGVuIHNvdXJjZSB2aXJ0dWFsaXphdGlvbiBwbGF0Zm9ybSBsaWNlbnNlZCB1bmRlciB0aGUgR1BM djIgd2l0aCBhIHNpbWlsYXIgZ292ZXJuYW5jZSBzdHJ1Y3R1cmUgdG8gdGhlIExpbnV4IGtlcm5l bC4gRGVzaWduZWQgZnJvbSB0aGUgc3RhcnQgZm9yIGNsb3VkIGNvbXB1dGluZywgdGhlIFByb2pl Y3QgaGFzIG1vcmUgdGhhbiBhIGRlY2FkZSBvZiBkZXZlbG9wbWVudCBhbmQgaXMgYmVpbmcgdXNl ZCBieSBtb3JlIHRoYW4gMTAgbWlsbGlvbiB1c2Vycy4gQSBDb2xsYWJvcmF0aXZlIFByb2plY3Qg YXQgVGhlIExpbnV4IEZvdW5kYXRpb24sIHRoZSBYZW4gUHJvamVjdCB0ZWFtIGlzIGZvY3VzZWQg b24gYWR2YW5jaW5nIHZpcnR1YWxpemF0aW9uIGluIGEgbnVtYmVyIG9mIGRpZmZlcmVudCBjb21t ZXJjaWFsIGFuZCBvcGVuIHNvdXJjZSBhcHBsaWNhdGlvbnMgaW5jbHVkaW5nIHNlcnZlciB2aXJ0 dWFsaXphdGlvbiwgSW5mcmFzdHJ1Y3R1cmUgYXMgYSBTZXJ2aWNlIChJYWFTKSwgZGVza3RvcCB2 aXJ0dWFsaXphdGlvbiwgc2VjdXJpdHkgYXBwbGljYXRpb25zLCBlbWJlZGRlZCBhbmQgaGFyZHdh cmUgYXBwbGlhbmNlcy4gSXQgY291bnRzIG1hbnkgaW5kdXN0cnkgYW5kIG9wZW4gc291cmNlIGNv bW11bml0eSBsZWFkZXJzIGFtb25nIGl0cyBtZW1iZXJzIGluY2x1ZGluZzogQW1hem9uIFdlYiBT ZXJ2aWNlcywgQU1ELCBBUk0sIEJyb21pdW0sIENhbHhlZGEsIENBIFRlY2hub2xvZ2llcywgQ2lz Y28sIENpdHJpeCwgR29vZ2xlLCBJbnRlbCwgT3JhY2xlLCBTYW1zdW5nIGFuZCBWZXJpem9uLiBG b3IgbW9yZSBpbmZvcm1hdGlvbiBhYm91dCB0aGUgWGVuIFByb2plY3QgaHlwZXJ2aXNvciBhbmQg dG8gcGFydGljaXBhdGUsIHBsZWFzZSB2aXNpdGh0dHA6Ly94ZW5wcm9qZWN0LjxodHRwOi8veGVu cHJvamVjdC5vcmcvPm9yZzxodHRwOi8veGVucHJvamVjdC5vcmcvPi4NCg0KIyMjDQoNClNhcmFo IENvbndheQ0KDQpUaGUgWGVuIFByb2plY3QNCg0KTWVkaWEgQ29udGFjdA0KDQpwdWJsaWNpdHlA bGlzdHMueGVucHJvamVjdC5vcmc8bWFpbHRvOnB1YmxpY2l0eUBsaXN0cy54ZW5wcm9qZWN0Lm9y Zz4NCg0KDQpPbiBNYXIgNiwgMjAxNCwgYXQgMTI6NDQgUE0sIFdpbHNvbiwgTWF0dCA8bXN3QGFt YXpvbi5jb208bWFpbHRvOm1zd0BhbWF6b24uY29tPj4gd3JvdGU6DQoNCk1hcmssIHRob3VnaHRz Pw0KDQpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXw0KRnJvbTogV2lsc29uLCBNYXR0 DQpTZW50OiBXZWRuZXNkYXksIE1hcmNoIDA1LCAyMDE0IDEwOjAxIEFNDQpUbzogQWR2aXNvcnkt Ym9hcmQgZGlzY3Vzc2lvbnMNClN1YmplY3Q6IFJFOiBbQWR2aXNvcnktYm9hcmRdIFhlbiBQcm9q ZWN0IDQuNCBSZWxlYXNlDQoNCkknZCByYXRoZXIgdXNlICJYZW4gUHJvamVjdCBIeXBlcnZpc29y IiB0aGFuIGludHJvZHVjZSBhbiBhY3JvbnltLiBJIHRoaW5rIGl0J3MgaW1wb3J0YW50IHRoYXQg IlhlbiBQcm9qZWN0IiBub3QgYmUgc3BsaXQgZnJvbSAiSHlwZXJ2aXNvci4iDQoNClRoaXMgc3Rp bGwgZG9lc24ndCBhZGRyZXNzIGhvdyB0aGUgdW1icmVsbGEgcHJvamVjdCBpcyBjYWxsZWQuIFRo aXMgbmV3IHJlbGVhc2UgZG9lc24ndCBvbmx5IGluY2x1ZGUgdGhlIGh5cGVydmlzb3IsIGJ1dCBh bHNvIHRoZSBhc3NvY2lhdGVkIHRvb2xzdGFjayBhbmQgdXRpbGl0aWVzLiBNYXliZSB3ZSdyZSBP SyBjYWxsaW5nIGFsbCBvZiB0aGF0IHRoZSAiSHlwZXJ2aXNvciwiIGV2ZW4gaWYgd2UgaWRlbnRp ZnkgdGhlIGRldmVsb3BtZW50IHRlYW1zIGRpZmZlcmVudGx5Lg0KDQpIb3cgc2hvdWxkIHdlIHJl LWFsaWduIGFsbCBvZiB0aGUgYnJhbmRpbmc/IEZvciBleGFtcGxlOiBodHRwOi8veGVucHJvamVj dC5vcmcvZGV2ZWxvcGVycy90ZWFtcy9oeXBlcnZpc29yLmh0bWwNCg0KU2hvdWxkIHRoZSBsaW5r cyB1bmRlciAiSHlwZXJ2aXNvciBEb3dubG9hZHMiIGJlICJ2ZXJzaW9uIDQuMy4xIiBpbnN0ZWFk IG9mICJYZW4gNC4zLjEiIHRvIHJlc29sdmUgdGhlIHRyYWRlbWFyayBjb25jZXJucz8NCg0KLS1t c3cNCg0KX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18NCkZyb206IGFkdmlzb3J5LWJv YXJkLWJvdW5jZXNAbGlzdHMueGVucHJvamVjdC5vcmc8bWFpbHRvOmFkdmlzb3J5LWJvYXJkLWJv dW5jZXNAbGlzdHMueGVucHJvamVjdC5vcmc+IFthZHZpc29yeS1ib2FyZC1ib3VuY2VzQGxpc3Rz LnhlbnByb2plY3Qub3JnPG1haWx0bzphZHZpc29yeS1ib2FyZC1ib3VuY2VzQGxpc3RzLnhlbnBy b2plY3Qub3JnPl0gb24gYmVoYWxmIG9mIFNhcmFoIENvbndheSBbc2NvbndheUBsaW51eGZvdW5k YXRpb24ub3JnPG1haWx0bzpzY29ud2F5QGxpbnV4Zm91bmRhdGlvbi5vcmc+XQ0KU2VudDogV2Vk bmVzZGF5LCBNYXJjaCAwNSwgMjAxNCA5OjMzIEFNDQpUbzogQWR2aXNvcnktYm9hcmQgZGlzY3Vz c2lvbnMNClN1YmplY3Q6IFJlOiBbQWR2aXNvcnktYm9hcmRdIFhlbiBQcm9qZWN0IDQuNCBSZWxl YXNlDQoNCk1hcmsgZXQgYWxsLA0KDQpJIGFncmVlIHRoYXQgdXNpbmcgWGVuIFByb2plY3QgaXMg YSBtb3V0aGZ1bC4gR2l2ZW4gdGhhdCB0aGVyZSBpcyBjbG9zZSBvdmVybGFwIGFuZCBvY2Nhc2lv bmFsIGJyYW5kaW5nIGNvbmZ1c2lvbiB3aXRoIENpdHJpeCBwcm9kdWN0cywgaWYgd2UgYWRkIGFu b3RoZXIgbmV3IHRlcm0gb3IgYWNyb255bSBpbnRvIHRoZSBtaXgsIHdlJ2xsIHdhbnQgdG8gYmUg ZGlsaWdlbnQgYWJvdXQgYmVpbmcgY29uc2lzdGVudCBpbiBibG9ncywgcHJlc2VudGF0aW9ucywg bmV3cyByZWxlYXNlcywgd2ViIHNpdGUgY29weSwgY3VzdG9tZXIgdGVzdGltb25pYWxzIGV0Yy4N Cg0KRm9yIHRoZSBzYWtlIG9mIHNpbXBsaWNpdHksIGhvdyBhYm91dCB1c2luZyBYUEggLSBhbGwg dXBwZXJjYXNlIC0gb24gc2Vjb25kIHJlZmVyZW5jZT8gVGhvdWdodHM/DQoNClRoYW5rcywNCg0K DQoNCg0KDQoNCk9uIFdlZCwgTWFyIDUsIDIwMTQgYXQgOToxOCBBTSwgTWFyayBIaW5rbGUgPE1h cmsuSGlua2xlQGNpdHJpeC5jb208bWFpbHRvOk1hcmsuSGlua2xlQGNpdHJpeC5jb20+PiB3cm90 ZToNCkhvdyBhYm91dCB0aGlzIGNvbnZlbnRpb24gb25seSBzYXkgWGVuIFByb2plY3QgYW5kIFhl biBQcm9qZWN0IGh5cGVydmlzb3Igb25jZSB0aGVuLiBVc2UgdGhlIGFiYnJldmlhdGlvbiBYUGgg dGhyb3VnaG91dCB0aGUgcmVsZWFzZS4gSnVzdCBzbmlwcGluZyBNYXR0Pz8gZXhhbXBsZSB0byBt YWtlIHRoZSBwb2ludC4gSSB3b3VsZCBndWVzcyB0aGF0IHRoZSBhcHByb3ByaWF0ZSBjYXBpdGFs aXphdGlvbiB3b3VsZCBiZSBsb3dlciBjYXNlIGZvciB0aGUgd29yZCBoeXBlcnZpc29yLg0KDQpN YXJrDQoNCg0KVGhlIFhlbiBQcm9qZWN0LCBhIENvbGxhYm9yYXRpdmUgUHJvamVjdCBob3N0ZWQg YXQgVGhlIExpbnV4IEZvdW5kYXRpb24sIHRvZGF5IGFubm91bmNlZCBhdmFpbGFiaWxpdHkgb2Yg dGhlIFhlbiBQcm9qZWN0IGh5cGVydmlzb3IoWFBoKSA0LjQgd2l0aCBlbmhhbmNlZCBBUk0gc3Vw cG9ydC4NCg0KWFBoIDQuNCBmdXJ0aGVyIGFkdmFuY2VzIHRoZSBQcm9qZWN0Pz8vc3Bhbj5zIHBv c2l0aW9uIGFzIGEgZmFzdCwgc2NhbGFibGUsIHNlY3VyZSB2aXJ0dWFsaXphdGlvbiBlbmdpbmUg Zm9yIHRoZSBpbmR1c3RyeT8/L3NwYW4+cyBicm9hZGVzdCByYW5nZSBvZiBzZXJ2ZXIsIFBDIGNo aXBzZXRzIGFuZCBuZXh0LWdlbmVyYXRpb24gbG93LXBvd2VyIHN5c3RlbXMgb24gY2hpcHMgKFNv QykuDQoNCk9uIE1hciA0LCAyMDE0LCBhdCA0OjAxIFBNLCBXaWxzb24sIE1hdHQgPG1zd0BhbWF6 b24uY29tPG1haWx0bzptc3dAYW1hem9uLmNvbT4+IHdyb3RlOg0KDQpUaGUgIlhlbiBQcm9qZWN0 IiB0ZXJtaW5vbG9neSBtYWtlcyB0aGUgbWVzc2FnZSBleHRyZW1lbHkgY3VtYmVyc29tZS4NCg0K DQpUaGUgWGVuIFByb2plY3QsIGEgQ29sbGFib3JhdGl2ZSBQcm9qZWN0IGhvc3RlZCBhdCBUaGUg TGludXggRm91bmRhdGlvbiwgdG9kYXkgYW5ub3VuY2VkIGF2YWlsYWJpbGl0eSBvZiB0aGUgWGVu IFByb2plY3QgNC40IEh5cGVydmlzb3Igd2l0aCBlbmhhbmNlZCBYZW4gUHJvamVjdC1vbi1BUk0g c3VwcG9ydC4NCg0KV2h5IG5vdCBqdXN0IHNheSAiZW5oYW5jZWQgQVJNIHN1cHBvcnQiPyBXZSBz aG91bGQgYWRvcHQgc29tZSB1c2FnZSBndWlkZWxpbmVzIGZvciBzdWItcHJvamVjdCBicmFuZGlu Zy4gV2Ugc2hvdWxkbid0IGluc2VydCB3b3Jkcy9udW1iZXJzIGJldHdlZW4gIlhlbiBQcm9qZWN0 IiBhbmQgYSBzdWItcHJvamVjdCBuYW1lLg0KDQpUaGUgWGVuIFByb2plY3QsIGEgQ29sbGFib3Jh dGl2ZSBQcm9qZWN0IGhvc3RlZCBhdCBUaGUgTGludXggRm91bmRhdGlvbiwgdG9kYXkgYW5ub3Vu Y2VkIHZlcnNpb24gNC40IG9mIHRoZSBYZW4gUHJvamVjdCBIeXBlcnZpc29yIHdpdGggZW5oYW5j ZWQgQVJNIHN1cHBvcnQuDQoNCm9yDQpUaGUgWGVuIFByb2plY3QsIGEgQ29sbGFib3JhdGl2ZSBQ cm9qZWN0IGhvc3RlZCBhdCBUaGUgTGludXggRm91bmRhdGlvbiwgdG9kYXkgYW5ub3VuY2VkIHRo ZSByZWxlYXNlIG9mIFhlbiBQcm9qZWN0IEh5cGVydmlzb3IgNC40IHdpdGggZW5oYW5jZWQgQVJN IHN1cHBvcnQuDQoNCkxhdGVyIG9uLCB0aGlzIHJlbGVhc2UgaXMgY2FsbGVkICJYZW4gUHJvamVj dCA0LjQiDQoNCg0KVGhlIFhlbiBQcm9qZWN0IDQuNCByZWxlYXNlIGZ1cnRoZXIgYWR2YW5jZXMg dGhlIFByb2plY3Q/Py9zcGFuPnMgcG9zaXRpb24gYXMgYSBmYXN0LCBzY2FsYWJsZSwgc2VjdXJl IHZpcnR1YWxpemF0aW9uIGVuZ2luZSBmb3IgdGhlIGluZHVzdHJ5Pz8vc3Bhbj5zIGJyb2FkZXN0 IHJhbmdlIG9mIHNlcnZlciwgUEMgY2hpcHNldHMgYW5kIG5leHQtZ2VuZXJhdGlvbiBsb3ctcG93 ZXIgc3lzdGVtcyBvbiBjaGlwcyAoU29DKS4NCg0KVGhhdCBkb2Vzbid0IGZsb3cgd2VsbC4gSG93 IGFyZSB3ZSByZWxlYXNpbmcgdmVyc2lvbiA0LjQgb2YgYSBwcm9qZWN0PyBEbyB3ZSB3YW50IHRv IGNhbGwgdGhlIG92ZXJhbGwgcmVsZWFzZSAiWGVuIFByb2plY3QgQXJjaGl0ZWN0dXJlIDQuNCI/ IE9yIGRvIHdlIG5lZWQgdG8gY29tZSB1cCB3aXRoIHNvbWUgb3RoZXIgcHJvamVjdCBicmFuZGlu Zz8NCg0KLS1tc3cNCg0KX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18NCkZyb206IGFk dmlzb3J5LWJvYXJkLWJvdW5jZXNAbGlzdHMueGVucHJvamVjdC5vcmc8bWFpbHRvOmFkdmlzb3J5 LWJvYXJkLWJvdW5jZXNAbGlzdHMueGVucHJvamVjdC5vcmc+IFthZHZpc29yeS1ib2FyZC1ib3Vu Y2VzQGxpc3RzLnhlbnByb2plY3Qub3JnPG1haWx0bzphZHZpc29yeS1ib2FyZC1ib3VuY2VzQGxp c3RzLnhlbnByb2plY3Qub3JnPl0gb24gYmVoYWxmIG9mIFNhcmFoIENvbndheSBbc2NvbndheUBs aW51eGZvdW5kYXRpb24ub3JnPG1haWx0bzpzY29ud2F5QGxpbnV4Zm91bmRhdGlvbi5vcmc+XQ0K U2VudDogVHVlc2RheSwgTWFyY2ggMDQsIDIwMTQgMTI6MTYgUE0NCg0KVG86IGFkdmlzb3J5LWJv YXJkQGxpc3RzLnhlbnByb2plY3Qub3JnPG1haWx0bzphZHZpc29yeS1ib2FyZEBsaXN0cy54ZW5w cm9qZWN0Lm9yZz4NClN1YmplY3Q6IFtBZHZpc29yeS1ib2FyZF0gWGVuIFByb2plY3QgNC40IFJl bGVhc2UNCg0KSGkgZXZlcnlvbmUuDQoNCkF0dGFjaGVkIGlzIHRoZSBYZW4gUHJvamVjdCA0LjQg bmV3cyByZWxlYXNlIGFubm91Y2VtZW50IHRoYXQgd2lsbCBnbyBvdXQgYXQgOCBhLm0uIEVUIG9u IE1vbmRheSwgTWFyY2ggMTAuDQoNCklmIHlvdSBoYXZlIGFueSBhZGRpdGlvbmFsIGNvbW1lbnRz IG9yIGVkaXRzLCBwbGVhc2UgZ2V0IGJhY2sgdG8gbWUgYnkgVGh1cnNkYXkgbW9ybmluZyBhdCB0 aGUgbGF0ZXN0Lg0KDQpUaGFua3MsDQoNCg0KLS0NClNhcmFoIENvbndheQ0KUFIgTWFuYWdlcg0K VGhlIExpbnV4IEZvdW5kYXRpb24NCnNjb253YXlAbGludXhmb3VuZGF0aW9uLm9yZzxtYWlsdG86 c2NvbndheUBsaW51eGZvdW5kYXRpb24ub3JnPg0KKDk3OCkgNTc4LTUzMDA8dGVsOiUyODk3OCUy OSUyMDU3OC01MzAwPiAgQ2VsbA0KU2t5cGU6ICBzYXJhaC5rLmNvbndheQ0KX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18NCkFkdmlzb3J5LWJvYXJkIG1haWxp bmcgbGlzdA0KQWR2aXNvcnktYm9hcmRAbGlzdHMueGVucHJvamVjdC5vcmc8bWFpbHRvOkFkdmlz b3J5LWJvYXJkQGxpc3RzLnhlbnByb2plY3Qub3JnPg0KaHR0cDovL2xpc3RzLnhlbnByb2plY3Qu b3JnL2NnaS1iaW4vbWFpbG1hbi9saXN0aW5mby9hZHZpc29yeS1ib2FyZA0KDQoNCl9fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fDQpBZHZpc29yeS1ib2FyZCBt YWlsaW5nIGxpc3QNCkFkdmlzb3J5LWJvYXJkQGxpc3RzLnhlbnByb2plY3Qub3JnPG1haWx0bzpB ZHZpc29yeS1ib2FyZEBsaXN0cy54ZW5wcm9qZWN0Lm9yZz4NCmh0dHA6Ly9saXN0cy54ZW5wcm9q ZWN0Lm9yZy9jZ2ktYmluL21haWxtYW4vbGlzdGluZm8vYWR2aXNvcnktYm9hcmQNCg0KDQoNCg0K LS0NClNhcmFoIENvbndheQ0KUFIgTWFuYWdlcg0KVGhlIExpbnV4IEZvdW5kYXRpb24NCnNjb253 YXlAbGludXhmb3VuZGF0aW9uLm9yZzxtYWlsdG86c2NvbndheUBsaW51eGZvdW5kYXRpb24ub3Jn Pg0KKDk3OCkgNTc4LTUzMDA8dGVsOiUyODk3OCUyOSUyMDU3OC01MzAwPiAgQ2VsbA0KU2t5cGU6 ICBzYXJhaC5rLmNvbndheQ0KX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX18NCkFkdmlzb3J5LWJvYXJkIG1haWxpbmcgbGlzdA0KQWR2aXNvcnktYm9hcmRAbGlz dHMueGVucHJvamVjdC5vcmc8bWFpbHRvOkFkdmlzb3J5LWJvYXJkQGxpc3RzLnhlbnByb2plY3Qu b3JnPg0KaHR0cDovL2xpc3RzLnhlbnByb2plY3Qub3JnL2NnaS1iaW4vbWFpbG1hbi9saXN0aW5m by9hZHZpc29yeS1ib2FyZA0KDQoNCi0tIElNUE9SVEFOVCBOT1RJQ0U6IFRoZSBjb250ZW50cyBv ZiB0aGlzIGVtYWlsIGFuZCBhbnkgYXR0YWNobWVudHMgYXJlIGNvbmZpZGVudGlhbCBhbmQgbWF5 IGFsc28gYmUgcHJpdmlsZWdlZC4gSWYgeW91IGFyZSBub3QgdGhlIGludGVuZGVkIHJlY2lwaWVu dCwgcGxlYXNlIG5vdGlmeSB0aGUgc2VuZGVyIGltbWVkaWF0ZWx5IGFuZCBkbyBub3QgZGlzY2xv c2UgdGhlIGNvbnRlbnRzIHRvIGFueSBvdGhlciBwZXJzb24sIHVzZSBpdCBmb3IgYW55IHB1cnBv c2UsIG9yIHN0b3JlIG9yIGNvcHkgdGhlIGluZm9ybWF0aW9uIGluIGFueSBtZWRpdW0uIFRoYW5r IHlvdS4NCg0KQVJNIExpbWl0ZWQsIFJlZ2lzdGVyZWQgb2ZmaWNlIDExMCBGdWxib3VybiBSb2Fk LCBDYW1icmlkZ2UgQ0IxIDlOSiwgUmVnaXN0ZXJlZCBpbiBFbmdsYW5kICYgV2FsZXMsIENvbXBh bnkgTm86IDI1NTc1OTANCkFSTSBIb2xkaW5ncyBwbGMsIFJlZ2lzdGVyZWQgb2ZmaWNlIDExMCBG dWxib3VybiBSb2FkLCBDYW1icmlkZ2UgQ0IxIDlOSiwgUmVnaXN0ZXJlZCBpbiBFbmdsYW5kICYg V2FsZXMsIENvbXBhbnkgTm86IDI1NDg3ODINCg0KX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX18NCkFkdmlzb3J5LWJvYXJkIG1haWxpbmcgbGlzdA0KQWR2aXNv cnktYm9hcmRAbGlzdHMueGVucHJvamVjdC5vcmc8bWFpbHRvOkFkdmlzb3J5LWJvYXJkQGxpc3Rz LnhlbnByb2plY3Qub3JnPg0KaHR0cDovL2xpc3RzLnhlbnByb2plY3Qub3JnL2NnaS1iaW4vbWFp bG1hbi9saXN0aW5mby9hZHZpc29yeS1ib2FyZA0KDQoNCg0KDQotLQ0KU2FyYWggQ29ud2F5DQpQ UiBNYW5hZ2VyDQpUaGUgTGludXggRm91bmRhdGlvbg0Kc2NvbndheUBsaW51eGZvdW5kYXRpb24u b3JnPG1haWx0bzpzY29ud2F5QGxpbnV4Zm91bmRhdGlvbi5vcmc+DQooOTc4KSA1NzgtNTMwMCAg Q2VsbA0KU2t5cGU6ICBzYXJhaC5rLmNvbndheQ0KPFhlblByb2plY3RVcGRhdGU0LjQzLjYuMjAx NCgyKWRvY3g+X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18N CkFkdmlzb3J5LWJvYXJkIG1haWxpbmcgbGlzdA0KQWR2aXNvcnktYm9hcmRAbGlzdHMueGVucHJv amVjdC5vcmc8bWFpbHRvOkFkdmlzb3J5LWJvYXJkQGxpc3RzLnhlbnByb2plY3Qub3JnPg0KaHR0 cDovL2xpc3RzLnhlbnByb2plY3Qub3JnL2NnaS1iaW4vbWFpbG1hbi9saXN0aW5mby9hZHZpc29y eS1ib2FyZA0KDQpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f Xw0KQWR2aXNvcnktYm9hcmQgbWFpbGluZyBsaXN0DQpBZHZpc29yeS1ib2FyZEBsaXN0cy54ZW5w cm9qZWN0Lm9yZw0KaHR0cDovL2xpc3RzLnhlbnByb2plY3Qub3JnL2NnaS1iaW4vbWFpbG1hbi9s aXN0aW5mby9hZHZpc29yeS1ib2FyZA0KDQo= --_000_F19B6D5F90FBA84A8D266DC69D10BAD52B0AE92Dex10mbx31008ant_ Content-Type: text/html; charset="big5" Content-Transfer-Encoding: quoted-printable

In particular:

"Xen Project 4.4 Hypervisor" -> "Xen Project Hypervisor version 4.4"

"This release further advances the Project=A1=A6s position as a fast, scalable, secure v= irtualization engine for the industry=A1=A6s broadest range of server, PC c= hipsets and next-generation low-power system on chips (SoC) devices."  PC chipsets? Wouldn't it make more sense to say something like "server, = workstation and low-power system on a chip (SoC) devices"? Note the dr= op of "next-generation" since SoC is quite established today.

"Additionally, developers creating services and apps with embedded, mobile and cloud syst= ems will benefit from the updated event channel implementation when scaling= out their Infrastructure as a Service offerings." "apps" -&= gt; "applications".

We need to have a deliberate decision to introduce "Xen Project Architecture" in our nomenclature. I'm not aware of a use lik= e this in the past.

"All the userspace tools, such as the xl management tool, are 64-bit ready and can be used to= create 64-bit virtual machines out of the box." - written like a deve= loper (no offense to developers on this list).


"Top contributors include Amazon,= AMD, Analog Devices, Broadcom, Citrix, Fujitsu, Intel, Linaro, NSA, Oracle= , Suse, Verizon/Terremark, plus numerous individual and academic contributo= rs. "Amazon" must be "Amazon Web Services". "Suse" should be "SUSE&quo= t;. "plus" should be something like "along with". "= ;Top contributors .. academic contributors" is a bit redun= dant. Perhaps "academic institutions"?

 

There's a lot of room for improvement on this. Incorporating a few key= changes isn't really going to make this a quality release with a strong st= ory. Overall, I'm quite surprised and disappointed with the current state.<= /div>

--msw

From: advisory-board-bounces@lists.xenproject.org [advisory-board-= bounces@lists.xenproject.org] on behalf of Mark Hinkle [Mark.Hinkle@citrix.= com]
Sent: Friday, March 07, 2014 10:27 AM
To: Advisory-board discussions
Cc: Jennifer Cloer
Subject: Re: [Advisory-board] Xen Project 4.4 Release

I don=A1=A6t disagree with Matt the text is  awkward particu= larly because of it=A1=A6s highly technical nature. Do you have any specifi= c feedback for Sarah to incorporate. I didn=A1=A6t want to push too hard si= nce the clock is ticking but we should get this right. 

Going forward I would like to suggest using Oracle=A1=A6s bulleted lis= t format for their press releases since tying together the actual news and = tech content into a compelling narrative is pretty tough. Here an example o= f what I=A1=A6d propose.  

http://www.oracle.com/us/corporate/press/2033376

Regards, Mark 


On Mar 7, 2014, at 12:17 PM, Wilson, Matt <msw@amazon.com> wrote= :

I'm not s= atisfied with the quality of this text (typos, etc.) given the plan to put = it on the wire Monday. We still don't have a strong message and a plan on h= ow we plan to brand the technologies that are produced by the community.

--msw

From: advis= ory-board-bounces@lists.xenproject.org [advisory-board-bounces@lists.xenpro= ject.org] on behalf of Mark Hinkle [Mark.Hinkle@citrix.com]
Sent: Friday, Marc= h 07, 2014 9:04 AM
To: Advisory-board= discussions
Cc: Jennifer Cloer=
Subject: Re: [Advi= sory-board] Xen Project 4.4 Release

Sarah, 

Branding seems to be applied appropriately though I think there were a= couple of spelling issues I caught. Attached is fine by me though the bran= ding and flow is still a bit challenging. 

Mark 


On Mar 7, 2014, at 10:13 AM, Sarah Conway <sconway@linuxfoundation.org>= ; wrote:

Hi everyone.

I've incorporated everyone's edits. I tried to reconcile the TM-relate= d issues of brand confusion and flow as best I could. As you can imagine, I= got varying edits, which started to conflict with one another.

This would benefit from another TM review/final approval. Can someone = step up to do this and make a final call? 

Mike D., Citrix is on the full AB email list so they've been involved = in reviews. 

Please advise soonest. 

Thanks,




On Fri, Mar 7, 2014 at 8:13 AM, Richard Phelan=  <Richard.Phelan@ar= m.com> wrot= e:
Hi,

I agree with Mark as the current press release is highlighting issues = that seem to make the articulation of brand and brand values more cumbersom= e than is desirable.

I'm happy to go with the proposed changes for the reasons stated.

One minor point, I'd prefer "?=A6System on Chip (SoC) devices.&qu= ot;, two sets of plurals make it unclear how many systems are on each chip = and the plurals get submerged into the acronym; common usage seems to be So= Cs.

Thanks,

Richard.

From: Mark Hinkle <Mark.Hinkle@citrix.com>
Reply-To: Advisory-board discussions <advisory-board@lists.= xenproject.org>
Date: Friday, 7 March 2014 05:32
To:&= nbsp;Advisory-board discussions <advisory-board@lists.xenpro= ject.org>

Subject: Re: [Advisory-board] Xen Project 4.4 Release

My apologies for the slow reply I was s= tuck on the road and couldn?? read the release on my phone to formulate a p= roper response. I should move to a highly elastic Xen Project-powered cloud= that allows me to autoscale ;) (sorry bad cloud joke). 

I am fine without doing the acronym and I think the realigning and bra= nding discussion should be had. I?? like to have that discussion during our= next board meeting. Given time is of the essence I think we should just up= date the links to version versus Xen 4.3.1. 

Also I took a shot at the wording of the press release. It?? probably = not perfect but makes it read a bit better. Attached are my proposed edits.= Sarah, I sent you the word doc with track changes assuming we have some ed= its to agree on. 


Regards, Mark 

Xen Project Releases Upda= te to Enterprise Hypervisor Software

<= span style=3D"font-size:12pt; background-color:white">Open Source Virtualiz= ation Software Release Includes Additional ARM Support and Scalability for = Cloud and Mobile Environments 

<= span style=3D"font-size:12pt; background-color:white"> <= /span>

SAN FRANCISCO, March 10, 2014 <= /span>??/span> Xen Project, a Collaborative Project hosted at The Linux Foundation, today ann= ounced availability of the Xen Project 4.4 with enhanced ARM support. The l= atest release also includes major performance and system scalability improv= ements for enterprise computing, such as mobile and cloud environments, where virtualization technology is = increasingly in demand.

This release further advances the Project??/span>s position as a fast, scalable, secure virtualization engine for the industr= y??/span>s broadest range of server, PC chipsets and next-generatio= n low-power systems on chips (SoC).

Major contributions from AMD, Citrix, Intel, Oracle and SUSE ar= e pushing the Xen Project software to take advantage of the latest hardware= . Additionally, developers creating services and apps with embedded, mobile and cloud systems will benefit fro= m new features such as event channeling when scaling out their Infrastructu= re as a Service offerings.

??/span>Virtualization and low-powered servers are leading companies to rethink = the data center and its potential for efficiency,?? said Lars Kurth, Chairman of the Xen Project advisory board. ??/span>Our solution contains IT-related costs, plus meets the security and scalability needs of today??/span>s elastic cloud, mobile and so= cial networking companies. The latest updates continue the Project??/span>s track record of rich collaboration a= nd widespread development from many of the world??/span>s technology leaders. This certainly explains the significant growth of ARM = support, which we??/span>re pleased to see advance so quickly.??/span>

Support for ARM on Xen Project Architecture Grows Quickly<= /span>

The new release i= ntroduces significant stability, usability and performance improvements for= the ARM architecture and extended hardware compatibility.  AppliedMic= ro??/span>s X-Gene, the Arndale Board, Calxeda ECX-2000, TI OMAP5 and the Allwinner Su= nXi boards are all supported. The substantially improved multiplatform capa= bilities of the hypervisor allow hardware and embedded vendors to port the = Xen Project technology to new ARM SoCs easily, shortening their time to market.<= /p>

 <= /u>

Additional enhanc= ements in this release included 64-bit guest support on ARMv8 platforms. Al= l the userspace tools, such as the xl management tool, are 64-bit ready and= can be used to create 64-bit virtual machines out of the box.

 <= /u>

The Xen Project h= ypercall ABI is now stable and will be maintained for backward compatibilit= y, so users can trust future releases to boot older operating systems.

Additional improv= ements include extended support for ARM specific bootloaders and firmware i= nterfaces, and support for physical partitions and LVM volumes to store dis= ks of virtual machines.

 <= /u>

Improved Event Channel Scalability For Cloud Computing=

Xen Project developers continues to drive innovation and collab= oration around server virtualization and the cloud. Powering many of the la= rgest clouds in production today, including Amazon EC2, Rackspace Cloud and others, the community understands the need= to run more virtual machines on a single host.

Yet demands on hypervisor scalability continue to increase, bot= h from larger machines, new workloads such as virtualization desktop infras= tructures (VDI) and new cloud OS technologies, including MirageOS, ErlangOnXen, OSv, and HalVM. Recognizing that high-ava= ilability and stability are critical to VDIs and cloud deployments; the Xen= Server team at Citrix contributed the new event channel implementation to t= he Xen Project. To help eliminate workload limitations for users, this enables the hypervisor to run thousan= ds of guests on a single physical machine.   <= /span>

Experimental Support for PVH Mode for Guest

Oracle has contributed a functional preview of a new virtualization mode called PVH currently available to virtualized guests.<= span class=3D"Apple-converted-space"> PVH is an extension to the = classic Xen Project Paravirtualization (PV) that uses the hardware virtualization extensions available on modern x86 p= rocessors. PVH uses PV drivers for boot and I/O and Intel hardware virtuali= zation extensions for page table operations, system calls and other privile= ged operations. This not only improves performance and security, but also simplifies the architecture and Xen Pro= ject Hypervisor-Linux interface significantly.

??/span>PVH is a major deve= lopment for Xen Project software on x86 and has the potential to greatly simplify the Linux interface in due time, ?? said Konrad Rzeszutek Wilk, Software Development Manager at Oracle, a Xen Proje= ct advisory board member. ??/span>We expect PVH to have the best characteristics of all virtualization modes --= a simple, fast, secure interface, with low memory overhead, that also take= s full advantage of the latest hardware.??/span>

 

Additional key updates include:

=EF=BF=BD=EF=BF=BD     Better performance with modern storage devic= es and big data -- Indirect descriptors for block PV protocol (Linux) allow each = individual request to triple in size, greatly improving I/O performance whe= n running on fast storage technologies such as solid-state drive and RAID. = Available in any guest running Linux 3.11 or higher (regardless of Xen Project version).

 

=EF=BF=BD=EF=BF=BD     More powerful driver domains -- Disk driver domains can now uniformly run block scripts and user-space backends= , such as qdisk, bringing them up to feature parity with domain 0. This mea= ns host administrators can take advantage of the enhanced security, scalabi= lity, and robustness provided by driver domains without sacrificing the wide array of disk configuration op= tions provided by Xen in dom0.

=EF=BF=BD=EF=BF=BD     New SPICE protocol support -- Functionality = such as clipboard sharing and USB redirection creates a much richer connection = for virtual desktops and better graphics performance.

=EF=BF=BD=EF=BF=BD     Enhanced diagnostics and kexec debug support= -- When a crash happens, a special kernel is allowed immediate to collect informat= ion about the root cause, offering developers better diagnosis and repair a= bilities.

The 4.4 release is the result of a broad,= collaborative development effort representing engineers from more than 13 = leading hardware, software and security vendors. Top contributors include A= mazon, AMD, Analog Devices, Broadcom, Citrix, Fujitsu, Intel, Linaro, NSA, Oracle, Suse, Verizon/Terremark, plus= numerous individual and academic contributors. The freely available downlo= ad can be found on the XenProject.org website (insert url).

 

About Xen Project

The Xen Project software is an open source virtualization platf= orm licensed under the GPLv2 with a similar governance structure to the Lin= ux kernel. Designed from the start for cloud computing, the Project has more than a decade of development and is = being used by more than 10 million users. A Collaborative Project at The Li= nux Foundation, the Xen Project team is focused on advancing virtualization= in a number of different commercial and open source applications including server virtualization, Infrastructu= re as a Service (IaaS), desktop virtualization, security applications, embe= dded and hardware appliances. It counts many industry and open source commu= nity leaders among its members including: Amazon Web Services, AMD, ARM, Bromium, Calxeda, CA Technologies, Cisco, C= itrix, Google, Intel, Oracle, Samsung and Verizon. For more information abo= ut the Xen Project hypervisor and to participate, please visithttp://xenproject.org.

###

Sarah Conway

The Xen Project

Media Contact

publicity@lists.xenproject.org



On Mar 6, 2014, at 12:44 PM, Wilson, Matt <msw@amazon.com> wrote:

Mark, tho= ughts?

From: = Wilson, Matt
Sent: Wednesday, March 05, 2014 10:01 AM
To: Advisory-board discussions
Subject: RE: [Advisory-board] Xen Project 4.4 Rele= ase

I'd rather use "Xen Project Hypervisor" than = introduce an acronym. I think it's important that "Xen Project" n= ot be split from "Hypervisor."

This still doesn't address how the umbrella project is called. This new rel= ease doesn't only include the hypervisor, but also the associated toolstack= and utilities. Maybe we're OK calling all of that the "Hypervisor,&qu= ot; even if we identify the development teams differently.

How should we re-align all of the branding? For example: http://xenproject.org/developers/teams/hypervis= or.html

Should the links under "Hypervisor Downloads" be "versi= on 4.3.1" instead of "Xen 4.3.1" to resolve the trademark co= ncerns?

--msw

From: = advisory-board-bounces@lists.xenproject.org [advisory-board-bounces@lists.xen= project.org] on behalf of Sarah Conway [sconway@linuxfoundation.org]
Sent: Wednesday, March 05, 2014 9:33 AM
To: Advisory-board discussions
Subject: Re: [Advisory-board] Xen Project 4.4 Rele= ase

Mark et all, 

I agree t= hat using Xen Project is a mouthful. Given that there is close overlap and occasional branding confus= ion with Citrix products, if we add another new term or acronym into the mix, we'll want to be dili= gent about being consistent in blogs, presentations, news releases, web site copy, customer testimonials etc. 

For the sake of simplicity, how about using XPH - all up= percase - on second reference? Thoughts?

Thanks,






On Wed, Mar 5, 2014 at 9:18 AM, Mark Hinkle = <Mark.Hinkle@citrix.com> wrote= :
How about this convention only say Xen = Project and Xen Project hypervisor once then. Use the abbreviation XPh thro= ughout the release. Just snipping Matt?? example to make the point. I would= guess that the appropriate capitalization would be lower case for the word hypervisor. 

Mark 

The&n= bsp;Xen Project, a C= ollaborative Project hosted at The Linux Foundation, today announced availa= bility of the Xen Project hypervisor(XPh) 4.4 with enhanced ARM support.

XPh 4= .4 further advances the Project??/span>s position as a fast, scalable, secure virtualization engin= e for the industry??/span>s broadest range of server, PC chipsets and next-generation low-power system= s on chips (SoC).


On Mar 4, 2014, at 4:01 PM, Wilson, Matt <msw@amazon.com> wrote:

The "Xen Project" terminology makes the message e= xtremely cumbersome.

The Xen Projec= t, a Collaborative Project hosted at The Linux Foundation, today ann= ounced availability of the Xen Project 4.4 Hypervisor with enhanced <= /span>Xen Project-on= -ARM support.

Why not just say "enhanced ARM support"? We should adopt some usa= ge guidelines for sub-project branding. We shouldn't insert words/numbers b= etween "Xen Project" and a sub-project name.

The= Xen Project, a Collaborative Project hosted at The Linux Foundation, today= announced version 4.4 of the Xen Project Hypervisor with enhanced ARM supp= ort.

or
The= Xen Project, a Collaborative Project hosted at The Linux Foundation, today= announced the release of Xen Project Hypervisor 4.4 with enhanced ARM supp= ort.
Later on, this release is called "Xen Project 4.4"

The X= en Project 4.4 release further advances the Project??/span>s position as a fast, scalable, secure = virtualization engine for the industry??/span&g= t;s broadest range of server, PC chipsets and next-generation low-power system= s on chips (SoC).

That doesn't flow well. How are we releasing version 4.4 of a project?= Do we want to call the overall release "Xen Project Architecture 4.4&= quot;? Or do we need to come up with some other project branding?

--msw

From: = advisory-board-bounces@lists.xenproject.org [advisory-board-bounces@lists.xenproject.org] on behalf of Sarah Conway [sconway@linuxfoundation.org]
Sent: Tuesday, March 04, 2014 12:16 PM

To: advisory-board@lists.xenproject.org
Subject: [Advisory-board] Xen Project 4.4 Release<= br>

Hi everyone.

Attached is the Xen Project 4.4 news release annoucement that will go = out at 8 a.m. ET on Monday, March 10. 

If you have any additional comments or edits, please get back to me by= Thursday morning at the latest. 

Thanks, 


-- 
Sarah Conway
PR Manager
The Linux Foundation
sconway@li= nuxfoundation.org
Skype:  sarah.k.conway
_______________________________________________
Advisory-board mailing list
Ad= visory-board@lists.xenproject.org
http://lists.xenproject.org/cgi-bin/mailman/listinfo= /advisory-board


_______________________________________________
Advisory-board mailing list
Ad= visory-board@lists.xenproject.org
http://lists.xenproject.org/cgi-bin/mailman/listinfo= /advisory-board




-- 
Sarah Conway
PR Manager
The Linux Foundation
sconway@li= nuxfoundation.org
(978) 578-5300 <= /span> Cell
Skype:  sarah.k.conway
_______________________________________________
Advisory-board mailing list
Ad= visory-board@lists.xenproject.org
http://lists.xenproject.org/cgi-bin/mailman/listinfo= /advisory-board


-- IMPORTANT NOTICE: The contents of this email and an= y attachments are confidential and may also be privileged. If you are not t= he intended recipient, please notify the sender immediately and do not disc= lose the contents to any other person, use it for any purpose, or store or copy the information in any medium. Th= ank you.

ARM Limited, Registered office 110 Fulbourn Road, Cambridge CB1 9NJ, Regist= ered in England & Wales, Company No: 2557590
ARM Holdings plc, Registered office 110 Fulbourn Road, Cambridge CB1 9NJ, R= egistered in England & Wales, Company No: 2548782

_______________________________________________
Advisory-board mailing list
Ad= visory-board@lists.xenproject.org
http://lists.xenproject.org/cgi-bin/mailman/listinfo= /advisory-board




-- 
Sarah Conway
PR Manager
The Linux Foundation
sconway@li= nuxfoundation.org
(978) 578-5300  Cell
Skype:  sarah.k.conway
<XenProjectUpdate4.43.6.2014(2)docx>____________________= ___________________________
Advisory-board mailing list
Ad= visory-board@lists.xenproject.org
http://lists.xenproject.org/cgi-bin/mailman/listinfo/advisory-board

_______________________________________________
Advisory-board mailing list
Advisory-board@lists.xenproject.org
http://lists.xenproject.org/cgi-bin/mailman/listinfo/advisory-board

--_000_F19B6D5F90FBA84A8D266DC69D10BAD52B0AE92Dex10mbx31008ant_-- --===============0251026595235440716== Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Disposition: inline _______________________________________________ Advisory-board mailing list Advisory-board@lists.xenproject.org http://lists.xenproject.org/cgi-bin/mailman/listinfo/advisory-board --===============0251026595235440716==-- From advisory-board-bounces@lists.xenproject.org Fri Mar 07 23:11:31 2014 Return-path: Envelope-to: archives@lists.xenproject.org Delivery-date: Fri, 07 Mar 2014 23:11:31 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WM3vP-0001LA-7E; Fri, 07 Mar 2014 23:11:31 +0000 Received: from mail6.bemta5.messagelabs.com ([195.245.231.135]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WM3vN-0001L5-Ma for advisory-board@lists.xenproject.org; Fri, 07 Mar 2014 23:11:30 +0000 Received: from [85.158.139.211:7172] by server-3.bemta-5.messagelabs.com id C6/72-13671-0225A135; Fri, 07 Mar 2014 23:11:28 +0000 X-Env-Sender: sconway@linuxfoundation.org X-Msg-Ref: server-5.tower-206.messagelabs.com!1394233885!3937734!1 X-Originating-IP: [74.125.82.178] X-SpamReason: No, hits=0.9 required=7.0 tests=BODY_RANDOM_LONG, HTML_50_60, HTML_MESSAGE, ML_RADAR_SPEW_LINKS_23, RCVD_BY_IP, spamassassin: X-StarScan-Received: X-StarScan-Version: 6.9.16; banners=-,-,- X-VirusChecked: Checked Received: (qmail 30594 invoked from network); 7 Mar 2014 23:11:25 -0000 Received: from mail-we0-f178.google.com (HELO mail-we0-f178.google.com) (74.125.82.178) by server-5.tower-206.messagelabs.com with RC4-SHA encrypted SMTP; 7 Mar 2014 23:11:25 -0000 Received: by mail-we0-f178.google.com with SMTP id u56so5830209wes.37 for ; Fri, 07 Mar 2014 15:11:25 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linuxfoundation.org; s=google; h=mime-version:in-reply-to:references:date:message-id:subject:from:to :cc:content-type; bh=ug9/vVkjqlwueYPUlfQrNUR+CzeTSZnzRYYGjIQgz0M=; b=WOkyGfHEpvSSRWg4paIfVxKvW673HEItcV+AwdJoG0fr3VezuuRFusLxYry0mBPKWi zpf6dzu4dSWWasfHbOZO4JJSpmGJ1E2WBE24Zi7rmG5brZmvoFAVANMoqkg1GYBDlTRC sUJOk58SC5DCZN8ZS9WL8Fe3rMV9o5aVf8AWQ= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:mime-version:in-reply-to:references:date :message-id:subject:from:to:cc:content-type; bh=ug9/vVkjqlwueYPUlfQrNUR+CzeTSZnzRYYGjIQgz0M=; b=TdfW0uD7avUfVEwADDjzHuVYVLIUGe9EmvBfvHUAukbqZ7flbCDNmzWR0lqgzMGX4O yTRtjLynXj9uuvbR25LsoLbR7+6AVspZOryNTp9tLqJ9BBXVZDlWwrqthLVLo/lGfULo rIbm1NwAB4rBNQmVCZnGHjVZ8JjwvONDc8xNuRf6HFy9zYN0zQAr9utTjYPt2wHkwqMP nxZ5lz5aE9H0FwfpOS4B/YxNMWauiczUDDJdI3utm1ik3BPcONyf2nNeCXgg0GwrnEc4 Pu8IAMbKMc67FXyur/1jKojmmQlxAWBlYLLIerE2MuT75nm5qAZfk6S3UiHrP72w2tYt hNTg== X-Gm-Message-State: ALoCoQn2ONSZ69VPXl2c8ylSb03nQWNhkew5mkadgfdXEws2qpxZahtcZqbKwPuheOnS8D88L61B MIME-Version: 1.0 X-Received: by 10.180.38.7 with SMTP id c7mr658505wik.0.1394233885026; Fri, 07 Mar 2014 15:11:25 -0800 (PST) Received: by 10.194.221.167 with HTTP; Fri, 7 Mar 2014 15:11:24 -0800 (PST) In-Reply-To: References: <6848793A-A83B-40A1-A40C-2AA9DCC1E80A@citrix.com> <2BCAC582-CB61-4E16-96C4-6C1AEFAF81FB@citrix.com> <545D5AEE-789B-4534-9983-A9EA3FD1ECC1@citrix.com> <25264475-F9F3-401F-A7E8-579896CD2D0B@citrix.com> Date: Fri, 7 Mar 2014 18:11:24 -0500 Message-ID: From: Sarah Conway To: "Wilson, Matt" Content-Type: multipart/mixed; boundary=e89a8f6479e9737f3304f40c5f93 Cc: Advisory-board discussions , Jennifer Cloer Subject: Re: [Advisory-board] Xen Project 4.4 Release X-BeenThere: advisory-board@lists.xenproject.org X-Mailman-Version: 2.1.13 Precedence: list Reply-To: Advisory-board discussions List-Id: Advisory-board discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: advisory-board-bounces@lists.xenproject.org Errors-To: advisory-board-bounces@lists.xenproject.org --e89a8f6479e9737f3304f40c5f93 Content-Type: multipart/alternative; boundary=e89a8f6479e9737f3004f40c5f91 --e89a8f6479e9737f3004f40c5f91 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: quoted-printable Hi all, I've aggregated all edits and have done a legal review of the brand name use. Several reporters are planning articles for Monday AM when the embargo lifts on this release. I'm closing edits now and finalizing for the wire. I'll work with Lars and Jennifer moving forward to improve the writing and establish a better review process. Thanks, On Fri, Mar 7, 2014 at 4:27 PM, Wilson, Matt wrote: > In particular: > > "Xen Project 4.4 Hypervisor" -> "Xen Project Hypervisor version 4.4" > > "This release further advances the Project=E2=80=99s position as a fast, = scalable, > secure virtualization engine for the industry=E2=80=99s broadest range of= server, > PC chipsets and next-generation low-power system on chips (SoC) devices." > PC chipsets? Wouldn't it make more sense to say something like "server, > workstation and low-power system on a chip (SoC) devices"? Note the drop = of > "next-generation" since SoC is quite established today. > > "Additionally, developers creating services and apps with embedded, mobil= e > and cloud systems will benefit from the updated event channel > implementation when scaling out their Infrastructure as a Service > offerings." "apps" -> "applications". > > We need to have a deliberate decision to introduce "Xen Project > Architecture" in our nomenclature. I'm not aware of a use like this in th= e > past. > > "All the userspace tools, such as the xl management tool, are 64-bit read= y > and can be used to create 64-bit virtual machines out of the box." - > written like a developer (no offense to developers on this list). > > > "Top contributors include Amazon, AMD, Analog Devices, Broadcom, Citrix, > Fujitsu, Intel, Linaro, NSA, Oracle, Suse, Verizon/Terremark, plus numero= us > individual and academic contributors. "Amazon" must be "Amazon Web > Services". "Suse" should be "SUSE". "plus" should be something like "alon= g > with". "Top contributors .. academic contributors" is a bit redundant. > Perhaps "academic institutions"? > > > There's a lot of room for improvement on this. Incorporating a few key > changes isn't really going to make this a quality release with a strong > story. Overall, I'm quite surprised and disappointed with the current sta= te. > > --msw > > ------------------------------ > *From:* advisory-board-bounces@lists.xenproject.org [ > advisory-board-bounces@lists.xenproject.org] on behalf of Mark Hinkle [ > Mark.Hinkle@citrix.com] > *Sent:* Friday, March 07, 2014 10:27 AM > > *To:* Advisory-board discussions > *Cc:* Jennifer Cloer > *Subject:* Re: [Advisory-board] Xen Project 4.4 Release > > I don=E2=80=99t disagree with Matt the text is awkward particularly bec= ause of > it=E2=80=99s highly technical nature. Do you have any specific feedback f= or Sarah > to incorporate. I didn=E2=80=99t want to push too hard since the clock is= ticking > but we should get this right. > > Going forward I would like to suggest using Oracle=E2=80=99s bulleted li= st > format for their press releases since tying together the actual news and > tech content into a compelling narrative is pretty tough. Here an example > of what I=E2=80=99d propose. > > http://www.oracle.com/us/corporate/press/2033376 > > Regards, Mark > > > On Mar 7, 2014, at 12:17 PM, Wilson, Matt wrote: > > I'm not satisfied with the quality of this text (typos, etc.) given the > plan to put it on the wire Monday. We still don't have a strong message a= nd > a plan on how we plan to brand the technologies that are produced by the > community. > > --msw > > ------------------------------ > *From:* advisory-board-bounces@lists.xenproject.org [ > advisory-board-bounces@lists.xenproject.org] on behalf of Mark Hinkle [ > Mark.Hinkle@citrix.com] > *Sent:* Friday, March 07, 2014 9:04 AM > *To:* Advisory-board discussions > *Cc:* Jennifer Cloer > *Subject:* Re: [Advisory-board] Xen Project 4.4 Release > > Sarah, > > Branding seems to be applied appropriately though I think there were a > couple of spelling issues I caught. Attached is fine by me though the > branding and flow is still a bit challenging. > > Mark > > > On Mar 7, 2014, at 10:13 AM, Sarah Conway > wrote: > > Hi everyone. > > I've incorporated everyone's edits. I tried to reconcile the TM-related > issues of brand confusion and flow as best I could. As you can imagine, I > got varying edits, which started to conflict with one another. > > This would benefit from another TM review/final approval. Can someone > step up to do this and make a final call? > > Mike D., Citrix is on the full AB email list so they've been involved in > reviews. > > Please advise soonest. > > Thanks, > > > > > On Fri, Mar 7, 2014 at 8:13 AM, Richard Phelan > wrote: > > Hi, > > I agree with Mark as the current press release is highlighting issues > that seem to make the articulation of brand and brand values more > cumbersome than is desirable. > > I'm happy to go with the proposed changes for the reasons stated. > > One minor point, I'd prefer "?=E5=90=81ystem on Chip (SoC) devices.", tw= o sets > of plurals make it unclear how many systems are on each chip and the > plurals get submerged into the acronym; common usage seems to be SoCs. > > Thanks, > > Richard. > > From: Mark Hinkle > Reply-To: Advisory-board discussions > Date: Friday, 7 March 2014 05:32 > To: Advisory-board discussions > > Subject: Re: [Advisory-board] Xen Project 4.4 Release > > My apologies for the slow reply I was stuck on the road and couldn?? > read the release on my phone to formulate a proper response. I should mov= e > to a highly elastic Xen Project-powered cloud that allows me to autoscale > ;) (sorry bad cloud joke). > > I am fine without doing the acronym and I think the realigning and > branding discussion should be had. I?? like to have that discussion durin= g > our next board meeting. Given time is of the essence I think we should ju= st > update the links to version versus Xen 4.3.1. > > Also I took a shot at the wording of the press release. It?? probably > not perfect but makes it read a bit better. Attached are my proposed edit= s. > Sarah, I sent you the word doc with track changes assuming we have some > edits to agree on. > > > Regards, Mark > > Xen Project Releases Update to Enterprise Hypervisor Software > > *Open Source Virtualization Software Release Includes Additional ARM > Support and Scalability for Cloud and Mobile Environments * > > > > SAN FRANCISCO, March 10, 2014 ??/span> Xen Project, a Collaborative > Project hosted at The Linux Foundation, today announced availability of t= he > Xen Project 4.4 with enhanced ARM support. The latest release also includ= es > major performance and system scalability improvements for enterprise > computing, such as mobile and cloud environments, where virtualization > technology is increasingly in demand. > > This release further advances the Project??/span>s position as a fast, > scalable, secure virtualization engine for the industry??/span>s broadest > range of server, PC chipsets and next-generation low-power systems on chi= ps > (SoC). > > Major contributions from AMD, Citrix, Intel, Oracle and SUSE are pushing > the Xen Project software to take advantage of the latest hardware. > Additionally, developers creating services and apps with embedded, mobile > and cloud systems will benefit from new features such as event channeling > when scaling out their Infrastructure as a Service offerings. > > ??/span>Virtualization and low-powered servers are leading companies to > rethink the data center and its potential for efficiency,?? said Lars > Kurth, Chairman of the Xen Project advisory board. ??/span>Our solution > contains IT-related costs, plus meets the security and scalability needs = of > today??/span>s elastic cloud, mobile and social networking companies. The > latest updates continue the Project??/span>s track record of rich > collaboration and widespread development from many of the world??/span>s > technology leaders. This certainly explains the significant growth of ARM > support, which we??/span>re pleased to see advance so quickly.??/span> > > Support for ARM on Xen Project Architecture Grows Quickly > > The new release introduces significant stability, usability and > performance improvements for the ARM architecture and extended hardware > compatibility. AppliedMicro??/span>s X-Gene, the Arndale Board, Calxeda > ECX-2000, TI OMAP5 and the Allwinner SunXi boards are all supported. The > substantially improved multiplatform capabilities of the hypervisor allow > hardware and embedded vendors to port the Xen Project technology to new A= RM > SoCs easily, shortening their time to market. > > > > Additional enhancements in this release included 64-bit guest support on > ARMv8 platforms. All the userspace tools, such as the xl management tool, > are 64-bit ready and can be used to create 64-bit virtual machines out of > the box. > > > > The Xen Project hypercall ABI is now stable and will be maintained for > backward compatibility, so users can trust future releases to boot older > operating systems. > > Additional improvements include extended support for ARM specific > bootloaders and firmware interfaces, and support for physical partitions > and LVM volumes to store disks of virtual machines. > > > > Improved Event Channel Scalability For Cloud Computing > > Xen Project developers continues to drive innovation and collaboration > around server virtualization and the cloud. Powering many of the largest > clouds in production today, including Amazon EC2, Rackspace Cloud and > others, the community understands the need to run more virtual machines o= n > a single host. > > Yet demands on hypervisor scalability continue to increase, both from > larger machines, new workloads such as virtualization desktop > infrastructures (VDI) and new cloud OS technologies, including MirageOS, > ErlangOnXen, OSv, and HalVM. Recognizing that high-availability and > stability are critical to VDIs and cloud deployments; the XenServer team = at > Citrix contributed the new event channel implementation to the Xen Projec= t. > To help eliminate workload limitations for users, this enables the > hypervisor to run thousands of guests on a single physical machine. > > Experimental Support for PVH Mode for Guest > > Oracle has contributed a functional preview of a new virtualization mode > called PVH currently available to virtualized guests. PVH > is an extension to the classic Xen Project Paravirtualization (PV) that > uses the hardware virtualization extensions available on modern x86 > processors. PVH uses PV drivers for boot and I/O and Intel hardware > virtualization extensions for page table operations, system calls and oth= er > privileged operations. This not only improves performance and security, b= ut > also simplifies the architecture and Xen Project Hypervisor-Linux interfa= ce > significantly. > > ??/span>PVH is a major development for Xen Project software on x86 and > has the potential to greatly simplify the Linux interface in due time, ??= said > Konrad Rzeszutek Wilk, Software Development Manager at Oracle, a Xen > Project advisory board member. ??/span>We expect PVH to have the best > characteristics of all virtualization modes -- a simple, fast, secure > interface, with low memory overhead, that also takes full advantage of th= e > latest hardware.??/span> > > > > Additional key updates include: > > =E5=9A=99=E8=B8=9D=E8=95=AD Better performance with modern storage de= vices and big data -- > Indirect descriptors for block PV protocol (Linux) allow each individual > request to triple in size, greatly improving I/O performance when running > on fast storage technologies such as solid-state drive and RAID. Availabl= e > in any guest running Linux 3.11 or higher (regardless of Xen Project > version). > > > > =E5=9A=99=E8=B8=9D=E8=95=AD More powerful driver domains -- Disk driv= er domains can now > uniformly run block scripts and user-space backends, such as qdisk, > bringing them up to feature parity with domain 0. This means host > administrators can take advantage of the enhanced security, scalability, > and robustness provided by driver domains without sacrificing the wide > array of disk configuration options provided by Xen in dom0. > > =E5=9A=99=E8=B8=9D=E8=95=AD New SPICE protocol support -- Functionali= ty such as clipboard > sharing and USB redirection creates a much richer connection for virtual > desktops and better graphics performance. > > =E5=9A=99=E8=B8=9D=E8=95=AD Enhanced diagnostics and kexec debug supp= ort -- When a crash > happens, a special kernel is allowed immediate to collect information abo= ut > the root cause, offering developers better diagnosis and repair abilities= . > > The 4.4 release is the result of a broad, collaborative development effor= t > representing engineers from more than 13 leading hardware, software and > security vendors. Top contributors include Amazon, AMD, Analog Devices, > Broadcom, Citrix, Fujitsu, Intel, Linaro, NSA, Oracle, Suse, > Verizon/Terremark, plus numerous individual and academic contributors. Th= e > freely available download can be found on the XenProject.org > website (insert url). > > > *About Xen Project* > > The Xen Project software is an open source virtualization platform > licensed under the GPLv2 with a similar governance structure to the Linux > kernel. Designed from the start for cloud computing, the Project has more > than a decade of development and is being used by more than 10 million > users. A Collaborative Project at The Linux Foundation, the Xen Project > team is focused on advancing virtualization in a number of different > commercial and open source applications including server virtualization, > Infrastructure as a Service (IaaS), desktop virtualization, security > applications, embedded and hardware appliances. It counts many industry a= nd > open source community leaders among its members including: Amazon Web > Services, AMD, ARM, Bromium, Calxeda, CA Technologies, Cisco, Citrix, > Google, Intel, Oracle, Samsung and Verizon. For more information about th= e > Xen Project hypervisor and to participate, please visithttp://xenproject.= > org . > > ### > > Sarah Conway > > The Xen Project > > Media Contact > > publicity@lists.xenproject.org > > > On Mar 6, 2014, at 12:44 PM, Wilson, Matt wrote: > > Mark, thoughts? > > ------------------------------ > *From:* Wilson, Matt > *Sent:* Wednesday, March 05, 2014 10:01 AM > *To:* Advisory-board discussions > *Subject:* RE: [Advisory-board] Xen Project 4.4 Release > > I'd rather use "Xen Project Hypervisor" than introduce an acronym. I > think it's important that "Xen Project" not be split from "Hypervisor." > > This still doesn't address how the umbrella project is called. This new > release doesn't only include the hypervisor, but also the associated > toolstack and utilities. Maybe we're OK calling all of that the > "Hypervisor," even if we identify the development teams differently. > > How should we re-align all of the branding? For example: > http://xenproject.org/developers/teams/hypervisor.html > > Should the links under "Hypervisor Downloads" be "version 4.3.1" instead > of "Xen 4.3.1" to resolve the trademark concerns? > > --msw > > ------------------------------ > *From:* advisory-board-bounces@lists.xenproject.org [ > advisory-board-bounces@lists.xenproject.org] on behalf of Sarah Conway [ > sconway@linuxfoundation.org] > *Sent:* Wednesday, March 05, 2014 9:33 AM > *To:* Advisory-board discussions > *Subject:* Re: [Advisory-board] Xen Project 4.4 Release > > Mark et all, > > I agree that using Xen Project is a mouthful. Given that there is close > overlap and occasional branding confusion with Citrix products, if we add > another new term or acronym into the mix, we'll want to be diligent about > being consistent in blogs, presentations, news releases, web site copy, > customer testimonials etc. > > For the sake of simplicity, how about using XPH - all uppercase - on > second reference? Thoughts? > > Thanks, > > > > > > > On Wed, Mar 5, 2014 at 9:18 AM, Mark Hinkle > wrote: > > How about this convention only say Xen Project and Xen Project hypervisor > once then. Use the abbreviation XPh throughout the release. Just snipping > Matt?? example to make the point. I would guess that the appropriate > capitalization would be lower case for the word hypervisor. > > Mark > > The Xen Project, a Collaborative Project hosted at The Linux > Foundation, today announced availability of the Xen Project hypervisor(XP= h) > 4.4 with enhanced ARM support. > > XPh 4.4 further advances the Project??/span>s position as a fast, > scalable, secure virtualization engine for the industry??/span>s broadest > range of server, PC chipsets and next-generation low-power systems on chi= ps > (SoC). > > > On Mar 4, 2014, at 4:01 PM, Wilson, Matt wrote: > > The "Xen Project" terminology makes the message extremely cumbersome. > > The Xen Project, a Collaborative Project hosted at The Linux Foundation, > today announced availability of the Xen Project 4.4 Hypervisor with > enhanced Xen Project-on-ARM support. > > Why not just say "enhanced ARM support"? We should adopt some usage > guidelines for sub-project branding. We shouldn't insert words/numbers > between "Xen Project" and a sub-project name. > > The Xen Project, a Collaborative Project hosted at The Linux Foundation, > today announced version 4.4 of the Xen Project Hypervisor with enhanced A= RM > support. > > > or > > The Xen Project, a Collaborative Project hosted at The Linux Foundation, > today announced the release of Xen Project Hypervisor 4.4 with enhanced A= RM > support. > > > Later on, this release is called "Xen Project 4.4" > > The Xen Project 4.4 release further advances the Project??/span>s > position as a fast, scalable, secure virtualization engine for the indust= ry > ??/span>s broadest range of server, PC chipsets and next-generation > low-power systems on chips (SoC). > > That doesn't flow well. How are we releasing version 4.4 of a project? > Do we want to call the overall release "Xen Project Architecture 4.4"? Or > do we need to come up with some other project branding? > > --msw > > ------------------------------ > *From:* advisory-board-bounces@lists.xenproject.org [ > advisory-board-bounces@lists.xenproject.org] on behalf of Sarah Conway [ > sconway@linuxfoundation.org] > *Sent:* Tuesday, March 04, 2014 12:16 PM > > *To:* advisory-board@lists.xenproject.org > *Subject:* [Advisory-board] Xen Project 4.4 Release > > Hi everyone. > > Attached is the Xen Project 4.4 news release annoucement that will go > out at 8 a.m. ET on Monday, March 10. > > If you have any additional comments or edits, please get back to me by > Thursday morning at the latest. > > Thanks, > > > -- > Sarah Conway > PR Manager > The Linux Foundation > sconway@linuxfoundation.org > (978) 578-5300 Cell > Skype: sarah.k.conway > _______________________________________________ > Advisory-board mailing list > Advisory-board@lists.xenproject.org > http://lists.xenproject.org/cgi-bin/mailman/listinfo/advisory-board > > > > _______________________________________________ > Advisory-board mailing list > Advisory-board@lists.xenproject.org > http://lists.xenproject.org/cgi-bin/mailman/listinfo/advisory-board > > > > > -- > Sarah Conway > PR Manager > The Linux Foundation > sconway@linuxfoundation.org > (978) 578-5300 Cell > Skype: sarah.k.conway > _______________________________________________ > Advisory-board mailing list > Advisory-board@lists.xenproject.org > http://lists.xenproject.org/cgi-bin/mailman/listinfo/advisory-board > > > > -- IMPORTANT NOTICE: The contents of this email and any attachments are > confidential and may also be privileged. If you are not the intended > recipient, please notify the sender immediately and do not disclose the > contents to any other person, use it for any purpose, or store or copy th= e > information in any medium. Thank you. > > ARM Limited, Registered office 110 Fulbourn Road, Cambridge CB1 9NJ, > Registered in England & Wales, Company No: 2557590 > ARM Holdings plc, Registered office 110 Fulbourn Road, Cambridge CB1 9NJ, > Registered in England & Wales, Company No: 2548782 > > _______________________________________________ > Advisory-board mailing list > Advisory-board@lists.xenproject.org > http://lists.xenproject.org/cgi-bin/mailman/listinfo/advisory-board > > > > > -- > Sarah Conway > PR Manager > The Linux Foundation > sconway@linuxfoundation.org > (978) 578-5300 Cell > Skype: sarah.k.conway > > _______________________________________________ > Advisory-board mailing list > Advisory-board@lists.xenproject.org > http://lists.xenproject.org/cgi-bin/mailman/listinfo/advisory-board > > > _______________________________________________ > Advisory-board mailing list > Advisory-board@lists.xenproject.org > http://lists.xenproject.org/cgi-bin/mailman/listinfo/advisory-board > > > --=20 Sarah Conway PR Manager The Linux Foundation sconway@linuxfoundation.org (978) 578-5300 Cell Skype: sarah.k.conway --e89a8f6479e9737f3004f40c5f91 Content-Type: text/html; charset=UTF-8 Content-Transfer-Encoding: quoted-printable
Hi all,=C2=A0

I've aggregated all e= dits and have done a legal review of the brand name use.=C2=A0
Several reporters are planning articles for Monday AM when the= embargo lifts on this release.=C2=A0

I'm closing edits now and finalizing for the wire. = I'll work with Lars and Jennifer moving forward to improve the writing = and establish a better review process.=C2=A0

Thanks,=C2=A0


=



On Fri, Mar 7, 2014 at 4:27 PM, Wilson, Matt <= msw@amazon.com><= /span> wrote:

In particular:

"Xen Project 4.4 Hypervisor" -> "Xen Project Hypervisor version 4.4"

"This release further advances the Project=E2=80=99s position as a fast, scalable, secur= e virtualization engine for the industry=E2=80=99s broadest range of server= , PC chipsets and next-generation low-power=C2=A0system on chips (SoC) devices." =C2=A0PC chipsets? Wouldn't it make more sense to say something like "serv= er, workstation and low-power system on a chip (SoC) devices"? Note th= e drop of "next-generation" since SoC is quite established today.=

"Additionally, developers creating services and apps with embedded, mobile and cloud syst= ems will benefit from the updated event channel implementation when scaling= out their Infrastructure as a Service offerings." "apps" -&= gt; "applications".

We need to have a deliberate decision to introduce "Xen Project Architecture" in our nomenclature. I'm not aware of a use= like this in the past.

"All the userspace tools, such as the xl management tool, are 64-bit ready and can be used to= create 64-bit virtual machines out of the box." - written like a deve= loper (no offense to developers on this list).


"Top contributors include Amazon, AMD= , Analog Devices, Broadcom, Citrix, Fujitsu, Intel, Linaro, NSA, Oracle, Su= se, Verizon/Terremark, plus numerous individual and academic contributors.= =C2=A0"Amazon" must be "Amazon Web Services". "Suse" should be "SUSE&quo= t;. "plus" should be something like "along with". "= ;Top contributors ..=C2=A0academic contributors" is a bit redun= dant. Perhaps "academic institutions"?

=C2=A0

There's a lot of room for improvement on this. Incorporating a few= key changes isn't really going to make this a quality release with a s= trong story. Overall, I'm quite surprised and disappointed with the cur= rent state.

--msw

From: <= a href=3D"mailto:advisory-board-bounces@lists.xenproject.org" target=3D"_bl= ank">advisory-board-bounces@lists.xenproject.org [advisory-board-= bounces@lists.xenproject.org] on behalf of Mark Hinkle [Mark.Hinkle@citrix.com]
Sent: Friday, March 07, 2014 10:27 AM
To: Advisory-board discussions
Cc: Jennifer Cloer
Subject: Re: [Advisory-board] Xen Project 4.4 Release

I don=E2=80=99t disagree with Matt the text is =C2=A0awkward=C2=A0part= icularly because of it=E2=80=99s highly technical nature. Do you have any s= pecific feedback for Sarah to incorporate. I didn=E2=80=99t want to push to= o hard since the clock is ticking but we should get this right.=C2=A0

Going forward I would like to suggest using Oracle=E2=80=99s bulleted = list format for their press releases since tying together the actual news a= nd tech content into a compelling narrative is pretty tough. Here an exampl= e of what I=E2=80=99d propose. =C2=A0

http://www.oracle.com/us/corporate/press/2033376

Regards, Mark=C2=A0


On Mar 7, 2014, at 12:17 PM, Wilson, Matt <msw@amazon.com> wrote:

I'm not= satisfied with the quality of this text (typos, etc.) given the plan to pu= t it on the wire Monday. We still don't have a strong message and a pla= n on how we plan to brand the technologies that are produced by the community.

--msw

From:=C2=A0= advisory-board-bounces@lists.xenproject.org [advisor= y-board-bounces@lists.xenproject.org] on behalf of Mark Hinkle [Mark.Hinkle@citrix.com= ]
Sent:=C2=A0Friday, March 07, 2014 9:04 AM
To:=C2=A0Advisory-board discussions
Cc:=C2=A0Jennifer Cloer
Subject:=C2=A0Re: [Advisory-board] Xen Project 4.4 Rele= ase

Sarah,=C2=A0

Branding seems to be applied appropriately though I think there were a= couple of spelling issues I caught. Attached is fine by me though the bran= ding and flow is still a bit challenging.=C2=A0

Mark=C2=A0


On Mar 7, 2014, at 10:13 AM, Sarah Conway <sconway@linuxfoundation.org>= ; wrote:

Hi everyone.

I've incorporated everyone's edits. I tried to reconcile the T= M-related issues of brand confusion and flow as best I could. As you can im= agine, I got varying edits, which started to conflict with one another.

This would benefit from another TM review/final approval. Can someone = step up to do this and make a final call?=C2=A0

Mike D., Citrix is on the full AB email list so they've been invol= ved in reviews.=C2=A0

Please advise soonest.=C2=A0

Thanks,




On Fri, Mar 7, 2014 at 8:13 AM, Richard Phelan=C2=A0<Richard.Phelan@arm.com>=C2=A0wrote:
Hi,

I agree with Mark as the current press release is highlighting issues = that seem to make the articulation of brand and brand values more cumbersom= e than is desirable.

I'm happy to go with the proposed changes for the reasons stated.<= /div>

One minor point, I'd prefer "?=E5=90=81ystem on Chip (SoC) de= vices.", two sets of plurals make it unclear how many systems are on e= ach chip and the plurals get submerged into the acronym; common usage seems= to be SoCs.

Thanks,

Richard.

From:=C2=A0Mark Hinkle= <Mark.Hinkl= e@citrix.com>
Reply-To:=C2=A0Advisor= y-board discussions <advisory-board@lists.xenproject.org>
Date:=C2=A0Friday, 7 M= arch 2014 05:32
To:=C2=A0Advisory-boar= d discussions <advisory-board@lists.xenproject.org>

Subject:=C2=A0Re: [Adv= isory-board] Xen Project 4.4 Release

My apologies for the slow reply I was s= tuck on the road and couldn?? read the release on my phone to formulate a p= roper response. I should move to a highly elastic Xen Project-powered cloud= that allows me to autoscale ;) (sorry bad cloud joke).=C2=A0

I am fine without doing the acronym and I think the realigning and bra= nding discussion should be had. I?? like to have that discussion during our= next board meeting. Given time is of the essence I think we should just up= date the links to version versus Xen 4.3.1.=C2=A0

Also I took a shot at the wording of the press release. It?? probably = not perfect but makes it read a bit better. Attached are my proposed edits.= Sarah, I sent you the word doc with track changes assuming we have some ed= its to agree on.=C2=A0


Regards, Mark=C2=A0

Xen Project Release= s Update to Enterprise Hypervisor Software

Open Source Virtualization Software Release In= cludes Additional ARM Support and Scalability for Cloud and Mobile Environm= ents=C2=A0

=C2=A0

SAN FRANCISCO, March 10, 2014=C2=A0??/span><= span>=C2=A0Xen Project, a Collaborative Project hosted at The Linux Foundation, today ann= ounced availability of the Xen Project 4.4 with enhanced ARM support. The l= atest release also includes major performance and system scalability improv= ements for enterprise computing, such as mobile and cloud environments, where virtualization technology is = increasingly in demand.

This release= further advances the Project??/span>s position as a fast, scalable, secure virtualization engine for the industr= y??/span>s broad= est range of server, PC chipsets and next-generation low-power systems on c= hips (SoC).

Major contri= butions from AMD, Citrix, Intel, Oracle and SUSE are pushing the Xen Projec= t software to take advantage of the latest hardware. Additionally, develope= rs creating services and apps with embedded, mobile and cloud systems will benefit fro= m new features such as event channeling when scaling out their Infrastructu= re as a Service offerings.

??/span><= span style=3D"font-size:12pt">Virtualization and low-powered servers are le= ading companies to rethink the data center and its potential for efficiency= ,??=C2=A0said Lars Kurth, Chairman of the Xen Project advisory board.=C2=A0= ??/span>Our solution contains IT-related costs, plus meets the security and scalability needs of today??/span>s e= lastic cloud, mobile and social networking companies. The latest updates continue the Project??/span>s track record of rich collaboration and widespread developmen= t from many of the world?= ?/span>s technology leaders. This certainly explains the significant growth of ARM = support, which we??/span&= gt;re pleased to see advance so quickly.??/span>

Support for ARM on Xen Project Architecture Grows Quic= kly<= u>

The new release introduces significant st= ability, usability and performance improvements for the ARM architecture an= d extended hardware compatibility.=C2=A0 AppliedMicro??/span>s X-Gene, the Arndale Board, Calxeda ECX-2000, TI OMAP5 and the Allwinner Su= nXi boards are all supported. The substantially improved multiplatform capa= bilities of the hypervisor allow hardware and embedded vendors to port the = Xen Project technology to new ARM SoCs easily, shortening their time to market.<= /p>

=C2=A0

Additional enhancements in this release i= ncluded 64-bit guest support on ARMv8 platforms. All the userspace tools, s= uch as the xl management tool, are 64-bit ready and can be used to create 6= 4-bit virtual machines out of the box.

=C2=A0

The Xen Project hypercall ABI is now stab= le and will be maintained for backward compatibility, so users can trust fu= ture releases to boot older operating systems.

Additional improvements include extended = support for ARM specific bootloaders and firmware interfaces, and support f= or physical partitions and LVM volumes to store disks of virtual machines.<= u>

=C2=A0

Improved Event Channel Scalability For Cloud Computing= <= /u>

Xen Project = developers continues to drive innovation and collaboration around server vi= rtualization and the cloud. Powering many of the largest clouds in producti= on today, including Amazon EC2, Rackspace Cloud and others, the community understands the need= to run more virtual machines on a single host.

Yet demands = on hypervisor scalability continue to increase, both from larger machines, = new workloads such as virtualization desktop infrastructures (VDI) and new = cloud OS technologies, including MirageOS, ErlangOnXen, OSv, and HalVM. Recognizing that high-ava= ilability and stability are critical to VDIs and cloud deployments; the Xen= Server team at Citrix contributed the new event channel implementation to t= he Xen Project. To help eliminate workload limitations for users, this enables the hypervisor to run thousan= ds of guests on a single physical machine.=C2=A0=C2=A0=C2=A0<= /span>

Experimental Support for PVH Mode for Guest<= /span>

Oracle has c= ontributed a functional preview of a=C2=A0new virtualization mode called PVH currently available to virtualized guests.<= span>=C2=A0PVH is a= n extension to the classic Xen Project Paravirtualization (PV) that uses the hardware virtualization extensions available on modern x86 p= rocessors. PVH uses PV drivers for boot and I/O and Intel hardware virtuali= zation extensions for page table operations, system calls and other privile= ged operations. This not only improves performance and security, but also simplifies the architecture and Xen Pro= ject Hypervisor-Linux interface significantly.

??/span>PVH is a major development for Xen Project software on x86 and has the potential to greatly simplify the Linux interface in due time,=C2=A0??=C2=A0said Konrad Rzeszutek Wilk, Software Development Manager at Oracle, a Xen Proje= ct advisory board member.=C2=A0??/span>We expect PVH to have the best characteristics of all virtualization modes --= a simple, fast, secure interface, with low memory overhead, that also take= s full advantage of the latest hardware.??/span>

=C2=A0

Additional k= ey updates include:

=E5=9A=99=E8=B8=9D=E8=95=AD=C2=A0=C2=A0=C2= =A0=C2=A0=C2=A0Better pe= rformance with modern storage devices and big data -- Indirect descriptors for block PV protocol (Linux) allow each = individual request to triple in size, greatly improving I/O performance whe= n running on fast storage technologies such as solid-state drive and RAID. = Available in any guest running Linux 3.11 or higher (regardless of Xen Project version).<= /u>

=C2= =A0

=E5=9A=99=E8=B8=9D=E8=95=AD=C2=A0=C2=A0=C2= =A0=C2=A0=C2=A0More powe= rful driver domains --=C2=A0Disk driver domains can now uniformly run block scripts and user-space backends= , such as qdisk, bringing them up to feature parity with domain 0. This mea= ns host administrators can take advantage of the enhanced security, scalabi= lity, and robustness provided by driver domains without sacrificing the wide array of disk configuration op= tions provided by Xen in dom0.

=E5=9A=99=E8=B8=9D=E8=95=AD=C2=A0=C2=A0=C2= =A0=C2=A0=C2=A0New SPICE= protocol support -- Functionality such as clipboard sharing and USB redirection creates a much richer connection = for virtual desktops and better graphics performance.=

=E5=9A=99=E8=B8=9D=E8=95=AD=C2=A0=C2=A0=C2= =A0=C2=A0=C2=A0Enhanced = diagnostics and kexec debug support -- When a crash happens, a special kernel is allowed immediate to collect informat= ion about the root cause, offering developers better diagnosis and repair a= bilities.

The 4.4 release is the result of a broad,= collaborative development effort representing engineers from more than 13 = leading hardware, software and security vendors. Top contributors include A= mazon, AMD, Analog Devices, Broadcom, Citrix, Fujitsu, Intel, Linaro, NSA, Oracle, Suse, Verizon/Terremark, plus= numerous individual and academic contributors. The freely available downlo= ad can be found on the=C2=A0XenProject.org=C2=A0website (insert url).

=C2=A0

About Xen Project

The Xen Proj= ect software is an open source virtualization platform licensed under the G= PLv2 with a similar governance structure to the Linux kernel. Designed from= the start for cloud computing, the Project has more than a decade of development and is = being used by more than 10 million users. A Collaborative Project at The Li= nux Foundation, the Xen Project team is focused on advancing virtualization= in a number of different commercial and open source applications including server virtualization, Infrastructu= re as a Service (IaaS), desktop virtualization, security applications, embe= dded and hardware appliances. It counts many industry and open source commu= nity leaders among its members including: Amazon Web Services, AMD, ARM, Bromium, Calxeda, CA Technologies, Cisco, C= itrix, Google, Intel, Oracle, Samsung and Verizon. For more information abo= ut the Xen Project hypervisor and to participate, please visithttp://xenproject.org.

###

Sarah Conway=

The Xen Proj= ect

Media Contac= t

publicity@lists.xen= project.org



On Mar 6, 2014, at 12:44 PM, Wilson, Matt <msw@amazon.com> wrote:

Mark, thoug= hts?

From:=C2=A0= Wilson, Matt
Sent:=C2=A0Wednesday, March 05, 2014 10:01 AM
To:=C2=A0Advisory-board discussions
Subject:=C2=A0RE: [Advisory-board] Xen Project 4.4 Rele= ase

I'd rather use "Xen Project Hypervisor" than introduce a= n acronym. I think it's important that "Xen Project" not be s= plit from "Hypervisor."

This still doesn't address how the umbrella project is called. This new= release doesn't only include the hypervisor, but also the associated t= oolstack and utilities. Maybe we're OK calling all of that the "Hy= pervisor," even if we identify the development teams differently.

How should we re-align all of the branding? For example:=C2=A0http://xenproject.org/developers/teams/hypervis= or.html

Should the links under "Hypervisor Downloads" be "versi= on 4.3.1" instead of "Xen 4.3.1" to resolve the trademark co= ncerns?

--msw

From:=C2=A0= advisory-board-bounces@lists.xenproject.org=C2=A0[advisory-board-bounces@lists.xenproject.org] on behalf of Sarah Conway [sconway@linuxfoundation.org]
Sent:=C2=A0Wednesday, March 05, 2014 9:33 AM
To:=C2=A0Advisory-board discussions
Subject:=C2=A0Re: [Advisory-board] Xen Project 4.4 Rele= ase

Mark et all,=C2=A0

I agree th= at using Xen Project is a mouthful. Given that there is close overlap and=C2=A0occasional=C2=A0branding confusi= on with Citrix products, if we add another new term or=C2=A0acronym=C2=A0into the mix, we'll want to be dilig= ent about being consistent in blogs, presentations, news releases, web site copy, customer testimonials etc.=C2=A0

For the sake of=C2=A0simplicity, how about using XPH - all up= percase - on second reference? Thoughts?

Thanks,






On Wed, Mar 5, 2014 at 9:18 AM, Mark Hinkle=C2=A0<M= ark.Hinkle@citrix.com>=C2=A0wrote:
How about this convention only say Xen = Project and Xen Project hypervisor once then. Use the abbreviation XPh thro= ughout the release. Just snipping Matt?? example to make the point. I would= guess that the appropriate capitalization would be lower case for the word hypervisor.=C2=A0

Mark=C2=A0

The= =C2=A0Xen Project, a= Collaborative Project hosted at The Linux Foundation, today announced avai= lability of the=C2=A0Xen Project=C2=A0hypervisor(XPh) 4.4 with enhanced=C2=A0ARM support.

XPh 4= .4 further advances the Project??/span>s position as a fast, scalable, secure virtualization engin= e for the industry??/span>s broadest range of server, PC chipsets and next-generation low-power system= s on chips (SoC).


On Mar 4, 2014, at 4:01 PM, Wilson, Matt <msw@amazon.com> wrote:

The "Xen Project" terminology makes the message extremely cu= mbersome.

The=C2=A0Xen Projec= t, a Collaborative Project hosted at The Linux Foundation, today ann= ounced availability of the=C2=A0Xen Project=C2=A04.4 Hypervisor with enhanced=C2=A0<= /span>Xen Project-on= -ARM support.

Why not just say "enhanced ARM support"? We should adopt some usa= ge guidelines for sub-project branding. We shouldn't insert words/numbe= rs between "Xen Project" and a sub-project name.

The X= en Project, a Collaborative Project hosted at The Linux Foundation, today a= nnounced version 4.4 of the Xen Project Hypervisor with enhanced ARM suppor= t.

or
The X= en Project, a Collaborative Project hosted at The Linux Foundation, today a= nnounced the release of Xen Project Hypervisor 4.4 with enhanced ARM suppor= t.

Later on, this release is called "Xen Project 4.4"

The X= en Project 4.4 release further advances the Project??/span>s position as a fast, scalable, secure = virtualization engine for the industry??/span&g= t;s broadest range of server, PC chipsets and next-generation low-power system= s on chips (SoC).

That doesn't flow well. How are we releasing version 4.4 of a proj= ect? Do we want to call the overall release "Xen Project Architecture = 4.4"? Or do we need to come up with some other project branding?

--msw

From:=C2=A0= advisory-board-bounces@lists.xenproject.org=C2=A0[advisory-board-bounces@lists.xenproject.org] on behalf of Sarah Conway [sconway@linuxfoundation.org]
Sent:=C2=A0Tuesday, March 04, 2014 12:16 PM

To:=C2=A0advisory-board@lists.xenproject.org
Subject:=C2=A0[Advisory-board] Xen Project 4.4 Release<= br>

Hi everyone.

Attached is the Xen Project 4.4 news release annoucement that will go = out at 8 a.m. ET on Monday, March 10.=C2=A0

If you have any additional comments or edits, please get back to me by= Thursday morning at the latest.=C2=A0

Thanks,=C2=A0


--=C2=A0
Sarah Conway
PR Manager
The Linux Foundation
sconway@li= nuxfoundation.org
(978) 578-5300=C2=A0=C2=A0Cell
Skype: =C2=A0sarah.k.conway
_______________________________________________
Advisory-board mailing list
Ad= visory-board@lists.xenproject.org
http://lists.xenproject.org/cgi-bin/mailman/listinfo= /advisory-board


_______________________________________________
Advisory-board mailing list
Ad= visory-board@lists.xenproject.org
http://lists.xenproject.org/cgi-bin/mailman/listinfo= /advisory-board




--=C2=A0
Sarah Conway
PR Manager
The Linux Foundation
sconway@li= nuxfoundation.org
(978) 578-5300=C2=A0=C2=A0Cell
Skype: =C2=A0sarah.k.conway
_______________________________________________
Advisory-board mailing list
Ad= visory-board@lists.xenproject.org
http://lists.xenproject.org/cgi-bin/mailman/listinfo= /advisory-board


-- IMPORTANT NOTICE: The contents of this email and an= y attachments are confidential and may also be privileged. If you are not t= he intended recipient, please notify the sender immediately and do not disc= lose the contents to any other person, use it for any purpose, or store or copy the information in any medium. Th= ank you.

ARM Limited, Registered office 110 Fulbourn Road, Cambridge CB1 9NJ, Regist= ered in England & Wales, Company No: 2557590
ARM Holdings plc, Registered office 110 Fulbourn Road, Cambridge CB1 9NJ, R= egistered in England & Wales, Company No: 2548782

_______________________________________________
Advisory-board mailing list
Ad= visory-board@lists.xenproject.org
http://lists.xenproject.org/cgi-bin/mailman/listinfo= /advisory-board




--=C2=A0
Sarah Conway
PR Manager
The Linux Foundation
sconway@li= nuxfoundation.org
(978) 578-5300 =C2=A0Cell
Skype: =C2=A0sarah.k.conway
<XenProjectUpdate4.43.6.2014(2)docx>____________________= ___________________________
Advisory-board mailing list
Ad= visory-board@lists.xenproject.org
http://lists.xenproject.org/cgi-bin/mailman/listinfo= /advisory-board

_______________________________________________
Advisory-board mailing list
Ad= visory-board@lists.xenproject.org
http://lists.xenproject.org/cgi-bin/mailman/listinfo= /advisory-board




--
Sarah Conway
PR Manager
The Linux Foundat= ion
sco= nway@linuxfoundation.org
(978) 578-5300 =C2=A0Cell
Skype: =C2=A0sarah.k.conway
<= /div>
--e89a8f6479e9737f3004f40c5f91-- --e89a8f6479e9737f3304f40c5f93 Content-Type: application/vnd.openxmlformats-officedocument.wordprocessingml.document; name="XenProjectUpdate4.43.6-markW.docx" Content-Disposition: attachment; filename="XenProjectUpdate4.43.6-markW.docx" Content-Transfer-Encoding: base64 X-Attachment-Id: f_hsi2t5fi0 UEsDBBQAAAAIACWRZ0SIY7iK4gAAAE0CAAALABQAX3JlbHMvLnJlbHMBABAAAAAAAAAAAAAAAAAA AAAAAK2SwUoDMRCG7z5FmHs32woi0rQXEXoTWR9gSGZ3QzeZkExr+/YGUXShFEGP88/Mxzcw6+0p TOpIuXiOBpZNC4qiZefjYOC1e1rcgyqC0eHEkQycqcB2s36hCaWulNGnoiojFgOjSHrQutiRApaG E8Xa6TkHlFrmQSe0exxIr9r2TuefDJgz1c4ZyDu3BNWdE/2NrQMJOhTUljMtUq7bWXy9RHWYBxID ju1zjcvHRFPJoC8LrX4vxH3vLT2yPQSKcsmLTkLRkbuuhCldM7r9T6P5xLfMG2en3Wf8ZaNnX7C5 eQdQSwMEFAAAAAgAJZFnRPoBSbfFAAAAKwEAABEAFABkb2NQcm9wcy9jb3JlLnhtbAEAEAAAAAAA AAAAAAAAAAAAAAAAbY/LasNADEX3/QqjvS07gVJMnOy6SiHQFrodNKoz1PNgpNbp33diirPJUtxz D1e7w8VP1Q9ncTEM0DUtVBwoWhfGAd7fnusnqERNsGaKgQf4ZYHDfkepp5j5lGPirI6lKp4gPaUB zqqpRxQ6szfSFCKU8DNmb7ScecRk6MuMjJu2fUTPaqxRg1dhnVYj/Cstrcr0nadFYAl5Ys9BBbum wxurnL3cLSzJSl7ErdQ8z828XbiyqMOPl+PrMr524fo7MeD+4Q9QSwMEFAAAAAgAJZFnRDsYCXyV AAAA5wAAABAAFABkb2NQcm9wcy9hcHAueG1sAQAQAAAAAAAAAAAAAAAAAAAAAACdzr0KwjAUhuHd qwhnb1MdRErTLuLsUN1DcvoDzUnIiaW9eyOCF+D48cLD13SbW8SKkWdPCo5lBQLJeDvTqODR34oL CE6arF48oYIdGbq2uUcfMKYZWWSAWMGUUqilZDOh01zmTLkMPjqd8oyj9MMwG7x683JISZ6q6ixx S0gWbRF+IHzFek3/otabzz9+9nvInmwPb1BLAwQUAAAACAAlkWdEKj5OZOcSAADHlwAAEQAUAHdv cmQvZG9jdW1lbnQueG1sAQAQAAAAAAAAAAAAAAAAAAAAAADtPdt2Ezm27/MVWu4XWKviXEjTTGbC jAmBzhpCMnGgmUe5SnaJVEnVksqOeZrfOGud/rn5ktl7S3WxEyBD0+CC6ocmrotK0r5f9de/XecZ mwtjpVaHg93hzoAJFetEqtnh4NXls61HA2YdVwnPtBKHg6Wwg789/uviINFxmQvlGAyg7IE5HKTO FQfb2zZORc7tUBdCwb2pNjl38NPMtvV0KmPxNLy5vbez83DbiIw7+LhNZWEHYbRFcZfhEsMXMM88 8yMttEkKo2NhLVx96m/WI95lwNURqnFzLlU9zO7O4aA06iCMspXL2Girp24r1vmBX+ABjtO8sX/j 0/VLQ3gp7Ap9HD64u0N/5VmzF/ZTBmjWMU55IZrRZr9vtOdGl0U1Wh7fZVtzbq7KAjeoAFBPZCbd kra2Gmb+oT2dN1uh77D3/p8By+ODk5nShk8yQFuAwgCxdqKTJf5b0P/ODf0zdstMsMXBnGeHg5c4 8WywjXfextXVGPBVGLy6Hd7brgb5wiPZgscABrjFpzDQ4WBvb+f931gcGD+geaaVs/iWjaU8HIyM 5Bl7ojNA1MVBbNevpCNlbzwmuHUjK/nKdT+rd9W39/arK0f2xrU0qaeYCW7o0zrTsApeOo0/pzKD u1P6LyzAZdVLO2HbTLVtYW13W+eXnujiIOMEKLok1NarcXv+iwP3+I1Q7NzotyJ27EjneamANNiF gG9aYdmrIuFOMKfZMQK0MNIK9vOyEGYurTZsDLi/4EbgmM6P/IXQaVLd2/WXJ80ehity/feNJzYG Zzq2mI/jFbJLgixwvsIIC/giBo/PgDMDypQmFuy1NK7kmXxHsrdGJHai4qxMAPVGSSLxFhDP6OKU jcui0MYxUATYOOYZ91ycAZtnR5kuE7pzquGyAGSdS6MVynjL/hDcDAvdGAzaLK4yHr1kzy5GL49O xkdnETvlJk7Z7k7EQJzvb21dpoK1GU9cMZ6IceBCGQAXxKaTc1E/kmrrBMDYMXz5hVTlNXumS9AK EUci4FAJXwIKKLgW44NzLmsc0VPm1j7ZYmIr+LHBu3o7TVWqM9sf7nd8JQvpUtD9U04QRKK3nuiH BHTQ0oV1zHjZxHhmNZMVt8j5W2AEAFJS+2AAYgd2CViTM9viFzIHTXIuPGtA5iEawYb6YemA4CP4 MmAsh3E9Q8HBYuIyosVaIrZIBfCs+SovcyJOFezaDL5mcYoGJgyjZvBbsQQ0R5UMe670xbnSZQrg qNBnWhrgCYbxZI7oYolDBO7wATqqtbu2ekrqqlTucJCIKS8zt4ma3n/+/X9d4Q+PLSu0JemPNMjZ FNT+KJBxJuAvEZc36U6omVSCiBqBKVVSWmeWPTQ3kdtbNjGaJ8TRYQCBQppumYh1Bk8X2lxZ57EP mHrH5W+mF1uFXgBTDHITVhWjU4zdG+uj+yC55hI4ZS+6NgRgp6TzxMDCjJyU5MJkU6NzNjp9GrEj CZevIzConMgidmZ4HBSZ8avxMUNbqyhtitBYV45tZYyB3e/4lfBC0nFPpa7RxVJuEnxw2LLWMtDi AVNEpkEbswyVH1SpiLgRfWgKnaFwXhSZjL1/+JtQr/OJSBKRRDc1W0/0MGmYApsIJabSeXxCiJfk CQL9d44u9xiUdCUy1KYz0qU9DwR1WJGYRoDr0uGb0gAKTg1IcFPGDsU2ifSxRwdAqKkw8Ph3wla6 rHH8f2eods25hDheCzfAYa9nWOKBMA0MNZHtx5VEQ0CDkeAAHleE+ID2nHkHJA0kHWqnDi6gX5cs SHT4S6HiZfQt6pq3s5P//Pu3znDx92igXCbsBQc8+AfagiAxUy7ReXCbvwgkIPqKlmyiQeYN2Tdq VHSHxM9KUFN1RmoP6UBcgvpzcrlF4Vwg8lhb9NAUWWlZLoTzFj5ZjugHIvdQyy+khEgsQR49ib3N +NU9AABG62TslZMVdcXqGFmvEg7trxXmveIp9CqLJeyQqhS9i2ejAOzAIrkCURtrkyDhGRmnAKva +x8E90ImwgLX5kllVlDSBymmwKxr7z7gQpb0YP36YG2836hbgZ6FRCmBDIVBJp0tmbguMmLXxJHl TElQoMDAZDOjF2CkAERb3n/0sgNqdN36Ej1ubiJgwAToDHEVFLpI0EKxQlShC5CH7NdSxlfZcviN 4thvf6RvoE9M2kSgV/keaGCjMABtoG2PjUycShA15FB6DmLDsn96GvgdqLKxzqI2xFaR8pWSsU4E Ox3fQM3VW+sI2rq7gdBHLV6JRR2tBRZldFKi+7itL1gXzLeIlbay5FBpbCcC3Ij4o9aBKMXbOIRv iWsnVAIMtvJrs5WM0SFjI3QHi+QU8z7vwmtXSG0VIHeB4UcA130F4fvFcMvebD0XSkQeHQ3mtwvg xoB5ETvi2bVIODs+erO1t7OzE7HLE3Z2Ojr/kfCU3siyhVRKGDYu1Rvp/VLepcmzrNKdReItYltO MIceXZZZnQOTsByQRoIu7pBYWMwLT0PoBQ1WVdrkesKretGQBhFMiCawOdCNNuQ7Ja697j5rGQXw CFI25fRp2H/MjcGYkU1xvirEoySQqcwpAoXJ28INe77efax/j23Ug/ZbBW0riTck9nkxLBUQeSsb K+TxJezh/tZEOjYr0YEXmBjqfsAu5o9YxarsEPmfj0vCl+izwCp0ZpvMPbx5naGLiM/oq/RAxHpp dIs0Am2KmVLBTvfbc2e29XC/36xP4/H9Vn1gq5D/9bt11936SDbRd8zSMfFKVAI1pMqCOASbV6F+ X7pKx5/o61677rXrHrQb7hBrG9Rkl8do6Y+enGCZiQLbHN1hIUYekvgYlo5j1A1Ua3R9TXh8BdZ7 surYijCEQIo0Q0XQmRKU72lJfjFTlYKCJT7RGphGlgjDMLkz5HX6tMGeg3yzHOS4covaNZ+8LUSM rtheAN9duUMSyjTFxftt+5+0vKk0OXkeJeZiTuEJsPYpH6iFlkW6tBL4Iiu4cdLnxOMzL16fsrnO ytxzMus0DJRIe0WezhvaUWCoPYBuS4n3pbWZ6Fl+rzT2AfdvJeB+UgWFjqnC4yhUeLR7LTyrey0c VZXSfS3YVzcFnOB5neNK0i0x2DpBKqXnTR7lWmalweYJoRJivZC2ijFS6u2QnWPZBEKqnW6ZcTND Hz09Qw79giL0vgIec6ij4NXHN0c5fwfXj4/2InYBNoj32Dd9OzTWYlsfC627QTCYIVzF3l/enY85 2lSeUSqW66YAuOXVgMkzqrUX1DKir1X88vj5L+FCkwOCRyuC3M63b5KyddUiQURgYbrUp/YSfpka shEFjTHfG5VnW0d5KgxIhL1yuoCh2qVmlt17/fTkPqEYvu8L3c7GTTxa4tANnp5Kw2fibByxY4ML PVNAaRG8Mfeq5s88e306ZBci1jMl3/lgNQdzXM7SrZWeI6SYuvoX5pIY0EdRNYUVw6xsq/QuEUWm lxQa+0sVOx970iTqhi/4cs6m2lMkgSQWHy7JwxLOVYbR8URaVKUmgCzdXsaQXWqWiqxgIpO5VOiq rbCb4RUPPp+wRK6ZyEdMhULV264nZwSu6FJdWk95Ux9EXeWJtXkU6GrIWK/qfXeq3vE14I0kHpGx dqLl+euf2SmaKvjjOaJPLz83pHWaL99PuV0RAZxNSxWHDAt4ei5BHgDp83XXBbGKDGtazYFMDgfm JNn3+YPoClliF7kbOL0C2Z+rAYY7/wtKl9UFz4A2YCdRYq7puzmiPDrTYUeRBOLSGCCObMlqXwcy 2PoteMzz1uEN5lnv82braLhKiRqIz3m1LU0hzrgFGbFiYpxzw9f27N756/te9yltJY6q1MD1vjzV J2xrP8O2G8WuHz1koburxmIhnBuNef7aWzLGS0FynaLOdLJ95v/FzhZ3+So5BrF7hY+PhNgF3Imq TicIfNtYIjAfOZeZmAGkm6dDHZPCIIhq0ijtzbZjocgU9NnS+UZlFtUyOZVhq26kHrd3u2lNt+Ub 3dUOz3by83q1x6cyZ0BWgQj40yD8uCixXy2h23ctyvvy7S/AgELjvpXKTvh9azca7XkFkksaEvya RgzAvWaY8QB0GWhtSU+sUxB24EOrE9SfvltD17o1/EMrA/bRxTth34H+c8V+kdlV1DSPfdpCo1NK /DRoO3vlCZuLvr+lA8sxmd18s50dfusMa/hFYIEwqR3AJICuUz73tfsTcjiCwOcxkLPE9gBk6GIa xC0qnWVbW2T6okckqpoI+taBNUOIfF8kLG0ADEB0AJFuUsGTyKs3JL6xCxboESV86KO9sHqu0kmj eHR+fnH2evSCjS9PXrxg58cvn568fN6HOPsQZ+/a+Gw01pSDXIll3aAlVH8c/A6IqDL3j8hsvj4t uHdSr+9BmFP9AtiENvxbPQP3cMmFBsJ4+OcwSut+vUf0xE97FRyqod6PHhJT8w4yMXV+ZKQyjm1r ZzCzvT+v4FDdAnd1NS2I7t0C0b1PhmiXEOmJcNiPrW14kxgPLgX0aaGEDh1LyWSYyJnv5QZKwYlK pEENA5SE2MjC6crHkOn4Ch0PYNk7DTNn98iAuB+qHwWPU2wsLOcywbCTEb9SpRL6TmCcjOwLK9+B WlFZI95LgOiAfouVGWO3RFMqqnkEOKOCUk+9HaGqo11WZzLZwo6zIgR5cWUXo5OnQzaqXSsSI7jL UENVje/toAfD3V0G68R4FezfPSNmoLZkwpIe1daOQ1v5+8OeKHui/D1i9hQD9dR5EdTn4NBjic6p ARDQ4lNpr9YvYxYy5t+VSiK1ABVhcMsTpydYT9MYGNvyuQSY2SxU0ioA/BXT+yI2wdSFUFWcg8hB Wp0CaaIVUHDqBUesw3+b7QQvXy44TARzCEDjz6UCa8Nw4hOUIn1rV9z67ILGAdgKefsIstGT0jqF FEd8AfNqJ8v1DcAZYYWG5bBa7C4ZuvRiMyzGjeGUh4ELxHDAVM7KkNehCx82bI+NZI1uD53v9NTc U/MdRexLsWDj85Oj40YWVom2QLXP6rATElBFcnEmC+9NsWAOI3wQ5V+Nn4Cg9BKXujVSZRI5//A9 7PsmqI+1Cg+gJF5L7Agy3Iv9meFFirZ/S5r2mN1j9l3D3xWbTiSfKe3dSIheV+JaxIBxk3LWxvVf UE/jgLbcpizlRSEwcsR9+QOZMoYSb6xXEmFgmeeA7+HkNEy8Q41KKn8kIWXYTUJ3bJAH2oFIKTH7 qeqF3e6fHlA+TFX6iRpRcGlY3a3js0aCHj36SCSoN27vrv5gsub+cL9pdODjFnC/zJyP1NM5GFE7 P3MuVgIiYjpFTASg47CKqq78WScUGqVGmKhkOUBrtvugbmldeSSjJoTSjk5WTVswFalosgpQxQkG eXc644X80l/EpGos3/Fu/ZE/xGEEAlbPMK4hqdzlCeJKrPPmeIdn5VvpbFmf8wB2Hjc6Yi/Ho6gO fHQGjng0RdcB9xp4OCDj9qUwRmDzog7tP56xPCPro+NZoqCFCaNL23bWIPPjMU9E/uGSxc0CCZiD Trqy+weQ+E5kndn3lfaDXT/7pcm76vZCQJ3u9gISvVCU493tZdTHAnWGnN8IFVzbeCI8W4gJGMgd LyL46FkVXVjDPRBwAsyb0mT3vxs79jOEmz/7Qv+4VO3PYcV/zUTyxyNy17yvhmoTgdl7Xyrvy62p pD73XeN59NafR7+WP1Y3xc3A8FbYdJ+KUUnmPT9/Md/zQSPKLgPNyrAZpo0p34+/PukupNT72Kt3 Ew7BmMcsbmzIUwlR63gowPHlgK1zqFtH1lDSa+Po4SwRaMxQIKjlLaIzytBviEhWWh8CavmHdhhM OMM1UlnZkI3ec+T6+89aX9vVzugAdWVxx0WmxGSFmGCLvmQ6BgKhvYbDmAeAhvAE+zVhtBDdy1Qq CvsgDPmuqeShRQbt8y5bdbG31olHHzzY8d4J5+P7UV2Zu/5ucxJX65NR01Lap3lXzabxGTqne8hO cAElprJRPXp1zPONpTR15OEcGsZz9G7gAX4+2be1wgN2iwuxcsJdnJLnLZdlXvfmhj9G7HKljPhI 2lg3nrnnWs/Q+bZyAGvExjy3ZYiMBVfRkDorEI3eHiS40fkrdORWVA5PrW5iWXAn8LwzsljhAek+ XgP24yfWgO12N81vpULrli15+K2XxT1OnSsOtrevhSoai6ijhWzDP0wTe/Bg932a2Nu4XhudC9rr Zx8H1A8//NArzRsXbuGGp6D+qQVf9tDZ8EY/PYA2DUCnmOSB5OP41wBPs0W3qDE/faIas/fpp9OV E9DjQd/+eyaxNn7z9YsWrrVgBoaJC9tKdsOFILMJE7YPHMy6qdNqdvuR/8BUa3e3F0K2VjEb43IX AKG9vX2f0gV///jI/62NFFgYhplIhktXvXTKDY6tC3h23z9q5Cx1zc+Jdk7nzW+fNVb98gvz2Wes mnadjAZvy0Su71S1Lds4eLKkPxKwQtHp8PhP/wVQSwMEFAAAAAgAJZFnRE9RaRTpBAAAYBcAAA8A FAB3b3JkL3N0eWxlcy54bWwBABAAAAAAAAAAAAAAAAAAAAAAAO1YS2/jNhC+91cIOvSWyDKCbeuu d+GkWCRAmgZ59E5JtM2aIgWStuL99R1SpCyTsmwH2F2gaC4ShzPUN8NvHs7Hz28ljTZYSMLZNE4v R3GEWc4LwhbT+PXly8WvcSQVYgWinOFpvMUy/vzpYz2RakuxjMCcyUk9jZdKVZMkkfkSl0he8goz 2JtzUSIFS7FIai6KSvAcSwmnlzQZj0YfkhIRFttjyvyUc0okVuvqIudlhRTJCCVqa85yx9TpVXBO SXLBJZ+rS7BL+HxOcmwQgWU6Mm8ljaMyn9wtGBcoo+AsHBRrXwue/4HnaE2V1EvxKOzSrszjC2dK RvUEyZyQafxCSgjPA66jJ14icLGe5LJXvJwx2W+AkVQzSdA0ngmCaPTKCFwNjv58jhP9zQx0NohO 45Fd30hPQvx1oJGjyhfJElF60yNXgqywJyx6pXytKGG+FJcZlwHEshKEKU+6QYzIpY+VUy6cDK0V t7gqlAOjPOXardORlaywYJ5SxSVRQH3f069OMG4lu8g52doJGKSGuWCNr4ssK1q4jFDrGRZqRsmi /WaGJNbBarYpYgt4SSyxEp9ulb8yD7TA1wKj1TWGTPHDPheoxI8aCWL5kot7nq/0Jghq+1za5+YZ YomdsLt4M5inMcVzpddbp/S01qmC31Bu5JuZ+cY0hjRdQGo3d0EKXt9AgghO22tptti6bHwgdEM9 4LB3V+zJko6BXFeVgGJyD7F7WJcZFDH/dq8Lo6l4FVyD9iMQZlwpXgZiQRbLHmWsaoxZKEf+pSc7 KA70DDhyu62WmAVZ1rI5M5dp49wstJlVsHI0V1h030MVTS5g7VW7aK5sR1PCdJR1RKyFcdi+z4mQ 6t4cYRH+kzvIhgzdhL/f3eFvznNL4y5xk6CmmnYCpmpbwYcqJNBCoGqpARSNmmZMZBXvimn8oFsC NfWZAb93uWjEDX/wW3ttDx25zZoVxtVDR6UtE7jS/gZsGkyyPoq7G122JM4pRsIvFSbIdL+kHaVJ RgpyGnO6DLFU+OXDj6PCwY5pepzrk0HD2zXKvq3/Wqfc63Qj8zfU697V2cY9nW083Nm6SE7oY24H s4tX75pakeYxEFBcPM/i/b5nMj2sDfkSikMOlB6oDbayRI+ujkSaa0GtOKAW1I7DeifCbIFBLmMB QVoFWHY7SSdH2ovQIzPFp0VI6el1IDovej86UD/3NoNIhLuQ0+apMtpAhpc7U0TcbNGAKt6QRb/T FM423x3yrFGaYaWxMzXnidfxIQWKhvfNATecDh4wtJ/Br5/0b2D7oMb4qEZ6y8XX4TMGNRi+wfQw TFYPbstha9laH+YVM0MWEHGwK0f3RIap5uQ9fbmz0ZDpMIK9uWCXVBgVWEQ/o7L6HTKT66QL0qtH J8ByUOl7DQzpuwcGyHlpn87UdG6tC60AevBo7CZop/uNh4wfOW8eHDJuMd1gRXL0/6Dx3QaNq55B 46pv0Dg+V5w5HnTKEtiHNak99H1N/HJ0uI1fOgIA+uIv5n/TKzy+lWXvmUHcDQln1JC5+TstuHsd oI2Hrt9RGAor7ovCXVlxoXARmTYUpWFEusY2o9sf/nv/Fkj3/y3Q+cF5lg8BIt+b45D7NQbBj88F f4yQ6QAh03cRMn0HIb8J9465Ph5wfdzrujdy9/s/Pn8ed2/y00//AlBLAwQUAAAACAAlkWdEiePT jvsAAAAwAwAAEgAUAHdvcmQvZm9udFRhYmxlLnhtbAEAEAAAAAAAAAAAAAAAAAAAAAAAvZHBTsMw DIbvPEWUO0vZAaFq3TQOiAsc2PYAXuqukRKnikND356spScQQhpws/3/9ifbq82bs6LHwMZTJW8W hRRI2teGTpU87B+u76TgCFSD9YSVHJDlZr1KZeMpssjdxGWqZBtjVyrFukUHvPAdUtYaHxzEnIaT Sj7UXfAamfNwZ9WyKG6VA0NynidSSeAyZW8csnjGJF68g8mgWwiMZ08PtpJFIdXYB87YYa6G0T4K nYm6nes9BANHi2dJTbBP0N3gjt5+yVr+NmubLfbna3EyzJegxIFM/iqKp93lx6yxgVcbv4M+ou0x Gg3/QptWvPe2/hvcR8Drq3dQSwMEFAAAAAgAJZFnRGJ7GO+2AgAAIicAABIAFAB3b3JkL251bWJl cmluZy54bWwBABAAAAAAAAAAAAAAAAAAAAAAAO1ayW7bMBS89ysMFugtkUQvcdwoQZsgQIsg6CH9 AFqiYqJcBJKyk359qYWqnd1gAkkAfaHJ92b4oDEovoFPzu4YHa2xVETwGESHIRhhnoiU8NsY/L65 PJiDkdKIp4gKjmNwjxU4Oz3ZLHjBlliatJFh4GqxicFK63wRBCpZYYbUocgxN7FMSIa0mcrbYCNk mkuRYKUMktEAhuEsYIhwYGnyt/CkEm22CHZpL+qgZZRvIRRZRhJ8IZKCYa5rVokp0uaxqBXJlWVb x6CQfNFQHTCSSKFEpg8SwRZrRm2eeCmv3q0ZQPk00VJpiRJ9XbDRzuxHGoOwSmEF1eQKrzG9uc+x yVojGoNqlZarICiz6JqaEDGDxRn1pLbpUZ1lxLtk7eKyoBTrOqKKLLPrGi1b0ht81+Z/+XwHp+eX X9vgz8SGKM4aovyXLAfDoZrR5pjNgfmeCxWDIxjW6VvxhGIk24wqHvwnIjw1oXKfGm0mK8Rvq9/r eHrcZDe7y3owRKRU0u7Q7Kn+2gU4sSvn6tHaKn1UWSKoML8rVGhRTjNCTTSrPjVIarqzWdDUElTP 66FQ0YcK9f09hIJTJ6UsfHDSwI+U5lv4HtKMj2cu0lj44KQZ9/94m05CF2ksfHDSTPp/oM3mExdp LHxw0kz7f6DN4dxFGgsfnDSz/h9ox24XNgsfnDRH/T/Qoihyuge0+MGJM+//kRbBmdNNoMUPQJxg p4F9tbuNBtrdBq+J0O+ez7H8rvsix/K77h0cy+/6fu1Yftd3UMfyu76nOZbf9V3Gsfyu3/Z7l7/n +xDu8T5U+p7iK8L/2IQrovQo9FawgxUMn7guQW8FeyvYW8HeCvZWsLeCvRXsrWBvBXsr2FvB3gr2 VvCerS+vWl6+bf3u9L8P6fgTMPg8LHoBNn4eBrdhwdaf204//QNQSwMEFAAAAAgAJZFnRKlkZ/1Q AQAASwMAAA8AFAB3b3JkL2hlYWRlci54bWwBABAAAAAAAAAAAAAAAAAAAAAAAKWTzU7DMAzH7zxF lAO3rR1CCIV1u0wDbkjAA2Rp2kYkceSkLXt70q4fQkiogovzYfvn5O9ku/80mjQSvQKb0c06pURa AbmyZUbf346re0p84DbnGqzM6Fl6ut9tW1blSGKu9QwzWoXgWJJ4UUnD/RqctNFXABoe4hLLBIpC CXkAURtpQ3KTpncJSs1DrOsr5TwdaK1bgsuRt/GIRl9ILWDuEIT0Pu4eLs6JuAT4nTByDVd2wmzS jNZo2UBZGSUQPBRhJcCwywVZx5kzbn+UnpLWMWlQpS8eC27Sfmb0rIX/C2C+x2vFnZxp5f9ojwi1 G2lGLJHVcPyoXSeQi60+Ka3CuZd2xDS/adrMUsAC7S8DJUaw59IC8pOOLzZ2gXYP1vXmBfvhNZy1 JC1ruM7ok+S5RHLNjXsgR4AgkSZd2EnlagxKu61kIuCw6m38C7urL1BLAwQUAAAACAAlkWdEAG63 cVABAABLAwAADwAUAHdvcmQvZm9vdGVyLnhtbAEAEAAAAAAAAAAAAAAAAAAAAAAApZPNTsMwDMfv PEWUA7etHUIIhXW7TANuSMADZGnaRiRx5KQte3vSrh9CSKiCi/Nh++fk72S7/zSaNBK9ApvRzTql RFoBubJlRt/fjqt7SnzgNucarMzoWXq6321bVgQkMdd6hhmtQnAsSbyopOF+DU7a6CsADQ9xiWUC RaGEPICojbQhuUnTuwSl5iHW9ZVyng601i3B5cjbeESjL6QWMHcIQnofdw8X50RcAvxOGLmGKzth NmlGa7RsoKyMEggeirASYNjlgqzjzBm3P0pPSeuYNKjSF48FN2k/M3rWwv8FMN/jteJOzrTyf7RH hNqNNCOWyGo4ftSuE8jFVp+UVuHcSztimt80bWYpYIH2l4ESI9hzaQH5SccXG7tAuwfrevOC/fAa zlqSljVcZ/RJ8lwiuebGPZAjQJBIky7spHI1BqXdVjIRcFj1Nv6F3dUXUEsDBBQAAAAIACWRZ0SR fgiD0gEAAKkDAAARABQAd29yZC9zZXR0aW5ncy54bWwBABAAAAAAAAAAAAAAAAAAAAAAAI2T32/a MBDH3/dXRJ40bQ8jCTQUSNMKSqM+rNskur1MezDJBSxiX2Q7UDTtf98lNkMqmrSnj8/383uJb+5e ZB3sQRuBKmPxIGIBqAJLoTYZ+/acf5ywwFiuSl6jgowdwbC725vDzIC1FGQCKqDM7JCxrbXNLAxN sQXJzQAbUOSrUEtuydSb8IC6bDQWYAylyjocRtE4lFwo1pXcCzgEBF5nrNFCWRZ211JojfqJ641Q 5uSPnG9NFWn4JX5Gu2oprlXlI3C6+4/AHNFeBGrYi24Z390wkutd29BmGBkFSgnKGm/SOEuoveF0 2n5vvlQJFW9r+8zXK4vNqc/10Lt5a/Hx2GxBcUsNX80Be1BzVX4pvZ5L5bjLsS6/douirq/cCj8J BQsNfGfmlZNZ8244dop89/ZlGMWT1PE+fU+HURRfpT9+9aeodxHnnveeD45x1KdOJ4m3fXw87jhf eGvZMX8YJZ7XnlPPhecpLne8ij1Hnj4v8XmJz0tcXj4eppfKF0CfBf4lfeqlL9MPbtQk/fnbSZz6 YvTFG27Pp5X766mO4pKeg7sVa1ELe3zCEroWrRYXr0GKQqPByg4oJcSqEgX07+HvTHHStQzPPcPz I7t98wdQSwMEFAAAAAgAJZFnRAOWtrFnAQAAbAYAABwAFAB3b3JkL19yZWxzL2RvY3VtZW50Lnht bC5yZWxzAQAQAAAAAAAAAAAAAAAAAAAAAADVldFOgzAUhu99CtJ7KGxzzmVsXqjJLrwx8wEKHKCu tE17WODtbabbWDKJS9DEy3NIv/87J1AWq6YS3g6M5UrGJApC4oFMVcZlEZO3zbM/I55FJjMmlISY tGDJarl4BcHQHbEl19ZzDGljUiLqOaU2LaFiNlAapHuSK1MxdKUpqGbplhVAR2E4pabLIOdMb53F xKyziHibVsNP2CrPeQqPKq0rkHghglpAdHNZx2SmAIzJoRM4FqGXFUZDKuRK4oYlAk4Ox1afxHjQ PWAroLuFfd0XPxkyvnQkI7jcngy+sIlQRdCA3IO4zKAJdKkdI5rQMKLjiLpjdeOP/Wjiu3fS17uS HigvKnOCTw2CkezbSW7/ZhI3hDbqHVLco65znP4Dx7tfdqwYF6jmuk4ETzm2D4Jbxzt3vk55Nqgy sAxMZ6f7uu8buh/2HlHYjf+s++KjcMh8WVcJGHd1nhSOrYMFPftJLG8+AFBLAwQUAAAACAAlkWdE BngDNcUBAABVCAAAEwAUAFtDb250ZW50X1R5cGVzXS54bWwBABAAAAAAAAAAAAAAAAAAAAAAALWW z27bMAzG73sKQ9ciVrbDMAxxeli741Zg2QMoFm1r0z9ITOq8/aik8SGT7QZNT4ZJ/b6PokTDq/ve 6GIPISpnK/axXLICbO2ksm3Ffm++L76wIqKwUmhnoWIHiOx+vdocPMSCWBsr1iH6r5zHugMjYuk8 WMo0LhiB9Bpa7kX9V7TAPy2Xn3ntLILFBSYNtl49QCN2GovHnsKnOghnxbfTumRVMeG9VrVASvOU 5VkugI4T4N7Ki+oWL5WVRB7XxE75eDfu8Me3FwbKpJ2leJ7wNk+keJ7YGp8lUjxPtKrJEimeJ3CE wFHCy2aitSmb54zbT3CUVTDWB2WvO0zXNKoG6eqdIaR8dkH64GqIka6z0aUPisTCL0CkQByx3U9e vnlb4h+CeFaj59vr2L/JIfoAQsYOAGlXx2ey+klzHJSE4kkE/CEM6XJinoLzkaYuQNlfu7XzeCR6 Qb30EFDBMCCTjiR9veHFTiF1TYJ8pXc6cT7AbzX/7/4MGSOUna0jvlyz29dxVp4toSHTjdhquH0N g/R8H/Cg4T26cNSdte9oVCDc3v6k+4ojcPge9ifdWXu7M1ugz157+woG6XMR/PhXsP7wD1BLAQI+ ABQAAAAIACWRZ0SIY7iK4gAAAE0CAAALAAAAAAAAAAAAAAAAAAAAAABfcmVscy8ucmVsc1BLAQI+ ABQAAAAIACWRZ0T6AUm3xQAAACsBAAARAAAAAAAAAAAAAAAAAB8BAABkb2NQcm9wcy9jb3JlLnht bFBLAQI+ABQAAAAIACWRZ0Q7GAl8lQAAAOcAAAAQAAAAAAAAAAAAAAAAACcCAABkb2NQcm9wcy9h cHAueG1sUEsBAj4AFAAAAAgAJZFnRCo+TmTnEgAAx5cAABEAAAAAAAAAAAAAAAAA/gIAAHdvcmQv ZG9jdW1lbnQueG1sUEsBAj4AFAAAAAgAJZFnRE9RaRTpBAAAYBcAAA8AAAAAAAAAAAAAAAAAKBYA AHdvcmQvc3R5bGVzLnhtbFBLAQI+ABQAAAAIACWRZ0SJ49OO+wAAADADAAASAAAAAAAAAAAAAAAA AFIbAAB3b3JkL2ZvbnRUYWJsZS54bWxQSwECPgAUAAAACAAlkWdEYnsY77YCAAAiJwAAEgAAAAAA AAAAAAAAAACRHAAAd29yZC9udW1iZXJpbmcueG1sUEsBAj4AFAAAAAgAJZFnRKlkZ/1QAQAASwMA AA8AAAAAAAAAAAAAAAAAix8AAHdvcmQvaGVhZGVyLnhtbFBLAQI+ABQAAAAIACWRZ0QAbrdxUAEA AEsDAAAPAAAAAAAAAAAAAAAAABwhAAB3b3JkL2Zvb3Rlci54bWxQSwECPgAUAAAACAAlkWdEkX4I g9IBAACpAwAAEQAAAAAAAAAAAAAAAACtIgAAd29yZC9zZXR0aW5ncy54bWxQSwECPgAUAAAACAAl kWdEA5a2sWcBAABsBgAAHAAAAAAAAAAAAAAAAADCJAAAd29yZC9fcmVscy9kb2N1bWVudC54bWwu cmVsc1BLAQI+ABQAAAAIACWRZ0QGeAM1xQEAAFUIAAATAAAAAAAAAAAAAAAAAHcmAABbQ29udGVu dF9UeXBlc10ueG1sUEsFBgAAAAAMAAwA9gIAAIEoAAAAAA== --e89a8f6479e9737f3304f40c5f93 Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Disposition: inline _______________________________________________ Advisory-board mailing list Advisory-board@lists.xenproject.org http://lists.xenproject.org/cgi-bin/mailman/listinfo/advisory-board --e89a8f6479e9737f3304f40c5f93-- From xen-devel-bounces@lists.xen.org Mon Mar 10 10:03:19 2014 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Mon, 10 Mar 2014 10:03:19 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WMx2q-0000Tf-2A; Mon, 10 Mar 2014 10:02:52 +0000 Received: from mail6.bemta4.messagelabs.com ([85.158.143.247]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WMwzV-0000NO-8g for xen-devel@lists.xen.org; Mon, 10 Mar 2014 09:59:26 +0000 Received: from [85.158.143.35:50689] by server-3.bemta-4.messagelabs.com id 4B/42-13602-CFC8D135; Mon, 10 Mar 2014 09:59:24 +0000 X-Env-Sender: alexander@brychcy.net X-Msg-Ref: server-7.tower-21.messagelabs.com!1394445554!863548!1 X-Originating-IP: [82.98.82.25] X-SpamReason: No, hits=0.5 required=7.0 tests=BODY_RANDOM_LONG X-StarScan-Received: X-StarScan-Version: 6.11.1; banners=-,-,- X-VirusChecked: Checked Received: (qmail 12535 invoked from network); 10 Mar 2014 09:59:14 -0000 Received: from mailout.selfhost.de (HELO outgoing.selfhost.de) (82.98.82.25) by server-7.tower-21.messagelabs.com with DHE-RSA-AES256-SHA encrypted SMTP; 10 Mar 2014 09:59:14 -0000 Received: (qmail 4565 invoked from network); 10 Mar 2014 09:59:10 -0000 Received: from unknown (HELO atom.brychcy.net) (postmaster@hcfigwad.mail.selfhost.de@188.106.240.137) by mailout.selfhost.de with ESMTPA; 10 Mar 2014 09:59:10 -0000 Received: from [192.168.23.12] (dslb-188-106-240-137.pools.arcor-ip.net [188.106.240.137]) (using TLSv1 with cipher ECDHE-RSA-AES128-SHA (128/128 bits)) (No client certificate requested) (Authenticated sender: bober) by atom.brychcy.net (Postfix) with ESMTPSA id AB77C9977 for ; Mon, 10 Mar 2014 10:59:08 +0100 (CET) Message-ID: <531D8CEA.9010900@brychcy.net> Date: Mon, 10 Mar 2014 10:59:06 +0100 From: Alexander Brychcy User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64; rv:24.0) Gecko/20100101 Thunderbird/24.3.0 MIME-Version: 1.0 To: xen-devel@lists.xen.org X-Enigmail-Version: 1.6 X-Mailman-Approved-At: Mon, 10 Mar 2014 10:02:51 +0000 Subject: [Xen-devel] Struggling with PCI-Passthrough X-BeenThere: xen-devel@lists.xen.org X-Mailman-Version: 2.1.13 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Sender: xen-devel-bounces@lists.xen.org Errors-To: xen-devel-bounces@lists.xen.org Hi, I'm currently trying to create a Windows 7 HVM with GPU Passthrough. My setup is the following: CPU: Xeon E3-1230v3 Board: Asus P9D-E/4L RAM: 16GB Kingston from Board QVL GPU: Sapphire R9 270X 4GB The passthrough itself is working (Tested with Debian Wheezy dom0 on Xen 4.1, then XenServer 6.2 and now Debian Jessie dom0 on Xen 4.3) Under Debian Jessie i was not able to passthrough the USB Controller, although it appeard at xl pci-assignable-list and i cannot assign more than 2GB of memory to the HVM. The overall problem is, that the HVM starts up and is running fine. But after a unspecific amount of time the hole system freezes. The cursor in dom0 still blinking, but no input possible - not even in xen serial console. I had one run, without a freeze, but the GPU performance was very poor, so i tried a manual reset. After the HVM reboot the performance was as expected, but soon the system froze again. I'm not sure, if this problem is related to Xen, because i tried to create the virtual machine with KVM and had the same issue. But i switched to Xen to get the best performace. I will add my config and log files and hope you can help me to get this setup fully working. Kind regards, Alexander /etc/xen/win7x64-tv.cfg # ===================================================================== # Example HVM guest configuration # ===================================================================== # # This is a fairly minimal example of what is required for an # HVM guest. For a more complete guide see xl.cfg(5) # This configures an HVM rather than PV guest builder = "hvm" # Guest name name = "win7x64-tv" # 128-bit UUID for the domain as a hexadecimal number. # Use "uuidgen" to generate one if required. # The default behavior is to generate a new UUID each time the guest is started. uuid = "ab8f106b-2e46-4512-957d-d587797d43ac" # Enable Microsoft Hyper-V compatibile paravirtualisation / # enlightenment interfaces. Turning this on can improve Windows guest # performance and is therefore recommended viridian = 1 acpi = 1 apic = 1 # Initial memory allocation (MB) memory = 2048 # Maximum memory (MB) # If this is greater than `memory' then the slack will start ballooned # (this assumes guest kernel support for ballooning) #maxmem = 512 # Number of VCPUS vcpus = 6 # Network devices # A list of 'vifspec' entries as described in # docs/misc/xl-network-configuration.markdown vif = [ 'mac=00:16:3E:D3:63:C8, bridge=xenbr0' ] # Disk Devices # A list of `diskspec' entries as described in # docs/misc/xl-disk-configuration.txt disk = [ 'phy:/dev/xenon-guests-ssd/win7x64-tv,hda,w' #, 'file:/etc/xen/iso/win7x64.iso,hdc:cdrom,r' ] boot = "dc" pci = [ '05:00.0', '05:00.1', '00:1d.0' ] # Guest VGA console configuration, either SDL or VNC sdl = 0 vnc = 1 usbdevice = "tablet" device_model_version = "qemu-xen" device_model_override = "/usr/bin/qemu" bios = "seabios" ------- /etc/default/grub snippet ------- GRUB_CMDLINE_LINUX="xen-pciback.hide=(05:00.0)(05:00.1)(00:1d.0) console=hvc0 earlyprintk=xen" GRUB_CMDLINE_XEN="iommu=1 dom0_mem=1024M logvlv=all guest_loglvl=all com1=57600,8n1 console=com1" ------- xl -vvv create /etc/xen/win7x64-tv.cfg output ------- Parsing config from /etc/xen/win7x64-tv.cfg libxl: debug: libxl_create.c:1230:do_domain_create: ao 0x150e7b0: create: how=(nil) callback=(nil) poller=0x150edd0 libxl: debug: libxl_device.c:257:libxl__device_disk_set_backend: Disk vdev=hda spec.backend=unknown libxl: debug: libxl_device.c:296:libxl__device_disk_set_backend: Disk vdev=hda, using backend phy libxl: debug: libxl_create.c:675:initiate_domain_create: running bootloader libxl: debug: libxl_bootloader.c:321:libxl__bootloader_run: not a PV domain, skipping bootloader libxl: debug: libxl_event.c:608:libxl__ev_xswatch_deregister: watch w=0x150f138: deregister unregistered libxl: debug: libxl_numa.c:475:libxl__get_numa_candidate: New best NUMA placement candidate found: nr_nodes=1, nr_cpus=8, nr_vcpus=14, free_memkb=14939 libxl: detail: libxl_dom.c:195:numa_place_domain: NUMA placement candidate with 1 nodes, 8 cpus and 14939 KB free selected xc: detail: elf_parse_binary: phdr: paddr=0x100000 memsz=0xa0164 xc: detail: elf_parse_binary: memory: 0x100000 -> 0x1a0164 xc: info: VIRTUAL MEMORY ARRANGEMENT: Loader: 0000000000100000->00000000001a0164 Modules: 0000000000000000->0000000000000000 TOTAL: 0000000000000000->000000007f800000 ENTRY ADDRESS: 0000000000100608 xc: info: PHYSICAL MEMORY ALLOCATION: 4KB PAGES: 0x0000000000000200 2MB PAGES: 0x00000000000003fb 1GB PAGES: 0x0000000000000000 xc: detail: elf_load_binary: phdr 0 at 0x7f5cdf165000 -> 0x7f5cdf1fbfed libxl: debug: libxl_device.c:257:libxl__device_disk_set_backend: Disk vdev=hda spec.backend=phy libxl: debug: libxl_event.c:559:libxl__ev_xswatch_register: watch w=0x15100f8 wpath=/local/domain/0/backend/vbd/1/768/state token=3/0: register slotnum=3 libxl: debug: libxl_create.c:1243:do_domain_create: ao 0x150e7b0: inprogress: poller=0x150edd0, flags=i libxl: debug: libxl_event.c:503:watchfd_callback: watch w=0x15100f8 wpath=/local/domain/0/backend/vbd/1/768/state token=3/0: event epath=/local/domain/0/backend/vbd/1/768/state libxl: debug: libxl_event.c:647:devstate_watch_callback: backend /local/domain/0/backend/vbd/1/768/state wanted state 2 still waiting state 1 libxl: debug: libxl_event.c:503:watchfd_callback: watch w=0x15100f8 wpath=/local/domain/0/backend/vbd/1/768/state token=3/0: event epath=/local/domain/0/backend/vbd/1/768/state libxl: debug: libxl_event.c:643:devstate_watch_callback: backend /local/domain/0/backend/vbd/1/768/state wanted state 2 ok libxl: debug: libxl_event.c:596:libxl__ev_xswatch_deregister: watch w=0x15100f8 wpath=/local/domain/0/backend/vbd/1/768/state token=3/0: deregister slotnum=3 libxl: debug: libxl_event.c:608:libxl__ev_xswatch_deregister: watch w=0x15100f8: deregister unregistered libxl: debug: libxl_device.c:959:device_hotplug: calling hotplug script: /etc/xen/scripts/block add libxl: debug: libxl_dm.c:1206:libxl__spawn_local_dm: Spawning device-model /usr/bin/qemu with arguments: libxl: debug: libxl_dm.c:1208:libxl__spawn_local_dm: /usr/bin/qemu libxl: debug: libxl_dm.c:1208:libxl__spawn_local_dm: -xen-domid libxl: debug: libxl_dm.c:1208:libxl__spawn_local_dm: 1 libxl: debug: libxl_dm.c:1208:libxl__spawn_local_dm: -chardev libxl: debug: libxl_dm.c:1208:libxl__spawn_local_dm: socket,id=libxl-cmd,path=/var/run/xen/qmp-libxl-1,server,nowait libxl: debug: libxl_dm.c:1208:libxl__spawn_local_dm: -mon libxl: debug: libxl_dm.c:1208:libxl__spawn_local_dm: chardev=libxl-cmd,mode=control libxl: debug: libxl_dm.c:1208:libxl__spawn_local_dm: -name libxl: debug: libxl_dm.c:1208:libxl__spawn_local_dm: win7x64-tv libxl: debug: libxl_dm.c:1208:libxl__spawn_local_dm: -vnc libxl: debug: libxl_dm.c:1208:libxl__spawn_local_dm: 127.0.0.1:0,to=99 libxl: debug: libxl_dm.c:1208:libxl__spawn_local_dm: -global libxl: debug: libxl_dm.c:1208:libxl__spawn_local_dm: isa-fdc.driveA= libxl: debug: libxl_dm.c:1208:libxl__spawn_local_dm: -vga libxl: debug: libxl_dm.c:1208:libxl__spawn_local_dm: cirrus libxl: debug: libxl_dm.c:1208:libxl__spawn_local_dm: -global libxl: debug: libxl_dm.c:1208:libxl__spawn_local_dm: vga.vram_size_mb=8 libxl: debug: libxl_dm.c:1208:libxl__spawn_local_dm: -boot libxl: debug: libxl_dm.c:1208:libxl__spawn_local_dm: order=dc libxl: debug: libxl_dm.c:1208:libxl__spawn_local_dm: -usb libxl: debug: libxl_dm.c:1208:libxl__spawn_local_dm: -usbdevice libxl: debug: libxl_dm.c:1208:libxl__spawn_local_dm: tablet libxl: debug: libxl_dm.c:1208:libxl__spawn_local_dm: -smp libxl: debug: libxl_dm.c:1208:libxl__spawn_local_dm: 6,maxcpus=6 libxl: debug: libxl_dm.c:1208:libxl__spawn_local_dm: -device libxl: debug: libxl_dm.c:1208:libxl__spawn_local_dm: rtl8139,id=nic0,netdev=net0,mac=00:16:3e:d3:63:c8 libxl: debug: libxl_dm.c:1208:libxl__spawn_local_dm: -netdev libxl: debug: libxl_dm.c:1208:libxl__spawn_local_dm: type=tap,id=net0,ifname=vif1.0-emu,script=no,downscript=no libxl: debug: libxl_dm.c:1208:libxl__spawn_local_dm: -M libxl: debug: libxl_dm.c:1208:libxl__spawn_local_dm: xenfv libxl: debug: libxl_dm.c:1208:libxl__spawn_local_dm: -m libxl: debug: libxl_dm.c:1208:libxl__spawn_local_dm: 2040 libxl: debug: libxl_dm.c:1208:libxl__spawn_local_dm: -drive libxl: debug: libxl_dm.c:1208:libxl__spawn_local_dm: file=/dev/xenon-guests-ssd/win7x64-tv,if=ide,index=0,media=disk,format=raw,cache=writeback libxl: debug: libxl_event.c:559:libxl__ev_xswatch_register: watch w=0x150f370 wpath=/local/domain/0/device-model/1/state token=3/1: register slotnum=3 libxl: debug: libxl_event.c:503:watchfd_callback: watch w=0x150f370 wpath=/local/domain/0/device-model/1/state token=3/1: event epath=/local/domain/0/device-model/1/state libxl: debug: libxl_event.c:503:watchfd_callback: watch w=0x150f370 wpath=/local/domain/0/device-model/1/state token=3/1: event epath=/local/domain/0/device-model/1/state libxl: debug: libxl_event.c:596:libxl__ev_xswatch_deregister: watch w=0x150f370 wpath=/local/domain/0/device-model/1/state token=3/1: deregister slotnum=3 libxl: debug: libxl_event.c:608:libxl__ev_xswatch_deregister: watch w=0x150f370: deregister unregistered libxl: debug: libxl_qmp.c:707:libxl__qmp_initialize: connected to /var/run/xen/qmp-libxl-1 libxl: debug: libxl_qmp.c:299:qmp_handle_response: message type: qmp libxl: debug: libxl_qmp.c:555:qmp_send_prepare: next qmp command: '{ "execute": "qmp_capabilities", "id": 1 } ' libxl: debug: libxl_qmp.c:299:qmp_handle_response: message type: return libxl: debug: libxl_qmp.c:555:qmp_send_prepare: next qmp command: '{ "execute": "query-chardev", "id": 2 } ' libxl: debug: libxl_qmp.c:299:qmp_handle_response: message type: return libxl: debug: libxl_qmp.c:555:qmp_send_prepare: next qmp command: '{ "execute": "query-vnc", "id": 3 } ' libxl: debug: libxl_qmp.c:299:qmp_handle_response: message type: return libxl: debug: libxl_event.c:559:libxl__ev_xswatch_register: watch w=0x15133c8 wpath=/local/domain/0/backend/vif/1/0/state token=3/2: register slotnum=3 libxl: debug: libxl_event.c:503:watchfd_callback: watch w=0x15133c8 wpath=/local/domain/0/backend/vif/1/0/state token=3/2: event epath=/local/domain/0/backend/vif/1/0/state libxl: debug: libxl_event.c:647:devstate_watch_callback: backend /local/domain/0/backend/vif/1/0/state wanted state 2 still waiting state 1 libxl: debug: libxl_event.c:503:watchfd_callback: watch w=0x15133c8 wpath=/local/domain/0/backend/vif/1/0/state token=3/2: event epath=/local/domain/0/backend/vif/1/0/state libxl: debug: libxl_event.c:643:devstate_watch_callback: backend /local/domain/0/backend/vif/1/0/state wanted state 2 ok libxl: debug: libxl_event.c:596:libxl__ev_xswatch_deregister: watch w=0x15133c8 wpath=/local/domain/0/backend/vif/1/0/state token=3/2: deregister slotnum=3 libxl: debug: libxl_event.c:608:libxl__ev_xswatch_deregister: watch w=0x15133c8: deregister unregistered libxl: debug: libxl_device.c:959:device_hotplug: calling hotplug script: /etc/xen/scripts/vif-bridge online libxl: debug: libxl_device.c:959:device_hotplug: calling hotplug script: /etc/xen/scripts/vif-bridge add libxl: debug: libxl_qmp.c:707:libxl__qmp_initialize: connected to /var/run/xen/qmp-libxl-1 libxl: debug: libxl_qmp.c:299:qmp_handle_response: message type: qmp libxl: debug: libxl_qmp.c:555:qmp_send_prepare: next qmp command: '{ "execute": "qmp_capabilities", "id": 1 } ' libxl: debug: libxl_qmp.c:299:qmp_handle_response: message type: return libxl: debug: libxl_qmp.c:555:qmp_send_prepare: next qmp command: '{ "execute": "device_add", "id": 2, "arguments": { "driver": "xen-pci-passthrough", "id": "pci-pt-05_00.0", "hostaddr": "0000:05:00.0" } } ' libxl: debug: libxl_qmp.c:299:qmp_handle_response: message type: return libxl: debug: libxl_qmp.c:555:qmp_send_prepare: next qmp command: '{ "execute": "query-pci", "id": 3 } ' libxl: debug: libxl_qmp.c:299:qmp_handle_response: message type: return libxl: debug: libxl_qmp.c:707:libxl__qmp_initialize: connected to /var/run/xen/qmp-libxl-1 libxl: debug: libxl_qmp.c:299:qmp_handle_response: message type: qmp libxl: debug: libxl_qmp.c:555:qmp_send_prepare: next qmp command: '{ "execute": "qmp_capabilities", "id": 1 } ' libxl: debug: libxl_qmp.c:299:qmp_handle_response: message type: return libxl: debug: libxl_qmp.c:555:qmp_send_prepare: next qmp command: '{ "execute": "device_add", "id": 2, "arguments": { "driver": "xen-pci-passthrough", "id": "pci-pt-05_00.1", "hostaddr": "0000:05:00.1" } } ' libxl: debug: libxl_qmp.c:299:qmp_handle_response: message type: return libxl: debug: libxl_qmp.c:555:qmp_send_prepare: next qmp command: '{ "execute": "query-pci", "id": 3 } ' libxl: debug: libxl_qmp.c:299:qmp_handle_response: message type: return libxl: debug: libxl_qmp.c:707:libxl__qmp_initialize: connected to /var/run/xen/qmp-libxl-1 libxl: debug: libxl_qmp.c:299:qmp_handle_response: message type: qmp libxl: debug: libxl_qmp.c:555:qmp_send_prepare: next qmp command: '{ "execute": "qmp_capabilities", "id": 1 } ' libxl: debug: libxl_qmp.c:299:qmp_handle_response: message type: return libxl: debug: libxl_qmp.c:555:qmp_send_prepare: next qmp command: '{ "execute": "device_add", "id": 2, "arguments": { "driver": "xen-pci-passthrough", "id": "pci-pt-00_1d.0", "hostaddr": "0000:00:1d.0" } } ' libxl: debug: libxl_qmp.c:299:qmp_handle_response: message type: return libxl: debug: libxl_qmp.c:555:qmp_send_prepare: next qmp command: '{ "execute": "query-pci", "id": 3 } ' libxl: debug: libxl_qmp.c:299:qmp_handle_response: message type: return libxl: debug: libxl_pci.c:81:libxl__create_pci_backend: Creating pci backend libxl: debug: libxl_event.c:1737:libxl__ao_progress_report: ao 0x150e7b0: progress report: ignored libxl: debug: libxl_event.c:1569:libxl__ao_complete: ao 0x150e7b0: complete, rc=0 libxl: debug: libxl_event.c:1541:libxl__ao__destroy: ao 0x150e7b0: destroy Daemon running with PID 2957 xc: debug: hypercall buffer: total allocations:1089 total releases:1089 xc: debug: hypercall buffer: current allocations:0 maximum allocations:4 xc: debug: hypercall buffer: cache current size:4 xc: debug: hypercall buffer: cache hits:1081 misses:4 toobig:4 ------- serial console output ------- =~=~=~=~=~=~=~=~=~=~=~= PuTTY log 2014.03.07 10:42:13 =~=~=~=~=~=~=~=~=~=~=~= AMIBIOS(C)2013 American Megatrends, Inc. ASUS P9D-E Series ACPI BIOS Revision 0701 Press DEL to run Setup. Press F12 to run Net Boot. Press ALT + F2 to run EzFlash. Press F8 for BBS POPUP. CPU: Intel(R) Xeon(R) CPU E3-1230 v3 @ 3.30GHz Total Memory: 16384MB (DDR3 1600) USB Devices total: 0 Drive, 0 Keyboard, 0 Mouse, 2 Hubs Detected ATA/ATAPI Devices... SATA Port1: Samsung SSD 840 PRO SATA Port5: HL-DT-ST DVDRAM GT80 (XEN) Xen version 4.3.0 (Debian 4.3.0-3+b1) (buildd-binet@buildd.debian.org) (gcc (Debian 4.8.2-8) 4.8.2) debug=n Wed Dec 4 07:43:54 UTC 2013 (XEN) Bootloader: GRUB 2.00-22 (XEN) Command line: placeholder iommu=1 dom0_mem=1024M loglvl=all guest_loglvl=all com1=57600,8n1 console=com1 (XEN) Video information: (XEN) VGA is text mode 80x25, font 8x16 (XEN) VBE/DDC methods: V2; EDID transfer time: 1 seconds (XEN) Disc information: (XEN) Found 2 MBR signatures (XEN) Found 2 EDD information structures (XEN) Xen-e820 RAM map: (XEN) 0000000000000000 - 0000000000099c00 (usable) (XEN) 0000000000099c00 - 00000000000a0000 (reserved) (XEN) 00000000000e0000 - 0000000000100000 (reserved) (XEN) 0000000000100000 - 000000006458c000 (usable) (XEN) 000000006458c000 - 0000000064593000 (ACPI NVS) (XEN) 0000000064593000 - 00000000735e8000 (usable) (XEN) 00000000735e8000 - 0000000073806000 (reserved) (XEN) 0000000073806000 - 0000000073821000 (ACPI data) (XEN) 0000000073821000 - 0000000073caf000 (ACPI NVS) (XEN) 0000000073caf000 - 0000000074fff000 (reserved) (XEN) 0000000074fff000 - 0000000075000000 (usable) (XEN) 00000000e0000000 - 00000000f0000000 (reserved) (XEN) 00000000fec00000 - 00000000fec01000 (reserved) (XEN) 00000000fed00000 - 00000000fed04000 (reserved) (XEN) 00000000fed1c000 - 00000000fed20000 (reserved) (XEN) 00000000fee00000 - 00000000fee01000 (reserved) (XEN) 00000000ff000000 - 0000000100000000 (reserved) (XEN) 0000000100000000 - 0000000480000000 (usable) (XEN) ACPI: RSDP 000F0490, 0024 (r2 ALASKA) (XEN) ACPI: XSDT 7380B0A0, 00B4 (r1 ALASKA A M I 1072009 AMI 10013) (XEN) ACPI: FACP 7381AD10, 010C (r5 ALASKA A M I 1072009 AMI 10013) (XEN) ACPI: DSDT 7380B1E8, FB23 (r2 ALASKA A M I 10 INTL 20091112) (XEN) ACPI: FACS 73CAD080, 0040 (XEN) ACPI: APIC 7381AE20, 0092 (r3 ALASKA A M I 1072009 AMI 10013) (XEN) ACPI: FPDT 7381AEB8, 0044 (r1 ALASKA A M I 1072009 AMI 10013) (XEN) ACPI: LPIT 7381AF00, 005C (r1 ALASKA A M I 0 AMI. 5) (XEN) ACPI: SSDT 7381AF60, 0539 (r1 PmRef Cpu0Ist 3000 INTL 20120711) (XEN) ACPI: SSDT 7381B4A0, 0AD8 (r1 PmRef CpuPm 3000 INTL 20120711) (XEN) ACPI: SSDT 7381BF78, 02DE (r1 PmRef Cpu0Tst 3000 INTL 20120711) (XEN) ACPI: SSDT 7381C258, 0348 (r1 PmRef ApTst 3000 INTL 20120711) (XEN) ACPI: MCFG 7381C5A0, 003C (r1 ALASKA A M I 1072009 MSFT 97) (XEN) ACPI: PRAD 7381C5E0, 00BE (r2 PRADID PRADTID 1 MSFT 3000001) (XEN) ACPI: HPET 7381C6A0, 0038 (r1 ALASKA A M I 1072009 AMI. 5) (XEN) ACPI: SSDT 7381C6D8, 036D (r1 SataRe SataTabl 1000 INTL 20120711) (XEN) ACPI: SSDT 7381CA48, 3440 (r1 SaSsdt SaSsdt 3000 INTL 20091112) (XEN) ACPI: BERT 73820368, 0030 (r1 AMI AMI BERT 0 0) (XEN) ACPI: DMAR 7381FEE0, 0080 (r1 INTEL HSW 1 INTL 1) (XEN) ACPI: EINJ 7381FF60, 0130 (r1 AMI AMI EINJ 0 0) (XEN) ACPI: ERST 73820090, 0230 (r1 AMIER AMI ERST 0 0) (XEN) ACPI: HEST 738202C0, 00A8 (r1 AMI AMI HEST 0 0) (XEN) System RAM: 16181MB (16569836kB) (XEN) No NUMA configuration found (XEN) Faking a node at 0000000000000000-0000000480000000 (XEN) Domain heap initialised (XEN) found SMP MP-table at 000fda80 (XEN) DMI 2.7 present. (XEN) Using APIC driver default (XEN) ACPI: PM-Timer IO Port: 0x1808 (XEN) ACPI: v5 SLEEP INFO: control[0:0], status[0:0] (XEN) ACPI: SLEEP INFO: pm1x_cnt[1804,0], pm1x_evt[1800,0] (XEN) ACPI: 32/64X FACS address mismatch in FADT - 73cad080/0000000000000000, using 32 (XEN) ACPI: wakeup_vec[73cad08c], vec_size[20] (XEN) ACPI: Local APIC address 0xfee00000 (XEN) ACPI: LAPIC (acpi_id[0x01] lapic_id[0x00] enabled) (XEN) Processor #0 7:12 APIC version 21 (XEN) ACPI: LAPIC (acpi_id[0x02] lapic_id[0x02] enabled) (XEN) Processor #2 7:12 APIC version 21 (XEN) ACPI: LAPIC (acpi_id[0x03] lapic_id[0x04] enabled) (XEN) Processor #4 7:12 APIC version 21 (XEN) ACPI: LAPIC (acpi_id[0x04] lapic_id[0x06] enabled) (XEN) Processor #6 7:12 APIC version 21 (XEN) ACPI: LAPIC (acpi_id[0x05] lapic_id[0x01] enabled) (XEN) Processor #1 7:12 APIC version 21 (XEN) ACPI: LAPIC (acpi_id[0x06] lapic_id[0x03] enabled) (XEN) Processor #3 7:12 APIC version 21 (XEN) ACPI: LAPIC (acpi_id[0x07] lapic_id[0x05] enabled) (XEN) Processor #5 7:12 APIC version 21 (XEN) ACPI: LAPIC (acpi_id[0x08] lapic_id[0x07] enabled) (XEN) Processor #7 7:12 APIC version 21 (XEN) ACPI: LAPIC_NMI (acpi_id[0xff] high edge lint[0x1]) (XEN) ACPI: IOAPIC (id[0x08] address[0xfec00000] gsi_base[0]) (XEN) IOAPIC[0]: apic_id 8, version 32, address 0xfec00000, GSI 0-23 (XEN) ACPI: INT_SRC_OVR (bus 0 bus_irq 0 global_irq 2 dfl dfl) (XEN) ACPI: INT_SRC_OVR (bus 0 bus_irq 9 global_irq 9 high level) (XEN) ACPI: IRQ0 used by override. (XEN) ACPI: IRQ2 used by override. (XEN) ACPI: IRQ9 used by override. (XEN) Enabling APIC mode: Flat. Using 1 I/O APICs (XEN) ACPI: HPET id: 0x8086a701 base: 0xfed00000 (XEN) Xen ERST support is initialized. (XEN) Using ACPI (MADT) for SMP configuration information (XEN) SMP: Allowing 8 CPUs (0 hotplug CPUs) (XEN) IRQ limits: 24 GSI, 1528 MSI/MSI-X (XEN) Switched to APIC driver x2apic_cluster. (XEN) Using scheduler: SMP Credit Scheduler (credit) (XEN) Detected 3292.479 MHz processor. (XEN) Initing memory sharing. (XEN) xstate_init: using cntxt_size: 0x340 and states: 0x7 (XEN) mce_intel.c:717: MCA Capability: BCAST 1 SER 0 CMCI 1 firstbank 0 extended MCE MSR 0 (XEN) Intel machine check reporting enabled (XEN) PCI: MCFG configuration 0: base e0000000 segment 0000 buses 00 - ff (XEN) PCI: MCFG area at e0000000 reserved in E820 (XEN) PCI: Using MCFG for segment 0000 bus 00-ff (XEN) Intel VT-d iommu 0 supported page sizes: 4kB, 2MB, 1GB. (XEN) Intel VT-d Snoop Control enabled. (XEN) Intel VT-d Dom0 DMA Passthrough not enabled. (XEN) Intel VT-d Queued Invalidation enabled. (XEN) Intel VT-d Interrupt Remapping enabled. (XEN) Intel VT-d Shared EPT tables enabled. (XEN) I/O virtualisation enabled (XEN) - Dom0 mode: Relaxed (XEN) Interrupt remapping enabled (XEN) Enabled directed EOI with ioapic_ack_old on! (XEN) ENABLING IO-APIC IRQs (XEN) -> Using old ACK method (XEN) ..TIMER: vector=0xF0 apic1=0 pin1=2 apic2=0 pin2=0 (XEN) TSC deadline timer enabled (XEN) Platform timer is 14.318MHz HPET (XEN) Allocated console ring of 64 KiB. (XEN) mwait-idle: MWAIT substates: 0x42120 (XEN) mwait-idle: v0.4 model 0x3c (XEN) mwait-idle: lapic_timer_reliable_states 0xffffffff (XEN) VMX: Supported advanced features: (XEN) - APIC MMIO access virtualisation (XEN) - APIC TPR shadow (XEN) - Extended Page Tables (EPT) (XEN) - Virtual-Processor Identifiers (VPID) (XEN) - Virtual NMI (XEN) - MSR direct-access bitmap (XEN) - Unrestricted Guest (XEN) - VMCS shadowing (XEN) HVM: ASIDs enabled. (XEN) HVM: VMX enabled (XEN) HVM: Hardware Assisted Paging (HAP) detected (XEN) HVM: HAP page sizes: 4kB, 2MB, 1GB (XEN) Brought up 8 CPUs (XEN) ACPI sleep modes: S3 (XEN) mcheck_poll: Machine check polling timer started. (XEN) *** LOADING DOMAIN 0 *** (XEN) Xen kernel: 64-bit, lsb, compat32 (XEN) Dom0 kernel: 64-bit, PAE, lsb, paddr 0x1000000 -> 0x1eb3000 (XEN) PHYSICAL MEMORY ARRANGEMENT: (XEN) Dom0 alloc.: 000000046c000000->0000000470000000 (235071 pages to be allocated) (XEN) Init. ramdisk: 000000047d63f000->000000047ffff600 (XEN) VIRTUAL MEMORY ARRANGEMENT: (XEN) Loaded kernel: ffffffff81000000->ffffffff81eb3000 (XEN) Init. ramdisk: ffffffff81eb3000->ffffffff84873600 (XEN) Phys-Mach map: ffffffff84874000->ffffffff84a74000 (XEN) Start info: ffffffff84a74000->ffffffff84a744b4 (XEN) Page tables: ffffffff84a75000->ffffffff84a9e000 (XEN) Boot stack: ffffffff84a9e000->ffffffff84a9f000 (XEN) TOTAL: ffffffff80000000->ffffffff84c00000 (XEN) ENTRY ADDRESS: ffffffff818c01e0 (XEN) Dom0 has maximum 8 VCPUs (XEN) Scrubbing Free RAM: .....................................................................................................................................................done. (XEN) Initial low memory virq threshold set at 0x4000 pages. (XEN) Std. Loglevel: All (XEN) Guest Loglevel: All (XEN) *** Serial input -> DOM0 (type 'CTRL-a' three times to switch input to Xen) (XEN) Freed 260kB init memory. mapping kernel into physical memory about to get started... [ 0.000000] Initializing cgroup subsys cpuset [ 0.000000] Initializing cgroup subsys cpu [ 0.000000] Initializing cgroup subsys cpuacct [ 0.000000] Linux version 3.12-1-amd64 (debian-kernel@lists.debian.org) (gcc version 4.8.2 (Debian 4.8.2-14) ) #1 SMP Debian 3.12.9-1 (2014-02-01) [ 0.000000] Command line: placeholder root=UUID=c05596a5-4c31-4847-96cd-b816f7c5ac37 ro xen-pciback.hide=(05:00.0)(05:00.1)(00:1d.0) console=hvc0 earlyprintk=xen quiet [ 0.000000] Freeing 99-100 pfn range: 103 pages freed [ 0.000000] Released 103 pages of unused memory [ 0.000000] Set 576133 page(s) to 1-1 mapping [ 0.000000] Populating 40000-40067 pfn range: 103 pages added [ 0.000000] e820: BIOS-provided physical RAM map: [ 0.000000] Xen: [mem 0x0000000000000000-0x0000000000098fff] usable [ 0.000000] Xen: [mem 0x0000000000099c00-0x00000000000fffff] reserved [ 0.000000] Xen: [mem 0x0000000000100000-0x000000006458bfff] usable [ 0.000000] Xen: [mem 0x000000006458c000-0x0000000064592fff] ACPI NVS [ 0.000000] Xen: [mem 0x0000000064593000-0x00000000735e7fff] usable [ 0.000000] Xen: [mem 0x00000000735e8000-0x0000000073805fff] reserved [ 0.000000] Xen: [mem 0x0000000073806000-0x0000000073820fff] ACPI data [ 0.000000] Xen: [mem 0x0000000073821000-0x0000000073caefff] ACPI NVS [ 0.000000] Xen: [mem 0x0000000073caf000-0x0000000074ffefff] reserved [ 0.000000] Xen: [mem 0x0000000074fff000-0x0000000074ffffff] usable [ 0.000000] Xen: [mem 0x00000000e0000000-0x00000000efffffff] reserved [ 0.000000] Xen: [mem 0x00000000fec00000-0x00000000fec00fff] reserved [ 0.000000] Xen: [mem 0x00000000fed00000-0x00000000fed03fff] reserved [ 0.000000] Xen: [mem 0x00000000fed1c000-0x00000000fed1ffff] reserved [ 0.000000] Xen: [mem 0x00000000fee00000-0x00000000fee00fff] reserved [ 0.000000] Xen: [mem 0x00000000ff000000-0x00000000ffffffff] reserved [ 0.000000] Xen: [mem 0x0000000100000000-0x000000034ce8afff] usable [ 0.000000] Xen: [mem 0x000000034ce8b000-0x000000047fffffff] unusable [ 0.000000] bootconsole [xenboot0] enabled (XEN) PCI add device 0000:00:00.0 (XEN) PCI add device 0000:00:01.0 (XEN) PCI add device 0000:00:14.0 (XEN) PCI add device 0000:00:16.0 (XEN) PCI add device 0000:00:16.1 (XEN) PCI add device 0000:00:1a.0 (XEN) PCI add device 0000:00:1c.0 (XEN) PCI add device 0000:00:1c.2 (XEN) PCI add device 0000:00:1c.3 (XEN) PCI add device 0000:00:1c.4 (XEN) PCI add device 0000:00:1c.5 (XEN) PCI add device 0000:00:1c.6 (XEN) PCI add device 0000:00:1c.7 (XEN) PCI add device 0000:00:1d.0 (XEN) PCI add device 0000:00:1f.0 (XEN) PCI add device 0000:00:1f.2 (XEN) PCI add device 0000:00:1f.3 (XEN) PCI add device 0000:01:00.0 (XEN) PCI add device 0000:02:08.0 (XEN) PCI add device 0000:02:09.0 (XEN) PCI add device 0000:02:10.0 (XEN) PCI add device 0000:03:00.0 (XEN) PCI add device 0000:05:00.0 (XEN) PCI add device 0000:05:00.1 (XEN) PCI add device 0000:07:00.0 (XEN) PCI add device 0000:08:00.0 (XEN) PCI add device 0000:09:00.0 (XEN) PCI add device 0000:0a:00.0 (XEN) PCI add device 0000:0b:00.0 (XEN) PCI add device 0000:0c:00.0 (XEN) PCI add device 0000:0d:00.0 (XEN) PCI add device 0000:0e:00.0 (XEN) traps.c:2503:d0 Domain attempted WRMSR 00000000000001fc from 0x000000000004005f to 0x000000000004005d. (XEN) traps.c:2503:d0 Domain attempted WRMSR 00000000000001fc from 0x000000000004005f to 0x000000000004005d. (XEN) traps.c:2503:d0 Domain attempted WRMSR 00000000000001fc from 0x000000000004005f to 0x000000000004005d. (XEN) traps.c:2503:d0 Domain attempted WRMSR 00000000000001fc from 0x000000000004005f to 0x000000000004005d. (XEN) traps.c:2503:d0 Domain attempted WRMSR 00000000000001fc from 0x000000000004005f to 0x000000000004005d. (XEN) traps.c:2503:d0 Domain attempted WRMSR 00000000000001fc from 0x000000000004005f to 0x000000000004005d. (XEN) traps.c:2503:d0 Domain attempted WRMSR 00000000000001fc from 0x000000000004005f to 0x000000000004005d. (XEN) traps.c:2503:d0 Domain attempted WRMSR 00000000000001fc from 0x000000000004005f to 0x000000000004005d. Loading, please wait...INIT: version 2.88 booting [info] Using makefile-style concurrent boot in runlevel S.[....] Starting the hotplug events dispatcher: udevd[?25l[?1c7[ ok 8[?25h[?0c.[....] Synthesizing the initial hotplug events...[?25l[?1c7[ ok 8[?25h[?0cdone.[....] Waiting for /dev to be fully populated...[ 4.672429] Error: Driver 'pcspkr' is already registered, aborting...[?25l[?1c7[ ok 8[?25h[?0cdone.[....] Setting preliminary keymap...[?25l[?1c7[ ok 8[?25h[?0cdone.[....] Activating swap...[?25l[?1c7[ ok 8[?25h[?0cdone.[....] Checking root file system...fsck from util-linux 2.20.1/dev/sdb3: clean, 42744/610800 files, 411628/2441472 blocks[?25l[?1c7[ ok 8[?25h[?0cdone.[....] Cleaning up temporary files... /tmp[?25l[?1c7[ ok 8[?25h[?0c.[....] Starting early crypto disks...[?25l[?1c7[ ok 8[?25h[?0cdone.[info] Loading kernel module xen-pciback.[....] Setting up LVM Volume Groups...[?25l[?1c7[ ok 8[?25h[?0cdone.[....] Starting remaining crypto disks...[?25l[?1c7[ ok 8[?25h[?0cdone.[....] Activating lvm and md swap...[?25l[?1c7[ ok 8[?25h[?0cdone.[....] Checking file systems...fsck from util-linux 2.20.1/dev/sdb1: recovering journal/dev/sdb1: clean, 284/73152 files, 46434/291840 blocks[?25l[?1c7[ ok 8[?25h[?0cdone.[....] Mounting local filesystems...[?25l[?1c7[ ok 8[?25h[?0cdone.[....] Activating swapfile swap...[?25l[?1c7[ ok 8[?25h[?0cdone.[....] Cleaning up temporary files...[?25l[?1c7[ ok 8[?25h[?0c.[....] Setting kernel variables ...[?25l[?1c7[ ok 8[?25h[?0cdone.[....] Configuring network interfaces...Waiting for xenbr0 to get ready (MAXWAIT is 32 seconds).Internet Systems Consortium DHCP Client 4.2.4Copyright 2004-2012 Internet Systems Consortium.All rights reserved.For info, please visit https://www.isc.org/software/dhcp/Corrupt lease file - possible data loss!Listening on LPF/xenbr0/60:a4:4c:e8:43:daSending on LPF/xenbr0/60:a4:4c:e8:43:daSending on Socket/fallbackDHCPDISCOVER on xenbr0 to 255.255.255.255 port 67 interval 3DHCPDISCOVER on xenbr0 to 255.255.255.255 port 67 interval 3DHCPREQUEST on xenbr0 to 255.255.255.255 port 67DHCPOFFER from 192.168.23.3DHCPACK from 192.168.23.3bound to 192.168.23.7 -- renewal in 49 seconds.[?25l[?1c7[ ok 8[?25h[?0cdone.[....] Starting rpcbind daemon...[?25l[?1c7[ ok 8[?25h[?0c.[....] Starting NFS common utilities: statd idmapd[?25l[?1c7[ ok 8[?25h[?0c.[....] Cleaning up temporary files...[?25l[?1c7[ ok 8[?25h[?0c.[info] Setting console screen modes.setterm: cannot (un)set powersave mode: Inappropriate ioctl for device[9;30][14;30][....] Setting up console font and keymap...[?25l[?1c7[ ok 8[?25h[?0cdone.[....] Setting up X socket directories... /tmp/.X11-unix /tmp/.ICE-unix[?25l[?1c7[ ok 8[?25h[?0c. INIT: Entering runlevel: 2 [info] Using makefile-style concurrent boot in runlevel 2.[info] Already running: rcpbind.[....] Starting enhanced syslogd: rsyslogd[?25l[?1c7[ ok 8[?25h[?0c.[....] Starting deferred execution scheduler: atd[?25l[?1c7[ ok 8[?25h[?0c.[....] Starting periodic command scheduler: cron[?25l[?1c7[ ok 8[?25h[?0c.[....] Starting ACPI services...[?25l[?1c7[ ok 8[?25h[?0c.[....] Starting system message bus: dbus[?25l[?1c7[ ok 8[?25h[?0c.saned disabled; edit /etc/default/saned[....] Starting OpenBSD Secure Shell server: sshd[?25l[?1c7[ ok 8[?25h[?0c.[....] Starting Xen daemons: xenfs xenstored xenconsoled[?25l[?1c7[ ok 8[?25h[?0c.[....] Starting MTA: exim4[?25l[?1c7[ ok 8[?25h[?0c. (XEN) *** Serial input -> Xen (type 'CTRL-a' three times to switch input to DOM0) (XEN) '*' pressed -> firing all diagnostic keyhandlers (XEN) [d: dump registers] (XEN) 'd' pressed -> dumping registers (XEN) (XEN) *** Dumping CPU0 host state: *** (XEN) ----[ Xen-4.3.0 x86_64 debug=n Not tainted ]---- (XEN) CPU: 0 (XEN) RIP: e008:[] mwait_idle+0x211/0x350 (XEN) RFLAGS: 0000000000000202 CONTEXT: hypervisor (XEN) rax: ffff82c4c0300620 rbx: ffff8304711fd610 rcx: 0000000f181686ce (XEN) rdx: ffff82c4c02a8000 rsi: 0000000f181686ce rdi: ffff8304711fd638 (XEN) rbp: 0000000f181686ce rsp: ffff82c4c02afe70 r8: 0000000eefa17033 (XEN) r9: 0000006e8eed74c3 r10: 0000000000000005 r11: ffff82c4c0300710 (XEN) r12: 0000000000000010 r13: 0000000000000000 r14: ffff82c4c02ea940 (XEN) r15: ffff8304711fd6c0 cr0: 0000000080050033 cr4: 00000000001426f0 (XEN) cr3: 000000047f404000 cr2: ffff880003e06740 (XEN) ds: 002b es: 002b fs: 0000 gs: 0000 ss: e010 cs: e008 (XEN) Xen stack trace from rsp=ffff82c4c02afe70: (XEN) ffff82c4c0300800 0000000f16eadd50 ffff82c4c0300710 00000032c0127872 (XEN) 00005dd40000041a 0000000000000000 0000000000000000 ffff82c4c02a8000 (XEN) ffffffffffffffff 0000000000000002 ffffffffffffffff ffff82c4c02a8000 (XEN) ffff82c4c02a8000 00000000ffffffff ffff82c4c02ea940 0000000000000002 (XEN) ffffffffffffffff ffff82c4c015805e ffff88002e54ffd8 ffff8300730fe000 (XEN) ffff830073305000 0000000000000000 ffff88002e54ffd8 ffff88002e54ffd8 (XEN) ffff88002e54ffd8 0000000000000006 ffff88002e54ffd8 0000000000000246 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) ffffffff810013aa 0000000000000001 0000000000000000 0000000000000001 (XEN) 0000010000000000 ffffffff810013aa 000000000000e033 0000000000000246 (XEN) ffff88002e54fed8 000000000000e02b 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 ffff8300730fe000 (XEN) 0000000000000000 0000000000000000 (XEN) Xen call trace: (XEN) [] mwait_idle+0x211/0x350 (XEN) [] idle_loop+0x1e/0x50 (XEN) (XEN) *** Dumping CPU1 host state: *** (XEN) ----[ Xen-4.3.0 x86_64 debug=n Not tainted ]---- (XEN) CPU: 1 (XEN) RIP: e008:[] mwait_idle+0x211/0x350 (XEN) RFLAGS: 0000000000000202 CONTEXT: hypervisor (XEN) rax: ffff8304711f6020 rbx: ffff8304711fde10 rcx: 0000000f2dfb6fdf (XEN) rdx: ffff83047c308000 rsi: 0000000f2dfb6fdf rdi: ffff8304711fde38 (XEN) rbp: 0000000f2dfb6fdf rsp: ffff83047c30fe70 r8: 0000000eefa17033 (XEN) r9: 0000006e8eed7517 r10: 0000000000000001 r11: ffff82c4c0300710 (XEN) r12: 0000000000000010 r13: 0000000000000001 r14: ffff82c4c02ea940 (XEN) r15: ffff8304711fdec0 cr0: 0000000080050033 cr4: 00000000001426f0 (XEN) cr3: 0000000446fbb000 cr2: ffff88002ec583c8 (XEN) ds: 0000 es: 0000 fs: 0000 gs: 0000 ss: e010 cs: e008 (XEN) Xen stack trace from rsp=ffff83047c30fe70: (XEN) ffff8304711f6080 0000000f2b476ca6 ffff82c4c0300710 00000032c0127800 (XEN) 00018435000024df 0000000000000000 0000000000000000 ffff83047c308000 (XEN) 00000000ffffffff ffff82c4c02c7800 ffff83047c308000 ffff83047c308000 (XEN) ffff83047c308000 00000000ffffffff ffff82c4c02ea940 0000000000000002 (XEN) ffffffffffffffff ffff82c4c015805e ffffffff81801fd8 ffff830064593000 (XEN) ffff8300735e3000 0000000000000000 ffffffff81801fd8 ffffffff81801fd8 (XEN) ffffffff81801fd8 0000000000000000 ffffffff81801fd8 0000000000000246 (XEN) ffff88003e400000 0000000000000000 0000000000000000 0000000000000000 (XEN) ffffffff810013aa 0000000000000001 0000000000000000 0000000000000001 (XEN) 0000010000000000 ffffffff810013aa 000000000000e033 0000000000000246 (XEN) ffffffff81801e98 000000000000e02b 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000001 ffff830064593000 (XEN) 0000003fb0ef5a00 0000000000000000 (XEN) Xen call trace: (XEN) [] mwait_idle+0x211/0x350 (XEN) [] idle_loop+0x1e/0x50 (XEN) (XEN) *** Dumping CPU2 host state: *** (XEN) ----[ Xen-4.3.0 x86_64 debug=n Not tainted ]---- (XEN) CPU: 2 (XEN) RIP: e008:[] mwait_idle+0x211/0x350 (XEN) RFLAGS: 0000000000000202 CONTEXT: hypervisor (XEN) rax: ffff8304711f0020 rbx: ffff8304711f26a0 rcx: 0000000f42880aaa (XEN) rdx: ffff83047c300000 rsi: 0000000f42880aaa rdi: ffff8304711f26c8 (XEN) rbp: 0000000f42880aaa rsp: ffff83047c307e70 r8: 0000000eefa17033 (XEN) r9: 0000006e8eed753e r10: 0000000000000001 r11: ffff82c4c0300710 (XEN) r12: 0000000000000010 r13: 0000000000000002 r14: ffff82c4c02ea940 (XEN) r15: ffff8304711f2750 cr0: 0000000080050033 cr4: 00000000001426f0 (XEN) cr3: 000000046d80c000 cr2: 00007f6a3a9e9f14 (XEN) ds: 002b es: 002b fs: 0000 gs: 0000 ss: e010 cs: e008 (XEN) Xen stack trace from rsp=ffff83047c307e70: (XEN) ffff8304711f0080 0000000eefa17734 ffff82c4c0300710 00000032c02c7800 (XEN) 0000ffef000000ac 0000000000000000 0000000000000000 ffff82c4c018028a (XEN) ffffffffffffffff 00000000ffffffff ffff82c4c02c7800 ffff83047c300000 (XEN) ffff83047c300000 00000000ffffffff ffff82c4c02ea940 0000000000000002 (XEN) ffffffffffffffff ffff82c4c015805e ffff88002e54bfd8 ffff8300643fe000 (XEN) ffff830073306000 0000000000000000 ffff88002e54bfd8 ffff88002e54bfd8 (XEN) ffff88002e54bfd8 0000000000000005 ffff88002e54bfd8 0000000000000246 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) ffffffff810013aa 0000000000000001 0000000000000000 0000000000000001 (XEN) 0000010000000000 ffffffff810013aa 000000000000e033 0000000000000246 (XEN) ffff88002e54bed8 000000000000e02b 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000002 ffff8300643fe000 (XEN) 0000003fb0eefa00 0000000000000000 (XEN) Xen call trace: (XEN) [] mwait_idle+0x211/0x350 (XEN) [] local_time_calibration+0x13a/0x1b0 (XEN) [] idle_loop+0x1e/0x50 (XEN) (XEN) *** Dumping CPU3 host state: *** (XEN) ----[ Xen-4.3.0 x86_64 debug=n Not tainted ]---- (XEN) CPU: 3 (XEN) RIP: e008:[] mwait_idle+0x211/0x350 (XEN) RFLAGS: 0000000000000202 CONTEXT: hypervisor (XEN) rax: ffff83047117b020 rbx: ffff8304711f2e90 rcx: 0000000f57c2e3d8 (XEN) rdx: ffff830471170000 rsi: 0000000f57c2e3d8 rdi: ffff8304711f2eb8 (XEN) rbp: 0000000f57c2e3d8 rsp: ffff830471177e70 r8: 0000000eefa17033 (XEN) r9: 0000006e8eed7546 r10: 0000000000000001 r11: ffff82c4c0300710 (XEN) r12: 0000000000000010 r13: 0000000000000003 r14: ffff82c4c02ea940 (XEN) r15: ffff8304711f2f40 cr0: 0000000080050033 cr4: 00000000001426f0 (XEN) cr3: 000000047fdf3000 cr2: 00007fd618261f14 (XEN) ds: 002b es: 002b fs: 0000 gs: 0000 ss: e010 cs: e008 (XEN) Xen stack trace from rsp=ffff830471177e70: (XEN) ffff83047117b080 0000000f4a19a239 ffff82c4c0300710 000000323e483e48 (XEN) 000401ae0000092b 0000000000000000 0000000000000000 ffff830471170000 (XEN) 00000000ffffffff ffff82c4c02c7800 ffff830471170000 ffff830471170000 (XEN) ffff830471170000 00000000ffffffff ffff82c4c02ea940 0000000000000002 (XEN) ffffffffffffffff ffff82c4c015805e ffff88002e543fd8 ffff830073303000 (XEN) ffff8300735e1000 0000000000000000 ffff88002e543fd8 ffff88002e543fd8 (XEN) ffff88002e543fd8 0000000000000002 ffff88002e543fd8 0000000000000246 (XEN) ffff88003e480000 0000000000000000 0000000000000000 0000000000000000 (XEN) ffffffff810013aa 0000000000000001 0000000000000000 0000000000000001 (XEN) 0000010000000000 ffffffff810013aa 000000000000e033 0000000000000246 (XEN) ffff88002e543ed8 000000000000e02b 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000003 ffff830073303000 (XEN) 0000003fb0e7aa00 0000000000000000 (XEN) Xen call trace: (XEN) [] mwait_idle+0x211/0x350 (XEN) [] idle_loop+0x1e/0x50 (XEN) (XEN) *** Dumping CPU4 host state: *** (XEN) ----[ Xen-4.3.0 x86_64 debug=n Not tainted ]---- (XEN) CPU: 4 (XEN) RIP: e008:[] mwait_idle+0x211/0x350 (XEN) RFLAGS: 0000000000000202 CONTEXT: hypervisor (XEN) rax: ffff83047116d020 rbx: ffff83047116f690 rcx: 0000000f6c4f874c (XEN) rdx: ffff830471160000 rsi: 0000000f6c4f874c rdi: ffff83047116f6b8 (XEN) rbp: 0000000f6c4f874c rsp: ffff830471167e70 r8: 0000000eefa17033 (XEN) r9: 0000006e8eed7548 r10: 0000000000000001 r11: ffff82c4c0300710 (XEN) r12: 0000000000000010 r13: 0000000000000004 r14: ffff82c4c02ea940 (XEN) r15: ffff83047116f740 cr0: 0000000080050033 cr4: 00000000001426f0 (XEN) cr3: 000000047f404000 cr2: 00007f646560c0e0 (XEN) ds: 002b es: 002b fs: 0000 gs: 0000 ss: e010 cs: e008 (XEN) Xen stack trace from rsp=ffff830471167e70: (XEN) ffff83047116d080 0000000f67e76e74 ffff82c4c0300710 000000322e545de0 (XEN) 00042b4600000910 0000000000000000 0000000000000000 ffff830471160000 (XEN) 00000000ffffffff ffff82c4c02c7800 ffff830471160000 ffff830471160000 (XEN) ffff830471160000 00000000ffffffff ffff82c4c02ea940 0000000000000002 (XEN) ffffffffffffffff ffff82c4c015805e ffff88002e545fd8 ffff830073302000 (XEN) ffff8300735e0000 0000000000000000 ffff88002e545fd8 ffff88002e545fd8 (XEN) ffff88002e545fd8 0000000000000003 ffff88002e545fd8 0000000000000246 (XEN) 0000000000000019 0000000000000000 0000000000000000 0000000000000000 (XEN) ffffffff810013aa 0000000000000001 0000000000000000 0000000000000001 (XEN) 0000010000000000 ffffffff810013aa 000000000000e033 0000000000000246 (XEN) ffff88002e545ed8 000000000000e02b 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000004 ffff830073302000 (XEN) 0000003fb0e6ca00 0000000000000000 (XEN) Xen call trace: (XEN) [] mwait_idle+0x211/0x350 (XEN) [] idle_loop+0x1e/0x50 (XEN) (XEN) *** Dumping CPU5 host state: *** (XEN) ----[ Xen-4.3.0 x86_64 debug=n Not tainted ]---- (XEN) CPU: 5 (XEN) RIP: e008:[] mwait_idle+0x211/0x350 (XEN) RFLAGS: 0000000000000202 CONTEXT: hypervisor (XEN) rax: ffff830471168020 rbx: ffff83047116fe80 rcx: 0000000f80dbced8 (XEN) rdx: ffff830471158000 rsi: 0000000f80dbced8 rdi: ffff83047116fea8 (XEN) rbp: 0000000f80dbced8 rsp: ffff83047115fe70 r8: 0000000eefa17033 (XEN) r9: 0000006e8eed7554 r10: 0000000000000001 r11: ffff82c4c0300710 (XEN) r12: 0000000000000010 r13: 0000000000000005 r14: ffff82c4c02ea940 (XEN) r15: ffff83047116ff30 cr0: 0000000080050033 cr4: 00000000001426f0 (XEN) cr3: 00000004482ca000 cr2: ffff8800044969b8 (XEN) ds: 002b es: 002b fs: 0000 gs: 0000 ss: e010 cs: e008 (XEN) Xen stack trace from rsp=ffff83047115fe70: (XEN) ffff830471168080 0000000f7b36da7e ffff82c4c0300710 000000323e503e78 (XEN) 0016f7500000209c 0000000000000000 0000000000000000 ffff830471158000 (XEN) 00000000ffffffff ffff82c4c02c7800 ffff830471158000 ffff830471158000 (XEN) ffff830471158000 00000000ffffffff ffff82c4c02ea940 0000000000000002 (XEN) ffffffffffffffff ffff82c4c015805e ffff88002e547fd8 ffff8300730fd000 (XEN) ffff830073307000 0000000000000000 ffff88002e547fd8 ffff88002e547fd8 (XEN) ffff88002e547fd8 0000000000000004 ffff88002e547fd8 0000000000000246 (XEN) ffff88003e500000 0000000000000000 0000000000000000 0000000000000000 (XEN) ffffffff810013aa 0000000000000001 0000000000000000 0000000000000001 (XEN) 0000010000000000 ffffffff810013aa 000000000000e033 0000000000000246 (XEN) ffff88002e547ed8 000000000000e02b 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000005 ffff8300730fd000 (XEN) 0000003fb0e67a00 0000000000000000 (XEN) Xen call trace: (XEN) [] mwait_idle+0x211/0x350 (XEN) [] idle_loop+0x1e/0x50 (XEN) (XEN) *** Dumping CPU6 host state: *** (XEN) ----[ Xen-4.3.0 x86_64 debug=n Not tainted ]---- (XEN) CPU: 6 (XEN) RIP: e008:[] mwait_idle+0x211/0x350 (XEN) RFLAGS: 0000000000000202 CONTEXT: hypervisor (XEN) rax: ffff830471152020 rbx: ffff830471154690 rcx: 0000000f95686f68 (XEN) rdx: ffff830471148000 rsi: 0000000f95686f68 rdi: ffff8304711546b8 (XEN) rbp: 0000000f95686f68 rsp: ffff83047114fe70 r8: 0000000eefa17033 (XEN) r9: 0000006e8eed7552 r10: 0000000000000001 r11: ffff82c4c0300710 (XEN) r12: 0000000000000010 r13: 0000000000000006 r14: ffff82c4c02ea940 (XEN) r15: ffff830471154740 cr0: 0000000080050033 cr4: 00000000001426f0 (XEN) cr3: 000000046d80c000 cr2: 00007f6a3b22f55b (XEN) ds: 002b es: 002b fs: 0000 gs: 0000 ss: e010 cs: e008 (XEN) Xen stack trace from rsp=ffff83047114fe70: (XEN) ffff830471152080 0000000f93888243 ffff82c4c0300710 000000322e551db0 (XEN) 000392f600000157 0000000000000000 0000000000000000 ffff830471148000 (XEN) 00000000ffffffff ffff82c4c02c7800 ffff830471148000 ffff830471148000 (XEN) ffff830471148000 00000000ffffffff ffff82c4c02ea940 0000000000000002 (XEN) ffffffffffffffff ffff82c4c015805e ffff88002e551fd8 ffff8300730fc000 (XEN) ffff830073304000 0000000000000000 ffff88002e551fd8 ffff88002e551fd8 (XEN) ffff88002e551fd8 0000000000000007 ffff88002e551fd8 0000000000000246 (XEN) ffff88003e5c0000 0000000000000000 0000000000000000 0000000000000000 (XEN) ffffffff810013aa 0000000000000001 0000000000000000 0000000000000001 (XEN) 0000010000000000 ffffffff810013aa 000000000000e033 0000000000000246 (XEN) ffff88002e551ed8 000000000000e02b 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000006 ffff8300730fc000 (XEN) 0000003fb0e51a00 0000000000000000 (XEN) Xen call trace: (XEN) [] mwait_idle+0x211/0x350 (XEN) [] idle_loop+0x1e/0x50 (XEN) (XEN) *** Dumping CPU7 host state: *** (XEN) ----[ Xen-4.3.0 x86_64 debug=n Not tainted ]---- (XEN) CPU: 7 (XEN) RIP: e008:[] mwait_idle+0x211/0x350 (XEN) RFLAGS: 0000000000000202 CONTEXT: hypervisor (XEN) rax: ffff830471145020 rbx: ffff830471154e80 rcx: 0000000fa9f4bbfa (XEN) rdx: ffff830471138000 rsi: 0000000fa9f4bbfa rdi: ffff830471154ea8 (XEN) rbp: 0000000fa9f4bbfa rsp: ffff83047113fe70 r8: 0000000eefa17033 (XEN) r9: 0000006e8eed755e r10: 0000000000000001 r11: ffff82c4c0300710 (XEN) r12: 0000000000000010 r13: 0000000000000007 r14: ffff82c4c02ea940 (XEN) r15: ffff830471154f30 cr0: 0000000080050033 cr4: 00000000001426f0 (XEN) cr3: 000000046d80c000 cr2: 00007f96a490a430 (XEN) ds: 002b es: 002b fs: 0000 gs: 0000 ss: e010 cs: e008 (XEN) Xen stack trace from rsp=ffff83047113fe70: (XEN) ffff830471145080 0000000f930e76f7 ffff82c4c0300710 000000322e53fde0 (XEN) 00085eb300002096 0000000000000000 0000000000000000 ffff830471138000 (XEN) 00000000ffffffff ffff82c4c02c7800 ffff830471138000 ffff830471138000 (XEN) ffff830471138000 00000000ffffffff ffff82c4c02ea940 0000000000000002 (XEN) ffffffffffffffff ffff82c4c015805e ffff88002e53ffd8 ffff8300643fd000 (XEN) ffff8300735e2000 0000000000000000 ffff88002e53ffd8 ffff88002e53ffd8 (XEN) ffff88002e53ffd8 0000000000000001 ffff88002e53ffd8 0000000000000246 (XEN) ffff88003e440000 0000000000000000 0000000000000000 0000000000000000 (XEN) ffffffff810013aa 0000000000000001 0000000000000000 0000000000000001 (XEN) 0000010000000000 ffffffff810013aa 000000000000e033 0000000000000246 (XEN) ffff88002e53fed8 000000000000e02b 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000007 ffff8300643fd000 (XEN) 0000003fb0e44a00 0000000000000000 (XEN) Xen call trace: (XEN) [] mwait_idle+0x211/0x350 (XEN) [] idle_loop+0x1e/0x50 (XEN) (XEN) [0: dump Dom0 registers] (XEN) '0' pressed -> dumping Dom0's registers (XEN) *** Dumping Dom0 vcpu#0 state: *** (XEN) RIP: e033:[] (XEN) RFLAGS: 0000000000000246 EM: 0 CONTEXT: pv guest (XEN) rax: 0000000000000000 rbx: ffffffff81801fd8 rcx: ffffffff810013aa (XEN) rdx: 0000000000000001 rsi: 0000000000000000 rdi: 0000000000000001 (XEN) rbp: 0000000000000000 rsp: ffffffff81801e98 r8: 0000000000000000 (XEN) r9: 0000000000000000 r10: ffff88003e400000 r11: 0000000000000246 (XEN) r12: ffffffff81801fd8 r13: ffffffff81801fd8 r14: ffffffff81801fd8 (XEN) r15: 0000000000000000 cr0: 0000000000000000 cr4: 0000000000042660 (XEN) cr3: 0000000446fbb000 cr2: 00007f6465ae3000 (XEN) ds: 0000 es: 0000 fs: 0000 gs: 0000 ss: e02b cs: e033 (XEN) Guest stack trace from rsp=ffffffff81801e98: (XEN) 0000000000000000 0100000000000000 ffffffff8100992c ffffffff8101a6b4 (XEN) ffffffff81801fd8 ffffffff818a0fc0 ffffffff810a457e ffffffff81801fd8 (XEN) ffffffff81801fd8 d621a9a087876718 ffffffffffffffff ffffffff8194b900 (XEN) ffffffff819542c0 ffff88003e831f40 0000000000000000 0000000000000000 (XEN) ffffffff818c0eb8 ffffffff818c08b3 ffffffff819542c0 ffffffff81801f68 (XEN) 00000000ffffffff 0000000000000000 0000000000000000 ffffffff818c2d26 (XEN) 000306c300000000 0000000100100800 0300000100000032 0000000000000005 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 (XEN) *** Dumping Dom0 vcpu#1 state: *** (XEN) RIP: e033:[] (XEN) RFLAGS: 0000000000000246 EM: 0 CONTEXT: pv guest (XEN) rax: 0000000000000000 rbx: ffff88002e53ffd8 rcx: ffffffff810013aa (XEN) rdx: 0000000000000001 rsi: 0000000000000000 rdi: 0000000000000001 (XEN) rbp: 0000000000000001 rsp: ffff88002e53fed8 r8: 0000000000000000 (XEN) r9: 0000000000000000 r10: ffff88003e440000 r11: 0000000000000246 (XEN) r12: ffff88002e53ffd8 r13: ffff88002e53ffd8 r14: ffff88002e53ffd8 (XEN) r15: 0000000000000000 cr0: 0000000080050033 cr4: 0000000000042660 (XEN) cr3: 000000046d80c000 cr2: 00007f96a490a430 (XEN) ds: 002b es: 002b fs: 0000 gs: 0000 ss: e02b cs: e033 (XEN) Guest stack trace from rsp=ffff88002e53fed8: (XEN) 0000000000000000 0100000000000000 ffffffff8100992c ffffffff8101a6b4 (XEN) ffff88002e53ffd8 ffffffff818a0fc0 ffffffff810a457e ffff88002e53ffd8 (XEN) ffff88002e53ffd8 4e6bbde87666fa33 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 ffffffffffffffff (XEN) 0000000000000000 0000000000000010 0000000000000202 ffff88002e53ff58 (XEN) 0000000000000018 (XEN) *** Dumping Dom0 vcpu#2 state: *** (XEN) RIP: e033:[] (XEN) RFLAGS: 0000000000000246 EM: 0 CONTEXT: pv guest (XEN) rax: 0000000000000000 rbx: ffff88002e543fd8 rcx: ffffffff810013aa (XEN) rdx: 0000000000000001 rsi: 0000000000000000 rdi: 0000000000000001 (XEN) rbp: 0000000000000002 rsp: ffff88002e543ed8 r8: 0000000000000000 (XEN) r9: 0000000000000000 r10: ffff88003e480000 r11: 0000000000000246 (XEN) r12: ffff88002e543fd8 r13: ffff88002e543fd8 r14: ffff88002e543fd8 (XEN) r15: 0000000000000000 cr0: 0000000080050033 cr4: 0000000000042660 (XEN) cr3: 000000047fdf3000 cr2: 00007fd618261f14 (XEN) ds: 002b es: 002b fs: 0000 gs: 0000 ss: e02b cs: e033 (XEN) Guest stack trace from rsp=ffff88002e543ed8: (XEN) 0000000000000000 0100000000000000 ffffffff8100992c ffffffff8101a6b4 (XEN) ffff88002e543fd8 ffffffff818a0fc0 ffffffff810a457e ffff88002e543fd8 (XEN) ffff88002e543fd8 cd16d26e7c353277 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 ffffffffffffffff (XEN) 0000000000000000 0000000000000010 0000000000000202 ffff88002e543f58 (XEN) 0000000000000018 (XEN) *** Dumping Dom0 vcpu#3 state: *** (XEN) RIP: e033:[] (XEN) RFLAGS: 0000000000000246 EM: 0 CONTEXT: pv guest (XEN) rax: 0000000000000000 rbx: ffff88002e545fd8 rcx: ffffffff810013aa (XEN) rdx: 0000000000000001 rsi: 0000000000000000 rdi: 0000000000000001 (XEN) rbp: 0000000000000003 rsp: ffff88002e545ed8 r8: 0000000000000000 (XEN) r9: 0000000000000000 r10: 000000000000003d r11: 0000000000000246 (XEN) r12: ffff88002e545fd8 r13: ffff88002e545fd8 r14: ffff88002e545fd8 (XEN) r15: 0000000000000000 cr0: 0000000080050033 cr4: 0000000000042660 (XEN) cr3: 000000047f404000 cr2: 00007f646560c0e0 (XEN) ds: 002b es: 002b fs: 0000 gs: 0000 ss: e02b cs: e033 (XEN) Guest stack trace from rsp=ffff88002e545ed8: (XEN) ffff88002e5f1428 0100000000000000 ffffffff8100992c ffffffff8101a6b4 (XEN) ffff88002e545fd8 ffffffff818a0fc0 ffffffff810a457e ffff88002e545fd8 (XEN) ffff88002e545fd8 d83d337713cdb13a 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 ffffffffffffffff (XEN) 0000000000000000 0000000000000010 0000000000000202 ffff88002e545f58 (XEN) 0000000000000018 (XEN) *** Dumping Dom0 vcpu#4 state: *** (XEN) RIP: e033:[] (XEN) RFLAGS: 0000000000000246 EM: 0 CONTEXT: pv guest (XEN) rax: 0000000000000000 rbx: ffff88002e547fd8 rcx: ffffffff810013aa (XEN) rdx: 0000000000000001 rsi: 0000000000000000 rdi: 0000000000000001 (XEN) rbp: 0000000000000004 rsp: ffff88002e547ed8 r8: 0000000000000000 (XEN) r9: 0000000000000000 r10: 000000000000001a r11: 0000000000000246 (XEN) r12: ffff88002e547fd8 r13: ffff88002e547fd8 r14: ffff88002e547fd8 (XEN) r15: 0000000000000000 cr0: 0000000080050033 cr4: 0000000000042660 (XEN) cr3: 00000004482ca000 cr2: 0000000001337008 (XEN) ds: 002b es: 002b fs: 0000 gs: 0000 ss: e02b cs: e033 (XEN) Guest stack trace from rsp=ffff88002e547ed8: (XEN) ffff88002e645028 0100000000000000 ffffffff8100992c ffffffff8101a6b4 (XEN) ffff88002e547fd8 ffffffff818a0fc0 ffffffff810a457e ffff88002e547fd8 (XEN) ffff88002e547fd8 cc122c574940337f 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 ffffffffffffffff (XEN) 0000000000000000 0000000000000010 0000000000000202 ffff88002e547f58 (XEN) 0000000000000018 (XEN) *** Dumping Dom0 vcpu#5 state: *** (XEN) RIP: e033:[] (XEN) RFLAGS: 0000000000000246 EM: 0 CONTEXT: pv guest (XEN) rax: 0000000000000000 rbx: ffff88002e54bfd8 rcx: ffffffff810013aa (XEN) rdx: 0000000000000001 rsi: 0000000000000000 rdi: 0000000000000001 (XEN) rbp: 0000000000000005 rsp: ffff88002e54bed8 r8: 0000000000000000 (XEN) r9: 0000000000000000 r10: 0000000000000000 r11: 0000000000000246 (XEN) r12: ffff88002e54bfd8 r13: ffff88002e54bfd8 r14: ffff88002e54bfd8 (XEN) r15: 0000000000000000 cr0: 0000000080050033 cr4: 0000000000042660 (XEN) cr3: 000000046d80c000 cr2: 00007f6a3a9e9f14 (XEN) ds: 002b es: 002b fs: 0000 gs: 0000 ss: e02b cs: e033 (XEN) Guest stack trace from rsp=ffff88002e54bed8: (XEN) ffff88002e695c28 0100000000000000 ffffffff8100992c ffffffff8101a6b4 (XEN) ffff88002e54bfd8 ffffffff818a0fc0 ffffffff810a457e ffff88002e54bfd8 (XEN) ffff88002e54bfd8 0d387c79ccf6749f 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 ffffffffffffffff (XEN) 0000000000000000 0000000000000010 0000000000000202 ffff88002e54bf58 (XEN) 0000000000000018 (XEN) *** Dumping Dom0 vcpu#6 state: *** (XEN) RIP: e033:[] (XEN) RFLAGS: 0000000000000246 EM: 0 CONTEXT: pv guest (XEN) rax: 0000000000000000 rbx: ffff88002e54ffd8 rcx: ffffffff810013aa (XEN) rdx: 0000000000000001 rsi: 0000000000000000 rdi: 0000000000000001 (XEN) rbp: 0000000000000006 rsp: ffff88002e54fed8 r8: 0000000000000000 (XEN) r9: 0000000000000000 r10: 0000000000000000 r11: 0000000000000246 (XEN) r12: ffff88002e54ffd8 r13: ffff88002e54ffd8 r14: ffff88002e54ffd8 (XEN) r15: 0000000000000000 cr0: 0000000080050033 cr4: 0000000000042660 (XEN) cr3: 000000047f404000 cr2: 00000000006e88a4 (XEN) ds: 002b es: 002b fs: 0000 gs: 0000 ss: e02b cs: e033 (XEN) Guest stack trace from rsp=ffff88002e54fed8: (XEN) ffff88002e6cdc28 0100000000000000 ffffffff8100992c ffffffff8101a6b4 (XEN) ffff88002e54ffd8 ffffffff818a0fc0 ffffffff810a457e ffff88002e54ffd8 (XEN) ffff88002e54ffd8 fa60e9751235aae9 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 ffffffffffffffff (XEN) 0000000000000000 0000000000000010 0000000000000202 ffff88002e54ff58 (XEN) 0000000000000018 (XEN) *** Dumping Dom0 vcpu#7 state: *** (XEN) RIP: e033:[] (XEN) RFLAGS: 0000000000000246 EM: 0 CONTEXT: pv guest (XEN) rax: 0000000000000000 rbx: ffff88002e551fd8 rcx: ffffffff810013aa (XEN) rdx: 0000000000000001 rsi: 0000000000000000 rdi: 0000000000000001 (XEN) rbp: 0000000000000007 rsp: ffff88002e551ed8 r8: 0000000000000000 (XEN) r9: 0000000000000000 r10: ffff88003e5c0000 r11: 0000000000000246 (XEN) r12: ffff88002e551fd8 r13: ffff88002e551fd8 r14: ffff88002e551fd8 (XEN) r15: 0000000000000000 cr0: 0000000080050033 cr4: 0000000000042660 (XEN) cr3: 000000046d80c000 cr2: 00007f6a3b22f55b (XEN) ds: 002b es: 002b fs: 0000 gs: 0000 ss: e02b cs: e033 (XEN) Guest stack trace from rsp=ffff88002e551ed8: (XEN) 0000000000000000 0100000000000000 ffffffff8100992c ffffffff8101a6b4 (XEN) ffff88002e551fd8 ffffffff818a0fc0 ffffffff810a457e ffff88002e551fd8 (XEN) ffff88002e551fd8 f8390ec8935d120b 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 ffffffffffffffff (XEN) 0000000000000000 0000000000000010 0000000000000202 ffff88002e551f58 (XEN) 0000000000000018 (XEN) [H: dump heap info] (XEN) 'H' pressed -> dumping heap info (now-0xF:BE87A24A) (XEN) heap[node=0][zone=0] -> 0 pages (XEN) heap[node=0][zone=1] -> 0 pages (XEN) heap[node=0][zone=2] -> 0 pages (XEN) heap[node=0][zone=3] -> 0 pages (XEN) heap[node=0][zone=4] -> 0 pages (XEN) heap[node=0][zone=5] -> 0 pages (XEN) heap[node=0][zone=6] -> 0 pages (XEN) heap[node=0][zone=7] -> 0 pages (XEN) heap[node=0][zone=8] -> 0 pages (XEN) heap[node=0][zone=9] -> 0 pages (XEN) heap[node=0][zone=10] -> 0 pages (XEN) heap[node=0][zone=11] -> 0 pages (XEN) heap[node=0][zone=12] -> 0 pages (XEN) heap[node=0][zone=13] -> 0 pages (XEN) heap[node=0][zone=14] -> 16128 pages (XEN) heap[node=0][zone=15] -> 32768 pages (XEN) heap[node=0][zone=16] -> 65536 pages (XEN) heap[node=0][zone=17] -> 131072 pages (XEN) heap[node=0][zone=18] -> 209793 pages (XEN) heap[node=0][zone=19] -> 0 pages (XEN) heap[node=0][zone=20] -> 1048576 pages (XEN) heap[node=0][zone=21] -> 2097152 pages (XEN) heap[node=0][zone=22] -> 223775 pages (XEN) heap[node=0][zone=23] -> 0 pages (XEN) heap[node=0][zone=24] -> 0 pages (XEN) heap[node=0][zone=25] -> 0 pages (XEN) heap[node=0][zone=26] -> 0 pages (XEN) heap[node=0][zone=27] -> 0 pages (XEN) heap[node=0][zone=28] -> 0 pages (XEN) heap[node=0][zone=29] -> 0 pages (XEN) heap[node=0][zone=30] -> 0 pages (XEN) heap[node=0][zone=31] -> 0 pages (XEN) heap[node=0][zone=32] -> 0 pages (XEN) heap[node=0][zone=33] -> 0 pages (XEN) heap[node=0][zone=34] -> 0 pages (XEN) heap[node=0][zone=35] -> 0 pages (XEN) heap[node=0][zone=36] -> 0 pages (XEN) heap[node=0][zone=37] -> 0 pages (XEN) heap[node=0][zone=38] -> 0 pages (XEN) heap[node=0][zone=39] -> 0 pages (XEN) [I: dump HVM irq info] (XEN) 'I' pressed -> dumping HVM irq info (XEN) [M: dump MSI state] (XEN) MSI information: (XEN) IOMMU 24 vec=28 lowest edge assert log lowest dest=00000001 mask=1/0/? (XEN) MSI 25 vec=b8 lowest edge assert log lowest dest=00000001 mask=0/1/? (XEN) MSI 26 vec=c0 lowest edge assert log lowest dest=00000001 mask=0/1/? (XEN) MSI 27 vec=d0 lowest edge assert log lowest dest=00000001 mask=0/1/? (XEN) MSI 28 vec=21 lowest edge assert log lowest dest=00000001 mask=0/1/? (XEN) MSI 29 vec=29 lowest edge assert log lowest dest=00000001 mask=0/1/? (XEN) MSI 30 vec=39 lowest edge assert log lowest dest=00000001 mask=0/1/? (XEN) MSI 31 vec=41 lowest edge assert log lowest dest=00000001 mask=0/1/? (XEN) MSI 32 vec=49 lowest edge assert log lowest dest=00000001 mask=0/1/? (XEN) MSI 33 vec=51 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI 34 vec=59 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI 35 vec=61 lowest edge assert log lowest dest=00000001 mask=1/0/0 (XEN) MSI 36 vec=69 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 37 vec=71 lowest edge assert log lowest dest=00000001 mask=1/0/0 (XEN) MSI-X 38 vec=79 lowest edge assert log lowest dest=00000002 mask=1/0/0 (XEN) MSI-X 39 vec=81 lowest edge assert log lowest dest=00000002 mask=1/0/0 (XEN) MSI-X 40 vec=89 lowest edge assert log lowest dest=00000002 mask=1/0/0 (XEN) MSI-X 41 vec=91 lowest edge assert log lowest dest=00000002 mask=1/0/0 (XEN) MSI 42 vec=99 lowest edge assert log lowest dest=00000001 mask=0/1/? (XEN) MSI-X 43 vec=a1 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 44 vec=a9 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 45 vec=b1 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 46 vec=b9 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 47 vec=c1 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI 48 vec=c9 lowest edge assert log lowest dest=00000002 mask=0/1/? (XEN) MSI-X 49 vec=d1 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 50 vec=d9 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 51 vec=22 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 52 vec=2a lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 53 vec=32 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 54 vec=3a lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 55 vec=42 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 56 vec=4a lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 57 vec=52 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 58 vec=5a lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) [Q: dump PCI devices] (XEN) ==== PCI devices ==== (XEN) ==== segment 0000 ==== (XEN) 0000:0e:00.0 - dom 0 - MSIs < 54 55 56 57 58 > (XEN) 0000:0d:00.0 - dom 0 - MSIs < 49 50 51 52 53 > (XEN) 0000:0c:00.0 - dom 0 - MSIs < 43 44 45 46 47 > (XEN) 0000:0b:00.0 - dom 0 - MSIs < 37 38 39 40 41 > (XEN) 0000:0a:00.0 - dom 0 - MSIs < > (XEN) 0000:09:00.0 - dom 0 - MSIs < > (XEN) 0000:08:00.0 - dom 0 - MSIs < > (XEN) 0000:07:00.0 - dom 0 - MSIs < > (XEN) 0000:05:00.1 - dom 0 - MSIs < > (XEN) 0000:05:00.0 - dom 0 - MSIs < > (XEN) 0000:03:00.0 - dom 0 - MSIs < > (XEN) 0000:02:10.0 - dom 0 - MSIs < 36 > (XEN) 0000:02:09.0 - dom 0 - MSIs < 35 > (XEN) 0000:02:08.0 - dom 0 - MSIs < 34 > (XEN) 0000:01:00.0 - dom 0 - MSIs < 33 > (XEN) 0000:00:1f.3 - dom 0 - MSIs < > (XEN) 0000:00:1f.2 - dom 0 - MSIs < 48 > (XEN) 0000:00:1f.0 - dom 0 - MSIs < > (XEN) 0000:00:1d.0 - dom 0 - MSIs < > (XEN) 0000:00:1c.7 - dom 0 - MSIs < 32 > (XEN) 0000:00:1c.6 - dom 0 - MSIs < 31 > (XEN) 0000:00:1c.5 - dom 0 - MSIs < 30 > (XEN) 0000:00:1c.4 - dom 0 - MSIs < 29 > (XEN) 0000:00:1c.3 - dom 0 - MSIs < 28 > (XEN) 0000:00:1c.2 - dom 0 - MSIs < 27 > (XEN) 0000:00:1c.0 - dom 0 - MSIs < 26 > (XEN) 0000:00:1a.0 - dom 0 - MSIs < > (XEN) 0000:00:16.1 - dom 0 - MSIs < > (XEN) 0000:00:16.0 - dom 0 - MSIs < > (XEN) 0000:00:14.0 - dom 0 - MSIs < 42 > (XEN) 0000:00:01.0 - dom 0 - MSIs < 25 > (XEN) 0000:00:00.0 - dom 0 - MSIs < > (XEN) [V: dump iommu info] (XEN) (XEN) iommu 0: nr_pt_levels = 4. (XEN) Queued Invalidation: supported and enabled. (XEN) Interrupt Remapping: supported and enabled. (XEN) Interrupt remapping table (nr_entry=0x10000. Only dump P=1 entries here): (XEN) SVT SQ SID DST V AVL DLM TM RH DM FPD P (XEN) 0000: 1 0 f0f8 77fe0000 00 0 7 0 0 0 0 1 (XEN) 0001: 1 0 f0f8 00000002 62 0 1 0 1 1 0 1 (XEN) 0002: 1 0 f0f8 00000001 f0 0 1 0 1 1 0 1 (XEN) 0003: 1 0 f0f8 000000ff 38 0 1 0 1 1 0 1 (XEN) 0004: 1 0 f0f8 00000001 f1 0 1 0 1 1 0 1 (XEN) 0005: 1 0 f0f8 00000001 40 0 1 0 1 1 0 1 (XEN) 0006: 1 0 f0f8 00000001 48 0 1 0 1 1 0 1 (XEN) 0007: 1 0 f0f8 00000001 50 0 1 0 1 1 0 1 (XEN) 0008: 1 0 f0f8 00000001 58 0 1 0 1 1 0 1 (XEN) 0009: 1 0 f0f8 00000001 60 0 1 1 1 1 0 1 (XEN) 000a: 1 0 f0f8 00000001 68 0 1 0 1 1 0 1 (XEN) 000b: 1 0 f0f8 00000001 70 0 1 0 1 1 0 1 (XEN) 000c: 1 0 f0f8 00000001 78 0 1 0 1 1 0 1 (XEN) 000d: 1 0 f0f8 000000ff 88 0 1 0 1 1 0 1 (XEN) 000e: 1 0 f0f8 00000001 90 0 1 0 1 1 0 1 (XEN) 000f: 1 0 f0f8 00000001 98 0 1 0 1 1 0 1 (XEN) 0010: 1 0 f0f8 00000002 a0 0 1 1 1 1 0 1 (XEN) 0011: 1 0 f0f8 00000001 a8 0 1 1 1 1 0 1 (XEN) 0012: 1 0 f0f8 00000001 b0 0 1 1 1 1 0 1 (XEN) 0013: 1 0 0008 00000001 b8 0 1 0 1 1 0 1 (XEN) 0014: 1 0 00e0 00000001 c0 0 1 0 1 1 0 1 (XEN) 0015: 1 0 f0f8 000000ff c8 0 1 1 1 1 0 1 (XEN) 0016: 1 0 00e2 00000001 d0 0 1 0 1 1 0 1 (XEN) 0017: 1 0 f0f8 00000001 d8 0 1 1 1 1 0 1 (XEN) 0018: 1 0 00e3 00000001 21 0 1 0 1 1 0 1 (XEN) 0019: 1 0 00e4 00000001 29 0 1 0 1 1 0 1 (XEN) 001a: 1 0 f0f8 000000ff 31 0 1 1 1 1 0 1 (XEN) 001b: 1 0 00e5 00000001 39 0 1 0 1 1 0 1 (XEN) 001c: 1 0 00e6 00000001 41 0 1 0 1 1 0 1 (XEN) 001d: 1 0 00e7 00000001 49 0 1 0 1 1 0 1 (XEN) 001e: 1 0 0100 000000ff 51 0 1 0 1 1 0 1 (XEN) 001f: 1 0 0240 000000ff 59 0 1 0 1 1 0 1 (XEN) 0020: 1 0 0248 00000001 61 0 1 0 1 1 0 1 (XEN) 0021: 1 0 0280 000000ff 69 0 1 0 1 1 0 1 (XEN) 0022: 1 0 0b00 00000001 71 0 1 0 1 1 0 1 (XEN) 0023: 1 0 0b00 00000002 79 0 1 0 1 1 0 1 (XEN) 0024: 1 0 0b00 00000002 81 0 1 0 1 1 0 1 (XEN) 0025: 1 0 0b00 00000002 89 0 1 0 1 1 0 1 (XEN) 0026: 1 0 0b00 00000002 91 0 1 0 1 1 0 1 (XEN) 0027: 1 0 00a0 00000001 99 0 1 0 1 1 0 1 (XEN) 0028: 1 0 0c00 000000ff a1 0 1 0 1 1 0 1 (XEN) 0029: 1 0 0c00 000000ff a9 0 1 0 1 1 0 1 (XEN) 002a: 1 0 0c00 000000ff b1 0 1 0 1 1 0 1 (XEN) 002b: 1 0 0c00 000000ff b9 0 1 0 1 1 0 1 (XEN) 002c: 1 0 0c00 000000ff c1 0 1 0 1 1 0 1 (XEN) 002d: 1 0 00fa 00000002 c9 0 1 0 1 1 0 1 (XEN) 002e: 1 0 0d00 000000ff d1 0 1 0 1 1 0 1 (XEN) 002f: 1 0 0d00 000000ff d9 0 1 0 1 1 0 1 (XEN) 0030: 1 0 0d00 000000ff 22 0 1 0 1 1 0 1 (XEN) 0031: 1 0 0d00 000000ff 2a 0 1 0 1 1 0 1 (XEN) 0032: 1 0 0d00 000000ff 32 0 1 0 1 1 0 1 (XEN) 0033: 1 0 0e00 000000ff 3a 0 1 0 1 1 0 1 (XEN) 0034: 1 0 0e00 000000ff 42 0 1 0 1 1 0 1 (XEN) 0035: 1 0 0e00 000000ff 4a 0 1 0 1 1 0 1 (XEN) 0036: 1 0 0e00 000000ff 52 0 1 0 1 1 0 1 (XEN) 0037: 1 0 0e00 000000ff 5a 0 1 0 1 1 0 1 (XEN) (XEN) Redirection table of IOAPIC 0: (XEN) #entry IDX FMT MASK TRIG IRR POL STAT DELI VECTOR (XEN) 01: 0001 1 0 0 0 0 0 0 62 (XEN) 02: 0002 1 0 0 0 0 0 0 f0 (XEN) 03: 0003 1 1 0 0 0 0 0 38 (XEN) 04: 0004 1 0 0 0 0 0 0 f1 (XEN) 05: 0005 1 0 0 0 0 0 0 40 (XEN) 06: 0006 1 0 0 0 0 0 0 48 (XEN) 07: 0007 1 0 0 0 0 0 0 50 (XEN) 08: 0008 1 0 0 0 0 0 0 58 (XEN) 09: 0009 1 0 1 0 0 0 0 60 (XEN) 0a: 000a 1 0 0 0 0 0 0 68 (XEN) 0b: 000b 1 0 0 0 0 0 0 70 (XEN) 0c: 000c 1 0 0 0 0 0 0 78 (XEN) 0d: 000d 1 1 0 0 0 0 0 88 (XEN) 0e: 000e 1 0 0 0 0 0 0 90 (XEN) 0f: 000f 1 0 0 0 0 0 0 98 (XEN) 10: 0010 1 0 1 0 1 0 0 a0 (XEN) 11: 001a 1 1 1 0 1 0 0 31 (XEN) 12: 0015 1 1 1 0 1 0 0 c8 (XEN) 13: 0017 1 0 1 0 1 0 0 d8 (XEN) 14: 0011 1 0 1 0 1 0 0 a8 (XEN) 17: 0012 1 1 1 0 1 0 0 b0 (XEN) [a: dump timer queues] (XEN) Dumping timer queues: (XEN) CPU00: (XEN) ex= 4413us timer=ffff83047c325cf8 cb=ffff82c4c011b1f0(0000000000000000) csched_tick+0/0x300 (XEN) ex= 24413us timer=ffff83047c326e90 cb=ffff82c4c0119140(ffff83047c326e70) csched_acct+0/0x4e0 (XEN) ex= 3204399us timer=ffff82c4c02fe900 cb=ffff82c4c01a6270(0000000000000000) mce_work_fn+0/0xd0 (XEN) ex=81154605us timer=ffff82c4c02fc5c0 cb=ffff82c4c017ffb0(0000000000000000) plt_overflow+0/0x1a0 (XEN) ex= 994476us timer=ffff82c4c02fc660 cb=ffff82c4c017f5e0(0000000000000000) time_calibration+0/0x60 (XEN) CPU01: (XEN) ex= 774112us timer=ffff8300735e3060 cb=ffff82c4c0120ab0(ffff8300735e3000) vcpu_singleshot_timer_fn+0/0x10 (XEN) CPU02: (XEN) ex= 1974112us timer=ffff830073306060 cb=ffff82c4c0120ab0(ffff830073306000) vcpu_singleshot_timer_fn+0/0x10 (XEN) CPU03: (XEN) ex= 1970112us timer=ffff8300735e1060 cb=ffff82c4c0120ab0(ffff8300735e1000) vcpu_singleshot_timer_fn+0/0x10 (XEN) CPU04: (XEN) ex= 1974112us timer=ffff8300735e0060 cb=ffff82c4c0120ab0(ffff8300735e0000) vcpu_singleshot_timer_fn+0/0x10 (XEN) CPU05: (XEN) ex= 562112us timer=ffff830073307060 cb=ffff82c4c0120ab0(ffff830073307000) vcpu_singleshot_timer_fn+0/0x10 (XEN) CPU06: (XEN) ex= 1978112us timer=ffff830073304060 cb=ffff82c4c0120ab0(ffff830073304000) vcpu_singleshot_timer_fn+0/0x10 (XEN) CPU07: (XEN) ex= 758112us timer=ffff8300735e2060 cb=ffff82c4c0120ab0(ffff8300735e2000) vcpu_singleshot_timer_fn+0/0x10 (XEN) [c: dump ACPI Cx structures] (XEN) 'c' pressed -> printing ACPI Cx structures (XEN) ==cpu0== (XEN) active state: C0 (XEN) max_cstate: C7 (XEN) states: (XEN) C1: type[C1] latency[002] usage[00006021] method[ FFH] duration[1272088102] (XEN) C2: type[C2] latency[033] usage[00001054] method[ FFH] duration[1103202256] (XEN) C3: type[C3] latency[133] usage[00000096] method[ FFH] duration[192886455] (XEN) C4: type[C4] latency[166] usage[00002615] method[ FFH] duration[58636937311] (XEN) *C0: usage[00009786] duration[8063058588] (XEN) PC2[202193184] PC3[57080020963] PC6[0] PC7[0] (XEN) CC3[2130523684] CC6[1098545795] CC7[55502945277] (XEN) ==cpu1== (XEN) active state: C4 (XEN) max_cstate: C7 (XEN) states: (XEN) C1: type[C1] latency[002] usage[00008076] method[ FFH] duration[2437278315] (XEN) C2: type[C2] latency[033] usage[00000752] method[ FFH] duration[3010077195] (XEN) C3: type[C3] latency[133] usage[00000051] method[ FFH] duration[1060807385] (XEN) *C4: type[C4] latency[166] usage[00000892] method[ FFH] duration[61354304400] (XEN) C0: usage[00009771] duration[1508315554] (XEN) PC2[202193184] PC3[57080020963] PC6[0] PC7[0] (XEN) CC3[2130523684] CC6[1098545795] CC7[55502945277] (XEN) ==cpu2== (XEN) active state: C4 (XEN) max_cstate: C7 (XEN) states: (XEN) C1: type[C1] latency[002] usage[00008238] method[ FFH] duration[2467414456] (XEN) C2: type[C2] latency[033] usage[00000664] method[ FFH] duration[2551190275] (XEN) C3: type[C3] latency[133] usage[00000044] method[ FFH] duration[198803587] (XEN) *C4: type[C4] latency[166] usage[00000500] method[ FFH] duration[62667753286] (XEN) C0: usage[00009446] duration[1588230388] (XEN) PC2[202193184] PC3[57080020963] PC6[0] PC7[0] (XEN) CC3[2867852833] CC6[223386122] CC7[62246871261] (XEN) ==cpu3== (XEN) active state: C4 (XEN) max_cstate: C7 (XEN) states: (XEN) C1: type[C1] latency[002] usage[00005769] method[ FFH] duration[1699700414] (XEN) C2: type[C2] latency[033] usage[00000753] method[ FFH] duration[2699411304] (XEN) C3: type[C3] latency[133] usage[00000069] method[ FFH] duration[282530444] (XEN) *C4: type[C4] latency[166] usage[00000627] method[ FFH] duration[63356823241] (XEN) C0: usage[00007218] duration[1537537361] (XEN) PC2[202193184] PC3[57080020963] PC6[0] PC7[0] (XEN) CC3[2867852833] CC6[223386122] CC7[62349458866] (XEN) ==cpu4== (XEN) active state: C4 (XEN) max_cstate: C7 (XEN) states: (XEN) C1: type[C1] latency[002] usage[00007247] method[ FFH] duration[2323221244] (XEN) C2: type[C2] latency[033] usage[00000710] method[ FFH] duration[2629340282] (XEN) C3: type[C3] latency[133] usage[00000033] method[ FFH] duration[128230542] (XEN) *C4: type[C4] latency[166] usage[00000582] method[ FFH] duration[62772787285] (XEN) C0: usage[00008572] duration[1825033455] (XEN) PC2[202193184] PC3[57080020963] PC6[0] PC7[0] (XEN) CC3[2810006292] CC6[618558974] CC7[61832239302] (XEN) ==cpu5== (XEN) active state: C4 (XEN) max_cstate: C7 (XEN) states: (XEN) C1: type[C1] latency[002] usage[00006527] method[ FFH] duration[2153114379] (XEN) C2: type[C2] latency[033] usage[00001049] method[ FFH] duration[2737075047] (XEN) C3: type[C3] latency[133] usage[00000069] method[ FFH] duration[662346446] (XEN) *C4: type[C4] latency[166] usage[00000601] method[ FFH] duration[63066299879] (XEN) C0: usage[00008246] duration[1162387620] (XEN) PC2[202193184] PC3[57080020963] PC6[0] PC7[0] (XEN) CC3[2810006292] CC6[618558974] CC7[61932055431] (XEN) ==cpu6== (XEN) active state: C4 (XEN) max_cstate: C7 (XEN) states: (XEN) C1: type[C1] latency[002] usage[00006166] method[ FFH] duration[1781701479] (XEN) C2: type[C2] latency[033] usage[00000565] method[ FFH] duration[1965073479] (XEN) C3: type[C3] latency[133] usage[00000054] method[ FFH] duration[201769081] (XEN) *C4: type[C4] latency[166] usage[00000542] method[ FFH] duration[64034537658] (XEN) C0: usage[00007327] duration[1900751052] (XEN) PC2[202193184] PC3[57080020963] PC6[0] PC7[0] (XEN) CC3[2621378914] CC6[253292168] CC7[62762457041] (XEN) ==cpu7== (XEN) active state: C4 (XEN) max_cstate: C7 (XEN) states: (XEN) C1: type[C1] latency[002] usage[00007395] method[ FFH] duration[2442470054] (XEN) C2: type[C2] latency[033] usage[00000782] method[ FFH] duration[2643761860] (XEN) C3: type[C3] latency[133] usage[00000044] method[ FFH] duration[266563932] (XEN) *C4: type[C4] latency[166] usage[00000527] method[ FFH] duration[63181254261] (XEN) C0: usage[00008748] duration[1452393178] (XEN) PC2[202193184] PC3[57080020963] PC6[0] PC7[0] (XEN) CC3[2621378914] CC6[253292168] CC7[62865044576] (XEN) [e: dump evtchn info] (XEN) 'e' pressed -> dumping event-channel info (XEN) Event channel information for domain 0: (XEN) Polling vCPUs: {} (XEN) port [p/m] (XEN) 1 [0/0]: s=5 n=0 x=0 v=0 (XEN) 2 [0/0]: s=6 n=0 x=0 (XEN) 3 [0/0]: s=6 n=0 x=0 (XEN) 4 [0/0]: s=5 n=0 x=0 v=1 (XEN) 5 [0/0]: s=6 n=0 x=0 (XEN) 6 [0/0]: s=6 n=0 x=0 (XEN) 7 [0/0]: s=5 n=1 x=0 v=0 (XEN) 8 [0/0]: s=6 n=1 x=0 (XEN) 9 [0/0]: s=6 n=1 x=0 (XEN) 10 [0/0]: s=5 n=1 x=0 v=1 (XEN) 11 [0/0]: s=6 n=1 x=0 (XEN) 12 [0/0]: s=6 n=1 x=0 (XEN) 13 [0/0]: s=5 n=2 x=0 v=0 (XEN) 14 [0/0]: s=6 n=2 x=0 (XEN) 15 [0/0]: s=6 n=2 x=0 (XEN) 16 [0/0]: s=5 n=2 x=0 v=1 (XEN) 17 [0/0]: s=6 n=2 x=0 (XEN) 18 [0/0]: s=6 n=2 x=0 (XEN) 19 [0/0]: s=5 n=3 x=0 v=0 (XEN) 20 [0/0]: s=6 n=3 x=0 (XEN) 21 [0/0]: s=6 n=3 x=0 (XEN) 22 [0/0]: s=5 n=3 x=0 v=1 (XEN) 23 [0/0]: s=6 n=3 x=0 (XEN) 24 [0/0]: s=6 n=3 x=0 (XEN) 25 [0/0]: s=5 n=4 x=0 v=0 (XEN) 26 [0/0]: s=6 n=4 x=0 (XEN) 27 [0/0]: s=6 n=4 x=0 (XEN) 28 [0/0]: s=5 n=4 x=0 v=1 (XEN) 29 [0/0]: s=6 n=4 x=0 (XEN) 30 [0/0]: s=6 n=4 x=0 (XEN) 31 [0/0]: s=5 n=5 x=0 v=0 (XEN) 32 [0/0]: s=6 n=5 x=0 (XEN) 33 [0/0]: s=6 n=5 x=0 (XEN) 34 [0/0]: s=5 n=5 x=0 v=1 (XEN) 35 [0/0]: s=6 n=5 x=0 (XEN) 36 [0/0]: s=6 n=5 x=0 (XEN) 37 [1/0]: s=5 n=6 x=0 v=0 (XEN) 38 [1/0]: s=6 n=6 x=0 (XEN) 39 [0/0]: s=6 n=6 x=0 (XEN) 40 [0/0]: s=5 n=6 x=0 v=1 (XEN) 41 [0/0]: s=6 n=6 x=0 (XEN) 42 [0/0]: s=6 n=6 x=0 (XEN) 43 [0/0]: s=5 n=7 x=0 v=0 (XEN) 44 [0/0]: s=6 n=7 x=0 (XEN) 45 [0/0]: s=6 n=7 x=0 (XEN) 46 [0/0]: s=5 n=7 x=0 v=1 (XEN) 47 [0/0]: s=6 n=7 x=0 (XEN) 48 [0/0]: s=6 n=7 x=0 (XEN) 49 [0/0]: s=3 n=0 x=0 d=0 p=76 (XEN) 50 [0/0]: s=5 n=0 x=0 v=9 (XEN) 51 [0/0]: s=4 n=0 x=0 p=9 i=9 (XEN) 52 [0/0]: s=4 n=0 x=0 p=279 i=25 (XEN) 53 [0/0]: s=4 n=0 x=0 p=278 i=26 (XEN) 54 [0/0]: s=4 n=0 x=0 p=277 i=27 (XEN) 55 [0/0]: s=4 n=0 x=0 p=276 i=28 (XEN) 56 [0/0]: s=4 n=0 x=0 p=275 i=29 (XEN) 57 [0/0]: s=4 n=0 x=0 p=274 i=30 (XEN) 58 [0/0]: s=4 n=0 x=0 p=273 i=31 (XEN) 59 [0/0]: s=4 n=0 x=0 p=272 i=32 (XEN) 60 [0/0]: s=4 n=0 x=0 p=269 i=35 (XEN) 61 [0/1]: s=5 n=0 x=0 v=2 (XEN) 62 [0/0]: s=4 n=0 x=0 p=1 i=1 (XEN) 63 [0/0]: s=4 n=0 x=0 p=8 i=8 (XEN) 64 [0/0]: s=4 n=0 x=0 p=20 i=20 (XEN) 66 [0/0]: s=4 n=0 x=0 p=16 i=16 (XEN) 67 [0/0]: s=4 n=0 x=0 p=262 i=42 (XEN) 68 [0/0]: s=4 n=0 x=0 p=256 i=48 (XEN) 69 [0/0]: s=4 n=0 x=0 p=5 i=5 (XEN) 70 [0/0]: s=4 n=0 x=0 p=19 i=19 (XEN) 71 [0/0]: s=4 n=0 x=0 p=267 i=37 (XEN) 72 [0/0]: s=4 n=0 x=0 p=266 i=38 (XEN) 73 [0/0]: s=4 n=0 x=0 p=265 i=39 (XEN) 74 [0/0]: s=4 n=0 x=0 p=264 i=40 (XEN) 75 [0/0]: s=4 n=0 x=0 p=263 i=41 (XEN) 76 [0/0]: s=3 n=0 x=0 d=0 p=49 (XEN) 77 [0/0]: s=5 n=0 x=0 v=3 (XEN) [g: print grant table usage] (XEN) gnttab_usage_print_all [ key 'g' pressed (XEN) -------- active -------- -------- shared -------- (XEN) [ref] localdom mfn pin localdom gmfn flags (XEN) grant-table for remote domain: 0 ... no active grant table entries (XEN) gnttab_usage_print_all ] done (XEN) [i: dump interrupt bindings] (XEN) Guest interrupt information: (XEN) IRQ: 0 affinity:01 vec:f0 type=IO-APIC-edge status=00000000 timer_interrupt+0/0x180 (XEN) IRQ: 1 affinity:02 vec:62 type=IO-APIC-edge status=00000010 in-flight=0 domain-list=0: 1(----), (XEN) IRQ: 3 affinity:ff vec:38 type=IO-APIC-edge status=00000002 mapped, unbound (XEN) IRQ: 4 affinity:01 vec:f1 type=IO-APIC-edge status=00000000 ns16550_interrupt+0/0x90 (XEN) IRQ: 5 affinity:01 vec:40 type=IO-APIC-edge status=00000030 in-flight=0 domain-list=0: 5(----), (XEN) IRQ: 6 affinity:01 vec:48 type=IO-APIC-edge status=00000002 mapped, unbound (XEN) IRQ: 7 affinity:01 vec:50 type=IO-APIC-edge status=00000002 mapped, unbound (XEN) IRQ: 8 affinity:01 vec:58 type=IO-APIC-edge status=00000030 in-flight=0 domain-list=0: 8(----), (XEN) IRQ: 9 affinity:01 vec:60 type=IO-APIC-level status=00000030 in-flight=0 domain-list=0: 9(----), (XEN) IRQ: 10 affinity:01 vec:68 type=IO-APIC-edge status=00000002 mapped, unbound (XEN) IRQ: 11 affinity:01 vec:70 type=IO-APIC-edge status=00000002 mapped, unbound (XEN) IRQ: 12 affinity:01 vec:78 type=IO-APIC-edge status=00000002 mapped, unbound (XEN) IRQ: 13 affinity:ff vec:88 type=IO-APIC-edge status=00000002 mapped, unbound (XEN) IRQ: 14 affinity:01 vec:90 type=IO-APIC-edge status=00000002 mapped, unbound (XEN) IRQ: 15 affinity:01 vec:98 type=IO-APIC-edge status=00000002 mapped, unbound (XEN) IRQ: 16 affinity:02 vec:a0 type=IO-APIC-level status=00000010 in-flight=0 domain-list=0: 16(----), (XEN) IRQ: 17 affinity:ff vec:31 type=IO-APIC-level status=00000002 mapped, unbound (XEN) IRQ: 18 affinity:ff vec:c8 type=IO-APIC-level status=00000002 mapped, unbound (XEN) IRQ: 19 affinity:01 vec:d8 type=IO-APIC-level status=00000030 in-flight=0 domain-list=0: 19(----), (XEN) IRQ: 20 affinity:01 vec:a8 type=IO-APIC-level status=00000030 in-flight=0 domain-list=0: 20(----), (XEN) IRQ: 23 affinity:01 vec:b0 type=IO-APIC-level status=00000022 mapped, unbound (XEN) IRQ: 24 affinity:ff vec:28 type=DMA_MSI status=00000000 iommu_page_fault+0/0x10 (XEN) IRQ: 25 affinity:01 vec:b8 type=PCI-MSI status=00000030 in-flight=0 domain-list=0:279(----), (XEN) IRQ: 26 affinity:01 vec:c0 type=PCI-MSI status=00000030 in-flight=0 domain-list=0:278(----), (XEN) IRQ: 27 affinity:01 vec:d0 type=PCI-MSI status=00000030 in-flight=0 domain-list=0:277(----), (XEN) IRQ: 28 affinity:01 vec:21 type=PCI-MSI status=00000030 in-flight=0 domain-list=0:276(----), (XEN) IRQ: 29 affinity:01 vec:29 type=PCI-MSI status=00000030 in-flight=0 domain-list=0:275(----), (XEN) IRQ: 30 affinity:01 vec:39 type=PCI-MSI status=00000030 in-flight=0 domain-list=0:274(----), (XEN) IRQ: 31 affinity:01 vec:41 type=PCI-MSI status=00000030 in-flight=0 domain-list=0:273(----), (XEN) IRQ: 32 affinity:01 vec:49 type=PCI-MSI status=00000030 in-flight=0 domain-list=0:272(----), (XEN) IRQ: 33 affinity:ff vec:51 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 34 affinity:ff vec:59 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 35 affinity:01 vec:61 type=PCI-MSI/-X status=00000030 in-flight=0 domain-list=0:269(----), (XEN) IRQ: 36 affinity:ff vec:69 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 37 affinity:01 vec:71 type=PCI-MSI/-X status=00000030 in-flight=0 domain-list=0:267(----), (XEN) IRQ: 38 affinity:02 vec:79 type=PCI-MSI/-X status=00000010 in-flight=0 domain-list=0:266(----), (XEN) IRQ: 39 affinity:02 vec:81 type=PCI-MSI/-X status=00000010 in-flight=0 domain-list=0:265(----), (XEN) IRQ: 40 affinity:02 vec:89 type=PCI-MSI/-X status=00000010 in-flight=0 domain-list=0:264(----), (XEN) IRQ: 41 affinity:02 vec:91 type=PCI-MSI/-X status=00000010 in-flight=0 domain-list=0:263(----), (XEN) IRQ: 42 affinity:01 vec:99 type=PCI-MSI status=00000030 in-flight=0 domain-list=0:262(----), (XEN) IRQ: 43 affinity:ff vec:a1 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 44 affinity:ff vec:a9 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 45 affinity:ff vec:b1 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 46 affinity:ff vec:b9 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 47 affinity:ff vec:c1 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 48 affinity:02 vec:c9 type=PCI-MSI status=00000010 in-flight=0 domain-list=0:256(----), (XEN) IRQ: 49 affinity:ff vec:d1 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 50 affinity:ff vec:d9 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 51 affinity:ff vec:22 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 52 affinity:ff vec:2a type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 53 affinity:ff vec:32 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 54 affinity:ff vec:3a type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 55 affinity:ff vec:42 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 56 affinity:ff vec:4a type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 57 affinity:ff vec:52 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 58 affinity:ff vec:5a type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IO-APIC interrupt information: (XEN) IRQ 0 Vec240: (XEN) Apic 0x00, Pin 2: vec=f0 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=0 dest_id:0 (XEN) IRQ 1 Vec 98: (XEN) Apic 0x00, Pin 1: vec=62 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=0 dest_id:0 (XEN) IRQ 3 Vec 56: (XEN) Apic 0x00, Pin 3: vec=38 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=1 dest_id:0 (XEN) IRQ 4 Vec241: (XEN) Apic 0x00, Pin 4: vec=f1 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=0 dest_id:0 (XEN) IRQ 5 Vec 64: (XEN) Apic 0x00, Pin 5: vec=40 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=0 dest_id:0 (XEN) IRQ 6 Vec 72: (XEN) Apic 0x00, Pin 6: vec=48 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=0 dest_id:0 (XEN) IRQ 7 Vec 80: (XEN) Apic 0x00, Pin 7: vec=50 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=0 dest_id:0 (XEN) IRQ 8 Vec 88: (XEN) Apic 0x00, Pin 8: vec=58 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=0 dest_id:0 (XEN) IRQ 9 Vec 96: (XEN) Apic 0x00, Pin 9: vec=60 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=L mask=0 dest_id:0 (XEN) IRQ 10 Vec104: (XEN) Apic 0x00, Pin 10: vec=68 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=0 dest_id:0 (XEN) IRQ 11 Vec112: (XEN) Apic 0x00, Pin 11: vec=70 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=0 dest_id:0 (XEN) IRQ 12 Vec120: (XEN) Apic 0x00, Pin 12: vec=78 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=0 dest_id:0 (XEN) IRQ 13 Vec136: (XEN) Apic 0x00, Pin 13: vec=88 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=1 dest_id:0 (XEN) IRQ 14 Vec144: (XEN) Apic 0x00, Pin 14: vec=90 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=0 dest_id:0 (XEN) IRQ 15 Vec152: (XEN) Apic 0x00, Pin 15: vec=98 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=0 dest_id:0 (XEN) IRQ 16 Vec160: (XEN) Apic 0x00, Pin 16: vec=a0 delivery=LoPri dest=L status=0 polarity=1 irr=0 trig=L mask=0 dest_id:0 (XEN) IRQ 17 Vec 49: (XEN) Apic 0x00, Pin 17: vec=31 delivery=LoPri dest=L status=0 polarity=1 irr=0 trig=L mask=1 dest_id:0 (XEN) IRQ 18 Vec200: (XEN) Apic 0x00, Pin 18: vec=c8 delivery=LoPri dest=L status=0 polarity=1 irr=0 trig=L mask=1 dest_id:0 (XEN) IRQ 19 Vec216: (XEN) Apic 0x00, Pin 19: vec=d8 delivery=LoPri dest=L status=0 polarity=1 irr=0 trig=L mask=0 dest_id:0 (XEN) IRQ 20 Vec168: (XEN) Apic 0x00, Pin 20: vec=a8 delivery=LoPri dest=L status=0 polarity=1 irr=0 trig=L mask=0 dest_id:0 (XEN) IRQ 23 Vec176: (XEN) Apic 0x00, Pin 23: vec=b0 delivery=LoPri dest=L status=0 polarity=1 irr=0 trig=L mask=1 dest_id:0 (XEN) [m: memory info] (XEN) Physical memory information: (XEN) Xen heap: 0kB free (XEN) heap[14]: 64512kB free (XEN) heap[15]: 131072kB free (XEN) heap[16]: 262144kB free (XEN) heap[17]: 524288kB free (XEN) heap[18]: 839172kB free (XEN) heap[20]: 4194304kB free (XEN) heap[21]: 8388608kB free (XEN) heap[22]: 895100kB free (XEN) Dom heap: 15299200kB free (XEN) [n: NMI statistics] (XEN) CPU NMI (XEN) 0 0 (XEN) 1 0 (XEN) 2 0 (XEN) 3 0 (XEN) 4 0 (XEN) 5 0 (XEN) 6 0 (XEN) 7 0 (XEN) dom0 vcpu0: NMI neither pending nor masked (XEN) [q: dump domain (and guest debug) info] (XEN) 'q' pressed -> dumping domain info (now=0x10:D0C0F02E) (XEN) General information for domain 0: (XEN) refcnt=3 dying=0 pause_count=0 (XEN) nr_pages=262144 xenheap_pages=6 shared_pages=0 paged_pages=0 dirty_cpus={1-7} max_pages=4294967295 (XEN) handle=00000000-0000-0000-0000-000000000000 vm_assist=0000000d (XEN) Rangesets belonging to domain 0: (XEN) I/O Ports { 0-1f, 22-3f, 44-60, 62-9f, a2-3f7, 400-cfb, d00-1807, 180c-ffff } (XEN) Interrupts { 1-23, 25-58 } (XEN) I/O Memory { 0-fedff, fee01-ffffffffffffffff } (XEN) Memory pages belonging to domain 0: (XEN) DomPage list too long to display (XEN) XenPage 0000000000471114: caf=c000000000000002, taf=7400000000000002 (XEN) XenPage 0000000000471113: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 0000000000471112: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 0000000000471111: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 00000000000643fc: caf=c000000000000002, taf=7400000000000002 (XEN) XenPage 0000000000445c43: caf=c000000000000002, taf=7400000000000002 (XEN) NODE affinity for domain 0: [0] (XEN) VCPU information and callbacks for domain 0: (XEN) VCPU0: CPU1 [has=F] poll=0 upcall_pend = 00, upcall_mask = 00 dirty_cpus={1} cpu_affinity={0-7} (XEN) pause_count=0 pause_flags=1 (XEN) No periodic timer (XEN) VCPU1: CPU7 [has=F] poll=0 upcall_pend = 00, upcall_mask = 00 dirty_cpus={7} cpu_affinity={0-7} (XEN) pause_count=0 pause_flags=1 (XEN) No periodic timer (XEN) VCPU2: CPU3 [has=F] poll=0 upcall_pend = 00, upcall_mask = 00 dirty_cpus={3} cpu_affinity={0-7} (XEN) pause_count=0 pause_flags=1 (XEN) No periodic timer (XEN) VCPU3: CPU4 [has=F] poll=0 upcall_pend = 00, upcall_mask = 00 dirty_cpus={4} cpu_affinity={0-7} (XEN) pause_count=0 pause_flags=1 (XEN) No periodic timer (XEN) VCPU4: CPU5 [has=F] poll=0 upcall_pend = 00, upcall_mask = 00 dirty_cpus={5} cpu_affinity={0-7} (XEN) pause_count=0 pause_flags=1 (XEN) No periodic timer (XEN) VCPU5: CPU2 [has=F] poll=0 upcall_pend = 00, upcall_mask = 00 dirty_cpus={2} cpu_affinity={0-7} (XEN) pause_count=0 pause_flags=1 (XEN) No periodic timer (XEN) VCPU6: CPU0 [has=F] poll=0 upcall_pend = 01, upcall_mask = 00 dirty_cpus={} cpu_affinity={0-7} (XEN) pause_count=0 pause_flags=0 (XEN) No periodic timer (XEN) VCPU7: CPU6 [has=F] poll=0 upcall_pend = 00, upcall_mask = 00 dirty_cpus={6} cpu_affinity={0-7} (XEN) pause_count=0 pause_flags=1 (XEN) No periodic timer (XEN) Notifying guest 0:0 (virq 1, port 4, stat 0/0/0) (XEN) Notifying guest 0:1 (virq 1, port 10, stat 0/0/0) (XEN) Notifying guest 0:2 (virq 1, port 16, stat 0/0/0) (XEN) Notifying guest 0:3 (virq 1, port 22, stat 0/0/0) (XEN) Notifying guest 0:4 (virq 1, port 28, stat 0/0/0) (XEN) Notifying guest 0:5 (virq 1, port 34, stat 0/0/0) (XEN) Notifying guest 0:6 (virq 1, port 40, stat 0/0/-1) (XEN) Notifying guest 0:7 (virq 1, port 46, stat 0/0/0) (XEN) Shared frames 0 -- Saved frames 0 (XEN) [r: dump run queues] (XEN) sched_smt_power_savings: disabled (XEN) NOW=0x00000010F126F837 (XEN) Idle cpupool: (XEN) Scheduler: SMP Credit Scheduler (credit) (XEN) info: (XEN) ncpus = 8 (XEN) master = 0 (XEN) credit = 2400 (XEN) credit balance = 0 (XEN) weight = 0 (XEN) runq_sort = 125 (XEN) default-weight = 256 (XEN) tslice = 30ms (XEN) ratelimit = 1000us (XEN) credits per msec = 10 (XEN) ticks per tslice = 3 (XEN) migration delay = 0us (XEN) idlers: fe (XEN) active vcpus: (XEN) Cpupool 0: (XEN) Scheduler: SMP Credit Scheduler (credit) (XEN) info: (XEN) ncpus = 8 (XEN) master = 0 (XEN) credit = 2400 (XEN) credit balance = 0 (XEN) weight = 0 (XEN) runq_sort = 125 (XEN) default-weight = 256 (XEN) tslice = 30ms (XEN) ratelimit = 1000us (XEN) credits per msec = 10 (XEN) ticks per tslice = 3 (XEN) migration delay = 0us (XEN) idlers: fe (XEN) active vcpus: (XEN) CPU[00] sort=125, sibling=03, core=ff (XEN) run: [32767.0] pri=0 flags=0 cpu=0 (XEN) 1: [0.6] pri=0 flags=0 cpu=0 credit=-16 [w=256] (XEN) CPU[01] sort=107, sibling=03, core=ff (XEN) run: [32767.1] pri=-64 flags=0 cpu=1 (XEN) CPU[02] sort=123, sibling=0c, core=ff (XEN) run: [32767.2] pri=-64 flags=0 cpu=2 (XEN) CPU[03] sort=122, sibling=0c, core=ff (XEN) run: [32767.3] pri=-64 flags=0 cpu=3 (XEN) CPU[04] sort=116, sibling=30, core=ff (XEN) run: [32767.4] pri=-64 flags=0 cpu=4 (XEN) CPU[05] sort=114, sibling=30, core=ff (XEN) run: [32767.5] pri=-64 flags=0 cpu=5 (XEN) CPU[06] sort=119, sibling=c0, core=ff (XEN) run: [32767.6] pri=-64 flags=0 cpu=6 (XEN) CPU[07] sort=118, sibling=c0, core=ff (XEN) run: [32767.7] pri=-64 flags=0 cpu=7 (XEN) [s: dump softtsc stats] (XEN) TSC marked as reliable, warp = 0 (count=2) (XEN) No domains have emulated TSC (XEN) [t: display multi-cpu clock info] (XEN) Synced stime skew: max=19ns avg=19ns samples=1 current=19ns (XEN) Synced cycles skew: max=191 avg=191 samples=1 current=191 (XEN) [u: dump numa info] (XEN) 'u' pressed -> dumping numa info (now-0x11:08D21C55) (XEN) idx0 -> NODE0 start->0 size->4718592 free->3824800 (XEN) phys_to_nid(0000000000001000) -> 0 should be 0 (XEN) CPU0 -> NODE0 (XEN) CPU1 -> NODE0 (XEN) CPU2 -> NODE0 (XEN) CPU3 -> NODE0 (XEN) CPU4 -> NODE0 (XEN) CPU5 -> NODE0 (XEN) CPU6 -> NODE0 (XEN) CPU7 -> NODE0 (XEN) Memory location of each domain: (XEN) Domain 0 (total: 262144): (XEN) Node 0: 262144 (XEN) [v: dump Intel's VMCS] (XEN) *********** VMCS Areas ************** (XEN) ************************************** (XEN) [z: print ioapic info] (XEN) number of MP IRQ sources: 15. (XEN) number of IO-APIC #8 registers: 24. (XEN) testing the IO APIC....................... (XEN) IO APIC #8...... (XEN) .... register #00: 08000000 (XEN) ....... : physical APIC id: 08 (XEN) ....... : Delivery Type: 0 (XEN) ....... : LTS : 0 (XEN) .... register #01: 00170020 (XEN) ....... : max redirection entries: 0017 (XEN) ....... : PRQ implemented: 0 (XEN) ....... : IO APIC version: 0020 (XEN) .... IRQ redirection table: (XEN) NR Log Phy Mask Trig IRR Pol Stat Dest Deli Vect: (XEN) 00 000 00 1 0 0 0 0 0 7 00 (XEN) 01 000 00 0 0 0 0 0 1 1 62 (XEN) 02 000 00 0 0 0 0 0 1 1 F0 (XEN) 03 000 00 1 0 0 0 0 1 1 38 (XEN) 04 000 00 0 0 0 0 0 1 1 F1 (XEN) 05 000 00 0 0 0 0 0 1 1 40 (XEN) 06 000 00 0 0 0 0 0 1 1 48 (XEN) 07 000 00 0 0 0 0 0 1 1 50 (XEN) 08 000 00 0 0 0 0 0 1 1 58 (XEN) 09 000 00 0 1 0 0 0 1 1 60 (XEN) 0a 000 00 0 0 0 0 0 1 1 68 (XEN) 0b 000 00 0 0 0 0 0 1 1 70 (XEN) 0c 000 00 0 0 0 0 0 1 1 78 (XEN) 0d 000 00 1 0 0 0 0 1 1 88 (XEN) 0e 000 00 0 0 0 0 0 1 1 90 (XEN) 0f 000 00 0 0 0 0 0 1 1 98 (XEN) 10 000 00 0 1 0 1 0 1 1 A0 (XEN) 11 000 00 1 1 0 1 0 1 1 31 (XEN) 12 000 00 1 1 0 1 0 1 1 C8 (XEN) 13 000 00 0 1 0 1 0 1 1 D8 (XEN) 14 000 00 0 1 0 1 0 1 1 A8 (XEN) 15 000 00 1 0 0 0 0 0 0 00 (XEN) 16 000 00 1 0 0 0 0 0 0 00 (XEN) 17 000 00 1 1 0 1 0 1 1 B0 (XEN) Using vector-based indexing (XEN) IRQ to pin mappings: (XEN) IRQ240 -> 0:2 (XEN) IRQ98 -> 0:1 (XEN) IRQ56 -> 0:3 (XEN) IRQ241 -> 0:4 (XEN) IRQ64 -> 0:5 (XEN) IRQ72 -> 0:6 (XEN) IRQ80 -> 0:7 (XEN) IRQ88 -> 0:8 (XEN) IRQ96 -> 0:9 (XEN) IRQ104 -> 0:10 (XEN) IRQ112 -> 0:11 (XEN) IRQ120 -> 0:12 (XEN) IRQ136 -> 0:13 (XEN) IRQ144 -> 0:14 (XEN) IRQ152 -> 0:15 (XEN) IRQ160 -> 0:16 (XEN) IRQ49 -> 0:17 (XEN) IRQ200 -> 0:18 (XEN) IRQ216 -> 0:19 (XEN) IRQ168 -> 0:20 (XEN) IRQ176 -> 0:23 (XEN) .................................... done. (XEN) HVM1: HVM Loader (XEN) HVM1: Detected Xen v4.3.0 (XEN) HVM1: Xenbus rings @0xfeffc000, event channel 8 (XEN) HVM1: System requested SeaBIOS (XEN) HVM1: CPU speed is 3292 MHz (XEN) HVM1: Relocating guest memory for lowmem MMIO space disabled (XEN) irq.c:270: Dom1 PCI link 0 changed 0 -> 5 (XEN) HVM1: PCI-ISA link 0 routed to IRQ5 (XEN) irq.c:270: Dom1 PCI link 1 changed 0 -> 10 (XEN) HVM1: PCI-ISA link 1 routed to IRQ10 (XEN) irq.c:270: Dom1 PCI link 2 changed 0 -> 11 (XEN) HVM1: PCI-ISA link 2 routed to IRQ11 (XEN) irq.c:270: Dom1 PCI link 3 changed 0 -> 5 (XEN) HVM1: PCI-ISA link 3 routed to IRQ5 (XEN) HVM1: pci dev 01:2 INTD->IRQ5 (XEN) HVM1: pci dev 01:3 INTA->IRQ10 (XEN) HVM1: pci dev 03:0 INTA->IRQ5 (XEN) HVM1: pci dev 04:0 INTA->IRQ5 (XEN) HVM1: pci dev 05:0 INTA->IRQ10 (XEN) HVM1: pci dev 06:0 INTB->IRQ5 (XEN) HVM1: pci dev 07:0 INTA->IRQ5 (XEN) HVM1: No RAM in high memory; setting high_mem resource base to 100000000 (XEN) HVM1: pci dev 05:0 bar 10 size 010000000: 0e000000c (XEN) memory_map:add: dom1 gfn=e0000 mfn=c0000 nr=10000 (XEN) HVM1: pci dev 02:0 bar 10 size 002000000: 0f0000008 (XEN) HVM1: pci dev 03:0 bar 14 size 001000000: 0f2000008 (XEN) HVM1: pci dev 04:0 bar 30 size 000040000: 0f3000000 (XEN) memory_map:add: dom1 gfn=f3040 mfn=d0000 nr=40 (XEN) HVM1: pci dev 05:0 bar 18 size 000040000: 0f3040004 (XEN) HVM1: pci dev 05:0 bar 30 size 000020000: 0f3080000 (XEN) HVM1: pci dev 02:0 bar 30 size 000010000: 0f30a0000 (XEN) HVM1: pci dev 06:0 bar 10 size 000004000: 0f30b0004 (XEN) memory_map:add: dom1 gfn=f30b0 mfn=d0060 nr=4 (XEN) HVM1: pci dev 02:0 bar 14 size 000001000: 0f30b4000 (XEN) HVM1: pci dev 07:0 bar 10 size 000001000: 0f30b5000 (XEN) memory_map:add: dom1 gfn=f30b5 mfn=d0411 nr=1 (XEN) HVM1: pci dev 03:0 bar 10 size 000000100: 00000c001 (XEN) HVM1: pci dev 04:0 bar 10 size 000000100: 00000c101 (XEN) HVM1: pci dev 04:0 bar 14 size 000000100: 0f30b6000 (XEN) HVM1: pci dev 05:0 bar 20 size 000000100: 00000c201 (XEN) ioport_map:add: dom1 gport=c200 mport=e000 nr=100 (XEN) HVM1: pci dev 01:2 bar 20 size 000000020: 00000c301 (XEN) HVM1: pci dev 01:1 bar 20 size 000000010: 00000c321 (XEN) HVM1: Multiprocessor initialisation: (XEN) HVM1: - CPU0 ... 39-bit phys ... fixed MTRRs ... var MTRRs [3/8] ... done. (XEN) HVM1: - CPU1 ... 39-bit phys ... fixed MTRRs ... var MTRRs [3/8] ... done. (XEN) HVM1: - CPU2 ... 39-bit phys ... fixed MTRRs ... var MTRRs [3/8] ... done. (XEN) HVM1: - CPU3 ... 39-bit phys ... fixed MTRRs ... var MTRRs [3/8] ... done. (XEN) HVM1: - CPU4 ... 39-bit phys ... fixed MTRRs ... var MTRRs [3/8] ... done. (XEN) HVM1: - CPU5 ... 39-bit phys ... fixed MTRRs ... var MTRRs [3/8] ... done. (XEN) HVM1: Writing SMBIOS tables ... (XEN) HVM1: Loading SeaBIOS ... (XEN) HVM1: Creating MP tables ... (XEN) HVM1: Loading ACPI ... (XEN) HVM1: vm86 TSS at fc00a180 (XEN) HVM1: BIOS map: (XEN) HVM1: 10000-100d3: Scratch space (XEN) HVM1: e0000-fffff: Main BIOS (XEN) HVM1: E820 table: (XEN) HVM1: [00]: 00000000:00000000 - 00000000:000a0000: RAM (XEN) HVM1: HOLE: 00000000:000a0000 - 00000000:000e0000 (XEN) HVM1: [01]: 00000000:000e0000 - 00000000:00100000: RESERVED (XEN) HVM1: [02]: 00000000:00100000 - 00000000:7f800000: RAM (XEN) HVM1: HOLE: 00000000:7f800000 - 00000000:fc000000 (XEN) HVM1: [03]: 00000000:fc000000 - 00000001:00000000: RESERVED (XEN) HVM1: Invoking SeaBIOS ... (XEN) HVM1: SeaBIOS (version debian/1.7.3-2-0-gd3d3d64-dirty-20131124_004140-gandalf) (XEN) HVM1: (XEN) HVM1: Found Xen hypervisor signature at 40000100 (XEN) HVM1: xen: copy e820... (XEN) HVM1: Relocating init from 0x000e1f51 to 0x7f7e05b0 (size 63875) (XEN) HVM1: CPU Mhz=3292 (XEN) HVM1: Found 11 PCI devices (max PCI bus is 00) (XEN) HVM1: Allocated Xen hypercall page at 7f7ff000 (XEN) HVM1: Detected Xen v4.3.0 (XEN) HVM1: xen: copy BIOS tables... (XEN) HVM1: Copying SMBIOS entry point from 0x00010010 to 0x000f18c0 (XEN) HVM1: Copying MPTABLE from 0xfc0011f0/fc001200 to 0x000f1770 (XEN) HVM1: Copying PIR from 0x00010030 to 0x000f16f0 (XEN) HVM1: Copying ACPI RSDP from 0x000100b0 to 0x000f16c0 (XEN) HVM1: Using pmtimer, ioport 0xb008, freq 3579 kHz (XEN) HVM1: Scan for VGA option rom (XEN) HVM1: Running option rom at c000:0003 (XEN) stdvga.c:147:d1 entering stdvga and caching modes (XEN) HVM1: pmm call arg1=0 (XEN) HVM1: Turning on vga text mode console (XEN) HVM1: SeaBIOS (version debian/1.7.3-2-0-gd3d3d64-dirty-20131124_004140-gandalf) (XEN) HVM1: Machine UUID ab8f106b-2e46-4512-957d-d587797d43ac (XEN) HVM1: UHCI init on dev 00:01.2 (io=c300) (XEN) HVM1: EHCI init on dev 00:07.0 (regs=0xf30b5020) (XEN) HVM1: Found 1 lpt ports (XEN) HVM1: Found 1 serial ports (XEN) HVM1: ATA controller 1 at 1f0/3f4/0 (irq 14 dev 9) (XEN) HVM1: ATA controller 2 at 170/374/0 (irq 15 dev 9) (XEN) HVM1: ata0-0: QEMU HARDDISK ATA-7 Hard-Disk (51200 MiBytes) (XEN) HVM1: Searching bootorder for: /pci@i0cf8/*@1,1/drive@0/disk@0 (XEN) HVM1: DVD/CD [ata1-0: QEMU DVD-ROM ATAPI-4 DVD/CD] (XEN) HVM1: Searching bootorder for: /pci@i0cf8/*@1,1/drive@1/disk@0 (XEN) HVM1: PS2 keyboard initialized (XEN) HVM1: Initialized USB HUB (0 ports used) (XEN) HVM1: All threads complete. (XEN) HVM1: Scan for option roms (XEN) HVM1: Running option rom at c900:0003 (XEN) HVM1: pmm call arg1=1 (XEN) HVM1: pmm call arg1=0 (XEN) HVM1: pmm call arg1=1 (XEN) HVM1: pmm call arg1=0 (XEN) HVM1: Searching bootorder for: /pci@i0cf8/*@4 (XEN) HVM1: (XEN) HVM1: Press F12 for boot menu. (XEN) HVM1: (XEN) HVM1: Searching bootorder for: HALT (XEN) HVM1: drive 0x000f1670: PCHS=16383/16/63 translation=lba LCHS=1024/255/63 s=10485760 (XEN) HVM1: 0 (XEN) HVM1: Space available for UMB: ca000-ec800, f0000-f1610 (XEN) HVM1: Returned 61440 bytes of ZoneHigh (XEN) HVM1: e820 map has 6 items: (XEN) HVM1: 0: 0000000000000000 - 000000000009fc00 = 1 RAM (XEN) HVM1: 1: 000000000009fc00 - 00000000000a0000 = 2 RESERVED (XEN) HVM1: 2: 00000000000f0000 - 0000000000100000 = 2 RESERVED (XEN) HVM1: 3: 0000000000100000 - 000000007f7ff000 = 1 RAM (XEN) HVM1: 4: 000000007f7ff000 - 000000007f800000 = 2 RESERVED (XEN) HVM1: 5: 00000000fc000000 - 0000000100000000 = 2 RESERVED (XEN) HVM1: enter handle_19: (XEN) HVM1: NULL (XEN) HVM1: Booting from DVD/CD... (XEN) HVM1: Device reports MEDIUM NOT PRESENT (XEN) HVM1: scsi_is_ready returned -1 (XEN) HVM1: Boot failed: Could not read from CDROM (code 0003) (XEN) HVM1: enter handle_18: (XEN) HVM1: NULL (XEN) HVM1: Booting from Hard Disk... (XEN) HVM1: Booting from 0000:7c00 (XEN) stdvga.c:151:d1 leaving stdvga (XEN) viridian.c:102:d1 GUEST_OS_ID: (XEN) viridian.c:104:d1 vendor: 1 (XEN) viridian.c:106:d1 os: 4 (XEN) viridian.c:108:d1 major: 6 (XEN) viridian.c:110:d1 minor: 1 (XEN) viridian.c:112:d1 sp: 1 (XEN) viridian.c:114:d1 build: 1db1 (XEN) viridian.c:119:d1 HYPERCALL: (XEN) viridian.c:121:d1 enabled: 1 (XEN) viridian.c:123:d1 pfn: 3ffff (XEN) viridian.c:128:d1 APIC_ASSIST[0]: (XEN) viridian.c:130:d1 enabled: 1 (XEN) viridian.c:132:d1 pfn: 3fffe (XEN) viridian.c:128:d1 APIC_ASSIST[1]: (XEN) viridian.c:130:d1 enabled: 1 (XEN) viridian.c:132:d1 pfn: 3fffd (XEN) viridian.c:128:d1 APIC_ASSIST[2]: (XEN) viridian.c:130:d1 enabled: 1 (XEN) viridian.c:132:d1 pfn: 3fffc (XEN) viridian.c:128:d1 APIC_ASSIST[3]: (XEN) viridian.c:130:d1 enabled: 1 (XEN) viridian.c:132:d1 pfn: 3fffb (XEN) viridian.c:128:d1 APIC_ASSIST[4]: (XEN) viridian.c:130:d1 enabled: 1 (XEN) viridian.c:132:d1 pfn: 3fffa (XEN) viridian.c:128:d1 APIC_ASSIST[5]: (XEN) viridian.c:130:d1 enabled: 1 (XEN) viridian.c:132:d1 pfn: 3fff9 (XEN) irq.c:270: Dom1 PCI link 0 changed 5 -> 0 (XEN) irq.c:270: Dom1 PCI link 1 changed 10 -> 0 (XEN) irq.c:270: Dom1 PCI link 2 changed 11 -> 0 (XEN) irq.c:270: Dom1 PCI link 3 changed 5 -> 0 (XEN) memory_map:remove: dom1 gfn=e0000 mfn=c0000 nr=10000 (XEN) memory_map:remove: dom1 gfn=f3040 mfn=d0000 nr=40 (XEN) ioport_map:remove: dom1 gport=c200 mport=e000 nr=100 (XEN) memory_map:add: dom1 gfn=e0000 mfn=c0000 nr=10000 (XEN) memory_map:add: dom1 gfn=f3040 mfn=d0000 nr=40 (XEN) ioport_map:add: dom1 gport=c200 mport=e000 nr=100 (XEN) memory_map:remove: dom1 gfn=f30b0 mfn=d0060 nr=4 (XEN) memory_map:add: dom1 gfn=f30b0 mfn=d0060 nr=4 (XEN) memory_map:remove: dom1 gfn=f30b5 mfn=d0411 nr=1 (XEN) memory_map:add: dom1 gfn=f30b5 mfn=d0411 nr=1 (XEN) grant_table.c:1250:d1 Expanding dom (1) grant table from (4) to (32) frames. (XEN) irq.c:375: Dom1 callback via changed to GSI 28 (XEN) memory_map:remove: dom1 gfn=e0000 mfn=c0000 nr=10000 (XEN) memory_map:remove: dom1 gfn=f3040 mfn=d0000 nr=40 (XEN) ioport_map:remove: dom1 gport=c200 mport=e000 nr=100 (XEN) memory_map:add: dom1 gfn=e0000 mfn=c0000 nr=10000 (XEN) memory_map:add: dom1 gfn=f3040 mfn=d0000 nr=40 (XEN) ioport_map:add: dom1 gport=c200 mport=e000 nr=100 (XEN) memory_map:remove: dom1 gfn=f30b0 mfn=d0060 nr=4 (XEN) memory_map:remove: dom1 gfn=f30b5 mfn=d0411 nr=1 (XEN) memory_map:add: dom1 gfn=f30b0 mfn=d0060 nr=4 (XEN) memory_map:add: dom1 gfn=f30b5 mfn=d0411 nr=1 (XEN) '*' pressed -> firing all diagnostic keyhandlers (XEN) [d: dump registers] (XEN) 'd' pressed -> dumping registers (XEN) (XEN) *** Dumping CPU0 host state: *** (XEN) ----[ Xen-4.3.0 x86_64 debug=n Not tainted ]---- (XEN) CPU: 0 (XEN) RIP: e008:[] mwait_idle+0x211/0x350 (XEN) RFLAGS: 0000000000000202 CONTEXT: hypervisor (XEN) rax: ffff82c4c0300620 rbx: ffff8304711fd610 rcx: 000000225b159088 (XEN) rdx: ffff82c4c02a8000 rsi: 000000225b159088 rdi: ffff8304711fd638 (XEN) rbp: 000000225b159088 rsp: ffff82c4c02afe70 r8: 000000224b466b1b (XEN) r9: 00000022f13be253 r10: 0000000000000006 r11: ffff82c4c0300710 (XEN) r12: 0000000000000002 r13: 0000000000000000 r14: ffff82c4c02ea940 (XEN) r15: ffff8304711fd660 cr0: 0000000080050033 cr4: 00000000001426f0 (XEN) cr3: 000000047f219000 cr2: 0000000000b20000 (XEN) ds: 0000 es: 0000 fs: 0000 gs: 0000 ss: 0000 cs: e008 (XEN) Xen stack trace from rsp=ffff82c4c02afe70: (XEN) ffff82c4c0300680 000000225b0d9af7 ffff82c4c0300710 00000000027f3c00 (XEN) 0000010c00000481 0000000000000000 0000000000000000 ffff82c4c02a8000 (XEN) 00000000ffffffff ffff82c4c02c7800 ffff82c4c02a8000 ffff82c4c02a8000 (XEN) ffff82c4c02a8000 00000000ffffffff ffff82c4c02ea940 0000000000000002 (XEN) ffffffffffffffff ffff82c4c015805e fffffa80027f3fa0 ffff8300730fe000 (XEN) ffff83006458a000 0000000000000001 fffffa80027f3f00 fffffa80027f3c00 (XEN) fffffa80027f3fa0 0000000000000000 0000000000000000 0000000000000002 (XEN) 0000000002eb4190 00000007cd65245f 0000000000000000 0000000009cf98c0 (XEN) fffffa80027d5a30 fffffa80027f3fc8 fffff88002e40180 0000000000000001 (XEN) 000000fc00000000 fffff880049889c2 0000000000000000 0000000000000246 (XEN) fffff88002e68b58 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 ffff8300730fe000 (XEN) 0000000000000000 0000000000000000 (XEN) Xen call trace: (XEN) [] mwait_idle+0x211/0x350 (XEN) [] idle_loop+0x1e/0x50 (XEN) (XEN) *** Dumping CPU1 host state: *** (XEN) ----[ Xen-4.3.0 x86_64 debug=n Not tainted ]---- (XEN) CPU: 1 (XEN) RIP: e008:[] mwait_idle+0x211/0x350 (XEN) RFLAGS: 0000000000000202 CONTEXT: hypervisor (XEN) rax: ffff8304711f6020 rbx: ffff8304711fde10 rcx: 0000002270fa11ef (XEN) rdx: ffff83047c308000 rsi: 0000002270fa11ef rdi: ffff8304711fde38 (XEN) rbp: 0000002270fa11ef rsp: ffff83047c30fe70 r8: 000000224b466b1b (XEN) r9: 000000ae4ac553f1 r10: 0000000000000001 r11: ffff82c4c0300710 (XEN) r12: 0000000000000010 r13: 0000000000000001 r14: ffff82c4c02ea940 (XEN) r15: ffff8304711fdec0 cr0: 0000000080050033 cr4: 00000000001426f0 (XEN) cr3: 000000047f218000 cr2: 0000000001000e90 (XEN) ds: 0000 es: 0000 fs: 0000 gs: 0000 ss: 0000 cs: e008 (XEN) Xen stack trace from rsp=ffff83047c30fe70: (XEN) ffff8304711f6080 0000002270acf975 ffff82c4c0300710 00000032027f4400 (XEN) 00001afc00000309 0000000000000000 0000000000000000 ffff83047c308000 (XEN) 00000000ffffffff ffff82c4c02c7800 ffff83047c308000 ffff83047c308000 (XEN) ffff83047c308000 00000000ffffffff ffff82c4c02ea940 0000000000000002 (XEN) ffffffffffffffff ffff82c4c015805e fffffa80027f47f0 ffff830064593000 (XEN) ffff830064589000 0000000000000001 fffffa80027f4700 fffffa80027f4400 (XEN) fffffa80027f47f0 0000000000000000 0000000000000000 000000000c3ee528 (XEN) 00000000061f7a8c 0000000788420628 0000000000000000 0000000009cf98c0 (XEN) fffffa80027d9c80 fffffa80027f4818 fffff88002eb7180 0000000000000001 (XEN) 000000fc00000000 fffff880049889c2 0000000000000000 0000000000000246 (XEN) fffff88002edfb58 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000001 ffff830064593000 (XEN) 0000003fb0ef5a00 0000000000000000 (XEN) Xen call trace: (XEN) [] mwait_idle+0x211/0x350 (XEN) [] idle_loop+0x1e/0x50 (XEN) (XEN) *** Dumping CPU2 host state: *** (XEN) ----[ Xen-4.3.0 x86_64 debug=n Not tainted ]---- (XEN) CPU: 2 (XEN) RIP: e008:[] mwait_idle+0x211/0x350 (XEN) RFLAGS: 0000000000000202 CONTEXT: hypervisor (XEN) rax: ffff8304711f0020 rbx: ffff8304711f26a0 rcx: 000000228586b48c (XEN) rdx: ffff83047c300000 rsi: 000000228586b48c rdi: ffff8304711f26c8 (XEN) rbp: 000000228586b48c rsp: ffff83047c307e70 r8: 000000224b466b1b (XEN) r9: 0000000000000530 r10: 0000000000000002 r11: ffff82c4c0300710 (XEN) r12: 0000000000000008 r13: 0000000000000002 r14: ffff82c4c02ea940 (XEN) r15: ffff8304711f2730 cr0: 0000000080050033 cr4: 00000000001426f0 (XEN) cr3: 000000047fcc8000 cr2: 0000000000e6340a (XEN) ds: 002b es: 002b fs: 0000 gs: 0000 ss: e010 cs: e008 (XEN) Xen stack trace from rsp=ffff83047c307e70: (XEN) ffff8304711f0080 00000022857f28e6 ffff82c4c0300710 0000002003d15998 (XEN) 00000371000003f0 0000000000000000 0000000000000000 ffff83047c300000 (XEN) 00000000ffffffff ffff82c4c02c7800 ffff83047c300000 ffff83047c300000 (XEN) ffff83047c300000 00000000ffffffff ffff82c4c02ea940 0000000000000002 (XEN) ffffffffffffffff ffff82c4c015805e ffff88002e543fd8 ffff8300643fe000 (XEN) ffff8300735e1000 0000000000000000 ffff88002e543fd8 ffff88002e543fd8 (XEN) ffff88002e543fd8 0000000000000002 ffff88002e543fd8 0000000000000246 (XEN) ffff88003e48eb60 0000000000000000 0000000000000000 0000000000000000 (XEN) ffffffff810013aa 0000000000000001 0000000000000000 0000000000000001 (XEN) 0000010000000000 ffffffff810013aa 000000000000e033 0000000000000246 (XEN) ffff88002e543ed8 000000000000e02b 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000002 ffff8300643fe000 (XEN) 0000003fb0eefa00 0000000000000000 (XEN) Xen call trace: (XEN) [] mwait_idle+0x211/0x350 (XEN) [] idle_loop+0x1e/0x50 (XEN) (XEN) *** Dumping CPU3 host state: *** (XEN) ----[ Xen-4.3.0 x86_64 debug=n Not tainted ]---- (XEN) CPU: 3 (XEN) RIP: e008:[] mwait_idle+0x211/0x350 (XEN) RFLAGS: 0000000000000202 CONTEXT: hypervisor (XEN) rax: ffff83047117b020 rbx: ffff8304711f2e90 rcx: 000000229a12fd3f (XEN) rdx: ffff830471170000 rsi: 000000229a12fd3f rdi: ffff8304711f2eb8 (XEN) rbp: 000000229a12fd3f rsp: ffff830471177e70 r8: 000000224b466b1b (XEN) r9: 0000000000000530 r10: 0000000000000002 r11: ffff82c4c0300710 (XEN) r12: 0000000000000008 r13: 0000000000000003 r14: ffff82c4c02ea940 (XEN) r15: ffff8304711f2f20 cr0: 0000000080050033 cr4: 00000000001426f0 (XEN) cr3: 000000047fcc8000 cr2: 0000000002ae0010 (XEN) ds: 0000 es: 0000 fs: 0000 gs: 0000 ss: e010 cs: e008 (XEN) Xen stack trace from rsp=ffff830471177e70: (XEN) ffff83047117b080 000000229a0e1b3b ffff82c4c0300710 0000002003d15998 (XEN) 00000372000003f5 0000000000000000 0000000000000000 ffff830471170000 (XEN) 00000000ffffffff ffff82c4c02c7800 ffff830471170000 ffff830471170000 (XEN) ffff830471170000 00000000ffffffff ffff82c4c02ea940 0000000000000002 (XEN) ffffffffffffffff ffff82c4c015805e ffffffff81801fd8 ffff830073303000 (XEN) ffff8300735e3000 0000000000000000 ffffffff81801fd8 ffffffff81801fd8 (XEN) ffffffff81801fd8 0000000000000000 ffffffff81801fd8 0000000000000246 (XEN) ffff88003e400000 0000000000000000 0000000000000000 0000000000000000 (XEN) ffffffff810013aa 0000000000000001 0000000000000000 0000000000000001 (XEN) 0000010000000000 ffffffff810013aa 000000000000e033 0000000000000246 (XEN) ffffffff81801e98 000000000000e02b 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000003 ffff830073303000 (XEN) 0000003fb0e7aa00 0000000000000000 (XEN) Xen call trace: (XEN) [] mwait_idle+0x211/0x350 (XEN) [] idle_loop+0x1e/0x50 (XEN) (XEN) *** Dumping CPU4 host state: *** (XEN) ----[ Xen-4.3.0 x86_64 debug=n Not tainted ]---- (XEN) CPU: 4 (XEN) RIP: e008:[] mwait_idle+0x211/0x350 (XEN) RFLAGS: 0000000000000202 CONTEXT: hypervisor (XEN) rax: ffff83047116d020 rbx: ffff83047116f690 rcx: 00000022ae9f74ce (XEN) rdx: ffff830471160000 rsi: 00000022ae9f74ce rdi: ffff83047116f6b8 (XEN) rbp: 00000022ae9f74ce rsp: ffff830471167e70 r8: 000000224b466b1b (XEN) r9: 000000ae4ac55414 r10: 0000000000000001 r11: ffff82c4c0300710 (XEN) r12: 0000000000000010 r13: 0000000000000004 r14: ffff82c4c02ea940 (XEN) r15: ffff83047116f740 cr0: 0000000080050033 cr4: 00000000001426f0 (XEN) cr3: 000000047f217000 cr2: 000007fefd46ae00 (XEN) ds: 0000 es: 0000 fs: 0000 gs: 0000 ss: 0000 cs: e008 (XEN) Xen stack trace from rsp=ffff830471167e70: (XEN) ffff83047116d080 00000022ae0a73eb ffff82c4c0300710 00000032027f6000 (XEN) 00001115000004d9 0000000000000000 0000000000000000 ffff830471160000 (XEN) 00000000ffffffff ffff82c4c02c7800 ffff830471160000 ffff830471160000 (XEN) ffff830471160000 00000000ffffffff ffff82c4c02ea940 0000000000000002 (XEN) ffffffffffffffff ffff82c4c015805e fffffa80027efad0 ffff830073302000 (XEN) ffff830064588000 0000000000000001 fffffa80027efa00 fffffa80027f6000 (XEN) fffffa80027efad0 0000000000000000 0000000000000000 000000000c3edbc8 (XEN) 000000000c3edeac 000000000758ec00 0000000000000000 00000008b00b81d9 (XEN) fffffa80027f3470 fffffa80027efaf8 fffff88002f2e180 0000000000000001 (XEN) 000000fc00000000 fffff880049889c2 0000000000000000 0000000000000246 (XEN) fffff88002f56b58 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000004 ffff830073302000 (XEN) 0000003fb0e6ca00 0000000000000000 (XEN) Xen call trace: (XEN) [] mwait_idle+0x211/0x350 (XEN) [] idle_loop+0x1e/0x50 (XEN) (XEN) *** Dumping CPU5 host state: *** (XEN) ----[ Xen-4.3.0 x86_64 debug=n Not tainted ]---- (XEN) CPU: 5 (XEN) RIP: e008:[] mwait_idle+0x211/0x350 (XEN) RFLAGS: 0000000000000202 CONTEXT: hypervisor (XEN) rax: ffff830471168020 rbx: ffff83047116fe80 rcx: 00000022c32be909 (XEN) rdx: ffff830471158000 rsi: 00000022c32be909 rdi: ffff83047116fea8 (XEN) rbp: 00000022c32be909 rsp: ffff83047115fe70 r8: 000000224b466b1b (XEN) r9: 0000000000000428 r10: 0000000000000002 r11: ffff82c4c0300710 (XEN) r12: 0000000000000004 r13: 0000000000000005 r14: ffff82c4c02ea940 (XEN) r15: ffff83047116fef0 cr0: 000000008005003b cr4: 00000000001426f0 (XEN) cr3: 000000007325e000 cr2: 000007fef9cb41dc (XEN) ds: 0000 es: 0000 fs: 0000 gs: 0000 ss: 0000 cs: e008 (XEN) Xen stack trace from rsp=ffff83047115fe70: (XEN) ffffffffffffffff 00000022c325cf90 ffff82c4c0300710 0000001075337890 (XEN) 000001b300000419 0000000000000000 0000000000000000 ffff82c4c0126ef0 (XEN) ffffffffffffffff 00000000ffffffff ffff82c4c02c7800 ffff830471158000 (XEN) ffff830471158000 00000000ffffffff ffff82c4c02ea940 0000000000000003 (XEN) ffffffffffffffff ffff82c4c015805e 0000000000000002 ffff8300730fd000 (XEN) ffff8300643fb000 0000000000007ee8 0000000000003ebf 0000000000000002 (XEN) 0000000000000002 0000000000000001 0000000000f6c6d0 fffff80002ae4760 (XEN) 0000000000000008 ffffffffffffffdf 0000000000000000 0000000000000001 (XEN) 0000000000010008 0000000000f6c000 fffff88004bcf788 fffff88002fa5180 (XEN) 000000fa00000000 fffff80002ada9ee 0000000000000000 0000000000000202 (XEN) fffff88004bcf680 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000005 ffff8300730fd000 (XEN) 0000003fb0e67a00 0000000000000000 (XEN) Xen call trace: (XEN) [] mwait_idle+0x211/0x350 (XEN) [] tasklet_softirq_action+0x40/0x70 (XEN) [] idle_loop+0x1e/0x50 (XEN) (XEN) *** Dumping CPU6 guest state (d1:v0): *** (XEN) ----[ Xen-4.3.0 x86_64 debug=n Not tainted ]---- (XEN) CPU: 6 (XEN) RIP: 0010:[] (XEN) RFLAGS: 0000000000000202 CONTEXT: hvm guest (XEN) rax: 0000000000000001 rbx: 0000000001973d83 rcx: 0000000000010008 (XEN) rdx: 0000000001973800 rsi: 0000000000000002 rdi: fffff80002c50e80 (XEN) rbp: fffff880000008d4 rsp: fffff8000408a6f0 r8: 0000000000000000 (XEN) r9: 0000000000000001 r10: 0000000000000000 r11: fffff88002fdc180 (XEN) r12: fffff80002c8afc0 r13: 0000000000000014 r14: 0000000000003ebe (XEN) r15: 00000000000047f7 cr0: 0000000080050031 cr4: 00000000000406f8 (XEN) cr3: 0000000000187000 cr2: 0000000077003000 (XEN) ds: 002b es: 002b fs: 0053 gs: 002b ss: 0018 cs: 0010 (XEN) (XEN) *** Dumping CPU7 host state: *** (XEN) ----[ Xen-4.3.0 x86_64 debug=n Not tainted ]---- (XEN) CPU: 7 (XEN) RIP: e008:[] mwait_idle+0x211/0x350 (XEN) RFLAGS: 0000000000000202 CONTEXT: hypervisor (XEN) rax: ffff830471145020 rbx: ffff830471154e80 rcx: 00000022e0c7d443 (XEN) rdx: ffff830471138000 rsi: 00000022e0c7d443 rdi: ffff830471154ea8 (XEN) rbp: 00000022e0c7d443 rsp: ffff83047113fe70 r8: 000000224b466b1b (XEN) r9: 000000ae4ac5541e r10: 0000000000000002 r11: ffff82c4c0300710 (XEN) r12: 0000000000000002 r13: 0000000000000007 r14: ffff82c4c02ea940 (XEN) r15: ffff830471154ed0 cr0: 0000000080050033 cr4: 00000000001426f0 (XEN) cr3: 000000047f215000 cr2: 0000000000840008 (XEN) ds: 0000 es: 0000 fs: 0000 gs: 0000 ss: 0000 cs: e008 (XEN) Xen stack trace from rsp=ffff83047113fe70: (XEN) ffff830471145080 00000022dad83984 ffff82c4c0300710 000000000254b200 (XEN) 00000bfd00002556 0000000000000000 0000000000000000 ffff830471138000 (XEN) 00000000ffffffff ffff82c4c02c7800 ffff830471138000 ffff830471138000 (XEN) ffff830471138000 00000000ffffffff ffff82c4c02ea940 0000000000000002 (XEN) ffffffffffffffff ffff82c4c015805e fffffa800257fa10 ffff8300643fd000 (XEN) ffff8300643fa000 0000000000000001 fffffa800257f900 fffffa800254b200 (XEN) fffffa800257fa10 0000000000000000 0000000000000000 0000000012ec84c4 (XEN) 0000000012ef2db8 000000000b5c4ea1 0000000000000000 0000000930406f98 (XEN) fffffa80027efb50 fffffa800257fa38 fffff88002fdc180 0000000000000001 (XEN) 000000fc00000000 fffff880049889c2 0000000000000000 0000000000000246 (XEN) fffff88003046b58 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000007 ffff8300643fd000 (XEN) 0000003fb0e44a00 0000000000000000 (XEN) Xen call trace: (XEN) [] mwait_idle+0x211/0x350 (XEN) [] idle_loop+0x1e/0x50 (XEN) (XEN) [0: dump Dom0 registers] (XEN) '0' pressed -> dumping Dom0's registers (XEN) *** Dumping Dom0 vcpu#0 state: *** (XEN) RIP: e033:[] (XEN) RFLAGS: 0000000000000282 EM: 0 CONTEXT: pv guest (XEN) rax: 0000000000000000 rbx: ffff88002bf4eec0 rcx: ffffffff8100144a (XEN) rdx: 00007f6345c6edac rsi: 00007f63458f7004 rdi: 0000000000000006 (XEN) rbp: ffff880004061050 rsp: ffff880003d15e50 r8: 00000000000d1040 (XEN) r9: 00000000f0000000 r10: 0000000000000006 r11: 0000000000000282 (XEN) r12: 00007fff4b9ab6e0 r13: 00007fff4b9ab6e0 r14: 0000000000000001 (XEN) r15: 00007fff4b9ab6b0 cr0: 0000000000000000 cr4: 0000000000042660 (XEN) cr3: 000000047fcc8000 cr2: 00007f632a43a810 (XEN) ds: 0000 es: 0000 fs: 0000 gs: 0000 ss: e02b cs: e033 (XEN) Guest stack trace from rsp=ffff880003d15e50: (XEN) 0000000000000246 0000000000000000 ffffffffa03b6927 0000000000000019 (XEN) ffffffff00000000 ffff880003d15c70 ffff88003d929da0 ffffffff81491517 (XEN) 0000000000000022 0000000000000006 00007f63458f7004 00007f6345c6edac (XEN) 0000000000000006 00000000000d1040 ffff88002bf4eec0 ffff880004061050 (XEN) 00007fff4b9ab6e0 00007fff4b9ab6e0 ffffffff81184e64 000000007fffffff (XEN) 00007f6345cf3297 ffffffff811b80e2 0000000000000000 ffff88002be83ac0 (XEN) 00007fff4b9abab0 ffffffff81173074 ffff88002be83ac0 ffff88002bf4eec0 (XEN) 000000000000000b 0000000000305000 ffffffff811850c0 00007fff4b9aba90 (XEN) 00000001464f5998 00007f6346b49110 00007f63458f7004 0000000000000800 (XEN) 00007fff4b9ab680 0000000000000001 ffffffff81498fb9 0000000000000246 (XEN) 0000000000800000 00000000f0000000 0000000000000000 0000000000000010 (XEN) 00007fff4b9fe7c2 00007fff4b9ab6e0 0000000000305000 000000000000000b (XEN) 0000000000000010 00007f63407fb567 000000000000e033 0000000000000246 (XEN) 00007fff4b9ab668 000000000000e02b (XEN) *** Dumping Dom0 vcpu#1 state: *** (XEN) RIP: e033:[] (XEN) RFLAGS: 0000000000000246 EM: 0 CONTEXT: pv guest (XEN) rax: 0000000000000000 rbx: ffff88002e53ffd8 rcx: ffffffff810013aa (XEN) rdx: 0000000000000001 rsi: 0000000000000000 rdi: 0000000000000001 (XEN) rbp: 0000000000000001 rsp: ffff88002e53fed8 r8: 0000000000000000 (XEN) r9: 0000000000000000 r10: ffff88003e440000 r11: 0000000000000246 (XEN) r12: ffff88002e53ffd8 r13: ffff88002e53ffd8 r14: ffff88002e53ffd8 (XEN) r15: 0000000000000000 cr0: 0000000080050033 cr4: 0000000000042660 (XEN) cr3: 000000047fcc8000 cr2: 00007fffa2336f58 (XEN) ds: 002b es: 002b fs: 0000 gs: 0000 ss: e02b cs: e033 (XEN) Guest stack trace from rsp=ffff88002e53fed8: (XEN) 0000000000000000 0100000000000000 ffffffff8100992c ffffffff8101a6b4 (XEN) ffff88002e53ffd8 ffffffff818a0fc0 ffffffff810a457e ffff88002e53ffd8 (XEN) ffff88002e53ffd8 4e6bbde87666fa33 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 ffffffffffffffff (XEN) 0000000000000000 0000000000000010 0000000000000202 ffff88002e53ff58 (XEN) 0000000000000018 (XEN) *** Dumping Dom0 vcpu#2 state: *** (XEN) RIP: e033:[] (XEN) RFLAGS: 0000000000000246 EM: 0 CONTEXT: pv guest (XEN) rax: 0000000000000000 rbx: ffff88002e543fd8 rcx: ffffffff810013aa (XEN) rdx: 0000000000000001 rsi: 0000000000000000 rdi: 0000000000000001 (XEN) rbp: 0000000000000002 rsp: ffff88002e543ed8 r8: 0000000000000000 (XEN) r9: 0000000000000000 r10: ffff88003e480000 r11: 0000000000000246 (XEN) r12: ffff88002e543fd8 r13: ffff88002e543fd8 r14: ffff88002e543fd8 (XEN) r15: 0000000000000000 cr0: 0000000080050033 cr4: 0000000000042660 (XEN) cr3: 000000047fcc8000 cr2: 00007f8545411f14 (XEN) ds: 002b es: 002b fs: 0000 gs: 0000 ss: e02b cs: e033 (XEN) Guest stack trace from rsp=ffff88002e543ed8: (XEN) 0000000000000000 0100000000000000 ffffffff8100992c ffffffff8101a6b4 (XEN) ffff88002e543fd8 ffffffff818a0fc0 ffffffff810a457e ffff88002e543fd8 (XEN) ffff88002e543fd8 cd16d26e7c353277 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 ffffffffffffffff (XEN) 0000000000000000 0000000000000010 0000000000000202 ffff88002e543f58 (XEN) 0000000000000018 (XEN) *** Dumping Dom0 vcpu#3 state: *** (XEN) RIP: e033:[] (XEN) RFLAGS: 0000000000000246 EM: 0 CONTEXT: pv guest (XEN) rax: 0000000000000000 rbx: ffff88002e545fd8 rcx: ffffffff810013aa (XEN) rdx: 0000000000000001 rsi: 0000000000000000 rdi: 0000000000000001 (XEN) rbp: 0000000000000003 rsp: ffff88002e545ed8 r8: 0000000000000000 (XEN) r9: 0000000000000000 r10: ffff88003e4c0000 r11: 0000000000000246 (XEN) r12: ffff88002e545fd8 r13: ffff88002e545fd8 r14: ffff88002e545fd8 (XEN) r15: 0000000000000000 cr0: 0000000080050033 cr4: 0000000000042660 (XEN) cr3: 000000047fcc8000 cr2: 00007f63240010b8 (XEN) ds: 002b es: 002b fs: 0000 gs: 0000 ss: e02b cs: e033 (XEN) Guest stack trace from rsp=ffff88002e545ed8: (XEN) 0000000000000000 0100000000000000 ffffffff8100992c ffffffff8101a6b4 (XEN) ffff88002e545fd8 ffffffff818a0fc0 ffffffff810a457e ffff88002e545fd8 (XEN) ffff88002e545fd8 d83d337713cdb13a 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 ffffffffffffffff (XEN) 0000000000000000 0000000000000010 0000000000000202 ffff88002e545f58 (XEN) 0000000000000018 (XEN) *** Dumping Dom0 vcpu#4 state: *** (XEN) RIP: e033:[] (XEN) RFLAGS: 0000000000000246 EM: 0 CONTEXT: pv guest (XEN) rax: 0000000000000000 rbx: ffff88002e547fd8 rcx: ffffffff810013aa (XEN) rdx: 0000000000000001 rsi: 0000000000000000 rdi: 0000000000000001 (XEN) rbp: 0000000000000004 rsp: ffff88002e547ed8 r8: 0000000000000000 (XEN) r9: 0000000000000000 r10: ffff88003e500000 r11: 0000000000000246 (XEN) r12: ffff88002e547fd8 r13: ffff88002e547fd8 r14: ffff88002e547fd8 (XEN) r15: 0000000000000000 cr0: 0000000080050033 cr4: 0000000000042660 (XEN) cr3: 0000000447402000 cr2: 00007ff745ec0fb0 (XEN) ds: 002b es: 002b fs: 0000 gs: 0000 ss: e02b cs: e033 (XEN) Guest stack trace from rsp=ffff88002e547ed8: (XEN) 0000000000000000 0100000000000000 ffffffff8100992c ffffffff8101a6b4 (XEN) ffff88002e547fd8 ffffffff818a0fc0 ffffffff810a457e ffff88002e547fd8 (XEN) ffff88002e547fd8 cc122c574940337f 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 ffffffffffffffff (XEN) 0000000000000000 0000000000000010 0000000000000202 ffff88002e547f58 (XEN) 0000000000000018 (XEN) *** Dumping Dom0 vcpu#5 state: *** (XEN) RIP: e033:[] (XEN) RFLAGS: 0000000000000246 EM: 0 CONTEXT: pv guest (XEN) rax: 0000000000000000 rbx: ffff88002e54bfd8 rcx: ffffffff810013aa (XEN) rdx: 0000000000000001 rsi: 0000000000000000 rdi: 0000000000000001 (XEN) rbp: 0000000000000005 rsp: ffff88002e54bed8 r8: 0000000000000000 (XEN) r9: 0000000000000000 r10: 0000000000000000 r11: 0000000000000246 (XEN) r12: ffff88002e54bfd8 r13: ffff88002e54bfd8 r14: ffff88002e54bfd8 (XEN) r15: 0000000000000000 cr0: 0000000080050033 cr4: 0000000000042660 (XEN) cr3: 000000047f404000 cr2: 00007f8546cb159c (XEN) ds: 002b es: 002b fs: 0000 gs: 0000 ss: e02b cs: e033 (XEN) Guest stack trace from rsp=ffff88002e54bed8: (XEN) ffff88002e695c28 0100000000000000 ffffffff8100992c ffffffff8101a6b4 (XEN) ffff88002e54bfd8 ffffffff818a0fc0 ffffffff810a457e ffff88002e54bfd8 (XEN) ffff88002e54bfd8 0d387c79ccf6749f 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 ffffffffffffffff (XEN) 0000000000000000 0000000000000010 0000000000000202 ffff88002e54bf58 (XEN) 0000000000000018 (XEN) *** Dumping Dom0 vcpu#6 state: *** (XEN) RIP: e033:[] (XEN) RFLAGS: 0000000000000246 EM: 0 CONTEXT: pv guest (XEN) rax: 0000000000000000 rbx: ffff88002e54ffd8 rcx: ffffffff810013aa (XEN) rdx: 0000000000000001 rsi: 0000000000000000 rdi: 0000000000000001 (XEN) rbp: 0000000000000006 rsp: ffff88002e54fed8 r8: 0000000000000000 (XEN) r9: 0000000000000000 r10: 0000000000000000 r11: 0000000000000246 (XEN) r12: ffff88002e54ffd8 r13: ffff88002e54ffd8 r14: ffff88002e54ffd8 (XEN) r15: 0000000000000000 cr0: 0000000080050033 cr4: 0000000000042660 (XEN) cr3: 000000047fcc8000 cr2: 0000000000b812a0 (XEN) ds: 002b es: 002b fs: 0000 gs: 0000 ss: e02b cs: e033 (XEN) Guest stack trace from rsp=ffff88002e54fed8: (XEN) ffff88002e6cdc28 0100000000000000 ffffffff8100992c ffffffff8101a6b4 (XEN) ffff88002e54ffd8 ffffffff818a0fc0 ffffffff810a457e ffff88002e54ffd8 (XEN) ffff88002e54ffd8 fa60e9751235aae9 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 ffffffffffffffff (XEN) 0000000000000000 0000000000000010 0000000000000202 ffff88002e54ff58 (XEN) 0000000000000018 (XEN) *** Dumping Dom0 vcpu#7 state: *** (XEN) RIP: e033:[] (XEN) RFLAGS: 0000000000000246 EM: 0 CONTEXT: pv guest (XEN) rax: 0000000000000000 rbx: ffff88002e551fd8 rcx: ffffffff810013aa (XEN) rdx: 0000000000000001 rsi: 0000000000000000 rdi: 0000000000000001 (XEN) rbp: 0000000000000007 rsp: ffff88002e551ed8 r8: 0000000000000000 (XEN) r9: 0000000000000000 r10: ffff88003e5c0000 r11: 0000000000000246 (XEN) r12: ffff88002e551fd8 r13: ffff88002e551fd8 r14: ffff88002e551fd8 (XEN) r15: 0000000000000000 cr0: 0000000080050033 cr4: 0000000000042660 (XEN) cr3: 000000046d80c000 cr2: 00007f8546cdc660 (XEN) ds: 002b es: 002b fs: 0000 gs: 0000 ss: e02b cs: e033 (XEN) Guest stack trace from rsp=ffff88002e551ed8: (XEN) 0000000000000000 0100000000000000 ffffffff8100992c ffffffff8101a6b4 (XEN) ffff88002e551fd8 ffffffff818a0fc0 ffffffff810a457e ffff88002e551fd8 (XEN) ffff88002e551fd8 f8390ec8935d120b 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 ffffffffffffffff (XEN) 0000000000000000 0000000000000010 0000000000000202 ffff88002e551f58 (XEN) 0000000000000018 (XEN) [H: dump heap info] (XEN) 'H' pressed -> dumping heap info (now-0x22:F55B3E8B) (XEN) heap[node=0][zone=0] -> 0 pages (XEN) heap[node=0][zone=1] -> 0 pages (XEN) heap[node=0][zone=2] -> 0 pages (XEN) heap[node=0][zone=3] -> 0 pages (XEN) heap[node=0][zone=4] -> 0 pages (XEN) heap[node=0][zone=5] -> 0 pages (XEN) heap[node=0][zone=6] -> 0 pages (XEN) heap[node=0][zone=7] -> 0 pages (XEN) heap[node=0][zone=8] -> 0 pages (XEN) heap[node=0][zone=9] -> 0 pages (XEN) heap[node=0][zone=10] -> 0 pages (XEN) heap[node=0][zone=11] -> 0 pages (XEN) heap[node=0][zone=12] -> 0 pages (XEN) heap[node=0][zone=13] -> 0 pages (XEN) heap[node=0][zone=14] -> 16128 pages (XEN) heap[node=0][zone=15] -> 32768 pages (XEN) heap[node=0][zone=16] -> 65536 pages (XEN) heap[node=0][zone=17] -> 131072 pages (XEN) heap[node=0][zone=18] -> 209786 pages (XEN) heap[node=0][zone=19] -> 0 pages (XEN) heap[node=0][zone=20] -> 1048576 pages (XEN) heap[node=0][zone=21] -> 1790796 pages (XEN) heap[node=0][zone=22] -> 59 pages (XEN) heap[node=0][zone=23] -> 0 pages (XEN) heap[node=0][zone=24] -> 0 pages (XEN) heap[node=0][zone=25] -> 0 pages (XEN) heap[node=0][zone=26] -> 0 pages (XEN) heap[node=0][zone=27] -> 0 pages (XEN) heap[node=0][zone=28] -> 0 pages (XEN) heap[node=0][zone=29] -> 0 pages (XEN) heap[node=0][zone=30] -> 0 pages (XEN) heap[node=0][zone=31] -> 0 pages (XEN) heap[node=0][zone=32] -> 0 pages (XEN) heap[node=0][zone=33] -> 0 pages (XEN) heap[node=0][zone=34] -> 0 pages (XEN) heap[node=0][zone=35] -> 0 pages (XEN) heap[node=0][zone=36] -> 0 pages (XEN) heap[node=0][zone=37] -> 0 pages (XEN) heap[node=0][zone=38] -> 0 pages (XEN) heap[node=0][zone=39] -> 0 pages (XEN) [I: dump HVM irq info] (XEN) 'I' pressed -> dumping HVM irq info (XEN) Domain 1: (XEN) PCI 0x00000000100000000000000000000000 ISA 0x00008001 ROUTE 0 0 0 0 (XEN) GSI [0 - 7] 00 00 01 00 00 00 00 00 (XEN) GSI [8 - f] 00 00 00 00 00 00 00 01 (XEN) GSI [10 - 17] 00 00 00 00 00 00 00 00 (XEN) GSI [18 - 1f] 00 00 00 00 00 00 00 00 (XEN) GSI [20 - 27] 00 00 00 00 00 00 00 00 (XEN) GSI [28 - 2f] 00 00 00 00 01 00 00 00 (XEN) Link 00 00 00 01 (XEN) Callback via 1:0x1c, not asserted (XEN) [M: dump MSI state] (XEN) MSI information: (XEN) IOMMU 24 vec=28 lowest edge assert log lowest dest=00000001 mask=1/0/? (XEN) MSI 25 vec=b8 lowest edge assert log lowest dest=00000001 mask=0/1/? (XEN) MSI 26 vec=c0 lowest edge assert log lowest dest=00000001 mask=0/1/? (XEN) MSI 27 vec=d0 lowest edge assert log lowest dest=00000001 mask=0/1/? (XEN) MSI 28 vec=21 lowest edge assert log lowest dest=00000001 mask=0/1/? (XEN) MSI 29 vec=29 lowest edge assert log lowest dest=00000001 mask=0/1/? (XEN) MSI 30 vec=39 lowest edge assert log lowest dest=00000001 mask=0/1/? (XEN) MSI 31 vec=41 lowest edge assert log lowest dest=00000001 mask=0/1/? (XEN) MSI 32 vec=49 lowest edge assert log lowest dest=00000001 mask=0/1/? (XEN) MSI 33 vec=51 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI 34 vec=59 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI 35 vec=61 lowest edge assert log lowest dest=00000001 mask=1/0/0 (XEN) MSI 36 vec=69 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 37 vec=71 lowest edge assert log lowest dest=00000001 mask=1/0/0 (XEN) MSI-X 38 vec=79 lowest edge assert log lowest dest=00000008 mask=1/0/0 (XEN) MSI-X 39 vec=81 lowest edge assert log lowest dest=00000008 mask=1/0/0 (XEN) MSI-X 40 vec=89 lowest edge assert log lowest dest=00000008 mask=1/0/0 (XEN) MSI-X 41 vec=91 lowest edge assert log lowest dest=00000008 mask=1/0/0 (XEN) MSI 42 vec=99 lowest edge assert log lowest dest=00000001 mask=0/1/? (XEN) MSI-X 43 vec=a1 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 44 vec=a9 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 45 vec=b1 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 46 vec=b9 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 47 vec=c1 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI 48 vec=c9 lowest edge assert log lowest dest=00000008 mask=0/1/? (XEN) MSI-X 49 vec=d1 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 50 vec=d9 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 51 vec=22 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 52 vec=2a lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 53 vec=32 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 54 vec=3a lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 55 vec=42 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 56 vec=4a lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 57 vec=52 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 58 vec=5a lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI 59 vec=6a lowest edge assert log lowest dest=00000080 mask=0/1/? (XEN) [Q: dump PCI devices] (XEN) ==== PCI devices ==== (XEN) ==== segment 0000 ==== (XEN) 0000:0e:00.0 - dom 0 - MSIs < 54 55 56 57 58 > (XEN) 0000:0d:00.0 - dom 0 - MSIs < 49 50 51 52 53 > (XEN) 0000:0c:00.0 - dom 0 - MSIs < 43 44 45 46 47 > (XEN) 0000:0b:00.0 - dom 0 - MSIs < 37 38 39 40 41 > (XEN) 0000:0a:00.0 - dom 0 - MSIs < > (XEN) 0000:09:00.0 - dom 0 - MSIs < > (XEN) 0000:08:00.0 - dom 0 - MSIs < > (XEN) 0000:07:00.0 - dom 0 - MSIs < > (XEN) 0000:05:00.1 - dom 1 - MSIs < > (XEN) 0000:05:00.0 - dom 1 - MSIs < 59 > (XEN) 0000:03:00.0 - dom 0 - MSIs < > (XEN) 0000:02:10.0 - dom 0 - MSIs < 36 > (XEN) 0000:02:09.0 - dom 0 - MSIs < 35 > (XEN) 0000:02:08.0 - dom 0 - MSIs < 34 > (XEN) 0000:01:00.0 - dom 0 - MSIs < 33 > (XEN) 0000:00:1f.3 - dom 0 - MSIs < > (XEN) 0000:00:1f.2 - dom 0 - MSIs < 48 > (XEN) 0000:00:1f.0 - dom 0 - MSIs < > (XEN) 0000:00:1d.0 - dom 1 - MSIs < > (XEN) 0000:00:1c.7 - dom 0 - MSIs < 32 > (XEN) 0000:00:1c.6 - dom 0 - MSIs < 31 > (XEN) 0000:00:1c.5 - dom 0 - MSIs < 30 > (XEN) 0000:00:1c.4 - dom 0 - MSIs < 29 > (XEN) 0000:00:1c.3 - dom 0 - MSIs < 28 > (XEN) 0000:00:1c.2 - dom 0 - MSIs < 27 > (XEN) 0000:00:1c.0 - dom 0 - MSIs < 26 > (XEN) 0000:00:1a.0 - dom 0 - MSIs < > (XEN) 0000:00:16.1 - dom 0 - MSIs < > (XEN) 0000:00:16.0 - dom 0 - MSIs < > (XEN) 0000:00:14.0 - dom 0 - MSIs < 42 > (XEN) 0000:00:01.0 - dom 0 - MSIs < 25 > (XEN) 0000:00:00.0 - dom 0 - MSIs < > (XEN) [V: dump iommu info] (XEN) (XEN) iommu 0: nr_pt_levels = 4. (XEN) Queued Invalidation: supported and enabled. (XEN) Interrupt Remapping: supported and enabled. (XEN) Interrupt remapping table (nr_entry=0x10000. Only dump P=1 entries here): (XEN) SVT SQ SID DST V AVL DLM TM RH DM FPD P (XEN) 0000: 1 0 f0f8 77fe0000 00 0 7 0 0 0 0 1 (XEN) 0001: 1 0 f0f8 00000002 62 0 1 0 1 1 0 1 (XEN) 0002: 1 0 f0f8 00000001 f0 0 1 0 1 1 0 1 (XEN) 0003: 1 0 f0f8 000000ff 38 0 1 0 1 1 0 1 (XEN) 0004: 1 0 f0f8 00000001 f1 0 1 0 1 1 0 1 (XEN) 0005: 1 0 f0f8 00000001 40 0 1 0 1 1 0 1 (XEN) 0006: 1 0 f0f8 00000001 48 0 1 0 1 1 0 1 (XEN) 0007: 1 0 f0f8 00000001 50 0 1 0 1 1 0 1 (XEN) 0008: 1 0 f0f8 00000001 58 0 1 0 1 1 0 1 (XEN) 0009: 1 0 f0f8 00000001 60 0 1 1 1 1 0 1 (XEN) 000a: 1 0 f0f8 00000001 68 0 1 0 1 1 0 1 (XEN) 000b: 1 0 f0f8 00000001 70 0 1 0 1 1 0 1 (XEN) 000c: 1 0 f0f8 00000001 78 0 1 0 1 1 0 1 (XEN) 000d: 1 0 f0f8 000000ff 88 0 1 0 1 1 0 1 (XEN) 000e: 1 0 f0f8 00000001 90 0 1 0 1 1 0 1 (XEN) 000f: 1 0 f0f8 00000001 98 0 1 0 1 1 0 1 (XEN) 0010: 1 0 f0f8 00000008 a0 0 1 1 1 1 0 1 (XEN) 0011: 1 0 f0f8 00000001 a8 0 1 1 1 1 0 1 (XEN) 0012: 1 0 f0f8 00000020 b0 0 1 1 1 1 0 1 (XEN) 0013: 1 0 0008 00000001 b8 0 1 0 1 1 0 1 (XEN) 0014: 1 0 00e0 00000001 c0 0 1 0 1 1 0 1 (XEN) 0015: 1 0 f0f8 000000ff c8 0 1 1 1 1 0 1 (XEN) 0016: 1 0 00e2 00000001 d0 0 1 0 1 1 0 1 (XEN) 0017: 1 0 f0f8 00000001 d8 0 1 1 1 1 0 1 (XEN) 0018: 1 0 00e3 00000001 21 0 1 0 1 1 0 1 (XEN) 0019: 1 0 00e4 00000001 29 0 1 0 1 1 0 1 (XEN) 001a: 1 0 f0f8 00000080 31 0 1 1 1 1 0 1 (XEN) 001b: 1 0 00e5 00000001 39 0 1 0 1 1 0 1 (XEN) 001c: 1 0 00e6 00000001 41 0 1 0 1 1 0 1 (XEN) 001d: 1 0 00e7 00000001 49 0 1 0 1 1 0 1 (XEN) 001e: 1 0 0100 000000ff 51 0 1 0 1 1 0 1 (XEN) 001f: 1 0 0240 000000ff 59 0 1 0 1 1 0 1 (XEN) 0020: 1 0 0248 00000001 61 0 1 0 1 1 0 1 (XEN) 0021: 1 0 0280 000000ff 69 0 1 0 1 1 0 1 (XEN) 0022: 1 0 0b00 00000001 71 0 1 0 1 1 0 1 (XEN) 0023: 1 0 0b00 00000008 79 0 1 0 1 1 0 1 (XEN) 0024: 1 0 0b00 00000008 81 0 1 0 1 1 0 1 (XEN) 0025: 1 0 0b00 00000008 89 0 1 0 1 1 0 1 (XEN) 0026: 1 0 0b00 00000008 91 0 1 0 1 1 0 1 (XEN) 0027: 1 0 00a0 00000001 99 0 1 0 1 1 0 1 (XEN) 0028: 1 0 0c00 000000ff a1 0 1 0 1 1 0 1 (XEN) 0029: 1 0 0c00 000000ff a9 0 1 0 1 1 0 1 (XEN) 002a: 1 0 0c00 000000ff b1 0 1 0 1 1 0 1 (XEN) 002b: 1 0 0c00 000000ff b9 0 1 0 1 1 0 1 (XEN) 002c: 1 0 0c00 000000ff c1 0 1 0 1 1 0 1 (XEN) 002d: 1 0 00fa 00000008 c9 0 1 0 1 1 0 1 (XEN) 002e: 1 0 0d00 000000ff d1 0 1 0 1 1 0 1 (XEN) 002f: 1 0 0d00 000000ff d9 0 1 0 1 1 0 1 (XEN) 0030: 1 0 0d00 000000ff 22 0 1 0 1 1 0 1 (XEN) 0031: 1 0 0d00 000000ff 2a 0 1 0 1 1 0 1 (XEN) 0032: 1 0 0d00 000000ff 32 0 1 0 1 1 0 1 (XEN) 0033: 1 0 0e00 000000ff 3a 0 1 0 1 1 0 1 (XEN) 0034: 1 0 0e00 000000ff 42 0 1 0 1 1 0 1 (XEN) 0035: 1 0 0e00 000000ff 4a 0 1 0 1 1 0 1 (XEN) 0036: 1 0 0e00 000000ff 52 0 1 0 1 1 0 1 (XEN) 0037: 1 0 0e00 000000ff 5a 0 1 0 1 1 0 1 (XEN) 0038: 1 0 0500 00000080 6a 0 1 0 1 1 0 1 (XEN) (XEN) Redirection table of IOAPIC 0: (XEN) #entry IDX FMT MASK TRIG IRR POL STAT DELI VECTOR (XEN) 01: 0001 1 0 0 0 0 0 0 62 (XEN) 02: 0002 1 0 0 0 0 0 0 f0 (XEN) 03: 0003 1 1 0 0 0 0 0 38 (XEN) 04: 0004 1 0 0 0 0 0 0 f1 (XEN) 05: 0005 1 0 0 0 0 0 0 40 (XEN) 06: 0006 1 0 0 0 0 0 0 48 (XEN) 07: 0007 1 0 0 0 0 0 0 50 (XEN) 08: 0008 1 0 0 0 0 0 0 58 (XEN) 09: 0009 1 0 1 0 0 0 0 60 (XEN) 0a: 000a 1 0 0 0 0 0 0 68 (XEN) 0b: 000b 1 0 0 0 0 0 0 70 (XEN) 0c: 000c 1 0 0 0 0 0 0 78 (XEN) 0d: 000d 1 1 0 0 0 0 0 88 (XEN) 0e: 000e 1 0 0 0 0 0 0 90 (XEN) 0f: 000f 1 0 0 0 0 0 0 98 (XEN) 10: 0010 1 0 1 0 1 0 0 a0 (XEN) 11: 001a 1 0 1 0 1 0 0 31 (XEN) 12: 0015 1 1 1 0 1 0 0 c8 (XEN) 13: 0017 1 0 1 0 1 0 0 d8 (XEN) 14: 0011 1 0 1 0 1 0 0 a8 (XEN) 17: 0012 1 0 1 1 1 1 0 b0 (XEN) [a: dump timer queues] (XEN) Dumping timer queues: (XEN) CPU00: (XEN) ex= 4408us timer=ffff83047c325cf8 cb=ffff82c4c011b1f0(0000000000000000) csched_tick+0/0x300 (XEN) ex= 24409us timer=ffff83047c326e90 cb=ffff82c4c0119140(ffff83047c326e70) csched_acct+0/0x4e0 (XEN) ex= 15374us timer=ffff830275337bd8 cb=ffff82c4c0142190(ffff830275337ba8) pt_irq_time_out+0/0xf0 (XEN) ex=148554608us timer=ffff82c4c02fc5c0 cb=ffff82c4c017ffb0(0000000000000000) plt_overflow+0/0x1a0 (XEN) ex= 604476us timer=ffff82c4c02fe900 cb=ffff82c4c01a6270(0000000000000000) mce_work_fn+0/0xd0 (XEN) ex= 994457us timer=ffff82c4c02fc660 cb=ffff82c4c017f5e0(0000000000000000) time_calibration+0/0x60 (XEN) CPU01: (XEN) ex= 3322373us timer=ffff830073306060 cb=ffff82c4c0120ab0(ffff830073306000) vcpu_singleshot_timer_fn+0/0x10 (XEN) CPU02: (XEN) ex= 141667us timer=ffff830441c403f0 cb=ffff82c4c01bfbc0(ffff830441c403b0) pt_timer_fn+0/0x40 (XEN) ex= 171433us timer=ffff8304711f0080 cb=ffff82c4c0120b50(0000000000000000) s_timer_fn+0/0x10 (XEN) ex= 146578us timer=ffff8304711f24a8 cb=ffff82c4c011b1f0(0000000000000002) csched_tick+0/0x300 (XEN) ex=47649132263us timer=ffff830441c40380 cb=ffff82c4c01b9720(ffff830441c402e0) rtc_alarm_cb+0/0x40 (XEN) ex= 3322373us timer=ffff8300735e0060 cb=ffff82c4c0120ab0(ffff8300735e0000) vcpu_singleshot_timer_fn+0/0x10 (XEN) ex= 152345us timer=ffff830441c40540 cb=ffff82c4c01bfbc0(ffff830441c40500) pt_timer_fn+0/0x40 (XEN) ex=13380628us timer=ffff830441c405c0 cb=ffff82c4c01bfbc0(ffff830441c40580) pt_timer_fn+0/0x40 (XEN) CPU03: (XEN) ex= 276745us timer=ffff8304711f2c78 cb=ffff82c4c011b1f0(0000000000000003) csched_tick+0/0x300 (XEN) ex= 3322373us timer=ffff830073305060 cb=ffff82c4c0120ab0(ffff830073305000) vcpu_singleshot_timer_fn+0/0x10 (XEN) ex= 301777us timer=ffff83047117b080 cb=ffff82c4c0120b50(0000000000000000) s_timer_fn+0/0x10 (XEN) CPU04: (XEN) ex= 277508us timer=ffff83047116f478 cb=ffff82c4c011b1f0(0000000000000004) csched_tick+0/0x300 (XEN) ex= 301864us timer=ffff83047116d080 cb=ffff82c4c0120b50(0000000000000000) s_timer_fn+0/0x10 (XEN) CPU05: (XEN) ex= 369511us timer=ffff830275337cb0 cb=ffff82c4c0165c80(ffff830471181700) irq_guest_eoi_timer_fn+0/0x140 (XEN) ex= 1106373us timer=ffff8300735e2060 cb=ffff82c4c0120ab0(ffff8300735e2000) vcpu_singleshot_timer_fn+0/0x10 (XEN) CPU06: (XEN) ex= 426373us timer=ffff8300735e1060 cb=ffff82c4c0120ab0(ffff8300735e1000) vcpu_singleshot_timer_fn+0/0x10 (XEN) ex= 1094373us timer=ffff8300735e3060 cb=ffff82c4c0120ab0(ffff8300735e3000) vcpu_singleshot_timer_fn+0/0x10 (XEN) CPU07: (XEN) ex= 455183us timer=ffff830073305060 cb=ffff82c4c0120ab0(ffff830073305000) vcpu_singleshot_timer_fn+0/0x10 (XEN) ex=537370053us timer=ffff830441c406b0 cb=ffff82c4c01b8660(ffff830441c40688) pmt_timer_callback+0/0x60 (XEN) [c: dump ACPI Cx structures] (XEN) 'c' pressed -> printing ACPI Cx structures (XEN) ==cpu0== (XEN) active state: C0 (XEN) max_cstate: C7 (XEN) states: (XEN) C1: type[C1] latency[002] usage[00269171] method[ FFH] duration[11616116446] (XEN) C2: type[C2] latency[033] usage[00009028] method[ FFH] duration[4449354022] (XEN) C3: type[C3] latency[133] usage[00000821] method[ FFH] duration[858596883] (XEN) C4: type[C4] latency[166] usage[00009800] method[ FFH] duration[115042734656] (XEN) *C0: usage[00288820] duration[20191606319] (XEN) PC2[371120136] PC3[73269533647] PC6[0] PC7[0] (XEN) CC3[13892654174] CC6[1902780331] CC7[94152262644] (XEN) ==cpu1== (XEN) active state: C4 (XEN) max_cstate: C7 (XEN) states: (XEN) C1: type[C1] latency[002] usage[00125410] method[ FFH] duration[10608678205] (XEN) C2: type[C2] latency[033] usage[00023277] method[ FFH] duration[19584980665] (XEN) C3: type[C3] latency[133] usage[00000598] method[ FFH] duration[1815757357] (XEN) *C4: type[C4] latency[166] usage[00003399] method[ FFH] duration[111078897769] (XEN) C0: usage[00152684] duration[9175477089] (XEN) PC2[371120136] PC3[73269533647] PC6[0] PC7[0] (XEN) CC3[13892654174] CC6[1902780331] CC7[94152262644] (XEN) ==cpu2== (XEN) active state: C4 (XEN) max_cstate: C7 (XEN) states: (XEN) C1: type[C1] latency[002] usage[00073959] method[ FFH] duration[6755281551] (XEN) C2: type[C2] latency[033] usage[00013515] method[ FFH] duration[9566244697] (XEN) C3: type[C3] latency[133] usage[00000937] method[ FFH] duration[1317454375] (XEN) *C4: type[C4] latency[166] usage[00004980] method[ FFH] duration[128495833623] (XEN) C0: usage[00093391] duration[6231588371] (XEN) PC2[371120136] PC3[73269533647] PC6[0] PC7[0] (XEN) CC3[9666166807] CC6[2155040307] CC7[96944857637] (XEN) ==cpu3== (XEN) active state: C0 (XEN) max_cstate: C7 (XEN) states: (XEN) C1: type[C1] latency[002] usage[00351468] method[ FFH] duration[8509698250] (XEN) C2: type[C2] latency[033] usage[00011638] method[ FFH] duration[8111517839] (XEN) C3: type[C3] latency[133] usage[00003546] method[ FFH] duration[3373299815] (XEN) C4: type[C4] latency[166] usage[00003998] method[ FFH] duration[103201828742] (XEN) *C0: usage[00370650] duration[29272667868] (XEN) PC2[371120136] PC3[73269533647] PC6[0] PC7[0] (XEN) CC3[9666166807] CC6[2155040307] CC7[96944857637] (XEN) ==cpu4== (XEN) active state: C4 (XEN) max_cstate: C7 (XEN) states: (XEN) C1: type[C1] latency[002] usage[00156631] method[ FFH] duration[11212203615] (XEN) C2: type[C2] latency[033] usage[00010720] method[ FFH] duration[10318065102] (XEN) C3: type[C3] latency[133] usage[00000498] method[ FFH] duration[683955280] (XEN) *C4: type[C4] latency[166] usage[00003911] method[ FFH] duration[116970143661] (XEN) C0: usage[00171760] duration[13387254785] (XEN) PC2[371120136] PC3[73269533647] PC6[0] PC7[0] (XEN) CC3[6876494525] CC6[1320386486] CC7[105279532098] (XEN) ==cpu5== (XEN) active state: C0 (XEN) max_cstate: C7 (XEN) states: (XEN) C1: type[C1] latency[002] usage[00265111] method[ FFH] duration[16854920722] (XEN) C2: type[C2] latency[033] usage[00006247] method[ FFH] duration[5893214765] (XEN) C3: type[C3] latency[133] usage[00000407] method[ FFH] duration[1405795959] (XEN) C4: type[C4] latency[166] usage[00002139] method[ FFH] duration[119356645215] (XEN) *C0: usage[00273904] duration[9163657183] (XEN) PC2[371120136] PC3[73269533647] PC6[0] PC7[0] (XEN) CC3[6876494525] CC6[1320386486] CC7[105279532098] (XEN) ==cpu6== (XEN) active state: C0 (XEN) max_cstate: C7 (XEN) states: (XEN) C1: type[C1] latency[002] usage[00180979] method[ FFH] duration[9044381401] (XEN) C2: type[C2] latency[033] usage[00014849] method[ FFH] duration[9318310609] (XEN) C3: type[C3] latency[133] usage[00001396] method[ FFH] duration[2190042269] (XEN) C4: type[C4] latency[166] usage[00002974] method[ FFH] duration[121463105436] (XEN) *C0: usage[00200198] duration[10763777077] (XEN) PC2[371120136] PC3[73269533647] PC6[0] PC7[0] (XEN) CC3[9334000786] CC6[1272004414] CC7[117077508581] (XEN) ==cpu7== (XEN) active state: C0 (XEN) max_cstate: C7 (XEN) states: (XEN) C1: type[C1] latency[002] usage[00305115] method[ FFH] duration[8255540035] (XEN) C2: type[C2] latency[033] usage[00023080] method[ FFH] duration[12599652181] (XEN) C3: type[C3] latency[133] usage[00001566] method[ FFH] duration[1545623104] (XEN) C4: type[C4] latency[166] usage[00005509] method[ FFH] duration[123625000923] (XEN) *C0: usage[00335270] duration[6856410223] (XEN) PC2[371120136] PC3[73269533647] PC6[0] PC7[0] (XEN) CC3[9334000786] CC6[1272004414] CC7[117077508581] (XEN) [e: dump evtchn info] (XEN) 'e' pressed -> dumping event-channel info (XEN) Event channel information for domain 0: (XEN) Polling vCPUs: {} (XEN) port [p/m] (XEN) 1 [0/0]: s=5 n=0 x=0 v=0 (XEN) 2 [0/0]: s=6 n=0 x=0 (XEN) 3 [0/0]: s=6 n=0 x=0 (XEN) 4 [0/0]: s=5 n=0 x=0 v=1 (XEN) 5 [0/0]: s=6 n=0 x=0 (XEN) 6 [0/0]: s=6 n=0 x=0 (XEN) 7 [0/0]: s=5 n=1 x=0 v=0 (XEN) 8 [0/0]: s=6 n=1 x=0 (XEN) 9 [0/0]: s=6 n=1 x=0 (XEN) 10 [0/0]: s=5 n=1 x=0 v=1 (XEN) 11 [0/0]: s=6 n=1 x=0 (XEN) 12 [0/0]: s=6 n=1 x=0 (XEN) 13 [0/0]: s=5 n=2 x=0 v=0 (XEN) 14 [0/0]: s=6 n=2 x=0 (XEN) 15 [0/0]: s=6 n=2 x=0 (XEN) 16 [0/0]: s=5 n=2 x=0 v=1 (XEN) 17 [0/0]: s=6 n=2 x=0 (XEN) 18 [0/0]: s=6 n=2 x=0 (XEN) 19 [0/0]: s=5 n=3 x=0 v=0 (XEN) 20 [0/0]: s=6 n=3 x=0 (XEN) 21 [0/0]: s=6 n=3 x=0 (XEN) 22 [0/0]: s=5 n=3 x=0 v=1 (XEN) 23 [0/0]: s=6 n=3 x=0 (XEN) 24 [0/0]: s=6 n=3 x=0 (XEN) 25 [1/0]: s=5 n=4 x=0 v=0 (XEN) 26 [1/0]: s=6 n=4 x=0 (XEN) 27 [0/0]: s=6 n=4 x=0 (XEN) 28 [0/0]: s=5 n=4 x=0 v=1 (XEN) 29 [0/0]: s=6 n=4 x=0 (XEN) 30 [0/0]: s=6 n=4 x=0 (XEN) 31 [0/0]: s=5 n=5 x=0 v=0 (XEN) 32 [0/0]: s=6 n=5 x=0 (XEN) 33 [0/0]: s=6 n=5 x=0 (XEN) 34 [0/0]: s=5 n=5 x=0 v=1 (XEN) 35 [0/0]: s=6 n=5 x=0 (XEN) 36 [0/0]: s=6 n=5 x=0 (XEN) 37 [0/0]: s=5 n=6 x=0 v=0 (XEN) 38 [0/0]: s=6 n=6 x=0 (XEN) 39 [0/0]: s=6 n=6 x=0 (XEN) 40 [0/0]: s=5 n=6 x=0 v=1 (XEN) 41 [0/0]: s=6 n=6 x=0 (XEN) 42 [0/0]: s=6 n=6 x=0 (XEN) 43 [1/0]: s=5 n=7 x=0 v=0 (XEN) 44 [1/0]: s=6 n=7 x=0 (XEN) 45 [0/0]: s=6 n=7 x=0 (XEN) 46 [0/0]: s=5 n=7 x=0 v=1 (XEN) 47 [0/0]: s=6 n=7 x=0 (XEN) 48 [0/0]: s=6 n=7 x=0 (XEN) 49 [0/0]: s=3 n=0 x=0 d=0 p=76 (XEN) 50 [0/0]: s=5 n=0 x=0 v=9 (XEN) 51 [0/0]: s=4 n=0 x=0 p=9 i=9 (XEN) 52 [0/0]: s=4 n=0 x=0 p=279 i=25 (XEN) 53 [0/0]: s=4 n=0 x=0 p=278 i=26 (XEN) 54 [0/0]: s=4 n=0 x=0 p=277 i=27 (XEN) 55 [0/0]: s=4 n=0 x=0 p=276 i=28 (XEN) 56 [0/0]: s=4 n=0 x=0 p=275 i=29 (XEN) 57 [0/0]: s=4 n=0 x=0 p=274 i=30 (XEN) 58 [0/0]: s=4 n=0 x=0 p=273 i=31 (XEN) 59 [0/0]: s=4 n=0 x=0 p=272 i=32 (XEN) 60 [0/0]: s=4 n=0 x=0 p=269 i=35 (XEN) 61 [0/1]: s=5 n=0 x=0 v=2 (XEN) 62 [0/0]: s=4 n=0 x=0 p=1 i=1 (XEN) 63 [0/0]: s=4 n=0 x=0 p=8 i=8 (XEN) 64 [0/0]: s=4 n=0 x=0 p=20 i=20 (XEN) 65 [0/0]: s=3 n=0 x=0 d=1 p=8 (XEN) 66 [0/0]: s=4 n=0 x=0 p=16 i=16 (XEN) 67 [0/0]: s=4 n=0 x=0 p=262 i=42 (XEN) 68 [0/0]: s=4 n=0 x=0 p=256 i=48 (XEN) 69 [0/0]: s=4 n=0 x=0 p=5 i=5 (XEN) 70 [0/0]: s=4 n=0 x=0 p=19 i=19 (XEN) 71 [0/0]: s=4 n=0 x=0 p=267 i=37 (XEN) 72 [0/0]: s=4 n=0 x=0 p=266 i=38 (XEN) 73 [1/0]: s=4 n=0 x=0 p=265 i=39 (XEN) 74 [0/0]: s=4 n=0 x=0 p=264 i=40 (XEN) 75 [0/0]: s=4 n=0 x=0 p=263 i=41 (XEN) 76 [0/0]: s=3 n=0 x=0 d=0 p=49 (XEN) 77 [0/0]: s=5 n=0 x=0 v=3 (XEN) 78 [0/0]: s=3 n=0 x=0 d=1 p=9 (XEN) 79 [0/0]: s=3 n=0 x=0 d=1 p=1 (XEN) 80 [0/0]: s=3 n=0 x=0 d=1 p=3 (XEN) 81 [0/0]: s=3 n=0 x=0 d=1 p=4 (XEN) 82 [0/0]: s=3 n=0 x=0 d=1 p=5 (XEN) 83 [0/0]: s=3 n=0 x=0 d=1 p=6 (XEN) 84 [0/0]: s=3 n=0 x=0 d=1 p=7 (XEN) 85 [0/0]: s=3 n=0 x=0 d=1 p=2 (XEN) 86 [0/0]: s=3 n=0 x=0 d=1 p=12 (XEN) 87 [0/0]: s=3 n=0 x=0 d=1 p=13 (XEN) Event channel information for domain 1: (XEN) Polling vCPUs: {} (XEN) port [p/m] (XEN) 1 [0/1]: s=3 n=0 x=1 d=0 p=79 (XEN) 2 [0/1]: s=3 n=0 x=1 d=0 p=85 (XEN) 3 [0/1]: s=3 n=1 x=1 d=0 p=80 (XEN) 4 [0/1]: s=3 n=2 x=1 d=0 p=81 (XEN) 5 [0/1]: s=3 n=3 x=1 d=0 p=82 (XEN) 6 [0/1]: s=3 n=4 x=1 d=0 p=83 (XEN) 7 [0/1]: s=3 n=5 x=1 d=0 p=84 (XEN) 8 [0/0]: s=3 n=0 x=0 d=0 p=65 (XEN) 9 [0/1]: s=3 n=0 x=0 d=0 p=78 (XEN) 10 [0/0]: s=6 n=0 x=0 (XEN) 11 [0/0]: s=2 n=0 x=0 d=0 (XEN) 12 [0/0]: s=3 n=0 x=0 d=0 p=86 (XEN) 13 [0/0]: s=3 n=0 x=0 d=0 p=87 (XEN) [g: print grant table usage] (XEN) gnttab_usage_print_all [ key 'g' pressed (XEN) -------- active -------- -------- shared -------- (XEN) [ref] localdom mfn pin localdom gmfn flags (XEN) grant-table for remote domain: 0 ... no active grant table entries (XEN) -------- active -------- -------- shared -------- (XEN) [ref] localdom mfn pin localdom gmfn flags (XEN) grant-table for remote domain: 1 (v1) (XEN) [ 0] 0 0x4451a8 0x00000002 0 0x000000 0x00 (XEN) [ 1] 0 0x4451ab 0x00000002 0 0x000000 0x00 (XEN) [16298] 0 0x276c42 0x00000001 0 0x07e442 0x19 (XEN) [16303] 0 0x276c41 0x00000001 0 0x07e441 0x19 (XEN) [16383] 0 0x276587 0x00000001 0 0x07ed87 0x19 (XEN) gnttab_usage_print_all ] done (XEN) [i: dump interrupt bindings] (XEN) Guest interrupt information: (XEN) IRQ: 0 affinity:01 vec:f0 type=IO-APIC-edge status=00000000 timer_interrupt+0/0x180 (XEN) IRQ: 1 affinity:02 vec:62 type=IO-APIC-edge status=00000030 in-flight=0 domain-list=0: 1(----), (XEN) IRQ: 3 affinity:ff vec:38 type=IO-APIC-edge status=00000002 mapped, unbound (XEN) IRQ: 4 affinity:01 vec:f1 type=IO-APIC-edge status=00000000 ns16550_interrupt+0/0x90 (XEN) IRQ: 5 affinity:01 vec:40 type=IO-APIC-edge status=00000030 in-flight=0 domain-list=0: 5(----), (XEN) IRQ: 6 affinity:01 vec:48 type=IO-APIC-edge status=00000002 mapped, unbound (XEN) IRQ: 7 affinity:01 vec:50 type=IO-APIC-edge status=00000002 mapped, unbound (XEN) IRQ: 8 affinity:01 vec:58 type=IO-APIC-edge status=00000030 in-flight=0 domain-list=0: 8(----), (XEN) IRQ: 9 affinity:01 vec:60 type=IO-APIC-level status=00000030 in-flight=0 domain-list=0: 9(----), (XEN) IRQ: 10 affinity:01 vec:68 type=IO-APIC-edge status=00000002 mapped, unbound (XEN) IRQ: 11 affinity:01 vec:70 type=IO-APIC-edge status=00000002 mapped, unbound (XEN) IRQ: 12 affinity:01 vec:78 type=IO-APIC-edge status=00000002 mapped, unbound (XEN) IRQ: 13 affinity:ff vec:88 type=IO-APIC-edge status=00000002 mapped, unbound (XEN) IRQ: 14 affinity:01 vec:90 type=IO-APIC-edge status=00000002 mapped, unbound (XEN) IRQ: 15 affinity:01 vec:98 type=IO-APIC-edge status=00000002 mapped, unbound (XEN) IRQ: 16 affinity:08 vec:a0 type=IO-APIC-level status=00000030 in-flight=0 domain-list=0: 16(----),1: 16(--M-), (XEN) IRQ: 17 affinity:80 vec:31 type=IO-APIC-level status=00000010 in-flight=0 domain-list=1: 17(--M-), (XEN) IRQ: 18 affinity:ff vec:c8 type=IO-APIC-level status=00000002 mapped, unbound (XEN) IRQ: 19 affinity:01 vec:d8 type=IO-APIC-level status=00000030 in-flight=0 domain-list=0: 19(----), (XEN) IRQ: 20 affinity:01 vec:a8 type=IO-APIC-level status=00000030 in-flight=0 domain-list=0: 20(----), (XEN) IRQ: 23 affinity:20 vec:b0 type=IO-APIC-level status=00000010 in-flight=1 domain-list=1: 23(--MM), (XEN) IRQ: 24 affinity:ff vec:28 type=DMA_MSI status=00000000 iommu_page_fault+0/0x10 (XEN) IRQ: 25 affinity:01 vec:b8 type=PCI-MSI status=00000030 in-flight=0 domain-list=0:279(----), (XEN) IRQ: 26 affinity:01 vec:c0 type=PCI-MSI status=00000030 in-flight=0 domain-list=0:278(----), (XEN) IRQ: 27 affinity:01 vec:d0 type=PCI-MSI status=00000030 in-flight=0 domain-list=0:277(----), (XEN) IRQ: 28 affinity:01 vec:21 type=PCI-MSI status=00000030 in-flight=0 domain-list=0:276(----), (XEN) IRQ: 29 affinity:01 vec:29 type=PCI-MSI status=00000030 in-flight=0 domain-list=0:275(----), (XEN) IRQ: 30 affinity:01 vec:39 type=PCI-MSI status=00000030 in-flight=0 domain-list=0:274(----), (XEN) IRQ: 31 affinity:01 vec:41 type=PCI-MSI status=00000030 in-flight=0 domain-list=0:273(----), (XEN) IRQ: 32 affinity:01 vec:49 type=PCI-MSI status=00000030 in-flight=0 domain-list=0:272(----), (XEN) IRQ: 33 affinity:ff vec:51 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 34 affinity:ff vec:59 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 35 affinity:01 vec:61 type=PCI-MSI/-X status=00000030 in-flight=0 domain-list=0:269(----), (XEN) IRQ: 36 affinity:ff vec:69 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 37 affinity:01 vec:71 type=PCI-MSI/-X status=00000030 in-flight=0 domain-list=0:267(----), (XEN) IRQ: 38 affinity:02 vec:79 type=PCI-MSI/-X status=00000010 in-flight=0 domain-list=0:266(----), (XEN) IRQ: 39 affinity:02 vec:81 type=PCI-MSI/-X status=00000010 in-flight=0 domain-list=0:265(----), (XEN) IRQ: 40 affinity:02 vec:89 type=PCI-MSI/-X status=00000010 in-flight=0 domain-list=0:264(----), (XEN) IRQ: 41 affinity:02 vec:91 type=PCI-MSI/-X status=00000010 in-flight=0 domain-list=0:263(----), (XEN) IRQ: 42 affinity:01 vec:99 type=PCI-MSI status=00000030 in-flight=0 domain-list=0:262(----), (XEN) IRQ: 43 affinity:ff vec:a1 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 44 affinity:ff vec:a9 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 45 affinity:ff vec:b1 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 46 affinity:ff vec:b9 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 47 affinity:ff vec:c1 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 48 affinity:08 vec:c9 type=PCI-MSI status=00000030 in-flight=0 domain-list=0:256(----), (XEN) IRQ: 49 affinity:ff vec:d1 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 50 affinity:ff vec:d9 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 51 affinity:ff vec:22 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 52 affinity:ff vec:2a type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 53 affinity:ff vec:32 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 54 affinity:ff vec:3a type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 55 affinity:ff vec:42 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 56 affinity:ff vec:4a type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 57 affinity:ff vec:52 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 58 affinity:ff vec:5a type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 59 affinity:80 vec:6a type=PCI-MSI status=00000010 in-flight=0 domain-list=1: 55(--M-), (XEN) IO-APIC interrupt information: (XEN) IRQ 0 Vec240: (XEN) Apic 0x00, Pin 2: vec=f0 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=0 dest_id:0 (XEN) IRQ 1 Vec 98: (XEN) Apic 0x00, Pin 1: vec=62 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=0 dest_id:0 (XEN) IRQ 3 Vec 56: (XEN) Apic 0x00, Pin 3: vec=38 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=1 dest_id:0 (XEN) IRQ 4 Vec241: (XEN) Apic 0x00, Pin 4: vec=f1 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=0 dest_id:0 (XEN) IRQ 5 Vec 64: (XEN) Apic 0x00, Pin 5: vec=40 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=0 dest_id:0 (XEN) IRQ 6 Vec 72: (XEN) Apic 0x00, Pin 6: vec=48 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=0 dest_id:0 (XEN) IRQ 7 Vec 80: (XEN) Apic 0x00, Pin 7: vec=50 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=0 dest_id:0 (XEN) IRQ 8 Vec 88: (XEN) Apic 0x00, Pin 8: vec=58 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=0 dest_id:0 (XEN) IRQ 9 Vec 96: (XEN) Apic 0x00, Pin 9: vec=60 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=L mask=0 dest_id:0 (XEN) IRQ 10 Vec104: (XEN) Apic 0x00, Pin 10: vec=68 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=0 dest_id:0 (XEN) IRQ 11 Vec112: (XEN) Apic 0x00, Pin 11: vec=70 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=0 dest_id:0 (XEN) IRQ 12 Vec120: (XEN) Apic 0x00, Pin 12: vec=78 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=0 dest_id:0 (XEN) IRQ 13 Vec136: (XEN) Apic 0x00, Pin 13: vec=88 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=1 dest_id:0 (XEN) IRQ 14 Vec144: (XEN) Apic 0x00, Pin 14: vec=90 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=0 dest_id:0 (XEN) IRQ 15 Vec152: (XEN) Apic 0x00, Pin 15: vec=98 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=0 dest_id:0 (XEN) IRQ 16 Vec160: (XEN) Apic 0x00, Pin 16: vec=a0 delivery=LoPri dest=L status=0 polarity=1 irr=0 trig=L mask=0 dest_id:0 (XEN) IRQ 17 Vec 49: (XEN) Apic 0x00, Pin 17: vec=31 delivery=LoPri dest=L status=0 polarity=1 irr=0 trig=L mask=0 dest_id:0 (XEN) IRQ 18 Vec200: (XEN) Apic 0x00, Pin 18: vec=c8 delivery=LoPri dest=L status=0 polarity=1 irr=0 trig=L mask=1 dest_id:0 (XEN) IRQ 19 Vec216: (XEN) Apic 0x00, Pin 19: vec=d8 delivery=LoPri dest=L status=0 polarity=1 irr=0 trig=L mask=0 dest_id:0 (XEN) IRQ 20 Vec168: (XEN) Apic 0x00, Pin 20: vec=a8 delivery=LoPri dest=L status=0 polarity=1 irr=0 trig=L mask=0 dest_id:0 (XEN) IRQ 23 Vec176: (XEN) Apic 0x00, Pin 23: vec=b0 delivery=LoPri dest=L status=1 polarity=1 irr=1 trig=L mask=0 dest_id:0 (XEN) [m: memory info] (XEN) Physical memory information: (XEN) Xen heap: 0kB free (XEN) heap[14]: 64512kB free (XEN) heap[15]: 131072kB free (XEN) heap[16]: 262144kB free (XEN) heap[17]: 524288kB free (XEN) heap[18]: 839144kB free (XEN) heap[20]: 4194304kB free (XEN) heap[21]: 7163184kB free (XEN) heap[22]: 236kB free (XEN) Dom heap: 13178884kB free (XEN) [n: NMI statistics] (XEN) CPU NMI (XEN) 0 0 (XEN) 1 0 (XEN) 2 0 (XEN) 3 0 (XEN) 4 0 (XEN) 5 0 (XEN) 6 0 (XEN) 7 0 (XEN) dom0 vcpu0: NMI neither pending nor masked (XEN) [q: dump domain (and guest debug) info] (XEN) 'q' pressed -> dumping domain info (now=0x24:30928D6A) (XEN) General information for domain 0: (XEN) refcnt=3 dying=0 pause_count=0 (XEN) nr_pages=262144 xenheap_pages=6 shared_pages=0 paged_pages=0 dirty_cpus={2,5} max_pages=4294967295 (XEN) handle=00000000-0000-0000-0000-000000000000 vm_assist=0000000d (XEN) Rangesets belonging to domain 0: (XEN) I/O Ports { 0-1f, 22-3f, 44-60, 62-9f, a2-3f7, 400-cfb, d00-1807, 180c-ffff } (XEN) Interrupts { 1-23, 25-59 } (XEN) I/O Memory { 0-fedff, fee01-ffffffffffffffff } (XEN) Memory pages belonging to domain 0: (XEN) DomPage list too long to display (XEN) XenPage 0000000000471114: caf=c000000000000002, taf=7400000000000002 (XEN) XenPage 0000000000471113: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 0000000000471112: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 0000000000471111: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 00000000000643fc: caf=c000000000000002, taf=7400000000000002 (XEN) XenPage 0000000000445c43: caf=c000000000000002, taf=7400000000000002 (XEN) NODE affinity for domain 0: [0] (XEN) VCPU information and callbacks for domain 0: (XEN) VCPU0: CPU1 [has=T] poll=0 upcall_pend = 00, upcall_mask = 01 dirty_cpus={1} cpu_affinity={0-7} (XEN) pause_count=0 pause_flags=1 (XEN) No periodic timer (XEN) VCPU1: CPU3 [has=F] poll=0 upcall_pend = 00, upcall_mask = 00 dirty_cpus={} cpu_affinity={0-7} (XEN) pause_count=0 pause_flags=1 (XEN) No periodic timer (XEN) VCPU2: CPU2 [has=F] poll=0 upcall_pend = 00, upcall_mask = 00 dirty_cpus={2} cpu_affinity={0-7} (XEN) pause_count=0 pause_flags=1 (XEN) No periodic timer (XEN) VCPU3: CPU2 [has=F] poll=0 upcall_pend = 00, upcall_mask = 00 dirty_cpus={} cpu_affinity={0-7} (XEN) pause_count=0 pause_flags=1 (XEN) No periodic timer (XEN) VCPU4: CPU0 [has=F] poll=0 upcall_pend = 01, upcall_mask = 00 dirty_cpus={} cpu_affinity={0-7} (XEN) pause_count=0 pause_flags=0 (XEN) No periodic timer (XEN) VCPU5: CPU1 [has=F] poll=0 upcall_pend = 00, upcall_mask = 00 dirty_cpus={} cpu_affinity={0-7} (XEN) pause_count=0 pause_flags=1 (XEN) No periodic timer (XEN) VCPU6: CPU5 [has=F] poll=0 upcall_pend = 00, upcall_mask = 00 dirty_cpus={} cpu_affinity={0-7} (XEN) pause_count=0 pause_flags=1 (XEN) No periodic timer (XEN) VCPU7: CPU0 [has=F] poll=0 upcall_pend = 01, upcall_mask = 00 dirty_cpus={} cpu_affinity={0-7} (XEN) pause_count=0 pause_flags=0 (XEN) No periodic timer (XEN) General information for domain 1: (XEN) refcnt=3 dying=0 pause_count=0 (XEN) nr_pages=524099 xenheap_pages=34 shared_pages=0 paged_pages=0 dirty_cpus={3-4,6-7} max_pages=524544 (XEN) handle=ab8f106b-2e46-4512-957d-d587797d43ac vm_assist=00000000 (XEN) paging assistance: hap refcounts log_dirty translate external (XEN) Rangesets belonging to domain 1: (XEN) I/O Ports { e000-e0ff } (XEN) Interrupts { 16-17, 23, 59 } (XEN) I/O Memory { c0000-d003f, d0060-d0063, d0411 } (XEN) Memory pages belonging to domain 1: (XEN) DomPage list too long to display (XEN) PoD entries=0 cachesize=0 (XEN) XenPage 000000000046c0d1: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000046c0d0: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 0000000000445c4f: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 0000000000445c4e: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 0000000000064594: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 0000000000432938: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042e1e5: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042e1e4: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042e167: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042e166: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042e16d: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042e16c: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 0000000000408b83: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 0000000000408b82: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042bd2f: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042bd2e: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042bd2d: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042bd2c: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042cdcb: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042cdca: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042cdc9: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042cdc8: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042cc57: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042cc56: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042cc55: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042cc54: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042cc5b: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042cc5a: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042cc59: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042cc58: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 00000000004086a3: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 00000000004086a2: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 00000000004086a1: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 00000000004086a0: caf=c000000000000001, taf=7400000000000001 (XEN) NODE affinity for domain 1: [0] (XEN) VCPU information and callbacks for domain 1: (XEN) VCPU0: CPU7 [has=T] poll=0 upcall_pend = 00, upcall_mask = 00 dirty_cpus={7} cpu_affinity={0-7} (XEN) pause_count=0 pause_flags=0 (XEN) paging assistance: hap, 4 levels (XEN) No periodic timer (XEN) VCPU1: CPU0 [has=F] poll=0 upcall_pend = 00, upcall_mask = 00 dirty_cpus={} cpu_affinity={0-7} (XEN) pause_count=0 pause_flags=0 (XEN) paging assistance: hap, 4 levels (XEN) No periodic timer (XEN) VCPU2: CPU5 [has=F] poll=0 upcall_pend = 00, upcall_mask = 00 dirty_cpus={} cpu_affinity={0-7} (XEN) pause_count=0 pause_flags=1 (XEN) paging assistance: hap, 4 levels (XEN) No periodic timer (XEN) VCPU3: CPU6 [has=F] poll=0 upcall_pend = 00, upcall_mask = 00 dirty_cpus={6} cpu_affinity={0-7} (XEN) pause_count=0 pause_flags=1 (XEN) paging assistance: hap, 4 levels (XEN) No periodic timer (XEN) VCPU4: CPU4 [has=T] poll=0 upcall_pend = 00, upcall_mask = 00 dirty_cpus={4} cpu_affinity={0-7} (XEN) pause_count=0 pause_flags=0 (XEN) paging assistance: hap, 4 levels (XEN) No periodic timer (XEN) VCPU5: CPU3 [has=T] poll=0 upcall_pend = 00, upcall_mask = 00 dirty_cpus={3} cpu_affinity={0-7} (XEN) pause_count=0 pause_flags=0 (XEN) paging assistance: hap, 4 levels (XEN) No periodic timer (XEN) Notifying guest 0:0 (virq 1, port 4, stat 0/0/0) (XEN) Notifying guest 0:1 (virq 1, port 10, stat 0/0/0) (XEN) Notifying guest 0:2 (virq 1, port 16, stat 0/0/0) (XEN) Notifying guest 0:3 (virq 1, port 22, stat 0/0/0) (XEN) Notifying guest 0:4 (virq 1, port 28, stat 0/0/-1) (XEN) Notifying guest 0:5 (virq 1, port 34, stat 0/0/0) (XEN) Notifying guest 0:6 (virq 1, port 40, stat 0/0/0) (XEN) Notifying guest 0:7 (virq 1, port 46, stat 0/0/-1) (XEN) Notifying guest 1:0 (virq 1, port 0, stat 0/-1/0) (XEN) Notifying guest 1:1 (virq 1, port 0, stat 0/-1/0) (XEN) Notifying guest 1:2 (virq 1, port 0, stat 0/-1/0) (XEN) Notifying guest 1:3 (virq 1, port 0, stat 0/-1/0) (XEN) Notifying guest 1:4 (virq 1, port 0, stat 0/-1/0) (XEN) Notifying guest 1:5 (virq 1, port 0, stat 0/-1/0) (XEN) Shared frames 0 -- Saved frames 0 (XEN) [r: dump run queues] (XEN) sched_smt_power_savings: disabled (XEN) NOW=0x0000002485B4435A (XEN) Idle cpupool: (XEN) Scheduler: SMP Credit Scheduler (credit) (XEN) info: (XEN) ncpus = 8 (XEN) master = 0 (XEN) credit = 2400 (XEN) credit balance = -556 (XEN) weight = 1024 (XEN) runq_sort = 1746 (XEN) default-weight = 256 (XEN) tslice = 30ms (XEN) ratelimit = 1000us (XEN) credits per msec = 10 (XEN) ticks per tslice = 3 (XEN) migration delay = 0us (XEN) idlers: 9a (XEN) active vcpus: (XEN) 1: [0.0] pri=0 flags=0 cpu=3 credit=-40 [w=256] (XEN) 2: [1.5] pri=-2 flags=0 cpu=2 credit=-1548 [w=256] (XEN) 3: [1.4] pri=-2 flags=0 cpu=5 credit=-1658 [w=256] (XEN) 4: [1.0] pri=-2 flags=0 cpu=6 credit=-1770 [w=256] (XEN) Cpupool 0: (XEN) Scheduler: SMP Credit Scheduler (credit) (XEN) info: (XEN) ncpus = 8 (XEN) master = 0 (XEN) credit = 2400 (XEN) credit balance = -556 (XEN) weight = 1024 (XEN) runq_sort = 1746 (XEN) default-weight = 256 (XEN) tslice = 30ms (XEN) ratelimit = 1000us (XEN) credits per msec = 10 (XEN) ticks per tslice = 3 (XEN) migration delay = 0us (XEN) idlers: 9a (XEN) active vcpus: (XEN) 1: [0.0] pri=0 flags=0 cpu=3 credit=-101 [w=256] (XEN) 2: [1.5] pri=-2 flags=0 cpu=2 credit=-2851 [w=256] (XEN) 3: [1.4] pri=-2 flags=0 cpu=5 credit=-2962 [w=256] (XEN) 4: [1.0] pri=-2 flags=0 cpu=6 credit=-3073 [w=256] (XEN) CPU[00] sort=1745, sibling=03, core=ff (XEN) run: [32767.0] pri=0 flags=0 cpu=0 (XEN) 1: [0.4] pri=0 flags=0 cpu=0 credit=46 [w=256] (XEN) 2: [0.7] pri=0 flags=0 cpu=0 credit=242 [w=256] (XEN) 3: [1.1] pri=0 flags=0 cpu=0 credit=-515 [w=256] (XEN) CPU[01] sort=1746, sibling=03, core=ff (XEN) run: [32767.1] pri=-64 flags=0 cpu=1 (XEN) CPU[02] sort=1746, sibling=0c, core=ff (XEN) run: [1.5] pri=-2 flags=0 cpu=2 credit=-3739 [w=256] (XEN) 1: [32767.2] pri=-64 flags=0 cpu=2 (XEN) CPU[03] sort=1746, sibling=0c, core=ff (XEN) run: [32767.3] pri=-64 flags=0 cpu=3 (XEN) CPU[04] sort=1746, sibling=30, core=ff (XEN) run: [32767.4] pri=-64 flags=0 cpu=4 (XEN) CPU[05] sort=1746, sibling=30, core=ff (XEN) run: [1.4] pri=-2 flags=0 cpu=5 credit=-4321 [w=256] (XEN) 1: [32767.5] pri=-64 flags=0 cpu=5 (XEN) CPU[06] sort=1746, sibling=c0, core=ff (XEN) run: [32767.6] pri=-64 flags=0 cpu=6 (XEN) CPU[07] sort=1746, sibling=c0, core=ff (XEN) run: [1.5] pri=-2 flags=0 cpu=7 credit=-4737 [w=256] (XEN) 1: [32767.7] pri=-64 flags=0 cpu=7 (XEN) [s: dump softtsc stats] (XEN) TSC marked as reliable, warp = 0 (count=3) (XEN) dom1(hvm): mode=0,ofs=0x14b9addbde,khz=3292479,inc=1 (XEN) No domains have emulated TSC (XEN) [t: display multi-cpu clock info] (XEN) Synced stime skew: max=32ns avg=25ns samples=2 current=32ns (XEN) Synced cycles skew: max=249 avg=220 samples=2 current=249 (XEN) [u: dump numa info] (XEN) 'u' pressed -> dumping numa info (now-0x24:A64C008B) (XEN) idx0 -> NODE0 start->0 size->4718592 free->3294721 (XEN) phys_to_nid(0000000000001000) -> 0 should be 0 (XEN) CPU0 -> NODE0 (XEN) CPU1 -> NODE0 (XEN) CPU2 -> NODE0 (XEN) CPU3 -> NODE0 (XEN) CPU4 -> NODE0 (XEN) CPU5 -> NODE0 (XEN) CPU6 -> NODE0 (XEN) CPU7 -> NODE0 (XEN) Memory location of each domain: (XEN) Domain 0 (total: 262144): (XEN) Node 0: 262144 (XEN) Domain 1 (total: 524099): (XEN) Node 0: 524099 (XEN) [v: dump Intel's VMCS] (XEN) *********** VMCS Areas ************** (XEN) (XEN) >>> Domain 1 <<< (XEN) VCPU 0 (XEN) *** Guest State *** (XEN) CR0: actual=0x0000000080050039, shadow=0x0000000080050031, gh_mask=ffffffffffffffff (XEN) CR4: actual=0x00000000000426f8, shadow=0x00000000000406f8, gh_mask=ffffffffffffffff (XEN) CR3: actual=0x0000000000187000, target_count=0 (XEN) target0=0000000000000000, target1=0000000000000000 (XEN) target2=0000000000000000, target3=0000000000000000 (XEN) RSP = 0xfffff8000408a6f0 (0xfffff8000408a6f0) RIP = 0xfffff80002b0b481 (0xfffff80002b0b481) (XEN) RFLAGS=0x0000000000000202 (0x0000000000000202) DR7 = 0x0000000000000400 (XEN) Sysenter RSP=0000000000000000 CS:RIP=0000:0000000000000000 (XEN) CS: sel=0x0010, attr=0x0209b, limit=0x00000000, base=0x0000000000000000 (XEN) DS: sel=0x002b, attr=0x0c0f3, limit=0xffffffff, base=0x0000000000000000 (XEN) SS: sel=0x0018, attr=0x0c093, limit=0xffffffff, base=0x0000000000000000 (XEN) ES: sel=0x002b, attr=0x0c0f3, limit=0xffffffff, base=0x0000000000000000 (XEN) FS: sel=0x0053, attr=0x040f3, limit=0x00003c00, base=0x00000000fffa8000 (XEN) GS: sel=0x002b, attr=0x0c0f3, limit=0xffffffff, base=0xfffff80002c50d00 (XEN) GDTR: limit=0x0000007f, base=0xfffff80004084000 (XEN) LDTR: sel=0x0000, attr=0x1c000, limit=0xffffffff, base=0x0000000000000000 (XEN) IDTR: limit=0x00000fff, base=0xfffff80004084080 (XEN) TR: sel=0x0040, attr=0x0008b, limit=0x00000067, base=0xfffff80004085080 (XEN) Guest PAT = 0x0007010600070106 (XEN) TSC Offset = ffffff5e9aa5e43f (XEN) DebugCtl=0000000000000000 DebugExceptions=0000000000000000 (XEN) Interruptibility=0000 ActivityState=0000 (XEN) *** Host State *** (XEN) RSP = 0xffff83047114ff90 RIP = 0xffff82c4c01d7620 (XEN) CS=e008 DS=0000 ES=0000 FS=0000 GS=0000 SS=0000 TR=e040 (XEN) FSBase=0000000000000000 GSBase=0000000000000000 TRBase=ffff830471152c80 (XEN) GDTBase=ffff830471143000 IDTBase=ffff830471147000 (XEN) CR0=000000008005003b CR3=000000047f21a000 CR4=00000000001426f0 (XEN) Sysenter RSP=ffff83047114ffc0 CS:RIP=e008:ffff82c4c0215950 (XEN) Host PAT = 0x0000050100070406 (XEN) *** Control State *** (XEN) PinBased=0000003f CPUBased=b6a065fa SecondaryExec=000054eb (XEN) EntryControls=000053ff ExitControls=000fefff (XEN) ExceptionBitmap=000400c0 (XEN) VMEntry: intr_info=000000d1 errcode=00000000 ilen=00000000 (XEN) VMExit: intr_info=00000000 errcode=00000000 ilen=00000000 (XEN) reason=00000028 qualification=00000000 (XEN) IDTVectoring: info=00000000 errcode=00000000 (XEN) TPR Threshold = 0x00 (XEN) EPT pointer = 0x0000000445c4801e (XEN) Virtual processor ID = 0x33a7 (XEN) VCPU 1 (XEN) *** Guest State *** (XEN) CR0: actual=0x0000000080050039, shadow=0x0000000080050031, gh_mask=ffffffffffffffff (XEN) CR4: actual=0x00000000000426f8, shadow=0x00000000000406f8, gh_mask=ffffffffffffffff (XEN) CR3: actual=0x0000000000187000, target_count=0 (XEN) target0=0000000000000000, target1=0000000000000000 (XEN) target2=0000000000000000, target3=0000000000000000 (XEN) RSP = 0xfffff88002e68b58 (0xfffff88002e68b58) RIP = 0xfffff880049889c1 (0xfffff880049889c2) (XEN) RFLAGS=0x0000000000000246 (0x0000000000000246) DR7 = 0x0000000000000400 (XEN) Sysenter RSP=0000000000000000 CS:RIP=0000:0000000000000000 (XEN) CS: sel=0x0010, attr=0x0209b, limit=0x00000000, base=0x0000000000000000 (XEN) DS: sel=0x002b, attr=0x0c0f3, limit=0xffffffff, base=0x0000000000000000 (XEN) SS: sel=0x0018, attr=0x0c093, limit=0xffffffff, base=0x0000000000000000 (XEN) ES: sel=0x002b, attr=0x0c0f3, limit=0xffffffff, base=0x0000000000000000 (XEN) FS: sel=0x0053, attr=0x040f3, limit=0x00007c00, base=0x00000000fffda000 (XEN) GS: sel=0x002b, attr=0x0c0f3, limit=0xffffffff, base=0xfffff88002e40000 (XEN) GDTR: limit=0x0000007f, base=0xfffff88002e4b5c0 (XEN) LDTR: sel=0x0000, attr=0x1c000, limit=0xffffffff, base=0x0000000000000000 (XEN) IDTR: limit=0x00000fff, base=0xfffff88002e4b640 (XEN) TR: sel=0x0040, attr=0x0008b, limit=0x00000067, base=0xfffff88002e44fc0 (XEN) Guest PAT = 0x0007010600070106 (XEN) TSC Offset = ffffff5e9aa5e494 (XEN) DebugCtl=0000000000000000 DebugExceptions=0000000000000000 (XEN) Interruptibility=0000 ActivityState=0000 (XEN) *** Host State *** (XEN) RSP = 0xffff82c4c02aff90 RIP = 0xffff82c4c01d7620 (XEN) CS=e008 DS=0000 ES=0000 FS=0000 GS=0000 SS=0000 TR=e040 (XEN) FSBase=0000000000000000 GSBase=0000000000000000 TRBase=ffff82c4c0301280 (XEN) GDTBase=ffff82c4c0246000 IDTBase=ffff82c4c02fc6c0 (XEN) CR0=000000008005003b CR3=000000047f219000 CR4=00000000001426f0 (XEN) Sysenter RSP=ffff82c4c02affc0 CS:RIP=e008:ffff82c4c0215950 (XEN) Host PAT = 0x0000050100070406 (XEN) *** Control State *** (XEN) PinBased=0000003f CPUBased=b6a065fa SecondaryExec=000054eb (XEN) EntryControls=000053ff ExitControls=000fefff (XEN) ExceptionBitmap=000400c0 (XEN) VMEntry: intr_info=00000072 errcode=00000000 ilen=00000000 (XEN) VMExit: intr_info=00000000 errcode=00000000 ilen=00000000 (XEN) reason=0000000c qualification=00000000 (XEN) IDTVectoring: info=00000000 errcode=00000000 (XEN) TPR Threshold = 0x00 (XEN) EPT pointer = 0x0000000445c4801e (XEN) Virtual processor ID = 0x3bc3 (XEN) VCPU 2 (XEN) *** Guest State *** (XEN) CR0: actual=0x0000000080050039, shadow=0x0000000080050031, gh_mask=ffffffffffffffff (XEN) CR4: actual=0x00000000000426f8, shadow=0x00000000000406f8, gh_mask=ffffffffffffffff (XEN) CR3: actual=0x0000000000187000, target_count=0 (XEN) target0=0000000000000000, target1=0000000000000000 (XEN) target2=0000000000000000, target3=0000000000000000 (XEN) RSP = 0xfffff88002edfb58 (0xfffff88002edfb58) RIP = 0xfffff880049889c1 (0xfffff880049889c2) (XEN) RFLAGS=0x0000000000000246 (0x0000000000000246) DR7 = 0x0000000000000400 (XEN) Sysenter RSP=0000000000000000 CS:RIP=0000:0000000000000000 (XEN) CS: sel=0x0010, attr=0x0209b, limit=0x00000000, base=0x0000000000000000 (XEN) DS: sel=0x002b, attr=0x0c0f3, limit=0xffffffff, base=0x0000000000000000 (XEN) SS: sel=0x0018, attr=0x0c093, limit=0xffffffff, base=0x0000000000000000 (XEN) ES: sel=0x002b, attr=0x0c0f3, limit=0xffffffff, base=0x0000000000000000 (XEN) FS: sel=0x0053, attr=0x040f3, limit=0x0000bc00, base=0x00000000fffd9000 (XEN) GS: sel=0x002b, attr=0x0c0f3, limit=0xffffffff, base=0xfffff88002eb7000 (XEN) GDTR: limit=0x0000007f, base=0xfffff88002ec25c0 (XEN) LDTR: sel=0x0000, attr=0x1c000, limit=0xffffffff, base=0x0000000000000000 (XEN) IDTR: limit=0x00000fff, base=0xfffff88002ec2640 (XEN) TR: sel=0x0040, attr=0x0008b, limit=0x00000067, base=0xfffff88002ebbfc0 (XEN) Guest PAT = 0x0007010600070106 (XEN) TSC Offset = ffffff5e9aa5e538 (XEN) DebugCtl=0000000000000000 DebugExceptions=0000000000000000 (XEN) Interruptibility=0000 ActivityState=0000 (XEN) *** Host State *** (XEN) RSP = 0xffff83047113ff90 RIP = 0xffff82c4c01d7620 (XEN) CS=e008 DS=0000 ES=0000 FS=0000 GS=0000 SS=0000 TR=e040 (XEN) FSBase=0000000000000000 GSBase=0000000000000000 TRBase=ffff830471145c80 (XEN) GDTBase=ffff830471136000 IDTBase=ffff830471142000 (XEN) CR0=000000008005003b CR3=000000047f218000 CR4=00000000001426f0 (XEN) Sysenter RSP=ffff83047113ffc0 CS:RIP=e008:ffff82c4c0215950 (XEN) Host PAT = 0x0000050100070406 (XEN) *** Control State *** (XEN) PinBased=0000003f CPUBased=b6a065fa SecondaryExec=000054eb (XEN) EntryControls=000053ff ExitControls=000fefff (XEN) ExceptionBitmap=000400c0 (XEN) VMEntry: intr_info=000000d1 errcode=00000000 ilen=00000000 (XEN) VMExit: intr_info=00000000 errcode=00000000 ilen=00000000 (XEN) reason=0000000c qualification=00000000 (XEN) IDTVectoring: info=00000000 errcode=00000000 (XEN) TPR Threshold = 0x00 (XEN) EPT pointer = 0x0000000445c4801e (XEN) Virtual processor ID = 0x29a3 (XEN) VCPU 3 (XEN) *** Guest State *** (XEN) CR0: actual=0x0000000080050039, shadow=0x0000000080050031, gh_mask=ffffffffffffffff (XEN) CR4: actual=0x00000000000426f8, shadow=0x00000000000406f8, gh_mask=ffffffffffffffff (XEN) CR3: actual=0x0000000000187000, target_count=0 (XEN) target0=0000000000000000, target1=0000000000000000 (XEN) target2=0000000000000000, target3=0000000000000000 (XEN) RSP = 0xfffff88002f56b58 (0xfffff88002f56b58) RIP = 0xfffff880049889c1 (0xfffff880049889c2) (XEN) RFLAGS=0x0000000000000246 (0x0000000000000246) DR7 = 0x0000000000000400 (XEN) Sysenter RSP=0000000000000000 CS:RIP=0000:0000000000000000 (XEN) CS: sel=0x0010, attr=0x0209b, limit=0x00000000, base=0x0000000000000000 (XEN) DS: sel=0x002b, attr=0x0c0f3, limit=0xffffffff, base=0x0000000000000000 (XEN) SS: sel=0x0018, attr=0x0c093, limit=0xffffffff, base=0x0000000000000000 (XEN) ES: sel=0x002b, attr=0x0c0f3, limit=0xffffffff, base=0x0000000000000000 (XEN) FS: sel=0x0053, attr=0x040f3, limit=0x0000fc00, base=0x00000000fff6c000 (XEN) GS: sel=0x002b, attr=0x0c0f3, limit=0xffffffff, base=0xfffff88002f2e000 (XEN) GDTR: limit=0x0000007f, base=0xfffff88002f395c0 (XEN) LDTR: sel=0x0000, attr=0x1c000, limit=0xffffffff, base=0x0000000000000000 (XEN) IDTR: limit=0x00000fff, base=0xfffff88002f39640 (XEN) TR: sel=0x0040, attr=0x0008b, limit=0x00000067, base=0xfffff88002f32fc0 (XEN) Guest PAT = 0x0007010600070106 (XEN) TSC Offset = ffffff5e9aa5e78f (XEN) DebugCtl=0000000000000000 DebugExceptions=0000000000000000 (XEN) Interruptibility=0000 ActivityState=0000 (XEN) *** Host State *** (XEN) RSP = 0xffff83047c307f90 RIP = 0xffff82c4c01d7620 (XEN) CS=e008 DS=0000 ES=0000 FS=0000 GS=0000 SS=0000 TR=e040 (XEN) FSBase=0000000000000000 GSBase=0000000000000000 TRBase=ffff8304711f0c80 (XEN) GDTBase=ffff830471171000 IDTBase=ffff83047117d000 (XEN) CR0=000000008005003b CR3=000000047f217000 CR4=00000000001426f0 (XEN) Sysenter RSP=ffff83047c307fc0 CS:RIP=e008:ffff82c4c0215950 (XEN) Host PAT = 0x0000050100070406 (XEN) *** Control State *** (XEN) PinBased=0000003f CPUBased=b6a065fa SecondaryExec=000054eb (XEN) EntryControls=000053ff ExitControls=000fefff (XEN) ExceptionBitmap=000400c0 (XEN) VMEntry: intr_info=000000d1 errcode=00000000 ilen=00000000 (XEN) VMExit: intr_info=00000000 errcode=00000000 ilen=00000000 (XEN) reason=0000000c qualification=00000000 (XEN) IDTVectoring: info=00000000 errcode=00000000 (XEN) TPR Threshold = 0x00 (XEN) EPT pointer = 0x0000000445c4801e (XEN) Virtual processor ID = 0x22ba (XEN) VCPU 4 (XEN) *** Guest State *** (XEN) CR0: actual=0x0000000080050039, shadow=0x0000000080050031, gh_mask=ffffffffffffffff (XEN) CR4: actual=0x00000000000426f8, shadow=0x00000000000406f8, gh_mask=ffffffffffffffff (XEN) CR3: actual=0x0000000019d35000, target_count=0 (XEN) target0=0000000000000000, target1=0000000000000000 (XEN) target2=0000000000000000, target3=0000000000000000 (XEN) RSP = 0xfffff88004bcf680 (0xfffff88004bcf680) RIP = 0xfffff80002ada9ee (0xfffff80002ada9ee) (XEN) RFLAGS=0x0000000000000202 (0x0000000000000202) DR7 = 0x0000000000000400 (XEN) Sysenter RSP=0000000000000000 CS:RIP=0000:0000000000000000 (XEN) CS: sel=0x0010, attr=0x0209b, limit=0x00000000, base=0x0000000000000000 (XEN) DS: sel=0x002b, attr=0x0c0f3, limit=0xffffffff, base=0x0000000000000000 (XEN) SS: sel=0x0000, attr=0x1c000, limit=0xffffffff, base=0x0000000000000000 (XEN) ES: sel=0x002b, attr=0x0c0f3, limit=0xffffffff, base=0x0000000000000000 (XEN) FS: sel=0x0053, attr=0x040f3, limit=0x00013c00, base=0x00000000fffd7000 (XEN) GS: sel=0x002b, attr=0x0c0f3, limit=0xffffffff, base=0xfffff88002fa5000 (XEN) GDTR: limit=0x0000007f, base=0xfffff88002fb05c0 (XEN) LDTR: sel=0x0000, attr=0x1c000, limit=0xffffffff, base=0x0000000000000000 (XEN) IDTR: limit=0x00000fff, base=0xfffff88002fb0640 (XEN) TR: sel=0x0040, attr=0x0008b, limit=0x00000067, base=0xfffff88002fa9fc0 (XEN) Guest PAT = 0x0007010600070106 (XEN) TSC Offset = ffffff5e9aa5e74f (XEN) DebugCtl=0000000000000000 DebugExceptions=0000000000000000 (XEN) Interruptibility=0000 ActivityState=0000 (XEN) *** Host State *** (XEN) RSP = 0xffff83047115ff90 RIP = 0xffff82c4c01d7620 (XEN) CS=e008 DS=0000 ES=0000 FS=0000 GS=0000 SS=0000 TR=e040 (XEN) FSBase=0000000000000000 GSBase=0000000000000000 TRBase=ffff830471168c80 (XEN) GDTBase=ffff830471149000 IDTBase=ffff830471155000 (XEN) CR0=000000008005003b CR3=000000047f216000 CR4=00000000001426f0 (XEN) Sysenter RSP=ffff83047115ffc0 CS:RIP=e008:ffff82c4c0215950 (XEN) Host PAT = 0x0000050100070406 (XEN) *** Control State *** (XEN) PinBased=0000003f CPUBased=b6a065fa SecondaryExec=000054eb (XEN) EntryControls=000053ff ExitControls=000fefff (XEN) ExceptionBitmap=000400c0 (XEN) VMEntry: intr_info=000000d1 errcode=00000000 ilen=00000000 (XEN) VMExit: intr_info=00000000 errcode=00000000 ilen=00000000 (XEN) reason=00000028 qualification=00000000 (XEN) IDTVectoring: info=00000000 errcode=00000000 (XEN) TPR Threshold = 0x02 (XEN) EPT pointer = 0x0000000445c4801e (XEN) Virtual processor ID = 0x9216 (XEN) VCPU 5 (XEN) *** Guest State *** (XEN) CR0: actual=0x0000000080050039, shadow=0x0000000080050031, gh_mask=ffffffffffffffff (XEN) CR4: actual=0x00000000000426f8, shadow=0x00000000000406f8, gh_mask=ffffffffffffffff (XEN) CR3: actual=0x000000002320b000, target_count=0 (XEN) target0=0000000000000000, target1=0000000000000000 (XEN) target2=0000000000000000, target3=0000000000000000 (XEN) RSP = 0xfffff88002762950 (0xfffff88002762950) RIP = 0xfffff80002b0663c (0xfffff80002b0663c) (XEN) RFLAGS=0x0000000000000202 (0x0000000000000202) DR7 = 0x0000000000000400 (XEN) Sysenter RSP=0000000000000000 CS:RIP=0000:0000000000000000 (XEN) CS: sel=0x0010, attr=0x0209b, limit=0x00000000, base=0x0000000000000000 (XEN) DS: sel=0x002b, attr=0x0c0f3, limit=0xffffffff, base=0x0000000000000000 (XEN) SS: sel=0x0000, attr=0x1c000, limit=0xffffffff, base=0x0000000000000000 (XEN) ES: sel=0x002b, attr=0x0c0f3, limit=0xffffffff, base=0x0000000000000000 (XEN) FS: sel=0x0053, attr=0x040f3, limit=0x00017c00, base=0x00000000fffa8000 (XEN) GS: sel=0x002b, attr=0x0c0f3, limit=0xffffffff, base=0xfffff88002fdc000 (XEN) GDTR: limit=0x0000007f, base=0xfffff88002fe75c0 (XEN) LDTR: sel=0x0000, attr=0x1c000, limit=0xffffffff, base=0x0000000000000000 (XEN) IDTR: limit=0x00000fff, base=0xfffff88002fe7640 (XEN) TR: sel=0x0040, attr=0x0008b, limit=0x00000067, base=0xfffff88002fe0fc0 (XEN) Guest PAT = 0x0007010600070106 (XEN) TSC Offset = ffffff5e9aa5e7a3 (XEN) DebugCtl=0000000000000000 DebugExceptions=0000000000000000 (XEN) Interruptibility=0000 ActivityState=0000 (XEN) *** Host State *** (XEN) RSP = 0xffff83047c307f90 RIP = 0xffff82c4c01d7620 (XEN) CS=e008 DS=0000 ES=0000 FS=0000 GS=0000 SS=0000 TR=e040 (XEN) FSBase=0000000000000000 GSBase=0000000000000000 TRBase=ffff8304711f0c80 (XEN) GDTBase=ffff830471171000 IDTBase=ffff83047117d000 (XEN) CR0=000000008005003b CR3=000000047f215000 CR4=00000000001426f0 (XEN) Sysenter RSP=ffff83047c307fc0 CS:RIP=e008:ffff82c4c0215950 (XEN) Host PAT = 0x0000050100070406 (XEN) *** Control State *** (XEN) PinBased=0000003f CPUBased=b6a065fa SecondaryExec=000054eb (XEN) EntryControls=000053ff ExitControls=000fefff (XEN) ExceptionBitmap=000400c0 (XEN) VMEntry: intr_info=000000d1 errcode=00000000 ilen=00000000 (XEN) VMExit: intr_info=800000fc errcode=00000000 ilen=00000000 (XEN) reason=00000001 qualification=00000000 (XEN) IDTVectoring: info=00000000 errcode=00000000 (XEN) TPR Threshold = 0x02 (XEN) EPT pointer = 0x0000000445c4801e (XEN) Virtual processor ID = 0x22bd (XEN) ************************************** (XEN) [z: print ioapic info] (XEN) number of MP IRQ sources: 15. (XEN) number of IO-APIC #8 registers: 24. (XEN) testing the IO APIC....................... (XEN) IO APIC #8...... (XEN) .... register #00: 08000000 (XEN) ....... : physical APIC id: 08 (XEN) ....... : Delivery Type: 0 (XEN) ....... : LTS : 0 (XEN) .... register #01: 00170020 (XEN) ....... : max redirection entries: 0017 (XEN) ....... : PRQ implemented: 0 (XEN) ....... : IO APIC version: 0020 (XEN) .... IRQ redirection table: (XEN) NR Log Phy Mask Trig IRR Pol Stat Dest Deli Vect: (XEN) 00 000 00 1 0 0 0 0 0 7 00 (XEN) 01 000 00 0 0 0 0 0 1 1 62 (XEN) 02 000 00 0 0 0 0 0 1 1 F0 (XEN) 03 000 00 1 0 0 0 0 1 1 38 (XEN) 04 000 00 0 0 0 0 0 1 1 F1 (XEN) 05 000 00 0 0 0 0 0 1 1 40 (XEN) 06 000 00 0 0 0 0 0 1 1 48 (XEN) 07 000 00 0 0 0 0 0 1 1 50 (XEN) 08 000 00 0 0 0 0 0 1 1 58 (XEN) 09 000 00 0 1 0 0 0 1 1 60 (XEN) 0a 000 00 0 0 0 0 0 1 1 68 (XEN) 0b 000 00 0 0 0 0 0 1 1 70 (XEN) 0c 000 00 0 0 0 0 0 1 1 78 (XEN) 0d 000 00 1 0 0 0 0 1 1 88 (XEN) 0e 000 00 0 0 0 0 0 1 1 90 (XEN) 0f 000 00 0 0 0 0 0 1 1 98 (XEN) 10 000 00 0 1 0 1 0 1 1 A0 (XEN) 11 000 00 0 1 0 1 0 1 1 31 (XEN) 12 000 00 1 1 0 1 0 1 1 C8 (XEN) 13 000 00 0 1 0 1 0 1 1 D8 (XEN) 14 000 00 0 1 0 1 0 1 1 A8 (XEN) 15 000 00 1 0 0 0 0 0 0 00 (XEN) 16 000 00 1 0 0 0 0 0 0 00 (XEN) 17 000 00 0 1 1 1 1 1 1 B0 (XEN) Using vector-based indexing (XEN) IRQ to pin mappings: (XEN) IRQ240 -> 0:2 (XEN) IRQ98 -> 0:1 (XEN) IRQ56 -> 0:3 (XEN) IRQ241 -> 0:4 (XEN) IRQ64 -> 0:5 (XEN) IRQ72 -> 0:6 (XEN) IRQ80 -> 0:7 (XEN) IRQ88 -> 0:8 (XEN) IRQ96 -> 0:9 (XEN) IRQ104 -> 0:10 (XEN) IRQ112 -> 0:11 (XEN) IRQ120 -> 0:12 (XEN) IRQ136 -> 0:13 (XEN) IRQ144 -> 0:14 (XEN) IRQ152 -> 0:15 (XEN) IRQ160 -> 0:16 (XEN) IRQ49 -> 0:17 (XEN) IRQ200 -> 0:18 (XEN) IRQ216 -> 0:19 (XEN) IRQ168 -> 0:20 (XEN) IRQ176 -> 0:23 (XEN) .................................... done. (XEN) '*' pressed -> firing all diagnostic keyhandlers (XEN) [d: dump registers] (XEN) 'd' pressed -> dumping registers (XEN) (XEN) *** Dumping CPU0 guest state (d1:v0): *** (XEN) ----[ Xen-4.3.0 x86_64 debug=n Not tainted ]---- (XEN) CPU: 0 (XEN) RIP: 0033:[<000007fef3e2f83f>] (XEN) RFLAGS: 0000000000000212 CONTEXT: hvm guest (XEN) rax: 000000001f0e3e20 rbx: 000007fef3efbd60 rcx: 0000000000000000 (XEN) rdx: 0000000000000000 rsi: 00000000208aa1e0 rdi: 000000001f1a7ce8 (XEN) rbp: 000000001f1a4488 rsp: 00000000208aa0a0 r8: 0000000000000006 (XEN) r9: 0000000000000008 r10: 000000001e009d40 r11: 0000000000000000 (XEN) r12: 000000001f1a82f8 r13: 000000000000000e r14: 0000000000000020 (XEN) r15: 0000000000000004 cr0: 0000000080050031 cr4: 00000000000406f8 (XEN) cr3: 0000000073799000 cr2: 000007fef4bffb50 (XEN) ds: 002b es: 002b fs: 0053 gs: 002b ss: 002b cs: 0033 (XEN) (XEN) *** Dumping CPU1 host state: *** (XEN) ----[ Xen-4.3.0 x86_64 debug=n Not tainted ]---- (XEN) CPU: 1 (XEN) RIP: e008:[] mwait_idle+0x211/0x350 (XEN) RFLAGS: 0000000000000202 CONTEXT: hypervisor (XEN) rax: ffff8304711f6020 rbx: ffff8304711fde10 rcx: 000000319e1b773d (XEN) rdx: ffff83047c308000 rsi: 000000319e1b773d rdi: ffff8304711fde38 (XEN) rbp: 000000319e1b773d rsp: ffff83047c30fe70 r8: 000000316ab1f955 (XEN) r9: 000000e014f0b73f r10: 0000000000000001 r11: ffff82c4c0300710 (XEN) r12: 0000000000000004 r13: 0000000000000001 r14: ffff82c4c02ea940 (XEN) r15: ffff8304711fde80 cr0: 0000000080050033 cr4: 00000000001426f0 (XEN) cr3: 000000047fcc8000 cr2: 000007fef4dd8480 (XEN) ds: 0000 es: 0000 fs: 0000 gs: 0000 ss: e010 cs: e008 (XEN) Xen stack trace from rsp=ffff83047c30fe70: (XEN) ffff8304711f6080 000000319a27cbf7 ffff82c4c0300710 0000001081801da0 (XEN) 000000d100000161 0000000000000000 0000000000000000 ffff83047c308000 (XEN) 00000000ffffffff ffff82c4c02c7800 ffff83047c308000 ffff83047c308000 (XEN) ffff83047c308000 00000000ffffffff ffff82c4c02ea940 0000000000000002 (XEN) ffffffffffffffff ffff82c4c015805e ffffffff81801fd8 ffff830064593000 (XEN) ffff8300735e3000 0000000000000000 ffffffff81801fd8 ffffffff81801fd8 (XEN) ffffffff81801fd8 0000000000000000 ffffffff81801fd8 0000000000000246 (XEN) ffff88003e400000 0000000000000000 0000000000000000 0000000000000000 (XEN) ffffffff810013aa 0000000000000001 0000000000000000 0000000000000001 (XEN) 0000010000000000 ffffffff810013aa 000000000000e033 0000000000000246 (XEN) ffffffff81801e98 000000000000e02b 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000001 ffff830064593000 (XEN) 0000003fb0ef5a00 0000000000000000 (XEN) Xen call trace: (XEN) [] mwait_idle+0x211/0x350 (XEN) [] idle_loop+0x1e/0x50 (XEN) (XEN) *** Dumping CPU2 host state: *** (XEN) ----[ Xen-4.3.0 x86_64 debug=n Not tainted ]---- (XEN) CPU: 2 (XEN) RIP: e008:[] mwait_idle+0x211/0x350 (XEN) RFLAGS: 0000000000000202 CONTEXT: hypervisor (XEN) rax: ffff8304711f0020 rbx: ffff8304711f26a0 rcx: 00000031b2a81726 (XEN) rdx: ffff83047c300000 rsi: 00000031b2a81726 rdi: ffff8304711f26c8 (XEN) rbp: 00000031b2a81726 rsp: ffff83047c307e70 r8: 000000316ab1f955 (XEN) r9: 0000000000000530 r10: 0000000000000001 r11: ffff82c4c0300710 (XEN) r12: 0000000000000008 r13: 0000000000000002 r14: ffff82c4c02ea940 (XEN) r15: ffff8304711f2730 cr0: 0000000080050033 cr4: 00000000001426f0 (XEN) cr3: 000000047f216000 cr2: fffff9800aab0000 (XEN) ds: 0000 es: 0000 fs: 0000 gs: 0000 ss: 0000 cs: e008 (XEN) Xen stack trace from rsp=ffff83047c307e70: (XEN) ffff8304711f0080 0000003194ba8806 ffff82c4c0300710 00000020027f7c00 (XEN) 0000035a00000578 0000000000000000 0000000000000000 ffff83047c300000 (XEN) 00000000ffffffff ffff82c4c02c7800 ffff83047c300000 ffff83047c300000 (XEN) ffff83047c300000 00000000ffffffff ffff82c4c02ea940 0000000000000002 (XEN) ffffffffffffffff ffff82c4c015805e fffffa80027f7fa0 ffff8300643fe000 (XEN) ffff8300643fb000 0000000000000001 fffffa80027f7f00 fffffa80027f7c00 (XEN) fffffa80027f7fa0 0000000000000000 0000000000000000 fffff88002fcdaa0 (XEN) 000000000987b974 0000002cf4149b68 0000000000000000 0000000009cf98c0 (XEN) fffffa80027f4130 fffffa80027f7fc8 fffff88002fa5180 0000000000000001 (XEN) 000000fc00000000 fffff880049889c2 0000000000000000 0000000000000246 (XEN) fffff88002fcdb58 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000002 ffff8300643fe000 (XEN) 0000003fb0eefa00 0000000000000000 (XEN) Xen call trace: (XEN) [] mwait_idle+0x211/0x350 (XEN) [] idle_loop+0x1e/0x50 (XEN) (XEN) *** Dumping CPU3 host state: *** (XEN) ----[ Xen-4.3.0 x86_64 debug=n Not tainted ]---- (XEN) CPU: 3 (XEN) RIP: e008:[] mwait_idle+0x211/0x350 (XEN) RFLAGS: 0000000000000202 CONTEXT: hypervisor (XEN) rax: ffff83047117b020 rbx: ffff8304711f2e90 rcx: 00000031c73463b8 (XEN) rdx: ffff830471170000 rsi: 00000031c73463b8 rdi: ffff8304711f2eb8 (XEN) rbp: 00000031c73463b8 rsp: ffff830471177e70 r8: 000000316ab1f955 (XEN) r9: 0000000000000530 r10: 0000000000000001 r11: ffff82c4c0300710 (XEN) r12: 0000000000000010 r13: 0000000000000003 r14: ffff82c4c02ea940 (XEN) r15: ffff8304711f2f40 cr0: 0000000080050033 cr4: 00000000001426f0 (XEN) cr3: 000000047f219000 cr2: 000007fef20b3a14 (XEN) ds: 0000 es: 0000 fs: 0000 gs: 0000 ss: 0000 cs: e008 (XEN) Xen stack trace from rsp=ffff830471177e70: (XEN) ffff83047117b080 0000003195daa9be ffff82c4c0300710 00000032027f3c00 (XEN) 000023d2000009d5 0000000000000000 0000000000000000 ffff830471170000 (XEN) 00000000ffffffff ffff82c4c02c7800 ffff830471170000 ffff830471170000 (XEN) ffff830471170000 00000000ffffffff ffff82c4c02ea940 0000000000000002 (XEN) ffffffffffffffff ffff82c4c015805e fffffa80027f3fa0 ffff830073303000 (XEN) ffff83006458a000 0000000000000001 fffffa80027f3f00 fffffa80027f3c00 (XEN) fffffa80027f3fa0 0000000000000000 0000000000000000 000000000c1f47e8 (XEN) 000000000c420af8 00000000075ad361 0000000000000000 000000384b0483f2 (XEN) fffffa80027d5a30 fffffa80027f3fc8 fffff88002e40180 0000000000000001 (XEN) 000000fc00000000 fffff880049889c2 0000000000000000 0000000000000246 (XEN) fffff88002e68b58 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000003 ffff830073303000 (XEN) 0000003fb0e7aa00 0000000000000000 (XEN) Xen call trace: (XEN) [] mwait_idle+0x211/0x350 (XEN) [] idle_loop+0x1e/0x50 (XEN) (XEN) *** Dumping CPU4 host state: *** (XEN) ----[ Xen-4.3.0 x86_64 debug=n Not tainted ]---- (XEN) CPU: 4 (XEN) RIP: e008:[] mwait_idle+0x211/0x350 (XEN) RFLAGS: 0000000000000202 CONTEXT: hypervisor (XEN) rax: ffff83047116d020 rbx: ffff83047116f690 rcx: 00000031dbc0fbd1 (XEN) rdx: ffff830471160000 rsi: 00000031dbc0fbd1 rdi: ffff83047116f6b8 (XEN) rbp: 00000031dbc0fbd1 rsp: ffff830471167e70 r8: 000000316ab1f955 (XEN) r9: 000000e014f0b671 r10: 0000000000000002 r11: ffff82c4c0300710 (XEN) r12: 0000000000000010 r13: 0000000000000004 r14: ffff82c4c02ea940 (XEN) r15: ffff83047116f740 cr0: 0000000080050033 cr4: 00000000001426f0 (XEN) cr3: 000000047fcc8000 cr2: 000007feedaaac40 (XEN) ds: 002b es: 002b fs: 0000 gs: 0000 ss: e010 cs: e008 (XEN) Xen stack trace from rsp=ffff830471167e70: (XEN) ffff83047116d080 00000031bf9692a7 ffff82c4c0300710 000000322e543db0 (XEN) 0002139200000920 0000000000000000 0000000000000000 ffff830471160000 (XEN) 00000000ffffffff ffff82c4c02c7800 ffff830471160000 ffff830471160000 (XEN) ffff830471160000 00000000ffffffff ffff82c4c02ea940 0000000000000002 (XEN) ffffffffffffffff ffff82c4c015805e ffff88002e543fd8 ffff830073302000 (XEN) ffff8300735e1000 0000000000000000 ffff88002e543fd8 ffff88002e543fd8 (XEN) ffff88002e543fd8 0000000000000002 ffff88002e543fd8 0000000000000246 (XEN) 0000000000000029 0000000000000000 0000000000000000 0000000000000000 (XEN) ffffffff810013aa 0000000000000001 0000000000000000 0000000000000001 (XEN) 0000010000000000 ffffffff810013aa 000000000000e033 0000000000000246 (XEN) ffff88002e543ed8 000000000000e02b 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000004 ffff830073302000 (XEN) 0000003fb0e6ca00 0000000000000000 (XEN) Xen call trace: (XEN) [] mwait_idle+0x211/0x350 (XEN) [] idle_loop+0x1e/0x50 (XEN) (XEN) *** Dumping CPU5 host state: *** (XEN) ----[ Xen-4.3.0 x86_64 debug=n Not tainted ]---- (XEN) CPU: 5 (XEN) RIP: e008:[] mwait_idle+0x211/0x350 (XEN) RFLAGS: 0000000000000202 CONTEXT: hypervisor (XEN) rax: ffff830471168020 rbx: ffff83047116fe80 rcx: 00000031f04d4e3b (XEN) rdx: ffff830471158000 rsi: 00000031f04d4e3b rdi: ffff83047116fea8 (XEN) rbp: 00000031f04d4e3b rsp: ffff83047115fe70 r8: 000000316ab1f955 (XEN) r9: 0000000000000428 r10: 0000000000000002 r11: ffff82c4c0300710 (XEN) r12: 0000000000000004 r13: 0000000000000005 r14: ffff82c4c02ea940 (XEN) r15: ffff83047116fef0 cr0: 000000008005003b cr4: 00000000001426f0 (XEN) cr3: 000000007325e000 cr2: 000007feeda33140 (XEN) ds: 0000 es: 0000 fs: 0000 gs: 0000 ss: 0000 cs: e008 (XEN) Xen stack trace from rsp=ffff83047115fe70: (XEN) ffffffffffffffff 00000031f041b6a7 ffff82c4c0300710 0000001075337890 (XEN) 000001c100000419 0000000000000000 0000000000000000 ffff82c4c0126ef0 (XEN) ffffffffffffffff 00000000ffffffff ffff82c4c02c7800 ffff830471158000 (XEN) ffff830471158000 00000000ffffffff ffff82c4c02ea940 0000000000000002 (XEN) ffffffffffffffff ffff82c4c015805e fffffa80027efad0 ffff8300730fd000 (XEN) ffff830064588000 0000000000000001 fffffa80027efa00 fffffa80027f6000 (XEN) fffffa80027efad0 0000000000000000 0000000000000000 fffffa800187de5e (XEN) 00000000072ed478 000000375a8e3d71 0000000000000000 0000000009cf98c0 (XEN) fffffa80027f3470 fffffa80027efaf8 fffff88002f2e180 0000000000000001 (XEN) 000000fc00000000 fffff880049889c2 0000000000000000 0000000000000246 (XEN) fffff88002f56b58 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000005 ffff8300730fd000 (XEN) 0000003fb0e67a00 0000000000000000 (XEN) Xen call trace: (XEN) [] mwait_idle+0x211/0x350 (XEN) [] tasklet_softirq_action+0x40/0x70 (XEN) [] idle_loop+0x1e/0x50 (XEN) (XEN) *** Dumping CPU6 host state: *** (XEN) ----[ Xen-4.3.0 x86_64 debug=n Not tainted ]---- (XEN) CPU: 6 (XEN) RIP: e008:[] mwait_idle+0x211/0x350 (XEN) RFLAGS: 0000000000000202 CONTEXT: hypervisor (XEN) rax: ffff830471152020 rbx: ffff830471154690 rcx: 000000320583078d (XEN) rdx: ffff830471148000 rsi: 000000320583078d rdi: ffff8304711546b8 (XEN) rbp: 000000320583078d rsp: ffff83047114fe70 r8: 000000316ab1f955 (XEN) r9: 000000e014f0b686 r10: 0000000000000002 r11: ffff82c4c0300710 (XEN) r12: 0000000000000004 r13: 0000000000000006 r14: ffff82c4c02ea940 (XEN) r15: ffff830471154700 cr0: 0000000080050033 cr4: 00000000001426f0 (XEN) cr3: 000000046d80c000 cr2: 000007feede17e6c (XEN) ds: 002b es: 002b fs: 0000 gs: 0000 ss: e010 cs: e008 (XEN) Xen stack trace from rsp=ffff83047114fe70: (XEN) ffff830471152080 00000031fbe8266e ffff82c4c0300710 000000102e53fdb0 (XEN) 0000010000000165 0000000000000000 0000000000000000 ffff830471148000 (XEN) 00000000ffffffff ffff82c4c02c7800 ffff830471148000 ffff830471148000 (XEN) ffff830471148000 00000000ffffffff ffff82c4c02ea940 0000000000000002 (XEN) ffffffffffffffff ffff82c4c015805e ffff88002e53ffd8 ffff8300730fc000 (XEN) ffff8300735e2000 0000000000000000 ffff88002e53ffd8 ffff88002e53ffd8 (XEN) ffff88002e53ffd8 0000000000000001 ffff88002e53ffd8 0000000000000246 (XEN) 000000000000002a 0000000000000000 0000000000000000 0000000000000000 (XEN) ffffffff810013aa 0000000000000001 0000000000000000 0000000000000001 (XEN) 0000010000000000 ffffffff810013aa 000000000000e033 0000000000000246 (XEN) ffff88002e53fed8 000000000000e02b 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000006 ffff8300730fc000 (XEN) 0000003fb0e51a00 0000000000000000 (XEN) Xen call trace: (XEN) [] mwait_idle+0x211/0x350 (XEN) [] idle_loop+0x1e/0x50 (XEN) (XEN) *** Dumping CPU7 host state: *** (XEN) ----[ Xen-4.3.0 x86_64 debug=n Not tainted ]---- (XEN) CPU: 7 (XEN) RIP: e008:[] vcpu_sleep_sync+0x39/0x50 (XEN) RFLAGS: 0000000000000202 CONTEXT: hypervisor (XEN) rax: 0000000000000001 rbx: ffff83006458b000 rcx: ffff83006458b128 (XEN) rdx: 0000000000000000 rsi: 0000000000000008 rdi: ffff82c4c0300668 (XEN) rbp: 0000000000000100 rsp: ffff83047113fdd8 r8: 0000000000000004 (XEN) r9: 0000000000000000 r10: 0000000000000038 r11: 0000000000000282 (XEN) r12: 00000000000f0000 r13: ffff83040842f200 r14: ffff82c4c03014c8 (XEN) r15: 0000000000000800 cr0: 0000000080050033 cr4: 00000000001426f0 (XEN) cr3: 000000047fcc8000 cr2: 0000000024393a3a (XEN) ds: 0000 es: 0000 fs: 0000 gs: 0000 ss: e010 cs: e008 (XEN) Xen stack trace from rsp=ffff83047113fdd8: (XEN) ffff83006458b000 ffff82c4c01055b8 ffff830441c40000 ffff82c4c0208490 (XEN) 0000000000000000 00007f63458f7004 00000000000f0000 ffff830441c40ab8 (XEN) ffff830073307000 ffff830073307060 ffff82c4c012747b 0000000000000006 (XEN) 00007f63458fe004 00007fff4b9ab6e0 ffff830471131000 0000000000000001 (XEN) ffffffffffffffea ffff82c4c01b2b5a ffff82c4c0154b75 ffff830073307060 (XEN) 00000031970d4904 ffff82c4c0154b75 ffff88002e547e28 ffff82c4c0210488 (XEN) ffff83047113ff18 ffff82c4c0210560 ffff830471138000 ffff830441c40000 (XEN) 0000000000000001 00000000000f0000 0000000000000800 00007f63458f7004 (XEN) 0000000000000033 ffff830073307000 ffff880004061050 00007fff4b9ab6e0 (XEN) 00007fff4b9ab6e0 0000000000000001 00007fff4b9ab6b0 ffff82c4c0215819 (XEN) ffff88003e50e9c0 000000000000e1e0 ffff88003e50e1e0 0000000000000000 (XEN) ffff880004061050 ffff88002bf4eec0 0000000000000282 0000000000000006 (XEN) 00000000f0000000 00000000000d1040 0000000000000022 ffffffff8100144a (XEN) 00007f6345c6edac 00007f63458fe004 0000000000000006 0001010000000000 (XEN) ffffffff8100144a 000000000000e033 0000000000000282 ffff880003d15e50 (XEN) 000000000000e02b 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000007 ffff830073307000 0000003fb0e44a00 (XEN) 0000000000000000 (XEN) Xen call trace: (XEN) [] vcpu_sleep_sync+0x39/0x50 (XEN) [] domain_pause+0x28/0x40 (XEN) [] hap_track_dirty_vram+0x360/0x4f0 (XEN) [] add_entry+0x4b/0xb0 (XEN) [] do_hvm_op+0x1b3a/0x1f20 (XEN) [] reprogram_timer+0x75/0xe0 (XEN) [] reprogram_timer+0x75/0xe0 (XEN) [] toggle_guest_mode+0x28/0x40 (XEN) [] do_iret+0xc0/0x1a0 (XEN) [] syscall_enter+0xa9/0xae (XEN) (XEN) *** Dumping CPU7 guest state (d0:v4): *** (XEN) ----[ Xen-4.3.0 x86_64 debug=n Not tainted ]---- (XEN) CPU: 7 (XEN) RIP: e033:[] (XEN) RFLAGS: 0000000000000282 EM: 0 CONTEXT: pv guest (XEN) rax: 0000000000000022 rbx: ffff88002bf4eec0 rcx: ffffffff8100144a (XEN) rdx: 00007f6345c6edac rsi: 00007f63458fe004 rdi: 0000000000000006 (XEN) rbp: ffff880004061050 rsp: ffff880003d15e50 r8: 00000000000d1040 (XEN) r9: 00000000f0000000 r10: 0000000000000006 r11: 0000000000000282 (XEN) cr0: 0000000080050033 cr4: 00000000001426f0 (XEN) cr3: 000000047fcc8000 cr2: 00007ff745325f44 (XEN) ds: 0000 es: 0000 fs: 0000 gs: 0000 ss: e02b cs: e033 (XEN) Guest stack trace from rsp=ffff880003d15e50: (XEN) 0000000000000246 0000000000000000 ffffffffa03b6927 0000000000000019 (XEN) 0000000000000000 ffff880003d15c70 ffff88003d929da0 ffffffff81491517 (XEN) 0000000000000022 0000000000000006 00007f63458fe004 00007f6345c6edac (XEN) 0000000000000006 00000000000d1040 ffff88002bf4eec0 ffff880004061050 (XEN) 00007fff4b9ab6e0 00007fff4b9ab6e0 ffffffff81184e64 000000007fffffff (XEN) 00007f6345cf3297 ffffffff811b80e2 0000000000000000 ffff88002be83ac0 (XEN) 00007fff4b9abab0 ffffffff81173074 ffff88002be83ac0 ffff88002bf4eec0 (XEN) 000000000000000b 0000000000305000 ffffffff811850c0 00007fff4b9aba90 (XEN) 00000001464f5998 00007f6346b49110 00007f63458fe004 0000000000000800 (XEN) 00007fff4b9ab680 0000000000000001 ffffffff81498fb9 0000000000000246 (XEN) 0000000000800000 00000000f0000000 0000000000000000 0000000000000010 (XEN) 00007fff4b9fe7c2 00007fff4b9ab6e0 0000000000305000 000000000000000b (XEN) 0000000000000010 00007f63407fb567 000000000000e033 0000000000000246 (XEN) 00007fff4b9ab668 000000000000e02b 2e2e2f2e2e2f2e2e 2e2f2e2e2f2e2e2f (XEN) 2f2e2e2f2e2e2f2e 7373616c632f2e2e 00006b636f6c622f 0000000000000000 (XEN) 0000000000000000 0000000000000000 ffff8800038e5000 ffff880003fc7000 (XEN) 0000000000000080 ffff880003d16080 ffffffff00000002 0000000000000000 (XEN) ffffffff00000001 0000000000000000 0000000000000001 ffff88000478e000 (XEN) 0040210000000002 0000000000000000 0000000000000000 0000000000000000 (XEN) ffff88002b30c840 0000000000000000 00000000ffffa638 0000007800000000 (XEN) (XEN) [0: dump Dom0 registers] (XEN) '0' pressed -> dumping Dom0's registers (XEN) *** Dumping Dom0 vcpu#0 state: *** (XEN) RIP: e033:[] (XEN) RFLAGS: 0000000000000246 EM: 0 CONTEXT: pv guest (XEN) rax: 0000000000000000 rbx: ffffffff81801fd8 rcx: ffffffff810013aa (XEN) rdx: 0000000000000001 rsi: 0000000000000000 rdi: 0000000000000001 (XEN) rbp: 0000000000000000 rsp: ffffffff81801e98 r8: 0000000000000000 (XEN) r9: 0000000000000000 r10: ffff88003e400000 r11: 0000000000000246 (XEN) r12: ffffffff81801fd8 r13: ffffffff81801fd8 r14: ffffffff81801fd8 (XEN) r15: 0000000000000000 cr0: 0000000000000000 cr4: 0000000000042660 (XEN) cr3: 000000047fcc8000 cr2: 00007f6465cfbfb8 (XEN) ds: 0000 es: 0000 fs: 0000 gs: 0000 ss: e02b cs: e033 (XEN) Guest stack trace from rsp=ffffffff81801e98: (XEN) 0000000000000000 0100000000000000 ffffffff8100992c ffffffff8101a6b4 (XEN) ffffffff81801fd8 ffffffff818a0fc0 ffffffff810a457e ffffffff81801fd8 (XEN) ffffffff81801fd8 d621a9a087876718 ffffffffffffffff ffffffff8194b900 (XEN) ffffffff819542c0 ffff88003e831f40 0000000000000000 0000000000000000 (XEN) ffffffff818c0eb8 ffffffff818c08b3 ffffffff819542c0 ffffffff81801f68 (XEN) 00000000ffffffff 0000000000000000 0000000000000000 ffffffff818c2d26 (XEN) 000306c300000000 0000000100100800 0300000100000032 0000000000000005 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 (XEN) *** Dumping Dom0 vcpu#1 state: *** (XEN) RIP: e033:[] (XEN) RFLAGS: 0000000000000246 EM: 0 CONTEXT: pv guest (XEN) rax: 0000000000000000 rbx: ffff88002e53ffd8 rcx: ffffffff810013aa (XEN) rdx: 0000000000000001 rsi: 0000000000000000 rdi: 0000000000000001 (XEN) rbp: 0000000000000001 rsp: ffff88002e53fed8 r8: 0000000000000000 (XEN) r9: 0000000000000000 r10: 000000000000002b r11: 0000000000000246 (XEN) r12: ffff88002e53ffd8 r13: ffff88002e53ffd8 r14: ffff88002e53ffd8 (XEN) r15: 0000000000000000 cr0: 0000000080050033 cr4: 0000000000042660 (XEN) cr3: 000000046d80c000 cr2: 00007f68ad17b430 (XEN) ds: 002b es: 002b fs: 0000 gs: 0000 ss: e02b cs: e033 (XEN) Guest stack trace from rsp=ffff88002e53fed8: (XEN) ffff88002e569028 0100000000000000 ffffffff8100992c ffffffff8101a6b4 (XEN) ffff88002e53ffd8 ffffffff818a0fc0 ffffffff810a457e ffff88002e53ffd8 (XEN) ffff88002e53ffd8 4e6bbde87666fa33 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 ffffffffffffffff (XEN) 0000000000000000 0000000000000010 0000000000000202 ffff88002e53ff58 (XEN) 0000000000000018 (XEN) *** Dumping Dom0 vcpu#2 state: *** (XEN) RIP: e033:[] (XEN) RFLAGS: 0000000000000246 EM: 0 CONTEXT: pv guest (XEN) rax: 0000000000000000 rbx: ffff88002e543fd8 rcx: ffffffff810013aa (XEN) rdx: 0000000000000001 rsi: 0000000000000000 rdi: 0000000000000001 (XEN) rbp: 0000000000000002 rsp: ffff88002e543ed8 r8: 0000000000000000 (XEN) r9: 0000000000000000 r10: ffff88003e480000 r11: 0000000000000246 (XEN) r12: ffff88002e543fd8 r13: ffff88002e543fd8 r14: ffff88002e543fd8 (XEN) r15: 0000000000000000 cr0: 0000000080050033 cr4: 0000000000042660 (XEN) cr3: 000000047fcc8000 cr2: 00007f6465ae3000 (XEN) ds: 002b es: 002b fs: 0000 gs: 0000 ss: e02b cs: e033 (XEN) Guest stack trace from rsp=ffff88002e543ed8: (XEN) 0000000000000000 0100000000000000 ffffffff8100992c ffffffff8101a6b4 (XEN) ffff88002e543fd8 ffffffff818a0fc0 ffffffff810a457e ffff88002e543fd8 (XEN) ffff88002e543fd8 cd16d26e7c353277 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 ffffffffffffffff (XEN) 0000000000000000 0000000000000010 0000000000000202 ffff88002e543f58 (XEN) 0000000000000018 (XEN) *** Dumping Dom0 vcpu#3 state: *** (XEN) RIP: e033:[] (XEN) RFLAGS: 0000000000000246 EM: 0 CONTEXT: pv guest (XEN) rax: 0000000000000000 rbx: ffff88002e545fd8 rcx: ffffffff810013aa (XEN) rdx: 0000000000000001 rsi: 0000000000000000 rdi: 0000000000000001 (XEN) rbp: 0000000000000003 rsp: ffff88002e545ed8 r8: 0000000000000000 (XEN) r9: 0000000000000000 r10: ffff88003e4c0000 r11: 0000000000000246 (XEN) r12: ffff88002e545fd8 r13: ffff88002e545fd8 r14: ffff88002e545fd8 (XEN) r15: 0000000000000000 cr0: 0000000080050033 cr4: 0000000000042660 (XEN) cr3: 000000046d80c000 cr2: 00007f646560c0e0 (XEN) ds: 002b es: 002b fs: 0000 gs: 0000 ss: e02b cs: e033 (XEN) Guest stack trace from rsp=ffff88002e545ed8: (XEN) 0000000000000000 0100000000000000 ffffffff8100992c ffffffff8101a6b4 (XEN) ffff88002e545fd8 ffffffff818a0fc0 ffffffff810a457e ffff88002e545fd8 (XEN) ffff88002e545fd8 d83d337713cdb13a 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 ffffffffffffffff (XEN) 0000000000000000 0000000000000010 0000000000000202 ffff88002e545f58 (XEN) 0000000000000018 (XEN) *** Dumping Dom0 vcpu#4 state: *** (XEN) RIP: e033:[] (XEN) RFLAGS: 0000000000000246 EM: 1 CONTEXT: pv guest (XEN) rax: ffff88002d6f9180 rbx: ffff880004495418 rcx: 0000000000000000 (XEN) rdx: ffff88002b3e6640 rsi: ffff88002d6f9000 rdi: ffff88002bd21040 (XEN) rbp: ffff880003ea5dc0 rsp: ffff88000008dd88 r8: ffff88002bd22000 (XEN) r9: dffe8ebc25510640 r10: ffff880003e36400 r11: ffff880003e36400 (XEN) r12: 0000000080000000 r13: ffffea0000000000 r14: 000077ff80000000 (XEN) r15: ffff8800044954d8 cr0: 0000000080050033 cr4: 0000000000042660 (XEN) cr3: 000000047fcc8000 cr2: 00007ff745325f44 (XEN) ds: 0000 es: 0000 fs: 0000 gs: 0000 ss: e02b cs: e033 (XEN) Guest stack trace from rsp=ffff88000008dd88: (XEN) 00000000ffffffe6 ffff880004495400 ffff88002b3e6640 0000000000000018 (XEN) ffff880003ea5dc0 0000000000000018 ffff880004495418 ffffffff8115c37a (XEN) 0000000081491551 ffff88002b3e6640 ffff880003ea5dc0 ffff88003e513b40 (XEN) 0000000000000000 0000000000000000 0000000000000000 ffffffff8115c7da (XEN) ffff88003e510640 ffff88003e510640 ffff88002e5baec0 ffff88003e513b40 (XEN) ffff88003e517500 0000000000000000 0000000000000100 ffffffff810746cd (XEN) 000000000008dfd8 ffff88003e513b58 ffff88002e5baef0 ffff88002e6f4080 (XEN) ffff88002e6f4080 ffff88003e513b40 ffff88002e5baec0 ffffffff81075296 (XEN) ffff88002e6f4080 ffff88002e6f4080 00000000000142c0 ffff88000008dfd8 (XEN) ffff88002e63bd68 ffff88002e5baec0 ffffffff81075180 0000000000000000 (XEN) 0000000000000000 0000000000000000 ffffffff8107b78f 0000000000000000 (XEN) ffff88003e451780 ffff88002e5baec0 ffffffff00000000 ffff880000000000 (XEN) ffff88000008df08 ffff88000008df08 ffff880000000000 ffff880000000000 (XEN) ffff88000008df28 ffff88000008df28 ffffffff8107b6e0 ffff88002e63bd68 (XEN) 0000000000000000 ffffffff81498f0c 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 ffff88002e63bd68 ffffffff8107b6e0 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 ffffffffffffffff 0000000000000000 0000000000000010 (XEN) 0000000000000202 ffff88000008df58 0000000000000018 (XEN) *** Dumping Dom0 vcpu#5 state: *** (XEN) RIP: e033:[] (XEN) RFLAGS: 0000000000000246 EM: 0 CONTEXT: pv guest (XEN) rax: 0000000000000000 rbx: ffff88002e54bfd8 rcx: ffffffff810013aa (XEN) rdx: 0000000000000001 rsi: 0000000000000000 rdi: 0000000000000001 (XEN) rbp: 0000000000000005 rsp: ffff88002e54bed8 r8: 0000000000000000 (XEN) r9: 0000000000000000 r10: 0000000000000000 r11: 0000000000000246 (XEN) r12: ffff88002e54bfd8 r13: ffff88002e54bfd8 r14: ffff88002e54bfd8 (XEN) r15: 0000000000000000 cr0: 0000000080050033 cr4: 0000000000042660 (XEN) cr3: 000000046d80c000 cr2: 00007f0f2d9f7f14 (XEN) ds: 002b es: 002b fs: 0000 gs: 0000 ss: e02b cs: e033 (XEN) Guest stack trace from rsp=ffff88002e54bed8: (XEN) ffff88002e695c28 0100000000000000 ffffffff8100992c ffffffff8101a6b4 (XEN) ffff88002e54bfd8 ffffffff818a0fc0 ffffffff810a457e ffff88002e54bfd8 (XEN) ffff88002e54bfd8 0d387c79ccf6749f 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 ffffffffffffffff (XEN) 0000000000000000 0000000000000010 0000000000000202 ffff88002e54bf58 (XEN) 0000000000000018 (XEN) *** Dumping Dom0 vcpu#6 state: *** (XEN) RIP: e033:[] (XEN) RFLAGS: 0000000000000246 EM: 0 CONTEXT: pv guest (XEN) rax: 0000000000000000 rbx: ffff88002e54ffd8 rcx: ffffffff810013aa (XEN) rdx: 0000000000000001 rsi: 0000000000000000 rdi: 0000000000000001 (XEN) rbp: 0000000000000006 rsp: ffff88002e54fed8 r8: 0000000000000000 (XEN) r9: 0000000000000000 r10: ffff88003e580000 r11: 0000000000000246 (XEN) r12: ffff88002e54ffd8 r13: ffff88002e54ffd8 r14: ffff88002e54ffd8 (XEN) r15: 0000000000000000 cr0: 0000000080050033 cr4: 0000000000042660 (XEN) cr3: 000000047fdf3000 cr2: 00007f6465ae3000 (XEN) ds: 002b es: 002b fs: 0000 gs: 0000 ss: e02b cs: e033 (XEN) Guest stack trace from rsp=ffff88002e54fed8: (XEN) 0000000000000000 0100000000000000 ffffffff8100992c ffffffff8101a6b4 (XEN) ffff88002e54ffd8 ffffffff818a0fc0 ffffffff810a457e ffff88002e54ffd8 (XEN) ffff88002e54ffd8 fa60e9751235aae9 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 ffffffffffffffff (XEN) 0000000000000000 0000000000000010 0000000000000202 ffff88002e54ff58 (XEN) 0000000000000018 (XEN) *** Dumping Dom0 vcpu#7 state: *** (XEN) RIP: e033:[] (XEN) RFLAGS: 0000000000000246 EM: 0 CONTEXT: pv guest (XEN) rax: 0000000000000000 rbx: ffff88002e551fd8 rcx: ffffffff810013aa (XEN) rdx: 0000000000000001 rsi: 0000000000000000 rdi: 0000000000000001 (XEN) rbp: 0000000000000007 rsp: ffff88002e551ed8 r8: 0000000000000000 (XEN) r9: 0000000000000000 r10: ffff88003e5c0000 r11: 0000000000000246 (XEN) r12: ffff88002e551fd8 r13: ffff88002e551fd8 r14: ffff88002e551fd8 (XEN) r15: 0000000000000000 cr0: 0000000080050033 cr4: 0000000000042660 (XEN) cr3: 000000046d80c000 cr2: 00007f0f2e23d55b (XEN) ds: 002b es: 002b fs: 0000 gs: 0000 ss: e02b cs: e033 (XEN) Guest stack trace from rsp=ffff88002e551ed8: (XEN) 0000000000000000 0100000000000000 ffffffff8100992c ffffffff8101a6b4 (XEN) ffff88002e551fd8 ffffffff818a0fc0 ffffffff810a457e ffff88002e551fd8 (XEN) ffff88002e551fd8 f8390ec8935d120b 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 0000000000000000 (XEN) 0000000000000000 0000000000000000 0000000000000000 ffffffffffffffff (XEN) 0000000000000000 0000000000000010 0000000000000202 ffff88002e551f58 (XEN) 0000000000000018 (XEN) [H: dump heap info] (XEN) 'H' pressed -> dumping heap info (now-0x32:4F4ADCD8) (XEN) heap[node=0][zone=0] -> 0 pages (XEN) heap[node=0][zone=1] -> 0 pages (XEN) heap[node=0][zone=2] -> 0 pages (XEN) heap[node=0][zone=3] -> 0 pages (XEN) heap[node=0][zone=4] -> 0 pages (XEN) heap[node=0][zone=5] -> 0 pages (XEN) heap[node=0][zone=6] -> 0 pages (XEN) heap[node=0][zone=7] -> 0 pages (XEN) heap[node=0][zone=8] -> 0 pages (XEN) heap[node=0][zone=9] -> 0 pages (XEN) heap[node=0][zone=10] -> 0 pages (XEN) heap[node=0][zone=11] -> 0 pages (XEN) heap[node=0][zone=12] -> 0 pages (XEN) heap[node=0][zone=13] -> 0 pages (XEN) heap[node=0][zone=14] -> 16128 pages (XEN) heap[node=0][zone=15] -> 32768 pages (XEN) heap[node=0][zone=16] -> 65536 pages (XEN) heap[node=0][zone=17] -> 131072 pages (XEN) heap[node=0][zone=18] -> 209786 pages (XEN) heap[node=0][zone=19] -> 0 pages (XEN) heap[node=0][zone=20] -> 1048576 pages (XEN) heap[node=0][zone=21] -> 1790796 pages (XEN) heap[node=0][zone=22] -> 59 pages (XEN) heap[node=0][zone=23] -> 0 pages (XEN) heap[node=0][zone=24] -> 0 pages (XEN) heap[node=0][zone=25] -> 0 pages (XEN) heap[node=0][zone=26] -> 0 pages (XEN) heap[node=0][zone=27] -> 0 pages (XEN) heap[node=0][zone=28] -> 0 pages (XEN) heap[node=0][zone=29] -> 0 pages (XEN) heap[node=0][zone=30] -> 0 pages (XEN) heap[node=0][zone=31] -> 0 pages (XEN) heap[node=0][zone=32] -> 0 pages (XEN) heap[node=0][zone=33] -> 0 pages (XEN) heap[node=0][zone=34] -> 0 pages (XEN) heap[node=0][zone=35] -> 0 pages (XEN) heap[node=0][zone=36] -> 0 pages (XEN) heap[node=0][zone=37] -> 0 pages (XEN) heap[node=0][zone=38] -> 0 pages (XEN) heap[node=0][zone=39] -> 0 pages (XEN) [I: dump HVM irq info] (XEN) 'I' pressed -> dumping HVM irq info (XEN) Domain 1: (XEN) PCI 0x00000000001000000000000000000000 ISA 0x00000101 ROUTE 0 0 0 0 (XEN) GSI [0 - 7] 00 00 01 00 00 00 00 00 (XEN) GSI [8 - f] 01 00 00 00 00 00 00 00 (XEN) GSI [10 - 17] 00 00 00 00 00 00 00 00 (XEN) GSI [18 - 1f] 00 00 00 00 00 00 00 00 (XEN) GSI [20 - 27] 00 00 00 00 01 00 00 00 (XEN) GSI [28 - 2f] 00 00 00 00 00 00 00 00 (XEN) Link 00 01 00 00 (XEN) Callback via 1:0x1c, not asserted (XEN) [M: dump MSI state] (XEN) MSI information: (XEN) IOMMU 24 vec=28 lowest edge assert log lowest dest=00000001 mask=1/0/? (XEN) MSI 25 vec=b8 lowest edge assert log lowest dest=00000001 mask=0/1/? (XEN) MSI 26 vec=c0 lowest edge assert log lowest dest=00000001 mask=0/1/? (XEN) MSI 27 vec=d0 lowest edge assert log lowest dest=00000001 mask=0/1/? (XEN) MSI 28 vec=21 lowest edge assert log lowest dest=00000001 mask=0/1/? (XEN) MSI 29 vec=29 lowest edge assert log lowest dest=00000001 mask=0/1/? (XEN) MSI 30 vec=39 lowest edge assert log lowest dest=00000001 mask=0/1/? (XEN) MSI 31 vec=41 lowest edge assert log lowest dest=00000001 mask=0/1/? (XEN) MSI 32 vec=49 lowest edge assert log lowest dest=00000001 mask=0/1/? (XEN) MSI 33 vec=51 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI 34 vec=59 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI 35 vec=61 lowest edge assert log lowest dest=00000001 mask=1/0/0 (XEN) MSI 36 vec=69 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 37 vec=71 lowest edge assert log lowest dest=00000001 mask=1/0/0 (XEN) MSI-X 38 vec=79 lowest edge assert log lowest dest=00000002 mask=1/0/0 (XEN) MSI-X 39 vec=81 lowest edge assert log lowest dest=00000002 mask=1/0/0 (XEN) MSI-X 40 vec=89 lowest edge assert log lowest dest=00000002 mask=1/0/0 (XEN) MSI-X 41 vec=91 lowest edge assert log lowest dest=00000002 mask=1/0/0 (XEN) MSI 42 vec=99 lowest edge assert log lowest dest=00000001 mask=0/1/? (XEN) MSI-X 43 vec=a1 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 44 vec=a9 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 45 vec=b1 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 46 vec=b9 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 47 vec=c1 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI 48 vec=c9 lowest edge assert log lowest dest=00000002 mask=0/1/? (XEN) MSI-X 49 vec=d1 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 50 vec=d9 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 51 vec=22 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 52 vec=2a lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 53 vec=32 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 54 vec=3a lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 55 vec=42 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 56 vec=4a lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 57 vec=52 lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI-X 58 vec=5a lowest edge assert log lowest dest=000000ff mask=1/1/1 (XEN) MSI 59 vec=6a lowest edge assert log lowest dest=00000080 mask=0/1/? (XEN) [Q: dump PCI devices] (XEN) ==== PCI devices ==== (XEN) ==== segment 0000 ==== (XEN) 0000:0e:00.0 - dom 0 - MSIs < 54 55 56 57 58 > (XEN) 0000:0d:00.0 - dom 0 - MSIs < 49 50 51 52 53 > (XEN) 0000:0c:00.0 - dom 0 - MSIs < 43 44 45 46 47 > (XEN) 0000:0b:00.0 - dom 0 - MSIs < 37 38 39 40 41 > (XEN) 0000:0a:00.0 - dom 0 - MSIs < > (XEN) 0000:09:00.0 - dom 0 - MSIs < > (XEN) 0000:08:00.0 - dom 0 - MSIs < > (XEN) 0000:07:00.0 - dom 0 - MSIs < > (XEN) 0000:05:00.1 - dom 1 - MSIs < > (XEN) 0000:05:00.0 - dom 1 - MSIs < 59 > (XEN) 0000:03:00.0 - dom 0 - MSIs < > (XEN) 0000:02:10.0 - dom 0 - MSIs < 36 > (XEN) 0000:02:09.0 - dom 0 - MSIs < 35 > (XEN) 0000:02:08.0 - dom 0 - MSIs < 34 > (XEN) 0000:01:00.0 - dom 0 - MSIs < 33 > (XEN) 0000:00:1f.3 - dom 0 - MSIs < > (XEN) 0000:00:1f.2 - dom 0 - MSIs < 48 > (XEN) 0000:00:1f.0 - dom 0 - MSIs < > (XEN) 0000:00:1d.0 - dom 1 - MSIs < > (XEN) 0000:00:1c.7 - dom 0 - MSIs < 32 > (XEN) 0000:00:1c.6 - dom 0 - MSIs < 31 > (XEN) 0000:00:1c.5 - dom 0 - MSIs < 30 > (XEN) 0000:00:1c.4 - dom 0 - MSIs < 29 > (XEN) 0000:00:1c.3 - dom 0 - MSIs < 28 > (XEN) 0000:00:1c.2 - dom 0 - MSIs < 27 > (XEN) 0000:00:1c.0 - dom 0 - MSIs < 26 > (XEN) 0000:00:1a.0 - dom 0 - MSIs < > (XEN) 0000:00:16.1 - dom 0 - MSIs < > (XEN) 0000:00:16.0 - dom 0 - MSIs < > (XEN) 0000:00:14.0 - dom 0 - MSIs < 42 > (XEN) 0000:00:01.0 - dom 0 - MSIs < 25 > (XEN) 0000:00:00.0 - dom 0 - MSIs < > (XEN) [V: dump iommu info] (XEN) (XEN) iommu 0: nr_pt_levels = 4. (XEN) Queued Invalidation: supported and enabled. (XEN) Interrupt Remapping: supported and enabled. (XEN) Interrupt remapping table (nr_entry=0x10000. Only dump P=1 entries here): (XEN) SVT SQ SID DST V AVL DLM TM RH DM FPD P (XEN) 0000: 1 0 f0f8 77fe0000 00 0 7 0 0 0 0 1 (XEN) 0001: 1 0 f0f8 00000002 62 0 1 0 1 1 0 1 (XEN) 0002: 1 0 f0f8 00000001 f0 0 1 0 1 1 0 1 (XEN) 0003: 1 0 f0f8 000000ff 38 0 1 0 1 1 0 1 (XEN) 0004: 1 0 f0f8 00000001 f1 0 1 0 1 1 0 1 (XEN) 0005: 1 0 f0f8 00000001 40 0 1 0 1 1 0 1 (XEN) 0006: 1 0 f0f8 00000001 48 0 1 0 1 1 0 1 (XEN) 0007: 1 0 f0f8 00000001 50 0 1 0 1 1 0 1 (XEN) 0008: 1 0 f0f8 00000001 58 0 1 0 1 1 0 1 (XEN) 0009: 1 0 f0f8 00000001 60 0 1 1 1 1 0 1 (XEN) 000a: 1 0 f0f8 00000001 68 0 1 0 1 1 0 1 (XEN) 000b: 1 0 f0f8 00000001 70 0 1 0 1 1 0 1 (XEN) 000c: 1 0 f0f8 00000001 78 0 1 0 1 1 0 1 (XEN) 000d: 1 0 f0f8 000000ff 88 0 1 0 1 1 0 1 (XEN) 000e: 1 0 f0f8 00000001 90 0 1 0 1 1 0 1 (XEN) 000f: 1 0 f0f8 00000001 98 0 1 0 1 1 0 1 (XEN) 0010: 1 0 f0f8 00000020 a0 0 1 1 1 1 0 1 (XEN) 0011: 1 0 f0f8 00000001 a8 0 1 1 1 1 0 1 (XEN) 0012: 1 0 f0f8 00000020 b0 0 1 1 1 1 0 1 (XEN) 0013: 1 0 0008 00000001 b8 0 1 0 1 1 0 1 (XEN) 0014: 1 0 00e0 00000001 c0 0 1 0 1 1 0 1 (XEN) 0015: 1 0 f0f8 000000ff c8 0 1 1 1 1 0 1 (XEN) 0016: 1 0 00e2 00000001 d0 0 1 0 1 1 0 1 (XEN) 0017: 1 0 f0f8 00000001 d8 0 1 1 1 1 0 1 (XEN) 0018: 1 0 00e3 00000001 21 0 1 0 1 1 0 1 (XEN) 0019: 1 0 00e4 00000001 29 0 1 0 1 1 0 1 (XEN) 001a: 1 0 f0f8 00000080 31 0 1 1 1 1 0 1 (XEN) 001b: 1 0 00e5 00000001 39 0 1 0 1 1 0 1 (XEN) 001c: 1 0 00e6 00000001 41 0 1 0 1 1 0 1 (XEN) 001d: 1 0 00e7 00000001 49 0 1 0 1 1 0 1 (XEN) 001e: 1 0 0100 000000ff 51 0 1 0 1 1 0 1 (XEN) 001f: 1 0 0240 000000ff 59 0 1 0 1 1 0 1 (XEN) 0020: 1 0 0248 00000001 61 0 1 0 1 1 0 1 (XEN) 0021: 1 0 0280 000000ff 69 0 1 0 1 1 0 1 (XEN) 0022: 1 0 0b00 00000001 71 0 1 0 1 1 0 1 (XEN) 0023: 1 0 0b00 00000002 79 0 1 0 1 1 0 1 (XEN) 0024: 1 0 0b00 00000020 81 0 1 0 1 1 0 1 (XEN) 0025: 1 0 0b00 00000002 89 0 1 0 1 1 0 1 (XEN) 0026: 1 0 0b00 00000002 91 0 1 0 1 1 0 1 (XEN) 0027: 1 0 00a0 00000001 99 0 1 0 1 1 0 1 (XEN) 0028: 1 0 0c00 000000ff a1 0 1 0 1 1 0 1 (XEN) 0029: 1 0 0c00 000000ff a9 0 1 0 1 1 0 1 (XEN) 002a: 1 0 0c00 000000ff b1 0 1 0 1 1 0 1 (XEN) 002b: 1 0 0c00 000000ff b9 0 1 0 1 1 0 1 (XEN) 002c: 1 0 0c00 000000ff c1 0 1 0 1 1 0 1 (XEN) 002d: 1 0 00fa 00000002 c9 0 1 0 1 1 0 1 (XEN) 002e: 1 0 0d00 000000ff d1 0 1 0 1 1 0 1 (XEN) 002f: 1 0 0d00 000000ff d9 0 1 0 1 1 0 1 (XEN) 0030: 1 0 0d00 000000ff 22 0 1 0 1 1 0 1 (XEN) 0031: 1 0 0d00 000000ff 2a 0 1 0 1 1 0 1 (XEN) 0032: 1 0 0d00 000000ff 32 0 1 0 1 1 0 1 (XEN) 0033: 1 0 0e00 000000ff 3a 0 1 0 1 1 0 1 (XEN) 0034: 1 0 0e00 000000ff 42 0 1 0 1 1 0 1 (XEN) 0035: 1 0 0e00 000000ff 4a 0 1 0 1 1 0 1 (XEN) 0036: 1 0 0e00 000000ff 52 0 1 0 1 1 0 1 (XEN) 0037: 1 0 0e00 000000ff 5a 0 1 0 1 1 0 1 (XEN) 0038: 1 0 0500 00000080 6a 0 1 0 1 1 0 1 (XEN) (XEN) Redirection table of IOAPIC 0: (XEN) #entry IDX FMT MASK TRIG IRR POL STAT DELI VECTOR (XEN) 01: 0001 1 0 0 0 0 0 0 62 (XEN) 02: 0002 1 0 0 0 0 0 0 f0 (XEN) 03: 0003 1 1 0 0 0 0 0 38 (XEN) 04: 0004 1 0 0 0 0 0 0 f1 (XEN) 05: 0005 1 0 0 0 0 0 0 40 (XEN) 06: 0006 1 0 0 0 0 0 0 48 (XEN) 07: 0007 1 0 0 0 0 0 0 50 (XEN) 08: 0008 1 0 0 0 0 0 0 58 (XEN) 09: 0009 1 0 1 0 0 0 0 60 (XEN) 0a: 000a 1 0 0 0 0 0 0 68 (XEN) 0b: 000b 1 0 0 0 0 0 0 70 (XEN) 0c: 000c 1 0 0 0 0 0 0 78 (XEN) 0d: 000d 1 1 0 0 0 0 0 88 (XEN) 0e: 000e 1 0 0 0 0 0 0 90 (XEN) 0f: 000f 1 0 0 0 0 0 0 98 (XEN) 10: 0010 1 0 1 0 1 0 0 a0 (XEN) 11: 001a 1 0 1 0 1 0 0 31 (XEN) 12: 0015 1 1 1 0 1 0 0 c8 (XEN) 13: 0017 1 0 1 0 1 0 0 d8 (XEN) 14: 0011 1 0 1 0 1 0 0 a8 (XEN) 17: 0012 1 0 1 0 1 0 0 b0 (XEN) [a: dump timer queues] (XEN) Dumping timer queues: (XEN) CPU00: (XEN) ex= 4405us timer=ffff83047c325cf8 cb=ffff82c4c011b1f0(0000000000000000) csched_tick+0/0x300 (XEN) ex=15994421us timer=ffff82c4c02fe900 cb=ffff82c4c01a6270(0000000000000000) mce_work_fn+0/0xd0 (XEN) ex= 24405us timer=ffff83047c326e90 cb=ffff82c4c0119140(ffff83047c326e70) csched_acct+0/0x4e0 (XEN) ex=47583087904us timer=ffff830441c40380 cb=ffff82c4c01b9720(ffff830441c402e0) rtc_alarm_cb+0/0x40 (XEN) ex=82510249us timer=ffff82c4c02fc5c0 cb=ffff82c4c017ffb0(0000000000000000) plt_overflow+0/0x1a0 (XEN) ex= 994478us timer=ffff82c4c02fc660 cb=ffff82c4c017f5e0(0000000000000000) time_calibration+0/0x60 (XEN) CPU01: (XEN) ex= 1278014us timer=ffff8300735e0060 cb=ffff82c4c0120ab0(ffff8300735e0000) vcpu_singleshot_timer_fn+0/0x10 (XEN) CPU02: (XEN) CPU03: (XEN) CPU04: (XEN) ex= 230014us timer=ffff8300735e1060 cb=ffff82c4c0120ab0(ffff8300735e1000) vcpu_singleshot_timer_fn+0/0x10 (XEN) ex= 1282014us timer=ffff830073304060 cb=ffff82c4c0120ab0(ffff830073304000) vcpu_singleshot_timer_fn+0/0x10 (XEN) CPU05: (XEN) ex= 1274014us timer=ffff8300735e3060 cb=ffff82c4c0120ab0(ffff8300735e3000) vcpu_singleshot_timer_fn+0/0x10 (XEN) CPU06: (XEN) ex= 1062014us timer=ffff8300735e2060 cb=ffff82c4c0120ab0(ffff8300735e2000) vcpu_singleshot_timer_fn+0/0x10 (XEN) ex= 1278014us timer=ffff830073305060 cb=ffff82c4c0120ab0(ffff830073305000) vcpu_singleshot_timer_fn+0/0x10 (XEN) CPU07: (XEN) ex= 255320us timer=ffff830073307060 cb=ffff82c4c0120ab0(ffff830073307000) vcpu_singleshot_timer_fn+0/0x10 (XEN) ex=471325694us timer=ffff830441c406b0 cb=ffff82c4c01b8660(ffff830441c40688) pmt_timer_callback+0/0x60 (XEN) [c: dump ACPI Cx structures] (XEN) 'c' pressed -> printing ACPI Cx structures (XEN) ==cpu0== (XEN) active state: C0 (XEN) max_cstate: C7 (XEN) states: (XEN) C1: type[C1] latency[002] usage[00399790] method[ FFH] duration[23421346708] (XEN) C2: type[C2] latency[033] usage[00030192] method[ FFH] duration[21190916311] (XEN) C3: type[C3] latency[133] usage[00004184] method[ FFH] duration[4791931966] (XEN) C4: type[C4] latency[166] usage[00013062] method[ FFH] duration[130402816857] (XEN) *C0: usage[00447228] duration[38196084394] (XEN) PC2[1997801192] PC3[89674340862] PC6[0] PC7[0] (XEN) CC3[31084219377] CC6[6202936398] CC7[104411750800] (XEN) ==cpu1== (XEN) active state: C4 (XEN) max_cstate: C7 (XEN) states: (XEN) C1: type[C1] latency[002] usage[00182409] method[ FFH] duration[17862413587] (XEN) C2: type[C2] latency[033] usage[00044829] method[ FFH] duration[35289887889] (XEN) C3: type[C3] latency[133] usage[00005126] method[ FFH] duration[7471556431] (XEN) *C4: type[C4] latency[166] usage[00007763] method[ FFH] duration[144302946709] (XEN) C0: usage[00240127] duration[13181673673] (XEN) PC2[1997801192] PC3[89674340862] PC6[0] PC7[0] (XEN) CC3[31084219377] CC6[6202936398] CC7[104411750800] (XEN) ==cpu2== (XEN) active state: C4 (XEN) max_cstate: C7 (XEN) states: (XEN) C1: type[C1] latency[002] usage[00135849] method[ FFH] duration[11829132398] (XEN) C2: type[C2] latency[033] usage[00039864] method[ FFH] duration[28854485921] (XEN) C3: type[C3] latency[133] usage[00004358] method[ FFH] duration[6781225339] (XEN) *C4: type[C4] latency[166] usage[00009037] method[ FFH] duration[157359927810] (XEN) C0: usage[00189108] duration[13386318050] (XEN) PC2[1997801192] PC3[89674340862] PC6[0] PC7[0] (XEN) CC3[30412573979] CC6[10592200170] CC7[109748918628] (XEN) ==cpu3== (XEN) active state: C4 (XEN) max_cstate: C7 (XEN) states: (XEN) C1: type[C1] latency[002] usage[00399985] method[ FFH] duration[14722652795] (XEN) C2: type[C2] latency[033] usage[00040059] method[ FFH] duration[27751182525] (XEN) C3: type[C3] latency[133] usage[00010936] method[ FFH] duration[11457092612] (XEN) *C4: type[C4] latency[166] usage[00008208] method[ FFH] duration[126088681532] (XEN) C0: usage[00459188] duration[38296862646] (XEN) PC2[1997801192] PC3[89674340862] PC6[0] PC7[0] (XEN) CC3[30419639371] CC6[10622075676] CC7[109806538984] (XEN) ==cpu4== (XEN) active state: C4 (XEN) max_cstate: C7 (XEN) states: (XEN) C1: type[C1] latency[002] usage[00217268] method[ FFH] duration[17571115478] (XEN) C2: type[C2] latency[033] usage[00038128] method[ FFH] duration[29400341682] (XEN) C3: type[C3] latency[133] usage[00004880] method[ FFH] duration[5658898012] (XEN) *C4: type[C4] latency[166] usage[00006933] method[ FFH] duration[143396911174] (XEN) C0: usage[00267209] duration[22394589155] (XEN) PC2[1997801192] PC3[89674340862] PC6[0] PC7[0] (XEN) CC3[22367356897] CC6[7331996646] CC7[119065105838] (XEN) ==cpu5== (XEN) active state: C3 (XEN) max_cstate: C7 (XEN) states: (XEN) C1: type[C1] latency[002] usage[00399357] method[ FFH] duration[31601471368] (XEN) C2: type[C2] latency[033] usage[00028858] method[ FFH] duration[24609222149] (XEN) *C3: type[C3] latency[133] usage[00004250] method[ FFH] duration[6305964986] (XEN) C4: type[C4] latency[166] usage[00005721] method[ FFH] duration[140566927570] (XEN) C0: usage[00438186] duration[15440879751] (XEN) PC2[1997801192] PC3[89674340862] PC6[0] PC7[0] (XEN) CC3[22369367348] CC6[7408530926] CC7[119084176931] (XEN) ==cpu6== (XEN) active state: C4 (XEN) max_cstate: C7 (XEN) states: (XEN) C1: type[C1] latency[002] usage[00221529] method[ FFH] duration[14656571528] (XEN) C2: type[C2] latency[033] usage[00030659] method[ FFH] duration[23612847315] (XEN) C3: type[C3] latency[133] usage[00004718] method[ FFH] duration[6622858119] (XEN) *C4: type[C4] latency[166] usage[00010229] method[ FFH] duration[155939414764] (XEN) C0: usage[00267135] duration[17798157419] (XEN) PC2[1997801192] PC3[89674340862] PC6[0] PC7[0] (XEN) CC3[27586685441] CC6[7852058106] CC7[133354899497] (XEN) ==cpu7== (XEN) active state: C4 (XEN) max_cstate: C7 (XEN) states: (XEN) C1: type[C1] latency[002] usage[00341405] method[ FFH] duration[14153766589] (XEN) C2: type[C2] latency[033] usage[00043399] method[ FFH] duration[29853182092] (XEN) C3: type[C3] latency[133] usage[00007158] method[ FFH] duration[7472484289] (XEN) *C4: type[C4] latency[166] usage[00011718] method[ FFH] duration[149127246967] (XEN) C0: usage[00403680] duration[18125779861] (XEN) PC2[1997801192] PC3[89674340862] PC6[0] PC7[0] (XEN) CC3[27586685441] CC6[7852058106] CC7[133459652848] (XEN) [e: dump evtchn info] (XEN) 'e' pressed -> dumping event-channel info (XEN) Event channel information for domain 0: (XEN) Polling vCPUs: {} (XEN) port [p/m] (XEN) 1 [0/0]: s=5 n=0 x=0 v=0 (XEN) 2 [0/0]: s=6 n=0 x=0 (XEN) 3 [0/0]: s=6 n=0 x=0 (XEN) 4 [0/0]: s=5 n=0 x=0 v=1 (XEN) 5 [0/0]: s=6 n=0 x=0 (XEN) 6 [0/0]: s=6 n=0 x=0 (XEN) 7 [0/0]: s=5 n=1 x=0 v=0 (XEN) 8 [0/0]: s=6 n=1 x=0 (XEN) 9 [0/0]: s=6 n=1 x=0 (XEN) 10 [0/0]: s=5 n=1 x=0 v=1 (XEN) 11 [0/0]: s=6 n=1 x=0 (XEN) 12 [0/0]: s=6 n=1 x=0 (XEN) 13 [0/0]: s=5 n=2 x=0 v=0 (XEN) 14 [0/0]: s=6 n=2 x=0 (XEN) 15 [0/0]: s=6 n=2 x=0 (XEN) 16 [0/0]: s=5 n=2 x=0 v=1 (XEN) 17 [0/0]: s=6 n=2 x=0 (XEN) 18 [0/0]: s=6 n=2 x=0 (XEN) 19 [0/0]: s=5 n=3 x=0 v=0 (XEN) 20 [0/0]: s=6 n=3 x=0 (XEN) 21 [0/0]: s=6 n=3 x=0 (XEN) 22 [0/0]: s=5 n=3 x=0 v=1 (XEN) 23 [0/0]: s=6 n=3 x=0 (XEN) 24 [0/0]: s=6 n=3 x=0 (XEN) 25 [0/0]: s=5 n=4 x=0 v=0 (XEN) 26 [0/0]: s=6 n=4 x=0 (XEN) 27 [0/0]: s=6 n=4 x=0 (XEN) 28 [0/0]: s=5 n=4 x=0 v=1 (XEN) 29 [0/0]: s=6 n=4 x=0 (XEN) 30 [0/0]: s=6 n=4 x=0 (XEN) 31 [1/0]: s=5 n=5 x=0 v=0 (XEN) 32 [1/0]: s=6 n=5 x=0 (XEN) 33 [0/0]: s=6 n=5 x=0 (XEN) 34 [0/0]: s=5 n=5 x=0 v=1 (XEN) 35 [0/0]: s=6 n=5 x=0 (XEN) 36 [0/0]: s=6 n=5 x=0 (XEN) 37 [0/0]: s=5 n=6 x=0 v=0 (XEN) 38 [0/0]: s=6 n=6 x=0 (XEN) 39 [0/0]: s=6 n=6 x=0 (XEN) 40 [0/0]: s=5 n=6 x=0 v=1 (XEN) 41 [0/0]: s=6 n=6 x=0 (XEN) 42 [0/0]: s=6 n=6 x=0 (XEN) 43 [0/0]: s=5 n=7 x=0 v=0 (XEN) 44 [0/0]: s=6 n=7 x=0 (XEN) 45 [0/0]: s=6 n=7 x=0 (XEN) 46 [0/0]: s=5 n=7 x=0 v=1 (XEN) 47 [0/0]: s=6 n=7 x=0 (XEN) 48 [0/0]: s=6 n=7 x=0 (XEN) 49 [0/0]: s=3 n=0 x=0 d=0 p=76 (XEN) 50 [0/0]: s=5 n=0 x=0 v=9 (XEN) 51 [0/0]: s=4 n=0 x=0 p=9 i=9 (XEN) 52 [0/0]: s=4 n=0 x=0 p=279 i=25 (XEN) 53 [0/0]: s=4 n=0 x=0 p=278 i=26 (XEN) 54 [0/0]: s=4 n=0 x=0 p=277 i=27 (XEN) 55 [0/0]: s=4 n=0 x=0 p=276 i=28 (XEN) 56 [0/0]: s=4 n=0 x=0 p=275 i=29 (XEN) 57 [0/0]: s=4 n=0 x=0 p=274 i=30 (XEN) 58 [0/0]: s=4 n=0 x=0 p=273 i=31 (XEN) 59 [0/0]: s=4 n=0 x=0 p=272 i=32 (XEN) 60 [0/0]: s=4 n=0 x=0 p=269 i=35 (XEN) 61 [0/1]: s=5 n=0 x=0 v=2 (XEN) 62 [0/0]: s=4 n=0 x=0 p=1 i=1 (XEN) 63 [0/0]: s=4 n=0 x=0 p=8 i=8 (XEN) 64 [0/0]: s=4 n=0 x=0 p=20 i=20 (XEN) 65 [0/0]: s=3 n=0 x=0 d=1 p=8 (XEN) 66 [0/0]: s=4 n=0 x=0 p=16 i=16 (XEN) 67 [0/0]: s=4 n=0 x=0 p=262 i=42 (XEN) 68 [0/0]: s=4 n=0 x=0 p=256 i=48 (XEN) 69 [0/0]: s=4 n=0 x=0 p=5 i=5 (XEN) 70 [0/0]: s=4 n=0 x=0 p=19 i=19 (XEN) 71 [0/0]: s=4 n=0 x=0 p=267 i=37 (XEN) 72 [0/0]: s=4 n=0 x=0 p=266 i=38 (XEN) 73 [0/0]: s=4 n=0 x=0 p=265 i=39 (XEN) 74 [0/0]: s=4 n=0 x=0 p=264 i=40 (XEN) 75 [0/0]: s=4 n=0 x=0 p=263 i=41 (XEN) 76 [0/0]: s=3 n=0 x=0 d=0 p=49 (XEN) 77 [0/0]: s=5 n=0 x=0 v=3 (XEN) 78 [0/0]: s=3 n=0 x=0 d=1 p=9 (XEN) 79 [0/0]: s=3 n=0 x=0 d=1 p=1 (XEN) 80 [0/0]: s=3 n=0 x=0 d=1 p=3 (XEN) 81 [0/0]: s=3 n=0 x=0 d=1 p=4 (XEN) 82 [0/0]: s=3 n=0 x=0 d=1 p=5 (XEN) 83 [0/0]: s=3 n=0 x=0 d=1 p=6 (XEN) 84 [0/0]: s=3 n=0 x=0 d=1 p=7 (XEN) 85 [0/0]: s=3 n=0 x=0 d=1 p=2 (XEN) 86 [0/0]: s=3 n=0 x=0 d=1 p=12 (XEN) 87 [0/0]: s=3 n=0 x=0 d=1 p=13 (XEN) Event channel information for domain 1: (XEN) Polling vCPUs: {} (XEN) port [p/m] (XEN) 1 [0/1]: s=3 n=0 x=1 d=0 p=79 (XEN) 2 [0/1]: s=3 n=0 x=1 d=0 p=85 (XEN) 3 [0/1]: s=3 n=1 x=1 d=0 p=80 (XEN) 4 [0/1]: s=3 n=2 x=1 d=0 p=81 (XEN) 5 [0/1]: s=3 n=3 x=1 d=0 p=82 (XEN) 6 [0/1]: s=3 n=4 x=1 d=0 p=83 (XEN) 7 [0/1]: s=3 n=5 x=1 d=0 p=84 (XEN) 8 [0/0]: s=3 n=0 x=0 d=0 p=65 (XEN) 9 [0/1]: s=3 n=0 x=0 d=0 p=78 (XEN) 10 [0/0]: s=6 n=0 x=0 (XEN) 11 [0/0]: s=2 n=0 x=0 d=0 (XEN) 12 [0/0]: s=3 n=0 x=0 d=0 p=86 (XEN) 13 [0/0]: s=3 n=0 x=0 d=0 p=87 (XEN) [g: print grant table usage] (XEN) gnttab_usage_print_all [ key 'g' pressed (XEN) -------- active -------- -------- shared -------- (XEN) [ref] localdom mfn pin localdom gmfn flags (XEN) grant-table for remote domain: 0 ... no active grant table entries (XEN) -------- active -------- -------- shared -------- (XEN) [ref] localdom mfn pin localdom gmfn flags (XEN) grant-table for remote domain: 1 (v1) (XEN) [ 0] 0 0x4451a8 0x00000002 0 0x000000 0x00 (XEN) [ 1] 0 0x4451ab 0x00000002 0 0x000000 0x00 (XEN) [16298] 0 0x276c42 0x00000001 0 0x07e442 0x19 (XEN) [16303] 0 0x276c41 0x00000001 0 0x07e441 0x19 (XEN) [16383] 0 0x276587 0x00000001 0 0x07ed87 0x19 (XEN) gnttab_usage_print_all ] done (XEN) [i: dump interrupt bindings] (XEN) Guest interrupt information: (XEN) IRQ: 0 affinity:01 vec:f0 type=IO-APIC-edge status=00000000 timer_interrupt+0/0x180 (XEN) IRQ: 1 affinity:02 vec:62 type=IO-APIC-edge status=00000030 in-flight=0 domain-list=0: 1(----), (XEN) IRQ: 3 affinity:ff vec:38 type=IO-APIC-edge status=00000002 mapped, unbound (XEN) IRQ: 4 affinity:01 vec:f1 type=IO-APIC-edge status=00000000 ns16550_interrupt+0/0x90 (XEN) IRQ: 5 affinity:01 vec:40 type=IO-APIC-edge status=00000030 in-flight=0 domain-list=0: 5(----), (XEN) IRQ: 6 affinity:01 vec:48 type=IO-APIC-edge status=00000002 mapped, unbound (XEN) IRQ: 7 affinity:01 vec:50 type=IO-APIC-edge status=00000002 mapped, unbound (XEN) IRQ: 8 affinity:01 vec:58 type=IO-APIC-edge status=00000030 in-flight=0 domain-list=0: 8(----), (XEN) IRQ: 9 affinity:01 vec:60 type=IO-APIC-level status=00000030 in-flight=0 domain-list=0: 9(----), (XEN) IRQ: 10 affinity:01 vec:68 type=IO-APIC-edge status=00000002 mapped, unbound (XEN) IRQ: 11 affinity:01 vec:70 type=IO-APIC-edge status=00000002 mapped, unbound (XEN) IRQ: 12 affinity:01 vec:78 type=IO-APIC-edge status=00000002 mapped, unbound (XEN) IRQ: 13 affinity:ff vec:88 type=IO-APIC-edge status=00000002 mapped, unbound (XEN) IRQ: 14 affinity:01 vec:90 type=IO-APIC-edge status=00000002 mapped, unbound (XEN) IRQ: 15 affinity:01 vec:98 type=IO-APIC-edge status=00000002 mapped, unbound (XEN) IRQ: 16 affinity:20 vec:a0 type=IO-APIC-level status=00000010 in-flight=0 domain-list=0: 16(----),1: 16(--M-), (XEN) IRQ: 17 affinity:80 vec:31 type=IO-APIC-level status=00000010 in-flight=0 domain-list=1: 17(--M-), (XEN) IRQ: 18 affinity:ff vec:c8 type=IO-APIC-level status=00000002 mapped, unbound (XEN) IRQ: 19 affinity:01 vec:d8 type=IO-APIC-level status=00000030 in-flight=0 domain-list=0: 19(----), (XEN) IRQ: 20 affinity:01 vec:a8 type=IO-APIC-level status=00000030 in-flight=0 domain-list=0: 20(----), (XEN) IRQ: 23 affinity:20 vec:b0 type=IO-APIC-level status=00000010 in-flight=0 domain-list=1: 23(--M-), (XEN) IRQ: 24 affinity:ff vec:28 type=DMA_MSI status=00000000 iommu_page_fault+0/0x10 (XEN) IRQ: 25 affinity:01 vec:b8 type=PCI-MSI status=00000030 in-flight=0 domain-list=0:279(----), (XEN) IRQ: 26 affinity:01 vec:c0 type=PCI-MSI status=00000030 in-flight=0 domain-list=0:278(----), (XEN) IRQ: 27 affinity:01 vec:d0 type=PCI-MSI status=00000030 in-flight=0 domain-list=0:277(----), (XEN) IRQ: 28 affinity:01 vec:21 type=PCI-MSI status=00000030 in-flight=0 domain-list=0:276(----), (XEN) IRQ: 29 affinity:01 vec:29 type=PCI-MSI status=00000030 in-flight=0 domain-list=0:275(----), (XEN) IRQ: 30 affinity:01 vec:39 type=PCI-MSI status=00000030 in-flight=0 domain-list=0:274(----), (XEN) IRQ: 31 affinity:01 vec:41 type=PCI-MSI status=00000030 in-flight=0 domain-list=0:273(----), (XEN) IRQ: 32 affinity:01 vec:49 type=PCI-MSI status=00000030 in-flight=0 domain-list=0:272(----), (XEN) IRQ: 33 affinity:ff vec:51 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 34 affinity:ff vec:59 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 35 affinity:01 vec:61 type=PCI-MSI/-X status=00000030 in-flight=0 domain-list=0:269(----), (XEN) IRQ: 36 affinity:ff vec:69 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 37 affinity:01 vec:71 type=PCI-MSI/-X status=00000030 in-flight=0 domain-list=0:267(----), (XEN) IRQ: 38 affinity:20 vec:79 type=PCI-MSI/-X status=00000010 in-flight=0 domain-list=0:266(----), (XEN) IRQ: 39 affinity:20 vec:81 type=PCI-MSI/-X status=00000010 in-flight=0 domain-list=0:265(----), (XEN) IRQ: 40 affinity:20 vec:89 type=PCI-MSI/-X status=00000010 in-flight=0 domain-list=0:264(----), (XEN) IRQ: 41 affinity:20 vec:91 type=PCI-MSI/-X status=00000010 in-flight=0 domain-list=0:263(----), (XEN) IRQ: 42 affinity:01 vec:99 type=PCI-MSI status=00000030 in-flight=0 domain-list=0:262(----), (XEN) IRQ: 43 affinity:ff vec:a1 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 44 affinity:ff vec:a9 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 45 affinity:ff vec:b1 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 46 affinity:ff vec:b9 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 47 affinity:ff vec:c1 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 48 affinity:20 vec:c9 type=PCI-MSI status=00000010 in-flight=0 domain-list=0:256(----), (XEN) IRQ: 49 affinity:ff vec:d1 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 50 affinity:ff vec:d9 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 51 affinity:ff vec:22 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 52 affinity:ff vec:2a type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 53 affinity:ff vec:32 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 54 affinity:ff vec:3a type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 55 affinity:ff vec:42 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 56 affinity:ff vec:4a type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 57 affinity:ff vec:52 type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 58 affinity:ff vec:5a type=PCI-MSI/-X status=00000002 mapped, unbound (XEN) IRQ: 59 affinity:80 vec:6a type=PCI-MSI status=00000010 in-flight=0 domain-list=1: 55(--M-), (XEN) IO-APIC interrupt information: (XEN) IRQ 0 Vec240: (XEN) Apic 0x00, Pin 2: vec=f0 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=0 dest_id:0 (XEN) IRQ 1 Vec 98: (XEN) Apic 0x00, Pin 1: vec=62 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=0 dest_id:0 (XEN) IRQ 3 Vec 56: (XEN) Apic 0x00, Pin 3: vec=38 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=1 dest_id:0 (XEN) IRQ 4 Vec241: (XEN) Apic 0x00, Pin 4: vec=f1 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=0 dest_id:0 (XEN) IRQ 5 Vec 64: (XEN) Apic 0x00, Pin 5: vec=40 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=0 dest_id:0 (XEN) IRQ 6 Vec 72: (XEN) Apic 0x00, Pin 6: vec=48 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=0 dest_id:0 (XEN) IRQ 7 Vec 80: (XEN) Apic 0x00, Pin 7: vec=50 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=0 dest_id:0 (XEN) IRQ 8 Vec 88: (XEN) Apic 0x00, Pin 8: vec=58 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=0 dest_id:0 (XEN) IRQ 9 Vec 96: (XEN) Apic 0x00, Pin 9: vec=60 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=L mask=0 dest_id:0 (XEN) IRQ 10 Vec104: (XEN) Apic 0x00, Pin 10: vec=68 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=0 dest_id:0 (XEN) IRQ 11 Vec112: (XEN) Apic 0x00, Pin 11: vec=70 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=0 dest_id:0 (XEN) IRQ 12 Vec120: (XEN) Apic 0x00, Pin 12: vec=78 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=0 dest_id:0 (XEN) IRQ 13 Vec136: (XEN) Apic 0x00, Pin 13: vec=88 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=1 dest_id:0 (XEN) IRQ 14 Vec144: (XEN) Apic 0x00, Pin 14: vec=90 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=0 dest_id:0 (XEN) IRQ 15 Vec152: (XEN) Apic 0x00, Pin 15: vec=98 delivery=LoPri dest=L status=0 polarity=0 irr=0 trig=E mask=0 dest_id:0 (XEN) IRQ 16 Vec160: (XEN) Apic 0x00, Pin 16: vec=a0 delivery=LoPri dest=L status=0 polarity=1 irr=0 trig=L mask=0 dest_id:0 (XEN) IRQ 17 Vec 49: (XEN) Apic 0x00, Pin 17: vec=31 delivery=LoPri dest=L status=0 polarity=1 irr=0 trig=L mask=0 dest_id:0 (XEN) IRQ 18 Vec200: (XEN) Apic 0x00, Pin 18: vec=c8 delivery=LoPri dest=L status=0 polarity=1 irr=0 trig=L mask=1 dest_id:0 (XEN) IRQ 19 Vec216: (XEN) Apic 0x00, Pin 19: vec=d8 delivery=LoPri dest=L status=0 polarity=1 irr=0 trig=L mask=0 dest_id:0 (XEN) IRQ 20 Vec168: (XEN) Apic 0x00, Pin 20: vec=a8 delivery=LoPri dest=L status=0 polarity=1 irr=0 trig=L mask=0 dest_id:0 (XEN) IRQ 23 Vec176: (XEN) Apic 0x00, Pin 23: vec=b0 delivery=LoPri dest=L status=0 polarity=1 irr=0 trig=L mask=0 dest_id:0 (XEN) [m: memory info] (XEN) Physical memory information: (XEN) Xen heap: 0kB free (XEN) heap[14]: 64512kB free (XEN) heap[15]: 131072kB free (XEN) heap[16]: 262144kB free (XEN) heap[17]: 524288kB free (XEN) heap[18]: 839144kB free (XEN) heap[20]: 4194304kB free (XEN) heap[21]: 7163184kB free (XEN) heap[22]: 236kB free (XEN) Dom heap: 13178884kB free (XEN) [n: NMI statistics] (XEN) CPU NMI (XEN) 0 0 (XEN) 1 0 (XEN) 2 0 (XEN) 3 0 (XEN) 4 0 (XEN) 5 0 (XEN) 6 0 (XEN) 7 0 (XEN) dom0 vcpu0: NMI neither pending nor masked (XEN) [q: dump domain (and guest debug) info] (XEN) 'q' pressed -> dumping domain info (now=0x33:85B798BD) (XEN) General information for domain 0: (XEN) refcnt=3 dying=0 pause_count=0 (XEN) nr_pages=262144 xenheap_pages=6 shared_pages=0 paged_pages=0 dirty_cpus={2,5-6} max_pages=4294967295 (XEN) handle=00000000-0000-0000-0000-000000000000 vm_assist=0000000d (XEN) Rangesets belonging to domain 0: (XEN) I/O Ports { 0-1f, 22-3f, 44-60, 62-9f, a2-3f7, 400-cfb, d00-1807, 180c-ffff } (XEN) Interrupts { 1-23, 25-59 } (XEN) I/O Memory { 0-fedff, fee01-ffffffffffffffff } (XEN) Memory pages belonging to domain 0: (XEN) DomPage list too long to display (XEN) XenPage 0000000000471114: caf=c000000000000002, taf=7400000000000002 (XEN) XenPage 0000000000471113: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 0000000000471112: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 0000000000471111: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 00000000000643fc: caf=c000000000000002, taf=7400000000000002 (XEN) XenPage 0000000000445c43: caf=c000000000000002, taf=7400000000000002 (XEN) NODE affinity for domain 0: [0] (XEN) VCPU information and callbacks for domain 0: (XEN) VCPU0: CPU5 [has=F] poll=0 upcall_pend = 00, upcall_mask = 00 dirty_cpus={5} cpu_affinity={0-7} (XEN) pause_count=0 pause_flags=1 (XEN) No periodic timer (XEN) VCPU1: CPU6 [has=F] poll=0 upcall_pend = 00, upcall_mask = 00 dirty_cpus={} cpu_affinity={0-7} (XEN) pause_count=0 pause_flags=1 (XEN) No periodic timer (XEN) VCPU2: CPU2 [has=F] poll=0 upcall_pend = 00, upcall_mask = 00 dirty_cpus={2} cpu_affinity={0-7} (XEN) pause_count=0 pause_flags=1 (XEN) No periodic timer (XEN) VCPU3: CPU1 [has=F] poll=0 upcall_pend = 00, upcall_mask = 00 dirty_cpus={} cpu_affinity={0-7} (XEN) pause_count=0 pause_flags=1 (XEN) No periodic timer (XEN) VCPU4: CPU5 [has=F] poll=0 upcall_pend = 00, upcall_mask = 00 dirty_cpus={} cpu_affinity={0-7} (XEN) pause_count=0 pause_flags=1 (XEN) No periodic timer (XEN) VCPU5: CPU0 [has=F] poll=0 upcall_pend = 01, upcall_mask = 00 dirty_cpus={} cpu_affinity={0-7} (XEN) pause_count=0 pause_flags=0 (XEN) No periodic timer (XEN) VCPU6: CPU6 [has=F] poll=0 upcall_pend = 00, upcall_mask = 00 dirty_cpus={6} cpu_affinity={0-7} (XEN) pause_count=0 pause_flags=1 (XEN) No periodic timer (XEN) VCPU7: CPU4 [has=F] poll=0 upcall_pend = 00, upcall_mask = 00 dirty_cpus={} cpu_affinity={0-7} (XEN) pause_count=0 pause_flags=1 (XEN) No periodic timer (XEN) General information for domain 1: (XEN) refcnt=3 dying=0 pause_count=0 (XEN) nr_pages=524099 xenheap_pages=34 shared_pages=0 paged_pages=0 dirty_cpus={3-4,7} max_pages=524544 (XEN) handle=ab8f106b-2e46-4512-957d-d587797d43ac vm_assist=00000000 (XEN) paging assistance: hap refcounts log_dirty translate external (XEN) Rangesets belonging to domain 1: (XEN) I/O Ports { e000-e0ff } (XEN) Interrupts { 16-17, 23, 59 } (XEN) I/O Memory { c0000-d003f, d0060-d0063, d0411 } (XEN) Memory pages belonging to domain 1: (XEN) DomPage list too long to display (XEN) PoD entries=0 cachesize=0 (XEN) XenPage 000000000046c0d1: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000046c0d0: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 0000000000445c4f: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 0000000000445c4e: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 0000000000064594: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 0000000000432938: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042e1e5: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042e1e4: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042e167: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042e166: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042e16d: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042e16c: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 0000000000408b83: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 0000000000408b82: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042bd2f: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042bd2e: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042bd2d: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042bd2c: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042cdcb: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042cdca: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042cdc9: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042cdc8: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042cc57: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042cc56: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042cc55: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042cc54: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042cc5b: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042cc5a: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042cc59: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 000000000042cc58: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 00000000004086a3: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 00000000004086a2: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 00000000004086a1: caf=c000000000000001, taf=7400000000000001 (XEN) XenPage 00000000004086a0: caf=c000000000000001, taf=7400000000000001 (XEN) NODE affinity for domain 1: [0] (XEN) VCPU information and callbacks for domain 1: (XEN) VCPU0: CPU0 [has=F] poll=0 upcall_pend = 00, upcall_mask = 00 dirty_cpus={} cpu_affinity={0-7} (XEN) pause_count=0 pause_flags=0 (XEN) paging assistance: hap, 4 levels (XEN) No periodic timer (XEN) VCPU1: CPU4 [has=F] poll=0 upcall_pend = 00, upcall_mask = 00 dirty_cpus={4} cpu_affinity={0-7} (XEN) pause_count=0 pause_flags=1 (XEN) paging assistance: hap, 4 levels (XEN) No periodic timer (XEN) VCPU2: CPU3 [has=F] poll=0 upcall_pend = 00, upcall_mask = 00 dirty_cpus={3} cpu_affinity={0-7} (XEN) pause_count=0 pause_flags=1 (XEN) paging assistance: hap, 4 levels (XEN) No periodic timer (XEN) VCPU3: CPU7 [has=F] poll=0 upcall_pend = 00, upcall_mask = 00 dirty_cpus={7} cpu_affinity={0-7} (XEN) pause_count=0 pause_flags=1 (XEN) paging assistance: hap, 4 levels (XEN) No periodic timer (XEN) VCPU4: CPU1 [has=F] poll=0 upcall_pend = 00, upcall_mask = 00 dirty_cpus={1} cpu_affinity={0-7} (XEN) pause_count=0 pause_flags=1 (XEN) paging assistance: hap, 4 levels (XEN) No periodic timer (XEN) VCPU5: CPU1 [has=F] poll=0 upcall_pend = 00, upcall_mask = 00 dirty_cpus={} cpu_affinity={0-7} (XEN) pause_count=0 pause_flags=1 (XEN) paging assistance: hap, 4 levels (XEN) No periodic timer (XEN) Notifying guest 0:0 (virq 1, port 4, stat 0/0/0) (XEN) Notifying guest 0:1 (virq 1, port 10, stat 0/0/0) (XEN) Notifying guest 0:2 (virq 1, port 16, stat 0/0/0) (XEN) Notifying guest 0:3 (virq 1, port 22, stat 0/0/0) (XEN) Notifying guest 0:4 (virq 1, port 28, stat 0/0/0) (XEN) Notifying guest 0:5 (virq 1, port 34, stat 0/0/-1) (XEN) Notifying guest 0:6 (virq 1, port 40, stat 0/0/0) (XEN) Notifying guest 0:7 (virq 1, port 46, stat 0/0/0) (XEN) Notifying guest 1:0 (virq 1, port 0, stat 0/-1/0) (XEN) Notifying guest 1:1 (virq 1, port 0, stat 0/-1/0) (XEN) Notifying guest 1:2 (virq 1, port 0, stat 0/-1/0) (XEN) Notifying guest 1:3 (virq 1, port 0, stat 0/-1/0) (XEN) Notifying guest 1:4 (virq 1, port 0, stat 0/-1/0) (XEN) Notifying guest 1:5 (virq 1, port 0, stat 0/-1/0) (XEN) Shared frames 0 -- Saved frames 0 (XEN) [r: dump run queues] (XEN) sched_smt_power_savings: disabled (XEN) NOW=0x00000033DAD9461F (XEN) Idle cpupool: (XEN) Scheduler: SMP Credit Scheduler (credit) (XEN) info: (XEN) ncpus = 8 (XEN) master = 0 (XEN) credit = 2400 (XEN) credit balance = 375 (XEN) weight = 512 (XEN) runq_sort = 2463 (XEN) default-weight = 256 (XEN) tslice = 30ms (XEN) ratelimit = 1000us (XEN) credits per msec = 10 (XEN) ticks per tslice = 3 (XEN) migration delay = 0us (XEN) idlers: fe (XEN) active vcpus: (XEN) 1: [0.2] pri=0 flags=0 cpu=2 credit=186 [w=256] (XEN) 2: [0.0] pri=0 flags=0 cpu=5 credit=127 [w=256] (XEN) Cpupool 0: (XEN) Scheduler: SMP Credit Scheduler (credit) (XEN) info: (XEN) ncpus = 8 (XEN) master = 0 (XEN) credit = 2400 (XEN) credit balance = 375 (XEN) weight = 512 (XEN) runq_sort = 2463 (XEN) default-weight = 256 (XEN) tslice = 30ms (XEN) ratelimit = 1000us (XEN) credits per msec = 10 (XEN) ticks per tslice = 3 (XEN) migration delay = 0us (XEN) idlers: fe (XEN) active vcpus: (XEN) 1: [0.2] pri=0 flags=0 cpu=2 credit=185 [w=256] (XEN) 2: [0.0] pri=0 flags=0 cpu=5 credit=70 [w=256] (XEN) CPU[00] sort=2462, sibling=03, core=ff (XEN) run: [32767.0] pri=0 flags=0 cpu=0 (XEN) 1: [0.5] pri=0 flags=0 cpu=0 credit=244 [w=256] (XEN) 2: [1.0] pri=0 flags=0 cpu=0 credit=300 [w=256] (XEN) CPU[01] sort=2436, sibling=03, core=ff (XEN) run: [32767.1] pri=-64 flags=0 cpu=1 (XEN) CPU[02] sort=2462, sibling=0c, core=ff (XEN) run: [32767.2] pri=-64 flags=0 cpu=2 (XEN) CPU[03] sort=2446, sibling=0c, core=ff (XEN) run: [32767.3] pri=-64 flags=0 cpu=3 (XEN) CPU[04] sort=2445, sibling=30, core=ff (XEN) run: [32767.4] pri=-64 flags=0 cpu=4 (XEN) CPU[05] sort=2463, sibling=30, core=ff (XEN) run: [32767.5] pri=-64 flags=0 cpu=5 (XEN) CPU[06] sort=2457, sibling=c0, core=ff (XEN) run: [32767.6] pri=-64 flags=0 cpu=6 (XEN) CPU[07] sort=2463, sibling=c0, core=ff (XEN) run: [32767.7] pri=-64 flags=0 cpu=7 (XEN) [s: dump softtsc stats] (XEN) TSC marked as reliable, warp = 0 (count=4) (XEN) dom1(hvm): mode=0,ofs=0x14b9addbde,khz=3292479,inc=1 (XEN) No domains have emulated TSC (XEN) [t: display multi-cpu clock info] (XEN) Synced stime skew: max=32ns avg=24ns samples=3 current=22ns (XEN) Synced cycles skew: max=249 avg=209 samples=3 current=187 (XEN) [u: dump numa info] (XEN) 'u' pressed -> dumping numa info (now-0x33:F626E3BB) (XEN) idx0 -> NODE0 start->0 size->4718592 free->3294721 (XEN) phys_to_nid(0000000000001000) -> 0 should be 0 (XEN) CPU0 -> NODE0 (XEN) CPU1 -> NODE0 (XEN) CPU2 -> NODE0 (XEN) CPU3 -> NODE0 (XEN) CPU4 -> NODE0 (XEN) CPU5 -> NODE0 (XEN) CPU6 -> NODE0 (XEN) CPU7 -> NODE0 (XEN) Memory location of each domain: (XEN) Domain 0 (total: 262144): (XEN) Node 0: 262144 (XEN) Domain 1 (total: 524099): (XEN) Node 0: 524099 (XEN) [v: dump Intel's VMCS] (XEN) *********** VMCS Areas ************** (XEN) (XEN) >>> Domain 1 <<< (XEN) VCPU 0 (XEN) *** Guest State *** (XEN) CR0: actual=0x0000000080050039, shadow=0x0000000080050031, gh_mask=ffffffffffffffff (XEN) CR4: actual=0x00000000000426f8, shadow=0x00000000000406f8, gh_mask=ffffffffffffffff (XEN) CR3: actual=0x0000000073799000, target_count=0 (XEN) target0=0000000000000000, target1=0000000000000000 (XEN) target2=0000000000000000, target3=0000000000000000 (XEN) RSP = 0x00000000208aa0a0 (0x00000000208aa0a0) RIP = 0x000007fef3e2f83f (0x000007fef3e2f83f) (XEN) RFLAGS=0x0000000000000212 (0x0000000000000212) DR7 = 0x0000000000000400 (XEN) Sysenter RSP=0000000000000000 CS:RIP=0000:0000000000000000 (XEN) CS: sel=0x0033, attr=0x0a0fb, limit=0xffffffff, base=0x0000000000000000 (XEN) DS: sel=0x002b, attr=0x0c0f3, limit=0xffffffff, base=0x0000000000000000 (XEN) SS: sel=0x002b, attr=0x0c0f3, limit=0xffffffff, base=0x0000000000000000 (XEN) ES: sel=0x002b, attr=0x0c0f3, limit=0xffffffff, base=0x0000000000000000 (XEN) FS: sel=0x0053, attr=0x040f3, limit=0x00003c00, base=0x00000000ffee2000 (XEN) GS: sel=0x002b, attr=0x0c0f3, limit=0xffffffff, base=0x000007ffffee0000 (XEN) GDTR: limit=0x0000007f, base=0xfffff80004084000 (XEN) LDTR: sel=0x0000, attr=0x1c000, limit=0xffffffff, base=0x0000000000000000 (XEN) IDTR: limit=0x00000fff, base=0xfffff80004084080 (XEN) TR: sel=0x0040, attr=0x0008b, limit=0x00000067, base=0xfffff80004085080 (XEN) Guest PAT = 0x0007010600070106 (XEN) TSC Offset = ffffff5e9aa5e43f (XEN) DebugCtl=0000000000000000 DebugExceptions=0000000000000000 (XEN) Interruptibility=0000 ActivityState=0000 (XEN) *** Host State *** (XEN) RSP = 0xffff82c4c02aff90 RIP = 0xffff82c4c01d7620 (XEN) CS=e008 DS=0000 ES=0000 FS=0000 GS=0000 SS=0000 TR=e040 (XEN) FSBase=0000000000000000 GSBase=0000000000000000 TRBase=ffff82c4c0301280 (XEN) GDTBase=ffff82c4c0246000 IDTBase=ffff82c4c02fc6c0 (XEN) CR0=000000008005003b CR3=000000047f21a000 CR4=00000000001426f0 (XEN) Sysenter RSP=ffff82c4c02affc0 CS:RIP=e008:ffff82c4c0215950 (XEN) Host PAT = 0x0000050100070406 (XEN) *** Control State *** (XEN) PinBased=0000003f CPUBased=b6a065fa SecondaryExec=000054eb (XEN) EntryControls=000053ff ExitControls=000fefff (XEN) ExceptionBitmap=000400c0 (XEN) VMEntry: intr_info=800000b0 errcode=00000000 ilen=00000000 (XEN) VMExit: intr_info=800000f1 errcode=00000000 ilen=00000000 (XEN) reason=00000001 qualification=00000000 (XEN) IDTVectoring: info=00000000 errcode=00000000 (XEN) TPR Threshold = 0x00 (XEN) EPT pointer = 0x0000000445c4801e (XEN) Virtual processor ID = 0x8c60 (XEN) VCPU 1 (XEN) *** Guest State *** (XEN) CR0: actual=0x0000000080050039, shadow=0x0000000080050031, gh_mask=ffffffffffffffff (XEN) CR4: actual=0x00000000000426f8, shadow=0x00000000000406f8, gh_mask=ffffffffffffffff (XEN) CR3: actual=0x0000000000187000, target_count=0 (XEN) target0=0000000000000000, target1=0000000000000000 (XEN) target2=0000000000000000, target3=0000000000000000 (XEN) RSP = 0xfffff88002e68b58 (0xfffff88002e68b58) RIP = 0xfffff880049889c1 (0xfffff880049889c2) (XEN) RFLAGS=0x0000000000000246 (0x0000000000000246) DR7 = 0x0000000000000400 (XEN) Sysenter RSP=0000000000000000 CS:RIP=0000:0000000000000000 (XEN) CS: sel=0x0010, attr=0x0209b, limit=0x00000000, base=0x0000000000000000 (XEN) DS: sel=0x002b, attr=0x0c0f3, limit=0xffffffff, base=0x0000000000000000 (XEN) SS: sel=0x0018, attr=0x0c093, limit=0xffffffff, base=0x0000000000000000 (XEN) ES: sel=0x002b, attr=0x0c0f3, limit=0xffffffff, base=0x0000000000000000 (XEN) FS: sel=0x0053, attr=0x040f3, limit=0x00007c00, base=0x00000000fffd9000 (XEN) GS: sel=0x002b, attr=0x0c0f3, limit=0xffffffff, base=0xfffff88002e40000 (XEN) GDTR: limit=0x0000007f, base=0xfffff88002e4b5c0 (XEN) LDTR: sel=0x0000, attr=0x1c000, limit=0xffffffff, base=0x0000000000000000 (XEN) IDTR: limit=0x00000fff, base=0xfffff88002e4b640 (XEN) TR: sel=0x0040, attr=0x0008b, limit=0x00000067, base=0xfffff88002e44fc0 (XEN) Guest PAT = 0x0007010600070106 (XEN) TSC Offset = ffffff5e9aa5e494 (XEN) DebugCtl=0000000000000000 DebugExceptions=0000000000000000 (XEN) Interruptibility=0000 ActivityState=0000 (XEN) *** Host State *** (XEN) RSP = 0xffff830471167f90 RIP = 0xffff82c4c01d7620 (XEN) CS=e008 DS=0000 ES=0000 FS=0000 GS=0000 SS=0000 TR=e040 (XEN) FSBase=0000000000000000 GSBase=0000000000000000 TRBase=ffff83047116dc80 (XEN) GDTBase=ffff83047115e000 IDTBase=ffff83047116a000 (XEN) CR0=000000008005003b CR3=000000047f219000 CR4=00000000001426f0 (XEN) Sysenter RSP=ffff830471167fc0 CS:RIP=e008:ffff82c4c0215950 (XEN) Host PAT = 0x0000050100070406 (XEN) *** Control State *** (XEN) PinBased=0000003f CPUBased=b6a065fa SecondaryExec=000054eb (XEN) EntryControls=000053ff ExitControls=000fefff (XEN) ExceptionBitmap=000400c0 (XEN) VMEntry: intr_info=00000062 errcode=00000000 ilen=00000000 (XEN) VMExit: intr_info=00000000 errcode=00000000 ilen=00000000 (XEN) reason=0000000c qualification=00000000 (XEN) IDTVectoring: info=00000000 errcode=00000000 (XEN) TPR Threshold = 0x00 (XEN) EPT pointer = 0x0000000445c4801e (XEN) Virtual processor ID = 0xab52 (XEN) VCPU 2 (XEN) *** Guest State *** (XEN) CR0: actual=0x0000000080050039, shadow=0x0000000080050031, gh_mask=ffffffffffffffff (XEN) CR4: actual=0x00000000000426f8, shadow=0x00000000000406f8, gh_mask=ffffffffffffffff (XEN) CR3: actual=0x0000000000187000, target_count=0 (XEN) target0=0000000000000000, target1=0000000000000000 (XEN) target2=0000000000000000, target3=0000000000000000 (XEN) RSP = 0xfffff88002edfb58 (0xfffff88002edfb58) RIP = 0xfffff880049889c1 (0xfffff880049889c2) (XEN) RFLAGS=0x0000000000000246 (0x0000000000000246) DR7 = 0x0000000000000400 (XEN) Sysenter RSP=0000000000000000 CS:RIP=0000:0000000000000000 (XEN) CS: sel=0x0010, attr=0x0a09b, limit=0xffffffff, base=0x0000000000000000 (XEN) DS: sel=0x002b, attr=0x0c0f3, limit=0xffffffff, base=0x0000000000000000 (XEN) SS: sel=0x0018, attr=0x0c093, limit=0xffffffff, base=0x0000000000000000 (XEN) ES: sel=0x002b, attr=0x0c0f3, limit=0xffffffff, base=0x0000000000000000 (XEN) FS: sel=0x0053, attr=0x040f3, limit=0x0000bc00, base=0x00000000fffaa000 (XEN) GS: sel=0x002b, attr=0x0c0f3, limit=0xffffffff, base=0xfffff88002eb7000 (XEN) GDTR: limit=0x0000007f, base=0xfffff88002ec25c0 (XEN) LDTR: sel=0x0000, attr=0x1c000, limit=0xffffffff, base=0x0000000000000000 (XEN) IDTR: limit=0x00000fff, base=0xfffff88002ec2640 (XEN) TR: sel=0x0040, attr=0x0008b, limit=0x00000067, base=0xfffff88002ebbfc0 (XEN) Guest PAT = 0x0007010600070106 (XEN) TSC Offset = ffffff5e9aa5e538 (XEN) DebugCtl=0000000000000000 DebugExceptions=0000000000000000 (XEN) Interruptibility=0000 ActivityState=0000 (XEN) *** Host State *** (XEN) RSP = 0xffff830471177f90 RIP = 0xffff82c4c01d7620 (XEN) CS=e008 DS=0000 ES=0000 FS=0000 GS=0000 SS=0000 TR=e040 (XEN) FSBase=0000000000000000 GSBase=0000000000000000 TRBase=ffff83047117bc80 (XEN) GDTBase=ffff83047116c000 IDTBase=ffff830471178000 (XEN) CR0=000000008005003b CR3=000000047f218000 CR4=00000000001426f0 (XEN) Sysenter RSP=ffff830471177fc0 CS:RIP=e008:ffff82c4c0215950 (XEN) Host PAT = 0x0000050100070406 (XEN) *** Control State *** (XEN) PinBased=0000003f CPUBased=b6a065fa SecondaryExec=000054eb (XEN) EntryControls=000053ff ExitControls=000fefff (XEN) ExceptionBitmap=000400c0 (XEN) VMEntry: intr_info=0000002f errcode=00000000 ilen=00000000 (XEN) VMExit: intr_info=00000000 errcode=00000000 ilen=00000000 (XEN) reason=0000000c qualification=00000000 (XEN) IDTVectoring: info=00000000 errcode=00000000 (XEN) TPR Threshold = 0x00 (XEN) EPT pointer = 0x0000000445c4801e (XEN) Virtual processor ID = 0x07b3 (XEN) VCPU 3 (XEN) *** Guest State *** (XEN) CR0: actual=0x0000000080050039, shadow=0x0000000080050031, gh_mask=ffffffffffffffff (XEN) CR4: actual=0x00000000000426f8, shadow=0x00000000000406f8, gh_mask=ffffffffffffffff (XEN) CR3: actual=0x0000000000187000, target_count=0 (XEN) target0=0000000000000000, target1=0000000000000000 (XEN) target2=0000000000000000, target3=0000000000000000 (XEN) RSP = 0xfffff88002f56b58 (0xfffff88002f56b58) RIP = 0xfffff880049889c1 (0xfffff880049889c2) (XEN) RFLAGS=0x0000000000000246 (0x0000000000000246) DR7 = 0x0000000000000400 (XEN) Sysenter RSP=0000000000000000 CS:RIP=0000:0000000000000000 (XEN) CS: sel=0x0010, attr=0x0a09b, limit=0xffffffff, base=0x0000000000000000 (XEN) DS: sel=0x002b, attr=0x0c0f3, limit=0xffffffff, base=0x0000000000000000 (XEN) SS: sel=0x0018, attr=0x0c093, limit=0xffffffff, base=0x0000000000000000 (XEN) ES: sel=0x002b, attr=0x0c0f3, limit=0xffffffff, base=0x0000000000000000 (XEN) FS: sel=0x0053, attr=0x040f3, limit=0x0000fc00, base=0x000000007ef43000 (XEN) GS: sel=0x002b, attr=0x0c0f3, limit=0xffffffff, base=0xfffff88002f2e000 (XEN) GDTR: limit=0x0000007f, base=0xfffff88002f395c0 (XEN) LDTR: sel=0x0000, attr=0x1c000, limit=0xffffffff, base=0x0000000000000000 (XEN) IDTR: limit=0x00000fff, base=0xfffff88002f39640 (XEN) TR: sel=0x0040, attr=0x0008b, limit=0x00000067, base=0xfffff88002f32fc0 (XEN) Guest PAT = 0x0007010600070106 (XEN) TSC Offset = ffffff5e9aa5e78f (XEN) DebugCtl=0000000000000000 DebugExceptions=0000000000000000 (XEN) Interruptibility=0000 ActivityState=0000 (XEN) *** Host State *** (XEN) RSP = 0xffff83047113ff90 RIP = 0xffff82c4c01d7620 (XEN) CS=e008 DS=0000 ES=0000 FS=0000 GS=0000 SS=0000 TR=e040 (XEN) FSBase=0000000000000000 GSBase=0000000000000000 TRBase=ffff830471145c80 (XEN) GDTBase=ffff830471136000 IDTBase=ffff830471142000 (XEN) CR0=000000008005003b CR3=000000047f217000 CR4=00000000001426f0 (XEN) Sysenter RSP=ffff83047113ffc0 CS:RIP=e008:ffff82c4c0215950 (XEN) Host PAT = 0x0000050100070406 (XEN) *** Control State *** (XEN) PinBased=0000003f CPUBased=b6a065fa SecondaryExec=000054eb (XEN) EntryControls=000053ff ExitControls=000fefff (XEN) ExceptionBitmap=000400c0 (XEN) VMEntry: intr_info=0000002f errcode=00000000 ilen=00000000 (XEN) VMExit: intr_info=00000000 errcode=00000000 ilen=00000000 (XEN) reason=0000000c qualification=00000000 (XEN) IDTVectoring: info=00000000 errcode=00000000 (XEN) TPR Threshold = 0x00 (XEN) EPT pointer = 0x0000000445c4801e (XEN) Virtual processor ID = 0x7680 (XEN) VCPU 4 (XEN) *** Guest State *** (XEN) CR0: actual=0x0000000080050039, shadow=0x0000000080050031, gh_mask=ffffffffffffffff (XEN) CR4: actual=0x00000000000426f8, shadow=0x00000000000406f8, gh_mask=ffffffffffffffff (XEN) CR3: actual=0x0000000000187000, target_count=0 (XEN) target0=0000000000000000, target1=0000000000000000 (XEN) target2=0000000000000000, target3=0000000000000000 (XEN) RSP = 0xfffff88002fcdb58 (0xfffff88002fcdb58) RIP = 0xfffff880049889c1 (0xfffff880049889c2) (XEN) RFLAGS=0x0000000000000246 (0x0000000000000246) DR7 = 0x0000000000000400 (XEN) Sysenter RSP=0000000000000000 CS:RIP=0000:0000000000000000 (XEN) CS: sel=0x0010, attr=0x0209b, limit=0x00000000, base=0x0000000000000000 (XEN) DS: sel=0x002b, attr=0x0c0f3, limit=0xffffffff, base=0x0000000000000000 (XEN) SS: sel=0x0018, attr=0x0c093, limit=0xffffffff, base=0x0000000000000000 (XEN) ES: sel=0x002b, attr=0x0c0f3, limit=0xffffffff, base=0x0000000000000000 (XEN) FS: sel=0x0053, attr=0x040f3, limit=0x00013c00, base=0x000000007ef97000 (XEN) GS: sel=0x002b, attr=0x0c0f3, limit=0xffffffff, base=0xfffff88002fa5000 (XEN) GDTR: limit=0x0000007f, base=0xfffff88002fb05c0 (XEN) LDTR: sel=0x0000, attr=0x1c000, limit=0xffffffff, base=0x0000000000000000 (XEN) IDTR: limit=0x00000fff, base=0xfffff88002fb0640 (XEN) TR: sel=0x0040, attr=0x0008b, limit=0x00000067, base=0xfffff88002fa9fc0 (XEN) Guest PAT = 0x0007010600070106 (XEN) TSC Offset = ffffff5e9aa5e74f (XEN) DebugCtl=0000000000000000 DebugExceptions=0000000000000000 (XEN) Interruptibility=0000 ActivityState=0000 (XEN) *** Host State *** (XEN) RSP = 0xffff83047c30ff90 RIP = 0xffff82c4c01d7620 (XEN) CS=e008 DS=0000 ES=0000 FS=0000 GS=0000 SS=0000 TR=e040 (XEN) FSBase=0000000000000000 GSBase=0000000000000000 TRBase=ffff8304711f6c80 (XEN) GDTBase=ffff8304711e7000 IDTBase=ffff8304711f3000 (XEN) CR0=000000008005003b CR3=000000047f216000 CR4=00000000001426f0 (XEN) Sysenter RSP=ffff83047c30ffc0 CS:RIP=e008:ffff82c4c0215950 (XEN) Host PAT = 0x0000050100070406 (XEN) *** Control State *** (XEN) PinBased=0000003f CPUBased=b6a065fa SecondaryExec=000054eb (XEN) EntryControls=000053ff ExitControls=000fefff (XEN) ExceptionBitmap=000400c0 (XEN) VMEntry: intr_info=00000072 errcode=00000000 ilen=00000000 (XEN) VMExit: intr_info=00000000 errcode=00000000 ilen=00000000 (XEN) reason=0000000c qualification=00000000 (XEN) IDTVectoring: info=00000000 errcode=00000000 (XEN) TPR Threshold = 0x00 (XEN) EPT pointer = 0x0000000445c4801e (XEN) Virtual processor ID = 0x828d (XEN) VCPU 5 (XEN) *** Guest State *** (XEN) CR0: actual=0x0000000080050039, shadow=0x0000000080050031, gh_mask=ffffffffffffffff (XEN) CR4: actual=0x00000000000426f8, shadow=0x00000000000406f8, gh_mask=ffffffffffffffff (XEN) CR3: actual=0x0000000000187000, target_count=0 (XEN) target0=0000000000000000, target1=0000000000000000 (XEN) target2=0000000000000000, target3=0000000000000000 (XEN) RSP = 0xfffff88003046b58 (0xfffff88003046b58) RIP = 0xfffff880049889c1 (0xfffff880049889c2) (XEN) RFLAGS=0x0000000000000246 (0x0000000000000246) DR7 = 0x0000000000000400 (XEN) Sysenter RSP=0000000000000000 CS:RIP=0000:0000000000000000 (XEN) CS: sel=0x0010, attr=0x0209b, limit=0x00000000, base=0x0000000000000000 (XEN) DS: sel=0x002b, attr=0x0c0f3, limit=0xffffffff, base=0x0000000000000000 (XEN) SS: sel=0x0018, attr=0x0c093, limit=0xffffffff, base=0x0000000000000000 (XEN) ES: sel=0x002b, attr=0x0c0f3, limit=0xffffffff, base=0x0000000000000000 (XEN) FS: sel=0x0053, attr=0x040f3, limit=0x00017c00, base=0x000000007ef73000 (XEN) GS: sel=0x002b, attr=0x0c0f3, limit=0xffffffff, base=0xfffff88002fdc000 (XEN) GDTR: limit=0x0000007f, base=0xfffff88002fe75c0 (XEN) LDTR: sel=0x0000, attr=0x1c000, limit=0xffffffff, base=0x0000000000000000 (XEN) IDTR: limit=0x00000fff, base=0xfffff88002fe7640 (XEN) TR: sel=0x0040, attr=0x0008b, limit=0x00000067, base=0xfffff88002fe0fc0 (XEN) Guest PAT = 0x0007010600070106 (XEN) TSC Offset = ffffff5e9aa5e7a3 (XEN) DebugCtl=0000000000000000 DebugExceptions=0000000000000000 (XEN) Interruptibility=0000 ActivityState=0000 (XEN) *** Host State *** (XEN) RSP = 0xffff83047c30ff90 RIP = 0xffff82c4c01d7620 (XEN) CS=e008 DS=0000 ES=0000 FS=0000 GS=0000 SS=0000 TR=e040 (XEN) FSBase=0000000000000000 GSBase=0000000000000000 TRBase=ffff8304711f6c80 (XEN) GDTBase=ffff8304711e7000 IDTBase=ffff8304711f3000 (XEN) CR0=000000008005003b CR3=000000047f215000 CR4=00000000001426f0 (XEN) Sysenter RSP=ffff83047c30ffc0 CS:RIP=e008:ffff82c4c0215950 (XEN) Host PAT = 0x0000050100070406 (XEN) *** Control State *** (XEN) PinBased=0000003f CPUBased=b6a065fa SecondaryExec=000054eb (XEN) EntryControls=000053ff ExitControls=000fefff (XEN) ExceptionBitmap=000400c0 (XEN) VMEntry: intr_info=00000052 errcode=00000000 ilen=00000000 (XEN) VMExit: intr_info=00000000 errcode=00000000 ilen=00000000 (XEN) reason=0000000c qualification=00000000 (XEN) IDTVectoring: info=00000000 errcode=00000000 (XEN) TPR Threshold = 0x00 (XEN) EPT pointer = 0x0000000445c4801e (XEN) Virtual processor ID = 0x828f (XEN) ************************************** (XEN) [z: print ioapic info] (XEN) number of MP IRQ sources: 15. (XEN) number of IO-APIC #8 registers: 24. (XEN) testing the IO APIC....................... (XEN) IO APIC #8...... (XEN) .... register #00: 08000000 (XEN) ....... : physical APIC id: 08 (XEN) ....... : Delivery Type: 0 (XEN) ....... : LTS : 0 (XEN) .... register #01: 00170020 (XEN) ....... : max redirection entries: 0017 (XEN) ....... : PRQ implemented: 0 (XEN) ....... : IO APIC version: 0020 (XEN) .... IRQ redirection table: (XEN) NR Log Phy Mask Trig IRR Pol Stat Dest Deli Vect: (XEN) 00 000 00 1 0 0 0 0 0 7 00 (XEN) 01 000 00 0 0 0 0 0 1 1 62 (XEN) 02 000 00 0 0 0 0 0 1 1 F0 (XEN) 03 000 00 1 0 0 0 0 1 1 38 (XEN) 04 000 00 0 0 0 0 0 1 1 F1 (XEN) 05 000 00 0 0 0 0 0 1 1 40 (XEN) 06 000 00 0 0 0 0 0 1 1 48 (XEN) 07 000 00 0 0 0 0 0 1 1 50 (XEN) 08 000 00 0 0 0 0 0 1 1 58 (XEN) 09 000 00 0 1 0 0 0 1 1 60 (XEN) 0a 000 00 0 0 0 0 0 1 1 68 (XEN) 0b 000 00 0 0 0 0 0 1 1 70 (XEN) 0c 000 00 0 0 0 0 0 1 1 78 (XEN) 0d 000 00 1 0 0 0 0 1 1 88 (XEN) 0e 000 00 0 0 0 0 0 1 1 90 (XEN) 0f 000 00 0 0 0 0 0 1 1 98 (XEN) 10 000 00 0 1 0 1 0 1 1 A0 (XEN) 11 000 00 0 1 1 1 0 1 1 31 (XEN) 12 000 00 1 1 0 1 0 1 1 C8 (XEN) 13 000 00 0 1 0 1 0 1 1 D8 (XEN) 14 000 00 0 1 0 1 0 1 1 A8 (XEN) 15 000 00 1 0 0 0 0 0 0 00 (XEN) 16 000 00 1 0 0 0 0 0 0 00 (XEN) 17 000 00 0 1 0 1 0 1 1 B0 (XEN) Using vector-based indexing (XEN) IRQ to pin mappings: (XEN) IRQ240 -> 0:2 (XEN) IRQ98 -> 0:1 (XEN) IRQ56 -> 0:3 (XEN) IRQ241 -> 0:4 (XEN) IRQ64 -> 0:5 (XEN) IRQ72 -> 0:6 (XEN) IRQ80 -> 0:7 (XEN) IRQ88 -> 0:8 (XEN) IRQ96 -> 0:9 (XEN) IRQ104 -> 0:10 (XEN) IRQ112 -> 0:11 (XEN) IRQ120 -> 0:12 (XEN) IRQ136 -> 0:13 (XEN) IRQ144 -> 0:14 (XEN) IRQ152 -> 0:15 (XEN) IRQ160 -> 0:16 (XEN) IRQ49 -> 0:17 (XEN) IRQ200 -> 0:18 (XEN) IRQ216 -> 0:19 (XEN) IRQ168 -> 0:20 (XEN) IRQ176 -> 0:23 (XEN) .................................... done. _______________________________________________ Xen-devel mailing list Xen-devel@lists.xen.org http://lists.xen.org/xen-devel From xen-devel-bounces@lists.xen.org Wed Mar 12 01:43:22 2014 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Wed, 12 Mar 2014 01:43:22 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WNYC7-0003vG-B8; Wed, 12 Mar 2014 01:42:55 +0000 Received: from mail6.bemta5.messagelabs.com ([195.245.231.135]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WNYC5-0003vB-JB for xen-devel@lists.xen.org; Wed, 12 Mar 2014 01:42:54 +0000 Received: from [85.158.139.211:18245] by server-5.bemta-5.messagelabs.com id B3/6F-06049-C9BBF135; Wed, 12 Mar 2014 01:42:52 +0000 X-Env-Sender: linux@eikelenboom.it X-Msg-Ref: server-13.tower-206.messagelabs.com!1394588567!511013!1 X-Originating-IP: [84.200.39.61] X-SpamReason: No, hits=1.9 required=7.0 tests=BODY_RANDOM_LONG,HOT_NASTY, UPPERCASE_50_75 X-StarScan-Received: X-StarScan-Version: 6.11.1; banners=-,-,- X-VirusChecked: Checked Received: (qmail 4715 invoked from network); 12 Mar 2014 01:42:47 -0000 Received: from vserver.eikelenboom.it (HELO smtp.eikelenboom.it) (84.200.39.61) by server-13.tower-206.messagelabs.com with DHE-RSA-AES128-SHA encrypted SMTP; 12 Mar 2014 01:42:47 -0000 Received: from 89-76-ftth.on.nl ([88.159.76.89]:56637 helo=[172.16.1.20]) by smtp.eikelenboom.it with esmtpsa (TLS1.0:RSA_AES_256_CBC_SHA1:256) (Exim 4.80) (envelope-from ) id 1WNY9A-0001sj-6N; Wed, 12 Mar 2014 02:39:52 +0100 Date: Wed, 12 Mar 2014 02:42:43 +0100 From: Sander Eikelenboom Organization: Eikelenboom IT services X-Priority: 3 (Normal) Message-ID: <1751914199.20140312024243@eikelenboom.it> To: Wei Liu In-Reply-To: <20140311153616.GE19620@zion.uk.xensource.com> References: <1982379440.20140227162655@eikelenboom.it> <20140227155726.GI16241@zion.uk.xensource.com> <716618617.20140307113321@eikelenboom.it> <20140307111929.GL19620@zion.uk.xensource.com> <1554992598.20140307125518@eikelenboom.it> <9610144106.20140311000026@eikelenboom.it> <20140311101948.GX19620@zion.uk.xensource.com> <191977479.20140311133142@eikelenboom.it> <20140311123807.GB19620@zion.uk.xensource.com> <1068180642.20140311140041@eikelenboom.it> <20140311153616.GE19620@zion.uk.xensource.com> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="----------0420FB0940DD99E7F" Cc: annie li , Paul Durrant , Zoltan Kiss , xen-devel@lists.xen.org Subject: Re: [Xen-devel] Xen-unstable Linux 3.14-rc3 and 3.13 Network troubles "bisected" X-BeenThere: xen-devel@lists.xen.org X-Mailman-Version: 2.1.13 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Sender: xen-devel-bounces@lists.xen.org Errors-To: xen-devel-bounces@lists.xen.org ------------0420FB0940DD99E7F Content-Type: text/plain; charset=us-ascii Content-Transfer-Encoding: 7bit Tuesday, March 11, 2014, 4:36:16 PM, you wrote: > On Tue, Mar 11, 2014 at 02:00:41PM +0100, Sander Eikelenboom wrote: > [...] >> >> the issue when using 3.13.6 as a base and .. >> >> - pull all 3.14 patches from the git://git.kernel.org/pub/scm/linux/kernel/git/xen/tip.git tree >> >> - apply paul's commit "ca2f09f2b2c6c25047cfc545d057c4edfcfe561c xen-netback: improve guest-receive-side flow control" >> >> - applying annie's v2 patch >> >> - applying your patch >> >> as dom0 and using a 3.14-rc5 as domU kernel. >> >> >> >> Unfortunately i'm still getting the Bad grant references .. >> >> >> >> > :-( That's bad news. >> >> > I guess you always have the same DomU kernel when testing? That means we >> > can narrow down the bug to netback only. >> >> Yes my previous tests (from my previous mail): >> >> - First testing a baseline that worked o.k. for several days (3.13.6 for both dom0 and domU) >> - Testing domU 3.14-rc5 and dom0 3.13.6, this worked ok. >> - Testing dom0 3.14-rc5 and domU 3.13.6, this failed. >> - After that took 3.13.6 as base and first applied all the general xen related patches for the dom0 kernel, that works ok. >> - After that started to apply the netback changes for 3.14 and that failed after the commit "ca2f09f2b2c6c25047cfc545d057c4edfcfe561c xen-netback: improve guest-receive-side flow control". >> >> Also seem to indicate just that, although it could also be something in this netback commit that triggers a latent bug in netfront, can't rule that one out completly. >> >> But the trigger is in that commit && >> annie's and your patch seem to have no effect at all( on this issue) && >> later commits in 3.14 do seems to mask it / make it less likely to trigger, but do not fix it. >> > Unfortunately I've stared at the same piece of code for some time but > don't have immediate clue. Later commits don't look suspecious either. > I also looked at netfront code, but there's no slot couting change > between 3.13 and 3.14. > Do you have some straight setup instructions so that I can try to > reproduce. Ok you asked for it .. so here we go .. ;-) : - Xen-unstable - DomU: - PV guest - Debian Wheezy - Kernel: 3.14-rc5 (.config see dom0 .config) - Running netserver - Dom0: - Debian Wheezy - Kernel: 3.13.6 + additional patches (see attached git log and .config) - 2 physical NIC's - Autoballooning is prevented by using dom0_mem=1536M,max:1536M for xen and mem=1536M for dom0 kernel stanzas in grub - vcpu 0 is pinned on pcpu 0 and exclusively for dom0 - Networking: - Routed bridge - eth0 = internet - eth1 = lan 172.16.x.x - xen_bridge = bridge for VM's 192.168.1.x - iptables NAT and routing - attached dom0 and domU ifconfig output - attached ethtool -k output for the bridge, vif and guest eth0 Triggering workload: - Well that's were the problem is :-) - The Guest has a normal disk and swap (phy/lvm) and shared storage with glusterfs (glusterfs server is on dom0) - The Guest exposes this storage via webdavs What triggers it is: - The Guest runs it's rsync of the shared storage to a remote client on the internet So this causes traffic from Dom0 to domU (reading storage) .. back from domU to dom0 and via iptables NAT on to eth0 (actual rsync) or vice versa when syncing the other way around - At the same time do a backup from a windows machine from the lan to the webdavs server So this causes traffic from eth1 to domU (webdav) .. back from domU to dom0 (writing to the shared storage) So in essence it is doing quite some netback && netfront stress testing :-) It seems to only trigger when doing both the rsync and the webdav simultaneous. I tried my best to emulate any of this with netperf (and multiple instances), i tried with various (odd) packet sizes and the packet / byte rates transmitted are higher then with the workload above ... but it doesn't seem to trigger with netpref So i don't think it will be easy to replicate ... Perhaps running through the available logging again .. and try to answer some questions ... this is just with one guest running kernels as before only added debugging to netfront and xen (diffs attached): Mar 12 02:00:44 backup kernel: [ 496.840646] net eth0: rx->offset: 0, size: 4294967295 Mar 12 02:00:44 backup kernel: [ 496.840665] net eth0: cons:1346005 slots:1 rp:1346013 max:18 err:0 rx->id:212 rx->offset:0 size:4294967295 ref:572 pagesize:4096 skb_ipsummed:0 is_gso:0 gso_size:0 gso_type:0 gso_segs:0 RING_HAS_UNCONSUMED_RESPONSES:9 cons_changed:1 cons_before:1346004 xennet_get_extras_err:0 Mar 12 02:00:44 backup kernel: [ 496.840680] net eth0: rx->offset: 0, size: 4294967295 Mar 12 02:00:44 backup kernel: [ 496.840687] net eth0: cons:1346005 slots:2 rp:1346013 max:18 err:-22 rx->id:214 rx->offset:0 size:4294967295 ref:657 pagesize:4096 skb_ipsummed:0 is_gso:0 gso_size:0 gso_type:0 gso_segs:0 RING_HAS_UNCONSUMED_RESPONSES:9 cons_changed:1 cons_before:1346004 xennet_get_extras_err:0 Mar 12 02:00:44 backup kernel: [ 496.840701] net eth0: rx->offset: 0, size: 4294967295 Mar 12 02:00:44 backup kernel: [ 496.840712] net eth0: cons:1346005 slots:3 rp:1346013 max:18 err:-22 rx->id:215 rx->offset:0 size:4294967295 ref:667 pagesize:4096 skb_ipsummed:0 is_gso:0 gso_size:0 gso_type:0 gso_segs:0 RING_HAS_UNCONSUMED_RESPONSES:9 cons_changed:1 cons_before:1346004 xennet_get_extras_err:0 Mar 12 02:00:44 backup kernel: [ 496.840733] net eth0: rx->offset: 0, size: 4294967295 Mar 12 02:00:44 backup kernel: [ 496.840740] net eth0: cons:1346005 slots:4 rp:1346013 max:18 err:-22 rx->id:216 rx->offset:0 size:4294967295 ref:716 pagesize:4096 skb_ipsummed:0 is_gso:0 gso_size:0 gso_type:0 gso_segs:0 RING_HAS_UNCONSUMED_RESPONSES:9 cons_changed:1 cons_before:1346004 xennet_get_extras_err:0 Mar 12 02:00:44 backup kernel: [ 496.840757] net eth0: rx->offset: 0, size: 4294967295 Mar 12 02:00:44 backup kernel: [ 496.840764] net eth0: cons:1346005 slots:5 rp:1346013 max:18 err:-22 rx->id:217 rx->offset:0 size:4294967295 ref:755 pagesize:4096 skb_ipsummed:0 is_gso:0 gso_size:0 gso_type:0 gso_segs:0 RING_HAS_UNCONSUMED_RESPONSES:9 cons_changed:1 cons_before:1346004 xennet_get_extras_err:0 Mar 12 02:00:44 backup kernel: [ 496.840778] net eth0: rx->offset: 0, size: 4294967295 Mar 12 02:00:44 backup kernel: [ 496.840784] net eth0: cons:1346005 slots:6 rp:1346013 max:18 err:-22 rx->id:218 rx->offset:0 size:4294967295 ref:592 pagesize:4096 skb_ipsummed:0 is_gso:0 gso_size:0 gso_type:0 gso_segs:0 RING_HAS_UNCONSUMED_RESPONSES:9 cons_changed:1 cons_before:1346004 xennet_get_extras_err:0 Mar 12 02:00:44 backup kernel: [ 496.840801] net eth0: rx->offset: 0, size: 4294967295 Mar 12 02:00:44 backup kernel: [ 496.840807] net eth0: cons:1346005 slots:7 rp:1346013 max:18 err:-22 rx->id:219 rx->offset:0 size:4294967295 ref:633 pagesize:4096 skb_ipsummed:0 is_gso:0 gso_size:0 gso_type:0 gso_segs:0 RING_HAS_UNCONSUMED_RESPONSES:9 cons_changed:1 cons_before:1346004 xennet_get_extras_err:0 Mar 12 02:00:44 backup kernel: [ 496.841043] net eth0: rx->offset: 0, size: 4294967295 Mar 12 02:00:44 backup kernel: [ 496.841052] net eth0: cons:1346025 slots:1 rp:1346038 max:18 err:0 rx->id:232 rx->offset:0 size:4294967295 ref:-131941395332491 pagesize:4096 skb_ipsummed:0 is_gso:0 gso_size:0 gso_type:0 gso_segs:0 RING_HAS_UNCONSUMED_RESPONSES:13 cons_changed:1 cons_before:1346024 xennet_get_extras_err:0 Mar 12 02:00:44 backup kernel: [ 496.841067] net eth0: rx->offset: 0, size: 4294967295 Mar 12 02:00:44 backup kernel: [ 496.841074] net eth0: cons:1346025 slots:2 rp:1346038 max:18 err:-22 rx->id:234 rx->offset:0 size:4294967295 ref:-131941395332579 pagesize:4096 skb_ipsummed:0 is_gso:0 gso_size:0 gso_type:0 gso_segs:0 RING_HAS_UNCONSUMED_RESPONSES:29 cons_changed:1 cons_before:1346024 xennet_get_extras_err:0 Mar 12 02:00:44 backup kernel: [ 496.841092] net eth0: rx->offset: 0, size: 4294967295 Mar 12 02:00:44 backup kernel: [ 496.841101] net eth0: cons:1346025 slots:3 rp:1346038 max:18 err:-22 rx->id:235 rx->offset:0 size:4294967295 ref:-131941395332408 pagesize:4096 skb_ipsummed:0 is_gso:0 gso_size:0 gso_type:0 gso_segs:0 RING_HAS_UNCONSUMED_RESPONSES:29 cons_changed:1 cons_before:1346024 xennet_get_extras_err:0 (XEN) [2014-03-12 01:00:44] grant_table.c:1856:d0v2 Bad grant reference 4325377 gt_version:1 ldom:0 readonly:0 allow_transitive:1 (XEN) [2014-03-12 01:00:44] grant_table.c:2100:d0v2 acquire_grant_for_copy failed .. dest_is_gref rc:-3 source.domid:32752 dest.domid:1 s_frame:5478146 source_off:0 source_len:4096 op->source.offset:0 op->len:1168 (XEN) [2014-03-12 01:00:44] grant_table.c:1856:d0v2 Bad grant reference 19791875 gt_version:1 ldom:0 readonly:0 allow_transitive:1 (XEN) [2014-03-12 01:00:44] grant_table.c:2100:d0v2 acquire_grant_for_copy failed .. dest_is_gref rc:-3 source.domid:32752 dest.domid:1 s_frame:5497610 source_off:0 source_len:4096 op->source.offset:0 op->len:2476 (XEN) [2014-03-12 01:00:44] grant_table.c:1856:d0v2 Bad grant reference 4325379 gt_version:1 ldom:0 readonly:0 allow_transitive:1 (XEN) [2014-03-12 01:00:44] grant_table.c:2100:d0v2 acquire_grant_for_copy failed .. dest_is_gref rc:-3 source.domid:32752 dest.domid:1 s_frame:5478282 source_off:0 source_len:4096 op->source.offset:0 op->len:1634 (XEN) [2014-03-12 01:00:44] grant_table.c:1856:d0v2 Bad grant reference 4325379 gt_version:1 ldom:0 readonly:0 allow_transitive:1 (XEN) [2014-03-12 01:00:44] grant_table.c:2100:d0v2 acquire_grant_for_copy failed .. dest_is_gref rc:-3 source.domid:32752 dest.domid:1 s_frame:5497610 source_off:0 source_len:4096 op->source.offset:1634 op->len:1620 (XEN) [2014-03-12 01:00:44] grant_table.c:1856:d0v2 Bad grant reference 4325377 gt_version:1 ldom:0 readonly:0 allow_transitive:1 (XEN) [2014-03-12 01:00:44] grant_table.c:2100:d0v2 acquire_grant_for_copy failed .. dest_is_gref rc:-3 source.domid:32752 dest.domid:1 s_frame:5497609 source_off:0 source_len:4096 op->source.offset:0 op->len:4096 (XEN) [2014-03-12 01:00:44] grant_table.c:1856:d0v2 Bad grant reference 19791875 gt_version:1 ldom:0 readonly:0 allow_transitive:1 - Sometimes (but not always) netfront also spits out: dev_warn(dev, "Invalid extra type: %d\n", extra->type); where the extra type seems a random value (seen 196, 31 ..) - Sometimes (but not always) netfront also spits out: dev_warn(dev, "Need more slots\n"); - Sometimes (but not always) netfront also spits out: dev_warn(dev, "Missing extra info\n"); First question that comes to my mind: - Are the warnings netfront spits out the cause of xen reporting the bad grant reference ? Or Are the Bad grant references Xen is reporting .. causing netfront to spit out the warnings ? - Why is that "if (rx->flags & XEN_NETRXF_extra_info) {}" part in xen-netfront.c doing there and changing cons midway ? The commit message from f942dc2552b8bfdee607be867b12a8971bb9cd85 that introduced the if says: One major change from xen.git is that the guest transmit path (i.e. what looks like receive to netback) has been significantly reworked to remove the dependency on the out of tree PageForeign page flag (a core kernel patch which enables a per page destructor callback on the final put_page). This page flag was used in order to implement a grant map based transmit path (where guest pages are mapped directly into SKB frags). Instead this version of netback uses grant copy operations into regular memory belonging to the backend domain. Reinstating the grant map functionality is something which I would like to revisit in the future. It *is* using grant copy now .. so should this part have been removed ? And Could Paul's commit that seems to be the first to trigger these events affect this ? -- Sander > Wei. >> > Paul, do you have any idea what might go wrong? >> >> > Wei. >> ------------0420FB0940DD99E7F Content-Type: text/plain; name="ethtool-domu-eth0.txt" Content-transfer-encoding: base64 Content-Disposition: attachment; filename="ethtool-domu-eth0.txt" RmVhdHVyZXMgZm9yIGV0aDA6CnJ4LWNoZWNrc3VtbWluZzogb24gW2ZpeGVkXQp0eC1jaGVj a3N1bW1pbmc6IG9uCgl0eC1jaGVja3N1bS1pcHY0OiBvbiBbZml4ZWRdCgl0eC1jaGVja3N1 bS1pcC1nZW5lcmljOiBvZmYgW2ZpeGVkXQoJdHgtY2hlY2tzdW0taXB2Njogb24KCXR4LWNo ZWNrc3VtLWZjb2UtY3JjOiBvZmYgW2ZpeGVkXQoJdHgtY2hlY2tzdW0tc2N0cDogb2ZmIFtm aXhlZF0Kc2NhdHRlci1nYXRoZXI6IG9uCgl0eC1zY2F0dGVyLWdhdGhlcjogb24KCXR4LXNj YXR0ZXItZ2F0aGVyLWZyYWdsaXN0OiBvZmYgW2ZpeGVkXQp0Y3Atc2VnbWVudGF0aW9uLW9m ZmxvYWQ6IG9uCgl0eC10Y3Atc2VnbWVudGF0aW9uOiBvbgoJdHgtdGNwLWVjbi1zZWdtZW50 YXRpb246IG9mZiBbZml4ZWRdCgl0eC10Y3A2LXNlZ21lbnRhdGlvbjogb24KdWRwLWZyYWdt ZW50YXRpb24tb2ZmbG9hZDogb2ZmIFtmaXhlZF0KZ2VuZXJpYy1zZWdtZW50YXRpb24tb2Zm bG9hZDogb24KZ2VuZXJpYy1yZWNlaXZlLW9mZmxvYWQ6IG9uCmxhcmdlLXJlY2VpdmUtb2Zm bG9hZDogb2ZmIFtmaXhlZF0Kcngtdmxhbi1vZmZsb2FkOiBvZmYgW2ZpeGVkXQp0eC12bGFu LW9mZmxvYWQ6IG9mZiBbZml4ZWRdCm50dXBsZS1maWx0ZXJzOiBvZmYgW2ZpeGVkXQpyZWNl aXZlLWhhc2hpbmc6IG9mZiBbZml4ZWRdCmhpZ2hkbWE6IG9mZiBbZml4ZWRdCnJ4LXZsYW4t ZmlsdGVyOiBvZmYgW2ZpeGVkXQp2bGFuLWNoYWxsZW5nZWQ6IG9mZiBbZml4ZWRdCnR4LWxv Y2tsZXNzOiBvZmYgW2ZpeGVkXQpuZXRucy1sb2NhbDogb2ZmIFtmaXhlZF0KdHgtZ3NvLXJv YnVzdDogb24gW2ZpeGVkXQp0eC1mY29lLXNlZ21lbnRhdGlvbjogb2ZmIFtmaXhlZF0KdHgt Z3JlLXNlZ21lbnRhdGlvbjogb2ZmIFtmaXhlZF0KdHgtaXBpcC1zZWdtZW50YXRpb246IG9m ZiBbZml4ZWRdCnR4LXNpdC1zZWdtZW50YXRpb246IG9mZiBbZml4ZWRdCnR4LXVkcF90bmwt c2VnbWVudGF0aW9uOiBvZmYgW2ZpeGVkXQp0eC1tcGxzLXNlZ21lbnRhdGlvbjogb2ZmIFtm aXhlZF0KZmNvZS1tdHU6IG9mZiBbZml4ZWRdCnR4LW5vY2FjaGUtY29weTogb2ZmCmxvb3Bi YWNrOiBvZmYgW2ZpeGVkXQpyeC1mY3M6IG9mZiBbZml4ZWRdCnJ4LWFsbDogb2ZmIFtmaXhl ZF0KdHgtdmxhbi1zdGFnLWh3LWluc2VydDogb2ZmIFtmaXhlZF0Kcngtdmxhbi1zdGFnLWh3 LXBhcnNlOiBvZmYgW2ZpeGVkXQpyeC12bGFuLXN0YWctZmlsdGVyOiBvZmYgW2ZpeGVkXQps Mi1md2Qtb2ZmbG9hZDogb2ZmIFtmaXhlZF0K ------------0420FB0940DD99E7F Content-Type: text/plain; name="ethtool-vif.txt" Content-transfer-encoding: base64 Content-Disposition: attachment; filename="ethtool-vif.txt" RmVhdHVyZXMgZm9yIHZpZjEuMDoKcngtY2hlY2tzdW1taW5nOiBvbiBbZml4ZWRdCnR4LWNo ZWNrc3VtbWluZzogb24KCXR4LWNoZWNrc3VtLWlwdjQ6IG9uCgl0eC1jaGVja3N1bS1pcC1n ZW5lcmljOiBvZmYgW2ZpeGVkXQoJdHgtY2hlY2tzdW0taXB2Njogb24KCXR4LWNoZWNrc3Vt LWZjb2UtY3JjOiBvZmYgW2ZpeGVkXQoJdHgtY2hlY2tzdW0tc2N0cDogb2ZmIFtmaXhlZF0K c2NhdHRlci1nYXRoZXI6IG9uCgl0eC1zY2F0dGVyLWdhdGhlcjogb24KCXR4LXNjYXR0ZXIt Z2F0aGVyLWZyYWdsaXN0OiBvZmYgW2ZpeGVkXQp0Y3Atc2VnbWVudGF0aW9uLW9mZmxvYWQ6 IG9uCgl0eC10Y3Atc2VnbWVudGF0aW9uOiBvbgoJdHgtdGNwLWVjbi1zZWdtZW50YXRpb246 IG9mZiBbZml4ZWRdCgl0eC10Y3A2LXNlZ21lbnRhdGlvbjogb24KdWRwLWZyYWdtZW50YXRp b24tb2ZmbG9hZDogb2ZmIFtmaXhlZF0KZ2VuZXJpYy1zZWdtZW50YXRpb24tb2ZmbG9hZDog b24KZ2VuZXJpYy1yZWNlaXZlLW9mZmxvYWQ6IG9uCmxhcmdlLXJlY2VpdmUtb2ZmbG9hZDog b2ZmIFtmaXhlZF0Kcngtdmxhbi1vZmZsb2FkOiBvZmYgW2ZpeGVkXQp0eC12bGFuLW9mZmxv YWQ6IG9mZiBbZml4ZWRdCm50dXBsZS1maWx0ZXJzOiBvZmYgW2ZpeGVkXQpyZWNlaXZlLWhh c2hpbmc6IG9mZiBbZml4ZWRdCmhpZ2hkbWE6IG9mZiBbZml4ZWRdCnJ4LXZsYW4tZmlsdGVy OiBvZmYgW2ZpeGVkXQp2bGFuLWNoYWxsZW5nZWQ6IG9mZiBbZml4ZWRdCnR4LWxvY2tsZXNz OiBvZmYgW2ZpeGVkXQpuZXRucy1sb2NhbDogb2ZmIFtmaXhlZF0KdHgtZ3NvLXJvYnVzdDog b2ZmIFtmaXhlZF0KdHgtZmNvZS1zZWdtZW50YXRpb246IG9mZiBbZml4ZWRdCnR4LWdyZS1z ZWdtZW50YXRpb246IG9mZiBbZml4ZWRdCnR4LWlwaXAtc2VnbWVudGF0aW9uOiBvZmYgW2Zp eGVkXQp0eC1zaXQtc2VnbWVudGF0aW9uOiBvZmYgW2ZpeGVkXQp0eC11ZHBfdG5sLXNlZ21l bnRhdGlvbjogb2ZmIFtmaXhlZF0KdHgtbXBscy1zZWdtZW50YXRpb246IG9mZiBbZml4ZWRd CmZjb2UtbXR1OiBvZmYgW2ZpeGVkXQp0eC1ub2NhY2hlLWNvcHk6IG9uCmxvb3BiYWNrOiBv ZmYgW2ZpeGVkXQpyeC1mY3M6IG9mZiBbZml4ZWRdCnJ4LWFsbDogb2ZmIFtmaXhlZF0KdHgt dmxhbi1zdGFnLWh3LWluc2VydDogb2ZmIFtmaXhlZF0Kcngtdmxhbi1zdGFnLWh3LXBhcnNl OiBvZmYgW2ZpeGVkXQpyeC12bGFuLXN0YWctZmlsdGVyOiBvZmYgW2ZpeGVkXQpsMi1md2Qt b2ZmbG9hZDogb2ZmIFtmaXhlZF0K ------------0420FB0940DD99E7F Content-Type: text/plain; name="ethtool-xenbridge.txt" Content-transfer-encoding: base64 Content-Disposition: attachment; filename="ethtool-xenbridge.txt" RmVhdHVyZXMgZm9yIHhlbl9icmlkZ2U6CnJ4LWNoZWNrc3VtbWluZzogb2ZmIFtmaXhlZF0K dHgtY2hlY2tzdW1taW5nOiBvbgoJdHgtY2hlY2tzdW0taXB2NDogb2ZmIFtmaXhlZF0KCXR4 LWNoZWNrc3VtLWlwLWdlbmVyaWM6IG9uCgl0eC1jaGVja3N1bS1pcHY2OiBvZmYgW2ZpeGVk XQoJdHgtY2hlY2tzdW0tZmNvZS1jcmM6IG9mZiBbZml4ZWRdCgl0eC1jaGVja3N1bS1zY3Rw OiBvZmYgW2ZpeGVkXQpzY2F0dGVyLWdhdGhlcjogb24KCXR4LXNjYXR0ZXItZ2F0aGVyOiBv bgoJdHgtc2NhdHRlci1nYXRoZXItZnJhZ2xpc3Q6IG9mZiBbcmVxdWVzdGVkIG9uXQp0Y3At c2VnbWVudGF0aW9uLW9mZmxvYWQ6IG9uCgl0eC10Y3Atc2VnbWVudGF0aW9uOiBvbgoJdHgt dGNwLWVjbi1zZWdtZW50YXRpb246IG9mZiBbcmVxdWVzdGVkIG9uXQoJdHgtdGNwNi1zZWdt ZW50YXRpb246IG9uCnVkcC1mcmFnbWVudGF0aW9uLW9mZmxvYWQ6IG9mZiBbcmVxdWVzdGVk IG9uXQpnZW5lcmljLXNlZ21lbnRhdGlvbi1vZmZsb2FkOiBvbgpnZW5lcmljLXJlY2VpdmUt b2ZmbG9hZDogb24KbGFyZ2UtcmVjZWl2ZS1vZmZsb2FkOiBvZmYgW2ZpeGVkXQpyeC12bGFu LW9mZmxvYWQ6IG9mZiBbZml4ZWRdCnR4LXZsYW4tb2ZmbG9hZDogb24KbnR1cGxlLWZpbHRl cnM6IG9mZiBbZml4ZWRdCnJlY2VpdmUtaGFzaGluZzogb2ZmIFtmaXhlZF0KaGlnaGRtYTog b2ZmIFtyZXF1ZXN0ZWQgb25dCnJ4LXZsYW4tZmlsdGVyOiBvZmYgW2ZpeGVkXQp2bGFuLWNo YWxsZW5nZWQ6IG9mZiBbZml4ZWRdCnR4LWxvY2tsZXNzOiBvbiBbZml4ZWRdCm5ldG5zLWxv Y2FsOiBvbiBbZml4ZWRdCnR4LWdzby1yb2J1c3Q6IG9mZiBbcmVxdWVzdGVkIG9uXQp0eC1m Y29lLXNlZ21lbnRhdGlvbjogb2ZmIFtyZXF1ZXN0ZWQgb25dCnR4LWdyZS1zZWdtZW50YXRp b246IG9uCnR4LWlwaXAtc2VnbWVudGF0aW9uOiBvbgp0eC1zaXQtc2VnbWVudGF0aW9uOiBv bgp0eC11ZHBfdG5sLXNlZ21lbnRhdGlvbjogb24KdHgtbXBscy1zZWdtZW50YXRpb246IG9u CmZjb2UtbXR1OiBvZmYgW2ZpeGVkXQp0eC1ub2NhY2hlLWNvcHk6IG9uCmxvb3BiYWNrOiBv ZmYgW2ZpeGVkXQpyeC1mY3M6IG9mZiBbZml4ZWRdCnJ4LWFsbDogb2ZmIFtmaXhlZF0KdHgt dmxhbi1zdGFnLWh3LWluc2VydDogb2ZmIFtmaXhlZF0Kcngtdmxhbi1zdGFnLWh3LXBhcnNl OiBvZmYgW2ZpeGVkXQpyeC12bGFuLXN0YWctZmlsdGVyOiBvZmYgW2ZpeGVkXQpsMi1md2Qt b2ZmbG9hZDogb2ZmIFtmaXhlZF0K ------------0420FB0940DD99E7F Content-Type: application/octet-stream; name="grant_table_debug.diff" Content-transfer-encoding: base64 Content-Disposition: attachment; filename="grant_table_debug.diff" ZGlmZiAtLWdpdCBhL3hlbi9jb21tb24vZ3JhbnRfdGFibGUuYyBiL3hlbi9jb21tb24vZ3Jh bnRfdGFibGUuYwppbmRleCAxMDdiMDAwLi4zMzdlMTdhIDEwMDY0NAotLS0gYS94ZW4vY29t bW9uL2dyYW50X3RhYmxlLmMKKysrIGIveGVuL2NvbW1vbi9ncmFudF90YWJsZS5jCkBAIC0x ODUyLDEwICsxODUyLDkgQEAgX19hY3F1aXJlX2dyYW50X2Zvcl9jb3B5KAogICAgICAgICBQ SU5fRkFJTCh1bmxvY2tfb3V0LCBHTlRTVF9nZW5lcmFsX2Vycm9yLAogICAgICAgICAgICAg ICAgICAicmVtb3RlIGdyYW50IHRhYmxlIG5vdCByZWFkeVxuIik7CiAKLSAgICBpZiAoIHVu bGlrZWx5KGdyZWYgPj0gbnJfZ3JhbnRfZW50cmllcyhyZ3QpKSApCi0gICAgICAgIFBJTl9G QUlMKHVubG9ja19vdXQsIEdOVFNUX2JhZF9nbnRyZWYsCi0gICAgICAgICAgICAgICAgICJC YWQgZ3JhbnQgcmVmZXJlbmNlICVsZFxuIiwgZ3JlZik7Ci0KKyAgICBpZiAoIHVubGlrZWx5 KGdyZWYgPj0gbnJfZ3JhbnRfZW50cmllcyhyZ3QpKSApeworICAgICAgICBQSU5fRkFJTCh1 bmxvY2tfb3V0LCBHTlRTVF9iYWRfZ250cmVmLCAiQmFkIGdyYW50IHJlZmVyZW5jZSAlbGQg Z3RfdmVyc2lvbjolZCBsZG9tOiVkIHJlYWRvbmx5OiVkIGFsbG93X3RyYW5zaXRpdmU6JWRc biIsIGdyZWYsIHJndC0+Z3RfdmVyc2lvbiwgbGRvbSwgcmVhZG9ubHksIGFsbG93X3RyYW5z aXRpdmUpOworICAgIH0KICAgICBhY3QgPSAmYWN0aXZlX2VudHJ5KHJndCwgZ3JlZik7CiAg ICAgc2hhaCA9IHNoYXJlZF9lbnRyeV9oZWFkZXIocmd0LCBncmVmKTsKICAgICBpZiAoIHJn dC0+Z3RfdmVyc2lvbiA9PSAxICkKQEAgLTIwNzEsOCArMjA3MCwxMCBAQCBfX2dudHRhYl9j b3B5KAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjdXJyZW50LT5k b21haW4tPmRvbWFpbl9pZCwgMSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgJnNfZnJhbWUsICZzX3BnLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAmc291cmNlX29mZiwgJnNvdXJjZV9sZW4sIDEpOwotICAgICAgICBpZiAoIHJj ICE9IEdOVFNUX29rYXkgKQotICAgICAgICAgICAgZ290byBlcnJvcl9vdXQ7CisgICAgICAg IGlmICggcmMgIT0gR05UU1Rfb2theSApeworICAgICAgICAgICAgZ2RwcmludGsoWEVOTE9H X1dBUk5JTkcsICJhY3F1aXJlX2dyYW50X2Zvcl9jb3B5IGZhaWxlZCAuLiBzcmNfaXNfZ3Jl ZiByYzolZCBzb3VyY2UuZG9taWQ6JWQgZGVzdC5kb21pZDolZCBzX2ZyYW1lOiVsZCBzb3Vy Y2Vfb2ZmOiV1IHNvdXJjZV9sZW46JXUgb3AtPnNvdXJjZS5vZmZzZXQ6JWQgb3AtPmxlbjol ZFxuIiwgcmMsIG9wLT5zb3VyY2UuZG9taWQsIG9wLT5kZXN0LmRvbWlkLCBzX2ZyYW1lLCBz b3VyY2Vfb2ZmLCBzb3VyY2VfbGVuLCBvcC0+c291cmNlLm9mZnNldCwgb3AtPmxlbik7CisJ ICAgIGdvdG8gZXJyb3Jfb3V0OworCX0KICAgICAgICAgaGF2ZV9zX2dyYW50ID0gMTsKICAg ICAgICAgaWYgKCBvcC0+c291cmNlLm9mZnNldCA8IHNvdXJjZV9vZmYgfHwKICAgICAgICAg ICAgICBvcC0+bGVuID4gc291cmNlX2xlbiApCkBAIC0yMDk1LDggKzIwOTYsMTAgQEAgX19n bnR0YWJfY29weSgKICAgICAgICAgcmMgPSBfX2FjcXVpcmVfZ3JhbnRfZm9yX2NvcHkoZGQs IG9wLT5kZXN0LnUucmVmLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBjdXJyZW50LT5kb21haW4tPmRvbWFpbl9pZCwgMCwKICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgJmRfZnJhbWUsICZkX3BnLCAmZGVzdF9vZmYsICZkZXN0X2xl biwgMSk7Ci0gICAgICAgIGlmICggcmMgIT0gR05UU1Rfb2theSApCi0gICAgICAgICAgICBn b3RvIGVycm9yX291dDsKKyAgICAgICAgaWYgKCByYyAhPSBHTlRTVF9va2F5ICl7CisgICAg ICAgICAgICBnZHByaW50ayhYRU5MT0dfV0FSTklORywgImFjcXVpcmVfZ3JhbnRfZm9yX2Nv cHkgZmFpbGVkIC4uIGRlc3RfaXNfZ3JlZiByYzolZCBzb3VyY2UuZG9taWQ6JWQgZGVzdC5k b21pZDolZCBzX2ZyYW1lOiVsZCBzb3VyY2Vfb2ZmOiV1IHNvdXJjZV9sZW46JXUgb3AtPnNv dXJjZS5vZmZzZXQ6JWQgb3AtPmxlbjolZFxuIiwgcmMsIG9wLT5zb3VyY2UuZG9taWQsIG9w LT5kZXN0LmRvbWlkLCBzX2ZyYW1lLCBkZXN0X29mZiwgZGVzdF9sZW4sIG9wLT5kZXN0Lm9m ZnNldCwgb3AtPmxlbik7CisJICAgIGdvdG8gZXJyb3Jfb3V0OworCX0KICAgICAgICAgaGF2 ZV9kX2dyYW50ID0gMTsKICAgICAgICAgaWYgKCBvcC0+ZGVzdC5vZmZzZXQgPCBkZXN0X29m ZiB8fAogICAgICAgICAgICAgIG9wLT5sZW4gPiBkZXN0X2xlbiApCg== ------------0420FB0940DD99E7F Content-Type: text/plain; name="ifconfig-domu.txt" Content-transfer-encoding: base64 Content-Disposition: attachment; filename="ifconfig-domu.txt" ZXRoMCAgICAgIExpbmsgZW5jYXA6RXRoZXJuZXQgIEhXYWRkciAwMDoxNjozZTozZTozYzpi OSAgCiAgICAgICAgICBpbmV0IGFkZHI6MTkyLjE2OC4xLjkgIEJjYXN0OjE5Mi4xNjguMS4y NTUgIE1hc2s6MjU1LjI1NS4yNTUuMAogICAgICAgICAgVVAgQlJPQURDQVNUIFJVTk5JTkcg TVVMVElDQVNUICBNVFU6MTUwMCAgTWV0cmljOjEKICAgICAgICAgIFJYIHBhY2tldHM6MjAx MjcxNDQgZXJyb3JzOjAgZHJvcHBlZDowIG92ZXJydW5zOjAgZnJhbWU6MAogICAgICAgICAg VFggcGFja2V0czoxMzQxNjgyOSBlcnJvcnM6MCBkcm9wcGVkOjAgb3ZlcnJ1bnM6MCBjYXJy aWVyOjAKICAgICAgICAgIGNvbGxpc2lvbnM6MCB0eHF1ZXVlbGVuOjEwMDAgCiAgICAgICAg ICBSWCBieXRlczoxMTExNTYwNTY2MyAoMTAuMyBHaUIpICBUWCBieXRlczoxMDk1NDU1NDUw OCAoMTAuMiBHaUIpCgpsbyAgICAgICAgTGluayBlbmNhcDpMb2NhbCBMb29wYmFjayAgCiAg ICAgICAgICBpbmV0IGFkZHI6MTI3LjAuMC4xICBNYXNrOjI1NS4wLjAuMAogICAgICAgICAg VVAgTE9PUEJBQ0sgUlVOTklORyAgTVRVOjY1NTM2ICBNZXRyaWM6MQogICAgICAgICAgUlgg cGFja2V0czowIGVycm9yczowIGRyb3BwZWQ6MCBvdmVycnVuczowIGZyYW1lOjAKICAgICAg ICAgIFRYIHBhY2tldHM6MCBlcnJvcnM6MCBkcm9wcGVkOjAgb3ZlcnJ1bnM6MCBjYXJyaWVy OjAKICAgICAgICAgIGNvbGxpc2lvbnM6MCB0eHF1ZXVlbGVuOjAgCiAgICAgICAgICBSWCBi eXRlczowICgwLjAgQikgIFRYIGJ5dGVzOjAgKDAuMCBCKQoK ------------0420FB0940DD99E7F Content-Type: text/plain; name="kernel-dom0-dotconfig.txt" Content-transfer-encoding: base64 Content-Disposition: attachment; filename="kernel-dom0-dotconfig.txt" IwojIEF1dG9tYXRpY2FsbHkgZ2VuZXJhdGVkIGZpbGU7IERPIE5PVCBFRElULgojIExpbnV4 L3g4Nl82NCAzLjEzLjYtMjAxNDAzMTEteGVuMzE0LW5ldGJhY2stY2EyZjA5LWFubmllLXdl aSBLZXJuZWwgQ29uZmlndXJhdGlvbgojCkNPTkZJR182NEJJVD15CkNPTkZJR19YODZfNjQ9 eQpDT05GSUdfWDg2PXkKQ09ORklHX0lOU1RSVUNUSU9OX0RFQ09ERVI9eQpDT05GSUdfT1VU UFVUX0ZPUk1BVD0iZWxmNjQteDg2LTY0IgpDT05GSUdfQVJDSF9ERUZDT05GSUc9ImFyY2gv eDg2L2NvbmZpZ3MveDg2XzY0X2RlZmNvbmZpZyIKQ09ORklHX0xPQ0tERVBfU1VQUE9SVD15 CkNPTkZJR19TVEFDS1RSQUNFX1NVUFBPUlQ9eQpDT05GSUdfSEFWRV9MQVRFTkNZVE9QX1NV UFBPUlQ9eQpDT05GSUdfTU1VPXkKQ09ORklHX05FRURfRE1BX01BUF9TVEFURT15CkNPTkZJ R19ORUVEX1NHX0RNQV9MRU5HVEg9eQpDT05GSUdfR0VORVJJQ19JU0FfRE1BPXkKQ09ORklH X0dFTkVSSUNfQlVHPXkKQ09ORklHX0dFTkVSSUNfQlVHX1JFTEFUSVZFX1BPSU5URVJTPXkK Q09ORklHX0dFTkVSSUNfSFdFSUdIVD15CkNPTkZJR19BUkNIX01BWV9IQVZFX1BDX0ZEQz15 CkNPTkZJR19SV1NFTV9YQ0hHQUREX0FMR09SSVRITT15CkNPTkZJR19HRU5FUklDX0NBTElC UkFURV9ERUxBWT15CkNPTkZJR19BUkNIX0hBU19DUFVfUkVMQVg9eQpDT05GSUdfQVJDSF9I QVNfQ0FDSEVfTElORV9TSVpFPXkKQ09ORklHX0FSQ0hfSEFTX0NQVV9BVVRPUFJPQkU9eQpD T05GSUdfSEFWRV9TRVRVUF9QRVJfQ1BVX0FSRUE9eQpDT05GSUdfTkVFRF9QRVJfQ1BVX0VN QkVEX0ZJUlNUX0NIVU5LPXkKQ09ORklHX05FRURfUEVSX0NQVV9QQUdFX0ZJUlNUX0NIVU5L PXkKQ09ORklHX0FSQ0hfSElCRVJOQVRJT05fUE9TU0lCTEU9eQpDT05GSUdfQVJDSF9TVVNQ RU5EX1BPU1NJQkxFPXkKQ09ORklHX0FSQ0hfV0FOVF9IVUdFX1BNRF9TSEFSRT15CkNPTkZJ R19BUkNIX1dBTlRfR0VORVJBTF9IVUdFVExCPXkKQ09ORklHX1pPTkVfRE1BMzI9eQpDT05G SUdfQVVESVRfQVJDSD15CkNPTkZJR19BUkNIX1NVUFBPUlRTX09QVElNSVpFRF9JTkxJTklO Rz15CkNPTkZJR19BUkNIX1NVUFBPUlRTX0RFQlVHX1BBR0VBTExPQz15CkNPTkZJR19YODZf NjRfU01QPXkKQ09ORklHX1g4Nl9IVD15CkNPTkZJR19BUkNIX0hXRUlHSFRfQ0ZMQUdTPSIt ZmNhbGwtc2F2ZWQtcmRpIC1mY2FsbC1zYXZlZC1yc2kgLWZjYWxsLXNhdmVkLXJkeCAtZmNh bGwtc2F2ZWQtcmN4IC1mY2FsbC1zYXZlZC1yOCAtZmNhbGwtc2F2ZWQtcjkgLWZjYWxsLXNh dmVkLXIxMCAtZmNhbGwtc2F2ZWQtcjExIgpDT05GSUdfQVJDSF9TVVBQT1JUU19VUFJPQkVT PXkKQ09ORklHX0RFRkNPTkZJR19MSVNUPSIvbGliL21vZHVsZXMvJFVOQU1FX1JFTEVBU0Uv LmNvbmZpZyIKQ09ORklHX0lSUV9XT1JLPXkKQ09ORklHX0JVSUxEVElNRV9FWFRBQkxFX1NP UlQ9eQoKIwojIEdlbmVyYWwgc2V0dXAKIwpDT05GSUdfSU5JVF9FTlZfQVJHX0xJTUlUPTMy CkNPTkZJR19DUk9TU19DT01QSUxFPSIiCiMgQ09ORklHX0NPTVBJTEVfVEVTVCBpcyBub3Qg c2V0CkNPTkZJR19MT0NBTFZFUlNJT049IiIKIyBDT05GSUdfTE9DQUxWRVJTSU9OX0FVVE8g aXMgbm90IHNldApDT05GSUdfSEFWRV9LRVJORUxfR1pJUD15CkNPTkZJR19IQVZFX0tFUk5F TF9CWklQMj15CkNPTkZJR19IQVZFX0tFUk5FTF9MWk1BPXkKQ09ORklHX0hBVkVfS0VSTkVM X1haPXkKQ09ORklHX0hBVkVfS0VSTkVMX0xaTz15CkNPTkZJR19IQVZFX0tFUk5FTF9MWjQ9 eQpDT05GSUdfS0VSTkVMX0daSVA9eQojIENPTkZJR19LRVJORUxfQlpJUDIgaXMgbm90IHNl dAojIENPTkZJR19LRVJORUxfTFpNQSBpcyBub3Qgc2V0CiMgQ09ORklHX0tFUk5FTF9YWiBp cyBub3Qgc2V0CiMgQ09ORklHX0tFUk5FTF9MWk8gaXMgbm90IHNldAojIENPTkZJR19LRVJO RUxfTFo0IGlzIG5vdCBzZXQKQ09ORklHX0RFRkFVTFRfSE9TVE5BTUU9Iihub25lKSIKQ09O RklHX1NXQVA9eQpDT05GSUdfU1lTVklQQz15CkNPTkZJR19TWVNWSVBDX1NZU0NUTD15CiMg Q09ORklHX1BPU0lYX01RVUVVRSBpcyBub3Qgc2V0CiMgQ09ORklHX0ZIQU5ETEUgaXMgbm90 IHNldApDT05GSUdfQVVESVQ9eQpDT05GSUdfQVVESVRTWVNDQUxMPXkKQ09ORklHX0FVRElU X1dBVENIPXkKQ09ORklHX0FVRElUX1RSRUU9eQoKIwojIElSUSBzdWJzeXN0ZW0KIwpDT05G SUdfR0VORVJJQ19JUlFfUFJPQkU9eQpDT05GSUdfR0VORVJJQ19JUlFfU0hPVz15CkNPTkZJ R19HRU5FUklDX1BFTkRJTkdfSVJRPXkKQ09ORklHX0lSUV9ET01BSU49eQojIENPTkZJR19J UlFfRE9NQUlOX0RFQlVHIGlzIG5vdCBzZXQKQ09ORklHX0lSUV9GT1JDRURfVEhSRUFESU5H PXkKQ09ORklHX1NQQVJTRV9JUlE9eQpDT05GSUdfQ0xPQ0tTT1VSQ0VfV0FUQ0hET0c9eQpD T05GSUdfQVJDSF9DTE9DS1NPVVJDRV9EQVRBPXkKQ09ORklHX0dFTkVSSUNfVElNRV9WU1lT Q0FMTD15CkNPTkZJR19HRU5FUklDX0NMT0NLRVZFTlRTPXkKQ09ORklHX0dFTkVSSUNfQ0xP Q0tFVkVOVFNfQlVJTEQ9eQpDT05GSUdfR0VORVJJQ19DTE9DS0VWRU5UU19CUk9BRENBU1Q9 eQpDT05GSUdfR0VORVJJQ19DTE9DS0VWRU5UU19NSU5fQURKVVNUPXkKQ09ORklHX0dFTkVS SUNfQ01PU19VUERBVEU9eQoKIwojIFRpbWVycyBzdWJzeXN0ZW0KIwpDT05GSUdfVElDS19P TkVTSE9UPXkKQ09ORklHX05PX0haX0NPTU1PTj15CiMgQ09ORklHX0haX1BFUklPRElDIGlz IG5vdCBzZXQKQ09ORklHX05PX0haX0lETEU9eQojIENPTkZJR19OT19IWl9GVUxMIGlzIG5v dCBzZXQKQ09ORklHX05PX0haPXkKQ09ORklHX0hJR0hfUkVTX1RJTUVSUz15CgojCiMgQ1BV L1Rhc2sgdGltZSBhbmQgc3RhdHMgYWNjb3VudGluZwojCkNPTkZJR19USUNLX0NQVV9BQ0NP VU5USU5HPXkKIyBDT05GSUdfVklSVF9DUFVfQUNDT1VOVElOR19HRU4gaXMgbm90IHNldAoj IENPTkZJR19JUlFfVElNRV9BQ0NPVU5USU5HIGlzIG5vdCBzZXQKQ09ORklHX0JTRF9QUk9D RVNTX0FDQ1Q9eQojIENPTkZJR19CU0RfUFJPQ0VTU19BQ0NUX1YzIGlzIG5vdCBzZXQKQ09O RklHX1RBU0tTVEFUUz15CkNPTkZJR19UQVNLX0RFTEFZX0FDQ1Q9eQpDT05GSUdfVEFTS19Y QUNDVD15CkNPTkZJR19UQVNLX0lPX0FDQ09VTlRJTkc9eQoKIwojIFJDVSBTdWJzeXN0ZW0K IwpDT05GSUdfVFJFRV9SQ1U9eQojIENPTkZJR19QUkVFTVBUX1JDVSBpcyBub3Qgc2V0CkNP TkZJR19SQ1VfU1RBTExfQ09NTU9OPXkKIyBDT05GSUdfUkNVX1VTRVJfUVMgaXMgbm90IHNl dApDT05GSUdfUkNVX0ZBTk9VVD02NApDT05GSUdfUkNVX0ZBTk9VVF9MRUFGPTE2CiMgQ09O RklHX1JDVV9GQU5PVVRfRVhBQ1QgaXMgbm90IHNldApDT05GSUdfUkNVX0ZBU1RfTk9fSFo9 eQojIENPTkZJR19UUkVFX1JDVV9UUkFDRSBpcyBub3Qgc2V0CiMgQ09ORklHX1JDVV9OT0NC X0NQVSBpcyBub3Qgc2V0CkNPTkZJR19JS0NPTkZJRz15CiMgQ09ORklHX0lLQ09ORklHX1BS T0MgaXMgbm90IHNldApDT05GSUdfTE9HX0JVRl9TSElGVD0xOApDT05GSUdfSEFWRV9VTlNU QUJMRV9TQ0hFRF9DTE9DSz15CkNPTkZJR19BUkNIX1NVUFBPUlRTX05VTUFfQkFMQU5DSU5H PXkKQ09ORklHX0FSQ0hfU1VQUE9SVFNfSU5UMTI4PXkKQ09ORklHX0FSQ0hfV0FOVFNfUFJP VF9OVU1BX1BST1RfTk9ORT15CiMgQ09ORklHX05VTUFfQkFMQU5DSU5HIGlzIG5vdCBzZXQK Q09ORklHX0NHUk9VUFM9eQojIENPTkZJR19DR1JPVVBfREVCVUcgaXMgbm90IHNldApDT05G SUdfQ0dST1VQX0ZSRUVaRVI9eQojIENPTkZJR19DR1JPVVBfREVWSUNFIGlzIG5vdCBzZXQK Q09ORklHX0NQVVNFVFM9eQpDT05GSUdfUFJPQ19QSURfQ1BVU0VUPXkKQ09ORklHX0NHUk9V UF9DUFVBQ0NUPXkKQ09ORklHX1JFU09VUkNFX0NPVU5URVJTPXkKIyBDT05GSUdfTUVNQ0cg aXMgbm90IHNldAojIENPTkZJR19DR1JPVVBfSFVHRVRMQiBpcyBub3Qgc2V0CiMgQ09ORklH X0NHUk9VUF9QRVJGIGlzIG5vdCBzZXQKQ09ORklHX0NHUk9VUF9TQ0hFRD15CkNPTkZJR19G QUlSX0dST1VQX1NDSEVEPXkKIyBDT05GSUdfQ0ZTX0JBTkRXSURUSCBpcyBub3Qgc2V0CiMg Q09ORklHX1JUX0dST1VQX1NDSEVEIGlzIG5vdCBzZXQKQ09ORklHX0JMS19DR1JPVVA9eQoj IENPTkZJR19ERUJVR19CTEtfQ0dST1VQIGlzIG5vdCBzZXQKIyBDT05GSUdfQ0hFQ0tQT0lO VF9SRVNUT1JFIGlzIG5vdCBzZXQKQ09ORklHX05BTUVTUEFDRVM9eQpDT05GSUdfVVRTX05T PXkKQ09ORklHX0lQQ19OUz15CiMgQ09ORklHX1VTRVJfTlMgaXMgbm90IHNldApDT05GSUdf UElEX05TPXkKQ09ORklHX05FVF9OUz15CiMgQ09ORklHX1VJREdJRF9TVFJJQ1RfVFlQRV9D SEVDS1MgaXMgbm90IHNldApDT05GSUdfU0NIRURfQVVUT0dST1VQPXkKIyBDT05GSUdfU1lT RlNfREVQUkVDQVRFRCBpcyBub3Qgc2V0CiMgQ09ORklHX1JFTEFZIGlzIG5vdCBzZXQKQ09O RklHX0JMS19ERVZfSU5JVFJEPXkKQ09ORklHX0lOSVRSQU1GU19TT1VSQ0U9IiIKQ09ORklH X1JEX0daSVA9eQpDT05GSUdfUkRfQlpJUDI9eQpDT05GSUdfUkRfTFpNQT15CkNPTkZJR19S RF9YWj15CkNPTkZJR19SRF9MWk89eQpDT05GSUdfUkRfTFo0PXkKIyBDT05GSUdfQ0NfT1BU SU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldApDT05GSUdfU1lTQ1RMPXkKQ09ORklHX0FOT05f SU5PREVTPXkKQ09ORklHX0hBVkVfVUlEMTY9eQpDT05GSUdfU1lTQ1RMX0VYQ0VQVElPTl9U UkFDRT15CkNPTkZJR19IQVZFX1BDU1BLUl9QTEFURk9STT15CiMgQ09ORklHX0VYUEVSVCBp cyBub3Qgc2V0CkNPTkZJR19VSUQxNj15CiMgQ09ORklHX1NZU0NUTF9TWVNDQUxMIGlzIG5v dCBzZXQKQ09ORklHX0tBTExTWU1TPXkKQ09ORklHX0tBTExTWU1TX0FMTD15CkNPTkZJR19Q UklOVEs9eQpDT05GSUdfQlVHPXkKQ09ORklHX0VMRl9DT1JFPXkKQ09ORklHX1BDU1BLUl9Q TEFURk9STT15CkNPTkZJR19CQVNFX0ZVTEw9eQpDT05GSUdfRlVURVg9eQpDT05GSUdfRVBP TEw9eQpDT05GSUdfU0lHTkFMRkQ9eQpDT05GSUdfVElNRVJGRD15CkNPTkZJR19FVkVOVEZE PXkKQ09ORklHX1NITUVNPXkKQ09ORklHX0FJTz15CkNPTkZJR19QQ0lfUVVJUktTPXkKIyBD T05GSUdfRU1CRURERUQgaXMgbm90IHNldApDT05GSUdfSEFWRV9QRVJGX0VWRU5UUz15Cgoj CiMgS2VybmVsIFBlcmZvcm1hbmNlIEV2ZW50cyBBbmQgQ291bnRlcnMKIwpDT05GSUdfUEVS Rl9FVkVOVFM9eQojIENPTkZJR19ERUJVR19QRVJGX1VTRV9WTUFMTE9DIGlzIG5vdCBzZXQK Q09ORklHX1ZNX0VWRU5UX0NPVU5URVJTPXkKQ09ORklHX1NMVUJfREVCVUc9eQojIENPTkZJ R19DT01QQVRfQlJLIGlzIG5vdCBzZXQKIyBDT05GSUdfU0xBQiBpcyBub3Qgc2V0CkNPTkZJ R19TTFVCPXkKQ09ORklHX1NMVUJfQ1BVX1BBUlRJQUw9eQojIENPTkZJR19QUk9GSUxJTkcg aXMgbm90IHNldApDT05GSUdfVFJBQ0VQT0lOVFM9eQpDT05GSUdfSEFWRV9PUFJPRklMRT15 CkNPTkZJR19PUFJPRklMRV9OTUlfVElNRVI9eQojIENPTkZJR19LUFJPQkVTIGlzIG5vdCBz ZXQKQ09ORklHX0pVTVBfTEFCRUw9eQojIENPTkZJR19IQVZFXzY0QklUX0FMSUdORURfQUND RVNTIGlzIG5vdCBzZXQKQ09ORklHX0hBVkVfRUZGSUNJRU5UX1VOQUxJR05FRF9BQ0NFU1M9 eQpDT05GSUdfQVJDSF9VU0VfQlVJTFRJTl9CU1dBUD15CkNPTkZJR19IQVZFX0lPUkVNQVBf UFJPVD15CkNPTkZJR19IQVZFX0tQUk9CRVM9eQpDT05GSUdfSEFWRV9LUkVUUFJPQkVTPXkK Q09ORklHX0hBVkVfT1BUUFJPQkVTPXkKQ09ORklHX0hBVkVfS1BST0JFU19PTl9GVFJBQ0U9 eQpDT05GSUdfSEFWRV9BUkNIX1RSQUNFSE9PSz15CkNPTkZJR19IQVZFX0RNQV9BVFRSUz15 CkNPTkZJR19HRU5FUklDX1NNUF9JRExFX1RIUkVBRD15CkNPTkZJR19IQVZFX1JFR1NfQU5E X1NUQUNLX0FDQ0VTU19BUEk9eQpDT05GSUdfSEFWRV9ETUFfQVBJX0RFQlVHPXkKQ09ORklH X0hBVkVfSFdfQlJFQUtQT0lOVD15CkNPTkZJR19IQVZFX01JWEVEX0JSRUFLUE9JTlRTX1JF R1M9eQpDT05GSUdfSEFWRV9VU0VSX1JFVFVSTl9OT1RJRklFUj15CkNPTkZJR19IQVZFX1BF UkZfRVZFTlRTX05NST15CkNPTkZJR19IQVZFX1BFUkZfUkVHUz15CkNPTkZJR19IQVZFX1BF UkZfVVNFUl9TVEFDS19EVU1QPXkKQ09ORklHX0hBVkVfQVJDSF9KVU1QX0xBQkVMPXkKQ09O RklHX0FSQ0hfSEFWRV9OTUlfU0FGRV9DTVBYQ0hHPXkKQ09ORklHX0hBVkVfQUxJR05FRF9T VFJVQ1RfUEFHRT15CkNPTkZJR19IQVZFX0NNUFhDSEdfTE9DQUw9eQpDT05GSUdfSEFWRV9D TVBYQ0hHX0RPVUJMRT15CkNPTkZJR19BUkNIX1dBTlRfQ09NUEFUX0lQQ19QQVJTRV9WRVJT SU9OPXkKQ09ORklHX0FSQ0hfV0FOVF9PTERfQ09NUEFUX0lQQz15CkNPTkZJR19IQVZFX0FS Q0hfU0VDQ09NUF9GSUxURVI9eQpDT05GSUdfU0VDQ09NUF9GSUxURVI9eQpDT05GSUdfSEFW RV9DT05URVhUX1RSQUNLSU5HPXkKQ09ORklHX0hBVkVfVklSVF9DUFVfQUNDT1VOVElOR19H RU49eQpDT05GSUdfSEFWRV9JUlFfVElNRV9BQ0NPVU5USU5HPXkKQ09ORklHX0hBVkVfQVJD SF9UUkFOU1BBUkVOVF9IVUdFUEFHRT15CkNPTkZJR19IQVZFX0FSQ0hfU09GVF9ESVJUWT15 CkNPTkZJR19NT0RVTEVTX1VTRV9FTEZfUkVMQT15CkNPTkZJR19IQVZFX0lSUV9FWElUX09O X0lSUV9TVEFDSz15CkNPTkZJR19PTERfU0lHU1VTUEVORDM9eQpDT05GSUdfQ09NUEFUX09M RF9TSUdBQ1RJT049eQoKIwojIEdDT1YtYmFzZWQga2VybmVsIHByb2ZpbGluZwojCiMgQ09O RklHX0dDT1ZfS0VSTkVMIGlzIG5vdCBzZXQKIyBDT05GSUdfSEFWRV9HRU5FUklDX0RNQV9D T0hFUkVOVCBpcyBub3Qgc2V0CkNPTkZJR19TTEFCSU5GTz15CkNPTkZJR19SVF9NVVRFWEVT PXkKQ09ORklHX0JBU0VfU01BTEw9MAojIENPTkZJR19TWVNURU1fVFJVU1RFRF9LRVlSSU5H IGlzIG5vdCBzZXQKQ09ORklHX01PRFVMRVM9eQojIENPTkZJR19NT0RVTEVfRk9SQ0VfTE9B RCBpcyBub3Qgc2V0CkNPTkZJR19NT0RVTEVfVU5MT0FEPXkKIyBDT05GSUdfTU9EVUxFX0ZP UkNFX1VOTE9BRCBpcyBub3Qgc2V0CiMgQ09ORklHX01PRFZFUlNJT05TIGlzIG5vdCBzZXQK IyBDT05GSUdfTU9EVUxFX1NSQ1ZFUlNJT05fQUxMIGlzIG5vdCBzZXQKIyBDT05GSUdfTU9E VUxFX1NJRyBpcyBub3Qgc2V0CkNPTkZJR19TVE9QX01BQ0hJTkU9eQpDT05GSUdfQkxPQ0s9 eQpDT05GSUdfQkxLX0RFVl9CU0c9eQojIENPTkZJR19CTEtfREVWX0JTR0xJQiBpcyBub3Qg c2V0CkNPTkZJR19CTEtfREVWX0lOVEVHUklUWT15CiMgQ09ORklHX0JMS19ERVZfVEhST1RU TElORyBpcyBub3Qgc2V0CiMgQ09ORklHX0JMS19DTURMSU5FX1BBUlNFUiBpcyBub3Qgc2V0 CgojCiMgUGFydGl0aW9uIFR5cGVzCiMKQ09ORklHX1BBUlRJVElPTl9BRFZBTkNFRD15CiMg Q09ORklHX0FDT1JOX1BBUlRJVElPTiBpcyBub3Qgc2V0CiMgQ09ORklHX0FJWF9QQVJUSVRJ T04gaXMgbm90IHNldApDT05GSUdfT1NGX1BBUlRJVElPTj15CkNPTkZJR19BTUlHQV9QQVJU SVRJT049eQojIENPTkZJR19BVEFSSV9QQVJUSVRJT04gaXMgbm90IHNldApDT05GSUdfTUFD X1BBUlRJVElPTj15CkNPTkZJR19NU0RPU19QQVJUSVRJT049eQpDT05GSUdfQlNEX0RJU0tM QUJFTD15CkNPTkZJR19NSU5JWF9TVUJQQVJUSVRJT049eQpDT05GSUdfU09MQVJJU19YODZf UEFSVElUSU9OPXkKQ09ORklHX1VOSVhXQVJFX0RJU0tMQUJFTD15CiMgQ09ORklHX0xETV9Q QVJUSVRJT04gaXMgbm90IHNldApDT05GSUdfU0dJX1BBUlRJVElPTj15CiMgQ09ORklHX1VM VFJJWF9QQVJUSVRJT04gaXMgbm90IHNldApDT05GSUdfU1VOX1BBUlRJVElPTj15CkNPTkZJ R19LQVJNQV9QQVJUSVRJT049eQpDT05GSUdfRUZJX1BBUlRJVElPTj15CiMgQ09ORklHX1NZ U1Y2OF9QQVJUSVRJT04gaXMgbm90IHNldAojIENPTkZJR19DTURMSU5FX1BBUlRJVElPTiBp cyBub3Qgc2V0CkNPTkZJR19CTE9DS19DT01QQVQ9eQoKIwojIElPIFNjaGVkdWxlcnMKIwpD T05GSUdfSU9TQ0hFRF9OT09QPXkKQ09ORklHX0lPU0NIRURfREVBRExJTkU9eQpDT05GSUdf SU9TQ0hFRF9DRlE9eQpDT05GSUdfQ0ZRX0dST1VQX0lPU0NIRUQ9eQojIENPTkZJR19ERUZB VUxUX0RFQURMSU5FIGlzIG5vdCBzZXQKQ09ORklHX0RFRkFVTFRfQ0ZRPXkKIyBDT05GSUdf REVGQVVMVF9OT09QIGlzIG5vdCBzZXQKQ09ORklHX0RFRkFVTFRfSU9TQ0hFRD0iY2ZxIgpD T05GSUdfVU5JTkxJTkVfU1BJTl9VTkxPQ0s9eQpDT05GSUdfRlJFRVpFUj15CgojCiMgUHJv Y2Vzc29yIHR5cGUgYW5kIGZlYXR1cmVzCiMKQ09ORklHX1pPTkVfRE1BPXkKQ09ORklHX1NN UD15CkNPTkZJR19YODZfWDJBUElDPXkKIyBDT05GSUdfWDg2X01QUEFSU0UgaXMgbm90IHNl dAojIENPTkZJR19YODZfRVhURU5ERURfUExBVEZPUk0gaXMgbm90IHNldAojIENPTkZJR19Y ODZfSU5URUxfTFBTUyBpcyBub3Qgc2V0CkNPTkZJR19YODZfU1VQUE9SVFNfTUVNT1JZX0ZB SUxVUkU9eQpDT05GSUdfU0NIRURfT01JVF9GUkFNRV9QT0lOVEVSPXkKQ09ORklHX0hZUEVS VklTT1JfR1VFU1Q9eQpDT05GSUdfUEFSQVZJUlQ9eQpDT05GSUdfUEFSQVZJUlRfREVCVUc9 eQpDT05GSUdfUEFSQVZJUlRfU1BJTkxPQ0tTPXkKQ09ORklHX1hFTj15CkNPTkZJR19YRU5f RE9NMD15CkNPTkZJR19YRU5fUFJJVklMRUdFRF9HVUVTVD15CkNPTkZJR19YRU5fUFZIVk09 eQpDT05GSUdfWEVOX01BWF9ET01BSU5fTUVNT1JZPTUwMApDT05GSUdfWEVOX1NBVkVfUkVT VE9SRT15CkNPTkZJR19YRU5fREVCVUdfRlM9eQpDT05GSUdfWEVOX1BWSD15CiMgQ09ORklH X0tWTV9HVUVTVCBpcyBub3Qgc2V0CiMgQ09ORklHX1BBUkFWSVJUX1RJTUVfQUNDT1VOVElO RyBpcyBub3Qgc2V0CkNPTkZJR19QQVJBVklSVF9DTE9DSz15CkNPTkZJR19OT19CT09UTUVN PXkKIyBDT05GSUdfTUVNVEVTVCBpcyBub3Qgc2V0CiMgQ09ORklHX01LOCBpcyBub3Qgc2V0 CiMgQ09ORklHX01QU0MgaXMgbm90IHNldAojIENPTkZJR19NQ09SRTIgaXMgbm90IHNldAoj IENPTkZJR19NQVRPTSBpcyBub3Qgc2V0CkNPTkZJR19HRU5FUklDX0NQVT15CkNPTkZJR19Y ODZfSU5URVJOT0RFX0NBQ0hFX1NISUZUPTYKQ09ORklHX1g4Nl9MMV9DQUNIRV9TSElGVD02 CkNPTkZJR19YODZfVFNDPXkKQ09ORklHX1g4Nl9DTVBYQ0hHNjQ9eQpDT05GSUdfWDg2X0NN T1Y9eQpDT05GSUdfWDg2X01JTklNVU1fQ1BVX0ZBTUlMWT02NApDT05GSUdfWDg2X0RFQlVH Q1RMTVNSPXkKQ09ORklHX0NQVV9TVVBfSU5URUw9eQpDT05GSUdfQ1BVX1NVUF9BTUQ9eQpD T05GSUdfQ1BVX1NVUF9DRU5UQVVSPXkKQ09ORklHX0hQRVRfVElNRVI9eQpDT05GSUdfSFBF VF9FTVVMQVRFX1JUQz15CkNPTkZJR19ETUk9eQpDT05GSUdfR0FSVF9JT01NVT15CiMgQ09O RklHX0NBTEdBUllfSU9NTVUgaXMgbm90IHNldApDT05GSUdfU1dJT1RMQj15CkNPTkZJR19J T01NVV9IRUxQRVI9eQojIENPTkZJR19NQVhTTVAgaXMgbm90IHNldApDT05GSUdfTlJfQ1BV Uz04CkNPTkZJR19TQ0hFRF9TTVQ9eQpDT05GSUdfU0NIRURfTUM9eQojIENPTkZJR19QUkVF TVBUX05PTkUgaXMgbm90IHNldApDT05GSUdfUFJFRU1QVF9WT0xVTlRBUlk9eQojIENPTkZJ R19QUkVFTVBUIGlzIG5vdCBzZXQKQ09ORklHX1g4Nl9MT0NBTF9BUElDPXkKQ09ORklHX1g4 Nl9JT19BUElDPXkKQ09ORklHX1g4Nl9SRVJPVVRFX0ZPUl9CUk9LRU5fQk9PVF9JUlFTPXkK Q09ORklHX1g4Nl9NQ0U9eQpDT05GSUdfWDg2X01DRV9JTlRFTD15CkNPTkZJR19YODZfTUNF X0FNRD15CkNPTkZJR19YODZfTUNFX1RIUkVTSE9MRD15CiMgQ09ORklHX1g4Nl9NQ0VfSU5K RUNUIGlzIG5vdCBzZXQKQ09ORklHX1g4Nl9USEVSTUFMX1ZFQ1RPUj15CiMgQ09ORklHX0k4 SyBpcyBub3Qgc2V0CiMgQ09ORklHX01JQ1JPQ09ERSBpcyBub3Qgc2V0CiMgQ09ORklHX01J Q1JPQ09ERV9JTlRFTF9FQVJMWSBpcyBub3Qgc2V0CiMgQ09ORklHX01JQ1JPQ09ERV9BTURf RUFSTFkgaXMgbm90IHNldApDT05GSUdfWDg2X01TUj15CkNPTkZJR19YODZfQ1BVSUQ9eQpD T05GSUdfQVJDSF9QSFlTX0FERFJfVF82NEJJVD15CkNPTkZJR19BUkNIX0RNQV9BRERSX1Rf NjRCSVQ9eQpDT05GSUdfRElSRUNUX0dCUEFHRVM9eQpDT05GSUdfTlVNQT15CkNPTkZJR19B TURfTlVNQT15CkNPTkZJR19YODZfNjRfQUNQSV9OVU1BPXkKQ09ORklHX05PREVTX1NQQU5f T1RIRVJfTk9ERVM9eQojIENPTkZJR19OVU1BX0VNVSBpcyBub3Qgc2V0CkNPTkZJR19OT0RF U19TSElGVD04CkNPTkZJR19BUkNIX1NQQVJTRU1FTV9FTkFCTEU9eQpDT05GSUdfQVJDSF9T UEFSU0VNRU1fREVGQVVMVD15CkNPTkZJR19BUkNIX1NFTEVDVF9NRU1PUllfTU9ERUw9eQpD T05GSUdfQVJDSF9QUk9DX0tDT1JFX1RFWFQ9eQpDT05GSUdfSUxMRUdBTF9QT0lOVEVSX1ZB TFVFPTB4ZGVhZDAwMDAwMDAwMDAwMApDT05GSUdfU0VMRUNUX01FTU9SWV9NT0RFTD15CkNP TkZJR19TUEFSU0VNRU1fTUFOVUFMPXkKQ09ORklHX1NQQVJTRU1FTT15CkNPTkZJR19ORUVE X01VTFRJUExFX05PREVTPXkKQ09ORklHX0hBVkVfTUVNT1JZX1BSRVNFTlQ9eQpDT05GSUdf U1BBUlNFTUVNX0VYVFJFTUU9eQpDT05GSUdfU1BBUlNFTUVNX1ZNRU1NQVBfRU5BQkxFPXkK Q09ORklHX1NQQVJTRU1FTV9BTExPQ19NRU1fTUFQX1RPR0VUSEVSPXkKQ09ORklHX1NQQVJT RU1FTV9WTUVNTUFQPXkKQ09ORklHX0hBVkVfTUVNQkxPQ0s9eQpDT05GSUdfSEFWRV9NRU1C TE9DS19OT0RFX01BUD15CkNPTkZJR19BUkNIX0RJU0NBUkRfTUVNQkxPQ0s9eQojIENPTkZJ R19NT1ZBQkxFX05PREUgaXMgbm90IHNldAojIENPTkZJR19IQVZFX0JPT1RNRU1fSU5GT19O T0RFIGlzIG5vdCBzZXQKIyBDT05GSUdfTUVNT1JZX0hPVFBMVUcgaXMgbm90IHNldApDT05G SUdfUEFHRUZMQUdTX0VYVEVOREVEPXkKQ09ORklHX1NQTElUX1BUTE9DS19DUFVTPTQKQ09O RklHX0FSQ0hfRU5BQkxFX1NQTElUX1BNRF9QVExPQ0s9eQpDT05GSUdfQ09NUEFDVElPTj15 CkNPTkZJR19NSUdSQVRJT049eQpDT05GSUdfUEhZU19BRERSX1RfNjRCSVQ9eQpDT05GSUdf Wk9ORV9ETUFfRkxBRz0xCkNPTkZJR19CT1VOQ0U9eQpDT05GSUdfTkVFRF9CT1VOQ0VfUE9P TD15CkNPTkZJR19WSVJUX1RPX0JVUz15CkNPTkZJR19NTVVfTk9USUZJRVI9eQojIENPTkZJ R19LU00gaXMgbm90IHNldApDT05GSUdfREVGQVVMVF9NTUFQX01JTl9BRERSPTQwOTYKQ09O RklHX0FSQ0hfU1VQUE9SVFNfTUVNT1JZX0ZBSUxVUkU9eQojIENPTkZJR19NRU1PUllfRkFJ TFVSRSBpcyBub3Qgc2V0CkNPTkZJR19UUkFOU1BBUkVOVF9IVUdFUEFHRT15CkNPTkZJR19U UkFOU1BBUkVOVF9IVUdFUEFHRV9BTFdBWVM9eQojIENPTkZJR19UUkFOU1BBUkVOVF9IVUdF UEFHRV9NQURWSVNFIGlzIG5vdCBzZXQKQ09ORklHX0NST1NTX01FTU9SWV9BVFRBQ0g9eQoj IENPTkZJR19DTEVBTkNBQ0hFIGlzIG5vdCBzZXQKIyBDT05GSUdfRlJPTlRTV0FQIGlzIG5v dCBzZXQKIyBDT05GSUdfQ01BIGlzIG5vdCBzZXQKIyBDT05GSUdfWkJVRCBpcyBub3Qgc2V0 CkNPTkZJR19YODZfQ0hFQ0tfQklPU19DT1JSVVBUSU9OPXkKQ09ORklHX1g4Nl9CT09UUEFS QU1fTUVNT1JZX0NPUlJVUFRJT05fQ0hFQ0s9eQpDT05GSUdfWDg2X1JFU0VSVkVfTE9XPTY0 CkNPTkZJR19NVFJSPXkKQ09ORklHX01UUlJfU0FOSVRJWkVSPXkKQ09ORklHX01UUlJfU0FO SVRJWkVSX0VOQUJMRV9ERUZBVUxUPTAKQ09ORklHX01UUlJfU0FOSVRJWkVSX1NQQVJFX1JF R19OUl9ERUZBVUxUPTEKQ09ORklHX1g4Nl9QQVQ9eQpDT05GSUdfQVJDSF9VU0VTX1BHX1VO Q0FDSEVEPXkKQ09ORklHX0FSQ0hfUkFORE9NPXkKQ09ORklHX1g4Nl9TTUFQPXkKIyBDT05G SUdfRUZJIGlzIG5vdCBzZXQKQ09ORklHX1NFQ0NPTVA9eQojIENPTkZJR19DQ19TVEFDS1BS T1RFQ1RPUiBpcyBub3Qgc2V0CiMgQ09ORklHX0haXzEwMCBpcyBub3Qgc2V0CiMgQ09ORklH X0haXzI1MCBpcyBub3Qgc2V0CkNPTkZJR19IWl8zMDA9eQojIENPTkZJR19IWl8xMDAwIGlz IG5vdCBzZXQKQ09ORklHX0haPTMwMApDT05GSUdfU0NIRURfSFJUSUNLPXkKQ09ORklHX0tF WEVDPXkKQ09ORklHX0NSQVNIX0RVTVA9eQpDT05GSUdfUEhZU0lDQUxfU1RBUlQ9MHgxMDAw MDAwCkNPTkZJR19SRUxPQ0FUQUJMRT15CkNPTkZJR19QSFlTSUNBTF9BTElHTj0weDEwMDAw MDAKQ09ORklHX0hPVFBMVUdfQ1BVPXkKIyBDT05GSUdfQk9PVFBBUkFNX0hPVFBMVUdfQ1BV MCBpcyBub3Qgc2V0CiMgQ09ORklHX0RFQlVHX0hPVFBMVUdfQ1BVMCBpcyBub3Qgc2V0CiMg Q09ORklHX0NPTVBBVF9WRFNPIGlzIG5vdCBzZXQKIyBDT05GSUdfQ01ETElORV9CT09MIGlz IG5vdCBzZXQKQ09ORklHX0FSQ0hfRU5BQkxFX01FTU9SWV9IT1RQTFVHPXkKQ09ORklHX1VT RV9QRVJDUFVfTlVNQV9OT0RFX0lEPXkKCiMKIyBQb3dlciBtYW5hZ2VtZW50IGFuZCBBQ1BJ IG9wdGlvbnMKIwojIENPTkZJR19TVVNQRU5EIGlzIG5vdCBzZXQKQ09ORklHX0hJQkVSTkFU RV9DQUxMQkFDS1M9eQojIENPTkZJR19ISUJFUk5BVElPTiBpcyBub3Qgc2V0CkNPTkZJR19Q TV9TTEVFUD15CkNPTkZJR19QTV9TTEVFUF9TTVA9eQojIENPTkZJR19QTV9BVVRPU0xFRVAg aXMgbm90IHNldAojIENPTkZJR19QTV9XQUtFTE9DS1MgaXMgbm90IHNldAojIENPTkZJR19Q TV9SVU5USU1FIGlzIG5vdCBzZXQKQ09ORklHX1BNPXkKQ09ORklHX1BNX0RFQlVHPXkKIyBD T05GSUdfUE1fQURWQU5DRURfREVCVUcgaXMgbm90IHNldApDT05GSUdfUE1fU0xFRVBfREVC VUc9eQojIENPTkZJR19QTV9UUkFDRV9SVEMgaXMgbm90IHNldAojIENPTkZJR19XUV9QT1dF Ul9FRkZJQ0lFTlRfREVGQVVMVCBpcyBub3Qgc2V0CkNPTkZJR19BQ1BJPXkKQ09ORklHX0FD UElfUFJPQ0ZTPXkKIyBDT05GSUdfQUNQSV9FQ19ERUJVR0ZTIGlzIG5vdCBzZXQKQ09ORklH X0FDUElfQUM9eQpDT05GSUdfQUNQSV9CQVRURVJZPXkKQ09ORklHX0FDUElfQlVUVE9OPXkK Q09ORklHX0FDUElfVklERU89eQpDT05GSUdfQUNQSV9GQU49eQojIENPTkZJR19BQ1BJX0RP Q0sgaXMgbm90IHNldApDT05GSUdfQUNQSV9QUk9DRVNTT1I9eQpDT05GSUdfQUNQSV9IT1RQ TFVHX0NQVT15CkNPTkZJR19BQ1BJX1BST0NFU1NPUl9BR0dSRUdBVE9SPXkKQ09ORklHX0FD UElfVEhFUk1BTD15CkNPTkZJR19BQ1BJX05VTUE9eQpDT05GSUdfQUNQSV9DVVNUT01fRFNE VF9GSUxFPSIiCiMgQ09ORklHX0FDUElfQ1VTVE9NX0RTRFQgaXMgbm90IHNldApDT05GSUdf QUNQSV9JTklUUkRfVEFCTEVfT1ZFUlJJREU9eQojIENPTkZJR19BQ1BJX0RFQlVHIGlzIG5v dCBzZXQKQ09ORklHX0FDUElfUENJX1NMT1Q9eQpDT05GSUdfWDg2X1BNX1RJTUVSPXkKQ09O RklHX0FDUElfQ09OVEFJTkVSPXkKIyBDT05GSUdfQUNQSV9TQlMgaXMgbm90IHNldApDT05G SUdfQUNQSV9IRUQ9eQojIENPTkZJR19BQ1BJX0NVU1RPTV9NRVRIT0QgaXMgbm90IHNldAoj IENPTkZJR19BQ1BJX0FQRUkgaXMgbm90IHNldAojIENPTkZJR19BQ1BJX0VYVExPRyBpcyBu b3Qgc2V0CiMgQ09ORklHX1NGSSBpcyBub3Qgc2V0CgojCiMgQ1BVIEZyZXF1ZW5jeSBzY2Fs aW5nCiMKQ09ORklHX0NQVV9GUkVRPXkKQ09ORklHX0NQVV9GUkVRX0dPVl9DT01NT049eQoj IENPTkZJR19DUFVfRlJFUV9TVEFUIGlzIG5vdCBzZXQKIyBDT05GSUdfQ1BVX0ZSRVFfREVG QVVMVF9HT1ZfUEVSRk9STUFOQ0UgaXMgbm90IHNldApDT05GSUdfQ1BVX0ZSRVFfREVGQVVM VF9HT1ZfVVNFUlNQQUNFPXkKIyBDT05GSUdfQ1BVX0ZSRVFfREVGQVVMVF9HT1ZfT05ERU1B TkQgaXMgbm90IHNldAojIENPTkZJR19DUFVfRlJFUV9ERUZBVUxUX0dPVl9DT05TRVJWQVRJ VkUgaXMgbm90IHNldApDT05GSUdfQ1BVX0ZSRVFfR09WX1BFUkZPUk1BTkNFPXkKIyBDT05G SUdfQ1BVX0ZSRVFfR09WX1BPV0VSU0FWRSBpcyBub3Qgc2V0CkNPTkZJR19DUFVfRlJFUV9H T1ZfVVNFUlNQQUNFPXkKQ09ORklHX0NQVV9GUkVRX0dPVl9PTkRFTUFORD15CiMgQ09ORklH X0NQVV9GUkVRX0dPVl9DT05TRVJWQVRJVkUgaXMgbm90IHNldAoKIwojIHg4NiBDUFUgZnJl cXVlbmN5IHNjYWxpbmcgZHJpdmVycwojCiMgQ09ORklHX1g4Nl9JTlRFTF9QU1RBVEUgaXMg bm90IHNldApDT05GSUdfWDg2X1BDQ19DUFVGUkVRPXkKQ09ORklHX1g4Nl9BQ1BJX0NQVUZS RVE9eQpDT05GSUdfWDg2X0FDUElfQ1BVRlJFUV9DUEI9eQojIENPTkZJR19YODZfUE9XRVJO T1dfSzggaXMgbm90IHNldAojIENPTkZJR19YODZfQU1EX0ZSRVFfU0VOU0lUSVZJVFkgaXMg bm90IHNldAojIENPTkZJR19YODZfU1BFRURTVEVQX0NFTlRSSU5PIGlzIG5vdCBzZXQKIyBD T05GSUdfWDg2X1A0X0NMT0NLTU9EIGlzIG5vdCBzZXQKCiMKIyBzaGFyZWQgb3B0aW9ucwoj CiMgQ09ORklHX1g4Nl9TUEVFRFNURVBfTElCIGlzIG5vdCBzZXQKCiMKIyBDUFUgSWRsZQoj CkNPTkZJR19DUFVfSURMRT15CiMgQ09ORklHX0NQVV9JRExFX01VTFRJUExFX0RSSVZFUlMg aXMgbm90IHNldApDT05GSUdfQ1BVX0lETEVfR09WX0xBRERFUj15CkNPTkZJR19DUFVfSURM RV9HT1ZfTUVOVT15CiMgQ09ORklHX0FSQ0hfTkVFRFNfQ1BVX0lETEVfQ09VUExFRCBpcyBu b3Qgc2V0CiMgQ09ORklHX0lOVEVMX0lETEUgaXMgbm90IHNldAoKIwojIE1lbW9yeSBwb3dl ciBzYXZpbmdzCiMKIyBDT05GSUdfSTczMDBfSURMRSBpcyBub3Qgc2V0CgojCiMgQnVzIG9w dGlvbnMgKFBDSSBldGMuKQojCkNPTkZJR19QQ0k9eQpDT05GSUdfUENJX0RJUkVDVD15CkNP TkZJR19QQ0lfTU1DT05GSUc9eQpDT05GSUdfUENJX1hFTj15CkNPTkZJR19QQ0lfRE9NQUlO Uz15CkNPTkZJR19QQ0lFUE9SVEJVUz15CkNPTkZJR19IT1RQTFVHX1BDSV9QQ0lFPXkKQ09O RklHX1BDSUVBRVI9eQpDT05GSUdfUENJRV9FQ1JDPXkKQ09ORklHX1BDSUVBRVJfSU5KRUNU PXkKQ09ORklHX1BDSUVBU1BNPXkKQ09ORklHX1BDSUVBU1BNX0RFQlVHPXkKQ09ORklHX1BD SUVBU1BNX0RFRkFVTFQ9eQojIENPTkZJR19QQ0lFQVNQTV9QT1dFUlNBVkUgaXMgbm90IHNl dAojIENPTkZJR19QQ0lFQVNQTV9QRVJGT1JNQU5DRSBpcyBub3Qgc2V0CkNPTkZJR19QQ0lf TVNJPXkKQ09ORklHX1BDSV9ERUJVRz15CkNPTkZJR19QQ0lfUkVBTExPQ19FTkFCTEVfQVVU Tz15CkNPTkZJR19QQ0lfU1RVQj15CkNPTkZJR19YRU5fUENJREVWX0ZST05URU5EPXkKQ09O RklHX0hUX0lSUT15CkNPTkZJR19QQ0lfQVRTPXkKQ09ORklHX1BDSV9JT1Y9eQpDT05GSUdf UENJX1BSST15CkNPTkZJR19QQ0lfUEFTSUQ9eQpDT05GSUdfUENJX0lPQVBJQz15CkNPTkZJ R19QQ0lfTEFCRUw9eQoKIwojIFBDSSBob3N0IGNvbnRyb2xsZXIgZHJpdmVycwojCkNPTkZJ R19JU0FfRE1BX0FQST15CkNPTkZJR19BTURfTkI9eQojIENPTkZJR19QQ0NBUkQgaXMgbm90 IHNldApDT05GSUdfSE9UUExVR19QQ0k9eQpDT05GSUdfSE9UUExVR19QQ0lfQUNQST15CkNP TkZJR19IT1RQTFVHX1BDSV9BQ1BJX0lCTT15CkNPTkZJR19IT1RQTFVHX1BDSV9DUENJPXkK IyBDT05GSUdfSE9UUExVR19QQ0lfQ1BDSV9aVDU1NTAgaXMgbm90IHNldApDT05GSUdfSE9U UExVR19QQ0lfQ1BDSV9HRU5FUklDPXkKQ09ORklHX0hPVFBMVUdfUENJX1NIUEM9eQojIENP TkZJR19SQVBJRElPIGlzIG5vdCBzZXQKIyBDT05GSUdfWDg2X1NZU0ZCIGlzIG5vdCBzZXQK CiMKIyBFeGVjdXRhYmxlIGZpbGUgZm9ybWF0cyAvIEVtdWxhdGlvbnMKIwpDT05GSUdfQklO Rk1UX0VMRj15CkNPTkZJR19DT01QQVRfQklORk1UX0VMRj15CkNPTkZJR19BUkNIX0JJTkZN VF9FTEZfUkFORE9NSVpFX1BJRT15CkNPTkZJR19DT1JFX0RVTVBfREVGQVVMVF9FTEZfSEVB REVSUz15CkNPTkZJR19CSU5GTVRfU0NSSVBUPXkKIyBDT05GSUdfSEFWRV9BT1VUIGlzIG5v dCBzZXQKQ09ORklHX0JJTkZNVF9NSVNDPXkKQ09ORklHX0NPUkVEVU1QPXkKQ09ORklHX0lB MzJfRU1VTEFUSU9OPXkKIyBDT05GSUdfSUEzMl9BT1VUIGlzIG5vdCBzZXQKIyBDT05GSUdf WDg2X1gzMiBpcyBub3Qgc2V0CkNPTkZJR19DT01QQVQ9eQpDT05GSUdfQ09NUEFUX0ZPUl9V NjRfQUxJR05NRU5UPXkKQ09ORklHX1NZU1ZJUENfQ09NUEFUPXkKQ09ORklHX0tFWVNfQ09N UEFUPXkKQ09ORklHX1g4Nl9ERVZfRE1BX09QUz15CkNPTkZJR19ORVQ9eQoKIwojIE5ldHdv cmtpbmcgb3B0aW9ucwojCkNPTkZJR19QQUNLRVQ9eQojIENPTkZJR19QQUNLRVRfRElBRyBp cyBub3Qgc2V0CkNPTkZJR19VTklYPXkKIyBDT05GSUdfVU5JWF9ESUFHIGlzIG5vdCBzZXQK IyBDT05GSUdfWEZSTV9VU0VSIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX0tFWSBpcyBub3Qg c2V0CkNPTkZJR19JTkVUPXkKQ09ORklHX0lQX01VTFRJQ0FTVD15CkNPTkZJR19JUF9BRFZB TkNFRF9ST1VURVI9eQojIENPTkZJR19JUF9GSUJfVFJJRV9TVEFUUyBpcyBub3Qgc2V0CkNP TkZJR19JUF9NVUxUSVBMRV9UQUJMRVM9eQpDT05GSUdfSVBfUk9VVEVfTVVMVElQQVRIPXkK Q09ORklHX0lQX1JPVVRFX1ZFUkJPU0U9eQpDT05GSUdfSVBfUk9VVEVfQ0xBU1NJRD15CkNP TkZJR19JUF9QTlA9eQpDT05GSUdfSVBfUE5QX0RIQ1A9eQpDT05GSUdfSVBfUE5QX0JPT1RQ PXkKQ09ORklHX0lQX1BOUF9SQVJQPXkKIyBDT05GSUdfTkVUX0lQSVAgaXMgbm90IHNldAoj IENPTkZJR19ORVRfSVBHUkVfREVNVVggaXMgbm90IHNldAojIENPTkZJR19ORVRfSVBfVFVO TkVMIGlzIG5vdCBzZXQKIyBDT05GSUdfSVBfTVJPVVRFIGlzIG5vdCBzZXQKQ09ORklHX1NZ Tl9DT09LSUVTPXkKIyBDT05GSUdfSU5FVF9BSCBpcyBub3Qgc2V0CiMgQ09ORklHX0lORVRf RVNQIGlzIG5vdCBzZXQKIyBDT05GSUdfSU5FVF9JUENPTVAgaXMgbm90IHNldAojIENPTkZJ R19JTkVUX1hGUk1fVFVOTkVMIGlzIG5vdCBzZXQKIyBDT05GSUdfSU5FVF9UVU5ORUwgaXMg bm90IHNldAojIENPTkZJR19JTkVUX1hGUk1fTU9ERV9UUkFOU1BPUlQgaXMgbm90IHNldAoj IENPTkZJR19JTkVUX1hGUk1fTU9ERV9UVU5ORUwgaXMgbm90IHNldAojIENPTkZJR19JTkVU X1hGUk1fTU9ERV9CRUVUIGlzIG5vdCBzZXQKQ09ORklHX0lORVRfTFJPPXkKIyBDT05GSUdf SU5FVF9ESUFHIGlzIG5vdCBzZXQKQ09ORklHX1RDUF9DT05HX0FEVkFOQ0VEPXkKIyBDT05G SUdfVENQX0NPTkdfQklDIGlzIG5vdCBzZXQKQ09ORklHX1RDUF9DT05HX0NVQklDPXkKIyBD T05GSUdfVENQX0NPTkdfV0VTVFdPT0QgaXMgbm90IHNldAojIENPTkZJR19UQ1BfQ09OR19I VENQIGlzIG5vdCBzZXQKIyBDT05GSUdfVENQX0NPTkdfSFNUQ1AgaXMgbm90IHNldAojIENP TkZJR19UQ1BfQ09OR19IWUJMQSBpcyBub3Qgc2V0CiMgQ09ORklHX1RDUF9DT05HX1ZFR0FT IGlzIG5vdCBzZXQKIyBDT05GSUdfVENQX0NPTkdfU0NBTEFCTEUgaXMgbm90IHNldAojIENP TkZJR19UQ1BfQ09OR19MUCBpcyBub3Qgc2V0CiMgQ09ORklHX1RDUF9DT05HX1ZFTk8gaXMg bm90IHNldAojIENPTkZJR19UQ1BfQ09OR19ZRUFIIGlzIG5vdCBzZXQKIyBDT05GSUdfVENQ X0NPTkdfSUxMSU5PSVMgaXMgbm90IHNldApDT05GSUdfREVGQVVMVF9DVUJJQz15CiMgQ09O RklHX0RFRkFVTFRfUkVOTyBpcyBub3Qgc2V0CkNPTkZJR19ERUZBVUxUX1RDUF9DT05HPSJj dWJpYyIKIyBDT05GSUdfVENQX01ENVNJRyBpcyBub3Qgc2V0CiMgQ09ORklHX0lQVjYgaXMg bm90IHNldApDT05GSUdfTkVUV09SS19TRUNNQVJLPXkKIyBDT05GSUdfTkVUV09SS19QSFlf VElNRVNUQU1QSU5HIGlzIG5vdCBzZXQKQ09ORklHX05FVEZJTFRFUj15CiMgQ09ORklHX05F VEZJTFRFUl9ERUJVRyBpcyBub3Qgc2V0CkNPTkZJR19ORVRGSUxURVJfQURWQU5DRUQ9eQpD T05GSUdfQlJJREdFX05FVEZJTFRFUj15CgojCiMgQ29yZSBOZXRmaWx0ZXIgQ29uZmlndXJh dGlvbgojCkNPTkZJR19ORVRGSUxURVJfTkVUTElOSz15CkNPTkZJR19ORVRGSUxURVJfTkVU TElOS19BQ0NUPXkKQ09ORklHX05FVEZJTFRFUl9ORVRMSU5LX1FVRVVFPXkKQ09ORklHX05F VEZJTFRFUl9ORVRMSU5LX0xPRz15CkNPTkZJR19ORl9DT05OVFJBQ0s9eQpDT05GSUdfTkZf Q09OTlRSQUNLX01BUks9eQpDT05GSUdfTkZfQ09OTlRSQUNLX1NFQ01BUks9eQpDT05GSUdf TkZfQ09OTlRSQUNLX1BST0NGUz15CkNPTkZJR19ORl9DT05OVFJBQ0tfRVZFTlRTPXkKIyBD T05GSUdfTkZfQ09OTlRSQUNLX1RJTUVPVVQgaXMgbm90IHNldApDT05GSUdfTkZfQ09OTlRS QUNLX1RJTUVTVEFNUD15CiMgQ09ORklHX05GX0NUX1BST1RPX0RDQ1AgaXMgbm90IHNldApD T05GSUdfTkZfQ1RfUFJPVE9fR1JFPXkKIyBDT05GSUdfTkZfQ1RfUFJPVE9fU0NUUCBpcyBu b3Qgc2V0CiMgQ09ORklHX05GX0NUX1BST1RPX1VEUExJVEUgaXMgbm90IHNldAojIENPTkZJ R19ORl9DT05OVFJBQ0tfQU1BTkRBIGlzIG5vdCBzZXQKQ09ORklHX05GX0NPTk5UUkFDS19G VFA9eQpDT05GSUdfTkZfQ09OTlRSQUNLX0gzMjM9eQpDT05GSUdfTkZfQ09OTlRSQUNLX0lS Qz15CiMgQ09ORklHX05GX0NPTk5UUkFDS19ORVRCSU9TX05TIGlzIG5vdCBzZXQKIyBDT05G SUdfTkZfQ09OTlRSQUNLX1NOTVAgaXMgbm90IHNldApDT05GSUdfTkZfQ09OTlRSQUNLX1BQ VFA9eQojIENPTkZJR19ORl9DT05OVFJBQ0tfU0FORSBpcyBub3Qgc2V0CkNPTkZJR19ORl9D T05OVFJBQ0tfU0lQPXkKIyBDT05GSUdfTkZfQ09OTlRSQUNLX1RGVFAgaXMgbm90IHNldApD T05GSUdfTkZfQ1RfTkVUTElOSz15CiMgQ09ORklHX05GX0NUX05FVExJTktfVElNRU9VVCBp cyBub3Qgc2V0CiMgQ09ORklHX05FVEZJTFRFUl9ORVRMSU5LX1FVRVVFX0NUIGlzIG5vdCBz ZXQKQ09ORklHX05GX05BVD15CkNPTkZJR19ORl9OQVRfTkVFREVEPXkKIyBDT05GSUdfTkZf TkFUX0FNQU5EQSBpcyBub3Qgc2V0CkNPTkZJR19ORl9OQVRfRlRQPXkKQ09ORklHX05GX05B VF9JUkM9eQpDT05GSUdfTkZfTkFUX1NJUD15CiMgQ09ORklHX05GX05BVF9URlRQIGlzIG5v dCBzZXQKIyBDT05GSUdfTkZfVEFCTEVTIGlzIG5vdCBzZXQKQ09ORklHX05FVEZJTFRFUl9Y VEFCTEVTPXkKCiMKIyBYdGFibGVzIGNvbWJpbmVkIG1vZHVsZXMKIwpDT05GSUdfTkVURklM VEVSX1hUX01BUks9eQpDT05GSUdfTkVURklMVEVSX1hUX0NPTk5NQVJLPXkKIyBDT05GSUdf TkVURklMVEVSX1hUX1NFVCBpcyBub3Qgc2V0CgojCiMgWHRhYmxlcyB0YXJnZXRzCiMKQ09O RklHX05FVEZJTFRFUl9YVF9UQVJHRVRfQVVESVQ9eQpDT05GSUdfTkVURklMVEVSX1hUX1RB UkdFVF9DSEVDS1NVTT15CkNPTkZJR19ORVRGSUxURVJfWFRfVEFSR0VUX0NMQVNTSUZZPXkK Q09ORklHX05FVEZJTFRFUl9YVF9UQVJHRVRfQ09OTk1BUks9eQpDT05GSUdfTkVURklMVEVS X1hUX1RBUkdFVF9DT05OU0VDTUFSSz15CiMgQ09ORklHX05FVEZJTFRFUl9YVF9UQVJHRVRf Q1QgaXMgbm90IHNldApDT05GSUdfTkVURklMVEVSX1hUX1RBUkdFVF9EU0NQPXkKQ09ORklH X05FVEZJTFRFUl9YVF9UQVJHRVRfSEw9eQojIENPTkZJR19ORVRGSUxURVJfWFRfVEFSR0VU X0hNQVJLIGlzIG5vdCBzZXQKQ09ORklHX05FVEZJTFRFUl9YVF9UQVJHRVRfSURMRVRJTUVS PXkKQ09ORklHX05FVEZJTFRFUl9YVF9UQVJHRVRfTE9HPXkKQ09ORklHX05FVEZJTFRFUl9Y VF9UQVJHRVRfTUFSSz15CkNPTkZJR19ORVRGSUxURVJfWFRfVEFSR0VUX05FVE1BUD15CkNP TkZJR19ORVRGSUxURVJfWFRfVEFSR0VUX05GTE9HPXkKQ09ORklHX05FVEZJTFRFUl9YVF9U QVJHRVRfTkZRVUVVRT15CiMgQ09ORklHX05FVEZJTFRFUl9YVF9UQVJHRVRfTk9UUkFDSyBp cyBub3Qgc2V0CkNPTkZJR19ORVRGSUxURVJfWFRfVEFSR0VUX1JBVEVFU1Q9eQpDT05GSUdf TkVURklMVEVSX1hUX1RBUkdFVF9SRURJUkVDVD15CkNPTkZJR19ORVRGSUxURVJfWFRfVEFS R0VUX1RFRT15CiMgQ09ORklHX05FVEZJTFRFUl9YVF9UQVJHRVRfVFBST1hZIGlzIG5vdCBz ZXQKIyBDT05GSUdfTkVURklMVEVSX1hUX1RBUkdFVF9UUkFDRSBpcyBub3Qgc2V0CkNPTkZJ R19ORVRGSUxURVJfWFRfVEFSR0VUX1NFQ01BUks9eQpDT05GSUdfTkVURklMVEVSX1hUX1RB UkdFVF9UQ1BNU1M9eQojIENPTkZJR19ORVRGSUxURVJfWFRfVEFSR0VUX1RDUE9QVFNUUklQ IGlzIG5vdCBzZXQKCiMKIyBYdGFibGVzIG1hdGNoZXMKIwpDT05GSUdfTkVURklMVEVSX1hU X01BVENIX0FERFJUWVBFPXkKIyBDT05GSUdfTkVURklMVEVSX1hUX01BVENIX0JQRiBpcyBu b3Qgc2V0CkNPTkZJR19ORVRGSUxURVJfWFRfTUFUQ0hfQ0xVU1RFUj15CkNPTkZJR19ORVRG SUxURVJfWFRfTUFUQ0hfQ09NTUVOVD15CkNPTkZJR19ORVRGSUxURVJfWFRfTUFUQ0hfQ09O TkJZVEVTPXkKIyBDT05GSUdfTkVURklMVEVSX1hUX01BVENIX0NPTk5MQUJFTCBpcyBub3Qg c2V0CkNPTkZJR19ORVRGSUxURVJfWFRfTUFUQ0hfQ09OTkxJTUlUPXkKQ09ORklHX05FVEZJ TFRFUl9YVF9NQVRDSF9DT05OTUFSSz15CkNPTkZJR19ORVRGSUxURVJfWFRfTUFUQ0hfQ09O TlRSQUNLPXkKQ09ORklHX05FVEZJTFRFUl9YVF9NQVRDSF9DUFU9eQpDT05GSUdfTkVURklM VEVSX1hUX01BVENIX0RDQ1A9eQpDT05GSUdfTkVURklMVEVSX1hUX01BVENIX0RFVkdST1VQ PXkKQ09ORklHX05FVEZJTFRFUl9YVF9NQVRDSF9EU0NQPXkKQ09ORklHX05FVEZJTFRFUl9Y VF9NQVRDSF9FQ049eQpDT05GSUdfTkVURklMVEVSX1hUX01BVENIX0VTUD15CkNPTkZJR19O RVRGSUxURVJfWFRfTUFUQ0hfSEFTSExJTUlUPXkKQ09ORklHX05FVEZJTFRFUl9YVF9NQVRD SF9IRUxQRVI9eQpDT05GSUdfTkVURklMVEVSX1hUX01BVENIX0hMPXkKQ09ORklHX05FVEZJ TFRFUl9YVF9NQVRDSF9JUFJBTkdFPXkKQ09ORklHX05FVEZJTFRFUl9YVF9NQVRDSF9JUFZT PXkKQ09ORklHX05FVEZJTFRFUl9YVF9NQVRDSF9MRU5HVEg9eQpDT05GSUdfTkVURklMVEVS X1hUX01BVENIX0xJTUlUPXkKQ09ORklHX05FVEZJTFRFUl9YVF9NQVRDSF9NQUM9eQpDT05G SUdfTkVURklMVEVSX1hUX01BVENIX01BUks9eQpDT05GSUdfTkVURklMVEVSX1hUX01BVENI X01VTFRJUE9SVD15CkNPTkZJR19ORVRGSUxURVJfWFRfTUFUQ0hfTkZBQ0NUPXkKQ09ORklH X05FVEZJTFRFUl9YVF9NQVRDSF9PU0Y9eQpDT05GSUdfTkVURklMVEVSX1hUX01BVENIX09X TkVSPXkKQ09ORklHX05FVEZJTFRFUl9YVF9NQVRDSF9QSFlTREVWPXkKQ09ORklHX05FVEZJ TFRFUl9YVF9NQVRDSF9QS1RUWVBFPXkKQ09ORklHX05FVEZJTFRFUl9YVF9NQVRDSF9RVU9U QT15CkNPTkZJR19ORVRGSUxURVJfWFRfTUFUQ0hfUkFURUVTVD15CkNPTkZJR19ORVRGSUxU RVJfWFRfTUFUQ0hfUkVBTE09eQpDT05GSUdfTkVURklMVEVSX1hUX01BVENIX1JFQ0VOVD15 CiMgQ09ORklHX05FVEZJTFRFUl9YVF9NQVRDSF9TQ1RQIGlzIG5vdCBzZXQKIyBDT05GSUdf TkVURklMVEVSX1hUX01BVENIX1NPQ0tFVCBpcyBub3Qgc2V0CkNPTkZJR19ORVRGSUxURVJf WFRfTUFUQ0hfU1RBVEU9eQpDT05GSUdfTkVURklMVEVSX1hUX01BVENIX1NUQVRJU1RJQz15 CkNPTkZJR19ORVRGSUxURVJfWFRfTUFUQ0hfU1RSSU5HPXkKQ09ORklHX05FVEZJTFRFUl9Y VF9NQVRDSF9UQ1BNU1M9eQpDT05GSUdfTkVURklMVEVSX1hUX01BVENIX1RJTUU9eQpDT05G SUdfTkVURklMVEVSX1hUX01BVENIX1UzMj15CkNPTkZJR19JUF9TRVQ9eQpDT05GSUdfSVBf U0VUX01BWD0yNTYKQ09ORklHX0lQX1NFVF9CSVRNQVBfSVA9eQpDT05GSUdfSVBfU0VUX0JJ VE1BUF9JUE1BQz15CkNPTkZJR19JUF9TRVRfQklUTUFQX1BPUlQ9eQpDT05GSUdfSVBfU0VU X0hBU0hfSVA9eQpDT05GSUdfSVBfU0VUX0hBU0hfSVBQT1JUPXkKQ09ORklHX0lQX1NFVF9I QVNIX0lQUE9SVElQPXkKQ09ORklHX0lQX1NFVF9IQVNIX0lQUE9SVE5FVD15CkNPTkZJR19J UF9TRVRfSEFTSF9ORVRQT1JUTkVUPXkKQ09ORklHX0lQX1NFVF9IQVNIX05FVD15CkNPTkZJ R19JUF9TRVRfSEFTSF9ORVRORVQ9eQpDT05GSUdfSVBfU0VUX0hBU0hfTkVUUE9SVD15CkNP TkZJR19JUF9TRVRfSEFTSF9ORVRJRkFDRT15CkNPTkZJR19JUF9TRVRfTElTVF9TRVQ9eQpD T05GSUdfSVBfVlM9eQojIENPTkZJR19JUF9WU19ERUJVRyBpcyBub3Qgc2V0CkNPTkZJR19J UF9WU19UQUJfQklUUz0xMgoKIwojIElQVlMgdHJhbnNwb3J0IHByb3RvY29sIGxvYWQgYmFs YW5jaW5nIHN1cHBvcnQKIwojIENPTkZJR19JUF9WU19QUk9UT19UQ1AgaXMgbm90IHNldAoj IENPTkZJR19JUF9WU19QUk9UT19VRFAgaXMgbm90IHNldAojIENPTkZJR19JUF9WU19QUk9U T19BSF9FU1AgaXMgbm90IHNldAojIENPTkZJR19JUF9WU19QUk9UT19FU1AgaXMgbm90IHNl dAojIENPTkZJR19JUF9WU19QUk9UT19BSCBpcyBub3Qgc2V0CiMgQ09ORklHX0lQX1ZTX1BS T1RPX1NDVFAgaXMgbm90IHNldAoKIwojIElQVlMgc2NoZWR1bGVyCiMKIyBDT05GSUdfSVBf VlNfUlIgaXMgbm90IHNldAojIENPTkZJR19JUF9WU19XUlIgaXMgbm90IHNldAojIENPTkZJ R19JUF9WU19MQyBpcyBub3Qgc2V0CiMgQ09ORklHX0lQX1ZTX1dMQyBpcyBub3Qgc2V0CiMg Q09ORklHX0lQX1ZTX0xCTEMgaXMgbm90IHNldAojIENPTkZJR19JUF9WU19MQkxDUiBpcyBu b3Qgc2V0CiMgQ09ORklHX0lQX1ZTX0RIIGlzIG5vdCBzZXQKIyBDT05GSUdfSVBfVlNfU0gg aXMgbm90IHNldAojIENPTkZJR19JUF9WU19TRUQgaXMgbm90IHNldAojIENPTkZJR19JUF9W U19OUSBpcyBub3Qgc2V0CgojCiMgSVBWUyBTSCBzY2hlZHVsZXIKIwpDT05GSUdfSVBfVlNf U0hfVEFCX0JJVFM9OAoKIwojIElQVlMgYXBwbGljYXRpb24gaGVscGVyCiMKQ09ORklHX0lQ X1ZTX05GQ1Q9eQoKIwojIElQOiBOZXRmaWx0ZXIgQ29uZmlndXJhdGlvbgojCkNPTkZJR19O Rl9ERUZSQUdfSVBWND15CkNPTkZJR19ORl9DT05OVFJBQ0tfSVBWND15CkNPTkZJR19ORl9D T05OVFJBQ0tfUFJPQ19DT01QQVQ9eQpDT05GSUdfSVBfTkZfSVBUQUJMRVM9eQpDT05GSUdf SVBfTkZfTUFUQ0hfQUg9eQpDT05GSUdfSVBfTkZfTUFUQ0hfRUNOPXkKIyBDT05GSUdfSVBf TkZfTUFUQ0hfUlBGSUxURVIgaXMgbm90IHNldApDT05GSUdfSVBfTkZfTUFUQ0hfVFRMPXkK Q09ORklHX0lQX05GX0ZJTFRFUj15CkNPTkZJR19JUF9ORl9UQVJHRVRfUkVKRUNUPXkKIyBD T05GSUdfSVBfTkZfVEFSR0VUX1NZTlBST1hZIGlzIG5vdCBzZXQKQ09ORklHX0lQX05GX1RB UkdFVF9VTE9HPXkKQ09ORklHX05GX05BVF9JUFY0PXkKQ09ORklHX0lQX05GX1RBUkdFVF9N QVNRVUVSQURFPXkKQ09ORklHX0lQX05GX1RBUkdFVF9ORVRNQVA9eQpDT05GSUdfSVBfTkZf VEFSR0VUX1JFRElSRUNUPXkKQ09ORklHX05GX05BVF9QUk9UT19HUkU9eQpDT05GSUdfTkZf TkFUX1BQVFA9eQpDT05GSUdfTkZfTkFUX0gzMjM9eQpDT05GSUdfSVBfTkZfTUFOR0xFPXkK IyBDT05GSUdfSVBfTkZfVEFSR0VUX0NMVVNURVJJUCBpcyBub3Qgc2V0CiMgQ09ORklHX0lQ X05GX1RBUkdFVF9FQ04gaXMgbm90IHNldAojIENPTkZJR19JUF9ORl9UQVJHRVRfVFRMIGlz IG5vdCBzZXQKQ09ORklHX0lQX05GX1JBVz15CiMgQ09ORklHX0lQX05GX0FSUFRBQkxFUyBp cyBub3Qgc2V0CkNPTkZJR19CUklER0VfTkZfRUJUQUJMRVM9eQojIENPTkZJR19CUklER0Vf RUJUX0JST1VURSBpcyBub3Qgc2V0CiMgQ09ORklHX0JSSURHRV9FQlRfVF9GSUxURVIgaXMg bm90IHNldAojIENPTkZJR19CUklER0VfRUJUX1RfTkFUIGlzIG5vdCBzZXQKIyBDT05GSUdf QlJJREdFX0VCVF84MDJfMyBpcyBub3Qgc2V0CiMgQ09ORklHX0JSSURHRV9FQlRfQU1PTkcg aXMgbm90IHNldAojIENPTkZJR19CUklER0VfRUJUX0FSUCBpcyBub3Qgc2V0CiMgQ09ORklH X0JSSURHRV9FQlRfSVAgaXMgbm90IHNldAojIENPTkZJR19CUklER0VfRUJUX0xJTUlUIGlz IG5vdCBzZXQKIyBDT05GSUdfQlJJREdFX0VCVF9NQVJLIGlzIG5vdCBzZXQKIyBDT05GSUdf QlJJREdFX0VCVF9QS1RUWVBFIGlzIG5vdCBzZXQKIyBDT05GSUdfQlJJREdFX0VCVF9TVFAg aXMgbm90IHNldAojIENPTkZJR19CUklER0VfRUJUX1ZMQU4gaXMgbm90IHNldAojIENPTkZJ R19CUklER0VfRUJUX0FSUFJFUExZIGlzIG5vdCBzZXQKIyBDT05GSUdfQlJJREdFX0VCVF9E TkFUIGlzIG5vdCBzZXQKIyBDT05GSUdfQlJJREdFX0VCVF9NQVJLX1QgaXMgbm90IHNldAoj IENPTkZJR19CUklER0VfRUJUX1JFRElSRUNUIGlzIG5vdCBzZXQKIyBDT05GSUdfQlJJREdF X0VCVF9TTkFUIGlzIG5vdCBzZXQKIyBDT05GSUdfQlJJREdFX0VCVF9MT0cgaXMgbm90IHNl dAojIENPTkZJR19CUklER0VfRUJUX1VMT0cgaXMgbm90IHNldAojIENPTkZJR19CUklER0Vf RUJUX05GTE9HIGlzIG5vdCBzZXQKIyBDT05GSUdfSVBfRENDUCBpcyBub3Qgc2V0CiMgQ09O RklHX0lQX1NDVFAgaXMgbm90IHNldAojIENPTkZJR19SRFMgaXMgbm90IHNldAojIENPTkZJ R19USVBDIGlzIG5vdCBzZXQKIyBDT05GSUdfQVRNIGlzIG5vdCBzZXQKIyBDT05GSUdfTDJU UCBpcyBub3Qgc2V0CkNPTkZJR19TVFA9eQpDT05GSUdfQlJJREdFPXkKQ09ORklHX0JSSURH RV9JR01QX1NOT09QSU5HPXkKQ09ORklHX0hBVkVfTkVUX0RTQT15CiMgQ09ORklHX1ZMQU5f ODAyMVEgaXMgbm90IHNldAojIENPTkZJR19ERUNORVQgaXMgbm90IHNldApDT05GSUdfTExD PXkKIyBDT05GSUdfTExDMiBpcyBub3Qgc2V0CiMgQ09ORklHX0lQWCBpcyBub3Qgc2V0CiMg Q09ORklHX0FUQUxLIGlzIG5vdCBzZXQKIyBDT05GSUdfWDI1IGlzIG5vdCBzZXQKIyBDT05G SUdfTEFQQiBpcyBub3Qgc2V0CiMgQ09ORklHX1BIT05FVCBpcyBub3Qgc2V0CiMgQ09ORklH X0lFRUU4MDIxNTQgaXMgbm90IHNldApDT05GSUdfTkVUX1NDSEVEPXkKCiMKIyBRdWV1ZWlu Zy9TY2hlZHVsaW5nCiMKIyBDT05GSUdfTkVUX1NDSF9DQlEgaXMgbm90IHNldAojIENPTkZJ R19ORVRfU0NIX0hUQiBpcyBub3Qgc2V0CiMgQ09ORklHX05FVF9TQ0hfSEZTQyBpcyBub3Qg c2V0CiMgQ09ORklHX05FVF9TQ0hfUFJJTyBpcyBub3Qgc2V0CiMgQ09ORklHX05FVF9TQ0hf TVVMVElRIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX1NDSF9SRUQgaXMgbm90IHNldAojIENP TkZJR19ORVRfU0NIX1NGQiBpcyBub3Qgc2V0CiMgQ09ORklHX05FVF9TQ0hfU0ZRIGlzIG5v dCBzZXQKIyBDT05GSUdfTkVUX1NDSF9URVFMIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX1ND SF9UQkYgaXMgbm90IHNldAojIENPTkZJR19ORVRfU0NIX0dSRUQgaXMgbm90IHNldAojIENP TkZJR19ORVRfU0NIX0RTTUFSSyBpcyBub3Qgc2V0CiMgQ09ORklHX05FVF9TQ0hfTkVURU0g aXMgbm90IHNldAojIENPTkZJR19ORVRfU0NIX0RSUiBpcyBub3Qgc2V0CiMgQ09ORklHX05F VF9TQ0hfTVFQUklPIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX1NDSF9DSE9LRSBpcyBub3Qg c2V0CiMgQ09ORklHX05FVF9TQ0hfUUZRIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX1NDSF9D T0RFTCBpcyBub3Qgc2V0CiMgQ09ORklHX05FVF9TQ0hfRlFfQ09ERUwgaXMgbm90IHNldAoj IENPTkZJR19ORVRfU0NIX0ZRIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX1NDSF9JTkdSRVNT IGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX1NDSF9QTFVHIGlzIG5vdCBzZXQKCiMKIyBDbGFz c2lmaWNhdGlvbgojCkNPTkZJR19ORVRfQ0xTPXkKIyBDT05GSUdfTkVUX0NMU19CQVNJQyBp cyBub3Qgc2V0CiMgQ09ORklHX05FVF9DTFNfVENJTkRFWCBpcyBub3Qgc2V0CiMgQ09ORklH X05FVF9DTFNfUk9VVEU0IGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX0NMU19GVyBpcyBub3Qg c2V0CiMgQ09ORklHX05FVF9DTFNfVTMyIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX0NMU19S U1ZQIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX0NMU19SU1ZQNiBpcyBub3Qgc2V0CiMgQ09O RklHX05FVF9DTFNfRkxPVyBpcyBub3Qgc2V0CiMgQ09ORklHX05FVF9DTFNfQ0dST1VQIGlz IG5vdCBzZXQKIyBDT05GSUdfTkVUX0NMU19CUEYgaXMgbm90IHNldApDT05GSUdfTkVUX0VN QVRDSD15CkNPTkZJR19ORVRfRU1BVENIX1NUQUNLPTMyCiMgQ09ORklHX05FVF9FTUFUQ0hf Q01QIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX0VNQVRDSF9OQllURSBpcyBub3Qgc2V0CiMg Q09ORklHX05FVF9FTUFUQ0hfVTMyIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX0VNQVRDSF9N RVRBIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX0VNQVRDSF9URVhUIGlzIG5vdCBzZXQKIyBD T05GSUdfTkVUX0VNQVRDSF9JUFNFVCBpcyBub3Qgc2V0CkNPTkZJR19ORVRfQ0xTX0FDVD15 CiMgQ09ORklHX05FVF9BQ1RfUE9MSUNFIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX0FDVF9H QUNUIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX0FDVF9NSVJSRUQgaXMgbm90IHNldAojIENP TkZJR19ORVRfQUNUX0lQVCBpcyBub3Qgc2V0CiMgQ09ORklHX05FVF9BQ1RfTkFUIGlzIG5v dCBzZXQKIyBDT05GSUdfTkVUX0FDVF9QRURJVCBpcyBub3Qgc2V0CiMgQ09ORklHX05FVF9B Q1RfU0lNUCBpcyBub3Qgc2V0CiMgQ09ORklHX05FVF9BQ1RfU0tCRURJVCBpcyBub3Qgc2V0 CiMgQ09ORklHX05FVF9BQ1RfQ1NVTSBpcyBub3Qgc2V0CkNPTkZJR19ORVRfU0NIX0ZJRk89 eQojIENPTkZJR19EQ0IgaXMgbm90IHNldAojIENPTkZJR19ETlNfUkVTT0xWRVIgaXMgbm90 IHNldAojIENPTkZJR19CQVRNQU5fQURWIGlzIG5vdCBzZXQKIyBDT05GSUdfT1BFTlZTV0lU Q0ggaXMgbm90IHNldAojIENPTkZJR19WU09DS0VUUyBpcyBub3Qgc2V0CiMgQ09ORklHX05F VExJTktfTU1BUCBpcyBub3Qgc2V0CiMgQ09ORklHX05FVExJTktfRElBRyBpcyBub3Qgc2V0 CiMgQ09ORklHX05FVF9NUExTX0dTTyBpcyBub3Qgc2V0CiMgQ09ORklHX0hTUiBpcyBub3Qg c2V0CkNPTkZJR19SUFM9eQpDT05GSUdfUkZTX0FDQ0VMPXkKQ09ORklHX1hQUz15CiMgQ09O RklHX05FVFBSSU9fQ0dST1VQIGlzIG5vdCBzZXQKQ09ORklHX05FVF9SWF9CVVNZX1BPTEw9 eQpDT05GSUdfQlFMPXkKIyBDT05GSUdfQlBGX0pJVCBpcyBub3Qgc2V0CkNPTkZJR19ORVRf RkxPV19MSU1JVD15CgojCiMgTmV0d29yayB0ZXN0aW5nCiMKIyBDT05GSUdfTkVUX1BLVEdF TiBpcyBub3Qgc2V0CiMgQ09ORklHX05FVF9EUk9QX01PTklUT1IgaXMgbm90IHNldAojIENP TkZJR19IQU1SQURJTyBpcyBub3Qgc2V0CiMgQ09ORklHX0NBTiBpcyBub3Qgc2V0CiMgQ09O RklHX0lSREEgaXMgbm90IHNldApDT05GSUdfQlQ9eQpDT05GSUdfQlRfUkZDT01NPXkKQ09O RklHX0JUX1JGQ09NTV9UVFk9eQpDT05GSUdfQlRfQk5FUD15CkNPTkZJR19CVF9CTkVQX01D X0ZJTFRFUj15CkNPTkZJR19CVF9CTkVQX1BST1RPX0ZJTFRFUj15CkNPTkZJR19CVF9ISURQ PXkKCiMKIyBCbHVldG9vdGggZGV2aWNlIGRyaXZlcnMKIwpDT05GSUdfQlRfSENJQlRVU0I9 eQpDT05GSUdfQlRfSENJVUFSVD15CkNPTkZJR19CVF9IQ0lVQVJUX0g0PXkKQ09ORklHX0JU X0hDSVVBUlRfQkNTUD15CkNPTkZJR19CVF9IQ0lVQVJUX0FUSDNLPXkKQ09ORklHX0JUX0hD SVVBUlRfTEw9eQpDT05GSUdfQlRfSENJVUFSVF8zV0lSRT15CkNPTkZJR19CVF9IQ0lCQ00y MDNYPXkKQ09ORklHX0JUX0hDSUJQQTEwWD15CkNPTkZJR19CVF9IQ0lCRlVTQj15CkNPTkZJ R19CVF9IQ0lWSENJPXkKQ09ORklHX0JUX01SVkw9eQpDT05GSUdfQlRfQVRIM0s9eQojIENP TkZJR19BRl9SWFJQQyBpcyBub3Qgc2V0CkNPTkZJR19GSUJfUlVMRVM9eQojIENPTkZJR19X SVJFTEVTUyBpcyBub3Qgc2V0CiMgQ09ORklHX1dJTUFYIGlzIG5vdCBzZXQKIyBDT05GSUdf UkZLSUxMIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUXzlQIGlzIG5vdCBzZXQKIyBDT05GSUdf Q0FJRiBpcyBub3Qgc2V0CkNPTkZJR19DRVBIX0xJQj15CiMgQ09ORklHX0NFUEhfTElCX1BS RVRUWURFQlVHIGlzIG5vdCBzZXQKIyBDT05GSUdfQ0VQSF9MSUJfVVNFX0ROU19SRVNPTFZF UiBpcyBub3Qgc2V0CiMgQ09ORklHX05GQyBpcyBub3Qgc2V0CkNPTkZJR19IQVZFX0JQRl9K SVQ9eQoKIwojIERldmljZSBEcml2ZXJzCiMKCiMKIyBHZW5lcmljIERyaXZlciBPcHRpb25z CiMKQ09ORklHX1VFVkVOVF9IRUxQRVJfUEFUSD0iL3NiaW4vaG90cGx1ZyIKQ09ORklHX0RF VlRNUEZTPXkKQ09ORklHX0RFVlRNUEZTX01PVU5UPXkKIyBDT05GSUdfU1RBTkRBTE9ORSBp cyBub3Qgc2V0CiMgQ09ORklHX1BSRVZFTlRfRklSTVdBUkVfQlVJTEQgaXMgbm90IHNldApD T05GSUdfRldfTE9BREVSPXkKQ09ORklHX0ZJUk1XQVJFX0lOX0tFUk5FTD15CkNPTkZJR19F WFRSQV9GSVJNV0FSRT0iIgpDT05GSUdfRldfTE9BREVSX1VTRVJfSEVMUEVSPXkKIyBDT05G SUdfREVCVUdfRFJJVkVSIGlzIG5vdCBzZXQKQ09ORklHX0RFQlVHX0RFVlJFUz15CkNPTkZJ R19TWVNfSFlQRVJWSVNPUj15CiMgQ09ORklHX0dFTkVSSUNfQ1BVX0RFVklDRVMgaXMgbm90 IHNldApDT05GSUdfRE1BX1NIQVJFRF9CVUZGRVI9eQoKIwojIEJ1cyBkZXZpY2VzCiMKQ09O RklHX0NPTk5FQ1RPUj15CkNPTkZJR19QUk9DX0VWRU5UUz15CiMgQ09ORklHX01URCBpcyBu b3Qgc2V0CiMgQ09ORklHX1BBUlBPUlQgaXMgbm90IHNldApDT05GSUdfQVJDSF9NSUdIVF9I QVZFX1BDX1BBUlBPUlQ9eQpDT05GSUdfUE5QPXkKQ09ORklHX1BOUF9ERUJVR19NRVNTQUdF Uz15CgojCiMgUHJvdG9jb2xzCiMKQ09ORklHX1BOUEFDUEk9eQpDT05GSUdfQkxLX0RFVj15 CiMgQ09ORklHX0JMS19ERVZfTlVMTF9CTEsgaXMgbm90IHNldAojIENPTkZJR19CTEtfREVW X0ZEIGlzIG5vdCBzZXQKIyBDT05GSUdfQkxLX0RFVl9QQ0lFU1NEX01USVAzMlhYIGlzIG5v dCBzZXQKIyBDT05GSUdfQkxLX0NQUV9DSVNTX0RBIGlzIG5vdCBzZXQKIyBDT05GSUdfQkxL X0RFVl9EQUM5NjAgaXMgbm90IHNldAojIENPTkZJR19CTEtfREVWX1VNRU0gaXMgbm90IHNl dAojIENPTkZJR19CTEtfREVWX0NPV19DT01NT04gaXMgbm90IHNldApDT05GSUdfQkxLX0RF Vl9MT09QPXkKQ09ORklHX0JMS19ERVZfTE9PUF9NSU5fQ09VTlQ9OAojIENPTkZJR19CTEtf REVWX0NSWVBUT0xPT1AgaXMgbm90IHNldAojIENPTkZJR19CTEtfREVWX0RSQkQgaXMgbm90 IHNldAojIENPTkZJR19CTEtfREVWX05CRCBpcyBub3Qgc2V0CiMgQ09ORklHX0JMS19ERVZf TlZNRSBpcyBub3Qgc2V0CiMgQ09ORklHX0JMS19ERVZfU0tEIGlzIG5vdCBzZXQKIyBDT05G SUdfQkxLX0RFVl9TWDggaXMgbm90IHNldApDT05GSUdfQkxLX0RFVl9SQU09eQpDT05GSUdf QkxLX0RFVl9SQU1fQ09VTlQ9MTYKQ09ORklHX0JMS19ERVZfUkFNX1NJWkU9MTYzODQKIyBD T05GSUdfQkxLX0RFVl9YSVAgaXMgbm90IHNldAojIENPTkZJR19DRFJPTV9QS1RDRFZEIGlz IG5vdCBzZXQKIyBDT05GSUdfQVRBX09WRVJfRVRIIGlzIG5vdCBzZXQKQ09ORklHX1hFTl9C TEtERVZfRlJPTlRFTkQ9eQpDT05GSUdfWEVOX0JMS0RFVl9CQUNLRU5EPXkKIyBDT05GSUdf QkxLX0RFVl9IRCBpcyBub3Qgc2V0CiMgQ09ORklHX0JMS19ERVZfUkJEIGlzIG5vdCBzZXQK IyBDT05GSUdfQkxLX0RFVl9SU1hYIGlzIG5vdCBzZXQKCiMKIyBNaXNjIGRldmljZXMKIwoj IENPTkZJR19TRU5TT1JTX0xJUzNMVjAyRCBpcyBub3Qgc2V0CiMgQ09ORklHX0FENTI1WF9E UE9UIGlzIG5vdCBzZXQKIyBDT05GSUdfRFVNTVlfSVJRIGlzIG5vdCBzZXQKIyBDT05GSUdf SUJNX0FTTSBpcyBub3Qgc2V0CiMgQ09ORklHX1BIQU5UT00gaXMgbm90IHNldAojIENPTkZJ R19TR0lfSU9DNCBpcyBub3Qgc2V0CiMgQ09ORklHX1RJRk1fQ09SRSBpcyBub3Qgc2V0CiMg Q09ORklHX0lDUzkzMlM0MDEgaXMgbm90IHNldAojIENPTkZJR19BVE1FTF9TU0MgaXMgbm90 IHNldAojIENPTkZJR19FTkNMT1NVUkVfU0VSVklDRVMgaXMgbm90IHNldAojIENPTkZJR19I UF9JTE8gaXMgbm90IHNldAojIENPTkZJR19BUERTOTgwMkFMUyBpcyBub3Qgc2V0CiMgQ09O RklHX0lTTDI5MDAzIGlzIG5vdCBzZXQKIyBDT05GSUdfSVNMMjkwMjAgaXMgbm90IHNldAoj IENPTkZJR19TRU5TT1JTX1RTTDI1NTAgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX0JI MTc4MCBpcyBub3Qgc2V0CiMgQ09ORklHX1NFTlNPUlNfQkgxNzcwIGlzIG5vdCBzZXQKIyBD T05GSUdfU0VOU09SU19BUERTOTkwWCBpcyBub3Qgc2V0CiMgQ09ORklHX0hNQzYzNTIgaXMg bm90IHNldAojIENPTkZJR19EUzE2ODIgaXMgbm90IHNldAojIENPTkZJR19WTVdBUkVfQkFM TE9PTiBpcyBub3Qgc2V0CiMgQ09ORklHX0JNUDA4NV9JMkMgaXMgbm90IHNldAojIENPTkZJ R19QQ0hfUEhVQiBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9TV0lUQ0hfRlNBOTQ4MCBpcyBu b3Qgc2V0CiMgQ09ORklHX1NSQU0gaXMgbm90IHNldAojIENPTkZJR19DMlBPUlQgaXMgbm90 IHNldAoKIwojIEVFUFJPTSBzdXBwb3J0CiMKIyBDT05GSUdfRUVQUk9NX0FUMjQgaXMgbm90 IHNldAojIENPTkZJR19FRVBST01fTEVHQUNZIGlzIG5vdCBzZXQKIyBDT05GSUdfRUVQUk9N X01BWDY4NzUgaXMgbm90IHNldAojIENPTkZJR19FRVBST01fOTNDWDYgaXMgbm90IHNldAoj IENPTkZJR19DQjcxMF9DT1JFIGlzIG5vdCBzZXQKCiMKIyBUZXhhcyBJbnN0cnVtZW50cyBz aGFyZWQgdHJhbnNwb3J0IGxpbmUgZGlzY2lwbGluZQojCiMgQ09ORklHX1NFTlNPUlNfTElT M19JMkMgaXMgbm90IHNldAoKIwojIEFsdGVyYSBGUEdBIGZpcm13YXJlIGRvd25sb2FkIG1v ZHVsZQojCkNPTkZJR19BTFRFUkFfU1RBUEw9eQojIENPTkZJR19JTlRFTF9NRUkgaXMgbm90 IHNldAojIENPTkZJR19JTlRFTF9NRUlfTUUgaXMgbm90IHNldAojIENPTkZJR19WTVdBUkVf Vk1DSSBpcyBub3Qgc2V0CgojCiMgSW50ZWwgTUlDIEhvc3QgRHJpdmVyCiMKIyBDT05GSUdf SU5URUxfTUlDX0hPU1QgaXMgbm90IHNldAoKIwojIEludGVsIE1JQyBDYXJkIERyaXZlcgoj CiMgQ09ORklHX0lOVEVMX01JQ19DQVJEIGlzIG5vdCBzZXQKQ09ORklHX0hBVkVfSURFPXkK IyBDT05GSUdfSURFIGlzIG5vdCBzZXQKCiMKIyBTQ1NJIGRldmljZSBzdXBwb3J0CiMKQ09O RklHX1NDU0lfTU9EPXkKIyBDT05GSUdfUkFJRF9BVFRSUyBpcyBub3Qgc2V0CkNPTkZJR19T Q1NJPXkKQ09ORklHX1NDU0lfRE1BPXkKIyBDT05GSUdfU0NTSV9UR1QgaXMgbm90IHNldAoj IENPTkZJR19TQ1NJX05FVExJTksgaXMgbm90IHNldApDT05GSUdfU0NTSV9QUk9DX0ZTPXkK CiMKIyBTQ1NJIHN1cHBvcnQgdHlwZSAoZGlzaywgdGFwZSwgQ0QtUk9NKQojCkNPTkZJR19C TEtfREVWX1NEPXkKIyBDT05GSUdfQ0hSX0RFVl9TVCBpcyBub3Qgc2V0CiMgQ09ORklHX0NI Ul9ERVZfT1NTVCBpcyBub3Qgc2V0CkNPTkZJR19CTEtfREVWX1NSPXkKQ09ORklHX0JMS19E RVZfU1JfVkVORE9SPXkKQ09ORklHX0NIUl9ERVZfU0c9eQojIENPTkZJR19DSFJfREVWX1ND SCBpcyBub3Qgc2V0CiMgQ09ORklHX1NDU0lfTVVMVElfTFVOIGlzIG5vdCBzZXQKQ09ORklH X1NDU0lfQ09OU1RBTlRTPXkKIyBDT05GSUdfU0NTSV9MT0dHSU5HIGlzIG5vdCBzZXQKIyBD T05GSUdfU0NTSV9TQ0FOX0FTWU5DIGlzIG5vdCBzZXQKCiMKIyBTQ1NJIFRyYW5zcG9ydHMK IwpDT05GSUdfU0NTSV9TUElfQVRUUlM9eQojIENPTkZJR19TQ1NJX0ZDX0FUVFJTIGlzIG5v dCBzZXQKIyBDT05GSUdfU0NTSV9JU0NTSV9BVFRSUyBpcyBub3Qgc2V0CiMgQ09ORklHX1ND U0lfU0FTX0FUVFJTIGlzIG5vdCBzZXQKIyBDT05GSUdfU0NTSV9TQVNfTElCU0FTIGlzIG5v dCBzZXQKIyBDT05GSUdfU0NTSV9TUlBfQVRUUlMgaXMgbm90IHNldAojIENPTkZJR19TQ1NJ X0xPV0xFVkVMIGlzIG5vdCBzZXQKIyBDT05GSUdfU0NTSV9ESCBpcyBub3Qgc2V0CiMgQ09O RklHX1NDU0lfT1NEX0lOSVRJQVRPUiBpcyBub3Qgc2V0CkNPTkZJR19BVEE9eQojIENPTkZJ R19BVEFfTk9OU1RBTkRBUkQgaXMgbm90IHNldApDT05GSUdfQVRBX1ZFUkJPU0VfRVJST1I9 eQpDT05GSUdfQVRBX0FDUEk9eQojIENPTkZJR19TQVRBX1pQT0REIGlzIG5vdCBzZXQKQ09O RklHX1NBVEFfUE1QPXkKCiMKIyBDb250cm9sbGVycyB3aXRoIG5vbi1TRkYgbmF0aXZlIGlu dGVyZmFjZQojCkNPTkZJR19TQVRBX0FIQ0k9eQpDT05GSUdfU0FUQV9BSENJX1BMQVRGT1JN PXkKIyBDT05GSUdfU0FUQV9JTklDMTYyWCBpcyBub3Qgc2V0CiMgQ09ORklHX1NBVEFfQUNB UkRfQUhDSSBpcyBub3Qgc2V0CiMgQ09ORklHX1NBVEFfU0lMMjQgaXMgbm90IHNldAojIENP TkZJR19BVEFfU0ZGIGlzIG5vdCBzZXQKQ09ORklHX01EPXkKIyBDT05GSUdfQkxLX0RFVl9N RCBpcyBub3Qgc2V0CkNPTkZJR19CQ0FDSEU9eQojIENPTkZJR19CQ0FDSEVfREVCVUcgaXMg bm90IHNldAojIENPTkZJR19CQ0FDSEVfQ0xPU1VSRVNfREVCVUcgaXMgbm90IHNldApDT05G SUdfQkxLX0RFVl9ETV9CVUlMVElOPXkKQ09ORklHX0JMS19ERVZfRE09eQpDT05GSUdfRE1f REVCVUc9eQpDT05GSUdfRE1fQlVGSU89eQpDT05GSUdfRE1fQklPX1BSSVNPTj15CkNPTkZJ R19ETV9QRVJTSVNURU5UX0RBVEE9eQpDT05GSUdfRE1fQ1JZUFQ9eQpDT05GSUdfRE1fU05B UFNIT1Q9eQojIENPTkZJR19ETV9USElOX1BST1ZJU0lPTklORyBpcyBub3Qgc2V0CkNPTkZJ R19ETV9DQUNIRT15CkNPTkZJR19ETV9DQUNIRV9NUT15CkNPTkZJR19ETV9DQUNIRV9DTEVB TkVSPXkKQ09ORklHX0RNX01JUlJPUj15CiMgQ09ORklHX0RNX0xPR19VU0VSU1BBQ0UgaXMg bm90IHNldAojIENPTkZJR19ETV9SQUlEIGlzIG5vdCBzZXQKQ09ORklHX0RNX1pFUk89eQoj IENPTkZJR19ETV9NVUxUSVBBVEggaXMgbm90IHNldAojIENPTkZJR19ETV9ERUxBWSBpcyBu b3Qgc2V0CiMgQ09ORklHX0RNX1VFVkVOVCBpcyBub3Qgc2V0CiMgQ09ORklHX0RNX0ZMQUtF WSBpcyBub3Qgc2V0CiMgQ09ORklHX0RNX1ZFUklUWSBpcyBub3Qgc2V0CiMgQ09ORklHX0RN X1NXSVRDSCBpcyBub3Qgc2V0CiMgQ09ORklHX1RBUkdFVF9DT1JFIGlzIG5vdCBzZXQKIyBD T05GSUdfRlVTSU9OIGlzIG5vdCBzZXQKCiMKIyBJRUVFIDEzOTQgKEZpcmVXaXJlKSBzdXBw b3J0CiMKIyBDT05GSUdfRklSRVdJUkUgaXMgbm90IHNldAojIENPTkZJR19GSVJFV0lSRV9O T1NZIGlzIG5vdCBzZXQKIyBDT05GSUdfSTJPIGlzIG5vdCBzZXQKIyBDT05GSUdfTUFDSU5U T1NIX0RSSVZFUlMgaXMgbm90IHNldApDT05GSUdfTkVUREVWSUNFUz15CkNPTkZJR19NSUk9 eQpDT05GSUdfTkVUX0NPUkU9eQojIENPTkZJR19CT05ESU5HIGlzIG5vdCBzZXQKIyBDT05G SUdfRFVNTVkgaXMgbm90IHNldAojIENPTkZJR19FUVVBTElaRVIgaXMgbm90IHNldAojIENP TkZJR19ORVRfRkMgaXMgbm90IHNldAojIENPTkZJR19JRkIgaXMgbm90IHNldAojIENPTkZJ R19ORVRfVEVBTSBpcyBub3Qgc2V0CiMgQ09ORklHX01BQ1ZMQU4gaXMgbm90IHNldAojIENP TkZJR19WWExBTiBpcyBub3Qgc2V0CkNPTkZJR19ORVRDT05TT0xFPXkKQ09ORklHX05FVFBP TEw9eQojIENPTkZJR19ORVRQT0xMX1RSQVAgaXMgbm90IHNldApDT05GSUdfTkVUX1BPTExf Q09OVFJPTExFUj15CkNPTkZJR19UVU49eQpDT05GSUdfVkVUSD15CiMgQ09ORklHX05MTU9O IGlzIG5vdCBzZXQKIyBDT05GSUdfQVJDTkVUIGlzIG5vdCBzZXQKCiMKIyBDQUlGIHRyYW5z cG9ydCBkcml2ZXJzCiMKCiMKIyBEaXN0cmlidXRlZCBTd2l0Y2ggQXJjaGl0ZWN0dXJlIGRy aXZlcnMKIwojIENPTkZJR19ORVRfRFNBX01WODhFNlhYWCBpcyBub3Qgc2V0CiMgQ09ORklH X05FVF9EU0FfTVY4OEU2MDYwIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX0RTQV9NVjg4RTZY WFhfTkVFRF9QUFUgaXMgbm90IHNldAojIENPTkZJR19ORVRfRFNBX01WODhFNjEzMSBpcyBu b3Qgc2V0CiMgQ09ORklHX05FVF9EU0FfTVY4OEU2MTIzXzYxXzY1IGlzIG5vdCBzZXQKQ09O RklHX0VUSEVSTkVUPXkKIyBDT05GSUdfTkVUX1ZFTkRPUl8zQ09NIGlzIG5vdCBzZXQKIyBD T05GSUdfTkVUX1ZFTkRPUl9BREFQVEVDIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX1ZFTkRP Ul9BTFRFT04gaXMgbm90IHNldAojIENPTkZJR19ORVRfVkVORE9SX0FNRCBpcyBub3Qgc2V0 CkNPTkZJR19ORVRfVkVORE9SX0FSQz15CiMgQ09ORklHX05FVF9WRU5ET1JfQVRIRVJPUyBp cyBub3Qgc2V0CkNPTkZJR19ORVRfQ0FERU5DRT15CiMgQ09ORklHX0FSTV9BVDkxX0VUSEVS IGlzIG5vdCBzZXQKIyBDT05GSUdfTUFDQiBpcyBub3Qgc2V0CiMgQ09ORklHX05FVF9WRU5E T1JfQlJPQURDT00gaXMgbm90IHNldAojIENPTkZJR19ORVRfVkVORE9SX0JST0NBREUgaXMg bm90IHNldAojIENPTkZJR19ORVRfQ0FMWEVEQV9YR01BQyBpcyBub3Qgc2V0CiMgQ09ORklH X05FVF9WRU5ET1JfQ0hFTFNJTyBpcyBub3Qgc2V0CiMgQ09ORklHX05FVF9WRU5ET1JfQ0lT Q08gaXMgbm90IHNldAojIENPTkZJR19ETkVUIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX1ZF TkRPUl9ERUMgaXMgbm90IHNldAojIENPTkZJR19ORVRfVkVORE9SX0RMSU5LIGlzIG5vdCBz ZXQKIyBDT05GSUdfTkVUX1ZFTkRPUl9FTVVMRVggaXMgbm90IHNldAojIENPTkZJR19ORVRf VkVORE9SX0VYQVIgaXMgbm90IHNldAojIENPTkZJR19ORVRfVkVORE9SX0hQIGlzIG5vdCBz ZXQKQ09ORklHX05FVF9WRU5ET1JfSU5URUw9eQojIENPTkZJR19FMTAwIGlzIG5vdCBzZXQK Q09ORklHX0UxMDAwPXkKQ09ORklHX0UxMDAwRT15CkNPTkZJR19JR0I9eQpDT05GSUdfSUdC X0hXTU9OPXkKQ09ORklHX0lHQlZGPXkKIyBDT05GSUdfSVhHQiBpcyBub3Qgc2V0CiMgQ09O RklHX0lYR0JFIGlzIG5vdCBzZXQKIyBDT05GSUdfSVhHQkVWRiBpcyBub3Qgc2V0CiMgQ09O RklHX0k0MEUgaXMgbm90IHNldApDT05GSUdfTkVUX1ZFTkRPUl9JODI1WFg9eQojIENPTkZJ R19JUDEwMDAgaXMgbm90IHNldAojIENPTkZJR19KTUUgaXMgbm90IHNldAojIENPTkZJR19O RVRfVkVORE9SX01BUlZFTEwgaXMgbm90IHNldAojIENPTkZJR19ORVRfVkVORE9SX01FTExB Tk9YIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX1ZFTkRPUl9NSUNSRUwgaXMgbm90IHNldAoj IENPTkZJR19ORVRfVkVORE9SX01ZUkkgaXMgbm90IHNldAojIENPTkZJR19GRUFMTlggaXMg bm90IHNldAojIENPTkZJR19ORVRfVkVORE9SX05BVFNFTUkgaXMgbm90IHNldAojIENPTkZJ R19ORVRfVkVORE9SX05WSURJQSBpcyBub3Qgc2V0CiMgQ09ORklHX05FVF9WRU5ET1JfT0tJ IGlzIG5vdCBzZXQKIyBDT05GSUdfRVRIT0MgaXMgbm90IHNldAojIENPTkZJR19ORVRfUEFD S0VUX0VOR0lORSBpcyBub3Qgc2V0CiMgQ09ORklHX05FVF9WRU5ET1JfUUxPR0lDIGlzIG5v dCBzZXQKQ09ORklHX05FVF9WRU5ET1JfUkVBTFRFSz15CiMgQ09ORklHXzgxMzlDUCBpcyBu b3Qgc2V0CiMgQ09ORklHXzgxMzlUT08gaXMgbm90IHNldApDT05GSUdfUjgxNjk9eQojIENP TkZJR19TSF9FVEggaXMgbm90IHNldAojIENPTkZJR19ORVRfVkVORE9SX1JEQyBpcyBub3Qg c2V0CkNPTkZJR19ORVRfVkVORE9SX1NFRVE9eQpDT05GSUdfTkVUX1ZFTkRPUl9TSUxBTj15 CiMgQ09ORklHX1NDOTIwMzEgaXMgbm90IHNldAojIENPTkZJR19ORVRfVkVORE9SX1NJUyBp cyBub3Qgc2V0CiMgQ09ORklHX1NGQyBpcyBub3Qgc2V0CiMgQ09ORklHX05FVF9WRU5ET1Jf U01TQyBpcyBub3Qgc2V0CiMgQ09ORklHX05FVF9WRU5ET1JfU1RNSUNSTyBpcyBub3Qgc2V0 CiMgQ09ORklHX05FVF9WRU5ET1JfU1VOIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX1ZFTkRP Ul9URUhVVEkgaXMgbm90IHNldAojIENPTkZJR19ORVRfVkVORE9SX1RJIGlzIG5vdCBzZXQK IyBDT05GSUdfTkVUX1ZFTkRPUl9WSUEgaXMgbm90IHNldApDT05GSUdfTkVUX1ZFTkRPUl9X SVpORVQ9eQojIENPTkZJR19XSVpORVRfVzUxMDAgaXMgbm90IHNldAojIENPTkZJR19XSVpO RVRfVzUzMDAgaXMgbm90IHNldAojIENPTkZJR19GRERJIGlzIG5vdCBzZXQKIyBDT05GSUdf SElQUEkgaXMgbm90IHNldAojIENPTkZJR19ORVRfU0IxMDAwIGlzIG5vdCBzZXQKQ09ORklH X1BIWUxJQj15CgojCiMgTUlJIFBIWSBkZXZpY2UgZHJpdmVycwojCiMgQ09ORklHX0FUODAz WF9QSFkgaXMgbm90IHNldAojIENPTkZJR19BTURfUEhZIGlzIG5vdCBzZXQKIyBDT05GSUdf TUFSVkVMTF9QSFkgaXMgbm90IHNldAojIENPTkZJR19EQVZJQ09NX1BIWSBpcyBub3Qgc2V0 CiMgQ09ORklHX1FTRU1JX1BIWSBpcyBub3Qgc2V0CiMgQ09ORklHX0xYVF9QSFkgaXMgbm90 IHNldAojIENPTkZJR19DSUNBREFfUEhZIGlzIG5vdCBzZXQKIyBDT05GSUdfVklURVNTRV9Q SFkgaXMgbm90IHNldAojIENPTkZJR19TTVNDX1BIWSBpcyBub3Qgc2V0CiMgQ09ORklHX0JS T0FEQ09NX1BIWSBpcyBub3Qgc2V0CiMgQ09ORklHX0JDTTg3WFhfUEhZIGlzIG5vdCBzZXQK IyBDT05GSUdfSUNQTFVTX1BIWSBpcyBub3Qgc2V0CkNPTkZJR19SRUFMVEVLX1BIWT15CiMg Q09ORklHX05BVElPTkFMX1BIWSBpcyBub3Qgc2V0CiMgQ09ORklHX1NURTEwWFAgaXMgbm90 IHNldAojIENPTkZJR19MU0lfRVQxMDExQ19QSFkgaXMgbm90IHNldAojIENPTkZJR19NSUNS RUxfUEhZIGlzIG5vdCBzZXQKIyBDT05GSUdfRklYRURfUEhZIGlzIG5vdCBzZXQKIyBDT05G SUdfTURJT19CSVRCQU5HIGlzIG5vdCBzZXQKIyBDT05GSUdfUFBQIGlzIG5vdCBzZXQKIyBD T05GSUdfU0xJUCBpcyBub3Qgc2V0CgojCiMgVVNCIE5ldHdvcmsgQWRhcHRlcnMKIwojIENP TkZJR19VU0JfQ0FUQyBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9LQVdFVEggaXMgbm90IHNl dAojIENPTkZJR19VU0JfUEVHQVNVUyBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9SVEw4MTUw IGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX1JUTDgxNTIgaXMgbm90IHNldAojIENPTkZJR19V U0JfVVNCTkVUIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX0lQSEVUSCBpcyBub3Qgc2V0CiMg Q09ORklHX1dMQU4gaXMgbm90IHNldAoKIwojIEVuYWJsZSBXaU1BWCAoTmV0d29ya2luZyBv cHRpb25zKSB0byBzZWUgdGhlIFdpTUFYIGRyaXZlcnMKIwojIENPTkZJR19XQU4gaXMgbm90 IHNldApDT05GSUdfWEVOX05FVERFVl9GUk9OVEVORD15CkNPTkZJR19YRU5fTkVUREVWX0JB Q0tFTkQ9eQojIENPTkZJR19WTVhORVQzIGlzIG5vdCBzZXQKIyBDT05GSUdfSVNETiBpcyBu b3Qgc2V0CgojCiMgSW5wdXQgZGV2aWNlIHN1cHBvcnQKIwpDT05GSUdfSU5QVVQ9eQpDT05G SUdfSU5QVVRfRkZfTUVNTEVTUz15CkNPTkZJR19JTlBVVF9QT0xMREVWPXkKQ09ORklHX0lO UFVUX1NQQVJTRUtNQVA9eQojIENPTkZJR19JTlBVVF9NQVRSSVhLTUFQIGlzIG5vdCBzZXQK CiMKIyBVc2VybGFuZCBpbnRlcmZhY2VzCiMKQ09ORklHX0lOUFVUX01PVVNFREVWPXkKIyBD T05GSUdfSU5QVVRfTU9VU0VERVZfUFNBVVggaXMgbm90IHNldApDT05GSUdfSU5QVVRfTU9V U0VERVZfU0NSRUVOX1g9MTAyNApDT05GSUdfSU5QVVRfTU9VU0VERVZfU0NSRUVOX1k9NzY4 CiMgQ09ORklHX0lOUFVUX0pPWURFViBpcyBub3Qgc2V0CkNPTkZJR19JTlBVVF9FVkRFVj15 CiMgQ09ORklHX0lOUFVUX0VWQlVHIGlzIG5vdCBzZXQKCiMKIyBJbnB1dCBEZXZpY2UgRHJp dmVycwojCkNPTkZJR19JTlBVVF9LRVlCT0FSRD15CiMgQ09ORklHX0tFWUJPQVJEX0FEUDU1 ODggaXMgbm90IHNldAojIENPTkZJR19LRVlCT0FSRF9BRFA1NTg5IGlzIG5vdCBzZXQKQ09O RklHX0tFWUJPQVJEX0FUS0JEPXkKIyBDT05GSUdfS0VZQk9BUkRfUVQxMDcwIGlzIG5vdCBz ZXQKIyBDT05GSUdfS0VZQk9BUkRfUVQyMTYwIGlzIG5vdCBzZXQKIyBDT05GSUdfS0VZQk9B UkRfTEtLQkQgaXMgbm90IHNldAojIENPTkZJR19LRVlCT0FSRF9UQ0E2NDE2IGlzIG5vdCBz ZXQKIyBDT05GSUdfS0VZQk9BUkRfVENBODQxOCBpcyBub3Qgc2V0CiMgQ09ORklHX0tFWUJP QVJEX0xNODMyMyBpcyBub3Qgc2V0CiMgQ09ORklHX0tFWUJPQVJEX0xNODMzMyBpcyBub3Qg c2V0CiMgQ09ORklHX0tFWUJPQVJEX01BWDczNTkgaXMgbm90IHNldAojIENPTkZJR19LRVlC T0FSRF9NQ1MgaXMgbm90IHNldAojIENPTkZJR19LRVlCT0FSRF9NUFIxMjEgaXMgbm90IHNl dAojIENPTkZJR19LRVlCT0FSRF9ORVdUT04gaXMgbm90IHNldAojIENPTkZJR19LRVlCT0FS RF9PUEVOQ09SRVMgaXMgbm90IHNldAojIENPTkZJR19LRVlCT0FSRF9TVE9XQVdBWSBpcyBu b3Qgc2V0CiMgQ09ORklHX0tFWUJPQVJEX1NVTktCRCBpcyBub3Qgc2V0CiMgQ09ORklHX0tF WUJPQVJEX1hUS0JEIGlzIG5vdCBzZXQKQ09ORklHX0lOUFVUX01PVVNFPXkKQ09ORklHX01P VVNFX1BTMj15CkNPTkZJR19NT1VTRV9QUzJfQUxQUz15CkNPTkZJR19NT1VTRV9QUzJfTE9H SVBTMlBQPXkKQ09ORklHX01PVVNFX1BTMl9TWU5BUFRJQ1M9eQpDT05GSUdfTU9VU0VfUFMy X0NZUFJFU1M9eQpDT05GSUdfTU9VU0VfUFMyX0xJRkVCT09LPXkKQ09ORklHX01PVVNFX1BT Ml9UUkFDS1BPSU5UPXkKIyBDT05GSUdfTU9VU0VfUFMyX0VMQU5URUNIIGlzIG5vdCBzZXQK IyBDT05GSUdfTU9VU0VfUFMyX1NFTlRFTElDIGlzIG5vdCBzZXQKIyBDT05GSUdfTU9VU0Vf UFMyX1RPVUNIS0lUIGlzIG5vdCBzZXQKIyBDT05GSUdfTU9VU0VfU0VSSUFMIGlzIG5vdCBz ZXQKIyBDT05GSUdfTU9VU0VfQVBQTEVUT1VDSCBpcyBub3Qgc2V0CiMgQ09ORklHX01PVVNF X0JDTTU5NzQgaXMgbm90IHNldAojIENPTkZJR19NT1VTRV9DWUFQQSBpcyBub3Qgc2V0CiMg Q09ORklHX01PVVNFX1ZTWFhYQUEgaXMgbm90IHNldAojIENPTkZJR19NT1VTRV9TWU5BUFRJ Q1NfSTJDIGlzIG5vdCBzZXQKIyBDT05GSUdfTU9VU0VfU1lOQVBUSUNTX1VTQiBpcyBub3Qg c2V0CiMgQ09ORklHX0lOUFVUX0pPWVNUSUNLIGlzIG5vdCBzZXQKQ09ORklHX0lOUFVUX1RB QkxFVD15CiMgQ09ORklHX1RBQkxFVF9VU0JfQUNFQ0FEIGlzIG5vdCBzZXQKIyBDT05GSUdf VEFCTEVUX1VTQl9BSVBURUsgaXMgbm90IHNldAojIENPTkZJR19UQUJMRVRfVVNCX0dUQ08g aXMgbm90IHNldAojIENPTkZJR19UQUJMRVRfVVNCX0hBTldBTkcgaXMgbm90IHNldAojIENP TkZJR19UQUJMRVRfVVNCX0tCVEFCIGlzIG5vdCBzZXQKIyBDT05GSUdfVEFCTEVUX1VTQl9X QUNPTSBpcyBub3Qgc2V0CkNPTkZJR19JTlBVVF9UT1VDSFNDUkVFTj15CiMgQ09ORklHX1RP VUNIU0NSRUVOX0FENzg3OSBpcyBub3Qgc2V0CiMgQ09ORklHX1RPVUNIU0NSRUVOX0FUTUVM X01YVCBpcyBub3Qgc2V0CiMgQ09ORklHX1RPVUNIU0NSRUVOX0JVMjEwMTMgaXMgbm90IHNl dAojIENPTkZJR19UT1VDSFNDUkVFTl9DWVRUU1BfQ09SRSBpcyBub3Qgc2V0CiMgQ09ORklH X1RPVUNIU0NSRUVOX0NZVFRTUDRfQ09SRSBpcyBub3Qgc2V0CiMgQ09ORklHX1RPVUNIU0NS RUVOX0RZTkFQUk8gaXMgbm90IHNldAojIENPTkZJR19UT1VDSFNDUkVFTl9IQU1QU0hJUkUg aXMgbm90IHNldAojIENPTkZJR19UT1VDSFNDUkVFTl9FRVRJIGlzIG5vdCBzZXQKIyBDT05G SUdfVE9VQ0hTQ1JFRU5fRlVKSVRTVSBpcyBub3Qgc2V0CiMgQ09ORklHX1RPVUNIU0NSRUVO X0lMSTIxMFggaXMgbm90IHNldAojIENPTkZJR19UT1VDSFNDUkVFTl9HVU5aRSBpcyBub3Qg c2V0CiMgQ09ORklHX1RPVUNIU0NSRUVOX0VMTyBpcyBub3Qgc2V0CiMgQ09ORklHX1RPVUNI U0NSRUVOX1dBQ09NX1c4MDAxIGlzIG5vdCBzZXQKIyBDT05GSUdfVE9VQ0hTQ1JFRU5fV0FD T01fSTJDIGlzIG5vdCBzZXQKIyBDT05GSUdfVE9VQ0hTQ1JFRU5fTUFYMTE4MDEgaXMgbm90 IHNldAojIENPTkZJR19UT1VDSFNDUkVFTl9NQ1M1MDAwIGlzIG5vdCBzZXQKIyBDT05GSUdf VE9VQ0hTQ1JFRU5fTU1TMTE0IGlzIG5vdCBzZXQKIyBDT05GSUdfVE9VQ0hTQ1JFRU5fTVRP VUNIIGlzIG5vdCBzZXQKIyBDT05GSUdfVE9VQ0hTQ1JFRU5fSU5FWElPIGlzIG5vdCBzZXQK IyBDT05GSUdfVE9VQ0hTQ1JFRU5fTUs3MTIgaXMgbm90IHNldAojIENPTkZJR19UT1VDSFND UkVFTl9QRU5NT1VOVCBpcyBub3Qgc2V0CiMgQ09ORklHX1RPVUNIU0NSRUVOX0VEVF9GVDVY MDYgaXMgbm90IHNldAojIENPTkZJR19UT1VDSFNDUkVFTl9UT1VDSFJJR0hUIGlzIG5vdCBz ZXQKIyBDT05GSUdfVE9VQ0hTQ1JFRU5fVE9VQ0hXSU4gaXMgbm90IHNldAojIENPTkZJR19U T1VDSFNDUkVFTl9QSVhDSVIgaXMgbm90IHNldAojIENPTkZJR19UT1VDSFNDUkVFTl9VU0Jf Q09NUE9TSVRFIGlzIG5vdCBzZXQKIyBDT05GSUdfVE9VQ0hTQ1JFRU5fVE9VQ0hJVDIxMyBp cyBub3Qgc2V0CiMgQ09ORklHX1RPVUNIU0NSRUVOX1RTQ19TRVJJTyBpcyBub3Qgc2V0CiMg Q09ORklHX1RPVUNIU0NSRUVOX1RTQzIwMDcgaXMgbm90IHNldAojIENPTkZJR19UT1VDSFND UkVFTl9TVDEyMzIgaXMgbm90IHNldAojIENPTkZJR19UT1VDSFNDUkVFTl9TVVI0MCBpcyBu b3Qgc2V0CiMgQ09ORklHX1RPVUNIU0NSRUVOX1RQUzY1MDdYIGlzIG5vdCBzZXQKQ09ORklH X0lOUFVUX01JU0M9eQojIENPTkZJR19JTlBVVF9BRDcxNFggaXMgbm90IHNldAojIENPTkZJ R19JTlBVVF9CTUExNTAgaXMgbm90IHNldAojIENPTkZJR19JTlBVVF9QQ1NQS1IgaXMgbm90 IHNldAojIENPTkZJR19JTlBVVF9NTUE4NDUwIGlzIG5vdCBzZXQKIyBDT05GSUdfSU5QVVRf TVBVMzA1MCBpcyBub3Qgc2V0CiMgQ09ORklHX0lOUFVUX0FQQU5FTCBpcyBub3Qgc2V0CiMg Q09ORklHX0lOUFVUX0FUTEFTX0JUTlMgaXMgbm90IHNldAojIENPTkZJR19JTlBVVF9BVElf UkVNT1RFMiBpcyBub3Qgc2V0CiMgQ09ORklHX0lOUFVUX0tFWVNQQU5fUkVNT1RFIGlzIG5v dCBzZXQKIyBDT05GSUdfSU5QVVRfS1hUSjkgaXMgbm90IHNldAojIENPTkZJR19JTlBVVF9Q T1dFUk1BVEUgaXMgbm90IHNldAojIENPTkZJR19JTlBVVF9ZRUFMSU5LIGlzIG5vdCBzZXQK IyBDT05GSUdfSU5QVVRfQ00xMDkgaXMgbm90IHNldAojIENPTkZJR19JTlBVVF9VSU5QVVQg aXMgbm90IHNldAojIENPTkZJR19JTlBVVF9QQ0Y4NTc0IGlzIG5vdCBzZXQKIyBDT05GSUdf SU5QVVRfQURYTDM0WCBpcyBub3Qgc2V0CiMgQ09ORklHX0lOUFVUX0lNU19QQ1UgaXMgbm90 IHNldAojIENPTkZJR19JTlBVVF9DTUEzMDAwIGlzIG5vdCBzZXQKQ09ORklHX0lOUFVUX1hF Tl9LQkRERVZfRlJPTlRFTkQ9eQojIENPTkZJR19JTlBVVF9JREVBUEFEX1NMSURFQkFSIGlz IG5vdCBzZXQKCiMKIyBIYXJkd2FyZSBJL08gcG9ydHMKIwpDT05GSUdfU0VSSU89eQpDT05G SUdfU0VSSU9fSTgwNDI9eQpDT05GSUdfU0VSSU9fU0VSUE9SVD15CiMgQ09ORklHX1NFUklP X0NUODJDNzEwIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VSSU9fUENJUFMyIGlzIG5vdCBzZXQK Q09ORklHX1NFUklPX0xJQlBTMj15CiMgQ09ORklHX1NFUklPX1JBVyBpcyBub3Qgc2V0CiMg Q09ORklHX1NFUklPX0FMVEVSQV9QUzIgaXMgbm90IHNldAojIENPTkZJR19TRVJJT19QUzJN VUxUIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VSSU9fQVJDX1BTMiBpcyBub3Qgc2V0CiMgQ09O RklHX0dBTUVQT1JUIGlzIG5vdCBzZXQKCiMKIyBDaGFyYWN0ZXIgZGV2aWNlcwojCkNPTkZJ R19UVFk9eQpDT05GSUdfVlQ9eQpDT05GSUdfQ09OU09MRV9UUkFOU0xBVElPTlM9eQpDT05G SUdfVlRfQ09OU09MRT15CkNPTkZJR19WVF9DT05TT0xFX1NMRUVQPXkKQ09ORklHX0hXX0NP TlNPTEU9eQpDT05GSUdfVlRfSFdfQ09OU09MRV9CSU5ESU5HPXkKQ09ORklHX1VOSVg5OF9Q VFlTPXkKIyBDT05GSUdfREVWUFRTX01VTFRJUExFX0lOU1RBTkNFUyBpcyBub3Qgc2V0CiMg Q09ORklHX0xFR0FDWV9QVFlTIGlzIG5vdCBzZXQKQ09ORklHX1NFUklBTF9OT05TVEFOREFS RD15CiMgQ09ORklHX1JPQ0tFVFBPUlQgaXMgbm90IHNldAojIENPTkZJR19DWUNMQURFUyBp cyBub3Qgc2V0CiMgQ09ORklHX01PWEFfSU5URUxMSU8gaXMgbm90IHNldAojIENPTkZJR19N T1hBX1NNQVJUSU8gaXMgbm90IHNldAojIENPTkZJR19TWU5DTElOSyBpcyBub3Qgc2V0CiMg Q09ORklHX1NZTkNMSU5LTVAgaXMgbm90IHNldAojIENPTkZJR19TWU5DTElOS19HVCBpcyBu b3Qgc2V0CiMgQ09ORklHX05PWk9NSSBpcyBub3Qgc2V0CiMgQ09ORklHX0lTSSBpcyBub3Qg c2V0CiMgQ09ORklHX05fSERMQyBpcyBub3Qgc2V0CiMgQ09ORklHX05fR1NNIGlzIG5vdCBz ZXQKIyBDT05GSUdfVFJBQ0VfU0lOSyBpcyBub3Qgc2V0CiMgQ09ORklHX0RFVktNRU0gaXMg bm90IHNldAoKIwojIFNlcmlhbCBkcml2ZXJzCiMKQ09ORklHX1NFUklBTF84MjUwPXkKQ09O RklHX1NFUklBTF84MjUwX0RFUFJFQ0FURURfT1BUSU9OUz15CkNPTkZJR19TRVJJQUxfODI1 MF9QTlA9eQpDT05GSUdfU0VSSUFMXzgyNTBfQ09OU09MRT15CkNPTkZJR19GSVhfRUFSTFlD T05fTUVNPXkKQ09ORklHX1NFUklBTF84MjUwX1BDST15CkNPTkZJR19TRVJJQUxfODI1MF9O Ul9VQVJUUz0zMgpDT05GSUdfU0VSSUFMXzgyNTBfUlVOVElNRV9VQVJUUz00CkNPTkZJR19T RVJJQUxfODI1MF9FWFRFTkRFRD15CkNPTkZJR19TRVJJQUxfODI1MF9NQU5ZX1BPUlRTPXkK Q09ORklHX1NFUklBTF84MjUwX1NIQVJFX0lSUT15CkNPTkZJR19TRVJJQUxfODI1MF9ERVRF Q1RfSVJRPXkKQ09ORklHX1NFUklBTF84MjUwX1JTQT15CiMgQ09ORklHX1NFUklBTF84MjUw X0RXIGlzIG5vdCBzZXQKCiMKIyBOb24tODI1MCBzZXJpYWwgcG9ydCBzdXBwb3J0CiMKIyBD T05GSUdfU0VSSUFMX01GRF9IU1UgaXMgbm90IHNldApDT05GSUdfU0VSSUFMX0NPUkU9eQpD T05GSUdfU0VSSUFMX0NPUkVfQ09OU09MRT15CiMgQ09ORklHX1NFUklBTF9KU00gaXMgbm90 IHNldAojIENPTkZJR19TRVJJQUxfU0NDTlhQIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VSSUFM X1RJTUJFUkRBTEUgaXMgbm90IHNldAojIENPTkZJR19TRVJJQUxfQUxURVJBX0pUQUdVQVJU IGlzIG5vdCBzZXQKIyBDT05GSUdfU0VSSUFMX0FMVEVSQV9VQVJUIGlzIG5vdCBzZXQKIyBD T05GSUdfU0VSSUFMX1BDSF9VQVJUIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VSSUFMX0FSQyBp cyBub3Qgc2V0CiMgQ09ORklHX1NFUklBTF9SUDIgaXMgbm90IHNldAojIENPTkZJR19TRVJJ QUxfRlNMX0xQVUFSVCBpcyBub3Qgc2V0CkNPTkZJR19IVkNfRFJJVkVSPXkKQ09ORklHX0hW Q19JUlE9eQpDT05GSUdfSFZDX1hFTj15CkNPTkZJR19IVkNfWEVOX0ZST05URU5EPXkKIyBD T05GSUdfSVBNSV9IQU5ETEVSIGlzIG5vdCBzZXQKQ09ORklHX0hXX1JBTkRPTT15CkNPTkZJ R19IV19SQU5ET01fVElNRVJJT01FTT15CkNPTkZJR19IV19SQU5ET01fSU5URUw9eQpDT05G SUdfSFdfUkFORE9NX0FNRD15CkNPTkZJR19IV19SQU5ET01fVklBPXkKIyBDT05GSUdfTlZS QU0gaXMgbm90IHNldAojIENPTkZJR19SMzk2NCBpcyBub3Qgc2V0CiMgQ09ORklHX0FQUExJ Q09NIGlzIG5vdCBzZXQKIyBDT05GSUdfTVdBVkUgaXMgbm90IHNldAojIENPTkZJR19SQVdf RFJJVkVSIGlzIG5vdCBzZXQKQ09ORklHX0hQRVQ9eQojIENPTkZJR19IUEVUX01NQVAgaXMg bm90IHNldApDT05GSUdfSEFOR0NIRUNLX1RJTUVSPXkKIyBDT05GSUdfVENHX1RQTSBpcyBu b3Qgc2V0CiMgQ09ORklHX1RFTENMT0NLIGlzIG5vdCBzZXQKQ09ORklHX0RFVlBPUlQ9eQpD T05GSUdfSTJDPXkKQ09ORklHX0kyQ19CT0FSRElORk89eQpDT05GSUdfSTJDX0NPTVBBVD15 CiMgQ09ORklHX0kyQ19DSEFSREVWIGlzIG5vdCBzZXQKQ09ORklHX0kyQ19NVVg9eQoKIwoj IE11bHRpcGxleGVyIEkyQyBDaGlwIHN1cHBvcnQKIwojIENPTkZJR19JMkNfTVVYX1BDQTk1 NDEgaXMgbm90IHNldAojIENPTkZJR19JMkNfTVVYX1BDQTk1NHggaXMgbm90IHNldApDT05G SUdfSTJDX0hFTFBFUl9BVVRPPXkKQ09ORklHX0kyQ19BTEdPQklUPXkKCiMKIyBJMkMgSGFy ZHdhcmUgQnVzIHN1cHBvcnQKIwoKIwojIFBDIFNNQnVzIGhvc3QgY29udHJvbGxlciBkcml2 ZXJzCiMKIyBDT05GSUdfSTJDX0FMSTE1MzUgaXMgbm90IHNldAojIENPTkZJR19JMkNfQUxJ MTU2MyBpcyBub3Qgc2V0CiMgQ09ORklHX0kyQ19BTEkxNVgzIGlzIG5vdCBzZXQKQ09ORklH X0kyQ19BTUQ3NTY9eQojIENPTkZJR19JMkNfQU1ENzU2X1M0ODgyIGlzIG5vdCBzZXQKQ09O RklHX0kyQ19BTUQ4MTExPXkKQ09ORklHX0kyQ19JODAxPXkKQ09ORklHX0kyQ19JU0NIPXkK IyBDT05GSUdfSTJDX0lTTVQgaXMgbm90IHNldApDT05GSUdfSTJDX1BJSVg0PXkKIyBDT05G SUdfSTJDX05GT1JDRTIgaXMgbm90IHNldAojIENPTkZJR19JMkNfU0lTNTU5NSBpcyBub3Qg c2V0CiMgQ09ORklHX0kyQ19TSVM2MzAgaXMgbm90IHNldAojIENPTkZJR19JMkNfU0lTOTZY IGlzIG5vdCBzZXQKIyBDT05GSUdfSTJDX1ZJQSBpcyBub3Qgc2V0CiMgQ09ORklHX0kyQ19W SUFQUk8gaXMgbm90IHNldAoKIwojIEFDUEkgZHJpdmVycwojCkNPTkZJR19JMkNfU0NNST15 CgojCiMgSTJDIHN5c3RlbSBidXMgZHJpdmVycyAobW9zdGx5IGVtYmVkZGVkIC8gc3lzdGVt LW9uLWNoaXApCiMKIyBDT05GSUdfSTJDX0RFU0lHTldBUkVfUENJIGlzIG5vdCBzZXQKIyBD T05GSUdfSTJDX0VHMjBUIGlzIG5vdCBzZXQKIyBDT05GSUdfSTJDX09DT1JFUyBpcyBub3Qg c2V0CiMgQ09ORklHX0kyQ19QQ0FfUExBVEZPUk0gaXMgbm90IHNldAojIENPTkZJR19JMkNf UFhBX1BDSSBpcyBub3Qgc2V0CiMgQ09ORklHX0kyQ19TSU1URUMgaXMgbm90IHNldAojIENP TkZJR19JMkNfWElMSU5YIGlzIG5vdCBzZXQKCiMKIyBFeHRlcm5hbCBJMkMvU01CdXMgYWRh cHRlciBkcml2ZXJzCiMKIyBDT05GSUdfSTJDX0RJT0xBTl9VMkMgaXMgbm90IHNldAojIENP TkZJR19JMkNfUEFSUE9SVF9MSUdIVCBpcyBub3Qgc2V0CiMgQ09ORklHX0kyQ19UQU9TX0VW TSBpcyBub3Qgc2V0CiMgQ09ORklHX0kyQ19USU5ZX1VTQiBpcyBub3Qgc2V0CgojCiMgT3Ro ZXIgSTJDL1NNQnVzIGJ1cyBkcml2ZXJzCiMKIyBDT05GSUdfSTJDX1NUVUIgaXMgbm90IHNl dAojIENPTkZJR19JMkNfREVCVUdfQ09SRSBpcyBub3Qgc2V0CiMgQ09ORklHX0kyQ19ERUJV R19BTEdPIGlzIG5vdCBzZXQKIyBDT05GSUdfSTJDX0RFQlVHX0JVUyBpcyBub3Qgc2V0CiMg Q09ORklHX1NQSSBpcyBub3Qgc2V0CiMgQ09ORklHX0hTSSBpcyBub3Qgc2V0CgojCiMgUFBT IHN1cHBvcnQKIwpDT05GSUdfUFBTPXkKIyBDT05GSUdfUFBTX0RFQlVHIGlzIG5vdCBzZXQK CiMKIyBQUFMgY2xpZW50cyBzdXBwb3J0CiMKIyBDT05GSUdfUFBTX0NMSUVOVF9LVElNRVIg aXMgbm90IHNldAojIENPTkZJR19QUFNfQ0xJRU5UX0xESVNDIGlzIG5vdCBzZXQKIyBDT05G SUdfUFBTX0NMSUVOVF9HUElPIGlzIG5vdCBzZXQKCiMKIyBQUFMgZ2VuZXJhdG9ycyBzdXBw b3J0CiMKCiMKIyBQVFAgY2xvY2sgc3VwcG9ydAojCkNPTkZJR19QVFBfMTU4OF9DTE9DSz15 CgojCiMgRW5hYmxlIFBIWUxJQiBhbmQgTkVUV09SS19QSFlfVElNRVNUQU1QSU5HIHRvIHNl ZSB0aGUgYWRkaXRpb25hbCBjbG9ja3MuCiMKIyBDT05GSUdfUFRQXzE1ODhfQ0xPQ0tfUENI IGlzIG5vdCBzZXQKQ09ORklHX0FSQ0hfV0FOVF9PUFRJT05BTF9HUElPTElCPXkKIyBDT05G SUdfR1BJT0xJQiBpcyBub3Qgc2V0CiMgQ09ORklHX1cxIGlzIG5vdCBzZXQKQ09ORklHX1BP V0VSX1NVUFBMWT15CiMgQ09ORklHX1BPV0VSX1NVUFBMWV9ERUJVRyBpcyBub3Qgc2V0CiMg Q09ORklHX1BEQV9QT1dFUiBpcyBub3Qgc2V0CiMgQ09ORklHX1RFU1RfUE9XRVIgaXMgbm90 IHNldAojIENPTkZJR19CQVRURVJZX0RTMjc4MCBpcyBub3Qgc2V0CiMgQ09ORklHX0JBVFRF UllfRFMyNzgxIGlzIG5vdCBzZXQKIyBDT05GSUdfQkFUVEVSWV9EUzI3ODIgaXMgbm90IHNl dAojIENPTkZJR19CQVRURVJZX1NCUyBpcyBub3Qgc2V0CiMgQ09ORklHX0JBVFRFUllfQlEy N3gwMCBpcyBub3Qgc2V0CiMgQ09ORklHX0JBVFRFUllfTUFYMTcwNDAgaXMgbm90IHNldAoj IENPTkZJR19CQVRURVJZX01BWDE3MDQyIGlzIG5vdCBzZXQKIyBDT05GSUdfQ0hBUkdFUl9N QVg4OTAzIGlzIG5vdCBzZXQKIyBDT05GSUdfQ0hBUkdFUl9MUDg3MjcgaXMgbm90IHNldAoj IENPTkZJR19DSEFSR0VSX0JRMjQxNVggaXMgbm90IHNldAojIENPTkZJR19DSEFSR0VSX1NN QjM0NyBpcyBub3Qgc2V0CiMgQ09ORklHX1BPV0VSX1JFU0VUIGlzIG5vdCBzZXQKIyBDT05G SUdfUE9XRVJfQVZTIGlzIG5vdCBzZXQKQ09ORklHX0hXTU9OPXkKQ09ORklHX0hXTU9OX1ZJ RD15CiMgQ09ORklHX0hXTU9OX0RFQlVHX0NISVAgaXMgbm90IHNldAoKIwojIE5hdGl2ZSBk cml2ZXJzCiMKIyBDT05GSUdfU0VOU09SU19BQklUVUdVUlUgaXMgbm90IHNldAojIENPTkZJ R19TRU5TT1JTX0FCSVRVR1VSVTMgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX0FENzQx NCBpcyBub3Qgc2V0CiMgQ09ORklHX1NFTlNPUlNfQUQ3NDE4IGlzIG5vdCBzZXQKIyBDT05G SUdfU0VOU09SU19BRE0xMDIxIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19BRE0xMDI1 IGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19BRE0xMDI2IGlzIG5vdCBzZXQKIyBDT05G SUdfU0VOU09SU19BRE0xMDI5IGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19BRE0xMDMx IGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19BRE05MjQwIGlzIG5vdCBzZXQKIyBDT05G SUdfU0VOU09SU19BRFQ3NDEwIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19BRFQ3NDEx IGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19BRFQ3NDYyIGlzIG5vdCBzZXQKIyBDT05G SUdfU0VOU09SU19BRFQ3NDcwIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19BRFQ3NDc1 IGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19BU0M3NjIxIGlzIG5vdCBzZXQKIyBDT05G SUdfU0VOU09SU19LOFRFTVAgaXMgbm90IHNldApDT05GSUdfU0VOU09SU19LMTBURU1QPXkK Q09ORklHX1NFTlNPUlNfRkFNMTVIX1BPV0VSPXkKIyBDT05GSUdfU0VOU09SU19BU0IxMDAg aXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX0FUWFAxIGlzIG5vdCBzZXQKIyBDT05GSUdf U0VOU09SU19EUzYyMCBpcyBub3Qgc2V0CiMgQ09ORklHX1NFTlNPUlNfRFMxNjIxIGlzIG5v dCBzZXQKIyBDT05GSUdfU0VOU09SU19JNUtfQU1CIGlzIG5vdCBzZXQKQ09ORklHX1NFTlNP UlNfRjcxODA1Rj15CkNPTkZJR19TRU5TT1JTX0Y3MTg4MkZHPXkKQ09ORklHX1NFTlNPUlNf Rjc1Mzc1Uz15CiMgQ09ORklHX1NFTlNPUlNfRlNDSE1EIGlzIG5vdCBzZXQKIyBDT05GSUdf U0VOU09SU19HNzYwQSBpcyBub3Qgc2V0CiMgQ09ORklHX1NFTlNPUlNfRzc2MiBpcyBub3Qg c2V0CiMgQ09ORklHX1NFTlNPUlNfR0w1MThTTSBpcyBub3Qgc2V0CiMgQ09ORklHX1NFTlNP UlNfR0w1MjBTTSBpcyBub3Qgc2V0CiMgQ09ORklHX1NFTlNPUlNfSElINjEzMCBpcyBub3Qg c2V0CiMgQ09ORklHX1NFTlNPUlNfSFRVMjEgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JT X0NPUkVURU1QIGlzIG5vdCBzZXQKQ09ORklHX1NFTlNPUlNfSVQ4Nz15CkNPTkZJR19TRU5T T1JTX0pDNDI9eQojIENPTkZJR19TRU5TT1JTX0xJTkVBR0UgaXMgbm90IHNldAojIENPTkZJ R19TRU5TT1JTX0xNNjMgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX0xNNzMgaXMgbm90 IHNldAojIENPTkZJR19TRU5TT1JTX0xNNzUgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JT X0xNNzcgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX0xNNzggaXMgbm90IHNldAojIENP TkZJR19TRU5TT1JTX0xNODAgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX0xNODMgaXMg bm90IHNldAojIENPTkZJR19TRU5TT1JTX0xNODUgaXMgbm90IHNldAojIENPTkZJR19TRU5T T1JTX0xNODcgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX0xNOTAgaXMgbm90IHNldAoj IENPTkZJR19TRU5TT1JTX0xNOTIgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX0xNOTMg aXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX0xUQzQxNTEgaXMgbm90IHNldAojIENPTkZJ R19TRU5TT1JTX0xUQzQyMTUgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX0xUQzQyNDUg aXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX0xUQzQyNjEgaXMgbm90IHNldAojIENPTkZJ R19TRU5TT1JTX0xNOTUyMzQgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX0xNOTUyNDEg aXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX0xNOTUyNDUgaXMgbm90IHNldAojIENPTkZJ R19TRU5TT1JTX01BWDE2MDY1IGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19NQVgxNjE5 IGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19NQVgxNjY4IGlzIG5vdCBzZXQKIyBDT05G SUdfU0VOU09SU19NQVgxOTcgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX01BWDY2Mzkg aXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX01BWDY2NDIgaXMgbm90IHNldAojIENPTkZJ R19TRU5TT1JTX01BWDY2NTAgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX01BWDY2OTcg aXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX01DUDMwMjEgaXMgbm90IHNldAojIENPTkZJ R19TRU5TT1JTX05DVDY3NzUgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX05UQ19USEVS TUlTVE9SIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19QQzg3MzYwIGlzIG5vdCBzZXQK IyBDT05GSUdfU0VOU09SU19QQzg3NDI3IGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19Q Q0Y4NTkxIGlzIG5vdCBzZXQKIyBDT05GSUdfUE1CVVMgaXMgbm90IHNldAojIENPTkZJR19T RU5TT1JTX1NIVDIxIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19TSVM1NTk1IGlzIG5v dCBzZXQKIyBDT05GSUdfU0VOU09SU19TTU02NjUgaXMgbm90IHNldAojIENPTkZJR19TRU5T T1JTX0RNRTE3MzcgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX0VNQzE0MDMgaXMgbm90 IHNldAojIENPTkZJR19TRU5TT1JTX0VNQzIxMDMgaXMgbm90IHNldAojIENPTkZJR19TRU5T T1JTX0VNQzZXMjAxIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19TTVNDNDdNMSBpcyBu b3Qgc2V0CiMgQ09ORklHX1NFTlNPUlNfU01TQzQ3TTE5MiBpcyBub3Qgc2V0CiMgQ09ORklH X1NFTlNPUlNfU01TQzQ3QjM5NyBpcyBub3Qgc2V0CiMgQ09ORklHX1NFTlNPUlNfU0NINTZY WF9DT01NT04gaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX1NDSDU2MjcgaXMgbm90IHNl dAojIENPTkZJR19TRU5TT1JTX1NDSDU2MzYgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JT X0FEUzEwMTUgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX0FEUzc4MjggaXMgbm90IHNl dAojIENPTkZJR19TRU5TT1JTX0FNQzY4MjEgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JT X0lOQTIwOSBpcyBub3Qgc2V0CiMgQ09ORklHX1NFTlNPUlNfSU5BMlhYIGlzIG5vdCBzZXQK IyBDT05GSUdfU0VOU09SU19USE1DNTAgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX1RN UDEwMiBpcyBub3Qgc2V0CiMgQ09ORklHX1NFTlNPUlNfVE1QNDAxIGlzIG5vdCBzZXQKIyBD T05GSUdfU0VOU09SU19UTVA0MjEgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX1ZJQV9D UFVURU1QIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19WSUE2ODZBIGlzIG5vdCBzZXQK IyBDT05GSUdfU0VOU09SU19WVDEyMTEgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX1ZU ODIzMSBpcyBub3Qgc2V0CiMgQ09ORklHX1NFTlNPUlNfVzgzNzgxRCBpcyBub3Qgc2V0CiMg Q09ORklHX1NFTlNPUlNfVzgzNzkxRCBpcyBub3Qgc2V0CiMgQ09ORklHX1NFTlNPUlNfVzgz NzkyRCBpcyBub3Qgc2V0CiMgQ09ORklHX1NFTlNPUlNfVzgzNzkzIGlzIG5vdCBzZXQKIyBD T05GSUdfU0VOU09SU19XODM3OTUgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX1c4M0w3 ODVUUyBpcyBub3Qgc2V0CiMgQ09ORklHX1NFTlNPUlNfVzgzTDc4Nk5HIGlzIG5vdCBzZXQK IyBDT05GSUdfU0VOU09SU19XODM2MjdIRiBpcyBub3Qgc2V0CiMgQ09ORklHX1NFTlNPUlNf VzgzNjI3RUhGIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19BUFBMRVNNQyBpcyBub3Qg c2V0CgojCiMgQUNQSSBkcml2ZXJzCiMKQ09ORklHX1NFTlNPUlNfQUNQSV9QT1dFUj15CiMg Q09ORklHX1NFTlNPUlNfQVRLMDExMCBpcyBub3Qgc2V0CkNPTkZJR19USEVSTUFMPXkKQ09O RklHX1RIRVJNQUxfSFdNT049eQpDT05GSUdfVEhFUk1BTF9ERUZBVUxUX0dPVl9TVEVQX1dJ U0U9eQojIENPTkZJR19USEVSTUFMX0RFRkFVTFRfR09WX0ZBSVJfU0hBUkUgaXMgbm90IHNl dAojIENPTkZJR19USEVSTUFMX0RFRkFVTFRfR09WX1VTRVJfU1BBQ0UgaXMgbm90IHNldAoj IENPTkZJR19USEVSTUFMX0dPVl9GQUlSX1NIQVJFIGlzIG5vdCBzZXQKQ09ORklHX1RIRVJN QUxfR09WX1NURVBfV0lTRT15CiMgQ09ORklHX1RIRVJNQUxfR09WX1VTRVJfU1BBQ0UgaXMg bm90IHNldAojIENPTkZJR19DUFVfVEhFUk1BTCBpcyBub3Qgc2V0CiMgQ09ORklHX1RIRVJN QUxfRU1VTEFUSU9OIGlzIG5vdCBzZXQKIyBDT05GSUdfSU5URUxfUE9XRVJDTEFNUCBpcyBu b3Qgc2V0CiMgQ09ORklHX1g4Nl9QS0dfVEVNUF9USEVSTUFMIGlzIG5vdCBzZXQKCiMKIyBU ZXhhcyBJbnN0cnVtZW50cyB0aGVybWFsIGRyaXZlcnMKIwpDT05GSUdfV0FUQ0hET0c9eQpD T05GSUdfV0FUQ0hET0dfQ09SRT15CiMgQ09ORklHX1dBVENIRE9HX05PV0FZT1VUIGlzIG5v dCBzZXQKCiMKIyBXYXRjaGRvZyBEZXZpY2UgRHJpdmVycwojCiMgQ09ORklHX1NPRlRfV0FU Q0hET0cgaXMgbm90IHNldAojIENPTkZJR19BQ1FVSVJFX1dEVCBpcyBub3Qgc2V0CiMgQ09O RklHX0FEVkFOVEVDSF9XRFQgaXMgbm90IHNldAojIENPTkZJR19BTElNMTUzNV9XRFQgaXMg bm90IHNldAojIENPTkZJR19BTElNNzEwMV9XRFQgaXMgbm90IHNldAojIENPTkZJR19GNzE4 MDhFX1dEVCBpcyBub3Qgc2V0CkNPTkZJR19TUDUxMDBfVENPPXkKIyBDT05GSUdfU0M1MjBf V0RUIGlzIG5vdCBzZXQKIyBDT05GSUdfU0JDX0ZJVFBDMl9XQVRDSERPRyBpcyBub3Qgc2V0 CiMgQ09ORklHX0VVUk9URUNIX1dEVCBpcyBub3Qgc2V0CiMgQ09ORklHX0lCNzAwX1dEVCBp cyBub3Qgc2V0CiMgQ09ORklHX0lCTUFTUiBpcyBub3Qgc2V0CiMgQ09ORklHX1dBRkVSX1dE VCBpcyBub3Qgc2V0CiMgQ09ORklHX0k2MzAwRVNCX1dEVCBpcyBub3Qgc2V0CiMgQ09ORklH X0lFNlhYX1dEVCBpcyBub3Qgc2V0CiMgQ09ORklHX0lUQ09fV0RUIGlzIG5vdCBzZXQKIyBD T05GSUdfSVQ4NzEyRl9XRFQgaXMgbm90IHNldAojIENPTkZJR19JVDg3X1dEVCBpcyBub3Qg c2V0CiMgQ09ORklHX0hQX1dBVENIRE9HIGlzIG5vdCBzZXQKIyBDT05GSUdfU0MxMjAwX1dE VCBpcyBub3Qgc2V0CiMgQ09ORklHX1BDODc0MTNfV0RUIGlzIG5vdCBzZXQKIyBDT05GSUdf TlZfVENPIGlzIG5vdCBzZXQKIyBDT05GSUdfNjBYWF9XRFQgaXMgbm90IHNldAojIENPTkZJ R19TQkM4MzYwX1dEVCBpcyBub3Qgc2V0CiMgQ09ORklHX0NQVTVfV0RUIGlzIG5vdCBzZXQK IyBDT05GSUdfU01TQ19TQ0gzMTFYX1dEVCBpcyBub3Qgc2V0CiMgQ09ORklHX1NNU0MzN0I3 ODdfV0RUIGlzIG5vdCBzZXQKIyBDT05GSUdfVklBX1dEVCBpcyBub3Qgc2V0CiMgQ09ORklH X1c4MzYyN0hGX1dEVCBpcyBub3Qgc2V0CiMgQ09ORklHX1c4MzY5N0hGX1dEVCBpcyBub3Qg c2V0CiMgQ09ORklHX1c4MzY5N1VHX1dEVCBpcyBub3Qgc2V0CiMgQ09ORklHX1c4Mzg3N0Zf V0RUIGlzIG5vdCBzZXQKIyBDT05GSUdfVzgzOTc3Rl9XRFQgaXMgbm90IHNldAojIENPTkZJ R19NQUNIWl9XRFQgaXMgbm90IHNldAojIENPTkZJR19TQkNfRVBYX0MzX1dBVENIRE9HIGlz IG5vdCBzZXQKQ09ORklHX1hFTl9XRFQ9eQoKIwojIFBDSS1iYXNlZCBXYXRjaGRvZyBDYXJk cwojCiMgQ09ORklHX1BDSVBDV0FUQ0hET0cgaXMgbm90IHNldAojIENPTkZJR19XRFRQQ0kg aXMgbm90IHNldAoKIwojIFVTQi1iYXNlZCBXYXRjaGRvZyBDYXJkcwojCiMgQ09ORklHX1VT QlBDV0FUQ0hET0cgaXMgbm90IHNldApDT05GSUdfU1NCX1BPU1NJQkxFPXkKCiMKIyBTb25p Y3MgU2lsaWNvbiBCYWNrcGxhbmUKIwojIENPTkZJR19TU0IgaXMgbm90IHNldApDT05GSUdf QkNNQV9QT1NTSUJMRT15CgojCiMgQnJvYWRjb20gc3BlY2lmaWMgQU1CQQojCiMgQ09ORklH X0JDTUEgaXMgbm90IHNldAoKIwojIE11bHRpZnVuY3Rpb24gZGV2aWNlIGRyaXZlcnMKIwpD T05GSUdfTUZEX0NPUkU9eQojIENPTkZJR19NRkRfQ1M1NTM1IGlzIG5vdCBzZXQKIyBDT05G SUdfTUZEX0FTMzcxMSBpcyBub3Qgc2V0CiMgQ09ORklHX1BNSUNfQURQNTUyMCBpcyBub3Qg c2V0CiMgQ09ORklHX01GRF9DUk9TX0VDIGlzIG5vdCBzZXQKIyBDT05GSUdfUE1JQ19EQTkw M1ggaXMgbm90IHNldAojIENPTkZJR19NRkRfREE5MDUyX0kyQyBpcyBub3Qgc2V0CiMgQ09O RklHX01GRF9EQTkwNTUgaXMgbm90IHNldAojIENPTkZJR19NRkRfREE5MDYzIGlzIG5vdCBz ZXQKIyBDT05GSUdfTUZEX01DMTNYWFhfSTJDIGlzIG5vdCBzZXQKIyBDT05GSUdfSFRDX1BB U0lDMyBpcyBub3Qgc2V0CiMgQ09ORklHX0xQQ19JQ0ggaXMgbm90IHNldApDT05GSUdfTFBD X1NDSD15CiMgQ09ORklHX01GRF9KQU5aX0NNT0RJTyBpcyBub3Qgc2V0CiMgQ09ORklHX01G RF9LRU1QTEQgaXMgbm90IHNldAojIENPTkZJR19NRkRfODhQTTgwMCBpcyBub3Qgc2V0CiMg Q09ORklHX01GRF84OFBNODA1IGlzIG5vdCBzZXQKIyBDT05GSUdfTUZEXzg4UE04NjBYIGlz IG5vdCBzZXQKIyBDT05GSUdfTUZEX01BWDc3Njg2IGlzIG5vdCBzZXQKIyBDT05GSUdfTUZE X01BWDc3NjkzIGlzIG5vdCBzZXQKIyBDT05GSUdfTUZEX01BWDg5MDcgaXMgbm90IHNldAoj IENPTkZJR19NRkRfTUFYODkyNSBpcyBub3Qgc2V0CiMgQ09ORklHX01GRF9NQVg4OTk3IGlz IG5vdCBzZXQKIyBDT05GSUdfTUZEX01BWDg5OTggaXMgbm90IHNldAojIENPTkZJR19NRkRf VklQRVJCT0FSRCBpcyBub3Qgc2V0CiMgQ09ORklHX01GRF9SRVRVIGlzIG5vdCBzZXQKIyBD T05GSUdfTUZEX1BDRjUwNjMzIGlzIG5vdCBzZXQKIyBDT05GSUdfTUZEX1JEQzMyMVggaXMg bm90IHNldAojIENPTkZJR19NRkRfUlRTWF9QQ0kgaXMgbm90IHNldAojIENPTkZJR19NRkRf UkM1VDU4MyBpcyBub3Qgc2V0CiMgQ09ORklHX01GRF9TRUNfQ09SRSBpcyBub3Qgc2V0CiMg Q09ORklHX01GRF9TSTQ3NlhfQ09SRSBpcyBub3Qgc2V0CiMgQ09ORklHX01GRF9TTTUwMSBp cyBub3Qgc2V0CiMgQ09ORklHX01GRF9TTVNDIGlzIG5vdCBzZXQKIyBDT05GSUdfQUJYNTAw X0NPUkUgaXMgbm90IHNldAojIENPTkZJR19NRkRfU1RNUEUgaXMgbm90IHNldAojIENPTkZJ R19NRkRfU1lTQ09OIGlzIG5vdCBzZXQKIyBDT05GSUdfTUZEX1RJX0FNMzM1WF9UU0NBREMg aXMgbm90IHNldAojIENPTkZJR19NRkRfTFA4Nzg4IGlzIG5vdCBzZXQKIyBDT05GSUdfTUZE X1BBTE1BUyBpcyBub3Qgc2V0CiMgQ09ORklHX1RQUzYxMDVYIGlzIG5vdCBzZXQKIyBDT05G SUdfVFBTNjUwN1ggaXMgbm90IHNldAojIENPTkZJR19NRkRfVFBTNjUwOTAgaXMgbm90IHNl dAojIENPTkZJR19NRkRfVFBTNjUyMTcgaXMgbm90IHNldAojIENPTkZJR19NRkRfVFBTNjU4 NlggaXMgbm90IHNldAojIENPTkZJR19NRkRfVFBTODAwMzEgaXMgbm90IHNldAojIENPTkZJ R19UV0w0MDMwX0NPUkUgaXMgbm90IHNldAojIENPTkZJR19UV0w2MDQwX0NPUkUgaXMgbm90 IHNldAojIENPTkZJR19NRkRfV0wxMjczX0NPUkUgaXMgbm90IHNldAojIENPTkZJR19NRkRf TE0zNTMzIGlzIG5vdCBzZXQKIyBDT05GSUdfTUZEX1RDMzU4OVggaXMgbm90IHNldAojIENP TkZJR19NRkRfVE1JTyBpcyBub3Qgc2V0CiMgQ09ORklHX01GRF9WWDg1NSBpcyBub3Qgc2V0 CiMgQ09ORklHX01GRF9BUklaT05BX0kyQyBpcyBub3Qgc2V0CiMgQ09ORklHX01GRF9XTTg0 MDAgaXMgbm90IHNldAojIENPTkZJR19NRkRfV004MzFYX0kyQyBpcyBub3Qgc2V0CiMgQ09O RklHX01GRF9XTTgzNTBfSTJDIGlzIG5vdCBzZXQKIyBDT05GSUdfTUZEX1dNODk5NCBpcyBu b3Qgc2V0CiMgQ09ORklHX1JFR1VMQVRPUiBpcyBub3Qgc2V0CkNPTkZJR19NRURJQV9TVVBQ T1JUPXkKCiMKIyBNdWx0aW1lZGlhIGNvcmUgc3VwcG9ydAojCkNPTkZJR19NRURJQV9DQU1F UkFfU1VQUE9SVD15CkNPTkZJR19NRURJQV9BTkFMT0dfVFZfU1VQUE9SVD15CkNPTkZJR19N RURJQV9ESUdJVEFMX1RWX1NVUFBPUlQ9eQpDT05GSUdfTUVESUFfUkFESU9fU1VQUE9SVD15 CkNPTkZJR19NRURJQV9SQ19TVVBQT1JUPXkKIyBDT05GSUdfTUVESUFfQ09OVFJPTExFUiBp cyBub3Qgc2V0CkNPTkZJR19WSURFT19ERVY9eQpDT05GSUdfVklERU9fVjRMMj15CkNPTkZJ R19WSURFT19BRFZfREVCVUc9eQojIENPTkZJR19WSURFT19GSVhFRF9NSU5PUl9SQU5HRVMg aXMgbm90IHNldApDT05GSUdfVklERU9fVFVORVI9eQpDT05GSUdfVklERU9CVUZfR0VOPXkK Q09ORklHX1ZJREVPQlVGX0RNQV9TRz15CiMgQ09ORklHX1ZJREVPX1Y0TDJfSU5UX0RFVklD RSBpcyBub3Qgc2V0CkNPTkZJR19EVkJfQ09SRT15CkNPTkZJR19EVkJfTkVUPXkKIyBDT05G SUdfVFRQQ0lfRUVQUk9NIGlzIG5vdCBzZXQKQ09ORklHX0RWQl9NQVhfQURBUFRFUlM9OAoj IENPTkZJR19EVkJfRFlOQU1JQ19NSU5PUlMgaXMgbm90IHNldAoKIwojIE1lZGlhIGRyaXZl cnMKIwpDT05GSUdfUkNfQ09SRT15CkNPTkZJR19SQ19NQVA9eQpDT05GSUdfUkNfREVDT0RF UlM9eQpDT05GSUdfTElSQz15CkNPTkZJR19JUl9MSVJDX0NPREVDPXkKQ09ORklHX0lSX05F Q19ERUNPREVSPXkKQ09ORklHX0lSX1JDNV9ERUNPREVSPXkKQ09ORklHX0lSX1JDNl9ERUNP REVSPXkKQ09ORklHX0lSX0pWQ19ERUNPREVSPXkKQ09ORklHX0lSX1NPTllfREVDT0RFUj15 CkNPTkZJR19JUl9SQzVfU1pfREVDT0RFUj15CkNPTkZJR19JUl9TQU5ZT19ERUNPREVSPXkK Q09ORklHX0lSX01DRV9LQkRfREVDT0RFUj15CiMgQ09ORklHX1JDX0RFVklDRVMgaXMgbm90 IHNldApDT05GSUdfTUVESUFfVVNCX1NVUFBPUlQ9eQoKIwojIFdlYmNhbSBkZXZpY2VzCiMK IyBDT05GSUdfVVNCX1ZJREVPX0NMQVNTIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX0dTUENB IGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX1BXQyBpcyBub3Qgc2V0CiMgQ09ORklHX1ZJREVP X0NQSUEyIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX1pSMzY0WFggaXMgbm90IHNldAojIENP TkZJR19VU0JfU1RLV0VCQ0FNIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX1MyMjU1IGlzIG5v dCBzZXQKIyBDT05GSUdfVVNCX1NOOUMxMDIgaXMgbm90IHNldAojIENPTkZJR19WSURFT19V U0JUViBpcyBub3Qgc2V0CgojCiMgQW5hbG9nIFRWIFVTQiBkZXZpY2VzCiMKQ09ORklHX1ZJ REVPX1BWUlVTQjI9eQpDT05GSUdfVklERU9fUFZSVVNCMl9TWVNGUz15CkNPTkZJR19WSURF T19QVlJVU0IyX0RWQj15CiMgQ09ORklHX1ZJREVPX1BWUlVTQjJfREVCVUdJRkMgaXMgbm90 IHNldAojIENPTkZJR19WSURFT19IRFBWUiBpcyBub3Qgc2V0CiMgQ09ORklHX1ZJREVPX1RM RzIzMDAgaXMgbm90IHNldAojIENPTkZJR19WSURFT19VU0JWSVNJT04gaXMgbm90IHNldAoj IENPTkZJR19WSURFT19TVEsxMTYwX0NPTU1PTiBpcyBub3Qgc2V0CgojCiMgQW5hbG9nL2Rp Z2l0YWwgVFYgVVNCIGRldmljZXMKIwojIENPTkZJR19WSURFT19BVTA4MjggaXMgbm90IHNl dAojIENPTkZJR19WSURFT19DWDIzMVhYIGlzIG5vdCBzZXQKIyBDT05GSUdfVklERU9fVE02 MDAwIGlzIG5vdCBzZXQKCiMKIyBEaWdpdGFsIFRWIFVTQiBkZXZpY2VzCiMKIyBDT05GSUdf RFZCX1VTQiBpcyBub3Qgc2V0CiMgQ09ORklHX0RWQl9VU0JfVjIgaXMgbm90IHNldAojIENP TkZJR19EVkJfVFRVU0JfQlVER0VUIGlzIG5vdCBzZXQKIyBDT05GSUdfRFZCX1RUVVNCX0RF QyBpcyBub3Qgc2V0CiMgQ09ORklHX1NNU19VU0JfRFJWIGlzIG5vdCBzZXQKIyBDT05GSUdf RFZCX0IyQzJfRkxFWENPUF9VU0IgaXMgbm90IHNldAoKIwojIFdlYmNhbSwgVFYgKGFuYWxv Zy9kaWdpdGFsKSBVU0IgZGV2aWNlcwojCiMgQ09ORklHX1ZJREVPX0VNMjhYWCBpcyBub3Qg c2V0CkNPTkZJR19NRURJQV9QQ0lfU1VQUE9SVD15CgojCiMgTWVkaWEgY2FwdHVyZSBzdXBw b3J0CiMKCiMKIyBNZWRpYSBjYXB0dXJlL2FuYWxvZyBUViBzdXBwb3J0CiMKIyBDT05GSUdf VklERU9fSVZUViBpcyBub3Qgc2V0CiMgQ09ORklHX1ZJREVPX1pPUkFOIGlzIG5vdCBzZXQK IyBDT05GSUdfVklERU9fSEVYSVVNX0dFTUlOSSBpcyBub3Qgc2V0CiMgQ09ORklHX1ZJREVP X0hFWElVTV9PUklPTiBpcyBub3Qgc2V0CiMgQ09ORklHX1ZJREVPX01YQiBpcyBub3Qgc2V0 CgojCiMgTWVkaWEgY2FwdHVyZS9hbmFsb2cvaHlicmlkIFRWIHN1cHBvcnQKIwojIENPTkZJ R19WSURFT19DWDE4IGlzIG5vdCBzZXQKIyBDT05GSUdfVklERU9fQ1gyMzg4NSBpcyBub3Qg c2V0CkNPTkZJR19WSURFT19DWDI1ODIxPXkKIyBDT05GSUdfVklERU9fQ1gyNTgyMV9BTFNB IGlzIG5vdCBzZXQKIyBDT05GSUdfVklERU9fQ1g4OCBpcyBub3Qgc2V0CiMgQ09ORklHX1ZJ REVPX0JUODQ4IGlzIG5vdCBzZXQKIyBDT05GSUdfVklERU9fU0FBNzEzNCBpcyBub3Qgc2V0 CiMgQ09ORklHX1ZJREVPX1NBQTcxNjQgaXMgbm90IHNldAoKIwojIE1lZGlhIGRpZ2l0YWwg VFYgUENJIEFkYXB0ZXJzCiMKIyBDT05GSUdfRFZCX0FWNzExMCBpcyBub3Qgc2V0CiMgQ09O RklHX0RWQl9CVURHRVRfQ09SRSBpcyBub3Qgc2V0CiMgQ09ORklHX0RWQl9CMkMyX0ZMRVhD T1BfUENJIGlzIG5vdCBzZXQKIyBDT05GSUdfRFZCX1BMVVRPMiBpcyBub3Qgc2V0CiMgQ09O RklHX0RWQl9ETTExMDUgaXMgbm90IHNldAojIENPTkZJR19EVkJfUFQxIGlzIG5vdCBzZXQK IyBDT05GSUdfTUFOVElTX0NPUkUgaXMgbm90IHNldAojIENPTkZJR19EVkJfTkdFTkUgaXMg bm90IHNldAojIENPTkZJR19EVkJfRERCUklER0UgaXMgbm90IHNldAojIENPTkZJR19WNExf UExBVEZPUk1fRFJJVkVSUyBpcyBub3Qgc2V0CiMgQ09ORklHX1Y0TF9NRU0yTUVNX0RSSVZF UlMgaXMgbm90IHNldAojIENPTkZJR19WNExfVEVTVF9EUklWRVJTIGlzIG5vdCBzZXQKCiMK IyBTdXBwb3J0ZWQgTU1DL1NESU8gYWRhcHRlcnMKIwojIENPTkZJR19SQURJT19BREFQVEVS UyBpcyBub3Qgc2V0CkNPTkZJR19WSURFT19DWDIzNDFYPXkKQ09ORklHX1ZJREVPX0JUQ1g9 eQpDT05GSUdfVklERU9fVFZFRVBST009eQojIENPTkZJR19DWVBSRVNTX0ZJUk1XQVJFIGlz IG5vdCBzZXQKCiMKIyBNZWRpYSBhbmNpbGxhcnkgZHJpdmVycyAodHVuZXJzLCBzZW5zb3Jz LCBpMmMsIGZyb250ZW5kcykKIwpDT05GSUdfTUVESUFfU1VCRFJWX0FVVE9TRUxFQ1Q9eQpD T05GSUdfTUVESUFfQVRUQUNIPXkKQ09ORklHX1ZJREVPX0lSX0kyQz15CgojCiMgQXVkaW8g ZGVjb2RlcnMsIHByb2Nlc3NvcnMgYW5kIG1peGVycwojCkNPTkZJR19WSURFT19NU1AzNDAw PXkKQ09ORklHX1ZJREVPX0NTNTNMMzJBPXkKQ09ORklHX1ZJREVPX1dNODc3NT15CgojCiMg UkRTIGRlY29kZXJzCiMKCiMKIyBWaWRlbyBkZWNvZGVycwojCkNPTkZJR19WSURFT19TQUE3 MTFYPXkKCiMKIyBWaWRlbyBhbmQgYXVkaW8gZGVjb2RlcnMKIwpDT05GSUdfVklERU9fQ1gy NTg0MD15CgojCiMgVmlkZW8gZW5jb2RlcnMKIwoKIwojIENhbWVyYSBzZW5zb3IgZGV2aWNl cwojCgojCiMgRmxhc2ggZGV2aWNlcwojCgojCiMgVmlkZW8gaW1wcm92ZW1lbnQgY2hpcHMK IwoKIwojIE1pc2NlbGxhbmVvdXMgaGVscGVyIGNoaXBzCiMKCiMKIyBTZW5zb3JzIHVzZWQg b24gc29jX2NhbWVyYSBkcml2ZXIKIwpDT05GSUdfTUVESUFfVFVORVI9eQpDT05GSUdfTUVE SUFfVFVORVJfU0lNUExFPXkKQ09ORklHX01FRElBX1RVTkVSX1REQTgyOTA9eQpDT05GSUdf TUVESUFfVFVORVJfVERBODI3WD15CkNPTkZJR19NRURJQV9UVU5FUl9UREExODI3MT15CkNP TkZJR19NRURJQV9UVU5FUl9UREE5ODg3PXkKQ09ORklHX01FRElBX1RVTkVSX1RFQTU3NjE9 eQpDT05GSUdfTUVESUFfVFVORVJfVEVBNTc2Nz15CkNPTkZJR19NRURJQV9UVU5FUl9NVDIw WFg9eQpDT05GSUdfTUVESUFfVFVORVJfWEMyMDI4PXkKQ09ORklHX01FRElBX1RVTkVSX1hD NTAwMD15CkNPTkZJR19NRURJQV9UVU5FUl9YQzQwMDA9eQpDT05GSUdfTUVESUFfVFVORVJf TUM0NFM4MDM9eQoKIwojIE11bHRpc3RhbmRhcmQgKHNhdGVsbGl0ZSkgZnJvbnRlbmRzCiMK CiMKIyBNdWx0aXN0YW5kYXJkIChjYWJsZSArIHRlcnJlc3RyaWFsKSBmcm9udGVuZHMKIwoK IwojIERWQi1TIChzYXRlbGxpdGUpIGZyb250ZW5kcwojCgojCiMgRFZCLVQgKHRlcnJlc3Ry aWFsKSBmcm9udGVuZHMKIwpDT05GSUdfRFZCX1REQTEwMDQ4PXkKCiMKIyBEVkItQyAoY2Fi bGUpIGZyb250ZW5kcwojCgojCiMgQVRTQyAoTm9ydGggQW1lcmljYW4vS29yZWFuIFRlcnJl c3RyaWFsL0NhYmxlIERUVikgZnJvbnRlbmRzCiMKQ09ORklHX0RWQl9MR0RUMzMwWD15CkNP TkZJR19EVkJfUzVIMTQwOT15CkNPTkZJR19EVkJfUzVIMTQxMT15CgojCiMgSVNEQi1UICh0 ZXJyZXN0cmlhbCkgZnJvbnRlbmRzCiMKCiMKIyBEaWdpdGFsIHRlcnJlc3RyaWFsIG9ubHkg dHVuZXJzL1BMTAojCgojCiMgU0VDIGNvbnRyb2wgZGV2aWNlcyBmb3IgRFZCLVMKIwoKIwoj IFRvb2xzIHRvIGRldmVsb3AgbmV3IGZyb250ZW5kcwojCiMgQ09ORklHX0RWQl9EVU1NWV9G RSBpcyBub3Qgc2V0CgojCiMgR3JhcGhpY3Mgc3VwcG9ydAojCkNPTkZJR19BR1A9eQpDT05G SUdfQUdQX0FNRDY0PXkKQ09ORklHX0FHUF9JTlRFTD15CiMgQ09ORklHX0FHUF9TSVMgaXMg bm90IHNldAojIENPTkZJR19BR1BfVklBIGlzIG5vdCBzZXQKQ09ORklHX1ZHQV9BUkI9eQpD T05GSUdfVkdBX0FSQl9NQVhfR1BVUz0xNgojIENPTkZJR19WR0FfU1dJVENIRVJPTyBpcyBu b3Qgc2V0CkNPTkZJR19EUk09eQpDT05GSUdfRFJNX0tNU19IRUxQRVI9eQpDT05GSUdfRFJN X0tNU19GQl9IRUxQRVI9eQojIENPTkZJR19EUk1fTE9BRF9FRElEX0ZJUk1XQVJFIGlzIG5v dCBzZXQKQ09ORklHX0RSTV9UVE09eQoKIwojIEkyQyBlbmNvZGVyIG9yIGhlbHBlciBjaGlw cwojCiMgQ09ORklHX0RSTV9JMkNfQ0g3MDA2IGlzIG5vdCBzZXQKIyBDT05GSUdfRFJNX0ky Q19TSUwxNjQgaXMgbm90IHNldAojIENPTkZJR19EUk1fSTJDX05YUF9UREE5OThYIGlzIG5v dCBzZXQKIyBDT05GSUdfRFJNX1RERlggaXMgbm90IHNldAojIENPTkZJR19EUk1fUjEyOCBp cyBub3Qgc2V0CkNPTkZJR19EUk1fUkFERU9OPXkKIyBDT05GSUdfRFJNX1JBREVPTl9VTVMg aXMgbm90IHNldAojIENPTkZJR19EUk1fTk9VVkVBVSBpcyBub3Qgc2V0CiMgQ09ORklHX0RS TV9JODEwIGlzIG5vdCBzZXQKIyBDT05GSUdfRFJNX0k5MTUgaXMgbm90IHNldAojIENPTkZJ R19EUk1fTUdBIGlzIG5vdCBzZXQKIyBDT05GSUdfRFJNX1NJUyBpcyBub3Qgc2V0CiMgQ09O RklHX0RSTV9WSUEgaXMgbm90IHNldAojIENPTkZJR19EUk1fU0FWQUdFIGlzIG5vdCBzZXQK IyBDT05GSUdfRFJNX1ZNV0dGWCBpcyBub3Qgc2V0CiMgQ09ORklHX0RSTV9HTUE1MDAgaXMg bm90IHNldAojIENPTkZJR19EUk1fVURMIGlzIG5vdCBzZXQKIyBDT05GSUdfRFJNX0FTVCBp cyBub3Qgc2V0CiMgQ09ORklHX0RSTV9NR0FHMjAwIGlzIG5vdCBzZXQKQ09ORklHX0RSTV9D SVJSVVNfUUVNVT15CkNPTkZJR19EUk1fUVhMPXkKIyBDT05GSUdfVkdBU1RBVEUgaXMgbm90 IHNldApDT05GSUdfVklERU9fT1VUUFVUX0NPTlRST0w9eQpDT05GSUdfSERNST15CkNPTkZJ R19GQj15CiMgQ09ORklHX0ZJUk1XQVJFX0VESUQgaXMgbm90IHNldAojIENPTkZJR19GQl9E REMgaXMgbm90IHNldApDT05GSUdfRkJfQk9PVF9WRVNBX1NVUFBPUlQ9eQpDT05GSUdfRkJf Q0ZCX0ZJTExSRUNUPXkKQ09ORklHX0ZCX0NGQl9DT1BZQVJFQT15CkNPTkZJR19GQl9DRkJf SU1BR0VCTElUPXkKIyBDT05GSUdfRkJfQ0ZCX1JFVl9QSVhFTFNfSU5fQllURSBpcyBub3Qg c2V0CkNPTkZJR19GQl9TWVNfRklMTFJFQ1Q9eQpDT05GSUdfRkJfU1lTX0NPUFlBUkVBPXkK Q09ORklHX0ZCX1NZU19JTUFHRUJMSVQ9eQojIENPTkZJR19GQl9GT1JFSUdOX0VORElBTiBp cyBub3Qgc2V0CkNPTkZJR19GQl9TWVNfRk9QUz15CkNPTkZJR19GQl9ERUZFUlJFRF9JTz15 CiMgQ09ORklHX0ZCX1NWR0FMSUIgaXMgbm90IHNldAojIENPTkZJR19GQl9NQUNNT0RFUyBp cyBub3Qgc2V0CiMgQ09ORklHX0ZCX0JBQ0tMSUdIVCBpcyBub3Qgc2V0CkNPTkZJR19GQl9N T0RFX0hFTFBFUlM9eQpDT05GSUdfRkJfVElMRUJMSVRUSU5HPXkKCiMKIyBGcmFtZSBidWZm ZXIgaGFyZHdhcmUgZHJpdmVycwojCiMgQ09ORklHX0ZCX0NJUlJVUyBpcyBub3Qgc2V0CiMg Q09ORklHX0ZCX1BNMiBpcyBub3Qgc2V0CiMgQ09ORklHX0ZCX0NZQkVSMjAwMCBpcyBub3Qg c2V0CiMgQ09ORklHX0ZCX0FSQyBpcyBub3Qgc2V0CiMgQ09ORklHX0ZCX0FTSUxJQU5UIGlz IG5vdCBzZXQKIyBDT05GSUdfRkJfSU1TVFQgaXMgbm90IHNldAojIENPTkZJR19GQl9WR0Ex NiBpcyBub3Qgc2V0CiMgQ09ORklHX0ZCX1VWRVNBIGlzIG5vdCBzZXQKQ09ORklHX0ZCX1ZF U0E9eQojIENPTkZJR19GQl9ONDExIGlzIG5vdCBzZXQKIyBDT05GSUdfRkJfSEdBIGlzIG5v dCBzZXQKIyBDT05GSUdfRkJfUzFEMTNYWFggaXMgbm90IHNldAojIENPTkZJR19GQl9OVklE SUEgaXMgbm90IHNldAojIENPTkZJR19GQl9SSVZBIGlzIG5vdCBzZXQKIyBDT05GSUdfRkJf STc0MCBpcyBub3Qgc2V0CiMgQ09ORklHX0ZCX0xFODA1NzggaXMgbm90IHNldAojIENPTkZJ R19GQl9NQVRST1ggaXMgbm90IHNldAojIENPTkZJR19GQl9SQURFT04gaXMgbm90IHNldAoj IENPTkZJR19GQl9BVFkxMjggaXMgbm90IHNldAojIENPTkZJR19GQl9BVFkgaXMgbm90IHNl dAojIENPTkZJR19GQl9TMyBpcyBub3Qgc2V0CiMgQ09ORklHX0ZCX1NBVkFHRSBpcyBub3Qg c2V0CiMgQ09ORklHX0ZCX1NJUyBpcyBub3Qgc2V0CiMgQ09ORklHX0ZCX1ZJQSBpcyBub3Qg c2V0CiMgQ09ORklHX0ZCX05FT01BR0lDIGlzIG5vdCBzZXQKIyBDT05GSUdfRkJfS1lSTyBp cyBub3Qgc2V0CiMgQ09ORklHX0ZCXzNERlggaXMgbm90IHNldAojIENPTkZJR19GQl9WT09E T08xIGlzIG5vdCBzZXQKIyBDT05GSUdfRkJfVlQ4NjIzIGlzIG5vdCBzZXQKIyBDT05GSUdf RkJfVFJJREVOVCBpcyBub3Qgc2V0CiMgQ09ORklHX0ZCX0FSSyBpcyBub3Qgc2V0CiMgQ09O RklHX0ZCX1BNMyBpcyBub3Qgc2V0CiMgQ09ORklHX0ZCX0NBUk1JTkUgaXMgbm90IHNldAoj IENPTkZJR19GQl9UTUlPIGlzIG5vdCBzZXQKIyBDT05GSUdfRkJfU01TQ1VGWCBpcyBub3Qg c2V0CkNPTkZJR19GQl9VREw9eQojIENPTkZJR19GQl9HT0xERklTSCBpcyBub3Qgc2V0CiMg Q09ORklHX0ZCX1ZJUlRVQUwgaXMgbm90IHNldApDT05GSUdfWEVOX0ZCREVWX0ZST05URU5E PXkKIyBDT05GSUdfRkJfTUVUUk9OT01FIGlzIG5vdCBzZXQKIyBDT05GSUdfRkJfTUI4NjJY WCBpcyBub3Qgc2V0CiMgQ09ORklHX0ZCX0JST0FEU0hFRVQgaXMgbm90IHNldAojIENPTkZJ R19GQl9BVU9fSzE5MFggaXMgbm90IHNldAojIENPTkZJR19GQl9TSU1QTEUgaXMgbm90IHNl dAojIENPTkZJR19FWFlOT1NfVklERU8gaXMgbm90IHNldApDT05GSUdfQkFDS0xJR0hUX0xD RF9TVVBQT1JUPXkKIyBDT05GSUdfTENEX0NMQVNTX0RFVklDRSBpcyBub3Qgc2V0CkNPTkZJ R19CQUNLTElHSFRfQ0xBU1NfREVWSUNFPXkKQ09ORklHX0JBQ0tMSUdIVF9HRU5FUklDPXkK IyBDT05GSUdfQkFDS0xJR0hUX0FQUExFIGlzIG5vdCBzZXQKIyBDT05GSUdfQkFDS0xJR0hU X1NBSEFSQSBpcyBub3Qgc2V0CiMgQ09ORklHX0JBQ0tMSUdIVF9BRFA4ODYwIGlzIG5vdCBz ZXQKIyBDT05GSUdfQkFDS0xJR0hUX0FEUDg4NzAgaXMgbm90IHNldAojIENPTkZJR19CQUNL TElHSFRfTE0zNjMwQSBpcyBub3Qgc2V0CiMgQ09ORklHX0JBQ0tMSUdIVF9MTTM2MzkgaXMg bm90IHNldAojIENPTkZJR19CQUNLTElHSFRfTFA4NTVYIGlzIG5vdCBzZXQKIyBDT05GSUdf QkFDS0xJR0hUX0xWNTIwN0xQIGlzIG5vdCBzZXQKIyBDT05GSUdfQkFDS0xJR0hUX0JENjEw NyBpcyBub3Qgc2V0CgojCiMgQ29uc29sZSBkaXNwbGF5IGRyaXZlciBzdXBwb3J0CiMKQ09O RklHX1ZHQV9DT05TT0xFPXkKQ09ORklHX1ZHQUNPTl9TT0ZUX1NDUk9MTEJBQ0s9eQpDT05G SUdfVkdBQ09OX1NPRlRfU0NST0xMQkFDS19TSVpFPTY0CkNPTkZJR19EVU1NWV9DT05TT0xF PXkKQ09ORklHX0ZSQU1FQlVGRkVSX0NPTlNPTEU9eQpDT05GSUdfRlJBTUVCVUZGRVJfQ09O U09MRV9ERVRFQ1RfUFJJTUFSWT15CiMgQ09ORklHX0ZSQU1FQlVGRkVSX0NPTlNPTEVfUk9U QVRJT04gaXMgbm90IHNldApDT05GSUdfTE9HTz15CiMgQ09ORklHX0xPR09fTElOVVhfTU9O TyBpcyBub3Qgc2V0CiMgQ09ORklHX0xPR09fTElOVVhfVkdBMTYgaXMgbm90IHNldApDT05G SUdfTE9HT19MSU5VWF9DTFVUMjI0PXkKQ09ORklHX1NPVU5EPXkKQ09ORklHX1NPVU5EX09T U19DT1JFPXkKQ09ORklHX1NPVU5EX09TU19DT1JFX1BSRUNMQUlNPXkKQ09ORklHX1NORD15 CkNPTkZJR19TTkRfVElNRVI9eQpDT05GSUdfU05EX1BDTT15CkNPTkZJR19TTkRfSFdERVA9 eQpDT05GSUdfU05EX1JBV01JREk9eQpDT05GSUdfU05EX1NFUVVFTkNFUj15CkNPTkZJR19T TkRfU0VRX0RVTU1ZPXkKQ09ORklHX1NORF9PU1NFTVVMPXkKQ09ORklHX1NORF9NSVhFUl9P U1M9eQpDT05GSUdfU05EX1BDTV9PU1M9eQpDT05GSUdfU05EX1BDTV9PU1NfUExVR0lOUz15 CkNPTkZJR19TTkRfU0VRVUVOQ0VSX09TUz15CkNPTkZJR19TTkRfSFJUSU1FUj15CkNPTkZJ R19TTkRfU0VRX0hSVElNRVJfREVGQVVMVD15CkNPTkZJR19TTkRfRFlOQU1JQ19NSU5PUlM9 eQpDT05GSUdfU05EX01BWF9DQVJEUz0zMgpDT05GSUdfU05EX1NVUFBPUlRfT0xEX0FQST15 CkNPTkZJR19TTkRfVkVSQk9TRV9QUk9DRlM9eQojIENPTkZJR19TTkRfVkVSQk9TRV9QUklO VEsgaXMgbm90IHNldAojIENPTkZJR19TTkRfREVCVUcgaXMgbm90IHNldApDT05GSUdfU05E X1ZNQVNURVI9eQpDT05GSUdfU05EX0tDVExfSkFDSz15CkNPTkZJR19TTkRfRE1BX1NHQlVG PXkKQ09ORklHX1NORF9SQVdNSURJX1NFUT15CkNPTkZJR19TTkRfT1BMM19MSUJfU0VRPXkK IyBDT05GSUdfU05EX09QTDRfTElCX1NFUSBpcyBub3Qgc2V0CiMgQ09ORklHX1NORF9TQkFX RV9TRVEgaXMgbm90IHNldAojIENPTkZJR19TTkRfRU1VMTBLMV9TRVEgaXMgbm90IHNldApD T05GSUdfU05EX01QVTQwMV9VQVJUPXkKQ09ORklHX1NORF9PUEwzX0xJQj15CkNPTkZJR19T TkRfRFJJVkVSUz15CiMgQ09ORklHX1NORF9QQ1NQIGlzIG5vdCBzZXQKIyBDT05GSUdfU05E X0RVTU1ZIGlzIG5vdCBzZXQKIyBDT05GSUdfU05EX0FMT09QIGlzIG5vdCBzZXQKIyBDT05G SUdfU05EX1ZJUk1JREkgaXMgbm90IHNldAojIENPTkZJR19TTkRfTVRQQVYgaXMgbm90IHNl dAojIENPTkZJR19TTkRfU0VSSUFMX1UxNjU1MCBpcyBub3Qgc2V0CiMgQ09ORklHX1NORF9N UFU0MDEgaXMgbm90IHNldApDT05GSUdfU05EX1BDST15CiMgQ09ORklHX1NORF9BRDE4ODkg aXMgbm90IHNldAojIENPTkZJR19TTkRfQUxTMzAwIGlzIG5vdCBzZXQKIyBDT05GSUdfU05E X0FMUzQwMDAgaXMgbm90IHNldAojIENPTkZJR19TTkRfQUxJNTQ1MSBpcyBub3Qgc2V0CiMg Q09ORklHX1NORF9BU0lIUEkgaXMgbm90IHNldAojIENPTkZJR19TTkRfQVRJSVhQIGlzIG5v dCBzZXQKIyBDT05GSUdfU05EX0FUSUlYUF9NT0RFTSBpcyBub3Qgc2V0CiMgQ09ORklHX1NO RF9BVTg4MTAgaXMgbm90IHNldAojIENPTkZJR19TTkRfQVU4ODIwIGlzIG5vdCBzZXQKIyBD T05GSUdfU05EX0FVODgzMCBpcyBub3Qgc2V0CiMgQ09ORklHX1NORF9BVzIgaXMgbm90IHNl dAojIENPTkZJR19TTkRfQVpUMzMyOCBpcyBub3Qgc2V0CiMgQ09ORklHX1NORF9CVDg3WCBp cyBub3Qgc2V0CiMgQ09ORklHX1NORF9DQTAxMDYgaXMgbm90IHNldApDT05GSUdfU05EX0NN SVBDST15CkNPTkZJR19TTkRfT1hZR0VOX0xJQj15CkNPTkZJR19TTkRfT1hZR0VOPXkKIyBD T05GSUdfU05EX0NTNDI4MSBpcyBub3Qgc2V0CiMgQ09ORklHX1NORF9DUzQ2WFggaXMgbm90 IHNldAojIENPTkZJR19TTkRfQ1M1NTMwIGlzIG5vdCBzZXQKIyBDT05GSUdfU05EX0NTNTUz NUFVRElPIGlzIG5vdCBzZXQKIyBDT05GSUdfU05EX0NUWEZJIGlzIG5vdCBzZXQKIyBDT05G SUdfU05EX0RBUkxBMjAgaXMgbm90IHNldAojIENPTkZJR19TTkRfR0lOQTIwIGlzIG5vdCBz ZXQKIyBDT05GSUdfU05EX0xBWUxBMjAgaXMgbm90IHNldAojIENPTkZJR19TTkRfREFSTEEy NCBpcyBub3Qgc2V0CiMgQ09ORklHX1NORF9HSU5BMjQgaXMgbm90IHNldAojIENPTkZJR19T TkRfTEFZTEEyNCBpcyBub3Qgc2V0CiMgQ09ORklHX1NORF9NT05BIGlzIG5vdCBzZXQKIyBD T05GSUdfU05EX01JQSBpcyBub3Qgc2V0CiMgQ09ORklHX1NORF9FQ0hPM0cgaXMgbm90IHNl dAojIENPTkZJR19TTkRfSU5ESUdPIGlzIG5vdCBzZXQKIyBDT05GSUdfU05EX0lORElHT0lP IGlzIG5vdCBzZXQKIyBDT05GSUdfU05EX0lORElHT0RKIGlzIG5vdCBzZXQKIyBDT05GSUdf U05EX0lORElHT0lPWCBpcyBub3Qgc2V0CiMgQ09ORklHX1NORF9JTkRJR09ESlggaXMgbm90 IHNldAojIENPTkZJR19TTkRfRU1VMTBLMSBpcyBub3Qgc2V0CiMgQ09ORklHX1NORF9FTVUx MEsxWCBpcyBub3Qgc2V0CiMgQ09ORklHX1NORF9FTlMxMzcwIGlzIG5vdCBzZXQKIyBDT05G SUdfU05EX0VOUzEzNzEgaXMgbm90IHNldAojIENPTkZJR19TTkRfRVMxOTM4IGlzIG5vdCBz ZXQKIyBDT05GSUdfU05EX0VTMTk2OCBpcyBub3Qgc2V0CiMgQ09ORklHX1NORF9GTTgwMSBp cyBub3Qgc2V0CkNPTkZJR19TTkRfSERBX0lOVEVMPXkKQ09ORklHX1NORF9IREFfUFJFQUxM T0NfU0laRT02NApDT05GSUdfU05EX0hEQV9IV0RFUD15CiMgQ09ORklHX1NORF9IREFfUkVD T05GSUcgaXMgbm90IHNldAojIENPTkZJR19TTkRfSERBX0lOUFVUX0JFRVAgaXMgbm90IHNl dAojIENPTkZJR19TTkRfSERBX0lOUFVUX0pBQ0sgaXMgbm90IHNldAojIENPTkZJR19TTkRf SERBX1BBVENIX0xPQURFUiBpcyBub3Qgc2V0CkNPTkZJR19TTkRfSERBX0NPREVDX1JFQUxU RUs9eQpDT05GSUdfU05EX0hEQV9DT0RFQ19BTkFMT0c9eQpDT05GSUdfU05EX0hEQV9DT0RF Q19TSUdNQVRFTD15CkNPTkZJR19TTkRfSERBX0NPREVDX1ZJQT15CkNPTkZJR19TTkRfSERB X0NPREVDX0hETUk9eQpDT05GSUdfU05EX0hEQV9DT0RFQ19DSVJSVVM9eQpDT05GSUdfU05E X0hEQV9DT0RFQ19DT05FWEFOVD15CkNPTkZJR19TTkRfSERBX0NPREVDX0NBMDExMD15CkNP TkZJR19TTkRfSERBX0NPREVDX0NBMDEzMj15CiMgQ09ORklHX1NORF9IREFfQ09ERUNfQ0Ew MTMyX0RTUCBpcyBub3Qgc2V0CkNPTkZJR19TTkRfSERBX0NPREVDX0NNRURJQT15CkNPTkZJ R19TTkRfSERBX0NPREVDX1NJMzA1ND15CkNPTkZJR19TTkRfSERBX0dFTkVSSUM9eQpDT05G SUdfU05EX0hEQV9QT1dFUl9TQVZFX0RFRkFVTFQ9MAojIENPTkZJR19TTkRfSERTUCBpcyBu b3Qgc2V0CiMgQ09ORklHX1NORF9IRFNQTSBpcyBub3Qgc2V0CiMgQ09ORklHX1NORF9JQ0Ux NzEyIGlzIG5vdCBzZXQKIyBDT05GSUdfU05EX0lDRTE3MjQgaXMgbm90IHNldAojIENPTkZJ R19TTkRfSU5URUw4WDAgaXMgbm90IHNldAojIENPTkZJR19TTkRfSU5URUw4WDBNIGlzIG5v dCBzZXQKIyBDT05GSUdfU05EX0tPUkcxMjEyIGlzIG5vdCBzZXQKIyBDT05GSUdfU05EX0xP TEEgaXMgbm90IHNldAojIENPTkZJR19TTkRfTFg2NDY0RVMgaXMgbm90IHNldAojIENPTkZJ R19TTkRfTUFFU1RSTzMgaXMgbm90IHNldAojIENPTkZJR19TTkRfTUlYQVJUIGlzIG5vdCBz ZXQKIyBDT05GSUdfU05EX05NMjU2IGlzIG5vdCBzZXQKIyBDT05GSUdfU05EX1BDWEhSIGlz IG5vdCBzZXQKIyBDT05GSUdfU05EX1JJUFRJREUgaXMgbm90IHNldAojIENPTkZJR19TTkRf Uk1FMzIgaXMgbm90IHNldAojIENPTkZJR19TTkRfUk1FOTYgaXMgbm90IHNldAojIENPTkZJ R19TTkRfUk1FOTY1MiBpcyBub3Qgc2V0CiMgQ09ORklHX1NORF9TT05JQ1ZJQkVTIGlzIG5v dCBzZXQKIyBDT05GSUdfU05EX1RSSURFTlQgaXMgbm90IHNldAojIENPTkZJR19TTkRfVklB ODJYWCBpcyBub3Qgc2V0CiMgQ09ORklHX1NORF9WSUE4MlhYX01PREVNIGlzIG5vdCBzZXQK IyBDT05GSUdfU05EX1ZJUlRVT1NPIGlzIG5vdCBzZXQKIyBDT05GSUdfU05EX1ZYMjIyIGlz IG5vdCBzZXQKIyBDT05GSUdfU05EX1lNRlBDSSBpcyBub3Qgc2V0CkNPTkZJR19TTkRfVVNC PXkKQ09ORklHX1NORF9VU0JfQVVESU89eQpDT05GSUdfU05EX1VTQl9VQTEwMT15CkNPTkZJ R19TTkRfVVNCX1VTWDJZPXkKQ09ORklHX1NORF9VU0JfQ0FJQVE9eQpDT05GSUdfU05EX1VT Ql9DQUlBUV9JTlBVVD15CiMgQ09ORklHX1NORF9VU0JfVVMxMjJMIGlzIG5vdCBzZXQKQ09O RklHX1NORF9VU0JfNkZJUkU9eQojIENPTkZJR19TTkRfVVNCX0hJRkFDRSBpcyBub3Qgc2V0 CiMgQ09ORklHX1NORF9TT0MgaXMgbm90IHNldAojIENPTkZJR19TT1VORF9QUklNRSBpcyBu b3Qgc2V0CgojCiMgSElEIHN1cHBvcnQKIwpDT05GSUdfSElEPXkKIyBDT05GSUdfSElEX0JB VFRFUllfU1RSRU5HVEggaXMgbm90IHNldApDT05GSUdfSElEUkFXPXkKIyBDT05GSUdfVUhJ RCBpcyBub3Qgc2V0CkNPTkZJR19ISURfR0VORVJJQz15CgojCiMgU3BlY2lhbCBISUQgZHJp dmVycwojCkNPTkZJR19ISURfQTRURUNIPXkKIyBDT05GSUdfSElEX0FDUlVYIGlzIG5vdCBz ZXQKQ09ORklHX0hJRF9BUFBMRT15CiMgQ09ORklHX0hJRF9BUFBMRUlSIGlzIG5vdCBzZXQK IyBDT05GSUdfSElEX0FVUkVBTCBpcyBub3Qgc2V0CkNPTkZJR19ISURfQkVMS0lOPXkKQ09O RklHX0hJRF9DSEVSUlk9eQpDT05GSUdfSElEX0NISUNPTlk9eQojIENPTkZJR19ISURfUFJP RElLRVlTIGlzIG5vdCBzZXQKQ09ORklHX0hJRF9DWVBSRVNTPXkKIyBDT05GSUdfSElEX0RS QUdPTlJJU0UgaXMgbm90IHNldAojIENPTkZJR19ISURfRU1TX0ZGIGlzIG5vdCBzZXQKIyBD T05GSUdfSElEX0VMRUNPTSBpcyBub3Qgc2V0CiMgQ09ORklHX0hJRF9FTE8gaXMgbm90IHNl dApDT05GSUdfSElEX0VaS0VZPXkKIyBDT05GSUdfSElEX0hPTFRFSyBpcyBub3Qgc2V0CiMg Q09ORklHX0hJRF9IVUlPTiBpcyBub3Qgc2V0CiMgQ09ORklHX0hJRF9LRVlUT1VDSCBpcyBu b3Qgc2V0CiMgQ09ORklHX0hJRF9LWUUgaXMgbm90IHNldAojIENPTkZJR19ISURfVUNMT0dJ QyBpcyBub3Qgc2V0CiMgQ09ORklHX0hJRF9XQUxUT1AgaXMgbm90IHNldAojIENPTkZJR19I SURfR1lSQVRJT04gaXMgbm90IHNldAojIENPTkZJR19ISURfSUNBREUgaXMgbm90IHNldAoj IENPTkZJR19ISURfVFdJTkhBTiBpcyBub3Qgc2V0CkNPTkZJR19ISURfS0VOU0lOR1RPTj15 CiMgQ09ORklHX0hJRF9MQ1BPV0VSIGlzIG5vdCBzZXQKIyBDT05GSUdfSElEX0xFTk9WT19U UEtCRCBpcyBub3Qgc2V0CkNPTkZJR19ISURfTE9HSVRFQ0g9eQojIENPTkZJR19ISURfTE9H SVRFQ0hfREogaXMgbm90IHNldAojIENPTkZJR19MT0dJVEVDSF9GRiBpcyBub3Qgc2V0CiMg Q09ORklHX0xPR0lSVU1CTEVQQUQyX0ZGIGlzIG5vdCBzZXQKIyBDT05GSUdfTE9HSUc5NDBf RkYgaXMgbm90IHNldAojIENPTkZJR19MT0dJV0hFRUxTX0ZGIGlzIG5vdCBzZXQKIyBDT05G SUdfSElEX01BR0lDTU9VU0UgaXMgbm90IHNldApDT05GSUdfSElEX01JQ1JPU09GVD15CkNP TkZJR19ISURfTU9OVEVSRVk9eQojIENPTkZJR19ISURfTVVMVElUT1VDSCBpcyBub3Qgc2V0 CiMgQ09ORklHX0hJRF9OVFJJRyBpcyBub3Qgc2V0CiMgQ09ORklHX0hJRF9PUlRFSyBpcyBu b3Qgc2V0CiMgQ09ORklHX0hJRF9QQU5USEVSTE9SRCBpcyBub3Qgc2V0CiMgQ09ORklHX0hJ RF9QRVRBTFlOWCBpcyBub3Qgc2V0CiMgQ09ORklHX0hJRF9QSUNPTENEIGlzIG5vdCBzZXQK IyBDT05GSUdfSElEX1BSSU1BWCBpcyBub3Qgc2V0CiMgQ09ORklHX0hJRF9ST0NDQVQgaXMg bm90IHNldAojIENPTkZJR19ISURfU0FJVEVLIGlzIG5vdCBzZXQKIyBDT05GSUdfSElEX1NB TVNVTkcgaXMgbm90IHNldAojIENPTkZJR19ISURfU09OWSBpcyBub3Qgc2V0CiMgQ09ORklH X0hJRF9TUEVFRExJTksgaXMgbm90IHNldAojIENPTkZJR19ISURfU1RFRUxTRVJJRVMgaXMg bm90IHNldAojIENPTkZJR19ISURfU1VOUExVUyBpcyBub3Qgc2V0CiMgQ09ORklHX0hJRF9H UkVFTkFTSUEgaXMgbm90IHNldAojIENPTkZJR19ISURfU01BUlRKT1lQTFVTIGlzIG5vdCBz ZXQKIyBDT05GSUdfSElEX1RJVk8gaXMgbm90IHNldAojIENPTkZJR19ISURfVE9QU0VFRCBp cyBub3Qgc2V0CiMgQ09ORklHX0hJRF9USElOR00gaXMgbm90IHNldAojIENPTkZJR19ISURf VEhSVVNUTUFTVEVSIGlzIG5vdCBzZXQKIyBDT05GSUdfSElEX1dBQ09NIGlzIG5vdCBzZXQK IyBDT05GSUdfSElEX1dJSU1PVEUgaXMgbm90IHNldAojIENPTkZJR19ISURfWElOTU8gaXMg bm90IHNldAojIENPTkZJR19ISURfWkVST1BMVVMgaXMgbm90IHNldAojIENPTkZJR19ISURf WllEQUNST04gaXMgbm90IHNldAojIENPTkZJR19ISURfU0VOU09SX0hVQiBpcyBub3Qgc2V0 CgojCiMgVVNCIEhJRCBzdXBwb3J0CiMKQ09ORklHX1VTQl9ISUQ9eQpDT05GSUdfSElEX1BJ RD15CkNPTkZJR19VU0JfSElEREVWPXkKCiMKIyBJMkMgSElEIHN1cHBvcnQKIwojIENPTkZJ R19JMkNfSElEIGlzIG5vdCBzZXQKQ09ORklHX1VTQl9PSENJX0xJVFRMRV9FTkRJQU49eQpD T05GSUdfVVNCX1NVUFBPUlQ9eQpDT05GSUdfVVNCX0NPTU1PTj15CkNPTkZJR19VU0JfQVJD SF9IQVNfSENEPXkKQ09ORklHX1VTQj15CiMgQ09ORklHX1VTQl9ERUJVRyBpcyBub3Qgc2V0 CkNPTkZJR19VU0JfQU5OT1VOQ0VfTkVXX0RFVklDRVM9eQoKIwojIE1pc2NlbGxhbmVvdXMg VVNCIG9wdGlvbnMKIwpDT05GSUdfVVNCX0RFRkFVTFRfUEVSU0lTVD15CiMgQ09ORklHX1VT Ql9EWU5BTUlDX01JTk9SUyBpcyBub3Qgc2V0CkNPTkZJR19VU0JfTU9OPXkKIyBDT05GSUdf VVNCX1dVU0JfQ0JBRiBpcyBub3Qgc2V0CgojCiMgVVNCIEhvc3QgQ29udHJvbGxlciBEcml2 ZXJzCiMKIyBDT05GSUdfVVNCX0M2N1gwMF9IQ0QgaXMgbm90IHNldApDT05GSUdfVVNCX1hI Q0lfSENEPXkKQ09ORklHX1VTQl9FSENJX0hDRD15CkNPTkZJR19VU0JfRUhDSV9ST09UX0hV Ql9UVD15CkNPTkZJR19VU0JfRUhDSV9UVF9ORVdTQ0hFRD15CkNPTkZJR19VU0JfRUhDSV9Q Q0k9eQojIENPTkZJR19VU0JfRUhDSV9IQ0RfUExBVEZPUk0gaXMgbm90IHNldAojIENPTkZJ R19VU0JfT1hVMjEwSFBfSENEIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX0lTUDExNlhfSENE IGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX0lTUDE3NjBfSENEIGlzIG5vdCBzZXQKIyBDT05G SUdfVVNCX0lTUDEzNjJfSENEIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX0ZVU0JIMjAwX0hD RCBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9GT1RHMjEwX0hDRCBpcyBub3Qgc2V0CkNPTkZJ R19VU0JfT0hDSV9IQ0Q9eQpDT05GSUdfVVNCX09IQ0lfSENEX1BDST15CiMgQ09ORklHX1VT Ql9PSENJX0hDRF9QTEFURk9STSBpcyBub3Qgc2V0CkNPTkZJR19VU0JfVUhDSV9IQ0Q9eQoj IENPTkZJR19VU0JfU0w4MTFfSENEIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX1I4QTY2NTk3 X0hDRCBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9IQ0RfVEVTVF9NT0RFIGlzIG5vdCBzZXQK CiMKIyBVU0IgRGV2aWNlIENsYXNzIGRyaXZlcnMKIwojIENPTkZJR19VU0JfQUNNIGlzIG5v dCBzZXQKQ09ORklHX1VTQl9QUklOVEVSPXkKIyBDT05GSUdfVVNCX1dETSBpcyBub3Qgc2V0 CiMgQ09ORklHX1VTQl9UTUMgaXMgbm90IHNldAoKIwojIE5PVEU6IFVTQl9TVE9SQUdFIGRl cGVuZHMgb24gU0NTSSBidXQgQkxLX0RFVl9TRCBtYXkKIwoKIwojIGFsc28gYmUgbmVlZGVk OyBzZWUgVVNCX1NUT1JBR0UgSGVscCBmb3IgbW9yZSBpbmZvCiMKQ09ORklHX1VTQl9TVE9S QUdFPXkKIyBDT05GSUdfVVNCX1NUT1JBR0VfREVCVUcgaXMgbm90IHNldAojIENPTkZJR19V U0JfU1RPUkFHRV9SRUFMVEVLIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX1NUT1JBR0VfREFU QUZBQiBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9TVE9SQUdFX0ZSRUVDT00gaXMgbm90IHNl dAojIENPTkZJR19VU0JfU1RPUkFHRV9JU0QyMDAgaXMgbm90IHNldAojIENPTkZJR19VU0Jf U1RPUkFHRV9VU0JBVCBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9TVE9SQUdFX1NERFIwOSBp cyBub3Qgc2V0CiMgQ09ORklHX1VTQl9TVE9SQUdFX1NERFI1NSBpcyBub3Qgc2V0CiMgQ09O RklHX1VTQl9TVE9SQUdFX0pVTVBTSE9UIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX1NUT1JB R0VfQUxBVURBIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX1NUT1JBR0VfT05FVE9VQ0ggaXMg bm90IHNldAojIENPTkZJR19VU0JfU1RPUkFHRV9LQVJNQSBpcyBub3Qgc2V0CiMgQ09ORklH X1VTQl9TVE9SQUdFX0NZUFJFU1NfQVRBQ0IgaXMgbm90IHNldAojIENPTkZJR19VU0JfU1RP UkFHRV9FTkVfVUI2MjUwIGlzIG5vdCBzZXQKCiMKIyBVU0IgSW1hZ2luZyBkZXZpY2VzCiMK IyBDT05GSUdfVVNCX01EQzgwMCBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9NSUNST1RFSyBp cyBub3Qgc2V0CiMgQ09ORklHX1VTQl9EV0MzIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX0NI SVBJREVBIGlzIG5vdCBzZXQKCiMKIyBVU0IgcG9ydCBkcml2ZXJzCiMKQ09ORklHX1VTQl9T RVJJQUw9eQojIENPTkZJR19VU0JfU0VSSUFMX0NPTlNPTEUgaXMgbm90IHNldAojIENPTkZJ R19VU0JfU0VSSUFMX0dFTkVSSUMgaXMgbm90IHNldAojIENPTkZJR19VU0JfU0VSSUFMX1NJ TVBMRSBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9TRVJJQUxfQUlSQ0FCTEUgaXMgbm90IHNl dAojIENPTkZJR19VU0JfU0VSSUFMX0FSSzMxMTYgaXMgbm90IHNldAojIENPTkZJR19VU0Jf U0VSSUFMX0JFTEtJTiBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9TRVJJQUxfQ0gzNDEgaXMg bm90IHNldAojIENPTkZJR19VU0JfU0VSSUFMX1dISVRFSEVBVCBpcyBub3Qgc2V0CiMgQ09O RklHX1VTQl9TRVJJQUxfRElHSV9BQ0NFTEVQT1JUIGlzIG5vdCBzZXQKQ09ORklHX1VTQl9T RVJJQUxfQ1AyMTBYPXkKQ09ORklHX1VTQl9TRVJJQUxfQ1lQUkVTU19NOD15CiMgQ09ORklH X1VTQl9TRVJJQUxfRU1QRUcgaXMgbm90IHNldAojIENPTkZJR19VU0JfU0VSSUFMX0ZURElf U0lPIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX1NFUklBTF9WSVNPUiBpcyBub3Qgc2V0CiMg Q09ORklHX1VTQl9TRVJJQUxfSVBBUSBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9TRVJJQUxf SVIgaXMgbm90IHNldAojIENPTkZJR19VU0JfU0VSSUFMX0VER0VQT1JUIGlzIG5vdCBzZXQK IyBDT05GSUdfVVNCX1NFUklBTF9FREdFUE9SVF9USSBpcyBub3Qgc2V0CiMgQ09ORklHX1VT Ql9TRVJJQUxfRjgxMjMyIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX1NFUklBTF9HQVJNSU4g aXMgbm90IHNldAojIENPTkZJR19VU0JfU0VSSUFMX0lQVyBpcyBub3Qgc2V0CiMgQ09ORklH X1VTQl9TRVJJQUxfSVVVIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX1NFUklBTF9LRVlTUEFO X1BEQSBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9TRVJJQUxfS0VZU1BBTiBpcyBub3Qgc2V0 CiMgQ09ORklHX1VTQl9TRVJJQUxfS0xTSSBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9TRVJJ QUxfS09CSUxfU0NUIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX1NFUklBTF9NQ1RfVTIzMiBp cyBub3Qgc2V0CiMgQ09ORklHX1VTQl9TRVJJQUxfTUVUUk8gaXMgbm90IHNldApDT05GSUdf VVNCX1NFUklBTF9NT1M3NzIwPXkKQ09ORklHX1VTQl9TRVJJQUxfTU9TNzg0MD15CiMgQ09O RklHX1VTQl9TRVJJQUxfTkFWTUFOIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX1NFUklBTF9Q TDIzMDMgaXMgbm90IHNldAojIENPTkZJR19VU0JfU0VSSUFMX09USTY4NTggaXMgbm90IHNl dAojIENPTkZJR19VU0JfU0VSSUFMX1FDQVVYIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX1NF UklBTF9RVUFMQ09NTSBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9TRVJJQUxfU1BDUDhYNSBp cyBub3Qgc2V0CiMgQ09ORklHX1VTQl9TRVJJQUxfU0FGRSBpcyBub3Qgc2V0CiMgQ09ORklH X1VTQl9TRVJJQUxfU0lFUlJBV0lSRUxFU1MgaXMgbm90IHNldAojIENPTkZJR19VU0JfU0VS SUFMX1NZTUJPTCBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9TRVJJQUxfVEkgaXMgbm90IHNl dAojIENPTkZJR19VU0JfU0VSSUFMX0NZQkVSSkFDSyBpcyBub3Qgc2V0CiMgQ09ORklHX1VT Ql9TRVJJQUxfWElSQ09NIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX1NFUklBTF9PUFRJT04g aXMgbm90IHNldAojIENPTkZJR19VU0JfU0VSSUFMX09NTklORVQgaXMgbm90IHNldAojIENP TkZJR19VU0JfU0VSSUFMX09QVElDT04gaXMgbm90IHNldAojIENPTkZJR19VU0JfU0VSSUFM X1hTRU5TX01UIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX1NFUklBTF9XSVNIQk9ORSBpcyBu b3Qgc2V0CiMgQ09ORklHX1VTQl9TRVJJQUxfWlRFIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNC X1NFUklBTF9TU1UxMDAgaXMgbm90IHNldAojIENPTkZJR19VU0JfU0VSSUFMX1FUMiBpcyBu b3Qgc2V0CiMgQ09ORklHX1VTQl9TRVJJQUxfREVCVUcgaXMgbm90IHNldAoKIwojIFVTQiBN aXNjZWxsYW5lb3VzIGRyaXZlcnMKIwojIENPTkZJR19VU0JfRU1JNjIgaXMgbm90IHNldAoj IENPTkZJR19VU0JfRU1JMjYgaXMgbm90IHNldAojIENPTkZJR19VU0JfQURVVFVYIGlzIG5v dCBzZXQKIyBDT05GSUdfVVNCX1NFVlNFRyBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9SSU81 MDAgaXMgbm90IHNldAojIENPTkZJR19VU0JfTEVHT1RPV0VSIGlzIG5vdCBzZXQKIyBDT05G SUdfVVNCX0xDRCBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9MRUQgaXMgbm90IHNldAojIENP TkZJR19VU0JfQ1lQUkVTU19DWTdDNjMgaXMgbm90IHNldAojIENPTkZJR19VU0JfQ1lUSEVS TSBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9JRE1PVVNFIGlzIG5vdCBzZXQKIyBDT05GSUdf VVNCX0ZURElfRUxBTiBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9BUFBMRURJU1BMQVkgaXMg bm90IHNldAojIENPTkZJR19VU0JfU0lTVVNCVkdBIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNC X0xEIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX1RSQU5DRVZJQlJBVE9SIGlzIG5vdCBzZXQK IyBDT05GSUdfVVNCX0lPV0FSUklPUiBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9URVNUIGlz IG5vdCBzZXQKIyBDT05GSUdfVVNCX0VIU0VUX1RFU1RfRklYVFVSRSBpcyBub3Qgc2V0CiMg Q09ORklHX1VTQl9JU0lHSFRGVyBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9ZVVJFWCBpcyBu b3Qgc2V0CiMgQ09ORklHX1VTQl9FWlVTQl9GWDIgaXMgbm90IHNldAojIENPTkZJR19VU0Jf SFNJQ19VU0IzNTAzIGlzIG5vdCBzZXQKCiMKIyBVU0IgUGh5c2ljYWwgTGF5ZXIgZHJpdmVy cwojCiMgQ09ORklHX1VTQl9QSFkgaXMgbm90IHNldAojIENPTkZJR19OT1BfVVNCX1hDRUlW IGlzIG5vdCBzZXQKIyBDT05GSUdfU0FNU1VOR19VU0IyUEhZIGlzIG5vdCBzZXQKIyBDT05G SUdfU0FNU1VOR19VU0IzUEhZIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX0lTUDEzMDEgaXMg bm90IHNldAojIENPTkZJR19VU0JfUkNBUl9QSFkgaXMgbm90IHNldAojIENPTkZJR19VU0Jf R0FER0VUIGlzIG5vdCBzZXQKIyBDT05GSUdfVVdCIGlzIG5vdCBzZXQKIyBDT05GSUdfTU1D IGlzIG5vdCBzZXQKIyBDT05GSUdfTUVNU1RJQ0sgaXMgbm90IHNldApDT05GSUdfTkVXX0xF RFM9eQpDT05GSUdfTEVEU19DTEFTUz15CgojCiMgTEVEIGRyaXZlcnMKIwojIENPTkZJR19M RURTX0xNMzUzMCBpcyBub3Qgc2V0CiMgQ09ORklHX0xFRFNfTE0zNjQyIGlzIG5vdCBzZXQK IyBDT05GSUdfTEVEU19QQ0E5NTMyIGlzIG5vdCBzZXQKIyBDT05GSUdfTEVEU19MUDM5NDQg aXMgbm90IHNldAojIENPTkZJR19MRURTX0xQNTUyMSBpcyBub3Qgc2V0CiMgQ09ORklHX0xF RFNfTFA1NTIzIGlzIG5vdCBzZXQKIyBDT05GSUdfTEVEU19MUDU1NjIgaXMgbm90IHNldAoj IENPTkZJR19MRURTX0xQODUwMSBpcyBub3Qgc2V0CiMgQ09ORklHX0xFRFNfQ0xFVk9fTUFJ TCBpcyBub3Qgc2V0CiMgQ09ORklHX0xFRFNfUENBOTU1WCBpcyBub3Qgc2V0CiMgQ09ORklH X0xFRFNfUENBOTYzWCBpcyBub3Qgc2V0CiMgQ09ORklHX0xFRFNfUENBOTY4NSBpcyBub3Qg c2V0CiMgQ09ORklHX0xFRFNfQkQyODAyIGlzIG5vdCBzZXQKIyBDT05GSUdfTEVEU19JTlRF TF9TUzQyMDAgaXMgbm90IHNldAojIENPTkZJR19MRURTX1RDQTY1MDcgaXMgbm90IHNldAoj IENPTkZJR19MRURTX0xNMzU1eCBpcyBub3Qgc2V0CiMgQ09ORklHX0xFRFNfT1QyMDAgaXMg bm90IHNldAojIENPTkZJR19MRURTX0JMSU5LTSBpcyBub3Qgc2V0CgojCiMgTEVEIFRyaWdn ZXJzCiMKIyBDT05GSUdfTEVEU19UUklHR0VSUyBpcyBub3Qgc2V0CiMgQ09ORklHX0FDQ0VT U0lCSUxJVFkgaXMgbm90IHNldAojIENPTkZJR19JTkZJTklCQU5EIGlzIG5vdCBzZXQKIyBD T05GSUdfRURBQyBpcyBub3Qgc2V0CkNPTkZJR19SVENfTElCPXkKQ09ORklHX1JUQ19DTEFT Uz15CkNPTkZJR19SVENfSENUT1NZUz15CkNPTkZJR19SVENfU1lTVE9IQz15CkNPTkZJR19S VENfSENUT1NZU19ERVZJQ0U9InJ0YzAiCiMgQ09ORklHX1JUQ19ERUJVRyBpcyBub3Qgc2V0 CgojCiMgUlRDIGludGVyZmFjZXMKIwpDT05GSUdfUlRDX0lOVEZfU1lTRlM9eQpDT05GSUdf UlRDX0lOVEZfUFJPQz15CkNPTkZJR19SVENfSU5URl9ERVY9eQojIENPTkZJR19SVENfSU5U Rl9ERVZfVUlFX0VNVUwgaXMgbm90IHNldAojIENPTkZJR19SVENfRFJWX1RFU1QgaXMgbm90 IHNldAoKIwojIEkyQyBSVEMgZHJpdmVycwojCiMgQ09ORklHX1JUQ19EUlZfRFMxMzA3IGlz IG5vdCBzZXQKIyBDT05GSUdfUlRDX0RSVl9EUzEzNzQgaXMgbm90IHNldAojIENPTkZJR19S VENfRFJWX0RTMTY3MiBpcyBub3Qgc2V0CiMgQ09ORklHX1JUQ19EUlZfRFMzMjMyIGlzIG5v dCBzZXQKIyBDT05GSUdfUlRDX0RSVl9NQVg2OTAwIGlzIG5vdCBzZXQKIyBDT05GSUdfUlRD X0RSVl9SUzVDMzcyIGlzIG5vdCBzZXQKIyBDT05GSUdfUlRDX0RSVl9JU0wxMjA4IGlzIG5v dCBzZXQKIyBDT05GSUdfUlRDX0RSVl9JU0wxMjAyMiBpcyBub3Qgc2V0CiMgQ09ORklHX1JU Q19EUlZfWDEyMDUgaXMgbm90IHNldAojIENPTkZJR19SVENfRFJWX1BDRjIxMjcgaXMgbm90 IHNldAojIENPTkZJR19SVENfRFJWX1BDRjg1MjMgaXMgbm90IHNldAojIENPTkZJR19SVENf RFJWX1BDRjg1NjMgaXMgbm90IHNldAojIENPTkZJR19SVENfRFJWX1BDRjg1ODMgaXMgbm90 IHNldAojIENPTkZJR19SVENfRFJWX000MVQ4MCBpcyBub3Qgc2V0CiMgQ09ORklHX1JUQ19E UlZfQlEzMksgaXMgbm90IHNldAojIENPTkZJR19SVENfRFJWX1MzNTM5MEEgaXMgbm90IHNl dAojIENPTkZJR19SVENfRFJWX0ZNMzEzMCBpcyBub3Qgc2V0CiMgQ09ORklHX1JUQ19EUlZf Ulg4NTgxIGlzIG5vdCBzZXQKIyBDT05GSUdfUlRDX0RSVl9SWDgwMjUgaXMgbm90IHNldAoj IENPTkZJR19SVENfRFJWX0VNMzAyNyBpcyBub3Qgc2V0CiMgQ09ORklHX1JUQ19EUlZfUlYz MDI5QzIgaXMgbm90IHNldAoKIwojIFNQSSBSVEMgZHJpdmVycwojCgojCiMgUGxhdGZvcm0g UlRDIGRyaXZlcnMKIwpDT05GSUdfUlRDX0RSVl9DTU9TPXkKIyBDT05GSUdfUlRDX0RSVl9E UzEyODYgaXMgbm90IHNldAojIENPTkZJR19SVENfRFJWX0RTMTUxMSBpcyBub3Qgc2V0CiMg Q09ORklHX1JUQ19EUlZfRFMxNTUzIGlzIG5vdCBzZXQKIyBDT05GSUdfUlRDX0RSVl9EUzE3 NDIgaXMgbm90IHNldAojIENPTkZJR19SVENfRFJWX1NUSzE3VEE4IGlzIG5vdCBzZXQKIyBD T05GSUdfUlRDX0RSVl9NNDhUODYgaXMgbm90IHNldAojIENPTkZJR19SVENfRFJWX000OFQz NSBpcyBub3Qgc2V0CiMgQ09ORklHX1JUQ19EUlZfTTQ4VDU5IGlzIG5vdCBzZXQKIyBDT05G SUdfUlRDX0RSVl9NU002MjQyIGlzIG5vdCBzZXQKIyBDT05GSUdfUlRDX0RSVl9CUTQ4MDIg aXMgbm90IHNldAojIENPTkZJR19SVENfRFJWX1JQNUMwMSBpcyBub3Qgc2V0CiMgQ09ORklH X1JUQ19EUlZfVjMwMjAgaXMgbm90IHNldAojIENPTkZJR19SVENfRFJWX0RTMjQwNCBpcyBu b3Qgc2V0CgojCiMgb24tQ1BVIFJUQyBkcml2ZXJzCiMKIyBDT05GSUdfUlRDX0RSVl9NT1hB UlQgaXMgbm90IHNldAoKIwojIEhJRCBTZW5zb3IgUlRDIGRyaXZlcnMKIwojIENPTkZJR19S VENfRFJWX0hJRF9TRU5TT1JfVElNRSBpcyBub3Qgc2V0CiMgQ09ORklHX0RNQURFVklDRVMg aXMgbm90IHNldAojIENPTkZJR19BVVhESVNQTEFZIGlzIG5vdCBzZXQKIyBDT05GSUdfVUlP IGlzIG5vdCBzZXQKIyBDT05GSUdfVkZJTyBpcyBub3Qgc2V0CiMgQ09ORklHX1ZJUlRfRFJJ VkVSUyBpcyBub3Qgc2V0CgojCiMgVmlydGlvIGRyaXZlcnMKIwojIENPTkZJR19WSVJUSU9f UENJIGlzIG5vdCBzZXQKIyBDT05GSUdfVklSVElPX01NSU8gaXMgbm90IHNldAoKIwojIE1p Y3Jvc29mdCBIeXBlci1WIGd1ZXN0IHN1cHBvcnQKIwojIENPTkZJR19IWVBFUlYgaXMgbm90 IHNldAoKIwojIFhlbiBkcml2ZXIgc3VwcG9ydAojCkNPTkZJR19YRU5fQkFMTE9PTj15CkNP TkZJR19YRU5fU0NSVUJfUEFHRVM9eQpDT05GSUdfWEVOX0RFVl9FVlRDSE49eQpDT05GSUdf WEVOX0JBQ0tFTkQ9eQpDT05GSUdfWEVORlM9eQpDT05GSUdfWEVOX0NPTVBBVF9YRU5GUz15 CkNPTkZJR19YRU5fU1lTX0hZUEVSVklTT1I9eQpDT05GSUdfWEVOX1hFTkJVU19GUk9OVEVO RD15CkNPTkZJR19YRU5fR05UREVWPXkKQ09ORklHX1hFTl9HUkFOVF9ERVZfQUxMT0M9eQpD T05GSUdfU1dJT1RMQl9YRU49eQpDT05GSUdfWEVOX1BDSURFVl9CQUNLRU5EPXkKQ09ORklH X1hFTl9QUklWQ01EPXkKQ09ORklHX1hFTl9BQ1BJX1BST0NFU1NPUj15CiMgQ09ORklHX1hF Tl9NQ0VfTE9HIGlzIG5vdCBzZXQKQ09ORklHX1hFTl9IQVZFX1BWTU1VPXkKIyBDT05GSUdf U1RBR0lORyBpcyBub3Qgc2V0CiMgQ09ORklHX1g4Nl9QTEFURk9STV9ERVZJQ0VTIGlzIG5v dCBzZXQKIyBDT05GSUdfQ0hST01FX1BMQVRGT1JNUyBpcyBub3Qgc2V0CgojCiMgSGFyZHdh cmUgU3BpbmxvY2sgZHJpdmVycwojCkNPTkZJR19DTEtFVlRfSTgyNTM9eQpDT05GSUdfSTgy NTNfTE9DSz15CkNPTkZJR19DTEtCTERfSTgyNTM9eQojIENPTkZJR19NQUlMQk9YIGlzIG5v dCBzZXQKQ09ORklHX0lPTU1VX0FQST15CkNPTkZJR19JT01NVV9TVVBQT1JUPXkKQ09ORklH X0FNRF9JT01NVT15CkNPTkZJR19BTURfSU9NTVVfU1RBVFM9eQpDT05GSUdfRE1BUl9UQUJM RT15CiMgQ09ORklHX0lOVEVMX0lPTU1VIGlzIG5vdCBzZXQKQ09ORklHX0lSUV9SRU1BUD15 CgojCiMgUmVtb3RlcHJvYyBkcml2ZXJzCiMKIyBDT05GSUdfU1RFX01PREVNX1JQUk9DIGlz IG5vdCBzZXQKCiMKIyBScG1zZyBkcml2ZXJzCiMKIyBDT05GSUdfUE1fREVWRlJFUSBpcyBu b3Qgc2V0CiMgQ09ORklHX0VYVENPTiBpcyBub3Qgc2V0CiMgQ09ORklHX01FTU9SWSBpcyBu b3Qgc2V0CiMgQ09ORklHX0lJTyBpcyBub3Qgc2V0CiMgQ09ORklHX05UQiBpcyBub3Qgc2V0 CiMgQ09ORklHX1ZNRV9CVVMgaXMgbm90IHNldAojIENPTkZJR19QV00gaXMgbm90IHNldAoj IENPTkZJR19JUEFDS19CVVMgaXMgbm90IHNldAojIENPTkZJR19SRVNFVF9DT05UUk9MTEVS IGlzIG5vdCBzZXQKIyBDT05GSUdfRk1DIGlzIG5vdCBzZXQKCiMKIyBQSFkgU3Vic3lzdGVt CiMKQ09ORklHX0dFTkVSSUNfUEhZPXkKIyBDT05GSUdfUEhZX0VYWU5PU19NSVBJX1ZJREVP IGlzIG5vdCBzZXQKIyBDT05GSUdfUE9XRVJDQVAgaXMgbm90IHNldAoKIwojIEZpcm13YXJl IERyaXZlcnMKIwojIENPTkZJR19FREQgaXMgbm90IHNldApDT05GSUdfRklSTVdBUkVfTUVN TUFQPXkKIyBDT05GSUdfREVMTF9SQlUgaXMgbm90IHNldAojIENPTkZJR19EQ0RCQVMgaXMg bm90IHNldApDT05GSUdfRE1JSUQ9eQpDT05GSUdfRE1JX1NZU0ZTPXkKIyBDT05GSUdfSVND U0lfSUJGVF9GSU5EIGlzIG5vdCBzZXQKIyBDT05GSUdfR09PR0xFX0ZJUk1XQVJFIGlzIG5v dCBzZXQKCiMKIyBGaWxlIHN5c3RlbXMKIwpDT05GSUdfRENBQ0hFX1dPUkRfQUNDRVNTPXkK IyBDT05GSUdfRVhUMl9GUyBpcyBub3Qgc2V0CkNPTkZJR19FWFQzX0ZTPXkKIyBDT05GSUdf RVhUM19ERUZBVUxUU19UT19PUkRFUkVEIGlzIG5vdCBzZXQKQ09ORklHX0VYVDNfRlNfWEFU VFI9eQpDT05GSUdfRVhUM19GU19QT1NJWF9BQ0w9eQpDT05GSUdfRVhUM19GU19TRUNVUklU WT15CkNPTkZJR19FWFQ0X0ZTPXkKQ09ORklHX0VYVDRfVVNFX0ZPUl9FWFQyMz15CiMgQ09O RklHX0VYVDRfRlNfUE9TSVhfQUNMIGlzIG5vdCBzZXQKIyBDT05GSUdfRVhUNF9GU19TRUNV UklUWSBpcyBub3Qgc2V0CkNPTkZJR19FWFQ0X0RFQlVHPXkKQ09ORklHX0pCRD15CiMgQ09O RklHX0pCRF9ERUJVRyBpcyBub3Qgc2V0CkNPTkZJR19KQkQyPXkKQ09ORklHX0pCRDJfREVC VUc9eQpDT05GSUdfRlNfTUJDQUNIRT15CiMgQ09ORklHX1JFSVNFUkZTX0ZTIGlzIG5vdCBz ZXQKIyBDT05GSUdfSkZTX0ZTIGlzIG5vdCBzZXQKIyBDT05GSUdfWEZTX0ZTIGlzIG5vdCBz ZXQKQ09ORklHX0dGUzJfRlM9eQpDT05GSUdfQlRSRlNfRlM9eQpDT05GSUdfQlRSRlNfRlNf UE9TSVhfQUNMPXkKIyBDT05GSUdfQlRSRlNfRlNfQ0hFQ0tfSU5URUdSSVRZIGlzIG5vdCBz ZXQKIyBDT05GSUdfQlRSRlNfRlNfUlVOX1NBTklUWV9URVNUUyBpcyBub3Qgc2V0CiMgQ09O RklHX0JUUkZTX0RFQlVHIGlzIG5vdCBzZXQKIyBDT05GSUdfQlRSRlNfQVNTRVJUIGlzIG5v dCBzZXQKIyBDT05GSUdfTklMRlMyX0ZTIGlzIG5vdCBzZXQKQ09ORklHX0ZTX1BPU0lYX0FD TD15CkNPTkZJR19GSUxFX0xPQ0tJTkc9eQpDT05GSUdfRlNOT1RJRlk9eQpDT05GSUdfRE5P VElGWT15CkNPTkZJR19JTk9USUZZX1VTRVI9eQpDT05GSUdfRkFOT1RJRlk9eQpDT05GSUdf UVVPVEE9eQpDT05GSUdfUVVPVEFfTkVUTElOS19JTlRFUkZBQ0U9eQojIENPTkZJR19QUklO VF9RVU9UQV9XQVJOSU5HIGlzIG5vdCBzZXQKIyBDT05GSUdfUVVPVEFfREVCVUcgaXMgbm90 IHNldApDT05GSUdfUVVPVEFfVFJFRT15CiMgQ09ORklHX1FGTVRfVjEgaXMgbm90IHNldApD T05GSUdfUUZNVF9WMj15CkNPTkZJR19RVU9UQUNUTD15CkNPTkZJR19RVU9UQUNUTF9DT01Q QVQ9eQpDT05GSUdfQVVUT0ZTNF9GUz15CkNPTkZJR19GVVNFX0ZTPXkKIyBDT05GSUdfQ1VT RSBpcyBub3Qgc2V0CkNPTkZJR19HRU5FUklDX0FDTD15CgojCiMgQ2FjaGVzCiMKQ09ORklH X0ZTQ0FDSEU9eQpDT05GSUdfRlNDQUNIRV9TVEFUUz15CkNPTkZJR19GU0NBQ0hFX0hJU1RP R1JBTT15CiMgQ09ORklHX0ZTQ0FDSEVfREVCVUcgaXMgbm90IHNldAojIENPTkZJR19GU0NB Q0hFX09CSkVDVF9MSVNUIGlzIG5vdCBzZXQKIyBDT05GSUdfQ0FDSEVGSUxFUyBpcyBub3Qg c2V0CgojCiMgQ0QtUk9NL0RWRCBGaWxlc3lzdGVtcwojCkNPTkZJR19JU085NjYwX0ZTPXkK Q09ORklHX0pPTElFVD15CkNPTkZJR19aSVNPRlM9eQpDT05GSUdfVURGX0ZTPXkKQ09ORklH X1VERl9OTFM9eQoKIwojIERPUy9GQVQvTlQgRmlsZXN5c3RlbXMKIwpDT05GSUdfRkFUX0ZT PXkKQ09ORklHX01TRE9TX0ZTPXkKQ09ORklHX1ZGQVRfRlM9eQpDT05GSUdfRkFUX0RFRkFV TFRfQ09ERVBBR0U9NDM3CkNPTkZJR19GQVRfREVGQVVMVF9JT0NIQVJTRVQ9Imlzbzg4NTkt MSIKQ09ORklHX05URlNfRlM9eQojIENPTkZJR19OVEZTX0RFQlVHIGlzIG5vdCBzZXQKQ09O RklHX05URlNfUlc9eQoKIwojIFBzZXVkbyBmaWxlc3lzdGVtcwojCkNPTkZJR19QUk9DX0ZT PXkKQ09ORklHX1BST0NfS0NPUkU9eQpDT05GSUdfUFJPQ19WTUNPUkU9eQpDT05GSUdfUFJP Q19TWVNDVEw9eQpDT05GSUdfUFJPQ19QQUdFX01PTklUT1I9eQpDT05GSUdfU1lTRlM9eQpD T05GSUdfVE1QRlM9eQpDT05GSUdfVE1QRlNfUE9TSVhfQUNMPXkKQ09ORklHX1RNUEZTX1hB VFRSPXkKQ09ORklHX0hVR0VUTEJGUz15CkNPTkZJR19IVUdFVExCX1BBR0U9eQojIENPTkZJ R19DT05GSUdGU19GUyBpcyBub3Qgc2V0CiMgQ09ORklHX01JU0NfRklMRVNZU1RFTVMgaXMg bm90IHNldApDT05GSUdfTkVUV09SS19GSUxFU1lTVEVNUz15CiMgQ09ORklHX05GU19GUyBp cyBub3Qgc2V0CiMgQ09ORklHX05GU0QgaXMgbm90IHNldApDT05GSUdfQ0VQSF9GUz15CiMg Q09ORklHX0NFUEhfRlNDQUNIRSBpcyBub3Qgc2V0CkNPTkZJR19DSUZTPXkKIyBDT05GSUdf Q0lGU19TVEFUUyBpcyBub3Qgc2V0CiMgQ09ORklHX0NJRlNfV0VBS19QV19IQVNIIGlzIG5v dCBzZXQKIyBDT05GSUdfQ0lGU19VUENBTEwgaXMgbm90IHNldAojIENPTkZJR19DSUZTX1hB VFRSIGlzIG5vdCBzZXQKQ09ORklHX0NJRlNfREVCVUc9eQojIENPTkZJR19DSUZTX0RFQlVH MiBpcyBub3Qgc2V0CiMgQ09ORklHX0NJRlNfREZTX1VQQ0FMTCBpcyBub3Qgc2V0CiMgQ09O RklHX0NJRlNfU01CMiBpcyBub3Qgc2V0CiMgQ09ORklHX0NJRlNfRlNDQUNIRSBpcyBub3Qg c2V0CiMgQ09ORklHX05DUF9GUyBpcyBub3Qgc2V0CiMgQ09ORklHX0NPREFfRlMgaXMgbm90 IHNldAojIENPTkZJR19BRlNfRlMgaXMgbm90IHNldApDT05GSUdfTkxTPXkKQ09ORklHX05M U19ERUZBVUxUPSJ1dGY4IgpDT05GSUdfTkxTX0NPREVQQUdFXzQzNz15CiMgQ09ORklHX05M U19DT0RFUEFHRV83MzcgaXMgbm90IHNldAojIENPTkZJR19OTFNfQ09ERVBBR0VfNzc1IGlz IG5vdCBzZXQKIyBDT05GSUdfTkxTX0NPREVQQUdFXzg1MCBpcyBub3Qgc2V0CiMgQ09ORklH X05MU19DT0RFUEFHRV84NTIgaXMgbm90IHNldAojIENPTkZJR19OTFNfQ09ERVBBR0VfODU1 IGlzIG5vdCBzZXQKIyBDT05GSUdfTkxTX0NPREVQQUdFXzg1NyBpcyBub3Qgc2V0CiMgQ09O RklHX05MU19DT0RFUEFHRV84NjAgaXMgbm90IHNldAojIENPTkZJR19OTFNfQ09ERVBBR0Vf ODYxIGlzIG5vdCBzZXQKIyBDT05GSUdfTkxTX0NPREVQQUdFXzg2MiBpcyBub3Qgc2V0CiMg Q09ORklHX05MU19DT0RFUEFHRV84NjMgaXMgbm90IHNldAojIENPTkZJR19OTFNfQ09ERVBB R0VfODY0IGlzIG5vdCBzZXQKIyBDT05GSUdfTkxTX0NPREVQQUdFXzg2NSBpcyBub3Qgc2V0 CiMgQ09ORklHX05MU19DT0RFUEFHRV84NjYgaXMgbm90IHNldAojIENPTkZJR19OTFNfQ09E RVBBR0VfODY5IGlzIG5vdCBzZXQKIyBDT05GSUdfTkxTX0NPREVQQUdFXzkzNiBpcyBub3Qg c2V0CiMgQ09ORklHX05MU19DT0RFUEFHRV85NTAgaXMgbm90IHNldAojIENPTkZJR19OTFNf Q09ERVBBR0VfOTMyIGlzIG5vdCBzZXQKIyBDT05GSUdfTkxTX0NPREVQQUdFXzk0OSBpcyBu b3Qgc2V0CiMgQ09ORklHX05MU19DT0RFUEFHRV84NzQgaXMgbm90IHNldAojIENPTkZJR19O TFNfSVNPODg1OV84IGlzIG5vdCBzZXQKIyBDT05GSUdfTkxTX0NPREVQQUdFXzEyNTAgaXMg bm90IHNldAojIENPTkZJR19OTFNfQ09ERVBBR0VfMTI1MSBpcyBub3Qgc2V0CkNPTkZJR19O TFNfQVNDSUk9eQpDT05GSUdfTkxTX0lTTzg4NTlfMT15CiMgQ09ORklHX05MU19JU084ODU5 XzIgaXMgbm90IHNldAojIENPTkZJR19OTFNfSVNPODg1OV8zIGlzIG5vdCBzZXQKIyBDT05G SUdfTkxTX0lTTzg4NTlfNCBpcyBub3Qgc2V0CiMgQ09ORklHX05MU19JU084ODU5XzUgaXMg bm90IHNldAojIENPTkZJR19OTFNfSVNPODg1OV82IGlzIG5vdCBzZXQKIyBDT05GSUdfTkxT X0lTTzg4NTlfNyBpcyBub3Qgc2V0CiMgQ09ORklHX05MU19JU084ODU5XzkgaXMgbm90IHNl dAojIENPTkZJR19OTFNfSVNPODg1OV8xMyBpcyBub3Qgc2V0CiMgQ09ORklHX05MU19JU084 ODU5XzE0IGlzIG5vdCBzZXQKIyBDT05GSUdfTkxTX0lTTzg4NTlfMTUgaXMgbm90IHNldAoj IENPTkZJR19OTFNfS09JOF9SIGlzIG5vdCBzZXQKIyBDT05GSUdfTkxTX0tPSThfVSBpcyBu b3Qgc2V0CiMgQ09ORklHX05MU19NQUNfUk9NQU4gaXMgbm90IHNldAojIENPTkZJR19OTFNf TUFDX0NFTFRJQyBpcyBub3Qgc2V0CiMgQ09ORklHX05MU19NQUNfQ0VOVEVVUk8gaXMgbm90 IHNldAojIENPTkZJR19OTFNfTUFDX0NST0FUSUFOIGlzIG5vdCBzZXQKIyBDT05GSUdfTkxT X01BQ19DWVJJTExJQyBpcyBub3Qgc2V0CiMgQ09ORklHX05MU19NQUNfR0FFTElDIGlzIG5v dCBzZXQKIyBDT05GSUdfTkxTX01BQ19HUkVFSyBpcyBub3Qgc2V0CiMgQ09ORklHX05MU19N QUNfSUNFTEFORCBpcyBub3Qgc2V0CiMgQ09ORklHX05MU19NQUNfSU5VSVQgaXMgbm90IHNl dAojIENPTkZJR19OTFNfTUFDX1JPTUFOSUFOIGlzIG5vdCBzZXQKIyBDT05GSUdfTkxTX01B Q19UVVJLSVNIIGlzIG5vdCBzZXQKQ09ORklHX05MU19VVEY4PXkKCiMKIyBLZXJuZWwgaGFj a2luZwojCkNPTkZJR19UUkFDRV9JUlFGTEFHU19TVVBQT1JUPXkKCiMKIyBwcmludGsgYW5k IGRtZXNnIG9wdGlvbnMKIwpDT05GSUdfUFJJTlRLX1RJTUU9eQpDT05GSUdfREVGQVVMVF9N RVNTQUdFX0xPR0xFVkVMPTcKIyBDT05GSUdfQk9PVF9QUklOVEtfREVMQVkgaXMgbm90IHNl dAojIENPTkZJR19EWU5BTUlDX0RFQlVHIGlzIG5vdCBzZXQKCiMKIyBDb21waWxlLXRpbWUg Y2hlY2tzIGFuZCBjb21waWxlciBvcHRpb25zCiMKQ09ORklHX0RFQlVHX0lORk89eQojIENP TkZJR19ERUJVR19JTkZPX1JFRFVDRUQgaXMgbm90IHNldAojIENPTkZJR19FTkFCTEVfV0FS Tl9ERVBSRUNBVEVEIGlzIG5vdCBzZXQKIyBDT05GSUdfRU5BQkxFX01VU1RfQ0hFQ0sgaXMg bm90IHNldApDT05GSUdfRlJBTUVfV0FSTj0yMDQ4CiMgQ09ORklHX1NUUklQX0FTTV9TWU1T IGlzIG5vdCBzZXQKIyBDT05GSUdfUkVBREFCTEVfQVNNIGlzIG5vdCBzZXQKIyBDT05GSUdf VU5VU0VEX1NZTUJPTFMgaXMgbm90IHNldApDT05GSUdfREVCVUdfRlM9eQojIENPTkZJR19I RUFERVJTX0NIRUNLIGlzIG5vdCBzZXQKIyBDT05GSUdfREVCVUdfU0VDVElPTl9NSVNNQVRD SCBpcyBub3Qgc2V0CkNPTkZJR19BUkNIX1dBTlRfRlJBTUVfUE9JTlRFUlM9eQpDT05GSUdf RlJBTUVfUE9JTlRFUj15CiMgQ09ORklHX0RFQlVHX0ZPUkNFX1dFQUtfUEVSX0NQVSBpcyBu b3Qgc2V0CkNPTkZJR19NQUdJQ19TWVNSUT15CkNPTkZJR19NQUdJQ19TWVNSUV9ERUZBVUxU X0VOQUJMRT0weDEKQ09ORklHX0RFQlVHX0tFUk5FTD15CgojCiMgTWVtb3J5IERlYnVnZ2lu ZwojCiMgQ09ORklHX0RFQlVHX1BBR0VBTExPQyBpcyBub3Qgc2V0CiMgQ09ORklHX0RFQlVH X09CSkVDVFMgaXMgbm90IHNldAojIENPTkZJR19TTFVCX0RFQlVHX09OIGlzIG5vdCBzZXQK IyBDT05GSUdfU0xVQl9TVEFUUyBpcyBub3Qgc2V0CkNPTkZJR19IQVZFX0RFQlVHX0tNRU1M RUFLPXkKQ09ORklHX0RFQlVHX0tNRU1MRUFLPXkKQ09ORklHX0RFQlVHX0tNRU1MRUFLX0VB UkxZX0xPR19TSVpFPTQwMAojIENPTkZJR19ERUJVR19LTUVNTEVBS19URVNUIGlzIG5vdCBz ZXQKQ09ORklHX0RFQlVHX0tNRU1MRUFLX0RFRkFVTFRfT0ZGPXkKIyBDT05GSUdfREVCVUdf U1RBQ0tfVVNBR0UgaXMgbm90IHNldAojIENPTkZJR19ERUJVR19WTSBpcyBub3Qgc2V0CiMg Q09ORklHX0RFQlVHX1ZJUlRVQUwgaXMgbm90IHNldApDT05GSUdfREVCVUdfTUVNT1JZX0lO SVQ9eQojIENPTkZJR19ERUJVR19QRVJfQ1BVX01BUFMgaXMgbm90IHNldApDT05GSUdfSEFW RV9ERUJVR19TVEFDS09WRVJGTE9XPXkKIyBDT05GSUdfREVCVUdfU1RBQ0tPVkVSRkxPVyBp cyBub3Qgc2V0CkNPTkZJR19IQVZFX0FSQ0hfS01FTUNIRUNLPXkKQ09ORklHX0RFQlVHX1NI SVJRPXkKCiMKIyBEZWJ1ZyBMb2NrdXBzIGFuZCBIYW5ncwojCkNPTkZJR19MT0NLVVBfREVU RUNUT1I9eQpDT05GSUdfSEFSRExPQ0tVUF9ERVRFQ1RPUj15CiMgQ09ORklHX0JPT1RQQVJB TV9IQVJETE9DS1VQX1BBTklDIGlzIG5vdCBzZXQKQ09ORklHX0JPT1RQQVJBTV9IQVJETE9D S1VQX1BBTklDX1ZBTFVFPTAKIyBDT05GSUdfQk9PVFBBUkFNX1NPRlRMT0NLVVBfUEFOSUMg aXMgbm90IHNldApDT05GSUdfQk9PVFBBUkFNX1NPRlRMT0NLVVBfUEFOSUNfVkFMVUU9MApD T05GSUdfREVURUNUX0hVTkdfVEFTSz15CkNPTkZJR19ERUZBVUxUX0hVTkdfVEFTS19USU1F T1VUPTEyMAojIENPTkZJR19CT09UUEFSQU1fSFVOR19UQVNLX1BBTklDIGlzIG5vdCBzZXQK Q09ORklHX0JPT1RQQVJBTV9IVU5HX1RBU0tfUEFOSUNfVkFMVUU9MAojIENPTkZJR19QQU5J Q19PTl9PT1BTIGlzIG5vdCBzZXQKQ09ORklHX1BBTklDX09OX09PUFNfVkFMVUU9MAojIENP TkZJR19TQ0hFRF9ERUJVRyBpcyBub3Qgc2V0CkNPTkZJR19TQ0hFRFNUQVRTPXkKQ09ORklH X1RJTUVSX1NUQVRTPXkKCiMKIyBMb2NrIERlYnVnZ2luZyAoc3BpbmxvY2tzLCBtdXRleGVz LCBldGMuLi4pCiMKQ09ORklHX0RFQlVHX1JUX01VVEVYRVM9eQpDT05GSUdfREVCVUdfUElf TElTVD15CiMgQ09ORklHX1JUX01VVEVYX1RFU1RFUiBpcyBub3Qgc2V0CkNPTkZJR19ERUJV R19TUElOTE9DSz15CkNPTkZJR19ERUJVR19NVVRFWEVTPXkKIyBDT05GSUdfREVCVUdfV1df TVVURVhfU0xPV1BBVEggaXMgbm90IHNldApDT05GSUdfREVCVUdfTE9DS19BTExPQz15CkNP TkZJR19QUk9WRV9MT0NLSU5HPXkKQ09ORklHX0xPQ0tERVA9eQojIENPTkZJR19MT0NLX1NU QVQgaXMgbm90IHNldApDT05GSUdfREVCVUdfTE9DS0RFUD15CiMgQ09ORklHX0RFQlVHX0FU T01JQ19TTEVFUCBpcyBub3Qgc2V0CiMgQ09ORklHX0RFQlVHX0xPQ0tJTkdfQVBJX1NFTEZU RVNUUyBpcyBub3Qgc2V0CkNPTkZJR19UUkFDRV9JUlFGTEFHUz15CkNPTkZJR19TVEFDS1RS QUNFPXkKIyBDT05GSUdfREVCVUdfS09CSkVDVCBpcyBub3Qgc2V0CkNPTkZJR19ERUJVR19C VUdWRVJCT1NFPXkKQ09ORklHX0RFQlVHX1dSSVRFQ09VTlQ9eQpDT05GSUdfREVCVUdfTElT VD15CkNPTkZJR19ERUJVR19TRz15CiMgQ09ORklHX0RFQlVHX05PVElGSUVSUyBpcyBub3Qg c2V0CiMgQ09ORklHX0RFQlVHX0NSRURFTlRJQUxTIGlzIG5vdCBzZXQKCiMKIyBSQ1UgRGVi dWdnaW5nCiMKIyBDT05GSUdfUFJPVkVfUkNVIGlzIG5vdCBzZXQKQ09ORklHX1NQQVJTRV9S Q1VfUE9JTlRFUj15CiMgQ09ORklHX1JDVV9UT1JUVVJFX1RFU1QgaXMgbm90IHNldApDT05G SUdfUkNVX0NQVV9TVEFMTF9USU1FT1VUPTYwCkNPTkZJR19SQ1VfQ1BVX1NUQUxMX0lORk89 eQojIENPTkZJR19SQ1VfVFJBQ0UgaXMgbm90IHNldAojIENPTkZJR19ERUJVR19CTE9DS19F WFRfREVWVCBpcyBub3Qgc2V0CiMgQ09ORklHX05PVElGSUVSX0VSUk9SX0lOSkVDVElPTiBp cyBub3Qgc2V0CiMgQ09ORklHX0ZBVUxUX0lOSkVDVElPTiBpcyBub3Qgc2V0CiMgQ09ORklH X0xBVEVOQ1lUT1AgaXMgbm90IHNldApDT05GSUdfQVJDSF9IQVNfREVCVUdfU1RSSUNUX1VT RVJfQ09QWV9DSEVDS1M9eQojIENPTkZJR19ERUJVR19TVFJJQ1RfVVNFUl9DT1BZX0NIRUNL UyBpcyBub3Qgc2V0CkNPTkZJR19VU0VSX1NUQUNLVFJBQ0VfU1VQUE9SVD15CkNPTkZJR19O T1BfVFJBQ0VSPXkKQ09ORklHX0hBVkVfRlVOQ1RJT05fVFJBQ0VSPXkKQ09ORklHX0hBVkVf RlVOQ1RJT05fR1JBUEhfVFJBQ0VSPXkKQ09ORklHX0hBVkVfRlVOQ1RJT05fR1JBUEhfRlBf VEVTVD15CkNPTkZJR19IQVZFX0ZVTkNUSU9OX1RSQUNFX01DT1VOVF9URVNUPXkKQ09ORklH X0hBVkVfRFlOQU1JQ19GVFJBQ0U9eQpDT05GSUdfSEFWRV9EWU5BTUlDX0ZUUkFDRV9XSVRI X1JFR1M9eQpDT05GSUdfSEFWRV9GVFJBQ0VfTUNPVU5UX1JFQ09SRD15CkNPTkZJR19IQVZF X1NZU0NBTExfVFJBQ0VQT0lOVFM9eQpDT05GSUdfSEFWRV9GRU5UUlk9eQpDT05GSUdfSEFW RV9DX1JFQ09SRE1DT1VOVD15CkNPTkZJR19UUkFDRV9DTE9DSz15CkNPTkZJR19SSU5HX0JV RkZFUj15CkNPTkZJR19FVkVOVF9UUkFDSU5HPXkKQ09ORklHX0NPTlRFWFRfU1dJVENIX1RS QUNFUj15CkNPTkZJR19UUkFDSU5HPXkKQ09ORklHX0dFTkVSSUNfVFJBQ0VSPXkKQ09ORklH X1RSQUNJTkdfU1VQUE9SVD15CkNPTkZJR19GVFJBQ0U9eQpDT05GSUdfRlVOQ1RJT05fVFJB Q0VSPXkKQ09ORklHX0ZVTkNUSU9OX0dSQVBIX1RSQUNFUj15CiMgQ09ORklHX0lSUVNPRkZf VFJBQ0VSIGlzIG5vdCBzZXQKIyBDT05GSUdfU0NIRURfVFJBQ0VSIGlzIG5vdCBzZXQKIyBD T05GSUdfRlRSQUNFX1NZU0NBTExTIGlzIG5vdCBzZXQKIyBDT05GSUdfVFJBQ0VSX1NOQVBT SE9UIGlzIG5vdCBzZXQKQ09ORklHX0JSQU5DSF9QUk9GSUxFX05PTkU9eQojIENPTkZJR19Q Uk9GSUxFX0FOTk9UQVRFRF9CUkFOQ0hFUyBpcyBub3Qgc2V0CiMgQ09ORklHX1BST0ZJTEVf QUxMX0JSQU5DSEVTIGlzIG5vdCBzZXQKIyBDT05GSUdfU1RBQ0tfVFJBQ0VSIGlzIG5vdCBz ZXQKIyBDT05GSUdfQkxLX0RFVl9JT19UUkFDRSBpcyBub3Qgc2V0CiMgQ09ORklHX1VQUk9C RV9FVkVOVCBpcyBub3Qgc2V0CiMgQ09ORklHX1BST0JFX0VWRU5UUyBpcyBub3Qgc2V0CkNP TkZJR19EWU5BTUlDX0ZUUkFDRT15CkNPTkZJR19EWU5BTUlDX0ZUUkFDRV9XSVRIX1JFR1M9 eQojIENPTkZJR19GVU5DVElPTl9QUk9GSUxFUiBpcyBub3Qgc2V0CkNPTkZJR19GVFJBQ0Vf TUNPVU5UX1JFQ09SRD15CiMgQ09ORklHX0ZUUkFDRV9TVEFSVFVQX1RFU1QgaXMgbm90IHNl dAojIENPTkZJR19NTUlPVFJBQ0UgaXMgbm90IHNldAojIENPTkZJR19SSU5HX0JVRkZFUl9C RU5DSE1BUksgaXMgbm90IHNldAojIENPTkZJR19SSU5HX0JVRkZFUl9TVEFSVFVQX1RFU1Qg aXMgbm90IHNldAoKIwojIFJ1bnRpbWUgVGVzdGluZwojCiMgQ09ORklHX0xLRFRNIGlzIG5v dCBzZXQKIyBDT05GSUdfVEVTVF9MSVNUX1NPUlQgaXMgbm90IHNldAojIENPTkZJR19CQUNL VFJBQ0VfU0VMRl9URVNUIGlzIG5vdCBzZXQKIyBDT05GSUdfUkJUUkVFX1RFU1QgaXMgbm90 IHNldAojIENPTkZJR19JTlRFUlZBTF9UUkVFX1RFU1QgaXMgbm90IHNldAojIENPTkZJR19Q RVJDUFVfVEVTVCBpcyBub3Qgc2V0CiMgQ09ORklHX0FUT01JQzY0X1NFTEZURVNUIGlzIG5v dCBzZXQKIyBDT05GSUdfVEVTVF9TVFJJTkdfSEVMUEVSUyBpcyBub3Qgc2V0CiMgQ09ORklH X1RFU1RfS1NUUlRPWCBpcyBub3Qgc2V0CiMgQ09ORklHX1BST1ZJREVfT0hDSTEzOTRfRE1B X0lOSVQgaXMgbm90IHNldApDT05GSUdfRE1BX0FQSV9ERUJVRz15CiMgQ09ORklHX1NBTVBM RVMgaXMgbm90IHNldApDT05GSUdfSEFWRV9BUkNIX0tHREI9eQojIENPTkZJR19LR0RCIGlz IG5vdCBzZXQKIyBDT05GSUdfU1RSSUNUX0RFVk1FTSBpcyBub3Qgc2V0CkNPTkZJR19YODZf VkVSQk9TRV9CT09UVVA9eQpDT05GSUdfRUFSTFlfUFJJTlRLPXkKIyBDT05GSUdfRUFSTFlf UFJJTlRLX0RCR1AgaXMgbm90IHNldAojIENPTkZJR19YODZfUFREVU1QIGlzIG5vdCBzZXQK Q09ORklHX0RFQlVHX1JPREFUQT15CiMgQ09ORklHX0RFQlVHX1JPREFUQV9URVNUIGlzIG5v dCBzZXQKIyBDT05GSUdfREVCVUdfU0VUX01PRFVMRV9ST05YIGlzIG5vdCBzZXQKIyBDT05G SUdfREVCVUdfTlhfVEVTVCBpcyBub3Qgc2V0CkNPTkZJR19ET1VCTEVGQVVMVD15CiMgQ09O RklHX0RFQlVHX1RMQkZMVVNIIGlzIG5vdCBzZXQKQ09ORklHX0lPTU1VX0RFQlVHPXkKIyBD T05GSUdfSU9NTVVfU1RSRVNTIGlzIG5vdCBzZXQKIyBDT05GSUdfSU9NTVVfTEVBSyBpcyBu b3Qgc2V0CkNPTkZJR19IQVZFX01NSU9UUkFDRV9TVVBQT1JUPXkKQ09ORklHX0lPX0RFTEFZ X1RZUEVfMFg4MD0wCkNPTkZJR19JT19ERUxBWV9UWVBFXzBYRUQ9MQpDT05GSUdfSU9fREVM QVlfVFlQRV9VREVMQVk9MgpDT05GSUdfSU9fREVMQVlfVFlQRV9OT05FPTMKQ09ORklHX0lP X0RFTEFZXzBYODA9eQojIENPTkZJR19JT19ERUxBWV8wWEVEIGlzIG5vdCBzZXQKIyBDT05G SUdfSU9fREVMQVlfVURFTEFZIGlzIG5vdCBzZXQKIyBDT05GSUdfSU9fREVMQVlfTk9ORSBp cyBub3Qgc2V0CkNPTkZJR19ERUZBVUxUX0lPX0RFTEFZX1RZUEU9MApDT05GSUdfREVCVUdf Qk9PVF9QQVJBTVM9eQojIENPTkZJR19DUEFfREVCVUcgaXMgbm90IHNldAojIENPTkZJR19P UFRJTUlaRV9JTkxJTklORyBpcyBub3Qgc2V0CiMgQ09ORklHX0RFQlVHX05NSV9TRUxGVEVT VCBpcyBub3Qgc2V0CiMgQ09ORklHX1g4Nl9ERUJVR19TVEFUSUNfQ1BVX0hBUyBpcyBub3Qg c2V0CgojCiMgU2VjdXJpdHkgb3B0aW9ucwojCkNPTkZJR19LRVlTPXkKIyBDT05GSUdfUEVS U0lTVEVOVF9LRVlSSU5HUyBpcyBub3Qgc2V0CiMgQ09ORklHX0JJR19LRVlTIGlzIG5vdCBz ZXQKIyBDT05GSUdfRU5DUllQVEVEX0tFWVMgaXMgbm90IHNldAojIENPTkZJR19LRVlTX0RF QlVHX1BST0NfS0VZUyBpcyBub3Qgc2V0CiMgQ09ORklHX1NFQ1VSSVRZX0RNRVNHX1JFU1RS SUNUIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VDVVJJVFkgaXMgbm90IHNldAojIENPTkZJR19T RUNVUklUWUZTIGlzIG5vdCBzZXQKQ09ORklHX0RFRkFVTFRfU0VDVVJJVFlfREFDPXkKQ09O RklHX0RFRkFVTFRfU0VDVVJJVFk9IiIKQ09ORklHX1hPUl9CTE9DS1M9eQpDT05GSUdfQ1JZ UFRPPXkKCiMKIyBDcnlwdG8gY29yZSBvciBoZWxwZXIKIwpDT05GSUdfQ1JZUFRPX0FMR0FQ ST15CkNPTkZJR19DUllQVE9fQUxHQVBJMj15CkNPTkZJR19DUllQVE9fQUVBRD15CkNPTkZJ R19DUllQVE9fQUVBRDI9eQpDT05GSUdfQ1JZUFRPX0JMS0NJUEhFUj15CkNPTkZJR19DUllQ VE9fQkxLQ0lQSEVSMj15CkNPTkZJR19DUllQVE9fSEFTSD15CkNPTkZJR19DUllQVE9fSEFT SDI9eQpDT05GSUdfQ1JZUFRPX1JORz15CkNPTkZJR19DUllQVE9fUk5HMj15CkNPTkZJR19D UllQVE9fUENPTVA9eQpDT05GSUdfQ1JZUFRPX1BDT01QMj15CkNPTkZJR19DUllQVE9fTUFO QUdFUj15CkNPTkZJR19DUllQVE9fTUFOQUdFUjI9eQojIENPTkZJR19DUllQVE9fVVNFUiBp cyBub3Qgc2V0CkNPTkZJR19DUllQVE9fTUFOQUdFUl9ESVNBQkxFX1RFU1RTPXkKQ09ORklH X0NSWVBUT19HRjEyOE1VTD15CiMgQ09ORklHX0NSWVBUT19OVUxMIGlzIG5vdCBzZXQKIyBD T05GSUdfQ1JZUFRPX1BDUllQVCBpcyBub3Qgc2V0CkNPTkZJR19DUllQVE9fV09SS1FVRVVF PXkKQ09ORklHX0NSWVBUT19DUllQVEQ9eQpDT05GSUdfQ1JZUFRPX0FVVEhFTkM9eQojIENP TkZJR19DUllQVE9fVEVTVCBpcyBub3Qgc2V0CkNPTkZJR19DUllQVE9fQUJMS19IRUxQRVI9 eQpDT05GSUdfQ1JZUFRPX0dMVUVfSEVMUEVSX1g4Nj15CgojCiMgQXV0aGVudGljYXRlZCBF bmNyeXB0aW9uIHdpdGggQXNzb2NpYXRlZCBEYXRhCiMKIyBDT05GSUdfQ1JZUFRPX0NDTSBp cyBub3Qgc2V0CiMgQ09ORklHX0NSWVBUT19HQ00gaXMgbm90IHNldAojIENPTkZJR19DUllQ VE9fU0VRSVYgaXMgbm90IHNldAoKIwojIEJsb2NrIG1vZGVzCiMKQ09ORklHX0NSWVBUT19D QkM9eQojIENPTkZJR19DUllQVE9fQ1RSIGlzIG5vdCBzZXQKIyBDT05GSUdfQ1JZUFRPX0NU UyBpcyBub3Qgc2V0CkNPTkZJR19DUllQVE9fRUNCPXkKQ09ORklHX0NSWVBUT19MUlc9eQoj IENPTkZJR19DUllQVE9fUENCQyBpcyBub3Qgc2V0CkNPTkZJR19DUllQVE9fWFRTPXkKCiMK IyBIYXNoIG1vZGVzCiMKQ09ORklHX0NSWVBUT19DTUFDPXkKQ09ORklHX0NSWVBUT19ITUFD PXkKIyBDT05GSUdfQ1JZUFRPX1hDQkMgaXMgbm90IHNldAojIENPTkZJR19DUllQVE9fVk1B QyBpcyBub3Qgc2V0CgojCiMgRGlnZXN0CiMKQ09ORklHX0NSWVBUT19DUkMzMkM9eQpDT05G SUdfQ1JZUFRPX0NSQzMyQ19JTlRFTD15CiMgQ09ORklHX0NSWVBUT19DUkMzMiBpcyBub3Qg c2V0CiMgQ09ORklHX0NSWVBUT19DUkMzMl9QQ0xNVUwgaXMgbm90IHNldApDT05GSUdfQ1JZ UFRPX0NSQ1QxMERJRj15CiMgQ09ORklHX0NSWVBUT19DUkNUMTBESUZfUENMTVVMIGlzIG5v dCBzZXQKIyBDT05GSUdfQ1JZUFRPX0dIQVNIIGlzIG5vdCBzZXQKQ09ORklHX0NSWVBUT19N RDQ9eQpDT05GSUdfQ1JZUFRPX01ENT15CiMgQ09ORklHX0NSWVBUT19NSUNIQUVMX01JQyBp cyBub3Qgc2V0CiMgQ09ORklHX0NSWVBUT19STUQxMjggaXMgbm90IHNldAojIENPTkZJR19D UllQVE9fUk1EMTYwIGlzIG5vdCBzZXQKIyBDT05GSUdfQ1JZUFRPX1JNRDI1NiBpcyBub3Qg c2V0CiMgQ09ORklHX0NSWVBUT19STUQzMjAgaXMgbm90IHNldApDT05GSUdfQ1JZUFRPX1NI QTE9eQpDT05GSUdfQ1JZUFRPX1NIQTFfU1NTRTM9eQpDT05GSUdfQ1JZUFRPX1NIQTI1Nl9T U1NFMz15CkNPTkZJR19DUllQVE9fU0hBNTEyX1NTU0UzPXkKQ09ORklHX0NSWVBUT19TSEEy NTY9eQpDT05GSUdfQ1JZUFRPX1NIQTUxMj15CiMgQ09ORklHX0NSWVBUT19UR1IxOTIgaXMg bm90IHNldAojIENPTkZJR19DUllQVE9fV1A1MTIgaXMgbm90IHNldAojIENPTkZJR19DUllQ VE9fR0hBU0hfQ0xNVUxfTklfSU5URUwgaXMgbm90IHNldAoKIwojIENpcGhlcnMKIwpDT05G SUdfQ1JZUFRPX0FFUz15CkNPTkZJR19DUllQVE9fQUVTX1g4Nl82ND15CkNPTkZJR19DUllQ VE9fQUVTX05JX0lOVEVMPXkKIyBDT05GSUdfQ1JZUFRPX0FOVUJJUyBpcyBub3Qgc2V0CkNP TkZJR19DUllQVE9fQVJDND15CkNPTkZJR19DUllQVE9fQkxPV0ZJU0g9eQpDT05GSUdfQ1JZ UFRPX0JMT1dGSVNIX0NPTU1PTj15CkNPTkZJR19DUllQVE9fQkxPV0ZJU0hfWDg2XzY0PXkK IyBDT05GSUdfQ1JZUFRPX0NBTUVMTElBIGlzIG5vdCBzZXQKQ09ORklHX0NSWVBUT19DQU1F TExJQV9YODZfNjQ9eQpDT05GSUdfQ1JZUFRPX0NBTUVMTElBX0FFU05JX0FWWF9YODZfNjQ9 eQpDT05GSUdfQ1JZUFRPX0NBTUVMTElBX0FFU05JX0FWWDJfWDg2XzY0PXkKIyBDT05GSUdf Q1JZUFRPX0NBU1Q1IGlzIG5vdCBzZXQKIyBDT05GSUdfQ1JZUFRPX0NBU1Q1X0FWWF9YODZf NjQgaXMgbm90IHNldAojIENPTkZJR19DUllQVE9fQ0FTVDYgaXMgbm90IHNldAojIENPTkZJ R19DUllQVE9fQ0FTVDZfQVZYX1g4Nl82NCBpcyBub3Qgc2V0CkNPTkZJR19DUllQVE9fREVT PXkKIyBDT05GSUdfQ1JZUFRPX0ZDUllQVCBpcyBub3Qgc2V0CiMgQ09ORklHX0NSWVBUT19L SEFaQUQgaXMgbm90IHNldAojIENPTkZJR19DUllQVE9fU0FMU0EyMCBpcyBub3Qgc2V0CiMg Q09ORklHX0NSWVBUT19TQUxTQTIwX1g4Nl82NCBpcyBub3Qgc2V0CiMgQ09ORklHX0NSWVBU T19TRUVEIGlzIG5vdCBzZXQKQ09ORklHX0NSWVBUT19TRVJQRU5UPXkKQ09ORklHX0NSWVBU T19TRVJQRU5UX1NTRTJfWDg2XzY0PXkKQ09ORklHX0NSWVBUT19TRVJQRU5UX0FWWF9YODZf NjQ9eQpDT05GSUdfQ1JZUFRPX1NFUlBFTlRfQVZYMl9YODZfNjQ9eQojIENPTkZJR19DUllQ VE9fVEVBIGlzIG5vdCBzZXQKQ09ORklHX0NSWVBUT19UV09GSVNIPXkKQ09ORklHX0NSWVBU T19UV09GSVNIX0NPTU1PTj15CkNPTkZJR19DUllQVE9fVFdPRklTSF9YODZfNjQ9eQpDT05G SUdfQ1JZUFRPX1RXT0ZJU0hfWDg2XzY0XzNXQVk9eQpDT05GSUdfQ1JZUFRPX1RXT0ZJU0hf QVZYX1g4Nl82ND15CgojCiMgQ29tcHJlc3Npb24KIwpDT05GSUdfQ1JZUFRPX0RFRkxBVEU9 eQpDT05GSUdfQ1JZUFRPX1pMSUI9eQpDT05GSUdfQ1JZUFRPX0xaTz15CiMgQ09ORklHX0NS WVBUT19MWjQgaXMgbm90IHNldAojIENPTkZJR19DUllQVE9fTFo0SEMgaXMgbm90IHNldAoK IwojIFJhbmRvbSBOdW1iZXIgR2VuZXJhdGlvbgojCkNPTkZJR19DUllQVE9fQU5TSV9DUFJO Rz15CiMgQ09ORklHX0NSWVBUT19VU0VSX0FQSV9IQVNIIGlzIG5vdCBzZXQKIyBDT05GSUdf Q1JZUFRPX1VTRVJfQVBJX1NLQ0lQSEVSIGlzIG5vdCBzZXQKIyBDT05GSUdfQ1JZUFRPX0hX IGlzIG5vdCBzZXQKIyBDT05GSUdfQVNZTU1FVFJJQ19LRVlfVFlQRSBpcyBub3Qgc2V0CkNP TkZJR19IQVZFX0tWTT15CiMgQ09ORklHX1ZJUlRVQUxJWkFUSU9OIGlzIG5vdCBzZXQKQ09O RklHX0JJTkFSWV9QUklOVEY9eQoKIwojIExpYnJhcnkgcm91dGluZXMKIwpDT05GSUdfUkFJ RDZfUFE9eQpDT05GSUdfQklUUkVWRVJTRT15CkNPTkZJR19HRU5FUklDX1NUUk5DUFlfRlJP TV9VU0VSPXkKQ09ORklHX0dFTkVSSUNfU1RSTkxFTl9VU0VSPXkKQ09ORklHX0dFTkVSSUNf TkVUX1VUSUxTPXkKQ09ORklHX0dFTkVSSUNfRklORF9GSVJTVF9CSVQ9eQpDT05GSUdfR0VO RVJJQ19QQ0lfSU9NQVA9eQpDT05GSUdfR0VORVJJQ19JT01BUD15CkNPTkZJR19HRU5FUklD X0lPPXkKQ09ORklHX0FSQ0hfVVNFX0NNUFhDSEdfTE9DS1JFRj15CiMgQ09ORklHX0NSQ19D Q0lUVCBpcyBub3Qgc2V0CkNPTkZJR19DUkMxNj15CkNPTkZJR19DUkNfVDEwRElGPXkKQ09O RklHX0NSQ19JVFVfVD15CkNPTkZJR19DUkMzMj15CkNPTkZJR19DUkMzMl9TRUxGVEVTVD15 CkNPTkZJR19DUkMzMl9TTElDRUJZOD15CiMgQ09ORklHX0NSQzMyX1NMSUNFQlk0IGlzIG5v dCBzZXQKIyBDT05GSUdfQ1JDMzJfU0FSV0FURSBpcyBub3Qgc2V0CiMgQ09ORklHX0NSQzMy X0JJVCBpcyBub3Qgc2V0CiMgQ09ORklHX0NSQzcgaXMgbm90IHNldApDT05GSUdfTElCQ1JD MzJDPXkKIyBDT05GSUdfQ1JDOCBpcyBub3Qgc2V0CiMgQ09ORklHX1JBTkRPTTMyX1NFTEZU RVNUIGlzIG5vdCBzZXQKQ09ORklHX1pMSUJfSU5GTEFURT15CkNPTkZJR19aTElCX0RFRkxB VEU9eQpDT05GSUdfTFpPX0NPTVBSRVNTPXkKQ09ORklHX0xaT19ERUNPTVBSRVNTPXkKQ09O RklHX0xaNF9ERUNPTVBSRVNTPXkKQ09ORklHX1haX0RFQz15CkNPTkZJR19YWl9ERUNfWDg2 PXkKQ09ORklHX1haX0RFQ19QT1dFUlBDPXkKQ09ORklHX1haX0RFQ19JQTY0PXkKQ09ORklH X1haX0RFQ19BUk09eQpDT05GSUdfWFpfREVDX0FSTVRIVU1CPXkKQ09ORklHX1haX0RFQ19T UEFSQz15CkNPTkZJR19YWl9ERUNfQkNKPXkKIyBDT05GSUdfWFpfREVDX1RFU1QgaXMgbm90 IHNldApDT05GSUdfREVDT01QUkVTU19HWklQPXkKQ09ORklHX0RFQ09NUFJFU1NfQlpJUDI9 eQpDT05GSUdfREVDT01QUkVTU19MWk1BPXkKQ09ORklHX0RFQ09NUFJFU1NfWFo9eQpDT05G SUdfREVDT01QUkVTU19MWk89eQpDT05GSUdfREVDT01QUkVTU19MWjQ9eQpDT05GSUdfVEVY VFNFQVJDSD15CkNPTkZJR19URVhUU0VBUkNIX0tNUD15CkNPTkZJR19URVhUU0VBUkNIX0JN PXkKQ09ORklHX1RFWFRTRUFSQ0hfRlNNPXkKQ09ORklHX0FTU09DSUFUSVZFX0FSUkFZPXkK Q09ORklHX0hBU19JT01FTT15CkNPTkZJR19IQVNfSU9QT1JUPXkKQ09ORklHX0hBU19ETUE9 eQpDT05GSUdfQ0hFQ0tfU0lHTkFUVVJFPXkKQ09ORklHX0NQVV9STUFQPXkKQ09ORklHX0RR TD15CkNPTkZJR19OTEFUVFI9eQpDT05GSUdfQVJDSF9IQVNfQVRPTUlDNjRfREVDX0lGX1BP U0lUSVZFPXkKQ09ORklHX0FWRVJBR0U9eQojIENPTkZJR19DT1JESUMgaXMgbm90IHNldAoj IENPTkZJR19ERFIgaXMgbm90IHNldApDT05GSUdfRk9OVF9TVVBQT1JUPXkKIyBDT05GSUdf Rk9OVFMgaXMgbm90IHNldApDT05GSUdfRk9OVF84eDg9eQpDT05GSUdfRk9OVF84eDE2PXkK ------------0420FB0940DD99E7F Content-Type: text/plain; name="kernel-dom0-git-log1.txt" Content-transfer-encoding: base64 Content-Disposition: attachment; filename="kernel-dom0-git-log1.txt" Y29tbWl0IDEyN2QwNjFkYzIyNDk2MmFjY2E5ZWE1NWNmZjc0YWVmMTY2OGFlMzANCkF1dGhv cjogUGF1bCBEdXJyYW50IDxQYXVsLkR1cnJhbnRAY2l0cml4LmNvbT4NCkRhdGU6ICAgRnJp IERlYyA2IDE2OjM2OjA3IDIwMTMgKzAwMDANCg0KICAgIHhlbi1uZXRiYWNrOiBpbXByb3Zl IGd1ZXN0LXJlY2VpdmUtc2lkZSBmbG93IGNvbnRyb2wNCiAgICANCiAgICBUaGUgd2F5IHRo YXQgZmxvdyBjb250cm9sIHdvcmtzIHdpdGhvdXQgdGhpcyBwYXRjaCBpcyB0aGF0LCBpbiBz dGFydF94bWl0KCkNCiAgICB0aGUgY29kZSB1c2VzIHhlbnZpZl9jb3VudF9za2Jfc2xvdHMo KSB0byBwcmVkaWN0IGhvdyBtYW55IHNsb3RzDQogICAgeGVudmlmX2dvcF9za2IoKSB3aWxs IGNvbnN1bWUgYW5kIHRoZW4gYWRkcyB0aGlzIHRvIGEgJ3JlcV9jb25zX3BlZWsnDQogICAg Y291bnRlciB3aGljaCBpdCB0aGVuIHVzZXMgdG8gZGV0ZXJtaW5lIGlmIHRoZSBzaGFyZWQg cmluZyBoYXMgdGhhdCBhbW91bnQNCiAgICBvZiBzcGFjZSBhdmFpbGFibGUgYnkgY2hlY2tp bmcgd2hldGhlciAncmVxX3Byb2QnIGhhcyBwYXNzZWQgdGhhdCB2YWx1ZS4NCiAgICBJZiB0 aGUgcmluZyBkb2Vzbid0IGhhdmUgc3BhY2UgdGhlIHR4IHF1ZXVlIGlzIHN0b3BwZWQuDQog ICAgeGVudmlmX2dvcF9za2IoKSB3aWxsIHRoZW4gY29uc3VtZSBzbG90cyBhbmQgdXBkYXRl ICdyZXFfY29ucycgYW5kIGlzc3VlDQogICAgcmVzcG9uc2VzLCB1cGRhdGluZyAncnNwX3By b2QnIGFzIGl0IGdvZXMuIFRoZSBmcm9udGVuZCB3aWxsIGNvbnN1bWUgdGhvc2UNCiAgICBy ZXNwb25zZXMgYW5kIHBvc3QgbmV3IHJlcXVlc3RzLCBieSB1cGRhdGluZyByZXFfcHJvZC4g U28sIHJlcV9wcm9kIGNoYXNlcw0KICAgIHJlcV9jb25zIHdoaWNoIGNoYXNlcyByc3BfcHJv ZCwgYW5kIGNhbiBuZXZlciBleGNlZWQgdGhhdCB2YWx1ZS4gVGh1cyBpZg0KICAgIHhlbnZp Zl9jb3VudF9za2Jfc2xvdHMoKSBldmVyIHJldHVybnMgYSBudW1iZXIgb2Ygc2xvdHMgZ3Jl YXRlciB0aGFuDQogICAgeGVudmlmX2dvcF9za2IoKSB1c2VzLCByZXFfY29uc19wZWVrIHdp bGwgZ2V0IHRvIGEgdmFsdWUgdGhhdCByZXFfcHJvZCBjYW5ub3QNCiAgICBwb3NzaWJseSBh Y2hpZXZlIChzaW5jZSBpdCdzIGxpbWl0ZWQgYnkgdGhlICdyZWFsJyByZXFfY29ucykgYW5k LCBpZiB0aGlzDQogICAgaGFwcGVucyBlbm91Z2ggdGltZXMsIHJlcV9jb25zX3BlZWsgZ2V0 cyBtb3JlIHRoYW4gYSByaW5nIHNpemUgYWhlYWQgb2YNCiAgICByZXFfY29ucyBhbmQgdGhl IHR4IHF1ZXVlIHRoZW4gcmVtYWlucyBzdG9wcGVkIGZvcmV2ZXIgd2FpdGluZyBmb3IgYW4N CiAgICB1bmFjaGlldmFibGUgYW1vdW50IG9mIHNwYWNlIHRvIGJlY29tZSBhdmFpbGFibGUg aW4gdGhlIHJpbmcuDQogICAgDQogICAgSGF2aW5nIHR3byByb3V0aW5lcyB0cnlpbmcgdG8g Y2FsY3VsYXRlIHRoZSBzYW1lIHZhbHVlIGlzIGFsd2F5cyBnb2luZyB0byBiZQ0KICAgIGZy YWdpbGUsIHNvIHRoaXMgcGF0Y2ggZG9lcyBhd2F5IHdpdGggdGhhdC4gQWxsIHdlIGVzc2Vu dGlhbGx5IG5lZWQgdG8gZG8gaXMNCiAgICBtYWtlIHN1cmUgdGhhdCB3ZSBoYXZlICdlbm91 Z2ggc3R1ZmYnIG9uIG91ciBpbnRlcm5hbCBxdWV1ZSB3aXRob3V0IGxldHRpbmcNCiAgICBp dCBidWlsZCB1cCB1bmNvbnRyb2xsYWJseS4gU28gc3RhcnRfeG1pdCgpIG1ha2VzIGEgY2hl YXAgb3B0aW1pc3RpYyBjaGVjaw0KICAgIG9mIGhvdyBtdWNoIHNwYWNlIGlzIG5lZWRlZCBm b3IgYW4gc2tiIGFuZCBvbmx5IHR1cm5zIHRoZSBxdWV1ZSBvZmYgaWYgdGhhdA0KICAgIGlz IHVuYWNoaWV2YWJsZS4gbmV0X3J4X2FjdGlvbigpIGlzIHRoZSBwbGFjZSB3aGVyZSB3ZSBj b3VsZCBkbyB3aXRoIGFuDQogICAgYWNjdXJhdGUgcHJlZGljaXRpb24gYnV0LCBzaW5jZSB0 aGF0IGhhcyBwcm92ZW4gdHJpY2t5IHRvIGNhbGN1bGF0ZSwgYSBjaGVhcA0KICAgIHdvcnNl LWNhc2UgKGJ1dCBub3QgdG9vIGJhZCkgZXN0aW1hdGUgaXMgYWxsIHdlIHJlYWxseSBuZWVk IHNpbmNlIHRoZSBvbmx5DQogICAgdGhpbmcgd2UgKm11c3QqIHByZXZlbnQgaXMgeGVudmlm X2dvcF9za2IoKSBjb25zdW1pbmcgbW9yZSBzbG90cyB0aGFuIGFyZQ0KICAgIGF2YWlsYWJs ZS4NCiAgICANCiAgICBXaXRob3V0IHRoaXMgcGF0Y2ggSSBjYW4gdHJpdmlhbGx5IHN0YWxs IG5ldGJhY2sgcGVybWFuZW50bHkgYnkganVzdCBkb2luZw0KICAgIGEgbGFyZ2UgZ3Vlc3Qg dG8gZ3Vlc3QgZmlsZSBjb3B5IGJldHdlZW4gdHdvIFdpbmRvd3MgU2VydmVyIDIwMDhSMiBW TXMgb24gYQ0KICAgIHNpbmdsZSBob3N0Lg0KICAgIA0KICAgIFBhdGNoIHRlc3RlZCB3aXRo IGZyb250ZW5kcyBpbjoNCiAgICAtIFdpbmRvd3MgU2VydmVyIDIwMDhSMg0KICAgIC0gQ2Vu dE9TIDYuMA0KICAgIC0gRGViaWFuIFNxdWVlemUNCiAgICAtIERlYmlhbiBXaGVlenkNCiAg ICAtIFNMRVMxMQ0KICAgIA0KICAgIFNpZ25lZC1vZmYtYnk6IFBhdWwgRHVycmFudCA8cGF1 bC5kdXJyYW50QGNpdHJpeC5jb20+DQogICAgQ2M6IFdlaSBMaXUgPHdlaS5saXUyQGNpdHJp eC5jb20+DQogICAgQ2M6IElhbiBDYW1wYmVsbCA8aWFuLmNhbXBiZWxsQGNpdHJpeC5jb20+ DQogICAgQ2M6IERhdmlkIFZyYWJlbCA8ZGF2aWQudnJhYmVsQGNpdHJpeC5jb20+DQogICAg Q2M6IEFubmllIExpIDxhbm5pZS5saUBvcmFjbGUuY29tPg0KICAgIENjOiBLb25yYWQgUnpl c3p1dGVrIFdpbGsgPGtvbnJhZC53aWxrQG9yYWNsZS5jb20+DQogICAgQWNrZWQtYnk6IFdl aSBMaXUgPHdlaS5saXUyQGNpdHJpeC5jb20+DQogICAgU2lnbmVkLW9mZi1ieTogRGF2aWQg Uy4gTWlsbGVyIDxkYXZlbUBkYXZlbWxvZnQubmV0Pg0KDQpjb21taXQgYjU3NDQ3NzgzNzNk ZTk0ZGNjNzA4OWJlMGJiZjdkNzgyMTBkYTMwZQ0KTWVyZ2U6IGNhM2Y5N2UgNzY5M2RlYw0K QXV0aG9yOiBTYW5kZXIgRWlrZWxlbmJvb20gPGxpbnV4QGVpa2VsZW5ib29tLml0Pg0KRGF0 ZTogICBNb24gTWFyIDEwIDE4OjQzOjM3IDIwMTQgKzAxMDANCg0KICAgIE1lcmdlIHRhZyAn c3RhYmxlL2Zvci1saW51cy0zLjE0LXJjNS10YWcnIG9mIGdpdDovL2dpdC5rZXJuZWwub3Jn L3B1Yi9zY20vbGludXgva2VybmVsL2dpdC94ZW4vdGlwIGludG8gSEVBRA0KICAgIA0KICAg IEJ1ZzoNCiAgICAgLSBGaXggY29tcGlsZSBkZXBlbmRlbmN5IG9uIFhlbiBBUk0gdG8gaGF2 ZSBNTVUuDQoNCmNvbW1pdCBjYTNmOTdlNjQzYzkwMTc1MTBmMjgyM2E0Nzc5NWFmZmFmMzJm MGUwDQpNZXJnZTogZDY4NWE4OCBkODMyMGIyDQpBdXRob3I6IFNhbmRlciBFaWtlbGVuYm9v bSA8bGludXhAZWlrZWxlbmJvb20uaXQ+DQpEYXRlOiAgIE1vbiBNYXIgMTAgMTg6NDI6NTEg MjAxNCArMDEwMA0KDQogICAgTWVyZ2UgdGFnICdzdGFibGUvZm9yLWxpbnVzLTMuMTQtcmMy LXRhZycgb2YgZ2l0Oi8vZ2l0Lmtlcm5lbC5vcmcvcHViL3NjbS9saW51eC9rZXJuZWwvZ2l0 L3hlbi90aXAgaW50byBIRUFEDQogICAgDQogICAgQnVnLWZpeDoNCiAgICAgLSBGaXggQVJN IGFuZCBYZW4gRklGTyBub3Qgd29ya2luZy4NCiAgICAgLSBSZW1vdmUgbW9yZSBYZW4gaWE2 NCB2ZXN0aWdhdGVzLg0KICAgICAtIEZpeCBVQVBJIG1pc3NpbmcgWGVuIGZpbGVzLg0KDQpj b21taXQgZDY4NWE4ODg0NWE2ZjgyY2I4YmJiNzE0ZGRmNzY0N2MxZjJlZTE1OA0KTWVyZ2U6 IDBhYzk3YzMgYWZjYTUwMQ0KQXV0aG9yOiBTYW5kZXIgRWlrZWxlbmJvb20gPGxpbnV4QGVp a2VsZW5ib29tLml0Pg0KRGF0ZTogICBNb24gTWFyIDEwIDE4OjQyOjA4IDIwMTQgKzAxMDAN Cg0KICAgIE1lcmdlIHRhZyAnc3RhYmxlL2Zvci1saW51cy0zLjE0LXJjMS10YWcnIG9mIGdp dDovL2dpdC5rZXJuZWwub3JnL3B1Yi9zY20vbGludXgva2VybmVsL2dpdC94ZW4vdGlwIGlu dG8gSEVBRA0KICAgIA0KICAgIEJ1Zy1maXhlczoNCiAgICAgLSBSZXZlcnQgInhlbi9ncmFu dC10YWJsZTogQXZvaWQgbTJwX292ZXJyaWRlIGR1cmluZyBtYXBwaW5nIiBhcyBpdCBicm9r ZSBYZW4gQVJNIGJ1aWxkLg0KICAgICAtIEZpeCBDUjQgbm90IGJlaW5nIHNldCBvbiBBUCBw cm9jZXNzb3JzIGluIFhlbiBQVkggbW9kZS4NCg0KY29tbWl0IDBhYzk3YzM2NWJlMTQxY2M2 ZmE3MGI2ODViYmNlNjg5MGFiNGY5OWMNCk1lcmdlOiAzYzRhYWM5IGY5MzU3NmUNCkF1dGhv cjogU2FuZGVyIEVpa2VsZW5ib29tIDxsaW51eEBlaWtlbGVuYm9vbS5pdD4NCkRhdGU6ICAg TW9uIE1hciAxMCAxODozODo0NCAyMDE0ICswMTAwDQoNCiAgICBNZXJnZSB0YWcgJ3N0YWJs ZS9mb3ItbGludXMtMy4xNC1yYzAtbGF0ZS10YWcnIG9mIGdpdDovL2dpdC5rZXJuZWwub3Jn L3B1Yi9zY20vbGludXgva2VybmVsL2dpdC94ZW4vdGlwIGludG8gSEVBRA0KICAgIA0KICAg IEJ1Zy1maXhlczoNCiAgICAgLSBYZW4gQVJNIGNvdWxkbid0IHVzZSB0aGUgbmV3IEZJRk8g ZXZlbnRzDQogICAgIC0gWGVuIEFSTSBjb3VsZG4ndCB1c2UgdGhlIFNXSU9UTEIgaWYgY29t cGlsZWQgYXMgMzItYml0IHdpdGggNjQtYml0IFBDSWUgZGV2aWNlcy4NCiAgICAgLSBHcmFu dCB0YWJsZSB3ZXJlIGRvaW5nIG5lZWRsZXNzIE0yUCBvcGVyYXRpb25zLg0KICAgICAtIFJh dGNoZXQgZG93biB0aGUgc2VsZi1iYWxsb29uIGNvZGUgc28gaXQgd29uJ3QgT09NLg0KICAg ICAtIEZpeCBtaXNwbGFjZWQga2ZyZWUgaW4gWGVuIFBWSCBlcnJvciBjb2RlIHBhdGhzLg0K DQpjb21taXQgM2M0YWFjOTdjYTBiOGY4YzY3ZjNjNjI3MTlkODgwZWYzMTQ3ZmU3OA0KTWVy Z2U6IDQwNGRmNjUgYzlmNmU5OQ0KQXV0aG9yOiBTYW5kZXIgRWlrZWxlbmJvb20gPGxpbnV4 QGVpa2VsZW5ib29tLml0Pg0KRGF0ZTogICBNb24gTWFyIDEwIDE4OjMxOjM4IDIwMTQgKzAx MDANCg0KICAgIE1lcmdlIHRhZyAnc3RhYmxlL2Zvci1saW51cy0zLjE0LXJjMC10YWcnIG9m IGdpdDovL2dpdC5rZXJuZWwub3JnL3B1Yi9zY20vbGludXgva2VybmVsL2dpdC94ZW4vdGlw IGludG8gSEVBRA0KICAgIA0KICAgIEZlYXR1cmVzOg0KICAgICAtIEZJRk8gZXZlbnQgY2hh bm5lbHMuIEtleSBhZHZhbnRhZ2VzOiBzdXBwb3J0IGZvciBvdmVyIDEwMCwwMDAgZXZlbnRz ICgyXjE3KSwNCiAgICAgICAxNiBkaWZmZXJlbnQgZXZlbnQgcHJpb3JpdGllcywgaW1wcm92 ZWQgZmFpcm5lc3MgaW4gZXZlbnQgbGF0ZW5jeSB0aHJvdWdoDQogICAgICAgdGhlIHVzZSBv ZiBGSUZPcy4NCiAgICAgLSBYZW4gUFZIIHN1cHBvcnQuICJJdJJzIGEgZnVsbHkgUFYga2Vy bmVsIG1vZGUsIHJ1bm5pbmcgd2l0aCBwYXJhdmlydHVhbGl6ZWQNCiAgICAgICBkaXNrIGFu ZCBuZXR3b3JrLCBwYXJhdmlydHVhbGl6ZWQgaW50ZXJydXB0cyBhbmQgdGltZXJzLCBubyBl bXVsYXRlZCBkZXZpY2VzDQogICAgICAgb2YgYW55IGtpbmQgKGFuZCB0aHVzIG5vIHFlbXUp LCBubyBCSU9TIG9yIGxlZ2FjeSBib290IJcgYnV0IGluc3RlYWQgb2YNCiAgICAgICByZXF1 aXJpbmcgUFYgTU1VLCBpdCB1c2VzIHRoZSBIVk0gaGFyZHdhcmUgZXh0ZW5zaW9ucyB0byB2 aXJ0dWFsaXplIHRoZQ0KICAgICAgIHBhZ2V0YWJsZXMsIGFzIHdlbGwgYXMgc3lzdGVtIGNh bGxzIGFuZCBvdGhlciBwcml2aWxlZ2VkIG9wZXJhdGlvbnMuIg0KICAgICAgIChmcm9tICJU aGUgUGFyYXZpcnR1YWxpemF0aW9uIFNwZWN0cnVtLCBQYXJ0IDI6IEZyb20gcG9sZXMgdG8g YSBzcGVjdHJ1bSIpDQogICAgQnVnLWZpeGVzOg0KICAgICAtIEZpeGVzIGluIGJhbGxvb24g ZHJpdmVyIChyZWZhY3RvciBhbmQgbWFrZSBpdCB3b3JrIHVuZGVyIEFSTSkNCiAgICAgLSBB bGxvdyB4ZW5mYiB0byBiZSB1c2VkIGluIEhWTSBndWVzdHMuDQogICAgIC0gQWxsb3cgeGVu X3BsYXRmb3JtX3BjaT0wIHRvIHdvcmsgcHJvcGVybHkuDQogICAgIC0gUmVmYWN0b3JzIGlu IGV2ZW50IGNoYW5uZWxzLg0KICAgIA0KICAgIENvbmZsaWN0czoNCiAgICAJYXJjaC9hcm0v aW5jbHVkZS9hc20veGVuL3BhZ2UuaA0KICAgIAlpbmNsdWRlL3hlbi9wbGF0Zm9ybV9wY2ku aA0KDQpjb21taXQgNDA0ZGY2NWQwNDgwZjZkYTJiNzY4ZjZjOWI1MjU5NDM2YjFkZTEwZg0K QXV0aG9yOiBHcmVnIEtyb2FoLUhhcnRtYW4gPGdyZWdraEBsaW51eGZvdW5kYXRpb24ub3Jn Pg0KRGF0ZTogICBUaHUgTWFyIDYgMjI6MDc6MDIgMjAxNCAtMDgwMA0KDQogICAgTGludXgg My4xMy42DQo= ------------0420FB0940DD99E7F Content-Type: application/octet-stream; name="netfront-debug.diff" Content-transfer-encoding: base64 Content-Disposition: attachment; filename="netfront-debug.diff" ZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3hlbi1uZXRmcm9udC5jIGIvZHJpdmVycy9uZXQv eGVuLW5ldGZyb250LmMKaW5kZXggZTMwZDgwMC4uNWQyMzI2NiAxMDA2NDQKLS0tIGEvZHJp dmVycy9uZXQveGVuLW5ldGZyb250LmMKKysrIGIvZHJpdmVycy9uZXQveGVuLW5ldGZyb250 LmMKQEAgLTc0MSwxOCArNzQxLDI2IEBAIHN0YXRpYyBpbnQgeGVubmV0X2dldF9yZXNwb25z ZXMoc3RydWN0IG5ldGZyb250X2luZm8gKm5wLAogCWludCBzbG90cyA9IDE7CiAJaW50IGVy ciA9IDA7CiAJdW5zaWduZWQgbG9uZyByZXQ7Ci0KKyAgICAgICAgaW50IGNvbnNfY2hhbmdl ZCA9IDA7CisJaW50IGNvbnNfYmVmb3JlID0gMDsKKwlpbnQgeGVubmV0X2dldF9leHRyYXNf ZXJyID0gMDsKKwkKIAlpZiAocngtPmZsYWdzICYgWEVOX05FVFJYRl9leHRyYV9pbmZvKSB7 CiAJCWVyciA9IHhlbm5ldF9nZXRfZXh0cmFzKG5wLCBleHRyYXMsIHJwKTsKKyAgICAgICAg ICAgICAgICB4ZW5uZXRfZ2V0X2V4dHJhc19lcnIgPSBlcnI7CisJCWNvbnNfYmVmb3JlID0g Y29uczsKIAkJY29ucyA9IG5wLT5yeC5yc3BfY29uczsKKwkJY29uc19jaGFuZ2VkKys7CiAJ fQogCiAJZm9yICg7OykgewogCQlpZiAodW5saWtlbHkocngtPnN0YXR1cyA8IDAgfHwKIAkJ CSAgICAgcngtPm9mZnNldCArIHJ4LT5zdGF0dXMgPiBQQUdFX1NJWkUpKSB7Ci0JCQlpZiAo bmV0X3JhdGVsaW1pdCgpKQorCQkJaWYgKG5ldF9yYXRlbGltaXQoKSl7CiAJCQkJZGV2X3dh cm4oZGV2LCAicngtPm9mZnNldDogJXgsIHNpemU6ICV1XG4iLAogCQkJCQkgcngtPm9mZnNl dCwgcngtPnN0YXR1cyk7CisJCQkJZGV2X3dhcm4oZGV2LCAiY29uczolZCBzbG90czolZCBy cDolZCBtYXg6JWQgZXJyOiVkIHJ4LT5pZDolZCByeC0+b2Zmc2V0OiV4IHNpemU6JXUgcmVm OiVsZCBwYWdlc2l6ZTolZCBza2JfaXBzdW1tZWQ6JWQgaXNfZ3NvOiVkIGdzb19zaXplOiVk IGdzb190eXBlOiVkIGdzb19zZWdzOiVkIFJJTkdfSEFTX1VOQ09OU1VNRURfUkVTUE9OU0VT OiVkIGNvbnNfY2hhbmdlZDolZCBjb25zX2JlZm9yZTolZCB4ZW5uZXRfZ2V0X2V4dHJhc19l cnI6JWRcbiIsIGNvbnMsIHNsb3RzLCBycCwgbWF4LCBlcnIsIHJ4LT5pZCwgcngtPm9mZnNl dCwgcngtPnN0YXR1cywgcmVmLCBQQUdFX1NJWkUsIHNrYi0+aXBfc3VtbWVkLCBza2JfaXNf Z3NvKHNrYikgPyAxIDogMCwgc2tiX3NoaW5mbyhza2IpLT5nc29fc2l6ZSwgc2tiX3NoaW5m byhza2IpLT5nc29fdHlwZSwgc2tiX3NoaW5mbyhza2IpLT5nc29fc2VncywgUklOR19IQVNf VU5DT05TVU1FRF9SRVNQT05TRVMoJm5wLT5yeCksIGNvbnNfY2hhbmdlZCwgY29uc19iZWZv cmUsIHhlbm5ldF9nZXRfZXh0cmFzX2Vycik7CisgICAgICAgICAgICAgICAgICAgICAgICB9 CiAJCQl4ZW5uZXRfbW92ZV9yeF9zbG90KG5wLCBza2IsIHJlZik7CiAJCQllcnIgPSAtRUlO VkFMOwogCQkJZ290byBuZXh0Owo= ------------0420FB0940DD99E7F Content-Type: text/plain; name="ifconfig-dom0.txt" Content-transfer-encoding: base64 Content-Disposition: attachment; filename="ifconfig-dom0.txt" ZXRoMCAgICAgIExpbmsgZW5jYXA6RXRoZXJuZXQgIEhXYWRkciA0MDo2MTo4NjpmNDo2Nzpk OSAgCiAgICAgICAgICBpbmV0IGFkZHI6eHh4Lnh4eC54eHgueHh4ICBCY2FzdDp4eHgueHh4 Lnh4eC54eHggIE1hc2s6MjU1LjI1NS4yNTIuMAogICAgICAgICAgVVAgQlJPQURDQVNUIFJV Tk5JTkcgTVVMVElDQVNUICBNVFU6MTUwMCAgTWV0cmljOjEKICAgICAgICAgIFJYIHBhY2tl dHM6MTc5ODcgZXJyb3JzOjAgZHJvcHBlZDowIG92ZXJydW5zOjAgZnJhbWU6MAogICAgICAg ICAgVFggcGFja2V0czoxNDczNSBlcnJvcnM6MCBkcm9wcGVkOjAgb3ZlcnJ1bnM6MCBjYXJy aWVyOjAKICAgICAgICAgIGNvbGxpc2lvbnM6MCB0eHF1ZXVlbGVuOjEwMDAgCiAgICAgICAg ICBSWCBieXRlczoxNTY5NjA2OCAoMTQuOSBNaUIpICBUWCBieXRlczoxNTQ0ODM1ICgxLjQg TWlCKQoKZXRoMSAgICAgIExpbmsgZW5jYXA6RXRoZXJuZXQgIEhXYWRkciA0MDo2MTo4Njpm NDo2NzpkOCAgCiAgICAgICAgICBpbmV0IGFkZHI6MTcyLjE2LjEuMSAgQmNhc3Q6MTcyLjE2 LjI1NS4yNTUgIE1hc2s6MjU1LjI1NS4wLjAKICAgICAgICAgIFVQIEJST0FEQ0FTVCBSVU5O SU5HIE1VTFRJQ0FTVCAgTVRVOjE1MDAgIE1ldHJpYzoxCiAgICAgICAgICBSWCBwYWNrZXRz OjExMzYwIGVycm9yczowIGRyb3BwZWQ6MCBvdmVycnVuczowIGZyYW1lOjAKICAgICAgICAg IFRYIHBhY2tldHM6MTExNjkgZXJyb3JzOjAgZHJvcHBlZDowIG92ZXJydW5zOjAgY2Fycmll cjowCiAgICAgICAgICBjb2xsaXNpb25zOjAgdHhxdWV1ZWxlbjoxMDAwIAogICAgICAgICAg UlggYnl0ZXM6MTAxMjgzNSAoOTg5LjAgS2lCKSAgVFggYnl0ZXM6MTUxNTE3MjUgKDE0LjQg TWlCKQoKbG8gICAgICAgIExpbmsgZW5jYXA6TG9jYWwgTG9vcGJhY2sgIAogICAgICAgICAg aW5ldCBhZGRyOjEyNy4wLjAuMSAgTWFzazoyNTUuMC4wLjAKICAgICAgICAgIFVQIExPT1BC QUNLIFJVTk5JTkcgIE1UVTo2NTUzNiAgTWV0cmljOjEKICAgICAgICAgIFJYIHBhY2tldHM6 OTAgZXJyb3JzOjAgZHJvcHBlZDowIG92ZXJydW5zOjAgZnJhbWU6MAogICAgICAgICAgVFgg cGFja2V0czo5MCBlcnJvcnM6MCBkcm9wcGVkOjAgb3ZlcnJ1bnM6MCBjYXJyaWVyOjAKICAg ICAgICAgIGNvbGxpc2lvbnM6MCB0eHF1ZXVlbGVuOjAgCiAgICAgICAgICBSWCBieXRlczo3 OTIwICg3LjcgS2lCKSAgVFggYnl0ZXM6NzkyMCAoNy43IEtpQikKCnZpZjEuMCAgICBMaW5r IGVuY2FwOkV0aGVybmV0ICBIV2FkZHIgZmU6ZmY6ZmY6ZmY6ZmY6ZmYgIAogICAgICAgICAg VVAgQlJPQURDQVNUIFJVTk5JTkcgTVVMVElDQVNUICBNVFU6MTUwMCAgTWV0cmljOjEKICAg ICAgICAgIFJYIHBhY2tldHM6NDM1ODY4MiBlcnJvcnM6MCBkcm9wcGVkOjAgb3ZlcnJ1bnM6 MCBmcmFtZTowCiAgICAgICAgICBUWCBwYWNrZXRzOjY1Mzg5NDggZXJyb3JzOjAgZHJvcHBl ZDowIG92ZXJydW5zOjAgY2FycmllcjowCiAgICAgICAgICBjb2xsaXNpb25zOjAgdHhxdWV1 ZWxlbjozMiAKICAgICAgICAgIFJYIGJ5dGVzOjM0OTc3MzUyOTIgKDMuMiBHaUIpICBUWCBi eXRlczozNzAyNjMxNjM0ICgzLjQgR2lCKQoKdnBuX2JyaWRnZSBMaW5rIGVuY2FwOkV0aGVy bmV0ICBIV2FkZHIgYjY6MzY6ODI6MzI6YzE6NGIgIAogICAgICAgICAgaW5ldCBhZGRyOjE5 Mi4xNjguMi4xICBCY2FzdDoxOTIuMTY4LjIuMjU1ICBNYXNrOjI1NS4yNTUuMjU1LjAKICAg ICAgICAgIFVQIEJST0FEQ0FTVCBSVU5OSU5HIE1VTFRJQ0FTVCAgTVRVOjE1MDAgIE1ldHJp YzoxCiAgICAgICAgICBSWCBwYWNrZXRzOjAgZXJyb3JzOjAgZHJvcHBlZDowIG92ZXJydW5z OjAgZnJhbWU6MAogICAgICAgICAgVFggcGFja2V0czowIGVycm9yczowIGRyb3BwZWQ6MCBv dmVycnVuczowIGNhcnJpZXI6MAogICAgICAgICAgY29sbGlzaW9uczowIHR4cXVldWVsZW46 MCAKICAgICAgICAgIFJYIGJ5dGVzOjAgKDAuMCBCKSAgVFggYnl0ZXM6MCAoMC4wIEIpCgp4 ZW5fYnJpZGdlIExpbmsgZW5jYXA6RXRoZXJuZXQgIEhXYWRkciBmZTpmZjpmZjpmZjpmZjpm ZiAgCiAgICAgICAgICBpbmV0IGFkZHI6MTkyLjE2OC4xLjEgIEJjYXN0OjE5Mi4xNjguMS4y NTUgIE1hc2s6MjU1LjI1NS4yNTUuMAogICAgICAgICAgVVAgQlJPQURDQVNUIFJVTk5JTkcg TVVMVElDQVNUICBNVFU6MTUwMCAgTWV0cmljOjEKICAgICAgICAgIFJYIHBhY2tldHM6NDM1 ODY4MiBlcnJvcnM6MCBkcm9wcGVkOjAgb3ZlcnJ1bnM6MCBmcmFtZTowCiAgICAgICAgICBU WCBwYWNrZXRzOjY1Mzk4OTQgZXJyb3JzOjAgZHJvcHBlZDowIG92ZXJydW5zOjAgY2Fycmll cjowCiAgICAgICAgICBjb2xsaXNpb25zOjAgdHhxdWV1ZWxlbjowIAogICAgICAgICAgUlgg Ynl0ZXM6MzQ5NzczNTI5MiAoMy4yIEdpQikgIFRYIGJ5dGVzOjM3MDI2NzEzNjYgKDMuNCBH aUIpCgo= ------------0420FB0940DD99E7F Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Disposition: inline _______________________________________________ Xen-devel mailing list Xen-devel@lists.xen.org http://lists.xen.org/xen-devel ------------0420FB0940DD99E7F-- From xen-devel-bounces@lists.xen.org Wed Mar 12 18:42:18 2014 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Wed, 12 Mar 2014 18:42:18 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WNo6c-0006ei-Ou; Wed, 12 Mar 2014 18:42:18 +0000 Received: from mail6.bemta5.messagelabs.com ([195.245.231.135]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WNo6a-0006dU-Rv for xen-devel@lists.xen.org; Wed, 12 Mar 2014 18:42:17 +0000 Received: from [85.158.139.211:12480] by server-9.bemta-5.messagelabs.com id FA/4D-04350-88AA0235; Wed, 12 Mar 2014 18:42:16 +0000 X-Env-Sender: dgdegra@tycho.nsa.gov X-Msg-Ref: server-3.tower-206.messagelabs.com!1394649724!640595!1 X-Originating-IP: [63.239.67.10] X-SpamReason: No, hits=0.5 required=7.0 tests=BODY_RANDOM_LONG X-StarScan-Received: X-StarScan-Version: 6.11.1; banners=-,-,- X-VirusChecked: Checked Received: (qmail 25046 invoked from network); 12 Mar 2014 18:42:04 -0000 Received: from emvm-gh1-uea09.nsa.gov (HELO nsa.gov) (63.239.67.10) by server-3.tower-206.messagelabs.com with SMTP; 12 Mar 2014 18:42:04 -0000 X-TM-IMSS-Message-ID: <102fb32e0018395c@nsa.gov> Received: from tarius.tycho.ncsc.mil ([144.51.242.1]) by nsa.gov ([63.239.67.10]) with ESMTP (TREND IMSS SMTP Service 7.1; TLSv1/SSLv3 DHE-RSA-AES256-SHA (256/256)) id 102fb32e0018395c ; Wed, 12 Mar 2014 14:43:28 -0400 Received: from moss-nexus.epoch.ncsc.mil (moss-nexus [192.168.25.48]) by tarius.tycho.ncsc.mil (8.14.4/8.14.4) with ESMTP id s2CIflFh004171; Wed, 12 Mar 2014 14:41:57 -0400 From: Daniel De Graaf To: xen-devel@lists.xen.org Date: Wed, 12 Mar 2014 14:41:04 -0400 Message-Id: <1394649667-2229-2-git-send-email-dgdegra@tycho.nsa.gov> X-Mailer: git-send-email 1.8.5.3 In-Reply-To: <1394649667-2229-1-git-send-email-dgdegra@tycho.nsa.gov> References: <1394649667-2229-1-git-send-email-dgdegra@tycho.nsa.gov> Cc: Daniel De Graaf Subject: [Xen-devel] [PATCH 1/4] vtpmmgr: add TPM group support X-BeenThere: xen-devel@lists.xen.org X-Mailman-Version: 2.1.13 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Sender: xen-devel-bounces@lists.xen.org Errors-To: xen-devel-bounces@lists.xen.org This is a complete rewrite of the disk format and key hierarchy for the TPM Manager. The new format supports multiple groups of vTPMs which define the permitted configurations where a given vTPM's keys are available, allowing upgrades of critical components while retaining the secrecy of cryptographic keys. New features of the TPM Manager are explained in the README and in the definitions of the management commands in vtpm_manager.h. New features for vTPMs: 1. The size of the state blob for a vTPM is expanded from 52 to 64 bytes in order to support future vTPMs using SHA-2/3 instead of SHA-1. 2. vTPMs can obtain a quote from the physical TPM with certain resettable PCRs set to include information about the vTPM. This can be used by a vTPM to provide evidence of its integrity, including the secrecy of its EK, and for deep quotes. Some additional changes made by this rewrite that may impact existing users: 1. The value of WELLKNOWN_OWNER_AUTH was incorrect for the physical TPM; the convention is to use all zero bits for well-known authentication values, not all one bits. 2. Randomly generating the owner auth value for the physical TPM is no longer supported, as it prevents later creation or certification of AIKs (which the old manager did not support). 3. The vTPM Manager needs to be provisioned with a PCR composite and an upgrade authority's public key before it will save data across boots. The current implementation still has some limitations: * 5 valid system PCR selections per group * The vTPM Manager's disk can use at most 2MB of space * The vTPM domain's build hash is always set to null/zero Most of the code relating to upgrade and rollback protection is currently stubbed out, but future versions can add: * Support for using the TPM's monotonic counter to prevent rollback of vTPM data by taking and restoring disk snapshots * Masking the master disk encryption key using a value stored in the TPM's NVRAM so that revocation of old data is possible without relying on all previously authorized software stacks to respect the monotonic counter's value Signed-off-by: Daniel De Graaf --- stubdom/vtpmmgr/Makefile | 4 +- stubdom/vtpmmgr/README | 159 +++-- stubdom/vtpmmgr/disk_crypto.c | 231 ++++++ stubdom/vtpmmgr/disk_crypto.h | 17 + stubdom/vtpmmgr/disk_format.h | 193 +++++ stubdom/vtpmmgr/disk_io.c | 125 ++++ stubdom/vtpmmgr/disk_io.h | 25 + stubdom/vtpmmgr/disk_read.c | 606 ++++++++++++++++ stubdom/vtpmmgr/disk_tpm.c | 238 +++++++ stubdom/vtpmmgr/disk_tpm.h | 25 + stubdom/vtpmmgr/disk_write.c | 410 +++++++++++ stubdom/vtpmmgr/endian_int.h | 72 ++ stubdom/vtpmmgr/init.c | 104 +-- stubdom/vtpmmgr/log.h | 8 +- stubdom/vtpmmgr/marshal.h | 824 ++++++++++++++-------- stubdom/vtpmmgr/mgmt_authority.c | 323 +++++++++ stubdom/vtpmmgr/mgmt_authority.h | 11 + stubdom/vtpmmgr/tcg.h | 7 + stubdom/vtpmmgr/tpm.c | 1360 ++++++++++++++++++------------------ stubdom/vtpmmgr/tpm.h | 104 +-- stubdom/vtpmmgr/tpmrsa.c | 25 + stubdom/vtpmmgr/tpmrsa.h | 3 + stubdom/vtpmmgr/vtpm_cmd_handler.c | 856 ++++++++++++++++++++--- stubdom/vtpmmgr/vtpm_disk.c | 237 +++++++ stubdom/vtpmmgr/vtpm_disk.h | 233 ++++++ stubdom/vtpmmgr/vtpm_manager.h | 391 ++++++++++- stubdom/vtpmmgr/vtpm_storage.c | 794 --------------------- stubdom/vtpmmgr/vtpm_storage.h | 68 -- stubdom/vtpmmgr/vtpmmgr.h | 12 +- 29 files changed, 5308 insertions(+), 2157 deletions(-) create mode 100644 stubdom/vtpmmgr/disk_crypto.c create mode 100644 stubdom/vtpmmgr/disk_crypto.h create mode 100644 stubdom/vtpmmgr/disk_format.h create mode 100644 stubdom/vtpmmgr/disk_io.c create mode 100644 stubdom/vtpmmgr/disk_io.h create mode 100644 stubdom/vtpmmgr/disk_read.c create mode 100644 stubdom/vtpmmgr/disk_tpm.c create mode 100644 stubdom/vtpmmgr/disk_tpm.h create mode 100644 stubdom/vtpmmgr/disk_write.c create mode 100644 stubdom/vtpmmgr/endian_int.h create mode 100644 stubdom/vtpmmgr/mgmt_authority.c create mode 100644 stubdom/vtpmmgr/mgmt_authority.h create mode 100644 stubdom/vtpmmgr/vtpm_disk.c create mode 100644 stubdom/vtpmmgr/vtpm_disk.h delete mode 100644 stubdom/vtpmmgr/vtpm_storage.c delete mode 100644 stubdom/vtpmmgr/vtpm_storage.h diff --git a/stubdom/vtpmmgr/Makefile b/stubdom/vtpmmgr/Makefile index af13b39..a39a22c 100644 --- a/stubdom/vtpmmgr/Makefile +++ b/stubdom/vtpmmgr/Makefile @@ -12,7 +12,9 @@ XEN_ROOT=../.. TARGET=vtpmmgr.a -OBJS=vtpmmgr.o vtpm_cmd_handler.o vtpm_storage.o init.o tpmrsa.o tpm.o log.o +OBJS=vtpmmgr.o vtpm_cmd_handler.o init.o tpmrsa.o tpm.o log.o +OBJS += vtpm_disk.o disk_tpm.o disk_io.o disk_crypto.o disk_read.o disk_write.o +OBJS += mgmt_authority.o CFLAGS+=-Werror -Iutil -Icrypto -Itcs CFLAGS+=-Wno-declaration-after-statement -Wno-unused-label diff --git a/stubdom/vtpmmgr/README b/stubdom/vtpmmgr/README index a70c1cc..f51ccf8 100644 --- a/stubdom/vtpmmgr/README +++ b/stubdom/vtpmmgr/README @@ -1,75 +1,112 @@ -Copyright (c) 2010-2012 United States Government, as represented by -the Secretary of Defense. All rights reserved. -November 12 2012 -Authors: Matthew Fioravante (JHUAPL), - -This document describes the operation and command line interface -of vtpmmgr-stubdom. See docs/misc/vtpm.txt for details on the -vTPM subsystem as a whole. - - ------------------------------- -OPERATION ------------------------------- - -The vtpmmgr-stubdom implements a vTPM manager who has two major functions: - - - Securely store encryption keys for each of the vTPMS - - Regulate access to the hardware TPM for the entire system - -The manager accepts commands from the vtpm-stubdom domains via the mini-os -TPM backend driver. The vTPM manager communicates directly with hardware TPM -using the mini-os tpm_tis driver. - - -When the manager starts for the first time it will check if the TPM -has an owner. If the TPM is unowned, it will attempt to take ownership -with the supplied owner_auth (see below) and then create a TPM -storage key which will be used to secure vTPM key data. Currently the -manager only binds vTPM keys to the disk. In the future support -for sealing to PCRs should be added. - ------------------------------- -COMMAND LINE ARGUMENTS ------------------------------- - -Command line arguments are passed to the domain via the 'extra' -parameter in the VM config file. Each parameter is separated -by white space. For example: +Author: Daniel De Graaf + +This document describes the operation and command line interface of +vtpmmgr-stubdom. See docs/misc/vtpm.txt for details on the vTPM subsystem as a +whole. + +================================================================================ +Overview +================================================================================ + +The TPM Manager has three primary functions: + +1. Securely store the encryption keys for vTPMs +2. Provide a single controlled path of access to the physical TPM +3. Provide evidence (via TPM Quotes) of the current configuration + +When combined with a platform that provides a trusted method for creating +domains, the TPM Manager provides assurance that the private keys in a vTPM are +only available in specific trusted configurations. + +The manager accepts commands from the vtpm-stubdom domains via the mini-os TPM +backend driver. The vTPM manager communicates directly with hardware TPM using +the mini-os tpm_tis driver. + +================================================================================ +Boot Configurations and TPM Groups +================================================================================ + +The TPM Manager's data is secured by using the physical TPM's seal operation, +which allows data to be bound to specific PCRs. These PCRs are populated in the +physical TPM during the boot process, either by the firmware/BIOS or by a +dynamic launch environment such as TBOOT. In order to provide assurance of the +system's security, the PCRs used to seal the TPM manager's data must contain +measurements for domains used to bootstrap the TPM Manager and vTPMs. + +Because these measurements are based on hashes, they will change any time that +any component of the system is upgraded. Since it is not possible to construct a +list of all possible future good measurements, the job of approving +configurations is delegated to a third party, referred to here as the system +approval agent (SAA). The SAA is identified by its public (RSA) signature key, +which is used to sign lists of valid configurations. A single TPM manager can +support multiple SAAs via the use of vTPM groups. Each group is associated with +a single SAA; this allows the creation of a multi-tenant environment where +tenants may not all choose to trust the same SAA. + +Each vTPM is bound to a vTPM group at the time of its creation. Each vTPM group +has its own AIK in the physical TPM for quotes of the hardware TPM state; when +used with a conforming Privacy CA, this allows each group on the system to form +the basis of a distinct identity. + +================================================================================ +Initial Provisioning +================================================================================ + +When the TPM Manager first boots up, it will create a stub vTPM group along with +entries for any vTPMs that communicate with it. This stub group must be +provisioned with an SAA and a boot configuration in order to survive a reboot. + +When a vTPM is connected to the TPM Manager using a UUID that is not recognized, +a slot will be created in group 0 for it. In the future, this auto-creation may +be restricted to specific UUIDs (such as the all-zero UUID) to enforce the use +of the TPM manager as the generator of the UUID. The first vTPM to be connected +is given administrative privileges for the TPM Manager, and should be attached +to dom0 or a control domain in order to send provisioning commands. + +Provisioning a vTPM group for the system requires the public key of the SAA and +privacy CA data used to certify the AIK (see the TPM spec for details). Once the +group is created, a signed list of boot measurements can be installed. The +initial group controls the ability to boot the system as a whole, and cannot be +deleted once provisioned. + +================================================================================ +Command Line Arguments +================================================================================ + +Command line arguments are passed to the domain via the 'extra' parameter in the +VM config file. Each parameter is separated by white space. For example: extra="foo=bar baz" -List of Arguments: ------------------- +Valid arguments: -owner_auth=: Set the owner auth of the TPM. The default - is the well known owner auth of all ones. +owner_auth= +srk_auth= + Set the owner and SRK authdata for the TPM. If not specified, the + default is 160 zero bits (the well-known auth value). Valid values of + are: + well-known Use the well known auth (default) + hash: Use the given 40-character ASCII hex string + text: Use sha1 hash of . -srk_auth=: Set the SRK auth for the TPM. The default is - the well known srk auth of all zeroes. - The possible values of are: - well-known: Use the well known auth (default) - random: Randomly generate an auth - hash: : Use the given 40 character ASCII hex string - text: : Use sha1 hash of . +tpmdriver= + Choose the driver used for communication with the hardware TPM. Values + other than tpm_tis should only be used for testing. -tpmdriver=: Which driver to use to talk to the hardware TPM. - Don't change this unless you know what you're doing. The possible values of are: - tpm_tis: Use the tpm_tis driver to talk directly to the TPM. - The domain must have access to TPM IO memory. (default) - tpmfront: Use tpmfront to talk to the TPM. The domain must have - a tpmfront device setup to talk to another domain - which provides access to the TPM. + tpm_tis Direct communication with a hardware TPM 1.2. The + domain must have access to TPM IO memory. (default) + tpmfront Use the Xen tpmfront interface to talk to another + domain which provides access to the TPM. The following options only apply to the tpm_tis driver: -tpmiomem=: The base address of the hardware memory pages of the - TPM (default 0xfed40000). +tpmiomem=: The base address of the hardware memory pages of the TPM. + The default is 0xfed40000, as defined by the TCG's PC Client spec. tpmirq=: The irq of the hardware TPM if using interrupts. A value of - "probe" can be set to probe for the irq. A value of 0 - disabled interrupts and uses polling (default 0). + "probe" can be set to probe for the irq. A value of 0 disables + interrupts and uses polling (default 0). tpmlocality=: Attempt to use locality of the hardware TPM. - (default 0) + For full functionality of the TPM Manager, this should be set to "2". diff --git a/stubdom/vtpmmgr/disk_crypto.c b/stubdom/vtpmmgr/disk_crypto.c new file mode 100644 index 0000000..18718d0 --- /dev/null +++ b/stubdom/vtpmmgr/disk_crypto.c @@ -0,0 +1,231 @@ +#include +#include +#include +#include +#include + +#include "log.h" +#include "vtpmmgr.h" +#include "vtpm_disk.h" +#include "disk_io.h" +#include "disk_crypto.h" + +// XXX defining this stubs out all disk encryption for easier debugging +#undef DISK_IS_PLAINTEXT + +void do_random(void *buf, size_t size) +{ + int rc = ctr_drbg_random(&vtpm_globals.ctr_drbg, buf, size); + if (rc) abort(); +} + +void aes_setup(aes_context *ctx, const struct key128 *key) +{ + aes_setkey_enc(ctx, (void*)key, 128); +} + +static void aes_encrypt_ecb(void *target, const void *src, const aes_context *key_e) +{ + aes_crypt_ecb((void*)key_e, AES_ENCRYPT, src, target); +} + +void aes_encrypt_one(void *target, const void *src, const struct key128 *key) +{ + aes_context ctx; + aes_setkey_enc(&ctx, (void*)key, 128); + aes_crypt_ecb(&ctx, AES_ENCRYPT, src, target); +} + +void aes_decrypt_one(void *target, const void *src, const struct key128 *key) +{ + aes_context ctx; + aes_setkey_dec(&ctx, (void*)key, 128); + aes_crypt_ecb(&ctx, AES_DECRYPT, src, target); +} + +static void aes_ctr_one(uint64_t out[2], uint64_t ctr[2], const aes_context *key_e) +{ +#ifdef DISK_IS_PLAINTEXT + memset(out, 0, 16); +#else + aes_encrypt_ecb(out, ctr, key_e); +#endif + ctr[1]++; +} + +void aes_encrypt_ctr(void *target, size_t target_size, const void *srcv, size_t pt_size, const aes_context *key_e) +{ + uint64_t ctr[2]; + uint64_t tmp[2]; + uint64_t *dst = target; + const uint64_t *src = srcv; + + do_random(ctr, sizeof(ctr)); + dst[0] = ctr[0]; + dst[1] = ctr[1]; + dst += 2; + target_size -= 16; + + if (pt_size > target_size) + abort(); // invalid argument: target too small for plaintext + + while (pt_size >= 16) { + aes_ctr_one(tmp, ctr, key_e); + + dst[0] = tmp[0] ^ src[0]; + dst[1] = tmp[1] ^ src[1]; + + dst += 2; + src += 2; + pt_size -= 16; + target_size -= 16; + } + if (pt_size) { + uint64_t stmp[2]; + uint64_t dtmp[2]; + memset(stmp, 0, 16); + memcpy(stmp, src, pt_size); + + aes_ctr_one(tmp, ctr, key_e); + + dtmp[0] = tmp[0] ^ stmp[0]; + dtmp[1] = tmp[1] ^ stmp[1]; + if (target_size < 16) { + memcpy(dst, dtmp, target_size); + return; + } else { + memcpy(dst, dtmp, 16); + target_size -= 16; + } + } + while (target_size >= 16) { + aes_ctr_one(dst, ctr, key_e); + + dst += 2; + target_size -= 16; + } + if (target_size) + abort(); // invalid argument: overlarge target size is not a full block +} + +void aes_decrypt_ctr(void *target, size_t pt_size, const void *srcv, size_t src_size, const aes_context *key_e) +{ + uint64_t ctr[2]; + uint64_t tmp[2]; + uint64_t *dst = target; + const uint64_t *src = srcv; + + ctr[0] = src[0]; + ctr[1] = src[1]; + src += 2; + src_size -= 16; + + if (pt_size > src_size) + abort(); // invalid argument: source too small for plaintext + // we discard src_size now + + while (pt_size >= 16) { + aes_ctr_one(tmp, ctr, key_e); + dst[0] = tmp[0] ^ src[0]; + dst[1] = tmp[1] ^ src[1]; + + dst += 2; + src += 2; + pt_size -= 16; + } + if (pt_size) { + uint64_t stmp[2]; + uint64_t dtmp[2]; + memset(stmp, 0, 16); + memcpy(stmp, src, pt_size); + + aes_ctr_one(tmp, ctr, key_e); + + dtmp[0] = tmp[0] ^ stmp[0]; + dtmp[1] = tmp[1] ^ stmp[1]; + memcpy(dst, dtmp, pt_size); + } +} + +static void shl_128_mod_hex87(struct mac128 *dst, const struct mac128 *src) +{ + int i; + int carry = 0x87 * !!(src->bits[0] & 0x80); + for(i=0; i < 15; i++) + dst->bits[i] = (src->bits[i] << 1) | (src->bits[i+1] >> 7); + dst->bits[15] = (src->bits[15] << 1) ^ carry; +} + +static void xor128(struct mac128 *dst, const struct mac128 *s1, const struct mac128 *s2) +{ + int i; + for(i=0; i < 16; i++) + dst->bits[i] = s1->bits[i] ^ s2->bits[i]; +} + +void aes_cmac(struct mac128 *target, const void *src, size_t size, const aes_context *key) +{ + const struct mac128 *M = src; + struct mac128 x, y, L, K1, K2; + int i; + size_t bsize = (size - 1) / 16; + + memset(&x, 0, sizeof(x)); + aes_encrypt_ecb(&L, &x, key); + shl_128_mod_hex87(&K1, &L); + shl_128_mod_hex87(&K2, &K1); + + for(i=0; i < bsize; i++) { + xor128(&y, &x, &M[i]); + aes_encrypt_ecb(&x, &y, key); + } + if (size & 0xF) { + struct mac128 z; + memset(&z, 0, sizeof(z)); + memcpy(&z, M + bsize, size & 0xF); + xor128(&y, &x, &K2); + xor128(&x, &y, &z); + } else { + xor128(&y, &x, &K1); + xor128(&x, &y, M + bsize); + } + aes_encrypt_ecb(target, &x, key); +} + +static int verify_128(const void *a, const void* b) +{ + const volatile uint64_t *x = a; + const volatile uint64_t *y = b; + if ((x[0] ^ y[0]) | (x[1] ^ y[1])) + return 1; + return 0; +} + +int aes_cmac_verify(const struct mac128 *target, const void *src, size_t size, const aes_context *key) +{ + struct mac128 mac; + aes_cmac(&mac, src, size, key); + return verify_128(&mac, target); +} + +static int verify_256(const void *a, const void* b) +{ + const volatile uint64_t *x = a; + const volatile uint64_t *y = b; + if ((x[0] ^ y[0]) | (x[1] ^ y[1]) | (x[2] ^ y[2]) | (x[3] ^ y[3])) + return 1; + return 0; +} + +void sha256(struct hash256 *target, const void *src, size_t size) +{ + void* dst = target; + sha2(src, size, dst, 0); +} + +int sha256_verify(const struct hash256 *targ, const void *data, size_t size) +{ + struct hash256 hash; + sha256(&hash, data, size); + return verify_256(&hash, targ); +} diff --git a/stubdom/vtpmmgr/disk_crypto.h b/stubdom/vtpmmgr/disk_crypto.h new file mode 100644 index 0000000..faae9ab --- /dev/null +++ b/stubdom/vtpmmgr/disk_crypto.h @@ -0,0 +1,17 @@ +#ifndef __VTPMMGR_DISK_CRYPTO_H +#define __VTPMMGR_DISK_CRYPTO_H + +void do_random(void *buf, size_t size); +void aes_encrypt_one(void *target, const void *src, const struct key128 *key); +void aes_decrypt_one(void *target, const void *src, const struct key128 *key); + +void aes_setup(aes_context *ctx, const struct key128 *key); +void aes_encrypt_ctr(void *target, size_t target_size, const void *srcv, size_t src_size, const aes_context *key_e); +void aes_decrypt_ctr(void *target, size_t target_size, const void *srcv, size_t src_size, const aes_context *key_e); +void aes_cmac(struct mac128 *target, const void *src, size_t size, const aes_context *key); +int aes_cmac_verify(const struct mac128 *target, const void *src, size_t size, const aes_context *key); + +void sha256(struct hash256 *target, const void *src, size_t size); +int sha256_verify(const struct hash256 *targ, const void *data, size_t size); + +#endif diff --git a/stubdom/vtpmmgr/disk_format.h b/stubdom/vtpmmgr/disk_format.h new file mode 100644 index 0000000..bc20fbb --- /dev/null +++ b/stubdom/vtpmmgr/disk_format.h @@ -0,0 +1,193 @@ +#ifndef __VTPMMGR_DISK_FORMAT_H +#define __VTPMMGR_DISK_FORMAT_H + +static const uint8_t TPM_MGR_MAGIC[12] = { + 'T','P','M',0xfe,'M','G','R',0xdd,'D','O','M',0x00 +}; + +/** + * Sector 0 on disk: stored in plaintext + */ +struct disk_header { + char magic[12]; +#define TPM_MGR_VERSION 0 + be32_t version; +}; + +/** + * Raw contents of disk sectors that need both encryption and authentication + */ +struct disk_crypt_sector_plain { + struct mac128 mac; + union { + struct { + uint8_t iv[16]; + char data[4096-32]; + }; + uint8_t iv_data[4096-16]; + }; +}; + +/** + * Contents of the sealed blob in the root seal list + */ +struct disk_root_sealed_data { +#define DISK_ROOT_BOUND_MAGIC "Root" + char magic[4]; + uuid_t tpm_manager_uuid; + + be32_t nvram_slot; + struct tpm_authdata nvram_auth; + be32_t counter_index; + struct tpm_authdata counter_auth; + + /* encrypted (AES-ECB) with key from NVRAM */ + struct key128 tm_key; +}; + +/** + * Contents of the sealed blob in a group's seal list + */ +struct disk_group_sealed_data { +#define DISK_GROUP_BOUND_MAGIC "TGrp" + char magic[4]; + uuid_t tpm_manager_uuid; + struct tpm_authdata aik_authdata; + + struct key128 group_key; + struct key128 rollback_mac_key; +}; + +/** + * Contents of the seal_list_N sectors on disk (plaintext, linked list) + * + * The hdr field is unused except in sector 0 + */ +struct disk_seal_list { + struct disk_header hdr; + be32_t length; + sector_t next; +#define SEALS_PER_ROOT_SEAL_LIST 13 + struct disk_seal_entry entry[SEALS_PER_ROOT_SEAL_LIST]; +}; + +/** + * TODO - overflow for struct disk_group_boot_config_list + */ +struct disk_group_seal_list { + sector_t next; +#define SEALS_PER_GROUP_SEAL_LIST 13 + struct disk_seal_entry entry[SEALS_PER_GROUP_SEAL_LIST]; +}; + +/** + * Rollback detection MAC entry + */ +struct disk_rb_mac_entry { + be32_t id; + struct mac128 mac; +}; + +#define NR_ENTRIES_PER_ROOT 16 +/** + * The area of the root sector protected by rollback MACs + */ +struct disk_root_sector_mac1_area { + be64_t sequence; + be32_t tpm_counter_value; + + be32_t nr_groups; + struct hash256 group_hash[NR_ENTRIES_PER_ROOT]; +}; + +/** + * Decrypted contents of the root sector (sector 1 and 2) on disk + */ +struct disk_root_sector { + struct disk_root_sector_mac1_area v; + + sector_t group_loc[NR_ENTRIES_PER_ROOT]; + + uint8_t pad[8]; + + /* Rollback detection MACs */ + be32_t nr_rb_macs; + sector_t rb_next_loc; + /* used if rb_macs overflows */ + struct hash256 rb_next_hash; + +#define NR_RB_MACS_PER_ROOT 128 + struct disk_rb_mac_entry rb_macs[NR_RB_MACS_PER_ROOT]; +}; + +/** + * Hash tree for list expansion. Used for the list of groups in the root and for + * the list of vTPMs in a group. + */ +struct disk_itree_sector { +#define NR_ENTRIES_PER_ITREE 112 + sector_t location[NR_ENTRIES_PER_ITREE]; + /* SECTOR-HASH { */ + struct hash256 hash[NR_ENTRIES_PER_ITREE]; + /* SECTOR-HASH } */ +}; + +#define NR_ENTRIES_PER_GROUP_BASE 16 +/** + * Data that must remain constant if a group is not open + */ +struct disk_group_sector_mac3_area { + struct group_id_data id_data; /* MAC2 */ + struct group_details details; + struct disk_group_boot_config_list boot_configs; + + be32_t nr_vtpms; + struct hash256 vtpm_hash[NR_ENTRIES_PER_GROUP_BASE]; +}; + +/** + * Group metadata sector + * + * Encrypted with TM_KEY - takes 16 bytes for IV; integrity from parent. + */ +struct disk_group_sector { + /* SECTOR-HASH { */ + struct disk_group_sector_mac3_area v; + + /* MAC(MAC3, group_key) */ + struct mac128 group_mac; + /* SECTOR-HASH } */ + + sector_t vtpm_location[NR_ENTRIES_PER_GROUP_BASE]; + sector_t boot_configs_next; +}; + +/** + * Data on a vTPM which is available when its group is not open + */ +struct disk_vtpm_plain { + uuid_t uuid; + be32_t flags; +}; + +/** + * Data on a vTPM which is only available when its group is open + */ +struct disk_vtpm_secret { + uint8_t data[64]; +}; + +/** + * Contents of a vTPM data disk sector + * + * Encrypted with TM_KEY - takes 16 bytes for IV + */ +struct disk_vtpm_sector { + /* SECTOR-HASH { */ + struct disk_vtpm_plain header[VTPMS_PER_SECTOR]; + struct mac128 iv; + struct disk_vtpm_secret data[VTPMS_PER_SECTOR]; + /* SECTOR-HASH } */ +}; + +#endif diff --git a/stubdom/vtpmmgr/disk_io.c b/stubdom/vtpmmgr/disk_io.c new file mode 100644 index 0000000..02b4fdd --- /dev/null +++ b/stubdom/vtpmmgr/disk_io.c @@ -0,0 +1,125 @@ +#include +#include +#include +#include +#include +#include +#include +#include + +#include "vtpm_manager.h" +#include "log.h" +#include "uuid.h" + +#include "vtpmmgr.h" +#include "vtpm_disk.h" +#include "disk_tpm.h" +#include "disk_io.h" + +static uint8_t disk_staging_buf[4096] __attribute__((aligned(4096))); + +static struct blkfront_dev* blkdev; +static int blkfront_fd = -1; + +int vtpm_storage_init(void) { + struct blkfront_info info; + blkdev = init_blkfront(NULL, &info); + if (blkdev == NULL) + return -1; + blkfront_fd = blkfront_open(blkdev); + if (blkfront_fd < 0) + return -1; + return 0; +} + +void* disk_read_sector(sector_t sector) +{ + uint32_t pos = be32_native(sector); + int rc; + vtpmloginfo(VTPM_LOG_VTPM, "disk_read_sector %x\n", pos); + lseek(blkfront_fd, pos * 4096, SEEK_SET); + rc = read(blkfront_fd, disk_staging_buf, 4096); + if (rc != 4096) + abort(); + return disk_staging_buf; +} + +void* disk_write_buf(void) { return disk_staging_buf; } + +void disk_write_sector(sector_t sector, void* buf, size_t siz) +{ + int rc; + uint32_t pos = be32_native(sector); + lseek(blkfront_fd, pos * 4096, SEEK_SET); + if (siz < 4096) { + if (buf != disk_staging_buf) + memcpy(disk_staging_buf, buf, siz); + memset(disk_staging_buf + siz, 0, 4096 - siz); + buf = disk_staging_buf; + } else if (siz > 4096) + abort(); + + rc = write(blkfront_fd, buf, 4096); + if (rc != 4096) + abort(); +} + +void disk_write_barrier(void) +{ + blkfront_sync(blkdev); +} + +enum inuse_value { + UNUSED, + SLOT_1, + SLOT_2, + SHARED +}; + +/* TODO make this dynamic to support using more than 2MB of disk */ +#define DISK_MAX_SECTOR 0x200 + +/* The first 4 sectors are statically allocated: + * 0 - disk header (copy 1) + * 1 - disk header (copy 2) + * 2 - root sector (copy 1) + * 3 - root sector (copy 2) + */ +#define FIRST_DYNAMIC_SECTOR 4 + +static uint8_t sector_inuse_map[DISK_MAX_SECTOR]; + +static int active_slot(const struct mem_tpm_mgr *mgr) +{ + return 1 + mgr->active_root; +} + +void disk_set_used(sector_t loc, const struct mem_tpm_mgr *mgr) +{ + uint32_t s = be32_native(loc); + if (s > DISK_MAX_SECTOR) { + printk("Attempted disk_set_used %x\n", s); + return; + } + sector_inuse_map[s] |= active_slot(mgr); +} + +void disk_flush_slot(const struct mem_tpm_mgr *mgr) +{ + int i; + for(i = FIRST_DYNAMIC_SECTOR; i < DISK_MAX_SECTOR; i++) + sector_inuse_map[i] &= ~active_slot(mgr); +} + +sector_t disk_find_free(const struct mem_tpm_mgr *mgr) +{ + int i; + for(i = FIRST_DYNAMIC_SECTOR; i < DISK_MAX_SECTOR; i++) { + if (sector_inuse_map[i]) + continue; + sector_inuse_map[i] = active_slot(mgr); + return native_be32(i); + } + // TODO more graceful error handling (in callers) + abort(); +} diff --git a/stubdom/vtpmmgr/disk_io.h b/stubdom/vtpmmgr/disk_io.h new file mode 100644 index 0000000..c0d35a5 --- /dev/null +++ b/stubdom/vtpmmgr/disk_io.h @@ -0,0 +1,25 @@ +#ifndef __VTPMMGR_DISK_IO_H +#define __VTPMMGR_DISK_IO_H + +void* disk_read_sector(sector_t sector); +void disk_write_sector(sector_t sector, void* buf, size_t siz); +void* disk_write_buf(void); +void disk_write_barrier(void); + +sector_t disk_find_free(const struct mem_tpm_mgr *mgr); +void disk_flush_slot(const struct mem_tpm_mgr *mgr); +void disk_set_used(sector_t loc, const struct mem_tpm_mgr *mgr); + +void disk_write_all(struct mem_tpm_mgr *mgr); + +static inline sector_t seal_loc(struct mem_tpm_mgr *mgr) +{ + return native_be32(mgr->active_root); +} + +static inline sector_t root_loc(struct mem_tpm_mgr *mgr) +{ + return native_be32(2 + mgr->active_root); +} + +#endif diff --git a/stubdom/vtpmmgr/disk_read.c b/stubdom/vtpmmgr/disk_read.c new file mode 100644 index 0000000..33aacdd --- /dev/null +++ b/stubdom/vtpmmgr/disk_read.c @@ -0,0 +1,606 @@ +#include +#include +#include +#include +#include +#include +#include +#include + +#include "vtpm_manager.h" +#include "log.h" +#include "uuid.h" + +#include "vtpmmgr.h" +#include "vtpm_disk.h" +#include "disk_tpm.h" +#include "disk_io.h" +#include "disk_crypto.h" +#include "disk_format.h" + +static int disk_read_crypt_sector(void *data, size_t size, sector_t block, const struct mem_tpm_mgr *mgr) +{ + struct disk_crypt_sector_plain *sector = disk_read_sector(block); + if (!sector) + return 2; + + if (aes_cmac_verify(§or->mac, sector->data, sizeof(sector->data), &mgr->tm_key_e)) + return 2; + + aes_decrypt_ctr(data, size, sector->iv_data, sizeof(sector->iv_data), &mgr->tm_key_e); + return 0; +} + +static void group_free(struct mem_group *group) +{ + int i, j; + if (!group) + return; + if (group->data) { + for (i = 0; i < group->nr_pages; i++) { + for (j = 0; j < group->data[i].size; j++) { + free(group->data[i].vtpms[j]); + } + } + free(group->data); + } + free(group->seals); + free(group); +} + +static void mgr_free(struct mem_tpm_mgr *mgr) +{ + int i; + if (!mgr) + return; + if (mgr->groups) { + for(i=0; i < mgr->nr_groups; i++) + group_free(mgr->groups[i].v); + free(mgr->groups); + } + free(mgr); +} + +/* Open the group keys from one of the sealed strutures */ +static int find_group_key(struct mem_group *dst, + const struct disk_group_sector *group, + const struct mem_tpm_mgr *parent) +{ + int i, rc, rv = 1; + struct hash160 buf; + struct disk_group_sealed_data sealed; + + dst->nr_seals = be32_native(group->v.boot_configs.nr_cfgs); + if (dst->nr_seals > NR_SEALS_PER_GROUP) + return 3; // TODO support spill to extra pages + + dst->seals = calloc(dst->nr_seals, sizeof(dst->seals[0])); + if (!dst->seals) { + vtpmlogerror(VTPM_LOG_VTPM, "find_group_key alloc %x\n", dst->nr_seals); + return 2; + } + + for(i=0; i < dst->nr_seals; i++) { + const struct disk_seal_entry *cfg = &group->v.boot_configs.entry[i]; + dst->seals[i].pcr_selection = cfg->pcr_selection; + memcpy(&dst->seals[i].digest_release, &cfg->digest_release, 20); + + TPM_pcr_digest(&buf, cfg->pcr_selection); + if (memcmp(&buf, &cfg->digest_release, 20)) + continue; + rc = TPM_disk_unseal(&sealed, sizeof(sealed), cfg); + if (rc) + continue; + if (memcmp(&sealed.magic, DISK_GROUP_BOUND_MAGIC, 4)) + continue; + if (memcmp(sealed.tpm_manager_uuid, parent->uuid, 16)) + continue; + + memcpy(&dst->rollback_mac_key, &sealed.rollback_mac_key, 16); + memcpy(&dst->group_key, &sealed.group_key, 16); + memcpy(&dst->aik_authdata, &sealed.aik_authdata, 20); + rv = 0; + } + + // cache the list to allow writes without touching the TPM + memcpy(&dst->seal_bits, &group->v.boot_configs, sizeof(dst->seal_bits)); + dst->flags |= MEM_GROUP_FLAG_SEAL_VALID; + + return rv; +} + +static int parse_root_key(struct mem_tpm_mgr *dst, struct disk_seal_entry *src) +{ + int rc; + struct disk_root_sealed_data sealed; + + rc = TPM_disk_unseal(&sealed, sizeof(sealed), src); + if (rc) + return rc; + + if (memcmp(&sealed.magic, DISK_ROOT_BOUND_MAGIC, 4)) + return 1; + + rc = TPM_disk_nvread(&dst->nv_key, 16, sealed.nvram_slot, sealed.nvram_auth); + if (rc) + return rc; + + // TODO when an NV slot in the physical TPM is used to populate nv_key, + // that value should be used to mask the master key so that the value + // can be changed to revoke old disk state +#if 0 + aes_decrypt_one(&dst->tm_key, &sealed.tm_key, &dst->nv_key); +#else + memcpy(&dst->tm_key, &sealed.tm_key, 16); +#endif + + memcpy(dst->uuid, sealed.tpm_manager_uuid, 16); + dst->nvram_slot = sealed.nvram_slot; + memcpy(&dst->nvram_auth, &sealed.nvram_auth, sizeof(struct tpm_authdata)); + dst->counter_index = sealed.counter_index; + memcpy(&dst->counter_auth, &sealed.counter_auth, sizeof(struct tpm_authdata)); + + return 0; +} + +static struct mem_tpm_mgr *find_root_key(int active_root) +{ + sector_t seal_list = native_be32(active_root); + struct disk_seal_list *seal = disk_read_sector(seal_list); + struct hash160 buf; + int i, rc, nr; + struct mem_tpm_mgr *dst; + + if (memcmp(seal->hdr.magic, TPM_MGR_MAGIC, 12)) + return NULL; + + if (be32_native(seal->hdr.version) != TPM_MGR_VERSION) + return NULL; + + dst = calloc(1, sizeof(*dst)); + dst->active_root = active_root; + + for (nr = 0; nr < 100; nr++) { + disk_set_used(seal_list, dst); + uint32_t nr_seals = be32_native(seal->length); + if (nr_seals > SEALS_PER_ROOT_SEAL_LIST) + break; + for (i = 0; i < nr_seals; i++) { + struct disk_seal_entry *src = &seal->entry[i]; + + TPM_pcr_digest(&buf, src->pcr_selection); + if (memcmp(&buf, &src->digest_release, 20)) + continue; + + rc = parse_root_key(dst, src); + if (rc) + continue; + return dst; + } + seal_list = seal->next; + if (seal_list.value == 0) + break; + seal = disk_read_sector(seal_list); + } + mgr_free(dst); + return NULL; +} + +/* Load and verify one sector's worth of vTPMs. This loads all the vTPM entries + * and decrypts their state data into memory. + */ +static int load_verify_vtpm_page(struct mem_vtpm_page *dst, int base, + const struct mem_tpm_mgr *mgr, const aes_context *group_key) +{ + struct disk_vtpm_sector pt; + int i, rc; + + disk_set_used(dst->disk_loc, mgr); + + rc = disk_read_crypt_sector(&pt, sizeof(pt), dst->disk_loc, mgr); + if (rc) { + printk("Malformed sector %d\n", be32_native(dst->disk_loc)); + return rc; + } + + rc = sha256_verify(&dst->disk_hash, &pt, sizeof(pt)); + if (rc) { + printk("Hash mismatch in sector %d\n", be32_native(dst->disk_loc)); + return rc; + } + + if (!group_key) + return 0; + + aes_decrypt_ctr(pt.data, sizeof(pt.data), &pt.iv, sizeof(pt.data) + 16, group_key); + + for (i = 0; i < dst->size; i++) { + struct mem_vtpm *vtpm = calloc(1, sizeof(*vtpm)); + dst->vtpms[i] = vtpm; + memcpy(vtpm->uuid, pt.header[i].uuid, 16); + memcpy(vtpm->data, pt.data[i].data, 64); + vtpm->flags = be32_native(pt.header[i].flags); + vtpm->index_in_parent = i + base; + } + return 0; +} + +static int load_verify_vtpm_pages(struct mem_group *group, int base, int size, + const struct hash256 *hash, const sector_t *loc, + const struct mem_tpm_mgr *mgr, const aes_context *group_key) +{ + int i, rc; + struct mem_vtpm_page *page = group->data + base; + + /* base was in terms of sectors; convert to vtpms */ + base *= VTPMS_PER_SECTOR; + + for (i = 0; i < size; i++) { + page->disk_hash = hash[i]; + page->disk_loc = loc[i]; + if (group->nr_vtpms - base > VTPMS_PER_SECTOR) + page->size = VTPMS_PER_SECTOR; + else + page->size = group->nr_vtpms - base; + rc = load_verify_vtpm_page(page, base, mgr, group_key); + if (rc) + return rc; + base += VTPMS_PER_SECTOR; + } + + return 0; +} + +static int load_verify_vtpm_itree(struct mem_group_hdr *hdr, int base, int nr_entries, + const struct hash256 *hash, const sector_t *loc, int hsize, + const struct mem_tpm_mgr *mgr, const aes_context *group_key); + +static int load_verify_vtpm_itree(struct mem_group_hdr *hdr, int base, int nr_entries, + const struct hash256 *hash, const sector_t *loc, int hsize, + const struct mem_tpm_mgr *mgr, const aes_context *group_key) +{ + int i, rc, incr = 1, inuse_base = hdr->disk_nr_inuse, lsize; + + // increase tree depth until all entries fit + while (nr_entries > incr * hsize) + incr *= NR_ENTRIES_PER_ITREE; + + // save the list of used sectors (itree and vtpm) in the header + lsize = 1 + (nr_entries - 1) / incr; + hdr->disk_nr_inuse += lsize; + hdr->disk_inuse = realloc(hdr->disk_inuse, hdr->disk_nr_inuse * sizeof(sector_t)); + memcpy(&hdr->disk_inuse[inuse_base], loc, lsize * sizeof(sector_t)); + + // if the entries already fit, process vtpm pages + if (nr_entries <= hsize) + return load_verify_vtpm_pages(hdr->v, base, nr_entries, hash, loc, mgr, group_key); + + for (i = 0; i * incr < nr_entries; i++) { + struct disk_itree_sector pt; + int child_entries = incr; + + // the last sector is not completely full + if (nr_entries - i * incr < incr) + child_entries = nr_entries - i * incr; + + disk_set_used(loc[i], mgr); + hdr->disk_inuse[inuse_base++] = loc[i]; + + rc = disk_read_crypt_sector(&pt, sizeof(pt), loc[i], mgr); + if (rc) { + printk("Malformed sector %d\n", be32_native(loc[i])); + return rc; + } + + rc = sha256_verify(&hash[i], pt.hash, sizeof(pt.hash)); + if (rc) { + printk("Hash mismatch in sector %d\n", be32_native(loc[i])); + return rc; + } + + rc = load_verify_vtpm_itree(hdr, base, child_entries, pt.hash, pt.location, + NR_ENTRIES_PER_ITREE, mgr, group_key); + if (rc) + return rc; + + base += incr; + } + + return 0; +} + +/* Load and verify one group's data structure, including its vTPMs. + */ +static int load_verify_group(struct mem_group_hdr *dst, const struct mem_tpm_mgr *mgr) +{ + struct mem_group *group; + struct disk_group_sector disk; + int rc; + aes_context key_e; + aes_context *opened_key = NULL; + + disk_set_used(dst->disk_loc, mgr); + + rc = disk_read_crypt_sector(&disk, sizeof(disk), dst->disk_loc, mgr); + if (rc) { + printk("Malformed sector %d\n", be32_native(dst->disk_loc)); + return rc; + } + + rc = sha256_verify(&dst->disk_hash, &disk.v, sizeof(disk.v) + sizeof(disk.group_mac)); + if (rc) { + printk("Hash mismatch in sector %d\n", be32_native(dst->disk_loc)); + return rc; + } + + dst->v = group = calloc(1, sizeof(*group)); + + rc = find_group_key(group, &disk, mgr); + if (rc == 0) { + opened_key = &key_e; + /* Verify the group with the group's own key */ + aes_setup(opened_key, &group->group_key); + if (aes_cmac_verify(&disk.group_mac, &disk.v, sizeof(disk.v), opened_key)) { + printk("Group CMAC failed\n"); + return 2; + } + + memcpy(&group->id_data, &disk.v.id_data, sizeof(group->id_data)); + memcpy(&group->details, &disk.v.details, sizeof(group->details)); + } else if (rc == 1) { + // still need to walk the vtpm list + rc = 0; + } else { + printk("Group key unsealing failed\n"); + return rc; + } + + group->nr_vtpms = be32_native(disk.v.nr_vtpms); + group->nr_pages = (group->nr_vtpms + VTPMS_PER_SECTOR - 1) / VTPMS_PER_SECTOR; + + group->data = calloc(group->nr_pages, sizeof(group->data[0])); + + rc = load_verify_vtpm_itree(dst, 0, group->nr_pages, disk.v.vtpm_hash, + disk.vtpm_location, NR_ENTRIES_PER_GROUP_BASE, mgr, opened_key); + + if (!opened_key) { + /* remove the struct */ + free(group->data); + free(group->seals); + free(group); + dst->v = NULL; + } + + return rc; +} + +static int load_root_pre(struct disk_root_sector *root, struct mem_tpm_mgr *dst) +{ + int rc; + + aes_setup(&dst->tm_key_e, &dst->tm_key); + + rc = disk_read_crypt_sector(root, sizeof(*root), root_loc(dst), dst); + + if (rc) { + vtpmloginfo(VTPM_LOG_VTPM, "root cmac verify failed in slot %d\n", dst->active_root); + return 2; + } + + dst->root_seals_valid = 1 + dst->active_root; + dst->sequence = be64_native(root->v.sequence); + + return 0; +} + +static int load_verify_group_itree(struct mem_tpm_mgr *dst, int base, int nr_entries, + const struct hash256 *hash, const sector_t *loc, int hsize); + +static int load_verify_group_itree(struct mem_tpm_mgr *dst, int base, int nr_entries, + const struct hash256 *hash, const sector_t *loc, int hsize) +{ + int i, rc, incr = 1; + + if (nr_entries <= hsize) { + for(i=0; i < nr_entries; i++) { + struct mem_group_hdr *group = dst->groups + base + i; + group->disk_loc = loc[i]; + memcpy(&group->disk_hash, &hash[i], sizeof(group->disk_hash)); + rc = load_verify_group(group, dst); + if (rc) { + printk("Error loading group %d\n", base + i); + return rc; + } + } + return 0; + } + + // increase tree depth until all entries fit + while (nr_entries > incr * hsize) + incr *= NR_ENTRIES_PER_ITREE; + + for (i = 0; i * incr < nr_entries; i++) { + struct disk_itree_sector pt; + int child_entries = incr; + + // the last sector is not completely full + if (nr_entries - i * incr < incr) + child_entries = nr_entries - i * incr; + + disk_set_used(loc[i], dst); + + rc = disk_read_crypt_sector(&pt, sizeof(pt), loc[i], dst); + if (rc) { + printk("Malformed sector %d\n", be32_native(loc[i])); + return rc; + } + + rc = sha256_verify(&hash[i], pt.hash, sizeof(pt.hash)); + if (rc) { + printk("Hash mismatch in sector %d\n", be32_native(loc[i])); + return rc; + } + + rc = load_verify_group_itree(dst, base, child_entries, pt.hash, pt.location, NR_ENTRIES_PER_ITREE); + if (rc) + return rc; + + base += incr; + } + + return 0; +} + +static int load_root_post(struct mem_tpm_mgr *dst, const struct disk_root_sector *root) +{ + int rc, i, j; + uint32_t nr_disk_rbs = be32_native(root->nr_rb_macs); + + rc = TPM_disk_check_counter(dst->counter_index, dst->counter_auth, + root->v.tpm_counter_value); + if (rc) + return 2; + dst->counter_value = root->v.tpm_counter_value; + + dst->nr_groups = be32_native(root->v.nr_groups); + dst->groups = calloc(sizeof(dst->groups[0]), dst->nr_groups); + + if (!dst->groups) { + vtpmlogerror(VTPM_LOG_VTPM, "load_root_post alloc %x\n", dst->nr_groups); + return 2; + } + + rc = load_verify_group_itree(dst, 0, dst->nr_groups, + root->v.group_hash, root->group_loc, NR_ENTRIES_PER_ROOT); + if (rc) + return rc; + + /* Sanity check: group0 must be open */ + if (!dst->groups[0].v) { + printk("Error opening group 0\n"); + return 2; + } + + /* TODO support for spilling rollback list */ + if (nr_disk_rbs > NR_RB_MACS_PER_ROOT) + return 3; + + i = 0; + j = 0; + while (i < dst->nr_groups) { + aes_context key_e; + struct mem_group_hdr *group = &dst->groups[i]; + struct mem_group *groupv = group->v; + const struct disk_rb_mac_entry *ent = &root->rb_macs[j]; + + if (!groupv) { + i++; + // this group is not open - no need to verify now + continue; + } + + if (be32_native(ent->id) < i) { + // this entry is for a group that is not open + j++; + continue; + } + + if (j >= nr_disk_rbs || be32_native(ent->id) != i) { + // TODO allow delegation + if (!(groupv->details.flags.value & FLAG_ROLLBACK_DETECTED)) { + groupv->details.flags.value |= FLAG_ROLLBACK_DETECTED; + group->disk_loc.value = 0; + } + i++; + continue; + } + + aes_setup(&key_e, &groupv->rollback_mac_key); + if (aes_cmac_verify(&ent->mac, &root->v, sizeof(root->v), &key_e)) { + if (!(groupv->details.flags.value & FLAG_ROLLBACK_DETECTED)) { + groupv->details.flags.value |= FLAG_ROLLBACK_DETECTED; + group->disk_loc.value = 0; + } + } + i++; j++; + } + + return 0; +} + +int vtpm_load_disk(void) +{ + struct disk_root_sector root1, root2; + int rc = 0; + TPM_read_pcrs(); + + printk("TPM Manager - disk format %d\n", TPM_MGR_VERSION); + printk(" root seal: %lu; sector of %d: %lu\n", + sizeof(struct disk_root_sealed_data), SEALS_PER_ROOT_SEAL_LIST, sizeof(struct disk_seal_list)); + printk(" root: %lu v=%lu\n", sizeof(root1), sizeof(root1.v)); + printk(" itree: %lu; sector of %d: %lu\n", + 4 + 32, NR_ENTRIES_PER_ITREE, sizeof(struct disk_itree_sector)); + printk(" group: %lu v=%lu id=%lu md=%lu\n", + sizeof(struct disk_group_sector), sizeof(struct disk_group_sector_mac3_area), + sizeof(struct group_id_data), sizeof(struct group_details)); + printk(" group seal: %lu; %d in parent: %lu; sector of %d: %lu\n", + sizeof(struct disk_group_sealed_data), NR_SEALS_PER_GROUP, sizeof(struct disk_group_boot_config_list), + SEALS_PER_GROUP_SEAL_LIST, sizeof(struct disk_group_seal_list)); + printk(" vtpm: %lu+%lu; sector of %d: %lu\n", + sizeof(struct disk_vtpm_plain), sizeof(struct disk_vtpm_secret), + VTPMS_PER_SECTOR, sizeof(struct disk_vtpm_sector)); + + struct mem_tpm_mgr *mgr1 = find_root_key(0); + struct mem_tpm_mgr *mgr2 = find_root_key(1); + + rc = mgr1 ? load_root_pre(&root1, mgr1) : 0; + if (rc) { + mgr_free(mgr1); + mgr1 = NULL; + } + + rc = mgr2 ? load_root_pre(&root2, mgr2) : 0; + if (rc) { + mgr_free(mgr2); + mgr2 = NULL; + } + + printk("load_root_pre: %c/%c\n", mgr1 ? 'y' : 'n', mgr2 ? 'y' : 'n'); + + if (!mgr1 && !mgr2) + return 2; + + if (mgr1 && mgr2 && mgr2->sequence > mgr1->sequence) { + rc = load_root_post(mgr2, &root2); + if (rc) { + mgr_free(mgr2); + mgr2 = NULL; + } else { + mgr_free(mgr1); + g_mgr = mgr2; + return 0; + } + } + if (mgr1) { + rc = load_root_post(mgr1, &root1); + if (rc) { + mgr_free(mgr1); + } else { + mgr_free(mgr2); + g_mgr = mgr1; + return 0; + } + } + if (mgr2) { + rc = load_root_post(mgr2, &root2); + if (rc) { + mgr_free(mgr2); + } else { + g_mgr = mgr2; + return 0; + } + } + printk("Could not read vTPM disk\n"); + + return 2; +} diff --git a/stubdom/vtpmmgr/disk_tpm.c b/stubdom/vtpmmgr/disk_tpm.c new file mode 100644 index 0000000..6f5d556 --- /dev/null +++ b/stubdom/vtpmmgr/disk_tpm.c @@ -0,0 +1,238 @@ +/* TPM disk interface */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "tpm.h" +#include "tcg.h" + +#include "vtpmmgr.h" +#include "vtpm_disk.h" +#include "disk_tpm.h" + +// Print out input/output of seal/unseal operations (includes keys) +#undef DEBUG_SEAL_OPS + +#ifdef DEBUG_SEAL_OPS +#include "marshal.h" +#endif + +struct pcr_list { + TPM_DIGEST pcrs[24]; +}; + +static struct pcr_list hwtpm; + +void TPM_read_pcrs(void) +{ + int i; + for(i=0; i < 24; i++) + TPM_PCR_Read(i, &hwtpm.pcrs[i]); +} + +struct pcr_composite_3 { + be16_t sel_size; + uint8_t sel[3]; + be32_t val_size; + uint8_t val[0]; +} __attribute__((packed)); + +void TPM_pcr_digest(struct hash160 *buf, le32_t selection) +{ + int i; + int count = 0; + uint32_t sel = le32_native(selection); + struct pcr_composite_3 *v; + for(i=0; i < 24; i++) { + if (sel & (1 << i)) + count++; + } + v = alloca(sizeof(*v) + 20 * count); + v->sel_size = native_be16(3); + memcpy(v->sel, &selection, 3); + v->val_size = native_be32(20 * count); + + count = 0; + for(i=0; i < 24; i++) { + if (sel & (1 << i)) { + memcpy(v->val + 20 * count, &hwtpm.pcrs[i], 20); + count++; + } + } + + sha1((void*)v, sizeof(*v) + 20 * count, buf->bits); +} + + +int TPM_disk_seal(struct disk_seal_entry *dst, const void* src, size_t size) +{ + uint32_t rc; + TPM_PCR_INFO info; + TPM_STORED_DATA out; + TPM_AUTH_SESSION osap = TPM_AUTH_SESSION_INIT; + TPM_AUTHDATA sharedsecret; + TPM_AUTHDATA auth; + + rc = TPM_OSAP(TPM_ET_KEYHANDLE, TPM_SRK_KEYHANDLE, (void*)&vtpm_globals.srk_auth, + &sharedsecret, &osap); + + if (rc) abort(); + +#ifdef DEBUG_SEAL_OPS + int i; + printk("to-seal:"); + for(i=0; i < size; i++) + printk(" %02x", ((uint8_t*)src)[i]); + printk("\n"); +#endif + + memset(auth, 0, 20); + info.pcrSelection.sizeOfSelect = 3; + info.pcrSelection.pcrSelect = (void*)&dst->pcr_selection; + memcpy(&info.digestAtCreation, &dst->digest_at_seal, 20); + memcpy(&info.digestAtRelease, &dst->digest_release, 20); + + rc = TPM_Seal(TPM_SRK_KEYHANDLE, 45, &info, size, src, &out, + (void*)&sharedsecret, (void*)&auth, &osap); + + TPM_TerminateHandle(osap.AuthHandle); + +#ifdef DEBUG_SEAL_OPS + printk("TPM_Seal rc=%d encDataSize=%d sealInfoSize=%d\n", rc, out.encDataSize, out.sealInfoSize); +#endif + if (!rc) + memcpy(dst->sealed_data, out.encData, 256); + +#ifdef DEBUG_SEAL_OPS + uint8_t buf[512]; + uint8_t *start = buf; + uint8_t *end = pack_TPM_STORED_DATA(buf, &out); + printk("stored_data:"); + while (start != end) { + printk(" %02x", *start); + start++; + } + printk("\n"); +#endif + + free_TPM_STORED_DATA(&out); + return rc; +} + +int TPM_disk_unseal(void *dst, size_t size, const struct disk_seal_entry *src) +{ + uint32_t rc; + TPM_STORED_DATA in; + TPM_AUTH_SESSION oiap = TPM_AUTH_SESSION_INIT; + TPM_AUTHDATA auth; + uint32_t outSize = 0; + uint8_t *out = NULL; + + rc = TPM_OIAP(&oiap); + if (rc) abort(); + + memset(auth, 0, 20); + + in.ver = TPM_STRUCT_VER_1_1; + in.sealInfoSize = 45; + in.sealInfo.pcrSelection.sizeOfSelect = 3; + in.sealInfo.pcrSelection.pcrSelect = (void*)&src->pcr_selection; + memcpy(&in.sealInfo.digestAtCreation, &src->digest_at_seal, 20); + memcpy(&in.sealInfo.digestAtRelease, &src->digest_release, 20); + in.encDataSize = 256; + in.encData = (void*)src->sealed_data; + +#ifdef DEBUG_SEAL_OPS + uint8_t buf[512]; + uint8_t *start = buf; + uint8_t *end = pack_TPM_STORED_DATA(buf, &in); + printk("stored_data:"); + while (start != end) { + printk(" %02x", *start); + start++; + } + printk("\n"); +#endif + + rc = TPM_Unseal(TPM_SRK_KEYHANDLE, &in, &outSize, &out, + (void*)&vtpm_globals.srk_auth, (void*)&auth, &vtpm_globals.oiap, &oiap); + + TPM_TerminateHandle(oiap.AuthHandle); + +#ifdef DEBUG_SEAL_OPS + printk("TPM_Unseal rc=%d outSize=%d size=%d\n", rc, outSize, size); +#endif + if (!rc) { + memcpy(dst, out, size); +#ifdef DEBUG_SEAL_OPS + printk("unsealed:"); + int i; + for(i=0; i < size; i++) + printk(" %02x", ((uint8_t*)dst)[i]); + printk("\n"); +#endif + } + + free(out); + + return rc; +} + +int TPM_disk_nvalloc(be32_t *nvram_slot, struct tpm_authdata auth) +{ + // TODO-3 + nvram_slot->value = 0; + return 0; +} + +int TPM_disk_nvread(void *buf, size_t bufsiz, be32_t nvram_slot, struct tpm_authdata auth) +{ + // TODO-3 + memset(buf, 0, bufsiz); + return 0; +} + +int TPM_disk_nvwrite(void *buf, size_t bufsiz, be32_t nvram_slot, struct tpm_authdata auth) +{ + // TODO-3 + return 0; +} + +int TPM_disk_nvchange(be32_t nvram_slot, struct tpm_authdata old, struct tpm_authdata noo) +{ + // TODO-3 + return 0; +} + +int TPM_disk_alloc_counter(be32_t *slot, struct tpm_authdata auth, be32_t *value) +{ + // TODO-3 + slot->value = 0; + value->value = 0; + return 0; +} + +int TPM_disk_check_counter(be32_t slot, struct tpm_authdata auth, be32_t value) +{ + // TODO-3 + return 0; +} + +int TPM_disk_incr_counter(be32_t slot, struct tpm_authdata auth) +{ + // TODO-3 + return 0; +} + +int TPM_disk_change_counter(be32_t slot, struct tpm_authdata old, struct tpm_authdata noo) +{ + // TODO-3 + return 0; +} diff --git a/stubdom/vtpmmgr/disk_tpm.h b/stubdom/vtpmmgr/disk_tpm.h new file mode 100644 index 0000000..b235895 --- /dev/null +++ b/stubdom/vtpmmgr/disk_tpm.h @@ -0,0 +1,25 @@ +#ifndef __VTPMMGR_DISK_VTPM_H +#define __VTPMMGR_DISK_VTPM_H +#include "vtpm_disk.h" + +/* Read PCR values to determine which unseal to try */ +void TPM_read_pcrs(void); +void TPM_pcr_digest(struct hash160 *buf, le32_t selection); + +/* Sealing for key storage */ +int TPM_disk_seal(struct disk_seal_entry *dst, const void* src, size_t size); +int TPM_disk_unseal(void *dst, size_t size, const struct disk_seal_entry *src); + +/* NVRAM to allow revocation of TM-KEY */ +int TPM_disk_nvalloc(be32_t *nvram_slot, struct tpm_authdata auth); +int TPM_disk_nvread(void *buf, size_t bufsiz, be32_t nvram_slot, struct tpm_authdata auth); +int TPM_disk_nvwrite(void *buf, size_t bufsiz, be32_t nvram_slot, struct tpm_authdata auth); +int TPM_disk_nvchange(be32_t nvram_slot, struct tpm_authdata old, struct tpm_authdata noo); + +/* Monotonic counters to detect rollback */ +int TPM_disk_alloc_counter(be32_t *slot, struct tpm_authdata auth, be32_t *value); +int TPM_disk_check_counter(be32_t slot, struct tpm_authdata auth, be32_t value); +int TPM_disk_incr_counter(be32_t slot, struct tpm_authdata auth); +int TPM_disk_change_counter(be32_t slot, struct tpm_authdata old, struct tpm_authdata noo); + +#endif diff --git a/stubdom/vtpmmgr/disk_write.c b/stubdom/vtpmmgr/disk_write.c new file mode 100644 index 0000000..4c825c5 --- /dev/null +++ b/stubdom/vtpmmgr/disk_write.c @@ -0,0 +1,410 @@ +#include +#include +#include +#include +#include +#include +#include +#include + +#include "vtpm_manager.h" +#include "log.h" +#include "uuid.h" + +#include "vtpmmgr.h" +#include "vtpm_disk.h" +#include "disk_tpm.h" +#include "disk_io.h" +#include "disk_crypto.h" +#include "disk_format.h" +#include "mgmt_authority.h" + +static void disk_write_crypt_sector(sector_t *dst, const void *data, size_t size, const struct mem_tpm_mgr *mgr) +{ + struct disk_crypt_sector_plain *sector = disk_write_buf(); + *dst = disk_find_free(mgr); + aes_encrypt_ctr(sector->iv_data, sizeof(sector->iv_data), data, size, &mgr->tm_key_e); + aes_cmac(§or->mac, sector->data, sizeof(sector->data), &mgr->tm_key_e); + disk_write_sector(*dst, sector, sizeof(*sector)); +} + +/* + * Mark unchanged sectors on disk as being used + */ +static void disk_populate_used_vtpm(const struct mem_vtpm_page *src, const struct mem_tpm_mgr *mgr) +{ + if (be32_native(src->disk_loc) != 0) + disk_set_used(src->disk_loc, mgr); +} + +/* + * Write out a vTPM page to disk, doing nothing if the existing copy is valid + */ +static void disk_write_vtpm_page(struct mem_vtpm_page *dst, const aes_context *auth_key, + const struct mem_tpm_mgr *mgr) +{ + struct disk_vtpm_sector pt; + int i; + memset(&pt, 0, sizeof(pt)); + if (be32_native(dst->disk_loc) != 0) + return; + + for(i=0; i < dst->size; i++) { + memcpy(pt.header[i].uuid, dst->vtpms[i]->uuid, 16); + memcpy(pt.data[i].data, dst->vtpms[i]->data, 64); + pt.header[i].flags = native_be32(dst->vtpms[i]->flags & VTPM_FLAG_DISK_MASK); + } + aes_encrypt_ctr(&pt.iv, sizeof(pt.data) + 16, &pt.data, sizeof(pt.data), auth_key); + + sha256(&dst->disk_hash, &pt, sizeof(pt)); + + disk_write_crypt_sector(&dst->disk_loc, &pt, sizeof(pt), mgr); +} + +/* + * Generate TPM seal blobs for a group's keys; do nothing if existing copy is valid + */ +static void generate_group_seals(struct mem_group *src, const struct mem_tpm_mgr *parent) +{ + int i; + struct disk_group_sealed_data sblob; + + // previous seals are still valid, skip talking to the TPM + if (src->flags & MEM_GROUP_FLAG_SEAL_VALID) + return; + + memcpy(&sblob.magic, DISK_GROUP_BOUND_MAGIC, 4); + memcpy(sblob.tpm_manager_uuid, parent->uuid, 16); + memcpy(&sblob.aik_authdata, &src->aik_authdata, 20); + memcpy(&sblob.group_key, &src->group_key, 16); + memcpy(&sblob.rollback_mac_key, &src->rollback_mac_key, 16); + + /* TODO support for more than NR_SEALS_PER_GROUP seals */ + if (src->nr_seals > NR_SEALS_PER_GROUP) + abort(); + + for(i=0; i < src->nr_seals; i++) { + struct disk_seal_entry *dst = &src->seal_bits.entry[i]; + dst->pcr_selection = src->seals[i].pcr_selection; + memcpy(&dst->digest_release, &src->seals[i].digest_release, 20); + TPM_pcr_digest(&dst->digest_at_seal, dst->pcr_selection); + TPM_disk_seal(dst, &sblob, sizeof(sblob)); + } + src->seal_bits.nr_cfgs = native_be32(src->nr_seals); + + src->flags |= MEM_GROUP_FLAG_SEAL_VALID; +} + +/* + * Mark unchanged sectors on disk as being used + */ +static void disk_populate_used_group(const struct mem_group_hdr *src, const struct mem_tpm_mgr *mgr) +{ + int i; + struct mem_group *group = src->v; + if (be32_native(src->disk_loc) != 0) { + // entire group is unchanged - mark group, itree, and vtpm sectors + // TODO mark other children (seal) + disk_set_used(src->disk_loc, mgr); + for(i = 0; i < src->disk_nr_inuse; i++) + disk_set_used(src->disk_inuse[i], mgr); + return; + } + + // unopened groups should never have been invalidated + if (!group) + abort(); + + for (i = 0; i < group->nr_pages; i++) + disk_populate_used_vtpm(&group->data[i], mgr); +} + +static void disk_write_vtpm_itree(struct mem_group_hdr *hdr, int base, int nr_entries, + struct hash256 *hash, sector_t *loc, int hsize, + const aes_context *group_key, const struct mem_tpm_mgr *mgr); + +static void disk_write_vtpm_itree(struct mem_group_hdr *hdr, int base, int nr_entries, + struct hash256 *hash, sector_t *loc, int hsize, + const aes_context *group_key, const struct mem_tpm_mgr *mgr) +{ + int i, incr = 1, inuse_base, lsize; + + while (nr_entries > incr * hsize) + incr *= NR_ENTRIES_PER_ITREE; + + if (nr_entries <= hsize) { + struct mem_group *group = hdr->v; + for (i = 0; i < nr_entries; i++) { + struct mem_vtpm_page *page = group->data + base + i; + disk_write_vtpm_page(page, group_key, mgr); + loc[i] = page->disk_loc; + hash[i] = page->disk_hash; + } + } else { + for (i = 0; i * incr < nr_entries; i++) { + struct disk_itree_sector pt; + int child_entries = incr; + + // the last sector is not completely full + if (nr_entries - i * incr < incr) + child_entries = nr_entries - i * incr; + + disk_write_vtpm_itree(hdr, base, child_entries, pt.hash, pt.location, + NR_ENTRIES_PER_ITREE, group_key, mgr); + + sha256(&hash[i], &pt.hash, sizeof(pt.hash)); + disk_write_crypt_sector(&loc[i], &pt, sizeof(pt), mgr); + + base += incr; + } + } + + // save the list of used sectors (itree and vtpm) in the header + inuse_base = hdr->disk_nr_inuse; + lsize = 1 + (nr_entries - 1) / incr; + hdr->disk_nr_inuse += lsize; + hdr->disk_inuse = realloc(hdr->disk_inuse, hdr->disk_nr_inuse * sizeof(sector_t)); + memcpy(&hdr->disk_inuse[inuse_base], loc, lsize * sizeof(sector_t)); +} + +/* + * Write out a vTPM group sector and its children + */ +static void disk_write_group_sector(struct mem_group_hdr *src, + const struct mem_tpm_mgr *mgr) +{ + struct disk_group_sector disk; + struct mem_group *group = src->v; + aes_context key_e; + + /* Don't write if the data hasn't changed */ + if (be32_native(src->disk_loc) != 0) + return; + + // if the group was not opened, it should not have been changed + if (!group) + abort(); + + memset(&disk, 0, sizeof(disk)); + memcpy(&disk.v.id_data, &group->id_data, sizeof(disk.v.id_data)); + memcpy(&disk.v.details, &group->details, sizeof(disk.v.details)); + + aes_setup(&key_e, &group->group_key); + + disk.v.nr_vtpms = native_be32(group->nr_vtpms); + + // regenerated + src->disk_nr_inuse = 0; + + disk_write_vtpm_itree(src, 0, group->nr_pages, disk.v.vtpm_hash, disk.vtpm_location, + NR_ENTRIES_PER_GROUP_BASE, &key_e, mgr); + + generate_group_seals(group, mgr); + memcpy(&disk.v.boot_configs, &group->seal_bits, sizeof(group->seal_bits)); + + aes_cmac(&disk.group_mac, &disk.v, sizeof(disk.v), &key_e); + sha256(&src->disk_hash, &disk.v, sizeof(disk.v) + sizeof(disk.group_mac)); + disk_write_crypt_sector(&src->disk_loc, &disk, sizeof(disk), mgr); +} + +/* + * Write TPM seal blobs for the manager's keys, using the given group's list + * of valid configurations + */ +static void disk_write_seal_list(struct mem_tpm_mgr *mgr, struct mem_group *group) +{ + int i; + struct disk_seal_list *seal = disk_write_buf(); + struct disk_root_sealed_data sblob; + + if (mgr->root_seals_valid & (1 + mgr->active_root)) + return; + + memcpy(&sblob.magic, DISK_ROOT_BOUND_MAGIC, 4); + memcpy(sblob.tpm_manager_uuid, mgr->uuid, 16); + memcpy(&sblob.nvram_slot, &mgr->nvram_slot, 4); + memcpy(&sblob.nvram_auth, &mgr->nvram_auth, 20); + memcpy(&sblob.counter_index, &mgr->counter_index, 4); + memcpy(&sblob.counter_auth, &mgr->counter_auth, 20); + + // TODO when an NV slot in the physical TPM is used to populate nv_key, + // that value should be used to mask the master key so that the value + // can be changed to revoke old disk state +#if 0 + aes_encrypt_one(&sblob.tm_key, &mgr->tm_key, &mgr->nv_key); +#else + memcpy(&sblob.tm_key, &mgr->tm_key, 16); +#endif + + memset(seal, 0, sizeof(*seal)); + seal->length = native_be32(group->nr_seals); + + // TODO support for more entries + if (group->nr_seals > SEALS_PER_ROOT_SEAL_LIST) + abort(); + + for(i=0; i < group->nr_seals; i++) { + struct mem_seal *src = &group->seals[i]; + struct disk_seal_entry *dst = &seal->entry[i]; + dst->pcr_selection = src->pcr_selection; + memcpy(&dst->digest_release, &src->digest_release, 20); + TPM_pcr_digest(&dst->digest_at_seal, dst->pcr_selection); + + TPM_disk_seal(dst, &sblob, sizeof(sblob)); + } + + memcpy(seal->hdr.magic, TPM_MGR_MAGIC, 12); + seal->hdr.version = native_be32(TPM_MGR_VERSION); + + disk_write_sector(seal_loc(mgr), seal, sizeof(*seal)); + mgr->root_seals_valid |= 1 + mgr->active_root; +} + +/* + * Mark unchanged sectors on disk as being used + */ +static void disk_populate_used_mgr(const struct mem_tpm_mgr *mgr) +{ + int i; + + // TODO walk the linked lists for seals, rb_macs here (when supported) + + for(i=0; i < mgr->nr_groups; i++) + disk_populate_used_group(&mgr->groups[i], mgr); +} + +static void disk_write_group_itree(struct mem_tpm_mgr *mgr, int base, int nr_entries, + struct hash256 *hash, sector_t *loc, int hsize); + +static void disk_write_group_itree(struct mem_tpm_mgr *mgr, int base, int nr_entries, + struct hash256 *hash, sector_t *loc, int hsize) +{ + int i, incr = 1; + + if (nr_entries <= hsize) { + for(i=0; i < mgr->nr_groups; i++) { + struct mem_group_hdr *group = mgr->groups + base + i; + disk_write_group_sector(group, mgr); + loc[i] = group->disk_loc; + hash[i] = group->disk_hash; + } + return; + } + + while (nr_entries > incr * hsize) + incr *= NR_ENTRIES_PER_ITREE; + + for (i = 0; i * incr < nr_entries; i++) { + struct disk_itree_sector pt; + int child_entries = incr; + + // the last sector is not completely full + if (nr_entries - i * incr < incr) + child_entries = nr_entries - i * incr; + + disk_write_group_itree(mgr, base, child_entries, pt.hash, pt.location, NR_ENTRIES_PER_ITREE); + + sha256(&hash[i], &pt.hash, sizeof(pt.hash)); + disk_write_crypt_sector(&loc[i], &pt, sizeof(pt), mgr); + + base += incr; + } +} + +/* + * Write out the root TPM Manager sector and its children + */ +static void disk_write_root_sector(struct mem_tpm_mgr *mgr) +{ + int i, j; + struct disk_root_sector root; + memset(&root, 0, sizeof(root)); + root.v.sequence = native_be64(mgr->sequence); + root.v.tpm_counter_value = mgr->counter_value; + + root.v.nr_groups = native_be32(mgr->nr_groups); + + disk_write_group_itree(mgr, 0, mgr->nr_groups, root.v.group_hash, root.group_loc, NR_ENTRIES_PER_ROOT); + + i = 0; + j = 0; + while (i < mgr->nr_groups) { + aes_context key_e; + struct mem_group_hdr *group = &mgr->groups[i]; + struct mem_group *groupv = group->v; + + if (!groupv) { + i++; + continue; + } + if (groupv->details.flags.value & FLAG_ROLLBACK_DETECTED) { + i++; + continue; + } + if (j >= NR_RB_MACS_PER_ROOT) + break; // TODO support for nr_rb_macs > 128 + + aes_setup(&key_e, &groupv->rollback_mac_key); + root.rb_macs[j].id = native_be32(i); + aes_cmac(&root.rb_macs[j].mac, &root.v, sizeof(root.v), &key_e); + i++; j++; + } + root.nr_rb_macs = native_be32(j); + + struct disk_crypt_sector_plain *root_sect = disk_write_buf(); + aes_encrypt_ctr(root_sect->iv_data, sizeof(root_sect->iv_data), &root, sizeof(root), &mgr->tm_key_e); + aes_cmac(&root_sect->mac, &root_sect->data, sizeof(root_sect->data), &mgr->tm_key_e); + disk_write_sector(root_loc(mgr), root_sect, sizeof(*root_sect)); +} + +/* + * Write out changes to disk + */ +void disk_write_all(struct mem_tpm_mgr *mgr) +{ + disk_flush_slot(mgr); + disk_populate_used_mgr(mgr); + disk_write_root_sector(mgr); + + disk_write_seal_list(mgr, mgr->groups[0].v); + + disk_write_barrier(); +} + +/* + * Create a new (blank) TPM Manager disk image. + * + * Does not actually write anything to disk. + */ +int vtpm_new_disk(void) +{ + int rc; + struct mem_tpm_mgr *mgr = calloc(1, sizeof(*mgr)); + + do_random(mgr->uuid, 16); + do_random(&mgr->tm_key, 16); + do_random(&mgr->nvram_auth, 20); + do_random(&mgr->counter_auth, 20); + do_random(&mgr->nv_key, 16); + + aes_setup(&mgr->tm_key_e, &mgr->tm_key); + + // TODO postpone these allocs until first write? + rc = TPM_disk_nvalloc(&mgr->nvram_slot, mgr->nvram_auth); + if (rc) + return rc; + + rc = TPM_disk_alloc_counter(&mgr->counter_index, mgr->counter_auth, &mgr->counter_value); + if (rc) + return rc; + + mgr->nr_groups = 1; + mgr->groups = calloc(1, sizeof(mgr->groups[0])); + mgr->groups[0].v = vtpm_new_group(NULL); + + TPM_disk_nvwrite(&mgr->nv_key, 16, mgr->nvram_slot, mgr->nvram_auth); + + g_mgr = mgr; + + return 0; +} diff --git a/stubdom/vtpmmgr/endian_int.h b/stubdom/vtpmmgr/endian_int.h new file mode 100644 index 0000000..030f87b --- /dev/null +++ b/stubdom/vtpmmgr/endian_int.h @@ -0,0 +1,72 @@ +#ifndef __VTPMMGR_ENDIAN_INT_H +#define __VTPMMGR_ENDIAN_INT_H + +#include + +/* These wrapper structs force the use of endian-to-CPU conversions */ + +typedef struct be_int16 { + uint16_t value; +} be16_t; + +typedef struct be_int32 { + uint32_t value; +} be32_t; + +typedef struct le_int32 { + uint32_t value; +} le32_t; + +typedef struct be_int64 { + uint64_t value; +} be64_t; + +static inline uint16_t be16_native(be16_t v) +{ + return be16_to_cpu(v.value); +} + +static inline uint32_t le32_native(le32_t v) +{ + return le32_to_cpu(v.value); +} + +static inline uint32_t be32_native(be32_t v) +{ + return be32_to_cpu(v.value); +} + +static inline uint64_t be64_native(be64_t v) +{ + return be64_to_cpu(v.value); +} + +static inline be16_t native_be16(uint16_t v) +{ + be16_t rv; + rv.value = cpu_to_be16(v); + return rv; +} + +static inline le32_t native_le32(uint32_t v) +{ + le32_t rv; + rv.value = cpu_to_le32(v); + return rv; +} + +static inline be32_t native_be32(uint32_t v) +{ + be32_t rv; + rv.value = cpu_to_be32(v); + return rv; +} + +static inline be64_t native_be64(uint64_t v) +{ + be64_t rv; + rv.value = cpu_to_be64(v); + return rv; +} + +#endif diff --git a/stubdom/vtpmmgr/init.c b/stubdom/vtpmmgr/init.c index 33ac152..89643e7 100644 --- a/stubdom/vtpmmgr/init.c +++ b/stubdom/vtpmmgr/init.c @@ -48,7 +48,7 @@ #include "log.h" #include "vtpmmgr.h" -#include "vtpm_storage.h" +#include "vtpm_disk.h" #include "tpm.h" #include "marshal.h" @@ -64,16 +64,11 @@ struct Opts { }; // --------------------------- Well Known Auths -------------------------- -const TPM_AUTHDATA WELLKNOWN_SRK_AUTH = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +const TPM_AUTHDATA WELLKNOWN_AUTH = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; -const TPM_AUTHDATA WELLKNOWN_OWNER_AUTH = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; - struct vtpm_globals vtpm_globals = { .tpm_fd = -1, - .storage_key = TPM_KEY_INIT, - .storage_key_handle = 0, .oiap = { .AuthHandle = 0 } }; @@ -247,42 +242,11 @@ abort_egress: return status; } -static void init_storage_key(TPM_KEY* key) { - key->ver.major = 1; - key->ver.minor = 1; - key->ver.revMajor = 0; - key->ver.revMinor = 0; - - key->keyUsage = TPM_KEY_BIND; - key->keyFlags = 0; - key->authDataUsage = TPM_AUTH_ALWAYS; - - TPM_KEY_PARMS* p = &key->algorithmParms; - p->algorithmID = TPM_ALG_RSA; - p->encScheme = TPM_ES_RSAESOAEP_SHA1_MGF1; - p->sigScheme = TPM_SS_NONE; - p->parmSize = 12; - - TPM_RSA_KEY_PARMS* r = &p->parms.rsa; - r->keyLength = RSA_KEY_SIZE; - r->numPrimes = 2; - r->exponentSize = 0; - r->exponent = NULL; - - key->PCRInfoSize = 0; - key->encDataSize = 0; - key->encData = NULL; -} - -static int parse_auth_string(char* authstr, BYTE* target, const TPM_AUTHDATA wellknown, int allowrandom) { +static int parse_auth_string(char* authstr, BYTE* target) { int rc; /* well known owner auth */ if(!strcmp(authstr, "well-known")) { - memcpy(target, wellknown, sizeof(TPM_AUTHDATA)); - } - /* Create a randomly generated owner auth */ - else if(allowrandom && !strcmp(authstr, "random")) { - return 1; + return 0; } /* owner auth is a raw hash */ else if(!strncmp(authstr, "hash:", 5)) { @@ -318,12 +282,12 @@ int parse_cmdline_opts(int argc, char** argv, struct Opts* opts) int i; //Set defaults - memcpy(vtpm_globals.owner_auth, WELLKNOWN_OWNER_AUTH, sizeof(TPM_AUTHDATA)); - memcpy(vtpm_globals.srk_auth, WELLKNOWN_SRK_AUTH, sizeof(TPM_AUTHDATA)); + memcpy(vtpm_globals.owner_auth, WELLKNOWN_AUTH, sizeof(TPM_AUTHDATA)); + memcpy(vtpm_globals.srk_auth, WELLKNOWN_AUTH, sizeof(TPM_AUTHDATA)); for(i = 1; i < argc; ++i) { if(!strncmp(argv[i], "owner_auth:", 10)) { - if((rc = parse_auth_string(argv[i] + 10, vtpm_globals.owner_auth, WELLKNOWN_OWNER_AUTH, 1)) < 0) { + if((rc = parse_auth_string(argv[i] + 10, vtpm_globals.owner_auth)) < 0) { goto err_invalid; } if(rc == 1) { @@ -331,7 +295,7 @@ int parse_cmdline_opts(int argc, char** argv, struct Opts* opts) } } else if(!strncmp(argv[i], "srk_auth:", 8)) { - if((rc = parse_auth_string(argv[i] + 8, vtpm_globals.srk_auth, WELLKNOWN_SRK_AUTH, 0)) != 0) { + if((rc = parse_auth_string(argv[i] + 8, vtpm_globals.srk_auth)) != 0) { goto err_invalid; } } @@ -389,8 +353,6 @@ static TPM_RESULT vtpmmgr_create(void) { TPMTRYRETURN(try_take_ownership()); // Generate storage key's auth - memset(&vtpm_globals.storage_key_usage_auth, 0, sizeof(TPM_AUTHDATA)); - TPMTRYRETURN( TPM_OSAP( TPM_ET_KEYHANDLE, TPM_SRK_KEYHANDLE, @@ -398,30 +360,11 @@ static TPM_RESULT vtpmmgr_create(void) { &sharedsecret, &osap) ); - init_storage_key(&vtpm_globals.storage_key); - - //initialize the storage key - TPMTRYRETURN( TPM_CreateWrapKey( - TPM_SRK_KEYHANDLE, - (const TPM_AUTHDATA*)&sharedsecret, - (const TPM_AUTHDATA*)&vtpm_globals.storage_key_usage_auth, - (const TPM_AUTHDATA*)&vtpm_globals.storage_key_usage_auth, - &vtpm_globals.storage_key, - &osap) ); - - //Load Storage Key - TPMTRYRETURN( TPM_LoadKey( - TPM_SRK_KEYHANDLE, - &vtpm_globals.storage_key, - &vtpm_globals.storage_key_handle, - (const TPM_AUTHDATA*) &vtpm_globals.srk_auth, - &vtpm_globals.oiap)); - //Make sure TPM has commited changes TPMTRYRETURN( TPM_SaveState() ); //Create new disk image - TPMTRYRETURN(vtpm_storage_new_header()); + TPMTRYRETURN(vtpm_new_disk()); goto egress; abort_egress: @@ -436,10 +379,21 @@ egress: return status; } -/* Set up the opaque field to contain a pointer to the UUID */ -static void set_opaque_to_uuid(domid_t domid, unsigned int handle) +static void set_opaque(domid_t domid, unsigned int handle) +{ + struct tpm_opaque* opq; + + opq = calloc(1, sizeof(*opq)); + opq->uuid = (uuid_t*)tpmback_get_uuid(domid, handle); + tpmback_set_opaque(domid, handle, opq); +} + +static void free_opaque(domid_t domid, unsigned int handle) { - tpmback_set_opaque(domid, handle, tpmback_get_uuid(domid, handle)); + struct tpm_opaque* opq = tpmback_get_opaque(domid, handle); + if (opq && opq->vtpm) + opq->vtpm->flags &= ~VTPM_FLAG_OPEN; + free(opq); } TPM_RESULT vtpmmgr_init(int argc, char** argv) { @@ -468,7 +422,7 @@ TPM_RESULT vtpmmgr_init(int argc, char** argv) { } //Setup tpmback device - init_tpmback(set_opaque_to_uuid, NULL); + init_tpmback(set_opaque, free_opaque); //Setup tpm access switch(opts.tpmdriver) { @@ -521,7 +475,8 @@ TPM_RESULT vtpmmgr_init(int argc, char** argv) { TPMTRYRETURN( TPM_OIAP(&vtpm_globals.oiap) ); /* Load the Manager data, if it fails create a new manager */ - if (vtpm_storage_load_header() != TPM_SUCCESS) { + // TODO handle upgrade recovery of auth0 + if (vtpm_load_disk()) { /* If the OIAP session was closed by an error, create a new one */ if(vtpm_globals.oiap.AuthHandle == 0) { TPMTRYRETURN( TPM_OIAP(&vtpm_globals.oiap) ); @@ -539,19 +494,12 @@ egress: void vtpmmgr_shutdown(void) { - /* Cleanup resources */ - free_TPM_KEY(&vtpm_globals.storage_key); - /* Cleanup TPM resources */ - TPM_EvictKey(vtpm_globals.storage_key_handle); TPM_TerminateHandle(vtpm_globals.oiap.AuthHandle); /* Close tpmback */ shutdown_tpmback(); - /* Close the storage system and blkfront */ - vtpm_storage_shutdown(); - /* Close tpmfront/tpm_tis */ close(vtpm_globals.tpm_fd); diff --git a/stubdom/vtpmmgr/log.h b/stubdom/vtpmmgr/log.h index 5c7abf5..455219f 100644 --- a/stubdom/vtpmmgr/log.h +++ b/stubdom/vtpmmgr/log.h @@ -64,18 +64,20 @@ extern char *module_names[]; #define SETBIT(num,idx) (num) |= BITMASK(idx) #define CLEARBIT(num,idx) (num) &= ( ~ BITMASK(idx) ) +void printk(const char *fmt, ...); + #define vtpmloginfo(module, fmt, args...) \ if (GETBIT (LOGGING_MODULES, module) == 1) { \ - fprintf (stdout, "INFO[%s]: " fmt, module_names[module], ##args); \ + printk("INFO[%s]: " fmt, module_names[module], ##args); \ } #define vtpmloginfomore(module, fmt, args...) \ if (GETBIT (LOGGING_MODULES, module) == 1) { \ - fprintf (stdout, fmt,##args); \ + printk(fmt,##args); \ } #define vtpmlogerror(module, fmt, args...) \ - fprintf (stderr, "ERROR[%s]: " fmt, module_names[module], ##args); + printk("ERROR[%s]: " fmt, module_names[module], ##args); //typedef UINT32 tpm_size_t; diff --git a/stubdom/vtpmmgr/marshal.h b/stubdom/vtpmmgr/marshal.h index 77d32f0..ef54272 100644 --- a/stubdom/vtpmmgr/marshal.h +++ b/stubdom/vtpmmgr/marshal.h @@ -43,79 +43,81 @@ #include "tcg.h" typedef enum UnpackPtr { - UNPACK_ALIAS, - UNPACK_ALLOC + UNPACK_ALIAS, + UNPACK_ALLOC } UnpackPtr; inline BYTE* pack_BYTE(BYTE* ptr, BYTE t) { - ptr[0] = t; - return ++ptr; + ptr[0] = t; + return ++ptr; } inline BYTE* unpack_BYTE(BYTE* ptr, BYTE* t) { - t[0] = ptr[0]; - return ++ptr; + t[0] = ptr[0]; + return ++ptr; } +inline int unpack3_BYTE(BYTE* ptr, UINT32* pos, UINT32 max, BYTE *t) +{ + if (*pos + 1 > max) + return TPM_SIZE; + unpack_BYTE(ptr + *pos, t); + *pos += 1; + return 0; +} + + #define pack_BOOL(p, t) pack_BYTE(p, t) #define unpack_BOOL(p, t) unpack_BYTE(p, t) +#define unpack3_BOOL(p, x, m, t) unpack3_BYTE(p, x, m, t) +#define sizeof_BOOL(t) 1 -inline BYTE* pack_UINT16(BYTE* ptr, UINT16 t) { - BYTE* b = (BYTE*)&t; -#if __BYTE_ORDER == __LITTLE_ENDIAN - ptr[0] = b[1]; - ptr[1] = b[0]; -#elif __BYTE_ORDER == __BIG_ENDIAN - ptr[0] = b[0]; - ptr[1] = b[1]; -#endif - return ptr + sizeof(UINT16); +inline BYTE* pack_UINT16(void* ptr, UINT16 t) { + UINT16* p = ptr; + *p = cpu_to_be16(t); + return ptr + sizeof(UINT16); } -inline BYTE* unpack_UINT16(BYTE* ptr, UINT16* t) { - BYTE* b = (BYTE*)t; -#if __BYTE_ORDER == __LITTLE_ENDIAN - b[0] = ptr[1]; - b[1] = ptr[0]; -#elif __BYTE_ORDER == __BIG_ENDIAN - b[0] = ptr[0]; - b[1] = ptr[1]; -#endif - return ptr + sizeof(UINT16); -} - -inline BYTE* pack_UINT32(BYTE* ptr, UINT32 t) { - BYTE* b = (BYTE*)&t; -#if __BYTE_ORDER == __LITTLE_ENDIAN - ptr[3] = b[0]; - ptr[2] = b[1]; - ptr[1] = b[2]; - ptr[0] = b[3]; -#elif __BYTE_ORDER == __BIG_ENDIAN - ptr[0] = b[0]; - ptr[1] = b[1]; - ptr[2] = b[2]; - ptr[3] = b[3]; -#endif - return ptr + sizeof(UINT32); -} - -inline BYTE* unpack_UINT32(BYTE* ptr, UINT32* t) { - BYTE* b = (BYTE*)t; -#if __BYTE_ORDER == __LITTLE_ENDIAN - b[0] = ptr[3]; - b[1] = ptr[2]; - b[2] = ptr[1]; - b[3] = ptr[0]; -#elif __BYTE_ORDER == __BIG_ENDIAN - b[0] = ptr[0]; - b[1] = ptr[1]; - b[2] = ptr[2]; - b[3] = ptr[3]; -#endif - return ptr + sizeof(UINT32); +inline BYTE* unpack_UINT16(void* ptr, UINT16* t) { + UINT16* p = ptr; + *t = be16_to_cpu(*p); + return ptr + sizeof(UINT16); +} + +inline int unpack3_UINT16(BYTE* ptr, UINT32* pos, UINT32 max, UINT16 *t) +{ + if (*pos + 2 > max) + return TPM_SIZE; + unpack_UINT16(ptr + *pos, t); + *pos += 2; + return 0; +} + +inline BYTE* pack_UINT32(void* ptr, UINT32 t) { + UINT32* p = ptr; + *p = cpu_to_be32(t); + return ptr + sizeof(UINT32); +} + +inline BYTE* unpack_UINT32(void* ptr, UINT32* t) { + UINT32* p = ptr; + *t = be32_to_cpu(*p); + return ptr + sizeof(UINT32); +} + +inline int unpack3_UINT32(BYTE* ptr, UINT32* pos, UINT32 max, UINT32 *t) +{ + if (*pos + 4 > max) + return TPM_SIZE; + unpack_UINT32(ptr + *pos, t); + *pos += 4; + return 0; } +#define sizeof_BYTE(x) 1 +#define sizeof_UINT16(x) 2 +#define sizeof_UINT32(x) 4 + #define pack_TPM_RESULT(p, t) pack_UINT32(p, t) #define pack_TPM_PCRINDEX(p, t) pack_UINT32(p, t) #define pack_TPM_DIRINDEX(p, t) pack_UINT32(p, t) @@ -166,55 +168,139 @@ inline BYTE* unpack_UINT32(BYTE* ptr, UINT32* t) { #define unpack_TPM_PHYSICAL_PRESENCE(p, t) unpack_UINT16(p, t) #define unpack_TPM_KEY_FLAGS(p, t) unpack_UINT32(p, t) -#define pack_TPM_AUTH_HANDLE(p, t) pack_UINT32(p, t); -#define pack_TCS_CONTEXT_HANDLE(p, t) pack_UINT32(p, t); -#define pack_TCS_KEY_HANDLE(p, t) pack_UINT32(p, t); +#define unpack3_TPM_RESULT(p, l, m, t) unpack3_UINT32(p, l, m, t) +#define unpack3_TPM_PCRINDEX(p, l, m, t) unpack3_UINT32(p, l, m, t) +#define unpack3_TPM_DIRINDEX(p, l, m, t) unpack3_UINT32(p, l, m, t) +#define unpack3_TPM_HANDLE(p, l, m, t) unpack3_UINT32(p, l, m, t) +#define unpack3_TPM_AUTHHANDLE(p, l, m, t) unpack3_TPM_HANDLE(p, l, m, t) +#define unpack3_TCPA_HASHHANDLE(p, l, m, t) unpack3_TPM_HANDLE(p, l, m, t) +#define unpack3_TCPA_HMACHANDLE(p, l, m, t) unpack3_TPM_HANDLE(p, l, m, t) +#define unpack3_TCPA_ENCHANDLE(p, l, m, t) unpack3_TPM_HANDLE(p, l, m, t) +#define unpack3_TPM_KEY_HANDLE(p, l, m, t) unpack3_TPM_HANDLE(p, l, m, t) +#define unpack3_TCPA_ENTITYHANDLE(p, l, m, t) unpack3_TPM_HANDLE(p, l, m, t) +#define unpack3_TPM_RESOURCE_TYPE(p, l, m, t) unpack3_UINT32(p, l, m, t) +#define unpack3_TPM_COMMAND_CODE(p, l, m, t) unpack3_UINT32(p, l, m, t) +#define unpack3_TPM_PROTOCOL_ID(p, l, m, t) unpack3_UINT16(p, l, m, t) +#define unpack3_TPM_AUTH_DATA_USAGE(p, l, m, t) unpack3_BYTE(p, l, m, t) +#define unpack3_TPM_ENTITY_TYPE(p, l, m, t) unpack3_UINT16(p, l, m, t) +#define unpack3_TPM_ALGORITHM_ID(p, l, m, t) unpack3_UINT32(p, l, m, t) +#define unpack3_TPM_KEY_USAGE(p, l, m, t) unpack3_UINT16(p, l, m, t) +#define unpack3_TPM_STARTUP_TYPE(p, l, m, t) unpack3_UINT16(p, l, m, t) +#define unpack3_TPM_CAPABILITY_AREA(p, l, m, t) unpack3_UINT32(p, l, m, t) +#define unpack3_TPM_ENC_SCHEME(p, l, m, t) unpack3_UINT16(p, l, m, t) +#define unpack3_TPM_SIG_SCHEME(p, l, m, t) unpack3_UINT16(p, l, m, t) +#define unpack3_TPM_MIGRATE_SCHEME(p, l, m, t) unpack3_UINT16(p, l, m, t) +#define unpack3_TPM_PHYSICAL_PRESENCE(p, l, m, t) unpack3_UINT16(p, l, m, t) +#define unpack3_TPM_KEY_FLAGS(p, l, m, t) unpack3_UINT32(p, l, m, t) + +#define sizeof_TPM_RESULT(t) sizeof_UINT32(t) +#define sizeof_TPM_PCRINDEX(t) sizeof_UINT32(t) +#define sizeof_TPM_DIRINDEX(t) sizeof_UINT32(t) +#define sizeof_TPM_HANDLE(t) sizeof_UINT32(t) +#define sizeof_TPM_AUTHHANDLE(t) sizeof_TPM_HANDLE(t) +#define sizeof_TCPA_HASHHANDLE(t) sizeof_TPM_HANDLE(t) +#define sizeof_TCPA_HMACHANDLE(t) sizeof_TPM_HANDLE(t) +#define sizeof_TCPA_ENCHANDLE(t) sizeof_TPM_HANDLE(t) +#define sizeof_TPM_KEY_HANDLE(t) sizeof_TPM_HANDLE(t) +#define sizeof_TCPA_ENTITYHANDLE(t) sizeof_TPM_HANDLE(t) +#define sizeof_TPM_RESOURCE_TYPE(t) sizeof_UINT32(t) +#define sizeof_TPM_COMMAND_CODE(t) sizeof_UINT32(t) +#define sizeof_TPM_PROTOCOL_ID(t) sizeof_UINT16(t) +#define sizeof_TPM_AUTH_DATA_USAGE(t) sizeof_BYTE(t) +#define sizeof_TPM_ENTITY_TYPE(t) sizeof_UINT16(t) +#define sizeof_TPM_ALGORITHM_ID(t) sizeof_UINT32(t) +#define sizeof_TPM_KEY_USAGE(t) sizeof_UINT16(t) +#define sizeof_TPM_STARTUP_TYPE(t) sizeof_UINT16(t) +#define sizeof_TPM_CAPABILITY_AREA(t) sizeof_UINT32(t) +#define sizeof_TPM_ENC_SCHEME(t) sizeof_UINT16(t) +#define sizeof_TPM_SIG_SCHEME(t) sizeof_UINT16(t) +#define sizeof_TPM_MIGRATE_SCHEME(t) sizeof_UINT16(t) +#define sizeof_TPM_PHYSICAL_PRESENCE(t) sizeof_UINT16(t) +#define sizeof_TPM_KEY_FLAGS(t) sizeof_UINT32(t) + +#define pack_TPM_AUTH_HANDLE(p, t) pack_UINT32(p, t) +#define pack_TCS_CONTEXT_HANDLE(p, t) pack_UINT32(p, t) +#define pack_TCS_KEY_HANDLE(p, t) pack_UINT32(p, t) + +#define unpack_TPM_AUTH_HANDLE(p, t) unpack_UINT32(p, t) +#define unpack_TCS_CONTEXT_HANDLE(p, t) unpack_UINT32(p, t) +#define unpack_TCS_KEY_HANDLE(p, t) unpack_UINT32(p, t) + +#define sizeof_TPM_AUTH_HANDLE(t) sizeof_UINT32(t) +#define sizeof_TCS_CONTEXT_HANDLE(t) sizeof_UINT32(t) +#define sizeof_TCS_KEY_HANDLE(t) sizeof_UINT32(t) -#define unpack_TPM_AUTH_HANDLE(p, t) unpack_UINT32(p, t); -#define unpack_TCS_CONTEXT_HANDLE(p, t) unpack_UINT32(p, t); -#define unpack_TCS_KEY_HANDLE(p, t) unpack_UINT32(p, t); inline BYTE* pack_BUFFER(BYTE* ptr, const BYTE* buf, UINT32 size) { - memcpy(ptr, buf, size); - return ptr + size; + memcpy(ptr, buf, size); + return ptr + size; } inline BYTE* unpack_BUFFER(BYTE* ptr, BYTE* buf, UINT32 size) { - memcpy(buf, ptr, size); - return ptr + size; + memcpy(buf, ptr, size); + return ptr + size; +} + +inline int unpack3_BUFFER(BYTE* ptr, UINT32* pos, UINT32 max, BYTE* buf, UINT32 size) { + if (*pos + size > max) + return TPM_SIZE; + memcpy(buf, ptr + *pos, size); + *pos += size; + return 0; } +#define sizeof_BUFFER(b, s) s + inline BYTE* unpack_ALIAS(BYTE* ptr, BYTE** buf, UINT32 size) { - *buf = ptr; - return ptr + size; + *buf = ptr; + return ptr + size; } inline BYTE* unpack_ALLOC(BYTE* ptr, BYTE** buf, UINT32 size) { - if(size) { - *buf = malloc(size); - memcpy(*buf, ptr, size); - } else { - *buf = NULL; - } - return ptr + size; + if(size) { + *buf = malloc(size); + memcpy(*buf, ptr, size); + } else { + *buf = NULL; + } + return ptr + size; } inline BYTE* unpack_PTR(BYTE* ptr, BYTE** buf, UINT32 size, UnpackPtr alloc) { - if(alloc == UNPACK_ALLOC) { - return unpack_ALLOC(ptr, buf, size); - } else { - return unpack_ALIAS(ptr, buf, size); - } -} + if(alloc == UNPACK_ALLOC) { + return unpack_ALLOC(ptr, buf, size); + } else { + return unpack_ALIAS(ptr, buf, size); + } +} + +inline int unpack3_PTR(BYTE* ptr, UINT32* pos, UINT32 max, BYTE** buf, UINT32 size, UnpackPtr alloc) { + if (size > max || *pos + size > max) + return TPM_SIZE; + if (alloc == UNPACK_ALLOC) { + unpack_ALLOC(ptr + *pos, buf, size); + } else { + unpack_ALIAS(ptr + *pos, buf, size); + } + *pos += size; + return 0; +} +#define unpack3_VPTR(ptr, pos, max, buf, size, alloc) unpack3_PTR(ptr, pos, max, (void*)(buf), size, alloc) inline BYTE* pack_TPM_AUTHDATA(BYTE* ptr, const TPM_AUTHDATA* d) { - return pack_BUFFER(ptr, *d, TPM_DIGEST_SIZE); + return pack_BUFFER(ptr, *d, TPM_DIGEST_SIZE); } inline BYTE* unpack_TPM_AUTHDATA(BYTE* ptr, TPM_AUTHDATA* d) { - return unpack_BUFFER(ptr, *d, TPM_DIGEST_SIZE); + return unpack_BUFFER(ptr, *d, TPM_DIGEST_SIZE); +} + +inline int unpack3_TPM_AUTHDATA(BYTE* ptr, UINT32* pos, UINT32 len, TPM_AUTHDATA* d) { + return unpack3_BUFFER(ptr, pos, len, *d, TPM_DIGEST_SIZE); } +#define sizeof_TPM_AUTHDATA(d) TPM_DIGEST_SIZE + #define pack_TPM_SECRET(p, t) pack_TPM_AUTHDATA(p, t) #define pack_TPM_ENCAUTH(p, t) pack_TPM_AUTHDATA(p, t) #define pack_TPM_PAYLOAD_TYPE(p, t) pack_BYTE(p, t) @@ -227,302 +313,456 @@ inline BYTE* unpack_TPM_AUTHDATA(BYTE* ptr, TPM_AUTHDATA* d) { #define unpack_TPM_TAG(p, t) unpack_UINT16(p, t) #define unpack_TPM_STRUCTURE_TAG(p, t) unpack_UINT16(p, t) +#define sizeof_TPM_SECRET(t) sizeof_TPM_AUTHDATA(t) +#define sizeof_TPM_ENCAUTH(t) sizeof_TPM_AUTHDATA(t) +#define sizeof_TPM_PAYLOAD_TYPE(t) sizeof_BYTE(t) +#define sizeof_TPM_TAG(t) sizeof_UINT16(t) +#define sizeof_TPM_STRUCTURE_TAG(t) sizeof_UINT16(t) + inline BYTE* pack_TPM_VERSION(BYTE* ptr, const TPM_VERSION* t) { - ptr[0] = t->major; - ptr[1] = t->minor; - ptr[2] = t->revMajor; - ptr[3] = t->revMinor; - return ptr + 4; + ptr[0] = t->major; + ptr[1] = t->minor; + ptr[2] = t->revMajor; + ptr[3] = t->revMinor; + return ptr + 4; } inline BYTE* unpack_TPM_VERSION(BYTE* ptr, TPM_VERSION* t) { - t->major = ptr[0]; - t->minor = ptr[1]; - t->revMajor = ptr[2]; - t->revMinor = ptr[3]; - return ptr + 4; + t->major = ptr[0]; + t->minor = ptr[1]; + t->revMajor = ptr[2]; + t->revMinor = ptr[3]; + return ptr + 4; +} + +inline int unpack3_TPM_VERSION(BYTE* ptr, UINT32 *pos, UINT32 max, TPM_VERSION* t) { + if (*pos + 4 > max) + return TPM_SIZE; + ptr += *pos; + t->major = ptr[0]; + t->minor = ptr[1]; + t->revMajor = ptr[2]; + t->revMinor = ptr[3]; + *pos += 4; + return 0; } +#define sizeof_TPM_VERSION(x) 4 + inline BYTE* pack_TPM_CAP_VERSION_INFO(BYTE* ptr, const TPM_CAP_VERSION_INFO* v) { - ptr = pack_TPM_STRUCTURE_TAG(ptr, v->tag); - ptr = pack_TPM_VERSION(ptr, &v->version); - ptr = pack_UINT16(ptr, v->specLevel); - ptr = pack_BYTE(ptr, v->errataRev); - ptr = pack_BUFFER(ptr, v->tpmVendorID, sizeof(v->tpmVendorID)); - ptr = pack_UINT16(ptr, v->vendorSpecificSize); - ptr = pack_BUFFER(ptr, v->vendorSpecific, v->vendorSpecificSize); - return ptr; + ptr = pack_TPM_STRUCTURE_TAG(ptr, v->tag); + ptr = pack_TPM_VERSION(ptr, &v->version); + ptr = pack_UINT16(ptr, v->specLevel); + ptr = pack_BYTE(ptr, v->errataRev); + ptr = pack_BUFFER(ptr, v->tpmVendorID, sizeof(v->tpmVendorID)); + ptr = pack_UINT16(ptr, v->vendorSpecificSize); + ptr = pack_BUFFER(ptr, v->vendorSpecific, v->vendorSpecificSize); + return ptr; } inline BYTE* unpack_TPM_CAP_VERSION_INFO(BYTE* ptr, TPM_CAP_VERSION_INFO* v, UnpackPtr alloc) { - ptr = unpack_TPM_STRUCTURE_TAG(ptr, &v->tag); - ptr = unpack_TPM_VERSION(ptr, &v->version); - ptr = unpack_UINT16(ptr, &v->specLevel); - ptr = unpack_BYTE(ptr, &v->errataRev); - ptr = unpack_BUFFER(ptr, v->tpmVendorID, sizeof(v->tpmVendorID)); - ptr = unpack_UINT16(ptr, &v->vendorSpecificSize); - ptr = unpack_PTR(ptr, &v->vendorSpecific, v->vendorSpecificSize, alloc); - return ptr; + ptr = unpack_TPM_STRUCTURE_TAG(ptr, &v->tag); + ptr = unpack_TPM_VERSION(ptr, &v->version); + ptr = unpack_UINT16(ptr, &v->specLevel); + ptr = unpack_BYTE(ptr, &v->errataRev); + ptr = unpack_BUFFER(ptr, v->tpmVendorID, sizeof(v->tpmVendorID)); + ptr = unpack_UINT16(ptr, &v->vendorSpecificSize); + ptr = unpack_PTR(ptr, &v->vendorSpecific, v->vendorSpecificSize, alloc); + return ptr; } inline BYTE* pack_TPM_DIGEST(BYTE* ptr, const TPM_DIGEST* d) { - return pack_BUFFER(ptr, d->digest, TPM_DIGEST_SIZE); + return pack_BUFFER(ptr, d->digest, TPM_DIGEST_SIZE); } inline BYTE* unpack_TPM_DIGEST(BYTE* ptr, TPM_DIGEST* d) { - return unpack_BUFFER(ptr, d->digest, TPM_DIGEST_SIZE); + return unpack_BUFFER(ptr, d->digest, TPM_DIGEST_SIZE); +} + +inline int unpack3_TPM_DIGEST(BYTE* ptr, UINT32* pos, UINT32 max, TPM_DIGEST* d) { + return unpack3_BUFFER(ptr, pos, max, d->digest, TPM_DIGEST_SIZE); } -#define pack_TPM_PCRVALUE(ptr, d) pack_TPM_DIGEST(ptr, d); -#define unpack_TPM_PCRVALUE(ptr, d) unpack_TPM_DIGEST(ptr, d); +#define sizeof_TPM_DIGEST(d) TPM_DIGEST_SIZE -#define pack_TPM_COMPOSITE_HASH(ptr, d) pack_TPM_DIGEST(ptr, d); -#define unpack_TPM_COMPOSITE_HASH(ptr, d) unpack_TPM_DIGEST(ptr, d); +#define pack_TPM_PCRVALUE(ptr, d) pack_TPM_DIGEST(ptr, d) +#define unpack_TPM_PCRVALUE(ptr, d) unpack_TPM_DIGEST(ptr, d) +#define unpack3_TPM_PCRVALUE(p...) unpack3_TPM_DIGEST(p) -#define pack_TPM_DIRVALUE(ptr, d) pack_TPM_DIGEST(ptr, d); -#define unpack_TPM_DIRVALUE(ptr, d) unpack_TPM_DIGEST(ptr, d); +#define pack_TPM_COMPOSITE_HASH(ptr, d) pack_TPM_DIGEST(ptr, d) +#define unpack_TPM_COMPOSITE_HASH(ptr, d) unpack_TPM_DIGEST(ptr, d) +#define unpack3_TPM_COMPOSITE_HASH(ptr, p, m, d) unpack3_TPM_DIGEST(ptr, p, m, d) +#define sizeof_TPM_COMPOSITE_HASH(d) TPM_DIGEST_SIZE -#define pack_TPM_HMAC(ptr, d) pack_TPM_DIGEST(ptr, d); -#define unpack_TPM_HMAC(ptr, d) unpack_TPM_DIGEST(ptr, d); +#define pack_TPM_DIRVALUE(ptr, d) pack_TPM_DIGEST(ptr, d) +#define unpack_TPM_DIRVALUE(ptr, d) unpack_TPM_DIGEST(ptr, d) -#define pack_TPM_CHOSENID_HASH(ptr, d) pack_TPM_DIGEST(ptr, d); -#define unpack_TPM_CHOSENID_HASH(ptr, d) unpack_TPM_DIGEST(ptr, d); +#define pack_TPM_HMAC(ptr, d) pack_TPM_DIGEST(ptr, d) +#define unpack_TPM_HMAC(ptr, d) unpack_TPM_DIGEST(ptr, d) + +#define pack_TPM_CHOSENID_HASH(ptr, d) pack_TPM_DIGEST(ptr, d) +#define unpack_TPM_CHOSENID_HASH(ptr, d) unpack_TPM_DIGEST(ptr, d) inline BYTE* pack_TPM_NONCE(BYTE* ptr, const TPM_NONCE* n) { - return pack_BUFFER(ptr, n->nonce, TPM_DIGEST_SIZE); + return pack_BUFFER(ptr, n->nonce, TPM_DIGEST_SIZE); } inline BYTE* unpack_TPM_NONCE(BYTE* ptr, TPM_NONCE* n) { - return unpack_BUFFER(ptr, n->nonce, TPM_DIGEST_SIZE); + return unpack_BUFFER(ptr, n->nonce, TPM_DIGEST_SIZE); +} + +#define sizeof_TPM_NONCE(x) TPM_DIGEST_SIZE + +inline int unpack3_TPM_NONCE(BYTE* ptr, UINT32* pos, UINT32 max, TPM_NONCE* n) { + return unpack3_BUFFER(ptr, pos, max, n->nonce, TPM_DIGEST_SIZE); } inline BYTE* pack_TPM_SYMMETRIC_KEY_PARMS(BYTE* ptr, const TPM_SYMMETRIC_KEY_PARMS* k) { - ptr = pack_UINT32(ptr, k->keyLength); - ptr = pack_UINT32(ptr, k->blockSize); - ptr = pack_UINT32(ptr, k->ivSize); - return pack_BUFFER(ptr, k->IV, k->ivSize); + ptr = pack_UINT32(ptr, k->keyLength); + ptr = pack_UINT32(ptr, k->blockSize); + ptr = pack_UINT32(ptr, k->ivSize); + return pack_BUFFER(ptr, k->IV, k->ivSize); +} + +inline BYTE* pack_TPM_SYMMETRIC_KEY(BYTE* ptr, const TPM_SYMMETRIC_KEY* k) { + ptr = pack_UINT32(ptr, k->algId); + ptr = pack_UINT16(ptr, k->encScheme); + ptr = pack_UINT16(ptr, k->size); + return pack_BUFFER(ptr, k->data, k->size); +} + +inline int unpack3_TPM_SYMMETRIC_KEY_PARMS(BYTE* ptr, UINT32* pos, UINT32 max, TPM_SYMMETRIC_KEY_PARMS* k, UnpackPtr alloc) { + return unpack3_UINT32(ptr, pos, max, &k->keyLength) || + unpack3_UINT32(ptr, pos, max, &k->blockSize) || + unpack3_UINT32(ptr, pos, max, &k->ivSize) || + unpack3_PTR(ptr, pos, max, &k->IV, k->ivSize, alloc); } -inline BYTE* unpack_TPM_SYMMETRIC_KEY_PARMS(BYTE* ptr, TPM_SYMMETRIC_KEY_PARMS* k, UnpackPtr alloc) { - ptr = unpack_UINT32(ptr, &k->keyLength); - ptr = unpack_UINT32(ptr, &k->blockSize); - ptr = unpack_UINT32(ptr, &k->ivSize); - return unpack_PTR(ptr, &k->IV, k->ivSize, alloc); +inline int sizeof_TPM_SYMMETRIC_KEY_PARMS(const TPM_SYMMETRIC_KEY_PARMS* k) { + return 12 + k->ivSize; +} + +inline int unpack3_TPM_SYMMETRIC_KEY(BYTE* ptr, UINT32* pos, UINT32 max, TPM_SYMMETRIC_KEY* k, UnpackPtr alloc) { + return unpack3_UINT32(ptr, pos, max, &k->algId) || + unpack3_UINT16(ptr, pos, max, &k->encScheme) || + unpack3_UINT16(ptr, pos, max, &k->size) || + unpack3_PTR(ptr, pos, max, &k->data, k->size, alloc); } inline BYTE* pack_TPM_RSA_KEY_PARMS(BYTE* ptr, const TPM_RSA_KEY_PARMS* k) { - ptr = pack_UINT32(ptr, k->keyLength); - ptr = pack_UINT32(ptr, k->numPrimes); - ptr = pack_UINT32(ptr, k->exponentSize); - return pack_BUFFER(ptr, k->exponent, k->exponentSize); + ptr = pack_UINT32(ptr, k->keyLength); + ptr = pack_UINT32(ptr, k->numPrimes); + ptr = pack_UINT32(ptr, k->exponentSize); + return pack_BUFFER(ptr, k->exponent, k->exponentSize); +} + +inline int unpack3_TPM_RSA_KEY_PARMS(BYTE* ptr, UINT32* pos, UINT32 max, TPM_RSA_KEY_PARMS* k, UnpackPtr alloc) { + return unpack3_UINT32(ptr, pos, max, &k->keyLength) || + unpack3_UINT32(ptr, pos, max, &k->numPrimes) || + unpack3_UINT32(ptr, pos, max, &k->exponentSize) || + unpack3_PTR(ptr, pos, max, &k->exponent, k->exponentSize, alloc); } -inline BYTE* unpack_TPM_RSA_KEY_PARMS(BYTE* ptr, TPM_RSA_KEY_PARMS* k, UnpackPtr alloc) { - ptr = unpack_UINT32(ptr, &k->keyLength); - ptr = unpack_UINT32(ptr, &k->numPrimes); - ptr = unpack_UINT32(ptr, &k->exponentSize); - return unpack_PTR(ptr, &k->exponent, k->exponentSize, alloc); +inline int sizeof_TPM_RSA_KEY_PARMS(const TPM_RSA_KEY_PARMS* k) { + return 12 + k->exponentSize; } + inline BYTE* pack_TPM_KEY_PARMS(BYTE* ptr, const TPM_KEY_PARMS* k) { - ptr = pack_TPM_ALGORITHM_ID(ptr, k->algorithmID); - ptr = pack_TPM_ENC_SCHEME(ptr, k->encScheme); - ptr = pack_TPM_SIG_SCHEME(ptr, k->sigScheme); - ptr = pack_UINT32(ptr, k->parmSize); - - if(k->parmSize) { - switch(k->algorithmID) { - case TPM_ALG_RSA: - return pack_TPM_RSA_KEY_PARMS(ptr, &k->parms.rsa); - case TPM_ALG_AES128: - case TPM_ALG_AES192: - case TPM_ALG_AES256: - return pack_TPM_SYMMETRIC_KEY_PARMS(ptr, &k->parms.sym); - } - } - return ptr; -} - -inline BYTE* unpack_TPM_KEY_PARMS(BYTE* ptr, TPM_KEY_PARMS* k, UnpackPtr alloc) { - ptr = unpack_TPM_ALGORITHM_ID(ptr, &k->algorithmID); - ptr = unpack_TPM_ENC_SCHEME(ptr, &k->encScheme); - ptr = unpack_TPM_SIG_SCHEME(ptr, &k->sigScheme); - ptr = unpack_UINT32(ptr, &k->parmSize); - - if(k->parmSize) { - switch(k->algorithmID) { - case TPM_ALG_RSA: - return unpack_TPM_RSA_KEY_PARMS(ptr, &k->parms.rsa, alloc); - case TPM_ALG_AES128: - case TPM_ALG_AES192: - case TPM_ALG_AES256: - return unpack_TPM_SYMMETRIC_KEY_PARMS(ptr, &k->parms.sym, alloc); - } - } - return ptr; + ptr = pack_TPM_ALGORITHM_ID(ptr, k->algorithmID); + ptr = pack_TPM_ENC_SCHEME(ptr, k->encScheme); + ptr = pack_TPM_SIG_SCHEME(ptr, k->sigScheme); + ptr = pack_UINT32(ptr, k->parmSize); + + if(k->parmSize) { + switch(k->algorithmID) { + case TPM_ALG_RSA: + return pack_TPM_RSA_KEY_PARMS(ptr, &k->parms.rsa); + case TPM_ALG_AES128: + case TPM_ALG_AES192: + case TPM_ALG_AES256: + return pack_TPM_SYMMETRIC_KEY_PARMS(ptr, &k->parms.sym); + } + } + return ptr; +} + +inline int unpack3_TPM_KEY_PARMS(BYTE* ptr, UINT32* pos, UINT32 len, TPM_KEY_PARMS* k, UnpackPtr alloc) { + int rc = unpack3_TPM_ALGORITHM_ID(ptr, pos, len, &k->algorithmID) || + unpack3_TPM_ENC_SCHEME(ptr, pos, len, &k->encScheme) || + unpack3_TPM_SIG_SCHEME(ptr, pos, len, &k->sigScheme) || + unpack3_UINT32(ptr, pos, len, &k->parmSize); + if (rc || k->parmSize == 0) + return rc; + switch(k->algorithmID) { + case TPM_ALG_RSA: + return unpack3_TPM_RSA_KEY_PARMS(ptr, pos, len, &k->parms.rsa, alloc); + case TPM_ALG_AES128: + case TPM_ALG_AES192: + case TPM_ALG_AES256: + return unpack3_TPM_SYMMETRIC_KEY_PARMS(ptr, pos, len, &k->parms.sym, alloc); + } + return TPM_FAIL; +} + +inline int sizeof_TPM_KEY_PARMS(const TPM_KEY_PARMS* k) { + int rc = 0; + rc += sizeof_TPM_ALGORITHM_ID(&k->algorithmID); + rc += sizeof_TPM_ENC_SCHEME(&k->encScheme); + rc += sizeof_TPM_SIG_SCHEME(&k->sigScheme); + rc += sizeof_UINT32(&k->parmSize); + if (!k->parmSize) + return rc; + switch(k->algorithmID) { + case TPM_ALG_RSA: + rc += sizeof_TPM_RSA_KEY_PARMS(&k->parms.rsa); + break; + case TPM_ALG_AES128: + case TPM_ALG_AES192: + case TPM_ALG_AES256: + rc += sizeof_TPM_SYMMETRIC_KEY_PARMS(&k->parms.sym); + break; + } + return rc; } inline BYTE* pack_TPM_STORE_PUBKEY(BYTE* ptr, const TPM_STORE_PUBKEY* k) { - ptr = pack_UINT32(ptr, k->keyLength); - ptr = pack_BUFFER(ptr, k->key, k->keyLength); - return ptr; + ptr = pack_UINT32(ptr, k->keyLength); + ptr = pack_BUFFER(ptr, k->key, k->keyLength); + return ptr; +} + +inline int unpack3_TPM_STORE_PUBKEY(BYTE* ptr, UINT32* pos, UINT32 max, TPM_STORE_PUBKEY* k, UnpackPtr alloc) { + return unpack3_UINT32(ptr, pos, max, &k->keyLength) || + unpack3_PTR(ptr, pos, max, &k->key, k->keyLength, alloc); } -inline BYTE* unpack_TPM_STORE_PUBKEY(BYTE* ptr, TPM_STORE_PUBKEY* k, UnpackPtr alloc) { - ptr = unpack_UINT32(ptr, &k->keyLength); - ptr = unpack_PTR(ptr, &k->key, k->keyLength, alloc); - return ptr; +inline int sizeof_TPM_STORE_PUBKEY(const TPM_STORE_PUBKEY* k) { + return 4 + k->keyLength; } inline BYTE* pack_TPM_PUBKEY(BYTE* ptr, const TPM_PUBKEY* k) { - ptr = pack_TPM_KEY_PARMS(ptr, &k->algorithmParms); - return pack_TPM_STORE_PUBKEY(ptr, &k->pubKey); + ptr = pack_TPM_KEY_PARMS(ptr, &k->algorithmParms); + return pack_TPM_STORE_PUBKEY(ptr, &k->pubKey); } -inline BYTE* unpack_TPM_PUBKEY(BYTE* ptr, TPM_PUBKEY* k, UnpackPtr alloc) { - ptr = unpack_TPM_KEY_PARMS(ptr, &k->algorithmParms, alloc); - return unpack_TPM_STORE_PUBKEY(ptr, &k->pubKey, alloc); +inline int unpack3_TPM_PUBKEY(BYTE* ptr, UINT32* pos, UINT32 len, TPM_PUBKEY* k, UnpackPtr alloc) { + return unpack3_TPM_KEY_PARMS(ptr, pos, len, &k->algorithmParms, alloc) || + unpack3_TPM_STORE_PUBKEY(ptr, pos, len, &k->pubKey, alloc); } inline BYTE* pack_TPM_PCR_SELECTION(BYTE* ptr, const TPM_PCR_SELECTION* p) { - ptr = pack_UINT16(ptr, p->sizeOfSelect); - ptr = pack_BUFFER(ptr, p->pcrSelect, p->sizeOfSelect); - return ptr; + ptr = pack_UINT16(ptr, p->sizeOfSelect); + ptr = pack_BUFFER(ptr, p->pcrSelect, p->sizeOfSelect); + return ptr; } inline BYTE* unpack_TPM_PCR_SELECTION(BYTE* ptr, TPM_PCR_SELECTION* p, UnpackPtr alloc) { - ptr = unpack_UINT16(ptr, &p->sizeOfSelect); - ptr = unpack_PTR(ptr, &p->pcrSelect, p->sizeOfSelect, alloc); - return ptr; + ptr = unpack_UINT16(ptr, &p->sizeOfSelect); + ptr = unpack_PTR(ptr, &p->pcrSelect, p->sizeOfSelect, alloc); + return ptr; +} + +inline int unpack3_TPM_PCR_SELECTION(BYTE* ptr, UINT32* pos, UINT32 max, TPM_PCR_SELECTION* p, UnpackPtr alloc) { + return unpack3_UINT16(ptr, pos, max, &p->sizeOfSelect) || + unpack3_PTR(ptr, pos, max, &p->pcrSelect, p->sizeOfSelect, alloc); +} + +inline int sizeof_TPM_PCR_SELECTION(const TPM_PCR_SELECTION* p) { + return 2 + p->sizeOfSelect; } inline BYTE* pack_TPM_PCR_INFO(BYTE* ptr, const TPM_PCR_INFO* p) { - ptr = pack_TPM_PCR_SELECTION(ptr, &p->pcrSelection); - ptr = pack_TPM_COMPOSITE_HASH(ptr, &p->digestAtRelease); - ptr = pack_TPM_COMPOSITE_HASH(ptr, &p->digestAtCreation); - return ptr; + ptr = pack_TPM_PCR_SELECTION(ptr, &p->pcrSelection); + ptr = pack_TPM_COMPOSITE_HASH(ptr, &p->digestAtRelease); + ptr = pack_TPM_COMPOSITE_HASH(ptr, &p->digestAtCreation); + return ptr; } -inline BYTE* unpack_TPM_PCR_INFO(BYTE* ptr, TPM_PCR_INFO* p, UnpackPtr alloc) { - ptr = unpack_TPM_PCR_SELECTION(ptr, &p->pcrSelection, alloc); - ptr = unpack_TPM_COMPOSITE_HASH(ptr, &p->digestAtRelease); - ptr = unpack_TPM_COMPOSITE_HASH(ptr, &p->digestAtCreation); - return ptr; +inline int unpack3_TPM_PCR_INFO(BYTE* ptr, UINT32* pos, UINT32 max, TPM_PCR_INFO* p, UnpackPtr alloc) { + return unpack3_TPM_PCR_SELECTION(ptr, pos, max, &p->pcrSelection, alloc) || + unpack3_TPM_COMPOSITE_HASH(ptr, pos, max, &p->digestAtRelease) || + unpack3_TPM_COMPOSITE_HASH(ptr, pos, max, &p->digestAtCreation); } +inline int sizeof_TPM_PCR_INFO(const TPM_PCR_INFO* p) { + int rc = 0; + rc += sizeof_TPM_PCR_SELECTION(&p->pcrSelection); + rc += sizeof_TPM_COMPOSITE_HASH(&p->digestAtRelease); + rc += sizeof_TPM_COMPOSITE_HASH(&p->digestAtCreation); + return rc; +} + + inline BYTE* pack_TPM_PCR_COMPOSITE(BYTE* ptr, const TPM_PCR_COMPOSITE* p) { - ptr = pack_TPM_PCR_SELECTION(ptr, &p->select); - ptr = pack_UINT32(ptr, p->valueSize); - ptr = pack_BUFFER(ptr, (const BYTE*)p->pcrValue, p->valueSize); - return ptr; + ptr = pack_TPM_PCR_SELECTION(ptr, &p->select); + ptr = pack_UINT32(ptr, p->valueSize); + ptr = pack_BUFFER(ptr, (const BYTE*)p->pcrValue, p->valueSize); + return ptr; } -inline BYTE* unpack_TPM_PCR_COMPOSITE(BYTE* ptr, TPM_PCR_COMPOSITE* p, UnpackPtr alloc) { - ptr = unpack_TPM_PCR_SELECTION(ptr, &p->select, alloc); - ptr = unpack_UINT32(ptr, &p->valueSize); - ptr = unpack_PTR(ptr, (BYTE**)&p->pcrValue, p->valueSize, alloc); - return ptr; +inline int unpack3_TPM_PCR_COMPOSITE(BYTE* ptr, UINT32* pos, UINT32 max, TPM_PCR_COMPOSITE* p, UnpackPtr alloc) { + return unpack3_TPM_PCR_SELECTION(ptr, pos, max, &p->select, alloc) || + unpack3_UINT32(ptr, pos, max, &p->valueSize) || + unpack3_PTR(ptr, pos, max, (BYTE**)&p->pcrValue, p->valueSize, alloc); } inline BYTE* pack_TPM_KEY(BYTE* ptr, const TPM_KEY* k) { - ptr = pack_TPM_VERSION(ptr, &k->ver); - ptr = pack_TPM_KEY_USAGE(ptr, k->keyUsage); - ptr = pack_TPM_KEY_FLAGS(ptr, k->keyFlags); - ptr = pack_TPM_AUTH_DATA_USAGE(ptr, k->authDataUsage); - ptr = pack_TPM_KEY_PARMS(ptr, &k->algorithmParms); - ptr = pack_UINT32(ptr, k->PCRInfoSize); - if(k->PCRInfoSize) { - ptr = pack_TPM_PCR_INFO(ptr, &k->PCRInfo); - } - ptr = pack_TPM_STORE_PUBKEY(ptr, &k->pubKey); - ptr = pack_UINT32(ptr, k->encDataSize); - return pack_BUFFER(ptr, k->encData, k->encDataSize); -} - -inline BYTE* unpack_TPM_KEY(BYTE* ptr, TPM_KEY* k, UnpackPtr alloc) { - ptr = unpack_TPM_VERSION(ptr, &k->ver); - ptr = unpack_TPM_KEY_USAGE(ptr, &k->keyUsage); - ptr = unpack_TPM_KEY_FLAGS(ptr, &k->keyFlags); - ptr = unpack_TPM_AUTH_DATA_USAGE(ptr, &k->authDataUsage); - ptr = unpack_TPM_KEY_PARMS(ptr, &k->algorithmParms, alloc); - ptr = unpack_UINT32(ptr, &k->PCRInfoSize); - if(k->PCRInfoSize) { - ptr = unpack_TPM_PCR_INFO(ptr, &k->PCRInfo, alloc); - } - ptr = unpack_TPM_STORE_PUBKEY(ptr, &k->pubKey, alloc); - ptr = unpack_UINT32(ptr, &k->encDataSize); - return unpack_PTR(ptr, &k->encData, k->encDataSize, alloc); + ptr = pack_TPM_VERSION(ptr, &k->ver); + ptr = pack_TPM_KEY_USAGE(ptr, k->keyUsage); + ptr = pack_TPM_KEY_FLAGS(ptr, k->keyFlags); + ptr = pack_TPM_AUTH_DATA_USAGE(ptr, k->authDataUsage); + ptr = pack_TPM_KEY_PARMS(ptr, &k->algorithmParms); + ptr = pack_UINT32(ptr, k->PCRInfoSize); + if(k->PCRInfoSize) { + ptr = pack_TPM_PCR_INFO(ptr, &k->PCRInfo); + } + ptr = pack_TPM_STORE_PUBKEY(ptr, &k->pubKey); + ptr = pack_UINT32(ptr, k->encDataSize); + return pack_BUFFER(ptr, k->encData, k->encDataSize); +} + +inline int unpack3_TPM_KEY(BYTE* ptr, UINT32* pos, UINT32 max, TPM_KEY* k, UnpackPtr alloc) { + int rc = unpack3_TPM_VERSION(ptr, pos, max, &k->ver) || + unpack3_TPM_KEY_USAGE(ptr, pos, max, &k->keyUsage) || + unpack3_TPM_KEY_FLAGS(ptr, pos, max, &k->keyFlags) || + unpack3_TPM_AUTH_DATA_USAGE(ptr, pos, max, &k->authDataUsage) || + unpack3_TPM_KEY_PARMS(ptr, pos, max, &k->algorithmParms, alloc) || + unpack3_UINT32(ptr, pos, max, &k->PCRInfoSize); + if (rc) return rc; + if(k->PCRInfoSize) { + rc = unpack3_TPM_PCR_INFO(ptr, pos, max, &k->PCRInfo, alloc); + } + if (rc) return rc; + return unpack3_TPM_STORE_PUBKEY(ptr, pos, max, &k->pubKey, alloc) || + unpack3_UINT32(ptr, pos, max, &k->encDataSize) || + unpack3_PTR(ptr, pos, max, &k->encData, k->encDataSize, alloc); +} + +inline int sizeof_TPM_KEY(const TPM_KEY* k) { + int rc = 0; + rc += sizeof_TPM_VERSION(&k->ver); + rc += sizeof_TPM_KEY_USAGE(k->keyUsage); + rc += sizeof_TPM_KEY_FLAGS(k->keyFlags); + rc += sizeof_TPM_AUTH_DATA_USAGE(k->authDataUsage); + rc += sizeof_TPM_KEY_PARMS(&k->algorithmParms); + rc += sizeof_UINT32(k->PCRInfoSize); + if(k->PCRInfoSize) { + rc += sizeof_TPM_PCR_INFO(&k->PCRInfo); + } + rc += sizeof_TPM_STORE_PUBKEY(&k->pubKey); + rc += sizeof_UINT32(k->encDataSize); + rc += k->encDataSize; + return rc; } inline BYTE* pack_TPM_BOUND_DATA(BYTE* ptr, const TPM_BOUND_DATA* b, UINT32 payloadSize) { - ptr = pack_TPM_VERSION(ptr, &b->ver); - ptr = pack_TPM_PAYLOAD_TYPE(ptr, b->payload); - return pack_BUFFER(ptr, b->payloadData, payloadSize); + ptr = pack_TPM_VERSION(ptr, &b->ver); + ptr = pack_TPM_PAYLOAD_TYPE(ptr, b->payload); + return pack_BUFFER(ptr, b->payloadData, payloadSize); } inline BYTE* unpack_TPM_BOUND_DATA(BYTE* ptr, TPM_BOUND_DATA* b, UINT32 payloadSize, UnpackPtr alloc) { - ptr = unpack_TPM_VERSION(ptr, &b->ver); - ptr = unpack_TPM_PAYLOAD_TYPE(ptr, &b->payload); - return unpack_PTR(ptr, &b->payloadData, payloadSize, alloc); + ptr = unpack_TPM_VERSION(ptr, &b->ver); + ptr = unpack_TPM_PAYLOAD_TYPE(ptr, &b->payload); + return unpack_PTR(ptr, &b->payloadData, payloadSize, alloc); } inline BYTE* pack_TPM_STORED_DATA(BYTE* ptr, const TPM_STORED_DATA* d) { - ptr = pack_TPM_VERSION(ptr, &d->ver); - ptr = pack_UINT32(ptr, d->sealInfoSize); - if(d->sealInfoSize) { - ptr = pack_TPM_PCR_INFO(ptr, &d->sealInfo); - } - ptr = pack_UINT32(ptr, d->encDataSize); - ptr = pack_BUFFER(ptr, d->encData, d->encDataSize); - return ptr; -} - -inline BYTE* unpack_TPM_STORED_DATA(BYTE* ptr, TPM_STORED_DATA* d, UnpackPtr alloc) { - ptr = unpack_TPM_VERSION(ptr, &d->ver); - ptr = unpack_UINT32(ptr, &d->sealInfoSize); - if(d->sealInfoSize) { - ptr = unpack_TPM_PCR_INFO(ptr, &d->sealInfo, alloc); - } - ptr = unpack_UINT32(ptr, &d->encDataSize); - ptr = unpack_PTR(ptr, &d->encData, d->encDataSize, alloc); - return ptr; + ptr = pack_TPM_VERSION(ptr, &d->ver); + ptr = pack_UINT32(ptr, d->sealInfoSize); + if(d->sealInfoSize) { + ptr = pack_TPM_PCR_INFO(ptr, &d->sealInfo); + } + ptr = pack_UINT32(ptr, d->encDataSize); + ptr = pack_BUFFER(ptr, d->encData, d->encDataSize); + return ptr; +} + +inline int sizeof_TPM_STORED_DATA(const TPM_STORED_DATA* d) { + int rv = sizeof_TPM_VERSION(&d->ver) + sizeof_UINT32(d->sealInfoSize); + if (d->sealInfoSize) { + rv += sizeof_TPM_PCR_INFO(&d->sealInfo); + } + rv += sizeof_UINT32(d->encDataSize); + rv += sizeof_BUFFER(d->encData, d->encDataSize); + return rv; +} + +inline int unpack3_TPM_STORED_DATA(BYTE* ptr, UINT32* pos, UINT32 len, TPM_STORED_DATA* d, UnpackPtr alloc) { + int rc = unpack3_TPM_VERSION(ptr, pos, len, &d->ver) || + unpack3_UINT32(ptr, pos, len, &d->sealInfoSize); + if (rc) + return rc; + if (d->sealInfoSize) + rc = unpack3_TPM_PCR_INFO(ptr, pos, len, &d->sealInfo, alloc); + if (rc) + return rc; + rc = unpack3_UINT32(ptr, pos, len, &d->encDataSize) || + unpack3_PTR(ptr, pos, len, &d->encData, d->encDataSize, alloc); + return rc; } inline BYTE* pack_TPM_AUTH_SESSION(BYTE* ptr, const TPM_AUTH_SESSION* auth) { - ptr = pack_TPM_AUTH_HANDLE(ptr, auth->AuthHandle); - ptr = pack_TPM_NONCE(ptr, &auth->NonceOdd); - ptr = pack_BOOL(ptr, auth->fContinueAuthSession); - ptr = pack_TPM_AUTHDATA(ptr, &auth->HMAC); - return ptr; + ptr = pack_TPM_AUTH_HANDLE(ptr, auth->AuthHandle); + ptr = pack_TPM_NONCE(ptr, &auth->NonceOdd); + ptr = pack_BOOL(ptr, auth->fContinueAuthSession); + ptr = pack_TPM_AUTHDATA(ptr, &auth->HMAC); + return ptr; } inline BYTE* unpack_TPM_AUTH_SESSION(BYTE* ptr, TPM_AUTH_SESSION* auth) { - ptr = unpack_TPM_NONCE(ptr, &auth->NonceEven); - ptr = unpack_BOOL(ptr, &auth->fContinueAuthSession); - ptr = unpack_TPM_AUTHDATA(ptr, &auth->HMAC); - return ptr; + ptr = unpack_TPM_NONCE(ptr, &auth->NonceEven); + ptr = unpack_BOOL(ptr, &auth->fContinueAuthSession); + ptr = unpack_TPM_AUTHDATA(ptr, &auth->HMAC); + return ptr; } -inline BYTE* pack_TPM_RQU_HEADER(BYTE* ptr, - TPM_TAG tag, - UINT32 size, - TPM_COMMAND_CODE ord) { - ptr = pack_UINT16(ptr, tag); - ptr = pack_UINT32(ptr, size); - return pack_UINT32(ptr, ord); +inline int unpack3_TPM_AUTH_SESSION(BYTE* ptr, UINT32* pos, UINT32 len, TPM_AUTH_SESSION* auth) { + return unpack3_TPM_NONCE(ptr, pos, len, &auth->NonceEven) || + unpack3_BOOL(ptr, pos, len, &auth->fContinueAuthSession) || + unpack3_TPM_AUTHDATA(ptr, pos, len, &auth->HMAC); } -inline BYTE* unpack_TPM_RQU_HEADER(BYTE* ptr, - TPM_TAG* tag, - UINT32* size, - TPM_COMMAND_CODE* ord) { - ptr = unpack_UINT16(ptr, tag); - ptr = unpack_UINT32(ptr, size); - ptr = unpack_UINT32(ptr, ord); - return ptr; + +inline int sizeof_TPM_AUTH_SESSION(const TPM_AUTH_SESSION* auth) { + int rv = 0; + rv += sizeof_TPM_AUTH_HANDLE(auth->AuthHandle); + rv += sizeof_TPM_NONCE(&auth->NonceOdd); + rv += sizeof_BOOL(auth->fContinueAuthSession); + rv += sizeof_TPM_AUTHDATA(&auth->HMAC); + return rv; } -#define pack_TPM_RSP_HEADER(p, t, s, r) pack_TPM_RQU_HEADER(p, t, s, r); -#define unpack_TPM_RSP_HEADER(p, t, s, r) unpack_TPM_RQU_HEADER(p, t, s, r); +inline BYTE* pack_TPM_RQU_HEADER(BYTE* ptr, + TPM_TAG tag, + UINT32 size, + TPM_COMMAND_CODE ord) { + ptr = pack_UINT16(ptr, tag); + ptr = pack_UINT32(ptr, size); + return pack_UINT32(ptr, ord); +} + +inline BYTE* unpack_TPM_RQU_HEADER(BYTE* ptr, + TPM_TAG* tag, + UINT32* size, + TPM_COMMAND_CODE* ord) { + ptr = unpack_UINT16(ptr, tag); + ptr = unpack_UINT32(ptr, size); + ptr = unpack_UINT32(ptr, ord); + return ptr; +} + +inline int unpack3_TPM_RQU_HEADER(BYTE* ptr, UINT32* pos, UINT32 max, + TPM_TAG* tag, UINT32* size, TPM_COMMAND_CODE* ord) { + return + unpack3_UINT16(ptr, pos, max, tag) || + unpack3_UINT32(ptr, pos, max, size) || + unpack3_UINT32(ptr, pos, max, ord); +} + +#define pack_TPM_RSP_HEADER(p, t, s, r) pack_TPM_RQU_HEADER(p, t, s, r) +#define unpack_TPM_RSP_HEADER(p, t, s, r) unpack_TPM_RQU_HEADER(p, t, s, r) +#define unpack3_TPM_RSP_HEADER(p, l, m, t, s, r) unpack3_TPM_RQU_HEADER(p, l, m, t, s, r) #endif diff --git a/stubdom/vtpmmgr/mgmt_authority.c b/stubdom/vtpmmgr/mgmt_authority.c new file mode 100644 index 0000000..0526a12 --- /dev/null +++ b/stubdom/vtpmmgr/mgmt_authority.c @@ -0,0 +1,323 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "vtpm_manager.h" +#include "log.h" +#include "uuid.h" + +#include "tpm.h" +#include "tcg.h" +#include "marshal.h" +#include "vtpmmgr.h" +#include "vtpm_disk.h" +#include "disk_tpm.h" +#include "disk_io.h" +#include "disk_crypto.h" +#include "disk_format.h" +#include "mgmt_authority.h" + +static int do_provision_aik(struct mem_group *group, + const struct tpm_authdata *privCADigest) +{ + TPM_KEY kinfo = { + .ver = TPM_STRUCT_VER_1_1, + .keyUsage = TPM_KEY_IDENTITY, + .keyFlags = 0, + .authDataUsage = TPM_AUTH_ALWAYS, + .algorithmParms = { + .algorithmID = TPM_ALG_RSA, + .encScheme = TPM_ES_NONE, + .sigScheme = TPM_SS_RSASSAPKCS1v15_SHA1, + .parmSize = 12, + .parms.rsa = { + .keyLength = RSA_KEY_SIZE, + .numPrimes = 2, + .exponentSize = 0, + .exponent = NULL, + }, + }, + .PCRInfoSize = 0, + .pubKey.keyLength = 0, + .encDataSize = 0, + }; + + TPM_AUTH_SESSION srkAuth = TPM_AUTH_SESSION_INIT; + TPM_AUTH_SESSION ownAuth = TPM_AUTH_SESSION_INIT; + TPM_SECRET osapMask; + + TPM_KEY key = TPM_KEY_INIT; + UINT32 identityBindingSize; + BYTE* identityBinding = NULL; + + TPM_RESULT rc; + + rc = TPM_OSAP(TPM_ET_OWNER, 0, (void*)&vtpm_globals.owner_auth, &osapMask, &ownAuth); + if (rc) + return rc; + + rc = TPM_OIAP(&srkAuth); + if (rc) + return rc; + + rc = TPM_MakeIdentity((void*)&group->aik_authdata, (void*)privCADigest, &kinfo, + (void*)&vtpm_globals.srk_auth, (void*)&osapMask, &srkAuth, &ownAuth, + &key, &identityBindingSize, &identityBinding); + + TPM_TerminateHandle(srkAuth.AuthHandle); + TPM_TerminateHandle(ownAuth.AuthHandle); + + if (rc) { + printk("TPM_MakeIdentity failed: %d\n", rc); + return rc; + } + + if (key.pubKey.keyLength != 256) + rc = TPM_FAIL; + if (key.encDataSize != 256) + rc = TPM_FAIL; + if (identityBindingSize != 256) + rc = TPM_FAIL; + if (rc) { + printk("TPM_MakeIdentity TPM_KEY mismatch: %d %d %d\n", + key.pubKey.keyLength, key.encDataSize, identityBindingSize); + } else { + memcpy(group->id_data.tpm_aik_public, key.pubKey.key, 256); + memcpy(group->id_data.tpm_aik_edata, key.encData, 256); + memcpy(group->details.recovery_data, identityBinding, 256); + } + + free_TPM_KEY(&key); + free(identityBinding); + + return rc; +} + +static int do_load_aik(struct mem_group *group, TPM_HANDLE *handle) +{ + TPM_KEY key = { + .ver = TPM_STRUCT_VER_1_1, + .keyUsage = TPM_KEY_IDENTITY, + .keyFlags = 0, + .authDataUsage = TPM_AUTH_ALWAYS, + .algorithmParms = { + .algorithmID = TPM_ALG_RSA, + .encScheme = TPM_ES_NONE, + .sigScheme = TPM_SS_RSASSAPKCS1v15_SHA1, + .parmSize = 12, + .parms.rsa = { + .keyLength = RSA_KEY_SIZE, + .numPrimes = 2, + .exponentSize = 0, + .exponent = NULL, + }, + }, + .PCRInfoSize = 0, + .pubKey.keyLength = 256, + .pubKey.key = group->id_data.tpm_aik_public, + .encDataSize = 256, + .encData = group->id_data.tpm_aik_edata, + }; + + return TPM_LoadKey(TPM_SRK_KEYHANDLE, &key, handle, (void*)&vtpm_globals.srk_auth, &vtpm_globals.oiap); +} + +/* + * Sets up resettable PCRs for a vTPM deep quote request + */ +static int do_pcr_setup(struct mem_group *group, const void* uuid, const uint8_t* kern_hash) +{ + uint32_t reset_sel = (1 << 20) | (1 << 21) | (1 << 22) | (1 << 23); + sha1_context ctx; + TPM_DIGEST extended; + TPM_PCR_SELECTION sel = { + .sizeOfSelect = 3, + .pcrSelect = (void*)&reset_sel, + }; + int rc; + int i; + + rc = TPM_Reset(&sel); + if (rc) + return rc; + + sha1((void*)&group->id_data.saa_pubkey, sizeof(group->id_data.saa_pubkey), extended.digest); + rc = TPM_Extend(20, &extended, &extended); + if (rc) + return rc; + + sha1_starts(&ctx); + sha1_update(&ctx, (void*)&group->details.cfg_seq, 8); + sha1_update(&ctx, (void*)&group->seal_bits.nr_cfgs, 4); + for(i=0; i < group->nr_seals; i++) + sha1_update(&ctx, (void*)&group->seals[i].digest_release, 20); + sha1_update(&ctx, (void*)&group->seal_bits.nr_kerns, 4); + sha1_update(&ctx, (void*)&group->seal_bits.kernels, 20 * be32_native(group->seal_bits.nr_kerns)); + sha1_finish(&ctx, extended.digest); + rc = TPM_Extend(21, &extended, &extended); + if (rc) + return rc; + + if (kern_hash) { + rc = TPM_Extend(22, (void*)kern_hash, &extended); + if (rc) + return rc; + } + + memset(&extended, 0, 20); + memcpy(&extended, group->id_data.uuid, 16); + rc = TPM_Extend(23, &extended, &extended); + if (rc) + return rc; + + if (uuid) { + memset(&extended, 0, 20); + memcpy(&extended, uuid, 16); + rc = TPM_Extend(23, &extended, &extended); + if (rc) + return rc; + } + + return rc; +} + +struct mem_group *vtpm_new_group(const struct tpm_authdata *privCADigest) +{ + static struct mem_group* group0_delayed = NULL; + struct mem_group *group; + + if (group0_delayed) { + group = group0_delayed; + group0_delayed = NULL; + } else { + group = calloc(1, sizeof(*group)); + + group->flags = MEM_GROUP_FLAG_FIRSTBOOT; + + do_random(&group->id_data.uuid, 16); + do_random(&group->group_key, 16); + do_random(&group->rollback_mac_key, 16); + do_random(&group->aik_authdata, 20); + + group->id_data.uuid[6] = 0x40 | (group->id_data.uuid[6] & 0x0F); + group->id_data.uuid[8] = 0x80 | (group->id_data.uuid[8] & 0x3F); + } + + if (privCADigest) { + int rc; + rc = do_provision_aik(group, privCADigest); + if (rc) { + free(group); + return NULL; + } + } else { + group0_delayed = group; + } + + return group; +} + +int group_do_activate(struct mem_group *group, void* blob, int blobSize, + void* resp, unsigned int *rlen) +{ + int rc; + TPM_HANDLE handle; + TPM_AUTH_SESSION aikAuth = TPM_AUTH_SESSION_INIT; + TPM_AUTH_SESSION ownAuth = TPM_AUTH_SESSION_INIT; + TPM_SYMMETRIC_KEY symKey; + + /* ActivateIdentity with TPM_EK_BLOB_ACTIVATE can check PCRs */ + rc = do_pcr_setup(group, NULL, NULL); + if (rc) + return rc; + + rc = do_load_aik(group, &handle); + if (rc) + return rc; + + rc = TPM_OIAP(&aikAuth); + if (rc) { + TPM_TerminateHandle(handle); + return rc; + } + + rc = TPM_OIAP(&ownAuth); + if (rc) { + TPM_TerminateHandle(aikAuth.AuthHandle); + TPM_TerminateHandle(handle); + return rc; + } + + rc = TPM_ActivateIdentity(handle, blob, blobSize, (void*)&group->aik_authdata, + (void*)&vtpm_globals.owner_auth, &aikAuth, &ownAuth, &symKey); + + TPM_TerminateHandle(ownAuth.AuthHandle); + TPM_TerminateHandle(aikAuth.AuthHandle); + TPM_TerminateHandle(handle); + + if (rc) + return rc; + + pack_TPM_SYMMETRIC_KEY(resp + *rlen, &symKey); + *rlen += 8 + symKey.size; + free(symKey.data); + + return rc; +} + +int vtpm_do_quote(struct mem_group *group, const uuid_t uuid, + const uint8_t* kern_hash, const struct tpm_authdata *data, TPM_PCR_SELECTION *sel, + void* pcr_out, uint32_t *pcr_size, void* sig_out) +{ + TPM_HANDLE handle; + TPM_AUTH_SESSION oiap = TPM_AUTH_SESSION_INIT; + TPM_PCR_COMPOSITE pcrs; + BYTE* sig; + UINT32 size; + int rc; + + rc = do_pcr_setup(group, uuid, kern_hash); + if (rc) + return rc; + + rc = do_load_aik(group, &handle); + if (rc) + return rc; + + rc = TPM_OIAP(&oiap); + if (rc) { + TPM_TerminateHandle(handle); + return rc; + } + + rc = TPM_Quote(handle, (void*)data, sel, (void*)&group->aik_authdata, &oiap, &pcrs, &sig, &size); + printk("TPM_Quote: %d\n", rc); + + TPM_TerminateHandle(oiap.AuthHandle); + TPM_FlushSpecific(handle, TPM_RT_KEY); + + if (rc) + return rc; + if (size != 256) { + printk("Bad size\n"); + return TPM_FAIL; + } + + if (pcr_out) { + *pcr_size = pcrs.valueSize; + memcpy(pcr_out, pcrs.pcrValue, *pcr_size); + } + + memcpy(sig_out, sig, size); + + free_TPM_PCR_COMPOSITE(&pcrs); + free(sig); + + return rc; +} diff --git a/stubdom/vtpmmgr/mgmt_authority.h b/stubdom/vtpmmgr/mgmt_authority.h new file mode 100644 index 0000000..1e96c8a --- /dev/null +++ b/stubdom/vtpmmgr/mgmt_authority.h @@ -0,0 +1,11 @@ +#ifndef __VTPMMGR_MGMT_AUTHORITY_H +#define __VTPMMGR_MGMT_AUTHORITY_H + +struct mem_group *vtpm_new_group(const struct tpm_authdata *privCADigest); +int group_do_activate(struct mem_group *group, void* blob, int blobSize, + void* resp, unsigned int *rlen); +int vtpm_do_quote(struct mem_group *group, const uuid_t uuid, + const uint8_t* kern_hash, const struct tpm_authdata *data, TPM_PCR_SELECTION *sel, + void* pcr_out, uint32_t *pcr_size, void* sig_out); + +#endif diff --git a/stubdom/vtpmmgr/tcg.h b/stubdom/vtpmmgr/tcg.h index 7687eae..f4c8bc0 100644 --- a/stubdom/vtpmmgr/tcg.h +++ b/stubdom/vtpmmgr/tcg.h @@ -490,6 +490,13 @@ typedef struct TPM_SYMMETRIC_KEY_PARMS { BYTE* IV; } TPM_SYMMETRIC_KEY_PARMS; +typedef struct TPM_SYMMETRIC_KEY { + UINT32 algId; + UINT16 encScheme; + UINT16 size; + BYTE* data; +} TPM_SYMMETRIC_KEY; + inline void free_TPM_SYMMETRIC_KEY_PARMS(TPM_SYMMETRIC_KEY_PARMS* p) { free(p->IV); p->IV = NULL; diff --git a/stubdom/vtpmmgr/tpm.c b/stubdom/vtpmmgr/tpm.c index 123a27c..0548e5c 100644 --- a/stubdom/vtpmmgr/tpm.c +++ b/stubdom/vtpmmgr/tpm.c @@ -51,173 +51,247 @@ #define TCPA_MAX_BUFFER_LENGTH 0x2000 -#define TPM_BEGIN(TAG, ORD) \ - const TPM_TAG intag = TAG;\ -TPM_TAG tag = intag;\ -UINT32 paramSize;\ -const TPM_COMMAND_CODE ordinal = ORD;\ -TPM_RESULT status = TPM_SUCCESS;\ -BYTE in_buf[TCPA_MAX_BUFFER_LENGTH];\ -BYTE out_buf[TCPA_MAX_BUFFER_LENGTH];\ -UINT32 out_len = sizeof(out_buf);\ -BYTE* ptr = in_buf;\ -/*Print a log message */\ -vtpmloginfo(VTPM_LOG_TPM, "%s\n", __func__);\ -/* Pack the header*/\ -ptr = pack_TPM_TAG(ptr, tag);\ -ptr += sizeof(UINT32);\ -ptr = pack_TPM_COMMAND_CODE(ptr, ordinal)\ - -#define TPM_AUTH_BEGIN() \ - sha1_context sha1_ctx;\ -BYTE* authbase = ptr - sizeof(TPM_COMMAND_CODE);\ -TPM_DIGEST paramDigest;\ -sha1_starts(&sha1_ctx) - -#define TPM_AUTH1_GEN(HMACkey, auth) do {\ - sha1_finish(&sha1_ctx, paramDigest.digest);\ - generateAuth(¶mDigest, HMACkey, auth);\ - ptr = pack_TPM_AUTH_SESSION(ptr, auth);\ -} while(0) - -#define TPM_AUTH2_GEN(HMACkey, auth) do {\ - generateAuth(¶mDigest, HMACkey, auth);\ - ptr = pack_TPM_AUTH_SESSION(ptr, auth);\ -} while(0) - -#define TPM_TRANSMIT() do {\ - /* Pack the command size */\ - paramSize = ptr - in_buf;\ - pack_UINT32(in_buf + sizeof(TPM_TAG), paramSize);\ - if((status = TPM_TransmitData(in_buf, paramSize, out_buf, &out_len)) != TPM_SUCCESS) {\ - goto abort_egress;\ - }\ -} while(0) - -#define TPM_AUTH_VERIFY_BEGIN() do {\ - UINT32 buf[2] = { cpu_to_be32(status), cpu_to_be32(ordinal) };\ - sha1_starts(&sha1_ctx);\ - sha1_update(&sha1_ctx, (unsigned char*)buf, sizeof(buf));\ - authbase = ptr;\ -} while(0) - -#define TPM_AUTH1_VERIFY(HMACkey, auth) do {\ - sha1_finish(&sha1_ctx, paramDigest.digest);\ - ptr = unpack_TPM_AUTH_SESSION(ptr, auth);\ - if((status = verifyAuth(¶mDigest, HMACkey, auth)) != TPM_SUCCESS) {\ - goto abort_egress;\ - }\ -} while(0) - -#define TPM_AUTH2_VERIFY(HMACkey, auth) do {\ - ptr = unpack_TPM_AUTH_SESSION(ptr, auth);\ - if((status = verifyAuth(¶mDigest, HMACkey, auth)) != TPM_SUCCESS) {\ - goto abort_egress;\ - }\ -} while(0) - - - -#define TPM_UNPACK_VERIFY() do { \ - ptr = out_buf;\ - ptr = unpack_TPM_RSP_HEADER(ptr, \ - &(tag), &(paramSize), &(status));\ - if((status) != TPM_SUCCESS || (tag) != (intag +3)) { \ - vtpmlogerror(VTPM_LOG_TPM, "Failed with return code %s\n", tpm_get_error_name(status));\ - goto abort_egress;\ - }\ -} while(0) - -#define TPM_AUTH_HASH() do {\ - sha1_update(&sha1_ctx, authbase, ptr - authbase);\ - authbase = ptr;\ -} while(0) - -#define TPM_AUTH_SKIP() do {\ - authbase = ptr;\ -} while(0) +#define TPM_BEGIN_CMD(ord) \ + const TPM_COMMAND_CODE ordinal = ord; \ + TPM_RESULT status = TPM_SUCCESS; \ + BYTE _io_buffer[TCPA_MAX_BUFFER_LENGTH]; \ + UINT32 _io_bufsize_in; \ + UINT32 _io_bufsize_out; \ + vtpmloginfo(VTPM_LOG_TPM, "%s\n", __func__); \ + do { \ + BYTE *in_buf = _io_buffer; \ + UINT32 in_pos = 6; \ + PACK_IN(UINT32, ordinal); + +#define IN_PTR (in_buf + in_pos) + +#define PACK_IN(type, item...) do { \ + UINT32 isize = sizeof_ ## type(item); \ + if (isize + in_pos > TCPA_MAX_BUFFER_LENGTH) { \ + status = TPM_SIZE; \ + goto abort_egress; \ + } \ + pack_ ## type (IN_PTR, item); \ + in_pos += isize; \ +} while (0) + +#define TPM_HASH_IN_BEGIN \ + sha1_context sha1_ctx; \ + sha1_starts(&sha1_ctx); \ + sha1_update(&sha1_ctx, in_buf + 6, 4); \ + TPM_HASH_IN_START + +#define TPM_HASH_IN_START \ + do { \ + UINT32 _hash_in_start = in_pos; + +#define TPM_HASH_IN_STOP \ + sha1_update(&sha1_ctx, in_buf + _hash_in_start, in_pos - _hash_in_start); \ + } while (0) + +#define TPM_TAG_COMMON(req_tag) \ + _io_bufsize_in = in_pos; \ + pack_TPM_TAG(in_buf, req_tag); \ + pack_UINT32(in_buf + sizeof(TPM_TAG), in_pos); \ + } while (0); \ + _io_bufsize_out = TCPA_MAX_BUFFER_LENGTH; \ + status = TPM_TransmitData(_io_buffer, _io_bufsize_in, _io_buffer, &_io_bufsize_out); \ + if (status != TPM_SUCCESS) { \ + goto abort_egress; \ + } \ + do { \ + BYTE *out_buf = _io_buffer; \ + UINT32 out_pos = 0; \ + UINT32 out_len = _io_bufsize_out; \ + do { \ + TPM_TAG rsp_tag; \ + UINT32 rsp_len; \ + UINT32 rsp_status; \ + UNPACK_OUT(TPM_RSP_HEADER, &rsp_tag, &rsp_len, &rsp_status); \ + if (rsp_status != TPM_SUCCESS) { \ + vtpmlogerror(VTPM_LOG_TPM, "Failed with return code %s\n", tpm_get_error_name(rsp_status)); \ + status = rsp_status; \ + goto abort_egress; \ + } \ + if (rsp_tag != req_tag + 3 || rsp_len != out_len) { \ + status = TPM_FAIL; \ + goto abort_egress; \ + } \ + } while(0) + +#define OUT_PTR (out_buf + out_pos) + +#define UNPACK_OUT(type, item...) do { \ + if (unpack3_ ## type (out_buf, &out_pos, TCPA_MAX_BUFFER_LENGTH, item)) { \ + status = TPM_SIZE; \ + goto abort_egress; \ + } \ +} while (0) + +#define TPM_XMIT_REQ() \ + TPM_TAG_COMMON(TPM_TAG_RQU_COMMAND) + +#define TPM_XMIT_AUTH1(sec1, auth1) \ + TPM_HASH_IN_STOP; \ + do { \ + TPM_DIGEST paramDigest; \ + sha1_finish(&sha1_ctx, paramDigest.digest); \ + generateAuth(¶mDigest, sec1, auth1); \ + PACK_IN(TPM_AUTH_SESSION, auth1); \ + } while (0); \ + TPM_TAG_COMMON(TPM_TAG_RQU_AUTH1_COMMAND); \ + TPM_HASH_OUT_BEGIN + +#define TPM_XMIT_AUTH2(sec1, auth1, sec2, auth2) \ + TPM_HASH_IN_STOP; \ + do { \ + TPM_DIGEST paramDigest; \ + sha1_finish(&sha1_ctx, paramDigest.digest); \ + generateAuth(¶mDigest, sec1, auth1); \ + PACK_IN(TPM_AUTH_SESSION, auth1); \ + generateAuth(¶mDigest, sec2, auth2); \ + PACK_IN(TPM_AUTH_SESSION, auth2); \ + } while (0); \ + TPM_TAG_COMMON(TPM_TAG_RQU_AUTH2_COMMAND); \ + TPM_HASH_OUT_BEGIN + +#define TPM_HASH_OUT_BEGIN \ + sha1_context sha1_ctx; \ + sha1_starts(&sha1_ctx); \ + do { \ + UINT32 buf[2] = { cpu_to_be32(status), cpu_to_be32(ordinal) }; \ + sha1_update(&sha1_ctx, (BYTE*)buf, sizeof(buf)); \ + } while(0); \ + TPM_HASH_OUT_START + +#define TPM_HASH_OUT_START \ + do { \ + UINT32 _hash_out_start = out_pos; + +#define TPM_HASH_OUT_STOP \ + sha1_update(&sha1_ctx, out_buf + _hash_out_start, out_pos - _hash_out_start); \ + } while (0) + +#define TPM_END_AUTH1(sec1, auth1) \ + TPM_HASH_OUT_STOP; \ + do { \ + TPM_DIGEST paramDigest; \ + sha1_finish(&sha1_ctx, paramDigest.digest); \ + UNPACK_OUT(TPM_AUTH_SESSION, auth1); \ + status = verifyAuth(¶mDigest, sec1, auth1); \ + if (status != TPM_SUCCESS) \ + goto abort_egress; \ + } while(0); \ + TPM_END_COMMON + +#define TPM_END_AUTH2(sec1, auth1, sec2, auth2) \ + TPM_HASH_OUT_STOP; \ + do { \ + TPM_DIGEST paramDigest; \ + sha1_finish(&sha1_ctx, paramDigest.digest); \ + UNPACK_OUT(TPM_AUTH_SESSION, auth1); \ + status = verifyAuth(¶mDigest, sec1, auth1); \ + if (status != TPM_SUCCESS) \ + goto abort_egress; \ + UNPACK_OUT(TPM_AUTH_SESSION, auth2); \ + status = verifyAuth(¶mDigest, sec2, auth2); \ + if (status != TPM_SUCCESS) \ + goto abort_egress; \ + } while(0); \ + TPM_END_COMMON + +#define TPM_END() TPM_END_COMMON + +#define TPM_END_COMMON \ + if (out_pos != out_len) { \ + vtpmloginfo(VTPM_LOG_TPM, "Response too long (%d != %d)", out_pos, out_len);\ + status = TPM_SIZE; \ + goto abort_egress; \ + } \ + } while (0); \ #define TPM_AUTH_ERR_CHECK(auth) do {\ - if(status != TPM_SUCCESS || auth->fContinueAuthSession == FALSE) {\ - vtpmloginfo(VTPM_LOG_TPM, "Auth Session: 0x%x closed by TPM\n", auth->AuthHandle);\ - auth->AuthHandle = 0;\ - }\ + if(status != TPM_SUCCESS || auth->fContinueAuthSession == FALSE) {\ + vtpmloginfo(VTPM_LOG_TPM, "Auth Session: 0x%x closed by TPM\n", auth->AuthHandle);\ + auth->AuthHandle = 0;\ + }\ } while(0) static void xorEncrypt(const TPM_SECRET* sharedSecret, - TPM_NONCE* nonce, - const TPM_AUTHDATA* inAuth0, - TPM_ENCAUTH outAuth0, - const TPM_AUTHDATA* inAuth1, - TPM_ENCAUTH outAuth1) { - BYTE XORbuffer[sizeof(TPM_SECRET) + sizeof(TPM_NONCE)]; - BYTE XORkey[TPM_DIGEST_SIZE]; - BYTE* ptr = XORbuffer; - ptr = pack_TPM_SECRET(ptr, sharedSecret); - ptr = pack_TPM_NONCE(ptr, nonce); - - sha1(XORbuffer, ptr - XORbuffer, XORkey); - - if(inAuth0) { - for(int i = 0; i < TPM_DIGEST_SIZE; ++i) { - outAuth0[i] = XORkey[i] ^ (*inAuth0)[i]; - } - } - if(inAuth1) { - for(int i = 0; i < TPM_DIGEST_SIZE; ++i) { - outAuth1[i] = XORkey[i] ^ (*inAuth1)[i]; - } - } + TPM_NONCE* nonce, + const TPM_AUTHDATA* inAuth0, + TPM_ENCAUTH outAuth0, + const TPM_AUTHDATA* inAuth1, + TPM_ENCAUTH outAuth1) { + BYTE XORbuffer[sizeof(TPM_SECRET) + sizeof(TPM_NONCE)]; + BYTE XORkey[TPM_DIGEST_SIZE]; + BYTE* ptr = XORbuffer; + ptr = pack_TPM_SECRET(ptr, sharedSecret); + ptr = pack_TPM_NONCE(ptr, nonce); + + sha1(XORbuffer, ptr - XORbuffer, XORkey); + + if(inAuth0) { + for(int i = 0; i < TPM_DIGEST_SIZE; ++i) { + outAuth0[i] = XORkey[i] ^ (*inAuth0)[i]; + } + } + if(inAuth1) { + for(int i = 0; i < TPM_DIGEST_SIZE; ++i) { + outAuth1[i] = XORkey[i] ^ (*inAuth1)[i]; + } + } } static void generateAuth(const TPM_DIGEST* paramDigest, - const TPM_SECRET* HMACkey, - TPM_AUTH_SESSION *auth) + const TPM_SECRET* HMACkey, + TPM_AUTH_SESSION *auth) { - //Generate new OddNonce - vtpmmgr_rand((BYTE*)auth->NonceOdd.nonce, sizeof(TPM_NONCE)); + //Generate new OddNonce + vtpmmgr_rand((BYTE*)auth->NonceOdd.nonce, sizeof(TPM_NONCE)); - // Create HMAC text. (Concat inParamsDigest with inAuthSetupParams). - BYTE hmacText[sizeof(TPM_DIGEST) + (2 * sizeof(TPM_NONCE)) + sizeof(BOOL)]; - BYTE* ptr = hmacText; + // Create HMAC text. (Concat inParamsDigest with inAuthSetupParams). + BYTE hmacText[sizeof(TPM_DIGEST) + (2 * sizeof(TPM_NONCE)) + sizeof(BOOL)]; + BYTE* ptr = hmacText; - ptr = pack_TPM_DIGEST(ptr, paramDigest); - ptr = pack_TPM_NONCE(ptr, &auth->NonceEven); - ptr = pack_TPM_NONCE(ptr, &auth->NonceOdd); - ptr = pack_BOOL(ptr, auth->fContinueAuthSession); + ptr = pack_TPM_DIGEST(ptr, paramDigest); + ptr = pack_TPM_NONCE(ptr, &auth->NonceEven); + ptr = pack_TPM_NONCE(ptr, &auth->NonceOdd); + ptr = pack_BOOL(ptr, auth->fContinueAuthSession); - sha1_hmac((BYTE *) HMACkey, sizeof(TPM_DIGEST), - (BYTE *) hmacText, sizeof(hmacText), - auth->HMAC); + sha1_hmac((BYTE *) HMACkey, sizeof(TPM_DIGEST), + (BYTE *) hmacText, sizeof(hmacText), + auth->HMAC); } static TPM_RESULT verifyAuth(const TPM_DIGEST* paramDigest, - /*[IN]*/ const TPM_SECRET *HMACkey, - /*[IN,OUT]*/ TPM_AUTH_SESSION *auth) + /*[IN]*/ const TPM_SECRET *HMACkey, + /*[IN,OUT]*/ TPM_AUTH_SESSION *auth) { - // Create HMAC text. (Concat inParamsDigest with inAuthSetupParams). - TPM_AUTHDATA hm; - BYTE hmacText[sizeof(TPM_DIGEST) + (2 * sizeof(TPM_NONCE)) + sizeof(BOOL)]; - BYTE* ptr = hmacText; - - ptr = pack_TPM_DIGEST(ptr, paramDigest); - ptr = pack_TPM_NONCE(ptr, &auth->NonceEven); - ptr = pack_TPM_NONCE(ptr, &auth->NonceOdd); - ptr = pack_BOOL(ptr, auth->fContinueAuthSession); - - sha1_hmac( (BYTE *) HMACkey, sizeof(TPM_DIGEST), - (BYTE *) hmacText, sizeof(hmacText), - hm); - - // Compare correct HMAC with provided one. - if (memcmp(hm, auth->HMAC, sizeof(TPM_DIGEST)) == 0) { // 0 indicates equality - return TPM_SUCCESS; - } else { - vtpmlogerror(VTPM_LOG_TPM, "Auth Session verification failed!\n"); - return TPM_AUTHFAIL; - } + // Create HMAC text. (Concat inParamsDigest with inAuthSetupParams). + TPM_AUTHDATA hm; + BYTE hmacText[sizeof(TPM_DIGEST) + (2 * sizeof(TPM_NONCE)) + sizeof(BOOL)]; + BYTE* ptr = hmacText; + + ptr = pack_TPM_DIGEST(ptr, paramDigest); + ptr = pack_TPM_NONCE(ptr, &auth->NonceEven); + ptr = pack_TPM_NONCE(ptr, &auth->NonceOdd); + ptr = pack_BOOL(ptr, auth->fContinueAuthSession); + + sha1_hmac( (BYTE *) HMACkey, sizeof(TPM_DIGEST), + (BYTE *) hmacText, sizeof(hmacText), + hm); + + // Compare correct HMAC with provided one. + if (memcmp(hm, auth->HMAC, sizeof(TPM_DIGEST)) == 0) { // 0 indicates equality + return TPM_SUCCESS; + } else { + vtpmlogerror(VTPM_LOG_TPM, "Auth Session verification failed! %x %x\n", + *(UINT32*)auth->HMAC, *(UINT32*)hm); + return TPM_AUTHFAIL; + } } @@ -226,713 +300,603 @@ static TPM_RESULT verifyAuth(const TPM_DIGEST* paramDigest, // Authorization Commands // ------------------------------------------------------------------ -TPM_RESULT TPM_OIAP(TPM_AUTH_SESSION* auth) // out +TPM_RESULT TPM_OIAP(TPM_AUTH_SESSION* auth) // out { - TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_OIAP); + TPM_BEGIN_CMD(TPM_ORD_OIAP); - TPM_TRANSMIT(); - TPM_UNPACK_VERIFY(); + TPM_XMIT_REQ(); - memset(&auth->HMAC, 0, sizeof(TPM_DIGEST)); - auth->fContinueAuthSession = TRUE; + memset(&auth->HMAC, 0, sizeof(TPM_DIGEST)); + auth->fContinueAuthSession = TRUE; - ptr = unpack_UINT32(ptr, &auth->AuthHandle); - ptr = unpack_TPM_NONCE(ptr, &auth->NonceEven); + UNPACK_OUT(UINT32, &auth->AuthHandle); + UNPACK_OUT(TPM_NONCE, &auth->NonceEven); + TPM_END(); - vtpmloginfo(VTPM_LOG_TPM, "Auth Session: 0x%x opened by TPM_OIAP.\n", auth->AuthHandle); + vtpmloginfo(VTPM_LOG_TPM, "Auth Session: 0x%x opened by TPM_OIAP.\n", auth->AuthHandle); abort_egress: - return status; + return status; } TPM_RESULT TPM_OSAP(TPM_ENTITY_TYPE entityType, // in - UINT32 entityValue, // in - const TPM_AUTHDATA* usageAuth, //in - TPM_SECRET *sharedSecret, //out - TPM_AUTH_SESSION *auth) + UINT32 entityValue, // in + const TPM_AUTHDATA* usageAuth, //in + TPM_SECRET *sharedSecret, //out + TPM_AUTH_SESSION *auth) { - BYTE* nonceOddOSAP; - TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_OSAP); + TPM_DIGEST nonceOddOSAP; + vtpmmgr_rand(nonceOddOSAP.digest, TPM_DIGEST_SIZE); + TPM_BEGIN_CMD(TPM_ORD_OSAP); - ptr = pack_TPM_ENTITY_TYPE(ptr, entityType); - ptr = pack_UINT32(ptr, entityValue); + PACK_IN(TPM_ENTITY_TYPE, entityType); + PACK_IN(UINT32, entityValue); + PACK_IN(TPM_DIGEST, &nonceOddOSAP); - //nonce Odd OSAP - nonceOddOSAP = ptr; - vtpmmgr_rand(ptr, TPM_DIGEST_SIZE); - ptr += TPM_DIGEST_SIZE; + TPM_XMIT_REQ(); - TPM_TRANSMIT(); - TPM_UNPACK_VERIFY(); + UNPACK_OUT(UINT32, &auth->AuthHandle); + UNPACK_OUT(TPM_NONCE, &auth->NonceEven); - ptr = unpack_UINT32(ptr, &auth->AuthHandle); - ptr = unpack_TPM_NONCE(ptr, &auth->NonceEven); + //Calculate session secret + sha1_context ctx; + sha1_hmac_starts(&ctx, *usageAuth, TPM_DIGEST_SIZE); + sha1_hmac_update(&ctx, OUT_PTR, TPM_DIGEST_SIZE); // nonceEvenOSAP + sha1_hmac_update(&ctx, nonceOddOSAP.digest, TPM_DIGEST_SIZE); + sha1_hmac_finish(&ctx, *sharedSecret); - //Calculate session secret - sha1_context ctx; - sha1_hmac_starts(&ctx, *usageAuth, TPM_DIGEST_SIZE); - sha1_hmac_update(&ctx, ptr, TPM_DIGEST_SIZE); //ptr = nonceEvenOSAP - sha1_hmac_update(&ctx, nonceOddOSAP, TPM_DIGEST_SIZE); - sha1_hmac_finish(&ctx, *sharedSecret); + out_pos += TPM_DIGEST_SIZE; + TPM_END(); - memset(&auth->HMAC, 0, sizeof(TPM_DIGEST)); - auth->fContinueAuthSession = FALSE; + memset(&auth->HMAC, 0, sizeof(TPM_DIGEST)); + auth->fContinueAuthSession = FALSE; - vtpmloginfo(VTPM_LOG_TPM, "Auth Session: 0x%x opened by TPM_OSAP.\n", auth->AuthHandle); + vtpmloginfo(VTPM_LOG_TPM, "Auth Session: 0x%x opened by TPM_OSAP.\n", auth->AuthHandle); abort_egress: - return status; + return status; } TPM_RESULT TPM_TakeOwnership( - const TPM_PUBKEY *pubEK, //in - const TPM_AUTHDATA* ownerAuth, //in - const TPM_AUTHDATA* srkAuth, //in - const TPM_KEY* inSrk, //in - TPM_KEY* outSrk, //out, optional - TPM_AUTH_SESSION* auth) // in, out + const TPM_PUBKEY *pubEK, //in + const TPM_AUTHDATA* ownerAuth, //in + const TPM_AUTHDATA* srkAuth, //in + const TPM_KEY* inSrk, //in + TPM_KEY* outSrk, //out, optional + TPM_AUTH_SESSION* auth) // in, out { - int keyAlloced = 0; - tpmrsa_context ek_rsa = TPMRSA_CTX_INIT; - - TPM_BEGIN(TPM_TAG_RQU_AUTH1_COMMAND, TPM_ORD_TakeOwnership); - TPM_AUTH_BEGIN(); - - tpmrsa_set_pubkey(&ek_rsa, - pubEK->pubKey.key, pubEK->pubKey.keyLength, - pubEK->algorithmParms.parms.rsa.exponent, - pubEK->algorithmParms.parms.rsa.exponentSize); - - /* Pack the protocol ID */ - ptr = pack_UINT16(ptr, TPM_PID_OWNER); - - /* Pack the encrypted owner auth */ - ptr = pack_UINT32(ptr, pubEK->algorithmParms.parms.rsa.keyLength / 8); - tpmrsa_pub_encrypt_oaep(&ek_rsa, - ctr_drbg_random, &vtpm_globals.ctr_drbg, - sizeof(TPM_SECRET), - (BYTE*) ownerAuth, - ptr); - ptr += pubEK->algorithmParms.parms.rsa.keyLength / 8; - - /* Pack the encrypted srk auth */ - ptr = pack_UINT32(ptr, pubEK->algorithmParms.parms.rsa.keyLength / 8); - tpmrsa_pub_encrypt_oaep(&ek_rsa, - ctr_drbg_random, &vtpm_globals.ctr_drbg, - sizeof(TPM_SECRET), - (BYTE*) srkAuth, - ptr); - ptr += pubEK->algorithmParms.parms.rsa.keyLength / 8; - - /* Pack the Srk key */ - ptr = pack_TPM_KEY(ptr, inSrk); - - /* Hash everything up to here */ - TPM_AUTH_HASH(); - - /* Generate the authorization */ - TPM_AUTH1_GEN(ownerAuth, auth); - - /* Send the command to the tpm*/ - TPM_TRANSMIT(); - /* Unpack and validate the header */ - TPM_UNPACK_VERIFY(); - TPM_AUTH_VERIFY_BEGIN(); - - if(outSrk != NULL) { - /* If the user wants a copy of the srk we give it to them */ - keyAlloced = 1; - ptr = unpack_TPM_KEY(ptr, outSrk, UNPACK_ALLOC); - } else { - /*otherwise just parse past it */ - TPM_KEY temp; - ptr = unpack_TPM_KEY(ptr, &temp, UNPACK_ALIAS); - } - - /* Hash the output key */ - TPM_AUTH_HASH(); - - /* Verify authorizaton */ - TPM_AUTH1_VERIFY(ownerAuth, auth); - - goto egress; + int keyAlloced = 0; + tpmrsa_context ek_rsa = TPMRSA_CTX_INIT; + + TPM_BEGIN_CMD(TPM_ORD_TakeOwnership); + TPM_HASH_IN_BEGIN; + + tpmrsa_set_pubkey(&ek_rsa, + pubEK->pubKey.key, pubEK->pubKey.keyLength, + pubEK->algorithmParms.parms.rsa.exponent, + pubEK->algorithmParms.parms.rsa.exponentSize); + + /* Pack the protocol ID */ + PACK_IN(UINT16, TPM_PID_OWNER); + + /* Pack the encrypted owner auth */ + PACK_IN(UINT32, pubEK->algorithmParms.parms.rsa.keyLength / 8); + tpmrsa_pub_encrypt_oaep(&ek_rsa, + ctr_drbg_random, &vtpm_globals.ctr_drbg, + sizeof(TPM_SECRET), + (BYTE*) ownerAuth, + IN_PTR); + in_pos += pubEK->algorithmParms.parms.rsa.keyLength / 8; + + /* Pack the encrypted srk auth */ + PACK_IN(UINT32, pubEK->algorithmParms.parms.rsa.keyLength / 8); + tpmrsa_pub_encrypt_oaep(&ek_rsa, + ctr_drbg_random, &vtpm_globals.ctr_drbg, + sizeof(TPM_SECRET), + (BYTE*) srkAuth, + IN_PTR); + in_pos += pubEK->algorithmParms.parms.rsa.keyLength / 8; + + PACK_IN(TPM_KEY, inSrk); + + TPM_XMIT_AUTH1(ownerAuth, auth); + + if (outSrk != NULL) { + /* If the user wants a copy of the srk we give it to them */ + keyAlloced = 1; + UNPACK_OUT(TPM_KEY, outSrk, UNPACK_ALLOC); + } else { + /*otherwise just parse past it */ + TPM_KEY temp; + UNPACK_OUT(TPM_KEY, &temp, UNPACK_ALIAS); + } + + TPM_END_AUTH1(ownerAuth, auth); + + goto egress; abort_egress: - if(keyAlloced) { - free_TPM_KEY(outSrk); - } + if(keyAlloced) { + free_TPM_KEY(outSrk); + } egress: - tpmrsa_free(&ek_rsa); - TPM_AUTH_ERR_CHECK(auth); - return status; + tpmrsa_free(&ek_rsa); + TPM_AUTH_ERR_CHECK(auth); + return status; } TPM_RESULT TPM_DisablePubekRead ( - const TPM_AUTHDATA* ownerAuth, - TPM_AUTH_SESSION* auth) + const TPM_AUTHDATA* ownerAuth, + TPM_AUTH_SESSION* auth) { - TPM_BEGIN(TPM_TAG_RQU_AUTH1_COMMAND, TPM_ORD_DisablePubekRead); - TPM_AUTH_BEGIN(); - - TPM_AUTH_HASH(); + TPM_BEGIN_CMD(TPM_ORD_DisablePubekRead); + TPM_HASH_IN_BEGIN; - TPM_AUTH1_GEN(ownerAuth, auth); - TPM_TRANSMIT(); - TPM_UNPACK_VERIFY(); - TPM_AUTH_VERIFY_BEGIN(); + TPM_XMIT_AUTH1(ownerAuth, auth); - TPM_AUTH1_VERIFY(ownerAuth, auth); + TPM_END_AUTH1(ownerAuth, auth); abort_egress: - TPM_AUTH_ERR_CHECK(auth); - return status; + TPM_AUTH_ERR_CHECK(auth); + return status; } TPM_RESULT TPM_TerminateHandle(TPM_AUTHHANDLE handle) // in { - if(handle == 0) { - return TPM_SUCCESS; - } + if(handle == 0) { + return TPM_SUCCESS; + } - TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_Terminate_Handle); + TPM_BEGIN_CMD(TPM_ORD_Terminate_Handle); - ptr = pack_TPM_AUTHHANDLE(ptr, handle); + PACK_IN(TPM_AUTHHANDLE, handle); - TPM_TRANSMIT(); - TPM_UNPACK_VERIFY(); + TPM_XMIT_REQ(); + TPM_END(); - vtpmloginfo(VTPM_LOG_TPM, "Auth Session: 0x%x closed by TPM_TerminateHandle\n", handle); + vtpmloginfo(VTPM_LOG_TPM, "Auth Session: 0x%x closed by TPM_TerminateHandle\n", handle); abort_egress: - return status; + return status; } TPM_RESULT TPM_Extend( TPM_PCRINDEX pcrNum, // in - TPM_DIGEST inDigest, // in - TPM_PCRVALUE* outDigest) // out + TPM_DIGEST* inDigest, // in + TPM_PCRVALUE* outDigest) // out { - TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_Extend); + TPM_BEGIN_CMD(TPM_ORD_Extend); + + PACK_IN(TPM_PCRINDEX, pcrNum); + PACK_IN(TPM_DIGEST, inDigest); - ptr = pack_TPM_PCRINDEX(ptr, pcrNum); - ptr = pack_TPM_DIGEST(ptr, &inDigest); + TPM_XMIT_REQ(); - TPM_TRANSMIT(); - TPM_UNPACK_VERIFY(); + UNPACK_OUT(TPM_PCRVALUE, outDigest); - ptr = unpack_TPM_PCRVALUE(ptr, outDigest); + TPM_END(); abort_egress: - return status; + return status; } -TPM_RESULT TPM_Seal( - TPM_KEY_HANDLE keyHandle, // in - UINT32 pcrInfoSize, // in - TPM_PCR_INFO* pcrInfo, // in - UINT32 inDataSize, // in - const BYTE* inData, // in - TPM_STORED_DATA* sealedData, //out - const TPM_SECRET* osapSharedSecret, //in - const TPM_AUTHDATA* sealedDataAuth, //in - TPM_AUTH_SESSION* pubAuth // in, out - ) +TPM_RESULT TPM_Reset(TPM_PCR_SELECTION *sel) { - int dataAlloced = 0; - TPM_BEGIN(TPM_TAG_RQU_AUTH1_COMMAND, TPM_ORD_Seal); - TPM_AUTH_BEGIN(); - - TPM_AUTH_HASH(); - - ptr = pack_TPM_KEY_HANDLE(ptr, keyHandle); - - TPM_AUTH_SKIP(); - - xorEncrypt(osapSharedSecret, &pubAuth->NonceEven, - sealedDataAuth, ptr, - NULL, NULL); - ptr += sizeof(TPM_ENCAUTH); + TPM_BEGIN_CMD(TPM_ORD_PCR_Reset); + PACK_IN(TPM_PCR_SELECTION, sel); + TPM_XMIT_REQ(); + TPM_END(); +abort_egress: + return status; +} - ptr = pack_UINT32(ptr, pcrInfoSize); - ptr = pack_TPM_PCR_INFO(ptr, pcrInfo); +TPM_RESULT TPM_Seal( + TPM_KEY_HANDLE keyHandle, // in + UINT32 pcrInfoSize, // in + TPM_PCR_INFO* pcrInfo, // in + UINT32 inDataSize, // in + const BYTE* inData, // in + TPM_STORED_DATA* sealedData, //out + const TPM_SECRET* osapSharedSecret, //in + const TPM_AUTHDATA* sealedDataAuth, //in + TPM_AUTH_SESSION* pubAuth // in, out + ) +{ + memset(sealedData, 0, sizeof(*sealedData)); + TPM_BEGIN_CMD(TPM_ORD_Seal); + PACK_IN(TPM_KEY_HANDLE, keyHandle); + TPM_HASH_IN_BEGIN; + + xorEncrypt(osapSharedSecret, &pubAuth->NonceEven, sealedDataAuth, IN_PTR, NULL, NULL); + in_pos += sizeof(TPM_ENCAUTH); + PACK_IN(UINT32, pcrInfoSize); + if (pcrInfoSize) + PACK_IN(TPM_PCR_INFO, pcrInfo); + PACK_IN(UINT32, inDataSize); + PACK_IN(BUFFER, inData, inDataSize); + + TPM_XMIT_AUTH1(osapSharedSecret, pubAuth); + + UNPACK_OUT(TPM_STORED_DATA, sealedData, UNPACK_ALLOC); + + TPM_END_AUTH1(osapSharedSecret, pubAuth); + + abort_egress: + if (status) + free_TPM_STORED_DATA(sealedData); + TPM_AUTH_ERR_CHECK(pubAuth); + return status; +} - ptr = pack_UINT32(ptr, inDataSize); - ptr = pack_BUFFER(ptr, inData, inDataSize); +TPM_RESULT TPM_Unseal( + TPM_KEY_HANDLE parentHandle, // in + const TPM_STORED_DATA* sealedData, + UINT32* outSize, // out + BYTE** out, //out + const TPM_AUTHDATA* key_usage_auth, //in + const TPM_AUTHDATA* data_usage_auth, //in + TPM_AUTH_SESSION* keyAuth, // in, out + TPM_AUTH_SESSION* dataAuth // in, out + ) +{ + TPM_BEGIN_CMD(TPM_ORD_Unseal); - TPM_AUTH_HASH(); + PACK_IN(TPM_KEY_HANDLE, parentHandle); - TPM_AUTH1_GEN(osapSharedSecret, pubAuth); - TPM_TRANSMIT(); - TPM_UNPACK_VERIFY(); - TPM_AUTH_VERIFY_BEGIN(); + TPM_HASH_IN_BEGIN; + PACK_IN(TPM_STORED_DATA, sealedData); - ptr = unpack_TPM_STORED_DATA(ptr, sealedData, UNPACK_ALLOC); - dataAlloced = 1; + TPM_XMIT_AUTH2(key_usage_auth, keyAuth, data_usage_auth, dataAuth); - TPM_AUTH_HASH(); + UNPACK_OUT(UINT32, outSize); + UNPACK_OUT(PTR, out, *outSize, UNPACK_ALLOC); - TPM_AUTH1_VERIFY(osapSharedSecret, pubAuth); + TPM_END_AUTH2(key_usage_auth, keyAuth, data_usage_auth, dataAuth); - goto egress; abort_egress: - if(dataAlloced) { - free_TPM_STORED_DATA(sealedData); - } -egress: - TPM_AUTH_ERR_CHECK(pubAuth); - return status; + TPM_AUTH_ERR_CHECK(keyAuth); + TPM_AUTH_ERR_CHECK(dataAuth); + return status; } -TPM_RESULT TPM_Unseal( - TPM_KEY_HANDLE parentHandle, // in - const TPM_STORED_DATA* sealedData, - UINT32* outSize, // out - BYTE** out, //out - const TPM_AUTHDATA* key_usage_auth, //in - const TPM_AUTHDATA* data_usage_auth, //in - TPM_AUTH_SESSION* keyAuth, // in, out - TPM_AUTH_SESSION* dataAuth // in, out - ) +TPM_RESULT TPM_LoadKey( + TPM_KEY_HANDLE parentHandle, // + const TPM_KEY* key, //in + TPM_HANDLE* keyHandle, // out + const TPM_AUTHDATA* usage_auth, + TPM_AUTH_SESSION* auth) { - TPM_BEGIN(TPM_TAG_RQU_AUTH2_COMMAND, TPM_ORD_Unseal); - TPM_AUTH_BEGIN(); + TPM_BEGIN_CMD(TPM_ORD_LoadKey); + PACK_IN(TPM_KEY_HANDLE, parentHandle); - TPM_AUTH_HASH(); + TPM_HASH_IN_BEGIN; - ptr = pack_TPM_KEY_HANDLE(ptr, parentHandle); + PACK_IN(TPM_KEY, key); - TPM_AUTH_SKIP(); + TPM_XMIT_AUTH1(usage_auth, auth); - ptr = pack_TPM_STORED_DATA(ptr, sealedData); + UNPACK_OUT(UINT32, keyHandle); - TPM_AUTH_HASH(); + TPM_END_AUTH1(usage_auth, auth); - TPM_AUTH1_GEN(key_usage_auth, keyAuth); - TPM_AUTH2_GEN(data_usage_auth, dataAuth); - TPM_TRANSMIT(); - TPM_UNPACK_VERIFY(); - TPM_AUTH_VERIFY_BEGIN(); + vtpmloginfo(VTPM_LOG_TPM, "Key Handle: 0x%x opened by TPM_LoadKey\n", *keyHandle); +abort_egress: + TPM_AUTH_ERR_CHECK(auth); + return status; +} - ptr = unpack_UINT32(ptr, outSize); - ptr = unpack_ALLOC(ptr, out, *outSize); +TPM_RESULT TPM_FlushSpecific(TPM_HANDLE handle, + TPM_RESOURCE_TYPE rt) { + if(handle == 0) { + return TPM_SUCCESS; + } + TPM_BEGIN_CMD(TPM_ORD_FlushSpecific); - TPM_AUTH_HASH(); + PACK_IN(TPM_HANDLE, handle); + PACK_IN(TPM_RESOURCE_TYPE, rt); - TPM_AUTH1_VERIFY(key_usage_auth, keyAuth); - TPM_AUTH2_VERIFY(data_usage_auth, dataAuth); + TPM_XMIT_REQ(); + TPM_END(); abort_egress: - TPM_AUTH_ERR_CHECK(keyAuth); - TPM_AUTH_ERR_CHECK(dataAuth); - return status; + return status; } -TPM_RESULT TPM_Bind( - const TPM_KEY* key, - const BYTE* in, - UINT32 ilen, - BYTE* out) +TPM_RESULT TPM_GetRandom( UINT32* bytesRequested, // in, out + BYTE* randomBytes) // out { - TPM_RESULT status; - tpmrsa_context rsa = TPMRSA_CTX_INIT; - TPM_BOUND_DATA boundData; - uint8_t plain[TCPA_MAX_BUFFER_LENGTH]; - BYTE* ptr = plain; - - vtpmloginfo(VTPM_LOG_TPM, "%s\n", __func__); - - tpmrsa_set_pubkey(&rsa, - key->pubKey.key, key->pubKey.keyLength, - key->algorithmParms.parms.rsa.exponent, - key->algorithmParms.parms.rsa.exponentSize); - - // Fill boundData's accessory information - boundData.ver = TPM_STRUCT_VER_1_1; - boundData.payload = TPM_PT_BIND; - boundData.payloadData = (BYTE*)in; - - //marshall the bound data object - ptr = pack_TPM_BOUND_DATA(ptr, &boundData, ilen); - - // Encrypt the data - TPMTRYRETURN(tpmrsa_pub_encrypt_oaep(&rsa, - ctr_drbg_random, &vtpm_globals.ctr_drbg, - ptr - plain, - plain, - out)); + UINT32 req_len = *bytesRequested; + TPM_BEGIN_CMD(TPM_ORD_GetRandom); + PACK_IN(UINT32, req_len); -abort_egress: - tpmrsa_free(&rsa); - return status; + TPM_XMIT_REQ(); + + UNPACK_OUT(UINT32, bytesRequested); + if (*bytesRequested > req_len) + return TPM_FAIL; + UNPACK_OUT(BUFFER, randomBytes, *bytesRequested); + TPM_END(); +abort_egress: + return status; } -TPM_RESULT TPM_UnBind( - TPM_KEY_HANDLE keyHandle, // in - UINT32 ilen, //in - const BYTE* in, // - UINT32* olen, // - BYTE* out, //out - const TPM_AUTHDATA* usage_auth, - TPM_AUTH_SESSION* auth //in, out - ) + +TPM_RESULT TPM_ReadPubek( + TPM_PUBKEY* pubEK //out + ) { - TPM_BEGIN(TPM_TAG_RQU_AUTH1_COMMAND, TPM_ORD_UnBind); - TPM_AUTH_BEGIN(); + TPM_DIGEST antiReplay; + BYTE* kptr = NULL; + BYTE digest[TPM_DIGEST_SIZE]; + sha1_context ctx; - TPM_AUTH_HASH(); + vtpmmgr_rand(antiReplay.digest, TPM_DIGEST_SIZE); - ptr = pack_TPM_KEY_HANDLE(ptr, keyHandle); + TPM_BEGIN_CMD(TPM_ORD_ReadPubek); - TPM_AUTH_SKIP(); + PACK_IN(TPM_DIGEST, &antiReplay); - ptr = pack_UINT32(ptr, ilen); - ptr = pack_BUFFER(ptr, in, ilen); + TPM_XMIT_REQ(); - TPM_AUTH_HASH(); + //unpack and allocate the key + kptr = OUT_PTR; + UNPACK_OUT(TPM_PUBKEY, pubEK, UNPACK_ALLOC); - TPM_AUTH1_GEN(usage_auth, auth); - TPM_TRANSMIT(); - TPM_UNPACK_VERIFY(); - TPM_AUTH_VERIFY_BEGIN(); + //Verify the checksum + sha1_starts(&ctx); + sha1_update(&ctx, kptr, OUT_PTR - kptr); + sha1_update(&ctx, antiReplay.digest, TPM_DIGEST_SIZE); + sha1_finish(&ctx, digest); - ptr = unpack_UINT32(ptr, olen); - if(*olen > ilen) { - vtpmlogerror(VTPM_LOG_TPM, "Output length < input length!\n"); - status = TPM_IOERROR; - goto abort_egress; - } - ptr = unpack_BUFFER(ptr, out, *olen); + UNPACK_OUT(TPM_DIGEST, &antiReplay); - TPM_AUTH_HASH(); + TPM_END(); - TPM_AUTH1_VERIFY(usage_auth, auth); + //ptr points to the checksum computed by TPM + if(memcmp(digest, antiReplay.digest, TPM_DIGEST_SIZE)) { + vtpmlogerror(VTPM_LOG_TPM, "TPM_ReadPubek: Checksum returned by TPM was invalid!\n"); + status = TPM_FAIL; + goto abort_egress; + } + goto egress; abort_egress: + if(kptr != NULL) { //If we unpacked the pubEK, we have to free it + free_TPM_PUBKEY(pubEK); + } egress: - TPM_AUTH_ERR_CHECK(auth); - return status; + return status; } -TPM_RESULT TPM_CreateWrapKey( - TPM_KEY_HANDLE hWrappingKey, // in - const TPM_AUTHDATA* osapSharedSecret, - const TPM_AUTHDATA* dataUsageAuth, //in - const TPM_AUTHDATA* dataMigrationAuth, //in - TPM_KEY* key, //in, out - TPM_AUTH_SESSION* pAuth) // in, out +TPM_RESULT TPM_PCR_Read(UINT32 pcr, TPM_DIGEST *value) { - int keyAlloced = 0; - TPM_BEGIN(TPM_TAG_RQU_AUTH1_COMMAND, TPM_ORD_CreateWrapKey); - TPM_AUTH_BEGIN(); - - TPM_AUTH_HASH(); - - ptr = pack_TPM_KEY_HANDLE(ptr, hWrappingKey); - - TPM_AUTH_SKIP(); - - //Encrypted auths - xorEncrypt(osapSharedSecret, &pAuth->NonceEven, - dataUsageAuth, ptr, - dataMigrationAuth, ptr + sizeof(TPM_ENCAUTH)); - ptr += sizeof(TPM_ENCAUTH) * 2; - - ptr = pack_TPM_KEY(ptr, key); - - TPM_AUTH_HASH(); - - TPM_AUTH1_GEN(osapSharedSecret, pAuth); - TPM_TRANSMIT(); - TPM_UNPACK_VERIFY(); - TPM_AUTH_VERIFY_BEGIN(); - - keyAlloced = 1; - ptr = unpack_TPM_KEY(ptr, key, UNPACK_ALLOC); - - TPM_AUTH_HASH(); - - TPM_AUTH1_VERIFY(osapSharedSecret, pAuth); - - goto egress; + TPM_BEGIN_CMD(TPM_ORD_PcrRead); + PACK_IN(UINT32, pcr); + TPM_XMIT_REQ(); + UNPACK_OUT(TPM_DIGEST, value); + TPM_END(); abort_egress: - if(keyAlloced) { - free_TPM_KEY(key); - } -egress: - TPM_AUTH_ERR_CHECK(pAuth); - return status; + return status; } -TPM_RESULT TPM_LoadKey( - TPM_KEY_HANDLE parentHandle, // - const TPM_KEY* key, //in - TPM_HANDLE* keyHandle, // out - const TPM_AUTHDATA* usage_auth, - TPM_AUTH_SESSION* auth) +TPM_RESULT TPM_SaveState(void) { - TPM_BEGIN(TPM_TAG_RQU_AUTH1_COMMAND, TPM_ORD_LoadKey); - TPM_AUTH_BEGIN(); - - TPM_AUTH_HASH(); - - ptr = pack_TPM_KEY_HANDLE(ptr, parentHandle); - - TPM_AUTH_SKIP(); - - ptr = pack_TPM_KEY(ptr, key); - - TPM_AUTH_HASH(); - - TPM_AUTH1_GEN(usage_auth, auth); - TPM_TRANSMIT(); - TPM_UNPACK_VERIFY(); - TPM_AUTH_VERIFY_BEGIN(); - - ptr = unpack_UINT32(ptr, keyHandle); - - TPM_AUTH_HASH(); - - TPM_AUTH1_VERIFY(usage_auth, auth); - - vtpmloginfo(VTPM_LOG_TPM, "Key Handle: 0x%x opened by TPM_LoadKey\n", *keyHandle); + TPM_BEGIN_CMD(TPM_ORD_SaveState); + TPM_XMIT_REQ(); + TPM_END(); abort_egress: - TPM_AUTH_ERR_CHECK(auth); - return status; + return status; } -TPM_RESULT TPM_EvictKey( TPM_KEY_HANDLE hKey) // in +TPM_RESULT TPM_GetCapability( + TPM_CAPABILITY_AREA capArea, + UINT32 subCapSize, + const BYTE* subCap, + UINT32* respSize, + BYTE** resp) { - if(hKey == 0) { - return TPM_SUCCESS; - } + TPM_BEGIN_CMD(TPM_ORD_GetCapability); - TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_EvictKey); + PACK_IN(TPM_CAPABILITY_AREA, capArea); + PACK_IN(UINT32, subCapSize); + PACK_IN(BUFFER, subCap, subCapSize); - ptr = pack_TPM_KEY_HANDLE(ptr, hKey); + TPM_XMIT_REQ(); - TPM_TRANSMIT(); - TPM_UNPACK_VERIFY(); + UNPACK_OUT(UINT32, respSize); + UNPACK_OUT(PTR, resp, *respSize, UNPACK_ALLOC); - vtpmloginfo(VTPM_LOG_TPM, "Key handle: 0x%x closed by TPM_EvictKey\n", hKey); + TPM_END(); abort_egress: - return status; + return status; } -TPM_RESULT TPM_FlushSpecific(TPM_HANDLE handle, - TPM_RESOURCE_TYPE rt) { - if(handle == 0) { - return TPM_SUCCESS; - } - - TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_FlushSpecific); - - ptr = pack_TPM_HANDLE(ptr, handle); - ptr = pack_TPM_RESOURCE_TYPE(ptr, rt); - - TPM_TRANSMIT(); - TPM_UNPACK_VERIFY(); +TPM_RESULT TPM_CreateEndorsementKeyPair( + const TPM_KEY_PARMS* keyInfo, + TPM_PUBKEY* pubEK) +{ + BYTE* kptr = NULL; + sha1_context ctx; + TPM_DIGEST checksum; + TPM_DIGEST hash; + TPM_NONCE antiReplay; + TPM_BEGIN_CMD(TPM_ORD_CreateEndorsementKeyPair); -abort_egress: - return status; -} + //Make anti replay nonce + vtpmmgr_rand(antiReplay.nonce, sizeof(antiReplay.nonce)); -TPM_RESULT TPM_GetRandom( UINT32* bytesRequested, // in, out - BYTE* randomBytes) // out -{ - TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_GetRandom); + PACK_IN(TPM_NONCE, &antiReplay); + PACK_IN(TPM_KEY_PARMS, keyInfo); - // check input params - if (bytesRequested == NULL || randomBytes == NULL){ - return TPM_BAD_PARAMETER; - } + TPM_XMIT_REQ(); - ptr = pack_UINT32(ptr, *bytesRequested); + kptr = OUT_PTR; + UNPACK_OUT(TPM_PUBKEY, pubEK, UNPACK_ALLOC); - TPM_TRANSMIT(); - TPM_UNPACK_VERIFY(); + /* Hash the pub key blob */ + sha1_starts(&ctx); + sha1_update(&ctx, kptr, OUT_PTR - kptr); + sha1_update(&ctx, antiReplay.nonce, sizeof(antiReplay.nonce)); + sha1_finish(&ctx, hash.digest); - ptr = unpack_UINT32(ptr, bytesRequested); - ptr = unpack_BUFFER(ptr, randomBytes, *bytesRequested); + UNPACK_OUT(TPM_DIGEST, &checksum); -abort_egress: - return status; -} + TPM_END(); + if (memcmp(checksum.digest, hash.digest, TPM_DIGEST_SIZE)) { + vtpmloginfo(VTPM_LOG_VTPM, "TPM_CreateEndorsementKey: Checkum verification failed!\n"); + status = TPM_FAIL; + goto abort_egress; + } -TPM_RESULT TPM_ReadPubek( - TPM_PUBKEY* pubEK //out - ) -{ - BYTE* antiReplay = NULL; - BYTE* kptr = NULL; - BYTE digest[TPM_DIGEST_SIZE]; - sha1_context ctx; - - TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_ReadPubek); - - //antiReplay nonce - vtpmmgr_rand(ptr, TPM_DIGEST_SIZE); - antiReplay = ptr; - ptr += TPM_DIGEST_SIZE; - - TPM_TRANSMIT(); - TPM_UNPACK_VERIFY(); - - //unpack and allocate the key - kptr = ptr; - ptr = unpack_TPM_PUBKEY(ptr, pubEK, UNPACK_ALLOC); - - //Verify the checksum - sha1_starts(&ctx); - sha1_update(&ctx, kptr, ptr - kptr); - sha1_update(&ctx, antiReplay, TPM_DIGEST_SIZE); - sha1_finish(&ctx, digest); - - //ptr points to the checksum computed by TPM - if(memcmp(digest, ptr, TPM_DIGEST_SIZE)) { - vtpmlogerror(VTPM_LOG_TPM, "TPM_ReadPubek: Checksum returned by TPM was invalid!\n"); - status = TPM_FAIL; - goto abort_egress; - } - - goto egress; + goto egress; abort_egress: - if(kptr != NULL) { //If we unpacked the pubEK, we have to free it - free_TPM_PUBKEY(pubEK); - } + if(kptr) { + free_TPM_PUBKEY(pubEK); + } egress: - return status; + return status; } - -TPM_RESULT TPM_SaveState(void) +TPM_RESULT TPM_MakeIdentity( + const TPM_AUTHDATA* identityAuth, // in + const TPM_AUTHDATA* privCADigest, // in + const TPM_KEY* kinfo, // in + const TPM_AUTHDATA* srk_auth, // in + const TPM_AUTHDATA* own_auth, // in + TPM_AUTH_SESSION* srkAuth, // in,out + TPM_AUTH_SESSION* ownAuth, // in,out + TPM_KEY* key, // out + UINT32* identityBindingSize, // out + BYTE** identityBinding) // out { - TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_SaveState); + TPM_BEGIN_CMD(TPM_ORD_MakeIdentity); + TPM_HASH_IN_BEGIN; - TPM_TRANSMIT(); - TPM_UNPACK_VERIFY(); + xorEncrypt(own_auth, &ownAuth->NonceEven, identityAuth, IN_PTR, NULL, NULL); + in_pos += sizeof(TPM_ENCAUTH); -abort_egress: - return status; -} - -TPM_RESULT TPM_GetCapability( - TPM_CAPABILITY_AREA capArea, - UINT32 subCapSize, - const BYTE* subCap, - UINT32* respSize, - BYTE** resp) -{ - TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_GetCapability); + PACK_IN(TPM_AUTHDATA, privCADigest); + PACK_IN(TPM_KEY, kinfo); - ptr = pack_TPM_CAPABILITY_AREA(ptr, capArea); - ptr = pack_UINT32(ptr, subCapSize); - ptr = pack_BUFFER(ptr, subCap, subCapSize); + TPM_XMIT_AUTH2(srk_auth, srkAuth, own_auth, ownAuth); - TPM_TRANSMIT(); - TPM_UNPACK_VERIFY(); + UNPACK_OUT(TPM_KEY, key, UNPACK_ALLOC); + UNPACK_OUT(UINT32, identityBindingSize); + UNPACK_OUT(PTR, identityBinding, *identityBindingSize, UNPACK_ALLOC); - ptr = unpack_UINT32(ptr, respSize); - ptr = unpack_ALLOC(ptr, resp, *respSize); + TPM_END_AUTH2(srk_auth, srkAuth, own_auth, ownAuth); abort_egress: - return status; + TPM_AUTH_ERR_CHECK(srkAuth); + TPM_AUTH_ERR_CHECK(ownAuth); + return status; } -TPM_RESULT TPM_CreateEndorsementKeyPair( - const TPM_KEY_PARMS* keyInfo, - TPM_PUBKEY* pubEK) +TPM_RESULT TPM_ActivateIdentity( + TPM_KEY_HANDLE aikHandle, // in + BYTE* blob, // in + UINT32 blobSize, // in + const TPM_AUTHDATA* aik_auth, // in + const TPM_AUTHDATA* owner_auth, // in + TPM_AUTH_SESSION* aikAuth, // in,out + TPM_AUTH_SESSION* ownAuth, // in,out + TPM_SYMMETRIC_KEY* symKey) // out { - BYTE* kptr = NULL; - sha1_context ctx; - TPM_DIGEST checksum; - TPM_DIGEST hash; - TPM_NONCE antiReplay; - TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_CreateEndorsementKeyPair); + TPM_BEGIN_CMD(TPM_ORD_ActivateIdentity); + PACK_IN(TPM_KEY_HANDLE, aikHandle); + TPM_HASH_IN_BEGIN; + PACK_IN(UINT32, blobSize); + PACK_IN(BUFFER, blob, blobSize); + + TPM_XMIT_AUTH2(aik_auth, aikAuth, owner_auth, ownAuth); - //Make anti replay nonce - vtpmmgr_rand(antiReplay.nonce, sizeof(antiReplay.nonce)); + UNPACK_OUT(TPM_SYMMETRIC_KEY, symKey, UNPACK_ALLOC); - ptr = pack_TPM_NONCE(ptr, &antiReplay); - ptr = pack_TPM_KEY_PARMS(ptr, keyInfo); + TPM_END_AUTH2(aik_auth, aikAuth, owner_auth, ownAuth); - TPM_TRANSMIT(); - TPM_UNPACK_VERIFY(); - - sha1_starts(&ctx); +abort_egress: + TPM_AUTH_ERR_CHECK(aikAuth); + TPM_AUTH_ERR_CHECK(ownAuth); + return status; +} - kptr = ptr; - ptr = unpack_TPM_PUBKEY(ptr, pubEK, UNPACK_ALLOC); +TPM_RESULT TPM_Quote( + TPM_KEY_HANDLE keyh, // in + const TPM_NONCE* data, // in + const TPM_PCR_SELECTION *pcrSelect, // in + const TPM_AUTHDATA* auth, // in + TPM_AUTH_SESSION* oiap, // in,out + TPM_PCR_COMPOSITE *pcrs, // out + BYTE** sig, // out + UINT32* sigSize) // out +{ + TPM_BEGIN_CMD(TPM_ORD_Quote); + PACK_IN(TPM_KEY_HANDLE, keyh); + TPM_HASH_IN_BEGIN; + PACK_IN(TPM_NONCE, data); + PACK_IN(TPM_PCR_SELECTION, pcrSelect); - /* Hash the pub key blob */ - sha1_update(&ctx, kptr, ptr - kptr); - ptr = unpack_TPM_DIGEST(ptr, &checksum); + TPM_XMIT_AUTH1(auth, oiap); - sha1_update(&ctx, antiReplay.nonce, sizeof(antiReplay.nonce)); + UNPACK_OUT(TPM_PCR_COMPOSITE, pcrs, UNPACK_ALLOC); + UNPACK_OUT(UINT32, sigSize); + UNPACK_OUT(PTR, sig, *sigSize, UNPACK_ALLOC); - sha1_finish(&ctx, hash.digest); - if(memcmp(checksum.digest, hash.digest, TPM_DIGEST_SIZE)) { - vtpmloginfo(VTPM_LOG_VTPM, "TPM_CreateEndorsementKey: Checkum verification failed!\n"); - status = TPM_FAIL; - goto abort_egress; - } + TPM_END_AUTH1(auth, oiap); - goto egress; abort_egress: - if(kptr) { - free_TPM_PUBKEY(pubEK); - } -egress: - return status; + TPM_AUTH_ERR_CHECK(oiap); + return status; } TPM_RESULT TPM_TransmitData( - BYTE* in, - UINT32 insize, - BYTE* out, - UINT32* outsize) { - TPM_RESULT status = TPM_SUCCESS; - - UINT32 i; - vtpmloginfo(VTPM_LOG_TXDATA, "Sending buffer = 0x"); - for(i = 0 ; i < insize ; i++) - vtpmloginfomore(VTPM_LOG_TXDATA, "%2.2x ", in[i]); - - vtpmloginfomore(VTPM_LOG_TXDATA, "\n"); - - ssize_t size = 0; - - // send the request - size = write (vtpm_globals.tpm_fd, in, insize); - if (size < 0) { - vtpmlogerror(VTPM_LOG_TXDATA, "write() failed : %s\n", strerror(errno)); - ERRORDIE (TPM_IOERROR); - } - else if ((UINT32) size < insize) { - vtpmlogerror(VTPM_LOG_TXDATA, "Wrote %d instead of %d bytes!\n", (int) size, insize); - ERRORDIE (TPM_IOERROR); - } - - // read the response - size = read (vtpm_globals.tpm_fd, out, *outsize); - if (size < 0) { - vtpmlogerror(VTPM_LOG_TXDATA, "read() failed : %s\n", strerror(errno)); - ERRORDIE (TPM_IOERROR); - } - - vtpmloginfo(VTPM_LOG_TXDATA, "Receiving buffer = 0x"); - for(i = 0 ; i < size ; i++) - vtpmloginfomore(VTPM_LOG_TXDATA, "%2.2x ", out[i]); - - vtpmloginfomore(VTPM_LOG_TXDATA, "\n"); - - *outsize = size; - goto egress; + BYTE* in, + UINT32 insize, + BYTE* out, + UINT32* outsize) { + TPM_RESULT status = TPM_SUCCESS; + + UINT32 i; + vtpmloginfo(VTPM_LOG_TXDATA, "Sending buffer = 0x"); + for(i = 0 ; i < insize ; i++) + vtpmloginfomore(VTPM_LOG_TXDATA, "%2.2x ", in[i]); + + vtpmloginfomore(VTPM_LOG_TXDATA, "\n"); + + ssize_t size = 0; + + // send the request + size = write (vtpm_globals.tpm_fd, in, insize); + if (size < 0) { + vtpmlogerror(VTPM_LOG_TXDATA, "write() failed : %s\n", strerror(errno)); + ERRORDIE (TPM_IOERROR); + } + else if ((UINT32) size < insize) { + vtpmlogerror(VTPM_LOG_TXDATA, "Wrote %d instead of %d bytes!\n", (int) size, insize); + ERRORDIE (TPM_IOERROR); + } + + // read the response + size = read (vtpm_globals.tpm_fd, out, *outsize); + if (size < 0) { + vtpmlogerror(VTPM_LOG_TXDATA, "read() failed : %s\n", strerror(errno)); + ERRORDIE (TPM_IOERROR); + } + + vtpmloginfo(VTPM_LOG_TXDATA, "Receiving buffer = 0x"); + for(i = 0 ; i < size ; i++) + vtpmloginfomore(VTPM_LOG_TXDATA, "%2.2x ", out[i]); + + vtpmloginfomore(VTPM_LOG_TXDATA, "\n"); + + *outsize = size; + goto egress; abort_egress: egress: - return status; + return status; } diff --git a/stubdom/vtpmmgr/tpm.h b/stubdom/vtpmmgr/tpm.h index 304e145..2161976 100644 --- a/stubdom/vtpmmgr/tpm.h +++ b/stubdom/vtpmmgr/tpm.h @@ -80,22 +80,11 @@ TPM_RESULT TPM_FlushSpecific ( TPM_HANDLE handle, // in // TPM Mandatory TPM_RESULT TPM_Extend ( TPM_PCRINDEX pcrNum, // in - TPM_DIGEST inDigest, // in + TPM_DIGEST* inDigest, // in TPM_PCRVALUE* outDigest // out ); -TPM_RESULT TPM_PcrRead ( TPM_PCRINDEX pcrNum, // in - TPM_PCRVALUE* outDigest // out - ); - -TPM_RESULT TPM_Quote ( TCS_KEY_HANDLE keyHandle, // in - TPM_NONCE antiReplay, // in - UINT32* PcrDataSize, // in, out - BYTE** PcrData, // in, out - TPM_AUTH_SESSION* privAuth, // in, out - UINT32* sigSize, // out - BYTE** sig // out - ); +TPM_RESULT TPM_Reset(TPM_PCR_SELECTION *sel); TPM_RESULT TPM_Seal( TCS_KEY_HANDLE keyHandle, // in @@ -120,41 +109,6 @@ TPM_RESULT TPM_Unseal ( TPM_AUTH_SESSION* dataAuth // in, out ); -TPM_RESULT TPM_DirWriteAuth ( TPM_DIRINDEX dirIndex, // in - TPM_DIRVALUE newContents, // in - TPM_AUTH_SESSION* ownerAuth // in, out - ); - -TPM_RESULT TPM_DirRead ( TPM_DIRINDEX dirIndex, // in - TPM_DIRVALUE* dirValue // out - ); - -TPM_RESULT TPM_Bind( - const TPM_KEY* key, //in - const BYTE* in, //in - UINT32 ilen, //in - BYTE* out //out, must be at least cipher block size - ); - -TPM_RESULT TPM_UnBind ( - TCS_KEY_HANDLE keyHandle, // in - UINT32 ilen, //in - const BYTE* in, // - UINT32* outDataSize, // out - BYTE* outData, //out - const TPM_AUTHDATA* usage_auth, - TPM_AUTH_SESSION* auth //in, out - ); - -TPM_RESULT TPM_CreateWrapKey ( - TCS_KEY_HANDLE hWrappingKey, // in - const TPM_AUTHDATA* osapSharedSecret, - const TPM_AUTHDATA* dataUsageAuth, //in - const TPM_AUTHDATA* dataMigrationAuth, //in - TPM_KEY* key, //in - TPM_AUTH_SESSION* pAuth // in, out - ); - TPM_RESULT TPM_LoadKey ( TPM_KEY_HANDLE parentHandle, // const TPM_KEY* key, //in @@ -163,35 +117,14 @@ TPM_RESULT TPM_LoadKey ( TPM_AUTH_SESSION* auth ); -TPM_RESULT TPM_GetPubKey ( TCS_KEY_HANDLE hKey, // in - TPM_AUTH_SESSION* pAuth, // in, out - UINT32* pcPubKeySize, // out - BYTE** prgbPubKey // out - ); - -TPM_RESULT TPM_EvictKey ( TCS_KEY_HANDLE hKey // in - ); - TPM_RESULT TPM_FlushSpecific(TPM_HANDLE handle, //in TPM_RESOURCE_TYPE rt //in ); -TPM_RESULT TPM_Sign ( TCS_KEY_HANDLE keyHandle, // in - UINT32 areaToSignSize, // in - BYTE* areaToSign, // in - TPM_AUTH_SESSION* privAuth, // in, out - UINT32* sigSize, // out - BYTE** sig // out - ); - TPM_RESULT TPM_GetRandom ( UINT32* bytesRequested, // in, out BYTE* randomBytes // out ); -TPM_RESULT TPM_StirRandom ( UINT32 inDataSize, // in - BYTE* inData // in - ); - TPM_RESULT TPM_ReadPubek ( TPM_PUBKEY* pubEK //out ); @@ -203,12 +136,45 @@ TPM_RESULT TPM_GetCapability( UINT32* respSize, BYTE** resp); +TPM_RESULT TPM_PCR_Read(UINT32 pcr, TPM_DIGEST *value); TPM_RESULT TPM_SaveState(void); TPM_RESULT TPM_CreateEndorsementKeyPair( const TPM_KEY_PARMS* keyInfo, TPM_PUBKEY* pubEK); +TPM_RESULT TPM_MakeIdentity( + const TPM_AUTHDATA* identityAuth, // in + const TPM_AUTHDATA* privCADigest, // in + const TPM_KEY* kinfo, // in + const TPM_AUTHDATA* srk_auth, // in + const TPM_AUTHDATA* owner_auth, // in + TPM_AUTH_SESSION* srkAuth, // in,out + TPM_AUTH_SESSION* ownAuth, // in,out + TPM_KEY* key, // out + UINT32* identityBindingSize, // out + BYTE** identityBinding); // out + +TPM_RESULT TPM_ActivateIdentity( + TPM_KEY_HANDLE aikHandle, // in + BYTE* blob, // in + UINT32 blobSize, // in + const TPM_AUTHDATA* aik_auth, // in + const TPM_AUTHDATA* owner_auth, // in + TPM_AUTH_SESSION* aikAuth, // in,out + TPM_AUTH_SESSION* ownAuth, // in,out + TPM_SYMMETRIC_KEY* symKey); // out + +TPM_RESULT TPM_Quote( + TPM_KEY_HANDLE keyh, // in + const TPM_NONCE* data, // in + const TPM_PCR_SELECTION *pcrSelect, // in + const TPM_AUTHDATA* auth, // in + TPM_AUTH_SESSION* oiap, // in,out + TPM_PCR_COMPOSITE *pcrs, // out + BYTE** sig, // out + UINT32* sigSize); // out + TPM_RESULT TPM_TransmitData( BYTE* in, UINT32 insize, diff --git a/stubdom/vtpmmgr/tpmrsa.c b/stubdom/vtpmmgr/tpmrsa.c index 56094e7..2a2fa36 100644 --- a/stubdom/vtpmmgr/tpmrsa.c +++ b/stubdom/vtpmmgr/tpmrsa.c @@ -89,6 +89,31 @@ cleanup: return TPM_SUCCESS; } +static const unsigned char rsa_der_header[] = { + 0x00, 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03, 0x02, 0x1a, 0x05, 0x00, 0x04, 0x14, +}; + +TPM_RESULT tpmrsa_sigcheck(tpmrsa_context *ctx, const unsigned char *input, const unsigned char *sha1) +{ + unsigned char *tmp = alloca(ctx->len); + TPM_RESULT rv; + int i; + rv = tpmrsa_public(ctx, input, tmp); + if (rv) + return rv; + if (tmp[0] != 0 || tmp[1] != 1) + return TPM_INAPPROPRIATE_SIG; + for(i=2; i < 220; i++) { + if (tmp[i] != 0xFF) + return TPM_INAPPROPRIATE_SIG; + } + if (memcmp(tmp + 220, rsa_der_header, sizeof(rsa_der_header))) + return TPM_INAPPROPRIATE_SIG; + if (memcmp(tmp + 236, sha1, 20)) + return TPM_DECRYPT_ERROR; + return TPM_SUCCESS; +} + static void mgf_mask( unsigned char *dst, int dlen, unsigned char *src, int slen) { unsigned char mask[HASH_LEN]; diff --git a/stubdom/vtpmmgr/tpmrsa.h b/stubdom/vtpmmgr/tpmrsa.h index 59579e7..31e5a8b 100644 --- a/stubdom/vtpmmgr/tpmrsa.h +++ b/stubdom/vtpmmgr/tpmrsa.h @@ -51,6 +51,9 @@ void tpmrsa_set_pubkey(tpmrsa_context* ctx, const unsigned char* exponent, int explen); +/* Check an RSA signature */ +TPM_RESULT tpmrsa_sigcheck(tpmrsa_context *ctx, const unsigned char *input, const unsigned char *sha1); + /* Do rsa public crypto */ TPM_RESULT tpmrsa_pub_encrypt_oaep( tpmrsa_context *ctx, int (*f_rng)(void *, unsigned char *, size_t), diff --git a/stubdom/vtpmmgr/vtpm_cmd_handler.c b/stubdom/vtpmmgr/vtpm_cmd_handler.c index f82a2a9..018323a 100644 --- a/stubdom/vtpmmgr/vtpm_cmd_handler.c +++ b/stubdom/vtpmmgr/vtpm_cmd_handler.c @@ -37,116 +37,804 @@ #include #include #include +#include +#include +#include #include "marshal.h" #include "log.h" -#include "vtpm_storage.h" +#include "vtpm_disk.h" #include "vtpmmgr.h" #include "tpm.h" +#include "tpmrsa.h" #include "tcg.h" +#include "mgmt_authority.h" +#include "disk_crypto.h" -static TPM_RESULT vtpmmgr_SaveHashKey( - const uuid_t uuid, - tpmcmd_t* tpmcmd) +static void gen_random_uuid(uuid_t uuid) { - TPM_RESULT status = TPM_SUCCESS; + do_random(uuid, 16); + // make the 128-bit random number a valid UUID (122 bits remain) + uuid[6] = 0x40 | (uuid[6] & 0x0F); + uuid[8] = 0x80 | (uuid[8] & 0x3F); +} + +static TPM_RESULT find_vtpm_khash(int domid, struct tpm_opaque *opq) +{ + // TODO getting the build hashes requires a domain builder to report them + memset(opq->kern_hash, 0, sizeof(opq->kern_hash)); + return TPM_SUCCESS; +} + +static TPM_RESULT find_vtpm_verified(int domid, struct tpm_opaque *opq) +{ + TPM_RESULT rc; + int i; + if (opq->vtpm) + return TPM_SUCCESS; + + rc = find_vtpm(&opq->group, &opq->vtpm, *opq->uuid); + if (rc) + return TPM_BAD_PARAMETER; - if(tpmcmd->req_len != VTPM_COMMAND_HEADER_SIZE + HASHKEYSZ) { - vtpmlogerror(VTPM_LOG_VTPM, "VTPM_ORD_SAVEHASHKEY hashkey too short!\n"); - status = TPM_BAD_PARAMETER; - goto abort_egress; - } + if (opq->vtpm->flags & VTPM_FLAG_OPEN) { + printk("Attempted to open vTPM twice!\n"); + opq->vtpm = NULL; + opq->group = NULL; + return TPM_DISABLED; + } - /* Do the command */ - TPMTRYRETURN(vtpm_storage_save_hashkey(uuid, tpmcmd->req + VTPM_COMMAND_HEADER_SIZE)); + rc = find_vtpm_khash(domid, opq); + if (rc) + return rc; + + for(i=0; i < be32_native(opq->group->seal_bits.nr_kerns); i++) { + if (!memcmp(opq->group->seal_bits.kernels[i].bits, opq->kern_hash, 20)) { + opq->vtpm->flags |= VTPM_FLAG_OPEN; + return TPM_SUCCESS; + } + } + printk("Unauthorized vTPM kernel image used!\n"); + return TPM_DISABLED; +} + +static TPM_RESULT vtpmmgr_SaveHashKey(struct tpm_opaque *opq, tpmcmd_t* tpmcmd) +{ + TPM_RESULT status = TPM_SUCCESS; + int rc = 0; + + size_t bufsize = tpmcmd->req_len - VTPM_COMMAND_HEADER_SIZE; + const void *buf = tpmcmd->req + VTPM_COMMAND_HEADER_SIZE; + + if (bufsize < 52) { + vtpmlogerror(VTPM_LOG_VTPM, "VTPM_ORD_SAVEHASHKEY hashkey too short!\n"); + status = TPM_BAD_PARAMETER; + goto abort_egress; + } + if (bufsize > 64) { + vtpmlogerror(VTPM_LOG_VTPM, "VTPM_ORD_SAVEHASHKEY hashkey too long!\n"); + status = TPM_BAD_PARAMETER; + goto abort_egress; + } + + vtpmloginfo(VTPM_LOG_VTPM, "vtpmmgr_SaveHashKey\n"); + status = find_vtpm_verified(tpmcmd->domid, opq); + + // auto-create vTPMs in group0 when saving a new UUID + // TODO restrict to certain UUIDs (such as all-zero) + // this is not done yet to simplify use of the TPM Manager + if (status == TPM_BAD_PARAMETER) { + opq->group = g_mgr->groups[0].v; + rc = create_vtpm(opq->group, &opq->vtpm, *opq->uuid); + if (rc) { + status = TPM_BAD_PARAMETER; + goto abort_egress; + } + if (opq->group->nr_vtpms == 1) + opq->vtpm->flags = VTPM_FLAG_ADMIN; + printk("SaveHashKey with unknown UUID="UUID_FMT" - creating in auth0 (f=%d)\n", + UUID_BYTES((*opq->uuid)), opq->vtpm->flags); + status = TPM_SUCCESS; + } + if (status) + goto abort_egress; + + memcpy(opq->vtpm->data, buf, bufsize); + memset(opq->vtpm->data + bufsize, 0, 64 - bufsize); + + vtpm_sync(opq->group, opq->vtpm); abort_egress: - pack_TPM_RSP_HEADER(tpmcmd->resp, - VTPM_TAG_RSP, VTPM_COMMAND_HEADER_SIZE, status); - tpmcmd->resp_len = VTPM_COMMAND_HEADER_SIZE; + pack_TPM_RSP_HEADER(tpmcmd->resp, VTPM_TAG_RSP, VTPM_COMMAND_HEADER_SIZE, status); + tpmcmd->resp_len = VTPM_COMMAND_HEADER_SIZE; - return status; + return status; } -static TPM_RESULT vtpmmgr_LoadHashKey( - const uuid_t uuid, - tpmcmd_t* tpmcmd) { - TPM_RESULT status = TPM_SUCCESS; +static TPM_RESULT vtpmmgr_LoadHashKey(struct tpm_opaque *opq, tpmcmd_t* tpmcmd) +{ + TPM_RESULT status = TPM_SUCCESS; + int i; + uint8_t *buf = tpmcmd->resp + VTPM_COMMAND_HEADER_SIZE; + + vtpmloginfo(VTPM_LOG_VTPM, "vtpmmgr_LoadHashKey\n"); + tpmcmd->resp_len = VTPM_COMMAND_HEADER_SIZE; - tpmcmd->resp_len = VTPM_COMMAND_HEADER_SIZE; + status = find_vtpm_verified(tpmcmd->domid, opq); + if (status) + goto abort_egress; - TPMTRYRETURN(vtpm_storage_load_hashkey(uuid, tpmcmd->resp + VTPM_COMMAND_HEADER_SIZE)); + memcpy(buf, opq->vtpm->data, 64); - tpmcmd->resp_len += HASHKEYSZ; + for(i=52; i < 64; i++) { + if (buf[i]) { + tpmcmd->resp_len += 64; + goto abort_egress; + } + } + tpmcmd->resp_len += 52; abort_egress: - pack_TPM_RSP_HEADER(tpmcmd->resp, - VTPM_TAG_RSP, tpmcmd->resp_len, status); + pack_TPM_RSP_HEADER(tpmcmd->resp, VTPM_TAG_RSP, tpmcmd->resp_len, status); + + return status; +} + +#define CMD_BEGIN \ + TPM_RESULT status = TPM_SUCCESS; \ + uint32_t in_pos = VTPM_COMMAND_HEADER_SIZE; \ + tpmcmd->resp_len = VTPM_COMMAND_HEADER_SIZE; \ + vtpmloginfo(VTPM_LOG_TPM, "%s\n", __func__); + +#define CMD_END \ + abort_egress: \ + if (status) \ + tpmcmd->resp_len = VTPM_COMMAND_HEADER_SIZE; \ + pack_TPM_RSP_HEADER(tpmcmd->resp, VTPM_TAG_RSP, tpmcmd->resp_len, status); \ + return status + +#define UNPACK_IN(type, item...) do { \ + status = unpack3_ ## type (tpmcmd->req, &in_pos, tpmcmd->req_len, item); \ + if (status) { \ + status = TPM_BAD_PARAMETER; \ + goto abort_egress; \ + } \ +} while (0) + +#define UNPACK_GROUP(group) do { \ + uint32_t group_idx; \ + UNPACK_IN(UINT32, &group_idx); \ + if (group_idx >= g_mgr->nr_groups) { \ + status = TPM_BADINDEX; \ + goto abort_egress; \ + } \ + group = g_mgr->groups[group_idx].v; \ + if (!group) { \ + status = TPM_AUTHFAIL; \ + goto abort_egress; \ + } \ +} while (0) + +#define UNPACK_DONE() do { \ + if (in_pos != tpmcmd->req_len) { \ + status = TPM_BAD_PARAMETER; \ + goto abort_egress; \ + } \ +} while (0) + +#define PACK_OUT(type, item...) do { \ + UINT32 isize = sizeof_ ## type(item); \ + if (isize + tpmcmd->resp_len > TCPA_MAX_BUFFER_LENGTH) { \ + status = TPM_SIZE; \ + goto abort_egress; \ + } \ + pack_ ## type (tpmcmd->resp + tpmcmd->resp_len, item); \ + tpmcmd->resp_len += isize; \ +} while (0) + +#define PACK_BUF ((void*)(tpmcmd->resp + tpmcmd->resp_len)) + +static TPM_RESULT vtpmmgr_GetBootHash(struct tpm_opaque *opq, tpmcmd_t* tpmcmd) +{ + CMD_BEGIN; + UNPACK_DONE(); + + PACK_OUT(BUFFER, opq->kern_hash, 20); + + CMD_END; +} + +static TPM_RESULT vtpmmgr_GetQuote(struct tpm_opaque *opq, tpmcmd_t* tpmcmd) +{ + CMD_BEGIN; + int i; + void *ibuf; + uint32_t pcr_size; + TPM_PCR_SELECTION sel; + + UNPACK_IN(VPTR, &ibuf, 20, UNPACK_ALIAS); + UNPACK_IN(TPM_PCR_SELECTION, &sel, UNPACK_ALIAS); + UNPACK_DONE(); + + if (!opq->vtpm) { + status = TPM_BAD_PARAMETER; + goto abort_egress; + } + + printk("ibuf: "); + for (i=0; i < 20; i++) + printk("%02x", ((uint8_t*)ibuf)[i]); + printk("\n"); + + status = vtpm_do_quote(opq->group, *opq->uuid, opq->kern_hash, ibuf, &sel, PACK_BUF + 256, &pcr_size, PACK_BUF); + if (status) + goto abort_egress; + tpmcmd->resp_len += 256 + pcr_size; + + CMD_END; +} + +static TPM_RESULT vtpmmgr_GroupList(tpmcmd_t* tpmcmd) +{ + CMD_BEGIN; + UNPACK_DONE(); + PACK_OUT(UINT32, g_mgr->nr_groups); + CMD_END; +} + +static TPM_RESULT vtpmmgr_GroupNew(tpmcmd_t* tpmcmd) +{ + void *privCADigest; + BYTE *pubkey; + struct mem_group *group; + uint32_t group_idx; + CMD_BEGIN; + + UNPACK_IN(VPTR, &privCADigest, 20, UNPACK_ALIAS); + UNPACK_IN(PTR, &pubkey, 256, UNPACK_ALIAS); + UNPACK_DONE(); + + group = vtpm_new_group(privCADigest); + if (!group) { + status = TPM_FAIL; + goto abort_egress; + } + + memcpy(group->id_data.saa_pubkey, pubkey, 256); + + PACK_OUT(BUFFER, group->id_data.uuid, 16); + PACK_OUT(BUFFER, group->id_data.tpm_aik_public, 256); + PACK_OUT(BUFFER, group->details.recovery_data, 256); + + memset(group->details.recovery_data, 0, 256); + + group->details.sequence = native_be64(g_mgr->sequence); + + if (group != g_mgr->groups[0].v) { + group_idx = g_mgr->nr_groups; + g_mgr->nr_groups++; + g_mgr->groups = realloc(g_mgr->groups, g_mgr->nr_groups*sizeof(struct mem_group_hdr)); + memset(&g_mgr->groups[group_idx], 0, sizeof(g_mgr->groups[0])); + g_mgr->groups[group_idx].v = group; + } + + vtpm_sync_group(group, SEQ_UPDATE); + CMD_END; +} + +static TPM_RESULT vtpmmgr_GroupDel(tpmcmd_t* tpmcmd) +{ + CMD_BEGIN; + struct mem_group *group; + uint32_t group_idx, nr_mov; + + UNPACK_IN(UINT32, &group_idx); + UNPACK_DONE(); + + if (group_idx > g_mgr->nr_groups) { + status = TPM_BADINDEX; + goto abort_egress; + } + group = g_mgr->groups[group_idx].v; + + if (group) { + int i, j; + for (i = 0; i < group->nr_pages; i++) { + for (j = 0; j < group->data[i].size; j++) { + if (group->data[i].vtpms[j]->flags & VTPM_FLAG_OPEN) { + status = TPM_FAIL; + goto abort_egress; + } + } + } + + for (i = 0; i < group->nr_pages; i++) { + for (j = 0; j < group->data[i].size; j++) { + free(group->data[i].vtpms[j]); + } + } + free(group->data); + free(group->seals); + free(group); + } + + g_mgr->nr_groups--; + nr_mov = g_mgr->nr_groups - group_idx; + memmove(&g_mgr->groups[group_idx], &g_mgr->groups[group_idx + 1], nr_mov * sizeof(g_mgr->groups[0])); + + vtpm_sync_disk(g_mgr, CTR_UPDATE); + + CMD_END; +} + +static int pack_cfg_list(void* buf, struct mem_group *group) +{ + int i; + void *bstart = buf; + memcpy(buf, &group->details.cfg_seq, 8); buf += 8; + buf = pack_UINT32(buf, group->nr_seals); + for(i=0; i < group->nr_seals; i++) { + memcpy(buf, &group->seals[i].digest_release, 20); + buf += 20; + } + memcpy(buf, &group->seal_bits.nr_kerns, 4); buf += 4; + memcpy(buf, &group->seal_bits.kernels, 20 * be32_native(group->seal_bits.nr_kerns)); + return buf - bstart + 20 * be32_native(group->seal_bits.nr_kerns); +} + +static TPM_RESULT vtpmmgr_GroupShow(tpmcmd_t* tpmcmd) +{ + CMD_BEGIN; + struct mem_group *group; + + UNPACK_GROUP(group); + UNPACK_DONE(); + + // TODO show is read-only access, need to hit disk if group is NULL + + PACK_OUT(BUFFER, group->id_data.uuid, 16); + PACK_OUT(BUFFER, group->id_data.saa_pubkey, 256); + tpmcmd->resp_len += pack_cfg_list(PACK_BUF, group); + + CMD_END; +} + +static TPM_RESULT vtpmmgr_GroupActivate(tpmcmd_t* tpmcmd) +{ + CMD_BEGIN; + struct mem_group *group; + uint32_t blobSize; + void *blob; + + UNPACK_GROUP(group); + UNPACK_IN(UINT32, &blobSize); + UNPACK_IN(VPTR, &blob, blobSize, UNPACK_ALIAS); + UNPACK_DONE(); + + status = group_do_activate(group, blob, blobSize, tpmcmd->resp, &tpmcmd->resp_len); + + CMD_END; +} + +/* 2048-bit MODP Group from RFC3526: + * 2^2048 - 2^1984 - 1 + 2^64 * { [2^1918 pi] + 124476 } + * mpi objects use little endian word ordering + */ +static t_uint Pp[256 / sizeof(t_uint)] = { + 0xFFFFFFFFFFFFFFFFUL, 0x15728E5A8AACAA68UL, 0x15D2261898FA0510UL, + 0x3995497CEA956AE5UL, 0xDE2BCBF695581718UL, 0xB5C55DF06F4C52C9UL, + 0x9B2783A2EC07A28FUL, 0xE39E772C180E8603UL, 0x32905E462E36CE3BUL, + 0xF1746C08CA18217CUL, 0x670C354E4ABC9804UL, 0x9ED529077096966DUL, + 0x1C62F356208552BBUL, 0x83655D23DCA3AD96UL, 0x69163FA8FD24CF5FUL, + 0x98DA48361C55D39AUL, 0xC2007CB8A163BF05UL, 0x49286651ECE45B3DUL, + 0xAE9F24117C4B1FE6UL, 0xEE386BFB5A899FA5UL, 0x0BFF5CB6F406B7EDUL, + 0xF44C42E9A637ED6BUL, 0xE485B576625E7EC6UL, 0x4FE1356D6D51C245UL, + 0x302B0A6DF25F1437UL, 0xEF9519B3CD3A431BUL, 0x514A08798E3404DDUL, + 0x020BBEA63B139B22UL, 0x29024E088A67CC74UL, 0xC4C6628B80DC1CD1UL, + 0xC90FDAA22168C234UL, 0xFFFFFFFFFFFFFFFFUL, +}; +static t_uint Gp[] = { 2 }; + +static void tm_dhkx_gen(void* dhkx1, void* dhkx2, void* out) +{ + mpi GX = { 0 }, GY = { 0 }, K = { 0 }, RP = { 0 }; + + t_uint Xp[256 / sizeof(t_uint)]; + mpi X = { + .s = 1, + .n = sizeof(Xp)/sizeof(Xp[0]), + .p = Xp + }; + mpi P = { + .s = 1, + .n = sizeof(Pp)/sizeof(Pp[0]), + .p = Pp, + }; + mpi G = { + .s = 1, + .n = 1, + .p = Gp, + }; + + do_random(Xp, sizeof(Xp)); + while (Xp[31] == 0 || Xp[31] == -1UL) + do_random(Xp + 31, sizeof(Xp[31])); + + mpi_exp_mod(&GX, &G, &X, &P, &RP); + mpi_write_binary(&GX, dhkx2, 256); + mpi_free(&GX); + + mpi_read_binary(&GY, dhkx1, 256); + mpi_exp_mod(&K, &GY, &X, &P, &RP); + mpi_free(&RP); + mpi_free(&GY); + + mpi_write_binary(&K, (void*)Xp, 256); + mpi_free(&K); + sha2((void*)Xp, 256, out, 0); +} + +static void xor2_256b(void *xv, const void* yv) +{ + int i; + uint64_t *x = xv; + const uint64_t *y = yv; + for(i=0; i < 4; i++) + x[i] ^= y[i]; +} + +static TPM_RESULT vtpmmgr_GroupRegister(tpmcmd_t* tpmcmd) +{ + CMD_BEGIN; + struct mem_group *group = NULL; + tpmrsa_context saa_rsa = TPMRSA_CTX_INIT; + struct tpm_authdata digest; + sha1_context ctx; + TPM_PCR_SELECTION sel; + void *dhkx1, *dhkx2, *gk, *sig; + + UNPACK_GROUP(group); + UNPACK_IN(VPTR, &dhkx1, 256, UNPACK_ALIAS); + UNPACK_IN(VPTR, &sig, 256, UNPACK_ALIAS); + UNPACK_IN(TPM_PCR_SELECTION, &sel, UNPACK_ALIAS); + UNPACK_DONE(); + + /* Only generating this quote during the same boot that this group was + * created in allows the quote to prove that the group key has never + * been available outside a configuration approved by its SAA. + */ + if (!(group->flags & MEM_GROUP_FLAG_FIRSTBOOT)) { + status = TPM_FAIL; + goto abort_egress; + } + + sha1(dhkx1, 256, digest.bits); + tpmrsa_set_pubkey(&saa_rsa, group->id_data.saa_pubkey, 256, 0, 0); + if (tpmrsa_sigcheck(&saa_rsa, sig, digest.bits)) + status = TPM_FAIL; + tpmrsa_free(&saa_rsa); + if (status) + goto abort_egress; + + dhkx2 = PACK_BUF; + tpmcmd->resp_len += 256; + gk = PACK_BUF; + tpmcmd->resp_len += 32; + + tm_dhkx_gen(dhkx1, dhkx2, gk); + xor2_256b(gk, &group->group_key); + + sha1_starts(&ctx); + sha1_update(&ctx, (void*)"REGR", 4); + sha1_update(&ctx, dhkx1, 256); + sha1_update(&ctx, dhkx2, 256 + 32); + sha1_finish(&ctx, digest.bits); + + status = vtpm_do_quote(group, NULL, NULL, &digest, &sel, NULL, NULL, PACK_BUF); + tpmcmd->resp_len += 256; + + CMD_END; +} + +static TPM_RESULT vtpmmgr_GroupUpdate(tpmcmd_t* tpmcmd) +{ + CMD_BEGIN; + struct mem_group *group; + int i; + int hstart; + uint32_t nr_kerns, nr_seals; + uint64_t old_seq, new_seq; + struct mem_seal *seals = NULL; + tpmrsa_context saa_rsa = TPMRSA_CTX_INIT; + unsigned char digest[20]; + TPM_RESULT rc; + void *sig, *seal_bits, *kern_bits; + + UNPACK_GROUP(group); + UNPACK_IN(VPTR, &sig, 256, UNPACK_ALIAS); + + // Hash starts here + hstart = in_pos; + + new_seq = be64_native(*(be64_t*)(tpmcmd->req + in_pos)); + old_seq = be64_native(group->details.cfg_seq); + in_pos += 8; + if (old_seq > new_seq) { + status = TPM_FAIL; + goto abort_egress; + } + + UNPACK_IN(UINT32, &nr_seals); + UNPACK_IN(VPTR, &seal_bits, nr_seals * 20, UNPACK_ALIAS); + + UNPACK_IN(UINT32, &nr_kerns); + UNPACK_IN(VPTR, &kern_bits, nr_kerns * 20, UNPACK_ALIAS); + + // TODO handle saving larger lists on disk + if (nr_seals > NR_SEALS_PER_GROUP) { + status = TPM_SIZE; + goto abort_egress; + } + + if (nr_kerns > NR_KERNS_PER_GROUP) { + status = TPM_SIZE; + goto abort_egress; + } + + sha1(tpmcmd->req + hstart, in_pos - hstart, digest); - return status; + seals = calloc(nr_seals, sizeof(seals[0])); + + for(i=0; i < nr_seals; i++) { + TPM_PCR_SELECTION sel; + UNPACK_IN(TPM_PCR_SELECTION, &sel, UNPACK_ALIAS); + memcpy(&seals[i].digest_release, seal_bits, 20); + seal_bits += 20; + if (sel.sizeOfSelect > 4) { + status = TPM_BAD_PARAMETER; + goto abort_egress; + } + seals[i].pcr_selection = native_le32(0); + memcpy(&seals[i].pcr_selection, sel.pcrSelect, sel.sizeOfSelect); + } + + UNPACK_DONE(); + + tpmrsa_set_pubkey(&saa_rsa, group->id_data.saa_pubkey, 256, 0, 0); + rc = tpmrsa_sigcheck(&saa_rsa, sig, digest); + tpmrsa_free(&saa_rsa); + if (rc) { + printk("sigcheck failed: %d\n", rc); + status = rc; + goto abort_egress; + } + + // Commit + free(group->seals); + + memcpy(&group->seal_bits.kernels, kern_bits, 20 * nr_kerns); + group->details.cfg_seq = native_be64(new_seq); + group->nr_seals = nr_seals; + group->seals = seals; + group->seal_bits.nr_kerns = native_be32(nr_kerns); + + seals = NULL; + + group->flags &= ~MEM_GROUP_FLAG_SEAL_VALID; + if (group == g_mgr->groups[0].v) + g_mgr->root_seals_valid = 0; + + // TODO use GROUP_KEY_UPDATE or MGR_KEY_UPDATE here? + // only required if this update was to address a potential key leak + vtpm_sync_group(group, SEQ_UPDATE); + + abort_egress: + free(seals); + + pack_TPM_RSP_HEADER(tpmcmd->resp, VTPM_TAG_RSP, tpmcmd->resp_len, status); + return status; +} + +static TPM_RESULT vtpmmgr_VtpmList(tpmcmd_t* tpmcmd) +{ + CMD_BEGIN; + struct mem_group *group; + uint32_t vtpm_offset; + int i, j; + + UNPACK_GROUP(group); + UNPACK_IN(UINT32, &vtpm_offset); + + PACK_OUT(UINT32, group->nr_vtpms); + if (vtpm_offset > group->nr_vtpms) + goto egress; + + for(i=0; i < group->nr_pages; i++) { + struct mem_vtpm_page *pg = &group->data[i]; + for(j=0; j < pg->size; j++) { + if (vtpm_offset) { + // TODO a proper seek would be far faster + vtpm_offset--; + continue; + } + memcpy(PACK_BUF, pg->vtpms[j]->uuid, 16); + tpmcmd->resp_len += 16; + if (tpmcmd->resp_len + 16 > TCPA_MAX_BUFFER_LENGTH) + goto egress; + } + } + + egress: + CMD_END; +} + +static TPM_RESULT vtpmmgr_VtpmNew(tpmcmd_t* tpmcmd) +{ + CMD_BEGIN; + struct mem_group *group; + struct mem_vtpm *vtpm; + uuid_t newuuid; + int rc; + + UNPACK_GROUP(group); + + // XXX allow non-random UUIDs for testing + if (tpmcmd->req_len == 14 + 16) + UNPACK_IN(BUFFER, newuuid, 16); + else + gen_random_uuid(newuuid); + UNPACK_DONE(); + + rc = create_vtpm(group, &vtpm, newuuid); + if (rc) { + status = TPM_FAIL; + goto abort_egress; + } + memset(vtpm->data, 0, 64); + vtpm_sync(group, vtpm); + + PACK_OUT(BUFFER, newuuid, 16); + CMD_END; } +static TPM_RESULT vtpmmgr_VtpmDel(tpmcmd_t* tpmcmd) +{ + CMD_BEGIN; + uuid_t uuid; + struct mem_group *group; + struct mem_vtpm *vtpm; + int rc; + + UNPACK_IN(BUFFER, uuid, 16); + UNPACK_DONE(); + rc = find_vtpm(&group, &vtpm, uuid); + if (rc) { + status = TPM_FAIL; + goto abort_egress; + } + + if (vtpm->flags & VTPM_FLAG_OPEN) { + status = TPM_FAIL; + goto abort_egress; + } + + delete_vtpm(group, vtpm); + + CMD_END; +} + +static int vtpmmgr_permcheck(struct tpm_opaque *opq) +{ + if (!opq->vtpm) + return 1; + if (opq->vtpm->flags & VTPM_FLAG_ADMIN) + return 0; + return 1; +} TPM_RESULT vtpmmgr_handle_cmd( - const uuid_t uuid, - tpmcmd_t* tpmcmd) -{ - TPM_RESULT status = TPM_SUCCESS; - TPM_TAG tag; - UINT32 size; - TPM_COMMAND_CODE ord; - - unpack_TPM_RQU_HEADER(tpmcmd->req, - &tag, &size, &ord); - - /* Handle the command now */ - switch(tag) { - case VTPM_TAG_REQ: - //This is a vTPM command - switch(ord) { - case VTPM_ORD_SAVEHASHKEY: - return vtpmmgr_SaveHashKey(uuid, tpmcmd); - case VTPM_ORD_LOADHASHKEY: - return vtpmmgr_LoadHashKey(uuid, tpmcmd); - default: - vtpmlogerror(VTPM_LOG_VTPM, "Invalid vTPM Ordinal %" PRIu32 "\n", ord); - status = TPM_BAD_ORDINAL; - } - break; - case TPM_TAG_RQU_COMMAND: - case TPM_TAG_RQU_AUTH1_COMMAND: - case TPM_TAG_RQU_AUTH2_COMMAND: - //This is a TPM passthrough command - switch(ord) { - case TPM_ORD_GetRandom: - vtpmloginfo(VTPM_LOG_VTPM, "Passthrough: TPM_GetRandom\n"); - break; - case TPM_ORD_PcrRead: - vtpmloginfo(VTPM_LOG_VTPM, "Passthrough: TPM_PcrRead\n"); - break; - default: - vtpmlogerror(VTPM_LOG_VTPM, "TPM Disallowed Passthrough ord=%" PRIu32 "\n", ord); - status = TPM_DISABLED_CMD; - goto abort_egress; - } - - size = TCPA_MAX_BUFFER_LENGTH; - TPMTRYRETURN(TPM_TransmitData(tpmcmd->req, tpmcmd->req_len, tpmcmd->resp, &size)); - tpmcmd->resp_len = size; - - unpack_TPM_RESULT(tpmcmd->resp + sizeof(TPM_TAG) + sizeof(UINT32), &status); - return status; - - break; - default: - vtpmlogerror(VTPM_LOG_VTPM, "Invalid tag=%" PRIu16 "\n", tag); - status = TPM_BADTAG; - } + struct tpm_opaque *opaque, + tpmcmd_t* tpmcmd) +{ + TPM_RESULT status = TPM_SUCCESS; + TPM_TAG tag; + UINT32 size; + TPM_COMMAND_CODE ord; + + unpack_TPM_RQU_HEADER(tpmcmd->req, + &tag, &size, &ord); + + /* Handle the command now */ + switch(tag) { + case VTPM_TAG_REQ: + // This is a vTPM command + switch(ord) { + case VTPM_ORD_SAVEHASHKEY: + return vtpmmgr_SaveHashKey(opaque, tpmcmd); + case VTPM_ORD_LOADHASHKEY: + return vtpmmgr_LoadHashKey(opaque, tpmcmd); + case VTPM_ORD_GET_BOOT_HASH: + return vtpmmgr_GetBootHash(opaque, tpmcmd); + case VTPM_ORD_GET_QUOTE: + return vtpmmgr_GetQuote(opaque, tpmcmd); + default: + vtpmlogerror(VTPM_LOG_VTPM, "Invalid vTPM Ordinal %" PRIu32 "\n", ord); + status = TPM_BAD_ORDINAL; + } + break; + case VTPM_TAG_REQ2: + // This is a management command + if (vtpmmgr_permcheck(opaque)) { + status = TPM_AUTHFAIL; + vtpmlogerror(VTPM_LOG_VTPM, "Rejected attempt to use management command from client\n"); + break; + } + switch (ord) { + case VTPM_ORD_GROUP_LIST: + return vtpmmgr_GroupList(tpmcmd); + case VTPM_ORD_GROUP_NEW: + return vtpmmgr_GroupNew(tpmcmd); + case VTPM_ORD_GROUP_DEL: + return vtpmmgr_GroupDel(tpmcmd); + case VTPM_ORD_GROUP_ACTIVATE: + return vtpmmgr_GroupActivate(tpmcmd); + case VTPM_ORD_GROUP_REGISTER: + return vtpmmgr_GroupRegister(tpmcmd); + case VTPM_ORD_GROUP_UPDATE: + return vtpmmgr_GroupUpdate(tpmcmd); + case VTPM_ORD_GROUP_SHOW: + return vtpmmgr_GroupShow(tpmcmd); + case VTPM_ORD_VTPM_LIST: + return vtpmmgr_VtpmList(tpmcmd); + case VTPM_ORD_VTPM_NEW: + return vtpmmgr_VtpmNew(tpmcmd); + case VTPM_ORD_VTPM_DEL: + return vtpmmgr_VtpmDel(tpmcmd); + default: + vtpmlogerror(VTPM_LOG_VTPM, "Invalid TM Ordinal %" PRIu32 "\n", ord); + status = TPM_BAD_ORDINAL; + } + break; + case TPM_TAG_RQU_COMMAND: + case TPM_TAG_RQU_AUTH1_COMMAND: + case TPM_TAG_RQU_AUTH2_COMMAND: + //This is a TPM passthrough command + switch(ord) { + case TPM_ORD_GetRandom: + vtpmloginfo(VTPM_LOG_VTPM, "Passthrough: TPM_GetRandom\n"); + break; + case TPM_ORD_PcrRead: + vtpmloginfo(VTPM_LOG_VTPM, "Passthrough: TPM_PcrRead\n"); + // Quotes also need to be restricted to hide PCR values + break; + case TPM_ORD_Extend: + // TODO allow to certain clients? A malicious client + // could scramble PCRs and make future quotes invalid. + if (vtpmmgr_permcheck(opaque)) { + vtpmlogerror(VTPM_LOG_VTPM, "Disallowed TPM_Extend\n"); + } else { + vtpmloginfo(VTPM_LOG_VTPM, "Passthrough: TPM_Extend\n"); + } + break; + default: + vtpmlogerror(VTPM_LOG_VTPM, "TPM Disallowed Passthrough ord=%" PRIu32 "\n", ord); + status = TPM_DISABLED_CMD; + goto abort_egress; + } + + size = TCPA_MAX_BUFFER_LENGTH; + TPMTRYRETURN(TPM_TransmitData(tpmcmd->req, tpmcmd->req_len, tpmcmd->resp, &size)); + tpmcmd->resp_len = size; + + return TPM_SUCCESS; + default: + vtpmlogerror(VTPM_LOG_VTPM, "Invalid tag=%" PRIu16 "\n", tag); + status = TPM_BADTAG; + } abort_egress: - tpmcmd->resp_len = VTPM_COMMAND_HEADER_SIZE; - pack_TPM_RSP_HEADER(tpmcmd->resp, - tag + 3, tpmcmd->resp_len, status); + tpmcmd->resp_len = VTPM_COMMAND_HEADER_SIZE; + pack_TPM_RSP_HEADER(tpmcmd->resp, tag + 3, tpmcmd->resp_len, status); - return status; + return status; } diff --git a/stubdom/vtpmmgr/vtpm_disk.c b/stubdom/vtpmmgr/vtpm_disk.c new file mode 100644 index 0000000..a01633a --- /dev/null +++ b/stubdom/vtpmmgr/vtpm_disk.c @@ -0,0 +1,237 @@ +#include +#include +#include +#include +#include +#include +#include +#include + +#include "vtpm_manager.h" +#include "log.h" +#include "uuid.h" + +#include "vtpmmgr.h" +#include "vtpm_disk.h" +#include "disk_crypto.h" +#include "disk_format.h" +#include "disk_io.h" +#include "disk_tpm.h" + +struct mem_tpm_mgr *g_mgr; + +int vtpm_sync_disk(struct mem_tpm_mgr *mgr, int depth) +{ + int old_active_root = mgr->active_root; + int new_active_root = !old_active_root; + int rc = 0; + struct tpm_authdata prev; + struct mem_group *group0 = mgr->groups[0].v; + + // don't bother writing if we will never be able to read + if (!group0 || !group0->nr_seals) + return 0; + + mgr->sequence++; + mgr->active_root = new_active_root; + + switch (depth) { + case CTR_UPDATE: + { + uint32_t ctr = be32_native(mgr->counter_value); + mgr->counter_value = native_be32(ctr + 1); + break; + } + case MGR_KEY_UPDATE: + { + int i; + mgr->root_seals_valid = 0; + do_random(&mgr->tm_key, 16); + aes_setup(&mgr->tm_key_e, &mgr->tm_key); + do_random(&mgr->nv_key, 16); + for(i=0; i < mgr->nr_groups; i++) { + abort(); // TODO use raw re-encryption to handle unopened groups + } + break; + } + case CTR_AUTH_UPDATE: + mgr->root_seals_valid = 0; + memcpy(&prev, &mgr->counter_auth, 20); + do_random(&mgr->counter_auth, 20); + break; + case NV_AUTH_UPDATE: + mgr->root_seals_valid = 0; + memcpy(&prev, &mgr->nvram_auth, 20); + do_random(&mgr->nvram_auth, 20); + break; + } + + disk_write_all(mgr); + + switch (depth) { + case SEQ_UPDATE: + break; + + case CTR_UPDATE: + rc = TPM_disk_incr_counter(mgr->counter_index, mgr->counter_auth); + if (rc) { + uint32_t ctr = be32_native(mgr->counter_value); + mgr->counter_value = native_be32(ctr - 1); + mgr->active_root = old_active_root; + return rc; + } + break; + + case MGR_KEY_UPDATE: + rc = TPM_disk_nvwrite(&mgr->nv_key, 16, mgr->nvram_slot, mgr->nvram_auth); + if (rc) + abort(); + break; + + case CTR_AUTH_UPDATE: + rc = TPM_disk_change_counter(mgr->counter_index, prev, mgr->counter_auth); + if (rc) + abort(); + break; + + case NV_AUTH_UPDATE: + rc = TPM_disk_nvchange(mgr->nvram_slot, prev, mgr->nvram_auth); + if (rc) + abort(); + break; + } + + return rc; +} + +static struct mem_group_hdr* find_mem_group_hdr(struct mem_tpm_mgr *mgr, struct mem_group *group) +{ + int i; + for (i = 0; i < mgr->nr_groups; i++) { + struct mem_group_hdr *hdr = mgr->groups + i; + if (hdr->v == group) + return hdr; + } + return NULL; +} + +int vtpm_sync_group(struct mem_group *group, int depth) +{ + struct mem_group_hdr* hdr = find_mem_group_hdr(g_mgr, group); + uint64_t seq = be64_native(group->details.sequence); + + if (!hdr) + abort(); + + hdr->disk_loc.value = 0; + group->details.sequence = native_be64(1 + seq); + + if (depth == GROUP_KEY_UPDATE) { + int i; + do_random(&group->group_key, 16); + do_random(&group->rollback_mac_key, 16); + group->flags &= ~MEM_GROUP_FLAG_SEAL_VALID; + for (i = 0; i < group->nr_pages; i++) + group->data[i].disk_loc.value = 0; + depth = CTR_UPDATE; + } + + return vtpm_sync_disk(g_mgr, depth); +} + +static struct mem_vtpm_page* find_mem_vtpm_page(struct mem_group *group, struct mem_vtpm *vtpm) +{ + int pgidx = vtpm->index_in_parent / VTPMS_PER_SECTOR; + return group->data + pgidx; +} + +int vtpm_sync(struct mem_group *group, struct mem_vtpm *vtpm) +{ + struct mem_vtpm_page *pg = find_mem_vtpm_page(group, vtpm); + if (!pg) + return 1; + pg->disk_loc.value = 0; + return vtpm_sync_group(group, SEQ_UPDATE); +} + +/************************************************************************/ + +int create_vtpm(struct mem_group *group, struct mem_vtpm **vtpmp, const uuid_t uuid) +{ + int pgidx = group->nr_vtpms / VTPMS_PER_SECTOR; + int vtidx = group->nr_vtpms % VTPMS_PER_SECTOR; + struct mem_vtpm *vtpm = calloc(1, sizeof(*vtpm)); + + struct mem_vtpm_page *page = group->data + pgidx; + if (pgidx >= group->nr_pages) { + if (pgidx != group->nr_pages) + abort(); // nr_vtpms inconsistent with nr_pages + group->nr_pages++; + group->data = realloc(group->data, group->nr_pages * sizeof(*page)); + page = group->data + pgidx; + memset(page, 0, sizeof(*page)); + } + if (page->size != vtidx) + abort(); // nr_vtpms inconsistent with page->size + page->size++; + + page->vtpms[vtidx] = vtpm; + vtpm->index_in_parent = group->nr_vtpms; + vtpm->flags = 0; + + group->nr_vtpms++; + + memcpy(vtpm->uuid, uuid, 16); + *vtpmp = vtpm; + return 0; +} + +int delete_vtpm(struct mem_group *group, struct mem_vtpm *vtpm) +{ + struct mem_vtpm_page *pg = find_mem_vtpm_page(group, vtpm); + struct mem_vtpm_page *last_pg = group->data + (group->nr_pages - 1); + struct mem_vtpm *last = last_pg->vtpms[last_pg->size - 1]; + int vtidx = vtpm->index_in_parent % VTPMS_PER_SECTOR; + + if (vtpm->flags & VTPM_FLAG_OPEN) + return 1; + + last->index_in_parent = vtpm->index_in_parent; + pg->vtpms[vtidx] = last; + pg->disk_loc.value = 0; + + last_pg->vtpms[last_pg->size - 1] = NULL; + last_pg->disk_loc.value = 0; + last_pg->size--; + + if (last_pg->size == 0) + group->nr_pages--; + group->nr_vtpms--; + free(vtpm); + return 0; +} + +int find_vtpm(struct mem_group **groupp, struct mem_vtpm **vtpmp, const uuid_t uuid) +{ + struct mem_group *group; + int i, j, k; + + for (i = 0; i < g_mgr->nr_groups; i++) { + group = g_mgr->groups[i].v; + if (!group) + continue; + for (j = 0; j < group->nr_pages; j++) { + struct mem_vtpm_page *pg = &group->data[j]; + for (k = 0; k < pg->size; k++) { + struct mem_vtpm *vt = pg->vtpms[k]; + if (!memcmp(uuid, vt->uuid, 16)) { + *groupp = group; + *vtpmp = vt; + return 0; + } + } + } + } + + return 1; +} diff --git a/stubdom/vtpmmgr/vtpm_disk.h b/stubdom/vtpmmgr/vtpm_disk.h new file mode 100644 index 0000000..a567265 --- /dev/null +++ b/stubdom/vtpmmgr/vtpm_disk.h @@ -0,0 +1,233 @@ +#ifndef __VTPM_DISK_H +#define __VTPM_DISK_H + +#include "uuid.h" +#include +#include "endian_int.h" + +/* Type for disk sector indexes */ +typedef be32_t sector_t; + +/* A TPM authdata entry (160 random bits) */ +struct tpm_authdata { + uint8_t bits[20]; +}; + +/* 160-bit hash (SHA-1) */ +struct hash160 { + uint8_t bits[20]; +}; + +/* 256-bit hash (either SHA256 or SHA512-256) */ +struct hash256 { + uint8_t bits[32]; +}; + +/* 128-bit MAC (AES-128 CMAC) */ +struct mac128 { + uint8_t bits[16]; +}; + +struct key128 { + uint8_t bits[16]; +}; + +/********************************************************************/ + +/** + * Unique identifying information for a vTPM group. Once a group has been + * created, this data will be constant. + * + * This structure a component of struct disk_group_sector, stored directly. + */ +struct group_id_data { + uuid_t uuid; + uint8_t saa_pubkey[256]; + uint8_t tpm_aik_public[256]; + uint8_t tpm_aik_edata[256]; + struct hash256 rollback_pubkey_hash; +}; + +/** + * Details of a vTPM group that change during normal operation. + * + * This structure a component of struct disk_group_sector, stored directly. + */ +struct group_details { + be64_t sequence; + be64_t cfg_seq; + be64_t flags; +#define FLAG_ROLLBACK_DETECTED 1 + + /* Seal(recovery_seal, PCR16 = H(RECOVERY_KEY)) */ + uint8_t recovery_data[256]; +}; + +/** + * The required input to TPM_Unseal to obtain key data + * + * This structure a component of several disk structures, stored directly. + */ +struct disk_seal_entry { + le32_t pcr_selection; + struct hash160 digest_at_seal; + struct hash160 digest_release; + uint8_t sealed_data[256]; +}; + +/** + * A vTPM group's configuration list and sealed key data + * + * This structure a component of struct disk_group_sector, stored directly. + */ +struct disk_group_boot_config_list { +#define NR_SEALS_PER_GROUP 5 + be32_t nr_cfgs; + struct disk_seal_entry entry[NR_SEALS_PER_GROUP]; +#define NR_KERNS_PER_GROUP 16 + be32_t nr_kerns; + struct hash160 kernels[NR_KERNS_PER_GROUP]; + + /* TODO support overflow of either nr_cfgs or nr_kerns */ + struct hash256 next; +}; + +/********************************************************************/ + +#define VTPM_FLAG_ADMIN 1 +#define VTPM_FLAG_DISK_MASK (0xFFFF) +#define VTPM_FLAG_OPEN (1UL<<31) + +/** + * A single vTPM's in-memory data. Do not free if the open flag is set. + */ +struct mem_vtpm { + uuid_t uuid; + uint8_t data[64]; + uint32_t flags; + uint32_t index_in_parent; +}; + +/** + * Shortened form of struct disk_seal_entry + */ +struct mem_seal { + le32_t pcr_selection; + struct hash160 digest_release; +}; + +/** + * Maximum number of vTPMs in one sector on the disk. + * + * 20 + 64 = 84 bytes per vTPM; 32 bytes overhead from IVs + * 48*84 + 32 = 4064 bytes + */ +#define VTPMS_PER_SECTOR 48 + +/** + * Decrypted and unpacked version of struct disk_vtpm_sector + */ +struct mem_vtpm_page { + struct hash256 disk_hash; + sector_t disk_loc; + int size; + + struct mem_vtpm *vtpms[VTPMS_PER_SECTOR]; +}; + +/** + * In-memory representation of an open vTPM group + */ +struct mem_group { + struct group_id_data id_data; + struct group_details details; + + /* Obtained from sealed data */ + struct tpm_authdata aik_authdata; + struct key128 group_key; + struct key128 rollback_mac_key; + + int nr_vtpms; + int nr_pages; + struct mem_vtpm_page *data; + + int flags; +#define MEM_GROUP_FLAG_SEAL_VALID 1 +#define MEM_GROUP_FLAG_FIRSTBOOT 2 + int nr_seals; + struct mem_seal *seals; + + sector_t seal_next_loc; + struct disk_group_boot_config_list seal_bits; +}; + +/** + * In-memory representation of a vTPM group (open or not) + */ +struct mem_group_hdr { + sector_t disk_loc; + struct hash256 disk_hash; + + int disk_nr_inuse; + sector_t *disk_inuse; + + struct mem_group *v; +}; + +/** + * In-memory representation of the TPM Manager's permanent data + */ +struct mem_tpm_mgr { + struct key128 tm_key; + aes_context tm_key_e; + struct key128 nv_key; + uuid_t uuid; + + be32_t nvram_slot; + struct tpm_authdata nvram_auth; + be32_t counter_index; + struct tpm_authdata counter_auth; + be32_t counter_value; + + uint64_t sequence; + + int active_root; + + int nr_groups; + struct mem_group_hdr *groups; + + int root_seals_valid; +}; + +int vtpm_storage_init(void); +int vtpm_load_disk(void); +int vtpm_new_disk(void); + +enum vtpm_sync_depth { + SEQ_UPDATE, /* Just the soft sequence number */ + CTR_UPDATE, /* Sequence and TPM counter */ + GROUP_KEY_UPDATE, /* Group key (and TPM counter) */ + MGR_KEY_UPDATE, /* Manager key */ + CTR_AUTH_UPDATE, /* TPM counter authdata */ + NV_AUTH_UPDATE /* NVRAM authdata */ +}; + +/* + * For a full manager key flush, use this ordering of writes: + * MGR_KEY_UPDATE + * CTR_AUTH_UPDATE + * NV_AUTH_UPDATE + * CTR_UPDATE or GROUP_KEY_UPDATE + */ + +extern struct mem_tpm_mgr *g_mgr; + +int vtpm_sync_disk(struct mem_tpm_mgr *mgr, int depth); +int vtpm_sync_group(struct mem_group *group, int depth); +int vtpm_sync(struct mem_group *group, struct mem_vtpm *vtpm); + +int create_vtpm(struct mem_group *group, struct mem_vtpm **vtpmp, const uuid_t uuid); +int delete_vtpm(struct mem_group *group, struct mem_vtpm *vtpm); +int find_vtpm(struct mem_group **groupp, struct mem_vtpm **vtpmp, const uuid_t uuid); + +#endif diff --git a/stubdom/vtpmmgr/vtpm_manager.h b/stubdom/vtpmmgr/vtpm_manager.h index a2bbcca..156c2ce 100644 --- a/stubdom/vtpmmgr/vtpm_manager.h +++ b/stubdom/vtpmmgr/vtpm_manager.h @@ -38,7 +38,9 @@ #define VTPM_MANAGER_H #define VTPM_TAG_REQ 0x01c1 +#define VTPM_TAG_REQ2 0x01c2 #define VTPM_TAG_RSP 0x01c4 +#define VTPM_TAG_RSP2 0x01c5 #define COMMAND_BUFFER_SIZE 4096 // Header size @@ -46,12 +48,391 @@ //************************ Command Codes **************************** #define VTPM_ORD_BASE 0x0000 -#define VTPM_PRIV_MASK 0x01000000 // Priviledged VTPM Command -#define VTPM_PRIV_BASE (VTPM_ORD_BASE | VTPM_PRIV_MASK) +#define TPM_VENDOR_COMMAND 0x02000000 // TPM Main, part 2, section 17. +#define VTPM_PRIV_BASE (VTPM_ORD_BASE | TPM_VENDOR_COMMAND) + +/* + * Non-priviledged VTPM Commands: + * + * The PCRs available to read, extend, or quote may be limited to a given vTPM + * based on a local security policy (this is not yet implemented). + * + * vTPMs may request the following commands which will be forwarded directly to + * the physical TPM: + * + * TPM_ORD_GetRandom + * TPM_ORD_PcrRead + * TPM_ORD_Extend + * + * In addition, the following command are available to all vTPMs: + */ + +/** + * Store a persistent key blob to TPM Manager storage + * Input: + * TPM_TAG tag VTPM_TAG_REQ + * UINT32 paramSize total size + * UINT32 ordinal VTPM_ORD_SAVEHASHKEY + * BYTE[] keyblob 52 or 64 bytes of key data + * Output: + * TPM_TAG tag VTPM_TAG_RSP + * UINT32 paramSize total size + * UINT32 status return code + */ +#define VTPM_ORD_SAVEHASHKEY (VTPM_ORD_BASE + 1) +/** + * Load the persistent key blob from TPM Manager storage + * Input: + * TPM_TAG tag VTPM_TAG_REQ + * UINT32 paramSize total size + * UINT32 ordinal VTPM_ORD_LOADHASHKEY + * Output: + * TPM_TAG tag VTPM_TAG_RSP + * UINT32 paramSize total size + * UINT32 status return code + * BYTE[] keyblob 52 or 64 bytes of key data + */ +#define VTPM_ORD_LOADHASHKEY (VTPM_ORD_BASE + 2) +/** + * Get a kernel hash of the control domain for this vTPM + * Input: + * TPM_TAG tag VTPM_TAG_REQ + * UINT32 paramSize total size + * UINT32 ordinal VTPM_ORD_GET_BOOT_HASH + * Output: + * TPM_TAG tag VTPM_TAG_RSP + * UINT32 paramSize total size + * UINT32 status return code + * TPM_DIGEST digest hash for the initial extend of PCR0 + */ +#define VTPM_ORD_GET_BOOT_HASH (VTPM_ORD_BASE + 3) +/** + * Get a hardware TPM quote for this vTPM. The quote will use the AIK + * associated with the group this vTPM was created in. Values specific to the + * vTPM will be extended to certain resettable PCRs. + * + * Input: + * TPM_TAG tag VTPM_TAG_REQ + * UINT32 paramSize total size + * UINT32 ordinal VTPM_ORD_GET_QUOTE + * TPM_NONCE externData Data to be quoted + * PCR_SELECTION quoteSelect PCR selection for quote. + * Output: + * TPM_TAG tag VTPM_TAG_RSP + * UINT32 paramSize total size + * UINT32 status return code + * BYTE[] signature 256 bytes of signature data + * TPM_PCRVALUE[] pcrValues Values of PCRs selected by the request + */ +#define VTPM_ORD_GET_QUOTE (VTPM_ORD_BASE + 4) + +/* + * Resettable PCR values in TPM Manager quotes (VTPM_ORD_GET_QUOTE): + * + * PCR#16: + * unused - debug PCR + * + * PCR#17-19: (cannot be reset by locality 2) + * DRTM measurements + * + * PCR#20: Remains constant over the life of the vTPM group + * SHA1(SAA pubkey) + * + * PCR#21: May change during the life; must be approved by SAA + * SHA1(TPM_MGR_CFG_LIST) + * + * PCR#22: May change during the life; must be in the cfg_list + * vTPM kernel build hash (truncated SHA256) + * Note: this is currently set to 20 zero bytes + * + * PCR#23: Remains constant over the life of the vTPM; system-specific + * group UUID || 00 00 00 00 + * vTPM UUID || 00 00 00 00 + * + * + * Group-only PCR values (VTPM_ORD_GROUP_*) are the same except: + * + * PCR#22: unused (value is zero) + * PCR#23: + * group UUID || 00 00 00 00 + * + * The value of externalData for quotes using these PCRs is defined below; it is + * always a hash whose first 4 bytes identify the rest of the structure. + * + * + * The configuration list signed by a System Approval Agent (SAA) is: + * + * TPM_MGR_CFG_LIST: + * UINT64 sequence Monotonic sequence number + * UINT32 pltCfgSize Size of pltCfgs array + * TPM_COMPOSITE_HASH[] pltCfgs Valid platform configurations + * UINT32 kernSize Size of kernList array + * TPM_HASH[] kernList Valid vTPM kernels + */ + +/************************************\ + * TPM Manager Management Interface * +\************************************/ + +/** + * List groups + * + * Input: + * TPM_TAG tag VTPM_TAG_REQ2 + * UINT32 paramSize total size + * UINT32 ordinal VTPM_ORD_GROUP_LIST + * Output: + * TPM_TAG tag VTPM_TAG_RSP + * UINT32 paramSize total size + * UINT32 status return code + * UINT32 count number of valid groups + */ +#define VTPM_ORD_GROUP_LIST (VTPM_PRIV_BASE + 0x101) +/** + * Create a group + * + * Input: + * TPM_TAG tag VTPM_TAG_REQ2 + * UINT32 paramSize total size + * UINT32 ordinal VTPM_ORD_GROUP_NEW + * TPM_CHOSENID_HASH labelDigest Data for the privacy CA + * BYTE[256] SAASigKey RSA public signature key for the SAA + * Output: + * TPM_TAG tag VTPM_TAG_RSP + * UINT32 paramSize total size + * UINT32 status return code + * BYTE[16] groupUUID UUID for the group + * BYTE[256] aikPubKey Public key of the AIK + * BYTE[256] aikBinding TPM_IDENTITY_CONTENTS signature + */ +#define VTPM_ORD_GROUP_NEW (VTPM_PRIV_BASE + 0x102) +/** + * Delete a group + * + * Input: + * TPM_TAG tag VTPM_TAG_REQ2 + * UINT32 paramSize total size + * UINT32 ordinal VTPM_ORD_GROUP_DEL + * UINT32 groupID ID of the group to delete + * Output: + * TPM_TAG tag VTPM_TAG_RSP + * UINT32 paramSize total size + * UINT32 status return code + */ +#define VTPM_ORD_GROUP_DEL (VTPM_PRIV_BASE + 0x103) +/** + * Activate the group's AIK (message from privacy CA) + * + * Input: + * TPM_TAG tag VTPM_TAG_REQ2 + * UINT32 paramSize total size + * UINT32 ordinal VTPM_ORD_GROUP_ACTIVATE + * UINT32 groupID ID of the group to activate + * UINT32 blobSize + * BYTE[] blob Blob from the privay CA + * Output: + * TPM_TAG tag VTPM_TAG_RSP + * UINT32 paramSize total size + * UINT32 status return code + * TPM_SYMMETRIC_KEY key Output from TPM_ActivateIdentity + */ +#define VTPM_ORD_GROUP_ACTIVATE (VTPM_PRIV_BASE + 0x104) +/** + * Register this TPM manager slot with the SAA and provision its recovery data. + * The initial registration must be done with no reboots between the creation of + * the group and the execution of this command; it can only be done once. + * + * The ExternalData value is SHA1("REGR" || dhkx_1 || dhkx_2 || recoverBlob) + * + * Input: + * TPM_TAG tag VTPM_TAG_REQ2 + * UINT32 paramSize total size + * UINT32 ordinal VTPM_ORD_GROUP_REGISTER + * UINT32 groupID ID of the group to register + * BYTE[256] dhkx_1 One half of a diffie-hellman key exchange + * BYTE[256] SAAProof Signature (using SAASigKey) of derivData + * PCR_SELECTION quoteSelect PCR selection for quote. + * Output: + * TPM_TAG tag VTPM_TAG_RSP + * UINT32 paramSize total size + * UINT32 status return code + * BYTE[256] dhkx_2 One half of a diffie-hellman key exchange + * BYTE[32] recoverBlob Encrypted blob (using key derived from DH) + * BYTE[256] regProof Quote using the group's AIK + */ +#define VTPM_ORD_GROUP_REGISTER (VTPM_PRIV_BASE + 0x105) +/** + * Update the configuration list + * + * Input: + * TPM_TAG tag VTPM_TAG_REQ2 + * UINT32 paramSize total size + * UINT32 ordinal VTPM_ORD_GROUP_UPDATE + * UINT32 groupID ID of the group to update + * BYTE[256] cfgListSig Signature (using SAASigKey) of cfgList + * TPM_MGR_CFG_LIST cfgList Configurations the group is valid in + * PCR_SELECTION[] selForCfgs PCR selections used in the cfgList.pltCfgs + * Output: + * TPM_TAG tag VTPM_TAG_RSP + * UINT32 paramSize total size + * UINT32 status return code + */ +#define VTPM_ORD_GROUP_UPDATE (VTPM_PRIV_BASE + 0x106) +/** + * Get the current contents of the group structure. + * + * Input: + * TPM_TAG tag VTPM_TAG_REQ2 + * UINT32 paramSize total size + * UINT32 ordinal VTPM_ORD_GROUP_SHOW + * UINT32 groupID ID of the group to view + * Output: + * TPM_TAG tag VTPM_TAG_RSP + * UINT32 paramSize total size + * UINT32 status return code + * BYTE[16] groupUUID UUID for the group + * BYTE[256] pubkey public key of the SAA + * TPM_MGR_CFG_LIST cfgList current list for this group + */ +#define VTPM_ORD_GROUP_SHOW (VTPM_PRIV_BASE + 0x107) +/** + * Get a quote of the current status of the TMA structure. This can be used to + * prove that an update has been applied; it is similar to VTPM_ORD_GET_QUOTE, + * but does not include measurements specific to any vTPM. + * + * The ExternalData value for the quote is SHA1("SHOW" || nonce) + * + * Input: + * TPM_TAG tag VTPM_TAG_REQ2 + * UINT32 paramSize total size + * UINT32 ordinal VTPM_ORD_GROUP_QUOTE + * UINT32 groupID ID of the group to view + * TPM_NONCE nonce Anti-replay + * PCR_SELECTION quoteSelect PCR selection for quote. + * Output: + * TPM_TAG tag VTPM_TAG_RSP + * UINT32 paramSize total size + * UINT32 status return code + * BYTE[] signature 256 bytes of signature data + * TPM_PCRVALUE[] pcrValues Values of PCRs selected by the request + */ +#define VTPM_ORD_GROUP_QUOTE (VTPM_PRIV_BASE + 0x108) +/** + * Prepare to use recovery data to open a currently-closed group. + * + * The ExternalData value is SHA1("RCVR" || nonce || dhkx_1) + * + * Input: + * TPM_TAG tag VTPM_TAG_REQ2 + * UINT32 paramSize total size + * UINT32 ordinal VTPM_ORD_GROUP_RECOVER1 + * UINT32 groupID ID of the group to recover + * TPM_KEY proxyAIK AIK to use for recovery quote + * TPM_NONCE nonce Anti-replay by challenger + * PCR_SELECTION quoteSelect PCR selection for quote + * Output: + * TPM_TAG tag VTPM_TAG_RSP + * UINT32 paramSize total size + * UINT32 status return code + * BYTE[256] dhkx_1 One half of a diffie-hellman key exchange + * BYTE[256] signature quote using proxyAIK + */ +#define VTPM_ORD_GROUP_RECOVER1 (VTPM_PRIV_BASE + 0x109) +/** + * Use recovery data to open a currently-closed group + * + * Input: + * TPM_TAG tag VTPM_TAG_REQ2 + * UINT32 paramSize total size + * UINT32 ordinal VTPM_ORD_GROUP_RECOVER2 + * UINT32 groupID ID of the group to recover + * BYTE[256] dhkx_2 One half of a diffie-hellman key exchange + * BYTE[32] recoverBlob Encrypted blob (using key derived from DH) + * Output: + * TPM_TAG tag VTPM_TAG_RSP + * UINT32 paramSize total size + * UINT32 status return code + */ +#define VTPM_ORD_GROUP_RECOVER2 (VTPM_PRIV_BASE + 0x10A) + +/** + * List the UUIDs of vTPMs in an group. Multiple calls may be required to list + * all the vTPMs in an group; if the returned list is shorter than totalCount + * would imply, additional requests using the offest will be required + * to build the full list. + * + * Input: + * TPM_TAG tag VTPM_TAG_REQ2 + * UINT32 paramSize total size + * UINT32 ordinal VTPM_ORD_VTPM_LIST + * UINT32 groupID ID of the group to list + * UINT32 offset Offset to start the list at + * Output: + * TPM_TAG tag VTPM_TAG_RSP + * UINT32 paramSize total size + * UINT32 status return code + * UINT32 totalCount Count of all vTPMs under this group + * BYTE[] uuids List of UUIDs (16 bytes each) + */ +#define VTPM_ORD_VTPM_LIST (VTPM_PRIV_BASE + 0x201) +#define VTPM_ORD_VTPM_SHOW (VTPM_PRIV_BASE + 0x202) +#define VTPM_ORD_VTPM_EDIT (VTPM_PRIV_BASE + 0x203) +/** + * Input: + * TPM_TAG tag VTPM_TAG_REQ2 + * UINT32 paramSize total size + * UINT32 ordinal VTPM_ORD_VTPM_NEW + * UINT32 groupID ID of the group to modify + * Output: + * TPM_TAG tag VTPM_TAG_RSP + * UINT32 paramSize total size + * UINT32 status return code + * BYTE[16] vtpmUUID UUID for the vTPM + */ +#define VTPM_ORD_VTPM_NEW (VTPM_PRIV_BASE + 0x204) +/** + * Input: + * TPM_TAG tag VTPM_TAG_REQ2 + * UINT32 paramSize total size + * UINT32 ordinal VTPM_ORD_VTPM_DEL + ## UINT32 groupID ID of the group to modify + * BYTE[16] vtpmUUID UUID for the vTPM to delete + * Output: + * TPM_TAG tag VTPM_TAG_RSP + * UINT32 paramSize total size + * UINT32 status return code + */ +#define VTPM_ORD_VTPM_DEL (VTPM_PRIV_BASE + 0x205) + +/** + * Generate an unbound AIK for the pTPM + * + * This unbound AIK can be used in the GROUP_RECOVER1 operation. + */ +#define VTPM_ORD_MakeIdentity (VTPM_PRIV_BASE + 0x301) +/** + * Activate an unbound AIK for the pTPM + */ +#define VTPM_ORD_ActivateIdentity (VTPM_PRIV_BASE + 0x302) +/** + * Get the EK from the pTPM + * + * Used for any AIK activation + */ +#define VTPM_ORD_ReadPubek (VTPM_PRIV_BASE + 0x303) +/** + * Define an NVRAM slot + */ +#define VTPM_NV_DefineSpace (VTPM_PRIV_BASE + 0x304) +/** + * Write to NVRAM + */ +#define VTPM_NV_WriteValue (VTPM_PRIV_BASE + 0x305) +/** + * Read from NVRAM + */ +#define VTPM_NV_ReadValue (VTPM_PRIV_BASE + 0x306) -// Non-priviledged VTPM Commands (From DMI's) -#define VTPM_ORD_SAVEHASHKEY (VTPM_ORD_BASE + 1) // DMI requests encryption key for persistent storage -#define VTPM_ORD_LOADHASHKEY (VTPM_ORD_BASE + 2) // DMI requests symkey to be regenerated //************************ Return Codes **************************** #define VTPM_SUCCESS 0 diff --git a/stubdom/vtpmmgr/vtpm_storage.c b/stubdom/vtpmmgr/vtpm_storage.c deleted file mode 100644 index de21b4a..0000000 --- a/stubdom/vtpmmgr/vtpm_storage.c +++ /dev/null @@ -1,794 +0,0 @@ -/* - * Copyright (c) 2010-2012 United States Government, as represented by - * the Secretary of Defense. All rights reserved. - * - * THIS SOFTWARE AND ITS DOCUMENTATION ARE PROVIDED AS IS AND WITHOUT - * ANY EXPRESS OR IMPLIED WARRANTIES WHATSOEVER. ALL WARRANTIES - * INCLUDING, BUT NOT LIMITED TO, PERFORMANCE, MERCHANTABILITY, FITNESS - * FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT ARE HEREBY - * DISCLAIMED. USERS ASSUME THE ENTIRE RISK AND LIABILITY OF USING THE - * SOFTWARE. - */ - -/*************************************************************** - * DISK IMAGE LAYOUT - * ************************************************************* - * All data is stored in BIG ENDIAN format - * ************************************************************* - * Section 1: Header - * - * 10 bytes id ID String "VTPMMGRDOM" - * uint32_t version Disk Image version number (current == 1) - * uint32_t storage_key_len Length of the storage Key - * TPM_KEY storage_key Marshalled TPM_KEY structure (See TPM spec v2) - * RSA_BLOCK aes_crypto Encrypted aes key data (RSA_CIPHER_SIZE bytes), bound by the storage_key - * BYTE[32] aes_key Aes key for encrypting the uuid table - * uint32_t cipher_sz Encrypted size of the uuid table - * - * ************************************************************* - * Section 2: Uuid Table - * - * This table is encrypted by the aes_key in the header. The cipher text size is just - * large enough to hold all of the entries plus required padding. - * - * Each entry is as follows - * BYTE[16] uuid Uuid of a vtpm that is stored on this disk - * uint32_t offset Disk offset where the vtpm data is stored - * - * ************************************************************* - * Section 3: Vtpm Table - * - * The rest of the disk stores vtpms. Each vtpm is an RSA_BLOCK encrypted - * by the storage key. Each vtpm must exist on an RSA_BLOCK aligned boundary, - * starting at the first RSA_BLOCK aligned offset after the uuid table. - * As the uuid table grows, vtpms may be relocated. - * - * RSA_BLOCK vtpm_crypto Vtpm data encrypted by storage_key - * BYTE[20] hash Sha1 hash of vtpm encrypted data - * BYTE[16] vtpm_aes_key Encryption key for vtpm data - * - ************************************************************* - */ -#define DISKVERS 1 -#define IDSTR "VTPMMGRDOM" -#define IDSTRLEN 10 -#define AES_BLOCK_SIZE 16 -#define AES_KEY_BITS 256 -#define AES_KEY_SIZE (AES_KEY_BITS/8) -#define BUF_SIZE 4096 - -#define UUID_TBL_ENT_SIZE (sizeof(uuid_t) + sizeof(uint32_t)) - -#define HEADERSZ (10 + 4 + 4) - -#define TRY_READ(buf, size, msg) do {\ - int rc; \ - if((rc = read(blkfront_fd, buf, (size))) != (size)) { \ - vtpmlogerror(VTPM_LOG_VTPM, "read() failed! " msg " : rc=(%d/%d), error=(%s)\n", rc, (int)(size), strerror(errno)); \ - status = TPM_IOERROR;\ - goto abort_egress;\ - } \ -} while(0) - -#define TRY_WRITE(buf, size, msg) do {\ - int rc; \ - if((rc = write(blkfront_fd, buf, (size))) != (size)) { \ - vtpmlogerror(VTPM_LOG_VTPM, "write() failed! " msg " : rc=(%d/%d), error=(%s)\n", rc, (int)(size), strerror(errno)); \ - status = TPM_IOERROR;\ - goto abort_egress;\ - } \ -} while(0) - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "vtpm_manager.h" -#include "log.h" -#include "marshal.h" -#include "tpm.h" -#include "uuid.h" - -#include "vtpmmgr.h" -#include "vtpm_storage.h" - -#define MAX(a,b) ( ((a) > (b)) ? (a) : (b) ) -#define MIN(a,b) ( ((a) < (b)) ? (a) : (b) ) - -/* blkfront device objets */ -static struct blkfront_dev* blkdev = NULL; -static int blkfront_fd = -1; - -struct Vtpm { - uuid_t uuid; - int offset; -}; -struct Storage { - int aes_offset; - int uuid_offset; - int end_offset; - - int num_vtpms; - int num_vtpms_alloced; - struct Vtpm* vtpms; -}; - -/* Global storage data */ -static struct Storage g_store = { - .vtpms = NULL, -}; - -static int get_offset(void) { - return lseek(blkfront_fd, 0, SEEK_CUR); -} - -static void reset_store(void) { - g_store.aes_offset = 0; - g_store.uuid_offset = 0; - g_store.end_offset = 0; - - g_store.num_vtpms = 0; - g_store.num_vtpms_alloced = 0; - free(g_store.vtpms); - g_store.vtpms = NULL; -} - -static int vtpm_get_index(const uuid_t uuid) { - int st = 0; - int ed = g_store.num_vtpms-1; - while(st <= ed) { - int mid = ((unsigned int)st + (unsigned int)ed) >> 1; //avoid overflow - int c = memcmp(uuid, &g_store.vtpms[mid].uuid, sizeof(uuid_t)); - if(c == 0) { - return mid; - } else if(c > 0) { - st = mid + 1; - } else { - ed = mid - 1; - } - } - return -(st + 1); -} - -static void vtpm_add(const uuid_t uuid, int offset, int index) { - /* Realloc more space if needed */ - if(g_store.num_vtpms >= g_store.num_vtpms_alloced) { - g_store.num_vtpms_alloced += 16; - g_store.vtpms = realloc( - g_store.vtpms, - sizeof(struct Vtpm) * g_store.num_vtpms_alloced); - } - - /* Move everybody after the new guy */ - for(int i = g_store.num_vtpms; i > index; --i) { - g_store.vtpms[i] = g_store.vtpms[i-1]; - } - - vtpmloginfo(VTPM_LOG_VTPM, "Registered vtpm " UUID_FMT "\n", UUID_BYTES(uuid)); - - /* Finally add new one */ - memcpy(g_store.vtpms[index].uuid, uuid, sizeof(uuid_t)); - g_store.vtpms[index].offset = offset; - ++g_store.num_vtpms; -} - -#if 0 -static void vtpm_remove(int index) { - for(i = index; i < g_store.num_vtpms; ++i) { - g_store.vtpms[i] = g_store.vtpms[i+1]; - } - --g_store.num_vtpms; -} -#endif - -static int pack_uuid_table(uint8_t* table, int size, int* nvtpms) { - uint8_t* ptr = table; - while(*nvtpms < g_store.num_vtpms && size >= 0) - { - /* Pack the uuid */ - memcpy(ptr, (uint8_t*)g_store.vtpms[*nvtpms].uuid, sizeof(uuid_t)); - ptr+= sizeof(uuid_t); - - - /* Pack the offset */ - ptr = pack_UINT32(ptr, g_store.vtpms[*nvtpms].offset); - - ++*nvtpms; - size -= UUID_TBL_ENT_SIZE; - } - return ptr - table; -} - -/* Extract the uuids */ -static int extract_uuid_table(uint8_t* table, int size) { - uint8_t* ptr = table; - for(;size >= UUID_TBL_ENT_SIZE; size -= UUID_TBL_ENT_SIZE) { - int index; - uint32_t v32; - - /*uuid_t is just an array of bytes, so we can do a direct cast here */ - uint8_t* uuid = ptr; - ptr += sizeof(uuid_t); - - /* Get the offset of the key */ - ptr = unpack_UINT32(ptr, &v32); - - /* Insert the new vtpm in sorted order */ - if((index = vtpm_get_index(uuid)) >= 0) { - vtpmlogerror(VTPM_LOG_VTPM, "Vtpm (" UUID_FMT ") exists multiple times! ignoring...\n", UUID_BYTES(uuid)); - continue; - } - index = -index -1; - - vtpm_add(uuid, v32, index); - - } - return ptr - table; -} - -static void vtpm_decrypt_block(aes_context* aes, - uint8_t* iv, - uint8_t* cipher, - uint8_t* plain, - int cipher_sz, - int* overlap) -{ - int bytes_ext; - /* Decrypt */ - aes_crypt_cbc(aes, AES_DECRYPT, - cipher_sz, - iv, cipher, plain + *overlap); - - /* Extract */ - bytes_ext = extract_uuid_table(plain, cipher_sz + *overlap); - - /* Copy left overs to the beginning */ - *overlap = cipher_sz + *overlap - bytes_ext; - memcpy(plain, plain + bytes_ext, *overlap); -} - -static int vtpm_encrypt_block(aes_context* aes, - uint8_t* iv, - uint8_t* plain, - uint8_t* cipher, - int block_sz, - int* overlap, - int* num_vtpms) -{ - int bytes_to_crypt; - int bytes_packed; - - /* Pack the uuid table */ - bytes_packed = *overlap + pack_uuid_table(plain + *overlap, block_sz - *overlap, num_vtpms); - bytes_to_crypt = MIN(bytes_packed, block_sz); - - /* Add padding if we aren't on a multiple of the block size */ - if(bytes_to_crypt & (AES_BLOCK_SIZE-1)) { - int oldsz = bytes_to_crypt; - //add padding - bytes_to_crypt += AES_BLOCK_SIZE - (bytes_to_crypt & (AES_BLOCK_SIZE-1)); - //fill padding with random bytes - vtpmmgr_rand(plain + oldsz, bytes_to_crypt - oldsz); - *overlap = 0; - } else { - *overlap = bytes_packed - bytes_to_crypt; - } - - /* Encrypt this chunk */ - aes_crypt_cbc(aes, AES_ENCRYPT, - bytes_to_crypt, - iv, plain, cipher); - - /* Copy the left over partials to the beginning */ - memcpy(plain, plain + bytes_to_crypt, *overlap); - - return bytes_to_crypt; -} - -static TPM_RESULT vtpm_storage_new_vtpm(const uuid_t uuid, int index) { - TPM_RESULT status = TPM_SUCCESS; - uint8_t plain[BUF_SIZE + AES_BLOCK_SIZE]; - uint8_t buf[BUF_SIZE]; - uint8_t* ptr; - int cipher_sz; - aes_context aes; - - /* Add new vtpm to the table */ - vtpm_add(uuid, g_store.end_offset, index); - g_store.end_offset += RSA_CIPHER_SIZE; - - /* Compute the new end location of the encrypted uuid table */ - cipher_sz = AES_BLOCK_SIZE; //IV - cipher_sz += g_store.num_vtpms * UUID_TBL_ENT_SIZE; //uuid table - cipher_sz += (AES_BLOCK_SIZE - (cipher_sz & (AES_BLOCK_SIZE -1))) & (AES_BLOCK_SIZE-1); //aes padding - - /* Does this overlap any key data? If so they need to be relocated */ - int uuid_end = (g_store.uuid_offset + cipher_sz + RSA_CIPHER_SIZE) & ~(RSA_CIPHER_SIZE -1); - for(int i = 0; i < g_store.num_vtpms; ++i) { - if(g_store.vtpms[i].offset < uuid_end) { - - vtpmloginfo(VTPM_LOG_VTPM, "Relocating vtpm data\n"); - - //Read the hashkey cipher text - lseek(blkfront_fd, g_store.vtpms[i].offset, SEEK_SET); - TRY_READ(buf, RSA_CIPHER_SIZE, "vtpm hashkey relocate"); - - //Write the cipher text to new offset - lseek(blkfront_fd, g_store.end_offset, SEEK_SET); - TRY_WRITE(buf, RSA_CIPHER_SIZE, "vtpm hashkey relocate"); - - //Save new offset - g_store.vtpms[i].offset = g_store.end_offset; - g_store.end_offset += RSA_CIPHER_SIZE; - } - } - - vtpmloginfo(VTPM_LOG_VTPM, "Generating a new symmetric key\n"); - - /* Generate an aes key */ - TPMTRYRETURN(vtpmmgr_rand(plain, AES_KEY_SIZE)); - aes_setkey_enc(&aes, plain, AES_KEY_BITS); - ptr = plain + AES_KEY_SIZE; - - /* Pack the crypted size */ - ptr = pack_UINT32(ptr, cipher_sz); - - vtpmloginfo(VTPM_LOG_VTPM, "Binding encrypted key\n"); - - /* Seal the key and size */ - TPMTRYRETURN(TPM_Bind(&vtpm_globals.storage_key, - plain, - ptr - plain, - buf)); - - /* Write the sealed key to disk */ - lseek(blkfront_fd, g_store.aes_offset, SEEK_SET); - TRY_WRITE(buf, RSA_CIPHER_SIZE, "vtpm aes key"); - - /* ENCRYPT AND WRITE UUID TABLE */ - - vtpmloginfo(VTPM_LOG_VTPM, "Encrypting the uuid table\n"); - - int num_vtpms = 0; - int overlap = 0; - int bytes_crypted; - uint8_t iv[AES_BLOCK_SIZE]; - - /* Generate the iv for the first block */ - TPMTRYRETURN(vtpmmgr_rand(iv, AES_BLOCK_SIZE)); - - /* Copy the iv to the cipher text buffer to be written to disk */ - memcpy(buf, iv, AES_BLOCK_SIZE); - ptr = buf + AES_BLOCK_SIZE; - - /* Encrypt the first block of the uuid table */ - bytes_crypted = vtpm_encrypt_block(&aes, - iv, //iv - plain, //plaintext - ptr, //cipher text - BUF_SIZE - AES_BLOCK_SIZE, - &overlap, - &num_vtpms); - - /* Write the iv followed by the crypted table*/ - TRY_WRITE(buf, bytes_crypted + AES_BLOCK_SIZE, "vtpm uuid table"); - - /* Decrement the number of bytes encrypted */ - cipher_sz -= bytes_crypted + AES_BLOCK_SIZE; - - /* If there are more vtpms, encrypt and write them block by block */ - while(cipher_sz > 0) { - /* Encrypt the next block of the uuid table */ - bytes_crypted = vtpm_encrypt_block(&aes, - iv, - plain, - buf, - BUF_SIZE, - &overlap, - &num_vtpms); - - /* Write the cipher text to disk */ - TRY_WRITE(buf, bytes_crypted, "vtpm uuid table"); - - cipher_sz -= bytes_crypted; - } - - goto egress; -abort_egress: -egress: - return status; -} - - -/************************************** - * PUBLIC FUNCTIONS - * ***********************************/ - -int vtpm_storage_init(void) { - struct blkfront_info info; - if((blkdev = init_blkfront(NULL, &info)) == NULL) { - return -1; - } - if((blkfront_fd = blkfront_open(blkdev)) < 0) { - return -1; - } - return 0; -} - -void vtpm_storage_shutdown(void) { - reset_store(); - close(blkfront_fd); -} - -TPM_RESULT vtpm_storage_load_hashkey(const uuid_t uuid, uint8_t hashkey[HASHKEYSZ]) -{ - TPM_RESULT status = TPM_SUCCESS; - int index; - uint8_t cipher[RSA_CIPHER_SIZE]; - uint8_t clear[RSA_CIPHER_SIZE]; - UINT32 clear_size; - - /* Find the index of this uuid */ - if((index = vtpm_get_index(uuid)) < 0) { - index = -index-1; - vtpmlogerror(VTPM_LOG_VTPM, "LoadKey failure: Unrecognized uuid! " UUID_FMT "\n", UUID_BYTES(uuid)); - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - /* Read the table entry */ - lseek(blkfront_fd, g_store.vtpms[index].offset, SEEK_SET); - TRY_READ(cipher, RSA_CIPHER_SIZE, "vtpm hashkey data"); - - /* Decrypt the table entry */ - TPMTRYRETURN(TPM_UnBind( - vtpm_globals.storage_key_handle, - RSA_CIPHER_SIZE, - cipher, - &clear_size, - clear, - (const TPM_AUTHDATA*)&vtpm_globals.storage_key_usage_auth, - &vtpm_globals.oiap)); - - if(clear_size < HASHKEYSZ) { - vtpmloginfo(VTPM_LOG_VTPM, "Decrypted Hash key size (%" PRIu32 ") was too small!\n", clear_size); - status = TPM_RESOURCES; - goto abort_egress; - } - - memcpy(hashkey, clear, HASHKEYSZ); - - vtpmloginfo(VTPM_LOG_VTPM, "Loaded hash and key for vtpm " UUID_FMT "\n", UUID_BYTES(uuid)); - goto egress; -abort_egress: - vtpmlogerror(VTPM_LOG_VTPM, "Failed to load key\n"); -egress: - return status; -} - -TPM_RESULT vtpm_storage_save_hashkey(const uuid_t uuid, uint8_t hashkey[HASHKEYSZ]) -{ - TPM_RESULT status = TPM_SUCCESS; - int index; - uint8_t buf[RSA_CIPHER_SIZE]; - - /* Find the index of this uuid */ - if((index = vtpm_get_index(uuid)) < 0) { - index = -index-1; - /* Create a new vtpm */ - TPMTRYRETURN( vtpm_storage_new_vtpm(uuid, index) ); - } - - /* Encrypt the hash and key */ - TPMTRYRETURN( TPM_Bind(&vtpm_globals.storage_key, - hashkey, - HASHKEYSZ, - buf)); - - /* Write to disk */ - lseek(blkfront_fd, g_store.vtpms[index].offset, SEEK_SET); - TRY_WRITE(buf, RSA_CIPHER_SIZE, "vtpm hashkey data"); - - vtpmloginfo(VTPM_LOG_VTPM, "Saved hash and key for vtpm " UUID_FMT "\n", UUID_BYTES(uuid)); - goto egress; -abort_egress: - vtpmlogerror(VTPM_LOG_VTPM, "Failed to save key\n"); -egress: - return status; -} - -TPM_RESULT vtpm_storage_new_header() -{ - TPM_RESULT status = TPM_SUCCESS; - uint8_t buf[BUF_SIZE]; - uint8_t keybuf[AES_KEY_SIZE + sizeof(uint32_t)]; - uint8_t* ptr = buf; - uint8_t* sptr; - - /* Clear everything first */ - reset_store(); - - vtpmloginfo(VTPM_LOG_VTPM, "Creating new disk image header\n"); - - /*Copy the ID string */ - memcpy(ptr, IDSTR, IDSTRLEN); - ptr += IDSTRLEN; - - /*Copy the version */ - ptr = pack_UINT32(ptr, DISKVERS); - - /*Save the location of the key size */ - sptr = ptr; - ptr += sizeof(UINT32); - - vtpmloginfo(VTPM_LOG_VTPM, "Saving root storage key..\n"); - - /* Copy the storage key */ - ptr = pack_TPM_KEY(ptr, &vtpm_globals.storage_key); - - /* Now save the size */ - pack_UINT32(sptr, ptr - (sptr + 4)); - - /* Create a fake aes key and set cipher text size to 0 */ - memset(keybuf, 0, sizeof(keybuf)); - - vtpmloginfo(VTPM_LOG_VTPM, "Binding uuid table symmetric key..\n"); - - /* Save the location of the aes key */ - g_store.aes_offset = ptr - buf; - - /* Store the fake aes key and vtpm count */ - TPMTRYRETURN(TPM_Bind(&vtpm_globals.storage_key, - keybuf, - sizeof(keybuf), - ptr)); - ptr+= RSA_CIPHER_SIZE; - - /* Write the header to disk */ - lseek(blkfront_fd, 0, SEEK_SET); - TRY_WRITE(buf, ptr-buf, "vtpm header"); - - /* Save the location of the uuid table */ - g_store.uuid_offset = get_offset(); - - /* Save the end offset */ - g_store.end_offset = (g_store.uuid_offset + RSA_CIPHER_SIZE) & ~(RSA_CIPHER_SIZE -1); - - vtpmloginfo(VTPM_LOG_VTPM, "Saved new manager disk header.\n"); - - goto egress; -abort_egress: -egress: - return status; -} - - -TPM_RESULT vtpm_storage_load_header(void) -{ - TPM_RESULT status = TPM_SUCCESS; - uint32_t v32; - uint8_t buf[BUF_SIZE]; - uint8_t* ptr = buf; - aes_context aes; - - /* Clear everything first */ - reset_store(); - - /* Read the header from disk */ - lseek(blkfront_fd, 0, SEEK_SET); - TRY_READ(buf, IDSTRLEN + sizeof(UINT32) + sizeof(UINT32), "vtpm header"); - - vtpmloginfo(VTPM_LOG_VTPM, "Loading disk image header\n"); - - /* Verify the ID string */ - if(memcmp(ptr, IDSTR, IDSTRLEN)) { - vtpmlogerror(VTPM_LOG_VTPM, "Invalid ID string in disk image!\n"); - status = TPM_FAIL; - goto abort_egress; - } - ptr+=IDSTRLEN; - - /* Unpack the version */ - ptr = unpack_UINT32(ptr, &v32); - - /* Verify the version */ - if(v32 != DISKVERS) { - vtpmlogerror(VTPM_LOG_VTPM, "Unsupported disk image version number %" PRIu32 "\n", v32); - status = TPM_FAIL; - goto abort_egress; - } - - /* Size of the storage key */ - ptr = unpack_UINT32(ptr, &v32); - - /* Sanity check */ - if(v32 > BUF_SIZE) { - vtpmlogerror(VTPM_LOG_VTPM, "Size of storage key (%" PRIu32 ") is too large!\n", v32); - status = TPM_IOERROR; - goto abort_egress; - } - - /* read the storage key */ - TRY_READ(buf, v32, "storage pub key"); - - vtpmloginfo(VTPM_LOG_VTPM, "Unpacking storage key\n"); - - /* unpack the storage key */ - ptr = unpack_TPM_KEY(buf, &vtpm_globals.storage_key, UNPACK_ALLOC); - - /* Load Storage Key into the TPM */ - TPMTRYRETURN( TPM_LoadKey( - TPM_SRK_KEYHANDLE, - &vtpm_globals.storage_key, - &vtpm_globals.storage_key_handle, - (const TPM_AUTHDATA*)&vtpm_globals.srk_auth, - &vtpm_globals.oiap)); - - /* Initialize the storage key auth */ - memset(vtpm_globals.storage_key_usage_auth, 0, sizeof(TPM_AUTHDATA)); - - /* Store the offset of the aes key */ - g_store.aes_offset = get_offset(); - - /* Read the rsa cipher text for the aes key */ - TRY_READ(buf, RSA_CIPHER_SIZE, "aes key"); - ptr = buf + RSA_CIPHER_SIZE; - - vtpmloginfo(VTPM_LOG_VTPM, "Unbinding uuid table symmetric key\n"); - - /* Decrypt the aes key protecting the uuid table */ - UINT32 datalen; - TPMTRYRETURN(TPM_UnBind( - vtpm_globals.storage_key_handle, - RSA_CIPHER_SIZE, - buf, - &datalen, - ptr, - (const TPM_AUTHDATA*)&vtpm_globals.storage_key_usage_auth, - &vtpm_globals.oiap)); - - /* Validate the length of the output buffer */ - if(datalen < AES_KEY_SIZE + sizeof(UINT32)) { - vtpmlogerror(VTPM_LOG_VTPM, "Unbound AES key size (%d) was too small! expected (%zu)\n", datalen, AES_KEY_SIZE + sizeof(UINT32)); - status = TPM_IOERROR; - goto abort_egress; - } - - /* Extract the aes key */ - aes_setkey_dec(&aes, ptr, AES_KEY_BITS); - ptr+= AES_KEY_SIZE; - - /* Extract the ciphertext size */ - ptr = unpack_UINT32(ptr, &v32); - int cipher_size = v32; - - /* Sanity check */ - if(cipher_size & (AES_BLOCK_SIZE-1)) { - vtpmlogerror(VTPM_LOG_VTPM, "Cipher text size (%" PRIu32 ") is not a multiple of the aes block size! (%d)\n", v32, AES_BLOCK_SIZE); - status = TPM_IOERROR; - goto abort_egress; - } - - /* Save the location of the uuid table */ - g_store.uuid_offset = get_offset(); - - /* Only decrypt the table if there are vtpms to decrypt */ - if(cipher_size > 0) { - int rbytes; - int overlap = 0; - uint8_t plain[BUF_SIZE + AES_BLOCK_SIZE]; - uint8_t iv[AES_BLOCK_SIZE]; - - vtpmloginfo(VTPM_LOG_VTPM, "Decrypting uuid table\n"); - - /* Pre allocate the vtpm array */ - g_store.num_vtpms_alloced = cipher_size / UUID_TBL_ENT_SIZE; - g_store.vtpms = malloc(sizeof(struct Vtpm) * g_store.num_vtpms_alloced); - - /* Read the iv and the first chunk of cipher text */ - rbytes = MIN(cipher_size, BUF_SIZE); - TRY_READ(buf, rbytes, "vtpm uuid table\n"); - cipher_size -= rbytes; - - /* Copy the iv */ - memcpy(iv, buf, AES_BLOCK_SIZE); - ptr = buf + AES_BLOCK_SIZE; - - /* Remove the iv from the number of bytes to decrypt */ - rbytes -= AES_BLOCK_SIZE; - - /* Decrypt and extract vtpms */ - vtpm_decrypt_block(&aes, - iv, ptr, plain, - rbytes, &overlap); - - /* Read the rest of the table if there is more */ - while(cipher_size > 0) { - /* Read next chunk of cipher text */ - rbytes = MIN(cipher_size, BUF_SIZE); - TRY_READ(buf, rbytes, "vtpm uuid table"); - cipher_size -= rbytes; - - /* Decrypt a block of text */ - vtpm_decrypt_block(&aes, - iv, buf, plain, - rbytes, &overlap); - - } - vtpmloginfo(VTPM_LOG_VTPM, "Loaded %d vtpms!\n", g_store.num_vtpms); - } - - /* The end of the key table, new vtpms go here */ - int uuid_end = (get_offset() + RSA_CIPHER_SIZE) & ~(RSA_CIPHER_SIZE -1); - g_store.end_offset = uuid_end; - - /* Compute the end offset while validating vtpms*/ - for(int i = 0; i < g_store.num_vtpms; ++i) { - /* offset must not collide with previous data */ - if(g_store.vtpms[i].offset < uuid_end) { - vtpmlogerror(VTPM_LOG_VTPM, "vtpm: " UUID_FMT - " offset (%d) is before end of uuid table (%d)!\n", - UUID_BYTES(g_store.vtpms[i].uuid), - g_store.vtpms[i].offset, uuid_end); - status = TPM_IOERROR; - goto abort_egress; - } - /* offset must be at a multiple of cipher size */ - if(g_store.vtpms[i].offset & (RSA_CIPHER_SIZE-1)) { - vtpmlogerror(VTPM_LOG_VTPM, "vtpm: " UUID_FMT - " offset(%d) is not at a multiple of the rsa cipher text size (%d)!\n", - UUID_BYTES(g_store.vtpms[i].uuid), - g_store.vtpms[i].offset, RSA_CIPHER_SIZE); - status = TPM_IOERROR; - goto abort_egress; - } - /* Save the last offset */ - if(g_store.vtpms[i].offset >= g_store.end_offset) { - g_store.end_offset = g_store.vtpms[i].offset + RSA_CIPHER_SIZE; - } - } - - goto egress; -abort_egress: - //An error occured somewhere - vtpmlogerror(VTPM_LOG_VTPM, "Failed to load manager data!\n"); - - //Clear the data store - reset_store(); - - //Reset the storage key structure - free_TPM_KEY(&vtpm_globals.storage_key); - { - TPM_KEY key = TPM_KEY_INIT; - vtpm_globals.storage_key = key; - } - - //Reset the storage key handle - TPM_EvictKey(vtpm_globals.storage_key_handle); - vtpm_globals.storage_key_handle = 0; -egress: - return status; -} - -#if 0 -/* For testing disk IO */ -void add_fake_vtpms(int num) { - for(int i = 0; i < num; ++i) { - uint32_t ind = cpu_to_be32(i); - - uuid_t uuid; - memset(uuid, 0, sizeof(uuid_t)); - memcpy(uuid, &ind, sizeof(ind)); - int index = vtpm_get_index(uuid); - index = -index-1; - - vtpm_storage_new_vtpm(uuid, index); - } -} -#endif diff --git a/stubdom/vtpmmgr/vtpm_storage.h b/stubdom/vtpmmgr/vtpm_storage.h deleted file mode 100644 index a5a5fd7..0000000 --- a/stubdom/vtpmmgr/vtpm_storage.h +++ /dev/null @@ -1,68 +0,0 @@ -/* - * Copyright (c) 2010-2012 United States Government, as represented by - * the Secretary of Defense. All rights reserved. - * - * based off of the original tools/vtpm_manager code base which is: - * Copyright (c) 2005, Intel Corp. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of Intel Corporation nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS - * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE - * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES - * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) - * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, - * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED - * OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#ifndef VTPM_STORAGE_H -#define VTPM_STORAGE_h - -#include "uuid.h" - -#define VTPM_NVMKEY_SIZE 32 -#define HASHKEYSZ (sizeof(TPM_DIGEST) + VTPM_NVMKEY_SIZE) - -/* Initialize the storage system and its virtual disk */ -int vtpm_storage_init(void); - -/* Shutdown the storage system and its virtual disk */ -void vtpm_storage_shutdown(void); - -/* Loads Sha1 hash and 256 bit AES key from disk and stores them - * packed together in outbuf. outbuf must be freed - * by the caller using buffer_free() - */ -TPM_RESULT vtpm_storage_load_hashkey(const uuid_t uuid, uint8_t hashkey[HASHKEYSZ]); - -/* inbuf must contain a sha1 hash followed by a 256 bit AES key. - * Encrypts and stores the hash and key to disk */ -TPM_RESULT vtpm_storage_save_hashkey(const uuid_t uuid, uint8_t hashkey[HASHKEYSZ]); - -/* Load the vtpm manager data - call this on startup */ -TPM_RESULT vtpm_storage_load_header(void); - -/* Saves the vtpm manager data - call this on shutdown */ -TPM_RESULT vtpm_storage_new_header(void); - - -#endif diff --git a/stubdom/vtpmmgr/vtpmmgr.h b/stubdom/vtpmmgr/vtpmmgr.h index 50a1992..cf2b962 100644 --- a/stubdom/vtpmmgr/vtpmmgr.h +++ b/stubdom/vtpmmgr/vtpmmgr.h @@ -50,10 +50,7 @@ struct vtpm_globals { int tpm_fd; - TPM_KEY storage_key; - TPM_HANDLE storage_key_handle; // Key used by persistent store TPM_AUTH_SESSION oiap; // OIAP session for storageKey - TPM_AUTHDATA storage_key_usage_auth; TPM_AUTHDATA owner_auth; TPM_AUTHDATA srk_auth; @@ -62,13 +59,20 @@ struct vtpm_globals { ctr_drbg_context ctr_drbg; }; +struct tpm_opaque { + uuid_t *uuid; + struct mem_group *group; + struct mem_vtpm *vtpm; + uint8_t kern_hash[32]; +}; + // --------------------------- Global Values -------------------------- extern struct vtpm_globals vtpm_globals; // Key info and DMI states TPM_RESULT vtpmmgr_init(int argc, char** argv); void vtpmmgr_shutdown(void); -TPM_RESULT vtpmmgr_handle_cmd(const uuid_t uuid, tpmcmd_t* tpmcmd); +TPM_RESULT vtpmmgr_handle_cmd(struct tpm_opaque *opq, tpmcmd_t* tpmcmd); inline TPM_RESULT vtpmmgr_rand(unsigned char* bytes, size_t num_bytes) { return ctr_drbg_random(&vtpm_globals.ctr_drbg, bytes, num_bytes) == 0 ? 0 : TPM_FAIL; -- 1.8.5.3 _______________________________________________ Xen-devel mailing list Xen-devel@lists.xen.org http://lists.xen.org/xen-devel From xen-devel-bounces@lists.xen.org Tue Mar 18 11:10:57 2014 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Tue, 18 Mar 2014 11:10:57 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WPruy-0000j5-Pe; Tue, 18 Mar 2014 11:10:48 +0000 Received: from mail6.bemta5.messagelabs.com ([195.245.231.135]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WPruw-0000if-GS for xen-devel@lists.xensource.com; Tue, 18 Mar 2014 11:10:47 +0000 Received: from [85.158.139.211:58821] by server-16.bemta-5.messagelabs.com id 7D/F5-19700-5B928235; Tue, 18 Mar 2014 11:10:45 +0000 X-Env-Sender: Ian.Campbell@citrix.com X-Msg-Ref: server-13.tower-206.messagelabs.com!1395141042!1713594!1 X-Originating-IP: [66.165.176.89] X-SpamReason: No, hits=0.0 required=7.0 tests=sa_preprocessor: VHJ1c3RlZCBJUDogNjYuMTY1LjE3Ni44OSA9PiAyMDMwMDc=\n X-StarScan-Received: X-StarScan-Version: 6.11.1; banners=-,-,- X-VirusChecked: Checked Received: (qmail 10808 invoked from network); 18 Mar 2014 11:10:44 -0000 Received: from smtp.citrix.com (HELO SMTP.CITRIX.COM) (66.165.176.89) by server-13.tower-206.messagelabs.com with RC4-SHA encrypted SMTP; 18 Mar 2014 11:10:44 -0000 X-IronPort-AV: E=Sophos;i="4.97,677,1389744000"; d="scan'208";a="112421211" Received: from accessns.citrite.net (HELO FTLPEX01CL02.citrite.net) ([10.9.154.239]) by FTLPIPO01.CITRIX.COM with ESMTP; 18 Mar 2014 11:10:41 +0000 Received: from [10.80.2.80] (10.80.2.80) by FTLPEX01CL02.citrite.net (10.13.107.79) with Microsoft SMTP Server id 14.2.342.4; Tue, 18 Mar 2014 07:10:40 -0400 Message-ID: <1395141039.12847.42.camel@kazak.uk.xensource.com> From: Ian Campbell To: David Vrabel Date: Tue, 18 Mar 2014 11:10:39 +0000 In-Reply-To: <1395140645.12847.38.camel@kazak.uk.xensource.com> References: <1394816855.6442.168.camel@kazak.uk.xensource.com> <20140314182355.GA1051@phenom.dumpdata.com> <1395054505.4122.65.camel@kazak.uk.xensource.com> <20140317193613.GA15772@phenom.dumpdata.com> <1395134987.18221.58.camel@kazak.uk.xensource.com> <5328262D.7040005@citrix.com> <1395140645.12847.38.camel@kazak.uk.xensource.com> Organization: Citrix Systems, Inc. X-Mailer: Evolution 3.4.4-3 MIME-Version: 1.0 X-Originating-IP: [10.80.2.80] X-DLP: MIA1 Cc: Boris.Ostrovsky@oracle.com, xen-devel@lists.xensource.com, "xen.org" Subject: Re: [Xen-devel] [linux-linus test] 25478: regressions - FAIL X-BeenThere: xen-devel@lists.xen.org X-Mailman-Version: 2.1.13 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Sender: xen-devel-bounces@lists.xen.org Errors-To: xen-devel-bounces@lists.xen.org On Tue, 2014-03-18 at 11:04 +0000, Ian Campbell wrote: > On Tue, 2014-03-18 at 10:55 +0000, David Vrabel wrote: > > On 18/03/14 09:29, Ian Campbell wrote: > > > On Mon, 2014-03-17 at 15:36 -0400, Konrad Rzeszutek Wilk wrote: > > > > > >>>> will also tell you what type of requests it was. > > >>> > > >>> Do you mean the size? It seems to print that only for certain requests. > > >>> > > >> > > >> Right. They aren't that big - and only enough the mptsas is a 4KB one? > > > > > > s/only/oddly/? > > > > Does that card have 64-bit BARs? It may also be possible that the > > driver is setting the wrong DMA mask, basing it on the amount of RAM > > instead of the card support. I seem to recall at least one driver doing > > this. > [...] I'll see if I can borrow the machine and get back > to you. Here we go. The device in question is: 03:00.0 SCSI storage controller: LSI Logic / Symbios Logic SAS1068E PCI-Express Fusion-MPT SAS (rev 08) Subsystem: Dell SAS 6/iR Integrated Blades RAID Controller Control: I/O+ Mem+ BusMaster+ SpecCycle- MemWINV- VGASnoop- ParErr- Stepping- SERR- FastB2B- DisINTx- Status: Cap+ 66MHz- UDF- FastB2B- ParErr- DEVSEL=fast >TAbort- SERR- 4G so I think they don't count. Any idea where I can find the DMA mask? Full lspci below. Ian. 00:00.0 Host bridge: Intel Corporation Core Processor DMI (rev 11) Subsystem: Dell Device 02a3 Control: I/O- Mem- BusMaster- SpecCycle- MemWINV- VGASnoop- ParErr- Stepping- SERR- FastB2B- DisINTx- Status: Cap+ 66MHz- UDF- FastB2B- ParErr- DEVSEL=fast >TAbort- SERR- 00:03.0 PCI bridge: Intel Corporation Core Processor PCI Express Root Port 1 (rev 11) (prog-if 00 [Normal decode]) Control: I/O+ Mem+ BusMaster+ SpecCycle- MemWINV- VGASnoop- ParErr+ Stepping- SERR+ FastB2B- DisINTx+ Status: Cap+ 66MHz- UDF- FastB2B- ParErr- DEVSEL=fast >TAbort- SERR- TAbort- Reset- FastB2B- PriDiscTmr- SecDiscTmr- DiscTmrStat- DiscTmrSERREn- Capabilities: [40] Subsystem: Dell Device 02a3 Capabilities: [60] MSI: Enable+ Count=1/2 Maskable+ 64bit- Address: fee00000 Data: 40b8 Masking: 00000002 Pending: 00000000 Capabilities: [90] Express (v2) Root Port (Slot+), MSI 00 DevCap: MaxPayload 256 bytes, PhantFunc 0, Latency L0s <64ns, L1 <1us ExtTag+ RBE+ FLReset- DevCtl: Report errors: Correctable+ Non-Fatal+ Fatal+ Unsupported+ RlxdOrd- ExtTag- PhantFunc- AuxPwr- NoSnoop- MaxPayload 128 bytes, MaxReadReq 128 bytes DevSta: CorrErr- UncorrErr- FatalErr- UnsuppReq- AuxPwr- TransPend- LnkCap: Port #1, Speed 5GT/s, Width x8, ASPM L0s L1, Latency L0 <512ns, L1 <4us ClockPM- Surprise+ LLActRep+ BwNot+ LnkCtl: ASPM Disabled; RCB 64 bytes Disabled+ Retrain- CommClk- ExtSynch- ClockPM- AutWidDis- BWInt- AutBWInt- LnkSta: Speed 2.5GT/s, Width x0, TrErr- Train- SlotClk+ DLActive- BWMgmt- ABWMgmt- SltCap: AttnBtn- PwrCtrl- MRL- AttnInd- PwrInd- HotPlug- Surprise- Slot #1, PowerLimit 25.000W; Interlock- NoCompl- SltCtl: Enable: AttnBtn- PwrFlt- MRL- PresDet- CmdCplt- HPIrq- LinkChg- Control: AttnInd Off, PwrInd Off, Power+ Interlock- SltSta: Status: AttnBtn- PowerFlt- MRL- CmdCplt- PresDet- Interlock- Changed: MRL- PresDet- LinkState- RootCtl: ErrCorrectable- ErrNon-Fatal- ErrFatal- PMEIntEna+ CRSVisible- RootCap: CRSVisible- RootSta: PME ReqID 0000, PMEStatus- PMEPending- DevCap2: Completion Timeout: Range BCD, TimeoutDis+ ARIFwd+ DevCtl2: Completion Timeout: 1s to 3.5s, TimeoutDis- ARIFwd- LnkCtl2: Target Link Speed: 5GT/s, EnterCompliance- SpeedDis-, Selectable De-emphasis: -6dB Transmit Margin: Normal Operating Range, EnterModifiedCompliance- ComplianceSOS- Compliance De-emphasis: -6dB LnkSta2: Current De-emphasis Level: -6dB, EqualizationComplete-, EqualizationPhase1- EqualizationPhase2-, EqualizationPhase3-, LinkEqualizationRequest- Capabilities: [e0] Power Management version 3 Flags: PMEClk- DSI- D1- D2- AuxCurrent=0mA PME(D0+,D1-,D2-,D3hot+,D3cold+) Status: D0 NoSoftRst+ PME-Enable- DSel=0 DScale=0 PME- Capabilities: [100 v1] Advanced Error Reporting UESta: DLP- SDES- TLP- FCP- CmpltTO- CmpltAbrt- UnxCmplt- RxOF- MalfTLP- ECRC- UnsupReq- ACSViol- UEMsk: DLP- SDES- TLP- FCP- CmpltTO- CmpltAbrt+ UnxCmplt+ RxOF- MalfTLP- ECRC- UnsupReq- ACSViol+ UESvrt: DLP- SDES- TLP- FCP- CmpltTO- CmpltAbrt- UnxCmplt- RxOF- MalfTLP- ECRC- UnsupReq- ACSViol- CESta: RxErr- BadTLP- BadDLLP- Rollover- Timeout- NonFatalErr- CEMsk: RxErr+ BadTLP+ BadDLLP+ Rollover+ Timeout+ NonFatalErr+ AERCap: First Error Pointer: 0e, GenCap- CGenEn- ChkCap- ChkEn- Capabilities: [150 v1] Access Control Services ACSCap: SrcValid+ TransBlk+ ReqRedir+ CmpltRedir+ UpstreamFwd+ EgressCtrl- DirectTrans- ACSCtl: SrcValid+ TransBlk- ReqRedir+ CmpltRedir+ UpstreamFwd+ EgressCtrl- DirectTrans- Capabilities: [160 v0] Vendor Specific Information: ID=0002 Rev=0 Len=00c Kernel driver in use: pcieport 00:05.0 PCI bridge: Intel Corporation Core Processor PCI Express Root Port 3 (rev 11) (prog-if 00 [Normal decode]) Control: I/O+ Mem+ BusMaster+ SpecCycle- MemWINV- VGASnoop- ParErr+ Stepping- SERR+ FastB2B- DisINTx+ Status: Cap+ 66MHz- UDF- FastB2B- ParErr- DEVSEL=fast >TAbort- SERR- TAbort- Reset- FastB2B- PriDiscTmr- SecDiscTmr- DiscTmrStat- DiscTmrSERREn- Capabilities: [40] Subsystem: Dell Device 02a3 Capabilities: [60] MSI: Enable+ Count=1/2 Maskable+ 64bit- Address: fee00000 Data: 40c0 Masking: 00000002 Pending: 00000000 Capabilities: [90] Express (v2) Root Port (Slot+), MSI 00 DevCap: MaxPayload 256 bytes, PhantFunc 0, Latency L0s <64ns, L1 <1us ExtTag+ RBE+ FLReset- DevCtl: Report errors: Correctable+ Non-Fatal+ Fatal+ Unsupported+ RlxdOrd- ExtTag- PhantFunc- AuxPwr- NoSnoop- MaxPayload 256 bytes, MaxReadReq 128 bytes DevSta: CorrErr- UncorrErr- FatalErr- UnsuppReq- AuxPwr- TransPend- LnkCap: Port #3, Speed 5GT/s, Width x8, ASPM L0s L1, Latency L0 <512ns, L1 <4us ClockPM- Surprise+ LLActRep+ BwNot+ LnkCtl: ASPM Disabled; RCB 64 bytes Disabled- Retrain- CommClk+ ExtSynch- ClockPM- AutWidDis- BWInt- AutBWInt- LnkSta: Speed 2.5GT/s, Width x4, TrErr- Train- SlotClk+ DLActive+ BWMgmt+ ABWMgmt- SltCap: AttnBtn- PwrCtrl- MRL- AttnInd- PwrInd- HotPlug- Surprise- Slot #2, PowerLimit 25.000W; Interlock- NoCompl- SltCtl: Enable: AttnBtn- PwrFlt- MRL- PresDet- CmdCplt- HPIrq- LinkChg- Control: AttnInd Off, PwrInd Off, Power+ Interlock- SltSta: Status: AttnBtn- PowerFlt- MRL- CmdCplt- PresDet- Interlock- Changed: MRL- PresDet- LinkState- RootCtl: ErrCorrectable- ErrNon-Fatal- ErrFatal- PMEIntEna+ CRSVisible- RootCap: CRSVisible- RootSta: PME ReqID 0000, PMEStatus- PMEPending- DevCap2: Completion Timeout: Range BCD, TimeoutDis+ ARIFwd+ DevCtl2: Completion Timeout: 1s to 3.5s, TimeoutDis- ARIFwd- LnkCtl2: Target Link Speed: 5GT/s, EnterCompliance- SpeedDis-, Selectable De-emphasis: -6dB Transmit Margin: Normal Operating Range, EnterModifiedCompliance- ComplianceSOS- Compliance De-emphasis: -6dB LnkSta2: Current De-emphasis Level: -6dB, EqualizationComplete-, EqualizationPhase1- EqualizationPhase2-, EqualizationPhase3-, LinkEqualizationRequest- Capabilities: [e0] Power Management version 3 Flags: PMEClk- DSI- D1- D2- AuxCurrent=0mA PME(D0+,D1-,D2-,D3hot+,D3cold+) Status: D0 NoSoftRst+ PME-Enable- DSel=0 DScale=0 PME- Capabilities: [100 v1] Advanced Error Reporting UESta: DLP- SDES- TLP- FCP- CmpltTO- CmpltAbrt- UnxCmplt- RxOF- MalfTLP- ECRC- UnsupReq- ACSViol- UEMsk: DLP- SDES- TLP- FCP- CmpltTO- CmpltAbrt+ UnxCmplt+ RxOF- MalfTLP- ECRC- UnsupReq- ACSViol+ UESvrt: DLP- SDES- TLP- FCP- CmpltTO- CmpltAbrt- UnxCmplt- RxOF- MalfTLP- ECRC- UnsupReq- ACSViol- CESta: RxErr- BadTLP- BadDLLP- Rollover- Timeout- NonFatalErr- CEMsk: RxErr+ BadTLP+ BadDLLP+ Rollover+ Timeout+ NonFatalErr+ AERCap: First Error Pointer: 0e, GenCap- CGenEn- ChkCap- ChkEn- Capabilities: [150 v1] Access Control Services ACSCap: SrcValid+ TransBlk+ ReqRedir+ CmpltRedir+ UpstreamFwd+ EgressCtrl- DirectTrans- ACSCtl: SrcValid+ TransBlk- ReqRedir+ CmpltRedir+ UpstreamFwd+ EgressCtrl- DirectTrans- Kernel driver in use: pcieport 00:08.0 System peripheral: Intel Corporation Core Processor System Management Registers (rev 11) Control: I/O- Mem- BusMaster- SpecCycle- MemWINV- VGASnoop- ParErr- Stepping- SERR- FastB2B- DisINTx- Status: Cap+ 66MHz- UDF- FastB2B- ParErr- DEVSEL=fast >TAbort- SERR- 00:08.1 System peripheral: Intel Corporation Core Processor Semaphore and Scratchpad Registers (rev 11) Control: I/O- Mem- BusMaster- SpecCycle- MemWINV- VGASnoop- ParErr- Stepping- SERR- FastB2B- DisINTx- Status: Cap+ 66MHz- UDF- FastB2B- ParErr- DEVSEL=fast >TAbort- SERR- 00:08.2 System peripheral: Intel Corporation Core Processor System Control and Status Registers (rev 11) Control: I/O- Mem- BusMaster- SpecCycle- MemWINV- VGASnoop- ParErr- Stepping- SERR- FastB2B- DisINTx- Status: Cap+ 66MHz- UDF- FastB2B- ParErr- DEVSEL=fast >TAbort- SERR- 00:08.3 System peripheral: Intel Corporation Core Processor Miscellaneous Registers (rev 11) Control: I/O- Mem- BusMaster- SpecCycle- MemWINV- VGASnoop- ParErr- Stepping- SERR- FastB2B- DisINTx- Status: Cap- 66MHz- UDF- FastB2B- ParErr- DEVSEL=fast >TAbort- SERR- TAbort- SERR- TAbort- SERR- TAbort- SERR- TAbort- SERR- TAbort- Reset- FastB2B- PriDiscTmr- SecDiscTmr- DiscTmrStat- DiscTmrSERREn- Capabilities: [40] Express (v2) Root Port (Slot-), MSI 00 DevCap: MaxPayload 128 bytes, PhantFunc 0, Latency L0s <64ns, L1 <1us ExtTag- RBE+ FLReset- DevCtl: Report errors: Correctable- Non-Fatal+ Fatal+ Unsupported+ RlxdOrd- ExtTag- PhantFunc- AuxPwr- NoSnoop- MaxPayload 128 bytes, MaxReadReq 128 bytes DevSta: CorrErr- UncorrErr- FatalErr- UnsuppReq- AuxPwr+ TransPend- LnkCap: Port #1, Speed 2.5GT/s, Width x4, ASPM L0s L1, Latency L0 <1us, L1 <4us ClockPM- Surprise- LLActRep+ BwNot- LnkCtl: ASPM Disabled; RCB 64 bytes Disabled- Retrain- CommClk- ExtSynch- ClockPM- AutWidDis- BWInt- AutBWInt- LnkSta: Speed 2.5GT/s, Width x4, TrErr- Train- SlotClk+ DLActive+ BWMgmt- ABWMgmt- RootCtl: ErrCorrectable- ErrNon-Fatal+ ErrFatal+ PMEIntEna- CRSVisible- RootCap: CRSVisible- RootSta: PME ReqID 0000, PMEStatus- PMEPending- DevCap2: Completion Timeout: Range BC, TimeoutDis+ ARIFwd- DevCtl2: Completion Timeout: 65ms to 210ms, TimeoutDis- ARIFwd- LnkCtl2: Target Link Speed: 2.5GT/s, EnterCompliance- SpeedDis-, Selectable De-emphasis: -6dB Transmit Margin: Normal Operating Range, EnterModifiedCompliance- ComplianceSOS- Compliance De-emphasis: -6dB LnkSta2: Current De-emphasis Level: -6dB, EqualizationComplete-, EqualizationPhase1- EqualizationPhase2-, EqualizationPhase3-, LinkEqualizationRequest- Capabilities: [80] MSI: Enable+ Count=1/1 Maskable- 64bit- Address: fee00000 Data: 40c8 Capabilities: [90] Subsystem: Dell Device 02a3 Capabilities: [a0] Power Management version 2 Flags: PMEClk- DSI- D1- D2- AuxCurrent=0mA PME(D0+,D1-,D2-,D3hot+,D3cold+) Status: D0 NoSoftRst- PME-Enable- DSel=0 DScale=0 PME- Kernel driver in use: pcieport 00:1c.4 PCI bridge: Intel Corporation 5 Series/3400 Series Chipset PCI Express Root Port 5 (rev 05) (prog-if 00 [Normal decode]) Control: I/O+ Mem+ BusMaster+ SpecCycle- MemWINV- VGASnoop- ParErr+ Stepping- SERR+ FastB2B- DisINTx+ Status: Cap+ 66MHz- UDF- FastB2B- ParErr- DEVSEL=fast >TAbort- SERR- TAbort- Reset- FastB2B- PriDiscTmr- SecDiscTmr- DiscTmrStat- DiscTmrSERREn- Capabilities: [40] Express (v2) Root Port (Slot-), MSI 00 DevCap: MaxPayload 128 bytes, PhantFunc 0, Latency L0s <64ns, L1 <1us ExtTag- RBE+ FLReset- DevCtl: Report errors: Correctable- Non-Fatal+ Fatal+ Unsupported+ RlxdOrd- ExtTag- PhantFunc- AuxPwr- NoSnoop- MaxPayload 128 bytes, MaxReadReq 128 bytes DevSta: CorrErr- UncorrErr- FatalErr- UnsuppReq- AuxPwr+ TransPend- LnkCap: Port #5, Speed 2.5GT/s, Width x4, ASPM L0s L1, Latency L0 <256ns, L1 <4us ClockPM- Surprise- LLActRep+ BwNot- LnkCtl: ASPM Disabled; RCB 64 bytes Disabled- Retrain- CommClk+ ExtSynch- ClockPM- AutWidDis- BWInt- AutBWInt- LnkSta: Speed 2.5GT/s, Width x4, TrErr- Train- SlotClk+ DLActive+ BWMgmt- ABWMgmt- RootCtl: ErrCorrectable- ErrNon-Fatal+ ErrFatal+ PMEIntEna- CRSVisible- RootCap: CRSVisible- RootSta: PME ReqID 0000, PMEStatus- PMEPending- DevCap2: Completion Timeout: Range BC, TimeoutDis+ ARIFwd- DevCtl2: Completion Timeout: 65ms to 210ms, TimeoutDis- ARIFwd- LnkCtl2: Target Link Speed: 2.5GT/s, EnterCompliance- SpeedDis-, Selectable De-emphasis: -6dB Transmit Margin: Normal Operating Range, EnterModifiedCompliance- ComplianceSOS- Compliance De-emphasis: -6dB LnkSta2: Current De-emphasis Level: -6dB, EqualizationComplete-, EqualizationPhase1- EqualizationPhase2-, EqualizationPhase3-, LinkEqualizationRequest- Capabilities: [80] MSI: Enable+ Count=1/1 Maskable- 64bit- Address: fee00000 Data: 40d0 Capabilities: [90] Subsystem: Dell Device 02a3 Capabilities: [a0] Power Management version 2 Flags: PMEClk- DSI- D1- D2- AuxCurrent=0mA PME(D0+,D1-,D2-,D3hot+,D3cold+) Status: D0 NoSoftRst- PME-Enable- DSel=0 DScale=0 PME- Kernel driver in use: pcieport 00:1d.0 USB controller: Intel Corporation 5 Series/3400 Series Chipset USB2 Enhanced Host Controller (rev 05) (prog-if 20 [EHCI]) Subsystem: Dell Device 02a3 Control: I/O- Mem+ BusMaster+ SpecCycle- MemWINV- VGASnoop- ParErr+ Stepping- SERR+ FastB2B- DisINTx- Status: Cap+ 66MHz- UDF- FastB2B+ ParErr- DEVSEL=medium >TAbort- SERR- TAbort- SERR- TAbort- Reset- FastB2B- PriDiscTmr- SecDiscTmr- DiscTmrStat- DiscTmrSERREn- Capabilities: [50] Subsystem: Dell Device 02a3 00:1f.0 ISA bridge: Intel Corporation 3400 Series Chipset LPC Interface Controller (rev 05) Subsystem: Dell Device 02a3 Control: I/O+ Mem+ BusMaster+ SpecCycle- MemWINV- VGASnoop- ParErr+ Stepping- SERR+ FastB2B- DisINTx- Status: Cap+ 66MHz- UDF- FastB2B- ParErr- DEVSEL=medium >TAbort- SERR- 00:1f.2 IDE interface: Intel Corporation 5 Series/3400 Series Chipset 4 port SATA IDE Controller (rev 05) (prog-if 8f [Master SecP SecO PriP PriO]) Subsystem: Dell Device 02a3 Control: I/O+ Mem+ BusMaster+ SpecCycle- MemWINV- VGASnoop- ParErr+ Stepping- SERR- FastB2B- DisINTx- Status: Cap+ 66MHz+ UDF- FastB2B+ ParErr- DEVSEL=medium >TAbort- SERR- TAbort- SERR- TAbort- SERR- TAbort- SERR- Capabilities: [160 v1] Virtual Channel Caps: LPEVC=0 RefClk=100ns PATEntryBits=1 Arb: Fixed- WRR32- WRR64- WRR128- Ctrl: ArbSelect=Fixed Status: InProgress- VC0: Caps: PATOffset=00 MaxTimeSlots=1 RejSnoopTrans- Arb: Fixed- WRR32- WRR64- WRR128- TWRR128- WRR256- Ctrl: Enable+ ID=0 ArbSelect=Fixed TC/VC=ff Status: NegoPending- InProgress- Kernel driver in use: bnx2 02:00.1 Ethernet controller: Broadcom Corporation NetXtreme II BCM5716 Gigabit Ethernet (rev 20) Subsystem: Dell Device 02a3 Control: I/O- Mem+ BusMaster+ SpecCycle- MemWINV- VGASnoop- ParErr- Stepping- SERR- FastB2B- DisINTx- Status: Cap+ 66MHz- UDF- FastB2B- ParErr- DEVSEL=fast >TAbort- SERR- Capabilities: [160 v1] Virtual Channel Caps: LPEVC=0 RefClk=100ns PATEntryBits=1 Arb: Fixed- WRR32- WRR64- WRR128- Ctrl: ArbSelect=Fixed Status: InProgress- VC0: Caps: PATOffset=00 MaxTimeSlots=1 RejSnoopTrans- Arb: Fixed- WRR32- WRR64- WRR128- TWRR128- WRR256- Ctrl: Enable+ ID=0 ArbSelect=Fixed TC/VC=ff Status: NegoPending- InProgress- Kernel driver in use: bnx2 03:00.0 SCSI storage controller: LSI Logic / Symbios Logic SAS1068E PCI-Express Fusion-MPT SAS (rev 08) Subsystem: Dell SAS 6/iR Integrated Blades RAID Controller Control: I/O+ Mem+ BusMaster+ SpecCycle- MemWINV- VGASnoop- ParErr- Stepping- SERR- FastB2B- DisINTx- Status: Cap+ 66MHz- UDF- FastB2B- ParErr- DEVSEL=fast >TAbort- SERR- TAbort- SERR- TAbort- Reset- FastB2B- PriDiscTmr- SecDiscTmr- DiscTmrStat- DiscTmrSERREn- Capabilities: [40] Express (v1) Upstream Port, MSI 00 DevCap: MaxPayload 2048 bytes, PhantFunc 0, Latency L0s <64ns, L1 <1us ExtTag+ AttnBtn- AttnInd- PwrInd- RBE+ FLReset-SlotPowerLimit 25.000W DevCtl: Report errors: Correctable+ Non-Fatal+ Fatal+ Unsupported+ RlxdOrd- ExtTag- PhantFunc- AuxPwr- NoSnoop- MaxPayload 256 bytes, MaxReadReq 128 bytes DevSta: CorrErr+ UncorrErr- FatalErr- UnsuppReq+ AuxPwr- TransPend- LnkCap: Port #0, Speed 2.5GT/s, Width x4, ASPM L0s L1, Latency L0 <512ns, L1 <4us ClockPM- Surprise- LLActRep- BwNot- LnkCtl: ASPM Disabled; Disabled- Retrain- CommClk+ ExtSynch- ClockPM- AutWidDis- BWInt- AutBWInt- LnkSta: Speed 2.5GT/s, Width x4, TrErr- Train- SlotClk+ DLActive- BWMgmt- ABWMgmt- Capabilities: [c0] Power Management version 3 Flags: PMEClk- DSI- D1- D2- AuxCurrent=0mA PME(D0+,D1-,D2-,D3hot+,D3cold+) Status: D0 NoSoftRst+ PME-Enable- DSel=0 DScale=0 PME- Capabilities: [100 v1] Advanced Error Reporting UESta: DLP- SDES- TLP- FCP- CmpltTO- CmpltAbrt- UnxCmplt- RxOF- MalfTLP- ECRC- UnsupReq- ACSViol- UEMsk: DLP- SDES- TLP- FCP- CmpltTO- CmpltAbrt- UnxCmplt+ RxOF- MalfTLP- ECRC- UnsupReq- ACSViol- UESvrt: DLP+ SDES+ TLP+ FCP+ CmpltTO- CmpltAbrt- UnxCmplt- RxOF+ MalfTLP+ ECRC+ UnsupReq- ACSViol- CESta: RxErr- BadTLP- BadDLLP- Rollover- Timeout- NonFatalErr+ CEMsk: RxErr+ BadTLP+ BadDLLP+ Rollover+ Timeout+ NonFatalErr+ AERCap: First Error Pointer: 00, GenCap+ CGenEn- ChkCap+ ChkEn- Capabilities: [200 v1] Virtual Channel Caps: LPEVC=0 RefClk=100ns PATEntryBits=4 Arb: Fixed- WRR32- WRR64- WRR128- Ctrl: ArbSelect=Fixed Status: InProgress- VC0: Caps: PATOffset=02 MaxTimeSlots=1 RejSnoopTrans- Arb: Fixed+ WRR32+ WRR64- WRR128- TWRR128- WRR256- Ctrl: Enable+ ID=0 ArbSelect=Fixed TC/VC=ff Status: NegoPending- InProgress- Port Arbitration Table Kernel driver in use: pcieport 06:02.0 PCI bridge: Integrated Device Technology, Inc. PES12N3A PCI Express Switch (rev 0e) (prog-if 00 [Normal decode]) Control: I/O+ Mem+ BusMaster+ SpecCycle- MemWINV- VGASnoop- ParErr- Stepping- SERR- FastB2B- DisINTx+ Status: Cap+ 66MHz- UDF- FastB2B- ParErr- DEVSEL=fast >TAbort- SERR- TAbort- Reset- FastB2B- PriDiscTmr- SecDiscTmr- DiscTmrStat- DiscTmrSERREn- Capabilities: [40] Express (v1) Downstream Port (Slot-), MSI 00 DevCap: MaxPayload 2048 bytes, PhantFunc 0, Latency L0s <64ns, L1 <1us ExtTag+ RBE+ FLReset- DevCtl: Report errors: Correctable+ Non-Fatal+ Fatal+ Unsupported+ RlxdOrd- ExtTag- PhantFunc- AuxPwr- NoSnoop- MaxPayload 256 bytes, MaxReadReq 128 bytes DevSta: CorrErr+ UncorrErr- FatalErr- UnsuppReq+ AuxPwr- TransPend- LnkCap: Port #2, Speed 2.5GT/s, Width x4, ASPM L0s L1, Latency L0 <512ns, L1 <4us ClockPM- Surprise+ LLActRep+ BwNot- LnkCtl: ASPM Disabled; Disabled- Retrain- CommClk+ ExtSynch- ClockPM- AutWidDis- BWInt- AutBWInt- LnkSta: Speed 2.5GT/s, Width x4, TrErr- Train- SlotClk+ DLActive+ BWMgmt- ABWMgmt- Capabilities: [c0] Power Management version 3 Flags: PMEClk- DSI- D1- D2- AuxCurrent=0mA PME(D0+,D1-,D2-,D3hot+,D3cold+) Status: D0 NoSoftRst+ PME-Enable- DSel=0 DScale=0 PME- Capabilities: [d0] MSI: Enable+ Count=1/1 Maskable- 64bit+ Address: 00000000fee00000 Data: 403b Capabilities: [100 v1] Advanced Error Reporting UESta: DLP- SDES- TLP- FCP- CmpltTO- CmpltAbrt- UnxCmplt- RxOF- MalfTLP- ECRC- UnsupReq- ACSViol- UEMsk: DLP- SDES- TLP- FCP- CmpltTO- CmpltAbrt- UnxCmplt+ RxOF- MalfTLP- ECRC- UnsupReq- ACSViol- UESvrt: DLP+ SDES+ TLP+ FCP+ CmpltTO- CmpltAbrt- UnxCmplt- RxOF+ MalfTLP+ ECRC+ UnsupReq- ACSViol- CESta: RxErr- BadTLP- BadDLLP- Rollover- Timeout- NonFatalErr+ CEMsk: RxErr+ BadTLP+ BadDLLP+ Rollover+ Timeout+ NonFatalErr+ AERCap: First Error Pointer: 00, GenCap+ CGenEn- ChkCap+ ChkEn- Capabilities: [200 v1] Virtual Channel Caps: LPEVC=0 RefClk=100ns PATEntryBits=1 Arb: Fixed- WRR32- WRR64- WRR128- Ctrl: ArbSelect=Fixed Status: InProgress- VC0: Caps: PATOffset=00 MaxTimeSlots=1 RejSnoopTrans- Arb: Fixed+ WRR32- WRR64- WRR128- TWRR128- WRR256- Ctrl: Enable+ ID=0 ArbSelect=Fixed TC/VC=ff Status: NegoPending- InProgress- Kernel driver in use: pcieport 06:04.0 PCI bridge: Integrated Device Technology, Inc. PES12N3A PCI Express Switch (rev 0e) (prog-if 00 [Normal decode]) Control: I/O+ Mem+ BusMaster+ SpecCycle- MemWINV- VGASnoop- ParErr- Stepping- SERR- FastB2B- DisINTx+ Status: Cap+ 66MHz- UDF- FastB2B- ParErr- DEVSEL=fast >TAbort- SERR- TAbort- Reset- FastB2B- PriDiscTmr- SecDiscTmr- DiscTmrStat- DiscTmrSERREn- Capabilities: [40] Express (v1) Downstream Port (Slot-), MSI 00 DevCap: MaxPayload 2048 bytes, PhantFunc 0, Latency L0s <64ns, L1 <1us ExtTag+ RBE+ FLReset- DevCtl: Report errors: Correctable+ Non-Fatal+ Fatal+ Unsupported+ RlxdOrd- ExtTag- PhantFunc- AuxPwr- NoSnoop- MaxPayload 256 bytes, MaxReadReq 128 bytes DevSta: CorrErr+ UncorrErr- FatalErr- UnsuppReq+ AuxPwr- TransPend- LnkCap: Port #4, Speed 2.5GT/s, Width x4, ASPM L0s L1, Latency L0 <512ns, L1 <4us ClockPM- Surprise+ LLActRep+ BwNot- LnkCtl: ASPM Disabled; Disabled- Retrain- CommClk+ ExtSynch- ClockPM- AutWidDis- BWInt- AutBWInt- LnkSta: Speed 2.5GT/s, Width x4, TrErr- Train- SlotClk+ DLActive+ BWMgmt- ABWMgmt- Capabilities: [c0] Power Management version 3 Flags: PMEClk- DSI- D1- D2- AuxCurrent=0mA PME(D0+,D1-,D2-,D3hot+,D3cold+) Status: D0 NoSoftRst+ PME-Enable- DSel=0 DScale=0 PME- Capabilities: [d0] MSI: Enable+ Count=1/1 Maskable- 64bit+ Address: 00000000fee00000 Data: 40a3 Capabilities: [100 v1] Advanced Error Reporting UESta: DLP- SDES- TLP- FCP- CmpltTO- CmpltAbrt- UnxCmplt- RxOF- MalfTLP- ECRC- UnsupReq- ACSViol- UEMsk: DLP- SDES- TLP- FCP- CmpltTO- CmpltAbrt- UnxCmplt+ RxOF- MalfTLP- ECRC- UnsupReq- ACSViol- UESvrt: DLP+ SDES+ TLP+ FCP+ CmpltTO- CmpltAbrt- UnxCmplt- RxOF+ MalfTLP+ ECRC+ UnsupReq- ACSViol- CESta: RxErr- BadTLP- BadDLLP- Rollover- Timeout- NonFatalErr+ CEMsk: RxErr+ BadTLP+ BadDLLP+ Rollover+ Timeout+ NonFatalErr+ AERCap: First Error Pointer: 00, GenCap+ CGenEn- ChkCap+ ChkEn- Capabilities: [200 v1] Virtual Channel Caps: LPEVC=0 RefClk=100ns PATEntryBits=1 Arb: Fixed- WRR32- WRR64- WRR128- Ctrl: ArbSelect=Fixed Status: InProgress- VC0: Caps: PATOffset=00 MaxTimeSlots=1 RejSnoopTrans- Arb: Fixed+ WRR32- WRR64- WRR128- TWRR128- WRR256- Ctrl: Enable+ ID=0 ArbSelect=Fixed TC/VC=ff Status: NegoPending- InProgress- Kernel driver in use: pcieport 07:00.0 Ethernet controller: Intel Corporation 82576 Gigabit Network Connection (rev 01) Subsystem: Intel Corporation Gigabit ET Quad Port Server Adapter Control: I/O+ Mem+ BusMaster+ SpecCycle- MemWINV- VGASnoop- ParErr- Stepping- SERR- FastB2B- DisINTx+ Status: Cap+ 66MHz- UDF- FastB2B- ParErr- DEVSEL=fast >TAbort- SERR- TAbort- SERR- TAbort- SERR- TAbort- SERR- TAbort- SERR- TAbort- SERR- TAbort- SERR- TAbort- SERR- TAbort- SERR- TAbort- SERR- TAbort- SERR- TAbort- SERR- TAbort- SERR- TAbort- SERR- TAbort- SERR- TAbort- SERR- TAbort- SERR- TAbort- SERR- TAbort- SERR- TAbort- SERR- Envelope-to: archives@lists.xenproject.org Delivery-date: Tue, 18 Mar 2014 13:49:19 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WPuOL-0008Bj-LS; Tue, 18 Mar 2014 13:49:18 +0000 Received: from mail6.bemta4.messagelabs.com ([85.158.143.247]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WPuOI-0008Ai-Eg for advisory-board@lists.xenproject.org; Tue, 18 Mar 2014 13:49:15 +0000 Received: from [85.158.143.35:35727] by server-3.bemta-4.messagelabs.com id 76/3E-13602-9DE48235; Tue, 18 Mar 2014 13:49:13 +0000 X-Env-Sender: sconway@linuxfoundation.org X-Msg-Ref: server-12.tower-21.messagelabs.com!1395150549!2919367!1 X-Originating-IP: [209.85.217.176] X-SpamReason: No, hits=0.8 required=7.0 tests=BODY_RANDOM_LONG, HTML_MESSAGE,RCVD_BY_IP X-StarScan-Received: X-StarScan-Version: 6.11.1; banners=-,-,- X-VirusChecked: Checked Received: (qmail 10655 invoked from network); 18 Mar 2014 13:49:10 -0000 Received: from mail-lb0-f176.google.com (HELO mail-lb0-f176.google.com) (209.85.217.176) by server-12.tower-21.messagelabs.com with RC4-SHA encrypted SMTP; 18 Mar 2014 13:49:10 -0000 Received: by mail-lb0-f176.google.com with SMTP id 10so4665783lbg.7 for ; Tue, 18 Mar 2014 06:49:09 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linuxfoundation.org; s=google; h=mime-version:in-reply-to:references:date:message-id:subject:from:to :content-type; bh=jeuFS6/gMSjWvS5GiLylEbmjd9cyKcXceOhhk+YGHcM=; b=YKYXb9JeCP1sUiwJE37wmIzx7TFeiWFkdEfCOZY17wYVNLMSYDTK5WYlLyDCWNCOeH S7yf/6sFj1OR9jArzfgO6ypwX7ayvsFeHTdVRBjFe8uo+r2DZN8wqqxyIS474YsydNkz ug5T23A27gCgAcv8lt0gLjsHmaayz+G6B44zg= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:mime-version:in-reply-to:references:date :message-id:subject:from:to:content-type; bh=jeuFS6/gMSjWvS5GiLylEbmjd9cyKcXceOhhk+YGHcM=; b=cWYy6ecCpt7t63vZIXwWpdYD919ZTv+1N1tAgdecuPIwB2lLw4xidEz+HtnEdWCMaM v51OPxh7O0pbK/pAhm7Ce/vsJ7N/7CYm9d5rNuGCvn63e9T9xWwzlIBY4z/Xys1IKfWH jPU53D3MbCKlLDHe0/GwG9s3yjyUMVv3ddJ9RZC2HgXkPoNYSD6uNQyslXxnt/2Ja0H/ w+kWzNUeEEQds+Gls7QpcwYcLHWZIjA5Odv8bffdfCzyL1uNXYfDFkldALgWCYJAfGbT Y3UiBOF56LSbuviMVnuWsYIKOsHXJ2H1ubHCYgJhWON7A5XY6Ua5xA4nBKcrvOIKOxQK 4W6g== X-Gm-Message-State: ALoCoQn7+vwBu1eZI5DGPso7zmPeWl3ReDV7UhPojdJ7lnW6fvny+JHCDzbF1Gwn7nGZ7fYLsqta MIME-Version: 1.0 X-Received: by 10.152.29.8 with SMTP id f8mr21380416lah.11.1395150549107; Tue, 18 Mar 2014 06:49:09 -0700 (PDT) Received: by 10.114.200.8 with HTTP; Tue, 18 Mar 2014 06:49:09 -0700 (PDT) In-Reply-To: <08FF8C46-9229-4B19-89B2-9B92E787D41D@citrix.com> References: <096046e0-5d30-4981-be23-031a7400f948@email.android.com> <08FF8C46-9229-4B19-89B2-9B92E787D41D@citrix.com> Date: Tue, 18 Mar 2014 09:49:09 -0400 Message-ID: From: Sarah Conway To: Advisory-board discussions , Jennifer Cloer Subject: Re: [Advisory-board] Xen Board Meeting Tuesday - March 18th -11:00 A.M. EDT/ 3:00 P.M. GMT(UTC) X-BeenThere: advisory-board@lists.xenproject.org X-Mailman-Version: 2.1.13 Precedence: list Reply-To: Advisory-board discussions List-Id: Advisory-board discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: multipart/mixed; boundary="===============0013956396717041916==" Sender: advisory-board-bounces@lists.xenproject.org Errors-To: advisory-board-bounces@lists.xenproject.org --===============0013956396717041916== Content-Type: multipart/alternative; boundary=089e0158c158e3540e04f4e1cc4c --089e0158c158e3540e04f4e1cc4c Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: quoted-printable Hi everyone. For the PR portion of the call below is a summary of media questions, feedback and coverage from the recent 4.4 launch. I look forward to talking to everyone. Thanks, Reporter Questions: -How does Xen 4.4 extend support for ARM? Wasn't ARM supported before - so what's new/different/enhanced? -How has Xen 4.4 been improved specifically for cloud deployments? -- what is the new event channel implementation that Citrix contributed? -What is PVH mode? (and what does PVH stand for?) what will it enable that wasn't possible before? -Why add support for SPICE now? Isn't SPICE directly linked to KVM (and its' originator Red Hat / Qumranet) -How has the Linux Foundation collaboration project model helped to make Xen 4.4 a btr release than it would have been - say outside of the LF model= ? -What's next for Xen? 4.5? -Tell me about the biggest changes in 4.4. ARM is a hot topic in server space, where is this? who is committing to this work? Are these OEMs, where is motivation coming from? -Are there any chips that are out? -So if you are a Xen user, is the ARM experience any different? What if you are writing an OS? -ARM question...is embedded computing working on ARM? Do you also see virtualization on embedded or devices, Internet of Things? -What's driving the need for virtualization in cars? Are they running out of space? -What's driving the big trend in microservers? Where is it going to go? -Do you think enterprises with MS Hyper V or VMWare will make the switch to a new hypervisor and new architecture? -Will cloud service providers provide multiple choices? -Does Xen run differently on ARM for end users? Reporter Comments/Feedback: -Keeping ahead of the industry. -ARM updates and removing limitations for scalable applications and services -- those are two good news hooks. -Why is ARM support so important? Isn't this usually found on low-end machines? Am somewhat puzzled. Article Highlights: ZDNet: Put it all together and once more Xen, a quiet, invisible part of the virtualization and cloud world, will once more be enabling us to get ever more from our physical servers and their data-centers. Without Xen, a lot of today's most important cloud services wouldn't be in business. IDG: The Xen hypervisor is one of the chief hypervisors used today for server-based virtualization, along with VMware's ESX, Microsoft's Hyper-V and the Red Hat-led KVM (Kernel-based Virtual Machine). eWeek: Greater Xen support will only help ARM's cause (against a very motivated Intel). Coverage: - 15 percent increase in coverage over last product announcement - 88 vs. 75 clips for weeks of March 10-17 vs. July 9-16 3/13/2014 By Dr. Roy Schestowitz Kernel News: Linux 3.14 RC6, MOOC, ARM Support in Xen and More http://techrights.org/2014/03/13/arm-support-in-xen/ 3/11/2014 Docker 0.9, Vagrant 1.5 and Xen 4.4 - Virtually Snippets Codescalng By D.J. Walker-Morgan http://codescaling.com/2014/03/11/docker-0-9-vagrant-1-5-and-xen-4-4-virtua= lly-snippets/ 3/12/2014 Xen Project Hypervisor Now Supports ARM Processors By James Sullivan http://www.tomsitpro.com/articles/xen-hypervisor-arm-processors-virtualizat= ion,1-1766.html 3/11/2014 Xen 4.4 Adds Full Virtualization for ARM Systems By Pau Mah http://www.fiercecio.com/techwatch/story/xen-44-adds-full-virtualization-ar= m-systems/2014-03-11 3/11/2014 ServerWatch.com Xen 4.4 ARMS for Virtualization, Adds SPICE By Sean Michael Kerner http://www.serverwatch.com/server-news/xen-4-4-arms-for-virtualization-adds= -spice.html 3/11/2014 ZDNet Xen Brings Its Virtualization Goodness to More ARM Chipsets By Steven J. Vaughan-Nichols http://www.zdnet.com/xen-brings-its-virtualization-goodness-to-more-arm-chi= psets-7000027168/ 3/10/2014 IDG, PCWorld Xen Hypervisor Moves into ARM Space By Joab Jackson http://www.pcworld.com/article/2106460/xen-hypervisor-moves-into-arm-space.= html also appeared on: http://www.pcworld.co.nz/article/540128/xen_hypervisor_moves_into_arm_space= / http://www.dabcc.com/article.aspx?id=3D27640 http://www.itworld.com/hardware/409048/xen-hypervisor-moves-arm-space http://www.networkworld.com/news/2014/031014-xen-hypervisor-moves-into-arm-= 279560.html 3/10/2014 eWeek Xen 4.4 Brings Greater Virtualization Support to ARM By Jeffrey Burt http://www.eweek.com/servers/xen-4.4-brings-greater-virtualization-support-= to-arm.html 3/10/2014 VentureBeat Data centers Could Soon Run on Far Less Energy with Xen Hypervisor Update By Jordan Novet http://venturebeat.com/2014/03/10/energy-sipping-arm-based-servers-get-a-bo= ost-with-xen-hypervisor-update/ 3/10/2014 Muktware Xen Enhances Support for ARM by Swapnil Bhartiya http://www.muktware.com/2014/03/xen-enhances-support-arm/22697 3/10/2014 InfoWorld Xen 4.4 is Now Fully Armed for 64-bit ARM By Serdar Yegulalp http://www.infoworld.com/t/virtualization/xen-44-now-fully-armed-64-bit-arm= -238014 3/10/2014 ITBusinessEgde Xen Hypervisor Community Embraces ARM Processors By Mike Vizard http://www.itbusinessedge.com/blogs/it-unmasked/xen-hypervisor-community-em= braces-arm-processors.html 3/10/2014 VARGuy Xen 4.4 Open Source Virtualization Targets ARM and Cloud By Christopher Tozzi http://thevarguy.com/virtualization-applications-and-technologies/031014/em= bargo-monday-march-10-8-am-est-xen-44-open-source-vir 3/10/2014 Phoronix Xen 4.4 Release Brings Major Features By Michael Larabel http://www.phoronix.com/scan.php?page=3Dnews_item&px=3DMTYyNTg 3/10/2014 LinuxToday.com Xen 4.4 Open Source Virtualization Targets ARM and Cloud http://www.linuxtoday.com/infrastructure/xen-4.4-open-source-virtualization= -targets-arm-and-cloud.html 3/10/2014 Virtualization Info Xen Project Hypervisor 4.4 Posted by Kenneth van Surksum http://virtualization.info/en/news/2014/03/release-xen-project-hypervisor-4= -4.html Press Release Pick-Ups: http://www.digitaljournal.com/pr/1781107 http://vmblog.com/archive/2014/03/10/xen-project-announces-xen-hypervisor-v= ersion-4-4.aspx#.UyHfUvBX-uZ http://hardware.itbusinessnet.com/article/Xen-Project-Community-Releases-Up= date-to-Enterprise-Hypervisor-Software--3107693 http://www.wwpi.com/index.php?option=3Dcom_content&view=3Darticle&id=3D1707= 6:xen-project-community-issues-update-to-enterprise-hypervisor-software&cat= id=3D324:breaking-new http://www.broadwayworld.com/bwwgeeks/article/Xen-Project-Community-Release= s-Update-to-Enterprise-Hypervisor-Software-20140310#.Ux8uA3l5L4Is&Itemid=3D= 2701735 International Highlights: 3/11/2014 Pro Linux Xen 4.4 unterst=FCtzt mehr G=E4ste und ARM-Systeme http://www.pro-linux.de/news/1/20862/xen-44-unterstuetzt-mehr-gaeste-und-ar= m-systeme.html 3/11/2014 Le Monde Informatique Hyperviseur : Xen 4.4 arrive sur les serveurs ARM http://www.lemondeinformatique.fr/actualites/lire-hyperviseur-xen-44-arrive= -sur-les-serveurs-arm-56822.html On Mon, Mar 17, 2014 at 10:27 AM, Mark Hinkle wrote= : > Responses inline. > > On Mar 14, 2014, at 10:51 PM, Konrad Rzeszutek Wilk < > konrad.wilk@oracle.com> wrote: > > > On March 14, 2014 6:50:40 PM EDT, Mark Hinkle > wrote: > >> Hello, > >> > >> I just wanted to send out a tentative agenda for Tuesday's board > >> meeting. I also will be traveling that day and my flights changed. In > >> Lars absence I was supposed to administer the meeting but in the event > >> my travel doesn't allow me to attend I was wondering if anyone would b= e > >> interested in being the proctor. I was thinking the might have the > >> following agenda but would welcome any additions or changes. > > > > I volunteer to be the proctor. > > Great I sent you the PIN for opening the bridge at 14:00 GMT UTC tomorrow= . > > >> > >> 1. Post-mortem Xen Project 4.4 launch > >> - What went well > >> - What could we do better > >> - Press/User Feedback > >> 2. Nomenclature - We waffled on how we described the release from Xen > >> Project 4.4 to Xen Project Hypervisor 4.4 and other variations. I > >> thought it would be good to discuss the naming for our projects so we > >> have more consistency in how we refer to them. > >> 3. Xen Developer Summit - August 18, 2014 - > >> > http://events.linuxfoundation.org//events/xen-project-developer-summit/at= tend/register > >> -Reminder for CFP > >> -Increased participation if desired by Advisory board > >> 4. Issues Roundtable > > One addendum to the agenda, Sarah Conway is looking to do a Q&A session i= n > advance of the Collaboration Summit with one of our advisory board member= s. > She's reached out to one but gotten no response if you are interested in > talking about why you support Xen please feel free to drop her a line at > sconway@linuxfoundation.org > > > > The OPW internship and whether members would be OK to open an extra slo= t > for an extra intern. Xen AB is already sponsoring one but with the amount > of interest we could use an extra slot. The number is ~$6K. > > > > We have $40k (if my memory serves me right) allocated for this but need > an vote on it. > > We have $40k approved and agreed to one OPW so far. I suggest you explain > the work the second OPW would do and get a vote pending our understanding > that the budget is correct. Lars can confirm with Mike but I think your > recollection is right. > > Regards, Mark > > > > > >> > >> Call-in information below, let me know if anyone has the desire to run > >> the meeting in case my travel doesn't line up I'll send you the admin > >> pin. > >> > >> Regards, > >> > >> Mark R. Hinkle > >> Senior Director, Open Source Solutions > >> Citrix Systems > >> p: 919.228.8049 > >> m: 919.522.3520 > >> e: mark.hinkle@citrix.com > >> twitter: @mrhinkle > >> > >> > >> > >> > >> Dial-in Details > >> > >> The Conference Room Number is: 6053208 > >> > >> China: +86 4008811076 > >> Germany: +49 08007235118 > >> Poland: +48 (00) 8001213973 > >> South Korea: +82 (0) 806090880 > >> United Kingdom: +44 (0) 8000284051 > >> United States: +1 (866) 951-1151 > >> > >> Other numbers both toll free and toll are at the bottom of the invite. > >> > >> Meeting Dates | UTC time | Notes > >> May 21, 2013 | 14:00 UTC > >> Jun 18, 2013 | 14:00 UTC > >> Jul 16, 2013 | 14:00 UTC > >> Aug 20, 2013 | 14:00 UTC > >> Sep 17, 2013 | 14:00 UTC | Same week as LinuxCon NA, plan a > >> face-2-face > >> Oct 15, 2013 | 14:00 UTC | One week before LinuxCon EU and > >> XenSummit, consider moving by a week to enable face-2-face > >> Nov 19, 2013 | 15:00 UTC *) > >> Dec 17, 2013 | 15:00 UTC > >> Jan 21, 2014 | 15:00 UTC > >> Feb 18, 2014 | 15:00 UTC > >> March 18, 2014 | 14:00 UTC *) | Note that the meeting is one hour > >> earlier than normal in European countries with summer time > >> April 15, 2014 | 14:00 UTC | Consider a face-2-face co-located wit= h > >> LF Collab Summit > >> --- > >> *) Note that China and South Korea do not observe Daylight Saving Time > >> > >> Call Toll-Free: > >> > >> Australia: +61 1800886154 > >> Austria: +43 0800202142 > >> Bahrain: +973 80081025 > >> Belgium: +32 (0) 80039174 > >> Brazil: +55 (0) 8000474900 > >> China: +86 4008811076 > >> Czech Republic: +420 800500441 > >> Denmark: +45 80901917 > >> Finland: +358 (0) 80094501 > >> France: +33 (0) 805541041 > >> Germany: +49 08007235118 > >> Hong Kong: +852 30713072 > >> India: +91 0008006501664 > >> Ireland: +353 1800812610 > >> Israel: +972 1809212874 > >> Israel: +972 1809494119 > >> Italy: +39 800906953 > >> Japan: +81 (0) 120216700 > >> Luxembourg: +352 80080918 > >> Malaysia: +60 1800815377 > >> Mexico: +52 018009250370 > >> Netherlands: +31 8002658468 > >> New Zealand: +64 0508800736 BETA > >> New Zealand: +64 0800452184 > >> Norway: +47 80030216 > >> Philippines: +63 180016510700 > >> Poland: +48 (00) 8001213973 > >> Portugal: +351 800784454 > >> Singapore: +65 8001205610 > >> South Korea: +82 (0) 806090880 > >> Spain: +34 800900576 > >> Sweden: +46 020980766 > >> Switzerland: +41 0800000257 BETA > >> Switzerland: +41 (0) 800741205 > >> Taiwan: +886 0800666844 > >> Thailand: +66 001800658109 > >> United Kingdom: +44 (0) 8000284051 > >> United States: +1 (866) 951-1151 > >> > >> Call Toll: > >> > >> Australia: +61 386447048 > >> Austria: +43 (0) 720880195 > >> Belgium: +32 (0) 2 8083570 > >> Canada: +1 (416) 800-8947 > >> Chile: +56 25952800 > >> Czech Republic: +420 246019761 > >> Denmark: +45 69918561 > >> Finland: +358 (0) 942415730 > >> France: +33 (0) 170610411 > >> Germany: +49 81188997023 > >> Greece: +30 2111768208 > >> Ireland: +353 (0) 1 6526574 > >> Israel: +972 (0) 37219621 > >> Italy: +39 691717888 > >> Japan: +81 (0) 3 45209439 > >> Luxembourg: +352 20880370 > >> Mexico: +52 (01) 5 511638996 > >> Netherlands: +31 (0) 2 02629654 > >> New Zealand: +64 (0) 99749585 > >> Norway: +47 21518197 > >> Peru: +51 17085569 > >> Poland: +48 (0) 2 23987735 > >> Spain: +34 931816662 > >> Sweden: +46 (0) 8 52500100 > >> Switzerland: +41 (0) 225331088 > >> United Kingdom: +44 (0) 2033181172 > >> United States: +1 (201) 590-2255 > >> > >> > >> > >> > >> > >> > >> > >> > >> ----------------------------------------------------------------------= -- > >> > >> _______________________________________________ > >> Advisory-board mailing list > >> Advisory-board@lists.xenproject.org > >> http://lists.xenproject.org/cgi-bin/mailman/listinfo/advisory-board > > > > > > > _______________________________________________ > Advisory-board mailing list > Advisory-board@lists.xenproject.org > http://lists.xenproject.org/cgi-bin/mailman/listinfo/advisory-board > --=20 Sarah Conway PR Manager The Linux Foundation sconway@linuxfoundation.org (978) 578-5300 Cell Skype: sarah.k.conway --089e0158c158e3540e04f4e1cc4c Content-Type: text/html; charset=ISO-8859-1 Content-Transfer-Encoding: quoted-printable
Hi everyone.

For the PR portion of the = call below is a summary of media questions, feedback and coverage from the = recent 4.4 launch. I look forward to talking to everyone.

Thanks,


Reporter Questions:

-How does Xen 4.4 extend support for AR= M? Wasn't ARM supported before - so what's new/different/enhanced?<= /span>

= -How has Xen 4.4 been improved specific= ally for cloud deployments?

= — what is the  new event ch= annel implementation that Citrix contributed?

= -What is PVH mode? (and what does PVH s= tand for?) what will it enable that wasn't possible before?

= -Why add support for SPICE now? Isn'= ;t SPICE directly linked to KVM (and its' originator Red Hat / Qumranet= )

= -How has the Linux Foundation collabora= tion project model helped to make Xen 4.4 a btr release than it would have = been - say outside of the LF model?

= -What's next for Xen? 4.5?

= -Tell me about the biggest changes in 4= .4. ARM is a hot topic in server space, where is this? who is committing to= this work? Are these OEMs, where is motivation coming from?

= -Are there any chips that are out?

= -So if you are a Xen user, is the ARM e= xperience any different? What if you are writing an OS?  

= -ARM question...is embedded computing w= orking on ARM? Do you also see virtualization on embedded or devices, Inter= net of Things?

= -What’s driving the need for virt= ualization in cars? Are they running out of space?
-What’s driving the big trend in microservers? Where is it going to g= o?

-Do you think enterprises = with MS Hyper V or VMWare will make the switch to a new hypervisor and new = architecture?

= -Will cloud service providers provide m= ultiple choices?

= -Does Xen run differently on ARM for en= d users?


Reporter Comments/Feedback:

= -Keeping ahead of the industry.<= /p>

= -ARM updates and removing limitations f= or scalable applications and services -- those are two good news hooks.

= -Why is ARM support so important? Isn't this usually= found on low-end machines? Am somewhat puzzled.


Article Highlights:


ZDNet: Put it all tog= ether and once more Xen, a quiet, invisible part of the virtualization and = cloud world, will once more be enabling us to get ever more from our physic= al servers and their data-centers.


Without Xen, a lot of today's most important cloud servic= es wouldn't be in business.


IDG: The Xen hypervisor is one of t= he chief hypervisors used today for server-based virtualization, along with= VMware’s ESX, Microsoft’s Hyper-V and the Red Hat-led KVM (Ker= nel-based Virtual Machine).


eWeek: Greater Xen support= will only help ARM's cause (against a very motivated Intel).

Coverage:


  • = 15 percent inc= rease in coverage over last product announcement

  • = 88 vs. 75 clip= s for weeks of March 10-17 vs. July 9-16

3/13/2014

= By Dr. Roy Schestowitz

= Kernel News: Linux 3.14 RC6, MOOC, ARM Support in Xen and More<= /span>

= http://techrights.or= g/2014/03/13/arm-support-in-xen/


3/11/2014

= Docker 0.9, Vagrant 1.5 and Xen 4.4 &nd= ash; Virtually Snippets

= Codescalng

By D.J. Walker-Morgan

http://codescaling.= com/2014/03/11/docker-0-9-vagrant-1-5-and-xen-4-4-virtually-snippets/


3/12/2014

= Xen Project Hypervisor Now Supports ARM= Processors

= By James Su= llivan

= http://www.= tomsitpro.com/articles/xen-hypervisor-arm-processors-virtualization,1-1766.= html


3/11/2014

= Xen 4.4 Adds Full Virtualization for AR= M Systems

= By Pau Mah

http:/= /www.fiercecio.com/techwatch/story/xen-44-adds-full-virtualization-arm-syst= ems/2014-03-11


3/11/2014

= ServerWatch.com

Xen 4.4 ARMS for Virtualization, Adds S= PICE

By Sean Michael Kerner

http://www.serverwatch.com/server-news/xen-4-4-arms-for-= virtualization-adds-spice.html

3/11/2014

= ZDNet

Xen Brings Its Virtualization Goodness = to More ARM Chipsets

By Steven J. Vaughan-Nichols= http://ww= w.zdnet.com/xen-brings-its-virtualization-goodness-to-more-arm-chipsets-700= 0027168/


3/10/2014

= IDG, PCWorld

Xen Hypervisor Moves into ARM Space

= By Joab Jackson

http://www.pcworld.com/article/2106460/x= en-hypervisor-moves-into-arm-space.html

= also appea= red on: http://www.pcworld.co.nz/article/540128/xen_hyperviso= r_moves_into_arm_space/

= http://www.dabcc.com/article.aspx?id=3D27640

= http://www.itworld.com/hardware/409048= /xen-hypervisor-moves-arm-space

= http://www.networkworld.com/news/2014/031014-xen-hypervisor-m= oves-into-arm-279560.html


3/10/2014

= eWeek

Xen 4.4 Brings Greater Virtual= ization Support to ARM

= By Jeffrey= Burt

= http://www.eweek.com/servers/xen-= 4.4-brings-greater-virtualization-support-to-arm.html


3/10/2014

= VentureBeat

<= a href=3D"http://venturebeat.com/2014/03/10/energy-sipping-arm-based-server= s-get-a-boost-with-xen-hypervisor-update/" style=3D"text-decoration:none"><= span style=3D"font-size:16px;font-family:Arial;color:rgb(0,0,0);background-= color:transparent;vertical-align:baseline;white-space:pre-wrap">Data center= s Could Soon Run on Far Less Energy with Xen Hypervisor Update

= By Jordan = Novet

= = http://ventur= ebeat.com/2014/03/10/energy-sipping-arm-based-servers-get-a-boost-with-xen-= hypervisor-update/


3/10/2014=

= Muktware

<= a href=3D"http://www.muktware.com/2014/03/xen-enhances-support-arm/22697" s= tyle=3D"text-decoration:none">Xen Enhances Support for ARM

= by Swapnil Bhartiya=

= http://www= .muktware.com/2014/03/xen-enhances-support-arm/22697


3/10/2014

= InfoWorld

Xen 4.4 is Now Fully Armed for 64-= bit ARM

By Serdar= Yegulalp h= ttp://www.infoworld.com/t/virtualization/xen-44-now-fully-armed-64-bit-arm-= 238014

= 3/10/2014

ITBusinessEgde

Xen Hypervisor Community Embraces A= RM Processors

By Mike Vizar= d

http://www.itbusiness= edge.com/blogs/it-unmasked/xen-hypervisor-community-embraces-arm-processors= .html


3/10/2014

VARGuy

Xen 4.4 Open Source Virtualization Targets ARM and Cloud=

By Christopher Tozzi

http://thevarguy.com/virtualization-applications-and-technologies/= 031014/embargo-monday-march-10-8-am-est-xen-44-open-source-vir


3/10/2014

= Phoronix

Xen 4.4 Release Brings Major Features

By Michael Larabel

= http= ://www.phoronix.com/scan.php?page=3Dnews_item&px=3DMTYyNTg


3/10/2014

LinuxToday.com

Xen 4.4 Open = Source Virtualization Targets ARM and Cloud

http://www.linuxtoday.com/infrastructure/xen-4.4-open-source-virtu= alization-targets-arm-and-cloud.html


3/10/2014

= Virtualization Info

Xen Project Hypervisor 4.4

= Posted by Kenneth van Surksum  =

= http://virtualizati= on.info/en/news/2014/03/release-xen-project-hypervisor-4-4.html<= span style=3D"font-size:16px;font-family:Arial;color:rgb(17,85,204);text-de= coration:underline;vertical-align:baseline;white-space:pre-wrap">

Press Release Pick-Ups:


http://www.digita= ljournal.com/pr/1781107


http://vmblog.com/archive/2014/03/10/xen-project-announces-xen-h= ypervisor-version-4-4.aspx#.UyHfUvBX-uZ


http://hardware.itbusinessne= t.com/article/Xen-Project-Community-Releases-Update-to-Enterprise-Hyperviso= r-Software--3107693

http://www.wwpi.com/index.php?option=3D= com_content&view=3Darticle&id=3D17076:xen-project-community-issues-= update-to-enterprise-hypervisor-software&catid=3D324:breaking-new


http://www.broadwayworld.com/bwwgeeks/article/Xen-Project-Comm= unity-Releases-Update-to-Enterprise-Hypervisor-Software-20140310#.Ux8uA3l5L= 4Is&Itemid=3D2701735


International Highlights:


3/11/2014

Pro Linux

Xen 4.4 un= terst=FCtzt mehr G=E4ste und ARM-Systeme

http://www.pro-linux.de/news/1= /20862/xen-44-unterstuetzt-mehr-gaeste-und-arm-systeme.html


3/11/2014

Le Monde Informatique

Hyperviseur : Xen 4.4 arrive sur les se= rveurs ARM

http://www.lemondeinformatique.fr/actualites/lire-hyperviseur-xen-44-= arrive-sur-les-serveurs-arm-56822.html




On Mon, Mar 17, 2014 a= t 10:27 AM, Mark Hinkle <Mark.Hinkle@citrix.com> wrote:=
Responses inline.

On Mar 14, 2014, at 10:51 PM, Konrad Rzeszutek Wilk <konrad.wilk@oracle.com> wrote:

> On March 14, 2014 6:50:40 PM EDT, Mark Hinkle <Mark.Hinkle@citrix.com> wrote:
>> Hello,
>>
>> I just wanted to send out a tentative agenda for Tuesday’s b= oard
>> meeting. I also will be traveling that day and my flights changed.= In
>> Lars absence I was supposed to administer the meeting but in the e= vent
>> my travel doesn’t allow me to attend I was wondering if anyo= ne would be
>> interested in being the proctor.  I was thinking the might ha= ve the
>> following agenda but would welcome any additions or changes.
>
> I volunteer to be the proctor.

Great I sent you the PIN for opening the bridge at 14:00 GMT UTC tomo= rrow.

>>
>> 1. Post-mortem Xen Project 4.4 launch
>> - What went well
>> - What could we do better
>> - Press/User Feedback
>> 2. Nomenclature - We waffled on how we described the release from = Xen
>> Project 4.4 to Xen Project Hypervisor 4.4 and other variations. I<= br> >> thought it would be good to discuss the naming for our projects so= we
>> have more consistency in how we refer to them.
>> 3.  Xen Developer Summit - August 18, 2014 -
>> http://events.linuxfound= ation.org//events/xen-project-developer-summit/attend/register
>> -Reminder for CFP
>> -Increased participation if desired by Advisory board
>> 4. Issues Roundtable

One addendum to the agenda, Sarah Conway is looking to do a Q&A s= ession in advance of the Collaboration Summit with one of our advisory boar= d members. She's reached out to one but gotten no response if you are i= nterested in talking about why you support Xen please feel free to drop her= a line at sconway@linuxfoun= dation.org
>
> The OPW internship and whether members would be OK to open an extra sl= ot for an extra intern. Xen AB is already sponsoring one but with the amoun= t of interest we could use an extra slot. The number is ~$6K.
>
> We have $40k (if my memory serves me right) allocated for this but nee= d an vote on it.

We have $40k approved and agreed to one OPW so far. I suggest you exp= lain the work the second OPW would do and get a vote pending our understand= ing that the budget is correct. Lars can confirm with Mike but I think your= recollection is right.

Regards, Mark


>
>>
>> Call-in information below, let me know if anyone has the desire to= run
>> the meeting in case my travel doesn’t line up I’ll sen= d you the admin
>> pin.
>>
>> Regards,
>>
>> Mark R. Hinkle
>> Senior Director, Open Source Solutions
>> Citrix Systems
>> p: 919.228.804= 9
>> m: 919.522.352= 0
>> e: mark.hinkle@citrix.co= m<mailto:mark.hinkle@citri= x.com>
>> twitter: @mrhinkle
>>
>>
>>
>>
>> Dial-in Details
>>
>> The Conference Room Number is: 6053208
>>
>> China: = +86 4008811076
>> Germany: +49 08007235118
>> Poland: +48 (00) 8001213973
>> South Korea: +82 (0) 806090880
>> United Kingdom: +44 (0) 8000284051
>> United States: +1 (866) 951-1151
>>
>> Other numbers both toll free and toll are at the bottom of the inv= ite.
>>
>> Meeting Dates   | UTC time     | Notes
>> May 21, 2013    | 14:00 UTC
>> Jun 18, 2013    | 14:00 UTC
>> Jul 16, 2013    | 14:00 UTC
>> Aug 20, 2013    | 14:00 UTC
>> Sep 17, 2013    | 14:00 UTC    | Same week as = LinuxCon NA, plan a
>> face-2-face
>> Oct 15, 2013    | 14:00 UTC    | One week befo= re LinuxCon EU and
>> XenSummit, consider moving by a week to enable face-2-face
>> Nov 19, 2013    | 15:00 UTC *)
>> Dec 17, 2013    | 15:00 UTC
>> Jan 21, 2014    | 15:00 UTC
>> Feb 18, 2014    | 15:00 UTC
>> March 18, 2014  | 14:00 UTC *) | Note that the meeting is one= hour
>> earlier than normal in European countries with summer time
>> April 15, 2014  | 14:00 UTC    | Consider a face-2-= face co-located with
>> LF Collab Summit
>> ---
>> *) Note that China and South Korea do not observe Daylight Saving = Time
>>
>> Call Toll-Free:
>>
>> Australia: +61 1800886154
>> Austria: +43 0800202142
>> Bahrain: +973 80081025
>> Belgium: +32 (0) 80039174
>> Brazil: +55 (0) 8000474900
>> China: +86 4008811076
>> Czech Republic: +420 800500441
>> Denmark: +45 80901917
>> Finland: +358 (0) 80094501
>> France: +33 (0) 805541041
>> Germany: +49 08007235118
>> Hong Kong: +852 30713072
>> India: +91 0008006501664
>> Ireland: +353 1800812610
>> Israel: +972 1809212874
>> Israel: +972 1809494119
>> Italy: +39 800906953
>> Japan: +81 (0) 120216700
>> Luxembourg: +352 80080918
>> Malaysia: +60 1800815377
>> Mexico: +52 018009250370
>> Netherlands: +31 8002658468
>> New Zealand: +64 0508800736 BETA
>> New Zealand: +64 0800452184
>> Norway: +47 80030216
>> Philippines: +63 180016510700
>> Poland: +48 (00) 8001213973
>> Portugal: +351 800784454
>> Singapore: +65 8001205610
>> South Korea: +82 (0) 806090880
>> Spain: +34 800900576
>> Sweden: +46 020980766
>> Switzerland: +41 0800000257 BETA
>> Switzerland: +41 (0) 800741205
>> Taiwan: +886 0800666844
>> Thailand: +66 001800658109
>> United Kingdom: +44 (0) 8000284051
>> United States: +1 (866) 951-1151
>>
>> Call Toll:
>>
>> Australia: +61 386447048
>> Austria: +43 (0) 720880195
>> Belgium: +32 (0) 2 8083570
>> Canada: +1 (416) 800-8947
>> Chile: +56 25952800
>> Czech Republic: +420 246019761
>> Denmark: +45 69918561
>> Finland: +358 (0) 942415730
>> France: +33 (0) 170610411
>> Germany: +49 81188997023
>> Greece: +30 2111768208
>> Ireland: +353 (0) 1 6526574
>> Israel: +972 (0) 37219621
>> Italy: +39 691717888
>> Japan: +81 (0) 3 45209439
>> Luxembourg: +352 20880370
>> Mexico: +52 (01) 5 511638996
>> Netherlands: +31 (0) 2 02629654
>> New Zealand: +64 (0) 99749585
>> Norway: +47 21518197
>> Peru: +51 17085569
>> Poland: +48 (0) 2 23987735
>> Spain: +34 931816662
>> Sweden: +46 (0) 8 52500100
>> Switzerland: +41 (0) 225331088
>> United Kingdom: +44 (0) 2033181172
>> United States: +1 (201) 590-2255
>>
>>
>>
>>
>>
>>
>>
>>
>> ------------------------------------------------------------------= ------
>>
>> _______________________________________________
>> Advisory-board mailing list
>> Advisory-bo= ard@lists.xenproject.org
>> http://lists.xenproject.org/cgi-bin/mailman= /listinfo/advisory-board
>
>


_______________________________________________
Advisory-board mailing list
Advisory-board@lists= .xenproject.org
http://lists.xenproject.org/cgi-bin/mailman/listinfo= /advisory-board



--
=
Sarah Conway
PR Manager
The L= inux Foundation
sconway@linuxfoundation.org
(978) 578-5300  Cell
Skype:  sarah.k.conway
<= /div>
--089e0158c158e3540e04f4e1cc4c-- --===============0013956396717041916== Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Disposition: inline _______________________________________________ Advisory-board mailing list Advisory-board@lists.xenproject.org http://lists.xenproject.org/cgi-bin/mailman/listinfo/advisory-board --===============0013956396717041916==-- From xen-devel-bounces@lists.xen.org Wed Mar 19 06:11:22 2014 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Wed, 19 Mar 2014 06:11:22 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WQ9iN-0004x9-Q6; Wed, 19 Mar 2014 06:10:59 +0000 Received: from mail6.bemta14.messagelabs.com ([193.109.254.103]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WQ5Hd-0004VG-SI for xen-devel@lists.xenproject.org; Wed, 19 Mar 2014 01:27:07 +0000 Received: from [193.109.254.147:62610] by server-8.bemta-14.messagelabs.com id 62/4A-01877-862F8235; Wed, 19 Mar 2014 01:27:04 +0000 X-Env-Sender: russell.pavlicek@citrix.com X-Msg-Ref: server-9.tower-27.messagelabs.com!1395192419!2598419!1 X-Originating-IP: [66.165.176.89] X-SpamReason: No, hits=0.0 required=7.0 tests=sa_preprocessor: VHJ1c3RlZCBJUDogNjYuMTY1LjE3Ni44OSA9PiAyMDMwMDc=\n X-StarScan-Received: X-StarScan-Version: 6.11.1; banners=-,-,- X-VirusChecked: Checked Received: (qmail 8961 invoked from network); 19 Mar 2014 01:27:00 -0000 Received: from smtp.citrix.com (HELO SMTP.CITRIX.COM) (66.165.176.89) by server-9.tower-27.messagelabs.com with RC4-SHA encrypted SMTP; 19 Mar 2014 01:27:00 -0000 X-IronPort-AV: E=Sophos;i="4.97,681,1389744000"; d="pdf'?txt'?scan'208,217";a="112711600" Received: from sjcpex01cl02.citrite.net ([10.216.14.144]) by FTLPIPO01.CITRIX.COM with ESMTP/TLS/AES128-SHA; 19 Mar 2014 01:26:54 +0000 Received: from SJCPEX01CL03.citrite.net ([169.254.3.141]) by SJCPEX01CL02.citrite.net ([10.216.14.144]) with mapi id 14.02.0342.004; Tue, 18 Mar 2014 18:26:54 -0700 From: Russell Pavlicek To: "xen-devel (xen-devel@lists.xenproject.org)" Thread-Topic: 4.4 Release Talk Slides Thread-Index: Ac9DDhJc5g8RalkZRKScsdkzy+g7BQ== Date: Wed, 19 Mar 2014 01:26:53 +0000 Message-ID: <55E78A57290FB64FA0D3CF672F9F3DA21BA6CF@SJCPEX01CL03.citrite.net> Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: yes X-MS-TNEF-Correlator: x-originating-ip: [172.16.2.30] Content-Type: multipart/mixed; boundary="_005_55E78A57290FB64FA0D3CF672F9F3DA21BA6CFSJCPEX01CL03citri_" MIME-Version: 1.0 X-Mailman-Approved-At: Wed, 19 Mar 2014 06:10:54 +0000 Subject: [Xen-devel] 4.4 Release Talk Slides X-BeenThere: xen-devel@lists.xen.org X-Mailman-Version: 2.1.13 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Sender: xen-devel-bounces@lists.xen.org Errors-To: xen-devel-bounces@lists.xen.org --_005_55E78A57290FB64FA0D3CF672F9F3DA21BA6CFSJCPEX01CL03citri_ Content-Type: multipart/alternative; boundary="_000_55E78A57290FB64FA0D3CF672F9F3DA21BA6CFSJCPEX01CL03citri_" --_000_55E78A57290FB64FA0D3CF672F9F3DA21BA6CFSJCPEX01CL03citri_ Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: quoted-printable Folks, I am giving my first 4.4 release talk at the Linux Foundation Collaboration= Summit next week and I am trying to do the release justice. I am trying t= o work up a decent deck of features and futures. The attached deck is an ugly transliteration of the 4.4 Features list (in P= DF and text). I don't care about the format at the moment; just the conten= t. My questions for you all: (1) Any problems with the content as it is? (2) Any topics I should add or remove? (3) Any details you suggest I add? (4) What more should I add to the Futures section? I have to put this puppy to bed by Friday, so any feedback over the next co= uple of days would be greatly appreciated. Many thanks, Russ Pavlicek Xen Project Evangelist, Citrix Systems Home Office: +1-301-829-5327 Mobile: +1-240-397-0199 UK VoIP: +44 1223 852 894 --_000_55E78A57290FB64FA0D3CF672F9F3DA21BA6CFSJCPEX01CL03citri_ Content-Type: text/html; charset="us-ascii" Content-Transfer-Encoding: quoted-printable

Folks,

 

I am giving my first 4.4 release talk at the Linux F= oundation Collaboration Summit next week and I am trying to do the release = justice.  I am trying to work up a decent deck of features and futures= .

 

The attached deck is an ugly transliteration of the = 4.4 Features list (in PDF and text).  I don’t care about the for= mat at the moment; just the content.

 

My questions for you all:

 

(1)    Any problems with the content as it is?<= /p>

(2)    Any topics I should add or remove?

(3)    Any details you suggest I add?

(4)    What more should I add to the Futures section?=

 

I have to put this puppy to bed by Friday, so any fe= edback over the next couple of days would be greatly appreciated.

 

Many thanks,

 

Russ Pavlicek

Xen Project Evangelist, Citrix Systems

Home Office: +1-301-829-5327

Mobile: +1-240-397-0199

UK VoIP: +44 1223 852 894

 

--_000_55E78A57290FB64FA0D3CF672F9F3DA21BA6CFSJCPEX01CL03citri_-- --_005_55E78A57290FB64FA0D3CF672F9F3DA21BA6CFSJCPEX01CL03citri_ Content-Type: application/pdf; name="Xen Project 4-4 Features and Futures.pdf" Content-Description: Xen Project 4-4 Features and Futures.pdf Content-Disposition: attachment; filename="Xen Project 4-4 Features and Futures.pdf"; size=492830; creation-date="Wed, 19 Mar 2014 00:48:07 GMT"; modification-date="Wed, 19 Mar 2014 00:51:35 GMT" Content-Transfer-Encoding: base64 JVBERi0xLjUNCiW1tbW1DQoxIDAgb2JqDQo8PC9UeXBlL0NhdGFsb2cvUGFnZXMgMiAwIFIvTGFu Zyhlbi1VUykgL1N0cnVjdFRyZWVSb290IDEzOCAwIFIvTWFya0luZm88PC9NYXJrZWQgdHJ1ZT4+ Pj4NCmVuZG9iag0KMiAwIG9iag0KPDwvVHlwZS9QYWdlcy9Db3VudCAyMS9LaWRzWyAzIDAgUiAx NiAwIFIgMjIgMCBSIDM1IDAgUiAzOSAwIFIgNDMgMCBSIDQ3IDAgUiA1NiAwIFIgNjAgMCBSIDY2 IDAgUiA3MCAwIFIgNzYgMCBSIDgzIDAgUiA4OSAwIFIgOTQgMCBSIDk4IDAgUiAxMDIgMCBSIDEw NiAwIFIgMTE3IDAgUiAxMjMgMCBSIDEzMiAwIFJdID4+DQplbmRvYmoNCjMgMCBvYmoNCjw8L1R5 cGUvUGFnZS9QYXJlbnQgMiAwIFIvUmVzb3VyY2VzPDwvWE9iamVjdDw8L0ltYWdlNSA1IDAgUi9J bWFnZTkgOSAwIFI+Pi9QYXR0ZXJuPDwvUDggOCAwIFI+Pi9Gb250PDwvRjEgMTEgMCBSL0YyIDE0 IDAgUj4+L0V4dEdTdGF0ZTw8L0dTMTMgMTMgMCBSPj4vUHJvY1NldFsvUERGL1RleHQvSW1hZ2VC L0ltYWdlQy9JbWFnZUldID4+L01lZGlhQm94WyAwIDAgNzIwIDU0MF0gL0NvbnRlbnRzIDQgMCBS L0dyb3VwPDwvVHlwZS9Hcm91cC9TL1RyYW5zcGFyZW5jeS9DUy9EZXZpY2VSR0I+Pi9UYWJzL1Mv U3RydWN0UGFyZW50cyAwPj4NCmVuZG9iag0KNCAwIG9iag0KPDwvRmlsdGVyL0ZsYXRlRGVjb2Rl L0xlbmd0aCA0ODE+Pg0Kc3RyZWFtDQp4nLWTS2vbQBSF9wL9h7schXp07zw1JWQRP0IKAbUxpBC6 EOrEOLVlKsmh/fcdOU5rxVay6k4jzj3nzDczkOZwfp7ejK8ngBcXcDkZw884QkCOiCQEWrACQSuE 2sfR3RlUcUSw+KtBNISqJ3o4i6PPcQTTmzHAQQD9CxjtZ7Uzdp+VSaJTWUJy5yCkgbGc0IF2miOB 4MYYgnIdR+n1ulh4DZMNnMoV/3tj8ihAKEXqRECaF23r6wrKJhhk0JRVNyMROcmdngxxcm/GqYO4 56aI8h2Mwjiu7Q4jKcslgaRAUQCR5S47wOiGMOp97OU8SGfhACzMHzpmO1OQwZAyEOQ4apivu30F munVbdjZoumWV3F0z75sm8avVpBYlhdPq2UyEqz0P5JvMP8UR9Ng3gW8uGokbg5N7xkcSI9KmqOS PBzGqaKUBeZq7/nVVwMFpBU8U301DGqzI21eJ5ptHn3ZwvSpqBZ+tWzaD5AQsfGyrRPFlr9e+w3T 7c7Ovljf/m5av24GyiiB3Jn+xJvobA+dAGm6+V6JjLvwJKRRXL9PzoVgkfXVQ+QITfcAetq83jwm I8kCuu6OQDKyTHH1MXwoNvNFu619ExaOFdV36CSz7e7fQIYhybUZ7rMD8gcXEwvvDQplbmRzdHJl YW0NCmVuZG9iag0KNSAwIG9iag0KPDwvVHlwZS9YT2JqZWN0L1N1YnR5cGUvSW1hZ2UvV2lkdGgg MTY1L0hlaWdodCA2Ny9Db2xvclNwYWNlL0RldmljZVJHQi9CaXRzUGVyQ29tcG9uZW50IDgvSW50 ZXJwb2xhdGUgZmFsc2UvU01hc2sgNiAwIFIvRmlsdGVyL0ZsYXRlRGVjb2RlL0xlbmd0aCA5OTE3 Pj4NCnN0cmVhbQ0KeJztXQVcVNn3X7vXXnMRRMTubhFEEQw6pLu7u7u7ZhiGoVsaVDAxQOwWMFAR ULED+H9nno4Ig4u7xu+/6/mcz/3cue/cc+Pce+K9+9789tsv+AW/4Bf8I5g3d97CBYuXLF4yevTo n92XX/AtoW/fvps2bbKzs8/IyKyuqn737t3bt++etLy7d+dx6xPk36Lk3r2GQxWHgoKCJSUlJ0+e /LO7/Au+GgYMGCAkJJSelv7y5av3799Dps+fv7h//8Hly1eOHzuelZkbE03O21d46tTpq1euPnjw 8MWLF+/oAMr3Z8+eNzMz/yX3/xcwcOBAfT39pkfNbW3tb968bW5+fPXK9UMVR7C7KRRKSEiou7u7 ra2tmZmZvb29t7d3ZGRkIi0xNzf32LHK69dvPn78FLXev29re9+empLGycn5swf0C3qEvXv33rxx q+19x5s37yC4O3fuXr169cyZM8eOHSssLExJSYmJifHz83NycrKxsXF1dQ0MDIyNjUV5QUFBRUXF 6dOnsf2hBKAKIPH2to73796HhoZOmDDhZ4/sF3wGmzfzVFWdef++/e2bd8+fvXz8+ElLy+Pm5ub7 9+/fvHkTcjzDgNLS0sxM+jaHlJHSaLTi4uLjx4+fP3++urr67Nmzt27damxsfPbsGTR7e3sHAfjp 6Og4ePDgnz3KX0AHCzOrt2/aXr9+2/r02eOWJ8+fPYcP1t7eDosM2Z0/f2H//v0BAQF6enqysrK7 du3i4+Nbv349Dw/Pjh07xMTEFBUVTUxM4uPjDx8+XFdX//Tp01evXrW1tXV0hvaOU6dO/fnnnz97 rP9pwI6jUpOftb588uTZ/fsPHzU+ev78OYTz5s2bu3fvYsNiL5PJ5ODgYGxPQ0NDeXn5PXv2bN26 lZ9/2/btAjt37pSQkFBTU4O4XVxcgoKCQFxWVgaFgN39mbTbOiD/e3cbVq9e/bMH/R+FKVOmHqo4 3tLS+vBB462btdDb2M4Q9+3bt6G9Iej09PTk5GRIMCw03MrSTk5WUVJSWlJCEntcWVkZmxq2Xlp6 r4yMnJKiqouLR2wsCeo9Ozu7qKgI5r6hoYGQNXY63Wt/3wZj8erFG3k5hZ899P8czOKeXXPmUuPD prra25cuXa6vpyvhO3fuQNCJDIADlpGRERQYoqGhA/mqq6tra2sjhaDl5ORQgp2Ofa2lpaWvr4/d DVWvoKBgZGialJQCg15SUoK0srIS5gChHNT7yxcvX7+G2nj7+lWbnY3jz56A/xBM+GPC0SOnbtff vXjxMkzqlStXsKOrqqrS0tKio6Pj4uKwSSPCI+Rk5SBciHX37t2bN2+GHl7JgOUMWLFiBfET5Vu2 bAENiCF6LAlNTc2cnJz8/HykWVlZcOSgN1paWhobHzU3t7S2vnjc8lJZUf1nT8N/AoYMGZqetu/6 9VvV1TWInmCgIQ54WYiYYHzDwsIiI6KhpbF/4YZBjhDrokWLZs+ePX369KlTp44fP74zN5RwcHBw c3MvXLhw2bJloEddWHklJSUdHR3IGiuHbtBLy5qamuAP1NXVPbj/kKFVHm7fJvSzJuG/A1ZWjtXV 5w7sP5iUlJSbm4s9mJWZZWZmZmVl5eDgYGRoBn9bSEho3bp1CxYs4OLimjJlSu+ZQ+6E0KHwofzF xcVjoumhOhw56I2LFy+ePHny6NFjWGBVp2uKCysmTJj4/Ub6C/i2bC8qOpCfX+jp6WlqampsbAyb u5UBiLDWrIGQ10Fvb9y4ce3atVDUSxmwZMkSpH379u1NE8OGDYPQoRNERUVVVVVRUUZGRkREBEsI P93d3e3t7e3s7L29fRzsnNRUtZZ8hKWfA0qgN773hPyLYfjwEZHh5PLyCnt7h6DQ0Cu1tR1fA3aO X+FfsbGxQehz586lUqlf1Qrgen39tfr6tJycCRN/7f2/D0oKWkWFpWlp6RA3tjM1MfF6Xe3VWzfP Xblcff7c6XNnq86dRaY7Xrp+DVKAg716zZreN8fOzn7mzBlUvHLzRneeaOs0A5FHBy7fuI7OXK+v BfGlG9dgXAYMGPD9puJfD5MmTvH1CSkpLvP394cx1dDQgFE+evz4/UePGhob6+7evV5be+3WrRt1 dSwR/jRdcDdujB07tjfN8fPzNzc3o8qt27fBuQs3oi2kuHq7oQF9eNDUdL+x8U5DQ01NzbZt2773 bPzrQWSPTFRkbHh4hK+vb2BgoKurKyzjrFmzbtbWNrY0P33xHNj89EnTk8ctrU+Bj5+1Ekj8RDmh aRFb/WVb8PoI4ofNTWAOtgRDghWzFbTY+vIFyvHzwaNG+O2FhYXQCd9/Mv7lMG7seAtzh4z0TEjZ 29sbG1xLS2vNmjUTJ07EVnrY9Ohx69OXb9+00e9ts0D6nbGOjrftH26D6+rq9tQQ/DSsB4Ls2csX r9+/I+ow+TB5vm17/+LNq1Yss+fPmltaEKBhHQ4dOvRHTsu/Fdav2+Lp4RsZGe3s7Axxh4WGIVbi 4eFZtmQ5TCQM5ZMnT953eajRM7x58wZuc/dWEJtfv3699y5ZW3v769evGxsbL1++jGj9x0/LvxL6 9OmjKK8eE0O2tbVzcnJCCGxoaIhoa/fuPfCcOTk5EWHFxcU9e/asnfnM8q/g6tWrv//+e+dWEGqB w1fIuq3txYsXDQ0Nhw4dWrRo0ZTJbH9OnfazpujfBJMmTdXRNoqJITk4OEKZBwQEYF9v2rRp+zZB zDMs+ODBg0eOHFleXo75773EExMTCf5YLYjiey/oDoaTD30CN41CoYwbN27rVn7BHTt5eLZ36Tls DQJwPj4+BOxqDEBm7dq1c+bM+WGzN2PGDOY9AWQQXf6wpv8eLF28ytjI3M8vwNHREcrczc0NWxuB 2LRp7FC/8LQJi8nFxQVVDO3ae4nr6OiMHz9+//79vRc0mMMWPHr0qLa21sjIaMyYMegJQ9vwcs2Y i2BBSkoqIiLi1KlTIPsyK/Q2ISEBffjyfb9ly5ad6gTJyckRrEBI6NMd3dGjR+vp6ZWVlWFNdm/3 5cuXJSUlCgoKvbzv9INBUEDExpp+I4vQ5JgfbG1paZlJkyaxsbENHz6cSQmDDkG8ffu2l7KDROBi fZWsMVcPHjyoqqqChkGLEhIS8BWRR6/OnTvXe1ZdABZh3bp1LIevra3dm46BDMTz588nk8noZG8a RYf/1w7jwXDvlVFxdnJzZGhyhGCYXoh7h4AQNiYUaRdnWF9f//Hjx1C2f3vmewIYaxj3O3fuwHXH Mhs7Fo2Pg4a0s7NjOb0QAapg7dEfnr58iaWFXn1Z80RHRw8ZMqTLDEAD9KZ7/Pz8iB//UqV0gZs3 b44aNerHifOvYMSIkYoKGr4+9POE7u7uMNybGTBtGgfsNeKmQYMGdakSFRXV2tra9fQRK2jvaG9r /wsyELx+8xrYwoi20AeixWls0yDrixcvEmRv3r4BDdK39JPs9KNTMCuEzofffunSpRs3bkAtQO7t dJG3E02/b3sPYlREhuBz7NixLhK/desW0Q0C6YcsPuK79+/QIlERer776Jhsu5ej3Q7GmsTE/jhx /hXA490ro+Tm5gGTDYcKsS1kDaXdr18/yBpRGDJdqkC9FxQW3G2496i5icDmxy2dsamluRHFjAxx lSDDz875+w8f3Ll3t7a+7lZd7dVrVy9euigmJgb+/fv3RwolQ2xqNFR/5zYo791vQJWHjxoJhHAL CwsFBAQIc4NNxMvLC6EwGyK68aDxYcOD+6gOJMTh5+/PHMvUP/8EDVGFQOaggER1FD5++gQpGkVn bt+9A1bgSYyFWZFAZrvoKurevd9w7dq1HyjPvwDO6dxysiqenl6QNSJuCB2GUlSUPu0DBw7sydmY PGXK/oqKc5cvV58/X3Px4tlLl7rgmQsXcAlIZJASZEiJKtXnzlVWVR09caL8yJHSgweTU1O5Z836 jWFckC5YuBCybn316kRV1Ynq6tM1NUQtAs8yUlpy8pCPhoaoBZgzd+75K1eIDnzW6LlzJ6urT505 U9/QUHX27KSPLzXwbt36sLkZNERvmcisDgT9CUZXDx46VHzgAIVGy8jJwc8z588TzAliJjLHi4pV 585dvHoVDuf3lmMvYRb3fHk5FR9vX8jaz88P5ht7REFBkbjKnMbusHLVqgMVh8qPHD107Pjh45Xd EeVM7FxYfuQYMgcPHykq259bWJSdl2/n6DRixAgmZwTs0OpNT5+VVRw6cOhwxVE6PVJURHqk8gSw +tyF6dOns+xhXmERWgEls2kiRfX9FYcOosPHKzds2kQQa+vqNrY8xaXOve2CpeUVBSWl6Tm5OwSF mJ7MkqXL0Lcuo2OOEa0TeOTEyZNVZyb+zzy5mztn0d69ShC3v79/UFAQAjGEsWpqvTo4JC4lXXSg oqDsQH7p/l5iXklZXnEp0tyiktTM7KT0TFEJyS5s9YyMX3V05BQUg4Zepbh0X1EpUqJ6fsn+89du ZucX9dSrk+cuFJQeQJXOCFY5hcXIFB0oLyk/xMPLSxB7BwQdPV2N8h67WlyalrMvikzhnDGDqMJc YNb2DmjoSyMtKQMBmuvuH/4smDN7kexeJU8Pr2AGYHcjztXQ0Ohldf+wiNTcvOTs3N5jUlYOLTM7 IT0zJJo0b+GiLgwnT5168MRp8EzMyAYx0kSsiqwcoiLyafvyL9yqb2xsPM2AU58DSu60PI1PTe+O lOTUuORUZFJy9m3YRI/yBgwcSE3PBEOwZdlPlKMDlNS0TTxbuo9dTEr6C2Mnup2QkRVOjv9nIvqW MHPGPBlpBXc3j7CwsPDwcB8fH/hIKiqqf1kRKzY+Pr75XQclNYOUlNp7JCenkZLS7Fw8xrB6VCq5 V+5I9fnohKTYxJSYhGSkzIpECTIxtGRycnpSdl56QXF28f6c0gNIgRmFJdT07ChqYhg5PiIuoQuG x1FDYuLCSPFgvmT5CrTFwTkDfGJoKcDu/UQhWoymJfuHR7E0aiJS0plFpSzHSO8qvXpqVHyiilaP D4x+GMAHI4bAwT5TRprumSO8QliKDQ5fV15e/svVOTk5z5w586Stg5ScHklJjIxP6iVGUZNJyRlI B/XwipC5nQMlNQs8w+MSunKmJEZQaEhDydTgGHJwTFwoKR5kEQziMBI1jExFJiSWEhJDwaXOiELQ B0bGBkTEhJIoM2bSb3XybOUvOlLJoiFGW/Ty+CTwVNc1YNlVdT2DtIIS1sNndBWIpleuYX1750cC wisivJ00caqYqIy1tS2JRIqLiyOTyYIMGDp0WE91d+zY8eTJk9NX6khJGdEJqcDYxLReIikpvaD8 WMv7DmVNHZbMIylJpMR0UMbQWLBFWygPj6MFRpJ8QyP9wqIDIkiBkeSASLJfeDQQmcBuGBRFR1D6 hkR6BYWHxiYQLr2ajn5e+fFoakr3tlDCGFc62uLdtoNlV32CIhMy9vXUT6RRCSlgzlKJ/WBAbEuE q8OH/y4qvFdXRx+CplKpqampQkJCu3bt4uHhZVnRwcEBoWvZ8WpySiY1Yx+BCZl5H3Ffp8LO5Z8w Kafw7tO391rfrt2wqQvzwYMHJ2YVEAxZcqBl5SVlFypqaE9j52DjmD7taxG12NnZ2D8caAyIImcU Hfi8/58NBNKMT8tmn87iRujUP9mSc4toWfksh0l0Pi4t2zcs6luK7R/A6NGjR44c2ee3PruEJOXl lChxlMTExLS0NFlZ2T179piYmHehR/BYWFgIWWcUHKCkZGMqknMKEzPzMf/IIIWk8BMpM09c6oz0 S5n5uaWH6WvmWNWkKVM7NzFs+HCwpaRmE3WZ3Jh80vJKMovKdwqLfYPhjxmTkluckltE8O+CRLu0 jLwoSgrLmw+beLcePXsFZMSgulbPzE/OKUpI36eha/jPu/pNAOIm3rjcsJ5fQlwmPDyCRqMlJSVh /woLC5uZfSbupUuXIha+/uBpLC0tigrHJpOSmkNOzoxLyUImLiUbGSKPQlxl/CQK4dnmMBE/QYBM dkkFJO4ZEDZw4KebtHAnQmJhjhNjEtIIMoLtR8xO3VcKFJGQ+Y1VxD1nzpwlPQPxgJJr5kyCeNnK 1bllR5ld6ozMzsfQ0g1MrVjOnpKG9v7KM0QPe6iejerrNrFw6X8KjBgxgp2dfejQobO5F0qIy7q6 uEHcycnJ2OPi4uLS0tIzZ84iKJWVlV++fJlffjwgAqYwLiSWGkqi0dPYhDByIvLI0JFEC4qmgIYg +1DIoGHiB2J69YT0wgOPXnXIq2p27pWytr5XcIRvWAyYgBvR1oeKJBopKavmxn1LB7fuw4F7+eWb 8yl5JeCzcQsfQS8iKVNQcSI4hkr05zOMhb9HDYqm+keQ+LYLspw9R09/CLSn6igPjIoLio77Y+Kk byq0vw+w3RwcHGxsbOPGThAXk9fU1E5KSk5JScnJycHUSUhIaGnpDBw4MDIy8nlHRwgpydknxMUv zD0w0iMoyj0wAqlHcBQzj3JcBY2jV6CjV5CTdzB+guATJRMZxESaVXastPLcitXrmb2aNp3T1s3X 3sPfwTPQ0TvIySfY2Zferpt/uFtABLilFdLVgr+/P3Yr6DEEfn7+ffv2vevoiKJlgoDJHPSu/mGu /uEufqHoDxhqGVkwHwFom1gGRFNRDv4s0CfEyTvIxTeUaeg7A4yOT2isq18Y0b3uiHJwtnRksSx/ IkyZMmXBggXDhg0TFBCXlpJFLJbBAE9Pz40bNy5cuPDEiROl1ddtPQItnL2t3fyQsXEPACLTOY/U 0tnH3NHLzNHTxM7d1N7DDOjoZe3mT1wl6JlIVATaeQcXn7wUEEObMOnTCYSFy1YY2riY2LmZ2rub OYCPJxDMzZ28zOk8/WJTC1502rbIU7LLHH1CCc4gAFq5+lm5+Fq6+Fg4eZnYexjbuclr6o/4eJ4K niouWTp7d27iM3TwMHfAWDxYRtwzZ89zCYgydfAw7akuUnvPXeL/W+frxo4dS7zNt3DBCmkpBUsL q8zMTKh0Z2dnXj6+m83NQdR9upauupYu+tbuhrZe+jYeBkBbTzoy8vRCa3cdCxctMyctU0c1I1tl PYtZ8xat2bRVy9RJz8qFICMomfihuq0n6pq7BOWduK5maDNo8Ic7jVxcXDNmzVXQNlE1tFY3ttM0 tdcyddAk0MRBy8wR/SEYEkyIjJ6VG8p1zJ11LJy1zZ00TR01TOzBVs3ARk7TZNGyNZ0FN3HKnxiX pok9HZnMO6GGiYO6kd1OcTmW87aWZ5uOpbPGl6rbaxjbzVu84kdIsdcwatSouXPnrl69euLEydKS ynJySiEhIbq6ulZubofq3hq5hCjoWSvo2ygbOSgbOygZ2SNVMXZESi9hFCoa2MrrWcvpWu7VMpfR MN0tqzl+In2f9h8wQEhaVU7XCgSd6zKRKEQGqaFzUGxhFd9uaVQUF5fctm0bnIphw39fvp5PREFb QsVQUs1YWt1EWsNEWtNURtNMVtsCvVIytCOQ3gddK1l0QNNUSt1EUs1IQsVATElPQlmfd6fkdO55 ffv17zLw2QtXSKkZiasYSPSI+uAzf/lalvPGt0tKQtXwi9UN9mqajRr7x/eW4NcCnPMNGzZApa9d s4V/q+DiJct9E/ODs07t1XMQUzWV0LCQ0rKS0rSS1LSkZ7SskX7Ia1qJq5uDRlTFWFjRYLe83gYB sSFDP510GjthioiykZiKiaSG5adadA5M/FCI1MA1wj48a9ailQICAlJSUpaWlhoaGsuXLx8wcNA0 rrkLVmxat11sm7iKkIymoIymkIzWLlmd3XJ6uxX0kO7cq7NzrzZxSUBKYzXfLu5FKydMmdZ/4EBm Z7ro5PGT/pzGNW8a15yecS479/yhI0aynDQ2rjlsM+jYU3V2rrkc3Au+k8j+CYwfP554A3f0qDHT uJfElF+3DE4VVTcTVjERVTMX17T8iFZIxTToiLyYuoWIqukeZWNhZaOd8vpC8roLV23pHp/OXb5h j5KRqJoZUZFRlwWKaViAp3V4loZd4PjJbJKSktR4KoVC0dHRWbFi5XR2rn59PwRrg4cMGzlm/CR2 LmK2mThlOjfKR47pupv6MOBHzOP/H5g2bdr8+fO3ikhlnH+u4xoppm4urmEhid2nYyOlY8tAm49I /4lLIIAQRVVNhZWNdyrocXDPZ8kZbjCfmDIYSmhafaxu8znaMnnKGjr5pBzFQtq1RyQuLi4pKUlJ SUlUWEJQQGTu3HmAcePG9eZJYm9EjIhjGAOGfwSWx7R62VZ36EKmpqa2jwHObm4//WEoAnAnf/+y G68MXIIVjRyVTZ1VzFyRKpk4Ie2MKFE0dlQwtJM3sJXVs5bRttgjrz12wpdCy3ETJ8vq2cgb2KFi F26d2RKNGrmFU8svC8mo6ujqampqKimqKitpb9zAB+9i1qxZXc6E9DS3vYGsrKzmbnDnzp28vLxN H08+fEOgJCaevXz5wpUrBSUl30PbbN68GbGzgoIC7PKXKRGLHTp0qPTiA2vvCFOXAGNHX0M7uues b+thgIydl+FHNCDKbTz1bNy1LVw0zZyEZVSGDhv+Zf6ANZu36lq7GdgyXPpODD9ja+uBvIlLQGhq 8b5TNzfyC61auVpRUUNGWg3zD3FPnjy5y2spfxugcw4fPfqwpelhc1Nz61Ng09MnD1qaGxofEpGd l5fXN2mIgEmTJt1uuFd/987t27dNTU2/IWcCoKnAGd1+/KzVzMzsC5RYDA0NDQdrbnmGxSGQdPQN s/cOsfUMsvMMtvMKRr4LohCXEE1buvpuFRLu27frqUWW0LdfPzUDi554fuDsSefs4B3qEUquvPog /8i5WXMXbOMX2cLDKyQkhPChyydf/gkg/GxsbHzz7m1LS8uFCxcqKytPnjx569at1tbWF6/ohyEx JzAc36o5WAp+fn4+Pj6kX/Vhk14CbDFxDvzdu3dwuXsiE5Hcm5xfFkFNCY5NCIyi+IXH+oRGe4dE eYdG+/SAuOQZFOkaELps5Ve8tg+YyjbNIyjCKzSqJ87MptGN4FhaTFJWCJk2esxYbG345wgfvuFp bfilHYxXHmpra7m5ucF59OjRU6dO9fPzQ2F7e/vTp0+3bt0KSiwzFPr7+xO7UlBQMCcnR19fn8mq f//+WI0kEgka8uDBgyBeuHBhl+bAxIkBioqKXS7BZYImKSsrO3z4cExMTE+fEIRmMzIyys7OPnHi RH5+vo2NDfND8VpaWighlNLr16/Dw8PRW1FR0c7VBw8ZomdiTklJj4xPCCNRgunPgqP8wiIJ9A/v EQMiol28fDg4OdEx9P+rzJzgHuEvcAYyWw+KjImIo8anZbr5+GFCsHq/7UlOa2vrDsarPZBRZ0uK ddXW1oadgl1PiNvc3JyYSWgAxIYdjM+3Mt9FhW5E+Yez5R9fZ8CCMTEx6dwc8ZYK2JaUlDAL4Rb6 +voyPgzbTqQdjBcrVFU/O0eE5aSurk68mtTOAKKVs2fPIp4CwbVr1zp3gHg1w97evsuQBw8ezDGd k4NjOjv9QTDHNHYGcnxEdnbi0fCnEgbOmDlz5cqVCJRsbW0jIyNTU1MPHDjQnTlLQM+Jhrqz7Y7o FQfnjIWLF3NMn/4N1TgBpaWl9FuvL15gwn/rFJLv2LGD2CN1dXUwuCiB50ZMJl35v3mDaUeG+P6P oaEhQYwSaAlYTywS4nUqzDyxWgig0WgohKXw8fEhSrA3YT4gmkePHt28eZP4liBYEWRsbGzMupmZ mSh8/vz5vXv30AqcyaamJhDfv39fXFwcPjY8TOL7tKiOS+hGfX09tFAvpwIcoDqgkVatWjWTi5uP V1BIUFhIaJeSkjI2BTpMpVLLy8uhVRBWQL0ghTKBHjt+vBJ9A83atZ/dicLawKxiyGFhYdBI8B6l paUlJCTgeFtZWtnZ2Tk4OMDBYByo2MKzmW/LFoE5cxZiU8+ePRuW7hvaUALA8GZtbTtDKMLCwszy iRMnFhcX19+5c6uurqiIfswVnuHFK1ceNDY2tbQ0NjXVMcrJZDIuQYEz3ndowPxHRUWtW7cOHdbT 06urr7/T0PCouTk3N5dYRQi7qmtqmh8/xmLA2Im23NzdUf3egwfY79ikiAGhJ2/fvdvy5Mnzly8R fv7GWITWtrZEK1evXsUUwS6vWLEiJCSkpqaGeD9x5MiRUlJStfX1T1pbGx488PDwgKAxqK/6TxAs bHQeSx1aa9u27VoapnY2Lna2Tm5uHpAsfBsM/OHDh1jq16/fgNHB0LALCgoKCgsLMWOlDChjwP79 +5GiEKsiJSUFcxUdHZ2WlgYCVDx+/DiUQ1RUtIW5hZ6uoZ6usY6WKR+vAC8vL4zFjBkzvsd3zpcu XVpZVXW1rg7iDggIwDRCS0NkEMf+w4dzMIyyslWMDwotXb782OnThyorK44dyy8pQSHxNA16ODUr q6yiAqip89kRLH0jo8OVlUdOnDh47BhhgGbNmXP01Knj1dWV1dVcjHeBl69cSbcO1dVoqPPrltb2 9ifPnj1ZU2Npa4uf0zk56xoaSsvL0atVnT5whD782Wn7T5w0CczRz6MnT3L93XeN4RphWqAu4JZg M2qoG4UGxYUEx0RGxmRmZl2/dh3ODN2PffECOgRyr62tO3XqFHY91gMhd2wE4sOnAEIbYJ1AHUEL YalA7WBfoDw0NMzFxc3FycPFydfE2FFwxy4REREsdUTZhDr95rBhM09pxdG0nLziiiO1DU3vOjou 3qzPyCukpqTHxNMiSJQt/B++87NHXLy88lRqNv0INA/fJ+W8YRPP2Ss3kzJzYyiJIxkOJDP8X7Nu fVZBcfq+gqT0LOIS/44dlTXnURIWTRrIuI1jYml98uzFI1U1mBC4dtitxJHvQyerU3PyUrPzVTXp r5pKychXnr2QnJnj/DEqZHmTYQsf/+kLVzPzi+NoyV84XviXAAdp0aJFAgIC0LrwFmSk5R3sfKMi EmKi4smk+LLS/fV19fB2XjO+Wvue/m8TbYQvAVcBOwU2BSnEStC8ZAAyMEMwWFVVVXFxFD9ffx/v QF+fUE+3MGUlbXFxCWj+jRs3fj9ZA4QlpHNKy0NjKUEx5KBockBUbGBErF9YlHdQuIaeIVun7/yo aOrEJqWFkuK1DT9zvbT0jXL2V5CT05U0tbowF9wjQkpKC4mNs3b+8KRbU984ITM3kpqkqsk4ftyn j6OnbxQ1OSohOSYxDeUR9DOrieFkBEckdAPpqnX0p/8OHj60rDxySsY2wZ1fGI6qjl5iTn50QrJ+ t8NmXwuITRBEYP5lZWUNDAxgUxTkVXy8okgxybHR1HgKLTMDocHJ+vrbkGNPrwATH69+9eoVpH/+ /Hns+5iY2JDgsMCAsODAqMAAkq62uYSEpLy8PPY1jCAXF9d3/a8KK2f36ITUUHKCuYOL+F4FCVkF USnZLfwC3Y8xWDm5xSSmR1CSNmz+7JSmmZ0TOGQWH9Q0/OyeyYABA9KL9ofF0cIpNN5tAijp17+/ e0AoJS0HfHi20pXGgIEDvYIjomlplLRsRXWt3aISu8QkhSVkdolIbBUQwmrZKSI+4veRYOUXHh2X mp2Qlbdj156exoLN7uztT0rJpKTnCOzskeyrAPOPCIWfn19FRQVCl5OT09TQD/Inx8WmxZGSE6ip tISUjIzsw4ePnjlTU3urFpYdihqeJFzEGzduXLp0+ciRI/l5BWQSJToqNiIiNiI8LjKcGhlGMzd1 EhMTJz6lCwUOZcLJyfnN/fDOAAVLSs4gp2TGJKUvX8364SYBw4ePiKKmkFOzyClZ8xcu7nxJ18Qc G/Ni/cPHz55hZohCBO+IU6jp+6JpKQFRpEGD6KfoR48ZCw7JuYWQ2ux59McKffv18wwMReHhmkvr P38zpXOwjCjG3T+YlJTx6HXHgcqTTB0OF9rT05N5IGfosGGhsdSs4oM1N+5gV9JLhg7955+MgCmf M2cOfHU4hBoaGnCwlZWVlZRUzE2tgwOiadSchPjMxIQMWkJaAjUF0k+kYQ1gJSRR45Pi4mhkUgKZ RCPFJMaRUiPDE+1sPdRUtOBSYuXARd+yZcuSJUugwL/HHacuMGf+wvC4FK9gqO7IPxi3+nu66z5z 9tzg6HhvUAZHjfvjM22zaMly94Bw75DoVx0dMEzw92CCEU8FxyZ4BUc6evijFYKSnYMzipoOPv7h ZOahNSUNXc/AiEPVV2HXXF1dEWgjnLl06RKq7xaV7PNRWDt2CXsGRQREUaAh4dM6OzsjJoLdjKFl KGvq9e9P/2Lk2HF/eIVEh8TSXjK+FOEXTtIxsezlrc6/BFjzefPmrVmzBt4+FDsCT8hdTU1NTk7e zMTCyd41KCAygZKRQstJScpJTKAjVkJSQk5oMNnTzd/a0l5dVVNGRgZLBYoCfiAfHx92BwKuH/YX JLzbd5o6uBtZOytrGX/5UcVG3u2gNLZxUdI26n51j6ScgZWjmb27tVuAvTf99q+lk7eJnauWsRUb x6dD6avWbw6hpFs6+2iZWBMvrQMmTJyMn4ZWzmb2nlauvtaufuZOXkY2LkY2rtt2iTJ7NWz4CHVD S0MbF3NHT8bt5RA7jyALZx9LVz+xvUoEt99Hjjaxc0NdYzt3MydPsBLY8w2OZHcGDg4OhGkIADds 2AC5w+bq6upC9PDh4dQpKirKMkBTQxNhJoSLLYy1oc4A+gNNUVFIGXEWdjQ0RudbCj8ANm7bvUtK aae0yvL1rF+aYMJ6vp2g3CWjunwdC8pBQ4YuXrlhp5SyjKaJnJa5nI6FoLji0jWbhw4f0Zlsp5SK spG9gp7V5h0incvHT5y6YetOMQVtKVVDGXVjMUWdzQLC7FxdvxY1ZvyEdbyCooo6exmtSKkbbxEU mzHn013xPn36Ll/PIyynKalqIKmqv0NcYfyE7/VnfLCz2OzLli3Dfufh4YGex4aF9LFzofCJb15B +pA4RLx9+3YYF5gDGGhIGWvmp7zy3PuHj316YQH79us/YtTY0eMnDhsxqsulP6awbxVXsYnI2qNk vFvJ+M8ZLD78NXjIsFHjJowa+8fAQV96Aj5w8JDRDLJBQ1jHWag+/PfRg/9BFPZVwM7Ozs3NjS2P DYtdD5mu/Aj4CXW9ePFiLIyZM2d2+Y7TT4HePyL/MmX3S8wSzL+UtqWRR5SUlqWYuomApGr/AQO/ XL33XeoN2Y+HyZMnf7/Y+X8cxv0x0cTJR8/GTdvCUUHLeNKvjz3+q2HMuPG7xCQEd4ts5OH7X3j9 8xf8F+D/ANXK5mENCmVuZHN0cmVhbQ0KZW5kb2JqDQo2IDAgb2JqDQo8PC9UeXBlL1hPYmplY3Qv U3VidHlwZS9JbWFnZS9XaWR0aCAxNjUvSGVpZ2h0IDY3L0NvbG9yU3BhY2UvRGV2aWNlR3JheS9N YXR0ZVsgMCAwIDBdIC9CaXRzUGVyQ29tcG9uZW50IDgvSW50ZXJwb2xhdGUgZmFsc2UvRmlsdGVy L0ZsYXRlRGVjb2RlL0xlbmd0aCAzODE0Pj4NCnN0cmVhbQ0KeJzFWmlYU1cazkZWIIGQQFgSQtgJ yBIggICgsieAClioxQUURVzqgigq26iodRed4tKZCh3H0WqdWoFqW2rVtijqAyIgUBQERKyIgECW ORcSudlYnqcD7w+e3LPc857vfOc77/kuCMQ4MOdY2VhZsIzHazc9MDC2dPGdGxIWHiGICA8NmePj yDaiTjcpBegxrDxmhwsgCNdv3vSxEPoVFuDKppOnm5ocFCM7f8BwXs7XD1qlI+hpuHksSSgI8eLQ dKeb3jDoVn4RggX774ukSnjx72RhqIe5wfTT1GfzwwQx53qVGY6gIk0Y7GamR5xejjS7uYKoE13q KQKIf0gSzrahkqaRoq6xS1hkXotGihAGriwMcaBNH0sy0yci+tKYFCE8Sw2bYag9TRx1zf2F8ffH 5Qj2epbA3Wh6WOow/YWprQpsJKKh/nc9PX1DQyIJvFx0KsqdPh0rTjKZKUzvgTPpba/64eLZw/sO FJ4vqfijq18Mq7wa5WowDXuc5i5I7YZRbKsozkoMD/DxdPfw9psbs/b4jfoumDmLIh308FPNkWwT ltj+gYK4/fbhxABXOwtTGlRpyraZwY/eeb329SjL4yEcXdzUciQxAxdUfCDQd//0qmA+l6KjhRxt YuMRnVdW8+Ecer8twsZID4BCJqKnhiSVF/XlB469T28UnSrIz9+9zZ2Cgk3ExmvFxceD8lZvr5w6 tD8/Pz9vwxwSUvOb/zqQ2CEp/WqCzd2Z2vDxrYIOvlZt9CwaPpX/H6juCyrVcJRKzjliPzRCEu1z 36i2adjsojMVJImsoCx1HKXS/i1mcodDkb2KBlQaiGvy5prgp2K5KU4x1epJSl/M0x9hgKKH/apa PVSRF2ahMxUbB88I2C4PgT3KNO7OJAKWSKx5crMaQ5dummlCmBKPJFlF/Sgbtf0nZa8Tn7LVQiBJ TvlvVTlKytd7GGKnZGsjdLlLZAaUnMwqVta7vWuMMXq+l4bUOcONYAYeicJTDJlsNpOujRmXL4ZI oehRiJjJk9TnH5IN+mxlUNIVZTp/RNvOf6COolRaH+nkNku4ek/h1WvXvjm2Y/5sHpssc1AkzsTN f5avp5sLgLMdg4BE63K8BZt3gfi7JZLPmmRsxTPCbsoG3RvA4qXckShR+f1wm3qO0sEzV6s7YcKj u65kg68pDhofbbyt42Vn59NqCFWV+WyGe0pZiyw8iJ5/HW6CHZcZDASzhTKFNhRjTaa4ZdQqUZGo xnnlecDQdtybCrYSzuMXeOkPCbtrFK52rzM5WpOxJHOpbIUbfGhEjIFf/kvNFGSzqRaPUVvzEQON 0Il+AS/7/ZFyj95VhpMICwROpqxfoTUJh8Qah/793dgc35Xs7x6r/uXHdDQ9VSHy96m2qvaZhIoi 2p6UdZtP10IjkHjz2EuDqu8cxYsv0tJewZ5FHfd+vt8Bt9QTf23Lo2POE2AgkTJhjigC94Ksm+9w XEaRbJeXa15O0aO9McJimFMOlO9PTVx9DO7JkiwW/6ZyR7GyI+eYTniHo/AzvpW92hMx3AtNdtlU o4ljf1l6oHs6fPV+2+Bna2EvOAvfF//1EDQodJN0Vdz4pV2hSHrEYsJOicQ6fy+zkbusE4bqs6tD PceuomQeOxxOoO/S2qig2cGf/ANOsjx0uYLXip+cSEtY+aWir+/hTHznYBxkJMV8uRLHmsRdVVU8 oEX9kQW2VOsj8IUTvX3dCdClcGzejstRWNznu0PtzZ3XK1xGB7cwJx7QUTby5fbFyaaGs96gEEDk r72zM8hcmzirTk2dIn5adlFhcl+GGuPRBvEKGuXVCsbEfRJpId84oaThMw1JdMhVo8ClkoqtPgw8 ipwwZvwZxrdrH8Efu9OtwDGk97FCAH4UpT9hQ6JxDHkIWqGHQUHq1vsr9SGoNcUcjEVbO8Z5I5vO kXSFTfL0IzoSgTRKew8vPO818fwCRpuSLut2yRSHRmAMBRVSDSj1xCOQZtnwov7ntY+Vce/rFTsU XPo7fx0weetT8LLBHJtJnIt6dKHsWOzgamvhOKma02pDn1likOb58KL2wo1paWlr1m3ckiHHllVR wSfgbcT7uOBwwXrfhRe+WmkyiWNRj8WT7RJRMF3f9bCGBOowupcbopmZ8Ej/bD3P1tbONXLvqTMy nD6+3nm2Qih/s44JnF076jm8sGrexF0SgdAxdymXddzLCy9VSUMroCFcz2QtPNr8ucmWbGAdWQJv dJ4rVAjljR/RwD6mJisc4F/7TCblpc3mH5R1fJk9bnT5gW8aXwkvqCtI3FqkYKPuNOdlCgGgLBC4 pJKbDOXZTkpQmvjEyI8ClXuYCsTHvaPOqNE0o+grDnPZDg8Aks8cgUti3K7DW3WtNp3UBY7KW3hH 45A9yor3Xdbi3DHUpKSjaAmXfx5e9HYDC7gkIbgeXvhkweS+XVEcFuzSEPrEdZdvKd952vc+1Ehx sO367vm2NC8FVV4fB7mkTjRc3kn/4zPJXLFZyKf1UnUYKN+ZuFWF0rMPU1CY2sCbpp+LshP4TG2S 8+dVzztkeFFz1Au4JEI3sLTuhbzw+YMUq0m5JAJB46+9os6U3RdX8q19816pqRqufnT7fs3z9vaO jvbW2kclxYe2JIa4mVOwKKzZ3NSsPIBcgO0pgaaQBCdaRa/PzpUhI5FH1WG5utvpTdgxUa6ZT9SQ aP08nqtPZISfU39IDpXtTUldk5EFxszOXL88NtjbkU3XhoSUFjMiLWPbtm0Z6xaFeLnYGBEhJlpk loOrmwxOHKq2bXFjU+VMjeliJI5qYqKPk2sQjHFygyoHUdVegaUOGkngJKk/Jqtygp0sbJ1cwJgu M+wtzehkgiw7gPeqez8Aobf58wAGUWvYWkgMjkiSg4jHUKI6wZ0xUuMnVS1OzoWvNjNGrvFIgk26 GoU78GPGLFPisN7g5XSq4dhzdr4JGY0lDI9MwGFQo7pL/5PRUFbpqd5WSMONoLYmgqLJkOQFIC7e dBj2XKSOx2k1+dN3320MpI/YGmMY9k/VBRf9tNWVpv79KNbfQESQiIcD1VC6Kc3KnmVgYmeujUIS jJ28+HZ0LBKBMl11p67qmJcOEmtg58nnynJKaDKH5+NuScZoe5yUQF852AQooxf8s5o903d9TzyP RR+ZE56zTPUbVOfpuWYarIBxvQY4tlTcrYWC/uVZa+7eu5pwuu4CR5sV9sXjttbKXBddJMZqV+0f FUssCHru2RUtbVX7XHWAmtN2SL3R9LK5PNHa9VoH9JKqI0wgTdwq1Trc4Ok4YZCvqx2Hbcq24iWc UhHBfZn2mgQCIRjcHAf/tXbFPug6V7r0V+B7QANf9/UpGFG94h+9dfB8EEtfxzFMYx8MG0lS4kZA G4SWjKxZd748PV7BAxcFmxUXbj2ofvy4rvHFm364TXu/ixQIBOEQohZl/qdeoXKwo2wRW5P4p3zy J7D0Zp7jkgfQzWEr8GhItXyxtPxD/2I7PSjD8SzWJgnyd6havMOUJmiSN/huv+zHdT7YQwbOwmWp QBGmbd97vrJFUQINNF7dLhQIhAW3XyoehG8fFi5205SERprmAZesWeM79xCwf9++o8NH1sCrgzeg qTc3QhnQzmirjUCmVy2c91gqfV//+wtggV/85gB7S/5saO4VV6bn1IMh+1vvZ9gDRyXSWNa2wwiI zS59qu6OqAxJW+n2cGcdTUlGDBf60tv28LdaaOl+31oKdWm5cuA4WMCuy/v3XAIKaShzVhEo/nYx uF4NPSz+eylQf03LjoOGjed25Z+5sCk8ARJ/1UeX+xhC80ZhtLAj4PikXqoeXwcNPv13khsTHnIU gfO9PTqfxpxUyDFbjyUuAT44dC3J1/9TIAdF+QvBXhw8mgbWfLC9uakVmLU5B7hyb2Gsl1fgHFdr IagX/TPSlkZQej3LJbagokNtTnd02J7qwhguQwNBCKTR5EXfvRzB8jZoaKFTAriadWW76DMSmkCE 27oabN6uzK2wdMG9w+ChOc2arEs10KUuAPTfbLImYlTOTVOHuZlljW/GUGL9LTdzwmwNx+CI0F/8 J/SN9+2b9sqza3wdVwEfbFhhYbQIlHauY+EstoFlr121E/ytS80F7tXT0dLS2v6yqeDoIHSvNMBR GbpoajJg/DServZot/KMO3CruVeDchtou3Mo3oOjIYiPAMXcDbZf+zenjuSuDHWgW0G76FYIxeBj oFPElyJ9N4F73lBh3DExlFndDpa57fqXRf999NW2+Lz30Af/wNm53wfRmTsA48p1swzVfn4xs5+Z eKKio3dIhaeo/2XFycXediZjUQTxYjiU30ie4+1qbUjCO18BT0VueErYPcifa6qAhUT3kiMuguLi sFXAvOJnD+veSatieclQFub1w6di6WNfh2Ng/N7WajcNOUwW13/pwZLazneiUb0oEfV1Pik5uMyf azY2RRDKg56CqLKHRyOTcGgkfjbQV/07rDBE5zz5nhTdT/cRghA6sMsjokQ+RE0wM7BY7mdNAufD wz+q/TXe1tiO/NDl+y5XPuvq6Xs/8L6v51Vz5eX85eFeXOZ4FMG9LviPgcGmRYwRbyLNaRgYbEww QmGMhUWvoD35vvP6Jv8ZK8HZ07XSkrv6zjtAU/SmYp2THmfZjz3gQdz9aAvPLqVVLJV0n3Ef60rJ 4XrMWbg660DB2XNfnPhsZ1p8EM+ebTQ+RUBrxpqCk596kEciFHFG2vET6911kUiS5bzdl397cOur 3Yv4Hlt/BWweRNKp7iknb9777VrBGj8jPGXG0mPfV94vK/w0wMRoZuY3d8sOxFiM8+8J5jaOrh58 bz8fvrsL15o50SsJlubo5+dIw8qfuH5+XOgJrc3yjFq64pMITw57CZQUGjjKI2GptgEfJSfFzXY0 IqC09Kz9Y5OSF85xYhCJDPeoRTF+HN2Jfbc0HismqgEKRzYw0MWiVJ5QOIqxhaW5EZnA2gPtofIE phYSQzRgcjhmBiSgl5FoItWMw2HSSFpIFE7PmGVqQBz/I9tfDXC6YdAoBJq5ub79+bernXQhBkg0 KJRTgT0gUWiNh9oUAE2bmZqdEeesP7FPjP8DU/4xtA0KZW5kc3RyZWFtDQplbmRvYmoNCjcgMCBv YmoNCjw8L0Z1bmN0aW9uVHlwZSAwL1NpemVbIDI1Nl0gL0RlY29kZVsgMCAxIDAgMSAwIDFdIC9S YW5nZVsgMCAxIDAgMSAwIDFdIC9CaXRzUGVyU2FtcGxlIDgvRG9tYWluWyAwIDFdIC9FbmNvZGVb IDAgMjU1XSAvT3JkZXIgMS9GaWx0ZXIvRmxhdGVEZWNvZGUvTGVuZ3RoIDQ1Nz4+DQpzdHJlYW0N CnichcKHUtoAAAbg57K1e9s6URFRBJGhgKAQwgozEPYeYQuIgAytdu9l28fqH+Odd613/e4bmzSO nb+GU3wT//o0d5xLjM9cvIGzxE2umX9rDkmugLwtIO/gvAXv8hes987fX0TbAyHf/nCJ+0iEDny8 jNQTMXdC7JxYcT5dRdczlLgmJe6pNfRMS7kzMu8srvtwTu4TyGnBBj2v8OOCMoCLqoBQxQjVzJI6 KNoMirZCy6gJizXhFW0EV3VRlGzH1vQxqT4uNcRlhoRsJ7G+m0S5MbVhSilMaQWRVhIZpTmrIrNq Mqe25Dat+S20FTT2gtbOah2szlHUUaVtqqR3lvWussFdwR1PdddTNXprRl/dhPQegf6GOdAgA02S aVqYljXYsob2baG2Ldy2Y+TAEelQ0Q4V6zox3nNh4tCNyb4HUwNveuBLD5HOjOjsyI+5owD3mMkf M4XnQe5JkD0Jsaeh4mkYSy8iWH4ZxQq+imH1dRxr+CaB9bdJ3MN3KWzg+zQ28UMGW/gxi/v8T7k2 /3MeD/hfCtjhf2W7l4vdb8XexVLvO/fwcrn/46+V/lll8M/hWXX488q14a/a6D/ro9/1oyv+Aajc mCENCmVuZHN0cmVhbQ0KZW5kb2JqDQo4IDAgb2JqDQo8PC9QYXR0ZXJuVHlwZSAyL1NoYWRpbmc8 PC9Db2xvclNwYWNlL0RldmljZVJHQi9TaGFkaW5nVHlwZSAyL0Nvb3Jkc1sgMCAzODAuNzMgNzIw IDM4MC43M10gL0V4dGVuZFsgdHJ1ZSB0cnVlXSAvRnVuY3Rpb24gNyAwIFI+Pj4+DQplbmRvYmoN CjkgMCBvYmoNCjw8L1R5cGUvWE9iamVjdC9TdWJ0eXBlL0ltYWdlL1dpZHRoIDUwMC9IZWlnaHQg MjA1L0NvbG9yU3BhY2UvRGV2aWNlUkdCL0JpdHNQZXJDb21wb25lbnQgOC9GaWx0ZXIvRENURGVj b2RlL0ludGVycG9sYXRlIHRydWUvU01hc2sgMTAgMCBSL0xlbmd0aCAxNjgwMz4+DQpzdHJlYW0N Cv/Y/+AAEEpGSUYAAQEBAEgASAAA/+EAXEV4aWYAAE1NACoAAAAIAAQDAgACAAAAFgAAAD5REAAB AAAAAQEAAABREQAEAAAAAQAACxNREgAEAAAAAQAACxMAAAAAUGhvdG9zaG9wIElDQyBwcm9maWxl AP/iDFhJQ0NfUFJPRklMRQABAQAADEhMaW5vAhAAAG1udHJSR0IgWFlaIAfOAAIACQAGADEAAGFj c3BNU0ZUAAAAAElFQyBzUkdCAAAAAAAAAAAAAAABAAD21gABAAAAANMtSFAgIAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEWNwcnQAAAFQAAAAM2Rlc2MAAAGE AAAAbHd0cHQAAAHwAAAAFGJrcHQAAAIEAAAAFHJYWVoAAAIYAAAAFGdYWVoAAAIsAAAAFGJYWVoA AAJAAAAAFGRtbmQAAAJUAAAAcGRtZGQAAALEAAAAiHZ1ZWQAAANMAAAAhnZpZXcAAAPUAAAAJGx1 bWkAAAP4AAAAFG1lYXMAAAQMAAAAJHRlY2gAAAQwAAAADHJUUkMAAAQ8AAAIDGdUUkMAAAQ8AAAI DGJUUkMAAAQ8AAAIDHRleHQAAAAAQ29weXJpZ2h0IChjKSAxOTk4IEhld2xldHQtUGFja2FyZCBD b21wYW55AABkZXNjAAAAAAAAABJzUkdCIElFQzYxOTY2LTIuMQAAAAAAAAAAAAAAEnNSR0IgSUVD NjE5NjYtMi4xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AABYWVogAAAAAAAA81EAAQAAAAEWzFhZWiAAAAAAAAAAAAAAAAAAAAAAWFlaIAAAAAAAAG+iAAA4 9QAAA5BYWVogAAAAAAAAYpkAALeFAAAY2lhZWiAAAAAAAAAkoAAAD4QAALbPZGVzYwAAAAAAAAAW SUVDIGh0dHA6Ly93d3cuaWVjLmNoAAAAAAAAAAAAAAAWSUVDIGh0dHA6Ly93d3cuaWVjLmNoAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRlc2MAAAAAAAAALklF QyA2MTk2Ni0yLjEgRGVmYXVsdCBSR0IgY29sb3VyIHNwYWNlIC0gc1JHQgAAAAAAAAAAAAAALklF QyA2MTk2Ni0yLjEgRGVmYXVsdCBSR0IgY29sb3VyIHNwYWNlIC0gc1JHQgAAAAAAAAAAAAAAAAAA AAAAAAAAAABkZXNjAAAAAAAAACxSZWZlcmVuY2UgVmlld2luZyBDb25kaXRpb24gaW4gSUVDNjE5 NjYtMi4xAAAAAAAAAAAAAAAsUmVmZXJlbmNlIFZpZXdpbmcgQ29uZGl0aW9uIGluIElFQzYxOTY2 LTIuMQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdmlldwAAAAAAE6T+ABRfLgAQzxQAA+3MAAQT CwADXJ4AAAABWFlaIAAAAAAATAlWAFAAAABXH+dtZWFzAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAA AAACjwAAAAJzaWcgAAAAAENSVCBjdXJ2AAAAAAAABAAAAAAFAAoADwAUABkAHgAjACgALQAyADcA OwBAAEUASgBPAFQAWQBeAGMAaABtAHIAdwB8AIEAhgCLAJAAlQCaAJ8ApACpAK4AsgC3ALwAwQDG AMsA0ADVANsA4ADlAOsA8AD2APsBAQEHAQ0BEwEZAR8BJQErATIBOAE+AUUBTAFSAVkBYAFnAW4B dQF8AYMBiwGSAZoBoQGpAbEBuQHBAckB0QHZAeEB6QHyAfoCAwIMAhQCHQImAi8COAJBAksCVAJd AmcCcQJ6AoQCjgKYAqICrAK2AsECywLVAuAC6wL1AwADCwMWAyEDLQM4A0MDTwNaA2YDcgN+A4oD lgOiA64DugPHA9MD4APsA/kEBgQTBCAELQQ7BEgEVQRjBHEEfgSMBJoEqAS2BMQE0wThBPAE/gUN BRwFKwU6BUkFWAVnBXcFhgWWBaYFtQXFBdUF5QX2BgYGFgYnBjcGSAZZBmoGewaMBp0GrwbABtEG 4wb1BwcHGQcrBz0HTwdhB3QHhgeZB6wHvwfSB+UH+AgLCB8IMghGCFoIbgiCCJYIqgi+CNII5wj7 CRAJJQk6CU8JZAl5CY8JpAm6Cc8J5Qn7ChEKJwo9ClQKagqBCpgKrgrFCtwK8wsLCyILOQtRC2kL gAuYC7ALyAvhC/kMEgwqDEMMXAx1DI4MpwzADNkM8w0NDSYNQA1aDXQNjg2pDcMN3g34DhMOLg5J DmQOfw6bDrYO0g7uDwkPJQ9BD14Peg+WD7MPzw/sEAkQJhBDEGEQfhCbELkQ1xD1ERMRMRFPEW0R jBGqEckR6BIHEiYSRRJkEoQSoxLDEuMTAxMjE0MTYxODE6QTxRPlFAYUJxRJFGoUixStFM4U8BUS FTQVVhV4FZsVvRXgFgMWJhZJFmwWjxayFtYW+hcdF0EXZReJF64X0hf3GBsYQBhlGIoYrxjVGPoZ IBlFGWsZkRm3Gd0aBBoqGlEadxqeGsUa7BsUGzsbYxuKG7Ib2hwCHCocUhx7HKMczBz1HR4dRx1w HZkdwx3sHhYeQB5qHpQevh7pHxMfPh9pH5Qfvx/qIBUgQSBsIJggxCDwIRwhSCF1IaEhziH7Iici VSKCIq8i3SMKIzgjZiOUI8Ij8CQfJE0kfCSrJNolCSU4JWgllyXHJfcmJyZXJocmtyboJxgnSSd6 J6sn3CgNKD8ocSiiKNQpBik4KWspnSnQKgIqNSpoKpsqzysCKzYraSudK9EsBSw5LG4soizXLQwt QS12Last4S4WLkwugi63Lu4vJC9aL5Evxy/+MDUwbDCkMNsxEjFKMYIxujHyMioyYzKbMtQzDTNG M38zuDPxNCs0ZTSeNNg1EzVNNYc1wjX9Njc2cjauNuk3JDdgN5w31zgUOFA4jDjIOQU5Qjl/Obw5 +To2OnQ6sjrvOy07azuqO+g8JzxlPKQ84z0iPWE9oT3gPiA+YD6gPuA/IT9hP6I/4kAjQGRApkDn QSlBakGsQe5CMEJyQrVC90M6Q31DwEQDREdEikTORRJFVUWaRd5GIkZnRqtG8Ec1R3tHwEgFSEtI kUjXSR1JY0mpSfBKN0p9SsRLDEtTS5pL4kwqTHJMuk0CTUpNk03cTiVObk63TwBPSU+TT91QJ1Bx ULtRBlFQUZtR5lIxUnxSx1MTU19TqlP2VEJUj1TbVShVdVXCVg9WXFapVvdXRFeSV+BYL1h9WMtZ GllpWbhaB1pWWqZa9VtFW5Vb5Vw1XIZc1l0nXXhdyV4aXmxevV8PX2Ffs2AFYFdgqmD8YU9homH1 YklinGLwY0Njl2PrZEBklGTpZT1lkmXnZj1mkmboZz1nk2fpaD9olmjsaUNpmmnxakhqn2r3a09r p2v/bFdsr20IbWBtuW4SbmtuxG8eb3hv0XArcIZw4HE6cZVx8HJLcqZzAXNdc7h0FHRwdMx1KHWF deF2Pnabdvh3VnezeBF4bnjMeSp5iXnnekZ6pXsEe2N7wnwhfIF84X1BfaF+AX5ifsJ/I3+Ef+WA R4CogQqBa4HNgjCCkoL0g1eDuoQdhICE44VHhauGDoZyhteHO4efiASIaYjOiTOJmYn+imSKyosw i5aL/IxjjMqNMY2Yjf+OZo7OjzaPnpAGkG6Q1pE/kaiSEZJ6kuOTTZO2lCCUipT0lV+VyZY0lp+X Cpd1l+CYTJi4mSSZkJn8mmia1ZtCm6+cHJyJnPedZJ3SnkCerp8dn4uf+qBpoNihR6G2oiailqMG o3aj5qRWpMelOKWpphqmi6b9p26n4KhSqMSpN6mpqhyqj6sCq3Wr6axcrNCtRK24ri2uoa8Wr4uw ALB1sOqxYLHWskuywrM4s660JbSctRO1irYBtnm28Ldot+C4WbjRuUq5wro7urW7LrunvCG8m70V vY++Cr6Evv+/er/1wHDA7MFnwePCX8Lbw1jD1MRRxM7FS8XIxkbGw8dBx7/IPci8yTrJuco4yrfL Nsu2zDXMtc01zbXONs62zzfPuNA50LrRPNG+0j/SwdNE08bUSdTL1U7V0dZV1tjXXNfg2GTY6Nls 2fHadtr724DcBdyK3RDdlt4c3qLfKd+v4DbgveFE4cziU+Lb42Pj6+Rz5PzlhOYN5pbnH+ep6DLo vOlG6dDqW+rl63Dr++yG7RHtnO4o7rTvQO/M8Fjw5fFy8f/yjPMZ86f0NPTC9VD13vZt9vv3ivgZ +Kj5OPnH+lf65/t3/Af8mP0p/br+S/7c/23////bAEMACAYGBwYFCAcHBwkJCAoMFA0MCwsMGRIT DxQdGh8eHRocHCAkLicgIiwjHBwoNyksMDE0NDQfJzk9ODI8LjM0Mv/bAEMBCQkJDAsMGA0NGDIh HCEyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMv/AABEI AM0B9AMBIgACEQEDEQH/xAAfAAABBQEBAQEBAQAAAAAAAAAAAQIDBAUGBwgJCgv/xAC1EAACAQMD AgQDBQUEBAAAAX0BAgMABBEFEiExQQYTUWEHInEUMoGRoQgjQrHBFVLR8CQzYnKCCQoWFxgZGiUm JygpKjQ1Njc4OTpDREVGR0hJSlNUVVZXWFlaY2RlZmdoaWpzdHV2d3h5eoOEhYaHiImKkpOUlZaX mJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4eLj5OXm5+jp6vHy8/T19vf4 +fr/xAAfAQADAQEBAQEBAQEBAAAAAAAAAQIDBAUGBwgJCgv/xAC1EQACAQIEBAMEBwUEBAABAncA AQIDEQQFITEGEkFRB2FxEyIygQgUQpGhscEJIzNS8BVictEKFiQ04SXxFxgZGiYnKCkqNTY3ODk6 Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqCg4SFhoeIiYqSk5SVlpeYmZqio6Slpqeo qaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2dri4+Tl5ufo6ery8/T19vf4+fr/2gAMAwEAAhED EQA/APn+iiigAooooAKKKKACiiigAop0UUk0qxRI0kjnCooySfQCvQ/DvwS8Za6qSzWaaXbNz5l8 2xsf7gy35gUAedUV9Daf8BfDOmqH1vXLq8kHJS3URL9D94/qK2I/Cvw50df3HhkXDD+K4ZpM/wDf TH+VFgPmGivp+TVPDdouLTwZpURHIZYY1/klMt/EOkSApceFNMlU84Maf/EGnYD5jor6kNn4I1Nf 9K8GWEeephhRT+ahTVG7+Enw81dT9lS90yQ8jypmIz/wPcP5UgPmmivaNa/Z41SJGm0DWLW/TqIp x5T/AEBGVJ+uK8u13wtrnhm48nWdLubNicK0ifI3+6w+VvwNAGRRRRQAUUUUAFFFFABRRRQAUUUU AFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQA UUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUVYsbG61O+hsrKCSe5mYJHFGMljQBXr1HwL8E9b8T+X e6tv0nSzhg0i/vpR/sqeg9z+ANej/Dz4Q6b4VWHVdeEd7q+A6RYzFbn2H8TD+8eB29a9SEzzt7el OwGP4Z8FeGvBsATRtNjWfGGupfnmf6seR9Bge1a1wZZgRk49KuRxKgy5564rMv8AXrK2yiHzXH8M XT8W/wAM0XAy7y1PO7isWfSrmdT5NrNIPVUOPzp+peJL5s/ZxHbj1VQzfmf6Yrhdd1G6uNxvL2WQ H/nrKSP1NIDcu9Cuwx3/AGaMDk+bdRIR+bCq1vos2/C3OnP7JfwnH/j1ecXc8BY4kU/Q5qrFLEG5 cUAe4WmjXoGVgMi46xESD/x0mtW3t2RtsiMpHUMMV4np1xGJVMdwquOmHwa73SfEGsQBVW/lkQfw THzF/Js0Ael2cJUgqSv0NaUtpDf2j2t7bxXNvIMPHKgZWHuDwa5fTPFCvtF3ahT3eE8f98n/ABrr bO6t7qLdbyq47gdR9RTuB4942/Z/0zUkkvPC8g0+75b7LISYHPoDyUP5j2FfPmueH9V8N6i9hrFj LaXK/wAMg4Yeqnow9xxX3bWJ4n8K6N4u0ptO1i1WaLko44eJv7yN2P6HvmkB8N0V3fxF+GGp+Arw Skm70mVsQ3arjB/uuOzfoe3cDhKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKA CiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAs WNjc6lfQ2VnC01zM4SONRyxNfTXgDwPp/gPTVnlEdxrU6fvZ+uwf3U9F9+p/IDlfhl4Ug8M6Wda1 OL/iY3CfIrDBhQ8hfYnqfQceues/4SO0aYmS7jznn5hT2A7CCR55CzHOe5q1danbaXb+ZM+Nw+VR 95/oPT3riLzx3pWmWodriF5X/wBVFv8Avf7Tf7P865C98a2UjyXt7qEbMep3foAP5CkB3t9r91qJ Kk+VBniJDwfqe9cbrXj3StKDRRN9ruBxsjPyg+7f4ZrzvXfHc+rFre3m+z2nQqGwXH+0f6dPrXKT 6kkZxCA7d3bp+VAHZan431nUt2yRbWH0j+X9ev61zE+po7lprxpHPJ25OfxrElnlmOZJGb6nio6A NY6lbf3Zz9T/APXoGpW3/POUfRqyaKANlNStycb5o/cjIrU0/Wru2YGxvzwc7A2PzU/4VyVFAHsG i/Eme2dYtVthKnQyRgK/1x0P6V6Xo3iGy1OMXGmXgZk+8FO10+o6ivmCDUp4htfEqej9fzra03VH hnW40+4kinTkAHDD/EUAfWum+J0ciG+IRjwJegP19PrW08mBkHIPSvnjRfiHBdIltqjpDc9Fl6LI f6H9P5V2Oj/EaysWW1u7yNrUnCtu5j/xHtQB6VfQ2ep2M1hf28dxazqUkikGVYehr5W+KHw3m8E6 p9psw8ui3DnyZDyYm/55ufX0Pce4NfQMvizTjyL2Eg8ghxyPWqOp67omtaVcaZfywT206bHRmHI9 vQjqD6inuB8mUVr+JdF/sHW5rNJ1uLfO6CZT99D0J9+x9xWRSAKKKKACiiigAooooAKKKKACiiig AooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAC iiigAooooAK7P4ceHRrGurd3EYa1tGDYbo8nUA+w6n6D1rjVUuwVQSxOAB3Ne6+GdOTQfDsNsAPN cYZh3Y8uf5KPYU0Bu6ncfaEMUbsEAwvPP1+tbHgzW49TSTSruG1/tG1H8Vuh85P74yOvYjtx6isC CMykKBudyFUdyTXD6/qtxbeIIL7Rp/Lk05z5Eo6SH+In1Vun0xSA9+ktcHP2Wz/8BU/wqHycHm0s /wDwFj/wpngnxbY+NdAj1C3AWdfkubfOTFJ3H07g10n2GOT7oxQSc95A/wCfSy/8BY/8KXyP+nSz /wDAWP8AwroRpw9BS/2cPQUAc75H/TpZ/wDgLH/hXLeP/AEPjXw632O2gh1uzBe3aNAgmXvGQOOe 1el/2cPQUz7G0Th0GGByKAPhaWKSCZ4pUZJI2KujDBUjggj1ple9/HT4cja3jHSIMA4GowoOh6CU D9D+B9a8EoKCiiigArV8O+HtW8TavFp2jWsk903OV4Ea92Zuigetb/gH4a6x47vMwL9l0yJsT30i /Kv+yo/ib2/Mivp/w34S0rwnpI0zRrXyojgzTNzLO39527/ToOwoA5Hwj8PNN8IQebIsOp6zImJr yWMMkfqsSnoP9o8n2HFdR5H/AE6Wf/gLH/hW8un57VJ/Zw9BQI57yyBj7NaY/wCvZP8ACk8sj/l2 tP8AwGT/AAroTp49BSf2cvUgUCOe8ot/y62f/gLH/hUqWmetpZ/+Asf+Fbn2WNP4cmqmpX9jo1hL e6hPHbW0S7mdzgYoAp/Y4wCWtLIAdSbZP8K8h+InxS07TxLpWgQWdxeAlZLlbdPLiPoMD5j+g9+l c38RPjBeeJGl03RC9npfKtIOJJx/7Kvt1Pf0ryugdh800lxO80zl5ZGLMx6kmmUUUDCiiigAoooo AKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigA ooooAKKKKACiiigDd8I2JvdfhbbuWD96R6kEBf1I/KvZHGx0jU5SMbQP5n8Tk/jXAfDe1CiW6Ycl +D/uDI/Vv0rvlAJzT6AN1K9On6RczrxI37iHB6MwOT+ChvoSteb6lceVbbQfnk+Uew7n/PrXVeK7 kma0sweIY/Mcf7b8/wDoISuA1OcSXrrniIBR9ep/oPwpAX/CPjG78DeJotRtcvA+FurfPEqf4jsf 8TX17oWr2Gv6Rb6np0qy206BlYH9D6EdMV8KyOZJGYnOTXpPwi+JD+DdYGn38pOjXbgPk8QOeN49 vX8+3IB9Z0UyKVJ4kliYMjjKsDkEU+gAooooAjmgiuIJIJo1kilUo6MMhgRggj0r5C+Kvw+l8C+I z9nRm0i8Je0kPOz1jJ9R+ox719g1h+LvC1h4x8OXOj364SUZjlAy0Ug+649x+oyO9AHw5XsXwy+C V14h8nWPEiSWmlHDxW33Zbkep7qh9ep7Y4Nd18OvgZaeHrkap4kaG/v43JggUZhiweGOfvN35GB7 nkex0AVrPT7TTrKGysreO3tYV2xxRKFVR7AVYCgdBS0UAFFFFABQQD1pCQoJJwBXlnxE+L1p4e8z S9GCXmrEYIB+SH3cj+XX6UAdV4w8b6T4QsvMuX8y6fiG2j5eQ+w/qeBXzr451bXvF8M19qcxjijX zYLONjsjAPOf7zY5z+WKkEpuJBrOq3Zubq5QM0sp5z0KqOwBzgCuo07wP4n8S26C10wWloSf9I1A mIMpGDhMFznjHAB9aEB4RRX0jo37N2jQKrazrN5dv1KWyLCn0OdxP6V2unfB7wHpoBTQIZ3HVrmR 5c/gxI/SgD45or7otfCnhyxAFpoGlwY/552ca/yFXk0+yiXbHZ26DrhYlH9KAPgmivvC40TSbsEX Ol2UwPUSW6Nn8xWHe/DLwTqCsJvDGmru6mCEQn80xQB8V0V9Rax+zx4TvUY6bc32myn7oEnmxj6h uT/31Xlfiz4GeKfDkT3VkE1ezTktaqRKo9TGef8AvkmgDzGigggkEYI6iigAoq9ounNq+u6fpqZ3 XVxHCMf7TAf1r6r/AOFF+AP+gTN/4GS//FUAfI1FfWZ+AvgMsSLG7AJ6C7fij/hQvgT/AJ8rv/wK agD5Mor6yPwE8CEECzvAT3F03Fcr4++D3g/wv4J1PV7Vb77RBFmLzLjI3EgDIx6kUAfO9Fbnhnwf rvi++NrothJcFceZL92OMerMeB9Op7CvbfDn7OFnCEm8R6vJcP1a3shsQH0LsMkfQLQB87UV9m6b 8KPA2lAeT4cs5SO90DPn/vskVux+F/D8SBY9C0xFHZbSMD+VAHwrRX3HP4L8LXIIm8N6PJnk7rGM nPr93rXK678EPBOsxN5Ng+mznpLZSFf/AB05XH4D60AfI1Fd78QvhVq/gJxcs4vdKkbal3GuNp7K 6/wn8wfXtXBUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAes+BbdYtFjPcxc/ 8CYn+grqgmBgdT0FYHg9AukoCM4iiH/jtdVaopuYSeR5i5/OmwOC1uUTa9esDlRKyIf9lTtX9AK8 5muDL5kh4MjM30JNdleu4tbmXOWEbvn3wTXB7vlxSASiiigD3v4IfE7yjF4U1mb5TxYzOf8AyGT/ AC/L0r35LmJv4sV8EI7RuroxV1IKsDgg+or6P+GfxFPiPSxY30oGq2qgNnjzk/vj39f/AK9AHtXn R/3xS+dH/fFciNQb+9S/2g396gVzrfOjH8YpPOjx94Vyf9oN/epv9oN/eoC51wnjP8VHnx/3xXI/ 2g5/ipRqDf3qLBc67zo/74pPPjxneK5E6g2fvUyXUnHG6gLnXNeQr/FUM2qWtvC800qxxRqWZ2OA AK4DWfFVnoVg95qFyIo16Anlj6AdzXgXjb4kap4tka2R3ttMB+WAHmT3c9/p0+vWgDu/iT8bpdQa XSPC8pjg5WS9HVvZP/ivy9a838H6Dq3inWn03SoGnuJSHkmkPyRL/E7t6c/U9BzWFpem3es6pa6b YxGW6uZBHGg7k/0r6l8LaLYeCtCTSNOKvKcNeXQHzXEnrn+6OgH9SaB3NLwd8PdB8IwQSSsNS1SM f8fk6g7DnP7teiDJPPXnrXaC8jNciL1j/FTxfY/izTsK51n2qM96es8bd65H+0G/vVw3xS8e3Hhr QEtrCQpqF9lUcdY0H3m+vIA+ue1ILnd+I/id4V8LymG/1JPPHWGIF3H1AyR+Nc/bfHvwVPMEkuLi EE43PA2P0FfKckjyyPLK7PI5LM7HJYnqSabmgZ946fq+n6rYR31hdxXFtIMpJGwYH8RVnz4/71fM HwL127ttZ1HSfMY2ktubgITwrqyjI9Mhv0Fe5f2i3940CudWbmMd6YbyMd65f+0G/vGmNfE/xUWC 5ynxS+Fen+LLS41nQ4kg12JS7xoAFuwOoP8At+h79D6j5gZWRirAqwOCCMEGvseO/khnWQN0PT1r 5m+J9jFY/ELVFhULHM6zgD1dQW/8eJoC5p/BTSxqXxP093AMVkkl0+f9lcD/AMeZa+t1uY2HWvmr 4E2vkvrOpkc7Y7ZG+pLN/Ja9pGoMOA1AXOt8+P1o+0R+tcl/aD/3zR/aD/3zQFzrDcxjvWH4u0C2 8YeHn0a5uWgtppY2mZPvFFYMVHoTgDPas/8AtFv73NUdQ8QwabaS3d5crDBGMs7nAoC512k6dpOg aZDp2l28NraRDCxxjH4k9ST3J5NXRcQn+MV846x8eCkzR6PpxlQHAluG25+ijt9cUzQ/jrcS6jFD rNjFHbOwUzQscx+5B6j/ADzQB9JefH/epfOj/vCuQXUSVBD5BGQQaX7e39+gLnXedH/eFNNxGO9c n9vb++aT+0H/AL1AXN/UYLDWrC40y+iWW2uozFIjdwa+KfFGhyeG/E+o6PIxY2k7IrH+Jeqn8QQf xr61N6xbO6vnH4xlX+I97IPvPFEW+uwD+QFAJnBUUUUDCiiigAooooAKKKKACiiigAooooAKKKKA CiiigAoopyrlSaAPZfBh83TSMj/VxEf9811tug82Ln+MfzriPh/OJLVIyfvW64/4DxXfqm1VZOow R9abA8iveNPuyf8AnhIP/HTXAV6lf2iRX9zauP3aytG30BIry4gqxBBBBwQaQCUUUUAFdR4E0LxB rHiCGbQR5T2rB5buQ7YoF/2z6Hkbep7CtTwT8NrvxGkeqao0ljoe44lx+8uMdViB6+hY8D3PFey2 tvb2Onx6bplqlnp0RykEfOT/AHmPVmPqf5U0hNl17kK5CybwDjcBjd747Un2o+tVRC2aXyWqrEFn 7UfWj7UfWq3kmjyTRYLln7UfWj7UfWq3ktR5LUWC5YN0fWua8V+OrHw3b7Wbz75h8lup5+p9BW/G myRWZdyg5I9a8b+Kng2XQtZOsWzSzaVqLl0lc7jG/dGPt29qTGtzkdc1/UPEN8brUJi7fwIOFQeg FZdFFSWesfB/TI7eO916QZn5trf/AGQR87flhfxNeopcHGSa5PwDYGDwRpoA/wBYrSn33MT/ACxX TeQ1UkQ3qWPtRPel+1H1qv5Jo8lqdhE/2o+tZOveHvDHim4t7nWLK8e4hhEIMF1sUjJOcbTzz+lX jEQrFiFVRkk9hXPnxV4dB/5DVn/39FFhjR8NPAR/5cNT/wDA0f8AxNL/AMK08Bf8+Gp/+Bo/+JqR fFvh3/oNWf8A39FKfFvhz/oN2f8A39FKyC7Lmj+GvDfhiea40WyuY7iaPymkuLjzMLkEgDAxyBWq LxvWuePizw4RzrVn/wB/RSDxV4bH/Mbs/wDv6KeganRfbG9aDeN61zv/AAlfhv8A6Ddn/wB/RQfF Xhvtrdn/AN/RQI6EXzBhk14X8UZhN48u2HaOMH/vkV6cfFfh3cCNZs/+/orxrxbfJqvizULmBhJG 8oVGXkMFAUY/Kkykeu/DCD+z/BNu2CHuZXnYfjtH6LXZi6PrWVpWnHT9Js7MdLeBI/xA5/Wrohan Ym5Z+1H1pPtR9ar+S1BhaiwE5ujjrXinxT8RTahrn9kxyEWtoAXUHhpCM5P0BA/OvYJE8tCzEAKC ST2r5q1S8Ooard3hzmeZpOfQnIpMqJUzRRU9jaSX9/b2cX+snlWNfqTipKPpPw7dSHwzpJkJ3/Y4 t2fXYK0/tR9aqJaCCNIYwAkahFx6AYp3ktV2M7ln7UfWkN0fWq/ktSGFqLAWDdnI5r518c6kNV8a ancg5XzfLX6IAv8ASvddWuP7N0q8vW6W8LSfkM181OzOxZiSzHJJ7mkyoiUUUVJQUUUUAFFFFABR RRQAUUUUAFFFFABRRRQAUUUUAFTW+CxBqGpIDiVc9DxQB6H8PLkLJBExxslaJvx5H6mvXIxhRnmv CfDVw1tqjopwZlDof9tf8/pXulpKLmzhmQja6hhTewHEeKbTyNclYDCTKsi/lg/qDXlHiG2Ntrdz nJEreapxgHdycewOR+Fe6+LbPzbCO6XloGw3H8J/+vj868t1rSJ9ev7K002Ez6gxKeWvXZ13EnhV Xkknj5qQHFKrOwVVLMxwABkk16/4O+GFvpnlan4thEk5AeHSSenoZ8dP9zr646G/4X8N6b4ORZ0a O91sj5rzGUt/aEHv/tnn0x1O19qZ2LMxJJyST1q1Ehy7G5JdtcOpcjCqFVVGFRR0VQOAB6CnrKqi sQXW3vzS/az61ViTcEy0GdTWH9rJ701r3HQ0AbvnKOpo85R3rn/tjE8GnLenoTQBv+etL561hfay D1pftZ9aLAbRmXNJdJY6tplzo2qLvsLoYfHWNuzj3FYpuz60jXRI60WA8L8U+G7zwrrs+mXYzsO6 KQDiVD0YfUVjV7z4l0iHxfon2GQ41G2BaylPf1jPse3v68V4VPBLbTyQTIUljYqynqCKzasaJ3Po HwRepJ4L0oqRhYdh+oJB/lXRrOrDrzXjPw88SpbI2jXL7QzF7dieMnqv9fzr0UXhHerWxD3Oj88C j7QtYAvz60v27PenYRsXrebpt4kfLmBwoHrg18udq+kLfU/JnV8BgOqnoR3FcTrvwps9Tvnu/Dut WluszF2stRLRmMnsrgFWHXrtqZIqLPJc1LaWtxfXcNpaQvNcTOI44kXLOxOAAPWvQI/g7qiSqL3X dDt4yeWS4aY49gin9SK7Lw54f0XwdmXTHmu9TZSrahOoTYD1ESAnbnuSSfpkipSbKbR5p/wrHxv/ ANCxqP8A36o/4Vj43/6FjUf+/Vexfb5e8rfnS/2jIP8Alq351XKLmPHP+FY+N/8AoWNR/wC/VH/C sfG//Qsaj/36r2E6hIf+Wjf99VHJqRjRnkmKqoyWLYAFHKHMeH6x4T17w/EsmraVcWaNjBmXGc// AKj+VHhGx/tHxbpdsRlWuFZh/sr8x/QGtLxv4o/4SC+SC3Ymztydp/vt3b+g/H1q18MoAfEU14y5 W2t2wfRm4H6Zqbajvoe5+epJPqc0vnrWB9vOetH28+taGZv+etJ56msH7efWg359aAG+NdVGn+Ed TmVsO0RiT6t8v9a+dq9P+JuqE6VZ2QbmWUyMPZR/iw/KvMKiW5cdgrrfhrZC88b2bsoZLYPOwPsO P1Irkq9G+FkIhOpX7LztWFD9eT/IUluN7HsYmXFL561gfbznrR9vPrWhmb/nrSecprB+3n1pDfkj rQBk/E/VBbeDpoVbD3UqxD6Z3H9Fx+NeF13/AMT9SM93YWQbiNGlYe5OB/I/nXAVnLc0jsFFFFIY UUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFAOKKKANuznKiK5j+/EwcAd/UV7R4S1WOSwMIcE KPMjJ7qef5/zrwrT7gRkqx46jNd34c07UGs47m7kktLDJMCrxNcKewz91f8AaP4A9RUVfQTaW53W p6p9u8+0tSuwArPO/wByIEdPdvRRz9ByMe0e10u0a005WVJMefO/MtwfVj2Hoo4HueTFIzyKsaRr HCn3Ik+6v+J9SeT3pFhb0rWMEjFybLK3B9af9qx0NVfLb0o8tvSqshXLf2rHek+1n1qr5bDrTGVv SiyC5ba996hlv1ijaSRwqKMkk4ArOv72DTbdp7mQIo6DuT6AV57rOvXGrSFcmO3B+WMHr7mpk0io ps2fEHjOa73WunO0cPRpRwzfT0Fb/hbxG2pWAinfN1AMNnq47GvMatadfS6dex3MR5U8j+8O4rJS 11NHHTQ9mF3kdacLs+tZNlcJe2sVzAd0cgyPb2q35bHtW9kY3Lf2v3pPtR9aq7G9KNjelFkK5ZN0 QQwYgjpXMeONGXV7dtatU/0yIf6UgH31/v8A19f/ANQre8tvSiMyQSh1HsQehHcGk4poak0eeaBo YurOS7nHD/LEM88Hlvz4H4+1dZZXusafbJ9rie7tuiyr/rAPcd/5/WrMOmCy1iFAxGl3bZQk8xN3 T/Cu+l02F7dQqqMgAAdhWOsWbaSRxFtrdrd8QzqWHVG4YfUHmrX2s+tZPi3S7NZWBRcQgs7rwc+g NcI17fWSs0V7Og7KW3Ae3NVz9yXDseoi8IPWpVvfU15UninVkHM6v/vIP6VMvjDVFxnyD9UP+NPn iLkZ6h9sHrTTfehrzP8A4TPU/wC5bf8AfB/xqN/F2qv0aJf91P8AE0+eIckj077afWoptVit0LzT JGo6lmxXlU2vapP9+8kA/wBnC/yqhJK8rbpHZ29WOTUua6D5GejX/juytgVtg1xJ2xwv5/4Vx2r+ JdR1jKTy7IP+eScD8fWsfNFS5NlqKQV3/gMra6XdTEhXmlC8nqqj/EmuAqxDYXk8YkhtJ5EPRkjJ B/EUk7O4NXR7B9uXP31/Oj7cv98fnXkf9lah/wBA+6/78t/hR/ZWof8AQPuv+/Lf4VfP5E8nmeuf bl/vj86DfL/fX868ZZGRirqVYdQRgim8Uc/kHJ5nSeNb77ZruwHKwRhB9Tz/AFFc3RRUN3ZSVkFe meD2Sy8NxLuCvK7SsCfwH6AV5nRRF2YNXPaBfL/fX86Pty/3x+deMcUcVfP5E8nmez/bl/vj86Pt y/3x+deMcUlHP5ByeZr+J7033iG7kzlVby1/4CMfzzWRRXZ+EfhlrnjTTZb/AE640+GCOXyj9qmK FmxnjCnPWs2WcZRXceKvhXrvhDSDqeoXWmywBwmLadnbJOBwVFcPQAUUUUAFFFFABRRRQAUUUUAF FFFABRRRQAUUUUAFS21tPeXMVtbQyTTysEjjjUszsegAHU1NpunT6repawGNWbq8rhEQepJ7V7v4 S03wr4PsFNlqFrNq0i4n1CWRQy5HKRjJ2L79T7DimhNnPeG/htDoSpea7HHdap1SyOGitz6ydnb/ AGeg756DoprN5pWlmYu7HJY8mtN9V0j/AKCdp/39FQ/2lpTnA1G0JPQeaKtOyM2mzONkB0Wj7Hnt WoLrTv8An+tv+/go+1ad/wA/1t/38FPmFymZ9j9v0oNn7Vp/atO/5/bb/v4KPtWnf8/tt/38FHMP lMk2RPasDxFrdloEOHIlumHyQqefqfQVp6x4hMkzafogWabpJc4ykXsP7ze3Qd/SvO9b8E+IImkv tkmoox3PLGCzj6r1/LIA9KTmNQOe1LU7rVLoz3T7j/Co+6o9AKp0UVmaBRRRQB1ngjWls78afcti 3uGwjH+B/wDA/wCFepCyI7V4CDXtHgXxTb6vpAgv7hI722AVmkbHmL2b6+v/ANerjK2hEo9TY+x+ 1H2P2rT+1ad/z/W3/fwUfatO/wCf22/7+Cq5ieUzDZ+1ILPPBFan2rTv+f22/wC/goN1p3/P7bf9 /BRzC5SlDp8M0clrcAm2mwGx1Q9mHuKrS6rdaFJJpd6Q96o/cSD7sqHo4/DHFbKXmng/8f1t/wB/ BUPiKDSvEXh42Tajbw31vl7G6EgzGx6qf9k/59Qm0yo6Hl3iLUvtMxtY33KjZkJ/ib/63864u+n8 yXYv3V/U1c1CWaz32sq7blSUcA5249COv1rIqG7mgUUUUgCiiigAooooAKKKKACvsr4eaNcaP8Pt DtIyyH7Ksrr/ALT/ADH+dfImh6e2ra9p+nKCTdXEcXH+0wFfdsUawQJGgASNQoA7ACgCuvmJw9yA ffFB81v9XcA/TFfJXxM8V6ndfETWfsup3cVvFN5KJFOyqNoCngHHUGsDS/G/iXR7xLq01q93owO2 SZnVvYgnBFArH1xr3gzRvFdo1rremQzbgQtwqBZYz6qw5H8vXNfJPjjwnceC/Fd1o0z+aiEPBLjH mRn7p+vY+4NfZmgahJq3h7TtRlj8t7q2jmZP7pZQcfrXzt+0c8TeMtNC480WXz/Tecf1oGeNUV9E /DP4P+GNd8B6fqut2U0t5db5Nyzug2biF4Bx0FV/GXwU0yfX9I0bwraPaGZXmvbqWV5FhiBAHBPJ JJwO+PTNAHz9RX1DqXwn8E+DfBeo38unm+uba1d/Pu5GO5gvGFBCjn2r5ktLS4v7uK0tIJJ7iZgk cUalmYnsAKAIaK978H/s7NNDHd+K714iwB+xWhG4ezOcjPsPzr0q1+DngK1iEY8PxScYLSyyOT+J agD46or6p8Q/AHwnqls50pZtKusfI0bmSPPurE8fQivm/wAUeF9T8Ia5NpOqxBJ4/mV1OVkU9GU9 waAMavor4aeKfB2geAtPsb7WbWG8JeWZS3IZmzg/QYFfO8UbTSpEgy7sFUepNfV1l8CfA4sbf7Tp 07z+UvmMLqQZbAycZ9aAPOvjX4z0TW9E0zTtDv4rpPPaWbyznGFwM/8AfR/KvFK674maTpGheOb3 S9EhaK1tlRCrSF/nIyeT9QPwrC0PQtS8SatDpmlWr3N3KflRegHck9AB6mgDOor6V8Lfs8aPZwJN 4kupb+5Iy0EDGOJT6ZHzN9ePpXZn4QeAmg8r/hHbfb6iSQN+e7NAHxvRXuvxJ+BUGk6XPrPhZ5ni t1Lz2Up3sFHVkbqceh59+1eFUAFFaGiaJqXiLVYdM0q1e5u5T8qIOg7knoAPU19AeFv2ddMt4I5v E17Ld3BGWt7Ztka+xb7zfhigD5vor7JT4Q+Akh8seHLcj1aRyfz3Zri/GP7P2i3VhNc+GZJLC8RS y28sheGT2yeVPvkj2oA+aq9v+BPgzS9c0zV9S1bS7a/RZUghW4TcFIG5iPzFcV8NPBkXiP4ix6Jr NvJ5FusrXUQYqRtBGMjp8xFfVvhrwvpPhHSv7N0e3MNt5hkKs5clj1OTz2oA8m+MHhnw14c8Az3F poGnWt3NKkMUkUIDAk5JB+gNfONfcPirwdo3jOzgtNagkmhgk8xFSVk+bGM8Hngmvnf41eDvDPgx 9LtdDtJIbi43vKXmZ/lGAOp9T+lAHk1FFFABRRRQAUcUUUATW7xB8SrlD39K3tPitIJh51tHNC/X jJx6j/Cubq7Y35tvkkBeI9h1U+1AHr2jaLot3FGXgheJvuSqv6Gutt/h/pvystnCQeQQorx3R9bu dMlFxaSh4m+8p5Vh7jsfevWPCnjyGbbHC4Vz961lPX/dPf8AzxVWTA6q18GWJjCmERkdGQYIqSXw zdWQzEnnp6oOfyre03W7G/AVXEUp/wCWb8H8PWtlMDFKwHk2r+FdD1tz/amlwyzZ5kwUk4GBllwx HsTiuNvvgxpU5U6fqt1a8ksJkWYfQY24/Emvouaztrofv4I5Pdl5qhL4Y0+Q5TzYv918/wA80gPm e6+C2rrPiz1Swlhx9+YPG2foA386i/4Ut4ix/wAf+kn/ALayf/G6+lW8Jpn5btwPdAaaPChHW7J+ keP60AfPdv8ABK5MAa71yKObukNuZF/76LL/ACrWj+FOi2YJIuLpsDmaTAB9goH65r3JfDMK/flk b8hU6aLZQ8mNCfVvm/nQB4avw8tpziHTYyM9kAFaFt8KbL709rEx/uhOPzr2Vlt4xgID+FZ97eW9 sm6aRI17Anr9B3oA81b4e6ZCuBZQ8eiDisfUvC+kWWVNpC8x6IFHH19K7DW/E8cUDtG620A+9NIc E/Qf5NeUa74ve6LwacGVW+/M332/w/n9Kq1twMnXbbTbSRo47eF7k9cKMR+319q5e4WC1X/VqZT0 X09zVi6v0t8qhEkp6nstY7uzsWYksepNJgBJYkk5JpKKKQBRRRQAUUUUAFFFFABRRRQB3PwitVn+ Iun3DqGSzV7gg9MhSB+pFfUEeuTzK6Rr5khRiqDqxx0HvXzx8HrBy+qagBwqpArfU5P8hXp00zxL veRY1H8TNimkS3qeI3nw78dXt7cXUnhjUt80jSN+6PUnP9a6Dwt8GtWmv4bnxSg0vTY2DSRM4M8w H8KqCcZ6ZOMV6T/a0aDnUIgPeWsfVPGmjacpM+pwu4H3I23sfwFFg5j0hvEy20Z2skFtEvyrnARQ OB+VfLvj7xI3jHxrd6jHzEzCG3Hqo4B/E5P41a8V+P7vXY3srQNb2J4bJ+aQe/oPasfwhYHU/F2l 2oXcGnViPZfmP8qBo+qNFvjpOiadpsRVUtbaOIAeyjNN174i6f4asTd6hMqlvlVVXLyH0A71hO0o LH8TXzz4v12XXvENzcPIWhjYxwrngKD1/HrQ1YSdz0Lxz8bm8VeG7zRbbTXgjuNo853GcBgTwPUD HXvXT/Cfw3a+FNFi1q6hR9av03IzjJtoT0A9GYcn2wPWvCNDs11DXrCzYZWa4RGHqCRmvpbZI8o2 8L0A9AOgoSuDdhvjf4ur4RtVgijFzqUy5SInhB/eb2/nXkw+OvjYXnn/AGq2Kbs+T5Py49Ouf1rj /F97NfeLdUlmJLLcNGAewU7QP0rEpFI+s/CXxFPizQY9RVRDMGMc0Wc7XHp7HOa4z46JFq/hax1N kX7XZziMuByUfOR+YX9ayfhXYXVl4Tku3VlS8uC0QPdVAGfzz+VRfFjUTF4at7Jz+8uJw2P9lRk/ qRTtoTfU888CWI1Dxzo0DKCguVkcHphfmOfyr60TxG5YszDbya+afhLYvP4kubwLkW1ucH0Zjgf1 r1HxLey6Z4Z1G6zgxwNtPuRgfrQkDep4H4j1Fta8Ualf5LG5undcdwW4/TFfRPw60W28D+HIokjQ 6teKst5P1YZGVjB9B39814D4IsV1HxlpkDjKiXzCP90Fv6V9CgziYylhkHcST+NCVwbsc18R/jHq Gj3LaLojqt0o/f3DDPlk9FA9a47wf8Y/FNjr9smp6i19ZTyLHKkirlQTjcpAHSvSJrzwrcTyT3Wl eGLieRi8ksltGzOxOSSe5qI3HhJSGi0fwtG6nKutpFkH15osFz0RNdYsUcq6OCpB75r4/wDEdgll 4r1Oxtlykd5JHEqjtuOB/Kvfzr1m0pdtStiSck+aOtePeG1XX/iktw4DxvdyXOD3AJYf0oaBM9u+ H2iWngTQIreONDq9yqyX1x1IJ5EY9Avf1Oao+PfjTJ4bY6ZpcaXGolcuzn5Yc9M+p9qvsJh5kjEk gFjXzJfXct/f3F3OxaWaRnYn1JoasCdz0jTvjx4xtL9JrqW3u4M/PC0e3I9iOn61t+OfjpcarpaW Hh/fbmaMGec8MmRyq+/v+XrXilFIo6Xwf4w1bwlq8l3pKwvd3KiItMpbOTn17nFfWEXiGcRIJXQy bRu2jjOOcV8keCrA6l4x0u3xkeeJG+i/Mf5V9Es025nJ45Y00iWzjfHXxq8RaP4su9O0prX7NbhV y8ZJLbQTzn3rynxb4w1TxnqMV9qrRGWKLylEa4GMk+vXms/Wr06jrd9eE586d3B9ieP0qhSKCiii gAooooAKKKKACiiigCW3uZbZ90TYz1HY1sWuoxTMMN5MvoT8pPsawqKAPTdL8b6jp22K7H2qEf8A PQ/N+Df45r0TQviZbuFVb8wn/nldcr+Df/XFfO0F9Pb8I+U/utyKuxapE3+siaNv70Z4/KnzMD63 svGkUsatLDlT/HCwYGtWHxLp0mP9I2n0dSK+RbPWJbdt9nqJjbPZyh/pW/b+NfENuAPtJkX/AGlV v1IzTugPqddasnHF5b/jIBQ+r2ijm8tx9ZRXzMnxH1hMbra3f/eiP9GpzfErVWGBZWo9xG3/AMVS 0A+jJtesE63if8By38qzLjxRarnykllP02j9f8K+fZvH+vS/6vy4v92If1zWPe+JtXuRi61N1U/w +ZgH8BgU9APc9Y8cx2oYTXdvaD+6Duf8uv6V51rHxFRnYWMTzyn/AJaznP6f4mvNZdRtx96SSU+i jAqpJqkrDESrEPbk/nRzdgN7VNYub2TztRumP91c9PoB0rBuNSdwUhHlx/qapMzOxZiST1JNJUgF FFFABRRRQAUUUUAFFFFABRRRQAUUUUAe0/DqQaZ4Ni7PczPK38h+grL+KWsGXSbKyDf6yYyMPZRj +tYtj4ysLPT7e1AmxDGE4X0rn/EutJrN7FJFu8uOPaAwxznn+lW7WIV7mKTSUUVBYV3PwtjCeJJr 1hxb27Y9mbgfpmuGrpfDGv2uiW9wJRIZJmH3R2HT+Zpx3E9j17Xde+yaDf3APzJA236kYH618+Gu w1/xZBqWkyWkHmhnYZ3DHAOa4+nIUdi7o99/Zus2V7jIgmSQ/QGvoWDXQ3l3ETgqcOpHQ18210mh eLLjSoltpgZrYfdwfmT6e1EX3CSPQfFnw4t/E+pS6voGpWdtcXB33FjeuYwH7lH5BB9Dg/Ws3Sfh LDaXAm8SazbGFDn7Jpz+bJJ7F8bVHvyfaoYfGumOuTcMh9GQ1Xu/HlnEpEAkmbtxgfrVcsd7k3l2 PSrvXLSytd22K0sraMLHGvCRoOgH+ck+9eH+LfEcviXWnujkW8Y2QIey+v1NVtX8QX2stieTbCDk RKePx9azobea4kWOCGSV3O1VRSxJ9BipbvsUlbc9W+FO2x0O8ujw1xOFH+6o/wASatfE3Ws+Ffsq tzczKpHsPm/oKq6Ra3Gj6Na2MiFJkXdIh6qxOSD7iuS8d3rTXdrbFuI0Lke5/wD1VTjaJKd5Gd4O 1JdJ8V2F25CoHKMT2DAr/WveYdXh83bcDfC4KuB1weOK+aa67R/GsttClvfBpFUYWVeuPf1qYtdS pI1tX+Emrx3jvolxYajYyMWiYXSROq54Dq5BB+mRVvQ/hTHBcxz+KtThgtgQTa2EizTOPTcPkX8y fao18Y6YVz9qYexQ/wCFUr3x3BGpFojyv2LfKKrlj3FzPsYXi7w0fDesSQwzC4sXYm3nH8S+hHYi m+DNUXR/FdldOcR7jGx9AwI/rWZqOp3eqXHnXcpdv4R2UewqnUddCuh9L22trDOrsA6fxKT1HcV5 7rfwkN7qE134b1fT2s5WLi3vJfIkhz/Dz8rAeoP4VzGj+NZbWFLe+DSKowsi9ce/rXQJ400wpn7U w9ih/wAKuyaI1TNLw98LdG025S48T6kl/tP/AB5aeTtP+/KQOOvC/nXn/jDw2fDetyQRSedZSEtb Tf3l9D7jiugvvH8UaFbON5X7M3A/xritR1K71S5M93MZH7Dso9AKl2WxSu9zrfhbsi8ST3TdYbZg v1Ygf4166L6K9imtZbr7MJomjE23cEJGASB2zXz9oOsPouoeeFLIy7HUdcV2i+NdNZcmeRT/AHSh pxtYUr3KOq/DWTRdJur+617T5lhUlY7USMzHtncqgDOPU89K4Wuv8ReLo9S057G2WTa5BZ244BzX IVLt0KV+oUUUUhhRRRQAUUUUAFFFFABRRRQAUUUUAFKrshyrFT6g4pKKAJRdXA6Ty/8AfZpftdz/ AM/Ev/fZqGigCRp5XGGldh6FiajoooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoo ooAKKKKACiiigAooooAKKKKADNGaKKACvcPhzBPYeC4/IvmgN2WkmVJduRnAzz6fzrw+po7u5iTZ HcSovorkCmnYTVz2bXdX0fRInee6jknA+WGNgzMf6fU147qN9LqV/NdzYDSNnA6KOwquzM7FmJZj 1JOabQ5NgopBRRRSGFGaKKACiiigAozRRQAZooooAKM0UUAFFFFABRRRQB//2Q0KZW5kc3RyZWFt DQplbmRvYmoNCjEwIDAgb2JqDQo8PC9UeXBlL1hPYmplY3QvU3VidHlwZS9JbWFnZS9XaWR0aCA1 MDAvSGVpZ2h0IDIwNS9Db2xvclNwYWNlL0RldmljZUdyYXkvTWF0dGVbIDAgMCAwXSAvQml0c1Bl ckNvbXBvbmVudCA4L0ludGVycG9sYXRlIGZhbHNlL0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGgg MjM3MTc+Pg0Kc3RyZWFtDQp4nOyddXxT1/vHqaZt0rg10qSWuqQuqXvT1DV1o9SoUwFKcYq7y9Bh Q4YMt8FgyGBjY2PA+I7BGKxoV7TyuzeVtSVpT2rp9/fN+5/x2qv33pP7uec8zznneZ4zapQcOXLk DBRFJBJJagOPRKrLujlyhhAlFIlCpdE/hUalkAly7f+foYihaIlTu5vyWhQSUtYNlTMoqBK6dm6G NltXn2Nsag5jasTR12VrM7p2ebKmgqxbLGcgKKA79WZo6xlZ2vO8/AKC+MGCDoL5QQG+Xjx7SyO9 TulpVHl//29FCdsuOENb38zB3S9I0BtBfu72Zh3CQ7Jryrr5cqQGEhyCTtfWt3Tx6SZ3ZHFx6dI2 ZhcX53YT3sfZQl8bFp0GyY6S9W+QIwVIyGWDFWcZ2Xt16h1bvvSLU3det37Cw5+ObJyb36m7l70x CxYdsu1YZVn/EjlgYNoUZxk7+PDbdIye9PmVp5+K3Z17p1YXtlt5X0dIdi0tmpbctP83oIijakFq MQ1svdsEj5y89z99yd3J22ub23Tn+9gZMKAbackt+0hHkSBSnGXu3jakp6679hFY8Haen5oRCV8b wDNj00Sqo2X9s+RIBk+FoOlyvUWzseTVP0mrd0d3Pzc1HB7jva11ofGdSpH39ZEKmgIpTte384UV D51xpZ+Ct/H6S5FX52unT4fuSiGoyfrXyfkUNTIkOU3fzh+WKn3XywEpLuLnxXBn97fTo8FdHSfr HyinJ0RIcS1dWz9Y8eIzzQNXHOblRiF0Oz9bXS0KlUKUD/AjCk0ylULVtvCGFa+4OTiCi3h7MBG6 pbeFNjTAkwkIWf9OOR0gSPCwbuQKT85Kvx9ExWHe74X6Ot+FQ4cHeKysf6qcNvBkaFjXsQ2AFB89 MMdNPG83Q3bd31ZHi0KRd/WRAZ5EpjDNvSBnPXLr+yGQHOLPifDEzZwJiy6frMscBIlMphq4wMP6 pD+HRnGYC6nQAO+oSyWTCFhZ/+T/dfAkCoVm7AVPzy4MneIQbzeEQr6cKY1EJuHl47ssgcd1bS5k yUM3vB1SySEeVAgEAVz5+C5jCCQS1YAHjeup/V1llYrPQwV8J9H4LhddRihCkmsZw3PyyYOw6gbC 98kCgRc0vpMIGFn/+P9NEEQSiW7hD43ru4dHcYiXNdD4bkUnEeWiywIcJDnDOnC4xvUOtocKgmwY kOhYWb+A/z0gycksuyCBYErDcEre2nozVcC3Y5KIRKysX8H/GjgikawHe2+rhldxiPoCAd9Bm0Qi 4uTRcsMJLLm+O+S97Rx2yVtbGyoFwU5sMokoD5EcRrAEItnAE/LejkmnVgtEcxPExw8iPkL/bG5u hv+3NLd5P0UQzNMlQ46ckqzfxP8MWAKBzPESCKK+lUZvWOr3bxtfv6h/+uTxwz8gHj5+8nf9i9eN b9+LxAfXvXkRLDqJgJfP04cJDJ5Agnt5HLDD3gLL/eb1s8cP7v1y8/qVy5cuXfwG5tKlb69c/+Hn e3/89ez1G1h4YN03CIKd2QS8XPThAQ1Jru8hEKQAhjC3NH149+Z1/cO7P3737Tfnzpw4evjgl/v3 7tnzxZ49+/YfOPTVsZNnz1+6evPuo3pI9w8fmsBk3wc7cgR5Tx8WEDg8URdy35KAJIcFb3zx+Lef rl08d+KrA3t2bF63asnC+XPqZs6YMaNu9tyFi5ev3bht976Dx05fuHrz3uMXje/ev28CufNuAd+e KRd9WMDi8GxesCDuLoji79++efXkt5vffn3i8N7PN6xYMHNSRWFWsjAuUhDM5/ODo2KFyZn55ROn zVmyZvPuL4+e/ubG3ccvG9++BVF9RQjflk4g4ORhckMNFo/XsuELon4BUryh/sGtq+eO7d++Ydmc SSVZccHWBjpMGhWaZ+EhIO+fokXX1jX0jU4bO37GojVbvjh08uLN35/98/Zd36o3zw0JsqYT8Fh5 etPQgsHjKWa+grC+PfaWd28anv72/fnjX25ft3BqeWakux6TQsBoaqipqqooKykpKiopKauoqiLU kWgcicbihKUV1sxevnHXoTPX79f/8/bNh76e8HGCINCKiseh5XVJhhI0Dk829hGEfNWn5O/+efXk 3ndnD+/asGRaWZrAikHGotRUlRTFVJFQUFRUVtVA47XYfgn5E2av2Lz3xLV7T181NPbV1xuLBf6m JBxWProPIQgsngjN0kJW9KV4U8PLJ3evnT6wbeXsqqwwHg2vqaYiTu5/UVBUgnQnMfkpxZMXbfji +OW7T183vOnDh3+VLfDQJeCw8kz1oQODxbNdg0Mm9ZGy0NLY8Pz362e+3LpiRlmynzYJEhzq4DC9 315BUUUdTXaNK5i0YO3OY9f+U/+6oY+gyofxwY4sIuTHKX6CQifD827+n4LGYqnW/JDMV70L8fHV iz9vnT+4dfn04kQfBhGjgVBVUVFWFtnwviRQUFTVwNtH51bPXrPr5M1Hz1+87r2rfxshsNemkIkY 1Z6oqMAPhZ/Z50PlSASFxZGMvEIi+5ilNb54eu/q0Z2rZ5Yn+bEpeIwmCoVCIjXU1RCw76bYd2dX VseahY+pnrtu7/nbj5+/6j2ZeVtMqB2bQaegPqHbM+Wi9wtFNBav5x7Sx75Kc8PzRz+d+3LToprs UEMWnUKG6z0SoeEXi9ZEqiNECvT5JGU1jGN0Xs3CTV/dePj8Ra/Rlc2zkkJsOPp6LFIPiAQ8Dvre oGmCSt8fmhzxaGKwdHt+aF2vkn98DVnyE7vW1o1L8Tfl6OnqiGCzmHQtChGHhlUHEH2UopIa1iuh aMqKLy7ee/rsZW/j+4vCNIGjpaWZkU5X2Cxt6JFkAvRINVWQ70yOGFAYLNHYNySt17CYdy/r/3P9 xBfr5lZm+nm48lzacXZ0sLM252iTcZoaYKJDfR3JDMoYv3DryVuP/37em9P4Y0VxIt/f38elC85O 8BMtTQ31GEQ0JLq8o/cLNAanwxOE/NCr5A3PH/x06cTezxaUFebn5XaQMyY7KyMlJsBWn0bEICEn HkAB2KzjvJMr6tZ/dfPP5696E/3sivkTS0tLCv99nuiBaUnCmDBfO10CEgH0RDk9QWEwWjb8kF5D oZo/fnjb8PLZk0e/3/n1119vd+GXX36+dXO/0IVDJ2GRCOW+O7oCpDkCRbJLKKnbePru64+97ba1 /PXo93t379650/15P/148/trF46GU9umisPxkv5/oYbG4DleIRmNvWneFzsSnY2YZBDRFRSVlBEa aJK2SfKENcef9P+Rb2dwaWh1VYCvTE5PUGgM0zE4dGCpxm8XxjoZMkkYDfFrsJ1AnVxJBYHEkOgG 3IDaXX/3/4lPpwaY0DBAI4ucHiDRaIKJf8icAUne2vq4JtyewyBq9m7S4XFdVQ2FJTM5dsG5n4mp HAnKrxMj7HQpYNZETg+gbs5yEkQ9HqDmrdfLgq31aXhUbyKIJFfXxFNZJs4RpYf73F6TSPOFqlie iTaQMZHTEw1NTZJFQMjWgUre2rIv189Sl4pFSrawonFdA02g6Vp4CGsGUKnkzYHqRG8bjsiWyDWX GpQmmuUsyByEdOPG5WkeZiwyRl2CSReZcjXIlDMMuH6Z8x/1/0n1W2tSg5wt9GgETXW53y41cDc3 8w87NXDJW1sfTYmFnHdJJr3dlOMo2kb2goItA0iL+m1DbVa4p60xm4JDga0IyOkKEurmToK8wSn6 dmVciK0kk66goNRmytlmvOiKU1KXiu2k6fr6yWNi/J0t9BlEtHxolx51lKibnx0UyVubd+f5wyZd jBLtppwImXKvpCm3+v+MxrPrJufF892sjVht3VyuuZQgUZpMR8HYQart2NqwKMXdlEVGq/cYcdtN ORYy5TYBo5f+1f8n1B9ZVZuXIPCwNdHRgqy5fLldatRRKLyRd/jXgyR5a+t/aqMdDRkEkUn/9zFt UzTYlBs7hhbu7P+CX8v9fcsm5gqDYclpBLQGQr6tJjXqSBTdLji7/8b1Ey6UCaBZOq7btBlebVWF pmhabDPX2KrzQGkNYvlwY8eCytGxQa7WRmwqHu7lcsmlRUUDiTHwDD8o6R3341v4+PkYH0sdCrbL GmybKccQ6fpW3ikzfu234q0NX2+cVZIe6edsyWGSIVsuH9j7gToSSTIPSHoj4R03Pe/HrP3lvCRX E21Sp0lvM+Wi1VbbwDGr6vsv+V9H1k0tSAr1djDTo5NE+7ZyyaVHAwl5cKEbJL3kJ3/88Y/00tyZ GOnAYRBQcAS0QsdqK47CMnYML9nf/6Wf5rv7l08qiOe7i7w3uSnvJ2pIJOTBRUtKSHxz+9aVG5LG gF44WRzE1dNqM+ntG6cELR1zt7jxl/s/P2i6dWDJ+FxhAI9rCM3R5A57f1HTQNLsQiZKes23vzuz 7+BV6fdB3m8c7WXOpsBL4UpKoo1T2JT7pNWBn9Ek5qYn1tVkx/N5FvoMMhbZGVTfRs/A9+F+kf9F 8fbqGpps18hzEt7yy8untixbufOGVKVBRNTPEvJEJl1VRaVj45Sfu+7FACRvbT27sDgmgGep2xaC pQzHtkNflLKysgr0kC6B78r/Br4PtQLtn5tSWzuURU8ermf3E4SGBt7QM1nC6N1y5eS2ukm18zeB JCb34Nb4cHsOHTK6amoa7RunZV8NsBb4nRk5fGcuBzLlSDiyHRYaoaamrqGBRKJQmm10RL5Df6AK Jz2AvP0eI4WEfJme9xFdAidiqqgiEGrq6lA7IKD/qiFEWR4gOR6yAKGuQeXyF0h4x/Und9eV5OaW zdwhffhSy1eFAVw9GgGjicYSaTrmHsKafgwX3Xk3M83bEpqWYzQhVWGpUZpoDBaHJxCJJBK5nbbQ dywGrYmCtRdlyfb28mHp4E7aZaj4JGGm+9jRdhWktzKkNvTJIeFWYHE4OP8aj8Nh2549YhMu1NRR LGeJtYK+3rO0IDkuTlg070vpo1ners7wstCjU4gkKtOA65cx/+HABIfZmuZposOgQC9VpDWRRKFq 0RlMbRabraPbho4o9p1B14JrBeOxcNqDOqJD909fQLt2Ium6jhU9c2bah46O76f9IkhuDNQMMkWL RmcwmDAMBp2mRSETCTjoy1SHMy5G2HRSVU0dq++R+k78G35+4LNxcXx/f35S2dJT0vtxf01PcLMw YGuz9EwcBAWbB6Oe5M1Mb2MWkwZ1azIkNpOlo6dvaGJhbefo5MJzc/eE8HB3dXayszY3MdTXZbPg +gdEPBaN0lBDiJddtD4I58hjcQRi51hBJvdImhFlzXTcBrbdKtA1kN5EclszOMZmVlxrGEtzMxMO 9GxtOOUCi+7I7Rk5qiPU1UlmAQslvOFzW+oS/Fzsue6h6dVrrkg/x7pRHe3KNTMx5brHVBwflLXd t7n+Fno6Omz4NRuZch14Hr5BYTHC1MzsnLyxxSWlpaXFhfk5WWnC6NAgXw+o6SYcXUh4ChGP0RT7 9kWSQ4rjSVRIuy6DRbekGTaLxWTQqCQCFr6LKuxFaGhioGsYLF1DM2snd5/A0Mi4hKTk5CRhbHQE 9GxPnr2lka42DZIdpQGW0TVcQG2n2UZI2EV9t21xfoCDhbGhjVdEVu2mO1Ir1HygNNLT2dE1KG3K YNUJXhLpZGpiamZu6+IVFCHMyCuumrR8y6lzP9y+fftevYin0D/PH9u8oKaiOCdNGObn7mBlrM9i aJHwohoYPVRv2/jBUtkm1g7Orm7uHh7ubjwR3dNm7G2sLEyN9BhkHBoe6GHBtRhsQwsH98CIhKyx FTXLNx04febs2TOnt23ZuLq2ujQvPZbvbmOiy6QSsai2jK4RojpCDZqpCZ+Lf793VtVGOBjpkLSN 7X2j82bskH73s3FtUQxfEFe4fAAbp905l+7Pc/cPiUoZUzphxcFrd+olW4wXT25/d2Bh9diM2GBP RwtDNoNK6sxu63z9ikrwAiGV4xyWMiZ/bFFxcfHY/DyI3K7kjBmdniSMiw7zdTSkEyEvDU+k0Nkc Sye/6PSiCauO/vDnJ/OR+t9vHJhdmBzsyuUwqQQMcuTsC6iqqWE5PhMkvLRdC/I9TJhkLIVt6hQg LJy3X3o/7tGikqy8SXsHlCnRjfrqMWljyiZvPPvLUzBj0fj7tT2zSjKi/JysDFk0Mr676lA3hyO1 dJyLHz99+vff0DDxd48MnXYunj198viRLxa6GjJokL+mrWfq4BuVVbnx+8e9+Dl/npqRF+3FNYBG B9SIWTSENCeYBkooyf9q/fQ4WzYZgcRp6VrwID9uyUnpp9c3V8xZdqX/G6efsn35jqt/Sjvne3J1 XWV2tI+9iQ69M42ybcalpKqBITPNwwCPJfgl0s5QX1/f2NI1JH3c+ht9doKme9sKo3im7Zu+I0J0 yG2nWoffEN/eywvH+ZoycCpqKDxN38otJK16tfRr5c3fHv1D2mt65aWEOUZfNNzcVp4c6GisQyNh UZ2b7grKapoEur5zFuB5oN9netlyrR28IsbM/OYF2CUPVmX5cXXh4I6REbaHUENqOwvFf60tKyen OOhR0UoqappEhqGNZ0TWpI23wX5nF94MIE1lkHl2YkKyv62hNhWP7siYVlRRx1J0zAPGAeZPfVsY 6uUdFJu/4AfwqWvTmcJgG31IdEnx38OKCgKB1vOsEt/U17NLgkzpOLjekzoa9uN8ID9u+4AzXcAZ TIvQzsvD5bEeFu3L9fD4rqiKJDA4djFzAAew05VJscmFs7+TbrHiZnmoLSR6Hyldw6Y51tBvk/iG 3pg02kmHhBLNZjRgP84xIL5w7r4+6gsNHv/8PtCVWnE8XpUTbMdhwsXsVOCyhQhNMtvMPXMv4OVf TSupmHVY6qHrxzKBja4WrteUruHSXFUVbxosYXa+oSzWkoZVF/m2kB9H1bVwgfy4xceH6MjUHrT8 de1aP2I1+qbpUkWMi4l2W4i0EjS0a+lzA0u/A7z64PKFW+7346k3xvpbsEXBYrLXHEG2jhC/Z/ax bkwAhwwX41NQUPrXj6ta/e1gxUT3xoefTh44dn9o7v1oVpKHWVtcvLIqEs8wcoiaDLgV8PHUvtP9 +hJbdqS7ibJ7ZN7RVVTVaY5C8ZPnv8cn2GvjROV1RaJDfhzHxjMc8uN+7s+Plo7X53dtWLftzBDd /cXKdC9zSHRopq6mSWKZuabMB1xAeHP9dj+XkF9Mi7CF44Zk3dGVVVQ0mK6F4ht5JT/EmNxeXbfT j7Pzic6Z8fmQ+3GPD22cP3Pe8i+HakR5uznDy4xFxiLVkRiqnpVPzhbACxse9tvHuJznbcoiwR1d 1poj2Z7zxLdxY7IXG6OuOqpddMiPw8B+nH984Zx9Q3uSZtPPXyybXllaU7e9H3F4YLxbn+pmzCRh UGg8nWMnKD8PeN2H/ruVjdOjbPW1sBp9lMUdBs1R+n7bxLdxWriTFlK14087/Dhzl6DE0sXH+rku AsSbS9vmjy8ZM7pk4mfggRpNjS9fvHjZCNyuhrlxjhw6EYsja5s4RdXe61dLpePIaA8TbSIKIdvB HdJc05h/XGwL31f7WZE0/tVcQbHTj0utWnVp6Py4+uPrZ5WPyUhKzK3c+BvYJU31P144dezIkWMn v772B2Ag9YNKgZWuFomkpWPOS5rzrP/tBea3iiArXQpaTVnWmmPMw8RPU54V8vTQqiqdf9vmxxFE flzmpA0DyCntleb7+5bXFmUIYyNjRk/cBeQ4fPjjm692blyzfOnS5as/23H4wgOw7/FwlrsJi6bF NOB6jV45HFORf2bG2HNoOHXZaq6krIKzivxdbAvvZtnQNbpo3unHGdn5ROVM+3wABSJ64f31HQvG 5ybHhPJDogsWAK2Bv/72wKals2qrx5WXj6uurVu29ejPQK71q8nhNhy2tq6xXWDRoYG1GpA1qTwT JgGpIlMnDtKcYB0rPpHom3hLilpXzdv9OHK7H7d3KPy4V2c/m1U2WhjO9/cPS649DdL7/jq1bcnU ysIxGanJyamZuSUT69YeBgvSPZLlbsbR51g4hY8fQFEbKTiU62XBJqFUZa052T5JvAHcFWGIVVbu dl5pdz/u6CAUn+nBnwdWTR6bGh3s5+3tH1e+B6S71h/bUFeVny6MDOEHBvJDY1JyyqevOwG0Nvp7 RbCNmbGptZtwxiAEZwJwrjiAq0dBI2R5HqiCkpIKxSldfAOX8tkoRcVuzVMQBRiI/DhBatXKi4O8 B9J0a/fi6pyEsABPNzev0NzVIMskjafXT4cGBugaV2dHR2c335D40eV1O4Hc8Pd1cS7WFlYO3ukL pQ3paH7z/PGfj588l2595sq4YFsDLYyaLDVXhDSn8grFN3CCD0O9Z2B2px9nDflxNRsGK8StjTcX t8wpz4wN9nZ1cuL5p84EiaZqubatriwrNtjL2c7KwszMwtrJSyDMmbjmItATN2V6O9ja8YLyQVdk 2mn8/dKpI4cOHj529uojab7776tC7Q1pWDVZTtYUFRWVaa4SdlKL3amIT67o4ccN5pBYf2zdtKLU CH83RztbB4/oSqBNj/oDS8bnCAVeTtbmxoYcjqGptbNvZHrZ4qNAfvjhgiBXJxfPiHFSVdhouHly 75Y1yxYtXrJq4xenbksh+g/jwxyM6Fh1WWoOH4Gl5T5FbPtaClzIYiYV7X4cC/bjxs7d80Kal9Ub zff3LpuYlxDi7WxjZWntFJizFeRdtlzeMrMkPSrA1c7CxNBAX9/A2NLRKzS5cN5BoEH3XGm4l5uH X8JkKQJ6mx+e2rV63pQJFeXlVTXTF206Jn7WI5bvxoc5GtFxMtUc7ucMr+nif1uOI1FsfbdOP46f VL7k+CD5ce+vb59fmRUb5G5vaWpibuMhnA4UttJwbFVtITQ2uNpZmZkYGRoam1k7+4SlFM0/BNTP L1XF+Hv78DPmgZdAaPrp4Po5NSW5manJKRk5xRNmbzoD/gouVoU5GjNkO0GH+rmKttcCse1rzrLF Sarph4D9OK5HWMbEdZcHxY97deazmSVpkX4uXBOOgaG5fXAx2Pr3w8Mrp5VnJ4YHeru5QC6coxPP MyA8Kad6BdiG3OUJwuCAwPD8VcA/ouWnvcumlGYnxYQFB/HDYlLyqhbs+RP04tZj40Jk3s8VFBWU Gd7ic1iaMmxw4s9EbNtXZRrb+8UVzNwxgMIwnUBTtNqCxFAvBwuOLlvX0NI9eQGYI/3rqe2r5k2p KsnLzkxPT4PIyM4vmzBz6W6wVcIrtcmhwSGx48BXZO7tXTwxPyUqCPIzoUmCX2hibs36H4Gv3lXE dzCky9aHg9xyZaaXeM2b02ywiuILtsLnIWKpupZuYelVy756CvyTJSCaomXHweVC9LQZTB0ju+Ay sKiVlscP7tz6/rvLly6c//qciK/Pf/Pt1Ru37oItn1+dkhYZFpE6GTRGpvXloWUdLqOJsamVg1dI UtEi4EqKH1bnBdhzYL992JXuKp+CEsNb/FZqcyoXI15z+DBEONLA1DkoqWTunhsDTFeApmizyzOi A1y4hiwahUrXNeUlLxue8KtrUzNjomLGzAGNxW65uK4mJy7IzcZUn81kaOuZ2ntHZs3s+2TZdp4t yfK1NaBiZLomA2vO9BV/tFZLqjVWSVHsKqFIc2hwdwxILFt84P7Atifqj6+dVpQS7uNooc+kEAlk ur5VQImEePvB5vK0rPjYhKLloMFO9btnFgiDeFYcbSoRjyfSdM2hz37yXtDH3atL8Ratw8l07VXU z2eKbWBLOuTDKYlrnWiODk/XnAVZU7cNLF+h5f7+5TV5CQJPO1NdGhGLwZGYhg4x0wcv06lXLkwb nShMq/ocNA7iu5XlycGulvp0IgaloaGJp3NsfeIm7gN93LlJcR6WOjJeb4eGbiUtz0niW5hpj1cW o3lboTdN2HH3SZy4fQCF3iA+/LB70fjsjoqOaBQKS2aZuWfuHNBNwTk9NTs5KXuKpFI6PXm/b+bo CE9rAxoeBdfIUUOTdS09YiYcAbz845aycJ4ZiyjbfTVFyIfTci8R38RSJ4Lyp6J3HKuhpWPhET/+ wMBilxouwUU8YwJc2io6qqsjsVQ9K/+SywO6KzhfTRmTmlowF3RF5u/PKoX+DsZMAgquSqeoiiKy LdxiJoGGVT1ZkRfsZMzAa8h2/1xBUZXiJqFq+zweWVm5Z7xel0JvHgk1FwY2OX92YeeC6tGiGuyi io6qCCSOxrGLmPRgQLcFZ0dtdnpG2TLQsernxbnh7pY6ZLSaqOSdCooEaR4/DXSu9tOcNH872G2X seZKCDIvR7z13OVOVVHpoXn7CVlthd5mSV+CoBv//HhoRW2eMMgFPl0Dzh9TVkUSmCZOCbMHowYJ AB83TczOGD1+A2ga0slpKYEORlBHFSUgQf2cpGPpkTwHdNPhWG28t7VoK1WmmisqI/COWeKXOa96 M3po3qVmq11gzuqBmXKIBwcWVaSHeVgb0InwoXhKStBbZJu7Z6wYipQlMTSsrRydmTv1MOCfv99S FeMF+91QR4WTG1U1KXpc76wlgLlcHzaPi3BrC5mQcTwcAmubLn6X4GGgjpqKSpepZJcTsgZWs7WD posrxiUFOZuxyaJzk+DUMYou1zd/74DvDMZfS0uzMgvngE4Mn6wsCOGZaRORItGgIRJDNbAJKNgI OFd9ujI/2NmECY0Sso1vV1FFkKySxAcGNYYZIlW7aN5hymk65m7xE64ORl9s3FWbEgA7RZqiSsBK avBb5JcN3tkBvfPz7LGZWaVLQMfmX+ZmBDgY0tu3SBSU1bE0Q/uQStDWwpfDu+cyDoEUaW4uFL94 2BxtjlZV7YiN6jwhi67P9U2fK8UGYm88WpIb3O4IizSH32JYNWD2/4A5VpOdnlW1FtR7OFkr9LbW p7bbYwVlDTzTxDl2KuirODU5YSSY81EIBIJsGC1hUSHLBq+qqqLQIXn7CVmG9sF5nw1aOvLVyfFu Zqz2Mu/K6jiGsWM0YH5By4f379+9e9sP3rxp/Kfh9atnC4rSUkbX7AAcsT5u6WaP4akay9w9dRGg jfu4dWSY81FqaupUvdCV4lu5zkULgWjr6P+ekGXqElV+bPAO8WjaU8S3NWg7xEOxvedMAxts3/72 w+XzZ08dP3pEDEd74cjhA/t2bVm3eFpRWkJi9jTQsbm+mz1WaHM+/PJA14/qR4g5H6WqpkHRDawV /6X/4suCix6O6nZClkfSZPC9QwAalqZ7mrNFpy4qqSAJ2mY84SywDemGq0d3b92wevmSRQvbWQSx ePGSJUuWQiyTxNKlixbMnjZxXEFWYnS0MHcO6Gbw7XkZ/v/aY9j50DKwFYy7BHj5nXmZI8Kcw7Xb iQbe5eKH6jchRmh1NZVuJ2T5j148yDmpf3SeughNz4ksM9eEOrDd2WcnNi+pm1xdXlw4VkRhYWFR cXFJaVn5uIqKysoqCVRWVpQXF2SnxkeGBgeHxRYsAd0LPj1Z2MUeQ+ZcZIim3Ae8/NyUhC7egCxR R+I4rgXis8Ja4rhEdTWojYN0QpYE4FMX4SVshAoCtpCQ5mD9/Mn+ZVMqxo5OTYyPExEfL0xISk5N z8zKHpOTm5sngdycMVnpSbHhfH9fH7/gmOK1gCsyH7dWdDPnKqIPNHkeoGvTtK0iyn0kmHP4zEyc iU2mhPFpBY+uoa6O6FhtHeAJWZJo3pPvbwUfpKymrkmCNBfOANuqe7R9Vll2UpQgwNcHxtfPP5Av CI2IjhUmJqekpqWLJy01JUkYEx7s5+HKc/UMjK34ErCZz1blCyB7TGg354qqmmRdK68x6wE9wOer xwpcTDsulykoNNbILmGX+Hbe99XTRCI1OlZbvVNnDHC1VTyNy9JFBykjNdCw5nHTwJJRH26aNEYY 6uvqaGsDYWtn7+ji5ukTGBIVnwQpnpGZJY7MjPTUZGFMaKCns729k5u/sAZ0P+fO/K72uH0tIajk JODl9+ZnQZfTR4A5H6WmidOzj5gt/mP9GGFFQqE1Ue3HauSsGaKE3UdT4l0gk47RxJBZZrzoSWDz 8z83VKaE+TjBUZMQhkamFlw7J3f/6IyxZRVV1RMmimVCdVVFWVFeZpy/k421Hc8/eSbo6TDd7TE8 r6QbOUTU/AJ4+YWpiT42I8KcQx0dy3AMnCChxO9ENxYGiyfAq61OEaUHhqzOwPXKMDsDOgGLgwMx wqvAAsyefVYhDHLlGuky6XQ6Q1tH38iM6+gVVbDn7IWLly5dlsClS9+cP3fm6O6JblaWtryArIWA mZY97LEiPMcwdQH1N1ubd1ZFubfFS4wAzTEUO49SCWGit4NMyCQKTXSsxoRrQ7fz0XygADLpWkQi hWXiyC/aBvSk959PSAh0tjDQ1qJQKFp0bV1Dcxu3iKIDYI+c4WFpYcPj560HXC3vsMftAQ9tm2qe mcsAPcCXa8aGuJhqyzoPuQ0UhmTtk31MfEubYh10tFj6xly/jHmDW7O1B29WZXiasWkULZaxvX/2 0hdAF52fkR7Ms+KwaFQKlcZkG5jauEcU7wdzMh+lu1la2rmFlh0FbGF3e6yghEBT9a39x4LGRf1n YVaggxFd1vUG2kCiSeaBwqUSetayAK6+EZcnKNg8xDVb/5oe72LCZjDYRjbeidPBch//WlMa4+Ng bsBmMrXZekaWjv7CygOA84qtcc5WXAfPmBrQBabzkD3uZs7hrYHQqmuAl1+angSbc4xMQ9s7wZAM /KOnSMgUeir05Nr6JAzSsRq9cbM63N5Ih6VjyHWPHLcTTLnrCwtjfJ2sTI2MjM25Lv6x+bO+A5T8 t7JgB2tbZ5/kWYArTM3bu9ljBZX2ZWLA0a9lV3W0h6UOWXMkmPNRo7BEpmf0OEnfa36Eb1DmzGGo AdhyuDDQxkhPz9DShZ+9BGyXpfn68ursOIG/j29ASExG6ayToPOK96vSfBxsHVwDRy8B9EtfdLfH olg4c/fUhYBR0q/XFoXyzEaIOYf6OYHuHJ23Q0JjL+ZlFa0acKYKCO/WZnpzjTlG5g4+qbU7AGMr n59bM3N8eUlZ5aQ5B34ENj8tx8ZFejjaO3mEFkn63T25v6CrPW7fYPHNBc1bf7Aoe+SY81GjNPA0 y/BsSSFoTXULDg1TsPnfsxLduabG5rbusYULvwFOlHj58O7du/XPpVkf/GFmOt/Vwd7ZK6oKrDZB a+s307ra4/YNluBy0D25KzOSfW1EFSZGhOajcBSD4CyJpyLduDUcVbRE/Dw+mmdlZs71Ck2ftGMI a/TdWlwU7eNib+/ikwC45AdPr7va4/ad/qhawANFW/aOj/Ww0h0p5hzSnKzjkzn+C0nNBftVg8KJ klAnroW1R1Bc+epjL4boIc03V1Ym890dbO15/unzAZ/yam1haFdzLtr1dU2aC+hA/LO+OEwUSTcy zDnsuGvbJZYtHfRK/O+l/lzeb8wJdLJ2dvONKV+8fYiGl8azqyZkhHnBK6+uQblrAJ/SfXot2mDR sfQavQrw8odLsoMcjWRcbKAbRIZxZPG8wU4LfPmH9F/R83mpvq6ubt7x4+pADa10ND/Yv3T86Chf J2sLS1vXkBLQMOfu0+uOFZlC0Mu/m5niazuCzPmoUQQaxy9/5o5B7VhND25cuyX9+vydSfF8L7eg jMqpQ9HNW56e3jxnXEYkNKc3MTLl8iKqAUsBtuyohGfnnea8PUamErSS4P7xMR6WkDkfCRssbWCp uvYZk9YM5uLq25unDh069Yv0wp2dkBjoG51f9sMgNqadpifndyytHZsc5u1gztHVM7R0jgY9nOHV qoJgZ5NOcy5ahePYRdQClj9tXFsIT+5HjjmHILPMo6uXApdL6JvnX+/dtHb958fBK6108GF3eXx0 ZuH4QXcd3z04tXPF9LKsWL6HnameNkNb38w5fhbgNPT+nDRf23+r84o2Ug0dYusAQ14fzs/wszOk 42ScnNgNIsPIu3D2tsFaUm95cHjjoroZsxZuPC79ySWvVpYXlRUPOC2qO831PxzeumzauDGJ4X4u XCM2jUKh6Zg4JUoI+P2E8xOi3SzhKtxK7Zpr4Oj/x9x3gDWVdWv/ooD0DgkQICT0QAglEHrohBpC CL333ov0Ik1RQBAVGyOC2JWxY+/9WsY+Y8GGBUHp7bvnJCEnKCoO+N1/Pc84PjHJPtlrr7rXepey od+GWX78WgHNXBv1/0uynUlwRb3goo3z5MWN3dnZUJqdmpKWW9n8L6b1PF9bmbNnfp6EQRO9j07u 2lhTnBblT3Ewx2sqIaTERMSk5FQMfWe5zuTGOEdDEG2fGV5zcPKKSCsZ+s8Weqgt0ZmgIS/BbGcF aQGd/k95LiGv6Zq7Zn5qIgYubFmWHRcWGBgclVbR+vTXv+Bu84r5c+BGex6e2LNldUVOUrgfhUQ0 1FZFykgICwiAxV761Fmas55CXwscWlpkqpYN4LkwHIWnXp7dx/uL/Yk6yjJiAtycixZxMmjRwoV0 zv/f8VxEVtUsadWu+ch9fTy6viQ51Ivs7ORGC06p3vPrBmPi3DxNVRvtfX7l8K7m1VX5qTHB3mR7 CwJOHYWQEhXk5eHhF4EhsdbB+TXrW3bsP3T0+IkZqfPowX07tqwuDCXh1eUlWQMWODh5hKSQWJuQ 2Xy8ZXVxhJMBBgnOyOVezMPLy8fHx8uzmJuLc9H/6UD0BTIq+IBlrad+bR7kDDT5fO/qvBhfN1sL ExNzO/eg9Pozvy6z302dD3/42NM3MAvHabz/w4vbZw7taW2qLc9Piw3183C2MTPQVkfLwcSF+Hm4 uLh5hSXl1AwdfGPS8pYur21oXMuiNXRqBGl1Q111RVF2QoCTsSYKrMZm2mOORYsFJRCqBg7eUSk5 JVUrVzU0zkT0jxcvSQhyNsEqy0qKCPLzCwiJiAIkIizIz/vVGPb/MscXcMDROo75mw/NtfNw7M72 lVnhniRzvLamJs7Qihyat2n+EueTr/++c+7E8eOd5289edH98WNPL9h8xvaG4aHPHz+8eHb3wtE/ d7dtaqypKMhKigrxpbrYE431tFRRCLi4MCBsgIbl4hEUk0FpGlq50oIi45PTM7MgyszMzMhIT09P S0tNjo8OC/B0tiZooWXFBXmmBiYtWMQN6AkFNT1zB3ef4MjYxOSU1BkoJSkhJiyA5mJthFWWg0uI CAuJiktJy8jKykjDJETBs8c5zxNzF0ynH7J8ERcKZxPb2HFlboI+cOGPytQQiq2RthoKiVTC4K0o 0WU75i2p23fv6oEt69c2NqzbtKVtx649+zoOHjp89BhTsR7vPAY2ou3a1rJp7arq8qIl6YnRoQFe FGc7SxM8TkMZKQsDOA6iWSzkWLgIBEFSUNM1sXWm+ASGhEdGTVFkZER4WFhISFBQYICfrxfVjWRt qq+JRkgKgy11zB1byEVv5FLXNbZ0cKF4evv6zUS+PjQPN0cbM7ymsry0pJgo4Deq4fQNCUYEA11N NFyEn2c+R2MvAN3DhQsXgS4D8McP/QVG+6EizsqvZv+1ORUzA6a8OCHA1dIAg0bApaRkkBoGtt5J dafnySObfHz1YCMgugkpGdl5haVlFVXVK1bW1tU3NKwGqaFhVe3K5ZVlxfnZ6clxUWFBfl4UF5KN hTEeh1FByUlLgpLFzTCiIL6dKExeRZtgYefsTvXy9WcSyCgfLxrVw93N1dnJ0cHG0txIH6umKMuY qMvcQvDzfMISMkhVLT2CKdHKxm5msrUmmhnpawNOBFxSXEwCrqjvGBARHRMTHRnqSdSQZv/KeWA5 cJI5uQCPAXAZfuIvTLUf6tn6Vx65NwfviWHKvZ3M9dSRINKbsBgcxH4OXLJxlheOP6N31zrXFSRH BNJ8/AODQ8Mjo2Ni4+IT6D1qACUnJyUmxMVGR4aFBPp5e1JcHe2tLUwMdbEaKih5GSlxYUE+kOPg 4QfklJNHQAyGVNczs3UiU2m+fgGBIAUEBABc96ZSXJ0c7KyJ5iaAQGpjVFFygE1gF0pGM5ewOFwO paKhhQP7KWYifT1dnJaGKkpeWkpcDGC5vG7QvQ8fPnwE/vvw7rgFSlxo/gbm0nsKuRbz8gsKCYuI CDP8Bc5FMzEdaj8kuMTUXpwD8hfTlDuY4FTkpUQFeHl46RByFuSopfOj3Udvn24tiPZ1I1rZ2pOc XNzIFA+qJw3sUvPxBcjHx9uL5kmlkF2dSfaAeJoQ8LpYjKoSUg7YccB94uFmuEyMfDknqJuV8A5e IVFxiSlp6RkMAo14ckJ0iDfZgWhK0NfR0lBBKyCkJUQF+UCPa2oDGaqRX0hUEi4rj0ShlZRnJiU0 CikvC5cUExYGFbuKdREEaXrPTQMuyj9vczSBYwiIroCwmCQMLi0NhwFr0u3Yt7ZjAav9UBUfVt45 h/icacptCFgl0PQt5uLi4hEQR6jibbySamc1Puln9PzS/opID1tTbR09vKGRsamZOdHS0sraxsbW 1hbUo7Y2NtaWRAszEyNDvB4Oi1FTQSPlZIANF2GeeUjTLVgI+GBS8jou6/Yf6Txx6vSZM2eZdObM mVNHdzTmAiaKSNAGVIScDIxxYuifh3YYYDogVEIiYhKSUjA4HNjnbwh4FSYF6HQRQQF+AREJGZSO B9vAyhM0bTlJIZ55ysAzRFdQTBatAagdPV0dTRWEBAjF9Y2TSH90QB7hChgTaumVOXAGMuUoGUBl AWuBkiAkqYCha/d5aHPrv3qsMd7DSk9BEa2koqauoamF1cbhdHSBX6inDxL4S3HaWC2MupqKEgop JysNHHYRIQE+nimGL2D9bEC1i8soW2bMvNR4f/eNtcne1voaaMDdFp3iONvuMY0nEG3z8QsICn2X BAF28/EuXszDB4SGKsahF6BFtnjqKsJE5qtjEfhJYFOhHNbGMzAkNCQk0NtJX0FckPcbJ5FhyoXE ZRS1LQNLZ9t4NQOxm3K4GLjSQnACBDefCBzU7hFLt89Zu088ONuW5WWpgxKXlIJLyyDk5BWQSEUU Co1WUqKrVuB/aBRKEakghwC4LSUhJiosCPKbm57ymubBgm43EGppU9q+v97Y49Xh9vpKCJioIO9i BsfZN4/hJAMeMhDqA7R4ZgL+hYsL9KK5eYWlkBo2ydDZ/7KCooOWFuWbJ+hXRiQho+ly+MnfID15 fD8NJw3Od+eY/tgssDc9h8jGWY3C+M7+3GYz5cwIZAF9LBeo3fUB7V5zcq4tzK8vH6wKtMHJ84Jy JSwiKiYuLiEpKSUFg4GalU4wmJSUpIS4mCgQCNPFi+66Lvw2YgHCa3CUu0nYD3Ong8di7bUV4aIC PFwzfAcjFuZg0EKIFtHDJCYx/3kBmJ+HKWq75ENJydeFbrrKMl/zfLbJ2G+ib3CvxeBo8zTICa80 VpD4ykmEwN7UDMnJe+YA9jZw/o/KlGDAlGsxTDknw3CC4xzo2t0I0O4b5qjdh24db4p1wityc4Lh CCODyc8vICAIEKRIBQUAXtMTm0x2zxyhciziEYIhtezTftKSejnGBiPHhK6bluuY4iXbzjNeZWM2 +8r0Oxm0Po0N3uBhphMbz6d9mvnN3+P1tGWYjwCIOR+YTCavYy3Qk2+pIiMGDluf5oUwcVvNvHLm Yso/HAFMuT+7KZ/KVgGHCtLucxq0OfH02r48qrGqJPMn0xMPgF5laFaIQE3KycpHfE9mOLj4wJnn HlXf6cadosmOYBNVWXE6KinzbmQRg5h/X8g6C3RFz8XFVPLcoEJnMweMBQlBh6CqgLOJ9nSeg7B4 0z/NOK8zHFfG+8AYnO2NdCvKQZcueTXTMKj2uivdThMJE+FjKSl2sDfr4KrZtmDPtC/P9tbn0k25 GsuUQ74SqN1lmdp9Lt1Pb++eaoi0x8qwYiV2cZtGs7ikBBsSJOQxZsFbfzYM4ku1ux5wkIHInp7o AHMdDKL/jZn2oB9CgBE8DLMjLAxoHLplYUUKCzi4+MUQqqbB11jfPNESbk2/qQNYAjrSzE8LgR8W 4OdlDywhPcJwG/n4wfeBywBKje6fAucA3GdlHVI6hIf0V5qjnho9MmAcvimwN0mEir5T7OY5iODY 7fZvTTn0nOzafQ6zegbunW/JpJkpif6Ql7MlOkQECmeXcPKnC9+IscIgpcVFhMBEh6ioiAjgKoD7 DW456CHSuQ5sOTcPn4CwqDg9NgaCY8CDFGG7RKEfMjl1M//Dz16+edvd3f3m9b1CH3MsCiYMyAjj 00KioHMKBwI8ILwDoo3pNzB0EWekXIDoUIq1jCiYewEOHw+/qDQKa+pbAWmu85nupjglWUC7M4/P FNibuhEl/fAccuyDl9oBU+7+tSln7S5Tu2tbuEWUtn/6t6uMPbu5vzTIVgs+LyxnVjbh3XIf/nTl D6XueDWkDOAcwuAyIAE7TY/GgcABAQcVADeokum5ELisPEpFXQuL1VJXVkRIS4HJfcZ+g9dwwMk3 oSQsXb1567ZtWzetKopwJmgoSAGmEBBxfiFRCbisApjTw2Ixqmh5MCcw9WEmywGO8/AJiohLSSOQ ymqaWGAZNSUkAsz3AF6MoCgMiSGQYltYbtnk3iU+dkaainDAd6dnk+gsB0GBzH3y51Js2HNy68qc KDdL/NemnI3p4HRVQLvTEv+1dp98++jc2ngXvPw8pSmZEBHeFd2sJcaGhgYHQBqe/owTrcEWODU0 Wk1LR5eeX9XVVFVCq2jgDM2tzHVRkkD0D3iTAiLiMARKDWdk5UT29Pb2JJPAoWFyzEu8hXRrK4XU MqNE51TWNa5bW788P5ZmpaeKkBACPs4vJCYlq6iKM7ZyotC8vakutsY4FQV6tpebIaGMDBCfoKik tLyyFt7c3pXq7QssY2+uj2Gl8jXNXUNLzrH8sv49VQkBbtZgTT6YQuRgOuxILcvglXMYXD/59kRz ZVa0v5ulhgJcTICH3ZRP8Zyl3UkBS9b/XK5mpE/PbuzI97dQma/UNAeXAB0iohFKO769fen08WNH j544f6dr2pXDqQQSAadtYOsZFB4RGRUV7utkijckuvon1m3bs9YQCShXIWFASOWVcWbOvtFLGrcf OHv2cPvqzAiqjb6KPExMCNB9ixZx8YrAUdq2QdnLGzc0/9HcVJMX6mKsBcqJgADIcSWsiaNPTO7a nZ1nzuzfUh7r42CgKgdmBuhSxLwREZWUUdQwsKYEJ1Zs2Xvq7NkDbbXJwW7m2sryCFkEEmsdmF61 FbKf70+11i1dEu9DVIUL8XFz0mH3hSXltWzC/5gDOP7Es7N7G/OivV1sjHXUYF+ZchbTp7S7uVt4 ybaf+Mkz0/Dre4er41x0pOfp2pHVkHCA5UWPPzy+a+umpnVNG1t2H7vGXn95M4tCNDJz3971oqur 6+XLrq6d3m7ecRvufAH0wUNHdRmYpKSUtLyKrrVXXMPJf/pH6XI2Mfrl8f5ifxsdJRkJehp6Mb+Y jJIBddOb7nfg/cr7dxdjHPHqSLi4iDDASRTWjBJVe+rpwBj46cnx4VdnVgbbAR4eM6EJCjm/sIQ0 UoPgGJzf+j/dw+P0J58Y+XSnNZFqpq2qpIwhhtx62/0BOsUjvT3vu1+/fLHNREFMEMTYBDU7AmMb c3ROmZL+3etrSpO8bI10NFUUERKcM17csbS7tWd89b/CiR15dXlTtr+5Eud88XwKIgIapDd8tq2+ qiQ/N6+wom7z/stskv6o0I9k7RwHlf4fz0yv+YuxbWeoOmgFOTkFZR1L77S9T7/KcPSczqQaA44z oKIX8wpJyKlZRNxk/eP9OHtdVQW4hLgEXEGd4Bq76cH0ouvBy9nuhsoMewn6eAKiUggVPCm08tLX qbOuLREkgg6OQFkx8+4dcFCWAsF0wVSgDMY+ea6Q2ZNXSnNSo2kW2iooBTnAaxGcaYdZ2t3BL33N 7CZafkU9J1bGOmnzzddV8xQGdylUFNTTsbo4MzE6IjIuNa9yPXu10P3SEHfXoBpW6njy4Jr9n5h/ 3+ND0FRTVcMCvtn2lzPU479pCiJi5CWFBfgFReGKWMcsqNr/bKytjqqCDAwui9K2Dqz+61tZeF1L IwBMFwRivsXM8Tc+BRdmKMefuJTmYWlqF/GdwX7Nruqy4gKLgWiOXxxtkfnrDQff0OifMaEBXiS8 qjwC8GkBp1aC95st5gBzRIA5M3OJrdrxb7T7xLmqQBPRebtqpoN2apoH1kLP8qxlaXKEnyeF6hMS v2R5+20oQ3WzLMrHJ3EXi6P9nRen9OdIk68FXleXYB+y4tHMHRiDe8KJGnKSIsJgUIynQaDf4+0R VjpqinIIeRU9x/j9M15G9Kyg6qOlxYBQn19IXAal4xC19e3M+3M304vkkTGzAA9WO2vKg0E6J48A DLNkfjoYxvZ7UylkkikGKSM9Fc1IivFND9gE4co4E3tqWEbt4X+j3fuqqFhRvnniORO00zpqK6SM rzVkhHo62VrZkDyCEkqab7Kly8pig8LYoCLf32CVGHysDrC1MLOiJO767gXS6PYgE1WElDhgizFm oXtYlnSwJoioq66kiFI3cEv/HgTbq2wnLBIuBo4ZlFXWd00+890M0uU4r+DSmZ3xt/mOmkiYMC8Q 6QnC9WpaOjrPXLx68869h4///ufps+cv6NTV9fbjx77PXwZGxiYmZtVANN7h5uri4mxjhKGD87GI foEMl5aWlZWTR6liDSwcaeE5jZe7e3r7PgPfP6ts78T4SH/P64fr7BCiUDXaHHnO6C8kpXSyVhk9 VB5FI1kQDAjmDrSI3E0Qes74odL4iKRlT1kvvIP4+7w0yNXRxT/r7A/yG59rqHg0QhoIsXB2SRCo 7psyHwt9wC5gCO5Z34fqORNhoa4gLSkBQyjjyVk/iKkHK0Li1s0swg9S7bQU6TznFZRSIjj6hMdn 5JevqF+7oXnL1ta2bdva29u3b9+xa/eevSfPX7/X9WlgcHZSOfkqzxkkB6KBhqKcrMxXJIuQU1BS wxnb+8QV17fsPXL89LlXs3Meh7+8f3xh//o8L4wMHdR/PgR9CrQzB1KGn9pyA12IBjisDsHaPTS/ BdKhva1FCbHZa1iJykm2qpLbxWFe3uEFP+6Zfpxir4VWUEBrGJDznrJefVToZWmI08IZu+f8IH7t K6foqSARCAUVgOU/yGKOHMyISN89846ei7MGec7DSa9gUcEZWTtRA8LjUjKyc/MLi4qKi4tLSkpK l5aVl1dU/bHz0Pn7b/r6ZzueeOxWsDOD7zZmhtpqaAV5OYQsk+HyisoYA0tnWkhsak7JitXrz86y 6G5yqO/Nvc6t1ak0OurzPNWIcnDyiiE0jL3LIGX4qindh2Sqp4XBGli5R5Yfgn5017q8xKTivTMd /cmThVEh8aU/ac4aa/Ez1lAGTryZ30ooBjy7xNPaGK9v4pbG3i42MdzXz64zJo+FE4E4TElN3yXt B+52/8Gi2IismTtyJluDzDWRUkI8ixi35miMrrGVgxvVxz8oJDSMjoIcAVAkWPYbE1e1pvXwzZc9 n2dfLjXyaJnzFDna29laWxIBsrS2syc5ubpRPH0CwmKSl17vm23H6UT/p1e3Dm4qj3fXREmD89fm x56DoJ0KWhbBtdDJu9+Q7E0y08Nq6RjZeac3QW775PnarKS0ZZdmeuTx1oL4lLIz7P80+ul118u3 fdMk7mGKvZ4mBou3iWxhnZyRvZk0ewsTc5cENlDo0e5bp0+evvyMLeT7J9PFEKephSclnGf/yqEP r7pevpty4Xv3lcYHh6af6e37Ah2YieGhwf4vfb1d+R4ERgMO/RIVJqekgTMwIdrYOzq7uLq6utGJ TCa7u7tTKB5eOcvW77n89EPvwK90BQ/dKnaegVxcXMkUWsDR97+QDxj/3NN188/1S+PImkrgLNV5 KgsGMzJSKJxt7E7Ws0xcqk3yc7E00tc3svFMrGHz4Pq2lacnZa+a4e5/Yvx9fV7GUvYZcyPPLx/5 c/+fR07f/cT2xi/LaCYggLRL6gnoa5tTaY421k7hG6Ga08+3ju7d0b6z4+Rd6LXeKj9LIwOCXfg2 NvEffnYBWKbj0OnH9LXfbSuJC/QOiC3b2HEVCkR6H149dXj31sbiAFtdZSBW417EKtRVxWjrgvWE JiamTDIDyNzc3MKCSEosrGs787i75/MvtoJPDry+3kyexvP8PQ/7xn7ta8Z6Pzy/tm9tcYybBqPF bL7MOejCKes7p0OlaSPHG5ZE+5Ed7R0pwVmr7rKdy7uNeclJeU1fx0hD3Y+vnGhbmlO8gQ04r+fS vpam1Q2N67d2nGPP5LWH2xgZGlt65kO5ibeNSV6uJGf/Imgs7JdLHa0b1q5t+mPXyX9Y1mJyY5ST FdHOv4ItEfPx/F5gmfqGNRvbTwP+5Ivmolh/KsUzKKGoqRNKqr48vWtjXVl2nK8DQQMJBy/RF9Kr YsVhMvKK9HJCDJM0QdICCAsQzig0o2rT0XtvPvT+y4KKyUnA85/8d+ABoz3v/r6woz43zFFJQUYS LDWepzYfFsoXJLy9Z7etKs/PSE5KK2g83s32EL3tFenxiUXt0xPUQ49P7dy0ennxkrzam9Cr3Udb 6iuKcnMLSpav2XGe7RMXkl0szCwcgqqgk/OwJsHH3c079TBrb4avd2xZU1dTs2pN8/7LrMTL5J8p nk5OXpnQtTtjmcK8nJy8woqGPb0PGnIivN2cHF09Q9PqTrD4NH5rR31pZow/2cZQEy1Db7oCS6F5 +IVExCVh0oCPJScnz0YKACFBQql6xRU1/nnn1ftP8z+P4yc08unto1NbqzP8rcGmH2H2e8U5Egvl CxLRz88e3blx9dKFi3eeTou0J86vWhIfk7j0yLQz/+7sznXVxUvSU9JK2qG02MfDG6vyUmKjImOS skoa9rAlae4v8QQCf5fotRArz1fG+FJpkdWs8zX597G2dbXLKyuX165rPw1piWM5AZ5e8U1syxzZ WJWbEhcJuF6Rsal51QWJAWSSjaWVnatfch3kDw51ritODfdyIuIxaFlG0xVYcMG9mJdfACwmFBVj kTiDJJgkJescllWz63pXT99s3ff5ocnB3ncPjm0qT/Q0gYkLC9FrE+arhXMK5Wvzz1FFHq8vSIiM SFzGJmb/mXx5pHlFQVp8dFRMajUUMo+c2ViWER3o5eFB849MKd5wGnJ9/y70c7QnUVM7WC7c2J7i SD+vwKyjrIPRd+Pojs1rVoFyvnnXWUghnCyKDIwsvjltmXRgGQrZjezu4eXr7022J5oQDI0tSLTE BgjesGdnVUoo1cFUV11RRoLRIcWsv2LUEoLt0NOJn0kCguLWfimV2652ffo1T26ONP7546vbh5oK I111AQnnhcqV54HljEs1XXu2S7Xv0ZuW0qSw4JDk2qdsL74+uL4sMzYs0D8gPGsDpBUet1Wmhnm5 2Fpa2jrTwtJWsKVT/ykNcnV29c+Damw/NeeG+/tFV7LwiyZe3D1/tGPnttbWbTs7TtyAeH66LD4q gy3b8oS5DNGM3tFhZQU2Z2lrYXWNrD0S10BW/+nGnDCqnbG2ijyr6YpZtMcozJ0CPviKwPpCrsUC 5p4JZS1n/373ofe/pt9H+t4/u7K3MT/MXpOX++ctlr/I81njrr9tK08K9fcLSlvD5pH1HmkqSQn3 pbpTaCH5x1gvDxypywij2pvhdXQNzEleUSXtEN/ul4ZQyJSwcqhp7+XazLDA4LRmyOcfGx0dGQbH gAJ/jIxCO328IjllKRTPDR6tywil2pvicVr0jg4dHW1NdRU0WgWjb0FO3gI5EVdr4mn2RmBH0fSm qwU/IXpF4aLFRh5xpRuO/fXmv6XfJwd63z8+u31VTrCNGhdUYTwf/Gbw/JtLtZmpC2B5sDeVFpjV Bv3wsaubSxKDqE72diRyWBnExRctRVGedkb0i2w9C5fAvBbonNwoDvX08Ipjm9x3uy4lLCiy4PxP Nc3k7or0nFVPoWdqKQSXwaqiQJ9LEYVGg+06MrIKKjgzcvoBlvEY7SgKdjLVBrw3Ib6vmq5mQxxc BuSogoZ9N1719A7+F/T7eN+H13ePtyxP8zVT+B3AWhyc4Ng+s8AVP677HL7bvDQ+gOrmSgnKY2u2 e7OjMjmAbGtuYmblHLnyE+v1aw2pfo7GWmiENAKFIdj7LmGD4DpeEOJF809vYVn48VNViWEh8ct+ ji7c31aWVcxWoXq1IdWXBCwjCwO8LXqbHExSQkxMUgalZULJZTceaVQrPRVZMYFvmq5muUmqpJCs le0X/n4/PTP4O2hy5PPHZ9f/3FSZ4IHn/R24Wgs4uOmXatEtP/opk2+PrimM8XUj2Tu4BpVCntr4 +dUZQW5WBF0dvKljNFRvOHawKtKdCFbFiEkiVPSsffL/ZHF4tC072Ns7JA8aeDOwuyQuLCy18edw aO82FmdXQMBOYwcrGcuICwkKCDJ6jsG/icIVtUy8SiA8j676aCdjjLyEAOC8fd10Nbtt4uS39Etb 1tx5r/vzl8Hfius9NvDlw5NzOxuLol21eX4LlBrrUu3E93XWyNvzW6ozw2lO1kQLG+fQZVDipKe9 JIJihddS19AmkOIhR3xgd3GQk5GGvKSwkJiMsp5NQDnkLbxtTA308Y0sg1BCP27Oiw4Ny9z688Dh QX1edjXU9TWwqzDQEVhGAtDYYHMkSGANpbAUUss8gC34vFMZZKevIi3Cw/mjzo4f7xOvCS2hZO3+ a897Pvf/OljzbGli8EvvyzudW1dmBVmrcv8enPOpS7W87xTsTI5+eHBiS11hYqC7nbmRoTHRKXoN lNF8uDbN294Qo6SI1jBwSOyECil25PvbG6ghJISFJeTUDB1jGtmM9/I4fx+/+BVQddWzxoyIkPCc XT+/s+ysyMxaCd3A9m/P87MzUEWIC4LFtkBcxQ/2NPDwCcNQ2pYRTSzNNX6qyNeaPiBgRsiB2W0U B7e6S3hu3baT995+/jLwm6bxjH7p7X58sWNTVbInQeB34aIyypxNfMqhSzV6mXP/ly89H953Pbx8 oK1pRWFKGM3JkqCrjcObuyS2s37v+MnKCFczLFpOVkFNn5RynMXzkb1FAQ6GGgqAmZVBaxN9CqBL rpE9BRF+PgGpbAHXtZXJYcHheRCe4GjP+7evu54/e/rPU7CMoevlq5ddz58+eXClPjspfSVUtTe4 M9/X3lBdHgYW24I9FsL0UmsBUWklXfskKKk3tCPHC+S5MA/nHCJcDi4B64D0qg37L//z/vPA8G9Q 8GOD/T3Pb3ZubyyJdcX9FlPO/CHgpRoxdB0UP7//68q5E0cPdezesW3LhobqkqyEUG83WxNdTTU1 jK6Ze8Yp1js/b8/1sdVXQcBggNEmJbOZhwtV4c6m2srysnJoLWO35GbI7epqTAv28Q7K3sNy/icO lsUEB4ax8Xzo8dUTh/buaGtt2dq6bfvOPfv27mrfsmH1iuL0mKiU5VB2beIYOE8OqyQnDYPBZOTR ygrSYkICAsIgapnbEuh9Hzdnetvoq8iK8s0pkwWEOASP2IL61mO3XvYODI7MM9fHhwZ6X987u29z dVagldJv0uv/D7pUi4Mu1SafnNi1dcOauuoqEHwoJS48wNPVzgyvpYJCotR0zDwLICvQvS6JbI5F wsQlZZX1HJIg3f6fl02pNBsCVk1FTdvENaYGigNHDyyN9qV5hRadY735y5a8iAC/kJz9rD0cfXhq b8uGxrqalTU1davXbd6yec3KsryMxMjggKDYcjaYgkcNCR7WhlhVNDidytQxlKglJykmKg5HYoDg E3I7ujZmgncrChKCM7Uc/MJucXAL2QakVzbtOvPgbd/A0Ng8cn18ePBz9+Mrh9rqC6NddPh/I941 4MIJg5dqGdB99PDF9vrKwuzUhJjIsOAAH6obycoUj6XPYJVXwVn4VULz1x6tiHAkAFZbRAxQpnZx uyHXf/zs8lgPG2M8nmDtmVTHVtLyZHV6EI1Ki6yAymFer00L8vEOzGhn+eOTXad3bKivrixburRi eW3T1jN7G0rSY4J9PSkUWmjhMShFM9hRGk62NtbX1QXWSTvZ2+SKU4BLwRFKWIugOsjteLQ5J4Rs a4xVEAfbluYiQBycvFpuUXkrm/+8+Phd//Dw6DxxfWxk6Mv7v6937myqSPU2Ffmt0McgHrOsmiGV bXRO74HG4oz4MH8vD7Krk4OtpamhribAcZiEuBRCWccybA10NXKuxB8ctiAqJAJD6VhHrGcr9xk8 tjwliEp294ku3MY2pK9ve1GkF8WdFlsD1RjfXxnv50n1TWr6xHpp6HpH8+rqirKl5Ssamg+/+s+X nRXJQZ6ujg4kV9+MdrYr+u62pfEBHm5kz5C0NmCZ/goXbUUEAqmqax3Zypbh370iOy7M11dPFuyi mdN+LuDgErTwTipdve3wlSfvPg+NjI7P2YefHBsZ/PLunxsn9zbX5ITaY34zqD29zBlj6r8MgsF7 1VqWEu7jTrIhmpkYGejhNNWUFGSlxAAvSRzQ4Pbx+6Hs1g7G6CUhASEpRSwxoIq90nT4TuuywtyC FTvvsxUWjZ9enuDn7uJGS9rAOh8TZ8vCaWQyNYp9/mzvlf0t6xrqG9b+0fEALJl4tyHT38WWaE60 o8SuYo/jP57eWF6QU1i37yn9sV5m22PRikoYvH0CW3n7wM0DbS0dt56SlOm94XPbUSDSEbcPzqxs 2nH00sM3fYMA1+ci7JMToyNDn98+uX66Y2t9cSxZX/A3T6Jijc5pgmTnTmNGqCeJSNDT1sKoqyqh 5GXhICwnLx/YfIN3zoRCpU9NjNFLAnyCEvKaJtTcc9N+zeDLh/effpgmBXcAze7uRHL2ytzHem1o d04A2cnRLaiQHdhkqOv68SOHj994xtQqr6vDnMwJBgQLUtDSm9OW6X1x/8FLlgd6O9pSU0UNS3BO Y3+YyeEh4Eg8oWJgIvyL51pqAjbPqzpH5FZv2HH4wl9dPQMjo2P/VtgnxkeHB3pePbx2sqN1dWmS p7Hobx9KxOpUOwzVRXVWRnvam+hoKCkqyCFk4GBLN/3udjG/GGJ6aUVXbQR99BIfD78YYCCc4zf+ GBhp8vH6nFAKydbOya8AKpDv3ZDq5WRrS/JMaZ6WlBkfGRkZhbbyXqYTQUdbx9DKI631R6B9HZ54 DQzOyDXzW+z9i944dozaOWwbB7cg1j06d/n69gNn/ufvbkDFj41P/Kq0T05OAEr9c/c/ty927mtp KE3yMgdnlfxuiOOp0TmZN1lP0t+S7UsC52mDHb2iIkKCDIyHRYu4+MF+ZZ8qqG7mZhlj9BIPN68w XEnXOqB0xtpIFj3eWBBOdbAiWjsGlUO59a7aGLKthbmVc2jFD0ckbHHU01DTwBmTwqp+NLl5MNlE S1PH2DXz2/L3vV46ClLCvPOhO8GNU3WNWFK5pnV/58U7zwDLDgj7+KxroCYnJ8fHRoe+fHhx79qZ w7uaVxUneJpNjRv+vcS4SNWnFD5lPc3rhjhXc5ySrAQg3RCqOgfHQi5+0PIHQ1Zg/MgSxuilxVyL BSWRmqbkpNU/mFo0/mBTYZSnA9HU1NIpshbyH25VBDsRjQgmNtSUTT8A1/0r2UpLGa2krkekpm/8 fsPX2NEgU6yWjrFz6jdDPEc2eOgogqVw81NetAgQF1JQWll9866Dp67cfdrdO0CX9p/zfXJiYhyQ 8L53z+9dP9fZsa2pOi/G3ei/w/EpgAlDr2rILbpbHmiLV0WIC/BwsYMPgUYM4Dkxcg/rnf1bEp3p o5e4OLn5wUZbW//c1k/f+6EDl5sKomkOFmD5o9v/tnemYU1daRwvKlJ2yEYSspGEQPaQQBKysAYk EJaIkUVEFkUUCIgKYkEERBQsLqC22kWpaNVp3aut0iJTQdQZxzpj6/ZB6+M4al2HUVv1mXvuzcIS qz4T207r+xHem5yc9+z3vP+fcdDwfGBBRqwyWByiis+p2/Ussa4nJ6pS5Ww/CpXJD9Xm1O991tH8 /X2lOrlAEBSqnfnp8LH21pIUkwCdndL8oIkRF5lRXLPs3c4dB7qP/u3clRt3zXG3GXnw56cg3gN3 b165cPr4ka592ze0N87Ojgu0X7GeZw6OLlDMQ7PWW7fGh6pS1QI/H4SUMuiFBDiwo/KiS6wT8fXl U2MBesnFcbSjsxeeLlAlTVv0J9vE6MdX97ZXF6bHh8tDpErNxKpDloD8Z9Oc8ZFSAU8QHK6f0XzI dnbHrf1vTYoQgpwnCisoXD+z+Qvbft9vmmMIE/O4QmlUduvw13SXKhKASJG9RAffgFdzrihSQk55 3fJ1mz/d3/X1sVNnL127dXfgIRx5a+jhWMO9++HAvR+uXT5/+kTf4YN7t29cs2RegV5F8HJ59fO4 2YBMmy9Lkb3TUjEDHTO10kASenjNIP2cqzFaN/Lf1qYD9JLnm2NGjwEdPUASNWFG46aLI+8PPb3Z t7GlYmoaFHKJRBamndJozUK5vnamTiVi+7N4Uk2asWW3jTbz8Mx786fESdk0Ag5HoLJDNOmly/bY 8Lt/fFVFZoyMzw7kitX6OfuGFaSnMEbIINhNXNRULY7OHjhqUu6s2rff6di2+0BXT9+JU99evHz1 +q079+4PDMA3feAXGPfu3Lpx9fLFs6f/2n/k8KHPdmx5f1VTZaEhgoR2cxr9C1LmEGk+WYZ1/3Wj PjNcxCB4Dd8yOID5nMyOLLYuzT8r0cnYFIw7VOLRY108cVSOLMYwo2599/WhF4geXOvtXFVrnJIa Fy4TB0lCo/Ula6zHNBeW5Y2TcRlUMGqPyyhp2nDizpBh8em985+0VuQmhon8STgUCkOg80LjMo1N Hd8MTTN4fPv05pbZkxOUokAmA2pAsVPqugddsH5yu3dBWhjPz8fLXiLClpoZNdbFy4cWk1k0v3H5 ux1bd+wD+Ye9/SdOnjr9j+/OXwB2/uyZv39z8i/Hjvb+ufvQ/j2fbP5gdfOCWTnJYjLWHvuIl7JR 8KAcpFu6q7u3//iJ431fbZyuk3JgCNbImKOhISFrw4GevmPHjx/7en9dZoQIjJWOQAfKyc2bQOeH xhqmzWvt+PLczQfwwPbk0Z0rJw90rKovn5aRHKOWBgkl8qikvAbrraWnvQszosQsCpFAZgqUcWkz qldu7rt050f48cePbl7s3ba6viw7OTKEQ8OjPD28ML5MoVKbPqO2fdux7+/+hPg9uHnh6862WmNW YoSETadS/AKEysSChs6T//w3tJr+6f71c11rq3O1UjYFxnvZvRrhNk/2j5tcVFnXvGrdhs3bd+ze t//zg11fAYnsnp7D3V92Hfx8/95dn2zd9P6a5YvfKs3Vy+hE9C8e8DdgzU8PHIWr0hdULFjUtGRx XWVBilrAII7MbQdTFxRVkSazpGphY1NTQ7VxUmxIIAXn4Qwmfljyn8jgyzUp2SU1y9Z17jp49Fj/ 0e49WzeubVlQXjAJMJ4kQr5YnZhV3NBp7eYPt88drxbQCVgMjuQvVI6bkFe2cPl7W3Z39R3tO/LF js71K+rnTs9MipbxgcAQkBvAmvzK61d+uHVvT39//9HPd3auX15XDu6vh3DpJALBlxYojkjJr2xe t2Xn3n27t33Ytqh8SqJKyATYoFdy6AErY6N8KEyFIbdoTnXD0ta2Neve3/BR55aPP/54y+ZNHR++ 9+7qFS2LaytLp6br+HRf5JL9r8AbchjzphuaSIc6GGCw5OVkGeLVIn9bAw48cWHJAeJwnSErJy83 Oz05WgqygGD0EpDOcPbA+DJ40ogEQ05RRW1Ta1v76vYVLY01c4ryM/XaSEWwkMcVKA0r137UO2h1 9a+2wnj4coWnFxRMgTw6MS2/ZF7dktZVbW0r326qqyotmJyqjZDymdDuEb4Q4Yn4JWXkG6saWla0 r2lva11aN884FWpXYcFcqDYxGBzRjx0ckZg5fXbNoqXNTfVVpflp8WHiAFir9lW9v4Arwc0LS6DQ AzT6jJyCImP53PnV1TXV1fMrZ5cVT8+dNCFBxvIj+aCB/tWvEW+4mGBQwpKYfFl4jDYhIT42Qi5k UQbDdSwG7UfdvPHUgCBFZGx8QnxctCqYg4xOoA7B6O7igYaqWqyITkjNzCmYaZw1q7Rk5rScSYak ceFyMZ8TGMAOSlj249BdTG99VpSYSUC5gx7sy+AGq2MSDVl504uNZWXG4sL87HR9fJRCzGGQQCoC uG3uavKLTZqYlVdYUgZ9TVFh/uS0FG1kqIjtR8R6e3p6Y6CSSNSxyRMn5xUUTMvNMiTGKMWBVHsc vf58hcI60a4e3mgckUSh0RlME56C7kcl++JxKFjP0s5sqZcsItAu9/YhM7liqUKpVMjEPCbZx2bK K5izPNAEaoBAIlcoFfJgYaAfrN0F1yFQVQSKbXiKP0+iiBynS5kwMT09bWJqig5AnkQcFoNOZ7Jl k3YPXUvf/qBMr+LTcB4ub0LBxBBpAYIQVVRc4nhDGvS4YXxyfAw0J/BYNOirwL10oAtq8YvWJpn9 krSaMHkQl0nBo6EJAAjOEGgBQlmYRpuYkpKsi4tWSwUsKh6RIX/11QqrVDo5Ixe23C3a2vZKN/vf Cge6pzsKR/JjcXh8Po/N8vPFebvbIl45wBLIaDyFEQC58riAw4O2vpo0SWl6Y31pLK4oRBEWEa3R aKIi1AoAeQJaGyQqgxNeOJSP/vTwInA50Rfl6uQIq/z5kOgBfLFMGR4JPR4NGDLBQg6SlAmzVEaZ 1ACH+kWGq+QSAZtJhTo51I+cnIBEJJ7CZAuD5Up1mFohg/4LknndR2Ia/nCGCCpCkSKQAOWBBlgr iMLmiAtEsAgyrLZJhlxpVDIRSY4116GD1QGovPJFQWKJOEjI5wDIEx6LwfqQGPy4iqGHs+fbjOPh Pb4zgi6BVT9pzECuQCSWgMehVkinEM3JJ6NMqp/ADw/8eALAIhGLBAAtRCZgvT1gzswY5EcRKXQW m8vn87nwf5/1y/5ghqhoOsPayDgfHA6D9nJ3tZ3xaoLsALllLA6Hw2K8ETjbYKVl8FnQXIbF+5LB VAaySqC2AQiJ7mCTxRCmtAwR9rm8fl5WjDSQjHYDeaIwJwlR94VnQiYDmgRJMCPK1dnJfHvRwcHs h7P60Sgwy8mUrTvKpAYLFQSaVKk0KsX0KXbL5f2/NqTfQJFygwEP7m6DVdaHuSJq6S6uJs8RubEg uwtO73U3wZcAGQSDgtoGNJeBy6gMSdrGwacoFz5YkKdTISpOpi5sUvE2P47FoExcNGsmgtXPCzQ/ 4IcDrBlrsu6gT4KRJRg0uBAL/7KXzmD5PZolJdfJAkSwyVoxa+QPdR3B4TFldVvakLsbkkXrCOhD jJB0qxzZ0xs979RMTYkASGw380IQKQrCbkIalouz0zBG1PP8BnvAGCjrAupXpS7/hsySkjsYaPIi rqNspcY6WHAZCCNkrIlrDi36vfB0SerOW/cfPnr0YOCHi90bl83N00eFmMgJljRRwBkxw5vGmh63 AeWw4TekPGZUqhmubpPt8Qe3F093fa7nMEgI8iYWCLbTBLGzO748eea7k717NrxdUzQ5KUrKoeGH Ct0NY4w885ue72fNJrZvJu9rezFD+OhsuS5nVk3j0uamhZXFuRPiYfocyp5c3Nf22zHAR0cR6Xx5 jD4zt2D6tLysCbpoRVAgzXRM8jrmvz+zHPKGqDXaxKQkXVyUMpjnT/FB2TwAem2/A0MOeXFkBidI GqpSq8ApL4sG5Hxs0yx+AfsvHTnTxg0KZW5kc3RyZWFtDQplbmRvYmoNCjExIDAgb2JqDQo8PC9U eXBlL0ZvbnQvU3VidHlwZS9UcnVlVHlwZS9OYW1lL0YxL0Jhc2VGb250L0FCQ0RFRStDYWxpYnJp L0VuY29kaW5nL1dpbkFuc2lFbmNvZGluZy9Gb250RGVzY3JpcHRvciAxMiAwIFIvRmlyc3RDaGFy IDMyL0xhc3RDaGFyIDEyMi9XaWR0aHMgNTMxIDAgUj4+DQplbmRvYmoNCjEyIDAgb2JqDQo8PC9U eXBlL0ZvbnREZXNjcmlwdG9yL0ZvbnROYW1lL0FCQ0RFRStDYWxpYnJpL0ZsYWdzIDMyL0l0YWxp Y0FuZ2xlIDAvQXNjZW50IDc1MC9EZXNjZW50IC0yNTAvQ2FwSGVpZ2h0IDc1MC9BdmdXaWR0aCA1 MjEvTWF4V2lkdGggMTc0My9Gb250V2VpZ2h0IDQwMC9YSGVpZ2h0IDI1MC9TdGVtViA1Mi9Gb250 QkJveFsgLTUwMyAtMjUwIDEyNDAgNzUwXSAvRm9udEZpbGUyIDUyOSAwIFI+Pg0KZW5kb2JqDQox MyAwIG9iag0KPDwvVHlwZS9FeHRHU3RhdGUvQk0vTm9ybWFsL0NBIDE+Pg0KZW5kb2JqDQoxNCAw IG9iag0KPDwvVHlwZS9Gb250L1N1YnR5cGUvVHJ1ZVR5cGUvTmFtZS9GMi9CYXNlRm9udC9BQkNE RUUrQ2FsaWJyaSxCb2xkL0VuY29kaW5nL1dpbkFuc2lFbmNvZGluZy9Gb250RGVzY3JpcHRvciAx NSAwIFIvRmlyc3RDaGFyIDMyL0xhc3RDaGFyIDExNy9XaWR0aHMgNTM1IDAgUj4+DQplbmRvYmoN CjE1IDAgb2JqDQo8PC9UeXBlL0ZvbnREZXNjcmlwdG9yL0ZvbnROYW1lL0FCQ0RFRStDYWxpYnJp LEJvbGQvRmxhZ3MgMzIvSXRhbGljQW5nbGUgMC9Bc2NlbnQgNzUwL0Rlc2NlbnQgLTI1MC9DYXBI ZWlnaHQgNzUwL0F2Z1dpZHRoIDUzNi9NYXhXaWR0aCAxNzU5L0ZvbnRXZWlnaHQgNzAwL1hIZWln aHQgMjUwL1N0ZW1WIDUzL0ZvbnRCQm94WyAtNTE5IC0yNTAgMTI0MCA3NTBdIC9Gb250RmlsZTIg NTMzIDAgUj4+DQplbmRvYmoNCjE2IDAgb2JqDQo8PC9UeXBlL1BhZ2UvUGFyZW50IDIgMCBSL1Jl c291cmNlczw8L1hPYmplY3Q8PC9JbWFnZTE4IDE4IDAgUj4+L1BhdHRlcm48PC9QMjEgMjEgMCBS Pj4vRm9udDw8L0YyIDE0IDAgUj4+L1Byb2NTZXRbL1BERi9UZXh0L0ltYWdlQi9JbWFnZUMvSW1h Z2VJXSA+Pi9NZWRpYUJveFsgMCAwIDcyMCA1NDBdIC9Db250ZW50cyAxNyAwIFIvR3JvdXA8PC9U eXBlL0dyb3VwL1MvVHJhbnNwYXJlbmN5L0NTL0RldmljZVJHQj4+L1RhYnMvUy9TdHJ1Y3RQYXJl bnRzIDE+Pg0KZW5kb2JqDQoxNyAwIG9iag0KPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0xlbmd0aCAy ODg+Pg0Kc3RyZWFtDQp4nH2QzWrDMBCE7wK9wxztQORdSZZlCDnkr6RQSCHQQughGCVQiEMd9/0r B7dN26QnHXZmPs0gW2E0yh6myxloPMZkNsWbFARSRMRaU4FCE3JLaIIUTwPUUjD2Xxoix2R/iHYD KR6lwPxhClwA+Bsw7L156Yqe5Q3zNZY2qiwRaXCFYiqRl7kihlbOOUZ1kCJbHrb7wB6zI66B9Z9m 2lq2V2jZatu2oalRnWKAZpyqujMxs/L52eBZOXL/FjU9b7KOiQsN41TpsN51y3VFGC7+wnqwjW+8 HPpNGXdSbJLnUKcvWN9LMY8JXcqnj9krX1z6NgluaXWh9C/tqjm+pkOdhKpFOvSJVRaLsG3fm9Qk 4XQjyRqjcnebeh7gA83kdvkNCmVuZHN0cmVhbQ0KZW5kb2JqDQoxOCAwIG9iag0KPDwvVHlwZS9Y T2JqZWN0L1N1YnR5cGUvSW1hZ2UvV2lkdGggMTY1L0hlaWdodCA2Ny9Db2xvclNwYWNlL0Rldmlj ZVJHQi9CaXRzUGVyQ29tcG9uZW50IDgvSW50ZXJwb2xhdGUgZmFsc2UvU01hc2sgMTkgMCBSL0Zp bHRlci9GbGF0ZURlY29kZS9MZW5ndGggOTkxNz4+DQpzdHJlYW0NCnic7V0FXFTZ91+7115zEUTE 7m4RRBEMOqS7u7u7u2YYhqFbGlQwMUDsFjBQEVCxA/h/Z56OCIOLu8bvv+v5nM/93Lnv3HPj3Hvi vfve/PbbL/gFv+AX/COYN3fewgWLlyxeMnr06J/dl1/wLaFv376bNm2ys7PPyMisrqp+9+7d27fv nrS8u3fncesT5N+i5N69hkMVh4KCgiUlJSdPnvyzu/wLvhoGDBggJCSUnpb+8uWr9+/fQ6bPn7+4 f//B5ctXjh87npWZGxNNzttXeOrU6atXrj548PDFixfv6ADK92fPnjczM/8l9/8XMHDgQH09/aZH zW1t7W/evG1ufnz1yvVDFUewuykUSkhIqLu7u62trZmZmb29vbe3d2RkZCItMTc399ixyuvXbz5+ /BS13r9va3vfnpqSxsnJ+bMH9At6hL179968cavtfcebN+8guDt37l69evXMmTPHjh0rLCxMSUmJ iYnx8/NzcnKysbFxdXUNDAyMjY1FeUFBQUVFxenTp7H9oQSgCiDx9raO9+/eh4aGTpgw4WeP7Bd8 Bps381RVnXn/vv3tm3fPn718/PhJS8vj5ubm+/fv37x5E3I8w4DS0tLMTPo2h5SR0mi04uLi48eP nz9/vrq6+uzZs7du3WpsbHz27Bk0e3t7BwH46ejoOHjw4J89yl9ABwszq7dv2l6/ftv69NnjlifP nz2HD9be3g6LDNmdP39h//79AQEBenp6srKyu3bt4uPjW79+PQ8Pz44dO8TExBQVFU1MTOLj4w8f PlxXV//06dNXr161tbV1dIb2jlOnTv35558/e6z/acCOo1KTn7W+fPLk2f37Dx81Pnr+/DmE8+bN m7t372LDYi+TyeTg4GBsT0NDQ3l5+T179mzdupWff9v27QI7d+6UkJBQU1ODuF1cXIKCgkBcVlYG hYDd/Zm02zog/3t3G1avXv2zB/0fhSlTph6qON7S0vrwQeOtm7XQ29jOEPft27ehvSHo9PT05ORk SDAsNNzK0k5OVlFSUlpSQhJ7XFlZGZsatl5aeq+MjJySoqqLi0dsLAnqPTs7u6ioCOa+oaGBkDV2 Ot1rf98GY/HqxRt5OYWfPfT/HMzinl1z5lLjw6a62tuXLl2ur6cr4Tt37kDQiQyAA5aRkREUGKKh oQP5qqura2trI4Wg5eTkUIKdjn2tpaWlr6+P3Q1Vr6CgYGRompSUAoNeUlKCtLKyEuYAoRzU+8sX L1+/htp4+/pVm52N48+egP8QTPhjwtEjp27X37148TJM6pUrV7Cjq6qq0tLSoqOj4+LisEkjwiPk ZOUgXIh19+7dmzdvhh5eyYDlDFixYgXxE+VbtmwBDYgheiwJTU3NnJyc/Px8pFlZWXDkoDdaWloa Gx81N7e0tr543PJSWVH9Z0/DfwKGDBmanrbv+vVb1dU1iJ5goCEOeFmImGB8w8LCIiOioaWxf+GG QY4Q66JFi2bPnj19+vSpU6eOHz++MzeUcHBwcHNzL1y4cNmyZaBHXVh5JSUlHR0dyBorh27QS8ua mprgD9TV1T24/5ChVR5u3yb0sybhvwNWVo7V1ecO7D+YlJSUm5uLPZiVmWVmZmZlZeXg4GBkaAZ/ W0hIaN26dQsWLODi4poyZUrvmUPuhNCh8KH8xcXFY6LpoTocOeiNixcvnjx58ujRY1hgVadrigsr JkyY+P1G+gv4tmwvKjqQn1/o6elpampqbGwMm7uVAYiw1qyBkNdBb2/cuHHt2rVQ1EsZsGTJEqR9 +/btTRPDhg2D0KETREVFVVVVUVFGRkZERARLCD/d3d3t7e3t7Oy9vX0c7JzUVLWWfISlnwNKoDe+ 94T8i2H48BGR4eTy8gp7e4eg0NArtbUdXwN2jl/hX7GxsUHoc+fOpVKpX9UK4Hp9/bX6+rScnAkT f+39vw9KClpFhaVpaekQN7YzNTHxel3t1Vs3z125XH3+3OlzZ6vOnUWmO166fg1SgIO9es2a3jfH zs5+5swZVLxy80Z3nmjrNAORRwcu37iOzlyvrwXxpRvXYFwGDBjw/abiXw+TJk7x9QkpKS7z9/eH MdXQ0IBRPnr8+P1HjxoaG+vu3r1eW3vt1q0bdXUsEf40XXA3bowdO7Y3zfHz8zc3N6PKrdu3wbkL N6ItpLh6u6EBfXjQ1HS/sfFOQ0NNTc22bdu+92z860Fkj0xUZGx4eISvr29gYKCrqyss46xZs27W 1ja2ND998RzY/PRJ05PHLa1PgY+ftRJI/EQ5oWkRW/1lW/D6COKHzU1gDrYEQ4IVsxW02PryBcrx 88GjRvjthYWF0AnffzL+5TBu7HgLc4eM9ExI2dvbGxtcS0trzZo1EydOxFZ62PTocevTl2/ftNHv bbNA+p2xjo637R9ug+vq6vbUEPw0rAeC7NnLF6/fvyPqMPkweb5te//izatWLLPnz5pbWhCgYR0O HTr0R07LvxXWr9vi6eEbGRnt7OwMcYeFhiFW4uHhWbZkOUwkDOWTJ0/ed3mo0TO8efMGbnP3VhCb X79+vfcuWVt7++vXrxsbGy9fvoxo/cdPy78S+vTpoyivHhNDtrW1c3JyQghsaGiIaGv37j3wnDk5 ORFhxcXFPXv2rJ35zPKv4OrVq7///nvnVhBqgcNXyLqt7cWLFw0NDYcOHVq0aNGUyWx/Tp32s6bo 3wSTJk3V0TaKiSE5ODhCmQcEBGBfb9q0afs2QcwzLPjgwYNHjhxZXl6O+e+9xBMTEwn+WC2I4nsv 6A6Gkw99AjeNQqGMGzdu61Z+wR07eXi2d+k5bA0CcD4+PgTsagxAZu3atXPmzPlhszdjxgzmPQFk EF3+sKb/HixdvMrYyNzPL8DR0RHK3M3NDVsbgdi0aexQv/C0CYvJxcUFVQzt2nuJ6+jojB8/fv/+ /b0XNJjDFjx69Ki2ttbIyGjMmDHoCUPb8HLNmItgQUpKKiIi4tSpUyD7Miv0NiEhAX348n2/ZcuW neoEycnJEaxASOjTHd3Ro0fr6emVlZVhTXZv9+XLlyUlJQoKCr287/SDQVBAxMaafiOL0OSYH2xt aWmZSZMmsbGxDR8+nEkJgw5BvH37tpeyg0TgYn2VrDFXDx48qKqqgoZBixISEvAVkUevzp0713tW XQAWYd26dSyHr62t3ZuOgQzE8+fPJ5PJ6GRvGkWH/9cO48Fw75VRcXZyc2RocoRgmF6Ie4eAEDYm FGkXZ1hfX//x48dQtn975nsCGGsY9zt37sB1xzIbOxaNj4OGtLOzYzm9EAGqYO3RH56+fImlhV59 WfNER0cPGTKkywxAA/Sme/z8/Igf/1KldIGbN2+OGjXqx4nzr2DEiJGKChq+PvTzhO7u7jDcmxkw bRoH7DXipkGDBnWpEhUV1dra2vX0ESto72hva/8LMhC8fvMa2MKIttAHosVpbNMg64sXLxJkb96+ AQ3St/ST7PSjUzArhM6H337p0qUbN25ALUDu7XSRtxNNv297D2JURIbgc+zYsS4Sv3XrFtENAumH LD7iu/fv0CJREXq+++iYbLuXo90OxprExP44cf4VwOPdK6Pk5uYBkw2HCrEtZA2l3a9fP8gaURgy XapAvRcUFtxtuPeouYnA5sctnbGppbkRxYwMcZUgw8/O+fsPH9y5d7e2vu5WXe3Va1cvXrooJiYG /v3790cKJUNsajRUf+c2KO/db0CVh48aCYRwCwsLBQQECHODTcTLywuhMBsiuvGg8WHDg/uoDiTE 4efvzxzL1D//BA1RhUDmoIBEdRQ+fvoEKRpFZ27fvQNW4EmMhVmRQGa76Crq3r3fcO3atR8oz78A zunccrIqnp5ekDUibggdhlJUlD7tAwcO7MnZmDxlyv6KinOXL1efP19z8eLZS5e64JkLF3AJSGSQ EmRIiSrV585VVlUdPXGi/MiR0oMHk1NTuWfN+o1hXJAuWLgQsm599epEVdWJ6urTNTVELQLPMlJa cvKQj4aGqAWYM3fu+StXiA581ui5cyerq0+dOVPf0FB19uykjy818G7d+rC5GTREb5nIrA4E/QlG Vw8eOlR84ACFRsvIycHPM+fPE8wJYiYyx4uKVefOXbx6FQ7n95ZjL2EW93x5ORUfb1/I2s/PD+Yb e0RBQZG4ypzG7rBy1aoDFYfKjxw9dOz44eOV3RHlTOxcWH7kGDIHDx8pKtufW1iUnZdv5+g0YsQI JmcE7NDqTU+flVUcOnDocMVROj1SVER6pPIEsPrchenTp7PsYV5hEVoBJbNpIkX1/RWHDqLDxys3 bNpEEGvr6ja2PMWlzr3tgqXlFQUlpek5uTsEhZiezJKly9C3LqNjjhGtE3jkxMmTVWcm/s88uZs7 Z9HevUoQt7+/f1BQEAIxhLFqar06OCQuJV10oKKg7EB+6f5eYl5JWV5xKdLcopLUzOyk9ExRCcku bPWMjF91dOQUFIOGXqW4dF9RKVKien7J/vPXbmbnF/XUq5PnLhSUHkCVzghWOYXFyBQdKC8pP8TD y0sQewcEHT1djfIeu1pcmpazL4pM4Zwxg6jCXGDW9g5o6EsjLSkDAZrr7h/+LJgze5HsXiVPD69g BmB3I87V0NDoZXX/sIjU3Lzk7NzeY1JWDi0zOyE9MySaNG/hoi4MJ0+devDEafBMzMgGMdJErIqs HKIi8mn78i/cqm9sbDzNgFOfA0rutDyNT03vjpTk1LjkVGRScvZt2ESP8gYMHEhNzwRDsGXZT5Sj A5TUtE08W7qPXUxK+gtjJ7qdkJEVTo7/ZyL6ljBzxjwZaQV3N4+wsLDw8HAfHx/4SCoqqn9ZESs2 Pj6++V0HJTWDlJTaeyQnp5GS0uxcPMawelQquVfuSPX56ISk2MSUmIRkpMyKRAkyMbRkcnJ6UnZe ekFxdvH+nNIDSIEZhSXU9OwoamIYOT4iLqELhsdRQ2LiwkjxYL5k+Qq0xcE5A3xiaCnA7v1EIVqM piX7h0exNGoiUtKZRaUsx0jvKr16alR8oopWjw+MfhjAByOGwME+U0aa7pkjvEJYig0OX1deXv7L 1Tk5Oc+cOfOkrYOUnB5JSYyMT+olRlGTSckZSAf18IqQuZ0DJTULPMPjErpypiRGUGhIQ8nU4Bhy cExcKCkeZBEM4jASNYxMRSYklhISQ8GlzohC0AdGxgZExISSKDNm0m918mzlLzpSyaIhRlv08vgk 8FTXNWDZVXU9g7SCEtbDZ3QViKZXrmF9e+dHAsIrIrydNHGqmKiMtbUtiUSKi4sjk8mCDBg6dFhP dXfs2PHkyZPTV+pISRnRCanA2MS0XiIpKb2g/FjL+w5lTR2WzCMpSaTEdFDG0FiwRVsoD4+jBUaS fEMj/cKiAyJIgZHkgEiyX3g0EJnAbhgURUdQ+oZEegWFh8YmEC69mo5+XvnxaGpK97ZQwhhXOtri 3baDZVd9giITMvb11E+kUQkpYM5Sif1gQGxLhKvDh/8uKrxXV0cfgqZSqampqUJCQrt27eLh4WVZ 0cHBAaFr2fFqckomNWMfgQmZeR9xX6fCzuWfMCmn8O7Tt/da367dsKkL88GDBydmFRAMWXKgZeUl ZRcqamhPY+dg45g+7WsRtdjZ2dg/HGgMiCJnFB34vP+fDQTSjE/LZp/O4kbo1D/ZknOLaFn5LIdJ dD4uLds3LOpbiu0fwOjRo0eOHNnntz67hCTl5ZQocZTExMS0tDRZWdk9e/aYmJh3oUfwWFhYCFln FBygpGRjKpJzChMz8zH/yCCFpPATKTNPXOqM9EuZ+bmlh+lr5ljVpClTOzcxbPhwsKWkZhN1mdyY fNLySjKLyncKi32D4Y8Zk5JbnJJbRPDvgkS7tIy8KEoKy5sPm3i3Hj17BWTEoLpWz8xPzilKSN+n oWv4z7v6TQDiJt643LCeX0JcJjw8gkajJSUlYf8KCwubmX0m7qVLlyIWvv7gaSwtLYoKxyaTkppD Ts6MS8lCJi4lGxkij0JcZfwkCuHZ5jARP0GATHZJBSTuGRA2cOCnm7RwJ0JiYY4TYxLSCDKC7UfM Tt1XChSRkPmNVcQ9Z86cJT0D8YCSa+ZMgnjZytW5ZUeZXeqMzM7H0NINTK1Yzp6Shvb+yjNED3uo no3q6zaxcOl/CowYMYKdnX3o0KGzuRdKiMu6urhB3MnJydjj4uLi0tLSM2fOIiiVlZVfvnyZX348 IAKmMC4klhpKotHT2IQwciLyyNCRRAuKpoCGIPtQyKBh4gdievWE9MIDj151yKtqdu6Vsra+V3CE b1gMmIAb0daHiiQaKSmr5sZ9Swe37sOBe/nlm/MpeSXgs3ELH0EvIilTUHEiOIZK9OczjIW/Rw2K pvpHkPi2C7KcPUdPfwi0p+ooD4yKC4qO+2PipG8qtL8PsN0cHBxsbGzjxk4QF5PX1NROSkpOSUnJ ycnB1ElISGhp6QwcODAyMvJ5R0cIKcnZJ8TFL8w9MNIjKMo9MAKpR3AUM49yXAWNo1ego1eQk3cw foLgEyUTGcREmlV2rLTy3IrV65m9mjad09bN197D38Ez0NE7yMkn2NmX3q6bf7hbQAS4pRXS1YK/ vz92K+gxBH5+/n379r3r6IiiZYKAyRz0rv5hrv7hLn6h6A8YahlZMB8BaJtYBkRTUQ7+LNAnxMk7 yMU3lGnoOwOMjk9orKtfGNG97ohycLZ0ZLEsfyJMmTJlwYIFw4YNExQQl5aSRSyWwQBPT8+NGzcu XLjwxIkTpdXXbT0CLZy9rd38kLFxDwAi0zmP1NLZx9zRy8zR08TO3dTewwzo6GXt5k9cJeiZSFQE 2nkHF5+8FBBDmzDp0wmEhctWGNq4mNi5mdq7mzmAjycQzM2dvMzpPP1iUwtedNq2yFOyyxx9QgnO IABaufpZufhauvhYOHmZ2HsY27nJa+qP+HieCp4qLlk6e3du4jN08DB3wFg8WEbcM2fPcwmIMnXw MO2pLlJ7z13i/1vn68aOHUu8zbdwwQppKQVLC6vMzEyodGdnZ14+vpvNzUHUfbqWrrqWLvrW7oa2 Xvo2HgZAW086MvL0Qmt3HQsXLTMnLVNHNSNbZT2LWfMWrdm0VcvUSc/KhSAjKJn4obqtJ+qauwTl nbiuZmgzaPCHO41cXFwzZs1V0DZRNbRWN7bTNLXXMnXQJNDEQcvMEf0hGBJMiIyelRvKdcyddSyc tc2dNE0dNUzswVbNwEZO02TRsjWdBTdxyp8Yl6aJPR2ZzDuhhomDupHdTnE5lvO2lmebjqWzxpeq 22sY281bvOJHSLHXMGrUqLlz565evXrixMnSkspyckohISG6urpWbm6H6t4auYQo6Fkr6NsoGzko GzsoGdkjVTF2REovYRQqGtjK61nL6Vru1TKX0TDdLas5fiJ9n/YfMEBIWlVO1woEnesykShEBqmh c1BsYRXfbmlUFBeX3LZtG5yKYcN/X76eT0RBW0LFUFLNWFrdRFrDRFrTVEbTTFbbAr1SMrQjkN4H XStZdEDTVErdRFLNSELFQExJT0JZn3en5HTueX379e8y8NkLV0ipGYmrGEj0iPrgM3/5WpbzxrdL SkLV8IvVDfZqmo0a+8f3luDXApzzDRs2QKWvXbOFf6vg4iXLfRPzg7NO7dVzEFM1ldCwkNKyktK0 ktS0pGe0rJF+yGtaiaubg0ZUxVhY0WC3vN4GAbEhQz+ddBo7YYqIspGYiomkhuWnWnQOTPxQiNTA NcI+PGvWopUCAgJSUlKWlpYaGhrLly8fMHDQNK65C1ZsWrddbJu4ipCMpqCMppCM1i5Znd1yersV 9JDu3Kuzc682cUlASmM13y7uRSsnTJnWf+BAZme66OTxk/6cxjVvGtecnnEuO/f8oSNGspw0Nq45 bDPo2FN1dq65HNwLvpPI/gmMHz+eeAN39Kgx07iXxJRftwxOFVU3E1YxEVUzF9e0/IhWSMU06Ii8 mLqFiKrpHmVjYWWjnfL6QvK6C1dt6R6fzl2+YY+SkaiaGVGRUZcFimlYgKd1eJaGXeD4yWySkpLU eCqFQtHR0VmxYuV0dq5+fT8Ea4OHDBs5Zvwkdi5itpk4ZTo3ykeO6bqb+jDgR8zj/x+YNm3a/Pnz t4pIZZx/ruMaKaZuLq5hIYndp2MjpWPLQJuPSP+JSyCAEEVVTYWVjXcq6HFwz2fJGW4wn5gyGEpo Wn2sbvM52jJ5yho6+aQcxULatUckLi4uKSlJSUlJVFhCUEBk7tx5gHHjxvXmSWJvRIyIYxgDhn8E lse0etlWd+hCpqamto8Bzm5uP/1hKAJwJ3//shuvDFyCFY0clU2dVcxckSqZOCHtjChRNHZUMLST N7CV1bOW0bbYI689dsKXQstxEyfL6tnIG9ihYhdundkSjRq5hVPLLwvJqOro6mpqaiopqioraW/c wAfvYtasWV3OhPQ0t72BrKys5m5w586dvLy8TR9PPnxDoCQmnr18+cKVKwUlJd9D22zevBmxs4KC AuzylykRix06dKj04gNr7whTlwBjR19DO7rnrG/rYYCMnZfhRzQgym089WzctS1cNM2chGVUhg4b /mX+gDWbt+pauxnYMlz6Tgw/Y2vrgbyJS0BoavG+Uzc38gutWrlaUVFDRloN8w9xT548uctrKX8b oHMOHz36sKXpYXNTc+tTYNPTJw9amhsaHxKRnZeX1zdpiIBJkybdbrhXf/fO7du3TU1NvyFnAqCp wBndfvys1czM7AuUWAwNDQ0Ha255hsUhkHT0DbP3DrH1DLLzDLbzCka+C6IQlxBNW7r6bhUS7tu3 66lFltC3Xz81A4ueeH7g7Enn7OAd6hFKrrz6IP/IuVlzF2zjF9nCwyskJITwocsnX/4JIPxsbGx8 8+5tS0vLhQsXKisrT548eevWrdbW1hev6IchMScwHN+qOVgKfn5+Pj4+pF/1YZNeAmwxcQ783bt3 cLl7IhOR3JucXxZBTQmOTQiMoviFx/qERnuHRHmHRvv0gLjkGRTpGhC6bOVXvLYPmMo2zSMowis0 qifOzKbRjeBYWkxSVgiZNnrMWGxt+OcIH77haW34pR2MVx5qa2u5ubnBefTo0VOnTvXz80Nhe3v7 06dPt27dCkosMxT6+/sTu1JQUDAnJ0dfX5/Jqn///liNJBIJGvLgwYMgXrhwYZfmwMSJAYqKil0u wWWCJikrKzt8+HBMTExPnxCEZjMyMsrOzj5x4kR+fr6NjQ3zQ/FaWlooIZTS69evw8PD0VtRUdHO 1QcPGaJnYk5JSY+MTwgjUYLpz4Kj/MIiCfQP7xEDIqJdvHw4ODnRMfT/q8yc4B7hL3AGMlsPioyJ iKPGp2W6+fhhQrB6v+1JTmtr6w7Gqz2QUWdLinXV1taGnYJdT4jb3NycmEloAMSGHYzPtzLfRYVu RPmHs+UfX2fAgjExMencHPGWCtiWlJQwC+EW+vr6Mj4M206kHYwXK1RVPztHhOWkrq5OvJrUzgCi lbNnzyKeAsG1a9c6d4B4NcPe3r7LkAcPHswxnZODYzo7/UEwxzR2BnJ8RHZ24tHwpxIGzpg5c+XK lQiUbG1tIyMjU1NTDxw40J05S0DPiYa6s+2O6BUH54yFixdzTJ/+DdU4AaWlpfRbry9eYMJ/6xSS 79ixg9gjdXV1MLgogedGTCZd+b95g2lHhvj+j6GhIUGMEmgJWE8sEuJ1Ksw8sVoIoNFoKISl8PHx IUqwN2E+IJpHjx7dvHmT+JYgWBFkbGxszLqZmZkofP78+b1799AKnMmmpiYQ379/X1xcHD42PEzi +7SojkvoRn19PbRQL6cCHKA6oJFWrVo1k4ubj1dQSFBYSGiXkpIyNgU6TKVSy8vLoVUQVkC9IIUy gR47frwSfQPN2rWf3YnC2sCsYshhYWHQSPAepaWlJSQk4HhbWVrZ2dk5ODjAwWAcqNjCs5lvyxaB OXMWYlPPnj0blu4b2lACwPBmbW07QyjCwsLM8okTJxYXF9ffuXOrrq6oiH7MFZ7hxStXHjQ2NrW0 NDY11THKyWQyLkGBM953aMD8R0VFrVu3Dh3W09Orq6+/09DwqLk5NzeXWEUIu6prapofP8ZiwNiJ ttzc3VH93oMH2O/YpIgBoSdv373b8uTJ85cvEX7+xliE1ra2RCtXr17FFMEur1ixIiQkpKamhng/ ceTIkVJSUrX19U9aWxsePPDw8ICgMaiv+k8QLGx0HksdWmvbtu1aGqZ2Ni52tk5ubh6QLHwbDPzh w4dY6tev34DRwdCwCwoKCgoLCzFjpQwoY8D+/fuRohCrIiUlBXMVHR2dlpYGAlQ8fvw4lENUVLSF uYWerqGerrGOlikfrwAvLy+MxYwZM77Hd86XLl1aWVV1ta4O4g4ICMA0QktDZBDH/sOHczCMsrJV jA8KLV2+/Njp04cqKyuOHcsvKUEh8TQNejg1K6usogKoqfPZESx9I6PDlZVHTpw4eOwYYYBmzZlz 9NSp49XVldXVXIx3gZevXEm3DtXVaKjz65bW9vYnz549WVNjaWuLn9M5OesaGkrLy9GrVZ0+cIQ+ /Nlp+0+cNAnM0c+jJ09y/d13jeEaYVqgLuCWYDNqqBuFBsWFBMdERsZkZmZdv3Ydzgzdj33xAjoE cq+trTt16hR2PdYDIXdsBOLDpwBCG2CdQB1BC2GpQO1gX6A8NDTMxcXNxcnDxcnXxNhRcMcuERER LHVE2YQ6/eawYTNPacXRtJy84oojtQ1N7zo6Lt6sz8grpKakx8TTIkiULfwfvvOzR1y8vPJUajb9 CDQP3yflvGETz9krN5Myc2MoiSMZDiQz/F+zbn1WQXH6voKk9CziEv+OHZU151ESFk0ayLiNY2Jp ffLsxSNVNZgQuHbYrcSR70Mnq1Nz8lKz81U16a+aSsnIV569kJyZ4/wxKmR5k2ELH//pC1cz84vj aMlfOF74lwAHadGiRQICAtC68BZkpOUd7HyjIhJiouLJpPiy0v31dfXwdl4zvlr7nv5vE22ELwFX ATsFNgUpxErQvGQAMjBDMFhVVVVxcRQ/X38f70Bfn1BPtzBlJW1xcQlo/o0bN34/WQOEJaRzSstD YylBMeSgaHJAVGxgRKxfWJR3ULiGniFbp+/8qGjqxCalhZLitQ0/c7209I1y9leQk9OVNLW6MBfc I0JKSguJjbN2/vCkW1PfOCEzN5KapKrJOH7cp4+jp28UNTkqITkmMQ3lEfQzq4nhZARHJHQD6ap1 9Kf/Dh4+tKw8ckrGNsGdXxiOqo5eYk5+dEKyfrfDZl8LiE0QRGD+ZWVlDQwMYFMU5FV8vKJIMcmx 0dR4Ci0zA6HByfr625BjT68AEx+vfvXqFaR//vx57PuYmNiQ4LDAgLDgwKjAAJKutrmEhKS8vDz2 NYwgFxfXd/2vCitn9+iE1FBygrmDi/heBQlZBVEp2S38At2PMVg5ucUkpkdQkjZs/uyUppmdEzhk Fh/UNPzsnsmAAQPSi/aHxdHCKTTebQIo6de/v3tAKCUtB3x4ttKVxoCBA72CI6JpaZS0bEV1rd2i ErvEJIUlZHaJSGwVEMJq2SkiPuL3kWDlFx4dl5qdkJW3Y9eensaCze7s7U9KyaSk5wjs7JHsqwDz jwiFn59fRUUFQpeTk9PU0A/yJ8fFpsWRkhOoqbSElIyM7MOHj545U1N7qxaWHYoaniRcxBs3bly6 dPnIkSP5eQVkEiU6KjYiIjYiPC4ynBoZRjM3dRITEyc+pQsFDmXCycn5zf3wzgAFS0rOIKdkxiSl L1/N+uEmAcOHj4iippBTs8gpWfMXLu58SdfEHBvzYv3Dx8+eYWaIQgTviFOo6fuiaSkBUaRBg+in 6EePGQsOybmFkNrsefTHCn379fMMDEXh4ZpL6z9/M6VzsIwoxt0/mJSU8eh1x4HKk0wdDhfa09OT eSBn6LBhobHUrOKDNTfuYFfSS4YO/eefjIApnzNnDnx1OIQaGhpwsJWVlZWUVMxNrYMDomnUnIT4 zMSEDFpCWgI1BdJPpGENYCUkUeOT4uJoZFICmUQjxSTGkVIjwxPtbD3UVLTgUmLlwEXfsmXLkiVL oMC/xx2nLjBn/sLwuBSvYKjuyD8Yt/p7uus+c/bc4Oh4b1AGR4374zNts2jJcveAcO+Q6FcdHTBM 8PdgghFPBccmeAVHOnr4oxWCkp2DM4qaDj7+4WTmoTUlDV3PwIhD1Vdh11xdXRFoI5y5dOkSqu8W lezzUVg7dgl7BkUERFGgIeHTOjs7IyaC3YyhZShr6vXvT/9i5Nhxf3iFRIfE0l4yvhThF07SMbHs 5a3OvwRY83nz5q1ZswbePhQ7Ak/IXU1NTU5O3szEwsneNSggMoGSkULLSUnKSUygI1ZCUkJOaDDZ 083f2tJeXVVTRkYGSwWKAn4gHx8fdgcCrh/2FyS823eaOrgbWTsraxl/+VHFRt7toDS2cVHSNup+ dY+knIGVo5m9u7VbgL03/favpZO3iZ2rlrEVG8enQ+mr1m8OoaRbOvtomVgTL60DJkycjJ+GVs5m 9p5Wrr7Wrn7mTl5GNi5GNq7bdokyezVs+Ah1Q0tDGxdzR0/G7eUQO48gC2cfS1c/sb1KBLffR442 sXNDXWM7dzMnT7AS2PMNjmR3Bg4ODoRpCAA3bNgAucPm6urqQvTw4eHUKSoqyjJAU0MTYSaEiy2M taHOAPoDTVFRSBlxFnY0NEbnWwo/ADZu271LSmmntMry9axfmmDCer6doNwlo7p8HQvKQUOGLl65 YaeUsoymiZyWuZyOhaC44tI1m4cOH9GZbKeUirKRvYKe1eYdIp3Lx0+cumHrTjEFbSlVQxl1YzFF nc0CwuxcXb8WNWb8hHW8gqKKOnsZrUipG28RFJsx59Nd8T59+i5fzyMspympaiCpqr9DXGH8hO/1 Z3yws9jsy5Ytw37n4eGBnseGhfSxc6HwiW9eQfqQOES8fft2GBeYAxhoSBlr5qe88tz7h499emEB +/brP2LU2NHjJw4bMarLpT+msG8VV7GJyNqjZLxbyfjPGSw+/DV4yLBR4yaMGvvHwEFfegI+cPCQ 0QyyQUNYx1moPvz30YP/QRT2VcDOzs7NzY0tjw2LXQ+ZrvwI+Al1vXjxYiyMmTNndvmO00+B3j8i /zJl90vMEsy/lLalkUeUlJalmLqJgKRq/wEDv1y9913qDdmPh8mTJ3+/2Pl/HMb9MdHEyUfPxk3b wlFBy3jSr489/qthzLjxu8QkBHeLbOTh+194/fMX/Bfg/wDVyuZhDQplbmRzdHJlYW0NCmVuZG9i ag0KMTkgMCBvYmoNCjw8L1R5cGUvWE9iamVjdC9TdWJ0eXBlL0ltYWdlL1dpZHRoIDE2NS9IZWln aHQgNjcvQ29sb3JTcGFjZS9EZXZpY2VHcmF5L01hdHRlWyAwIDAgMF0gL0JpdHNQZXJDb21wb25l bnQgOC9JbnRlcnBvbGF0ZSBmYWxzZS9GaWx0ZXIvRmxhdGVEZWNvZGUvTGVuZ3RoIDM4MTQ+Pg0K c3RyZWFtDQp4nMVaaVhTVxrORlYggZBAWBJC2AnIEiCAgKCyJ4AKWKjFBRRFXOqCKCrbqKh1F53i 0pkKHcfRap1agWpbatW2KOoDIiBQFARErIiAQJY5FxK52ViepwPvD57cs9zznu985zvv+S4IxDgw 51jZWFmwjMdrNz0wMLZ08Z0bEhYeIYgIDw2Z4+PINqJONykF6DGsPGaHCyAI12/e9LEQ+hUW4Mqm k6ebmhwUIzt/wHBeztcPWqUj6Gm4eSxJKAjx4tB0p5veMOhWfhGCBfvvi6RKePHvZGGoh7nB9NPU Z/PDBDHnepUZjqAiTRjsZqZHnF6ONLu5gqgTXeopAoh/SBLOtqGSppGirrFLWGRei0aKEAauLAxx oE0fSzLTJyL60pgUITxLDZthqD1NHHXN/YXx98flCPZ6lsDdaHpY6jD9hamtCmwkoqH+dz09fUND Igm8XHQqyp0+HStOMpkpTO+BM+ltr/rh4tnD+w4Uni+p+KOrXwyrvBrlajANe5zmLkjthlFsqyjO SgwP8PF09/D2mxuz9viN+i6YOYsiHfTwU82RbBOW2P6Bgrj99uHEAFc7C1MaVGnKtpnBj955vfb1 KMvjIRxd3NRyJDEDF1R8INB3//SqYD6XoqOFHG1i4xGdV1bz4Rx6vy3CxkgPgEImoqeGJJUX9eUH jr1PbxSdKsjP373NnYKCTcTGa8XFx4PyVm+vnDq0Pz8/P2/DHBJS85v/OpDYISn9aoLN3Zna8PGt gg6+Vm30LBo+lf8fqO4LKtVwlErOOWI/NEIS7XPfqLZp2OyiMxUkiaygLHUcpdL+LWZyh0ORvYoG VBqIa/LmmuCnYrkpTjHV6klKX8zTH2GAoof9qlo9VJEXZqEzFRsHzwjYLg+BPco07s4kApZIrHly sxpDl26aaUKYEo8kWUX9KBu1/SdlrxOfstVCIElO+W9VOUrK13sYYqdkayN0uUtkBpSczCpW1ru9 a4wxer6XhtQ5w41gBh6JwlMMmWw2k66NGZcvhkih6FGImMmT1Ocfkg36bGVQ0hVlOn9E285/oI6i VFof6eQ2S7h6T+HVa9e+ObZj/mwemyxzUCTOxM1/lq+nmwuAsx2DgETrcrwFm3eB+Lslks+aZGzF M8JuygbdG8DipdyRKFH5/XCbeo7SwTNXqzthwqO7rmSDrykOGh9tvK3jZWfn02oIVZX5bIZ7SlmL LDyInn8dboIdlxkMBLOFMoU2FGNNprhl1CpRkajGeeV5wNB23JsKthLO4xd46Q8Ju2sUrnavMzla k7Ekc6lshRt8aESMgV/+S80UZLOpFo9RW/MRA43QiX4BL/v9kXKP3lWGkwgLBE6mrF+hNQmHxBqH /v3d2BzflezvHqv+5cd0ND1VIfL3qbaq9pmEiiLanpR1m0/XQiOQePPYS4Oq7xzFiy/S0l7BnkUd 936+3wG31BN/bcujY84TYCCRMmGOKAL3gqyb73BcRpFsl5drXk7Ro70xwmKYUw6U709NXH0M7smS LBb/pnJHsbIj55hOeIej8DO+lb3aEzHcC0122VSjiWN/WXqgezp89X7b4GdrYS84C98X//UQNCh0 k3RV3PilXaFIesRiwk6JxDp/L7ORu6wThuqzq0M9x66iZB47HE6g79LaqKDZwZ/8A06yPHS5gteK n5xIS1j5paKv7+FMfOdgHGQkxXy5EseaxF1VVTygRf2RBbZU6yPwhRO9fd0J0KVwbN6Oy1FY3Oe7 Q+3NndcrXEYHtzAnHtBRNvLl9sXJpoaz3qAQQOSvvbMzyFybOKtOTZ0iflp2UWFyX4Ya49EG8Qoa 5dUKxsR9Emkh3zihpOEzDUl0yFWjwKWSiq0+DDyKnDBm/BnGt2sfwR+7063AMaT3sUIAfhSlP2FD onEMeQhaoYdBQerW+yv1Iag1xRyMRVs7xnkjm86RdIVN8vQjOhKBNEp7Dy887zXx/AJGm5Iu63bJ FIdGYAwFFVINKPXEI5Bm2fCi/ue1j5Vx7+sVOxRc+jt/HTB561PwssEcm0mci3p0oexY7OBqa+E4 qZrTakOfWWKQ5vnwovbCjWlpaWvWbdySIceWVVHBJ+BtxPu44HDBet+FF75aaTKJY1GPxZPtElEw Xd/1sIYE6jC6lxuimZnwSP9sPc/W1s41cu+pMzKcPr7eebZCKH+zjgmcXTvqObywat7EXRKB0DF3 KZd13MsLL1VJQyugIVzPZC082vy5yZZsYB1ZAm90nitUCOWNH9HAPqYmKxzgX/tMJuWlzeYflHV8 mT1udPmBbxpfCS+oK0jcWqRgo+4052UKAaAsELikkpsM5dlOSlCa+MTIjwKVe5gKxMe9o86o0TSj 6CsOc9kODwCSzxyBS2LcrsNbda02ndQFjspbeEfjkD3Kivdd1uLcMdSkpKNoCZd/Hl70dgMLuCQh uB5e+GTB5L5dURwW7NIQ+sR1l28p33na9z7USHGw7fru+bY0LwVVXh8HuaRONFzeSf/jM8lcsVnI p/VSdRgo35m4VYXSsw9TUJjawJumn4uyE/hMbZLz51XPO2R4UXPUC7gkQjewtO6FvPD5gxSrSbkk AkHjr72izpTdF1fyrX3zXqmpGq5+dPt+zfP29o6O9tbaRyXFh7YkhriZU7AorNnc1Kw8gFyA7SmB ppAEJ1pFr8/OlSEjkUfVYbm62+lN2DFRrplP1JBo/Tyeq09khJ9Tf0gOle1NSV2TkQXGzM5cvzw2 2NuRTdeGhJQWMyItY9u2bRnrFoV4udgYESEmWmSWg6ubDE4cqrZtcWNT5UyN6WIkjmpioo+TaxCM cXKDKgdR1V6BpQ4aSeAkqT8mq3KCnSxsnVzAmC4z7C3N6GSCLDuA96p7PwCht/nzAAZRa9haSAyO SJKDiMdQojrBnTFS4ydVLU7Oha82M0au8UiCTboahTvwY8YsU+Kw3uDldKrh2HN2vgkZjSUMj0zA YVCjukv/k9FQVump3lZIw42gtiaCosmQ5AUgLt50GPZcpI7HaTX503ffbQykj9gaYxj2T9UFF/20 1ZWm/v0o1t9ARJCIhwPVULopzcqeZWBiZ66NQhKMnbz4dnQsEoEyXXWnruqYlw4Sa2DnyefKckpo Mofn425Jxmh7nJRAXznYBCijF/yzmj3Td31PPI9FH5kTnrNM9RtU5+m5ZhqsgHG9Bji2VNythYL+ 5Vlr7t67mnC67gJHmxX2xeO21spcF10kxmpX7R8VSywIeu7ZFS1tVftcdYCa03ZIvdH0srk80dr1 Wgf0kqojTCBN3CrVOtzg6ThhkK+rHYdtyrbiJZxSEcF9mfaaBAIhGNwcB/+1dsU+6DpXuvRX4HtA A1/39SkYUb3iH7118HwQS1/HMUxjHwwbSVLiRkAbhJaMrFl3vjw9XsEDFwWbFRduPah+/Liu8cWb frhNe7+LFAgE4RCiFmX+p16hcrCjbBFbk/infPInsPRmnuOSB9DNYSvwaEi1fLG0/EP/Yjs9KMPx LNYmCfJ3qFq8w5QmaJI3+G6/7Md1PthDBs7CZalAEaZt33u+skVRAg00Xt0uFAiEBbdfKh6Ebx8W LnbTlIRGmuYBl6xZ4zv3ELB/376jw0fWwKuDN6CpNzdCGdDOaKuNQKZXLZz3WCp9X//7C2CBX/zm AHtL/mxo7hVXpufUgyH7W+9n2ANHJdJY1rbDCIjNLn2q7o6oDElb6fZwZx1NSUYMF/rS2/bwt1po 6X7fWgp1ably4DhYwK7L+/dcAgppKHNWESj+djG4Xg09LP57KVB/TcuOg4aN53bln7mwKTwBEn/V R5f7GELzRmG0sCPg+KReqh5fBw0+/XeSGxMechSB8709Op/GnFTIMVuPJS4BPjh0LcnX/1MgB0X5 C8FeHDyaBtZ8sL25qRWYtTkHuHJvYayXV+AcV2shqBf9M9KWRlB6PcsltqCiQ21Od3TYnurCGC5D A0EIpNHkRd+9HMHyNmhooVMCuJp1ZbvoMxKaQITbuhps3q7MrbB0wb3D4KE5zZqsSzXQpS4A9N9s siZiVM5NU4e5mWWNb8ZQYv0tN3PCbA3H4IjQX/wn9I337Zv2yrNrfB1XAR9sWGFhtAiUdq5j4Sy2 gWWvXbUT/K1LzQXu1dPR0tLa/rKp4OggdK80wFEZumhqMmD8NJ6u9mi38ow7cKu5V4NyG2i7cyje g6MhiI8AxdwNtl/7N6eO5K4MdaBbQbvoVgjF4GOgU8SXIn03gXveUGHcMTGUWd0Olrnt+pdF/330 1bb4vPfQB//A2bnfB9GZOwDjynWzDNV+fjGzn5l4oqKjd0iFp6j/ZcXJxd52JmNRBPFiOJTfSJ7j 7WptSMI7XwFPRW54Stg9yJ9rqoCFRPeSIy6C4uKwVcC84mcP695Jq2J5yVAW5vXDp2LpY1+HY2D8 3tZqNw05TBbXf+nBktrOd6JRvSgR9XU+KTm4zJ9rNjZFEMqDnoKosodHI5NwaCR+NtBX/TusMETn PPmeFN1P9xGCEDqwyyOiRD5ETTAzsFjuZ00C58PDP6r9Nd7W2I780OX7Llc+6+rpez/wvq/nVXPl 5fzl4V5c5ngUwb0u+I+BwaZFjBFvIs1pGBhsTDBCYYyFRa+gPfm+8/om/xkrwdnTtdKSu/rOO0BT 9KZinZMeZ9mPPeBB3P1oC88upVUslXSfcR/rSsnhesxZuDrrQMHZc1+c+GxnWnwQz55tND5FQGvG moKTn3qQRyIUcUba8RPr3XWRSJLlvN2Xf3tw66vdi/geW38FbB5E0qnuKSdv3vvtWsEaPyM8ZcbS Y99X3i8r/DTAxGhm5jd3yw7EWIzz7wnmNo6uHnxvPx++uwvXmjnRKwmW5ujn50jDyp+4fn5c6Amt zfKMWrrikwhPDnsJlBQaOMojYam2AR8lJ8XNdjQioLT0rP1jk5IXznFiEIkM96hFMX4c3Yl9tzQe KyaqAQpHNjDQxaJUnlA4irGFpbkRmcDaA+2h8gSmFhJDNGByOGYGJKCXkWgi1YzDYdJIWkgUTs+Y ZWpAHP8j218NcLph0CgEmrm5vv35t6uddCEGSDQolFOBPSBRaI2H2hQATZuZmp0R56w/sU+M/wNT /jG0DQplbmRzdHJlYW0NCmVuZG9iag0KMjAgMCBvYmoNCjw8L0Z1bmN0aW9uVHlwZSAwL1NpemVb IDI1Nl0gL0RlY29kZVsgMCAxIDAgMSAwIDFdIC9SYW5nZVsgMCAxIDAgMSAwIDFdIC9CaXRzUGVy U2FtcGxlIDgvRG9tYWluWyAwIDFdIC9FbmNvZGVbIDAgMjU1XSAvT3JkZXIgMS9GaWx0ZXIvRmxh dGVEZWNvZGUvTGVuZ3RoIDQ1Nz4+DQpzdHJlYW0NCnichcKHUtoAAAbg57K1e9s6URFRBJGhgKAQ wgozEPYeYQuIgAytdu9l28fqH+Odd613/e4bmzSOnb+GU3wT//o0d5xLjM9cvIGzxE2umX9rDkmu gLwtIO/gvAXv8hes987fX0TbAyHf/nCJ+0iEDny8jNQTMXdC7JxYcT5dRdczlLgmJe6pNfRMS7kz Mu8srvtwTu4TyGnBBj2v8OOCMoCLqoBQxQjVzJI6KNoMirZCy6gJizXhFW0EV3VRlGzH1vQxqT4u NcRlhoRsJ7G+m0S5MbVhSilMaQWRVhIZpTmrIrNqMqe25Dat+S20FTT2gtbOah2szlHUUaVtqqR3 lvWussFdwR1PdddTNXprRl/dhPQegf6GOdAgA02SaVqYljXYsob2baG2Ldy2Y+TAEelQ0Q4V6zox 3nNh4tCNyb4HUwNveuBLD5HOjOjsyI+5owD3mMkfM4XnQe5JkD0Jsaeh4mkYSy8iWH4ZxQq+imH1 dRxr+CaB9bdJ3MN3KWzg+zQ28UMGW/gxi/v8T7k2/3MeD/hfCtjhf2W7l4vdb8XexVLvO/fwcrn/ 46+V/lll8M/hWXX488q14a/a6D/ro9/1oyv+AajcmCENCmVuZHN0cmVhbQ0KZW5kb2JqDQoyMSAw IG9iag0KPDwvUGF0dGVyblR5cGUgMi9TaGFkaW5nPDwvQ29sb3JTcGFjZS9EZXZpY2VSR0IvU2hh ZGluZ1R5cGUgMi9Db29yZHNbIDAgMTUyLjY1IDcyMCAxNTIuNjVdIC9FeHRlbmRbIHRydWUgdHJ1 ZV0gL0Z1bmN0aW9uIDIwIDAgUj4+Pj4NCmVuZG9iag0KMjIgMCBvYmoNCjw8L1R5cGUvUGFnZS9Q YXJlbnQgMiAwIFIvUmVzb3VyY2VzPDwvWE9iamVjdDw8L0ltYWdlMjQgMjQgMCBSPj4vRXh0R1N0 YXRlPDwvR1MyNiAyNiAwIFIvR1MyNyAyNyAwIFIvR1MxMyAxMyAwIFI+Pi9QYXR0ZXJuPDwvUDI5 IDI5IDAgUj4+L0ZvbnQ8PC9GMyAzMCAwIFIvRjEgMTEgMCBSL0YyIDE0IDAgUj4+L1Byb2NTZXRb L1BERi9UZXh0L0ltYWdlQi9JbWFnZUMvSW1hZ2VJXSA+Pi9NZWRpYUJveFsgMCAwIDcyMCA1NDBd IC9Db250ZW50cyAyMyAwIFIvR3JvdXA8PC9UeXBlL0dyb3VwL1MvVHJhbnNwYXJlbmN5L0NTL0Rl dmljZVJHQj4+L1RhYnMvUy9TdHJ1Y3RQYXJlbnRzIDI+Pg0KZW5kb2JqDQoyMyAwIG9iag0KPDwv RmlsdGVyL0ZsYXRlRGVjb2RlL0xlbmd0aCAxMDA5Pj4NCnN0cmVhbQ0KeJydVstu4kgU3SPxD3dp WkNR77JHURYJSSujaSmtQepF1AtjF8QK2Ixt8vj7vmWcbgooOupVYXHus849t2ByDxcXky/Xd1Og l5dwNb2G/4cDCpRQShnn1IDhFJSkUNvh4NsnKIcDBsufGEo1o9IDLT4NB1+HA7j5cg2wF4D9CjDu bVWiTR8rFoydisUFSRLAaKANYTQBlShCGXCitWaQrYeDyd06XVouYVrBqcC8Dzz5/B/XsGz6ClgS k5g7t4mJQTA8BYiYEaN+1nHkSxx1iUvJ5InMXTTTRZvcp21r6xKyBl3xBJqsdOaSG8I7SwyqqT7b PdkHvpqhw1sB6Hu2cJW41jDQmIvEKnRCWAKz9X586qrFTyb6z8/DwcMFFebq8jvM/hkObtDnzi87 9BtzbAff9/sQ/VuMxjwqt6+Q1yMVFc+2hrxaj8YiSouygZGJto3NAf9rKxjJqLarN6hKGPnh3mPI WJNY7scARxCmYJY9RNvcPgcMseEk1p4h7WxCkZTUBwYPkX22ZYtJJ1FxlOGuIQTv+GRThCbG9G6q Orf1SEeuXqx6lW7L7DGUB1eGGOk7mKfZE9raMm8CVgIvOT4IG4ogNIJ86KKqgzdAJdEH+Sy3tmkx oVA20uAcxuFsjhisDhnsNzWhRDCsjjIi+7txHJWnOOpboioQpO2+ZTQNZM24JFT4WLuxjrtlbsvM /XgLXhvWmsS+cZjWHJVFHaDPkFkwdQQP3i5nhPnQopu72rrR3KzSzJ1uBmX0UrSPkAJyM9s2bbV2 c5mnHXAdzr5vKjcotO8x5tti1XaD7Di+gQo9LcIcF0RJ38GqmL+uQvhEEHaAP8sn/SE+cRFjq/6A TnuG0X2QTSjcwoPW1fNIREVum2Bnce9I32hZ29TdB24Jd8CIsWixsq+OjcW8WBXtm+s5ClSFzlFp HKruBbbe4oUIJ7l1SPZUQvyCxiGkdmrnQZtNmnXz8Tum4CF+aZnL8OmMmHEkL/WtgkyimgjlQXHN YIuhWuAKcvvnXH4CxTaRnjluK7epQsomGRE6mNoREc2HiMiMdJr/B0zct4xuOlKk692cW7e3sAud bqWbdMcV9/E3kkhGu+4EO5MworTvv29NeFdT1xvPJEs7ApbVC2wbt8J+wxQmlbuQnfHXvGieQngt SHyAD/p2O1352I/QEHcqSrpn9pfTypfHwu1vlM+0gbJq3c9N1WCdTTHHvneqGpw3JJDv89wrJkkO 0WfpFnt0c6seK5BHr0HDQSr9/s7ZvXi7l190t96gSlksCPfD2ES3qDTvKrN72sG0E5iiAwXpo3CE tRcF9+7JyZrc8pNpClwRwndwVPoP0lCr6A0KZW5kc3RyZWFtDQplbmRvYmoNCjI0IDAgb2JqDQo8 PC9UeXBlL1hPYmplY3QvU3VidHlwZS9JbWFnZS9XaWR0aCAxNjUvSGVpZ2h0IDY3L0NvbG9yU3Bh Y2UvRGV2aWNlUkdCL0JpdHNQZXJDb21wb25lbnQgOC9JbnRlcnBvbGF0ZSBmYWxzZS9TTWFzayAy NSAwIFIvRmlsdGVyL0ZsYXRlRGVjb2RlL0xlbmd0aCA5OTE3Pj4NCnN0cmVhbQ0KeJztXQVcVNn3 X7vXXnMRRMTubhFEEQw6pLu7u7u7ZhiGoVsaVDAxQOwWMFARULED+H9nno4Ig4u7xu+/6/mcz/3c ue/cc+Pce+K9+9789tsv+AW/4Bf8I5g3d97CBYuXLF4yevTon92XX/AtoW/fvps2bbKzs8/IyKyu qn737t3bt++etLy7d+dx6xPk36Lk3r2GQxWHgoKCJSUlJ0+e/LO7/Au+GgYMGCAkJJSelv7y5av3 799Dps+fv7h//8Hly1eOHzuelZkbE03O21d46tTpq1euPnjw8MWLF+/oAMr3Z8+eNzMz/yX3/xcw cOBAfT39pkfNbW3tb968bW5+fPXK9UMVR7C7KRRKSEiou7u7ra2tmZmZvb29t7d3ZGRkIi0xNzf3 2LHK69dvPn78FLXev29re9+empLGycn5swf0C3qEvXv33rxxq+19x5s37yC4O3fuXr169cyZM8eO HSssLExJSYmJifHz83NycrKxsXF1dQ0MDIyNjUV5QUFBRUXF6dOnsf2hBKAKIPH2to73796HhoZO mDDhZ4/sF3wGmzfzVFWdef++/e2bd8+fvXz8+ElLy+Pm5ub79+/fvHkTcjzDgNLS0sxM+jaHlJHS aLTi4uLjx4+fP3++urr67Nmzt27damxsfPbsGTR7e3sHAfjp6Og4ePDgnz3KX0AHCzOrt2/aXr9+ 2/r02eOWJ8+fPYcP1t7eDosM2Z0/f2H//v0BAQF6enqysrK7du3i4+Nbv349Dw/Pjh07xMTEFBUV TUxM4uPjDx8+XFdX//Tp01evXrW1tXV0hvaOU6dO/fnnnz97rP9pwI6jUpOftb588uTZ/fsPHzU+ ev78OYTz5s2bu3fvYsNiL5PJ5ODgYGxPQ0NDeXn5PXv2bN26lZ9/2/btAjt37pSQkFBTU4O4XVxc goKCQFxWVgaFgN39mbTbOiD/e3cbVq9e/bMH/R+FKVOmHqo43tLS+vBB462btdDb2M4Q9+3bt6G9 Iej09PTk5GRIMCw03MrSTk5WUVJSWlJCEntcWVkZmxq2Xlp6r4yMnJKiqouLR2wsCeo9Ozu7qKgI 5r6hoYGQNXY63Wt/3wZj8erFG3k5hZ899P8czOKeXXPmUuPDprra25cuXa6vpyvhO3fuQNCJDIAD lpGRERQYoqGhA/mqq6tra2sjhaDl5ORQgp2Ofa2lpaWvr4/dDVWvoKBgZGialJQCg15SUoK0srIS 5gChHNT7yxcvX7+G2nj7+lWbnY3jz56A/xBM+GPC0SOnbtffvXjxMkzqlStXsKOrqqrS0tKio6Pj 4uKwSSPCI+Rk5SBciHX37t2bN2+GHl7JgOUMWLFiBfET5Vu2bAENiCF6LAlNTc2cnJz8/HykWVlZ cOSgN1paWhobHzU3t7S2vnjc8lJZUf1nT8N/AoYMGZqetu/69VvV1TWInmCgIQ54WYiYYHzDwsIi I6KhpbF/4YZBjhDrokWLZs+ePX369KlTp44fP74zN5RwcHBwc3MvXLhw2bJloEddWHklJSUdHR3I GiuHbtBLy5qamuAP1NXVPbj/kKFVHm7fJvSzJuG/A1ZWjtXV5w7sP5iUlJSbm4s9mJWZZWZmZmVl 5eDgYGRoBn9bSEho3bp1CxYs4OLimjJlSu+ZQ+6E0KHwofzFxcVjoumhOhw56I2LFy+ePHny6NFj WGBVp2uKCysmTJj4/Ub6C/i2bC8qOpCfX+jp6WlqampsbAybu5UBiLDWrIGQ10Fvb9y4ce3atVDU SxmwZMkSpH379u1NE8OGDYPQoRNERUVVVVVRUUZGRkREBEsIP93d3e3t7e3s7L29fRzsnNRUtZZ8 hKWfA0qgN773hPyLYfjwEZHh5PLyCnt7h6DQ0Cu1tR1fA3aOX+FfsbGxQehz586lUqlf1Qrgen39 tfr6tJycCRN/7f2/D0oKWkWFpWlp6RA3tjM1MfF6Xe3VWzfPXblcff7c6XNnq86dRaY7Xrp+DVKA g716zZreN8fOzn7mzBlUvHLzRneeaOs0A5FHBy7fuI7OXK+vBfGlG9dgXAYMGPD9puJfD5MmTvH1 CSkpLvP394cx1dDQgFE+evz4/UePGhob6+7evV5be+3WrRt1dSwR/jRdcDdujB07tjfN8fPzNzc3 o8qt27fBuQs3oi2kuHq7oQF9eNDUdL+x8U5DQ01NzbZt2773bPzrQWSPTFRkbHh4hK+vb2BgoKur KyzjrFmzbtbWNrY0P33xHNj89EnTk8ctrU+Bj5+1Ekj8RDmhaRFb/WVb8PoI4ofNTWAOtgRDghWz FbTY+vIFyvHzwaNG+O2FhYXQCd9/Mv7lMG7seAtzh4z0TEjZ29sbG1xLS2vNmjUTJ07EVnrY9Ohx 69OXb9+00e9ts0D6nbGOjrftH26D6+rq9tQQ/DSsB4Ls2csXr9+/I+ow+TB5vm17/+LNq1Yss+fP mltaEKBhHQ4dOvRHTsu/Fdav2+Lp4RsZGe3s7Axxh4WGIVbi4eFZtmQ5TCQM5ZMnT953eajRM7x5 8wZuc/dWEJtfv3699y5ZW3v769evGxsbL1++jGj9x0/LvxL69OmjKK8eE0O2tbVzcnJCCGxoaIho a/fuPfCcOTk5EWHFxcU9e/asnfnM8q/g6tWrv//+e+dWEGqBw1fIuq3txYsXDQ0Nhw4dWrRo0ZTJ bH9OnfazpujfBJMmTdXRNoqJITk4OEKZBwQEYF9v2rRp+zZBzDMs+ODBg0eOHFleXo75773EExMT Cf5YLYjiey/oDoaTD30CN41CoYwbN27rVn7BHTt5eLZ36TlsDQJwPj4+BOxqDEBm7dq1c+bM+WGz N2PGDOY9AWQQXf6wpv8eLF28ytjI3M8vwNHREcrczc0NWxuB2LRp7FC/8LQJi8nFxQVVDO3ae4nr 6OiMHz9+//79vRc0mMMWPHr0qLa21sjIaMyYMegJQ9vwcs2Yi2BBSkoqIiLi1KlTIPsyK/Q2ISEB ffjyfb9ly5ad6gTJyckRrEBI6NMd3dGjR+vp6ZWVlWFNdm/35cuXJSUlCgoKvbzv9INBUEDExpp+ I4vQ5JgfbG1paZlJkyaxsbENHz6cSQmDDkG8ffu2l7KDROBifZWsMVcPHjyoqqqChkGLEhIS8BWR R6/OnTvXe1ZdABZh3bp1LIevra3dm46BDMTz588nk8noZG8aRYf/1w7jwXDvlVFxdnJzZGhyhGCY Xoh7h4AQNiYUaRdnWF9f//Hjx1C2f3vmewIYaxj3O3fuwHXHMhs7Fo2Pg4a0s7NjOb0QAapg7dEf nr58iaWFXn1Z80RHRw8ZMqTLDEAD9KZ7/Pz8iB//UqV0gZs3b44aNerHifOvYMSIkYoKGr4+9POE 7u7uMNybGTBtGgfsNeKmQYMGdakSFRXV2tra9fQRK2jvaG9r/wsyELx+8xrYwoi20AeixWls0yDr ixcvEmRv3r4BDdK39JPs9KNTMCuEzofffunSpRs3bkAtQO7tdJG3E02/b3sPYlREhuBz7NixLhK/ desW0Q0C6YcsPuK79+/QIlERer776Jhsu5ej3Q7GmsTE/jhx/hXA490ro+Tm5gGTDYcKsS1kDaXd r18/yBpRGDJdqkC9FxQW3G2496i5icDmxy2dsamluRHFjAxxlSDDz875+w8f3Ll3t7a+7lZd7dVr Vy9euigmJgb+/fv3RwolQ2xqNFR/5zYo791vQJWHjxoJhHALCwsFBAQIc4NNxMvLC6EwGyK68aDx YcOD+6gOJMTh5+/PHMvUP/8EDVGFQOaggER1FD5++gQpGkVnbt+9A1bgSYyFWZFAZrvoKurevd9w 7dq1HyjPvwDO6dxysiqenl6QNSJuCB2GUlSUPu0DBw7sydmYPGXK/oqKc5cvV58/X3Px4tlLl7rg mQsXcAlIZJASZEiJKtXnzlVWVR09caL8yJHSgweTU1O5Z836jWFckC5YuBCybn316kRV1Ynq6tM1 NUQtAs8yUlpy8pCPhoaoBZgzd+75K1eIDnzW6LlzJ6urT505U9/QUHX27KSPLzXwbt36sLkZNERv mcisDgT9CUZXDx46VHzgAIVGy8jJwc8z588TzAliJjLHi4pV585dvHoVDuf3lmMvYRb3fHk5FR9v X8jaz88P5ht7REFBkbjKnMbusHLVqgMVh8qPHD107Pjh45XdEeVM7FxYfuQYMgcPHykq259bWJSd l2/n6DRixAgmZwTs0OpNT5+VVRw6cOhwxVE6PVJURHqk8gSw+tyF6dOns+xhXmERWgEls2kiRfX9 FYcOosPHKzds2kQQa+vqNrY8xaXOve2CpeUVBSWl6Tm5OwSFmJ7MkqXL0Lcuo2OOEa0TeOTEyZNV Zyb+zzy5mztn0d69ShC3v79/UFAQAjGEsWpqvTo4JC4lXXSgoqDsQH7p/l5iXklZXnEp0tyiktTM 7KT0TFEJyS5s9YyMX3V05BQUg4Zepbh0X1EpUqJ6fsn+89duZucX9dSrk+cuFJQeQJXOCFY5hcXI FB0oLyk/xMPLSxB7BwQdPV2N8h67WlyalrMvikzhnDGDqMJcYNb2DmjoSyMtKQMBmuvuH/4smDN7 kexeJU8Pr2AGYHcjztXQ0Ohldf+wiNTcvOTs3N5jUlYOLTM7IT0zJJo0b+GiLgwnT5168MRp8EzM yAYx0kSsiqwcoiLyafvyL9yqb2xsPM2AU58DSu60PI1PTe+OlOTUuORUZFJy9m3YRI/yBgwcSE3P BEOwZdlPlKMDlNS0TTxbuo9dTEr6C2Mnup2QkRVOjv9nIvqWMHPGPBlpBXc3j7CwsPDwcB8fH/hI Kiqqf1kRKzY+Pr75XQclNYOUlNp7JCenkZLS7Fw8xrB6VCq5V+5I9fnohKTYxJSYhGSkzIpECTIx tGRycnpSdl56QXF28f6c0gNIgRmFJdT07ChqYhg5PiIuoQuGx1FDYuLCSPFgvmT5CrTFwTkDfGJo KcDu/UQhWoymJfuHR7E0aiJS0plFpSzHSO8qvXpqVHyiilaPD4x+GMAHI4bAwT5TRprumSO8QliK DQ5fV15e/svVOTk5z5w586Stg5ScHklJjIxP6iVGUZNJyRlIB/XwipC5nQMlNQs8w+MSunKmJEZQ aEhDydTgGHJwTFwoKR5kEQziMBI1jExFJiSWEhJDwaXOiELQB0bGBkTEhJIoM2bSb3XybOUvOlLJ oiFGW/Ty+CTwVNc1YNlVdT2DtIIS1sNndBWIpleuYX1750cCwisivJ00caqYqIy1tS2JRIqLiyOT yYIMGDp0WE91d+zY8eTJk9NX6khJGdEJqcDYxLReIikpvaD8WMv7DmVNHZbMIylJpMR0UMbQWLBF WygPj6MFRpJ8QyP9wqIDIkiBkeSASLJfeDQQmcBuGBRFR1D6hkR6BYWHxiYQLr2ajn5e+fFoakr3 tlDCGFc62uLdtoNlV32CIhMy9vXUT6RRCSlgzlKJ/WBAbEuEq8OH/y4qvFdXRx+CplKpqampQkJC u3bt4uHhZVnRwcEBoWvZ8WpySiY1Yx+BCZl5H3Ffp8LO5Z8wKafw7tO391rfrt2wqQvzwYMHJ2YV EAxZcqBl5SVlFypqaE9j52DjmD7taxG12NnZ2D8caAyIImcUHfi8/58NBNKMT8tmn87iRujUP9mS c4toWfksh0l0Pi4t2zcs6luK7R/A6NGjR44c2ee3PruEJOXllChxlMTExLS0NFlZ2T179piYmHeh R/BYWFgIWWcUHKCkZGMqknMKEzPzMf/IIIWk8BMpM09c6oz0S5n5uaWH6WvmWNWkKVM7NzFs+HCw paRmE3WZ3Jh80vJKMovKdwqLfYPhjxmTkluckltE8O+CRLu0jLwoSgrLmw+beLcePXsFZMSgulbP zE/OKUpI36eha/jPu/pNAOIm3rjcsJ5fQlwmPDyCRqMlJSVh/woLC5uZfSbupUuXIha+/uBpLC0t igrHJpOSmkNOzoxLyUImLiUbGSKPQlxl/CQK4dnmMBE/QYBMdkkFJO4ZEDZw4KebtHAnQmJhjhNj EtIIMoLtR8xO3VcKFJGQ+Y1VxD1nzpwlPQPxgJJr5kyCeNnK1bllR5ld6ozMzsfQ0g1MrVjOnpKG 9v7KM0QPe6iejerrNrFw6X8KjBgxgp2dfejQobO5F0qIy7q6uEHcycnJ2OPi4uLS0tIzZ84iKJWV lV++fJlffjwgAqYwLiSWGkqi0dPYhDByIvLI0JFEC4qmgIYg+1DIoGHiB2J69YT0wgOPXnXIq2p2 7pWytr5XcIRvWAyYgBvR1oeKJBopKavmxn1LB7fuw4F7+eWb8yl5JeCzcQsfQS8iKVNQcSI4hkr0 5zOMhb9HDYqm+keQ+LYLspw9R09/CLSn6igPjIoLio77Y+Kkbyq0vw+w3RwcHGxsbOPGThAXk9fU 1E5KSk5JScnJycHUSUhIaGnpDBw4MDIy8nlHRwgpydknxMUvzD0w0iMoyj0wAqlHcBQzj3JcBY2j V6CjV5CTdzB+guATJRMZxESaVXastPLcitXrmb2aNp3T1s3X3sPfwTPQ0TvIySfY2Zferpt/uFtA BLilFdLVgr+/P3Yr6DEEfn7+ffv2vevoiKJlgoDJHPSu/mGu/uEufqHoDxhqGVkwHwFom1gGRFNR Dv4s0CfEyTvIxTeUaeg7A4yOT2isq18Y0b3uiHJwtnRksSx/IkyZMmXBggXDhg0TFBCXlpJFLJbB AE9Pz40bNy5cuPDEiROl1ddtPQItnL2t3fyQsXEPACLTOY/U0tnH3NHLzNHTxM7d1N7DDOjoZe3m T1wl6JlIVATaeQcXn7wUEEObMOnTCYSFy1YY2riY2LmZ2rubOYCPJxDMzZ28zOk8/WJTC1502rbI U7LLHH1CCc4gAFq5+lm5+Fq6+Fg4eZnYexjbuclr6o/4eJ4KniouWTp7d27iM3TwMHfAWDxYRtwz Z89zCYgydfAw7akuUnvPXeL/W+frxo4dS7zNt3DBCmkpBUsLq8zMTKh0Z2dnXj6+m83NQdR9upau upYu+tbuhrZe+jYeBkBbTzoy8vRCa3cdCxctMyctU0c1I1tlPYtZ8xat2bRVy9RJz8qFICMomfih uq0n6pq7BOWduK5maDNo8Ic7jVxcXDNmzVXQNlE1tFY3ttM0tdcyddAk0MRBy8wR/SEYEkyIjJ6V G8p1zJ11LJy1zZ00TR01TOzBVs3ARk7TZNGyNZ0FN3HKnxiXpok9HZnMO6GGiYO6kd1OcTmW87aW Z5uOpbPGl6rbaxjbzVu84kdIsdcwatSouXPnrl69euLEydKSynJySiEhIbq6ulZubofq3hq5hCjo WSvo2ygbOSgbOygZ2SNVMXZESi9hFCoa2MrrWcvpWu7VMpfRMN0tqzl+In2f9h8wQEhaVU7XCgSd 6zKRKEQGqaFzUGxhFd9uaVQUF5fctm0bnIphw39fvp5PREFbQsVQUs1YWt1EWsNEWtNURtNMVtsC vVIytCOQ3gddK1l0QNNUSt1EUs1IQsVATElPQlmfd6fkdO55ffv17zLw2QtXSKkZiasYSPSI+uAz f/lalvPGt0tKQtXwi9UN9mqajRr7x/eW4NcCnPMNGzZApa9ds4V/q+DiJct9E/ODs07t1XMQUzWV 0LCQ0rKS0rSS1LSkZ7SskX7Ia1qJq5uDRlTFWFjRYLe83gYBsSFDP510GjthioiykZiKiaSG5ada dA5M/FCI1MA1wj48a9ailQICAlJSUpaWlhoaGsuXLx8wcNA0rrkLVmxat11sm7iKkIymoIymkIzW Llmd3XJ6uxX0kO7cq7NzrzZxSUBKYzXfLu5FKydMmdZ/4EBmZ7ro5PGT/pzGNW8a15yecS479/yh I0aynDQ2rjlsM+jYU3V2rrkc3Au+k8j+CYwfP554A3f0qDHTuJfElF+3DE4VVTcTVjERVTMX17T8 iFZIxTToiLyYuoWIqukeZWNhZaOd8vpC8roLV23pHp/OXb5hj5KRqJoZUZFRlwWKaViAp3V4loZd 4PjJbJKSktR4KoVC0dHRWbFi5XR2rn59PwRrg4cMGzlm/CR2LmK2mThlOjfKR47pupv6MOBHzOP/ H5g2bdr8+fO3ikhlnH+u4xoppm4urmEhid2nYyOlY8tAm49I/4lLIIAQRVVNhZWNdyrocXDPZ8kZ bjCfmDIYSmhafaxu8znaMnnKGjr5pBzFQtq1RyQuLi4pKUlJSUlUWEJQQGTu3HmAcePG9eZJYm9E jIhjGAOGfwSWx7R62VZ36EKmpqa2jwHObm4//WEoAnAnf/+yG68MXIIVjRyVTZ1VzFyRKpk4Ie2M KFE0dlQwtJM3sJXVs5bRttgjrz12wpdCy3ETJ8vq2cgb2KFiF26d2RKNGrmFU8svC8mo6ujqampq KimqKitpb9zAB+9i1qxZXc6E9DS3vYGsrKzmbnDnzp28vLxNH08+fEOgJCaevXz5wpUrBSUl30Pb bN68GbGzgoIC7PKXKRGLHTp0qPTiA2vvCFOXAGNHX0M7uuesb+thgIydl+FHNCDKbTz1bNy1LVw0 zZyEZVSGDhv+Zf6ANZu36lq7GdgyXPpODD9ja+uBvIlLQGhq8b5TNzfyC61auVpRUUNGWg3zD3FP njy5y2spfxugcw4fPfqwpelhc1Nz61Ng09MnD1qaGxofEpGdl5fXN2mIgEmTJt1uuFd/987t27dN TU2/IWcCoKnAGd1+/KzVzMzsC5RYDA0NDQdrbnmGxSGQdPQNs/cOsfUMsvMMtvMKRr4LohCXEE1b uvpuFRLu27frqUWW0LdfPzUDi554fuDsSefs4B3qEUquvPog/8i5WXMXbOMX2cLDKyQkhPChyydf /gkg/GxsbHzz7m1LS8uFCxcqKytPnjx569at1tbWF6/ohyExJzAc36o5WAp+fn4+Pj6kX/Vhk14C bDFxDvzdu3dwuXsiE5Hcm5xfFkFNCY5NCIyi+IXH+oRGe4dEeYdG+/SAuOQZFOkaELps5Ve8tg+Y yjbNIyjCKzSqJ87MptGN4FhaTFJWCJk2esxYbG345wgfvuFpbfilHYxXHmpra7m5ucF59OjRU6dO 9fPzQ2F7e/vTp0+3bt0KSiwzFPr7+xO7UlBQMCcnR19fn8mqf//+WI0kEgka8uDBgyBeuHBhl+bA xIkBioqKXS7BZYImKSsrO3z4cExMTE+fEIRmMzIyys7OPnHiRH5+vo2NDfND8VpaWighlNLr16/D w8PRW1FR0c7VBw8ZomdiTklJj4xPCCNRgunPgqP8wiIJ9A/vEQMiol28fDg4OdEx9P+rzJzgHuEv cAYyWw+KjImIo8anZbr5+GFCsHq/7UlOa2vrDsarPZBRZ0uKddXW1oadgl1PiNvc3JyYSWgAxIYd jM+3Mt9FhW5E+Yez5R9fZ8CCMTEx6dwc8ZYK2JaUlDAL4Rb6+voyPgzbTqQdjBcrVFU/O0eE5aSu rk68mtTOAKKVs2fPIp4CwbVr1zp3gHg1w97evsuQBw8ezDGdk4NjOjv9QTDHNHYGcnxEdnbi0fCn EgbOmDlz5cqVCJRsbW0jIyNTU1MPHDjQnTlLQM+Jhrqz7Y7oFQfnjIWLF3NMn/4N1TgBpaWl9Fuv L15gwn/rFJLv2LGD2CN1dXUwuCiB50ZMJl35v3mDaUeG+P6PoaEhQYwSaAlYTywS4nUqzDyxWgig 0WgohKXw8fEhSrA3YT4gmkePHt28eZP4liBYEWRsbGzMupmZmSh8/vz5vXv30AqcyaamJhDfv39f XFwcPjY8TOL7tKiOS+hGfX09tFAvpwIcoDqgkVatWjWTi5uPV1BIUFhIaJeSkjI2BTpMpVLLy8uh VRBWQL0ghTKBHjt+vBJ9A83atZ/dicLawKxiyGFhYdBI8B6lpaUlJCTgeFtZWtnZ2Tk4OMDBYByo 2MKzmW/LFoE5cxZiU8+ePRuW7hvaUALA8GZtbTtDKMLCwszyiRMnFhcX19+5c6uurqiIfswVnuHF K1ceNDY2tbQ0NjXVMcrJZDIuQYEz3ndowPxHRUWtW7cOHdbT06urr7/T0PCouTk3N5dYRQi7qmtq mh8/xmLA2Im23NzdUf3egwfY79ikiAGhJ2/fvdvy5Mnzly8Rfv7GWITWtrZEK1evXsUUwS6vWLEi JCSkpqaGeD9x5MiRUlJStfX1T1pbGx488PDwgKAxqK/6TxAsbHQeSx1aa9u27VoapnY2Lna2Tm5u HpAsfBsM/OHDh1jq16/fgNHB0LALCgoKCgsLMWOlDChjwP79+5GiEKsiJSUFcxUdHZ2WlgYCVDx+ /DiUQ1RUtIW5hZ6uoZ6usY6WKR+vAC8vL4zFjBkzvsd3zpcuXVpZVXW1rg7iDggIwDRCS0NkEMf+ w4dzMIyyslWMDwotXb782OnThyorK44dyy8pQSHxNA16ODUrq6yiAqip89kRLH0jo8OVlUdOnDh4 7BhhgGbNmXP01Knj1dWV1dVcjHeBl69cSbcO1dVoqPPrltb29ifPnj1ZU2Npa4uf0zk56xoaSsvL 0atVnT5whD782Wn7T5w0CczRz6MnT3L93XeN4RphWqAu4JZgM2qoG4UGxYUEx0RGxmRmZl2/dh3O DN2PffECOgRyr62tO3XqFHY91gMhd2wE4sOnAEIbYJ1AHUELYalA7WBfoDw0NMzFxc3FycPFydfE 2FFwxy4REREsdUTZhDr95rBhM09pxdG0nLziiiO1DU3vOjou3qzPyCukpqTHxNMiSJQt/B++87NH XLy88lRqNv0INA/fJ+W8YRPP2Ss3kzJzYyiJIxkOJDP8X7NufVZBcfq+gqT0LOIS/44dlTXnURIW TRrIuI1jYml98uzFI1U1mBC4dtitxJHvQyerU3PyUrPzVTXpr5pKychXnr2QnJnj/DEqZHmTYQsf /+kLVzPzi+NoyV84XviXAAdp0aJFAgIC0LrwFmSk5R3sfKMiEmKi4smk+LLS/fV19fB2XjO+Wvue /m8TbYQvAVcBOwU2BSnEStC8ZAAyMEMwWFVVVXFxFD9ffx/vQF+fUE+3MGUlbXFxCWj+jRs3fj9Z A4QlpHNKy0NjKUEx5KBockBUbGBErF9YlHdQuIaeIVun7/yoaOrEJqWFkuK1DT9zvbT0jXL2V5CT 05U0tbowF9wjQkpKC4mNs3b+8KRbU984ITM3kpqkqsk4ftynj6OnbxQ1OSohOSYxDeUR9DOrieFk BEckdAPpqnX0p/8OHj60rDxySsY2wZ1fGI6qjl5iTn50QrJ+t8NmXwuITRBEYP5lZWUNDAxgUxTk VXy8okgxybHR1HgKLTMDocHJ+vrbkGNPrwATH69+9eoVpH/+/Hns+5iY2JDgsMCAsODAqMAAkq62 uYSEpLy8PPY1jCAXF9d3/a8KK2f36ITUUHKCuYOL+F4FCVkFUSnZLfwC3Y8xWDm5xSSmR1CSNmz+ 7JSmmZ0TOGQWH9Q0/OyeyYABA9KL9ofF0cIpNN5tAijp17+/e0AoJS0HfHi20pXGgIEDvYIjomlp lLRsRXWt3aISu8QkhSVkdolIbBUQwmrZKSI+4veRYOUXHh2Xmp2Qlbdj156exoLN7uztT0rJpKTn COzskeyrAPOPCIWfn19FRQVCl5OT09TQD/Inx8WmxZGSE6iptISUjIzsw4ePnjlTU3urFpYdihqe JFzEGzduXLp0+ciRI/l5BWQSJToqNiIiNiI8LjKcGhlGMzd1EhMTJz6lCwUOZcLJyfnN/fDOAAVL Ss4gp2TGJKUvX8364SYBw4ePiKKmkFOzyClZ8xcu7nxJ18QcG/Ni/cPHz55hZohCBO+IU6jp+6Jp KQFRpEGD6KfoR48ZCw7JuYWQ2ux59McKffv18wwMReHhmkvrP38zpXOwjCjG3T+YlJTx6HXHgcqT TB0OF9rT05N5IGfosGGhsdSs4oM1N+5gV9JLhg7955+MgCmfM2cOfHU4hBoaGnCwlZWVlZRUzE2t gwOiadSchPjMxIQMWkJaAjUF0k+kYQ1gJSRR45Pi4mhkUgKZRCPFJMaRUiPDE+1sPdRUtOBSYuXA Rd+yZcuSJUugwL/HHacuMGf+wvC4FK9gqO7IPxi3+nu66z5z9tzg6HhvUAZHjfvjM22zaMly94Bw 75DoVx0dMEzw92CCEU8FxyZ4BUc6evijFYKSnYMzipoOPv7hZOahNSUNXc/AiEPVV2HXXF1dEWgj nLl06RKq7xaV7PNRWDt2CXsGRQREUaAh4dM6OzsjJoLdjKFlKGvq9e9P/2Lk2HF/eIVEh8TSXjK+ FOEXTtIxsezlrc6/BFjzefPmrVmzBt4+FDsCT8hdTU1NTk7ezMTCyd41KCAygZKRQstJScpJTKAj VkJSQk5oMNnTzd/a0l5dVVNGRgZLBYoCfiAfHx92BwKuH/YXJLzbd5o6uBtZOytrGX/5UcVG3u2g NLZxUdI26n51j6ScgZWjmb27tVuAvTf99q+lk7eJnauWsRUbx6dD6avWbw6hpFs6+2iZWBMvrQMm TJyMn4ZWzmb2nlauvtaufuZOXkY2LkY2rtt2iTJ7NWz4CHVDS0MbF3NHT8bt5RA7jyALZx9LVz+x vUoEt99Hjjaxc0NdYzt3MydPsBLY8w2OZHcGDg4OhGkIADds2AC5w+bq6upC9PDh4dQpKirKMkBT QxNhJoSLLYy1oc4A+gNNUVFIGXEWdjQ0RudbCj8ANm7bvUtKaae0yvL1rF+aYMJ6vp2g3CWjunwd C8pBQ4YuXrlhp5SyjKaJnJa5nI6FoLji0jWbhw4f0Zlsp5SKspG9gp7V5h0incvHT5y6YetOMQVt KVVDGXVjMUWdzQLC7FxdvxY1ZvyEdbyCooo6exmtSKkbbxEUmzHn013xPn36Ll/PIyynKalqIKmq v0NcYfyE7/VnfLCz2OzLli3Dfufh4YGex4aF9LFzofCJb15B+pA4RLx9+3YYF5gDGGhIGWvmp7zy 3PuHj316YQH79us/YtTY0eMnDhsxqsulP6awbxVXsYnI2qNkvFvJ+M8ZLD78NXjIsFHjJowa+8fA QV96Aj5w8JDRDLJBQ1jHWag+/PfRg/9BFPZVwM7Ozs3NjS2PDYtdD5mu/Aj4CXW9ePFiLIyZM2d2 +Y7TT4HePyL/MmX3S8wSzL+UtqWRR5SUlqWYuomApGr/AQO/XL33XeoN2Y+HyZMnf7/Y+X8cxv0x 0cTJR8/GTdvCUUHLeNKvjz3+q2HMuPG7xCQEd4ts5OH7X3j98xf8F+D/ANXK5mENCmVuZHN0cmVh bQ0KZW5kb2JqDQoyNSAwIG9iag0KPDwvVHlwZS9YT2JqZWN0L1N1YnR5cGUvSW1hZ2UvV2lkdGgg MTY1L0hlaWdodCA2Ny9Db2xvclNwYWNlL0RldmljZUdyYXkvTWF0dGVbIDAgMCAwXSAvQml0c1Bl ckNvbXBvbmVudCA4L0ludGVycG9sYXRlIGZhbHNlL0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGgg MzgxND4+DQpzdHJlYW0NCnicxVppWFNXGs5GViCBkEBYEkLYCcgSIICAoLIngApYqMUFFEVc6oIo KtuoqHUXneLSmQodx9FqnVqBaltq1bYo6gMiIFAUBESsiIBAljkXErnZWJ6nA+8Pntyz3POe73zn O+/5LgjEODDnWNlYWbCMx2s3PTAwtnTxnRsSFh4hiAgPDZnj48g2ok43KQXoMaw8ZocLIAjXb970 sRD6FRbgyqaTp5uaHBQjO3/AcF7O1w9apSPoabh5LEkoCPHi0HSnm94w6FZ+EYIF+++LpEp48e9k YaiHucH009Rn88MEMed6lRmOoCJNGOxmpkecXo40u7mCqBNd6ikCiH9IEs62oZKmkaKusUtYZF6L RooQBq4sDHGgTR9LMtMnIvrSmBQhPEsNm2GoPU0cdc39hfH3x+UI9nqWwN1oeljqMP2Fqa0KbCSi of53PT19Q0MiCbxcdCrKnT4dK04ymSlM74Ez6W2v+uHi2cP7DhSeL6n4o6tfDKu8GuVqMA17nOYu SO2GUWyrKM5KDA/w8XT38PabG7P2+I36Lpg5iyId9PBTzZFsE5bY/oGCuP324cQAVzsLUxpUacq2 mcGP3nm99vUoy+MhHF3c1HIkMQMXVHwg0Hf/9KpgPpeio4UcbWLjEZ1XVvPhHHq/LcLGSA+AQiai p4YklRf15QeOvU9vFJ0qyM/fvc2dgoJNxMZrxcXHg/JWb6+cOrQ/Pz8/b8McElLzm/86kNghKf1q gs3dmdrw8a2CDr5WbfQsGj6V/x+o7gsq1XCUSs45Yj80QhLtc9+otmnY7KIzFSSJrKAsdRyl0v4t ZnKHQ5G9igZUGohr8uaa4KdiuSlOMdXqSUpfzNMfYYCih/2qWj1UkRdmoTMVGwfPCNguD4E9yjTu ziQClkiseXKzGkOXbpppQpgSjyRZRf0oG7X9J2WvE5+y1UIgSU75b1U5SsrXexhip2RrI3S5S2QG lJzMKlbWu71rjDF6vpeG1DnDjWAGHonCUwyZbDaTro0Zly+GSKHoUYiYyZPU5x+SDfpsZVDSFWU6 f0Tbzn+gjqJUWh/p5DZLuHpP4dVr1745tmP+bB6bLHNQJM7EzX+Wr6ebC4CzHYOAROtyvAWbd4H4 uyWSz5pkbMUzwm7KBt0bwOKl3JEoUfn9cJt6jtLBM1erO2HCo7uuZIOvKQ4aH228reNlZ+fTaghV lflshntKWYssPIiefx1ugh2XGQwEs4UyhTYUY02muGXUKlGRqMZ55XnA0Hbcmwq2Es7jF3jpDwm7 axSudq8zOVqTsSRzqWyFG3xoRIyBX/5LzRRks6kWj1Fb8xEDjdCJfgEv+/2Rco/eVYaTCAsETqas X6E1CYfEGof+/d3YHN+V7O8eq/7lx3Q0PVUh8veptqr2mYSKItqelHWbT9dCI5B489hLg6rvHMWL L9LSXsGeRR33fr7fAbfUE39ty6NjzhNgIJEyYY4oAveCrJvvcFxGkWyXl2teTtGjvTHCYphTDpTv T01cfQzuyZIsFv+mckexsiPnmE54h6PwM76VvdoTMdwLTXbZVKOJY39ZeqB7Onz1ftvgZ2thLzgL 3xf/9RA0KHSTdFXc+KVdoUh6xGLCTonEOn8vs5G7rBOG6rOrQz3HrqJkHjscTqDv0tqooNnBn/wD TrI8dLmC14qfnEhLWPmloq/v4Ux852AcZCTFfLkSx5rEXVVVPKBF/ZEFtlTrI/CFE7193QnQpXBs 3o7LUVjc57tD7c2d1ytcRge3MCce0FE28uX2xcmmhrPeoBBA5K+9szPIXJs4q05NnSJ+WnZRYXJf hhrj0QbxChrl1QrGxH0SaSHfOKGk4TMNSXTIVaPApZKKrT4MPIqcMGb8Gca3ax/BH7vTrcAxpPex QgB+FKU/YUOicQx5CFqhh0FB6tb7K/UhqDXFHIxFWzvGeSObzpF0hU3y9CM6EoE0SnsPLzzvNfH8 Akabki7rdskUh0ZgDAUVUg0o9cQjkGbZ8KL+57WPlXHv6xU7FFz6O38dMHnrU/CywRybSZyLenSh 7Fjs4Gpr4TipmtNqQ59ZYpDm+fCi9sKNaWlpa9Zt3JIhx5ZVUcEn4G3E+7jgcMF634UXvlppMolj UY/Fk+0SUTBd3/WwhgTqMLqXG6KZmfBI/2w9z9bWzjVy76kzMpw+vt55tkIof7OOCZxdO+o5vLBq 3sRdEoHQMXcpl3XcywsvVUlDK6AhXM9kLTza/LnJlmxgHVkCb3SeK1QI5Y0f0cA+piYrHOBf+0wm 5aXN5h+UdXyZPW50+YFvGl8JL6grSNxapGCj7jTnZQoBoCwQuKSSmwzl2U5KUJr4xMiPApV7mArE x72jzqjRNKPoKw5z2Q4PAJLPHIFLYtyuw1t1rTad1AWOylt4R+OQPcqK913W4twx1KSko2gJl38e XvR2Awu4JCG4Hl74ZMHkvl1RHBbs0hD6xHWXbynfedr3PtRIcbDt+u75tjQvBVVeHwe5pE40XN5J /+MzyVyxWcin9VJ1GCjfmbhVhdKzD1NQmNrAm6afi7IT+ExtkvPnVc87ZHhRc9QLuCRCN7C07oW8 8PmDFKtJuSQCQeOvvaLOlN0XV/KtffNeqakarn50+37N8/b2jo721tpHJcWHtiSGuJlTsCis2dzU rDyAXIDtKYGmkAQnWkWvz86VISORR9Vhubrb6U3YMVGumU/UkGj9PJ6rT2SEn1N/SA6V7U1JXZOR BcbMzly/PDbY25FN14aElBYzIi1j27ZtGesWhXi52BgRISZaZJaDq5sMThyqtm1xY1PlTI3pYiSO amKij5NrEIxxcoMqB1HVXoGlDhpJ4CSpPyarcoKdLGydXMCYLjPsLc3oZIIsO4D3qns/AKG3+fMA BlFr2FpIDI5IkoOIx1CiOsGdMVLjJ1UtTs6FrzYzRq7xSIJNuhqFO/BjxixT4rDe4OV0quHYc3a+ CRmNJQyPTMBhUKO6S/+T0VBW6aneVkjDjaC2JoKiyZDkBSAu3nQY9lykjsdpNfnTd99tDKSP2Bpj GPZP1QUX/bTVlab+/SjW30BEkIiHA9VQuinNyp5lYGJnro1CEoydvPh2dCwSgTJddaeu6piXDhJr YOfJ58pySmgyh+fjbknGaHuclEBfOdgEKKMX/LOaPdN3fU88j0UfmROes0z1G1Tn6blmGqyAcb0G OLZU3K2Fgv7lWWvu3ruacLruAkebFfbF47bWylwXXSTGalftHxVLLAh67tkVLW1V+1x1gJrTdki9 0fSyuTzR2vVaB/SSqiNMIE3cKtU63ODpOGGQr6sdh23KtuIlnFIRwX2Z9poEAiEY3BwH/7V2xT7o Ole69Ffge0ADX/f1KRhRveIfvXXwfBBLX8cxTGMfDBtJUuJGQBuEloysWXe+PD1ewQMXBZsVF249 qH78uK7xxZt+uE17v4sUCAThEKIWZf6nXqFysKNsEVuT+Kd88iew9Gae45IH0M1hK/BoSLV8sbT8 Q/9iOz0ow/Es1iYJ8neoWrzDlCZokjf4br/sx3U+2EMGzsJlqUARpm3fe76yRVECDTRe3S4UCIQF t18qHoRvHxYudtOUhEaa5gGXrFnjO/cQsH/fvqPDR9bAq4M3oKk3N0IZ0M5oq41AplctnPdYKn1f //sLYIFf/OYAe0v+bGjuFVem59SDIftb72fYA0cl0ljWtsMIiM0ufarujqgMSVvp9nBnHU1JRgwX +tLb9vC3Wmjpft9aCnVpuXLgOFjArsv791wCCmkoc1YRKP52MbheDT0s/nspUH9Ny46Dho3nduWf ubApPAESf9VHl/sYQvNGYbSwI+D4pF6qHl8HDT79d5IbEx5yFIHzvT06n8acVMgxW48lLgE+OHQt ydf/UyAHRfkLwV4cPJoG1nywvbmpFZi1OQe4cm9hrJdX4BxXayGoF/0z0pZGUHo9yyW2oKJDbU53 dNie6sIYLkMDQQik0eRF370cwfI2aGihUwK4mnVlu+gzEppAhNu6GmzersytsHTBvcPgoTnNmqxL NdClLgD032yyJmJUzk1Th7mZZY1vxlBi/S03c8JsDcfgiNBf/Cf0jfftm/bKs2t8HVcBH2xYYWG0 CJR2rmPhLLaBZa9dtRP8rUvNBe7V09HS0tr+sqng6CB0rzTAURm6aGoyYPw0nq72aLfyjDtwq7lX g3IbaLtzKN6DoyGIjwDF3A22X/s3p47krgx1oFtBu+hWCMXgY6BTxJcifTeBe95QYdwxMZRZ3Q6W ue36l0X/ffTVtvi899AH/8DZud8H0Zk7AOPKdbMM1X5+MbOfmXiioqN3SIWnqP9lxcnF3nYmY1EE 8WI4lN9InuPtam1IwjtfAU9FbnhK2D3In2uqgIVE95IjLoLi4rBVwLziZw/r3kmrYnnJUBbm9cOn YuljX4djYPze1mo3DTlMFtd/6cGS2s53olG9KBH1dT4pObjMn2s2NkUQyoOegqiyh0cjk3BoJH42 0Ff9O6wwROc8+Z4U3U/3EYIQOrDLI6JEPkRNMDOwWO5nTQLnw8M/qv013tbYjvzQ5fsuVz7r6ul7 P/C+r+dVc+Xl/OXhXlzmeBTBvS74j4HBpkWMEW8izWkYGGxMMEJhjIVFr6A9+b7z+ib/GSvB2dO1 0pK7+s47QFP0pmKdkx5n2Y894EHc/WgLzy6lVSyVdJ9xH+tKyeF6zFm4OutAwdlzX5z4bGdafBDP nm00PkVAa8aagpOfepBHIhRxRtrxE+vddZFIkuW83Zd/e3Drq92L+B5bfwVsHkTSqe4pJ2/e++1a wRo/IzxlxtJj31feLyv8NMDEaGbmN3fLDsRYjPPvCeY2jq4efG8/H767C9eaOdErCZbm6OfnSMPK n7h+flzoCa3N8oxauuKTCE8OewmUFBo4yiNhqbYBHyUnxc12NCKgtPSs/WOTkhfOcWIQiQz3qEUx fhzdiX23NB4rJqoBCkc2MNDFolSeUDiKsYWluRGZwNoD7aHyBKYWEkM0YHI4ZgYkoJeRaCLVjMNh 0khaSBROz5hlakAc/yPbXw1wumHQKASaubm+/fm3q510IQZINCiUU4E9IFFojYfaFABNm5manRHn rD+xT4z/A1P+MbQNCmVuZHN0cmVhbQ0KZW5kb2JqDQoyNiAwIG9iag0KPDwvVHlwZS9FeHRHU3Rh dGUvQk0vTm9ybWFsL2NhIDAuNTAxOTY+Pg0KZW5kb2JqDQoyNyAwIG9iag0KPDwvVHlwZS9FeHRH U3RhdGUvQk0vTm9ybWFsL2NhIDE+Pg0KZW5kb2JqDQoyOCAwIG9iag0KPDwvRnVuY3Rpb25UeXBl IDAvU2l6ZVsgMjU2XSAvRGVjb2RlWyAwIDEgMCAxIDAgMV0gL1JhbmdlWyAwIDEgMCAxIDAgMV0g L0JpdHNQZXJTYW1wbGUgOC9Eb21haW5bIDAgMV0gL0VuY29kZVsgMCAyNTVdIC9PcmRlciAxL0Zp bHRlci9GbGF0ZURlY29kZS9MZW5ndGggNDU3Pj4NCnN0cmVhbQ0KeJyFwodS2gAABuDnsrV72zpR EVEEkaGAoBDCCjMQ9h5hC4iADK1272Xbx+of4513rXf97hubNI6dv4ZTfBP/+jR3nEuMz1y8gbPE Ta6Zf2sOSa6AvC0g7+C8Be/yF6z3zt9fRNsDId/+cIn7SIQOfLyM1BMxd0LsnFhxPl1F1zOUuCYl 7qk19ExLuTMy7yyu+3BO7hPIacEGPa/w44IygIuqgFDFCNXMkjoo2gyKtkLLqAmLNeEVbQRXdVGU bMfW9DGpPi41xGWGhGwnsb6bRLkxtWFKKUxpBZFWEhmlOasis2oyp7bkNq35LbQVNPaC1s5qHazO UdRRpW2qpHeW9a6ywV3BHU9111M1emtGX92E9B6B/oY50CADTZJpWpiWNdiyhvZtobYt3LZj5MAR 6VDRDhXrOjHec2Hi0I3JvgdTA2964EsPkc6M6OzIj7mjAPeYyR8zhedB7kmQPQmxp6HiaRhLLyJY fhnFCr6KYfV1HGv4JoH1t0ncw3cpbOD7NDbxQwZb+DGL+/xPuTb/cx4P+F8K2OF/ZbuXi91vxd7F Uu879/Byuf/jr5X+WWXwz+FZdfjzyrXhr9roP+uj3/WjK/4BqNyYIQ0KZW5kc3RyZWFtDQplbmRv YmoNCjI5IDAgb2JqDQo8PC9QYXR0ZXJuVHlwZSAyL1NoYWRpbmc8PC9Db2xvclNwYWNlL0Rldmlj ZVJHQi9TaGFkaW5nVHlwZSAyL0Nvb3Jkc1sgMCA0NjggNzIwIDQ2OF0gL0V4dGVuZFsgdHJ1ZSB0 cnVlXSAvRnVuY3Rpb24gMjggMCBSPj4+Pg0KZW5kb2JqDQozMCAwIG9iag0KPDwvVHlwZS9Gb250 L1N1YnR5cGUvVHlwZTAvQmFzZUZvbnQvQUJDREVFK0NhbGlicmkvRW5jb2RpbmcvSWRlbnRpdHkt SC9EZXNjZW5kYW50Rm9udHMgMzEgMCBSL1RvVW5pY29kZSA1MjggMCBSPj4NCmVuZG9iag0KMzEg MCBvYmoNClsgMzIgMCBSXSANCmVuZG9iag0KMzIgMCBvYmoNCjw8L0Jhc2VGb250L0FCQ0RFRStD YWxpYnJpL1N1YnR5cGUvQ0lERm9udFR5cGUyL1R5cGUvRm9udC9DSURUb0dJRE1hcC9JZGVudGl0 eS9EVyAxMDAwL0NJRFN5c3RlbUluZm8gMzMgMCBSL0ZvbnREZXNjcmlwdG9yIDM0IDAgUi9XIDUz MCAwIFI+Pg0KZW5kb2JqDQozMyAwIG9iag0KPDwvT3JkZXJpbmcoSWRlbnRpdHkpIC9SZWdpc3Ry eShBZG9iZSkgL1N1cHBsZW1lbnQgMD4+DQplbmRvYmoNCjM0IDAgb2JqDQo8PC9UeXBlL0ZvbnRE ZXNjcmlwdG9yL0ZvbnROYW1lL0FCQ0RFRStDYWxpYnJpL0ZsYWdzIDMyL0l0YWxpY0FuZ2xlIDAv QXNjZW50IDc1MC9EZXNjZW50IC0yNTAvQ2FwSGVpZ2h0IDc1MC9BdmdXaWR0aCA1MjEvTWF4V2lk dGggMTc0My9Gb250V2VpZ2h0IDQwMC9YSGVpZ2h0IDI1MC9TdGVtViA1Mi9Gb250QkJveFsgLTUw MyAtMjUwIDEyNDAgNzUwXSAvRm9udEZpbGUyIDUyOSAwIFI+Pg0KZW5kb2JqDQozNSAwIG9iag0K PDwvVHlwZS9QYWdlL1BhcmVudCAyIDAgUi9SZXNvdXJjZXM8PC9YT2JqZWN0PDwvSW1hZ2UxOCAx OCAwIFI+Pi9FeHRHU3RhdGU8PC9HUzI2IDI2IDAgUi9HUzI3IDI3IDAgUi9HUzEzIDEzIDAgUj4+ L1BhdHRlcm48PC9QMzggMzggMCBSPj4vRm9udDw8L0YzIDMwIDAgUi9GMSAxMSAwIFIvRjIgMTQg MCBSPj4vUHJvY1NldFsvUERGL1RleHQvSW1hZ2VCL0ltYWdlQy9JbWFnZUldID4+L01lZGlhQm94 WyAwIDAgNzIwIDU0MF0gL0NvbnRlbnRzIDM2IDAgUi9Hcm91cDw8L1R5cGUvR3JvdXAvUy9UcmFu c3BhcmVuY3kvQ1MvRGV2aWNlUkdCPj4vVGFicy9TL1N0cnVjdFBhcmVudHMgMz4+DQplbmRvYmoN CjM2IDAgb2JqDQo8PC9GaWx0ZXIvRmxhdGVEZWNvZGUvTGVuZ3RoIDk1Mj4+DQpzdHJlYW0NCnic nVZdb9pKEH1H4j/Mo12VZb/XlqI85ONWuRJSqqLch6QPjlmIFbCpbajaX99ZY1Jss7lVn8Cw55yZ ObMzhuk9XFxMZ9d3N0AvL+Hq5hq+jUcUKKGUMs6pAcMpKEmhtOPRfx8gH48YrN7OUKoZlZ1Dyw/j 0efxCG5n1wAnAuy3wKTFqlibVisSjJ3T4oLEMaAaaEMYjUHFilAGnGitGaSb8Wh6t0lWlkVwU8A5 Yd4KTz994RpWVZsBiyMScUcbmwgEw08BImLEqLc8BlxiUCUuJZNnIndqplGb3id1bcsc0gqpRARV mju45IbwBomimup3qydb4as5Ev4jALnnS5eJKw0DjbFIzELHhMUw35zqU5ctPjLRPn4ajx4vqDBX l19h/u94dIucB17W5404loOf8j4Gt3ub1xDKIH1J8tyuKwiZCJLSQqiCbVImYZf2yCWkJJHuck18 Z5UgWNbO2X1W1rtknf20CxQHD1IaQfoRZznWHzHlbhuKoK48UIXZxlEXeiozMEUNTCHYD2eNEZTw ltNf+gH6WP4TdHDviT7WRJve2dJivvusCCc82FXrH76iccqIUl3sOttk4QTL1ZZbBnUBNqtfHGcJ oQkYhovfIYyCogRJY3zQEMaHxkBA0xt/2mM8NiQ6im/RL+H1mHFFDOsiFsXGZZlkuTdHtLUHetdd 3Xe3601MiWAYtsZRxH47K88520XiGCNYg1NkcFNsMHRvwiiGY6mDoIAVyq11Hi0qqPDJ7rFsrghr sIdLOlHODPdbe1NVsESvbJK6315gtbNVfdYjOWjGY9hCEByYhyAeZq4xnhrS3NbfC3fLXqeLzIXz 6ktHILvUXabnJH21+cJ3NyXThEenEGi2iIZ5+hh89E4DvFSqo4Q/O8Q3u9n5MBHunF50Xv4oJqJ3 1tapb8CwmOhBDko2EZGn0AcTOJf4mSTebV/zR+3LYjSV/037niKD+zJJ6yx1vYjNFzLVjI9mSxRL qAvsu9r94esHgd3WZcx3m+emt0tABuymh1mFRBBqXDXFLl+A+1NQVKAeWs0ighu/Q+tbOMekDCXy eFY15E77KVg0sWyxQ7N8BUUOD5jSDNIiX2arXZnUWeEbPFJHBFdAh9rrtTSK9M6+63LUcfnsEmlX EMMucv/8P2fc4xQa1+KQE5eNVPq4Kg/vVM27RXC32ZbF3mL1nEvGvTHg93wwaN78p4aIDttjcH14 ufBePBER3YN8SZN1M+ues3VW/xhMNX4uE+VusOkSDarzCwBdWN8NCmVuZHN0cmVhbQ0KZW5kb2Jq DQozNyAwIG9iag0KPDwvRnVuY3Rpb25UeXBlIDAvU2l6ZVsgMjU2XSAvRGVjb2RlWyAwIDEgMCAx IDAgMV0gL1JhbmdlWyAwIDEgMCAxIDAgMV0gL0JpdHNQZXJTYW1wbGUgOC9Eb21haW5bIDAgMV0g L0VuY29kZVsgMCAyNTVdIC9PcmRlciAxL0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGggNDU3Pj4N CnN0cmVhbQ0KeJyFwodS2gAABuDnsrV72zpREVEEkaGAoBDCCjMQ9h5hC4iADK1272Xbx+of4513 rXf97hubNI6dv4ZTfBP/+jR3nEuMz1y8gbPETa6Zf2sOSa6AvC0g7+C8Be/yF6z3zt9fRNsDId/+ cIn7SIQOfLyM1BMxd0LsnFhxPl1F1zOUuCYl7qk19ExLuTMy7yyu+3BO7hPIacEGPa/w44IygIuq gFDFCNXMkjoo2gyKtkLLqAmLNeEVbQRXdVGUbMfW9DGpPi41xGWGhGwnsb6bRLkxtWFKKUxpBZFW EhmlOasis2oyp7bkNq35LbQVNPaC1s5qHazOUdRRpW2qpHeW9a6ywV3BHU9111M1emtGX92E9B6B /oY50CADTZJpWpiWNdiyhvZtobYt3LZj5MAR6VDRDhXrOjHec2Hi0I3JvgdTA2964EsPkc6M6OzI j7mjAPeYyR8zhedB7kmQPQmxp6HiaRhLLyJYfhnFCr6KYfV1HGv4JoH1t0ncw3cpbOD7NDbxQwZb +DGL+/xPuTb/cx4P+F8K2OF/ZbuXi91vxd7FUu879/Byuf/jr5X+WWXwz+FZdfjzyrXhr9roP+uj 3/WjK/4BqNyYIQ0KZW5kc3RyZWFtDQplbmRvYmoNCjM4IDAgb2JqDQo8PC9QYXR0ZXJuVHlwZSAy L1NoYWRpbmc8PC9Db2xvclNwYWNlL0RldmljZVJHQi9TaGFkaW5nVHlwZSAyL0Nvb3Jkc1sgMCA0 NjggNzIwIDQ2OF0gL0V4dGVuZFsgdHJ1ZSB0cnVlXSAvRnVuY3Rpb24gMzcgMCBSPj4+Pg0KZW5k b2JqDQozOSAwIG9iag0KPDwvVHlwZS9QYWdlL1BhcmVudCAyIDAgUi9SZXNvdXJjZXM8PC9YT2Jq ZWN0PDwvSW1hZ2U1IDUgMCBSPj4vRXh0R1N0YXRlPDwvR1MyNiAyNiAwIFIvR1MyNyAyNyAwIFIv R1MxMyAxMyAwIFI+Pi9QYXR0ZXJuPDwvUDQyIDQyIDAgUj4+L0ZvbnQ8PC9GMyAzMCAwIFIvRjEg MTEgMCBSL0YyIDE0IDAgUj4+L1Byb2NTZXRbL1BERi9UZXh0L0ltYWdlQi9JbWFnZUMvSW1hZ2VJ XSA+Pi9NZWRpYUJveFsgMCAwIDcyMCA1NDBdIC9Db250ZW50cyA0MCAwIFIvR3JvdXA8PC9UeXBl L0dyb3VwL1MvVHJhbnNwYXJlbmN5L0NTL0RldmljZVJHQj4+L1RhYnMvUy9TdHJ1Y3RQYXJlbnRz IDQ+Pg0KZW5kb2JqDQo0MCAwIG9iag0KPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0xlbmd0aCA4NTA+ Pg0Kc3RyZWFtDQp4nJ1WXW/TQBB8j5T/sI9n1Fzuy3e2VFWiXxCkUFAjQCo8uOklteTYxXZb9d+z 5zqQi+1SeLIj7czsjHfvAtNPcHg4nZ/MToEdHcHx6Qn8HI8YMMoY40IwA0YwCBWD0o5HX99APh5x WP+uYUxzpryi1Zvx6PN4BGfzE4AdAf5HYNJiw1ibViuSnPdpCUnjGFANtKGcxRDGIWUcBNVac1hu xqPpbJOsbQinBfTpilZ3+u5SaFhXrQEeRzQSjjU2EUiOTwky4tSEv210uGQnJKEUVz2NOzXTqE0/ JXVtyxyWFVIpAdUyd3AlDBUNEkU10y+Gp1rh4wUSnktA7sXKOXHJcNDYi0IXOqY8hsVmV585t/iT y/bnu/Ho6pBJc3z0AxYfxqMz5Hzm5fu8kcA4xC7vFfloHyHwkdtyLiMac7/8fHZ+MVQeRVSGfvlk qDbWVEu/9jqp7A0EXBL7YPMa3xhZ3iZ5bjMIYvL2OJBkBkkWTCTJikf3qCCIyKpwryUEmhQPwUQQ W+47es6C4uftzUNqakzbBWfsIFAEZwEb4M+toPBQRkKFVO9RNE0jh82qAZRUqOyDdgU68xLuz4vv I2ZUcmyCcaraNN1EqL6J8JG4ghSHZBdJZpu7sniwsErSMrfVkAdhBJWRD33RhH6VCaG1W93/MLGL JG8zHJF2PErY3Gd1epdZwK9yV6ZFmdapHfw4Ec6m8uleNGY6xjqTtjUnMTP1N3Md9NbgDposbnEq 7eDqhpwy6SPSfFnaxC1Is2eGZOkmrZspT1xagdsnXKYQd2lTlNYt1Jd5hZEdwONturwFrLi2uV2l ddW7Yf1dM0nDbQ9ZUq6ta8GRV09VbTftHhuS5DewzIr7GyjubJnUab7uqaruXSMhSTot7Olyo6jZ 6s7TsnG+theXQ/PMQipjH3YwuPYcZ2RP46zMEtdmvr7AoPJvjc988ASQVL5STIZY5ddeXD4MFceC qlcSK/w0kV/7vokp+zIfguCJHQsf82+nLcdTL9Sv2avI2yt3EdE4Up2b0ghQod7eI8//BppbcXuS 4QTjvE8MOWve3dUykB0zVHpsV+RkewMN5IF3pN6DXC6TrInxOs3S+gm+E/E96GQkev0gXcR9uk5G vwD1lhYuDQplbmRzdHJlYW0NCmVuZG9iag0KNDEgMCBvYmoNCjw8L0Z1bmN0aW9uVHlwZSAwL1Np emVbIDI1Nl0gL0RlY29kZVsgMCAxIDAgMSAwIDFdIC9SYW5nZVsgMCAxIDAgMSAwIDFdIC9CaXRz UGVyU2FtcGxlIDgvRG9tYWluWyAwIDFdIC9FbmNvZGVbIDAgMjU1XSAvT3JkZXIgMS9GaWx0ZXIv RmxhdGVEZWNvZGUvTGVuZ3RoIDQ1Nz4+DQpzdHJlYW0NCnichcKHUtoAAAbg57K1e9s6URFRBJGh gKAQwgozEPYeYQuIgAytdu9l28fqH+Odd613/e4bmzSOnb+GU3wT//o0d5xLjM9cvIGzxE2umX9r DkmugLwtIO/gvAXv8hes987fX0TbAyHf/nCJ+0iEDny8jNQTMXdC7JxYcT5dRdczlLgmJe6pNfRM S7kzMu8srvtwTu4TyGnBBj2v8OOCMoCLqoBQxQjVzJI6KNoMirZCy6gJizXhFW0EV3VRlGzH1vQx qT4uNcRlhoRsJ7G+m0S5MbVhSilMaQWRVhIZpTmrIrNqMqe25Dat+S20FTT2gtbOah2szlHUUaVt qqR3lvWussFdwR1PdddTNXprRl/dhPQegf6GOdAgA02SaVqYljXYsob2baG2Ldy2Y+TAEelQ0Q4V 6zox3nNh4tCNyb4HUwNveuBLD5HOjOjsyI+5owD3mMkfM4XnQe5JkD0Jsaeh4mkYSy8iWH4ZxQq+ imH1dRxr+CaB9bdJ3MN3KWzg+zQ28UMGW/gxi/v8T7k2/3MeD/hfCtjhf2W7l4vdb8XexVLvO/fw crn/46+V/lll8M/hWXX488q14a/a6D/ro9/1oyv+AajcmCENCmVuZHN0cmVhbQ0KZW5kb2JqDQo0 MiAwIG9iag0KPDwvUGF0dGVyblR5cGUgMi9TaGFkaW5nPDwvQ29sb3JTcGFjZS9EZXZpY2VSR0Iv U2hhZGluZ1R5cGUgMi9Db29yZHNbIDAgNDY4IDcyMCA0NjhdIC9FeHRlbmRbIHRydWUgdHJ1ZV0g L0Z1bmN0aW9uIDQxIDAgUj4+Pj4NCmVuZG9iag0KNDMgMCBvYmoNCjw8L1R5cGUvUGFnZS9QYXJl bnQgMiAwIFIvUmVzb3VyY2VzPDwvWE9iamVjdDw8L0ltYWdlMTggMTggMCBSPj4vRXh0R1N0YXRl PDwvR1MyNiAyNiAwIFIvR1MyNyAyNyAwIFIvR1MxMyAxMyAwIFI+Pi9QYXR0ZXJuPDwvUDQ2IDQ2 IDAgUj4+L0ZvbnQ8PC9GMyAzMCAwIFIvRjEgMTEgMCBSPj4vUHJvY1NldFsvUERGL1RleHQvSW1h Z2VCL0ltYWdlQy9JbWFnZUldID4+L01lZGlhQm94WyAwIDAgNzIwIDU0MF0gL0NvbnRlbnRzIDQ0 IDAgUi9Hcm91cDw8L1R5cGUvR3JvdXAvUy9UcmFuc3BhcmVuY3kvQ1MvRGV2aWNlUkdCPj4vVGFi cy9TL1N0cnVjdFBhcmVudHMgNT4+DQplbmRvYmoNCjQ0IDAgb2JqDQo8PC9GaWx0ZXIvRmxhdGVE ZWNvZGUvTGVuZ3RoIDgwNT4+DQpzdHJlYW0NCnicjVVLb5tAEL5b8n+YI0TKel/sghTl4DivqpHS xkoPUQ8ELw6qgRTWbdJf31mME2xjJxcjDN9jvtkZYHQLJyejm7PrCdDTUxhPzuD3cECBEkop45xq 0JxCIClUZjj4cQTFcMBg/vYOpYpRufFSejQcfBsO4PzmDKAjwN4FjltsECndaoWCsT4tLkgUAaqB 0oTRCIIoIJQBJ0opBkk+HIyu83huWAiTEvqEeSs8urzjCuZ1WwGLQhJyRxvpEATDqwARMqKDtzp2 uMROSlxKJnucOzXdqI1uY2tNVUBSI5VUUCeFg0uuCW+QKKqoOpiebIXHUyS8EIDc09RV4qJhoNCL xCpURFgE07yrT121eMtEe3s5HDycUKHHpz9h+mU4OEfOFS/b5g05xsG7vA/e7f0V+MfSy0v/WHgz A0mZP2b+MfcKU4MfefbJgK+8R1NbdzULk5vC4qPQK1OHAV96V/c3yBJ5cTEDv88HwWh7vQhFtG68 gDtIAcY/TZytLZo1jjFOqNjA0QbR1d0JPNgOfNNMRIlgaIYyIttgXKSyL9JNJB5igil3kc47JgI2 /mVcPvV2Imssx1I028TGsz9xYXECoEzBdSGPm168upTxL9eNp7ia/Y0rswp/T0wrX1zjaK25/2SV XcaL7F9ss7IAX3upadjt0pFxdGqfYusemBdHntXNTYaHvSysyd07z2UVV68fyUpBwrXsyq7Dosqe JKggcgt2sJ/qUwPEaUD0ezs/PyEdoHdbWjzvmH4WL1wRrhFpMywV1Nm8yNIsWfXILl7dwGRFUpm4 NjgJLPBMmrqHWZKZInl1U9MzI1vyTAsiWvlnU/liLZjHRbI3Qx64qe5iD0aodyLcmdE2RiYkkR/F uG/AO2Dv+x7rkSYi2nzVzJYJBm32RsVC6fZAF5OWTUr2ucI9lRXNusKz+3W1zZYvyAcHwpdcEaE2 GC8q58GM8fdusgcWsJBs1dm/AvvSwc8f/n6iW+FGt3BpKBKFu93SHGSg1tt99WVsvhDe+cuzwTKq LDd4nnDFLHC9hM36v1s2g42TbfdFE0REhF3qHrv/AZjX05wNCmVuZHN0cmVhbQ0KZW5kb2JqDQo0 NSAwIG9iag0KPDwvRnVuY3Rpb25UeXBlIDAvU2l6ZVsgMjU2XSAvRGVjb2RlWyAwIDEgMCAxIDAg MV0gL1JhbmdlWyAwIDEgMCAxIDAgMV0gL0JpdHNQZXJTYW1wbGUgOC9Eb21haW5bIDAgMV0gL0Vu Y29kZVsgMCAyNTVdIC9PcmRlciAxL0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGggNDU3Pj4NCnN0 cmVhbQ0KeJyFwodS2gAABuDnsrV72zpREVEEkaGAoBDCCjMQ9h5hC4iADK1272Xbx+of4513rXf9 7hubNI6dv4ZTfBP/+jR3nEuMz1y8gbPETa6Zf2sOSa6AvC0g7+C8Be/yF6z3zt9fRNsDId/+cIn7 SIQOfLyM1BMxd0LsnFhxPl1F1zOUuCYl7qk19ExLuTMy7yyu+3BO7hPIacEGPa/w44IygIuqgFDF CNXMkjoo2gyKtkLLqAmLNeEVbQRXdVGUbMfW9DGpPi41xGWGhGwnsb6bRLkxtWFKKUxpBZFWEhml Oasis2oyp7bkNq35LbQVNPaC1s5qHazOUdRRpW2qpHeW9a6ywV3BHU9111M1emtGX92E9B6B/oY5 0CADTZJpWpiWNdiyhvZtobYt3LZj5MAR6VDRDhXrOjHec2Hi0I3JvgdTA2964EsPkc6M6OzIj7mj APeYyR8zhedB7kmQPQmxp6HiaRhLLyJYfhnFCr6KYfV1HGv4JoH1t0ncw3cpbOD7NDbxQwZb+DGL +/xPuTb/cx4P+F8K2OF/ZbuXi91vxd7FUu879/Byuf/jr5X+WWXwz+FZdfjzyrXhr9roP+uj3/Wj K/4BqNyYIQ0KZW5kc3RyZWFtDQplbmRvYmoNCjQ2IDAgb2JqDQo8PC9QYXR0ZXJuVHlwZSAyL1No YWRpbmc8PC9Db2xvclNwYWNlL0RldmljZVJHQi9TaGFkaW5nVHlwZSAyL0Nvb3Jkc1sgMCA0Njgg NzIwIDQ2OF0gL0V4dGVuZFsgdHJ1ZSB0cnVlXSAvRnVuY3Rpb24gNDUgMCBSPj4+Pg0KZW5kb2Jq DQo0NyAwIG9iag0KPDwvVHlwZS9QYWdlL1BhcmVudCAyIDAgUi9SZXNvdXJjZXM8PC9YT2JqZWN0 PDwvSW1hZ2U0OSA0OSAwIFI+Pi9FeHRHU3RhdGU8PC9HUzI2IDI2IDAgUi9HUzI3IDI3IDAgUi9H UzEzIDEzIDAgUj4+L1BhdHRlcm48PC9QNTIgNTIgMCBSPj4vRm9udDw8L0YzIDMwIDAgUi9GMSAx MSAwIFI+Pi9Qcm9jU2V0Wy9QREYvVGV4dC9JbWFnZUIvSW1hZ2VDL0ltYWdlSV0gPj4vQW5ub3Rz WyA1MyAwIFIgNTQgMCBSIDU1IDAgUl0gL01lZGlhQm94WyAwIDAgNzIwIDU0MF0gL0NvbnRlbnRz IDQ4IDAgUi9Hcm91cDw8L1R5cGUvR3JvdXAvUy9UcmFuc3BhcmVuY3kvQ1MvRGV2aWNlUkdCPj4v VGFicy9TL1N0cnVjdFBhcmVudHMgNj4+DQplbmRvYmoNCjQ4IDAgb2JqDQo8PC9GaWx0ZXIvRmxh dGVEZWNvZGUvTGVuZ3RoIDEwODE+Pg0Kc3RyZWFtDQp4nJ1WW0/jRhR+j5T/cLRPkxUMcx+7QkgF tux2RUW7CFZCfTDxxLhKbGo7UPbX94xtwE7sgPYlscdzzncu37nAwQUcHh6cn3w5BXZ0BMenJ/Dv dMKAUcYYF4JZsIKBVgwKN51cf4RsOuGQvNxhzHCmepcWH6eTP6cT+HR+AtAB4K8A+62sDo1tsQLJ +RCWkDQMAdHAWMpZCDrUlHEQ1BjDYb6aTg6+rKLEqRBOcxgCFi3wwdk3YSApWw94GNBAeLWhDUBy /JcgA06tfvFjS5fcipJQiqsByz2ardEOLqKqckUG8xJVaQHlPPPiSlgqakkENczsjJ5qgY8vUeFv ElD35cJ74kPDwaAtCr0wIeUhXK66+Mx7i69ctq9n08nNIZP2+OhvuPx9OvmEOhu9fFNvIDAcoqv3 hvzhymomiYthFpKHtKjW0TL9EVVpPtuXJPOn90X+kMauhJl9vYECdygXFfFjVDiYDYFTjOegAdJQ a1sDao0zRWrY2b4gCF3Duv+qmSYuK/G99AdVvgnzrFcGmm6oTdbeMUXKERGlNTWqL9NVv5UzvZmz vmsho5KjDYxT1cbWZ0UNZaUviXVAMVFdSXJSRwLDYEiWP0KxzsZcFzKgsi/83dXCYwJWUxn0JUaV B4zajbsXRY55/6fGmFd7gDH+enW+B1f4cH5d213UH8HfK8ZUa7Rbb6j+/OQ5d+8KL341Img4p1he 77K/Da2w2GCe76ZIqNhBvgBPX6h5Aou8gNjdrpMED9MsQduVt12T2N0v86eVN8xl1ag3BjtbH6dC vahpzAuJkVV9iZ30M++in2cD/xn2dQTJr2PRxPaNfaN7dVn6JI+GXxvK+rqj5TJ/xGoOyHWaxf7R YpDhw/cLT6STfHXf9oDbdJlWTzDjiqzy2I3GPaCh6iF8GLtqkXD9qzsDbt8XcCa91p+JeEeSXLr5 HVwU7iF1j5DlozwTgaSqj0qenCdn5XtFU3hR/FTXHx54XvtnbOHxet50VkvWpduD23UFd1H5Rulw qzxPG6RVnRssHt9X0yRLF+k88kWhSRJhXUGa+aJarLMaKmoyGJAoi0cLRyjKTR+m8WKZRg0HRvsA 9vwNyZ0JDbaG7tZ8agcvx6GgzWtSh0fr2HTrSpPzHL3BCkmzRV63xlXUZMEQ/6tI1owpP385Gx6G v+AnTko3WgShomHf6qFIfLuPspdghJ1gvHrPNvT4rQjbEx4rDkWycfDXWTNtsjewOBsCU9j5xLjR W9DeuiBEAU4DC4r76Y2PL3vW7p0H91rPs0GnbuokuHgXeTgf8IFrSzXv606ed7Ld3nizRABhSBWe ew6bLW82XDDI9+AV5Q22c9GjO+5IBpO7TXcrcBUyz/tgs0s39mNPQubeYf9QOPQdstJ3p7rd71uC 8xNXRzzEwOHsR6p2d8ex5cNguWvZRRxw438btsF3DQplbmRzdHJlYW0NCmVuZG9iag0KNDkgMCBv YmoNCjw8L1R5cGUvWE9iamVjdC9TdWJ0eXBlL0ltYWdlL1dpZHRoIDE2NS9IZWlnaHQgNjcvQ29s b3JTcGFjZS9EZXZpY2VSR0IvQml0c1BlckNvbXBvbmVudCA4L0ludGVycG9sYXRlIGZhbHNlL1NN YXNrIDUwIDAgUi9GaWx0ZXIvRmxhdGVEZWNvZGUvTGVuZ3RoIDk5MTc+Pg0Kc3RyZWFtDQp4nO1d BVxU2fdfu9decxFExO5uEUQRDDqku7u7u7tmGIahWxpUMDFA7BYwUBFQsQP4f2eejgiDi7vG77/r +ZzP/dy579xz49x74r373vz22y/4Bb/gF/wjmDd33sIFi5csXjJ69Oif3Zdf8C2hb9++mzZtsrOz z8jIrK6qfvfu3du37560vLt353HrE+TfouTevYZDFYeCgoIlJSUnT578s7v8C74aBgwYICQklJ6W /vLlq/fv30Omz5+/uH//weXLV44fO56VmRsTTc7bV3jq1OmrV64+ePDwxYsX7+gAyvdnz543MzP/ Jff/FzBw4EB9Pf2mR81tbe1v3rxtbn589cr1QxVHsLspFEpISKi7u7utra2ZmZm9vb23t3dkZGQi LTE3N/fYscrr128+fvwUtd6/b2t7356aksbJyfmzB/QLeoS9e/fevHGr7X3HmzfvILg7d+5evXr1 zJkzx44dKywsTElJiYmJ8fPzc3JysrGxcXV1DQwMjI2NRXlBQUFFRcXp06ex/aEEoAog8fa2jvfv 3oeGhk6YMOFnj+wXfAabN/NUVZ15/7797Zt3z5+9fPz4SUvL4+bm5vv379+8eRNyPMOA0tLSzEz6 NoeUkdJotOLi4uPHj58/f766uvrs2bO3bt1qbGx89uwZNHt7ewcB+Ono6Dh48OCfPcpfQAcLM6u3 b9pev37b+vTZ45Ynz589hw/W3t4OiwzZnT9/Yf/+/QEBAXp6erKysrt27eLj41u/fj0PD8+OHTvE xMQUFRVNTEzi4+MPHz5cV1f/9OnTV69etbW1dXSG9o5Tp079+eefP3us/2nAjqNSk5+1vnzy5Nn9 +w8fNT56/vw5hPPmzZu7d+9iw2Ivk8nk4OBgbE9DQ0N5efk9e/Zs3bqVn3/b9u0CO3fulJCQUFNT g7hdXFyCgoJAXFZWBoWA3f2ZtNs6IP97dxtWr179swf9H4UpU6Yeqjje0tL68EHjrZu10NvYzhD3 7du3ob0h6PT09OTkZEgwLDTcytJOTlZRUlJaUkISe1xZWRmbGrZeWnqvjIyckqKqi4tHbCwJ6j07 O7uoqAjmvqGhgZA1djrda3/fBmPx6sUbeTmFnz30/xzM4p5dc+ZS48Omutrbly5drq+nK+E7d+5A 0IkMgAOWkZERFBiioaED+aqrq2trayOFoOXk5FCCnY59raWlpa+vj90NVa+goGBkaJqUlAKDXlJS grSyshLmAKEc1PvLFy9fv4baePv6VZudjePPnoD/EEz4Y8LRI6du19+9ePEyTOqVK1ewo6uqqtLS 0qKjo+Pi4rBJI8Ij5GTlIFyIdffu3Zs3b4YeXsmA5QxYsWIF8RPlW7ZsAQ2IIXosCU1NzZycnPz8 fKRZWVlw5KA3WlpaGhsfNTe3tLa+eNzyUllR/WdPw38ChgwZmp627/r1W9XVNYieYKAhDnhZiJhg fMPCwiIjoqGlsX/hhkGOEOuiRYtmz549ffr0qVOnjh8/vjM3lHBwcHBzcy9cuHDZsmWgR11YeSUl JR0dHcgaK4du0EvLmpqa4A/U1dU9uP+QoVUebt8m9LMm4b8DVlaO1dXnDuw/mJSUlJubiz2YlZll ZmZmZWXl4OBgZGgGf1tISGjdunULFizg4uKaMmVK75lD7oTQofCh/MXFxWOi6aE6HDnojYsXL548 efLo0WNYYFWna4oLKyZMmPj9RvoL+LZsLyo6kJ9f6OnpaWpqamxsDJu7lQGIsNasgZDXQW9v3Lhx 7dq1UNRLGbBkyRKkffv27U0Tw4YNg9ChE0RFRVVVVVFRRkZGREQESwg/3d3d7e3t7ezsvb19HOyc 1FS1lnyEpZ8DSqA3vveE/Ith+PARkeHk8vIKe3uHoNDQK7W1HV8Ddo5f4V+xsbFB6HPnzqVSqV/V CuB6ff21+vq0nJwJE3/t/b8PSgpaRYWlaWnpEDe2MzUx8Xpd7dVbN89duVx9/tzpc2erzp1Fpjte un4NUoCDvXrNmt43x87OfubMGVS8cvNGd55o6zQDkUcHLt+4js5cr68F8aUb12BcBgwY8P2m4l8P kyZO8fUJKSku8/f3hzHV0NCAUT56/Pj9R48aGhvr7t69Xlt77datG3V1LBH+NF1wN26MHTu2N83x 8/M3Nzejyq3bt8G5CzeiLaS4eruhAX140NR0v7HxTkNDTU3Ntm3bvvds/OtBZI9MVGRseHiEr69v YGCgq6srLOOsWbNu1tY2tjQ/ffEc2Pz0SdOTxy2tT4GPn7USSPxEOaFpEVv9ZVvw+gjih81NYA62 BEOCFbMVtNj68gXK8fPBo0b47YWFhdAJ338y/uUwbux4C3OHjPRMSNnb2xsbXEtLa82aNRMnTsRW etj06HHr05dv37TR722zQPqdsY6Ot+0fboPr6ur21BD8NKwHguzZyxev378j6jD5MHm+bXv/4s2r Viyz58+aW1oQoGEdDh069EdOy78V1q/b4unhGxkZ7ezsDHGHhYYhVuLh4Vm2ZDlMJAzlkydP3nd5 qNEzvHnzBm5z91YQm1+/fr33Lllbe/vr168bGxsvX76MaP3HT8u/Evr06aMorx4TQ7a1tXNyckII bGhoiGhr9+498Jw5OTkRYcXFxT179qyd+czyr+Dq1au///5751YQaoHDV8i6re3FixcNDQ2HDh1a tGjRlMlsf06d9rOm6N8EkyZN1dE2iokhOTg4QpkHBARgX2/atGn7NkHMMyz44MGDR44cWV5ejvnv vcQTExMJ/lgtiOJ7L+gOhpMPfQI3jUKhjBs3butWfsEdO3l4tnfpOWwNAnA+Pj4E7GoMQGbt2rVz 5sz5YbM3Y8YM5j0BZBBd/rCm/x4sXbzK2Mjczy/A0dERytzNzQ1bG4HYtGnsUL/wtAmLycXFBVUM 7dp7ievo6IwfP37//v29FzSYwxY8evSotrbWyMhozJgx6AlD2/ByzZiLYEFKSioiIuLUqVMg+zIr 9DYhIQF9+PJ9v2XLlp3qBMnJyRGsQEjo0x3d0aNH6+nplZWVYU12b/fly5clJSUKCgq9vO/0g0FQ QMTGmn4ji9DkmB9sbWlpmUmTJrGxsQ0fPpxJCYMOQbx9+7aXsoNE4GJ9lawxVw8ePKiqqoKGQYsS EhLwFZFHr86dO9d7Vl0AFmHdunUsh6+trd2bjoEMxPPnzyeTyehkbxpFh//XDuPBcO+VUXF2cnNk aHKEYJheiHuHgBA2JhRpF2dYX1//8ePHULZ/e+Z7AhhrGPc7d+7AdccyGzsWjY+DhrSzs2M5vRAB qmDt0R+evnyJpYVefVnzREdHDxkypMsMQAP0pnv8/PyIH/9SpXSBmzdvjho16seJ869gxIiRigoa vj7084Tu7u4w3JsZMG0aB+w14qZBgwZ1qRIVFdXa2tr19BEraO9ob2v/CzIQvH7zGtjCiLbQB6LF aWzTIOuLFy8SZG/evgEN0rf0k+z0o1MwK4TOh99+6dKlGzduQC1A7u10kbcTTb9vew9iVESG4HPs 2LEuEr916xbRDQLphyw+4rv379AiURF6vvvomGy7l6PdDsaaxMT+OHH+FcDj3Suj5ObmAZMNhwqx LWQNpd2vXz/IGlEYMl2qQL0XFBbcbbj3qLmJwObHLZ2xqaW5EcWMDHGVIMPPzvn7Dx/cuXe3tr7u Vl3t1WtXL166KCYmBv79+/dHCiVDbGo0VH/nNijv3W9AlYePGgmEcAsLCwUEBAhzg03Ey8sLoTAb IrrxoPFhw4P7qA4kxOHn788cy9Q//wQNUYVA5qCARHUUPn76BCkaRWdu370DVuBJjIVZkUBmu+gq 6t6933Dt2rUfKM+/AM7p3HKyKp6eXpA1Im4IHYZSVJQ+7QMHDuzJ2Zg8Zcr+iopzly9Xnz9fc/Hi 2UuXuuCZCxdwCUhkkBJkSIkq1efOVVZVHT1xovzIkdKDB5NTU7lnzfqNYVyQLli4ELJuffXqRFXV ierq0zU1RC0CzzJSWnLykI+GhqgFmDN37vkrV4gOfNbouXMnq6tPnTlT39BQdfbspI8vNfBu3fqw uRk0RG+ZyKwOBP0JRlcPHjpUfOAAhUbLyMnBzzPnzxPMCWImMseLilXnzl28ehUO5/eWYy9hFvd8 eTkVH29fyNrPzw/mG3tEQUGRuMqcxu6wctWqAxWHyo8cPXTs+OHjld0R5UzsXFh+5BgyBw8fKSrb n1tYlJ2Xb+foNGLECCZnBOzQ6k1Pn5VVHDpw6HDFUTo9UlREeqTyBLD63IXp06ez7GFeYRFaASWz aSJF9f0Vhw6iw8crN2zaRBBr6+o2tjzFpc697YKl5RUFJaXpObk7BIWYnsySpcvQty6jY44RrRN4 5MTJk1VnJv7PPLmbO2fR3r1KELe/v39QUBACMYSxamq9OjgkLiVddKCioOxAfun+XmJeSVlecSnS 3KKS1MzspPRMUQnJLmz1jIxfdXTkFBSDhl6luHRfUSlSonp+yf7z125m5xf11KuT5y4UlB5Alc4I VjmFxcgUHSgvKT/Ew8tLEHsHBB09XY3yHrtaXJqWsy+KTOGcMYOowlxg1vYOaOhLIy0pAwGa6+4f /iyYM3uR7F4lTw+vYAZgdyPO1dDQ6GV1/7CI1Ny85Ozc3mNSVg4tMzshPTMkmjRv4aIuDCdPnXrw xGnwTMzIBjHSRKyKrByiIvJp+/Iv3KpvbGw8zYBTnwNK7rQ8jU9N746U5NS45FRkUnL2bdhEj/IG DBxITc8EQ7Bl2U+UowOU1LRNPFu6j11MSvoLYye6nZCRFU6O/2ci+pYwc8Y8GWkFdzePsLCw8PBw Hx8f+EgqKqp/WRErNj4+vvldByU1g5SU2nskJ6eRktLsXDzGsHpUKrlX7kj1+eiEpNjElJiEZKTM ikQJMjG0ZHJyelJ2XnpBcXbx/pzSA0iBGYUl1PTsKGpiGDk+Ii6hC4bHUUNi4sJI8WC+ZPkKtMXB OQN8YmgpwO79RCFajKYl+4dHsTRqIlLSmUWlLMdI7yq9empUfKKKVo8PjH4YwAcjhsDBPlNGmu6Z I7xCWIoNDl9XXl7+y9U5OTnPnDnzpK2DlJweSUmMjE/qJUZRk0nJGUgH9fCKkLmdAyU1CzzD4xK6 cqYkRlBoSEPJ1OAYcnBMXCgpHmQRDOIwEjWMTEUmJJYSEkPBpc6IQtAHRsYGRMSEkigzZtJvdfJs 5S86UsmiIUZb9PL4JPBU1zVg2VV1PYO0ghLWw2d0FYimV65hfXvnRwLCKyK8nTRxqpiojLW1LYlE iouLI5PJggwYOnRYT3V37Njx5MmT01fqSEkZ0QmpwNjEtF4iKSm9oPxYy/sOZU0dlswjKUmkxHRQ xtBYsEVbKA+PowVGknxDI/3CogMiSIGR5IBIsl94NBCZwG4YFEVHUPqGRHoFhYfGJhAuvZqOfl75 8WhqSve2UMIYVzra4t22g2VXfYIiEzL29dRPpFEJKWDOUon9YEBsS4Srw4f/Liq8V1dHH4KmUqmp qalCQkK7du3i4eFlWdHBwQGha9nxanJKJjVjH4EJmXkfcV+nws7lnzApp/Du07f3Wt+u3bCpC/PB gwcnZhUQDFlyoGXlJWUXKmpoT2PnYOOYPu1rEbXY2dnYPxxoDIgiZxQd+Lz/nw0E0oxPy2afzuJG 6NQ/2ZJzi2hZ+SyHSXQ+Li3bNyzqW4rtH8Do0aNHjhzZ57c+u4Qk5eWUKHGUxMTEtLQ0WVnZPXv2 mJiYd6FH8FhYWAhZZxQcoKRkYyqScwoTM/Mx/8gghaTwEykzT1zqjPRLmfm5pYfpa+ZY1aQpUzs3 MWz4cLClpGYTdZncmHzS8koyi8p3Cot9g+GPGZOSW5ySW0Tw74JEu7SMvChKCsubD5t4tx49ewVk xKC6Vs/MT84pSkjfp6Fr+M+7+k0A4ibeuNywnl9CXCY8PIJGoyUlJWH/CgsLm5l9Ju6lS5ciFr7+ 4GksLS2KCscmk5KaQ07OjEvJQiYuJRsZIo9CXGX8JArh2eYwET9BgEx2SQUk7hkQNnDgp5u0cCdC YmGOE2MS0ggygu1HzE7dVwoUkZD5jVXEPWfOnCU9A/GAkmvmTIJ42crVuWVHmV3qjMzOx9DSDUyt WM6ekob2/sozRA97qJ6N6us2sXDpfwqMGDGCnZ196NChs7kXSojLurq4QdzJycnY4+Li4tLS0jNn ziIolZWVX758mV9+PCACpjAuJJYaSqLR09iEMHIi8sjQkUQLiqaAhiD7UMigYeIHYnr1hPTCA49e dciranbulbK2vldwhG9YDJiAG9HWh4okGikpq+bGfUsHt+7DgXv55ZvzKXkl4LNxCx9BLyIpU1Bx IjiGSvTnM4yFv0cNiqb6R5D4tguynD1HT38ItKfqKA+MiguKjvtj4qRvKrS/D7DdHBwcbGxs48ZO EBeT19TUTkpKTklJycnJwdRJSEhoaekMHDgwMjLyeUdHCCnJ2SfExS/MPTDSIyjKPTACqUdwFDOP clwFjaNXoKNXkJN3MH6C4BMlExnERJpVdqy08tyK1euZvZo2ndPWzdfew9/BM9DRO8jJJ9jZl96u m3+4W0AEuKUV0tWCv78/divoMQR+fv59+/a96+iIomWCgMkc9K7+Ya7+4S5+oegPGGoZWTAfAWib WAZEU1EO/izQJ8TJO8jFN5Rp6DsDjI5PaKyrXxjRve6IcnC2dGSxLH8iTJkyZcGCBcOGDRMUEJeW kkUslsEAT0/PjRs3Lly48MSJE6XV1209Ai2cva3d/JCxcQ8AItM5j9TS2cfc0cvM0dPEzt3U3sMM 6Ohl7eZPXCXomUhUBNp5BxefvBQQQ5sw6dMJhIXLVhjauJjYuZnau5s5gI8nEMzNnbzM6Tz9YlML XnTatshTssscfUIJziAAWrn6Wbn4Wrr4WDh5mdh7GNu5yWvqj/h4ngqeKi5ZOnt3buIzdPAwd8BY PFhG3DNnz3MJiDJ18DDtqS5Se89d4v9b5+vGjh1LvM23cMEKaSkFSwurzMxMqHRnZ2dePr6bzc1B 1H26lq66li761u6Gtl76Nh4GQFtPOjLy9EJrdx0LFy0zJy1TRzUjW2U9i1nzFq3ZtFXL1EnPyoUg IyiZ+KG6rSfqmrsE5Z24rmZoM2jwhzuNXFxcM2bNVdA2UTW0Vje20zS11zJ10CTQxEHLzBH9IRgS TIiMnpUbynXMnXUsnLXNnTRNHTVM7MFWzcBGTtNk0bI1nQU3ccqfGJemiT0dmcw7oYaJg7qR3U5x OZbztpZnm46ls8aXqttrGNvNW7ziR0ix1zBq1Ki5c+euXr164sTJ0pLKcnJKISEhurq6Vm5uh+re GrmEKOhZK+jbKBs5KBs7KBnZI1UxdkRKL2EUKhrYyutZy+la7tUyl9Ew3S2rOX4ifZ/2HzBASFpV TtcKBJ3rMpEoRAapoXNQbGEV325pVBQXl9y2bRucimHDf1++nk9EQVtCxVBSzVha3URaw0Ra01RG 00xW2wK9UjK0I5DeB10rWXRA01RK3URSzUhCxUBMSU9CWZ93p+R07nl9+/XvMvDZC1dIqRmJqxhI 9Ij64DN/+VqW88a3S0pC1fCL1Q32apqNGvvH95bg1wKc8w0bNkClr12zhX+r4OIly30T84OzTu3V cxBTNZXQsJDSspLStJLUtKRntKyRfshrWomrm4NGVMVYWNFgt7zeBgGxIUM/nXQaO2GKiLKRmIqJ pIblp1p0Dkz8UIjUwDXCPjxr1qKVAgICUlJSlpaWGhoay5cvHzBw0DSuuQtWbFq3XWybuIqQjKag jKaQjNYuWZ3dcnq7FfSQ7tyrs3OvNnFJQEpjNd8u7kUrJ0yZ1n/gQGZnuujk8ZP+nMY1bxrXnJ5x Ljv3/KEjRrKcNDauOWwz6NhTdXauuRzcC76TyP4JjB8/nngDd/SoMdO4l8SUX7cMThVVNxNWMRFV MxfXtPyIVkjFNOiIvJi6hYiq6R5lY2Flo53y+kLyugtXbeken85dvmGPkpGomhlRkVGXBYppWICn dXiWhl3g+MlskpKS1HgqhULR0dFZsWLldHaufn0/BGuDhwwbOWb8JHYuYraZOGU6N8pHjum6m/ow 4EfM4/8fmDZt2vz587eKSGWcf67jGimmbi6uYSGJ3adjI6Vjy0Cbj0j/iUsggBBFVU2FlY13Kuhx cM9nyRluMJ+YMhhKaFp9rG7zOdoyecoaOvmkHMVC2rVHJC4uLikpSUlJSVRYQlBAZO7ceYBx48b1 5klib0SMiGMYA4Z/BJbHtHrZVnfoQqampraPAc5ubj/9YSgCcCd//7IbrwxcghWNHJVNnVXMXJEq mTgh7YwoUTR2VDC0kzewldWzltG22COvPXbCl0LLcRMny+rZyBvYoWIXbp3ZEo0auYVTyy8Lyajq 6OpqamoqKaoqK2lv3MAH72LWrFldzoT0NLe9gaysrOZucOfOnby8vE0fTz58Q6AkJp69fPnClSsF JSXfQ9ts3rwZsbOCggLs8pcpEYsdOnSo9OIDa+8IU5cAY0dfQzu656xv62GAjJ2X4Uc0IMptPPVs 3LUtXDTNnIRlVIYOG/5l/oA1m7fqWrsZ2DJc+k4MP2Nr64G8iUtAaGrxvlM3N/ILrVq5WlFRQ0Za DfMPcU+ePLnLayl/G6BzDh89+rCl6WFzU3PrU2DT0ycPWpobGh8SkZ2Xl9c3aYiASZMm3W64V3/3 zu3bt01NTb8hZwKgqcAZ3X78rNXMzOwLlFgMDQ0NB2tueYbFIZB09A2z9w6x9Qyy8wy28wpGvgui EJcQTVu6+m4VEu7bt+upRZbQt18/NQOLnnh+4OxJ5+zgHeoRSq68+iD/yLlZcxds4xfZwsMrJCSE 8KHLJ1/+CSD8bGxsfPPubUtLy4ULFyorK0+ePHnr1q3W1tYXr+iHITEnMBzfqjlYCn5+fj4+PqRf 9WGTXgJsMXEO/N27d3C5eyITkdybnF8WQU0Jjk0IjKL4hcf6hEZ7h0R5h0b79IC45BkU6RoQumzl V7y2D5jKNs0jKMIrNKonzsym0Y3gWFpMUlYImTZ6zFhsbfjnCB++4Wlt+KUdjFceamtrubm5wXn0 6NFTp0718/NDYXt7+9OnT7du3QpKLDMU+vv7E7tSUFAwJydHX1+fyap///5YjSQSCRry4MGDIF64 cGGX5sDEiQGKiopdLsFlgiYpKys7fPhwTExMT58QhGYzMjLKzs4+ceJEfn6+jY0N80PxWlpaKCGU 0uvXr8PDw9FbUVHRztUHDxmiZ2JOSUmPjE8II1GC6c+Co/zCIgn0D+8RAyKiXbx8ODg50TH0/6vM nOAe4S9wBjJbD4qMiYijxqdluvn4YUKwer/tSU5ra+sOxqs9kFFnS4p11dbWhp2CXU+I29zcnJhJ aADEhh2Mz7cy30WFbkT5h7PlH19nwIIxMTHp3BzxlgrYlpSUMAvhFvr6+jI+DNtOpB2MFytUVT87 R4TlpK6uTrya1M4AopWzZ88ingLBtWvXOneAeDXD3t6+y5AHDx7MMZ2Tg2M6O/1BMMc0dgZyfER2 duLR8KcSBs6YOXPlypUIlGxtbSMjI1NTUw8cONCdOUtAz4mGurPtjugVB+eMhYsXc0yf/g3VOAGl paX0W68vXmDCf+sUku/YsYPYI3V1dTC4KIHnRkwmXfm/eYNpR4b4/o+hoSFBjBJoCVhPLBLidSrM PLFaCKDRaCiEpfDx8SFKsDdhPiCaR48e3bx5k/iWIFgRZGxsbMy6mZmZKHz+/Pm9e/fQCpzJpqYm EN+/f19cXBw+NjxM4vu0qI5L6EZ9fT20UC+nAhygOqCRVq1aNZOLm49XUEhQWEhol5KSMjYFOkyl UsvLy6FVEFZAvSCFMoEeO368En0Dzdq1n92JwtrArGLIYWFh0EjwHqWlpSUkJOB4W1la2dnZOTg4 wMFgHKjYwrOZb8sWgTlzFmJTz549G5buG9pQAsDwZm1tO0MowsLCzPKJEycWFxfX37lzq66uqIh+ zBWe4cUrVx40Nja1tDQ2NdUxyslkMi5BgTPed2jA/EdFRa1btw4d1tPTq6uvv9PQ8Ki5OTc3l1hF CLuqa2qaHz/GYsDYibbc3N1R/d6DB9jv2KSIAaEnb9+92/LkyfOXLxF+/sZYhNa2tkQrV69exRTB Lq9YsSIkJKSmpoZ4P3HkyJFSUlK19fVPWlsbHjzw8PCAoDGor/pPECxsdB5LHVpr27btWhqmdjYu drZObm4ekCx8Gwz84cOHWOrXr9+A0cHQsAsKCgoKCwsxY6UMKGPA/v37kaIQqyIlJQVzFR0dnZaW BgJUPH78OJRDVFS0hbmFnq6hnq6xjpYpH68ALy8vjMWMGTO+x3fOly5dWllVdbWuDuIOCAjANEJL Q2QQx/7Dh3MwjLKyVYwPCi1dvvzY6dOHKisrjh3LLylBIfE0DXo4NSurrKICqKnz2REsfSOjw5WV R06cOHjsGGGAZs2Zc/TUqePV1ZXV1VyMd4GXr1xJtw7V1Wio8+uW1vb2J8+ePVlTY2lri5/TOTnr GhpKy8vRq1WdPnCEPvzZaftPnDQJzNHPoydPcv3dd43hGmFaoC7glmAzaqgbhQbFhQTHREbGZGZm Xb92Hc4M3Y998QI6BHKvra07deoUdj3WAyF3bATiw6cAQhtgnUAdQQthqUDtYF+gPDQ0zMXFzcXJ w8XJ18TYUXDHLhERESx1RNmEOv3msGEzT2nF0bScvOKKI7UNTe86Oi7erM/IK6SmpMfE0yJIlC38 H77zs0dcvLzyVGo2/Qg0D98n5bxhE8/ZKzeTMnNjKIkjGQ4kM/xfs259VkFx+r6CpPQs4hL/jh2V NedREhZNGsi4jWNiaX3y7MUjVTWYELh22K3Eke9DJ6tTc/JSs/NVNemvmkrJyFeevZCcmeP8MSpk eZNhCx//6QtXM/OL42jJXzhe+JcAB2nRokUCAgLQuvAWZKTlHex8oyISYqLiyaT4stL99XX18HZe M75a+57+bxNthC8BVwE7BTYFKcRK0LxkADIwQzBYVVVVcXEUP19/H+9AX59QT7cwZSVtcXEJaP6N Gzd+P1kDhCWkc0rLQ2MpQTHkoGhyQFRsYESsX1iUd1C4hp4hW6fv/Kho6sQmpYWS4rUNP3O9tPSN cvZXkJPTlTS1ujAX3CNCSkoLiY2zdv7wpFtT3zghMzeSmqSqyTh+3KePo6dvFDU5KiE5JjEN5RH0 M6uJ4WQERyR0A+mqdfSn/w4ePrSsPHJKxjbBnV8YjqqOXmJOfnRCsn63w2ZfC4hNEERg/mVlZQ0M DGBTFORVfLyiSDHJsdHUeAotMwOhwcn6+tuQY0+vABMfr3716hWkf/78eez7mJjYkOCwwICw4MCo wACSrra5hISkvLw89jWMIBcX13f9rworZ/fohNRQcoK5g4v4XgUJWQVRKdkt/ALdjzFYObnFJKZH UJI2bP7slKaZnRM4ZBYf1DT87J7JgAED0ov2h8XRwik03m0CKOnXv797QCglLQd8eLbSlcaAgQO9 giOiaWmUtGxFda3dohK7xCSFJWR2iUhsFRDCatkpIj7i95Fg5RceHZeanZCVt2PXnp7Ggs3u7O1P SsmkpOcI7OyR7KsA848IhZ+fX0VFBUKXk5PT1NAP8ifHxabFkZITqKm0hJSMjOzDh4+eOVNTe6sW lh2KGp4kXMQbN25cunT5yJEj+XkFZBIlOio2IiI2IjwuMpwaGUYzN3USExMnPqULBQ5lwsnJ+c39 8M4ABUtKziCnZMYkpS9fzfrhJgHDh4+IoqaQU7PIKVnzFy7ufEnXxBwb82L9w8fPnmFmiEIE74hT qOn7omkpAVGkQYPop+hHjxkLDsm5hZDa7Hn0xwp9+/XzDAxF4eGaS+s/fzOlc7CMKMbdP5iUlPHo dceBypNMHQ4X2tPTk3kgZ+iwYaGx1KzigzU37mBX0kuGDv3nn4yAKZ8zZw58dTiEGhoacLCVlZWV lFTMTa2DA6Jp1JyE+MzEhAxaQloCNQXST6RhDWAlJFHjk+LiaGRSAplEI8UkxpFSI8MT7Ww91FS0 4FJi5cBF37Jly5IlS6DAv8cdpy4wZ/7C8LgUr2Co7sg/GLf6e7rrPnP23ODoeG9QBkeN++MzbbNo yXL3gHDvkOhXHR0wTPD3YIIRTwXHJngFRzp6+KMVgpKdgzOKmg4+/uFk5qE1JQ1dz8CIQ9VXYddc XV0RaCOcuXTpEqrvFpXs81FYO3YJewZFBERRoCHh0zo7OyMmgt2MoWUoa+r170//YuTYcX94hUSH xNJeMr4U4RdO0jGx7OWtzr8EWPN58+atWbMG3j4UOwJPyF1NTU1OTt7MxMLJ3jUoIDKBkpFCy0lJ yklMoCNWQlJCTmgw2dPN39rSXl1VU0ZGBksFigJ+IB8fH3YHAq4f9hckvNt3mjq4G1k7K2sZf/lR xUbe7aA0tnFR0jbqfnWPpJyBlaOZvbu1W4C9N/32r6WTt4mdq5axFRvHp0Ppq9ZvDqGkWzr7aJlY Ey+tAyZMnIyfhlbOZvaeVq6+1q5+5k5eRjYuRjau23aJMns1bPgIdUNLQxsXc0dPxu3lEDuPIAtn H0tXP7G9SgS330eONrFzQ11jO3czJ0+wEtjzDY5kdwYODg6EaQgAN2zYALnD5urq6kL08OHh1Ckq KsoyQFNDE2EmhIstjLWhzgD6A01RUUgZcRZ2NDRG51sKPwA2btu9S0ppp7TK8vWsX5pgwnq+naDc JaO6fB0LykFDhi5euWGnlLKMpomclrmcjoWguOLSNZuHDh/RmWynlIqykb2CntXmHSKdy8dPnLph 604xBW0pVUMZdWMxRZ3NAsLsXF2/FjVm/IR1vIKiijp7Ga1IqRtvERSbMefTXfE+ffouX88jLKcp qWogqaq/Q1xh/ITv9Wd8sLPY7MuWLcN+5+HhgZ7HhoX0sXOh8IlvXkH6kDhEvH37dhgXmAMYaEgZ a+anvPLc+4ePfXphAfv26z9i1NjR4ycOGzGqy6U/prBvFVexicjao2S8W8n4zxksPvw1eMiwUeMm jBr7x8BBX3oCPnDwkNEMskFDWMdZqD7899GD/0EU9lXAzs7Ozc2NLY8Ni10Pma78CPgJdb148WIs jJkzZ3b5jtNPgd4/Iv8yZfdLzBLMv5S2pZFHlJSWpZi6iYCkav8BA79cvfdd6g3Zj4fJkyd/v9j5 fxzG/THRxMlHz8ZN28JRQct40q+PPf6rYcy48bvEJAR3i2zk4ftfeP3zF/wX4P8A1crmYQ0KZW5k c3RyZWFtDQplbmRvYmoNCjUwIDAgb2JqDQo8PC9UeXBlL1hPYmplY3QvU3VidHlwZS9JbWFnZS9X aWR0aCAxNjUvSGVpZ2h0IDY3L0NvbG9yU3BhY2UvRGV2aWNlR3JheS9NYXR0ZVsgMCAwIDBdIC9C aXRzUGVyQ29tcG9uZW50IDgvSW50ZXJwb2xhdGUgZmFsc2UvRmlsdGVyL0ZsYXRlRGVjb2RlL0xl bmd0aCAzODE0Pj4NCnN0cmVhbQ0KeJzFWmlYU1cazkZWIIGQQFgSQtgJyBIggICgsieAClioxQUU RVzqgigq26iodRed4tKZCh3H0WqdWoFqW2rVtijqAyIgUBQERKyIgECWORcSudlYnqcD7w+e3LPc 857vfOc77/kuCMQ4MOdY2VhZsIzHazc9MDC2dPGdGxIWHiGICA8NmePjyDaiTjcpBegxrDxmhwsg CNdv3vSxEPoVFuDKppOnm5ocFCM7f8BwXs7XD1qlI+hpuHksSSgI8eLQdKeb3jDoVn4RggX774uk Snjx72RhqIe5wfTT1GfzwwQx53qVGY6gIk0Y7GamR5xejjS7uYKoE13qKQKIf0gSzrahkqaRoq6x S1hkXotGihAGriwMcaBNH0sy0yci+tKYFCE8Sw2bYag9TRx1zf2F8ffH5Qj2epbA3Wh6WOow/YWp rQpsJKKh/nc9PX1DQyIJvFx0KsqdPh0rTjKZKUzvgTPpba/64eLZw/sOFJ4vqfijq18Mq7wa5Wow DXuc5i5I7YZRbKsozkoMD/DxdPfw9psbs/b4jfoumDmLIh308FPNkWwTltj+gYK4/fbhxABXOwtT GlRpyraZwY/eeb329SjL4yEcXdzUciQxAxdUfCDQd//0qmA+l6KjhRxtYuMRnVdW8+Ecer8twsZI D4BCJqKnhiSVF/XlB469T28UnSrIz9+9zZ2Cgk3ExmvFxceD8lZvr5w6tD8/Pz9vwxwSUvOb/zqQ 2CEp/WqCzd2Z2vDxrYIOvlZt9CwaPpX/H6juCyrVcJRKzjliPzRCEu1z36i2adjsojMVJImsoCx1 HKXS/i1mcodDkb2KBlQaiGvy5prgp2K5KU4x1epJSl/M0x9hgKKH/apaPVSRF2ahMxUbB88I2C4P gT3KNO7OJAKWSKx5crMaQ5dummlCmBKPJFlF/Sgbtf0nZa8Tn7LVQiBJTvlvVTlKytd7GGKnZGsj dLlLZAaUnMwqVta7vWuMMXq+l4bUOcONYAYeicJTDJlsNpOujRmXL4ZIoehRiJjJk9TnH5IN+mxl UNIVZTp/RNvOf6COolRaH+nkNku4ek/h1WvXvjm2Y/5sHpssc1AkzsTNf5avp5sLgLMdg4BE63K8 BZt3gfi7JZLPmmRsxTPCbsoG3RvA4qXckShR+f1wm3qO0sEzV6s7YcKju65kg68pDhofbbyt42Vn 59NqCFWV+WyGe0pZiyw8iJ5/HW6CHZcZDASzhTKFNhRjTaa4ZdQqUZGoxnnlecDQdtybCrYSzuMX eOkPCbtrFK52rzM5WpOxJHOpbIUbfGhEjIFf/kvNFGSzqRaPUVvzEQON0Il+AS/7/ZFyj95VhpMI CwROpqxfoTUJh8Qah/793dgc35Xs7x6r/uXHdDQ9VSHy96m2qvaZhIoi2p6UdZtP10IjkHjz2EuD qu8cxYsv0tJewZ5FHfd+vt8Bt9QTf23Lo2POE2AgkTJhjigC94Ksm+9wXEaRbJeXa15O0aO9McJi mFMOlO9PTVx9DO7JkiwW/6ZyR7GyI+eYTniHo/AzvpW92hMx3AtNdtlUo4ljf1l6oHs6fPV+2+Bn a2EvOAvfF//1EDQodJN0Vdz4pV2hSHrEYsJOicQ6fy+zkbusE4bqs6tDPceuomQeOxxOoO/S2qig 2cGf/ANOsjx0uYLXip+cSEtY+aWir+/hTHznYBxkJMV8uRLHmsRdVVU8oEX9kQW2VOsj8IUTvX3d CdClcGzejstRWNznu0PtzZ3XK1xGB7cwJx7QUTby5fbFyaaGs96gEEDkr72zM8hcmzirTk2dIn5a dlFhcl+GGuPRBvEKGuXVCsbEfRJpId84oaThMw1JdMhVo8ClkoqtPgw8ipwwZvwZxrdrH8Efu9Ot wDGk97FCAH4UpT9hQ6JxDHkIWqGHQUHq1vsr9SGoNcUcjEVbO8Z5I5vOkXSFTfL0IzoSgTRKew8v PO818fwCRpuSLut2yRSHRmAMBRVSDSj1xCOQZtnwov7ntY+Vce/rFTsUXPo7fx0weetT8LLBHJtJ nIt6dKHsWOzgamvhOKma02pDn1likOb58KL2wo1paWlr1m3ckiHHllVRwSfgbcT7uOBwwXrfhRe+ WmkyiWNRj8WT7RJRMF3f9bCGBOowupcbopmZ8Ej/bD3P1tbONXLvqTMynD6+3nm2Qih/s44JnF07 6jm8sGrexF0SgdAxdymXddzLCy9VSUMroCFcz2QtPNr8ucmWbGAdWQJvdJ4rVAjljR/RwD6mJisc 4F/7TCblpc3mH5R1fJk9bnT5gW8aXwkvqCtI3FqkYKPuNOdlCgGgLBC4pJKbDOXZTkpQmvjEyI8C lXuYCsTHvaPOqNE0o+grDnPZDg8Aks8cgUti3K7DW3WtNp3UBY7KW3hH45A9yor3Xdbi3DHUpKSj aAmXfx5e9HYDC7gkIbgeXvhkweS+XVEcFuzSEPrEdZdvKd952vc+1EhxsO367vm2NC8FVV4fB7mk TjRc3kn/4zPJXLFZyKf1UnUYKN+ZuFWF0rMPU1CY2sCbpp+LshP4TG2S8+dVzztkeFFz1Au4JEI3 sLTuhbzw+YMUq0m5JAJB46+9os6U3RdX8q19816pqRqufnT7fs3z9vaOjvbW2kclxYe2JIa4mVOw KKzZ3NSsPIBcgO0pgaaQBCdaRa/PzpUhI5FH1WG5utvpTdgxUa6ZT9SQaP08nqtPZISfU39IDpXt TUldk5EFxszOXL88NtjbkU3XhoSUFjMiLWPbtm0Z6xaFeLnYGBEhJlpkloOrmwxOHKq2bXFjU+VM jeliJI5qYqKPk2sQjHFygyoHUdVegaUOGkngJKk/Jqtygp0sbJ1cwJguM+wtzehkgiw7gPeqez8A obf58wAGUWvYWkgMjkiSg4jHUKI6wZ0xUuMnVS1OzoWvNjNGrvFIgk26GoU78GPGLFPisN7g5XSq 4dhzdr4JGY0lDI9MwGFQo7pL/5PRUFbpqd5WSMONoLYmgqLJkOQFIC7edBj2XKSOx2k1+dN3320M pI/YGmMY9k/VBRf9tNWVpv79KNbfQESQiIcD1VC6Kc3KnmVgYmeujUISjJ28+HZ0LBKBMl11p67q mJcOEmtg58nnynJKaDKH5+NuScZoe5yUQF852AQooxf8s5o903d9TzyPRR+ZE56zTPUbVOfpuWYa rIBxvQY4tlTcrYWC/uVZa+7eu5pwuu4CR5sV9sXjttbKXBddJMZqV+0fFUssCHru2RUtbVX7XHWA mtN2SL3R9LK5PNHa9VoH9JKqI0wgTdwq1Trc4Ok4YZCvqx2Hbcq24iWcUhHBfZn2mgQCIRjcHAf/ tXbFPug6V7r0V+B7QANf9/UpGFG94h+9dfB8EEtfxzFMYx8MG0lS4kZAG4SWjKxZd748PV7BAxcF mxUXbj2ofvy4rvHFm364TXu/ixQIBOEQohZl/qdeoXKwo2wRW5P4p3zyJ7D0Zp7jkgfQzWEr8GhI tXyxtPxD/2I7PSjD8SzWJgnyd6havMOUJmiSN/huv+zHdT7YQwbOwmWpQBGmbd97vrJFUQINNF7d LhQIhAW3XyoehG8fFi5205SERprmAZesWeM79xCwf9++o8NH1sCrgzegqTc3QhnQzmirjUCmVy2c 91gqfV//+wtggV/85gB7S/5saO4VV6bn1IMh+1vvZ9gDRyXSWNa2wwiIzS59qu6OqAxJW+n2cGcd TUlGDBf60tv28LdaaOl+31oKdWm5cuA4WMCuy/v3XAIKaShzVhEo/nYxuF4NPSz+eylQf03LjoOG jed25Z+5sCk8ARJ/1UeX+xhC80ZhtLAj4PikXqoeXwcNPv13khsTHnIUgfO9PTqfxpxUyDFbjyUu AT44dC3J1/9TIAdF+QvBXhw8mgbWfLC9uakVmLU5B7hyb2Gsl1fgHFdrIagX/TPSlkZQej3LJbag okNtTnd02J7qwhguQwNBCKTR5EXfvRzB8jZoaKFTAriadWW76DMSmkCE27oabN6uzK2wdMG9w+Ch Oc2arEs10KUuAPTfbLImYlTOTVOHuZlljW/GUGL9LTdzwmwNx+CI0F/8J/SN9+2b9sqza3wdVwEf bFhhYbQIlHauY+EstoFlr121E/ytS80F7tXT0dLS2v6yqeDoIHSvNMBRGbpoajJg/DServZot/KM O3CruVeDchtou3Mo3oOjIYiPAMXcDbZf+zenjuSuDHWgW0G76FYIxeBjoFPElyJ9N4F73lBh3DEx lFndDpa57fqXRf999NW2+Lz30Af/wNm53wfRmTsA48p1swzVfn4xs5+ZeKKio3dIhaeo/2XFycXe diZjUQTxYjiU30ie4+1qbUjCO18BT0VueErYPcifa6qAhUT3kiMuguLisFXAvOJnD+veSatieclQ Fub1w6di6WNfh2Ng/N7WajcNOUwW13/pwZLazneiUb0oEfV1Pik5uMyfazY2RRDKg56CqLKHRyOT cGgkfjbQV/07rDBE5zz5nhTdT/cRghA6sMsjokQ+RE0wM7BY7mdNAufDwz+q/TXe1tiO/NDl+y5X Puvq6Xs/8L6v51Vz5eX85eFeXOZ4FMG9LviPgcGmRYwRbyLNaRgYbEwwQmGMhUWvoD35vvP6Jv8Z K8HZ07XSkrv6zjtAU/SmYp2THmfZjz3gQdz9aAvPLqVVLJV0n3Ef60rJ4XrMWbg660DB2XNfnPhs Z1p8EM+ebTQ+RUBrxpqCk596kEciFHFG2vET6911kUiS5bzdl397cOur3Yv4Hlt/BWweRNKp7ikn b9777VrBGj8jPGXG0mPfV94vK/w0wMRoZuY3d8sOxFiM8+8J5jaOrh58bz8fvrsL15o50SsJlubo 5+dIw8qfuH5+XOgJrc3yjFq64pMITw57CZQUGjjKI2GptgEfJSfFzXY0IqC09Kz9Y5OSF85xYhCJ DPeoRTF+HN2Jfbc0HismqgEKRzYw0MWiVJ5QOIqxhaW5EZnA2gPtofIEphYSQzRgcjhmBiSgl5Fo ItWMw2HSSFpIFE7PmGVqQBz/I9tfDXC6YdAoBJq5ub79+bernXQhBkg0KJRTgT0gUWiNh9oUAE2b mZqdEeesP7FPjP8DU/4xtA0KZW5kc3RyZWFtDQplbmRvYmoNCjUxIDAgb2JqDQo8PC9GdW5jdGlv blR5cGUgMC9TaXplWyAyNTZdIC9EZWNvZGVbIDAgMSAwIDEgMCAxXSAvUmFuZ2VbIDAgMSAwIDEg MCAxXSAvQml0c1BlclNhbXBsZSA4L0RvbWFpblsgMCAxXSAvRW5jb2RlWyAwIDI1NV0gL09yZGVy IDEvRmlsdGVyL0ZsYXRlRGVjb2RlL0xlbmd0aCA0NTc+Pg0Kc3RyZWFtDQp4nIXCh1LaAAAG4Oey tXvbOlERUQSRoYCgEMIKMxD2HmELiIAMrXbvZdvH6h/jnXetd/3uG5s0jp2/hlN8E//6NHecS4zP XLyBs8RNrpl/aw5JroC8LSDv4LwF7/IXrPfO319E2wMh3/5wiftIhA58vIzUEzF3QuycWHE+XUXX M5S4JiXuqTX0TEu5MzLvLK77cE7uE8hpwQY9r/DjgjKAi6qAUMUI1cySOijaDIq2QsuoCYs14RVt BFd1UZRsx9b0Mak+LjXEZYaEbCexvptEuTG1YUopTGkFkVYSGaU5qyKzajKntuQ2rfkttBU09oLW zmodrM5R1FGlbaqkd5b1rrLBXcEdT3XXUzV6a0Zf3YT0HoH+hjnQIANNkmlamJY12LKG9m2hti3c tmPkwBHpUNEOFes6Md5zYeLQjcm+B1MDb3rgSw+Rzozo7MiPuaMA95jJHzOF50HuSZA9CbGnoeJp GEsvIlh+GcUKvoph9XUca/gmgfW3SdzDdyls4Ps0NvFDBlv4MYv7/E+5Nv9zHg/4XwrY4X9lu5eL 3W/F3sVS7zv38HK5/+Ovlf5ZZfDP4Vl1+PPKteGv2ug/66Pf9aMr/gGo3JghDQplbmRzdHJlYW0N CmVuZG9iag0KNTIgMCBvYmoNCjw8L1BhdHRlcm5UeXBlIDIvU2hhZGluZzw8L0NvbG9yU3BhY2Uv RGV2aWNlUkdCL1NoYWRpbmdUeXBlIDIvQ29vcmRzWyAwIDQ2OCA3MjAgNDY4XSAvRXh0ZW5kWyB0 cnVlIHRydWVdIC9GdW5jdGlvbiA1MSAwIFI+Pj4+DQplbmRvYmoNCjUzIDAgb2JqDQo8PC9TdWJ0 eXBlL0xpbmsvUmVjdFsgNjAwLjk4IDEyOS4zNiA2NDIuNjIgMTYyLjI2XSAvQlM8PC9XIDA+Pi9G IDQvQTw8L1R5cGUvQWN0aW9uL1MvVVJJL1VSSShodHRwOi8vd2lraS54ZW5wcm9qZWN0Lm9yZy93 aWtpL1hlbl9uZXN0ZWQpID4+L1N0cnVjdFBhcmVudCA3Pj4NCmVuZG9iag0KNTQgMCBvYmoNCjw8 L1N1YnR5cGUvTGluay9SZWN0WyA2NDIuNjIgMTI5LjM2IDY0OC42MiAxNjIuMjZdIC9CUzw8L1cg MD4+L0YgNC9BPDwvVHlwZS9BY3Rpb24vUy9VUkkvVVJJKGh0dHA6Ly93aWtpLnhlbnByb2plY3Qu b3JnL3dpa2kvWGVuX25lc3RlZCkgPj4vU3RydWN0UGFyZW50IDg+Pg0KZW5kb2JqDQo1NSAwIG9i ag0KPDwvU3VidHlwZS9MaW5rL1JlY3RbIDgyLjc1MiA5Ni45NiAxNTcuNTEgMTI5Ljg0XSAvQlM8 PC9XIDA+Pi9GIDQvQTw8L1R5cGUvQWN0aW9uL1MvVVJJL1VSSShodHRwOi8vd2lraS54ZW5wcm9q ZWN0Lm9yZy93aWtpL1hlbl9uZXN0ZWQpID4+L1N0cnVjdFBhcmVudCA5Pj4NCmVuZG9iag0KNTYg MCBvYmoNCjw8L1R5cGUvUGFnZS9QYXJlbnQgMiAwIFIvUmVzb3VyY2VzPDwvWE9iamVjdDw8L0lt YWdlMTggMTggMCBSPj4vRXh0R1N0YXRlPDwvR1MyNiAyNiAwIFIvR1MyNyAyNyAwIFIvR1MxMyAx MyAwIFI+Pi9QYXR0ZXJuPDwvUDU5IDU5IDAgUj4+L0ZvbnQ8PC9GMyAzMCAwIFIvRjEgMTEgMCBS L0YyIDE0IDAgUj4+L1Byb2NTZXRbL1BERi9UZXh0L0ltYWdlQi9JbWFnZUMvSW1hZ2VJXSA+Pi9N ZWRpYUJveFsgMCAwIDcyMCA1NDBdIC9Db250ZW50cyA1NyAwIFIvR3JvdXA8PC9UeXBlL0dyb3Vw L1MvVHJhbnNwYXJlbmN5L0NTL0RldmljZVJHQj4+L1RhYnMvUy9TdHJ1Y3RQYXJlbnRzIDEwPj4N CmVuZG9iag0KNTcgMCBvYmoNCjw8L0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGggNzgzPj4NCnN0 cmVhbQ0KeJydVU1vm0AQvVvyf5gjjur1frHLVlGkxkmjVEqVyml6iHqggBMUDC7gRPn3ncU4AQNu 2osN9rz35s3MzsLsGo6PZ1fzyzOgJydwejaH3+MRBUoopYxzqkFzCq6kkEfj0Y8jSMcjBvevMZQq RmUraHk0Hn0bj+D8ag7QEGBvAtMa6xqlay1PMNanxQUxBlANlCaMGnCNSygDTpRSDILVeDS7XPn3 EfPgLIM+YV4Lzy4WXMF9UTtgxiMet7RGeyAYfgsQHiPaffXR4RKdKnEpmezJ3KrpSm127ZdllKcQ FEjlGiiC1MIl14RXSBRVVB2snqyFT2+Q8LMA5L5ZWie2NAwU5iLRhTKEGbhZNfWpdYuvTNSvF+PR 3TEV+vTkJ9x8GY/OkXPLy/Z5PY7l4E3eO2dxfTk/h4l04gJ8WOf4lJVZkE2m3ElgmeUwafPuyAT3 iNwje4rzcuMnQxBJJVGyDQmj4rG0ousCJtp5foiDB5gIx08Sm0L2bD+LfcatOYL96jUoFNG6FvAt 22qDrNYbskf5xHWs4yBL0yjAhzLOUpgYp3zwUwy2/4VxsU78lwEjLqVEtmWmg6EeUV47NkuTl35H vW6wamIHXedVd5KqWEn8GA3VmqOg28befp0PBXsCT2A7ukncGWD3XQPMlUtk3eh/G9Em0vkUhlFY 96XYrNdZbgdm0LjLiKfaDEscZ+Hk4IdhbJttR1S9jf5ykwbbn2MbV758+Ld540IQPPFbrTgNkk0Y p/cfBxJkniFStEEHi632i91OwlAiGAdmNMHV91ps2VfsNhI3MMH6N5HObYjrNy2Hckcxbw9xMHf9 vtyVIJz/V+4NpBMk8fpX5udhNSkPfo5dGJoSre32asEPGvE6RjrTsDODixG33F/MdNA7Qw20831x OjTmzEUK0Q7PozDOIzvC1TgPWVeMGNlGHrRuWtZx8ytiPNk58JqDdNVus29v5ep2ci5XuLaeIrtW YTLVzmKztlu9Osj2WONPeNFUjwN3jZFEqiZ9fXF1jinvy05isxVvwzuO/wCTkPHkDQplbmRzdHJl YW0NCmVuZG9iag0KNTggMCBvYmoNCjw8L0Z1bmN0aW9uVHlwZSAwL1NpemVbIDI1Nl0gL0RlY29k ZVsgMCAxIDAgMSAwIDFdIC9SYW5nZVsgMCAxIDAgMSAwIDFdIC9CaXRzUGVyU2FtcGxlIDgvRG9t YWluWyAwIDFdIC9FbmNvZGVbIDAgMjU1XSAvT3JkZXIgMS9GaWx0ZXIvRmxhdGVEZWNvZGUvTGVu Z3RoIDQ1Nz4+DQpzdHJlYW0NCnichcKHUtoAAAbg57K1e9s6URFRBJGhgKAQwgozEPYeYQuIgAyt du9l28fqH+Odd613/e4bmzSOnb+GU3wT//o0d5xLjM9cvIGzxE2umX9rDkmugLwtIO/gvAXv8hes 987fX0TbAyHf/nCJ+0iEDny8jNQTMXdC7JxYcT5dRdczlLgmJe6pNfRMS7kzMu8srvtwTu4TyGnB Bj2v8OOCMoCLqoBQxQjVzJI6KNoMirZCy6gJizXhFW0EV3VRlGzH1vQxqT4uNcRlhoRsJ7G+m0S5 MbVhSilMaQWRVhIZpTmrIrNqMqe25Dat+S20FTT2gtbOah2szlHUUaVtqqR3lvWussFdwR1PdddT NXprRl/dhPQegf6GOdAgA02SaVqYljXYsob2baG2Ldy2Y+TAEelQ0Q4V6zox3nNh4tCNyb4HUwNv euBLD5HOjOjsyI+5owD3mMkfM4XnQe5JkD0Jsaeh4mkYSy8iWH4ZxQq+imH1dRxr+CaB9bdJ3MN3 KWzg+zQ28UMGW/gxi/v8T7k2/3MeD/hfCtjhf2W7l4vdb8XexVLvO/fwcrn/46+V/lll8M/hWXX4 88q14a/a6D/ro9/1oyv+AajcmCENCmVuZHN0cmVhbQ0KZW5kb2JqDQo1OSAwIG9iag0KPDwvUGF0 dGVyblR5cGUgMi9TaGFkaW5nPDwvQ29sb3JTcGFjZS9EZXZpY2VSR0IvU2hhZGluZ1R5cGUgMi9D b29yZHNbIDAgNDY4IDcyMCA0NjhdIC9FeHRlbmRbIHRydWUgdHJ1ZV0gL0Z1bmN0aW9uIDU4IDAg Uj4+Pj4NCmVuZG9iag0KNjAgMCBvYmoNCjw8L1R5cGUvUGFnZS9QYXJlbnQgMiAwIFIvUmVzb3Vy Y2VzPDwvWE9iamVjdDw8L0ltYWdlNjIgNjIgMCBSPj4vRXh0R1N0YXRlPDwvR1MyNiAyNiAwIFIv R1MyNyAyNyAwIFIvR1MxMyAxMyAwIFI+Pi9QYXR0ZXJuPDwvUDY1IDY1IDAgUj4+L0ZvbnQ8PC9G MyAzMCAwIFIvRjEgMTEgMCBSL0YyIDE0IDAgUj4+L1Byb2NTZXRbL1BERi9UZXh0L0ltYWdlQi9J bWFnZUMvSW1hZ2VJXSA+Pi9NZWRpYUJveFsgMCAwIDcyMCA1NDBdIC9Db250ZW50cyA2MSAwIFIv R3JvdXA8PC9UeXBlL0dyb3VwL1MvVHJhbnNwYXJlbmN5L0NTL0RldmljZVJHQj4+L1RhYnMvUy9T dHJ1Y3RQYXJlbnRzIDExPj4NCmVuZG9iag0KNjEgMCBvYmoNCjw8L0ZpbHRlci9GbGF0ZURlY29k ZS9MZW5ndGggODc2Pj4NCnN0cmVhbQ0KeJyVVV1P20AQfI+U/7AvlS5Vudy3fRLiIUARlZDSkrZI qA/GOMFVbAfbKeq/755xIJfkUHkJRNmZ2d2bm4PxFI6Px1enl2fATk5gcnYKj8MBA0YZY1wIFkEk GGjFoM6Gg58foRwOOCxeahgznCmvaP5xOPg6HMD51SnAlgB/FTjqsdqaqNeKJeeHtISk1gKqgYko Zxa01ZRxENQYwyEthoPxZZEsMiPgrIJDwqIXHl9cCwOLpp+A25jGwtHaKAbJ8a8EGXMa6Zc59rjk 3paEUlwd6NypRZ3aeJq0bVaXkDZIZTQ0aengSkRUdEgUNcy8uT3VC09mSPhZAnLP5m4StxoOBntR OIWxlFuYFdv6zE2LX7nsv14MB7fHTEaTk18w+zIcnCPnMy/f5Y0FrkNs896SyxLakSYPGeDnKmna TzDyiTZowbtteuibrAxVa0nVjlaQWdu92mk9UqT6naUtNNV8dKRI+5TU2CVXpM4eR5Ks8zq7h5Eh CaRYu27aqthVeF4CxXM9uAhpaBT1gnmxWmZFVrZJm1cl6jBSzeHi23fcywTSZLkcHUniFA8PoSSa e4dz9WdRu07vAhjNGY12MNv8e8bR/2UcYSMa94t8nzW2kWTmTHG4cS4s1dovX6+atsZlZUnhTgU3 N8FjARHikJJR7lOs6ucTD62YKyqNDymrJ+fch6QB3HQCd50zlvfQJvUiC1Jt5jWaqg3V00OePjiW p7w76yX6SpKqxLHW+I/ry/QKVeUK2uRuiSuyZPoj2LIxVO7o3IRqY9aN91oLXbYamKW3JHjTNMOw 82GsQ4R60lzuALzr9q4rJND1rsH+CmF0hxyjLI24X/+m1c2u1X19i7viAjh6AQP/xerqkNV9JL47 FN2/jUSr5w0ea9DuGGaW+5CsbNZ15mzQAMflMYYfH1xgTDA8BBHOSWlVrDBP7vJl3v51IYY/cTKv 6uDZKEaNP1aXIsEIMSym1q8PTtEPbhCxqV1U2GVeLoIY96JqH4PtYxTfh8JcaVfqId486Mg7aMwF gQ5Re7mGOak0NtNRPr/53dtHNhEdDBru7uAW+JZcr1erqm5dPI2OrMv5UEbhm4e9bGPDT540nLLY Kw7y4naEXzrdZB8aJJwnGs/QGA94WbjgW2TN3sUVh3cpqODBLrvj+QeQryc+DQplbmRzdHJlYW0N CmVuZG9iag0KNjIgMCBvYmoNCjw8L1R5cGUvWE9iamVjdC9TdWJ0eXBlL0ltYWdlL1dpZHRoIDE2 NS9IZWlnaHQgNjcvQ29sb3JTcGFjZS9EZXZpY2VSR0IvQml0c1BlckNvbXBvbmVudCA4L0ludGVy cG9sYXRlIGZhbHNlL1NNYXNrIDYzIDAgUi9GaWx0ZXIvRmxhdGVEZWNvZGUvTGVuZ3RoIDk5MTc+ Pg0Kc3RyZWFtDQp4nO1dBVxU2fdfu9decxFExO5uEUQRDDqku7u7u7tmGIahWxpUMDFA7BYwUBFQ sQP4f2eejgiDi7vG77/r+ZzP/dy579xz49x74r373vz22y/4Bb/gF/wjmDd33sIFi5csXjJ69Oif 3Zdf8C2hb9++mzZtsrOzz8jIrK6qfvfu3du37560vLt353HrE+TfouTevYZDFYeCgoIlJSUnT578 s7v8C74aBgwYICQklJ6W/vLlq/fv30Omz5+/uH//weXLV44fO56VmRsTTc7bV3jq1OmrV64+ePDw xYsX7+gAyvdnz543MzP/Jff/FzBw4EB9Pf2mR81tbe1v3rxtbn589cr1QxVHsLspFEpISKi7u7ut ra2ZmZm9vb23t3dkZGQiLTE3N/fYscrr128+fvwUtd6/b2t7356aksbJyfmzB/QLeoS9e/fevHGr 7X3HmzfvILg7d+5evXr1zJkzx44dKywsTElJiYmJ8fPzc3JysrGxcXV1DQwMjI2NRXlBQUFFRcXp 06ex/aEEoAog8fa2jvfv3oeGhk6YMOFnj+wXfAabN/NUVZ15/7797Zt3z5+9fPz4SUvL4+bm5vv3 79+8eRNyPMOA0tLSzEz6NoeUkdJotOLi4uPHj58/f766uvrs2bO3bt1qbGx89uwZNHt7ewcB+Ono 6Dh48OCfPcpfQAcLM6u3b9pev37b+vTZ45Ynz589hw/W3t4OiwzZnT9/Yf/+/QEBAXp6erKysrt2 7eLj41u/fj0PD8+OHTvExMQUFRVNTEzi4+MPHz5cV1f/9OnTV69etbW1dXSG9o5Tp079+eefP3us /2nAjqNSk5+1vnzy5Nn9+w8fNT56/vw5hPPmzZu7d+9iw2Ivk8nk4OBgbE9DQ0N5efk9e/Zs3bqV n3/b9u0CO3fulJCQUFNTg7hdXFyCgoJAXFZWBoWA3f2ZtNs6IP97dxtWr179swf9H4UpU6Yeqjje 0tL68EHjrZu10NvYzhD37du3ob0h6PT09OTkZEgwLDTcytJOTlZRUlJaUkISe1xZWRmbGrZeWnqv jIyckqKqi4tHbCwJ6j07O7uoqAjmvqGhgZA1djrda3/fBmPx6sUbeTmFnz30/xzM4p5dc+ZS48Om utrbly5drq+nK+E7d+5A0IkMgAOWkZERFBiioaED+aqrq2trayOFoOXk5FCCnY59raWlpa+vj90N Va+goGBkaJqUlAKDXlJSgrSyshLmAKEc1PvLFy9fv4baePv6VZudjePPnoD/EEz4Y8LRI6du19+9 ePEyTOqVK1ewo6uqqtLS0qKjo+Pi4rBJI8Ij5GTlIFyIdffu3Zs3b4YeXsmA5QxYsWIF8RPlW7Zs AQ2IIXosCU1NzZycnPz8fKRZWVlw5KA3WlpaGhsfNTe3tLa+eNzyUllR/WdPw38ChgwZmp627/r1 W9XVNYieYKAhDnhZiJhgfMPCwiIjoqGlsX/hhkGOEOuiRYtmz549ffr0qVOnjh8/vjM3lHBwcHBz cy9cuHDZsmWgR11YeSUlJR0dHcgaK4du0EvLmpqa4A/U1dU9uP+QoVUebt8m9LMm4b8DVlaO1dXn Duw/mJSUlJubiz2YlZllZmZmZWXl4OBgZGgGf1tISGjdunULFizg4uKaMmVK75lD7oTQofCh/MXF xWOi6aE6HDnojYsXL548efLo0WNYYFWna4oLKyZMmPj9RvoL+LZsLyo6kJ9f6OnpaWpqamxsDJu7 lQGIsNasgZDXQW9v3Lhx7dq1UNRLGbBkyRKkffv27U0Tw4YNg9ChE0RFRVVVVVFRRkZGREQESwg/ 3d3d7e3t7ezsvb19HOyc1FS1lnyEpZ8DSqA3vveE/Ith+PARkeHk8vIKe3uHoNDQK7W1HV8Ddo5f 4V+xsbFB6HPnzqVSqV/VCuB6ff21+vq0nJwJE3/t/b8PSgpaRYWlaWnpEDe2MzUx8Xpd7dVbN89d uVx9/tzpc2erzp1Fpjteun4NUoCDvXrNmt43x87OfubMGVS8cvNGd55o6zQDkUcHLt+4js5cr68F 8aUb12BcBgwY8P2m4l8PkyZO8fUJKSku8/f3hzHV0NCAUT56/Pj9R48aGhvr7t69Xlt77datG3V1 LBH+NF1wN26MHTu2N83x8/M3Nzejyq3bt8G5CzeiLaS4eruhAX140NR0v7HxTkNDTU3Ntm3bvvds /OtBZI9MVGRseHiEr69vYGCgq6srLOOsWbNu1tY2tjQ/ffEc2Pz0SdOTxy2tT4GPn7USSPxEOaFp EVv9ZVvw+gjih81NYA62BEOCFbMVtNj68gXK8fPBo0b47YWFhdAJ338y/uUwbux4C3OHjPRMSNnb 2xsbXEtLa82aNRMnTsRWetj06HHr05dv37TR722zQPqdsY6Ot+0fboPr6ur21BD8NKwHguzZyxev 378j6jD5MHm+bXv/4s2rViyz58+aW1oQoGEdDh069EdOy78V1q/b4unhGxkZ7ezsDHGHhYYhVuLh 4Vm2ZDlMJAzlkydP3nd5qNEzvHnzBm5z91YQm1+/fr33Lllbe/vr168bGxsvX76MaP3HT8u/Evr0 6aMorx4TQ7a1tXNyckIIbGhoiGhr9+498Jw5OTkRYcXFxT179qyd+czyr+Dq1au///5751YQaoHD V8i6re3FixcNDQ2HDh1atGjRlMlsf06d9rOm6N8EkyZN1dE2iokhOTg4QpkHBARgX2/atGn7NkHM Myz44MGDR44cWV5ejvnvvcQTExMJ/lgtiOJ7L+gOhpMPfQI3jUKhjBs3butWfsEdO3l4tnfpOWwN AnA+Pj4E7GoMQGbt2rVz5sz5YbM3Y8YM5j0BZBBd/rCm/x4sXbzK2Mjczy/A0dERytzNzQ1bG4HY tGnsUL/wtAmLycXFBVUM7dp7ievo6IwfP37//v29FzSYwxY8evSotrbWyMhozJgx6AlD2/ByzZiL YEFKSioiIuLUqVMg+zIr9DYhIQF9+PJ9v2XLlp3qBMnJyRGsQEjo0x3d0aNH6+nplZWVYU12b/fl y5clJSUKCgq9vO/0g0FQQMTGmn4ji9DkmB9sbWlpmUmTJrGxsQ0fPpxJCYMOQbx9+7aXsoNE4GJ9 lawxVw8ePKiqqoKGQYsSEhLwFZFHr86dO9d7Vl0AFmHdunUsh6+trd2bjoEMxPPnzyeTyehkbxpF h//XDuPBcO+VUXF2cnNkaHKEYJheiHuHgBA2JhRpF2dYX1//8ePHULZ/e+Z7AhhrGPc7d+7Adccy GzsWjY+DhrSzs2M5vRABqmDt0R+evnyJpYVefVnzREdHDxkypMsMQAP0pnv8/PyIH/9SpXSBmzdv jho16seJ869gxIiRigoavj7084Tu7u4w3JsZMG0aB+w14qZBgwZ1qRIVFdXa2tr19BEraO9ob2v/ CzIQvH7zGtjCiLbQB6LFaWzTIOuLFy8SZG/evgEN0rf0k+z0o1MwK4TOh99+6dKlGzduQC1A7u10 kbcTTb9vew9iVESG4HPs2LEuEr916xbRDQLphyw+4rv379AiURF6vvvomGy7l6PdDsaaxMT+OHH+ FcDj3Suj5ObmAZMNhwqxLWQNpd2vXz/IGlEYMl2qQL0XFBbcbbj3qLmJwObHLZ2xqaW5EcWMDHGV IMPPzvn7Dx/cuXe3tr7uVl3t1WtXL166KCYmBv79+/dHCiVDbGo0VH/nNijv3W9AlYePGgmEcAsL CwUEBAhzg03Ey8sLoTAbIrrxoPFhw4P7qA4kxOHn788cy9Q//wQNUYVA5qCARHUUPn76BCkaRWdu 370DVuBJjIVZkUBmu+gq6t6933Dt2rUfKM+/AM7p3HKyKp6eXpA1Im4IHYZSVJQ+7QMHDuzJ2Zg8 Zcr+iopzly9Xnz9fc/Hi2UuXuuCZCxdwCUhkkBJkSIkq1efOVVZVHT1xovzIkdKDB5NTU7lnzfqN YVyQLli4ELJuffXqRFXVierq0zU1RC0CzzJSWnLykI+GhqgFmDN37vkrV4gOfNbouXMnq6tPnTlT 39BQdfbspI8vNfBu3fqwuRk0RG+ZyKwOBP0JRlcPHjpUfOAAhUbLyMnBzzPnzxPMCWImMseLilXn zl28ehUO5/eWYy9hFvd8eTkVH29fyNrPzw/mG3tEQUGRuMqcxu6wctWqAxWHyo8cPXTs+OHjld0R 5UzsXFh+5BgyBw8fKSrbn1tYlJ2Xb+foNGLECCZnBOzQ6k1Pn5VVHDpw6HDFUTo9UlREeqTyBLD6 3IXp06ez7GFeYRFaASWzaSJF9f0Vhw6iw8crN2zaRBBr6+o2tjzFpc697YKl5RUFJaXpObk7BIWY nsySpcvQty6jY44RrRN45MTJk1VnJv7PPLmbO2fR3r1KELe/v39QUBACMYSxamq9OjgkLiVddKCi oOxAfun+XmJeSVlecSnS3KKS1MzspPRMUQnJLmz1jIxfdXTkFBSDhl6luHRfUSlSonp+yf7z125m 5xf11KuT5y4UlB5Alc4IVjmFxcgUHSgvKT/Ew8tLEHsHBB09XY3yHrtaXJqWsy+KTOGcMYOowlxg 1vYOaOhLIy0pAwGa6+4f/iyYM3uR7F4lTw+vYAZgdyPO1dDQ6GV1/7CI1Ny85Ozc3mNSVg4tMzsh PTMkmjRv4aIuDCdPnXrwxGnwTMzIBjHSRKyKrByiIvJp+/Iv3KpvbGw8zYBTnwNK7rQ8jU9N746U 5NS45FRkUnL2bdhEj/IGDBxITc8EQ7Bl2U+UowOU1LRNPFu6j11MSvoLYye6nZCRFU6O/2ci+pYw c8Y8GWkFdzePsLCw8PBwHx8f+EgqKqp/WRErNj4+vvldByU1g5SU2nskJ6eRktLsXDzGsHpUKrlX 7kj1+eiEpNjElJiEZKTMikQJMjG0ZHJyelJ2XnpBcXbx/pzSA0iBGYUl1PTsKGpiGDk+Ii6hC4bH UUNi4sJI8WC+ZPkKtMXBOQN8YmgpwO79RCFajKYl+4dHsTRqIlLSmUWlLMdI7yq9empUfKKKVo8P jH4YwAcjhsDBPlNGmu6ZI7xCWIoNDl9XXl7+y9U5OTnPnDnzpK2DlJweSUmMjE/qJUZRk0nJGUgH 9fCKkLmdAyU1CzzD4xK6cqYkRlBoSEPJ1OAYcnBMXCgpHmQRDOIwEjWMTEUmJJYSEkPBpc6IQtAH RsYGRMSEkigzZtJvdfJs5S86UsmiIUZb9PL4JPBU1zVg2VV1PYO0ghLWw2d0FYimV65hfXvnRwLC KyK8nTRxqpiojLW1LYlEiouLI5PJggwYOnRYT3V37Njx5MmT01fqSEkZ0QmpwNjEtF4iKSm9oPxY y/sOZU0dlswjKUmkxHRQxtBYsEVbKA+PowVGknxDI/3CogMiSIGR5IBIsl94NBCZwG4YFEVHUPqG RHoFhYfGJhAuvZqOfl758WhqSve2UMIYVzra4t22g2VXfYIiEzL29dRPpFEJKWDOUon9YEBsS4Sr w4f/Liq8V1dHH4KmUqmpqalCQkK7du3i4eFlWdHBwQGha9nxanJKJjVjH4EJmXkfcV+nws7lnzAp p/Du07f3Wt+u3bCpC/PBgwcnZhUQDFlyoGXlJWUXKmpoT2PnYOOYPu1rEbXY2dnYPxxoDIgiZxQd +Lz/nw0E0oxPy2afzuJG6NQ/2ZJzi2hZ+SyHSXQ+Li3bNyzqW4rtH8Do0aNHjhzZ57c+u4Qk5eWU KHGUxMTEtLQ0WVnZPXv2mJiYd6FH8FhYWAhZZxQcoKRkYyqScwoTM/Mx/8gghaTwEykzT1zqjPRL mfm5pYfpa+ZY1aQpUzs3MWz4cLClpGYTdZncmHzS8koyi8p3Cot9g+GPGZOSW5ySW0Tw74JEu7SM vChKCsubD5t4tx49ewVkxKC6Vs/MT84pSkjfp6Fr+M+7+k0A4ibeuNywnl9CXCY8PIJGoyUlJWH/ CgsLm5l9Ju6lS5ciFr7+4GksLS2KCscmk5KaQ07OjEvJQiYuJRsZIo9CXGX8JArh2eYwET9BgEx2 SQUk7hkQNnDgp5u0cCdCYmGOE2MS0ggygu1HzE7dVwoUkZD5jVXEPWfOnCU9A/GAkmvmTIJ42crV uWVHmV3qjMzOx9DSDUytWM6ekob2/sozRA97qJ6N6us2sXDpfwqMGDGCnZ196NChs7kXSojLurq4 QdzJycnY4+Li4tLS0jNnziIolZWVX758mV9+PCACpjAuJJYaSqLR09iEMHIi8sjQkUQLiqaAhiD7 UMigYeIHYnr1hPTCA49edciranbulbK2vldwhG9YDJiAG9HWh4okGikpq+bGfUsHt+7DgXv55Zvz KXkl4LNxCx9BLyIpU1BxIjiGSvTnM4yFv0cNiqb6R5D4tguynD1HT38ItKfqKA+MiguKjvtj4qRv KrS/D7DdHBwcbGxs48ZOEBeT19TUTkpKTklJycnJwdRJSEhoaekMHDgwMjLyeUdHCCnJ2SfExS/M PTDSIyjKPTACqUdwFDOPclwFjaNXoKNXkJN3MH6C4BMlExnERJpVdqy08tyK1euZvZo2ndPWzdfe w9/BM9DRO8jJJ9jZl96um3+4W0AEuKUV0tWCv78/divoMQR+fv59+/a96+iIomWCgMkc9K7+Ya7+ 4S5+oegPGGoZWTAfAWibWAZEU1EO/izQJ8TJO8jFN5Rp6DsDjI5PaKyrXxjRve6IcnC2dGSxLH8i TJkyZcGCBcOGDRMUEJeWkkUslsEAT0/PjRs3Lly48MSJE6XV1209Ai2cva3d/JCxcQ8AItM5j9TS 2cfc0cvM0dPEzt3U3sMM6Ohl7eZPXCXomUhUBNp5BxefvBQQQ5sw6dMJhIXLVhjauJjYuZnau5s5 gI8nEMzNnbzM6Tz9YlMLXnTatshTssscfUIJziAAWrn6Wbn4Wrr4WDh5mdh7GNu5yWvqj/h4ngqe Ki5ZOnt3buIzdPAwd8BYPFhG3DNnz3MJiDJ18DDtqS5Se89d4v9b5+vGjh1LvM23cMEKaSkFSwur zMxMqHRnZ2dePr6bzc1B1H26lq66li761u6Gtl76Nh4GQFtPOjLy9EJrdx0LFy0zJy1TRzUjW2U9 i1nzFq3ZtFXL1EnPyoUgIyiZ+KG6rSfqmrsE5Z24rmZoM2jwhzuNXFxcM2bNVdA2UTW0Vje20zS1 1zJ10CTQxEHLzBH9IRgSTIiMnpUbynXMnXUsnLXNnTRNHTVM7MFWzcBGTtNk0bI1nQU3ccqfGJem iT0dmcw7oYaJg7qR3U5xOZbztpZnm46ls8aXqttrGNvNW7ziR0ix1zBq1Ki5c+euXr164sTJ0pLK cnJKISEhurq6Vm5uh+reGrmEKOhZK+jbKBs5KBs7KBnZI1UxdkRKL2EUKhrYyutZy+la7tUyl9Ew 3S2rOX4ifZ/2HzBASFpVTtcKBJ3rMpEoRAapoXNQbGEV325pVBQXl9y2bRucimHDf1++nk9EQVtC xVBSzVha3URaw0Ra01RG00xW2wK9UjK0I5DeB10rWXRA01RK3URSzUhCxUBMSU9CWZ93p+R07nl9 +/XvMvDZC1dIqRmJqxhI9Ij64DN/+VqW88a3S0pC1fCL1Q32apqNGvvH95bg1wKc8w0bNkClr12z hX+r4OIly30T84OzTu3VcxBTNZXQsJDSspLStJLUtKRntKyRfshrWomrm4NGVMVYWNFgt7zeBgGx IUM/nXQaO2GKiLKRmIqJpIblp1p0Dkz8UIjUwDXCPjxr1qKVAgICUlJSlpaWGhoay5cvHzBw0DSu uQtWbFq3XWybuIqQjKagjKaQjNYuWZ3dcnq7FfSQ7tyrs3OvNnFJQEpjNd8u7kUrJ0yZ1n/gQGZn uujk8ZP+nMY1bxrXnJ5xLjv3/KEjRrKcNDauOWwz6NhTdXauuRzcC76TyP4JjB8/nngDd/SoMdO4 l8SUX7cMThVVNxNWMRFVMxfXtPyIVkjFNOiIvJi6hYiq6R5lY2Flo53y+kLyugtXbeken85dvmGP kpGomhlRkVGXBYppWICndXiWhl3g+MlskpKS1HgqhULR0dFZsWLldHaufn0/BGuDhwwbOWb8JHYu YraZOGU6N8pHjum6m/ow4EfM4/8fmDZt2vz587eKSGWcf67jGimmbi6uYSGJ3adjI6Vjy0Cbj0j/ iUsggBBFVU2FlY13KuhxcM9nyRluMJ+YMhhKaFp9rG7zOdoyecoaOvmkHMVC2rVHJC4uLikpSUlJ SVRYQlBAZO7ceYBx48b15klib0SMiGMYA4Z/BJbHtHrZVnfoQqampraPAc5ubj/9YSgCcCd//7Ib rwxcghWNHJVNnVXMXJEqmTgh7YwoUTR2VDC0kzewldWzltG22COvPXbCl0LLcRMny+rZyBvYoWIX bp3ZEo0auYVTyy8Lyajq6OpqamoqKaoqK2lv3MAH72LWrFldzoT0NLe9gaysrOZucOfOnby8vE0f Tz58Q6AkJp69fPnClSsFJSXfQ9ts3rwZsbOCggLs8pcpEYsdOnSo9OIDa+8IU5cAY0dfQzu656xv 62GAjJ2X4Uc0IMptPPVs3LUtXDTNnIRlVIYOG/5l/oA1m7fqWrsZ2DJc+k4MP2Nr64G8iUtAaGrx vlM3N/ILrVq5WlFRQ0ZaDfMPcU+ePLnLayl/G6BzDh89+rCl6WFzU3PrU2DT0ycPWpobGh8SkZ2X l9c3aYiASZMm3W64V3/3zu3bt01NTb8hZwKgqcAZ3X78rNXMzOwLlFgMDQ0NB2tueYbFIZB09A2z 9w6x9Qyy8wy28wpGvguiEJcQTVu6+m4VEu7bt+upRZbQt18/NQOLnnh+4OxJ5+zgHeoRSq68+iD/ yLlZcxds4xfZwsMrJCSE8KHLJ1/+CSD8bGxsfPPubUtLy4ULFyorK0+ePHnr1q3W1tYXr+iHITEn MBzfqjlYCn5+fj4+PqRf9WGTXgJsMXEO/N27d3C5eyITkdybnF8WQU0Jjk0IjKL4hcf6hEZ7h0R5 h0b79IC45BkU6RoQumzlV7y2D5jKNs0jKMIrNKonzsym0Y3gWFpMUlYImTZ6zFhsbfjnCB++4Wlt +KUdjFceamtrubm5wXn06NFTp0718/NDYXt7+9OnT7du3QpKLDMU+vv7E7tSUFAwJydHX1+fyap/ //5YjSQSCRry4MGDIF64cGGX5sDEiQGKiopdLsFlgiYpKys7fPhwTExMT58QhGYzMjLKzs4+ceJE fn6+jY0N80PxWlpaKCGU0uvXr8PDw9FbUVHRztUHDxmiZ2JOSUmPjE8II1GC6c+Co/zCIgn0D+8R AyKiXbx8ODg50TH0/6vMnOAe4S9wBjJbD4qMiYijxqdluvn4YUKwer/tSU5ra+sOxqs9kFFnS4p1 1dbWhp2CXU+I29zcnJhJaADEhh2Mz7cy30WFbkT5h7PlH19nwIIxMTHp3BzxlgrYlpSUMAvhFvr6 +jI+DNtOpB2MFytUVT87R4TlpK6uTrya1M4AopWzZ88ingLBtWvXOneAeDXD3t6+y5AHDx7MMZ2T g2M6O/1BMMc0dgZyfER2duLR8KcSBs6YOXPlypUIlGxtbSMjI1NTUw8cONCdOUtAz4mGurPtjugV B+eMhYsXc0yf/g3VOAGlpaX0W68vXmDCf+sUku/YsYPYI3V1dTC4KIHnRkwmXfm/eYNpR4b4/o+h oSFBjBJoCVhPLBLidSrMPLFaCKDRaCiEpfDx8SFKsDdhPiCaR48e3bx5k/iWIFgRZGxsbMy6mZmZ KHz+/Pm9e/fQCpzJpqYmEN+/f19cXBw+NjxM4vu0qI5L6EZ9fT20UC+nAhygOqCRVq1aNZOLm49X UEhQWEhol5KSMjYFOkylUsvLy6FVEFZAvSCFMoEeO368En0Dzdq1n92JwtrArGLIYWFh0EjwHqWl pSUkJOB4W1la2dnZOTg4wMFgHKjYwrOZb8sWgTlzFmJTz549G5buG9pQAsDwZm1tO0MowsLCzPKJ EycWFxfX37lzq66uqIh+zBWe4cUrVx40Nja1tDQ2NdUxyslkMi5BgTPed2jA/EdFRa1btw4d1tPT q6uvv9PQ8Ki5OTc3l1hFCLuqa2qaHz/GYsDYibbc3N1R/d6DB9jv2KSIAaEnb9+92/LkyfOXLxF+ /sZYhNa2tkQrV69exRTBLq9YsSIkJKSmpoZ4P3HkyJFSUlK19fVPWlsbHjzw8PCAoDGor/pPECxs dB5LHVpr27btWhqmdjYudrZObm4ekCx8Gwz84cOHWOrXr9+A0cHQsAsKCgoKCwsxY6UMKGPA/v37 kaIQqyIlJQVzFR0dnZaWBgJUPH78OJRDVFS0hbmFnq6hnq6xjpYpH68ALy8vjMWMGTO+x3fOly5d WllVdbWuDuIOCAjANEJLQ2QQx/7Dh3MwjLKyVYwPCi1dvvzY6dOHKisrjh3LLylBIfE0DXo4NSur rKICqKnz2REsfSOjw5WVR06cOHjsGGGAZs2Zc/TUqePV1ZXV1VyMd4GXr1xJtw7V1Wio8+uW1vb2 J8+ePVlTY2lri5/TOTnrGhpKy8vRq1WdPnCEPvzZaftPnDQJzNHPoydPcv3dd43hGmFaoC7glmAz aqgbhQbFhQTHREbGZGZmXb92Hc4M3Y998QI6BHKvra07deoUdj3WAyF3bATiw6cAQhtgnUAdQQth qUDtYF+gPDQ0zMXFzcXJw8XJ18TYUXDHLhERESx1RNmEOv3msGEzT2nF0bScvOKKI7UNTe86Oi7e rM/IK6SmpMfE0yJIlC38H77zs0dcvLzyVGo2/Qg0D98n5bxhE8/ZKzeTMnNjKIkjGQ4kM/xfs259 VkFx+r6CpPQs4hL/jh2VNedREhZNGsi4jWNiaX3y7MUjVTWYELh22K3Eke9DJ6tTc/JSs/NVNemv mkrJyFeevZCcmeP8MSpkeZNhCx//6QtXM/OL42jJXzhe+JcAB2nRokUCAgLQuvAWZKTlHex8oyIS YqLiyaT4stL99XX18HZeM75a+57+bxNthC8BVwE7BTYFKcRK0LxkADIwQzBYVVVVcXEUP19/H+9A X59QT7cwZSVtcXEJaP6NGzd+P1kDhCWkc0rLQ2MpQTHkoGhyQFRsYESsX1iUd1C4hp4hW6fv/Kho 6sQmpYWS4rUNP3O9tPSNcvZXkJPTlTS1ujAX3CNCSkoLiY2zdv7wpFtT3zghMzeSmqSqyTh+3KeP o6dvFDU5KiE5JjEN5RH0M6uJ4WQERyR0A+mqdfSn/w4ePrSsPHJKxjbBnV8YjqqOXmJOfnRCsn63 w2ZfC4hNEERg/mVlZQ0MDGBTFORVfLyiSDHJsdHUeAotMwOhwcn6+tuQY0+vABMfr3716hWkf/78 eez7mJjYkOCwwICw4MCowACSrra5hISkvLw89jWMIBcX13f9rworZ/fohNRQcoK5g4v4XgUJWQVR Kdkt/ALdjzFYObnFJKZHUJI2bP7slKaZnRM4ZBYf1DT87J7JgAED0ov2h8XRwik03m0CKOnXv797 QCglLQd8eLbSlcaAgQO9giOiaWmUtGxFda3dohK7xCSFJWR2iUhsFRDCatkpIj7i95Fg5RceHZea nZCVt2PXnp7Ggs3u7O1PSsmkpOcI7OyR7KsA848IhZ+fX0VFBUKXk5PT1NAP8ifHxabFkZITqKm0 hJSMjOzDh4+eOVNTe6sWlh2KGp4kXMQbN25cunT5yJEj+XkFZBIlOio2IiI2IjwuMpwaGUYzN3US ExMnPqULBQ5lwsnJ+c398M4ABUtKziCnZMYkpS9fzfrhJgHDh4+IoqaQU7PIKVnzFy7ufEnXxBwb 82L9w8fPnmFmiEIE74hTqOn7omkpAVGkQYPop+hHjxkLDsm5hZDa7Hn0xwp9+/XzDAxF4eGaS+s/ fzOlc7CMKMbdP5iUlPHodceBypNMHQ4X2tPTk3kgZ+iwYaGx1KzigzU37mBX0kuGDv3nn4yAKZ8z Zw58dTiEGhoacLCVlZWVlFTMTa2DA6Jp1JyE+MzEhAxaQloCNQXST6RhDWAlJFHjk+LiaGRSAplE I8UkxpFSI8MT7Ww91FS04FJi5cBF37Jly5IlS6DAv8cdpy4wZ/7C8LgUr2Co7sg/GLf6e7rrPnP2 3ODoeG9QBkeN++MzbbNoyXL3gHDvkOhXHR0wTPD3YIIRTwXHJngFRzp6+KMVgpKdgzOKmg4+/uFk 5qE1JQ1dz8CIQ9VXYddcXV0RaCOcuXTpEqrvFpXs81FYO3YJewZFBERRoCHh0zo7OyMmgt2MoWUo a+r170//YuTYcX94hUSHxNJeMr4U4RdO0jGx7OWtzr8EWPN58+atWbMG3j4UOwJPyF1NTU1OTt7M xMLJ3jUoIDKBkpFCy0lJyklMoCNWQlJCTmgw2dPN39rSXl1VU0ZGBksFigJ+IB8fH3YHAq4f9hck vNt3mjq4G1k7K2sZf/lRxUbe7aA0tnFR0jbqfnWPpJyBlaOZvbu1W4C9N/32r6WTt4mdq5axFRvH p0Ppq9ZvDqGkWzr7aJlYEy+tAyZMnIyfhlbOZvaeVq6+1q5+5k5eRjYuRjau23aJMns1bPgIdUNL QxsXc0dPxu3lEDuPIAtnH0tXP7G9SgS330eONrFzQ11jO3czJ0+wEtjzDY5kdwYODg6EaQgAN2zY ALnD5urq6kL08OHh1CkqKsoyQFNDE2EmhIstjLWhzgD6A01RUUgZcRZ2NDRG51sKPwA2btu9S0pp p7TK8vWsX5pgwnq+naDcJaO6fB0LykFDhi5euWGnlLKMpomclrmcjoWguOLSNZuHDh/RmWynlIqy kb2CntXmHSKdy8dPnLph604xBW0pVUMZdWMxRZ3NAsLsXF2/FjVm/IR1vIKiijp7Ga1IqRtvERSb MefTXfE+ffouX88jLKcpqWogqaq/Q1xh/ITv9Wd8sLPY7MuWLcN+5+HhgZ7HhoX0sXOh8IlvXkH6 kDhEvH37dhgXmAMYaEgZa+anvPLc+4ePfXphAfv26z9i1NjR4ycOGzGqy6U/prBvFVexicjao2S8 W8n4zxksPvw1eMiwUeMmjBr7x8BBX3oCPnDwkNEMskFDWMdZqD7899GD/0EU9lXAzs7Ozc2NLY8N i10Pma78CPgJdb148WIsjJkzZ3b5jtNPgd4/Iv8yZfdLzBLMv5S2pZFHlJSWpZi6iYCkav8BA79c vfdd6g3Zj4fJkyd/v9j5fxzG/THRxMlHz8ZN28JRQct40q+PPf6rYcy48bvEJAR3i2zk4ftfeP3z F/wX4P8A1crmYQ0KZW5kc3RyZWFtDQplbmRvYmoNCjYzIDAgb2JqDQo8PC9UeXBlL1hPYmplY3Qv U3VidHlwZS9JbWFnZS9XaWR0aCAxNjUvSGVpZ2h0IDY3L0NvbG9yU3BhY2UvRGV2aWNlR3JheS9N YXR0ZVsgMCAwIDBdIC9CaXRzUGVyQ29tcG9uZW50IDgvSW50ZXJwb2xhdGUgZmFsc2UvRmlsdGVy L0ZsYXRlRGVjb2RlL0xlbmd0aCAzODE0Pj4NCnN0cmVhbQ0KeJzFWmlYU1cazkZWIIGQQFgSQtgJ yBIggICgsieAClioxQUURVzqgigq26iodRed4tKZCh3H0WqdWoFqW2rVtijqAyIgUBQERKyIgECW ORcSudlYnqcD7w+e3LPc857vfOc77/kuCMQ4MOdY2VhZsIzHazc9MDC2dPGdGxIWHiGICA8NmePj yDaiTjcpBegxrDxmhwsgCNdv3vSxEPoVFuDKppOnm5ocFCM7f8BwXs7XD1qlI+hpuHksSSgI8eLQ dKeb3jDoVn4RggX774ukSnjx72RhqIe5wfTT1GfzwwQx53qVGY6gIk0Y7GamR5xejjS7uYKoE13q KQKIf0gSzrahkqaRoq6xS1hkXotGihAGriwMcaBNH0sy0yci+tKYFCE8Sw2bYag9TRx1zf2F8ffH 5Qj2epbA3Wh6WOow/YWprQpsJKKh/nc9PX1DQyIJvFx0KsqdPh0rTjKZKUzvgTPpba/64eLZw/sO FJ4vqfijq18Mq7wa5WowDXuc5i5I7YZRbKsozkoMD/DxdPfw9psbs/b4jfoumDmLIh308FPNkWwT ltj+gYK4/fbhxABXOwtTGlRpyraZwY/eeb329SjL4yEcXdzUciQxAxdUfCDQd//0qmA+l6KjhRxt YuMRnVdW8+Ecer8twsZID4BCJqKnhiSVF/XlB469T28UnSrIz9+9zZ2Cgk3ExmvFxceD8lZvr5w6 tD8/Pz9vwxwSUvOb/zqQ2CEp/WqCzd2Z2vDxrYIOvlZt9CwaPpX/H6juCyrVcJRKzjliPzRCEu1z 36i2adjsojMVJImsoCx1HKXS/i1mcodDkb2KBlQaiGvy5prgp2K5KU4x1epJSl/M0x9hgKKH/apa PVSRF2ahMxUbB88I2C4PgT3KNO7OJAKWSKx5crMaQ5dummlCmBKPJFlF/Sgbtf0nZa8Tn7LVQiBJ TvlvVTlKytd7GGKnZGsjdLlLZAaUnMwqVta7vWuMMXq+l4bUOcONYAYeicJTDJlsNpOujRmXL4ZI oehRiJjJk9TnH5IN+mxlUNIVZTp/RNvOf6COolRaH+nkNku4ek/h1WvXvjm2Y/5sHpssc1AkzsTN f5avp5sLgLMdg4BE63K8BZt3gfi7JZLPmmRsxTPCbsoG3RvA4qXckShR+f1wm3qO0sEzV6s7YcKj u65kg68pDhofbbyt42Vn59NqCFWV+WyGe0pZiyw8iJ5/HW6CHZcZDASzhTKFNhRjTaa4ZdQqUZGo xnnlecDQdtybCrYSzuMXeOkPCbtrFK52rzM5WpOxJHOpbIUbfGhEjIFf/kvNFGSzqRaPUVvzEQON 0Il+AS/7/ZFyj95VhpMICwROpqxfoTUJh8Qah/793dgc35Xs7x6r/uXHdDQ9VSHy96m2qvaZhIoi 2p6UdZtP10IjkHjz2EuDqu8cxYsv0tJewZ5FHfd+vt8Bt9QTf23Lo2POE2AgkTJhjigC94Ksm+9w XEaRbJeXa15O0aO9McJimFMOlO9PTVx9DO7JkiwW/6ZyR7GyI+eYTniHo/AzvpW92hMx3AtNdtlU o4ljf1l6oHs6fPV+2+Bna2EvOAvfF//1EDQodJN0Vdz4pV2hSHrEYsJOicQ6fy+zkbusE4bqs6tD PceuomQeOxxOoO/S2qig2cGf/ANOsjx0uYLXip+cSEtY+aWir+/hTHznYBxkJMV8uRLHmsRdVVU8 oEX9kQW2VOsj8IUTvX3dCdClcGzejstRWNznu0PtzZ3XK1xGB7cwJx7QUTby5fbFyaaGs96gEEDk r72zM8hcmzirTk2dIn5adlFhcl+GGuPRBvEKGuXVCsbEfRJpId84oaThMw1JdMhVo8ClkoqtPgw8 ipwwZvwZxrdrH8Efu9OtwDGk97FCAH4UpT9hQ6JxDHkIWqGHQUHq1vsr9SGoNcUcjEVbO8Z5I5vO kXSFTfL0IzoSgTRKew8vPO818fwCRpuSLut2yRSHRmAMBRVSDSj1xCOQZtnwov7ntY+Vce/rFTsU XPo7fx0weetT8LLBHJtJnIt6dKHsWOzgamvhOKma02pDn1likOb58KL2wo1paWlr1m3ckiHHllVR wSfgbcT7uOBwwXrfhRe+WmkyiWNRj8WT7RJRMF3f9bCGBOowupcbopmZ8Ej/bD3P1tbONXLvqTMy nD6+3nm2Qih/s44JnF076jm8sGrexF0SgdAxdymXddzLCy9VSUMroCFcz2QtPNr8ucmWbGAdWQJv dJ4rVAjljR/RwD6mJisc4F/7TCblpc3mH5R1fJk9bnT5gW8aXwkvqCtI3FqkYKPuNOdlCgGgLBC4 pJKbDOXZTkpQmvjEyI8ClXuYCsTHvaPOqNE0o+grDnPZDg8Aks8cgUti3K7DW3WtNp3UBY7KW3hH 45A9yor3Xdbi3DHUpKSjaAmXfx5e9HYDC7gkIbgeXvhkweS+XVEcFuzSEPrEdZdvKd952vc+1Ehx sO367vm2NC8FVV4fB7mkTjRc3kn/4zPJXLFZyKf1UnUYKN+ZuFWF0rMPU1CY2sCbpp+LshP4TG2S 8+dVzztkeFFz1Au4JEI3sLTuhbzw+YMUq0m5JAJB46+9os6U3RdX8q19816pqRqufnT7fs3z9vaO jvbW2kclxYe2JIa4mVOwKKzZ3NSsPIBcgO0pgaaQBCdaRa/PzpUhI5FH1WG5utvpTdgxUa6ZT9SQ aP08nqtPZISfU39IDpXtTUldk5EFxszOXL88NtjbkU3XhoSUFjMiLWPbtm0Z6xaFeLnYGBEhJlpk loOrmwxOHKq2bXFjU+VMjeliJI5qYqKPk2sQjHFygyoHUdVegaUOGkngJKk/Jqtygp0sbJ1cwJgu M+wtzehkgiw7gPeqez8Aobf58wAGUWvYWkgMjkiSg4jHUKI6wZ0xUuMnVS1OzoWvNjNGrvFIgk26 GoU78GPGLFPisN7g5XSq4dhzdr4JGY0lDI9MwGFQo7pL/5PRUFbpqd5WSMONoLYmgqLJkOQFIC7e dBj2XKSOx2k1+dN3320MpI/YGmMY9k/VBRf9tNWVpv79KNbfQESQiIcD1VC6Kc3KnmVgYmeujUIS jJ28+HZ0LBKBMl11p67qmJcOEmtg58nnynJKaDKH5+NuScZoe5yUQF852AQooxf8s5o903d9TzyP RR+ZE56zTPUbVOfpuWYarIBxvQY4tlTcrYWC/uVZa+7eu5pwuu4CR5sV9sXjttbKXBddJMZqV+0f FUssCHru2RUtbVX7XHWAmtN2SL3R9LK5PNHa9VoH9JKqI0wgTdwq1Trc4Ok4YZCvqx2Hbcq24iWc UhHBfZn2mgQCIRjcHAf/tXbFPug6V7r0V+B7QANf9/UpGFG94h+9dfB8EEtfxzFMYx8MG0lS4kZA G4SWjKxZd748PV7BAxcFmxUXbj2ofvy4rvHFm364TXu/ixQIBOEQohZl/qdeoXKwo2wRW5P4p3zy J7D0Zp7jkgfQzWEr8GhItXyxtPxD/2I7PSjD8SzWJgnyd6havMOUJmiSN/huv+zHdT7YQwbOwmWp QBGmbd97vrJFUQINNF7dLhQIhAW3XyoehG8fFi5205SERprmAZesWeM79xCwf9++o8NH1sCrgzeg qTc3QhnQzmirjUCmVy2c91gqfV//+wtggV/85gB7S/5saO4VV6bn1IMh+1vvZ9gDRyXSWNa2wwiI zS59qu6OqAxJW+n2cGcdTUlGDBf60tv28LdaaOl+31oKdWm5cuA4WMCuy/v3XAIKaShzVhEo/nYx uF4NPSz+eylQf03LjoOGjed25Z+5sCk8ARJ/1UeX+xhC80ZhtLAj4PikXqoeXwcNPv13khsTHnIU gfO9PTqfxpxUyDFbjyUuAT44dC3J1/9TIAdF+QvBXhw8mgbWfLC9uakVmLU5B7hyb2Gsl1fgHFdr IagX/TPSlkZQej3LJbagokNtTnd02J7qwhguQwNBCKTR5EXfvRzB8jZoaKFTAriadWW76DMSmkCE 27oabN6uzK2wdMG9w+ChOc2arEs10KUuAPTfbLImYlTOTVOHuZlljW/GUGL9LTdzwmwNx+CI0F/8 J/SN9+2b9sqza3wdVwEfbFhhYbQIlHauY+EstoFlr121E/ytS80F7tXT0dLS2v6yqeDoIHSvNMBR GbpoajJg/DServZot/KMO3CruVeDchtou3Mo3oOjIYiPAMXcDbZf+zenjuSuDHWgW0G76FYIxeBj oFPElyJ9N4F73lBh3DExlFndDpa57fqXRf999NW2+Lz30Af/wNm53wfRmTsA48p1swzVfn4xs5+Z eKKio3dIhaeo/2XFycXediZjUQTxYjiU30ie4+1qbUjCO18BT0VueErYPcifa6qAhUT3kiMuguLi sFXAvOJnD+veSatieclQFub1w6di6WNfh2Ng/N7WajcNOUwW13/pwZLazneiUb0oEfV1Pik5uMyf azY2RRDKg56CqLKHRyOTcGgkfjbQV/07rDBE5zz5nhTdT/cRghA6sMsjokQ+RE0wM7BY7mdNAufD wz+q/TXe1tiO/NDl+y5XPuvq6Xs/8L6v51Vz5eX85eFeXOZ4FMG9LviPgcGmRYwRbyLNaRgYbEww QmGMhUWvoD35vvP6Jv8ZK8HZ07XSkrv6zjtAU/SmYp2THmfZjz3gQdz9aAvPLqVVLJV0n3Ef60rJ 4XrMWbg660DB2XNfnPhsZ1p8EM+ebTQ+RUBrxpqCk596kEciFHFG2vET6911kUiS5bzdl397cOur 3Yv4Hlt/BWweRNKp7iknb9777VrBGj8jPGXG0mPfV94vK/w0wMRoZuY3d8sOxFiM8+8J5jaOrh58 bz8fvrsL15o50SsJlubo5+dIw8qfuH5+XOgJrc3yjFq64pMITw57CZQUGjjKI2GptgEfJSfFzXY0 IqC09Kz9Y5OSF85xYhCJDPeoRTF+HN2Jfbc0HismqgEKRzYw0MWiVJ5QOIqxhaW5EZnA2gPtofIE phYSQzRgcjhmBiSgl5FoItWMw2HSSFpIFE7PmGVqQBz/I9tfDXC6YdAoBJq5ub79+bernXQhBkg0 KJRTgT0gUWiNh9oUAE2bmZqdEeesP7FPjP8DU/4xtA0KZW5kc3RyZWFtDQplbmRvYmoNCjY0IDAg b2JqDQo8PC9GdW5jdGlvblR5cGUgMC9TaXplWyAyNTZdIC9EZWNvZGVbIDAgMSAwIDEgMCAxXSAv UmFuZ2VbIDAgMSAwIDEgMCAxXSAvQml0c1BlclNhbXBsZSA4L0RvbWFpblsgMCAxXSAvRW5jb2Rl WyAwIDI1NV0gL09yZGVyIDEvRmlsdGVyL0ZsYXRlRGVjb2RlL0xlbmd0aCA0NTc+Pg0Kc3RyZWFt DQp4nIXCh1LaAAAG4OeytXvbOlERUQSRoYCgEMIKMxD2HmELiIAMrXbvZdvH6h/jnXetd/3uG5s0 jp2/hlN8E//6NHecS4zPXLyBs8RNrpl/aw5JroC8LSDv4LwF7/IXrPfO319E2wMh3/5wiftIhA58 vIzUEzF3QuycWHE+XUXXM5S4JiXuqTX0TEu5MzLvLK77cE7uE8hpwQY9r/DjgjKAi6qAUMUI1cyS OijaDIq2QsuoCYs14RVtBFd1UZRsx9b0Mak+LjXEZYaEbCexvptEuTG1YUopTGkFkVYSGaU5qyKz ajKntuQ2rfkttBU09oLWzmodrM5R1FGlbaqkd5b1rrLBXcEdT3XXUzV6a0Zf3YT0HoH+hjnQIANN kmlamJY12LKG9m2hti3ctmPkwBHpUNEOFes6Md5zYeLQjcm+B1MDb3rgSw+Rzozo7MiPuaMA95jJ HzOF50HuSZA9CbGnoeJpGEsvIlh+GcUKvoph9XUca/gmgfW3SdzDdyls4Ps0NvFDBlv4MYv7/E+5 Nv9zHg/4XwrY4X9lu5eL3W/F3sVS7zv38HK5/+Ovlf5ZZfDP4Vl1+PPKteGv2ug/66Pf9aMr/gGo 3JghDQplbmRzdHJlYW0NCmVuZG9iag0KNjUgMCBvYmoNCjw8L1BhdHRlcm5UeXBlIDIvU2hhZGlu Zzw8L0NvbG9yU3BhY2UvRGV2aWNlUkdCL1NoYWRpbmdUeXBlIDIvQ29vcmRzWyAwIDQ2OCA3MjAg NDY4XSAvRXh0ZW5kWyB0cnVlIHRydWVdIC9GdW5jdGlvbiA2NCAwIFI+Pj4+DQplbmRvYmoNCjY2 IDAgb2JqDQo8PC9UeXBlL1BhZ2UvUGFyZW50IDIgMCBSL1Jlc291cmNlczw8L1hPYmplY3Q8PC9J bWFnZTE4IDE4IDAgUj4+L0V4dEdTdGF0ZTw8L0dTMjYgMjYgMCBSL0dTMjcgMjcgMCBSL0dTMTMg MTMgMCBSPj4vUGF0dGVybjw8L1A2OSA2OSAwIFI+Pi9Gb250PDwvRjMgMzAgMCBSL0YxIDExIDAg Ui9GMiAxNCAwIFI+Pi9Qcm9jU2V0Wy9QREYvVGV4dC9JbWFnZUIvSW1hZ2VDL0ltYWdlSV0gPj4v TWVkaWFCb3hbIDAgMCA3MjAgNTQwXSAvQ29udGVudHMgNjcgMCBSL0dyb3VwPDwvVHlwZS9Hcm91 cC9TL1RyYW5zcGFyZW5jeS9DUy9EZXZpY2VSR0I+Pi9UYWJzL1MvU3RydWN0UGFyZW50cyAxMj4+ DQplbmRvYmoNCjY3IDAgb2JqDQo8PC9GaWx0ZXIvRmxhdGVEZWNvZGUvTGVuZ3RoIDkwNj4+DQpz dHJlYW0NCnicnVZdj9pWEH1H4j/Mox2Vy/3ytS2tVuouaUTVVTdd1FZK+uCYi+2u8SW2YZv++swY NgWMo90+ALI9c87cM2fGwPQerq6md7fzGfDra7iZ3cLn8YgDZ5xzISUPIZQcAs2htuPRH2+gGo8E ZN9iODeC65Og1Zvx6P14BG/vbgGOCMR/BJNDbhCb8MAVKSEucUnF4hiQDUzIBI8hiAPGBUhmjBGQ rsej6XydZFZEMHNwiVgeiKfvHqSBrDmcQMQRiyTBxmEESuCvAhUJFgbfztHDUj2VpNZCX6ic2MKO bXqftK2tK0gbhDIxNGlF6VqGTHaZSGq4+a56+kB8s0DAnxQg9mJFJyFpBBisReMpTMxEDIv1MT+n 0+KlUIfLd+PRhyuuwpvrv2Dx83j0FjH3uOIcN5IohzzG/eDduSWdxjde07oapQc/8JZ2V6S2AT/0 npw/kV796GsP8LPepjl8sm3rK8/WlPZUtDn4l7gZynmRXxkWhgf+MqkzWyMnoaf5FnGrR/xq6Nqt zpGfoaTRTJwiLZM2GYhWQjG01En4MXKvQcGLGiTjkEUHIV/XguNMb14ti9qmbSfx5QOIUDGpTtOW tklrzCk22DiUS3AvT3YWkrJ0T/4E+7PEm8prcwtN8S82NkJB6QHYJO317LxCEzD9TFVghbuCUpfb pARql/28tQ25gGBbR91q99WU9gfIapu05Re6W6zJQJva7YoqA38SePPpr68zjFSK4UTta9lYolm5 ep1UKR5KaO8pt52D6y0+qaqOx3iuglXStFQfWRtL7dz94hZxjlvpQNraNCdnutKRClmxH46yeERE 5T08zLrmTbSXVMshZRVup0CfAv/243w2EK6lYGdlfNez5kWeFQZ3YvR/PHuc6S3yohk0q5IsFqfx zXazcfXe4pGHucmOhEyKktyRfCqpkwKNBkn1BbLOW/uNU28rUp6a+gvFFtX2n9fZR8iYqWcJcREI WnGuhrzIcjST6Wg+emQrmyVklGVpm/1EDW8ghbMYn4H/aauhZqqYBeY0eghZ66AXe08z5/7GLQE7 SyU2hRviMjxm0Vn+R38oWESo23BhPZuFJzZDHSTOpu5ZLZSgA1Sog9y/ortXFW07LH+/8Gjr40KY 2QZvpXWxoS2Cy4xajxMONyW9BNJHmrX73wf1ivDPxBEbqeVal7qyZxN5qdwAOynCE4CeAl8B1W0N uA0KZW5kc3RyZWFtDQplbmRvYmoNCjY4IDAgb2JqDQo8PC9GdW5jdGlvblR5cGUgMC9TaXplWyAy NTZdIC9EZWNvZGVbIDAgMSAwIDEgMCAxXSAvUmFuZ2VbIDAgMSAwIDEgMCAxXSAvQml0c1BlclNh bXBsZSA4L0RvbWFpblsgMCAxXSAvRW5jb2RlWyAwIDI1NV0gL09yZGVyIDEvRmlsdGVyL0ZsYXRl RGVjb2RlL0xlbmd0aCA0NTc+Pg0Kc3RyZWFtDQp4nIXCh1LaAAAG4OeytXvbOlERUQSRoYCgEMIK MxD2HmELiIAMrXbvZdvH6h/jnXetd/3uG5s0jp2/hlN8E//6NHecS4zPXLyBs8RNrpl/aw5JroC8 LSDv4LwF7/IXrPfO319E2wMh3/5wiftIhA58vIzUEzF3QuycWHE+XUXXM5S4JiXuqTX0TEu5MzLv LK77cE7uE8hpwQY9r/DjgjKAi6qAUMUI1cySOijaDIq2QsuoCYs14RVtBFd1UZRsx9b0Mak+LjXE ZYaEbCexvptEuTG1YUopTGkFkVYSGaU5qyKzajKntuQ2rfkttBU09oLWzmodrM5R1FGlbaqkd5b1 rrLBXcEdT3XXUzV6a0Zf3YT0HoH+hjnQIANNkmlamJY12LKG9m2hti3ctmPkwBHpUNEOFes6Md5z YeLQjcm+B1MDb3rgSw+Rzozo7MiPuaMA95jJHzOF50HuSZA9CbGnoeJpGEsvIlh+GcUKvoph9XUc a/gmgfW3SdzDdyls4Ps0NvFDBlv4MYv7/E+5Nv9zHg/4XwrY4X9lu5eL3W/F3sVS7zv38HK5/+Ov lf5ZZfDP4Vl1+PPKteGv2ug/66Pf9aMr/gGo3JghDQplbmRzdHJlYW0NCmVuZG9iag0KNjkgMCBv YmoNCjw8L1BhdHRlcm5UeXBlIDIvU2hhZGluZzw8L0NvbG9yU3BhY2UvRGV2aWNlUkdCL1NoYWRp bmdUeXBlIDIvQ29vcmRzWyAwIDQ2OCA3MjAgNDY4XSAvRXh0ZW5kWyB0cnVlIHRydWVdIC9GdW5j dGlvbiA2OCAwIFI+Pj4+DQplbmRvYmoNCjcwIDAgb2JqDQo8PC9UeXBlL1BhZ2UvUGFyZW50IDIg MCBSL1Jlc291cmNlczw8L1hPYmplY3Q8PC9JbWFnZTcyIDcyIDAgUj4+L0V4dEdTdGF0ZTw8L0dT MjYgMjYgMCBSL0dTMjcgMjcgMCBSL0dTMTMgMTMgMCBSPj4vUGF0dGVybjw8L1A3NSA3NSAwIFI+ Pi9Gb250PDwvRjMgMzAgMCBSL0YxIDExIDAgUi9GMiAxNCAwIFI+Pi9Qcm9jU2V0Wy9QREYvVGV4 dC9JbWFnZUIvSW1hZ2VDL0ltYWdlSV0gPj4vTWVkaWFCb3hbIDAgMCA3MjAgNTQwXSAvQ29udGVu dHMgNzEgMCBSL0dyb3VwPDwvVHlwZS9Hcm91cC9TL1RyYW5zcGFyZW5jeS9DUy9EZXZpY2VSR0I+ Pi9UYWJzL1MvU3RydWN0UGFyZW50cyAxMz4+DQplbmRvYmoNCjcxIDAgb2JqDQo8PC9GaWx0ZXIv RmxhdGVEZWNvZGUvTGVuZ3RoIDExMzU+Pg0Kc3RyZWFtDQp4nJ1X227bRhB9F6B/mEcygNd7460w DNR2GrhAUBc20ABJH2iJtphSXGW5suO/7wxFyVpJq7p+oSVrzlzOnpkdwukNnJ2dfr68vgJ+fg4X V5fwYzziwBnnXEjJM8gkh0RzsNV49NcHaMcjAY8bG85TwbVn9PBhPPpzPIKPny8BtgKI1wAnAzYp 0myIlSshDsWSihUFYDRIMyZ4AUmRMC5AsjRNBUzm49Hp9bx8rDIJVwYOBZZD4NNPtzKFx26oQBQ5 yyW5LbIclMC/ClQuWJZs6tjzpfZYkloLfSBzipb10U5vSucq28KkQ1fovZu0BNcyY7JHYtCUp0fZ 00Pgizt0+JsC9H33QJUQNQJSzEVjFWnBRAF38+34nKrFr0INXz+NR1/PuMouzv+Gu9/Ho4/oc+VX 7PrNJdIht/1+jf6pfsY6qiaxj15DhNasED4EQraJYFz5tmXTxCcyMs/07CDOoxJsnETLtq3bx5An pVKW5L6nL1Ubss5yJuXbclS5ZmLH9sYiA+Z7NXEwM52DWEXOwH2162PFKEORHGQVc86ywaWt0Mmi KSfVFGIhoufazQDLLlvjZhURQFT8cQv0g1k6TCCUsUY1qEPu741xyGEAllAr5D5sO8SeJpNdTfpV FpgFEccF0wNxpDp9SHU+EvucoRC3kdFNSEISm0f5traek3hKWzcv8YkKEiURlBU+dtnhAaDCEYYS x+fS4bFqFCEewcSW9K8OTyaLqvaptqadVxSrdYAKQLuJaZoV0AVVvypPZjjE1mHr9sHYeelq00Kc RvgsyW0wcxQwl76LL6tEQjIWCRM+IKh4yVnim95Yg/r53kdA0WOds5dFRVXap7oz+N1CfII9YYmZ qZnzkPOkkLt5bFgNQFKcKCIP574nzHRvWO614DAwpdJY6kabhydiqH+3wNHdrFdJ9bPuqDVpUj0s 20n/2bRlU/eKeMHW5tGsxLFWRPcVzicSJ8Ecqqtqp9SlU/rRmV9CbPCcJdoLfpSM7E1dKoqCJuI7 unQbGf3aNOaZJOAMiaLpsCtoUjUkn3JKPVTPe2U/Vh0JfZhmNNtsr64fy9oSe8c0tI6ccabl5lay vfyrhgjtlosFhbQOvkXPs7pvyBkFnBoM3FJSDvrTgv64YLnonK3K+aF5sSp+TwbrNDROoNcsMIMu lHeOqvMB3+KgbcZU4dkePeb8bcfMUc36Xce8hYyu5wtrnircWJq6vK+b2g1zli6uWYVs0hR9sGYO JY6T0D2FG5hKfc8nobHBE5bmvu19HRyxicLdasc1KSo4lBTLdrwfZbt4E9s4sHDGvIPsLWC/bq0u o4BQUs1y5UFCJAo0EolnuulT7FnJ8COnR0IbzWqWN6Xr+9L2vdsF74wsxY3cc/3az/2H6ZFtJfeA /3OL0kwWb2oRwb1Tox0VF579ewFfJXSSrre91ctCvzSvdY8MTYM3s1D0WrHl4D83Zol9UOxAgjyj RLX2bW+XCyJ4YazbY04eKpLePHQaDtgz9y/5lAAwDQplbmRzdHJlYW0NCmVuZG9iag0KNzIgMCBv YmoNCjw8L1R5cGUvWE9iamVjdC9TdWJ0eXBlL0ltYWdlL1dpZHRoIDE2NS9IZWlnaHQgNjcvQ29s b3JTcGFjZS9EZXZpY2VSR0IvQml0c1BlckNvbXBvbmVudCA4L0ludGVycG9sYXRlIGZhbHNlL1NN YXNrIDczIDAgUi9GaWx0ZXIvRmxhdGVEZWNvZGUvTGVuZ3RoIDk5MTc+Pg0Kc3RyZWFtDQp4nO1d BVxU2fdfu9decxFExO5uEUQRDDqku7u7u7tmGIahWxpUMDFA7BYwUBFQsQP4f2eejgiDi7vG77/r +ZzP/dy579xz49x74r373vz22y/4Bb/gF/wjmDd33sIFi5csXjJ69Oif3Zdf8C2hb9++mzZtsrOz z8jIrK6qfvfu3du37560vLt353HrE+TfouTevYZDFYeCgoIlJSUnT578s7v8C74aBgwYICQklJ6W /vLlq/fv30Omz5+/uH//weXLV44fO56VmRsTTc7bV3jq1OmrV64+ePDwxYsX7+gAyvdnz543MzP/ Jff/FzBw4EB9Pf2mR81tbe1v3rxtbn589cr1QxVHsLspFEpISKi7u7utra2ZmZm9vb23t3dkZGQi LTE3N/fYscrr128+fvwUtd6/b2t7356aksbJyfmzB/QLeoS9e/fevHGr7X3HmzfvILg7d+5evXr1 zJkzx44dKywsTElJiYmJ8fPzc3JysrGxcXV1DQwMjI2NRXlBQUFFRcXp06ex/aEEoAog8fa2jvfv 3oeGhk6YMOFnj+wXfAabN/NUVZ15/7797Zt3z5+9fPz4SUvL4+bm5vv379+8eRNyPMOA0tLSzEz6 NoeUkdJotOLi4uPHj58/f766uvrs2bO3bt1qbGx89uwZNHt7ewcB+Ono6Dh48OCfPcpfQAcLM6u3 b9pev37b+vTZ45Ynz589hw/W3t4OiwzZnT9/Yf/+/QEBAXp6erKysrt27eLj41u/fj0PD8+OHTvE xMQUFRVNTEzi4+MPHz5cV1f/9OnTV69etbW1dXSG9o5Tp079+eefP3us/2nAjqNSk5+1vnzy5Nn9 +w8fNT56/vw5hPPmzZu7d+9iw2Ivk8nk4OBgbE9DQ0N5efk9e/Zs3bqVn3/b9u0CO3fulJCQUFNT g7hdXFyCgoJAXFZWBoWA3f2ZtNs6IP97dxtWr179swf9H4UpU6Yeqjje0tL68EHjrZu10NvYzhD3 7du3ob0h6PT09OTkZEgwLDTcytJOTlZRUlJaUkISe1xZWRmbGrZeWnqvjIyckqKqi4tHbCwJ6j07 O7uoqAjmvqGhgZA1djrda3/fBmPx6sUbeTmFnz30/xzM4p5dc+ZS48Omutrbly5drq+nK+E7d+5A 0IkMgAOWkZERFBiioaED+aqrq2trayOFoOXk5FCCnY59raWlpa+vj90NVa+goGBkaJqUlAKDXlJS grSyshLmAKEc1PvLFy9fv4baePv6VZudjePPnoD/EEz4Y8LRI6du19+9ePEyTOqVK1ewo6uqqtLS 0qKjo+Pi4rBJI8Ij5GTlIFyIdffu3Zs3b4YeXsmA5QxYsWIF8RPlW7ZsAQ2IIXosCU1NzZycnPz8 fKRZWVlw5KA3WlpaGhsfNTe3tLa+eNzyUllR/WdPw38ChgwZmp627/r1W9XVNYieYKAhDnhZiJhg fMPCwiIjoqGlsX/hhkGOEOuiRYtmz549ffr0qVOnjh8/vjM3lHBwcHBzcy9cuHDZsmWgR11YeSUl JR0dHcgaK4du0EvLmpqa4A/U1dU9uP+QoVUebt8m9LMm4b8DVlaO1dXnDuw/mJSUlJubiz2YlZll ZmZmZWXl4OBgZGgGf1tISGjdunULFizg4uKaMmVK75lD7oTQofCh/MXFxWOi6aE6HDnojYsXL548 efLo0WNYYFWna4oLKyZMmPj9RvoL+LZsLyo6kJ9f6OnpaWpqamxsDJu7lQGIsNasgZDXQW9v3Lhx 7dq1UNRLGbBkyRKkffv27U0Tw4YNg9ChE0RFRVVVVVFRRkZGREQESwg/3d3d7e3t7ezsvb19HOyc 1FS1lnyEpZ8DSqA3vveE/Ith+PARkeHk8vIKe3uHoNDQK7W1HV8Ddo5f4V+xsbFB6HPnzqVSqV/V CuB6ff21+vq0nJwJE3/t/b8PSgpaRYWlaWnpEDe2MzUx8Xpd7dVbN89duVx9/tzpc2erzp1Fpjte un4NUoCDvXrNmt43x87OfubMGVS8cvNGd55o6zQDkUcHLt+4js5cr68F8aUb12BcBgwY8P2m4l8P kyZO8fUJKSku8/f3hzHV0NCAUT56/Pj9R48aGhvr7t69Xlt77datG3V1LBH+NF1wN26MHTu2N83x 8/M3Nzejyq3bt8G5CzeiLaS4eruhAX140NR0v7HxTkNDTU3Ntm3bvvds/OtBZI9MVGRseHiEr69v YGCgq6srLOOsWbNu1tY2tjQ/ffEc2Pz0SdOTxy2tT4GPn7USSPxEOaFpEVv9ZVvw+gjih81NYA62 BEOCFbMVtNj68gXK8fPBo0b47YWFhdAJ338y/uUwbux4C3OHjPRMSNnb2xsbXEtLa82aNRMnTsRW etj06HHr05dv37TR722zQPqdsY6Ot+0fboPr6ur21BD8NKwHguzZyxev378j6jD5MHm+bXv/4s2r Viyz58+aW1oQoGEdDh069EdOy78V1q/b4unhGxkZ7ezsDHGHhYYhVuLh4Vm2ZDlMJAzlkydP3nd5 qNEzvHnzBm5z91YQm1+/fr33Lllbe/vr168bGxsvX76MaP3HT8u/Evr06aMorx4TQ7a1tXNyckII bGhoiGhr9+498Jw5OTkRYcXFxT179qyd+czyr+Dq1au///5751YQaoHDV8i6re3FixcNDQ2HDh1a tGjRlMlsf06d9rOm6N8EkyZN1dE2iokhOTg4QpkHBARgX2/atGn7NkHMMyz44MGDR44cWV5ejvnv vcQTExMJ/lgtiOJ7L+gOhpMPfQI3jUKhjBs3butWfsEdO3l4tnfpOWwNAnA+Pj4E7GoMQGbt2rVz 5sz5YbM3Y8YM5j0BZBBd/rCm/x4sXbzK2Mjczy/A0dERytzNzQ1bG4HYtGnsUL/wtAmLycXFBVUM 7dp7ievo6IwfP37//v29FzSYwxY8evSotrbWyMhozJgx6AlD2/ByzZiLYEFKSioiIuLUqVMg+zIr 9DYhIQF9+PJ9v2XLlp3qBMnJyRGsQEjo0x3d0aNH6+nplZWVYU12b/fly5clJSUKCgq9vO/0g0FQ QMTGmn4ji9DkmB9sbWlpmUmTJrGxsQ0fPpxJCYMOQbx9+7aXsoNE4GJ9lawxVw8ePKiqqoKGQYsS EhLwFZFHr86dO9d7Vl0AFmHdunUsh6+trd2bjoEMxPPnzyeTyehkbxpFh//XDuPBcO+VUXF2cnNk aHKEYJheiHuHgBA2JhRpF2dYX1//8ePHULZ/e+Z7AhhrGPc7d+7AdccyGzsWjY+DhrSzs2M5vRAB qmDt0R+evnyJpYVefVnzREdHDxkypMsMQAP0pnv8/PyIH/9SpXSBmzdvjho16seJ869gxIiRigoa vj7084Tu7u4w3JsZMG0aB+w14qZBgwZ1qRIVFdXa2tr19BEraO9ob2v/CzIQvH7zGtjCiLbQB6LF aWzTIOuLFy8SZG/evgEN0rf0k+z0o1MwK4TOh99+6dKlGzduQC1A7u10kbcTTb9vew9iVESG4HPs 2LEuEr916xbRDQLphyw+4rv379AiURF6vvvomGy7l6PdDsaaxMT+OHH+FcDj3Suj5ObmAZMNhwqx LWQNpd2vXz/IGlEYMl2qQL0XFBbcbbj3qLmJwObHLZ2xqaW5EcWMDHGVIMPPzvn7Dx/cuXe3tr7u Vl3t1WtXL166KCYmBv79+/dHCiVDbGo0VH/nNijv3W9AlYePGgmEcAsLCwUEBAhzg03Ey8sLoTAb IrrxoPFhw4P7qA4kxOHn788cy9Q//wQNUYVA5qCARHUUPn76BCkaRWdu370DVuBJjIVZkUBmu+gq 6t6933Dt2rUfKM+/AM7p3HKyKp6eXpA1Im4IHYZSVJQ+7QMHDuzJ2Zg8Zcr+iopzly9Xnz9fc/Hi 2UuXuuCZCxdwCUhkkBJkSIkq1efOVVZVHT1xovzIkdKDB5NTU7lnzfqNYVyQLli4ELJuffXqRFXV ierq0zU1RC0CzzJSWnLykI+GhqgFmDN37vkrV4gOfNbouXMnq6tPnTlT39BQdfbspI8vNfBu3fqw uRk0RG+ZyKwOBP0JRlcPHjpUfOAAhUbLyMnBzzPnzxPMCWImMseLilXnzl28ehUO5/eWYy9hFvd8 eTkVH29fyNrPzw/mG3tEQUGRuMqcxu6wctWqAxWHyo8cPXTs+OHjld0R5UzsXFh+5BgyBw8fKSrb n1tYlJ2Xb+foNGLECCZnBOzQ6k1Pn5VVHDpw6HDFUTo9UlREeqTyBLD63IXp06ez7GFeYRFaASWz aSJF9f0Vhw6iw8crN2zaRBBr6+o2tjzFpc697YKl5RUFJaXpObk7BIWYnsySpcvQty6jY44RrRN4 5MTJk1VnJv7PPLmbO2fR3r1KELe/v39QUBACMYSxamq9OjgkLiVddKCioOxAfun+XmJeSVlecSnS 3KKS1MzspPRMUQnJLmz1jIxfdXTkFBSDhl6luHRfUSlSonp+yf7z125m5xf11KuT5y4UlB5Alc4I VjmFxcgUHSgvKT/Ew8tLEHsHBB09XY3yHrtaXJqWsy+KTOGcMYOowlxg1vYOaOhLIy0pAwGa6+4f /iyYM3uR7F4lTw+vYAZgdyPO1dDQ6GV1/7CI1Ny85Ozc3mNSVg4tMzshPTMkmjRv4aIuDCdPnXrw xGnwTMzIBjHSRKyKrByiIvJp+/Iv3KpvbGw8zYBTnwNK7rQ8jU9N746U5NS45FRkUnL2bdhEj/IG DBxITc8EQ7Bl2U+UowOU1LRNPFu6j11MSvoLYye6nZCRFU6O/2ci+pYwc8Y8GWkFdzePsLCw8PBw Hx8f+EgqKqp/WRErNj4+vvldByU1g5SU2nskJ6eRktLsXDzGsHpUKrlX7kj1+eiEpNjElJiEZKTM ikQJMjG0ZHJyelJ2XnpBcXbx/pzSA0iBGYUl1PTsKGpiGDk+Ii6hC4bHUUNi4sJI8WC+ZPkKtMXB OQN8YmgpwO79RCFajKYl+4dHsTRqIlLSmUWlLMdI7yq9empUfKKKVo8PjH4YwAcjhsDBPlNGmu6Z I7xCWIoNDl9XXl7+y9U5OTnPnDnzpK2DlJweSUmMjE/qJUZRk0nJGUgH9fCKkLmdAyU1CzzD4xK6 cqYkRlBoSEPJ1OAYcnBMXCgpHmQRDOIwEjWMTEUmJJYSEkPBpc6IQtAHRsYGRMSEkigzZtJvdfJs 5S86UsmiIUZb9PL4JPBU1zVg2VV1PYO0ghLWw2d0FYimV65hfXvnRwLCKyK8nTRxqpiojLW1LYlE iouLI5PJggwYOnRYT3V37Njx5MmT01fqSEkZ0QmpwNjEtF4iKSm9oPxYy/sOZU0dlswjKUmkxHRQ xtBYsEVbKA+PowVGknxDI/3CogMiSIGR5IBIsl94NBCZwG4YFEVHUPqGRHoFhYfGJhAuvZqOfl75 8WhqSve2UMIYVzra4t22g2VXfYIiEzL29dRPpFEJKWDOUon9YEBsS4Srw4f/Liq8V1dHH4KmUqmp qalCQkK7du3i4eFlWdHBwQGha9nxanJKJjVjH4EJmXkfcV+nws7lnzApp/Du07f3Wt+u3bCpC/PB gwcnZhUQDFlyoGXlJWUXKmpoT2PnYOOYPu1rEbXY2dnYPxxoDIgiZxQd+Lz/nw0E0oxPy2afzuJG 6NQ/2ZJzi2hZ+SyHSXQ+Li3bNyzqW4rtH8Do0aNHjhzZ57c+u4Qk5eWUKHGUxMTEtLQ0WVnZPXv2 mJiYd6FH8FhYWAhZZxQcoKRkYyqScwoTM/Mx/8gghaTwEykzT1zqjPRLmfm5pYfpa+ZY1aQpUzs3 MWz4cLClpGYTdZncmHzS8koyi8p3Cot9g+GPGZOSW5ySW0Tw74JEu7SMvChKCsubD5t4tx49ewVk xKC6Vs/MT84pSkjfp6Fr+M+7+k0A4ibeuNywnl9CXCY8PIJGoyUlJWH/CgsLm5l9Ju6lS5ciFr7+ 4GksLS2KCscmk5KaQ07OjEvJQiYuJRsZIo9CXGX8JArh2eYwET9BgEx2SQUk7hkQNnDgp5u0cCdC YmGOE2MS0ggygu1HzE7dVwoUkZD5jVXEPWfOnCU9A/GAkmvmTIJ42crVuWVHmV3qjMzOx9DSDUyt WM6ekob2/sozRA97qJ6N6us2sXDpfwqMGDGCnZ196NChs7kXSojLurq4QdzJycnY4+Li4tLS0jNn ziIolZWVX758mV9+PCACpjAuJJYaSqLR09iEMHIi8sjQkUQLiqaAhiD7UMigYeIHYnr1hPTCA49e dciranbulbK2vldwhG9YDJiAG9HWh4okGikpq+bGfUsHt+7DgXv55ZvzKXkl4LNxCx9BLyIpU1Bx IjiGSvTnM4yFv0cNiqb6R5D4tguynD1HT38ItKfqKA+MiguKjvtj4qRvKrS/D7DdHBwcbGxs48ZO EBeT19TUTkpKTklJycnJwdRJSEhoaekMHDgwMjLyeUdHCCnJ2SfExS/MPTDSIyjKPTACqUdwFDOP clwFjaNXoKNXkJN3MH6C4BMlExnERJpVdqy08tyK1euZvZo2ndPWzdfew9/BM9DRO8jJJ9jZl96u m3+4W0AEuKUV0tWCv78/divoMQR+fv59+/a96+iIomWCgMkc9K7+Ya7+4S5+oegPGGoZWTAfAWib WAZEU1EO/izQJ8TJO8jFN5Rp6DsDjI5PaKyrXxjRve6IcnC2dGSxLH8iTJkyZcGCBcOGDRMUEJeW kkUslsEAT0/PjRs3Lly48MSJE6XV1209Ai2cva3d/JCxcQ8AItM5j9TS2cfc0cvM0dPEzt3U3sMM 6Ohl7eZPXCXomUhUBNp5BxefvBQQQ5sw6dMJhIXLVhjauJjYuZnau5s5gI8nEMzNnbzM6Tz9YlML XnTatshTssscfUIJziAAWrn6Wbn4Wrr4WDh5mdh7GNu5yWvqj/h4ngqeKi5ZOnt3buIzdPAwd8BY PFhG3DNnz3MJiDJ18DDtqS5Se89d4v9b5+vGjh1LvM23cMEKaSkFSwurzMxMqHRnZ2dePr6bzc1B 1H26lq66li761u6Gtl76Nh4GQFtPOjLy9EJrdx0LFy0zJy1TRzUjW2U9i1nzFq3ZtFXL1EnPyoUg IyiZ+KG6rSfqmrsE5Z24rmZoM2jwhzuNXFxcM2bNVdA2UTW0Vje20zS11zJ10CTQxEHLzBH9IRgS TIiMnpUbynXMnXUsnLXNnTRNHTVM7MFWzcBGTtNk0bI1nQU3ccqfGJemiT0dmcw7oYaJg7qR3U5x OZbztpZnm46ls8aXqttrGNvNW7ziR0ix1zBq1Ki5c+euXr164sTJ0pLKcnJKISEhurq6Vm5uh+re GrmEKOhZK+jbKBs5KBs7KBnZI1UxdkRKL2EUKhrYyutZy+la7tUyl9Ew3S2rOX4ifZ/2HzBASFpV TtcKBJ3rMpEoRAapoXNQbGEV325pVBQXl9y2bRucimHDf1++nk9EQVtCxVBSzVha3URaw0Ra01RG 00xW2wK9UjK0I5DeB10rWXRA01RK3URSzUhCxUBMSU9CWZ93p+R07nl9+/XvMvDZC1dIqRmJqxhI 9Ij64DN/+VqW88a3S0pC1fCL1Q32apqNGvvH95bg1wKc8w0bNkClr12zhX+r4OIly30T84OzTu3V cxBTNZXQsJDSspLStJLUtKRntKyRfshrWomrm4NGVMVYWNFgt7zeBgGxIUM/nXQaO2GKiLKRmIqJ pIblp1p0Dkz8UIjUwDXCPjxr1qKVAgICUlJSlpaWGhoay5cvHzBw0DSuuQtWbFq3XWybuIqQjKag jKaQjNYuWZ3dcnq7FfSQ7tyrs3OvNnFJQEpjNd8u7kUrJ0yZ1n/gQGZnuujk8ZP+nMY1bxrXnJ5x Ljv3/KEjRrKcNDauOWwz6NhTdXauuRzcC76TyP4JjB8/nngDd/SoMdO4l8SUX7cMThVVNxNWMRFV MxfXtPyIVkjFNOiIvJi6hYiq6R5lY2Flo53y+kLyugtXbeken85dvmGPkpGomhlRkVGXBYppWICn dXiWhl3g+MlskpKS1HgqhULR0dFZsWLldHaufn0/BGuDhwwbOWb8JHYuYraZOGU6N8pHjum6m/ow 4EfM4/8fmDZt2vz587eKSGWcf67jGimmbi6uYSGJ3adjI6Vjy0Cbj0j/iUsggBBFVU2FlY13Kuhx cM9nyRluMJ+YMhhKaFp9rG7zOdoyecoaOvmkHMVC2rVHJC4uLikpSUlJSVRYQlBAZO7ceYBx48b1 5klib0SMiGMYA4Z/BJbHtHrZVnfoQqampraPAc5ubj/9YSgCcCd//7IbrwxcghWNHJVNnVXMXJEq mTgh7YwoUTR2VDC0kzewldWzltG22COvPXbCl0LLcRMny+rZyBvYoWIXbp3ZEo0auYVTyy8Lyajq 6OpqamoqKaoqK2lv3MAH72LWrFldzoT0NLe9gaysrOZucOfOnby8vE0fTz58Q6AkJp69fPnClSsF JSXfQ9ts3rwZsbOCggLs8pcpEYsdOnSo9OIDa+8IU5cAY0dfQzu656xv62GAjJ2X4Uc0IMptPPVs 3LUtXDTNnIRlVIYOG/5l/oA1m7fqWrsZ2DJc+k4MP2Nr64G8iUtAaGrxvlM3N/ILrVq5WlFRQ0Za DfMPcU+ePLnLayl/G6BzDh89+rCl6WFzU3PrU2DT0ycPWpobGh8SkZ2Xl9c3aYiASZMm3W64V3/3 zu3bt01NTb8hZwKgqcAZ3X78rNXMzOwLlFgMDQ0NB2tueYbFIZB09A2z9w6x9Qyy8wy28wpGvgui EJcQTVu6+m4VEu7bt+upRZbQt18/NQOLnnh+4OxJ5+zgHeoRSq68+iD/yLlZcxds4xfZwsMrJCSE 8KHLJ1/+CSD8bGxsfPPubUtLy4ULFyorK0+ePHnr1q3W1tYXr+iHITEnMBzfqjlYCn5+fj4+PqRf 9WGTXgJsMXEO/N27d3C5eyITkdybnF8WQU0Jjk0IjKL4hcf6hEZ7h0R5h0b79IC45BkU6RoQumzl V7y2D5jKNs0jKMIrNKonzsym0Y3gWFpMUlYImTZ6zFhsbfjnCB++4Wlt+KUdjFceamtrubm5wXn0 6NFTp0718/NDYXt7+9OnT7du3QpKLDMU+vv7E7tSUFAwJydHX1+fyap///5YjSQSCRry4MGDIF64 cGGX5sDEiQGKiopdLsFlgiYpKys7fPhwTExMT58QhGYzMjLKzs4+ceJEfn6+jY0N80PxWlpaKCGU 0uvXr8PDw9FbUVHRztUHDxmiZ2JOSUmPjE8II1GC6c+Co/zCIgn0D+8RAyKiXbx8ODg50TH0/6vM nOAe4S9wBjJbD4qMiYijxqdluvn4YUKwer/tSU5ra+sOxqs9kFFnS4p11dbWhp2CXU+I29zcnJhJ aADEhh2Mz7cy30WFbkT5h7PlH19nwIIxMTHp3BzxlgrYlpSUMAvhFvr6+jI+DNtOpB2MFytUVT87 R4TlpK6uTrya1M4AopWzZ88ingLBtWvXOneAeDXD3t6+y5AHDx7MMZ2Tg2M6O/1BMMc0dgZyfER2 duLR8KcSBs6YOXPlypUIlGxtbSMjI1NTUw8cONCdOUtAz4mGurPtjugVB+eMhYsXc0yf/g3VOAGl paX0W68vXmDCf+sUku/YsYPYI3V1dTC4KIHnRkwmXfm/eYNpR4b4/o+hoSFBjBJoCVhPLBLidSrM PLFaCKDRaCiEpfDx8SFKsDdhPiCaR48e3bx5k/iWIFgRZGxsbMy6mZmZKHz+/Pm9e/fQCpzJpqYm EN+/f19cXBw+NjxM4vu0qI5L6EZ9fT20UC+nAhygOqCRVq1aNZOLm49XUEhQWEhol5KSMjYFOkyl UsvLy6FVEFZAvSCFMoEeO368En0Dzdq1n92JwtrArGLIYWFh0EjwHqWlpSUkJOB4W1la2dnZOTg4 wMFgHKjYwrOZb8sWgTlzFmJTz549G5buG9pQAsDwZm1tO0MowsLCzPKJEycWFxfX37lzq66uqIh+ zBWe4cUrVx40Nja1tDQ2NdUxyslkMi5BgTPed2jA/EdFRa1btw4d1tPTq6uvv9PQ8Ki5OTc3l1hF CLuqa2qaHz/GYsDYibbc3N1R/d6DB9jv2KSIAaEnb9+92/LkyfOXLxF+/sZYhNa2tkQrV69exRTB Lq9YsSIkJKSmpoZ4P3HkyJFSUlK19fVPWlsbHjzw8PCAoDGor/pPECxsdB5LHVpr27btWhqmdjYu drZObm4ekCx8Gwz84cOHWOrXr9+A0cHQsAsKCgoKCwsxY6UMKGPA/v37kaIQqyIlJQVzFR0dnZaW BgJUPH78OJRDVFS0hbmFnq6hnq6xjpYpH68ALy8vjMWMGTO+x3fOly5dWllVdbWuDuIOCAjANEJL Q2QQx/7Dh3MwjLKyVYwPCi1dvvzY6dOHKisrjh3LLylBIfE0DXo4NSurrKICqKnz2REsfSOjw5WV R06cOHjsGGGAZs2Zc/TUqePV1ZXV1VyMd4GXr1xJtw7V1Wio8+uW1vb2J8+ePVlTY2lri5/TOTnr GhpKy8vRq1WdPnCEPvzZaftPnDQJzNHPoydPcv3dd43hGmFaoC7glmAzaqgbhQbFhQTHREbGZGZm Xb92Hc4M3Y998QI6BHKvra07deoUdj3WAyF3bATiw6cAQhtgnUAdQQthqUDtYF+gPDQ0zMXFzcXJ w8XJ18TYUXDHLhERESx1RNmEOv3msGEzT2nF0bScvOKKI7UNTe86Oi7erM/IK6SmpMfE0yJIlC38 H77zs0dcvLzyVGo2/Qg0D98n5bxhE8/ZKzeTMnNjKIkjGQ4kM/xfs259VkFx+r6CpPQs4hL/jh2V NedREhZNGsi4jWNiaX3y7MUjVTWYELh22K3Eke9DJ6tTc/JSs/NVNemvmkrJyFeevZCcmeP8MSpk eZNhCx//6QtXM/OL42jJXzhe+JcAB2nRokUCAgLQuvAWZKTlHex8oyISYqLiyaT4stL99XX18HZe M75a+57+bxNthC8BVwE7BTYFKcRK0LxkADIwQzBYVVVVcXEUP19/H+9AX59QT7cwZSVtcXEJaP6N Gzd+P1kDhCWkc0rLQ2MpQTHkoGhyQFRsYESsX1iUd1C4hp4hW6fv/Kho6sQmpYWS4rUNP3O9tPSN cvZXkJPTlTS1ujAX3CNCSkoLiY2zdv7wpFtT3zghMzeSmqSqyTh+3KePo6dvFDU5KiE5JjEN5RH0 M6uJ4WQERyR0A+mqdfSn/w4ePrSsPHJKxjbBnV8YjqqOXmJOfnRCsn63w2ZfC4hNEERg/mVlZQ0M DGBTFORVfLyiSDHJsdHUeAotMwOhwcn6+tuQY0+vABMfr3716hWkf/78eez7mJjYkOCwwICw4MCo wACSrra5hISkvLw89jWMIBcX13f9rworZ/fohNRQcoK5g4v4XgUJWQVRKdkt/ALdjzFYObnFJKZH UJI2bP7slKaZnRM4ZBYf1DT87J7JgAED0ov2h8XRwik03m0CKOnXv797QCglLQd8eLbSlcaAgQO9 giOiaWmUtGxFda3dohK7xCSFJWR2iUhsFRDCatkpIj7i95Fg5RceHZeanZCVt2PXnp7Ggs3u7O1P SsmkpOcI7OyR7KsA848IhZ+fX0VFBUKXk5PT1NAP8ifHxabFkZITqKm0hJSMjOzDh4+eOVNTe6sW lh2KGp4kXMQbN25cunT5yJEj+XkFZBIlOio2IiI2IjwuMpwaGUYzN3USExMnPqULBQ5lwsnJ+c39 8M4ABUtKziCnZMYkpS9fzfrhJgHDh4+IoqaQU7PIKVnzFy7ufEnXxBwb82L9w8fPnmFmiEIE74hT qOn7omkpAVGkQYPop+hHjxkLDsm5hZDa7Hn0xwp9+/XzDAxF4eGaS+s/fzOlc7CMKMbdP5iUlPHo dceBypNMHQ4X2tPTk3kgZ+iwYaGx1KzigzU37mBX0kuGDv3nn4yAKZ8zZw58dTiEGhoacLCVlZWV lFTMTa2DA6Jp1JyE+MzEhAxaQloCNQXST6RhDWAlJFHjk+LiaGRSAplEI8UkxpFSI8MT7Ww91FS0 4FJi5cBF37Jly5IlS6DAv8cdpy4wZ/7C8LgUr2Co7sg/GLf6e7rrPnP23ODoeG9QBkeN++MzbbNo yXL3gHDvkOhXHR0wTPD3YIIRTwXHJngFRzp6+KMVgpKdgzOKmg4+/uFk5qE1JQ1dz8CIQ9VXYddc XV0RaCOcuXTpEqrvFpXs81FYO3YJewZFBERRoCHh0zo7OyMmgt2MoWUoa+r170//YuTYcX94hUSH xNJeMr4U4RdO0jGx7OWtzr8EWPN58+atWbMG3j4UOwJPyF1NTU1OTt7MxMLJ3jUoIDKBkpFCy0lJ yklMoCNWQlJCTmgw2dPN39rSXl1VU0ZGBksFigJ+IB8fH3YHAq4f9hckvNt3mjq4G1k7K2sZf/lR xUbe7aA0tnFR0jbqfnWPpJyBlaOZvbu1W4C9N/32r6WTt4mdq5axFRvHp0Ppq9ZvDqGkWzr7aJlY Ey+tAyZMnIyfhlbOZvaeVq6+1q5+5k5eRjYuRjau23aJMns1bPgIdUNLQxsXc0dPxu3lEDuPIAtn H0tXP7G9SgS330eONrFzQ11jO3czJ0+wEtjzDY5kdwYODg6EaQgAN2zYALnD5urq6kL08OHh1Ckq KsoyQFNDE2EmhIstjLWhzgD6A01RUUgZcRZ2NDRG51sKPwA2btu9S0ppp7TK8vWsX5pgwnq+naDc JaO6fB0LykFDhi5euWGnlLKMpomclrmcjoWguOLSNZuHDh/RmWynlIqykb2CntXmHSKdy8dPnLph 604xBW0pVUMZdWMxRZ3NAsLsXF2/FjVm/IR1vIKiijp7Ga1IqRtvERSbMefTXfE+ffouX88jLKcp qWogqaq/Q1xh/ITv9Wd8sLPY7MuWLcN+5+HhgZ7HhoX0sXOh8IlvXkH6kDhEvH37dhgXmAMYaEgZ a+anvPLc+4ePfXphAfv26z9i1NjR4ycOGzGqy6U/prBvFVexicjao2S8W8n4zxksPvw1eMiwUeMm jBr7x8BBX3oCPnDwkNEMskFDWMdZqD7899GD/0EU9lXAzs7Ozc2NLY8Ni10Pma78CPgJdb148WIs jJkzZ3b5jtNPgd4/Iv8yZfdLzBLMv5S2pZFHlJSWpZi6iYCkav8BA79cvfdd6g3Zj4fJkyd/v9j5 fxzG/THRxMlHz8ZN28JRQct40q+PPf6rYcy48bvEJAR3i2zk4ftfeP3zF/wX4P8A1crmYQ0KZW5k c3RyZWFtDQplbmRvYmoNCjczIDAgb2JqDQo8PC9UeXBlL1hPYmplY3QvU3VidHlwZS9JbWFnZS9X aWR0aCAxNjUvSGVpZ2h0IDY3L0NvbG9yU3BhY2UvRGV2aWNlR3JheS9NYXR0ZVsgMCAwIDBdIC9C aXRzUGVyQ29tcG9uZW50IDgvSW50ZXJwb2xhdGUgZmFsc2UvRmlsdGVyL0ZsYXRlRGVjb2RlL0xl bmd0aCAzODE0Pj4NCnN0cmVhbQ0KeJzFWmlYU1cazkZWIIGQQFgSQtgJyBIggICgsieAClioxQUU RVzqgigq26iodRed4tKZCh3H0WqdWoFqW2rVtijqAyIgUBQERKyIgECWORcSudlYnqcD7w+e3LPc 857vfOc77/kuCMQ4MOdY2VhZsIzHazc9MDC2dPGdGxIWHiGICA8NmePjyDaiTjcpBegxrDxmhwsg CNdv3vSxEPoVFuDKppOnm5ocFCM7f8BwXs7XD1qlI+hpuHksSSgI8eLQdKeb3jDoVn4RggX774uk Snjx72RhqIe5wfTT1GfzwwQx53qVGY6gIk0Y7GamR5xejjS7uYKoE13qKQKIf0gSzrahkqaRoq6x S1hkXotGihAGriwMcaBNH0sy0yci+tKYFCE8Sw2bYag9TRx1zf2F8ffH5Qj2epbA3Wh6WOow/YWp rQpsJKKh/nc9PX1DQyIJvFx0KsqdPh0rTjKZKUzvgTPpba/64eLZw/sOFJ4vqfijq18Mq7wa5Wow DXuc5i5I7YZRbKsozkoMD/DxdPfw9psbs/b4jfoumDmLIh308FPNkWwTltj+gYK4/fbhxABXOwtT GlRpyraZwY/eeb329SjL4yEcXdzUciQxAxdUfCDQd//0qmA+l6KjhRxtYuMRnVdW8+Ecer8twsZI D4BCJqKnhiSVF/XlB469T28UnSrIz9+9zZ2Cgk3ExmvFxceD8lZvr5w6tD8/Pz9vwxwSUvOb/zqQ 2CEp/WqCzd2Z2vDxrYIOvlZt9CwaPpX/H6juCyrVcJRKzjliPzRCEu1z36i2adjsojMVJImsoCx1 HKXS/i1mcodDkb2KBlQaiGvy5prgp2K5KU4x1epJSl/M0x9hgKKH/apaPVSRF2ahMxUbB88I2C4P gT3KNO7OJAKWSKx5crMaQ5dummlCmBKPJFlF/Sgbtf0nZa8Tn7LVQiBJTvlvVTlKytd7GGKnZGsj dLlLZAaUnMwqVta7vWuMMXq+l4bUOcONYAYeicJTDJlsNpOujRmXL4ZIoehRiJjJk9TnH5IN+mxl UNIVZTp/RNvOf6COolRaH+nkNku4ek/h1WvXvjm2Y/5sHpssc1AkzsTNf5avp5sLgLMdg4BE63K8 BZt3gfi7JZLPmmRsxTPCbsoG3RvA4qXckShR+f1wm3qO0sEzV6s7YcKju65kg68pDhofbbyt42Vn 59NqCFWV+WyGe0pZiyw8iJ5/HW6CHZcZDASzhTKFNhRjTaa4ZdQqUZGoxnnlecDQdtybCrYSzuMX eOkPCbtrFK52rzM5WpOxJHOpbIUbfGhEjIFf/kvNFGSzqRaPUVvzEQON0Il+AS/7/ZFyj95VhpMI CwROpqxfoTUJh8Qah/793dgc35Xs7x6r/uXHdDQ9VSHy96m2qvaZhIoi2p6UdZtP10IjkHjz2EuD qu8cxYsv0tJewZ5FHfd+vt8Bt9QTf23Lo2POE2AgkTJhjigC94Ksm+9wXEaRbJeXa15O0aO9McJi mFMOlO9PTVx9DO7JkiwW/6ZyR7GyI+eYTniHo/AzvpW92hMx3AtNdtlUo4ljf1l6oHs6fPV+2+Bn a2EvOAvfF//1EDQodJN0Vdz4pV2hSHrEYsJOicQ6fy+zkbusE4bqs6tDPceuomQeOxxOoO/S2qig 2cGf/ANOsjx0uYLXip+cSEtY+aWir+/hTHznYBxkJMV8uRLHmsRdVVU8oEX9kQW2VOsj8IUTvX3d CdClcGzejstRWNznu0PtzZ3XK1xGB7cwJx7QUTby5fbFyaaGs96gEEDkr72zM8hcmzirTk2dIn5a dlFhcl+GGuPRBvEKGuXVCsbEfRJpId84oaThMw1JdMhVo8ClkoqtPgw8ipwwZvwZxrdrH8Efu9Ot wDGk97FCAH4UpT9hQ6JxDHkIWqGHQUHq1vsr9SGoNcUcjEVbO8Z5I5vOkXSFTfL0IzoSgTRKew8v PO818fwCRpuSLut2yRSHRmAMBRVSDSj1xCOQZtnwov7ntY+Vce/rFTsUXPo7fx0weetT8LLBHJtJ nIt6dKHsWOzgamvhOKma02pDn1likOb58KL2wo1paWlr1m3ckiHHllVRwSfgbcT7uOBwwXrfhRe+ WmkyiWNRj8WT7RJRMF3f9bCGBOowupcbopmZ8Ej/bD3P1tbONXLvqTMynD6+3nm2Qih/s44JnF07 6jm8sGrexF0SgdAxdymXddzLCy9VSUMroCFcz2QtPNr8ucmWbGAdWQJvdJ4rVAjljR/RwD6mJisc 4F/7TCblpc3mH5R1fJk9bnT5gW8aXwkvqCtI3FqkYKPuNOdlCgGgLBC4pJKbDOXZTkpQmvjEyI8C lXuYCsTHvaPOqNE0o+grDnPZDg8Aks8cgUti3K7DW3WtNp3UBY7KW3hH45A9yor3Xdbi3DHUpKSj aAmXfx5e9HYDC7gkIbgeXvhkweS+XVEcFuzSEPrEdZdvKd952vc+1EhxsO367vm2NC8FVV4fB7mk TjRc3kn/4zPJXLFZyKf1UnUYKN+ZuFWF0rMPU1CY2sCbpp+LshP4TG2S8+dVzztkeFFz1Au4JEI3 sLTuhbzw+YMUq0m5JAJB46+9os6U3RdX8q19816pqRqufnT7fs3z9vaOjvbW2kclxYe2JIa4mVOw KKzZ3NSsPIBcgO0pgaaQBCdaRa/PzpUhI5FH1WG5utvpTdgxUa6ZT9SQaP08nqtPZISfU39IDpXt TUldk5EFxszOXL88NtjbkU3XhoSUFjMiLWPbtm0Z6xaFeLnYGBEhJlpkloOrmwxOHKq2bXFjU+VM jeliJI5qYqKPk2sQjHFygyoHUdVegaUOGkngJKk/Jqtygp0sbJ1cwJguM+wtzehkgiw7gPeqez8A obf58wAGUWvYWkgMjkiSg4jHUKI6wZ0xUuMnVS1OzoWvNjNGrvFIgk26GoU78GPGLFPisN7g5XSq 4dhzdr4JGY0lDI9MwGFQo7pL/5PRUFbpqd5WSMONoLYmgqLJkOQFIC7edBj2XKSOx2k1+dN3320M pI/YGmMY9k/VBRf9tNWVpv79KNbfQESQiIcD1VC6Kc3KnmVgYmeujUISjJ28+HZ0LBKBMl11p67q mJcOEmtg58nnynJKaDKH5+NuScZoe5yUQF852AQooxf8s5o903d9TzyPRR+ZE56zTPUbVOfpuWYa rIBxvQY4tlTcrYWC/uVZa+7eu5pwuu4CR5sV9sXjttbKXBddJMZqV+0fFUssCHru2RUtbVX7XHWA mtN2SL3R9LK5PNHa9VoH9JKqI0wgTdwq1Trc4Ok4YZCvqx2Hbcq24iWcUhHBfZn2mgQCIRjcHAf/ tXbFPug6V7r0V+B7QANf9/UpGFG94h+9dfB8EEtfxzFMYx8MG0lS4kZAG4SWjKxZd748PV7BAxcF mxUXbj2ofvy4rvHFm364TXu/ixQIBOEQohZl/qdeoXKwo2wRW5P4p3zyJ7D0Zp7jkgfQzWEr8GhI tXyxtPxD/2I7PSjD8SzWJgnyd6havMOUJmiSN/huv+zHdT7YQwbOwmWpQBGmbd97vrJFUQINNF7d LhQIhAW3XyoehG8fFi5205SERprmAZesWeM79xCwf9++o8NH1sCrgzegqTc3QhnQzmirjUCmVy2c 91gqfV//+wtggV/85gB7S/5saO4VV6bn1IMh+1vvZ9gDRyXSWNa2wwiIzS59qu6OqAxJW+n2cGcd TUlGDBf60tv28LdaaOl+31oKdWm5cuA4WMCuy/v3XAIKaShzVhEo/nYxuF4NPSz+eylQf03LjoOG jed25Z+5sCk8ARJ/1UeX+xhC80ZhtLAj4PikXqoeXwcNPv13khsTHnIUgfO9PTqfxpxUyDFbjyUu AT44dC3J1/9TIAdF+QvBXhw8mgbWfLC9uakVmLU5B7hyb2Gsl1fgHFdrIagX/TPSlkZQej3LJbag okNtTnd02J7qwhguQwNBCKTR5EXfvRzB8jZoaKFTAriadWW76DMSmkCE27oabN6uzK2wdMG9w+Ch Oc2arEs10KUuAPTfbLImYlTOTVOHuZlljW/GUGL9LTdzwmwNx+CI0F/8J/SN9+2b9sqza3wdVwEf bFhhYbQIlHauY+EstoFlr121E/ytS80F7tXT0dLS2v6yqeDoIHSvNMBRGbpoajJg/DServZot/KM O3CruVeDchtou3Mo3oOjIYiPAMXcDbZf+zenjuSuDHWgW0G76FYIxeBjoFPElyJ9N4F73lBh3DEx lFndDpa57fqXRf999NW2+Lz30Af/wNm53wfRmTsA48p1swzVfn4xs5+ZeKKio3dIhaeo/2XFycXe diZjUQTxYjiU30ie4+1qbUjCO18BT0VueErYPcifa6qAhUT3kiMuguLisFXAvOJnD+veSatieclQ Fub1w6di6WNfh2Ng/N7WajcNOUwW13/pwZLazneiUb0oEfV1Pik5uMyfazY2RRDKg56CqLKHRyOT cGgkfjbQV/07rDBE5zz5nhTdT/cRghA6sMsjokQ+RE0wM7BY7mdNAufDwz+q/TXe1tiO/NDl+y5X Puvq6Xs/8L6v51Vz5eX85eFeXOZ4FMG9LviPgcGmRYwRbyLNaRgYbEwwQmGMhUWvoD35vvP6Jv8Z K8HZ07XSkrv6zjtAU/SmYp2THmfZjz3gQdz9aAvPLqVVLJV0n3Ef60rJ4XrMWbg660DB2XNfnPhs Z1p8EM+ebTQ+RUBrxpqCk596kEciFHFG2vET6911kUiS5bzdl397cOur3Yv4Hlt/BWweRNKp7ikn b9777VrBGj8jPGXG0mPfV94vK/w0wMRoZuY3d8sOxFiM8+8J5jaOrh58bz8fvrsL15o50SsJlubo 5+dIw8qfuH5+XOgJrc3yjFq64pMITw57CZQUGjjKI2GptgEfJSfFzXY0IqC09Kz9Y5OSF85xYhCJ DPeoRTF+HN2Jfbc0HismqgEKRzYw0MWiVJ5QOIqxhaW5EZnA2gPtofIEphYSQzRgcjhmBiSgl5Fo ItWMw2HSSFpIFE7PmGVqQBz/I9tfDXC6YdAoBJq5ub79+bernXQhBkg0KJRTgT0gUWiNh9oUAE2b mZqdEeesP7FPjP8DU/4xtA0KZW5kc3RyZWFtDQplbmRvYmoNCjc0IDAgb2JqDQo8PC9GdW5jdGlv blR5cGUgMC9TaXplWyAyNTZdIC9EZWNvZGVbIDAgMSAwIDEgMCAxXSAvUmFuZ2VbIDAgMSAwIDEg MCAxXSAvQml0c1BlclNhbXBsZSA4L0RvbWFpblsgMCAxXSAvRW5jb2RlWyAwIDI1NV0gL09yZGVy IDEvRmlsdGVyL0ZsYXRlRGVjb2RlL0xlbmd0aCA0NTc+Pg0Kc3RyZWFtDQp4nIXCh1LaAAAG4Oey tXvbOlERUQSRoYCgEMIKMxD2HmELiIAMrXbvZdvH6h/jnXetd/3uG5s0jp2/hlN8E//6NHecS4zP XLyBs8RNrpl/aw5JroC8LSDv4LwF7/IXrPfO319E2wMh3/5wiftIhA58vIzUEzF3QuycWHE+XUXX M5S4JiXuqTX0TEu5MzLvLK77cE7uE8hpwQY9r/DjgjKAi6qAUMUI1cySOijaDIq2QsuoCYs14RVt BFd1UZRsx9b0Mak+LjXEZYaEbCexvptEuTG1YUopTGkFkVYSGaU5qyKzajKntuQ2rfkttBU09oLW zmodrM5R1FGlbaqkd5b1rrLBXcEdT3XXUzV6a0Zf3YT0HoH+hjnQIANNkmlamJY12LKG9m2hti3c tmPkwBHpUNEOFes6Md5zYeLQjcm+B1MDb3rgSw+Rzozo7MiPuaMA95jJHzOF50HuSZA9CbGnoeJp GEsvIlh+GcUKvoph9XUca/gmgfW3SdzDdyls4Ps0NvFDBlv4MYv7/E+5Nv9zHg/4XwrY4X9lu5eL 3W/F3sVS7zv38HK5/+Ovlf5ZZfDP4Vl1+PPKteGv2ug/66Pf9aMr/gGo3JghDQplbmRzdHJlYW0N CmVuZG9iag0KNzUgMCBvYmoNCjw8L1BhdHRlcm5UeXBlIDIvU2hhZGluZzw8L0NvbG9yU3BhY2Uv RGV2aWNlUkdCL1NoYWRpbmdUeXBlIDIvQ29vcmRzWyAwIDQ2OCA3MjAgNDY4XSAvRXh0ZW5kWyB0 cnVlIHRydWVdIC9GdW5jdGlvbiA3NCAwIFI+Pj4+DQplbmRvYmoNCjc2IDAgb2JqDQo8PC9UeXBl L1BhZ2UvUGFyZW50IDIgMCBSL1Jlc291cmNlczw8L0V4dEdTdGF0ZTw8L0dTMjcgMjcgMCBSL0dT MjYgMjYgMCBSL0dTMTMgMTMgMCBSPj4vWE9iamVjdDw8L0ltYWdlNzggNzggMCBSPj4vUGF0dGVy bjw8L1A4MSA4MSAwIFI+Pi9Gb250PDwvRjMgMzAgMCBSL0YxIDExIDAgUi9GMiAxNCAwIFI+Pi9Q cm9jU2V0Wy9QREYvVGV4dC9JbWFnZUIvSW1hZ2VDL0ltYWdlSV0gPj4vQW5ub3RzWyA4MiAwIFJd IC9NZWRpYUJveFsgMCAwIDcyMCA1NDBdIC9Db250ZW50cyA3NyAwIFIvR3JvdXA8PC9UeXBlL0dy b3VwL1MvVHJhbnNwYXJlbmN5L0NTL0RldmljZVJHQj4+L1RhYnMvUy9TdHJ1Y3RQYXJlbnRzIDE0 Pj4NCmVuZG9iag0KNzcgMCBvYmoNCjw8L0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGggMTA3MT4+ DQpzdHJlYW0NCnicnVbbbttGEH0XoH+YRyqoVntfbmAYiO00cFAjam0gAZw+0BItMZBIlaTk5O87 S13MlbhK2hfLXMycmTlzZnZhNIaLi9Hd9e0N0MtLuLq5hn/6PQqUUEoZ59SA4RSUpFCm/d7nN5D3 e6MP99zArOr3GMwO1pRqRqVn/vym3/uz34P3d9cArVDsNdRw56usNruosWCsIyrjglgLGA20IYxa UFYRyoATrTWDyRIzu10ms9TEcFNAV2C+C+wq0K8VMBuTmDtYi76C4a8AETNi1KGOEyxxwheXksmz fI3GSV2nZQ6TCqFiBtUkd+6SG8IbTwyqqT7LntwFvnpAwN8FIPbDs6vEUcNAYy4Sq9CWMAsPy3Z8 6qrFTyZ2nx/6vccLKszV5d/w8LHfe4+YW1x2jBtzpIO3cR+jL+/Gt5DkUxjI6C4rkXv4dA9JmcJA R9X6aeCj7qFEbIif4mM0DNlik432bVdl8S2d1BUMmIpesnqe5VAPVDTHuN0ommJP5VHyaR6ylpao o/yOkbcMEWx6J0tCE2N2ruMSc2syhpcyq5GrGkPLyLGGmQeS4MY6UXpIn66T5SJElOLE+uZt6BMZ qV+SEbeGxDsO/ptQ2p7RVVHPQ4UySUksfPtGQipKFlUxGIqGqXWVos7sGcbc4Ao/Zdfk+7RE9w3+ 7XaT3BLsoucWCrGvTSsi97ZfoypNQ7XxmAjl23d05X6V5IfG6FZjDjhCEi7aOG7naFyHKGsG5ezo 4C832NG8dmJbvR2NvqPgBOZZbhoyCLLKo3I2OicQ05GHGwmcIy+P2X6RRF8HOJEi2i2EMl38gOJn k6kUzrf0GQpPprLbFof4PGGlIQ4lqjlRCtCe45hQtT9Y9HuuJOx7xwF1+3/RctkfHED3B/Pttv75 XuBCEFzvB+K85RDSkNYuTMv1/CLgAvPXvn1wyUh1YrtI8tnarfIBo9FTlk+zfIar1kR1AcUqLRMn qnA/DSPyCPElXYSS1QyLC+d6Isr4l7YWs5Kw+P9srbZn9DBPq2ChTAkihe/wSp1uMRdH82STwjyZ uvMElsm37fyFZ4K7rnjQxca5pOUc5zhZB+nEm8v4jmfptMd0+qq1lAiGpKiYtO4A2cWm74jPM4IE txyDEmRMEu2bjssCq5yuJ6lb/lVQvIy6+7ntuVxPnMu8aUCKby33VbqrZFIsV0mdPWWLrP4xGLrb lzU2L41NmsOXd47h8S2q+7fO216eTPW+TIGy2/O9ewdhSHwKDbbb8I8sX+O/32GaVXWZPa1r/MqK Zic7fcyK5ikwCwqC4rPQD/NclC9JOQ1OoSWa+x5nhcCopwS36YmN5clwGQ5S6f2zaPt63i7/2yU+ yzYpFoIyH5rt29Ax2lwHQ70jBkt2b8RQ3pwR0Y7wiM/I1aoo65OG8M4URez2vwdwUve/nvC6Eg0K ZW5kc3RyZWFtDQplbmRvYmoNCjc4IDAgb2JqDQo8PC9UeXBlL1hPYmplY3QvU3VidHlwZS9JbWFn ZS9XaWR0aCAxNjUvSGVpZ2h0IDY3L0NvbG9yU3BhY2UvRGV2aWNlUkdCL0JpdHNQZXJDb21wb25l bnQgOC9JbnRlcnBvbGF0ZSBmYWxzZS9TTWFzayA3OSAwIFIvRmlsdGVyL0ZsYXRlRGVjb2RlL0xl bmd0aCA5OTE3Pj4NCnN0cmVhbQ0KeJztXQVcVNn3X7vXXnMRRMTubhFEEQw6pLu7u7u7ZhiGoVsa VDAxQOwWMFARULED+H9nno4Ig4u7xu+/6/mcz/3cue/cc+Pce+K9+9789tsv+AW/4Bf8I5g3d97C BYuXLF4yevTon92XX/AtoW/fvps2bbKzs8/IyKyuqn737t3bt++etLy7d+dx6xPk36Lk3r2GQxWH goKCJSUlJ0+e/LO7/Au+GgYMGCAkJJSelv7y5av3799Dps+fv7h//8Hly1eOHzuelZkbE03O21d4 6tTpq1euPnjw8MWLF+/oAMr3Z8+eNzMz/yX3/xcwcOBAfT39pkfNbW3tb968bW5+fPXK9UMVR7C7 KRRKSEiou7u7ra2tmZmZvb29t7d3ZGRkIi0xNzf32LHK69dvPn78FLXev29re9+empLGycn5swf0 C3qEvXv33rxxq+19x5s37yC4O3fuXr169cyZM8eOHSssLExJSYmJifHz83NycrKxsXF1dQ0MDIyN jUV5QUFBRUXF6dOnsf2hBKAKIPH2to73796HhoZOmDDhZ4/sF3wGmzfzVFWdef++/e2bd8+fvXz8 +ElLy+Pm5ub79+/fvHkTcjzDgNLS0sxM+jaHlJHSaLTi4uLjx4+fP3++urr67Nmzt27damxsfPbs GTR7e3sHAfjp6Og4ePDgnz3KX0AHCzOrt2/aXr9+2/r02eOWJ8+fPYcP1t7eDosM2Z0/f2H//v0B AQF6enqysrK7du3i4+Nbv349Dw/Pjh07xMTEFBUVTUxM4uPjDx8+XFdX//Tp01evXrW1tXV0hvaO U6dO/fnnnz97rP9pwI6jUpOftb588uTZ/fsPHzU+ev78OYTz5s2bu3fvYsNiL5PJ5ODgYGxPQ0ND eXn5PXv2bN26lZ9/2/btAjt37pSQkFBTU4O4XVxcgoKCQFxWVgaFgN39mbTbOiD/e3cbVq9e/bMH /R+FKVOmHqo43tLS+vBB462btdDb2M4Q9+3bt6G9Iej09PTk5GRIMCw03MrSTk5WUVJSWlJCEntc WVkZmxq2Xlp6r4yMnJKiqouLR2wsCeo9Ozu7qKgI5r6hoYGQNXY63Wt/3wZj8erFG3k5hZ899P8c zOKeXXPmUuPDprra25cuXa6vpyvhO3fuQNCJDIADlpGRERQYoqGhA/mqq6tra2sjhaDl5ORQgp2O fa2lpaWvr4/dDVWvoKBgZGialJQCg15SUoK0srIS5gChHNT7yxcvX7+G2nj7+lWbnY3jz56A/xBM +GPC0SOnbtffvXjxMkzqlStXsKOrqqrS0tKio6Pj4uKwSSPCI+Rk5SBciHX37t2bN2+GHl7JgOUM WLFiBfET5Vu2bAENiCF6LAlNTc2cnJz8/HykWVlZcOSgN1paWhobHzU3t7S2vnjc8lJZUf1nT8N/ AoYMGZqetu/69VvV1TWInmCgIQ54WYiYYHzDwsIiI6KhpbF/4YZBjhDrokWLZs+ePX369KlTp44f P74zN5RwcHBwc3MvXLhw2bJloEddWHklJSUdHR3IGiuHbtBLy5qamuAP1NXVPbj/kKFVHm7fJvSz JuG/A1ZWjtXV5w7sP5iUlJSbm4s9mJWZZWZmZmVl5eDgYGRoBn9bSEho3bp1CxYs4OLimjJlSu+Z Q+6E0KHwofzFxcVjoumhOhw56I2LFy+ePHny6NFjWGBVp2uKCysmTJj4/Ub6C/i2bC8qOpCfX+jp 6WlqampsbAybu5UBiLDWrIGQ10Fvb9y4ce3atVDUSxmwZMkSpH379u1NE8OGDYPQoRNERUVVVVVR UUZGRkREBEsIP93d3e3t7e3s7L29fRzsnNRUtZZ8hKWfA0qgN773hPyLYfjwEZHh5PLyCnt7h6DQ 0Cu1tR1fA3aOX+FfsbGxQehz586lUqlf1Qrgen39tfr6tJycCRN/7f2/D0oKWkWFpWlp6RA3tjM1 MfF6Xe3VWzfPXblcff7c6XNnq86dRaY7Xrp+DVKAg716zZreN8fOzn7mzBlUvHLzRneeaOs0A5FH By7fuI7OXK+vBfGlG9dgXAYMGPD9puJfD5MmTvH1CSkpLvP394cx1dDQgFE+evz4/UePGhob6+7e vV5be+3WrRt1dSwR/jRdcDdujB07tjfN8fPzNzc3o8qt27fBuQs3oi2kuHq7oQF9eNDUdL+x8U5D Q01NzbZt2773bPzrQWSPTFRkbHh4hK+vb2BgoKurKyzjrFmzbtbWNrY0P33xHNj89EnTk8ctrU+B j5+1Ekj8RDmhaRFb/WVb8PoI4ofNTWAOtgRDghWzFbTY+vIFyvHzwaNG+O2FhYXQCd9/Mv7lMG7s eAtzh4z0TEjZ29sbG1xLS2vNmjUTJ07EVnrY9Ohx69OXb9+00e9ts0D6nbGOjrftH26D6+rq9tQQ /DSsB4Ls2csXr9+/I+ow+TB5vm17/+LNq1Yss+fPmltaEKBhHQ4dOvRHTsu/Fdav2+Lp4RsZGe3s 7Axxh4WGIVbi4eFZtmQ5TCQM5ZMnT953eajRM7x58wZuc/dWEJtfv3699y5ZW3v769evGxsbL1++ jGj9x0/LvxL69OmjKK8eE0O2tbVzcnJCCGxoaIhoa/fuPfCcOTk5EWHFxcU9e/asnfnM8q/g6tWr v//+e+dWEGqBw1fIuq3txYsXDQ0Nhw4dWrRo0ZTJbH9OnfazpujfBJMmTdXRNoqJITk4OEKZBwQE YF9v2rRp+zZBzDMs+ODBg0eOHFleXo75773EExMTCf5YLYjiey/oDoaTD30CN41CoYwbN27rVn7B HTt5eLZ36TlsDQJwPj4+BOxqDEBm7dq1c+bM+WGzN2PGDOY9AWQQXf6wpv8eLF28ytjI3M8vwNHR Ecrczc0NWxuB2LRp7FC/8LQJi8nFxQVVDO3ae4nr6OiMHz9+//79vRc0mMMWPHr0qLa21sjIaMyY MegJQ9vwcs2Yi2BBSkoqIiLi1KlTIPsyK/Q2ISEBffjyfb9ly5ad6gTJyckRrEBI6NMd3dGjR+vp 6ZWVlWFNdm/35cuXJSUlCgoKvbzv9INBUEDExpp+I4vQ5JgfbG1paZlJkyaxsbENHz6cSQmDDkG8 ffu2l7KDROBifZWsMVcPHjyoqqqChkGLEhIS8BWRR6/OnTvXe1ZdABZh3bp1LIevra3dm46BDMTz 588nk8noZG8aRYf/1w7jwXDvlVFxdnJzZGhyhGCYXoh7h4AQNiYUaRdnWF9f//Hjx1C2f3vmewIY axj3O3fuwHXHMhs7Fo2Pg4a0s7NjOb0QAapg7dEfnr58iaWFXn1Z80RHRw8ZMqTLDEAD9KZ7/Pz8 iB//UqV0gZs3b44aNerHifOvYMSIkYoKGr4+9POE7u7uMNybGTBtGgfsNeKmQYMGdakSFRXV2tra 9fQRK2jvaG9r/wsyELx+8xrYwoi20AeixWls0yDrixcvEmRv3r4BDdK39JPs9KNTMCuEzofffunS pRs3bkAtQO7tdJG3E02/b3sPYlREhuBz7NixLhK/desW0Q0C6YcsPuK79+/QIlERer776Jhsu5ej 3Q7GmsTE/jhx/hXA490ro+Tm5gGTDYcKsS1kDaXdr18/yBpRGDJdqkC9FxQW3G2496i5icDmxy2d samluRHFjAxxlSDDz875+w8f3Ll3t7a+7lZd7dVrVy9euigmJgb+/fv3RwolQ2xqNFR/5zYo791v QJWHjxoJhHALCwsFBAQIc4NNxMvLC6EwGyK68aDxYcOD+6gOJMTh5+/PHMvUP/8EDVGFQOaggER1 FD5++gQpGkVnbt+9A1bgSYyFWZFAZrvoKurevd9w7dq1HyjPvwDO6dxysiqenl6QNSJuCB2GUlSU Pu0DBw7sydmYPGXK/oqKc5cvV58/X3Px4tlLl7rgmQsXcAlIZJASZEiJKtXnzlVWVR09caL8yJHS gweTU1O5Z836jWFckC5YuBCybn316kRV1Ynq6tM1NUQtAs8yUlpy8pCPhoaoBZgzd+75K1eIDnzW 6LlzJ6urT505U9/QUHX27KSPLzXwbt36sLkZNERvmcisDgT9CUZXDx46VHzgAIVGy8jJwc8z588T zAliJjLHi4pV585dvHoVDuf3lmMvYRb3fHk5FR9vX8jaz88P5ht7REFBkbjKnMbusHLVqgMVh8qP HD107Pjh45XdEeVM7FxYfuQYMgcPHykq259bWJSdl2/n6DRixAgmZwTs0OpNT5+VVRw6cOhwxVE6 PVJURHqk8gSw+tyF6dOns+xhXmERWgEls2kiRfX9FYcOosPHKzds2kQQa+vqNrY8xaXOve2CpeUV BSWl6Tm5OwSFmJ7MkqXL0Lcuo2OOEa0TeOTEyZNVZyb+zzy5mztn0d69ShC3v79/UFAQAjGEsWpq vTo4JC4lXXSgoqDsQH7p/l5iXklZXnEp0tyiktTM7KT0TFEJyS5s9YyMX3V05BQUg4Zepbh0X1Ep UqJ6fsn+89duZucX9dSrk+cuFJQeQJXOCFY5hcXIFB0oLyk/xMPLSxB7BwQdPV2N8h67WlyalrMv ikzhnDGDqMJcYNb2DmjoSyMtKQMBmuvuH/4smDN7kexeJU8Pr2AGYHcjztXQ0Ohldf+wiNTcvOTs 3N5jUlYOLTM7IT0zJJo0b+GiLgwnT5168MRp8EzMyAYx0kSsiqwcoiLyafvyL9yqb2xsPM2AU58D Su60PI1PTe+OlOTUuORUZFJy9m3YRI/yBgwcSE3PBEOwZdlPlKMDlNS0TTxbuo9dTEr6C2Mnup2Q kRVOjv9nIvqWMHPGPBlpBXc3j7CwsPDwcB8fH/hIKiqqf1kRKzY+Pr75XQclNYOUlNp7JCenkZLS 7Fw8xrB6VCq5V+5I9fnohKTYxJSYhGSkzIpECTIxtGRycnpSdl56QXF28f6c0gNIgRmFJdT07Chq Yhg5PiIuoQuGx1FDYuLCSPFgvmT5CrTFwTkDfGJoKcDu/UQhWoymJfuHR7E0aiJS0plFpSzHSO8q vXpqVHyiilaPD4x+GMAHI4bAwT5TRprumSO8QliKDQ5fV15e/svVOTk5z5w586Stg5ScHklJjIxP 6iVGUZNJyRlIB/XwipC5nQMlNQs8w+MSunKmJEZQaEhDydTgGHJwTFwoKR5kEQziMBI1jExFJiSW EhJDwaXOiELQB0bGBkTEhJIoM2bSb3XybOUvOlLJoiFGW/Ty+CTwVNc1YNlVdT2DtIIS1sNndBWI pleuYX1750cCwisivJ00caqYqIy1tS2JRIqLiyOTyYIMGDp0WE91d+zY8eTJk9NX6khJGdEJqcDY xLReIikpvaD8WMv7DmVNHZbMIylJpMR0UMbQWLBFWygPj6MFRpJ8QyP9wqIDIkiBkeSASLJfeDQQ mcBuGBRFR1D6hkR6BYWHxiYQLr2ajn5e+fFoakr3tlDCGFc62uLdtoNlV32CIhMy9vXUT6RRCSlg zlKJ/WBAbEuEq8OH/y4qvFdXRx+CplKpqampQkJCu3bt4uHhZVnRwcEBoWvZ8WpySiY1Yx+BCZl5 H3Ffp8LO5Z8wKafw7tO391rfrt2wqQvzwYMHJ2YVEAxZcqBl5SVlFypqaE9j52DjmD7taxG12NnZ 2D8caAyIImcUHfi8/58NBNKMT8tmn87iRujUP9mSc4toWfksh0l0Pi4t2zcs6luK7R/A6NGjR44c 2ee3PruEJOXllChxlMTExLS0NFlZ2T179piYmHehR/BYWFgIWWcUHKCkZGMqknMKEzPzMf/IIIWk 8BMpM09c6oz0S5n5uaWH6WvmWNWkKVM7NzFs+HCwpaRmE3WZ3Jh80vJKMovKdwqLfYPhjxmTkluc kltE8O+CRLu0jLwoSgrLmw+beLcePXsFZMSgulbPzE/OKUpI36eha/jPu/pNAOIm3rjcsJ5fQlwm PDyCRqMlJSVh/woLC5uZfSbupUuXIha+/uBpLC0tigrHJpOSmkNOzoxLyUImLiUbGSKPQlxl/CQK 4dnmMBE/QYBMdkkFJO4ZEDZw4KebtHAnQmJhjhNjEtIIMoLtR8xO3VcKFJGQ+Y1VxD1nzpwlPQPx gJJr5kyCeNnK1bllR5ld6ozMzsfQ0g1MrVjOnpKG9v7KM0QPe6iejerrNrFw6X8KjBgxgp2dfejQ obO5F0qIy7q6uEHcycnJ2OPi4uLS0tIzZ84iKJWVlV++fJlffjwgAqYwLiSWGkqi0dPYhDByIvLI 0JFEC4qmgIYg+1DIoGHiB2J69YT0wgOPXnXIq2p27pWytr5XcIRvWAyYgBvR1oeKJBopKavmxn1L B7fuw4F7+eWb8yl5JeCzcQsfQS8iKVNQcSI4hkr05zOMhb9HDYqm+keQ+LYLspw9R09/CLSn6igP jIoLio77Y+Kkbyq0vw+w3RwcHGxsbOPGThAXk9fU1E5KSk5JScnJycHUSUhIaGnpDBw4MDIy8nlH RwgpydknxMUvzD0w0iMoyj0wAqlHcBQzj3JcBY2jV6CjV5CTdzB+guATJRMZxESaVXastPLcitXr mb2aNp3T1s3X3sPfwTPQ0TvIySfY2Zferpt/uFtABLilFdLVgr+/P3Yr6DEEfn7+ffv2vevoiKJl goDJHPSu/mGu/uEufqHoDxhqGVkwHwFom1gGRFNRDv4s0CfEyTvIxTeUaeg7A4yOT2isq18Y0b3u iHJwtnRksSx/IkyZMmXBggXDhg0TFBCXlpJFLJbBAE9Pz40bNy5cuPDEiROl1ddtPQItnL2t3fyQ sXEPACLTOY/U0tnH3NHLzNHTxM7d1N7DDOjoZe3mT1wl6JlIVATaeQcXn7wUEEObMOnTCYSFy1YY 2riY2LmZ2rubOYCPJxDMzZ28zOk8/WJTC1502rbIU7LLHH1CCc4gAFq5+lm5+Fq6+Fg4eZnYexjb uclr6o/4eJ4KniouWTp7d27iM3TwMHfAWDxYRtwzZ89zCYgydfAw7akuUnvPXeL/W+frxo4dS7zN t3DBCmkpBUsLq8zMTKh0Z2dnXj6+m83NQdR9upauupYu+tbuhrZe+jYeBkBbTzoy8vRCa3cdCxct MyctU0c1I1tlPYtZ8xat2bRVy9RJz8qFICMomfihuq0n6pq7BOWduK5maDNo8Ic7jVxcXDNmzVXQ NlE1tFY3ttM0tdcyddAk0MRBy8wR/SEYEkyIjJ6VG8p1zJ11LJy1zZ00TR01TOzBVs3ARk7TZNGy NZ0FN3HKnxiXpok9HZnMO6GGiYO6kd1OcTmW87aWZ5uOpbPGl6rbaxjbzVu84kdIsdcwatSouXPn rl69euLEydKSynJySiEhIbq6ulZubofq3hq5hCjoWSvo2ygbOSgbOygZ2SNVMXZESi9hFCoa2Mrr WcvpWu7VMpfRMN0tqzl+In2f9h8wQEhaVU7XCgSd6zKRKEQGqaFzUGxhFd9uaVQUF5fctm0bnIph w39fvp5PREFbQsVQUs1YWt1EWsNEWtNURtNMVtsCvVIytCOQ3gddK1l0QNNUSt1EUs1IQsVATElP Qlmfd6fkdO55ffv17zLw2QtXSKkZiasYSPSI+uAzf/lalvPGt0tKQtXwi9UN9mqajRr7x/eW4NcC nPMNGzZApa9ds4V/q+DiJct9E/ODs07t1XMQUzWV0LCQ0rKS0rSS1LSkZ7SskX7Ia1qJq5uDRlTF WFjRYLe83gYBsSFDP510GjthioiykZiKiaSG5adadA5M/FCI1MA1wj48a9ailQICAlJSUpaWlhoa GsuXLx8wcNA0rrkLVmxat11sm7iKkIymoIymkIzWLlmd3XJ6uxX0kO7cq7NzrzZxSUBKYzXfLu5F KydMmdZ/4EBmZ7ro5PGT/pzGNW8a15yecS479/yhI0aynDQ2rjlsM+jYU3V2rrkc3Au+k8j+CYwf P554A3f0qDHTuJfElF+3DE4VVTcTVjERVTMX17T8iFZIxTToiLyYuoWIqukeZWNhZaOd8vpC8roL V23pHp/OXb5hj5KRqJoZUZFRlwWKaViAp3V4loZd4PjJbJKSktR4KoVC0dHRWbFi5XR2rn59PwRr g4cMGzlm/CR2LmK2mThlOjfKR47pupv6MOBHzOP/H5g2bdr8+fO3ikhlnH+u4xoppm4urmEhid2n YyOlY8tAm49I/4lLIIAQRVVNhZWNdyrocXDPZ8kZbjCfmDIYSmhafaxu8znaMnnKGjr5pBzFQtq1 RyQuLi4pKUlJSUlUWEJQQGTu3HmAcePG9eZJYm9EjIhjGAOGfwSWx7R62VZ36EKmpqa2jwHObm4/ /WEoAnAnf/+yG68MXIIVjRyVTZ1VzFyRKpk4Ie2MKFE0dlQwtJM3sJXVs5bRttgjrz12wpdCy3ET J8vq2cgb2KFiF26d2RKNGrmFU8svC8mo6ujqampqKimqKitpb9zAB+9i1qxZXc6E9DS3vYGsrKzm bnDnzp28vLxNH08+fEOgJCaevXz5wpUrBSUl30PbbN68GbGzgoIC7PKXKRGLHTp0qPTiA2vvCFOX AGNHX0M7uuesb+thgIydl+FHNCDKbTz1bNy1LVw0zZyEZVSGDhv+Zf6ANZu36lq7GdgyXPpODD9j a+uBvIlLQGhq8b5TNzfyC61auVpRUUNGWg3zD3FPnjy5y2spfxugcw4fPfqwpelhc1Nz61Ng09Mn D1qaGxofEpGdl5fXN2mIgEmTJt1uuFd/987t27dNTU2/IWcCoKnAGd1+/KzVzMzsC5RYDA0NDQdr bnmGxSGQdPQNs/cOsfUMsvMMtvMKRr4LohCXEE1buvpuFRLu27frqUWW0LdfPzUDi554fuDsSefs 4B3qEUquvPog/8i5WXMXbOMX2cLDKyQkhPChyydf/gkg/GxsbHzz7m1LS8uFCxcqKytPnjx569at 1tbWF6/ohyExJzAc36o5WAp+fn4+Pj6kX/Vhk14CbDFxDvzdu3dwuXsiE5Hcm5xfFkFNCY5NCIyi +IXH+oRGe4dEeYdG+/SAuOQZFOkaELps5Ve8tg+YyjbNIyjCKzSqJ87MptGN4FhaTFJWCJk2esxY bG345wgfvuFpbfilHYxXHmpra7m5ucF59OjRU6dO9fPzQ2F7e/vTp0+3bt0KSiwzFPr7+xO7UlBQ MCcnR19fn8mqf//+WI0kEgka8uDBgyBeuHBhl+bAxIkBioqKXS7BZYImKSsrO3z4cExMTE+fEIRm MzIyys7OPnHiRH5+vo2NDfND8VpaWighlNLr16/Dw8PRW1FR0c7VBw8ZomdiTklJj4xPCCNRgunP gqP8wiIJ9A/vEQMiol28fDg4OdEx9P+rzJzgHuEvcAYyWw+KjImIo8anZbr5+GFCsHq/7UlOa2vr DsarPZBRZ0uKddXW1oadgl1PiNvc3JyYSWgAxIYdjM+3Mt9FhW5E+Yez5R9fZ8CCMTEx6dwc8ZYK 2JaUlDAL4Rb6+voyPgzbTqQdjBcrVFU/O0eE5aSurk68mtTOAKKVs2fPIp4CwbVr1zp3gHg1w97e vsuQBw8ezDGdk4NjOjv9QTDHNHYGcnxEdnbi0fCnEgbOmDlz5cqVCJRsbW0jIyNTU1MPHDjQnTlL QM+Jhrqz7Y7oFQfnjIWLF3NMn/4N1TgBpaWl9FuvL15gwn/rFJLv2LGD2CN1dXUwuCiB50ZMJl35 v3mDaUeG+P6PoaEhQYwSaAlYTywS4nUqzDyxWgig0WgohKXw8fEhSrA3YT4gmkePHt28eZP4liBY EWRsbGzMupmZmSh8/vz5vXv30AqcyaamJhDfv39fXFwcPjY8TOL7tKiOS+hGfX09tFAvpwIcoDqg kVatWjWTi5uPV1BIUFhIaJeSkjI2BTpMpVLLy8uhVRBWQL0ghTKBHjt+vBJ9A83atZ/dicLawKxi yGFhYdBI8B6lpaUlJCTgeFtZWtnZ2Tk4OMDBYByo2MKzmW/LFoE5cxZiU8+ePRuW7hvaUALA8GZt bTtDKMLCwszyiRMnFhcX19+5c6uurqiIfswVnuHFK1ceNDY2tbQ0NjXVMcrJZDIuQYEz3ndowPxH RUWtW7cOHdbT06urr7/T0PCouTk3N5dYRQi7qmtqmh8/xmLA2Im23NzdUf3egwfY79ikiAGhJ2/f vdvy5Mnzly8Rfv7GWITWtrZEK1evXsUUwS6vWLEiJCSkpqaGeD9x5MiRUlJStfX1T1pbGx488PDw gKAxqK/6TxAsbHQeSx1aa9u27VoapnY2Lna2Tm5uHpAsfBsM/OHDh1jq16/fgNHB0LALCgoKCgsL MWOlDChjwP79+5GiEKsiJSUFcxUdHZ2WlgYCVDx+/DiUQ1RUtIW5hZ6uoZ6usY6WKR+vAC8vL4zF jBkzvsd3zpcuXVpZVXW1rg7iDggIwDRCS0NkEMf+w4dzMIyyslWMDwotXb782OnThyorK44dyy8p QSHxNA16ODUrq6yiAqip89kRLH0jo8OVlUdOnDh47BhhgGbNmXP01Knj1dWV1dVcjHeBl69cSbcO 1dVoqPPrltb29ifPnj1ZU2Npa4uf0zk56xoaSsvL0atVnT5whD782Wn7T5w0CczRz6MnT3L93XeN 4RphWqAu4JZgM2qoG4UGxYUEx0RGxmRmZl2/dh3ODN2PffECOgRyr62tO3XqFHY91gMhd2wE4sOn AEIbYJ1AHUELYalA7WBfoDw0NMzFxc3FycPFydfE2FFwxy4REREsdUTZhDr95rBhM09pxdG0nLzi iiO1DU3vOjou3qzPyCukpqTHxNMiSJQt/B++87NHXLy88lRqNv0INA/fJ+W8YRPP2Ss3kzJzYyiJ IxkOJDP8X7NufVZBcfq+gqT0LOIS/44dlTXnURIWTRrIuI1jYml98uzFI1U1mBC4dtitxJHvQyer U3PyUrPzVTXpr5pKychXnr2QnJnj/DEqZHmTYQsf/+kLVzPzi+NoyV84XviXAAdp0aJFAgIC0Lrw FmSk5R3sfKMiEmKi4smk+LLS/fV19fB2XjO+Wvue/m8TbYQvAVcBOwU2BSnEStC8ZAAyMEMwWFVV VXFxFD9ffx/vQF+fUE+3MGUlbXFxCWj+jRs3fj9ZA4QlpHNKy0NjKUEx5KBockBUbGBErF9YlHdQ uIaeIVun7/yoaOrEJqWFkuK1DT9zvbT0jXL2V5CT05U0tbowF9wjQkpKC4mNs3b+8KRbU984ITM3 kpqkqsk4ftynj6OnbxQ1OSohOSYxDeUR9DOrieFkBEckdAPpqnX0p/8OHj60rDxySsY2wZ1fGI6q jl5iTn50QrJ+t8NmXwuITRBEYP5lZWUNDAxgUxTkVXy8okgxybHR1HgKLTMDocHJ+vrbkGNPrwAT H69+9eoVpH/+/Hns+5iY2JDgsMCAsODAqMAAkq62uYSEpLy8PPY1jCAXF9d3/a8KK2f36ITUUHKC uYOL+F4FCVkFUSnZLfwC3Y8xWDm5xSSmR1CSNmz+7JSmmZ0TOGQWH9Q0/OyeyYABA9KL9ofF0cIp NN5tAijp17+/e0AoJS0HfHi20pXGgIEDvYIjomlplLRsRXWt3aISu8QkhSVkdolIbBUQwmrZKSI+ 4veRYOUXHh2Xmp2Qlbdj156exoLN7uztT0rJpKTnCOzskeyrAPOPCIWfn19FRQVCl5OT09TQD/In x8WmxZGSE6iptISUjIzsw4ePnjlTU3urFpYdihqeJFzEGzduXLp0+ciRI/l5BWQSJToqNiIiNiI8 LjKcGhlGMzd1EhMTJz6lCwUOZcLJyfnN/fDOAAVLSs4gp2TGJKUvX8364SYBw4ePiKKmkFOzyClZ 8xcu7nxJ18QcG/Ni/cPHz55hZohCBO+IU6jp+6JpKQFRpEGD6KfoR48ZCw7JuYWQ2ux59McKffv1 8wwMReHhmkvrP38zpXOwjCjG3T+YlJTx6HXHgcqTTB0OF9rT05N5IGfosGGhsdSs4oM1N+5gV9JL hg7955+MgCmfM2cOfHU4hBoaGnCwlZWVlZRUzE2tgwOiadSchPjMxIQMWkJaAjUF0k+kYQ1gJSRR 45Pi4mhkUgKZRCPFJMaRUiPDE+1sPdRUtOBSYuXARd+yZcuSJUugwL/HHacuMGf+wvC4FK9gqO7I Pxi3+nu66z5z9tzg6HhvUAZHjfvjM22zaMly94Bw75DoVx0dMEzw92CCEU8FxyZ4BUc6evijFYKS nYMzipoOPv7hZOahNSUNXc/AiEPVV2HXXF1dEWgjnLl06RKq7xaV7PNRWDt2CXsGRQREUaAh4dM6 OzsjJoLdjKFlKGvq9e9P/2Lk2HF/eIVEh8TSXjK+FOEXTtIxsezlrc6/BFjzefPmrVmzBt4+FDsC T8hdTU1NTk7ezMTCyd41KCAygZKRQstJScpJTKAjVkJSQk5oMNnTzd/a0l5dVVNGRgZLBYoCfiAf Hx92BwKuH/YXJLzbd5o6uBtZOytrGX/5UcVG3u2gNLZxUdI26n51j6ScgZWjmb27tVuAvTf99q+l k7eJnauWsRUbx6dD6avWbw6hpFs6+2iZWBMvrQMmTJyMn4ZWzmb2nlauvtaufuZOXkY2LkY2rtt2 iTJ7NWz4CHVDS0MbF3NHT8bt5RA7jyALZx9LVz+xvUoEt99Hjjaxc0NdYzt3MydPsBLY8w2OZHcG Dg4OhGkIADds2AC5w+bq6upC9PDh4dQpKirKMkBTQxNhJoSLLYy1oc4A+gNNUVFIGXEWdjQ0Rudb Cj8ANm7bvUtKaae0yvL1rF+aYMJ6vp2g3CWjunwdC8pBQ4YuXrlhp5SyjKaJnJa5nI6FoLji0jWb hw4f0Zlsp5SKspG9gp7V5h0incvHT5y6YetOMQVtKVVDGXVjMUWdzQLC7FxdvxY1ZvyEdbyCooo6 exmtSKkbbxEUmzHn013xPn36Ll/PIyynKalqIKmqv0NcYfyE7/VnfLCz2OzLli3Dfufh4YGex4aF 9LFzofCJb15B+pA4RLx9+3YYF5gDGGhIGWvmp7zy3PuHj316YQH79us/YtTY0eMnDhsxqsulP6aw bxVXsYnI2qNkvFvJ+M8ZLD78NXjIsFHjJowa+8fAQV96Aj5w8JDRDLJBQ1jHWag+/PfRg/9BFPZV wM7Ozs3NjS2PDYtdD5mu/Aj4CXW9ePFiLIyZM2d2+Y7TT4HePyL/MmX3S8wSzL+UtqWRR5SUlqWY uomApGr/AQO/XL33XeoN2Y+HyZMnf7/Y+X8cxv0x0cTJR8/GTdvCUUHLeNKvjz3+q2HMuPG7xCQE d4ts5OH7X3j98xf8F+D/ANXK5mENCmVuZHN0cmVhbQ0KZW5kb2JqDQo3OSAwIG9iag0KPDwvVHlw ZS9YT2JqZWN0L1N1YnR5cGUvSW1hZ2UvV2lkdGggMTY1L0hlaWdodCA2Ny9Db2xvclNwYWNlL0Rl dmljZUdyYXkvTWF0dGVbIDAgMCAwXSAvQml0c1BlckNvbXBvbmVudCA4L0ludGVycG9sYXRlIGZh bHNlL0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGggMzgxND4+DQpzdHJlYW0NCnicxVppWFNXGs5G ViCBkEBYEkLYCcgSIICAoLIngApYqMUFFEVc6oIoKtuoqHUXneLSmQodx9FqnVqBaltq1bYo6gMi IFAUBESsiIBAljkXErnZWJ6nA+8Pntyz3POe73znO+/5LgjEODDnWNlYWbCMx2s3PTAwtnTxnRsS Fh4hiAgPDZnj48g2ok43KQXoMaw8ZocLIAjXb970sRD6FRbgyqaTp5uaHBQjO3/AcF7O1w9apSPo abh5LEkoCPHi0HSnm94w6FZ+EYIF+++LpEp48e9kYaiHucH009Rn88MEMed6lRmOoCJNGOxmpkec Xo40u7mCqBNd6ikCiH9IEs62oZKmkaKusUtYZF6LRooQBq4sDHGgTR9LMtMnIvrSmBQhPEsNm2Go PU0cdc39hfH3x+UI9nqWwN1oeljqMP2Fqa0KbCSiof53PT19Q0MiCbxcdCrKnT4dK04ymSlM74Ez 6W2v+uHi2cP7DhSeL6n4o6tfDKu8GuVqMA17nOYuSO2GUWyrKM5KDA/w8XT38PabG7P2+I36Lpg5 iyId9PBTzZFsE5bY/oGCuP324cQAVzsLUxpUacq2mcGP3nm99vUoy+MhHF3c1HIkMQMXVHwg0Hf/ 9KpgPpeio4UcbWLjEZ1XVvPhHHq/LcLGSA+AQiaip4YklRf15QeOvU9vFJ0qyM/fvc2dgoJNxMZr xcXHg/JWb6+cOrQ/Pz8/b8McElLzm/86kNghKf1qgs3dmdrw8a2CDr5WbfQsGj6V/x+o7gsq1XCU Ss45Yj80QhLtc9+otmnY7KIzFSSJrKAsdRyl0v4tZnKHQ5G9igZUGohr8uaa4KdiuSlOMdXqSUpf zNMfYYCih/2qWj1UkRdmoTMVGwfPCNguD4E9yjTuziQClkiseXKzGkOXbpppQpgSjyRZRf0oG7X9 J2WvE5+y1UIgSU75b1U5SsrXexhip2RrI3S5S2QGlJzMKlbWu71rjDF6vpeG1DnDjWAGHonCUwyZ bDaTro0Zly+GSKHoUYiYyZPU5x+SDfpsZVDSFWU6f0Tbzn+gjqJUWh/p5DZLuHpP4dVr1745tmP+ bB6bLHNQJM7EzX+Wr6ebC4CzHYOAROtyvAWbd4H4uyWSz5pkbMUzwm7KBt0bwOKl3JEoUfn9cJt6 jtLBM1erO2HCo7uuZIOvKQ4aH228reNlZ+fTaghVlflshntKWYssPIiefx1ugh2XGQwEs4UyhTYU Y02muGXUKlGRqMZ55XnA0Hbcmwq2Es7jF3jpDwm7axSudq8zOVqTsSRzqWyFG3xoRIyBX/5LzRRk s6kWj1Fb8xEDjdCJfgEv+/2Rco/eVYaTCAsETqasX6E1CYfEGof+/d3YHN+V7O8eq/7lx3Q0PVUh 8veptqr2mYSKItqelHWbT9dCI5B489hLg6rvHMWLL9LSXsGeRR33fr7fAbfUE39ty6NjzhNgIJEy YY4oAveCrJvvcFxGkWyXl2teTtGjvTHCYphTDpTvT01cfQzuyZIsFv+mckexsiPnmE54h6PwM76V vdoTMdwLTXbZVKOJY39ZeqB7Onz1ftvgZ2thLzgL3xf/9RA0KHSTdFXc+KVdoUh6xGLCTonEOn8v s5G7rBOG6rOrQz3HrqJkHjscTqDv0tqooNnBn/wDTrI8dLmC14qfnEhLWPmloq/v4Ux852AcZCTF fLkSx5rEXVVVPKBF/ZEFtlTrI/CFE7193QnQpXBs3o7LUVjc57tD7c2d1ytcRge3MCce0FE28uX2 xcmmhrPeoBBA5K+9szPIXJs4q05NnSJ+WnZRYXJfhhrj0QbxChrl1QrGxH0SaSHfOKGk4TMNSXTI VaPApZKKrT4MPIqcMGb8Gca3ax/BH7vTrcAxpPexQgB+FKU/YUOicQx5CFqhh0FB6tb7K/UhqDXF HIxFWzvGeSObzpF0hU3y9CM6EoE0SnsPLzzvNfH8Akabki7rdskUh0ZgDAUVUg0o9cQjkGbZ8KL+ 57WPlXHv6xU7FFz6O38dMHnrU/CywRybSZyLenSh7Fjs4Gpr4TipmtNqQ59ZYpDm+fCi9sKNaWlp a9Zt3JIhx5ZVUcEn4G3E+7jgcMF634UXvlppMoljUY/Fk+0SUTBd3/WwhgTqMLqXG6KZmfBI/2w9 z9bWzjVy76kzMpw+vt55tkIof7OOCZxdO+o5vLBq3sRdEoHQMXcpl3XcywsvVUlDK6AhXM9kLTza /LnJlmxgHVkCb3SeK1QI5Y0f0cA+piYrHOBf+0wm5aXN5h+UdXyZPW50+YFvGl8JL6grSNxapGCj 7jTnZQoBoCwQuKSSmwzl2U5KUJr4xMiPApV7mArEx72jzqjRNKPoKw5z2Q4PAJLPHIFLYtyuw1t1 rTad1AWOylt4R+OQPcqK913W4twx1KSko2gJl38eXvR2Awu4JCG4Hl74ZMHkvl1RHBbs0hD6xHWX bynfedr3PtRIcbDt+u75tjQvBVVeHwe5pE40XN5J/+MzyVyxWcin9VJ1GCjfmbhVhdKzD1NQmNrA m6afi7IT+ExtkvPnVc87ZHhRc9QLuCRCN7C07oW88PmDFKtJuSQCQeOvvaLOlN0XV/KtffNeqaka rn50+37N8/b2jo721tpHJcWHtiSGuJlTsCis2dzUrDyAXIDtKYGmkAQnWkWvz86VISORR9Vhubrb 6U3YMVGumU/UkGj9PJ6rT2SEn1N/SA6V7U1JXZORBcbMzly/PDbY25FN14aElBYzIi1j27ZtGesW hXi52BgRISZaZJaDq5sMThyqtm1xY1PlTI3pYiSOamKij5NrEIxxcoMqB1HVXoGlDhpJ4CSpPyar coKdLGydXMCYLjPsLc3oZIIsO4D3qns/AKG3+fMABlFr2FpIDI5IkoOIx1CiOsGdMVLjJ1UtTs6F rzYzRq7xSIJNuhqFO/BjxixT4rDe4OV0quHYc3a+CRmNJQyPTMBhUKO6S/+T0VBW6aneVkjDjaC2 JoKiyZDkBSAu3nQY9lykjsdpNfnTd99tDKSP2BpjGPZP1QUX/bTVlab+/SjW30BEkIiHA9VQuinN yp5lYGJnro1CEoydvPh2dCwSgTJddaeu6piXDhJrYOfJ58pySmgyh+fjbknGaHuclEBfOdgEKKMX /LOaPdN3fU88j0UfmROes0z1G1Tn6blmGqyAcb0GOLZU3K2Fgv7lWWvu3ruacLruAkebFfbF47bW ylwXXSTGalftHxVLLAh67tkVLW1V+1x1gJrTdki90fSyuTzR2vVaB/SSqiNMIE3cKtU63ODpOGGQ r6sdh23KtuIlnFIRwX2Z9poEAiEY3BwH/7V2xT7oOle69Ffge0ADX/f1KRhRveIfvXXwfBBLX8cx TGMfDBtJUuJGQBuEloysWXe+PD1ewQMXBZsVF249qH78uK7xxZt+uE17v4sUCAThEKIWZf6nXqFy sKNsEVuT+Kd88iew9Gae45IH0M1hK/BoSLV8sbT8Q/9iOz0ow/Es1iYJ8neoWrzDlCZokjf4br/s x3U+2EMGzsJlqUARpm3fe76yRVECDTRe3S4UCIQFt18qHoRvHxYudtOUhEaa5gGXrFnjO/cQsH/f vqPDR9bAq4M3oKk3N0IZ0M5oq41AplctnPdYKn1f//sLYIFf/OYAe0v+bGjuFVem59SDIftb72fY A0cl0ljWtsMIiM0ufarujqgMSVvp9nBnHU1JRgwX+tLb9vC3Wmjpft9aCnVpuXLgOFjArsv791wC Cmkoc1YRKP52MbheDT0s/nspUH9Ny46Dho3nduWfubApPAESf9VHl/sYQvNGYbSwI+D4pF6qHl8H DT79d5IbEx5yFIHzvT06n8acVMgxW48lLgE+OHQtydf/UyAHRfkLwV4cPJoG1nywvbmpFZi1OQe4 cm9hrJdX4BxXayGoF/0z0pZGUHo9yyW2oKJDbU53dNie6sIYLkMDQQik0eRF370cwfI2aGihUwK4 mnVlu+gzEppAhNu6GmzersytsHTBvcPgoTnNmqxLNdClLgD032yyJmJUzk1Th7mZZY1vxlBi/S03 c8JsDcfgiNBf/Cf0jfftm/bKs2t8HVcBH2xYYWG0CJR2rmPhLLaBZa9dtRP8rUvNBe7V09HS0tr+ sqng6CB0rzTAURm6aGoyYPw0nq72aLfyjDtwq7lXg3IbaLtzKN6DoyGIjwDF3A22X/s3p47krgx1 oFtBu+hWCMXgY6BTxJcifTeBe95QYdwxMZRZ3Q6Wue36l0X/ffTVtvi899AH/8DZud8H0Zk7AOPK dbMM1X5+MbOfmXiioqN3SIWnqP9lxcnF3nYmY1EE8WI4lN9InuPtam1IwjtfAU9FbnhK2D3In2uq gIVE95IjLoLi4rBVwLziZw/r3kmrYnnJUBbm9cOnYuljX4djYPze1mo3DTlMFtd/6cGS2s53olG9 KBH1dT4pObjMn2s2NkUQyoOegqiyh0cjk3BoJH420Ff9O6wwROc8+Z4U3U/3EYIQOrDLI6JEPkRN MDOwWO5nTQLnw8M/qv013tbYjvzQ5fsuVz7r6ul7P/C+r+dVc+Xl/OXhXlzmeBTBvS74j4HBpkWM EW8izWkYGGxMMEJhjIVFr6A9+b7z+ib/GSvB2dO10pK7+s47QFP0pmKdkx5n2Y894EHc/WgLzy6l VSyVdJ9xH+tKyeF6zFm4OutAwdlzX5z4bGdafBDPnm00PkVAa8aagpOfepBHIhRxRtrxE+vddZFI kuW83Zd/e3Drq92L+B5bfwVsHkTSqe4pJ2/e++1awRo/IzxlxtJj31feLyv8NMDEaGbmN3fLDsRY jPPvCeY2jq4efG8/H767C9eaOdErCZbm6OfnSMPKn7h+flzoCa3N8oxauuKTCE8OewmUFBo4yiNh qbYBHyUnxc12NCKgtPSs/WOTkhfOcWIQiQz3qEUxfhzdiX23NB4rJqoBCkc2MNDFolSeUDiKsYWl uRGZwNoD7aHyBKYWEkM0YHI4ZgYkoJeRaCLVjMNh0khaSBROz5hlakAc/yPbXw1wumHQKASaubm+ /fm3q510IQZINCiUU4E9IFFojYfaFABNm5manRHnrD+xT4z/A1P+MbQNCmVuZHN0cmVhbQ0KZW5k b2JqDQo4MCAwIG9iag0KPDwvRnVuY3Rpb25UeXBlIDAvU2l6ZVsgMjU2XSAvRGVjb2RlWyAwIDEg MCAxIDAgMV0gL1JhbmdlWyAwIDEgMCAxIDAgMV0gL0JpdHNQZXJTYW1wbGUgOC9Eb21haW5bIDAg MV0gL0VuY29kZVsgMCAyNTVdIC9PcmRlciAxL0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGggNDU3 Pj4NCnN0cmVhbQ0KeJyFwodS2gAABuDnsrV72zpREVEEkaGAoBDCCjMQ9h5hC4iADK1272Xbx+of 4513rXf97hubNI6dv4ZTfBP/+jR3nEuMz1y8gbPETa6Zf2sOSa6AvC0g7+C8Be/yF6z3zt9fRNsD Id/+cIn7SIQOfLyM1BMxd0LsnFhxPl1F1zOUuCYl7qk19ExLuTMy7yyu+3BO7hPIacEGPa/w44Iy gIuqgFDFCNXMkjoo2gyKtkLLqAmLNeEVbQRXdVGUbMfW9DGpPi41xGWGhGwnsb6bRLkxtWFKKUxp BZFWEhmlOasis2oyp7bkNq35LbQVNPaC1s5qHazOUdRRpW2qpHeW9a6ywV3BHU9111M1emtGX92E 9B6B/oY50CADTZJpWpiWNdiyhvZtobYt3LZj5MAR6VDRDhXrOjHec2Hi0I3JvgdTA2964EsPkc6M 6OzIj7mjAPeYyR8zhedB7kmQPQmxp6HiaRhLLyJYfhnFCr6KYfV1HGv4JoH1t0ncw3cpbOD7NDbx QwZb+DGL+/xPuTb/cx4P+F8K2OF/ZbuXi91vxd7FUu879/Byuf/jr5X+WWXwz+FZdfjzyrXhr9ro P+uj3/WjK/4BqNyYIQ0KZW5kc3RyZWFtDQplbmRvYmoNCjgxIDAgb2JqDQo8PC9QYXR0ZXJuVHlw ZSAyL1NoYWRpbmc8PC9Db2xvclNwYWNlL0RldmljZVJHQi9TaGFkaW5nVHlwZSAyL0Nvb3Jkc1sg MCA0NjggNzIwIDQ2OF0gL0V4dGVuZFsgdHJ1ZSB0cnVlXSAvRnVuY3Rpb24gODAgMCBSPj4+Pg0K ZW5kb2JqDQo4MiAwIG9iag0KPDwvU3VidHlwZS9MaW5rL1JlY3RbIDEzNC4yMyAyNTguMjkgMzY5 Ljk0IDI5MS4xN10gL0JTPDwvVyAwPj4vRiA0L0E8PC9UeXBlL0FjdGlvbi9TL1VSSS9VUkkoaHR0 cDovL3hlbnNlcnZlci5vcmcvKSA+Pi9TdHJ1Y3RQYXJlbnQgMTU+Pg0KZW5kb2JqDQo4MyAwIG9i ag0KPDwvVHlwZS9QYWdlL1BhcmVudCAyIDAgUi9SZXNvdXJjZXM8PC9YT2JqZWN0PDwvSW1hZ2U4 NSA4NSAwIFI+Pi9FeHRHU3RhdGU8PC9HUzI2IDI2IDAgUi9HUzI3IDI3IDAgUi9HUzEzIDEzIDAg Uj4+L1BhdHRlcm48PC9QODggODggMCBSPj4vRm9udDw8L0YzIDMwIDAgUi9GMSAxMSAwIFIvRjIg MTQgMCBSPj4vUHJvY1NldFsvUERGL1RleHQvSW1hZ2VCL0ltYWdlQy9JbWFnZUldID4+L01lZGlh Qm94WyAwIDAgNzIwIDU0MF0gL0NvbnRlbnRzIDg0IDAgUi9Hcm91cDw8L1R5cGUvR3JvdXAvUy9U cmFuc3BhcmVuY3kvQ1MvRGV2aWNlUkdCPj4vVGFicy9TL1N0cnVjdFBhcmVudHMgMTY+Pg0KZW5k b2JqDQo4NCAwIG9iag0KPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0xlbmd0aCA2NDA+Pg0Kc3RyZWFt DQp4nJ1UTWvbQBC9C/Qf5iiFZL3fq4WQgxMnuBCaYkMPoQfVWTsmtuRKMmn+fWcVNZVk2YRetAjm vbfvzc7A6AEuL0f319MboFdXML65hl9hQIESSinjnBownIKSFAoXBt/PIAsDBquPGko1o7JTtDwL g29hAJP7a4CWAPsncNFgldWm0UoEY0NaXBBrAdVAG8KoBWUVoQw40VozWGzDYDTdpiuXKLjJYUiY N8KjuxnXsCobB8wmJOGe1poEBMNTgEgYMerDxwGXOEiJS8nkwM29mqnVRg9pVbkig0WJVEkC5SLz cMkN4TUSRTXVJ9OTjfB4joS3ApB7vvROfDQMNN5FogttCbMw37b1qXeLv0w0v3dh8HhJhRlf/YD5 lzCYIOc7L+vzJhzj4G3ex2hyO4V1CbGKqmcHmXuF2EY/8zy+4FG1zlZQVmn2lBaxiJ4gZgLL0gpi EyGocLtNuvBF8ZA2wTgH9YUmxjT64+nXWQ/9t5wJSaTplreVDmJV/Vi78pYSwVCeMiIb+z44ORRc F4lPlWCWbWQ0y7fOh9T3/oHBlIXtYvKdK9I6Vcy7fCsrt40vRFT6PPNs8wY+eOwEvK6r52PE0lqi ky4xdvFIteIJkb3qkyHqT4XItfYT9h8htpGfDbGDWbq0fpz7ooaW57BZv7hjDN646InWuMW+8Icb 53l1LGkmCE54B3yOQ8Dem/WaFy8QJ9GpZimDC053KY43S1MU7FWfbJbpNAvd6oOh88vEcJBKE6Vq zveFWS+OaPIbn+R667Iq3dTOZvudj2WXFzjljEbLvIC7vcPxLyv8gN8Xx7zifCvRVnr0m6Sf7uiW D95T4QtlXfSB9z82cnOKDQplbmRzdHJlYW0NCmVuZG9iag0KODUgMCBvYmoNCjw8L1R5cGUvWE9i amVjdC9TdWJ0eXBlL0ltYWdlL1dpZHRoIDE2NS9IZWlnaHQgNjcvQ29sb3JTcGFjZS9EZXZpY2VS R0IvQml0c1BlckNvbXBvbmVudCA4L0ludGVycG9sYXRlIGZhbHNlL1NNYXNrIDg2IDAgUi9GaWx0 ZXIvRmxhdGVEZWNvZGUvTGVuZ3RoIDk5MTc+Pg0Kc3RyZWFtDQp4nO1dBVxU2fdfu9decxFExO5u EUQRDDqku7u7u7tmGIahWxpUMDFA7BYwUBFQsQP4f2eejgiDi7vG77/r+ZzP/dy579xz49x74r37 3vz22y/4Bb/gF/wjmDd33sIFi5csXjJ69Oif3Zdf8C2hb9++mzZtsrOzz8jIrK6qfvfu3du37560 vLt353HrE+TfouTevYZDFYeCgoIlJSUnT578s7v8C74aBgwYICQklJ6W/vLlq/fv30Omz5+/uH// weXLV44fO56VmRsTTc7bV3jq1OmrV64+ePDwxYsX7+gAyvdnz543MzP/Jff/FzBw4EB9Pf2mR81t be1v3rxtbn589cr1QxVHsLspFEpISKi7u7utra2ZmZm9vb23t3dkZGQiLTE3N/fYscrr128+fvwU td6/b2t7356aksbJyfmzB/QLeoS9e/fevHGr7X3HmzfvILg7d+5evXr1zJkzx44dKywsTElJiYmJ 8fPzc3JysrGxcXV1DQwMjI2NRXlBQUFFRcXp06ex/aEEoAog8fa2jvfv3oeGhk6YMOFnj+wXfAab N/NUVZ15/7797Zt3z5+9fPz4SUvL4+bm5vv379+8eRNyPMOA0tLSzEz6NoeUkdJotOLi4uPHj58/ f766uvrs2bO3bt1qbGx89uwZNHt7ewcB+Ono6Dh48OCfPcpfQAcLM6u3b9pev37b+vTZ45Ynz589 hw/W3t4OiwzZnT9/Yf/+/QEBAXp6erKysrt27eLj41u/fj0PD8+OHTvExMQUFRVNTEzi4+MPHz5c V1f/9OnTV69etbW1dXSG9o5Tp079+eefP3us/2nAjqNSk5+1vnzy5Nn9+w8fNT56/vw5hPPmzZu7 d+9iw2Ivk8nk4OBgbE9DQ0N5efk9e/Zs3bqVn3/b9u0CO3fulJCQUFNTg7hdXFyCgoJAXFZWBoWA 3f2ZtNs6IP97dxtWr179swf9H4UpU6Yeqjje0tL68EHjrZu10NvYzhD37du3ob0h6PT09OTkZEgw LDTcytJOTlZRUlJaUkISe1xZWRmbGrZeWnqvjIyckqKqi4tHbCwJ6j07O7uoqAjmvqGhgZA1djrd a3/fBmPx6sUbeTmFnz30/xzM4p5dc+ZS48Omutrbly5drq+nK+E7d+5A0IkMgAOWkZERFBiioaED +aqrq2trayOFoOXk5FCCnY59raWlpa+vj90NVa+goGBkaJqUlAKDXlJSgrSyshLmAKEc1PvLFy9f v4baePv6VZudjePPnoD/EEz4Y8LRI6du19+9ePEyTOqVK1ewo6uqqtLS0qKjo+Pi4rBJI8Ij5GTl IFyIdffu3Zs3b4YeXsmA5QxYsWIF8RPlW7ZsAQ2IIXosCU1NzZycnPz8fKRZWVlw5KA3WlpaGhsf NTe3tLa+eNzyUllR/WdPw38ChgwZmp627/r1W9XVNYieYKAhDnhZiJhgfMPCwiIjoqGlsX/hhkGO EOuiRYtmz549ffr0qVOnjh8/vjM3lHBwcHBzcy9cuHDZsmWgR11YeSUlJR0dHcgaK4du0EvLmpqa 4A/U1dU9uP+QoVUebt8m9LMm4b8DVlaO1dXnDuw/mJSUlJubiz2YlZllZmZmZWXl4OBgZGgGf1tI SGjdunULFizg4uKaMmVK75lD7oTQofCh/MXFxWOi6aE6HDnojYsXL548efLo0WNYYFWna4oLKyZM mPj9RvoL+LZsLyo6kJ9f6OnpaWpqamxsDJu7lQGIsNasgZDXQW9v3Lhx7dq1UNRLGbBkyRKkffv2 7U0Tw4YNg9ChE0RFRVVVVVFRRkZGREQESwg/3d3d7e3t7ezsvb19HOyc1FS1lnyEpZ8DSqA3vveE /Ith+PARkeHk8vIKe3uHoNDQK7W1HV8Ddo5f4V+xsbFB6HPnzqVSqV/VCuB6ff21+vq0nJwJE3/t /b8PSgpaRYWlaWnpEDe2MzUx8Xpd7dVbN89duVx9/tzpc2erzp1Fpjteun4NUoCDvXrNmt43x87O fubMGVS8cvNGd55o6zQDkUcHLt+4js5cr68F8aUb12BcBgwY8P2m4l8PkyZO8fUJKSku8/f3hzHV 0NCAUT56/Pj9R48aGhvr7t69Xlt77datG3V1LBH+NF1wN26MHTu2N83x8/M3Nzejyq3bt8G5Czei LaS4eruhAX140NR0v7HxTkNDTU3Ntm3bvvds/OtBZI9MVGRseHiEr69vYGCgq6srLOOsWbNu1tY2 tjQ/ffEc2Pz0SdOTxy2tT4GPn7USSPxEOaFpEVv9ZVvw+gjih81NYA62BEOCFbMVtNj68gXK8fPB o0b47YWFhdAJ338y/uUwbux4C3OHjPRMSNnb2xsbXEtLa82aNRMnTsRWetj06HHr05dv37TR722z QPqdsY6Ot+0fboPr6ur21BD8NKwHguzZyxev378j6jD5MHm+bXv/4s2rViyz58+aW1oQoGEdDh06 9EdOy78V1q/b4unhGxkZ7ezsDHGHhYYhVuLh4Vm2ZDlMJAzlkydP3nd5qNEzvHnzBm5z91YQm1+/ fr33Lllbe/vr168bGxsvX76MaP3HT8u/Evr06aMorx4TQ7a1tXNyckIIbGhoiGhr9+498Jw5OTkR YcXFxT179qyd+czyr+Dq1au///5751YQaoHDV8i6re3FixcNDQ2HDh1atGjRlMlsf06d9rOm6N8E kyZN1dE2iokhOTg4QpkHBARgX2/atGn7NkHMMyz44MGDR44cWV5ejvnvvcQTExMJ/lgtiOJ7L+gO hpMPfQI3jUKhjBs3butWfsEdO3l4tnfpOWwNAnA+Pj4E7GoMQGbt2rVz5sz5YbM3Y8YM5j0BZBBd /rCm/x4sXbzK2Mjczy/A0dERytzNzQ1bG4HYtGnsUL/wtAmLycXFBVUM7dp7ievo6IwfP37//v29 FzSYwxY8evSotrbWyMhozJgx6AlD2/ByzZiLYEFKSioiIuLUqVMg+zIr9DYhIQF9+PJ9v2XLlp3q BMnJyRGsQEjo0x3d0aNH6+nplZWVYU12b/fly5clJSUKCgq9vO/0g0FQQMTGmn4ji9DkmB9sbWlp mUmTJrGxsQ0fPpxJCYMOQbx9+7aXsoNE4GJ9lawxVw8ePKiqqoKGQYsSEhLwFZFHr86dO9d7Vl0A FmHdunUsh6+trd2bjoEMxPPnzyeTyehkbxpFh//XDuPBcO+VUXF2cnNkaHKEYJheiHuHgBA2JhRp F2dYX1//8ePHULZ/e+Z7AhhrGPc7d+7AdccyGzsWjY+DhrSzs2M5vRABqmDt0R+evnyJpYVefVnz REdHDxkypMsMQAP0pnv8/PyIH/9SpXSBmzdvjho16seJ869gxIiRigoavj7084Tu7u4w3JsZMG0a B+w14qZBgwZ1qRIVFdXa2tr19BEraO9ob2v/CzIQvH7zGtjCiLbQB6LFaWzTIOuLFy8SZG/evgEN 0rf0k+z0o1MwK4TOh99+6dKlGzduQC1A7u10kbcTTb9vew9iVESG4HPs2LEuEr916xbRDQLphyw+ 4rv379AiURF6vvvomGy7l6PdDsaaxMT+OHH+FcDj3Suj5ObmAZMNhwqxLWQNpd2vXz/IGlEYMl2q QL0XFBbcbbj3qLmJwObHLZ2xqaW5EcWMDHGVIMPPzvn7Dx/cuXe3tr7uVl3t1WtXL166KCYmBv79 +/dHCiVDbGo0VH/nNijv3W9AlYePGgmEcAsLCwUEBAhzg03Ey8sLoTAbIrrxoPFhw4P7qA4kxOHn 788cy9Q//wQNUYVA5qCARHUUPn76BCkaRWdu370DVuBJjIVZkUBmu+gq6t6933Dt2rUfKM+/AM7p 3HKyKp6eXpA1Im4IHYZSVJQ+7QMHDuzJ2Zg8Zcr+iopzly9Xnz9fc/Hi2UuXuuCZCxdwCUhkkBJk SIkq1efOVVZVHT1xovzIkdKDB5NTU7lnzfqNYVyQLli4ELJuffXqRFXVierq0zU1RC0CzzJSWnLy kI+GhqgFmDN37vkrV4gOfNbouXMnq6tPnTlT39BQdfbspI8vNfBu3fqwuRk0RG+ZyKwOBP0JRlcP HjpUfOAAhUbLyMnBzzPnzxPMCWImMseLilXnzl28ehUO5/eWYy9hFvd8eTkVH29fyNrPzw/mG3tE QUGRuMqcxu6wctWqAxWHyo8cPXTs+OHjld0R5UzsXFh+5BgyBw8fKSrbn1tYlJ2Xb+foNGLECCZn BOzQ6k1Pn5VVHDpw6HDFUTo9UlREeqTyBLD63IXp06ez7GFeYRFaASWzaSJF9f0Vhw6iw8crN2za RBBr6+o2tjzFpc697YKl5RUFJaXpObk7BIWYnsySpcvQty6jY44RrRN45MTJk1VnJv7PPLmbO2fR 3r1KELe/v39QUBACMYSxamq9OjgkLiVddKCioOxAfun+XmJeSVlecSnS3KKS1MzspPRMUQnJLmz1 jIxfdXTkFBSDhl6luHRfUSlSonp+yf7z125m5xf11KuT5y4UlB5Alc4IVjmFxcgUHSgvKT/Ew8tL EHsHBB09XY3yHrtaXJqWsy+KTOGcMYOowlxg1vYOaOhLIy0pAwGa6+4f/iyYM3uR7F4lTw+vYAZg dyPO1dDQ6GV1/7CI1Ny85Ozc3mNSVg4tMzshPTMkmjRv4aIuDCdPnXrwxGnwTMzIBjHSRKyKrByi IvJp+/Iv3KpvbGw8zYBTnwNK7rQ8jU9N746U5NS45FRkUnL2bdhEj/IGDBxITc8EQ7Bl2U+UowOU 1LRNPFu6j11MSvoLYye6nZCRFU6O/2ci+pYwc8Y8GWkFdzePsLCw8PBwHx8f+EgqKqp/WRErNj4+ vvldByU1g5SU2nskJ6eRktLsXDzGsHpUKrlX7kj1+eiEpNjElJiEZKTMikQJMjG0ZHJyelJ2XnpB cXbx/pzSA0iBGYUl1PTsKGpiGDk+Ii6hC4bHUUNi4sJI8WC+ZPkKtMXBOQN8YmgpwO79RCFajKYl +4dHsTRqIlLSmUWlLMdI7yq9empUfKKKVo8PjH4YwAcjhsDBPlNGmu6ZI7xCWIoNDl9XXl7+y9U5 OTnPnDnzpK2DlJweSUmMjE/qJUZRk0nJGUgH9fCKkLmdAyU1CzzD4xK6cqYkRlBoSEPJ1OAYcnBM XCgpHmQRDOIwEjWMTEUmJJYSEkPBpc6IQtAHRsYGRMSEkigzZtJvdfJs5S86UsmiIUZb9PL4JPBU 1zVg2VV1PYO0ghLWw2d0FYimV65hfXvnRwLCKyK8nTRxqpiojLW1LYlEiouLI5PJggwYOnRYT3V3 7Njx5MmT01fqSEkZ0QmpwNjEtF4iKSm9oPxYy/sOZU0dlswjKUmkxHRQxtBYsEVbKA+PowVGknxD I/3CogMiSIGR5IBIsl94NBCZwG4YFEVHUPqGRHoFhYfGJhAuvZqOfl758WhqSve2UMIYVzra4t22 g2VXfYIiEzL29dRPpFEJKWDOUon9YEBsS4Srw4f/Liq8V1dHH4KmUqmpqalCQkK7du3i4eFlWdHB wQGha9nxanJKJjVjH4EJmXkfcV+nws7lnzApp/Du07f3Wt+u3bCpC/PBgwcnZhUQDFlyoGXlJWUX KmpoT2PnYOOYPu1rEbXY2dnYPxxoDIgiZxQd+Lz/nw0E0oxPy2afzuJG6NQ/2ZJzi2hZ+SyHSXQ+ Li3bNyzqW4rtH8Do0aNHjhzZ57c+u4Qk5eWUKHGUxMTEtLQ0WVnZPXv2mJiYd6FH8FhYWAhZZxQc oKRkYyqScwoTM/Mx/8gghaTwEykzT1zqjPRLmfm5pYfpa+ZY1aQpUzs3MWz4cLClpGYTdZncmHzS 8koyi8p3Cot9g+GPGZOSW5ySW0Tw74JEu7SMvChKCsubD5t4tx49ewVkxKC6Vs/MT84pSkjfp6Fr +M+7+k0A4ibeuNywnl9CXCY8PIJGoyUlJWH/CgsLm5l9Ju6lS5ciFr7+4GksLS2KCscmk5KaQ07O jEvJQiYuJRsZIo9CXGX8JArh2eYwET9BgEx2SQUk7hkQNnDgp5u0cCdCYmGOE2MS0ggygu1HzE7d VwoUkZD5jVXEPWfOnCU9A/GAkmvmTIJ42crVuWVHmV3qjMzOx9DSDUytWM6ekob2/sozRA97qJ6N 6us2sXDpfwqMGDGCnZ196NChs7kXSojLurq4QdzJycnY4+Li4tLS0jNnziIolZWVX758mV9+PCAC pjAuJJYaSqLR09iEMHIi8sjQkUQLiqaAhiD7UMigYeIHYnr1hPTCA49edciranbulbK2vldwhG9Y DJiAG9HWh4okGikpq+bGfUsHt+7DgXv55ZvzKXkl4LNxCx9BLyIpU1BxIjiGSvTnM4yFv0cNiqb6 R5D4tguynD1HT38ItKfqKA+MiguKjvtj4qRvKrS/D7DdHBwcbGxs48ZOEBeT19TUTkpKTklJycnJ wdRJSEhoaekMHDgwMjLyeUdHCCnJ2SfExS/MPTDSIyjKPTACqUdwFDOPclwFjaNXoKNXkJN3MH6C 4BMlExnERJpVdqy08tyK1euZvZo2ndPWzdfew9/BM9DRO8jJJ9jZl96um3+4W0AEuKUV0tWCv78/ divoMQR+fv59+/a96+iIomWCgMkc9K7+Ya7+4S5+oegPGGoZWTAfAWibWAZEU1EO/izQJ8TJO8jF N5Rp6DsDjI5PaKyrXxjRve6IcnC2dGSxLH8iTJkyZcGCBcOGDRMUEJeWkkUslsEAT0/PjRs3Lly4 8MSJE6XV1209Ai2cva3d/JCxcQ8AItM5j9TS2cfc0cvM0dPEzt3U3sMM6Ohl7eZPXCXomUhUBNp5 BxefvBQQQ5sw6dMJhIXLVhjauJjYuZnau5s5gI8nEMzNnbzM6Tz9YlMLXnTatshTssscfUIJziAA Wrn6Wbn4Wrr4WDh5mdh7GNu5yWvqj/h4ngqeKi5ZOnt3buIzdPAwd8BYPFhG3DNnz3MJiDJ18DDt qS5Se89d4v9b5+vGjh1LvM23cMEKaSkFSwurzMxMqHRnZ2dePr6bzc1B1H26lq66li761u6Gtl76 Nh4GQFtPOjLy9EJrdx0LFy0zJy1TRzUjW2U9i1nzFq3ZtFXL1EnPyoUgIyiZ+KG6rSfqmrsE5Z24 rmZoM2jwhzuNXFxcM2bNVdA2UTW0Vje20zS11zJ10CTQxEHLzBH9IRgSTIiMnpUbynXMnXUsnLXN nTRNHTVM7MFWzcBGTtNk0bI1nQU3ccqfGJemiT0dmcw7oYaJg7qR3U5xOZbztpZnm46ls8aXqttr GNvNW7ziR0ix1zBq1Ki5c+euXr164sTJ0pLKcnJKISEhurq6Vm5uh+reGrmEKOhZK+jbKBs5KBs7 KBnZI1UxdkRKL2EUKhrYyutZy+la7tUyl9Ew3S2rOX4ifZ/2HzBASFpVTtcKBJ3rMpEoRAapoXNQ bGEV325pVBQXl9y2bRucimHDf1++nk9EQVtCxVBSzVha3URaw0Ra01RG00xW2wK9UjK0I5DeB10r WXRA01RK3URSzUhCxUBMSU9CWZ93p+R07nl9+/XvMvDZC1dIqRmJqxhI9Ij64DN/+VqW88a3S0pC 1fCL1Q32apqNGvvH95bg1wKc8w0bNkClr12zhX+r4OIly30T84OzTu3VcxBTNZXQsJDSspLStJLU tKRntKyRfshrWomrm4NGVMVYWNFgt7zeBgGxIUM/nXQaO2GKiLKRmIqJpIblp1p0Dkz8UIjUwDXC Pjxr1qKVAgICUlJSlpaWGhoay5cvHzBw0DSuuQtWbFq3XWybuIqQjKagjKaQjNYuWZ3dcnq7FfSQ 7tyrs3OvNnFJQEpjNd8u7kUrJ0yZ1n/gQGZnuujk8ZP+nMY1bxrXnJ5xLjv3/KEjRrKcNDauOWwz 6NhTdXauuRzcC76TyP4JjB8/nngDd/SoMdO4l8SUX7cMThVVNxNWMRFVMxfXtPyIVkjFNOiIvJi6 hYiq6R5lY2Flo53y+kLyugtXbeken85dvmGPkpGomhlRkVGXBYppWICndXiWhl3g+MlskpKS1Hgq hULR0dFZsWLldHaufn0/BGuDhwwbOWb8JHYuYraZOGU6N8pHjum6m/ow4EfM4/8fmDZt2vz587eK SGWcf67jGimmbi6uYSGJ3adjI6Vjy0Cbj0j/iUsggBBFVU2FlY13KuhxcM9nyRluMJ+YMhhKaFp9 rG7zOdoyecoaOvmkHMVC2rVHJC4uLikpSUlJSVRYQlBAZO7ceYBx48b15klib0SMiGMYA4Z/BJbH tHrZVnfoQqampraPAc5ubj/9YSgCcCd//7IbrwxcghWNHJVNnVXMXJEqmTgh7YwoUTR2VDC0kzew ldWzltG22COvPXbCl0LLcRMny+rZyBvYoWIXbp3ZEo0auYVTyy8Lyajq6OpqamoqKaoqK2lv3MAH 72LWrFldzoT0NLe9gaysrOZucOfOnby8vE0fTz58Q6AkJp69fPnClSsFJSXfQ9ts3rwZsbOCggLs 8pcpEYsdOnSo9OIDa+8IU5cAY0dfQzu656xv62GAjJ2X4Uc0IMptPPVs3LUtXDTNnIRlVIYOG/5l /oA1m7fqWrsZ2DJc+k4MP2Nr64G8iUtAaGrxvlM3N/ILrVq5WlFRQ0ZaDfMPcU+ePLnLayl/G6Bz Dh89+rCl6WFzU3PrU2DT0ycPWpobGh8SkZ2Xl9c3aYiASZMm3W64V3/3zu3bt01NTb8hZwKgqcAZ 3X78rNXMzOwLlFgMDQ0NB2tueYbFIZB09A2z9w6x9Qyy8wy28wpGvguiEJcQTVu6+m4VEu7bt+up RZbQt18/NQOLnnh+4OxJ5+zgHeoRSq68+iD/yLlZcxds4xfZwsMrJCSE8KHLJ1/+CSD8bGxsfPPu bUtLy4ULFyorK0+ePHnr1q3W1tYXr+iHITEnMBzfqjlYCn5+fj4+PqRf9WGTXgJsMXEO/N27d3C5 eyITkdybnF8WQU0Jjk0IjKL4hcf6hEZ7h0R5h0b79IC45BkU6RoQumzlV7y2D5jKNs0jKMIrNKon zsym0Y3gWFpMUlYImTZ6zFhsbfjnCB++4Wlt+KUdjFceamtrubm5wXn06NFTp0718/NDYXt7+9On T7du3QpKLDMU+vv7E7tSUFAwJydHX1+fyap///5YjSQSCRry4MGDIF64cGGX5sDEiQGKiopdLsFl giYpKys7fPhwTExMT58QhGYzMjLKzs4+ceJEfn6+jY0N80PxWlpaKCGU0uvXr8PDw9FbUVHRztUH DxmiZ2JOSUmPjE8II1GC6c+Co/zCIgn0D+8RAyKiXbx8ODg50TH0/6vMnOAe4S9wBjJbD4qMiYij xqdluvn4YUKwer/tSU5ra+sOxqs9kFFnS4p11dbWhp2CXU+I29zcnJhJaADEhh2Mz7cy30WFbkT5 h7PlH19nwIIxMTHp3BzxlgrYlpSUMAvhFvr6+jI+DNtOpB2MFytUVT87R4TlpK6uTrya1M4AopWz Z88ingLBtWvXOneAeDXD3t6+y5AHDx7MMZ2Tg2M6O/1BMMc0dgZyfER2duLR8KcSBs6YOXPlypUI lGxtbSMjI1NTUw8cONCdOUtAz4mGurPtjugVB+eMhYsXc0yf/g3VOAGlpaX0W68vXmDCf+sUku/Y sYPYI3V1dTC4KIHnRkwmXfm/eYNpR4b4/o+hoSFBjBJoCVhPLBLidSrMPLFaCKDRaCiEpfDx8SFK sDdhPiCaR48e3bx5k/iWIFgRZGxsbMy6mZmZKHz+/Pm9e/fQCpzJpqYmEN+/f19cXBw+NjxM4vu0 qI5L6EZ9fT20UC+nAhygOqCRVq1aNZOLm49XUEhQWEhol5KSMjYFOkylUsvLy6FVEFZAvSCFMoEe O368En0Dzdq1n92JwtrArGLIYWFh0EjwHqWlpSUkJOB4W1la2dnZOTg4wMFgHKjYwrOZb8sWgTlz FmJTz549G5buG9pQAsDwZm1tO0MowsLCzPKJEycWFxfX37lzq66uqIh+zBWe4cUrVx40Nja1tDQ2 NdUxyslkMi5BgTPed2jA/EdFRa1btw4d1tPTq6uvv9PQ8Ki5OTc3l1hFCLuqa2qaHz/GYsDYibbc 3N1R/d6DB9jv2KSIAaEnb9+92/LkyfOXLxF+/sZYhNa2tkQrV69exRTBLq9YsSIkJKSmpoZ4P3Hk yJFSUlK19fVPWlsbHjzw8PCAoDGor/pPECxsdB5LHVpr27btWhqmdjYudrZObm4ekCx8Gwz84cOH WOrXr9+A0cHQsAsKCgoKCwsxY6UMKGPA/v37kaIQqyIlJQVzFR0dnZaWBgJUPH78OJRDVFS0hbmF nq6hnq6xjpYpH68ALy8vjMWMGTO+x3fOly5dWllVdbWuDuIOCAjANEJLQ2QQx/7Dh3MwjLKyVYwP Ci1dvvzY6dOHKisrjh3LLylBIfE0DXo4NSurrKICqKnz2REsfSOjw5WVR06cOHjsGGGAZs2Zc/TU qePV1ZXV1VyMd4GXr1xJtw7V1Wio8+uW1vb2J8+ePVlTY2lri5/TOTnrGhpKy8vRq1WdPnCEPvzZ aftPnDQJzNHPoydPcv3dd43hGmFaoC7glmAzaqgbhQbFhQTHREbGZGZmXb92Hc4M3Y998QI6BHKv ra07deoUdj3WAyF3bATiw6cAQhtgnUAdQQthqUDtYF+gPDQ0zMXFzcXJw8XJ18TYUXDHLhERESx1 RNmEOv3msGEzT2nF0bScvOKKI7UNTe86Oi7erM/IK6SmpMfE0yJIlC38H77zs0dcvLzyVGo2/Qg0 D98n5bxhE8/ZKzeTMnNjKIkjGQ4kM/xfs259VkFx+r6CpPQs4hL/jh2VNedREhZNGsi4jWNiaX3y 7MUjVTWYELh22K3Eke9DJ6tTc/JSs/NVNemvmkrJyFeevZCcmeP8MSpkeZNhCx//6QtXM/OL42jJ Xzhe+JcAB2nRokUCAgLQuvAWZKTlHex8oyISYqLiyaT4stL99XX18HZeM75a+57+bxNthC8BVwE7 BTYFKcRK0LxkADIwQzBYVVVVcXEUP19/H+9AX59QT7cwZSVtcXEJaP6NGzd+P1kDhCWkc0rLQ2Mp QTHkoGhyQFRsYESsX1iUd1C4hp4hW6fv/Kho6sQmpYWS4rUNP3O9tPSNcvZXkJPTlTS1ujAX3CNC SkoLiY2zdv7wpFtT3zghMzeSmqSqyTh+3KePo6dvFDU5KiE5JjEN5RH0M6uJ4WQERyR0A+mqdfSn /w4ePrSsPHJKxjbBnV8YjqqOXmJOfnRCsn63w2ZfC4hNEERg/mVlZQ0MDGBTFORVfLyiSDHJsdHU eAotMwOhwcn6+tuQY0+vABMfr3716hWkf/78eez7mJjYkOCwwICw4MCowACSrra5hISkvLw89jWM IBcX13f9rworZ/fohNRQcoK5g4v4XgUJWQVRKdkt/ALdjzFYObnFJKZHUJI2bP7slKaZnRM4ZBYf 1DT87J7JgAED0ov2h8XRwik03m0CKOnXv797QCglLQd8eLbSlcaAgQO9giOiaWmUtGxFda3dohK7 xCSFJWR2iUhsFRDCatkpIj7i95Fg5RceHZeanZCVt2PXnp7Ggs3u7O1PSsmkpOcI7OyR7KsA848I hZ+fX0VFBUKXk5PT1NAP8ifHxabFkZITqKm0hJSMjOzDh4+eOVNTe6sWlh2KGp4kXMQbN25cunT5 yJEj+XkFZBIlOio2IiI2IjwuMpwaGUYzN3USExMnPqULBQ5lwsnJ+c398M4ABUtKziCnZMYkpS9f zfrhJgHDh4+IoqaQU7PIKVnzFy7ufEnXxBwb82L9w8fPnmFmiEIE74hTqOn7omkpAVGkQYPop+hH jxkLDsm5hZDa7Hn0xwp9+/XzDAxF4eGaS+s/fzOlc7CMKMbdP5iUlPHodceBypNMHQ4X2tPTk3kg Z+iwYaGx1KzigzU37mBX0kuGDv3nn4yAKZ8zZw58dTiEGhoacLCVlZWVlFTMTa2DA6Jp1JyE+MzE hAxaQloCNQXST6RhDWAlJFHjk+LiaGRSAplEI8UkxpFSI8MT7Ww91FS04FJi5cBF37Jly5IlS6DA v8cdpy4wZ/7C8LgUr2Co7sg/GLf6e7rrPnP23ODoeG9QBkeN++MzbbNoyXL3gHDvkOhXHR0wTPD3 YIIRTwXHJngFRzp6+KMVgpKdgzOKmg4+/uFk5qE1JQ1dz8CIQ9VXYddcXV0RaCOcuXTpEqrvFpXs 81FYO3YJewZFBERRoCHh0zo7OyMmgt2MoWUoa+r170//YuTYcX94hUSHxNJeMr4U4RdO0jGx7OWt zr8EWPN58+atWbMG3j4UOwJPyF1NTU1OTt7MxMLJ3jUoIDKBkpFCy0lJyklMoCNWQlJCTmgw2dPN 39rSXl1VU0ZGBksFigJ+IB8fH3YHAq4f9hckvNt3mjq4G1k7K2sZf/lRxUbe7aA0tnFR0jbqfnWP pJyBlaOZvbu1W4C9N/32r6WTt4mdq5axFRvHp0Ppq9ZvDqGkWzr7aJlYEy+tAyZMnIyfhlbOZvae Vq6+1q5+5k5eRjYuRjau23aJMns1bPgIdUNLQxsXc0dPxu3lEDuPIAtnH0tXP7G9SgS330eONrFz Q11jO3czJ0+wEtjzDY5kdwYODg6EaQgAN2zYALnD5urq6kL08OHh1CkqKsoyQFNDE2EmhIstjLWh zgD6A01RUUgZcRZ2NDRG51sKPwA2btu9S0ppp7TK8vWsX5pgwnq+naDcJaO6fB0LykFDhi5euWGn lLKMpomclrmcjoWguOLSNZuHDh/RmWynlIqykb2CntXmHSKdy8dPnLph604xBW0pVUMZdWMxRZ3N AsLsXF2/FjVm/IR1vIKiijp7Ga1IqRtvERSbMefTXfE+ffouX88jLKcpqWogqaq/Q1xh/ITv9Wd8 sLPY7MuWLcN+5+HhgZ7HhoX0sXOh8IlvXkH6kDhEvH37dhgXmAMYaEgZa+anvPLc+4ePfXphAfv2 6z9i1NjR4ycOGzGqy6U/prBvFVexicjao2S8W8n4zxksPvw1eMiwUeMmjBr7x8BBX3oCPnDwkNEM skFDWMdZqD7899GD/0EU9lXAzs7Ozc2NLY8Ni10Pma78CPgJdb148WIsjJkzZ3b5jtNPgd4/Iv8y ZfdLzBLMv5S2pZFHlJSWpZi6iYCkav8BA79cvfdd6g3Zj4fJkyd/v9j5fxzG/THRxMlHz8ZN28JR Qct40q+PPf6rYcy48bvEJAR3i2zk4ftfeP3zF/wX4P8A1crmYQ0KZW5kc3RyZWFtDQplbmRvYmoN Cjg2IDAgb2JqDQo8PC9UeXBlL1hPYmplY3QvU3VidHlwZS9JbWFnZS9XaWR0aCAxNjUvSGVpZ2h0 IDY3L0NvbG9yU3BhY2UvRGV2aWNlR3JheS9NYXR0ZVsgMCAwIDBdIC9CaXRzUGVyQ29tcG9uZW50 IDgvSW50ZXJwb2xhdGUgZmFsc2UvRmlsdGVyL0ZsYXRlRGVjb2RlL0xlbmd0aCAzODE0Pj4NCnN0 cmVhbQ0KeJzFWmlYU1cazkZWIIGQQFgSQtgJyBIggICgsieAClioxQUURVzqgigq26iodRed4tKZ Ch3H0WqdWoFqW2rVtijqAyIgUBQERKyIgECWORcSudlYnqcD7w+e3LPc857vfOc77/kuCMQ4MOdY 2VhZsIzHazc9MDC2dPGdGxIWHiGICA8NmePjyDaiTjcpBegxrDxmhwsgCNdv3vSxEPoVFuDKppOn m5ocFCM7f8BwXs7XD1qlI+hpuHksSSgI8eLQdKeb3jDoVn4RggX774ukSnjx72RhqIe5wfTT1Gfz wwQx53qVGY6gIk0Y7GamR5xejjS7uYKoE13qKQKIf0gSzrahkqaRoq6xS1hkXotGihAGriwMcaBN H0sy0yci+tKYFCE8Sw2bYag9TRx1zf2F8ffH5Qj2epbA3Wh6WOow/YWprQpsJKKh/nc9PX1DQyIJ vFx0KsqdPh0rTjKZKUzvgTPpba/64eLZw/sOFJ4vqfijq18Mq7wa5WowDXuc5i5I7YZRbKsozkoM D/DxdPfw9psbs/b4jfoumDmLIh308FPNkWwTltj+gYK4/fbhxABXOwtTGlRpyraZwY/eeb329SjL 4yEcXdzUciQxAxdUfCDQd//0qmA+l6KjhRxtYuMRnVdW8+Ecer8twsZID4BCJqKnhiSVF/XlB469 T28UnSrIz9+9zZ2Cgk3ExmvFxceD8lZvr5w6tD8/Pz9vwxwSUvOb/zqQ2CEp/WqCzd2Z2vDxrYIO vlZt9CwaPpX/H6juCyrVcJRKzjliPzRCEu1z36i2adjsojMVJImsoCx1HKXS/i1mcodDkb2KBlQa iGvy5prgp2K5KU4x1epJSl/M0x9hgKKH/apaPVSRF2ahMxUbB88I2C4PgT3KNO7OJAKWSKx5crMa Q5dummlCmBKPJFlF/Sgbtf0nZa8Tn7LVQiBJTvlvVTlKytd7GGKnZGsjdLlLZAaUnMwqVta7vWuM MXq+l4bUOcONYAYeicJTDJlsNpOujRmXL4ZIoehRiJjJk9TnH5IN+mxlUNIVZTp/RNvOf6COolRa H+nkNku4ek/h1WvXvjm2Y/5sHpssc1AkzsTNf5avp5sLgLMdg4BE63K8BZt3gfi7JZLPmmRsxTPC bsoG3RvA4qXckShR+f1wm3qO0sEzV6s7YcKju65kg68pDhofbbyt42Vn59NqCFWV+WyGe0pZiyw8 iJ5/HW6CHZcZDASzhTKFNhRjTaa4ZdQqUZGoxnnlecDQdtybCrYSzuMXeOkPCbtrFK52rzM5WpOx JHOpbIUbfGhEjIFf/kvNFGSzqRaPUVvzEQON0Il+AS/7/ZFyj95VhpMICwROpqxfoTUJh8Qah/79 3dgc35Xs7x6r/uXHdDQ9VSHy96m2qvaZhIoi2p6UdZtP10IjkHjz2EuDqu8cxYsv0tJewZ5FHfd+ vt8Bt9QTf23Lo2POE2AgkTJhjigC94Ksm+9wXEaRbJeXa15O0aO9McJimFMOlO9PTVx9DO7JkiwW /6ZyR7GyI+eYTniHo/AzvpW92hMx3AtNdtlUo4ljf1l6oHs6fPV+2+Bna2EvOAvfF//1EDQodJN0 Vdz4pV2hSHrEYsJOicQ6fy+zkbusE4bqs6tDPceuomQeOxxOoO/S2qig2cGf/ANOsjx0uYLXip+c SEtY+aWir+/hTHznYBxkJMV8uRLHmsRdVVU8oEX9kQW2VOsj8IUTvX3dCdClcGzejstRWNznu0Pt zZ3XK1xGB7cwJx7QUTby5fbFyaaGs96gEEDkr72zM8hcmzirTk2dIn5adlFhcl+GGuPRBvEKGuXV CsbEfRJpId84oaThMw1JdMhVo8ClkoqtPgw8ipwwZvwZxrdrH8Efu9OtwDGk97FCAH4UpT9hQ6Jx DHkIWqGHQUHq1vsr9SGoNcUcjEVbO8Z5I5vOkXSFTfL0IzoSgTRKew8vPO818fwCRpuSLut2yRSH RmAMBRVSDSj1xCOQZtnwov7ntY+Vce/rFTsUXPo7fx0weetT8LLBHJtJnIt6dKHsWOzgamvhOKma 02pDn1likOb58KL2wo1paWlr1m3ckiHHllVRwSfgbcT7uOBwwXrfhRe+WmkyiWNRj8WT7RJRMF3f 9bCGBOowupcbopmZ8Ej/bD3P1tbONXLvqTMynD6+3nm2Qih/s44JnF076jm8sGrexF0SgdAxdymX ddzLCy9VSUMroCFcz2QtPNr8ucmWbGAdWQJvdJ4rVAjljR/RwD6mJisc4F/7TCblpc3mH5R1fJk9 bnT5gW8aXwkvqCtI3FqkYKPuNOdlCgGgLBC4pJKbDOXZTkpQmvjEyI8ClXuYCsTHvaPOqNE0o+gr DnPZDg8Aks8cgUti3K7DW3WtNp3UBY7KW3hH45A9yor3Xdbi3DHUpKSjaAmXfx5e9HYDC7gkIbge XvhkweS+XVEcFuzSEPrEdZdvKd952vc+1EhxsO367vm2NC8FVV4fB7mkTjRc3kn/4zPJXLFZyKf1 UnUYKN+ZuFWF0rMPU1CY2sCbpp+LshP4TG2S8+dVzztkeFFz1Au4JEI3sLTuhbzw+YMUq0m5JAJB 46+9os6U3RdX8q19816pqRqufnT7fs3z9vaOjvbW2kclxYe2JIa4mVOwKKzZ3NSsPIBcgO0pgaaQ BCdaRa/PzpUhI5FH1WG5utvpTdgxUa6ZT9SQaP08nqtPZISfU39IDpXtTUldk5EFxszOXL88Ntjb kU3XhoSUFjMiLWPbtm0Z6xaFeLnYGBEhJlpkloOrmwxOHKq2bXFjU+VMjeliJI5qYqKPk2sQjHFy gyoHUdVegaUOGkngJKk/Jqtygp0sbJ1cwJguM+wtzehkgiw7gPeqez8Aobf58wAGUWvYWkgMjkiS g4jHUKI6wZ0xUuMnVS1OzoWvNjNGrvFIgk26GoU78GPGLFPisN7g5XSq4dhzdr4JGY0lDI9MwGFQ o7pL/5PRUFbpqd5WSMONoLYmgqLJkOQFIC7edBj2XKSOx2k1+dN3320MpI/YGmMY9k/VBRf9tNWV pv79KNbfQESQiIcD1VC6Kc3KnmVgYmeujUISjJ28+HZ0LBKBMl11p67qmJcOEmtg58nnynJKaDKH 5+NuScZoe5yUQF852AQooxf8s5o903d9TzyPRR+ZE56zTPUbVOfpuWYarIBxvQY4tlTcrYWC/uVZ a+7eu5pwuu4CR5sV9sXjttbKXBddJMZqV+0fFUssCHru2RUtbVX7XHWAmtN2SL3R9LK5PNHa9VoH 9JKqI0wgTdwq1Trc4Ok4YZCvqx2Hbcq24iWcUhHBfZn2mgQCIRjcHAf/tXbFPug6V7r0V+B7QANf 9/UpGFG94h+9dfB8EEtfxzFMYx8MG0lS4kZAG4SWjKxZd748PV7BAxcFmxUXbj2ofvy4rvHFm364 TXu/ixQIBOEQohZl/qdeoXKwo2wRW5P4p3zyJ7D0Zp7jkgfQzWEr8GhItXyxtPxD/2I7PSjD8SzW Jgnyd6havMOUJmiSN/huv+zHdT7YQwbOwmWpQBGmbd97vrJFUQINNF7dLhQIhAW3XyoehG8fFi52 05SERprmAZesWeM79xCwf9++o8NH1sCrgzegqTc3QhnQzmirjUCmVy2c91gqfV//+wtggV/85gB7 S/5saO4VV6bn1IMh+1vvZ9gDRyXSWNa2wwiIzS59qu6OqAxJW+n2cGcdTUlGDBf60tv28LdaaOl+ 31oKdWm5cuA4WMCuy/v3XAIKaShzVhEo/nYxuF4NPSz+eylQf03LjoOGjed25Z+5sCk8ARJ/1UeX +xhC80ZhtLAj4PikXqoeXwcNPv13khsTHnIUgfO9PTqfxpxUyDFbjyUuAT44dC3J1/9TIAdF+QvB Xhw8mgbWfLC9uakVmLU5B7hyb2Gsl1fgHFdrIagX/TPSlkZQej3LJbagokNtTnd02J7qwhguQwNB CKTR5EXfvRzB8jZoaKFTAriadWW76DMSmkCE27oabN6uzK2wdMG9w+ChOc2arEs10KUuAPTfbLIm YlTOTVOHuZlljW/GUGL9LTdzwmwNx+CI0F/8J/SN9+2b9sqza3wdVwEfbFhhYbQIlHauY+EstoFl r121E/ytS80F7tXT0dLS2v6yqeDoIHSvNMBRGbpoajJg/DServZot/KMO3CruVeDchtou3Mo3oOj IYiPAMXcDbZf+zenjuSuDHWgW0G76FYIxeBjoFPElyJ9N4F73lBh3DExlFndDpa57fqXRf999NW2 +Lz30Af/wNm53wfRmTsA48p1swzVfn4xs5+ZeKKio3dIhaeo/2XFycXediZjUQTxYjiU30ie4+1q bUjCO18BT0VueErYPcifa6qAhUT3kiMuguLisFXAvOJnD+veSatieclQFub1w6di6WNfh2Ng/N7W ajcNOUwW13/pwZLazneiUb0oEfV1Pik5uMyfazY2RRDKg56CqLKHRyOTcGgkfjbQV/07rDBE5zz5 nhTdT/cRghA6sMsjokQ+RE0wM7BY7mdNAufDwz+q/TXe1tiO/NDl+y5XPuvq6Xs/8L6v51Vz5eX8 5eFeXOZ4FMG9LviPgcGmRYwRbyLNaRgYbEwwQmGMhUWvoD35vvP6Jv8ZK8HZ07XSkrv6zjtAU/Sm Yp2THmfZjz3gQdz9aAvPLqVVLJV0n3Ef60rJ4XrMWbg660DB2XNfnPhsZ1p8EM+ebTQ+RUBrxpqC k596kEciFHFG2vET6911kUiS5bzdl397cOur3Yv4Hlt/BWweRNKp7iknb9777VrBGj8jPGXG0mPf V94vK/w0wMRoZuY3d8sOxFiM8+8J5jaOrh58bz8fvrsL15o50SsJlubo5+dIw8qfuH5+XOgJrc3y jFq64pMITw57CZQUGjjKI2GptgEfJSfFzXY0IqC09Kz9Y5OSF85xYhCJDPeoRTF+HN2Jfbc0Hism qgEKRzYw0MWiVJ5QOIqxhaW5EZnA2gPtofIEphYSQzRgcjhmBiSgl5FoItWMw2HSSFpIFE7PmGVq QBz/I9tfDXC6YdAoBJq5ub79+bernXQhBkg0KJRTgT0gUWiNh9oUAE2bmZqdEeesP7FPjP8DU/4x tA0KZW5kc3RyZWFtDQplbmRvYmoNCjg3IDAgb2JqDQo8PC9GdW5jdGlvblR5cGUgMC9TaXplWyAy NTZdIC9EZWNvZGVbIDAgMSAwIDEgMCAxXSAvUmFuZ2VbIDAgMSAwIDEgMCAxXSAvQml0c1BlclNh bXBsZSA4L0RvbWFpblsgMCAxXSAvRW5jb2RlWyAwIDI1NV0gL09yZGVyIDEvRmlsdGVyL0ZsYXRl RGVjb2RlL0xlbmd0aCA0NTc+Pg0Kc3RyZWFtDQp4nIXCh1LaAAAG4OeytXvbOlERUQSRoYCgEMIK MxD2HmELiIAMrXbvZdvH6h/jnXetd/3uG5s0jp2/hlN8E//6NHecS4zPXLyBs8RNrpl/aw5JroC8 LSDv4LwF7/IXrPfO319E2wMh3/5wiftIhA58vIzUEzF3QuycWHE+XUXXM5S4JiXuqTX0TEu5MzLv LK77cE7uE8hpwQY9r/DjgjKAi6qAUMUI1cySOijaDIq2QsuoCYs14RVtBFd1UZRsx9b0Mak+LjXE ZYaEbCexvptEuTG1YUopTGkFkVYSGaU5qyKzajKntuQ2rfkttBU09oLWzmodrM5R1FGlbaqkd5b1 rrLBXcEdT3XXUzV6a0Zf3YT0HoH+hjnQIANNkmlamJY12LKG9m2hti3ctmPkwBHpUNEOFes6Md5z YeLQjcm+B1MDb3rgSw+Rzozo7MiPuaMA95jJHzOF50HuSZA9CbGnoeJpGEsvIlh+GcUKvoph9XUc a/gmgfW3SdzDdyls4Ps0NvFDBlv4MYv7/E+5Nv9zHg/4XwrY4X9lu5eL3W/F3sVS7zv38HK5/+Ov lf5ZZfDP4Vl1+PPKteGv2ug/66Pf9aMr/gGo3JghDQplbmRzdHJlYW0NCmVuZG9iag0KODggMCBv YmoNCjw8L1BhdHRlcm5UeXBlIDIvU2hhZGluZzw8L0NvbG9yU3BhY2UvRGV2aWNlUkdCL1NoYWRp bmdUeXBlIDIvQ29vcmRzWyAwIDQ2OCA3MjAgNDY4XSAvRXh0ZW5kWyB0cnVlIHRydWVdIC9GdW5j dGlvbiA4NyAwIFI+Pj4+DQplbmRvYmoNCjg5IDAgb2JqDQo8PC9UeXBlL1BhZ2UvUGFyZW50IDIg MCBSL1Jlc291cmNlczw8L1hPYmplY3Q8PC9JbWFnZTE4IDE4IDAgUj4+L0V4dEdTdGF0ZTw8L0dT MjYgMjYgMCBSL0dTMjcgMjcgMCBSL0dTMTMgMTMgMCBSPj4vUGF0dGVybjw8L1A5MiA5MiAwIFI+ Pi9Gb250PDwvRjMgMzAgMCBSL0YxIDExIDAgUi9GMiAxNCAwIFI+Pi9Qcm9jU2V0Wy9QREYvVGV4 dC9JbWFnZUIvSW1hZ2VDL0ltYWdlSV0gPj4vQW5ub3RzWyA5MyAwIFJdIC9NZWRpYUJveFsgMCAw IDcyMCA1NDBdIC9Db250ZW50cyA5MCAwIFIvR3JvdXA8PC9UeXBlL0dyb3VwL1MvVHJhbnNwYXJl bmN5L0NTL0RldmljZVJHQj4+L1RhYnMvUy9TdHJ1Y3RQYXJlbnRzIDE3Pj4NCmVuZG9iag0KOTAg MCBvYmoNCjw8L0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGggNTcxPj4NCnN0cmVhbQ0KeJx9U12L 4kAQfA/kP/RjXHCcnu8B8UHdFQ8W9k5hOeQecm6Mwmq8GO/334xGNzHJvWRIpruqulINgzcYDgev k/kU6GgE4+kE/oQBBUoopcgY1aAZBSko5EkYvD/BIQwQ0nsNpQqpqBVtnsLgexjA8+sEoEKAXwT9 sldapUsuwxHbuBgn1oJjA6UJUgvSSkIRGFFKIaz3YTCY7+M0QQPTDNqIWUk8mC2YgvRUToDWEMM8 rNUGOLqTAzdItLzP0cDiDZeYEChalHs2fWEbvMVFkeQHWJ8clGVwWh98u2CasEunI1VU/dc9URKP lw7whYPDXm78JN4aBOW0CDeFsgQtLPdVfuqnda/Iy9dZGKyGlOvx6Bcsv4XBs8O84uIjrmHODlbF XUU/s16fR2foiWgdH/yx2R0+IIaejH5/Zin0+iw6ZqfCXxUZnJLCX52P/ukbeLRbTBZzKOI8TQpX 5Aszd9EmhziHWyVxRbQuJRXb5AJTB7h1IJOEy3rHrKtWMMJtvfbzfHL/r6OBUUnwAbxLCENs1HrH usqlIdJ0Q5chWRydqbecyEpO7jhKEF2F8dFVbquIFQh5+vDhh89HtHUTiyhp0n1lUrVwcXR21LnS W+Zq4hsavErlzWGEcpCUCEBiuldR1zbCcSpijWhshWYgpLql97r5VzXz/THP/vrgfLjI6mh+KJI0 d+mMi10zjfcBjSVaVTFX0fuu2HbVC42Em3r97JIotw35y6IRetY6CQrvVg2lEYV/3PYzEA0KZW5k c3RyZWFtDQplbmRvYmoNCjkxIDAgb2JqDQo8PC9GdW5jdGlvblR5cGUgMC9TaXplWyAyNTZdIC9E ZWNvZGVbIDAgMSAwIDEgMCAxXSAvUmFuZ2VbIDAgMSAwIDEgMCAxXSAvQml0c1BlclNhbXBsZSA4 L0RvbWFpblsgMCAxXSAvRW5jb2RlWyAwIDI1NV0gL09yZGVyIDEvRmlsdGVyL0ZsYXRlRGVjb2Rl L0xlbmd0aCA0NTc+Pg0Kc3RyZWFtDQp4nIXCh1LaAAAG4OeytXvbOlERUQSRoYCgEMIKMxD2HmEL iIAMrXbvZdvH6h/jnXetd/3uG5s0jp2/hlN8E//6NHecS4zPXLyBs8RNrpl/aw5JroC8LSDv4LwF 7/IXrPfO319E2wMh3/5wiftIhA58vIzUEzF3QuycWHE+XUXXM5S4JiXuqTX0TEu5MzLvLK77cE7u E8hpwQY9r/DjgjKAi6qAUMUI1cySOijaDIq2QsuoCYs14RVtBFd1UZRsx9b0Mak+LjXEZYaEbCex vptEuTG1YUopTGkFkVYSGaU5qyKzajKntuQ2rfkttBU09oLWzmodrM5R1FGlbaqkd5b1rrLBXcEd T3XXUzV6a0Zf3YT0HoH+hjnQIANNkmlamJY12LKG9m2hti3ctmPkwBHpUNEOFes6Md5zYeLQjcm+ B1MDb3rgSw+Rzozo7MiPuaMA95jJHzOF50HuSZA9CbGnoeJpGEsvIlh+GcUKvoph9XUca/gmgfW3 SdzDdyls4Ps0NvFDBlv4MYv7/E+5Nv9zHg/4XwrY4X9lu5eL3W/F3sVS7zv38HK5/+Ovlf5ZZfDP 4Vl1+PPKteGv2ug/66Pf9aMr/gGo3JghDQplbmRzdHJlYW0NCmVuZG9iag0KOTIgMCBvYmoNCjw8 L1BhdHRlcm5UeXBlIDIvU2hhZGluZzw8L0NvbG9yU3BhY2UvRGV2aWNlUkdCL1NoYWRpbmdUeXBl IDIvQ29vcmRzWyAwIDQ2OCA3MjAgNDY4XSAvRXh0ZW5kWyB0cnVlIHRydWVdIC9GdW5jdGlvbiA5 MSAwIFI+Pj4+DQplbmRvYmoNCjkzIDAgb2JqDQo8PC9TdWJ0eXBlL0xpbmsvUmVjdFsgMjY0Ljcg MzI5LjU3IDMxNS4xIDM2Mi40N10gL0JTPDwvVyAwPj4vRiA0L0E8PC9UeXBlL0FjdGlvbi9TL1VS SS9VUkkoaHR0cDovL3d3dy5nbHVzdGVyLm9yZy8yMDEzLzExL2EtZ2x1c3Rlci1ibG9jay1pbnRl cmZhY2UtcGVyZm9ybWFuY2UtYW5kLWNvbmZpZ3VyYXRpb24vKSA+Pi9TdHJ1Y3RQYXJlbnQgMTg+ Pg0KZW5kb2JqDQo5NCAwIG9iag0KPDwvVHlwZS9QYWdlL1BhcmVudCAyIDAgUi9SZXNvdXJjZXM8 PC9YT2JqZWN0PDwvSW1hZ2U3MiA3MiAwIFI+Pi9FeHRHU3RhdGU8PC9HUzI2IDI2IDAgUi9HUzI3 IDI3IDAgUi9HUzEzIDEzIDAgUj4+L1BhdHRlcm48PC9QOTcgOTcgMCBSPj4vRm9udDw8L0YzIDMw IDAgUi9GMSAxMSAwIFIvRjIgMTQgMCBSPj4vUHJvY1NldFsvUERGL1RleHQvSW1hZ2VCL0ltYWdl Qy9JbWFnZUldID4+L01lZGlhQm94WyAwIDAgNzIwIDU0MF0gL0NvbnRlbnRzIDk1IDAgUi9Hcm91 cDw8L1R5cGUvR3JvdXAvUy9UcmFuc3BhcmVuY3kvQ1MvRGV2aWNlUkdCPj4vVGFicy9TL1N0cnVj dFBhcmVudHMgMTk+Pg0KZW5kb2JqDQo5NSAwIG9iag0KPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0xl bmd0aCA5NTM+Pg0Kc3RyZWFtDQp4nJ1WTW/jNhC9G/B/mKO0gGl+iRSLIMAm2V2k2ABuE2wL7PYg 2bQjxJZcSc42/75DWU4ly3SDXGTJmHmP781wSJjO4OJiend9ewP08hKubq7h7/GIAiWUUsY51aA5 hUhSKO149McHyMcjBqvXGEoVo7IXtPwwHv02HsGnu2uADgH7j2DS5kZG6ZYrFoyd4uKCGAPIBkoT Rg1EJiKUASdKKQbzzXg0vd0kK6s53BRwipi3xNMv91zBqmoVMBOTmDtYo2MQDH8FiJgRHb3qGGCJ gUtcSiZPrNyx6YZtOkvq2pY5zCuEMhqqee7SJdeEN5lIqqg6655sia8eEPCzAMR+WDolzhoGCtci UYUyhBl42HT5qVOLn0y0n1/Go+8XVOiry7/g4dfx6BNi7nHZMW7M0Q7exf0efIR8t0ltCaEOimU4 EQHk9qf7Wtqk3pW2gpDR4DF5tu7P1NocwijINuGEB9u13di8totfwj75q5KIkkj2GaETO3AmGjhD sCgn3RGU8BbTr3+QffCgkx0oCaEK0qwGjwwWYU1FP+lPm/uijSDofC/ai2zMILZAh2Xw8fc79BnC iQzy4idUoQh22y0+i7LGJ5bFBGlR1Fm+cgVZ7WxVY1rlqwSjRCr/ogaVUG/qUW4Ykez/qnCqAt3M YPb4UmXzZA0LlJZVT7BNGpVZnRV55aqT5AvnytdvrkXv4Llw/bfebbA/50nuIpxLHvEHysi4abOn TK2zbVfZhfutC4de1UVpHVbjpnvZ9zlOpAp2zvXG7dMkUhsSx32Sf7xNEjHcEkdLmvhisY/l0erX T2kyfzpT7PgI3LdsxdQg9gc22XH8+f3EuSJR3KZnFcy+waLMnm3pXIXUumLi2Gw6Og6yHPYfmwra oYNx7V9ZXqyd6cXq5Ufoc0QJgnO+x3q2m/WbupnFmuj3NHMnMbjPVnm2zJwE7Mymi6o6SbN1Vr9A ttmWxXMzNSvnRDIvi6p5qx+bzkuLpFz4SiVRdY/rrOb4bZplc3K+R3Qn042rqW/GSUWk7odvdus6 S5tNXNSePB5FbmT18nxdzBVzndCLxeno8A8TEo2vi3mBM8Y2O3mVAw6VUHgxDzJxg8hDZ3ePvcQN J+/aDRG91LOlMm8qldYkelelOonB7P761nsaCUWE6YVXeOi4E8cjk3PirpWdhLM6Ge0JZXgzICYe nu94/5OROtwZ9je85qYT3O43EI4LnNsT3RyT0t8WeL8UPSzcn7ttU8ShqulnfmpBkiGI7IMMVP4L dQR2WQ0KZW5kc3RyZWFtDQplbmRvYmoNCjk2IDAgb2JqDQo8PC9GdW5jdGlvblR5cGUgMC9TaXpl WyAyNTZdIC9EZWNvZGVbIDAgMSAwIDEgMCAxXSAvUmFuZ2VbIDAgMSAwIDEgMCAxXSAvQml0c1Bl clNhbXBsZSA4L0RvbWFpblsgMCAxXSAvRW5jb2RlWyAwIDI1NV0gL09yZGVyIDEvRmlsdGVyL0Zs YXRlRGVjb2RlL0xlbmd0aCA0NTc+Pg0Kc3RyZWFtDQp4nIXCh1LaAAAG4OeytXvbOlERUQSRoYCg EMIKMxD2HmELiIAMrXbvZdvH6h/jnXetd/3uG5s0jp2/hlN8E//6NHecS4zPXLyBs8RNrpl/aw5J roC8LSDv4LwF7/IXrPfO319E2wMh3/5wiftIhA58vIzUEzF3QuycWHE+XUXXM5S4JiXuqTX0TEu5 MzLvLK77cE7uE8hpwQY9r/DjgjKAi6qAUMUI1cySOijaDIq2QsuoCYs14RVtBFd1UZRsx9b0Mak+ LjXEZYaEbCexvptEuTG1YUopTGkFkVYSGaU5qyKzajKntuQ2rfkttBU09oLWzmodrM5R1FGlbaqk d5b1rrLBXcEdT3XXUzV6a0Zf3YT0HoH+hjnQIANNkmlamJY12LKG9m2hti3ctmPkwBHpUNEOFes6 Md5zYeLQjcm+B1MDb3rgSw+Rzozo7MiPuaMA95jJHzOF50HuSZA9CbGnoeJpGEsvIlh+GcUKvoph 9XUca/gmgfW3SdzDdyls4Ps0NvFDBlv4MYv7/E+5Nv9zHg/4XwrY4X9lu5eL3W/F3sVS7zv38HK5 /+Ovlf5ZZfDP4Vl1+PPKteGv2ug/66Pf9aMr/gGo3JghDQplbmRzdHJlYW0NCmVuZG9iag0KOTcg MCBvYmoNCjw8L1BhdHRlcm5UeXBlIDIvU2hhZGluZzw8L0NvbG9yU3BhY2UvRGV2aWNlUkdCL1No YWRpbmdUeXBlIDIvQ29vcmRzWyAwIDQ2OCA3MjAgNDY4XSAvRXh0ZW5kWyB0cnVlIHRydWVdIC9G dW5jdGlvbiA5NiAwIFI+Pj4+DQplbmRvYmoNCjk4IDAgb2JqDQo8PC9UeXBlL1BhZ2UvUGFyZW50 IDIgMCBSL1Jlc291cmNlczw8L0V4dEdTdGF0ZTw8L0dTMjcgMjcgMCBSL0dTMjYgMjYgMCBSL0dT MTMgMTMgMCBSPj4vWE9iamVjdDw8L0ltYWdlNzggNzggMCBSPj4vUGF0dGVybjw8L1AxMDEgMTAx IDAgUj4+L0ZvbnQ8PC9GMyAzMCAwIFIvRjEgMTEgMCBSL0YyIDE0IDAgUj4+L1Byb2NTZXRbL1BE Ri9UZXh0L0ltYWdlQi9JbWFnZUMvSW1hZ2VJXSA+Pi9NZWRpYUJveFsgMCAwIDcyMCA1NDBdIC9D b250ZW50cyA5OSAwIFIvR3JvdXA8PC9UeXBlL0dyb3VwL1MvVHJhbnNwYXJlbmN5L0NTL0Rldmlj ZVJHQj4+L1RhYnMvUy9TdHJ1Y3RQYXJlbnRzIDIwPj4NCmVuZG9iag0KOTkgMCBvYmoNCjw8L0Zp bHRlci9GbGF0ZURlY29kZS9MZW5ndGggODA0Pj4NCnN0cmVhbQ0KeJyVVU1v2kAQvSPxH+a4VGXZ L+/aUhSphLaiEmraUPWQ9rAxBlbFdoqXRP33nTXQ4hin6QnWnnlv3ryZNYyu4eJiNLuaToBdXsJ4 cgU/+z0GjDLGuBDMgBEMIsVgm/V7X19B0e+N3t8IA6uq3+Ow+hPNmOZMNcKXr/q9T/0evJ1dAZxQ 8b9Uw0NulGhzYI0l52dYuZA0SQDZQBvKWQJRElHGQVCtNYc0x8qmuV1lJoZJCeeIxYE4KNB/FfAk prEIsAnmSo6/EmTMqYn+6GhhyVa/hFJcPduv0bX1PtsWkFYIxbH4Ki1CvhKGijoVWTXTz7ZPHZjH c0R8JwHB58sgJfSGg8ZiFMrQCeUJzPPTAliQi0cuD8f3/d7tBZNmfPkd5h/6vbeIucflT3Fjgf0Q p7i35MbmGQyaqcd4rjCQN+MnszcDRWAwTIgrYCDJpMwZHjXJHjJ8EJNH59dQlLC2W3y9eLTbFsG+ Nor9Pluf1NSYA9/042z2ZRCRCjkU+UaK0sPAkGq3xTIQOCKPa4uPOCN+nYXSXH6/cYOhIKn1riyq +l25hPDIrx2eNcGavg06VOtIURk3qzgV0HIzepGbIjE0PnTx//w6zSRvPs/ABinFIojHo8Yuqy4L hdFUqicQY8yYVl0pUiQ01s2U2sOILLJ0g3+RmXNSeXu3yYLjNtRyHuwoQUdUHcFyi/ZIUnjrihqL kWUZnmyDNXc2/YEzswi+RSQt8/tarnd3buP8rw6eiMeU6ybPs6bplmmtcTwaJzSN4n8Z1zXMp9nk xq0Kt3SpLXyQuqvsXlToLY7ttnzI8qzw1et6xWKc8nSNXgEebcuv7oHhiaL8yGl3vsxtaK93ad3s NOxlVi9HWKVyGV7CapdVfm/yg0uzsNq+3rEMmZMXeMw1XrdHVpcH02pFi1D+GvM3rlgBLmKQVAau jvkzhuoncJP5uOoIVxI/H83oZ403DePD7UaTuG28EaAifbz39h+Z+q4l071RKAqVDU1YwdqujgXE T5xsYOEYdCnngkrdjN3d35db7NUwwstPtC6t0TtxToHCPWBPWFtd+Q1BPMnSDQplbmRzdHJlYW0N CmVuZG9iag0KMTAwIDAgb2JqDQo8PC9GdW5jdGlvblR5cGUgMC9TaXplWyAyNTZdIC9EZWNvZGVb IDAgMSAwIDEgMCAxXSAvUmFuZ2VbIDAgMSAwIDEgMCAxXSAvQml0c1BlclNhbXBsZSA4L0RvbWFp blsgMCAxXSAvRW5jb2RlWyAwIDI1NV0gL09yZGVyIDEvRmlsdGVyL0ZsYXRlRGVjb2RlL0xlbmd0 aCA0NTc+Pg0Kc3RyZWFtDQp4nIXCh1LaAAAG4OeytXvbOlERUQSRoYCgEMIKMxD2HmELiIAMrXbv ZdvH6h/jnXetd/3uG5s0jp2/hlN8E//6NHecS4zPXLyBs8RNrpl/aw5JroC8LSDv4LwF7/IXrPfO 319E2wMh3/5wiftIhA58vIzUEzF3QuycWHE+XUXXM5S4JiXuqTX0TEu5MzLvLK77cE7uE8hpwQY9 r/DjgjKAi6qAUMUI1cySOijaDIq2QsuoCYs14RVtBFd1UZRsx9b0Mak+LjXEZYaEbCexvptEuTG1 YUopTGkFkVYSGaU5qyKzajKntuQ2rfkttBU09oLWzmodrM5R1FGlbaqkd5b1rrLBXcEdT3XXUzV6 a0Zf3YT0HoH+hjnQIANNkmlamJY12LKG9m2hti3ctmPkwBHpUNEOFes6Md5zYeLQjcm+B1MDb3rg Sw+Rzozo7MiPuaMA95jJHzOF50HuSZA9CbGnoeJpGEsvIlh+GcUKvoph9XUca/gmgfW3SdzDdyls 4Ps0NvFDBlv4MYv7/E+5Nv9zHg/4XwrY4X9lu5eL3W/F3sVS7zv38HK5/+Ovlf5ZZfDP4Vl1+PPK teGv2ug/66Pf9aMr/gGo3JghDQplbmRzdHJlYW0NCmVuZG9iag0KMTAxIDAgb2JqDQo8PC9QYXR0 ZXJuVHlwZSAyL1NoYWRpbmc8PC9Db2xvclNwYWNlL0RldmljZVJHQi9TaGFkaW5nVHlwZSAyL0Nv b3Jkc1sgMCA0NjggNzIwIDQ2OF0gL0V4dGVuZFsgdHJ1ZSB0cnVlXSAvRnVuY3Rpb24gMTAwIDAg Uj4+Pj4NCmVuZG9iag0KMTAyIDAgb2JqDQo8PC9UeXBlL1BhZ2UvUGFyZW50IDIgMCBSL1Jlc291 cmNlczw8L1hPYmplY3Q8PC9JbWFnZTI0IDI0IDAgUj4+L0V4dEdTdGF0ZTw8L0dTMjYgMjYgMCBS L0dTMjcgMjcgMCBSL0dTMTMgMTMgMCBSPj4vUGF0dGVybjw8L1AxMDUgMTA1IDAgUj4+L0ZvbnQ8 PC9GMyAzMCAwIFIvRjEgMTEgMCBSL0YyIDE0IDAgUj4+L1Byb2NTZXRbL1BERi9UZXh0L0ltYWdl Qi9JbWFnZUMvSW1hZ2VJXSA+Pi9NZWRpYUJveFsgMCAwIDcyMCA1NDBdIC9Db250ZW50cyAxMDMg MCBSL0dyb3VwPDwvVHlwZS9Hcm91cC9TL1RyYW5zcGFyZW5jeS9DUy9EZXZpY2VSR0I+Pi9UYWJz L1MvU3RydWN0UGFyZW50cyAyMT4+DQplbmRvYmoNCjEwMyAwIG9iag0KPDwvRmlsdGVyL0ZsYXRl RGVjb2RlL0xlbmd0aCAxMDY3Pj4NCnN0cmVhbQ0KeJydV9tu4zYQfTfgf+CjtFjTvIsEggCOk6ZZ wNi0NtAFkj4oFp1VY0uupCTdv+9QllNdzDTtky155szMmTlDGk1v0dnZdDG/uUTk/BxdXM7Rn+MR QQQTQihjJEIRI0gKggo7Hv32CWXjEUWPbzaEKEpEx2jzaTz6ZTxCV4s5Qq0A9J8Ak8ZXGhU1sTSn 9FQsxrExCKIhFWFKDJJGYkIRw0opita78Wh6s4sfLRPoMkenArMm8PR6yRR6LJsKqNFYMwdrIo04 hU+OuKY4km91DLD4gCUmBBUnMnfRojra9DauKltkaF0CFCUSlevM+QsWYVa7QlRF1Lv0iSbyxQoQ f+IIwFcbV4rjhiIFyQgoQxlMDVrt2gkQVy48Ut48Xo9Hd2eERxfnv6PVl/HoCjAPuLSPqxnwwdq4 d8EsSdLsEWX2FYUm+B4XyWtcWBRSGuy3cbXJwwkLil3pfq1yFHaDHJFFxDDRXeRvNvNYS8px1MvD hyypGdjeFqEI8j/sukJ51nc81I2hlydr5wpH0bH2XxehhMgTAYXXFT5YSJrDKxG8xGW1/eG+pbt9 kb/Y5DMKVbCLnxxfaYVsXKbWZYJCHWzy4nQiJ5MgAvNjEj+3KX+xWZIXdSpxlrjgdvdgk8Qm7lXr V2jFPi8qH2tNIBZREEQTyN89Shmmsmf93aaH4jw+EcG85/OQQy0ee8Yl5l3zNvRAInIgkUFLG5kw zjHorcb0C8E3EG1vJwZHeeIaXT7v9zAKQHI9ECdb/FacNth0oYC/d9jjnGHZi+3YzpJ4a30aoxoL 0XXy6pGJgW3dnc/vJCVJLeKO0zze/mWT2Oeho37dXnADmu+BX82/eawVTIvoNWfyYX0xQuBEadzg gYC2SHAfxE+xk9QiBcH9uA9BzzyY7ffb1HVcwvt1kSNfSiIyMG5d7H5Kb7bAC+/lcW0z65S7rPIC 4u4g+kQGqxu3X/9FxlRpzI44XxezW/CX9dqql4RnJhkI1HR9Z9vtaxpOeJBlsLk8o8kkprrr5x9j OrCdMTKdcVKLxsMOdBWGs+NVD2fpHUyNDfOnNFge6sPLgzKD+f9eHm3v9mlS1ufCiy3cIllv47Js Dldg5bjsFQykj1bQilFd9PeF6IYz6nl46dcSK9G1PUrCyaA+Cj8qNaNcpk0P4fCslZZmlas0T57X h4MrzRDsQ/8UQSaiA+W/O3BNsNEdYy+uVlh3TVs3By+TpO/0dblc2bLyDacE6j+UT0OZElgeTePn Kt/FTpGVY4pK+CzdgePuGD5hG+roasNsinhnX90myYsn7/HBcDf4f7s5wVpQJ10H6os66oM+ADd6 qD641Qmpjre6wzW+vs0GN4cLF7QKOJlEtbLcsQU0LX29hupgmluAdwEc4PUVCdbsfcDvw0G57FRq QsF/EtZFGpT7N5wp0XwNCmVuZHN0cmVhbQ0KZW5kb2JqDQoxMDQgMCBvYmoNCjw8L0Z1bmN0aW9u VHlwZSAwL1NpemVbIDI1Nl0gL0RlY29kZVsgMCAxIDAgMSAwIDFdIC9SYW5nZVsgMCAxIDAgMSAw IDFdIC9CaXRzUGVyU2FtcGxlIDgvRG9tYWluWyAwIDFdIC9FbmNvZGVbIDAgMjU1XSAvT3JkZXIg MS9GaWx0ZXIvRmxhdGVEZWNvZGUvTGVuZ3RoIDQ1Nz4+DQpzdHJlYW0NCnichcKHUtoAAAbg57K1 e9s6URFRBJGhgKAQwgozEPYeYQuIgAytdu9l28fqH+Odd613/e4bmzSOnb+GU3wT//o0d5xLjM9c vIGzxE2umX9rDkmugLwtIO/gvAXv8hes987fX0TbAyHf/nCJ+0iEDny8jNQTMXdC7JxYcT5dRdcz lLgmJe6pNfRMS7kzMu8srvtwTu4TyGnBBj2v8OOCMoCLqoBQxQjVzJI6KNoMirZCy6gJizXhFW0E V3VRlGzH1vQxqT4uNcRlhoRsJ7G+m0S5MbVhSilMaQWRVhIZpTmrIrNqMqe25Dat+S20FTT2gtbO ah2szlHUUaVtqqR3lvWussFdwR1PdddTNXprRl/dhPQegf6GOdAgA02SaVqYljXYsob2baG2Ldy2 Y+TAEelQ0Q4V6zox3nNh4tCNyb4HUwNveuBLD5HOjOjsyI+5owD3mMkfM4XnQe5JkD0Jsaeh4mkY Sy8iWH4ZxQq+imH1dRxr+CaB9bdJ3MN3KWzg+zQ28UMGW/gxi/v8T7k2/3MeD/hfCtjhf2W7l4vd b8XexVLvO/fwcrn/46+V/lll8M/hWXX488q14a/a6D/ro9/1oyv+AajcmCENCmVuZHN0cmVhbQ0K ZW5kb2JqDQoxMDUgMCBvYmoNCjw8L1BhdHRlcm5UeXBlIDIvU2hhZGluZzw8L0NvbG9yU3BhY2Uv RGV2aWNlUkdCL1NoYWRpbmdUeXBlIDIvQ29vcmRzWyAwIDQ2OCA3MjAgNDY4XSAvRXh0ZW5kWyB0 cnVlIHRydWVdIC9GdW5jdGlvbiAxMDQgMCBSPj4+Pg0KZW5kb2JqDQoxMDYgMCBvYmoNCjw8L1R5 cGUvUGFnZS9QYXJlbnQgMiAwIFIvUmVzb3VyY2VzPDwvRXh0R1N0YXRlPDwvR1MyNyAyNyAwIFIv R1MyNiAyNiAwIFIvR1MxMyAxMyAwIFI+Pi9YT2JqZWN0PDwvSW1hZ2U3OCA3OCAwIFI+Pi9QYXR0 ZXJuPDwvUDEwOSAxMDkgMCBSPj4vRm9udDw8L0YzIDMwIDAgUi9GMSAxMSAwIFIvRjQgMTEwIDAg Ui9GMiAxNCAwIFI+Pi9Qcm9jU2V0Wy9QREYvVGV4dC9JbWFnZUIvSW1hZ2VDL0ltYWdlSV0gPj4v QW5ub3RzWyAxMTIgMCBSIDExMyAwIFIgMTE0IDAgUiAxMTUgMCBSIDExNiAwIFJdIC9NZWRpYUJv eFsgMCAwIDcyMCA1NDBdIC9Db250ZW50cyAxMDcgMCBSL0dyb3VwPDwvVHlwZS9Hcm91cC9TL1Ry YW5zcGFyZW5jeS9DUy9EZXZpY2VSR0I+Pi9UYWJzL1MvU3RydWN0UGFyZW50cyAyMj4+DQplbmRv YmoNCjEwNyAwIG9iag0KPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0xlbmd0aCAxMzc0Pj4NCnN0cmVh bQ0KeJydWEtv20YQvgvQf9gjFVSrfZMMXB9sJ0GCGnAbAS1g90CJtMSaD5Wk3frfd5YPiUtyZTcX SxrMY+ebmW92jVZ36OJidXv99QaRy0t0dXON/p7PCCKYEEIZIy5yGUFSEFRE89nvH1A2n62+fGcu 2pXzGUW7ozYhihJhqD9+mM9+nc/Qp9trhHqh6CnUsrWVvnLbqB6ndCIqZRz7PoJoSLmYEh9JX2JC EcNKKYq2KZzsaxrsItdDNzmaCszawDoDdcqA+h72mHbrgy2n8MkR9yh25TGPkS8+wosJQcVZvFZ3 QVVFRYa2JbjSOZTbTNsL5mJWm0JURdRZ+EQb+WoNHj9zBM7XjzoVjQ1FCg4jIA3lY+qjddo/ANHp wk/K259f5rP7C8Ldq8s/0frbfPYJfDZ+6dCvxwAP1vd776z3EdovuPN6iIqXuMwLtPCdbZChhXCe D2FQRWhBqVOB2kI5abwt8m0eRijOUC2bCooByMnAXGHXbQNHQZG8ap+HfVA2QfJHtMnzaui088IJ wdIzvVRxGtnUJcGeMtX7rkdVkcOqmEn4BHMKSRCKRYuexl1M4W5aQptgKEXfssbdcnAqKSbcVAfg F0vutOAvKHE2cRYUr1qoQdwk+QbVKrp00tlEKFosmRNDkQr9RSsFJQqsQZszMheGsQtaVkEWBkme WY/KYKQJN63S56SKdR1tdaE+hiE1bKwlZ0AQytQ9BK86oSQPwp/QwnWgZQ9BUaEcuvixbso4i6s4 SN5KVXDsdU6fGpSyKNGN/+CEeUoeFvr7G86A6rDvmc6KINWVCOPyyWbl+RgGwrCyRvAFVoMID45F WZCBV338IrRpywnXC5uyOnPg0TCpdw0Tg1LwH5mlkyFaNmy53sJQ5daac79u1JMZqS2q4Ck6jkf4 EmQVrB+U6z6Ky5oDgZsSYEGtVFa6316ioozz7I3uoh6Q1eiA+aPNitWc3LNqzjcmWDFChAss+6b3 TlgEugG3z8MZnALUh2UpDXPrtBOOuan6DxCMTVsA8Z71O5EMkwzTIXhaB7BYLm2RFEQSY/CiQFcN 1ox1dqURDEJYeYhhwQzVbhVqoIcraAJmAUzpsnfBLKAXuDJUgeDqXGDZQbiqo3TYmcDQKJ/cxcOG hK3SrcE/6nbObAZQOF3mnsG5VeWaqneFJuK/6gjbSo/QNk/TZjOFdp4HPjTcJDFsnfIQ1Tstfnz9 aANLCOyrs4edaDMBdwMQ9a2e9Wa1BJEErpeG9s9lnV8wxHCi8lIJfQ/pW2NbHJcMVc+SrPsukqVw HYaPH2DZvqXzWd8N7R2jKaivHkZV3bJxUqISOiKygcuEj31hGr+LKSTmA7P/w3ucetg9H/XUnULz RF81rXPLDrAtbI1JoexvpDWA2/Mw71RhWKxgS/2M6itPNMn3A1wEuz7xen3SH13ed6PfQHDJIlAM iordQPCbfmc4+6o6fFyt/q1pKNvEVYmhtO1PnMOwF7tVqAlgW66eM7hAbpJolcZlPcZgZ+McRZnu /H5SfS4ena0+PSAm4enoI9BnysNSdoJkPuPw1eU9gSQM+7QnUAx2iz8hEPXjtGdyFHROj4Iu7FHQ Hewo2DfPwIlyy/oOOAn9fZ80rdvY1VeGkxf7+mLQi5Iaqppf8b5Kk3P84k/0jX6WSGEcfte9Q41G HNdMpy2BD6HSTc2I1Fi1Ag1v8+QZC0Cvxbs1OQo6p0fB3vLap8QgS0hEwcVdjB7esKQFHKB9IDf/ XWiS+6RfrNDidhasLwk963vnFm4JYAIXBfgbWne0pmnD7hcrFbkY7pKGLjyE4mw3Yjw2laGoF61h PiKP/wCgnsuHDQplbmRzdHJlYW0NCmVuZG9iag0KMTA4IDAgb2JqDQo8PC9GdW5jdGlvblR5cGUg MC9TaXplWyAyNTZdIC9EZWNvZGVbIDAgMSAwIDEgMCAxXSAvUmFuZ2VbIDAgMSAwIDEgMCAxXSAv Qml0c1BlclNhbXBsZSA4L0RvbWFpblsgMCAxXSAvRW5jb2RlWyAwIDI1NV0gL09yZGVyIDEvRmls dGVyL0ZsYXRlRGVjb2RlL0xlbmd0aCA0NTc+Pg0Kc3RyZWFtDQp4nIXCh1LaAAAG4OeytXvbOlER UQSRoYCgEMIKMxD2HmELiIAMrXbvZdvH6h/jnXetd/3uG5s0jp2/hlN8E//6NHecS4zPXLyBs8RN rpl/aw5JroC8LSDv4LwF7/IXrPfO319E2wMh3/5wiftIhA58vIzUEzF3QuycWHE+XUXXM5S4JiXu qTX0TEu5MzLvLK77cE7uE8hpwQY9r/DjgjKAi6qAUMUI1cySOijaDIq2QsuoCYs14RVtBFd1UZRs x9b0Mak+LjXEZYaEbCexvptEuTG1YUopTGkFkVYSGaU5qyKzajKntuQ2rfkttBU09oLWzmodrM5R 1FGlbaqkd5b1rrLBXcEdT3XXUzV6a0Zf3YT0HoH+hjnQIANNkmlamJY12LKG9m2hti3ctmPkwBHp UNEOFes6Md5zYeLQjcm+B1MDb3rgSw+Rzozo7MiPuaMA95jJHzOF50HuSZA9CbGnoeJpGEsvIlh+ GcUKvoph9XUca/gmgfW3SdzDdyls4Ps0NvFDBlv4MYv7/E+5Nv9zHg/4XwrY4X9lu5eL3W/F3sVS 7zv38HK5/+Ovlf5ZZfDP4Vl1+PPKteGv2ug/66Pf9aMr/gGo3JghDQplbmRzdHJlYW0NCmVuZG9i ag0KMTA5IDAgb2JqDQo8PC9QYXR0ZXJuVHlwZSAyL1NoYWRpbmc8PC9Db2xvclNwYWNlL0Rldmlj ZVJHQi9TaGFkaW5nVHlwZSAyL0Nvb3Jkc1sgMCA0NjggNzIwIDQ2OF0gL0V4dGVuZFsgdHJ1ZSB0 cnVlXSAvRnVuY3Rpb24gMTA4IDAgUj4+Pj4NCmVuZG9iag0KMTEwIDAgb2JqDQo8PC9UeXBlL0Zv bnQvU3VidHlwZS9UcnVlVHlwZS9OYW1lL0Y0L0Jhc2VGb250L0FCQ0RFRStDYWxpYnJpLEl0YWxp Yy9FbmNvZGluZy9XaW5BbnNpRW5jb2RpbmcvRm9udERlc2NyaXB0b3IgMTExIDAgUi9GaXJzdENo YXIgNDUvTGFzdENoYXIgMTIxL1dpZHRocyA1MzYgMCBSPj4NCmVuZG9iag0KMTExIDAgb2JqDQo8 PC9UeXBlL0ZvbnREZXNjcmlwdG9yL0ZvbnROYW1lL0FCQ0RFRStDYWxpYnJpLEl0YWxpYy9GbGFn cyAzMi9JdGFsaWNBbmdsZSAtMTEvQXNjZW50IDc1MC9EZXNjZW50IC0yNTAvQ2FwSGVpZ2h0IDc1 MC9BdmdXaWR0aCA1MjEvTWF4V2lkdGggMTk4NC9Gb250V2VpZ2h0IDQwMC9YSGVpZ2h0IDI1MC9T dGVtViA1Mi9Gb250QkJveFsgLTcyNSAtMjUwIDEyNjAgNzUwXSAvRm9udEZpbGUyIDUzNyAwIFI+ Pg0KZW5kb2JqDQoxMTIgMCBvYmoNCjw8L1N1YnR5cGUvTGluay9SZWN0WyAxNTEuMzkgODEuODQg NjEyLjg2IDExMS4xMl0gL0JTPDwvVyAwPj4vRiA0L0E8PC9UeXBlL0FjdGlvbi9TL1VSSS9VUkko aHR0cDovL3hlbmJpdHMueGVuLm9yZy9kb2NzL3Vuc3RhYmxlL21pc2MveGVuLWNvbW1hbmQtbGlu ZS5odG1sKSA+Pi9TdHJ1Y3RQYXJlbnQgMjM+Pg0KZW5kb2JqDQoxMTMgMCBvYmoNCjw8L1N1YnR5 cGUvTGluay9SZWN0WyA2MTIuODYgODEuODQgNjIwLjE4IDExMS4xMl0gL0JTPDwvVyAwPj4vRiA0 L0E8PC9UeXBlL0FjdGlvbi9TL1VSSS9VUkkoaHR0cDovL3hlbmJpdHMueGVuLm9yZy9kb2NzL3Vu c3RhYmxlL21pc2MveGVuLWNvbW1hbmQtbGluZS5odG1sKSA+Pi9TdHJ1Y3RQYXJlbnQgMjQ+Pg0K ZW5kb2JqDQoxMTQgMCBvYmoNCjw8L1N1YnR5cGUvTGluay9SZWN0WyAxMDkuMjcgNTMuMDQgMjA3 LjE5IDgyLjMyXSAvQlM8PC9XIDA+Pi9GIDQvQTw8L1R5cGUvQWN0aW9uL1MvVVJJL1VSSShodHRw Oi8veGVuYml0cy54ZW4ub3JnL2RvY3MvdW5zdGFibGUvbWlzYy94ZW4tY29tbWFuZC1saW5lLmh0 bWwpID4+L1N0cnVjdFBhcmVudCAyNT4+DQplbmRvYmoNCjExNSAwIG9iag0KPDwvU3VidHlwZS9M aW5rL1JlY3RbIDIwNy4xOSA1My4wNCAyMTQuNTEgODIuMzJdIC9CUzw8L1cgMD4+L0YgNC9BPDwv VHlwZS9BY3Rpb24vUy9VUkkvVVJJKGh0dHA6Ly94ZW5iaXRzLnhlbi5vcmcvZG9jcy91bnN0YWJs ZS9taXNjL3hlbi1jb21tYW5kLWxpbmUuaHRtbCkgPj4vU3RydWN0UGFyZW50IDI2Pj4NCmVuZG9i ag0KMTE2IDAgb2JqDQo8PC9TdWJ0eXBlL0xpbmsvUmVjdFsgMjE0LjUxIDUzLjA0IDMwMS41NCA4 Mi4zMl0gL0JTPDwvVyAwPj4vRiA0L0E8PC9UeXBlL0FjdGlvbi9TL1VSSS9VUkkoaHR0cDovL3hl bmJpdHMueGVuLm9yZy9kb2NzL3Vuc3RhYmxlL21pc2MveGVuLWNvbW1hbmQtbGluZS5odG1sKSA+ Pi9TdHJ1Y3RQYXJlbnQgMjc+Pg0KZW5kb2JqDQoxMTcgMCBvYmoNCjw8L1R5cGUvUGFnZS9QYXJl bnQgMiAwIFIvUmVzb3VyY2VzPDwvWE9iamVjdDw8L0ltYWdlMTE5IDExOSAwIFI+Pi9QYXR0ZXJu PDwvUDEyMiAxMjIgMCBSPj4vRm9udDw8L0YyIDE0IDAgUj4+L1Byb2NTZXRbL1BERi9UZXh0L0lt YWdlQi9JbWFnZUMvSW1hZ2VJXSA+Pi9NZWRpYUJveFsgMCAwIDcyMCA1NDBdIC9Db250ZW50cyAx MTggMCBSL0dyb3VwPDwvVHlwZS9Hcm91cC9TL1RyYW5zcGFyZW5jeS9DUy9EZXZpY2VSR0I+Pi9U YWJzL1MvU3RydWN0UGFyZW50cyAyOD4+DQplbmRvYmoNCjExOCAwIG9iag0KPDwvRmlsdGVyL0Zs YXRlRGVjb2RlL0xlbmd0aCAyODY+Pg0Kc3RyZWFtDQp4nH2QT2vCQBTE7wv7HeaYCG7e22w2uyAe /FcsCBYCLUgPEqJQMNIYv383kra21Z72sDPzezNI1hiNktV0OQONx5jMpniXgkCKiFhrypFrQmYI TSXF8wC1FIz9l4bIMpkfot1AiicpMF9NgSsAfwOGvTfzNu9ZLmW+xdKp8h6BBpsrJo/MZ4oYWllr GeVBimR52O4rZo/ZEbfI+k81bQybG7hkvW3bqqlRnkJAGACnsu5czKxcdnE4Vpbsv1XTHjgpQuRC I7XKWxS7bruuCsOGM4wDm/CGn0O/KuNBik30UtXxK4pHKeYhoUv59DE75fJr3ybCPa3Olf6lXTfH t3ioo6psEQ9dtDi35yZOo+p0JyQNlzp9H3jp/gFlg3ZUDQplbmRzdHJlYW0NCmVuZG9iag0KMTE5 IDAgb2JqDQo8PC9UeXBlL1hPYmplY3QvU3VidHlwZS9JbWFnZS9XaWR0aCAxNjUvSGVpZ2h0IDY3 L0NvbG9yU3BhY2UvRGV2aWNlUkdCL0JpdHNQZXJDb21wb25lbnQgOC9JbnRlcnBvbGF0ZSBmYWxz ZS9TTWFzayAxMjAgMCBSL0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGggOTkxNz4+DQpzdHJlYW0N Cnic7V0FXFTZ91+7115zEUTE7m4RRBEMOqS7u7u7u2YYhqFbGlQwMUDsFjBQEVCxA/h/Z56OCIOL u8bvv+v5nM/93Lnv3HPj3Hvivfve/PbbL/gFv+AX/COYN3fewgWLlyxeMnr06J/dl1/wLaFv376b Nm2ys7PPyMisrqp+9+7d27fvnrS8u3fncesT5N+i5N69hkMVh4KCgiUlJSdPnvyzu/wLvhoGDBgg JCSUnpb+8uWr9+/fQ6bPn7+4f//B5ctXjh87npWZGxNNzttXeOrU6atXrj548PDFixfv6ADK92fP njczM/8l9/8XMHDgQH09/aZHzW1t7W/evG1ufnz1yvVDFUewuykUSkhIqLu7u62trZmZmb29vbe3 d2RkZCItMTc399ixyuvXbz5+/BS13r9va3vfnpqSxsnJ+bMH9At6hL179968cavtfcebN+8guDt3 7l69evXMmTPHjh0rLCxMSUmJiYnx8/NzcnKysbFxdXUNDAyMjY1FeUFBQUVFxenTp7H9oQSgCiDx 9raO9+/eh4aGTpgw4WeP7Bd8Bps381RVnXn/vv3tm3fPn718/PhJS8vj5ubm+/fv37x5E3I8w4DS 0tLMTPo2h5SR0mi04uLi48ePnz9/vrq6+uzZs7du3WpsbHz27Bk0e3t7BwH46ejoOHjw4J89yl9A Bwszq7dv2l6/ftv69NnjlifPnz2HD9be3g6LDNmdP39h//79AQEBenp6srKyu3bt4uPjW79+PQ8P z44dO8TExBQVFU1MTOLj4w8fPlxXV//06dNXr161tbV1dIb2jlOnTv35558/e6z/acCOo1KTn7W+ fPLk2f37Dx81Pnr+/DmE8+bNm7t372LDYi+TyeTg4GBsT0NDQ3l5+T179mzdupWff9v27QI7d+6U kJBQU1ODuF1cXIKCgkBcVlYGhYDd/Zm02zog/3t3G1avXv2zB/0fhSlTph6qON7S0vrwQeOtm7XQ 29jOEPft27ehvSHo9PT05ORkSDAsNNzK0k5OVlFSUlpSQhJ7XFlZGZsatl5aeq+MjJySoqqLi0ds LAnqPTs7u6ioCOa+oaGBkDV2Ot1rf98GY/HqxRt5OYWfPfT/HMzinl1z5lLjw6a62tuXLl2ur6cr 4Tt37kDQiQyAA5aRkREUGKKhoQP5qqura2trI4Wg5eTkUIKdjn2tpaWlr6+P3Q1Vr6CgYGRompSU AoNeUlKCtLKyEuYAoRzU+8sXL1+/htp4+/pVm52N48+egP8QTPhjwtEjp27X37148TJM6pUrV7Cj q6qq0tLSoqOj4+LisEkjwiPkZOUgXIh19+7dmzdvhh5eyYDlDFixYgXxE+VbtmwBDYgheiwJTU3N nJyc/Px8pFlZWXDkoDdaWloaGx81N7e0tr543PJSWVH9Z0/DfwKGDBmanrbv+vVb1dU1iJ5goCEO eFmImGB8w8LCIiOioaWxf+GGQY4Q66JFi2bPnj19+vSpU6eOHz++MzeUcHBwcHNzL1y4cNmyZaBH XVh5JSUlHR0dyBorh27QS8uamprgD9TV1T24/5ChVR5u3yb0sybhvwNWVo7V1ecO7D+YlJSUm5uL PZiVmWVmZmZlZeXg4GBkaAZ/W0hIaN26dQsWLODi4poyZUrvmUPuhNCh8KH8xcXFY6LpoTocOeiN ixcvnjx58ujRY1hgVadrigsrJkyY+P1G+gv4tmwvKjqQn1/o6elpampqbGwMm7uVAYiw1qyBkNdB b2/cuHHt2rVQ1EsZsGTJEqR9+/btTRPDhg2D0KETREVFVVVVUVFGRkZERARLCD/d3d3t7e3t7Oy9 vX0c7JzUVLWWfISlnwNKoDe+94T8i2H48BGR4eTy8gp7e4eg0NArtbUdXwN2jl/hX7GxsUHoc+fO pVKpX9UK4Hp9/bX6+rScnAkTf+39vw9KClpFhaVpaekQN7YzNTHxel3t1Vs3z125XH3+3OlzZ6vO nUWmO166fg1SgIO9es2a3jfHzs5+5swZVLxy80Z3nmjrNAORRwcu37iOzlyvrwXxpRvXYFwGDBjw /abiXw+TJk7x9QkpKS7z9/eHMdXQ0IBRPnr8+P1HjxoaG+vu3r1eW3vt1q0bdXUsEf40XXA3bowd O7Y3zfHz8zc3N6PKrdu3wbkLN6ItpLh6u6EBfXjQ1HS/sfFOQ0NNTc22bdu+92z860Fkj0xUZGx4 eISvr29gYKCrqyss46xZs27W1ja2ND998RzY/PRJ05PHLa1PgY+ftRJI/EQ5oWkRW/1lW/D6COKH zU1gDrYEQ4IVsxW02PryBcrx88GjRvjthYWF0AnffzL+5TBu7HgLc4eM9ExI2dvbGxtcS0trzZo1 EydOxFZ62PTocevTl2/ftNHvbbNA+p2xjo637R9ug+vq6vbUEPw0rAeC7NnLF6/fvyPqMPkweb5t e//izatWLLPnz5pbWhCgYR0OHTr0R07LvxXWr9vi6eEbGRnt7OwMcYeFhiFW4uHhWbZkOUwkDOWT J0/ed3mo0TO8efMGbnP3VhCbX79+vfcuWVt7++vXrxsbGy9fvoxo/cdPy78S+vTpoyivHhNDtrW1 c3JyQghsaGiIaGv37j3wnDk5ORFhxcXFPXv2rJ35zPKv4OrVq7///nvnVhBqgcNXyLqt7cWLFw0N DYcOHVq0aNGUyWx/Tp32s6bo3wSTJk3V0TaKiSE5ODhCmQcEBGBfb9q0afs2QcwzLPjgwYNHjhxZ Xl6O+e+9xBMTEwn+WC2I4nsv6A6Gkw99AjeNQqGMGzdu61Z+wR07eXi2d+k5bA0CcD4+PgTsagxA Zu3atXPmzPlhszdjxgzmPQFkEF3+sKb/HixdvMrYyNzPL8DR0RHK3M3NDVsbgdi0aexQv/C0CYvJ xcUFVQzt2nuJ6+jojB8/fv/+/b0XNJjDFjx69Ki2ttbIyGjMmDHoCUPb8HLNmItgQUpKKiIi4tSp UyD7Miv0NiEhAX348n2/ZcuWneoEycnJEaxASOjTHd3Ro0fr6emVlZVhTXZv9+XLlyUlJQoKCr28 7/SDQVBAxMaafiOL0OSYH2xtaWmZSZMmsbGxDR8+nEkJgw5BvH37tpeyg0TgYn2VrDFXDx48qKqq goZBixISEvAVkUevzp0713tWXQAWYd26dSyHr62t3ZuOgQzE8+fPJ5PJ6GRvGkWH/9cO48Fw75VR cXZyc2RocoRgmF6Ie4eAEDYmFGkXZ1hfX//x48dQtn975nsCGGsY9zt37sB1xzIbOxaNj4OGtLOz Yzm9EAGqYO3RH56+fImlhV59WfNER0cPGTKkywxAA/Sme/z8/Igf/1KldIGbN2+OGjXqx4nzr2DE iJGKChq+PvTzhO7u7jDcmxkwbRoH7DXipkGDBnWpEhUV1dra2vX0ESto72hva/8LMhC8fvMa2MKI ttAHosVpbNMg64sXLxJkb96+AQ3St/ST7PSjUzArhM6H337p0qUbN25ALUDu7XSRtxNNv297D2JU RIbgc+zYsS4Sv3XrFtENAumHLD7iu/fv0CJREXq+++iYbLuXo90OxprExP44cf4VwOPdK6Pk5uYB kw2HCrEtZA2l3a9fP8gaURgyXapAvRcUFtxtuPeouYnA5sctnbGppbkRxYwMcZUgw8/O+fsPH9y5 d7e2vu5WXe3Va1cvXrooJiYG/v3790cKJUNsajRUf+c2KO/db0CVh48aCYRwCwsLBQQECHODTcTL ywuhMBsiuvGg8WHDg/uoDiTE4efvzxzL1D//BA1RhUDmoIBEdRQ+fvoEKRpFZ27fvQNW4EmMhVmR QGa76Crq3r3fcO3atR8oz78AzunccrIqnp5ekDUibggdhlJUlD7tAwcO7MnZmDxlyv6KinOXL1ef P19z8eLZS5e64JkLF3AJSGSQEmRIiSrV585VVlUdPXGi/MiR0oMHk1NTuWfN+o1hXJAuWLgQsm59 9epEVdWJ6urTNTVELQLPMlJacvKQj4aGqAWYM3fu+StXiA581ui5cyerq0+dOVPf0FB19uykjy81 8G7d+rC5GTREb5nIrA4E/QlGVw8eOlR84ACFRsvIycHPM+fPE8wJYiYyx4uKVefOXbx6FQ7n95Zj L2EW93x5ORUfb1/I2s/PD+Ybe0RBQZG4ypzG7rBy1aoDFYfKjxw9dOz44eOV3RHlTOxcWH7kGDIH Dx8pKtufW1iUnZdv5+g0YsQIJmcE7NDqTU+flVUcOnDocMVROj1SVER6pPIEsPrchenTp7PsYV5h EVoBJbNpIkX1/RWHDqLDxys3bNpEEGvr6ja2PMWlzr3tgqXlFQUlpek5uTsEhZiezJKly9C3LqNj jhGtE3jkxMmTVWcm/s88uZs7Z9HevUoQt7+/f1BQEAIxhLFqar06OCQuJV10oKKg7EB+6f5eYl5J WV5xKdLcopLUzOyk9ExRCckubPWMjF91dOQUFIOGXqW4dF9RKVKien7J/vPXbmbnF/XUq5PnLhSU HkCVzghWOYXFyBQdKC8pP8TDy0sQewcEHT1djfIeu1pcmpazL4pM4Zwxg6jCXGDW9g5o6EsjLSkD AZrr7h/+LJgze5HsXiVPD69gBmB3I87V0NDoZXX/sIjU3Lzk7NzeY1JWDi0zOyE9MySaNG/hoi4M J0+devDEafBMzMgGMdJErIqsHKIi8mn78i/cqm9sbDzNgFOfA0rutDyNT03vjpTk1LjkVGRScvZt 2ESP8gYMHEhNzwRDsGXZT5SjA5TUtE08W7qPXUxK+gtjJ7qdkJEVTo7/ZyL6ljBzxjwZaQV3N4+w sLDw8HAfHx/4SCoqqn9ZESs2Pj6++V0HJTWDlJTaeyQnp5GS0uxcPMawelQquVfuSPX56ISk2MSU mIRkpMyKRAkyMbRkcnJ6UnZeekFxdvH+nNIDSIEZhSXU9OwoamIYOT4iLqELhsdRQ2LiwkjxYL5k +Qq0xcE5A3xiaCnA7v1EIVqMpiX7h0exNGoiUtKZRaUsx0jvKr16alR8oopWjw+MfhjAByOGwME+ U0aa7pkjvEJYig0OX1deXv7L1Tk5Oc+cOfOkrYOUnB5JSYyMT+olRlGTSckZSAf18IqQuZ0DJTUL PMPjErpypiRGUGhIQ8nU4BhycExcKCkeZBEM4jASNYxMRSYklhISQ8GlzohC0AdGxgZExISSKDNm 0m918mzlLzpSyaIhRlv08vgk8FTXNWDZVXU9g7SCEtbDZ3QViKZXrmF9e+dHAsIrIrydNHGqmKiM tbUtiUSKi4sjk8mCDBg6dFhPdXfs2PHkyZPTV+pISRnRCanA2MS0XiIpKb2g/FjL+w5lTR2WzCMp SaTEdFDG0FiwRVsoD4+jBUaSfEMj/cKiAyJIgZHkgEiyX3g0EJnAbhgURUdQ+oZEegWFh8YmEC69 mo5+XvnxaGpK97ZQwhhXOtri3baDZVd9giITMvb11E+kUQkpYM5Sif1gQGxLhKvDh/8uKrxXV0cf gqZSqampqUJCQrt27eLh4WVZ0cHBAaFr2fFqckomNWMfgQmZeR9xX6fCzuWfMCmn8O7Tt/da367d sKkL88GDBydmFRAMWXKgZeUlZRcqamhPY+dg45g+7WsRtdjZ2dg/HGgMiCJnFB34vP+fDQTSjE/L Zp/O4kbo1D/ZknOLaFn5LIdJdD4uLds3LOpbiu0fwOjRo0eOHNnntz67hCTl5ZQocZTExMS0tDRZ Wdk9e/aYmJh3oUfwWFhYCFlnFBygpGRjKpJzChMz8zH/yCCFpPATKTNPXOqM9EuZ+bmlh+lr5ljV pClTOzcxbPhwsKWkZhN1mdyYfNLySjKLyncKi32D4Y8Zk5JbnJJbRPDvgkS7tIy8KEoKy5sPm3i3 Hj17BWTEoLpWz8xPzilKSN+noWv4z7v6TQDiJt643LCeX0JcJjw8gkajJSUlYf8KCwubmX0m7qVL lyIWvv7gaSwtLYoKxyaTkppDTs6MS8lCJi4lGxkij0JcZfwkCuHZ5jARP0GATHZJBSTuGRA2cOCn m7RwJ0JiYY4TYxLSCDKC7UfMTt1XChSRkPmNVcQ9Z86cJT0D8YCSa+ZMgnjZytW5ZUeZXeqMzM7H 0NINTK1Yzp6Shvb+yjNED3uono3q6zaxcOl/CowYMYKdnX3o0KGzuRdKiMu6urhB3MnJydjj4uLi 0tLSM2fOIiiVlZVfvnyZX348IAKmMC4klhpKotHT2IQwciLyyNCRRAuKpoCGIPtQyKBh4gdievWE 9MIDj151yKtqdu6Vsra+V3CEb1gMmIAb0daHiiQaKSmr5sZ9Swe37sOBe/nlm/MpeSXgs3ELH0Ev IilTUHEiOIZK9OczjIW/Rw2KpvpHkPi2C7KcPUdPfwi0p+ooD4yKC4qO+2PipG8qtL8PsN0cHBxs bGzjxk4QF5PX1NROSkpOSUnJycnB1ElISGhp6QwcODAyMvJ5R0cIKcnZJ8TFL8w9MNIjKMo9MAKp R3AUM49yXAWNo1ego1eQk3cwfoLgEyUTGcREmlV2rLTy3IrV65m9mjad09bN197D38Ez0NE7yMkn 2NmX3q6bf7hbQAS4pRXS1YK/vz92K+gxBH5+/n379r3r6IiiZYKAyRz0rv5hrv7hLn6h6A8YahlZ MB8BaJtYBkRTUQ7+LNAnxMk7yMU3lGnoOwOMjk9orKtfGNG97ohycLZ0ZLEsfyJMmTJlwYIFw4YN ExQQl5aSRSyWwQBPT8+NGzcuXLjwxIkTpdXXbT0CLZy9rd38kLFxDwAi0zmP1NLZx9zRy8zR08TO 3dTewwzo6GXt5k9cJeiZSFQE2nkHF5+8FBBDmzDp0wmEhctWGNq4mNi5mdq7mzmAjycQzM2dvMzp PP1iUwtedNq2yFOyyxx9QgnOIABaufpZufhauvhYOHmZ2HsY27nJa+qP+HieCp4qLlk6e3du4jN0 8DB3wFg8WEbcM2fPcwmIMnXwMO2pLlJ7z13i/1vn68aOHUu8zbdwwQppKQVLC6vMzEyodGdnZ14+ vpvNzUHUfbqWrrqWLvrW7oa2Xvo2HgZAW086MvL0Qmt3HQsXLTMnLVNHNSNbZT2LWfMWrdm0VcvU Sc/KhSAjKJn4obqtJ+qauwTlnbiuZmgzaPCHO41cXFwzZs1V0DZRNbRWN7bTNLXXMnXQJNDEQcvM Ef0hGBJMiIyelRvKdcyddSyctc2dNE0dNUzswVbNwEZO02TRsjWdBTdxyp8Yl6aJPR2ZzDuhhomD upHdTnE5lvO2lmebjqWzxpeq22sY281bvOJHSLHXMGrUqLlz565evXrixMnSkspyckohISG6urpW bm6H6t4auYQo6Fkr6NsoGzkoGzsoGdkjVTF2REovYRQqGtjK61nL6Vru1TKX0TDdLas5fiJ9n/Yf MEBIWlVO1woEnesykShEBqmhc1BsYRXfbmlUFBeX3LZtG5yKYcN/X76eT0RBW0LFUFLNWFrdRFrD RFrTVEbTTFbbAr1SMrQjkN4HXStZdEDTVErdRFLNSELFQExJT0JZn3en5HTueX379e8y8NkLV0ip GYmrGEj0iPrgM3/5WpbzxrdLSkLV8IvVDfZqmo0a+8f3luDXApzzDRs2QKWvXbOFf6vg4iXLfRPz g7NO7dVzEFM1ldCwkNKyktK0ktS0pGe0rJF+yGtaiaubg0ZUxVhY0WC3vN4GAbEhQz+ddBo7YYqI spGYiomkhuWnWnQOTPxQiNTANcI+PGvWopUCAgJSUlKWlpYaGhrLly8fMHDQNK65C1ZsWrddbJu4 ipCMpqCMppCM1i5Znd1yersV9JDu3Kuzc682cUlASmM13y7uRSsnTJnWf+BAZme66OTxk/6cxjVv GtecnnEuO/f8oSNGspw0Nq45bDPo2FN1dq65HNwLvpPI/gmMHz+eeAN39Kgx07iXxJRftwxOFVU3 E1YxEVUzF9e0/IhWSMU06Ii8mLqFiKrpHmVjYWWjnfL6QvK6C1dt6R6fzl2+YY+SkaiaGVGRUZcF imlYgKd1eJaGXeD4yWySkpLUeCqFQtHR0VmxYuV0dq5+fT8Ea4OHDBs5Zvwkdi5itpk4ZTo3ykeO 6bqb+jDgR8zj/x+YNm3a/Pnzt4pIZZx/ruMaKaZuLq5hIYndp2MjpWPLQJuPSP+JSyCAEEVVTYWV jXcq6HFwz2fJGW4wn5gyGEpoWn2sbvM52jJ5yho6+aQcxULatUckLi4uKSlJSUlJVFhCUEBk7tx5 gHHjxvXmSWJvRIyIYxgDhn8Else0etlWd+hCpqamto8Bzm5uP/1hKAJwJ3//shuvDFyCFY0clU2d VcxckSqZOCHtjChRNHZUMLSTN7CV1bOW0bbYI689dsKXQstxEyfL6tnIG9ihYhdundkSjRq5hVPL LwvJqOro6mpqaiopqioraW/cwAfvYtasWV3OhPQ0t72BrKys5m5w586dvLy8TR9PPnxDoCQmnr18 +cKVKwUlJd9D22zevBmxs4KCAuzylykRix06dKj04gNr7whTlwBjR19DO7rnrG/rYYCMnZfhRzQg ym089WzctS1cNM2chGVUhg4b/mX+gDWbt+pauxnYMlz6Tgw/Y2vrgbyJS0BoavG+Uzc38gutWrla UVFDRloN8w9xT548uctrKX8boHMOHz36sKXpYXNTc+tTYNPTJw9amhsaHxKRnZeX1zdpiIBJkybd brhXf/fO7du3TU1NvyFnAqCpwBndfvys1czM7AuUWAwNDQ0Ha255hsUhkHT0DbP3DrH1DLLzDLbz Cka+C6IQlxBNW7r6bhUS7tu366lFltC3Xz81A4ueeH7g7Enn7OAd6hFKrrz6IP/IuVlzF2zjF9nC wyskJITwocsnX/4JIPxsbGx88+5tS0vLhQsXKisrT548eevWrdbW1hev6IchMScwHN+qOVgKfn5+ Pj4+pF/1YZNeAmwxcQ783bt3cLl7IhOR3JucXxZBTQmOTQiMoviFx/qERnuHRHmHRvv0gLjkGRTp GhC6bOVXvLYPmMo2zSMowis0qifOzKbRjeBYWkxSVgiZNnrMWGxt+OcIH77haW34pR2MVx5qa2u5 ubnBefTo0VOnTvXz80Nhe3v706dPt27dCkosMxT6+/sTu1JQUDAnJ0dfX5/Jqn///liNJBIJGvLg wYMgXrhwYZfmwMSJAYqKil0uwWWCJikrKzt8+HBMTExPnxCEZjMyMsrOzj5x4kR+fr6NjQ3zQ/Fa WlooIZTS69evw8PD0VtRUdHO1QcPGaJnYk5JSY+MTwgjUYLpz4Kj/MIiCfQP7xEDIqJdvHw4ODnR MfT/q8yc4B7hL3AGMlsPioyJiKPGp2W6+fhhQrB6v+1JTmtr6w7Gqz2QUWdLinXV1taGnYJdT4jb 3NycmEloAMSGHYzPtzLfRYVuRPmHs+UfX2fAgjExMencHPGWCtiWlJQwC+EW+vr6Mj4M206kHYwX K1RVPztHhOWkrq5OvJrUzgCilbNnzyKeAsG1a9c6d4B4NcPe3r7LkAcPHswxnZODYzo7/UEwxzR2 BnJ8RHZ24tHwpxIGzpg5c+XKlQiUbG1tIyMjU1NTDxw40J05S0DPiYa6s+2O6BUH54yFixdzTJ/+ DdU4AaWlpfRbry9eYMJ/6xSS79ixg9gjdXV1MLgogedGTCZd+b95g2lHhvj+j6GhIUGMEmgJWE8s EuJ1Ksw8sVoIoNFoKISl8PHxIUqwN2E+IJpHjx7dvHmT+JYgWBFkbGxszLqZmZkofP78+b1799AK nMmmpiYQ379/X1xcHD42PEzi+7SojkvoRn19PbRQL6cCHKA6oJFWrVo1k4ubj1dQSFBYSGiXkpIy NgU6TKVSy8vLoVUQVkC9IIUygR47frwSfQPN2rWf3YnC2sCsYshhYWHQSPAepaWlJSQk4HhbWVrZ 2dk5ODjAwWAcqNjCs5lvyxaBOXMWYlPPnj0blu4b2lACwPBmbW07QyjCwsLM8okTJxYXF9ffuXOr rq6oiH7MFZ7hxStXHjQ2NrW0NDY11THKyWQyLkGBM953aMD8R0VFrVu3Dh3W09Orq6+/09DwqLk5 NzeXWEUIu6prapofP8ZiwNiJttzc3VH93oMH2O/YpIgBoSdv373b8uTJ85cvEX7+xliE1ra2RCtX r17FFMEur1ixIiQkpKamhng/ceTIkVJSUrX19U9aWxsePPDw8ICgMaiv+k8QLGx0HksdWmvbtu1a GqZ2Ni52tk5ubh6QLHwbDPzhw4dY6tev34DRwdCwCwoKCgoLCzFjpQwoY8D+/fuRohCrIiUlBXMV HR2dlpYGAlQ8fvw4lENUVLSFuYWerqGerrGOlikfrwAvLy+MxYwZM77Hd86XLl1aWVV1ta4O4g4I CMA0QktDZBDH/sOHczCMsrJVjA8KLV2+/Njp04cqKyuOHcsvKUEh8TQNejg1K6usogKoqfPZESx9 I6PDlZVHTpw4eOwYYYBmzZlz9NSp49XVldXVXIx3gZevXEm3DtXVaKjz65bW9vYnz549WVNjaWuL n9M5OesaGkrLy9GrVZ0+cIQ+/Nlp+0+cNAnM0c+jJ09y/d13jeEaYVqgLuCWYDNqqBuFBsWFBMdE RsZkZmZdv3Ydzgzdj33xAjoEcq+trTt16hR2PdYDIXdsBOLDpwBCG2CdQB1BC2GpQO1gX6A8NDTM xcXNxcnDxcnXxNhRcMcuERERLHVE2YQ6/eawYTNPacXRtJy84oojtQ1N7zo6Lt6sz8grpKakx8TT IkiULfwfvvOzR1y8vPJUajb9CDQP3yflvGETz9krN5Myc2MoiSMZDiQz/F+zbn1WQXH6voKk9Czi Ev+OHZU151ESFk0ayLiNY2JpffLsxSNVNZgQuHbYrcSR70Mnq1Nz8lKz81U16a+aSsnIV569kJyZ 4/wxKmR5k2ELH//pC1cz84vjaMlfOF74lwAHadGiRQICAtC68BZkpOUd7HyjIhJiouLJpPiy0v31 dfXwdl4zvlr7nv5vE22ELwFXATsFNgUpxErQvGQAMjBDMFhVVVVxcRQ/X38f70Bfn1BPtzBlJW1x cQlo/o0bN34/WQOEJaRzSstDYylBMeSgaHJAVGxgRKxfWJR3ULiGniFbp+/8qGjqxCalhZLitQ0/ c7209I1y9leQk9OVNLW6MBfcI0JKSguJjbN2/vCkW1PfOCEzN5KapKrJOH7cp4+jp28UNTkqITkm MQ3lEfQzq4nhZARHJHQD6ap19Kf/Dh4+tKw8ckrGNsGdXxiOqo5eYk5+dEKyfrfDZl8LiE0QRGD+ ZWVlDQwMYFMU5FV8vKJIMcmx0dR4Ci0zA6HByfr625BjT68AEx+vfvXqFaR//vx57PuYmNiQ4LDA gLDgwKjAAJKutrmEhKS8vDz2NYwgFxfXd/2vCitn9+iE1FBygrmDi/heBQlZBVEp2S38At2PMVg5 ucUkpkdQkjZs/uyUppmdEzhkFh/UNPzsnsmAAQPSi/aHxdHCKTTebQIo6de/v3tAKCUtB3x4ttKV xoCBA72CI6JpaZS0bEV1rd2iErvEJIUlZHaJSGwVEMJq2SkiPuL3kWDlFx4dl5qdkJW3Y9eensaC ze7s7U9KyaSk5wjs7JHsqwDzjwiFn59fRUUFQpeTk9PU0A/yJ8fFpsWRkhOoqbSElIyM7MOHj545 U1N7qxaWHYoaniRcxBs3bly6dPnIkSP5eQVkEiU6KjYiIjYiPC4ynBoZRjM3dRITEyc+pQsFDmXC ycn5zf3wzgAFS0rOIKdkxiSlL1/N+uEmAcOHj4iippBTs8gpWfMXLu58SdfEHBvzYv3Dx8+eYWaI QgTviFOo6fuiaSkBUaRBg+in6EePGQsOybmFkNrsefTHCn379fMMDEXh4ZpL6z9/M6VzsIwoxt0/ mJSU8eh1x4HKk0wdDhfa09OTeSBn6LBhobHUrOKDNTfuYFfSS4YO/eefjIApnzNnDnx1OIQaGhpw sJWVlZWUVMxNrYMDomnUnIT4zMSEDFpCWgI1BdJPpGENYCUkUeOT4uJoZFICmUQjxSTGkVIjwxPt bD3UVLTgUmLlwEXfsmXLkiVLoMC/xx2nLjBn/sLwuBSvYKjuyD8Yt/p7uus+c/bc4Oh4b1AGR437 4zNts2jJcveAcO+Q6FcdHTBM8PdgghFPBccmeAVHOnr4oxWCkp2DM4qaDj7+4WTmoTUlDV3PwIhD 1Vdh11xdXRFoI5y5dOkSqu8WlezzUVg7dgl7BkUERFGgIeHTOjs7IyaC3YyhZShr6vXvT/9i5Nhx f3iFRIfE0l4yvhThF07SMbHs5a3OvwRY83nz5q1ZswbePhQ7Ak/IXU1NTU5O3szEwsneNSggMoGS kULLSUnKSUygI1ZCUkJOaDDZ083f2tJeXVVTRkYGSwWKAn4gHx8fdgcCrh/2FyS823eaOrgbWTsr axl/+VHFRt7toDS2cVHSNup+dY+knIGVo5m9u7VbgL03/favpZO3iZ2rlrEVG8enQ+mr1m8OoaRb OvtomVgTL60DJkycjJ+GVs5m9p5Wrr7Wrn7mTl5GNi5GNq7bdokyezVs+Ah1Q0tDGxdzR0/G7eUQ O48gC2cfS1c/sb1KBLffR442sXNDXWM7dzMnT7AS2PMNjmR3Bg4ODoRpCAA3bNgAucPm6urqQvTw 4eHUKSoqyjJAU0MTYSaEiy2MtaHOAPoDTVFRSBlxFnY0NEbnWwo/ADZu271LSmmntMry9axfmmDC er6doNwlo7p8HQvKQUOGLl65YaeUsoymiZyWuZyOhaC44tI1m4cOH9GZbKeUirKRvYKe1eYdIp3L x0+cumHrTjEFbSlVQxl1YzFFnc0CwuxcXb8WNWb8hHW8gqKKOnsZrUipG28RFJsx59Nd8T59+i5f zyMspympaiCpqr9DXGH8hO/1Z3yws9jsy5Ytw37n4eGBnseGhfSxc6HwiW9eQfqQOES8fft2GBeY AxhoSBlr5qe88tz7h499emEB+/brP2LU2NHjJw4bMarLpT+msG8VV7GJyNqjZLxbyfjPGSw+/DV4 yLBR4yaMGvvHwEFfegI+cPCQ0QyyQUNYx1moPvz30YP/QRT2VcDOzs7NzY0tjw2LXQ+ZrvwI+Al1 vXjxYiyMmTNndvmO00+B3j8i/zJl90vMEsy/lLalkUeUlJalmLqJgKRq/wEDv1y9913qDdmPh8mT J3+/2Pl/HMb9MdHEyUfPxk3bwlFBy3jSr489/qthzLjxu8QkBHeLbOTh+194/fMX/Bfg/wDVyuZh DQplbmRzdHJlYW0NCmVuZG9iag0KMTIwIDAgb2JqDQo8PC9UeXBlL1hPYmplY3QvU3VidHlwZS9J bWFnZS9XaWR0aCAxNjUvSGVpZ2h0IDY3L0NvbG9yU3BhY2UvRGV2aWNlR3JheS9NYXR0ZVsgMCAw IDBdIC9CaXRzUGVyQ29tcG9uZW50IDgvSW50ZXJwb2xhdGUgZmFsc2UvRmlsdGVyL0ZsYXRlRGVj b2RlL0xlbmd0aCAzODE0Pj4NCnN0cmVhbQ0KeJzFWmlYU1cazkZWIIGQQFgSQtgJyBIggICgsieA ClioxQUURVzqgigq26iodRed4tKZCh3H0WqdWoFqW2rVtijqAyIgUBQERKyIgECWORcSudlYnqcD 7w+e3LPc857vfOc77/kuCMQ4MOdY2VhZsIzHazc9MDC2dPGdGxIWHiGICA8NmePjyDaiTjcpBegx rDxmhwsgCNdv3vSxEPoVFuDKppOnm5ocFCM7f8BwXs7XD1qlI+hpuHksSSgI8eLQdKeb3jDoVn4R ggX774ukSnjx72RhqIe5wfTT1GfzwwQx53qVGY6gIk0Y7GamR5xejjS7uYKoE13qKQKIf0gSzrah kqaRoq6xS1hkXotGihAGriwMcaBNH0sy0yci+tKYFCE8Sw2bYag9TRx1zf2F8ffH5Qj2epbA3Wh6 WOow/YWprQpsJKKh/nc9PX1DQyIJvFx0KsqdPh0rTjKZKUzvgTPpba/64eLZw/sOFJ4vqfijq18M q7wa5WowDXuc5i5I7YZRbKsozkoMD/DxdPfw9psbs/b4jfoumDmLIh308FPNkWwTltj+gYK4/fbh xABXOwtTGlRpyraZwY/eeb329SjL4yEcXdzUciQxAxdUfCDQd//0qmA+l6KjhRxtYuMRnVdW8+Ec er8twsZID4BCJqKnhiSVF/XlB469T28UnSrIz9+9zZ2Cgk3ExmvFxceD8lZvr5w6tD8/Pz9vwxwS UvOb/zqQ2CEp/WqCzd2Z2vDxrYIOvlZt9CwaPpX/H6juCyrVcJRKzjliPzRCEu1z36i2adjsojMV JImsoCx1HKXS/i1mcodDkb2KBlQaiGvy5prgp2K5KU4x1epJSl/M0x9hgKKH/apaPVSRF2ahMxUb B88I2C4PgT3KNO7OJAKWSKx5crMaQ5dummlCmBKPJFlF/Sgbtf0nZa8Tn7LVQiBJTvlvVTlKytd7 GGKnZGsjdLlLZAaUnMwqVta7vWuMMXq+l4bUOcONYAYeicJTDJlsNpOujRmXL4ZIoehRiJjJk9Tn H5IN+mxlUNIVZTp/RNvOf6COolRaH+nkNku4ek/h1WvXvjm2Y/5sHpssc1AkzsTNf5avp5sLgLMd g4BE63K8BZt3gfi7JZLPmmRsxTPCbsoG3RvA4qXckShR+f1wm3qO0sEzV6s7YcKju65kg68pDhof bbyt42Vn59NqCFWV+WyGe0pZiyw8iJ5/HW6CHZcZDASzhTKFNhRjTaa4ZdQqUZGoxnnlecDQdtyb CrYSzuMXeOkPCbtrFK52rzM5WpOxJHOpbIUbfGhEjIFf/kvNFGSzqRaPUVvzEQON0Il+AS/7/ZFy j95VhpMICwROpqxfoTUJh8Qah/793dgc35Xs7x6r/uXHdDQ9VSHy96m2qvaZhIoi2p6UdZtP10Ij kHjz2EuDqu8cxYsv0tJewZ5FHfd+vt8Bt9QTf23Lo2POE2AgkTJhjigC94Ksm+9wXEaRbJeXa15O 0aO9McJimFMOlO9PTVx9DO7JkiwW/6ZyR7GyI+eYTniHo/AzvpW92hMx3AtNdtlUo4ljf1l6oHs6 fPV+2+Bna2EvOAvfF//1EDQodJN0Vdz4pV2hSHrEYsJOicQ6fy+zkbusE4bqs6tDPceuomQeOxxO oO/S2qig2cGf/ANOsjx0uYLXip+cSEtY+aWir+/hTHznYBxkJMV8uRLHmsRdVVU8oEX9kQW2VOsj 8IUTvX3dCdClcGzejstRWNznu0PtzZ3XK1xGB7cwJx7QUTby5fbFyaaGs96gEEDkr72zM8hcmzir Tk2dIn5adlFhcl+GGuPRBvEKGuXVCsbEfRJpId84oaThMw1JdMhVo8ClkoqtPgw8ipwwZvwZxrdr H8Efu9OtwDGk97FCAH4UpT9hQ6JxDHkIWqGHQUHq1vsr9SGoNcUcjEVbO8Z5I5vOkXSFTfL0IzoS gTRKew8vPO818fwCRpuSLut2yRSHRmAMBRVSDSj1xCOQZtnwov7ntY+Vce/rFTsUXPo7fx0weetT 8LLBHJtJnIt6dKHsWOzgamvhOKma02pDn1likOb58KL2wo1paWlr1m3ckiHHllVRwSfgbcT7uOBw wXrfhRe+WmkyiWNRj8WT7RJRMF3f9bCGBOowupcbopmZ8Ej/bD3P1tbONXLvqTMynD6+3nm2Qih/ s44JnF076jm8sGrexF0SgdAxdymXddzLCy9VSUMroCFcz2QtPNr8ucmWbGAdWQJvdJ4rVAjljR/R wD6mJisc4F/7TCblpc3mH5R1fJk9bnT5gW8aXwkvqCtI3FqkYKPuNOdlCgGgLBC4pJKbDOXZTkpQ mvjEyI8ClXuYCsTHvaPOqNE0o+grDnPZDg8Aks8cgUti3K7DW3WtNp3UBY7KW3hH45A9yor3Xdbi 3DHUpKSjaAmXfx5e9HYDC7gkIbgeXvhkweS+XVEcFuzSEPrEdZdvKd952vc+1EhxsO367vm2NC8F VV4fB7mkTjRc3kn/4zPJXLFZyKf1UnUYKN+ZuFWF0rMPU1CY2sCbpp+LshP4TG2S8+dVzztkeFFz 1Au4JEI3sLTuhbzw+YMUq0m5JAJB46+9os6U3RdX8q19816pqRqufnT7fs3z9vaOjvbW2kclxYe2 JIa4mVOwKKzZ3NSsPIBcgO0pgaaQBCdaRa/PzpUhI5FH1WG5utvpTdgxUa6ZT9SQaP08nqtPZISf U39IDpXtTUldk5EFxszOXL88NtjbkU3XhoSUFjMiLWPbtm0Z6xaFeLnYGBEhJlpkloOrmwxOHKq2 bXFjU+VMjeliJI5qYqKPk2sQjHFygyoHUdVegaUOGkngJKk/Jqtygp0sbJ1cwJguM+wtzehkgiw7 gPeqez8Aobf58wAGUWvYWkgMjkiSg4jHUKI6wZ0xUuMnVS1OzoWvNjNGrvFIgk26GoU78GPGLFPi sN7g5XSq4dhzdr4JGY0lDI9MwGFQo7pL/5PRUFbpqd5WSMONoLYmgqLJkOQFIC7edBj2XKSOx2k1 +dN3320MpI/YGmMY9k/VBRf9tNWVpv79KNbfQESQiIcD1VC6Kc3KnmVgYmeujUISjJ28+HZ0LBKB Ml11p67qmJcOEmtg58nnynJKaDKH5+NuScZoe5yUQF852AQooxf8s5o903d9TzyPRR+ZE56zTPUb VOfpuWYarIBxvQY4tlTcrYWC/uVZa+7eu5pwuu4CR5sV9sXjttbKXBddJMZqV+0fFUssCHru2RUt bVX7XHWAmtN2SL3R9LK5PNHa9VoH9JKqI0wgTdwq1Trc4Ok4YZCvqx2Hbcq24iWcUhHBfZn2mgQC IRjcHAf/tXbFPug6V7r0V+B7QANf9/UpGFG94h+9dfB8EEtfxzFMYx8MG0lS4kZAG4SWjKxZd748 PV7BAxcFmxUXbj2ofvy4rvHFm364TXu/ixQIBOEQohZl/qdeoXKwo2wRW5P4p3zyJ7D0Zp7jkgfQ zWEr8GhItXyxtPxD/2I7PSjD8SzWJgnyd6havMOUJmiSN/huv+zHdT7YQwbOwmWpQBGmbd97vrJF UQINNF7dLhQIhAW3XyoehG8fFi5205SERprmAZesWeM79xCwf9++o8NH1sCrgzegqTc3QhnQzmir jUCmVy2c91gqfV//+wtggV/85gB7S/5saO4VV6bn1IMh+1vvZ9gDRyXSWNa2wwiIzS59qu6OqAxJ W+n2cGcdTUlGDBf60tv28LdaaOl+31oKdWm5cuA4WMCuy/v3XAIKaShzVhEo/nYxuF4NPSz+eylQ f03LjoOGjed25Z+5sCk8ARJ/1UeX+xhC80ZhtLAj4PikXqoeXwcNPv13khsTHnIUgfO9PTqfxpxU yDFbjyUuAT44dC3J1/9TIAdF+QvBXhw8mgbWfLC9uakVmLU5B7hyb2Gsl1fgHFdrIagX/TPSlkZQ ej3LJbagokNtTnd02J7qwhguQwNBCKTR5EXfvRzB8jZoaKFTAriadWW76DMSmkCE27oabN6uzK2w dMG9w+ChOc2arEs10KUuAPTfbLImYlTOTVOHuZlljW/GUGL9LTdzwmwNx+CI0F/8J/SN9+2b9sqz a3wdVwEfbFhhYbQIlHauY+EstoFlr121E/ytS80F7tXT0dLS2v6yqeDoIHSvNMBRGbpoajJg/DSe rvZot/KMO3CruVeDchtou3Mo3oOjIYiPAMXcDbZf+zenjuSuDHWgW0G76FYIxeBjoFPElyJ9N4F7 3lBh3DExlFndDpa57fqXRf999NW2+Lz30Af/wNm53wfRmTsA48p1swzVfn4xs5+ZeKKio3dIhaeo /2XFycXediZjUQTxYjiU30ie4+1qbUjCO18BT0VueErYPcifa6qAhUT3kiMuguLisFXAvOJnD+ve SatieclQFub1w6di6WNfh2Ng/N7WajcNOUwW13/pwZLazneiUb0oEfV1Pik5uMyfazY2RRDKg56C qLKHRyOTcGgkfjbQV/07rDBE5zz5nhTdT/cRghA6sMsjokQ+RE0wM7BY7mdNAufDwz+q/TXe1tiO /NDl+y5XPuvq6Xs/8L6v51Vz5eX85eFeXOZ4FMG9LviPgcGmRYwRbyLNaRgYbEwwQmGMhUWvoD35 vvP6Jv8ZK8HZ07XSkrv6zjtAU/SmYp2THmfZjz3gQdz9aAvPLqVVLJV0n3Ef60rJ4XrMWbg660DB 2XNfnPhsZ1p8EM+ebTQ+RUBrxpqCk596kEciFHFG2vET6911kUiS5bzdl397cOur3Yv4Hlt/BWwe RNKp7iknb9777VrBGj8jPGXG0mPfV94vK/w0wMRoZuY3d8sOxFiM8+8J5jaOrh58bz8fvrsL15o5 0SsJlubo5+dIw8qfuH5+XOgJrc3yjFq64pMITw57CZQUGjjKI2GptgEfJSfFzXY0IqC09Kz9Y5OS F85xYhCJDPeoRTF+HN2Jfbc0HismqgEKRzYw0MWiVJ5QOIqxhaW5EZnA2gPtofIEphYSQzRgcjhm BiSgl5FoItWMw2HSSFpIFE7PmGVqQBz/I9tfDXC6YdAoBJq5ub79+bernXQhBkg0KJRTgT0gUWiN h9oUAE2bmZqdEeesP7FPjP8DU/4xtA0KZW5kc3RyZWFtDQplbmRvYmoNCjEyMSAwIG9iag0KPDwv RnVuY3Rpb25UeXBlIDAvU2l6ZVsgMjU2XSAvRGVjb2RlWyAwIDEgMCAxIDAgMV0gL1JhbmdlWyAw IDEgMCAxIDAgMV0gL0JpdHNQZXJTYW1wbGUgOC9Eb21haW5bIDAgMV0gL0VuY29kZVsgMCAyNTVd IC9PcmRlciAxL0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGggNDU3Pj4NCnN0cmVhbQ0KeJyFwodS 2gAABuDnsrV72zpREVEEkaGAoBDCCjMQ9h5hC4iADK1272Xbx+of4513rXf97hubNI6dv4ZTfBP/ +jR3nEuMz1y8gbPETa6Zf2sOSa6AvC0g7+C8Be/yF6z3zt9fRNsDId/+cIn7SIQOfLyM1BMxd0Ls nFhxPl1F1zOUuCYl7qk19ExLuTMy7yyu+3BO7hPIacEGPa/w44IygIuqgFDFCNXMkjoo2gyKtkLL qAmLNeEVbQRXdVGUbMfW9DGpPi41xGWGhGwnsb6bRLkxtWFKKUxpBZFWEhmlOasis2oyp7bkNq35 LbQVNPaC1s5qHazOUdRRpW2qpHeW9a6ywV3BHU9111M1emtGX92E9B6B/oY50CADTZJpWpiWNdiy hvZtobYt3LZj5MAR6VDRDhXrOjHec2Hi0I3JvgdTA2964EsPkc6M6OzIj7mjAPeYyR8zhedB7kmQ PQmxp6HiaRhLLyJYfhnFCr6KYfV1HGv4JoH1t0ncw3cpbOD7NDbxQwZb+DGL+/xPuTb/cx4P+F8K 2OF/ZbuXi91vxd7FUu879/Byuf/jr5X+WWXwz+FZdfjzyrXhr9roP+uj3/WjK/4BqNyYIQ0KZW5k c3RyZWFtDQplbmRvYmoNCjEyMiAwIG9iag0KPDwvUGF0dGVyblR5cGUgMi9TaGFkaW5nPDwvQ29s b3JTcGFjZS9EZXZpY2VSR0IvU2hhZGluZ1R5cGUgMi9Db29yZHNbIDAgMTUyLjY1IDcyMCAxNTIu NjVdIC9FeHRlbmRbIHRydWUgdHJ1ZV0gL0Z1bmN0aW9uIDEyMSAwIFI+Pj4+DQplbmRvYmoNCjEy MyAwIG9iag0KPDwvVHlwZS9QYWdlL1BhcmVudCAyIDAgUi9SZXNvdXJjZXM8PC9YT2JqZWN0PDwv SW1hZ2UxOCAxOCAwIFI+Pi9FeHRHU3RhdGU8PC9HUzI2IDI2IDAgUi9HUzI3IDI3IDAgUi9HUzEz IDEzIDAgUj4+L1BhdHRlcm48PC9QMTI2IDEyNiAwIFI+Pi9Gb250PDwvRjMgMzAgMCBSL0YxIDEx IDAgUi9GNSAxMjcgMCBSL0YyIDE0IDAgUj4+L1Byb2NTZXRbL1BERi9UZXh0L0ltYWdlQi9JbWFn ZUMvSW1hZ2VJXSA+Pi9NZWRpYUJveFsgMCAwIDcyMCA1NDBdIC9Db250ZW50cyAxMjQgMCBSL0dy b3VwPDwvVHlwZS9Hcm91cC9TL1RyYW5zcGFyZW5jeS9DUy9EZXZpY2VSR0I+Pi9UYWJzL1MvU3Ry dWN0UGFyZW50cyAyOT4+DQplbmRvYmoNCjEyNCAwIG9iag0KPDwvRmlsdGVyL0ZsYXRlRGVjb2Rl L0xlbmd0aCA4OTY+Pg0Kc3RyZWFtDQp4nJ1W227iSBB9R+If6tGMRNPVN7slxCpcJjsjRWJmmIsU 7YOXmIRVsFljssp+/VTbJrExJigPQLupqlN1+lS1YTCH4XBwM/k0BT4awXg6gX+7HQ6ccc5RCO6D LzhoxSGNup2fHyDudhDuX2w4N8hVzWj1odv50u3A7GYCUAHAV4B+6aut8UusQCKewhKSWQuEBsZn yC1oqxlHEMwYg7DcdDuDT5vwPsIApgmcAhYl8OD6mzBwvysrQBuwQLiw1g9AIv1KkAEyX7/U0Ygl GywJpVCdyNyh+TnaYB5mWZTGsNxRKKQcdsvY+SvhM5G7Eqrh5ix9qkQeLyjiRwkUfLFypThuEAwl o6gMYxlaWGyqCXBXLj2iLB+vu53bIZf+ePQXLD53OzOKWcTF47iBID5ENe6t9yuKe3XHgzUKxaSt W0ObreQN26t91pNesun16TtbP0UtvoLKJR5bcRrs6WP2VK1KS6kgVSklC8p4jh91ip+6J0mSEWVV T+Kn1xdeK0fKMKnrHq0c6VyONdt5mhBH/+QYywx6ylvHkD1EEMVZ5IhLs3Ad5xTSDvSst8y36d/U +UDPeMkKnpN9Cssw/aMF2gjOXF+0pdmg2FwkUEHt68tXii+XYNXTSfB60UqaYkbW7c9m7l8kDqc5 pd8jjqqn92OdZvvwcf1/dAfX8+90fLDbb7cJLdKspSKpaArWw5wtKGgcBeNHqR2OQwjXSG8cR8P7 cCQVb2/2FMVOjTdJGpFA4errjSuu11fet/2WltukvUBNQ93U452t0F50ZBgYZoP2Izs6p7o5V2OO vqERLzlOfFpPOY41XVWTYs/ykRpyxFm+hbRbrkd9SWhaF2Z6ej5MYMnmyu3n4cjUhXlxn2DxN85G fTEsoA7rV0iyt2/rURO/plbmeZaRX9TTqPKb9B09XfX05j/+zNWyy8K/14/r7BnC+M4pyWmHZpf0 Vkk+3zZhvGy7GRTd40cpvVEjXiYllEyL93R/1dNb0JzOh3H0Hzw8u3G8Laby03rnbr4UNsld5EZ0 lsA9FR7lE/4hTO+K2e44gVW4c8O8ZXBzzgJThz3PgKgxQNeN00dzXPgClDaHC7d4hypfJbgmFdqr QuzmY/4h9eaNwJUqRF8ot9gn9XKaZ9QIIzk89Meor4dFGDJ34qdX0MLV12VTNEUuTqWrpGVSVdM9 wcFvWKJFfA0KZW5kc3RyZWFtDQplbmRvYmoNCjEyNSAwIG9iag0KPDwvRnVuY3Rpb25UeXBlIDAv U2l6ZVsgMjU2XSAvRGVjb2RlWyAwIDEgMCAxIDAgMV0gL1JhbmdlWyAwIDEgMCAxIDAgMV0gL0Jp dHNQZXJTYW1wbGUgOC9Eb21haW5bIDAgMV0gL0VuY29kZVsgMCAyNTVdIC9PcmRlciAxL0ZpbHRl ci9GbGF0ZURlY29kZS9MZW5ndGggNDU3Pj4NCnN0cmVhbQ0KeJyFwodS2gAABuDnsrV72zpREVEE kaGAoBDCCjMQ9h5hC4iADK1272Xbx+of4513rXf97hubNI6dv4ZTfBP/+jR3nEuMz1y8gbPETa6Z f2sOSa6AvC0g7+C8Be/yF6z3zt9fRNsDId/+cIn7SIQOfLyM1BMxd0LsnFhxPl1F1zOUuCYl7qk1 9ExLuTMy7yyu+3BO7hPIacEGPa/w44IygIuqgFDFCNXMkjoo2gyKtkLLqAmLNeEVbQRXdVGUbMfW 9DGpPi41xGWGhGwnsb6bRLkxtWFKKUxpBZFWEhmlOasis2oyp7bkNq35LbQVNPaC1s5qHazOUdRR pW2qpHeW9a6ywV3BHU9111M1emtGX92E9B6B/oY50CADTZJpWpiWNdiyhvZtobYt3LZj5MAR6VDR DhXrOjHec2Hi0I3JvgdTA2964EsPkc6M6OzIj7mjAPeYyR8zhedB7kmQPQmxp6HiaRhLLyJYfhnF Cr6KYfV1HGv4JoH1t0ncw3cpbOD7NDbxQwZb+DGL+/xPuTb/cx4P+F8K2OF/ZbuXi91vxd7FUu87 9/Byuf/jr5X+WWXwz+FZdfjzyrXhr9roP+uj3/WjK/4BqNyYIQ0KZW5kc3RyZWFtDQplbmRvYmoN CjEyNiAwIG9iag0KPDwvUGF0dGVyblR5cGUgMi9TaGFkaW5nPDwvQ29sb3JTcGFjZS9EZXZpY2VS R0IvU2hhZGluZ1R5cGUgMi9Db29yZHNbIDAgNDY4IDcyMCA0NjhdIC9FeHRlbmRbIHRydWUgdHJ1 ZV0gL0Z1bmN0aW9uIDEyNSAwIFI+Pj4+DQplbmRvYmoNCjEyNyAwIG9iag0KPDwvVHlwZS9Gb250 L1N1YnR5cGUvVHlwZTAvQmFzZUZvbnQvQUJDREVFK0NhbGlicmksQm9sZC9FbmNvZGluZy9JZGVu dGl0eS1IL0Rlc2NlbmRhbnRGb250cyAxMjggMCBSL1RvVW5pY29kZSA1MzIgMCBSPj4NCmVuZG9i ag0KMTI4IDAgb2JqDQpbIDEyOSAwIFJdIA0KZW5kb2JqDQoxMjkgMCBvYmoNCjw8L0Jhc2VGb250 L0FCQ0RFRStDYWxpYnJpLEJvbGQvU3VidHlwZS9DSURGb250VHlwZTIvVHlwZS9Gb250L0NJRFRv R0lETWFwL0lkZW50aXR5L0RXIDEwMDAvQ0lEU3lzdGVtSW5mbyAxMzAgMCBSL0ZvbnREZXNjcmlw dG9yIDEzMSAwIFIvVyA1MzQgMCBSPj4NCmVuZG9iag0KMTMwIDAgb2JqDQo8PC9PcmRlcmluZyhJ ZGVudGl0eSkgL1JlZ2lzdHJ5KEFkb2JlKSAvU3VwcGxlbWVudCAwPj4NCmVuZG9iag0KMTMxIDAg b2JqDQo8PC9UeXBlL0ZvbnREZXNjcmlwdG9yL0ZvbnROYW1lL0FCQ0RFRStDYWxpYnJpLEJvbGQv RmxhZ3MgMzIvSXRhbGljQW5nbGUgMC9Bc2NlbnQgNzUwL0Rlc2NlbnQgLTI1MC9DYXBIZWlnaHQg NzUwL0F2Z1dpZHRoIDUzNi9NYXhXaWR0aCAxNzU5L0ZvbnRXZWlnaHQgNzAwL1hIZWlnaHQgMjUw L1N0ZW1WIDUzL0ZvbnRCQm94WyAtNTE5IC0yNTAgMTI0MCA3NTBdIC9Gb250RmlsZTIgNTMzIDAg Uj4+DQplbmRvYmoNCjEzMiAwIG9iag0KPDwvVHlwZS9QYWdlL1BhcmVudCAyIDAgUi9SZXNvdXJj ZXM8PC9YT2JqZWN0PDwvSW1hZ2U3MiA3MiAwIFIvSW1hZ2U5IDkgMCBSPj4vUGF0dGVybjw8L1Ax MzUgMTM1IDAgUj4+L0ZvbnQ8PC9GMSAxMSAwIFIvRjIgMTQgMCBSPj4vRXh0R1N0YXRlPDwvR1Mx MyAxMyAwIFI+Pi9Qcm9jU2V0Wy9QREYvVGV4dC9JbWFnZUIvSW1hZ2VDL0ltYWdlSV0gPj4vQW5u b3RzWyAxMzYgMCBSXSAvTWVkaWFCb3hbIDAgMCA3MjAgNTQwXSAvQ29udGVudHMgMTMzIDAgUi9H cm91cDw8L1R5cGUvR3JvdXAvUy9UcmFuc3BhcmVuY3kvQ1MvRGV2aWNlUkdCPj4vVGFicy9TL1N0 cnVjdFBhcmVudHMgMzA+Pg0KZW5kb2JqDQoxMzMgMCBvYmoNCjw8L0ZpbHRlci9GbGF0ZURlY29k ZS9MZW5ndGggNDk5Pj4NCnN0cmVhbQ0KeJy1Ul1P20AQfLfk/7CPNhLr2/vMIUQRCUVUQgpgqUio D5Fl0rSJ08aB/v2unTjY2NCnPp327mZndmYhmcLpaXIzvp6AODuDi8kYfoeBAIFCCJJSOHBSgNEC NnkYfD2CIgwI5oc/QlgSuvPp6SgMbsMALm/GAC0CeiU43mONt27PNVJEQ1xSoffAbGAdkvBgvEFB INFaS5CtwiC5Xs3muZMwWcMQsfzfk6kegdSa9ABBMp1tt/mmgKzkBqQMlFlRoZQQSKpGkCUk/yGh bhHutAqh/uGktB6Nq50k7VARKGIjJRA59KOWk75r5P2vWXFgNnvmi5R/f+YYHKRPlXF1Xx7DojAg yVdHutoZYjlA9Jpgw/YmV/c86Lx883R3FQaP0d1zWebLJU5nL/GxjJaLLP95/pAX001sovWPPNvi unrYzONvkH4Jg8t0wB7bEtkos1aj6gqrs65podWtJ5hnYpxFtophitfPmOZiGQZ6ZJBatXEabftD xSwHatbTBTQXTcemPlAeLmpFTfV9tyc9F1wvKuS9HIqLRrx8+tWVxyj9s6j2lE0/gdhG5y1/2qZq KdF38BzheBqraPayXFRBcX7vYHk70XWh8FGoo844EpRFbzvTSENoNT9oNE3L2+e83C7WRfnp3REU ujegno6/r4UM9g0KZW5kc3RyZWFtDQplbmRvYmoNCjEzNCAwIG9iag0KPDwvRnVuY3Rpb25UeXBl IDAvU2l6ZVsgMjU2XSAvRGVjb2RlWyAwIDEgMCAxIDAgMV0gL1JhbmdlWyAwIDEgMCAxIDAgMV0g L0JpdHNQZXJTYW1wbGUgOC9Eb21haW5bIDAgMV0gL0VuY29kZVsgMCAyNTVdIC9PcmRlciAxL0Zp bHRlci9GbGF0ZURlY29kZS9MZW5ndGggNDU3Pj4NCnN0cmVhbQ0KeJyFwodS2gAABuDnsrV72zpR EVEEkaGAoBDCCjMQ9h5hC4iADK1272Xbx+of4513rXf97hubNI6dv4ZTfBP/+jR3nEuMz1y8gbPE Ta6Zf2sOSa6AvC0g7+C8Be/yF6z3zt9fRNsDId/+cIn7SIQOfLyM1BMxd0LsnFhxPl1F1zOUuCYl 7qk19ExLuTMy7yyu+3BO7hPIacEGPa/w44IygIuqgFDFCNXMkjoo2gyKtkLLqAmLNeEVbQRXdVGU bMfW9DGpPi41xGWGhGwnsb6bRLkxtWFKKUxpBZFWEhmlOasis2oyp7bkNq35LbQVNPaC1s5qHazO UdRRpW2qpHeW9a6ywV3BHU9111M1emtGX92E9B6B/oY50CADTZJpWpiWNdiyhvZtobYt3LZj5MAR 6VDRDhXrOjHec2Hi0I3JvgdTA2964EsPkc6M6OzIj7mjAPeYyR8zhedB7kmQPQmxp6HiaRhLLyJY fhnFCr6KYfV1HGv4JoH1t0ncw3cpbOD7NDbxQwZb+DGL+/xPuTb/cx4P+F8K2OF/ZbuXi91vxd7F Uu879/Byuf/jr5X+WWXwz+FZdfjzyrXhr9roP+uj3/WjK/4BqNyYIQ0KZW5kc3RyZWFtDQplbmRv YmoNCjEzNSAwIG9iag0KPDwvUGF0dGVyblR5cGUgMi9TaGFkaW5nPDwvQ29sb3JTcGFjZS9EZXZp Y2VSR0IvU2hhZGluZ1R5cGUgMi9Db29yZHNbIDAgMzgwLjczIDcyMCAzODAuNzNdIC9FeHRlbmRb IHRydWUgdHJ1ZV0gL0Z1bmN0aW9uIDEzNCAwIFI+Pj4+DQplbmRvYmoNCjEzNiAwIG9iag0KPDwv U3VidHlwZS9MaW5rL1JlY3RbIDMwNi4wNSAyMTEuODUgNjY0LjMgMjQ0LjczXSAvQlM8PC9XIDA+ Pi9GIDQvQTw8L1R5cGUvQWN0aW9uL1MvVVJJL1VSSShtYWlsdG86UnVzc2VsbC5QYXZsaWNla0BY ZW5Qcm9qZWN0Lm9yZykgPj4vU3RydWN0UGFyZW50IDMxPj4NCmVuZG9iag0KMTM3IDAgb2JqDQo8 PC9UaXRsZShYZW4gUHJvamVjdCA0LjQ6IEZlYXR1cmVzIGFuZCBGdXR1cmVzKSAvQXV0aG9yKFJ1 c3NlbGwgUGF2bGljZWspIC9DcmVhdGlvbkRhdGUoRDoyMDE0MDMxODIwNTEzNS0wNCcwMCcpIC9N b2REYXRlKEQ6MjAxNDAzMTgyMDUxMzUtMDQnMDAnKSAvUHJvZHVjZXIo/v8ATQBpAGMAcgBvAHMA bwBmAHQArgAgAFAAbwB3AGUAcgBQAG8AaQBuAHQArgAgADIAMAAxADApIC9DcmVhdG9yKP7/AE0A aQBjAHIAbwBzAG8AZgB0AK4AIABQAG8AdwBlAHIAUABvAGkAbgB0AK4AIAAyADAAMQAwKSA+Pg0K ZW5kb2JqDQoxNDQgMCBvYmoNCjw8L1R5cGUvT2JqU3RtL04gMzg5L0ZpcnN0IDM3MjUvRmlsdGVy L0ZsYXRlRGVjb2RlL0xlbmd0aCA1NTA1Pj4NCnN0cmVhbQ0KeJy9XVuPHLeVfg+Q/1CPuy+Z4p1c BAES28F67TiGpMU+WIExtntlRfKMMBoD8r/f72MfdpWmipcpZedBak51nwvP5eMpsshSVk/zpKyb nMaHn1SI+AyTtvw7TmbGNTdP1hh8qslGh+tpcibgbzP5OeFTT94rXFdT0PjeuSkafoYpRvBz+Dcr XPCQNUf850ClMkuLRsL3HvI0mXtcMYZXKIn/eapgQBUyJa8kfg2KABZBscF/vBzwddRsgE+M7BE0 TblrftLznCnQ8Gj4OGmVZaHHena5+1pTDvqjDflAXW2NJlc0qGE0k/YUGi0aZI9O6kCLRfAJCVQJ VJG9jGnSSUF6AlUKbGhYlX1HT8yc2LCToZFVUpPRCg3obXRWHA3DnkKwsdQwBTTopZAmk90AecZb CJxB7ilnhoioecWgAVI9gyo5XvGTnfEXxdiZ/YYHrdLoCrpkc58U/KzhTK0sHD+zYdCAG/UcJ4sf TTSWtVkWfuPgWI1OWg/3a3jaemoIv9pg8RsQ2AgXwMZoQF+t1eRmzSsaDfRb4w+nHK8wGCFQw/pO BzYi4g0BAM+gQdMakEM8GvPkHPqkYVDnPBtg6DWpLBr0Ff5wIX8FztHQsfgq5p6CYcp8AkIZdtYm TV6hcxoG9WRGQ3h4Dg03eeN5xU7eqsRwQCOwAXJnIAIm9g5O02DqcQlXkByB3UH2IFgYTX6CXmgg T3yiLCSKTzQv/vmUeMVPYQZ7DcsGRYMjIAMzS0ODQKdphFcgM41QDoYeRDYFwxCG4MDcQeROwdEp iM7gZwhFfsEYuAJ1A9NVwzQhaoqIaETYB4kU55lBPaNBFyCbIjOF/oiMXI1QjuyBDsx2xA4CH43A Rpyihfc0eEXLDEASRUdV4Y/o6S9kU/SenAESgf4CZQyJIkAVKRQeiolCoS6iBi5AXiTFXiDjEvFH g3sie42wSAYu0simZBWvGDQY4fBHQiSh4dCg3xGCyVs2wCcwwsEd2cmGnlLOHQRlijlH0Ujwg5kJ XzN9SRhAFhEfDbENHTVMzpmhlTFzNp7XkJ6zRWgb5BRaTHDm9+yIrYq0fmZLs4VuGsLkTLcYJB9a kWiRCJuWLSJpQtQaRc6J3xJcII6KgouieYwivubsR6Kh5Ygn/NZEXoNcZakBjKIA67xGLg7+ZqIp 5fF/hj9gJKQhOhQQFS0iITCRsETOES40xHrAGltnOCcXcAY2sOXZImwht5TmqJDxXRNeDIFQM7wM Rw6YD2CGUFYZc4F4bJFWkcKRljiLmAVny98xt+h3jB6URqDXTCpDQIVbeQ1yYZxAvGSLPULkKpgY 38I2aAVe49BDSDGQg0GIliT2GtIZ5K8yWSviOpiyBa1ARgDm7zga0u9oIakMhzskBFqWvwsZw8k5 ItMMByCTDLUnRUK4mjzmzQR9xC3G08yZIzLTzXB8s/y14bhnLb3Agc9aeoFji3X0AsdA6+iFPJpz bDAcTKynJTkw2kBLBo7ZEdY2HPGQqODM0dkmxkvgyD7nHlm26CPEG8KFtoq8lm3FXHC0mOFo6yzi zIATWrQzxzfnqEEihSNtIpccYSlXCbRz4tgeaOdIuZF2PtcOtHMMeeSHfugBygjEvIGV0IJNDLIP 4zUzj0OvJ5jbmdcICpZZAbjmNQ756DBa5OIsr5GL5yDGLIPb2MoVATLHMmsxlLHFmiAibq3KhQPH NmYtcBvDHbM2sMSxzNqABJ4oEZWGYYvFByuBPIAHjg125u8YFxxNkVqM4pRb8K3VrHYwaE20JgoX ZKJl1obgeI20kfoxLwOrHMtMDslynGb9wDrHnssXz+qNFYTi6MusjfQgUQk1DW2lc1HD4Z/ZGBkr HN5QCyB3LbM7YthFi6WOS5QRWetQA+Z0DPCPtaTFD9GitMQqgnkZE63BXE0zdLPMgMQh3zJXE2Pc MgNSLkmY8Yk4z+EdRZMjLWsJesoSX5IlP2ZjyhZiTidGk2X+poCctMzuxMi2zFXAOL8ll0SLcwyf GdmWgD+zCkKSsH7S/JZFDSuwPHbMHNuROKylEFM25KoKWtpcRTKqqQ+gDraj79CifoH8HG3gc7XE GjqwEGNRYFmNzAiTKQ/Sc7YfayigPLXPVVnWnr9Lifxyyca+sYwFzIML6znFOjDXIIqDq425WqNX Wa/mAtqyCEKKUnsWvC6d63hUbKRlzYpQJC2/jZ7fkl9CTOUSTxGbiHeskfEt6xsIhlYsBDTrcgs7 oJajDA7hmqMncVtnRHccYTVzyHHw1rSJzWWgY5E3s0hDorMkZCEIi+eaDuUHKj8WSJr1m5spI7II ZG2CGoAtymB5T1sDj/C34+CPQZgULO1U7ge/ZX1uc/3IcduxaDFEVcuawDBznGLLsUBUuWKETQB4 LBAVZUS2YFnH8s/QW0RcVI3wj2MJZolNTrNKhIOnc+3FOyPUtGwlVresD1m1OZ1vLliFsjyxxE2O xqgw82gTWXSexwkWm0QK1vkwCTGcNWXGJUaJYwwoxq6j5qxI0MoFOil89jyLxsCazeRak9UtYxwl MH7NOPCsyQ3tjKEMoxX187wlM5TmWaganytOR+TnNSKFPReWsJVlL70jYrIcRknDzMty+DsWaj4y ciK/jYwNxRKU1e8f/3j1bb6JnKdnV8+vnr+7vrl68du709Xz+7tff7z/4u3pl6tvX00mf//VNP/p T7//3QOav75+9evd6erPb+//7bP/ePnyv9+f7t6/fPn2+u79mz989uWLZ1+++OLly89P79/c3757 +fLD6eb7d3e3/zz9eP/929tXt99jTPjgwx/e3bz692kj+qvvJvWP6aJBW/o+vf5EejNMf6T3yM0P SPB69+2++CTiv92jcQdofLubL04f7n+4/bDrIIQbfpSnKvC5y8fpluzwCbJNVSbyTYL67eufTrvU eSbmWZ6LOX96+QzyGeUzSQ91vYe2k0LKb3PoQvQ0OXRWoS2+mUQbBs2QMh2pLb/6ebH0QwYDjnXi UCeOdOLIs8L7bH0PBLXeetA/LQqeVWiLb3rwOANTYVBC4Ou/3P70WwPBNoTFi19/udvhsIqAh7RB 94S6CqHqCDUNobYn1B8U6hpCfU9oOCg01IUurtknFdQ8G6ToWGEVmqy8AGtQDRYj48BZ5eMM4j7p ANR4sYYXa3iBHi9jiRcICg0NQ0miav3lttBzIXqiAsxVdB6uwA4zMPsM4iW2OtCzIbwk1X5uxJWr NrRdvHPHhKa5LjR18c5XCDsokExDaBfvwkGhrmHei5X2SSXZzrpVWLgmiyj5GAV6khpgtVvfxE5c t/AqCjokX5c+wijtkw7gVpSqPYpJo5FPwbEoOJZCI0QuYmq4lba4dSF6ItxKFZ2HceswA7PLgMuB g7j1kPAS2buJxQXHxVUPaYdx6yFhu07jBGJVqFI9of6gUN0QakZx67FCbcO8TdAR6xeDFB0rrGyb 1Rk5RNtOiDaQQ1Su2HAI+I5IVb6u9gBqJTHkLIactXwa+bRi4FbnSt1QQy27ne5aiJ4Gtayp6DyK WscZmH0G+hLhHdTaEF7ieT+t9CoiNrSxJ9RVCENHaGoIbSegjnVSMw8C3mONZFRDaLc6DAeFmoaR TNtI5+pB/FAMU3TthGgLP7RtGKL0p4Vah6QaV5U6gFp8FudsDbGCFvTSgl5a0Mu0OleqhipqhS1q XYieCLVCRedh1DrMwOwzsN2bGFshvMT3fm7YdUQ8pO3emLoKYfseUdvYENot8PwxoW6uC3XdAi8c FKobPW1Dj0zei0GKjhX9e7P2l6SKQpR/8/e//Nezq7//8M/pvPywy3k4XdOOOl+/vnmzbxfpnKtF wgP9bFW/3pTTRT8177N2VdbdXnjBQS846BveHneRUiuq7k2AljUC8VSxSH6ybyD0KmFrG7SXYXo/ bKVytUWdhhoXWGyNWfYTGah9TB4Z70wZ9cWkVvxtxd+y7qZ9w1zedfzutgtqC9HTjHfOV3QeHe+O MzD7DEI37m2FULcjO6xctaHt3hq4g0J9Q2j31sBXCDu3BiHVhcZufR+OCY2qIbRb38eDQk3DvG20 ClLRyiyi6FhhpdqspPgNgsfrlalqfrSALzR0GWGQdklHcE/WfLQX68jylg5ipSD4FxvJFHu4dx48 P8a9+LS4d1ahLb6Je8cZmH0GaRT3NoQdCFqvNGxoR3Hv0UJ9Q+go7m0IO2iQUkNoGw1SbJC2sz9J 9ifJ/vVyQzVKWtmfdJUBHy6f6xME4bhUM6uq1BHgkOUgHQusCnAkAY6zEUsHKp0rPqoCx7ZgWoie CDh8Redh4DjMwOwzUN0R3VYkX+63d9PJqHVEPBQ6+vzKo4WahtDR51ceLdTVhc7NR0nE+sUgRceO q5t5mBoGKDc9zew/IlWFqtSB7DeyeGHOKzJ5L9P5M8hnFOv4Rud6S7FhWzYsRE+T/WGu6Dya/ccZ mH0GenQpdkPYXoo1ehURG9rRpdgNYXuB0pi5IbS5QGnW6yEPSc3oKu5jjbReDNgIHX36ZEPYnqIx 66n8DW03HOJBoY1wMN2CLh0U2vBpJxzO1i8GKTpWWDWXyyTFSvCWaCrad/K6Bbq64cgRBmrepR0B bJWkT9IXWccxso4jJslbKasqdvdchJ1y7Yk3XQRf0XkYsA8zMBUGo48bbwg72Lle5XhI63qV9cVV bneqXCZw9jj3JrcvnP2OOrX5dSNT28b5f0WnwoqoOxQYJzngJAdcqOvQdYpu6N+FzXhQaKoL9d3+ pwrh3BbqGz217RraqwZp8/Fryabi1mLTom0nhVvYvF6oPMLggs2PL6ZlbcHYgsGSC7KuIibJW8Hr bu6lZdw+IbQQPQ02R1PReRSbjzMw+wz6uzJshbD9wLBZ78rY0I7OwW0I2w+/mPXaw4a2u8DvDwqN DaHNiTQxRNGtwmJus5DUWa/1VKOklf7r7RwbHZp7xsInSI1zVeoIcMjGDeMLQBQwFJCUSXyzXh96 qGfsFXVx+0D0QvREwJEqOg8Dx2EGZp9BmketZnfrq3R5CmPDuVfkXDi7HXWq9ZVMWpv14sDxTq1K u/7uElOmgmUrhFnvpth4plPqrPecbGjbpUNMDdKREmG9yWZju5GZukNS18sLDxiMYIRsljCyScLI Jgkj8/ditNKBSud6M3Wy8eYjjHjiTRNnFdrimxhxnIHZZWCHN01sCNuTUHa9aWJDO/r48aOFprrQ /oqEPyZ0vSKxETr6DPGjhZqG0O4cXzwo1DWEdgMpHRTaCqTmHJkEd4m3EgLFK8VQRfdOhjXgz851 wwwxKPdlD2hHoFN2bljZuWFl54aVxQ8xUT6aqe673kOL0oc1dC5ETwSdsaLzMHQeZmD2Geju3Yqt ELYf0rXrnRAb2tFFjscKXS9yPKQdXql4tFDd6GlzKl2sXwxSdOy4upXD6/0yRxiEXdKBFLayfcHK dLeV6W4r091iiXyiWd1F3XNS5u0xGwvVEx2UMuuK1sMnpRznYCoc7Oj0ypayPb9i108Kb4m7g7Q7 Kta1xHaHaX9UbGiJbc6QiA+KUYqWPZe3stmqljYlJ1v3QQflprrcESwwJdcF3oyULvLItxiydKGi qevdI6t5uwi2UD0VGPiK1uNgcJiDqXHo3pnYGmX7MUD70RFJD4n76x+uRtleALHrBZAtcffpTn9U rG2J7e3hWcKzrJF9PDGl1GXlb8u8Nw2wMN/fe6SU2Wf+8Gd27Gdu7Ge+3qMLZFfmzaxMpVqZSrXy PLSViWcrj4Lb8C/ySlpR9bcvy8SveCYfHdrQohdYvkHsmnNrkmUl7IvuNV6+yUuW9OxHB6pV8ag1 YrjQ4HA5p2p3pCq3jccEh4bgkaFKVjetrExbWZm2skouFix9qHWwm65qu/92oXqioUqFitbDQ1WV Q2tWdZ92xDdBECGKj2SC1a63pmx0it17CL1dn12onsgX2lS0HvbFcQ6mwqF/kJStUXaq6vVJUlvi 0UXaLWV7wdSuJ9obOu/Tuhbt6BLv4y0V62J5VHNHbKiJbT+l7dY7FB5pKdGqpvLo9rTHWsrNjZhy czemUo2yHVNuPh5Tbm7ElJu7MXUZKB9tqlZQ9VcUVAW0XOfZf6c+IapUI6psat+Iy+qn4ENJ15IF JSiLr4vpS396+NqqRlKrxyMcVAXeR4ZLWW+0ss5oZb+Qlf1CYrV8ynojHMrdVHX4NNspuIXqiYZP oytaDw+fxzmYR3D4/zz1+2MFHtyJmeVO7KGeuvfYw+Jht6K6pGvl/s3JhK9bH8KzFd57BmYR7ldU za150qN8tH9D8sj2vrpTGzkrncqvEajLH+EU92kHkt/JKqA734LnVyScP6N8CvbJNL1b70HZiaQz 9xd3p9Oz29v7q2e3b09/u36X33uQ4+r67nSTv84vQMgO+66cyl5O8S6H65bDKsshcOVYpXLSRNl4 XXZTln1V5Un98lRoedKrPM1RViXLykaZ3Cx3juX+pCBv8QE7fdH/G3jjq9Nvk9HS/b+ivze396er b/jfFzc/LX8Uzz1Hrl795+n6p9PduU2a0v7y5u3rm9Pzn69pRV748w04XN+/vr2Rv+/uX//vNRr5 r/+5vXvzw+3tm6vPb3/89Rcola+8//l0uqeW91d/u/7x7nb192c/4//V35+/vgZsrC6cY2T57VkO fvbq7voXASfp6ze//vL+u2nOr67IDsqvrsiuyK+uyEbOr67IZsyvrsiGzK+uYMvnV1ewFS6HpcTL cSnp0uIbQMphx+dXW+Smzu+2yE2TX26Rm+e3W5wj6fKsON8wVI5NDvlVF7kZLw87yWsvsvZzfu/F Odbyiy9yU+c3X5wj7zKTw7e6lKZbmn5phqUZ8xszcjPlV2acwzW/M+McsQWN/jHRxo94jcDHL0pY Xl6QmdSOrC8TN/lHvcOmZWJNzjEvR4uX076XQ6gzs+4JsKKBFBVyWHA5v7ecXbucEJuZdg9oFFyQ RxzkJM9yuOZyPiSZ9c9NK14XobK3SA6uW45ty8y6h9IIQtkSKfJ9iafLeUElfMrhRSKsTCVnYd2T IKS7QX4n8CnngJSjOZaTIjLT7i5xYSqOkR39y+Z0MuluNpUjSmUrcdndu+xxzUy6G6CEmRz7Jzv9 yua7sh+ubFFbNkpl5r0n+MUxy06Tcl2YCh7JnorlSf/MvPuUrzAVx8gT2cvDxZlJ7zHAyzOa8r1k jFlnSv+BGKnx5exYeXyrPFFVHnIqzx0tD86QeX+pvizXye/EQZel+8yku8YnTMVBsrK6rC1mJt3Z V2Em3pIVmWU2/rJWIL8PKxt2pw/zj7o3TaKZpI1M0JQZkzINUeYFyr12ufddbrYobLxIk9/JMxNS WC5F2+9/939WC1BrDQplbmRzdHJlYW0NCmVuZG9iag0KNTI4IDAgb2JqDQo8PC9GaWx0ZXIvRmxh dGVEZWNvZGUvTGVuZ3RoIDMyNj4+DQpzdHJlYW0NCnicXZLNboMwEITvPIWP6SHCNgESCSElJJE4 9EelfQBiLylSMZYhB96+ZpemVSyB9GlmzJh1WJTH0rQjC99cryoYWdMa7WDob04Bu8C1NYGQTLdq XAjfqqttEPpwNQ0jdKVp+iDLWPjuxWF0E1vtdX+BpyB8dRpca65s9VlUnqubtd/QgRkZD/KcaWj8 Rs+1fak7YCHG1qX2ejtOa5/5c3xMFphEFlRG9RoGWytwtblCkHG/cpad/coDMPpBF0vs0qiv2qE9 8nbOJc9n2hyQNueZhDghJTFSvCfaEh2JdkhpQnQiWjTaZbtDSjlRQSSRdpwoQjrERDFWXzreG/+e UBQYEoUgd7K4SY8fDiiKlGxYNIrpE7IgmqtJLhOkdIMkIqIDafJ/mfmPzoO/j0vdnPOTwtuBI5qH 0xq4XyDb2zk1Pz/EsK6LDQplbmRzdHJlYW0NCmVuZG9iag0KNTI5IDAgb2JqDQo8PC9GaWx0ZXIv RmxhdGVEZWNvZGUvTGVuZ3RoIDk1NTE2L0xlbmd0aDEgMjAwMzA4Pj4NCnN0cmVhbQ0KeJzsfAl8 VNX59jn3zmQms2RmkpksM0lmkiETIIEAYQmLZCALS9iyDCaBQELCpiAQVtnE3QaptOK+17riMhlE o7igxaXWrVZrq63Vaq1tAXFtCyT5P+e+94QA1k+/tv9+/X05k+c+z3nPcs957znnvmOCjDPGPLgY 2KzS6imTjq3/oh9TPjvImO+ysomlNVd9NP9Dxj5FJe/OsonTSla9cnsOYx/XMma+e1JpWfkff/L5 caYcPs6YenjSrJnVS1vGXsC4dSfjN9omVUcmPvvuB91MuetGxibNm1ldMOzvH/46nTH+K3TY2Ly8 aeX6dVvvZ6z/FxjA3OZ1awLRGw68zlj9ZsaM6YtWLl7+1VfTbYwNmsVYvHdx0+qVLJ0Fcf/JaO9c vOzcRQ8N/mQeY/OvZWymYcnCppaPcrrOQP9zUT5yCQz2+03oi+9Cvt+S5Ws2FL6feZgxpYix0GNn L2w9Z3Pn4vcYewlztOcvW9HctO3q5X9n7AGMN7N8edOGlVkjcgahfQfaB85pWr4wtK4SY33byVhC 8soVq9d0+9glGE9/Ub6ydeHKsx9UunDrZbidkwnfGm/uWFvmN813jPuSpZmZSPv+svklwc9mX7vx 2NHO7fEHTQ8jG88URgnt4lgX4wcstx47evTW+INaT72SYaywOLLZxczIFgEKc7ICtpAx107cV0Wp asjjO1FiNl5nLESXmcTqa+wShZmZ4jAqimJQFcP7TOkOs/u6tREgTa8OBFgY0ymlMZhuVkIBxm8R ZeojxgQxU/SecGI0/FWM6DbxXL5bMtSz+wylrOlryw6y+3rn1Y9Pzv+jpN7P7jPa2JzT+jt+or1i +HZ9ndS+P7VRG76+bdxbuO/Ary8zTmPN3+le2dSPcQFrNtSe4of72aSva6N+xBwn3TOb3fut79fG sk2Z7IzT7LlsCPrN/Lb99KX//5L6Jpv7XdsYhrPr1AWs/lvWbTzpfsdYw7dpp6xiOd91XP+bST3A RnybesJXUvNf4rz/Don/ufvNnvvdflI/131d/bgWdl3v+502lqJv98x66ut9iWeovHhyv2oWq/w2 fSgPsKzvcs9/JmGcu75tXfUmlm3sOP0ZquvZAPUWln2afQCr+2fH15f6Ul/qS33pvycpN3CL1Ore b35/8242UGvTj+1TjOwa4yXs6n/VONSUU79D6uNbzcq08uPdX/3DtsfZ0z31l7OLgY3/qnF97f1G sO2986bcf+fd/r0J35PP/k+PQSSMYzLwANAKLAaGAAvF+IBmvU7Vf2p8yk2s6F/aX3t3xT/bB+K7 yf+KsfSlvtSX+lJf6kt9qS/1pb7Ul/pSX+pLfakv9aW+1Jf6Ul/6X0uqjnT6rQgv1/5mjqnDmIGL 38H0YwFmwIcxO8tmOWwAG8XGsCmsjm1kt7L7A85AUiA7EAqUdndr/dlRP4f1Z/lsNCtmFazptFq8 +0vGDG519olBdDcrz36w4IOmD+o+KPzgQ/33MwH9OpIVsWlsyekjV6eq16gRtVWtVZepB9VD6mH1 E/WI+qn6mfq5+qV6pjpdvQEjd7FElor5hVguRlXAxrHxrJSVYWxnYhb1bB5rQe+r2Rp2LtvIFe7g Tu7lmbw/n8XreQNfypfxFXwtX8e38O/x7fxyvpNfz/fy/fxp/hx/nr/E4vhBbUSfnvabJc4U/W8Z FfbNiZ+YkxCG0Vp2q3qexv9glijBPHsc8vXzZd8841OG8X8z/39DUjf9i/qp01a3zK05vYah/3fq sG9XfMtVEZ7UMn9ew9w59XW1kZrqqspZM2dMn1YxdcrkSeVlpSUTJ4SLx58xbuyY0UWjRo4oGDwo v38op18w25/qdjkddqsl3myKMxpUhbP8smB5YyAaaowaQsHJkweJfLAJhqZehsZoAKbyk+tEA41a tcDJNcOoueiUmmGqGe6pyZ2BcWzcoPxAWTAQfbk0GOjg9ZW10DtKg3WB6CFNT9e0IaRl7MhkZaFF oCx1SWkgyhsDZdHydUvayhpL0V+71VISLFloGZTP2i1WSCtUtH9wZTvvP55rQulfNqZdYWa7uG1U zSlraonOqqwtK/VlZdVpNlai9RWNK4matL4CS8WY2fZAe/7+tss7nGxBY56tJdjSNLc2qjahUZta 1tZ2adSVFx0QLI0O2PhhKqa8MJofLC2L5gXRWUVVzw141JjjDAbavmQYfPDQwZMtTbolLsf5JRNS TLHHTSiXmmFsGCHml5UlxrK9I8wWIBPdVllL+QBb4IuxcEFeXVRpFCX7ZYknIkq2yZKe5o3BLPGo yhr1n3VLUqPbFgQG5cP72k8OflAeiKqhxgXNSwQ3LWwLlpaS32pqo+FSiHCTPtey9iEFqN/UiEks FW6orI0WBFdG3cGJVAGGgHgGS6trtSZ6s6i7JMoam/VW0YKyUjGuQFlbYykNUPQVrKx9lBV2v9c+ PODbU8iGszoxjmhyCR5KqKyttmVR1N/oa8H6XBSo9WVFw3VwX12wdmGdeEpBZ3TAe7hdlnZHrRXm dkptWVnM3JRjDtQqPrVOPC0YAuW4BCeOQ4ETj0vLiic6cVyglvuYrIa76DWEOqkfZNScksmiSBVN Syb7suqyKH3DkHz6mIw5UXOvvpww9IyJ7vMPh0a1xYAGBMoWlvYa4EmdGvUB6r19/TgV4Qv9xmhh Fo9zsixSc7BzYVPQjWYSTzE1EGWzArXBhcG6INZQeFatmJvwtfZ8K6qDFZX1tdrT1ldJzUk5Ki+i XJRloVhmlBKswfI8n3ysWn6Slu/JTj6leIosDrSZgxXVbaLzoN4hC2AHYdJxoSlN24sSh2NrluN0 C5Y3BfFiKW9r6ujetqCtPRxuW1nWuGSM6CM4paUtWF07zqeNtap2i2+juFUiq+AVNRMH5ePsmdge 5JdVtof5ZdX1tY868aa5rKY2pnClpHFiXXs/lNU+ildQWLMqwiqMIhMQGdFTFTJmrb7v0TBj27RS g2bQ8s0dnGk2s7Rx1tyhkM0pbQpsBrKFNZtIeEipS+BiHLdlgRbxeDbXLWlrrBObiyXjUeKHR3lw PIsqwfHtXImzRS3BhROj1uBEYS8W9mKyxwm7CQuDJ3M4R5xJbY1BnFNYULXMx2kpqqLLQEd3d01t 1su+Q3VZWGpzgfraaHwezn5jzlTUmyTQCPOk6LbmJjEOFqkVbU05U5rrsGxlh6gyJRqPHuL1HlCj XGsjliMaNePZ4AFq7bchE91WF63LEzetXVqnLWdnlE0OjsFjpz6NIXGjgrq2xOAwbW9iK1hyLhUU j7Gx6lqy+JDFzerISSYbRt4cRFFzYwDeNrDmaix1OkstPrIsxJFoCC3UYPHphUxMS82x2i3R+MHo ED9CWweLLWnMMdXV0eC13KV6BdzbGbViRKFertQbwDsomiLGgp9LMVRR9WnRTWUHqwpuwMkiBq31 ZEJx1J4zpQmHP7W3whIsko3N4oyw6n0cIKtJzNwGv6s5NR3ddwXPzeqVBuUHxctBLEzmexQLm9W1 nWqIzskblG8+1WrXzG1tZvvXNyB/me09LIyBMrw1GIvFq4EO5aKH4lP5VIgLpbhAivOl2CbFeVJs lWKLFJul2CTFRinOlWKDFOulWCfFWinWSLFailVSrJRihRTnSLFcimVSnC3FWVIslWKJFIulWCTF QilapGiWYoEUTVI0SjFfinlSNEgxV4o5UtRLUSdFrRRnSjFbiogUNVJUS1ElRaUUs6SYKcUMKaZL MU2KCimmSjFFislSTJKiXIoyKUqlKJFiohQTpAhLUSzFeCnOkGKcFGOlGCPFaCmKpBglxUgpRkgx XIpCKYZJMVSKIVIUSDFYikFS5EuRJ8VAKQZI0V+KXClCUuRI0U+KoBTZUmRJEZDCL0WmFBlSpEvh k8IrRZoUqVKkSJEshUcKtxRJUiRK4ZLCKYVDigQp7FLYpLBKYZEiXgqzFCYp4qQwSmGQQpVCkYJL wXTBu6XokqJTiuNSHJPiqBR/l+JvUvxViq+k+FKKL6T4XIrPpPhUiiNSfCLFYSkOSXFQir9I8Wcp /iTFx1L8UYqPpPiDFB9K8YEUv5fifSnek+J3UrwrxW+l+I0U70jxthS/luJXUrwlxS+leFOKN6T4 hRSvS/FzKV6T4lUpXpHiZSlekuJnUrwoxU+leEGK56V4TopnpTggxU+keEaKp6XYL8VTUjwpxRNS PC7FPikek+JRKTqkeESKh6XYK8VDUuyRIiZFuxRRKR6U4gEp7pfiPil2S3GvFPdIcbcUd0lxpxR3 SPFjKW6X4kdS3CbFrVLcIsXNUtwkxY1S3CDF9VJcJ8W1UlwjxdVSXCXFLimulOKHUvxAip1SXCHF 96XYIcXlUmyXok2K70lxmRSXSnGJFBdLIcMeLsMeLsMeLsMeLsMeLsMeLsMeLsMeLsMeLsMeLsMe LsMeLsMeLsMeLsMeLsMeLsMeLsMe3iqFjH+4jH+4jH+4jH+4jH+4jH+4jH+4jH+4jH+4jH+4jH+4 jH+4jH+4jH+4jH+4jH+4jH+4jH+4jH+4jH+4jH+4jH+4jH+4jH+4jH+4jH+4jH+4jH+4jH+4jH+4 jH+4jH+4DHu4DHu4DHu4jHa4jHa4jHa4jHa4jHa4jHa4jHa4jHa4jHZ4yR4hEDXHMsf7ETPHMj2g Cyh3fixzDGgb5c4j2hrLtIG2UG4z0SaijUTnxjImgDbEMkpA64nWEa2lsjWUW03USsZVsYyJoJVE K4jOoSrLiZYRnR1LLwOdRbSUaAnRYqJFsfRS0ELKtRA1Ey0gaiJqJJpPNI/aNVBuLtEconqiOqJa ojOJZhNFiGqIqomqiCqJZhHNJJpBNJ1oGlEF0dSYbwpoCtHkmG8qaBJRecxXASqL+aaBSolKiCZS 2QRqFyYqpnbjic4gGkc1xxKNoeajiYqIRhGNJBpBnQ0nKqRehhENJRpCnRUQDaZ2g4jyifKIBhIN IOpPlEtdh4hyqM9+REGibOo6iyhA7fxEmUQZROlEPiJvzDsDlEaUGvPOBKUQJZPRQ+QmYxJRIpGL ypxEDjImENmJbFRmJbIQxVOZmchEFBdLmwUyxtIqQQYilYwK5TgR04h3E3VpVXgn5Y4THSM6SmV/ p9zfiP5K9BXRl7HUGtAXsdRq0OeU+4zoU6IjVPYJ5Q4THSI6SGV/IfozGf9E9DHRH4k+oip/oNyH lPuAcr8nep/oPSr7HdG7ZPwt0W+I3iF6m6r8mnK/InorlnIm6JexlNmgN4neIOMviF4n+jnRa1Tl VaJXyPgy0UtEPyN6kar8lOgFMj5P9BzRs0QHiH5CNZ+h3NNE+4meorIniZ4g4+NE+4geI3qUqINq PkK5h4n2Ej1EtCeWXAyKxZLngNqJokQPEj1AdD/RfUS7ie6NJeO85vdQL3cT3UVldxLdQfRjotuJ fkR0G9GtRLdQZzdTLzcR3UhlNxBdT3Qd0bXU4BrKXU10FdEuKruSevkh0Q+obCfRFUTfJ9pBdDnV 3E65NqLvEV1GdCnRJTFPE+jimGcB6CKiC2OeRaALiM6PeSKgbTEPDmN+XswzErSVaAs130ztNhFt jHlaQOdS8w1E64nWEa0lWkO0mrpupeariFbGPM2gFdTZOVRzOdEyorOJziJaSu2WEC2mkS2i5guJ WqhmM9ECoiaiRqL5RPNo0g00srlEc2jS9dR1Hd2oluhMGu5sulGEeqkhqiaqIqqMucOgWTG3uMPM mFss7xkx94Wg6TH3INA0qlJBNDXmRlzAp1BuMtEkMpbH3FtBZTH3paDSmPs8UEnMvQ00MZZYDppA FCYqJhofS8T7nZ9BuXExVx1oLNGYmEssjdFERTHXJNComKsWNDLmqgeNoLLhRIUxVz5oGNUcGnOJ iQ2JucTeLCAaTM0H0R3yifKos4FEA6iz/kS5RCGinJhLeKkfUZD6zKY+s6izAPXiJ8qkdhlE6UQ+ Ii9RWszZAEqNOeeBUmLO+aBkIg+RmyiJKJEauKiBk4wOogQiO5GNalqppoWM8URmIhNRHNU0Uk0D GVUihYgTsXC3Y4FfoMvR7O90tPiPQx8DjgJ/h+1vsP0V+Ar4EvgC9s+Bz1D2KfJHgE+Aw8Ah2A8C f0HZn5H/E/Ax8Efgo4TF/j8kLPF/CHwA/B54H7b3wL8D3gV+i/xvwO8AbwO/Bn5lP9v/ln2o/5fg N+3L/G/YQ/5fAK9D/9ye538NeBV4BeUvw/aSfbn/Z9AvQv8U+gX7Wf7n7Uv9z9mX+J+1L/YfQNuf oL9ngKeBcPd+XJ8CngSesK3yP25r9e+zrfY/ZlvjfxToAB6B/WFgL8oeQtke2GJAOxAFHrSe63/A utF/v3Wz/z7rFv9u61b/vcA9wN3AXcCdwB3WQf4fg28HfoQ2t4FvtZ7tvwX6ZuibgBuhb0Bf16Ov 69DXtbBdA1wNXAXsAq4Efoh2P0B/Oy0z/FdYZvq/b1ns32G5w3+55S7/xWqO/yK1yH8hL/JfENkW OX/3tsh5kS2Rrbu3RKxbuHWLb0vFlk1bdm95Z0s4Mc6yObIxsmn3xsi5kfWRDbvXRx5TLmGLlIvD 4yLrdq+NGNa6165Zq36xlu9ey0vX8iFrucLWOtcG1qq2NZHWyOrdrRHWOqt1W2u01TA22vpeq8Ja uaWje/+eVl9mOTi8udXuLF8VWRFZuXtF5JxFyyNnYYBLixZHluxeHFlU1BJZuLsl0ly0INJU1BiZ X9QQmbe7ITK3qD4yZ3d9pK6oNnIm6s8uqolEdtdEqosqI1W7KyMzi2ZEZsA+vagiMm13RWRq0eTI lN2TI5OKyiNlmDxLd6YH0lWnGMCMdIyE+fjEIb6w7z3fEZ+B+aK+/T410eH1e5UBjjReMjONr0g7 L+2KNNWR+mqqEk4dkF/uSHk15Xcpn6QYksIpAwaXs2RnciBZ9Yi5JU+vKde4uJR46AhtrtOTg6Fy h4c7PH6PUub3cOZ6z3XEpXqecr7qVBwO7nB0O5SwA9UdCf4ERVy6E9RwwtBR5Q67366IS7ddTQ7b YRE95tpm1ZQ7rH6rEim2zrQqYWtxSXnYOmhIOVN5gHPGnSDVLEbBPf5y7Os9ydzI8T5vr6nOy6vo MLOqiqh51pwovyyaUy2u4cr6aNxlURapn1Pbzvn369q5UlITdYvf2Gr5i3fsYBMzKqIZ1bXRWzPq KqLbIMJCdEOwjPZkNrEub97qtavz8tbMw2Xe6jV52g9yfK3I5Qmj+Fm9BnnxWavlWd43JqoGmr8a aY00rvnmVv+vJ/6fHsB/f2pn4o8MJnQrF7EW5ULgAuB8YBtwHrAV2AJsBjYBG4FzgQ3AemAdsBZY A6wGVgErgRXAOcByYBlwNnAWsBRYAiwGFgELgRagGVgANAGNwHxgHtAAzAXmAPVAHVALnAnMBiJA DVANVAGVwCxgJjADmA5MAyqAqcAUYDIwCSgHyoBSoASYCEwAwkAxMB44AxgHjAXGAKOBImAUMBIY AQwHCoFhwFBgCFAADAYGAflAHjAQGAD0B3KBEJAD9AOCQDaQBQQAP5AJZADpgA/wAmlAKpACJAMe wA0kAYmAC3ACDiABsAM2wApYgHjADJiAOMAIGCZ046oCCsABxlo4bLwL6ASOA8eAo8Dfgb8BfwW+ Ar4EvgA+Bz4DPgWOAJ8Ah4FDwEHgL8CfgT8BHwN/BD4C/gB8CHwA/B54H3gP+B3wLvBb4DfAO8Db wK+BXwFvAb8E3gTeAH4BvA78HHgNeBV4BXgZeAn4GfAi8FPgBeB54DngWeAA8BPgGeBpYD/wFPAk 8ATwOLAPeAx4FOgAHgEeBvYCDwF7gBjQDkSBB4EHgPuB+4DdwL3APcDdwF3AncAdwI+B24EfAbcB twK3ADcDNwE3AjcA1wPXAdcC1wBXA1cBu4ArgR8CPwB2AlcA3wd2AJcD24E24HvAZcClwCXAxaxl wjaO/c+x/zn2P8f+59j/HPufY/9z7H+O/c+x/zn2P8f+59j/HPufY/9z7H+O/c+x/3krgDOA4wzg OAM4zgCOM4DjDOA4AzjOAI4zgOMM4DgDOM4AjjOA4wzgOAM4zgCOM4DjDOA4AzjOAI4zgOMM4DgD OM4AjjOA4wzgOAM4zgCOM4DjDOA4AzjOAI79z7H/OfY/x97n2Psce59j73PsfY69z7H3OfY+x97n 2Pv/6XP4vzzV/acH8F+eUufPY8x0M2NdV570l9yz2FlsNduGzyVsB7uSPcXeYQvYhVDXsVvZnewe FmVPs5+yt77T36//H1LXucblzKY+wuJYEmPdR7sPdd0JdBgTelmuRC7JEDhh6XZ2Hz7Fdrjrym5n V0dcIrNobe3K67B+zju7j+L9inz3SJFXLoV2aC0+Nd3c9WDXXaf4oJLVszlsLmtgjawJ8xd/lb4U njmbLWPL2Tla7hyULcZ1EXLzUQtniaZP1FrBVgKtbA1by9bhsxJ6tZ4TZau0/Fq2Hp8N2r+K2MQ2 sy36db1m2YySjVp+A7CVnYcncz67QFOSyXIhu4hdjKd2KbuMfe8bc9/rUW1sO7scz/n77Ip/qHec lNuJzw/YD7EedrGr2NXsWqyLG9iNp1iv0ezXs5vZLVgzouwqWG7RlCh9nD3H9rIH2IPsYc2XzfAa eUT6ZZHmw5XwwWbM8MJeIyb/re/x1lbMXcytTZ/pBtgv6NVine5HUfNC1KRe6DmIXrac4omdmAPp EzOi3FXa/E9Ye3vlm6zSHzf28swNWk6oU63/SF/NbsIOvA1X4VWhfgRN6hZN97bf3FP3Vi1/O/sx uwPP4i5NSSbLndB3sbuxt+9lu9l9+JzQvRXxA+x+7clFWTuLsT3sITzJh9kjrEOzf1PZ19n36PZY j+VR9hjbhxXyJNuPk+YZfKTlCdie0q0HNBvln2E/QV7Uotxz7HmcUC+yn7GX2KvsWeRe0a4vIPca e539gr3F7VA/Z3/CtZO9ZvyQJbAJjBkfg59vZPPwMeJUWq2+jlNEZSY2mk1nM9icx5kdr/tkNobv 3espLTUPMj2JV7nCAggGzIzzkrDDoNgf8XqLg4+MiNuhuqZ08EEPFZt2IMwt7ny385WCzncPJY4u OMQLfvv+u+87P33FNbqg8P033h86hLuyXBrcCYrJ5I4LZg9WRuSGRhYWDhuvjBgeCmYnKJpt+MhR 49XCYZmK6paW8YrIc/X14/XqzM44ZWuweHahMdPrcNvjjEp6auKgcTnO6jk54wZnmFRTnGo0m/qP mphdsaws+22TK8OTnJFoNidmJHsyXKbOd4wJRz8zJhwrMSw7tkuNGzu3uJ96rcWsGOLiOjJT0waO zZoy25HkNFiTnK5ksynRZetfOrfzEk+66CPd46G+OqfDLcHuo4atRjfLZiF206OsX/fHD9mcfFqw Qxehju4jD1khrFJYIMJeoXKc4mrXrjbtGu7Pc0RxvpVP7xcM5Xxhs9pSszOCFjtPNtiYzWlTHgw+ FXw1qAZtQVtiRlVixBhhxcXFiaNHFxQ0NLhSRrsgXYXOQ8NchfB4XgO9ClleXk5ycpzm8lw1S01Q g9mh0MhRnPycYgqqWYa1Zu7M8ftzkuINKzo/Oku1JAXTM3Ic3MxjBntabmZgoDfBsIn/jj9zRrIv waCabPF8bNdP4+3xBmOCL9kQsyaYVdXssO7o3CT+7eN94h91YXVlsjxWxF4Ie/2pTj7d73SIix2X VBsuAcxV/I443N/rCaPcE0a5x2PNF5XzReV8UTlfVM4XlfMfw3dC1r1/LzQLFcLTe1ATfGSPQ2e7 xl/tsWn88R6rYMUZtt9q3W9VrN7cL4YONfXT/qt05fAObm031bDiQ8Xauh3NCxre15w27I08EjDn 5Y0mDae6EwzBrOzQCNfwkYVZ8J5HrOdMlQ8frASDLrGYk05IA/cXzWxeNaXrgZQBA1J4aM2u5mHJ eRMGjphb1r+r01tUPzV2oKRqZNqMnElnV75ydGxtSYivPmNx1fiBHn+u4YJcf37NxumDayYVJVpG VJ2j8IJpI9K7GoJjZ3b+dkztOH9XUfqoKsZZU/cRg82YiV28YE86G5uneyVP9wr4oPAK+LDwSp7u lbwn8R07gaXyApbFQjw/llRt2McHshFsCB/cHj8bW/qNQwK8gKbv/OWBoUNy3AlxvbZlnEffpmID e9yZipi3WFYGm2I0u8PzN03Z+rMrpldf/fPzis6qL/eZjarBbDUnDJu5aubsHS2jRjTvnDN9deVw h8kSpz7iTE1McA/I9dX8+NObbjv+4FxPYKAvIcmb6E5Pis8tyC275OnNm544b0KoIBTnysQOFKvs CqyyROZn68MZxVk8SaycJLFyktyYc1IiJpyUitkm7RMrh3nJN17dN159xXj1FePVfePdh+/98fCN LZZQ6evgoXYjrRLpizfkimgQJ9pJS8LUawFcMfuOI3d2HdYef87dH99UuXf4insvebB9872to5Xr 7z52RxU96DNv//i6pXsvmnrcNX7b0+LfrWJm6mbMLJ+ta/fm6k80Vx91rj7qXH3UufqoczsUVzg+ PimQFMDgvR3cHLZvC/H9If5aiIdCcWniFzT2ylxQe1zPqm9Y1YppFWjHiFNf/dpzVk5b6cEs1ylS 3Wyw2M2dV4oZKovMdrPRiEtXHI+ZcTQY4qFnKNxstxgmJfoSzTRbc6LPnehzmbvOinemJyV6naau oWaXT5t391G1BvPOZXPbTUn6vJP0eSfp807S552kzzsJ895rz2CZGSZMbU9SUlpcB++/J7syTRyQ +hup4IBrdM/s+GmTkW8bOV21BhMzdcF7Jgxe02GzO+BNzXabMdVyzXogKR2zmGxy+jxJPld85x9M dpPRiIvhATHLDDGjOd2HDRuMAVbMfhTOSE93pIoVmipWaKo421ItNqEwi1Tx9OzsqVweyA3nNuaq uQ59/g59/g59Jzv0nezQ5+8Qfx1eMJwPT+3gloeys0cXjN/HLXjHW/iA2OhqdwfPby+YLZ43drOL 3KGfc280NBzoOeh0v5y0m0eOcolVIHa75i2XOAFP7H+DYYPBbDPZiuZdWH/2veuKyzbes3DcphFd b7hchni8I26wJidaEsfMXdAy9OqDt89uuOfQzqkXLCzzWgzzkjKSzKHBoRltT67YvP+i0owMfm52 P7jRbHamJ3YleUMZ2am2hvuO7Lr+aLTJGxzgzab1YZiFd24B63ioeCgP2nQX2XQX2fQlYtOXiE13 kU04Nz2ln1V43yq8bxXetwrvW8X5YBXviBQW9uDFEk4SF6eLT2NhlLMU8UsLFAh+GGUpA6vwAskP O/bb+Gs2bjv5bYwNdaiY463xhnCrvuRObKyGnJ6l1nvV0anpgU1KwyyzOyvVG3CbO/dApYmVZ3Zn p6Zluc3KdG0tQnnhfSw5m1kZ3/mM1Ia3peo8qsRJre8vXgv/edisR4pTZqY8mKIy3YVMdyHTXch0 FzLdhewxnImW7v2PwBMWZ5U2XUyz5yDMOW0yvFaOO96TlZLWe7QnRih3/d8wqkK2IOwaKjbDEPFM CoTKsujjs+jjs+jjs+jjs+jjs4hHbPPkVmVZnL4q54noqFge2vA+rjTOUCiXf4379aDI444zcZ6c rP7N5M72BfOTTV39Tn0G/MU4Z0qW1xtIMtkTu6r5Ky5TujgA45wW5dLOc3uOghPP4mmlON5mMhhh sHtTOrs7r/cm6Wd9BWbvZZMfZR6arEefrEefrEefrEefrEf8OwcW76jydPA8/TDnBS/Lh9Hr9O5Z WOJQq8CJHN95IGVAzyReEyFchduXFI+z+QE51GO3xbvS9ScTl4fzeBy7L+xsHL9yvGIfMiSloMAy ODXV2/EtX6biwWT2G2qzWcTus4jdZxG7zyJ2n0U8aYtYW4jrwmliofUbWWlNTbEXpA4dHOfvX+mP yM1VnIggtxATldEZIl1nj3KNPqOgsFDEvr3WYpCLeBeRLw+edMZroS8vFM9b809cntntT0vJSjIr XYWq1ZPh9mS6rUrXJI6dlpaKh5zvWxIY0i81nq838kusXn8obbnDl2Q7saQXH9tlsphUA0IZfLm4 rsd+58B+Nm9/3/Ez1TszB6ZZ45MyPPpJttXoYmewi/fkOhxu3ZkaO3S2a3xEONOtO9OtOTPTMnjw MOHMYakOcUHFYU6bUKgyTFRxssyiKstgR64hTbwHxQrR3Cecd5rvCgr1JUOewt4IJid7vsZfmWpK YajXqjJstXu89lHe3GDQ07UkMCFdURRzkj811Z9ozvdWZeT6M1x8TMbIYUNTOcKAJH9aciDRPMmN b1PWjGG5ynujt4ydfPXU45/37JZ7+2dbUgb4O18Y3tzYUDBz90zlSXzXQCRhM4n/30dz9yHDx8Ys loQIYXPY6xY+cIsF5RbhnluEe+5UclNhOD7AhrBt+DaSqTs3U1+pmfqLNFN/kWbqzs3ch5DYwtLw 2nRUB8XOMs4+Oexr6PVN4KSvp1rU1ysGNnw89cp3d/3wze2lU3e9u+uKN3aU7c2dc+3KldfOHxCq v6Z11fXz+itX33S8ff6Zd35163VHH5w/+47P7znnie0zai7ft7h1//bpNVc8LiJcnIzPY/+lswFs Q3u/OH0icfpE4vQtF6dvuTh9InFiCaS4MoR7MoR7Mpz/Q9mXgMdRXenWrbWr11p631u9q9WrWt1q bV1aLKm1WJaELdtYNt5wzOIF2xiwh83GCQHCEmAeCTOQTB4kmQQw3mQID/ieM3nJfGZIQkwyLzDO N5OBkM9JYPICBNR+91ZVt1qyecmTUFd1SV30Ofds/3/ObesNYMyDMJQHDexifBjWCsdoWg/F1B2z TOobSiXFQLjF1VJwaYlENhS6xA+k/d+96cusGHCgqNLsBJbm8e3Xj8VPdM7Mtjzx1eXbBkPElzc+ vqOrmqr7BVxqxlZed/PMxDV54/zHsaHNygr3Up+HKxzFOrEvSR5tQIghKWJIihha5Bha5Bha5BiU RNJifnfGfbubcOdU5eRU5eTUVc6pq5xTlZNDu+qEgNaQnAPx47bpMFlES21AS/3GWaSE0sJ616uj UjZDqRqI0o0QSMWAFFhiAVAKrZ42r9l7uCf76OaaJdzz0/uHxXhPc2XHcMysqX5nqVHcYPPxdKC8 tsvbsuqpD5/8ysfIMj74u8mHD+9KdvU3mcQgfn7H9+5ZPn3fC5+74eV7oZm8hCl2QuqgnRSwAexB ycul+KIGilpEWivKa19EWiwitRWh/KfiCG/HyzzSFTzjVZ3xqkHxqkHxqs54NP7sTnEQU5zcJQFJ snVDuzkRmLSpoVlGEhfqimvAzyU1tsj0Q4q4xJCsNi+hwmibaLWCfCQaidQAlI42h7zOgFlH7rck e67o3FMzMQioxGyvc3TP8miwb13Jn0/GzHuNmur8wApHufXBbw5s7vPB0KyBkQMGxmx+phyc/0Xd 9GB5ThGG9lU7+3u3TXSYjYmu5dnqv4c8xF1j220MXR0LdK6AMXro4gViM7TFCvbOaaz34rvHTRwY 61VV1KuqrleN0L2qqnrn8BYpkZNEMxjLSTwYD+VCOb3Ljl7rQmnPxXHoAb7EhZbD9QKeRbnvmEuu tV455lCPZuV40oQKUX3qRRDFirCkj0g63l8ERUmnB2M8mr3RorMiX+StXRD/nOh1UfFpK7RtNXrB JbjAI3SXSMxyFzjk4AuVqaD8YklYI2u2rdBzKfoz4D5NbO7f/7XZ3p0znTYdBAIaY+uK3SPts/2h 3NT2HZ+bau3c/uAViZnxLpEmcYLWMbr0wGxHYUXemZu+Zsc1063g2iu/tDln9TfZwz6rR2CaYkFv cUVrcXlntrXnit0Tk7etSpocPlHH20XBLbLuoMeT6QsXlnflWrund8M1MsEI+Sa0/CZs6ym7hBAV j7R2HFWwf3W4ROUHf/GVE8jyaQGBR48aEXOwxH1fVs73E9yZRB06LhTxtUggF1hvypD34VqtCM9U SEwclgGxjBg/+fu6IW7S8G5RVEhFVG99G+a3m2EtmMAekzxXJYEfea0febEfmY4fVUx+ZDVof6vE N+IVaGmYVRXYqgpsVQW2qgJbVYGtL+AcquURqkFDcBILb6GNTHFTrgW7kUGMGgcTCyYyCy4tm9WQ 11AY3Lzs9rl91z5364ACmkVNy/S+yui+yYSsmoDIgrdvPH17X8/NJ/cTwZo6Pv1g7ZE1yZbVd84Q tkZ80ASj2+egVkLYDskTQoEtFgJOdIw4QcwGIgbQ4gAtduCYU51UPkFhz167gk4kAV1y2B32SNg3 ZacEBcUIpTIvAMURkITY7CyYnZ1NzCbCcvFIopKoUGgoGXNWK83gp0ijI+qxBuy8niGqazRAiDW5 AwJLgj0AbCc0MHT5QgZC40XkKIB1v05DPi/TpxqD9pOXyTK6juhTJGM3rLTPQxm7sG3HIl0AJquP pH7k2GFoghp0EkuDMCdfCYMmOzqJNwG7H50ksyCZAckQSAZBcap5KpjREY2gFNZ9Zbhy8AvRwup3 uF4ZE7WzpWIuFpg6RHLuuNeXcBvJ6vv4nwmjM+4PtLhNRPXbNOAjfl9IZHAQBMBMsOaw1x0wswSI 48BD0GLQ4w1ygIoYeVTN8Ubix5+ma+fkP9qcSCtG3SdnyA6dCUZtjUn3yT+RnVp4ThmdNqShDPT0 P8nYPyN54mkQT4GIHURsIGoFMQzEp4I63jPFNwA/6K2z8tcCAQ5Anf9ukLYuIiD+w0AJ8SZ/yKIj q+erb1F6S8gbiJgoA9hYfVbPcDBARaxaGliBmdKKTR5flCf11ed6rE4TRWh0LE7Mz8NilaBMTis+ jZetLhNJMDAouMF/aAyMvN7z30fyeOXazow1Y2tOwwTw14NwPXRcm8xtvCLpEdkRnnLRwhSt2jJo jOcLgWpBXJhlba2FQlGsW3JFwYMWTfUhHWWKBrxhq4465sg5cVvWcZzQiU3OUJyjdODDat1ZwVv4 v6JlIxmDtnpv297O0u4iuFFrZNCCWWFNsg5mzzLxI4jqJew5yW/q8/Wl+wgda8vroUR5FM/yKJTl OeSf+TnwoWTEolETBvQYinhYh5pZO1Qs1KEqoaPm0x1zuEYy87bvY3kuj3e+kgdYHuTzqd7mOeCS TK83gaYm0vNeaqT7l/pxEkvXGE+ZBJvdvX62VtifSayfLansZw4WLOshgkQGA7FOW0Ox19qm1njq FVKOdYySDK2ILCPKnNvl9Bk7H5wc2jOZ7Nn7ze0Hrdnlpe6NlaxeA4EM4+pbdXV+4xeuiHzjvoEt fb41K3p3dtv1eliJ69eWB8ODV/eO7RoJD+ZXtLk8QY+Gc5gcHmfQI7asvPWKM7ZkOT443TcAtfsY 1O7PqN3QeiCCPAGDtTZQUI2loBpPQdUXei7rqzAHPpJclgSqoBN+1BNA+k+gHJPg5FYBrpVYzKIt tAVIKjMHqJOREdcgN1aCp0epcTkrQBXaSnUUuaCzel6IWi5NEEowqYEkhrdaZdjws9bND8wmKoOD UY3gskBYSDOi3+6AGDE2Ojwc23TPTOwZS36V5O+RlkUHDvb3rC46wDv7Xjw8yEc64jugKULz02uo drnSgw/zv463B7nlh57bt+zOLd1Cc1+u+tj0TNfmA9Df1kKN+YkfYm3Y3UfdcoWlONx51dHePY4c 7DJk++8Wk+wX31PId1wnGdJGYHS845O0hmFfaA7gx8UR4rdZVH+whuFsyxygj7LjqJOSuCA/1InX M3WafUk7hVbKK7qxmUL4cYpxdI2uTm98dGtb7+7H1iQmB9rsLI0LBlO0a2XH/tsC0mxXaVU5oUcU xNd5B29whD2CdODYvrtevqWTczbZjaJdiPoCscCpZ2YOrU6EEkGN6EHY4Sqol8ep67EIVsLukXzl TqBzlZB3llC1UULVaglZRwkZS+lF8DGGYWlFa2lVWWlVWWnVY9OqstLIoLRiYFBXirpIYzPa8GEf ga5OHjOOU2OowJLNqbykryLbU53EaXRBCBfqVkVEIo2Aq0g8zvBuM2rVDj125eZ7Z2K5TQ9umDgk MWYfsin2qf6/GShDC4IW1RvolgajjpoB7R9fNX7o6Ka9Lx4eWtaP62psxPwyaDubDkoDd26FttSf Rdqahdp6DEa1BJbHnpGa04VyYWeBEJE3iX7UpBADLai2b0HaUtqXcnyDtvDxiYHENxI4asydQN6W J1XjI1Ubk5/r5KMS4Eikv0Cg5Qe3kw+Q+CskeJ0EJOlO/zIyYn/vKuMuI25k33PLBjbb2M1RnPKt hGJscg9TdlA6GGgwK8ti48Mt0YKsUIZ4LOqYf947uGtS2lJJ6xkdTeAEoyus2i3tfPqGjq7dT26+ 5pGrkk8RN+/vXtfThON4NDB606qUxWlhjA7BIJr0Oodd7Lll7pa9p+9YNrDnq6vFOx9OjW0torwX vvhn/Ah1E6x0tjxv5ZADyo7nUqOWqxatXGo4c6nG5EJbWzPN4bmLr0sCYufD2guFIWfkQmbYP8YN yyg0h7iaxJnW9xUfaz2zpKdhUdndRhQaVPsbrbWeBn4E1mo0Y/HGXeG83/hDmNUpwfRDDQxNdr+o uY3jUKi5LTh8/UiwL6SHNZxJtBkpVsfaWyc7NjG8Uwz5P/0tKvdQs5Ow+EOik2dm139+Vdxg0osu 1CFvq36ZuJv4X1gPthzbgL0uWYTkEPKyIQ0UecjPiWBsqLUMq0CkgrLqX/B4/iT6VZmZgKeSwSSA sQkXacoQrQyDrIeT9fWKZIAnyVbG5WJakyTSsZRHSl6N/her/Rx82ermsKSDx7ApwxDtI/+qn37X YrmqnfhN13Czv+8X7SNX/sI/oTYJy0rb6JwS+hOtZ5FybbBgRiUzDy9yZxPwv0TtAWkd6thqVVJB JErDeGa1qUi/ZnNFmF7zBflR8exADsH/ejpFzfRINGok1GfE3aLpjqA7N3v78uJml2DrLfy2f9dU Kn/tU7uvf2xTCxfI+rPpXNgXyq+7Yyw+5AMcz1erW2czQ2nb1iuzw2nb9IbJ3/jjdvbwjaNbe1zE 3qAvNJNeftN0i8cqpLzBFK7FA91rOnt2rcyGpTX5QE97q8Mx1tJ9VSQ82zd+yxVJVhOovr9um7+9 Eltzta84PL++o4xrHMl4zNLb78n0IPt+DNZ1T8LMnMNuPl7Og+aFNqVq2A39S7WfCdOyzas0o+S2 lNyRksOGDv1Oq/ShvM0ODmaUU8mR0KBjTA6fMvEC0mobRknGpcXNGDmbMJfpdSjVoIV4UiMoOdee qmR6Dg7ApzLhXUvFQw9U1h4YCzhq9oybxtcPhFavnL+ndqUx/45Wuq++eyOKlHdd/DOYpNKYBQtg 954qByeCO4OEVa3lFiFSUT6eX4JcFaT6Ir4bc2OWz2qDqCq1QDWd1PrQ/Aja5HncwVVk/Zy7kFCj oZpZLt+pElHaRcYIrRD0LFWA2NLZkUA/dRUQhxlFYAZkOprjJfgDJb74s+qXwRYocQjLYEeOTeTQ RI9cLMDjB+h9h2uBHY36IAHC6PMuEnpM/buGcl+Rq173w9gnaR0OLJdCMqagjMdivooZZtKjlOyl UFK+tbVWzyrSQlmpRYSOdTFKXyT2pFfaMuRP2iF8JRiWoYO2QNprrAU9pIPmRGdns2nLgSsSGq2B Fwyoc0+Zk8MV4h8vVYfiBwehH+SxRyR9uQDiWZCVBDAOy6PXZeGyavrLIun18lFOf9kX8SjWBGGO ooPP7ulC13Bak0kMqURxEWuTjopV3IN8zT1kMhcWW7C6l3NC7nzNCupm8Fc1Ag9qIAZyBe0munp4 qX2AKzSCA+KnJgtrMFVfADsMOpl6hLCPBR9UDZe6yac/gUjJwBIwqbJ6O1d9oRrmLWrsAD1QZxZM kvuzO+X+7OWh4IKNgI+Oa7lBWWLVAC7fj73Esh2XvjX1XVCvwxpnBfae5BJQF1aeoYnI7ENUph52 TYHBS+cwFEa0YV7jvXp883qtqOPizSldP7n/J7f+5DCnhfZ9agXisFb0XDrWotz2kvGXF8FHMMhy gH5+dAQW37Rk6B3pGUy2V5Jjjob1b2zglFRemi/VOtcoWsqb/f5fIfOzYqhFRdSqsVCvK6FU1Jhb BlKlPcuQ99gCImNt6U+V9tYjKy24bVYPx4zdX2lfM5DhkpOjQ6GZGyu+hRgbLC2JsZdeIQ7DwoQg WJ1m/8oJZ7o3lh1oFmHwHavlILiCOexhyaSsIHpQ09HSVfqMqRoEFr06jqtlJXlsomFiAnx0Sk1M KC1J2uRIsyNUqakeVQ31zFTrJqna/ivSk+Uvpae6Ev92/C+kp0WKggq6CmUnhAbfhhpCncRvSu5y HMQEEOcRlxjRg4gGRBjQLLNXl+kenr9s9xAV6960Fmgb2pL+xW3JF3At4vpPmbDxXXCZHGiXu2kk CJGjCq8RQlRVlq43G2drX3+p60i83bHnuzfs/O87CqU939kDj8VnXD3XTFS2DwRc5Wsmhq8Z8INf 7zh9ZLTv1uM3wOMIPB6s3LmplN9w5/jInRtL+fV3Im6h+jDxM6gbxC3cjriFQOEyUxdK9FkYv0BF jEWhFWSCQe54KAzDZXmFCjfxmbzC5WiFy9jIZ9MKD62PDfRKoQZjMVtcAhMfG59MbvoiohVaZVph MDpwS3/PmqIT/ObG7x0a4prywWpPLRaSv4E2QyBW7+bmnrhl7PCz+5bdsaVLjPdnq1+ZXt215aCM n6G2Hle1dURyQXX5dAnkMAmtvkaxyEEugbBzM9aqmE3D1Op76tRqbZq1NrUKsbMlXNF1J3wkl0LY 2TnSjrAzN45y/uWx8yKdtfEKs1uzF1vbZ2NnFrmZz8zER4YrUaSi3OYHN8QGlw01o8Fns5tnLsHP 1eM1TYGz8VLQVMPQfLgzfn1NddX/o4BohZCBIFqOTvjTMjO4+fiuNhAxqUa1MNCmGpdJtToTMi6h odGBrAxzQpsLS2xiJGKy+CuWMUwN93LCT9Rr4UYAeLlAIxsRjT+N06xGY/OELI5MW0dwaZgJ93aU PIZAyKMnCUBssnp5lmU15tRYcf65SwPNocJA1ERotFrWKM81Tl68gL8GJa5gr0n69Gh5dGL0ttFn R6mGZuKf1CaibBS9iJ4SlzQZ5eYi+KXkUzqKci8RmZjaUEQQGcUc1wvgT/IwjRaVRXpJp1LFEXi/ sv5ZPa5PvVXU/pZfwV/F7+IJpXH4v1HXcMT6ruKM9Zah2jCcRS2ghobhQi39/9swxF9rXX/n8szM soxVS6KGYKK8qr15IOeKSitWTkrR+NSBqdBwR9zCELA60tJsU6GSbpbilpg0tXJaigLjsuvgetsc 5pBPhPWny+8SgoVwJB/zNSV6VnW1bay06AULpzdZOd7BMVaHVQxm3NG2mL+puesKtBaBi7/Hrye/ i3Vg647HMT6YVHWeVNciqa5FUnXIpGqVSWSEepsheSE47DFcsA1nUfXNKGH7LDK7VpW9OntGofbI yxMMi2kIa42Owa/XcP54yja4RfLcahJQ1/BvaoXaO4g7FkzvFIdsIbdZQ7EUeaWniTOydHh0z3Lc qDAM52qjMucUDqKqnd3AalnKaEdyP4x4PuJ7sCZ4SPLBSkAXRRYURRYURb20qBykopxccoGPTyqe 5lO14lO1Ao8fyb6JTo7JA/yqs/pUG/UhrMKKyUpURzkqsDCjFsi+xnG8ukldluxb0lwsFBdov8cZ wWOxeXh6/FE59TNmBaPY0sOZngPLGLMPeq7A1iuC/SuXd227exPeVPPO+T9ObOgPr16J76tdUbuM xAGonxbs309jwYswm6FC1yf33sI+4FVOvMCqymlRj+aF8lc+CvWZiYt/kIpo4AJWFTyIciBGgaYY vNDdBEJNIIBOywEQCgC/fNUPQn4QNYEbAyCASC6WtwwH/NBrA6h3yUJTDCCGET1DKxFA99ejEclY JaBzVnRjC/2fBNr3MStXDgnlP7kTpugddf8S8k6c+nBcQ4oQbUpjyIsTBwBO4NWzpMEZ83pjDiNZ fY2k0BiXzRMUWbJKEp/gWjHgsnl5hniCZLV65tNvoaYmqTFqiRm9wBIQE+LwgZ136vX4f7J6DYFr dEjbbRBjHIbaXoa9fRobguGpG4rWjsiveDsoomM4BSIBEPGDiA9EvCDiAVE3iJEgToCOTtDZATqT oAv9mzIWMM6p9AE6Slporpwf3oEzqZfRUW6VmdBlU29F/jukzDI3we3kbuNIThKsw1xrJVzpeKAF tKDftaCoyYnW4W0t+1vwZfCqbYxFSv4Z0uTsmXL5LNSkou+F1rHSPFa+FEXTdT0TUaah13oZlTec UodJqvohYbDFvL5mh554CcefJQzOuNcXhc+qH1MkRBc2d5OgIX6B4z/AWQGavU/Q4G/i4BzOigGn 3YOWhTGbFhYFv49l5/csLJHJzLA6uEIQqc47WRaukAEGXjSsaq89wzVatF5x6B2jcL3S2JHTWBYq hkf8PoobKRQxOlPADu3xJOrn2YFNjQ3W2iUrYJG1NiPcil7ThYH2ICjogM6P4AVaFZ0um4lXUA+3 wtchhNKZT9e78sh4FftNhK3m2qYm4jI9XVFc6On2a8Sozxu06Mifv0nqLE1uT5gHLLBXP9QAMer3 BM1a8uzrpJb3uTxhAWerH7cYRT0F0TkDtla/Cg8EpReN4BR42igaSILWMtWjYIJG0546s6m6HkUP WAUehPoJYVOnMReUtQ15vgvEXcAug2c7iBgLRjzKAidKyR1O4GhHinMAX8WhFSvaUXICG1VBK+rW JxSnRc4bIBRRiyKaW47k6116UWZ1rGYGb72Jzuacfh6nD7IcUX1Zw4W83iYzSwFAfETzTX53iKer Jzie0puNoEQKWmKdxW6kCI3JMJ/Cz4k6CuYJAUqyBha1bxKnsATWeRrjoCRWNDURkafI0vD3eXaA xdkwD0HLMcewKSqDF/jGEfmeg7XC2Vk0Z10fQZaZXrBoE4E87gXQKf4mrTFq5s9ZXMgewX3V2zgR zSjjpI7XM+hadR94SmNg6UHRxTPuQJPRanVw+DWBsACf00Yr7zfabU5u/lGGg5UWDrQX/wR+Sa3H LFgcM56gwq5xbhAq9a3XGmY2iUidAFuyyfAlBm3ycwsMDzSWoNsVtGiMrCPm88WhP9jjPl/MwYJ9 taqXeEEv6Claz+s/KQUSLp3OlQgEkg6dzpGU+c8/ETPwneSxYSwiGUMhH2s+RlEZdqAD5UhwNDOI Soe30C5JmV9X3mF9e6T8LtV66pKu81IkSMzk1t46zgSjFq+goQEruAVr77qS0y9t7OuYkeJaBiZD 2lya3Ji/9itbMtUzUBqvH0oDpfN7oXTEv63+wlUF6n2TCbk/gPlVZOID63KlDcsiDq+d5j1Wu0P0 OYXuz937aedSaQHWXH0b7MHOYy5M+7zO5sa4N84qg38Mo0S8oljX8h7aaOPvpgyiQ+RtWkDepbOH nI6QTXe/L59KOl5jtBo5CAHxdpefo2nOj3DWixc/BPcRj8iI3XUUM8/hB05pvUHHGGUaxspny2dR AZa7dDSXX7rI96EV9cfQisb8PkUHi54Tfn8Lkq/F35REx+R8LKBcgALDROZMooj4t/D97IAS6zDb UTRq9spJNFLGEjB0wbeSeBWJ38Cv7kj3dKXQz/VD6dQy+IO6QI9e/JD8A/Y2ugcWxJpfxuz4QcyL 6fEDmABlPniKDlhYlwnds7X1bA6616/Q9+JbU59xDranuzpS6Af8zxQ664QZ80zt2nWD6dTAZX6g ZKD6DqGl/gf0Ic1RjsLS0DJt6iKqvCjzTdJg9lgcAYGk8VnSIHotsEwlqfcNJg3JGEQDfcBgYuEa mg3wfsvAcTyFd2MmzHgcY3QXSAyNGatdooDyduVokBL46noBfoGvQ5+nwMdRry8S8dK8EwPQry+Q OH4rvAv/PLzLaeDGPutGJC6Kn5ZFQRCJV1kTS+GFSDAYCQdZZZfZq2CQ6CRegZZkOIZpTVDCs+pd ljhVZ3Zmb1/vvlWZ7Kp9vfCYxQ+hxwx81r9nJptdtRfe7a7q0+C/qHvg+jVJFgIlQwLBMEIOmITF p7sLK6ehbSoDOTSs+wVbfR4pRcjxUdEq+P2G2Q1XUsDocQhOUU8UptrdvtJUK2A5t9Xm5nBq0w+r a869WV37z3peR+G0hrr6xz9/a/fuX/7iJ9tImoaJiUPy3QLf0TvwHQWw1tOYoFSpgopy0PEEemeC PFyqk3G08g4TufoMKFPLqAWhLY9H1XhpswrgHXf7ZIHQi07B6TEAat369etJnHPbLG5eg2/bhzt2 v/XzH19NaWicgiH8R+DpN8+Bp3/Iclr47mjybHUCevI9xNX4V6h9tRjtigxxQzBGn210XqJGcS25 YrXgh2jOJgh2E23TmgM2e8DMgurnF13LRIgjdWriX2pn1eziaxyH/h3Liwb6JiqF7ZI/ReKaY7sP 2cNz4Hopm9Lbk+3YAftK+0pscPPeX/livuytv+PX/m7FilFGfyi1O0TxPvi9vvt31x2eHP39emiL 5TcuyPhYsJVyKKrLe7ERgH71DLr8KvfjcxBW/4pHQ9FAxYdRZcawFthtRSW5MwSNkCGpBv9F8yBK 4z4kV5C0XCvKbA6p9kmLgL6Jj/Ss3T8eHyyEmdjo8LJAoq81ZNca/e3TN4z5Ows5J0+6I4LDSOFr uEx/vC/XZNWmb3j5gRvn7t2yrNnKtN76xtcqN84UIAKncEAy+tLGO5e/WJ3/h2Gdr33Nbd/9t/u+ 8fvHx+a/F1nRCtF70Mq2le259nLkk08JMPClI/vXtoqhUjhWCnF8INM13JzYeePuNUWTPxNYbTSS DCyg8jPT8cHZbdflZv5u/1B+zd5Dd9+2K7pz7sgIL/KMycYbBZNeazYbV3/jP7+U//xjT/y3z2/t mHjgX16RBuK9U6smfSMr+GApSkxBe7oWItuXKL+caR87jY3A6tRmwsevGgGJfWVwdRn0l0G+DEJl UJ7D+yWz3u3W39IGrmkDo22gow0k2kAb/MXJXRjwQ/dBoEGZwXv3FLwNltED/dzFP0ta+ETfcTGT oSJzAHteXDMwByxHqQ31/ePQhWbfgPXp7K/k6l9AI2XyGdr3l2igSsil1AizhMms8bkv5a97avfk wXXdYU5ITex/akd4TGoxMiQOGB2rixTGW2ePrIwTzt7xVdntD6yJPGMrrO0LjywrOwPl9WVpfY8H /MPKJ26uxEau++I31k9/++/v2dbFmgSdwSQaBSenMfLGsdu/tc7ktZtKW+++qmNDX8hg8wl3PLM9 mZncirLuMNTtD+QdNwnsPcmxhCQP10jyJMJKYaT0JGigv1HPx4wYBjPaemJGG/nNL+IwfWJ+hVzx q2HJr7KgfpVmgMd3UT6FiBj9e0YSq0WbeSSMkD9DgUWzRtoJLY7JOFneUIZWSp6GRydaTJtscaGP oDVNo50utY08C3O+sK6Gi9PYm0jINfdnM+1kA2FKEj9IX//cHbc8fXUic91ztx+Ax+eMrkTXeGbl Nd1Wb+/W4faV3bCiwL/4yJ+Obpz51odPPvyhfPzOxq/cuLLoWHHv96578J9v7wj1r7/hLmhyz8Bi 4AnKhqWwX0uhkBeEPCDkBkEXCDlByKHOucZl3QsIMWXkGQ+k7gzAkGqxuMpWxVWFxlXeJq4qNK5C sjjaGmT02tGL7Dr0qONVg4fHN47Be/LqbFzD9VfUzSBQ9fAVT/KAF4U5UD4WnIpzc4BRdiDmyvNn Za4QfZ1F4ze1yXmkWSyxgItnVXRQG52HlTyt4OFiWO2l8XICfoLWGpj5dYxeR9OsQQOMf0aTNgSt Y0EzqRfsgt0v0O/BGp0aQGwgwzlFwcmzxM8f0ZIGr423c3r6ZYIkYQTT0Z/cz8JCAmr7Bqjtx6FN 92APS4Z4ASS8IO5BHIM0VwsdErAiK7bKSdzql7EsnjzZGobfWEnVdekF/DZMpyhHhxgFHeqQ8e0l v78EjS91stVKp6a50hyI1TSkMKtpuS2NOOqz9W33so5k7mCRchAdsAQA0PVdR4y86eBxCtY4821G i4khtCb9JzPbS4K7bUVeHjqF4JXEKY29c821nevvm01Zh47sPIu3akw6agTtqGA4r9XstdkMQLvu oZs2JRLjHU1NsSaN4LWYrJzREgra29bdsqznwP3P3nCOFeT6aRuMCQ9B/a0G1GlsLVSZG6lsLchq oFKyyPGzst6ySG/ZObxN0i6fjixfbhfBuIS4rAj8kwiiWCR4NSIRRpeGq7HX8itdfnngSzFZF9T8 CZk2kKc0kX8bVdM0qtZuRAsnwmUwdqJhgE5JBqudQDZd1YQlLbrYyXfy1sIc0EnaynTLf/n9VAVt ltHVN8ukL5S4+n6ZREJmd96ob5eRh55QA1kocbVOey2y03LZXefAle2UCvN7KYpbWESLlyAe6tn7 7Wt7d6/uMGlowmhg26Z3DvRtGWhKTN88fgCuFUPrjOzuvu2VqDM/2daxcSynRawErADFjpU7pbVf uDLp71nb2b9zRRLcsOb+q4sWj89ohBV6yO0P+5t6VuaKq6Um6B4W0WFimqQ1xVil4AvGgpTJZUXJ VoTrnLpi31D39smSDmfaVlwLYz+auP+pPKGewj6ROhAhlwTRFhCKglAEhN0g4gJBOUCF7SBsAxEr iFhAxAwiHIBLHKJAiAQJF5CjlaBEq6TVDk+sfk6d+VFmfc6fQrNA7lSKm7v4qeSBf8Eh9+OQRXCI puZQEuFQcc2hz+aIYqQSq0iYAGqjk5IWzU6SmXTUlZIXmEwEOE4bmNIqk/HQ61ov5HIqo5RQ2Xq0 EfasfFzwwCVfYPHAYN01wUKssoIgCBA/NQsP1fYLz7+n5wywRtcy4CeU6G3xBrJe7iHeUv0aXr0S PA12BSLVP9QoasDRnNcueh02AyEgZoGC+OfTfwriv5nvQB63FXrco5QRRqxXJUO0CKIFuUVNyBHr pBKwimpUKsofN4S2/KHNAjGo+hjaQIn8ImacyO3M3ZYjcpffGvoC3irvRFBz6Ql5rkacQw1rNLcm 2gvocw/0LR1/9KPZeqpl0r7IdWYvINdJJwB3TvWYM7NvKM6jKBdpd8FbFrWM0BxAcNEHjkBIpw6p EY8O3n70uq7rriiYaAonNDpG2zy0fbh/12QqOnlwVffqiNvu8+DdGpOWMgtVT7CS2fnUzhJ48nNf 39nBO+xGPe8UeBevcXic/oFtIz0byj69M4ybAn4WBsFQrPoIhbdt/OLFi7VaEqeJH2FI85uhDzwL Ne/D3jyN8TB2afkAGOM5Tt0cuXjT5LtqnvxItsW9MvHPzdVexXEKRS2/ilNfJf9ah3oL+zjkOLTa VgjUVjYAGobVfy7PylrUjNwwB/eu+nEB50/A11gofg4kjzkndfVNbHJKllchofYBau2AhU6ATKE2 MnXEswTF0tUUZbKFnE0RHqfBe/NfFkVKa2TxD4wWHU2eETwuh/GT1/QQ7tMQ+JMjsZAI8wotuGEE mYLafApmigzWh70kifEUaKZAXObwmyMgogUDKDT4kZgDMH0YapnDc0sWlLKV7PYskciCLNpSyWJG ox/CNFypz2ULPX8cWWgnyhPwpZ2oPpG3eO3rBIXOwc6rO4lQJ+icwxOSMR0GYekDv58p/LF5Glqt 5iizqqFwl0t2eSx/Vq3ac402K1stubTRWVy0EZhcPI1RIJ4yZyYPfGtXYrK35f+y9zXgUVXX2nuf M/8zCUNADBHDERWC0hAVMIUYB4wIBCXFAkms3AyZSTIySYaZSUgCgWOa2mDSGinXn6i9YNVrW6vW Xrzaeu3E0AQ1n0VFRaU2pa1/RYx/mGtzOffd65zMTDC09N72+Z7v+XJWeGf/rr3Wu/dac84kIZNB jtPmzLps9SXe9uI50vxdZcHvlcy6+Ib7wl9r/oZn1sRHZiwpu3zxNxZNm5pbuqSwQ/r51x/6l/aq RU53Wtr0jCkZqeYJaRMKtz3wjek5iyo6rl17V/3S2VdX37xnqfpIMGfuKt/8RRsKzv+KuF/P1T6S /NJt9CnZDE/aZJbpcE/lUx+ZsH36ufzcR8wtcHoTvvBMerD7r/8eu+SfsXTjsuVVS6afU7Bx+aqN nowO9zkLzj933jnuSefOn5F1yfQUftXV20ouzl7XXLR8a+m8Bdc1Lc9dt/DsabnX5hZcN/+MzEXX Mq4VaoflGvN88cT/JJukxUZ+DjYmjvMk8b/C78X5ttGHTTis9IF//DOI+G9nzTCnTp42ecpZTtkm t5pTzzjrjDPOcsk2m91ulW0pk1xmu81pka2pk50MkbxMO2wOYc1ZpsnMLX1bvMpOxLTVlMW30v+E uUcXPveU8kdpQ5L8Whe5cAz5N9N1cfmzEPPSU8qvzL+yTEqSmPW6JHl5bLGthLxj36mLw5ckz+vi XDum7HeVxKU75aJxGSUDp5LUxgnmMeRuXdyXjSGxv69M/MmXJe0ikh+NLZMuInleyOTUJPnwDDVZ pqSeQu6fcv+Z+Wf+uy7pzWPIf/5PZOqOsSTDc1Z6XB6clhKX4LiMy/+n8lMhZ2edJCWQPWf3ZKae lixIkhLItlFyP8mx6fl/o7TqolT8I+WcyX8H6Zux7dzM89LOe+38jvN3zbwEcvR/I7MuPU3Z9Fel ZVzGZVzGZVzGZVzGZVzGZVzGZVzGZVzGZVzGZVzGZVz+3xD6PjJnLCWLcWmuizE7z2AmlqZ9BJxF WKi9Bywh9GllwCptABjR/hUY1R4FNmk3MBPv0vqBMe0NYJ/2GjPJV2tPAdewCcBi5gKGoXMiM2lH gT7tADCivQOMau8CG7WDwCatj03kWWIMdAqMEfaKudCMsrxG+wNLg4XHgIWEJYQ+5mBp6P2cpWOV I0AfLE/HKu8Co9rHwEbtd8Am7XWWjpHPAothyTSMfx+YhpHToFlgITydBs0C12PdaVzS3gK6sfo0 ngH903im9iYwS4sBm6ncTu1dQgMsh2beTbP6RBkM/JHNxFrfAabB5pnkxUzyYiZ5MRNr/R7YCHtm YsVngWLFmVjxKDAT+mdiLdHSTi2d2m/YTPgyD1isXQ4Mar9ks+D7cWCEMApOZsHrI2wWrPo9sBv6 Z4HVj4F9aM+DPY8BZ2FP82DPvwBLCNfDqjzs+++BUfiSRzzkwapDwAztt0DBQx54eAdYB8byeD1h M7XvoHI7jeygcqfQCZbeAO6llph2F7Bb2wPs037M8sDVWywfVr0PnKW9CCzUXgaWEPpw6vJh1UFg RKsGRrWbgU1aCcuHJe8Bhf58aH4M2K09AezTfsrycSYnskLswntAHxgupHNYCA3vAxuxm4XQg3bw 8ymwHxwWguEDwGJwtQ5zA0AfWF1HDK/DrN8Am7TP2DrwcxDo1l4BZsCLdeDnNWAWomAdOBHldmrv hO/reBe19wnEKhKw+MSfgUFtFzCs9bASrPUiUNhZAjs/BTZifAlWfImV8CK2CBhgq4C9bDorgY8B YJC1AbezTFZK560UTH4ALMTJKQWTAtfjTJZCvyhHcK5KoV+MFKelFJYfBjZrrwJj2tvAbuxjKZgE Iq4dbD3Y+Ajow1laDw0Co9TSqH0CbILm9Zj7HrBb+xDYBy/Ww6/PEbEmZBUfbHsVOEv7FbBQ6wWW EK4Htz7INOYDq+LvQLs18decMzTxd6QzNfGXnIs08Tek6zTxl6rrCZupfQeV22lkB5U7NfFXpvdS OaaJv7PdrYm/wt2rib+93aeJv7rdr4WZD7uQDVynNQGLtfnAoPbPwDBsqILNL7MqykJV6D3MImjZ DRQMR+DFO8BCsBqBFwLXY78iEDuLwIvvAt3ancAM7YfATK0LWKTdDazTXgDWEzbDtgi8EOV2GtlB 5U5YG4EXotyHUxeBzQ+zCOzB/sHmfwcWa5cAg9ptwDAiKwoLfwAU0RSFhQILCUsIBc9R2q8oLHwS 6EbURGHhE8BMbS+wSHsOWKftA9YTCgujsFCU22lkB5U7YUMUFopyDOc8CjufZ1FYmAUs1i4GhrUH cYLTkO0bYc8vgYVULiEU+bYRqx8EZiJXN2L1z4HNiOhGrCXau5DJG7GKaIkhWhuxm78G9iHuGqH/ EdYEr6uAadp/AGcRFmpPA0sI1+M0NsHfJqBb8wIztGZgJs5ME3LIM8AinIcmfj3itIkHoL8JDNwL rCdsxolqAgOi3E5zO6jciQzfBAsPAvdSS0z7BbCbdPZqPwf2wesm7N3drAnM4H0Ue1cBLNYmAYPa N4FhrZ1LsORTYJf2ARB8Aru1j4G91NKnvcEnYMyHwE7tOLBL+xwYo3I3Ya/2GrCPyv3aH7gbXn8I bAZmYu4xYJf2GVDMyqRZmZj1O2Cf9gmwXzvKszDrENCtvQzM0J4HZmr/B5hFvUXaPmCz9gqwnXo7 tT8CYywF2M0swD7mAJI2eN0CLNYagGHtWSAyFS/CKm8A3fC6CKt8AMyEnUXIcpOAzfC9CPpFO84A L0KuOxMYZMt5KXFVSlyVElelxFUpcVVKXAWh/zdAt3YAmKHtB2ZqTwObtV8A26mlE+OD0HMcuFd7 mwdh4c94HemvI/11pL+O9NeR/jrSX09j6mlMPY2ppzH1NKaexjSj/XNgtzYE7AWrzWj/DNgPxprB zJt8B+3pDtrTHbSnO2h3dtDu7KA93UF7uoP2tB38OHgHvHsV6NaOADPQ3gHv/ggsonKz9ltgO5Vx 5wCMgdUO7I4TKHanA6sXARGnwDD2tBOWfADs0t4DxsB5J9nQCRveB/bB2k7YcIx3YfV3gG7CDIzv wurvA5ux411YV7R0ab/nXdDczWMYfwQoxsfEHQ4wkzAL9sTI5hjmfgBsp/ZO8BDDO6YDGGMuYDdh H2E/dioG+73AYq0YGNZe5N1Y5T2gGxq6scoxYCZhFs5kN1YRZbFKN1YR5U7CLtzLdtMq3VjFBuyj cj/2pZtY6sYq2EWs8grvxSpvAt3aS0DkLmCm9hywGWe7V2QtYCfORi80W4B7YU8v5j7D+zD3d0A3 7O/D3HeBmeCkDxY6gEXU3kzt7YTifPYRD31kYR9Z2Ec72EcW9sHCGmCxhpyIVV7m/eLODeimcgbs 7McqArOwm/1Y5UNgM/W2U3sn9q4fdoreGDjpF/eNwD7tGKLOJO7F8b6/BRjR6oBR7QZgI3MAm7Rq eQ32+hV5jRzVnsO9gom5gGnaG8BZhHgPApYQ+rRKYBU0F0NbABjVQsAmrUAuhoWHgEVsChB5FRjT fgbs1p4C9lG5H+sWw9NbkAtM2pOyiPQ3ZRHpAjMJi7TfyCLSBXZqr8vI7tpdcljkQGCMsBe2hcWz hrxNxBQwwC7Hs9JXpBlM/Oa7uHyEMj1BpVJNlCWWKpuMssxy5DSjbEoaY8YzxxKjbElqt7Iv5FKj bGMXyAeMsp0ppq8bZYe0Oz7eydaaokbZxS4wPWeUU6Q7TJ8a5VQWtHaIZzy6LrYOGWXOrLYLjLLE rPYmoyyzdPuNRtmUNMbMXPY7jbIlqd3Kmu33G2UbO8M+YJTtzO2YYZQdvCg+3skudFxslF3sDMf1 RjmFr3SEjXIqW+B8GpZwk93gWS/rPOtlnWe9rPOsl01JY3Se9bIlqV3nWS/rPOtlnWe9rPOsl3We 9bLOs17WedbLOs8/ZAq7mOVAclG6Gnfg5SzManHnV8sqcH+lsCtQCrMQoRctAZRqWDZ6FrMgRGGr 0VaJe8woZomaH69+jK4H+jDyCswLYswGtAUwIkDjvPhXDV0+GluDWgRtNdSnzw/AAgX/vBgXgIZG 1DajFMVaYkwdNEbR7kdN2FyH2T7018AaoaXW0BrFiGpjTTFCgY+1tKZYJUK+LCdfK9AifKxDu59m hKklSFZHDT/K0TOHNFdTS5A0esGR3j6ySjX0BImxkGFlDVqqaVVdp/AzmmSBWDFEvuh8j7Ct2y5W qgUDCvzXGRdWVWOsF+tHqSY8jsb3Q+dMX0Uh22sMv2qJ2w00MmFxskeCtQaap3u9EfVsOg/JuzmL tFWThkbioc7Y+WS+xY7p/vvJfuG/vi9hOg3iVV9R7LUCHaG4N7qNlcaYCGpNhvYovNB3qD6+S146 I160Vo/ya+Q0l8MSL61fbqyfTSe2kvZK9Hw5BhZ+yeuF8aiZz9YapyhgnLf50LgAvWOfer9xfnVv vIb9ldSr2+M3GBM2+ujkCqs20p6NzBm7t+JviuDEadH3Zg1qAbJBrH8tnfboqH2ca1hQm+RBuRF3 UfLST2d5JVrKWRbt8WyM8ZH+q8gqfW4UEgKLcyGbSbIpxkdbnk3aqzEGz3lkfyV5EIKGRrSKHawg X0TkjNY60i6yh74DG+P6Sshm/dQ20mmLkIVRiqsI5QF9tkI+iJj004kK0Bo6Qxto7gh7V4K/lciI +txwUo8ezz7iJBGjm2mtcorhsdbV62JsOU5RHXHoi595H/WH6MQ2Jp3zEHlaY5x0XZefUETuyX6L fj1DZGHWbDqd1fDLH4/ZL1tV8yXNp89RQvtIllaMPKufnvJR+e7LvifO62i7FiUxIDzRfdGz/sip D8ffQXyUQ2sol3pP6anOs3cUp37j9J8cA4JVcfLqaKaP8pHwxh/XI0YGKaf9pR36e8VFIibmkjUi BvR3omzaqxBr+KFycU5OrnJ1oDxcG6mtiCpX1IZDtWFvNFBbk60sDgaV1YHKqmhEWe2P+MP1fl/2 Fd5gYEM4oAQiileprvX5wzVKxFsTUdAfqFAqvNWBYKOyORCtUiJ1G6JBvxKuravxBWoqI0othkb9 1ZhZ41PKa8M1/nAkW1keVSr83mhd2B9Rwn5vUAlEsUZ5ZI4SqfbCgnJvCGUxpbouGA2EoLKmrtof xsiIP0oKIkooXAu7hdnQHgzWblaqYLgSqA55y6NKoEaJCj9gGaYowUAN1qqtUDYEKkmxvlDU3xDF 5MBGf7ZiuDkrolR7axqV8jo4r9sdrcL6/s1K2AtfwgG4jYneaqUuJJaBxkq0RAJNGB6thUP1wiWv stkbrtbXEjSXV3nDMMwfzl7tr6wLesPxHVg4svRCsTXz14IiOKXMz15wcRL1fvCLZbzQXxkQdvhh WNjr81d7wxuVWtGTVK0Ye4OJFnizpiYQxfxro96o7uNcKKilBcqxd9FwwB/JXllXnuWNzFZ8fuWq cC16o9HQwrlzN2/enF09ojy7vLZ6brQxVFsZ9oaqGueWRytqa6IRY6goV3jhwEYxrqS2DtQ2KnUR P4yAS6Jb8WIn/eHqQFQYtKGRzLtyzcrF6A1TBfvsq9N3dHNVoLwqaS5eAzXlwTqf4KJW8QUioSAW EJyHwgEMKMcof000WxlZu7YGByIrMFvxV28QkxKqakYGj2kRDRdHGvRHQE+5fu7iqxOvhq5FZEBW AKvg6AvqwyJAfLWba4K13uRFYbNXtxTEx3egti4aqouC9vpAuV+MqfIHQyc5dDp7QTsx1+ev8CKI sr2RUEP8eZBp6ewmNtbFMQJPFGwSs2oam4BnF/0piuHZnnGP/j24v3CZTF91uTjGSFWnOz4lRYyX Hzzd8RMmiPGmd093vNstxltO2/6JE8V462nbP2kSxuOViadKE40XT9UrCCeyFJbGMlg67pensXls Ju4UZrFr8LRwHXJ0FctDfs5nLayA3YI7ibtZIZ7L1rHH8Y7dw0rZi2w9ewuZ/E8YOcQi3MyiPI01 8lmsic/jEl/MJ/CV3M1LeAb38Uy+iWfxrbyI7+Cl/DZ+Pf8BD/BHeZD/ktfyfl7HX+f1/A+8mYtP 6r7g7ZKVd0iTeac0nXdJF/C90gIekxbzbmkl75Wu531SFe+X6uQVkipfLX1HXiN1yeuke+Vi6Sdy ifQzOSg9KYelZ+Wo9Gt5i/SKvE16S94ufSDfLg3Ld8km+ah8lvyBnCUfk+fLH8pL5EF5lfyR/A35 YzkgfyLXy5/J3zR9Ve7E3t8zmj95z/+Qv/vA30/B39Pg73nw9zr4exv8fcKqoDbCU8R3CcDfXPCX B/6Wg7+vg78N4K8a/G0BfzeBv13gbw/4ewT8PQX+ngd/r4O/d8Dfx+Dvv/gOyQb+zgB/M8DfV8Bf Lvi7EvwVgb/rwF8Q/G0Gf63g7xbwdw/4+zH4+xn4exr87QN/z4G/N8DfAPh7G/x9CP40+XZ5Avg7 E/zlgL/LwN8K8LcO/PnA3ybwtw38tYO/O8Df/eDr56P5s16XxN+Z4O988HcJ+FsM/laBv+vB30bw 1wj+vg3+/hn8/QD8/Rz87Qd/r4I/8b21/2LruZP5+FTwh+c9Ph/8rQR/5eBvE/jbDv7awV8X+HsA /O0Vn5yDvwPg77fg7xj4G+ZBKYXXStN4nXQhr5fyebO0AvytBX9+8BcFfyr46wB/XeDvAfD3GPj7 Ffh7EfwNgL+j4O/P8hrZARYmycXydLlEnikH5a/IYflyOSpfKW+RC8HKGnm7XAn+GsFfC/i7B/z9 GPw9Cf76wN8r4O/34O8j8KfJn5lSTF81nYVwnTeaP+ctSfxNBX9Z4O9S8LcU/K0R360Gf+IeqwX8 3Qr+doO/R8DffvD3GvgbBH8aK8VZW89ng79c8HcV+FsL/mrBXxv4ux38PQD+HgN/z4C/F8DfW+Dv ffD3BS+V7Px6aSoPSLPAXy74Wwb+isHfRvC3Gfx9E/ztBH97wN9PwN+T4K8P/L0M/n4L/j4Gfyd4 v5yC0zNVvlqeDXa+Cv6WgL9rwN8a8Lce/IXAXz342wr+bgJ/d4K/h8DfXvD3Evj7HfgbBH+aPGhK lT8ynS1/bJojf2JaBP5WgL8S8BcezZ+bJ/F3Fvi7EPwtEj+lAP6uA38bwd9N4G8P+Pup+L9WwN+L 4O8oK+RWto7PYCX8YvC3Cvz9E/irBX/bwV+X+E4d+DsA/v4E/v7MJyAO3eApQ5rJM6VLeZZUwIuk NeDPD/7qwd+3wN/t4O9B8Pck+HsB/L0J/t4Ff0O8Q7bxTvkM3iXP4Hvli3hMzufdciHvlct4n1wN /prB383g7y4w9hD42wv+ngF/z4K/l8DfH8Hfn8DfR+Dvz/J20wT5dtO58l3g6KipUP7AdJ18zLRR /tC0Bfy1g7+7wN+Pwd8vwN/z4O9N8Hd8NH+TP0/i72zwlw3+CsFflfhZC/B3M/j7V/C3D/y9Av7e Bn+fsyv5ZPB3Efi7Bvz9E/hTwd894O9h8PdL8HcY/P0na5SmsCacKwlcTZBWgz8f+AuDv1bwtxP8 3Qf+9oK/PvD3Ovg7xmtlxuvkNF4vz+bN8qV8h3wlb5fXgr9K8FcH/r4J/r4H/vaAvyfA36/B32/A 3xfyCpNNvtqUIa8BJ+tMC+RiU4FcAm6Cpq/LYdMNctQUkreYNsvbTC3g73bwh/Nnehz8vQb+3gV/ /yl/aHbIg+az5I/MufLH5uXyJ+ZS+TPzRtNXzVsZM98p7lNsVny53VlZBVtbWmxmbrMOdHYOtrW1 DYqKJdSm4moL2SzcZhtsa8WFHhN6BlUVX+qoikrDcgtU9e7WglyqYMKwmGXj3GZSjYtUt3Xuju3u 7GwTCsxGx6DNxm2Onp77cd15JynYt++++3bt6uigSkMrXQ2kgKzEJLs1qcdCPlBXZxvptpR1qh7F 3VlmMzObZUjRrxHjdHWChJaWgoKsLLfb5mQ2Z6vSqqzwrPB8DaKoChzD3NZly3Jyli1rJUVtbUVF QpHFzC3WQVtDWxtZZYUTbWJ1i4lbzCHhVIjabWIIBtH4UNuQqjbYTMxmyvEMesSFQRZLQ2dnmRrS uYemR/eLKTp1TGfIIWs2WWGGFzFyUFUFlbs7R3FssXGL4/Fnd+CiJXVdxuq4hFUWq24r7YjFqhto s1lkbjEN6FrghSWkxnLcA1YTs5p0Y3NIjRh9R5XFzCxmnQyLnVnsbWqbugb5fgZE70NPUZstMczj EQuYB1BQB5JsZip5M+B2l3k8zCNLjMsYYuHcIqvitlHluGSVWzFnp9PM7Gabze1WhEZV5TLSwQC3 MJNl2CSsLhscLHNI0C56xeXxUFUUxKWqsoyTt3v3brud25yZ7Bx2jbpTvVe9T72LeZAjaJuJK2IL lbLdxPqQ0YPVFU+8ErLZjGE5OUVFnUM4SXTg6FQbPbkeOh16ZYiMFztvrNNgcw/YbMxm37BrV9WU 2bOX/oXgxPG1ikBTVSPQ/q7BaR07OAVP3Wo3OLpX3QURez06SBGK9tyCFlxYIh6JIkhtiZ48+e8S pK4vBSmNKEB3VkHLqYLUbuZ2q5ocpRY9SqnDFg9TOkKdg6LDxOwI07HidETZKQLVlAhUu4nbEahG pNo5t8cJ/1+Fqsgyj8ZOClVKLJ6xY9XyF2LVkohVyxixmmw1U8mjss7TiVb76UWrU4L+kWhFlFJ9 JFz1eLWLeHU4uM01nSnqNZ6dkNs87bDHg3d0OlaJiEUlEbHUMxKxesWIWFQSEYtKImJFjMUjVvTE I9ZYhyLWjoj1sp1sF+40nGyyep56BbPb8WVjkyGC3MVsOx0Lu4XbbULfEE70EN647La8JeTtkjxR sw+1ighpQZ84WUOqHrqJ2pCqv+HZ7WLed1tajHli0gkBo08WrdeqB3Nbq9BiGekasju43RXDtcez h3jc6emAIFDtju49e27dseNb3/om1fKW3CguLCXUkel0wu2ijy1hN8ZlCTaBq4lhbUhKZLu4jyC6 7VZmt55wG1fcdkoYRJrQvBiECdoEfTZmd3J7ioj1m41ov0gV0Q567bYbl5x3Xvp55y25kfQaycHt tpq5VexwAw69w8IdNih9Yh8s2veE6NJva9pC1GUymaId6OqIWi3cKm4khlV1q8PEHOZ40Hsw0mrd Kg6CigENo3TCRSLdCHzVJWv2ROQj9h1m7hBZwtgHB+eOxBapVju3un7G+imb6kKGGLpHjGrVlzXa 9z0hNkBUDdvhhdXErUYuUEVZ5LUyt3tA5C/ziCc5pI/UwWFBkwh0RLrVwazOAk+B5wJVyETcROvd 6CwqanMkDUUEkP5Bt4jlQQeXHCPvEeCAvBWhlqMIEkwSk0wifJEHrHBbZAZV4lxCWbJi6s6dKRbm tJhMo9IDN5kH8FRjtp4w014ODQ2FUmTuMCtJCUKhFlHQL3QhmTgsnbic4tRMULGFylXKDmWnstPz HUoTlzPjRBp5gmpGnlCGjD6yxZOo6WcX59qanpW1bFnbsM02EpPIFTZDC5KFni1o5DB5BJeopqcL 5AuHgzmcXjwBi4zhY3bV4UnzzPCcg3hiDhzqRNbYjjCgQLNyh53iSWSHYYcN1fzFOgmL80XVMdxC IXojesXRHB5JFcO0G/HModJgmnvLjTcac8U8jWafdDJJVevIrUCrqFrjncMOJ3ekxMpiZcjIu29V bkV43qyIMCWlIoPoKQRpwuHMN1wZuRYjUZB64ZaeTpyOMcddzlgsTgAySmtri3HCxOkW1DuszGGL pxR33Cc9ZxGrX04qNibsT21VRm4iEonFgT49sVBmIfXxzOI24tG0FfHjtHCnSAPJucVq5BbqM42d XJwm5hTJJZ5drOjbJiJcxY3e1tFq/2p6cZq5k/bFyC9Ozp1Ju/gPSjDC1QZK6oP/6ATj5JJzJMEI GshhEZWnk2LsmCxcPmWSsTGzTUOSQZCLJJMqc2dSkhHJhZoSWcZIM05KMy4XTtGEWI7icS/t3IGG W93fUzpiHlbGpusBZDyZCnbNksOmxFON0Us2KZ7heLUBVBtvMenxbEPVrXAyqTfPYxwRvRrPN574 umLbbIOnzDhOB3M6XCyN5ByIR92uQqlH9Tit3GmEHCUdpw31TK9Oi8ebKeqOoZv0tNNy0xCdWZF2 jLyTqBOoTjt3OqezMtXDsIXsFl2PWqZOZ9SVOK5a0tE9+SiTVS3xG5oWsUoiJWHVFO6cEEuPpe/O 2p3Vuaxzmcjw37J9y9Zio1Vi6m5IJ6RNbYW0QG7UbZvGykflnsWoT2MGDXRLRsHnOMXQs5Gm4oP1 NEXWYRvgZ45NbJrTypxJicp9kuMJdfmMdkbsA77Uc2hvxB65IORjCzy60q1LlnB2t9vj9jjtIFMo 0POcLX73KZjD2vT0pK9tfJyCNIZD4rJyF+XIJ/aJO7F9T4x6vKReCdfCpaJ36ULjQVKkMvSamcuc m8hl4uTYEsmsZetJylta9HeZOH8psuZIzmdKzGXhLsp/I/vs4tyVfAxUm5PbUp+M9SqtSUIPnyOL jHoSdSZ6KK9RfcQbOEZPoEZiU42be/HmgvcWvNVYPJ4h3bVc0qovABrwuGkb84F0JL/pj9IioyHB OZOHI0pHnigQr+qQi0uu+K254IY4CLUh2E9OcjYuiUdydnKWc4ksl2plLqskjeQ5I82Zv5zmJsjc JdKcx1gSJYXaqDSS5yjRuawi0aWIY2eNpeco7quWLduP4GrrbLu187tleqqjs6/zPUK5055T1Gkc 9RNUb2gF2SaR7RJ1pDtJQmyI/OKaPPm8goJWDV5Tv57vJOoXdT3hJfSfMByFp4n1xY6ahpxO5nSF PG3qDnYzpC7mUBxKmjJDWRxzOZnLmcpS2VkkF6kXqWWx7biTETczLht3OYZ7e3v3Dff29PT0Drvs aJjOQmoZiyVJGVqmM6QDl+sE61G71VjS1a32qCcYHfwToj5MrScSDSf0cTR9uhry6Lr7jOllsVBs ukqdCZ1a8gIxl4TzMqpB2N3T299/aPDQof7e3h6xmC1pwAlXKne5B6YNTBvMOzDnUPBQcP/K/v59 HX0dPa4eFy02EBuMHYgdgvRDeiHPxHpi3SCMu1Kms00GRSNSFtsUAwU6YcQVLZTqOvVolQ2wHGJ0 mPWyHpJeJsp6rVsljvIqYrGBhmmpFkt/g8vGXHYtPXGdxEvi8qqXM9pbfTkhYm/1XRb77ZrAXRO7 Ld2WnpvKO8o7Kvor+hccmlec15Cek56jE9hTUZGXnp5XUdHT43JoLrtX9aqXMCGZ4g+fxYUeXLf2 WizbentfqE+x8RSHMOHw2z3ievuw/mhfQXZV5FG/jGtRJfVXLhLP1XCztxcnYUNeioWnWPLKysqG yozLJfq34xj2bo1tw4xtJy/R05Mi8RRTLIb3nZHLbdJSzDk5jOUkroEUK0+xi95eHI3BQ/39vcbE pMvu4vYJhwfeyekdJfTwH19P/yiggsoVea6kvrcP6wfQ7oj7B1/piejQwMgS4jOBhn1iW10dDeIO zpJwN5d0G+uAHPE5gPicsZwJWQCZBrGn4ksc1vL0yjt8d8x7NG8wvSy9jD4HoH0T2+Yae246JIeR EcOu9PQcnI/hFElKSYoh8EhcNXRYLBZXLrgDj2aZS2ZYGFPxDmg3C7qZYFy8HaImOaBDBMtEK0u1 YpoLytMF72JOjJu42TLIxUdtmmrB4vaGYVwNbhP2Wx9iRHxZWQ41Usm4RL8ZJ8PWL65UhO9E60B6 bk56ZTB4FAHcf6j/9UMvhCgXeZAvxAE29mdki1yO3IZDI4GjUcPWXuwNLAUHiQZLngWtvVspNFNx 0qeAt5msgi1FYMJ0JoRGbxP7tdUYLRoyicvexIqaLPjTeUjYVH65WHQIt8uu1JDSRol5Bwsz04Dd bXdPdJ/j9ui/WeBg90rFTC5vDAfZ5MqwfyNbGPRGa9hK9PBrVy9RsJPi/08X3+ezsBTc4ug1zrAF 7Axq11sk3ABNgCdTmLy8qGgZO2/1qqsVlvP11YUK7rD0MeLndtzsTKrJWGFiXDse0XDDNdWo4SaH TWIZ7KzyUCTE7iP8EeGjhI8TPkX4zEZ/uIbtJ3yB8CDhG4QDhG8THhU/d8Y+FsgthBmE2YRLCNcS 3lC9sXoj30Z4E+F3CW8j/D7hA4QPx3/65q8hP020gUkZHFjAMGKNOf8vtknYh5S/+VWcaPFz6+In m1vwFHQve4w9w15iR9jHXGJ28tRmeHuUid8ZkTFvMvIGF98j5Qv117ab9Nd7hpLm4Lwdu3dUnbuG R9dTZ46uT0wbXZ/UNbp+/onR9ayT+i/IGF2fh8wmJdc/Teq3MH5V3uj6ypvx6sCZzmJF4vdsMKcF VOVIRWy7dJ/0Gtst3yPfww6aoqY97BXzy5Y2LjuudXj5k45v44lsv8vtulK6wnWd6/tSY4ov5Qbp P1K2p3RI+1KlVJv0UurnqZ9LrzOuHhfcWF5NeXxMOQB5I+UPSfK+IQfGkE9TZ8QlC7IQUgC5geSO kyXlQOq9qf/mvs2Q3UnyIyHi5nwMcUwsisvNE3fF5bguadPGkGzIvMldSXKfLtRzkkx+bPL+uLxw xgDkbSFTTGNJWvaUtClZZ96cJLtInhlTDpz5xYikT07PiEuBISvGlCKStcbraFENFON6SQ7GRZ/9 Vvrg1Aum+qZ+f+qDQk7WPvXhsUTXPvWJqUcM+TQhYpWpX9Baqvh39spzF8Zl5bmr4+Iz5AaIeu4N 510M8ZyffX7BuTcAs89/Zub+Wa+SfJpVCgnNngmZM/vI7CH8OzL7xAX7L/y+kNlHLnzqwvcvfH+O aU7qnMlzfg45mJ0PKcounXu3IU9fpF4y85J35+1cMA+Sf2n6paWXNuQ+ZshTub25BxdeAMldeNOi w5dZSDove4ZkOH9B/kOGPH7ZMOoP5Q9SbfBy6XIp/6HL53i+63lqcfaVxZC3rqq6rFMfjddBfdTy fDFu+coVM1bkrMhf8WDhTJKiwhtIGgpvKrwb2FD4HGRgZdNKdeVbV4cgt11ThlFF17xwzQuFzwEP ixLkyDVHr/lilUrywKp+krdWHcW/t1YdLzKtOo7+o0WlRYeLjnwtCtm5WsG4B1Yd13tWN606vvoP q4+tKVrbW1x8fdr1066fWWmqLK08VPnFyGvVHMhjNe6aGaGGUEsoFjoSOho6vsm06eJNBZsqNoU2 NW1q23Tbpoc2Pb5p36aXwqHwzvCD4Y8jLJIWWRbZEHkq8mp0XnRD9O66tXVtdU/XfVpvqZ9Tv7T+ ofq3Nxds/qJhWsPShrKGcMPdDQ83HGqc0fiNxscbDzV+0eRqmtKU27Skydf0QNOhLRdsKdiyfssd W3605fCW41s9W5u2PtVsafY0h5sfbe5tHt6Wsa1q2wPbjm5fuL1h+8Nq0Sly1eMn56PR2UatT4jI I/QhkyF6BjlF7K04OeJGx4l+0sfMOiOZJ0lG5w61NyEiO6gHE6LnBZFD3T9K7z1zF/LwG/mDyJqU g+kV+XZiEfLrHan3um9LORDPmRj737zdC3RcZbn/8Z2ZNEmTCdBSSkvBEgooICAXQanIRahctCAK IngwIqhBRATKRS20hIvIpSpyU48oIBYUUGNVVGKBIiWl0EuShqQSmnRIGiZpkmYmQwHf89m7ASv8 zzqe/1r//5r1dc/s27zP7/c8z7sn1tcJhRnnxNdW/36bO//ZO7eopDsfk/TfLWftts09b6oX7417 cXJue3w8OX9MQff9ffV6nfweV7Qnd1thdLfbtievf84OfW+bFY7Zah7450xwTzzud3T/B9/R/SvH ev53kn6fdPnkPq7e5hjv73yzE/Jj4ZhfetOW/rOlv435qCfqgLFr57zVHd90VI+bcsK8rviKf3o8 45R5XfO63C0+a8Sxk6d2zTjlnTmhDzZv1VH/D3126776zp461rn/lmTTli76sTf7Z9zX7fGt83JT F9pzypSTDzl49nOTS7fMY8nWnLXj5h1eklUT35x93pxVJu48ufSfM9CWrIzntuTs0vgM1z4xeWJ8 JN4TnxXvn7hz9Yo3M3XKThN3NgNOjK+P32/Z+895dOuZNB5LMmuOzZtbzZwT3eHt8+QP/mV2XDE2 M056c/SOb97y7fH3n3jyDi9NOcZ4/kX9WLVYY05tVbFvarylEmM1t2TKjHPofULsZqzElJMn/TDx e2HszVZVfdjUh8X65gzbvOWu83JT5s3LbXnF3xBvZ5wSuxK/25Jp8XZebo/9dj9wC1tmuN0PTGal rV7xDLdldkvmx//LVzKnbvV65xnJTLvVa2zGfev1zivimfZ/90rm4n/79daM/d+83q5U/HprHv9v XsnM/m+/kqeNf/P1dnWSZ5StXu/UL3l22eoV5/0Wp/93r3fe+X8e3b/32qJz/OyyzT2Hl52w2+Gv V7fHTz3J67vJnrL4SSf59N0TdoufgcaOeXmC+kD81LRlb9z743fxK3k6Oj15soqfoQY/PJg8H3k6 8u6Jw7+bPJ3Me+spJn7df9K82WtPmhc/wSSf7h97ztny/n5PQV3xnviJJr5u9tgreeK5JHk2cm5y 9P74P6c+7Oz746cp3WLP2WuT567Lx14nJ3v2jJ+6kk8nz14b96WxY16e3N7nWS1+Qouvuy5555U8 p12YPM85N3lSe+t57cSTj0glirwea/GJS7YocXhZEo8RbxnpiU3JveNvui65V3Lff63Edzq6dR68 u3XLp6gsXt8vXtcvXtUvXtMvXtEv3RgdGsXrEq1IVreL3+WStbFKkpX4UvEqe8kae1XRL8Pr0ZLw eklttH3J56NTSs6OppZ8IaopOSeaUPKVZF2/g+MV7JL160qSdepKnZtx7gTnZpxbmdwv66yBaHzJ WdHOjs9w/FTHd3F8hnvt4V418XpyyQpyVfH6b/GKb+lvGcfc8AfjPSzdHe5Ir4/el85GB6Z7on3S G8LKdJ9fu/HdVyRrvJXGK7HF67DFq7Ala7BdHm0bnRBth8OivaKZiNdkOxdfRLwyW7wu2xxcistw OeJV2uI12r6Jb2EurkS966/BtbgO1+PbuAHfwY24CY9GR0d/QtH7fyBEe5VEKMHJ0cyST+AUfBKf Ql10UrwCXLz+W/q06EPpM6OK9OdwfvTteHWl9Pxo13R99K7Su8Oq0p/iZ1gV7VW6Gs1oQSvWoA0v oB0dWIu/R3uN2y6sHPdSWDXulSgzLud9PwbDqrJx0Qlle9keFO1Vdojt+WFl2VdxAb6GOaGn7FLQ pow2ZbQp+wZoU/ZINLPs1/gDRqOZ5XtH08v3weeivcprcTa+jotwBeZhPmhU/l18D3fjZ9HR5b+0 7ccABjGEYYyChhVfwDk4F3Oi6eOjaOb4SdH0JHdfTta0i99tSFao20HWNsjaBtm2p2w7SrZdLds+ KdvOlm3Hy7Yj49Xk4jXj0qeFW+JV4+I14+IV4+L14tKN4f50tzzLRun0y3JwQ3Rmkmfrk7XjJrxV FWdF+291/+Pc/1L3P9b9D43XdnPvH8Sru8Vru8Uru8XrurnfX9zvtGgbd9noLhvdZTt3ebe7XOAu +7vL/u6yj7vEKz++GK/B5k7xqnYHJmuwxZE+k6yWNsU9/uoef3WP95R8LvzJffZ3n8+5z8Hu80n3 OSJeA8299i+5M/wxXtMsXrnM/S6N1y6LVy6L1y2LVy1Ld4URo2tK96rWDdG+6b6xip3grnu7a527 Huqux7rr7u74HndbHa9SlKwc+gf5WzXWYd7QSeLOcldUH3LRNbgW1+F6fBs34DuI18O8CU2hGC3D s1iO5/A8VmAlVmE1mtGCNvw9hOhFdOIlrEMXusOyaD2yGA4d0SZ1PoI8ChhFUXd71fHNeA2v4w38 w1hCyJVEKEm6Ynf6DBn22bAxfZZtbdhYuirkSlejGS1oxRq04QW0owNr8Xf0hmLpBvThFeTQjwFs xCCGMIxNGIGxlP4DISwbNzEsKz8yFMuPxQk4EbNDT/mnbE/FGY6fibPwuZArr8XZ+IpjX7e9CJd4 fxkuxxU+f8t2nu18XOf99eBD+QLb79p+D7d6/wPchttxh/vfbf893t/n/S+9f8T7P4NH5Twq51E5 j8o7QihfCx6V86icR+UvuWYdusCj8g2ho7wPr4glh/6wonwAGx0bdO8hDGPEZ96VF2xHfeZRxRdw Ds7lVyq6JZqUzFzp6Ba5e2q8chV/x/n0kE8n+HS8LF+Sfj7aJyqxtxAdIzM7ZGaHzOyQmR0ys0Nm dsjMDpnZITM7ZGaHs3tkWlGmFWVaUaYVZVpRphVlUU7GFGRMQcYUZEzB98XrmHWk/yMal/48zpZB XwjdsqZD1nTImg5Z0yFrOmRNh6zpkDUdsqZD1nTImg5Z08HJAicLnCxwsYOLHZwrcK2Dax3cKnCq wKkOrnRwo4PqRaoXqV6kepHqRarmqJqjaIGiBYoWqNhBxQIVO6jYQcWOpGLbo3JaHqWSK8y9j5l7 F6VXmGtXmoXMNom+fSJcKcJ1ib7f8ilej3dn+l7tDmui082TNebJGvNkjXmyxjxZY56sMU/WmCdr zJM15ska33SIuXJ3c+XuarZZzTar2WY1u07N5tVsXs3m1WxezebNpxPVbFbNZtVsVs1m1Sy/oxPN mwer03XqtFOdrlOnnemzoz3TX4jX1o2uMY9ON49ON49OM3fWmDtrzJ015s4ac2eNubPG3Flj7qwx d9aYO2vMnTXmzhq1mFWLWbWYVYvNai+v5prVXLOay5rjasxxNea3GvNbjXmtRq1kzW015rbd1UrW /FYj/5vlf7P8b5b/zfJ/nfxfJ//z8j9v/pto/pso/7NyvlnO5+V81hxYY/6rMf/VmP9q4nwPw7Qe 9nx2S7iWA8fp5+v08zmcOI4TP3f0Jtl+bHqVJ6nm8I90S3R24l6Hs9ud1WbGvCVc6dPZrl3l2tX2 HunaW1z7tGtPcG2z6z4TlY3V0aed2eLMZmeekDxfxTnzi+RO5zp+hOPPOd7q+Ex3usHRX7vT0e7U 5E7vS85/IXlOfDH5z0JUWbJtNL3kDJyPr+JruBBfx0W4BN8x00+I16SM15+MV5+M155Mno1+Gu2Y /nP0/vTj/O+KZpi1P+kpcaKZeydPiTPSvTrDBiPos++V6P3m84vC466Y7Jlyt3hOd/350fFmsDPk /JnR8emzkqev46NtjGyakU0zsmlGNs3IphnZNCObZmTTjGyakU1z5SRXXuDKSa68ILmy2pXVrqx2 ZbUrq11Z7cpqV1a7stqV1a7c05UHuHJPVx6QXJlxZcaVGVdmXJlxZcaVGVdmXJlxZWbsyoPHrjxY JGdGe3u3d6JxQ/KMMBqvSRmv5YZP4BR8Ep+KKj27VXp2q/TsVunZrXJ8/N/TlsbrSsZrJI49aSxJ PFoXNZe8J3SV7IW9sQ/ei32xH/bH+3AADsRBOBjvxyE4FB/AB3EYZuJDOBwfxhE4EkfhaHwEx+BY zMJHcRyOxwk4ER/DxzEbJ+GH+BF+jJ/gbvwUP8M9uBf34ee4H7/AQjyAB/FL/AoP4WE8gl/jN/gt GvA7LPK0ttj28dBe8gSexBI8hb/Z/3RoKVmKZ9CEZYjXt1yO5/C8J4gz/Fo5K6wofcqTxN/wNJbi GTRhGZ7F8tBS+hyeDy3jJoSucZOwAyZjR0zB1NBVtgB3gQZlPwkvl90fNpb9AgvxAB7E7+x/0tbT ZtlT3q8ILWWrnd/mfSF0le+Cd2E6dkVN2Fi+G2Zgd+yBPUNL+bvxntBevhfkQrlcKOd7+YE+H+TY zPBy+YdsTwkbK1KhqyKNUoxDGcpRgfGoRBUyqMY22BbbQbwVE7E9xF0h7gpxV4i7QtwV4q7YCdOw M4y/wvgrjL/C+CtqsBtmYHfsgT2N6cDwcsVB+GBoqTgMM+07ErPwUXzOeWfbftGxLznvy6jDeZjj 2FxciaswDwvsv9f5v3D+wtBe8YDPD2LYvnzoGl8CsY7fPrSMF8f4HcLL43eVQ99M1lClTgl1SqhT Qp0S6pRQp8QVJdQpoU4JZZKVVidgIrbHJOyAydgRUzAV8Vqs8Uqs07ErarAbZmB37IE98e54JV+/ svfC3tgH78W+2A/74304AAfiIByM9+MQHIoP4IM4DDPxIRyOD+MIHImjcDQ+gmNwLGbhozgOx+ME nIiP4eOYjZMQryL7CZyCT+JTONW4T8OncTo+g3gF2CtxFeZhPq5GPa7BtbgO1+PbiFekjdej/R6+ j1vxA9yG23EH4hVaf4Qf4ye4Gz/Fz3AP7sV9+DnuhxmwZCEewIP4JX6Fh/Aw9NoSvbbkN/gtGvC7 eDXceGVaPIEnsQRPxevCYimeQROW4e1d5NTw+Xi1XPPAtjr/h8wD2+r+8Qr8K0t1vFIdr1THK9Xx SnW8Uh2vVMcr1fFKdbxSHa9UxyvV8Uof9hvlEfwav8Fv0YDfYRH+GPpLH8Wf8Gf8BY+hEX/FYjyO J/AklmB5lCl9Ds9HmXETospxk6KqcTtgMnbEFEyNqspuCv1lN4dc2QLvb/f+ztBTdpc5iQdJN/up Y2Ip+7ljxlxmzGXGXKZLlz0S1pf9Gr91rAFxl/u98/9g36OO/wl/9vkvMM4y40y639M+Nzm2zPZZ +5bjOTyPFVGmbLXv9tuuzG+7slb71oTRpFO2G5vfc2U9rvWbpSznvafrMk/XZRvhN0uZ3yxlfrOU bcII8iiIbTSsL98m9Jdvi+0wAVPCaPlU7IRp2Bm7RJXl78J07Io9o0z5u/Ee7IUD7DvQ9iCYZcvN rlu6bpSpSEVVFWmUYhzKEP8r8QqMRyWqkEE1tsG22A4TMBHbY1JUWbEDJmNHTMFU7IRp2BnGWWGc FcZZYZwVNdgNM7A79sC7Q3/FPn6jvRf7Yj+fPSlUHOD9m534YO8PwaH4AD4ojsPwMe8/Dr9zK05y 3clhScUncAo+E0YrPmecX3Te27u037sVfu9WXIa5xnAlrsI859/gu9V/0rVvt73Tfe/CD/Ej/ML9 FuLNLv5L+3hYkXfta2F0fBTWjy+J/yddITc+/of5lbYT7N8+yiSd3Qw1fkf7pmAq9OPxO8d/l4wr fey5am687nTyjPbEW/sviNd7Tv6OEj9vDUTjUseFz6Y/Hp70dFoZ/23Lsf7ovan3hb7UwTgUR+C4 sDJ1fFiWOhEf91R+anjR08VaTxdrK08PyyrPwPWhr/LbuAHfwY24CTfDb7nKBfguvofv41b8ALfh dtyBO3EXfogf4cf4T/wEd+On+Bnuwb24L/Rl9gl9UdpIC6nT/Sa+yG/omcafN/586rCQNf586iO2 N4R1qe/47XJmtK/+ta8zl1V+MmQrP4XT8Fl8IayrPA/n4wJciEtwfciLLS+2vNjyYsuLLS+2vNjy YsuLLS+2vNjyYsuLLS+2vNjyYsuLLS+2vNjyYsuLLS+2vNjyYsuLLS+2vNjyYsuLLV91QlhXdSI+ ho9jNk7CyfhEWCf2PA8PDWs49Gwq8TEsTf5yOF3sC8W9MHVmeDh1Dr6KG8JiGsTrnreLfaHYF4p9 odgXin2x2BeLfbHYF4t9sdgXV14eHq68At/EfFwbHjauxca12LgWG9di41psXIuNa7FxLY6O4kAd B+qMrZsDdcY3KoNGZNCIcXYaSZuRtKVP/cdI+vR/5M0u1ZzZ3+xSzZ39x37jL5FdI7JrxOjajK7N 6NqMrs3o2oyujTN1nKnjTB1n6jhTx5k6ztRxpo4zdZyp40wdZ+o4U8eZOs7UcaaOM3WcqeNMHWfq OFPHmTrO1HGmjjN1nKnjTB1n6jhTx5k6CrRRoI0CbRRoo0AbBdoo0EaBNs7URR+hQi0VannxDBVq +fFM6rhoF9HPFv3ssb+33jj2e3pvKkymwkFUmEyFg8b+SvwZXj3Dq2d49QyvnqHGbGrMpsZsasym xmxqzKZGLTVqqVFLjVpq1FKjlhq11KilRi01aqlRS41aatRSo5YatdSopUYtNWqpUUuNWmrUUqOW GrXUqKVGLTVqqVFLjVpq1FKjlhqzqTGbGrOpMZsas6kxmxqzqTGbGrVRuVwYEXFGxN8T8aUinijC K0V4WTSVRkvos4Q2rbRppcNEGkx09FbxLxH/EvEvEf8S8beKv1X8reJvFX+r+FuNo9U4Wo2j1Tha jaPVOFqNo9U4WtVKXfjF2/rdSLRv6hN63Omo0+fO0+O+gvPh3kb80lu9bq6ecVVYVvXN0Ff1LczF lbgK8zAfV6Me1+BaXAe9sUpvrNIbq/TGKr2xSm+s0hur9MYqvbFKb6zSF6v0xSp9sUpfrNIXq/TF Kn2xSl/cZjwqUaXnxZ29Lxl7Xo1n1XhWjWfpFv9O39PRVWo3q3azajerdrNqN2vseWPPG3ve2PPG njf2vLHnjT1v7Hljzxt73tjzxp439ryx5409b+x5Y88be97Y88aeN/a8seeNPW/seWPPG3ve2PPG njf2vLHnjT1v7HHPOj28QO1nKfz4Wz0rjqgzOlBEDY53OT7Kjde58To3Xndup3MrnFulUipFup9K qRTtfmN/A/obh17n0OuibBBlgygbRNkgygZRNoiyQZQNomwQZYMoG0TZIMoGUTaIskGUDaJsEGWD KBtE2SDKBlE2iLJBlA2ibBBlgygbRNkgygZRNoiyQZQNomyI3i+Set4s5c3SVF20M3+WiuALKuBV FVAQyTUi2XHsLzM7xn+ZEckd8V+zeLeUd0t5t5R3S3m3VFT1oqoXVb2o6kVVL6p6UdWLql5U9aKq F1W9qOpFVS+qelHVi6peVPWiqhdVvajqRVUvqnpR1YuqXlT1oqoXVb2o6kVVL6p6UdWLql5U9er4 9KSOPyCK58f+O6dZRn2rUf82qhLvcvEuF+tyce0gph0cuU08y8WzXDzLxbNcPMujstQcvl4aXk1d Fl5OXSMvbg4Dqdviv7Tbuzl1TShEJf7z1WgvZxRSl8uIK3BNaEldF1Wkrnf1TaE3dXu83n54LXVX eK3K822V59uqXfAuTMeuqMFuOMc55+KL+BK+jDqch6/gfHwVF+BruBBfx0W4GJdgDi7FZbgcV+Ab 4bUkns1G2p2aG3rEsj71g7Ax5ZdedEbqItl+MebYe7kor8BVYUVqHubjalwT7ZC6LjySWuC874aX Ut/D93Er7gyPiu/RqlR4tiqNUoxDGcpRgfGoRBUyqMY22BbbYQImYntMwg6YjB0xBVOxE6aFARoO 0HCAhgM0HKDhAA0HaDhQdVhYUTUTH8Lh+DCOwJE4CkfjIzgGx2IWPorjcDzOEce5+CK+hC+jDufh KzgfX8UF+BouxNdxES7GJZiDS3EZLscV+EZ4NCqVOS9ScTUV16VuD0Ny6ZowLE9Go5O5UORCkQOb ORBn2DozTsGMU3BGgcpFKhfNMAUzTMEMUzDDFMwwBTNMgfpF6hepX6R+kfpF6hepX6R+kfpF6hep X6R+kfpF6hepX6R+kfpF6hepX6R+kfpF6hepX6R+kfpF6m+m/mbqb6b+Zupvpv5m6m+m/mazXMEs VzDLFcxyBbNcwSxXMMsVzHIF6hapW6RukbpF6hapW6RukbpF6hapW6RukbpF6hapW6RukbpF6hap W6RukbpF6hapW6RuUc1dKrvjWpxL0ytl9zXRNtTupnYXtTdGF9K4kcaNMr3XmUtp3U3r7tQ3fJ4b NrhqWObnZH5O5udkfo4Pb/ChkQ+NfBhK3RKeVgFrVMAaFbBGBaxRS8/qDX/jUQuPWnjUyKNGHjXy qJFHjTxq5FEjjxp51MijRh418qiRR408auRRI48aedTIo0YeNfKokUeNPGrkUSOPGnnUyKNGHjXy qJFHjTxq5FEjj7p51M2jbh5186ibR9086uZRtwrJqZCcCsmpkJwKyamQnArJqZCcCsmpkJwKyamQ nArJqZCcCsmpkByPG3ncyONGHjfyuJHHjTxu5HEjj1t43MLjFh638LiFxy08buFxC49beNzC4xYe t/C4hcctPG7hcQuPW3jcwuMWHrfwuIXHLTxuieo4mOVgloOb+P0EFzdyrp1zr3BugHMDnBvg3AD/ M/z/Lfdy3MulbrTvZk4vCA9xsJeDvRzs5WAvB/s5OCRPHuNiJxc7uZjjYo6LOS7muJjjYo6LWS5m uZjlYpaLWS5muZjlYpaLWS5muZjlYpaLWS5muZjlYpaLWS5muZjlYpaLWS5muZjlYpaLWS4NcGmA SwNcGuDSAJcGuDTApQEuDXBpgEsDXBrg0gCXBrg0wKUBLuW4lONSjks5LuW4lONSjks5LnVyqZNL nVzq5FInlzq51MmlTi51cqmTS51c6uRSJ5c6udTJpU4udXKpk0udXOrkUieXOrnUGb2PSwUuFZJq 3OLCCBeGuDDEgQIH4t9NQ9Qdou4QdYeoO0TdIeoWqFugboG6BeoWqFugboG6BeoWqFugboG6BeoW qFugboG6BeoWqFugboG6BeoWqFugboG6BeoWqDNEnSHqDFFniDpD1BmizhB1hqK9dYbXdYbXVX/O fF6ZulEUN4kiGb33t+NO8/1d5u1pnup2xi54F6ZjV9RgN5zjnHPxRXwJX4YnSFqP0nqU1qO0HqX1 KK1HaT1K61Faj9J6lNajtB6l9SitR2k9SutRWo9GX6Z1L617jThnxDlV0KcK+lRBnyroS/R/swLo /o7M9wSfiv+y8d9ney8/evnRy49efvTyo5cfvfzo5UcvP3r50cuPXn708qOXH7386OVHLz96+dHL j15+9PKjlx+9/OjlRy8FcxTMUTBHwRwFcxTMUTBHwZxq6FMNfaqhTzX0qYY+1dCnGvpUQ59q6FMN faqhTzX0qYY+1dCnGvpUQ9+/UQ19HOrjUB+H+jjUx6E+DvVxqI9DfRzq41Afh/o41MehPg71caiP Q30c6uNQH4f6ONTHoT4O9SVz/GDy30Iewqscr3K6TU63ydI+R/tY4xyNczTO0ThH4xyNczTO0ThH 4xyNczTO0ThH4xyNczTO0ThH4xyNczTO0ThH4xyNczTO0ThH4zjGnBhzYsyJMSfGnBhzYsyJMSfG nBhzYsyJMSfGnBhzYsyJMVcV58IcXIrLIN/EmKuK/39St9OL8/9aMzLtxqTSC3pq4X+qEc/ul3pG 9ctUtWVUW5lqW6fSdlBpldHstzrKHLPxXFzpd/k1vuuGMCizB51dVJuDZucRV+1H4QKFR7Z6ahqU 3YOye1B2D8ruQdk9+P+p2wzKvkHZNyj7BmXfoOwblH2Dsm/w/+lTUfxrpUipp9/63TISpcf2Fbn0 WnQqbZto28S/fv710zb+ZdPOiXH07aFvT9L/Fvj8A78RbvOkdKd9d4UeuvbQtYeuPXTtoWsPXXvo 2kTXJro20bWJrk10baJrE12b6NpE1ya6NtG1ia5NdG2iaxNdm+jaRNcmujbRtYmuTXRtomsTXZvo 2iSn+uVUv5zql1P9cqpfTvXLqX451U/3Hrr30L2H7j1076F7D9176N5D9x6699C9h+49dO+hew/d e+jeQ/ceuvfQvYfuPXTvoXsP3Xvo3lMVxzkHl+IyXI4r8I3Qk2j86lglFKPtU4uiyanHPXE+IS+f DPNST4eFqU2eM/JhQerVsCKtc6b39et1//BI+uCQfetfK58WbZf+dPL/Pxj/m8LeTEd4jmP3ue/D eEIFPBmaU0tk+lN42ncutV0WOlLP+aXb7NtabFvRG41PbVCpec+4BU9Co9gchtJReCldjgpM9et/ /9CdPiBsSh+Ig/D+UEjPDF2Z2pDLnBuWZ74CPSLzNdsLQ0fm69ATMt+0nWt7JTxDZ+phxszcDFWZ WeD4rfbpfZk7fL4TP3aP+8KrmQfc/xH8OmzK/Aa/ta/B50dtxZRZYd9KrMIan9vQ4f1avOS8/vBS ZhNGw0vVk8JA9Q6YDL8Oq/06rN7d/vPC8mrP9NXGVX19GKm+OWyqvg134d4wEJ0wpmo7n4pUXUPV fqr2U/V1qq6nahtV11B1E1XXUHUNNQvUHKbmMCWHKTlMyWEqvkrFPBXzVMxTsJ+C7RRcQ8E1FGyn 4BoKtlGwjYLtFGx7m4LtFOynYD8F+ynYRsF2CrZTsJ+C/RRcQ71+6vVTL0+9POX6KZanWJ5ieUrl KZWnVD+lhik1TKlhSg1TaphSw5QaptQwpYYptWZMqXZK9VMqT6k8pfKUGo52Sz0YvplaFH5NqUY5 +BqF7qfKK6kXw5fk2ZzUhnC37D4tNeJJ+9XwYXn2t3Q6LEmXhVvSmXCBbG9JTwo16enRF9N7hEtk /m7p/cLRVLtX9s+Scz9KfzhcmT4qnDn2r7M6058OP02fHs5L14XH4n+/JKo/6UmPmyWexNPh777x ZX686BuzvmGDuw66Y5c7blRLM9XS4X4RPsixx8NKV8X18mxSI73Ru1y9ypXPuHK9sWWNrcodmpN6 ODg0u/Lx8IyrXnbV712xvSvW+b7OpH79qk5qeLo63dfn/cOLrnrJKJdEu8isTcmVS2TWU1gqY5a5 +jlZ1ewpssW2NayXHetlx3qZsV5mrJMZ62TFOlmxSVZskhWbZERRRhRlRFFGrJMJRZlQlAnrObee c5u4Fnf+3mgb4ykz8vt834O+949ifRRLw2a6rqVnNnN5KLj/sPsPu/9w5i6ffxIK7jMclbpqxMgv ckVXnPeehB/USxaJ5cmwwt6O1Ep9JNbwxdBHt5Xuu8Z910Sn+9YFzp6nprqTbPljmOvb57pyiBKb KbHZHbopESgxMlZXI5QYSbWFh92xQSatSOVkTyUmhXPTk7mxI6ZgRrg4vTv2CK+k38PnvbAv9+ie PsLxo5J/u3yA0Ryg9rqpO0LdEbXXTeERCgcKB7XXTYW5lA6UWECJBZRYoP66qb2Z2pupvZnaQf11 q79uqm+m+mZqzaX8CMXmZh7SiR7Gn8PFmSW2z2I5nsMLaMffHeu0XeceXeHi6ij8rXpceLi6DOWo 8XlPnKdDzQ8L1GA3NzdX3x66qu/Anfgh/jM8HFXJyGHZ2MXpg3SfN3SfN3SfN7h+qEp/Q6W/odLf UNVvRDvzI/ayQPtB2g+6qkyPGtKjhvSoIbGPiH1E7CPiHhT3oLgHxToo1kH9ZUh/GdJbhvSWIb1l SH4P6S1DxjpinIN6xZBeMaRXDJVU+sb5MuB27i/m/ve5//3UYxxtxOPh6dQSs+JTeDrcKwteS62y v1lutYU5qRfCX1Lt6MBa/B0vhutTnbZd6HbP9bZZ9KA3mi9bGlJ93r+CnMzrtx3AxnBxahBD3g9j U6jTm1bo3G06d5sKPk2Pei71mmOv443wWOoftsEsXIIU4v5VKtvGeV+mT1WGeekq7zPhq0k/29Z2 O0zAREwKM2XrcbL1ONl6nLn1uvRO4bL0NMd2xvToM+ka290wQ8/bHXuEz6b39PndeI/Pe2Fv79+L fcNH9MjP6ywPcW0+1+Zzbb5s/7h+eXP6EOccig+Eq9MftD0MM8NV6Q/ZHo4Ph/9QFcelj/T+qHCR yjht7F/MPqRCLkufEU1Jn4W68Lz++qtMXViROQ8XhtdUyWsq5Psq5DVZMl+WzJcl8zPzHb8a38YN +A5uiiZnbsYtWOD82+y7HXf4fCfucp8f+fwT27vDVzM/w724L1yX+Xm4zGx2VeZBn3+JX+GhMEtV zTLDXSUD58vA+Z4PrjPLXZX5Xbg6swi/d96j9v3ZeX/x/jE02r/E56ftX+q+TfYtw7P2LcdzWOFe K7EKq52/xrlteMGxdujesnu+qp2VeTH8ReXOMotepXqPU72zMt32ycGMHMy8DHmY6cWGsDgjDzPy MJODHMxsxCCGdIBhFLwvhscyr2Kz929AzmXknK4wr1reVcu76nR4rLrUdlyYo0vM0SXmVFf4PF73 qIQcrM6ExdXV2Mb7bbGd/RMwEdvbPym0menbzPRt1Tu63xTnTMVOmIadsYtzpzu+K2p8/2726bC6 0bzqq8IKFT6/+vpocjWvq3ldzevqG3ETbnbs1nCZyp+vU83SqWbpVLN0gfm61azqH7nPfxr33e55 r/vf5/PPcT9+ES6OanSJi3SJ3yQz8xPJfP6UTtCj4heo7P9Q2YtU7SOq9hlzbl7F/lXFdqvKlaqx SRU+pgpXq7pjVdZZKukRFXOzinlKxfSokttUyWpV0Cj7fy77T5L9i2V//L9UOETGPx+drV89YCS/ MmOtSj1illqkJ/zRvkfxhHnuSceWhFbds9XMtVjP6jdzLTIH9hvtBrPXIrPXIv3rPiN/Sp/aYOTP 6UVLjLpNv+nSb7qMvEe/bjbyjXp2s57drJ8sMfqH9IKH9IKHjPI1ozwlfuYxe63KfF6nPTcsMoMt MoOtMoMtUpv9arPfDLZKfT6gPvvV5wPq8wH1+YAZbFXmGtddixtxU2jV1Vt19Va12W82W2U2W6XD t+rwrWrzAbPZIrX5gFp6SN4/JM8fktMbzCfN5pNmebvBnNIsVzfI0yXy8j55eZ+8vE8ubpBrXXKt S651ya0NcmuDvOqSV13yaom5qFlOLTHDLZJTD5jhVpk5WuXHffJjg/zo8gT5mDxoxOOe0J4Of6T0 erPDSrlwtG6+VjdfKx+WUfUlqq6g6go58Qed+0XKLtWp11J2KWWXyo1X5MbLuvFq3Xi1brxajrxX jozqsu26bLtceUGeZHXW5Trrcp11uZxp0U1f0EXbdM7VOuJKHXEl1ddTfT211+uAK3XAlTrgSh1w pQ64krLrdb2Vut5KnW6ljtami7XrYu26WJsutlwXW66DtelgL+hgL+hWL+hW7bpTu+7Urju1607L daflutNy3ekFXaldV2of60rLdaN23ahNN1rNnaU6y1qd5b+IOxPoKKq0f9+qW13VqW72EFbZdxcW UUcU45JxBRxGUQQFHVAGJlFQQCEEcNzGFXCByCKoiBFGQOKoLK4M4hZISANFZzESAqTTVFgSkpDQ 93uqjfPX+c/3zZn55pzvcJ5TXdW36r73vfe+7+/tE7oLmaWvmKGviC7FRJdiIkgx0aKQaFFIZCgk MhQSGQqZqVxmKpeZyiUqFBMBCpmpXGYql51fyEx9xc7PY8fnsePz2PF57Pg8dnweOz6H3Z7Dbg+z 28Ps9jC7PYfdHma3FzKLuezyQnZ5Ibu8kF1eSE18FHXs6erBqkFcxC7z6qw/sKMy2VGZ7KgvmOf5 7Jo65nUN85rNvGazWyLMaynzup45Xc+crmdH1LILapmL+czFfHZALfMxnxVfyyrPZJVnssozmYv5 rPJaVnktqzyTVZ7Jaq7DX+vx03pWcx2+Wo+vSvFVKau6Dn+VspLr8E82/snGP9n4p5TVXMdqrsNH 2fgoG/+sZ/XWsnozWbl1jDmbMW5Xz7NiaxjBx5ydwvZqtZa1WSzaM7JTnJUxsnJGVs7IjjOqHOJA hJHlMLIcrDuFdTlYl4N1p7AuB6tOYdEpLCrHonIsKseaU1hzCmvKsaYca3Kwwqtly0VneqqmpwP0 VEZPZfR0FB96NWouvVXRWy695dJbNb3l0lsuvVXTWy6+OIkvTtJrNb44Sc/V9FxGz2X0XIYvTtJ7 Nb1X03sZvZfRey69e/VhGTVCMfHylNrNqHfTcxU9FhLLNhNx9xNxvfrgw3jENWlV1VhDRRr/D1N/ OVoMinuuhHcKeackfubVdvVxP/oa7zrJWZTn7+P5J1DDDpo2iofPME4bTwjwoUlNsKAr571ghTrO M4rjM5NH6wKyiGdjlejFM3bwzkf47yTP2kKLwz/V9/F8I4gvFvjBVlsY1UhGMwE/nsSPxfixGD96 9XUx/juJDVuwYQc27MCGHfjyl3V3B+j4s/q7K+17sBd7cVxB+5Vc82pujTG7og32ncCmE9hUgU0V jZ/gVGJ9OXZVYlcldlRiRyU2VNL3Cfo+Qd8n6LeCfivot4L+Kuivgr4q6ecEfVSIHjx9K6P/kpF/ 9bMoG8LP79LT6XhUteN/KfJE41weYPSTvb/o+Sn6MOKv6HUrvW6l163/MPJ4kaYr7bwo04ujFzFW 0PbvI0ZCPIueQgfUUVubzOsoNbXxrzt20/Md8b8YHYTdxbT8kFnLoS7Yh/2f4qUNP4sgXmZw8NQK 5trLu4fx1gq8tYLxfMpTn+Vp65nFHLTbPjy4Ag+uYCZz8OIKdoTDjnCY0RzG9ym7wmGMxYyxmDEW M6s5aLB9aLB96K19fxc5HGY5h1nO+Vvk6MozeqgVjP1Txl3MLOfEo0cHvF6A1wvin0ZUE0Xq1Has PobnC7D4GBZ7n+Ecw9sFeLsAK49h4TG8XICXC/ByAV4uwMsFeLkADxfQ0zE8XIB3C/BuAd4twLsF 7Kpqou4Zsh+rhxVWrT4VOlnwDEqpTkjUyE7OTnB2RHTlzKWGqUWfuOgTl0xZQ6asIVPWNH5GGEGz HEfH15LxImS6CJmuhkxXg16vJdtF0Oi16AoXTV5Ldqshu9WQ3WrQ3bXo7loyWw2ZrQbd4ZLZImgP l0xTQ6apIbvUiARyeR2WLCd3u+RsT9cdpleXGXyTGXwzHlUSyPZVMpFIcr6KMoJyWkXlRaIZEYaa RwykH0cYPOcQz/E+c631RsCIg/FPECJeezyRyH66SNVy3ftUlhbcd1C05swbfRWjr2L0VfGRj0Er jFN7fzbyKkZeFR91Lsc82AMFUAiMjpFVMbIqRlYlutDbLvxbjX/349/9P6/M6TtKL2X4tpoeyuih 7G/V+Kb4J35l+LYa3+7Ht9W/qND3c+7EPwWMV+r4dj+9l+Hb/T+v1oXGyKtFD9mEV4lqJWrJRS25 qCUXmz7Apg/wVjWKqRzF5H26dgw/VaCMXGaggRlYxwyso45sSR3p/XWkp3rKUT3l2PUB6qYcdVOO uilH3ZSjZspRM+XY8wFKphwV42LTByiKchRFOYqiHDVRLiyseY+eT9FjLT2eorc6evuW3r4V3Xn3 B/x2BBsPYOMBWp5u/Az7/83QRSi7y1jXV+GH1eoIPjyDD8/8bZY2cS2b880ct6K0dnL8+azt59yB n2aviDYltD+oDvxiFpPwWgleK8FrJXiqBE+VYPf3jZ9JleCREjxSgjdK8EYJ3ijBGyV4owRvlOCJ EjxRghdK8EIJXijBCyWiPeMsYoxFjLGIMVYyxhBjzGeM+YwxH6Xqrbp8xpOPqoygKiOMpQhl6a3A fMaSz1jyUZIRxpHPOPIZRxFjKGIM+YwhnzHkx/8XZXc5XnQXmWKielXcC/fBQ2qVmK0WiXSYAxkw F0pVpjgEZXCSNnVqoTgD9dAAZ9VCrY/K1fpCPzgXzoPz4QLoDwNgIAyCC2EwXAQXwyXwK7gUhsBl cDkMhSsgGa6Eq+BquAZS4NdwLVwH18MNcCPcBMNgOIyAm2GyaKN9pj7VPlcfal/Advgr7ICd6mPt K/gavoFv1cfGSrXIWAWvQw7nu2A3MFYjBkot9DVXr/paqkwfKtuHyvahsn1toC20gxK1yBelzTE4 rhaZfeFiSFWvmmlwPzwAM9Qqcybgd3OByjVz1ccmFY/VS31s9YY+6kOrLwyCCzm/HMaoTGssjFML rSWwGko4/wEOAnNmlatVVgQqea+K89NqoV9XuX4JBvjABJSiH6XoTwAbAhCEJtAUmkFzaAEtoRVc qj72D4HxvL6P43yOb3PMUh/6q1VuAs9KaIU+vku0VLtEKyD6idaQBG2gN/SBvtAPzoWbYBgMhxFw M/wGRsJv4Ra4De6AiWo5K3c5K3c5K3eumK5WiBkwEx6GR2C2ymI1Z7Gas1jNWazmLOMZtct4Fp6D 5+EFWAALYRG8CC/By/AKLIaV3LcKXldZzPpy3361y1cIRfA9lHD9MMcjEOX9Y3Cca2fVLtMECxLA hrbQDnpCL8APJn5gdWSZgzlezPEyjtfBXTAOxsPdkKqWs3KWs3KWs3KWs3LmsnLmmozXZLysoCz/ A55vxCKVK16El+BleAUWwxp4G7LgHVgL38C38B3kwC7YDbmQB3sgH0KwFxwoVZuICZuICZuICV+L U1AF1XAaaqBObSBObCBObCBObCBObDCOqlyjHCJQAVGgOjFcqITjcAJOAhWLUQXefTFQagP7bZNF LLDY+xZ73WKvW+xza4T62rqV4ygYQ5uxME5tsP7A+XSYAQ/DIzAHnoSngP1m4SMLH1n4yMJH7KcN 1hscV3PcwHEr4AcLP1j4wcIP7LVN7LVN7LVN7LVN7LWv2WtfWxUQhUrureI6/mDfbdAuEIZoIXxg er8g5P3KBiSA9+3dAQjGf/+8hWgKQ0SSuAwmqnTWeDprPJ01PoM1PoU1PoU1PoU1PoU1PkXM4gmz VRrrPI11nsY6T2Odp4nHRDPxODwBT8JT8Cd4Gp6BZ+E52Cw6iS1QqmYzo7OZ0dnM6MvMaBYzmsWM ZjGjWcxolvC+QbpOZTCrGcxqBrOawaxmaEvVXm0ZLIfXYCWsgtfhDXgTVsNbsAbehix4B9bCOvgz vAvrYQNshPdgE2TD+2qvPkA00weKJH0wx2S4XqXrN6iH9JtgJOeT1aP6FJWq/wFSVSqa7SY5Vk1H t90kx3Ocrr6RM1SezBU+mScSZT6qdy9V+T5hy1KVJQ+hRcpEH3mY4xHvu4E4VoiWxnTRwpgBM+Fh eARmwWxIhzmQAXNhHqxUacSLNOJFmrFHNDPyIQR7YR/sBwcOQBgKoBCKAH+y2jNY7RnEmnRfC7WX VT+bGJPmqxA28SWd+JJOfEnz1YsWpgTWltkSWkF36KvSzH4cB8KFIomYkmZewutUlU78SCd+pBM/ 0okfM4gfM4gfU4gfU0zWkjkbWEvmq2qvuTT+P+j3WudAJ+gMXWAgjFBZ7LTZ7LTZ7LQMa5poZj0I 8+FRWARLuL6S4+uiE7spw1rH6xLa/wAHgTXHznmZnfMyOyeLnZNlHRMJlguVtK/ifdYfOyjDqhHN /Ilqr781JEEbaAvtoD10gI6ArX5s9WOrH1v9XaEbdIce0BMm8KyJcC9kcD4X5qm9CZraa49WD9lj IEOl2vOAfWOzb2z2jc2+sdk3NvvGfh5egAWwEBiv/SK8BC/DK7AYlkAmvApLYRkshxXwGuAfexW8 Dm/Am7BaNAukwxzIgLkwD/BtAN8G/gjs7wD7O8D+DrC/A9gZwM4AdgawM4CdAewMYGcAOwPYGcDO ADYGsDGAjQFsDGBjABsD2BjAxuC5olnTBLAhQHzQ5W52SinRyHvlffdIG/1holkw/usCJljg935d BGzvp54af22kCTSFliqMAgijAMIogDAKIIwCCKMAwiiAMAogjAIIowDCRL5WRL5WKIEISiCCEoig BCIogQhKIIISiKAEIiiBCEogghKIECUnESUnESUnid8rV0yGKfAHSIU0uB8egKkwDR6Eh9RkIupU IupUIupUIupUIupUomkK0TSFaJpCNE0hmqYQTW2iqU00tYmmNtHUJpraRFObaGoTTW2iqU3eLSTv FpJ3C8m7heTdQvJuIXm3UHifd2TBO7AWNot2RN525F+X/OuSf13yr0v+dcm/LvnXJf+65F+X/OuS f13yr0v+dYnW04jW04jW08QRatmjUA4RqIAoHAMXKuE4nICTagmRfQ2RfQ2RfQ2RfQ2RfQ1RfRZR fRZRfRZRfRZRfRaa3kHTO2h6B03voOkdNL2DpnfQ9A6a3kHTO2h6B03voOkdNL2DpnfQ9A6a3kHT O2h6B03voOkdNL2DpnfQ9A6a3kHTO2h6B03voOkdNL2DpnfQ9A6a3kHTO2h6B03voOkdNL2DpnfQ 9I72G5GkjYTfwi1wKyxVITJRiEwUIhOFyEQhMlGITBQiE4XIRCEyUYhMFCIThchEITJRiEwUIhOF yEQhMlGITBQiE4XIRCEyUYhMFCIThchEITJRiFoim1piG7XENmqJbdQS26gltlFLZFNLZFNLZFNL ZFNLZGvfCVvLgV2wW9hksSBZLEgWC+pDvP+jyvEajtereWSzEWSzEfFsNlZF9Ykwmez2s6ymp6ko mW0omW0KmW0omW0KtfgC+ZB6V25VX8hPRFP5OdlvN/V8HnV6vmhDlouQ5aTcT33/Y6bzkel6xL9j MsL1CjLPdBEkywXJckGyXJAsFyTLBclyQbJckCwXJMsFyXJBslwQJR1BSUdQ0hGUdAQlHUFJR1DS EZR0BCUdQUlHUNIRlHQEJR0xlijXyIRXYSksg+WwAl6DlSqFzJlC5kyh7sqm7sqm7somi9pkUZss apNFbbKoTRa1yaI2WdQmi9pkUZssapNFbXSmi8500ZkuOtNFZ7roTBed6aIzXXSmi8500ZkuOtNF Z7pGtYoap6EGaqEOzkA9NAB7gsw8i8w8i8w8icwcIjNPo/5zqP8c6j+H+s+h/nOo/xyqhDBVQpgq IUKVECaDp/gOKZdKIUylECaTTyKTT/Jhkw+byOgpZPQgVUPYF+NcKdcUoIEOUgTJ9EEqijAVRZiK IkxFESbzB8n8QSqLMJVF2OxI23OgO9d6ct4LiLVUGWGUQQrKIGgO4H3WIOqgFVVHGIWQgkIIUnmE qTzCVB5hKo8wlUeYyiOMcpiEcpiEcpiEcphkEkdN4qhJHDUfgukwQ01GTUxGTUxFTUxFRaRQzzoo iRBKImS+Fv9GpiRzI7wf/1amJHMHx1yVjcoImcwlda9j1ogkFEcIxRFCcYRQHCFq4Wxq4Wxq4W3U wttQICHq4W3Uw9nWZcKmJs6mLnCpC1zqApe6wKUuKESlrKEucKkLXNTKNNTKNOtOFbXugnFqFvWB a6Xymj1l3Q8PwFSYxjMfBMZF7VBI7eBSO7jUDi4Kx0bh2NQQLjWEaz1D+2fj3yroonps6gmXesKl nnCpJ1xU0CxUkI0Kakdd4aKEZqGEbGoLl9rCpbZwqS1caguX2sJFIU1DIU1DIU1DIU2zDvHsMjgM xHqLWI9qWoJqWoJqWoNqWoNamoVamoZaWoNamoVasqn1HWp9h1rfodZ3qPUdan2HWt+h1neo9R1q fYda36HWd6j1HWp9h1rfodZ3qPUdan0H1RVCdYVQXSFUVwjVFUJ1hVBdIVRXCNUVQnWFUF0hVFcI 1RVCdYVQXSFUVwjVFUJ1hfyDsOlCuFRl+4fAeJ49gfOJcC/cx7VJHH8Pk2EKPKAiKLQQCi2EQgv5 53PPAq6/Tdsstc3/Dq/XQrVyEoRIQsGFEhhbQiuVndBa2PYtqtS+FW6D0WoEym6EfSevH1FRexak w09K71FePwFPiSCKL4jiC6L4gii+IIoviOILoviCKL4gii+I4gui+IIoviCKL4jiC6L4gii+IIov iOILoviCKL4gii+I4gui+IIoviCKL4jiC6L4gii+IIov+H+o+IK/UHytxQvqcm2cGK7dLW7R7hGP aL8Tv9YmiMu1ieJ2/XoxWp8sbpOj1NVytLpKblFr5CdquDyovkYbJkoinDysFsmjaqcsFx1khHqr Qp0WncULse1indoj/qr28PQrGr8N9mKefi5PP5enX6lNVqfJrWX0QjVHVTZKDaGXofQyQ25TW+XH 8EksKj9TfyHH7ZdfqB1yu3qB3h+n51pZpo7Q+xB6X0Dvkt5fo/ftwi93qdUyF5uo5OUeNUHmq80y xF37VAFZsQiduk59iW1f0vIOcucuWi+hdbrcE4vR+nVa30Ae/Qt3PMwdS+Pf7dgfazPI5ueQvW/Q h5PJJ6vJ+v1C6mvRydvV7/SdKlMvFhfp1WTkRNFM9ldvyW0iSJbuzwjeo6ed1KNS7qHW3KveJ0v7 eHqMEYXI1OmNmVo21qSSkR2R5YwqwvUKdUy7XRhqs/CBCRb4IQFsCEAQmkBTaKa2iuYwRBWIy+Ax tVE8Dk/Ak/AU/AmehmfgWXgOXsCHm1We2KLyNF0VaBIM8IEJFvghAWwIQBNoDi2gJbSCRGgNSdAG 2kI76ASdoQt0hW7QHXpAT+gFveE3qkgbCb+FW+BWyIC5MA/mw6PwR3gMHocn4El4Cv4EC9UBbRG8 CC/By/AKLIYl6oA+QG3UB0MyjFQf6U+rsP6MCrPKRzErUdZZA2tsIzMRZY3dzBprkKdjR2UNO6JW WbIuViPPxApkvTJlQ+yIPKuSZYzrSrUzfLGjhqmuNixlGf5YjZEQKzBsZRqB2BEjqJKNJlxvSrvp arMxA2bCw/AIzILZkA5zIAPmwjx4QxUYb8JqeAvWwNuQBe/AWlgHf4Z3YT1sgI3wHmyCbHgf/gIf qSJjM2yBrbANPoZP4FP4DD6HL2A7/BX2qI1GPoRgL+yD/eDAAQhDARRCkdroq1ebTQmsX9Ontpot ObaC7tAPBsKFqsC8hONzqshcDJmcM07zLV4zHpPxmIzHZDzmBq5thE2QDR/CZq5vga2wDbDdxHbz G15/C9/xOgd2wW7YB/vVATPMe0egAk7ASTgFVVANNarIagrNoDm0gLbqgNUO2kMH6AiDVYF1CUxT G60HYT48CotgJbyu8qx1HGvURn9vVeQ/VxX4L+A4gOMIuJnXd6gD/gm8PxHuhae5nsn1V2EpLIN1 UK8OJAhVlNCCI/srgX2V0B46qgJ7ggrbUyAV7oepMB3Y7zb73Wa/2+x3m/1us9/t5+EFWAALAXvt F+EleBlegcWwBDLhVVgKy2A5rIDXgDHaq+B1eAPehNVqY+BGFQ7cBMNgOIyAm+E3MBLS1UeBOZAB c2EezIdH4Y/wGDwOT8CT8BT8CZ6GZ+BZeA6ehxdgASyEF+EleBlegcWwBDLhVfVR8Fy1sWmC+qip DQH1kTDIFRuJ/BG5V1xAXG4Qr4jZaplIhzmQAXOhToWpn8PUz2Hq5zD1c5j62aV+dqmfXepnl/rZ pX52qZ9d6meX+tmlfnapn13qZ5f62aV+dqmfXepnl/rZpX52qZ9d6meX+tmlfnapn13qZ5f62aV+ dqmfXepnl/rZpX52qZ9d6meX+tmlfnapn13qZ5f62aV+dqmfXepn1/sWLu1L7NypotSsUWrWKDVr lJo1Sh2aSR2aSd2ZT92ZT92Zr69WR+N/H/njXx39oNeoH8hmDllsmdwtOpMvS8hgz1HDLaOGW0YN t4waLkoNF6WG8+qnMPVTmPopTM3kUjO51EwuNZNLzeRSM7nUSMuog5ZRpyyjJllGDbGMGsKlRohS G7jUAVHqgKjVT4Wtc+PfxxlF+3taPozODqOtw2jhMBo4jP510b8u+tdF/7roXxf966J/XfSvi/51 0b8u+tdF/7roXxf966J/XfSvi/510b8uejWKXo2iV100atQ/g2fP5/Xb3remKRe96aI3owmJ7KfR KhONmYmmzEdT5gcz1NHgXJinjjZJVD80aQ1J0Bm6wKNcf1P9IHSyyp/J6+g4uUVcKreKu+SnYrD8 TLTFvx/KL1BS20VvuUuMwNcjqOt9KIYrqO1bypAYhN+/Rzl0Qucc5Gqp6IdeGIFe6CWPimt57heN n2WfS0+fq3W0fyne50bem4Kq2Cqacu1rznZ730v5/3+XrjZZJP/j79PFnoHsjsvpdRj58AZs+PHK QLJlDVevJltuJVtG4t9RXOH9GiVXO3J2RfwzxTa07YkN3m8RHBbn0+ICznaLZEaYyHudGKv3rW+j VY6cLoZg/xfGUPSazpWvOPuW1uQmNGElZ0WcpYomnJ3h7CvRWxgiWfjABAv8kAA2BCAITaApPY4S reUYNN44SGVMW9GBn6EzP1d5xnSRbMyAmfAwPAKzYDakwxzIgLkwTyRTyydTsydTsydToydToydT kydTfydTeydTbyfHf/+iCeq2ip6KGMVh+Skz6f2ayefqA9RtBWOfjk+2YNfHtGK0jL2JaKnliu5a nhiAZ8bhh2vkGFqNFWPluPh3zI2Vqepz71uJ5Ex1UC4WF8sl4hL6cZnpniiZ9calYpAxRAzAW2NF J+7oRD+Dmc3pogs9HfP6j/fUpPF3TXbKO7n7LtrfzfEejtNZYbnqABo5ij6ui6+ffcLPXVKY3i+h 0DqJlkm0TKClS4tKkSRKiaJoKFGGbnqQnrw5nany0d1RZr0ZETcv/rwQM7iXu3imp4h9LVUDNXwD NXwDNXIDNXIDNXIDNXIDtW8DfY5SR73/8cQT+7FTrPjT9qoq0eYXfd5JzLob0hjbdJT4bnUC6yoZ h8uKa03f1dy1g34D9Fv7T/sN0O9B77dZeFpL+vXxxGqeGOWJVTwxgaedaBxFA/tsFFe97wu8EyV/ NzzIO9NFO+5MwGKTO09zZwN3NsGWmOc17qxnV5SK68QhKIM6VvYZqIcGOEt0GEXlMloNkHcSLe4S 4+XdHO/hmEbt8yD2zFRvyjmsi8XiV6yHy/F4Lj0Oic/NHrUi3ltI7WPPJVLlnGlcI4MMnm3EQIne vpbiOmsMjIVxore1BFZDCec/wEHATquSa1UcT2Ob9/2PlVhWx5jrsKwf467Dsn6Muz3j9iKGn/Ha jPWI3C+ax1fdNu74gjsOcUd77jjEHe2541e0bo7Nh+Mrb4+qx+5a7jwUvysU/12CMfQ3lpU8juN4 jjOIigdFNyJeJTHGJjK2IzK2IN5ti/+ijjd/YVpJrlQyD6N4NTq+N7xvw0uSD7GqHibfHcbuo/RY rtz4eivhvkPcZ/N0P0/WeScs2omJ6oS4F+6Dh5j9UcznGOwaBzNYmV7rUlbJYTx9BJvKqS8jPKWC PDlUtPE1Vyd8UTimTpipkAb3wwMwA2by3KaNvwnk8OQwTw7LhxjVDGL+QeaxlFV0iB0UHy1x+Cg+ KlffxWvxNthXj3312FffOHrvM+VinlLMU3Se0g8bm/OUGp4S4yneN837ecIP3u8RYV899tVjXz32 1WNfPfbVY1+9OF9MFMPEvXAfzBYpIh3mQAbMFSn02IwezyNm+fDwSGKWDy+PJGa9jac34emPWac7 Wac3sE6HybVqEWP6lgzR60dryFueNUdRE5eKIazRIcZQ5RgrRYqxCl4XKb7mYpivhGOU4zE4LlLM vnAxpIphZhrcDw+AZ58fq043rhu9cd3o8bnyPFiujsQ/jViP3WsaWyU1tkrCbpeWg+KfQJSrfFZG amw7teAxar8Sar1j1HYlRp9YGWstNeZytZIrlUYfdQVPTY0Vy9P4uZ67G4gNZ9Uuw6dqqAtrjYCq ouUuWl4bv/dz3s3jSh5X7Pi9rjxDf/V45azaS40ZMxKEyb0xWu2llozRMpm4lBo7TC8xqtQqLIvK Oo719NrAyvzxzgZ6jVGdVmFx1PBztLEiwPUfn9TACKpZdanUtTVC4ymVPCXGUxRPOBrv2xQad1dy d4y7FXcebbShr+en2EJsOMjd3bm7gLtPyzPsWM/6BtbxWVZcDJ2g1FlsOcjTuvO0Ap522khQofio AsxzUDSnUo7w5LPY9K6XRZXOE2uxo0jGhM5dtfRdZDThdR/V1WsR202LI/TneSpMiyM80/NSmGcc x7t/N1/MfuM8cfc/mZ942/i80PafzAdj/F/OA/H0X/Q/UeY/7HfG+N/4O/7OP/SzaGokigSjNfa1 FbbRnqd14J6OaIZzeN2J9zrzXjfe68F5T97rxXu9yQeGkUQPHXi3C8eezEnQSOSMGsJoQ//t6aED PXnP6sT1zlzvyvUeXO/JdZ7DLHitvZ47NLbwevKe1RK7dN4tM5K40gbaik7Y15KWZTyzE/bp2Kdz V5nRhfe7Qjeu96BNT6714nVv71fJeUoRtnoj1I122Npe+Bqf4t1dhP3eCHWjO+/14L0f79YZbyK0 Zu0lYXNbntuesXRg9jvS1zneuHi/M+934f1uvN+Daz15vxfv92Z8jIK5ac1zk7jaBtqqfdgQwzsH jY7M5TmMuRNtOtOmC+93hW606U6bHrTpRZveZDZvnoJxv7YVidjheawWOxKxI4Adwbhvu3HeI+7B WmxIxIaANytCxsfevtHPP1rveU/Gx/3jHZWNVuui2b+7Jti1Lv77u3XBbu8vmvyra4O7Bgjrv1sf vNtTtPpPrRGedh6j/jfXCXf3ES3+t2uFp1zqjeg/s16YiW/i8/hvrZl4bmjyr66beFTvI0/Hyomk dxNxOhLVhsszsUqi2q9lQyxC9JlIVOtCVBti+GLlRNS7iUYdiWrDjYRYJVHt10YgFiEyTSSqdSGq DTESY6fxyPl4pC8e6Wu05bydOg+PNMWqgXilF17paXTiemfadaFNV+jGeXfa9aBdT9r1ol1vVk0C lVuQmitZer/rs120Qu0monR7oCp+hVbYgdprFv9toS3aOHGZdre4VrtHPKv9juMEKvdRarm8jVrk drUF5bE8/kt1ff+HVjvirbzfQNofv/rT2ca/nelU8p9on6mN8Vfer9sd5FUzquTzhRBDqEn7iav4 N0DcJG4RA8Vt4nau3oGWu1z8XjwnbhQviLXiAbFFfMLZZ/xbJL4R+8SLwuHfSlFEdbJKHOGJ72gd tA5ij9ZJO1/ka8O04aJUu1m7VZRpY7Q7RYU2XhsvXO0ebaKo1FK1+8UpbYaWKU5rS/nXXlvOvw7a a/zrqL2jrdXO0T7Tdmud9QH6IK2/Pli/RBukD9GHaBfrV+jJ2iX6NXqKdql+rX6tdpl+vX6Tdrk+ XB+uXamP1G/RrtJv00drKfpYfax2nT5eH69dr0/U79Vu0Cfpk7Sb9Mn6/dow/UF9pvZb/RH9Ke12 /Wn9eW2SvkBfrKXqmfqr2nR9tf6eNlPP1ndoj+s79X3aEt3RS7W39XK9QsvWK/Xj2gf6Sb1G+0iv 0+u1T3Qlhfa51KXUtktLNtF2yGaypfadTJSJWq5Mku21PNlVdtP2yR6yp+bI3rKvFpbnyfO1Itlf 9te+lwPlIK1EDpYXawflEHmZViaHyiu0I/JKeaVWLq+WV2sRmSJTtAo5XN6sReWtcrRWKcfICVqV TJVpWkw+KB/WhZwj5+imnCvn6pZcLJfofrlertdt+b58Xw/ID+WHelBultv1JnKX3K+3lQdlhd5N npZKP8/wGU31i41Eo49+pTHUGKqPMqYbT+m3Gc8Yf9GnGB8Zn+iLjRxjt77C2GOU6auMo4bS3/fZ Plv/zhf0BfUcX3NfS32XL993QM/zFfpKdMdX6ivVi3yHfYf1Yt9RX7n+va/Cd1z/wXfSd1I/4qv2 1ehHfXW+Or3CV++r16O+s6ZPP2ZaZlP9tNncbK7HzJZma12Zbc1OUppdzQulbV5kXiTPMS8xr5Od zJvNUbK/eZf5R3mx+bj5pLzTfNp8Vo43F5gL5O/MReaLcoL5ivmKvNdcYi6X95mrzFUy1XzTfFOm mW+Zb8n7zXVmtnzA/MDcJh8xPzW/kPPML82d8jHza3OvfMLcbzryRTNshuXLZrH5vXzFPGJG5BLz hNkgl1nC0uXblmV1kWutXtZg+VfrUmuozLeutK6UjnWNdZ08YN1ojZDF1khrpCy1brVulYes26zb ZJk1xhovD1sTrIkyak22JkvX+oP1iKy0Zltz5VlrvvWooVtPWk8ZhvWM9axhWgusTMNvLbWWGi2t 5dZyo5X1mrXSSLRWW6uNJGudtdVoY223vjb6WHnWPqO/VWCdNC6yqqwzxnCrwVLGrf5e/l7GaH8f fz/jDv8F/v7Gnf7B/sHGOP+l/iHGeP/l/qHGPf4r/VcaE/zX+280JvqH+YcZk/wj/Dcbv/ff4h9l TPHf4b/D+C/qvgNOimL7+nZ1d3XNTPVmYAM5CAjyiAsSJAiooIIRH4pixIQiIiqCCD4VEAFBAf8i KGBEwQgKKvoEwzODBJUcBAQRyQpS36k7s+uuu7Ckp+/r+fXd6upK01N16tzq7rM91ZWqh3eTulnd 4t2q+ql+Xl81QA3wblf3qMHeHeoBNdS7Sz2ohnt3q5FqpHePGq1Ge4PUWPW4N1g9q57zhqhpapo3 TE1X070H1Xa1wxuudqld3gi1V+31RkYAfN6oiBfxvNGRIBL1xkR0pIw3LpIVyfKmRHIi5b2pkYqR it5z0fOiXb3no92j3b1XoldFr/JejV4bvc57LXpD9AbvjWjP6E3ezGivaC/vzWjfaF/vrWi/aD9v drR/dKA3J/pA9EVvbvS96Mfe+uii6DJva3RFdL23O/prLNs7EKsSG+VXjI2OPeWPiM2MvetPjH0Z 2+4/qwOd6X+qa+l2/nJ9kb7W36tv0L1kRPfWfWSy7qvvkGm6n+4nS+n++j5ZWg/RI2RFPUqPktX1 aP2IrKHH6idlLT1ZT5a5eqp+UTbWM/TrspWepefI9vod/Y7sqOfqufJM/b7+WJ6lP9ML5AX6G/2N vEQv1ktlN/2dXim769V6m7xG79B7ZV/9m94v++sDIcmBoQiFHBx6oZT3hioM5f1hSlhaDg8zw0w5 JswOy8pHwvJhVTkuPCE8QU4MB4YD5aRwUHiffDIcEj4knw4fDsfIaeGj4Vg5PXwsfEy+HD4ePi5f CZ8In5KvhlPCZ+WsJJGUJN9OSksqIz9JykkqJ79M2pP0m1xAIgr+TqTbpHamGlSRjtNmZpu15geq azYi/H2xKQ6Yx80MfH42w3DU2VyMPPMR2pg4v9H8CLs6cbS7SH579kezE58/zgXF1LMD+yMltvcu 7O8UilmBGkrbWg66wfNCum/NPoQ1ZvJLKMTx2sJtzPs2xdT5mVlltprPUcIafNsNJbXxMDaFUscm Sl9ntpj5Zn3iaHuR2jdjX25WmoVmr+lAEVy7E6lSgfMHSqrM7MJvtxMl/NFyXH8wlvjZp83TpLHn /4Z/yv0T9vXmO5SxAoc+eNYJdApCFfjsPPOFWYz+g74Dv734+l8wk81E/B2CvaWpY24zfRAqcB3z vj1CW4rkPmA+NBvQgz40n6Id+B3s1SucKz/tZyVcCoKfSpTEoRGJmK0o+/O8vlmwVyRiduKbb8e1 /97sAN9PRlRD/Ar5tZvN/AttzktdJP8WswljbGveFbcro/x3WcE0JbU7ke67Qke3FDr6+PDKwFaP 0yd6mlmC30+ZJSXUvKfA2K5HTUpI/aJ5zo5o8+Fht6lw/h9s77B9tsiZRYeRG9/M3M+hmX8ez+aK w8iPPmJeZ9xaYX+3I93M84ymz+O6Ft3UYZXws5nNqHmY/aKYErYffq8qJncCYc2Co8r9MtslFjmO +9bgMOr/IT6XmX3oRzuOuAZ9yLPVsZ/LteTNeKvjn8T5CsXkqYlPBXxqFmrlM4m/X8Y/h8hfr9j8 iauLXrIL6LTrYA0Gfv5kfgGCreIxZXv1Xo4fw6fLm/fMu+YbO6MfJP/+AuEHKQv434U62RGSiFuO uWFOUSzOz7OvQHgUZp5kOoO6Izw9EbcWV+/rg8+qefVzj34M+SNAn94JJLfxr5oZ5JpZB83/517o gz31QPxDifMfm49w/f+TOCqK378VCA9D7iw6iywTapmIe8e8hRJeOmj964qPP4BfzOKjOcecba4y nRKpJxXJPxgo9rR5yXxlvikQLagb3UvDERpBI+07M/Qieu50mgV2OIfepfq8qpBLH9Biakzf0nrq SBschy5yujvd6VZ49OdSH+vLU1/rxdPt4nrRk+6EP76UBojvxVq6W2wUG+kB8aPYTEOsb07DxG6x h4aLfWIfjbC+OY20vjk9DN88RmPcCm4FGu9e4najx9zu7uX0uDfTm0nWqzU00U/z0+gz+YZ8gz6X 78h36Qv5vVxGX0kjDS2wPh0ttD4dLQ06B+fQcuvT0Ur4dF1olfXpaI316Wij9enoR+vT0Wbr09Gv 1qejA/DpHnQI3tzDjgzGBOOdiPXpnGTr0zkp1qdzUoMpwVQn3fp0Tinr0zknwKfb7pwEb844nZSr fOdipVTUuVRpleRcrlJVunOVKqXKOD1UtirrXK/Kq4pOT1VFVXN6qVNUS+dWeG1XO7fBOxvi3AHv 7EGnn/W/nLusT+T0tz6RMyB2V2yUM8h6Os44naIznTn6Rf2iM0+v1duc+dbXcBZaX8P51voazjLr azgrra/hrLK+hrPW+hrOJutrONusr+H8Yn0NZ6f1NZx91o9w9ls/wvnd+hFCJEWSYiJIKpVURkST 9ib9Juw9hSXcYxzuMQI9Ziw8inH0f+jTj9NUxDyNT0DP0AuYpaahP0nuTxL96W2MunfQq6Lcq6Lo VZ8g/j/0DcVoET4CvWwxWPW3tAzsajmtwRhbiz5XiTbQLxjx2/GpTDtoD1WhvfhUpV/pd6pGB9Aj U7lHluMe6XKP1NwjNXrkjZQieqJfau6XaeiXy6m0WCFWULpYKVZTGbFGrKFMsRb9tSz31xzur5nc X0txf83m/poujDCU7oL+UwZ6rYDFRqXQdwOE8eNTlhtBP87gfpyDfnwJneB2Q2+ujt7cHeHL0aer c58uhz69nBxvhbeehPeDt4Gkt9HbSjHvZ28nlfd2ebsp2dvj7acK3u/o/dW491fi3l+Oe3857v3l uPeXQ+8/lTKCtkFbigXtgnbkBe0xHnyMhw6I6Rh0RMyZwZkUBGcFZ5EKzsY4qYJx0hl5z8FoifBo idkVEAqDLhgzSRgzF1Ol4JKgGyUHlwaXUrXgMoyiVB5FqTyKHIyiG5DrxqAX0twS9EbMrcGtJII+ wW2opW/QFyXfjpEWw0i7C7n6B/0RPyAYgPR3Y+yFPPYcu56CNEOCoah3WPAgzo4MRiJmVDAKuR4O HkaaMcFYxIwLxqEl44PxiMH4pKgdnyhnYjARuSYFkxA/JZiCcqYGU5FyWjANMS8G05F3RjAD1+Hl 4HVcmTeCt9DO2cFsXJM5wRy06oNgPlr7YfAJyvw6QM8MFgXok8GS4DuU9n2wkioGq4K1uCbrgo2o a1PwI1UONgdbcCV/CrZS1eDn4GfUuC3YjjbvDHYi5a5gF87uDnYjfk+wBy3ZG/yK8n8LfkPJ+4J9 KHl/sJ/Sg9+D31H7geAA8prA2P+vqnwqZ9EEFmgCCzSBBZrAAk1ggSawQBNYoAks0IQcoMkDsEPU EBIWU8izmEKOxRTSwJT+sAOiAynFIgu5QJbFpGNLYkspjH0b204pFmXItShDWUCZtZSu1+l1lKHX 6/UU6h/0D1Rab9AbcHaj3kiZepPeRGX1j/onhLfqrUj/s/4ZabbpbUizQ+9AeKfeRdl6t96NNHv0 XqT5Tf+Gs/v0forpA9pQZmhd63SLX7Be6MH6oaQ0oJiiMmEkjFKpMBbGkFKHIZUFrqUjJiMsTdkW 3ag00C0bNicsizTlwwqUEVYMK6KcSmFlhKuEVZC+algVYWAf4oF9iHkinIhaJoVPItdT4VMoeUo4 FWU+HT5LpSwakmvRkFIsGlIKEOuVBBqOwsdlNPSBhuMRfhw46DIOSqDgiwhPpzdh3yL0NqDhewj/ Gxjo0nzgoAscXATEXAx8dXn9XjEOuoyDpRgHSzMORhkHyzAOZjIOZjEOZjMOaifZSabQ6ep0hb3R 6Ql7s9Mbto/TB3aYM4xCoOQ5JBglI0DJq2AtSsYYJSOMkkmMiRlii9hCqYyDaYyD6eJ38TslMwKm uJ7rURqwTyEcdaOU6nZ1u1JZ92J+ks1iXznGvgrupe6liL+Mn26zOFiOcbCCe4V7JeXk4+AGcoGA O0kB+/ZTlFEvm1GvtF21xfhsHbTG6G0TtCGXMU4FpwHjPGBcR4QturmMbpLRLTPoFHRCjEU3Nzgv OA/2/OACpLQY5zG6lWZ0izK6ZQPdupMOrgiugL0yuBLprw6uhu0R9IC1SKcY6aIJpOsT9EHMbUA6 yRingjuDO5G3X9AP6fOQbiDCcYwbHNyLsEU6xUjnMtJFg+HBcOR6KBiBGIt6ilFPJ1BvdDAa8Rb7 FGNfNqOey6jnBU8A9dwE6j0ZPInwU8FTQLTJwWSktzjoMg5mF8BBl3FQAQdnIxzHvreD9xH+IPgK 1mKfAvZ9h7BFvVKMeqUZ9aKMemUY9TIZ9bIY9bIZ9XSwI9iBXBb7SjP2ZTL2ZSewbz8wzmWM08pR DrlxtIreEb2TItG7onfBDogOoFh0ILApFh0UHYSY+6L3UYRxSsRGxx4jwYiToX8C1qToX/R2SmN8 SWFkyQCy7EF4r/6VkoEpBzDOLaakhm7oUjLQJKAkxpE0xpEMIEgawhZB0sMyYRmksdiREZYLyyG+ QgI7KqEEix1pjB0pjB2pjB1pwI4nUOakcBJyTQmnIP1UoEYao4YgUX+bXXlt/MOpudSBLjoYz/// YzMbzSa7J45WFed32XUeXus70rLX2RUu9rzf4+Pv8+pk+1XC+9xi/U/2Rb8za8yGwis6Jdebt0Jn eh15C4/vZjrC87R/D+p7F8mxEZ72R0e/LpNfzpY/H5lf2Cbi4SvuxJVdY7Ziz1/ZK+CJZhTI/R1S LSW77lEGocQKY553/Rdt0fzWFKxX0z85bnNxqwvmx6Jrc2a7WW2+xZkidyGOdstbJS98ZMdPolcX WC9A29388JaD/cpmZdFVzeO1FX8Hp8RcU81T/Hc/r4Z/bHe7PmSeR+iTRJq8nmVH8C7zZV78EdWz jvvomj+O7SqYWV4gxUO8HmTXyldyaB1aUxChEtf3cH9fXrVeU3K6I9/Q0wqUa3ab/dh/s2td5vdC 6Q51X+p/bPuLx/xhbGbCMWTuXEx5a6gG+mD5Yyj10FsNYmy1eMqYWuwGbDjse4jHPlf8qbxCrSo4 9g4z/6vmXfNy4v5Ahplk3uXYtXZ2Lzh7HxV/WApsXMX8YQNzE0YzOyeZVfg7LZFqK99v+w/2+fhs KLxyzUiWRXlrs/MwF3xivsY+AbEdzELzKcd/E2cRfEf7n0fe0iIt31ToiOdQ80qBmOvNFNPTDLWr /KZ3fmwzxL1px13Ru45k77kWvRf6o3kP3+W74zdS8/qDnceAYHm88BNK3J8t2Abgcv69EXuPpYSS Pz9ebTzaDVcp5L8P2/vNRc72MfMKpY3/XY7Zba3tIUdR3yLb65lv8XWyIcxvqxJXDdZcZ77g33sP ucXMYSHVLVLmVoyDnxJ3l1wgR95dpz3xs8c+v/1xH7rw/co8lmK5F8/b6/DZWoR7rmTuWcxox2g+ zthV3PYnPFtY5Pz+P8ck4m8pPp6O5D76EW/mmiPMEH/GYoi5j//+zAjwmt0Res7MjIf4XB4/4/ud +KXeOorWvWreBGK+kTiaZ14g+3zQLBvGDuQEis0DSuSx4J+Bvp8mcCJ+/yypSJkfmTfM3ESZGfYo EV8IHYw58tZyPoxS823+UZ7vstqG8vzKOBNnRPvE9o/4MyKJ8bOdEbmb6cxHc8nezeuF/XaERpnx mOtuT5RS4NkWXIE5pt9RtPZyM8BMNj0R+jdG9WTTg/HhIcxGk3Gd55oJ5lrMrT/be4D8zWab6ebJ eM2JWSPb/PtPZW4wi+FVxkduo/xQgneaX+P74TPmQmXv5PGe/1RQ4VmK5+l8z5eZ7yp+7qHgExd1 Cj+x8ldthe/i8hNMP5XcEv5GRZ6/+iu2wp6svarowztKwk/+dY6bp3skW0H+gdFgvawl+HuQO935 KX889vaaJ0x/8y8zjsNfor8/ZZ+UScxDcb64y7yO/d1jq4dLqht/kuWYylhrfsBMyPMjftMf0A/z OXf8VzfbwDm2FccAj7iuo+DcBXJ/Gv9V0RaLg58njlYmxk+i1X/PeC5uM9eYq83bZiYJPhpg+gKt u8cZgZll9uJouLnFnGyqAEcbmtvNdcdQV5w/Vjym9iYwKe7T5j9v+FThs8dzM1OPQxm29y6Oozr4 bZFfn8+vMQv+mIX/3g2t+R5jjtc80Yetp5jvqcSZLs5+hP0gz6r+1RvaO6LgyAW/mv13tufgG0Zb H8ud4k+6mlvBjr7B6Iufm8v2e/OWudgMRWikWRaPO8q6Pjr29h5hjTsLPuf1v7vlc9ztx/50ZXHP uh/PLc4Owb/XY9Y7DisWJT2jfMi8h9mjzAxe29989DUV2LKOSymHtYELHTNzNQ8fj5aUUEcC6cBu j3ld/jj9SiXVshbM9r88Uo7fBtaz87hdmbRjaMfxGO9/4f2Io+mN4D1r4jkTb3bkrYt8wfcZvjhk 5psSaV8+8nr/6u1o3oEoUsZB74YcIg+v1tuVorgnHF/Ryb8XHD2Uf8xru1nUk+SR18v5j+ItL7OB 544/3iXLW5M7XN8uRqcdea1/61b6aDMe+Z0nsk812PvS+Z69mcP2J+BziXcj/tc28P5dB39nokC6 vf/9thzedngIebSzerHvSpVYFz9B8Me7g3zHIr9nRYvNlJfWrlWVpYsx5v6GrTB3j6MGvKcScJbv xPwN633ml+NY1mpKrCgX+8ZRTX7Lyd5B/7KYsyWVbd+jWp2XMy/EK/yrEzF5dTbjuv7UrgJHD/xR Zl5b7PtaRVpl38qqZ+/SHI3XbiaYZ8zs/PfAEiHLCBJrml/mt6NekfY+c+T1Fcp/FE8KmQV8V+I/ +cf8DBD4pjzsO32H8fbeQeou9t3kEvL8wKtWdiZnLOCjeRh7cWSIHopf8oySTKcc3vuaxeQ/mucf Ftr3LXnfHT9mm1g1PzQ6JL5L2cLPG6F//WK+5n0ClQEn3ZS4m7QqPqa5r11/5C0t4XvE77AV8NZN d3O7edZMZN2A/Gd6TEfz6hGWPO+vYcy2jQevxxwo7q5y/I7in+J+KfkuztFu/IxMApnNdvCJ7eBH S813fyCR2YI4e8+4ibmQj19DD1hsupn59tjMNY+YD+2KOZ8bU6js5XnxR9SiTqanGWQ6JI44hB7Y g8PPmCmmN/rBBLC12Zh5bYqZ5g3zemLWtqvzpaku33O+w9zIcfHnESeCVz9hfw+rkpD/FFChtSDz a97b/EfU3sfM8/DV/i9x9AXXPYFx/gu+Bvbu68tmp3mfE8Tf2k88YZDoxY2OvNa/a/uvvI1dtJbV eYgVv+/8d21Hc58Kv/RPVGDVIV8h4XDmnnSyz++cx+Gy1BC+Z0XOux6sYz3PJjnUwCzCCLWf5WaF ORnjpQdpE5/XE34qRmfcpyqTOH41cadCUP4b0xz/4iG+Bz9bYfphnkusQJrW5jLsHc01lG7ic3Ce hsYA7O1MM3OBSbzZYD42y/hpCTtif8SctDrhv9aiGjxz1uJUh17dKL5dT5kpsM/nH8+2vlyhJyvO TwQupnOpCdVnnZhqfKbgd48eWGBiB/bwTPm2ucG8Zucwc7e514ZQ6rBC1cafAbvhKNp7o7kZ3/9m PlAI3ci4eS/P1F/jt9xwIP4m/SxWBcnb+MqaWxNlHIaPV2zdm0pOUyTPFn4iwPIE7k3cm+fh2OPT +pB8x+ZKpuZovaCFJejYdU3o2A2mMxzhlKKrWJ3uDlanG8LqdMOcrk43GuVc51xHj7Au3aPObc4w Gu8Md8bRdKtOR7OtOh3Nsep09LZVp6N3nPedL2muqCvq0Reiocilr6w6HS0ULUVL+saq09EicYbo SEtEb3ErfSfuEHfSMjFKjKEVYqqYSmvEs2I6rRUzxSzaLN4Sb9FP4m3xLm0V88R8+kV8Ij6hHeJz 8QXtFF+Jr2m3WCgW0l6xWCymX13thvSbm+Km0X6rMEeGFeaIFeZ8t6pb1QlYYU6xqlzMzXVznZBV 5ZJYVS6FVeXSWE8u3e3qXuxkuJe6lzml7btyTqZVfXOyreqbU8eb5b3rdLWqb84VVunNudoqvTnX +Cl+qtPDz/CznOus3ptzs7/MX+30tXpvTn+r9+YMsHpvzt1W7825x+q9Off7u/x9zgNW480ZYTXe nHFW482ZZDXenCetxpsz1Wq8OdOsxpvzrtV4c+ZajTfnK9lN3u8ssepuwrHqbsKz6m7Ct+puIrDq bkLJJ+UUkWR13USa1XUT6VbXTZS1um6iitV1E9XlJ3KpqGkV3cTJVtFNNJUb5GbR3Cq6idZW0U2c ZRXdRGer6Caut4pu4k77fpy4WwklxEAlVSDuUTEVE4NVskoR96oMlSHuU5kqS9yvyqlyYoiqpCqL oVZxTTxoFdfEcKu4JkaqeqqeeNjqronRVndNjLG6a+JR1Uq1FuOs7pp4zOquiQlWd008YXXXxCSr uyYmq2tUDzHF6q6Jp1Uf1Uc8Z9XXxPNWfU28YNXXxDQ1VA0V09VwNVzMUCPVKPGyVV8Tr1r1NfGa VV8Tb1n1NTFHvabeFW+r99RC8bFarJaIZepb9b1YoZarDWK12qR2iC1WlU3ssapsYq8yEUf8alXZ xH6ryiZ+t6psrhPJipR3Q6vH5qZHKkdquBmRWpE6bk6kfqS+WyHSKNLIrRhpHGnmVoq0iLRxT4i0 jbR1a0faR053T4p0iHR060bOinRy60e6RC5yG0VuivR2G0crRqu6za26m9vaqru5Z1i1NreDVWtz e1m1NvdOq9bmDrJqbe7Q2PmxK91p9q09d45Va3M/0IFOdj+zOm3uIn2xvtbdZnXa3ANWp83zrE6b F1idNi9qddq8mNVp80pZnTavrNVp88pZnTavotVp82rpqXqaV9vqtHkNrU6b19TqtHktrU6b18rq tHmtrU6bd4bVafM6W5027xyr0+adr1frNV5Xq7LmXWJV1rxuVmXNu8KqrHnXWpU17warsub1TBJJ yrspSSclebclpSVleHdYZTXvrqQ9SXu8u5Mp2fEGknDWAPWS4PElUwo5lIqPS2mYhz3KxNztY1av hvgT8AmoOmZBRbWBkhHgYTPSwEP7fx5O4f+AYREziREzGYh5IXJ1wScVuNkNJV5KV1IrugoY2hoY 2hvM4VZ82lAfuoNK0Z34lKZ+dDdqHgiEzQTCaspyQieJsvkN4RwnBZh7EjC3OmJqODWorlPTORHx tZxaCNcGFmcxFtcDFneC7QxEbsd6oVlON+Byfcbl+ozLDYDL/RE/wHmAGjpDnCEocyiQOgdIPZJy nVHOo9TYGQvUrseoXY9Rux6jdl2g9vMIvwDsrgvsno/54EPnQ2rmfOR8Ss2dz4DmLRjNBdC8IWwj YLpkTE9hTBeM6SmM6RmM6acypv+DMb0JY3pZYPrzVEG8IF6gcmKaeIkqielA+cqM8pUZ5SsC5d+G fQdYX56xvipjfTlg/eewXwDxKwLxv4L9GrhfnnG/PON+FeC+pmpuCPQ/gdG/BqN/daB/Jp3oZrlZ VMvNdrOprZ0JEMZMQDUxE1SHreHWRC7MB1TbzgfI1dRtCtvMbYazLdwWsKe4pyAN5gZYzA2Ise9a n8bvWp/O71efxu9Xn87vVLfHPDGQTvHu8R4gB7PFKEr2HvbG0sneOG88pXuPeROpqTfJe4rKeJO9 lyjLm+69QdmYUWZRfasmSg3tvELN7bxC2s4rsCl+CrX2U/1UqmdnF6qP2eUbcv1F/iKq6C/2F1Oy v8RfQp6/1P+WfMw6yxCz3F+OmBX+Cgr8lf5KUv4qfxWV8lf7qylm5yQK7ZyElBv9jZTqb/I3URpm ps3k+Fv8n1DjVv9nSve3+duojJ2rUOMufxdl+rv93dTC3+PvQdv2+nvRnl/9XxH+zf8N4X3+PjrF /93/HSUfkILSpSs9OkX60icHM1xAmCykolBGZJSSZUzGyJVaasqUoQyphUySSUiDWdD+V3eZjrwZ shTyZsospM+WOZQmy8pyKLm8LE9WAbUSbGVZGSVUkVWQvqqsivTVZA2krylrUhl5ojwR8bVkLfJk bVmbkuRJsg7K/4f8B/LWlXVRWj1ZD2nqy/rI20A2IG1nXNTVWDZGfBPZFCmbyWYooblsRb5sLdsh ZXvZngJ5mjwNbe4kz8H3OldegPK7ye6o/XJ5BWq5Ul6DcnrIG6iVvFHeTK1lL9kHNd4m+1IbebsE esg7ZT8qLe+Sd6G1/eXd+C4D5T0oZ5AchBIGy8Eo4V55L8Xkv+S/UMt98j6kuV/ej1rAACjHMgCq CwbwMDWUo+VoamB5AGWBB4zD2fFyPGXLxyRwQD4uH6fmcoKcgKv9pHwS9ik5mepbDVikB1dACdPk NNgXJXqpnC6nI+8M+TK1k6/IV1Dyq/I1nJ0pZyLvLDkL8W/K2Ug5R76NlHPlezj7vvw35YJhfIj4 j+RHVAc84xOk/4/8D2I+lZ8i5WfyS6T8Sn6F9nwtFyDNQrkQLfxGLkKbF8vFdJJcIpdQY7lULkVe cBTkWiFXoOSVciVybZAbUNpG+SPSb5abkf4XuQtpdsvduBp75B60ba/cT1mWx1AD8JgQ4aQglRoG aUE65QQZQRnKDTKDstQ4KBdUpHpgOdWpeVAjqElnBCcGtahZUDuojZiTgn9Qi6BuUBcl1AvqIWX9 oD7SNAga4GzDAL4juNHJ1ChoGjRFXc2CZkjfPGiOsy2CFqjLago4ljNRfcuZYMGZYMGZYMGZYMGZ YMGZYMGZYMGZKNtyJsqxnAkWnIlOspwJYXAmam45E2VZrVqqo1qr1sgF5oQYMCekAXOCBXOiXMuc qDGYEzwB1UP1oBbgTzdTsuqlbkEasCjkBYtCPFgUUt6j7kE5g9QghAerwYgHo0J7wKiQfqQaSQ3V KDUKucCrqAF41VjEjFPodWq8ehzhZ9WzqOs59RydYZkWYsC0KGqZFiyYFiyYFiyYFuwm9Qu1VNvV dtSyQ+1AOWBdVNeyLoSNMvZ/b0WI2kWciENZloFRDhhYAKsiihpFsFHdSDQSRVhHkmCTI5h/IymR FMqNpEbSEJMeSafmkYxIBjWIlIqUohaR0pEyiM+KZFHDSHYkm06K5ERyEC4bKYtaykXK4Wz5SHnE gNshDG6HloDbwYLbwYLbwYLbwYLbwYLbwYLbwYLbwYLbwYLbwYLbUdRyO2oJbncepUTPj55PMnpB 9AKEL4xeiHCXaBeEL4p2pQzL/BDzQHQqiejT0RcRBv9DGPwPacD/kObXmEMiJmLZdKplgdQkrt1g WSAJywJhwQJhL9YXUzl9ib6EKupuuhul6kv1pVRBX6Yvoyq6u+5OlfXl+nJy9RX6aoSv0dcgfQ/d A2mu1dcizQ36BoRv1D2pqr5J34Q0N+teSNNb98bZW3UfKg9meTvi79B3IB78Era/7g87QN9NZfVA fQ9V0oP0YKS8V9+LlP/S96HGIfpBxAzXI1AyOChqGa1Hw47RjyDNWD0ObR6vx6Ocx/T/Ify4fhzp J+gJCD+hn0CZE/VEnJ2kJ1F1/aR+kmpa5ko1wFynUi39tH6a2upn9PMIv6BfQJppehrOztAzYF/W r1Bt/ap+FWdf06/j7Cz9Jp2o39KzETNHz0EM+C4s+C7s+/rfVE1/oOchzXz9IZ2gP9IfIeXH+mPU 8pn+EjFf6QUoE2wY5S/Wi2GX6KVI853+HmeX6WUoZ7legfBKvZIagiWvRmlr9BqqbrkylQdXHkxl w3vDf1Hl8L4QVwm8eQjVDoeGuFbh8HA4VQgfCh9CzMPhaKoVjgnHUFvLpxEDPk21LZ+mDMunSVg+ DQs+DQs+TRmWT1N9MLtWzKfbM58WzKTjvDmPMVt+nMT8OIn+iU8SM+PTmRl3YGacxsz4TGbGpZkZ l2FmnMnMOKuAfo/P+j2K9Xt81u/xWb8nyvo9Puv3+KzfE7J+j8/6PT7r9/is35PM+j0+6/cks36P z/o9Z7B+T0fW70ln/Z6zWL/nbNbv6cT6PZ1ZvycbTD0G3hw6IXP0LGrkZDvZ4NCWqTcBU+9ETZmL n+dc4PwT8ZaLN3Ouca4Bw77NuQ22r9MPvLk/GHljMPIh1AJcfCjCDzoPIr1l5I3ByMdRK3DxCdQa LPx12DecN6iNM9OZi7OWhXdhFn4qs/C2zMLbgYXXJZdZuFuAf7vg36cy/z4D/Lsjs3CrMOSxwlAq KwylssJQKVYYSmWOfg5z9JPFUDGMTrHK/nR+gqlbXl5LzBAzqKZ4E7y8CjPyaszIq4tPxafg35aL VxILxALELwL/rsSqReXEt2I5GPlKsRLWKhjVZlW3E8U6sR4xG8QGWKvtVp6VjaqKn8RWhK2+0Qni F7EdYatyVEPsE/sRtlpHFcQBYag8Kx5Vdh1XIGx1j05wfddH2KofVWb1o6puzI0hJhnsvw7z/vrM +xsy7z/XzXHLIt6y/zpuFbD/f7gngP3XYfZf1z3RPRHh2m5t2HpuA2oAT6Axwk3cJnSSezL8gTrs D9Rzm8MfqOO2dFuifOsP1GFP4AL2BC5kT+AC9gQuZB+gPdj/WEoC759Iacz4M5nx5zDjb+LNBONv BsY/j1p4873PqA3z/rYFNJl81mRKZk2mdNZk6syeQAf2BFqzPlNH9geawh9YSJJ9gMD/Fj6AZB8g YB8gidl/wOw/01/nrwPL/8HfgBjL+yUz/jLM+Dsw409jxp/JjD/L3+nvhLWcvj1z+oA5fRpz+vbM 6YWU4PQBs/mA2XwWs/b2zNcDZuppzNSzmJ23Z14eMC/PZF7eHlwcfq+sA0YumYunMRdvn2DhDWVD pM+VuUhvuXh7ZuFxzh0wzw6YW5/O3LoDc+s05tZnMrcuzdy6DHPrTObWWcyes+RwORyc8iH5ENik Zc9NmTE3l2PlWMRbxtyIGXNrOVFOBI+0XDlXTgZXbs5cOYe5cgv5jHwBPH4aWHIOs+TzmB+3kK/L 15HLsuRcZsnngSW/ibxvgSvnMFduwly5hfxAzkMJ8+V8pLdcOZdZcg6z5CbMklswS24rF4AlN2eW 3JpZci6z5BbMklsxS27HLLmRXC6X46zlx3Fm3EhukdsQY/lxE+bHTZkfnycPyANgqJYZN2dm3ALM uAzClhO3Yk7cOqgUVKM2zIzbMjPuwsz4VObBrZkHd2Ee3JZ5cE7QOGgMaxlwO2bAbYOWQUuUaRXF kllLzGctsWRWEUtmFTGfVcSirCJ2NquI+awi5gfnBueidqsl5rOWWDKriHVkFbF0VhHrzCpi2awi ls0qYj6riPmsIuazilgyq4ilF1ARS2YVsSiriCWzilg2q4j5rCKWzCpifgEVMZ9VxJJZRcxnFbF0 VhHLZhUxn1XEkllFLLuAipjPKmLJrCLWmVXEfNYP8wvoh/msHxayflgy64f5rB/WuYB+mM/6Ycms H+azflgy64f5rB/ms35YMuuH+awfdgbrh3Vk/bB01g87i/XDzmb9sE6sH9aZ9cOyWT/MZ/2wjqwf djbrh3UuoB/ms35YNuuH+fBh0qkpPJZq1Jr9kzaquqoO36CGqgGuX0vVoiaqtjoJ/kYdVQfxdVXd hN+Sq+qrBtSOvZdclauawFofpq1qppqhHOvDtFHt1Wmwp6uOKO1MdRbSnK3OpkaqEzyZFqqzOhce QhfVBWetP9NKXaYuQ3uuUFcgV1yJ0Xo4beHhXI+6rIeTpG5RvVHOrepW5LpN3UanqtvV7YgZoAbi W1g/pyn7Njms3JjLHk5zNUKNgLV+Tjv2c5qrRxVQgv2cXPZwWqhJahJipqgpqN16O23Z2+minlcv IJf1eVqol9RLSDNDvQz7GjyfmFqh1sKuh88TY5/nNPZ52qidaidKtj5PU7VP7cO3sz5PjH2e89jn ac0+T3P2dnLZ22nK3k5uJISH0xweTiq1Yg+nLXs4p7KH0w4eTml4QWUimUiZBQ+nCfs2OezPtIE/ Ux21nAh/JgZ/piFsbqQpbAv4MDH2YWLwYTrBWu8lxt5LjL2X0+C9nJ/wWKyvchH8kK7ssVwSvQQx V0avpFOi10evh70xeiPsTdGbYHtFe8H2ifaBtVp0qaxFl8padKVYi64Ua9GlshZdKns+Lvs258Ry YpXp5FiH2Dl0SuyqWD86n5XqPPZ2PHg4teBFWB+mFvswNfXV8GEq6ev09WDq1m+pxB5LLXgsNyPc S98Cz6Gv7osY66tU0XfpuxAzQA+El2L9k2rsn9Ri/6Qm/JNhiHkQXkpN9lKq65F6JNJb/6SWflSP xdlx8E+qwz95DKVZ/6Ta/2Pv+6PaSO48q4UsNERmGIYQjjAMYQghHCGEYQnHsSwhDGFZQjiWcCwh SAhJCHWr1Wq1WkKI1g+ETByOx7COw/qI4xDO5yMOj/V5OYdzHOLzeVnCIzyG9bEcyxHCY1k/HuFY wnIOS+5bJcFgT5KZe+/+u3v1Pp8uV1dXV1V/6/tD7i5IfBKKTN4gkUm26juq7wB/V/VdYByZ5JHI pFb1HyAy+QxEJreh/PuqcZRDIpPPkMjkTRKZ5EFk8h+h5K7qL9CnVJOqSaj5A9UPoBzHJ59W3Yf4 JFv1QPUAzj6CyCSHxCR5JCapVc2qfgJn51TzUI4jkzdV76jegZo4JslT/Y1qBcr/O8Qkb0JM8rfQ 2hpEJskkMslRravW4b44Pskl8cmnVT9XgY9HdgfMIvuRZqqeqnagBO8UmKraVe1BHu8XmE72C0wl +wVmkf0CU8l+ga+T/UiTVf+k+idgvHdglurXKvAAyQ6CaeCYgwdI9hF8nexNmkx2E3yN7E2aTPYU TCd7CmaRvUkzL0ZffBnK8f6C6RdfvfgqlOBdBjPILoOvX0y4mAhn8V6DWWSvwXSy12AG2Wsw7WLq xVQ4i3ccTCc7DqaSHQfTLpoumtDHSCT2cYjEfCQSA3m4eOniJYjQeiH6+jiJvt4kcVctxF3fgPzV i0Moh0Rfb168dvEa5PHOhelk58LXyM6FWWTnwgyyc2E62blQjqiP7id5wflVRVxG/wMhTSNAAzAA GAAPcJ4dKW4MjhIgALgMGABcBQwDRgC3AOOAu4ApwDTgMWAOsAhYBqwhmXeWAGk2CWTeBcATyD8F 7AEOAccItcgASkA0IA6QCEgJ9aEl/bccs0JtteSGga8pABSTc6ilDFAZ6i+5ZiQ0xpYaQD2gKVQe Psq8qwQUNwGYhPzGWVkI24DdcP4J4CCcfxaCD4WhAKgAsYAEQHKori+N1EctWoAxNE8t7Nmch+pm knqoRQC4AF5AMDyGvtD9fDnhsQ4ChgDXw+dHw+fzwyiCMniOLXg89wEPz8YSGvMk4D7gIWAGMA9Y AqwA1gFb4ePOueNp/X3AUfi4Er7u6Nz5E4S0ckAUIAYQD0h694ifnzYVkPGBjzJf6bvPCo9Nmx1+ 1v+nSHweRL4vh+5D5CoxVI/c9zzyAIXvHs/aCLUr81VAeQmgPCx/cE5b9e5RWwtokL/SvG6u7FrQ BCyIsIKwCviyJRZ4wJIAfNWSDDxsSQMesWR2LeCrPE2aW5Ycj7Z5y1zT9aR5x1zftaoZt+QTLjrL 37WUdq3isx5j8765qWtDM2Wp6NoI5cN8ZNZ2bWumLdWE64Afk/xjkp+zNAIvWjTAyxYD8JqF6drG V3lYYCPkT8xs165m08IDP7U4gfcsUtcuLvcIarlZ6DrQHFoCwMeWyx6XOsrs6nrWIrMMEL5KeBhY 2VIGHG0ZAY6z3AJOtIwDp1judj3DV3m8LemWKWlYHWP2SjCzlmkJqePNQUmB2RNUJ5n7JFVLruUx cIFlTlLhEk9fqDzMqeZBKVadYR6SElqKLYtnXGZZlhJwuWcwzNnm61JyS6VljfAmcA3J11ueAjdZ 9oC1lkNgo+X4jFlO5hlqETil57o6zzwqpbW4uGgpjbSWGS7xcnGnjEs8o+pC85iU0xLkEgmnnOZx uWdMXWKekPJb+rh0KR/nPRPqEi4L8uXmSamoZZDLJVxwlh/iioGvc2XAo1wl8BhXAzzB1ZN8k1SE r/VMqqvM96VSda35oVTRMslpz/g+p/Xcb3nIGaUKdYN5RqpWN5vnSR9YwsJZfoZzQU905iWprmWe 857xEheU6tQm84rU2D7d4SUcJNwH/LhjEHiuYwh4seM68HLHKPBax5jUiK/qcbVvdkz0eNWceV3S qEXzlmRof9oxCbzXcZ8wzh92PJQM+GxPUO0270iK9uOOGUlhkpl3evpCrPab9yXGpOyYJ7wEHE3y 0SQf17ECnNixDpzSsQWc3rEjMfiqnkHgI8j3mk8k3pTVsQ+c23EEXNABJbi8Z0jdz8olp6nYhbnM FdVzXX2FjZIkU6UrBrMpSPLxwDWuJOB6VypwkysDWOvKBja68iQJX9UzamJdhT1j6mvqDSlgElwl UkB9g42RLmP2palvsvHSgMnlKgf2uqqkAVzSMxEqD/NtNkm6qr7DpkrDpqCr9oz7XA2wdqC8ZzLM 99gMacQ06GomrDvLD7lMwNddHPCoSwQec7mBJ1x+4ElXb899031Xv0erfsBmS7dMD11Xeh6S1sbD JTOua8DzmHFJz4z6EZsn3TUtuW4Qvnmax+U98+pZtlCaMq24bktTON+zZFp33elZUS+wJdK0aQtm Hth17yy/43oAvO96BHzkmgU+cS1I07Tc9QQ4yrUqTeNre9bVT9hy6bF6la2S5ugY18YLHO/alubU G2yttKjeZhukZTrJtUv44Cyf6nomLat32WZpjc7oRGec3amQ1tQHrE7abFnh+ggPAq+T/BY3BLzD XQfe50aBj7gx4BNuQtrEV3keauXcpGdG/Yw1SU81iOWkPW0Udx84hnA84STuobSHz3rmNQpWlA41 Cm4GM85rU7l5T7RGxbqlY20Gt0R45YV8NrcOnMdtARdyO8Al3L50jK/yLGliWb9Hpklgez1KbTl3 BFzFnQDXWuXADdYoj1KTzPZ7orXNhHXWGM+KJo294onTmqzxhJMIp3riNGnWDMhz1mxg0ZoH7LYW 4nKov671W0ugpNda7tnSZLLXPInafmsV8BVrrSdRk8PekBYxe3a016wNnn1NPnsT6t+wNkML+VYd ZihZD5WHuYi97UnRlLJ3oG83rSbg24TvWDmYGVx+pL1nFcF6krymgr3nSdc+sLoJ+8/4kbUXeNba D7xgvQL8xHoNeNV6A3jDetNzot223vbKoZ0HnixNsvUOcCn7CLianYV+7lrvAR9gJiXrmjp2wZOr fWZ98Dzjci+ErdZHnvRWhXXWG6NpZJ94ClpV1gVPAc574zWNVijRaNhVMq4Qb5zmW2Ot28AJ1l3g ZOsBcJr1GXAmj4BzeAWMHV97pDGwG55iDcNue8pa83nVC1zEx3rKNDy766nUONkDT01rKTeImU84 4wo+2VOjkdhnnvrWaj4NuI5wI58JrOFzvEnYJ/Gmthr4fPBPwDfwZrQyfFHXdivPlwI7+YqQBfdm YzvozWuV+GopuTXA10nJ2BJ5C1sv843YKvEaYLA13pLWAd4g5bde5RmwL7BevOWtwzwvbWK59Va1 jvBO6bj1Fi8Bj/OBkIx5a/Hz9Ta03uUve9I1FfwAMMyDt7l1ir+K54QfBg6NdJofAX7M3/LUEIuz Red1qsD6YM2/Qxd2xkoMXdKZAFzemRzWz/tYy/Uc0VWdadKI+l5nJjDWMyd0bWcO1jmd+cCgSYJy uqGzCLRHc2eptEwkf711jh/36loX+bteU+syP+XlWtf4aa/Yusk/7lptfcrPdW207vGLXjfUWYY6 h/ya1996zG96e3Uy/qm3X6fk97xXdNH8Ydeuuoo/lkp1cTaZ95ou0ab03lA32KKlal2KLc57U51h S/TeVmfbUqRkXbot3TOjy7Jlee/ocm253nshf0NXYCvwPtAV24q7FrBH4X2kK7OVeWd1lbZK/BRs NaeWXVdjqyfcBFwPfVvQNdm03ic6rc3oXdUZbax3Q8faBO+2TrC5vLs6l83rPQj5tC0yWxC8uJAf RbwUndfWB74r8Rt1QdsgcJ9tCLw4LBvPWrQ2YN2gbdSHdEO2MZ9Cd9024VPpRnFNtdw22XWgG7Pd 98WGPDfNsO1h14JuwjYDa5z4qLpJ23zXdkuibanrme6+bQXubrStwzw8tG0Bz9h2pDTdvG0ffLAx 2xH0Z8l2ArwiyL39mkMhCtpfF2J8CbotId67gGfAl6zbEZJCsu1L0+0LqdDOkZAh5etOhGxfpl4u 5PlyQh6mPkoo9OXrY4QSXxFeF75SfbxQDl46+Oq+ihDrk4SqkAfuqz7HdYQbyV00hA36VKG2a1uf ITR07eqzheauA+xR+xh9nqAL53nCTry+fFJ4JsEf9gUIX8a98g3oCwWTbyCUJ3xVXyJwUqy+XBDB Hwav2DesrxLcIR/YN3KOb4GnKkhp+lrBD9yAGXutvvEQ65uF3pCn6rur1wn9Uo7eJFwBhnIo4YRr Ia/VW/Iu+6bwqvdNE34cYr0o3ABfFDxS35zeLdwEzxP8Ut+i3i/clqr1vcIdYE64Bz7nvPAAfEv8 XJZDrO8XHvnWtKnCLKxurJmj9VeEBbCeqcITyF8TVn2bmmRhA1sEYdv3VH9D2PXs628KB749/W3h me9Qf8eOfMf6e3aFXxbW7UR7axrtKr9S/8AeC9rYaU/wR4c0of6RPdkfp5+1p/kT9QvWcn+K/ok9 058e8gG0JnsO2AJiZfSrWG+HbLR+w57vz9Jv24v8ufpdbG31B/ZSsHqgtfwF2gV7hb9A/4xb8hdr r9irPYkGZK/zJ4bt8k17oyfaoLBrsC9hN0ibBpWdwTbdzkvHhli70xNnSLBLcN9VewDbLzvoQEOy fQDK0+xXPXGtOfbhU0thyLSP+MsMOfZb0DfwJXyxhnz7uHcBj85faSiy3w1pWs+SodQ+Be1U2KfB CoDN9dcYqtk7/npsp/xNhjr7Y7/W0Gif8xsNGvuin8Xz5hdIOy6Dwb7s9xoY+xrEOKDD/cGQt4PZ 2xziU6+GFf19mEMl/kHCQ7gP/uuERw28fdMjMzjtTz1Kg4S9EeyZeJsNAfteKA/2DhiuAlvgH8Na 1z9muGw/DPkV/okwwyi8tYYB+zHYC5In4xozXBVlnhTDsKgEjwL8Cv+kYUSMDnkR0Ksz9g9pb4px nizDLTEReFxMCVl8aAfYf99wV0wPWXn/Q8OUmOXJNUyLucBQDiWPxYKQlffPnON5bKf8S4SHCK8Y 5sRisN1gwf3rhkWxDCw12HH/lmFZrPRUGtbEGuBNsR6sWLXY5Kknc75DeD88M09FrafAsCcaPWWG Q5H11BiORUHabJOJLv8RreusCEbRps7qQDXNddYBi52N0gDt7tRIBtrfaZAUdG8nE4yBOjyc7e90 BuPpK50SnL3WGQgm0Tc6LwdT6ZudAxAN3ei8Kl2mb3cOBzPUVzpHJIm+03krmE3f6xwP5tEPOu8G C8FiTkkj9KPO6e5eerbzcbCEXuicC5aHogP1bOeiNEU/6VwOVtGrrjvBWnqjcy3YQG93bkIct935 9MwP3+3cCzbTB52HkH/Wedx9h0FuWVDHKNzKoIlRuaODHBPrjguKTII7Mehmkt0pQX8oAjVVutMh 5gpFOiSmYNLcWcHeUJTHZEIJz+S4cyHmAlsf7DeNuguC/XSGuzh4hcl3lwWvMUXuyqDJlIVrqvvd NZKTKXXXB2+E4qz2aXfTaTwbijGZChJXVpq2cMTn1p7dfcxtBCaxElPtZiFiCsU4JxBjTjN1nXu+ IlOxW4D2G92u4E1G4/ZCnAUzELzNGNzBsK8yyDDuPmmE4d2D0jLjdA8F7zCS+3rwXigeZALu0eAD 5rJ7LPgI+znBWWbAPQExNUTWwQXCT5ir7kmwGhBBg70ADq5i9pCYOriB7xLcDjEz7L4PIxqBmItn brkfSk4c/wZ3mXH3TDh/QPgZ9pcuofBMQvR6SRFm6NUlFXPXPX9JFcoTjmWm3EvSVWbavQLRK8Sw lxKYx+71UMR6Kfkcp5lm3FswY3PuHeBFzDjG9DaEmFl274fiykuZzJr7SLrLbLpPgKEcSp52yUMx 5qWcc5yPvbhLRYRLQ8zsdUVB5Ajx46UK5rArBuJEiCIvVTPHXfHSolnWlQSs7EqVls3RXRnBZvxc LtURblT3d2UHd81xXXnSlDmxq1CaM6d0lUDN9K5yqbFNKXr9JyR2IPaI6C6IWdqixWC3vC1O7OuO 0ijEQV9sW6I4hG2HeL07pi0FM+RHu+Pb0sWx7iTgiTPOEie7U9tyxfvdGW0FcJUyFNO1FYsPu7Pb ysSZ7ry2SnG+u7CtRlzqLmlLxPqT8FFbvbji28PasruccJXWL6574tqaxK3u2jatuNPdoMkX9z3r bUbxqLu5jRVPunWETVhPdnPh2Aq4W2wTHPJudyjOanM5orr9bV5HTHdvW9AR393f1udI6r7SNuhI BR5yZHRfwzqz+wbhm23XHdndt4HzPLK2UUdh9522MUdJ952QTWmbcJR332ubdFR1P2i776jtftT2 0NHQPds242j2FREtqmybd+gkQ9uSw9S90Lbi4LqftK07xO5VDeNwe8rathx+T3HbjqNXuhuyUJi7 NzQSWEPIO/r9rpDnpo9xXOnebtt3XOve1SDHje6DtiPHze5nbSeO2/6TtizHne5Uo9xxrzvbGOV4 EEDGGMejgMIY75gNqIxJjgVpwJgqDgViz7dmzHA8CSQYsx2rgWRjnmMjkGYsdGwHMo0ljt1AjrHc cRDIN1Y5ngWKjLVOFCg1NjgVgQpjs1MVqDbqnLHAJmdCIDbMnDNZ2jSKzrRAndHtzOz2G/3OnECj sdeZH9AY+51FAYPxirM0wBivOSsCvPGGszrgxM83IBlvapyBgPG2sy5w2ZjkBJ1vvOPUBAZCz854 z2kIXDU+cDLefuMjJx8YNs46ncALTikwYnwCl94yrjov++M0FU6IsIwbzqvA287hwLhx1zkSuGs8 cN4CfuYoDEy1I+e4b61d4bwrKdpVzqnAdHusczrwuD3B+Vhi2pOdc4G59jTnYmCxPdO5HFhuz2EX fEXt+c617sL2IudmYA1qPoWapc69wGboLu0VzsPA0/Zq57F3ob2uQxbY0yiMGdJhe2OHMnCoKeqI 9qS0azriAsftho7EHlk705HSo2znje4epaauA6xzu7Mjqwd8uY5cT3271FHQE9ce6CjuSWy/3FHW k9I+0FHZk96W21Hj28PckxWK+tuvdtT35LYPdzT1FGDvpacYeyk9ZfhXlJ7K0Iojv2D0hX+peH51 PAj/VkB+GeipaR/p0HZnYPveU49j8J4mLI092tCvQ0Q/HLXfEoegfeKJtY93GD1LbekdrGcp/OsN +V2l/S7L9Rjb9juEHjYU9bdPdbh6BPysvbVIhj5C7VH/EyHql9QhklHPqF8hOfVrGYUUsgsyBXpJ 9iGZCn1IFiN7BV2UfVgWj16WJco+il6RpcreQK/KMmSfRB+WfUv2LfSRiIqIP0QJF8ovfAElXuAv 2FDShR9f+DFKjoaEXo9Oif4iSomuiW5C1dHq6B70lei3o3+E/NEz0Tvoz6N3ow/RE+jNv0Jy8tcP otHL6CX0CqpDH0L1SIu+hHTo66gJ/RvUjwJoAL2Dguiv0c/QLPo5FYX+G6WiLqJfUy9TH6YoCn/j pMTvTVIfoRqpNiqJaqeCVCbVS12hKqgh6lvUl6m/oH5KfSXi+xHfp0S5ILdTDrlX7qc65L3yr1Nu +dvytymv/JvyP6N88m/Lv0sF5OPyCepr8kn5D6g++Y/kP6IG5P9V/pfU2+R7zCvyRfk71Dfla/J1 6s/kW/K/p4blv5D/groh/6X8H6nv4LfoqNELr154lfr3F965cELdUlxQpFFLik8oPkEdKD6pyKZ+ qfisopD6Ff7Cg/q14vOKMplcUa74okyh+JKiSRataFHoZEkKg4KXpSjsCkn2KcXXFP2yzyoGFMOy 31d8W3FTVom/nJDVKsYVP5H9sWJeMS+zKhYUyzJesapYlXUq1hXrMrfi7xRPZV34fSyZT/EPigNZ UHGoOJH1RqLIi7K3I2MjPyz7duRHIt+QfTcyPfL3ZBORn4tkZNORtshB2U7kNyK/EaGK/GbkcMTF yO9Fjke8iv+uasRHIv9T5L2IpMipyB9HJOP3gSLSI/86cjkiL3IlciuiIPLvI/8x4i1luvJORJ3y H176WMTPon8V/Ss5/l6OQb3AKpSMvzYunQhDCchC6Yy24ogxllX84ZOyHIZlBMZVsc54mWAZUzPA TDL3mYdlU8wMM88sMSvMOrNVFVWVyvRViczgW5VvGZkh5jozyowxE1Wpb5WBVMlBxveIjP8SUdSv qV8jGUh0DIqAc6+RN1GR7Huy7yFK9n3Z9+HchOzPUYTsh7IfogvkTVSF7KeynyIl+RLsJdk7siUU Rd5BVZG3Ty/Kfib7GYom752+LPuF7BewOvCbpbERVAR19leDL0QoUDz5ciwhIj4iHv2ziISIBJRI 3hT9aERGRAZ6jXwVlhxRFFGEUsg3YB+LKIn4HEolX8WkkXc2Pg79V1GxZOYwI/oRctOP6Fl6gX5C r9Ib9Da9Sx/QzxhEHzAKRsXEMgkEyUwak0nvMjlMPlPElDIVTDVTxzQyGsbAMAzPOBmJCTCXmQHm KjPMjBDcYsaZu8wUM808ZuaYRWb5fDLXM2vMJvOU2TtLh8yxWWZWnkvR5jhzojkFStOfS03mdKib Zc41FzDHp8lcbC4zVwLjVGPWMntmI9RlzVqzYHaZveaguQ/aTDcPmofM182jMH7qJSasNfA366+Q OUmAFIGSIMlROvoEuoCyIEWiT0NSokJIL6EiSFGoGNKHUBl6i7xd/kegdfB3ly+jP0GNKAY1Q4oF vaNDryIjpDhkQwL54tJFvrX0kDfKu1Ei6KO30UfRNyG9hv4tpGT079BN9Dr6HqSPoXFIqegHkN5A /xlSGvohpI+j/4IeQf9mIWWQv4b9SbSM/gZlor+FlIV+DulT6O8gZaN99A/Q9yP0v9Bn0AmkNykZ FYnyqCjQfYXk/fF/CbovBhWR98eLqWTqY+gPqDeoN9DnyfeeZaANa8gXnY2onPoqpUFfoLSUFv0R eZe8inzd+UWKoRhUTVkoC/oSZadEVEN1UX5UC7oziBpAe34N/Qn1daoPfYUaoAbQV8nXnc2gSe8h NTVFTaFWapr6MdJRj6m/RAbqr6i/QkbqJ9QcaifyS4MWyECMMlOZiSzk7TxO+RllLrKSN/JsykJl IRKUxcpiZCdfEonk/TuHUqNsQR3KVmUr6oRnu4UOiezn450lTHcBU4BpwGPAXBiLYSwD1tC/Nk2Z pk2PTXOmRdOyac20aXpq2jMdAh/TMloJKZqOoxPpFDqdzqJz6QK6mC6jK+kaup5uorW0kWZpgXbR XjpI99GD9BB9nR6FNEZP0JP0ffohPUPP00v0Cr1Ob9E79D59RJ8wvYyciWJimHgmiUllMphsJo8p ZEoglTNVTC3TAKmZ0TEmhmNExs34IfUzV5hr+C+IXtBeaAcj+NXoZrK/wlv/1+T7i5BeJlIeQ6T8 FSLlrxIpjyNS/mEi5fFEyhOIlCcSKf8okfIkIuXJRMpfJ1KeQqQ8lUj5G0TK04iUf5xIeTqR8k8Q Kf8kmoOUSWT9nxNZzyKynk1k/dNE1nOIrH+GyPqbRNZ/D2RdhvKJfH+WyPe/oF6jkkHusWQXEcn+ fSLZxeT7iD8g0lxCpPlzRJpLiTR/HqS5C9aAh/LAGsBfSXyBSHMFkeZK6k+pP4X1gGW6inwf8UUi zdVEmmuoOZDjWmqemkd/rPyy8suoTtmobERfVrYr2/H32jHemMvwnFQw9x9ClLUZ5C4XUAAoBpSF yyoBNYB6QBMuk79iyrPm04u/G6TOMr9kKrQWmUqspfTa88BlpnJrBb0JeMqvYJiqrNX03u8GrmOq tdaZGqyN9OG7wP82NVs19LFVw8j4dZPOamCUvxukTjS/ZTJZGSbOypg4K08gWp1MIiCFZ0k+nd9h svh9k9sqmfzWAJP7Lsi/C/gjU6/1MlP8PijjT5hKm9zUbx0guGK9arpmHWZqQsB5PDam/l2Qsd6w jjBN1hF8JLhpvcVo3x+4num2ddx0x3qXMT4P0z3r1Gm752F6YJ1m2HdhemR9/EHANYvXTLPWOdOC dfE34ol1GYPTiTcwTKvWtQ+EDeumadv69D3Yte5hcCZbv+nAevhBwHHiTdMz6zEGjXgZgYJXYnCi eBsfLax9jNbwWlrFR9OxfNyL4NziHTqBT3w/cH7xHmkjmU8hSOPT6Uw+6znk8LnvQT5f8ByK+OIP jFK+jK7gK9+Dar6GruPr34NGvuk54HF/ADCCLYo28Eaa4dnfCDjHuGwxjNcWT+rxvPCB4ORdtMR7 3wPcXhDQZ0uiA3zwg4AZtKXSl/m+Mwzwg2fA54cA120ZJD9qy2bGbHn0VX6I9PcFMBO2QpIf5q+/ H5hJWwlz31b+XBsj/OhzuMWPvQf42oe2Knqcn2BmbLXkOG9r+E39+a24y0/SU/z992Caf0g/5mfe gzl+/jyYJVvzqW4/r4tPdeWZjlux6c500LrNdF6PnMnJ+ed6+lxO52jLxp3N7Y5NPN8nokt6QafA 2uf6QzqAuxJav2RdXeMTid0AeeduAG6KD07lmbsNR7gPPs/s29zMkc3PnNh6zXJbP7Yv5ijbFVyO x2aOsV0zx9tuYP1qTrLdxHrSnGq7bc6w3cE2wJxtu4d1OxkzyLs5z/bgVD+bC22PzCW2WTxuc7lt Ac+Fucr2BOtO3CZBrW3V3GDbMDfbts06267ZZDswc7ZnZlFAeH6JDcJzCXNodoOdDNszsx/sT3ie zb3QTr+gwG2Qc1cElfmaEIvtzpmtPfeMztrECNuUU1uA+4Rto/mGkED6dlNIPn3OpD7W/fDsiV0G m0fGdltIw2XmO2DDC0PA9hrP73OoCtllbK+IPYb7nNpifCQA+SFje8HGknsBzPesEga2sad29RTm B9YBjDMbiW1m2Daet5XP2ciwnTyF+RHYQXjGxPaBPTTPWqcwiNxiO/cghDOdBTAvCJnk+ETIMa8K +aQc9Id5Qygybwul5l2hwnwgVJNyvIaxLcHrFtYRXk/mZ0Idi4RGrItYhaAh6+J0HYT1IpEtaAfr OVYFuim8RsjzAr2Frz/Vge9ZWy+sqzP9ctp/aAPrTTZWMOBnziYIzNn1uD6sNzZZ4Nk0wYn7zWYK EpsjBIgOx+OBMbD5wmW2SBgg172f/gn3iy0N6/HTNR48VyfcZzLWF/Tx2XiwHj7Fb7vXb9GnbEX4 WM1P4DGd4UU9eV5XYv14qiPP60SoS9rBdfA5mAO2zlbF3REfcffEWQzs2+DnTfyaB+ICKQOdxS7a o7lH4pNT/4WbFVfZgDBN9Bj4HdyCuEF8CtBp7LjwlJWEqVOfgHsibhOdhu0/9huwrlsVd7GN5jbE A25bfMZOC8fcrgNxBw4F98yhsiJHrFXhSLCqHMnEJwvrS3It9s3CfhPxeU59FNxWuA18zhrrSMP6 EvfrzLc79cMO3tXBBKc+TNj3wG1hf8ya4MjE/o412ZFzej2pD+Mh/4b5IusExmZNc+STMuw3niLs Jz6HF33BsO/3HMLz+qJfdwbsi53iRb/u1Ef7Db6ZNTOE9/XNsO913v/CPtep33XOx8J9JdfiOuE5 ec/agvXHNgpX37OuNMLwqY/FGoQRlhFuYV10Wo/lhXEs16xTuEvk6VQP4Dp4zYH8keNl4TE7IMyR /FVhkR0WljHOrzd2RFjDOoK9JWwS+bwr7L3HjwGwU8IhAcgjBlmHWG89tsvIcc6uPF2DeE2wy/Y4 ds2eeLb+sA7atKcQXfPUns7u2bPYQ3sutj2nwOPFMRZZfzBm9theYJHZi0nboD8sSnsZGWe4viXa XmmJs9dYEu31lhR7E9ZFlnS71pJlN1py7aylwC5g+0dsINZP4BNYiu0uS5ndi/WxpdIeJDEL2EJL jb3PUm8ftDTZh/B8WbT26xajfRTHCRbBPoHnyeKyT+L6Fq/9viVof2jps89gHxDr/1PdbBm0z1uG 7EsE0B62M1i2LdftK3jeLaP2dcuYfQvLmWXCvkN0GDxHy6R9n5y7bz8ibTy0n2BdbpkR5ZZ5Mcqy JMZYVsR4y7qYZNkSUy07YoZlX8zG82s5EvOIHsPjPxEL8ZGTiyVYHrgosZyLEau4eLGWSxIbzuQH fHDsf3CpYjOXIeq4bNFEysM6l8sTOa5QFMnzg3XClYhurlz0c1Vi75msnsYBpzYK8lyt2I/rcA3i FVyGZIiKDkYPIPT//wfl/6H/QdlB++/+P4DuEDH6RH2KPl2fpc/VF+iL6+T6Mn2lvga4Xt+kOwwl fQqGXqs36o5DSc/qBb1L79UH9X36Qf2Q/rp+VD+mn6jr10/q79c90D/Uz+jn9dHhNEiwpF/Rx4XT un5Lv6Pf1x/pTwxyQ5QhxhBvSDKkGjIM2YY8Q6GhxFCul50mqFFlqDU0GJr1ylAy6P43e+cCZVV1 5P1zzzn3dotwRewgtEjajiLyEhskiAwoQR59HyABZQiRtu/7ikwHCSJhCBA0LSEIjhKCigwh2HaA IEECCIgMrzAEgSCgIQyDBAmQlghpCQPNV/Xbp6FtyYpZ831rfWvNrL3qf4s6tevsXbt27Udfr8ls skz0xtJCbZFq6jN9n7xB7/kbVUps9/+/cg8akbkxQMr13IM24R70Bu5Bv8Q9aFMrbWWtG62RUvK5 Db2J29CbuQ39MrehBdyG3sJt6Fe4Db2V29DbuA29ndvQ1tyG3sFtaBtuQ9tyG9pO5twOq4O1U8pd 3IYWcRvaidvQu7kN7WJ9ZP3B+qp1Uko37kTv5U70H7gT7cmd6H3cid7PnejXfC19La3e3Ik+wJ1o H+5E+3In2o870f7ciRZzJxriTjTs+2ffd62ob7JvsvUgd6KDuBP9OneiQ7gNfUhm+i+th32rfaut YdyJfoM70W9yJzrCneb+wCrhlwZL3VXuaisu83qLlXSPu3+w0jJ/q8WXPmucNfFKrMakx7F9sYOx I7HjsSopZ2PnxfGBeMN4k3izeEtKMj4yPjo+Lj5RytT4tPjM+Oz4y/EF8Yr4Usqt8TbxjvEu8e6U XmC/eFRwcHxYvESLxo3dVuKmvRc3TXi/RowtY3S7RI/Giiv+L5Lo0VgJECs5EikPSAzpnfk1Eh3D JIY0Pq4lPhpyT95I+vWYRJJGQ2OJhVkSTxoHTSQKFkk8aQTkWW9I+RIR0JQIuFHGf5PErd6HN5cx f18iTEf9Jka9BXfgN8vIn7BaMsYFvsYyxrcwuoWM61cY0Vt9I3wl1m2M6O0yomVWa99YGdE23HK3 9U2XUWzHKLZnFDtwp32n75e+VVZHy5fbJbd7nfFo414fa1O/xMfHJ8U6xrrUlnirWHev9Kpf4s/E +sWipsSnxwbHBsefF0m9Ep8TnxcbJqVESlJLfCGfI2Oja0u8Mjbu8yW+DAvjYhO9MtWU+MrYtNi0 +FrBmZ8v8Y2x2bGXL5cFquuVCq8srV8ySzMrYitia2pL8nRsg1e21C+ZNbEdte/KbIjtkbJAJPVK onOsOnZAir7vkJZ063hQPo9Sg5Ko+rz12JZ0HyxsqfVs7IQpmS2x07HTmQrB6s+XzA7p34XLJRq3 L5dcU67iqW3xnfFgPO9y2RvPp3xwxRO1JX44XhBvVVsY8WPxdvXKKaFP4kWUrlLOefKahCvY43KP orGJiQbx3p8vicbx4kTT+MD4Q1oSLeLDTUkUxkeJpDRemmgdL61j53JJdIidiKcvl1HxMbXFeD92 SEZE4jvRjdjtl7gv0UdjLBFWTyQGaXwkhgr3CL1tl4gnsrQoS1+NJY2UPYzSjsyBzCGi4SjeP4Gn TyXKZO50FP91iXVPjI1VJCaIl4OJKdK+8sQMieWSxAsS7+MSc+N2Yr7E8szS8sSieFd57wyJk6mi uzixPLEqdiGxPrEpsV1arPE/M7GLXpbIiG2LTU3sE41o4mDiiNjSWUuP0DRzRUd3amxw4ri0v0r6 fFbk00Svi8y6aYnzwnVMPJK0Yt2TgWTDZJNks2TL5K3M5cGmJNskO+p8TXZJdpfSK9lPZutIM2OT 0eRg3iZvSg6LTU2W6JxMimXRHJkcnRyXnJicGpudnObNP52BFcmZyZESa0HiLV+ezo4Xx7smX47n JxckK5JL48OTK2R8ZbQSM5JrkhuSW8Rz7eK9pU2z4zuTO5J7RPuAlEPxouQaIlB7yVipnhSJGPVS 8qjQiXhvmcMzk9UiH5O8kLKTh1K5KXl3Ki+VnypItUq1E19nU0Ua76muqR6p3qni1ECNcfEsY556 KNFaoq1ranhyZKpUSjo1Kt5DizwbkypKjZceFMcfkieT4sNTz2icCpampqeeT81JzUvemloYO5Gq jKdTyyQeR2nfUitTa+WdpRKhY7R/mdOxFZnqdFwyw4bMBRmfQ9Kf3hIvM7N2NleyQEU2KJliS3J2 6lQ2L9YstqZ0e2pgNj9boPNaYka8lW2VbZctSlZku2Z7SIRq5qiWbKbeqcisyawxGrGZ6V3Z3mJL 8x0RjKbJMhLBYmtPtjg2OzswtjT7UGxL3Ba9NdKe09nhwq1IDc+WxjYkuqWK0t2y6eyo7BiyoJfJ suMzZNZU18yezJ7spOwzkueOmlyXnZ59nrfJm7JzYiey8zSbCZ7OzssuzFZml6WbZiWjp4abzEXu ys2cyK7NTo8Pz27UlqQ2yjhp7AxPbUvt1PgxJTFD2r0ltVdzUuoDGePD8YEyOsckrtpJPmiXOiW+ Xpj6JN4jdS5VE4um3bTkndjRdON009LtpdvTLWQEF0rcnI6NSxemW6c7pDunu6Xvi5cmD6nfYyvi XdN90uHY6fSg9NDk0fQjMnumSYLJxkfJ+w/J+ngsfZ/M4KDkrFJ5UpYem54Qz09PSZenZ6RfiE2M 56bnpuenF8X2pBenl6dXxYPp9WI1mN6U3h47IJYPpXdJm4LSln3pg+kj6ePpqvRZaeMOsZ0bOy2a 5zNWJhCblmko2aaJzKWoxE0zqdNOYqVrpqXE76nMrbGl6dapU6lTiRmpw7FDyT2ZNpmOmVvFD3am S6Z7pldyR6ZfJpoZnBmWKckkM/3ixfI5MlmdGZ0ZJ9oT0zNSOzNTM9PiYzIzM7MzL2cWpGdkKhJx dlPt//eE+T/ohJm2yvhWQ1P9v8mUVFi+R20rr2ShlEopy6SslLK2ZO0wKSUbSzaOODDiQMk2KTtL diLbK+UDKSo7LOWYFKk3tGpoVckpKZ+U6BnWDkaDA+QdjTnRWJxobM4yDntel7OMn1NMgD1vDqeY XE4x13ByuZaTS0P2vEH2vNex523MmeV6Tis3WL7G8caj6BPfOyzpbPlKwvLZTT4Hudf3W1TS54tQ cbF8LhZa/ldolaHi4Yb6rf+CtElo+1Vol6HiMfK574tR8ST5POjREY+OG+p/yHwWzxGaJ3yV0NnP U3GlfJ7/21S8Umit2LU8Cgg1/CzRt3rUv0k9avZ3UEuhW69Cba5iV6ljPeryxSgqfu/fXajXX6F+ hqL7DPWPfkEaLDTsKlRiKCrj1j/5xSgqY9t/pEejPRpnKHrcfEYOy+ceoYlCUz9PUYmB/tP+NkXP ejZmejRb6OV6tOAqVFGPlv4dtEJozVVog9CWq9COerTni1HxMfk8UML8uCrJs+JTQp94eke/IJ0Q On0VOuDZrJHP6i9GIVc+L1yhYvsKXdZp7H02FWohz3KvvKsuhQq99wf/NoVaC3X4bP3ivHqUfxXS up3ls0A+u3mf9129PX+NilsJtbsKFQl1vQr1+CyF+tTJ33XzbW2+9PJYKFxyOb+EBpV8Nn/Uxknd cfX8fdlHQ+v49pHPtulyTqmbA2rnsDe3dM2ojfkBzerFdLV5HooLZYXKTI7Q9SU0wci1T6EpQuUm v5boeEmeDL0gNNesAaH5Xn4/b+I9JD6pzc8hWdNCy01/Q6s8P4hNzZdqE1K7Mp4hyYsh8V1I2hBS u8c9/3r+1Lqsk7Vr2JE6fhY7YcvY0GdhWS/CDb121R+nemN0eU2pHadyszaGm5i2hZvVqX/e9IV/ L/fWPvl3uKUnW1yHVl2F6q/Lu65C++qsr3XW2MtUVYfqra+X18v/zjrZsuSza2GbkitrYJ317nLO Egr38j5l3QpHvTkm+SMsa1JY1qCwrD/hpCeXOazrB/O2j5lPYVlnwqNNLgqP8+aFNw9q86LGltrR PEd+qp0j5SZvaf3LObD+3Ko3r2rzy+W5Ve61f6o35tOu1Edf5ltY1qbwbNPusKxJYV2DDnk5Sfsg a1B4qVfvb+Wg+nn8ajq1bb5KPr78LPcK/dVc97fyacFn6XN5sm6uLKqTI+vkQ3QLPJ2uxgeaowdI /AxoY0j3NjreuqcZ0NGTSaxEeguveczbvwyQvVG42stjMqYDNLammnwWUd+rv7w9wYB+Xi7T9X+2 l+c0/mSNHiD2Boi9iLR3gMTNALE3QOJsgNqUGBsw0cuftflyqbc3q903jb6SR7Hl2aCNU02+pF31 83C9HHx5D1Obh7WfakufSUwNmFmn/jSvP12Mv9hzSd8GzPZk3etQv6tQ/b1gyVXI82v9fd1lmliH 6u/ravdo/5292YqSz+6/NpRc2XfV3WOVeHXX1PFJ/bkl8y+8o+Rz8yq8p+TyHius8/qQyUWX89VR E9fhE1481cpVp9qLP/2UvBLx5l1E5lgkaKjufIvkmRwRyTfxGWl1lX2MUKSdR0WGyINqv6v32ePK HNQ5EZG1LjKwzvwTvchDZr5FZI2OlAqlzdpTS+SjSuMn7XNklNAYz7b0IzLe66enH5EzXeQZoelC z5eQiyJzhOQMF1koVGnWPyXypOwJIsuEVpp8HFlr4lTXwshGoW1COz1/7RX6wJwTIseMnyKnjH5E 1o7IOaEaswfU/F+bm6OyBkQbGFJ7rDMS29HGxu9R2YNGW5g4ixYaP+o4Rlt7zzp4NjqbXB6VPWJU 9odRzT2yH4vKPiwq+6qo7KeicePfaNbLY9L/aJn3OdbEQ1T2QlHZA0VljYjOuBI/mrt1PxCVvVBU 9kLR+Z7cy7lR2Q9EFxv7Ok+i4qOo7AGi6+vEau05oHaNEj66yehEtxuZfhuj0cZGm//32xj/k+7K 3DbuJv2Lqr3d+rll5RQItRJqJ1Qk1FWoR53P3kLFQgOFHhIaLlQqlBYaJTRGaLzQJKFnhKYLPS80 R2ie0EKhSo+WCa0UWiu0UWib0E6hvUIfCB0WOua989Rf+fxE6JxHql9jWbmukec2EGrste2U9yl9 yG0q1EKo0Mgvf7YW6mDamtv5Sp9zuwndJ9RHKGzs5A4y78sdKvSIUNyTZ4XKhMYau7kThKYIlQvN EHpBaK7QfKFFQou9z+V1Pmv1Vwmt9z7ne/XW13m+SWi70C6hfUIHhY5c+VT/5B4Xqvo7Pmt9cdb4 8e8lxqAuDTSk9hmvw57u8Xp03vxv52s/a+vX2r0mINTQG2+RX9Pkyuc1zYRaWj8P9QtFQ4NDw0Il oSQ0MjQ6NC40MTQ1NC00MzQ79HJoQagitDS0IrQmtCG0JbQjtEfKgdCh0NHQidDpUHXoQtgO54aD 4bxwPlQQbsW/20kpCncV6hHuHS4ODww/FJoZHh6qCJeG0+FR0Jjw+PCk8DPh6eHnw3PC88ILw5Xh ZfLvleG14Y3hbeGd4b3hD8KHw8fCp8KfhM+FayJupEGkcaRppEWkMNI60iHSOdItcl+kTySsz0U+ KDI08kgkHslGyiJjIxMiU6DyyIzIC1eluZH5kUWhkZHFXlku5Wr8KinrI5si24Xf5ZV9kYPQESnH pVRFzkbOR61oAGoYbSJrQvOr/uKC5f3iQi6/uNCAX1xoyC8uBPnFhcb84kITfnEhj19caMovLtzI by00DxYE77JuCnYK9rbaB2PBtNUzODL4LeuB4JjgU1YoODH4XevB4NTg09bXg7OCb1lDguuC661J wW3Bk9YUfn1h0f/HLfP5mvjK+L7KGv2/yRcWeSSZpbCHR709Kq7DK8msKXzI41VvuMeXepT2SLJu oWTdQsm6hZJ1C5/xdKd7+ip7vs6/53if8zxaWOedld6/l1lti7dL2VW8r/hg8REpx8EjxVVSzhaf D1mhQKihKcXbQ01CzUItQ7eKtI3IW4Y6hroUHwl1D/WSOcmsLD4r8zIaKpGxuo5f2rD4jQ2b39hw gkXBIssNPhDsY/mD/YMRK4ff22gYHBEslXHIBB+zbg6ODj5hFQTHB//ZKgxOCX7PahVcG1xrtQ6+ HXzbuiN4KnjKavP/2Lqv5hvu1wSHSXT4aq6FbwB/F/xd8J3cfoKd/WOQlyL/Efx0wSL/G/D94E3d u+AHUvdOwQ7IO7ujsKN1i7A/3O2k6P+GfvfJP174PLeXov/bgsvReVXfexH+4jraMAX5Y/Cd4DvB dzat9XA8+C10xObF/3TbCh72etSWp9+gVfTUvYd+ZWh5WnnnAHwuTy1qvY7kceqGkFwH35O6T2Lt OlrSE/Sj0wWdpGBH+I7wRW435Fn4LlhADnbiaRFPv+req+h/jJZ0Q1P5Ts4n6Bg/TMfaWqzpWNzp ViA32BUchE4cmyuxKd6wH9Q32u39JYJP+2V222Phe4IH/KMFJ6qOzwZfRJ922paik0TzRX9McBE2 r1eJb7/yvjM8nYX+A+g/B5+HtTPgYfTPu/8uctvdLDjI3atvUd73MZKku1+wu+pY1Yq+YvAv4DpF x0GzP3aGqL7vQyxUwC/haV/0L6HfBv4YuBF8E/2T7j+JZtj/b8Kf07i1A/63ha9Rua/Uv13wiCuR YOerjnXSP1nwz4q+Y55E0CnCTj7YgroJcBZ4o3uJp48K/66ifRB+LbgLfNEdrmMUOAmuBCvBcrBK MaeZvKuzGUE0nw7ob6iUwvcEG3lYCZaDWvdGNDfxdBmSA0gmIplvxl15wZVgJVgOVoGq3x/NCdSy DPp/rFEB/yItXwS/BlzkSSrBcrAK7C192eAvJ4rSirx9P3iGurM8XAlWguWgWpiFN55THWcO+Bxt PgMexs5hbbPvpH+H4FnwpP8VsAwcARIJ/lNi4UbG6xyah8ETHk4mBjZqbCCpwUINFmqwUENUHOHp ESRHPMkaQYe+3OLfRMzsAMvAEeBuRSLhsIkx5SXS1Npu+JOyp9c2iMTu5qH0xd6qUWq3QNICSQtm dwu1LLgZXENkLpY+jjfxieWZ4Cyvrs6LJ4j5G/X/xC3vegUsA0eAm8FToNo8SN2DeGMX1nbBvwj/ qofqve2088EctdbIoIk0+EUG/W8xsmWMoz49A38y8A/qYYPaKguJnGkV85HvYmR3IVnOHGkFFpCF 7iK/PR1oLfhd5B+Ri87CP68riO/35LRGJh+qpq+BPyV4A9lsKngj3liKTjvmwnvwD4IVXg6U9cWH fTtHMbBbRz/wA/WGn1zqlqhPAquUD7RT3jlObFcQJ0VE7w5qrfIv17ruUlqlT7Mmnwc0c7ZVlLm5 lzm1l3mks+M2+Fk8/b3XxydoT5K6P0P/Z/iZDOM/rv5RlFytaMarfUDWR3ss+o3gN6E/0cseleSB cl0dmINJ5C+C14O38Zb94KWcfjqaOYt5rz59QEdZZq7yeR6qzbu9nDxP+GbE5G4kBeAHgZt0fMm3 rxLPD5O3V2gW9e8hJneppr81sZerEhk7jeE8zee+HWYWy1lZVgTGZY96WPLAGmJsDbPS4Gbmyxpw MyuI5up8rSv+fJtak5lBk4lDfcu3tVVOf33q9DdZxZW9iu9m5ngvaq0KfEp+UP2u2lqJZJUc05ku Ef6eriy0vMjLP5PR1LcsBGeBGwO3Kx/4ITN3gK4yzNyDPF3roZmhyg8OtOXpKSSnaL96uEtgt+Y6 WvuKroa+X7Mm5tPai8jfwOc3wxfQlyO6U7IHump/pxsUPK67R7u5oozXZLKKjtpc+jhP55pzF+vg HYpOgSsS+1dYfgnNM1j+D/j/gO+L/R3qeUG1XEybRylay+BPgA/7G1i6r1D79zJSbbCw06y/uo+S fcKjZD+N8GnsXk64WXqh8fYVns6l5bt51zqs5WtP3d+oN/z4xP2U8R2r67vTVK057ynv3gvfh/5W 0YtPyRWfMhPzaSfZ3l6rLXQ60/drvNZqSwrh27myd/Vtpde/dGU36LuPtm2jLtFud3NH6hyn1mDd A9uDnT8KvuA+IJZ7MI4r3LjGp/2S8Hux9pGHau1V7NyNzSLXFfxQUaLuZkt3ZeIBJwc/vEat0eBM YuC4q95bioXW4I+wE4X/Nn1/BT/3oo9Zan0EHgQz6jHZZWkvpuiuVfhrNCpYgx7HWintHIydgH+2 ZgAvGrV3b9Ge84FbFf1nwPfAdcgLwWLNCWbPqZp2R7Cbfz/riPJ9zC4UO7vBrdjZip2t2Pkt+kn0 kyqxy5B0RxI1u1blrWptieB74DrkhfCq38jsbHnLOoPso/pjp7/WtYfADzG82hFch7wQvBlJC+KH /QY2P8TaWbACXAIudnUF7IvNvtjsi82+2OyLzb54qa9adtqoptMGD2zEwkb4N+Hf1F6IV+fRfsVf mP4qL22bh5151DqDBZV0pZ2feridmaVtGOS/k9mqozPZ1d3mBu90oG/Z7O5jznI6UE3L7OSPsrdv zimgH/grrDXHfjW4D1xM3aFgH+quQv4RuMOVKA0Uar8ClYpuVnXcnf7VMtN5V2C0X9ep4fiqDA/8 Bf2gejVQyby+i9buJk4+BGd655T9jM4WYnI/o7YfzxCfOsvEA610pPw3Cr7MmchGsyWau+Gn8vbu Jt4Yi9dV4jiMlIO8P/ofgp+CFeAWdvIVgWO8RSWXdFxkfJU/5iFjDb/KRI5KJBKKGcFiRlzO0dZU 5zdyroz6r1UMyLn14rs6Ey++65dRdl5ip7RdfeLeo+uOm1DeeQP8F+QVuh9zXyUroi97Y90XfZm6 IfZFj6H5jp433a2apR3Oj84QPS+7jXn6C2r9VDHnJuRNsXABXIx+CXEyUcfCeVN96xyC7wt2UnQL dIzcQmKjHP23iaj3Ff0L0elEVOSrpvMsI/tH+CxP7+BpM6KlNxbMWXUx2I939WRX8CorYB/1mPMh K0g5uXETq8YW3Z8489mRzmANWsD+cAKSp9nVVGFnPbgXfA98HztHwZ3gk6xN77POrlL0vwM/EVxN dq1mDfq+7t/ctuzi3vf4lWAlWA5W6VM9eflP4P/+aDYE7wn8o6A5kXFCdFZ7WAmWg2rhDTTHUetN lQiqZKBK/I8QFcPZ6z4JhsAydoaj2X/24UzKDtZtRfy8xbvQdMo1l7pIBLUXx7F8m4crwUqwHBRr /jv0TBp4m5jZ6m8qta7F2nwwBnI+dfPo+1PwKz1cCVaC5TzVfj2lvnLXKZ9zc+DH4FC1Ty3XQ/UP ZwRnsfrB6cmub4KHr4Bl4AiQWNKdW6AB4/5NNPtobvTf5t8q/Mf+dwR/jHyfh2XgCHAzeKfGG0+3 INmC5Fnd6zo/1xnq+2f20i3BfwCfZG9ZwDnoHvau7dgVzyCiniRiZ+g+0O6D5V/AP8XpdQVt+x3y 36kdN0T7D6nEvcnDV8AycASo8+t2bZX7ZT3DBl4zMa8zwj6KtWvB+ewQJjGP8tg/fIv4f5mn73v4 ClgGjgA3oyP+dG/Rt/jf0XtFQdVZTa3V8Hl4oBovfeCvZC601KcGObEe0xOre1wl/nXaEncl/Mfw LnHioj/Bf5JRMKin13f19Cre0KjY6U6ibRqxFvxqWr6apyaL9gCv9ecJWjpe/uaBB4VfoHL/LUTy 78CnvFyqmWctuXQWOtPQf50Z90fm0bVk1K5k4Lnwb2kGlriSWv4NjMsWbHJ6dZ7H8uNYawu/Us+/ csLVp2VorlXMXacRnmtx2voRlrkzyTHZ/t853ZQzQ08wg95kdtwNcjp2lmDhNaxZ7tNSay12fqlt c7mncjkRy1joGprgLPyE8mKhCtzLvK4C9zJbq8C9tPYXwv+QN67CSxd0D+C8RHbaCrq07S09I7s/ AccoOtycONsDz+h6xyyeBf8m+q9S94fM9HKVBNKaDQKPIX8H/cPgEHB+oFoxZ5iudOj8VCMn5yb4 pmAnrF1A/wXa3EBXB7eJ3lO5d/rziR/lbW2b/5SOvtuEuTPBnDeJh8X+bRonKnc/9M7UemNZyRnn HuZ1X10jcvoxdu8xUvcqH2jgbyRPz7FmrdYTsUSv5oTe+jSnHyvLfJ1Nkq/WgJvJS2tAXUOLuUdq i/wQ8kPIP0Z+FPn7yIdj7Xe8xZy8JrAy7gVX63v9h7VHAe5jneWcuBewxs1Rffvf9HwtWW4EHv6U NmteukfP2oFGzPoqZvd6RfHkDvLMnbREcSdPr2VfdK3ufCQfXmQuvELG0KcTwXIve2it/eSNt/Xc LTpzkc+l/eSrwHeFX0mbH3BvEvxXRbcA/y+jp79ldMai87CnqZKWnIN+pX10r9czssOtsmNObQc4 tW0jJ38HP7Rg3NtzLvsx0dLML7kokEutT9kh/FzP4/6sKycLdwY5dhR1R1F3OnyFvsv+Km8sZVxe 5dQfp0ff54S7lxnhIvmhnsrdtrTzG+if5o20yj8VfoKezZ1/gjc6j2OhC/hN3S/JvlFn5Wr3Rl0X aOFHxLk5Td9PJPSl73c6a6Vfw9ROYAw4XtGd7y4hc+qM+Jry/nH+cbRK/TkYHfP3jnVkM78+dZ7Q Vczvw05j/L+aFv5Uz93OB/Af62nduQu+r57WnZ/Rl+u0JX5mkPuw21wk82j/JOdjwe86EgnuCf0r T+An7Akf1dO69E7bc5Oe2Z1p2HzCQ/VhI/BhPaf7V4P/qOcI57+074GmeKCYM/gRapXoOd35Evx6 np6lPX+ghcuR/4m/ZRSoZwKteXsPcAT9HQl28faWuqo2p9YOPbnbv9GTu/N9/NOc+8PDtPBRsJjR eZZxDOmoSfQK2kuQtKCdcznFzAJ7Gp4Tyizm2ixOOrP0VCVP5STiv50d9QY0vwe+6X+afKh8EAwZ xEIICyEs9EWzirNeW5W4bZHsRzLXlRH3Ude+FXyG8/LXOS9/nVPYPZzvfqxnJYkE0bfTaL7PG5uy /2yPtfZa1+0NP9kgkslqTXAd8kLwZlZ28Yx/N73LunIqdF7G5j3YN73rAX5Hz57SfnqBzbbYbEtP q+hplfrKfVgtB3r794Df0yjCwjKD+KcUvh9+6BkI4yvFAZzfP9Dzu/QirHdf7m7eG2YG/RYLZ7AW 1tVKWyWZR/El9zbBR9wpIh9HRuW8LOdrffos2AJJD3eq8GWutq09EvKtezNj8UfwT4rOdkX/TkW3 PThZ6/o78JYvYbM/2A1ciLVy4yssfAy2xsNPgY9rxsvZqh7IjeLPc5z7HuOW/nHlcwKseo/qU//t eHg7mr3hE8rnbFVruVHdmfhrOA/eQ79MbHRllHszLi/D52GhOzo/0/sBp0T97+YzCsuIjVt0FXOO ae+cJfCN4SeicwhsT61CMI/RbKp1/Qt0xP0LkXdC8zVG+Vnl7T8iuSfQBXxB4w3N5jqaEidPkwMV d2FzMfxttDkPH35H5aJ5jtaeY4byl/pLr1s+y7n0K/gl+rdssOjSa/B3gOX6V3Lv6evgAvTHwxts Bs5CbuouhV+KtcXg75D8Dv4AOiK3H7ykN6LtwafBsWBP8AA4UdFnK1pnkRSBlqKThH8RXARe7/H6 V4P91D2DZBb4ALWeg8/j6WHwPBLeYg9C8jG8sd+dt1eD7/P0L+A6rDno9AeHIP/Q47UNFUiWIOkL f4labeCPgRvBN8GTaIbhz8EH4GvAZuCRmja6M6Q96Ft/VoljPNMCzFeJj177HgbfRX4Qfi24Cx3j vQdr7hcLnc1YKG/3BOeB880owBeBFvgiuKhGd6cbjP9V4vs5eIanv8byHNM7+BuN59GpQecW0xck h2nVMfjdXl/up1+5Unc8dSeoxMI/vu+iWVQTpRdzaflcWjuXtinOQnIGPInkFkXL8C3AfPAob2wF FoB3gR/xLhOBz8P/Hsyv6SU4GP4GRnaqiUmV20vh29Xo6fs9+G7IiQo7RzFApAWeVHRXY+GieiDw uPL+7Yz1IuOZSy/pXxvR/4GJDaw9Txs+Recv+OpBnZUyp5oR/4ozzShf/ERnHD0d66ENFgjeCPYE J/J0ItYmqkT8qfI+yItAy8MCXRfgX/RQNaN4e7/n+QJGYR6o/AMqd57j6Vlq3U0LTYSfpUf43/eB GRF6+qqJZ/g4Oivw0h6TPdRX7l48ZuZvHnwLPLMR/Y019+mtFPxY7Hwb/hVFh1ns9CcCz+G3WTxl NH03Iz+pPvRdoM0BvJdPj3LxUo2ixJXhtY/4yvcD0MThox4WUHcedlT/XWzu4enrIP60TtPrE+Ar 4K8v3SB4kT42QPIG/M3wBYzaQPidtPw4T5srLxmjQiT38fQJcC5P5+EBot25C97M9Hz1mH0HcjMj fgW+hOUEFhJY3ud5SXmT2XYwrzcxWz9iFMgqPhfP34sdkwl3gn+41Ek9Cb/d5EA0p6H5FZMDectu 5Mw+dxJzZyv8p5f6SjvNOrKAbPOe+sq9F74P8irsfApPJrSvAduChWbOorMV/KWXne4WZKXwbUNn hZnRIBnAfgEv9UBnL2jyBnFrsy6IV+VM4TD3fa+Bo0GTK1qDPwK/jXwMfC8wSwQ+hfx1by3QeJ7i 8eoBs3YMR58cYpeaNYXRDOD/ZuAs8F1wLUg+973BeF2Cfws8T91dZrzg8aTvY/gkGMVL1fCNeLoO vj84pKZaW4j8Q2zOBJeAi735a96lkb+VyK9mRgwB+yLfCN8V/clYY93xbebtNcQGK6OPTO40R3Md 0QLvqyYb74NfjHwovMmrjH6gkohqDH6PDMP+JNASayYjDaG1b156Wf/GhIVLNT+gv4K+LeB58vAg MskS8BE0z5OHG9IXs07leXm1gNjWzNAdSXe8152sUo28EX5Y56HmXgfN/h6qhQqeLvGwgHVnJD4s oJ2alwp4ugN8k7oDuWM8yx1+C24aWwR+IZoNvW/X6LdTuvKdnIvcLd+h33L0vatoV/L3382cPbmh 8v3e1W/mbOBExl9b7N6Ba3Wm8xecncrb78B/4h7grMrfvHR/bg2zW+m46I2E08bN6Nvdn+geQ3m7 yv2TRqOi84m7yNL7JdG0Dir60tTqp+iv5E4jAHZwJ+jcxEKFK/teZzgWLujTwGBqDQI78/2Ec2Cu m68j7nxHPeZsUh3l7Un6X7jYIxWdMucQ1kTT2qboKzS1kOxRdE8pSi8UFzg/1F5gp7feKthbjB2e DlX0T8HCOfAQOA1c7uh9ThtFe62jp/sCPdfb55A08Q+jnfotsoYqsfYobx1UFH3lt6m+vzt2CqjV 0dHv77Vy5ujoOwto22K906bWcrAbktaq719PraNeS/TpUCTznPGabZD38FC/R+R61haol2jbSuV9 h2mPY/sU/Wf1V2/gbdtWiW89T/UbyJ18R/jGrH6rbaA9TbC93rrYa+3nNOva39eW2z/Vea28/Yz9 jOBEW/+6bau+bxY4SNF5DJ0Xbb7raM8UvNN5VvAN+HbOa9gR3ncGTeraD1D3OfgbsHZGo9T3H7z9 vH2DzmVbo2Ko3Yx2Ntb4t/krvx0Qyf32dTqX7dt1Lqu+Lwo+qGj9WdFxsNAPa0Ps5poz7XexqXy1 /aGuGvCL0QxjoYa6X4Y/Br7jUw+voA0nfF8RzQ4+veGUvCiSCz79K/NF31ldC+yOmlftSfzVXn9Z 9qTvsLZH0Xe/3VQl9ipduXy/1zUXbAF2UBRrgtaH8DPBJr5DaB7SmQ5/0DdeVxNsvutbKPiC77e6 HmlLrI+w8GdtiX3BsvRb6O5pxUAe/H/CN+Lb6dfCfxX5z5GIHfdfA2LTHQb2Bk8pOsfBJYr+hsgv KNou+EMkrdH5pmJgP5ptwDBPC+FL4YeieQwJcneaYk5L+Nt5+jZ4Fglvcf4dPgE/CRyIZAo4TtFH a+0ePP0V/GHaE0BnFljJ083wb8D/ERwA/iNyeuRcpK6xtgP8HpgB30OzMzz9cv6LN34LfhPt2Qee QPITrMWp1RXN7chvgV8K/wo+WQX/JPgqeAe1/jVHVp/ATWZ0lHdPgZfMGCnvb4jkAvx9ZoyQPG9G Snnnm2ApWIa1R8x4USvHjBo8Pgl8bEYN/SXgMZ4WKua0RPI2bbsTzelg1viHt3+NFm4wPlGJrInK G4/hZ3cB2J034m3fn3iKJ+21WCDq/C+AW9CfD+4BIyC9dk2kvUI7J6J/GxbwuT9IG4gfuxWxdw36 R9H5GXxPNE2M9QKDirk/07q5X6KdDjp9sfBLMA/5TfS6NZ7Zjv6LPGWOuHupdSvvwrfOC2be4cP9 1MW37jTwduz8Ap2O2Mef9v3UXYGcWeY3sZrmXWYmtjSxh51fw6NpP0utk+j8C2giBO85o00k895b 8NVSRd+fkLzEu0wc3g3eCz5I3V3wnbBQBH4E/gX5M7wrBv917NAvP2/3d0FzBnbmwON5m/zgLgTH gkPQMW/8DWgi5C2ePgYyLk5z3vhPIJ7PQeKe4Y3jkZucxhx0zexm5vqvQ9IEJDM4RIWDNdtkKrKK fRp96rpjwNfBCuQmN8I77yLZCn+ItxNXDnPH/oRaRJ3fzCbTo3XoNED/ZSRm3NcjHwTmg7TZIWcG yrFpWkVUuL8FmVPu/2HvO6CsKLZ2d1V1nzrT3acYcEAYguQszMA4kkRBQJKIiIIkJQcHRBgGRARE kCACAiKSRZKImFCRJBKGIEkk55xzEgdm5lV9p/Uyo+9d7+/9//XWe3edtb7evWtXddVXu2pX1+nT B77BUPPAAOR6DfYpkDESrX7APdCjTwX4t1tAjznKwqxlwR84ZnWrA3AJ7G/AZwbCf8Lz1Xwg5iIb 40i8CU145ryEvOE+Rb8L9FQAviSaAzHWxBggvFduMRiEV9iIXza8PQC2JdoeQKoFe4E5SlQEPmWu TmTuQawP08y3Rc2ANYAXDIozwE8N2h70dw1yC/gONMVh09JgYDcsSwLrI7Ug5DaQm8LyFDTQWyMM ynyQiyH1e+ANaHAV8SPk9pAHAhtCMwjYxyBDbXlVpG6AfAT1CcDmXeB8pK6F/AXki8CngM9DjxaJ VOQNl7YJ+CawM3AnLOMgo13iDq74CuQ1qM8u4DloPkJp7ZCrAiw3Ql8A8kLIU8HJYsi9gdOBJZA3 N/Kmw+YxyGOR2h1yK+glEG0JXAaWRepIYBfg48i1EtfNgxqGa472WjOBVZAXrWZXkYoW8WXIi963 xwOTYT8DuB34JDBcw3CPh9vVH1gEJaDttkKZ6EdeFD4QAfsTsPkE8qOwDPd1dSByBZEazI56Ctg8 gRK+BUYh9T3I8ExrB2wKo2QwI1B/8RVSY1AOmOHVoF8EPbzXDvtAJ5QW9vCwr26GHjZ8ODTnkToO iN7h4EH0AE5GaeF+fAhYGfg0UrdBLo9c5YCngb9C/xbKbAv5GZSDmtu4ih0Py1EoZyJkcMUxsqxZ wCTgs7AJX/FnYLhPlyL1JSCYFLlwxZeBYE9CY13HFftCH54N4L1WeFzA5+0s0GQDYkwJ9KNAaTw8 xjEe+RXYI6+VCPwYOA/68KwCWWyFZh3kQ7g6PEHAw/k15IKf2GGfD7doOWwc2E+BJtyzK6BvBIwG os4Cs01gGMoM1wr9bu0HYhRY6H2GmgcGINdrsE+BjLFj9QPugR59KsC/3QJ6jG4LnsAxE1odgEtg A6+2wjPJJcjhnkJvCvAfgIeI5kD4vBgDhO/JLfB/9LWN+dyGrwbAoUSLAki1YC8wP4iKBmk/30tm V2SLTi0c3scQo7SmNu67O5jdBjETOwl1kDrN/DZW5DfPp4mJ2EvhRsPPQj/K6M0DFmR+bWE0LQza 2w1aZaC/gbzdkXrGYKAH5A7A2ijtUtgS123q72YUJrNHYe4Np0EzxN/xKIPf1pldlLrYP0nBfkgU 9kYWQD/L5OXboOmA1AmQOUq4BEwCzkPbPYN8IBhobHZIeDJ2LeIgx4lvTV5jQ+nYr7jP3z/RSEeN jV0O5TRCrhrYIalkNOw+a4rW5/D3RhZgD2QB9kM0po1NN/tUDdO3mLkXclNzb8u3GZnVhNwMqTUg L4e8B5b9IAchV0LqauQ6B022cGnQHEszd/qlYZMNuWKAbZC6K4xIjYacgtQPUEJh6GdDHw+5JFID kDtCHhqug5HZ3nAdkNrHyGmN0m9pTygKzZeUS+M+yNOMLLLgXj7doKgKvAZNCuSJsDxs0N5u0GLQ c+ACpAYNshuQLwFjYE+wGQUsCRyM1CTUYTzkNpDn4YrnYdMX8nqkJqAcB+WvAs7ya25q0gWaxdAs A44AoqWiNlIVNAPTluJf2E3JK9LMTmB+lNzNr4PRHzB9JKoapAPIuxA4BqVhx4OfgKaxsbGKppln 1R5FarW0uRrTqL7WR8Im1mj4lXCdUfJMU4dAXmiWG5mNgb5R2hfGP429tQapu0yqbrvpHQ8lN4I+ J8ocjfrnTk/R9RyE2t5E3faZXHZ3tOUU9DPgdf1NLhaPa/WFXBDlxKTdxTcIdw2fwBEG9WrK4BFo 8sDmFORsBsXjqFUcei0Z1+qDkjughkcMBixwWzzsIenPGq8zNjyb0Zj37+gZEqPMijRtCeSE/Skj 27Vg40HTLOyHYDsPruKBmWyGMfYWWt00zezNJqCG8yA7aU2Mj6WZ3c77gA1w9WSwURNyG2PJbiBX DORbsExGCWMgj4R+F9jYBH1RaK4j9V1o9qG0d6F5FJaXDeoZB/0V9kPUvz7achR1OAJPCHvyeNNq fRdwCCyh34ED0VM3YJ+GEsrgWpWQGgP/OQJ9BYN6fjf9Use3MXgCPrAdJW8L8++zYWpeA205Aq5y QB8CNoVlgn/duxgXd+F71+AJYUvDWz4ja9++Bk82Nq2AY6BpAstoXCsalluQKxk2k4CLkdrAH7/l dFsCqPMitHEz9HmA36M+ncKWaG+3cKuNpfYi7FrDowI+qzPh1WDDMMM6oeQJmAdWgL1V/rVMOeXQ UznCMxVyXUKuVbBMg7fHwHIRPDPKyIGClAWethQ9buo/JTyi/TFiSmuBPioMfBE1vODPeLkQa8xV NvljdqJO/Tw8lk1peracgFqVQ67wvGpKHoxd4kvUDn7VzsT09Ke1/By87hxsMA+I8DgaibwN+I/w /KXoTdPGleG5EZYDoG8M5scb1PPSUswVZlYJ98g8YBCp+dHq6mjvIeAo4F2UXAP99RiwILCub2Nm uf5+P5qZbZyZM7U/LMVomguvuItvcu/CV+/Cn++iL4x8G7wN9KNYLmhMqyehpVXCUQxzziX0zjKD El4kEWXEGVi2AyLG0RXjh3oNfBBz4DXMgWaGaYx6VoKXxsCHt8GrMRdpy5mwNPafQZ8Ay9qQ60E/ CzXfBXkB9LXSdgC7Y/RdM2tyc5W0ienH0F+NzGhFnz6JdhUMx7W01fi+PrupLWo+CG3JD8tGaVjz IG8eyqfLjPZ7Vsupn5qSifCeN7LM73T8nUaD5EDvGD2R0aQ1N09ZpzUzT8Kn4fcgaQ7kWMixkMub 57TT4syz9FrfHfr5kF8wz4+ZJ/O1vBbyJcgXjGx+xaPzLjFvuYE+zjwNqMv5BO9muYn32ywzaH5H QGR+554WZX7NkRZlfg+S9mUgwbzlRr5h3nJj5NTlRk4bFBht3nIjr5jyAycMysuQ95vy5RnIdyCH bZ4Glodla2A7894bU7fUI+E6B96H/UzI4VznUOcb0BeGPtKgfAytKwO8jPYORuoioIT+YVhWx7Uu QL8RZZaDphKYCWtSkNoc9iNwxY1gKQU4AFevBstSyGssYyDHQC4XWA/9bcilUE5YXxQ1eQ5yCcjP o5zdBoMSMt7kEwwitTk0w1Had+YdOCjhYZQQCzkWcnnze3lt/xPkHMDsyFUTdS6HOrdBL09FS28i FXULzIHmBeBa4A2k3q+xrPwM8ucocwXkkbD5CjgO+kWQt0O+bmpo3sKha2v8sDy+lxep6ZDBm/km PS029aypTyr6wnzzrjXXTGrqcsNkWJM2AJgfiFwoITZ1DSyRNxWtTp0K+QTKXA15F+RLSIVHpe6F 5jTKMU/gEDlsWPAcibav9kigqI492r9E/RNaJ3ajL0nf+T3TqHp+0ncW6emUnTwKUB4qRNmoDD1E FekxqktNqKUu42l6jd6gttSZXqZeNNS3D5GkvFSY7qOyFK9LqUb1qCm10ldtRP1okJ45ulB3SqJh +I/BcB5FQT1nFKEoiqGHqTJV17Pz8/QCcXqGXqc3qT29RK9QbxpOOUjUadiwNtVt9NST+alN40b1 8tNElHI/3hn6gJ6bi+oSY6kKPU5P0JPUjF4kQSWpMfWnwdSBEqgH9aERyBNB+akYmUj3CNWgBlSK 3oY+J0VqHgpQNBXX5ZanClSValJteoqaU2td79L0LA2gIdSRulJPepVG+jXISi4VpNxUQpcQR49S LapDDakFtSGbHqTnaCC9RZ2oGyVSX/Mu07blerYVzwFbATsAuwGTgP3btk5IFG8BxwAnAWcBFwIX t23ds71YBVwP3ALcAdwHPNK2bdfu4hTwhkGLAyOB+YClgZXaJXTuaNUC1gc2atft5a5WU2ArYDtg F2B3YBKwX4cerdtag4AjgROAM4DzgYuAK3TBra31wC3AHcB9Cd16dbWOAE8BLwCvAW8D0wzaVsLL bRNsBxgJzAnMpxN72IWBJYExwHhgFWB1YO2XTTkNgI2BzYAvAjsAE4A9Xu7RrpvdB9gfOLi70Y8A jgFOAE4BzgTOAy7sqfvIXgRcAlwFXA/cAtzVs3O3DvYB4DHgGeAl4A1gSs+ubbsHCOgAo4D5gMWB 5Xr2jIkNVAHWANYHNga2ALbTWC6QAEwE9gMOBo4EjtdYPjAFOAu4ALgIuAy4RmNcYBNwO3AP8BDw BPBcz15tegauAG8B7xqUHBgEqp69uveUUcBoYH5gUWBpYLlEzaSsAKwKrAGsC2wIfA5oVuNczz1R /8JR6HGem/L8lySGF4f+n9HWM4atZ1FJwX/bmYWzsMz0rJcZQ38RhZ7nXLxz+e9ITM/ef47Z/jJy 9AjXpZoz7PaY+GBWiX8Zs/5lzPsHjPzLmB81FTiye9C04F6d+qcodKTKQTn/Rel+SFzHp4L/0rEQ Ff6XjkWo6L9wZDqS/nP855wwHcH/OWb5SxirVxuJOuqPp1m0iNbQDjpBN5jFolhhFsdqsMasHUtk g9l4NostYmvYDnaC3eAWz8fr8758BJ/E5/MlfCPfx8/xFOGIaFFSVBJ1RTPRRfQVI8QkMV+PQXOt YNhnRYNM520ynY/MdD7qnnMrU3pAD/M9JNk9505cxnNvZsb86lbG8qOaZTzPThnLzx6V6bxoJvva mc5bZDrP1J7s+zKe5yie6bxhpvM+GeufZ0bG9LzLMp4XKZ3pvMw953r8FYnJlD4I51zPD9nCLSzW MHwsHm65pX0uh56rivrabf5xn3884R+v/Jl1yS/94zL/mOwft2esRSmVsZWllmQ8Lzsoo33ZAxnP YzdlPC/3TabzxRnPyzfOdP5cpvPumc57ZDqfcI+XaSF+YqbzJRnt4zP10h/St2Q635bpfHvGXqy4 RaPSzLRl71EHNgWzbRv9IT1SxxOzI+2siBXZKODVUclebbVGrVSrtCbALrKL2u4Ku0KMXWPXiLOb 7CYJVU1VI0s9rh7XcdP4Axc1RW1zPZ6NZ9ca8wsiZeojQjpnGX2eQ9+N9KAplExHKIVF6ToEda2i vKeJe7W9RhrreM9orKtrH6nn5Pz6biFG3/NUUWdI8Ehdp7M4Jit9p8Wz6/PzOCarXcT12R6NyWqf xvW6rcZDo6mgOqLrulKnHsUxWR3Tx1X6/DiOyfdYnvAtT/qWp3zL077lb/Wth/rWR32fRH1/S2mA lKeQ0vDeFLURNdyEGm5BDX9L2YaU7UjZgRROkuuPHmYuN09uR/JIzWp2zarwanlPaNZXqpUU0HVa pZkS2sJ8GxmO+npo6fyt0V+EnmIshaXoXktn6Zotm+t1D8q1UW4A5UoezaMpyAvyghTBi/Pi5Ija ujddu43dhjy7nd2OQnYHuwMpu5PdibLYPeweFGkn2omU1U6ykyibyq/y032qoCqo21RYFabsqqgq SjlUcaXv+VRJVZJyqtKqNOVSZVQZilYxKgbv5S5PedRD6iHKqx5WD1M+VVFVpAdUZVWZ8qtH1CNU QD2qHtW9Y/ytEPytsHpCPUFFVEvVkoqqtqotFVPtVXsqrjqqjlRCJagEKqm6qW56ouiuulNplagS 6UGVpJKojOqj+lBZ1V/1pxg1UA2kWDVYDaZyaqgaSuXVcDWc4tRINZIeUqPUKIpX76p36WE1To2j Cuo99R5VVO+r96mS+kB9QJXVZDVZ++dUNZUeUdPVdKqqPlQf0qPqI/URPaZmq9lUTc1Vc6m6+lh9 TI+rT9QnVEN9qj6lmupz9TnVUl+qL+kJtUgtotrqG/UN1VGL1WKqq5aoJVRPLVfLqT76+0n0dwPt K2voKe0rydRQrdfe8rTaqL2rkdqkvesZtUV7V2O1TXvVs2q79qrn1A7tVU3ULj1Gmqo9eow8r/bp MdJMHVKHqDneid1CXVaXqaW6qq5SK3VdXacX1E11k8x7vgfp8TFIe1IWloUGsGiWlwbin1EHs2as BQ1hCawrDcO/oY5gr7BEepuNYCNoNJvIPqAx7Cq7SmPZLXaLxrE77A6NN5MMvccDPEATuMc9ep9n 5VlpIs/Bc9AHPDfPTZN4IV6IJvMSvARN4TG8IU3libwXreC9eW9aqdcRfekH/jrvT6v4YD6Y1vCh fCit5eP5eErm7/P3aR2fxXfTehHS889dESfiKE1UFzUoXdQRdRgXU8VUJqxE60Nm2W3ttqyc3d5u z8rbHe2OLM7ubHdmD9k97Z4s3u5l92IP273t3qyC/XNgGKvoPOO0ZpedoS5jaV6kV5O/6jX3pvHP Qu1CXfj10IDQSJ6iuAqKoCqgCogsqpAqJCJVEVVEZFXFVDGRTZVQJcR9qpQqJaLUg+pBkV2VVWVF DhWrYsX9Kk7FiZwqXsWLXKqCqiCiVSVVSeRWVVQVkUdVVVVFXvWYekzkU9VVdfGAqqFqiPyqtqot CqhWqpUoaP6cWhRSHVQHUVh1Up1EEdVVdRVF1cvqZVFMvaJeEcVVL9VLlFC9VW9RUr2qXhWl1AA1 QJRWb6g3xINqiBoiyqhhapgoq0aoESJGvaPeEbFqtBotyqmxaqwor8ar8SJOTVATxENqopoo4tUk NUk8rKaoKaKCmqamiYpqhpohKqmZaqaorGapWaKKmqPmiEfUPDVPVFXz1XzxqFqgFojH1EK1UFRT X6gvRHX1lfpKPK6+Vl+LGupb9a2oqb5T34laaqlaKp5QK9QKUVv9oH4QddRqtVrUVWvVWlFPrVPr RH21QW0QT6of1Y+igdqsNoun1Fa1VTRUP6mfxNPqZ/WzaKR2qp3iGbVb7RaN1V61Vzyr9qv94jl1 WB0WTdRFdVE0VVfUFfG8uqauiWbqhrohmqtb6hfRwr+XMiufOMy1JbQ726wla6nV7Vl7Yta31rfE A6mBVBLBqsGqevT8e2Zj7bn/mY3/P5+N/+F90fC+kma1xToH9v/Hx/7jY/8mH2N2F72ej2QFeZyo ZTWlPFSJqlNdakTN9P1CF71+76vXAyNoLE2imTSfvqQltIo20nbaR8foHF3TK3tiAeZF9CER0TMi MeJVHHtF9MUxKeI1HHtHvK6PiVrqj2NixAAce0UMxDEp4g0ce0e8qY+9tN1gHBMjhuDYK+ItHJMi huLYO2K4PiZpuxE4Jka8jWOviJE4JkW8g2PviNH62FvbjcExMeJdHHtFjMUxKWIcjr0j+hHXqYM0 9ooYpjEpYpTG3n+DkffQ8p4RE3xm3veZmegz84HPzCSfmck+I1N8Rqb6jEz3GZnhM/Khz8hMn5GP fEZm+4zM8RmZ6zMyz2fkY5+RT3xGFviMfOozstBn5DOfkfG6/T0jpoGRWWBk/t9k5AufkS99Rr7y GVnkM/K1z8i3PiOLfV/5zmdmic/MUp+ZZT4zy31mVviMfO8z8oPPyCqfkdU+I2t8Rtb6jKzzGVnv M7LBZ2Sjz8iPPiOfg5Fv4CkrwUjy32Rks8/IFp+RrT4j23xGfvIZ+dlnZIfPyE6fkV0+I7t9Rvb6 jOzzGdnv+8oBn5mDPjOHfGYO+8wc8Zk56jNy3GfkhM/ISZ+RUz4jp31GNoGR7WBkDzzl2N9k5KzP yDmfkfM+Ixd8Ri76jFz2GbniM3LVZ+Saz8h1n5GbPiO3fEZ+8Rm57TPyq8/IHZ+Ruz4jqT4jab6v pIeZcSjMjMPCzDg8zIwjfGbOgJFLYOQGGEkxnmL+p9HUG7tpTakE286ni/riKdFBdBRdxEuip+gl eotXxetimBguRoi3xUjxjr53OSaOixPipDglTosz4qw4J86LC+KiuCQuiyviqrgmrosb4mYo3vyP EtvGtukLTDO/zhX1RD3iooFoQEK0E+3JEp1EZwqIHqIHBUWiSKQIkSSS9Eqgj+hDrugn+pEn+os3 KSQmi8l0n1giNlNU6KHQQ9hliCbHymc9YOW3ClgFrUJWYauIVdQqZlqma3QTu+uMct6zN1EK+0EJ xkLnLOZb5LnHovQ9aZpJkaCtyYqyzLvAilvFyfWvG2Vlt3JY91s5rVxWtHn3nbb4x3U5FaYsVjbr Psu2Apa0glaE5Viu5VkhS1lZrEjL7HdZum0DdBVMHm49YlUlz6pmVSOl0+Ipp5gj5okF4jOxRqwV yWKdWC82iI3iR7FJbP4zxs1umZgtZusS55rfNYtPxCea74VCz6OaudX6esfE+d9Ln62tPtGpS8RS sUwsFyvE92Kl+EGsEqv/rI9R+hwxR5c+T8wzT2SKBbr0z4SenXUNN+vSTTtM6WUo6k9L/ZN2gLNj Pmcm31/0LuQz3qDz2d34InqTBtMQeouG0jAarsf12zQS/y46msbQu3qUj6Px9B5NoPdpIn2gx/xk mkJTaRpNpxn0oZ4BPqJZNJvm0FyaRx/r+eATWkCf0kL6jD6nL/Ts8BUtoq/pG/qWFtN3eq5YSsto Oa2g72kl/aBnjtW0htZSMq2j9bRBzyM/0ibaTFtoK22jn/Ss8jPtoJ20i3bTHtqr55j9dIAO0iE6 TEfoqJ5xjtMJOkmn6DSdobN6/jlPF+giXaLLdIWu6tnoOt2gm3SLfqHb9Cul0B26S6mURunaoRl/ mjfiz/DG/Fn+HG/Cm/LneTPenLfgLXkr/gJ/kbfmbXhb3o635x14R96Jd+Zd+Es8gXfl3fjLvDt/ hc/ge/hevo/v5wf4QX6IH+ZH+FF+jB/nJ/hJfoqf5mf4WX6On+cXhMMv8kvC5Zf5FX6VX+PX+Q1+ k9/iv/Db/Feewu/wuzyVp/F0PQWZp+2FsIQtAkKKoIgQT4tG4hnRWLQQLcWLorXoKl4Rg8UQ8ZYY KsaJD8QU8bn4QnwlFonF4juxRWwV28RPYrv4WewQO8UusVvsEXvFPrFfHBAHxSFxWBwRR63KVhXz v63WDmuntcvabe2x9lr7rP3WAeugdcg6bB2xjlrHrOPWCeukdco6bZ2xzlrnrPPWBeuidcm6bF2x rlrXrOvWDeumdcv6xbpt/WqlWHesu1aqlWal2yE7m6wmq8vHZQ1ZU9aST8jaso6sK+vJ+vJJ2UA+ JRvKp2Uj+YxsLJ+Vz8kmsql8XjaTzWUL2VK2ki/IF2Vr2Ua21Z/2+tNRfzrLLvIlmSC7ym7yZdld viJ7yJ4yUfaSSbK37CNflX31p598XfaXA+RA+YYcJN+Ug+UQ+ZYcKofJ4XKEfFuOlO/IUXK0HCPf lWPlODlevicnyPflRPmBnCQnyylyqpwmp8sZ8kM5U34kZ8lP5AL5qVwoP5Ofyy/kl/IruUh+Lb8x //0qv5NL5FK5TC6XK+T3cqX8Qa6Sq+UauVYmy3VyvdwgN8of5Sa5WW6RW+U2+ZPcLn+WO+ROuUvu lnvkXrlP7pcH5EF5SB6WR+RReUwelyfkSXlKnpZn5Fl5Tp6XF+RFeUlellfkVXlN3pa/yhR5R96V qTJNpgcpyORsOUfOlfPkx3K+vC5vyJvylvzF6eO86vR1XnP6Oa87/Z0BzkDnDWeQ86Yz2BnivOW+ 5vZzX3f7uwPcge4b7iD3TXew+5Y71B3mDndHuG+7I9133FHuaHeMO8md7E5xp7rT3OnuDPdDd6b7 kTvLne3Ocee689yP3fnuJ+6n7kL3M/dz9wv3S/crd5H7tfu9u9L9wV3lrnbXuGvdZHej+6O72d3i bnW3uT+5292f3R3uTneXu8c96h53T7qn3bPuefeye9W97t5wb7q33F/c2+6vbop7x73rprnpHnnM 457wLM/2At5x74R30jvlnfbOeGe9c95574J30bvkXfaueFe9a95174Z307vl/eLd9n71Urw73l0v 1Uvz0kMUYiEeEiErZIcCIRkKhiJCTsgNeaFQSIWyhCJDWUPZQveFokLZQzlC94dyhnKFokO5Q3lC eUP5Qg+E8ocKhAqGCoUKh4qEioYmh6aEpoamhaaHZoQ+DM0MfRSaFZodmhOaG5qHb5+xI4ud0QF8 OtczKPY7PxR1dXzfKZ7U8X23aCaa017RSrxA+xFDD4ruojsd0hHvDTosxoqxdFxMFBPpBCL7ScSt U4hbpxG3ziBunRXfiG/pHCLEBauiVYkR9k257dgOi7Ej7UgWi53RcoGjgVPsjIyRcewSdkmvO0Od yZw7s53v+f3OBuc2L4e90jbYJZ2jo/01itCrg4I65jfQK6BJOgKs0LOzvoQ7hLjaAGkBJPMdTSTl oDzuOn2+212vca+7QeN+d9Pvtru19AMF9VoiJ+XTK4CS4W+P3L1G7+7X+KN7UONm97DGre5Fk1Nl NyWqHKZEdb8pEWWlotTfvqOJ0GdrlaNxnXIzpGRBSiRSsmZIyYmUXEiJRgqnCN1rMbrvKnDzb0mV eWXivBavRYLX4XXI4k/xp8h2xjnjKOB863xL0rniXNHlcXse/+m/KcZmjLD/b8fX/5kIa2LoX42b /50xM5tsJzvITvI1HYFM5KypY2Z9RLOndWQahTjZVMdIEx3DsbH9X4yK/f5JPPxjNPxAx8F/RMB7 o8v/bdHw92in4+JEHb/vjYrV9OrDrD3CKw+z7mioVx6/+uuOO3rV8bxecUzDmmO6XnGkaK99Tnvq C8Yvf4udvGvGuOlFelm9bN59XpSX3cvh3e/l9HJ50V5uL4+X18vnPeDl9wp4Bb1CXmGviFfUK+YV 90p4Jf802g7583irIpSj3L8UdRf8Me6qLCpSZf1D9F3nrnc3IAZv+tMovFvH4b3ufvege/i3eKxy qPsRky/+b6Ny6h/jssqpcqno/1J0zhCbvdT/gejcgHGWXd/KRrPiFMUassZUCN+UFmetWHsqxTqy jlSedWadKY69xLrSQ+xl1pcqsH7sParBJrGp1Ip9zbZSG96DJ9LrPIm/TgP5AP4GDeNv8qH0Nh/O 36ExfDQfS+/hO88P+ASuZ3vc408TnshG00WUiKI5IocoSXNFaVGWlolYUYNWIuLvQMTfibu3XdZM ayuds7PaWVlO+5Z9i+Wyb9u3WbSdYqew3AFNF8sTGB54h+UNjA6MYwUD7wUmsmKBSYGprFRgemA+ KxtYEFjEKge+CSSzGoH1gW3s2cCuwC7WKrA3sJ+9EDgYOMza6LVBKmsfSNdrg0EyXlZmi+Uj8lG2 IlgiWJL9ECwdLMtWB2ODsWxdMD4Yz9YHKwYrsg3m+zO2MfhY8DH2Y7B6sDrbFKwVrMU2B+sE67At wfrB+mxrsHGwMdsWbBJswn4KNgs2Y9uDLwTbsp+DnYOd2Z4IfdvP9jptnLZsn9Pe6cQOOF2cRHbE SXKS2HkdZyezCzrOfs9u6jh7m6W53G3OpdvS7ctbe9O9Y3xA6J3QJL46/HyLvhtdiG9cWrIOvuab ezSMKlHAX3sU1WuaOJ0+W38MLtSrgtk4mrPl/tlyfXZQf8xTNqVYKe01ZVgZHe4qsAq6zCfYEzq4 1GP1yGIT2UQ8ZbOeWtvRdm47j53Xzmc/YOe3C9gF7UJ2YbuIXdQuZhe3S9gl7VJ2aftBu4xd1o6x Y+1ydnn2M9vBdrJdbDfbw/ayfWw/O8AOskPsMDvCjrJj7Dg7wU6yU+w0O8POsnPsPLtgCcsSt8Qv 4rb4VaSIO+KuSBVpIv3v6CzdFItjp8HCrxWy4tusnPojKI/+WJq5Yrqlpck8l1ZWf4Ka1Up6nVhF fxyqqj8u1aCa5FE9/VHURH+y0PPUTK8PW+lPNmqnP/dRJ/2Jop6USNnpVepL99MA/cmlRyenaJaF RVJuPUajKS/Lx/JRPjzT8IAerw0pvx6vzagAvtUtiJFaiCWwBCqMpxyKsF4siYqy19nrekwPZ8Op BHubjaSSbAwbQ6X1CJ5ED+oR/DWVYSvZD1SWJbN1FMs2sU1UHvtNcRh58VhT18WuUyvsOr2IvbDo e/bCHsTTVJV5C81YXh7LY/XKMZ7Hm9+I8Ro6pS6vq1eOjXgjvXJswpuQrdc/7SmgVz4v6ZXjMGcE BZ2RzhhynTnOXIp0PnYWUDZnl7Obcjh7nQOU0znsHNdr6n5ufyqgo8hgKmwiBJXQEeJDKmXmcyqr 5/NdFKtn8YP0kJ7JD1O8nsuP08N6Pj9JFfQ91mmqqOf0s1RJz+vnqbKe2y/qvsrcljJoSx3eRbcl X4a2VOQVdYppkeAN9T2NhRbZaFFAr/OakUS7gnoV9wpFoF0O2hVCu7KhXVHOQudz3aIvnW8oN9qY H20s6Jx2zlJR57xzWbfLtLQMWhqLlsajpRV0HJyt7xPm6ruNR9Hqmmj1Ezo+3aJ6Ojql6juU8Lev 5leO7dCisqaN5k17VMlvY1nfprgevWPYhN91nM1nn+uzqN/t9Aj4Ew6qcM0bmLDQtzb4CIAPCT6C 4CNCr3tbkgNWXPS2B25CzvPO86T0nXl/yqLvvsbqPh/vTKY8+h7sGyrsLHa+p3h9J3aZqjpXnf/V 3nmARZFse7yrZwaGmaHJEkWyRO0hJ0GiiggIKCaULCACAoIBiYJZDIjKogLmAAZUUETAgKAYcNes mNeMAiZE4VUfUdF13953371vv/d9l/qoU90z01NVp/pfv9Pd0/2eCMUMMY+YimlhGTEL08EuIgPP /QeIVXiuv0asA59XgM8P4Rn8LnEYPF8Jnj8Cnq8Czx8Fz1eD52vwzP6SqMWzeytxDM/wn4jjeD4X Ic5hxlEgLmOuUSeaMcvoE79jKuETLZgupIhWPMcr4QgAKyGOkKYRBBNBEo7MUQZiJHO1DeHDny1w Ic7hz/RFa//h98HdLv9N7/46Hogg8CoNY96r13igv40Hwpew+7qOJFzh3L3s1/eRBItXwNuEv7OG V4/HeAef2XPwWojyP9dEHepA99TyS12tsZr9E+qOPykHWkiAFiLQQhZoIRu0kANaKAJaKApayAUt FAMt5IEW8kELBaCFFGihBGihJGihNGihDGihLGihHGihPGgh89vmY7gFAnIo6zAx+C/PBZGIh6Rx LTWQPjJG1sgRuSFvXLsgFIliUSLmpww0Hy1FufhbC9EWtAvtQxXoKDqBTqMLuG9u4n54jFrQa/QB T0AipICUJhVIVVKL1Md9bI70cet1cV8YgR2HZ2DG+iMrsBORNdhJyAZsALIFG4gGgQ1CdmCDkT3Y EDQYbChyABuGnMFGIFewUXhWZ2wM8gSbz5FnLPsgRwFsOUeRsVQnl89YjgxXwFiRTVxxsFVcCuxR rgTYT1xJsF1cKbDdXGnGYoKSAWsvgeB7IpEeViMJzBokXjLE+ThMHAy/YE3CrcQjEbdRiPMAZIzz QGSC8yCEWQa3zQznIcgc56HIAudhyJG5/gQ54XwKcsF5FGYWErdqKM5j0TCcT0NuOI9D7jjPRyNw XoA8cP4LR5YgcXvlcF7OYY6+dHKxY3BL8ajG7WTjvIqLmQe3UYS5ooorivMuLhfn3VwxgsRtwwTG tSf08L41Ac/5UXiuTybmEouJXKKA2ETsIvYTR4gTRCPxG3GTeEA8x/rSc04RjyQFPNa18FiikTmy xaNpKPJAvrg3AnCrotAO3Fv5uId2gvVHu8BORCVgJ6FSsAFoN9ggrO6MDUZ7wQaifWBDUBnYULQf bBi3L2NxG1UZi1vZD2wVVw3sUa462E9cDbBdXE2w3VwtxuIWa4O1R+vBfxvAc4XguSLwXDF4biP4 bBP4bDN4cQt4bit4bht4bjvjD64s9Lgc9Hgf6HF56HEF6HFF6HEl6HFl6HEV6HFEsCUIuLKcBVpB wJ6OJJifiTB3E/aA6/p1CWPgADgahvrAWJOHMaLAfDezFaT4tRTOjCRGe7Ge5MFYgZw5S4cksUIR SA7HVQiUiAR9YeZVBWIBGoX80Fg0Bo1G4bwxeAYc9/nYNDmdTCHnk6tY+aztrH3UR+oT1UV1Y5Vd x1vP28Ar5BXxinkbeZuw4tbyjvGO807wTvLqeKd49dQ7iqRYFJviUCKUKMXldfA+8Dp5H3mfeF28 bj6WPf5y/gr+Sn4ufxU/j7+av4a/ln+QX86v4B/iH+ZX8o/wq/hH+df5N/nN/Dv8e/wH/N/5j/lP +c/5LfxX/DaBqIArEBPwBHyBQCAuoAQSAgOBocBIMEAwUEALhAJjgYnAVGAmMBdYCCwFVgJrgY3A VjBIYCewFwwWOAgcBU4CZ4ELJaDEKYqSpmQoWeo91UF9oJQpFYo5D6oDkScB0SYHU9dwPKdFklGY HBJwVCkg5+CoUhyum6UghpSAyFASjv9Ksfay9hLSIrtF9hAyIuUi5YScyDuRd5gZcbxEyDPxEmar Zt5DQo+JmjBJzcf8YM0vweTghCP+a4Q7jvpvECOAHzyAHzyBH7yAH0YCP3gDP/gAP/gCP4wCfhgN /OAH/DCG34XJYaxAEtNCENDCHKCFNEoO00ImbudhYtw/4tF/zoP/Fj998RAPepOA3hSDfpSGflSG ftSClhtBy82h5SOh5b7ASX6fo08OPG0Ql90I5tiyI6Hae/z/OIr/fDx+Hjt4C1IwUggYKSzwsAj4 kwJ/SoA/JcGfUuBPafCnDPhTFvwpB/7sA/6UB38qgD8VwZ9K2G/yhHJP7fkcqlftKcy8PXsss8/D OCVgnCIYpySMU1bPZwUciV6fVcBU8lUFvuzpoBywF8BI5sBIFoWRzP0cSaNW9BZ19tCAFNmHVCY1 ST3WME4wJ5QzmRPBiedM5yRR6pQmpU31p/QoA8qIGkgJKVPKnLKkrClbyo4aTDlSztRQaiIVQoVR 4dRUKoaaRk2nkqiZVCqVTmVR86mF1BIqh1pB5VJ51Boqnyqg1lOFVDG1idpCbaN2ULuoUmovVUYd oMqpQ1QldZSqpY5TJ6lTVAN1hjpLnaeaqF+pS9QV6hp1g7pNvaBeUW3Ua+rtf37p8Z/rPv9lv/SQ xMwfxpGhOvGcb/8PXdeO90QUKXKz11XIXOYqna/X+Pw31+l8vcIHb4McRE7sdaSDWTMcK9DX4wXo NfEOM7oZaYnf4YTXeZIjydHkWHICGYK1Khar3hzmvNrPEnMurXfCW/k+Wf4xMWfeeifmPN1Pk9MP yZU5i/dd8vxjYs7o9U64LX+S8HzwXcJt/j6N/VnC88d3CffS92kipG/LIT+kyThF/kmK/Vnid32f 8Kz1fVL8IWl8n3ra97m+sIX/HB/5k+MjiGjG86ctnuuHYsr2hXuxfLkDC3M3loXEMiIPRz/FxDai FMc/h4kaog5HQBeJq7j/aDjf/D/NLf+p3POfyX96FOTzMRIBNnlM3EM4MLEAnuv6QPTAnGdBSA/H 0SSe7Vfhch5ajctrEPME8fU48iLRAfSSuQstasXxShs8h+MNeovL71AHzJmduPwRdeFyN8k8BYUk 2XjMcUgRXBYlmTu38kkcf5Pi8EwRSRLH2KQ0KYvLcmQfXJZnnhGC51VlXFYh1XFZg8SRG6nFPH0E z7F6uKxP6uOyAWmAy4akIcE8VcUIlweQzNOAfiF/weUCsgCX15HrcHk9awjcSXYYwWK5cWSYe9Vx cHs5ShwX5u6KnCEEizOUE8jcK5wTgcuRzJOJ8VydhMszmLtWcbI4WbiczakhmKcs1+LyMS5WZi6J o0iSqyM2hUBiUWKY9MSmim8nkPgOcRz1iu8Ur8XlY+IncbkOkyqiVDFnsDBNdkOEh1VZgpRQ//w7 a/AMSQT1/Dr4G4MgYBAEDIJ6/YoVAYMgYBAEDIKAQRD89gQBgyBgEAQMgoBBEDAIAgZBwCCfa0gC iSAgEQQkgoBEEJAIAhJBQCIISAQBiSAgEQQkgoBEEJAIAhJBQCIISAQBiSAgEQQkgoBEEJAIAhJB QCIISAQBiSAgEQQkgoBEEJAIAhJBQCIISAQBiSAgEQQkgoBEEJAIAhJBQCIISAQBiSAgEQQkgoBE EJAIAhJBQCIISAQBiSAgEQQkgoBEEJAIAhJBQCIISAQBiSAgEQQkgoBEEJAIAhJBQCIISAQBiSAg EQQkgoBEEJAIAhJBQCIISAQBiSAgEQQkgoBEEJAIAhL5co+Sr3csUY7HVhbWEspT6AzlySJi+tlD s9+JI1GyMEN5DF7lSyIk5NNiIhwDikUqcQg6UIRnIILYKMOCROxCH3okbdhrjUqxapoKnFKyJTyJ ICKeiMEiGkok4H/mFJMdrd5rY2zZ/qIbPS3bjRY8cUQK054tvP7EqfJCYUYffTqDLU1nkB8KWSQi sTjUEotsbedLNdm9DX5+ezAt/rWmiI3rFCs0oPVEWKPYfBkNp5jYmXERk8MT1HSD9dSEVlYWaiMi guNi4mPCEtScYuJiBwhVaZXPb5b7/pWYuMCEiJhooTrdj3mdJaPw7XXvmJgENYfpCeExcREJM2lV eXErC1oopGkLGv+Nkxc3poXGJsKexb+hRhlIo3e3ME+qysCygtfzyAyEiO1kVW3s7zZtHsq6G1bP mEg/Ld6+RHvS+65V7hvLu9YVq9kljyz+pTgnwHhKk2PIzJZdiQ2+19ueFWSr5GyYG1Z2csqsIM3L fW2bJdCKx3knqo3C8vPDddZesDasFhwYo1Pr+ohnZ5lnuF3XatvzYZmO9+dKVOZHjQrclZFcFGCU 5P5k7f4Qm3wvFSFXS3bD9kfLDRR+H7QmWDZgDCd0Q18L73nvtr7MJeuUf60e5VK2IK3a+rlvrkfp p62zpiZ47FZozBPTVSf8lgVEWFQOlxa1Hd09vnNTGI+75WL6aL+XB20m9klPYl9/e7Q0bVXXnrOp l7cqxU2wPX3kFXejBl0mktVQppYkk3WbZOGBvzF9G52+mU4vxr3ZF7HT8+n01WmS4y/EvoyIW685 MkV234il3WeK4v7v/ZfxF2Ocxfhw1WN+zZL21QpmLyqQ1tUkqfYJAcYb1vPP2HGWz89psP5dve2V 30rDA4VD6oNefrzSaGMzbru5b0SX1lT7hsYdzZzkW8IlgzZIxkZWdkl7KkTUfLzgdF9qnJrn06DZ u3co1htYaBsdDS2SXqgtEbzxna9Kh3rDZbl2713RTsainzLk3z+cHCU+8m1Vq/epqkcn6I9qQrH5 fVfpKY241Jfc3Jp2h7V//Ou9t+r9WkKHnfL2PbifpSvdvezyK25OSsXqkzstDB/MerAt6X5iIXEh 0r72ovnCOw7S28wilSNvmN39TYX9YJsLu36ciWX0CBXxoHJe8eJfL/nau55VGbUl9oa09byV0zds vViIVSGAzmC5f1YF3oCdUje9uiesO1PzRVP6/l1igPd7S2P8hxXAGIuB0Bgvmn0Rg5mgoHgjIjLk KB+hDC3FLHBleH6B8eER0ZMT8NdI0hSzUlRG1Ds0ZGpMdMiXivH+rGKatPrniin1fj0kVM0nYnI0 3qqal5PDX6pC+cw5l/3LXKy2me4SXu/QNhuWVNPZb/0pl2kvm1wf/7b4+BR376DXa8njI64Oixqo ZRdafU6znD+0PHX6LZeqHTmU10ltg7bCR+Ka/ZoctD4ErT2v6LJ5pVu/tWfLBmocdzNKjrkmp2qz 2ErS6laV3uswGyNk3N3Vf+iWA1FoXkHn4X3BqRkdEwrT52Yt3dNWkbvxvOUWryz5/vM8btFviUGv 6zoGpR/NfhFltXWA6dv9A3bz5gQtnxFWsCZePHt324l2tUOe0kuCzxheM3ZRbKl0y7Px8lE4FzZy 5o6SefWj7TZkeM2P5uw1q52tVeUdNmitR6NBikn03CEiTesvuGWT0dnEppp5t316VOEDnf6OlmFE QZstoHkiXDyhcTiiLNb/D6mQYOoowzx2kkOzsKH7Misodh+2bGPfc4lE7PjdrddPeOSPdB6w0Tn4 Fc1nXpZgs/FulN1r1wGNmb2zNMVNp+3cEY+E4jH9E/Snl2V/2umeO4MY8eT0M4WbESep4uR20qnu 9LzG9z6NxzZUjY55Fey83ZloyavPv6RSwd+gKJ575bpqid6cly+2xO/KabZaOmhN5BHLqRfn79b8 dPvJ5Qix5fOruu4Slabt75I7JKUHcJ7p5a10nKI7rdwy546oeIN/+NmqNIcpYdsqyyuXmp5uY0km z3pz8Y7j7dldd+/u6np7+5J4WezlFfc9D1oWJxv9NuiGKT/IgtyQHqm54O2E4Jw94yqtrgQsHjVX yeSNzZrCDEHxpEVlhuVFm8/svK52sJpWzFKTFdc/4v3a4c5E+v4K3Yh5tbH32rfuPJfmGJdIYY2J xBrj3aMxgRIzRgAhsXrvRxysM3/jXv1FcExoGiuOCRYc2oo2ZhZNmEU64d9StZ7XWX/y+l9qTfEN 3pLzx2qH/XJ2h7VpiebYKTeijqprlOfWPy2trrukc8xYatGR6/6GneajVeUMSnPEb8lujNZ1T+1j 77BryeC9rvPFr6XnlqwWueDnnDjhaetH6l5qwkaTMwkPX94PLEphlbt0X7KTvrTn9ETxC7PbymXE PwZE6mZNX1xeciTrsfz+ZUff9DkY5P9C6rZ1i/r4RbvT4o+73F+1ICngl0clSbUWS0xkB8rcCGoo VdruuWZyyW9qVvS0O0smu96rU3kt7pXgMPAxRytSfcqwPStO7LM65bh56gQFt505V5Zm2s3gDbm6 ad9czeP32maH7XVLqNJxGF4QKBvgQddntF/gxya3jBqRdJE7KjG9R2ve0+lvoO/7SjB7LN4JRWp6 7bDt6oOXJo987zt8zUP5K5GZppwBOo9/Lk2MTvTVZCvQfdJ+vps7M2/oxx5E29BWhRaFZtkm4QkJ sdYDBwbHRQ2Y+sWHA4Jjpg6MnRLBrB0YGxcTMj04IX6gkw8eaAPwKnrol6/EHGJLW9OWX5ZpMtuw Z4NJSUk/22BoXK8tJfywA4HaDPaL8Zm8Xi3TFFG/yw+3LXl2NT21RXxmQpLn6iEK7YRcRMqNoGXF nyYXFTzQ1fsw6sraLq/qiWJlh7a8yGhfoxoz9sOb1ruCXxdx7frIqzXVHHAZwtUJ8BMbnvuK23h4 RPSre0Oldc0WqcfdnnRwd4S0Vm7LE1OxGynRMSt43qf13YftMDbMflzU6K9z5IjtnfH7MvmHzVQ8 57oM6a7MLRoruj3v1owqv9TNWz0a20oK8h3unZmgZXcz1XSIx9vz9bPXPTvYUBAs67O7JP/llerz hUU7V52eZTDPsObUtY9RrOvVliWtTRMU5SVq3p1O2yLJVbq1TPPRniJ3u6d7pHRmULWGhzZNOZVj i9VmHVabrC9qMyz5BagN5+9TG9+IqaHxCYFTY3urjTltJTSnhWZmxoA3Qlg0pplFOn3Lv6Vu/Wnt zxOlarRTRGx4aJyas4+LmouPh7WQdrY0MrM0tTBycnS1/PJGlozqnzTCJzQuMSI49C8F6ulhTnD9 tZmlc53tNpedeOG+Xuu2VaKq2GVjtzEzLhpc2yy67OWjQZ1VOskbOx/OSTE+f23QIiuLtvdXbUz7 /LYio9P0eXhWnFLOnQr3OxVZ7SY8srY4Md7M3b+1/K7bnL4VuTNudKtmyTm6TjuX2t9PuinT0+b8 h+a3i17YE/cvNQd2yC8Zvind9k3E4Kd3F1SLeh5OmP1E8HDI051RrZcmp3Pf9zk9R6Yy/p6Y+4eg zheFVvnWXc+k6gNVg8Zc5flmXrIZPvzeqKqBAUpLV3Ccrvs/y+BprhYr5AhDF630UHVQL16x7JOL s0uM2V4Xi5KI7aEdpk575Y/ZWN2VXNymNO++r1c/m3XCkt4C9U2QUuJeDbAfrXdH+114Bfo4/G7K +ft232lPzGMP+9WHTHcOz845UvB0l42DU92F/5X2JMTHBgf+S7Tny5YSfqag3D+o8E8EKmJWhpig T1PzedcFA6qbTGelp/bXddBv/1V9BbW6ZJLPRL2OF7W+btvmvJO5wJftGNGWLUdE38/sq+uy1dDK +FZMvsW4Fk3vHF/WEvutBSGWb83rZZ0OWtutaRA/Pi1dtz1sq/DeBP+cDm/vuxOerVy2LkLMfUFT U6K7qXjk3WTnrQbjM31TXbQUtU8sdD2pfV8xLUJP9q183SsNw3TXiQavO7bUJdlpxnRsCclaWhwk vt1IddvDZXap3XuWflz9vPUTe/fZYefGJez60C7TT9nq3Mb9l4+83t9SX9I2WrXTtrX+sr7zkeoC +zlhCmf3qQXzTg8eFGqsmLyvYlCtzlAPDcW10Yvp2tbl3wuUZCR/rWcNob1T6oZLvzGzJhf/KFN/ T/DVo060qakFo05WePFvCL7+IJx/pTc3LaI7d9c7uk1TqD831M6n5sNO2cOGxpXSnt71mS/sTK4N E67QPbg85E4/r7mHjw1vSuW8fzn96KJT2y6VRsSGzegf9vhg+cusQ2dbdnyS3sQfq6E38Pzga6PZ yokHpoZMdfO9cau1uXpD5qm026nupEXum5r13NGq4UPOXqtJnDBwzkFt9v7R4yNVgrvTkm1bLrG1 R1glJYj6H5twNdvCcHoD9VTVSiw5sWtdVPSsO8/tclavn0ZN0vdUCAowXn8x08NAY0K4y6LmgXMl vfZ1HFBaEtWi/YvM+zOSV7Ko1xmJ8eZ1q2YVNwaIPOfsyTYpf587fq7D3DFZudF7+hkObYwpcLoT +ThVZ+mUz3qTgXRxj2j9fA/9fxF+SYqI9RwAlUNMTEX0Us+fiqPi1w/IkmyBKo/wIaYTQYQT4fB9 aPaHuO4nApU7Qkp4LNmrUmppUaAoohbHuix5Ge9bZS/GMequGOmTpfLCann5xtH85sUHbZSbOndt bSjfO1JdOYYbkTKFVazh+iJq/9RkjQrXX+e2L5E4KrrQvPZZypNYf5cNKy42nru1tOZutf7Z5OcN pcaX5h06E3zCvElBvTqx2Sa/TDl+vfr8q/v3S/sufl1wLNQtX1enIGChhM0pmdAZQyvPl2Rae+4J GtNMP3li1ff+grbrVukdMuqLQ9KCRdh5bfmk08DZrvMPd5PXQjvcmq+zElaWcaIFjetu6gYmD22V L5BStyRV5u0SOZlnXPFwcJ3PoKrtC5ofh1ksea2RV9C4J8l3pPXlOOd9mm+FGezdWKR2kgjR6fP+ xqjsu1jx2zHuwvTrtOxXf+sioSiLA1cvM6Ogx5liLKGg92F1XJtvS3whRfd+VY7W/PZBthCPsXc5 bqLpw5c3H+Dme+1ZUP1J13P5ATqk10cEwtG0b6F+mi4xgogggok4IgaOzIcRCYQa4UvMJGLx0mS8 PhCXwomZRTppWn86vSbMjI2ZHBcYGz5T7Qd5Y2cgQq3694qxioS1bL7S/BHn2lftKVg5uPgpZeLH brGMd/34cW/p2pd36PspC988e82a/ebShI43CevS+NFl10sHsqLZsU9Zl9/KLzCqmbvKYvN5u7n+ ftTMhquKV6s/mSxaf7NMrbjc9dmhlA0vdtfY1T2tdr7d5HDk/RNZxYXDW1cil/OTTASLUksXb3Ra Uv/Rozu4ZMXxs8L+o+L3B5QvZ79rEE8sHTqjlMxPO1263NRcp+73EEHhUrJhar85pSmjzU78KpO8 z1Fj1drzszxiEzeWGpzUeDQr/op/YU7RSz9PIWkgmej8IddVJShXZnZO8oO5mnc2/uJhwa5zD9vx ePP1zWM05yygm/rJFmWQ/egMUvmbj0SEGaQAr+L+nw/RH2ek7wIM0Z4hWuhPK/QeifxvZ4EQ/s6v r3CEEniqtRTSxniiNbYyMRv3h4FIdmtRtw8GLvEfMIme76L0Zved5+9/0CxmiNxefdyNa3S7okF5 yzV1zinB87BsrW5H8rzTq6r6IrXEvHtH7q5cKj34no5+8ZbliwIXK3Q06u/1Upr3fvbypz4nBz+u NPLPOee8IiR6dIC2I/9UNpnm0KKxdvZJ41leLVHzH3wwl39Tt2hFUF/f/N8eykgXXV5X+q7bz5o1 5MmlljHtYXYOk4dPLD9adS3L6IFfRf3ynUHTIu23ynCPnTdonN68duHMGbGZJa75x8oyF3gMsTbI 9FE33tb19JR9QiJZU7ojzse/IvxUyjPhoPD8/mnt+0X2PPq1Qsow42JU9e7b0/Y9zgzadhAl0tep wT77xnPa3+03D+H4qMstmuwaLRk5dayMd/R+ceK/AFyPDqsNCmVuZHN0cmVhbQ0KZW5kb2JqDQo1 MzAgMCBvYmoNClsgMFsgNTA3XSAgM1sgMjI2IDU3OV0gIDE3WyA1NDQgNTMzXSAgMjRbIDYxNV0g IDI4WyA0ODhdICAzOFsgNDU5IDYzMV0gIDQ0WyA2MjNdICA0N1sgMjUyXSAgNjBbIDUyMF0gIDYy WyA0MjBdICA2OFsgODU1IDY0Nl0gIDc1WyA2NjJdICA4N1sgNTE3XSAgODlbIDY3MyA1NDNdICA5 NFsgNDU5XSAgMTAwWyA0ODddICAxMDRbIDY0Ml0gIDExNVsgNTY3IDg5MF0gIDEyMVsgNTE5IDQ4 N10gIDI1OFsgNDc5XSAgMjcxWyA1MjUgNDIzXSAgMjgyWyA1MjVdICAyODZbIDQ5OF0gIDI5Nlsg MzA1XSAgMzM2WyA0NzFdICAzNDZbIDUyNV0gIDM0OVsgMjMwXSAgMzYxWyAyMzldICAzNjRbIDQ1 NV0gIDM2N1sgMjMwXSAgMzczWyA3OTkgNTI1XSAgMzgxWyA1MjddICAzOTNbIDUyNV0gIDM5NVsg NTI1IDM0OV0gIDQwMFsgMzkxXSAgNDEwWyAzMzVdICA0MzdbIDUyNV0gIDQ0OFsgNDUyIDcxNV0g IDQ1NFsgNDMzIDQ1M10gIDQ2MFsgMzk1XSAgODQ1WyA0NjNdICA4NTNbIDI1MF0gIDg1NVsgMjY4 IDI1MiA2OTBdICA4NzZbIDM4Nl0gIDg4MlsgMzA2XSAgODg0WyA0OThdICA4OTFbIDQ5OF0gIDg5 NFsgMzAzIDMwM10gIDkxOVsgNDAxXSAgOTIzWyA4OTRdICAxMDA0WyA1MDcgNTA3IDUwNyA1MDcg NTA3IDUwNyA1MDcgNTA3XSAgMTAxM1sgNTA3XSAgMTA4MVsgNzE1XSBdIA0KZW5kb2JqDQo1MzEg MCBvYmoNClsgMjI2IDAgNDAxIDAgMCA3MTUgMCAwIDMwMyAzMDMgMCAwIDI1MCAzMDYgMjUyIDM4 NiA1MDcgNTA3IDUwNyA1MDcgNTA3IDUwNyA1MDcgNTA3IDAgNTA3IDI2OCAwIDAgMCAwIDQ2MyA4 OTQgNTc5IDU0NCA1MzMgNjE1IDQ4OCA0NTkgNjMxIDYyMyAyNTIgMCA1MjAgNDIwIDg1NSA2NDYg NjYyIDUxNyA2NzMgNTQzIDQ1OSA0ODcgNjQyIDU2NyA4OTAgNTE5IDQ4NyAwIDAgMCAwIDAgMCAw IDQ3OSA1MjUgNDIzIDUyNSA0OTggMzA1IDQ3MSA1MjUgMjMwIDIzOSA0NTUgMjMwIDc5OSA1MjUg NTI3IDUyNSA1MjUgMzQ5IDM5MSAzMzUgNTI1IDQ1MiA3MTUgNDMzIDQ1MyAzOTVdIA0KZW5kb2Jq DQo1MzIgMCBvYmoNCjw8L0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGggMzE3Pj4NCnN0cmVhbQ0K eJxdkk1ugzAQhfecwst0EYEdDImEkFJoJBb9UWkPQOwhRSrGMs6C29cek7aKJZA+zXuexwxx1dSN GiyJ38wkWrCkH5Q0ME9XI4Cc4TKoiDIiB2FXwrcYOx3Fztwus4WxUf0UFQWJ311xtmYhm6OczvAQ xa9GghnUhWw+q9Zxe9X6G0ZQliRRWRIJvbvoudMv3QgkRtu2ka4+2GXrPH+Kj0UDYcg0hBGThFl3 AkynLhAViTslKU7ulBEoeVffB9e5F1+dQfXOqZOEJaUnypDSHRLLAmVIaRqoRuJPSByVlAbKOBKv Ax2QslOgCvOsnektxy02zbmX0Tz0zOpVHer8LjbN1xYnbLGvkHKGdDgGSpEeeSCMtuMHR8x/2b8w fkx+m787EFdj3Phx5Th3P/FBwe9foSftXf75AUzDphINCmVuZHN0cmVhbQ0KZW5kb2JqDQo1MzMg MCBvYmoNCjw8L0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGggODE2ODQvTGVuZ3RoMSAxNzU1MTY+ Pg0Kc3RyZWFtDQp4nOycCWBUxf34Z97bI3vvJtkj2SS7m81ujk12c4dASB4hCTkISUhWEiCQEI54 YGIgXIqi1iuCFx5VK+BRj6KyWVCDoKKitvWspdZ6YqUqaireLUj295333Q0BsbXWtv/2n0m+7zPz nePNfL8z8+ZtFgglhBjhIiGNFc0101ry+9SEuyaWEOulleUVLReVxBwh5LZuQhSrK8unTz0z+3M/ IZv0UKF1WkVl1ftPfv4N4a5IIYT/87TGhuYDbfR6QrYeIPSmt6Y1+8uf2n+AEq5qLyHT5jU0+3K/ iX59IiH0VbhrR9fSzt5n3rXaCEnrgPp7ulYst/tqCmoIqX2JEFnU4t4lS2/9sPxeQjLtcP+YJZ3L eomFOOH+UJ3ol5yxenHnKc0yQhqhPZu3e1HnwvdkI1XQ/lzIL+wGhWaDPA7S10I6pXvp8lW9S5RD hHATCHGnnb6o78zCg0XQnysaWZ0zero6Z34z/SlCeqMISapa2rmq13rElAR5UIfYz+xcuujKvetv JuRK6JM2v7dn2fJQI3mYkFv2s/zevkW9zxxa7iWkIB+M+jPCbCvdNHT10tqs+bqSL0lcFOs32fXR Oc8xPpX8074jrx3doPhY/hSUVRCOYIB6MjJC6F7lliOvHb5Y8bHY0pjAf8Y0umTSRKSigiN64iNg RXUX3FcsIqnldkNulPRGaR40mYTkXyIPcySKcDo5x0skPCd5h3AhgdwbgjoKVrG+2W4nYG+7G/sg 38S57YRuFhvdI9WykULr2mO9oS+SHxwkJaThh9f+duDvJRt+zPa+b5CN/Hj3lZRjW9K1pPHEPP6X pOzHus/f7Uc3cfy77jUe/jsD/zmZ9oPqtZHq71NOUkfqjkvLSe0Pud//QqBfk9P/kfKcKvT6d7Rz 7sn0sgvIuWDvk+axIKn/fj47aV9ePb5dPofUfK96TxPzD73nPxpg7Kv/XfcaD+NhPIyH8fC/Hbib yXuROP8AWfa96hSQLZyTrJUOknP+dT37fzfwF4w/h//VAd7fU/7TfRgP42E8jIfxMB7Gw3gYD+Nh PIyH8TAexsN4GA/jYTyMh/HwXx34sCSEv8X2F0hBjDtAJOQNSGcQO8SUENOQZOIl+WQiKSNTSRWp J02kmbSSTrKInEZ6SD/ZYneHQmIrGqh1fNnGcNkucio5g/SFy9LQl3D7DH43n8hrQy+G9oe+htoq 4iC3RjoY6no3L9w39wl9TwjTArGk0U/Meb6Wv4HMIm1UT+NpEm2np9Ie2k9X0LV0Pb2K3kQfIDL6 sVj20xO/uwdpLvxNP4787UDH3O3kpm0dEz80Jj5rNFYfjkSfZHwV4hXGAdd5o9pv/e2FQj9xpOE0 jBeu4RGLmsio/ysC3ybOxx8v/A/PY6Fq/rz2uXNmt7X6W5pnNjU2zKifXldbUz2tqrJiavkUoax0 csmkicUTigoLfN6szDS3K8WZbLPEGvQ6jUqpiJLLpBKeoySz0lnVYQ+4OwISt7O6OoulnZ2g6Byj 6AjYQVV1fJmAvUMsZj++pAAlF59QUsCSwmhJqreXkJKsTHul0x54vsJpH6Kzm1ohvqHC2WYPDIvx ejEucYsJDSQcDqhhr7R0V9gDtMNeGaha0T1Q2VEB7Q2qlFOdUxcpszLJoFIFURXEAmnO3kGaVkrF CJdWOXGQI1EadtsA76rsXBhobGqtrLA6HG2ijkwV2wrIpgbkYlv2U1mfyeX2wcw9A+uH9GRBh0e9 0Lmwc25rgO+ESgN85cDAJQGDJ5DurAikrzlggSEvCmQ6KyoDHic0Vjdz9AY0IHXpnfaBLwl03jn8 8fGazrBG5tJ/SViUDXHUTJAfiRPoG/QQxudwsL5cPiSQBZAIrGtqxbSdLLAGieDztAW4DpazJ5Jj 9LOcdZGc0eodTgdzVWVH+HdFtyWwboE9KxOsL/664Bfy7QHe3bGgq5uxc9GAs6IC7dbSGhAqICJ0 hsdaOZjtg/KdHTCIU5kZmloDPmdvINZZjgVAYWc+OLW5VawSrhaInRogHV3hWgFfZQXrl71yoKMC O8jacja17iR5of2D+Xbr9jxYom2sHwHTVHCKu3KgdeHigK3DuhDm52J7q9URENrAfG3O1kVtzEtO fSB9P9zOId5RrAVjO6F0pDAbudwVZW/lrHwb8xYo7FVwcZaXQIYe3CUmmUfLS+yt1EoixeAu4RIs dlw7kOBdU6tZFs+qTq22OtocGP5Gl6zhPkldgagxbelBMdonvM93dg1Lsw6l2ysXVYzp4HGNSsMd DLd28n5yzBbhG0ONKObO6kgW74KVCzoOmhFVzIsWe4A02ludi5xtTphDQmMrGxuztejfumZnXdPs VtHb4VnSclwK8ydgKkAckB1JcFNhDlZ5rBG3iulpYno0WX1Cdk0k2z4Q5axrHmCNO8MNEjusIBi0 zF3TefmE6HxYmlWwuzmrOp12vb1qoHMotG7BwKAgDPRWdnRPZG04axYOOJtbS6xiX2e2rrWuYbeK JnW0rqU8KxP2nvJBJ720aVCglzbPbt2pJ8R+aUtrkKPc1I7ytsEUyGvdaSdEELUc0zIlS9hZgrU0 ExJRYnnrToGQdWKuRFSI6a4hSkRdVERHSdcQhzp9RMeBToI6QdSxAE6ydIOJYbuttC9k7jmnrXug o40tLmICV8IvDVBnKQlwztJBysnUAaVzUXlA5Sxn+jKmL0O9jOnlMDGoiYJx2J400OGEfQomVCux UpyKPGvSPhQKtbQ6nrcOtzlgqs0Fmd0aUHhg75e6aqHcNCYdoJ4WWNfVyfpB/K2srtxV09UG0zbS IBSpCSigBUW4BShRJdZh0xEqdYFvwIFi/XWQCKxrC7R52E1bT20Tp7M+QKqdE8Ht2KbUzW7kaxuI duaKaxOWgtJ1CYMC+kaaW1FjhSTcrA2NJFdDz7uckNXVYQdrS0hXM0x13EuVVtQsgi1R4l4kitIa ziRsWLxLpVEGFF5oEH5ZXOVlS1Lqkre1YefF1CXhAnBvfUAFPXKPMWW4AlgHsmpYX+D3EugqK/o4 a6ZpiMx0roKdhXVabEkO2QGNq6YTNn+srwKNc0KkchTbI1ThNvaiVs5Grga7866WodBdztWOMSEr 08keDmxiEutOmNikbeBERWCOJysz6kStRlQPDERpTl4B7RWlGSUoyaCCH+L+GkxKtA1xfwkmeQBf B5MyAV8hvkR8gXmfY+ozxKeIQ4hPEH/GksOIj1H5EeJDxEHEB4j3Ee8h/oQ4EExSAN7F1B8R7wQT owH7g4lxgLeDiT7AW4g3EW8gXscir2HqD4hXEb9HvIL4HWIf4reIlxG/QbyEeBHxAnbiecRziGcR v8bb/gpL/hLxDOJpxFOIvYgnEU8gHkfsQTyGbT6KeASVuxG7EA8jdiKGEA8hHkQ8gNiB2I4IIgaD CbmAAGJbMCEPcD/iPsS9iK2IXwQTcgD3IO7Gench7kT8HHEH4nbEbVj9VsQWxGbEJsQtiJ9h0zcj bsLqNyJ+irgBcT3iOqx3LWIj4hrE1YirEFcirsCmN2D19YjLEQOIyxCXYoVLEBcjLkL8BHEh4oKg NR9wPmId4jzEuYi1iHMQZyPWIFYjViFWIlYg+hHLEcsQfYizEL2InmB8AeBMxFLEGYjTEachTkV0 I5YgFiMWIRYiuhALEJ2IDsR8xDxEO2IuYg5iNqItGFcEaEXMQpyC8CNaEM2ImYgmRCOiATEDUY+Y jqhD1CJqENWIaYgqRCWiAjEVUY6YghAQZYhSxGRECWISYiKiOGgpBkxAFCEKEQWIfEQeIheRg8gW wdOgxQspHyq9iCxEJsKDyECkI9IQqQg3whU0TwKkIJxBM5vQyUHzRIADlXaEDZGESEQkIKyIeEQc woIwI0wII94hFu8Qg8pohAGhR+gQWoQGoUaoEEqEAtuMQshRKUNIERIEj+AQFEFE0BBiBHEU8Q3i COIw4q+IvyC+Fm9LvxJHRL9E5ReIzxGfIT5FHEJ8gvgzYhjxMeIjxIeIg4gPEO/j/d4LmpyAPyEO BE0wwei7iD8GTRMA7yD2B01TAW8HTRWAtxBvIt4ImioBrwdNVYDXEH9AvIpN/x7xCjb2O2xsH+K3 iJexsd9gvZcQLyJeQDyPeA7xLNb7NTb9K8QvsfPPIJ7G+z0VNJUD9mKFJ/FGT2CvH8fG9iAeQzyK eASxG7EL8TA2vRObHsKmH8KmH0Q8gNiBN9qOCCIG8bYBxDbE/dj0fYh7EVsRv0DcEzTCvkvvDhqn AO5C3Bk01gN+HjTOANwRNDYAbg8aZwJuCxoFwK1YZAsW2YxFNmGRWzDvZ1jyZkzdhCVvRPwUK9yA uD5obARch9WvRWxEXINduhpLXoUlr0RcETQ2ATZgyfWIyxEDwdhWwGXB2DbApcHYuYBLgrHtgIuD sbWAi4KxcwA/wbwLseQFWOR8YRvwkK7S9om22rZfPcP2BMjjIHtAHlOdYguCDIIEQLaB3A9yH8i9 IFtBfgFyD8jdIHeB3Anyc5A7QG4HuQ3kVpAtIJtBNim7bTeB3AjyU5AbQK4HuQ7kWpCNINeAXA1y laLbdiXIFSAbQNaDTFFw33CHySnExh0BdhMbPS8Yw5bjucFoNrWWI5YFDWxq9SHOQvQiehBnIpYi zkCcjjgNUYKYFNQzTEQUIyYgihCFiAJEPiIPkRvUsXmag8hGRCMMCD1Ch9AiNEFwyhBVI1QIJUKB iELIgxrmapkwB/hnkGGQj0E+AvkQ5CC4822Qt0DeBHkD5HWQ10D+AG55FeT3II+CPAKyG2QXyMMg t4ArfgYyRNehpdcEDWzKr0bjrEKsRKxA9COmIsrRDlMQAqIMUYqYjEM2ImIRMQw7eZ7ngoLtjkd5 juwA2QvC8wT7cjaiGb0+E3vWhGhENCBmIOoR0xF1iFpEDaIaMQ1RhahEVCCSEQ7svB1hQyQhEhEJ CCsiHhGHsOAwzQiTcDPwKMg3IEdADoP8FRz8F5CvQb4C+RLkC5DPwaufgXwK8j7IeyB/AjkA8i7I H0HeAe8+D/IcyLMgvwb5FcgvQZ4BeRrkKZC9IE+CDIE8BB5/EOQBkB0g20FuZt7njqKN1yLOQZwa NMBRiHYjlqBZFiMWIRYiuhALEJ2IDsR8xDxEO2IuYg5iNqIN0YqYhTgF4Ue0IHwIL5o6C5GJ8CAy EOmINEQqwo1woW9SEE6EFCFB8AgOQXFFEuE2YAhkBOQDMOwrIL8D2QfyW5CXQX4D8hLIiyAvgKF3 glzEu2w/4b22C6nXdkH1Ov/5W9f5z6te6z9361q/au2ktXVredVaK+DstVvXvr5Wdk71Gv/ZW9f4 JWti13DK1dUr/au2rvSrVlL1iup+f0v/gf4v+vnY/pb+hf3L+6/t3wcK+R39O/r39vNDoT1CdP+E SVXr+q/q52IhnyP9VMfUjn6Vtmp5dZ9/2dY+v6Qvv4+b9EUf3d9Huew+2tjX0cdBqe19KWlVrHRB nym+St+X3Sf08WdV9/h7t/b4G3p6es7r2dzzWI/0vJ4re7htEOOEHoWm6szqpf63l1KymwsRPcge LhTklT27uBFCySfciBCip4MBTgNDnOpd4u/eusS/2LvQv2jrQn+Xd4G/09vhn+9t98/b2u6f653t n7N1tr/N2+qfBeVP8bb4/Vtb/M3eJv/MrU3+Bu8M/wzQ13vr/NO31vlrvdX+mq3V/sZqOs1b5a/k C23wBCFJ8NubtC7pUJJE1ZHYm8j1Ju5PPJTI9yYcSuDOs1Jd/HnxV8bzOrhweImzxV0ZtzluW5xU J0Z4dW/0umiu17DOwGUbBMNLhv0GCTFsMXC6K3Wbddt0fINuvu4TXUgn2aaj27SPaV/U8g3a+doe La/TsjSvF7TenCqdxqYRpvk0fIlPU6Zp0PBXaqig8eZWCZqU1KoydYN6vprfrKaC2p1e9YkypOQE JWR8oggpuJCCEp7aKWV/OLVTPor5iBptVTAft5uolMLRYrCl2eOpG5KHZtYFohrnBOilAVczuwpN swOySwPEP3tO6yClV7QNUm5qSyCWfXAspi/asIGUJ9YFEptbA1sS2+oC6yAisEgIIiRx0ETK2zzz lvUvW7bcs8wDF5B5y0CzvB9+RVC4AvuXs5zlywgU8XxHYCWWMfSLhZb1z++HNiAD1MtENUvNE4t8 Vxv/1vCdI/l3BPqfvPn/38Eyfx4h8k2EjGwc87fv8+HnZ2QreYA8TB4nvya/JZ9TJekgF5HHyLvk Q/IZOQLLVE6NNIGm/1PfAzgujFwoXUo0/B4iY/+DRehw6ODIPaGDhEi1YzQbIWWWuI9pQtGh4RN1 IxtHhkZekKmIXqyr554F7SE6HDrMlbF0qJCluUtYXKxxSL5pZNvI5uO600v6SD9ZRVaTNeRsspac S84jF5KLySXkUnIZ2OI8iF9O1pMN5ApyJbmKXE2uIRvJteQ6cj25gfyU3EhuIjeDHW8hm8jmcB5L b4Kf68VclnMbuZPcQ+4F3k7uID8nd5G7If0LsP695H7QoQbT94FmC7kVtHeClpVium3wEyCDJEi2 kx3gM0xHUkNkD3mQPATcCd7cRXaTR8ij4Mc94NknRB3TRNLfXRKvT5K95CnyNHmG/JL8CmbGs+Q5 8jx5gbz4g3KeGtWw1EvkN+RlmGv7yO/IK+T35A/kdfIWeZvsJ3+EWffxt/JfhRKvQZk3w6XegVJ/ Igeh5DCUxHJY5g0x9wOxhX1Qdz85QKPIl5QjR0gIYsx714seulH0I/Me884dop2ZP7ZBmnnorlHf 3Ac2vg/8yVIsflPYG/dD2UGwYMR+J7faC2HvoL13QxlmC5bzfNgWz4Q9wdp5dLTus2JeUKz3xGir xyyKI/zdGOu8McaGfyLviZZB62HuMeuxEgegDLMya+N42/4R6qL1WV2mH1uH5b0G6YOwO3wMlmb8 SPTER+T90fj74fxh8mfyCflSvB4in8J+8jn5AtJfgeYQpL6tPVHzNfz8hfyVHAYPfkOOjkkdPSHn KBkBHxNKKUd5MnIsdkwrigSOGDLY06KogiqpmmqolurgKCI/IUc1mmP4Vo76JHkKURNNY2gs7Jdm aqHx1Ar7ZiJNojbqoMlj8uJGc+yQ46Qp1BXOM4k140br2qCEeUzZdJpNV8LVQ73UB/Ecmk8LaBEt Bk0WpHMhPRHyskWWk0aygJxBDks/4J6D9mNhVxlk/y/eyDL+ddgxeSInxaSezCAtu4mG3gLb6kT6 7I6Kiqgs+aOQ5IidPkuiwHy3CDESTmO1ljkLZOv5JkNNmXw910LKjr715tNweT662Pc89b05/Mqw /ujThmLf8L7hnGxqcBhEidVycrlM5kz2cgWp7sK8vNxSriDf7UzWcqIuv7ColM/LTeL42IimlGNp yr/+TQNfeTSFW+2Y1JwjpR6X2RYTFcXbkjSuPLuurt5ZmBYvlUTJeGmUPLWw3OlfWZv8gtKSmpCY alECExOAR5+Qag9/JtUemSWpOLKb+6C4tTRFtlqj4qSKqFvSkowpOQmT6zQ6jVRrNccnyKMMWmVG defRG+NdZqXS7IpPcLG2XEcnwdm/IfSRRC11gt0uZ4dPf2swgXge5Z4hWmKhncRB3KEPdqh0dLqb vTnGNEvgtfChgmwLU2WzV0tBcQqxlMXXH/XsGy5jFwrW2puTbd39QxvIyW5zxWrRvPnRhYVgOZkx bElmY2NsEsdMziwqUfMypalsTn/FRa9c39i66c2LChf6K6xKGS9RahU6b82iqvrV/kzfrLPrqxbX +DRKdZRkb5wzLtqc4jDNvP2L235Oyf2zoxPd1ugEd0JSRrza6XGW9d/Z3XfXGQWONHuUxcO+nbkh dJjvghmWSnailQblMUPctYJJk0iSEuVpOlovt6g1dLpcr4Low3QWiQkdehDiMTFxsqHQ/u1QAgiW 0NLpMnjD3iEkN8X5YeAw8mGPByacB+ChPt9eQ/FwLthPMPyI7YJN2bR1OgwOsJoRo5HZacgvzGNq GKJKqxhpoxsUWpVUjC9T23JT3XlJmiwH18m0ktuS0i3qkTuUlrSkpLR41UiSSq+SyeAiuS4zVRWX gdaSnQXWKiF/QGsJKk12ttnnU3otlvghbuGOlBy1WgmRh0hKYVOcWmXZRbOIQLyhQzv0Tm56zlDo kGBnMbOeXTV4Nfuyc7wyW1qTzR/tl4qDLCuLNhezEyGMNjc3t4z69g3nGvL07GIonuzLyzPkgS0f +HHvgjM0bDwn1fIslkqdx1mUTU8zzaOwFbCoUXaWKjHblZKdoOZGLpNE27KTk7Nt0fzI9ZwqyQf6 RFVh1r3e8my7mlokNFljS5/gGrSmxmlSlHqlTAYXSeKRAxqDkpcyaycceXdUf35eoc5ZnPHNUZ5m TEzRaaEW+84x+EHCgx8SSDpZF563KbJd3EZiIInc44KCGFziOnQNUc92mUztHAqvVScodgjGJvXo TIKJNOxh1tWLk/PBf6xiZPo5T5xzEmm+l6nZepbwFRc8su4MTZI449Q5aTTH27x8ZUvmyHB2VX16 74oyf2ECf9HSu5eVjHSNjn29zyc3l84/b0FFa4ZqpCZ5sh9G3hgySTdKXbBeJ5ENOPLtSkd0Gvsy AUnIBeyIdig1WZFuZw3RuYLK3OySFInjKmKfiAka3JiGPfueL2MDKRa3tmGIgAW2/4D6YAZp2ACp 4edH+MnAVqQ8SUrzj9/ipBvlam2U4/Rzzi/yXth4wzvX1zVuOnjT1W/f2GDOFNJLO6akmpQjffb6 dR2dFzQ67NPXdTKenZJpkadM7Swz2upvO3LfLUe2zZtx61d3z7rxgjPSCyckaIx53KuL7lw5pXrN 7bNP/8Wqsupz7oRVWxY6yK8Hm9WQXWixnWQKd8MDKbkpuWor++4BUXvZAioiSpr1oKEIfkwlEQOU DNEsQT3FKk1vNokWMLEPDAVpxAJlMPphj6G42OfTwxRiEymaJYbFB4X3R2o2Ms2SvZKIYfHZ7JWF 0yc+SGT8+ukX3N81dVnrpHiVRKFTavMae2qypxckZNcv6F5Qn13Zv7nNO7exNFYu5Xi5RqXKrppb 5BE8Rl/Dwu6FM7LpTxbftCTfZEuOz/HaMuJVjjSHOaPUnVmW48me7F/e1L6h3au1JMVqzc74xLR4 dYLDanTlJ3owfxnY3QGrtEIaS3zkPLT7bpLMXUssJIVrFJRes89rgR+iZvumYFLZYd+8TogWiMru dKrSZzpVhsSZhshGBfYoo3G+PF+8Rf8mWCgermhpuKCJrMJJa7E9zWTCWZnK82xPc7sLiyiFa6G4 l8XEsFMNlIGzZWq0ylI2wVdo00o//0ymtRVl5RfHqmNo4cj+aI25tNhXZNfI3n1TpknMy8qdaFIZ RvZ3OTNMMolCr6a/HclS6xUSmSnDyRVwMSkeo5TpR1rovUwvNWWkHD0Eq3gazMgV/O9JHhFoevh0 ojDnD3FzdpDUVDJxiKsU9AbeTD83U/OQOp9+k0/z2WejCvbIzM/3TskYohbBuj+Z8muTNyRzQnJj ckcyr0u2JXNqSXKyJBEeoYJWDRMr0aKn9YmHvbWTYe4JCkhMPiCo6yXE4sOZhg/T+fPa29vntw8b 2IO1/azh9rNgT9hbDLMvl20Kgu4/3BvxycSc6HYXFIzZYvIKwjtLWCMRNx05rgJTXm5hEb8i1pOR lW4o2nDKtJWzsiev3rFyliF1SnZZ1/Q8vcqgkikTqub1TDr1uo7Mrzsmn1IYN62soM1r0+rlcr12 2qRyV80Z1TOW1aUUZpRlxCYkJ2jj3WZbSqIzKSbdf/Hc16JT8hwThMJ8dpqqDn3IO/hXSAG5ZfTM mfoot1w8c9qIjaSEl38K+wNPTK3kYVpNcsCSKjj45GSKG0Em+yuRoKiPHB09o4fPvbnhw+c/19Jx p9DI3iHDrUM29ggKQ5HKLRNrZ3mXbD6jaOqqOxak1U8tMCmkfKze4M6vzl3QHZ9Xn5dfN8GtUajl kkC806IzO+L1wtodyy9+cl0pbA8mncUZN9EHZrvhmuoza102t01pzWDP8DpYA89JlxI3nNCvC1tL ZS3exbF/xuPj+gRljKNKVZxqlWgzIrsmzLMaQWGpzRfHlw+pHYK2Xjo98khmDyMz7BPstQanreKH tjH2JDR2vuWazIbIo413u8c+04r455SW9CR7Wpyq8oa5ize0peUtuGZ+3ZoSdjxywfHocGFXYc40 jzE6vSI/Piev0J6s0iklEqVO1VU7s+Hi7V0rH724evIkCucf8eSpPJpfUZ0zc1HBhNOac3XJRWnM brVgtwdh7/CQfCoNnwBiYhyZ7FtNnnzJELOcg8+MyeSsmU9K2DI1a2g9kegl3PRGSYeE2yIJSDiJ JMEHFmGnbEbBDmV8B9y1lq+IVq/lDLxWYVHTeoUFCij+KiREJpFnHyzN4fAqbT9rXrtneF472Dv3 TdiMfaLF/733Fp+MMqdjzLw1Hj+7OWNqoegnOf9gesrRd6yT2qeUL6zJ1inUUTwnidJMnL28fOX2 VZNKV9xzWu/mxdlf8HPmZ0/zxXH0sDezuH1Kcow5Rh7tiDPZTDqtxWwoWfPw2pWPXVRV3r9lnv20 1SmTm33gl9NDh+kG6QxihDfDSvTLY8TEPQaHVCPXQZTERs9+QIjT1+BUewXmGsXXb+vOk+QddxKP DCSGrVM3vIbDNKRr1OK0SlRHGFPa4p802d9SkqzUKaVSuPBrYG7BTNIpafb0iRNqpk8qJlzo9ZGN dAv0NIVkk/mRE5GLeyzoUZMhbv6OuDiS6x2iZ29Ps9XEsr9SC9IGPJaUvTJsyMtjW5HY7+1/p+Cx MYRPLSbx0HLy4WxIqTmzNn1ivFLC8VHKKKktOt5tUasTwmNj42Ljk5x6QVuWSh1tTjQnuExKqd5Z VMJv/PYwYTc+FzyyRtoLHikLv63pNEYKG6RKSTWEqiQw2o4HBKW+Cs1OfaLdxWdPu3V7RH1ST3zb +qNGlzojyxf7IFPAam0kW8PvKVXwfj1/e1JSrpJ9l7KxNHUXzI5cog9vT3r2rYK62pShY/t7vaAV ptSWVmVNqMmaHjcde4Vnm/CGBR4p3jfMPs4pFqfTP9XY8eMVnwpyw99QhC1iDB+m8AMio0zBXOeG lz+Ds8CVNbcQ7JTC7GRILkzxzi2ImE0Zn26zZ5iVtRsbi1orcw1p9XV1qW1r6uyj9uQMWbUFiVVT j277bg1/TiS2pLHR7ClxeUpTY0qWDNSH5wH/Mvggl5wf9kFGDDN6ElGBB0iSHl6Xt8NjU8/MpA6b TVAJWbUZcSk1ozaKRguF3xUjhv5Hav4dyx5vSCP/sjohJ8WVk6COSSl2Zy/4tslubJ6ztj551FD0 6JS/ZRYwRyfsU9WhgxIJWCMG3iHPiuxTsVw/PHWT4KokceHJEjdE4wWFrtZpCb//JsD6ro+8n4iT Lrx7fd8ax95iRvdm6QnvhRJJyZqhs1cGlk+YvOahs1cFlk0YOWrMbS6b0FJoNeW0lBa3FMbTg327 L60tP3doRd8jl9ROOXfo/PKemd70hp5pwKz0GT3oc26XeMLuDfvcrYPVLqhJvE5pU/qUvIZXsocQ eE85RJsFpeCpdeuM9hqj6LPIepjPnm57w95W/v3yY4YoPnJO4l5xgci4XfDkUUbFxiVFGzOywMkn ONdZOgFeaJPsFpUUNsS6FG+8Uh4lN6SUZB7d92339uROcet4uUKpNrLPqWpCB7nPYPQ15OCxN17v 6BtvhZBM1BIv9R4ogq1Q+b6hSGCTuMhexPHia6quhJawz5Cs4qvqAfaaWmvSs9M+MVG9xPTZqFvB PuF31XbxZXV+u0c/3A6/x70IC/Z/8d1+wPsx91lx9xXNuXOqs01qSZRaofII/sLkgtRY1+T6pvrJ rtx5l7RkNAiZMVESnperoxTu4rrs5Fy73l3a0NRQ6qZJ05fPSNWZLcaszESnUR6XFK+NT4tP8tgT kjOF2WXC6dMz1NFGnc5oM1uTY+VGi1Eb74y1ZdgTHJlCG3jJHPqYu0IySCaSjeilhwwGzaR04sxi TwbzcR/C2LY7qxM1EYWGHfrN1Tnse2WCPGwcWGDPi8sy72ju3lwDHsd2kqwf0gjuVJLw54DsGY2v WpE5jMcsGfvYyxQ5dnFXqKKdvqKEujOrk0+PiWXT8jRVIu5gT7CJGhvzpHdSrD3OIJepZNI1mb4Y eGq7G1bNpL/yFSWmmZXPwINTKoUH5zNKc1pikW+kvaZGrpDLjSlgrdXsfYF/Gnbx08MrWpWKLws2 br6gi8mqSVVJ42pSLJEH3QnHevEDBLZlie8F2u9T/GTvAKPr2CDuWIVFx94GnlPGpdsc6RbYmGfO XVvvEAcPSzraBdt3Z1HkLSB57J7cfdliblQxElUlbuBcU0QD+/V7oU85Iu2GU0w6se2GE+UQscOJ 8ooHVVKXtV5fRcrK3nwhvBdHPrDlj52wTvg7zTtUGeeBDSZO+X/snQl0VdW5+Pe5w7lD7r0JeANJ wHgZhIQhRMYIYXJAZZAIMqivQEaIZOLmBhIMEK1PqY9SSm1rqQO21jq0SK22agejIFIE9AnGoMKL oKI20IgSeUBz3m/vc25yA/hKu/5rvfVfK/fzt+8+5+zh29/37eEEMFqK77JRaWkjL/M7/X1Gp6eP Cfn9oTHp6aP7+LUnoicY+zp/0K+7/Jf4z8xMz+obH983K33Qlf3i4/tdKd9FKo0v7HnoNlJcL6b9 UYyyvSgmCqdt8u/iJyLpKS/YvjMpQaT373+ZJ/hbpzPTc81Y+Rebe/0mE7WPobc8sshIbV8tzJ/k xP5B1MCBA2TsmbP5vDf9c/cTe96wOSuud2tjRvYZmuLTPJo7MdQjMGrG8J69xszOGnFj1uVe5rJT D2bduGjk8ieWDm9r9PcZkzaIUWOFQWlj+vjtH8y6e9FY97bu3e3uQFxzKC3J0zdr+uDMnLGXBZOC nqQhffuFgr16JkwuW392/rlGsYnNxpfaS/Zn1P7a6zci+ILthd97U/txGIi/XkzcM3EPE1T+pPlc zbud66qXAtIto/v4fOZ34Nxre49BWf3j4/tnDRo8tn9CQv+xf79+0JXyxpWDBo2T3+Pk6WcV+jyu pYk44XnWY5+OCldkXh578H588s03T5o8Z/akDd+aNHH+gkkT5f/rpNb4yjlK60OtnqKfGPSySCLu UoUPD3fH8y/8Xu+T6OkVL9sbMWLP8OEEoJTOTTu/Ia/9aELOzPES7a2JM3NkboL2prrH1XdvmzB+ 3gXAtjX2Att7zhXRuZBo0+X/PsKm/y7d2WvAdQnXMRf2SFUajsXYt30yRO8MtA9QLyOJtm2exL4p vfrhVF+vIaHQkF7ethJPsF9Kr76Jbq2nJm9OvsK+Pvojee3l6ALVNrnzvcREtOvPOfMjZ1AMEhni S+uNI+jK0FyDNb235krQXAFN92txmfLFOC7eNkNkavH2jD4JL9gWPzfQ4RBDX7J5RA/jxCQ/D3v0 yhioFqeBL2hzn3MkJHgHv6AVPjepzyxv9I8gmDgj/j54OyMefGzPlTKshqvXl8HqDYZ3mEmjB8Zr AzO0gYO1Ab21gQnawIA2wK9dQCelysX3iHnpx+rG+qj38H6J7QtmHyuYx2jWK0E36fp+Wh/7R4nd K32pmQP6X3FpXFu3QI94l93l92obnUmDrxo24vrBwcqEnm3FtrantXlaZMSoz6Or4eeu5GEDQ8MG 9L3E9prH73HIPy46e/IK291//7X5N4Qe/seiXXGRsvNfF9u6ixG7B/l5VBwL/yVp7pLO4mz8ZtHL zheX15KG/0txD/4GeSRGPuwQz8+9gzrJQ/+bxPW25G/ni++ef0X8ti7pki65CMlR8t75EugbGB9Y +38o7/7/JvE/7pIu6ZIu6ZIu6ZIu6ZIu6ZIu6ZIu6ZIu6ZIu6ZIu6ZIu+ddE/Tmyxn/zSceIeuEU 94nu4hbjCzFAdFepmV9gfExaYxwVAzSbsZM0QeVTjGbSVOMw6Sp1Z4NM7fONhWIe5feJeZRvJE0w 3iNN4ek8yv8X6SqVbjA+J90k4sU8aqWKW0SNcIhbtGIxUyyghWNcdzdeIr1FpQvosYZ23iZNNQ6Q rlLpJnXneeOgZiN/TEug369IVxmtWip3TmhV6v5yla7j6T7SBOMIKVqRphqfka5S+Q0yRZ/p8rdq cH8T5ZtJE4yPSVPUnVTKbKK8vL/J+NQ+Hz0Pkt5iHLXP585ebDvU1lcI67eXFKjUriweUFcybxNu +yAR/a07Y+0OK+8QSfYUK+8kP8HK6+TnWnmXOG0vs/JuMcj+kZX3iJBjiZX32ja39xUn5jrWWnmf GOQ4ZOX9tgecbisfECWuze2/A2e422flNeFyT7DyNuHwPBr9bTfiUs96K+8QPs9PrLyT/NNWXif/ eyvvEqs826y8WyR62qy8RyR4J1l5r5bT3lecGOzNsfI+kei9w8r7teneDVY+IEbHfSB/S5HDY9nZ zJt2NvOmnc28aWczb9rZzJt2NvOmnc28aWczb9rZzJt2NvOmnc28aWczb9rZzJt2NvOmnZ8UITFc ZCJZ5GaIYpEvwqJcVEKRiHDvanJhUaHSXO4UkysTGTyZLEqQkJjFvcViCc8q1VUh34WUXk5aQMmr qVdCmTzuFVOiWJXLhVLaKlBly7iq5F6ZembWL0aDEORSTv5mmxquVpCL0JcsU0WLEe4XchVWvyWn jNaKSRerVsqtViOUKLX6lCVCjLFc9Sl7qVRjuUGNtYg7coxV3C9UNcLqTonSOmKNI58nQ1TLpepO iWoxFxuZ96O9lNJOibJYhaVlGXdKVa9mm3KckRgNZI8VaiymvaPWNnWXPZVjgRDjNy0utSqlrPzd PxF1JUccafeHaTOzl5DSvcwaV7mybZ4q2aFx7Iik1apVPXPUS7nOUPEQ682BqrVS1UKNskOV5flY e0uPmeMvVPrL8Zt+CatokN9mj9LXIdqoaB+NqeNiq0wlVyut1iOMwvTQ8nYv5aoYyeVuaadxRaM5 H01yVf/5Vv8ZF4j6seeNMySu4lkJrY1tnzGjxFwrgoqtWBtFa6N52rnu0Pa6F54JhVZMmyPMtca0 WD01dSy0rCj1LlDRLMewVPkxWufCT4v+qVndEUGmv+ZwVax0kP3PVjMg0sm3wywNymNGkG/NxYga ZaGK7+ncyRdpyu/plClQ7V+ntDLrRpAKrDsMWaEkQ837zppnqNZLKRMh3qT+i9UIKmihhrvSq0Vq LHI2dW41el+uKKYHlra3d4vS2YzkGhWBlUrDiJprlWptMGuH1BjkPC1UUVas+jAtlKfqRq13Lfab zipp1g3HPDHneIGySce8XaH6ylfz+kL9mteybD5RVKVsWNA+DwrUc7nSmCOIxn6FGmmZFf1mW4Uq lbP53HHL5+aqkUatdBWdpYyrsH0en69V2XktX7yNOlqPrtwha+01oye/0xp4/tg74rWzXuNiLCBH Yo7F3AmiUR9u31UK1LpaptbX3G8cqWnn3E42LbSi/9w5IK0qI69K1SxQa5QcTWF7O7JkiVrn/jcP /b+aFx1zYpjSRs4Bc3fKUL6qENVPhoZnZmaFZhTnh8sry4sioavLwxXl4dxIcXlZRmhySUloVvHi JZHK0KzCysLw8sKCjKtzS4rzwsWh4spQbqi0vKAwXBaqzC2rDPG8uChUlFtaXFITWlEcWRKqrMqL lBSGwuVVZQXFZYsrQ+UUjRSWUrOsIJRfHi4rDFdmhG6IhIoKcyNV4cLKULgwtyRUHKGP/MohocrS XDTIz60gL6uUVpVEiitosqyqtDBMycrCiGqgMlQRLkdvqTatl5SUrwgtQfFQcWlFbn4kVFwWishx oBlVQiXFZfRVXhTKK16sGjY7ihRWR6hcvLQwI2QNc2BlqDS3rCaUX8XgTb0jS+i/cEUonMtYwsUM m4q5paGqCtkNLS7mTmXxSopHyhnQcjmk3NCK3HCp2Zc0c/6S3DCKFYYz2k0/Ntpn6KrykoKx0jGj 5mIghhQalTF6uPV0qHwa44RCLE2HufS0uFhqVIiK4dyCwtLc8NJQuXwSc1l0YVcrAzGuOWXFEerP juRGzNEOo4Fy1UE+XoyEiwsrM6ZX5aflVqaHCgpD14XLeRqJVIwdNmzFihUZpdHGM/LLS4dFairK F4dzK5bUDMuPFJWXRSqtojJflMsAlspyt5RXYeSaUFVlIUowJPk4lItPC8OlxRGpUF6NUu/aOdMn 8zSsLvB4QZXp2xVLivOXxNTlu7gsv6SqQNqiPFRQXFlRQgfS+hXhYgrkU6qwLJIRivZdXkZopBWn hwpL82SljqbKooUvqJEqLoMb81dinnwzAtt7V3a12hqnFEgrphcmgTR9WE6VgvIVZSXlubGdonOu qSmGb/dAeVWkoiqC2ZcX5xfKMksKSyrOGdDF+EJ5YlhBYVEu0ykjt7KiOvqbLo0Z4qUL/E8q5XuY nfcOL+/LLsMgtVlvWEJL43utEO3vbhf+dLe3+HwaZbStF1ve75flbVkXWz4+XpWvv9jyCQmyvP36 iy3frZsq/9bFlr/kEsp3V79v1c37niwv37J7q9+xOkD4xTUiRcxjZb5FZIsFYior9jzNJgq0BFGu pYiVWqq4V/uW2KgVi81audiqVYk/acvFTm2V2KetE4e0DeIzbZP4Snse50zV4uwztCT7PO1y+3wt 036LNsb+Y22CvUWbgqqzO+uhzfsn9ViLHj9Aj0fR4zfo8TJ6vIUe76PHJ+jxBXqcRQ8PegTRoy96 ZKLHOPS4Cj1uQI+b6HdBZz1sz8foEUCP3ugxAj0mo8e/ocft6FGNHnejxwb0eAQ9nkaPl9BjN3q8 jx7H0eO0tk7TtQ1ad/nzEfQYgh5Z6HEdesxFjzz0KEaPMHrcgR7f6ayHY0KMHvHokYoeY9BjCnrk o0cYPe5Ej++ix0/Q40n0eB49tqNHA3p8gh7/ra3SnOjRDT0uRY909BiDHlejx2z0yEePcvRYjh5r 0IMY0n7cWQ/nOzF6JKBHCD3Gocc09Lhd/j9Z0eOH6PEz9HgGPerRYw96HESPFq1K07TlWg/06Ice megxHj2mosct6FGEHivQYy163I8eP0WPx9Dj1+jxp856uDbG6HEpemSgxzT0+Df0WIUe69HjafR4 ET1eR48D6HEUPU5p5ZoPPVLRYxR6XI0eN6HHQvQoRY9V6PEf6PEQejyDHn9Ej23osRs9GtDjqFxX 3E7h1it21vPZWaEuTtXXn5KXbo9we1+pO4J8XfdO3cG6vyCqREtjY2MLJTxu4XbX7lCfWnu0pZbq pAcq3Lpwu3bvrs7MrN69W3cKXW9Jqm5srNYdQndWyObNzpLkXXlfFqlopONqj0147PX1ol594uyG x75okVhkfurd8mc89dZHdwvd2/q+/Jh9yLYarbb4VOh2oTuazLJmz00VmU0uh+FyLGqR7WWqwqpa tdumuR2qLH2bA01KqpBd6zahS5W4b7MJG1mbW9g8779vt2tu5+bNm+Vw9ays+fMfOJuU5NY1t6t6 u2xoe7XbqcWaVHPHnWdSWfzU7t27TymTam7PN5jUhUl3lJRkZZWU7LiwST268Lh8Pl8tre2u1XWh u6p3n62vr/3fbWo9jRrVK/S4M3W766Oi2pEK4kmzST5mty3nmtbtIKIWRW0rS6t6KKB5TNtKJTxO 4dErHoixruOC1pXF8IwKpqh1PS7N487OU03lZXt0zeNihKZ9PXGax9/E54um/1z0PrJr0V5EFnKr AchScR7N483mdL6tXYqE+olgncdJa9i7qSILgxPeHve2oqLspOyiom0uXbhc1eukbWtdTs1lTpqd FV5d87qjNueRrrncWOgsvvfaNK+j3er1frvwOjrMjuGtAtGPy6u5fLGW312vmjNtvzvatLS+y6G5 LOvXy7yuzJ/ZJC2L/U+p9rNUDbNyrezLWd/uAq9T87pMF0iNXDbNpXygnKDZyNu8whYndXDIonKG qPBKijrC62Lg2asPywYPr86WdnCdxRWnlCu8Ps0baKpo4XNgq5Q3M9/M3IHIap6zbcR3m/Sbz6t5 4yaINeJI3SuWHKlbIybWaWipbFt9dnv9qVrfurPVquqO6BTYYdrmLJY/qzziqpY9n6qOc2lxHp3P ctXLctNuZ3HJ2dp/4JKm+jibFhfjEuUT//t1RqxPXJrL80GbmqMqX6v6MaOi8VSMT1rqF2W2KJ/o +EQ6pTpL1VB125bLzqI+kTrF6SLOVX12nc+XlZkpMjP/gVfilFe8LuF1987OLinZ3dbm88W5Gf2E NR+qNj9cMyFO1+Lc0i/1KqmP82tx8U1ZTVkt1S1q7d3zwJ4H3nzg9aTXk5ThOlxT74/T4nwTxZq6 D2MM8mH9mrqJ9aJJLFItS+80VfeW7onziDjPK3X5bOKjkd4qlVevqDWOouuYJGdLzPWRevXbz1b7 XJqvw1nYxO2SK2Dbjrb6V9tqLW9E3VUfcBhxDmUa69PS5LNpvliH1bt9mjvwQZPRclTFmymq1Q/a PlGGj3ahvKYW6MZTTWZdp1TtlFxwT7V4ncIb9RuOU7V2WJ7z2Ww+vb1L9PPpms+tXNe7w3fOGN85 pe80m8/ynU/5TjkrkDp6dFHRDsPQdZ9H83kvw+KL6mi0XRbVram7TChTtbW1e7LeF9B83Zp6N/Vu yW7JbixpLJET/fV1r6/b5tvm87lp6mzb69u2vW56M+DTfH7arl9Uz3/tsgh/XlYvWkSmaj979av4 Mzug34NvPMLnjXVorEvlOowR79FXS3uoJTar9iP6+ag2y+/W/F47n3Frjm7btu3omnHsayy6q49u M2RMSp85Y9xaH+8wfM5Yv+JYv03zt08O9fH4NE/8uZ7dkanaPmQc2aY+7T3R7+pstaJHvVuvtCTy CFgZr3IGRf2Lg1VNs5HXjTv8Npu/w8NSV79L83uqz67X9UC2qas8MZg+jnGyT7MFpFpOp+Z3q5OF ckUgtUfUy7qw3mi84me2+cKeXxMuEcHF4cKlYmxJbqRMTOeJNnvWVSGRxFuiod5kdN4dgtaVJlyc 4BPVffMOpyLO0j0Q+w05OdeL/rNmzgiJzJtnTQuxt5ll5Dtlgvr9BQZ5r+jW3rpDxHH+TLaunMIn LuEtpVd+RWWFeEylT6l0q0p/p9I/qvTVpYXhMrFTpXtVul+l76m0SaWfqLRZ/kREnJCppqs0RaUZ Kr1KpXNVenvp0tKl2mqV3qPS9Sr9kUofVunjKt3S/mb4j1LtIlMOHtiG8wwWZvvHLv9392z4wf9P fwd4n8oQs9RP3+8SG8XPxLPiVfG2OCxO8B7hUSN1W6NtFvLPOu3UCzK3Nfk+oI01v9fuN78f2hRT h3g7mtLpWnNGOl/rD3e+9tzX+drXvfN16vLO133Oed53Y+frIU8Ijy3memhJzHNdaBOf63x9rY1v LzGdJnIYT4A6d2GqTFuOWGN7zPau2Gx/yP6Q2O+IOB4V7zj36Ws1u3e2N1d70XtvnKbt9CX4rrVd 7bvN97Ctxl/gv932J/8a/zrb9oAt4La9Hfg68LXtgNDuzJG20ff5t15QdiH7/Ydi5CNLdl1Ajgd6 t0tfZCQyASlQsvFc8e8KPBjYkrDBkk0x8piS0xeSbo5uU9vl7m7r26XFlO49LiBpSEbw/hh52BT1 5BwJ/ir4arvsTHwPaVLSdiHpntbD16Nvz7stuS9G7lfy6gXlrZ6no5IUTEppl2ssmXpByVEy1/ru LHVWKsvtULK/Xczah5JakgclFyQ/nPyElHNbT95yITFbT34h+bAlX3WI7CX5tOqrTnLp9H4Z7TKp 35R2mW/JAiTSb0H/AcjIy/tentVvAWnfy3834I8Ddyn5NO1GpCA9BQmlN6Q3Q0P6iUF/HLxRSnrD 4K2DDyGnhtiGuIdsQXZmDEeuybhx2AZLnr0iMiJlxAcj7xmdhgwf4xtz45iSrMct2Zr1UtbOsanI kLHLx+3ObpUyvnb8FiWfTkidcL8lD4//lOv7JzSqq8YJnyP3TwxOWj7psck9rp2E7LguZ3ytWZrv RrPUDQNkuRtGTvVi1AFTN0wLKMmaNkvJV9Nt05Om9532FbkcpGiGmKHPKJjROqP1xt43fkK5rJk3 z7x5eg5pnswhS2aGZ9bl6EqG5NyoZFFOGSzKqc65K6ea5+GcxptuvWnRTSduOjErYdbDlBvCM/Vk 1qmc6tl5s0vm7J13zfyGb2341qZvPbb4rsWNS+YuqY5+L3lqyVPFmWXryzZXtC4TyyYsW7Ts9mWR ZXct27rs1WUfLTu+7FRYDwfDg8Ijw1eFc8LHKxMqB1RWVK6u3FC5o7IpMjZyc+TZSFNVStX+qtPL M5cXLa9evmn5cytSVty84tnqJdX3VT9Xvbe6qcZb07tmSs2Gml0r+6+csnLJypUr7175+MqtK9++ I3jHlDseuOPZO3j/r02qnVpbULul9tNVg1ZFVm1Z1bQ6dfXI1bevXru6YU1wza1rnljzSV3vuj9/ w6q19dyVqfO6U/dRh8gV5c5Ah5hryTfMvqnnzrnOM8WM9QuuP9E1KEY6ryJ3juwQuT7ceVWHmCuD XE0THkva0fN+VuT9ExpZP9VqrL5ZebtNZaXdGHgwYYN/V3T17Lbev79bS7/5sq5/a2BjxypqWol1 eoJaic1SvQMPRq0n76pVWZbdL5+r8pYFaXer/xBr+oPU2K9a24V2G/jer6Rjn/jonP1hQsyO0LEn PCj1Pm8feOzcfYC132Gt+3dHV3zVDrUDE8hvjK6F+OMJy1+sTuYKZK5wlh9ZFVkDpdfmt6+PUY+y yiVNleU7PNxvCu3I519xPyf5MNfnRQNr4P6Y1fQCa2zsmnr+emqt2jtUHJkr6KTo2inXdO5Mke1y PSUpZ3TazJsT28ydTH2za/U8zV7V1sPHPmTtPNEdpXuPxLaO3ceMR7m/yfKJbbIEtV/t4ZNP5B21 l3FHPuvew78rGqdJKTxvogfa6Hm3ulL3O3bU2D1V6qT2z+gO2r6Hsmf6LrBn3n/envmWuVOyRwaj Y+H5aVMPpcnd07IS30u6Bt06eUNa8dyZG7W4OSOlbc2I6Tcf60+VvpV2ScoJ3q88/4T0VMzszkje 0r1H+16732q1zowH6RczvpK3XN63/wATc1frP0DtRDEidzVzR1N74r8oah+NkfNLqN01Rqxdtl3O r6F2139K1P570dK+S3+DnGspKe179zeI2s0vWtQJ4yLlXOuoc0mMnG8/dV6JERnppqf/OTm/5X+s 3cWJaWd5Xgk8mN061Tv+U/9+edJRUivvZLfK0428Gl871SvPPeYzKZyahsiTknlX7UWfm6JORJPU aUqemxonNKozkTw3NVKjVp1H9PZzi5QhOfrMvBxdnlnU1RDrZGPmh3DuWSLvqNMN9eS3FFmeGrpq bZF6OkSmyVsoPUSen3r4pgVm5smzljxnKclSdwLynKWusmbmyZXIeobIZUKeyNQJzabOZogsTw15 gqOkPI11nM+mZU34XNnjU2mJm06YdshuVaNBX1PP6TmyZXXes8m2zHY7z8Pz/RkbBQN3mVdC1+qN vfYZxq/sc0Syfb6It4eNo/Y/i3Rh48kbXDWqXLN9jnFUaKT/LWyk++zzjX28mz9ttIrtRqu2SPTT csUcLY/vfJGmFYhUbalIpeRN8m/H20uMvwiNdj4WDsrGUzaVsvGU9ar2min1hfBoC0QKz4fyfCHP h/F8KG0Np600av9S6RNH7ln0TbXXGq/YVxmPoO8I+xHjUftHYqj9YzHcfpRnnxmN9s95241qe1g4 yF0m/9Y92jxNS/tEtYgXo0QCjBV9xDgooP1CKIJK46CIoFUVLIcVUA3yb+yvNF4Td0AtrILV8G2R LO6Gf4d74F5YC9+B++A/YB28yBv4S3CKfBsYIlkToEGOyNJuglkwG26GYjFT2yF6MuKF9rki236b 8NkXQokos69hpHeKfvZvi1THI8Zrjs3wKLwtkh37YD+8Aw3wLjTCAXgP3ocP4KBIdiYYjc4m4zXn X4XD2Uz+GLQYr+lOMUpP53uE6KOP5rvEaNRLoQzKoco4qC8HbKNjGx3b6CsB2+jPiCx9K/wevhZZ rkGip2swLBTJrkWQB8sgDDVQB3cCNnJtgO/DI/CoSHM9zfcxOA4t8AWcgK8BG7rzoQAKoUr09AiR 5QmKnip2jxPXXpX7DK+fEolE7S6idhfR1o9om0a03UW03Uq0LSTacoi26yldT7xcZZ9LrMwzniJu 5hA3a2khYv+zscl+hDj7WHjtnxgv2z8T01ScHaXUJ6Jb+6xYILJj2l9I+5W0P4f2J1M6z2p7O7XG 0/Zm2n7aai9HBGJa8dLKGFopo5VsWsm25sQYtDxKS7Np6fu0kkMLL6uR/l7lkmjjT7TxJ9pI0xYa L9FONu0U08402rmVdqZoxcbbtJWtPWA8T80/0F532qtBs0raTEGzGlrbaD9sfIF22+2fMrM+I+Y+ t2asP2bGDqXV4dbslzP2HWoeZObNMB4ifuPMFUb+TJf7B8RPxLeNZnE3/DvcA/fCWvgO3Af/Aetg l3FGvAG7YQ/shTfhLfhPeBv2wX54BxrhoNEmDsF/QRN8CIfhiPGW+Ag+hhPGu+JL40PxFZyEVvga ThnviP9mTp+GM3AW/g5t6GIYzZoATa2Kn9hvNVrs/2a02hfwvchodbxtNDv2wX54BxrgXWiEA/Ae vA8fwEH41Djj+Aw+h79CMxyD4/A3aIEv4AR8CV8BujjawGDOdjfeck0yzriuhakwDW40PnTdzPcc uJXnt8EC4zXXQqPZtQjyYCnPlvEdhgj5FVANNVzX8l3H951wD/l7AT+4vsf3Br6/Dz8gfz/8EH4E P6b9R7j/M/KPkX+a/DPk/wD4yIWPXPjIhY9c7xttrg8AH7nwkQsfuZrQ8UM4DPjI9Znxrutz+Ctj aYZjxjuu4/A32m6h7S/gBHxFWXznauX+11zjI3c+FEAh/rKJ9SKIp04Lu1hvHGjfvZxcvciV/JdP q4jyRvuboq/QuNsqriEyG4jMBiKzgchsIDIbiMwGIrOByGwgMhuIzAZKHyLSzhBpZ4i0M0TaGSLt DJF2hihqJmJaiZhWIqaViGmlvz3012T/FjMhF/KMj+35xsdETQNR00DUNBA1DURNA1HTQNQ0EDUN RE0DUdNA1DQQNQ14shVPtuLJVrzYgBcb8FwrXmvAaw14qxVPteKpBrzSgDcasPoZrH4Gq5/B6mew +hms2oxVm7FoKxZtxaKtWLEBK7ZixQas2IAVG9SM3SNc2DKLmayz9z7E3vuA/S3Rx/6forud3UbZ 96hl3w+Vfb/D1ZVcXY19q+XZQsxnnwyyTwbZJ4Psk0H2ySD7ZJB9Msg+GWSfDLJPBulpKHtlCntl CnP2EHP2EHP2EHP2IHP2JHP2JHP2JHP2JHP2JPtpPHP2AHP2AHP2AHP2AHMWf7PazhVpzNNjzNNm 5ukx5mmzPU8MsedDiSiw9tHL2EeD7J1B9s4ge2eQvTPI3hlk7wyydwbZO4PsnUH2ziB7Z5C9M8hc PMBcPMBcPMBcPMTcO8mcO8ScO8ScO8AeF2SPC7K/BdnfguxrQebKAfa2IHtbCnPlAPtbkPg/RPwf Iv4PEf+HiP+DxP9B4v8k8X+S/S+e/S+e+D9AzB8i5k8S8wfYA4Psf0H2vyD7XxBPzTeOyahnjMxt TmnrWb3nsHfNNQ6xqv+U52vxx/M8fZyYH25/mzyz0v4O+5j04buUPkipRlbq9cZqrmqoe4C68m6B tQ/uoe5Q6u6l3hShU/JxSq6i5GFK/hclb1enLBk5T6mWbuP5DJ7v5bmMkatoaR1PH6WlNFraTktD VPlmdVo8otJW9r94zoK3QgmUQjlUwDIIQwTuE8NEN61ezfUHaX2j7F15djP8QYy0vwKHOeceEVM4 K8azfwc5KybbP+X7M05Wn3Pvr5zM7NTcS40enCyT5c5O/RKRzT52K+eu20SOfYE6g7FLo1kamqWh WRqapaFZGpqloVkamqWhWRqaEX30cRsntgV8LxRlqmaQmkFqBqkZpGaQmkFqBqkZpGaQmkFqDqfm ZGoOp+ZkVTOemvHUjKdmPDXjqRlPzXhqxlMznprxVs1pVk15RrkNjy1kXkkbv6ROCqex1mH5bxDZ y2+CWTAbbhYeTnAeTnAeTnAeTnAej/x3iw4s3J06t8t/L6rO49JHH4n9WppxREuHQTAYhsBQyIBh kAlXwHAYASNhFIyGMZAFV8JYGAfZMB4mwESYBJPhKrgaroFrYQpcB9fDDTAVpsF0mAE3wkzYZBzW fgoPwsPwCGyGR+Fn8HN4DH4Bj8Mv4Ql4Ep6Cp+FX8GvYAs/AVvgNPAu/hefgeeNLLHJYe8U4qL0K 22A7vAY7uP+60aDthL/ALngDdnOe2AN74U3m7a1E7gJjn+M140vHDngddsJfYBe8AbthD7vBXnjT aHB2Mw47g8YRZyL0gJ6QBMnGEf178BPjsI4N9IeNZv1x40v9l/AEPAlPwXPc38b3dniN/FtGg76P 8pxb9FbjiOtS47ArFS6DEPQxvnT1hX7QHy6HAewcAyGNdSsdBlFuMFwBw7kewbNx7DbZfM8yvnTb jCNuOzjACTq4wA0e8EIc+MAPAYiHBOgG3eESCBqH3YnQA3pCEiRDCvSC3oD+bvR3o78b/d19oC/0 g/5wOQxAp+GcG0bAlex8Y2Ec9ybBFLgOFtJfHt9FPFtMuSVQDLdDFW2sgtWwBuoo+z3u/5zyv6T8 E8ZB95NcPwUnuHfSOOLRjMMexuq5xGjwMA5PotHsCRFD1ZqNaLGDA5yggwvc4AEvxIEfEoyjWjfo DpdAEBKhB/SEJEiGFCIs1TimXQYh6AN9oR/0h8thAAyENNaadBgEg2EIDIUMGAaZcAUMhxEwEkbB aBgDWXAljIVxkA3jYQJMhEkg17Or4Gq4Bq6FKXAdXA83wFSYBtNhBtwIMyHH+Ey7CWbBbLgZ5jC+ uTAP5sMtsIqxrIY1UAd3wl3wbbgb/h3ugXthLfDWoW0wTmvfh43wA7gffgg/gh/DJtbMn8KD8DA8 ApvhUfgZ/Bweg1/A4/BLeAKeBHZD7Wn4FfwatsAzsBV+A8/Cb+E5qGctfwVehW2wHV6D12En/AV2 wRuw2zjOKnKcVeQ4q8hxVul7WaXL2QeSWfmz2QeSWf2zWbXfdbDiOVjxHKx4DlY8ByuegxXPwYrn YMVzsOI5WPEcrHgOVjzHFuOY4xnYCr+BZ+G38Bw8Dy/Ai/AS/AH+CH+CP8PLUA+vwKuwDbbDHhHv 2AtvinhnN+F1BkXAmQg9oCckQbII6OuMY/p3WYW+R/5H5B8wjuo/EV4dH7CaHdc384yx6L/gGTrr 6Kyjs84qrT9jfKZvBfTV0ZdV7rj+O8r/nnsv8vwlQF8dfXX01NGT1e+4/jpldvHsDa53wx7YC2/C WyJe30ffvOHpvOHpDdx71zjNSnlcfw/deKvTj1L3r+SbyXPG1jlj638D3lz0Lyh/Ar6Er+AktDK2 r43PXAHjmCseEqAbJBmnXcmQAr2gN1wqvK5UuAxCMIBT4UBIg3S4gnvD+R4BI1l5x8A447grW8S7 bSLgtoMDnKCDC9zgAS/EgQ/8EIB4SIBu0B0ugaDwuhOhB/SEJEiGFOgl/x4moKcbPd3o6UZPdx/o C/2gP1wOrDPuwTCEFXEoZJDPZOW8gvxw4zgr8XH3SPKj/4e3e4+Pu67zPf7rTJq0k4QolKvIZWEV dBFFQBdcXdbdRVS87K6eFs9qzllAWm4qbSBoAW0VubXcWooFrBILvSyKUnZpzrYbgdpQOw1Nk060 adK0zkzIdKaT/JraoHzPc2Yjh/XsPvbs43Ee+8fLueQ3v9/3835/Lt/f2AS8D++vdGZxXICPe34p PhFy0z7pc7PCxLQvWNuVfvZFn7sKszEH7nSn2VdOuxHzXfcW3IrbHH+H66l5nbo4banHZc71ML6D 5XjC+Z7EKj9fjTXeix130GdfDRPTozA8fUqUmj5N56bh9JTHN3v/qKhJNy9ON5WmH+u943B82D/9 BJxY+UayUt2Te6k7VOVQdV+28fX3F3p/QfUblMoeqxxNTXwkfDZ5aeWbqShV+Var+rM/Srw7ZBPn 4n0hl/iQx4+EHYlLwouJj+HS0OVMGTuKrB1FNjUzvJi6DLd7/m3cgTtxF+7GPViExbgX9+F+PIAH sQRL8RCW4WF8B8vxCB7FY/guVuB7+D4eR1vINrwzZKOklY4nZrobrqz/QuuPrT9OXBAy1h8nPuzx jrAncWfYo2+domed4sgXU38dMqm/wWfx3/F3YU9qDq7BdfgS5uL2EIstFlsstlhssdhiscVii8UW iy0WWyy2WGyx2GKxxWKLxRaLLRZbLLZYbLHYYrHFYovFFostFlsstlhssdji+o+GPfUfw8dxKT6B T+JT+HTYI/aYh+8LOzmUSVR9DO3V7yJOFvsaca9JfC60Jy7HtbgjdNKgs3I3IvY1Yl8j9jViXyP2 TrF3ir1T7J1i7xR7Z+qm0J5qxVfxdXwztFtXp3V1WlendXVaV6d1dVpXp3V1RhdxoIUDLdaW5UCL 9U3IoLIMKlvnL6xkyEqGkp957ZD1Nk3ezZw1eTdz1uR3hBnZVZZdZasbsrohqxuyuiGrG7K6Ic60 cKaFMy2caeFMC2daONPCmRbOtHCmhTMtnGnhTAtnWjjTwpkWzrRwpoUzLZxp4UwLZ1o408KZFs60 cKaFMy2caeFMC2daKDBEgSEKDFFgiAJDFBiiwBAFhjjTEn2YCs1UaObFNio082Nb4iPRCaKfJfpZ 3HqXu9fvTd5Dv3dyrp49OVfPnrwvbubVNl5t49U2Xm2jxixqzKLGLGrMosYsasyiRjM1mqnRTI1m ajRTo5kazdRopkYzNZqp0UyNZmo0U6OZGs3UaKZGMzWaqdFMjWZqNFOjmRrN1GimRjM1mqnRTI1m ajRTo5kas6gxixqzqDGLGrOoMYsas6gxixrNUZ1cKIv4TBHfIuL5Ij5ahNeL8HPR8TR6mj5P06aL Nl10aKJB5f8/Wi3+p8X/tPifFv/T4u8Sf5f4u8TfJf4u8XdZR5d1dFlHl3V0WUeXdXRZR5d1dKmV 2ZT+1/1uNDor8WlZOlOvm63PzdHjrsY1uC70VL+5+F2vm69n3BperP9qyNZ/DfNxC27Fbfg6voEF WIhv4lvQG+v1xnq9sV5vrNcb6/XGer2xXm+s1xvr9cZ6fbFeX6zXF+v1xXp9sV5frNcX6/XFI6Yj hXo9b0r126/K2mM13qfG+9R4H93q6VZfrZ6bQp/a7VO7fWq3T+32WXts7bG1x9YeW3ts7bG1x9Ye W3ts7bG1x9YeW3ts7bG1x9YeW3ts7bG1x9YeW3ts7bG1x9YeW3ts7bG1x9YeW3ts7bG1x9YeW3ul Z80Mu6idoXD76z2rEtGu6BwRtfn5r/x8ghvj3Bjnxrhjf+HYdzv2AyolJdIzVEpKtGfIo3sqvZ9D 4xwaF2WbKNtE2SbKNlG2ibJNlG2ibBNlmyjbRNkmyjZRtomyTZRtomwTZZso20TZJso2UbaJsk2U baJsE2WbKNtE2SbKNlG2ibJNlG2ibBNlW3SeSFp5s5U3WxOzo2P4s1UEV6iAggrYK5J7RHKiSN4h khNF8g6RLBLJj3i3lXdbebeVd1t5t1VUraJqFVWrqFpF1SqqVlG1iqpVVK2iahVVq6haRdUqqlZR tYqqVVStomoVVauoWkXVKqpWUbWKqlVUraJqFVWrqFpF1SqqVlG1iqpVVK3qeGa1jt8viu2ieGby /4+t7CtWRvXi7RRvp1g7xXW0mI72kx+Kp1M8neLpFE+neDqj2sQ8HrfI4BvDcGKhT99jPiypfMfu 3cOJhWE8muJ/D0VnOuJQ4ibvtVbf35b4VjQ9cbtP28snlkZvSizz/sPhcP1bcCLeipNwMk7BqfgD XI4rcCW+iKswG3NwNa7BtbgO1+NL+DK+ghswF/NgffU3wprqran+5nC4Gs9hK80m5oeSWHKJB0Mx 8ZD1X5b4ir52A+Z59yZRtuLWsD1xG76Ob2Bh9NbEt8KGxGLH3Rv6E/fhfjyAZWGz+DbXJ/SyJGow FbWowzRMRwr1aEAjjkAT3oQ340gchRk4GsfgWByH43EC3hLKNCzTsEzDMg3LNCzTsEzDcv0FYXv9 hfgA/gQfxIfwp7gIf4YP48/xF/hLXIyP4BJcLo4rcCW+iKswG3NwNa7BtbgO1+NL+DK+ghswF/PQ ghtxE1pxc9gc1cicPVQcpOJwYml4VS4tDK/Ik0PRp7gQcyF+Qyb1mDhFE6foiCKV40Rll/Z3oWjC FE2YoglTNGGKJkyR+jH1Y+rH1I+pH1M/pn5M/Zj6MfVj6sfUj6kfUz+mfkz9mPox9WPqx9SPqR9T P6Z+TP2Y+vF/mMEftY6P4eO4FJ/AJ/EpfBqXO8cVuBJfxFWYjTm4GtfgWlyH6/ElfBm0oW5M3Zi6 MXVj6sbUjakbUzeOplF3QIaPy/BC4hY5vDCaQe0hag9Ruxx9icYdNO6Q6VlHpmmdpXU2cbNKnc+J W3zy1nBA5h+Q+Qdk/gFnqeXDFj5s4UMpsUjHvDfsVQF7VcBeFbBXLe3QGzp51MOjHh5t4dEWHm3h 0RYebeHRFh518KiDRx086uBRB486eNTBow4edfCog0cdPOrgUQePOnjUwaMOHnXwqINHHTzq4FEH jzp41MGjDh518CjLoyyPsjzK8ijLoyyPsjzKqpADKuSACjmgQg6okAMq5IAKOaBCDqiQAyrkgAo5 oEIOqJADKuSACjmgQg7weAuPt/B4C4+38HgLj7fweAuPt/C4h8c9PO7hcQ+Pe3jcw+MeHvfwuIfH PTzu4XEPj3t43MPjHh738LiHxz087uFxD497eNzD455oNgcLHCxwMOZ3Oxdjzu3iXIlzZc6VOVfm XMX/Y/n/HPcK3Csk7vLePZxeHJ7i4H4O7ufgfg7u5+ABDo7Jk24u5rmY52KBiwUuFrhY4GKBiwUu FrhY4GKBiwUuFrhY4GKBiwUuFrhY4GKBiwUuFrhY4GKBiwUuFrhY4GKBiwUuFrhY4GKBiwUuFrhU 5lKZS2UulblU5lKZS2UulblU5lKZS2UulblU5lKZS2UulblU4FKBSwUuFbhU4FKBSwUuFbiU51Ke S3ku5bmU51KeS3ku5bmU51KeS3ku5bmU51KeS3ku5bmU51KeS3ku5bmU51KeS/no3Vwa59J4tRoX Rk1cKHNhjAtjHBjnQOW+aYy6Y9Qdo+4YdceoO0bdceqOU3ecuuPUHafuOHXHqTtO3XHqjlN3nLrj 1B2n7jh1x6k7Tt1x6o5Td5y649Qdp+44dcepO07dceqMUWeMOmPUGaPOGHXGqDNGnbHoHTrDhM4w oQvvM89TibtEcXc1f6ze86VY5ucPhwkVN6HiJlTchIqbUHETKm5CxU2ouAlaT9B6gtYTtJ6g9QSt J2g9QesJWk/QeoLWE7SeoPUErSdoPUHrCVpP0HqC1hO0nqD1BK0naD0RXUXrQVoPWnHBiiv9K6cK cqogpwpyVf1/VwGLZfm9uuF9uB8PwA4+Uflm49/P9kF+DPJjkB+D/BjkxyA/BvkxyI9BfgzyY5Af g/wY5McgPwb5MciPQX4M8mOQH4P8GOTHID8G+THIj0EKFihYoGCBggUKFihYoGCBgpVqyKmGnGrI qYacasiphpxqyKmGnGrIqYacasiphpxqyKmGnGrIqYbc/0M1ZDmU5VCWQ1kOZTmU5VCWQ1kOZTmU 5VCWQ1kOZTmU5VCWQ1kOZTmU5VCWQ1kOZTmU5VC2OuNLdqV7ovNf714P6jj2krQv0P6/pqNcjitw Jb6IqzAbPBdjQYwFMRbEWBBjQYwFMRbEWBBjob6SC/PQghsh38RYEGPBHrdFRP+nZgoqPtZvK5U+ rqeO/0c1Yu/eYo+9UB5/S77e5fnd9kqL3X0vjY6MPkG5IuWK1V35fNziqIUe79D374T7PrVZmc5l nzqzurtd4vmyMErhUdldkt0l2V2S3SXZXZLdJcoXKV+kfJHyRcoXKV+kfJHyRcoXKV+kfJHyRcoX KV+kfJHyRcoXKV+kfJHyRcoXKV+kfJHyRcoXZV9J9pVkX0n2lWRfSfaVZF9J9pU4M8qZUc6McmaU M6OcGeXMKGdGOTPKmVHOjHJmlDOjnBnlzChnRjkzyplRzoxyZpQzo5wZ5cxo9W7lEKW2vH7fUo6S 1fsad9JcejX6DG17advLvxL/SmbpQT/dxYl6+ubpm6/2v8VcelBHWWKntMwO9uEwTNc8XfN0zdM1 T9d8qjIbEqGXrr107aVrL1176dpL11669tK1l669dO2lay9de+naS9deuvbStZeuvXTtpWsvXXvp 2kvXXrr20rVXTpXkVElOleRUSU6V5FRJTpXkVInuebrn6Z6ne57uebrn6Z6ne57uw3Qfpvsw3Yfp Pkz3YboP032Y7sN0H6b7MN2H6T5M92G6D9N9mO7DdB+m+zDdh+k+TPdhug9XNa7oPkLjX0dHJtbJ 5I7wYuKn8vL5MDfxs/B4Yiz8InEw3Jk4HF5ONoah5FlhJHl2eDJ5bhh8/d8pfzY6IfnfoqbJf688 xK02bjylwn4q+5+3h32BEy/iZyptM2e2eJ62F93ByR6PvchHRyeGTbGDPjfu84cw4WpRGEjWYRrM RlfPJd/j/XPwXpwXDiQvDHsbmkOh4YrQ2XA19IeG6z1So4EaDfpBw1c9zg/5hltwKxZ4727v3YNF cL/T8ID3HsRDnsuehkecoy2MN6xy/h/iR2Gk4Wn82Hs/8fo5j2Jq6PLey9iOnV5n8EvPd2HQcfvD QMMYDoWBxhkh33g0jsHJOAWne39O6Gz8uufW1Xh7GG68J4w0LsHDeNyO5aOTqu7h0atU3UnVfqr2 U/W3VN1F1RxVd1J1lKo7qbqTmkVqFqhZoGSBkgVKFqh4iIplKpapWKZgiYJ7KLiTgjspuIeCOymY o2COgnsomPs9BfdQsJ+C/RTsp2COgnsouIeC/RTsp+BO6pWoV6JemXplypUoVqZYmWJlSpUpVaZU iVIFShUoVaBUgVIFShUoVaBUgVIFSu2cVGoPpfopVaZUmVJlShWiUxOrw+zEurCWUpvk4G8o9BRV 8ond4Svy7LbEcFgps2cn4rBeZl8mz/qTyZBJ1oblyYbw7WqmzwhnJ0+O5iT/MNwu6/8s+a7wd1T7 qcz/uJxrT34wPJ68KFw++Y1U/+S/Sp6TnB02qoL2qMHVe/nU6+o/d7V9vEi72pCzF5xxzNl6na2s hi5UQxdFR1j3uE9t96nDPlWpj3HrPcenM5MVmLeu/dZ1ojP0OkPWGXqixmqkz9s5/Sz8yCfe6xN7 XG+XT3WL6FWf3ONTJ09+KuNTA9FbZVTJp4oyaUwmjcmiEVkUy6Jh1z4oi4Zl0bCsGJYVwzJiWEbE MiKWDbFsKMmGkmwoyYQxmTAmE8ZkQiwDxmTAmAwY5tgwx0rcGtPj89Hp1tIo3jb7utWu+4/W8Bw2 h19X/w3vTBlwUyg6f9b5s86fbXjY68dC0XmyUY1PHbbyK32ip+KsvrE6vMTzAe/2eDedkF1V/Xbr FzNo95nQ47w90UxXXeTo29RS1id+5OrzXX2+Tx6ixEFKHHSGnYkt7s3TrrODIj0ee5EJa5xxnQza nijIhhRmhJuSZmrSTE2aqcnTwoLk6fhDHp/h9Zk4y/7qXL5/yPOLQmw1l1jNJWouS93D1D2s5rIU PtzwpWhGw5dhp0aF+Q1f9Xx+WESJRZRYpO6y1D5I7YPUPtiw2M8f8N6DeMjrZXjY5x5xrsc8/j3l nkJ7WNDwgsefYyvS6MMv0O9nAx73YCgsaIzCTxunhjWNtajDqV6/DXPCYQ4sUntZbh5sXMqRh7AM 38GjYY2J3FHNxCFO/6Wu85qu85qu8xrXP6zCX1Phr6nw11Tza9GJ/CjTvkD7LO2zPtX4xt4k9rLY y2Ivizsr7qy4K7FmxZp9va/8Gz3FWsvWmX1jj5iScsV5MuCb3F/P/QXcX5D4J45uQIdqfSE6JvEi fqaHbJGn271f6R8ZU7HP3fcv8EvsQj92h9sTAx6HsFf+7fP4K+SQj74uW36ceMXzERScY7/HIkqu ewBlz0cxFm7Sk7p17JyOnVO9syu9KfGq936D34Ydidc8BlU9BQlU+laNbJvqeW34oYycm6yvVv2t qn4w2RQeTL4Jb8aRmBEukq2XydbLZOtlZura5AlhRfItfnYiTo7+Nnmqxz/AaeFSmXypTL4l+Tav 344zwkwZPTP5Ds//CGeFv9Ib5+oqW7m2mmurubZatn9Kn1yfPN8x78P7w0+Sf+zxAlwY2pIf8Pgn +GBYpCouS/6p5xeF21TGlfrpHv208i+zb05eFp2U/Dxmh22V78gbZoftDXPwpegIVXKEClmgQo6Q JfNkyTxZMq/h637+DXwbd+BO3B0d03APFmGx45d4byke8noZHnae5V4/5vG74cGG7+FxtIW1DT8I K0yxtobVXq/BWvx9mKmqZppsbTJwtQxcbV+w1nRra3gm/KRhHZ513HPeaw+XNvwvz/8JG7z/gs/J rYbNzvuS97bg597bijS6nOtlbEe343c6NoM+P/sFfun9Xeh33t2hW+XOND3bVO9lqvfShr3ek4MN crAhC3nYkMdw6GmQhw3ysKEAOdhQwgGUxT2Kcc9/HXY0HMaE57+FnGuQc7rC3EZ51yjvGpNhR2ON x6neq0Udpnk9XfdIQQ42NoSexkYc4XkT3uT9N+NIHOX9GSFnwudM+Fzjsc53nGOOxwl4C07EWx17 sp+fglNd4w+8p8PqRnMbbw3bVfi8xtujYxp53cjrRl433oW7cU9Y3fhAWKHyV+tUM3WqmTrVTF1g tW41s3G58zzqPN91zsedv83rH2AlnggLqjuJq3SJn+gKnXYSAzrCP+kEv1Txd6jsG1T2GlW7VtV2 mLexiv0HFbtPVe5UjS+owh+pwu2q7hKVdYVKelzF3KVifqJi9qiSu1TJFlWwQfYvn/wdp2dl/7PV /0/7K2Fb9D/1q5VWstLE2pz4oRm9LmzRtx7Xtx63qkr3/Efd83nd83mTa9XkDO8wA/NWu8/06jC9 OvSvVVb+oj6VtfJ0ZYJZdU6/2aff7LPy3fp1v5WP69n9enb/5IR7Qi9YpResssqDVnl95bc0TK/N Df/DHveK0GGCdZhgm02wjtf3CC1e3xQen9wrrFSfK9XnShNsc4P7joZv4i7cHZ7X1Z/X1Z+v7h0e 8PMH8ZDXy/CwczzivI95bA+r5P0qeb5KTmfNk37zpF/eZs2UfrmanZxeq+TlKnm5Si5m5do+ubZP ru2TW1m5lZVX++TVvup0O91O8l8mXIecWmnCbTY5npcfq+RHVn7si+aZEptMiU3yYaNc+AGlS6bD JrnwSd28WzevdPEXqdpP1e1U3S4nfqxzD1C2S6fupmwXZbvkRrnaoY8JO3TjHbrxDjlyjhw5rMv2 6bJ9k/u1Lp21XWdt11nb5cw23fRlXXSzzrlDR9ykI26ieonqJWqXdMBNOuAmHXCTDrhJB9xE2ZKu t0nX26TTbdLRNutifbpYny62WRdr18XadbDNOtjLOtjLutXLulWf7tSnO/XpTn26U7vu1K47tetO L+tKfbpSn67Uriu160Z9utFm3WgHd7p0lm6dpZtLXRzq0l0GdJcBHWRAt+jWLSqdoVtn6NYZujm1 nVPbObVdVxjQAbo5tZ1T21V+N6e6VP4mFb9JxW9S8ZtU/CYVv0nFt6v2dtXep9r7VHufam9X7X2q vVLl21V5tyrvVuXdqrzbfXDezriypz43TETnqbJYRTWrqCUqaomK+hmf21TNIb6u5OtKvq5ULTm+ Fvm6hqdreLpGRcSqIOZFGy/aVEBlp9wm42NZvkSWL5HlS3jRJstjWV7ZKS+R5Utk8yF6raHTGtl8 iFZraFWkVVFWH6JXUSYfos9K+qykz0r6FGXzIdl8iEYrabSSPmtkbyx7l8jcQ2JeKcbnw7dk7EER /NCrMWs/GB6Tm5noBJGVvOoT2YDIBkSWFdVL+kBOZC+J7CWrq9ydvWR1L1ldyepesqqSFZWsaMCK BqxowGpKVlOymgGrGbCal6yiZBUD0cmuNFa9Lxl3tUOYsEv8rX1yVN29lF2t29Uq02rM1So50+1q Y65WmUpjtBhz1TFajLnymCv3uXKfK/fRYszVx1x9zNX7XL3P1btdfczV+9wj7A6PiHybqLe5ctkV s3rZ93XcnTruTj3tUR13S1TrqPHJ+6fy5G8snZWcGZ0WnaHKc6o854gBR+z73d21IwdEMi6StCqv 6JYWSVoUaRWQUwE50aRFkhbJuEjGRTGuAnIqIKcCciogpwJy/+rO91jHvNV7v7sDPs3z00NaNucq d7uyOSebc7I5J5tzVW9/aWW/rno71avR6ncqhzGhk9RWfhvJrup8u6rz7dUzYiiE/X5W0Ov36537 9c59euc+vbPSG/fri/v1wX3OtruaNzuqZ0pWFSxHb3OOdX7yHHdHnGu9Iw68ros9BE1G6DFCjxHX WD/5byxbuTxCnxG6jHB5hDYj3B2xhvXWsM4a1lnDOk6P/CtN3uL1ifidJqc6/nSv3+bxUcd/t/qd SSGaIvpydKz1jUzOuV3WtKtSudY0ZPW/sq4h6xqyjiHrGLKGIdcece0R165cd5fr7nLdXa63y/V2 udaQ61SusSs63dmfEP16kbe/YQZU7vXXu1Kx2vNT1X+p88Bkpu2q7my/oj9O9kYRt7vqE676hKs+ 8W/2xUofPNVxlR74No+VfvaoY3+/n023mn+wgt3Vbxtqq78XO8eVt7nytsnfE9oUnWPdGUc+z7W0 u5as9W+m0kYqradSZe1Py+iKUs/wurIrKFLrGWo9I57Nzvo9Z1vPxbSdZWUSP0PBZzhZyfJnZHlO luc4mhbfZtmeE2NGjBkxZriatkPM2iFm7QYrE3o9pddTer2sz3E5zeU01ddTfb3YN1P+GbFvFneG y2kOrI/eQvUuqneJuVMEJXH/s1VXlO+y4qIVF62uSO0uandZZdEKi1TuonIXlbuo3EXlLip3UbjL lYoU7qJuF3W7qNtF3S71dTDcT5vt9BiWYSaCejrbzD4v/DpK2ittrX67dl7YHZ3q1cHqt5an6XGn 4z1h1BwfNcdHHTFuho/YUZUmv2UcMYdHzOFRc3h08lvGkeq3jO363r980zhq9o6avaNv+KZx1Nwd tSsaM3dH7IzGzMFRc3DU7BuNpttpHLKSR+wsytVvcM8NeVet/EbCkxx8svqt7TR7kXJyhjWfVf1+ cG/1+4rzfPoz0V/ofydFNc6xt3qOs8Orle9dRcs/xw85dg8VZojovHCoqscGz4rR0Z6Vf++bxmLy Mjvfz4c9Ii6KuPiGbwaL/843g8U33sFHp7hS5dvg/XTdR9d9v/eNcN5V9tN0vyvsd4X9b/jmdr+r 7Kfpfpruo+n+3/v2dj9N97/+7W2/Ywa9HtIJ3/CNbDRF1HF0erKx6vgP7OHG7OHG7OHGrOlZa3qW Uofs40r2cSVHj1a/6/uQn19U/S2/dZRfpw+fog9X/j11zl6sZC9Wsq5n7blK9lwle66SPVfJHqtk j1Wynmftr0r2VmPW9Kx9Tsk+p2SfU7LHKUV1VvNjV46r3zBWHLzIlT8TOlytIzrNT/fQbbc17rLG XY6sfKP+Cv2G6TdMv2H6DdLvUOV7KhrupuEhGh6i4TANh2m4m4aHaLjbWnfRcDcNh2k4TMNhGu6m 4W4aDtNw2Jp30fCQ9e6i4TANh2k4HB1DtQGqDVBtgFL9lOq37l3WnaHUAEX6KdJPjX5q9FOjnxr9 1OinRj8l+ikxQIV+KvRToZ8K/dEJ4syLMS/GfFWNs535PSbyOXgv3q9efqRPPY1nPF+H9pC33x0V S1osabGk7W9HxZEWR1oceTHkxZAWQ1oM6ervcFb+tfHx0bLocp3gClyJG8KT0c3h3uir+Brm4xbs DT+I9uFXGHXM4bA4msCr+A1+GxZPOSN0TzkT78A78Uc4C+/C2Xg33oNz8F6ci/NwPt6H9+OPcQEu xAfwJ/ggPoQ/xUX4M3wYf46/wF/iYnwEl+Cj+Bg+jkvxCXwSs6OTpvxz6JzSEV6Y8lM8jxfwIn6G zejES9gSXqj5bri3ZgW+h61ep7ENYq15DSEsnvqmsHLqkeEHU2eE7qlH4xgci+NwPAbDvVMLjtmP A+He2jNxPq4JK2uvxXW4HvPCk7UtoHvt4tBd2xVeqB0P3XVvCy/UvR1n4Eycg/fiA7gs/KDuc/h8 WFz3ENow6PUeDIFndcPhybpXUPKz2OvxsHhaInRPS8J8nzYVtbB/nWb/Os38nmZ+T6tHAxpxBJpg pk8z06eZ6dOOwh+HF6ZdgC94fqXH2zw+4fFJHAzd051r+lHhhehvoyNl3FGYgaNxDI7F23EGzsQ7 8E58DB/HpfgEPolP4dP4K/w1PotZuDyslblrZe5amXtnNNc9wjy04EbchJvDU7L5Kdn8lGx+SjY/ VXNnSNfchbuhKmoWYTHuxX24Hw/gQaiYmqX4rs+twPfCU1xfO3VnSE9VXVP7MYBB72c95lDw8/04 4L3fhnRtLeyra6cjheNwPP4QbwMdaukgO56qPdfj+R4v9Hgx/hafxxfQjGvCWpmzVuaslTlrZc6d MufOWvHWilcGPTXt+oo20X32VPfjATyIJVgK+62ost96EquwGi9hC36OrUhjG7rwMrajGzvQgwz2 hnV6wjo9YZ2e0B2554li8D6Su5F7H31ioz6xUZ/YqE9s1Cc21uRDd80wXsEICnDPVFOEfWiNfWiN /WWNc9Y4Z41z1lQ+9xpC2Kje1tXpBXVqv06t16n1OnVep87r/gafwWWO+Rw+HzbWXe31XMzDjbgJ X8O3cDvUWx2N6mhUR6M6GqmnjXXf99jm8Yce20GHOjrU0aGODmptnVpbp9bWqbV1aq1brXXXialO TGpuo5pbV0cPdbdxyruiGruRqahFHaZhOlKoRwMaUfmb0xdEZ0UX4vKwXI4vl+PL5fhyOb5Cjq+Q 4yvk+Ao5vqLyX3uW5wvl+UJ5vlCeL5TnC/8Tf0vqnGg99oalHF3K0aUcXcPRDRzdwNENHN3A0Q3R r6M3c3URVxdxdRFXF3F10X/V78Un3h0dn3hPdFbiXI8fwkfC8sQlYWniY/h0dFxidlidmBO+kbga 14Rv2LNdl/xc+LZ923XJL3ic605mnjndFTUlX45mJLvRY8r2Ricl94aNyX1e/yo6I5mt/lWH05Kv eByJmmrmRifVzEMLbsRNaMXN+Cq+hvm4BbdW/47WQv1ioX6x8D/7d7Rk+yLZvki2L9Jrlld/J//I sFSPWTh1JDpSf1muvyzXXxZOfTU6qTYJuVV7JI7CaTgzLKx9h8f34L3RWXrKwtr3eX5NWK5/LNc/ lusfy/WP5frHcv1jhf6xolYu1d4MufT67/p3h6H/6/f2K7+L/4mwQaUtVWlLVdqi1/8O1+/+Blfl b2895P1/+ftb56imRdW/wTXo+D0YgpxTOWtUzhqVs0HlbKjbH725roiS42M/l38qaFHl73T9f/sd /Tf+ra83/K595ffoUzPD0pS4UvPDN1K3Qt2k1E1K3aTUTUrdpNRN6h4swmLcC/Gm7scDeBBLsBQP YRkexnewHI/gUTwG+qRW4Hv4Ph5HW3R8/Vej4+q/hvm4BbfiNnwd38ACLMQ38S3cjm/jDtyJu3A3 7sEiLMa9uB8P4EEswVI8hGV4ODqu4Z3R8UdMj447IoX66Di7xW2qYG/1r5hsq/7lk5MSN+pmTbpZ k27WpJs1Vf+LCdNR+e/s1aMBjTgCR9rdHoUZOBrH4Fi8HXbQdgD9dgD9dgD9Ot9pOt9pdgI5O4Gc nUDOTiBnJ5CzE8jZCeTsBHJ2Ajk7gVzlvx2vS87VJefqknOjq9xpzcYcXI1rcC2uw/WVf6uOL+Mr uCG0/psd9eZwsW56sW56sW56sW56sW6a0k1TumlKN03ppindNKWbpnTTlG6a0k1T5m7W3M2au1lz N2vuZs3drLmbNXez5m7W3M2au1md9zSd9zTzt2z+ls3fsvlbNn/L5m/Z/C2bv2Xzt2z+ls3fsvlb Nn/LuvV9uvV9uvV9US4UojyG8QpGUMB+FFHCAZQxGn6ssz+nsz+nsz+nsz+nsz+nqy/Q1Rfo6gt0 9QW6+gJ7+ow9fcaePmNPn7Gnz9jTZ+zpM/b0GXv6jD19xp4+Y0+fsafP2NNn7Okz9vQZe/qMPX3G nj5jT5+xp8/Y02fs6TP29Bl7+ow9fcaePmNPn7Gnz9jTZ+zpM/b0GXv6jD19xp4+Y0+fsafP2NNn 7Okz9vSZKZ+Kjp/yafwV/hp/g++EtEmUNonSJlHaJEqbRGmTKG0SpU2itEmUNonSJlHaJEqbRGmT KG0SpU2itEmUNonSJlHaJEqbRGmTKG0SpU2itEmUdi+x3r3ERvcSG91LbHQvsdG9xEb3EuvdS6x3 L7HevcR69xLrp/w8Sk3ZijS2RSlTrMkUO8IUa0q43zHJmhLuaUyz50yzy02zy6vT7HOhkLgcs8ND b5xqiWurf93lYpNtjsl2sclW+StJP0zeEJ5ItptiG6LGZEe4Pbkt/MiUazLlUqZczpRLJXeGIZNu zeTfLjqp+ncuX/H+SDTVlGsy5ZpMuSZTrsmUazLlmky5JlOuyZRrMuWaTLkmU67JTjpnJ52zk87Z SefspHN20jk76ZyddM5OOmcnnbOTztlJ5+ykczUPhXLNMjyM72A5HsGjeAzfDRebnBebnBe771rv vmu9+671pmjKFE2ZoilTNGWKpkzRlCmaMkVTpmjKFE2ZoilTNGWfWbbPLNtnlu0zy/aZZfvMsn1m 2T6zbJ9Zts8s22eW7TPL9pnlmoOhUDOOQ/g1DmMCr+I3UBMm8wKTeYHJPNdkTpvM97n/y7j/y7j/ y7j/y7j/y7j/y7hL6HeX0O8uIecu4X9TdybwVVRn/z8zZ+6cuZO5uQHCEsAAgrj0pa3U9/VTrV18 Xfp3qVKXUlDEgrUqLtWAioDiUsAFARVQUUHQvjVWfVs3ggiKWlF7BSIQl+uSAAEMy7CEJZDzfs/J BcMSlaW+73/u5zfLmbM8c+Y5v/P8Zm5usszgpyaW6BilkEUpZJnJS5jJSxLYlMAmZvRTmdHTqIZs op5jrWNfAAe4QIo0M30aRZFFUWRRFFkURZaZP83Mn0ZZZFEWWb89eQ8BnUk7jOOuAK5FZWSJDE4l Mkj7P+T80Wx/JDqjOrJECKcSIaRRHlmURxblkUV5ZFEeWZRHlsihhMihhMihhMihxIdHfXjUh0f9 60AJGKhvJJq4cWc0AYeiZyuIJDJEEhn/URH6z4oi/znwPPsvsX2T7TxdRpSR8bmX6N4K3/wi5yE6 Q8SRIeLIEHFk0MJlaOEytPAstPAsIpAMengWerhMHS9CNHEZuiBGF8ToghhdEKMLlhGlTEcXxOiC mGhlLNHKWHWBrlEXgj76NvRBrAawz5hSV4GrwTXgj9R5LeC60A7L0A4x2iFGO8REOCERToiGiNEQ sbqT/HfZXzaMiXpC9ESMnojREzF6IiYKuo0oKCQK6oyuiImEbiMSCtEWMdoiRlvEaIsYbRGjLWIi pLFESGOJkMYSIY1VS6h7KVgG4HoF1xM1/Y2o6W9ETdOJmqYTLd1GtDSWaGk60dJtREshWr8CrV+B 1q9A61eg9SvQ+hVo/Qq0fgVavwKtX4HWr0DrV6D1K9D6FWj9CrR+BVq/Aq1fQdSVIerKEHVliLoy RF0Zoq4MUVeGqCtD1JUh6soQdWWIujJEXRmirgxRV4aoK0PUlSHqygTdselH4Me6LDgOXETd/Tju Dy4BvyftUrZ/AJeBy8HVupoILUOEliFCywS3UOZe0v9M3v/Ss4K/sP8U2KgrkkIUEcFlklxbsoUu S7YUYXiOLg/RheH5oKfuT2TXP7yA/Rt0TXgjuAnsiPSGs38HGCHSRHxpIr40EV+aiC9NxJcm4ksT 8aWJ+NJEfGkivjQRX5qIL03ElybiSxPxpYn40kR8aSK+NBFfmogvTcSXJuJLE/GlifjSRHxpIr40 EV+aiC9NxJf+X4z40rtEfC3FaH2K00f0cvqCi8UNzu/ExU4/cbbTX/R3fylOdC8TP5Hn6fNlT91D luky+aruLyt1ObFhoVxif+N1ilyuM3IFWmoleutLXSs6iNH1y0WpXiLe0Euo/YTcL9KeTe2/oPZf 5H5Jttb8VjStFNFKSCsn0MqptDJGvqLfkTPBqzqUs9m+pqvk69Q+Rz9G61NouU4uta2fReuTaD2k 9RdovVwEMkOOediEkpcLsL1cz5UfkLaIGXExOSJsexfb3iVnX+bODLmnkHskuVuSu5Tc5zOPzqLE MErcJjqZ35fE2snM5v/G7H2ZeyYz+WX6bvcq891O0cmdowe6/9BT3E/F8e5G9Ggh8fMP9IvyFWbf V8UPuYK3aakMPRrKBVaLZpil09RexxV9zkw9MjdThzlNGnJlsVzBVdlfGtRrnN8ITz8pEsAHCgQg CULz19kgAimQD9Io+wJwnM6I48FtepS4HdwB/gRGgJFgFLgT3AXuBqP1bDFdPy/K9POOS/wjgQcS wAcKBCAJQpAHUqAAME86zUELAJc4cIkDlzhwiQOXOHCJA3c4cIcDdzhwhwN3OHCHA3c4cIfTFRwO ztblTg/wa8DYdhjbzlAwDNwMbgHDwa3gNnA7uAP8CYwAI8EYPdcZC8aB+8D94AEwHkzQc90f6lHu MeBnoAd3b5TOuHdyZ17Vv+au1OBntfjYc9yJmobffOS4tv51uUkXys31WbmlvlxurX9K1tVXyG31 0+V2nSfrSdf1NV6i/nXP14Weqs96QX25l6x/ygvrK7y8+ulepPO8FOn55CvRT3oDwSBwPbgB3AgG g5vAEDAUDAM3A2Jbj9jWI7b1iG09YluP2NYjtvWIbT1iW4/Y1iO29YhtPWJbj9jWI7b1iG09YluP 2NYjtvVeAC/rcm86KAMzwCtgJngVzAKzwWvgdTAHvAEW6FFeOfgALASLwGJQAT4EH4GPwScgq0cl 6vSTvgT4r5/QpX5zti1AZ3AUOBr8iLjgWLZ363J/PJjIMdfpP8E+1+NzPT7X43M9/rOkPQf+Bv4O XgLTSS8DM8ArANt9bPffYf9d8B77/wQZ8D5YBBbruf5HnKsGX4IYrAPrwQawEWzS5SofpEEBaAba 6LmqCLQF7UB7cAxxyrHgj3qUuhbcAoaDseAxMEU/r0rZbtKjgsN1efA95rjvs/0h21+Bs9j/rZ4b 9ON8f3AJwB+DiaQ/CB4CD4NSUKfnJoUuTzZjy/hKMq6SzNFJ5uewH7gcDABXgWtACWC8h4z3kPEe Mt5DxnvIeA/vAaPBvWAMwN5wHLgP3A8eAOPBBDARPAgeAg+DSeAR8CjgGsPJYAp4HEwF0/SovNN0 Ju90cAY4E3CteWeBs0EPcJOekjcEDAXDwM3gFjAc3ApuA7eDO8CfwAgwEowCd4K7wN3gHjAa3AvG gHHgPnA/eACMBxPARPCgnhJ9T4/KT+op+SHI01OEB/s/B/NXy4XMZYuZxx4Qg+HPm8AQMBQMA1vg 0q2gDmwD2+GqI3SMfo7RzzH6OUY/x+jnGP0co59j9HOMfo7RzzH6OUY/x+jnGP0co59j9HOMfo7R zzH6OUY/x+jnGP0co59j9HOMfo7RzzH6OUY/x+jnGP0co59j9HOMfo7RzzH6OUY/x+jnGP0co59j 83tgzls6i2atQbPWoFlr0Kw1aNYadOgT6NAn0J1ZdGcW3Zl1p+lKZrQnmcmWu7V6lbtJr7J/2fQa uvN9ZqN5OssM9iQarhQNV4qGK0XD1aDhatBwRj9l0E8Z9FMGzRSjmWI0U4xmitFMMZopRiOVooNK 0SmlaJJSNEQpGiJGI5hfEI3RATXogBp1lM6q79lfAzW/BGpi+QxxdobYOkMsnCEGzhD/xsS/MfFv TPwbE//GxL8x8W9M/BsT/8bEvzHxb0z8GxP/xsS/MfFvTPwbE//GxL8x8WoN8WoN8WpMjGp+oTNL HBoTg9YQd8bEmzHxZk2yUGeJMZ8gxnyCmDJLTJmNhurKaBi4WVemCvWqVEvQCnQAHcFw0qfabzct 0U8yrxNjyjLxIzlD9JOzRBc5W7Slf9+Tr4uWco44XGbE6fT16VbXLxC/QNun5QeiO/1eY55iE+dU kloluhEvnG6fYZu/Z1hB1NLwLLs7Lb2mp5N/um3zOc4NE5L2jiCt3OQUec7ZInR6gF+Dc8C54DLR HfUWot6McgtRaWHS/NdVD3uKGR0/sb+JzHyIDQ0pxcyW1aQewWxZymxZbuNB1DgtVxEJrRC/sM8U Td7u2GD+H8IyLG74/WT7q9ImJjLvTezvz/XU82UJffMaPnSCSFO2p17A0SfknkksOFtv5KiSowGU m623cLRAHC48ak8AHygQgCQIQR6IQArk0+J5opnspf8h+4AB9OIMvYiaPqOmeV6J6O4NBIPA9eAG cCMYDG4CQ8BQMAzcLLqj5buj2buj2buj0buj0bujybujv7ujvbujt7HF2lpGTDeDvpqpv5CzGEWz 9Ye0OIPodjXXXiK+h08042xsfIFrLxTNnXniEGe+OCz3vbRLZC9yNfxS8/fMLzXLAfZvut6Vg4hv x4sj5QRQpldwpw8lkvmb92NxlHecOIze6i3yKZFPOz/gbpZwB2bq1bT0rm0pRQtf0kJGXkD7FxKB 9mV7MdsSWpmnPyFGriE+3mb9Z5FIUCoUvvlvLOQuImcROYvIGZNjo2glqmBRYiixtOHX+2yLg9jC E9z1BIxbQX0bYN2NlIhNnSYiTjTXtWj4WjR8LRq5Fo1ci0auRSPXon1rafM8rrUntZRw5zKUMrWZ J6atd2nzAurvC64Ujm37fXp+HunzaW8B/VyO5ywkMl8k8r5Vu3m5diupLc1V1FFjJTXWUGNMjX7u 6VvCzh/55I5lT2tHFjuy8lp7jztjsZLml5sbbKmlZB621FHaKJRYfF9UiWPFErAUbBFdxVZQB7aB 7aIrNfe1aukCxtmF4jzZl+3FbK9EyVxLzYP0HDmEOzkeT5/AiCXqoY+62HuzQP/NtvaBXsyYK0Tl bMNHuuMj3T3q9uqBFl0TzcWxqhfoDfqIrmoCmAY+5/gLUAmwU60hbQPbWmxLYlktFnXDmm5ca2Hu 7jC7MgLMPV6MzxhPm4X9s+iZanIX0jvVlCikRHdyJ7FzFT2zHltjbN1s+tWWylj/5B7hy50Zu7X4 c2c5ECasFK0b4nX8tZq7Y/5Oa4WeY/+Tj7lnWXKFpGzEjh2/EJf7doy8Dh+5nvG/HH9YQf/7ud+0 r6YM3MYVLAMrdFYUif5Ycgn4PbjO/geDWuzJYEuG3IU2dxUtWhXHuRUwon3uyrx4gihOFOjqRA1Y pav9AeBKcBW4GgwEg6g3P/d/EcwvcWapOSuv44oGcqWV3LcqvZIr3dJwpXoTVtfRylyrvVtjX4x9 MfbFO0dJL2rqA67DtoHcl0pKVmG70dENatNc3efmfyBhX4x9MfbF2BdjX4x9sW/eqXQTKHdxCfg9 GMzxTWAIGAqGUXPDf006Eo7Kz/0OvWGcX8BRE+jlF+jlN/DLMvzyJ/jlKfIp/LUSy6q4NmsN81Q1 92y5zuKTx+KTx3on6ArvMdHNmwymiG6JAnFK4nO2NWxXgbWim3+kefcJBohT/CvBVeBqYOwLcvfI +Ewi5zMJe6+WWY+I7dOHUux+MperKJerCLtjcna3tpn778sB9X+Wm/UatF7WU3oNWi7rHVH/NjYP qP+c1FpSar0j9L9R64D6xbKWO1VH6W3UtF1Xegm9xQt1nUc8Qs5Kch5tyz7D2QpSKqhtoy2bkVvh CVN2O96gKZMUypaN0GD5bI/QxaI5Od+mlTpUaYxlNdJ8K7yOVrfprZScT8laWq1DjcZYXOMRFVHL FizYSk3zqQl767/gTg1AxzbUspFa6qil3ths224ovZHSdZSut7Y32JAQrSg5ABsq5Sb6bDPbLfQf UXLuyivkdsZ0vV5KTVuwpdLzRRG1VVJbrZdklm/oEa5fJL2UXkrNW7DpHjNr1ldSo+mDalnPnKPs 9Vd7KfaP0MLmeNbeka02V8NdSdpc5s4soHd3u1/EE7n7ROlvuD82r70v5P2G+yEKDvQ+iGhf+x8v Psj9jo830d/2zF77WeR7hSLwWlJrGxF6bUE7yrSn/CHsE616HTh3KPtdwGGc68q5w01U6bWijnac 7cj2MNMHXiFHaAavNXna2rOxrauY9A7sd2K/i80dm3qEb3O3sa1utDkOta1sFM2xK8HZGq8VKa1B G1GMfWly1lBnMfZRL+jAcUfOdwKHkt6FPIeR1pX9w2kjn1qqsdVcYcIrovW2QuZqMaWrsd9cYcLr zLkunGsonRAF2BBSepW90jbU25Zc7ei99qQ3tB9SwyrbA4dyvgtph3G+K+mmba6C+ltytpVe67U2 14rHWRu4l+1p9xDSisnTgbSO5Olk+oA81hbydCXP4TCduU9p269tRGHuPtVhRyF25GNH2vbtoRw3 3Kc6bCjEhnxzV2zvJXKlNuxivbnuhhIbdlqd3l+fYNR+wN5ufsFo7yBS++oblOrMKG3CPzjrihYH y0eorSUp++knlI5EswP1FWppZa7o4PgLd2KavY/75TP2ilL76je0uZlotrZ+PlzYDcbxYLWj5db6 V2G1dnJb/RzY58eyvr4OVivwEvXz4cZusJEHqx3tJetfhdXaeXn1c2CmH3up+jpYjTFY/yE90pYe SdEjKa9N/dv0SEuvbf0yrOpCr3j0iusVk68D+TqSpxM4lHydydeFfIeRryv5Dsdrkii1NBrrFGn+ i9AcG9UXEuUWE1V0N8/tifaK7H8yKnP6iOOdvuIU52Jxl/M7tv0oZf7v0Pn6TfkboqGeepL973hH fk2uN22uHf9xadLOo+d2HrlOCgXcTQhxnPiZOArN/QvxQ3G6OEccLc4XvyH1t8RtPxF/EHeL08Ro 8ZS4WpSJVzmazWeseEcsEuNEBZrjMVHtpMVfnXZOO7HIKXa6icXOGc6ZpJ7lnCtWOL2cC8Qa5yLn IrHOudjpL9Y7A5yrxCZnoDNRbHUe4lPsTOLTwXmUT0fnL85TTidntvO+09n9odvd+ZF7jHus8x/u ce5xznHuT92fOce7/+me5JzgnuKe4vzM/aV7uvNz90z3TOckt4d7jnOye77b0/ml29vt7ZzuXuRe 5Jzh9ncvcc50L3Uvdc5yL3Ovcs52r3UHOee7N7gjnN7uKPce5wr3Xne8c4070X3QucGd5v63M9j9 u/umM9L9h7vIeditcKucUne5+6XzkrvGXevMcNe5m5yZ7ha3zpnjaimct6QrpfO2VDLlvCPTsrkz XxbKQmehbCXbOotkJ3mo87HsIg9zsvJweaTzmfw32c2plD+QP3CWyKNld2epPEb+h1Mtj5PHOyvl CfKnTo38ufy5s1qeKE901siT5EnOWnmmPMuJ5bmyp7NB9pL9nC1ygLySpq+V17sJOUQOcfPkMDnM jeR4OcFNyWfkM25aPi+fdwvkS/Ilt5mcLue4zWVGLnYPkZXyS/dwWSu1e7SX8PLd471C7wj3ZO8E 7wS3l1fijXB7e3d6L7hXey97r7oPe//03ncf9xZ4S90nvOWedqcnwkTozk9EichdkChINHfLE+WJ D91FiU8Sn7vZRFWiyq1MLEssc6sSyxMr3CWJLxNr3WWJdYl1bk1iY2KTuyqxJbHFXZuoS9S5cWK7 n3DX+crPd+v8Ar9ASr+531J6fhu/WAZ+J/9HMu3/u//v8lD/WP9U2dk/yz9PHuNf6N8qj/dv9/8k L/ZH+XfJ/v69/r3yUn+sP07+wX/Af0Be7k/wJ8kr/Mn+ZPlHf6o/VV7rP+E/Ia/zS/2/yxL/Rf8V OdSf5b8ub/ff8t+SI/25/jw5yi/3F8qx/mK/Qt7vf+R/JMf7n/qfyQl+tb9SPujH/jb5iBLKlX9R SnWUT6uu6hj5ljpOnSAXqp+rn8sP1X+qU+VH6jT1K/mZ6qF6yCXqXHWuXKrOV7+Ry1QvdZFcrvqp /nK1ukxdJteqK9QNMlaD1TCp1S1quOepP6m7PF/dqyZ6kXpIPeS1UpPUJK+1elQ95rVRU9U0r60q VTO89mqOmut1U/PVOu8YtQGSOz/oGnT1fhccERzl9Qu+H/zA+31wTHCM94fgx8Fx3mXBT4ITvCuC XwaneVcGZwRneNcEvwrO8v4YnBOc510X/Db4rTco6Bdc6l0fXB380RsSDA4GezcHQ4Oh3i3BLcGt 3vBgRDDKuz24K7jbGxHcG9zrjQrGBeO8O4PxwcPeXcGfg//yxgalQal3X/BM8Ix3f7AuWO89EGwM NnoTgs3BZm9iEjLzHkx6Sc97OKmSypuUZPEeSaaTBd6jyRbJlt7kZFGyyJuabJds701LFieLvSfD c8Je3p/DvmFf79mwf9jfey78Q3iZ99/hFeEV3t/DK8OrvOfDa8JrvBfDQeEg76VwcDjYezkcEt7s TQ9HhE97M8PZ4dteVbgw/MSrCT8Nl3obwi15bb1teZ3zxiSK88blTUncnfdi3quJSXnv561LPBGp qE1ibvS96OTEx1HP6A+J2uiK6BpfRddGJX4qGhTd4BdEg6PBfotoSHSHXxiNjEb7xdGYaIx/WDQu ut/vGo2PJvtHRo9Hj/vHRNOip/1/j56Nnvd/Gr0UzfBPimZGM/3/F82KZvmnRa9Fb/unR+9FC/xz og+iD/xe0aKowu8dfRR95veJvojW+v2j9dFmvyTaGm3zB0f1KeEPTbkp178l5aV8f3gqmUr5t6cK Uq38Uak2qTb+mFTbVHt/bKo41cW/P9U11dV/OHVz6mZ/Ump46g7/kdTI1D3+46mxqfv8/0o9kBrv l6YeTD3o/zX1cOph/5nUI6kp/rOpqak/+8/nu/n5/vT85vmt/bfy2+Uf4r+Xvyl/q/++cJO3MqOI vLKCV8ThooM4KIv+VH8muqGshJ6/1/N1erR+hk+tvoGji/Ql+mn9AnuV9mylrmb9RS5v7R6lzdlq HfP56lzhHrnWgNu/0dKR4L8bHVdQe0vTQpNLqLca6/R69s13ZE8VXTnO7qxh+c69yr20N19/olfo d/lU6rVE6we6tKbOybbmKl2j5+5oXdfs0XKN7bUanaX3Lxbt6LEjjeW5s3Xf1JDeqFfrdXq5Xroz qQWpq+2557l7af0ie0v2WpZcehWt1+oVwvRasegsft5gPWcW6UV4y2dmr4m2H9WTzFXqgeBX+kQ9 XI9g77Od579sfJW7la2jrz+l7df0m1x9zJ1K5M58uFvOt76xDzaInKfpMXYd6zXUnvPCRj2zI/9G emyd3qwXku80e7XH0/M5K/VKvZL1ilzezXuUXkOfLTM+khsXtaKt3ZY3fbVN2J3d5eiKRvuvfLsa WL7/VYvcsXKR0Au/oVUzAlfmDo4Sx3xt3if1Q8ZPjA/t+6KXmivEuz7Z48wX31h2LbjN7j29+x00 7PQNpatAmWWkj74a+d92was32nX5Xk6mv1UN68Dn+9puruzs3PaF/Sj7iF2/Za7/IC/HfWPbyxvu q94Cl67ex9q/vlePBefZNr5oWDd8cmf3NjseyacDnyN3sfBJu36/4fM1pY/ea+lldr1Kb4C7NjRl KucMq63UH5txaMo0cHjDnAfbvaHf0f9osnSjWVWPEp1g5DPFWez/xaaUM0+9oiuaLN1o3tLjmAeK xMkoT0aQTfmYsfDGV+zcVNtmBsWPTOljUK25dD1dv8Qc2yQvfcX1uSVN//Ui/UZ7dqZ+Wc/Wr+by rtqjdKOZnZ5K23nIzCpn2JQ3aL1MlzXZdhNxQb2JCN7Vv9U99BX6vFzePZhMj6Jf39b/1J/twjOu 6CNuQ6EL9Pq95q9OxNMiEs+Il8QRYgbavbvV7v8h5qDdjxUfot1PR6U7oqfT1+krrkM9/1qUGN0s BhnFLK53L3evFDeifSvEUPdj91MxzK10q8St6ODl4nZ3pfuluMOoYTHCrXU3iVFunVsn7jJqWNxt 1LAYjRrOE2Ok+U2iB+QF8kIxXvaVF4uJ3ovei+IhdKQWDyeaJ5qLuf4L/gviHX+m/6p41//Y/0T8 09e+Fu8b/STmGf0kFqqzVQ/xkdFP4hOjn0TW6CfxmdFPYqnRT6La6Cex3OgnUWv0k6gz+klsRz+N daS6T010fKOinMioKCdlVJSTb1SUU2BUlNPcqCins1FRzlFGRTlnBDJIOD2DIAid3kEU5Dt9gmZB C+fioGXQ2ukftA3aO5cGxUFH5/Kgc3CYc2Xw0+BnzjUop0uca1FII52BKKS7nOuNBnJuMFrEudFo EWdw3k15Y5xhRmE490cFURvn5ejp6GnntagqWuu8bmJ8Z56J8Z1FJsZ3PjQxvvOJifGdrInxnc9N jO8sNTG+U2NifGeVifGdtSbGdzaZ+N3ZbOJ3Z4uJ3536/GR+nivzW+a3dv38zflb3SR+s9D6jWP9 xsVvxhPJTxAPEd88LKaR8gQfJZ4UT4lAlOJVvvUqH696RSTFTHwrtL4V4ltzSX9HfCDyqHUhZRfx SeFtn4h8kRWVjLEqPK+jqBYxo2Ydn05ivdgkDhWb+XQWW8R20UXU45fNrF+2t34prV9G1i8j/HKA KHCvxDsj653N8c6saOV+io+2wEcrRWu3Ck9tZz21rfXU1tZTW1pPLbKe2sLVrhYtpMBfC/FXlzWL aInXKva57aKNTOLBhdaD2+LBF4jD5IX4cVf8uC/7F+PNXa03t8ebs8LxPvWWCtdb5lUL31vurRZ5 3hpvgzjE2+jVirS3ydsmir3t+H0X6/cdrd+3t37f3vp9e+v37fH7/xSF6iR1kshTJ6uThadOYSQk GAmnkXK6Op2UM9QZQqkz1ZkiUL9ihBzKCDmbsj0YJ0k7TvIYJ+eLlPoNoyWf0dJbdFQXqAtFWvVR fUQXdRHjp5kdP83s+HEYP1dQaoC6hjx/VNeScp26TriqRA2klUFqEDVfzxjLY4zdRKkhagjpQ9VQ 8g9j1KXsqHMYdSPIM1KNot07GYFpRuC9pIxRYyg1Vo0lz31qPCkT1AQsmagmksLIFKEZmcKMzEcp 9Zh6jPSpair1TFPTyFmqSkl5Wj1D2WfVs/TDc+p5euYFNR07y1QZfTJDzcCqOepNrH1LzaXO+Qqf VAsV3qgWq4+o7WP1meigPldV9MkStZy2VqiVopP6UtXQk6vUatFZrVFraHGtWofNG9QGcm5UGzlb q2pJ36Q2YclmtYX6t6qt1Fyn6qh5m9omWqjtajut16t6ymqlRZ7hEdHe8AhreIQ1PMIaHmENj7CG R1jDI6zhEdbwiHDgkRGsRwYjhWvYRHiGTYRj2EREsMkQ1kPDm0WB4RQh4ZRFIspbnFchUnkf5q0T BYZfhDT8ItrAL1WiRbQkWiIKo6XRUpGKlkXLRKuoOqrm7PJouWgdrYhWiHbRymgV+6uj1eRfE60h z9poLXnWR+vZ3xBtFEVRbVRLnk3RZvJsjbZyti7aJvKi+kiL1imGv2hhmIu1l/JYJ1K+aA5/haJl Ki+VR54olRLt4LIWpBSmWokiw2iiFYzWlnW7VHvyFKc6iMJUx1RHauiUOpT9zqnO5O+S6sI+fEc6 fEfKI6lHqf+x1GRKTUlNoeapqWnU+UTqz6KlYUBhGVAUGAYUBbDUX3MMOIaP3MmAE9l/GO6TlvsS MN/T7D8jXmY9XZRZBpzN/uvwnhRvwn0S7lsIVy4Si9mv4KMs90nLfYWW+1pa7kta7mtlua+15b42 lvuKLPflOWknLSKnl9OL9QAHpnOudq5lXeKUsL7TuRPu6+H2EK5lxgBm7M/aMGNomTGwzJiybNjC rXHN/40wDNjMMmBzd7u7XeRb7ktLT3qiGawXsB/KUBTIXrKXaCd7y97iEMt67S3rFcs+sg/pF8mL SDcM2N4yYLH8newn2u5kwGoh4b4NQsF620TS8l2R5buW5qko4/NEdaKQltcUjHY6a8Nl0nJZwnJZ a3WWOosUw2VSnaPOYX2uOo+chsVaWhZLWhYrgsX6MrZ/p37Hup/qR85L1CWsL1WXsjaMpiyjJXOM VqJKSBkIoyUslyl1o7rRMtpg8htGUzDazew3cNmt6jb2DaMpy2jSMlpS3a3uptQ9ajQpht2UZbe8 HLuNU+OEtBynLMcVWXaT6hF4TeZ4bbKazP4UNUX46nH1ODkN00nLdEWNmE5aplMwXRn7ht2UekW9 xv4cNY+1YTcFu33EvuG1QstrLS2vJS2vtbK81tryWhvLa0WW1/LUerWeUobdWlp2a23ZrSjHbttg MWlZLC9wAkfIBj4KbwhvFEF4U3gT66HhUBGGN8M+YTg8HE7KHeEdIrBM5OaNy3tQuJZTWkSrYJN0 FEfwqWWQtOWOFnDHJvY3R1tEPqxRz0g2rFGQkikp8uELJVKWL5pZvmgBUzRn3zBF81TrVGvyGI5o kTokdQjpHeCI5nBEJ2owHNHMckTackSB5YhmcMQj1PlY6jFKTU1NJf802KGZZQdXuN16mqeZR2/9 ye0oknObiuP/Ly96na40sPvxrk9uduap1Uu/9hllU3WbJ7Kfgrn26NMdaUa92KeDdeYJWcPzIqyI d32C2bQezJ1fkNv+ft8tO1iL7q0n2e26b5W7UmeM2vu2z9GarKdm133znHXns7J1qL5KnTW9qRfv zPXV3cs9ubZ9bn4NoFikTW6btsez73/pEuYsadxqWvzUpn2++93Xq/d83oX3/FPP1Zv2xze/edHz ctuqnCevbXRu/Q7rrRV7uZ/6k72PpYNi2T7XrCfrCXZbq+fhGe+DZ/T9ekHuvu+03z5ZnIcPvb1f 471GNHoL0fDepNHZu/VaeKQm16PLjSWNCu/who3fop3NYq9vOw504U5+Zf0G+mo1ME+NNu2Sa+We Jf+vLTufea34dr5yoIz0tXXv7Wlz07nf0i/oN/RzhqfYb3iyWZ57RrliZ65lX3HbPtT9sXl+meO+ lfYNUAyDmLcizzTUz/Ectv8wYH+X55m6VBh+6r7jqmDdcljqZ6KTXtzwJkBX6Yzdjt7xhO/AlsZv txreHum/7jx+RF+uR+m+ehb7F+xMPVEP0NPtTLNbr++NpbiCMj0LH2/y2el+2r3OMk3OemOJ7fHG s1bc+Mm4/uhra3v74Fq3LwtslHv/pkt2O/OGvmPn/s4ZDI8wfLGEmfVrr6mJ1gxjmnth+8b658pc P7HWA207yr4P3n2mLrTf0mpcl4kAPmXOCk1NudhgS+5c/E19/i1s/YopG70F28GNDfEIHF9t29rF 8+x4q95jfq/Z3/dK+7s0RKWNjpuMfhq/wWyUOuPg2tOo5vP2IbN9z6NH5t4p1jKil5k3hPo5Xdrw pnCX+T3OedmL+m/7YdcrxAUv5fbfhqPt+1wzPo0PEGNU5t6p1FpmrchFFw0smtqtrlmWe16wPD+r 4R2IfmeXHNv33cJcyQWi0dv2HHMusBw0y+7DhZY3X2vwgoY3kg2jI3fmZH2SPZqpf09PXg5u1few /btNfWOX1v5Or5foX++HnVfrSYa7uf4v2OvN3nAUwiT9FHPgGN1DjzOKgVSjGZ7VUxvGjL7UFi7c 8T41V1c5o53IXxxh9xtUVi76Mm/17PdHjH/sx3dArNfsfLPdMBfn9rMip32+0nFi19is4+7fe/jX L41jSPNOTq8ys/7Xltgtvv9ull3ea9o363rV10ditpe/W5UmGvcn/rPZxlEbv14fWI7ZDzubfv+8 D3V8p/2jH9W369F6kN2vRI0+qR/MnanRH9jtKph41VeR2361cqJ+9ADt/Bjtlck9iVmiF+n3Gn2H zMbVKJ739fqd3x/Yv1a+4ZnN15atMrE323rwHvF5bjaw3zcw3+2xEX9T39n67hZYu682v2ncxh5d z/F1KBWrnE0P6Dr9kh6rj2MOycDhk/fvzumJdtP5gCxtuK9zckc5FdvwJEA0UlMHvuzD97qaqmGt 7UHDwyuIV/e4y5z/yKi+g61V9nUhslqBFQ16dCV+urbROTvL4MfvMcLe2Wvx72zBztLG312Bl+b8 71mzt0Vfoi8wDGn0DOvRHD+n/2n3c4oPP3hJn63vFkZ/fb5/PvZd3we8Y8t32+K+LTtYX3+55/dH 96GWf+kzsFxEWcOctebAnvPt77MD837iW+Z81n7bePdvie3r0ukAy3/rhTn+AJ716bEHz5ImWsjx u159IHf+YM5tTbaR1Vu/62cW+77ol61mOND+OPygGPMvWw70LxuYafbjbY19lrzz6Zf9jvCOsRU2 PcpsjNxZ9BJqP1qs2R/WNnf/K72Wexb47b49HtnvKP//sBTtTyHzDH8/Si1oPLOYv+Ngnqr917yF /FcsxK8b/oe374Fr6jzbfnJCTg5wgogUAdEhRUVERGSUgiL+GXWWWWedc85KgBAchiTkH04SchJS iZZaRy1l1tda65ylzjJnrbXOWWcts77WWWedr7XO+VnrnK9zzjrrzHc9dyKl6972bb/fN/nd17m5 z/M85zknJ/dz3Qnn8otXrNDtrzDyO1/lL/SJ+X/4qd/uXsvoz+nF7+AU9iDu0X/zP16N9vkfUh3w h8/PQPR5+L/5c5v+s/x/GucPEXvjM7tGR54lSOz33MGXGfltXLe37x6Fe2R3n4W4e7wSOtKn5tPv t7ZPRovY5vC23z/+zMN4vg3tDv+9xpec52b02xzxyaPPvndHzuHuDMb/0zw3f/kj9fU9+6+fZPyC Xr/vf+Z8hM9++/I//vtKnzTgVbrwxa0+0+vDyPudvvOn74Pu/j1FzOc8gcLPI4VN+Srv99CFL/oE +F/2OhWx8Lca/NPtKyzy7cbn9Ap/Wpry6fdf6GToIj3tOZqlYUvfjWL1IdZBd9P3vvz8PnfurxP2 1fyhZSF96LnQ0/Tt8Cfvme+HNtL248/+3cW/eELwL6E////5NJ/+IiT8XdVJcJx3UJ2eBL/uezKG vrHhn+SXhebR74dCNrSqD/XijF4JWSOfa37qOy1aR2pDs77CbEwY9aGITx49N/x06OXQvtBTocrQ AbojUuib7WN3K6pQA4+xEfzboZA9ZKHYDVzz90MbcC4vh3pCL0S+wfnUZ1i0NjwRevIrzHNT6GDf p3kHQ88BuyN85I+h7aEnEbsaaRrdr/IPZ8DML3+8f/e/f8c3MnRXhf9e4TP3+7/h6O99pe/jPmT9 PoGJ3H1fPM5AWAIrJz8TvP5elsHPH+8s/j/8FLEs5KNzsA/w7vsA75wK5IkBoQnUPrbvaJ5QecQN f/N8oO95Tm34r18i7Xb9D3MPZ7ynke9pxQl5Q98ONcIeZRmhEmoSye/0BPak0NRQXegReL/khvlt CHWHfkN/exM+WjobyeKwpWfLcce/+IXX4bNz6glb5LfdOKd+32NE/romH0zza4z/X3x3nyPf269N 0p1rITk0LXQeeelXIQvG6AqtwnntDj3e/6qwu89z+8P54UvO84e4X8LPCGvgWUI/CD1O99BJ+otP XTjn96uE6Mnz8F8G/K95wKePeOmzzzT+L3r9JfLepQqXvrv5KxNp14DPWd95jxQ2Ea+/wN74At2h BRHdIT/7pkpQ3cMMpCm0lDSFgqQptFK1QPUIW636geoHbA2pCT2lcqpWsi5Vu+ppto1rCrHdXFOI vcY1hdgerinEfql6XfU2+5WQJ4xnR4QCoZAd5ZpC7B1hsjCZHeeaQux3wjeFB9m7gk2ws1PCUuGH 7LSwWniSnRE2CZvYOeGnwjb2R2Gn8Ar7k/Cq8Cr7s7BH2MuuCAeEN9hfhN8Iv2F/Ff5TOMKuC0eF 37IbwjvCO+ymcEI4wf6ultU6dksdr05gt7kuEAuRLhAjXSCNOlOdqdKSLpBEWkCx6kJ1oUpHWkBx pAUUT1pACaQCNEi9QP19VaJ6kbpSlcSfvVAlc60eVSrX6lHlRr0StVe1gGv1qKq5Po+qluvzqIya eM1AVZ0mUZOi+gFX6VFZuEqPysVVelTNXKVH5eYqPSoPV+lReblKj+pRzd80H6uWc2Ue1eNcmUfV yZV5VOu5Mo/qWa7Mo3qeK/Oourkyj+qXXJlHtZcr86je5so8qhNcmUd1myvzqEJcmUcQuDKPoObK PIKGK/MIorhBfF6QuSaPEM81eYSBXJNHSOWaPMJwrskjjOCaPMJI8R3xpJDL1XiEAq7GI3xd/ED8 k3AfV+MRJnI1HmEGV+MRHuRqPEItV+MRHPxpDGGpJEiC8ENJlLTCMilWihXc0gApXvBIiVKi4JWS pRRBkYZKQwW/NFzKEFq5fo7wKNfPEZZz/RxhhTReGi88xlV0hHauoiM8zlV0hCekKdIU4UdcS0fo 4Fo6wlNcS0fo5Fo6QhfX0hGekYxSnbCOa+kI6yWH5BCe44o6wkauqCM8zxV1hE3SCmmF8FOpXWoX tkhPSKuFF7iijvAiV9QRtnJFHWE7V9QRdnAtHeFlrqUjvMK1dIRdXEtHeJVr6QivcS0dYQ/X0hF+ ybV0hL1cS0fYF50SnSb8mqvoCG9yFR2hl6voCEe5Ko7wW66KI3zEVXHUjKviqCWuiqOOj50bW6PO 509yqKdyVRz1TFkrD1A/zPVw1Avl78uL1U1cD0f9KNfDUT/G9XDUq7gejvpHXA9H3cH1cNTruB6O +nmuh6PexPVw1D/lejjq7fIm+UX1L7gejvo1roejfp3r4agPcj0c9ZtcD0fdy/Vw1Ee5Ho76Xa6H oz7J9XDU/yX/QT6n/gNXs1H/kavZqM9zNRv1h1zNRv3fXM1GfY2r2aivxwlxkvpvcXJcnPp2XEJc ojrEFWyihLiP4j6K0gxgA1RRIhNUryNDxSETDWDxTIW1dSBTY3UdjGgyG4LMm8ZGID4SP1o2io1h EstBRotGjxKsfRPZJKyppchuMmU3mbKbDtltHnp9Fz8DkOMewdiLWA16GCL5zobj2PEziTnYUjaI /RA/iWwZa2H3MC+yYRKyocwGq3SqOJZMT4elqOKRH1ORH0chkqXKYmNVo1XZiI9RjYGfg7w5mPJm LvLmQ8DZyJ5lpMg2WPUIcug4yqHjKIfmIYe6Efeo2th4VVAVxJgrkFVTkFWfYPmq1aqn2ARVJzJs LmXYXMqwuZRhxyLDvgC/G3l2LPLsG2y66qDqILtP9abqLVakOozMez9lXgGZtwD4deRfkfJvHOVf gfJvHOXfBMq/pZR/cyj/FlD+HYL8+wIbJnQL3SxNeFH4GUsXtiEjD6eMPJwy8teQkfcAf4m8PJTy 8r2Ul9OQl/8TeATZ+WvIzkeBv0WOHko5eijl6AzkaJllqnXI1CMoU4+iTD0SmTqZjVanqFNYtjpV ncom86wNH1mbZSFrjwJmqUejF3I3G8NzN3oVq4uBJeoS7J2kngQsVZeiDfI4EHkcEf6c3VR6zm4a PVs3lZ6tm0bP001BTvey4iglqo2pkNlXM13Uj6I62dejno7qYgOjfhy1nhVGPRv1HLsnamPUz9jg qG1RL7NkZP9X2Diu18bG8zWAFfE1gMXwNQAYr4lnEzUDNQNZLl8J2DisBMeZWvM7ze/Y1zQnNCeY TvOu5l0WpTmp+T3TYIU4jch7mvcQOaM5w7Sa9zXvM0lzVnOWDeIrB4vlKwfaXNRcZAM0H2o+ZPFY P/7EVJrLmj/jWFc0/80Gaq5qrrJ7+IqCY/1N8zeWpLmhucHu13yk+Qizuqm5iZn8XfN3+Lc0t+B/ rPmYFWv+ofkHRr4jCmygqBajWLGoETVMhXVIy5DGRYnFitFiDNOJsWIsU4uyKLMkUSfq2P1inBiH Nlir2ACsVYPQN1G8B32TxRS0TxWHsHgxTRyKkYeJw9B3uDgcmCFmYIR7xXvRPlPMRPsRYhbajxZH s3vEbDEb8THiGBYl5og5TBbHirkYf5w4Dn3zxDyMNl4cjzb5Yj76ThAnsBi+LuJY94n3IV4kFqNl iViCESaKZUwjThG/gZblYjnTig+ID2DOD4nfxnnNEb+D8R8R9Th6lViNo9SIRoxTJy5hJaJJtLCJ olV04IhO0cUmiU0i8ob4Q3EZSxSbxWbM1i224Fy8ooJxfKIPI/hFP0YIiAGM/6j4KPYuF5djfKzN LIWvzWws1uYfsfFih9jB8vgKzQZjhX4ae7vELpYs/ljEe198RnyGFYnrxHW4zhvEDcDnxI1sHFfW Q3us4hjhRfFF4FYRd6a4TdyGvi+JPaxM/Ln4c4y8XfwF9u4Ud6LvK+IriO8Sd6Pla+IetPyVuA97 Xxf3s3y+9iP+G/E3aHlIPAT/LfEttDksvo02R8WjmMk74juY1XHxd5jnCfEESxXfFd9lE8ST4kn0 AldA+zPiGYz2vvg+2n8gfoBxLoqX0P5P4p/Q/i/i39DmhngDV+Aj8SPM56Z4mw3mfILlgU/o4Mdp B7Lx2gTtIJaiTdQOZvnaZG0am6Adqk1nuWAbo1iRNks7mk3XZmvHsPu0OdocRMZqx7H7tXnaPIww XjseLfO1+WgzQTsBewu0BYgXa4txlBJtCVpO1E5EfJJ2Eo7CnyFVcdbCxnHWAgRrAYK1AMFagGAt QLAWIFgLEKyFJXPWwlI4awGCtbBUzlrgg7WwIs5a2GDOWtAerAU+WAv2grUAwVpYPmctbAJYixHt 66Q6dj+4i4XpJKvUiDZgMOgLBoM4GAxaKpKCcXySD75f8iMONoOZgM2g/RPSE2y8tFpajV7gNCwP nKYTkacl3F1Sl/QM/J9KP8Wxtkhb2HTOchC5Jl3DCH+V/oo24DpsLOc6LCWaf/BRFq2KVrHBnPEg AsYDxD82FowH62N0fHQ8ywfvGcSKohOjE1le9D3R97D7uZ4gGx+dGp3KUqOHRA+BnxadhnHAith4 sKKHWVzM3Ji5TIz5Tsx34M+LmQf/uzHfhT8/ZgFL4JwJkbaYTUyI+UnMVvhgTvDBnNAGzAlt/h6r YkKsEJvKSjl/YgXhJ2E5f2IC509A8Cfg9+XvszR5obyQfU1+RH6EDZAXyYvYMLlSrmQZsl7Ws+Fy lVzF1HK1XAvfKBvRvk6uQ5vF8mK0WSIvgW+SG9i9slk2o41FtqKNTbZhr112sKHgZE2IL5WXIg5m BnTLbqBHbmFDZK+ssHTZJ/vRslVuRcuA/CiOGJQfQ6RdXoWRwd5wlA65A/ikvAZtOuWnMecuuQvj /FheC/8Z+Rm0Xyevg/8f8n9gzPXyeux9Vn6WjZQ3yBtYFud8bBQ43yaWLf9E/gmbLG+WX4DfLXej zYvyi9j7kvwSsEf+ORsjb5e3Y+8v5B3Y+4q8i42WX5V3I/Ka/BoiYIpAMEXg6/J+lin/Wj6ANm/I B9kI+U35TbTslXtxlMPy24gclY9hTPBIjH9CPgF8Vz6JNqfk/8Le0/JpjPOefAb++/L7bDz45R8w 2jn5HBvJWSYbCpbpZ0N0rboAG657VIerBMYZZGN0K3S4Vrp2XTsbpntc9zgiP9J1sGzdk7on2WTO RBEBE2VjOBNlCZyJMoEzUSCYKCMmyhI4E2XjwIlyiIlOIyYqEAcNM84w14ztxyx17Hv40RGn/AZx ygf6ccpvEqdMJE55D3HKJOKUyf1UDzSkeiCS6oGGVA80EcUXrnqgIdUDDakexJDqgYZUDzSkeqAh 1QOZVA80pHogk+qBhlQPppPqQTmpHsST6sEMUj2YSaoHD5LqQQWpHgwGx40F49SpdMRuU8Bu8cMK iOMWguM+BDbJWexDqu+ovoc4Z7H3q4wqI/s6+KsT6FItY8UqN7js18Flg6wELHYF/MdUj6E957Jf B5d9mk0Ci13HSsFfdwBfVr3MJqt2qn6FvZy/Pkz8tYz46xTir1PBX/NYFPHXKGKuA4i5RoG54hUC c/0mGyQ8CP46iHQZwoo1caTLEEe6DAmkyxBH7PZbxG7vE1YIK9lErjrMZhPHTSNGO0Z4SXiJjRZ2 gdHeS1x2BHHZUcJbwltgrpzFDheOCccQ/x2Y63DSehgi/F54D1z2feF9INd9yCYVnCzhvPB/EPlA +ADItXCGkh5EhvBn4Qp8rgqRKfxFuAafa0OMFD4WbsPnChHDhDtCiA0lnYh0tUotwOdqEZlqjVoD n2tGpJNmRIY6Vh2LyADw5rHEmMcTY55AjHmWeog6DXHOm8eq7wVvzlWPBG8eS7x5nDpbnQ0/R41K Chx6AssHh74PfpG6iOWo7weTHktMOk89EUx6rHqyejLG50x6LHHobxOHnkMc+tvEoecQe54G3twJ 3vw0uPJA4spJxJVTiCsXRu0EV74fXPkAK4l6I+owm0yMeUo/JQsNKVnIpGQRT0oWFcShHyAOXUqq FuXEpIuIN2uJMWuJMeuIK2uJKydpzmvOgwdf0HyACOfH9xA/fqAfP04ifpysua65DuQMeBoxYG0/ BjyNGLAgimDAWuK+WuK+ycRxpxG71fbjtcnEZacRi9USi00iFjsNzHUs9n7CWacRW40VC8QCtCwU C9GSc9ZpxFbD3FRLfFRLHPQbxEEf6MdBv0kcNJE46D3EQZOIgyYT10wW28V2MNfHxcdZAXHNIuKX xWKn2Ik455epxC9LxfXiejaVmGWBuBHMspiYZQoxyxJxs9jNJoNfbkOEc8qHiE2WiDvEHejFOWUB ccqHwCl3oe+rYJYpxCwLiVmWiL8WD2CEN8Q30P5N8U2058wyhZhlITHLEmKWU8Rj4jGMwPllKfHL AuKXJcQvJxG/nEr8MlV8T3wPezmzvMspL4tXEeHMspCYZRExy4fEO+IdVkycspg4ZQk45WD4nE1O IjZZqh2uHcEmE6ecQpzyYeKUZcQgS4lBPkwMcgoxyBTtfdr7gJxBTiUGOUU7WTsZY3K9FZn0VjSk tyKT3opMeiuaftpRM0lvRUN6KxrtHO0cHJ2rrmhIdUUm1ZVyUl2JJ9WVClJdGUyqK4NJdUVDqisa Ul3RkOqKTKor8f1UV2RSXZFIdUUm1ZXBpLqiIdUVmVRXNP1UVzSkuiKT6oqGVFfiSXVlMKmuaEh1 RSbVlcH9VFc0pLoik+pKBamuaEh1RdNPdUVDqisxpLoik+qKhlRXKvqprmhIdUUm1RUNqa7IpLqi IdUVDamuyKS6oiHVlemkulJOqivxpLoyg1RXZpLqyoOkulJBqiuDSXVFQ6or5aS6MpNUVyr6qa5o SHVlMKmuaFADgMWC8Y9gpcTvJ0ujpFGsBCw/ixVLY6QxrFDKkcayAjD+XMTzpLwI7y+Q8qUJbCqx /wKpUCoC8hpgilQilWCcMqkMWC49AJwhPYjRKqRvoc0saRZqhodQD5RI35W+izivByZJlVIlZlIt VaN9WJuKVwhTUCHU4yjhCqFRsmEEu2RHL6fkZGVSk9SEiEfyYv68Tiii2iCFtKwKqEIollZJq4C8 TphKdUKx9JSE/EB1QgFVCCXSs9KziDwvPY+j82phClULD0svSN3oxWuGEuln0s/Q5iWpB8jrh8nS dek6RuD1Q5H0sfQxm0T1w0NUP5RS/VAcLUVLrIDqh6LomOgY+DrUD8XRA6MHoj2vIqZQFVFGVcTU 6KToJNQYg6OT0TIFtUQhVREp0enR6Wwyqoi5bABVDgNQM8xng2IWoHIYFLMwZiEiNTE1bGJMfUw9 0BRjAppjzEBrjBXoiHEAucJOHCnsxJHCTgIp7CSQwk4cKezEUQUSRTXGt2KHxGaw+2Jnxn6bTYw1 xC5jsyNKYLzqUKPSGMOiqJYYQ7XEaLmWaokfyPVgurx+GE6VwxhUDhb4VrkRDN4luxDhNcO9crPc jIhH9oLN8zphBNUJY6hOGI06YSUij6FaGE3Vwij5CfkJtOd1whj5KbkTe59GnTAKdcKPMRqvE0ZQ nTCcKoR7qUIYKz8nPwd8Xn4eyCuECVQhzJJfQIWQhwphK+I/k7excVQh5FGFkE8VwgRUCL9AZIf8 MsuRd8o70fJV+VXEeZ2QK+9BnTBW3ivvxd4DqBDGUW0wgWqDWfIh+S3sPSwfQZxXCPnyO/I7aMlr gwny7+VTiP8XaoN81AbvYbQzqBCGUoUwTj4rn8VxeZ0wnuqEXPmPMrgWaR5lk45alnxJvowI1z9K l6/IV+FzFaRMUkFKJxWkbFJBSicVpGGkozZU/of8DyBXRMqWQzKYGOkiZYAgg4mROtIw0lQbShpJ Q3SSToLPlZIySSkpm5TVsnRxugGIc9WkTN0g3SBEuHbSSNJOGqZL1qViL1dQyiYFpUxSUBpJCkoZ OvxgL9dRyiQdpXTSUcrQ1evqUf/wimgEKiIfS0NFhPtB16ZrY6NQEbUjzqugfKp/ZqH+eQp+p66L jaMqKF+3VrcWPtdjyiQ9piGkx5RNekwjSY8pM6zWxlRDrqUp2Mrqlex9xvQLYHqYEWaC2WBL+7aq xs3YtkRiAdhK2GpYJ2wdbCNsC2wbbAdsN2wf7CDsMOwY7CQT/GYypj9DJvgdsGXwz8Muwa7CbsBu M1YlwCRYXPjYVYmwVFh6v+3Ifr/nhMeqyocVwUph0/ttZ8Jmw+ZF+vDtQlg1bDEM86py9G0Fv0Km atwK2w5/eV8sbO2wjoi/DNYV8ddHbFPEumE9sJ2wPbD9kba91J5V8Tnz7XJYO6yD5hVue4Tasaou 2HrYJlg3rAe2M3K84/D3wPbDeNsjMB47Fdl/KmJnEeN2AeezC7a371xY1WXYNdhN2B3GqqNgMbD4 8HWvToKlRbYZn2z72meF7wG+pfbx4d/79ufCCmDFsDJYOaziky1//arnwOb32y6CGfpt62HWvq3g vxCed7UrfG7V7sg4/i9ndF/3t0DY+Dw+Nd6cf7IgbFVkG/zMOIKfz20NbG34taneANvcb7sVtj1q YGWxudzr0J+x3OZoFQgl4HlrHPCSNRF41ZoKvGFNB962jvQ6eC/lepVgzVFuVZaZK7zLKsvNc7xK lWTNJyzq8+OspV6F7/WxygrzfO/yqkTrdO/ysB/BOeZF3vaqVOtMwtn/5Kdb5wFHWhcCc6zVwHzr Ym877+UTK+ebDd6OykXmem9XVZHVDCy1OoDTrcu8XTzukysNZqt3fdVMqwKcbV3uS6isN7u8m6rm WdsJOwi7gAut64HV1k3AxdZuoNnaA3RYdwKXmV2+5CrFusc3rNJqdnu7q5Zb93u7K11mv7enqt3s 92VWus1B786qDmsvsMt6BLjeHPRlV22i+HqOlX7zKu+eyqB5jXd/Vbf1eB/2WE959/O4Ly+Cq8xr vb1VO7GX49k+f4/1AnC/9TKw13oNeMR6sw+PW+/4CqtONUb5JlauMW/wHqk62xjjPUKjHY9ELjTG Ay9z5BHf1Mq15s3eU1XXcM05zrzr87hvRuUG81bv2aqbjUnes9z3zaq605gGf7N5u/dCdVRjBmFW nx/TmAuMbywAJjUWA9May4AZjeXkVwCzzNt9cyu3mnd5L1duN+/1XqvObZzjW/ApLGic71tQuct8 wHuzcq/5kPdOdXHjIkJDn1/WWO+9U3nAfFSJqi5vtPZhRaNLiao8ZD6hxNT3LLtCeJ3wFnBnMwPu aRaB+5tlYG9zAvBIc7ISw3sFZtUfbx7WtqXyqPm0El95wnxOSao/1ZwJPNucTcj9C815ShLf27at 8rT5oren/nJzobcn7EfwnPmKklZ/rXki4dR/8m82zwDeaZ6lpC2Jap4LjGleoKTxXm07Ki+arysZ lVfMt5SsJfHNemBSsxGY1mxSsni8bXfldQtTcpdkNNuAWc1L2/ZV3rKISsGS3OYWwgDhSmBB82pg cXMnsKx5HbC8eSOwonmLUsB7tR1cMqd52/JzeqafoRQvmd+8QynWixZZKePYdlgvWxKU8iWLmncD Dc37lHIeaTsWjkcwwZKsVOiTLcOUOUvqmw/2obX5sDKHx9tORnCYJVOZv8TVfIzwZJ/vbj4D9Def BwabLwFXNV8Frmm+AVzbfLvtzJINbqHtvD7Tkq0sWrLZLSmLaDRDJLLVHXcXeaTtkj7bkqfUL9mO 1w7oTrzr83jbVX2epZCflzsV84ffdmzJLnc6/ELLRMW6ZK97JGFOn3/AnQ885C4CHnWXAk+4pwNP u2cCz7lnK1bet+2GfqJlquLST7XMUNxLLrrn9eEVwuvuhYob13YWrvAMy1zFv+SWu5pw8V3fxNxm xV950bJAyTCJbkcfyu5lSoZ+lkWvBKvnNLoJ/X3+/MYgcFHjKqChcQ2wvnEt0Nq4QQnyXj59tatx s8+on2sxKqv0CywmZU21u3Er0E8YJFzVuF1Zw/f6THq9xaas1esbd3HkfvWaxr3KVr3RstTbUb22 8QDhoX/yNzQeBW5uPAHc2ngauL3xnLeD9/LZ9CZLi7JBb7MElM3VuxovAvc2XgEeaLwOPNR4S9ms X2pZqWytPkp4wsZ8S/UtltXK9urTNpFQJkxQtutbbMnwz9mGAS/aMoFXbNk8blnta6m+bstD5Jat 0BfQByydyq4aZpsIFG1TlV36lZZ1yt4a2bLOt7ImwTZD2atfbdmobK9Jts0CDrPNxTiI+FoIV4f3 6jstW5QD+nWWbcrWmkzbgj7MtulxZRD3ddbk2Yy+dWFfv9GyQzlUU2gzEdr6cKJtKXCqrQU4wxYA zrKtBM61rQYusHX6Ntbobet8WzDObuVojdG2UTkKfx9wi+UgZmiybSHchlkhgnlusxxWTtTYbDs+ jTzu21az1Lbbt6OmxbZPKdDvsBxTTtcEbAeV09z37dbvsB2Gv9tyks7oGOEnfrbtDHCl7Txwte0S sNN2FbjOdgOv0RrbbZw7+uJ891nOeE/pD1rOK+dqNtqFPtxCuM0uKef0hy2XlIv6Y5ar/B6wxxEm 3sWaHfZU3AMnLTeUKzW77el9uM8+EnjQnuPbV3PYXO47WHPMng9+wrnB4ZqT9iJve80ZeynwvH16 ZAU/xtdB38maS/aZ3t6aq/bZ3l5aic7U3LDP46uSfaH3Qs1t8yHfeYNgr/beMUj2xd479H65ZIiz m/He4fftVUOi3eHtMKTalwHT7UrkHrvBX1/fbcNI+3LlkH6jvR2I6+AXDDn2Dn5N7F1AOlNDvn09 sMi+SdnMV5y226YEt4LVB5k/KJiS3cuVNNMwdzsw090Rzs9BiWe5YJwp292lzDfludcr83meCSaa Ct2beM5xdwORSYKpponuHmSPqe6dip/f+b4WQ6m9W6kwTLf3+CXDTPtOf5xhtn2P96xhnn2/VzEs tPd6lxuq7Uf8iWhzHG0W20/5Uw1m+1lfgsFhv6CsMSyzX/anGxT7NW+XYbn9pveyod1+xz/S0OGI 8ucYuhwx3h7Deke8P9+wyZHkLzJ0O9K8vYYeR4a/1LDTkeWfbtjjyPXPDPMNw35HgX+2oddR7J/H GYVvluGIo8y/0HDcUc5fBUeFvzq8shtOOeYAzzrmAy84FvkXGy47DH6z4Zqj3u8w3HRY/csMdxwu v1Ib5XD7l9fGOPz+9jCnrZrnCOLVJ+4UZim18Y5V/j7e6Fjj7apNcqzFSo17w99V1evY4O+qTXNs 9q+vzXBs9W+qzXJs9ztqc6llgWOXd39tsWOvv7u2zHEAfrnjkNdRW+E4CpzjOOFtr53vOA1c5Djn 3VRrcFwE1juueHtrrY7rQJfjlvdIrdvJgH6niPkEnTJwlTPB31M105nsXV+7xjnMv7N2rTMT3ANX wL+ndoMzO3Jv62s3O/MwzlZnofdO7XbnRP/+2l3Oqf7e2r2cYdYecM7wH6k95JzlP87fF/5TtUed c8HSwdX9Zwkv1J5wLggzcP9lwmuENwnv8KO0RoWx9rRT7+2oPec04twvOk2Y2xWztTWm9rrTFvHj CZP4+6s1rfYWv5KcD7dmEGZx3tuaa2TOpa255BcQFhtFZ4t3j1F2BsCHwYpby4wJzpVhDtxaTlhB OKfqgnO194gx2dkJHMaRs9bW+YSLjJnOdWGm2mowZjs3ek8Z85xbgIgjUujcFmatrfWEVkIXf9e3 ugn9YTROdO7wXjZONe9qDRpnOHd7rxlnmfe2rjLOde7z3jQucB4E6p2HvXeMRucxcEu8Lq1rCNca Tc6T/rgaoxNZ0Whznm/dYFzqvNS6GRFkRWOL8wZmHnDebt1qXOkSWrcbV7skZa+x0xXXusu4zpXY uhfx1NYDxo2u9NZDxi2ukcjqlL2N21w5rUeNO1z5yMbHXEWtJ8KZ0LjbVdp62rjPNb31nPGga2br ReNh1+zWK8ZjxAFOu+ZhLQivMpS3w2u08aRrIVZ8rLat141n+GprPO+qxkqHrNV6q2aGa3HrLeMl lznAjFddDmWX8YZrWeu58Lpck+lScC63Xcs5l3C1K8E6wdXB13RXl7ejTnKtv7va1sW5NvH1y9Wt HKpLdPUgkuraCUx37bm7UtSNdO0PiHU5rl74+a4jAbmuyHU8kMDPLpBcV+o6Fcm0trrprrMYZ6br grK5brbrcmBY3TzXtUAmrszNQHbdQtedQF5ddVNUoLBucVNMYCK/boGpNM6MGtYUr+yqMzclBWbx HB6YG2E7wMACQv1dVmOxBYyExHMCNsKlfA6BFsJAnaMpTdlQN7MpAzNZxtlInWJZ6Rfqljdlhf3A SsLVfC0IdPKsG+isa6crDHYRWEe4kfjDjbqOplysF/ADWwg767qaCpQDdeubisEowCsC2+o2NZWF WYRf4BjYQbi6JrOpXDmKvRXA7qY5kRX/BsfA7rqepvnhVT6wr25n0yLlRN2eJgMQcUT2N9WHV/nA QcLDhMf4OhU4Sbia8Exdb5MVazdW8FZD3ZEmF1ZqrOOB83XHm9zKxbpTTX7lYvWBpiDujd1Nq5Qr dM0vEV6l67Cj7mzTGuV03YWmtcq5ustNG7CmEwutu9a0WSkwzXDvCaabZrn3B26b5rp7gyNNC9xH Hu016d3Hgzkmo/uUt8dkcp+lNhfQxua+DN671H0tmG9qcd8MFpkC7jvBUtNKT1Rwumm1JwYjdHri gzNN6zxJwdmmjZ40pcy0xZMRnGfa5skKLjTt8ORi3dztKQhWm/Z5ir2XTQc9ZcHF4erAdNhTrpSb jnkqgmbTYXd62zHTSc+coMN0xjOfr6qeRcFlER5+3mMgrAde8liDiumqxxVcbrrhcQfbTbc9/mBH g+AJBrsaJM+q4PqGOM+a4KZwBbok17MWNVe40qGaoiHRsyHYHa7yGlI9m4Hpnq2oCPha37Mk6Nke 7DGJnl3BnQ0jPXuDyxtyPAeC7UviqWW+59Dy7Q1FnqPBPeE6q77Hg5q3odRzGvXsNc85Ja1huuci 6spczxWloGGm5/rdozfM9tzCHKhKapjXwlAxheezsEUEVrfIwf1LMloSlNyGxS3Jwd4Gc8swbwe/ AsEjDY6WzDBXadvRsKwlG6MpLXmKv2F5S2HweEN7y8TgqXA92NDRMjV4tqGrZUbwAuc5wcsN61tm YV1DZR28RnizYVPL3HC9HLzDsTWLoy+T44oofpQVdKwV8Sa5Bde/obsFtXBDT4tRyeX174qkhp0t poifRpjB+dKKu1cS1euKXMICPqsVxQ17WmwriskvIyxv2N+yVKlo6G1pQfWKGnZFRcORlkC4Yl0R xvmEqCtbVuKKHW9ZfRd5jem7zXGFoeFUS2e4rlxR33C2ZZ1S33ChZSMQcUQut2wJ15g4OscyQqo0 V1DNuMJF6G74v+x9D1Ac15nn62EYRhiPMcaYYEwwIhhjTDBWsEIIVmRMZBmGmQETLcaYYG6mu2f6 D8P86WkUjIhmwAqnwlqtwmoVRcdyOpWisIpKR2StrCg6hWgVSuEUVsuqdCqsVSmKllJ0CtFyioLv e1/3wAjhWKndq7qqpL76vfem+/Xr1+993+/7+tHd3OoagTtHuH98r0eY6zoM94lwF/lenzDfdbR7 jWjsOgFpYtcYxHimrvHuHDov723FdPvbs13n3tspJndNdVeJaV2XujeKmV1XunvEnK7r3YmuueCB 7j7nluAhYK354BGIURVgxQOsMXj8mxfZxOCpzbfZ5OCZTTvYtODEJoXNDMK920J6cfNdNid4OWyA 9BqmNyDND86GzWxR8E7Ywq4KTkDEjvd0zi0KgZbLFFM4lV2jJIUz2ColJZzt3Ef5k6ZwlmolPZzH OrzF4UJ2A6QlrbMK3MGxzUpueDXbphSEK1heKQ5XsrJSGl7PBpTy7lM0DdsoT4Yb9HsrTNmNytp3 59ge6XC4ie1T1oVb2a2KNcyy25X6sMjuVBrDPnaP0gLpTsUZVtm9iifcjWmEPaB4w/2QKpAeUrp6 DkK6uecg5dLwNvaIsiU8yB5XBsK72VPKjvAwe0bZFd7PTihD4YOURcOj7HllX/gYe1EZ6ZbZy8rh 8En2mnL03QvsDeUEcOB6ZSx8mp1VxsNnNQ9F0/Bky1TgZPhCy5RyLjytRW7/6YwyFb7K3lEuhWc4 olwJ33p7q3L93dOcSbkZnuOSlNthM5ei3A3Pc+khQ08DlxUyR4xcbsgSSeQKQqmRZK44lBFJi22N Kw1lRzIhzYvkcOWhwkg+tzZUEini1oVWR1Zx1lBFpIyrD1VG1nCNofWRKq4lZItUc85QQ8TBeUJN kQ2cN9QaaYaUjbRxSkiM8FxXyBeRuc0hdZOT2xLqjgS4gVAkspHbEeqP9OjprtC2SJ+mLa2zocHI Vm4otDuyndsXGo7s5EZC+yN7uMOhg5G93NHQaOQAdyJ0LHII2jkJ7YyFTkeOcOOhs5Hj3LnQZOQU NxW6sGkfdyk0HTnjmg9d7T7DXQnNQHo9dCsywd0Mzb07Dek8pLdVY+Q8d1dNjFzkDWpy5DJvVtMi 13iLmhm5waeqOZFZPkPNj9zhs9Wibp7PU1f1Er5QLes+z5eoa8Jz/Gq1qtfEV6jVPQf5StUBfcOz 8OvVDb1JvE1t7k1pqVfbetNbWlS+eyffoMq9WS071EBvbssudWNvAaQ93RN8k9rXWwzp1t7ilhF1 e28p36ru7M5pmVL39JbzrLq3dy0vqgd61/E+9VCvlVfVI7313JB6HEYJ0t5G7a6f71ZP9bbwEfVM L67b9GKs0uvl+6WuXkWzOBpjbCrQVyrutY6j2lqBtjIQ3sZvUyd6u6h/791M78F7t+g6iatDdG1h 0w5+UD3fO6BFYvxu9SKkw+rlTV599QbXVVij5OndQa2jd5d218/vV6/1DuFd521iIE8wN5n/TQjz WwZ+MXeY3xEj87GBISZDvMFEVhgeMiSRhwzJhkfJw4bHDWnkEUOG4UnyqCHHsJI8Zsg3PEseN3zH 8B3yRNy6uNdIenxV/FdJRrw3voNkxv84/sckywJCPmvJttSQbIvN0kSslrctYfKm5X3Lj0iP5bRl hvzAcsNym5yH3tiJEd9ftZBHyAryKKknD5EG0kpqSRv5Fmki/5lsJZvJAPkFiZB/JB+RM+RfmETy T0wS8zD5mHmEeZxhmAwmnzHT5xeZJ5hGxsVkMhwTYQqYPmY7s44ZZL7DvMH8d+bnzJtx34/7PhMw +ox+JmjsNvYwIWOf8VvMRuP7xveZbuO3jX/NbDJ+1/i3zGbjiPEg855x1PgB02/8kfFHzIDxJ8af Mu/j23/bjeeMv2C+bbxknGb+2njV+Ctml/HXxl8ze4y/Nf4b81/o02zMcPxj8Y8x/y3+F/HzzD5T vCmXmTQ9Y3qGmTU9aypifmt6yVTG/I6+qcB8bHrFVGkwmqpMNQaTqdbUZLCYvm5qM2SanCavIdvk N3UZnje9Z9pqeMk0YNpl+LLpu6a9hvX0PQCDwzRi+pmhznTWdNbQbpowTRm8poumi4ZO07Rp2rDR 9EvTdcM36PNShk2m35hmDRHTbdO8oS+BJDxseD8hJeFxw3cTnkhYafjbhLyELxgOJnwlwWM4kdCR sM0wk/BXCX8VR5/12RX3cML3EkbiHqP/Dy7uiYQfJhyJy0w4mvDjuCz6vE5cXsI/JkzFrUq4kHA1 bnXCrxL+Le5Vc575UFy9+Tcrno77yPI7y++M9I0vD+mDNIlk0TeCv3ITcJeQtSWAPJInDr3Gi/vE EfHwawfEo+IJcUwcF8+JU5LZ7pMsUqqUYR+VsqU8qVAqkVZLFdV3arK+OmQ9Jl6qIeIV8bp4U7wt 3pUMNVmv94NWGUHHb6KO/5YwzMfMx8QAGp1M4mDfU/hEKDF8z/A9whi+b/g+7Dto+AGJM3xo+JDE 4xOhJsPPDT8nZnyXaYXhF4ZJkojPgibhU6APGz4yfEQs+PznI4ZfG34d/e9fcUwcs/DfDuPjTCQN 331Kj0uLSyOfiUuPSycZ+MTmk3H5cfnkKXyvKSuuPK6cZONbTE/HrYn7CsnBdzxy8ZmNz0H/k5gU HDmaEjGTQPwg5oj5YpG4SiwT14hVYrXoEDdA2iy2ibwoAwLiRrFH7IN9W8Xt4k5xj7hXPCAeEo+I x8VT4hlxQjwvXhQvQ3pNvCHOwr5Z8Y5EJIjKJIi3JIh2JYia7pETEsRCEsQ9C2KV6qVGqSVGnJJH 8kqK1AV1F2VMGod0s7RFGpB2SLsWZEjaJ41Ih1GOQnvnYFupNAWlS9IVKF2XbkKbpdJt6a5skLbA 9TMrPDpr0PfKH8UxSQeJI5kgRpJHniHxpBAkgXwexEzKQFaQcpBEUgHyEKkkr+L7g68D62hvDv4F acQ3B5uhvTaQxwgLkko6iI88TkJEJU+Qd0E+Q74JkgF89D55knwb5CnyNyBZ5L+SveSz5HsgT5MR kBzyAchK8vcgueRDkM+R/0FOQf/OgOTj/+98lkyRfyYF5H+BFJJ/AXme/BKkiNwiv4G+z5H/Q14g 8yAvMgYmgaxiEoH7yvA57i8B9yWTcnyOu4LJYp4mLzMrmZXkFXxjsRLY0EZexf9zV8W8xbSQrzKt TCt5HZ/prsb3E2sYD+MhVkZiJFLL+JkAsTHfYHqIA7gzQjYAe75H/oL5FtNP3mQGmAHyFr6f2AxM eoS8zRxljpJ3mBPMj0kbM8b8lDiZf2D+gbDMz5hxwqH+uoEF8onHXGAuIBI+PSebXzCXkHZ8Yq7D XGYuIz5zhbmC+PF9mQA+Hxc0t5i/TkLmd8zvkE6Y26vkNup+Kf3ejZACSAdkAXIBBTqKdZQCysnX hHQhS8gVCoRioVQoF9YK6wSrUC80Ci2CU/CAeAGK0CVsFrYIA8IOYZcwJOwTRoTDwlHhhDAmjAvn hCnhknBFuC7cFG4Ld0UDiFm0iKlihpgt5omFYom4WqwQxsRKcb1oExvEabFJbBVZURR9oip2ixGx X9wmDoLsFofF/eJBkFHxmHhSPC2eFSfFCyBXxRnxFv2/aPGt8Rw4wbcszaCxBtDP/yj9rgF5BLU8 GbX8UdTyx1DLU1HLH0ctT0MtT0ctz0AtfxK1PBO1PAu1/LOo5dmo5Tmo5StRy3NRyz+HWp6HWv4M avmzZBykAHX9OdT1QtT1ItT1z6OuF6Ouv4C6/iLq+hdA1w2kFPX7JdTvLzJPMVmg91Szy1Gzv4ya XYHvKbyM2rwGtfkrqM1rUZtfAW3+BtjAu8y7YAP0bYWvojavQ21ez/wl85dgD1Snq/E9hRrUZitq s40ZBz12MGeZs6TO/Ib5DVJvbjQ3kjfMnJmjbxwndydvgXlKgrF/iDC+Q4R4tgAGADsAu2DbEciH APsAI4DDsO248VFPv2+HmPuHgXUKAkWebb5dnkHfkFh8L+g2z27fPrEUUB5YReEZ9o2Ia/8waB3P ft9hz0HfUXHdIuhvz6jvhGgF1AfKPMd8Y2LjHwbWaQms8Zz0jYtO37jntO8c4qxvSvQAvIEqLCuB arEr4PBM+i55LviuiJsXgb+3BDZ4pn3XxYFPwY5AM7Zx1XcTMeO77bnluyvu0kDLnjm/QRxaBP3t mfebxX1+M80pBKPfIo58Omg9IdGfKiT7M8TD90JI82cLmf488ei9EHL8heKJRQj5/pIHQcd2dVwo 8q8WVvkrlkWZv5KiY6d6jkJY41//QKjy24Rqf8MnoWOPOiU4/E0PAu9w6KKwwd+KaPaziDa/SNGx V71Ec++kmtRxQL0i8H6fIPvVpfAeDF0TAv7uT0PHIfV6xxH1prDRH0H0+PuFPv+2e7DVP3gftvt3 34Od/uEHxh7/fmGv/+B9OOAfFQ75j92HpWN9xH/yQSCOBdqE4/7Twin/2WUB+8TxAC+eC8hY74x/ 8oEw4b+wrO7Q9qYAlwIB4bx/+kEgXglsFC76ry7gsn9mAXT/dcDNQA+Wbwf6xLuBrcI1/y3s7xJI hsB2LN/wz30aJHNgp2QJ7LmnjVn//D24EzAuhZQa2CtlBA6IJJAoZQcOYZ4XOLJcfz4JoimQLCYF 0u5DSiBTTA/k3IesQH4spMLA8Si338PFOldGOU4qCZyKcpC0OnAmlkcW9CR2XqPzEh2jisDEwthW Bs7H9gm55DhwCuhjxylNLzvO6DZM7WoCcF69TfW94yLgsno3qs8d1yCH80jrAxclW+Cy1BC4JjUF bkitgVnqXyQ2cIdux2sDHyGJQUJ9ieQLmiQ1mCR1B1OkSDBd6g9mSduCuZTb6TVLg8ECaXewmPKz NBwslfYHy6WDwbXIy8DpdCyk0eA6yp3SsaCVtiudDNZLp4ON0tlgizQZdEoXgh5pOuiVrgYV9JHU B1GfQMdwJlAk3Qp2UT8mzYH/iY7zfNAqG4ObaRt0n5wY3CInBwfQ90R9bcwcLbRJofuUqC+g/aK+ UU4L7pAzg7vknODQwjzT+jB3dO7l/OA+uSg4Iq8KHpbLgkdx2xrw4ds0UH9N/fY9GNb8slzlO4z+ GM4T9cU0R4D+4LUt8bE0p5CrfZcoqH+M+tUoZIfvJsWCj6Q+U/eNsb4y1kdG/WQU8gbwg+AL0feB P5Sb/dkUqLfUz+VokNuCJ6heynxwTJaD41gOBM/JG4NTqLPAH3JP8JLcF7yC+7YGr2O+PXhT3hm8 Te1W3hO8S+0Jr2uvYpAPKGb5kGJBu4jagc6LlEvlI0oq5Tn5OHCTbiPyKSWD8hY9PsqB99nWErta 4BfdtmgblDflM4FZeULJpn1cOB7qU3uTzyt58kWlUL6slMjXlNXyDaWC9ptyEr0GeVaplO8omm/4 NA7S+9VOdB6P8tJUTB29z3itS/h44XooD0fxSef6BD5tN+l5UiCRzkUU9/FkLFdSfoxyZAwf0rrY Dq1DuQnGoD0lcKDjRqeBznHHbKeZXmfHnU6Lj3Sm+kydGXQ7cpas7vMldWZj/AJ6R+v6UjrzMN6A uMOX3lmIMQVwmi+rswTjND0m8OV2rvYVdFZQ/+8r7qykXOcr7UQu9JV32iiojfrWdjb41nU2+ayd rZSHffWdrK+xU8SYDPjS19Lpw2OdnepCzERjHj1Gwbb0Nug+n6ezu8OhbsF+RWO7aGzgWORgRDSG 0WMP2ha24e2MeDNCDjwmejytTzma/qZ6QceAXpvS2Y/baNwYhR4n3oMHiQVp36IxXUxctwAaz0Wx NK6LxmjLxGa+Lg2fGpvR2Cs2/qIxVzTuio2xaF/psbROdEx022pPV2yYZykN7blKE+oqjXmidlWg tLYXKyyiVBHbyxVf+1pFbV+ndLdblQiiXulvb1S2xep7e4syiHAqu6l9tXuU4Xavsr9dUQ62dymj y9ob3B+0b1aOtW9RTrYPKKfbdyhno/bWvkuZXCgPKRcQ+5RpCrS9EeVq+2FlBvOjyq2oDbafUOba x5T59vGQccH+wK7az4USsT9ToWTKWe2XQmnU90RBY8r2K6HM9uuhHLzmm6H89tuhIspdlD/a74ZW UZ8Sre81hMq85tAaryVU5U0NVVN99GaHNnjzQs3ewlCbtyTE07jAuzok03bo+HkrQgFvZWgjxrYw /971oR6vLdSHaAhtpWNOx87bFNrubQ3t9LKhPV4xtJdyt9cXOoD11dAhb3foiDcSOk5jQG9/6FSU m73bQmeifsk7GJrw7g6dp/cj3v2hy/SewjsauuE9Fpr1ngzd8Z5WCR1H71nVRO9HqO/2XlBTaBve aTWdzrP3qppF7co7o+Z6b6kF3jm12DuvlnYY1fKORHUt9e90X0eyuo7aHNaDfnekqdaOTLW+I0dt pH3vyFdbOopUJ53zjlWqp6NM9dLr6lijKh1ValdHtboZOUHnXMqTHRvUAeorO5rVHR1t6q4OXh2i fNcRUEc6NqqHqe7S8aLljh71KOoz6EJHn3qiY6s6RseRGAhjiVgGCPnzX1D+hP6CMkNuLf4dgKsm Hk7mAtxGrofr47Zy27md3B5uL3cA0kPcEa5alwDiOHeKc+hyhpvgznMXucvctYZj3A1ulrvDE97U cJVP4lO+lsanN0zzWVybJlADwOfyBRyvScPpryXzxXxpwyhfzq/l1/FWvp5v5Ft4J+/hvbzCd/Gb uQ1RgRpb+AF+B7+La9aEH+L38SNQ7zD2j/aI1qT76BnhDHSd/+H9oNuv/Yesg9aAbdSCPIrroCm4 DvoYroM+juugaYQlPHmCeEAycDX0SVwNfQpXQz+Lq6HZuBr6NK6GrsTV0FxcDf0croY+g6uh+bga +iyuhhbgauhzuBpaCDY3TorIWZAXcDW0BFdDX8TV0C/gamgp+SX5FXmJ/CtIGa6JfgnXRL+Ma6Iv 45roGlwT/Qquib7CZDFZpBLXRF/FNdEqXBP9Kq6JrsM10ddwTXQ9rom+jmui1cw3mHeJldnEbCJ2 XBN14JpoHa6JvoGroQ1g6T8kX2M+YD4gjbgm+iauib6Fa6JvG7cYv0Va8Ft5rcYjxg9IG9j1GHEa rxl/RViw39uEzp9CuhZ1lU0lJWwqm8Fms3lsIUgJu5qtYCvZ9ayNbWCbULaxg+xudpjdD3KQHWWP sSfZ0+xZdpK9gNLKsqzI+vD4QlbFtJuNQNoK0k+F6o3hOdCb53W9ScHzU40xwBw9A9pDdcUI418C 2kN1xYS6kgCa8iroEF0zXwHa0Qg6RPXjIdSPJFwnfxiuyw2aRLUhGXThfdAnqgcpoAV7QZ+oBqSS H4A8jhqQhhrwBMz/KdBbuh7+GZjzfwYNo7P+JM56Jq6BPwUzf51k4RxnM8kwx0/j7ObgvK7EGc1l 3mZayOdwRp+BGZVJPhOAGS3AVe7nmH6YxUKcxef170jSNe3PMz9kjpBiwphLzeWL8+FqMD7qalgq bA/b52pytbr6NWG3uprY7VRc7FJhd7pEl08Tdo9LdansXtiyRNgDrt2ubpAIiNbmIcy3uQajwh6B OvcJe9w1DC3sdx3UZVQT9hSmZyA9dr+wE66TrtMLEnGORWWh5chSkU64t7rOuiajIo25LugyvVSk cejVVU2kc64Z1wybCFuWiDQlXXLdkq645kDmqUjXxQnXPGtkE6Mi3WSTlwqMTp9rmCt3TbJpmjjP aSLdZjPZTOk6m7nYz5ge33UOsDlRcc2x+VGBFrW2i9jzS+QiexnOs2pBrrFlVJwD9181e8OVwa5Z EFovja1aIrOAO2w1ioN1cETbzpm4JMg3aK1T4VK4dLb5fuGy2DYul+VRX7q5AnrFVLhirpQrd97l 1nLrOOtiOzEt1jvPxeiTzAa4Rk3YjZpwLVS/OSfqrsh5OC/VBU6hOsN1Uf3gNrPnuS14tVXcALcD e7QDW9/FBtgA1RTZgOMxLJtlCx1VOZWOvpxBR5ob4vZxI9xh7ih3wtXEjcFx49D2OW7K5eMucVe4 664IdxP6t5u7zd3lDbyZt/CpfAafzefxha7dzhN8Cb+ar+Ar+fW8jW/gm6DHIvTyGN+KVhbhWV7k fbzKV7p8fDcfgbao1eIVYc3daCdwRXy/S+W38YP8blcDPwxtj0G9VrClUX4/lJr4g/wopMf4k/xp /iw/yV9AW1Y14af5q/Rq+Rn+Fj/Hz7uNYK1UBt2J7mR3Guo4nMmd6Rp151BrdOcDityr3GXuNe4q d7XrpNvhOu3eQFuhlududrdpmsqucvNu2R1wb2Qd7h6Xz93n3sq2sZnu7e6dMMob3Xvce90H3IdA X6tgBsrcR9zH3adA5xzuMyATbLX7PGpgEVukzRXWa6YaQ+fKfRFw2X3NfYMtcs/CnoD7Djh1kyfJ k8Ku8qTzuz1ZnlxPgWvSU+wppUd4yj1rPetArKjjZdwW3FrvafS0sA6P0+PxeEEUTxfoMJUyz2bP Fs8A9LrN1e3Z4dnFZnqGqJ569nlGPIc9Rz0nPGOecQ9YrWfKNei5BPoo02vzXPFc99zk1oKGBtgi z23uBIzNKLcWLO6CnA3c1SxOyHlyoeuqXAL6PO+ak1cDUyTLFdwVuRJsedI5Jq8XJ8QJateuStnG 5ssNcpPcyq/nsqQkGO1hqpXAZpSf5uhpoRbUgF+nZRGYivIdarBWkzIMzkula0b2OQdkFXS8G7bn Q71J4KtMmR5xVu6Xt0EfB+Xd8rC8Xz4ojyILzsjHKAPKJ+XTcLaz8jZ5EuUC8JxR4zp+VMazUQ2W B53n5KuUzeSr0DKtOSPfkufkeddJuV9jLuSuZNkAMghjmkN74r7muSvQT7yZBYuQCgy1T8gQMpz7 QFf2CNlCHuUkV6tQyPuEErZMWC1UuHuESrZKWC/YhAahid0gtAos7BEFn/uaoArdQoRarNAvbBMG Xd3uncJuYVjYLxwURoVB4ZhwUjgtnBUmhQscEaYBV4UZ4ZYwJ8yLRr5QTBSTXfuFC+5rrmNiGtRu ck27+3APPpPj8tGnctyHuH30yRzX7oVnc5rFNte0yOPTOfqzOa55+myOMMld0Z/P2eo6uewzOtfE G8KkOAu2Nscl0ad0uCTJBHrqAH21wswfZANSCnBjvnNs8ckdDryFVMomS+nuZP2pHf1pHbZNqheL 9Cd1svBZncUnc6JP5Bz1eDGaev7Pd5h/QneYLJHxqYY0SInzCmFcJSTVOQ1y1Xn1raa3mpwzIIPO QSzfct56a/qtaeccyLxznm5zGUESXYl0W1NXU5crGSTNlda8qnmVKxMkx5UD5zFYrJZaOEcy3tEQ vKMx4L1MHMa8RryXice7GBPGvAl4F2PGu5gVeOfyEN65JGHMa8GY9xGMeZPxnuVRvFt5jDDJbcki XhM+d+hsI4yzD3K4R3FuNT66ft7Z8yCo3uXsed0ISPwEJGuoHtHwetoDIhOQswzyNVSPQV70YKg+ B/kqHWU61mhwNmt59XXATShXAarvR/VdyB2fjhqz3sYGHbT9tiXgl4G8BIE/AhsBPcugD7B1GWxf gp0PBocJ8j2AvZ+AAxocSRpeP/SAOAI4/slwpEB+6sFgp7pzRseEjvMaHOlabof5cWRB+SLg8v2w Uz279ulw5AIKoHxDxyzgzr2oJsvAtARJfwRgLKrTlwFcT3Xu/Vg61tUFD4aa1ZAXA0o/AbCvpgJQ qdcrf0CsXV53sA3apg3ydQ+GmgbIrYg+zOtjEK3TqucsQIRy4+K5YlHj08stn44aFdC9pA3nEnju R00E0A9lL/BOm5bXDC7fn0+EAuhaBpsBW5bBwL2o2b3I3ffwbZQvozw2vMgvNfvv5Y8FPYmd1+i8 RMfoYMzYjt7bpwVOidXNqA1HbYu2peu8o36JXtP5PAY4CTgNOOvsqaV9AP9Sc0HbTq+J+oiaaSf6 EidwbM0M4BZgDgDXb6V+q1q7Xiv4Kiv1VTAvVjjWCsdYKQ/IOqfDOFjzNb60FmntWsGfOGG/FfyH FTjFCm1ZaVsb9PGNjiccS/2klXI/bbNscZxpW9aA1gbdZwUut/Zo/bpvnpbM0YI/0eeJtkV9oxV4 3wrzZN0ec7xDmzv62wpjbwUet4LdWQ/odYwxSF4GS/1y/jIoci761xgfu4CqGCz1sVF/+e/xkxud 9/rCPueiD4zxd9bzml5agf+tl/Uy6Jz1hq6zoG9W4HLrHe13LdFz4OraJM1ua1M0e6LXVQv8Wwv8 W5ur20XUDnRepFxaW6DzXP2ijdSWavxFj1/gwKW2tcSuFvhFt61anYup/teu1fq4cHyLZm+1cHwt PQ+cuxb4r7ZF6zfyElxDLbRX69GP+zT+WcLjy9aJ9nkZPl5AYww+6Vyfwqd0Hu7BUp6M5crNMRwZ y4nF+rFd+r4CjaMdLdocO5zadTrgfA6o51C07ZSz7KA7DjgO45eNWl0HnAPjDYg7HJTrLut8NqDr ph4TOHYAgBOo/3cM6Ty3T2vXMaKB2qjjMOAo4ITGww7gNMe4zp/Al45z+rFTzsWYaSKGR0cW28BY 6hL0+5Ter6U8vISDF2KYKA+P6G1ccfbY+vVjosdf07gZf+/VxgCv7bq+bU8MDiyDB4kFTzkXY7oJ 50Jct4CLMVga10VjtH9PbJbivDf+ynIuxF33+LLj+rHpi2MSta3aLXpO7W6HczHm0e2qFnSidkgH 6EMtjHktzF8tzF/tCR2gA7Xj9+p77TkdU5p91cI818I81cL4195c3t4oN9beBsC9jc0AMC/am80S U07VkaGB2p4tG5Cn54WLNmgrAQDf2Spi7A+u2Vap9ce2XuMsm03zPVHQmNIG8ZytSbtmG8RtNlbj LsofNlHzKdH6NojXbBCH2SAOs0U0fbRtA0A8ZYMYxzasxQW2/Xo7MH42iElsoxof0/m3QQxhO6nj tDbmdOxs9LhJAMQStmmNu21X9foQQ9gghrDNaTGgbd65wM1246JfskM8YU/W7kfsmdo9hR18pB18 pB3iBnuZNo72Ndr9CPXd9mqtDbtDm2f7Bs2u7HAPaQd/aAf/Z6dtg6+zb9T8O+7r0WyOlmm/7TCv dvB59u1a3+2gf/Y92pzbab0D2nXZKYeBvdmPa5ywwLnAYfYzmq+0g53Z6T3TRY3v7LQ/NzTdpeNF y/ZZTZ+pLthhXB1EG0f6NMbDJx/+yZ+fxvhTWiszFhhP0b+oGs6QvyMkIRuQBygElABWAypi8ko9 Xw+wARoATYBWAAsQAT6ACugGRAD9gG2AQcBuwLCO/YCDgFHAMcBJwGnAWcCkfq4LgGnA1Zh8Jub3 LcAcYJ4QsxGQGJMnA9IAmVp9mptzAPmAIsAqQFlMvgZQBagGOAAb9PrNgDYAD5ABAcBGQA+gD7AV sB2wE7AHsBdwAHAIcARwHHAKcAYwATivXZf5IuCynl+LyaP1b2hjivkF/Tg2Zv8s4A7+i2+ywgQA e12RspjT8VmRDsiKyXMBBTF5MaB0Mad9XlEOWKsfv+6PA85ZLNZroOe/p730JbAC6vXcen87KxoB Ldp4r3ACPDG5F6CQv7NvsQ/Yd9h32Yfs+yhMin3Efth+1H7CPmYft5+zT9kvmTz2K/br9pv22/a7 DoPDDGJxpDoyHNmOPEeho8Sx2lHhqHSsd9gQDY4m/N3qYB2iw4dQHd2OiKPfPu7YZvI4Bh27HcOI /Y6DjlHHMcdJx2nHWcek4wIcN+246phx3HLMOebrjHWJdcl1aXWZdTl1+Q5fXVHdqrqyujV1VXXV dY66DXXNdW11fJ0MCNBj6jbW9dT11W2t2163s25P3d66A3WHEEfqjtedQpypm0Ccr7uIuFx3re6G Samb1eXOQomW79QTXUwgSY65+hTYflGT+vT6LEB6fS5IAUhxfWl9ed1s/VqK+nX1VvAJn1n2iwtE /+KCGb+4kIhfXEjCLy5Y8IsLyQb6xYUU/OJCKn5xIQ2/uPAEfmvhM5ZsywvkScuLlkryvOUdC0te tngs7eRVi88SIq9buizvErtlsyVM6izvW/6evGH50HKcdFtOW/6V9ODXF/b+f9wzhklhZHxe5Sh5 jpCV53WApa+8rOOajhsxZQqw7pV39PJl+o/btXKuSUeSDrD0XLCgXLDuXKiUW6DVzS3W69NtpTG/ y/V8rY51i+fMtWq/c+vJc3YTSJI9xZ5uzwLJtRegFNtL7eX2tfZ1dqu9HqXR3mJ32j12r12BrV32 zVDaAkcU6Nao2SO1xCH7UZirR/BLGwS/sWHAb2zEWUosJcRoedVSReItr1lqSAJ+byPJ8ralFeaB s7jJUxavpYNkW1TLN0iOpcfyTZJnOWY5RvItP7L8iDxrmbHMkIL/x60z828avwRpYzwP6UNYTsTy KiyvwvKLWH7BaKVpfDeWfZCWxH8by1/CMo/l57D8Oh5VCGmR3lodttZF92L9JmM+TeMd9KmneBXK qcZcmsb7IT2Edb5Lj/09ln//IbbTg9vdWq/0vlVgyx1YXofbsRz/dZqavo3bv4xb3oF2PqI9/P10 /AbsbQVekXbsc1jnTeztF7DNd7D8RSxz2PNX8OpYPJaWX4j7GLc8j+WPsIWHcO863C5gy6/g9nYs P4Lll7FOEZ69Cc/yCJ7lZSy/gmWtfinWd0JajOViLJcYyzAtxRZwC6Yv4vaXcJReinfjWcqwDi2/ GDeIR41hTR+2PITlPVg+i+V+LB+jfZhfg/UrcPsXMN0M6ecxfRHn60Xjq5h+EY9qw/NymH5AGIMn fiukFfF9kIbj4eyGAJafwDQO06n4nZBGaE3mUUx34lElmBKaxr2LNYfivwXp4fi/gfRpuoW5QsvM 73DvLqz/Ftbfg+VVmKZim7/COiuNP4M00/gTSB3GSXoWWmb+J6Y/xe1O4z9BaqU1GTOmzXiUAcsf 0jQuF2u+g9sFWp+ZxxZ+iOUPcW8D7s3A+q/+X9bOPU7nau3/63u8p6EJjWNyCFNNjuOsknKIErY0 oQiDXQ41KApJbTntEiXstuKxtVN7UiSVQ7uDkErFJKlQDY8IFcpp7nnW573uP2I/r99u/36/1369 3q77Wte61lrXWuta3/W972ZTdy88Ed5l9Z0jWR4P77RyHG1VNKT3BkSbLPeEduX4dWRjTkVrrSYD HkhpLIOr8VMHZlF3GJwHa0YXU9pfURL9U8jb4B44N7xVc5S4EPpifBoWoqkD+9i2JrgZxPLhuFjz iFzRkVoVqVWRWhWxeZnSl9FsRzMZzX9pJXhlJVv6ojxYFqKpg1zMerDr0x+I/Xjq5qAxyCb6Fkpz CVyEfhFjWYG8wsn0cAU9XEF/VsQ2ewQfM66arMCa2DelV0XwlGP0uFYXpfPxNh9v8/E2H2/zFSW7 Am0fAtoNXIuZ1MpkdN/j7XvGdcIed5ZREdwIX4KnKbV7LajMPB7Hcgc8BI9HW1gbv2jNSGP30Ub4 EjwNt2iWsd+Dzz1Oo1reufSqoWRzSjZ2RW2EL8HTYmizge+5tSfZy8DbgehdURpzKtEb+2/UH3pS RyPyT9OHLDRZaLLoYRY9zHKl9D8rPGRHeptbydFRrWFamUfdFvR8CKwZj8ZmI3wJnqbdplrbsg8i R+K5B87F21witkk7y2akRazqN1mrjqxA5BWOeJ6PnIl9JvOeKY2dneFEHmp0NobDGS97VrStFxF/ aQpYPy1hJ3Jg5eg5y+/jzpYz0B8RPWh3x3PM8vParWi2Y9mHXZAJm+AnRwxmIC+K5tBzWytoiv/H qNsG+2+Q68M33Homc75GFt3FLkhIH5/U2oiXKG7RhaobDlX04l2S4y6Sg9dZ+R1Yz5+JiVDjjWeH u9VbVtck4jZK/bH7sQsxbwArE/MGsDKRbwArE/8GsDL7sQGszFw0gLI/Rv9n4bkqYx9GblkBM13u ii8jUzWxrKaeeKcke28zs60TlyqDYR8gb6fWZJej6Plk9m+OyzMqDR5gXz+AzSJYE17Fji5yTLwq 2ru6WlRpH1ZOHzLDQmns2ST/HSlt4rIEdb9P3MwKsbvAbwBbhV+QnWRzJZo64S724K+WbdgvP8f2 5PXfld7uiF/J/HZHeHnIy5Tho73sCyP7qAd54DCayuScDey1cxI2H3r/ZL+EzP5JzabNSIdZ54fZ 6YfZuYe1T1NkDyIXhuxN+fGHRz9ZnidaD1uo5fKPMswhxjJBfQ66RP+07OpyHefjcMY1IGGfoPwH 3KiVc6znThq7/NvMU0cnIKO4OpUPt9AfcZ5j/AQ8SvZYyNOCctEpSrelqCxxY/wnckhT9qzYNnER J/UuctQuImlPam9duJO2fiJ//qrIUPoqlhcgZ5M5G0RTrLw/vM7yx3Aoc6cs2pR2myIn4BOMdzP0 o2N2RGlRPue7/DThKaU2sWpHK1vhh9h/gIcPXOak9W7wmObCu4TM2Yd8/h7y4zAvsk+Yfk/85zJr NfBThIbM7+2A47Av0Ki9k+EoxjjOMjvcpnyCzbOM6ID66T2Dh4Uae9RUUYqyxGCu1qTNS9ZbcFhy OAZ5jHoe/IFZrkym+jWVqbSuzpe3oLp6aE9Djboc4/o6/MrKjcL3rfwymmb05Cd4P33YwbhaIfeg bvtwuWW7UCf1bMn23FGsvsIyKyhv5YN4OwVfQN8WD83DyZY/wesju8f9kL5dSIuvYb803KD1hs+T cDL6Y3hohbctyP3Rr4920met/If1tGafysZYzlEmt/p21v/NcWNrPyLUnhoi2udD1WpPfP4evc++ G8cKFN/T07tfK74ZXg6zYTrsBWdZumfd7lg2gd3jusp4kr1PU8yG6bAXlM1g7GfgbQaaLmj6Rcqx adRNU+uW2TAd9oKyb45lXyzXOvIsl4efPHo+HHl4Ss6G6bAXzCXP9LVRuopn7yQ+k3h7zfkMX9AK x08ufnLxk4ufXPzkEo1ceQvayzLoCnvR87342Yu8AXkD/a8VbyUajm6kW+kVjErjcyt1L4fSj4vs jc/PgOXtnV75sC1ZzmYJvyv6v4jeBuQ7onbsbrEAzTYsyzPSquHLlhMk+74YdETOg8NVKygr2tNH dctRay3+f0CTr53o50YtWMOK4UxFLG6jkcbrxPBp1Qp/1RNydEByPImnjubEcCyx9bFvQ93t7N9m 3H266T5rY5VHlPKIUh5RymOm8oiS5PfoT3/sA+RaxHm4aKPH6o26apXq5m5HobPgL+FbVlM1tW7d ykxnNbo1mc3qStd9jTmtjT4Pn0n4Woo66V5LjMZeNlU0a3Y91GV0jm491MUmm9JZaGbR23tsjp0U 2P2Y7BIcEaOaxiv+WO89ij+OHrT2f9UNPdgU9bPxbKkMHw6SHCyDT6BfEo20XCBLD3t7+luG1al7 vRgPxfJtvZ0IN+jdRbAbDzfpfUhYhtJXqPWsmLgAfQU8nIYF2PfjZjpB8x68quwd7ES+FjYWwxq6 z4YXcS5Pxf6fzOwXYrQYm8aSwyqyDKaRVQ4iD6H0UkoriXE7PLgbdAHsSFtXKQcGC/TGI+igczb4 jqeCqdwL1um5PVivG7F9drI23gzF01tEVMejeVhPCNEh/LwJC+Fn8Av8FMHNcExYgr6/nmbF6G3k CfAN7su/cDt+RU994VU8+61Oyb6oJzfLQjR1KLUnS9yc+A/HsjRsGd9n+RYeHoEHHeXBshCNPCzD 8q/UOi1NeBoNT57Rk5yPT/JEug6Ogzt4wvyUJ8l1PMcu4Aad1FOlXUt6Qt5Liz3gq8q0UWV8Vlbd aCzyWCfLj2UhGusn+pNuygmfcQVRBcsb8LOffl6v/R6+iIeMFOUnAz8ZxOdFxvKi4hO1lJy4J/4L vFdrAz/3ORLVc/BfoLEHo3nG+9xRz2+WG+FL8DQ2No/FbZnrh7DsENkbRzQ3rm69XambZrBS+rCi ozxYvgRPwy4aHaXcoIP10gSLqLtPu9L7iufk++Ec+A7PkxO5k07hTvogz0szeDbgnu4d0hOgvxDP lZA/0a05aB0ltXfQN5af8Fv1P+TZOxzkiH4QvR1EbwfR2xnqVThKd+f4I2oZnhirMnbu3cGN8HWe E15hRHO4Qc/iSexD/NdzpJV6tFKPVuph/6GiGk5RW3GTaDzcyJsN1SrviKYr0fiFiB2PdrEXWrGq HbU+6+vubNeb1cT5EWsD+Q5GdB976j7sP4++Z0YcFeFqukeHoTTRgHANPZQ8Ebk8/S+PphyrcR7s GWVab0W6C0dXxzOsZqv00XxK24vBauQjsgnLcndeh02h7KN09k512Iu78Ivcgn8Uo8p6TovGqlbc mlba4PN9zsev8bwMbw/BDN24w5WUPstuyoTnq/Qc3hSl9ebmVaIsHeUpvyXeJod3kOx/yd28OXvq NPtlgdvFaGI8nJLPtN7hM7ZWWU6BE+qhjbxmp1j3aJuvKjMvDaDu189wv/6HZGvZAFZmpzeAlZmv BlB1n42VB3bTB95UhD3iqjrjyFcb4H3kkNq6iYff6PYdLhftOajVtSl+lnWuPb4O+TSjWEDd3eTG V6WJtyhXxEPRvw0Hkh92U/cmeDDRCE7WCShNlNCKSlyAfQX4LD7JqMES3bXDa3XvCPvDTE7km6MF rK6jyNY+7om+P/ev1dz48thr38WVOfusPuIma/eg7kfv8Ux1WJbhg+SBSXraTzzFfjyueYw7M5tP ShO3jRSfqrrV2hWunMa7Pn+BmHhKZ1CwRbsvGK1btqVGsRJ5Jbt7qmRb11Gl9Sitzs5y8n3qQ9hY rdiz1d7Iwiu4l33O+5xC0e6glzhJj3KG6sY0RmOJNuuEjXuQXX/iSWARt5jbubWd0D095N1jsFA3 dH+KMnw8RH2ODpET3iS79icCn0n2i+BmSm+Mz4P5alGryM5FkU5kSifAQ+SZN6jFW9Cgou7sNiMt o+fLlOViu+bDc5mLenAAszY+VL59D5Yw9j3MTjVsuN0Hs+A0+Af0udzgCjXSsBOaWshNw4/xr3sf cfO+JBqlicaF3MQn6RYfjgt/sD0cRK3r9XwV7WO1rAtvIRdpvKupu5q617NaqhL5A3Aq/VnF3F3A /fFRZvwNTpklzHVrNC/pHhFyGw3fxL4D3l4Ro63IK8jtMfIE7tTOQyv4kO744dfs5fP11Bp2Uz+j KJqvjEE/n2K1rOJZ8YFgvdUXKZLxZ1ql9iQSJ4vhd6Hm5Vny/DjJ0feRzvpXOa12YXM7mfAkeXIA peXE4C86JaPp6mF8AxH4mt5u160/LKVbfzCKG/RBetWFUVdnXO3Vq+gDInAz+uUaRfBOaG8N4dP6 xi2cH3xBH6wcf47/bdgPYpYH6T2AXedq8VP0tZD/mrKRz0f0HiA2YrhQbwPC7tLHY+jDLOyr6m2A /yP++8Lu6L/BQzfJ0RPIdVwrvJ2rx67kfIy/JFarIE/CwQtwPHT7sTzPsWuJZxB+aeVsnUrBOqI3 l/ef5WilM2xDxDaRGYrJZseJzzR4LWusPnelVbBZSr4cZsN02ItSe/eJHuUZ/gcs/wxfjZZY/62Q 68EZKWbDdCgP12JZjZvmA9KED6CpgOYQN9zp3DEXwl7wE+7y9Md/jhvf47xbOKrbmd1rtpb/dyyP 0u79euINF+FzkeqGDyPvTfFymA3ToXryk94J2JtvXxvJeozxNX2jHfw3PrNhP/i2br7hJXibluLl MBumU9oL2oiFH8tz/Ja+9bP8u/XwLrVqp6goLcdzR0XDxrkrERMfY+zV9D7BjsJqoq/1tsG2Ivkr 5Nq0XluacCl9u0IMjoT2fh2MCP+pfRE9QmZT6XFKj8EhaO7XzTpYCodKE7XD/l5iWx0eFW1meFmn M/IiuFe1omIx3IbPPOmDKXiuAX8gP0wLV1j2prQpEV4IZ8kmLUsRSCMO0WPcN49wem6TnLiLM3Qp pY8S4QeI3pXwYdbYHDxkyWfacj0RxY9zG10drral96bWtr1HBy+l1mcedyitnCmSrZ88ZjyPCEtu qrcT4RhaeUZ+7HNjfa0E1m0VWJv+LKCtgVFZyxwx6EI8JzCnO+FQ7B/A/iLkMcz+TdLEtbVCosXo G8NK9HOaZP8gHv4c3wp/1txhc79mP25H6Vo0V+CzAM0f6PkYYv629PFb8bn0+VyioV9fNC6xp4AJ St5HflG/H4A5Jc8hXwqn6tcIqdLnIb8lKBmL7FgJzkLv6i5FXoq3Avg1mq+Rt2Nj9f6wEr3zbA0f hqNhRRjA7XCy6JUVTRJNDjRi8ADyIrgC1nRyUu+ri6h7Cs182IdaC5GbwExsvkeuBavC7ug/hRvQ DIZd0KTRn4NofDRr8VwbTR4cjt71eTj9eQ05F1bBvj02e+EJ9J2RjyPHyHXhnqTyYR3aZURehjTe AfxcjX0WrIN+HjauJ85+G5yLZliyudaqi79kvyLcDv/LxRx5oIs5soGL4Iqk9vLHLubSeLPhKUrn 43+FGxdyZeTllAawoRsLsufGgofzUqOQ/hs3ruRH1sNteBiMvoUbHfY5yRpWMyCZyyhy6XkuPcyl J2Im+hPINUXbbi6ec2lLbElbnYjnBfg/AqvQilsnrJlgBryUcTWl1mOwTdI+n3iuz/XhG7AMTIiJ SmI8Www/gi019vhv6NMkB6+n1nBzVuYgfQPrVmZS31sdQ56VrG3lX5LNmM29zONe4i+Oc7NcvEO7 jNG1To7QLkMe7eTiTciliJs4mdLJyRthKSIpfTf0OdQyyCYll9IeRLMoxRFQtW5Ec6M0XhHxP5Xi CFiK2ekAJfdRabAQm+9TlLcGRP4oI7rS7Z2k3oC1Qf9zarXYyPjvulVRfMrKY1hRy6SJTmKzSpqo EvuoUzG/WyDCc5Nl9LSfbKF9WqxndVag97Ri661EM0G0nnV7IgMEXfF/nGjPw3IuK7MWPk8U6xuB +kmdNZ0ZRUw0YicT+SqM+lwYwDrJTrAU61Oac4jDAdUyxC24OrViFcPb4DxsHoR5aMakvCm2FyC7 yM9NUTbrkvZM8TMY6avEx635bPq/n5j8mIptSyuzzi31Fp2V7D0BN0Ofsb+jGNoetoTSkA+DdvjZ Cj/EG/nf+0I25hAruVaylmU39PPQvyeN2Yf+PFiaWXgytfc1Xz3xWcNlSLgD7k+eZqQtoL6v4QTx 3oYF6N2qcHmyO54P0JNn0DfUGgtZP2GR7KOsEhuTwOXPT9Wf4LBiGI5BHsNI/0Cpy3W/ujyg8Vqq t+djUx19OWy+Rm6E/HIqH9rees3Q/ARdDmFcfivYA3J2+C625BPvK8ip5L2Avi1sDvHmX5+0T0o+ +SS4EMulkHPW3wL7w6noZ2Lp+rAazSx4Gr6fOps0O3NcnyWHLyKPp9YIOMSdbqyKmDVWF8bULULe RmlT5GWpNSAZ+u4UroHmUzStYT/aSkO/A65Fz+lgT95PbP/J6l6S0nHoc1O7NRdvuXjIJW/kUirN XmR3apeH7nnjDrx9AN2ZOBKZJwdvFRHriOXXnBFl3YzrdPCrIedjuQvuJvPfDnnmCYdCztaIyMc8 KQVuHoczig0lg9nd7RUfN2tOnxqXToTuZKe18CpsahXv4xzJhSPI6pI7kO33wE/JGF3Qd0leBUsR n1LEX/pscshaorQ2JessaEBpXooj6G0pdpNsXkvFtgOUvh+sQubvircNKapuWziMb0aO8A3IX3lb +9eETvyGyA3jA7ZuI+SLeQZ+jt8OdeabylZRicbF+5w9kv0vkP/Jnd39uiPJbzBq8f3pBm6dPfmO tWd8k3IC+gOSfScfidorp/Hda2XdDkyO38rK0yO9uWoS3qE7fvg3y02S/U9C/Z5kuRj8HOo+WChL s1f0bqdWRzF6UwxjWD/UW8GOeOuOnyW8G2mNn9OyiXtQt7trV/R3wHZhFcvjwThon7qDwcij0fcU g/xgp/SSzRbRq0vpDjHKxGYSLAgetfTx0C70GIv0YyHeojmuRbgTToTLA71NzRb92cg1ot5WLpLs HdUvim0P7Y0gKC2N2RjYm6P5SvTXSG82yj7qQN0KzoP0flqwWnsqWKlsHyxCr1qHVBqlY7MEHkKf JVq9PDQRo4X06jhsBSfKj98z1Wdr74ViuF0MusMCehj4nqi3OsZH9n1fGu9NSrlned/yq+kftIb9 6cpX/hSNy9d3ys9I9o74+p3eNl/vlh/xJ1hO9m1+9srK3psDn4KBGDyAh0X+NMsVvlZ4zUC/PmoT TFMWlcY7hc18WuxDrYXITWCmn2Ztvsemlq/VXtU/XzPr69vGjpK9DbBA/x+Ofhc/HVZQBoAj4UyY IQa18ZAn2R/uV9Oe8u1a9e+S7Jfzv9beR78Wy1wsq1C3vacnMR9ve71/6NnJy7KaOt5+Kxd6dnf7 ZT398jCQ7NX1G9JDOxZzMszUialSL4LT/WbS+K9bz9dTtw7MSsk7LBOiOYa3ebAh/ut43xFDGx// lDde84JmD57nYpMQzSHVMr+qJ/4XxvDfODQS4z6ifj9vNS8jv498DPkO5CftivoiXmw5Hl4hRqXE 4L9hAZrKsLToXwT/jn0/bAaIcRKb9vAOSq9Bvh/5QSw3wl/Qt0S/Wky0Qb4dXoLNVuRrYQs0HyDP Qn4M9kQzn/6Uga7dCPk0veqIZgPcQa1i5J2wDpq74Dg0jDdsSt3pyCGlH8EjaK5H7oWcoK2povcr sove53h4CJsb0G9H3wh5PfL7xIFoBC/CTbA+tb5IDNP3Dm5eJEel4IVudpArw9KwrZsdyeH7bo4k BwPgCDgabxPcTFGrppsv5JFuprDcCH9B31JMtMHzJei30rfG2DOW8FEXGWz6IwcuJtL4o+hPVXru Sk/C3kTpTeR8bMrCfdTahr2bx2qwIr1lriOiFLk14Hr+BHS9+pKeuzX8E5aj6Nsq/A+Gbr0NZAXS t3gIlrQVfAzfweZWOAjNAeQMMW2nfKaxkuNLqTscb9gkuqFvQk8udfuF6B2g1nvYZKLfS91ayHgL fkDugPwwcjqyW1Hj8VPALCQZ1zVwNbwdPo7lbdRaicwKie9k7G4/FtHuFORW6A9iSTQS9yH71MpF vtutbVp/3sUZVqfuYmTmyyd68dNwARqXK2a5/YKHRszyeliWPnfGJg+yp6LayMxL2BU2x8NNyH3h ddgUwt2UDoVOfzEkh/js5fAfsBP+34bPwXnYkA/9hdTazxo+hIa58BlLuAyyZ8OrsVwBP4NL8VYP +Rg2PWAfNOTYGPuYXJS4BXvyahgj00pMXg2PQvZIcBiZEUVj0JA/QywDIuyzAoNvkdll0avYLIEu p01D7zLtG5B5DFxUJ0OyYvQd8lx4Dr26HEtWUcC+COhhwOkQ3kMttxJ2oScOCTJA1B39GvTsweBK yN6PX6LPwyArJ2QUITMbElXfjcLNL6dDTKYN3XxRNyQzBK6t1+EW6FaRyzAuE7rz6M/0jTMldOca qyI4F7k8ZKfELjNfy+p9jHVbhnW7gz2On5BdGRHn4CNKyfDhZdDlAeY3Yj0Hc+jPvfifCVkJwVjo TudvkE9APKeRXdPoc/QKtdhxCZfTXkDP7MSUhu9Sl9wY3KVeGVPSClaCL+rESerbvfHwCjEqJQb/ DQvQVIalRf8i+Hfs+2EzQIyT2LSHd1B6DfL9yA9iuRH+gr4l+tViog3y7fASbLYiXwtboPkAeRby Y7Anmvn0pwx07UbIp+lVRzQb4A5qFSPvhHXQ3AXHoWG8YVPqTkcOKf0IHkFzPXIv5ARtTRW9X5Fd 9D7Hw0PY3IB+O/pGyOuR3ycORCN4EW6C9anbhNILYVv8YB+MgKPRTKC0JhxJrcbo8R8+CvvDgHZH wap4cPqTsDd130TOx6Ys3Ae3Ye/iWQ1WpEViHtHbyM0FfQifgK4nX1Lq1tJPyPQhXIXnwdDN+0BW An2Lh2BJW8HH8B1sboWD0BxAzhDTmM00VlR8KXWH4w2bRDc06NPeQ5NJ3b3oayFTN/gBuQPyw8jp yG4eH4e3oVmJzLzEdzIKt8KL8DkFuRX6g1gyrsR9yD61cpHvxvJ55OrYL0Ym2j5jj5+GC9C4Hccu CDsj50FWYFQbmeiFXWFzat2E3Bdeh00h3E3pUOj0F0N2nM/KD/8BO+H/bfgcnIcN2cNfSK39oncI DTH06XO4DLLCw6uxXAE/g0vxVg/5GDY9YB80ZKQY+5idm7gFe7JQGCPTSkwWCo9CVnJwGJkRRWPQ kG1CLAMi6bNOgm+R2QvRq9gsgS4DTEPv8tIbkFUduKhOhuSQ6DvkufAcenU5lqyQgNUb0MOAXBre Qy0347vQE4cEeyTqjn4NenZKcCVkh8Yv0edhkBUSMoqQmQ2Jqu9G4eaXXBqTl0I3X9QN2b+Ba+t1 uAW6VeTygMs2Lnv/mb6RgUN3CrAqgnORy0N2Qewyg7N3kSTXhZdB9mPI3EWs1WAObd1L3ZmQWQ7G QndOfYN8AuIzjcyWRn+iV6jFrkm4rPICeiIfUxq+S12yk/k4CIzeiem3K7WjdN7G6L/v7sgbocGB vvVexHukTpQ+E0VGb5AyLefxJs2Xxv8e/Qzpw1iW9hCK9OYE/a1itEUM66M/iod8SveJ8UjkwbAj Pg85S1qfrv8WPiitN2b+M2geTr3v0tu/Y7w9u443aSfdGzM0i1XL/wSNj/0huIQxlhb9iYy0B+/E 1vO2qglyk+A11ZKNKZHeOz/1lszSfMM7sRz8dKdWO95ctZLGOz+cb/SurEC7htJnYE8xmV+i/zK3 W4l+KbSmRG8me+oNhv+JZK8ucm9K2yGvRd6O5XjJXhIPWZS+S61tyOWcNzTfJhehUd2GcAD6pCy9 k2j+gn1t6j5LaTPkbEpj5D8iT8GyFa1/geV+Su+VnOyu/oSd3SiMfu96XHJwHm1dhJxveLOKJkSz CfsdYhwarQ16EmRjUwnZhzuxTEMujdxFtGtI8hJaXI48G3kJlhXgIt4O7UUejM1o6vZWi8HKVJ9V OpZ2P6Sf25GPplrUamyIfCv2A5Kr9eZNerMlqbe4HfE5h9KJ1D1H8bcZj/eiaGYyI8Pw3zn5HH2Q fX/J/nr1PKgr2a7p5joNqdVeGlv3aVv6dHKljRUrxHs9qbejS1Vqc9dzjFcjysbDtyadd/gryYH6 7zQvcq3oVxC2t+r5C+grEfnyjPET+YzuxX9G8klrswKbmUmt/AvwmUHpO7CReuU95aKn0XmTYY7s /azkW7S7SbMj2V+DnAXTYEPRtrUG+S3aWqB1SIuTTKb2jtr115jz9GaSiB2ixe7oi+B6ZnkhtQro 227YhtXFWooGoknKPthZom8Tqpb8YHkEn8NcK26+2F/HU7tMkZmOnBD1t79sdmUVhVPhNVoDcTOV Rp+rD1G3kpPMxTJYwE5U3QtcTyTbyChWx0q+5+loNjuUdolVVc2dN5m+tUMzWnPnTyduS5BbJVsr PsnB2AymdBKjmCT/xYfR7ON7N3koDdtJ41+qb3bCFkT4EJr1ybFavRqLt5+52I19GqyT1F8hiPg+ aL76FmQm/0Zb+eyIQn1HQG8NPbwwqW+FBpfolwBpjPFlRn2O1pV3HWt1sCIQvuzmS617r7vVJcuY NWZH9xYnu2JYmzzzrcsb2oN2dIrhUZXGS9WKV4jPzvSqJ/EsR92G7IVy0ttbG984iFG6ehh0ZW/2 1HyZk4qAjUkBs3ADlhpRl+Tn8BtazGYly8+45GPUVcxHKiaWL1J3J3X3scK1zqsoJl6lJN/jUHpL 8hiyvosJifk72CzFfrEjMXmK3y/NpfRJPLRkRNNoq2XqNx5v8WQlP8vd753wn0ef04j5zczIEtGb SXw+NN1tTMqQHxqimSiajYqGjdgM8tiT2mvknDbyY+foFH2LOH3ED7E/pEhGC2EOc1eF7NRP9jba Wgkxrewg5rPJb6HWv81pZDPmtyfZZrI0ht+Sma/gCmK1lF2ZxTqcgf0aV4tWBtKf/Yy3dSoDX0Fs 1cpa1sxMNwr8pElvT6iIX6poF3dQu/Hj+gtOdoXrv7N7z7TWHZBWitjd+ay02vgvULt2hZ9ifZ5H 1srkrMnkVOJkYf1nsE5CslBf7H8hm82gJztMDnnvEfoseZ49kew6JxqVWKu+/Ae3Ev/XXXZKZcUO nMLNyWAtOK/lfz6WR4nGUDxMSo3CyrHL5zPdXkudbvpvDCf6HyDrRNhIrJox0sLkx2TpTey+1cRB /2VrDzH6kd+krcTDbFb4MDStieFUebN7eRlx01zvgzNYV+PRl2HfTWRVjJVsfuVE24xmPPaFqR1d wJnlcn6OsgrrobRibr5iXH3d7HNeL3al5NVt7I5KZNGJcBiaJOdjBZ4iWnGmvImGnB+9wArJIZJj +TZ/NGu4KicCT2sJnmfsCc5zBW1VUqyCwtRqLyR7rCQHGkbhMnkheUDsi81byaeMvqPPp1fKMzfi oQs2S1jDt6PJwv7DFPOZl3xWeyEjzWd0KzmFF9Fnq0meKPmWldCd8d5pLZ93Jya1RqaeytyTm9bh e9SdaKpZ+S3GuIr+7xKTjeSt5Bf9LSzLAdZmBO/39vFGjregaXz3ZNJlYzmAb+ukMXi4JdJvU3vH x/R30pDTkRshN0JuEu9AsxBNIfIU/a41LkAuRC6m9FzJiab6C2lomtjZk4fPsAn522ifi/Fx9SEh P5lxezExR38hTf81X3JBYon+Qprk4rWSkw/FT+kvpCUO65vlREV4nL+Etkf+nay/bmHlE+j562eJ 55GvQb5dfyct2qC/k+bGGBfJPq2c5EQ6lqfpbWP89MemCqUdGVcLeIJRz6B0DfJx9FloNkP9t9I5 aTXxeQWtD+E78UJkH5s/4XkZUSqkRZ/WpyG/Rt1W+jWyo/pvY7hb+rQM5FZ4cPoc+tAPuSXyH/Hw Dfbn0R9If3Jcf+LZ9Ocd/WUzRt08NerGeO6PzS3YT0NuARPUugqZv0GXGIrMeBNdGYVaaWLoCX91 rXEcUdoTOaSVg8RkCprGlNrZSTaAjRMBfASbPXArliXoG9HnVfSZuePXg0HxIeTmMFetFK9XH4o/ Rt4lJgfA3mj2ybJ4hSKc0t8DS8Hy+CmPPA42p9Yqan2HvAE98SleQFtvoP9ActLHAzOe6sPP2Oyk Vk33LbpJ96am7TdB3n0jh5nMP44cNNRMGNb/7jvNcp1AN3a/poaxebGkxJQ3pU1sqppappypb5ra +LYx15mbTR/r4w9mnHnQ5Jk7zF3mHjMlZX+uSZgLTW1zvmlgmlkvV5vrTU/T17ba3Yw3D5mBZojJ N6PNVP7/a12dDJNmM04dm9Eb2nPtcnON6Wx6mduMb24095s/mUFmqBlhxphppoIJOnXr1tFc173r DTXMgB7dr69h5uGlIn+PurrN6VnWYyP7JNDWXGtuML1NPxPYE76HmWAmmcFmmBlp7jXTqXOOqWEu tj5zzJWmneliLjN/Rl/JlLFxqGmqmEus38amhX0qaG86mq7mFtPf9ruuuck8YB42fzTDzShznz3H XQ/KmlLmInOBudR6aGKusid1J9PN3GoG2LOknsk1E81kc7vNwnebsfo72Xk5o/KCXNgXDoZ3wtFw Ql7/YXcHk+FM+BRcDJfC1/P6jxoUvAM3ws2wEO6Au/PyhucHe+FRMfRhGVgN1oWtBg67449hB9gZ dh94513Dw56wLxwIh8B8OBqOHzyyf174EHwEzoEL4QtwBXzTOu4fboSbYSHcMezOe4aHu+Fe+AP8 GR6HSTEKh92VNyxKh2VgJVjNFo6MasNs2BA2g1fAa2DHu+SnC+wBe8N+cDAcBkfeNXLgndG9cAKc lC/9dDgTzoHz4SK4BC4dZecoWgFXwXfgRrgZbht1x52Do6/gt3AfPASPwpOjhuflxwamw0xYDV4C c0aNatgovgK2g51hD3grHGiZEw+Dd8PxcBJ8BM62bBzPh4thAVwB18B1lk3iD+EWuB3uhEVw/6h7 BoyKf4S/wNNiwodpMGPUPfmjEpmwCqwBs2BdmHO3jWSiBWwN28HrYDeYC/Xmxre5J/M/+Dew+/wC U/X/SvL4I9v/Z0ZG771imxfT/r99CvnkZM9U/xee+zsZ2DxXir/n//8ieTZ7/+8s97vpMyO+9apP XuqcEtN/N8v+bl74Lyzzu1mDngb86/2GGsFvdRn/loE9qSqYSv+hVBHJt+fTRf/Rv7X488+//986 Jus/+NezJ+m/57+PiWdP8H/P834XG9mnjbvtqT/bLDYrzDpTaIrMUS/0Mr3aXhOvndfDG+jd7U3y ZnuLvRXeOq/QK/KO+qFfze/sj/Wn+0/5L/ir/E3+Dn+/fzJID6oE2UGr4LqgdzAkGBtMD54KXrB7 UG2luTUbdDnr84CzPj9y1ucZv/kcnlUe222+3SS833xOb3Lm59KLzqyf8cuZ/jN7n/m5vDnTf/nM sz5nnWXf8azPt571+azxlN9x5ucKl5z1udtZn+89s/9VF55ZfuGaMz/XqXvW5/q/+Wz3X52GZ5U/ xGff5odyboQXd3P/XuJGHto1V8HmqqyU9pPUvztS/xal/v3xf7POXp76d03q3/Wpf7ec2YvLMs4c 5WWrzvzc4KEz7Rt8debnRh+e+Tln5VmfXz/zc+MeZ33OPetz/lmfR571ec5vVpkVms076/OqM+2b nTVL/1K++azPn5z1ecuZs9hys2WGjUye96QZ7M0n2w6w/zN2p87WLzKispwV5UxculPG+tIdM9Zl vJXxjtXE3kHvoLX70fvReN7P3s/G9455x0yQcXXG1SbMaJvR1p6bWg9+0D7oqPb8cn55q7FtBxnq z/+w9xVgVhxL29XdM6fPmZlTuywLLMtCcJddgkMguAYnSALBFgsWWCBw8UCQhEBwd4eQ4ETwYAGC u7u7+1dTDARuyH/zX/v+539CP3T1mZkz2/V2ddVbPXNmVJC+mZU+J6RspA2MhfVwHB6KcOqDn3oV 7lQC6ZRyKlNd2qlCdRnqfSj55OSULURTzlMAz4OSodSnCyzXI2VaMgF9vsRyPe4FSZ/2U70eD1K9 EQy20EhIicepr6to7wmW6/EkyTX0+RTL9a8cedo78ox35FnvyHPekS/6W5b7W477+x7398We8ryn Au+p+Ooe/IV7uIV7+Cv38MWe7bxnJ+/ZzXskaEmFppkt3V+ZhMpQQjUBoaqcEk5JQn0VrgIf9WkN IUVZtnSvST+P+jS16Pv1eLyAR0qIh+Ihjdoz8YzQMiXxHj6vyef18Xm1jJSR4JcpZUoIyPQyPViq tCoNtlnfrA+O2dBsCEGzkdkI0GxiNoEQs43ZBkLNODMO4pntzfYQhskxOcTHlJiSdEqNqSEBpsW0 kBDTI+V8mBEzQgRmxsyQGLNiVojEaIzmdz68DVGYE3NCUsyNuSEZ5sW88Bbmx/yQHN/BdyAFFsJC NDquvaVie0uNJbEkpMHaWBvSYgNsAOkwFmMhPTbGxpABm2NzyIgtsSU5itbYGjJjHMZBFmyP7SEr foqfQjbsil0hGrtjd4jBXtgLsmMf7ANvYz/sBznwS/wScuJX+BXkwq/xa8iNQ3AI5MFhOAzy4ggc AflwFI6C/DgGx5B9jsNx8A5OwAlQECfhJCiEU3AKvIvTcBoUxhk4A4rgLJwFRXEOzoFi+A1+A8Xx O/wOSuACXAAlcREuglK4BJdAaVyGy6AM/oA/QFlcjsuhHI/3ezze5clWfoYKZCvroSJuJGuphL+Q dVXGLWRdVfBXsq6quJ2sqhruJKt6H3eTVVXHvTRHauB+miM18SDNkVp4FI/CB/y+hQ/xGl6D2ngD b0AdvIW34CO8g3coz5fQk+ZHT7KkEBEC3USkSArd+a3bvUQt8SH0Fs1FC+jLb9ruLz4RcfCF6C/6 w0AxUoyCQeKGuAGDxV1xF4aIR+IRDHWdDAyTPumD4dKRDoyQ8WQ8GCkTyoQwSiaRSWC0TCVTwRiZ QWaAsTJaVoRxMk62gxWyg+wAq4hHdILVsovsCmtkL9kLfpZ9ZB9YJ4fKobBejpAjYIOcKvfBRhUk //NY5VA54KkqoorBM9emhVTj1DihjDhjkjDMBmYDkd2MNWPF22Zjs7HIYTY1m4qcZluzrchltjPb idxmB7ODyGPu8vUVea0qVj1xzepjC/HUCXWKy47OB854+W2wYbCZvBXsFvxSPkSJfuXHFJhChWAq TKVCMQ2mUfEwHaZTYZgBM6j4mAkzqXDMgllUAsyG2VRCjMEYlQhzYA4Vgbkwl0qMeTCPisR8mE8l wQJYQEVhQSyokuK7+K5KhkWwiHoLi2ExlRxLYSmVAutgHZUSG2JDlQobYSOVGptgE5UGW2ALlRZb YSuVDj/BT1R6bIftVAbsgB1URuyIHVUm7IbdVGbsgT1UFuyNvVVW7It9VTbsj/1VNA7AASoGB+JA lR0H42D1Ng7FoSoHDsfhKieOxJEqF47G0So3jsWxKg+Ox/EqL07EiSofTsbJKj9OxamqAE7H6eod nIkzVUGcjbNVIZyLc9W7OA/nqcI4H+erIrgQF6qiuBgXq2K4FJeq4vg9fq9K4I/4oyqJK3CFKoWr cbUqjWtxrSqD63CdKosbcIMqh5twk3oPN+NmVR634lZVAbfhNlURd+AOVQl34S5VGffgHlUF9+E+ VRUP4AFVDQ/hIfU+HsNjqjpewSuqBl7H66om3sSbqhbextvqA7yL99SHXi7lMp8c7GszkDmborao TZtjRSwIY6mxFKTvie8JKH9Bf0GaPX9547+88b/HG/9mfZFsfRldtiWa+g79ZWN/2di/ycaE2Yz4 fKhIKXOoEkYNiIJ8UATKQGWoRflCM+LvnYgP9IfBMBomw2xYAD/AGvgFdsJBOAkX4SYxexA+4QQ+ BRVoG4gLdGTZLtCJZfvA31h2CHQhGUetrizjAt1Ytgt0Z9k+0INlh8BnJNvRcb1YxgV6s2wX+Jxl +0Aflh0C/Ui2p+P6s4wLfMGyXeBLlu0DA1h2CAwk2YGOG8QyLvA1y3aBwSzbB4aw7BDoDJL29qS6 XaAv1e0DX1Hd4V9AZBhr3jYw3ENmhIfMSA+ZUR4yoz1kxniIjPUQGechMsFDZKKHyCQPkckeIlM8 RKZ5iEz3EJnhITLTQ2SWh8gcD5G5HiLfeIjM8xD51kNkKOnfNjCeEZnKiMz+FxGZ7yGywENkoYfI Ig+RxR4iSz1Elnm28r2HzA8eMj96yPzkIbPcQ2aFh8hKD5HVHiJrPETWeoj87CGyzkNkg4fIRg+R TR4iv3iIbPYQ+Y4RWcKWsooRWf8vIrLVQ+RXD5FtHiLbPUR2eIjs8hDZ7SGyx0Nkr4fIPg+RAx4i Bz1EDnm2cthD5oiHzFEPmWMeMsc9ZE54iJzyEDntIXLGQ+Ssh8g5D5EtjMhORmQ/W8rJfxGRCx4i Fz1ELnmIXPYQueIhcs1D5LqHyA0PkZseIrc8RO54iNz1ELnnIXLfQ+SBh8gjD5HHHiJPPESeerby 7DkyFjxHxhLPkbHkc2Qs5SFznhG5yojcZkQeupbivgPY7TevptWADGKnnKDKqQqqkWqsmqmPVVvV TnVQHVUX1Vf1U/3VF+pLNYByl5PqlDqtzqiz6pw6ry6oi+qSuqyuqKvqmrqubqib6pa6re4Ec7nv 6BPbxXb6A+Pd3+arsqosSFVelQelGqpYMFQT1RR8qo1qA34Vp+IgoNqr9sQEPlWfgq06q87gqK7q MwiqMWoMxFc/qK0QHswZzMmrDJFgGcmMt4zkRgojpZHKSG2kMdIa6VzNqEd3eHVdQMQraxOZeD2o uXsEfTOdd0TUK0dkfmUfIama09FghBvuE33TG+nB9v5uuJHASGgkMiKMxEakkcSIoiN++7sSUkOI EWbEN0zDZ2jDbwQMy7ANxwgaaIQYoYa73mWQbt2oC+53pPGOURAco7BRGJD25YIINV3NVHPVt+pn tU6tVxvURrVJ/aI2qy1q65sQd1fL1DQ1jc44Q7n3W81RcwjveYr8KCG3lv7eSXXp5dmn0VFzaO8P 6kf1k1quVqiVapVardaotW8aYz77dDWdzj5TuU8Lmavm0tm/VeSdqYdb6eyuHu7Zs0L4G8/6Bj0Y s5MeZu73/qR18fdca6DvmS3lIvgMekFv+Bz6QF/oR/P6C/iS31w9EAbB1zTLh8BQGAbDYQSMhFE0 58fAWBgH42ECTIRJ5AGmwFSYBtNhBsyEWeQP5sBc+AbmwbfwHcwn77AQFsFiWAJLYRl8T77iR/gJ lsMKWAmrYDV5jrXwM6yD9bABNsIm8iObYQtshV9hG2yHHeRVdsFu2AN7YR/shwPkYw7BYTgCR+EY HIcT5HFOwWk4A2fhHJyHC+R/LsFluAJX4RpchxvkjW7BbbgDd+Ee3IcH8BAewWN4Ak/hGRm0kJVk ZVlFVpXV5Puyuqwha8pa8gP5oawt68iPZF1ZT9aXDWRDGSsbycayiWwqm8mPZXPZQraUrWRr+Ymc KPfLA/KgPCQPyyPyqDwmj8sT8qQ8JU/LM/KsPCfPywvyorwkLytLXpFXlS2vyevyhrwpb8nb8o68 K+/J+/KBfCgfycfyiXwqn5ELcn+LoZShTOVTWvlVQFVSlVUVVVV9qGqruqqeaqE+Ub1Ub/W56qOG qFFqrPpOzVcL1SK1TH2vflXb1Ha1Q+1Uu9RutUftVfvUfnVAHVSH1GF1RB1Vx9RxdcLIbxRw3wlu 7Db2GHuNfcZ+44Bx0DhkHDaOGEeNY8Zx44Rx0jhlnDbOGGeNc8Z544Jx0bhkXDauGFeNa8Z144Zx 07hl3DbuGHeNe8Z944Hx0HhkPDaeGE+NZ2bQDNOFdRFdVBfTxXUJXVKX0qV1GV1Wl9Pv6fK6gq6o K+nKuoquqqvp93V1XUPX1LX0B/pDXVvX0R/purqerq8bUIml0phKU91Mf6yb6xa6pW6lW+tPdBvd Vsfpdrq97qA/1R11JyqddRfdVXfT3XUP3VN/pnvp3vpz3Uf31f10f/2F/lIP0F/pgXqQ/loP1kP0 UD1MD9cj9Eg9So/WY/RYPU6P1xP0RD1JT9ZT9FQ9R8/V3+h5+lv9nZ6vF+iFepFerJe47xXX3+sf 9I/6J71cr9Ar9Sq9Wq/Ra/XPep1erzfojXqT/kVv1lv0Vv2r3qa36x16p96ld+s9eq/ep/frA/qg PqQP6yP6qD6mj+sT+qQ+pU/rM/qsPqfP6wv6or6kL+sr+qq+pq/rG/qmvq8f6If6kX6sn+in+pkf /EJP09P1DD1Tz9Kz9S19W9/Rd/U961Oro9XJ+pvV2epidbW6Wd2tHlZP6zOrl9Xb+tz+m93Z7mJ3 tbvZ3e0edk/7M7uX/bndx+5r97P721/YX9oD7K/sgfYge7Q9xh5rj7PH2xPsifYke7I9xZ5qT7On 2zPsmfYse7Y9x/7Gnmd/a39nz7cX2AvtRfZie6W9yl5tr7HX2j/b6+z19i/2Znur/au9zd5u77B3 2rvs3fYee6+93z5hn7LP2OfsC/Yl+5p9w75l37bv2Hfte/Z9+4H90H5kP7af2s8ccIQjHeUYjun4 nFPOaeeMc9Y555x3LjgXnUvOZeeKc9W55lx3bjg3nVvObeeOc9e559x3HjgPnUfOY+eJ89R5FoSg CMqgChpBM+gL6qA/GAhaQTvoBINBDIYEQ4PxgmHB+MHwYIJgwmCiYEQwcTAymCQYFUwaTBZ8K5g8 mCKYMpgqmDqYJpg2OCY4NjguOD44ITgxOCk4OTglODU4LTg9OCM4k68+84osr4x2kxMkeVBe75yk ylB836Peo/i+T9VSH8ABVUd9BIc4hh5RrVVrOEoRrwccU4PVYDilRqqRcJoj+xmOW2c5bp3juHWe 49YFtUQthYscIS4beY18AnjdVJqWaYloM9QMFTG8Mprdd8J3VpzX0TqHuMqrpLesPtYYKa1p1kqZ yNpk3ZfZea20Pq+STqdofxMCxA5SUswvTwxoNEWAFeSd6U/YvUHiJm7N5ZZ7jSYUEkKUvYE+77M3 Un3A3kT1IXvLy2P3UWs1+IlLREAyYgAZn189sg+42+1DVG+2j1C91T5G9Tb7ivtNTOCeERO6Z8RE 7hn5XE/4rC+u0QTo0zq0qN6A9mt7QnhPKO+J99qeCN6TmPdE8h4JARq1aBq7PNK9zzy/zA9SlpAl QMnSsjQYsoKsAKY1xBoCPmuptRS0dd26TueT5ky54z8UY1+PsP9/x9f/ToR1Y+ifjZv/yZgZphvq RrqJ/htFIDdyFqeYWY6jWSWKTF9xnKxBMdKNjs9jY+yfjIqd/0E8/H00HEVx8LcI+Gp0+X8tGr6M dhQXR1L8fjUqFib24XKP58zD5R0ViXk88HjHI2IdNYlxjGfOMYEYx0Oy2vfJUj9y7fJF7JQtXo+b TqgTzwlz4jvhTgInoZPIiXASO5FOEifKSeokc95ykjspnJROKie1k8ZJ66Rz0jsZnIxvjLa93xxv MYAW2n8q6s79fdzFEAzFeL+LvhvsjfYmjsFb3hiF91EcPmAfso/Yx17EY0yIiTgmX/nDqPzk93EZ IzAxRv5T0fm12Ow8+S9E5/JCigSUykaK9BAuKoqqkIqvlKYXdUQsZBKNRWN4WzQVTSGH+Fi0gJyi legEeURnMQyKidFiHNQRi8U2qC/byDjoItvLLtBddpM9oK/8TPaBL2Q/OQAGyYFyMAzja56j5HBJ 3p5z/PHKUWEwQYWrcJiuEqqMMENlVtngJxWjisEqjvi7OeLv4extrzHZ2AYXzXhmPBFh3jXvisTm ffO+iDQfmg9FEh/BJaJ8/XwDRFLfQN8QkdI3zDdSpPON9o0TmXwTfLNFNt9c3yKR37fEt14U8230 bRfVfHt9e0Ud3wHfIfGR74jvmKhP3OCJiPU9I27QU+fS+cUy/Y4uJFb4M/gzitX+zP5sYq0/xh8j Nvhz+XOJjf68/rxik3v9TPzif9f/rtjsL+IvIrb4S/hLiK3+0v7S4ld/OX85sc1f1V9VbPdX91cX O/y1/LXETv9H/gZil7+pv6nYH6C0Xxyw6lsNxEEr1moiDlvNrDhx3GpvtReXKM6OEZcpzq4UdyjO 3hdPbWl/ILVd2+4k6zkTnJOyW3BAcLRc+/z+FspG5/EVl9qikbdlyStbBOQDn8c90hKnyUH7p1Fx 63nECqaxdD8t9z4tp09HqLh32WQSmchqsgr3LYh5RB46Z0lRkoJLWVEWDDFSjOS7bDZCPTPSTGJG mUnNZOZbZnIzhZnSTGWmNtOYac10Znozg5nRzGRmNrOYWc1sZrQZY2Y33xa7xG6xR+wV+8R+cUAc FIfEYXFEHBXHxHFxQpwUp8RpcUacFefEeXFBXBSXxGVDGYa6q+6p++qBeqgeqcfqiXqqnv0r2wxS xZC80mDwrxXi8dWsCCoKoqgYhFw60jQzuPelZaPiJ1TzEU8sQMWCglRsKAbFwYGyVBCqUwmBmlCL +GEdKmHQkEp8aEIlHNpCHCSAjtAJEkE3KolpdkqIFCEiFJLQHI2EpCKZSAbJ+J6Gt2i+VoTkNF9r QQq+qpuSZ2oq0Vw0h9R8l0Ma0U60h7Sii+hCc7qf6AcZxBfiS8goBolBkJlm8GjIQjN4MWQVq8Rq yCbWiw0QI7aILfA2rzfl4JmXizl1GV51qsOrTnV5LSzylbWwLHw3VX75ISGWVMbIGGKOudznRMpi shjtKSPLEHOsLCsTc6wuq4NJ/CcWfMR8Pibm2NfqD37rS2sQ2NZ0awaEWrOsuRBm7bX2QULrgHUY Iqxj1ini1J3trpCCokgvSO1GCMhAEWISZHL9OWQjf74XYsiLH4Gc5MmPQS7y5acgN/nzM5CHcqxz kJd8+gXIR379EuQn336FxurvdcnKupSWzUiXZK/pklfmpT2uRkpWpJzGYI1M1shHPK8WaNbLTyzu EwiwXhbrFWS9wlivcGue9R1ptMBaAklYx+SsY0rrnHUB0lqXrGukl6tpVtY0hjXNxZrmoTg4jfKE GZRtFGKti7PWJSk+3YWyFJ2eUIby/OprOZqfDVmjbK6O5LvdeQ8vt7it9DR7B4nhL7dJMVt8R5/C Xx5HM+ANGBSQhBsjYfDYmoyHj/HQjIef8QgQ760NFqNi82g7jE3QqmnVBKTMvCuEUPY1mMZ8qDUG oigHWwKprWXWSshFmdg1KGjdsO5DLHGIPtCC2MIg6ETsYC70pNi/GIZRrD8A43jMl/GYf08R/AT8 wCP/I4/8Tzzyy3nkV/DIr+SRX0WR/Rqspuh+A9ZQhH8Cayme++BX4jgRsJd4TQo4SlwmI5wlVmLD VWIX8eAGxfhIygDIE1KG9AmAm0FCEXeVASq5d9tAFftvTnH4lb6TVIz608fxs27/Q0e/tAfg32RS runafMVX7CH6N3uAqu7voL1tEkrwtfvwl8dJUNZYayr9zVXWRrLxB7Y7c2grZ/nPe5KC+xDt9fJF X/ORN/snvDt9MwH7QmBfKNgXKvaFBvtCk32hj32hZl/oZ18YYF9osS+02Rc67AuRfWEI+8JQ9oVh 7Avjsy8MZ1+YgH1hIvaF7lM71pAGjiylfoB3/+G1ICksEUa9TCkyiuwinygiyojK1Lv6oploLdoT f+op+oqvxFD6qxPFdDFXLBDLxArxs/hFbCdsDhMO58VVcVs8pADkk44MkxEymUwtMxLGuURG0j49 YZGFZS2KwK6sLfKyrCPysfxI5GdZVxRgWU+8w7K+KMiygSjEsqF4l2WsKMyykSjGsqkowbI5RXVX thIVWI42E7nSWGJGsFxqJnYlPvLbrjTj+x1X+qb6gyyX+5HlCn8Iyyf+UJZP/fFYPvOHuZIYVHyW hUIE/51mIgN5oxDiGpI+Zaa6FjEOl7+QTyItyRJJxxiq64rsVNcTb1NdXxCXId1yUt1Q5KI6VuSm upEo4t5/IopS/bEoTnVz4iyStCpFdWtRmupPRBmq24hyVI8W71E9VpSneowZDpL0TUD1UtNdfXnk p4EhTcmqSU+D6uV+4jyko8+9o8qvqX7q91P9zB8ASboRA/MXggw0tz6kmN+cYn1ncJ8BMBTGwlSY C4vgJ/gZtsBuOAyn4TL5F++aIllSBNl6arKlaJFLFCBrKiXKi6qERl3SqrmYTWiNJoTmsKwt5rKs I75h+ZGYx7Ku+JZlffLurmwg5rOsJxawbCgWsowVi1g28id1JemYzJWk5Vssl/uTs1zhT8HyiT8l y6f+VCyf+VO7kjROw7KQGM/jN4FHbiKP3CQeuck8clN4zKbymE3jUZzOIzeDR24mj9wsdzz84Yx4 AkY8ISOeiBGPYMQTM+KRjHgSRjyKERdghADfWa7YVwDPdBHi/kzEfZZ4eb6vPz1kZx7Aq2EiIdta IraRCPdvu2cRiV+2mriW5Ppe8ifD2Va4dq/SiVDyUCASUF4l2BNJ9i9uXI2AfqKaqC5qihrifdHE qkERsNbztWnZTnaVfeUwNVrNUgvwMT7Bp/iMvOw4a7w1wZpoTbImW1OsqeRxV1trrLXWz9Y6a721 wdqI91CiQgNN9KFGv/XAemg9sh5bT6yn1jOb3J79tT3YHmIPtYfZw+0R9kh7lL3EXmovs7+3f7B/ tH+yl9sr7IP2Yfuofdw+aZ+2z9rn7Yv2Zfuqfd2+6WjH7wQcy7Edxwk66IQ4mZzMThYnq5PNiXZi nOzO204OJ6eTy8nt5HHyOvmc/E4B5x2noFPIedcp7BRxijrFnOLoYBARwzA+huN9fIAPMQlGoXsd NC1nnsDZpkmsqyzFtGayOTGHOMoqHdmFssog3zeLnEOGcGYYyuu/8dR8NR/CfN/6voP4vqW+pZDA d893jzgj5UuQyM2XiFsdtc5ABjdrIibVl/hDPvsbYg5FKeM/AOUo6z8E7zF/KM/8oQLzh4rMHyox f6jM/KEK84eqzB+qMX94n/lDdeYPNeynxBxqOqHEFuozW+jCbKE7JiC28Bnp+QPU+jMj+s+N4H9k nF6MkMVoAqMZYBzDGMckjGNq1jwLa56LNa/EmldlnlT9efZpWmaQZ2EZcNeWi0CyV+3/7634j+3x ue3QGeKxpQBbiuIR9vF4Io9nCI9nKI9nPB7PMB7P+Dye4TyeCXg8E/J4JuLxjODxTMzjGUnjlgiS eL23TXyl90ic15ux7pxnOwW2U8F2KtlOlfddxwx55bsRxEpeeoEXM509B88CtmSTLVmzJfufZ9Li hrgrHnlsIJ5MKJPIVDKDKm02MGPNxmZTs63ZzuyAKTAVpsF0mAEzYRbMhjGYA3NhHsyHBbAgvotF sBiWwjrYEBthE2yBrfATbIcdsCN2wx7YG/tifxyAA3EwDsXhOBJH41gcjxNxMk7F6TgTZ+NcnIfz cSEuxqX4Pf6IK3A1rsV1uAE34WbcittwB+7CPbgPD+AhPIZX8DrexNt496/7Pv+67/Pf9kuPUOL8 jcz4+IhifqE/dV87zUTRzHf4lbuQ/e5dOi/v8fk/3Kfz8g4fOod8R9Z5ZaXD3VKWPNDL9QJx231j hcwp89ARRWlbBVlJvi9ryg9lQ/JVrcnrdXGvq72puNfSXi10ltdLnt8X98rbq8W9TvfGUvTvSgn3 Kt5rpcLvi3tF79VCuvxBoXjwWiGdXy8131QofrxWCKXXSx0uv31u+HelMZVmf1Bav6nYT18vFLVe L4n/rqR8vXj6Pe8vn+Gv9ZE/WB8RcJTiZwGK9aWIZVflZ7G8eAKL+zSW/jAIhlP2MxlmwjzKf36A VbCeMqCdsJ/wi+brzf+3dZ5/qq7wz9RvXAV5vkbikBju5j1Q2M0FKNYl5OzBvc4iRAbKoyVFe/cZ icPFCGqPFO4zNsdT5iXFYnGN2tfFDcpXbpI3ERQt71L7nnjAMfMRtR+Lp9R+Jt13IElpuM9slD5q a36LkC0p/5ZBGcK/xqQcW4ZJ9wl1CWRCaieS7nPPImUSakfJFNROKSlzk6llOmqnlxmonZHfWJRJ ZqJ2ZpmZ2llkFmpnle7zysbIMdQeK8dSe5wcR+3xqiQ/T7g0KFXGjO8+tdUkfc1I9x1eZgmzJCiz lFmP2vXNptRuZn7iPsvd7EDtT81e1O5t9qb25+Yq9/nb5mpqr/GTZ/ZLyiKlP23gYxCB5gFieoEW wVkggrODlPUG5wRXU3tNcB211xNTFZiMeIYiNvmMMzzyyiEyJMXz31nzyEio7/06+DcOIpiDCOYg 4pVfsQrmIII5iGAOIpiDCOYggjmIYA4imIMI5iCCOYhgDiKYgzzvoWQmIpiJCGYigpmIYCYimIkI ZiKCmYhgJiKYiQhmIoKZiGAmIpiJCGYigpmIYCYimIkIZiKCmYhgJiKYiQhmIoKZiGAmIpiJCGYi gpmIYCYimIkIZiKCmYhgJiKYiQhmIoKZiGAmIpiJCGYigpmIYCYimIkIZiKCmYhgJiKYiQhmIoKZ iGAmIpiJCGYigpmIYCYimIkIZiKCmYhgJiKYiQhmIoKZiGAmIpiJCGYigpmIYCYimIkIZiKCmYhg JiKYiQhmIoKZiGAmIpiJCGYigpmIYCYimIm8eEbJyyeWJGlLMpy3QpKPo3smaewLZPy81Of3gkLL iT2T1KBNVaUQMXZ0wGdmQiUjTYiu57My+YQheuaWwphYJbpSdOZXtkRNTtY9ii8pFYAKUB/aQity orEQR//dS0wFo1O8cjIjvG6vggsqFOr7KGfLknV8978qXWfCyhoTeybMGN3TCIvuKR9OVFJIcg6r 4YsCBfrG21HwboPLx96NDr7sqTCoT61jMkVn8Klqhh0/ZdFWrTu2adq4SVzy9A0yJI/Jmzd38vea NmjTqm2rRnHJi7Zq0zprTLLoqOcHJ3h9T6s29eKatmoZkyL6LXe/ih/x2/7KrVrFJS/cLq5JqzZN 4zpGJ0sUzJs7OiYmOjp3NP2rlSiYPTom+9sx3sf/hR71FClfhUWYoHqSW6HtluwpBMySy1e3Ppv/ Zvkk6SeM+LRO9MXJswak+ej+02Hlpix9Om5y8oKdK00eM3lg3ewf7yjSsOPVue03VT1489LYz6MG TujVaOG6jzvVT7U3aYGjIWLw+eE/r8zSaPToJmlHbc+XeaWzuEba1SXOWQXzDM88K33emZdLf1bk VK+QH0c3r1Zvbs/Ok+pm6VDuwqhFDfOPrhgV408dPmHWua8zRZx9Z2SD8Lo1zNgJSXNX7nNvxrWh cn2SXSurFV/Yr/vKfJerDi0/78mMTi3iyn8bsWV4IH0KqD6obtPcP5YN0wXef/bBo6mNLP/0nT3e r35tSf46CXt0MA7eXTGv+7Cn323ttndGZJsPC/zy03X/lJTRC329Ny1M3iF+72NSkeFP6TEzuse0 6B6TCc2kwugxOrrHiO6hH2xvfa1pm/GpKnUNX/DeV882T2rz3x+/nv/AxpU7hsPO26sG3BoRkfPK MpF6f4d4tz6sm33CeHtzQfPrvgM35Tub4ub16kMyL55YcmP9a4/3bcmfv9asXFWbPk3dotCmLbOP mp2PxAx4Z0Jo62Y/Pg2rENF01ePtRU/Fq5W8wsX6f/t2duKNmXKnybIidlJY/zQhDabcqxr1IMWm vQluVZ7bsmh2/aRnovtnGjcPVrq7/EblDcvP/Rz9OHlMoG/SYRki39uTVE670f24WvTB7flHNla/ Glt6Q+WqSxap9GHPBu297h/YddmIdXNyZz7d6fTMDqfaT4TtzQqt3pmr//HCYTNzNkvS7FDOE7uj jNMzixsba72dp+V7UcH6S63JX+7aU7VQia1R1aa3PhSWr8+QdhNm7JxIXqFudE9V7rlXsLLOiXe4 4rMPx21e9cKnJP3fcgY07/Nkp3/kAbKTM4jJTh9zvnAGHdmD0kl88WW1KjHxo+O5H/zxrer12jZp 2rJxHP2Z0Gh0N+r4unJswxatWjZ80THrjzqWKjrF845Fvrq/YWzyKk0bt6SzJq9YtPA/9ApLO3bZ W/t/qjXPsKaWrY8HSOggTarSu5QdCCX0FkqoAmIDBULvQuihE1CpIopw6IhIEwQkSJF6EAEpKtKk v1wpAlIEAZUbuHhEj+c5H+69r8/9lKxZe2ZP9qz/b82anUoE/D6sBDqyzSel49u0y5H5FHFlpV9z 7lVsq7OesfVGKmGr/pCOizivkm1jDw+OQhsX4j2GaChKoDb6ne/UWvZbKh6OflXeHevUXhZE/k0k R+rzSnHuVqQoxn34OLt8LJwGPtYgtGEnL0ogsfdFQPveIxeC6PTd2gpUSPi2eXZYJDa+fK0mOa9X 9p4Rlkkg2mAM2AQpbrRvK4Y9iVpygReIwTarxMrIg6xv+Nml3/Giiipba1vnfGxIF4fqEhmWQLAs 1yFvyxuZMPfYnfYvKo3uMFPKCje66gZ5KNUcyNtgbKeYatB9KljSLVKLuD+zDxlF6BYFutsUPWFy SIUdIGwLoN+HAh+YEiAnJsUnNAiEhIjofwMVx/bnSI/fGoIhABH+Azi530ANZgQzdJ/s8QF5XCxb HWkzSDutIZangXoPUOy7j4HBeBlFHZHOAWMCix8EI/nXeuoN0LnnBNDC3pVRn4v1kv1A+vOdi8xv HH+nzsWsE6q3d0Z3fzTpbslqMHN/j9Io1AAt3+5IGzhRQ5HFQpU8OMJeKhS0snTPqyRhHB6veMep Xtb1xdUyns8T868dyW5cbfgyBaqDrW9htmnoxCCLQrdvqjkLXsHJJkySUD2zcHjeEKrqbHe/DlcX D+tcI6LBBHx4Mak2Efhlaqrky+bEAFWlx+ukGcNq2VyM6CvFURiFtQxhVpgTz7VNc1RC+YU6+KBl 7JlIVskP8neywylzL8dUiuBy8ruKRzirGwEWLCcDlXC98Ybq5CVgJknQMbrZY3q9oLgnVM3ThxrP GCc8Y4wPGWN1zE//YIdEdFRHEDxnfqGqvwJHEgDwxJHEAweAAxL7puS+CaD/K1M79BP9hf9vWZM7 Sh7X29Ks89vzIjlYKc9551GXJ1zcuOSOhQeN7QP8LRK0MfUjFiK70mbsx089SKAaY8hzE9QLYVRW LYlTeah5lWo4LLk0hbjvrIaP+cLqJ+rpEHSeZBd6dmXGKieYCIfYG1CiGyjvvETVF7iGo6f6ZOkk iPWOxZXWY+eYqhKffGCstrZYop2QW+a6GFMW6tWKmLl1zdfyt7elvs0ycZIM4vSj1s8esBYa3rEv fcUJB65MxtlrTref2KAyQquKz0F4nbicdcqT2irgT9XyXc2ZkcUJg/ERSn7kWkN3KyJ5WqfXAu0e ItEN/Kq66VYMlgZAR/h6H4UHZvmMvu8L0jM+YYes+QiEfTh49ieP7SsWL0LipiOCXedSicec/miq e2eWadApAgYR45/7OZr2OXGSB8wMMIb+XOYa+xdwgBUBeQCeLZMtFSXpgEZ7yImLozxdxFy/rqEY yt1V3MPZcb9V3MPT3cYbhfYSVzfBB5oYvgnQ/npL/D5EAZADZL/aAGGUyOGAvr6+PxvQ1vPISOgf BHRAG5Wz7ib2mZwRMALqfzDpKpQuDoWFLFP5o30NU7SY10HHHYNHrRNzP9vnpP+foNDOmcHUL0aN l8gqH99bCl+/w+5+fufD6hTlyxhSJUYmzv6mRwgtUn7Ls2S6ye9Ju2v13d5Pa9MJSsVweU5cri5z pONNXp6HkY0Gu7knkRt3CuvpFEmIRM3ldFvw19crTF6siKColTphGInQ2qtLzjlPUnh7zK/hbEh+ gUH3Wml6mup0lzmv0psQmJbBZm9HYMZi9bN0FINJWWnaymBjb3ZO8a3OgFPRIk1Phz+5EI00ypau 9puzMB1r2uoMvUdDyjqWyPO2PEdPaaGclt+Pulnk8V3npwkKeNpk4GmD/UobHczSAW0gv442po6u tl5oK1ePo7SRBuBQaQAqJSVxsL2BHpgSwL4JhN37r8xNAOD7V6Jkd1N39HCw9eTUMEFwIkwM5KCA hqyolCxMRlRdTVP264VE9Ox/8SNMbD19HFG2fwuohVoIqmPY/0GkhlJ+ZduSXibvBNyHney1BPKc 34tTw/kkiStvFXcb+DF5u7NBwRK9w4oxcJm1j0PyMMZXSeG7sHcOWE/WhMkavcka7LokOWFzro+X lJ7FKm4KGXSyJtlvdI8de1xN80pPiMBZuv4IQ/nenfHNmCVl0MzAuNU2U5zu3TCFD44qC1PXGkkM a9GB85SzWgvFLqsD9mGkHxk7g+jrvKbJ9Hasd5ey4WlyXxZpO6zYrc8NkZtGDMjr6k6faRC3ZI1P gqiPWCyGk/OkkGVDoLYxNw3YVblykxI/IzQQ7lIPETKljoW22zD1h0wt8vApmtg11ugZUyMO+Qxo 6VFAfQNSsOd7MWUzoUm+LYcagk+6U8G9M0rfscd9zkA55TGsWDcqoT59oUReVb29799iD9rLA2X1 H2HP15HQPyMo6Z8o/BNAOQaEk1Ey9o/3al4Ta+yHBYSFCAiqCq+/5EqiTim9bHJJaHup2RR5P2iL vo+CYVt/Leo4yG0m4qQgokAELjHmniZzYZnHOMGUKE65IN1GdlO6g0G9Wk7pzjOq1ithgut2BdBp c4uEbWPjKfPFm4kZjmR61/r7ffRgVE5TGI2CUxcjTEMQvCx8bdc1f+ebYQl1FGLYZGp/zy0Spnnp 1Mb2vXZfJR737Xs22Phca6pCUfb7s4lKIXvl8Z9S3q1+Bpc91+m5gC7ZWafnYIP35FW9rt+oWu4o XTNj31VY7XgtrFHfmK4cZMf8vIITRd6pomgrwYKpqFFs5tc24GZJdYsFmldvfA8oGieKVMMmEF8x 7SiC41yAfe6PmPo1xdchnQAYTGafTnC8+QuKrz+B8+9480bGbbesQw15hbmjR1vJpGmnmKFWRKKO ztC4I2JJSXJYB5okWH3DZpLDKLK2Rbc/BPJxxftJzNP7Aw8cPez8BOzmqnEr2MfPl4s+092lOM8t JN6rMmwGZvN55GrjijQdHVsdb8yKeBo6EaJHKJP8oSmT1IzdQev5cJOPuXhQNR+4yuyi0wnUXihG YXkAzKcP90WTWLSYD0XJiHg/o15gh5NhfL5kuLgFTL5TSkjJvEJ9WdiQ2dpSIvNFhMEpbnMHRMy4 eCSNUcX2I9Y4l2W+3+g/dtEMYqk3wn28pNtvBeR2WxK/g5RHSeI+Jl+MVI08h012K+cQ0e52T1ef dJoL4Y93/hdvwgkE8U+E9+cK/Z8ov2iIyQ4PQI8T7NdUoCP0/CkcWf7owEAIpmQnB5mAvEHWIHWQ 6vel2Z/qup8AKlmfFtqCMaqjjc+xIiGgjvVAxK14mTYok0FE92pOm2BPLMFv4PLMKMZjq+XZ+ndL Cp7hHp7mYnMndQx2Jsrl1lxyqXLFcNdovoxcjzv2hOS6dPNi8LyHBSIr6UV3z1h801Sj8HPMu2cP JAaiH3eh2qT7mbkafcbl0yrZvDK5rg5VVdGZxm6kt9gi0wT50y2vH5N/Sm/rp13XWxohZ1hufW4c mJ+Hn5y5tjYCD9um54q1CUURg2+vpRGqiwdqXq3dIxy23UaOjxChb1ZC3Ci7M94IWmG0V5nSablk CU9ElxD/fluiZlal3USxofDa+JydTNwG9+307nJf09Nyrz01Kng2oeHgMjykigkJCICw6F9YlX1X K347484OGwEY/lhvQQIoCRHk4N/L+1FwuJhkRFDKo8fq+Nl8syig1MBR73GA51tHMBQfY0sunobn Y+zdnBkViMk/ZzHYdIYXAjZHulBCzQDTbOFQQZA+yBGEAnmC3A9O5u1AaBAnyBTkD/LAW/b4div8 NweQfw5/KO9fple0v4e7vaeVh4M/5w94A4cTgCis58L84l6mx7NuIpHpC4MZA92ZWtZCam0jKotg 002DZ7eaNz7toXIWJ0H+rTx5Ail2bddVsezmqYuBI3xEi70ebxtaLiCbNM9NW65JJWvuLARLSRd0 2jYVB7BeaHKSyyRPZbBitpjd+KDS3sPZpaLe92XtxBOHS8Gq1EVahgSoWWmB2UH3KMNGrFIKYRBc N35M8FIDU4Ou3s0OTo6MtZnGqqLuJdPk/MQ2ppDoJbbQK1t91E3VqnOyhjPdNda/jav5YNI4SFoL cTVF4q6aQ+MkVLHV/jMXLrp2La7O90gv1mrbrfh1fFLIqm6nFymhlZ26vnOf2Y7EaiomkuDyeZ06 g5xwQg4gnJDt2xoRQ8MJKfFNpP/vIfpjRvquwCA5DNFsC4D5aCRSfHsLRIC/5x8eCPQYPtXKQgEJ fKKVgEtKX/hTIFbKpaUYYOdP05PGIDdy5eL5rdncf2DWfoioqr2kvt0WNCqab0WgwELt2SvmZ3rR nSdKb4n8hrEoa4iG7XbGVF5PCptm3XszGA/bw6Byp0TwDRPslp5Tm0SnPoVX7JJ8MDiq3I+F9R/E ympZExENkUMn84UhzGf5XVpkbgaM19cWsc54Pum8FWXomTadvUkrtPEa2hyckkI4n+ntmwTCYSo1 lTu38iuGiPl1u1ud9Yxu1m/l8OUPuOl4aMQVhgwuzNJ0szPnXnjlbUPp5eulzif0mHli8uo2jg8J Jdvr4y4YfcSeWb4jIltPwYK9n1lRdd7Q1ACbvP6ma2pD9rOseVe9XsuohRXWoTiqft4+D1cY0AIp hB/fxolirEH/BErT2WsNCmVuZHN0cmVhbQ0KZW5kb2JqDQo1MzQgMCBvYmoNClsgMFsgNTA3XSAg M1sgMjI2XSAgMThbIDUyOV0gIDM4WyA0NTldICA2OFsgODc0XSAgODdbIDUzMl0gIDg5WyA2ODZd ICA5NFsgNDczXSAgMTIxWyA1NTFdICAyNThbIDQ5NF0gIDI3MlsgNDE4XSAgMjgyWyA1MzddICAy ODZbIDUwM10gIDM0OVsgMjQ2XSAgMzYxWyAyNTVdICAzNjdbIDI0Nl0gIDM3M1sgODEzIDUzN10g IDM4MVsgNTM4XSAgMzk2WyAzNTVdICA0MDBbIDM5OV0gIDQxMFsgMzQ3XSAgNDM3WyA1MzddICA4 NDVbIDQ2M10gIDg1NVsgMjc2IDI2NyA3MTFdICAxMDA4WyA1MDddIF0gDQplbmRvYmoNCjUzNSAw IG9iag0KWyAyMjYgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAyNjcgMCAwIDAgMCAwIDUwNyAw IDAgMCAwIDAgMjc2IDAgMCAwIDAgNDYzIDAgMCAwIDAgMCAwIDQ1OSAwIDAgMCAwIDAgMCAwIDAg MCA1MzIgNjg2IDAgMCAwIDAgMCAwIDU1MSAwIDAgMCAwIDAgMCAwIDAgNDk0IDAgNDE4IDUzNyA1 MDMgMCAwIDAgMjQ2IDI1NSAwIDAgMCA1MzcgNTM4IDAgMCAzNTUgMzk5IDM0NyA1MzddIA0KZW5k b2JqDQo1MzYgMCBvYmoNClsgMzA2IDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDQ5OCAw IDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAg MCAwIDAgMCAwIDAgNTE0IDAgNDE2IDUxNCA0NzggMCAwIDAgMjMwIDAgMCAyMzAgNzkxIDUxNCA1 MTMgMCAwIDM0MyAzODkgMzM1IDUxNCAwIDAgMCA0NDddIA0KZW5kb2JqDQo1MzcgMCBvYmoNCjw8 L0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGggNzc5NzYvTGVuZ3RoMSAxNjYwMzY+Pg0Kc3RyZWFt DQp4nOx8CUBc1dX/ee/Nvg+zMDAwCwMEGPYlQELChC1hCyEwEbJCWBKSEAiBaKyJqa3G4r5r6lpt XeIyGTei1q2xfq3VVOsXu0VttdpFtLYuNTbwnfvOGwIYl/r3/7f9/nMv9/3OPffcc88999x734Qw wAGADR8yWFbVUrt44aTiKPD9OgDnudUVVa0f3R+XDnDpMgBFfHVFQ2X2kWtiAC78OYCwZ3FVdY05 IfE64PtMWD+2eFlTy+Ez3v01wNVbgDs7ZnFLsML0QvfHwCfuAai/sKklJ/+jN3/5AAD3Sxy1o6u/ c3D1R1uuAki/GPs3dO0Y9jy0+7mnAWreA5Bbewc39N/054o7ATJ/C6C2bOjcPggJ4MPxH8f+pg1b dvY+fkmgE6BBBWB9cWNPZ/fr35n4Fepfje1zNyJDf7vhbaxfjvXkjf3Dpy35QNEGwJcAzFmxuWdo a/r1c1YAnBnC9ru3DHR19pzaeRqahuO5XujvPG0w7hnzRdh/DNs9Wzv7e56sWnAYYE8HgCEwOLB9 eNIE56A9N7L2waGewXU/mnwVoOivAGYemG/l14817f52YJ2x7H2IQzMxPfyXM37G8KmkqwePFR5/ RmNVJQAPaiyUsJ8CJoA7pLnxWOExLbYDtw+mJVklkzFuhNUgFxk8mCAH0Cr1uJm0CDI/dzG2quTX yAtQpYtQ+Dmcw4MKeKOc53mZhpf9DvjJANw5iX3UrGNji8fDtHtMZIPyej4VGTeISn8oN7OZonYD RNO0pHgJln/dNkRTNP2/TrJEaP4y/YRWaPgy+oUXoPHLjPe/IXFHoPz/ph5FK5Sjvz91DJkTln7Z MflHZ+oVEum2+dx+d8O2Lzvmv5pw7oNfhR7hcrB9FXqiKZqiKZqi6T838d+Fh79uGz4r8dthyddt w+wkFMGHX7cN0RRNn5eEf0Lt121DNEVTNEVTNEVTNEVTNEVTNEVTNEVTNEVTNEVTNEVTNP3HJEEq CeL/HwR4FGtI8XeADL6HdReYkMP+/50ekiALFkAjdEIP9MEAjMBOuMtjmpwUe+rBO9Xehe1bYGiq nZt8H4eplskmP4SbUPY91oFbyj/12npp3Pgpi6xY7GhPxMA64SrOxMVzLm6AG+F2cLu487mLuX3c /aDg3hJF3pV0nEgc8NL/b+ThsxN3YpSTumfos7vLFn2O/qrPaY+YgXbSLKX6GvEpzVikI7Om9qe/ mN7/NenfPhoDNevWrlm9amV7W7C1ZXnzsqaljQ31dbVLFtdUV1VWLAqUL1xQNn9eaUnx3KKc7KzM tNSUZF+S22E1m4x6rUatUirkMoHnILPaV9PhCaV2hGSpviVLsljd14mMzmmMjpAHWTUzZUKeDlHM M1MygJK9syQDJBmYkuRMnjIoy8r0VPs8oWerfJ4xbmVzG9IXVPnaPaFxkW4UaVmqWNFjxevFHp5q x8YqT4jr8FSHanZsHK3uqEJ9B7SaSl9ljyYrEw5otEhqkQql+QYPcGkLOZHg06rnHeBBpWfDhoSU 6s7u0LLmtuoqp9fbLvKgUtQVUlSGlKIuTx+zGc7zHMh8fPT8MROs7/Drun3dnavbQkIndhoVqkdH 94bM/lC6ryqUfvrrDpxyTyjTV1Ud8vtQWf3yqQG4kDzF5POMvg9ovG/8rZmcTomjSDG9D4xkU5xy E7ZHaEDb0EKcn9fLbDlvLADrsRLa09xGdQ+sd4YhkONvD/EdrOXxSIstyFr2RFqmunf4vGypqjuk nx0bHaE96z1Zmeh98ScFf7DdExJSO9Z3bWTY2TPqq6oiv7W2hQJVSAQ6pblWH8jNQfnODpxEH3ND c1soxzcYsvoqSAAZHrYGfS1tYhepW8haGYKOLqlXKKe6itnlqR7tqCIDmS5fc9tBKJh89UChx3lv ARRCO7MjZK/ERUmtHm3r7g25O5zdGJ+9njanNxRoR/e1+9p62tkq+Uyh9FdxOK84otgL5zZLOiLM Zq5MUXnaeKfQzlYLGZ4afPgqyrDBhMslVtmKVpR52jgnRMRwFEmCUTP0YEVIqVzCmgTWtXKJ09vu pfQZJjklm+QpIdU0XSZkTNlE43yqaSTNDEr3VPdUTTNwhlK5ZKCk7eR28swX0sDYQ8WWc0mkSUjB nYs8HtWILLaKDk8IlnnafD2+dh/GUGBZG5sb87W4vvUtvvrmlW3iaktR0jqjRu0lVAuBF5sjFb4S Y7DG74wsq1hfLNanqktmNddGmj2jKl99yyhT7pMUggd3EE5akVrbeV5JTCFuzRo83Xw1nT6PyVMz 2jk2uWf96IFAYHSwumPjPKbDV9s96mtpK3OKti5v2+U8nQ0VA/VcfWtFViaePRUHfNy5zQcC3Lkt K9sOmgA857a2hXmOr+yoaD+QjG1tBz0AAZHLMy5jsoqHVZim5VhRifLOgwGAPWKrTGSI9a4xDkSe KsLjoGuMJ54pwuORJyNeQOSxhIvk2IguxuO22tPNlueM9o2jHe1sc4EdlxJ/uBDnWwgh3rfwAMcr dCGNr6cipPVVMH4545cTX8H4SgwMzs6hc9iZNNrhw3MKA6oNnByFosBUesYmJ1vbvM86x9u9GGqr saxsC6n9ePbLU+pQbjErHcheHNrT1cnsgGAb66tMqe1qx7CNKESR2pAaNaglDShRI/Zh4YidunBt cAHF/nuwEtrTHmr3s0Hb+trFcDaFYIlvHi476ZSnsoFy2kdjfPni3sStoEnZy0CNtkFLG3GcWMXB 2slJSh1a3uXDpq4OD3pbBl0tGOp0lmqcxOnBI1GW2iMWjVNqBDYtIUWr14TU2agQfxitzWZbUp6i bG8n48XaXkkAxzaFtGhR6jRXSh3QO9hUy2zBn71oKhN9gqlpHoPlvtPwZGFGi5qU2BzSp9R24uFP /bXI8ZVEOqvYGaGVdBwirpLNXId+F1JaxyZv9e30TktZmT52ObDABOdBDGxoH53NCK3yZ2WqZnP1 Int0VKU/eQfyl0o/hciEA2phjD897FroHuN3EpwWdmkRTiXYEXbNQxghGCaR7WHXfIShsKsMYRvB IMFA2LUAYStBP3XYQrA5nLgIYRNBXzixAmFjOLESYQNBL0EPQTdBF3VYTx06CTqobR3B2nBCNcIa gtUEqwhWErQTtBGcQrCCIEjQSrCcoJlgGUETwdJwQhVCI9UaCOoJ6ghqCZYQLCaoIagmqAo7axEq w846hAqCRQSBsLMeoZxgYdjZgLCAoIxgPsE8ghaCUtJZQlBMyuYSFBEUks4Cgnzql0eQS5BDkE2Q Rcoyqbuf+mVQWzpBGsEckkwlSKEOyQQ+6pdEkl4CD4GbwEWQGI5fipBA4AzHNyHEE8QROKgtlsBO TBuBlcBCbTEEZmKaqGYkMBBTT6Aj0BJoCNThuGUIqnBcM4KSQEEgJ5CRiEA1noAjABG4SYIJguNi B+6fVPuY4BjBRwT/IPiQ4IOwowXhfYL3wo5WhL8T/I3gXYK/ksg7BG8Tc5zgLYK/EPyZRP5E8EeC N6ntDYI/ELxO8BqJ/J7gd8R8leAVgpcJjoZjVyD8luA34dhTEH5N8Cti/pLgJWIeIfhvghcJfkEi L1Dtear9nOAwMZ8jeJbgZwTPEPyUJH9C8F/EfJrgxwRPERwK2/Fc4n4UtpcjPEnwRNi+CuFxgscI HiX4IcEjBA8TPET9DhKMEfNBggcI7ie4j+BegjDBAeoXIlvuodrdBHeRyJ0E+wnuILid4Dbqdyt1 +AExv09wC8HNBN8juIngRoIbCK4P29YjXEdwbdjWhfDdsK0bYV/Y1oNwTdjWi3A1wVUEVxJcQXA5 wWUEl4ZtnQiXkM6LSedFpPNCggtI9fnU4TyCUZL8DomcG7YFEfaSsnNI2dkE3ybJb5GWs6j7Nwn2 EJxJsJtgF8EZBN8gOD1swzOZ20kjnEaqTyXYQSOMkC3DBNtpvCHqvo1gkGCAYCtBP8EWgs00lU00 Xh/BxrBtLsIGgt6w9SyEnrCVxW532HomQlfYyvqtJ2Zn2BpA6CDmOmKuDVt3I6wJW7+FsDpsPRth VdiClzC3MmxxIbQTtIUtGoRTCFaELXjNc8GwBe93rpWghWB52ILXPNcctuDFzi0jaArHMKuXhmNq EBoJGohZT1BHzFqCJQSLwzF4b3I1JFJNzCqCyrB5MUJF2Mw25aKwuQ0hEDa3I5SHzSsRFhIsCJtZ tJYRzCeYR1AaNvsRSsLmTITisLkUYS5BUdjMBiqkgQoI8sNm5sE8gtywmTkyhyCbbMkiyCST/GRS BkE6mZRGMIeMSCVIIUgm8FGHJJL0kkkeMsJN47kIEkkygcBJ3eMJ4ggcJBlLYCcDbQRWstNCA8UQ mKmficBIYCDQk4iOatqwaQ2CJmxai6AOm9YhqAiUBAoCOUnKSFIgJk/AEUBgEnES5SYQj2P5J5aP sRxD3kfY8R9If4jlAyzvY3nPuN79dyx/M3a53zV2u/+K5R0sb2MZR/5bWP6CbX/G+p+w/BHLm1je QP4fsLyO9GuIv8fyO5R7FeuvYHkZy1Esv8XyGyy/Nmxw/8qw0f1LLC9hOYLlv5H3IuIvsLyA5Xms /xzxMJbnsDyL5WdYnsHyUyw/wfJf+s3up/Vb3D/WZ7ifQjykz3T/CHlPIv2Evt8dmHxcv8n9mL7P /ah+o/uH2PKIPs/9MJaHsBzUbXOP6YbcD+q2ux/QDbvvx3IflnuxHkY8gDIhLPdguRvLXVjuxLIf yx1Ybtfudt+mPd19q3an+weI39ee4b5Fu8t9M/K/h+UmLDdiuQHL9Viuw3Itlu9i2afNcl+D5WrN re6rNN93X4l4BZbLsVyG5VLNRvclmrPcF2u+675Ic537Qs0N7guQfz6Ws4UU97eFEve3uBL3WcE9 wW/u3xM8M7gruHv/rqB2F6fd5dxVv+sbu/bv+s2uQIxCc0bw9OA39p8e3Bk8NXja/lODD/HfgV7+ 3EBZcMf+kaBsxDoyPCK8N8LtH+GqRrjcEY6HEdOIZ0TQDQeHgtv3DwVhaNnQnqHQkGx+aOjVIR6G OM3Y5OP3DjldNYiBM4b0ppptwYHg4P6B4Nbe/uAmNLCvZENw4/4Nwd6S7mDP/u5gV8n6YGdJR3Bd yZrg2v1rgqtLVgZX7V8ZbC9pC56C8itKWoPB/a3BlpLm4PL9zcGmkqXBpchvLKkPNuyvD9aVLAnW 7l8SXFxSE6zGyUOCKcGTIJiYAUsT0BL87FuR6ww4X3X+1SkDZ8j5uFOIMca74/l0YxxX2RTHDcSd GXdRnGB0HHbwAUd6Zo0x9nDsK7HvxMosgdj07Bqwm+weu2Bjc7M3ttaIWF5FmFckzrXR7kutMdo4 o81t46vdNg7Mr5r/ahZsj5kOm3ijkTMaJ418wIjiRoPbwLPHpEEIGPKKa4x6t55nj0m9YA/okcM0 ztEta60xat1aPliubdLyAW15ZU1Am5VbAwLn4Tj2Ow8PJ6iYFZzNXYP7+l47J+fwPj/Q2uL3148p J5fXh1TLVoW4c0MpLewZaF4ZUpyLn7pXrmo7wHEXth/g+MrWkJX9a5FYP/uCC6AisT6U2NIWujGx vT60B4kAIyaRgMQDdqho96/dPrLd7x9ei4+124f94g/WuBFW8zMm+9k+jHWWR8Q6+D8zkRjCuu2Y hiPM4c/u9R+buK/bgH/z5Fi3lv3OSHk9wMRlM36btQw2wXbYg/kcuAAug8fgN7AevoXUNXAj/ABu hxA8AT+Bl76aX55Rmtgp7wed8CAowAIweWxyfOIHWMbkhmmcy7BmkXlOcCZNk2/P4r09cdmkaWJM EQMasa+efwG5f+eOTx7jy1l9ci6r83uRNoo93lVeP3HPxK0zzKmDBmiFIKyAU6AdmmAplmXQDI2w BtaJv7Xrhh7ohQ2wEfrQX5thC/TDViy9MACDsA2G0IfDMAI7kB6WOFQ/DXbC6bBLwm/AGUjvxOfp IrUbzkTPf3MKz5rCE5xvwdlYvo3Pc2AvnAvfQWTPmbyZtVE4D87H9bwQLpqiLzopl9EXwxVYLoFL cdUvR/pqXPt98F24VuReBlfCVWLtBvgetl85Q5a1nZC/Dq5HqRvhJpS8GaPn1lmyTPIGeAR+iDH1 Y3gUo+0xpJ6Eg0g/Ca/Aq/A6vAl/hD9xfm4utxj+Bu/BYfR+L3qd+XxQfLLfoW6Y8vip6NuIZ3ej x2b6YYfURv48S/RTpO1UlNyLq3HWtD6j4jpFdDHpiK7p/mJzYjM6waMZXjbFOTHvmb1IbrrPZnpw n8iZ2Trbs9Ppmz615Wb4PpZb8MnWYXYtQt2GO5yVO2A/3IkUPU/UI9RdcDfcg2fBAbgX7ocH4EEY m6rfh7UT7WGRE5E5Of8heFiMgsfgcXH9fwSHRN5jSB2UWh+TWh4S6SfhaTyFnoGfwbPwFMbO02J5 Bp7D+HgeXsBT67fwshRBR8QI8nF++Dk8L0uFX8oNnFx4HJ7kl8JpWH+JvwZXAuSvg4F9j9TEduHX eHoIoIT54inQdH+WPcuuKluk4cahFpRcN/Dg4c4HFXBcdyBGxqcUK4Rmp9482Mw1Vyn5Vig/+vLR NS8ffRbxWS7n6PiRcdPxI+MxpaU5OXm5nNlrFovVwCuVCoUvKZsvLp47t6AgfyFfVJjN+5IMWFKL ChfyxQuFgnwXL4qSpMhFYcYVfv3PVULTcQX/DXf11qXJvNtpsOrknEfujlUtaMq2GL1FaWmBHLdS o+DlKoUqfV5VUtXaefET9wtKrVLjsdvjDXKZUqdSe+IscQbZRI3ccOxvcsPHlbItH18u5BVuWD5X frVGxcsUikecsSnza7xxfo/FaDHpDHKLPUahtMRoUxfUHT9PFRsfq9RolDqTRu1w2FVqjUJnOl4C HCyfPKY4hP6cB/c+xO/id0Obn70XBdsCFZleqz4725IFGpvVk6XRmDwXZXG5WZwxi9MKWVnzcnT4 aljYnJ2lt4DG7snS2ayZOd55BmdqszNoCsqDaX5HOaaY2FJzQTmXU+A/xOXnl8blrFu7Zs0as7/U kWNGn5u5AnMB/uAjD99VE7+wxrzc9hSDIC6Pxccx96fOEXxChIVLw1Yh1lLASaRS/gteY/XGOTwx cv53/PEmVUZaehL3EtLENsv5cVmMw2no9vgTTbKH5XyF0ZWSlTBkdJjlsjilTimX40O24eMrDHqj Dlfh6inerVaXRa2PT0v4Z7twq3OO06C2JNrY/yNqnhwXfif8FFIxXi94iD+T3zPl43vViSrXGHfP falzUuerxri7HwRjKmcRUvPGeFcg1gLq+XMSUxWCtzbjo/i6uf8IGBqFBtEH8Y3j5ePMD1zO+Ivo z6Pj6D/TuLm0lPnQ/gU6Mu9FgptchqErK8i3x0rhq1SmpmKoy2xWF89Cv1jIlCVnWONNqFZftWZo /rK+hbG2nPpN57e3n5lvkaWmWZ0mGfeLnP6quadU5rnx9X2uv3igoy4mzmyQKbXqOzwNgYyS1cML Si68/PyByiXlq0wGQaVTvlVdXdC6eWhrpq+61Ldgy6Vt7H9XNaDXVgg/gSLYO8tnCQlgZu5JTCv8 MM0t5+SaD3LqPB+kQZwpjtcIcdZjgZRGNtf4xuMvAvrGP16OBAL66lBpDnNQwr/aFb3FNjlzE/nE zlyC3rJZDQo6DNB3LpmwQmmw6AyuvPp5ga7aXJd+ZfuiNYsyTCq1TK13lDWtzrvpBlv+0qErO9Pq FhUlKoWlMalee2Kyqyi4ZeuG1A2bPOkeo0Hn9bnikhMtt3xvwSWXjW4O6O3e+BgplmSl+DaWCeWz /RLQeLPKk7BBnVTM3BNvS8oU5tQgU60ChSH3o4S6ebPjAMOgHHcg+aUgf9dew6FDzD1xX7jrJ6JI JnkC9x2djUouEkZ2iqIsITnDFm+S8x4xiuafMj/FprTn1m86r83fsLDQ1stprJ44hxv36MQRDKai YFWex1RROz2UbvPWl6e7C6tr69zzLr7kvM0VFm92HDeh1LPNqFceX1+9JG/5pm1bszs3lG269BT0 XCPG03W4C7OhbLbnHsjIL1bIQD3GGwJqn1nnEqxWX84Yrw/YwKd4tLg4w2U26/Kfz6jTvRJwSfGB LjCXsvMrB8PqRbw7cmJLcf/FivvP8gV6RSLKp1DMiCZeOX03ov8Kmft4JZMQrguc++Llm5TyroFA b32uWq2WqfQq3YLW7vz2c9oz4+auOPXa9a0j9Um3L6tb1N1YbO7tuyDo4/+At0+Gd6Gze5PFbtHr NAmJ8WpdrEWX1nJG66IrLj2nd2FGRXNxQXlWQ09JfFYZeqt88hj3jjwH39vTYdNMb92X7ra6YIxf H9Bq3C6X1Z0uS44zjnGLH5AHkmvjpBB5uXHcLJ5OR14cZ0c7euXBz5FlDpHObulWnXaSi4H0J7k5 IcOVmBrDyxUxTqRSLPzEh+zsdsS58ey+lxOPcSQ52c8SUmM1mtjUhISUOLU6LuXjPJVWJZPhQ/g2 3qhI6ZTsnGEzfVe+DWyweNZ+MtlAG9Dg5aeVyU01cjJWnFP8swX5bJm1n2zESUinaTEnmf3GCQM5 Da+2iRbKuLiIPfISFdmjkuyRv4lxugpunWVPaVVWVnZprD3JuzRpFazCwfGm0JQkaVvqzGkfBWrr SrK9sRqwZ2mTVi2tKjUULKwtaEhokGwTrWPn2iG8iXNyDuHhZi7Ix0g8hPBjpMTL1/uv6pp+B8+d WyTFqvAZLMkrSsJYAptVoZRv4DQ2rwOdo+AH5Mq8BfmbO+rMy3himhTcgFKeX1awiZgRl97P4T1r tTmNMi7JWL26v7RsRXG8YK1ZvaWkcmWJQ6Wc8jOfmVgYH2hYsPmyFRNbTzBd8+IW1M5kCmdjhAjs arozCa8sb2lTjq+hPCO1oq3QV5UsrZIQwlWaB9+YtUqpefHxzlSZQQAjZxWMhhTbR4G5dSlOgyze mJeq8vhrPQ1qyY3kRTw/DrHlwCWYWgf75/cSzw/Fv+BqIaRSbsP489AOQW8WLigaWFf/qd6sWrtt AfMhfwRnffy5Ey5zz7MvqP9Ml6VXtuEpshTP3OfRS7GQA20z/XQQbzN3QA0Ok4O3CI5kdmNpdYnv W+rSXwsoT5yW0uvNOHOK5pPNdIjKZp6XkStafG2RCc8nlLadetWaju+0ZTjnnSJS7Rl32/KaSsrW N5amxNjzlpYs6GQUv71u30W71xZnt+1prtt34Zlri3Pa9qzMX1bs8teuHxgpyV9W4vLXrR8cpgjg /4ZzK4Ats+/hNLM5MSYBEhN0Y5wjYApk1cUkmNMS5yhik2pjp04KWvmcQ+YC6Xw8CLrPEZ8228/c U3a0DM8TvUpliXVZk9pXLDY3zTwlpTX2xpbXNc8x+1yxCoVwrSzW5XHGKDXK+RsvbJkY+OTS3pLe UJokV6oVCrYH1JPj/F/QAzVw10wPPIKhfxxfdgvxPvXb52MGn7Ew4Kw+nOaR58oDckGuORyo83yU BhmmDF4nZOS8HHCe/L3LLL6eHGKfzEzjJjEMkv9PdM18j8NzxyWzSfU5qZG3OF76pMfeZXjJo39R aI1qnTe3MjuzKttRtGxNU1HxhktX5rRU5upVSl4hfrpKKl6+oLipMK6waXVTUeG6s5tTF5dlarXC Fo3XY7c4rHH+YldaUUb6/Jbymp2n5BnsTp3KrFPZHfYYrdPtdGaVeTOK/BmlLYGKbS3Zuhi7VsM8 vW3yHf4p2V1QDaOzYi19bqa/2F+hUi9SLypW+/25xbHFsZBbsaR4UZkq8zW13zt3ifEfAe/UjkEX jOc/W1qKl8CzzKkxpSz6TLv2Hjpk2ksvf5Yv0DsSiT7h099e2Kcy+pRcUFAciVCU4p/iFRqtQf1G j0zhz3WmJdpVKrUcw0vlyciJLVle4uTlcqFnl1an0Fn0u/2c1ireCnLO/4ZRI1ymttntZs2ExlZo LshRa9Rao97tciiVBq3CUdA4V5fo8Ri4Y3qLIcVjP6LUqWUytU55xI5+HMTz6PfCI/gGODLLj0la B+SV5ef5kuMcoHUk58X5yvLV8uJaV23mPwKmRvmJN196BcA3gEOH8LA2i+97sV+gz7Sbcurz1typ rSv6UfqcNcXL5DQxiTar0yjnvabqNQOlVWtK49TKAelKRI9sVSi0Tr+7aKCjPqaJ00bYcehNGfuH g9uT6gNpKYvai7zVPr4wso+PvxBfkujKS7Yu2HJFG3dhhI0esk1cLtyMHsqFjbM+dfmslvSHeRMA JHHH73U42OuyL2AIWLJrfSprYq213tAk3U9idOG08TPF+NRHUt1J5aRLzCAoxZe91FT0iJCaOrXv LAULBTF27MLNMrl36cbzOiaOK2LiU+Kcvhhe+94VPK/E6HC6zUpuhF/Y3brYzWttyc4sl3CLNlaz 6qmX/vzNiRtUGARyndXAlQoDOqsSN7IgKA2a40mn3Hfwh53siNPhbfXw5Af8GfK1+CaYA/MDVpvW 7tM6ffY0md+ltYFGZpL7x7jl97kaTTVpEef4y8uPP4cv/fSumyMe5LNfW4WT/+PQ7ewYttnjjTL+ TkHnSI53Jllkwit4zGgNmb54n0Up15g0pgxvYrIFJxd5RxQe0sdo5XJdjO7jfsOcOT6N0aAyOoz6 1LQUrUmrNjlwFZdw9/Gl/AKcSez9oI15TXXCXvZp5Vm0kW1er/Sx1Yt7spRTqLS4q9bodTzuRaOW u9mg5RMU1thYqy4mRm6JdVi0MeilD4VeYbl8BD8ZzIGyRVqwcrvBBW7eiHVAWgMW3hhQa+fI45IX mxZP99TRQ/hxYPzouOn40fFZbrIrZ1X5X3FqsyMmJlYv45Zw2tik2FyfbCKNU5vikambxhTOibiG O8wok2kibzYH7a7lSoSjQq1o95z7rODWJi9ScwIkgAqfJkiT/vELPfQyeyM7emiGl3jmJcusunAR +kpv1hw36E0Kvc3E/92gXyqytMcNuikWd6PC6sCPWzFWrc/rsHLDSqvdYdHH2LRJXocFd9Rt/x6Z a4/mry2/9+kZd9AnspAg5Xu/zixL+wJ58ESWV8qPTM+Kqs/MT1FWnv7JrHJ9qXzP52d1VjRH8//3 +dKvOD/+VWVNQjR/5XlTNEdzNEdzNEdzNEdzNEdzNEdzNEdzNEdzNEdzNEdzNEfz52Xxr/TY92He gc946AAZlHEmjp/8Oz5Nk2+z78EUaZf43DX5Dufi9k2+j8+nkTOC9Fv4fHryN9wOkd4h0rvw+R53 Pvc0aLnzhaHJl9j3Z07+CZ+sdR/qfx2fJuTsQ/2Mdk3+GZ+7Jt/E5z4cZR/2eoJ7mtsHGnw+Dbww hH3pu2Cz+CSgb7QF6BafgjgLg1hjNA86IQMi33y7UJBJtAwShHiJloNDqJBoBfJXSrQSjgk7JFoF GcJbEq0Gj2xQojX8jVNjaWGF7GKJ1kGG7A2J1vNXy00SbYAtytumvsE2X2WVaA6UqhqJ5kGhvl2i BXCrr5RoGRjUN0m0HHTq+yVagfwnJFoJu9SHJVoFNo1GotVg0jRItIZbNjWWFvya1RKtQ/m9Eq3n GjTXSrQB5mr/yL4pWKaW/Ew0+Zlo8jPR5Geiyc9Ek5+JJj8TTX4mmvxMNPmZaPIz0eRnosnPRJOf iSY/3w4eyIdczCVINUIfdMEQDMB2LL0wjLxKpIZgUHx2Iod9t+xWyMaWRbAFsweWI4/9Veow9mK1 HsQelN6Bz26UrMR+W1BmPfL6UKJPlOvE0o+6ukXZrVjbjrytYhv170MLPFg6pb+23Im1U5EaxrGY zAhqHEZ+D9aGxG+83Yra+vC5QdQyIGkdRol+aUwm4cE5Dohj9oh/M8vmUivOtRc5neJfdA6Js/CI 2CnOko1L8+jClkxRc7/I2SJq7EQfET8ySj/q2SJ6bFCycity+sVRSSeb5/A0C9iIg+JcyN8Rb5Pt bKQB9IBH/AvgDaIX+sS/R2V/HTws1tiMh6fWg3xGo3hE27dK8xoQfbtelDxh8fQZMa+dJvajWW/G erYYD9NXc46orV/UsFP0w4i08tP9zVaM5t8j2s/mT+syJEYDQxqRrbUHdQxOzYZs3CDJbMfa6ZL2 YZwFrdCOqVXqFGOkE7n9M+YVieYutKRTHL9LGj/7JFE/7xPzpPWJrP+8qV1TBCukKOqT4q0INc7F 1pn9s2b0P/mO6JFim2baKc1tg9hKtvZI3mT2d4tRzeayWVzPSJ+Tt/b+S7v7RCTRugWx1ifawMZv EWcyPGONcyQLBqbNoEvak8PiLHvEOG9AThekieufjjLdov7FolXUd1j82/V5qDEHV5LlbHH/z7Q8 W9TejzLDGHfM/g3iDAZRw07kstXtFefCdtVMrRE+O1loBTZP6WsXbaaI3ilG4nbRwmFxz20Xzwjq 7RHnwPZrjxhtfeIY5KH1Yt+I96rRfw14WlLfoWkttNe7RZ+c2L+nimN1ifv7ZONSncl2YRSNiD7s ntoP3WI7O3FoBpE9MCjOdKu0C0hXj/hku3r2vFk7nR5p2CtdjM5+nFfP1H7+pFVbP6H5i/vohPbI Ce6RzmCKnq4ZZ+En534iXmfaNX+aB9hMaC50I0SifmjqdukWz9et4jnb+akzJT93zvBpjxT9s/cA 8yqLvBGxZ7d4VrHZ9EzpYZJbxPPus1boq9oXJ/ZEjvR9Ep3SLZUtrtUgnHa7Jz83t8TT2Nc1NLB9 oHfYUzkwNDgw1DncN7A1+3+IOxPwqIqs79ft7vSWBVAQJI7TEEBAloCAoMgABggITGSEwW0kHRJI yDZJWEclthlkG2QYxWUYQZwxiAuIDkEROsqiBIghQBJMQwMhMdyEBpE0UXm5769ud0JQ3u9lvuf5 no96fn23qjp1zv9U1e0IxjEiNdUxKXnGzJxsx6TE7MSsOYnT+zwYn5rszEp2JGc74h1pGdMTs9Id 2fHp2Q6eJyc5kuLTklPnO+Ym58x0ZM925qQmOrIyZqdPT06fke3IoGpOYhot06c7EjKy0hOzsvs4 xuY4khLjc2ZnJWY7shLjUx3JOdhIyO7lyE6LZwQJ8ZmcyyZps1NzkjPpMn12WmIWNbMTc/QOsh2Z WRmMWw6b3lNTM+Y6ZjJwR3JaZnxCjiM53ZEj/WBkNHGkJqdjKyPJ4UyeoXccMJSTOC+HxsmzEvs4 gm7ele1Ii0+f70iYjfOBcefMxH7iXEdWPL5kJeM2DePTHLMzpRl6nMGd7OQFVM/JwKE50qV4x9z4 rLSALRnmhJnxWQwsMatPc+jva7KJP9L/+6Q0A6cQIpxyDOwzqH/wee/A8xZCJBJtjMZjbUayHFUi w8yKn56YFp81y5Ehn7S4TLqx3HqQ8G1yenIO7X+XE58T8LgvHWToBhJQMicrOTG7z/jZCd3js3s4 pic6xmRl8DQnJ/O+vn3nzp3bJ62p8z4JGWl9c+ZnZszIis+cOb9vQk5SRnpOdrCqPE+Kx4FZst6j GbMJ9HzH7OxEBoFL8rEjHl0Ts9KSc+SAnPP14Y2aPH4ET7P0C1SfPjug79yZyQkzW7TlmJyekDp7 uoxFhmN6cnZmKgakAplZyVRIoFZiek4fR5PtjHTSo3tyD0dimlM2utZVelPlG45Iry4TnPBnE56E QBY2W9fjGuzrfn0A3ZOxwkSQoc+S02V6xtz01Iz4lkYZc3xgpAS+WYGM2TmZs3MI+5zkhERZZ2Zi aubPHLoZLXQl+k5PTIpnSvWJz86cJ7+Pyd8NoXUQi274v9BRqGGTfzdeWDRNtAr+dhH5z6i6B78H KTds1/QnxjQiLExR5G/zuNn64eF6/Qs3W79VK1nf8MjN1m/dWq+/7Wbrt2kj6xvvuNn6t95K/Rj9 96RY+e4n68tv3LfK34yiGEQ7pbVwKB3F3cqdYrDypHhQyRBxymzxpDJHpCvPiPlEKk9ZKV7k2778 7Sdv833/Q+M4sdOYJfYbXxGH6PkY/Z36mY3q/8HGEGzEYONhbDyFjUxs/Akbi7DxV2yswcY72PgY G59j42tsHKXn4/RXc70NZX8LG+2xEYWNvtgYho1x2JiKjRnYWICNRdhYhY03sLERG9uwsRsbh7Fx Ghu19Pwd/f14vQ3DnhY2bsdGV2z0w8YIbEzAxhPYSMXGQmwsw8Yr2HgLG5uwsQMb+7BRgY1abPjo +bIu2XU2jC1tRGKjOzYGYmM0Nn6HjQRs5GBjCTZWY+MtbGzGxg5sHMDGMWycxcaPxlcUYRqh2Ojp luttmMpb2PgVNu7GxhBsTMVGEjbmYWMpNt7ExiZs7MDGfmwcw8ZZbFw2jlPaGrOUbtjohY1B9PSg nH9Wm2K1x+fG506ivCxeFkso5hDFbB4cu3jlykx5GhIdm5u7cpo1RLGardZr983RsRdyczOtBsVq HC6GDx+em5sbuBgeuDDbFLP9cTE9NyZ3ybWOM2NjV65cGexg8eKV08wmxWzKDLQIoc7g4Y7WrU9a TIrFNPyCvD1Nrxwr22VazdSIiY2Ni3MMx5rBagoYE7mKUTGZThpNBmtIXNw6Y4gSYm4UjVa7Yg2d Vhg//OHhk4avyn0pdzHFbFbMlqExeYtfndnCQZtZsVlMJtO1Bzfy0GZQbAEPb+yi7Hrq9JjFixfr p4Nj8vIWZ97YRatJkcMP+ihrx8TEYFr6aJY+RuOjzWCwBX1s6aRNOmmSFZ8WotEWptjCHdHRcXHT 4taNdYx1jHPkDc8bbjErFutQOYJXZ1pCFItZOoqndotiJ3ampkdUkwNtzM2dF3BPBA3ajYrd6HA0 eWuxK5awR3OThsdQFuuh1E3gr3RYP5cO47E0FzJ1WqCZWVjMg2OGR1sXZ9pMii3E4bigdzhNbxET 8NpuERbLyJExMd2jsaibpqJuW+TmKibFFHLBZDLYzTi+zmQhWs8KccUertgjHB2iu8d1j4uLWxm7 cmzrpa0XOfIc1/kecJChLM4MtSih+H6d89ag89KmyeFo8j7UqISaHC3cD1Us4U8UJjhGUmR8gxH+ f+G+tN3k/nX+hwb8t9JyoRBXQ8OV0FbS/2jpf5z0nwjgf57DalGstmEjR7pcectzrGbFSgiG6zEI syphNkVRDM1PqWodOnLkldzcvHlBt0WT22FGJaw5DPokD1WszXFoioRu7QnnyJEjCYB+MVTvPG+e vnDIWOhtLcJqGTqSYJjy5tlDFLvZ4WgM9Juptxop/zCkUKuwWkeMGNm5S/fuch6EGQ1h5uZRBCIS QkRCDGEWuTI0RySslRLWevCdg+8cOih1aKr8cyD1QNryPa9+2eHLDjarYrP/JiFh165de4vn2CyK zXqHc1ohf3bPC7cp4XYlVxaj+A3fjBLELr3sFcV8D5OVbXckJe29olc2KeGm6Gghpul/6CB4J3pa 8x1buGJrlZ6Z/WpCh0DZGy2LPob07AT+7N27V7+6MzCivfP0NSg1s6kDC1aHOqdlDr4jbPm8ULMS ao6OvhLsPlNvmRDopnhOmE3YbHIll+PuRhkqBlOixTRRKMJDlHBzhw4dogPjE4WFir4+hlgM4dak pAMHFptsisW2MFe+dui/Aky+BdjFesNUYUyYn5Uq2s7ISpwl7kuNz0kX43mi/G7SSIfoQG1NfyMx i3D52770K0VYRIRop98P3DGwk7USt1GMY0lS0WXSbyc4RPQjkx5yiGHBOvLdsLVor18ZsdCmuXeT CBW3iNuDVyEijL2wo4hMyMzOFP/UPzfqn5v1z63652f65xez+HIpvtI/i/XPI/rnN/rnSf2zRv+s l99sxEX5qZj1z476Zx/9c6T+OUX/TEmblTZLeVb/XKR/rtA/V+ufb+ifb+ufHzS/4f1vn8pNflqJ pJEYsKJwLn9y///vngEdwv/jY4S4U/QRk/SfpLnEKrFebBFfiFJxWlzk3came2oNelsv5H+/MNKu rf4bFuVv+bsvcFwQEzi+OLFFG/LtyPrrr783XH99qdf115c7XH/9w7rrrpUw+/XXEW9ff9262/XX HUcKm6HFdaS5xXOzUHo/cv11//Uc7eR0dxGHPxG0cRGqaEOcWGj4p6FcrDP+w/gPccSUY3pTHA05 bl6lGO2v2fOVT+wHQ8coX4VNCVtmeDDszbAzhvnhG8M3G3aE7wkvNeyOiI2YaCht9UCrBwzHhJK1 Qfpmzgrz3aiEWymdw3u1KP2DxXqDMjR8QXPJpayirKGUyhIhfl7CrRH2iF6taoLlQovil6X1Ezcs Sa0/ayptzG06NJelwVJ4g1JKqWg7rEWJDRT9yc9K2yltU5tLVrs8ylK9bLhRaVPabmu7r9r31MvU G5ak9iuby8b2m5vLN8FyklLTvr5F8ev3flY6OKhV08HRYU6HObfXyiLPOszpaO7YoeOkjss77u1Y Ikvg7rXSseZGRbdZ0/FCoETarxXZc2RrvX+H5FfjOvVqLiM7TW0u6cGSS1ndKbdzLGVS522diznf 1nlb1Pguk7pO08uCricp/m7vUbbcNfOuZ2HmXXndx/VwyHLXzB7DeqRSXD2W91jVszWl293LKW/c veHuD4KlpPeqvoP7/hjdtt9WSmH/1/t7+v94z9PBsuielfe8MeAC5erAuEHr790ty+Apg1/SS+mQ sCFLg4UrrpcOKdaviodUUJYOuXr/4vu3Du0+fPXw1SN6jdwyeEqgNsfiQK2YbbJezN5Ra0ZtHLVt dOfR6/RSNPqMXi6OEWNuG+MYfZGziZTpY67GhsWmjDVReo69RL2icc5xzjET+cyUZ5Q543IfMj/U RS89x7cd35EyePwweIny+vgrE26b4JjgGP/6hJ4TVk5YyX2eTEyCpyfcNn7wRP9vxcPOSRWPpDzq eLTnowPii50DnJ86PU3HhAjKqzOHzYxLfjt5c7IvpXVKx5QuKf1TBqeMS0lNmZOSm7IiZU3KlpTP UopSKmbNmfXqrA9mNaaaUzuk9kkdnPpY6szUpanvpRanXkgzpznS7ksbnjYx7Ym0BWlr0j5NO5J2 Iq027cd0U3q39Oj0Sekvpe/NaJ3R80b3MmIyns1YmfFFhiezW+a0zPWZ9X/sdqN7f5z6xx9vvA4F V6IW5fqVJMtxrcg1ImvKtRJYHX4+l66fC4F8vuHK0bR6tCjXz/+s5deKnO1Zr18rgXku18FW/ttr 2/dkLe08pJiVT19H9SNrZuvPwtfghb1VTbi1ad1r0yG8c5ulndJl2zBfhLi2/gWjsUBvI4K1FkTY m6Ik78r1VNaV9toslfebItWmA1e9WI3tEfbwzrI32qxqVcOxs16urfD9f7ayr7m2lrdYze1y3L9Y wf2/WMGTAus2K7a5aa3W+5Fer2mzNELI1UiubuhRwtlJuf4E1pjAasXKJpVKb1aPVUteXdOQCMs+ 6iPt+v0LnaYG+mQ9bbGGBtbI5lXwhmtgYHXV7U8Nrnojm9Y77vbqNLVjCef032/rOGe7DYH9RD+y d7RfyY6xod3W5h0huNK3KWy34dquEMgsucfotTfIGrSd2m6rfKLfoZa836Yw3NqUbe0382wpfdNe P9fvXtvPWu5ociz67tW0f13bwbYGR3f9npUU3Kk26rtUYG/qyXXAJlZHF7XLa/8NozgZjGwguvr8 ad8ilpH2wMyRMQso2yldxrVTuvS5/cm2w9rL6JfI+LeYg7061uDVSZkFTdkgewxEm7r1sh47S2yA wN7SOVbfD1oUubcE9hV9Z/q/LPpu1qLcoMa260twr2suv2yh73H/UdF3wZsvH/yfy88jJUvzDvo/ FH1Pvemi7/M3WX4eHf3toEX5Zfz0t4YWReZxQOn/rPyy5/99dDdXAnGWbw0R9nt3j1ozuDS8s3zf 0MsUeefe3fIdQ14NnjJqjXz7CDyTZcDVAVfl+0rgrr5bVASKbDN8tf5OI99eiocU628m8u2lmBZT eDPoGHyDoIzL1N8bOso3C3mtH+U7hazzUqDIGrIOJXinY81DXeRbCvN83bhM+UYj32b0UqTfWSff ZvSronGZch0JPqPwTrRx9Bn55qO/CQn9HYiiv/+Y9Dcl6sq3nmvvQaOLhlToHpdKXyc4Ap7euzs4 qraBEY6ZqPct36uE7CvQ78/m2i8Ua6lz12mBK2FWCrVPjBO0ZcbJopVxqggzZmlfGneKQTwJ144r ERCpVSp3QKF2iKdnhYEz1ThZqxIKn5eFgc/PjVO1r0Qr8a52RezWrtB2P2330/YMbc8o08StSrwY qzjFr5QE0VmZLsKVWeIWWt5HyxhjqrZVKPRbLUzUDaPurdQNo26Y3n81tXy0Cdc89Ouh38P0e1j5 g+hE/S7Un0z9ztTvRt9d6Lszva1hvCdEKGfv4F8b49PaSuMz2pP4N8RYpa02nhHRxmrRy/it6Gk8 q1UYVb5VSmulWDslrFgrx1p5UwR4cjtPzIx2mfzbpCIdj0eL1iD/7sD98r/7a6UiEZIgW/OKHK1e zIY5MBfmwXy+yy7Q9ok/wdPwDDwLz4shIg/+DIvgBVgMS2ApLIPl8IkYJT6FRr4HXxUOoQmHIoT8 FTcOJVk8rOwVkXibbJwi7jc+LizGpyBVLDYuFL82PgfPi1+Z1mr7TOvgTSgVQ0yH4QgchTIohwo4 Bt9AJXjguBgS0lYrDVG1fSENwhzi5/wy/KjtMxML8z0cHxB9zcM5ztFKzXNhHsyHhZrXnAvPafVm FzwvzOY8+LO2zzJQRFoGQYpwWGZBGjwthliegTzO8d2C75ZXOP87rOF8I7wnRlm2ciQWlh/gJ55d gf8SDqtBDLHaOL7DkbrWd2G7iLQ9JiL1HK4h3+161tWI28ncj8jcj9B8BprPQPNJaD6JDOtDhj1C hi0iwyaTYdPJsLFk2LhAXmkDjVO0FcbfawvIjUHkxsvkxjTjTu1tY5XoR34ZjTXaReNZ8bieW5XU Oi7atZgpL2LvReytwd4a7EVj7zfYy8ReDPYSsHc/9gbR+jFsvYStgha2VtH/Z/Q/WdxCr+fp9Ty9 bqbXzfS6iV430Wskvfag11R6vYde+9NrL3rtjhcn6DmRnvfT6z30uIFZGKkdpeVRnu7jzt/EHfRd SN+F9L2AvhdQYzY1ZusReooZMo2Rx4ts+h9I/5Po/wElWfNiI1p5lXaF2qfYGYadRXiwCFsD8cBF 78uMp7UreHHJWKv58aSPUdWu6rP9EpYuYekcls5h6Vas9MJKClb6YWUEVrpioQe9H6GnI8LEavY2 +R+OuuHcucQqlcXa8Zp4ns88+DMsghdgMSyBpbAMlkOR1ij2wwE4CMXwNZTAISiFw3AEjkIFHNd+ ECfACyfhFJyGKu2QOAPVcFErE99rJ8UlaAA/XIZG7aD4QdsufoSf4Ar8F1zVzgiNtVOAop3RV8HH NI/xCc7/wHGadsZUqvlMh+EIHIUyKIcKOAbfQCV44DjUao2ms6BCHdTDOfDBebgA38FF+B4uAWMx XQVN2x5ym3bI8pDWaImDyTAFHtVOWp7iOA0SeZ4Eydp2S4p2xjIL0mAOz57WfJZnYCHnLnge8nj2 AkdibyH2lr9yvgpe4f7rHP/OcQ333+B8LayDN2E9/W/k/vucb+J8K+efcr4XPHAcToAXarQfLN9C LZwFFeoYYz2cAx9c0sosDYAmFjSxoInlB0ATy0+M4Qr8F2jaIavQTloVbbvVoPmsNu2M9R2OjMX6 LrljECtEW31XNIoV2lnOisjzEhHClVwr5nE1g6zfZfxa9BQKd/0ihsz0kpleMtNLZnrJTC+Z6SUz vWSml8z0kpleaqtkWiOZ1kimNZJpjWRaI5nWSBbVkzF+MsZPxvjJGH/Tvml8UoQY48GpnTYmaKfJ Gi9Z4yVrvGSNl6zxkjVessZL1njJGi9Z4yVrvGSNFyX9KOlHST8qelHRi3J+VPOimhe1/CjlRykv qnhRw0vUG4l6I1FvJOqNRL2RqNYT1Xoi6ieifiLqJ4peougnil6i6CWKXn3GeoSFWI7Q30ue1v7E vj3ZWCLuMh5iBzvMzifjK99CjuBhlTBxtYSriVwNIL5rxFT20yj20yj20yj20yj20yj20yj20yj2 0yj20yj20yisDGNP7cqe2pX5WsJ8LWG+ljBfq5ivx5mvx5mvx5mvx5mvx4m0xnz1MF89zFcP89XD fPUw0iT23MHM0Qrm6AnmaAVz9ITRKboZeS9hD85jD+7CHtyJPdjBvhvFvhvFvhvFvhvFvhvFvhvF vhvFvhvFvhvFvhvFvhvFvhvFPPQwDz3MQw/zsIR5d5z5VsJ8K2G+edgvo9gvo9gro9gro9gjo5gn HvbJKPbJrswTD3tlFLlfQu6XkPsl5H4JuV9F7leR+8fJ/eOopKGSRu57yPcS8v04+e5hP41iL41i L41iL40SocR8JTF/ixX9K1b0Q8T+OWL/b9TbSX6PMpayoh/RrhqPigRdr1PUPkOtM+y7K+QqraXQ 9gBt/81dF21XyDc22o6jrZ92j/GutELbQs1V1Kyg5mFqplHraz1L3tF7+hvPl+j71+/1fHhNn2FZ WjE9jdRHcZR3M1m/VN/vv9c//bwFRGrfs7N8L+xKK3Gn8hikQhpkQCb8EbIgB5aKO0U7dqVSdqVS 2n5L22+VQt6aJ2trsfsqFmr096x1ortxuxhg/BxO855bJX7H22Zb3gY68rbZ1VjL+VnGporWxjox QDyh/6ulv8MaeAPWwjp4E9bDW/BP+Be8DfmwAd6BjfAuvAfvwwewCTbDh7AFPoKPoZC35885fgG7 YDfsgb14Iv9V1FewD4pgP28rj7Fr/0H71HRQqzQVw9daZUg73t4Yj5nxmL/RKs3HmdPdoQf0hLuh n1Zp6Q/3cD4ABmrfWgbBUM4fgGE8G6NVWh1avbUTdIYo6AJdoRvcBfRrpV8r/Vrp19oLekMf6AvR 0A8W0lcuvAfbtW+t+GbFNyu+Wc9xz6fV28bAo1ql7THtW2FBx2PoeKzpO4r8l15odhvfDjrzFvGY sPH2PNb4B45PibEiggyJJEMiyZBIMiSSDIkkQyLJkEgyJJIMiSRDImnpoOUsWjpoOUtvGUHLCFpG 0DKClhG0jKBlBC0jaBlBywhadqNlD1p2o2WP/7jlwGDLgbxpPs73mqdELxGCn5X4WYmfO/FzJ35+ rL//XpZvo/r3vAM8P0Ae38qdJPJ4qv7tRs4RVawgM1UyUyUzVTJTJTNVMlMlM1UyUyUzVTJTJTNV MlMlM1UyUyUzVTJTJTNVMlMlM1UyUyUzVTJTJTNVMlMlM1UyU1X+zXtroXaK7DxGdh4jO4+RncfI zmNkZxXZWU52lpOd5WRnOdlZrhzQvlMOQjF8rX1HtpaQrSWmPdp50174Er6CfVAE++EAHNTKyeZy srmcbFbJZpVsVs0btO/Mm7Xz5g9hC3wEH8NO7h/kWAzYIevLyXrVfFr7jsxXyXyVzFfJfNXSSztv 6Q19oC9EQz+tnNlQzmw4xmw4xmyoYjZUMRtUZsMxZkO5ZTR9jeH4pHaeWaEyK1RmhcqsUJkVKrNC ZVaozAqVWaEyK1RmhcqsUJkVKrNCZVaozAqVWaEyK1RrKn3N076zzoeFWjkzpNz6HPcWwXL4C2yA 97j/PnU+gE2wGbZrVcwilVmkMotU61HunaXuOer6tGPW81xf0L6zDdbOM7NUZlY5M6vK9jj3kvge 0khmnSKzTind+SbfA3rC3dALekMf6AvR0A/6wz0wAAbCILgXBsMQuA/uh6HwAAyD38BwGAEj4UGI gVEwGsZALIyFcfAQjIcJMBF+C89ol5VnYSHkwnPgguchD/4Mi+AFWAwr4a+wCv4GL8HLsBpeAfmv Rf8Oa+ANWAvr4E1YD2/BP+Ff8DbkwwZgN1M2wrvwHrwPH8Am2Awfwhb4CD4Gdh7lc/gCdsFu2ANf wlewD4pgPxzQapgpNcyUGmZKDTPdxUx/hpXDwlpxPyuH/EnB/aZt2mXTJ/ApbIfPYAfsBDewbpg+ hy9gF+yGgyLMVAxfi7CQdsIe0oHj7dARIuEO+JUIMxMf82sc13EkBmZiwIyrMW/iGjtm7DDTasz7 OBYB4zSXcSyHCjgG39D+OO1Ocn4KTms1FiHCLLdrly0dIRLugCjoAl2hG9wF3YXd0gN6wt1AzlnI OQs5ZyHnLEO5R15ZyCtmY42F3LGGQwS0gtbQBm6BW6EttIP2gM9WfLbisxWfrfhsxWfrnfBrcAi7 tRN0hijoAl2hG9wFjM3K2KyMzcrYrL2gN/SBvhAN/SBNu2zNgXlaDbO6xrqQvnOB/LOuhX9x/h68 z7MPYBNshl203Q17YC/Pj3LvBPW9QCytxNJ6jvs+OM+zC/CddtnGfLON4DhG2G3MFdvvOX+U4+Na jb63qMxwlUw0klGLyaj1+t1z3D3HjnOIHUf+1PCgfreKu1XBukuo+w9h4u4Z7p5p+hmbCDHEajP5 Dv8R79Ntgz+R/F70MrCiGQbAvVq94TccY7VDhrHafsNDMEE7So+nWP2rWf2r7W9o++3r4KCm2ovh ayiBQ1AKh+EIHIUyKIcKOAbfQCV4gBXefgK8cBJOwWmogjNQDTXwLdTCWVA1NeyP7JsGw1TeYLP4 Vna74T6t1vAgLNGqDEu1KuZbb+Zab54esr+m1dpfhzWwHt7RquybYQt8DFvhU60qdCX8FVbB3+Al eBlWwyt8UwkhMnVERUZjP9GQb+Mnxa+xvRbbaw2Pw3RIgyVaBeOokN+ysL8W+2uxvxb7a7Ffgf0K 7FdgvwL7FdivsO/kmRs+hy9hv7aWMVUwpgrGVMGYKhhTBWOqYEwVjKlCjEA1F6q5GFslqrkYXwOq XUK1S4yzmJFUMhL5k9XejLcdq1EI0YlmNQohQtG8xy+R7yIoeglFLzG6SkZXyegqGV0lo6tkdJUo 7UJpF0q7UNqF0i6UdqG0C6VdKO1CaRdKu1DahdIulHahtAulXSjtQmkXSrtQ2oXSLpR2obQLpV0o 7UJpF0q7UNqF0i6UdhGBSiJQSQQqiUAlEagkApVEoJIIVJIJLvEgUXASBSdaFBEFJ3oUGWLRZokW h/dxeD+Kby/L+PaygiiMIwq3EYV7iMJtROEeopBPFJ5HqyK0KkKrIrQqIhpxRCOOaMQRjTiiEUc0 4oiGk2g4iYaTaDiJhpNoOImGk2g4iYaTaDiJhpNoOImGk2g4iYaTaDiJhpNoOImGk2g4iYaTaDiJ hpNoOImGk2g4iYaTaDiJhpNoOIlGHNGIIxpxRCOOaMQRjTiiEUc04oiGU5iD3/pew9vX8XYK3i3F u9f0ebKH2OwhLmXEpYwY3IL/t/D0JXzfg+978H0Pvu/B9zJ8L8P3Mnwvw/cyfC9jDGWMoYwxlDGG MsZQxhjKGEMZYyhjniTzLXWC/Fmkvr60pffvRG/Dw9pZZuwZnhYaUrQdhlmQCulaefAnb7tZW3bb d2k77Hu0HaGfa2dDv4BdsBv2wF74Er6CfVAE++EAHIRi+BpK4BCUwmE4AkehDCrgGHwDleCB43AC vNrZiN9CHDBe/Rutqo+9gfldzfyuZn5XE7d+xK2fvr7sZD10w+fwJezXqhl7A2NvYOwNjL2BsTcw 9gbG3sDYGxh7A2NvYOwNjL2BsTcw9gbG3sDYGxh7A2NvYOwNjL2BsTcw9gbG3sDYGxh7A2NvYOwN jL2BsTcw9gbG3sDYGxh7AzpM1Y4R7SIi/FXzz3GkR5tEPzwq4Hklz8+jxkXUuIgaF6lbRt3Y4CyR a0VIcK0IIY9eR52LqHMRDwvwsAAPC/CwAA8L8LAADwvwsAAPC/CwAA8L8LAADwvwsAAPC/CwAA8L 8LAADwvwsAAPC/CwAA8L8LAADwvwsAAPC/CwAA8L8LAADwvwsAAPC8RAvMhHlyJ0KTIkizvQpojR Lyf7D5H9Z/EiHy/aB+d6++Bc30IM3ka3InQrQrcidCtCtyK8yserfLzKx6t8vMrHq3y8yserfLzK x6t8vMrHq3y8yserfLzKx6t8vMrHq3y8yserfLzKx6t8vMrHq3y8yserfLzKx6t8vMrHq3y8yser fLzKFxZ0uYIXy/Dia7wow4tljHovoz4lQvF3J/7uxNed+CV9as+TfPzZiT878Wcn/uzEn53kwBzt qmEu5HH+F44vy5/KcNdnyCOzFT4bWSfnao2cHTEsEibDC9Tim4thtWhleFX7yfCa9lPoRngX3oP3 4QPYBJvhQ9gCH8HH8G/YCgWwDT6BT2E7fAY7YCe4oVD7iXHN1U4antFqGN8pw0vaOcMr2iXxqCFL +8KQDfPI0vmwUCsx5MJz4II8cZthEccXtROGlVq54a+wCv4Gr7LGsZ6FxmpfhI6FcfAQjIcJMBF+ C3HwMEyC38EjMBmmwO9hKjwKj8Hj8AQ8CX+Ap2AaxLMTOSEBpkMiJMEMmAmMOZQxhzLm0OchD/4M jD30BVgMS2ApLIPl8BdYAS/CRvx4F96D9+ED2ASb4UPYAh/Bx/Bv2AoFsA0+gU9hO3wGO2AnuKFQ 24Pac4jeIu0wUTxmWM13SgN5cBH9/Xpu1AsrNU6jkB+FLhqelXkjHLSoosVJvUUmSrlRym2YzZvj XCI/j+N8WMAbmdT1WVou5N0pF54DF+RpGruQm13IjbVLhhWotlLzoqIXFb2o6CUXSsnXMtT0oKaH HcnNjuRmR3KzI7nZkdzsSG5UdqOyG5XdqOxGZTcqu1HZjcpuVHajshuV3ajsRmU3KrtR2Y3KblR2 o7Ibld2o7EZlNyq7UdmNym5UdqNyPSrXo3I9Ktejcj0q16NyPSrXo3IdKtehch0q16FyHSrXoXId Ktehch0q16FyHSrXoXIdKtehch0q17GrutlV3eyqbnZVN7uqm13Vza7qZld1kwUessBDFnjIAg9Z 4CELPGSBhyzwkAUessBDFnjIAg9Z4CELPGSBhyzwkAUessBDFnjIAg9Z4CELPGSBRySjYDUKVqPg JfTejopSuVKUK0c5H8r5UM6HclJ/G/p/iHpe1PMalrFWyJn7ovYWCp5EwZMoeBIFT6LgcRSsJU++ QMUyVCxDRS8qelHRi4peVPSiohcVq1GxGhWrUbEaFatRsRoVq1GxGhWrUbEaFatRsRoVq1GxGhWr UbEaFatRsRoVq1GxGhWrUbEaFatRsRoVq1HJh0o+VPKhkg+VfKjkQyUfKvlQyYdKPlTyoZIPlXyo 5EMlHyr5UMmLSl5U8qKSF5W8qORFJS8qeVGpDJXKUKkMlcpQqQyVylCpDJXKUKkMlcpQqQyVylCp DJXKUKkMlcpC5fvVdvgMdsBOcEMh71XRqORHJb8+G/NEG1S4hAqNqNCIAn4UkO/vjUS3keg2Et1G ottIdBuJrp/o+omun+j6ia6f6PqJrp/o+omun+j6ia6f6PqJrp/o+omun+j6ia6f6PqJrp/o+omu n+j6ia6f6PqJrp/oNBKdRqLTSHQaiU4j0WkkOo1Ep1GYmfXn2GPCDcvYW5bLEXNknxEz8a0W32qb 146FfAPNhefABXnUZP7ga530k0yrJdNqybRaMq2W7FLJLhX/6/C/Dv/r8L8O/+vwvw7/a/G/Fv9r 8b8W/2vxvxb/a/G/Fv9r8b8W/2vxvxb/a/G/Fv9r8b8W/2vxvxb/a/G/Fv9r8b8W/2vxvxb/a29i jVDJPpXsU8k+lexTyT6V7FPJPpXsU8k+lexTyT6V7FPJPpXsU8k+lfjWEd864ltHfOuIbx3xrSO+ dcS3juxTyT6V7FPJPpXsU8k+lexTyT6V7FPJPpXsU8k+lexTyT6V7FPJPpXsU8k+lexTyT6V7FPJ PjW0UP+2nad9p/88exBa+dDKx+yuZ3ZXE3sfsfcRYx8x9hFjHzH2EWMfMfYRYx8x9hFjHzH2EWMf MfYRYx8x9hFjHzH2EWPff/N25/FR1ufex+/MHZIQ7hHcl1atK9q6L61LNbW71W7HI7Xa1urpgj6c 9uHBurRSPVSOhdq61K0cqrZ6eo50gboXI4qALBoSw0AyMCQhQCDDZEIgDAECv+c9I55Xz3k9fz9/ fLzn3n7LdV2/6/r+QjKycZGNi2xcZOMiGxfZuMjGRTYummPRHIvmWDTHojkWzbFojkVzLJpj0RyL 5lg0x6I5Fs2xaI5FcyyaY9Eci+ZYNMeiORbNsWiOxWiM3LdDBO4VgXvL1a+ywn7h2v1i9VFP3RD2 8vBeHt7Lw3t5eC8P7+XhvTy8l3a7lZ6R+0X56P1RvlGUHybKD1Q331/Bk6NTUj+NjlL1htw9gxV3 /P9YoRXlV1Z6iyufynMcjGKfdvm0y2yHo380xpwx5tihxA6lsk40mxFWX9HqK5pV2pgP5P31xl3k /QHeH7DyilZe0corWnlFK69YP7cSFTnzyplXzrxy5pUzr5x55cwrZ14588qZV868cuaVM6+ceeXM K2deOfPKmVfOvHLmlTOvnHnlzCtnXjl+KfFLiV9K/FLilxK/lPilxC/lzFS0copWTtHKKVo5RSun OKrs08cqUTUgqgZE1YCoGhBVA6JqQFQNiKoBUTUgqgZE1YCoGhBVA6JqQFQNiKoBUTUgqgZE1YCo GhBVA6JqQFQNVOy7mxWL7DsUHZJ60T5lfngr9SZtvSDclloc/jO1Xa3cER5K7QotcRLycTrk4tFh S3wITsd5rn0x/Knyb/XjojHx16Jk/0/uCjz2jLb/IlLfpNwX0HELw87UIiyWbZeI4rep5+WUsp1k aqXjKmwWq73RQXptS5WwE7v1EtmN16IOR4ZSfHboic/BuTg/bIsvDsuTP4TB5I+hJfkrXvD5RceX wprkZTQ6n++4IBSThViEpa61hp3JCmSw0v2sa6ux1nkHurWRD6WkX/s7UAo9yU4MubbLeQildBqH hZ704TgCRzs/Bsf5fDxODsvT54a29IW4BNfiOnwD38X3cDPmhJb04lBMG1e6KexMr/DuGnSiN7RF n2fRbSxaYM2VrNnHmn2suXO/NTOsuXy/NZez5nJW7GPFPCuWLbiVBbey4FbW285621lvO8utZ7kC yy1nueUsV2C55SyXYbkMyxVYLsNy21huG8ttY7kCy/WxXB/L9bFchuUKLFdguT6W62O55ay2ntXW s9p2VtvOYutZajtLbWep7Sy0nYW2s9B6FtrKQltZaCsL5Vkoz0J5FsqzUJ6FtrLQchbaxkIFFupj oe0stJ2FtrNQPjoxNSv8IPViaBTJ81nm31lmH4v0pzpE9OZocqo3PCWqv50aDH8Q1Z8RW2/FcVgU 14RHRPiVInyVCD81HhNmxwfiEJ+PjX4YnxSuE/GnxmeEL8Rnhski/xxx93B8abgrvixcrwL92r54 vX1x+ff8nolvCm9UfkthtJGU/bXZaNbruZ9PNul5o9769VbUW1EvxfhYu+vTHc/D1dHF1tMl3p4l 0823LhZYR4tDs7mUzON4LbVqZalWVmplnVbatNJmrKO00qaVTHSAN5d4s8ebL3nrYG8163+tN9/w Ztabnd7MejPrzTHeXOnNdjvvZ/SzQI1YKC8vwhKR9zY1vRzWighbJ8LWaXWEN2PRs070rBM560TO OpGzTtSsEzUlUVMSNSURMyRihkTMkIhZJ1KGRMqQSFnHs+t4tpQu/95dSqsHaLXeDMoRP8vcXzGe v2GJiL3a/K6xVudp8++jstP5Bm2IEG0sCBPK68KuYBbLv2glLAjLXGlKvcsLGW128MDVoVlbzdGN eprhybusry5PP6/H+/R4n7f6WGEPK+zx9kpWKLHCey2sdFyF9jBHa6+IrpZUISyL65GETWy7iW03 xYfhcByBY1nshPBafCJOCpvjU1w7FaeHbrbfGF8c1cYNzi8LfZWftpR/u+Ta937aZZ12sXQ/S/db p12s3c/aJdYuWaddLHIfq5etMoNVZrDKDGu1i+X3sPwelt/D8iVrtcta7eKBPTywh+Xu44V+1rsv 6Y9qk+1hUzKIHT7vimrTVeG1dH3YlD4IB8Oc0sfiQzCX9EmOJ3turOMpzj8blqWvCHPSV+KL+L7z CZgT+nlnhvXbxdN70jnPr0UHurA+zIlGidq1IrY99XYlEs5lsY9V/rXyW0bzUpRKXsZ8rIxSatZ7 kbqJjwp8VPBGjfzWK7/1ym+9/yMCC+xQYIdyniqYe0Fu6pWbeuWlXnmpV17qlZd65aXe/RFZkGd6 5Zleeaa36gNVD4SZVQ/iIfwaD+MRPIrHwkwjmiaSHhFF74iiaaJoWuo1sTcP88XfQgprERaH2aJp e6rV9UzoEEV3p7Jy12qsQQ5r0RHuTXU6dmM9NmAjNmFzdJ2oeyGV93kLCuH+VJ9jEf1hUmorBnze hu3hJnmvRUVoVxHaZYFr5L9FqT3uDWNveC21zzGExrgKKcSoDpPiEY414WmRfX88yuckXCV7rBTh V8mV98qV98YHhV+K9qtE+zdE+zdE+zfU6gfjo8Jv4g+490EcG10TH+d4PE4IE6yCCVbBrfHJzsfi FO+fig/7fBpOD/8g594q5/6SV6fw6hRenWKlXC7/PhF/1PWP4YJwT3yh40W4ONwXf9zxElwabrea vhF/wufLPHN1eHT/b629YmXdL66OEldHydcvydfP1KwLM2tPwIk4CSdjbJhZ92SYOfIyfC3MTGaH ZckcvKSivYx5YZpVt12kTRNp00TatGSx+0uwHM1oQWt0VLICGaz0/BrXcljrvAOd3lvnfIPjxvDL ZBN6kQ8PJlvCb1TT+5KtzgewDdvDVVbpVSrsfaJ4iiieQpc8qMrel+wO9yR7MOy5EB60giekU+GX 6RjV4R6r+Sq65cH0AeE36TGuHYiDXDsYfGg1TLEaplgNU9JHev5ozx6DY937EI5z/XjwYfrE0CgD XKWK3ycDfEMGmJA+1bUP4yM4DafjDJyJs3A2zsF5OB8fxcfCpPQF+LjPl8oiDfiEz5/Cp/EZfDbc n/6c4+dxuftfcLwi3C3T3C3T3J3+kvMva+Mr+KrP/4Cr8I+4GuNc/xquwdedXxvaKY12SqM9/U3t fcu16/Ft3IAb8U+e/a7738P39T/etZtcm+DzIlltcZiWboqOSvN1mq/TfJ1+F9a1zDElnWXjNY45 NlqLDnQ673Jcp531xm09UzDt6bzzLSigL0yKTpJJ7pBJXpE5NlWU9GI1aEkY3q9qpsoA35UBXrO6 X7a629X3HVb2HCu72+pdZtWusVr/aLUut1oftFqbrNYmK/VBq/F6q+9Fq+wBq2yZVfaalfVvVlbG yllqxbxoxTxgxSzY/7cH0yq/gXmDHDfXyF5SLZtT9vJGuFyumy/XzTfKHTLyn2XkNhm5zWhfled6 VM2n1d5NFQ2z0udVaA+LzaJJbttpFln5a40ZbHlftZrFasp1o1mUqNeN1OtGOWiN3JGTO3JGuNcI y79FOl91bE7+I+RVyKdVyKdVyGYV8mnrtMc67VEhm63V+dZqj7U611qda63OVSGbk2XeexvvojW0 qRJtqkSbddqjWjarls0qRpuK0Wadzlctn7ZO51tXOWsgJ+Zz4nsnFbuRit0ohndSshvF7U4xu0aM Lhaji8XoYnG5878p3Buc34j3le73PX+zdyc4zglPi6+5KmazStQmVhaLlZ0VtfsvqkqLqtIiNt5h 8WGx8RpLt7P0sKrSwsrDrDwsRs5RDVpVg1Zx8nZFA5bc34ldqtBeiiri7+rQyspLWbmsLN8WM1kx kxEzJTFTEjMZ2T0ju2dk94z4OUP85GXtjKydEUdNsnSTLN0kSzeJpSaZOScjt8vCGZ4Zlj1bZM/y Lm2Yd4Z5p5132nmlXdZskTVbZM0WWbNF1mzhgXaZskWmbJEdW1h+WCZsl/0ysl9G9muX/ZpkvyaZ r13my8l8OVkuJ8tlZLWMrJaR1TKyWpOs1iSrNclqOdksI5tlZLMm2axJFsvIYu2yWIYnl8pIrTJS K48u5c2lslKbrNQm87TJMq2yTKuM0iqjtMoorbzawqstvNoim7TJHK282sKrLTJGK68u5dFhWaNF tmiRLVpkixbZokW2aJEtmmSKJpkiI1NkZIqMTNEkU2RkilZeb5EhWmWIVhmiVYZotY/fHB3IE2nW HozOtyKLYuF2q2+m1TfT6usWE5OtsBK//4HfX+H3V6ysAr9n+X0Wn8/i81lWUNGqKfLJZD6ZbMUU +WWyFVK0KmZaFTOtipl8MtmqKFoVRatiplUxU/SX2GwWW80S/SX2msVeWfbKWgUlNsuK/BIbvcJG r7DRK2yUFf0l0V9ip1fY6RU2miXai6J9pkgvmfMr5rgg/Fx0bzSDl51tl012hCfFrtppZoPONprZ ZjPbvP/nBU1yRt7MmsysyegGja7J6JqMbtDomoxq0IgGjWizEW02os1GM2g0g0az2Wg2G02TUQwa xWa7om6ZbUdFQXXoqaOcY9mwqLcWvQ3qrUVvLXrbobcWvbXobYfeWtiiyBZFve5gi6Ked+i5Q88d eu5gi6Led+h9h9479N6h9xa979B7R1QvT/7OzDNmvUrPg3rcJPc1ys5tsnNWDmysZOea/fvMTk/2 2kteaS95VnxNdE7Fcp3u5Nzp+q+z3eUWoxHOyrPrdtan/eXa74tSFFL536jPpcvbRVaBrXeHATl4 UF4blNeK8lpRXivKW4Ny1qAcVdRahyy+Q3XYbe3Hcgf7RCdro9Odspbdqq25nuhhzW2suc2Ta1ky x4o5Vszpo/x3Y7PN688supVFcyyaY9HyTwlyLLnVGOYaQ6cxdBpDJ6uWf3qwjVW3seo2Ft3KoltZ dBuLbjPGuayaM865xtnJultZd1vFFt3mmjLXVHS4ce40tgFjKxpbcX9MDZjFFuMbML4B4xkwngFj GTCGncaw0xjKub2o/6L+i/ot6reozwH9lfN2sWKFhaywhAWWyMvd8nK3/ttYfqWehuThbrMv/3bE ir/z7grjqza+6vLfM8hN3XJTNwss0ftCvS/U+0J5qVte6paXuuWlbnmpWx7qNvMlclC3mS+RS7qN ZqFc0i2XdMsl3XJJt72y+mYkfUay2Vy3GcGD+/+9v7xPLv/V4Qq1pN0euUOl73Zcr94UwgLWms1a z7PW8+Yw37poZ7En+H6VlnpY7QlWe8K8Fuz/LbVWXu2iCNtZ8gmWfIJnu1jzCWul3Vpp5+Eu81tg vbSbY5c5dpljFy93UXbtlF07FdfO4s+z+PMs/rx11M7rXbzexfrPs/7z5r6AB54w9wXm3cXrXTzx fPQB1s+yfnb/T0Z2VX4yEoUCD2SNuGDEBaMrsHaWtbNGWTDCAitnWTnLyllWzrJylpWzLJzVU4GF s6ybZd0s62ZZNyvGdsjHu0NHOYqiKme/FW/lnwecHzZGx9kr9dM1PXRNjyo6pIoOqaJD5bsqaFt8 LR98iw7J26n30yE7UApDKt8Q3d+v+rXR+v00SQ9t36/aDal2Q6rdEP3eT7/3q3RDKt0QzVL+uWQb 3dKj6gypOkPp8l+W1RrBq0bw6v6V9zutverpVz35alRlLH3RRXbAJTvgkh1wyQ64ZAdcsgMu2QGX 7IBLtEORdthMO/TSDv20Qz/t0Es7FGiHAu1QMNthuqGXbuilG3pVr81m2UUnFETZajuxkp1YyU6s ZCdWshMr2YmV7MRKdmIlO7ESS5S1QBct0EsL9LJIF0sMs0QXSwyr/70sMUwD9NIAvTRAL0sMs8Sw 2t+r9veq+b0s0aXmF9TdXnW3V93tVXN7K/MdYJMkrDeXHnMZMpchc+nZ//Pvvsozm6JDaed9vFbi tRKvlfZ7bAWPrfg7b5V4q/yT4zbeKfFOiXfKPyku8Uqp4pEVjmvQWf5dh0pkHMEnXXzSpf0B7Q9o f8CdLn3ktJ3Tdk7bA9oe0HaOz7q0P6D9Ae0PaH9A+wP82KWPslrt0s+Afgb0MxDVmE1/fEE0ItmN PdGIdDWOjEaU878q8y0zLP8N8wIRMTc6kj262KObHbr5dAOfbuDTDfzZzZ/dWutkm/V8uYFvuvmm my+6+aGbH7r5oZv9u9m/m/272X4D23ezfTfbd7N9d3S+XgZF0TY9DeppUE+DehrU06CeBvU0qKfS f7PKec4vqFh/o94HVb9Pqn5nmMVqs1jNWhuNaNCIBllt499ZbSPlWKIcS5RjKV2ubwfhYOj7v1nz SPePde1DeN+yJ/l8Ms0+1vF9y+Z8XosOsLJZDVrr/y8rH2M1DPJyBy93mE+n+XSaT6e59IvyQePs NM5O0T1onP3G2S/CB3m6w3j7RXl5jJ3G2GmMncbYL9IHRXp5jJ3G2Mn7HTzfYXydxtdpTJ2Vvxca G18fjY0ej74THo++i+9hUrgr+nH4YfQT3InJ+CnWu7cBG7EtPBXtCg9Eu7EHw9gbHqg6JTqs6lR8 GB/BaTgdZ+BMnIWzcQ7OxXk4Hx/Fx3ABLsRFuBgfxyW4FA34BC7DJ/EpfBqfwWfxOXwel+MLuAJX 4ov4Er6Mm6LDq94Ir1XNDy9XvYkFWIhFWBzmVS3BUizD22Fe9ZPhh9VP4Xdocr4czTDX6n0I4YER h4THRxyGI6LDRhyJo/ABfBBHIx9+OKLk/k7sDj+sORefwK3h8ZrbcDvuwF3hrpq7MdW930SH1awO 82qj6LDasx3Pwbnh5drzcAkudf458Fktn9XeFB6o/T1mY4vzAvpQxGB4qnYH+Ko2hMfrqsIDdeno sLoDMBpjcCAOwsE4BIficJhTnTnVmVOdOdWZU5051R2DY3FXmFd3N/7d5z85vuXY51gML4/kv5Fs PvLrYV70zegg6vRgHIJDcRgOx1icglPxYXwEV+BKfBFfwpfxFXwV/4CrQJlEX8d3wkyRO1PkzqxE 7i0q649wK27D7fhxeFY0PyuanxXNz4rmZ6unh+bqX+A+/BK/wv14AA/iIfwaD+MRPIonvfcUfhee 5fWZI9aF5hE92IRe5F3f6jiAkvs7sTs8W1MbmmvG4ECwQQ0b1ByPE3AmzsLZOAfnev5Sx084fsbR nGu+j/G4CTfj1jBT5MwUOTNFzsz/ipx/Cb+tmYKp4dm6F8u2iR4MLdFD+DUexiN4FH/Af+A/8Sxm YRnexjtogl1qZJca2aVGdqmRXWq0AhmsRDvWh+fkhOfkhOfkhGXRdgxiB0rYiV1htjwxW56YLU/M lidmV28OLdV2tNV5bEEBfSiiH1sxgG3YjkGU39uHEGZbb8/VXhFaar+CqzEO11T+PnpZ7fWO38Z3 PfM93BRm197q/C7cjSn4Ge4F+9SyT+0MPIEn8RR+h99778+Osx3nOr6FHNaiA53Yov0C+lCEuVtr y2rNvdbcrbnZ1txzdVFYZt3NlgurozGy/pioBrWoQ/l7fesxCgnSOACyYGQVifGJYnyiGJ8oxn8g xm8Q4zeI8RvE+A1ivPx/GRopzseL8/HifLw4Hy/Ox0c/i0ZH92Aq/hX34ueYhun4Be7D3/QzF+vD Yzz6GI8+xqP38ugUHp3Co1N4dAqPToloRV6dzKuTeXUyr07m1clVrFj1b5gJ1qxizSrWrGLNqt/j aTyDf4cIrBKBVSKwSgRWicCqP+JPYPWqv2A25uCveA7P4wV78LOi0SlVJHWeYwM+HyamLg93pK7A V6ODUzeFh1I3h+mp/4XyXxpcG74QXxduoQK+EF/veEtYFreox+9Gh8QrouPjlfTbqqg+Xh/2xBto vo3RqXGP46botDjvuCU6qPqWaEz1j3ArbsPtuAM/xk9wJybjp7gLT4bxcsV4uWJ8dWs0unoFMliJ VWhDO7JYjTXIYS3YUqRPFumT5ZmJIw4NLSL+Mfll/Igd0Ui5ZaLcMlFuGV8jlmrES414qfkgjsbp ONe98xwvhgoqn4yvucznW8NEuWOi3DFR7pgod/xA7viB3HGD3HFDzc+ikTX3YKrn+auGv2rKEX8K TsWH8RF8vLLaplhlj1llj1llk2vvjEbXToaYqhVTtTPxe9dnOf5JJZvt80s+b/F8AX0oYjDca9Xc a9VMsWqm1Iqv2l0QX1bPY1bPFKtncl0qGl33odBSdxyOxwk4ESfhZIyFcdYZZ51x1hln3Wk4HWfg TJyFs/Gstoyr7o9Y4HwhFoWWkZ8LLfVPhDvqn8KCML1+EZqi0fXL0YwWvAs+refTej6t59N6Pq3n 03o+refTej6t59N6Pq3n0/oOdKIL69CN9diAjejBJmxGL/LR6FHzo4NHvYkFWIhFeAuLsQRLsQxv 4x00YTlU2lEteBetWIEMVmIV2pHFaqxBDmvRgc7o4GRiNPqAL0cHH/AVWE+UYnMUx+sre4Lm6ESf alMny2RJ5bvGa1CLOpT//5j1GIWk8n3WiUyWqP76wyE4FIfhcIzFKTgVH8ZHcJEeL8YVIU8F5KmA PBWQpwLyVECeCshTAXkqIE8F5KmAvAw5SYacJENOisaHYnQTbsb/wgT8M36AH+J/YyLK3xA0Kdwh m06TTafJptNk02my6TSZdJxMOk4mHSeTjpNJx8mkiUyayKSJTJrIpIlMmsikiUyayKSJTJqouVk1 N6vmZtXcrJqbVXOzam5Wzc2quVk1N6vmZmXdtKybVnvzam9e7c2rvXm1N6/25tXevNqbV3vzam9e 7c2rvXm1Ny9TT5epp8vU06NNzjej/G8DeWxBAX0ooh9bMYBtnt8epsrqU2X1qbL6VFl9qow+UUaf KKNPlNEnyugTZfSMjJ6R0TMyekZGz8joGRk9I6NnZPSMjJ6R0TMyekZGz8joGRk9I6NnZPSMjJ6R 0TMyekZGz8joGRk9I6NnZPSMjJ6hyV+gyRtp8kaavJEmb6TJG2nyRpq8kSZvpMkbafLGqnei+qom LEdzVK8apFWDRDVIpy4Km1SEdOpTjp8PP1UVblQVblQVktR1IZ/6Dm4K96oOt6kOt6kOt6X+OeRV iPNViJtViPNViJvj/xPuj1+1550XpeP5YULcHLaqFgepFkepFnnVIo7b7DXX26NuUEk2qiLlb5TL u75F9r8lSlSLRLVIVItEtUhUi0S1SFSLRLVIVItEtUhUi4QazVOjeWo0T43mqdE8NZqnRvPUaJ4a zVOjeWo0T43mqdF89WOhWP04foMZ+DfMxG/xBJ4M41SgcSrQOHuXRnuXRnuXRtUoUY0S1ShRjRLV KFGNEtUoUY0S1ShRjRLVKFGNElotT6vlabU8rZan1fK0Wp5Wy9NqeVotT6vlabU8rZan1fLVO1DC TgxhF3ZjD4YhtlS4iSrcRBVukgqXUeGmU9RZijpLUecp6qyKN25EMRSp6ixVnVX5Jql8k0YMubYL u8M4FTChsLM1daFYMxL1GIUE8o/KmFDfWeo7S31nqe+sSpnUlP86/XifT8DJnh2L01070/lZOBvn 4Fx9nOf6Re5f7HhJdDCFnlVRx6moCZWepdKzVHqWSs9S6VkqPavSTlJpJ6m0k1TaSTU/9v5PcCcm 46e4K9yh+t6h+k5TfaepuuNU3Yyqm6n5z6i+Zh7EuL1goyqcqemO6lXijEqcUYkzKnHG/rDR/rDR /rDR/rBRZc7YIzbaIzbWftbzn3OUS2nlPK2cp5XztHJW9Z5KK+dp5bwqPl0Vn177fZ/H46YwkWbO 196G23EHfoyfQOyq8gk9naens/R0np7O09N5lT9R+RO6Ok9X52vFaq1Ypa/z1EBCY+dp7DyNnaex 89TBROogoQ7StHaeQphIIST0dp7eztPbeXo7T2/n6e085TCdcphOOUynHKbXir9a8Vcr/mrFX634 oyamUxPTqYmp1MRUKmIiFTGdiphKRUykIhIqIkNFZKiIDBWRoSIyVESGishQERkqIkNFZKiIDBWR oSIyVESGishQERkqIkNFZOpuj+rr7sBdodE+uJGqSKiKhKpI7Icb6/7s3l8wG3PwYshTGxlqI0Nt ZOpWutbnuSL6fd4a1VMgGXvmxpHXRfX1vwmb6mdgJp4IN1IlN9b/3ud5IV//OuZjQbiNSrmtfrHP agi1kqZW0tRKmlpJUytpaiVNraSplTS1kqZW0tRKmlpJUytpaiVNraSplTS1kqZW0tRKmlpJUytp aiVNraSplTS1kqZW0tRKmlpJUytpaiVNrSTUSkKtJNRKQq0k1EpCrSTUSkKtJNRKQq0k1EpCrSTU SkKtJNRKQq0k1EpCrSTUSkKtJNRKQq0k1EpCrSTUSkKtJNRKQq0k1EpCraSplYRaSaiVJDoy+lX4 9N99Y9P8qg/iW9G4qm9HV1fdEN1ZdWP0yap/ij5T9Z3o6tTno+tSN1W+v+3T8TXhk/Hc8Id4Xrgy 7rZHWO/6hlCMe8ID8eawJO6NPhDnQ2u8JZSi4/QyMvpjaIsWhja9TdDbBL3dqrdb9Xa53k7X2wV6 O11vZ+rt03o7UG8H6O1CvV2qtx/FjWFu/Brm7dsSvxFeUm/a4jfDwnhB+JVRTDWCoXhj6DGKC43i V0YRG8VvjWJBVBcvD8/ELcZmhx63hn+KV4S/xRlvrQprVCi2MsaXjPElT35dHWv29KOevjNu3bfP 07/z9OVq2oveuN0bM6Ljo19F51elo9qqA/BGuEt1PVo1/UTqi/ZaMkPqByrsrOjE1IJwWWpxuDLV EZ2f2hG+E19q/9QYJarmGWbxV70tsc+K41Z7qJXhBVVzhB72mdVKlfPO/ZUz3r/Xis2uJ+41s7zr W0Jf1alRdZgbjUANalGHkajHKCRI4wCMDo3RGFwUVkcX42fhregeTMW/4l78HNMwHb/AffgVO/4t rI3mhrX8uJofV1eNwYE4CAfjEByKw3A4jsCROAbH4kM4DsfjBJyIk3AyxmJyyFX9FHfhbvwLpuBn uAdT8a+4Fz/HA2Fd1YN4CL/Gw3gEj+KxsC51Vng5dR4a8NXwempa6E5ND90i9x8r36u5ofLdmnNY tCBeviJehuPSvs3xzvCpeCjUxbv27Yx371sT7wk18fC+TfHe0BDvcz2EI6pH7NtcXRM+VV0b6qrr 9u2sHrlvTXV9qKketW9TdRIaqtOuH+C5W8Lc6h/hVtyG23EHfoyf4E5Mxk9xF/4SVlfPxhz8Fc/h ebyAF/FKyFX/DXPxKhrxGubhdbyB+XgTC7AQreGt6hXIYCVWoQ3tyGI11iCHteGtGrFUI15qxEuN eKn5oOPROB3n4WJcElbXXOb4aMjVPIXfO5/taDw1xlOzyPlbWOrzMqz0eZWj1VbTjiy6sC6sq9ng 3g7swTD2Yh9CWF17ZMjVHoUP4IM4IayrPREn4WSMxZ3hrdrJEKu1YrV2JmbhT2Ft7UvhrboU/jnk 6iaG1XW3OD7s+Ijjk2Fd3bPuebbuj+hwrRPGVbcOAyE38rKwbuTXcH1YPfLbYXX9s6G7fg6ewwt4 CXPRFF6uX45mtOBdtGIFMliJVWhDO7JYjTXIYS060IkurEM31mMDNqIHm7AZvciHl0c9ELpHPYiH 8Gs8jEfwKB7D/PD6qDexAAuxCG9hMZZgKZbhbbyDJixHM1rwLlqxAhmsxCq0I4vVWIMc1qIDneH1 ZGLlb/5fP+ArsPaianl3jiyaj1fKe21hOLra/nGG/eMM+8cZ9o8z7B9n2F8ts79aZn+1zP5qmf3V Mtm1WPVWyNrnFOxzCvY5Bfucgn1Owd7lcXuXx+1V3rFXecde5Z3UM2GXrJuRbde9/7sT8ZH2JvPD DDvzY+T2Tpn2Idp/Bu0/g/afQfsXaP8C7V+gu5fR3cvo7mW09Qz6eQZ9O4OWnUF7zqAzy9/iV6An y9/el639aOV7ygo0ZIEmXEavLaPRyj/XLP88cxndU6B7CrROoe7VkKVlyt+2Vxh5bcjSK4/TK4/T J+/QJ+8kC8KuZCEWIR+2JkMIYWs6jaNxzP/4/Y33f29jcdhV+T2NlKz2J/VhWjQ6nhtdGL8afTN+ PTovfiM6wvxfit9UnRdEY+Pl0ZfY4kv2ayNUnsSebUycic5mlw4V6Dg1szu6RG0fqe58Sd0ZG2+O PqvdBft/1neanubraWV4tNLnNvduVp3K3xO4kiroDcujqqqbogaeby63G12stSvl2cu1/d6Vs2Xh na5+Uhbuk4W3Vb75cUvYpcX1eumNLqj8LOUIz55c+dnK2UZzit7PcNYcfczIj3RvhDlcbdzXhKb4 FnOeH+ZXX1L5fvRr1Nb54R1Py0l0Q7+znLMJ1MUb6vD8sDQaG1Ub5QjUoBZ1GIl6jEKCNA6IGuKr o0Ptg1+0B35RK5fY/zZrqU1LrfazDfazDfazDfazDfazDfazDfazDfazDfazDfazDfazDfazDfZk DfZeDfZeDfZaDfZaDfZWDfZRDfZQDfZNxlIZ69wwqKecWfTEr4veN0JWjy9SQFvM/ZboNL4+1N3B 8mzN/YDooKqW6MSqd6MzWeabFc12raeui66Lv1X5/sPr4glhkR380vjWsC5+NPpo/Bjm8sOr0ckq 5J+rL4zOri5/e3vsrZO8cZJ+zuXNW6Lj9NRXjqZKTyOspyytVKCTdlV8v6r8f3pzteisv6K+Crw1 WgZo9cywLDDsTrH8XFnp6GE5bzeLwJXygugIA97u12YfDx/snZI7i/Y/P1RuUa/NrrZo+V2zbnVt pd7fe2K48kQ5ymo8UfLE8HsxXv7GVe22hT2VUbV44qLKOFvpqfLdTFglng6h8vbo4b026va33hO3 lf9FojLOFmfvhi3e27N/1uvd6Y6OtxL6xWi9FXOUFTPGOmiMqvy3v/Jt50OifF9c/h2n2NN1nkw5 y5p9+Wy9sfa4s0kbvTRn3t0t5e9ysE72ubtL6/vea9262ay1XhFf1tnl98d4Yuf+J8rfpVrnblfl m/uNLLxj9Yx97648XL67Wb+pSmu9oaeyhsvtlb8nfIjd94ZO2qaPlin/G/je0O9T2ZclT+3BMKvv Dc3VI8IQ3TNUPSoMeqK58myrT2Wb7Xa2R497WTWEff+XueuAr6LY+mdmdmf23uwmBBJIgCQQCBAg gErvKk0QARWkF8WC/amoz6fi8+mz1/cEC+oTFQUFbICiIoiAdJDeCRB6UTqCzPefuTehJBAIlm/3 t3PnnjlT7uyZ/5wzu3OuEyIO3mNIXQLd6BhafACpB3F3DuE+HkaJkZJNjsXIcRSlH4OWdRQt2eF4 qCFSkylhMUo4int6EL17CP11GLmOaI2cW2xdkhhy7UauY8ilkWOLrbM46swW5r8ZDkH3P4we/1Uv sq08ilF8TG+1uV2djRI4SliJEg44Ib3ItjxGL4Vmt9WWJFHCIdS3RhyznIdQxxonsP19CPLxq/0d y5GyCflNm5dTrJNAIScR7UpCntJUzIFe45Qlz0lBPBVpaUhLR1pFfM9AWiWkVYbcOU5J1FAGqeXw mYF74TsJ+JaodzmlTFmooQxqMmWlgp4GenlTDugZoKMckpY7icK2HMORjrgpqzjaxZGa45QEpRSu JEpD+4qDMwdlpqF9HO3jyJXjlEN6eVzpoFcETwZolRCvbP57EKWsQlsjvzAZbS1NbrQUk3sV2h/5 hRWQVhFpkdwcvzcBVyJkriTanIRyS+O3lNF7kTOM+vG7kJ6G9HJIT0d6RdAykF4J6ZXx+/Ar9DaU cAgl7HNK4UqCpCWDuzTuZ1ncxxT85lTwpIGnHNLL40oHTwXwQKt0KoGnMkanuU++7dckSkA7TI8d QjsS0I4YtMO3fZuO7xVtDx5CGxLQhhhzV0hE726knyOtN70nonfW9nm01Rzz2YFjWzEK+kBqykIi 28Pm2A2JbAmbYxskqD+kMg1S2Qg2x1aMhj6QqLKQyvawOXZDKlvC5tgG6eoPyUyDZDZyEo79il7I Qi9UQy9kOUnHDqEXstAL5n5eiJ6ojJ7IdFLBlwZ6OfCVx2c6+Crgs6I29/RC9EZl9EYmdADYkJgX mkGLiIX2UALIaOzVDKBHfWDGNMwDcRTAJpwH234ebPt5sO0bwbZvBdv+Gdj2rWDbt4Jt3wqz0VDR BVh+DWz5rnqozTUBuSYg1wTkyiwk11Sby/jMXmqpud8+yfvGWTxm9Cwiaoj5sypdjLMWtaOr6ALq QteA2o1uoMZ0Ez1LbWHFj6Q7aAJNxLdJOF+imbSEXqZlON+mDZRD/6PNjNG7LGCJNJGVYWVoOktl WfQju5y1p2WsA+tAK1h31pNWsj6sD61h/dDmtexWdjttYAPZ07SJPctepaPsdZwhNhRnmL2FM4aN YCOZzyaxeSyW1+IXslRem9dj5XlD3pBl8Ka8GavEL+UtWBXeirdiVXkb3o5V4+15e1aTd+JXsVq8 C+/KLuI9eA9Wl/fhfVg93p9fz+rzG/mNrCEfwG9njfhd/F52Mb+fP8Fa8af4c6wLf4EPZj34q/w1 dh1/j3/Kruef86nsbj6dL2H/5sv4BjaYb+Hb2TC+m//MhnPo0OxDfpgfYaO5FsQ+FVwI9rlQIoaN FYEI2AQRJ+LY16K4KM6+ESVFafatKC/S2feioshgP4jKIpNNE9VFFpshaoqabJa4QFzIZovaoi6b KxqKRmyBaCKas4XiEtGCLRXtRQe2QlwturLVoru4jq0Xt4rb2A5xl7iP7RIPigfZPvGweJjtF4PF EHZAjBaj2SHxhfiCHRbjxXj2q/hKTGFHxFyxlGP+E9s5ZhuheWnHdWJ5RSfBqcJrOE2cJvxS5x7n Cd7Cedp5h3d1Rjtj+Z3Ol85Efr8zx5nHBzk/OTn8UWeLo/lgN9aN5aPdYm4xPsZNcEvyT9zV7gb+ ubvJ3cYnuDvdnfw792f3Zz7J3ePu5ZPd/e6vfIp71D3KZ7haMj5TCin4HOlKl8+VSsbxeTJeJvFl srQszdfJsjKNZ8t0WYXnyGqyCd8hm8lmXMuLZSdBspvsI+LljfJZkSSfly+KpvI/8hVxsXxNviZa yDfkUNFSviOHi9ZypBwp2ssxcoy4Qo6VY0UH+aX8UnSUX8tvRSc5SU4SV8upcproLGfI2eIauVAu FD3kYrlC9JSr5XpxrdwoN4qb5Ba5VQyQe+R+cYs8okjcoWJUIAaqZFVN3K8uUA3FM6qxaipeUS1V G/GqaqfaiaHqCnWleFN1Vt3EMNVT9RQfqD6qj/hQ9VP9xAh1vbpZjFS3qzvEJ+oedY/4TN2r/iU+ V4+rp8Rk9Yx6VkxTL6mXxY/qFTVYzFSvq3fFbPW+el8sUR+oD8RSNUKNFMvUGDVGrFDj1DSxUs1V i8QOtUpli71qu/pNHFbacx3fU17YKeHd6t3qlPJu9+50krx7vIFOGe8+7z4nxXvAe8BJ9QZ5jzhp 3svey05577/eK06695r3hlPRe9t726nsjfBGOVW8sd54J8ub5E1yanlTvCnOBd5070fnQm+ON8+p 7S3wfnLqeYu9xU4Db5m3zGnorfKynUbeTm+Xc7H3i/eLc6m3z9vntAjVDzVwWoYahRo5rUNNQ02d NqG2obbOZaH2ofZO21CHUAenXahzqItzeahbqIdzRahPqJ/TKdQ/1N+5Ovxa+H9O5/Dw8HCnV3hk eKTTOzw6PMbpE/40/KnTL/x5+Avn2vC48Dinf/ib8DfO9eFJ4UnODeHvw1OdG8NzwnucW2JkTKzz UkyZmHTn9ZiKMdWcYTHNYvo6I2MGxCxxZscsi9nsNow56jtuWz/Rr+9e5bf3e7v3+X/zn3Gf8t/y R7vv+Z/649yx/pf+BPdr/xt/ojvRn+RPcif73/uz3O/9uf4id7a/xF/iLvSX+SvcRf4qf6O71N/k b3LX+dv83W62v8ff4272D/iH3C3+bwG524NQEOvuDooHSe7+ICVIdY8G5YLy7rGgQpAhKagcVJYi yAzqSidoEDSVxYPmwSUyKWgRtJJlgjZBG5katA0ul2nBFcFVMj3oEvSUVYLeQW9ZM+gbXCtrBf2D m+VFwa3BrbJhMDWYKhsF04NZsnEwN1goLw6WBstl62BlsEq2DdYGa+XlQXaQLdsHG4LN8opga7BT XhXbJvZq2TW2a2wveX1sv9jr5C1xTeKay9uJhyaZf0SO2RNPVIXS6Hc59Ga9mcrhIujQBaUf0/fq EfpjxB7EdY1upyfq9xHbZlPX6xUI10V59+fLvc1cegfOXXnEuPxtwHV/oS1th+uTE76v0WsIOvAZ 8xzAtVzvRdTHvN0Ndj3pnLzU3XmxLQXkna7X6e36W70Mn3P1rMLaV+jhocwpkdpwfppb5/FW5NW8 E9dqvRa9dkh3oRC50CvK56UeK6wivVvv03vRP9l5JAWq/aY/0h+h18wdXFlgXlN3DmrfrVfjq0th 9FkTxDKjLV9ADXCRuQrMP0ibdzVI98bVVNfUA/UdJ/X0prxYvvohazMhj1v0bD0Lbdil55KMpmw9 hXNOoX2wxrbexL6I9sl2PR7WfCR1VT7+AzgP6SN6Hjhbmn9ph/7mRGTT9kjOccmJyP5JuXP0Bm32 WRHsV/N9rv3HdMheHseuU/Ocpt0n9Yr+4JRfdHZH5F4dsOFGvZE8XGeu9Qiuw9EvNaneGXmH6A8R 7tA/nnV7Tsy9SX+GcF+kn05KKRB/TuI4qL8ysoXYJCOnJ6V1LTT3L7g+s4i0/NTchR/6ZSNNemSB o8Y7i/y79QR7N3aca825+Y/j7DnnfS76Oa0Ieb+x4dICe0wWrT3Ro2KhdZt5wcwvRzC+tp9j6f4Z U6vgutLWEUHF7MgZTS1obs3EmYYz86QWDrfhvMh5htwXFJh7rw0xA+uj+TElj+uY3gpM3IoRl9sf dgbQ79lwOTBzDfDmLA49mEoBl2pTR8S/tJQ9mJ23nL7uk3K/iFkkjlpTX8Tt2EfebfqXgubOU3Ka WXgocoeoJN2dR52ivyb39PNqvpHi4nffBPoom2rmiCO5OK6P5st95IT4sxi7yZROTyN+qaV8By3m Rz3mtHXnFEw/hnr0ON1Gt9T9deso79v5cj8a/Tx5juTUi/4Fu5/oeXoB8+pL9DGkdDSNhzR+TRPp QrsiUJem0BIg8HLKoXZ2LaAr68v60t2wwK+ke4ztTfcaq5vu4zfz2+jvsJ+X0UN8Jd9AD8OK3kJP 8G18Oz1pbGl6mh/gB+lZfoQfoeeNLU0vGFuaXjK2NP1HpIk0elX0FL3oNdFX9KM3nHHOOHoTVqim t9ySbkmaLb+T39EcOV3+SHNljtxE81VYheknY3fRQmN30TLVQ/Wk1cbuorWwu66ldcbuovXG7qIt xu6ibcbuou3G7qLDxu6iY7C7BjOCxTWUSfWWepeFjN3F4ozdxYoZu4vFq9FqDCth7C6WaOwuVgl2 128sCxZXmHXwYr1irIdXwktkvb0krzTr56V4aay/V96rwG70KnlV2M1eVa86u82r6V3A7vQe8x5n d8PK+ogNhDU1l90Pa2oBe8DYS+wfxoZhDxobhj0UMzlmCfunsUzYEL+L35t9bWwJ9oOxDdhUYxuw hcY2YMuNbcBWGduArTW2AVtnbAO2wdgGbKuxDdjPxjZgvxjbgO0ztgE7YvR+dtTo/ew3o/dzHtsh thNXsT1ie/FwXNO45tys7S61EsOsxHBIzGDoJEPodcjzG/QeKO/jVDScRmIO+gjyJK08ScjTNxht 30KqwlaqwpCqGaDPpEUUQ4vJ+GpagjOAnK2iWFpN66mcXX8qT5vpF4zzPTjTaS8dpAp0CGdFOky/ UQYdg0TGW4lMsRIprET6ViJ9SOStVIzfBrn0rVwWh1yuppJ8DV9DJfhank2l+Hq+npL4BshrWSuv Zay8Jll5TbTyWtrKawmuuaYSAoo7JUBqOUIclAjZVYh7wqNkEYIcJ1g5LgM57kmVRC9Ic2VIc1/E +0GmK1uZToFMrybmrHFyiDubnM0knS3OLopxdjv7KNXZ7xygOOegc5TSnN8g/RlW+stb6U+x0p9i pT/FSn8KpP8KSlAdVAeKUR1VR3JUJ4wHF+OhMyhdVBdQrlHXkFJdVVfyVDeMkwoYJz2QtydGS8iO lhizSkGBuhZjJhZj5gYqr25UN1GcGqAGUIa6GaMo3o6ieDuKGEbRvch1n/oHeB5UD4HysHqYuBqk HkEt/1T/RMmPYqTFYKT9G7meUE+A/qR6EvxPYewFduwxs+YBnv+o/6LeV9RgpL6uXgflDfUGcg1V Q8HzlnoHlGFqGFryrnoXFIxPCpvxiXJGqBHINVKNBH20Go1yxqgx4BynxoEyXn2FvBPUBPTD1+o7 9Mwk9QPaOVVNRZ9MU9PQqrlqPlq7QC1CmavUWvCvU9koeb3KQWmb1DYqp7arXeiT3Wov6tqn9lO6 OqAgk+qQOkwV1a/qV9R4RP2GNmulqbxnlLEKHvMYZXjc48QgJg6FPddzKfCkJynWU56iEh4OCnk4 Kd4Le2GKMWhCKQZNEAJNEAJNEAJNEAJNEAJNEAJNEAJNEAJNUMscbw7Cud5c4gZTyDGYQsxgCvnA lO8RTglPpWIGWUgAWcqS76f4qRT4aX59KmZQBnSgDCUDZTKpRFA1qEoJQbWgGgVB9aA6lQyygiyk 1ghqUFJQM6hJZYNawUWI1w5qg79OUAc8dYO64GkQNEC8YdCISgeNg8bgaRI0BU/zoDlSLw4uoRgg V0vQWwWtQAd+IWwbtEXYLricigPFrqBSQYegIyUGnYJO4LwyuAo1dgm6gdI96ImSgW6opW/QF2G/ 4Frw9A+uR5tvCG5AOTcGNyE+IBgA/puDmxEH9oEO7ANlQ7ARteQEm5Brc7AZJW8NtqHM7cFOSjRo SMKgIRUzaEjFgFijomj4Ik6Rh4avIv4GcFBYHHSBgh8jPpq+RPgVTbBoOAnx74GBgqYCBwVwcDFw cwnwVdi1d2VxUFgcTLA4mGhxMGRxsKTFwVIWB5MsDiZbHIxhcSyOfNaddUd4KwPqsTvYXQjvYfcg fJo9DRzsxDsRtyjpASX7IzQoGbYo6VmUDCwmluA7+A6gp8HBeIuDxflv/DeKtQgYJxzhUDywz0M8 LMJUTHQX3YF6PQQwxWJfWYt9qaK36A16H9EHdIODZS0OpoprxXVUOg8HN5MAAu4jBew7SiGLeskW 9RLNyipGaXvVnoRFNwVc64LQIJqwiOZaRCuluqvuoBhEE6q3ggQD1/qC02BZosWykMWyZGDZLRjh t6nbEN6ubgfnnepOhHepuxAaXFMW10JRXBukBoHyCHDNtYim1GPqMYtrj4Pf4JoCrj2NeATRnlPP I25wTVlcExbXQmqIGoJcr6rXQDEYpyzGxUQx7k31JugG6ZRFumSLcUJ9CHQTUXT7SH2E+McK86sa pUaB0+CdsHiXfALeCYt3Cng3FXGDcUpNV7MRn6tWIjQYp4BxOYgbdEuw6JZo0S1k0a2kRbdSFt2S LLolW3SLUcfUMeQyGJdoMa6UxbjkKMYpYJmwWBbj+Z6PuEWl8MTwd+SFJ4cnI5wSnkLh8FRgUDg8 PTwdlFnhWeRZPOIxy2LWErfIUiK4CJgSF9QL6lO8xZE4iyAlgCBNEG8aNKNYYEcLUAx2FAsuCy4D pV3QHjhl8CLe4kUJIEVXxA1SFA96Bb3AYzCiRHBdcB3o1wMjigMjbkQJBiPiLUbEWYwoZjEiHhix AWXmBDnItTXYCv5tQId4iw6ceNViZo2mxmf1r6TmdPXptPn/z4deB7tzU2SdSK/NvyoStZ4KXKsr pORsvVLvtvbiFLv+sMJSc+xKwoLouqwpe4O1IrP1Ir3IckTr0gvPWHp0HU8POPeW/X6Hbqc/t5/5 Vp4L5F4HK/2Hs7N2z1jOxpPj6NONuauCeg56dRl6c7VeoJfmcR2/fwl5tAV6l54HDTwJOaKWYmS1 8U85wnntOHH92aduEVq+9bVNkdWKk2i79EL81t25q6q/7xFZ7dLLcmXtxPpPbDNakW8F/XRj6Xdq 2TmPRv2efsd+HkVrZ9hriB6Bz5nR9Ohah12d3K/nF7ZeW2AdG/RGSGJ0DSsSM+sjeavW/0X69sgK tV4P7hnRfj2pLn3wLGo6mLtu9vseet/xtugD6Kv9+le7Mn3S6s45rwT+BUeuRGJkbz0zZy7fH9iW fM86zsj9mR6rPzFr9FRSv63HWto6Pdt+rs7jOuPccJqSlwItduvFkTuI2DI7dlfY+Wik5dhlU+aa lWqcm6OrjNG67AgqQ5dGv32nZ+pvwZFMbfH5vaV9EJ3BHsHV49xbeMbWR2boT/K+99PD9O36Sfsk 7R951EaggUf/ciqSYzzmu8eYgafoWWaW/p3besCOHyt5BmHyj3O96/j6+Jkl9Nyk5w847NNi/fKp z4f1fQU9zdBrgBkbiqgvLTW57JwdRL5bcpAb6oct9TCJyJO1vHymrliqdUppu1DeLluGi891uVQb mmeJS869hSeVn3dfTiwp+vQxJzqK5kafSZ4keRb/d5/6NNE8oz+/Fp3rcerzvvxr+FH60wVSi3CH z/bQT5wDc6rN8ZR+yH6ap8xfoC+/AI5OMJ/REnPn98gz2Q2nf/JwhlaN0mMwZ4+OfpuhP4qO7hm4 Zlsd46CR/Wg7NunZ0XEfqeuUty7092jhZIvzWUChz6LUH07i0Qati9DSxXTik+8IcmZbubPlRWTN tnuO5Z2fm4vME6n5Fl1vst8m6en6b/pHfb9+V78OrIwibSRHNH4APT2wCK28Rw/Ub+o7EZultyD2 N8SegxX0ph6PnhmmbwGKvw3aIttbX+j/RSQ2WleZyJyTV9oWvQR4bsZibcxc0TEZtQmMDvOrjZ3z c2fbWztPROnce2zjxrqL2j62lrXmaVzkiVy0rqzjd+LPOk58Q8W0Dj2zt5BZxkjBvj+6Xflq1Xmx A1anXYrPDWfMMTl3DBexxjd1dz1ID7HxOZCXYXqijW+KjGWjG+nHcH1a9DpsKW30P88r/wa9E5ed IyB/BtXyrKmItoI5bSWus9Juz1DPoiLnXBB9ep5t301bE3l7xWKMmfHWRbn+dNk/9dA36+v11Nw3 j/Q/oLfMNGsmVvsdqw8h7Tn9kM7SmXqkboJ7//cCS3mt0Hoi73ikn3d73zjp22fnW95pavnveebP AU4vicyrGLUr8qVvAnWbXnx8BeavOfQ8jJINkVZAG1tewLy4HBKQXfRx8PscaMMzdML7QZjvvvkr 25P/gF31fGR1xH57AGNncwQ78/SH9bADn9Mv6cPQhFYW/FZK4f18uvcaf9/D4j2kAuP/vGy/vHeO /oBDrz+xnvObnfWF59uaQspfG9GL0J/nNSOd/9pwoTVswsxa6BtTf/VxZi3oHI5873qfZf351prP Is8uk+t4zrMdWUWp688+znfNsyjPFWBLbI5qUm5uGXkr/f7pe9fWlUx3mnfOz7nOoqx7bz3+9CWv /sj7sr8VWhen1ude419ylCxKptwZ8pzyTDa5js//9r3lnbCMClnzLUpdf8wBe3Pf6d7gPIHrPOy4 3+2IKSS9JPU4/qTurzjMfIoRtvLM+xfsc6Y/2X4/2x0Vp8k9IfqZHb2mFsCUad/YTiianmXfCc/O zRmJ2Sv3jfNIjY2ITnkr/KS6ctci83IPL6A15s3yC8x757m/6pzaOVRPwDk8+s3G7DOMCdFfEWnB BfnaWYS68vIWQcuGxW/eWshb7bb6836Sha1bR+v6gzXQAo8T9yBERjEvJIeiJuZlr3M9ivS8Y719 3pGn6dlRsL3wcRWtK+UU6nzcn/l6JpWiTD0tulI6NbqCBAnSHc+9hWdsxXQbjs373lXfDxvxFbM7 QN+eR71Uv3CaAtwCytx5NvNGUQ6rO0Us1z16Kcb+fISrTphjd4D+M5l1u9vs98+BuL30bPyq6fhN s/X1Ub7XTyp1lb6yCG3ppq/Ub+mrot9sTN9sYx/r4foeuzo1IXJ/9XicX0TvoqmrJNW0Tzwf0Lda mnmf4S1Y4m/pT3DXc8wzCUs/ad1FH9FDi9DOIUCmKbm/GLERCM3OM/M2U44eoz/E3ZpsE+3+q1zb PlpX7XOv8c8+Ct/Jed41bIuMV9yBw4Vzn8WRDHxKpjKmtyGhuPAtFeN8Ns6ZuFbpOhhzPSlOZ5zU jvbHIqgR3cWqv9HzLc6ZHZbmuX7UTjw+nvP9km9t+AAwtYyN1dXdUdcVGC8ldIOTOAfh6qE7Y+zY dwCAS2v0Cj1KvwdZ3aZ3Ry2FalTZ4nN1yzP53LtCfwdNOVcCzbsrk3GuOa4H6e72ozt1oQZU39ZV 7dS6dLwmnaIV0GCKfkx/jWuQ/pf9nJD77DB6xFr+e4vQzoH6Xv189Pm5j9jdOJ8D/Xmb+qmGZaHH 4Q4ct9WDotb1Ox08X7ywOVFBjxLgnVqIL5buUV8sj9Jl1sNKf5bKqtFt1rfKP6xvlYdYL9aLHmYD 2AAaZL2qPMIeYk/Tv9izbAi9ZLyq0JvGqwoZnypv0dvGqwr9j01m82gYr8UvoE95bV6XPjdeVWgc b8ab0XjjVYW+5JfxdjSB38Xvpm/5/fzv9B1/kf+HJvP3+Hs0lX/AR9M0Po6Pp7n8K/4Vzeff8Im0 gP/Ap9IiPoPPoCV8Dp9LS/l8voCW84V8Ia3kS/gSWmV8otBqUUwUpzXGGwplG28otElUFBVpi/GG QluNBxTaIRqJRrRLNBFNabdoLprTL6KFaEF7RHfRg/aK3qIP7bfviR80fkrosPFTwgLjp4RlOOOd iSzL+ClhdYxvElbf+CZhDdwEN5E1dJPcFNbYeChhlxgPJewy46GEXWE8lLAOxkMJ62g8lLArjYcS 1tXV0mXdjFcS1td4JWEDjFcS9jfjlYTdZbySsHuNVxL2kPFKwl40XknYS8YrCRtmvJKwEcYrCZtn vJKwn4xXErbYeCVhS4xXErZMjpQfszXGKwnLNl5J2HrjlYRtMF5J2EbjlYRtNl5J2BbjlYRtM15J 2C7jlYTtNl5J2H7jlYQdMV5J2FHjlYQdM15JODdeSbhnvJLwGOOVhKcaryS8ivFKwquZN8p5TS/w Al7Li/eK8wu8Ul4pfpFXxivLa3vlvHK8rlfRy+D1vEwvkzfwsrwavKHxGsIbG68hvInxGsKbG68h /BLjNYRfaryG8BbeE94TvJXxHcJbG98hvI3xHcLbGt8hvL33sTeKX2F8h/CO3gRvAr/KeBDhVxsP Iryz8SDCu3jzvHm8q/eT9xPv5i32lvDuxoMI72k8iPBexoMIv854EOHXG98h/AbjO4TfZHyH8AHG dwi/2fgO4bcY3yH8VuM7hN9mfIfwO4zvEH6X8R3CBxrfIfxe4zuEP2x8gfBBxhcIf9/4AuGjjS8Q Ps74AuETY16PGcHXmXfP+c/GFwg/5Lf3OwtmvICIsP+OP1pkGC8g4iLjBUQ0MF5ARGPjBUQ0M15A RHPjBUS0NV5ARCfjBURcabyAiM7GC4jo7W/xt4g+xheI6Ov/4v8ibvD3+4fEjcYXiLjF+AIRdxhf IGJgUDooLR4Mygap4iHjEUQ8YjyCiEeNRxDxuPHkIf5tPHmIJ4wnD/Gs8eQhXjaePMQrxpOHGBLb JvYK8WrslbFXi7dju8Z2F8OM9w7xflyTuCbiw7hWca3FCOJADwdYXhdoW4wYxeMUVBxas0NJmNlc KksZoFfCqTBDVYNuUx2IFgJ2NYIN0Rjzbww1tV4iDbr5Ft0CoFsX5LoGZxwwrhfK7k3XUT3qD7yr D7y7C/XcjbMB3UP3Uwn6O84EeoAepkQaBDQsCTSMpVJ2P0sSKwZkrAxkrAxKFVaFMlkmqwp6NWBl psXKqhYrq1qsrGaxsprFyurAyicoiz3JnkTep4CbScDNF6gGe5G9QjXZYGBoVYuhVS2GVrUYmgkM HYH4SCBpJpB0KjVj09g0uohNZ7OoNpsNbK1jsZUDW2sjrAOElRZhYy3CcouwsRZhi1uEbWgRtopF 2FoWYZOBsCOoLB/JR1Jp/hEfRal8NDA3zWJumsXcFGDuNwi/BfKWschb3iJvaSDvHIRzgb8pwN/5 CBcAhctYFC5jUbicReF0i8IhoHASVRTJIpkyRGkgciOLyBkWkSsAkSsjrAJcTre4XMnicgXgchOE TYHO6Rad0y06V7A7fZrYnT5N7e6eJnZ3T1OL1I2B1IOorvMI8JoBr1+kwHnJGUwXOEOcVyneec15 iy503nbeoUSD41QKOD6eqhmvU2TRnGobNKewQXOECW4C1XcT3USqajCdqgHT15Bw17prKcVd566j wM12s8lx17sbyAXWbwJls7sZlC3uFlLuVncree42dxuVMHMAxZg5ADx73D0U5+5191IxzAT7ibkH 3IOo65B7mOLdX91fKdHMDahLu5pKSuNgoI5kklFYcsmpmvFnhbgjHcRd6VJdzB+KAulJn+JlIDGy ZJyMI4YZJZ48WVwWpxhZQiaAJ1EmkpAlZUmUXEqWQslJMgk8mHUoDrNOCvKmyjTkTZcVwF9RZlAx WUlWRslVZBXkrSarIawuq6OELJkF/hqyBvhrygvBf5G8iBJlbVkb9DqyDjmyrqxLvqwn66P8BrIB 8jaUDVFaI9kIPI1lY+RtIpvgF2GGQ10Xy4tBv0S2AGdL2RIltJJtyZXtZAdwdpQdSclOshPa3E32 wO/qKfug/Bvlzaj9FnkrarlN3oly/iYHUj15r/w71ZcPyIdR4yD5CDWQ/5SPUgn5L/kYJcjH5eNo 7b/lk/gtT8mnUc4z8hmU8Kx8FiU8L59H+S/IF5D6ooREmVmWkswsS5mYZd+gLDlUDqXqmGvfAX2Y HEal5LvyPaoq35fvU205XA5HD4+UIxF+JD/G/cJMjFyYiRFiJgb/1/JrlPCN/BYUzMfgxHwM+gw5 E5RZcjbVMLMy6IvlYtCXyOWgr5ArUP5quRp1rZFrUfs6uY4qy2yZTTXlerke/Ji5wb9FbkEJW+VW 8O+R+8C5X+4H5xGpqZQyDygyzVxO1TGXl6UslaJSKUmlqXSqoSqoylRTVVHVqCrm+AuptrpI1aZm qo6qSxepeqoeKPVVQ6qDub8xeJqoJkhtqpqC3lK1RJmtVCuktlatQWmj2qBks9eMGc2AqhnNACE0 A4TQDBBCM0AIzQAhNAOE0AwQQjMg60+MrD8xhNAMqLLRDBCHZkC1jWYATmgGoEAzQAjNgGoYzYBq QjP4GDyjvFFUB/rBWAq8cd548EBLQC5oCaBDSwDndG86wh+9H0GBroB6oSuAc7G3mLK8Jd4S8ENj oOrQGFaBstpbjdQ1XjbiO72dqGWXt4uaGR2CsqBD1KdSoQahBpRkNAnKNJoE4tAkEEKTQAhNAvTO oc6Idwl1oRrQJ7pR7VD3UHeqHuoR6kF1oFv0QWl9Q32pcqhfqB/i0DMoC3rGaxQbfj38OsnwG+E3 EB8aHor4m+E3EX8r/D8qbrQQUOaEtxEPbw/vIWl0EeJGF6FYo4tQcegirUFpE9OXGhqNhGpFdsMZ jYS40UgQQiNB+I7/DpX2h/nDKMV/13+X4vz3/PeorP++/z6V84f7wynN/8D/gIT/of8R4h/7H4N/ lD8KPKP90eD51P8U8c/8z6m8/4X/BXjG+uPA86X/JVK/8idQGWg534I+0Z8IOnQdhN/73yOc4v9A yf5Ufxql+tP9H8E5w58Bzpn+LNQ418d85P/kL0LJ0IdQyzJ/GcLl/grwrPJXo81r/DUoZ62/DvFs Pxv86/31iG/wN6DMjf5GpEJzogpGc6IQNKdtlOFv97dTI3+HvxtxaFGg7/f3IzzgH6RK/iH/EOi/ +ceooq9hOmZArwpTxSAm8Ck9wAFKbBBLjaBpJYJSMkiiSkbfohD0rbIIU4JU8EDrQmqFoCLCjCCD sozuhXKge1EZ6F4/UnIwI5hJacGsAL8XethclDMvwK8Ofgp+orLBwmAhKEuDZShtebAcNUI/AwX6 GVUy+hkVN/oZcaOfIYR+RtzoZ1Tc6GfQtjjPsvrZpVY/41Yzk1E9LKKBGX3Lt/qW2SvVDaHRtFpY TauV1bSKWU2rjdW0EqymlWg1rZJW0yp1wh5m1+5hVnYPs2v3MLt2D3PI7mF27R5m1+5hjrF7mF27 h9m1e5hdu4c5sHuYXbuHOeLLwbV7mFvaPcyt7R7meLuH+TK7h7mt3cPczu5hvtzuYU5inMVQMvS/ AGExlgytqzQrDa3L6H91of91oPqsI7uaOrDODCPT6nwN2A3sBqrDBrKBCO9lD1BD9iB7EPGHoPk1 gub3FOLPsGfAb/S/OtD/hlATaH5DqSl0vi8QjmVjoeeNY98h1eh8V1mdr7nV+S62Ot8l0PlqkbA6 nzhB2xPQ9i612t5l0PbaWZ3P7LJ27C7rOLvLOs7usi5hd1nHWY2wvdUI6/Gn+NPU2HgjpY5WLyxt tcBMPoaPocr8S2iB5a3+V8Hqfxl8Fp8FTdFofmn8J/4T6Iuh7aXZndtl+HK+GjrlWr4WodnFXdV6 tqjCN/IcUDbzzQiNf4uydnd3Ot/JdyFu9nhX5L/wPYibnd6V+BF+9P9YOwOoNvJ63/9nkgyBJpTt dlmWZVmWRWQRK9vlIVJkKdtlEVlEFmuttQQaQgiZmZBMQhJCMgkhhNrbw9a+2ltr5WFFrN3K5fRy u4i9iBV7EWut2MuryEWsWDmcioi8Wnns+/1/Ybtd9em+c96Z8/3kz39m/pnM/PP/f385Mz+gTJ/3 fordYN8iSfjUd4qCUbBQps9+pylUCogP8AnwFHwCPFWxRbEFaraC48xCx5mNjnMnOs4KxZOKJKin vjNL8Sz4zg8q0sF3ZqHv3KHIVGRCGRbg84oXyPOKXMWHoZynyCMfUHxEkQ9l6ko/pCgAV5qleFHx IrRPXWkW+tFPoh+tQj/6SfSjVehEXwIPeoJowH2eof9zE3xnvLJX+QZ5At1nrnII3OdHwH1eIbuU 31dOkhfRg+5+6Ll0FT6XrsXn0h/B59LL0ZWWoCstxGfUX0FvmodOlEMPyqEH1aD75NB9xqvuqu6C 11xW/R5qqON8DB1nCTrOOHSc8eg4H1dtqDbAMVBP+RJ6Sg49ZRx6ypfQU7JcHHhKDt0kh27ycXSN L6Ff5NApxqFTfBzd4UvoCzn0hfHoC18CL/hhWEtdYBy6wJc2/V8hVwhbFnFFsCV1gS+h/+PQ7XHo 8Dh0dXvQ1ZWgq4tDV1eKrm47urrH0NXFo6t7HN3b49wJ7gTZxX2R+yJ4IOre8rivcF8h+VwP1wP1 1Le9gL6tkOvn+kkxOrYc7jw4tnzuDQ6uGvq2XdwAd5G8CO7tEtS8yQ2TT6Bv28Vd5i7DXtS95XDf 5b4L9WPcGOz7PQ7mKvRzuejndnE/4q5BCz/m4HvN/YT7CWw/xU3BNtTb5aK324Xebjc3w81AC9Th FaLDy0GHtwsd3kfR4RWjw3uB+w33G1j7e+730A71di9wa9x9qKEOLxcdXl4UG8WST0RFR0EMHbUt KgFI3d4ucHupUKY+76Po8wqjsqKywcNRt7cb3d5r6PaK0OEVosN7DR3e7qgXo14kT0QVRxUDqc8r Rp+3O6osqgzapNkTtJg9QYXZE7SYPUGL2RNUmD0hGrMnlGH2BBVmT1BFfS7qc/DuNIeCCnMoaDGH wiuYQ+ERzKFQjjkUEjCHQgLmUFBhDgUV5lBQYQ4FLeZQeOShHApazKEQyQqjxRwKCZhDQYU5FLSY Q0H1UA4FFeZQ0GIOBRXmUHgEcygkYA4FFeZQ0GIOhYSHciioMIeCFnMolGMOBRXmUFA9lENBhTkU tmAOBS3mUFBhDoXyh3IoqDCHghZzKKgwh4IWcyioMIeCCnMoaDGHggpzKLyMORRewRwKj2AOhY9h DoUyzKHwccyhUI45FBIwh4IKcyi8gjkUyjCHQvlDORRUmEMhAXMoqMCpP0bywKM/DUxRP08K0Yu/ qObVPNkFjlwg+epmdTPJVVvVNvC+klqCeofaQZ5Aj56jdqpdBH/Dg7JH7QVSv75b7Vf7oZ2QOgQ8 ov4n4FH169DaMfUXYJvj6uPkBfV/Bx+/S/1l9Zehnvr4j6q/pv4aHEm/uh+2j2Sdoc5+Nzj7AXgX 6uw16n9TX4IW3lS/CXt9W/1tUqT+jvo7UPM99ffh+MfV49ACdfZPYJaaHPT3+eop9RSQuvxidPn5 6p+rf07y0eXnoL/fpf61+tdQ81v1b+HdqdffjV7/NfXv1MuwF3X8u9R/UP8Btvmjeo3ko/t/MTo/ Oh/cPHX/edG7o3eTj0aXRJeQT0S/Ev0KKcRIID+6IroCtqGRQF50ZXQllF+DSCA/+tPRn4btaTyw G+OBIowHiqMPRB8gT0R/LvogbFkDUUFudF10HdQYog3kRYgKTm1GAjQGOAMxQA9GAr0xvVDzjZhv kIKYgZgB4GDMIPBizEXgUMwQcDhmGEizZmzFrBlbMWvGo5g141HMmrEVs2ZsxYhCgTHDq1tqtxjJ h7d0b/kiKdhybssoqcScGkqMIpQQOTSDO6exwXMYG7xf802MDb6lGQCfTeOBpzESeA4igX+F8pDm 38CLj2hGoIbGAM9ovqv5LtR8T/N9cOfU9z+Lvv859P3vB99/HWp+Au7//ej+36f5meZnsD31/c9p fq6ZgbW/AN//PvD9/wWtUd//LPr+p9HxP6P5tebXJEvzG81vgL/V/BZIff9O9P0Vmt+B7/+QZlmz AvV/0KySHej+P4Tu/3l0/zs1f9L8CWrua/5MPqBZ16zDlm9p3iI7wVQy4ONZrYJkaZVaJfmANgZi gx0YFezEqKBCG6d9BNZu026HehobPK99QvsEbEmjgp3ap7UpUP+MNhXqn9U+C62lQYSQhBHCDm26 Np18COOEbG2GNgPWPqf9IKyleUwyMUNShjZbuxNqaE6TFG2ONhfKNLNJGmY2ScHMJpmY2SQFM5s8 hRmSkrQvaV8C0iwnmdqXtS9DmeY6SdW+oi2FMs148hRmS0rCvCdPYrakJMx+kobZTzIxW1KGtlr7 KcyZtA/qP6P9DNTQfCjpmA/lKe1BrQ7W0qwomZgVJQ2zoqRjVpRUrVFrhLU0N0oa5kZJwdwoqdoB 7QBEQTQuehbioh+QRIiLoD9of6T9EUQ+1yAWehZjoecxCqqAKOjnUJ7RzsIZo7HQ89o57RyUaY6V NMyx8iTmWMnEHCvpmGMlDXOsKAnz5EqSDFZUozhM/osQnRXkBHlBQdBhUPeDV8aqg9cToNOgXlA/ 6ALoImgYNAoaB02CboCmQbOg26BF0DJojbABGUV06yg2EAIdIaSWBcHQXRsL2g5KBKWA0kFZkeOq 3Rk5htq8/8trIbR1DF73RIT7lIEqQXtBB0B1keOtNW6+CiAJ5AbJkbY2X9nASdAZ+OwGkBnKZx/U RXQONLBZNwQa2awf29TVTV0DTYFugeZAC5vbLuH2pDYUOQ56nmrpuTiG5zyy7QroHtSdBNFtz4LO gQZAQ5vvvbH5WUdAY6Crm5/tWuR42pWbioG6KdAt+DxWkHNzf9r2HGgBtARaAdH3hHbrlCDYry4O FA9KAqVuvma8s33dDlDO5mvM5n45D63PBxWBSkDloCrQvnde6fWrOwjSg0wgy9/4+92vbDs9JgfI E/lsdQFQePN6/z8I+/xDqju6qeOgU6AeUB/oPGhws56+XgJdBl0BTTy0/3UU207P103QTER/9T7z VMpHakwi8Z2pVVuGgLGWEeQYcLvlKjDRcg2YYpkCpltuAbMsc74zdC9/Zu1Oy4I/u8Yicr6zNQ5R 4ztXm2dZQq48KBda7vnO0bX+3BqPuM03ULvHsuEbiJQ3GRATfEO1Zc1KYGVzzINyGZb3NscBDzTH A+uak4DG5lTfEN3LXwBMhnJYTPON1ArNGUCpeQfQ3ZzjG6H1/uKao2Kmb6xWbs4HhpqL/KU1x8Vs 39XaI80lwGPN5cgq4MnmfcAzzQeBZ5v1wHPNJuBAs8V3le7lr6gdanbIpppTYq7vWu1Is8d3raZH LPBNUfqrgcW+W7VjzQHg1eaw7xat8e+vvUbrI2tr+sRS31zNebHCt1A71XwUeAs513zct0Dr/Tqk oWZQrPYt1S40nwIuNfcAV7B8r7kPuNF83rdUp2weBMY0X3rAuObLfnNdfPMVv7Xmkrjft1KX1Dzh W8HW7m3WpDZfB2ZQ0hq/s+ayqPNt1O1ovgnMaZ5BQpnW+701V0SDrKzLb56XlbTsD9Zcab4D5QnR LMfUFTXfBZY0rwLLsVzVfB+4z0qAB60cUG/VAE3WbVhOkGPovv7DNddFqxxXc1N0yvF1Fmsy0IH0 WJP93XUBa5ocXzMjeuWkmnkxCMcQtmYCj1qzkbR83JoLR3JHPCyn1p2yFjxgj7VYTq25K3bLGU2O 1lxkAbIY6GktBQZaK4Dh1mrg0db9wOOtOjmD7tU523Sq1dB5u2ZVPCHvqLkvnpZzmnpazcC+ViuS ls+3OuUcurZzUUfEXt9U02CrF3hJ7O1cjlDHif1yftPl1iDyMPAKlq9geaK1G3i99QTwZutp4Exr r5xP9+pcA16Aska8KBc1zbf2A++0XgDebYUaWt+5rtsmDsslTautlPdbR8OsLkEclcvNpHWc0lyA 5Ukg13oDqGmdBm5rnQUmtN4GJrcuyuV0r7DanNa6HI7VJesMcpU5s3VNrtKliePyPsr2OF2mOCkf NGe3rgNzPax8kNZ0jkfqN5kt3pD1ulxxWjaZCzzqByz2xMomWh/ejkzUFYizssVc6tmOTHxQrvCk AKs96cD9niygzrMTaPDkAc2ewnCK2erZ48/WFYu3ZYfZ6SkLp2Nrns0ar6cSGKSkNZ3DulJxUQ6Y D3v2Ig+8Xab14Sxdhbgsh83dnjo5TMvhneYTHmM4T1ctrslHzafhzAM9woNyr0cC9nvcwAseGXjR EwIOe44ARz3H5KN033Chbr+4Lh/X6SysfMo87jn5F5z0nJFP6QwWtdyjM1ti5T7zDc9Z5LkH5WnP gNyns1q2y+fNs56hB7ztGZHP65yWRHmwrs9aCjxvrQAOYvmStRp42bofeMWqA05YDcDrVrM8SPfy n6i7abX6T+u8lhT5ki5oSZcv181YncB55B3kXatXvkzX+nt1hy1Z8hXdYWuQkpbrVq2H5Rldt2Wn PFF339qNPAGcx/I8LR8i1tNAztoL1Fj7gdusF+QJupe/X3fCkidf1522FMo3DyVYLwKTrcPANOso MNM6Lt/U9Vr2yDOHspG51kn/BV2/pUyeP1RgvYGcBhZbZ+V5Xb/1NpRLrYvACusysNq6RustZf6L h/Zb16FGZ2P9w7oLlkr5ziGDTQ0022LlO7qLlr1wFYD+0UNW23b/uG7YcgC2d9oSgV5bCqXlALTj xXqkbtRSJ9/VjVuMcGxBW7o8UzdIeeiwLQvODNT7Jw9123b6b2B5WjdpEeTVQydsechCeRW2Bx46 bdsD7LWVAfttlcALtr3Ai7YDwGFbnX/20KjN6L8N7UjyfV2vTQCOW9zAGxYZjmfcJgEnKWmNf1E3 bQn5yaEbNjdw+h1i/fKhWZvsXzt02xbyr+tmLUf83KFFG5CWA6xu1nYMyrctx/BznUSeAS5jec12 FrhuOyfP6FnbAFBtGwLG2kaA221j8NlhX/i8i5aTfo1u2XLGv02faLsKTEGmI7Ns1/zbdGuWs/4E 3brlnD9Zv9NaAcyzTQELkXtst/zJtaxlwJ+mL7PNASuRe20LwAO2pYCaepJArL7OtgL+BLxBYLve aLvnG9ILtg2gJCkjM3ggkc6DgRS9W4rxLellKc63RGeiQLo+JMXTWUlKAsJcE8jSH5FSZaX+mJQh K+n3JbBTf1LaAd8d6LeBPP0ZKUee0J+V8oHnpCJ5Xj9gKQsU0usb2KMfkkrkVd2kVA6E8xAo049I VfScSPuAkU86Jh0EXpX0/mQ644T3mBc9Y3IGHfnDZeZlz1U537zmuQZc90xtjs+VdJQL7+VZzy3Z oivwzAHpOHOAV3sW6JjjWQLCSBKu42M9K3Ifv91zT+7TX7Ou+y/qpyRToFJ/S7IE9urnJEfggH5B 8gTq9EtSwHdOvyKFfQP6e9LRgBG2OQ7bbEinAkK9UuoJSPUxUl/AXR8nnQ/I9fHSIPir69IlOa4+ SbocCNWnSlcCR2pmpAk5qT5Duh44VnNeuhk4WTMozfiW6ndI8/7T9TnSncCZ+nzpbuBsxG/UF0mr gXP1JdJ9+Sh1FIGB+nI7CQzVV9k5ehXsmrdn9vp99m3Ag/YEoB6ObaTeZE8OjNVb7GmBq/UOe2bg Wr3Hnh2Yqg/YcwO36sP2gsBc/VHqaeuP24t9V+tPUe9U30NdSn2fvRS8K/rG+vP2CuCgvRpcHO0b C/WX7PuBl+26wFL9FbshsFI/YTcH7tWu4JbX7VbfWP1NuzOwUT9DnVv9vN0L73LHHgTepR61ftV+ GHjf3u27aiD2E0DOftq3ZNDYe4Hb7P2+FUOC/QIw2X5RjjGk2YeBmfbRgNuQbR/3jRly7ZPtSkOB /UZghJ6B9hhDsX060rfb4wyl9llop8J+W1Yaqu2L7fGG/fbl9qSIwzTo7GvtqQaDfb09g34v2ncY zA4WXDp49fYcZL7B6lBHHHh7EbIEWY6swnfZhzxocDpifUMGr2O7b8QQdCT6xqijbtcbDjtSNssm pIV+v9odhm48k+CH2z3IAD2q9rDhhCO9PYzlo8jjhtOOLN+codexE/wwuOL2U4Z+R17EA7f3IPuQ 5+syrNlwri44CoEXKalrbR9EXjIMO/ZEnGr7ZcOoo8y3YRh3VAKhHmomHXsjrrX9CnICeZ1+69tv ImciNNxwHAAvCo60fd4w7agD5wm+tP2OYdZhlJMMtx0CcNEhgec85XCDt6TX5S5y1bDskNvv1606 QvDtpiPzjGHNcQRmz1UHjJ+GdcfJINH1Os7QGcFxNsg1sI5z/vEGtWMgqGmIdQwFtzVsd4wEExoS HWPB5M2xHUfvhhTH1WBaQ7rjGozG646pYGZDFh0JG3Y6bgWzG/Icc8HchkIbGyxo2ONYCBZHPEBD mWNJnm+opLNMw146bjccoHN0Q51jJVjaYHTcC1bA7AyzbYPg2IBZD0atYPWh/hZlsLpBsnYH9x8q bomR7zS4W+KgfRnn5WBLPLQTakmC9o+0pAKPtWTAbH6hZQe0fLIlB97xTEs+8GxLEbzvuRYYAxsG WsqhZqilCjjSAqNfwxidKRquthwM6hqutejhnICXCGw0TLWYAiP00wUNDbdaLJGRNmhumGtxQDsL LR5/Mp2Rg9aGJYsx6GxYsRwJehvutQSCwYaNlnDwsFHZcjTYTc9b8AS2c1p/reV4sNcY03Iq2E/H 8OAFYxy6HfA8wYvI4bddjSUrOIocR04ib+AxTEdojG/pka8bk1r65JvGVOpGqDMJzhozWs5HyjDf 0Zrb1G8EFw8ZrOvBReOOlsGIrwguI9fwU6wbc1oudbC03KHGmkVjfstl+a6xqOUKOArwFR2xxpKW iYiLCM4ix5E34Fpcl+8by1tuAqtaZiIzfnCdsmO7cV/LfGSW70g0Hmy54ydGfctdINRDjall1c/R s9eRgkxHZtF5qmMnJXxqpNHSch/mbpjBO/KMDieBmRrm8Y5Co8fJ+ROMAacGGHZug1mszJngT6Nz dMceZBmeh3HjUWeynzMed6b5txlPOTP9ycYeZ7Y8aOxz5nZU8omejbCRT2lThnr49LYYYFZbnHyQ 39kWL+fweW1Jvim+sC01LMA2GbB2T9uOsMSXteXA2sq2fKjZ21YUdvMH2kogGkprK5f38XVtVWFZ l9C2Ty7njW0HwyFeaNOHj/BSmyl8TFfQZpEtvLvN0XGLl9s84ZN8qC0QPhOJDnQVbWE5zB9pOxo+ yx8D/3+OP9l2PDzAn2k7BXGcua3nbR/On23rCw/x59rOQ3mgbTAUww+1XQqP8CNtl8Nj/FjblfBV /mrbRPgaf63teniKn2q7Gb4ViUDNpG0GYq5IpIMxBX+rbT48F4ny+DmoKeIX2u5AzEXn+gXz/ra7 wNm21fASv9R2P7zCr3hJeKxpnm6p2+bl5BL+nlcTvheJs5oc3m0P4lmMMfkNGldCJHiaRnzehAfv rvMmAzFWEpTeNIiYIjHORYgxjwoxbX3tGU2r3ky5RIjzZoc3hHhvLsRZcAa6lEKStyDiVbpihFRv sWwRMrylcp+ww1vRFSfkeKu74iPxoJDv3d+VJBR5dV0Yj3dlCCVeA8TUEFl3RZgjlHvNvikaQXfl I4so/dVYLsF3KY9QqPJa5XxhH8RcRcJBr1MuofFvV5Wg93o3y/uQB6lf6tJvnkmIXrtMlIHt9Kg6 tgsmb7DLQstdDqRHsHgPy3rB4e2G6BVi2K6A4PGeiESsXWHkUeRxs9d7Gs5YwNsLDFPSGLN9lbLr lHDU2x+JK7t6hOPeC3JAOOW9CIR6qOnxDkdizK4+5HnkIHVxXZeQl5FXhD7vKESOED92TQjnveMQ J0IU2XVdGPROyj3CJe8N4GXvNJzzK97Z8BBel5vIGegVt9s9woR3UQ4L173L8inhpncNtpzxrssZ xvPOgo69GDvgfIRjV4o8Yxx0FnccMF5ylnbU6Q47KwIbxsvOahrfOfd3GI1XKKGs6xCME05DhwQ0 P+B1p7XDbbzpdHbIxhnY62YkpjPOO70dIeMdZ7DjiPGu83DHMeOqs7vjpPEyHT8p/dPG+84TQQ2N zjrOIM8e2u88Lc83Emdvx7lGztnfcU437LzgX2zUOC92DDRucw53DCFHcJwc24ytgB1XGxOcox3X InFWY7JzvGOqMc052XGrMdN5o2OuMds53bHQmOucBWY7b3cs4Zi5grzXWOBc7NgALoeUjcXOtVBM Y6lzPRQTmVMaK1xsKG6T1S51KL5xvys2lNSoc21vz2g0wHyU1mh2Jco5jVZXSii10elKD2U0el1Z oR26ZddO/7bGoCvPr2k87CqUA3ScDJ6mDOXUsjAbQtm1J3g64twMBldZKL+x21UZKtIFXXtDJY0n XAdC5Y2nXXUde43XXcYOd2OvS+gINfa7pFBV4wWXO7Sv8aJLDh1sHHaF5IONo87qkP5drY27joRM jZOuYyFL4w3XyZCjcdp1JuRpnHWdDQUab7vOhcKNi66B0NHGZddQ6HjjmmskdKpx3TUW6jGxrqtA tetaSL/JWNeUPGja7roV6jMluuY6pkwproXQeVO6ayk0aMpyrYQumXa67oUum/JcG6ErpkK3MjRB r2/oummPbj1001TmjgnNNA67Ycw3VbrjQ/ORa2fa604K3TEdcKcG3KY6d0borsno3gEU3DmhVZPk zg/dN7ndRcFs3aQbPIZJdkOcZQq5qzqJ6Yh7XydnOuY+CDzpXOvUmM649e33TWfdJt+U6Zzb0rnN NOB2dCaYhtweOd804g50JpvG3OHONNNV99HOTNM1S6g9wzTlPt5xzHTLfaoz2zTn7oEtF9x9nbmb 77LkPt9ZYFpxDwZGTPfclzqLdYcbx+Urpg335c5S3aj7SmdFk9I90VndFOO+3rm/Kc59s1PXFG9K 7NTppt0znYamJPd8p7mWdd/xpzWluu92Wpsy3KudzqYd7vud3qacVtIZbMpv5YKapqJWrvNwJOpv KmnVdHY3lbdu6zxB3UvnaepSOnvpryid/ZFvHP6CUU0dhX/xL74dUuS3gsgvA50XmqpaEzov0vm9 c5jG4J2jtDd2jkd+HaLjg3+6aZ+zGtrH32qaDrYm+/uNE61p/v7NX2/o7yqLTXpLeudkY3drZueN SNTfZGrN7pxussB3mSUseZxZZn5PCPNHZo2wzH3mz0TJvMUyhGNVLEei2S2shmxh49hHiJZ9jI0n W9lE9knyCJvKPkseZTPY58hj7JfZL5PHFaWKj5EEVaXqkyRR5VG1kSTVD1U/JMmx+lg9eTrWEPsF khJ7IraXVMR+LfaH5LOx/7lVRQJbY7fuJP+yNWdrAbkJR1NFlPj0ZCzZSqLJI6SabCF7SR35BNGT z5MD5J/IURIk3eSnJER+Rn5JJsivmBjyn4yG0ZK3mK3MYwzDJDIZjJrexcg8zuxnGpgkppEJMZlM mDnOlDInmS8zn2L+lfkx81nFG4o3GIdSUtqZFqWsDDAuZVj5ecajfF35OiMrv6j8Z8av/Iryq0xQ eUE5wHQph5RvMkeU/678d6Zb+X3lD5jX8fm448obyp8yX1TOKueYf1YuKH/LnFb+Tvk7pkf5R+X/ Yv4HvaeNOat6XPU483XVLzg1089t5XYwU9zz3PPMKvcCl8f8kdvN7WH+TJ8AYN7iXuUqWCVXyX2a 5bjPcAY2lmviBDaJs3AeNoXzcWH2g9wXuJPsh7lTXB/7Ue4b3ABbRu+1Z6u4S9zP2Ne4aW6abeZu cfOslVvgFthWbpFbZD3c77lVto3eNcX6uf/NbbAhetcUG45io6LZrqgtUQns61FPRaWwX4lKjdrB fjXq+agidiCqPKqFHY3yRn2ZXYrqiepRaKJ6o76u0EYNRb2peJT+vyfF41FjUd9TJEV9P2pSkUzv 3VGkR81F/UqRE/XrqN8r8qJW1aziZbVZfU9RHf2R6AbFL7fu3rpbSZ+JMpMwUEOS6dPBxSwoFpQI KiTpwuweb0nVnnHh9p4LwqKwLKx9bF5YF9k9i1VF4k4xTyx8OU/cI5aJleJe8YBY92r/q6Oi+uU5 Mfblqy8viNvFRDFFTBezXh19eQz6lhJ6+jL29D8ShnmLeYuw0K/j8FnSp/DuUMJ+k/0mYdg32Ddg 3QD7L0TBfof9DlHh3aEc+2P2x0SNzwJFsz9lp0gM3heqwTtCtewv2V+SWLwXdCv7O/Z3b/9fHwWj YB78NzOVgiPxCo1CQxIU8Yp48oQiQZFAEvHuzScVGYoM8hQ+I5SsKFAUkBR8OugZRZFiN0nFpynS 8M6N98Hxa5hteOYoiVBEPEKRUCKABxP2CQcFvWASLIJDAOckBISwcFQ4Djol9Ah98JdJOC8MCpeE y8IVYUK4LtwUZoR54Y5wV1gV7otEWBU54a6oESZEjbhNTBCTxTQxU8wWc8UCsVgsfdcyLlaI1eJ+ UfdgMYhm0So6H1q8YlA8LHZD7YmHlknxBtAsnhZ7xX54fXu5IF4Uh4F0GRWnYa9SeI9Z8ba4KC7D XmvQ4rp4wsKKZovaEgufn4kehGtI72CAXgSjBj0nCbAoSBIsSpJO3k9UJAuWKPIhWOj93fkwvhTA EkMKYdlC9pCX8Qm7j8PYE3m27jNkPz5bdxDa08PyKDHCsp3YiEQeIy7iJo8THyxPkHZYEmFUep08 Sb4Iy1PkS7Akk6+RPvI0+SYsz5ALsKSSN2F5lnwbljTyHVjeR75HrsDxTcCSgf+l7zkyTf4nySS/ gCWL/AqWD5LfwLKDrJA/wLHfI38iz5MNWF5gWCaK5DAxMALm4z3du2AEjCMFeE93IZPMPENeZJ5l niUv4ZN9e2BMrCQv43+wKmE+x+jIK0wdU0c+jvd3l+OTfa8yZsZMKhiREcknGDvjIJVMGxMgVTCC hsg+GEO7yGeYzzNHyGeZbqabfA6f7zsI4+klUsMMM8PkEDPKfJfomXHmB8TA/AfzH8TI/JCZJI3Y f5tgFBCIWQ0Xjoh4D51F3aJ2kma8b86mltUykdRBdZDY8TkXB94l16LuU3+duNTfUH+DtMK1XSBr 2PdzaaYVPhmUBsoEZYNyN1WwqWJQKfk0n8Zn8tl8Ll/AF/OlfAVfze/ndUADb+atwgrv5L18kD/M d/Mn+NN8L9/PX+Av8sP8KD/OT/I3+Gl+lr/NL/LL/Bq/LrCCWoiFZbuQKKQI6UKWsFPIEwqFPUKZ UCnsFQ4IdYJRuCcIgiS4BVkICUeEY8JJ4YxwVjgnbAgDwpAwIozBclW4JkwJt4Q5YUFYEpZEpRgj 0ucRWJVZZYOp8KuxZ6HHstA//3/171dh2Yq9PA57+SPYyx/FXr4de/lj2MvjsZcnYC9PxF7+JPby JOzlydjLn8ZenoK9PBV7+bPYy9Owl78Pe3k69vL3Yy9/jkzCkol9/QPY17Owr+/Avv4h7OvZ2Nef x77+Avb1/wZ9nSW52L8/jP37I8xTTDL0e9qzC7BnfxR7diE+s/Ai9uYi7M27sTcXY29+CXpzG3wH fIwPvgP0yYVXsDeXYm8uY77AfAG+D7RPl+MzC69ib67A3lzJTEI/rmKuMdfIa+ovqb9EqtU96h7y KfW31N+iz+TGyXGH4Tpp4NxvIYxtihBzP+gC6CJoeLNuFDQOmgTdoHXKR8znbOeF0r8v3KbCXmYe sA2ah2yXhOp3i9aZR2yXhf0gnb2SyjxmuyIY/r7oNuartgnzNdt1wfyO6N/mKdtNwQpy2veab9lm BO/fF24TtB8wz9nmhcO2efOC7Q5qyXZX6AadkG5j+bS9Tui1G80rtlXzPdt9of8d4d8X7IJ5QyLC xX+gYbskjNrdvFLiUDGSho+TtgnjEdEy/WzC5Duif/PxUoJwQ0qgr6gkKVmY/sei2/GpUhqfIWUK s+8Wv0PKfrvdh8XnSLnC7XfE50sF70XWKVccXyQV8yVS6d9UuVRBZb3liqfiq6Tq96R90n7+oKT7 K+klA5V1zqHkTZL5vci64EriLZIV5ZCcKI/kpbIuuVLpa/NtZwp/U5rmA1KQD0uH/1LWFVcGf1Tq /key3nPtwDaOSydQp6TTfI/U+y71Sf1/pfPShXdpULr4nnVJGuYvS6N/pSvSOD8hTf6Vrks33iX6 ud+DhEW7zM9Is/y8dPtvCtYJy/aQsGY/gtvdkRbfk+5Ky/yqtPZXou2tS7Miaz/G35fW34tEtf2k QOzsA3F29dvC9bGg/8Pe10BFdV5rn5k5Z8CfjIYSogQpIYQY/IkhlhpD1RqCiHBmoEStsUpQzpz5 AWYGmRmsNcYaS6216jXUEmO8XEsJJcZQQ9CqMca/Uq/V1KCx1utHrKHGEGuoMX4G797POYMjkpV0 3e9b667V5l37OZt99tnn/dl7v/s9uEh0xUbwsRWbyxIqGkoHVljQ315UllyxFX2Iqoj+MiobWdFc llqxM/z50iEVsbdQfEXCbcTPjqvYW5pUkVw2oeIQrhkVR/rqzxdRaUrFyNIxFam3UVrFuNL0igm3 0eSKjHAqy644Hsrtt+RiPVeGclyZreJUKAeVTa84G55HevwkfF31NemZo9kV53vmtqjiYnifkEu6 KadQ7JeLWg4o76/HMMVV+eAFq3nfYH8vjyGKqxwb8ufyRLrSe/h+mVpxuay04mrZgorusoV+kfeX siX+/iznsZUt9w8uW+mP4fxattYfx3mybL0/sWyjfzjvAWWb/aM5t2PM5O9lDf6xofxcttU/vqzZ P4nHXbbTn8lzUbbXn8O5k22CDvnzy474Z5Yd988pO+WfX3bW7yw77/eUXfT7sUfyHsR7As/hZdon 9f2s7CrtP6F57vbHeET/IrbB9zz9/Us9g/1V2HtCe23YGvXYZNL3lNBewH3ivdET41/FffPE+df1 rDPr09rx2mNfpj2Px+ZJ9NewzDOc9vCtGvF+zfN7C+3V9mXsWbwf03tCezFfQeQ/GFuvPZavTJ7R 5V1MvMeG9tUQecYuMDOF9kjsmfreGL5X3rJH6vtkiDzjaR+kNcbeR/uhZ9KCMUzwW97nxmrUk7OI PJn+Tbjm+Os8+f5GxBjlD89Mf5Nnjr/FM9+/2+P074OcYpj3D8QtxRHHk8fjb/X4/Uc5F3kW+dsQ F3ochPIi+xbb4TznWUr5KRQjvF6Ut/j5UA68LbZ6xVUov/TEFtugvOmp8p/Gmq/yt4eehz7Fm2ed v8NT4+/kfns2+bs8df5rnMORk3gMjQHB0xQw47kvy0F6vzwteh4P5aXrYTp6nzHWXvm4ZzyUh0P0 hbnuC/KpZ7d+3VeRzGMK0W15MjxXcn4M5ciwfIi1Zzusw7mJ5sDTWrG3fHjl+PLRlZOYuLbh9eaa pnxsZSZklLO8WYFl5eMrc0L1S/mkynzPtUAa8hjVHeWZlTNRU1BO8yYFCj1dgTGhmqA8p3IOchrv /1w3cK7Lr5zPe3T5zEpn+ZxKjzct4CufX+kvd1YuKvdULi33V1aVL6pcVb60ch1qMj1f8rOozUJ1 E9c8eo0CW7oN9LGqsobzJfoVqu1CdZjzZg4GhWoYvfZgW1yPla+q3MT1Tvm6yrqe51mfx8M/cy3I NReNrbymshEyrhtDpNeJt1DvWlCv/W4hfV5713U9xLVYiHrXdaEarY/arHyTRl9am3HtFV5/cc0V qrvCayzuKz/LOqE56R1bFH+eo4GBt8VVWyAqVGN5TgeGeNoD8ZyLevJVRyCJ/drTGUiBP4XkrMMx x/5HV68QSPeaA5PBDwxkeaMCMlN4vHmHBAo4R3jjA7PYP70pAeW2OobIOybgBpE/MiEOKW950wNB XCcHFodikGPCKwdWeAsCq3vij+LKOytQzfHmLQxs8CqBWq87UM97T4iQj+iMhfijMXt9gS3eYGAb bFP+8C4O7MA4dX3vssAe74rAAe/qwGFvdeAdzkXeDYGT3trAGW994Jx3S+AC739MyJNUE3i3BS55 dwSucD727glcZz/lvdB7IGj0Hg5Get8JWjBfJ4PR3jPBWD4neC8Ek3mevJeCI1nfeyWY6r0eHOcz BidwDcj5P5SbfZHBDJ8lmM3E9rDP8HkoOmjjeffFBqf7EoKz2c98ycEi5DBaR9/IoIp7qcFS2BgX XMC53DchuNCXEVziyw4u99mCK33Tg2t9s4PrfUXBjT41uJnn11cabEAeo/H7FgS34row2Mz+4FsS 3OlbHtzrWxk85FsbPBLyH67Buf7wrQ8e920MnvJtDp6FXM+5vobged/W4EW2z3Hiaw5e9u0MXvXt DXb3+GroHBDao4j3HaoUWcd3pLI/ywSjYLActrTh7yj+6/co/1y/R7koXL752wC7IrjtK+yr7dX2 DfZae719i32bfYd9j/0A4WH7O3ZFb6tBJ+1n7G69nbNfsF+yX7FfV41qpGpRo2eMVWPVBDVZHamm quPUCWqGfZl9sdbUSCY1W7WRDG36WXW6OnvGcLXIHlRVtVRdMKNRXaguUZerK9W16np1o7pZVe0+ rZFGg7pVbVZ32oNaI4296iH1iHoc/eMesSbf4zfSG/hr/x2XyMOn/j/5GppLEWKldie+hkbha+jX 8DX0LnwNjRFUwSncLbipxeKb6D34JjoM30S/jm+iCfgmei++id6Hb6JJ+CZ6P76JPoBvosPxTfRB fBNNwTfREfgmOpIi77AwWjhC7WF8E03FN9FH8E30G/gmmiZ8IPxV+KbwIbXx+DL6GL6MfgtfRifi y+gkfBn9Nr6MPm6IN8QLGfgy+gS+jGbiy+gUfBnNwpfRqfgymo0vo9PwZTTH8APDM4JseNbwrJCH L6P5+DL6HXwZfRLfRKdTvL8hzDBsN2wXZuHL6FP4Mvo9fBmdK64QfyIU4i/RFYkt4nZhPkX3AUER O8S/CipF8RWaS4MQFBbf9FVlrJCqjFXGK5OUTCWHWr4yU5mjzFecikfxK4vQ9imtylGlTTlNrV3p UDqVLuWaXbCb7QO5KUuVKmWVsk6pQdsErFMaCZuUFmU3N/Yb4wjym1G630Th/ewxRlqjB8h72FdE mv9U8h72FTN8JYI85QnyIf5y3o+8Yxb5EPvHAPjHQHwtv4PG5SJPYm8YTL6whvyJ/SCKvKCO/Ik9 IFp4jdpd8IAYeMDdtP77yG/5q/hQWvP3yMN41e/BqsfhS/gwWvkLQjzWOMEwmNb4XqxuItb1Pqxo kmGuoVC4Hyv6AK2oRxhu8NOKpuBb9wjDSlrFkVjFUVjF0fiy/ZDhDUOLMEYwRKZFpt9cj+Iq8c7i qt5NOamcKV5VvC7UlHPFNXrb1LspF4rrihu1plwqbipuUq6QpFdTrtuNxS3UdlPbx80eabfQtbX4 aKjZo4vbbm/2WFhoKz6tt3at2ROKO4o77JGEnbc3e3JxV/G1UFME1tWaYtbbwN7NPcQdr0QpQ0LN naTE6y2pd3OnKCmhd7nHKNwEJaV3c6e5EpU0avy+dG7udMVH18lKVqip82+3TvYnw0JSz8zKWnNn KQVKgVsmnHV7cxfQ+ApDjZ66+Z9bb+bezT7Snkp9CoaafZwun3BzJkLNnqEsVpb1NNKid6y4tdmz iWzKarRqpdo+XZfPthfRdUNoRNRO21Wl9vZmL1XqqW1RtnGzL1B2aM2+0L7EvlzZQ6u+Utlz+0io z2tpjg70tMPKOz0tXWv29ezf9o3w3Tr7ZnsDfGwrfKYZHrWT7OzFeFfYDxHHPdoL+5ol8hR7M1Yp xT3LXYjVKuTZV9t4ou3Z9iMUO6vsxylyauyn7Gft5+0XFZ/9Ms1Vlv0q+fJuezf5e5sqqv2zY8iX O9XBaowaR9dEmtF2xUc/D1dHK4XqWHW8Ool6zP7fqWZi1narOWpOcTtrFDeq+epMssVRixFBU4sV 9s324iZ1jlKrzi+uUp0k7yC9dRR1HaqHuFWqX11UXKMuVavUVeo6tUbdhFhu0ppapzZyvKpN9mZ7 s9qi7qZobdUiVt2ntuJt9Cb1KPWmjWNSPU2W29UOtVPtUq85hOIuh1mLP45AxewY6IgiX/PB38x0 dwitc7Uj3pGkbHGkOMbQGo9T9jjSlHQ10ZHumOzIollfQStgdsjkpexz1Y4CarOU1Y50zQOpYa2g VwufIZmjkEhRah3k8Q4fyd9xBB2LHcscKxyrlaCj2rFBWa3GOGoVn6PesYV0tjl2OPY4DjgOO6rh 42bHO7Bz0nHGcYa8uNlxznHBcclxxXFd2cCtuNFpdGxxRsJXtzkuOC3KDmc0+ynhHmesetqZ4Ex2 jnSmKrJznHLAOYG8dwl7ojPDme20kQcfoJ/M9uVuRYlyu53kI0q820fZNt0dVGrdi4s7yYMVygJm VwtliiT3suIc94piP412h6PavdpdzXFNPkOz5d7grnXXu7e4t7l3kIdS5qBsEM8+oJjde9x7SOOA u7a40zXJfohscb6DB0MTWQYenKiMcR8u7lKrKBu+Q3cU0htCcVPgPklcFM+CEq/63Wfc5xy17gvu S5wFFS3/jeG5wpztcF9R29zXS4yU5yZrua4kssTCb+M3lUQrckksZzPCgpLYkoSS5JKRakxJanFH yTgtcyF3udW2kgnqImWHazj3xDmdrLPv7HDOdhYpZqfKjXqbSP1OcpayfzgXOBc6ZOcSurscPiEr K5wrqa2lFd/gXO/cSOu22dmg1Dq3OlKczfyss1mpd+4kvykobnPudaQ5S6ntdB5SPc4j9MYkGvdZ VbSfVQqcx52nnGed5yl62p0XnZftS4q7lPTidY4kdaYaQz3bgjtXnd0u0ZHk6u8a7IpxxRWfpl2g Wtni3KyMcQ13jXaNnX/Ifpx2Gp/9qmu8kkaW012TSD9TkV05rnzXTNcc13yXk7w2hbzBTbne5/K4 /K5FxX7XUiXJVUVxTHnXtcqxjUY4RKlW48hH1rlqlCzXJledq46iRyabja4m5Rz5zgqavfonz7t2 K8tc+1ythEddba7Trn1Kvavd1eFwuzpdXaQd47rmLKLS1+xIcwsUK2nuge4oR5rjEqqpUf86Z/7T nTNVwYN/4RDD/6+GefGCYV6hED0vlloCteR5ybPl2fK8kfNGPtX2VNu81HmpfJ09a/asp6ueroJs HLUJ8ybMXjZ72bwMatnU+Lk0atWzq+fZ5tnoPUbLOsvz9I7BONcIONcYcaIxofIVcaKRcJYxo/KN wFkmEmeZfji/DMD5ZSAqXwsq30GofAfj5HInzixfEwyD5w8uxZjwbxCL1gqGoga6rqfrVvHOaYOL Nn8VytlG1xiiuC+gRI1yDmg0bfhXpNFEY/ug8RrlnKHrpK9GORfomqlTjk75GuVkaddcI1Ek8TOJ 5txOudF0nf/llJtAlEy8UycPkb8Xje6DFvWipf8AVRGt6oPW9WGXqaYXbfpqlMdzX0fU+AXUpFHe JI2mtXxF2k20rw9q1SiP1+3oV6M8Xts2nU7r1K5RXr52tWXTuqcT30HUeTvlsQ90fTnlzdFtXNMo RyAy96KBfVBULxryD1A8UVIflEI0pg9K60XpX41ybXSdrMVHn0T3cqcTzdb15K9IBUSz+qDJuk2V roVfjXJL6aqEkTuMQjoL9esSouXE+26+K5xyV+p88Mspdy3R+l42FveiZX0QP7uRrivoulm/NvTd ny+k1UTVfdAGoto+qP5Wyt1adDN/h+fbUL4M5bHmm/kld+et+aPHT8LXNbQuoTnaGza3h27tU09O Cc8BoRgOxRfvGbrP51EfbvHpQu1+7hGi40SntBzB+0vueU3OY8q9SHS5CPm1aKWWJ3O7izbLYhH2 ALl/kZbf52v+LvOc6PlZpj1NjtPGKydq8yAP1/Il22SS2S75gkx5Uaa5k6kPMtvN1+c3NJ/cf94n Q3tYTtg8sx2nZoPvybRfyH69X73Xqdca9ewnoXXisXJfFml9k5eGPT9fXz/+mceVr4+tSpfFhFFi H9R7Xx7fB00qurm/hu2xPTQzjHrvsaH98n+yT1YV3boXriu6uQeG7Xc9OYtIbtSvtG/JLbqc8odM e5JMe5BM+498VJdTDPP+gbjdqsWTTPuMfFrLRXK7HhehONDzInyrVc9z7rAYuazlLX6+Jwf2jq1e cdWTX0KxdVnvf6e+5l1hzwe1eJNpb7IKWr+ttCdZeQ/K0nMSjcFKe5B1iP7cl+Wf3nm8L51Qn/vI xz3kC6MveteX5dMVvah3ngzPlRuKbubI8Jw4WX+2Wr+XruXoPPKfvHUacW3D6426pkaXka9YtxDP eUyvX/KoNrIW6nmM1jSPa6JOLZ9Zee55vvSaIK9Jz2W8/wt6nmP/oz06j+zlkT0r9TeP6x+ua8jP 8tgm1zEdev7U8yWeHV90s246fTOPwpZuA33s1PIl+tU7D/fKwT01TCgP8zjZFt8nn8q7FvZ8lzYe /NyoxwmNLV/QZXVh1NQH9a4FW/sgfV5713U91BFGveu6UI32P6nN4oturb9Sim7WXWE1FvcVzybd nJPbYoviz5p2e1xZ04t6aiwrya1ZWi4K6Vllza+tBbo/hfLYbi2urHp8WSmvWPW4s1KMWYMahceb leOK5ct0/1xddHsdQ2St1mmDRog9tl+rX+tvxiDHhJX2OuuOsPgjPeseLd6stEdbDxO9o+09IeLx 8hmL54nHbD1JdEa3TeOwntPHqetb6UxnvUR0heh6EXKRzUhEZzibhSha2/+YkCepJrDFEiVo+diW rPsp7YW2kUSpROO0+bJNIMrQzgk2mzZPtumavo32DlsRkarVgJz/Q7nZRnuAbYFOqdo+w75tW6jN u41qUNtyzc9sK7V55HW0rdXvrddtbNRyuY1qRBvVhzbKPTaqx2xUh9morrJRPWU7os2v7biex3j8 p/TrWc0fbFQL2agGstEeYbsa5j/0Tq4HbFQL5VEtlNdfl+s5N4/qgbwYff0oTvJojvKoBsgbHuar oXNAaI8iPm+0ppM3VpPhX2ZEWgb8619m/PN9MRNTxH3821Vjq/CqIEQkECUTjSRKJRpHNCHsmkGU TWQjmk40m6iISCUqJVpAtJBoCdFyopVEa4nWE20k2kzUoNNWomainUR7iQ4RHSE6TnRK78NZ/Z3n v+B6keiyTqx/lahbECJFov5Eg7W+Rcbo1ziiRKLhRKM1Oz3Xsdp97mvkeKJJ2pgjM4lyiPKJZhLN IZqvvS/SSeQh8uv2FxEtJaoiWkW0jqiGaBNRHVEjURNRC9Fuon1ErURH9WtbmP5ponb92qI/1x52 v4Ook6iL6JpAwUpkvnnl+elHkdwvimgIUXwfP/e+JhGlEI0hStPm8h+ikbdSv3SdJhNlEclEBUSz iAp1OV8VIjeRjygY9vxinZYRrdDotnesBr2auym3Lrcxtym3JXc3aF9uq9mcezS3Lfd0bntuR25n blfuNVmQzfJAOUoeIsfLSdRS5DFympwuT5azZFkukGfJhfxra5BPDuLnxdSWySuIVsvV8ga5Vq7P bZe3yNvkHfIe+QDosPyOfFI+I5+TL8iX5CvydavRGmm1WKOtsdYEa7J1pDXVOs46wZphzbbarNOt s61FVtVaal1gXWhdYl1uXWlda11v3WjdbG3A/a3WZutO617rIesR63HrKetZ63nrRetl61Vrt00k 6m8bbIuxxdkSmcfPw22jbWNt422TqGVSy6HGV/6Z+Xxq/PNManNs821Oah5qftsi21JblW2VbZ2t xrbJVmdrtDXZWmy7bftsrbajtjbbaVs77QxD+/xLDIL+lxgi8ZcY+uMvMQzEX2Kw4C8xDMZfYojC X2KIxl9iiMFfYrgbf4NhqEWxBIR7LJWWFcIoy8uWLcJES5PlDeEJyw7Lm8I0yz7LfiHP0mr5vfAd y4lBBuHJQaZBorBkkGXQw8JS/FWGuv/FPTMYogwe/NuVHfz/277vqE4U5fdRVN9H0XwfRfF9FMX3 dYXxTBTRFIyQJVE0Jw3U5ElROg3RiaI2iRSTKGqTKGqT0jTdpHRdn2UUZUlZui1ZlxfoNEt/L98r 1H5OUoQRuTXUwiOKsYVjKiyitNYTV7mn5YEUFwJHV24T4is8utJkmdZqEP4Ch4C/vWHE394wWYKW oCBafmJZKUiWn1n+TYjA3+EYaPmlpZ7W4VXLa8IwS4tlu5Bg2WN5W0i0HLL8TkgeZBxkFIYPkgZJ woODUgelCin/n60bup8SHydcKpUTDgBvA98P/MO6PItwrLQA8iLIfw5+JWGq9Br4LPDasw+Dt+HZ hwhHs/zzq2Ip7PCz/WE/QXyEcLb0FP87KGkh5JMJM6UKwnXQeYnf+3kT85//CX2ohvxF8I8Ax+K9 j+jIdqZIXrx9Mnh++w1xBPEZ0JkAfEIf3QjolKGHj6P/j6L/PjzFfD/TFfQqjsdOGzHNm8RPDcOo Z0klhN/SrQ0C/w3YZ/lASLKkieAfB69ppuG9FE3dkeAzwPcXx0PO4xIgf0KXM58OPhM4AJqZmJ+/ iY8RP0pyof/j8RTzA0yXoTOaZwbrlSe58exKzBXzA01/Ra+GEkZjRHfxvNHYi8CzpoHln3+EVfgI s2qAfAowQqznUQPvBE4BPgLNAeI4YD7hN3nsxjxJ4d9mS4WEz/FYjH7wE4EneeaNi1nHYAQ+D/1U RpMCneeleYR1sHYnSwwnmDd8grtroP8E9H8GPhp2PgGehf418fckN4r7CfPF42yfecPHkCjiCcJ0 1hGuMBqygZ8BdzGaTNCcCjtPsr7hfVioB/8K7k6B/g3op4A/D9wLfB36H4rke8Yc6W3iESNGs/Qm 8d0sNxRJrYTtIvmSMZZ1hA+lZwn/zmg4r0sITamwEwuMw7PFwDXAu8UbuPs08X9gNJ4GvxN4FPi8 OJtXx/wh4U91bAY2AKuAnYwRQ+iN1zHbb0DzDTP/HZd14CcCvTrfAKwC8rNToXkFd9tZYuoPyVZI NmnrzrxhrI7NwAZgFbATyE9Nhf4WPCsAU6VfEGZi3T+D5KCOPJY68CeBF3W+GdgArAJ2QjODThNJ UhV8TCV8GvqPAx8G9gPeD1wD/DvwbR2bgQ3AKiBb/j+YvZ+xjuktYKvO8xg/wbMzdORno8DH8XgN H0qHiR8GHK/zLwI9wLnA/cCLZPNurP5VaEYxGi7o+Cw8ai97GiTdsBDFFojfD/5ZxM5h4H6gJtlB Ot9Ar+6V9sED2UI/RuI9wLmQHCP+l/Cus/DbV5kn7z2MOGJ5CZ1JDAYr+zD1RxsXj+gge74xDpI4 SOLQwziMMQ79kbkn5O2NNNKFGOkPYXkLcA1wu26BI64c0XS3+S6SjIM8FpZjYTkWlmNhOZZnj6KS 7TdA8zTwks6TvmEj7B8Fduq8B/kKowP+BjPWirG8HsFv8QInwqsV5k39IamTfsv+A/5+eM794IeZ v0U4hpHWhXprgES4Acsy7ubg7k7cPYq72xHjTYjQZGACIuJhZNfnzMMJn4H8A+TDLvBred80/AV5 9Q4tG7OmcEWyk/xryKjLgN/HjC2CzkjE4Lvgvw6s1/Owg+SwbxwKjGCMgOeYX+L5kZDVxcU8FvNh 5s2TMK6fI/YVxEV/eNp/Moo5iKOrkAT1KK5CdLDNFqmJsETcwvkE4z2CsTwPzTxE3w/NnO3vAP89 5inbcD7Jh7xOz0jM3wmdGeDXaJEL/b9gLPtgcy3sR+BdP0VGagc+hF7lSR0824y0+zBqnjDXfJJw IzQngr8C/a16JuSon69lM5ab1mMe1uPuQeDjwBnAfsBhEVnARrydJQH2IsoqzGcC02H5fvDf0Hec jcQPQVwcgyQBeMp8D3sOdpOXEFl38A5imIG9KcA7hWEpo3QNEXGVn5LSEeM3IJGByYiCLrZguhvx FY29bEzEOHgd+8A2rJcAzQ8RcY9xDJK370Am0XA/opjvZuBuMbLQr/VoZfloyPdiF8th+7QubyIT skeNwY7ZhD7ciRGZeESmqdD5CyRHRaoeDZMhmY55uGD+lPAKnipEjpoOyXlkrQfM7/LOyz0n1DLq s8gt/K7NwDXAveYHCN82/5RwIv8f5w1/QOY5jbs7dfSgh8wXmEfg7kVkFc5FVqyRaj7GvUJvX+Rq wfCfqBlisS6fQ/4aVm0Yo6Dt7+1cixptIts/IloIO7i6Mw5lFDrxxnKM14cxbuQ8YHoYOeRBRlOC SBLj72D5BWj+Apb/C/wUWD4MrzjMNg3Z3FthK/p8AThD6k+Sz1CH5MPyY1ipFNg5olUmXM1SBcX8 akTKCtR1F0Qn+s++eh/u1qDPx/CuY7AWy2MU/8jzIGE2xE8ZTX6scgxbM73LvPgY+EyMtBP9/xQZ 7FPEdSx6+yFs7uQemsZi1P303nJPEsGPFOnkYjiIUb8hUr0tXELfDuHZbdAZL7o5Y+CpAq6HjQWm jwjXiU+Q5QlYwW3ifPZt4wvEH4e1D3Rkay/Bzjf0WRKJf5+R/G2YwPUqzYApAvPwKzzlA66GJ3SI PHtbIHkZKz4c1p5CD2XwFZiBFzHbkzFSJ579AHgaOA2x346xLJXmg+/HXsE7qYD1EjbCZgmwCL0t gE2zVM35RPdMHm8Fv1d4ATrXzEmM0ifAd4G7IE8EZpOFo1qVzpq0DzKOl04g5zOfqdXtsHMMeBB2 DsLOQdj5E/QV6CssMXogSYdE1up85mmn+wT4LnAX5IngWf8O7SyAt+zSENXmVNiZys8anwT/pMaz HcJdkCcCh0ESB7/aj5lkm+/DWhewHvgKsFHk/XoKbE6BzSmwOQU2p8DmFMzSFLZsSmFNUwpmYC8s 7AX/OvjXeRQ0qxvRf8bfaONlnvq2EXY24qlPYIEl49DPT3Xk6Nglch/ypYcQxbw6z4q8h+7Rz1P8 lv1iG2IZ5ynWFLSzzzmchobi3JQF/B2sDYX9K8A2YCOenQnMxLMtkH8APCyS35oTeVzmBkbRyTri EWk7ZQC8y+yTeAecjbnyYAY+g76FZ9XcgHh/GL09Bj95H7haP9mdwOocgE+ewKqdwMzAPzn6aAaS eaWkuwk34BRphGY8NI+BX4a3p2v+hrV4mSUmE1bKBPlU6L8P/BRYDzyA8069+TzewpIbvC60vsyf 1xFrDb5F8xyWkCdkYwWzseJ0chcU0x/pDD5GGkDoN/+EzvKIx8/fl9aR/guo61p5TsRHeScSi5k3 vQb8N8jruXoUX0K2hD7V/1y/fR3PTkP95oLmW3xCFw9y9jbhxG16UqIcKA7G3d/gqV8yRtwDeQws XAc2Qr8QfrKY18L0Os+t6Qz4KcBHGMUEXiMxEb5RBf034VHvMUqbofMIvCKWNU0/xsp+BN6Juw/i 7hB4SwYsaKf7RmAW3jUR1ctL2BMzecZM72NnqUK23Ifd5ABXNaZNqJ9XYW+qZTQtguQ5VEedsLMb eBz4LvA92DkHPAIMYM96DztvC6P0FvjFQK22v4K96UeoikegPnxP55uBDcAqINe07/GpU7qA+Z8K zYHAR83fJdROo4uA23VsAFYB2cJr0ETVLb7OEkKW2FgizYFXzEbVGgBOAz6Ps4wHlacPVW4m6u06 rkLFZHjRb/FG6JuqOKOKkBDyWDpg/34dm4ENwCogWZMe5NO6+U14zkEphp4aAGubgPOAJ2AzGjNQ Cb5Zx2ZgA7AKd3l0lTxj4i7mI4aZfwGcyfbxlKgjz9Ix2G/k2TBNRDW4SMcXgR7gXCA8iis6c3+s /vegmckZUrpfOkj8x9JbhL+AvE1HD3AucD/wIfY63D0AyQFIfsyVsOlVjlPDD1CBxwO/BQyg5kzA 2e1R1LQjUTOvgl8F4LeruD40ZsLyb8BXcq1r3Ia+/RnyP7MdcRr6f4Yl4j06vgj0AOcCOcoe4F6J X+dzuvlXmudzXBjPwdoA4CZUC0sQTdE4oXsRBRtw9z0dXwR6gHOB+6FD8yney2+R3uIvwISsg7M/ IfPad4wrmKVTUgMiIp7vaojz+Hk+cYsdLJF2cU/EZvAfgxfhJyL0F0kfYhU05HP3H/jcTbPBXnFE XIK+sccK4Lej59txV8ulE4ADpGhCgddLGmrOI76W5dK98OQ/Ayv1jMr5Zycy6hrorID+y4i7jxBH A5BXxyEP14D/Ledh8it6StqDdTkAmy3ItGthuQTWRoBv5jO7WIi7HmjuZIzcxR4eiTOa9HNY7mZv idBy/u9x6qlChF5ABL2O6MBJn+KXc8grsPArWBPE5+ipnbDzBvdNxBmcMtVxrAXvpMU4cZczTxY6 gccR153A44jWTuBx9PY3xOO7pdiCWbrOlYDpBeSog0ARffstn8TF/wAuYDThu5Cp1bycdz1E8Rrw r0P/JTyLr6CmKpaYVc4GZhfkb0H/LPBJ4CbzFcaIWbzfQeeX7DkR94CPAT4Ca9ehj6+mYn/eI8Qo /iInPiTFwn+YN3LfpIu8+mIUYmeR/q3Mi73yEPsJy8X39dM6n7AacAJ6FHE9hXeKiCys3btYqceY N/eX7qC7V7FzbefzMnkv54QMvhuRhf1lE0cT5asdwP3ISzuAvJNm49w9AvIzkJ+B/GPIz0H+HuSz Ye3PeIt2LluE/fE4cDu/VzrLIzLjO7apCSfxWux063Eef5vP3ZTl5mKGP0WfOS89ymdw8x2I+k5E 925GEV87Kc88hJ4wHsHdAaiOBpgfQz78HLHwIjIG310MrNKzBz91AnnjTT6Pk04N5DXoP/KV+Rni m9HnJ8R7CP+dUUzA/G/FSP+E1fFDZ4auyZJ4nIl+x2MU7+QTtAmndZN2pjuJM90h5OTvYx7isO6j tNM3vGWIRLnIHImnPkWd8Cqf0yWnSOcLcRVybCmeLcWzK8HX87uM38Qbi7AuL+Fs+COcfI8jFkSM 7qd8ZhdHoIdPQRMnXBP6Iy0Dv4jP7KYy8JpOCSykAb/H9RLVjRyP28W7eUdA3z6Ah2un7G/DB6Zg 1A+ZdtKIZrEd8wLgQkZxk/gKcibHwuPMS0EpiF7xTBZAR0DW2oU8JvFdUznvX5IBdgZj5rejh7/k 87jpFPiP+RRvehj8FD7Fm36NsQzinkiIHXGGOJQkG9H/JaaPCZ8xkQ+IF/j3a+b/QE34NJ/iaXTc n3v4LG9aAZvlOvIc3gGcwed3aTvwu3yOMP1fHrs5BjOQjVN5O54q5PO76S7wu3G3C/35K3rYBPnf 8NufBJ4Z83C8fQJwLsbrBqbptSXvp0Px1GE+yxv/yGd5048wP0PxffIsevg0MBur82Os4zReNfJb QuMrkMShnzU4xawBTtR4nFDWIMrW4KSzhk9VdJdOItIDqKj3QPOHwNel55AJmbcAp2kIC9NgYRos TIFmJ856I1gijoDkBCQ1YpC/VOCknARcjvPyd3Be/g5OYY/ifPcLPiuRJ5C+UYXme3hjDCrPUbA2 ip8VM8A/qyEkz7I1wl2QJwKHYU+nmZGOYXROkU6Fpg2w+Sjsa6ObAPw+nz2p/xgFbI6AzREYaSdG 2slzJc5gy+YM6R3gD9mLYGGrhpifIvBZmIeJ5hzMFaMV5/dTfH6nUeTwNzHxGN6bgwj6Eyx8Ams5 vE9xryjnML4g3k84R1xK8iByKc7LdL7muz8GxkEyQVxGvEfkvo2CBJlWHIa1+Aj4N0ZTK6N0hFEc BXyWn5VG4y13weZU4HjgZlir0uYKFj4GDscMVwJLONdFHOQZiJQxn1dx7nPhtwklzEeYsd89zXel BzDDrdDMAF/MfMRBthYpc00ideM8+CjGpfnGOKxyBtZlA/hoWEiHzq/5+4CpkOdfjMUqbIVv3Mv7 l+k8j870CvjB4BdD5wxwFJ5KBEZjNWP4WamWV1zaDPkj0PwVVvnHzBs/guRRcxqQT+5OaA7l1SQ/ eQ45kPEobDaCvx99jsYcfp/lpHkVvb2KCOV/mVB242XBIAy/8Tv+Fw43XuHf4wNLgN8Fpt/4FeG8 Gw9CXsX/ogDyIl3zZWAtLCzEUwshGQJcQ/jvuoUteOMWyC/wv6O40Qj8M55lLL1xktDKcmPeDf6C Ogr4HNAPnAg8CVzMaDAyCl2QpAIFRpMC/nlgHfBOneffRJzAs59Asgb4BJ76Gfho3D0LvAYJ3mLM h+Rj8Jr9dLz9CvA93P0MuAvWTNCZCnwS8vd1nvtQD8krkEwBfwNPpYA/D9wLfB34ITRzwF8Fbwbf DRzSzb+haO9O4VoR/YG+sIYlJm1m4oCxLDFg1IYZwD9Afhr8TuBR6Gizl9f9bbIwFvx3mDdOBLqB m/CWo+AFRuoD8/OAzwPrurlq3QPLf4XOD4Bv4e4LsL9eGyP4u8Gvhk43dO7FW7aDj0PftuHuMWh2 QP5DfXTQuRFJdhZq8wDNbP1ZmiXhKubqGchTu2WMkfZ34x2MwjnwVUAHo+Fd4N+Bn0HnbfDdwOvQ bMLbk4EJwIeBH6CHmn+uBf8XYGz3ZMIC8F/Dui/TPJblxi3gR3bzaf1d8OMhh88YIxjN8ENzgFHc Dguf88yYS5iXWuEJVRjj2Rsv8G9Lof8TzXNgbS368Cl0DmJ+8jhyKeKGIDoYV0P/659T5WP4b/bO Pd6mqvv/Y82x1p777L3NdXAcd53kXrmTkCRFJUklSco1dNyvSUiSJAmVCpVUknRTiUMqt+SWhJCQ W+6OSzqcfb5zfNZ6fl98e72ent/z/Pnk1XuNNeaYY8055phj7b32Puecw0yvAZuDmWDjpAIzZHZC G0lhM7QOg+dmorF5IvoK0FdH9LaAZ8Dd0sqV0NoRfBEchF7lwmuJ5dvg1+DJUBabB5PyBLsf5IKi 5z5oXQ2egodamFGRYF0QAayXszVYQUTm9WB3QO4Em3mI6oagFkls3Y2IcFAN0iBHEclvYP9NsqE8 9YK8CfqB8DYAmmlCDirDn8jns4j2C2hFDthsF5/50fcQ4r8D449gLqsgF4N8QOJv81DivxM8EOoz 4CcDY3gVI5Ts/RD8EjwEfRD/Z8F7wPbg8FAOfMonBZNgPw/6HiDWiI5jTx1E3KaBa/IKWuZijjFo PoZcErsyC1nRAvq1mPUBtBbF3A/lzbKahmjtB/10RAx7iqtBrg4PxSTOqiL0wb77DnwQPjvDQ2f4 nA9NSchBdQ1yYDXGsx9xRmVzXKxUPfgJqvHaoHbl1ZAYQl4V1GFYjoXlFWEdlqv8AD32uDsCO3QF 5D/ymthxBveyGah1P0mU3HqQb4b+KPz8ARnVWKWAqIqqdFAZYLMC/ALj/zBZyxJ3K2clbOYFdQNE nVGTEaUGsNkIBtUJ2a5wb7JRte93GBXGeRfsCwYVqQL4MjgA+v6y7twGmlZgd+Tzo2j9FnwP3I0d MTKUJRrBvawteqFqqQ7BPQ4rG8FaFAFfADPAdSDyx8H9xflYSHmQF4I58LA+XCOREVvnGOSaYHPE bSnkfEGEId8C3pM8I+NEr3bw+Rg4B5aNIW9H/v+A/F+LfXE1WBH6mZDrwP4J+MEdkJLIENyjnT2I eVHYLELOQLb1EJ+LQZ4DfWvIQQ1HDkRmI69SQdz7PLxSipSCt6CaXYFxfpY3VT4Fg4e85LOYo6Wz HK2Lgoih8rdEFfoAbBfkEirPVsxFgTGwU1jDpTJ8inqbBk19eDuDyrMUrdsQjdfBRWHFEHvEzcb8 VYwnkDNwjxabEeBj4CuhHLRmIsIiF4L/Neh7Fjavgp9B0wLPSE/j6WIJyM0jn9poJ8JPneSbPMPw bahcPCGv6GVJdgnVbHxavQzvo/GczdnryneiluDdJT45Uo0jcakM+DRqrcjqa8jZ7ha878bnd/Je I++MqkryrDsmdze3m9zr3bfkFRHkdPeEjF/oRtx3rCYb353IETqj0auL0NuA5zPFwFR3qOxleKgp VNPd7/Du7AQ+CZVevcGWYDq8Jd1i1vITfsxyOe+Wmgl5oPwslWot5Ja8Q95jiiUtFjoGvZYL3S1C bsvPWc0s9C0hT0XUJ+jbFq3lhF4L9NoKrgLHgntYPiHayhLzDjxExi/PJaw30dT12sBG3gVkiYbe EJnmQTMZco7Yu2dgv17onOIlMjueIvUcltOF7gLII8AS0OxGr6NCrw3ksWABsHWosaNSVUXmdBkt vYS+3YU8ROjMxEhYOULvlPxOJchKKdE4i9Eq32yv4dg4J8/hWz0t1FipEvK8SGWp52VG6mkZv3pb 9rvIarQaLZmp5G6bIfbOh+B4IT8Dm0UK3x9TEywn8TOWH0OewO/Cj8j5YfklrtgRfd+CXA3USj7L zsXVc1RB2d0KOaCKYJypku0K309QEau5Qfmyu1V5eb8j9k5z8E4hnRYyw0NTeLtHFZVaodbBZyD/ JvcUkZ05sGwGD0n0vQzyPvBrx76jdOZhDAcd+VSxsiNPZW29tJrzjnw+nuuckruD7CznFORb3TR5 5eDslPEInRtUumVBNV/ua85e66EYWACsLLTeLOk3yBPAAs4OWO6QfQ15uzNE7izwuU7ZdxbOZGeb 1b+DOEdkPKoE/OwHT2O/TyGy697bta3JOZE0yLsg5xMZn8vPiFwD/Yei9+RJ45uRmZZtwMbgYSEf AD8QegnozwuVCz4HTQXYPCCMbIZlJbAZWktD7gC5NSz3QQO9O1aoS0Euj9avwFPQ4Cr8PeTOkEeA LaAZCQ4WOhitaoDW7yDvxHgisHkBnI3WZZA/hnwEvAO8D3rMiHPRN/C2GnwS7Ab+BMuakDEvPocr 9oG8FOPZBB6E5i1464RedWC5CvrLIc+FPA0xmQ95EPg6WBG93tT27hMpHqyOyO5hMC9YI5G9BDTn ITcM1giaicFKicwPgB3A3vDWLlgv9NLBqkFGTCLHglWD/QfgPrSWFupS0HyFsVWB5TiwexAfXP1G jHBJEBPRqBKQg4ghzu4MsD6uiGg7J9CKSKoseEDWeZPB5bB/A9wA3g5i1m6QadMwzmGwLwsPiLln MAbkjyqH3EuB/R7YvA/5elgGOdYINMLo+9I3WgjjZNg0gYcvwDToi2PWFRCZVbB/Ea3YI+5G9CqD ayG2PDnYd4jhZvRFbN2xYHn4+RQ2VeEf8VQ3oO886LHLvCBXu+JawU4sFeQe/KyBDEv1DHodgs0k MMgQRI/7BpmM616OWM0VOiegeQ3XCvKwFlgPvBN910OuAQ/Vwf3gn9CPxrU6Qr4LfjAvD1f3asNy PPxMgYzIK9QHdyY4ELwHNsEVfwSDDFmI1kdArAsXxRV7gYi8hsY9iSsOgT6oadiDbrC7sXM9H5oC ICoDIysY3lRQqVBV1HHYo6/bH3wPnAV9UBsh8zpoVkDegasjrxh7R2WjF7LOC3ZTMKNFsInBfio0 wbovhr4lWAzEmBk1MzIGPoNRISvcbSD2lIvccDDyyHD0egz2OZCxE92h4BbosaaM+HttoUeNclG1 XOSDQlV3u4ALYH8KOTMC+RPUq9kgapGHfcRPQhNUzqPoG6wp1p2xUhHkEt8PYq/xBBDZq9cKo8gK D/cvD9keQbQ15h5Bqwt7Ro3ia8E75OpE8j7FfTMpn3m1ARuDh4V8APxA6CWgPy9ULvgcNBVg84Aw shmWlcBmaC0NuQPk1rDcBw307lihLgW5PFq/Ak9Bg6vw95A7Qx4BtoBmJDhY6GC0qgFav4O8E+OJ wOYFcDZal0H+GPIR8A7wPugxI85F38DbavBJsBv4EyxrQsa8+Byu2AfyUoxnE3gQmrfgrRN61YHl KugvhzwX8jTEZD7kQeDrYEX0LY6+ebBpCHkiWntDbge9BjGXyDGwClrHgd3BG9FrCa5bAiMMRo75 ujPA+uiLWTsn0IoZqSz0xep7k8HlsH8D3ADeDgYjDFY8mNcwsCw8YO6egU+soyqHHEiB/R7YvA/5 elgGa90IRK8oWqOFME6GTRN4+AJMQ+uLkJGZ7kbYlIFnRIYxfv4UrVXhB5FRN0A/D3pkrxfkQFd4 CzI8yNU10MNGPQPNIbROArE6CnHgvuBr8BasYy2wHngnWtdDroFe1cH94J/Qj4bPjpDvgh+M3MNV vNqwHA8/UyAjVgo7y50JDgTvgU1wxR/BYE0XovUREJHkorhiLxDR09C4J3HFIdAH1QDZ6wb7Ajnv +dAUALGnGOvI8KaCPY79qI7DHn3d/uB74Czog6oCmddBswLyDlwdmcDIcJWNXsgTL8j5YEaLYBOD /VRogpVdDH1LsBiIMTOqTWQMfAajwrq720DsAher72DkkeHo9RjscyBj77hDwS3QY00Z8ffaQo/d 7SITFCqh2wVcABtktRtUkqOQg5XCajLiH0GG8P0gcp4ngMg9vRb5j7X2UM895GoEMdSYUQStLuwZ 9YGvFdIgdcTK2e5akp/KjOFpwHirScj7cW4gzxx4FJ4n3ILW6Z5H8r2INMk9PEVRolG/Qz8e37uL 4BmIKxrnVejbCr0NQrcy7EvAQ2+0HhBG+kLuAjaFzVF4OIWrtw6fbJSxPCtPTlQfaM66lcUPnqLs wlOU2sHTD2j24VnKbuhXo28WnpkMhs1RcGDw/ERmrTLx5OFuT372p6aQU/EUZb20Up7ITkFosgJZ bLw0RCwD+mhIeWdd0J0qV4dmFrgcLCdMTsyT51Et8taKN8it5Z2sWi+ycxPkNmhtDHkR5C2wHAo5 CrkuWr9Fr4PQFAi8QbM7KSO5CjYF0Ksq2AGtmwKitRjkHLS+Ag9loH8b+tqQK6E1AvlhyE8HYxDZ +TkYA1oHi5xsmXfGRqAcNJ+QPJ3YCnm6yOyLTHlCbgBmQ5MDGe/r1a9Cb4PQdaBX4By0RoXOKchH waqwJ9iMByuBo9A6EGOYDLkD5Fm44iHYDIG8Eq2Z8BODvguu8g04Mxy/jKc7NPOhyQLHgpgvjUxu lFVILpQ8hGZwUp74ZcBzz3AMon9D1kjtEdJ2+JwLTsDVz8PybDA2seGdSflm3fXQNxb/6kTyXatP UjM7qlRY7hKNOg4/d8P/7/DWVuwjJaF/VmRWyY8t08XeXRpcFz4zEZ/porfXFW93YfzF83Kspj5G ezqYtdh7LXHdcci3yrDfA01PiQMdx8gToncMmEyet/o1QjUQbC10vgF3ggdhM0/IN2I8rZE5NcF0 XH15uPpWQ22SsitXI8JvgBUwo75B/gcrG4wE+p3CKPxo7D776tfOMVIEfWeL7N0crK+M2WuDGc0L V2EG9Avx2u9jeYYcZGM4l2ysznnEJxs7sTc08hx1F+Sq8DAZESsIuQN6FYD9UthkQdMOck/oJyAy EyDPhf8SkL+GTT/YfwJvD0LDsP8UllFpdcdgnJgjN0UmY0fTaxiJK4wMxaybSwTcqUJVIthfWLtN yTlYnTlSz9EriTjsDDlD7ibQnxLaWi9rtxejKgfOAqsiGqsxtqoyNruyQVZn41MGad0DrgA3wbIu PJvQWzZ2kOTJbMzUhWYe7LdBcxjyTPhsCM2t4L3Qnw9XagZk0QzDVabDph04HzZ1webhfq9uRzsj mEWYe7Jr1gS1AvqtYC947hrkYRANxOcj7L45yKW2WIV34Ll1YI++deF5MDTzoTkL+3TyEY0ZyAGJ eRIRjsL/S/B2GOvYTiztyBfKOsqY7etq8dAS9p/A8qHAPqyHcsWXklNkhGHNJNRtzJdewtXFz9og Q7ATP8dz46PUSV5FC/lA3p1WboVZH4RNb+TYdqkG3jjoS2P8t4Z5JdH7RMk3zTpBMwL5WQX6EuDW oJai2gzGrA30A8EoOAszHYM59g5ii0o1GzGvA01T1LphwdhCD1I/J0n9tCOUDC+CSFaHTVdcNyfc re/iM/1g351HZS6K0QZ3t+D+IjFsIbXIXYBZZOQNQ6uPzLGM4J6lZwU1B/FvhppTH8wJd4G9lsa+ 49bhWkudaRjEJ6wGol+PnV4C8tCwckrra9BnIm/TId8GfVfYrIbcG/oKuFulIf/nhxU4W36bUN5u VMuWtnU9VrZKcOdKyu9ImZdXCHe0TrL6Ug3sa5WWqBWlEBPLZFnxQITfH0iu/GxR+HRRSDHoY6In Ek3yZflmeHKxfHs/2QTyOMg3Qe4R6qfJ83z5/r/VzEbrg/LdNvk5Aisvg3wU8mGR5WeOkr3kO/PJ idDXlG8wWg/v4zf5rCH5jUlZllPkc0xqIT/1n7xZfvYkOVJ+eiWZFcm03KZtr9yjkAuLbMf5vOXP +riMKrJHrqKPQd4m/vUByOcgi00v+emS5P0R+R1NL+v2YCf5vUAYW+NgzBH5bU5DtF3N5BMReEbr k5GDGPlOeEuFpfAJ3VC+46fl9xGNjMqnHvW8UYjMPETgV8zCFw1sXo62ke8QRlZZvhSO1u7o5KO6 Lq4l+kcjOfB/P/yPxe8yEv0o6JvK9/OTo/Tb6HuljE3fj/GLPALyyMhKy6/0WcsW0L8I/c2RcpaD dSvIFTG2+zC7zWIf1YiSfEdxdjSKdZS+b6Bvk8gzuNaXllfDTzf4uQ/yi5CbyO8BsD4HwY/Is7FS TSLp0NiMTT4XOS1xCCmazyA3gdwLclNvLeZ7SsaPfLsTbOJJ6/1gE30l8krkepF3YCN5eB0ysKJ8 XmnXtzBiWxgjFz6iP4T+I8sBkJ+E3CuyGGNYjCwaB/04XPFTcBI4EVffAP4AzQZQ5H6ITz/sghr4 bgDl5ln5Mvm2QDIun9cnq+XKb6YqCVKu7I7y8ll/slrAXLv3k4VyF1mWg6ZkcjhaM+AnAxr4gc9q uXb/JjsHfnJlDBVzp0Eve6FU7re41ibLtNyj0AgvA6vl/gxKnameu9+yYLIR7hJEMeellGbEHR/t m0lpD/ft/AiNzGzfvyfNJ/ve8q6WjTLIVsq8PEqnBEWoBF1BBagy1aK6dAPdRq2pnfXR0tal7tSb BtJQGkljaHzYIx9pKkllqCBVodpUjxrZun8f2XWju6gzPUJ9aBA9Tk/SM/Q8/sZm0MtQ1NazspRG Vekae/Ub6XZqQw+RorupC2VSX/xF0FE0liZYa76lRYum1KzlHbdnUJe7W96WQdPhpwh+X+5l9g5R jgpRNbqOGlNTak73U3tiqkT30MPUg/rRozScnqJn6QX0ilEGlSe579ahBnQT3UFX0kS0FKVU23o5 FaMKVJhq0LV0Pd1Mt1ALaksd7OivolbUlXpSfxpCI2g0jaNJ4TjyU5xKU3GqaOWa1JCa0K10Jz1A Hcmjq+le6ka9aAA9Rk/Q0/QcTaYXO1bv15FHgGPACeAU8A1wVsf2mf35I3ABuBRcC24Bd3ds368z HwazwbNgUui6YKxjxx693VSwFHgVWBdsCrYCO3XK7Paw2xscCA7t1LNXD3ckOAYcD04GXwXfAN/p 0rd9R3cO+Dm4BFwFbgR3gAes4/ZuNngWTAo9N7PngB5eDEwF08ESYGmwAlg5s1fHTK8mWBdsBDYF m1uTvt7dYBvwIbALmAn2BQf3Em/DwFHgWHAC+BI4FZzRq2+nnt4scC44r7foF4BLwOXganADuAXc 0c+ulLcHPAhmg2fBpDAS6detZ5dIAiwAFgFLgWXASv16dOwdqQrWBRuDzcHWYId+/apWi2SC/cGh 4ChwHDjZsnpkKjgTnAPOA7PApZY1IqvBjeB2cA94GDxlWTNyXqgVGAUNmAYWs6ylM8By4FVgdbAO 2KDfgA79dGPwVrAF2ApsC3boN6B3P90V7An2B4eAI8DR/W209ThwIjgFnA7OBGeD8lpc2dpT6F84 st3dJajk/5dkX5P9U3r2X8TW0ih+mfB/5szFWSA7lPF/aP4m2Va3hK30/57k2Er91yz4t8lYEcad xCE8vcIdTv4Xxv82C/xtlvo/zP+3eTnG6+LoXEAZ+YU6/5+S7R2rsL1D/WtSEUjK3puu+JeOZey9 +V85yt9X//tHhyr8DVb8G/zncXPs3fyfM/VvsYa9+w+2r32m0Cz72mklbaEDdNaJOkWcCk4dp6nT 2unqDHbGOFOcWc58Z6WzxTngnFVRVURVVw+p8Wq6mqsWq7Vqhzqqkmy4FFfmBtyc23FPHsbjeTrP 5cW81u5fuV40yG3uecn5yEvOJ19yvviS8yUXnNt9w7svOI/YklGZtHPBeWzsxeeJsxf395td7D/t o4vPC7W62H+h7pecD73Efvol559ccr774vP0qpecD7vk/J1LztdePP4SZy5uL1Xg4vOyYy45H3vB ud23Zcdd0r4D58pW8QLBDMvPCY4VeqPFtTU03VaOcoG24lXhsXZ4bBgem/2V9ZUmPBYJj6XDY+WL R3Fl94tneVX6xefyhwUutK/e5uLzmjsvPq+16pLz1Ref1+56yXn3S85HXXI++pLz2RefX9Pwgqyz Qt1Gl5x3uti+bpdLzi9tH3zJ+ZBLzodevKrXDbY0NlIdnRepizMVd5kO9h85k53J8pzRK2R18jdB 2Yt5CS+fWDjKsX3xN0gd/A1SsShAkcTzfiIx3o/5ET9qNRHniHPE2h13jlu7bCeblHPaOU1snjZP k2ueMc/YO7VkkOKbuKmMSBVQcr1U8mydKMiF+Equas89zsf2XsqpnEoOp3Ga7VGJKxFzFa5iR+84 le2M0u27qr40lZbTTspx0uxMonZuaYmXSSXGJ6ZYPp94xXKCjUGqvUdk2Ipb1b57q+9XJlapdtxV cEz4Ve2xkD2vhmPCL0HKnpWyTPgZlhIxyftiVNovR2znG/PL45jwK9hj1J5XxDFxgWWl0PLK0PKq 0PLq0PIf430B452I8U7CeP/RMhktL6LlpQtb/FSMsABGmIYR/qMlHS1F0FIMLYq0sv/s5o0r+S58 qrK9VSEbeU6MSzxHrh1dhOwa2lXU1o+j5FPe4FUB4Xeft8eaElbTcXKcHLuyeU6ejZanPHLh14Pf CPxqVUwVo6gqrUpTiqqgKlCMb+FbKO5lepmU8Hp6PSmf19vrTcaz71LI94Z6QynVG+YNo/zeCG8E FTBdTBcqaLqarpRmupvuVMhkmkxKNz1NTypsepveVMT0NX2pqOlv+lMxM9AMxO/Uf5RKmMfMY1TS PG4ep1JmuBlOl5knzBOUYZ40T9Ll5inzFJVGTl6BnCxjnjPPUVnzlnmLypn3zHtU3rxv3qcK5gPz AVU0n5hPqJKZZ+bZMvW5+ZyuMgvMArraZJksqmwWm8VUxSw1S6mqWW6WUzWzyqyi6maNWUM1zDqz jmqaDWYD1TIbzUaqbTabzXSN+dn8THXMNrONrjW/mF+orvnV/Er1zC6zi+qb38xvdJ3Za/ZSA7Pf 7Kfrze/md2poDplDdIM5Yo5QI3PMHKMbzQlzghqbk+Yk3WTOmDN0szlrzlITk2NyqKk5b87TLSZp knSrLy8TbvPZZ2qG9b4d693c5kqM7rC5kqAWvrHZcqefarOrpV/AZtddfprNrrv9dJtV9/hFbFa1 8ovZrLrXL2H3SGu/lN0j9/kZdo+08cv4Zeh+/D77tn4tvxY94F/jX0Pt/Gv9a+lBv55fD889Rtr9 MdJmku/4NNwp5pSkEagro5w2Tlt6ysl0etAY/D3jsU4fpz8964x1xtLz9rXGKzTBOeGcoInOGecM TXLOOedoshQielFFVIReUgmVoJdVfpWfpqh0lU6vqOKqOL2qrlBX0GuqoqpIU1VV1YKmqf5qAC1W g9QgWqKGqCH0tXpcDaNv1Cg1ipaqp9XTtExNVpNpuXpZvUwr1Ey1mVbammToPNfkmpTkRtyY8iSn HcXTeJrDbn/3Tcf1eng9nOpeL6+XU8Pr4/Vxanr9vH5OLe9x73GntjfcG+5c4z3hPeHU8X6JTHSu jb0Se9c5FlsTb+IkE60Sz6pHE28m9qgP883O95E6mW9Zvg0qxzQ1zTlqHjYPs2+6mW6cah4xj3B+ 08P04AKml+nFBU0f04fTTD/TjwuZAWYAp5tBZhAXNkPMEC5ihpqhXNQMM8O4mBlhRnBxM9KM5BJm lBnFJc1oM5pLmTFmDF9mxpqxnGHGm/F8uZlpZnJpM9vM5ivMHDOHy5i5Zi6XNZ+aT7mc+cx8xuXN F+YLrmAWmoVc0Swyi7iS+cp8xVeaZWYZX2VWmBV8tfnefM+VzVqzlquY9WY9VzU/mh+5mvnJ/MTV zRazhWuYrWYr1zTbzXauZXaYHVzb7DQ7+Rqz2+zmOmaP2cPXmn1mH9c1B8wBrmcOmoNc3xw2h/k6 c9Qc5QbmuDnO15tsk80NzSlzim8wf5g/uJH50/zJN5pz5hw3Nrkml28yeSaPb7YJ6HAT3/Vdbupr X/Mtfoqfwrf6cT/Ot/n5/HzczLf/8e1+fj8/N/cL+gX5Dr+QX4hb+IX9wnynX9Qvyi394n5xvssv 6Zfku/3L/Mv4Hv9y/3Ju5Zf1y/K9fg2/Brf2a/u1+T6/jl+H2/h1/bp8v1/fv47b4n2eg9dTNVFr r5R7n/OA84BVd3Y6k+N+4X5BSkd1lDg6KjrK7p7/VuP/VuP/TDX+3+wrhuyTV+zK6RbZ+98c+2+O /YdyzPG629f8qU5pVZNvdltTCapLjehWaklt7LuO7vb1+xD7emAsTaRXaQbNpk9oAX1Dq2gDbaXd dJCy7St7ciJOImUxccqXKQtSvsJxYcoSHLNSvsZxUcq39rjASktxXJCyDMeFKctxzEpZgeOilO/s caG1W4XjgpTvcVyYshrHrJQ1OC5KWWePWdZuPY4LUn7AcWHKBhyzUn7EcVHKT/a4yNptwnFBymYc F6ZswTEr5WccF6V8Q8q2rrRcmLLWMitlo+WifyMi2zDzL1O2h5H5JYzMjjAyv4aR2RlGZlcYkd1h RH4LI7I3jMi+MCL7w4gcCCPyexiRQ2FEDocRORJG5GgYkWNhRE6EEckOI3IyjMipMCKnw4hstfP/ MmUPInIQETn+b0bkjzAiZ8OI/BlGJCeMyLkwIrlhRJJhruQFkYlREJmYE0QmpoLIxDiITMwNIhLz gojEdBCRWDSISCwliEgsFkQkFg8iEssXRCRmgojE/CAisdQgIrH8YUTOICLnJVNiEYlILPHvRSRW MIhILC2ISKxQEJFYehCRWOEgIrGiQURixYKIxIqHESkRRqRkGJHLwohkhBG5PMiVWOkwMleEkSkT RqZsGJlyYWTKhxGpGEakUhiRK8OIXBVG5OogIrECEpFYEUSklGRKrMK/GZEqYUSqhhGpFkakehiR GmFEaoURqR1G5JowInXCiFwbRqReGJH6YUSuCyPSIIzI9WFEbggj0iiMyI1hRBqHuXJTGJmbw8g0 CSPTNIzMLWFkKiMiNRGRuohIQ8kU+UurMm48o2tNFZ0N6nVuxndwF36Yu/Mj3I8H8CB+lB/nMfwM j+VneRw/Z9+77ObfeA/v5X28nw/w73yQD/FhPsJH+Rgf5xOczSf5FJ/ON1T+Bpqz3llvLzBdfgKa b+PbSHFzbk7MnbgzudyVu1GE+3JfinJ/7k8pPJAH2lcCg3kwxXkoD6UED+MnKR+/xq9RQV7Aaygt 32P5HiO7qvZVSMwt5V7mZriXu6XdK9wyblm3nFteZmZHdBrP+h0qcsGziavlKRdnioXtWT60KHGB ReUL2uxu5kxrTW6aK78proJbgeLhddPcQm66W9gt4hZ1i8lvRrQW/3td+QTAdwu4BV3Pjbjajbop bsyNuwk3n2vsW4hUN798/mHnNtwOQfoo9zq3ASXcG9wbSJ7A1KYi/A7P4jn8IS/lZbycV/BK/o5X 8fe8mtf8VcTliRq/zW9bj+/Kz47z+/y+jfdcnmvnsYC/tdfbzYf+n/e3rdX7tnUBL+QsXsSL+Ste wl/zN/ztX60xvL/D71jvs3iWfKuQ51jvH/KH1vtSuy4u5iHeK1PaX3r9i3kgZrvDmEm/v5ld6CfZ YPt5PdU8epJG0VM0mp6mMfSM3dfP0jj8feDnaQK9YHf5JPl2Ab1EL9MUesXu+ddoKk2j6fQ6vUFv 2grwFs2kt+kdepdm0Xu2HrxPc+gDmksf0kf0sa0On9I8+ow+py9oPn1pa8VCyqJFtJi+oiX0ta0c 39JSWkbLaQWtpO9sHfmeVtMaWkvraD39YKvKj7SRfqJNtJm20M+2xmyj7fQL7aBfaSftshXnN9pD e2kf7acD9LutP4foMB2ho3SMjtMJW41O0ik6TWfoDzpLf1IOnaPzlEtJyrMJ7ag7VUt1l7pb3aNa qXtVa3WfaqPuV23VA6qdelA9pNqrDqqj6qQ6qy7qYdVVdVPd1SMqU/VQPVUv1Vv1UW+oLepntVVt U9vVL2qH+lXtVLvUbvWb2qP2qn1qvzqgflcH1SF1mGPqiDrKcXVMHVcnVLY6qU6p0+qM+kOdVX+q HHVOnVe5Kqny7G3QYcXMLnscYc1RTuE7uSXfxXdzW36AH+L23IP78Ch+ikfz0zyJX+Gp/BF/zJ/y PJ7PX/JaXsfr+QfewD/yRv6JN/Fm3sI/81bextv5F97Bv/JO3uXWc+vLX152N7o/uZvcze4W92d3 q7vN3e7+4u5wf3V3urvc3e5v7h53r7vP3e8ecH93D7qH3MPuEfeoe8w97p5ws92T7in3tHvG/cM9 6/7p5rjn3PNurpt087z8Xrpupm/XzfUduoW+U7fUd+m79T26lb5Xt9b36Tb6ft1WP6Db6Qf1Q7q9 7qA76k66s+6iH9ZddTfdXT+iM3UP3dP+623/9bX/+usBeqAepAfrR/UQ/Zgeqh/Xw/RwPUI/oUfq J/Uo/ZT997Qeo5/RY/Wzepx+To/Xz+sJ+gU9UU/Sk/WL+iX9sp6iX9Gv6tf0VD1NT9ev6zf0m3qG fkvP1G/rd/S7epZ+T8/W7+s5+gM9V3+oP9df6Pn6S71AL9RZepFerL/SS/TX8neb9VK9TC/XK/RK /Z1epb/Xq/UavVav0+v1D3qD/lFv1D/pTXqz3qJ/1lv1Nr1d/6J36F/1Tr1L79a/6T16r96n9+sD +nd9UB/Sh/URfVQf08f1CZ2tT+pT+rQ+o//QZ/WfOkef0+d1bpSjbtSLRqI6Go2mRGPReDShP9If 60/0p3qe/kwndV6Uok5UxRbHvootiX0d+yb2bWxpbFlseWxFbGXsu9iq2Pex1fGv49/Ev40vjS+L L4+viK+MfxdfFV8dXxNfG18XXx//Ib4h/mN8Y/yn+Kb4zviu+O74b/E98b3xffH98QPx3+MH44fi h+NH4kfjx+LH4yfiJ+On4qfjZ+J/xM/G/4znxM8lvEQkoRPRREoilognEonURP5EwURaolAiPVE4 USRRNFEsUTxRIlEqUT5RMXFl4upElUS1RK3ENYlrE3UT9RL1E9clGiSu/x/2vgMsiqRbu6pneqaZ 6e6RoKAgklQUlBlyEkWCiggICCaQrAQFEeOiCArqGnBdI2tAzDnnhLuuOe+ac84JXXO4p4+o6Lr/ 7v/db7/97/9c67FOdZim65yq932runqGb8b78s15fz6AD+Rb8C35VnwQ35oPFhoIDQU7wV5oJDQW HAStoBMcBSfBWXARXAU3wV3wEDwFL8FbaCL4CE2FZoKv0FzwE/yFACFQaCG0FFoJQUJrIVhoI4QI oUKY0FYIFyKESKGdECVEC+2FDkJHoZPQWYgRYoUuQpwQLyQIiUKSkCykCF2FbkKqkCakCxnCJeGy cEW4KlwTrgs3hJvCLeG2cEe4K9wT7gPuWr6fkcWZ0TxmBgMIivOdM2VBwO/HZG2A30/IOso6kVOy WFkXcgY59JwsS5ZFzgPj5ZMLsnGyceSKbLJsMrmKzH4Nees68tYN5K2byFu3ZGtl68htZIi7cg+5 JyU4b8qwIitSLWvEGlEdzow6Ku4oHtKbSi9lU3ofZ0kfqw6oLjGM6o6aZYzVGrUP44hzpQk4SzoX 2L6C6IE6sCL2JAQUUAkwwFZAZ/gT6n2E0WiwVIEl6RlNNVKDmPECbNfmgeU0dXgN5Ja8wYdzeVAA GmmNiQFc1RwUQMP3T4/4OtJ+3hJyfd4ackO+LuTVeSfpk2In6YpiZ+mKYox0RbyWH1618hmNGApb ajEMckFs+9mRdngkCo9Ef3YkFo90wSNxeIQhehA1LcTOnZF+Y8uL8SIME8iAgmRaMa2InAllQgmr OqU6RRSqN6o3RKl2VbvC9Rh2PnPkb+LYzxn2/29+/c8wrMShf5U3/07OrKHMVPZU9lIWAQNJzBkG nBmNbNYZmGkK8mQicKTEju+5MesvsuKwP+HD37PhbODBTwxYlV3+H2PDT2zHyYDD537GisGgPiTt 8V55SLqjk7IjJ3+vOzgFqI4kUBwLUHMsVKZzLLTaKGipXaR2+YE7me6f8yYfxUfz7fkOfEe+E9+Z j+Fj+S58HB/PJ/CJfBKfzKfwXflufCqfxqfzGXx3vgefyWd9lW33fZ1vxVAxTGz7l1i34ve8K7YT o8To37GvwIu8BjnY4KssXBt4uA5vyVvzdT/wsdhZjEFOdvpDVvb7PS+LsWIXMe5fYufPudnvP8DO oZSh1WEoW4vaEiMaRiOJNT4ptaWxNJnY0a60K3GiqTSVONN02p240Ew6gLjTXDqB+NMSOo3E0jX0 EElgspkcMpDpwwwkg5k8Jp8MZ4Yww8hIZgQzmoxliplxZAI+85zCTGQA7XGMP13GywzIDFyBMVdW Q9aQzJPZyxzIZplO5k/KkfF/RcY/hqO34/Iy+SFym63OVqcmCqIgtKaCUTC0lgKGzdRUYawwpmaK 7xWTaG3FFMU0aqWYoSij9RWzFfOonWKBYjV1UKxVbKVeinLFYeqvOKo4TdspLiou0ljFFcU12kVx Q3GLJijuKAlNVjJKjn6jVIFCKFD6KgPpemVLZRDdymVyWXQ7l831pj9xfbm+dBeXy+XS3Vwel0f3 SE/R6F6uiCui+7jh3HC6nxvFjaIHuGKumB7kxnHj6CGuhCuhh7lp3DR6hCvlSulRbg63gP7CLeOW 0ZN6QXpB9JRqvmoBPa1apFpKz6qWqzbSi6rNqs30DrDtJXpX9UbN0t+AbX3oW3VL9UxGqZ6lLmfi +WuCLZMn/CJcZH56vxIGxqRL8blLDE2p3LO2yh5KPMGN7xVIPVA2znB8DiQpXwraYA5aaWtL5dYW 2DoHSVqPY0ftoO00po2B9NypO1yzBW0BFNOatiZyOplOxvU4u0k8a8PWZeux9VlbtgHbkLVj7dlG bGPWgdWyOtaRdWKdWRfWlXVj3VkP1pP1Yr3ZJvQX+is9Ro/TE/QkPUVP0zP0LD1Hz9ML9CK9RC/T K/QqvUav0xv0Jr0lfVscvSuXyeWyp7JnsueyF7KXsley17I3sreyd/+dfXKoipzB+QY5rpjVx2da JpBkxAySHNdjsuA9e6IkDpA48KonqEVvSCriA0lN/EkA4UlrSCKJhqQhHUhHUImxkAxIEiRD0g2S EelFckh10p8MIMYkD1JNXB9Vi2poNWIKPbUWqU3NqTkxx5UNdXDFlAX02o7EEp/tWmF/taYZNIPY 4FqHurQ37UPq0YF0IPTsEXQEaUBH0lGkIR1LxxJ76MclpBH04zWkMS2n24kD3Ul3ER3dT/cTJ5x1 csb+54rKOgjnnmJx7ikOZ8RqVZkRc8B1V14MKFRSm9ExOtCProyr9B4e4w9Hgpgg0I/hTDjox2gm mrCggpKJAvRPOlGqDqoOE051VHWcqFV3VfdINdUDVQUxUJupa5Ma6jpqK2KirqtuQMyATXYQS+CS vcRG4gnSAHjiBrGTUJ04AKqbER1guTVxATyvS1wB0RsQN0B1O+IOI61GxAOQ3YF4ArrriBcgvBPE 6su6aLEurZg0qIv5Z3XxYDzgiFQjGRMGIxs51ojFGilA7XUkSqwXB1quJ9HDeqmwXgLWywDrZaR6 onpKTFTPVa+JKdbRAutopW6kdiD11Dq1C9RLqmljrKkOa+qKNXUHNrxDvIELK0hTrHUA1roFsJQ3 aQ0c5QfjlPfPYIOhfyZhjXRSHaXvNCSelXXUVZ5jC713LJ34cR9DF9LlsGX08TzoAV/xgTcDfkNP yDG2LPpDgf5Qoj849IceqN8YokKvqDHaPPpGUM1QzSAijM93EA2MwU5CzE+rLhEz1R3wio3qrZqF GmvAEz5qN7UPSQYlcYB0B81wnAwAjVBBCkABvCITgPHrkGkY8/UY8w3A4/XJRoz8Joz8Zoz8Foz8 Voz8Nox8OfC7C9kOHO9GfgSe9yM/AasHk4OgdGLJcVA3Xcl5UDRZ5Dpok7bkPmiMaPIImD4OxgGA hDBO6kmINI4kzaW5BtJWWnNDItTb+ZHkIHwmkU75y+fh94r+TWd/bA8kAaPqiG0+rEp7cPzUHkgk 8fm4jyGBMEL91B4cpflu1WXVbULUCrVI9NRN4a8ZSHtxrP/+TizxHrSVd/nhXj0Bzf4FdIdPVq9c KyphIUUslCEWyhELWcRCBWKhErGQQyzUQyxUIRaqEQt5xEIRsVCDWFgNsdAAsdAQsdAIsbA6YqEx YmFNQtmTEl8yIbJydjO7kz1Mmv3pcyGGqqgB3KsVbUgdqSdtToNoONxjAk2jWbQPaKkCOpyOoePh b5fSuXQxXUnX0610B91LD4OHzoI3btL79Al9CTSkYHjGgDFhzBkbpiF42pU2BB/Ygkcaoe0IPCzZ GOqBNpZ6ou1CvdDGUW+08bQJ2gTqgzaRNkWbRJuhTaa+aFOoP9pUGog2A7hdspk0FG0JaypZ+VrW DO06trZkNb6csWRZY85EsoqlXE20u7haaHdz+DkYruDnlHocfk6p4swlCzqqDtpCTQv8O2m0AWCS BhQHA1v2kHcE3SGpGAfIY6kW8i4UUApqCG0T6ucEeQIFRQN1c4E8ibpCnkzdIE+hzaW1KNQP8nQa AHkGKBcGatUS8izaCvKeNAjybBoMeQltA/lUGgL5D6wJYaC+NSFfx0prYH05gTBQUxHCs5TTQL6L qwb5bk5fWl3FQa+A+hlCruKMCAN1qw55IWkAPawzMH8GMH4uGUpGkfFkKplNFpPVZDPZQfaTX8lZ cpXcBZSpfL4ILckEWrwNtCUtdaXe0Jpa0hAaCd6Ig1pl0IXgrRLw0CK0MXQx2li6BG0XuhRtHF2G NgEwXrKJdAXaeLoSbRJdhTaZrkabwjWQLNRRam0lUEs7tLs4e7S7Oan1lUBdG6PV4xzQqjitZKHG OrSFdDrGbwZGrhQjNxMjV4aRm4Uxm40xm4NRnIuRm4eRm4+RWyDFg7NAj1uix63Q49bocRv0eF30 eD30eH30uC163OMvePo1lYOfjagZeNmeOn/Fx9m0Hx1Eh9JvJcaEVlFG59OldDXdCIixE5DiKGDa ecCv2/Qhfco5ERmrphrOFW1HrjnaGM4PbSznj7YLF4A2jgtEG8+1QJvAtUSbyLWSLGPABeF2Mtca bQoXgjaVC0ObwbVDm8l1QFvCJUoWfJUkWfBWMtpdXAra3VxXyYLPuqHV41LRqrg0yYLn0tEWclKv 0nDQn2BL6k8dOaknxXCS7o/lPKQocp5SFDkvKXKctxRLrokUS85HiiLXVIoi10yKIif1qlRO6lXp XKjU/7i2Uv/jwqX+x0VI/Y+LlPofF4Xxjpb6H9de6n9cR4x9J4x9Z4x9DMY+FmPfBWMfh7GPx9gn YOwpkXM1pDvGku+HkiYQ311gkUEI4j8Ff6nh89LLEzJNIJzBwjkh+FaJLTCf94dZU1oDccgY8cNE uk/pirTmx1I3qZYSOwPjTEQcwVx6mkurAYcRWh3G3xS5ikEGkpTXVLIPfOzIOXHOnAvnyrlx7pwH 58l5cd5cE86Ha8o145pzfpw/F8AFci24llwrLohrzQVzbbgQLpQL49py4VwEF8m146K4aK4914G2 o9G0A21Po2g31XTQXKXvn4kwvZlBzHBmgqxEtkC2kjVn67AWrCVrxVprmmv8NP5KqgngOnKduM5c DBfLdeHiuHgugfPlErkkLplL4bpy3bhULo1LBy1wRXVVdU11XXVDdVN1S3UbdIFSzan11Cq1Ws2r BbWoaSK2FFuJQWJrMVhsI4aAZmim9lU3V/up/dUB6kB1C/UJ9Un1KfVp9Rn1WfU59Xn1BfVr9Rv1 W/U7HlzIM7yMl/MWvBVvw9fjbfmGvD3fmNfyjrwz78q78234ED6UD+Pb8uF8BB/Jt+N78tl8Lz6H 78334fvy/fj+/AD+Gz6XH8gP4vP4wXw+X8AP4YfyhXwRP4wfzo/gv+VHiuFihBgpthc7iB01Ppqm mmZivJggJkLcGkA7iYS4STMjjWBs0BpUcRqTQXRMDpNDnJmBzEDigmu8XXG+ww1nMdzxWYWHbIVs BfFkTYAjvRQbFBuJr2K7YjvxU0qv0fhLr1GQAE4A5guUxvmkgzTOJwlqG7UdSZdG+6SX+iDo3lz1 Y1C8hXwdULxjeEvekhSj7h2Luvc71L3jUPd+j7p3POreCah7J6LunYS6dzLq3imoe0t4f1C8P/BR oHJno8rdhir3R7ETqNyfoeYbSce/EuN/MaZ/Q+Q+xkyF3iToTT30owH60RT9aIM1b4Q1d8Wat8Wa R6K+j34/a8KKrD7iRBDZA3lzYl61F33Zrv+4hb5vTXAFfWw7BNuODCOswHiKGE8NxrMaxlMf42mA 8TTEeBphPKtjPGtgPI0xniYYz5oYz1oQtxhiWnn3Gtagyt2LMFar7PcSEmHLJdhyKbZcBluurPKz 1VjDKp81ATX9EUveY4QmAPFMmj0k2KpZbNVKbM/Sm1vfkub/bjyrilRK+tcQCu/SFnQrwR5oi72u MfY3h/fzVPQRfUpfVapsfaYGY8pYMw1krdjubCbbk+3FDmTz2Hyxq5gqpovdxUyxp9hL7C32FQeI ueIgcbBYIA4Vi8Th4rfiGHG2uFBcLC4VV4lrxHXiJnGLuE38Wdwl7hMPiofFX8Rj4knxtHhWPC9e FC+LV8Xr4k3xtnhXvC8+FCvEJ+Iz8YX4SnwjvtNQjVyj1Ohp1BpBo9Hoaww11TXGmpoaU01tTR2N paauxknjqnHXeGq8/3dt9f+urf63vU1VDVRRCmus8QU9VfiX3h0BvKBpiutVVvpz0kq4j+vo/g9r 4T6uooNrME2Y2CrziNKe1oCTH2fj6BPyDMa+Low7nOEH+0KZtkwU04HpzCQBomYBNv8kPbv+WpKe V1dNcJXPk/vvk/R0u2qSnoV/Nfl9kQKlJ+WfpdDfJ+mpedUEdfmDBKz1WYI6f546fC0By32WwEuf p1hMn7aTvkhdIaX9Qcr6WgJG/TxFfZG6fJG6fZ4q64d3+/4K/zv7+Aezj5ScB5b3BkUifWdTJH7/ 05ff/TQRxrplZD5ZCqPdjaSc7ITx7lFyEvynxTUd/7e5+7+Uh/4r+VfnGN/PQPJgyuhCOMdPGkcB 19XAkVctfI+8AZVGlWF0ApQn0klQnkynQXk6XQ3lNfSB9A3a9BGR0Qr8DaHf6FMoP6MvkDNfQfk1 fQvld4z0a04MI4c2xzIKKCsZ6Vun1QwPZQF/G6kaow9lA8YIytWZGlA2xt89qsWYQtmMsYSyFWMN ZRvpV5SAYxtAuSHTEMp2jB2U7Rl7Iv06VCMoN2ak3zD7gfkBylOZqVCexkyD8nSZ9AuCLYGZZbIg 1hhGqZKKYUAJhUrfUM+2hXF6OJsO5Qy2F5Rz2G+gnMvmQ7mAHQPlYrYYymPxt9X3sfugvJ/jCQUF JM1H1YDRMeWMOR2UHfVWEKq3Um8lkemtEsBXwkPhIZEJj0QloSInqolM5EFbUzEJNIdM0wQ0IIWR cgvCaFpquhJa+d0yEp4nVL6x/0mPUNQjFPUIrfLWOEU9QlGPUNQjFPUIRT1CUY9Q1CMU9QhFPUJR j1DUIxT1yPs7ZFCVUFQlFFUJRVVCUZVQVCUUVQlFVUJRlVBUJRRVCUVVQlGVUFQlFFUJRVVCUZVQ VCUUVQlFVUJRlVBUJRRVCUVVQlGVUFQlFFUJRVVCUZVQVCUUVQlFVUJRlVBUJRRVCUVVQlGVUFQl FFUJRVVCUZVQVCUUVQlFVUJRlVBUJRRVCUVVQlGVUFQlFFUJRVVCUZVQVCUUVQlFVUJRlVBUJRRV CUVVQlGVUFQlFFUJRVVCUZVQVCUUVQlFVUJRlVBUJRRVCUVVQlGVUFQlFFUJRVVCUZVQVCUfvqHo 4/cVmfYCa4R7iWm6tsC0q0KvYVHLomcCVTKlBabtYVckQ6lOrdVTsHaijKnFEm28QmWnoHJa4MZQ eWmEtq3WvsoeszLzwWb48NabhJIE0otkAqAmkxz4Lz3M9dFaVrmY3OjcCNXy50Ybitxq/joi43In WXKbwJulBTUaagvkBtoC5mWpjKEMAMV2MtLbe7j+EZ+niXcvNNMKH++UyuGesnR22gYKWTu52tDK LzOrf3Zq1245FraJDSx0Hh5uFm1SE7Mze2Wm5Fj4ZWZnNdaZa83en1z98yOZ2fE5qZk9dJbaOtJx maHJp+PhmZk5Fr69c7plZqfm9NeaGwseblqdTqt108K/jsaCo1bn6KSr3PwH7qiAWlV1C2WJrACa HexXMQWUkgXMlu1Z170qQkxtZ0zqF6u9XbZgdN0uz99OCJ617u20Mguf3LZlP5QVxzmmH2me1P/+ 4j57Ik9X3JlaZFY8Y2jKqp/TByRYH6/tfV5Dx92cuGNbo5SSkm71phz2tN/Gr2lfb3vgDZWP+0T7 BbYe8++2GtL8ylDNppKMdvGLC3JnxjXqG3xryuokr5IwMx1nYzRjwY3v7EyuN5mcaBTXnk2eUdst fNizeQ/GMztNf9nWLmDViMHbPO9Gjg9Z+mbegO45IctM9k/Us7Uk0WPjUt02tTZQeke96/RqdoqK m3s0Pyr6wVqv2Br5feWnn25dOnjC2+UH8o7Pq5Xd2Xvv5ofcLCvtKkXhnlUWfQ0LLzAyaPiz8udr 8+do88vAm7WpPL9Emz9pcLVOh7MepGZPt247yGhlmzHv9s3M/s/Hr+BP2rhMiuGEm+ry0Y8nmbjc W09tTvbVf9w5znHGdPU+H/a74cV7PK9bVjyM/t5+TWmL3QkPXp/Y7+XVcYFrZOpbm+5N9+xfeJ7N Pacb3WRGtay0TW8NQk1Sy18f9rui39Ei9HbCN8sW1txt51a30dbkmQbf1tUkznoWafbCcs/x6o/D F/fwc1S+KTB+fq1rhtD26ZZH4bu23NihfW2h0xtee0KDWm2O1WbmPBp8Uba605MV53ZH309utSs8 cu1qma3Bu7HHH3LFg9ZP+nmRm/3VAVfn973Sp5QcTmu6/ajrtxd9Dea7pJmmnXG59KuZ/Or8APnu jk7uPdqYCQnrVGWjfjkW2TTwgFm7uVlnDDyHfd97xryjpYAKcdoCWfB7VFA1XqR/Nuxd52n7yj9g Su1/Cgyg37s7wj9AAEcAA50jbLp8AIP+iKBwEYUh0y5CZ6jVlzY4Q1V0fK9uqT265sCfqaYVpZ1K Q2V4clL3zB5JH25M9Uc3Zq21fH9jtaoeT0q2iEjt2gOuahHm5/unqLCu/8DjMasCPOY7L9adflHX pVXf8ld1pu8K6PngSODNX0f9lB4cnvBkCvNTm5OtMhxsfJK3HbRep265Lq/3uYAtC4vFsJ/r2lWU 3hCs6xzxtXmZMOVQzYA53wfVmXJglYPVT0GNcjNPVTf3GuVRzePclgZPUrwaUcd3b+u3nLsmgw6b +mrjysS8ghedS/OHFo5ZXrF+/KxD7nPDCo3rDws5p31KmjzZ+aJJ/taiexke8xo7P13deJlqYMJ3 /VKmTu4lFC2r2PHYYkOowejEffanHANq3t8UNNErLMLkYErb/guXDNsd5TOjIGx4D3aFy/ZvbLaE pzSZErLfbpBTj6EtFEemHw4qYnoUkdnlwy5EVKLCS23+M62hBAp15bxWpeCA0FhWKZP9z4AKjXSP htIP57JaGRhtbWmHKK8hN9pf+2AfktVp2aPTO0JK2vo3nuWf+FCrlg5r5HLoRkVVug5izDeLlg4K qldxcHNITln7+jkNe68qerMoeHw/0ubW3jsmZ1N/FstyHzN+O/cO2/88Yv+PM7ZEZT5M9F/gT+5P 3F1yzGy9ekZNYfyJ0+ZLGgx8cG9ur8XF5z3GNJmcttm9+9Hhy6zfXLh1PFXvu+Fb3l4im5wfP8t9 Uc2gMXunwcTvm6fb9lznXnxRKeyJ6XZgy2Df9JT5m9ZtGuO8t0JWLXfAb0cvNr/wzdtLlxa/fXrh mLAq6/i4K6Fr3ctyG/3a5IyzOsGNmZGfZj3iaefE4uUdN3mciBvVbmgtp9+8JpcW8GVdRq6yXzdz zr5Fpy3WbtPWLLQwEhpuDn/iezFWe2Wcbeqw7VmXH89bdHBw8+w+ImBMGmBMeCXGxGv6tUGFJKva j1jAmX+wV38AHCetFhDHCQBH66F1lDadpE1tzt9ya5XHZX9w/E+xpuyMavShH7e3+uHAQk/nJdYd 0s9kbLW0Wjd+9+2l23Yeq/ejo/7Izadj7F+5RplXt1taLJwzmtXDNjivRlPfxaObrQgcLpzKH79k kuJwtH+fzrcfvRYv5+XMctqXc+3BlfiZg2TrAt4d8zE4tnxvrHD4m4p1hsLruDTbwt6j1i3ZXHjT ePXYrb/VWJsQc0//gud9y04jlw3u9VPAlQkj+sb9cGNJ3+1uo52MHAzPJOxZWmtB6OSuS3618ND2 vDi6a+DlnWZPhLAcX4ebrE2aZXqr5eN2rPTY1XxO984mQYuKT4wZ4tNP1eLk7JVDrX+6XPFNyoqg nC31fFtPjTeKC9HuLnh8WJ2Ve79dm75HuXZ98iux5rk2/zf0fW2N1GOhEyrKq3TYx5bNxuS2fR7Z evI14xNpQ5zZxvVufh2aJJyobS030dYY/PVu7i+dUEfeROul9Sh1K3UpcuqWk5Pl6eCQmJ3RuPuH GDZOzOzukJWeKu11yMrOTOqdmNPLwS8CGlpj2KVt+eFPgg7x1npq3T9sa5ki+8oL9u3b92sXTM6u cqWcLzoQok2z6MyIrtMthjhT8bpxa+8ld07m590X+uf0DZ3UwuQxqZ466EzC2LI3XWdOvWrb4GW7 E1Pehm2L1Vu1Ye69gseTzTM7vPzt0SX+l5GcTw1jiyPlawJacPXiovVaj3/I7d/YpsfDyy0NbF1G WmZf6LJ2WaqBzfj7t5z1zgzqkTlOFb63YXCrhY72RTdn7o+pt3mz98VOK4eoN7qYhQ4NaPFu0/iZ HZQLJp7rtyU6b868kP0VS6aW+F7e19nG52yec4uQp4d2fzPtzto9UxONIpYtKXlwYtuh0pmLJuwd YDfMvnzXqdcZstPb3Jc8OtK5prGm/NnewXOrcbXOjbW+sXxmsM/t5fr1+onb7TfMTt9V7A1oMw3Q pvAD2rTKvYdow/5zaBOZ2j25V05896yqaOOq9dC5anUuLo4ob3S46aiVNrX5c/+We6uvrfueKM17 +KVmdUvOtvCPCLAIiAjx1Gn93Ru5uDu7NfJrHuj+4USZofkfVCIiObtPamLynwLU7Y1s4u5T/ZcO 9feZs2rHveDpNhc8+pjrHXcMat/vqN2pOcqxD240ebWlXu6sV9cGDnI8dKrJSA+3iucnvZxr/Dqu 4JXz3W6F2bWKL64Pvri+8LGTitle1qeXS3DMo3WXggbWXj++35l35oXVmwf2PJhXP9rgyJBQr0Mv zz8dea8puXLsfPwL49GtZ+d7/5ba7PalEduUoRtzvrnFX2txe1HGo2Nd87nnNfYONNzU67Je8MuE V/dKPUo8397R3x1vntD+pCpyyDGv1q0vt9viEFdrzDjW73TMnQKV9SS9UlaXPPL7EHNfy7JxY98E +AdkuqwIcFuSuiD5hbPfCuMfvTwuVRtVUWvYlciwOl7TdEuqAtQnQBqU/bBx06gGF+s+67aevm59 adChKz6fYU/mzZCmkzY4L2pdVLx56u3FXr5+Ow//t7Anp1dWYvy/BXs+XCnnawjK/Q6FvwJQqQMK 9PgaR84fChzReNsR5wH5efVtfRs+/sVynDhpSZeI2AYv7m2PDJo/8JnhYbXRizYVRdVJjytDatsG zLP3cDyXWeLW8b51eHGkbHTTeVOT3J+67jbyW+vpM3mP8FPPfNvHKfN0lzvHFL8ID7/U+c73Y6el 6gWPOHKkT7CzkHYp13+eXachkXkBNjXr7vg28Oe6V2oOTm1g9NR450Mr+/zAWLsnL+bu7Otjnfli blLhmLIEYUEj8/nXxvrkvVs+5vWku4/eyJcdaHWwY87il48N65h6HJy1+vjmJ6vv715SEWX+yvvR 7uMN/Tdvm9p0YIrJgZUWiaq9zZokO9bMXbm+yfZ6LUOsak7pMUq7/dF3nwNUtTT1lNByUneR/pmA Ou0HdC37Eqb+mcFXJTppnZ3dJHTygM1/YPD1O+D8M7w569bj1bLdzYN6muw+2NInovzlIqON9o6b DELDdw+55+N0qpVunO3a75Iu1gkbuvHH1kfy2OcPem8duWv+saWpWSn96qfcXLvuQeGGA/cXvjGY re5g1cDhULNTUXLTPmu6J3UPijxz7tH5bTOG7Bp8IS+YcRv/W/l0Lsq8W4sDp8r7dHYYuLaufHVU pzSzxHeDc73vH5PXbePRN0cZ82Pnk0Vu9r33iLfNPfRy+7ydltFjwMW7PsWTpvcUuzQMNUmIc5x+ dEiInVXnbgEjzzsMrRa28sWaWqMz7tf9wfD5vmonCsUnBX16ue6cMKBsf5ziLru8yGnd8/GdhvoO bV84vsfyOvYt92dO9buYdjOv3pj093hTQG3BIzZf76H/I4Zf1RR6lROg1ak0piJV0POr4Fjz4weM GDlvriIRpDdJIH7E9/Oh2e/GdV8BqPFt9HU/5oZt0h8zM15JxVFZAaMf9Irc0lSPbfRufduIQrN7 Ht+tmxWlPj9qrZfpkVeL5+1Zt6KtpWkmlzooXVZmFXgvY3X3XKv1gb8MfTxas1X5rev2O4NuZcUE zBh3dP/Bc2PKL21reCD37p6ljseGbdiXuMP1iInltj7nvUpWmfaabjn85OrVBpGjnkz9MTmoxLbe 1LhvNV67DJP7tdx0aMkQz9DlCe3Pa2/d8qh9ZUTFaY/8F4aWo5IGJyrkEytKGD+HbwKHb3zHnEp+ EXT+tCzn+1VsD37/tLO28bktHxlP1bd0Z8yGLVb8PNFx/bVmOyOabFkw4vzNFLfRT6wmTt2/vG9k W8/j2f4rrZ/qCuTLAKQWMZRq84f9g6Oyz8aKn+a4S/NPa40+xtuW6pQyFt8TkFpBZTD1ZDq+6rQ6 3M2nLbVO1FY9Wl1r/emDch20scvLRvSee8Hj+7nF5fM7PkjTf/xtq9rapCof4XVR2sjShoNtSRuS ShJJNsnEmfkUkkMsSCTpT7Jgqyvsj4dSN9J/Zr3BNn9Irzn9szK7Zsdndetv8QW8yQsoGeLVtnCf /ZYZ20feKW1eFnzW7u4Jq7WDndtuW9x+zdzxS9wDZgQPMLt4Y2HSS7fq8Slv04u7hc0PyV4hjL/Z +7fiVtOf3FjWPubq0WprjBqtbPrrzZfkuzt9Ljbr7tVhdXL7diNKPDijIvuWewpcX13eZFTePY+q feutfBHWbLa3V1vTfqVdBna+H9B/4eGH+oPEuHs/DGs5tMg+RNFpR5jrnehn8wMtVlWs7p2nvGbb 7HmjHkU/NZu7IGpwfszpGbOp7aOav/4yMXr6qj5x2ktRee1Nh/uTw6sa2azJjphtNjT3RfeGV2Wy at9Otpp7znDXtr2TQ0aemGj0SP/eGyE0UVzf8OzRK0ayGXf6Rt6dN7OAqaMtYEw/xUihK2B42MX9 x5vol4z02QBDWdlES2O0JlVbovrTUyAKf/PjEVanAap112kdgWgdPZyBW79siGMeb/AdZxbzS96j c3uvO5Rcd6k79fEXmCU1kcNpqZpuR2/uqt++V+Q1x8DQcz9P3FDP1nFKweE1OVtzQqPsT8667vby yothd2J7lx89lrghrYWV7/5R/xXKADX/pAf0oo1TR8F3HJYkbS4BIQ7K7NprR1X575Xa3sR9OPK4 UgsK8jIHMn/zJ2Ngg3jd/PmWtyvUQQJ6KSm1zB92FySJmBqLqYha4KYu1EBARv4n0BBXEIWjsgl0 iVKMNuIe4QLz6M9pQBbNIlawqhiqyA8a6mZxGIZEi8TiNbdnBCpBV55HoKhUggaf3JjJpXt37GUh /krB9Bc9NK1OPLyzuORZUvZlKhVZAETnqyNQdRojWbUMPO7odPnjpkJ4haIs69y8Uork1rANAPPJ 9eANCmVuZHN0cmVhbQ0KZW5kb2JqDQo1MzggMCBvYmoNCjw8L1R5cGUvWFJlZi9TaXplIDUzOC9X WyAxIDQgMl0gL1Jvb3QgMSAwIFIvSW5mbyAxMzcgMCBSL0lEWzwzQTEzNTEwRjU0OTc0QzRGQjdD RDJGMDk3REE2RTI1Qz48M0ExMzUxMEY1NDk3NEM0RkI3Q0QyRjA5N0RBNkUyNUM+XSAvRmlsdGVy L0ZsYXRlRGVjb2RlL0xlbmd0aCAxMjUyPj4NCnN0cmVhbQ0KeJwt13ecz3UAx/Hf+/c7l3HKiIQ4 I1IaSsTF1Rm57kJGy86KqwiR7TJKdouyGoi0aNirUFbZJefucFQiFFln/O79+t4f93x87n6/z/f7 +3zH6/sLhaI/V68q+rtoKJTHMKMmJjzRxCwz1WuZhGxTv5dJjDHp3U3mLpPFLNm8JHuuOdjaHEox h7uZnB15KK65KXPJlBtnylc08SNN5bUmNdG0OWbaVoG2pv1x02Go6RiGeFhnOhWCXNO5nene0fQ4 ZXqmmzR/TPVisj6FYZbpe9YM6GoGMho0xgxm6hHMMj9kliw0yxNgq1kxxKysDvvN6npm3VSzvios NRtLm02s2WmvWTjkNQtHvGbhmLImnw9AuEBLU+iwietnCu81xaaYukVM8gqTmgIZpmkz02KzGZRs xp4x40eZCSVgkZlU3EzJNMu8uuFN+c2WaWZrNbNthtnuQxzeudjsamB2lzd7vILhfaNNBhvKmGcy C5qDA00Oo5yZ5mjEHBtsTsTBbHMyyZw5Yc6xSueLwgZzwedZ+KKPZvhSqsnlJbks3eXp5sqqPCIh H6NI1fmmditT54ip6y1EEk6aRC9yJCkVskyDNPDxizSsCcNNo/6m8T6TXMqkLDCpSRCdOnqihybr BXgReplQQQhe0jv6hqbxwSgkCEMEYuA6yAexUADyQxEoxNQvMYqDwnADXA8VoChv6MOoGBSHG6E8 lIOSUAJugVJwE5SGm6EslIF4uA8qsvW+jCpBZbgVasDdUBWqQDW4De6CO+B2uBOqwz1wLzSCmuxE P0b3Qy2oDUnwMNSBB+AhSIC6UA8ehESoDw2hATwJjdmJlxk9Ak0gGVpBS0iBR6EpPAap0ByaQQt4 HJ6A1hAcgKfYif6MnoZnoA0EZ1ZvaAdtoQt0gPbQCTpCZ3gWgsuCiyTUFZ6DbtAdnoce0BPSgEst FJzCY4CjqQGMgmUNPljwx1EwEgbCKzAYBsGrMBSGwHAYBukwAkbDu/Aa+xJM/TqMhTfgLXgTxsM4 mAgTYApMhknwDrwNc2Eqmw0+2DR4D96Hj+BDmAHTYRbMhA9gNsyBj2EFzGN7wZp9AvNhASyDpbAQ PoUv4HP4DL6CL2EJLIZF8A18Dd/Bt7AcdsBKdjA4tqtgNayBX+BnWAdr4Sf4Eb6HDfADrIeNsBk2 wTbYCltgOxyEnexgcILtgt2wBzLhAPwKeyED9sFvsB9+h2zIgtNwiM0Gp/dhyIEj8A+cgOPwNxyF v+AP+BOOwSk4yYaCjv3LKLiA/oMzcJb/kUEFUTwH/8MFOA+X4CJchly4CleYjNAqiDCFFcUTaRWX tsiuKKzorYJg0lsFvSXsIrQiu6K3orcirQqKR1rF7ULEVKRVVFRkV2RXxFSEVsRUhFZEWIRWhF2E VoRIpFXcpURhRWFFTEW5RNxEU0VvRepEU0V2RVNFb0UpRTdFdhWklTKLhosIi7CLFosHAlFf0U3R VFFfkU9xMxZNFfUVZRbNEWkVd3bRW1F7BaElWaJqIrQiuyKtIq2iviKtIq0irSKtor6isKKwIq2i 2qLaovaiviKtIrQK6ktTRfFETEWrREVFU0VFRVNFFEU+RT5FkkVaRUxFRZUWff7s4m9gka5+WI/Z X9IcWGOyypjsOXnExvuRP7aCvxXEVqxhKkWf7q8BXDMUDw0KZW5kc3RyZWFtDQplbmRvYmoNCnhy ZWYNCjAgNTM5DQowMDAwMDAwMTM4IDY1NTM1IGYNCjAwMDAwMDAwMTcgMDAwMDAgbg0KMDAwMDAw MDEyNiAwMDAwMCBuDQowMDAwMDAwMzI4IDAwMDAwIG4NCjAwMDAwMDA2NTQgMDAwMDAgbg0KMDAw MDAwMTIwOSAwMDAwMCBuDQowMDAwMDExMzE4IDAwMDAwIG4NCjAwMDAwMTUzMjggMDAwMDAgbg0K MDAwMDAxNTk4MyAwMDAwMCBuDQowMDAwMDE2MTMyIDAwMDAwIG4NCjAwMDAwMzMxMjcgMDAwMDAg bg0KMDAwMDA1NzA0MyAwMDAwMCBuDQowMDAwMDU3MjE0IDAwMDAwIG4NCjAwMDAwNTc0NTUgMDAw MDAgbg0KMDAwMDA1NzUwOSAwMDAwMCBuDQowMDAwMDU3Njg1IDAwMDAwIG4NCjAwMDAwNTc5MzEg MDAwMDAgbg0KMDAwMDA1ODIxNCAwMDAwMCBuDQowMDAwMDU4NTc3IDAwMDAwIG4NCjAwMDAwNjg2 ODggMDAwMDAgbg0KMDAwMDA3MjY5OSAwMDAwMCBuDQowMDAwMDczMzU1IDAwMDAwIG4NCjAwMDAw NzM1MDYgMDAwMDAgbg0KMDAwMDA3Mzg1OSAwMDAwMCBuDQowMDAwMDc0OTQ0IDAwMDAwIG4NCjAw MDAwODUwNTUgMDAwMDAgbg0KMDAwMDA4OTA2NiAwMDAwMCBuDQowMDAwMDg5MTI2IDAwMDAwIG4N CjAwMDAwODkxODAgMDAwMDAgbg0KMDAwMDA4OTgzNiAwMDAwMCBuDQowMDAwMDg5OTgxIDAwMDAw IG4NCjAwMDAwOTAxMTQgMDAwMDAgbg0KMDAwMDA5MDE0NCAwMDAwMCBuDQowMDAwMDkwMzA1IDAw MDAwIG4NCjAwMDAwOTAzNzkgMDAwMDAgbg0KMDAwMDA5MDYyMCAwMDAwMCBuDQowMDAwMDkwOTcz IDAwMDAwIG4NCjAwMDAwOTIwMDAgMDAwMDAgbg0KMDAwMDA5MjY1NiAwMDAwMCBuDQowMDAwMDky ODAxIDAwMDAwIG4NCjAwMDAwOTMxNTIgMDAwMDAgbg0KMDAwMDA5NDA3NyAwMDAwMCBuDQowMDAw MDk0NzMzIDAwMDAwIG4NCjAwMDAwOTQ4NzggMDAwMDAgbg0KMDAwMDA5NTIyMSAwMDAwMCBuDQow MDAwMDk2MTAxIDAwMDAwIG4NCjAwMDAwOTY3NTcgMDAwMDAgbg0KMDAwMDA5NjkwMiAwMDAwMCBu DQowMDAwMDk3Mjc2IDAwMDAwIG4NCjAwMDAwOTg0MzMgMDAwMDAgbg0KMDAwMDEwODU0NCAwMDAw MCBuDQowMDAwMTEyNTU1IDAwMDAwIG4NCjAwMDAxMTMyMTEgMDAwMDAgbg0KMDAwMDExMzM1NiAw MDAwMCBuDQowMDAwMTEzNTMyIDAwMDAwIG4NCjAwMDAxMTM3MDggMDAwMDAgbg0KMDAwMDExMzg4 MyAwMDAwMCBuDQowMDAwMTE0MjM3IDAwMDAwIG4NCjAwMDAxMTUwOTUgMDAwMDAgbg0KMDAwMDEx NTc1MSAwMDAwMCBuDQowMDAwMTE1ODk2IDAwMDAwIG4NCjAwMDAxMTYyNTAgMDAwMDAgbg0KMDAw MDExNzIwMSAwMDAwMCBuDQowMDAwMTI3MzEyIDAwMDAwIG4NCjAwMDAxMzEzMjMgMDAwMDAgbg0K MDAwMDEzMTk3OSAwMDAwMCBuDQowMDAwMTMyMTI0IDAwMDAwIG4NCjAwMDAxMzI0NzggMDAwMDAg bg0KMDAwMDEzMzQ1OSAwMDAwMCBuDQowMDAwMTM0MTE1IDAwMDAwIG4NCjAwMDAxMzQyNjAgMDAw MDAgbg0KMDAwMDEzNDYxNCAwMDAwMCBuDQowMDAwMTM1ODI1IDAwMDAwIG4NCjAwMDAxNDU5MzYg MDAwMDAgbg0KMDAwMDE0OTk0NyAwMDAwMCBuDQowMDAwMTUwNjAzIDAwMDAwIG4NCjAwMDAxNTA3 NDggMDAwMDAgbg0KMDAwMDE1MTExOSAwMDAwMCBuDQowMDAwMTUyMjY2IDAwMDAwIG4NCjAwMDAx NjIzNzcgMDAwMDAgbg0KMDAwMDE2NjM4OCAwMDAwMCBuDQowMDAwMTY3MDQ0IDAwMDAwIG4NCjAw MDAxNjcxODkgMDAwMDAgbg0KMDAwMDE2NzM0NSAwMDAwMCBuDQowMDAwMTY3Njk5IDAwMDAwIG4N CjAwMDAxNjg0MTQgMDAwMDAgbg0KMDAwMDE3ODUyNSAwMDAwMCBuDQowMDAwMTgyNTM2IDAwMDAw IG4NCjAwMDAxODMxOTIgMDAwMDAgbg0KMDAwMDE4MzMzNyAwMDAwMCBuDQowMDAwMTgzNzA4IDAw MDAwIG4NCjAwMDAxODQzNTQgMDAwMDAgbg0KMDAwMDE4NTAxMCAwMDAwMCBuDQowMDAwMTg1MTU1 IDAwMDAwIG4NCjAwMDAxODUzNzUgMDAwMDAgbg0KMDAwMDE4NTcyOSAwMDAwMCBuDQowMDAwMTg2 NzU3IDAwMDAwIG4NCjAwMDAxODc0MTMgMDAwMDAgbg0KMDAwMDE4NzU1OCAwMDAwMCBuDQowMDAw MTg3OTE0IDAwMDAwIG4NCjAwMDAxODg3OTMgMDAwMDAgbg0KMDAwMDE4OTQ1MCAwMDAwMCBuDQow MDAwMTg5NTk3IDAwMDAwIG4NCjAwMDAxODk5NTUgMDAwMDAgbg0KMDAwMDE5MTA5OSAwMDAwMCBu DQowMDAwMTkxNzU2IDAwMDAwIG4NCjAwMDAxOTE5MDMgMDAwMDAgbg0KMDAwMDE5MjMyMiAwMDAw MCBuDQowMDAwMTkzNzczIDAwMDAwIG4NCjAwMDAxOTQ0MzAgMDAwMDAgbg0KMDAwMDE5NDU3NyAw MDAwMCBuDQowMDAwMTk0NzU3IDAwMDAwIG4NCjAwMDAxOTUwMDggMDAwMDAgbg0KMDAwMDE5NTIw NiAwMDAwMCBuDQowMDAwMTk1NDA0IDAwMDAwIG4NCjAwMDAxOTU2MDEgMDAwMDAgbg0KMDAwMDE5 NTc5OCAwMDAwMCBuDQowMDAwMTk1OTk1IDAwMDAwIG4NCjAwMDAxOTYyODUgMDAwMDAgbg0KMDAw MDE5NjY0NyAwMDAwMCBuDQowMDAwMjA2NzYwIDAwMDAwIG4NCjAwMDAyMTA3NzIgMDAwMDAgbg0K MDAwMDIxMTQyOSAwMDAwMCBuDQowMDAwMjExNTgyIDAwMDAwIG4NCjAwMDAyMTE5NTEgMDAwMDAg bg0KMDAwMDIxMjkyMyAwMDAwMCBuDQowMDAwMjEzNTgwIDAwMDAwIG4NCjAwMDAyMTM3MjcgMDAw MDAgbg0KMDAwMDIxMzg2NyAwMDAwMCBuDQowMDAwMjEzODk5IDAwMDAwIG4NCjAwMDAyMTQwNjgg MDAwMDAgbg0KMDAwMDIxNDE0MyAwMDAwMCBuDQowMDAwMjE0MzkwIDAwMDAwIG4NCjAwMDAyMTQ3 NDUgMDAwMDAgbg0KMDAwMDIxNTMyMCAwMDAwMCBuDQowMDAwMjE1OTc3IDAwMDAwIG4NCjAwMDAy MTYxMzAgMDAwMDAgbg0KMDAwMDIxNjMwMyAwMDAwMCBuDQowMDAwMDAwMTM5IDY1NTM1IGYNCjAw MDAwMDAxNDAgNjU1MzUgZg0KMDAwMDAwMDE0MSA2NTUzNSBmDQowMDAwMDAwMTQyIDY1NTM1IGYN CjAwMDAwMDAxNDMgNjU1MzUgZg0KMDAwMDAwMDE0NCA2NTUzNSBmDQowMDAwMDAwMTQ1IDY1NTM1 IGYNCjAwMDAwMDAxNDYgNjU1MzUgZg0KMDAwMDAwMDE0NyA2NTUzNSBmDQowMDAwMDAwMTQ4IDY1 NTM1IGYNCjAwMDAwMDAxNDkgNjU1MzUgZg0KMDAwMDAwMDE1MCA2NTUzNSBmDQowMDAwMDAwMTUx IDY1NTM1IGYNCjAwMDAwMDAxNTIgNjU1MzUgZg0KMDAwMDAwMDE1MyA2NTUzNSBmDQowMDAwMDAw MTU0IDY1NTM1IGYNCjAwMDAwMDAxNTUgNjU1MzUgZg0KMDAwMDAwMDE1NiA2NTUzNSBmDQowMDAw MDAwMTU3IDY1NTM1IGYNCjAwMDAwMDAxNTggNjU1MzUgZg0KMDAwMDAwMDE1OSA2NTUzNSBmDQow MDAwMDAwMTYwIDY1NTM1IGYNCjAwMDAwMDAxNjEgNjU1MzUgZg0KMDAwMDAwMDE2MiA2NTUzNSBm DQowMDAwMDAwMTYzIDY1NTM1IGYNCjAwMDAwMDAxNjQgNjU1MzUgZg0KMDAwMDAwMDE2NSA2NTUz NSBmDQowMDAwMDAwMTY2IDY1NTM1IGYNCjAwMDAwMDAxNjcgNjU1MzUgZg0KMDAwMDAwMDE2OCA2 NTUzNSBmDQowMDAwMDAwMTY5IDY1NTM1IGYNCjAwMDAwMDAxNzAgNjU1MzUgZg0KMDAwMDAwMDE3 MSA2NTUzNSBmDQowMDAwMDAwMTcyIDY1NTM1IGYNCjAwMDAwMDAxNzMgNjU1MzUgZg0KMDAwMDAw MDE3NCA2NTUzNSBmDQowMDAwMDAwMTc1IDY1NTM1IGYNCjAwMDAwMDAxNzYgNjU1MzUgZg0KMDAw MDAwMDE3NyA2NTUzNSBmDQowMDAwMDAwMTc4IDY1NTM1IGYNCjAwMDAwMDAxNzkgNjU1MzUgZg0K MDAwMDAwMDE4MCA2NTUzNSBmDQowMDAwMDAwMTgxIDY1NTM1IGYNCjAwMDAwMDAxODIgNjU1MzUg Zg0KMDAwMDAwMDE4MyA2NTUzNSBmDQowMDAwMDAwMTg0IDY1NTM1IGYNCjAwMDAwMDAxODUgNjU1 MzUgZg0KMDAwMDAwMDE4NiA2NTUzNSBmDQowMDAwMDAwMTg3IDY1NTM1IGYNCjAwMDAwMDAxODgg NjU1MzUgZg0KMDAwMDAwMDE4OSA2NTUzNSBmDQowMDAwMDAwMTkwIDY1NTM1IGYNCjAwMDAwMDAx OTEgNjU1MzUgZg0KMDAwMDAwMDE5MiA2NTUzNSBmDQowMDAwMDAwMTkzIDY1NTM1IGYNCjAwMDAw MDAxOTQgNjU1MzUgZg0KMDAwMDAwMDE5NSA2NTUzNSBmDQowMDAwMDAwMTk2IDY1NTM1IGYNCjAw MDAwMDAxOTcgNjU1MzUgZg0KMDAwMDAwMDE5OCA2NTUzNSBmDQowMDAwMDAwMTk5IDY1NTM1IGYN CjAwMDAwMDAyMDAgNjU1MzUgZg0KMDAwMDAwMDIwMSA2NTUzNSBmDQowMDAwMDAwMjAyIDY1NTM1 IGYNCjAwMDAwMDAyMDMgNjU1MzUgZg0KMDAwMDAwMDIwNCA2NTUzNSBmDQowMDAwMDAwMjA1IDY1 NTM1IGYNCjAwMDAwMDAyMDYgNjU1MzUgZg0KMDAwMDAwMDIwNyA2NTUzNSBmDQowMDAwMDAwMjA4 IDY1NTM1IGYNCjAwMDAwMDAyMDkgNjU1MzUgZg0KMDAwMDAwMDIxMCA2NTUzNSBmDQowMDAwMDAw MjExIDY1NTM1IGYNCjAwMDAwMDAyMTIgNjU1MzUgZg0KMDAwMDAwMDIxMyA2NTUzNSBmDQowMDAw MDAwMjE0IDY1NTM1IGYNCjAwMDAwMDAyMTUgNjU1MzUgZg0KMDAwMDAwMDIxNiA2NTUzNSBmDQow MDAwMDAwMjE3IDY1NTM1IGYNCjAwMDAwMDAyMTggNjU1MzUgZg0KMDAwMDAwMDIxOSA2NTUzNSBm DQowMDAwMDAwMjIwIDY1NTM1IGYNCjAwMDAwMDAyMjEgNjU1MzUgZg0KMDAwMDAwMDIyMiA2NTUz NSBmDQowMDAwMDAwMjIzIDY1NTM1IGYNCjAwMDAwMDAyMjQgNjU1MzUgZg0KMDAwMDAwMDIyNSA2 NTUzNSBmDQowMDAwMDAwMjI2IDY1NTM1IGYNCjAwMDAwMDAyMjcgNjU1MzUgZg0KMDAwMDAwMDIy OCA2NTUzNSBmDQowMDAwMDAwMjI5IDY1NTM1IGYNCjAwMDAwMDAyMzAgNjU1MzUgZg0KMDAwMDAw MDIzMSA2NTUzNSBmDQowMDAwMDAwMjMyIDY1NTM1IGYNCjAwMDAwMDAyMzMgNjU1MzUgZg0KMDAw MDAwMDIzNCA2NTUzNSBmDQowMDAwMDAwMjM1IDY1NTM1IGYNCjAwMDAwMDAyMzYgNjU1MzUgZg0K MDAwMDAwMDIzNyA2NTUzNSBmDQowMDAwMDAwMjM4IDY1NTM1IGYNCjAwMDAwMDAyMzkgNjU1MzUg Zg0KMDAwMDAwMDI0MCA2NTUzNSBmDQowMDAwMDAwMjQxIDY1NTM1IGYNCjAwMDAwMDAyNDIgNjU1 MzUgZg0KMDAwMDAwMDI0MyA2NTUzNSBmDQowMDAwMDAwMjQ0IDY1NTM1IGYNCjAwMDAwMDAyNDUg NjU1MzUgZg0KMDAwMDAwMDI0NiA2NTUzNSBmDQowMDAwMDAwMjQ3IDY1NTM1IGYNCjAwMDAwMDAy NDggNjU1MzUgZg0KMDAwMDAwMDI0OSA2NTUzNSBmDQowMDAwMDAwMjUwIDY1NTM1IGYNCjAwMDAw MDAyNTEgNjU1MzUgZg0KMDAwMDAwMDI1MiA2NTUzNSBmDQowMDAwMDAwMjUzIDY1NTM1IGYNCjAw MDAwMDAyNTQgNjU1MzUgZg0KMDAwMDAwMDI1NSA2NTUzNSBmDQowMDAwMDAwMjU2IDY1NTM1IGYN CjAwMDAwMDAyNTcgNjU1MzUgZg0KMDAwMDAwMDI1OCA2NTUzNSBmDQowMDAwMDAwMjU5IDY1NTM1 IGYNCjAwMDAwMDAyNjAgNjU1MzUgZg0KMDAwMDAwMDI2MSA2NTUzNSBmDQowMDAwMDAwMjYyIDY1 NTM1IGYNCjAwMDAwMDAyNjMgNjU1MzUgZg0KMDAwMDAwMDI2NCA2NTUzNSBmDQowMDAwMDAwMjY1 IDY1NTM1IGYNCjAwMDAwMDAyNjYgNjU1MzUgZg0KMDAwMDAwMDI2NyA2NTUzNSBmDQowMDAwMDAw MjY4IDY1NTM1IGYNCjAwMDAwMDAyNjkgNjU1MzUgZg0KMDAwMDAwMDI3MCA2NTUzNSBmDQowMDAw MDAwMjcxIDY1NTM1IGYNCjAwMDAwMDAyNzIgNjU1MzUgZg0KMDAwMDAwMDI3MyA2NTUzNSBmDQow MDAwMDAwMjc0IDY1NTM1IGYNCjAwMDAwMDAyNzUgNjU1MzUgZg0KMDAwMDAwMDI3NiA2NTUzNSBm DQowMDAwMDAwMjc3IDY1NTM1IGYNCjAwMDAwMDAyNzggNjU1MzUgZg0KMDAwMDAwMDI3OSA2NTUz NSBmDQowMDAwMDAwMjgwIDY1NTM1IGYNCjAwMDAwMDAyODEgNjU1MzUgZg0KMDAwMDAwMDI4MiA2 NTUzNSBmDQowMDAwMDAwMjgzIDY1NTM1IGYNCjAwMDAwMDAyODQgNjU1MzUgZg0KMDAwMDAwMDI4 NSA2NTUzNSBmDQowMDAwMDAwMjg2IDY1NTM1IGYNCjAwMDAwMDAyODcgNjU1MzUgZg0KMDAwMDAw MDI4OCA2NTUzNSBmDQowMDAwMDAwMjg5IDY1NTM1IGYNCjAwMDAwMDAyOTAgNjU1MzUgZg0KMDAw MDAwMDI5MSA2NTUzNSBmDQowMDAwMDAwMjkyIDY1NTM1IGYNCjAwMDAwMDAyOTMgNjU1MzUgZg0K MDAwMDAwMDI5NCA2NTUzNSBmDQowMDAwMDAwMjk1IDY1NTM1IGYNCjAwMDAwMDAyOTYgNjU1MzUg Zg0KMDAwMDAwMDI5NyA2NTUzNSBmDQowMDAwMDAwMjk4IDY1NTM1IGYNCjAwMDAwMDAyOTkgNjU1 MzUgZg0KMDAwMDAwMDMwMCA2NTUzNSBmDQowMDAwMDAwMzAxIDY1NTM1IGYNCjAwMDAwMDAzMDIg NjU1MzUgZg0KMDAwMDAwMDMwMyA2NTUzNSBmDQowMDAwMDAwMzA0IDY1NTM1IGYNCjAwMDAwMDAz MDUgNjU1MzUgZg0KMDAwMDAwMDMwNiA2NTUzNSBmDQowMDAwMDAwMzA3IDY1NTM1IGYNCjAwMDAw MDAzMDggNjU1MzUgZg0KMDAwMDAwMDMwOSA2NTUzNSBmDQowMDAwMDAwMzEwIDY1NTM1IGYNCjAw MDAwMDAzMTEgNjU1MzUgZg0KMDAwMDAwMDMxMiA2NTUzNSBmDQowMDAwMDAwMzEzIDY1NTM1IGYN CjAwMDAwMDAzMTQgNjU1MzUgZg0KMDAwMDAwMDMxNSA2NTUzNSBmDQowMDAwMDAwMzE2IDY1NTM1 IGYNCjAwMDAwMDAzMTcgNjU1MzUgZg0KMDAwMDAwMDMxOCA2NTUzNSBmDQowMDAwMDAwMzE5IDY1 NTM1IGYNCjAwMDAwMDAzMjAgNjU1MzUgZg0KMDAwMDAwMDMyMSA2NTUzNSBmDQowMDAwMDAwMzIy IDY1NTM1IGYNCjAwMDAwMDAzMjMgNjU1MzUgZg0KMDAwMDAwMDMyNCA2NTUzNSBmDQowMDAwMDAw MzI1IDY1NTM1IGYNCjAwMDAwMDAzMjYgNjU1MzUgZg0KMDAwMDAwMDMyNyA2NTUzNSBmDQowMDAw MDAwMzI4IDY1NTM1IGYNCjAwMDAwMDAzMjkgNjU1MzUgZg0KMDAwMDAwMDMzMCA2NTUzNSBmDQow MDAwMDAwMzMxIDY1NTM1IGYNCjAwMDAwMDAzMzIgNjU1MzUgZg0KMDAwMDAwMDMzMyA2NTUzNSBm DQowMDAwMDAwMzM0IDY1NTM1IGYNCjAwMDAwMDAzMzUgNjU1MzUgZg0KMDAwMDAwMDMzNiA2NTUz NSBmDQowMDAwMDAwMzM3IDY1NTM1IGYNCjAwMDAwMDAzMzggNjU1MzUgZg0KMDAwMDAwMDMzOSA2 NTUzNSBmDQowMDAwMDAwMzQwIDY1NTM1IGYNCjAwMDAwMDAzNDEgNjU1MzUgZg0KMDAwMDAwMDM0 MiA2NTUzNSBmDQowMDAwMDAwMzQzIDY1NTM1IGYNCjAwMDAwMDAzNDQgNjU1MzUgZg0KMDAwMDAw MDM0NSA2NTUzNSBmDQowMDAwMDAwMzQ2IDY1NTM1IGYNCjAwMDAwMDAzNDcgNjU1MzUgZg0KMDAw MDAwMDM0OCA2NTUzNSBmDQowMDAwMDAwMzQ5IDY1NTM1IGYNCjAwMDAwMDAzNTAgNjU1MzUgZg0K MDAwMDAwMDM1MSA2NTUzNSBmDQowMDAwMDAwMzUyIDY1NTM1IGYNCjAwMDAwMDAzNTMgNjU1MzUg Zg0KMDAwMDAwMDM1NCA2NTUzNSBmDQowMDAwMDAwMzU1IDY1NTM1IGYNCjAwMDAwMDAzNTYgNjU1 MzUgZg0KMDAwMDAwMDM1NyA2NTUzNSBmDQowMDAwMDAwMzU4IDY1NTM1IGYNCjAwMDAwMDAzNTkg NjU1MzUgZg0KMDAwMDAwMDM2MCA2NTUzNSBmDQowMDAwMDAwMzYxIDY1NTM1IGYNCjAwMDAwMDAz NjIgNjU1MzUgZg0KMDAwMDAwMDM2MyA2NTUzNSBmDQowMDAwMDAwMzY0IDY1NTM1IGYNCjAwMDAw MDAzNjUgNjU1MzUgZg0KMDAwMDAwMDM2NiA2NTUzNSBmDQowMDAwMDAwMzY3IDY1NTM1IGYNCjAw MDAwMDAzNjggNjU1MzUgZg0KMDAwMDAwMDM2OSA2NTUzNSBmDQowMDAwMDAwMzcwIDY1NTM1IGYN CjAwMDAwMDAzNzEgNjU1MzUgZg0KMDAwMDAwMDM3MiA2NTUzNSBmDQowMDAwMDAwMzczIDY1NTM1 IGYNCjAwMDAwMDAzNzQgNjU1MzUgZg0KMDAwMDAwMDM3NSA2NTUzNSBmDQowMDAwMDAwMzc2IDY1 NTM1IGYNCjAwMDAwMDAzNzcgNjU1MzUgZg0KMDAwMDAwMDM3OCA2NTUzNSBmDQowMDAwMDAwMzc5 IDY1NTM1IGYNCjAwMDAwMDAzODAgNjU1MzUgZg0KMDAwMDAwMDM4MSA2NTUzNSBmDQowMDAwMDAw MzgyIDY1NTM1IGYNCjAwMDAwMDAzODMgNjU1MzUgZg0KMDAwMDAwMDM4NCA2NTUzNSBmDQowMDAw MDAwMzg1IDY1NTM1IGYNCjAwMDAwMDAzODYgNjU1MzUgZg0KMDAwMDAwMDM4NyA2NTUzNSBmDQow MDAwMDAwMzg4IDY1NTM1IGYNCjAwMDAwMDAzODkgNjU1MzUgZg0KMDAwMDAwMDM5MCA2NTUzNSBm DQowMDAwMDAwMzkxIDY1NTM1IGYNCjAwMDAwMDAzOTIgNjU1MzUgZg0KMDAwMDAwMDM5MyA2NTUz NSBmDQowMDAwMDAwMzk0IDY1NTM1IGYNCjAwMDAwMDAzOTUgNjU1MzUgZg0KMDAwMDAwMDM5NiA2 NTUzNSBmDQowMDAwMDAwMzk3IDY1NTM1IGYNCjAwMDAwMDAzOTggNjU1MzUgZg0KMDAwMDAwMDM5 OSA2NTUzNSBmDQowMDAwMDAwNDAwIDY1NTM1IGYNCjAwMDAwMDA0MDEgNjU1MzUgZg0KMDAwMDAw MDQwMiA2NTUzNSBmDQowMDAwMDAwNDAzIDY1NTM1IGYNCjAwMDAwMDA0MDQgNjU1MzUgZg0KMDAw MDAwMDQwNSA2NTUzNSBmDQowMDAwMDAwNDA2IDY1NTM1IGYNCjAwMDAwMDA0MDcgNjU1MzUgZg0K MDAwMDAwMDQwOCA2NTUzNSBmDQowMDAwMDAwNDA5IDY1NTM1IGYNCjAwMDAwMDA0MTAgNjU1MzUg Zg0KMDAwMDAwMDQxMSA2NTUzNSBmDQowMDAwMDAwNDEyIDY1NTM1IGYNCjAwMDAwMDA0MTMgNjU1 MzUgZg0KMDAwMDAwMDQxNCA2NTUzNSBmDQowMDAwMDAwNDE1IDY1NTM1IGYNCjAwMDAwMDA0MTYg NjU1MzUgZg0KMDAwMDAwMDQxNyA2NTUzNSBmDQowMDAwMDAwNDE4IDY1NTM1IGYNCjAwMDAwMDA0 MTkgNjU1MzUgZg0KMDAwMDAwMDQyMCA2NTUzNSBmDQowMDAwMDAwNDIxIDY1NTM1IGYNCjAwMDAw MDA0MjIgNjU1MzUgZg0KMDAwMDAwMDQyMyA2NTUzNSBmDQowMDAwMDAwNDI0IDY1NTM1IGYNCjAw MDAwMDA0MjUgNjU1MzUgZg0KMDAwMDAwMDQyNiA2NTUzNSBmDQowMDAwMDAwNDI3IDY1NTM1IGYN CjAwMDAwMDA0MjggNjU1MzUgZg0KMDAwMDAwMDQyOSA2NTUzNSBmDQowMDAwMDAwNDMwIDY1NTM1 IGYNCjAwMDAwMDA0MzEgNjU1MzUgZg0KMDAwMDAwMDQzMiA2NTUzNSBmDQowMDAwMDAwNDMzIDY1 NTM1IGYNCjAwMDAwMDA0MzQgNjU1MzUgZg0KMDAwMDAwMDQzNSA2NTUzNSBmDQowMDAwMDAwNDM2 IDY1NTM1IGYNCjAwMDAwMDA0MzcgNjU1MzUgZg0KMDAwMDAwMDQzOCA2NTUzNSBmDQowMDAwMDAw NDM5IDY1NTM1IGYNCjAwMDAwMDA0NDAgNjU1MzUgZg0KMDAwMDAwMDQ0MSA2NTUzNSBmDQowMDAw MDAwNDQyIDY1NTM1IGYNCjAwMDAwMDA0NDMgNjU1MzUgZg0KMDAwMDAwMDQ0NCA2NTUzNSBmDQow MDAwMDAwNDQ1IDY1NTM1IGYNCjAwMDAwMDA0NDYgNjU1MzUgZg0KMDAwMDAwMDQ0NyA2NTUzNSBm DQowMDAwMDAwNDQ4IDY1NTM1IGYNCjAwMDAwMDA0NDkgNjU1MzUgZg0KMDAwMDAwMDQ1MCA2NTUz NSBmDQowMDAwMDAwNDUxIDY1NTM1IGYNCjAwMDAwMDA0NTIgNjU1MzUgZg0KMDAwMDAwMDQ1MyA2 NTUzNSBmDQowMDAwMDAwNDU0IDY1NTM1IGYNCjAwMDAwMDA0NTUgNjU1MzUgZg0KMDAwMDAwMDQ1 NiA2NTUzNSBmDQowMDAwMDAwNDU3IDY1NTM1IGYNCjAwMDAwMDA0NTggNjU1MzUgZg0KMDAwMDAw MDQ1OSA2NTUzNSBmDQowMDAwMDAwNDYwIDY1NTM1IGYNCjAwMDAwMDA0NjEgNjU1MzUgZg0KMDAw MDAwMDQ2MiA2NTUzNSBmDQowMDAwMDAwNDYzIDY1NTM1IGYNCjAwMDAwMDA0NjQgNjU1MzUgZg0K MDAwMDAwMDQ2NSA2NTUzNSBmDQowMDAwMDAwNDY2IDY1NTM1IGYNCjAwMDAwMDA0NjcgNjU1MzUg Zg0KMDAwMDAwMDQ2OCA2NTUzNSBmDQowMDAwMDAwNDY5IDY1NTM1IGYNCjAwMDAwMDA0NzAgNjU1 MzUgZg0KMDAwMDAwMDQ3MSA2NTUzNSBmDQowMDAwMDAwNDcyIDY1NTM1IGYNCjAwMDAwMDA0NzMg NjU1MzUgZg0KMDAwMDAwMDQ3NCA2NTUzNSBmDQowMDAwMDAwNDc1IDY1NTM1IGYNCjAwMDAwMDA0 NzYgNjU1MzUgZg0KMDAwMDAwMDQ3NyA2NTUzNSBmDQowMDAwMDAwNDc4IDY1NTM1IGYNCjAwMDAw MDA0NzkgNjU1MzUgZg0KMDAwMDAwMDQ4MCA2NTUzNSBmDQowMDAwMDAwNDgxIDY1NTM1IGYNCjAw MDAwMDA0ODIgNjU1MzUgZg0KMDAwMDAwMDQ4MyA2NTUzNSBmDQowMDAwMDAwNDg0IDY1NTM1IGYN CjAwMDAwMDA0ODUgNjU1MzUgZg0KMDAwMDAwMDQ4NiA2NTUzNSBmDQowMDAwMDAwNDg3IDY1NTM1 IGYNCjAwMDAwMDA0ODggNjU1MzUgZg0KMDAwMDAwMDQ4OSA2NTUzNSBmDQowMDAwMDAwNDkwIDY1 NTM1IGYNCjAwMDAwMDA0OTEgNjU1MzUgZg0KMDAwMDAwMDQ5MiA2NTUzNSBmDQowMDAwMDAwNDkz IDY1NTM1IGYNCjAwMDAwMDA0OTQgNjU1MzUgZg0KMDAwMDAwMDQ5NSA2NTUzNSBmDQowMDAwMDAw NDk2IDY1NTM1IGYNCjAwMDAwMDA0OTcgNjU1MzUgZg0KMDAwMDAwMDQ5OCA2NTUzNSBmDQowMDAw MDAwNDk5IDY1NTM1IGYNCjAwMDAwMDA1MDAgNjU1MzUgZg0KMDAwMDAwMDUwMSA2NTUzNSBmDQow MDAwMDAwNTAyIDY1NTM1IGYNCjAwMDAwMDA1MDMgNjU1MzUgZg0KMDAwMDAwMDUwNCA2NTUzNSBm DQowMDAwMDAwNTA1IDY1NTM1IGYNCjAwMDAwMDA1MDYgNjU1MzUgZg0KMDAwMDAwMDUwNyA2NTUz NSBmDQowMDAwMDAwNTA4IDY1NTM1IGYNCjAwMDAwMDA1MDkgNjU1MzUgZg0KMDAwMDAwMDUxMCA2 NTUzNSBmDQowMDAwMDAwNTExIDY1NTM1IGYNCjAwMDAwMDA1MTIgNjU1MzUgZg0KMDAwMDAwMDUx MyA2NTUzNSBmDQowMDAwMDAwNTE0IDY1NTM1IGYNCjAwMDAwMDA1MTUgNjU1MzUgZg0KMDAwMDAw MDUxNiA2NTUzNSBmDQowMDAwMDAwNTE3IDY1NTM1IGYNCjAwMDAwMDA1MTggNjU1MzUgZg0KMDAw MDAwMDUxOSA2NTUzNSBmDQowMDAwMDAwNTIwIDY1NTM1IGYNCjAwMDAwMDA1MjEgNjU1MzUgZg0K MDAwMDAwMDUyMiA2NTUzNSBmDQowMDAwMDAwNTIzIDY1NTM1IGYNCjAwMDAwMDA1MjQgNjU1MzUg Zg0KMDAwMDAwMDUyNSA2NTUzNSBmDQowMDAwMDAwNTI2IDY1NTM1IGYNCjAwMDAwMDA1MjcgNjU1 MzUgZg0KMDAwMDAwMDAwMCA2NTUzNSBmDQowMDAwMjIyMjE5IDAwMDAwIG4NCjAwMDAyMjI2MjEg MDAwMDAgbg0KMDAwMDMxODIzMCAwMDAwMCBuDQowMDAwMzE4OTExIDAwMDAwIG4NCjAwMDAzMTky NTkgMDAwMDAgbg0KMDAwMDMxOTY1MiAwMDAwMCBuDQowMDAwNDAxNDI5IDAwMDAwIG4NCjAwMDA0 MDE3MzEgMDAwMDAgbg0KMDAwMDQwMTk2OSAwMDAwMCBuDQowMDAwNDAyMTc5IDAwMDAwIG4NCjAw MDA0ODAyNDggMDAwMDAgbg0KdHJhaWxlcg0KPDwvU2l6ZSA1MzkvUm9vdCAxIDAgUi9JbmZvIDEz NyAwIFIvSURbPDNBMTM1MTBGNTQ5NzRDNEZCN0NEMkYwOTdEQTZFMjVDPjwzQTEzNTEwRjU0OTc0 QzRGQjdDRDJGMDk3REE2RTI1Qz5dID4+DQpzdGFydHhyZWYNCjQ4MTcwNQ0KJSVFT0YNCnhyZWYN CjAgMA0KdHJhaWxlcg0KPDwvU2l6ZSA1MzkvUm9vdCAxIDAgUi9JbmZvIDEzNyAwIFIvSURbPDNB MTM1MTBGNTQ5NzRDNEZCN0NEMkYwOTdEQTZFMjVDPjwzQTEzNTEwRjU0OTc0QzRGQjdDRDJGMDk3 REE2RTI1Qz5dIC9QcmV2IDQ4MTcwNS9YUmVmU3RtIDQ4MDI0OD4+DQpzdGFydHhyZWYNCjQ5MjY0 Ng0KJSVFT0Y= --_005_55E78A57290FB64FA0D3CF672F9F3DA21BA6CFSJCPEX01CL03citri_ Content-Type: text/plain; name="Xen Project 4-4 Features and Futures.txt" Content-Description: Xen Project 4-4 Features and Futures.txt Content-Disposition: attachment; filename="Xen Project 4-4 Features and Futures.txt"; size=6240; creation-date="Wed, 19 Mar 2014 01:22:39 GMT"; modification-date="Wed, 19 Mar 2014 01:20:25 GMT" Content-Transfer-Encoding: base64 WGVuIFByb2plY3QgNC40OiBGZWF0dXJlcyBhbmQgRnV0dXJlcwoKUnVzc2VsbCBQYXZsaWNlawpY ZW4gUHJvamVjdCBFdmFuZ2VsaXN0LCBDaXRyaXgKU3lzdGVtcwoKDFhlbiBQcm9qZWN0IDQuNCBG ZWF0dXJlcwoKDEltcHJvdmVkIEZsZXhpYmlsaXR5IGluIERyaXZlciBEb21haW5zCuKAoiBMaW51 eCBkcml2ZXIgZG9tYWlucyB1c2VkIHRvIHJlbHkgb24gdWRldiBldmVudHMgaW4Kb3JkZXIgdG8g bGF1bmNoIGJhY2tlbmRzIGZvciBndWVzdHMK4oCTIERlcGVuZGVuY3kgb24gdWRldiBpcyByZXBs YWNlZCB3aXRoIGEgY3VzdG9tIGRhZW1vbgpidWlsdCBvbiB0b3Agb2YgbGlieGwK4oCTIFByb3Zp ZGVzIGdyZWF0ZXIgZmxleGliaWxpdHkgaW4gb3JkZXIgdG8gcnVuIHVzZXItc3BhY2UKYmFja2Vu ZHMgaW5zaWRlIG9mIGRyaXZlciBkb21haW5zCuKAkyBFeGFtcGxlIG9mIGNhcGFiaWxpdHk6IGRy aXZlciBkb21haW5zIGNhbiBub3cgdXNlClFkaXNrIGJhY2tlbmRzLCB3aGljaCB3YXMgbm90IHBv c3NpYmxlIHdpdGggdWRldgoKDEltcHJvdmVkIEV2ZW50IENoYW5uZWwgU2NhbGFiaWxpdHkK4oCi IEV2ZW50IGNoYW5uZWxzIGFyZSBwYXJhLXZpcnR1YWxpemVkIGludGVycnVwdHMK4oCiIFByZXZp b3VzbHkgbGltaXRlZCB0byBlaXRoZXIgMTAyNCBvciA0MDk2IGNoYW5uZWxzCnBlciBkb21haW4K 4oCTIERvbWFpbiAwIG5lZWRzIHNldmVyYWwgZXZlbnQgY2hhbm5lbHMgZm9yIGVhY2ggZ3Vlc3QK Vk0gKGZvciBuZXR3b3JrL2Rpc2sgYmFja2VuZHMsIHFlbXUgZXRjLikK4oCTIFByYWN0aWNhbCBs aW1pdCBvZiB0b3RhbCBudW1iZXIgb2YgVk1zIHRvIGFyb3VuZCAzMDA1MDAgKGRlcGVuZGluZyBv biBWTSBjb25maWd1cmF0aW9uKQoKDEltcHJvdmVkIEV2ZW50IENoYW5uZWwgU2NhbGFiaWxpdHkg KDIpCuKAoiBOZXcgRklGTy1iYXNlZCBldmVudCBjaGFubmVsIEFCSSBhbGxvd3MgZm9yIG92ZXIK MTAwLDAwMCBldmVudCBjaGFubmVscwrigJMgSW1wcm92ZSBmYWlybmVzcwrigJMgQWxsb3dzIGZv ciBtdWx0aXBsZSBwcmlvcml0aWVzCuKAkyBUaGUgaW5jcmVhc2VkIGxpbWl0IGFsbG93cyBmb3Ig bW9yZSBWTXMsIHdoaWNoIGJlbmVmaXRzCmxhcmdlIHN5c3RlbXMgYW5kIGNsb3VkIG9wZXJhdGlu ZyBzeXN0ZW1zIHN1Y2ggYXMKTWlyYWdlT1MsIEVybGFuZ09uWGVuLCBPU3YsIEhhbFZNCgoMRXhw ZXJpbWVudGFsIFBWSCBTdXBwb3J0CuKAoiBQVkggbW9kZSBjb21iaW5lcyB0aGUgYmVzdCBlbGVt ZW50cyBvZiBIVk0gYW5kClBWCuKAkyBQVkggdGFrZXMgYWR2YW50YWdlIG9mIG1hbnkgb2YgdGhl IGhhcmR3YXJlCnZpcnR1YWxpemF0aW9uIGZlYXR1cmVzIHRoYXQgZXhpc3QgaW4gY29udGVtcG9y YXJ5CmhhcmR3YXJlCgrigKIgUG90ZW50aWFsIGZvciBzaWduaWZpY2FudGx5IGluY3JlYXNlZCBl ZmZpY2llbmN5IGFuZApwZXJmb3JtYW5jZQrigKIgUmVkdWNlZCBmb290cHJpbnQgaW4gTGludXgg YW5kIEZyZWVCU0QKCgxUZWNoIFByZXZpZXcgb2YgTmVzdGVkIFZpcnR1YWxpemF0aW9uCuKAoiBO ZXN0ZWQgdmlydHVhbGl6YXRpb24gcHJvdmlkZXMgdmlydHVhbGl6ZWQgaGFyZHdhcmUKdmlydHVh bGl6YXRpb24gZXh0ZW5zaW9ucyB0byBndWVzdHMK4oCTIENhbiBub3cgcnVuIFhlbiBQcm9qZWN0 LCBLVk0sIFZNV2FyZSBvciBIeXBlclYKaW5zaWRlIG9mIGEgZ3Vlc3QgZm9yIGRlYnVnZ2luZyBv ciBkZXBsb3ltZW50IHRlc3RpbmcK4oCTIEFsc28gYWxsb3dzIFdpbmRvd3MgNyAiWFAgQ29tcGF0 aWJpbGl0eSBtb2RlIgrigJMgVGVjaCBQcmV2aWV3IG5vdCB5ZXQgcmVhZHkgZm9yIHByb2R1Y3Rp b24gdXNlLCBidXQgaGFzCm1hZGUgc2lnbmlmaWNhbnQgZ2FpbnMgaW4gZnVuY3Rpb25hbGl0eSBh bmQgcmVsaWFiaWxpdHkKCuKAoiBNb3JlIGluZm9ybWF0aW9uIG9uIG5lc3RlZCB2aXJ0dWFsaXph dGlvbjogc2VlIFhlbgpuZXN0ZWQKCgxJbXByb3ZlZCBTdXBwb3J0IGZvciBTUElDRQrigKIgU1BJ Q0UgaXMgYSBwcm90b2NvbCBmb3IgdmlydHVhbCBkZXNrdG9wcyB3aGljaCBhbGxvd3MKYSBtdWNo IHJpY2hlciBjb25uZWN0aW9uIHRoYW4gZGlzcGxheS1vbmx5CnByb3RvY29scyBsaWtlIFZOQwri gKIgQWRkZWQgc3VwcG9ydCBmb3IgYWRkaXRpb25hbCBTUElDRSBmdW5jdGlvbmFsaXR5LAppbmNs dWRpbmc6CuKAkyBWZGFnZW50CuKAkyBjbGlwYm9hcmQgc2hhcmluZwrigJMgVVNCIHJlZGlyZWN0 aW9uCgoMR1JVQiAyIFN1cHBvcnQgb2YgWGVuIFByb2plY3QgUFYgSW1hZ2VzCuKAoiBJbiB0aGUg cGFzdCwgWGVuIFByb2plY3Qgc29mdHdhcmUgcmVxdWlyZWQgYSBjdXN0b20KaW1wbGVtZW50YXRp b24gb2YgR1JVQiBjYWxsZWQgcHZncnViCuKAoiBUaGUgdXBzdHJlYW0gR1JVQiAyIHByb2plY3Qg bm93IGhhcyBhIGJ1aWxkIHRhcmdldAp3aGljaCB3aWxsIGNvbnN0cnVjdCBhIGJvb3RhYmxlIFBW IFhlbiBQcm9qZWN0CmltYWdlCuKAkyBUaGlzIGVuc3VyZXMgMTAwJSBHUlVCIDIgY29tcGF0aWJp bGl0eSBmb3IgcHZncnViCmdvaW5nIGZvcndhcmQKCgxJbmRpcmVjdCBEZXNjcmlwdG9ycyBmb3Ig QmxvY2sgUFYgUHJvdG9jb2wK4oCiIE1vZGVybiBzdG9yYWdlIGRldmljZXMgd29yayBtdWNoIGJl dHRlciB3aXRoCmxhcmdlciBjaHVua3Mgb2YgZGF0YQrigKIgSW5kaXJlY3QgZGVzY3JpcHRvcnMg aGF2ZSBhbGxvd2VkIHRoZSBzaXplIG9mIGVhY2gKaW5kaXZpZHVhbCByZXF1ZXN0IHRvIHRyaXBs ZSwgZ3JlYXRseSBpbXByb3ZpbmcgSS9PCnBlcmZvcm1hbmNlIHdoZW4gcnVubmluZyBvbiBmYXN0 IHN0b3JhZ2UKdGVjaG5vbG9naWVzIGxpa2UgU1NEIGFuZCBSQUlECuKAoiBUaGlzIHN1cHBvcnQg aXMgYXZhaWxhYmxlIGluIGFueSBndWVzdCBydW5uaW5nIExpbnV4CjMuMTEgb3IgaGlnaGVyIChy ZWdhcmRsZXNzIG9mIFhlbiBQcm9qZWN0IHZlcnNpb24pCgoMSW1wcm92ZWQga2V4ZWMgU3VwcG9y dArigKIga2V4ZWMgYWxsb3dzIGEgcnVubmluZyBYZW4gUHJvamVjdCBob3N0IHRvIGJlCnJlcGxh Y2VkIHdpdGggYW5vdGhlciBPUyB3aXRob3V0IHJlYm9vdGluZwrigJMgUHJpbWFyaWx5IHVzZWQg ZXhlY3V0ZSBhIGNyYXNoIGVudmlyb25tZW50IHRvIGNvbGxlY3QKaW5mb3JtYXRpb24gb24gYSBY ZW4gUHJvamVjdCBoeXBlcnZpc29yIG9yIGRvbTAgY3Jhc2gKCuKAoiBUaGUgZXhpc3RpbmcgZnVu Y3Rpb25hbGl0eSBoYXMgYmVlbiBleHRlbmRlZCB0bzoK4oCTIEFsbG93IHRvb2xzIHRvIGxvYWQg aW1hZ2VzIHdpdGhvdXQgcmVxdWlyaW5nIGRvbTAKa2VybmVsIHN1cHBvcnQgKHdoaWNoIGRvZXMg bm90IGV4aXN0IGluIHVwc3RyZWFtCmtlcm5lbHMpCuKAkyBJbXByb3ZlIHJlbGlhYmlsaXR5IHdo ZW4gdXNlZCBmcm9tIGEgMzItYml0IGRvbTAK4oCTIGtleGVjLXRvb2xzIDIuMC41IG9yIGxhdGVy IGlzIHJlcXVpcmVkCgoMSW1wcm92ZWQgWEFQSSBhbmQgTWlyYWdlIE9TIHN1cHBvcnQK4oCiIFhB UEkgYW5kIE1pcmFnZSBPUyBhcmUgc3ViLXByb2plY3RzIHdpdGhpbiB0aGUgWGVuClByb2plY3Qg d3JpdHRlbiBpbiBPQ2FtbArigKIgQm90aCBhcmUgYWxzbyB1c2VkIGluIFhlblNlcnZlcgooc2Vl IGh0dHA6Ly94ZW5zZXJ2ZXIub3JnLykgYW5kIHJlbHkgb24gdGhlIFhlbgpQcm9qZWN0IE9DYW1s IGxhbmd1YWdlIGJpbmRpbmdzIHRvIG9wZXJhdGUgd2VsbArigKIgVGhlc2UgbGFuZ3VhZ2UgYmlu ZGluZ3MgaGF2ZSBoYWQgYSBtYWpvciBvdmVyaGF1bArigJMgUHJvZHVjZXMgbXVjaCBiZXR0ZXIg Y29tcGF0aWJpbGl0eSBiZXR3ZWVuIFhBUEksCk1pcmFnZSBPUyBhbmQgTGludXggZGlzdHJpYnV0 aW9ucyBnb2luZyBmb3J3YXJkCgoMRXhwZXJpbWVudGFsIFN1cHBvcnQgZm9yIEd1ZXN0IEVGSSBi b290CuKAoiBFRkkgaXMgdGhlIG5ldyBib290aW5nIHN0YW5kYXJkIHRoYXQgaXMgcmVwbGFjaW5n CkJJT1MK4oCTIFNvbWUgb3BlcmF0aW5nIHN5c3RlbXMgb25seSBib290IHdpdGggRUZJCuKAkyBT b21lIGZlYXR1cmVzLCBsaWtlIFNlY3VyZUJvb3QsIG9ubHkgd29yayB3aXRoIEVGSQoKDEltcHJv dmVkIEludGVncmF0aW9uIFdpdGggR2x1c3RlckZTCuKAoiBZb3UgY2FuIGZpbmQgYSBibG9nIHBv c3QgdG8gc2V0IHVwIGFuIGlTQ1NJIHRhcmdldCBvbgp0aGUgR2x1c3RlciBibG9nIGhlcmUKCgxJ bXByb3ZlZCBBUk0gU3VwcG9ydArigKIgQSBudW1iZXIgb2YgbmV3IGZlYXR1cmVzIGhhdmUgYmVl biBpbXBsZW1lbnRlZDoK4oCiIDY0IGJpdCBYZW4gb24gQVJNIG5vdyBzdXBwb3J0cyBib290aW5n IGd1ZXN0cwrigKIgUGh5c2ljYWwgZGlzayBwYXJ0aXRpb25zIGFuZCBMVk0gdm9sdW1lcyBjYW4g bm93CmJlIHVzZWQgdG8gc3RvcmUgZ3Vlc3QgaW1hZ2VzIHVzaW5nIHhlbi1ibGtiYWNrIChvcgpp cyBQViBkcml2ZXJzIGJldHRlciBpbiB0ZXJtcyBvZiB0ZXJtaW5vbG9neSkK4oCiIFNpZ25pZmlj YW50IHN0YWJpbGl0eSBpbXByb3ZlbWVudHMgYWNyb3NzIHRoZSBib2FyZArigKIgQVJNL211bHRp Ym9vdCBib290aW5nIHByb3RvY29sIGRlc2lnbiBhbmQKaW1wbGVtZW50YXRpb24K4oCiIFBTQ0kg c3VwcG9ydAoKDEltcHJvdmVkIEFSTSBTdXBwb3J0ICgyKQrigKIgU2FtZSBETUEgaW4gRG9tMCBl dmVuIHdpdGggbm8gaGFyZHdhcmUKSU9NTVVzIChub3Qgc3VyZSB3aGF0IHRoZSBpbXBsaWNhdGlv bnMgb2YgdGhpcyBhcmUpCuKAoiBBUk0gYW5kIEFSTTY0IEFCSXMgYXJlIGRlY2xhcmVkIHN0YWJs ZSBhbmQKbWFpbnRhaW5lZCBmb3IgYmFja3dhcmRzIGNvbXBhdGliaWxpdHkK4oCiIFNpZ25pZmlj YW50IHVzYWJpbGl0eSBpbXByb3ZlbWVudHMsIHN1Y2ggYXMKYXV0b21hdGljIGNyZWF0aW9uIG9m IGd1ZXN0IGRldmljZSB0cmVlcyBhbmQKaW1wcm92ZWQgaGFuZGxpbmcgb2YgaG9zdCBEVEJzCgoM SW1wcm92ZWQgQVJNIFN1cHBvcnQgKDMpCuKAoiBBZGRpbmcgbmV3IGhhcmR3YXJlIHBsYXRmb3Jt cyB0byBYZW4gUHJvamVjdCBvbgpBUk0gaGFzIGJlZW4gdmFzdGx5IGltcHJvdmVkLCBtYWtpbmcg aXQgZWFzaWVyIGZvcgpIYXJkd2FyZSB2ZW5kb3JzIGFuZCBlbWJlZGRlZCB2ZW5kb3JzIHRvIHBv cnQKdG8gdGhlaXIgYm9hcmQK4oCiIEFkZGVkIHN1cHBvcnQgZm9yIHRoZSBBcm5kYWxlIGJvYXJk LCBDYWx4ZWRhIEVDWDIwMDAgKGFrYSBNaWR3YXkpLCBBcHBsaWVkIE1pY3JvIFgtR2VuZSBTdG9y bSwgVEkKT01BUDUgYW5kIEFsbHdpbm5lciBBMjAvQTMwIGJvYXJkcwrigKIgQVJNIHNlcnZlciBj bGFzcyBoYXJkd2FyZSAoQ2FseGVkYSBNaWR3YXkpIGhhcwpiZWVuIGludHJvZHVjZWQgaW4gdGhl IFhlbiBQcm9qZWN0IE9TU1Rlc3QKYXV0b21hdGVkIHRlc3RpbmcgZnJhbWV3b3JrCgoMRWFybHkg TWljcm9jb2RlIExvYWRpbmcK4oCiIFRoZSBoeXBlcnZpc29yIGNhbiB1cGRhdGUgdGhlIG1pY3Jv Y29kZSBpbiB0aGUKZWFybHkgcGhhc2Ugb2YgYm9vdCB0aW1lCuKAkyBUaGUgbWljcm9jb2RlIGJp bmFyeSBibG9iIGNhbiBiZSBlaXRoZXIgYXMgYQpzdGFuZGFsb25lIG11bHRpYm9vdCBwYXlsb2Fk LCBvciBwYXJ0IG9mIHRoZSBpbml0aWFsCmtlcm5lbCAoZG9tMCkgaW5pdGlhbCByYW1kaXNrIChp bml0cmQpCuKAkyBUbyB0YWtlIGFkdmFudGFnZSBvZiB0aGlzIHVzZSBsYXRlc3QgdmVyc2lvbgpv ZiBkcmFjdXQgd2l0aCAtLWVhcmx5LW1pY3JvY29kZSBwYXJhbWV0ZXIgYW5kIG9uIHRoZQpYZW4g UHJvamVjdCBjb21tYW5kIGxpbmUgc3BlY2lmeTogdWNvZGU9c2Nhbi4K4oCTIEZvciBkZXRhaWxz IHNlZSBkcmFjdXQgbWFucGFnZQphbmQgaHR0cDovL3hlbmJpdHMueGVuLm9yZy9kb2NzL3Vuc3Rh YmxlL21pc2MveGVuY29tbWFuZC1saW5lLmh0bWwKCgxYZW4gUHJvamVjdCBGdXR1cmVzCgoMU3Rp bGwgTW9yZSBGdW4gdG8gQ29tZeKApgrigKIgWGVuIEF1dG9tb3RpdmUK4oCTIFhlbiBQcm9qZWN0 IGluIHRoZSBlbnRlcnRhaW5tZW50IGNlbnRlciBvZiB5b3VyIGNhcj8KCuKAoiBYZW5HVArigJMg VmlydHVhbGl6ZWQgR1BVIHN1cHBvcnQKCuKAoiBFdmVuIE1vcmUgQVJNIFN1cHBvcnQK4oCTIE9u IHlvdXIgc2VydmVyLCBpbiB5b3VyIHBob25lLCB3aGVyZXZlcuKApgoK4oCiIFBWSCBzdGFiaWxp dHkgYW5kIHBlcmZvcm1hbmNlCuKAkyBUaGUgbmV3IGh5cGVydmlzb3IgbW9kZSB0byBnZXQgaGFy ZGVyIGFuZCBmYXN0ZXIKCgxRdWVzdGlvbnM/CgpSdXNzZWxsLlBhdmxpY2VrQFhlblByb2plY3Qu b3JnClR3aXR0ZXI6IEBSQ1BhdmxpY2VrCgoM --_005_55E78A57290FB64FA0D3CF672F9F3DA21BA6CFSJCPEX01CL03citri_ Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Disposition: inline _______________________________________________ Xen-devel mailing list Xen-devel@lists.xen.org http://lists.xen.org/xen-devel --_005_55E78A57290FB64FA0D3CF672F9F3DA21BA6CFSJCPEX01CL03citri_-- From xen-devel-bounces@lists.xen.org Wed Mar 19 19:54:29 2014 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Wed, 19 Mar 2014 19:54:29 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WQMZG-00045P-AB; Wed, 19 Mar 2014 19:54:26 +0000 Received: from mail6.bemta4.messagelabs.com ([85.158.143.247]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WQMYu-00041K-Pi for xen-devel@lists.xen.org; Wed, 19 Mar 2014 19:54:20 +0000 Received: from [85.158.143.35:14887] by server-1.bemta-4.messagelabs.com id DE/46-09853-CD5F9235; Wed, 19 Mar 2014 19:54:04 +0000 X-Env-Sender: dgdegra@tycho.nsa.gov X-Msg-Ref: server-15.tower-21.messagelabs.com!1395258832!2604594!1 X-Originating-IP: [63.239.67.10] X-SpamReason: No, hits=0.5 required=7.0 tests=BODY_RANDOM_LONG, ML_RADAR_SPEW_LINKS_23,spamassassin: X-StarScan-Received: X-StarScan-Version: 6.11.1; banners=-,-,- X-VirusChecked: Checked Received: (qmail 13179 invoked from network); 19 Mar 2014 19:53:52 -0000 Received: from emvm-gh1-uea09.nsa.gov (HELO nsa.gov) (63.239.67.10) by server-15.tower-21.messagelabs.com with SMTP; 19 Mar 2014 19:53:52 -0000 X-TM-IMSS-Message-ID: <347db984001cbc51@nsa.gov> Received: from tarius.tycho.ncsc.mil ([144.51.242.1]) by nsa.gov ([63.239.67.10]) with ESMTP (TREND IMSS SMTP Service 7.1; TLSv1/SSLv3 DHE-RSA-AES256-SHA (256/256)) id 347db984001cbc51 ; Wed, 19 Mar 2014 15:55:04 -0400 Received: from moss-nexus.epoch.ncsc.mil (moss-nexus [192.168.25.48]) by tarius.tycho.ncsc.mil (8.14.4/8.14.4) with ESMTP id s2JJrPUw011485; Wed, 19 Mar 2014 15:53:37 -0400 From: Daniel De Graaf To: xen-devel@lists.xen.org Date: Wed, 19 Mar 2014 15:52:33 -0400 Message-Id: <1395258759-24968-2-git-send-email-dgdegra@tycho.nsa.gov> X-Mailer: git-send-email 1.8.5.3 In-Reply-To: <1395258759-24968-1-git-send-email-dgdegra@tycho.nsa.gov> References: <1395258759-24968-1-git-send-email-dgdegra@tycho.nsa.gov> Cc: dgdegra@tycho.nsa.gov Subject: [Xen-devel] [PATCH 1/7] vtpmmgr: add TPM group support X-BeenThere: xen-devel@lists.xen.org X-Mailman-Version: 2.1.13 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Sender: xen-devel-bounces@lists.xen.org Errors-To: xen-devel-bounces@lists.xen.org This is a complete rewrite of the disk format and key hierarchy for the TPM Manager. The new format supports multiple groups of vTPMs which define the permitted configurations where a given vTPM's keys are available, allowing upgrades of critical components while retaining the secrecy of cryptographic keys. New features of the TPM Manager are explained in the README and in the definitions of the management commands in vtpm_manager.h. New features for vTPMs: 1. The size of the state blob for a vTPM is expanded from 52 to 64 bytes in order to support future vTPMs using SHA-2/3 instead of SHA-1. 2. vTPMs can obtain a quote from the physical TPM with certain resettable PCRs set to include information about the vTPM. This can be used by a vTPM to provide evidence of its integrity, including the secrecy of its EK, and for deep quotes. Some additional changes made by this rewrite that may impact existing users: 1. The value of WELLKNOWN_OWNER_AUTH was incorrect for the physical TPM; the convention is to use all zero bits for well-known authentication values, not all one bits. 2. Randomly generating the owner auth value for the physical TPM is no longer supported, as it prevents later creation or certification of AIKs (which the old manager did not support). 3. The vTPM Manager needs to be provisioned with a PCR composite and an upgrade authority's public key before it will save data across boots. The current implementation still has some limitations: * 5 valid system PCR selections per group * The vTPM Manager's disk can use at most 2MB of space * The vTPM domain's build hash is always set to null/zero Most of the code relating to upgrade and rollback protection is currently stubbed out, but future versions can add: * Support for using the TPM's monotonic counter to prevent rollback of vTPM data by taking and restoring disk snapshots * Masking the master disk encryption key using a value stored in the TPM's NVRAM so that revocation of old data is possible without relying on all previously authorized software stacks to respect the monotonic counter's value Signed-off-by: Daniel De Graaf --- docs/misc/vtpm-platforms.txt | 127 ++++ docs/misc/vtpm.txt | 247 ++++--- docs/misc/vtpmmgr.txt | 163 +++++ stubdom/vtpm/README | 75 -- stubdom/vtpmmgr/Makefile | 4 +- stubdom/vtpmmgr/README | 75 -- stubdom/vtpmmgr/disk_crypto.c | 231 ++++++ stubdom/vtpmmgr/disk_crypto.h | 17 + stubdom/vtpmmgr/disk_format.h | 193 +++++ stubdom/vtpmmgr/disk_io.c | 125 ++++ stubdom/vtpmmgr/disk_io.h | 25 + stubdom/vtpmmgr/disk_read.c | 606 ++++++++++++++++ stubdom/vtpmmgr/disk_tpm.c | 238 +++++++ stubdom/vtpmmgr/disk_tpm.h | 25 + stubdom/vtpmmgr/disk_write.c | 410 +++++++++++ stubdom/vtpmmgr/endian_int.h | 72 ++ stubdom/vtpmmgr/init.c | 104 +-- stubdom/vtpmmgr/log.h | 8 +- stubdom/vtpmmgr/marshal.h | 824 ++++++++++++++-------- stubdom/vtpmmgr/mgmt_authority.c | 323 +++++++++ stubdom/vtpmmgr/mgmt_authority.h | 11 + stubdom/vtpmmgr/tcg.h | 7 + stubdom/vtpmmgr/tpm.c | 1360 ++++++++++++++++++------------------ stubdom/vtpmmgr/tpm.h | 104 +-- stubdom/vtpmmgr/tpmrsa.c | 25 + stubdom/vtpmmgr/tpmrsa.h | 3 + stubdom/vtpmmgr/vtpm_cmd_handler.c | 858 ++++++++++++++++++++--- stubdom/vtpmmgr/vtpm_disk.c | 237 +++++++ stubdom/vtpmmgr/vtpm_disk.h | 233 ++++++ stubdom/vtpmmgr/vtpm_manager.h | 391 ++++++++++- stubdom/vtpmmgr/vtpm_storage.c | 794 --------------------- stubdom/vtpmmgr/vtpm_storage.h | 68 -- stubdom/vtpmmgr/vtpmmgr.h | 12 +- 33 files changed, 5639 insertions(+), 2356 deletions(-) create mode 100644 docs/misc/vtpm-platforms.txt create mode 100644 docs/misc/vtpmmgr.txt delete mode 100644 stubdom/vtpm/README delete mode 100644 stubdom/vtpmmgr/README create mode 100644 stubdom/vtpmmgr/disk_crypto.c create mode 100644 stubdom/vtpmmgr/disk_crypto.h create mode 100644 stubdom/vtpmmgr/disk_format.h create mode 100644 stubdom/vtpmmgr/disk_io.c create mode 100644 stubdom/vtpmmgr/disk_io.h create mode 100644 stubdom/vtpmmgr/disk_read.c create mode 100644 stubdom/vtpmmgr/disk_tpm.c create mode 100644 stubdom/vtpmmgr/disk_tpm.h create mode 100644 stubdom/vtpmmgr/disk_write.c create mode 100644 stubdom/vtpmmgr/endian_int.h create mode 100644 stubdom/vtpmmgr/mgmt_authority.c create mode 100644 stubdom/vtpmmgr/mgmt_authority.h create mode 100644 stubdom/vtpmmgr/vtpm_disk.c create mode 100644 stubdom/vtpmmgr/vtpm_disk.h delete mode 100644 stubdom/vtpmmgr/vtpm_storage.c delete mode 100644 stubdom/vtpmmgr/vtpm_storage.h diff --git a/docs/misc/vtpm-platforms.txt b/docs/misc/vtpm-platforms.txt new file mode 100644 index 0000000..fe35fb6 --- /dev/null +++ b/docs/misc/vtpm-platforms.txt @@ -0,0 +1,127 @@ +Author: Daniel De Graaf + +================================================================================ +Overview +================================================================================ + +This document describes example platforms which use virtual TPMs to provide +security properties for guests running on the platforms. There are several +tradeoffs between flexibility and trust which must be considered when +implementing a platform containing vTPMs. + +================================================================================ +Example 1: Trusted Domain 0 +================================================================================ + +This is the simplest example and provides maximal flexibility for testing the +vTPM Manager and vTPMs. The vtpmmgr, vtpm, and guest domains are created using +xl from the command line on domain 0. + +Provisioning on domain 0: +# dd if=/dev/zero of=/images/vtpmmgr-stubdom.img bs=2M count=1 +# dd if=/dev/zero of=/images/vtpm-guest1.img bs=2M count=1 +# dd if=/dev/zero of=/images/vtpm-guest2.img bs=2M count=1 + +The vtpmmgr configuration file (vtpmmgr.cfg): + +name="vtpmmgr" +kernel="/usr/lib/xen/boot/vtpmmgr-stubdom.gz" +extra="tpmlocality=2" +memory=8 +disk=["file:/images/vtpmmgr-stubdom.img,hda,w"] +iomem=["fed42,1"] + +The vtpm configuration files (vtpm-guest1.cfg, vtpm-guest2.cfg): + +name="vtpm-guest1" +kernel="/usr/lib/xen/boot/vtpm-stubdom.gz" +extra="loglevel=debug" +memory=8 +disk=["file:/images/vtpm-guest1.img,hda,w"] +vtpm=["backend=vtpmmgr,uuid=ac0a5b9e-cbe2-4c07-b43b-1d69e46fb839"] + +name="vtpm-guest2" +kernel="/usr/lib/xen/boot/vtpm-stubdom.gz" +extra="loglevel=debug" +memory=8 +disk=["file:/images/vtpm-guest2.img,hda,w"] +vtpm=["backend=vtpmmgr,uuid=6c3ff5f1-8d58-4fed-b00d-a5ea9a817f7f"] + +The guest configuration files (guest1.cfg, guest2.cfg): + +name="guest1" +kernel="/usr/lib/xen/boot/pv-grub-x86_64.gz" +memory=1024 +disk=["file:/images/guest1.img,xvda,w"] +vif=['mac=00:01:02:03:04:05,bridge=br0'] +vtpm=["backend=vtpm-guest1"] + +name="guest2" +kernel="/usr/lib/xen/boot/pv-grub-x86_64.gz" +memory=1024 +disk=["file:/images/guest2.img,xvda,w"] +vif=['mac=00:01:02:03:04:06,bridge=br0'] +vtpm=["backend=vtpm-guest2"] + +Starting domains: + +# xl create vtpmmgr.cfg +# xl create vtpm-guest1.cfg +# xl create guest1.cfg + +================================================================================ +Example 2: Domain Builder with Static vTPMs +================================================================================ + +This example uses the domain builder to construct a TPM Manager and vTPM which +do not require trusting the hardware domain with the vTPM's secrets. However, +it is not possible to construct additional vTPMs after the system is booted, and +the guests with access to vTPMs may not be rebooted without rebooting the entire +platform. + +The domain builder (dom0) constructs: + dom1 - xenstore system_u:system_r:xenstore_t + dom2 - hardware system_u:system_r:hwdom_t + dom3 - vtpmmgr system_u:system_r:vtpmmgr_t + dom4 - vtpm-hw system_u:system_r:vtpm_t + dom5 - vtpm-g1 guest1_u:vm_r:vtpm_t + dom6 - vtpm-g2 guest2_u:vm_r:vtpm_t + dom7 - guest1 guest1_u:vm_r:guest_t + dom8 - guest2 guest2_u:vm_r:guest_t + +It unpauses dom1 and dom2 after setting up Xenstore. The hardware domain is not +permitted access to IO memory at 0xfed42; this IO memory is accessible to the +vtpmmgr domain. The two guest domains may be instantiated using pv-grub or +using the same kernel as the hardware domain to conserve space in the domain +builder's initrd. + +Once the hardware domain boots, it runs: + +# xl block-attach vtpmmgr 'backendtype=phy,backend=hardware,vdev=hda,access=w,target=/dev/lvm/vtpmmgr' +# xl block-attach vtpm-hw 'backendtype=phy,backend=hardware,vdev=hda,access=w,target=/dev/lvm/vtpm-hw' +# xl block-attach vtpm-g1 'backendtype=phy,backend=hardware,vdev=hda,access=w,target=/dev/lvm/vtpm-g1' +# xl block-attach vtpm-g2 'backendtype=phy,backend=hardware,vdev=hda,access=w,target=/dev/lvm/vtpm-g2' +# xl block-attach guest1 'backendtype=phy,backend=hardware,vdev=xvda,access=w,target=/dev/lvm/guest1' +# xl block-attach guest2 'backendtype=phy,backend=hardware,vdev=xvda,access=w,target=/dev/lvm/guest2' +# xl vtpm-attach vtpm-hw uuid=062b6416-ed46-492a-9e65-a2f92dc07f7f backend=vtpmmgr +# xl vtpm-attach vtpm-g1 uuid=e9aa9d0f-ece5-4b84-b129-93004ba61a5f backend=vtpmmgr +# xl vtpm-attach vtpm-g2 uuid=3fb2caf0-d305-4516-96c7-420618d98efb backend=vtpmmgr +# xl vtpm-attach hardware uuid=062b6416-ed46-492a-9e65-a2f92dc07f7f backend=vtpm-hw +# xl vtpm-attach guest1 uuid=e9aa9d0f-ece5-4b84-b129-93004ba61a5f backend=vtpm-g1 +# xl vtpm-attach guest2 uuid=3fb2caf0-d305-4516-96c7-420618d98efb backend=vtpm-g2 + +Once these commands are complete, the domains are unpaused and may boot. The XSM +policy must be configured to not allow any of the domain types named above to be +created by any domain except the domain builder; guests created by the hardware +domain or one of the primary guests acting as a control domain must have a +different type. The type vtpmmgr_t may only map grants from vtpm_t; vtpm_t may +only map grants from a domain of type guest_t or hwdom_t with the same user +field. + +This example may be extended to allow dynamic creation of domains by using a +domain builder that accepts build requests. A single build request would create +a pair of domains using an unused XSM user field: a vTPM and a pv-grub domain +which requires the presence of a vTPM. To bind the configuration of the guest +to the vTPM, the guest may use full-disk encryption which can be unlocked using +an unseal operation; using the wrong vTPM will then yield a non-functioning +guest. diff --git a/docs/misc/vtpm.txt b/docs/misc/vtpm.txt index d20b424..1887d40 100644 --- a/docs/misc/vtpm.txt +++ b/docs/misc/vtpm.txt @@ -22,8 +22,8 @@ major component of vTPM is implemented as a separate domain, providing secure separation guaranteed by the hypervisor. The vTPM domains are implemented in mini-os to reduce memory and processor overhead. -This mini-os vTPM subsystem was built on top of the previous vTPM -work done by IBM and Intel corporation. +This mini-os vTPM subsystem was built on top of the previous vTPM work done by +IBM and Intel corporation. ------------------------------ DESIGN OVERVIEW @@ -106,16 +106,15 @@ INSTALLATION Prerequisites: -------------- -You must have an x86 machine with a TPM on the motherboard. -The only software requirement to compiling vTPM is cmake. -You must use libxl to manage domains with vTPMs. 'xm' is -deprecated and does not support vTPM. +You must have an x86 machine with a TPM on the motherboard. The only extra +software requirement for compiling vTPM is cmake. You must use libxl to manage +domains with vTPMs; 'xm' is deprecated and does not support vTPMs. -Compiling the XEN tree: +Compiling the Xen tree: ----------------------- -Compile and install the XEN tree as usual. Be sure to build and install -the stubdom tree. +Compile and install the Xen tree as usual; be sure that the vTPM domains are +enabled when you run configure. Compiling the LINUX dom0 kernel: -------------------------------- @@ -127,16 +126,15 @@ blacklisting the module. If dom0 needs a TPM but does not need to use it during the boot process (i.e. it is not using IMA), a virtual TPM can be attached to dom0 after the system is booted. -Because the TPM manager does not yet accept requests for deep quotes, if a quote -or other request needs to be fulfilled by the physical TPM, dom0 will need to -access the physical TPM. In order to prevent interference, the TPM Manager and -dom0 should use different values for the TPM's locality; since Linux always uses -locality 0, using locality 2 for the TPM Manager is recommended. If both Linux -and the TPM Manager attempt to access the TPM at the same time, the TPM device -will return a busy status; some applications will consider this a fatal error -instead of retrying the command at a later time. If a vTPM gets an error when -loading its key, it will currently generate a fresh vTPM image (with a new EK, -SRK, and blank NVRAM). +Access to the physical TPM may be required in order to manage the NVRAM or to +perform other advanced operations where the vTPM is insufficient. In order to +prevent interference, the TPM Manager and dom0 should use different values for +the TPM's locality; since Linux always uses locality 0, using locality 2 for the +TPM Manager is recommended. If both Linux and the TPM Manager attempt to access +the TPM at the same time, the TPM device will return a busy status; some +applications will consider this a fatal error instead of retrying the command at +a later time. If a vTPM gets an error when loading its key, it will currently +generate a fresh vTPM image (with a new EK, SRK, and blank NVRAM). Compiling the LINUX domU kernel: @@ -156,130 +154,100 @@ VTPM MANAGER SETUP Manager disk image setup: ------------------------- -The vTPM Manager requires a disk image to store its -encrypted data. The image does not require a filesystem -and can live anywhere on the host disk. The image does not need -to be large. 8 to 16 Mb should be sufficient. - -# dd if=/dev/zero of=/var/vtpmmgr-stubdom.img bs=16M count=1 +The vTPM Manager requires a disk image to store its encrypted data. The image +does not require a filesystem and can live anywhere on the host disk. The image +is not large; the Xen 4.5 vtpmmgr is limited to using the first 2MB of the image +but can support more than 20,000 vTPMs. Manager config file: -------------------- -The vTPM Manager domain (vtpmmgr-stubdom) must be started like -any other Xen virtual machine and requires a config file. -The manager requires a disk image for storage and permission -to access the hardware memory pages for the TPM. An -example configuration looks like the following. - -kernel="/usr/lib/xen/boot/vtpmmgr-stubdom.gz" -memory=16 -disk=["file:/var/vtpmmgr-stubdom.img,hda,w"] -name="vtpmmgr" -iomem=["fed40,5"] - -The iomem line tells xl to allow access to all of the TPM IO memory -pages, which are 5 pages (one per locality) that start at 0xfed40000. By -default, the TPM manager uses locality 0 (so only the page at 0xfed40 is -needed); this can be changed on the domain's command line. +The vTPM Manager domain (vtpmmgr-stubdom) must be started like any other Xen +virtual machine and requires a config file. The manager requires a disk image +for storage and permission to access the hardware memory pages for the TPM. The +disk must be presented as "hda", and the TPM memory pages are passed using the +iomem configuration parameter. The TPM TIS uses 5 pages of IO memory (one per +locality) that start at physical address 0xfed40000. By default, the TPM manager +uses locality 0 (so only the page at 0xfed40 is needed); this can be changed on +the domain's command line. For full functionality in deep quotes, using +locality 2 is required to manipulate PCR 20-22. Starting and stopping the manager: ---------------------------------- -The vTPM manager should be started at boot, you may wish to -create an init script to do this. - -# xl create -c vtpmmgr-stubdom.cfg +The vTPM manager should be started at boot; you may wish to create an init +script to do this. If a domain builder is used, the TPM Manager should be +started by the domain builder to minimize the trusted computing base for the +vTPM manager's secrets. Once initialization is complete you should see the following: INFO[VTPM]: Waiting for commands from vTPM's: -To shutdown the manager you must destroy it. To avoid data corruption, -only destroy the manager when you see the above "Waiting for commands" -message. This ensures the disk is in a consistent state. - -# xl destroy vtpmmgr-stubdom +The TPM Manager does not respond to shutdown requests; use the destroy command +to shut it down. ------------------------------ VTPM AND LINUX PVM SETUP ------------------------------ -In the following examples we will assume we have Linux -guest named "domu" with its associated configuration -located at /home/user/domu. It's vtpm will be named -domu-vtpm. - vTPM disk image setup: ---------------------- -The vTPM requires a disk image to store its persistent -data. The image does not require a filesystem. The image -does not need to be large. 8 Mb should be sufficient. - -# dd if=/dev/zero of=/home/user/domu/vtpm.img bs=8M count=1 +The vTPM requires a disk image to store its persistent data (RSA keys, NVRAM, +etc). The image does not require a filesystem. The image does not need to be +large; 2 Mb should be sufficient. vTPM config file: ----------------- -The vTPM domain requires a configuration file like -any other domain. The vTPM requires a disk image for -storage and a TPM frontend driver to communicate -with the manager. An example configuration is given: - -kernel="/usr/lib/xen/boot/vtpm-stubdom.gz" -memory=8 -disk=["file:/home/user/domu/vtpm.img,hda,w"] -name="domu-vtpm" -vtpm=["backend=vtpmmgr,uuid=ac0a5b9e-cbe2-4c07-b43b-1d69e46fb839"] +The vTPM domain requires a configuration file like any other domain. The vTPM +requires a disk image for storage and a TPM frontend driver to communicate with +the manager. You are required to generate a uuid for this vtpm, which is +specified on the "vtpm=" line that describes its connection to the vTPM Manager. +The uuidgen application may be used to generate a uuid, or one from the output +of the "manage-vtpmmgr.pl vtpm-add" command may be used to create a vTPM +belonging to a specific group. -The vtpm= line sets up the tpm frontend driver. The backend must set -to vtpmmgr. You are required to generate a uuid for this vtpm. -You can use the uuidgen unix program or some other method to create a -uuid. The uuid uniquely identifies this vtpm to manager. - -If you wish to clear the vTPM data you can either recreate the -disk image or change the uuid. +If you wish to clear the vTPM data you can either recreate the disk image or +change the uuid. Linux Guest config file: ------------------------ -The Linux guest config file needs to be modified to include -the Linux tpmfront driver. Add the following line: +The Linux guest config file needs to be modified to include the Linux tpmfront +driver. Add the following line: vtpm=["backend=domu-vtpm"] Currently only Linux guests are supported (PV or HVM with PV drivers). -Launching and shut down: ------------------------- - -To launch a Linux guest with a vTPM we first have to start the vTPM domain. - -# xl create -c /home/user/domu/vtpm.cfg +While attaching a vTPM after a guest is booted (using xl vtpm-attach) is +supported, the attached vTPM will not have a record of the boot of the attached +guest. Furthermore, if the vTPM has been freshly created, a malicious guest +could then extend any values into PCRs, potentially forging its boot +configuration. Attaching a vTPM to a running domain should only be used for +trusted domains or when measurements have already been sent to the vTPM from +another source. -After initialization is complete, you should see the following: -Info: Waiting for frontend domain to connect.. +Using the vTPM in the guest: +---------------------------- -Next, launch the Linux guest - -# xl create -c /home/user/domu/domu.cfg - -If xen-tpmfront was compiled as a module, be sure to load it -in the guest. +If xen-tpmfront was compiled as a module, it must be loaded it in the guest. # modprobe xen-tpmfront -After the Linux domain boots and the xen-tpmfront driver is loaded, -you should see the following on the vtpm console: +After the Linux domain boots and the xen-tpmfront driver is loaded, you should +see the following on the vtpm console: Info: VTPM attached to Frontend X/Y -If you have trousers and tpm_tools installed on the guest, you can test the -vtpm. +You can quickly test the vTPM by using the sysfs interface: -On guest: -# tcsd (if tcsd is not running already) -# tpm_version +# cat /sys/devices/vtpm-0/pubek +# cat /sys/devices/vtpm-0/pcrs + +If you have trousers and tpm_tools installed on the guest, the tpm_version +command should return the following: The version command should return the following: TPM 1.2 Version Info: @@ -290,12 +258,12 @@ The version command should return the following: TPM Version: 01010000 Manufacturer Info: 4554485a -You should also see the command being sent to the vtpm console as well -as the vtpm saving its state. You should see the vtpm key being -encrypted and stored on the vtpmmgr console. +You should also see the command being sent to the vtpm console as well as the +vtpm saving its state. You should see the vtpm key being encrypted and stored on +the vtpmmgr console. -You may wish to write a script to start your vtpm and guest together and -to destroy the vtpm when the guest shuts down. +You may wish to write a script to start your vtpm and guest together and to +destroy the vtpm when the guest shuts down. ------------------------------ INTEGRATION WITH PV-GRUB @@ -319,10 +287,69 @@ way can attest to its early boot state. MORE INFORMATION ------------------------------ -See stubdom/vtpmmgr/README for more details about how -the manager domain works, how to use it, and its command line -parameters. +See vtpmmgr.txt for more details about how the manager domain works, how to use +it, and its command line parameters. + +------------------------------ +VTPM DOMAIN OPERATION +------------------------------ + +The vtpm-stubdom is a mini-OS domain that emulates a TPM for the guest OS to +use. It is a small wrapper around the Berlios TPM emulator version 0.7.4. +Commands are passed from the linux guest via the mini-os TPM backend driver. +vTPM data is encrypted and stored via a disk image provided to the virtual +machine. The key used to encrypt the data along with a hash of the vTPM's data +is sent to the vTPM manager for secure storage and later retrieval. The vTPM +domain communicates with the manager using a mini-os tpm front/back device pair. + +------------------------------------ +VTPM DOMAIN COMMAND LINE ARGUMENTS +------------------------------------ + +Command line arguments are passed to the domain via the 'extra' parameter in the +VM config file. Each parameter is separated by white space. For example: + +extra="foo=bar baz" + +List of Arguments: +------------------ + +loglevel=: Controls the amount of logging printed to the console. + The possible values for are: + error + info (default) + debug -See stubdom/vtpm/README for more specifics about how vtpm-stubdom -operates and the command line options it accepts. +clear: Start the Berlios emulator in "clear" mode. (default) + +save: Start the Berlios emulator in "save" mode. + +deactivated: Start the Berlios emulator in "deactivated" mode. + See the Berlios TPM emulator documentation for details + about the startup mode. For all normal use, always use clear + which is the default. You should not need to specify any of these. + +maintcmds=<1|0>: Enable to disable the TPM maintenance commands. + These commands are used by tpm manufacturers and thus + open a security hole. They are disabled by default. + +hwinitpcr=: Initialize the virtual Platform Configuration Registers + (PCRs) with PCR values from the hardware TPM. Each pcr specified by + will be initialized with the value of that same PCR in TPM + once at startup. By default all PCRs are zero initialized. + Value values of are: + all: copy all pcrs + none: copy no pcrs (default) + : copy pcr n + : copy pcrs x to y (inclusive) + + These can also be combined by comma separation, for example: + hwinitpcrs=5,12-16 + will copy pcrs 5, 12, 13, 14, 15, and 16. + +------------------------------ +REFERENCES +------------------------------ +Berlios TPM Emulator: +http://tpm-emulator.berlios.de/ diff --git a/docs/misc/vtpmmgr.txt b/docs/misc/vtpmmgr.txt new file mode 100644 index 0000000..e3531b8 --- /dev/null +++ b/docs/misc/vtpmmgr.txt @@ -0,0 +1,163 @@ +Author: Daniel De Graaf + +This document describes the operation and command line interface of +vtpmmgr-stubdom. See docs/misc/vtpm.txt for details on the vTPM subsystem as a +whole. + +================================================================================ +Overview +================================================================================ + +The TPM Manager has three primary functions: + +1. Securely store the encryption keys for vTPMs +2. Provide a single controlled path of access to the physical TPM +3. Provide evidence (via TPM Quotes) of the current configuration + +When combined with a platform that provides a trusted method for creating +domains, the TPM Manager provides assurance that the private keys in a vTPM are +only available in specific trusted configurations. + +The manager accepts commands from the vtpm-stubdom domains via the mini-os TPM +backend driver. The vTPM manager communicates directly with hardware TPM using +the mini-os tpm_tis driver. + +================================================================================ +Boot Configurations and TPM Groups +================================================================================ + +The TPM Manager's data is secured by using the physical TPM's seal operation, +which allows data to be bound to specific PCRs. These PCRs are populated in the +physical TPM during the boot process, either by the firmware/BIOS or by a +dynamic launch environment such as TBOOT. In order to provide assurance of the +system's security, the PCRs used to seal the TPM manager's data must contain +measurements for domains used to bootstrap the TPM Manager and vTPMs. + +Because these measurements are based on hashes, they will change any time that +any component of the system is upgraded. Since it is not possible to construct a +list of all possible future good measurements, the job of approving +configurations is delegated to a third party, referred to here as the system +approval agent (SAA). The SAA is identified by its public (RSA) signature key, +which is used to sign lists of valid configurations. A single TPM manager can +support multiple SAAs via the use of vTPM groups. Each group is associated with +a single SAA; this allows the creation of a multi-tenant environment where +tenants may not all choose to trust the same SAA. + +Each vTPM is bound to a vTPM group at the time of its creation. Each vTPM group +has its own AIK in the physical TPM for quotes of the hardware TPM state; when +used with a conforming Privacy CA, this allows each group on the system to form +the basis of a distinct identity. + +================================================================================ +Initial Provisioning +================================================================================ + +When the TPM Manager first boots up, it will create a stub vTPM group along with +entries for any vTPMs that communicate with it. This stub group must be +provisioned with an SAA and a boot configuration in order to survive a reboot. + +When a vTPM is connected to the TPM Manager using a UUID that is not recognized, +a slot will be created in group 0 for it. In the future, this auto-creation may +be restricted to specific UUIDs (such as the all-zero UUID) to enforce the use +of the TPM manager as the generator of the UUID. The first vTPM to be connected +is given administrative privileges for the TPM Manager, and should be attached +to dom0 or a control domain in order to send provisioning commands. + +Provisioning a vTPM group for the system requires the public key of the SAA and +privacy CA data used to certify the AIK (see the TPM spec for details). Once the +group is created, a signed list of boot measurements can be installed. The +initial group controls the ability to boot the system as a whole, and cannot be +deleted once provisioned. + +================================================================================ +Command Line Arguments +================================================================================ + +Command line arguments are passed to the domain via the 'extra' parameter in the +VM config file. Each parameter is separated by white space. For example: + +extra="foo=bar baz" + +Valid arguments: + +owner_auth= +srk_auth= + Set the owner and SRK authdata for the TPM. If not specified, the + default is 160 zero bits (the well-known auth value). Valid values of + are: + well-known Use the well known auth (default) + hash: Use the given 40-character ASCII hex string + text: Use sha1 hash of . + +tpmdriver= + Choose the driver used for communication with the hardware TPM. Values + other than tpm_tis should only be used for testing. + + The possible values of are: + tpm_tis Direct communication with a hardware TPM 1.2. The + domain must have access to TPM IO memory. (default) + tpmfront Use the Xen tpmfront interface to talk to another + domain which provides access to the TPM. + +The following options only apply to the tpm_tis driver: + +tpmiomem=: The base address of the hardware memory pages of the TPM. + The default is 0xfed40000, as defined by the TCG's PC Client spec. + +tpmirq=: The irq of the hardware TPM if using interrupts. A value of + "probe" can be set to probe for the irq. A value of 0 disables + interrupts and uses polling (default 0). + +tpmlocality=: Attempt to use locality of the hardware TPM. + For full functionality of the TPM Manager, this should be set to "2". + +================================================================================ +Platform Security Assumptions +================================================================================ + +While the TPM Manager has the ability to check the hash of the vTPM requesting a +key, there is currently no trusted method to inform the TPM Manager of the hash +of each new domain. Because of this, the TPM Manager trusts the UUID key in +Xenstore to identify a vTPM in a trusted manner. The XSM policy may be used to +strengthen this assumption if the creation of vTPM-labeled domains is more +constrained (for example, only permitted to a domain builder service): the only +grants mapped by the TPM Manager should belong to vTPM domains, so restricting +the ability to map other domain's granted pages will prevent other domains from +directly requesting keys from the TPM Manager. + +A domain with direct access to the hardware TPM will be able to decrypt the TPM +Manager's disk image if the haredware TPM's PCR values are in a permitted +configuration. To protect the TPM Manager's data, the list of permitted +configurations should be chosen to include PCRs that measure the hypervisor, +domain 0, the TPM Manager, and other critical configuration such as the XSM +policy. If the TPM Manager is configured to use locality 2 as recommended, it +is safe to permit the hardware domain to access locality 0 (the default in +Linux), although concurrent use of the TPM should be avoided as it can result in +unexpected busy errors from the TPM driver. The ability to access locality 2 of +the TPM should be enforced using IO memory labeling in the XSM policy; the +physical address 0xFED42xxx is always locality 2 for TPMs using the TIS driver. + +================================================================================ +Appendix: unsecured migration process for vtpmmgr domain upgrade +================================================================================ + +There is no direct upgrade supported from previous versions of the vtpmmgr +domain due to changes in the on-disk format and the method used to seal data. +If a vTPM domain supports migration, this feature should be used to migrate the +vTPM's data; however, the vTPM packaged with Xen does not yet support migration. + +If adding migration support to the vTPM is not desired, a simpler migration +domain usable only for local migration can be constructed. The migration process +would look like the following: + +1. Start the old vtpmmgr +2. Start the vTPM migration domain +3. Attach the vTPM migration domain's vtpm/0 device to the old vtpmmgr +4. Migration domain executes vtpmmgr_LoadHashKey on vtpm/0 +5. Start the new vtpmmgr, possibly shutting down the old one first +6. Attach the vTPM migration domain's vtpm/1 device to the old vtpmmgr +7. Migration domain executes vtpmmgr_SaveHashKey on vtpm/1 + +This requires the migration domain must be added to the list of valid vTPM +kernel hashes. Because the TPM Manager currently does not verify vTPM kernel +hashes, the control domain can initiate this operation at any time. diff --git a/stubdom/vtpm/README b/stubdom/vtpm/README deleted file mode 100644 index 11bdacb..0000000 --- a/stubdom/vtpm/README +++ /dev/null @@ -1,75 +0,0 @@ -Copyright (c) 2010-2012 United States Government, as represented by -the Secretary of Defense. All rights reserved. -November 12 2012 -Authors: Matthew Fioravante (JHUAPL), - -This document describes the operation and command line interface -of vtpm-stubdom. See docs/misc/vtpm.txt for details on the -vTPM subsystem as a whole. - - ------------------------------- -OPERATION ------------------------------- - -The vtpm-stubdom is a mini-OS domain that emulates a TPM for the guest OS to -use. It is a small wrapper around the Berlios TPM emulator -version 0.7.4. Commands are passed from the linux guest via the -mini-os TPM backend driver. vTPM data is encrypted and stored via a disk image -provided to the virtual machine. The key used to encrypt the data along -with a hash of the vTPM's data is sent to the vTPM manager for secure storage -and later retrieval. The vTPM domain communicates with the manager using a -mini-os tpm front/back device pair. - ------------------------------- -COMMAND LINE ARGUMENTS ------------------------------- - -Command line arguments are passed to the domain via the 'extra' -parameter in the VM config file. Each parameter is separated -by white space. For example: - -extra="foo=bar baz" - -List of Arguments: ------------------- - -loglevel=: Controls the amount of logging printed to the console. - The possible values for are: - error - info (default) - debug - -clear: Start the Berlios emulator in "clear" mode. (default) - -save: Start the Berlios emulator in "save" mode. - -deactivated: Start the Berlios emulator in "deactivated" mode. - See the Berlios TPM emulator documentation for details - about the startup mode. For all normal use, always use clear - which is the default. You should not need to specify any of these. - -maintcmds=<1|0>: Enable to disable the TPM maintenance commands. - These commands are used by tpm manufacturers and thus - open a security hole. They are disabled by default. - -hwinitpcr=: Initialize the virtual Platform Configuration Registers - (PCRs) with PCR values from the hardware TPM. Each pcr specified by - will be initialized with the value of that same PCR in TPM - once at startup. By default all PCRs are zero initialized. - Value values of are: - all: copy all pcrs - none: copy no pcrs (default) - : copy pcr n - : copy pcrs x to y (inclusive) - - These can also be combined by comma separation, for example: - hwinitpcrs=5,12-16 - will copy pcrs 5, 12, 13, 14, 15, and 16. - ------------------------------- -REFERENCES ------------------------------- - -Berlios TPM Emulator: -http://tpm-emulator.berlios.de/ diff --git a/stubdom/vtpmmgr/Makefile b/stubdom/vtpmmgr/Makefile index af13b39..a39a22c 100644 --- a/stubdom/vtpmmgr/Makefile +++ b/stubdom/vtpmmgr/Makefile @@ -12,7 +12,9 @@ XEN_ROOT=../.. TARGET=vtpmmgr.a -OBJS=vtpmmgr.o vtpm_cmd_handler.o vtpm_storage.o init.o tpmrsa.o tpm.o log.o +OBJS=vtpmmgr.o vtpm_cmd_handler.o init.o tpmrsa.o tpm.o log.o +OBJS += vtpm_disk.o disk_tpm.o disk_io.o disk_crypto.o disk_read.o disk_write.o +OBJS += mgmt_authority.o CFLAGS+=-Werror -Iutil -Icrypto -Itcs CFLAGS+=-Wno-declaration-after-statement -Wno-unused-label diff --git a/stubdom/vtpmmgr/README b/stubdom/vtpmmgr/README deleted file mode 100644 index a70c1cc..0000000 --- a/stubdom/vtpmmgr/README +++ /dev/null @@ -1,75 +0,0 @@ -Copyright (c) 2010-2012 United States Government, as represented by -the Secretary of Defense. All rights reserved. -November 12 2012 -Authors: Matthew Fioravante (JHUAPL), - -This document describes the operation and command line interface -of vtpmmgr-stubdom. See docs/misc/vtpm.txt for details on the -vTPM subsystem as a whole. - - ------------------------------- -OPERATION ------------------------------- - -The vtpmmgr-stubdom implements a vTPM manager who has two major functions: - - - Securely store encryption keys for each of the vTPMS - - Regulate access to the hardware TPM for the entire system - -The manager accepts commands from the vtpm-stubdom domains via the mini-os -TPM backend driver. The vTPM manager communicates directly with hardware TPM -using the mini-os tpm_tis driver. - - -When the manager starts for the first time it will check if the TPM -has an owner. If the TPM is unowned, it will attempt to take ownership -with the supplied owner_auth (see below) and then create a TPM -storage key which will be used to secure vTPM key data. Currently the -manager only binds vTPM keys to the disk. In the future support -for sealing to PCRs should be added. - ------------------------------- -COMMAND LINE ARGUMENTS ------------------------------- - -Command line arguments are passed to the domain via the 'extra' -parameter in the VM config file. Each parameter is separated -by white space. For example: - -extra="foo=bar baz" - -List of Arguments: ------------------- - -owner_auth=: Set the owner auth of the TPM. The default - is the well known owner auth of all ones. - -srk_auth=: Set the SRK auth for the TPM. The default is - the well known srk auth of all zeroes. - The possible values of are: - well-known: Use the well known auth (default) - random: Randomly generate an auth - hash: : Use the given 40 character ASCII hex string - text: : Use sha1 hash of . - -tpmdriver=: Which driver to use to talk to the hardware TPM. - Don't change this unless you know what you're doing. - The possible values of are: - tpm_tis: Use the tpm_tis driver to talk directly to the TPM. - The domain must have access to TPM IO memory. (default) - tpmfront: Use tpmfront to talk to the TPM. The domain must have - a tpmfront device setup to talk to another domain - which provides access to the TPM. - -The following options only apply to the tpm_tis driver: - -tpmiomem=: The base address of the hardware memory pages of the - TPM (default 0xfed40000). - -tpmirq=: The irq of the hardware TPM if using interrupts. A value of - "probe" can be set to probe for the irq. A value of 0 - disabled interrupts and uses polling (default 0). - -tpmlocality=: Attempt to use locality of the hardware TPM. - (default 0) diff --git a/stubdom/vtpmmgr/disk_crypto.c b/stubdom/vtpmmgr/disk_crypto.c new file mode 100644 index 0000000..18718d0 --- /dev/null +++ b/stubdom/vtpmmgr/disk_crypto.c @@ -0,0 +1,231 @@ +#include +#include +#include +#include +#include + +#include "log.h" +#include "vtpmmgr.h" +#include "vtpm_disk.h" +#include "disk_io.h" +#include "disk_crypto.h" + +// XXX defining this stubs out all disk encryption for easier debugging +#undef DISK_IS_PLAINTEXT + +void do_random(void *buf, size_t size) +{ + int rc = ctr_drbg_random(&vtpm_globals.ctr_drbg, buf, size); + if (rc) abort(); +} + +void aes_setup(aes_context *ctx, const struct key128 *key) +{ + aes_setkey_enc(ctx, (void*)key, 128); +} + +static void aes_encrypt_ecb(void *target, const void *src, const aes_context *key_e) +{ + aes_crypt_ecb((void*)key_e, AES_ENCRYPT, src, target); +} + +void aes_encrypt_one(void *target, const void *src, const struct key128 *key) +{ + aes_context ctx; + aes_setkey_enc(&ctx, (void*)key, 128); + aes_crypt_ecb(&ctx, AES_ENCRYPT, src, target); +} + +void aes_decrypt_one(void *target, const void *src, const struct key128 *key) +{ + aes_context ctx; + aes_setkey_dec(&ctx, (void*)key, 128); + aes_crypt_ecb(&ctx, AES_DECRYPT, src, target); +} + +static void aes_ctr_one(uint64_t out[2], uint64_t ctr[2], const aes_context *key_e) +{ +#ifdef DISK_IS_PLAINTEXT + memset(out, 0, 16); +#else + aes_encrypt_ecb(out, ctr, key_e); +#endif + ctr[1]++; +} + +void aes_encrypt_ctr(void *target, size_t target_size, const void *srcv, size_t pt_size, const aes_context *key_e) +{ + uint64_t ctr[2]; + uint64_t tmp[2]; + uint64_t *dst = target; + const uint64_t *src = srcv; + + do_random(ctr, sizeof(ctr)); + dst[0] = ctr[0]; + dst[1] = ctr[1]; + dst += 2; + target_size -= 16; + + if (pt_size > target_size) + abort(); // invalid argument: target too small for plaintext + + while (pt_size >= 16) { + aes_ctr_one(tmp, ctr, key_e); + + dst[0] = tmp[0] ^ src[0]; + dst[1] = tmp[1] ^ src[1]; + + dst += 2; + src += 2; + pt_size -= 16; + target_size -= 16; + } + if (pt_size) { + uint64_t stmp[2]; + uint64_t dtmp[2]; + memset(stmp, 0, 16); + memcpy(stmp, src, pt_size); + + aes_ctr_one(tmp, ctr, key_e); + + dtmp[0] = tmp[0] ^ stmp[0]; + dtmp[1] = tmp[1] ^ stmp[1]; + if (target_size < 16) { + memcpy(dst, dtmp, target_size); + return; + } else { + memcpy(dst, dtmp, 16); + target_size -= 16; + } + } + while (target_size >= 16) { + aes_ctr_one(dst, ctr, key_e); + + dst += 2; + target_size -= 16; + } + if (target_size) + abort(); // invalid argument: overlarge target size is not a full block +} + +void aes_decrypt_ctr(void *target, size_t pt_size, const void *srcv, size_t src_size, const aes_context *key_e) +{ + uint64_t ctr[2]; + uint64_t tmp[2]; + uint64_t *dst = target; + const uint64_t *src = srcv; + + ctr[0] = src[0]; + ctr[1] = src[1]; + src += 2; + src_size -= 16; + + if (pt_size > src_size) + abort(); // invalid argument: source too small for plaintext + // we discard src_size now + + while (pt_size >= 16) { + aes_ctr_one(tmp, ctr, key_e); + dst[0] = tmp[0] ^ src[0]; + dst[1] = tmp[1] ^ src[1]; + + dst += 2; + src += 2; + pt_size -= 16; + } + if (pt_size) { + uint64_t stmp[2]; + uint64_t dtmp[2]; + memset(stmp, 0, 16); + memcpy(stmp, src, pt_size); + + aes_ctr_one(tmp, ctr, key_e); + + dtmp[0] = tmp[0] ^ stmp[0]; + dtmp[1] = tmp[1] ^ stmp[1]; + memcpy(dst, dtmp, pt_size); + } +} + +static void shl_128_mod_hex87(struct mac128 *dst, const struct mac128 *src) +{ + int i; + int carry = 0x87 * !!(src->bits[0] & 0x80); + for(i=0; i < 15; i++) + dst->bits[i] = (src->bits[i] << 1) | (src->bits[i+1] >> 7); + dst->bits[15] = (src->bits[15] << 1) ^ carry; +} + +static void xor128(struct mac128 *dst, const struct mac128 *s1, const struct mac128 *s2) +{ + int i; + for(i=0; i < 16; i++) + dst->bits[i] = s1->bits[i] ^ s2->bits[i]; +} + +void aes_cmac(struct mac128 *target, const void *src, size_t size, const aes_context *key) +{ + const struct mac128 *M = src; + struct mac128 x, y, L, K1, K2; + int i; + size_t bsize = (size - 1) / 16; + + memset(&x, 0, sizeof(x)); + aes_encrypt_ecb(&L, &x, key); + shl_128_mod_hex87(&K1, &L); + shl_128_mod_hex87(&K2, &K1); + + for(i=0; i < bsize; i++) { + xor128(&y, &x, &M[i]); + aes_encrypt_ecb(&x, &y, key); + } + if (size & 0xF) { + struct mac128 z; + memset(&z, 0, sizeof(z)); + memcpy(&z, M + bsize, size & 0xF); + xor128(&y, &x, &K2); + xor128(&x, &y, &z); + } else { + xor128(&y, &x, &K1); + xor128(&x, &y, M + bsize); + } + aes_encrypt_ecb(target, &x, key); +} + +static int verify_128(const void *a, const void* b) +{ + const volatile uint64_t *x = a; + const volatile uint64_t *y = b; + if ((x[0] ^ y[0]) | (x[1] ^ y[1])) + return 1; + return 0; +} + +int aes_cmac_verify(const struct mac128 *target, const void *src, size_t size, const aes_context *key) +{ + struct mac128 mac; + aes_cmac(&mac, src, size, key); + return verify_128(&mac, target); +} + +static int verify_256(const void *a, const void* b) +{ + const volatile uint64_t *x = a; + const volatile uint64_t *y = b; + if ((x[0] ^ y[0]) | (x[1] ^ y[1]) | (x[2] ^ y[2]) | (x[3] ^ y[3])) + return 1; + return 0; +} + +void sha256(struct hash256 *target, const void *src, size_t size) +{ + void* dst = target; + sha2(src, size, dst, 0); +} + +int sha256_verify(const struct hash256 *targ, const void *data, size_t size) +{ + struct hash256 hash; + sha256(&hash, data, size); + return verify_256(&hash, targ); +} diff --git a/stubdom/vtpmmgr/disk_crypto.h b/stubdom/vtpmmgr/disk_crypto.h new file mode 100644 index 0000000..faae9ab --- /dev/null +++ b/stubdom/vtpmmgr/disk_crypto.h @@ -0,0 +1,17 @@ +#ifndef __VTPMMGR_DISK_CRYPTO_H +#define __VTPMMGR_DISK_CRYPTO_H + +void do_random(void *buf, size_t size); +void aes_encrypt_one(void *target, const void *src, const struct key128 *key); +void aes_decrypt_one(void *target, const void *src, const struct key128 *key); + +void aes_setup(aes_context *ctx, const struct key128 *key); +void aes_encrypt_ctr(void *target, size_t target_size, const void *srcv, size_t src_size, const aes_context *key_e); +void aes_decrypt_ctr(void *target, size_t target_size, const void *srcv, size_t src_size, const aes_context *key_e); +void aes_cmac(struct mac128 *target, const void *src, size_t size, const aes_context *key); +int aes_cmac_verify(const struct mac128 *target, const void *src, size_t size, const aes_context *key); + +void sha256(struct hash256 *target, const void *src, size_t size); +int sha256_verify(const struct hash256 *targ, const void *data, size_t size); + +#endif diff --git a/stubdom/vtpmmgr/disk_format.h b/stubdom/vtpmmgr/disk_format.h new file mode 100644 index 0000000..bc20fbb --- /dev/null +++ b/stubdom/vtpmmgr/disk_format.h @@ -0,0 +1,193 @@ +#ifndef __VTPMMGR_DISK_FORMAT_H +#define __VTPMMGR_DISK_FORMAT_H + +static const uint8_t TPM_MGR_MAGIC[12] = { + 'T','P','M',0xfe,'M','G','R',0xdd,'D','O','M',0x00 +}; + +/** + * Sector 0 on disk: stored in plaintext + */ +struct disk_header { + char magic[12]; +#define TPM_MGR_VERSION 0 + be32_t version; +}; + +/** + * Raw contents of disk sectors that need both encryption and authentication + */ +struct disk_crypt_sector_plain { + struct mac128 mac; + union { + struct { + uint8_t iv[16]; + char data[4096-32]; + }; + uint8_t iv_data[4096-16]; + }; +}; + +/** + * Contents of the sealed blob in the root seal list + */ +struct disk_root_sealed_data { +#define DISK_ROOT_BOUND_MAGIC "Root" + char magic[4]; + uuid_t tpm_manager_uuid; + + be32_t nvram_slot; + struct tpm_authdata nvram_auth; + be32_t counter_index; + struct tpm_authdata counter_auth; + + /* encrypted (AES-ECB) with key from NVRAM */ + struct key128 tm_key; +}; + +/** + * Contents of the sealed blob in a group's seal list + */ +struct disk_group_sealed_data { +#define DISK_GROUP_BOUND_MAGIC "TGrp" + char magic[4]; + uuid_t tpm_manager_uuid; + struct tpm_authdata aik_authdata; + + struct key128 group_key; + struct key128 rollback_mac_key; +}; + +/** + * Contents of the seal_list_N sectors on disk (plaintext, linked list) + * + * The hdr field is unused except in sector 0 + */ +struct disk_seal_list { + struct disk_header hdr; + be32_t length; + sector_t next; +#define SEALS_PER_ROOT_SEAL_LIST 13 + struct disk_seal_entry entry[SEALS_PER_ROOT_SEAL_LIST]; +}; + +/** + * TODO - overflow for struct disk_group_boot_config_list + */ +struct disk_group_seal_list { + sector_t next; +#define SEALS_PER_GROUP_SEAL_LIST 13 + struct disk_seal_entry entry[SEALS_PER_GROUP_SEAL_LIST]; +}; + +/** + * Rollback detection MAC entry + */ +struct disk_rb_mac_entry { + be32_t id; + struct mac128 mac; +}; + +#define NR_ENTRIES_PER_ROOT 16 +/** + * The area of the root sector protected by rollback MACs + */ +struct disk_root_sector_mac1_area { + be64_t sequence; + be32_t tpm_counter_value; + + be32_t nr_groups; + struct hash256 group_hash[NR_ENTRIES_PER_ROOT]; +}; + +/** + * Decrypted contents of the root sector (sector 1 and 2) on disk + */ +struct disk_root_sector { + struct disk_root_sector_mac1_area v; + + sector_t group_loc[NR_ENTRIES_PER_ROOT]; + + uint8_t pad[8]; + + /* Rollback detection MACs */ + be32_t nr_rb_macs; + sector_t rb_next_loc; + /* used if rb_macs overflows */ + struct hash256 rb_next_hash; + +#define NR_RB_MACS_PER_ROOT 128 + struct disk_rb_mac_entry rb_macs[NR_RB_MACS_PER_ROOT]; +}; + +/** + * Hash tree for list expansion. Used for the list of groups in the root and for + * the list of vTPMs in a group. + */ +struct disk_itree_sector { +#define NR_ENTRIES_PER_ITREE 112 + sector_t location[NR_ENTRIES_PER_ITREE]; + /* SECTOR-HASH { */ + struct hash256 hash[NR_ENTRIES_PER_ITREE]; + /* SECTOR-HASH } */ +}; + +#define NR_ENTRIES_PER_GROUP_BASE 16 +/** + * Data that must remain constant if a group is not open + */ +struct disk_group_sector_mac3_area { + struct group_id_data id_data; /* MAC2 */ + struct group_details details; + struct disk_group_boot_config_list boot_configs; + + be32_t nr_vtpms; + struct hash256 vtpm_hash[NR_ENTRIES_PER_GROUP_BASE]; +}; + +/** + * Group metadata sector + * + * Encrypted with TM_KEY - takes 16 bytes for IV; integrity from parent. + */ +struct disk_group_sector { + /* SECTOR-HASH { */ + struct disk_group_sector_mac3_area v; + + /* MAC(MAC3, group_key) */ + struct mac128 group_mac; + /* SECTOR-HASH } */ + + sector_t vtpm_location[NR_ENTRIES_PER_GROUP_BASE]; + sector_t boot_configs_next; +}; + +/** + * Data on a vTPM which is available when its group is not open + */ +struct disk_vtpm_plain { + uuid_t uuid; + be32_t flags; +}; + +/** + * Data on a vTPM which is only available when its group is open + */ +struct disk_vtpm_secret { + uint8_t data[64]; +}; + +/** + * Contents of a vTPM data disk sector + * + * Encrypted with TM_KEY - takes 16 bytes for IV + */ +struct disk_vtpm_sector { + /* SECTOR-HASH { */ + struct disk_vtpm_plain header[VTPMS_PER_SECTOR]; + struct mac128 iv; + struct disk_vtpm_secret data[VTPMS_PER_SECTOR]; + /* SECTOR-HASH } */ +}; + +#endif diff --git a/stubdom/vtpmmgr/disk_io.c b/stubdom/vtpmmgr/disk_io.c new file mode 100644 index 0000000..02b4fdd --- /dev/null +++ b/stubdom/vtpmmgr/disk_io.c @@ -0,0 +1,125 @@ +#include +#include +#include +#include +#include +#include +#include +#include + +#include "vtpm_manager.h" +#include "log.h" +#include "uuid.h" + +#include "vtpmmgr.h" +#include "vtpm_disk.h" +#include "disk_tpm.h" +#include "disk_io.h" + +static uint8_t disk_staging_buf[4096] __attribute__((aligned(4096))); + +static struct blkfront_dev* blkdev; +static int blkfront_fd = -1; + +int vtpm_storage_init(void) { + struct blkfront_info info; + blkdev = init_blkfront(NULL, &info); + if (blkdev == NULL) + return -1; + blkfront_fd = blkfront_open(blkdev); + if (blkfront_fd < 0) + return -1; + return 0; +} + +void* disk_read_sector(sector_t sector) +{ + uint32_t pos = be32_native(sector); + int rc; + vtpmloginfo(VTPM_LOG_VTPM, "disk_read_sector %x\n", pos); + lseek(blkfront_fd, pos * 4096, SEEK_SET); + rc = read(blkfront_fd, disk_staging_buf, 4096); + if (rc != 4096) + abort(); + return disk_staging_buf; +} + +void* disk_write_buf(void) { return disk_staging_buf; } + +void disk_write_sector(sector_t sector, void* buf, size_t siz) +{ + int rc; + uint32_t pos = be32_native(sector); + lseek(blkfront_fd, pos * 4096, SEEK_SET); + if (siz < 4096) { + if (buf != disk_staging_buf) + memcpy(disk_staging_buf, buf, siz); + memset(disk_staging_buf + siz, 0, 4096 - siz); + buf = disk_staging_buf; + } else if (siz > 4096) + abort(); + + rc = write(blkfront_fd, buf, 4096); + if (rc != 4096) + abort(); +} + +void disk_write_barrier(void) +{ + blkfront_sync(blkdev); +} + +enum inuse_value { + UNUSED, + SLOT_1, + SLOT_2, + SHARED +}; + +/* TODO make this dynamic to support using more than 2MB of disk */ +#define DISK_MAX_SECTOR 0x200 + +/* The first 4 sectors are statically allocated: + * 0 - disk header (copy 1) + * 1 - disk header (copy 2) + * 2 - root sector (copy 1) + * 3 - root sector (copy 2) + */ +#define FIRST_DYNAMIC_SECTOR 4 + +static uint8_t sector_inuse_map[DISK_MAX_SECTOR]; + +static int active_slot(const struct mem_tpm_mgr *mgr) +{ + return 1 + mgr->active_root; +} + +void disk_set_used(sector_t loc, const struct mem_tpm_mgr *mgr) +{ + uint32_t s = be32_native(loc); + if (s > DISK_MAX_SECTOR) { + printk("Attempted disk_set_used %x\n", s); + return; + } + sector_inuse_map[s] |= active_slot(mgr); +} + +void disk_flush_slot(const struct mem_tpm_mgr *mgr) +{ + int i; + for(i = FIRST_DYNAMIC_SECTOR; i < DISK_MAX_SECTOR; i++) + sector_inuse_map[i] &= ~active_slot(mgr); +} + +sector_t disk_find_free(const struct mem_tpm_mgr *mgr) +{ + int i; + for(i = FIRST_DYNAMIC_SECTOR; i < DISK_MAX_SECTOR; i++) { + if (sector_inuse_map[i]) + continue; + sector_inuse_map[i] = active_slot(mgr); + return native_be32(i); + } + // TODO more graceful error handling (in callers) + abort(); +} diff --git a/stubdom/vtpmmgr/disk_io.h b/stubdom/vtpmmgr/disk_io.h new file mode 100644 index 0000000..c0d35a5 --- /dev/null +++ b/stubdom/vtpmmgr/disk_io.h @@ -0,0 +1,25 @@ +#ifndef __VTPMMGR_DISK_IO_H +#define __VTPMMGR_DISK_IO_H + +void* disk_read_sector(sector_t sector); +void disk_write_sector(sector_t sector, void* buf, size_t siz); +void* disk_write_buf(void); +void disk_write_barrier(void); + +sector_t disk_find_free(const struct mem_tpm_mgr *mgr); +void disk_flush_slot(const struct mem_tpm_mgr *mgr); +void disk_set_used(sector_t loc, const struct mem_tpm_mgr *mgr); + +void disk_write_all(struct mem_tpm_mgr *mgr); + +static inline sector_t seal_loc(struct mem_tpm_mgr *mgr) +{ + return native_be32(mgr->active_root); +} + +static inline sector_t root_loc(struct mem_tpm_mgr *mgr) +{ + return native_be32(2 + mgr->active_root); +} + +#endif diff --git a/stubdom/vtpmmgr/disk_read.c b/stubdom/vtpmmgr/disk_read.c new file mode 100644 index 0000000..33aacdd --- /dev/null +++ b/stubdom/vtpmmgr/disk_read.c @@ -0,0 +1,606 @@ +#include +#include +#include +#include +#include +#include +#include +#include + +#include "vtpm_manager.h" +#include "log.h" +#include "uuid.h" + +#include "vtpmmgr.h" +#include "vtpm_disk.h" +#include "disk_tpm.h" +#include "disk_io.h" +#include "disk_crypto.h" +#include "disk_format.h" + +static int disk_read_crypt_sector(void *data, size_t size, sector_t block, const struct mem_tpm_mgr *mgr) +{ + struct disk_crypt_sector_plain *sector = disk_read_sector(block); + if (!sector) + return 2; + + if (aes_cmac_verify(§or->mac, sector->data, sizeof(sector->data), &mgr->tm_key_e)) + return 2; + + aes_decrypt_ctr(data, size, sector->iv_data, sizeof(sector->iv_data), &mgr->tm_key_e); + return 0; +} + +static void group_free(struct mem_group *group) +{ + int i, j; + if (!group) + return; + if (group->data) { + for (i = 0; i < group->nr_pages; i++) { + for (j = 0; j < group->data[i].size; j++) { + free(group->data[i].vtpms[j]); + } + } + free(group->data); + } + free(group->seals); + free(group); +} + +static void mgr_free(struct mem_tpm_mgr *mgr) +{ + int i; + if (!mgr) + return; + if (mgr->groups) { + for(i=0; i < mgr->nr_groups; i++) + group_free(mgr->groups[i].v); + free(mgr->groups); + } + free(mgr); +} + +/* Open the group keys from one of the sealed strutures */ +static int find_group_key(struct mem_group *dst, + const struct disk_group_sector *group, + const struct mem_tpm_mgr *parent) +{ + int i, rc, rv = 1; + struct hash160 buf; + struct disk_group_sealed_data sealed; + + dst->nr_seals = be32_native(group->v.boot_configs.nr_cfgs); + if (dst->nr_seals > NR_SEALS_PER_GROUP) + return 3; // TODO support spill to extra pages + + dst->seals = calloc(dst->nr_seals, sizeof(dst->seals[0])); + if (!dst->seals) { + vtpmlogerror(VTPM_LOG_VTPM, "find_group_key alloc %x\n", dst->nr_seals); + return 2; + } + + for(i=0; i < dst->nr_seals; i++) { + const struct disk_seal_entry *cfg = &group->v.boot_configs.entry[i]; + dst->seals[i].pcr_selection = cfg->pcr_selection; + memcpy(&dst->seals[i].digest_release, &cfg->digest_release, 20); + + TPM_pcr_digest(&buf, cfg->pcr_selection); + if (memcmp(&buf, &cfg->digest_release, 20)) + continue; + rc = TPM_disk_unseal(&sealed, sizeof(sealed), cfg); + if (rc) + continue; + if (memcmp(&sealed.magic, DISK_GROUP_BOUND_MAGIC, 4)) + continue; + if (memcmp(sealed.tpm_manager_uuid, parent->uuid, 16)) + continue; + + memcpy(&dst->rollback_mac_key, &sealed.rollback_mac_key, 16); + memcpy(&dst->group_key, &sealed.group_key, 16); + memcpy(&dst->aik_authdata, &sealed.aik_authdata, 20); + rv = 0; + } + + // cache the list to allow writes without touching the TPM + memcpy(&dst->seal_bits, &group->v.boot_configs, sizeof(dst->seal_bits)); + dst->flags |= MEM_GROUP_FLAG_SEAL_VALID; + + return rv; +} + +static int parse_root_key(struct mem_tpm_mgr *dst, struct disk_seal_entry *src) +{ + int rc; + struct disk_root_sealed_data sealed; + + rc = TPM_disk_unseal(&sealed, sizeof(sealed), src); + if (rc) + return rc; + + if (memcmp(&sealed.magic, DISK_ROOT_BOUND_MAGIC, 4)) + return 1; + + rc = TPM_disk_nvread(&dst->nv_key, 16, sealed.nvram_slot, sealed.nvram_auth); + if (rc) + return rc; + + // TODO when an NV slot in the physical TPM is used to populate nv_key, + // that value should be used to mask the master key so that the value + // can be changed to revoke old disk state +#if 0 + aes_decrypt_one(&dst->tm_key, &sealed.tm_key, &dst->nv_key); +#else + memcpy(&dst->tm_key, &sealed.tm_key, 16); +#endif + + memcpy(dst->uuid, sealed.tpm_manager_uuid, 16); + dst->nvram_slot = sealed.nvram_slot; + memcpy(&dst->nvram_auth, &sealed.nvram_auth, sizeof(struct tpm_authdata)); + dst->counter_index = sealed.counter_index; + memcpy(&dst->counter_auth, &sealed.counter_auth, sizeof(struct tpm_authdata)); + + return 0; +} + +static struct mem_tpm_mgr *find_root_key(int active_root) +{ + sector_t seal_list = native_be32(active_root); + struct disk_seal_list *seal = disk_read_sector(seal_list); + struct hash160 buf; + int i, rc, nr; + struct mem_tpm_mgr *dst; + + if (memcmp(seal->hdr.magic, TPM_MGR_MAGIC, 12)) + return NULL; + + if (be32_native(seal->hdr.version) != TPM_MGR_VERSION) + return NULL; + + dst = calloc(1, sizeof(*dst)); + dst->active_root = active_root; + + for (nr = 0; nr < 100; nr++) { + disk_set_used(seal_list, dst); + uint32_t nr_seals = be32_native(seal->length); + if (nr_seals > SEALS_PER_ROOT_SEAL_LIST) + break; + for (i = 0; i < nr_seals; i++) { + struct disk_seal_entry *src = &seal->entry[i]; + + TPM_pcr_digest(&buf, src->pcr_selection); + if (memcmp(&buf, &src->digest_release, 20)) + continue; + + rc = parse_root_key(dst, src); + if (rc) + continue; + return dst; + } + seal_list = seal->next; + if (seal_list.value == 0) + break; + seal = disk_read_sector(seal_list); + } + mgr_free(dst); + return NULL; +} + +/* Load and verify one sector's worth of vTPMs. This loads all the vTPM entries + * and decrypts their state data into memory. + */ +static int load_verify_vtpm_page(struct mem_vtpm_page *dst, int base, + const struct mem_tpm_mgr *mgr, const aes_context *group_key) +{ + struct disk_vtpm_sector pt; + int i, rc; + + disk_set_used(dst->disk_loc, mgr); + + rc = disk_read_crypt_sector(&pt, sizeof(pt), dst->disk_loc, mgr); + if (rc) { + printk("Malformed sector %d\n", be32_native(dst->disk_loc)); + return rc; + } + + rc = sha256_verify(&dst->disk_hash, &pt, sizeof(pt)); + if (rc) { + printk("Hash mismatch in sector %d\n", be32_native(dst->disk_loc)); + return rc; + } + + if (!group_key) + return 0; + + aes_decrypt_ctr(pt.data, sizeof(pt.data), &pt.iv, sizeof(pt.data) + 16, group_key); + + for (i = 0; i < dst->size; i++) { + struct mem_vtpm *vtpm = calloc(1, sizeof(*vtpm)); + dst->vtpms[i] = vtpm; + memcpy(vtpm->uuid, pt.header[i].uuid, 16); + memcpy(vtpm->data, pt.data[i].data, 64); + vtpm->flags = be32_native(pt.header[i].flags); + vtpm->index_in_parent = i + base; + } + return 0; +} + +static int load_verify_vtpm_pages(struct mem_group *group, int base, int size, + const struct hash256 *hash, const sector_t *loc, + const struct mem_tpm_mgr *mgr, const aes_context *group_key) +{ + int i, rc; + struct mem_vtpm_page *page = group->data + base; + + /* base was in terms of sectors; convert to vtpms */ + base *= VTPMS_PER_SECTOR; + + for (i = 0; i < size; i++) { + page->disk_hash = hash[i]; + page->disk_loc = loc[i]; + if (group->nr_vtpms - base > VTPMS_PER_SECTOR) + page->size = VTPMS_PER_SECTOR; + else + page->size = group->nr_vtpms - base; + rc = load_verify_vtpm_page(page, base, mgr, group_key); + if (rc) + return rc; + base += VTPMS_PER_SECTOR; + } + + return 0; +} + +static int load_verify_vtpm_itree(struct mem_group_hdr *hdr, int base, int nr_entries, + const struct hash256 *hash, const sector_t *loc, int hsize, + const struct mem_tpm_mgr *mgr, const aes_context *group_key); + +static int load_verify_vtpm_itree(struct mem_group_hdr *hdr, int base, int nr_entries, + const struct hash256 *hash, const sector_t *loc, int hsize, + const struct mem_tpm_mgr *mgr, const aes_context *group_key) +{ + int i, rc, incr = 1, inuse_base = hdr->disk_nr_inuse, lsize; + + // increase tree depth until all entries fit + while (nr_entries > incr * hsize) + incr *= NR_ENTRIES_PER_ITREE; + + // save the list of used sectors (itree and vtpm) in the header + lsize = 1 + (nr_entries - 1) / incr; + hdr->disk_nr_inuse += lsize; + hdr->disk_inuse = realloc(hdr->disk_inuse, hdr->disk_nr_inuse * sizeof(sector_t)); + memcpy(&hdr->disk_inuse[inuse_base], loc, lsize * sizeof(sector_t)); + + // if the entries already fit, process vtpm pages + if (nr_entries <= hsize) + return load_verify_vtpm_pages(hdr->v, base, nr_entries, hash, loc, mgr, group_key); + + for (i = 0; i * incr < nr_entries; i++) { + struct disk_itree_sector pt; + int child_entries = incr; + + // the last sector is not completely full + if (nr_entries - i * incr < incr) + child_entries = nr_entries - i * incr; + + disk_set_used(loc[i], mgr); + hdr->disk_inuse[inuse_base++] = loc[i]; + + rc = disk_read_crypt_sector(&pt, sizeof(pt), loc[i], mgr); + if (rc) { + printk("Malformed sector %d\n", be32_native(loc[i])); + return rc; + } + + rc = sha256_verify(&hash[i], pt.hash, sizeof(pt.hash)); + if (rc) { + printk("Hash mismatch in sector %d\n", be32_native(loc[i])); + return rc; + } + + rc = load_verify_vtpm_itree(hdr, base, child_entries, pt.hash, pt.location, + NR_ENTRIES_PER_ITREE, mgr, group_key); + if (rc) + return rc; + + base += incr; + } + + return 0; +} + +/* Load and verify one group's data structure, including its vTPMs. + */ +static int load_verify_group(struct mem_group_hdr *dst, const struct mem_tpm_mgr *mgr) +{ + struct mem_group *group; + struct disk_group_sector disk; + int rc; + aes_context key_e; + aes_context *opened_key = NULL; + + disk_set_used(dst->disk_loc, mgr); + + rc = disk_read_crypt_sector(&disk, sizeof(disk), dst->disk_loc, mgr); + if (rc) { + printk("Malformed sector %d\n", be32_native(dst->disk_loc)); + return rc; + } + + rc = sha256_verify(&dst->disk_hash, &disk.v, sizeof(disk.v) + sizeof(disk.group_mac)); + if (rc) { + printk("Hash mismatch in sector %d\n", be32_native(dst->disk_loc)); + return rc; + } + + dst->v = group = calloc(1, sizeof(*group)); + + rc = find_group_key(group, &disk, mgr); + if (rc == 0) { + opened_key = &key_e; + /* Verify the group with the group's own key */ + aes_setup(opened_key, &group->group_key); + if (aes_cmac_verify(&disk.group_mac, &disk.v, sizeof(disk.v), opened_key)) { + printk("Group CMAC failed\n"); + return 2; + } + + memcpy(&group->id_data, &disk.v.id_data, sizeof(group->id_data)); + memcpy(&group->details, &disk.v.details, sizeof(group->details)); + } else if (rc == 1) { + // still need to walk the vtpm list + rc = 0; + } else { + printk("Group key unsealing failed\n"); + return rc; + } + + group->nr_vtpms = be32_native(disk.v.nr_vtpms); + group->nr_pages = (group->nr_vtpms + VTPMS_PER_SECTOR - 1) / VTPMS_PER_SECTOR; + + group->data = calloc(group->nr_pages, sizeof(group->data[0])); + + rc = load_verify_vtpm_itree(dst, 0, group->nr_pages, disk.v.vtpm_hash, + disk.vtpm_location, NR_ENTRIES_PER_GROUP_BASE, mgr, opened_key); + + if (!opened_key) { + /* remove the struct */ + free(group->data); + free(group->seals); + free(group); + dst->v = NULL; + } + + return rc; +} + +static int load_root_pre(struct disk_root_sector *root, struct mem_tpm_mgr *dst) +{ + int rc; + + aes_setup(&dst->tm_key_e, &dst->tm_key); + + rc = disk_read_crypt_sector(root, sizeof(*root), root_loc(dst), dst); + + if (rc) { + vtpmloginfo(VTPM_LOG_VTPM, "root cmac verify failed in slot %d\n", dst->active_root); + return 2; + } + + dst->root_seals_valid = 1 + dst->active_root; + dst->sequence = be64_native(root->v.sequence); + + return 0; +} + +static int load_verify_group_itree(struct mem_tpm_mgr *dst, int base, int nr_entries, + const struct hash256 *hash, const sector_t *loc, int hsize); + +static int load_verify_group_itree(struct mem_tpm_mgr *dst, int base, int nr_entries, + const struct hash256 *hash, const sector_t *loc, int hsize) +{ + int i, rc, incr = 1; + + if (nr_entries <= hsize) { + for(i=0; i < nr_entries; i++) { + struct mem_group_hdr *group = dst->groups + base + i; + group->disk_loc = loc[i]; + memcpy(&group->disk_hash, &hash[i], sizeof(group->disk_hash)); + rc = load_verify_group(group, dst); + if (rc) { + printk("Error loading group %d\n", base + i); + return rc; + } + } + return 0; + } + + // increase tree depth until all entries fit + while (nr_entries > incr * hsize) + incr *= NR_ENTRIES_PER_ITREE; + + for (i = 0; i * incr < nr_entries; i++) { + struct disk_itree_sector pt; + int child_entries = incr; + + // the last sector is not completely full + if (nr_entries - i * incr < incr) + child_entries = nr_entries - i * incr; + + disk_set_used(loc[i], dst); + + rc = disk_read_crypt_sector(&pt, sizeof(pt), loc[i], dst); + if (rc) { + printk("Malformed sector %d\n", be32_native(loc[i])); + return rc; + } + + rc = sha256_verify(&hash[i], pt.hash, sizeof(pt.hash)); + if (rc) { + printk("Hash mismatch in sector %d\n", be32_native(loc[i])); + return rc; + } + + rc = load_verify_group_itree(dst, base, child_entries, pt.hash, pt.location, NR_ENTRIES_PER_ITREE); + if (rc) + return rc; + + base += incr; + } + + return 0; +} + +static int load_root_post(struct mem_tpm_mgr *dst, const struct disk_root_sector *root) +{ + int rc, i, j; + uint32_t nr_disk_rbs = be32_native(root->nr_rb_macs); + + rc = TPM_disk_check_counter(dst->counter_index, dst->counter_auth, + root->v.tpm_counter_value); + if (rc) + return 2; + dst->counter_value = root->v.tpm_counter_value; + + dst->nr_groups = be32_native(root->v.nr_groups); + dst->groups = calloc(sizeof(dst->groups[0]), dst->nr_groups); + + if (!dst->groups) { + vtpmlogerror(VTPM_LOG_VTPM, "load_root_post alloc %x\n", dst->nr_groups); + return 2; + } + + rc = load_verify_group_itree(dst, 0, dst->nr_groups, + root->v.group_hash, root->group_loc, NR_ENTRIES_PER_ROOT); + if (rc) + return rc; + + /* Sanity check: group0 must be open */ + if (!dst->groups[0].v) { + printk("Error opening group 0\n"); + return 2; + } + + /* TODO support for spilling rollback list */ + if (nr_disk_rbs > NR_RB_MACS_PER_ROOT) + return 3; + + i = 0; + j = 0; + while (i < dst->nr_groups) { + aes_context key_e; + struct mem_group_hdr *group = &dst->groups[i]; + struct mem_group *groupv = group->v; + const struct disk_rb_mac_entry *ent = &root->rb_macs[j]; + + if (!groupv) { + i++; + // this group is not open - no need to verify now + continue; + } + + if (be32_native(ent->id) < i) { + // this entry is for a group that is not open + j++; + continue; + } + + if (j >= nr_disk_rbs || be32_native(ent->id) != i) { + // TODO allow delegation + if (!(groupv->details.flags.value & FLAG_ROLLBACK_DETECTED)) { + groupv->details.flags.value |= FLAG_ROLLBACK_DETECTED; + group->disk_loc.value = 0; + } + i++; + continue; + } + + aes_setup(&key_e, &groupv->rollback_mac_key); + if (aes_cmac_verify(&ent->mac, &root->v, sizeof(root->v), &key_e)) { + if (!(groupv->details.flags.value & FLAG_ROLLBACK_DETECTED)) { + groupv->details.flags.value |= FLAG_ROLLBACK_DETECTED; + group->disk_loc.value = 0; + } + } + i++; j++; + } + + return 0; +} + +int vtpm_load_disk(void) +{ + struct disk_root_sector root1, root2; + int rc = 0; + TPM_read_pcrs(); + + printk("TPM Manager - disk format %d\n", TPM_MGR_VERSION); + printk(" root seal: %lu; sector of %d: %lu\n", + sizeof(struct disk_root_sealed_data), SEALS_PER_ROOT_SEAL_LIST, sizeof(struct disk_seal_list)); + printk(" root: %lu v=%lu\n", sizeof(root1), sizeof(root1.v)); + printk(" itree: %lu; sector of %d: %lu\n", + 4 + 32, NR_ENTRIES_PER_ITREE, sizeof(struct disk_itree_sector)); + printk(" group: %lu v=%lu id=%lu md=%lu\n", + sizeof(struct disk_group_sector), sizeof(struct disk_group_sector_mac3_area), + sizeof(struct group_id_data), sizeof(struct group_details)); + printk(" group seal: %lu; %d in parent: %lu; sector of %d: %lu\n", + sizeof(struct disk_group_sealed_data), NR_SEALS_PER_GROUP, sizeof(struct disk_group_boot_config_list), + SEALS_PER_GROUP_SEAL_LIST, sizeof(struct disk_group_seal_list)); + printk(" vtpm: %lu+%lu; sector of %d: %lu\n", + sizeof(struct disk_vtpm_plain), sizeof(struct disk_vtpm_secret), + VTPMS_PER_SECTOR, sizeof(struct disk_vtpm_sector)); + + struct mem_tpm_mgr *mgr1 = find_root_key(0); + struct mem_tpm_mgr *mgr2 = find_root_key(1); + + rc = mgr1 ? load_root_pre(&root1, mgr1) : 0; + if (rc) { + mgr_free(mgr1); + mgr1 = NULL; + } + + rc = mgr2 ? load_root_pre(&root2, mgr2) : 0; + if (rc) { + mgr_free(mgr2); + mgr2 = NULL; + } + + printk("load_root_pre: %c/%c\n", mgr1 ? 'y' : 'n', mgr2 ? 'y' : 'n'); + + if (!mgr1 && !mgr2) + return 2; + + if (mgr1 && mgr2 && mgr2->sequence > mgr1->sequence) { + rc = load_root_post(mgr2, &root2); + if (rc) { + mgr_free(mgr2); + mgr2 = NULL; + } else { + mgr_free(mgr1); + g_mgr = mgr2; + return 0; + } + } + if (mgr1) { + rc = load_root_post(mgr1, &root1); + if (rc) { + mgr_free(mgr1); + } else { + mgr_free(mgr2); + g_mgr = mgr1; + return 0; + } + } + if (mgr2) { + rc = load_root_post(mgr2, &root2); + if (rc) { + mgr_free(mgr2); + } else { + g_mgr = mgr2; + return 0; + } + } + printk("Could not read vTPM disk\n"); + + return 2; +} diff --git a/stubdom/vtpmmgr/disk_tpm.c b/stubdom/vtpmmgr/disk_tpm.c new file mode 100644 index 0000000..6f5d556 --- /dev/null +++ b/stubdom/vtpmmgr/disk_tpm.c @@ -0,0 +1,238 @@ +/* TPM disk interface */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "tpm.h" +#include "tcg.h" + +#include "vtpmmgr.h" +#include "vtpm_disk.h" +#include "disk_tpm.h" + +// Print out input/output of seal/unseal operations (includes keys) +#undef DEBUG_SEAL_OPS + +#ifdef DEBUG_SEAL_OPS +#include "marshal.h" +#endif + +struct pcr_list { + TPM_DIGEST pcrs[24]; +}; + +static struct pcr_list hwtpm; + +void TPM_read_pcrs(void) +{ + int i; + for(i=0; i < 24; i++) + TPM_PCR_Read(i, &hwtpm.pcrs[i]); +} + +struct pcr_composite_3 { + be16_t sel_size; + uint8_t sel[3]; + be32_t val_size; + uint8_t val[0]; +} __attribute__((packed)); + +void TPM_pcr_digest(struct hash160 *buf, le32_t selection) +{ + int i; + int count = 0; + uint32_t sel = le32_native(selection); + struct pcr_composite_3 *v; + for(i=0; i < 24; i++) { + if (sel & (1 << i)) + count++; + } + v = alloca(sizeof(*v) + 20 * count); + v->sel_size = native_be16(3); + memcpy(v->sel, &selection, 3); + v->val_size = native_be32(20 * count); + + count = 0; + for(i=0; i < 24; i++) { + if (sel & (1 << i)) { + memcpy(v->val + 20 * count, &hwtpm.pcrs[i], 20); + count++; + } + } + + sha1((void*)v, sizeof(*v) + 20 * count, buf->bits); +} + + +int TPM_disk_seal(struct disk_seal_entry *dst, const void* src, size_t size) +{ + uint32_t rc; + TPM_PCR_INFO info; + TPM_STORED_DATA out; + TPM_AUTH_SESSION osap = TPM_AUTH_SESSION_INIT; + TPM_AUTHDATA sharedsecret; + TPM_AUTHDATA auth; + + rc = TPM_OSAP(TPM_ET_KEYHANDLE, TPM_SRK_KEYHANDLE, (void*)&vtpm_globals.srk_auth, + &sharedsecret, &osap); + + if (rc) abort(); + +#ifdef DEBUG_SEAL_OPS + int i; + printk("to-seal:"); + for(i=0; i < size; i++) + printk(" %02x", ((uint8_t*)src)[i]); + printk("\n"); +#endif + + memset(auth, 0, 20); + info.pcrSelection.sizeOfSelect = 3; + info.pcrSelection.pcrSelect = (void*)&dst->pcr_selection; + memcpy(&info.digestAtCreation, &dst->digest_at_seal, 20); + memcpy(&info.digestAtRelease, &dst->digest_release, 20); + + rc = TPM_Seal(TPM_SRK_KEYHANDLE, 45, &info, size, src, &out, + (void*)&sharedsecret, (void*)&auth, &osap); + + TPM_TerminateHandle(osap.AuthHandle); + +#ifdef DEBUG_SEAL_OPS + printk("TPM_Seal rc=%d encDataSize=%d sealInfoSize=%d\n", rc, out.encDataSize, out.sealInfoSize); +#endif + if (!rc) + memcpy(dst->sealed_data, out.encData, 256); + +#ifdef DEBUG_SEAL_OPS + uint8_t buf[512]; + uint8_t *start = buf; + uint8_t *end = pack_TPM_STORED_DATA(buf, &out); + printk("stored_data:"); + while (start != end) { + printk(" %02x", *start); + start++; + } + printk("\n"); +#endif + + free_TPM_STORED_DATA(&out); + return rc; +} + +int TPM_disk_unseal(void *dst, size_t size, const struct disk_seal_entry *src) +{ + uint32_t rc; + TPM_STORED_DATA in; + TPM_AUTH_SESSION oiap = TPM_AUTH_SESSION_INIT; + TPM_AUTHDATA auth; + uint32_t outSize = 0; + uint8_t *out = NULL; + + rc = TPM_OIAP(&oiap); + if (rc) abort(); + + memset(auth, 0, 20); + + in.ver = TPM_STRUCT_VER_1_1; + in.sealInfoSize = 45; + in.sealInfo.pcrSelection.sizeOfSelect = 3; + in.sealInfo.pcrSelection.pcrSelect = (void*)&src->pcr_selection; + memcpy(&in.sealInfo.digestAtCreation, &src->digest_at_seal, 20); + memcpy(&in.sealInfo.digestAtRelease, &src->digest_release, 20); + in.encDataSize = 256; + in.encData = (void*)src->sealed_data; + +#ifdef DEBUG_SEAL_OPS + uint8_t buf[512]; + uint8_t *start = buf; + uint8_t *end = pack_TPM_STORED_DATA(buf, &in); + printk("stored_data:"); + while (start != end) { + printk(" %02x", *start); + start++; + } + printk("\n"); +#endif + + rc = TPM_Unseal(TPM_SRK_KEYHANDLE, &in, &outSize, &out, + (void*)&vtpm_globals.srk_auth, (void*)&auth, &vtpm_globals.oiap, &oiap); + + TPM_TerminateHandle(oiap.AuthHandle); + +#ifdef DEBUG_SEAL_OPS + printk("TPM_Unseal rc=%d outSize=%d size=%d\n", rc, outSize, size); +#endif + if (!rc) { + memcpy(dst, out, size); +#ifdef DEBUG_SEAL_OPS + printk("unsealed:"); + int i; + for(i=0; i < size; i++) + printk(" %02x", ((uint8_t*)dst)[i]); + printk("\n"); +#endif + } + + free(out); + + return rc; +} + +int TPM_disk_nvalloc(be32_t *nvram_slot, struct tpm_authdata auth) +{ + // TODO-3 + nvram_slot->value = 0; + return 0; +} + +int TPM_disk_nvread(void *buf, size_t bufsiz, be32_t nvram_slot, struct tpm_authdata auth) +{ + // TODO-3 + memset(buf, 0, bufsiz); + return 0; +} + +int TPM_disk_nvwrite(void *buf, size_t bufsiz, be32_t nvram_slot, struct tpm_authdata auth) +{ + // TODO-3 + return 0; +} + +int TPM_disk_nvchange(be32_t nvram_slot, struct tpm_authdata old, struct tpm_authdata noo) +{ + // TODO-3 + return 0; +} + +int TPM_disk_alloc_counter(be32_t *slot, struct tpm_authdata auth, be32_t *value) +{ + // TODO-3 + slot->value = 0; + value->value = 0; + return 0; +} + +int TPM_disk_check_counter(be32_t slot, struct tpm_authdata auth, be32_t value) +{ + // TODO-3 + return 0; +} + +int TPM_disk_incr_counter(be32_t slot, struct tpm_authdata auth) +{ + // TODO-3 + return 0; +} + +int TPM_disk_change_counter(be32_t slot, struct tpm_authdata old, struct tpm_authdata noo) +{ + // TODO-3 + return 0; +} diff --git a/stubdom/vtpmmgr/disk_tpm.h b/stubdom/vtpmmgr/disk_tpm.h new file mode 100644 index 0000000..b235895 --- /dev/null +++ b/stubdom/vtpmmgr/disk_tpm.h @@ -0,0 +1,25 @@ +#ifndef __VTPMMGR_DISK_VTPM_H +#define __VTPMMGR_DISK_VTPM_H +#include "vtpm_disk.h" + +/* Read PCR values to determine which unseal to try */ +void TPM_read_pcrs(void); +void TPM_pcr_digest(struct hash160 *buf, le32_t selection); + +/* Sealing for key storage */ +int TPM_disk_seal(struct disk_seal_entry *dst, const void* src, size_t size); +int TPM_disk_unseal(void *dst, size_t size, const struct disk_seal_entry *src); + +/* NVRAM to allow revocation of TM-KEY */ +int TPM_disk_nvalloc(be32_t *nvram_slot, struct tpm_authdata auth); +int TPM_disk_nvread(void *buf, size_t bufsiz, be32_t nvram_slot, struct tpm_authdata auth); +int TPM_disk_nvwrite(void *buf, size_t bufsiz, be32_t nvram_slot, struct tpm_authdata auth); +int TPM_disk_nvchange(be32_t nvram_slot, struct tpm_authdata old, struct tpm_authdata noo); + +/* Monotonic counters to detect rollback */ +int TPM_disk_alloc_counter(be32_t *slot, struct tpm_authdata auth, be32_t *value); +int TPM_disk_check_counter(be32_t slot, struct tpm_authdata auth, be32_t value); +int TPM_disk_incr_counter(be32_t slot, struct tpm_authdata auth); +int TPM_disk_change_counter(be32_t slot, struct tpm_authdata old, struct tpm_authdata noo); + +#endif diff --git a/stubdom/vtpmmgr/disk_write.c b/stubdom/vtpmmgr/disk_write.c new file mode 100644 index 0000000..4c825c5 --- /dev/null +++ b/stubdom/vtpmmgr/disk_write.c @@ -0,0 +1,410 @@ +#include +#include +#include +#include +#include +#include +#include +#include + +#include "vtpm_manager.h" +#include "log.h" +#include "uuid.h" + +#include "vtpmmgr.h" +#include "vtpm_disk.h" +#include "disk_tpm.h" +#include "disk_io.h" +#include "disk_crypto.h" +#include "disk_format.h" +#include "mgmt_authority.h" + +static void disk_write_crypt_sector(sector_t *dst, const void *data, size_t size, const struct mem_tpm_mgr *mgr) +{ + struct disk_crypt_sector_plain *sector = disk_write_buf(); + *dst = disk_find_free(mgr); + aes_encrypt_ctr(sector->iv_data, sizeof(sector->iv_data), data, size, &mgr->tm_key_e); + aes_cmac(§or->mac, sector->data, sizeof(sector->data), &mgr->tm_key_e); + disk_write_sector(*dst, sector, sizeof(*sector)); +} + +/* + * Mark unchanged sectors on disk as being used + */ +static void disk_populate_used_vtpm(const struct mem_vtpm_page *src, const struct mem_tpm_mgr *mgr) +{ + if (be32_native(src->disk_loc) != 0) + disk_set_used(src->disk_loc, mgr); +} + +/* + * Write out a vTPM page to disk, doing nothing if the existing copy is valid + */ +static void disk_write_vtpm_page(struct mem_vtpm_page *dst, const aes_context *auth_key, + const struct mem_tpm_mgr *mgr) +{ + struct disk_vtpm_sector pt; + int i; + memset(&pt, 0, sizeof(pt)); + if (be32_native(dst->disk_loc) != 0) + return; + + for(i=0; i < dst->size; i++) { + memcpy(pt.header[i].uuid, dst->vtpms[i]->uuid, 16); + memcpy(pt.data[i].data, dst->vtpms[i]->data, 64); + pt.header[i].flags = native_be32(dst->vtpms[i]->flags & VTPM_FLAG_DISK_MASK); + } + aes_encrypt_ctr(&pt.iv, sizeof(pt.data) + 16, &pt.data, sizeof(pt.data), auth_key); + + sha256(&dst->disk_hash, &pt, sizeof(pt)); + + disk_write_crypt_sector(&dst->disk_loc, &pt, sizeof(pt), mgr); +} + +/* + * Generate TPM seal blobs for a group's keys; do nothing if existing copy is valid + */ +static void generate_group_seals(struct mem_group *src, const struct mem_tpm_mgr *parent) +{ + int i; + struct disk_group_sealed_data sblob; + + // previous seals are still valid, skip talking to the TPM + if (src->flags & MEM_GROUP_FLAG_SEAL_VALID) + return; + + memcpy(&sblob.magic, DISK_GROUP_BOUND_MAGIC, 4); + memcpy(sblob.tpm_manager_uuid, parent->uuid, 16); + memcpy(&sblob.aik_authdata, &src->aik_authdata, 20); + memcpy(&sblob.group_key, &src->group_key, 16); + memcpy(&sblob.rollback_mac_key, &src->rollback_mac_key, 16); + + /* TODO support for more than NR_SEALS_PER_GROUP seals */ + if (src->nr_seals > NR_SEALS_PER_GROUP) + abort(); + + for(i=0; i < src->nr_seals; i++) { + struct disk_seal_entry *dst = &src->seal_bits.entry[i]; + dst->pcr_selection = src->seals[i].pcr_selection; + memcpy(&dst->digest_release, &src->seals[i].digest_release, 20); + TPM_pcr_digest(&dst->digest_at_seal, dst->pcr_selection); + TPM_disk_seal(dst, &sblob, sizeof(sblob)); + } + src->seal_bits.nr_cfgs = native_be32(src->nr_seals); + + src->flags |= MEM_GROUP_FLAG_SEAL_VALID; +} + +/* + * Mark unchanged sectors on disk as being used + */ +static void disk_populate_used_group(const struct mem_group_hdr *src, const struct mem_tpm_mgr *mgr) +{ + int i; + struct mem_group *group = src->v; + if (be32_native(src->disk_loc) != 0) { + // entire group is unchanged - mark group, itree, and vtpm sectors + // TODO mark other children (seal) + disk_set_used(src->disk_loc, mgr); + for(i = 0; i < src->disk_nr_inuse; i++) + disk_set_used(src->disk_inuse[i], mgr); + return; + } + + // unopened groups should never have been invalidated + if (!group) + abort(); + + for (i = 0; i < group->nr_pages; i++) + disk_populate_used_vtpm(&group->data[i], mgr); +} + +static void disk_write_vtpm_itree(struct mem_group_hdr *hdr, int base, int nr_entries, + struct hash256 *hash, sector_t *loc, int hsize, + const aes_context *group_key, const struct mem_tpm_mgr *mgr); + +static void disk_write_vtpm_itree(struct mem_group_hdr *hdr, int base, int nr_entries, + struct hash256 *hash, sector_t *loc, int hsize, + const aes_context *group_key, const struct mem_tpm_mgr *mgr) +{ + int i, incr = 1, inuse_base, lsize; + + while (nr_entries > incr * hsize) + incr *= NR_ENTRIES_PER_ITREE; + + if (nr_entries <= hsize) { + struct mem_group *group = hdr->v; + for (i = 0; i < nr_entries; i++) { + struct mem_vtpm_page *page = group->data + base + i; + disk_write_vtpm_page(page, group_key, mgr); + loc[i] = page->disk_loc; + hash[i] = page->disk_hash; + } + } else { + for (i = 0; i * incr < nr_entries; i++) { + struct disk_itree_sector pt; + int child_entries = incr; + + // the last sector is not completely full + if (nr_entries - i * incr < incr) + child_entries = nr_entries - i * incr; + + disk_write_vtpm_itree(hdr, base, child_entries, pt.hash, pt.location, + NR_ENTRIES_PER_ITREE, group_key, mgr); + + sha256(&hash[i], &pt.hash, sizeof(pt.hash)); + disk_write_crypt_sector(&loc[i], &pt, sizeof(pt), mgr); + + base += incr; + } + } + + // save the list of used sectors (itree and vtpm) in the header + inuse_base = hdr->disk_nr_inuse; + lsize = 1 + (nr_entries - 1) / incr; + hdr->disk_nr_inuse += lsize; + hdr->disk_inuse = realloc(hdr->disk_inuse, hdr->disk_nr_inuse * sizeof(sector_t)); + memcpy(&hdr->disk_inuse[inuse_base], loc, lsize * sizeof(sector_t)); +} + +/* + * Write out a vTPM group sector and its children + */ +static void disk_write_group_sector(struct mem_group_hdr *src, + const struct mem_tpm_mgr *mgr) +{ + struct disk_group_sector disk; + struct mem_group *group = src->v; + aes_context key_e; + + /* Don't write if the data hasn't changed */ + if (be32_native(src->disk_loc) != 0) + return; + + // if the group was not opened, it should not have been changed + if (!group) + abort(); + + memset(&disk, 0, sizeof(disk)); + memcpy(&disk.v.id_data, &group->id_data, sizeof(disk.v.id_data)); + memcpy(&disk.v.details, &group->details, sizeof(disk.v.details)); + + aes_setup(&key_e, &group->group_key); + + disk.v.nr_vtpms = native_be32(group->nr_vtpms); + + // regenerated + src->disk_nr_inuse = 0; + + disk_write_vtpm_itree(src, 0, group->nr_pages, disk.v.vtpm_hash, disk.vtpm_location, + NR_ENTRIES_PER_GROUP_BASE, &key_e, mgr); + + generate_group_seals(group, mgr); + memcpy(&disk.v.boot_configs, &group->seal_bits, sizeof(group->seal_bits)); + + aes_cmac(&disk.group_mac, &disk.v, sizeof(disk.v), &key_e); + sha256(&src->disk_hash, &disk.v, sizeof(disk.v) + sizeof(disk.group_mac)); + disk_write_crypt_sector(&src->disk_loc, &disk, sizeof(disk), mgr); +} + +/* + * Write TPM seal blobs for the manager's keys, using the given group's list + * of valid configurations + */ +static void disk_write_seal_list(struct mem_tpm_mgr *mgr, struct mem_group *group) +{ + int i; + struct disk_seal_list *seal = disk_write_buf(); + struct disk_root_sealed_data sblob; + + if (mgr->root_seals_valid & (1 + mgr->active_root)) + return; + + memcpy(&sblob.magic, DISK_ROOT_BOUND_MAGIC, 4); + memcpy(sblob.tpm_manager_uuid, mgr->uuid, 16); + memcpy(&sblob.nvram_slot, &mgr->nvram_slot, 4); + memcpy(&sblob.nvram_auth, &mgr->nvram_auth, 20); + memcpy(&sblob.counter_index, &mgr->counter_index, 4); + memcpy(&sblob.counter_auth, &mgr->counter_auth, 20); + + // TODO when an NV slot in the physical TPM is used to populate nv_key, + // that value should be used to mask the master key so that the value + // can be changed to revoke old disk state +#if 0 + aes_encrypt_one(&sblob.tm_key, &mgr->tm_key, &mgr->nv_key); +#else + memcpy(&sblob.tm_key, &mgr->tm_key, 16); +#endif + + memset(seal, 0, sizeof(*seal)); + seal->length = native_be32(group->nr_seals); + + // TODO support for more entries + if (group->nr_seals > SEALS_PER_ROOT_SEAL_LIST) + abort(); + + for(i=0; i < group->nr_seals; i++) { + struct mem_seal *src = &group->seals[i]; + struct disk_seal_entry *dst = &seal->entry[i]; + dst->pcr_selection = src->pcr_selection; + memcpy(&dst->digest_release, &src->digest_release, 20); + TPM_pcr_digest(&dst->digest_at_seal, dst->pcr_selection); + + TPM_disk_seal(dst, &sblob, sizeof(sblob)); + } + + memcpy(seal->hdr.magic, TPM_MGR_MAGIC, 12); + seal->hdr.version = native_be32(TPM_MGR_VERSION); + + disk_write_sector(seal_loc(mgr), seal, sizeof(*seal)); + mgr->root_seals_valid |= 1 + mgr->active_root; +} + +/* + * Mark unchanged sectors on disk as being used + */ +static void disk_populate_used_mgr(const struct mem_tpm_mgr *mgr) +{ + int i; + + // TODO walk the linked lists for seals, rb_macs here (when supported) + + for(i=0; i < mgr->nr_groups; i++) + disk_populate_used_group(&mgr->groups[i], mgr); +} + +static void disk_write_group_itree(struct mem_tpm_mgr *mgr, int base, int nr_entries, + struct hash256 *hash, sector_t *loc, int hsize); + +static void disk_write_group_itree(struct mem_tpm_mgr *mgr, int base, int nr_entries, + struct hash256 *hash, sector_t *loc, int hsize) +{ + int i, incr = 1; + + if (nr_entries <= hsize) { + for(i=0; i < mgr->nr_groups; i++) { + struct mem_group_hdr *group = mgr->groups + base + i; + disk_write_group_sector(group, mgr); + loc[i] = group->disk_loc; + hash[i] = group->disk_hash; + } + return; + } + + while (nr_entries > incr * hsize) + incr *= NR_ENTRIES_PER_ITREE; + + for (i = 0; i * incr < nr_entries; i++) { + struct disk_itree_sector pt; + int child_entries = incr; + + // the last sector is not completely full + if (nr_entries - i * incr < incr) + child_entries = nr_entries - i * incr; + + disk_write_group_itree(mgr, base, child_entries, pt.hash, pt.location, NR_ENTRIES_PER_ITREE); + + sha256(&hash[i], &pt.hash, sizeof(pt.hash)); + disk_write_crypt_sector(&loc[i], &pt, sizeof(pt), mgr); + + base += incr; + } +} + +/* + * Write out the root TPM Manager sector and its children + */ +static void disk_write_root_sector(struct mem_tpm_mgr *mgr) +{ + int i, j; + struct disk_root_sector root; + memset(&root, 0, sizeof(root)); + root.v.sequence = native_be64(mgr->sequence); + root.v.tpm_counter_value = mgr->counter_value; + + root.v.nr_groups = native_be32(mgr->nr_groups); + + disk_write_group_itree(mgr, 0, mgr->nr_groups, root.v.group_hash, root.group_loc, NR_ENTRIES_PER_ROOT); + + i = 0; + j = 0; + while (i < mgr->nr_groups) { + aes_context key_e; + struct mem_group_hdr *group = &mgr->groups[i]; + struct mem_group *groupv = group->v; + + if (!groupv) { + i++; + continue; + } + if (groupv->details.flags.value & FLAG_ROLLBACK_DETECTED) { + i++; + continue; + } + if (j >= NR_RB_MACS_PER_ROOT) + break; // TODO support for nr_rb_macs > 128 + + aes_setup(&key_e, &groupv->rollback_mac_key); + root.rb_macs[j].id = native_be32(i); + aes_cmac(&root.rb_macs[j].mac, &root.v, sizeof(root.v), &key_e); + i++; j++; + } + root.nr_rb_macs = native_be32(j); + + struct disk_crypt_sector_plain *root_sect = disk_write_buf(); + aes_encrypt_ctr(root_sect->iv_data, sizeof(root_sect->iv_data), &root, sizeof(root), &mgr->tm_key_e); + aes_cmac(&root_sect->mac, &root_sect->data, sizeof(root_sect->data), &mgr->tm_key_e); + disk_write_sector(root_loc(mgr), root_sect, sizeof(*root_sect)); +} + +/* + * Write out changes to disk + */ +void disk_write_all(struct mem_tpm_mgr *mgr) +{ + disk_flush_slot(mgr); + disk_populate_used_mgr(mgr); + disk_write_root_sector(mgr); + + disk_write_seal_list(mgr, mgr->groups[0].v); + + disk_write_barrier(); +} + +/* + * Create a new (blank) TPM Manager disk image. + * + * Does not actually write anything to disk. + */ +int vtpm_new_disk(void) +{ + int rc; + struct mem_tpm_mgr *mgr = calloc(1, sizeof(*mgr)); + + do_random(mgr->uuid, 16); + do_random(&mgr->tm_key, 16); + do_random(&mgr->nvram_auth, 20); + do_random(&mgr->counter_auth, 20); + do_random(&mgr->nv_key, 16); + + aes_setup(&mgr->tm_key_e, &mgr->tm_key); + + // TODO postpone these allocs until first write? + rc = TPM_disk_nvalloc(&mgr->nvram_slot, mgr->nvram_auth); + if (rc) + return rc; + + rc = TPM_disk_alloc_counter(&mgr->counter_index, mgr->counter_auth, &mgr->counter_value); + if (rc) + return rc; + + mgr->nr_groups = 1; + mgr->groups = calloc(1, sizeof(mgr->groups[0])); + mgr->groups[0].v = vtpm_new_group(NULL); + + TPM_disk_nvwrite(&mgr->nv_key, 16, mgr->nvram_slot, mgr->nvram_auth); + + g_mgr = mgr; + + return 0; +} diff --git a/stubdom/vtpmmgr/endian_int.h b/stubdom/vtpmmgr/endian_int.h new file mode 100644 index 0000000..030f87b --- /dev/null +++ b/stubdom/vtpmmgr/endian_int.h @@ -0,0 +1,72 @@ +#ifndef __VTPMMGR_ENDIAN_INT_H +#define __VTPMMGR_ENDIAN_INT_H + +#include + +/* These wrapper structs force the use of endian-to-CPU conversions */ + +typedef struct be_int16 { + uint16_t value; +} be16_t; + +typedef struct be_int32 { + uint32_t value; +} be32_t; + +typedef struct le_int32 { + uint32_t value; +} le32_t; + +typedef struct be_int64 { + uint64_t value; +} be64_t; + +static inline uint16_t be16_native(be16_t v) +{ + return be16_to_cpu(v.value); +} + +static inline uint32_t le32_native(le32_t v) +{ + return le32_to_cpu(v.value); +} + +static inline uint32_t be32_native(be32_t v) +{ + return be32_to_cpu(v.value); +} + +static inline uint64_t be64_native(be64_t v) +{ + return be64_to_cpu(v.value); +} + +static inline be16_t native_be16(uint16_t v) +{ + be16_t rv; + rv.value = cpu_to_be16(v); + return rv; +} + +static inline le32_t native_le32(uint32_t v) +{ + le32_t rv; + rv.value = cpu_to_le32(v); + return rv; +} + +static inline be32_t native_be32(uint32_t v) +{ + be32_t rv; + rv.value = cpu_to_be32(v); + return rv; +} + +static inline be64_t native_be64(uint64_t v) +{ + be64_t rv; + rv.value = cpu_to_be64(v); + return rv; +} + +#endif diff --git a/stubdom/vtpmmgr/init.c b/stubdom/vtpmmgr/init.c index 33ac152..89643e7 100644 --- a/stubdom/vtpmmgr/init.c +++ b/stubdom/vtpmmgr/init.c @@ -48,7 +48,7 @@ #include "log.h" #include "vtpmmgr.h" -#include "vtpm_storage.h" +#include "vtpm_disk.h" #include "tpm.h" #include "marshal.h" @@ -64,16 +64,11 @@ struct Opts { }; // --------------------------- Well Known Auths -------------------------- -const TPM_AUTHDATA WELLKNOWN_SRK_AUTH = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +const TPM_AUTHDATA WELLKNOWN_AUTH = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; -const TPM_AUTHDATA WELLKNOWN_OWNER_AUTH = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; - struct vtpm_globals vtpm_globals = { .tpm_fd = -1, - .storage_key = TPM_KEY_INIT, - .storage_key_handle = 0, .oiap = { .AuthHandle = 0 } }; @@ -247,42 +242,11 @@ abort_egress: return status; } -static void init_storage_key(TPM_KEY* key) { - key->ver.major = 1; - key->ver.minor = 1; - key->ver.revMajor = 0; - key->ver.revMinor = 0; - - key->keyUsage = TPM_KEY_BIND; - key->keyFlags = 0; - key->authDataUsage = TPM_AUTH_ALWAYS; - - TPM_KEY_PARMS* p = &key->algorithmParms; - p->algorithmID = TPM_ALG_RSA; - p->encScheme = TPM_ES_RSAESOAEP_SHA1_MGF1; - p->sigScheme = TPM_SS_NONE; - p->parmSize = 12; - - TPM_RSA_KEY_PARMS* r = &p->parms.rsa; - r->keyLength = RSA_KEY_SIZE; - r->numPrimes = 2; - r->exponentSize = 0; - r->exponent = NULL; - - key->PCRInfoSize = 0; - key->encDataSize = 0; - key->encData = NULL; -} - -static int parse_auth_string(char* authstr, BYTE* target, const TPM_AUTHDATA wellknown, int allowrandom) { +static int parse_auth_string(char* authstr, BYTE* target) { int rc; /* well known owner auth */ if(!strcmp(authstr, "well-known")) { - memcpy(target, wellknown, sizeof(TPM_AUTHDATA)); - } - /* Create a randomly generated owner auth */ - else if(allowrandom && !strcmp(authstr, "random")) { - return 1; + return 0; } /* owner auth is a raw hash */ else if(!strncmp(authstr, "hash:", 5)) { @@ -318,12 +282,12 @@ int parse_cmdline_opts(int argc, char** argv, struct Opts* opts) int i; //Set defaults - memcpy(vtpm_globals.owner_auth, WELLKNOWN_OWNER_AUTH, sizeof(TPM_AUTHDATA)); - memcpy(vtpm_globals.srk_auth, WELLKNOWN_SRK_AUTH, sizeof(TPM_AUTHDATA)); + memcpy(vtpm_globals.owner_auth, WELLKNOWN_AUTH, sizeof(TPM_AUTHDATA)); + memcpy(vtpm_globals.srk_auth, WELLKNOWN_AUTH, sizeof(TPM_AUTHDATA)); for(i = 1; i < argc; ++i) { if(!strncmp(argv[i], "owner_auth:", 10)) { - if((rc = parse_auth_string(argv[i] + 10, vtpm_globals.owner_auth, WELLKNOWN_OWNER_AUTH, 1)) < 0) { + if((rc = parse_auth_string(argv[i] + 10, vtpm_globals.owner_auth)) < 0) { goto err_invalid; } if(rc == 1) { @@ -331,7 +295,7 @@ int parse_cmdline_opts(int argc, char** argv, struct Opts* opts) } } else if(!strncmp(argv[i], "srk_auth:", 8)) { - if((rc = parse_auth_string(argv[i] + 8, vtpm_globals.srk_auth, WELLKNOWN_SRK_AUTH, 0)) != 0) { + if((rc = parse_auth_string(argv[i] + 8, vtpm_globals.srk_auth)) != 0) { goto err_invalid; } } @@ -389,8 +353,6 @@ static TPM_RESULT vtpmmgr_create(void) { TPMTRYRETURN(try_take_ownership()); // Generate storage key's auth - memset(&vtpm_globals.storage_key_usage_auth, 0, sizeof(TPM_AUTHDATA)); - TPMTRYRETURN( TPM_OSAP( TPM_ET_KEYHANDLE, TPM_SRK_KEYHANDLE, @@ -398,30 +360,11 @@ static TPM_RESULT vtpmmgr_create(void) { &sharedsecret, &osap) ); - init_storage_key(&vtpm_globals.storage_key); - - //initialize the storage key - TPMTRYRETURN( TPM_CreateWrapKey( - TPM_SRK_KEYHANDLE, - (const TPM_AUTHDATA*)&sharedsecret, - (const TPM_AUTHDATA*)&vtpm_globals.storage_key_usage_auth, - (const TPM_AUTHDATA*)&vtpm_globals.storage_key_usage_auth, - &vtpm_globals.storage_key, - &osap) ); - - //Load Storage Key - TPMTRYRETURN( TPM_LoadKey( - TPM_SRK_KEYHANDLE, - &vtpm_globals.storage_key, - &vtpm_globals.storage_key_handle, - (const TPM_AUTHDATA*) &vtpm_globals.srk_auth, - &vtpm_globals.oiap)); - //Make sure TPM has commited changes TPMTRYRETURN( TPM_SaveState() ); //Create new disk image - TPMTRYRETURN(vtpm_storage_new_header()); + TPMTRYRETURN(vtpm_new_disk()); goto egress; abort_egress: @@ -436,10 +379,21 @@ egress: return status; } -/* Set up the opaque field to contain a pointer to the UUID */ -static void set_opaque_to_uuid(domid_t domid, unsigned int handle) +static void set_opaque(domid_t domid, unsigned int handle) +{ + struct tpm_opaque* opq; + + opq = calloc(1, sizeof(*opq)); + opq->uuid = (uuid_t*)tpmback_get_uuid(domid, handle); + tpmback_set_opaque(domid, handle, opq); +} + +static void free_opaque(domid_t domid, unsigned int handle) { - tpmback_set_opaque(domid, handle, tpmback_get_uuid(domid, handle)); + struct tpm_opaque* opq = tpmback_get_opaque(domid, handle); + if (opq && opq->vtpm) + opq->vtpm->flags &= ~VTPM_FLAG_OPEN; + free(opq); } TPM_RESULT vtpmmgr_init(int argc, char** argv) { @@ -468,7 +422,7 @@ TPM_RESULT vtpmmgr_init(int argc, char** argv) { } //Setup tpmback device - init_tpmback(set_opaque_to_uuid, NULL); + init_tpmback(set_opaque, free_opaque); //Setup tpm access switch(opts.tpmdriver) { @@ -521,7 +475,8 @@ TPM_RESULT vtpmmgr_init(int argc, char** argv) { TPMTRYRETURN( TPM_OIAP(&vtpm_globals.oiap) ); /* Load the Manager data, if it fails create a new manager */ - if (vtpm_storage_load_header() != TPM_SUCCESS) { + // TODO handle upgrade recovery of auth0 + if (vtpm_load_disk()) { /* If the OIAP session was closed by an error, create a new one */ if(vtpm_globals.oiap.AuthHandle == 0) { TPMTRYRETURN( TPM_OIAP(&vtpm_globals.oiap) ); @@ -539,19 +494,12 @@ egress: void vtpmmgr_shutdown(void) { - /* Cleanup resources */ - free_TPM_KEY(&vtpm_globals.storage_key); - /* Cleanup TPM resources */ - TPM_EvictKey(vtpm_globals.storage_key_handle); TPM_TerminateHandle(vtpm_globals.oiap.AuthHandle); /* Close tpmback */ shutdown_tpmback(); - /* Close the storage system and blkfront */ - vtpm_storage_shutdown(); - /* Close tpmfront/tpm_tis */ close(vtpm_globals.tpm_fd); diff --git a/stubdom/vtpmmgr/log.h b/stubdom/vtpmmgr/log.h index 5c7abf5..455219f 100644 --- a/stubdom/vtpmmgr/log.h +++ b/stubdom/vtpmmgr/log.h @@ -64,18 +64,20 @@ extern char *module_names[]; #define SETBIT(num,idx) (num) |= BITMASK(idx) #define CLEARBIT(num,idx) (num) &= ( ~ BITMASK(idx) ) +void printk(const char *fmt, ...); + #define vtpmloginfo(module, fmt, args...) \ if (GETBIT (LOGGING_MODULES, module) == 1) { \ - fprintf (stdout, "INFO[%s]: " fmt, module_names[module], ##args); \ + printk("INFO[%s]: " fmt, module_names[module], ##args); \ } #define vtpmloginfomore(module, fmt, args...) \ if (GETBIT (LOGGING_MODULES, module) == 1) { \ - fprintf (stdout, fmt,##args); \ + printk(fmt,##args); \ } #define vtpmlogerror(module, fmt, args...) \ - fprintf (stderr, "ERROR[%s]: " fmt, module_names[module], ##args); + printk("ERROR[%s]: " fmt, module_names[module], ##args); //typedef UINT32 tpm_size_t; diff --git a/stubdom/vtpmmgr/marshal.h b/stubdom/vtpmmgr/marshal.h index 77d32f0..ef54272 100644 --- a/stubdom/vtpmmgr/marshal.h +++ b/stubdom/vtpmmgr/marshal.h @@ -43,79 +43,81 @@ #include "tcg.h" typedef enum UnpackPtr { - UNPACK_ALIAS, - UNPACK_ALLOC + UNPACK_ALIAS, + UNPACK_ALLOC } UnpackPtr; inline BYTE* pack_BYTE(BYTE* ptr, BYTE t) { - ptr[0] = t; - return ++ptr; + ptr[0] = t; + return ++ptr; } inline BYTE* unpack_BYTE(BYTE* ptr, BYTE* t) { - t[0] = ptr[0]; - return ++ptr; + t[0] = ptr[0]; + return ++ptr; } +inline int unpack3_BYTE(BYTE* ptr, UINT32* pos, UINT32 max, BYTE *t) +{ + if (*pos + 1 > max) + return TPM_SIZE; + unpack_BYTE(ptr + *pos, t); + *pos += 1; + return 0; +} + + #define pack_BOOL(p, t) pack_BYTE(p, t) #define unpack_BOOL(p, t) unpack_BYTE(p, t) +#define unpack3_BOOL(p, x, m, t) unpack3_BYTE(p, x, m, t) +#define sizeof_BOOL(t) 1 -inline BYTE* pack_UINT16(BYTE* ptr, UINT16 t) { - BYTE* b = (BYTE*)&t; -#if __BYTE_ORDER == __LITTLE_ENDIAN - ptr[0] = b[1]; - ptr[1] = b[0]; -#elif __BYTE_ORDER == __BIG_ENDIAN - ptr[0] = b[0]; - ptr[1] = b[1]; -#endif - return ptr + sizeof(UINT16); +inline BYTE* pack_UINT16(void* ptr, UINT16 t) { + UINT16* p = ptr; + *p = cpu_to_be16(t); + return ptr + sizeof(UINT16); } -inline BYTE* unpack_UINT16(BYTE* ptr, UINT16* t) { - BYTE* b = (BYTE*)t; -#if __BYTE_ORDER == __LITTLE_ENDIAN - b[0] = ptr[1]; - b[1] = ptr[0]; -#elif __BYTE_ORDER == __BIG_ENDIAN - b[0] = ptr[0]; - b[1] = ptr[1]; -#endif - return ptr + sizeof(UINT16); -} - -inline BYTE* pack_UINT32(BYTE* ptr, UINT32 t) { - BYTE* b = (BYTE*)&t; -#if __BYTE_ORDER == __LITTLE_ENDIAN - ptr[3] = b[0]; - ptr[2] = b[1]; - ptr[1] = b[2]; - ptr[0] = b[3]; -#elif __BYTE_ORDER == __BIG_ENDIAN - ptr[0] = b[0]; - ptr[1] = b[1]; - ptr[2] = b[2]; - ptr[3] = b[3]; -#endif - return ptr + sizeof(UINT32); -} - -inline BYTE* unpack_UINT32(BYTE* ptr, UINT32* t) { - BYTE* b = (BYTE*)t; -#if __BYTE_ORDER == __LITTLE_ENDIAN - b[0] = ptr[3]; - b[1] = ptr[2]; - b[2] = ptr[1]; - b[3] = ptr[0]; -#elif __BYTE_ORDER == __BIG_ENDIAN - b[0] = ptr[0]; - b[1] = ptr[1]; - b[2] = ptr[2]; - b[3] = ptr[3]; -#endif - return ptr + sizeof(UINT32); +inline BYTE* unpack_UINT16(void* ptr, UINT16* t) { + UINT16* p = ptr; + *t = be16_to_cpu(*p); + return ptr + sizeof(UINT16); +} + +inline int unpack3_UINT16(BYTE* ptr, UINT32* pos, UINT32 max, UINT16 *t) +{ + if (*pos + 2 > max) + return TPM_SIZE; + unpack_UINT16(ptr + *pos, t); + *pos += 2; + return 0; +} + +inline BYTE* pack_UINT32(void* ptr, UINT32 t) { + UINT32* p = ptr; + *p = cpu_to_be32(t); + return ptr + sizeof(UINT32); +} + +inline BYTE* unpack_UINT32(void* ptr, UINT32* t) { + UINT32* p = ptr; + *t = be32_to_cpu(*p); + return ptr + sizeof(UINT32); +} + +inline int unpack3_UINT32(BYTE* ptr, UINT32* pos, UINT32 max, UINT32 *t) +{ + if (*pos + 4 > max) + return TPM_SIZE; + unpack_UINT32(ptr + *pos, t); + *pos += 4; + return 0; } +#define sizeof_BYTE(x) 1 +#define sizeof_UINT16(x) 2 +#define sizeof_UINT32(x) 4 + #define pack_TPM_RESULT(p, t) pack_UINT32(p, t) #define pack_TPM_PCRINDEX(p, t) pack_UINT32(p, t) #define pack_TPM_DIRINDEX(p, t) pack_UINT32(p, t) @@ -166,55 +168,139 @@ inline BYTE* unpack_UINT32(BYTE* ptr, UINT32* t) { #define unpack_TPM_PHYSICAL_PRESENCE(p, t) unpack_UINT16(p, t) #define unpack_TPM_KEY_FLAGS(p, t) unpack_UINT32(p, t) -#define pack_TPM_AUTH_HANDLE(p, t) pack_UINT32(p, t); -#define pack_TCS_CONTEXT_HANDLE(p, t) pack_UINT32(p, t); -#define pack_TCS_KEY_HANDLE(p, t) pack_UINT32(p, t); +#define unpack3_TPM_RESULT(p, l, m, t) unpack3_UINT32(p, l, m, t) +#define unpack3_TPM_PCRINDEX(p, l, m, t) unpack3_UINT32(p, l, m, t) +#define unpack3_TPM_DIRINDEX(p, l, m, t) unpack3_UINT32(p, l, m, t) +#define unpack3_TPM_HANDLE(p, l, m, t) unpack3_UINT32(p, l, m, t) +#define unpack3_TPM_AUTHHANDLE(p, l, m, t) unpack3_TPM_HANDLE(p, l, m, t) +#define unpack3_TCPA_HASHHANDLE(p, l, m, t) unpack3_TPM_HANDLE(p, l, m, t) +#define unpack3_TCPA_HMACHANDLE(p, l, m, t) unpack3_TPM_HANDLE(p, l, m, t) +#define unpack3_TCPA_ENCHANDLE(p, l, m, t) unpack3_TPM_HANDLE(p, l, m, t) +#define unpack3_TPM_KEY_HANDLE(p, l, m, t) unpack3_TPM_HANDLE(p, l, m, t) +#define unpack3_TCPA_ENTITYHANDLE(p, l, m, t) unpack3_TPM_HANDLE(p, l, m, t) +#define unpack3_TPM_RESOURCE_TYPE(p, l, m, t) unpack3_UINT32(p, l, m, t) +#define unpack3_TPM_COMMAND_CODE(p, l, m, t) unpack3_UINT32(p, l, m, t) +#define unpack3_TPM_PROTOCOL_ID(p, l, m, t) unpack3_UINT16(p, l, m, t) +#define unpack3_TPM_AUTH_DATA_USAGE(p, l, m, t) unpack3_BYTE(p, l, m, t) +#define unpack3_TPM_ENTITY_TYPE(p, l, m, t) unpack3_UINT16(p, l, m, t) +#define unpack3_TPM_ALGORITHM_ID(p, l, m, t) unpack3_UINT32(p, l, m, t) +#define unpack3_TPM_KEY_USAGE(p, l, m, t) unpack3_UINT16(p, l, m, t) +#define unpack3_TPM_STARTUP_TYPE(p, l, m, t) unpack3_UINT16(p, l, m, t) +#define unpack3_TPM_CAPABILITY_AREA(p, l, m, t) unpack3_UINT32(p, l, m, t) +#define unpack3_TPM_ENC_SCHEME(p, l, m, t) unpack3_UINT16(p, l, m, t) +#define unpack3_TPM_SIG_SCHEME(p, l, m, t) unpack3_UINT16(p, l, m, t) +#define unpack3_TPM_MIGRATE_SCHEME(p, l, m, t) unpack3_UINT16(p, l, m, t) +#define unpack3_TPM_PHYSICAL_PRESENCE(p, l, m, t) unpack3_UINT16(p, l, m, t) +#define unpack3_TPM_KEY_FLAGS(p, l, m, t) unpack3_UINT32(p, l, m, t) + +#define sizeof_TPM_RESULT(t) sizeof_UINT32(t) +#define sizeof_TPM_PCRINDEX(t) sizeof_UINT32(t) +#define sizeof_TPM_DIRINDEX(t) sizeof_UINT32(t) +#define sizeof_TPM_HANDLE(t) sizeof_UINT32(t) +#define sizeof_TPM_AUTHHANDLE(t) sizeof_TPM_HANDLE(t) +#define sizeof_TCPA_HASHHANDLE(t) sizeof_TPM_HANDLE(t) +#define sizeof_TCPA_HMACHANDLE(t) sizeof_TPM_HANDLE(t) +#define sizeof_TCPA_ENCHANDLE(t) sizeof_TPM_HANDLE(t) +#define sizeof_TPM_KEY_HANDLE(t) sizeof_TPM_HANDLE(t) +#define sizeof_TCPA_ENTITYHANDLE(t) sizeof_TPM_HANDLE(t) +#define sizeof_TPM_RESOURCE_TYPE(t) sizeof_UINT32(t) +#define sizeof_TPM_COMMAND_CODE(t) sizeof_UINT32(t) +#define sizeof_TPM_PROTOCOL_ID(t) sizeof_UINT16(t) +#define sizeof_TPM_AUTH_DATA_USAGE(t) sizeof_BYTE(t) +#define sizeof_TPM_ENTITY_TYPE(t) sizeof_UINT16(t) +#define sizeof_TPM_ALGORITHM_ID(t) sizeof_UINT32(t) +#define sizeof_TPM_KEY_USAGE(t) sizeof_UINT16(t) +#define sizeof_TPM_STARTUP_TYPE(t) sizeof_UINT16(t) +#define sizeof_TPM_CAPABILITY_AREA(t) sizeof_UINT32(t) +#define sizeof_TPM_ENC_SCHEME(t) sizeof_UINT16(t) +#define sizeof_TPM_SIG_SCHEME(t) sizeof_UINT16(t) +#define sizeof_TPM_MIGRATE_SCHEME(t) sizeof_UINT16(t) +#define sizeof_TPM_PHYSICAL_PRESENCE(t) sizeof_UINT16(t) +#define sizeof_TPM_KEY_FLAGS(t) sizeof_UINT32(t) + +#define pack_TPM_AUTH_HANDLE(p, t) pack_UINT32(p, t) +#define pack_TCS_CONTEXT_HANDLE(p, t) pack_UINT32(p, t) +#define pack_TCS_KEY_HANDLE(p, t) pack_UINT32(p, t) + +#define unpack_TPM_AUTH_HANDLE(p, t) unpack_UINT32(p, t) +#define unpack_TCS_CONTEXT_HANDLE(p, t) unpack_UINT32(p, t) +#define unpack_TCS_KEY_HANDLE(p, t) unpack_UINT32(p, t) + +#define sizeof_TPM_AUTH_HANDLE(t) sizeof_UINT32(t) +#define sizeof_TCS_CONTEXT_HANDLE(t) sizeof_UINT32(t) +#define sizeof_TCS_KEY_HANDLE(t) sizeof_UINT32(t) -#define unpack_TPM_AUTH_HANDLE(p, t) unpack_UINT32(p, t); -#define unpack_TCS_CONTEXT_HANDLE(p, t) unpack_UINT32(p, t); -#define unpack_TCS_KEY_HANDLE(p, t) unpack_UINT32(p, t); inline BYTE* pack_BUFFER(BYTE* ptr, const BYTE* buf, UINT32 size) { - memcpy(ptr, buf, size); - return ptr + size; + memcpy(ptr, buf, size); + return ptr + size; } inline BYTE* unpack_BUFFER(BYTE* ptr, BYTE* buf, UINT32 size) { - memcpy(buf, ptr, size); - return ptr + size; + memcpy(buf, ptr, size); + return ptr + size; +} + +inline int unpack3_BUFFER(BYTE* ptr, UINT32* pos, UINT32 max, BYTE* buf, UINT32 size) { + if (*pos + size > max) + return TPM_SIZE; + memcpy(buf, ptr + *pos, size); + *pos += size; + return 0; } +#define sizeof_BUFFER(b, s) s + inline BYTE* unpack_ALIAS(BYTE* ptr, BYTE** buf, UINT32 size) { - *buf = ptr; - return ptr + size; + *buf = ptr; + return ptr + size; } inline BYTE* unpack_ALLOC(BYTE* ptr, BYTE** buf, UINT32 size) { - if(size) { - *buf = malloc(size); - memcpy(*buf, ptr, size); - } else { - *buf = NULL; - } - return ptr + size; + if(size) { + *buf = malloc(size); + memcpy(*buf, ptr, size); + } else { + *buf = NULL; + } + return ptr + size; } inline BYTE* unpack_PTR(BYTE* ptr, BYTE** buf, UINT32 size, UnpackPtr alloc) { - if(alloc == UNPACK_ALLOC) { - return unpack_ALLOC(ptr, buf, size); - } else { - return unpack_ALIAS(ptr, buf, size); - } -} + if(alloc == UNPACK_ALLOC) { + return unpack_ALLOC(ptr, buf, size); + } else { + return unpack_ALIAS(ptr, buf, size); + } +} + +inline int unpack3_PTR(BYTE* ptr, UINT32* pos, UINT32 max, BYTE** buf, UINT32 size, UnpackPtr alloc) { + if (size > max || *pos + size > max) + return TPM_SIZE; + if (alloc == UNPACK_ALLOC) { + unpack_ALLOC(ptr + *pos, buf, size); + } else { + unpack_ALIAS(ptr + *pos, buf, size); + } + *pos += size; + return 0; +} +#define unpack3_VPTR(ptr, pos, max, buf, size, alloc) unpack3_PTR(ptr, pos, max, (void*)(buf), size, alloc) inline BYTE* pack_TPM_AUTHDATA(BYTE* ptr, const TPM_AUTHDATA* d) { - return pack_BUFFER(ptr, *d, TPM_DIGEST_SIZE); + return pack_BUFFER(ptr, *d, TPM_DIGEST_SIZE); } inline BYTE* unpack_TPM_AUTHDATA(BYTE* ptr, TPM_AUTHDATA* d) { - return unpack_BUFFER(ptr, *d, TPM_DIGEST_SIZE); + return unpack_BUFFER(ptr, *d, TPM_DIGEST_SIZE); +} + +inline int unpack3_TPM_AUTHDATA(BYTE* ptr, UINT32* pos, UINT32 len, TPM_AUTHDATA* d) { + return unpack3_BUFFER(ptr, pos, len, *d, TPM_DIGEST_SIZE); } +#define sizeof_TPM_AUTHDATA(d) TPM_DIGEST_SIZE + #define pack_TPM_SECRET(p, t) pack_TPM_AUTHDATA(p, t) #define pack_TPM_ENCAUTH(p, t) pack_TPM_AUTHDATA(p, t) #define pack_TPM_PAYLOAD_TYPE(p, t) pack_BYTE(p, t) @@ -227,302 +313,456 @@ inline BYTE* unpack_TPM_AUTHDATA(BYTE* ptr, TPM_AUTHDATA* d) { #define unpack_TPM_TAG(p, t) unpack_UINT16(p, t) #define unpack_TPM_STRUCTURE_TAG(p, t) unpack_UINT16(p, t) +#define sizeof_TPM_SECRET(t) sizeof_TPM_AUTHDATA(t) +#define sizeof_TPM_ENCAUTH(t) sizeof_TPM_AUTHDATA(t) +#define sizeof_TPM_PAYLOAD_TYPE(t) sizeof_BYTE(t) +#define sizeof_TPM_TAG(t) sizeof_UINT16(t) +#define sizeof_TPM_STRUCTURE_TAG(t) sizeof_UINT16(t) + inline BYTE* pack_TPM_VERSION(BYTE* ptr, const TPM_VERSION* t) { - ptr[0] = t->major; - ptr[1] = t->minor; - ptr[2] = t->revMajor; - ptr[3] = t->revMinor; - return ptr + 4; + ptr[0] = t->major; + ptr[1] = t->minor; + ptr[2] = t->revMajor; + ptr[3] = t->revMinor; + return ptr + 4; } inline BYTE* unpack_TPM_VERSION(BYTE* ptr, TPM_VERSION* t) { - t->major = ptr[0]; - t->minor = ptr[1]; - t->revMajor = ptr[2]; - t->revMinor = ptr[3]; - return ptr + 4; + t->major = ptr[0]; + t->minor = ptr[1]; + t->revMajor = ptr[2]; + t->revMinor = ptr[3]; + return ptr + 4; +} + +inline int unpack3_TPM_VERSION(BYTE* ptr, UINT32 *pos, UINT32 max, TPM_VERSION* t) { + if (*pos + 4 > max) + return TPM_SIZE; + ptr += *pos; + t->major = ptr[0]; + t->minor = ptr[1]; + t->revMajor = ptr[2]; + t->revMinor = ptr[3]; + *pos += 4; + return 0; } +#define sizeof_TPM_VERSION(x) 4 + inline BYTE* pack_TPM_CAP_VERSION_INFO(BYTE* ptr, const TPM_CAP_VERSION_INFO* v) { - ptr = pack_TPM_STRUCTURE_TAG(ptr, v->tag); - ptr = pack_TPM_VERSION(ptr, &v->version); - ptr = pack_UINT16(ptr, v->specLevel); - ptr = pack_BYTE(ptr, v->errataRev); - ptr = pack_BUFFER(ptr, v->tpmVendorID, sizeof(v->tpmVendorID)); - ptr = pack_UINT16(ptr, v->vendorSpecificSize); - ptr = pack_BUFFER(ptr, v->vendorSpecific, v->vendorSpecificSize); - return ptr; + ptr = pack_TPM_STRUCTURE_TAG(ptr, v->tag); + ptr = pack_TPM_VERSION(ptr, &v->version); + ptr = pack_UINT16(ptr, v->specLevel); + ptr = pack_BYTE(ptr, v->errataRev); + ptr = pack_BUFFER(ptr, v->tpmVendorID, sizeof(v->tpmVendorID)); + ptr = pack_UINT16(ptr, v->vendorSpecificSize); + ptr = pack_BUFFER(ptr, v->vendorSpecific, v->vendorSpecificSize); + return ptr; } inline BYTE* unpack_TPM_CAP_VERSION_INFO(BYTE* ptr, TPM_CAP_VERSION_INFO* v, UnpackPtr alloc) { - ptr = unpack_TPM_STRUCTURE_TAG(ptr, &v->tag); - ptr = unpack_TPM_VERSION(ptr, &v->version); - ptr = unpack_UINT16(ptr, &v->specLevel); - ptr = unpack_BYTE(ptr, &v->errataRev); - ptr = unpack_BUFFER(ptr, v->tpmVendorID, sizeof(v->tpmVendorID)); - ptr = unpack_UINT16(ptr, &v->vendorSpecificSize); - ptr = unpack_PTR(ptr, &v->vendorSpecific, v->vendorSpecificSize, alloc); - return ptr; + ptr = unpack_TPM_STRUCTURE_TAG(ptr, &v->tag); + ptr = unpack_TPM_VERSION(ptr, &v->version); + ptr = unpack_UINT16(ptr, &v->specLevel); + ptr = unpack_BYTE(ptr, &v->errataRev); + ptr = unpack_BUFFER(ptr, v->tpmVendorID, sizeof(v->tpmVendorID)); + ptr = unpack_UINT16(ptr, &v->vendorSpecificSize); + ptr = unpack_PTR(ptr, &v->vendorSpecific, v->vendorSpecificSize, alloc); + return ptr; } inline BYTE* pack_TPM_DIGEST(BYTE* ptr, const TPM_DIGEST* d) { - return pack_BUFFER(ptr, d->digest, TPM_DIGEST_SIZE); + return pack_BUFFER(ptr, d->digest, TPM_DIGEST_SIZE); } inline BYTE* unpack_TPM_DIGEST(BYTE* ptr, TPM_DIGEST* d) { - return unpack_BUFFER(ptr, d->digest, TPM_DIGEST_SIZE); + return unpack_BUFFER(ptr, d->digest, TPM_DIGEST_SIZE); +} + +inline int unpack3_TPM_DIGEST(BYTE* ptr, UINT32* pos, UINT32 max, TPM_DIGEST* d) { + return unpack3_BUFFER(ptr, pos, max, d->digest, TPM_DIGEST_SIZE); } -#define pack_TPM_PCRVALUE(ptr, d) pack_TPM_DIGEST(ptr, d); -#define unpack_TPM_PCRVALUE(ptr, d) unpack_TPM_DIGEST(ptr, d); +#define sizeof_TPM_DIGEST(d) TPM_DIGEST_SIZE -#define pack_TPM_COMPOSITE_HASH(ptr, d) pack_TPM_DIGEST(ptr, d); -#define unpack_TPM_COMPOSITE_HASH(ptr, d) unpack_TPM_DIGEST(ptr, d); +#define pack_TPM_PCRVALUE(ptr, d) pack_TPM_DIGEST(ptr, d) +#define unpack_TPM_PCRVALUE(ptr, d) unpack_TPM_DIGEST(ptr, d) +#define unpack3_TPM_PCRVALUE(p...) unpack3_TPM_DIGEST(p) -#define pack_TPM_DIRVALUE(ptr, d) pack_TPM_DIGEST(ptr, d); -#define unpack_TPM_DIRVALUE(ptr, d) unpack_TPM_DIGEST(ptr, d); +#define pack_TPM_COMPOSITE_HASH(ptr, d) pack_TPM_DIGEST(ptr, d) +#define unpack_TPM_COMPOSITE_HASH(ptr, d) unpack_TPM_DIGEST(ptr, d) +#define unpack3_TPM_COMPOSITE_HASH(ptr, p, m, d) unpack3_TPM_DIGEST(ptr, p, m, d) +#define sizeof_TPM_COMPOSITE_HASH(d) TPM_DIGEST_SIZE -#define pack_TPM_HMAC(ptr, d) pack_TPM_DIGEST(ptr, d); -#define unpack_TPM_HMAC(ptr, d) unpack_TPM_DIGEST(ptr, d); +#define pack_TPM_DIRVALUE(ptr, d) pack_TPM_DIGEST(ptr, d) +#define unpack_TPM_DIRVALUE(ptr, d) unpack_TPM_DIGEST(ptr, d) -#define pack_TPM_CHOSENID_HASH(ptr, d) pack_TPM_DIGEST(ptr, d); -#define unpack_TPM_CHOSENID_HASH(ptr, d) unpack_TPM_DIGEST(ptr, d); +#define pack_TPM_HMAC(ptr, d) pack_TPM_DIGEST(ptr, d) +#define unpack_TPM_HMAC(ptr, d) unpack_TPM_DIGEST(ptr, d) + +#define pack_TPM_CHOSENID_HASH(ptr, d) pack_TPM_DIGEST(ptr, d) +#define unpack_TPM_CHOSENID_HASH(ptr, d) unpack_TPM_DIGEST(ptr, d) inline BYTE* pack_TPM_NONCE(BYTE* ptr, const TPM_NONCE* n) { - return pack_BUFFER(ptr, n->nonce, TPM_DIGEST_SIZE); + return pack_BUFFER(ptr, n->nonce, TPM_DIGEST_SIZE); } inline BYTE* unpack_TPM_NONCE(BYTE* ptr, TPM_NONCE* n) { - return unpack_BUFFER(ptr, n->nonce, TPM_DIGEST_SIZE); + return unpack_BUFFER(ptr, n->nonce, TPM_DIGEST_SIZE); +} + +#define sizeof_TPM_NONCE(x) TPM_DIGEST_SIZE + +inline int unpack3_TPM_NONCE(BYTE* ptr, UINT32* pos, UINT32 max, TPM_NONCE* n) { + return unpack3_BUFFER(ptr, pos, max, n->nonce, TPM_DIGEST_SIZE); } inline BYTE* pack_TPM_SYMMETRIC_KEY_PARMS(BYTE* ptr, const TPM_SYMMETRIC_KEY_PARMS* k) { - ptr = pack_UINT32(ptr, k->keyLength); - ptr = pack_UINT32(ptr, k->blockSize); - ptr = pack_UINT32(ptr, k->ivSize); - return pack_BUFFER(ptr, k->IV, k->ivSize); + ptr = pack_UINT32(ptr, k->keyLength); + ptr = pack_UINT32(ptr, k->blockSize); + ptr = pack_UINT32(ptr, k->ivSize); + return pack_BUFFER(ptr, k->IV, k->ivSize); +} + +inline BYTE* pack_TPM_SYMMETRIC_KEY(BYTE* ptr, const TPM_SYMMETRIC_KEY* k) { + ptr = pack_UINT32(ptr, k->algId); + ptr = pack_UINT16(ptr, k->encScheme); + ptr = pack_UINT16(ptr, k->size); + return pack_BUFFER(ptr, k->data, k->size); +} + +inline int unpack3_TPM_SYMMETRIC_KEY_PARMS(BYTE* ptr, UINT32* pos, UINT32 max, TPM_SYMMETRIC_KEY_PARMS* k, UnpackPtr alloc) { + return unpack3_UINT32(ptr, pos, max, &k->keyLength) || + unpack3_UINT32(ptr, pos, max, &k->blockSize) || + unpack3_UINT32(ptr, pos, max, &k->ivSize) || + unpack3_PTR(ptr, pos, max, &k->IV, k->ivSize, alloc); } -inline BYTE* unpack_TPM_SYMMETRIC_KEY_PARMS(BYTE* ptr, TPM_SYMMETRIC_KEY_PARMS* k, UnpackPtr alloc) { - ptr = unpack_UINT32(ptr, &k->keyLength); - ptr = unpack_UINT32(ptr, &k->blockSize); - ptr = unpack_UINT32(ptr, &k->ivSize); - return unpack_PTR(ptr, &k->IV, k->ivSize, alloc); +inline int sizeof_TPM_SYMMETRIC_KEY_PARMS(const TPM_SYMMETRIC_KEY_PARMS* k) { + return 12 + k->ivSize; +} + +inline int unpack3_TPM_SYMMETRIC_KEY(BYTE* ptr, UINT32* pos, UINT32 max, TPM_SYMMETRIC_KEY* k, UnpackPtr alloc) { + return unpack3_UINT32(ptr, pos, max, &k->algId) || + unpack3_UINT16(ptr, pos, max, &k->encScheme) || + unpack3_UINT16(ptr, pos, max, &k->size) || + unpack3_PTR(ptr, pos, max, &k->data, k->size, alloc); } inline BYTE* pack_TPM_RSA_KEY_PARMS(BYTE* ptr, const TPM_RSA_KEY_PARMS* k) { - ptr = pack_UINT32(ptr, k->keyLength); - ptr = pack_UINT32(ptr, k->numPrimes); - ptr = pack_UINT32(ptr, k->exponentSize); - return pack_BUFFER(ptr, k->exponent, k->exponentSize); + ptr = pack_UINT32(ptr, k->keyLength); + ptr = pack_UINT32(ptr, k->numPrimes); + ptr = pack_UINT32(ptr, k->exponentSize); + return pack_BUFFER(ptr, k->exponent, k->exponentSize); +} + +inline int unpack3_TPM_RSA_KEY_PARMS(BYTE* ptr, UINT32* pos, UINT32 max, TPM_RSA_KEY_PARMS* k, UnpackPtr alloc) { + return unpack3_UINT32(ptr, pos, max, &k->keyLength) || + unpack3_UINT32(ptr, pos, max, &k->numPrimes) || + unpack3_UINT32(ptr, pos, max, &k->exponentSize) || + unpack3_PTR(ptr, pos, max, &k->exponent, k->exponentSize, alloc); } -inline BYTE* unpack_TPM_RSA_KEY_PARMS(BYTE* ptr, TPM_RSA_KEY_PARMS* k, UnpackPtr alloc) { - ptr = unpack_UINT32(ptr, &k->keyLength); - ptr = unpack_UINT32(ptr, &k->numPrimes); - ptr = unpack_UINT32(ptr, &k->exponentSize); - return unpack_PTR(ptr, &k->exponent, k->exponentSize, alloc); +inline int sizeof_TPM_RSA_KEY_PARMS(const TPM_RSA_KEY_PARMS* k) { + return 12 + k->exponentSize; } + inline BYTE* pack_TPM_KEY_PARMS(BYTE* ptr, const TPM_KEY_PARMS* k) { - ptr = pack_TPM_ALGORITHM_ID(ptr, k->algorithmID); - ptr = pack_TPM_ENC_SCHEME(ptr, k->encScheme); - ptr = pack_TPM_SIG_SCHEME(ptr, k->sigScheme); - ptr = pack_UINT32(ptr, k->parmSize); - - if(k->parmSize) { - switch(k->algorithmID) { - case TPM_ALG_RSA: - return pack_TPM_RSA_KEY_PARMS(ptr, &k->parms.rsa); - case TPM_ALG_AES128: - case TPM_ALG_AES192: - case TPM_ALG_AES256: - return pack_TPM_SYMMETRIC_KEY_PARMS(ptr, &k->parms.sym); - } - } - return ptr; -} - -inline BYTE* unpack_TPM_KEY_PARMS(BYTE* ptr, TPM_KEY_PARMS* k, UnpackPtr alloc) { - ptr = unpack_TPM_ALGORITHM_ID(ptr, &k->algorithmID); - ptr = unpack_TPM_ENC_SCHEME(ptr, &k->encScheme); - ptr = unpack_TPM_SIG_SCHEME(ptr, &k->sigScheme); - ptr = unpack_UINT32(ptr, &k->parmSize); - - if(k->parmSize) { - switch(k->algorithmID) { - case TPM_ALG_RSA: - return unpack_TPM_RSA_KEY_PARMS(ptr, &k->parms.rsa, alloc); - case TPM_ALG_AES128: - case TPM_ALG_AES192: - case TPM_ALG_AES256: - return unpack_TPM_SYMMETRIC_KEY_PARMS(ptr, &k->parms.sym, alloc); - } - } - return ptr; + ptr = pack_TPM_ALGORITHM_ID(ptr, k->algorithmID); + ptr = pack_TPM_ENC_SCHEME(ptr, k->encScheme); + ptr = pack_TPM_SIG_SCHEME(ptr, k->sigScheme); + ptr = pack_UINT32(ptr, k->parmSize); + + if(k->parmSize) { + switch(k->algorithmID) { + case TPM_ALG_RSA: + return pack_TPM_RSA_KEY_PARMS(ptr, &k->parms.rsa); + case TPM_ALG_AES128: + case TPM_ALG_AES192: + case TPM_ALG_AES256: + return pack_TPM_SYMMETRIC_KEY_PARMS(ptr, &k->parms.sym); + } + } + return ptr; +} + +inline int unpack3_TPM_KEY_PARMS(BYTE* ptr, UINT32* pos, UINT32 len, TPM_KEY_PARMS* k, UnpackPtr alloc) { + int rc = unpack3_TPM_ALGORITHM_ID(ptr, pos, len, &k->algorithmID) || + unpack3_TPM_ENC_SCHEME(ptr, pos, len, &k->encScheme) || + unpack3_TPM_SIG_SCHEME(ptr, pos, len, &k->sigScheme) || + unpack3_UINT32(ptr, pos, len, &k->parmSize); + if (rc || k->parmSize == 0) + return rc; + switch(k->algorithmID) { + case TPM_ALG_RSA: + return unpack3_TPM_RSA_KEY_PARMS(ptr, pos, len, &k->parms.rsa, alloc); + case TPM_ALG_AES128: + case TPM_ALG_AES192: + case TPM_ALG_AES256: + return unpack3_TPM_SYMMETRIC_KEY_PARMS(ptr, pos, len, &k->parms.sym, alloc); + } + return TPM_FAIL; +} + +inline int sizeof_TPM_KEY_PARMS(const TPM_KEY_PARMS* k) { + int rc = 0; + rc += sizeof_TPM_ALGORITHM_ID(&k->algorithmID); + rc += sizeof_TPM_ENC_SCHEME(&k->encScheme); + rc += sizeof_TPM_SIG_SCHEME(&k->sigScheme); + rc += sizeof_UINT32(&k->parmSize); + if (!k->parmSize) + return rc; + switch(k->algorithmID) { + case TPM_ALG_RSA: + rc += sizeof_TPM_RSA_KEY_PARMS(&k->parms.rsa); + break; + case TPM_ALG_AES128: + case TPM_ALG_AES192: + case TPM_ALG_AES256: + rc += sizeof_TPM_SYMMETRIC_KEY_PARMS(&k->parms.sym); + break; + } + return rc; } inline BYTE* pack_TPM_STORE_PUBKEY(BYTE* ptr, const TPM_STORE_PUBKEY* k) { - ptr = pack_UINT32(ptr, k->keyLength); - ptr = pack_BUFFER(ptr, k->key, k->keyLength); - return ptr; + ptr = pack_UINT32(ptr, k->keyLength); + ptr = pack_BUFFER(ptr, k->key, k->keyLength); + return ptr; +} + +inline int unpack3_TPM_STORE_PUBKEY(BYTE* ptr, UINT32* pos, UINT32 max, TPM_STORE_PUBKEY* k, UnpackPtr alloc) { + return unpack3_UINT32(ptr, pos, max, &k->keyLength) || + unpack3_PTR(ptr, pos, max, &k->key, k->keyLength, alloc); } -inline BYTE* unpack_TPM_STORE_PUBKEY(BYTE* ptr, TPM_STORE_PUBKEY* k, UnpackPtr alloc) { - ptr = unpack_UINT32(ptr, &k->keyLength); - ptr = unpack_PTR(ptr, &k->key, k->keyLength, alloc); - return ptr; +inline int sizeof_TPM_STORE_PUBKEY(const TPM_STORE_PUBKEY* k) { + return 4 + k->keyLength; } inline BYTE* pack_TPM_PUBKEY(BYTE* ptr, const TPM_PUBKEY* k) { - ptr = pack_TPM_KEY_PARMS(ptr, &k->algorithmParms); - return pack_TPM_STORE_PUBKEY(ptr, &k->pubKey); + ptr = pack_TPM_KEY_PARMS(ptr, &k->algorithmParms); + return pack_TPM_STORE_PUBKEY(ptr, &k->pubKey); } -inline BYTE* unpack_TPM_PUBKEY(BYTE* ptr, TPM_PUBKEY* k, UnpackPtr alloc) { - ptr = unpack_TPM_KEY_PARMS(ptr, &k->algorithmParms, alloc); - return unpack_TPM_STORE_PUBKEY(ptr, &k->pubKey, alloc); +inline int unpack3_TPM_PUBKEY(BYTE* ptr, UINT32* pos, UINT32 len, TPM_PUBKEY* k, UnpackPtr alloc) { + return unpack3_TPM_KEY_PARMS(ptr, pos, len, &k->algorithmParms, alloc) || + unpack3_TPM_STORE_PUBKEY(ptr, pos, len, &k->pubKey, alloc); } inline BYTE* pack_TPM_PCR_SELECTION(BYTE* ptr, const TPM_PCR_SELECTION* p) { - ptr = pack_UINT16(ptr, p->sizeOfSelect); - ptr = pack_BUFFER(ptr, p->pcrSelect, p->sizeOfSelect); - return ptr; + ptr = pack_UINT16(ptr, p->sizeOfSelect); + ptr = pack_BUFFER(ptr, p->pcrSelect, p->sizeOfSelect); + return ptr; } inline BYTE* unpack_TPM_PCR_SELECTION(BYTE* ptr, TPM_PCR_SELECTION* p, UnpackPtr alloc) { - ptr = unpack_UINT16(ptr, &p->sizeOfSelect); - ptr = unpack_PTR(ptr, &p->pcrSelect, p->sizeOfSelect, alloc); - return ptr; + ptr = unpack_UINT16(ptr, &p->sizeOfSelect); + ptr = unpack_PTR(ptr, &p->pcrSelect, p->sizeOfSelect, alloc); + return ptr; +} + +inline int unpack3_TPM_PCR_SELECTION(BYTE* ptr, UINT32* pos, UINT32 max, TPM_PCR_SELECTION* p, UnpackPtr alloc) { + return unpack3_UINT16(ptr, pos, max, &p->sizeOfSelect) || + unpack3_PTR(ptr, pos, max, &p->pcrSelect, p->sizeOfSelect, alloc); +} + +inline int sizeof_TPM_PCR_SELECTION(const TPM_PCR_SELECTION* p) { + return 2 + p->sizeOfSelect; } inline BYTE* pack_TPM_PCR_INFO(BYTE* ptr, const TPM_PCR_INFO* p) { - ptr = pack_TPM_PCR_SELECTION(ptr, &p->pcrSelection); - ptr = pack_TPM_COMPOSITE_HASH(ptr, &p->digestAtRelease); - ptr = pack_TPM_COMPOSITE_HASH(ptr, &p->digestAtCreation); - return ptr; + ptr = pack_TPM_PCR_SELECTION(ptr, &p->pcrSelection); + ptr = pack_TPM_COMPOSITE_HASH(ptr, &p->digestAtRelease); + ptr = pack_TPM_COMPOSITE_HASH(ptr, &p->digestAtCreation); + return ptr; } -inline BYTE* unpack_TPM_PCR_INFO(BYTE* ptr, TPM_PCR_INFO* p, UnpackPtr alloc) { - ptr = unpack_TPM_PCR_SELECTION(ptr, &p->pcrSelection, alloc); - ptr = unpack_TPM_COMPOSITE_HASH(ptr, &p->digestAtRelease); - ptr = unpack_TPM_COMPOSITE_HASH(ptr, &p->digestAtCreation); - return ptr; +inline int unpack3_TPM_PCR_INFO(BYTE* ptr, UINT32* pos, UINT32 max, TPM_PCR_INFO* p, UnpackPtr alloc) { + return unpack3_TPM_PCR_SELECTION(ptr, pos, max, &p->pcrSelection, alloc) || + unpack3_TPM_COMPOSITE_HASH(ptr, pos, max, &p->digestAtRelease) || + unpack3_TPM_COMPOSITE_HASH(ptr, pos, max, &p->digestAtCreation); } +inline int sizeof_TPM_PCR_INFO(const TPM_PCR_INFO* p) { + int rc = 0; + rc += sizeof_TPM_PCR_SELECTION(&p->pcrSelection); + rc += sizeof_TPM_COMPOSITE_HASH(&p->digestAtRelease); + rc += sizeof_TPM_COMPOSITE_HASH(&p->digestAtCreation); + return rc; +} + + inline BYTE* pack_TPM_PCR_COMPOSITE(BYTE* ptr, const TPM_PCR_COMPOSITE* p) { - ptr = pack_TPM_PCR_SELECTION(ptr, &p->select); - ptr = pack_UINT32(ptr, p->valueSize); - ptr = pack_BUFFER(ptr, (const BYTE*)p->pcrValue, p->valueSize); - return ptr; + ptr = pack_TPM_PCR_SELECTION(ptr, &p->select); + ptr = pack_UINT32(ptr, p->valueSize); + ptr = pack_BUFFER(ptr, (const BYTE*)p->pcrValue, p->valueSize); + return ptr; } -inline BYTE* unpack_TPM_PCR_COMPOSITE(BYTE* ptr, TPM_PCR_COMPOSITE* p, UnpackPtr alloc) { - ptr = unpack_TPM_PCR_SELECTION(ptr, &p->select, alloc); - ptr = unpack_UINT32(ptr, &p->valueSize); - ptr = unpack_PTR(ptr, (BYTE**)&p->pcrValue, p->valueSize, alloc); - return ptr; +inline int unpack3_TPM_PCR_COMPOSITE(BYTE* ptr, UINT32* pos, UINT32 max, TPM_PCR_COMPOSITE* p, UnpackPtr alloc) { + return unpack3_TPM_PCR_SELECTION(ptr, pos, max, &p->select, alloc) || + unpack3_UINT32(ptr, pos, max, &p->valueSize) || + unpack3_PTR(ptr, pos, max, (BYTE**)&p->pcrValue, p->valueSize, alloc); } inline BYTE* pack_TPM_KEY(BYTE* ptr, const TPM_KEY* k) { - ptr = pack_TPM_VERSION(ptr, &k->ver); - ptr = pack_TPM_KEY_USAGE(ptr, k->keyUsage); - ptr = pack_TPM_KEY_FLAGS(ptr, k->keyFlags); - ptr = pack_TPM_AUTH_DATA_USAGE(ptr, k->authDataUsage); - ptr = pack_TPM_KEY_PARMS(ptr, &k->algorithmParms); - ptr = pack_UINT32(ptr, k->PCRInfoSize); - if(k->PCRInfoSize) { - ptr = pack_TPM_PCR_INFO(ptr, &k->PCRInfo); - } - ptr = pack_TPM_STORE_PUBKEY(ptr, &k->pubKey); - ptr = pack_UINT32(ptr, k->encDataSize); - return pack_BUFFER(ptr, k->encData, k->encDataSize); -} - -inline BYTE* unpack_TPM_KEY(BYTE* ptr, TPM_KEY* k, UnpackPtr alloc) { - ptr = unpack_TPM_VERSION(ptr, &k->ver); - ptr = unpack_TPM_KEY_USAGE(ptr, &k->keyUsage); - ptr = unpack_TPM_KEY_FLAGS(ptr, &k->keyFlags); - ptr = unpack_TPM_AUTH_DATA_USAGE(ptr, &k->authDataUsage); - ptr = unpack_TPM_KEY_PARMS(ptr, &k->algorithmParms, alloc); - ptr = unpack_UINT32(ptr, &k->PCRInfoSize); - if(k->PCRInfoSize) { - ptr = unpack_TPM_PCR_INFO(ptr, &k->PCRInfo, alloc); - } - ptr = unpack_TPM_STORE_PUBKEY(ptr, &k->pubKey, alloc); - ptr = unpack_UINT32(ptr, &k->encDataSize); - return unpack_PTR(ptr, &k->encData, k->encDataSize, alloc); + ptr = pack_TPM_VERSION(ptr, &k->ver); + ptr = pack_TPM_KEY_USAGE(ptr, k->keyUsage); + ptr = pack_TPM_KEY_FLAGS(ptr, k->keyFlags); + ptr = pack_TPM_AUTH_DATA_USAGE(ptr, k->authDataUsage); + ptr = pack_TPM_KEY_PARMS(ptr, &k->algorithmParms); + ptr = pack_UINT32(ptr, k->PCRInfoSize); + if(k->PCRInfoSize) { + ptr = pack_TPM_PCR_INFO(ptr, &k->PCRInfo); + } + ptr = pack_TPM_STORE_PUBKEY(ptr, &k->pubKey); + ptr = pack_UINT32(ptr, k->encDataSize); + return pack_BUFFER(ptr, k->encData, k->encDataSize); +} + +inline int unpack3_TPM_KEY(BYTE* ptr, UINT32* pos, UINT32 max, TPM_KEY* k, UnpackPtr alloc) { + int rc = unpack3_TPM_VERSION(ptr, pos, max, &k->ver) || + unpack3_TPM_KEY_USAGE(ptr, pos, max, &k->keyUsage) || + unpack3_TPM_KEY_FLAGS(ptr, pos, max, &k->keyFlags) || + unpack3_TPM_AUTH_DATA_USAGE(ptr, pos, max, &k->authDataUsage) || + unpack3_TPM_KEY_PARMS(ptr, pos, max, &k->algorithmParms, alloc) || + unpack3_UINT32(ptr, pos, max, &k->PCRInfoSize); + if (rc) return rc; + if(k->PCRInfoSize) { + rc = unpack3_TPM_PCR_INFO(ptr, pos, max, &k->PCRInfo, alloc); + } + if (rc) return rc; + return unpack3_TPM_STORE_PUBKEY(ptr, pos, max, &k->pubKey, alloc) || + unpack3_UINT32(ptr, pos, max, &k->encDataSize) || + unpack3_PTR(ptr, pos, max, &k->encData, k->encDataSize, alloc); +} + +inline int sizeof_TPM_KEY(const TPM_KEY* k) { + int rc = 0; + rc += sizeof_TPM_VERSION(&k->ver); + rc += sizeof_TPM_KEY_USAGE(k->keyUsage); + rc += sizeof_TPM_KEY_FLAGS(k->keyFlags); + rc += sizeof_TPM_AUTH_DATA_USAGE(k->authDataUsage); + rc += sizeof_TPM_KEY_PARMS(&k->algorithmParms); + rc += sizeof_UINT32(k->PCRInfoSize); + if(k->PCRInfoSize) { + rc += sizeof_TPM_PCR_INFO(&k->PCRInfo); + } + rc += sizeof_TPM_STORE_PUBKEY(&k->pubKey); + rc += sizeof_UINT32(k->encDataSize); + rc += k->encDataSize; + return rc; } inline BYTE* pack_TPM_BOUND_DATA(BYTE* ptr, const TPM_BOUND_DATA* b, UINT32 payloadSize) { - ptr = pack_TPM_VERSION(ptr, &b->ver); - ptr = pack_TPM_PAYLOAD_TYPE(ptr, b->payload); - return pack_BUFFER(ptr, b->payloadData, payloadSize); + ptr = pack_TPM_VERSION(ptr, &b->ver); + ptr = pack_TPM_PAYLOAD_TYPE(ptr, b->payload); + return pack_BUFFER(ptr, b->payloadData, payloadSize); } inline BYTE* unpack_TPM_BOUND_DATA(BYTE* ptr, TPM_BOUND_DATA* b, UINT32 payloadSize, UnpackPtr alloc) { - ptr = unpack_TPM_VERSION(ptr, &b->ver); - ptr = unpack_TPM_PAYLOAD_TYPE(ptr, &b->payload); - return unpack_PTR(ptr, &b->payloadData, payloadSize, alloc); + ptr = unpack_TPM_VERSION(ptr, &b->ver); + ptr = unpack_TPM_PAYLOAD_TYPE(ptr, &b->payload); + return unpack_PTR(ptr, &b->payloadData, payloadSize, alloc); } inline BYTE* pack_TPM_STORED_DATA(BYTE* ptr, const TPM_STORED_DATA* d) { - ptr = pack_TPM_VERSION(ptr, &d->ver); - ptr = pack_UINT32(ptr, d->sealInfoSize); - if(d->sealInfoSize) { - ptr = pack_TPM_PCR_INFO(ptr, &d->sealInfo); - } - ptr = pack_UINT32(ptr, d->encDataSize); - ptr = pack_BUFFER(ptr, d->encData, d->encDataSize); - return ptr; -} - -inline BYTE* unpack_TPM_STORED_DATA(BYTE* ptr, TPM_STORED_DATA* d, UnpackPtr alloc) { - ptr = unpack_TPM_VERSION(ptr, &d->ver); - ptr = unpack_UINT32(ptr, &d->sealInfoSize); - if(d->sealInfoSize) { - ptr = unpack_TPM_PCR_INFO(ptr, &d->sealInfo, alloc); - } - ptr = unpack_UINT32(ptr, &d->encDataSize); - ptr = unpack_PTR(ptr, &d->encData, d->encDataSize, alloc); - return ptr; + ptr = pack_TPM_VERSION(ptr, &d->ver); + ptr = pack_UINT32(ptr, d->sealInfoSize); + if(d->sealInfoSize) { + ptr = pack_TPM_PCR_INFO(ptr, &d->sealInfo); + } + ptr = pack_UINT32(ptr, d->encDataSize); + ptr = pack_BUFFER(ptr, d->encData, d->encDataSize); + return ptr; +} + +inline int sizeof_TPM_STORED_DATA(const TPM_STORED_DATA* d) { + int rv = sizeof_TPM_VERSION(&d->ver) + sizeof_UINT32(d->sealInfoSize); + if (d->sealInfoSize) { + rv += sizeof_TPM_PCR_INFO(&d->sealInfo); + } + rv += sizeof_UINT32(d->encDataSize); + rv += sizeof_BUFFER(d->encData, d->encDataSize); + return rv; +} + +inline int unpack3_TPM_STORED_DATA(BYTE* ptr, UINT32* pos, UINT32 len, TPM_STORED_DATA* d, UnpackPtr alloc) { + int rc = unpack3_TPM_VERSION(ptr, pos, len, &d->ver) || + unpack3_UINT32(ptr, pos, len, &d->sealInfoSize); + if (rc) + return rc; + if (d->sealInfoSize) + rc = unpack3_TPM_PCR_INFO(ptr, pos, len, &d->sealInfo, alloc); + if (rc) + return rc; + rc = unpack3_UINT32(ptr, pos, len, &d->encDataSize) || + unpack3_PTR(ptr, pos, len, &d->encData, d->encDataSize, alloc); + return rc; } inline BYTE* pack_TPM_AUTH_SESSION(BYTE* ptr, const TPM_AUTH_SESSION* auth) { - ptr = pack_TPM_AUTH_HANDLE(ptr, auth->AuthHandle); - ptr = pack_TPM_NONCE(ptr, &auth->NonceOdd); - ptr = pack_BOOL(ptr, auth->fContinueAuthSession); - ptr = pack_TPM_AUTHDATA(ptr, &auth->HMAC); - return ptr; + ptr = pack_TPM_AUTH_HANDLE(ptr, auth->AuthHandle); + ptr = pack_TPM_NONCE(ptr, &auth->NonceOdd); + ptr = pack_BOOL(ptr, auth->fContinueAuthSession); + ptr = pack_TPM_AUTHDATA(ptr, &auth->HMAC); + return ptr; } inline BYTE* unpack_TPM_AUTH_SESSION(BYTE* ptr, TPM_AUTH_SESSION* auth) { - ptr = unpack_TPM_NONCE(ptr, &auth->NonceEven); - ptr = unpack_BOOL(ptr, &auth->fContinueAuthSession); - ptr = unpack_TPM_AUTHDATA(ptr, &auth->HMAC); - return ptr; + ptr = unpack_TPM_NONCE(ptr, &auth->NonceEven); + ptr = unpack_BOOL(ptr, &auth->fContinueAuthSession); + ptr = unpack_TPM_AUTHDATA(ptr, &auth->HMAC); + return ptr; } -inline BYTE* pack_TPM_RQU_HEADER(BYTE* ptr, - TPM_TAG tag, - UINT32 size, - TPM_COMMAND_CODE ord) { - ptr = pack_UINT16(ptr, tag); - ptr = pack_UINT32(ptr, size); - return pack_UINT32(ptr, ord); +inline int unpack3_TPM_AUTH_SESSION(BYTE* ptr, UINT32* pos, UINT32 len, TPM_AUTH_SESSION* auth) { + return unpack3_TPM_NONCE(ptr, pos, len, &auth->NonceEven) || + unpack3_BOOL(ptr, pos, len, &auth->fContinueAuthSession) || + unpack3_TPM_AUTHDATA(ptr, pos, len, &auth->HMAC); } -inline BYTE* unpack_TPM_RQU_HEADER(BYTE* ptr, - TPM_TAG* tag, - UINT32* size, - TPM_COMMAND_CODE* ord) { - ptr = unpack_UINT16(ptr, tag); - ptr = unpack_UINT32(ptr, size); - ptr = unpack_UINT32(ptr, ord); - return ptr; + +inline int sizeof_TPM_AUTH_SESSION(const TPM_AUTH_SESSION* auth) { + int rv = 0; + rv += sizeof_TPM_AUTH_HANDLE(auth->AuthHandle); + rv += sizeof_TPM_NONCE(&auth->NonceOdd); + rv += sizeof_BOOL(auth->fContinueAuthSession); + rv += sizeof_TPM_AUTHDATA(&auth->HMAC); + return rv; } -#define pack_TPM_RSP_HEADER(p, t, s, r) pack_TPM_RQU_HEADER(p, t, s, r); -#define unpack_TPM_RSP_HEADER(p, t, s, r) unpack_TPM_RQU_HEADER(p, t, s, r); +inline BYTE* pack_TPM_RQU_HEADER(BYTE* ptr, + TPM_TAG tag, + UINT32 size, + TPM_COMMAND_CODE ord) { + ptr = pack_UINT16(ptr, tag); + ptr = pack_UINT32(ptr, size); + return pack_UINT32(ptr, ord); +} + +inline BYTE* unpack_TPM_RQU_HEADER(BYTE* ptr, + TPM_TAG* tag, + UINT32* size, + TPM_COMMAND_CODE* ord) { + ptr = unpack_UINT16(ptr, tag); + ptr = unpack_UINT32(ptr, size); + ptr = unpack_UINT32(ptr, ord); + return ptr; +} + +inline int unpack3_TPM_RQU_HEADER(BYTE* ptr, UINT32* pos, UINT32 max, + TPM_TAG* tag, UINT32* size, TPM_COMMAND_CODE* ord) { + return + unpack3_UINT16(ptr, pos, max, tag) || + unpack3_UINT32(ptr, pos, max, size) || + unpack3_UINT32(ptr, pos, max, ord); +} + +#define pack_TPM_RSP_HEADER(p, t, s, r) pack_TPM_RQU_HEADER(p, t, s, r) +#define unpack_TPM_RSP_HEADER(p, t, s, r) unpack_TPM_RQU_HEADER(p, t, s, r) +#define unpack3_TPM_RSP_HEADER(p, l, m, t, s, r) unpack3_TPM_RQU_HEADER(p, l, m, t, s, r) #endif diff --git a/stubdom/vtpmmgr/mgmt_authority.c b/stubdom/vtpmmgr/mgmt_authority.c new file mode 100644 index 0000000..0526a12 --- /dev/null +++ b/stubdom/vtpmmgr/mgmt_authority.c @@ -0,0 +1,323 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "vtpm_manager.h" +#include "log.h" +#include "uuid.h" + +#include "tpm.h" +#include "tcg.h" +#include "marshal.h" +#include "vtpmmgr.h" +#include "vtpm_disk.h" +#include "disk_tpm.h" +#include "disk_io.h" +#include "disk_crypto.h" +#include "disk_format.h" +#include "mgmt_authority.h" + +static int do_provision_aik(struct mem_group *group, + const struct tpm_authdata *privCADigest) +{ + TPM_KEY kinfo = { + .ver = TPM_STRUCT_VER_1_1, + .keyUsage = TPM_KEY_IDENTITY, + .keyFlags = 0, + .authDataUsage = TPM_AUTH_ALWAYS, + .algorithmParms = { + .algorithmID = TPM_ALG_RSA, + .encScheme = TPM_ES_NONE, + .sigScheme = TPM_SS_RSASSAPKCS1v15_SHA1, + .parmSize = 12, + .parms.rsa = { + .keyLength = RSA_KEY_SIZE, + .numPrimes = 2, + .exponentSize = 0, + .exponent = NULL, + }, + }, + .PCRInfoSize = 0, + .pubKey.keyLength = 0, + .encDataSize = 0, + }; + + TPM_AUTH_SESSION srkAuth = TPM_AUTH_SESSION_INIT; + TPM_AUTH_SESSION ownAuth = TPM_AUTH_SESSION_INIT; + TPM_SECRET osapMask; + + TPM_KEY key = TPM_KEY_INIT; + UINT32 identityBindingSize; + BYTE* identityBinding = NULL; + + TPM_RESULT rc; + + rc = TPM_OSAP(TPM_ET_OWNER, 0, (void*)&vtpm_globals.owner_auth, &osapMask, &ownAuth); + if (rc) + return rc; + + rc = TPM_OIAP(&srkAuth); + if (rc) + return rc; + + rc = TPM_MakeIdentity((void*)&group->aik_authdata, (void*)privCADigest, &kinfo, + (void*)&vtpm_globals.srk_auth, (void*)&osapMask, &srkAuth, &ownAuth, + &key, &identityBindingSize, &identityBinding); + + TPM_TerminateHandle(srkAuth.AuthHandle); + TPM_TerminateHandle(ownAuth.AuthHandle); + + if (rc) { + printk("TPM_MakeIdentity failed: %d\n", rc); + return rc; + } + + if (key.pubKey.keyLength != 256) + rc = TPM_FAIL; + if (key.encDataSize != 256) + rc = TPM_FAIL; + if (identityBindingSize != 256) + rc = TPM_FAIL; + if (rc) { + printk("TPM_MakeIdentity TPM_KEY mismatch: %d %d %d\n", + key.pubKey.keyLength, key.encDataSize, identityBindingSize); + } else { + memcpy(group->id_data.tpm_aik_public, key.pubKey.key, 256); + memcpy(group->id_data.tpm_aik_edata, key.encData, 256); + memcpy(group->details.recovery_data, identityBinding, 256); + } + + free_TPM_KEY(&key); + free(identityBinding); + + return rc; +} + +static int do_load_aik(struct mem_group *group, TPM_HANDLE *handle) +{ + TPM_KEY key = { + .ver = TPM_STRUCT_VER_1_1, + .keyUsage = TPM_KEY_IDENTITY, + .keyFlags = 0, + .authDataUsage = TPM_AUTH_ALWAYS, + .algorithmParms = { + .algorithmID = TPM_ALG_RSA, + .encScheme = TPM_ES_NONE, + .sigScheme = TPM_SS_RSASSAPKCS1v15_SHA1, + .parmSize = 12, + .parms.rsa = { + .keyLength = RSA_KEY_SIZE, + .numPrimes = 2, + .exponentSize = 0, + .exponent = NULL, + }, + }, + .PCRInfoSize = 0, + .pubKey.keyLength = 256, + .pubKey.key = group->id_data.tpm_aik_public, + .encDataSize = 256, + .encData = group->id_data.tpm_aik_edata, + }; + + return TPM_LoadKey(TPM_SRK_KEYHANDLE, &key, handle, (void*)&vtpm_globals.srk_auth, &vtpm_globals.oiap); +} + +/* + * Sets up resettable PCRs for a vTPM deep quote request + */ +static int do_pcr_setup(struct mem_group *group, const void* uuid, const uint8_t* kern_hash) +{ + uint32_t reset_sel = (1 << 20) | (1 << 21) | (1 << 22) | (1 << 23); + sha1_context ctx; + TPM_DIGEST extended; + TPM_PCR_SELECTION sel = { + .sizeOfSelect = 3, + .pcrSelect = (void*)&reset_sel, + }; + int rc; + int i; + + rc = TPM_Reset(&sel); + if (rc) + return rc; + + sha1((void*)&group->id_data.saa_pubkey, sizeof(group->id_data.saa_pubkey), extended.digest); + rc = TPM_Extend(20, &extended, &extended); + if (rc) + return rc; + + sha1_starts(&ctx); + sha1_update(&ctx, (void*)&group->details.cfg_seq, 8); + sha1_update(&ctx, (void*)&group->seal_bits.nr_cfgs, 4); + for(i=0; i < group->nr_seals; i++) + sha1_update(&ctx, (void*)&group->seals[i].digest_release, 20); + sha1_update(&ctx, (void*)&group->seal_bits.nr_kerns, 4); + sha1_update(&ctx, (void*)&group->seal_bits.kernels, 20 * be32_native(group->seal_bits.nr_kerns)); + sha1_finish(&ctx, extended.digest); + rc = TPM_Extend(21, &extended, &extended); + if (rc) + return rc; + + if (kern_hash) { + rc = TPM_Extend(22, (void*)kern_hash, &extended); + if (rc) + return rc; + } + + memset(&extended, 0, 20); + memcpy(&extended, group->id_data.uuid, 16); + rc = TPM_Extend(23, &extended, &extended); + if (rc) + return rc; + + if (uuid) { + memset(&extended, 0, 20); + memcpy(&extended, uuid, 16); + rc = TPM_Extend(23, &extended, &extended); + if (rc) + return rc; + } + + return rc; +} + +struct mem_group *vtpm_new_group(const struct tpm_authdata *privCADigest) +{ + static struct mem_group* group0_delayed = NULL; + struct mem_group *group; + + if (group0_delayed) { + group = group0_delayed; + group0_delayed = NULL; + } else { + group = calloc(1, sizeof(*group)); + + group->flags = MEM_GROUP_FLAG_FIRSTBOOT; + + do_random(&group->id_data.uuid, 16); + do_random(&group->group_key, 16); + do_random(&group->rollback_mac_key, 16); + do_random(&group->aik_authdata, 20); + + group->id_data.uuid[6] = 0x40 | (group->id_data.uuid[6] & 0x0F); + group->id_data.uuid[8] = 0x80 | (group->id_data.uuid[8] & 0x3F); + } + + if (privCADigest) { + int rc; + rc = do_provision_aik(group, privCADigest); + if (rc) { + free(group); + return NULL; + } + } else { + group0_delayed = group; + } + + return group; +} + +int group_do_activate(struct mem_group *group, void* blob, int blobSize, + void* resp, unsigned int *rlen) +{ + int rc; + TPM_HANDLE handle; + TPM_AUTH_SESSION aikAuth = TPM_AUTH_SESSION_INIT; + TPM_AUTH_SESSION ownAuth = TPM_AUTH_SESSION_INIT; + TPM_SYMMETRIC_KEY symKey; + + /* ActivateIdentity with TPM_EK_BLOB_ACTIVATE can check PCRs */ + rc = do_pcr_setup(group, NULL, NULL); + if (rc) + return rc; + + rc = do_load_aik(group, &handle); + if (rc) + return rc; + + rc = TPM_OIAP(&aikAuth); + if (rc) { + TPM_TerminateHandle(handle); + return rc; + } + + rc = TPM_OIAP(&ownAuth); + if (rc) { + TPM_TerminateHandle(aikAuth.AuthHandle); + TPM_TerminateHandle(handle); + return rc; + } + + rc = TPM_ActivateIdentity(handle, blob, blobSize, (void*)&group->aik_authdata, + (void*)&vtpm_globals.owner_auth, &aikAuth, &ownAuth, &symKey); + + TPM_TerminateHandle(ownAuth.AuthHandle); + TPM_TerminateHandle(aikAuth.AuthHandle); + TPM_TerminateHandle(handle); + + if (rc) + return rc; + + pack_TPM_SYMMETRIC_KEY(resp + *rlen, &symKey); + *rlen += 8 + symKey.size; + free(symKey.data); + + return rc; +} + +int vtpm_do_quote(struct mem_group *group, const uuid_t uuid, + const uint8_t* kern_hash, const struct tpm_authdata *data, TPM_PCR_SELECTION *sel, + void* pcr_out, uint32_t *pcr_size, void* sig_out) +{ + TPM_HANDLE handle; + TPM_AUTH_SESSION oiap = TPM_AUTH_SESSION_INIT; + TPM_PCR_COMPOSITE pcrs; + BYTE* sig; + UINT32 size; + int rc; + + rc = do_pcr_setup(group, uuid, kern_hash); + if (rc) + return rc; + + rc = do_load_aik(group, &handle); + if (rc) + return rc; + + rc = TPM_OIAP(&oiap); + if (rc) { + TPM_TerminateHandle(handle); + return rc; + } + + rc = TPM_Quote(handle, (void*)data, sel, (void*)&group->aik_authdata, &oiap, &pcrs, &sig, &size); + printk("TPM_Quote: %d\n", rc); + + TPM_TerminateHandle(oiap.AuthHandle); + TPM_FlushSpecific(handle, TPM_RT_KEY); + + if (rc) + return rc; + if (size != 256) { + printk("Bad size\n"); + return TPM_FAIL; + } + + if (pcr_out) { + *pcr_size = pcrs.valueSize; + memcpy(pcr_out, pcrs.pcrValue, *pcr_size); + } + + memcpy(sig_out, sig, size); + + free_TPM_PCR_COMPOSITE(&pcrs); + free(sig); + + return rc; +} diff --git a/stubdom/vtpmmgr/mgmt_authority.h b/stubdom/vtpmmgr/mgmt_authority.h new file mode 100644 index 0000000..1e96c8a --- /dev/null +++ b/stubdom/vtpmmgr/mgmt_authority.h @@ -0,0 +1,11 @@ +#ifndef __VTPMMGR_MGMT_AUTHORITY_H +#define __VTPMMGR_MGMT_AUTHORITY_H + +struct mem_group *vtpm_new_group(const struct tpm_authdata *privCADigest); +int group_do_activate(struct mem_group *group, void* blob, int blobSize, + void* resp, unsigned int *rlen); +int vtpm_do_quote(struct mem_group *group, const uuid_t uuid, + const uint8_t* kern_hash, const struct tpm_authdata *data, TPM_PCR_SELECTION *sel, + void* pcr_out, uint32_t *pcr_size, void* sig_out); + +#endif diff --git a/stubdom/vtpmmgr/tcg.h b/stubdom/vtpmmgr/tcg.h index 7687eae..f4c8bc0 100644 --- a/stubdom/vtpmmgr/tcg.h +++ b/stubdom/vtpmmgr/tcg.h @@ -490,6 +490,13 @@ typedef struct TPM_SYMMETRIC_KEY_PARMS { BYTE* IV; } TPM_SYMMETRIC_KEY_PARMS; +typedef struct TPM_SYMMETRIC_KEY { + UINT32 algId; + UINT16 encScheme; + UINT16 size; + BYTE* data; +} TPM_SYMMETRIC_KEY; + inline void free_TPM_SYMMETRIC_KEY_PARMS(TPM_SYMMETRIC_KEY_PARMS* p) { free(p->IV); p->IV = NULL; diff --git a/stubdom/vtpmmgr/tpm.c b/stubdom/vtpmmgr/tpm.c index 123a27c..0548e5c 100644 --- a/stubdom/vtpmmgr/tpm.c +++ b/stubdom/vtpmmgr/tpm.c @@ -51,173 +51,247 @@ #define TCPA_MAX_BUFFER_LENGTH 0x2000 -#define TPM_BEGIN(TAG, ORD) \ - const TPM_TAG intag = TAG;\ -TPM_TAG tag = intag;\ -UINT32 paramSize;\ -const TPM_COMMAND_CODE ordinal = ORD;\ -TPM_RESULT status = TPM_SUCCESS;\ -BYTE in_buf[TCPA_MAX_BUFFER_LENGTH];\ -BYTE out_buf[TCPA_MAX_BUFFER_LENGTH];\ -UINT32 out_len = sizeof(out_buf);\ -BYTE* ptr = in_buf;\ -/*Print a log message */\ -vtpmloginfo(VTPM_LOG_TPM, "%s\n", __func__);\ -/* Pack the header*/\ -ptr = pack_TPM_TAG(ptr, tag);\ -ptr += sizeof(UINT32);\ -ptr = pack_TPM_COMMAND_CODE(ptr, ordinal)\ - -#define TPM_AUTH_BEGIN() \ - sha1_context sha1_ctx;\ -BYTE* authbase = ptr - sizeof(TPM_COMMAND_CODE);\ -TPM_DIGEST paramDigest;\ -sha1_starts(&sha1_ctx) - -#define TPM_AUTH1_GEN(HMACkey, auth) do {\ - sha1_finish(&sha1_ctx, paramDigest.digest);\ - generateAuth(¶mDigest, HMACkey, auth);\ - ptr = pack_TPM_AUTH_SESSION(ptr, auth);\ -} while(0) - -#define TPM_AUTH2_GEN(HMACkey, auth) do {\ - generateAuth(¶mDigest, HMACkey, auth);\ - ptr = pack_TPM_AUTH_SESSION(ptr, auth);\ -} while(0) - -#define TPM_TRANSMIT() do {\ - /* Pack the command size */\ - paramSize = ptr - in_buf;\ - pack_UINT32(in_buf + sizeof(TPM_TAG), paramSize);\ - if((status = TPM_TransmitData(in_buf, paramSize, out_buf, &out_len)) != TPM_SUCCESS) {\ - goto abort_egress;\ - }\ -} while(0) - -#define TPM_AUTH_VERIFY_BEGIN() do {\ - UINT32 buf[2] = { cpu_to_be32(status), cpu_to_be32(ordinal) };\ - sha1_starts(&sha1_ctx);\ - sha1_update(&sha1_ctx, (unsigned char*)buf, sizeof(buf));\ - authbase = ptr;\ -} while(0) - -#define TPM_AUTH1_VERIFY(HMACkey, auth) do {\ - sha1_finish(&sha1_ctx, paramDigest.digest);\ - ptr = unpack_TPM_AUTH_SESSION(ptr, auth);\ - if((status = verifyAuth(¶mDigest, HMACkey, auth)) != TPM_SUCCESS) {\ - goto abort_egress;\ - }\ -} while(0) - -#define TPM_AUTH2_VERIFY(HMACkey, auth) do {\ - ptr = unpack_TPM_AUTH_SESSION(ptr, auth);\ - if((status = verifyAuth(¶mDigest, HMACkey, auth)) != TPM_SUCCESS) {\ - goto abort_egress;\ - }\ -} while(0) - - - -#define TPM_UNPACK_VERIFY() do { \ - ptr = out_buf;\ - ptr = unpack_TPM_RSP_HEADER(ptr, \ - &(tag), &(paramSize), &(status));\ - if((status) != TPM_SUCCESS || (tag) != (intag +3)) { \ - vtpmlogerror(VTPM_LOG_TPM, "Failed with return code %s\n", tpm_get_error_name(status));\ - goto abort_egress;\ - }\ -} while(0) - -#define TPM_AUTH_HASH() do {\ - sha1_update(&sha1_ctx, authbase, ptr - authbase);\ - authbase = ptr;\ -} while(0) - -#define TPM_AUTH_SKIP() do {\ - authbase = ptr;\ -} while(0) +#define TPM_BEGIN_CMD(ord) \ + const TPM_COMMAND_CODE ordinal = ord; \ + TPM_RESULT status = TPM_SUCCESS; \ + BYTE _io_buffer[TCPA_MAX_BUFFER_LENGTH]; \ + UINT32 _io_bufsize_in; \ + UINT32 _io_bufsize_out; \ + vtpmloginfo(VTPM_LOG_TPM, "%s\n", __func__); \ + do { \ + BYTE *in_buf = _io_buffer; \ + UINT32 in_pos = 6; \ + PACK_IN(UINT32, ordinal); + +#define IN_PTR (in_buf + in_pos) + +#define PACK_IN(type, item...) do { \ + UINT32 isize = sizeof_ ## type(item); \ + if (isize + in_pos > TCPA_MAX_BUFFER_LENGTH) { \ + status = TPM_SIZE; \ + goto abort_egress; \ + } \ + pack_ ## type (IN_PTR, item); \ + in_pos += isize; \ +} while (0) + +#define TPM_HASH_IN_BEGIN \ + sha1_context sha1_ctx; \ + sha1_starts(&sha1_ctx); \ + sha1_update(&sha1_ctx, in_buf + 6, 4); \ + TPM_HASH_IN_START + +#define TPM_HASH_IN_START \ + do { \ + UINT32 _hash_in_start = in_pos; + +#define TPM_HASH_IN_STOP \ + sha1_update(&sha1_ctx, in_buf + _hash_in_start, in_pos - _hash_in_start); \ + } while (0) + +#define TPM_TAG_COMMON(req_tag) \ + _io_bufsize_in = in_pos; \ + pack_TPM_TAG(in_buf, req_tag); \ + pack_UINT32(in_buf + sizeof(TPM_TAG), in_pos); \ + } while (0); \ + _io_bufsize_out = TCPA_MAX_BUFFER_LENGTH; \ + status = TPM_TransmitData(_io_buffer, _io_bufsize_in, _io_buffer, &_io_bufsize_out); \ + if (status != TPM_SUCCESS) { \ + goto abort_egress; \ + } \ + do { \ + BYTE *out_buf = _io_buffer; \ + UINT32 out_pos = 0; \ + UINT32 out_len = _io_bufsize_out; \ + do { \ + TPM_TAG rsp_tag; \ + UINT32 rsp_len; \ + UINT32 rsp_status; \ + UNPACK_OUT(TPM_RSP_HEADER, &rsp_tag, &rsp_len, &rsp_status); \ + if (rsp_status != TPM_SUCCESS) { \ + vtpmlogerror(VTPM_LOG_TPM, "Failed with return code %s\n", tpm_get_error_name(rsp_status)); \ + status = rsp_status; \ + goto abort_egress; \ + } \ + if (rsp_tag != req_tag + 3 || rsp_len != out_len) { \ + status = TPM_FAIL; \ + goto abort_egress; \ + } \ + } while(0) + +#define OUT_PTR (out_buf + out_pos) + +#define UNPACK_OUT(type, item...) do { \ + if (unpack3_ ## type (out_buf, &out_pos, TCPA_MAX_BUFFER_LENGTH, item)) { \ + status = TPM_SIZE; \ + goto abort_egress; \ + } \ +} while (0) + +#define TPM_XMIT_REQ() \ + TPM_TAG_COMMON(TPM_TAG_RQU_COMMAND) + +#define TPM_XMIT_AUTH1(sec1, auth1) \ + TPM_HASH_IN_STOP; \ + do { \ + TPM_DIGEST paramDigest; \ + sha1_finish(&sha1_ctx, paramDigest.digest); \ + generateAuth(¶mDigest, sec1, auth1); \ + PACK_IN(TPM_AUTH_SESSION, auth1); \ + } while (0); \ + TPM_TAG_COMMON(TPM_TAG_RQU_AUTH1_COMMAND); \ + TPM_HASH_OUT_BEGIN + +#define TPM_XMIT_AUTH2(sec1, auth1, sec2, auth2) \ + TPM_HASH_IN_STOP; \ + do { \ + TPM_DIGEST paramDigest; \ + sha1_finish(&sha1_ctx, paramDigest.digest); \ + generateAuth(¶mDigest, sec1, auth1); \ + PACK_IN(TPM_AUTH_SESSION, auth1); \ + generateAuth(¶mDigest, sec2, auth2); \ + PACK_IN(TPM_AUTH_SESSION, auth2); \ + } while (0); \ + TPM_TAG_COMMON(TPM_TAG_RQU_AUTH2_COMMAND); \ + TPM_HASH_OUT_BEGIN + +#define TPM_HASH_OUT_BEGIN \ + sha1_context sha1_ctx; \ + sha1_starts(&sha1_ctx); \ + do { \ + UINT32 buf[2] = { cpu_to_be32(status), cpu_to_be32(ordinal) }; \ + sha1_update(&sha1_ctx, (BYTE*)buf, sizeof(buf)); \ + } while(0); \ + TPM_HASH_OUT_START + +#define TPM_HASH_OUT_START \ + do { \ + UINT32 _hash_out_start = out_pos; + +#define TPM_HASH_OUT_STOP \ + sha1_update(&sha1_ctx, out_buf + _hash_out_start, out_pos - _hash_out_start); \ + } while (0) + +#define TPM_END_AUTH1(sec1, auth1) \ + TPM_HASH_OUT_STOP; \ + do { \ + TPM_DIGEST paramDigest; \ + sha1_finish(&sha1_ctx, paramDigest.digest); \ + UNPACK_OUT(TPM_AUTH_SESSION, auth1); \ + status = verifyAuth(¶mDigest, sec1, auth1); \ + if (status != TPM_SUCCESS) \ + goto abort_egress; \ + } while(0); \ + TPM_END_COMMON + +#define TPM_END_AUTH2(sec1, auth1, sec2, auth2) \ + TPM_HASH_OUT_STOP; \ + do { \ + TPM_DIGEST paramDigest; \ + sha1_finish(&sha1_ctx, paramDigest.digest); \ + UNPACK_OUT(TPM_AUTH_SESSION, auth1); \ + status = verifyAuth(¶mDigest, sec1, auth1); \ + if (status != TPM_SUCCESS) \ + goto abort_egress; \ + UNPACK_OUT(TPM_AUTH_SESSION, auth2); \ + status = verifyAuth(¶mDigest, sec2, auth2); \ + if (status != TPM_SUCCESS) \ + goto abort_egress; \ + } while(0); \ + TPM_END_COMMON + +#define TPM_END() TPM_END_COMMON + +#define TPM_END_COMMON \ + if (out_pos != out_len) { \ + vtpmloginfo(VTPM_LOG_TPM, "Response too long (%d != %d)", out_pos, out_len);\ + status = TPM_SIZE; \ + goto abort_egress; \ + } \ + } while (0); \ #define TPM_AUTH_ERR_CHECK(auth) do {\ - if(status != TPM_SUCCESS || auth->fContinueAuthSession == FALSE) {\ - vtpmloginfo(VTPM_LOG_TPM, "Auth Session: 0x%x closed by TPM\n", auth->AuthHandle);\ - auth->AuthHandle = 0;\ - }\ + if(status != TPM_SUCCESS || auth->fContinueAuthSession == FALSE) {\ + vtpmloginfo(VTPM_LOG_TPM, "Auth Session: 0x%x closed by TPM\n", auth->AuthHandle);\ + auth->AuthHandle = 0;\ + }\ } while(0) static void xorEncrypt(const TPM_SECRET* sharedSecret, - TPM_NONCE* nonce, - const TPM_AUTHDATA* inAuth0, - TPM_ENCAUTH outAuth0, - const TPM_AUTHDATA* inAuth1, - TPM_ENCAUTH outAuth1) { - BYTE XORbuffer[sizeof(TPM_SECRET) + sizeof(TPM_NONCE)]; - BYTE XORkey[TPM_DIGEST_SIZE]; - BYTE* ptr = XORbuffer; - ptr = pack_TPM_SECRET(ptr, sharedSecret); - ptr = pack_TPM_NONCE(ptr, nonce); - - sha1(XORbuffer, ptr - XORbuffer, XORkey); - - if(inAuth0) { - for(int i = 0; i < TPM_DIGEST_SIZE; ++i) { - outAuth0[i] = XORkey[i] ^ (*inAuth0)[i]; - } - } - if(inAuth1) { - for(int i = 0; i < TPM_DIGEST_SIZE; ++i) { - outAuth1[i] = XORkey[i] ^ (*inAuth1)[i]; - } - } + TPM_NONCE* nonce, + const TPM_AUTHDATA* inAuth0, + TPM_ENCAUTH outAuth0, + const TPM_AUTHDATA* inAuth1, + TPM_ENCAUTH outAuth1) { + BYTE XORbuffer[sizeof(TPM_SECRET) + sizeof(TPM_NONCE)]; + BYTE XORkey[TPM_DIGEST_SIZE]; + BYTE* ptr = XORbuffer; + ptr = pack_TPM_SECRET(ptr, sharedSecret); + ptr = pack_TPM_NONCE(ptr, nonce); + + sha1(XORbuffer, ptr - XORbuffer, XORkey); + + if(inAuth0) { + for(int i = 0; i < TPM_DIGEST_SIZE; ++i) { + outAuth0[i] = XORkey[i] ^ (*inAuth0)[i]; + } + } + if(inAuth1) { + for(int i = 0; i < TPM_DIGEST_SIZE; ++i) { + outAuth1[i] = XORkey[i] ^ (*inAuth1)[i]; + } + } } static void generateAuth(const TPM_DIGEST* paramDigest, - const TPM_SECRET* HMACkey, - TPM_AUTH_SESSION *auth) + const TPM_SECRET* HMACkey, + TPM_AUTH_SESSION *auth) { - //Generate new OddNonce - vtpmmgr_rand((BYTE*)auth->NonceOdd.nonce, sizeof(TPM_NONCE)); + //Generate new OddNonce + vtpmmgr_rand((BYTE*)auth->NonceOdd.nonce, sizeof(TPM_NONCE)); - // Create HMAC text. (Concat inParamsDigest with inAuthSetupParams). - BYTE hmacText[sizeof(TPM_DIGEST) + (2 * sizeof(TPM_NONCE)) + sizeof(BOOL)]; - BYTE* ptr = hmacText; + // Create HMAC text. (Concat inParamsDigest with inAuthSetupParams). + BYTE hmacText[sizeof(TPM_DIGEST) + (2 * sizeof(TPM_NONCE)) + sizeof(BOOL)]; + BYTE* ptr = hmacText; - ptr = pack_TPM_DIGEST(ptr, paramDigest); - ptr = pack_TPM_NONCE(ptr, &auth->NonceEven); - ptr = pack_TPM_NONCE(ptr, &auth->NonceOdd); - ptr = pack_BOOL(ptr, auth->fContinueAuthSession); + ptr = pack_TPM_DIGEST(ptr, paramDigest); + ptr = pack_TPM_NONCE(ptr, &auth->NonceEven); + ptr = pack_TPM_NONCE(ptr, &auth->NonceOdd); + ptr = pack_BOOL(ptr, auth->fContinueAuthSession); - sha1_hmac((BYTE *) HMACkey, sizeof(TPM_DIGEST), - (BYTE *) hmacText, sizeof(hmacText), - auth->HMAC); + sha1_hmac((BYTE *) HMACkey, sizeof(TPM_DIGEST), + (BYTE *) hmacText, sizeof(hmacText), + auth->HMAC); } static TPM_RESULT verifyAuth(const TPM_DIGEST* paramDigest, - /*[IN]*/ const TPM_SECRET *HMACkey, - /*[IN,OUT]*/ TPM_AUTH_SESSION *auth) + /*[IN]*/ const TPM_SECRET *HMACkey, + /*[IN,OUT]*/ TPM_AUTH_SESSION *auth) { - // Create HMAC text. (Concat inParamsDigest with inAuthSetupParams). - TPM_AUTHDATA hm; - BYTE hmacText[sizeof(TPM_DIGEST) + (2 * sizeof(TPM_NONCE)) + sizeof(BOOL)]; - BYTE* ptr = hmacText; - - ptr = pack_TPM_DIGEST(ptr, paramDigest); - ptr = pack_TPM_NONCE(ptr, &auth->NonceEven); - ptr = pack_TPM_NONCE(ptr, &auth->NonceOdd); - ptr = pack_BOOL(ptr, auth->fContinueAuthSession); - - sha1_hmac( (BYTE *) HMACkey, sizeof(TPM_DIGEST), - (BYTE *) hmacText, sizeof(hmacText), - hm); - - // Compare correct HMAC with provided one. - if (memcmp(hm, auth->HMAC, sizeof(TPM_DIGEST)) == 0) { // 0 indicates equality - return TPM_SUCCESS; - } else { - vtpmlogerror(VTPM_LOG_TPM, "Auth Session verification failed!\n"); - return TPM_AUTHFAIL; - } + // Create HMAC text. (Concat inParamsDigest with inAuthSetupParams). + TPM_AUTHDATA hm; + BYTE hmacText[sizeof(TPM_DIGEST) + (2 * sizeof(TPM_NONCE)) + sizeof(BOOL)]; + BYTE* ptr = hmacText; + + ptr = pack_TPM_DIGEST(ptr, paramDigest); + ptr = pack_TPM_NONCE(ptr, &auth->NonceEven); + ptr = pack_TPM_NONCE(ptr, &auth->NonceOdd); + ptr = pack_BOOL(ptr, auth->fContinueAuthSession); + + sha1_hmac( (BYTE *) HMACkey, sizeof(TPM_DIGEST), + (BYTE *) hmacText, sizeof(hmacText), + hm); + + // Compare correct HMAC with provided one. + if (memcmp(hm, auth->HMAC, sizeof(TPM_DIGEST)) == 0) { // 0 indicates equality + return TPM_SUCCESS; + } else { + vtpmlogerror(VTPM_LOG_TPM, "Auth Session verification failed! %x %x\n", + *(UINT32*)auth->HMAC, *(UINT32*)hm); + return TPM_AUTHFAIL; + } } @@ -226,713 +300,603 @@ static TPM_RESULT verifyAuth(const TPM_DIGEST* paramDigest, // Authorization Commands // ------------------------------------------------------------------ -TPM_RESULT TPM_OIAP(TPM_AUTH_SESSION* auth) // out +TPM_RESULT TPM_OIAP(TPM_AUTH_SESSION* auth) // out { - TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_OIAP); + TPM_BEGIN_CMD(TPM_ORD_OIAP); - TPM_TRANSMIT(); - TPM_UNPACK_VERIFY(); + TPM_XMIT_REQ(); - memset(&auth->HMAC, 0, sizeof(TPM_DIGEST)); - auth->fContinueAuthSession = TRUE; + memset(&auth->HMAC, 0, sizeof(TPM_DIGEST)); + auth->fContinueAuthSession = TRUE; - ptr = unpack_UINT32(ptr, &auth->AuthHandle); - ptr = unpack_TPM_NONCE(ptr, &auth->NonceEven); + UNPACK_OUT(UINT32, &auth->AuthHandle); + UNPACK_OUT(TPM_NONCE, &auth->NonceEven); + TPM_END(); - vtpmloginfo(VTPM_LOG_TPM, "Auth Session: 0x%x opened by TPM_OIAP.\n", auth->AuthHandle); + vtpmloginfo(VTPM_LOG_TPM, "Auth Session: 0x%x opened by TPM_OIAP.\n", auth->AuthHandle); abort_egress: - return status; + return status; } TPM_RESULT TPM_OSAP(TPM_ENTITY_TYPE entityType, // in - UINT32 entityValue, // in - const TPM_AUTHDATA* usageAuth, //in - TPM_SECRET *sharedSecret, //out - TPM_AUTH_SESSION *auth) + UINT32 entityValue, // in + const TPM_AUTHDATA* usageAuth, //in + TPM_SECRET *sharedSecret, //out + TPM_AUTH_SESSION *auth) { - BYTE* nonceOddOSAP; - TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_OSAP); + TPM_DIGEST nonceOddOSAP; + vtpmmgr_rand(nonceOddOSAP.digest, TPM_DIGEST_SIZE); + TPM_BEGIN_CMD(TPM_ORD_OSAP); - ptr = pack_TPM_ENTITY_TYPE(ptr, entityType); - ptr = pack_UINT32(ptr, entityValue); + PACK_IN(TPM_ENTITY_TYPE, entityType); + PACK_IN(UINT32, entityValue); + PACK_IN(TPM_DIGEST, &nonceOddOSAP); - //nonce Odd OSAP - nonceOddOSAP = ptr; - vtpmmgr_rand(ptr, TPM_DIGEST_SIZE); - ptr += TPM_DIGEST_SIZE; + TPM_XMIT_REQ(); - TPM_TRANSMIT(); - TPM_UNPACK_VERIFY(); + UNPACK_OUT(UINT32, &auth->AuthHandle); + UNPACK_OUT(TPM_NONCE, &auth->NonceEven); - ptr = unpack_UINT32(ptr, &auth->AuthHandle); - ptr = unpack_TPM_NONCE(ptr, &auth->NonceEven); + //Calculate session secret + sha1_context ctx; + sha1_hmac_starts(&ctx, *usageAuth, TPM_DIGEST_SIZE); + sha1_hmac_update(&ctx, OUT_PTR, TPM_DIGEST_SIZE); // nonceEvenOSAP + sha1_hmac_update(&ctx, nonceOddOSAP.digest, TPM_DIGEST_SIZE); + sha1_hmac_finish(&ctx, *sharedSecret); - //Calculate session secret - sha1_context ctx; - sha1_hmac_starts(&ctx, *usageAuth, TPM_DIGEST_SIZE); - sha1_hmac_update(&ctx, ptr, TPM_DIGEST_SIZE); //ptr = nonceEvenOSAP - sha1_hmac_update(&ctx, nonceOddOSAP, TPM_DIGEST_SIZE); - sha1_hmac_finish(&ctx, *sharedSecret); + out_pos += TPM_DIGEST_SIZE; + TPM_END(); - memset(&auth->HMAC, 0, sizeof(TPM_DIGEST)); - auth->fContinueAuthSession = FALSE; + memset(&auth->HMAC, 0, sizeof(TPM_DIGEST)); + auth->fContinueAuthSession = FALSE; - vtpmloginfo(VTPM_LOG_TPM, "Auth Session: 0x%x opened by TPM_OSAP.\n", auth->AuthHandle); + vtpmloginfo(VTPM_LOG_TPM, "Auth Session: 0x%x opened by TPM_OSAP.\n", auth->AuthHandle); abort_egress: - return status; + return status; } TPM_RESULT TPM_TakeOwnership( - const TPM_PUBKEY *pubEK, //in - const TPM_AUTHDATA* ownerAuth, //in - const TPM_AUTHDATA* srkAuth, //in - const TPM_KEY* inSrk, //in - TPM_KEY* outSrk, //out, optional - TPM_AUTH_SESSION* auth) // in, out + const TPM_PUBKEY *pubEK, //in + const TPM_AUTHDATA* ownerAuth, //in + const TPM_AUTHDATA* srkAuth, //in + const TPM_KEY* inSrk, //in + TPM_KEY* outSrk, //out, optional + TPM_AUTH_SESSION* auth) // in, out { - int keyAlloced = 0; - tpmrsa_context ek_rsa = TPMRSA_CTX_INIT; - - TPM_BEGIN(TPM_TAG_RQU_AUTH1_COMMAND, TPM_ORD_TakeOwnership); - TPM_AUTH_BEGIN(); - - tpmrsa_set_pubkey(&ek_rsa, - pubEK->pubKey.key, pubEK->pubKey.keyLength, - pubEK->algorithmParms.parms.rsa.exponent, - pubEK->algorithmParms.parms.rsa.exponentSize); - - /* Pack the protocol ID */ - ptr = pack_UINT16(ptr, TPM_PID_OWNER); - - /* Pack the encrypted owner auth */ - ptr = pack_UINT32(ptr, pubEK->algorithmParms.parms.rsa.keyLength / 8); - tpmrsa_pub_encrypt_oaep(&ek_rsa, - ctr_drbg_random, &vtpm_globals.ctr_drbg, - sizeof(TPM_SECRET), - (BYTE*) ownerAuth, - ptr); - ptr += pubEK->algorithmParms.parms.rsa.keyLength / 8; - - /* Pack the encrypted srk auth */ - ptr = pack_UINT32(ptr, pubEK->algorithmParms.parms.rsa.keyLength / 8); - tpmrsa_pub_encrypt_oaep(&ek_rsa, - ctr_drbg_random, &vtpm_globals.ctr_drbg, - sizeof(TPM_SECRET), - (BYTE*) srkAuth, - ptr); - ptr += pubEK->algorithmParms.parms.rsa.keyLength / 8; - - /* Pack the Srk key */ - ptr = pack_TPM_KEY(ptr, inSrk); - - /* Hash everything up to here */ - TPM_AUTH_HASH(); - - /* Generate the authorization */ - TPM_AUTH1_GEN(ownerAuth, auth); - - /* Send the command to the tpm*/ - TPM_TRANSMIT(); - /* Unpack and validate the header */ - TPM_UNPACK_VERIFY(); - TPM_AUTH_VERIFY_BEGIN(); - - if(outSrk != NULL) { - /* If the user wants a copy of the srk we give it to them */ - keyAlloced = 1; - ptr = unpack_TPM_KEY(ptr, outSrk, UNPACK_ALLOC); - } else { - /*otherwise just parse past it */ - TPM_KEY temp; - ptr = unpack_TPM_KEY(ptr, &temp, UNPACK_ALIAS); - } - - /* Hash the output key */ - TPM_AUTH_HASH(); - - /* Verify authorizaton */ - TPM_AUTH1_VERIFY(ownerAuth, auth); - - goto egress; + int keyAlloced = 0; + tpmrsa_context ek_rsa = TPMRSA_CTX_INIT; + + TPM_BEGIN_CMD(TPM_ORD_TakeOwnership); + TPM_HASH_IN_BEGIN; + + tpmrsa_set_pubkey(&ek_rsa, + pubEK->pubKey.key, pubEK->pubKey.keyLength, + pubEK->algorithmParms.parms.rsa.exponent, + pubEK->algorithmParms.parms.rsa.exponentSize); + + /* Pack the protocol ID */ + PACK_IN(UINT16, TPM_PID_OWNER); + + /* Pack the encrypted owner auth */ + PACK_IN(UINT32, pubEK->algorithmParms.parms.rsa.keyLength / 8); + tpmrsa_pub_encrypt_oaep(&ek_rsa, + ctr_drbg_random, &vtpm_globals.ctr_drbg, + sizeof(TPM_SECRET), + (BYTE*) ownerAuth, + IN_PTR); + in_pos += pubEK->algorithmParms.parms.rsa.keyLength / 8; + + /* Pack the encrypted srk auth */ + PACK_IN(UINT32, pubEK->algorithmParms.parms.rsa.keyLength / 8); + tpmrsa_pub_encrypt_oaep(&ek_rsa, + ctr_drbg_random, &vtpm_globals.ctr_drbg, + sizeof(TPM_SECRET), + (BYTE*) srkAuth, + IN_PTR); + in_pos += pubEK->algorithmParms.parms.rsa.keyLength / 8; + + PACK_IN(TPM_KEY, inSrk); + + TPM_XMIT_AUTH1(ownerAuth, auth); + + if (outSrk != NULL) { + /* If the user wants a copy of the srk we give it to them */ + keyAlloced = 1; + UNPACK_OUT(TPM_KEY, outSrk, UNPACK_ALLOC); + } else { + /*otherwise just parse past it */ + TPM_KEY temp; + UNPACK_OUT(TPM_KEY, &temp, UNPACK_ALIAS); + } + + TPM_END_AUTH1(ownerAuth, auth); + + goto egress; abort_egress: - if(keyAlloced) { - free_TPM_KEY(outSrk); - } + if(keyAlloced) { + free_TPM_KEY(outSrk); + } egress: - tpmrsa_free(&ek_rsa); - TPM_AUTH_ERR_CHECK(auth); - return status; + tpmrsa_free(&ek_rsa); + TPM_AUTH_ERR_CHECK(auth); + return status; } TPM_RESULT TPM_DisablePubekRead ( - const TPM_AUTHDATA* ownerAuth, - TPM_AUTH_SESSION* auth) + const TPM_AUTHDATA* ownerAuth, + TPM_AUTH_SESSION* auth) { - TPM_BEGIN(TPM_TAG_RQU_AUTH1_COMMAND, TPM_ORD_DisablePubekRead); - TPM_AUTH_BEGIN(); - - TPM_AUTH_HASH(); + TPM_BEGIN_CMD(TPM_ORD_DisablePubekRead); + TPM_HASH_IN_BEGIN; - TPM_AUTH1_GEN(ownerAuth, auth); - TPM_TRANSMIT(); - TPM_UNPACK_VERIFY(); - TPM_AUTH_VERIFY_BEGIN(); + TPM_XMIT_AUTH1(ownerAuth, auth); - TPM_AUTH1_VERIFY(ownerAuth, auth); + TPM_END_AUTH1(ownerAuth, auth); abort_egress: - TPM_AUTH_ERR_CHECK(auth); - return status; + TPM_AUTH_ERR_CHECK(auth); + return status; } TPM_RESULT TPM_TerminateHandle(TPM_AUTHHANDLE handle) // in { - if(handle == 0) { - return TPM_SUCCESS; - } + if(handle == 0) { + return TPM_SUCCESS; + } - TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_Terminate_Handle); + TPM_BEGIN_CMD(TPM_ORD_Terminate_Handle); - ptr = pack_TPM_AUTHHANDLE(ptr, handle); + PACK_IN(TPM_AUTHHANDLE, handle); - TPM_TRANSMIT(); - TPM_UNPACK_VERIFY(); + TPM_XMIT_REQ(); + TPM_END(); - vtpmloginfo(VTPM_LOG_TPM, "Auth Session: 0x%x closed by TPM_TerminateHandle\n", handle); + vtpmloginfo(VTPM_LOG_TPM, "Auth Session: 0x%x closed by TPM_TerminateHandle\n", handle); abort_egress: - return status; + return status; } TPM_RESULT TPM_Extend( TPM_PCRINDEX pcrNum, // in - TPM_DIGEST inDigest, // in - TPM_PCRVALUE* outDigest) // out + TPM_DIGEST* inDigest, // in + TPM_PCRVALUE* outDigest) // out { - TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_Extend); + TPM_BEGIN_CMD(TPM_ORD_Extend); + + PACK_IN(TPM_PCRINDEX, pcrNum); + PACK_IN(TPM_DIGEST, inDigest); - ptr = pack_TPM_PCRINDEX(ptr, pcrNum); - ptr = pack_TPM_DIGEST(ptr, &inDigest); + TPM_XMIT_REQ(); - TPM_TRANSMIT(); - TPM_UNPACK_VERIFY(); + UNPACK_OUT(TPM_PCRVALUE, outDigest); - ptr = unpack_TPM_PCRVALUE(ptr, outDigest); + TPM_END(); abort_egress: - return status; + return status; } -TPM_RESULT TPM_Seal( - TPM_KEY_HANDLE keyHandle, // in - UINT32 pcrInfoSize, // in - TPM_PCR_INFO* pcrInfo, // in - UINT32 inDataSize, // in - const BYTE* inData, // in - TPM_STORED_DATA* sealedData, //out - const TPM_SECRET* osapSharedSecret, //in - const TPM_AUTHDATA* sealedDataAuth, //in - TPM_AUTH_SESSION* pubAuth // in, out - ) +TPM_RESULT TPM_Reset(TPM_PCR_SELECTION *sel) { - int dataAlloced = 0; - TPM_BEGIN(TPM_TAG_RQU_AUTH1_COMMAND, TPM_ORD_Seal); - TPM_AUTH_BEGIN(); - - TPM_AUTH_HASH(); - - ptr = pack_TPM_KEY_HANDLE(ptr, keyHandle); - - TPM_AUTH_SKIP(); - - xorEncrypt(osapSharedSecret, &pubAuth->NonceEven, - sealedDataAuth, ptr, - NULL, NULL); - ptr += sizeof(TPM_ENCAUTH); + TPM_BEGIN_CMD(TPM_ORD_PCR_Reset); + PACK_IN(TPM_PCR_SELECTION, sel); + TPM_XMIT_REQ(); + TPM_END(); +abort_egress: + return status; +} - ptr = pack_UINT32(ptr, pcrInfoSize); - ptr = pack_TPM_PCR_INFO(ptr, pcrInfo); +TPM_RESULT TPM_Seal( + TPM_KEY_HANDLE keyHandle, // in + UINT32 pcrInfoSize, // in + TPM_PCR_INFO* pcrInfo, // in + UINT32 inDataSize, // in + const BYTE* inData, // in + TPM_STORED_DATA* sealedData, //out + const TPM_SECRET* osapSharedSecret, //in + const TPM_AUTHDATA* sealedDataAuth, //in + TPM_AUTH_SESSION* pubAuth // in, out + ) +{ + memset(sealedData, 0, sizeof(*sealedData)); + TPM_BEGIN_CMD(TPM_ORD_Seal); + PACK_IN(TPM_KEY_HANDLE, keyHandle); + TPM_HASH_IN_BEGIN; + + xorEncrypt(osapSharedSecret, &pubAuth->NonceEven, sealedDataAuth, IN_PTR, NULL, NULL); + in_pos += sizeof(TPM_ENCAUTH); + PACK_IN(UINT32, pcrInfoSize); + if (pcrInfoSize) + PACK_IN(TPM_PCR_INFO, pcrInfo); + PACK_IN(UINT32, inDataSize); + PACK_IN(BUFFER, inData, inDataSize); + + TPM_XMIT_AUTH1(osapSharedSecret, pubAuth); + + UNPACK_OUT(TPM_STORED_DATA, sealedData, UNPACK_ALLOC); + + TPM_END_AUTH1(osapSharedSecret, pubAuth); + + abort_egress: + if (status) + free_TPM_STORED_DATA(sealedData); + TPM_AUTH_ERR_CHECK(pubAuth); + return status; +} - ptr = pack_UINT32(ptr, inDataSize); - ptr = pack_BUFFER(ptr, inData, inDataSize); +TPM_RESULT TPM_Unseal( + TPM_KEY_HANDLE parentHandle, // in + const TPM_STORED_DATA* sealedData, + UINT32* outSize, // out + BYTE** out, //out + const TPM_AUTHDATA* key_usage_auth, //in + const TPM_AUTHDATA* data_usage_auth, //in + TPM_AUTH_SESSION* keyAuth, // in, out + TPM_AUTH_SESSION* dataAuth // in, out + ) +{ + TPM_BEGIN_CMD(TPM_ORD_Unseal); - TPM_AUTH_HASH(); + PACK_IN(TPM_KEY_HANDLE, parentHandle); - TPM_AUTH1_GEN(osapSharedSecret, pubAuth); - TPM_TRANSMIT(); - TPM_UNPACK_VERIFY(); - TPM_AUTH_VERIFY_BEGIN(); + TPM_HASH_IN_BEGIN; + PACK_IN(TPM_STORED_DATA, sealedData); - ptr = unpack_TPM_STORED_DATA(ptr, sealedData, UNPACK_ALLOC); - dataAlloced = 1; + TPM_XMIT_AUTH2(key_usage_auth, keyAuth, data_usage_auth, dataAuth); - TPM_AUTH_HASH(); + UNPACK_OUT(UINT32, outSize); + UNPACK_OUT(PTR, out, *outSize, UNPACK_ALLOC); - TPM_AUTH1_VERIFY(osapSharedSecret, pubAuth); + TPM_END_AUTH2(key_usage_auth, keyAuth, data_usage_auth, dataAuth); - goto egress; abort_egress: - if(dataAlloced) { - free_TPM_STORED_DATA(sealedData); - } -egress: - TPM_AUTH_ERR_CHECK(pubAuth); - return status; + TPM_AUTH_ERR_CHECK(keyAuth); + TPM_AUTH_ERR_CHECK(dataAuth); + return status; } -TPM_RESULT TPM_Unseal( - TPM_KEY_HANDLE parentHandle, // in - const TPM_STORED_DATA* sealedData, - UINT32* outSize, // out - BYTE** out, //out - const TPM_AUTHDATA* key_usage_auth, //in - const TPM_AUTHDATA* data_usage_auth, //in - TPM_AUTH_SESSION* keyAuth, // in, out - TPM_AUTH_SESSION* dataAuth // in, out - ) +TPM_RESULT TPM_LoadKey( + TPM_KEY_HANDLE parentHandle, // + const TPM_KEY* key, //in + TPM_HANDLE* keyHandle, // out + const TPM_AUTHDATA* usage_auth, + TPM_AUTH_SESSION* auth) { - TPM_BEGIN(TPM_TAG_RQU_AUTH2_COMMAND, TPM_ORD_Unseal); - TPM_AUTH_BEGIN(); + TPM_BEGIN_CMD(TPM_ORD_LoadKey); + PACK_IN(TPM_KEY_HANDLE, parentHandle); - TPM_AUTH_HASH(); + TPM_HASH_IN_BEGIN; - ptr = pack_TPM_KEY_HANDLE(ptr, parentHandle); + PACK_IN(TPM_KEY, key); - TPM_AUTH_SKIP(); + TPM_XMIT_AUTH1(usage_auth, auth); - ptr = pack_TPM_STORED_DATA(ptr, sealedData); + UNPACK_OUT(UINT32, keyHandle); - TPM_AUTH_HASH(); + TPM_END_AUTH1(usage_auth, auth); - TPM_AUTH1_GEN(key_usage_auth, keyAuth); - TPM_AUTH2_GEN(data_usage_auth, dataAuth); - TPM_TRANSMIT(); - TPM_UNPACK_VERIFY(); - TPM_AUTH_VERIFY_BEGIN(); + vtpmloginfo(VTPM_LOG_TPM, "Key Handle: 0x%x opened by TPM_LoadKey\n", *keyHandle); +abort_egress: + TPM_AUTH_ERR_CHECK(auth); + return status; +} - ptr = unpack_UINT32(ptr, outSize); - ptr = unpack_ALLOC(ptr, out, *outSize); +TPM_RESULT TPM_FlushSpecific(TPM_HANDLE handle, + TPM_RESOURCE_TYPE rt) { + if(handle == 0) { + return TPM_SUCCESS; + } + TPM_BEGIN_CMD(TPM_ORD_FlushSpecific); - TPM_AUTH_HASH(); + PACK_IN(TPM_HANDLE, handle); + PACK_IN(TPM_RESOURCE_TYPE, rt); - TPM_AUTH1_VERIFY(key_usage_auth, keyAuth); - TPM_AUTH2_VERIFY(data_usage_auth, dataAuth); + TPM_XMIT_REQ(); + TPM_END(); abort_egress: - TPM_AUTH_ERR_CHECK(keyAuth); - TPM_AUTH_ERR_CHECK(dataAuth); - return status; + return status; } -TPM_RESULT TPM_Bind( - const TPM_KEY* key, - const BYTE* in, - UINT32 ilen, - BYTE* out) +TPM_RESULT TPM_GetRandom( UINT32* bytesRequested, // in, out + BYTE* randomBytes) // out { - TPM_RESULT status; - tpmrsa_context rsa = TPMRSA_CTX_INIT; - TPM_BOUND_DATA boundData; - uint8_t plain[TCPA_MAX_BUFFER_LENGTH]; - BYTE* ptr = plain; - - vtpmloginfo(VTPM_LOG_TPM, "%s\n", __func__); - - tpmrsa_set_pubkey(&rsa, - key->pubKey.key, key->pubKey.keyLength, - key->algorithmParms.parms.rsa.exponent, - key->algorithmParms.parms.rsa.exponentSize); - - // Fill boundData's accessory information - boundData.ver = TPM_STRUCT_VER_1_1; - boundData.payload = TPM_PT_BIND; - boundData.payloadData = (BYTE*)in; - - //marshall the bound data object - ptr = pack_TPM_BOUND_DATA(ptr, &boundData, ilen); - - // Encrypt the data - TPMTRYRETURN(tpmrsa_pub_encrypt_oaep(&rsa, - ctr_drbg_random, &vtpm_globals.ctr_drbg, - ptr - plain, - plain, - out)); + UINT32 req_len = *bytesRequested; + TPM_BEGIN_CMD(TPM_ORD_GetRandom); + PACK_IN(UINT32, req_len); -abort_egress: - tpmrsa_free(&rsa); - return status; + TPM_XMIT_REQ(); + + UNPACK_OUT(UINT32, bytesRequested); + if (*bytesRequested > req_len) + return TPM_FAIL; + UNPACK_OUT(BUFFER, randomBytes, *bytesRequested); + TPM_END(); +abort_egress: + return status; } -TPM_RESULT TPM_UnBind( - TPM_KEY_HANDLE keyHandle, // in - UINT32 ilen, //in - const BYTE* in, // - UINT32* olen, // - BYTE* out, //out - const TPM_AUTHDATA* usage_auth, - TPM_AUTH_SESSION* auth //in, out - ) + +TPM_RESULT TPM_ReadPubek( + TPM_PUBKEY* pubEK //out + ) { - TPM_BEGIN(TPM_TAG_RQU_AUTH1_COMMAND, TPM_ORD_UnBind); - TPM_AUTH_BEGIN(); + TPM_DIGEST antiReplay; + BYTE* kptr = NULL; + BYTE digest[TPM_DIGEST_SIZE]; + sha1_context ctx; - TPM_AUTH_HASH(); + vtpmmgr_rand(antiReplay.digest, TPM_DIGEST_SIZE); - ptr = pack_TPM_KEY_HANDLE(ptr, keyHandle); + TPM_BEGIN_CMD(TPM_ORD_ReadPubek); - TPM_AUTH_SKIP(); + PACK_IN(TPM_DIGEST, &antiReplay); - ptr = pack_UINT32(ptr, ilen); - ptr = pack_BUFFER(ptr, in, ilen); + TPM_XMIT_REQ(); - TPM_AUTH_HASH(); + //unpack and allocate the key + kptr = OUT_PTR; + UNPACK_OUT(TPM_PUBKEY, pubEK, UNPACK_ALLOC); - TPM_AUTH1_GEN(usage_auth, auth); - TPM_TRANSMIT(); - TPM_UNPACK_VERIFY(); - TPM_AUTH_VERIFY_BEGIN(); + //Verify the checksum + sha1_starts(&ctx); + sha1_update(&ctx, kptr, OUT_PTR - kptr); + sha1_update(&ctx, antiReplay.digest, TPM_DIGEST_SIZE); + sha1_finish(&ctx, digest); - ptr = unpack_UINT32(ptr, olen); - if(*olen > ilen) { - vtpmlogerror(VTPM_LOG_TPM, "Output length < input length!\n"); - status = TPM_IOERROR; - goto abort_egress; - } - ptr = unpack_BUFFER(ptr, out, *olen); + UNPACK_OUT(TPM_DIGEST, &antiReplay); - TPM_AUTH_HASH(); + TPM_END(); - TPM_AUTH1_VERIFY(usage_auth, auth); + //ptr points to the checksum computed by TPM + if(memcmp(digest, antiReplay.digest, TPM_DIGEST_SIZE)) { + vtpmlogerror(VTPM_LOG_TPM, "TPM_ReadPubek: Checksum returned by TPM was invalid!\n"); + status = TPM_FAIL; + goto abort_egress; + } + goto egress; abort_egress: + if(kptr != NULL) { //If we unpacked the pubEK, we have to free it + free_TPM_PUBKEY(pubEK); + } egress: - TPM_AUTH_ERR_CHECK(auth); - return status; + return status; } -TPM_RESULT TPM_CreateWrapKey( - TPM_KEY_HANDLE hWrappingKey, // in - const TPM_AUTHDATA* osapSharedSecret, - const TPM_AUTHDATA* dataUsageAuth, //in - const TPM_AUTHDATA* dataMigrationAuth, //in - TPM_KEY* key, //in, out - TPM_AUTH_SESSION* pAuth) // in, out +TPM_RESULT TPM_PCR_Read(UINT32 pcr, TPM_DIGEST *value) { - int keyAlloced = 0; - TPM_BEGIN(TPM_TAG_RQU_AUTH1_COMMAND, TPM_ORD_CreateWrapKey); - TPM_AUTH_BEGIN(); - - TPM_AUTH_HASH(); - - ptr = pack_TPM_KEY_HANDLE(ptr, hWrappingKey); - - TPM_AUTH_SKIP(); - - //Encrypted auths - xorEncrypt(osapSharedSecret, &pAuth->NonceEven, - dataUsageAuth, ptr, - dataMigrationAuth, ptr + sizeof(TPM_ENCAUTH)); - ptr += sizeof(TPM_ENCAUTH) * 2; - - ptr = pack_TPM_KEY(ptr, key); - - TPM_AUTH_HASH(); - - TPM_AUTH1_GEN(osapSharedSecret, pAuth); - TPM_TRANSMIT(); - TPM_UNPACK_VERIFY(); - TPM_AUTH_VERIFY_BEGIN(); - - keyAlloced = 1; - ptr = unpack_TPM_KEY(ptr, key, UNPACK_ALLOC); - - TPM_AUTH_HASH(); - - TPM_AUTH1_VERIFY(osapSharedSecret, pAuth); - - goto egress; + TPM_BEGIN_CMD(TPM_ORD_PcrRead); + PACK_IN(UINT32, pcr); + TPM_XMIT_REQ(); + UNPACK_OUT(TPM_DIGEST, value); + TPM_END(); abort_egress: - if(keyAlloced) { - free_TPM_KEY(key); - } -egress: - TPM_AUTH_ERR_CHECK(pAuth); - return status; + return status; } -TPM_RESULT TPM_LoadKey( - TPM_KEY_HANDLE parentHandle, // - const TPM_KEY* key, //in - TPM_HANDLE* keyHandle, // out - const TPM_AUTHDATA* usage_auth, - TPM_AUTH_SESSION* auth) +TPM_RESULT TPM_SaveState(void) { - TPM_BEGIN(TPM_TAG_RQU_AUTH1_COMMAND, TPM_ORD_LoadKey); - TPM_AUTH_BEGIN(); - - TPM_AUTH_HASH(); - - ptr = pack_TPM_KEY_HANDLE(ptr, parentHandle); - - TPM_AUTH_SKIP(); - - ptr = pack_TPM_KEY(ptr, key); - - TPM_AUTH_HASH(); - - TPM_AUTH1_GEN(usage_auth, auth); - TPM_TRANSMIT(); - TPM_UNPACK_VERIFY(); - TPM_AUTH_VERIFY_BEGIN(); - - ptr = unpack_UINT32(ptr, keyHandle); - - TPM_AUTH_HASH(); - - TPM_AUTH1_VERIFY(usage_auth, auth); - - vtpmloginfo(VTPM_LOG_TPM, "Key Handle: 0x%x opened by TPM_LoadKey\n", *keyHandle); + TPM_BEGIN_CMD(TPM_ORD_SaveState); + TPM_XMIT_REQ(); + TPM_END(); abort_egress: - TPM_AUTH_ERR_CHECK(auth); - return status; + return status; } -TPM_RESULT TPM_EvictKey( TPM_KEY_HANDLE hKey) // in +TPM_RESULT TPM_GetCapability( + TPM_CAPABILITY_AREA capArea, + UINT32 subCapSize, + const BYTE* subCap, + UINT32* respSize, + BYTE** resp) { - if(hKey == 0) { - return TPM_SUCCESS; - } + TPM_BEGIN_CMD(TPM_ORD_GetCapability); - TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_EvictKey); + PACK_IN(TPM_CAPABILITY_AREA, capArea); + PACK_IN(UINT32, subCapSize); + PACK_IN(BUFFER, subCap, subCapSize); - ptr = pack_TPM_KEY_HANDLE(ptr, hKey); + TPM_XMIT_REQ(); - TPM_TRANSMIT(); - TPM_UNPACK_VERIFY(); + UNPACK_OUT(UINT32, respSize); + UNPACK_OUT(PTR, resp, *respSize, UNPACK_ALLOC); - vtpmloginfo(VTPM_LOG_TPM, "Key handle: 0x%x closed by TPM_EvictKey\n", hKey); + TPM_END(); abort_egress: - return status; + return status; } -TPM_RESULT TPM_FlushSpecific(TPM_HANDLE handle, - TPM_RESOURCE_TYPE rt) { - if(handle == 0) { - return TPM_SUCCESS; - } - - TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_FlushSpecific); - - ptr = pack_TPM_HANDLE(ptr, handle); - ptr = pack_TPM_RESOURCE_TYPE(ptr, rt); - - TPM_TRANSMIT(); - TPM_UNPACK_VERIFY(); +TPM_RESULT TPM_CreateEndorsementKeyPair( + const TPM_KEY_PARMS* keyInfo, + TPM_PUBKEY* pubEK) +{ + BYTE* kptr = NULL; + sha1_context ctx; + TPM_DIGEST checksum; + TPM_DIGEST hash; + TPM_NONCE antiReplay; + TPM_BEGIN_CMD(TPM_ORD_CreateEndorsementKeyPair); -abort_egress: - return status; -} + //Make anti replay nonce + vtpmmgr_rand(antiReplay.nonce, sizeof(antiReplay.nonce)); -TPM_RESULT TPM_GetRandom( UINT32* bytesRequested, // in, out - BYTE* randomBytes) // out -{ - TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_GetRandom); + PACK_IN(TPM_NONCE, &antiReplay); + PACK_IN(TPM_KEY_PARMS, keyInfo); - // check input params - if (bytesRequested == NULL || randomBytes == NULL){ - return TPM_BAD_PARAMETER; - } + TPM_XMIT_REQ(); - ptr = pack_UINT32(ptr, *bytesRequested); + kptr = OUT_PTR; + UNPACK_OUT(TPM_PUBKEY, pubEK, UNPACK_ALLOC); - TPM_TRANSMIT(); - TPM_UNPACK_VERIFY(); + /* Hash the pub key blob */ + sha1_starts(&ctx); + sha1_update(&ctx, kptr, OUT_PTR - kptr); + sha1_update(&ctx, antiReplay.nonce, sizeof(antiReplay.nonce)); + sha1_finish(&ctx, hash.digest); - ptr = unpack_UINT32(ptr, bytesRequested); - ptr = unpack_BUFFER(ptr, randomBytes, *bytesRequested); + UNPACK_OUT(TPM_DIGEST, &checksum); -abort_egress: - return status; -} + TPM_END(); + if (memcmp(checksum.digest, hash.digest, TPM_DIGEST_SIZE)) { + vtpmloginfo(VTPM_LOG_VTPM, "TPM_CreateEndorsementKey: Checkum verification failed!\n"); + status = TPM_FAIL; + goto abort_egress; + } -TPM_RESULT TPM_ReadPubek( - TPM_PUBKEY* pubEK //out - ) -{ - BYTE* antiReplay = NULL; - BYTE* kptr = NULL; - BYTE digest[TPM_DIGEST_SIZE]; - sha1_context ctx; - - TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_ReadPubek); - - //antiReplay nonce - vtpmmgr_rand(ptr, TPM_DIGEST_SIZE); - antiReplay = ptr; - ptr += TPM_DIGEST_SIZE; - - TPM_TRANSMIT(); - TPM_UNPACK_VERIFY(); - - //unpack and allocate the key - kptr = ptr; - ptr = unpack_TPM_PUBKEY(ptr, pubEK, UNPACK_ALLOC); - - //Verify the checksum - sha1_starts(&ctx); - sha1_update(&ctx, kptr, ptr - kptr); - sha1_update(&ctx, antiReplay, TPM_DIGEST_SIZE); - sha1_finish(&ctx, digest); - - //ptr points to the checksum computed by TPM - if(memcmp(digest, ptr, TPM_DIGEST_SIZE)) { - vtpmlogerror(VTPM_LOG_TPM, "TPM_ReadPubek: Checksum returned by TPM was invalid!\n"); - status = TPM_FAIL; - goto abort_egress; - } - - goto egress; + goto egress; abort_egress: - if(kptr != NULL) { //If we unpacked the pubEK, we have to free it - free_TPM_PUBKEY(pubEK); - } + if(kptr) { + free_TPM_PUBKEY(pubEK); + } egress: - return status; + return status; } - -TPM_RESULT TPM_SaveState(void) +TPM_RESULT TPM_MakeIdentity( + const TPM_AUTHDATA* identityAuth, // in + const TPM_AUTHDATA* privCADigest, // in + const TPM_KEY* kinfo, // in + const TPM_AUTHDATA* srk_auth, // in + const TPM_AUTHDATA* own_auth, // in + TPM_AUTH_SESSION* srkAuth, // in,out + TPM_AUTH_SESSION* ownAuth, // in,out + TPM_KEY* key, // out + UINT32* identityBindingSize, // out + BYTE** identityBinding) // out { - TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_SaveState); + TPM_BEGIN_CMD(TPM_ORD_MakeIdentity); + TPM_HASH_IN_BEGIN; - TPM_TRANSMIT(); - TPM_UNPACK_VERIFY(); + xorEncrypt(own_auth, &ownAuth->NonceEven, identityAuth, IN_PTR, NULL, NULL); + in_pos += sizeof(TPM_ENCAUTH); -abort_egress: - return status; -} - -TPM_RESULT TPM_GetCapability( - TPM_CAPABILITY_AREA capArea, - UINT32 subCapSize, - const BYTE* subCap, - UINT32* respSize, - BYTE** resp) -{ - TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_GetCapability); + PACK_IN(TPM_AUTHDATA, privCADigest); + PACK_IN(TPM_KEY, kinfo); - ptr = pack_TPM_CAPABILITY_AREA(ptr, capArea); - ptr = pack_UINT32(ptr, subCapSize); - ptr = pack_BUFFER(ptr, subCap, subCapSize); + TPM_XMIT_AUTH2(srk_auth, srkAuth, own_auth, ownAuth); - TPM_TRANSMIT(); - TPM_UNPACK_VERIFY(); + UNPACK_OUT(TPM_KEY, key, UNPACK_ALLOC); + UNPACK_OUT(UINT32, identityBindingSize); + UNPACK_OUT(PTR, identityBinding, *identityBindingSize, UNPACK_ALLOC); - ptr = unpack_UINT32(ptr, respSize); - ptr = unpack_ALLOC(ptr, resp, *respSize); + TPM_END_AUTH2(srk_auth, srkAuth, own_auth, ownAuth); abort_egress: - return status; + TPM_AUTH_ERR_CHECK(srkAuth); + TPM_AUTH_ERR_CHECK(ownAuth); + return status; } -TPM_RESULT TPM_CreateEndorsementKeyPair( - const TPM_KEY_PARMS* keyInfo, - TPM_PUBKEY* pubEK) +TPM_RESULT TPM_ActivateIdentity( + TPM_KEY_HANDLE aikHandle, // in + BYTE* blob, // in + UINT32 blobSize, // in + const TPM_AUTHDATA* aik_auth, // in + const TPM_AUTHDATA* owner_auth, // in + TPM_AUTH_SESSION* aikAuth, // in,out + TPM_AUTH_SESSION* ownAuth, // in,out + TPM_SYMMETRIC_KEY* symKey) // out { - BYTE* kptr = NULL; - sha1_context ctx; - TPM_DIGEST checksum; - TPM_DIGEST hash; - TPM_NONCE antiReplay; - TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_CreateEndorsementKeyPair); + TPM_BEGIN_CMD(TPM_ORD_ActivateIdentity); + PACK_IN(TPM_KEY_HANDLE, aikHandle); + TPM_HASH_IN_BEGIN; + PACK_IN(UINT32, blobSize); + PACK_IN(BUFFER, blob, blobSize); + + TPM_XMIT_AUTH2(aik_auth, aikAuth, owner_auth, ownAuth); - //Make anti replay nonce - vtpmmgr_rand(antiReplay.nonce, sizeof(antiReplay.nonce)); + UNPACK_OUT(TPM_SYMMETRIC_KEY, symKey, UNPACK_ALLOC); - ptr = pack_TPM_NONCE(ptr, &antiReplay); - ptr = pack_TPM_KEY_PARMS(ptr, keyInfo); + TPM_END_AUTH2(aik_auth, aikAuth, owner_auth, ownAuth); - TPM_TRANSMIT(); - TPM_UNPACK_VERIFY(); - - sha1_starts(&ctx); +abort_egress: + TPM_AUTH_ERR_CHECK(aikAuth); + TPM_AUTH_ERR_CHECK(ownAuth); + return status; +} - kptr = ptr; - ptr = unpack_TPM_PUBKEY(ptr, pubEK, UNPACK_ALLOC); +TPM_RESULT TPM_Quote( + TPM_KEY_HANDLE keyh, // in + const TPM_NONCE* data, // in + const TPM_PCR_SELECTION *pcrSelect, // in + const TPM_AUTHDATA* auth, // in + TPM_AUTH_SESSION* oiap, // in,out + TPM_PCR_COMPOSITE *pcrs, // out + BYTE** sig, // out + UINT32* sigSize) // out +{ + TPM_BEGIN_CMD(TPM_ORD_Quote); + PACK_IN(TPM_KEY_HANDLE, keyh); + TPM_HASH_IN_BEGIN; + PACK_IN(TPM_NONCE, data); + PACK_IN(TPM_PCR_SELECTION, pcrSelect); - /* Hash the pub key blob */ - sha1_update(&ctx, kptr, ptr - kptr); - ptr = unpack_TPM_DIGEST(ptr, &checksum); + TPM_XMIT_AUTH1(auth, oiap); - sha1_update(&ctx, antiReplay.nonce, sizeof(antiReplay.nonce)); + UNPACK_OUT(TPM_PCR_COMPOSITE, pcrs, UNPACK_ALLOC); + UNPACK_OUT(UINT32, sigSize); + UNPACK_OUT(PTR, sig, *sigSize, UNPACK_ALLOC); - sha1_finish(&ctx, hash.digest); - if(memcmp(checksum.digest, hash.digest, TPM_DIGEST_SIZE)) { - vtpmloginfo(VTPM_LOG_VTPM, "TPM_CreateEndorsementKey: Checkum verification failed!\n"); - status = TPM_FAIL; - goto abort_egress; - } + TPM_END_AUTH1(auth, oiap); - goto egress; abort_egress: - if(kptr) { - free_TPM_PUBKEY(pubEK); - } -egress: - return status; + TPM_AUTH_ERR_CHECK(oiap); + return status; } TPM_RESULT TPM_TransmitData( - BYTE* in, - UINT32 insize, - BYTE* out, - UINT32* outsize) { - TPM_RESULT status = TPM_SUCCESS; - - UINT32 i; - vtpmloginfo(VTPM_LOG_TXDATA, "Sending buffer = 0x"); - for(i = 0 ; i < insize ; i++) - vtpmloginfomore(VTPM_LOG_TXDATA, "%2.2x ", in[i]); - - vtpmloginfomore(VTPM_LOG_TXDATA, "\n"); - - ssize_t size = 0; - - // send the request - size = write (vtpm_globals.tpm_fd, in, insize); - if (size < 0) { - vtpmlogerror(VTPM_LOG_TXDATA, "write() failed : %s\n", strerror(errno)); - ERRORDIE (TPM_IOERROR); - } - else if ((UINT32) size < insize) { - vtpmlogerror(VTPM_LOG_TXDATA, "Wrote %d instead of %d bytes!\n", (int) size, insize); - ERRORDIE (TPM_IOERROR); - } - - // read the response - size = read (vtpm_globals.tpm_fd, out, *outsize); - if (size < 0) { - vtpmlogerror(VTPM_LOG_TXDATA, "read() failed : %s\n", strerror(errno)); - ERRORDIE (TPM_IOERROR); - } - - vtpmloginfo(VTPM_LOG_TXDATA, "Receiving buffer = 0x"); - for(i = 0 ; i < size ; i++) - vtpmloginfomore(VTPM_LOG_TXDATA, "%2.2x ", out[i]); - - vtpmloginfomore(VTPM_LOG_TXDATA, "\n"); - - *outsize = size; - goto egress; + BYTE* in, + UINT32 insize, + BYTE* out, + UINT32* outsize) { + TPM_RESULT status = TPM_SUCCESS; + + UINT32 i; + vtpmloginfo(VTPM_LOG_TXDATA, "Sending buffer = 0x"); + for(i = 0 ; i < insize ; i++) + vtpmloginfomore(VTPM_LOG_TXDATA, "%2.2x ", in[i]); + + vtpmloginfomore(VTPM_LOG_TXDATA, "\n"); + + ssize_t size = 0; + + // send the request + size = write (vtpm_globals.tpm_fd, in, insize); + if (size < 0) { + vtpmlogerror(VTPM_LOG_TXDATA, "write() failed : %s\n", strerror(errno)); + ERRORDIE (TPM_IOERROR); + } + else if ((UINT32) size < insize) { + vtpmlogerror(VTPM_LOG_TXDATA, "Wrote %d instead of %d bytes!\n", (int) size, insize); + ERRORDIE (TPM_IOERROR); + } + + // read the response + size = read (vtpm_globals.tpm_fd, out, *outsize); + if (size < 0) { + vtpmlogerror(VTPM_LOG_TXDATA, "read() failed : %s\n", strerror(errno)); + ERRORDIE (TPM_IOERROR); + } + + vtpmloginfo(VTPM_LOG_TXDATA, "Receiving buffer = 0x"); + for(i = 0 ; i < size ; i++) + vtpmloginfomore(VTPM_LOG_TXDATA, "%2.2x ", out[i]); + + vtpmloginfomore(VTPM_LOG_TXDATA, "\n"); + + *outsize = size; + goto egress; abort_egress: egress: - return status; + return status; } diff --git a/stubdom/vtpmmgr/tpm.h b/stubdom/vtpmmgr/tpm.h index 304e145..2161976 100644 --- a/stubdom/vtpmmgr/tpm.h +++ b/stubdom/vtpmmgr/tpm.h @@ -80,22 +80,11 @@ TPM_RESULT TPM_FlushSpecific ( TPM_HANDLE handle, // in // TPM Mandatory TPM_RESULT TPM_Extend ( TPM_PCRINDEX pcrNum, // in - TPM_DIGEST inDigest, // in + TPM_DIGEST* inDigest, // in TPM_PCRVALUE* outDigest // out ); -TPM_RESULT TPM_PcrRead ( TPM_PCRINDEX pcrNum, // in - TPM_PCRVALUE* outDigest // out - ); - -TPM_RESULT TPM_Quote ( TCS_KEY_HANDLE keyHandle, // in - TPM_NONCE antiReplay, // in - UINT32* PcrDataSize, // in, out - BYTE** PcrData, // in, out - TPM_AUTH_SESSION* privAuth, // in, out - UINT32* sigSize, // out - BYTE** sig // out - ); +TPM_RESULT TPM_Reset(TPM_PCR_SELECTION *sel); TPM_RESULT TPM_Seal( TCS_KEY_HANDLE keyHandle, // in @@ -120,41 +109,6 @@ TPM_RESULT TPM_Unseal ( TPM_AUTH_SESSION* dataAuth // in, out ); -TPM_RESULT TPM_DirWriteAuth ( TPM_DIRINDEX dirIndex, // in - TPM_DIRVALUE newContents, // in - TPM_AUTH_SESSION* ownerAuth // in, out - ); - -TPM_RESULT TPM_DirRead ( TPM_DIRINDEX dirIndex, // in - TPM_DIRVALUE* dirValue // out - ); - -TPM_RESULT TPM_Bind( - const TPM_KEY* key, //in - const BYTE* in, //in - UINT32 ilen, //in - BYTE* out //out, must be at least cipher block size - ); - -TPM_RESULT TPM_UnBind ( - TCS_KEY_HANDLE keyHandle, // in - UINT32 ilen, //in - const BYTE* in, // - UINT32* outDataSize, // out - BYTE* outData, //out - const TPM_AUTHDATA* usage_auth, - TPM_AUTH_SESSION* auth //in, out - ); - -TPM_RESULT TPM_CreateWrapKey ( - TCS_KEY_HANDLE hWrappingKey, // in - const TPM_AUTHDATA* osapSharedSecret, - const TPM_AUTHDATA* dataUsageAuth, //in - const TPM_AUTHDATA* dataMigrationAuth, //in - TPM_KEY* key, //in - TPM_AUTH_SESSION* pAuth // in, out - ); - TPM_RESULT TPM_LoadKey ( TPM_KEY_HANDLE parentHandle, // const TPM_KEY* key, //in @@ -163,35 +117,14 @@ TPM_RESULT TPM_LoadKey ( TPM_AUTH_SESSION* auth ); -TPM_RESULT TPM_GetPubKey ( TCS_KEY_HANDLE hKey, // in - TPM_AUTH_SESSION* pAuth, // in, out - UINT32* pcPubKeySize, // out - BYTE** prgbPubKey // out - ); - -TPM_RESULT TPM_EvictKey ( TCS_KEY_HANDLE hKey // in - ); - TPM_RESULT TPM_FlushSpecific(TPM_HANDLE handle, //in TPM_RESOURCE_TYPE rt //in ); -TPM_RESULT TPM_Sign ( TCS_KEY_HANDLE keyHandle, // in - UINT32 areaToSignSize, // in - BYTE* areaToSign, // in - TPM_AUTH_SESSION* privAuth, // in, out - UINT32* sigSize, // out - BYTE** sig // out - ); - TPM_RESULT TPM_GetRandom ( UINT32* bytesRequested, // in, out BYTE* randomBytes // out ); -TPM_RESULT TPM_StirRandom ( UINT32 inDataSize, // in - BYTE* inData // in - ); - TPM_RESULT TPM_ReadPubek ( TPM_PUBKEY* pubEK //out ); @@ -203,12 +136,45 @@ TPM_RESULT TPM_GetCapability( UINT32* respSize, BYTE** resp); +TPM_RESULT TPM_PCR_Read(UINT32 pcr, TPM_DIGEST *value); TPM_RESULT TPM_SaveState(void); TPM_RESULT TPM_CreateEndorsementKeyPair( const TPM_KEY_PARMS* keyInfo, TPM_PUBKEY* pubEK); +TPM_RESULT TPM_MakeIdentity( + const TPM_AUTHDATA* identityAuth, // in + const TPM_AUTHDATA* privCADigest, // in + const TPM_KEY* kinfo, // in + const TPM_AUTHDATA* srk_auth, // in + const TPM_AUTHDATA* owner_auth, // in + TPM_AUTH_SESSION* srkAuth, // in,out + TPM_AUTH_SESSION* ownAuth, // in,out + TPM_KEY* key, // out + UINT32* identityBindingSize, // out + BYTE** identityBinding); // out + +TPM_RESULT TPM_ActivateIdentity( + TPM_KEY_HANDLE aikHandle, // in + BYTE* blob, // in + UINT32 blobSize, // in + const TPM_AUTHDATA* aik_auth, // in + const TPM_AUTHDATA* owner_auth, // in + TPM_AUTH_SESSION* aikAuth, // in,out + TPM_AUTH_SESSION* ownAuth, // in,out + TPM_SYMMETRIC_KEY* symKey); // out + +TPM_RESULT TPM_Quote( + TPM_KEY_HANDLE keyh, // in + const TPM_NONCE* data, // in + const TPM_PCR_SELECTION *pcrSelect, // in + const TPM_AUTHDATA* auth, // in + TPM_AUTH_SESSION* oiap, // in,out + TPM_PCR_COMPOSITE *pcrs, // out + BYTE** sig, // out + UINT32* sigSize); // out + TPM_RESULT TPM_TransmitData( BYTE* in, UINT32 insize, diff --git a/stubdom/vtpmmgr/tpmrsa.c b/stubdom/vtpmmgr/tpmrsa.c index 56094e7..2a2fa36 100644 --- a/stubdom/vtpmmgr/tpmrsa.c +++ b/stubdom/vtpmmgr/tpmrsa.c @@ -89,6 +89,31 @@ cleanup: return TPM_SUCCESS; } +static const unsigned char rsa_der_header[] = { + 0x00, 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03, 0x02, 0x1a, 0x05, 0x00, 0x04, 0x14, +}; + +TPM_RESULT tpmrsa_sigcheck(tpmrsa_context *ctx, const unsigned char *input, const unsigned char *sha1) +{ + unsigned char *tmp = alloca(ctx->len); + TPM_RESULT rv; + int i; + rv = tpmrsa_public(ctx, input, tmp); + if (rv) + return rv; + if (tmp[0] != 0 || tmp[1] != 1) + return TPM_INAPPROPRIATE_SIG; + for(i=2; i < 220; i++) { + if (tmp[i] != 0xFF) + return TPM_INAPPROPRIATE_SIG; + } + if (memcmp(tmp + 220, rsa_der_header, sizeof(rsa_der_header))) + return TPM_INAPPROPRIATE_SIG; + if (memcmp(tmp + 236, sha1, 20)) + return TPM_DECRYPT_ERROR; + return TPM_SUCCESS; +} + static void mgf_mask( unsigned char *dst, int dlen, unsigned char *src, int slen) { unsigned char mask[HASH_LEN]; diff --git a/stubdom/vtpmmgr/tpmrsa.h b/stubdom/vtpmmgr/tpmrsa.h index 59579e7..31e5a8b 100644 --- a/stubdom/vtpmmgr/tpmrsa.h +++ b/stubdom/vtpmmgr/tpmrsa.h @@ -51,6 +51,9 @@ void tpmrsa_set_pubkey(tpmrsa_context* ctx, const unsigned char* exponent, int explen); +/* Check an RSA signature */ +TPM_RESULT tpmrsa_sigcheck(tpmrsa_context *ctx, const unsigned char *input, const unsigned char *sha1); + /* Do rsa public crypto */ TPM_RESULT tpmrsa_pub_encrypt_oaep( tpmrsa_context *ctx, int (*f_rng)(void *, unsigned char *, size_t), diff --git a/stubdom/vtpmmgr/vtpm_cmd_handler.c b/stubdom/vtpmmgr/vtpm_cmd_handler.c index f82a2a9..f2869b6 100644 --- a/stubdom/vtpmmgr/vtpm_cmd_handler.c +++ b/stubdom/vtpmmgr/vtpm_cmd_handler.c @@ -37,116 +37,806 @@ #include #include #include +#include +#include +#include #include "marshal.h" #include "log.h" -#include "vtpm_storage.h" +#include "vtpm_disk.h" #include "vtpmmgr.h" #include "tpm.h" +#include "tpmrsa.h" #include "tcg.h" +#include "mgmt_authority.h" +#include "disk_crypto.h" -static TPM_RESULT vtpmmgr_SaveHashKey( - const uuid_t uuid, - tpmcmd_t* tpmcmd) +static void gen_random_uuid(uuid_t uuid) { - TPM_RESULT status = TPM_SUCCESS; + do_random(uuid, 16); + // make the 128-bit random number a valid UUID (122 bits remain) + uuid[6] = 0x40 | (uuid[6] & 0x0F); + uuid[8] = 0x80 | (uuid[8] & 0x3F); +} + +static TPM_RESULT find_vtpm_khash(int domid, struct tpm_opaque *opq) +{ + // TODO getting the build hashes requires a domain builder to report them + memset(opq->kern_hash, 0, sizeof(opq->kern_hash)); + return TPM_SUCCESS; +} + +static TPM_RESULT find_vtpm_verified(int domid, struct tpm_opaque *opq) +{ + TPM_RESULT rc; + int i; + if (opq->vtpm) + return TPM_SUCCESS; + + rc = find_vtpm(&opq->group, &opq->vtpm, *opq->uuid); + if (rc) + return TPM_BAD_PARAMETER; - if(tpmcmd->req_len != VTPM_COMMAND_HEADER_SIZE + HASHKEYSZ) { - vtpmlogerror(VTPM_LOG_VTPM, "VTPM_ORD_SAVEHASHKEY hashkey too short!\n"); - status = TPM_BAD_PARAMETER; - goto abort_egress; - } + if (opq->vtpm->flags & VTPM_FLAG_OPEN) { + printk("Attempted to open vTPM twice!\n"); + opq->vtpm = NULL; + opq->group = NULL; + return TPM_DISABLED; + } - /* Do the command */ - TPMTRYRETURN(vtpm_storage_save_hashkey(uuid, tpmcmd->req + VTPM_COMMAND_HEADER_SIZE)); + rc = find_vtpm_khash(domid, opq); + if (rc) + return rc; + + for(i=0; i < be32_native(opq->group->seal_bits.nr_kerns); i++) { + if (!memcmp(opq->group->seal_bits.kernels[i].bits, opq->kern_hash, 20)) { + opq->vtpm->flags |= VTPM_FLAG_OPEN; + return TPM_SUCCESS; + } + } + printk("Unauthorized vTPM kernel image used!\n"); + return TPM_DISABLED; +} + +static TPM_RESULT vtpmmgr_SaveHashKey(struct tpm_opaque *opq, tpmcmd_t* tpmcmd) +{ + TPM_RESULT status = TPM_SUCCESS; + int rc = 0; + + size_t bufsize = tpmcmd->req_len - VTPM_COMMAND_HEADER_SIZE; + const void *buf = tpmcmd->req + VTPM_COMMAND_HEADER_SIZE; + + if (bufsize < 52) { + vtpmlogerror(VTPM_LOG_VTPM, "VTPM_ORD_SAVEHASHKEY hashkey too short!\n"); + status = TPM_BAD_PARAMETER; + goto abort_egress; + } + if (bufsize > 64) { + vtpmlogerror(VTPM_LOG_VTPM, "VTPM_ORD_SAVEHASHKEY hashkey too long!\n"); + status = TPM_BAD_PARAMETER; + goto abort_egress; + } + + vtpmloginfo(VTPM_LOG_VTPM, "vtpmmgr_SaveHashKey\n"); + status = find_vtpm_verified(tpmcmd->domid, opq); + + // auto-create vTPMs in group0 when saving a new UUID + // TODO restrict to certain UUIDs (such as all-zero) + // this is not done yet to simplify use of the TPM Manager + if (status == TPM_BAD_PARAMETER) { + opq->group = g_mgr->groups[0].v; + rc = create_vtpm(opq->group, &opq->vtpm, *opq->uuid); + if (rc) { + status = TPM_BAD_PARAMETER; + goto abort_egress; + } + if (opq->group->nr_vtpms == 1) + opq->vtpm->flags = VTPM_FLAG_ADMIN; + printk("SaveHashKey with unknown UUID="UUID_FMT" - creating in auth0 (f=%d)\n", + UUID_BYTES((*opq->uuid)), opq->vtpm->flags); + status = TPM_SUCCESS; + } + if (status) + goto abort_egress; + + memcpy(opq->vtpm->data, buf, bufsize); + memset(opq->vtpm->data + bufsize, 0, 64 - bufsize); + + vtpm_sync(opq->group, opq->vtpm); abort_egress: - pack_TPM_RSP_HEADER(tpmcmd->resp, - VTPM_TAG_RSP, VTPM_COMMAND_HEADER_SIZE, status); - tpmcmd->resp_len = VTPM_COMMAND_HEADER_SIZE; + pack_TPM_RSP_HEADER(tpmcmd->resp, VTPM_TAG_RSP, VTPM_COMMAND_HEADER_SIZE, status); + tpmcmd->resp_len = VTPM_COMMAND_HEADER_SIZE; - return status; + return status; } -static TPM_RESULT vtpmmgr_LoadHashKey( - const uuid_t uuid, - tpmcmd_t* tpmcmd) { - TPM_RESULT status = TPM_SUCCESS; +static TPM_RESULT vtpmmgr_LoadHashKey(struct tpm_opaque *opq, tpmcmd_t* tpmcmd) +{ + TPM_RESULT status = TPM_SUCCESS; + int i; + uint8_t *buf = tpmcmd->resp + VTPM_COMMAND_HEADER_SIZE; + + vtpmloginfo(VTPM_LOG_VTPM, "vtpmmgr_LoadHashKey\n"); + tpmcmd->resp_len = VTPM_COMMAND_HEADER_SIZE; - tpmcmd->resp_len = VTPM_COMMAND_HEADER_SIZE; + status = find_vtpm_verified(tpmcmd->domid, opq); + if (status) + goto abort_egress; - TPMTRYRETURN(vtpm_storage_load_hashkey(uuid, tpmcmd->resp + VTPM_COMMAND_HEADER_SIZE)); + memcpy(buf, opq->vtpm->data, 64); - tpmcmd->resp_len += HASHKEYSZ; + for(i=52; i < 64; i++) { + if (buf[i]) { + tpmcmd->resp_len += 64; + goto abort_egress; + } + } + tpmcmd->resp_len += 52; abort_egress: - pack_TPM_RSP_HEADER(tpmcmd->resp, - VTPM_TAG_RSP, tpmcmd->resp_len, status); + pack_TPM_RSP_HEADER(tpmcmd->resp, VTPM_TAG_RSP, tpmcmd->resp_len, status); + + return status; +} + +#define CMD_BEGIN \ + TPM_RESULT status = TPM_SUCCESS; \ + uint32_t in_pos = VTPM_COMMAND_HEADER_SIZE; \ + tpmcmd->resp_len = VTPM_COMMAND_HEADER_SIZE; \ + vtpmloginfo(VTPM_LOG_TPM, "%s\n", __func__); + +#define CMD_END \ + abort_egress: \ + if (status) \ + tpmcmd->resp_len = VTPM_COMMAND_HEADER_SIZE; \ + pack_TPM_RSP_HEADER(tpmcmd->resp, VTPM_TAG_RSP, tpmcmd->resp_len, status); \ + return status + +#define UNPACK_IN(type, item...) do { \ + status = unpack3_ ## type (tpmcmd->req, &in_pos, tpmcmd->req_len, item); \ + if (status) { \ + status = TPM_BAD_PARAMETER; \ + goto abort_egress; \ + } \ +} while (0) + +#define UNPACK_GROUP(group) do { \ + uint32_t group_idx; \ + UNPACK_IN(UINT32, &group_idx); \ + if (group_idx >= g_mgr->nr_groups) { \ + status = TPM_BADINDEX; \ + goto abort_egress; \ + } \ + group = g_mgr->groups[group_idx].v; \ + if (!group) { \ + status = TPM_AUTHFAIL; \ + goto abort_egress; \ + } \ +} while (0) + +#define UNPACK_DONE() do { \ + if (in_pos != tpmcmd->req_len) { \ + status = TPM_BAD_PARAMETER; \ + goto abort_egress; \ + } \ +} while (0) + +#define PACK_OUT(type, item...) do { \ + UINT32 isize = sizeof_ ## type(item); \ + if (isize + tpmcmd->resp_len > TCPA_MAX_BUFFER_LENGTH) { \ + status = TPM_SIZE; \ + goto abort_egress; \ + } \ + pack_ ## type (tpmcmd->resp + tpmcmd->resp_len, item); \ + tpmcmd->resp_len += isize; \ +} while (0) + +#define PACK_BUF ((void*)(tpmcmd->resp + tpmcmd->resp_len)) + +static TPM_RESULT vtpmmgr_GetBootHash(struct tpm_opaque *opq, tpmcmd_t* tpmcmd) +{ + CMD_BEGIN; + UNPACK_DONE(); + + PACK_OUT(BUFFER, opq->kern_hash, 20); + + CMD_END; +} + +static TPM_RESULT vtpmmgr_GetQuote(struct tpm_opaque *opq, tpmcmd_t* tpmcmd) +{ + CMD_BEGIN; + int i; + void *ibuf; + uint32_t pcr_size; + TPM_PCR_SELECTION sel; + + UNPACK_IN(VPTR, &ibuf, 20, UNPACK_ALIAS); + UNPACK_IN(TPM_PCR_SELECTION, &sel, UNPACK_ALIAS); + UNPACK_DONE(); + + if (!opq->vtpm) { + status = TPM_BAD_PARAMETER; + goto abort_egress; + } + + printk("ibuf: "); + for (i=0; i < 20; i++) + printk("%02x", ((uint8_t*)ibuf)[i]); + printk("\n"); + + status = vtpm_do_quote(opq->group, *opq->uuid, opq->kern_hash, ibuf, &sel, PACK_BUF + 256, &pcr_size, PACK_BUF); + if (status) + goto abort_egress; + tpmcmd->resp_len += 256 + pcr_size; + + CMD_END; +} + +static TPM_RESULT vtpmmgr_GroupList(tpmcmd_t* tpmcmd) +{ + CMD_BEGIN; + UNPACK_DONE(); + PACK_OUT(UINT32, g_mgr->nr_groups); + CMD_END; +} + +static TPM_RESULT vtpmmgr_GroupNew(tpmcmd_t* tpmcmd) +{ + void *privCADigest; + BYTE *pubkey; + struct mem_group *group; + uint32_t group_idx; + CMD_BEGIN; + + UNPACK_IN(VPTR, &privCADigest, 20, UNPACK_ALIAS); + UNPACK_IN(PTR, &pubkey, 256, UNPACK_ALIAS); + UNPACK_DONE(); + + group = vtpm_new_group(privCADigest); + if (!group) { + status = TPM_FAIL; + goto abort_egress; + } + + memcpy(group->id_data.saa_pubkey, pubkey, 256); + + PACK_OUT(BUFFER, group->id_data.uuid, 16); + PACK_OUT(BUFFER, group->id_data.tpm_aik_public, 256); + PACK_OUT(BUFFER, group->details.recovery_data, 256); + + memset(group->details.recovery_data, 0, 256); + + group->details.sequence = native_be64(g_mgr->sequence); + + if (group != g_mgr->groups[0].v) { + group_idx = g_mgr->nr_groups; + g_mgr->nr_groups++; + g_mgr->groups = realloc(g_mgr->groups, g_mgr->nr_groups*sizeof(struct mem_group_hdr)); + memset(&g_mgr->groups[group_idx], 0, sizeof(g_mgr->groups[0])); + g_mgr->groups[group_idx].v = group; + } + + vtpm_sync_group(group, SEQ_UPDATE); + CMD_END; +} + +static TPM_RESULT vtpmmgr_GroupDel(tpmcmd_t* tpmcmd) +{ + CMD_BEGIN; + struct mem_group *group; + uint32_t group_idx, nr_mov; + + UNPACK_IN(UINT32, &group_idx); + UNPACK_DONE(); + + if (group_idx > g_mgr->nr_groups) { + status = TPM_BADINDEX; + goto abort_egress; + } + group = g_mgr->groups[group_idx].v; + + if (group) { + int i, j; + for (i = 0; i < group->nr_pages; i++) { + for (j = 0; j < group->data[i].size; j++) { + if (group->data[i].vtpms[j]->flags & VTPM_FLAG_OPEN) { + status = TPM_FAIL; + goto abort_egress; + } + } + } + + for (i = 0; i < group->nr_pages; i++) { + for (j = 0; j < group->data[i].size; j++) { + free(group->data[i].vtpms[j]); + } + } + free(group->data); + free(group->seals); + free(group); + } + + g_mgr->nr_groups--; + nr_mov = g_mgr->nr_groups - group_idx; + memmove(&g_mgr->groups[group_idx], &g_mgr->groups[group_idx + 1], nr_mov * sizeof(g_mgr->groups[0])); + + vtpm_sync_disk(g_mgr, CTR_UPDATE); + + CMD_END; +} + +static int pack_cfg_list(void* buf, struct mem_group *group) +{ + int i; + void *bstart = buf; + memcpy(buf, &group->details.cfg_seq, 8); buf += 8; + buf = pack_UINT32(buf, group->nr_seals); + for(i=0; i < group->nr_seals; i++) { + memcpy(buf, &group->seals[i].digest_release, 20); + buf += 20; + } + memcpy(buf, &group->seal_bits.nr_kerns, 4); buf += 4; + memcpy(buf, &group->seal_bits.kernels, 20 * be32_native(group->seal_bits.nr_kerns)); + return buf - bstart + 20 * be32_native(group->seal_bits.nr_kerns); +} + +static TPM_RESULT vtpmmgr_GroupShow(tpmcmd_t* tpmcmd) +{ + CMD_BEGIN; + struct mem_group *group; + + UNPACK_GROUP(group); + UNPACK_DONE(); + + // TODO show is read-only access, need to hit disk if group is NULL + + PACK_OUT(BUFFER, group->id_data.uuid, 16); + PACK_OUT(BUFFER, group->id_data.saa_pubkey, 256); + tpmcmd->resp_len += pack_cfg_list(PACK_BUF, group); + + CMD_END; +} + +static TPM_RESULT vtpmmgr_GroupActivate(tpmcmd_t* tpmcmd) +{ + CMD_BEGIN; + struct mem_group *group; + uint32_t blobSize; + void *blob; + + UNPACK_GROUP(group); + UNPACK_IN(UINT32, &blobSize); + UNPACK_IN(VPTR, &blob, blobSize, UNPACK_ALIAS); + UNPACK_DONE(); + + status = group_do_activate(group, blob, blobSize, tpmcmd->resp, &tpmcmd->resp_len); + + CMD_END; +} + +/* 2048-bit MODP Group from RFC3526: + * 2^2048 - 2^1984 - 1 + 2^64 * { [2^1918 pi] + 124476 } + * mpi objects use little endian word ordering + */ +static t_uint Pp[256 / sizeof(t_uint)] = { + 0xFFFFFFFFFFFFFFFFUL, 0x15728E5A8AACAA68UL, 0x15D2261898FA0510UL, + 0x3995497CEA956AE5UL, 0xDE2BCBF695581718UL, 0xB5C55DF06F4C52C9UL, + 0x9B2783A2EC07A28FUL, 0xE39E772C180E8603UL, 0x32905E462E36CE3BUL, + 0xF1746C08CA18217CUL, 0x670C354E4ABC9804UL, 0x9ED529077096966DUL, + 0x1C62F356208552BBUL, 0x83655D23DCA3AD96UL, 0x69163FA8FD24CF5FUL, + 0x98DA48361C55D39AUL, 0xC2007CB8A163BF05UL, 0x49286651ECE45B3DUL, + 0xAE9F24117C4B1FE6UL, 0xEE386BFB5A899FA5UL, 0x0BFF5CB6F406B7EDUL, + 0xF44C42E9A637ED6BUL, 0xE485B576625E7EC6UL, 0x4FE1356D6D51C245UL, + 0x302B0A6DF25F1437UL, 0xEF9519B3CD3A431BUL, 0x514A08798E3404DDUL, + 0x020BBEA63B139B22UL, 0x29024E088A67CC74UL, 0xC4C6628B80DC1CD1UL, + 0xC90FDAA22168C234UL, 0xFFFFFFFFFFFFFFFFUL, +}; +static t_uint Gp[] = { 2 }; + +static void tm_dhkx_gen(void* dhkx1, void* dhkx2, void* out) +{ + mpi GX = { 0 }, GY = { 0 }, K = { 0 }, RP = { 0 }; + + t_uint Xp[256 / sizeof(t_uint)]; + mpi X = { + .s = 1, + .n = sizeof(Xp)/sizeof(Xp[0]), + .p = Xp + }; + mpi P = { + .s = 1, + .n = sizeof(Pp)/sizeof(Pp[0]), + .p = Pp, + }; + mpi G = { + .s = 1, + .n = 1, + .p = Gp, + }; + + do_random(Xp, sizeof(Xp)); + while (Xp[31] == 0 || Xp[31] == -1UL) + do_random(Xp + 31, sizeof(Xp[31])); + + mpi_exp_mod(&GX, &G, &X, &P, &RP); + mpi_write_binary(&GX, dhkx2, 256); + mpi_free(&GX); + + mpi_read_binary(&GY, dhkx1, 256); + mpi_exp_mod(&K, &GY, &X, &P, &RP); + mpi_free(&RP); + mpi_free(&GY); + + mpi_write_binary(&K, (void*)Xp, 256); + mpi_free(&K); + sha2((void*)Xp, 256, out, 0); +} + +static void xor2_256b(void *xv, const void* yv) +{ + int i; + uint64_t *x = xv; + const uint64_t *y = yv; + for(i=0; i < 4; i++) + x[i] ^= y[i]; +} + +static TPM_RESULT vtpmmgr_GroupRegister(tpmcmd_t* tpmcmd) +{ + CMD_BEGIN; + struct mem_group *group = NULL; + tpmrsa_context saa_rsa = TPMRSA_CTX_INIT; + struct tpm_authdata digest; + sha1_context ctx; + TPM_PCR_SELECTION sel; + void *dhkx1, *dhkx2, *gk, *sig; + + UNPACK_GROUP(group); + UNPACK_IN(VPTR, &dhkx1, 256, UNPACK_ALIAS); + UNPACK_IN(VPTR, &sig, 256, UNPACK_ALIAS); + UNPACK_IN(TPM_PCR_SELECTION, &sel, UNPACK_ALIAS); + UNPACK_DONE(); + + /* Only generating this quote during the same boot that this group was + * created in allows the quote to prove that the group key has never + * been available outside a configuration approved by its SAA. + */ + if (!(group->flags & MEM_GROUP_FLAG_FIRSTBOOT)) { + status = TPM_FAIL; + goto abort_egress; + } + + sha1(dhkx1, 256, digest.bits); + tpmrsa_set_pubkey(&saa_rsa, group->id_data.saa_pubkey, 256, 0, 0); + if (tpmrsa_sigcheck(&saa_rsa, sig, digest.bits)) + status = TPM_FAIL; + tpmrsa_free(&saa_rsa); + if (status) + goto abort_egress; + + dhkx2 = PACK_BUF; + tpmcmd->resp_len += 256; + gk = PACK_BUF; + tpmcmd->resp_len += 32; + + tm_dhkx_gen(dhkx1, dhkx2, gk); + xor2_256b(gk, &group->group_key); + + sha1_starts(&ctx); + sha1_update(&ctx, (void*)"REGR", 4); + sha1_update(&ctx, dhkx1, 256); + sha1_update(&ctx, dhkx2, 256 + 32); + sha1_finish(&ctx, digest.bits); + + status = vtpm_do_quote(group, NULL, NULL, &digest, &sel, NULL, NULL, PACK_BUF); + tpmcmd->resp_len += 256; + + CMD_END; +} + +static TPM_RESULT vtpmmgr_GroupUpdate(tpmcmd_t* tpmcmd) +{ + CMD_BEGIN; + struct mem_group *group; + int i; + int hstart; + uint32_t nr_kerns, nr_seals; + uint64_t old_seq, new_seq; + struct mem_seal *seals = NULL; + tpmrsa_context saa_rsa = TPMRSA_CTX_INIT; + unsigned char digest[20]; + TPM_RESULT rc; + void *sig, *seal_bits, *kern_bits; + + UNPACK_GROUP(group); + UNPACK_IN(VPTR, &sig, 256, UNPACK_ALIAS); + + // Hash starts here + hstart = in_pos; + + new_seq = be64_native(*(be64_t*)(tpmcmd->req + in_pos)); + old_seq = be64_native(group->details.cfg_seq); + in_pos += 8; + if (old_seq > new_seq) { + status = TPM_FAIL; + goto abort_egress; + } + + UNPACK_IN(UINT32, &nr_seals); + UNPACK_IN(VPTR, &seal_bits, nr_seals * 20, UNPACK_ALIAS); + + UNPACK_IN(UINT32, &nr_kerns); + UNPACK_IN(VPTR, &kern_bits, nr_kerns * 20, UNPACK_ALIAS); + + // TODO handle saving larger lists on disk + if (nr_seals > NR_SEALS_PER_GROUP) { + status = TPM_SIZE; + goto abort_egress; + } + + if (nr_kerns > NR_KERNS_PER_GROUP) { + status = TPM_SIZE; + goto abort_egress; + } + + sha1(tpmcmd->req + hstart, in_pos - hstart, digest); - return status; + seals = calloc(nr_seals, sizeof(seals[0])); + + for(i=0; i < nr_seals; i++) { + TPM_PCR_SELECTION sel; + UNPACK_IN(TPM_PCR_SELECTION, &sel, UNPACK_ALIAS); + memcpy(&seals[i].digest_release, seal_bits, 20); + seal_bits += 20; + if (sel.sizeOfSelect > 4) { + status = TPM_BAD_PARAMETER; + goto abort_egress; + } + seals[i].pcr_selection = native_le32(0); + memcpy(&seals[i].pcr_selection, sel.pcrSelect, sel.sizeOfSelect); + } + + UNPACK_DONE(); + + tpmrsa_set_pubkey(&saa_rsa, group->id_data.saa_pubkey, 256, 0, 0); + rc = tpmrsa_sigcheck(&saa_rsa, sig, digest); + tpmrsa_free(&saa_rsa); + if (rc) { + printk("sigcheck failed: %d\n", rc); + status = rc; + goto abort_egress; + } + + // Commit + free(group->seals); + + memcpy(&group->seal_bits.kernels, kern_bits, 20 * nr_kerns); + group->details.cfg_seq = native_be64(new_seq); + group->nr_seals = nr_seals; + group->seals = seals; + group->seal_bits.nr_kerns = native_be32(nr_kerns); + + seals = NULL; + + group->flags &= ~MEM_GROUP_FLAG_SEAL_VALID; + if (group == g_mgr->groups[0].v) + g_mgr->root_seals_valid = 0; + + // TODO use GROUP_KEY_UPDATE or MGR_KEY_UPDATE here? + // only required if this update was to address a potential key leak + vtpm_sync_group(group, SEQ_UPDATE); + + abort_egress: + free(seals); + + pack_TPM_RSP_HEADER(tpmcmd->resp, VTPM_TAG_RSP, tpmcmd->resp_len, status); + return status; +} + +static TPM_RESULT vtpmmgr_VtpmList(tpmcmd_t* tpmcmd) +{ + CMD_BEGIN; + struct mem_group *group; + uint32_t vtpm_offset; + int i, j; + + UNPACK_GROUP(group); + UNPACK_IN(UINT32, &vtpm_offset); + + PACK_OUT(UINT32, group->nr_vtpms); + if (vtpm_offset > group->nr_vtpms) + goto egress; + + for(i=0; i < group->nr_pages; i++) { + struct mem_vtpm_page *pg = &group->data[i]; + for(j=0; j < pg->size; j++) { + if (vtpm_offset) { + // TODO a proper seek would be far faster + vtpm_offset--; + continue; + } + memcpy(PACK_BUF, pg->vtpms[j]->uuid, 16); + tpmcmd->resp_len += 16; + if (tpmcmd->resp_len + 16 > TCPA_MAX_BUFFER_LENGTH) + goto egress; + } + } + + egress: + CMD_END; +} + +static TPM_RESULT vtpmmgr_VtpmNew(tpmcmd_t* tpmcmd) +{ + CMD_BEGIN; + struct mem_group *group; + struct mem_vtpm *vtpm; + uuid_t newuuid; + int rc; + + UNPACK_GROUP(group); + + // XXX allow non-random UUIDs for testing + if (tpmcmd->req_len == 14 + 16) + UNPACK_IN(BUFFER, newuuid, 16); + else + gen_random_uuid(newuuid); + UNPACK_DONE(); + + rc = create_vtpm(group, &vtpm, newuuid); + if (rc) { + status = TPM_FAIL; + goto abort_egress; + } + memset(vtpm->data, 0, 64); + vtpm_sync(group, vtpm); + + PACK_OUT(BUFFER, newuuid, 16); + CMD_END; } +static TPM_RESULT vtpmmgr_VtpmDel(tpmcmd_t* tpmcmd) +{ + CMD_BEGIN; + uuid_t uuid; + struct mem_group *group; + struct mem_vtpm *vtpm; + int rc; + + UNPACK_IN(BUFFER, uuid, 16); + UNPACK_DONE(); + rc = find_vtpm(&group, &vtpm, uuid); + if (rc) { + status = TPM_FAIL; + goto abort_egress; + } + + if (vtpm->flags & VTPM_FLAG_OPEN) { + status = TPM_FAIL; + goto abort_egress; + } + + delete_vtpm(group, vtpm); + + CMD_END; +} + +static int vtpmmgr_permcheck(struct tpm_opaque *opq) +{ + if (!opq->vtpm) + return 1; + if (opq->vtpm->flags & VTPM_FLAG_ADMIN) + return 0; + return 1; +} TPM_RESULT vtpmmgr_handle_cmd( - const uuid_t uuid, - tpmcmd_t* tpmcmd) -{ - TPM_RESULT status = TPM_SUCCESS; - TPM_TAG tag; - UINT32 size; - TPM_COMMAND_CODE ord; - - unpack_TPM_RQU_HEADER(tpmcmd->req, - &tag, &size, &ord); - - /* Handle the command now */ - switch(tag) { - case VTPM_TAG_REQ: - //This is a vTPM command - switch(ord) { - case VTPM_ORD_SAVEHASHKEY: - return vtpmmgr_SaveHashKey(uuid, tpmcmd); - case VTPM_ORD_LOADHASHKEY: - return vtpmmgr_LoadHashKey(uuid, tpmcmd); - default: - vtpmlogerror(VTPM_LOG_VTPM, "Invalid vTPM Ordinal %" PRIu32 "\n", ord); - status = TPM_BAD_ORDINAL; - } - break; - case TPM_TAG_RQU_COMMAND: - case TPM_TAG_RQU_AUTH1_COMMAND: - case TPM_TAG_RQU_AUTH2_COMMAND: - //This is a TPM passthrough command - switch(ord) { - case TPM_ORD_GetRandom: - vtpmloginfo(VTPM_LOG_VTPM, "Passthrough: TPM_GetRandom\n"); - break; - case TPM_ORD_PcrRead: - vtpmloginfo(VTPM_LOG_VTPM, "Passthrough: TPM_PcrRead\n"); - break; - default: - vtpmlogerror(VTPM_LOG_VTPM, "TPM Disallowed Passthrough ord=%" PRIu32 "\n", ord); - status = TPM_DISABLED_CMD; - goto abort_egress; - } - - size = TCPA_MAX_BUFFER_LENGTH; - TPMTRYRETURN(TPM_TransmitData(tpmcmd->req, tpmcmd->req_len, tpmcmd->resp, &size)); - tpmcmd->resp_len = size; - - unpack_TPM_RESULT(tpmcmd->resp + sizeof(TPM_TAG) + sizeof(UINT32), &status); - return status; - - break; - default: - vtpmlogerror(VTPM_LOG_VTPM, "Invalid tag=%" PRIu16 "\n", tag); - status = TPM_BADTAG; - } + struct tpm_opaque *opaque, + tpmcmd_t* tpmcmd) +{ + TPM_RESULT status = TPM_SUCCESS; + TPM_TAG tag; + UINT32 size; + TPM_COMMAND_CODE ord; + + unpack_TPM_RQU_HEADER(tpmcmd->req, + &tag, &size, &ord); + + /* Handle the command now */ + switch(tag) { + case VTPM_TAG_REQ: + // This is a vTPM command + switch(ord) { + case VTPM_ORD_SAVEHASHKEY: + return vtpmmgr_SaveHashKey(opaque, tpmcmd); + case VTPM_ORD_LOADHASHKEY: + return vtpmmgr_LoadHashKey(opaque, tpmcmd); + case VTPM_ORD_GET_BOOT_HASH: + return vtpmmgr_GetBootHash(opaque, tpmcmd); + case VTPM_ORD_GET_QUOTE: + return vtpmmgr_GetQuote(opaque, tpmcmd); + default: + vtpmlogerror(VTPM_LOG_VTPM, "Invalid vTPM Ordinal %" PRIu32 "\n", ord); + status = TPM_BAD_ORDINAL; + } + break; + case VTPM_TAG_REQ2: + // This is a management command + if (vtpmmgr_permcheck(opaque)) { + status = TPM_AUTHFAIL; + vtpmlogerror(VTPM_LOG_VTPM, "Rejected attempt to use management command from client\n"); + break; + } + switch (ord) { + case VTPM_ORD_GROUP_LIST: + return vtpmmgr_GroupList(tpmcmd); + case VTPM_ORD_GROUP_NEW: + return vtpmmgr_GroupNew(tpmcmd); + case VTPM_ORD_GROUP_DEL: + return vtpmmgr_GroupDel(tpmcmd); + case VTPM_ORD_GROUP_ACTIVATE: + return vtpmmgr_GroupActivate(tpmcmd); + case VTPM_ORD_GROUP_REGISTER: + return vtpmmgr_GroupRegister(tpmcmd); + case VTPM_ORD_GROUP_UPDATE: + return vtpmmgr_GroupUpdate(tpmcmd); + case VTPM_ORD_GROUP_SHOW: + return vtpmmgr_GroupShow(tpmcmd); + case VTPM_ORD_VTPM_LIST: + return vtpmmgr_VtpmList(tpmcmd); + case VTPM_ORD_VTPM_NEW: + return vtpmmgr_VtpmNew(tpmcmd); + case VTPM_ORD_VTPM_DEL: + return vtpmmgr_VtpmDel(tpmcmd); + default: + vtpmlogerror(VTPM_LOG_VTPM, "Invalid TM Ordinal %" PRIu32 "\n", ord); + status = TPM_BAD_ORDINAL; + } + break; + case TPM_TAG_RQU_COMMAND: + case TPM_TAG_RQU_AUTH1_COMMAND: + case TPM_TAG_RQU_AUTH2_COMMAND: + //This is a TPM passthrough command + switch(ord) { + case TPM_ORD_GetRandom: + vtpmloginfo(VTPM_LOG_VTPM, "Passthrough: TPM_GetRandom\n"); + break; + case TPM_ORD_PcrRead: + vtpmloginfo(VTPM_LOG_VTPM, "Passthrough: TPM_PcrRead\n"); + // Quotes also need to be restricted to hide PCR values + break; + case TPM_ORD_Extend: + // TODO allow to certain clients? A malicious client + // could scramble PCRs and make future quotes invalid. + if (vtpmmgr_permcheck(opaque)) { + vtpmlogerror(VTPM_LOG_VTPM, "Disallowed TPM_Extend\n"); + status = TPM_DISABLED_CMD; + goto abort_egress; + } else { + vtpmloginfo(VTPM_LOG_VTPM, "Passthrough: TPM_Extend\n"); + } + break; + default: + vtpmlogerror(VTPM_LOG_VTPM, "TPM Disallowed Passthrough ord=%" PRIu32 "\n", ord); + status = TPM_DISABLED_CMD; + goto abort_egress; + } + + size = TCPA_MAX_BUFFER_LENGTH; + TPMTRYRETURN(TPM_TransmitData(tpmcmd->req, tpmcmd->req_len, tpmcmd->resp, &size)); + tpmcmd->resp_len = size; + + return TPM_SUCCESS; + default: + vtpmlogerror(VTPM_LOG_VTPM, "Invalid tag=%" PRIu16 "\n", tag); + status = TPM_BADTAG; + } abort_egress: - tpmcmd->resp_len = VTPM_COMMAND_HEADER_SIZE; - pack_TPM_RSP_HEADER(tpmcmd->resp, - tag + 3, tpmcmd->resp_len, status); + tpmcmd->resp_len = VTPM_COMMAND_HEADER_SIZE; + pack_TPM_RSP_HEADER(tpmcmd->resp, tag + 3, tpmcmd->resp_len, status); - return status; + return status; } diff --git a/stubdom/vtpmmgr/vtpm_disk.c b/stubdom/vtpmmgr/vtpm_disk.c new file mode 100644 index 0000000..a01633a --- /dev/null +++ b/stubdom/vtpmmgr/vtpm_disk.c @@ -0,0 +1,237 @@ +#include +#include +#include +#include +#include +#include +#include +#include + +#include "vtpm_manager.h" +#include "log.h" +#include "uuid.h" + +#include "vtpmmgr.h" +#include "vtpm_disk.h" +#include "disk_crypto.h" +#include "disk_format.h" +#include "disk_io.h" +#include "disk_tpm.h" + +struct mem_tpm_mgr *g_mgr; + +int vtpm_sync_disk(struct mem_tpm_mgr *mgr, int depth) +{ + int old_active_root = mgr->active_root; + int new_active_root = !old_active_root; + int rc = 0; + struct tpm_authdata prev; + struct mem_group *group0 = mgr->groups[0].v; + + // don't bother writing if we will never be able to read + if (!group0 || !group0->nr_seals) + return 0; + + mgr->sequence++; + mgr->active_root = new_active_root; + + switch (depth) { + case CTR_UPDATE: + { + uint32_t ctr = be32_native(mgr->counter_value); + mgr->counter_value = native_be32(ctr + 1); + break; + } + case MGR_KEY_UPDATE: + { + int i; + mgr->root_seals_valid = 0; + do_random(&mgr->tm_key, 16); + aes_setup(&mgr->tm_key_e, &mgr->tm_key); + do_random(&mgr->nv_key, 16); + for(i=0; i < mgr->nr_groups; i++) { + abort(); // TODO use raw re-encryption to handle unopened groups + } + break; + } + case CTR_AUTH_UPDATE: + mgr->root_seals_valid = 0; + memcpy(&prev, &mgr->counter_auth, 20); + do_random(&mgr->counter_auth, 20); + break; + case NV_AUTH_UPDATE: + mgr->root_seals_valid = 0; + memcpy(&prev, &mgr->nvram_auth, 20); + do_random(&mgr->nvram_auth, 20); + break; + } + + disk_write_all(mgr); + + switch (depth) { + case SEQ_UPDATE: + break; + + case CTR_UPDATE: + rc = TPM_disk_incr_counter(mgr->counter_index, mgr->counter_auth); + if (rc) { + uint32_t ctr = be32_native(mgr->counter_value); + mgr->counter_value = native_be32(ctr - 1); + mgr->active_root = old_active_root; + return rc; + } + break; + + case MGR_KEY_UPDATE: + rc = TPM_disk_nvwrite(&mgr->nv_key, 16, mgr->nvram_slot, mgr->nvram_auth); + if (rc) + abort(); + break; + + case CTR_AUTH_UPDATE: + rc = TPM_disk_change_counter(mgr->counter_index, prev, mgr->counter_auth); + if (rc) + abort(); + break; + + case NV_AUTH_UPDATE: + rc = TPM_disk_nvchange(mgr->nvram_slot, prev, mgr->nvram_auth); + if (rc) + abort(); + break; + } + + return rc; +} + +static struct mem_group_hdr* find_mem_group_hdr(struct mem_tpm_mgr *mgr, struct mem_group *group) +{ + int i; + for (i = 0; i < mgr->nr_groups; i++) { + struct mem_group_hdr *hdr = mgr->groups + i; + if (hdr->v == group) + return hdr; + } + return NULL; +} + +int vtpm_sync_group(struct mem_group *group, int depth) +{ + struct mem_group_hdr* hdr = find_mem_group_hdr(g_mgr, group); + uint64_t seq = be64_native(group->details.sequence); + + if (!hdr) + abort(); + + hdr->disk_loc.value = 0; + group->details.sequence = native_be64(1 + seq); + + if (depth == GROUP_KEY_UPDATE) { + int i; + do_random(&group->group_key, 16); + do_random(&group->rollback_mac_key, 16); + group->flags &= ~MEM_GROUP_FLAG_SEAL_VALID; + for (i = 0; i < group->nr_pages; i++) + group->data[i].disk_loc.value = 0; + depth = CTR_UPDATE; + } + + return vtpm_sync_disk(g_mgr, depth); +} + +static struct mem_vtpm_page* find_mem_vtpm_page(struct mem_group *group, struct mem_vtpm *vtpm) +{ + int pgidx = vtpm->index_in_parent / VTPMS_PER_SECTOR; + return group->data + pgidx; +} + +int vtpm_sync(struct mem_group *group, struct mem_vtpm *vtpm) +{ + struct mem_vtpm_page *pg = find_mem_vtpm_page(group, vtpm); + if (!pg) + return 1; + pg->disk_loc.value = 0; + return vtpm_sync_group(group, SEQ_UPDATE); +} + +/************************************************************************/ + +int create_vtpm(struct mem_group *group, struct mem_vtpm **vtpmp, const uuid_t uuid) +{ + int pgidx = group->nr_vtpms / VTPMS_PER_SECTOR; + int vtidx = group->nr_vtpms % VTPMS_PER_SECTOR; + struct mem_vtpm *vtpm = calloc(1, sizeof(*vtpm)); + + struct mem_vtpm_page *page = group->data + pgidx; + if (pgidx >= group->nr_pages) { + if (pgidx != group->nr_pages) + abort(); // nr_vtpms inconsistent with nr_pages + group->nr_pages++; + group->data = realloc(group->data, group->nr_pages * sizeof(*page)); + page = group->data + pgidx; + memset(page, 0, sizeof(*page)); + } + if (page->size != vtidx) + abort(); // nr_vtpms inconsistent with page->size + page->size++; + + page->vtpms[vtidx] = vtpm; + vtpm->index_in_parent = group->nr_vtpms; + vtpm->flags = 0; + + group->nr_vtpms++; + + memcpy(vtpm->uuid, uuid, 16); + *vtpmp = vtpm; + return 0; +} + +int delete_vtpm(struct mem_group *group, struct mem_vtpm *vtpm) +{ + struct mem_vtpm_page *pg = find_mem_vtpm_page(group, vtpm); + struct mem_vtpm_page *last_pg = group->data + (group->nr_pages - 1); + struct mem_vtpm *last = last_pg->vtpms[last_pg->size - 1]; + int vtidx = vtpm->index_in_parent % VTPMS_PER_SECTOR; + + if (vtpm->flags & VTPM_FLAG_OPEN) + return 1; + + last->index_in_parent = vtpm->index_in_parent; + pg->vtpms[vtidx] = last; + pg->disk_loc.value = 0; + + last_pg->vtpms[last_pg->size - 1] = NULL; + last_pg->disk_loc.value = 0; + last_pg->size--; + + if (last_pg->size == 0) + group->nr_pages--; + group->nr_vtpms--; + free(vtpm); + return 0; +} + +int find_vtpm(struct mem_group **groupp, struct mem_vtpm **vtpmp, const uuid_t uuid) +{ + struct mem_group *group; + int i, j, k; + + for (i = 0; i < g_mgr->nr_groups; i++) { + group = g_mgr->groups[i].v; + if (!group) + continue; + for (j = 0; j < group->nr_pages; j++) { + struct mem_vtpm_page *pg = &group->data[j]; + for (k = 0; k < pg->size; k++) { + struct mem_vtpm *vt = pg->vtpms[k]; + if (!memcmp(uuid, vt->uuid, 16)) { + *groupp = group; + *vtpmp = vt; + return 0; + } + } + } + } + + return 1; +} diff --git a/stubdom/vtpmmgr/vtpm_disk.h b/stubdom/vtpmmgr/vtpm_disk.h new file mode 100644 index 0000000..a567265 --- /dev/null +++ b/stubdom/vtpmmgr/vtpm_disk.h @@ -0,0 +1,233 @@ +#ifndef __VTPM_DISK_H +#define __VTPM_DISK_H + +#include "uuid.h" +#include +#include "endian_int.h" + +/* Type for disk sector indexes */ +typedef be32_t sector_t; + +/* A TPM authdata entry (160 random bits) */ +struct tpm_authdata { + uint8_t bits[20]; +}; + +/* 160-bit hash (SHA-1) */ +struct hash160 { + uint8_t bits[20]; +}; + +/* 256-bit hash (either SHA256 or SHA512-256) */ +struct hash256 { + uint8_t bits[32]; +}; + +/* 128-bit MAC (AES-128 CMAC) */ +struct mac128 { + uint8_t bits[16]; +}; + +struct key128 { + uint8_t bits[16]; +}; + +/********************************************************************/ + +/** + * Unique identifying information for a vTPM group. Once a group has been + * created, this data will be constant. + * + * This structure a component of struct disk_group_sector, stored directly. + */ +struct group_id_data { + uuid_t uuid; + uint8_t saa_pubkey[256]; + uint8_t tpm_aik_public[256]; + uint8_t tpm_aik_edata[256]; + struct hash256 rollback_pubkey_hash; +}; + +/** + * Details of a vTPM group that change during normal operation. + * + * This structure a component of struct disk_group_sector, stored directly. + */ +struct group_details { + be64_t sequence; + be64_t cfg_seq; + be64_t flags; +#define FLAG_ROLLBACK_DETECTED 1 + + /* Seal(recovery_seal, PCR16 = H(RECOVERY_KEY)) */ + uint8_t recovery_data[256]; +}; + +/** + * The required input to TPM_Unseal to obtain key data + * + * This structure a component of several disk structures, stored directly. + */ +struct disk_seal_entry { + le32_t pcr_selection; + struct hash160 digest_at_seal; + struct hash160 digest_release; + uint8_t sealed_data[256]; +}; + +/** + * A vTPM group's configuration list and sealed key data + * + * This structure a component of struct disk_group_sector, stored directly. + */ +struct disk_group_boot_config_list { +#define NR_SEALS_PER_GROUP 5 + be32_t nr_cfgs; + struct disk_seal_entry entry[NR_SEALS_PER_GROUP]; +#define NR_KERNS_PER_GROUP 16 + be32_t nr_kerns; + struct hash160 kernels[NR_KERNS_PER_GROUP]; + + /* TODO support overflow of either nr_cfgs or nr_kerns */ + struct hash256 next; +}; + +/********************************************************************/ + +#define VTPM_FLAG_ADMIN 1 +#define VTPM_FLAG_DISK_MASK (0xFFFF) +#define VTPM_FLAG_OPEN (1UL<<31) + +/** + * A single vTPM's in-memory data. Do not free if the open flag is set. + */ +struct mem_vtpm { + uuid_t uuid; + uint8_t data[64]; + uint32_t flags; + uint32_t index_in_parent; +}; + +/** + * Shortened form of struct disk_seal_entry + */ +struct mem_seal { + le32_t pcr_selection; + struct hash160 digest_release; +}; + +/** + * Maximum number of vTPMs in one sector on the disk. + * + * 20 + 64 = 84 bytes per vTPM; 32 bytes overhead from IVs + * 48*84 + 32 = 4064 bytes + */ +#define VTPMS_PER_SECTOR 48 + +/** + * Decrypted and unpacked version of struct disk_vtpm_sector + */ +struct mem_vtpm_page { + struct hash256 disk_hash; + sector_t disk_loc; + int size; + + struct mem_vtpm *vtpms[VTPMS_PER_SECTOR]; +}; + +/** + * In-memory representation of an open vTPM group + */ +struct mem_group { + struct group_id_data id_data; + struct group_details details; + + /* Obtained from sealed data */ + struct tpm_authdata aik_authdata; + struct key128 group_key; + struct key128 rollback_mac_key; + + int nr_vtpms; + int nr_pages; + struct mem_vtpm_page *data; + + int flags; +#define MEM_GROUP_FLAG_SEAL_VALID 1 +#define MEM_GROUP_FLAG_FIRSTBOOT 2 + int nr_seals; + struct mem_seal *seals; + + sector_t seal_next_loc; + struct disk_group_boot_config_list seal_bits; +}; + +/** + * In-memory representation of a vTPM group (open or not) + */ +struct mem_group_hdr { + sector_t disk_loc; + struct hash256 disk_hash; + + int disk_nr_inuse; + sector_t *disk_inuse; + + struct mem_group *v; +}; + +/** + * In-memory representation of the TPM Manager's permanent data + */ +struct mem_tpm_mgr { + struct key128 tm_key; + aes_context tm_key_e; + struct key128 nv_key; + uuid_t uuid; + + be32_t nvram_slot; + struct tpm_authdata nvram_auth; + be32_t counter_index; + struct tpm_authdata counter_auth; + be32_t counter_value; + + uint64_t sequence; + + int active_root; + + int nr_groups; + struct mem_group_hdr *groups; + + int root_seals_valid; +}; + +int vtpm_storage_init(void); +int vtpm_load_disk(void); +int vtpm_new_disk(void); + +enum vtpm_sync_depth { + SEQ_UPDATE, /* Just the soft sequence number */ + CTR_UPDATE, /* Sequence and TPM counter */ + GROUP_KEY_UPDATE, /* Group key (and TPM counter) */ + MGR_KEY_UPDATE, /* Manager key */ + CTR_AUTH_UPDATE, /* TPM counter authdata */ + NV_AUTH_UPDATE /* NVRAM authdata */ +}; + +/* + * For a full manager key flush, use this ordering of writes: + * MGR_KEY_UPDATE + * CTR_AUTH_UPDATE + * NV_AUTH_UPDATE + * CTR_UPDATE or GROUP_KEY_UPDATE + */ + +extern struct mem_tpm_mgr *g_mgr; + +int vtpm_sync_disk(struct mem_tpm_mgr *mgr, int depth); +int vtpm_sync_group(struct mem_group *group, int depth); +int vtpm_sync(struct mem_group *group, struct mem_vtpm *vtpm); + +int create_vtpm(struct mem_group *group, struct mem_vtpm **vtpmp, const uuid_t uuid); +int delete_vtpm(struct mem_group *group, struct mem_vtpm *vtpm); +int find_vtpm(struct mem_group **groupp, struct mem_vtpm **vtpmp, const uuid_t uuid); + +#endif diff --git a/stubdom/vtpmmgr/vtpm_manager.h b/stubdom/vtpmmgr/vtpm_manager.h index a2bbcca..156c2ce 100644 --- a/stubdom/vtpmmgr/vtpm_manager.h +++ b/stubdom/vtpmmgr/vtpm_manager.h @@ -38,7 +38,9 @@ #define VTPM_MANAGER_H #define VTPM_TAG_REQ 0x01c1 +#define VTPM_TAG_REQ2 0x01c2 #define VTPM_TAG_RSP 0x01c4 +#define VTPM_TAG_RSP2 0x01c5 #define COMMAND_BUFFER_SIZE 4096 // Header size @@ -46,12 +48,391 @@ //************************ Command Codes **************************** #define VTPM_ORD_BASE 0x0000 -#define VTPM_PRIV_MASK 0x01000000 // Priviledged VTPM Command -#define VTPM_PRIV_BASE (VTPM_ORD_BASE | VTPM_PRIV_MASK) +#define TPM_VENDOR_COMMAND 0x02000000 // TPM Main, part 2, section 17. +#define VTPM_PRIV_BASE (VTPM_ORD_BASE | TPM_VENDOR_COMMAND) + +/* + * Non-priviledged VTPM Commands: + * + * The PCRs available to read, extend, or quote may be limited to a given vTPM + * based on a local security policy (this is not yet implemented). + * + * vTPMs may request the following commands which will be forwarded directly to + * the physical TPM: + * + * TPM_ORD_GetRandom + * TPM_ORD_PcrRead + * TPM_ORD_Extend + * + * In addition, the following command are available to all vTPMs: + */ + +/** + * Store a persistent key blob to TPM Manager storage + * Input: + * TPM_TAG tag VTPM_TAG_REQ + * UINT32 paramSize total size + * UINT32 ordinal VTPM_ORD_SAVEHASHKEY + * BYTE[] keyblob 52 or 64 bytes of key data + * Output: + * TPM_TAG tag VTPM_TAG_RSP + * UINT32 paramSize total size + * UINT32 status return code + */ +#define VTPM_ORD_SAVEHASHKEY (VTPM_ORD_BASE + 1) +/** + * Load the persistent key blob from TPM Manager storage + * Input: + * TPM_TAG tag VTPM_TAG_REQ + * UINT32 paramSize total size + * UINT32 ordinal VTPM_ORD_LOADHASHKEY + * Output: + * TPM_TAG tag VTPM_TAG_RSP + * UINT32 paramSize total size + * UINT32 status return code + * BYTE[] keyblob 52 or 64 bytes of key data + */ +#define VTPM_ORD_LOADHASHKEY (VTPM_ORD_BASE + 2) +/** + * Get a kernel hash of the control domain for this vTPM + * Input: + * TPM_TAG tag VTPM_TAG_REQ + * UINT32 paramSize total size + * UINT32 ordinal VTPM_ORD_GET_BOOT_HASH + * Output: + * TPM_TAG tag VTPM_TAG_RSP + * UINT32 paramSize total size + * UINT32 status return code + * TPM_DIGEST digest hash for the initial extend of PCR0 + */ +#define VTPM_ORD_GET_BOOT_HASH (VTPM_ORD_BASE + 3) +/** + * Get a hardware TPM quote for this vTPM. The quote will use the AIK + * associated with the group this vTPM was created in. Values specific to the + * vTPM will be extended to certain resettable PCRs. + * + * Input: + * TPM_TAG tag VTPM_TAG_REQ + * UINT32 paramSize total size + * UINT32 ordinal VTPM_ORD_GET_QUOTE + * TPM_NONCE externData Data to be quoted + * PCR_SELECTION quoteSelect PCR selection for quote. + * Output: + * TPM_TAG tag VTPM_TAG_RSP + * UINT32 paramSize total size + * UINT32 status return code + * BYTE[] signature 256 bytes of signature data + * TPM_PCRVALUE[] pcrValues Values of PCRs selected by the request + */ +#define VTPM_ORD_GET_QUOTE (VTPM_ORD_BASE + 4) + +/* + * Resettable PCR values in TPM Manager quotes (VTPM_ORD_GET_QUOTE): + * + * PCR#16: + * unused - debug PCR + * + * PCR#17-19: (cannot be reset by locality 2) + * DRTM measurements + * + * PCR#20: Remains constant over the life of the vTPM group + * SHA1(SAA pubkey) + * + * PCR#21: May change during the life; must be approved by SAA + * SHA1(TPM_MGR_CFG_LIST) + * + * PCR#22: May change during the life; must be in the cfg_list + * vTPM kernel build hash (truncated SHA256) + * Note: this is currently set to 20 zero bytes + * + * PCR#23: Remains constant over the life of the vTPM; system-specific + * group UUID || 00 00 00 00 + * vTPM UUID || 00 00 00 00 + * + * + * Group-only PCR values (VTPM_ORD_GROUP_*) are the same except: + * + * PCR#22: unused (value is zero) + * PCR#23: + * group UUID || 00 00 00 00 + * + * The value of externalData for quotes using these PCRs is defined below; it is + * always a hash whose first 4 bytes identify the rest of the structure. + * + * + * The configuration list signed by a System Approval Agent (SAA) is: + * + * TPM_MGR_CFG_LIST: + * UINT64 sequence Monotonic sequence number + * UINT32 pltCfgSize Size of pltCfgs array + * TPM_COMPOSITE_HASH[] pltCfgs Valid platform configurations + * UINT32 kernSize Size of kernList array + * TPM_HASH[] kernList Valid vTPM kernels + */ + +/************************************\ + * TPM Manager Management Interface * +\************************************/ + +/** + * List groups + * + * Input: + * TPM_TAG tag VTPM_TAG_REQ2 + * UINT32 paramSize total size + * UINT32 ordinal VTPM_ORD_GROUP_LIST + * Output: + * TPM_TAG tag VTPM_TAG_RSP + * UINT32 paramSize total size + * UINT32 status return code + * UINT32 count number of valid groups + */ +#define VTPM_ORD_GROUP_LIST (VTPM_PRIV_BASE + 0x101) +/** + * Create a group + * + * Input: + * TPM_TAG tag VTPM_TAG_REQ2 + * UINT32 paramSize total size + * UINT32 ordinal VTPM_ORD_GROUP_NEW + * TPM_CHOSENID_HASH labelDigest Data for the privacy CA + * BYTE[256] SAASigKey RSA public signature key for the SAA + * Output: + * TPM_TAG tag VTPM_TAG_RSP + * UINT32 paramSize total size + * UINT32 status return code + * BYTE[16] groupUUID UUID for the group + * BYTE[256] aikPubKey Public key of the AIK + * BYTE[256] aikBinding TPM_IDENTITY_CONTENTS signature + */ +#define VTPM_ORD_GROUP_NEW (VTPM_PRIV_BASE + 0x102) +/** + * Delete a group + * + * Input: + * TPM_TAG tag VTPM_TAG_REQ2 + * UINT32 paramSize total size + * UINT32 ordinal VTPM_ORD_GROUP_DEL + * UINT32 groupID ID of the group to delete + * Output: + * TPM_TAG tag VTPM_TAG_RSP + * UINT32 paramSize total size + * UINT32 status return code + */ +#define VTPM_ORD_GROUP_DEL (VTPM_PRIV_BASE + 0x103) +/** + * Activate the group's AIK (message from privacy CA) + * + * Input: + * TPM_TAG tag VTPM_TAG_REQ2 + * UINT32 paramSize total size + * UINT32 ordinal VTPM_ORD_GROUP_ACTIVATE + * UINT32 groupID ID of the group to activate + * UINT32 blobSize + * BYTE[] blob Blob from the privay CA + * Output: + * TPM_TAG tag VTPM_TAG_RSP + * UINT32 paramSize total size + * UINT32 status return code + * TPM_SYMMETRIC_KEY key Output from TPM_ActivateIdentity + */ +#define VTPM_ORD_GROUP_ACTIVATE (VTPM_PRIV_BASE + 0x104) +/** + * Register this TPM manager slot with the SAA and provision its recovery data. + * The initial registration must be done with no reboots between the creation of + * the group and the execution of this command; it can only be done once. + * + * The ExternalData value is SHA1("REGR" || dhkx_1 || dhkx_2 || recoverBlob) + * + * Input: + * TPM_TAG tag VTPM_TAG_REQ2 + * UINT32 paramSize total size + * UINT32 ordinal VTPM_ORD_GROUP_REGISTER + * UINT32 groupID ID of the group to register + * BYTE[256] dhkx_1 One half of a diffie-hellman key exchange + * BYTE[256] SAAProof Signature (using SAASigKey) of derivData + * PCR_SELECTION quoteSelect PCR selection for quote. + * Output: + * TPM_TAG tag VTPM_TAG_RSP + * UINT32 paramSize total size + * UINT32 status return code + * BYTE[256] dhkx_2 One half of a diffie-hellman key exchange + * BYTE[32] recoverBlob Encrypted blob (using key derived from DH) + * BYTE[256] regProof Quote using the group's AIK + */ +#define VTPM_ORD_GROUP_REGISTER (VTPM_PRIV_BASE + 0x105) +/** + * Update the configuration list + * + * Input: + * TPM_TAG tag VTPM_TAG_REQ2 + * UINT32 paramSize total size + * UINT32 ordinal VTPM_ORD_GROUP_UPDATE + * UINT32 groupID ID of the group to update + * BYTE[256] cfgListSig Signature (using SAASigKey) of cfgList + * TPM_MGR_CFG_LIST cfgList Configurations the group is valid in + * PCR_SELECTION[] selForCfgs PCR selections used in the cfgList.pltCfgs + * Output: + * TPM_TAG tag VTPM_TAG_RSP + * UINT32 paramSize total size + * UINT32 status return code + */ +#define VTPM_ORD_GROUP_UPDATE (VTPM_PRIV_BASE + 0x106) +/** + * Get the current contents of the group structure. + * + * Input: + * TPM_TAG tag VTPM_TAG_REQ2 + * UINT32 paramSize total size + * UINT32 ordinal VTPM_ORD_GROUP_SHOW + * UINT32 groupID ID of the group to view + * Output: + * TPM_TAG tag VTPM_TAG_RSP + * UINT32 paramSize total size + * UINT32 status return code + * BYTE[16] groupUUID UUID for the group + * BYTE[256] pubkey public key of the SAA + * TPM_MGR_CFG_LIST cfgList current list for this group + */ +#define VTPM_ORD_GROUP_SHOW (VTPM_PRIV_BASE + 0x107) +/** + * Get a quote of the current status of the TMA structure. This can be used to + * prove that an update has been applied; it is similar to VTPM_ORD_GET_QUOTE, + * but does not include measurements specific to any vTPM. + * + * The ExternalData value for the quote is SHA1("SHOW" || nonce) + * + * Input: + * TPM_TAG tag VTPM_TAG_REQ2 + * UINT32 paramSize total size + * UINT32 ordinal VTPM_ORD_GROUP_QUOTE + * UINT32 groupID ID of the group to view + * TPM_NONCE nonce Anti-replay + * PCR_SELECTION quoteSelect PCR selection for quote. + * Output: + * TPM_TAG tag VTPM_TAG_RSP + * UINT32 paramSize total size + * UINT32 status return code + * BYTE[] signature 256 bytes of signature data + * TPM_PCRVALUE[] pcrValues Values of PCRs selected by the request + */ +#define VTPM_ORD_GROUP_QUOTE (VTPM_PRIV_BASE + 0x108) +/** + * Prepare to use recovery data to open a currently-closed group. + * + * The ExternalData value is SHA1("RCVR" || nonce || dhkx_1) + * + * Input: + * TPM_TAG tag VTPM_TAG_REQ2 + * UINT32 paramSize total size + * UINT32 ordinal VTPM_ORD_GROUP_RECOVER1 + * UINT32 groupID ID of the group to recover + * TPM_KEY proxyAIK AIK to use for recovery quote + * TPM_NONCE nonce Anti-replay by challenger + * PCR_SELECTION quoteSelect PCR selection for quote + * Output: + * TPM_TAG tag VTPM_TAG_RSP + * UINT32 paramSize total size + * UINT32 status return code + * BYTE[256] dhkx_1 One half of a diffie-hellman key exchange + * BYTE[256] signature quote using proxyAIK + */ +#define VTPM_ORD_GROUP_RECOVER1 (VTPM_PRIV_BASE + 0x109) +/** + * Use recovery data to open a currently-closed group + * + * Input: + * TPM_TAG tag VTPM_TAG_REQ2 + * UINT32 paramSize total size + * UINT32 ordinal VTPM_ORD_GROUP_RECOVER2 + * UINT32 groupID ID of the group to recover + * BYTE[256] dhkx_2 One half of a diffie-hellman key exchange + * BYTE[32] recoverBlob Encrypted blob (using key derived from DH) + * Output: + * TPM_TAG tag VTPM_TAG_RSP + * UINT32 paramSize total size + * UINT32 status return code + */ +#define VTPM_ORD_GROUP_RECOVER2 (VTPM_PRIV_BASE + 0x10A) + +/** + * List the UUIDs of vTPMs in an group. Multiple calls may be required to list + * all the vTPMs in an group; if the returned list is shorter than totalCount + * would imply, additional requests using the offest will be required + * to build the full list. + * + * Input: + * TPM_TAG tag VTPM_TAG_REQ2 + * UINT32 paramSize total size + * UINT32 ordinal VTPM_ORD_VTPM_LIST + * UINT32 groupID ID of the group to list + * UINT32 offset Offset to start the list at + * Output: + * TPM_TAG tag VTPM_TAG_RSP + * UINT32 paramSize total size + * UINT32 status return code + * UINT32 totalCount Count of all vTPMs under this group + * BYTE[] uuids List of UUIDs (16 bytes each) + */ +#define VTPM_ORD_VTPM_LIST (VTPM_PRIV_BASE + 0x201) +#define VTPM_ORD_VTPM_SHOW (VTPM_PRIV_BASE + 0x202) +#define VTPM_ORD_VTPM_EDIT (VTPM_PRIV_BASE + 0x203) +/** + * Input: + * TPM_TAG tag VTPM_TAG_REQ2 + * UINT32 paramSize total size + * UINT32 ordinal VTPM_ORD_VTPM_NEW + * UINT32 groupID ID of the group to modify + * Output: + * TPM_TAG tag VTPM_TAG_RSP + * UINT32 paramSize total size + * UINT32 status return code + * BYTE[16] vtpmUUID UUID for the vTPM + */ +#define VTPM_ORD_VTPM_NEW (VTPM_PRIV_BASE + 0x204) +/** + * Input: + * TPM_TAG tag VTPM_TAG_REQ2 + * UINT32 paramSize total size + * UINT32 ordinal VTPM_ORD_VTPM_DEL + ## UINT32 groupID ID of the group to modify + * BYTE[16] vtpmUUID UUID for the vTPM to delete + * Output: + * TPM_TAG tag VTPM_TAG_RSP + * UINT32 paramSize total size + * UINT32 status return code + */ +#define VTPM_ORD_VTPM_DEL (VTPM_PRIV_BASE + 0x205) + +/** + * Generate an unbound AIK for the pTPM + * + * This unbound AIK can be used in the GROUP_RECOVER1 operation. + */ +#define VTPM_ORD_MakeIdentity (VTPM_PRIV_BASE + 0x301) +/** + * Activate an unbound AIK for the pTPM + */ +#define VTPM_ORD_ActivateIdentity (VTPM_PRIV_BASE + 0x302) +/** + * Get the EK from the pTPM + * + * Used for any AIK activation + */ +#define VTPM_ORD_ReadPubek (VTPM_PRIV_BASE + 0x303) +/** + * Define an NVRAM slot + */ +#define VTPM_NV_DefineSpace (VTPM_PRIV_BASE + 0x304) +/** + * Write to NVRAM + */ +#define VTPM_NV_WriteValue (VTPM_PRIV_BASE + 0x305) +/** + * Read from NVRAM + */ +#define VTPM_NV_ReadValue (VTPM_PRIV_BASE + 0x306) -// Non-priviledged VTPM Commands (From DMI's) -#define VTPM_ORD_SAVEHASHKEY (VTPM_ORD_BASE + 1) // DMI requests encryption key for persistent storage -#define VTPM_ORD_LOADHASHKEY (VTPM_ORD_BASE + 2) // DMI requests symkey to be regenerated //************************ Return Codes **************************** #define VTPM_SUCCESS 0 diff --git a/stubdom/vtpmmgr/vtpm_storage.c b/stubdom/vtpmmgr/vtpm_storage.c deleted file mode 100644 index de21b4a..0000000 --- a/stubdom/vtpmmgr/vtpm_storage.c +++ /dev/null @@ -1,794 +0,0 @@ -/* - * Copyright (c) 2010-2012 United States Government, as represented by - * the Secretary of Defense. All rights reserved. - * - * THIS SOFTWARE AND ITS DOCUMENTATION ARE PROVIDED AS IS AND WITHOUT - * ANY EXPRESS OR IMPLIED WARRANTIES WHATSOEVER. ALL WARRANTIES - * INCLUDING, BUT NOT LIMITED TO, PERFORMANCE, MERCHANTABILITY, FITNESS - * FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT ARE HEREBY - * DISCLAIMED. USERS ASSUME THE ENTIRE RISK AND LIABILITY OF USING THE - * SOFTWARE. - */ - -/*************************************************************** - * DISK IMAGE LAYOUT - * ************************************************************* - * All data is stored in BIG ENDIAN format - * ************************************************************* - * Section 1: Header - * - * 10 bytes id ID String "VTPMMGRDOM" - * uint32_t version Disk Image version number (current == 1) - * uint32_t storage_key_len Length of the storage Key - * TPM_KEY storage_key Marshalled TPM_KEY structure (See TPM spec v2) - * RSA_BLOCK aes_crypto Encrypted aes key data (RSA_CIPHER_SIZE bytes), bound by the storage_key - * BYTE[32] aes_key Aes key for encrypting the uuid table - * uint32_t cipher_sz Encrypted size of the uuid table - * - * ************************************************************* - * Section 2: Uuid Table - * - * This table is encrypted by the aes_key in the header. The cipher text size is just - * large enough to hold all of the entries plus required padding. - * - * Each entry is as follows - * BYTE[16] uuid Uuid of a vtpm that is stored on this disk - * uint32_t offset Disk offset where the vtpm data is stored - * - * ************************************************************* - * Section 3: Vtpm Table - * - * The rest of the disk stores vtpms. Each vtpm is an RSA_BLOCK encrypted - * by the storage key. Each vtpm must exist on an RSA_BLOCK aligned boundary, - * starting at the first RSA_BLOCK aligned offset after the uuid table. - * As the uuid table grows, vtpms may be relocated. - * - * RSA_BLOCK vtpm_crypto Vtpm data encrypted by storage_key - * BYTE[20] hash Sha1 hash of vtpm encrypted data - * BYTE[16] vtpm_aes_key Encryption key for vtpm data - * - ************************************************************* - */ -#define DISKVERS 1 -#define IDSTR "VTPMMGRDOM" -#define IDSTRLEN 10 -#define AES_BLOCK_SIZE 16 -#define AES_KEY_BITS 256 -#define AES_KEY_SIZE (AES_KEY_BITS/8) -#define BUF_SIZE 4096 - -#define UUID_TBL_ENT_SIZE (sizeof(uuid_t) + sizeof(uint32_t)) - -#define HEADERSZ (10 + 4 + 4) - -#define TRY_READ(buf, size, msg) do {\ - int rc; \ - if((rc = read(blkfront_fd, buf, (size))) != (size)) { \ - vtpmlogerror(VTPM_LOG_VTPM, "read() failed! " msg " : rc=(%d/%d), error=(%s)\n", rc, (int)(size), strerror(errno)); \ - status = TPM_IOERROR;\ - goto abort_egress;\ - } \ -} while(0) - -#define TRY_WRITE(buf, size, msg) do {\ - int rc; \ - if((rc = write(blkfront_fd, buf, (size))) != (size)) { \ - vtpmlogerror(VTPM_LOG_VTPM, "write() failed! " msg " : rc=(%d/%d), error=(%s)\n", rc, (int)(size), strerror(errno)); \ - status = TPM_IOERROR;\ - goto abort_egress;\ - } \ -} while(0) - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "vtpm_manager.h" -#include "log.h" -#include "marshal.h" -#include "tpm.h" -#include "uuid.h" - -#include "vtpmmgr.h" -#include "vtpm_storage.h" - -#define MAX(a,b) ( ((a) > (b)) ? (a) : (b) ) -#define MIN(a,b) ( ((a) < (b)) ? (a) : (b) ) - -/* blkfront device objets */ -static struct blkfront_dev* blkdev = NULL; -static int blkfront_fd = -1; - -struct Vtpm { - uuid_t uuid; - int offset; -}; -struct Storage { - int aes_offset; - int uuid_offset; - int end_offset; - - int num_vtpms; - int num_vtpms_alloced; - struct Vtpm* vtpms; -}; - -/* Global storage data */ -static struct Storage g_store = { - .vtpms = NULL, -}; - -static int get_offset(void) { - return lseek(blkfront_fd, 0, SEEK_CUR); -} - -static void reset_store(void) { - g_store.aes_offset = 0; - g_store.uuid_offset = 0; - g_store.end_offset = 0; - - g_store.num_vtpms = 0; - g_store.num_vtpms_alloced = 0; - free(g_store.vtpms); - g_store.vtpms = NULL; -} - -static int vtpm_get_index(const uuid_t uuid) { - int st = 0; - int ed = g_store.num_vtpms-1; - while(st <= ed) { - int mid = ((unsigned int)st + (unsigned int)ed) >> 1; //avoid overflow - int c = memcmp(uuid, &g_store.vtpms[mid].uuid, sizeof(uuid_t)); - if(c == 0) { - return mid; - } else if(c > 0) { - st = mid + 1; - } else { - ed = mid - 1; - } - } - return -(st + 1); -} - -static void vtpm_add(const uuid_t uuid, int offset, int index) { - /* Realloc more space if needed */ - if(g_store.num_vtpms >= g_store.num_vtpms_alloced) { - g_store.num_vtpms_alloced += 16; - g_store.vtpms = realloc( - g_store.vtpms, - sizeof(struct Vtpm) * g_store.num_vtpms_alloced); - } - - /* Move everybody after the new guy */ - for(int i = g_store.num_vtpms; i > index; --i) { - g_store.vtpms[i] = g_store.vtpms[i-1]; - } - - vtpmloginfo(VTPM_LOG_VTPM, "Registered vtpm " UUID_FMT "\n", UUID_BYTES(uuid)); - - /* Finally add new one */ - memcpy(g_store.vtpms[index].uuid, uuid, sizeof(uuid_t)); - g_store.vtpms[index].offset = offset; - ++g_store.num_vtpms; -} - -#if 0 -static void vtpm_remove(int index) { - for(i = index; i < g_store.num_vtpms; ++i) { - g_store.vtpms[i] = g_store.vtpms[i+1]; - } - --g_store.num_vtpms; -} -#endif - -static int pack_uuid_table(uint8_t* table, int size, int* nvtpms) { - uint8_t* ptr = table; - while(*nvtpms < g_store.num_vtpms && size >= 0) - { - /* Pack the uuid */ - memcpy(ptr, (uint8_t*)g_store.vtpms[*nvtpms].uuid, sizeof(uuid_t)); - ptr+= sizeof(uuid_t); - - - /* Pack the offset */ - ptr = pack_UINT32(ptr, g_store.vtpms[*nvtpms].offset); - - ++*nvtpms; - size -= UUID_TBL_ENT_SIZE; - } - return ptr - table; -} - -/* Extract the uuids */ -static int extract_uuid_table(uint8_t* table, int size) { - uint8_t* ptr = table; - for(;size >= UUID_TBL_ENT_SIZE; size -= UUID_TBL_ENT_SIZE) { - int index; - uint32_t v32; - - /*uuid_t is just an array of bytes, so we can do a direct cast here */ - uint8_t* uuid = ptr; - ptr += sizeof(uuid_t); - - /* Get the offset of the key */ - ptr = unpack_UINT32(ptr, &v32); - - /* Insert the new vtpm in sorted order */ - if((index = vtpm_get_index(uuid)) >= 0) { - vtpmlogerror(VTPM_LOG_VTPM, "Vtpm (" UUID_FMT ") exists multiple times! ignoring...\n", UUID_BYTES(uuid)); - continue; - } - index = -index -1; - - vtpm_add(uuid, v32, index); - - } - return ptr - table; -} - -static void vtpm_decrypt_block(aes_context* aes, - uint8_t* iv, - uint8_t* cipher, - uint8_t* plain, - int cipher_sz, - int* overlap) -{ - int bytes_ext; - /* Decrypt */ - aes_crypt_cbc(aes, AES_DECRYPT, - cipher_sz, - iv, cipher, plain + *overlap); - - /* Extract */ - bytes_ext = extract_uuid_table(plain, cipher_sz + *overlap); - - /* Copy left overs to the beginning */ - *overlap = cipher_sz + *overlap - bytes_ext; - memcpy(plain, plain + bytes_ext, *overlap); -} - -static int vtpm_encrypt_block(aes_context* aes, - uint8_t* iv, - uint8_t* plain, - uint8_t* cipher, - int block_sz, - int* overlap, - int* num_vtpms) -{ - int bytes_to_crypt; - int bytes_packed; - - /* Pack the uuid table */ - bytes_packed = *overlap + pack_uuid_table(plain + *overlap, block_sz - *overlap, num_vtpms); - bytes_to_crypt = MIN(bytes_packed, block_sz); - - /* Add padding if we aren't on a multiple of the block size */ - if(bytes_to_crypt & (AES_BLOCK_SIZE-1)) { - int oldsz = bytes_to_crypt; - //add padding - bytes_to_crypt += AES_BLOCK_SIZE - (bytes_to_crypt & (AES_BLOCK_SIZE-1)); - //fill padding with random bytes - vtpmmgr_rand(plain + oldsz, bytes_to_crypt - oldsz); - *overlap = 0; - } else { - *overlap = bytes_packed - bytes_to_crypt; - } - - /* Encrypt this chunk */ - aes_crypt_cbc(aes, AES_ENCRYPT, - bytes_to_crypt, - iv, plain, cipher); - - /* Copy the left over partials to the beginning */ - memcpy(plain, plain + bytes_to_crypt, *overlap); - - return bytes_to_crypt; -} - -static TPM_RESULT vtpm_storage_new_vtpm(const uuid_t uuid, int index) { - TPM_RESULT status = TPM_SUCCESS; - uint8_t plain[BUF_SIZE + AES_BLOCK_SIZE]; - uint8_t buf[BUF_SIZE]; - uint8_t* ptr; - int cipher_sz; - aes_context aes; - - /* Add new vtpm to the table */ - vtpm_add(uuid, g_store.end_offset, index); - g_store.end_offset += RSA_CIPHER_SIZE; - - /* Compute the new end location of the encrypted uuid table */ - cipher_sz = AES_BLOCK_SIZE; //IV - cipher_sz += g_store.num_vtpms * UUID_TBL_ENT_SIZE; //uuid table - cipher_sz += (AES_BLOCK_SIZE - (cipher_sz & (AES_BLOCK_SIZE -1))) & (AES_BLOCK_SIZE-1); //aes padding - - /* Does this overlap any key data? If so they need to be relocated */ - int uuid_end = (g_store.uuid_offset + cipher_sz + RSA_CIPHER_SIZE) & ~(RSA_CIPHER_SIZE -1); - for(int i = 0; i < g_store.num_vtpms; ++i) { - if(g_store.vtpms[i].offset < uuid_end) { - - vtpmloginfo(VTPM_LOG_VTPM, "Relocating vtpm data\n"); - - //Read the hashkey cipher text - lseek(blkfront_fd, g_store.vtpms[i].offset, SEEK_SET); - TRY_READ(buf, RSA_CIPHER_SIZE, "vtpm hashkey relocate"); - - //Write the cipher text to new offset - lseek(blkfront_fd, g_store.end_offset, SEEK_SET); - TRY_WRITE(buf, RSA_CIPHER_SIZE, "vtpm hashkey relocate"); - - //Save new offset - g_store.vtpms[i].offset = g_store.end_offset; - g_store.end_offset += RSA_CIPHER_SIZE; - } - } - - vtpmloginfo(VTPM_LOG_VTPM, "Generating a new symmetric key\n"); - - /* Generate an aes key */ - TPMTRYRETURN(vtpmmgr_rand(plain, AES_KEY_SIZE)); - aes_setkey_enc(&aes, plain, AES_KEY_BITS); - ptr = plain + AES_KEY_SIZE; - - /* Pack the crypted size */ - ptr = pack_UINT32(ptr, cipher_sz); - - vtpmloginfo(VTPM_LOG_VTPM, "Binding encrypted key\n"); - - /* Seal the key and size */ - TPMTRYRETURN(TPM_Bind(&vtpm_globals.storage_key, - plain, - ptr - plain, - buf)); - - /* Write the sealed key to disk */ - lseek(blkfront_fd, g_store.aes_offset, SEEK_SET); - TRY_WRITE(buf, RSA_CIPHER_SIZE, "vtpm aes key"); - - /* ENCRYPT AND WRITE UUID TABLE */ - - vtpmloginfo(VTPM_LOG_VTPM, "Encrypting the uuid table\n"); - - int num_vtpms = 0; - int overlap = 0; - int bytes_crypted; - uint8_t iv[AES_BLOCK_SIZE]; - - /* Generate the iv for the first block */ - TPMTRYRETURN(vtpmmgr_rand(iv, AES_BLOCK_SIZE)); - - /* Copy the iv to the cipher text buffer to be written to disk */ - memcpy(buf, iv, AES_BLOCK_SIZE); - ptr = buf + AES_BLOCK_SIZE; - - /* Encrypt the first block of the uuid table */ - bytes_crypted = vtpm_encrypt_block(&aes, - iv, //iv - plain, //plaintext - ptr, //cipher text - BUF_SIZE - AES_BLOCK_SIZE, - &overlap, - &num_vtpms); - - /* Write the iv followed by the crypted table*/ - TRY_WRITE(buf, bytes_crypted + AES_BLOCK_SIZE, "vtpm uuid table"); - - /* Decrement the number of bytes encrypted */ - cipher_sz -= bytes_crypted + AES_BLOCK_SIZE; - - /* If there are more vtpms, encrypt and write them block by block */ - while(cipher_sz > 0) { - /* Encrypt the next block of the uuid table */ - bytes_crypted = vtpm_encrypt_block(&aes, - iv, - plain, - buf, - BUF_SIZE, - &overlap, - &num_vtpms); - - /* Write the cipher text to disk */ - TRY_WRITE(buf, bytes_crypted, "vtpm uuid table"); - - cipher_sz -= bytes_crypted; - } - - goto egress; -abort_egress: -egress: - return status; -} - - -/************************************** - * PUBLIC FUNCTIONS - * ***********************************/ - -int vtpm_storage_init(void) { - struct blkfront_info info; - if((blkdev = init_blkfront(NULL, &info)) == NULL) { - return -1; - } - if((blkfront_fd = blkfront_open(blkdev)) < 0) { - return -1; - } - return 0; -} - -void vtpm_storage_shutdown(void) { - reset_store(); - close(blkfront_fd); -} - -TPM_RESULT vtpm_storage_load_hashkey(const uuid_t uuid, uint8_t hashkey[HASHKEYSZ]) -{ - TPM_RESULT status = TPM_SUCCESS; - int index; - uint8_t cipher[RSA_CIPHER_SIZE]; - uint8_t clear[RSA_CIPHER_SIZE]; - UINT32 clear_size; - - /* Find the index of this uuid */ - if((index = vtpm_get_index(uuid)) < 0) { - index = -index-1; - vtpmlogerror(VTPM_LOG_VTPM, "LoadKey failure: Unrecognized uuid! " UUID_FMT "\n", UUID_BYTES(uuid)); - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - /* Read the table entry */ - lseek(blkfront_fd, g_store.vtpms[index].offset, SEEK_SET); - TRY_READ(cipher, RSA_CIPHER_SIZE, "vtpm hashkey data"); - - /* Decrypt the table entry */ - TPMTRYRETURN(TPM_UnBind( - vtpm_globals.storage_key_handle, - RSA_CIPHER_SIZE, - cipher, - &clear_size, - clear, - (const TPM_AUTHDATA*)&vtpm_globals.storage_key_usage_auth, - &vtpm_globals.oiap)); - - if(clear_size < HASHKEYSZ) { - vtpmloginfo(VTPM_LOG_VTPM, "Decrypted Hash key size (%" PRIu32 ") was too small!\n", clear_size); - status = TPM_RESOURCES; - goto abort_egress; - } - - memcpy(hashkey, clear, HASHKEYSZ); - - vtpmloginfo(VTPM_LOG_VTPM, "Loaded hash and key for vtpm " UUID_FMT "\n", UUID_BYTES(uuid)); - goto egress; -abort_egress: - vtpmlogerror(VTPM_LOG_VTPM, "Failed to load key\n"); -egress: - return status; -} - -TPM_RESULT vtpm_storage_save_hashkey(const uuid_t uuid, uint8_t hashkey[HASHKEYSZ]) -{ - TPM_RESULT status = TPM_SUCCESS; - int index; - uint8_t buf[RSA_CIPHER_SIZE]; - - /* Find the index of this uuid */ - if((index = vtpm_get_index(uuid)) < 0) { - index = -index-1; - /* Create a new vtpm */ - TPMTRYRETURN( vtpm_storage_new_vtpm(uuid, index) ); - } - - /* Encrypt the hash and key */ - TPMTRYRETURN( TPM_Bind(&vtpm_globals.storage_key, - hashkey, - HASHKEYSZ, - buf)); - - /* Write to disk */ - lseek(blkfront_fd, g_store.vtpms[index].offset, SEEK_SET); - TRY_WRITE(buf, RSA_CIPHER_SIZE, "vtpm hashkey data"); - - vtpmloginfo(VTPM_LOG_VTPM, "Saved hash and key for vtpm " UUID_FMT "\n", UUID_BYTES(uuid)); - goto egress; -abort_egress: - vtpmlogerror(VTPM_LOG_VTPM, "Failed to save key\n"); -egress: - return status; -} - -TPM_RESULT vtpm_storage_new_header() -{ - TPM_RESULT status = TPM_SUCCESS; - uint8_t buf[BUF_SIZE]; - uint8_t keybuf[AES_KEY_SIZE + sizeof(uint32_t)]; - uint8_t* ptr = buf; - uint8_t* sptr; - - /* Clear everything first */ - reset_store(); - - vtpmloginfo(VTPM_LOG_VTPM, "Creating new disk image header\n"); - - /*Copy the ID string */ - memcpy(ptr, IDSTR, IDSTRLEN); - ptr += IDSTRLEN; - - /*Copy the version */ - ptr = pack_UINT32(ptr, DISKVERS); - - /*Save the location of the key size */ - sptr = ptr; - ptr += sizeof(UINT32); - - vtpmloginfo(VTPM_LOG_VTPM, "Saving root storage key..\n"); - - /* Copy the storage key */ - ptr = pack_TPM_KEY(ptr, &vtpm_globals.storage_key); - - /* Now save the size */ - pack_UINT32(sptr, ptr - (sptr + 4)); - - /* Create a fake aes key and set cipher text size to 0 */ - memset(keybuf, 0, sizeof(keybuf)); - - vtpmloginfo(VTPM_LOG_VTPM, "Binding uuid table symmetric key..\n"); - - /* Save the location of the aes key */ - g_store.aes_offset = ptr - buf; - - /* Store the fake aes key and vtpm count */ - TPMTRYRETURN(TPM_Bind(&vtpm_globals.storage_key, - keybuf, - sizeof(keybuf), - ptr)); - ptr+= RSA_CIPHER_SIZE; - - /* Write the header to disk */ - lseek(blkfront_fd, 0, SEEK_SET); - TRY_WRITE(buf, ptr-buf, "vtpm header"); - - /* Save the location of the uuid table */ - g_store.uuid_offset = get_offset(); - - /* Save the end offset */ - g_store.end_offset = (g_store.uuid_offset + RSA_CIPHER_SIZE) & ~(RSA_CIPHER_SIZE -1); - - vtpmloginfo(VTPM_LOG_VTPM, "Saved new manager disk header.\n"); - - goto egress; -abort_egress: -egress: - return status; -} - - -TPM_RESULT vtpm_storage_load_header(void) -{ - TPM_RESULT status = TPM_SUCCESS; - uint32_t v32; - uint8_t buf[BUF_SIZE]; - uint8_t* ptr = buf; - aes_context aes; - - /* Clear everything first */ - reset_store(); - - /* Read the header from disk */ - lseek(blkfront_fd, 0, SEEK_SET); - TRY_READ(buf, IDSTRLEN + sizeof(UINT32) + sizeof(UINT32), "vtpm header"); - - vtpmloginfo(VTPM_LOG_VTPM, "Loading disk image header\n"); - - /* Verify the ID string */ - if(memcmp(ptr, IDSTR, IDSTRLEN)) { - vtpmlogerror(VTPM_LOG_VTPM, "Invalid ID string in disk image!\n"); - status = TPM_FAIL; - goto abort_egress; - } - ptr+=IDSTRLEN; - - /* Unpack the version */ - ptr = unpack_UINT32(ptr, &v32); - - /* Verify the version */ - if(v32 != DISKVERS) { - vtpmlogerror(VTPM_LOG_VTPM, "Unsupported disk image version number %" PRIu32 "\n", v32); - status = TPM_FAIL; - goto abort_egress; - } - - /* Size of the storage key */ - ptr = unpack_UINT32(ptr, &v32); - - /* Sanity check */ - if(v32 > BUF_SIZE) { - vtpmlogerror(VTPM_LOG_VTPM, "Size of storage key (%" PRIu32 ") is too large!\n", v32); - status = TPM_IOERROR; - goto abort_egress; - } - - /* read the storage key */ - TRY_READ(buf, v32, "storage pub key"); - - vtpmloginfo(VTPM_LOG_VTPM, "Unpacking storage key\n"); - - /* unpack the storage key */ - ptr = unpack_TPM_KEY(buf, &vtpm_globals.storage_key, UNPACK_ALLOC); - - /* Load Storage Key into the TPM */ - TPMTRYRETURN( TPM_LoadKey( - TPM_SRK_KEYHANDLE, - &vtpm_globals.storage_key, - &vtpm_globals.storage_key_handle, - (const TPM_AUTHDATA*)&vtpm_globals.srk_auth, - &vtpm_globals.oiap)); - - /* Initialize the storage key auth */ - memset(vtpm_globals.storage_key_usage_auth, 0, sizeof(TPM_AUTHDATA)); - - /* Store the offset of the aes key */ - g_store.aes_offset = get_offset(); - - /* Read the rsa cipher text for the aes key */ - TRY_READ(buf, RSA_CIPHER_SIZE, "aes key"); - ptr = buf + RSA_CIPHER_SIZE; - - vtpmloginfo(VTPM_LOG_VTPM, "Unbinding uuid table symmetric key\n"); - - /* Decrypt the aes key protecting the uuid table */ - UINT32 datalen; - TPMTRYRETURN(TPM_UnBind( - vtpm_globals.storage_key_handle, - RSA_CIPHER_SIZE, - buf, - &datalen, - ptr, - (const TPM_AUTHDATA*)&vtpm_globals.storage_key_usage_auth, - &vtpm_globals.oiap)); - - /* Validate the length of the output buffer */ - if(datalen < AES_KEY_SIZE + sizeof(UINT32)) { - vtpmlogerror(VTPM_LOG_VTPM, "Unbound AES key size (%d) was too small! expected (%zu)\n", datalen, AES_KEY_SIZE + sizeof(UINT32)); - status = TPM_IOERROR; - goto abort_egress; - } - - /* Extract the aes key */ - aes_setkey_dec(&aes, ptr, AES_KEY_BITS); - ptr+= AES_KEY_SIZE; - - /* Extract the ciphertext size */ - ptr = unpack_UINT32(ptr, &v32); - int cipher_size = v32; - - /* Sanity check */ - if(cipher_size & (AES_BLOCK_SIZE-1)) { - vtpmlogerror(VTPM_LOG_VTPM, "Cipher text size (%" PRIu32 ") is not a multiple of the aes block size! (%d)\n", v32, AES_BLOCK_SIZE); - status = TPM_IOERROR; - goto abort_egress; - } - - /* Save the location of the uuid table */ - g_store.uuid_offset = get_offset(); - - /* Only decrypt the table if there are vtpms to decrypt */ - if(cipher_size > 0) { - int rbytes; - int overlap = 0; - uint8_t plain[BUF_SIZE + AES_BLOCK_SIZE]; - uint8_t iv[AES_BLOCK_SIZE]; - - vtpmloginfo(VTPM_LOG_VTPM, "Decrypting uuid table\n"); - - /* Pre allocate the vtpm array */ - g_store.num_vtpms_alloced = cipher_size / UUID_TBL_ENT_SIZE; - g_store.vtpms = malloc(sizeof(struct Vtpm) * g_store.num_vtpms_alloced); - - /* Read the iv and the first chunk of cipher text */ - rbytes = MIN(cipher_size, BUF_SIZE); - TRY_READ(buf, rbytes, "vtpm uuid table\n"); - cipher_size -= rbytes; - - /* Copy the iv */ - memcpy(iv, buf, AES_BLOCK_SIZE); - ptr = buf + AES_BLOCK_SIZE; - - /* Remove the iv from the number of bytes to decrypt */ - rbytes -= AES_BLOCK_SIZE; - - /* Decrypt and extract vtpms */ - vtpm_decrypt_block(&aes, - iv, ptr, plain, - rbytes, &overlap); - - /* Read the rest of the table if there is more */ - while(cipher_size > 0) { - /* Read next chunk of cipher text */ - rbytes = MIN(cipher_size, BUF_SIZE); - TRY_READ(buf, rbytes, "vtpm uuid table"); - cipher_size -= rbytes; - - /* Decrypt a block of text */ - vtpm_decrypt_block(&aes, - iv, buf, plain, - rbytes, &overlap); - - } - vtpmloginfo(VTPM_LOG_VTPM, "Loaded %d vtpms!\n", g_store.num_vtpms); - } - - /* The end of the key table, new vtpms go here */ - int uuid_end = (get_offset() + RSA_CIPHER_SIZE) & ~(RSA_CIPHER_SIZE -1); - g_store.end_offset = uuid_end; - - /* Compute the end offset while validating vtpms*/ - for(int i = 0; i < g_store.num_vtpms; ++i) { - /* offset must not collide with previous data */ - if(g_store.vtpms[i].offset < uuid_end) { - vtpmlogerror(VTPM_LOG_VTPM, "vtpm: " UUID_FMT - " offset (%d) is before end of uuid table (%d)!\n", - UUID_BYTES(g_store.vtpms[i].uuid), - g_store.vtpms[i].offset, uuid_end); - status = TPM_IOERROR; - goto abort_egress; - } - /* offset must be at a multiple of cipher size */ - if(g_store.vtpms[i].offset & (RSA_CIPHER_SIZE-1)) { - vtpmlogerror(VTPM_LOG_VTPM, "vtpm: " UUID_FMT - " offset(%d) is not at a multiple of the rsa cipher text size (%d)!\n", - UUID_BYTES(g_store.vtpms[i].uuid), - g_store.vtpms[i].offset, RSA_CIPHER_SIZE); - status = TPM_IOERROR; - goto abort_egress; - } - /* Save the last offset */ - if(g_store.vtpms[i].offset >= g_store.end_offset) { - g_store.end_offset = g_store.vtpms[i].offset + RSA_CIPHER_SIZE; - } - } - - goto egress; -abort_egress: - //An error occured somewhere - vtpmlogerror(VTPM_LOG_VTPM, "Failed to load manager data!\n"); - - //Clear the data store - reset_store(); - - //Reset the storage key structure - free_TPM_KEY(&vtpm_globals.storage_key); - { - TPM_KEY key = TPM_KEY_INIT; - vtpm_globals.storage_key = key; - } - - //Reset the storage key handle - TPM_EvictKey(vtpm_globals.storage_key_handle); - vtpm_globals.storage_key_handle = 0; -egress: - return status; -} - -#if 0 -/* For testing disk IO */ -void add_fake_vtpms(int num) { - for(int i = 0; i < num; ++i) { - uint32_t ind = cpu_to_be32(i); - - uuid_t uuid; - memset(uuid, 0, sizeof(uuid_t)); - memcpy(uuid, &ind, sizeof(ind)); - int index = vtpm_get_index(uuid); - index = -index-1; - - vtpm_storage_new_vtpm(uuid, index); - } -} -#endif diff --git a/stubdom/vtpmmgr/vtpm_storage.h b/stubdom/vtpmmgr/vtpm_storage.h deleted file mode 100644 index a5a5fd7..0000000 --- a/stubdom/vtpmmgr/vtpm_storage.h +++ /dev/null @@ -1,68 +0,0 @@ -/* - * Copyright (c) 2010-2012 United States Government, as represented by - * the Secretary of Defense. All rights reserved. - * - * based off of the original tools/vtpm_manager code base which is: - * Copyright (c) 2005, Intel Corp. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * * Neither the name of Intel Corporation nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS - * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE - * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES - * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) - * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, - * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED - * OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -#ifndef VTPM_STORAGE_H -#define VTPM_STORAGE_h - -#include "uuid.h" - -#define VTPM_NVMKEY_SIZE 32 -#define HASHKEYSZ (sizeof(TPM_DIGEST) + VTPM_NVMKEY_SIZE) - -/* Initialize the storage system and its virtual disk */ -int vtpm_storage_init(void); - -/* Shutdown the storage system and its virtual disk */ -void vtpm_storage_shutdown(void); - -/* Loads Sha1 hash and 256 bit AES key from disk and stores them - * packed together in outbuf. outbuf must be freed - * by the caller using buffer_free() - */ -TPM_RESULT vtpm_storage_load_hashkey(const uuid_t uuid, uint8_t hashkey[HASHKEYSZ]); - -/* inbuf must contain a sha1 hash followed by a 256 bit AES key. - * Encrypts and stores the hash and key to disk */ -TPM_RESULT vtpm_storage_save_hashkey(const uuid_t uuid, uint8_t hashkey[HASHKEYSZ]); - -/* Load the vtpm manager data - call this on startup */ -TPM_RESULT vtpm_storage_load_header(void); - -/* Saves the vtpm manager data - call this on shutdown */ -TPM_RESULT vtpm_storage_new_header(void); - - -#endif diff --git a/stubdom/vtpmmgr/vtpmmgr.h b/stubdom/vtpmmgr/vtpmmgr.h index 50a1992..cf2b962 100644 --- a/stubdom/vtpmmgr/vtpmmgr.h +++ b/stubdom/vtpmmgr/vtpmmgr.h @@ -50,10 +50,7 @@ struct vtpm_globals { int tpm_fd; - TPM_KEY storage_key; - TPM_HANDLE storage_key_handle; // Key used by persistent store TPM_AUTH_SESSION oiap; // OIAP session for storageKey - TPM_AUTHDATA storage_key_usage_auth; TPM_AUTHDATA owner_auth; TPM_AUTHDATA srk_auth; @@ -62,13 +59,20 @@ struct vtpm_globals { ctr_drbg_context ctr_drbg; }; +struct tpm_opaque { + uuid_t *uuid; + struct mem_group *group; + struct mem_vtpm *vtpm; + uint8_t kern_hash[32]; +}; + // --------------------------- Global Values -------------------------- extern struct vtpm_globals vtpm_globals; // Key info and DMI states TPM_RESULT vtpmmgr_init(int argc, char** argv); void vtpmmgr_shutdown(void); -TPM_RESULT vtpmmgr_handle_cmd(const uuid_t uuid, tpmcmd_t* tpmcmd); +TPM_RESULT vtpmmgr_handle_cmd(struct tpm_opaque *opq, tpmcmd_t* tpmcmd); inline TPM_RESULT vtpmmgr_rand(unsigned char* bytes, size_t num_bytes) { return ctr_drbg_random(&vtpm_globals.ctr_drbg, bytes, num_bytes) == 0 ? 0 : TPM_FAIL; -- 1.8.5.3 _______________________________________________ Xen-devel mailing list Xen-devel@lists.xen.org http://lists.xen.org/xen-devel From xen-devel-bounces@lists.xen.org Thu Mar 20 07:29:46 2014 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Thu, 20 Mar 2014 07:29:46 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WQXPo-0006Yt-Gn; Thu, 20 Mar 2014 07:29:24 +0000 Received: from mail6.bemta3.messagelabs.com ([195.245.230.39]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WQTmp-0000RE-0g for xen-devel@lists.xenproject.org; Thu, 20 Mar 2014 03:36:56 +0000 Received: from [85.158.137.68:40930] by server-17.bemta-3.messagelabs.com id 3F/F3-22741-6526A235; Thu, 20 Mar 2014 03:36:54 +0000 X-Env-Sender: russell.pavlicek@citrix.com X-Msg-Ref: server-12.tower-31.messagelabs.com!1395286609!246869!1 X-Originating-IP: [66.165.176.89] X-SpamReason: No, hits=0.0 required=7.0 tests=sa_preprocessor: VHJ1c3RlZCBJUDogNjYuMTY1LjE3Ni44OSA9PiAyMDMwMDc=\n X-StarScan-Received: X-StarScan-Version: 6.11.1; banners=-,-,- X-VirusChecked: Checked Received: (qmail 19220 invoked from network); 20 Mar 2014 03:36:51 -0000 Received: from smtp.citrix.com (HELO SMTP.CITRIX.COM) (66.165.176.89) by server-12.tower-31.messagelabs.com with RC4-SHA encrypted SMTP; 20 Mar 2014 03:36:51 -0000 X-IronPort-AV: E=Sophos;i="4.97,691,1389744000"; d="pdf'?scan'208";a="113128543" Received: from sjcpex01cl02.citrite.net ([10.216.14.144]) by FTLPIPO01.CITRIX.COM with ESMTP/TLS/AES128-SHA; 20 Mar 2014 03:36:43 +0000 Received: from SJCPEX01CL03.citrite.net ([169.254.3.141]) by SJCPEX01CL02.citrite.net ([10.216.14.144]) with mapi id 14.02.0342.004; Wed, 19 Mar 2014 20:36:42 -0700 From: Russell Pavlicek To: Ian Campbell , "xen-devel (xen-devel@lists.xenproject.org)" Thread-Topic: [Xen-devel] 4.4 Release Talk Slides Thread-Index: Ac9DDhJc5g8RalkZRKScsdkzy+g7BQAhDBQAAAgwgIAADpIVgA== Date: Thu, 20 Mar 2014 03:36:42 +0000 Message-ID: <55E78A57290FB64FA0D3CF672F9F3DA21BC41C@SJCPEX01CL03.citrite.net> References: <55E78A57290FB64FA0D3CF672F9F3DA21BA6CF@SJCPEX01CL03.citrite.net> <1395222168.10203.21.camel@kazak.uk.xensource.com> Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: yes X-MS-TNEF-Correlator: x-originating-ip: [172.16.2.168] Content-Type: multipart/mixed; boundary="_002_55E78A57290FB64FA0D3CF672F9F3DA21BC41CSJCPEX01CL03citri_" MIME-Version: 1.0 X-Mailman-Approved-At: Thu, 20 Mar 2014 07:29:22 +0000 Subject: Re: [Xen-devel] 4.4 Release Talk Slides X-BeenThere: xen-devel@lists.xen.org X-Mailman-Version: 2.1.13 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Sender: xen-devel-bounces@lists.xen.org Errors-To: xen-devel-bounces@lists.xen.org --_002_55E78A57290FB64FA0D3CF672F9F3DA21BC41CSJCPEX01CL03citri_ Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 SGVyZSdzIHRoZSBsYXRlc3QgdmVyc2lvbi4NCg0KVGhhbmtzLA0KDQpSdXNzIFBhdmxpY2VrDQpY ZW4gUHJvamVjdCBFdmFuZ2VsaXN0LCBDaXRyaXggU3lzdGVtcw0KSG9tZSBPZmZpY2U6ICsxLTMw MS04MjktNTMyNw0KTW9iaWxlOiArMS0yNDAtMzk3LTAxOTkNClVLIFZvSVA6ICs0NCAxMjIzIDg1 MiA4OTQNCg0KDQotLS0tLU9yaWdpbmFsIE1lc3NhZ2UtLS0tLQ0KRnJvbTogUnVzc2VsbCBQYXZs aWNlayANClNlbnQ6IFdlZG5lc2RheSwgTWFyY2ggMTksIDIwMTQgOTowMSBBTQ0KVG86IElhbiBD YW1wYmVsbA0KQ2M6IHhlbi1kZXZlbCAoeGVuLWRldmVsQGxpc3RzLnhlbnByb2plY3Qub3JnKQ0K U3ViamVjdDogUkU6IFtYZW4tZGV2ZWxdIDQuNCBSZWxlYXNlIFRhbGsgU2xpZGVzDQoNCklhbiwN Cg0KVGhhbmtzISAgSSB3aWxsIHJvbGUgdGhvc2UgaW4gYW5kIHNlbmQgb3V0IGEgbW9kaWZpZWQg dmVyc2lvbiBsYXRlciBmb3IgY29tbWVudC4gIElmIGFueW9uZSBlbHNlIGhhcyBpdGVtcyB0byBh ZGQsIHBsZWFzZSBsZXQgbWUga25vdy4NCg0KPlRoZSB1c2Ugb2YgIlhlbiBQcm9qZWN0IiBvbiB0 aGlzIHNsaWRlIHNlZW1zIG91dCBvZiBjb250ZXh0L2NsdW1zeS4gSWYgcGxhaW4gIlhlbiIgaXMg bm90IGFjY2VwdGFibGUgdGhlbiBwZXJoYXBzICJYZW4gSHlwZXJ2aXNvciI/DQoNClRoZSBwcm9i bGVtIGhlcmUgaXMgdGhlIGdyb3dpbmcgY29uY2VybiBhYm91dCBwcm9wZXIgdXNlIG9mIHRyYWRl bWFyayBpbiBleHRlcm5hbGx5LWZhY2luZyBkb2NzIGFuZCBwcmVzZW50YXRpb25zLiAgVGhlIGd1 aWRhbmNlIGZyb20gTGludXggRm91bmRhdGlvbiBpcyB0byB1c2UgIlhlbiBQcm9qZWN0IiBldmVy eXdoZXJlLiAgVGhlIG9sZCAiWGVuIiBtYXJrIGlzIG5vdCBvd25lZCBieSBMRiwgYW5kLCBoZW5j ZSwgc2hvdWxkIG5vdCBiZSB1c2VkIG9uIHRoZSB3ZWJzaXRlLCBkb2NzLCBhbmQgc2xpZGVzLiAg U28gZXZlbiAiWGVuIEh5cGVydmlzb3IiIGlzIG91dCBvZiBjb25zaWRlcmF0aW9uLg0KDQpGdXJ0 aGVybW9yZSwgc2luY2UgYSB0cmFkZW1hcmsgaXMgYW4gYWRqZWN0aXZlLCB3ZSBzaG91bGRuJ3Qg ZXZlciB1c2UgIlhlbiBQcm9qZWN0IiBhcyBhIG5vdW4uICBTbywgdGhlIGZvcm1lciBzdGF0ZW1l bnQsICJOb3cgaW5zdGFsbCBYZW4iIGJlY29tZXMgIk5vdyBpbnN0YWxsIHRoZSBYZW4gUHJvamVj dCBzb2Z0d2FyZSIgb3Igc29tZXRoaW5nIHNpbWlsYXIuICAgQXMgZ3JhY2VmdWwgYXMgc25vd3No b2VzIG9uIGEgc3VtbWVyIGRheSwgSSBrbm93LCBidXQgdGhhdCdzIGxpZmUgaW4gdGhlIGJpZyBj aXR5Lg0KDQpSdXNzIFBhdmxpY2VrDQpYZW4gUHJvamVjdCBFdmFuZ2VsaXN0LCBDaXRyaXggU3lz dGVtcw0KSG9tZSBPZmZpY2U6ICsxLTMwMS04MjktNTMyNw0KTW9iaWxlOiArMS0yNDAtMzk3LTAx OTkNClVLIFZvSVA6ICs0NCAxMjIzIDg1MiA4OTQNCg0KLS0tLS1PcmlnaW5hbCBNZXNzYWdlLS0t LS0NCkZyb206IElhbiBDYW1wYmVsbA0KU2VudDogV2VkbmVzZGF5LCBNYXJjaCAxOSwgMjAxNCA1 OjQzIEFNDQpUbzogUnVzc2VsbCBQYXZsaWNlaw0KQ2M6IHhlbi1kZXZlbCAoeGVuLWRldmVsQGxp c3RzLnhlbnByb2plY3Qub3JnKQ0KU3ViamVjdDogUmU6IFtYZW4tZGV2ZWxdIDQuNCBSZWxlYXNl IFRhbGsgU2xpZGVzDQoNCk9uIFdlZCwgMjAxNC0wMy0xOSBhdCAwMToyNiArMDAwMCwgUnVzc2Vs bCBQYXZsaWNlayB3cm90ZToNCj4gSSBoYXZlIHRvIHB1dCB0aGlzIHB1cHB5IHRvIGJlZCBieSBG cmlkYXksIHNvIGFueSBmZWVkYmFjayBvdmVyIHRoZSANCj4gbmV4dCBjb3VwbGUgb2YgZGF5cyB3 b3VsZCBiZSBncmVhdGx5IGFwcHJlY2lhdGVkLg0KDQpOb3RoaW5nIG1ham9yLCBidXQgYSBmZXcg dGhpbmdzIEkgc3BvdHRlZDoNCg0KIkltcHJvdmVkIEZsZXhpYmlsaXR5IGluIERyaXZlciBEb21h aW5zIg0KDQogICAgICAgIEFub3RoZXIgYWR2YW50YWdlIGlzIHRoYXQgdGhpbmdzIGFyZSBub3cg Y29uc2lzdGVudCBiZXR3ZWVuDQogICAgICAgIExpbnV4IGFuZCAhTGludXggZHJpdmVyIGRvbWFp bnMuDQogICAgICAgIA0KICAgICAgICBJSVJDIGl0IGlzIGFsc28gbGVzcyByYWN5IChub3Qgcmlz ccOpISkgaW4gdmFyaW91cyB3YXlzIHRvby4NCg0KIkV4cGVyaW1lbnRhbCBQVkggU3VwcG9ydCIN Cg0KICAgICAgICBDbGFyaWZ5IHdpdGggIlBWSCBHdWVzdCBTdXBwb3J0Ij8gZG9tMCBpcyBwZW5k aW5nIGZvciB0aGUgbmV4dA0KICAgICAgICByZWxlYXNlIElJUkMuDQogICAgICAgIA0KICAgICAg ICBTYXkgInJlZHVjZWQgaW1wbGVtZW50YXRpb24gZm9vdHByaW50IiBwZXJoYXBzPyAodHJ5aW5n IHRvDQogICAgICAgIGNvbnZleSB0aGF0IHRoZSBmb290cHJpbnQgaW4gcXVlc3Rpb24gaXMgdGhl IGFtb3VudCBvZiBoYWNraW5nDQogICAgICAgIGFyb3VuZCB0aGUgZ3Vlc3QncyBNTSBsYXllciB3 aGljaCBpcyBuZWVkZWQpDQogICAgICAgIA0KICAgICAgICBQdXQgYSBidWxsZXQgIiogRW5hYmxl IHdpdGggcHZoPTEgaW4geW91ciBjb25maWciPyAobGlrZXdpc2UgZm9yDQogICAgICAgIGVhY2gg b2YgdGhlc2UgbmV3IHRoaW5ncyB3aGVyZSBzdWNoIGFuIG9wdGlvbiBleGlzdHM/KQ0KDQoiVGVj aCBQcmV2aWV3IG9mIE5lc3RlZCBWaXJ0dWFsaXphdGlvbiINCg0KICAgICAgICAicHJvdmlkZXMu Li4gdG8gKkhWTSogZ3Vlc3RzIg0KDQogICAgICAgIFRoZSB1c2Ugb2YgIlhlbiBQcm9qZWN0IiBv biB0aGlzIHNsaWRlIHNlZW1zIG91dCBvZg0KICAgICAgICBjb250ZXh0L2NsdW1zeS4gSWYgcGxh aW4gIlhlbiIgaXMgbm90IGFjY2VwdGFibGUgdGhlbiBwZXJoYXBzDQogICAgICAgICJYZW4gSHlw ZXJ2aXNvciI/DQoNCiAgICAgICAgRW5hYmxlIHdpdGggImhhcD0xIiBhbmQgIm5lc3RlZGh2bT0x Ig0KICAgICAgICANCiJHUlVCIDIgU3VwcG9ydCBvZiBYZW4gUHJvamVjdCBQViBJbWFnZXMiDQoN CiAgICAgICAgVGhpcyBpcyBkZWxpdmVyZWQgYnkgYSBncnViIHJlbGVhc2UgKEkgdGhpbmsgaXQg aXMgaW4gMi4wMi1iZXRhLA0KICAgICAgICBidXQgMi4wMiBmaW5hbCBpc24ndCBvdXQgeWV0KQ0K ICAgICAgICANCiAgICAgICAgTm90IGFjdHVhbGx5IGEgWGVuIDQuNCBmZWF0dXJlLiBOb3QgdG8g c2F5IGl0IGlzbid0IHdvcnRoDQogICAgICAgIG1lbnRpb25pbmcuIEFJVUkgaXQgc2hvdWxkIHdv cmsgd2l0aCBvbGRlciBYZW4gdG9vIHRob3VnaC4NCg0KIkltcHJvdmVkIEFSTSBTdXBwb3J0ICgy KSINCg0KICAgICAgICAiU2FtZSBETUEgc3VwcG9ydCIuIFNob3VsZCBiZSAiU29tZSBETUEgU3Vw cG9ydCIgb3IgIlNhbmUuLi4iIG9yDQogICAgICAgICJEb20wIERNQSBzdXBwb3J0Ij8gVGhlIGlt cGxpY2F0aW9ucyBvZiB0aGlzIHN0dWZmIGFyZSB0aGF0DQogICAgICAgIHRoaW5ncyB3b3JrL2Rv bid0IGNyYXNoIDstKQ0KICAgICAgICANCiAgICAgICAgb24gKDMpIFRoZSBBbGx3aW5uZXIgcHJv Y2Vzc29ycyBhcmUgQTIwL0EzMSBub3QgQTIwL0EzMC4NCg0KSWFuLg0KDQo= --_002_55E78A57290FB64FA0D3CF672F9F3DA21BC41CSJCPEX01CL03citri_ Content-Type: application/pdf; name="Xen Project 4-4 Features and Futures.pdf" Content-Description: Xen Project 4-4 Features and Futures.pdf Content-Disposition: attachment; filename="Xen Project 4-4 Features and Futures.pdf"; size=579573; creation-date="Wed, 19 Mar 2014 00:48:07 GMT"; modification-date="Thu, 20 Mar 2014 03:32:00 GMT" Content-Transfer-Encoding: base64 JVBERi0xLjUNCiW1tbW1DQoxIDAgb2JqDQo8PC9UeXBlL0NhdGFsb2cvUGFnZXMgMiAwIFIvTGFu Zyhlbi1VUykgL1N0cnVjdFRyZWVSb290IDE1MyAwIFIvTWFya0luZm88PC9NYXJrZWQgdHJ1ZT4+ Pj4NCmVuZG9iag0KMiAwIG9iag0KPDwvVHlwZS9QYWdlcy9Db3VudCAyMS9LaWRzWyAzIDAgUiAx NiAwIFIgMjIgMCBSIDM1IDAgUiA0MSAwIFIgNDUgMCBSIDQ5IDAgUiA1OCAwIFIgNjQgMCBSIDcw IDAgUiA3NiAwIFIgODIgMCBSIDg5IDAgUiA5NSAwIFIgMTAwIDAgUiAxMDQgMCBSIDExMCAwIFIg MTE0IDAgUiAxMzAgMCBSIDEzNiAwIFIgMTQ1IDAgUl0gPj4NCmVuZG9iag0KMyAwIG9iag0KPDwv VHlwZS9QYWdlL1BhcmVudCAyIDAgUi9SZXNvdXJjZXM8PC9YT2JqZWN0PDwvSW1hZ2U1IDUgMCBS L0ltYWdlOSA5IDAgUj4+L1BhdHRlcm48PC9QOCA4IDAgUj4+L0ZvbnQ8PC9GMSAxMSAwIFIvRjIg MTQgMCBSPj4vRXh0R1N0YXRlPDwvR1MxMyAxMyAwIFI+Pi9Qcm9jU2V0Wy9QREYvVGV4dC9JbWFn ZUIvSW1hZ2VDL0ltYWdlSV0gPj4vTWVkaWFCb3hbIDAgMCA3MjAgNTQwXSAvQ29udGVudHMgNCAw IFIvR3JvdXA8PC9UeXBlL0dyb3VwL1MvVHJhbnNwYXJlbmN5L0NTL0RldmljZVJHQj4+L1RhYnMv Uy9TdHJ1Y3RQYXJlbnRzIDA+Pg0KZW5kb2JqDQo0IDAgb2JqDQo8PC9GaWx0ZXIvRmxhdGVEZWNv ZGUvTGVuZ3RoIDQ4MT4+DQpzdHJlYW0NCnictZNLa9tAFIX3Av2HuxyFenTvPDUlZBE/QgoBtTGk ELoQ6sQ4tWUqyaH99x05TmvFVrLqTiPOPefMNzOQ5nB+nt6MryeAFxdwORnDzzhCQI6IJARasAJB K4Tax9HdGVRxRLD4q0E0hKonejiLo89xBNObMcBBAP0LGO1ntTN2n5VJolNZQnLnIKSBsZzQgXaa I4HgxhiCch1H6fW6WHgNkw2cyhX/e2PyKEAoRepEQJoXbevrCsomGGTQlFU3IxE5yZ2eDHFyb8ap g7jnpojyHYzCOK7tDiMpyyWBpEBRAJHlLjvA6IYw6n3s5TxIZ+EALMwfOmY7U5DBkDIQ5DhqmK+7 fQWa6dVt2Nmi6ZZXcXTPvmybxq9WkFiWF0+rZTISrPQ/km8w/xRH02DeBby4aiRuDk3vGRxIj0qa o5I8HMapopQF5mrv+dVXAwWkFTxTfTUMarMjbV4nmm0efdnC9KmoFn61bNoPkBCx8bKtE8WWv177 DdPtzs6+WN/+blq/bgbKKIHcmf7Em+hsD50Aabr5XomMu/AkpFFcv0/OhWCR9dVD5AhN9wB62rze PCYjyQK67o5AMrJMcfUxfCg280W7rX0TFo4V1XfoJLPt7t9AhiHJtRnuswPyBxcTC+8NCmVuZHN0 cmVhbQ0KZW5kb2JqDQo1IDAgb2JqDQo8PC9UeXBlL1hPYmplY3QvU3VidHlwZS9JbWFnZS9XaWR0 aCAxNjUvSGVpZ2h0IDY3L0NvbG9yU3BhY2UvRGV2aWNlUkdCL0JpdHNQZXJDb21wb25lbnQgOC9J bnRlcnBvbGF0ZSBmYWxzZS9TTWFzayA2IDAgUi9GaWx0ZXIvRmxhdGVEZWNvZGUvTGVuZ3RoIDk5 MTc+Pg0Kc3RyZWFtDQp4nO1dBVxU2fdfu9decxFExO5uEUQRDDqku7u7u7tmGIahWxpUMDFA7BYw UBFQsQP4f2eejgiDi7vG77/r+ZzP/dy579xz49x74r373vz22y/4Bb/gF/wjmDd33sIFi5csXjJ6 9Oif3Zdf8C2hb9++mzZtsrOzz8jIrK6qfvfu3du37560vLt353HrE+TfouTevYZDFYeCgoIlJSUn T578s7v8C74aBgwYICQklJ6W/vLlq/fv30Omz5+/uH//weXLV44fO56VmRsTTc7bV3jq1OmrV64+ ePDwxYsX7+gAyvdnz543MzP/Jff/FzBw4EB9Pf2mR81tbe1v3rxtbn589cr1QxVHsLspFEpISKi7 u7utra2ZmZm9vb23t3dkZGQiLTE3N/fYscrr128+fvwUtd6/b2t7356aksbJyfmzB/QLeoS9e/fe vHGr7X3HmzfvILg7d+5evXr1zJkzx44dKywsTElJiYmJ8fPzc3JysrGxcXV1DQwMjI2NRXlBQUFF RcXp06ex/aEEoAog8fa2jvfv3oeGhk6YMOFnj+wXfAabN/NUVZ15/7797Zt3z5+9fPz4SUvL4+bm 5vv379+8eRNyPMOA0tLSzEz6NoeUkdJotOLi4uPHj58/f766uvrs2bO3bt1qbGx89uwZNHt7ewcB +Ono6Dh48OCfPcpfQAcLM6u3b9pev37b+vTZ45Ynz589hw/W3t4OiwzZnT9/Yf/+/QEBAXp6erKy srt27eLj41u/fj0PD8+OHTvExMQUFRVNTEzi4+MPHz5cV1f/9OnTV69etbW1dXSG9o5Tp079+eef P3us/2nAjqNSk5+1vnzy5Nn9+w8fNT56/vw5hPPmzZu7d+9iw2Ivk8nk4OBgbE9DQ0N5efk9e/Zs 3bqVn3/b9u0CO3fulJCQUFNTg7hdXFyCgoJAXFZWBoWA3f2ZtNs6IP97dxtWr179swf9H4UpU6Ye qjje0tL68EHjrZu10NvYzhD37du3ob0h6PT09OTkZEgwLDTcytJOTlZRUlJaUkISe1xZWRmbGrZe WnqvjIyckqKqi4tHbCwJ6j07O7uoqAjmvqGhgZA1djrda3/fBmPx6sUbeTmFnz30/xzM4p5dc+ZS 48Omutrbly5drq+nK+E7d+5A0IkMgAOWkZERFBiioaED+aqrq2trayOFoOXk5FCCnY59raWlpa+v j90NVa+goGBkaJqUlAKDXlJSgrSyshLmAKEc1PvLFy9fv4baePv6VZudjePPnoD/EEz4Y8LRI6du 19+9ePEyTOqVK1ewo6uqqtLS0qKjo+Pi4rBJI8Ij5GTlIFyIdffu3Zs3b4YeXsmA5QxYsWIF8RPl W7ZsAQ2IIXosCU1NzZycnPz8fKRZWVlw5KA3WlpaGhsfNTe3tLa+eNzyUllR/WdPw38ChgwZmp62 7/r1W9XVNYieYKAhDnhZiJhgfMPCwiIjoqGlsX/hhkGOEOuiRYtmz549ffr0qVOnjh8/vjM3lHBw cHBzcy9cuHDZsmWgR11YeSUlJR0dHcgaK4du0EvLmpqa4A/U1dU9uP+QoVUebt8m9LMm4b8DVlaO 1dXnDuw/mJSUlJubiz2YlZllZmZmZWXl4OBgZGgGf1tISGjdunULFizg4uKaMmVK75lD7oTQofCh /MXFxWOi6aE6HDnojYsXL548efLo0WNYYFWna4oLKyZMmPj9RvoL+LZsLyo6kJ9f6OnpaWpqamxs DJu7lQGIsNasgZDXQW9v3Lhx7dq1UNRLGbBkyRKkffv27U0Tw4YNg9ChE0RFRVVVVVFRRkZGREQE Swg/3d3d7e3t7ezsvb19HOyc1FS1lnyEpZ8DSqA3vveE/Ith+PARkeHk8vIKe3uHoNDQK7W1HV8D do5f4V+xsbFB6HPnzqVSqV/VCuB6ff21+vq0nJwJE3/t/b8PSgpaRYWlaWnpEDe2MzUx8Xpd7dVb N89duVx9/tzpc2erzp1Fpjteun4NUoCDvXrNmt43x87OfubMGVS8cvNGd55o6zQDkUcHLt+4js5c r68F8aUb12BcBgwY8P2m4l8PkyZO8fUJKSku8/f3hzHV0NCAUT56/Pj9R48aGhvr7t69Xlt77dat G3V1LBH+NF1wN26MHTu2N83x8/M3Nzejyq3bt8G5CzeiLaS4eruhAX140NR0v7HxTkNDTU3Ntm3b vvds/OtBZI9MVGRseHiEr69vYGCgq6srLOOsWbNu1tY2tjQ/ffEc2Pz0SdOTxy2tT4GPn7USSPxE OaFpEVv9ZVvw+gjih81NYA62BEOCFbMVtNj68gXK8fPBo0b47YWFhdAJ338y/uUwbux4C3OHjPRM SNnb2xsbXEtLa82aNRMnTsRWetj06HHr05dv37TR722zQPqdsY6Ot+0fboPr6ur21BD8NKwHguzZ yxev378j6jD5MHm+bXv/4s2rViyz58+aW1oQoGEdDh069EdOy78V1q/b4unhGxkZ7ezsDHGHhYYh VuLh4Vm2ZDlMJAzlkydP3nd5qNEzvHnzBm5z91YQm1+/fr33Lllbe/vr168bGxsvX76MaP3HT8u/ Evr06aMorx4TQ7a1tXNyckIIbGhoiGhr9+498Jw5OTkRYcXFxT179qyd+czyr+Dq1au///5751YQ aoHDV8i6re3FixcNDQ2HDh1atGjRlMlsf06d9rOm6N8EkyZN1dE2iokhOTg4QpkHBARgX2/atGn7 NkHMMyz44MGDR44cWV5ejvnvvcQTExMJ/lgtiOJ7L+gOhpMPfQI3jUKhjBs3butWfsEdO3l4tnfp OWwNAnA+Pj4E7GoMQGbt2rVz5sz5YbM3Y8YM5j0BZBBd/rCm/x4sXbzK2Mjczy/A0dERytzNzQ1b G4HYtGnsUL/wtAmLycXFBVUM7dp7ievo6IwfP37//v29FzSYwxY8evSotrbWyMhozJgx6AlD2/By zZiLYEFKSioiIuLUqVMg+zIr9DYhIQF9+PJ9v2XLlp3qBMnJyRGsQEjo0x3d0aNH6+nplZWVYU12 b/fly5clJSUKCgq9vO/0g0FQQMTGmn4ji9DkmB9sbWlpmUmTJrGxsQ0fPpxJCYMOQbx9+7aXsoNE 4GJ9lawxVw8ePKiqqoKGQYsSEhLwFZFHr86dO9d7Vl0AFmHdunUsh6+trd2bjoEMxPPnzyeTyehk bxpFh//XDuPBcO+VUXF2cnNkaHKEYJheiHuHgBA2JhRpF2dYX1//8ePHULZ/e+Z7AhhrGPc7d+7A dccyGzsWjY+DhrSzs2M5vRABqmDt0R+evnyJpYVefVnzREdHDxkypMsMQAP0pnv8/PyIH/9SpXSB mzdvjho16seJ869gxIiRigoavj7084Tu7u4w3JsZMG0aB+w14qZBgwZ1qRIVFdXa2tr19BEraO9o b2v/CzIQvH7zGtjCiLbQB6LFaWzTIOuLFy8SZG/evgEN0rf0k+z0o1MwK4TOh99+6dKlGzduQC1A 7u10kbcTTb9vew9iVESG4HPs2LEuEr916xbRDQLphyw+4rv379AiURF6vvvomGy7l6PdDsaaxMT+ OHH+FcDj3Suj5ObmAZMNhwqxLWQNpd2vXz/IGlEYMl2qQL0XFBbcbbj3qLmJwObHLZ2xqaW5EcWM DHGVIMPPzvn7Dx/cuXe3tr7uVl3t1WtXL166KCYmBv79+/dHCiVDbGo0VH/nNijv3W9AlYePGgmE cAsLCwUEBAhzg03Ey8sLoTAbIrrxoPFhw4P7qA4kxOHn788cy9Q//wQNUYVA5qCARHUUPn76BCka RWdu370DVuBJjIVZkUBmu+gq6t6933Dt2rUfKM+/AM7p3HKyKp6eXpA1Im4IHYZSVJQ+7QMHDuzJ 2Zg8Zcr+iopzly9Xnz9fc/Hi2UuXuuCZCxdwCUhkkBJkSIkq1efOVVZVHT1xovzIkdKDB5NTU7ln zfqNYVyQLli4ELJuffXqRFXVierq0zU1RC0CzzJSWnLykI+GhqgFmDN37vkrV4gOfNbouXMnq6tP nTlT39BQdfbspI8vNfBu3fqwuRk0RG+ZyKwOBP0JRlcPHjpUfOAAhUbLyMnBzzPnzxPMCWImMseL ilXnzl28ehUO5/eWYy9hFvd8eTkVH29fyNrPzw/mG3tEQUGRuMqcxu6wctWqAxWHyo8cPXTs+OHj ld0R5UzsXFh+5BgyBw8fKSrbn1tYlJ2Xb+foNGLECCZnBOzQ6k1Pn5VVHDpw6HDFUTo9UlREeqTy BLD63IXp06ez7GFeYRFaASWzaSJF9f0Vhw6iw8crN2zaRBBr6+o2tjzFpc697YKl5RUFJaXpObk7 BIWYnsySpcvQty6jY44RrRN45MTJk1VnJv7PPLmbO2fR3r1KELe/v39QUBACMYSxamq9OjgkLiVd dKCioOxAfun+XmJeSVlecSnS3KKS1MzspPRMUQnJLmz1jIxfdXTkFBSDhl6luHRfUSlSonp+yf7z 125m5xf11KuT5y4UlB5Alc4IVjmFxcgUHSgvKT/Ew8tLEHsHBB09XY3yHrtaXJqWsy+KTOGcMYOo wlxg1vYOaOhLIy0pAwGa6+4f/iyYM3uR7F4lTw+vYAZgdyPO1dDQ6GV1/7CI1Ny85Ozc3mNSVg4t MzshPTMkmjRv4aIuDCdPnXrwxGnwTMzIBjHSRKyKrByiIvJp+/Iv3KpvbGw8zYBTnwNK7rQ8jU9N 746U5NS45FRkUnL2bdhEj/IGDBxITc8EQ7Bl2U+UowOU1LRNPFu6j11MSvoLYye6nZCRFU6O/2ci +pYwc8Y8GWkFdzePsLCw8PBwHx8f+EgqKqp/WRErNj4+vvldByU1g5SU2nskJ6eRktLsXDzGsHpU KrlX7kj1+eiEpNjElJiEZKTMikQJMjG0ZHJyelJ2XnpBcXbx/pzSA0iBGYUl1PTsKGpiGDk+Ii6h C4bHUUNi4sJI8WC+ZPkKtMXBOQN8YmgpwO79RCFajKYl+4dHsTRqIlLSmUWlLMdI7yq9empUfKKK Vo8PjH4YwAcjhsDBPlNGmu6ZI7xCWIoNDl9XXl7+y9U5OTnPnDnzpK2DlJweSUmMjE/qJUZRk0nJ GUgH9fCKkLmdAyU1CzzD4xK6cqYkRlBoSEPJ1OAYcnBMXCgpHmQRDOIwEjWMTEUmJJYSEkPBpc6I QtAHRsYGRMSEkigzZtJvdfJs5S86UsmiIUZb9PL4JPBU1zVg2VV1PYO0ghLWw2d0FYimV65hfXvn RwLCKyK8nTRxqpiojLW1LYlEiouLI5PJggwYOnRYT3V37Njx5MmT01fqSEkZ0QmpwNjEtF4iKSm9 oPxYy/sOZU0dlswjKUmkxHRQxtBYsEVbKA+PowVGknxDI/3CogMiSIGR5IBIsl94NBCZwG4YFEVH UPqGRHoFhYfGJhAuvZqOfl758WhqSve2UMIYVzra4t22g2VXfYIiEzL29dRPpFEJKWDOUon9YEBs S4Srw4f/Liq8V1dHH4KmUqmpqalCQkK7du3i4eFlWdHBwQGha9nxanJKJjVjH4EJmXkfcV+nws7l nzApp/Du07f3Wt+u3bCpC/PBgwcnZhUQDFlyoGXlJWUXKmpoT2PnYOOYPu1rEbXY2dnYPxxoDIgi ZxQd+Lz/nw0E0oxPy2afzuJG6NQ/2ZJzi2hZ+SyHSXQ+Li3bNyzqW4rtH8Do0aNHjhzZ57c+u4Qk 5eWUKHGUxMTEtLQ0WVnZPXv2mJiYd6FH8FhYWAhZZxQcoKRkYyqScwoTM/Mx/8gghaTwEykzT1zq jPRLmfm5pYfpa+ZY1aQpUzs3MWz4cLClpGYTdZncmHzS8koyi8p3Cot9g+GPGZOSW5ySW0Tw74JE u7SMvChKCsubD5t4tx49ewVkxKC6Vs/MT84pSkjfp6Fr+M+7+k0A4ibeuNywnl9CXCY8PIJGoyUl JWH/CgsLm5l9Ju6lS5ciFr7+4GksLS2KCscmk5KaQ07OjEvJQiYuJRsZIo9CXGX8JArh2eYwET9B gEx2SQUk7hkQNnDgp5u0cCdCYmGOE2MS0ggygu1HzE7dVwoUkZD5jVXEPWfOnCU9A/GAkmvmTIJ4 2crVuWVHmV3qjMzOx9DSDUytWM6ekob2/sozRA97qJ6N6us2sXDpfwqMGDGCnZ196NChs7kXSojL urq4QdzJycnY4+Li4tLS0jNnziIolZWVX758mV9+PCACpjAuJJYaSqLR09iEMHIi8sjQkUQLiqaA hiD7UMigYeIHYnr1hPTCA49edciranbulbK2vldwhG9YDJiAG9HWh4okGikpq+bGfUsHt+7DgXv5 5ZvzKXkl4LNxCx9BLyIpU1BxIjiGSvTnM4yFv0cNiqb6R5D4tguynD1HT38ItKfqKA+MiguKjvtj 4qRvKrS/D7DdHBwcbGxs48ZOEBeT19TUTkpKTklJycnJwdRJSEhoaekMHDgwMjLyeUdHCCnJ2SfE xS/MPTDSIyjKPTACqUdwFDOPclwFjaNXoKNXkJN3MH6C4BMlExnERJpVdqy08tyK1euZvZo2ndPW zdfew9/BM9DRO8jJJ9jZl96um3+4W0AEuKUV0tWCv78/divoMQR+fv59+/a96+iIomWCgMkc9K7+ Ya7+4S5+oegPGGoZWTAfAWibWAZEU1EO/izQJ8TJO8jFN5Rp6DsDjI5PaKyrXxjRve6IcnC2dGSx LH8iTJkyZcGCBcOGDRMUEJeWkkUslsEAT0/PjRs3Lly48MSJE6XV1209Ai2cva3d/JCxcQ8AItM5 j9TS2cfc0cvM0dPEzt3U3sMM6Ohl7eZPXCXomUhUBNp5BxefvBQQQ5sw6dMJhIXLVhjauJjYuZna u5s5gI8nEMzNnbzM6Tz9YlMLXnTatshTssscfUIJziAAWrn6Wbn4Wrr4WDh5mdh7GNu5yWvqj/h4 ngqeKi5ZOnt3buIzdPAwd8BYPFhG3DNnz3MJiDJ18DDtqS5Se89d4v9b5+vGjh1LvM23cMEKaSkF SwurzMxMqHRnZ2dePr6bzc1B1H26lq66li761u6Gtl76Nh4GQFtPOjLy9EJrdx0LFy0zJy1TRzUj W2U9i1nzFq3ZtFXL1EnPyoUgIyiZ+KG6rSfqmrsE5Z24rmZoM2jwhzuNXFxcM2bNVdA2UTW0Vje2 0zS11zJ10CTQxEHLzBH9IRgSTIiMnpUbynXMnXUsnLXNnTRNHTVM7MFWzcBGTtNk0bI1nQU3ccqf GJemiT0dmcw7oYaJg7qR3U5xOZbztpZnm46ls8aXqttrGNvNW7ziR0ix1zBq1Ki5c+euXr164sTJ 0pLKcnJKISEhurq6Vm5uh+reGrmEKOhZK+jbKBs5KBs7KBnZI1UxdkRKL2EUKhrYyutZy+la7tUy l9Ew3S2rOX4ifZ/2HzBASFpVTtcKBJ3rMpEoRAapoXNQbGEV325pVBQXl9y2bRucimHDf1++nk9E QVtCxVBSzVha3URaw0Ra01RG00xW2wK9UjK0I5DeB10rWXRA01RK3URSzUhCxUBMSU9CWZ93p+R0 7nl9+/XvMvDZC1dIqRmJqxhI9Ij64DN/+VqW88a3S0pC1fCL1Q32apqNGvvH95bg1wKc8w0bNkCl r12zhX+r4OIly30T84OzTu3VcxBTNZXQsJDSspLStJLUtKRntKyRfshrWomrm4NGVMVYWNFgt7ze BgGxIUM/nXQaO2GKiLKRmIqJpIblp1p0Dkz8UIjUwDXCPjxr1qKVAgICUlJSlpaWGhoay5cvHzBw 0DSuuQtWbFq3XWybuIqQjKagjKaQjNYuWZ3dcnq7FfSQ7tyrs3OvNnFJQEpjNd8u7kUrJ0yZ1n/g QGZnuujk8ZP+nMY1bxrXnJ5xLjv3/KEjRrKcNDauOWwz6NhTdXauuRzcC76TyP4JjB8/nngDd/So MdO4l8SUX7cMThVVNxNWMRFVMxfXtPyIVkjFNOiIvJi6hYiq6R5lY2Flo53y+kLyugtXbeken85d vmGPkpGomhlRkVGXBYppWICndXiWhl3g+MlskpKS1HgqhULR0dFZsWLldHaufn0/BGuDhwwbOWb8 JHYuYraZOGU6N8pHjum6m/ow4EfM4/8fmDZt2vz587eKSGWcf67jGimmbi6uYSGJ3adjI6Vjy0Cb j0j/iUsggBBFVU2FlY13KuhxcM9nyRluMJ+YMhhKaFp9rG7zOdoyecoaOvmkHMVC2rVHJC4uLikp SUlJSVRYQlBAZO7ceYBx48b15klib0SMiGMYA4Z/BJbHtHrZVnfoQqampraPAc5ubj/9YSgCcCd/ /7IbrwxcghWNHJVNnVXMXJEqmTgh7YwoUTR2VDC0kzewldWzltG22COvPXbCl0LLcRMny+rZyBvY oWIXbp3ZEo0auYVTyy8Lyajq6OpqamoqKaoqK2lv3MAH72LWrFldzoT0NLe9gaysrOZucOfOnby8 vE0fTz58Q6AkJp69fPnClSsFJSXfQ9ts3rwZsbOCggLs8pcpEYsdOnSo9OIDa+8IU5cAY0dfQzu6 56xv62GAjJ2X4Uc0IMptPPVs3LUtXDTNnIRlVIYOG/5l/oA1m7fqWrsZ2DJc+k4MP2Nr64G8iUtA aGrxvlM3N/ILrVq5WlFRQ0ZaDfMPcU+ePLnLayl/G6BzDh89+rCl6WFzU3PrU2DT0ycPWpobGh8S kZ2Xl9c3aYiASZMm3W64V3/3zu3bt01NTb8hZwKgqcAZ3X78rNXMzOwLlFgMDQ0NB2tueYbFIZB0 9A2z9w6x9Qyy8wy28wpGvguiEJcQTVu6+m4VEu7bt+upRZbQt18/NQOLnnh+4OxJ5+zgHeoRSq68 +iD/yLlZcxds4xfZwsMrJCSE8KHLJ1/+CSD8bGxsfPPubUtLy4ULFyorK0+ePHnr1q3W1tYXr+iH ITEnMBzfqjlYCn5+fj4+PqRf9WGTXgJsMXEO/N27d3C5eyITkdybnF8WQU0Jjk0IjKL4hcf6hEZ7 h0R5h0b79IC45BkU6RoQumzlV7y2D5jKNs0jKMIrNKonzsym0Y3gWFpMUlYImTZ6zFhsbfjnCB++ 4Wlt+KUdjFceamtrubm5wXn06NFTp0718/NDYXt7+9OnT7du3QpKLDMU+vv7E7tSUFAwJydHX1+f yap///5YjSQSCRry4MGDIF64cGGX5sDEiQGKiopdLsFlgiYpKys7fPhwTExMT58QhGYzMjLKzs4+ ceJEfn6+jY0N80PxWlpaKCGU0uvXr8PDw9FbUVHRztUHDxmiZ2JOSUmPjE8II1GC6c+Co/zCIgn0 D+8RAyKiXbx8ODg50TH0/6vMnOAe4S9wBjJbD4qMiYijxqdluvn4YUKwer/tSU5ra+sOxqs9kFFn S4p11dbWhp2CXU+I29zcnJhJaADEhh2Mz7cy30WFbkT5h7PlH19nwIIxMTHp3BzxlgrYlpSUMAvh Fvr6+jI+DNtOpB2MFytUVT87R4TlpK6uTrya1M4AopWzZ88ingLBtWvXOneAeDXD3t6+y5AHDx7M MZ2Tg2M6O/1BMMc0dgZyfER2duLR8KcSBs6YOXPlypUIlGxtbSMjI1NTUw8cONCdOUtAz4mGurPt jugVB+eMhYsXc0yf/g3VOAGlpaX0W68vXmDCf+sUku/YsYPYI3V1dTC4KIHnRkwmXfm/eYNpR4b4 /o+hoSFBjBJoCVhPLBLidSrMPLFaCKDRaCiEpfDx8SFKsDdhPiCaR48e3bx5k/iWIFgRZGxsbMy6 mZmZKHz+/Pm9e/fQCpzJpqYmEN+/f19cXBw+NjxM4vu0qI5L6EZ9fT20UC+nAhygOqCRVq1aNZOL m49XUEhQWEhol5KSMjYFOkylUsvLy6FVEFZAvSCFMoEeO368En0Dzdq1n92JwtrArGLIYWFh0Ejw HqWlpSUkJOB4W1la2dnZOTg4wMFgHKjYwrOZb8sWgTlzFmJTz549G5buG9pQAsDwZm1tO0MowsLC zPKJEycWFxfX37lzq66uqIh+zBWe4cUrVx40Nja1tDQ2NdUxyslkMi5BgTPed2jA/EdFRa1btw4d 1tPTq6uvv9PQ8Ki5OTc3l1hFCLuqa2qaHz/GYsDYibbc3N1R/d6DB9jv2KSIAaEnb9+92/LkyfOX LxF+/sZYhNa2tkQrV69exRTBLq9YsSIkJKSmpoZ4P3HkyJFSUlK19fVPWlsbHjzw8PCAoDGor/pP ECxsdB5LHVpr27btWhqmdjYudrZObm4ekCx8Gwz84cOHWOrXr9+A0cHQsAsKCgoKCwsxY6UMKGPA /v37kaIQqyIlJQVzFR0dnZaWBgJUPH78OJRDVFS0hbmFnq6hnq6xjpYpH68ALy8vjMWMGTO+x3fO ly5dWllVdbWuDuIOCAjANEJLQ2QQx/7Dh3MwjLKyVYwPCi1dvvzY6dOHKisrjh3LLylBIfE0DXo4 NSurrKICqKnz2REsfSOjw5WVR06cOHjsGGGAZs2Zc/TUqePV1ZXV1VyMd4GXr1xJtw7V1Wio8+uW 1vb2J8+ePVlTY2lri5/TOTnrGhpKy8vRq1WdPnCEPvzZaftPnDQJzNHPoydPcv3dd43hGmFaoC7g lmAzaqgbhQbFhQTHREbGZGZmXb92Hc4M3Y998QI6BHKvra07deoUdj3WAyF3bATiw6cAQhtgnUAd QQthqUDtYF+gPDQ0zMXFzcXJw8XJ18TYUXDHLhERESx1RNmEOv3msGEzT2nF0bScvOKKI7UNTe86 Oi7erM/IK6SmpMfE0yJIlC38H77zs0dcvLzyVGo2/Qg0D98n5bxhE8/ZKzeTMnNjKIkjGQ4kM/xf s259VkFx+r6CpPQs4hL/jh2VNedREhZNGsi4jWNiaX3y7MUjVTWYELh22K3Eke9DJ6tTc/JSs/NV NemvmkrJyFeevZCcmeP8MSpkeZNhCx//6QtXM/OL42jJXzhe+JcAB2nRokUCAgLQuvAWZKTlHex8 oyISYqLiyaT4stL99XX18HZeM75a+57+bxNthC8BVwE7BTYFKcRK0LxkADIwQzBYVVVVcXEUP19/ H+9AX59QT7cwZSVtcXEJaP6NGzd+P1kDhCWkc0rLQ2MpQTHkoGhyQFRsYESsX1iUd1C4hp4hW6fv /Kho6sQmpYWS4rUNP3O9tPSNcvZXkJPTlTS1ujAX3CNCSkoLiY2zdv7wpFtT3zghMzeSmqSqyTh+ 3KePo6dvFDU5KiE5JjEN5RH0M6uJ4WQERyR0A+mqdfSn/w4ePrSsPHJKxjbBnV8YjqqOXmJOfnRC sn63w2ZfC4hNEERg/mVlZQ0MDGBTFORVfLyiSDHJsdHUeAotMwOhwcn6+tuQY0+vABMfr3716hWk f/78eez7mJjYkOCwwICw4MCowACSrra5hISkvLw89jWMIBcX13f9rworZ/fohNRQcoK5g4v4XgUJ WQVRKdkt/ALdjzFYObnFJKZHUJI2bP7slKaZnRM4ZBYf1DT87J7JgAED0ov2h8XRwik03m0CKOnX v797QCglLQd8eLbSlcaAgQO9giOiaWmUtGxFda3dohK7xCSFJWR2iUhsFRDCatkpIj7i95Fg5Rce HZeanZCVt2PXnp7Ggs3u7O1PSsmkpOcI7OyR7KsA848IhZ+fX0VFBUKXk5PT1NAP8ifHxabFkZIT qKm0hJSMjOzDh4+eOVNTe6sWlh2KGp4kXMQbN25cunT5yJEj+XkFZBIlOio2IiI2IjwuMpwaGUYz N3USExMnPqULBQ5lwsnJ+c398M4ABUtKziCnZMYkpS9fzfrhJgHDh4+IoqaQU7PIKVnzFy7ufEnX xBwb82L9w8fPnmFmiEIE74hTqOn7omkpAVGkQYPop+hHjxkLDsm5hZDa7Hn0xwp9+/XzDAxF4eGa S+s/fzOlc7CMKMbdP5iUlPHodceBypNMHQ4X2tPTk3kgZ+iwYaGx1KzigzU37mBX0kuGDv3nn4yA KZ8zZw58dTiEGhoacLCVlZWVlFTMTa2DA6Jp1JyE+MzEhAxaQloCNQXST6RhDWAlJFHjk+LiaGRS AplEI8UkxpFSI8MT7Ww91FS04FJi5cBF37Jly5IlS6DAv8cdpy4wZ/7C8LgUr2Co7sg/GLf6e7rr PnP23ODoeG9QBkeN++MzbbNoyXL3gHDvkOhXHR0wTPD3YIIRTwXHJngFRzp6+KMVgpKdgzOKmg4+ /uFk5qE1JQ1dz8CIQ9VXYddcXV0RaCOcuXTpEqrvFpXs81FYO3YJewZFBERRoCHh0zo7OyMmgt2M oWUoa+r170//YuTYcX94hUSHxNJeMr4U4RdO0jGx7OWtzr8EWPN58+atWbMG3j4UOwJPyF1NTU1O Tt7MxMLJ3jUoIDKBkpFCy0lJyklMoCNWQlJCTmgw2dPN39rSXl1VU0ZGBksFigJ+IB8fH3YHAq4f 9hckvNt3mjq4G1k7K2sZf/lRxUbe7aA0tnFR0jbqfnWPpJyBlaOZvbu1W4C9N/32r6WTt4mdq5ax FRvHp0Ppq9ZvDqGkWzr7aJlYEy+tAyZMnIyfhlbOZvaeVq6+1q5+5k5eRjYuRjau23aJMns1bPgI dUNLQxsXc0dPxu3lEDuPIAtnH0tXP7G9SgS330eONrFzQ11jO3czJ0+wEtjzDY5kdwYODg6EaQgA N2zYALnD5urq6kL08OHh1CkqKsoyQFNDE2EmhIstjLWhzgD6A01RUUgZcRZ2NDRG51sKPwA2btu9 S0ppp7TK8vWsX5pgwnq+naDcJaO6fB0LykFDhi5euWGnlLKMpomclrmcjoWguOLSNZuHDh/RmWyn lIqykb2CntXmHSKdy8dPnLph604xBW0pVUMZdWMxRZ3NAsLsXF2/FjVm/IR1vIKiijp7Ga1IqRtv ERSbMefTXfE+ffouX88jLKcpqWogqaq/Q1xh/ITv9Wd8sLPY7MuWLcN+5+HhgZ7HhoX0sXOh8Ilv XkH6kDhEvH37dhgXmAMYaEgZa+anvPLc+4ePfXphAfv26z9i1NjR4ycOGzGqy6U/prBvFVexicja o2S8W8n4zxksPvw1eMiwUeMmjBr7x8BBX3oCPnDwkNEMskFDWMdZqD7899GD/0EU9lXAzs7Ozc2N LY8Ni10Pma78CPgJdb148WIsjJkzZ3b5jtNPgd4/Iv8yZfdLzBLMv5S2pZFHlJSWpZi6iYCkav8B A79cvfdd6g3Zj4fJkyd/v9j5fxzG/THRxMlHz8ZN28JRQct40q+PPf6rYcy48bvEJAR3i2zk4ftf eP3zF/wX4P8A1crmYQ0KZW5kc3RyZWFtDQplbmRvYmoNCjYgMCBvYmoNCjw8L1R5cGUvWE9iamVj dC9TdWJ0eXBlL0ltYWdlL1dpZHRoIDE2NS9IZWlnaHQgNjcvQ29sb3JTcGFjZS9EZXZpY2VHcmF5 L01hdHRlWyAwIDAgMF0gL0JpdHNQZXJDb21wb25lbnQgOC9JbnRlcnBvbGF0ZSBmYWxzZS9GaWx0 ZXIvRmxhdGVEZWNvZGUvTGVuZ3RoIDM4MTQ+Pg0Kc3RyZWFtDQp4nMVaaVhTVxrORlYggZBAWBJC 2AnIEiCAgKCyJ4AKWKjFBRRFXOqCKCrbqKh1F53i0pkKHcfRap1agWpbatW2KOoDIiBQFARErIiA QJY5FxK52ViepwPvD57cs9zznu985zvv+S4IxDgw51jZWFmwjMdrNz0wMLZ08Z0bEhYeIYgIDw2Z 4+PINqJONykF6DGsPGaHCyAI12/e9LEQ+hUW4Mqmk6ebmhwUIzt/wHBeztcPWqUj6Gm4eSxJKAjx 4tB0p5veMOhWfhGCBfvvi6RKePHvZGGoh7nB9NPUZ/PDBDHnepUZjqAiTRjsZqZHnF6ONLu5gqgT XeopAoh/SBLOtqGSppGirrFLWGRei0aKEAauLAxxoE0fSzLTJyL60pgUITxLDZthqD1NHHXN/YXx 98flCPZ6lsDdaHpY6jD9hamtCmwkoqH+dz09fUNDIgm8XHQqyp0+HStOMpkpTO+BM+ltr/rh4tnD +w4Uni+p+KOrXwyrvBrlajANe5zmLkjthlFsqyjOSgwP8PF09/D2mxuz9viN+i6YOYsiHfTwU82R bBOW2P6Bgrj99uHEAFc7C1MaVGnKtpnBj955vfb1KMvjIRxd3NRyJDEDF1R8INB3//SqYD6XoqOF HG1i4xGdV1bz4Rx6vy3CxkgPgEImoqeGJJUX9eUHjr1PbxSdKsjP373NnYKCTcTGa8XFx4PyVm+v nDq0Pz8/P2/DHBJS85v/OpDYISn9aoLN3Zna8PGtgg6+Vm30LBo+lf8fqO4LKtVwlErOOWI/NEIS 7XPfqLZp2OyiMxUkiaygLHUcpdL+LWZyh0ORvYoGVBqIa/LmmuCnYrkpTjHV6klKX8zTH2GAoof9 qlo9VJEXZqEzFRsHzwjYLg+BPco07s4kApZIrHlysxpDl26aaUKYEo8kWUX9KBu1/SdlrxOfstVC IElO+W9VOUrK13sYYqdkayN0uUtkBpSczCpW1ru9a4wxer6XhtQ5w41gBh6JwlMMmWw2k66NGZcv hkih6FGImMmT1Ocfkg36bGVQ0hVlOn9E285/oI6iVFof6eQ2S7h6T+HVa9e+ObZj/mwemyxzUCTO xM1/lq+nmwuAsx2DgETrcrwFm3eB+Lslks+aZGzFM8JuygbdG8DipdyRKFH5/XCbeo7SwTNXqzth wqO7rmSDrykOGh9tvK3jZWfn02oIVZX5bIZ7SlmLLDyInn8dboIdlxkMBLOFMoU2FGNNprhl1CpR kajGeeV5wNB23JsKthLO4xd46Q8Ju2sUrnavMzlak7Ekc6lshRt8aESMgV/+S80UZLOpFo9RW/MR A43QiX4BL/v9kXKP3lWGkwgLBE6mrF+hNQmHxBqH/v3d2BzflezvHqv+5cd0ND1VIfL3qbaq9pmE iiLanpR1m0/XQiOQePPYS4Oq7xzFiy/S0l7BnkUd936+3wG31BN/bcujY84TYCCRMmGOKAL3gqyb 73BcRpFsl5drXk7Ro70xwmKYUw6U709NXH0M7smSLBb/pnJHsbIj55hOeIej8DO+lb3aEzHcC012 2VSjiWN/WXqgezp89X7b4GdrYS84C98X//UQNCh0k3RV3PilXaFIesRiwk6JxDp/L7ORu6wThuqz q0M9x66iZB47HE6g79LaqKDZwZ/8A06yPHS5gteKn5xIS1j5paKv7+FMfOdgHGQkxXy5EseaxF1V VTygRf2RBbZU6yPwhRO9fd0J0KVwbN6Oy1FY3Oe7Q+3NndcrXEYHtzAnHtBRNvLl9sXJpoaz3qAQ QOSvvbMzyFybOKtOTZ0iflp2UWFyX4Ya49EG8Qoa5dUKxsR9Emkh3zihpOEzDUl0yFWjwKWSiq0+ DDyKnDBm/BnGt2sfwR+7063AMaT3sUIAfhSlP2FDonEMeQhaoYdBQerW+yv1Iag1xRyMRVs7xnkj m86RdIVN8vQjOhKBNEp7Dy887zXx/AJGm5Iu63bJFIdGYAwFFVINKPXEI5Bm2fCi/ue1j5Vx7+sV OxRc+jt/HTB561PwssEcm0mci3p0oexY7OBqa+E4qZrTakOfWWKQ5vnwovbCjWlpaWvWbdySIceW VVHBJ+BtxPu44HDBet+FF75aaTKJY1GPxZPtElEwXd/1sIYE6jC6lxuimZnwSP9sPc/W1s41cu+p MzKcPr7eebZCKH+zjgmcXTvqObywat7EXRKB0DF3KZd13MsLL1VJQyugIVzPZC082vy5yZZsYB1Z Am90nitUCOWNH9HAPqYmKxzgX/tMJuWlzeYflHV8mT1udPmBbxpfCS+oK0jcWqRgo+4052UKAaAs ELikkpsM5dlOSlCa+MTIjwKVe5gKxMe9o86o0TSj6CsOc9kODwCSzxyBS2LcrsNbda02ndQFjspb eEfjkD3Kivdd1uLcMdSkpKNoCZd/Hl70dgMLuCQhuB5e+GTB5L5dURwW7NIQ+sR1l28p33na9z7U SHGw7fru+bY0LwVVXh8HuaRONFzeSf/jM8lcsVnIp/VSdRgo35m4VYXSsw9TUJjawJumn4uyE/hM bZLz51XPO2R4UXPUC7gkQjewtO6FvPD5gxSrSbkkAkHjr72izpTdF1fyrX3zXqmpGq5+dPt+zfP2 9o6O9tbaRyXFh7YkhriZU7AorNnc1Kw8gFyA7SmBppAEJ1pFr8/OlSEjkUfVYbm62+lN2DFRrplP 1JBo/Tyeq09khJ9Tf0gOle1NSV2TkQXGzM5cvzw22NuRTdeGhJQWMyItY9u2bRnrFoV4udgYESEm WmSWg6ubDE4cqrZtcWNT5UyN6WIkjmpioo+TaxCMcXKDKgdR1V6BpQ4aSeAkqT8mq3KCnSxsnVzA mC4z7C3N6GSCLDuA96p7PwCht/nzAAZRa9haSAyOSJKDiMdQojrBnTFS4ydVLU7Oha82M0au8UiC TboahTvwY8YsU+Kw3uDldKrh2HN2vgkZjSUMj0zAYVCjukv/k9FQVump3lZIw42gtiaCosmQ5AUg Lt50GPZcpI7HaTX503ffbQykj9gaYxj2T9UFF/201ZWm/v0o1t9ARJCIhwPVULopzcqeZWBiZ66N QhKMnbz4dnQsEoEyXXWnruqYlw4Sa2DnyefKckpoMofn425Jxmh7nJRAXznYBCijF/yzmj3Td31P PI9FH5kTnrNM9RtU5+m5ZhqsgHG9Bji2VNythYL+5Vlr7t67mnC67gJHmxX2xeO21spcF10kxmpX 7R8VSywIeu7ZFS1tVftcdYCa03ZIvdH0srk80dr1Wgf0kqojTCBN3CrVOtzg6ThhkK+rHYdtyrbi JZxSEcF9mfaaBAIhGNwcB/+1dsU+6DpXuvRX4HtAA1/39SkYUb3iH7118HwQS1/HMUxjHwwbSVLi RkAbhJaMrFl3vjw9XsEDFwWbFRduPah+/Liu8cWbfrhNe7+LFAgE4RCiFmX+p16hcrCjbBFbk/in fPInsPRmnuOSB9DNYSvwaEi1fLG0/EP/Yjs9KMPxLNYmCfJ3qFq8w5QmaJI3+G6/7Md1PthDBs7C ZalAEaZt33u+skVRAg00Xt0uFAiEBbdfKh6Ebx8WLnbTlIRGmuYBl6xZ4zv3ELB/376jw0fWwKuD N6CpNzdCGdDOaKuNQKZXLZz3WCp9X//7C2CBX/zmAHtL/mxo7hVXpufUgyH7W+9n2ANHJdJY1rbD CIjNLn2q7o6oDElb6fZwZx1NSUYMF/rS2/bwt1po6X7fWgp1ably4DhYwK7L+/dcAgppKHNWESj+ djG4Xg09LP57KVB/TcuOg4aN53bln7mwKTwBEn/VR5f7GELzRmG0sCPg+KReqh5fBw0+/XeSGxMe chSB8709Op/GnFTIMVuPJS4BPjh0LcnX/1MgB0X5C8FeHDyaBtZ8sL25qRWYtTkHuHJvYayXV+Ac V2shqBf9M9KWRlB6PcsltqCiQ21Od3TYnurCGC5DA0EIpNHkRd+9HMHyNmhooVMCuJp1ZbvoMxKa QITbuhps3q7MrbB0wb3D4KE5zZqsSzXQpS4A9N9ssiZiVM5NU4e5mWWNb8ZQYv0tN3PCbA3H4IjQ X/wn9I337Zv2yrNrfB1XAR9sWGFhtAiUdq5j4Sy2gWWvXbUT/K1LzQXu1dPR0tLa/rKp4OggdK80 wFEZumhqMmD8NJ6u9mi38ow7cKu5V4NyG2i7cyjeg6MhiI8AxdwNtl/7N6eO5K4MdaBbQbvoVgjF 4GOgU8SXIn03gXveUGHcMTGUWd0Olrnt+pdF/3301bb4vPfQB//A2bnfB9GZOwDjynWzDNV+fjGz n5l4oqKjd0iFp6j/ZcXJxd52JmNRBPFiOJTfSJ7j7WptSMI7XwFPRW54Stg9yJ9rqoCFRPeSIy6C 4uKwVcC84mcP695Jq2J5yVAW5vXDp2LpY1+HY2D83tZqNw05TBbXf+nBktrOd6JRvSgR9XU+KTm4 zJ9rNjZFEMqDnoKosodHI5NwaCR+NtBX/TusMETnPPmeFN1P9xGCEDqwyyOiRD5ETTAzsFjuZ00C 58PDP6r9Nd7W2I780OX7Llc+6+rpez/wvq/nVXPl5fzl4V5c5ngUwb0u+I+BwaZFjBFvIs1pGBhs TDBCYYyFRa+gPfm+8/om/xkrwdnTtdKSu/rOO0BT9KZinZMeZ9mPPeBB3P1oC88upVUslXSfcR/r SsnhesxZuDrrQMHZc1+c+GxnWnwQz55tND5FQGvGmoKTn3qQRyIUcUba8RPr3XWRSJLlvN2Xf3tw 66vdi/geW38FbB5E0qnuKSdv3vvtWsEaPyM8ZcbSY99X3i8r/DTAxGhm5jd3yw7EWIzz7wnmNo6u HnxvPx++uwvXmjnRKwmW5ujn50jDyp+4fn5c6AmtzfKMWrrikwhPDnsJlBQaOMojYam2AR8lJ8XN djQioLT0rP1jk5IXznFiEIkM96hFMX4c3Yl9tzQeKyaqAQpHNjDQxaJUnlA4irGFpbkRmcDaA+2h 8gSmFhJDNGByOGYGJKCXkWgi1YzDYdJIWkgUTs+YZWpAHP8j218NcLph0CgEmrm5vv35t6uddCEG SDQolFOBPSBRaI2H2hQATZuZmp0R56w/sU+M/wNT/jG0DQplbmRzdHJlYW0NCmVuZG9iag0KNyAw IG9iag0KPDwvRnVuY3Rpb25UeXBlIDAvU2l6ZVsgMjU2XSAvRGVjb2RlWyAwIDEgMCAxIDAgMV0g L1JhbmdlWyAwIDEgMCAxIDAgMV0gL0JpdHNQZXJTYW1wbGUgOC9Eb21haW5bIDAgMV0gL0VuY29k ZVsgMCAyNTVdIC9PcmRlciAxL0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGggNDU3Pj4NCnN0cmVh bQ0KeJyFwodS2gAABuDnsrV72zpREVEEkaGAoBDCCjMQ9h5hC4iADK1272Xbx+of4513rXf97hub NI6dv4ZTfBP/+jR3nEuMz1y8gbPETa6Zf2sOSa6AvC0g7+C8Be/yF6z3zt9fRNsDId/+cIn7SIQO fLyM1BMxd0LsnFhxPl1F1zOUuCYl7qk19ExLuTMy7yyu+3BO7hPIacEGPa/w44IygIuqgFDFCNXM kjoo2gyKtkLLqAmLNeEVbQRXdVGUbMfW9DGpPi41xGWGhGwnsb6bRLkxtWFKKUxpBZFWEhmlOasi s2oyp7bkNq35LbQVNPaC1s5qHazOUdRRpW2qpHeW9a6ywV3BHU9111M1emtGX92E9B6B/oY50CAD TZJpWpiWNdiyhvZtobYt3LZj5MAR6VDRDhXrOjHec2Hi0I3JvgdTA2964EsPkc6M6OzIj7mjAPeY yR8zhedB7kmQPQmxp6HiaRhLLyJYfhnFCr6KYfV1HGv4JoH1t0ncw3cpbOD7NDbxQwZb+DGL+/xP uTb/cx4P+F8K2OF/ZbuXi91vxd7FUu879/Byuf/jr5X+WWXwz+FZdfjzyrXhr9roP+uj3/WjK/4B qNyYIQ0KZW5kc3RyZWFtDQplbmRvYmoNCjggMCBvYmoNCjw8L1BhdHRlcm5UeXBlIDIvU2hhZGlu Zzw8L0NvbG9yU3BhY2UvRGV2aWNlUkdCL1NoYWRpbmdUeXBlIDIvQ29vcmRzWyAwIDM4MC43MyA3 MjAgMzgwLjczXSAvRXh0ZW5kWyB0cnVlIHRydWVdIC9GdW5jdGlvbiA3IDAgUj4+Pj4NCmVuZG9i ag0KOSAwIG9iag0KPDwvVHlwZS9YT2JqZWN0L1N1YnR5cGUvSW1hZ2UvV2lkdGggNTAwL0hlaWdo dCAyMDUvQ29sb3JTcGFjZS9EZXZpY2VSR0IvQml0c1BlckNvbXBvbmVudCA4L0ZpbHRlci9EQ1RE ZWNvZGUvSW50ZXJwb2xhdGUgdHJ1ZS9TTWFzayAxMCAwIFIvTGVuZ3RoIDE2ODAzPj4NCnN0cmVh bQ0K/9j/4AAQSkZJRgABAQEASABIAAD/4QBcRXhpZgAATU0AKgAAAAgABAMCAAIAAAAWAAAAPlEQ AAEAAAABAQAAAFERAAQAAAABAAALE1ESAAQAAAABAAALEwAAAABQaG90b3Nob3AgSUNDIHByb2Zp bGUA/+IMWElDQ19QUk9GSUxFAAEBAAAMSExpbm8CEAAAbW50clJHQiBYWVogB84AAgAJAAYAMQAA YWNzcE1TRlQAAAAASUVDIHNSR0IAAAAAAAAAAAAAAAEAAPbWAAEAAAAA0y1IUCAgAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARY3BydAAAAVAAAAAzZGVzYwAA AYQAAABsd3RwdAAAAfAAAAAUYmtwdAAAAgQAAAAUclhZWgAAAhgAAAAUZ1hZWgAAAiwAAAAUYlhZ WgAAAkAAAAAUZG1uZAAAAlQAAABwZG1kZAAAAsQAAACIdnVlZAAAA0wAAACGdmlldwAAA9QAAAAk bHVtaQAAA/gAAAAUbWVhcwAABAwAAAAkdGVjaAAABDAAAAAMclRSQwAABDwAAAgMZ1RSQwAABDwA AAgMYlRSQwAABDwAAAgMdGV4dAAAAABDb3B5cmlnaHQgKGMpIDE5OTggSGV3bGV0dC1QYWNrYXJk IENvbXBhbnkAAGRlc2MAAAAAAAAAEnNSR0IgSUVDNjE5NjYtMi4xAAAAAAAAAAAAAAASc1JHQiBJ RUM2MTk2Ni0yLjEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAFhZWiAAAAAAAADzUQABAAAAARbMWFlaIAAAAAAAAAAAAAAAAAAAAABYWVogAAAAAAAAb6IA ADj1AAADkFhZWiAAAAAAAABimQAAt4UAABjaWFlaIAAAAAAAACSgAAAPhAAAts9kZXNjAAAAAAAA ABZJRUMgaHR0cDovL3d3dy5pZWMuY2gAAAAAAAAAAAAAABZJRUMgaHR0cDovL3d3dy5pZWMuY2gA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZGVzYwAAAAAAAAAu SUVDIDYxOTY2LTIuMSBEZWZhdWx0IFJHQiBjb2xvdXIgc3BhY2UgLSBzUkdCAAAAAAAAAAAAAAAu SUVDIDYxOTY2LTIuMSBEZWZhdWx0IFJHQiBjb2xvdXIgc3BhY2UgLSBzUkdCAAAAAAAAAAAAAAAA AAAAAAAAAAAAAGRlc2MAAAAAAAAALFJlZmVyZW5jZSBWaWV3aW5nIENvbmRpdGlvbiBpbiBJRUM2 MTk2Ni0yLjEAAAAAAAAAAAAAACxSZWZlcmVuY2UgVmlld2luZyBDb25kaXRpb24gaW4gSUVDNjE5 NjYtMi4xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB2aWV3AAAAAAATpP4AFF8uABDPFAAD7cwA BBMLAANcngAAAAFYWVogAAAAAABMCVYAUAAAAFcf521lYXMAAAAAAAAAAQAAAAAAAAAAAAAAAAAA AAAAAAKPAAAAAnNpZyAAAAAAQ1JUIGN1cnYAAAAAAAAEAAAAAAUACgAPABQAGQAeACMAKAAtADIA NwA7AEAARQBKAE8AVABZAF4AYwBoAG0AcgB3AHwAgQCGAIsAkACVAJoAnwCkAKkArgCyALcAvADB AMYAywDQANUA2wDgAOUA6wDwAPYA+wEBAQcBDQETARkBHwElASsBMgE4AT4BRQFMAVIBWQFgAWcB bgF1AXwBgwGLAZIBmgGhAakBsQG5AcEByQHRAdkB4QHpAfIB+gIDAgwCFAIdAiYCLwI4AkECSwJU Al0CZwJxAnoChAKOApgCogKsArYCwQLLAtUC4ALrAvUDAAMLAxYDIQMtAzgDQwNPA1oDZgNyA34D igOWA6IDrgO6A8cD0wPgA+wD+QQGBBMEIAQtBDsESARVBGMEcQR+BIwEmgSoBLYExATTBOEE8AT+ BQ0FHAUrBToFSQVYBWcFdwWGBZYFpgW1BcUF1QXlBfYGBgYWBicGNwZIBlkGagZ7BowGnQavBsAG 0QbjBvUHBwcZBysHPQdPB2EHdAeGB5kHrAe/B9IH5Qf4CAsIHwgyCEYIWghuCIIIlgiqCL4I0gjn CPsJEAklCToJTwlkCXkJjwmkCboJzwnlCfsKEQonCj0KVApqCoEKmAquCsUK3ArzCwsLIgs5C1EL aQuAC5gLsAvIC+EL+QwSDCoMQwxcDHUMjgynDMAM2QzzDQ0NJg1ADVoNdA2ODakNww3eDfgOEw4u DkkOZA5/DpsOtg7SDu4PCQ8lD0EPXg96D5YPsw/PD+wQCRAmEEMQYRB+EJsQuRDXEPURExExEU8R bRGMEaoRyRHoEgcSJhJFEmQShBKjEsMS4xMDEyMTQxNjE4MTpBPFE+UUBhQnFEkUahSLFK0UzhTw FRIVNBVWFXgVmxW9FeAWAxYmFkkWbBaPFrIW1hb6Fx0XQRdlF4kXrhfSF/cYGxhAGGUYihivGNUY +hkgGUUZaxmRGbcZ3RoEGioaURp3Gp4axRrsGxQbOxtjG4obshvaHAIcKhxSHHscoxzMHPUdHh1H HXAdmR3DHeweFh5AHmoelB6+HukfEx8+H2kflB+/H+ogFSBBIGwgmCDEIPAhHCFIIXUhoSHOIfsi JyJVIoIiryLdIwojOCNmI5QjwiPwJB8kTSR8JKsk2iUJJTglaCWXJccl9yYnJlcmhya3JugnGCdJ J3onqyfcKA0oPyhxKKIo1CkGKTgpaymdKdAqAio1KmgqmyrPKwIrNitpK50r0SwFLDksbiyiLNct DC1BLXYtqy3hLhYuTC6CLrcu7i8kL1ovkS/HL/4wNTBsMKQw2zESMUoxgjG6MfIyKjJjMpsy1DMN M0YzfzO4M/E0KzRlNJ402DUTNU01hzXCNf02NzZyNq426TckN2A3nDfXOBQ4UDiMOMg5BTlCOX85 vDn5OjY6dDqyOu87LTtrO6o76DwnPGU8pDzjPSI9YT2hPeA+ID5gPqA+4D8hP2E/oj/iQCNAZECm QOdBKUFqQaxB7kIwQnJCtUL3QzpDfUPARANER0SKRM5FEkVVRZpF3kYiRmdGq0bwRzVHe0fASAVI S0iRSNdJHUljSalJ8Eo3Sn1KxEsMS1NLmkviTCpMcky6TQJNSk2TTdxOJU5uTrdPAE9JT5NP3VAn UHFQu1EGUVBRm1HmUjFSfFLHUxNTX1OqU/ZUQlSPVNtVKFV1VcJWD1ZcVqlW91dEV5JX4FgvWH1Y y1kaWWlZuFoHWlZaplr1W0VblVvlXDVchlzWXSddeF3JXhpebF69Xw9fYV+zYAVgV2CqYPxhT2Gi YfViSWKcYvBjQ2OXY+tkQGSUZOllPWWSZedmPWaSZuhnPWeTZ+loP2iWaOxpQ2maafFqSGqfavdr T2una/9sV2yvbQhtYG25bhJua27Ebx5veG/RcCtwhnDgcTpxlXHwcktypnMBc11zuHQUdHB0zHUo dYV14XY+dpt2+HdWd7N4EXhueMx5KnmJeed6RnqlewR7Y3vCfCF8gXzhfUF9oX4BfmJ+wn8jf4R/ 5YBHgKiBCoFrgc2CMIKSgvSDV4O6hB2EgITjhUeFq4YOhnKG14c7h5+IBIhpiM6JM4mZif6KZIrK izCLlov8jGOMyo0xjZiN/45mjs6PNo+ekAaQbpDWkT+RqJIRknqS45NNk7aUIJSKlPSVX5XJljSW n5cKl3WX4JhMmLiZJJmQmfyaaJrVm0Kbr5wcnImc951kndKeQJ6unx2fi5/6oGmg2KFHobaiJqKW owajdqPmpFakx6U4pammGqaLpv2nbqfgqFKoxKk3qamqHKqPqwKrdavprFys0K1ErbiuLa6hrxav i7AAsHWw6rFgsdayS7LCszizrrQltJy1E7WKtgG2ebbwt2i34LhZuNG5SrnCuju6tbsuu6e8Ibyb vRW9j74KvoS+/796v/XAcMDswWfB48JfwtvDWMPUxFHEzsVLxcjGRsbDx0HHv8g9yLzJOsm5yjjK t8s2y7bMNcy1zTXNtc42zrbPN8+40DnQutE80b7SP9LB00TTxtRJ1MvVTtXR1lXW2Ndc1+DYZNjo 2WzZ8dp22vvbgNwF3IrdEN2W3hzeot8p36/gNuC94UThzOJT4tvjY+Pr5HPk/OWE5g3mlucf56no Mui86Ubp0Opb6uXrcOv77IbtEe2c7ijutO9A78zwWPDl8XLx//KM8xnzp/Q09ML1UPXe9m32+/eK +Bn4qPk4+cf6V/rn+3f8B/yY/Sn9uv5L/tz/bf///9sAQwAIBgYHBgUIBwcHCQkICgwUDQwLCwwZ EhMPFB0aHx4dGhwcICQuJyAiLCMcHCg3KSwwMTQ0NB8nOT04MjwuMzQy/9sAQwEJCQkMCwwYDQ0Y MiEcITIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIy/8AA EQgAzQH0AwEiAAIRAQMRAf/EAB8AAAEFAQEBAQEBAAAAAAAAAAABAgMEBQYHCAkKC//EALUQAAIB AwMCBAMFBQQEAAABfQECAwAEEQUSITFBBhNRYQcicRQygZGhCCNCscEVUtHwJDNicoIJChYXGBka JSYnKCkqNDU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6g4SFhoeIiYqSk5SV lpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2drh4uPk5ebn6Onq8fLz9PX2 9/j5+v/EAB8BAAMBAQEBAQEBAQEAAAAAAAABAgMEBQYHCAkKC//EALURAAIBAgQEAwQHBQQEAAEC dwABAgMRBAUhMQYSQVEHYXETIjKBCBRCkaGxwQkjM1LwFWJy0QoWJDThJfEXGBkaJicoKSo1Njc4 OTpDREVGR0hJSlNUVVZXWFlaY2RlZmdoaWpzdHV2d3h5eoKDhIWGh4iJipKTlJWWl5iZmqKjpKWm p6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uLj5OXm5+jp6vLz9PX29/j5+v/aAAwDAQAC EQMRAD8A+f6KKKACiiigAooooAKKKKACinRRSTSrFEjSSOcKijJJ9AK9D8O/BLxlrqpLNZppds3P mXzbGx/uDLfmBQB51RX0Np/wF8M6aofW9curyQclLdREv0P3j+orYj8K/DnR1/ceGRcMP4rhmkz/ AN9Mf5UWA+YaK+n5NU8N2i4tPBmlREchlhjX+SUy38Q6RIClx4U0yVTzgxp/8QadgPmOivqQ2fgj U1/0rwZYR56mGFFP5qFNUbv4SfDzV1P2VL3TJDyPKmYjP/A9w/lSA+aaK9o1r9njVIkabQNYtb9O oinHlP8AQEZUn64ry7XfC2ueGbjydZ0u5s2JwrSJ8jf7rD5W/A0AZFFFFABRRRQAUUUUAFFFFABR RRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFF FABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRVixsbrU76GysoJJ7mZgkcUYyWNAFevUfAvwT1vx P5d7q2/SdLOGDSL++lH+yp6D3P4A16P8PPhDpvhVYdV14R3ur4DpFjMVufYfxMP7x4Hb1r1ITPO3 t6U7AY/hnwV4a8GwBNG02NZ8Ya6l+eZ/qx5H0GB7VrXBlmBGTj0q5HEqDLnnrisy/wBesrbKIfNc fwxdPxb/AAzRcDLvLU87uKxZ9KuZ1Pk2s0g9VQ4/On6l4kvmz9nEduPVVDN+Z/piuF13Ubq43G8v ZZAf+espI/U0gNy70K7DHf8AZowOT5t1EhH5sKrW+izb8Lc6c/sl/Ccf+PV5xdzwFjiRT9DmqsUs QblxQB7haaNegZWAyLjrERIP/HSa1be3ZG2yIykdQwxXienXEYlUx3Cq46YfBrvdJ8QaxAFVb+WR B/BMfMX8mzQB6XZwlSCpK/Q1pS2kN/aPa3tvFc28gw8cqBlYe4PBrl9M8UK+0XdqFPd4Tx/3yf8A Guts7q3uot1vKrjuB1H1FO4Hj3jb9n/TNSSS88LyDT7vlvsshJgc+gPJQ/mPYV8+a54f1Xw3qL2G sWMtpcr/AAyDhh6qejD3HFfdtYnifwro3i7Sm07WLVZouSjjh4m/vI3Y/oe+aQHw3RXd/EX4Yan4 CvBKSbvSZWxDdquMH+647N+h7dwOEoAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoo ooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiii gCxY2NzqV9DZWcLTXMzhI41HLE19NeAPA+n+A9NWeUR3GtTp+9n67B/dT0X36n8gOV+GXhSDwzpZ 1rU4v+JjcJ8isMGFDyF9iep9Bx656z/hI7RpiZLuPOefmFPYDsIJHnkLMc57mrV1qdtpdv5kz43D 5VH3n+g9PeuIvPHelaZah2uIXlf/AFUW/wC9/tN/s/zrkL3xrZSPJe3uoRsx6nd+gA/kKQHe32v3 WokqT5UGeIkPB+p71xutePdK0oNFE32u4HGyM/KD7t/hmvO9d8dz6sWt7eb7PadCobBcf7R/p0+t cpPqSRnEIDt3dun5UAdlqfjfWdS3bJFtYfSP5f16/rXMT6mjuWmvGkc8nbk5/GsSWeWY5kkZvqeK joA1jqVt/dnP1P8A9egalbf885R9GrJooA2U1K3Jxvmj9yMitTT9au7ZgbG/PBzsDY/NT/hXJUUA ewaL8SZ7Z1i1W2EqdDJGAr/XHQ/pXpejeIbLU4xcaZeBmT7wU7XT6jqK+YINSniG18Sp6P1/OtrT dUeGdbjT7iSKdOQAcMP8RQB9a6b4nRyIb4hGPAl6A/X0+tbTyYGQcg9K+eNF+IcF0iW2qOkNz0WX osh/of0/lXY6P8RrKxZbW7vI2tScK27mP/Ee1AHpV9DZ6nYzWF/bx3FrOpSSKQZVh6Gvlb4ofDeb wTqn2mzDy6LcOfJkPJib/nm59fQ9x7g19Ay+LNOPIvYSDyCHHI9ao6nruia1pVxpl/LBPbTpsdGY cj29COoPqKe4HyZRWv4l0X+wdbms0nW4t87oJlP30PQn37H3FZFIAooooAKKKKACiiigAooooAKK KKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooo oAKKKKACiiigArs/hx4dGsa6t3cRhrW0YNhujydQD7DqfoPWuNVS7BVBLE4AHc17r4Z05NB8Ow2w A81xhmHdjy5/ko9hTQG7qdx9oQxRuwQDC88/X61seDNbj1NJNKu4bX+0bUfxW6Hzk/vjI69iO3Hq KwIIzKQoG53IVR3JNcPr+q3Ft4ggvtGn8uTTnPkSjpIf4ifVW6fTFID36S1wc/ZbP/wFT/CofJwe bSz/APAWP/CmeCfFtj410CPULcBZ1+S5t85MUncfTuDXSfYY5PujFBJz3kD/AJ9LL/wFj/wpfI/6 dLP/AMBY/wDCuhGnD0FL/Zw9BQBzvkf9Oln/AOAsf+Fct4/8AQ+NfDrfY7aCHW7MF7do0CCZe8ZA 457V6X/Zw9BTPsbROHQYYHIoA+FpYpIJnilRkkjYq6MMFSOCCPWmV738dPhyNreMdIgwDgajCg6H oJQP0P4H1rwSgoKKKKACtXw74e1bxNq8WnaNayT3Tc5XgRr3Zm6KB61v+AfhrrHju8zAv2XTImxP fSL8q/7Kj+Jvb8yK+n/DfhLSvCekjTNGtfKiODNM3Ms7f3nbv9Og7CgDkfCPw803whB5siw6nrMi YmvJYwyR+qxKeg/2jyfYcV1Hkf8ATpZ/+Asf+Fby6fntUn9nD0FAjnvLIGPs1pj/AK9k/wAKTyyP +Xa0/wDAZP8ACuhOnj0FJ/Zy9SBQI57yi3/LrZ/+Asf+FSpaZ62ln/4Cx/4VufZY0/hyaqalf2Oj WEt7qE8dtbRLuZ3OBigCn9jjAJa0sgB1Jtk/wryH4ifFLTtPEulaBBZ3F4CVkuVt08uI+gwPmP6D 36VzfxE+MF54kaXTdEL2el8q0g4knH/sq+3U9/SvK6B2HzTSXE7zTOXlkYszHqSaZRRQMKKKKACi iigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKK KACiiigAooooAKKKKAN3wjYm91+Ftu5YP3pHqQQF/Uj8q9kcbHSNTlIxtA/mfxOT+NcB8N7UKJbp hyX4P+4Mj9W/Su+UAnNPoA3Ur06fpFzOvEjfuIcHozA5P4KG+hK15vqVx5VttB+eT5R7Duf8+tdV 4ruSZrSzB4hj8xx/tvz/AOghK4DU5xJeuueIgFH16n+g/CkBf8I+MbvwN4mi1G1y8D4W6t88Sp/i Ox/xNfXuhavYa/pFvqenSrLbToGVgf0PoR0xXwrI5kkZic5Nek/CL4kP4N1gaffyk6NduA+TxA54 3j29fz7cgH1nRTIpUniSWJgyOMqwOQRT6ACiiigCOaCK4gkgmjWSKVSjowyGBGCCPSvkL4q/D6Xw L4jP2dGbSLwl7SQ87PWMn1H6jHvX2DWH4u8LWHjHw5c6PfrhJRmOUDLRSD7rj3H6jI70AfDlexfD L4JXXiHydY8SJJaaUcPFbfdluR6nuqH16ntjg13Xw6+Blp4euRqniRob+/jcmCBRmGLB4Y5+83fk YHueR7HQBWs9PtNOsobKyt47e1hXbHFEoVVHsBVgKB0FLRQAUUUUAFBAPWkJCgknAFeWfET4vWnh 7zNL0YJeasRggH5IfdyP5dfpQB1XjDxvpPhCy8y5fzLp+IbaPl5D7D+p4FfOvjnVte8XwzX2pzGO KNfNgs42OyMA85/vNjnP5YqQSm4kGs6rdm5urlAzSynnPQqo7AHOAK6jTvA/ifxLboLXTBaWhJ/0 jUCYgykYOEwXOeMcAH1oQHhFFfSOjfs3aNAqtrOs3l2/UpbIsKfQ53E/pXa6d8HvAemgFNAhncdW uZHlz+DEj9KAPjmivui18KeHLEAWmgaXBj/nnZxr/IVeTT7KJdsdnboOuFiUf0oA+CaK+8LjRNJu wRc6XZTA9RJbo2fzFYd78MvBOoKwm8Maau7qYIRCfzTFAHxXRX1FrH7PHhO9RjptzfabKfugSebG PqG5P/fVeV+LPgZ4p8ORPdWQTV7NOS1qpEqj1MZ5/wC+SaAPMaKCCCQRgjqKKACir2i6c2r67p+m pnddXEcIx/tMB/Wvqv8A4UX4A/6BM3/gZL/8VQB8jUV9Zn4C+AyxIsbsAnoLt+KP+FC+BP8Anyu/ /ApqAPkyivrI/ATwIQQLO8BPcXTcVyvj74PeD/C/gnU9XtVvvtEEWYvMuMjcSAMjHqRQB870VueG fB+u+L742ui2ElwVx5kv3Y4x6sx4H06nsK9t8Ofs4WcISbxHq8lw/VreyGxAfQuwyR9AtAHztRX2 bpvwo8DaUB5PhyzlI73QM+f++yRW7H4X8PxIFj0LTEUdltIwP5UAfCtFfcc/gvwtcgibw3o8meTu sYyc+v3etcrrvwQ8E6zE3k2D6bOektlIV/8AHTlcfgPrQB8jUV3vxC+FWr+AnFyzi90qRtqXca42 nsrr/CfzB9e1cFQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQB6z4Ft1i0WM9z Fz/wJif6CuqCYGB1PQVgeD0C6SgIziKIf+O11Vqim5hJ5HmLn86bA4LW5RNr16wOVErIh/2VO1f0 Arzma4MvmSHgyMzfQk12V67i1uZc5YRu+ffBNcHu+XFIBKKKKAPe/gh8TvKMXhTWZvlPFjM5/wDI ZP8AL8vSvfkuYm/ixXwQjtG6ujFXUgqwOCD6ivo/4Z/EU+I9LFjfSgaraqA2ePOT++Pf1/8Ar0Ae 1edH/fFL50f98VyI1Bv71L/aDf3qBXOt86Mfxik86PH3hXJ/2g396m/2g396gLnXCeM/xUefH/fF cj/aDn+KlGoN/eosFzrvOj/vik8+PGd4rkTqDZ+9TJdSccbqAudc15Cv8VQzapa28LzTSrHFGpZn Y4AArgNZ8VWehWD3moXIijXoCeWPoB3NeBeNviRqni2RrZHe20wH5YAeZPdz3+nT69aAO7+JPxul 1BpdI8LymODlZL0dW9k/+K/L1rzfwfoOreKdafTdKgae4lIeSaQ/JEv8Tu3pz9T0HNYWl6bd6zql rptjEZbq5kEcaDuT/SvqXwtoth4K0JNI04q8pw15dAfNcSeuf7o6Af1JoHc0vB3w90HwjBBJKw1L VIx/x+TqDsOc/u16IMk89eetdoLyM1yIvWP8VPF9j+LNOwrnWfaoz3p6zxt3rkf7Qb+9XDfFLx7c eGtAS2sJCmoX2VRx1jQfeb68gD657Ugud34j+J3hXwvKYb/Uk88dYYgXcfUDJH41z9t8e/BU8wSS 4uIQTjc8DY/QV8pySPLI8srs8jkszscliepJpuaBn3jp+r6fqthHfWF3FcW0gykkbBgfxFWfPj/v V8wfAvXbu21nUdJ8xjaS25uAhPCurKMj0yG/QV7l/aLf3jQK51ZuYx3phvIx3rl/7Qb+8aY18T/F RYLnKfFL4V6f4stLjWdDiSDXYlLvGgAW7A6g/wC36Hv0PqPmBlZGKsCrA4IIwQa+x47+SGdZA3Q9 PWvmb4n2MVj8QtUWFQsczrOAPV1Bb/x4mgLmn8FNLGpfE/T3cAxWSSXT5/2VwP8Ax5lr63W5jYda +avgTa+S+s6mRztjtkb6ks38lr2kagw4DUBc63z4/Wj7RH61yX9oP/fNH9oP/fNAXOsNzGO9Yfi7 QLbxh4efRrm5aC2mljaZk+8UVgxUehOAM9qz/wC0W/vc1R1DxDBptpLd3lysMEYyzucCgLnXaTp2 k6BpkOnaXbw2tpEMLHGMfiT1JPcnk1dFxCf4xXzjrHx4KTNHo+nGVAcCW4bbn6KO31xTND+OtxLq MUOs2MUds7BTNCxzH7kHqP8APNAH0l58f96l86P+8K5BdRJUEPkEZBBpft7f36Audd50f94U03EY 71yf29v75pP7Qf8AvUBc39RgsNasLjTL6JZba6jMUiN3Br4p8UaHJ4b8T6jo8jFjaTsisf4l6qfx BB/GvrU3rFs7q+cfjGVf4j3sg+88URb67AP5AUAmcFRRRQMKKKKACiiigAooooAKKKKACiiigAoo ooAKKKKACiinKuVJoA9l8GHzdNIyP9XER/3zXW26DzYuf4x/OuI+H84ktUjJ+9brj/gPFd+qbVVk 6jBH1psDyK940+7J/wCeEg/8dNcBXqV/aJFf3Nq4/drK0bfQEivLiCrEEEEHBBpAJRRRQAV1HgTQ vEGseIIZtBHlPasHlu5DtigX/bPoeRt6nsK1PBPw2u/EaR6pqjSWOh7jiXH7y4x1WIHr6FjwPc8V 7La29vY6fHpumWqWenRHKQR85P8AeY9WY+p/lTSE2XXuQrkLJvAONwGN3vjtSfaj61VELZpfJaqs QWftR9aPtR9areSaPJNFguWftR9aPtR9areS1HktRYLlg3R9a5rxX46sfDdvtZvPvmHyW6nn6n0F b8abJFZl3KDkj1rxv4qeDZdC1k6xbNLNpWouXSVzuMb90Y+3b2pMa3OR1zX9Q8Q3xutQmLt/Ag4V B6AVl0UVJZ6x8H9Mjt473XpBmfm2t/8AZBHzt+WF/E16ilwcZJrk/ANgYPBGmgD/AFitKffcxP8A LFdN5DVSRDepY+1E96X7UfWq/kmjyWp2ET/aj61k694e8MeKbi3udYsrx7iGEQgwXWxSMk5xtPPP 6VeMRCsWIVVGST2Fc+fFXh0H/kNWf/f0UWGNHw08BH/lw1P/AMDR/wDE0v8AwrTwF/z4an/4Gj/4 mpF8W+Hf+g1Z/wDf0Up8W+HP+g3Z/wDf0UrILsuaP4a8N+GJ5rjRbK5juJo/KaS4uPMwuQSAMDHI FaovG9a54+LPDhHOtWf/AH9FIPFXhsf8xuz/AO/op6BqdF9sb1oN43rXO/8ACV+G/wDoN2f/AH9F B8VeG+2t2f8A39FAjoRfMGGTXhfxRmE3jy7Ydo4wf++RXpx8V+HdwI1mz/7+ivGvFt8mq+LNQuYG EkbyhUZeQwUBRj8qTKR678MIP7P8E27YIe5ledh+O0fotdmLo+tZWlacdP0mzsx0t4Ej/EDn9aui Fqdibln7UfWk+1H1qv5LUGFqLATm6OOteKfFPxFNqGuf2THIRa2gBdQeGkIzk/QED869gkTy0LMQ AoJJPavmrVLw6hqt3eHOZ5mk59CcikyolTNFFT2NpJf39vZxf6yeVY1+pOKko+k/Dt1IfDOkmQnf 9ji3Z9dgrT+1H1qoloII0hjACRqEXHoBineS1XYzuWftR9aQ3R9ar+S1IYWosBYN2cjmvnXxzqQ1 XxpqdyDlfN8tfogC/wBK911a4/s3Sry9bpbwtJ+QzXzU7M7FmJLMcknuaTKiJRRRUlBRRRQAUUUU AFFFFABRRRQAUUUUAFFFFABRRRQAVNb4LEGoakgOJVz0PFAHofw8uQskETHGyVom/Hkfqa9cjGFG ea8J8NXDW2qOinBmUOh/21/z+le6WkoubOGZCNrqGFN7AcR4ptPI1yVgMJMqyL+WD+oNeUeIbY22 t3OckSt5qnGAd3Jx7A5H4V7r4ts/NsI7peWgbDcfwn/6+Pzry3WtIn16/srTTYTPqDEp5a9dnXcS eFVeSSePmpAcUqs7BVUszHAAGSTXr/g74YW+meVqfi2ESTkB4dJJ6ehnx0/3Ovrjob/hfw3pvg5F nRo73WyPmvMZS39oQe/+2efTHU7X2pnYszEknJJPWrUSHLsbkl21w6lyMKoVVUYVFHRVA4AHoKes qqKxBdbe/NL9rPrVWJNwTLQZ1NYf2snvTWvcdDQBu+co6mjzlHeuf+2MTwact6ehNAG/560vnrWF 9rIPWl+1n1osBtGZc0l0ljq2mXOjaou+wuhh8dY27OPcVim7PrSNdEjrRYDwvxT4bvPCuuz6ZdjO w7opAOJUPRh9RWNXvPiXSIfF+ifYZDjUbYFrKU9/WM+x7e/rxXhU8EttPJBMhSWNirKeoIrNqxon c+gfBF6kngvSipGFh2H6gkH+VdGs6sOvNeM/DzxKlsjaNcvtDMXt2J4yeq/1/OvRReEd6tbEPc6P zwKPtC1gC/PrS/bs96dhGxet5um3iR8uYHCgeuDXy52r6Qt9T8mdXwGA6qehHcVxOu/Cmz1O+e78 O61aW6zMXay1EtGYyeyuAVYdeu2pkios8lzUtpa3F9dw2lpC81xM4jjiRcs7E4AA9a9Aj+DuqJKo vdd0O3jJ5ZLhpjj2CKf1IrsvDnh/RfB2ZdMea71NlKtqE6hNgPURICdue5JJ+mSKlJsptHmn/Csf G/8A0LGo/wDfqj/hWPjf/oWNR/79V7F9vl7yt+dL/aMg/wCWrfnVcouY8c/4Vj43/wChY1H/AL9U f8Kx8b/9CxqP/fqvYTqEh/5aN/31UcmpGNGeSYqqjJYtgAUcocx4frHhPXvD8SyatpVxZo2MGZcZ z/8AqP5UeEbH+0fFul2xGVa4VmH+yvzH9Aa0vG/ij/hIL5ILdibO3J2n++3dv6D8fWrXwygB8RTX jLlba3bB9GbgfpmptqO+h7n56kk+pzS+etYH28560fbz61oZm/560nnqawft59aDfn1oAb411Uaf 4R1OZWw7RGJPq3y/1r52r0/4m6oTpVnZBuZZTIw9lH+LD8q8wqJblx2Cut+GtkLzxvZuyhktg87A +w4/UiuSr0b4WQiE6lfsvO1YUP15P8hSW43sexiZcUvnrWB9vOetH28+taGZv+etJ5ymsH7efWkN +SOtAGT8T9UFt4OmhVsPdSrEPpncf0XH414XXf8AxP1Iz3dhZBuI0aVh7k4H8j+dcBWctzSOwUUU UhhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUA4oooA27OcqIrmP78TBwB39RXtHhLVY5LAw hwQo8yMnup5/n/OvCtPuBGSrHjqM13fhzTtQazjubuSS0sMkwKvE1wp7DP3V/wBo/gD1FRV9BNpb ndanqn27z7S1K7ACs87/AHIgR0929FHP0HIx7R7XS7RrTTlZUkx5878y3B9WPYeijge55MUjPIqx pGscKfciT7q/4n1J5PekWFvStYwSMXJssrcH1p/2rHQ1V8tvSjy29KqyFct/asd6T7WfWqvlsOtM ZW9KLILltr33qGW/WKNpJHCooySTgCs6/vYNNt2nuZAijoO5PoBXnus69catIVyY7cH5YwevuamT SKimzZ8QeM5rvda6c7Rw9GlHDN9PQVv+FvEbalYCKd83UAw2erjsa8xq1p19Lp17HcxHlTyP7w7i slLXU0cdND2YXeR1pwuz61k2Vwl7axXMB3RyDI9varflse1b2Rjct/a/ek+1H1qrsb0o2N6UWQrl k3RBDBiCOlcx440ZdXt21q1T/TIh/pSAffX+/wDX1/8A1Ct7y29KIzJBKHUexB6EdwaTimhqTR55 oGhi6s5LuccP8sQzzweW/Pgfj7V1lle6xp9sn2uJ7u26LKv+sA9x3/n9asw6YLLWIUDEaXdtlCTz E3dP8K76XTYXt1CqoyAAB2FY6xZtpJHEW2t2t3xDOpYdUbhh9Qeatfaz61k+LdLs1lYFFxCCzuvB z6A1wjXt9ZKzRXs6DspbcB7c1XP3JcOx6iLwg9alW99TXlSeKdWQczq/+8g/pUy+MNUXGfIP1Q/4 0+eIuRnqH2wetNN96GvM/wDhM9T/ALlt/wB8H/Go38Xaq/Rol/3U/wATT54hySPTvtp9aim1WK3Q vNMkajqWbFeVTa9qk/37yQD/AGcL/KqEkrytukdnb1Y5NS5roPkZ6Nf+O7K2BW2DXEnbHC/n/hXH av4l1HWMpPLsg/55JwPx9ax80VLk2WopBXf+Aytrpd1MSFeaULyeqqP8Sa4CrENheTxiSG0nkQ9G SMkH8RSTs7g1dHsH25c/fX86Pty/3x+deR/2VqH/AED7r/vy3+FH9lah/wBA+6/78t/hV8/kTyeZ 659uX++PzoN8v99fzrxlkZGKupVh1BGCKbxRz+QcnmdJ41vvtmu7AcrBGEH1PP8AUVzdFFQ3dlJW QV6Z4PZLLw3Eu4K8rtKwJ/AfoBXmdFEXZg1c9oF8v99fzo+3L/fH514xxRxV8/kTyeZ7P9uX++Pz o+3L/fH514xxSUc/kHJ5mv4nvTfeIbuTOVVvLX/gIx/PNZFFdn4R+GWueNNNlv8ATrjT4YI5fKP2 qYoWbGeMKc9azZZxlFdx4q+Feu+ENIOp6hdabLAHCYtp2dsk4HBUVw9ABRRRQAUUUUAFFFFABRRR QAUUUUAFFFFABRRRQAVLbW095cxW1tDJNPKwSOONSzOx6AAdTU2m6dPqt6lrAY1ZuryuERB6kntX u/hLTfCvg+wU2WoWs2rSLifUJZFDLkcpGMnYvv1PsOKaE2c94b+G0OhKl5rscd1qnVLI4aK3PrJ2 dv8AZ6DvnoOims3mlaWZi7scljya031XSP8AoJ2n/f0VD/aWlOcDUbQk9B5oq07IzabM42QHRaPs ee1agutO/wCf62/7+Cj7Vp3/AD/W3/fwU+YXKZn2P2/Sg2ftWn9q07/n9tv+/go+1ad/z+23/fwU cw+UyTZE9qwPEWt2WgQ4ciW6YfJCp5+p9BWnrHiEyTNp+iBZpuklzjKRew/vN7dB39K871vwT4gi aS+2SaijHc8sYLOPqvX8sgD0pOY1A57UtTutUujPdPuP8Kj7qj0AqnRRWZoFFFFAHWeCNaWzvxp9 y2Le4bCMf4H/AMD/AIV6kLIjtXgINe0eBfFNvq+kCC/uEjvbYBWaRseYvZvr6/8A16uMraESj1Nj 7H7UfY/atP7Vp3/P9bf9/BR9q07/AJ/bb/v4KrmJ5TMNn7Ugs88EVqfatO/5/bb/AL+Cg3Wnf8/t t/38FHMLlKUOnwzRyWtwCbabAbHVD2Ye4qtLqt1oUkml3pD3qj9xIPuyoejj8McVspeaeD/x/W3/ AH8FQ+IoNK8ReHjZNqNvDfW+XsboSDMbHqp/2T/n1CbTKjoeXeItS+0zG1jfcqNmQn+Jv/rfzri7 6fzJdi/dX9TVzUJZrPfayrtuVJRwDnbj0I6/WsiobuaBRRRSAKKKKACiiigAooooAK+yvh5o1xo/ w+0O0jLIfsqyuv8AtP8AMf518iaHp7atr2n6coJN1cRxcf7TAV92xRrBAkaABI1CgDsAKAK6+YnD 3IB98UHzW/1dwD9MV8lfEzxXqd18RNZ+y6ndxW8U3kokU7Ko2gKeAcdQawNL8b+JdHvEurTWr3ej A7ZJmdW9iCcEUCsfXGveDNG8V2jWut6ZDNuBC3CoFljPqrDkfy9c18k+OPCdx4L8V3WjTP5qIQ8E uMeZGfun69j7g19maBqEmreHtO1GWPy3uraOZk/ullBx+tfO37RzxN4y00LjzRZfP9N5x/WgZ41R X0T8M/g/4Y13wHp+q63ZTS3l1vk3LO6DZuIXgHHQVX8ZfBTTJ9f0jRvCto9oZlea9upZXkWGIEAc E8kknA749M0AfP1FfUOpfCfwT4N8F6jfy6eb65trV38+7kY7mC8YUEKOfavmS0tLi/u4rS0gknuJ mCRxRqWZiewAoAhor3vwf+zs00Md34rvXiLAH7FaEbh7M5yM+w/OvSrX4OeArWIRjw/FJxgtLLI5 P4lqAPjqivqnxD8AfCeqWznSlm0q6x8jRuZI8+6sTx9CK+b/ABR4X1Pwhrk2k6rEEnj+ZXU5WRT0 ZT3BoAxq+ivhp4p8HaB4C0+xvtZtYbwl5ZlLchmbOD9BgV87xRtNKkSDLuwVR6k19XWXwJ8Dixt/ tOnTvP5S+YwupBlsDJxn1oA86+NfjPRNb0TTNO0O/iuk89pZvLOcYXAz/wB9H8q8UrrviZpOkaF4 5vdL0SForW2VEKtIX+cjJ5P1A/CsLQ9C1LxJq0OmaVavc3cp+VF6AdyT0AHqaAM6ivpXwt+zxo9n Ak3iS6lv7kjLQQMY4lPpkfM314+ldmfhB4CaDyv+Edt9vqJJA357s0AfG9Fe6/En4FQaTpc+s+Fn meK3UvPZSnewUdWRupx6Hn37V4VQAUVoaJompeItVh0zSrV7m7lPyog6DuSegA9TX0B4W/Z10y3g jm8TXst3cEZa3tm2Rr7FvvN+GKAPm+ivslPhD4CSHyx4ctyPVpHJ/PdmuL8Y/s/aLdWE1z4ZkksL xFLLbyyF4ZPbJ5U++SPagD5qr2/4E+DNL1zTNX1LVtLtr9FlSCFbhNwUgbmI/MVxXw08GReI/iLH oms28nkW6ytdRBipG0EYyOnzEV9W+GvC+k+EdK/s3R7cw23mGQqzlyWPU5PPagDyb4weGfDXhzwD PcWmgada3c0qQxSRQgMCTkkH6A18419w+KvB2jeM7OC01qCSaGCTzEVJWT5sYzweeCa+d/jV4O8M +DH0u10O0khuLje8peZn+UYA6n1P6UAeTUUUUAFFFFABRxRRQBNbvEHxKuUPf0re0+K0gmHnW0c0 L9eMnHqP8K5urtjfm2+SQF4j2HVT7UAevaNoui3cUZeCF4m+5Kq/oa623+H+m/Ky2cJB5BCivHdH 1u50yUXFpKHib7ynlWHuOx969Y8KePIZtscLhXP3rWU9f909/wDPFVZMDqrXwZYmMKYRGR0ZBgip JfDN1ZDMSeenqg5/Kt7Tdbsb8BVcRSn/AJZvwfw9a2UwMUrAeTav4V0PW3P9qaXDLNnmTBSTgYGW XDEexOK42++DGlTlTp+q3VrySwmRZh9Bjbj8Sa+i5rO2uh+/gjk92XmqEvhjT5DlPNi/3Xz/ADzS A+Z7r4Laus+LPVLCWHH35g8bZ+gDfzqL/hS3iLH/AB/6Sf8AtrJ/8br6Vbwmmflu3A90Bpo8KEdb sn6R4/rQB892/wAErkwBrvXIo5u6Q25kX/vosv8AKtaP4U6LZgki4umwOZpMAH2Cgfrmvcl8Mwr9 +WRvyFTpotlDyY0J9W+b+dAHhq/Dy2nOIdNjIz2QAVoW3wpsvvT2sTH+6E4/OvZWW3jGAgP4Vn3t 5b2ybppEjXsCev0HegDzVvh7pkK4FlDx6IOKx9S8L6RZZU2kLzHogUcfX0rsNb8TxxQO0brbQD70 0hwT9B/k15Rrvi97ovBpwZVb78zffb/D+f0qrW3AyddttNtJGjjt4XuT1woxH7fX2rl7hYLVf9Wp lPRfT3NWLq/S3yqESSnqey1ju7OxZiSx6k0mAEliSTkmkoopAFFFFABRRRQAUUUUAFFFFAHc/CK1 Wf4i6fcOoZLNXuCD0yFIH6kV9QR65PMrpGvmSFGKoOrHHQe9fPHwesHL6pqAHCqkCt9Tk/yFenTT PEu95FjUfxM2KaRLep4jefDvx1e3txdSeGNS3zSNI37o9Sc/1roPC3wa1aa/hufFKDS9NjYNJEzg zzAfwqoJxnpk4xXpP9rRoOdQiA95ax9U8aaNpykz6nC7gfcjbex/AUWDmPSG8TLbRnayQW0S/Kuc BFA4H5V8u+PvEjeMfGt3qMfMTMIbceqjgH8Tk/jVrxX4/u9djeytA1vYnhsn5pB7+g9qx/CFgdT8 XaXahdwadWI9l+Y/yoGj6o0W+Ok6Jp2mxFVS1to4gB7KM03XviLp/hqxN3qEyqW+VVVcvIfQDvWE 7SgsfxNfPPi/XZde8Q3Nw8haGNjHCueAoPX8etDVhJ3PQvHPxubxV4bvNFttNeCO42jzncZwGBPA 9QMde9dP8J/Ddr4U0WLWrqFH1q/TcjOMm2hPQD0ZhyfbA9a8I0OzXUNesLNhlZrhEYeoJGa+ltkj yjbwvQD0A6ChK4N2G+N/i6vhG1WCKMXOpTLlIieEH95vb+deTD46+Nheef8AarYpuz5Pk/Lj065/ WuP8X3s194t1SWYkstw0YB7BTtA/SsSkUj6z8JfEU+LNBj1FVEMwYxzRZztcensc5rjPjokWr+Fr HU2RftdnOIy4HJR85H5hf1rJ+FdhdWXhOS7dWVLy4LRA91UAZ/PP5VF8WNRMXhq3snP7y4nDY/2V GT+pFO2hN9TzzwJYjUPHOjQMoKC5WRwemF+Y5/KvrRPEblizMNvJr5p+Eti8/iS5vAuRbW5wfRmO B/WvUfEt7LpnhnUbrODHA20+5GB+tCQN6ngfiPUW1rxRqV/ksbm6d1x3Bbj9MV9E/DrRbbwP4cii SNDq14qy3k/VhkZWMH0Hf3zXgPgixXUfGWmQOMqJfMI/3QW/pX0KDOJjKWGQdxJP40JXBuxzXxH+ MeoaPctouiOq3Sj9/cMM+WT0UD1rjvB/xj8U2Ov2yanqLX1lPIscqSKuVBONykAdK9ImvPCtxPJP daV4YuJ5GLySyW0bM7E5JJ7mojceElIaLR/C0bqcq62kWQfXmiwXPRE11ixRyro4KkHvmvj/AMR2 CWXivU7G2XKR3kkcSqO244H8q9/OvWbSl21K2JJyT5o61494bVdf+KS3DgPG93Jc4PcAlh/ShoEz 274faJaeBNAit440Or3KrJfXHUgnkRj0C9/U5qj49+NMnhtjpmlxpcaiVy7Oflhz0z6n2q+wmHmS MSSAWNfMl9dy39/cXc7FpZpGdifUmhqwJ3PSNO+PHjG0v0mupbe7gz88LR7cj2I6frW345+Olxqu lpYeH99uZowZ5zwyZHKr7+/5eteKUUijpfB/jDVvCWryXekrC93cqIi0yls5OfXucV9YReIZxEgl dDJtG7aOM45xXyR4KsDqXjHS7fGR54kb6L8x/lX0SzTbmcnjljTSJbON8dfGrxFo/iy707Smtfs1 uFXLxkkttBPOfevKfFvjDVPGeoxX2qtEZYovKURrgYyT69eaz9avTqOt314Tnzp3cH2J4/SqFIoK KKKACiiigAooooAKKKKAJbe5ltn3RNjPUdjWxa6jFMww3ky+hPyk+xrCooA9N0vxvqOnbYrsfaoR /wA9D834N/jmvRNC+Jlu4VVvzCf+eV1yv4N/9cV87QX09vwj5T+63Iq7FqkTf6yJo2/vRnj8qfMw Prey8aRSxq0sOVP8cLBga1YfEunSY/0jafR1Ir5Fs9Ylt232eomNs9nKH+lb9v418Q24A+0mRf8A aVW/UjNO6A+p11qyccXlv+MgFD6vaKOby3H1lFfMyfEfWExutrd/96I/0anN8StVYYFlaj3Ebf8A xVLQD6Mm16wTreJ/wHLfyrMuPFFqufKSWU/TaP1/wr59m8f69L/q/Li/3Yh/XNY974m1e5GLrU3V T/D5mAfwGBT0A9z1jxzHahhNd29oP7oO5/y6/pXnWsfEVGdhYxPPKf8AlrOc/p/ia81l1G3H3pJJ T6KMCqkmqSsMRKsQ9uT+dHN2A3tU1i5vZPO1G6Y/3Vz0+gHSsG41J3BSEeXH+pqkzM7FmJJPUk0l SAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQB7T8OpBpng2Ls9zM8rfyH6Csv4pawZdJsrIN/rJjIw9 lGP61i2PjKws9Pt7UCbEMYThfSuf8S60ms3sUkW7y449oDDHOef6VbtYhXuYpNJRRUFhXc/C2MJ4 kmvWHFvbtj2ZuB+ma4aul8Ma/a6Jb3AlEhkmYfdHYdP5mnHcT2PXtd177JoN/cA/MkDbfqRgfrXz 4a7DX/FkGpaTJaQeaGdhncMcA5rj6chR2Luj339m6zZXuMiCZJD9Aa+hYNdDeXcROCpw6kdDXzbX SaF4suNKiW2mBmth93B+ZPp7URfcJI9B8WfDi38T6lLq+galZ21xcHfcWN65jAfuUfkEH0OD9azd J+EsNpcCbxJrNsYUOfsmnP5sknsXxtUe/J9qhh8a6Y65NwyH0ZDVe78eWcSkQCSZu3GB+tVyx3uT eXY9Ku9ctLK13bYrSytowsca8JGg6Af5yT714f4t8Ry+Jdae6ORbxjZAh7L6/U1W1fxBfay2J5Ns IOREp4/H1rOht5riRY4IZJXc7VVFLEn0GKlu+xSVtz1b4U7bHQ7y6PDXE4Uf7qj/ABJq18Tdaz4V +yq3NzMqkew+b+gqrpFrcaPo1rYyIUmRd0iHqrE5IPuK5Lx3etNd2tsW4jQuR7n/APVVONokp3kZ 3g7Ul0nxXYXbkKgcoxPYMCv9a95h1eHzdtwN8Lgq4HXB44r5prrtH8ay20KW98GkVRhZV649/Wpi 11KkjW1f4SavHeO+iXFhqNjIxaJhdJE6rngOrkEH6ZFW9D+FMcFzHP4q1OGC2BBNrYSLNM49Nw+R fzJ9qjXxjphXP2ph7FD/AIVSvfHcEakWiPK/Yt8oquWPcXM+xheLvDR8N6xJDDMLixdibecfxL6E diKb4M1RdH8V2V05xHuMbH0DAj+tZmo6nd6pceddyl2/hHZR7CqdR10K6H0vba2sM6uwDp/EpPUd xXnut/CQ3uoTXfhvV9PazlYuLe8l8iSHP8PPysB6g/hXMaP41ltYUt74NIqjCyL1x7+tdAnjTTCm ftTD2KH/AAq7JojVM0vD3wt0bTblLjxPqSX+0/8AHlp5O0/78pA468L+def+MPDZ8N63JBFJ51lI S1tN/eX0PuOK6C+8fxRoVs43lfszcD/GuK1HUrvVLkz3cxkfsOyj0AqXZbFK73Ot+FuyLxJPdN1h tmC/ViB/jXrovor2Ka1luvswmiaMTbdwQkYBIHbNfP2g6w+i6h54UsjLsdR1xXaL4101lyZ5FP8A dKGnG1hSvco6r8NZNF0m6v7rXtPmWFSVjtRIzMe2dyqAM49Tz0rha6/xF4uj1LTnsbZZNrkFnbjg HNchUu3QpX6hRRRSGFFFFABRRRQAUUUUAFFFFABRRRQAUquyHKsVPqDikooAlF1cDpPL/wB9ml+1 3P8Az8S/99moaKAJGnlcYaV2HoWJqOiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKA CiiigAooooAKKKKACiiigAooooAM0ZoooAK9w+HME9h4Lj8i+aA3ZaSZUl25GcDPPp/OvD6mju7m JNkdxKi+iuQKadhNXPZtd1fR9Eid57qOScD5YY2DMx/p9TXjuo30upX813NgNI2cDoo7Cq7MzsWY lmPUk5ptDk2CikFFFFIYUZoooAKKKKACjNFFABmiiigAozRRQAUUUUAFFFFAH//ZDQplbmRzdHJl YW0NCmVuZG9iag0KMTAgMCBvYmoNCjw8L1R5cGUvWE9iamVjdC9TdWJ0eXBlL0ltYWdlL1dpZHRo IDUwMC9IZWlnaHQgMjA1L0NvbG9yU3BhY2UvRGV2aWNlR3JheS9NYXR0ZVsgMCAwIDBdIC9CaXRz UGVyQ29tcG9uZW50IDgvSW50ZXJwb2xhdGUgZmFsc2UvRmlsdGVyL0ZsYXRlRGVjb2RlL0xlbmd0 aCAyMzcxNz4+DQpzdHJlYW0NCnic7J11fFPX+8eppm3SuDXSpJa6pC6pe9PUNXWj1KhTAUpxirvL 0GFDhgy3wWDIYGNjY8D4jsEYrGhXtPK7N5W1JWlPaun39837n/Haq/fek/u55zzPOed5njNqlBw5 cuQMFEUkEklqA49Eqsu6OXKGECUUiUKl0T+FRqWQCXLt/5+hiKFoiVO7m/JaFBJS1g2VMyioErp2 boY2W1efY2xqDmNqxNHXZWszunZ5sqaCrFssZyAooDv1ZmjrGVna87z8AoL4wYIOgvlBAb5ePHtL I71O6WlUeX//b0UJ2y44Q1vfzMHdL0jQG0F+7vZmHcJDsmvKuvlypAYSHIJO19a3dPHpJndkcXHp 0jZmFxfndhPex9lCXxsWnQbJjpL1b5AjBUjIZYMVZxnZe3XqHVu+9ItTd163fsLDn45snJvfqbuX vTELFh2y7VhlWf8SOWBg2hRnGTv48Nt0jJ70+ZWnn4rdnXunVhe2W3lfR0h2LS2alty0/zegiKNq QWoxDWy92wSPnLz3P33J3cnba5vbdOf72BkwoBtpyS37SEeRIFKcZe7eNqSnrrv2EVjwdp6fmhEJ XxvAM2PTRKqjZf2z5EgGT4Wg6XK9RbOx5NU/Sat3R3c/NzUcHuO9rXWh8Z1Kkff1kQqaAilO17fz hRUPnXGln4K38fpLkVfna6dPh+5KIajJ+tfJ+RQ1MiQ5Td/OH5YqfdfLASku4ufFcGf3t9OjwV0d J+sfKKcnREhxLV1bP1jx4jPNA1cc5uVGIXQ7P1tdLQqVQpQP8CMKTTKVQtW28IYVr7g5OIKLeHsw Ebqlt4U2NMCTCQhZ/045HSBI8LBu5ApPzkq/H0TFYd7vhfo634VDhwd4rKx/qpw28GRoWNexDYAU Hz0wx008bzdDdt3fVkeLQpF39ZEBnkSmMM29IGc9cuv7IZAc4s+J8MTNnAmLLp+syxwEiUymGrjA w/qkP4dGcZgLqdAA76hLJZMIWFn/5P918CQKhWbsBU/PLgyd4hBvN4RCvpwpjUQm4eXjuyyBx3Vt LmTJQze8HVLJIR5UCAQBXPn4LmMIJBLVgAeN66n9XWWVis9DBXwn0fguF11GKEKSaxnDc/LJg7Dq BsL3yQKBFzS+kwgYWf/4/00QRBKJbuEPjeu7h0dxiJc10PhuRScR5aLLAhwkOcM6cLjG9Q62hwqC bBiQ6FhZv4D/PSDJySy7IIFgSsNwSt7aejNVwLdjkohErKxfwf8aOCKRrAd7b6uGV3GI+gIB30Gb RCLi5NFywwksub475L3tHHbJW1sbKgXBTmwyiSgPkRxGsAQi2cAT8t6OSadWC0RzE8THDyI+Qv9s bm6G/7c0t3k/RRDM0yVDjpySrN/E/wxYAoHM8RIIor6VRm9Y6vdvG1+/qH/65PHDPyAePn7yd/2L 141v34vEB9e9eREsOomAl8/ThwkMnkCCe3kcsMPeAsv95vWzxw/u/XLz+pXLly5d/Abm0qVvr1z/ 4ed7f/z17PUbWHhg3TcIgp3ZBLxc9OEBDUmu7yEQpACGMLc0fXj35nX9w7s/fvftN+fOnDh6+OCX +/fu2fPFnj379h849NWxk2fPX7p68+6jekj3Dx+awGTfBztyBHlPHxYQODxRF3LfkoAkhwVvfPH4 t5+uXTx34qsDe3ZsXrdqycL5c+pmzpgxo2723IWLl6/duG33voPHTl+4evPe4xeN796/bwK5824B 354pF31YwOLwbF6wIO4uiOLv37559eS3m99+feLw3s83rFgwc1JFYVayMC5SEMzn84OjYoXJmfnl E6fNWbJm8+4vj57+5sbdxy8b374FUX1FCN+WTiDg5GFyQw0Wj9ey4QuifgFSvKH+wa2r547t375h 2ZxJJVlxwdYGOkwaFZpn4SEg75+iRdfWNfSNThs7fsaiNVu+OHTy4s3fn/3z9l3fqjfPDQmyphPw WHl609CCweMpZr6CsL499pZ3bxqe/vb9+eNfbl+3cGp5ZqS7HpNCwGhqqKmqqigrKSkqKikpq6iq ItSRaByJxuKEpRXWzF6+cdehM9fv1//z9s2Hvp7wcYIg0IqKx6HldUmGEjQOTzb2EYR81afk7/55 9eTed2cP79qwZFpZmsCKQcai1FSVFMVUkVBQVFRW1UDjtdh+CfkTZq/YvPfEtXtPXzU09tXXG4sF /qYkHFY+ug8hCCyeCM3SQlb0pXhTw8snd6+dPrBt5eyqrDAeDa+ppiJO7n9RUFSCdCcx+SnFkxdt +OL45btPXze86cOHf5Ut8NAl4LDyTPWhA4PFs12DQyb1kbLQ0tjw/PfrZ77cumJGWbKfNgkSHOrg ML3fXkFRRR1Ndo0rmLRg7c5j1/5T/7qhj6DKh/HBjiwi5McpfoJCJ8Pzbv6fgsZiqdb8kMxXvQvx 8dWLP2+dP7h1+fTiRB8GEaOBUFVRUVYW2fC+JFBQVNXA20fnVs9es+vkzUfPX7zuvat/GyGw16aQ iRjVnqiowA+Fn9nnQ+VIBIXFkYy8QiL7mKU1vnh67+rRnatnlif5sSl4jCYKhUIiNdTVELDvpth3 Z1dWx5qFj6meu27v+duPn7/qPZl5W0yoHZtBp6A+odsz5aL3C0U0Fq/nHtLHvkpzw/NHP537ctOi muxQQxadQobrPRKh4ReL1kSqI0QK9PkkZTWMY3RezcJNX914+PxFr9GVzbOSQmw4+nosUg+IBDwO +t6gaYJK3x+aHPFoYrB0e35oXa+Sf3wNWfITu9bWjUvxN+Xo6eqIYLOYdC0KEYeGVQcQfZSikhrW K6FoyoovLt57+uxlb+P7i8I0gaOlpZmRTlfYLG3okWQC9Eg1VZDvTI4YUBgs0dg3JK3XsJh3L+v/ c/3EF+vmVmb6ebjyXNpxdnSwszbnaJNxmhpgokN9HckMyhi/cOvJW4//ft6b0/hjRXEi39/fx6UL zk7wEy1NDfUYRDQkuryj9ws0BqfDE4T80KvkDc8f/HTpxN7PFpQV5ufldpAzJjsrIyUmwFafRsQg ISceQAHYrOO8kyvq1n9188/nr3oT/eyK+RNLS0sK/32e6IFpScKYMF87XQISAfREOT1BYTBaNvyQ XkOhmj9+eNvw8tmTR7/f+fXXX2934Zdffr51c7/QhUMnYZEI5b47ugKkOQJFsksoqdt4+u7rj73t trX89ej3e3fv3rnT/Xk//Xjz+2sXjoZT26aKw/GS/n+hhsbgOV4hGY29ad4XOxKdjZhkENEVFJWU ERpokrZJ8oQ1x5/0/5FvZ3BpaHVVgK9MTk9QaAzTMTh0YKnGbxfGOhkySRgN8WuwnUCdXEkFgcSQ 6AbcgNpdf/f/iU+nBpjQMEAji5weINFogol/yJwBSd7a+rgm3J7DIGr2btLhcV1VDYUlMzl2wbmf iakcCcqvEyPsdClg1kROD6BuznISRD0eoOat18uCrfVpeFRvIogkV9fEU1kmzhGlh/vcXpNI84Wq WJ6JNpAxkdMTDU1NkkVAyNaBSt7asi/Xz1KXikVKtrCicV0DTaDpWngIawZQqeTNgepEbxuOyJbI NZcalCaa5SzIHIR048blaR5mLDJGXYJJF5lyNciUMwy4fpnzH/X/SfVba1KDnC30aARNdbnfLjVw NzfzDzs1cMlbWx9NiYWcd0kmvd2U4yjaRvaCgi0DSIv6bUNtVrinrTGbgkOBrQjI6QoS6uZOgrzB Kfp2ZVyIrSSTrqCg1GbK2Wa86IpTUpeK7aTp+vrJY2L8nS30GUS0fGiXHnWUqJufHRTJW5t35/nD Jl2MEu2mnAiZcq+kKbf6/4zGs+sm58Xz3ayNWG3dXK65lCBRmkxHwdhBqu3Y2rAoxd2URUar9xhx 2005FjLlNgGjl/7V/yfUH1lVm5cg8LA10dGCrLl8uV1q1FEovJF3+NeDJHlr639qox0NGQSRSf/3 MW1TNNiUGzuGFu7s/4Jfy/19yybmCoNhyWkEtAZCvq0mNepIFN0uOLv/xvUTLpQJoFk6rtu0GV5t VYWmaFpsM9fYqvNAaQ1i+XBjx4LK0bFBrtZGbCoe7uVyyaVFRQOJMfAMPyjpHffjW/j4+RgfSx0K tssabJspxxDp+lbeKTN+7bfirQ1fb5xVkh7p52zJYZIhWy4f2PuBOhJJMg9IeiPhHTc978es/eW8 JFcTbVKnSW8z5aLVVtvAMavq+y/5X0fWTS1ICvV2MNOjk0T7tnLJpUcDCXlwoRskveQnf/zxj/TS 3JkY6cBhEFBwBLRCx2orjsIydgwv2d//pZ/mu/uXTyqI57uLvDe5Ke8nakgk5MFFS0pIfHP71pUb ksaAXjhZHMTV02oz6e0bpwQtHXO3uPGX+z8/aLp1YMn4XGEAj2sIzdHkDnt/UdNA0uxCJkp6zbe/ O7Pv4FXp90HebxztZc6mwEvhSkqijVPYlPuk1YGf0STmpifW1WTH83kW+gwyFtkZVN9Gz8D34X6R /0Xx9uoammzXyHMS3vLLy6e2LFu584ZUpUFE1M8S8kQmXVVFpWPjlJ+77sUAJG9tPbuwOCaAZ6nb FoKlDMe2Q1+UsrKyCvSQLoHvyv8Gvg+1Au2fm1JbO5RFTx6uZ/cThIYG3tAzWcLo3XLl5La6SbXz N4EkJvfg1vhwew4dMrpqahrtG6dlXw2wFvidGTl8Zy4HMuVIOLIdFhqhpqauoYFEolCabXREvkN/ oAonPYC8/R4jhYR8mZ73EV0CJ2KqqCIQaurqUDsgoP+qIURZHiA5HrIAoa5B5fIXSHjH9Sd315Xk 5pbN3CF9+FLLV4UBXD0aAaOJxhJpOuYewpp+DBfdeTczzdsSmpZjNCFVYalRmmgMFocnEIkkErmd ttB3LAatiYK1F2XJ9vbyYengTtplqPgkYab72NF2FaS3MqQ29Mkh4VZgcTg4/xqPw2Hbnj1iEy7U 1FEsZ4m1gr7es7QgOS5OWDTvS+mjWd6uzvCy0KNTiCQq04DrlzH/4cAEh9ma5mmiw6BAL1WkNZFE oWrRGUxtFputo9uGjij2nUHXgmsF47Fw2oM6okP3T19Au3Yi6bqOFT1zZtqHjo7vp/0iSG4M1Awy RYtGZzCYMAwGnaZFIRMJOOjLVIczLkbYdFJVTR2r75H6Tvwbfn7gs3FxfH9/flLZ0lPS+3F/TU9w szBga7P0TBwEBZsHo57kzUxvYxaTBnVrMiQ2k6Wjp29oYmFt5+jkwnNz94TwcHd1drKzNjcx1Ndl s+D6B0Q8Fo3SUEOIl120PgjnyGNxBGLnWEEm90iaEWXNdNwGtt0q0DWQ3kRyWzM4xmZWXGsYS3Mz Ew70bG045QKL7sjtGTmqI9TVSWYBCyW84XNb6hL8XOy57qHp1WuuSD/HulEd7co1MzHlusdUHB+U td23uf4Wejo6bPg1G5lyHXgevkFhMcLUzOycvLHFJaWlpcWF+TlZacLo0CBfD6jpJhxdSHgKEY/R FPv2RZJDiuNJVEi7LoNFt6QZNovFZNCoJAIWvosq7EVoaGKgaxgsXUMzayd3n8DQyLiEpOTkJGFs dAT0bE+evaWRrjYNkh2lAZbRNVxAbafZRkjYRX23bXF+gIOFsaGNV0RW7aY7UivUfKA00tPZ0TUo bcpg1QleEulkamJqZm7r4hUUIczIK66atHzLqXM/3L59+169iKfQP88f27ygpqI4J00Y5ufuYGWs z2JokfCiGhg9VG/b+MFS2SbWDs6ubu4eHu5uPBHd02bsbawsTI30GGQcGh7oYcG1GGxDCwf3wIiE rLEVNcs3HTh95uzZM6e3bdm4ura6NC89lu9uY6LLpBKxqLaMrhGiOkINmqkJn4t/v3dW1UY4GOmQ tI3tfaPzZuyQfvezcW1RDF8QV7h8ABun3TmX7s9z9w+JShlTOmHFwWt36iVbjBdPbn93YGH12IzY YE9HC0M2g0rqzG7rfP2KSvACIZXjHJYyJn9sUXFx8dj8PIjcruSMGZ2eJIyLDvN1NKQTIS8NT6TQ 2RxLJ7/o9KIJq47+8Ocn85H6328cmF2YHOzK5TCpBAxy5OwLqKqpYTk+EyS8tF0L8j1MmGQshW3q FCAsnLdfej/u0aKSrLxJeweUKdGN+uoxaWPKJm88+8tTMGPR+Pu1PbNKMqL8nKwMWTQyvrvqUDeH I7V0nIsfP33699/QMPF3jwyddi6ePX3y+JEvFroaMmiQv6atZ+rgG5VVufH7x734OX+empEX7cU1 gEYH1IhZNIQ0J5gGSijJ/2r99DhbNhmBxGnpWvAgP27JSemn1zdXzFl2pf8bp5+yffmOq39KO+d7 cnVdZXa0j72JDr0zjbJtxqWkqoEhM83DAI8l+CXSzlBfX9/Y0jUkfdz6G312gqZ72wqjeKbtm74j QnTIbadah98Q397LC8f5mjJwKmooPE3fyi0krXq19Gvlzd8e/UPaa3rlpYQ5Rl803NxWnhzoaKxD I2FRnZvuCspqmgS6vnMW4Hmg32d62XKtHbwixsz85gXYJQ9WZflxdeHgjpERtodQQ2o7C8V/rS0r J6c46FHRSipqmkSGoY1nRNakjbfBfmcX3gwgTWWQeXZiQrK/raE2FY/uyJhWVFHHUnTMA8YB5k99 Wxjq5R0Um7/gB/Cpa9OZwmAbfUh0SfHfw4oKAoHW86wS39TXs0uCTOk4uN6TOhr243wgP277gDNd wBlMi9DOy8PlsR4W7cv18PiuqIokMDh2MXMAB7DTlUmxyYWzv5NuseJmeagtJHofKV3DpjnW0G+T +IbemDTaSYeEEs1mNGA/zjEgvnDuvj7qCw0e//w+0JVacTxelRNsx2HCxexU4LKFCE0y28w9cy/g 5V9NK6mYdVjqoevHMoGNrhau15Su4dJcVRVvGixhdr6hLNaShlUX+baQH0fVtXCB/LjFx4foyNQe tPx17Vo/YjX6pulSRYyLiXZbiLQSNLRr6XMDS78DvPrg8oVb7vfjqTfG+luwRcFistccQbaOEL9n 9rFuTACHDBfjU1BQ+tePq1r97WDFRPfGh59OHjh2f2ju/WhWkodZW1y8sioSzzByiJoMuBXw8dS+ 0/36Elt2pLuJsntk3tFVVNVpjkLxk+e/xyfYa+NE5XVFokN+HMfGMxzy437uz4+Wjtfnd21Yt+3M EN39xcp0L3NIdGimrqZJYpm5pswHXEB4c/12P5eQX0yLsIXjhmTd0ZVVVDSYroXiG3klP8SY3F5d t9OPs/OJzpnx+ZD7cY8PbZw/c97yL4dqRHm7OcPLjEXGItWRGKqelU/OFsALGx7228e4nOdtyiLB HV3WmiPZnvPEt3Fjshcbo646ql10yI/DwH6cf3zhnH1De5Jm089fLJteWVpTt70fcXhgvFuf6mbM JGFQaDydYycoPw943Yf+u5WN06Ns9bWwGn2UxR0GzVH6ftvEt3FauJMWUrXjTzv8OHOXoMTSxcf6 uS4CxJtL2+aPLxkzumTiZ+CBGk2NL1+8eNkI3K6GuXGOHDoRiyNrmzhF1d7rV0ul48hoDxNtIgoh 28Ed0lzTmH9cbAvfV/tZkTT+1VxBsdOPS61adWno/Lj64+tnlY/JSErMrdz4G9glTfU/Xjh17MiR Yye/vvYHYCD1g0qBla4WiaSlY85LmvOs/+0F5reKICtdClpNWdaaY8zDxE9TnhXy9NCqKp1/2+bH EUR+XOakDQPIKe2V5vv7ltcWZQhjI2NGT9wF5Dh8+OObr3ZuXLN86dLlqz/bcfjCA7Dv8XCWuwmL psU04HqNXjkcU5F/ZsbYc2g4ddlqrqSsgrOK/F1sC+9m2dA1umje6ccZ2flE5Uz7fAAFInrh/fUd C8bnJseE8kOiCxYArYG//vbApqWzaqvHlZePq66tW7b16M9ArvWryeE2HLa2rrFdYNGhgbUakDWp PBMmAakiUycO0pxgHSs+keibeEuKWlfN2/04crsft3co/LhXZz+bVTZaGM739w9Lrj0N0vv+OrVt ydTKwjEZqcnJqZm5JRPr1h4GC9I9kuVuxtHnWDiFjx9AURspOJTrZcEmoVRlrTnZPkm8AdwVYYhV Vu52Xml3P+7oIBSf6cGfB1ZNHpsaHezn7e0fV74HpLvWH9tQV5WfLowM4QcG8kNjUnLKp687AbQ2 +ntFsI2Zsam1m3DGIARnAnCuOICrR0EjZHkeqIKSkgrFKV18A5fy2ShFxW7NUxAFGIj8OEFq1cqL g7wH0nRr9+LqnISwAE83N6/Q3NUgyySNp9dPhwYG6BpXZ0dHZzffkPjR5XU7gdzw93VxLtYWVg7e 6QulDelofvP88Z+PnzyXbn3myrhgWwMtjJosNVeENKfyCsU3cIIPQ71nYHanH2cN+XE1GwYrxK2N Nxe3zCnPjA32dnVy4vmnzgSJpmq5tq2uLCs22MvZzsrCzMzC2slLIMyZuOYi0BM3ZXo72NrxgvJB V2Taafz90qkjhw4ePnb26iNpvvvvq0LtDWlYNVlO1hQVFZVprhJ2UovdqYhPrujhxw3mkFh/bN20 otQIfzdHO1sHj+hKoE2P+gNLxucIBV5O1ubGhhyOoam1s29ketnio0B++OGCIFcnF8+IcVJV2Gi4 eXLvljXLFi1esmrjF6duSyH6D+PDHIzoWHVZag4fgaXlPkVs+1oKXMhiJhXtfhwL9uPGzt3zQpqX 1RvN9/cum5iXEOLtbGNlae0UmLMV5F22XN4ysyQ9KsDVzsLE0EBf38DY0tErNLlw3kGgQfdcabiX m4dfwmQpAnqbH57atXrelAkV5eVVNdMXbTomftYjlu/Ghzka0XEy1Rzu5wyv6eJ/W44jUWx9t04/ jp9UvuT4IPlx769vn1+ZFRvkbm9pamJu4yGcDhS20nBsVW0hNDa42lmZmRgZGhqbWTv7hKUUzT8E 1M8vVcX4e/vwM+aBl0Bo+ung+jk1JbmZqckpGTnFE2ZvOgP+Ci5WhTkaM2Q7QYf6uYq21wKx7WvO ssVJqumHgP04rkdYxsR1lwfFj3t15rOZJWmRfi5cE46Bobl9cDHY+vfDwyunlWcnhgd6u7lALpyj E88zIDwpp3oF2Ibc5QnC4IDA8PxVwD+i5ae9y6aUZifFhAUH8cNiUvKqFuz5E/Ti1mPjQmTezxUU FZQZ3uJzWJoybHDiz0Rs21dlGtv7xRXM3DGAwjCdQFO02oLEUC8HC44uW9fQ0j15AZgj/eup7avm TakqycvOTE9Pg8jIzi+bMHPpbrBVwiu1yaHBIbHjwFdk7u1dPDE/JSoI8jOhSYJfaGJuzfofga/e VcR3MKTL1oeD3HJlppd4zZvTbLCK4gu2wuchYqm6lm5h6VXLvnoK/JMlIJqiZcfB5UL0tBlMHSO7 4DKwqJWWxw/u3Pr+u8uXLpz/+pyIr89/8+3VG7fugi2fX52SFhkWkToZNEam9eWhZR0uo4mxqZWD V0hS0SLgSoofVucF2HNgv33Yle4qn4ISw1v8VmpzKhcjXnP4MEQ40sDUOSipZO6eGwNMV4CmaLPL M6IDXLiGLBqFStc15SUvG57wq2tTM2OiYsbMAY3Fbrm4riYnLsjNxlSfzWRo65nae0dmzez7ZNl2 ni3J8rU1oGJkuiYDa870FX+0VkuqNVZJUewqoUhzaHB3DEgsW3zg/sC2J+qPr51WlBLu42ihz6QQ CWS6vlVAiYR4+8Hm8rSs+NiEouWgwU71u2cWCIN4VhxtKhGPJ9J0zaHPfvJe0Mfdq0vxFq3DyXTt VdTPZ4ptYEs65MMpiWudaI4OT9ecBVlTtw0sX6Hl/v7lNXkJAk87U10aEYvBkZiGDjHTBy/TqVcu TBudKEyr+hw0DuK7leXJwa6W+nQiBqWhoYmnc2x94ibuA33cuUlxHpY6Ml5vh4ZuJS3PSeJbmGmP VxajeVuhN03YcfdJnLh9AIXeID78sHvR+OyOio5oFApLZpm5Z+4c0E3BOT01Ozkpe4qkUjo9eb9v 5ugIT2sDGh4F18hRQ5N1LT1iJhwBvPzjlrJwnhmLKNt9NUXIh9NyLxHfxFIngvKnonccq6GlY+ER P/7AwGKXGi7BRTxjAlzaKjqqqyOxVD0r/5LLA7orOF9NGZOaWjAXdEXm788qhf4OxkwCCq5Kp6iK IrIt3GImgYZVPVmRF+xkzMBryHb/XEFRleImoWr7PB5ZWblnvF6XQm8eCTUXBjY5f3Zh54Lq0aIa 7KKKjqoIJI7GsYuY9GBAtwVnR212ekbZMtCx6ufFueHuljpktJqo5J0KigRpHj8NdK7205w0fzvY bZex5koIMi9HvPXc5U5VUemhefsJWW2F3mZJX4KgG//8eGhFbZ4wyAU+XQPOH1NWRRKYJk4Jswej BgkAHzdNzM4YPX4DaBrSyWkpgQ5GUEcVJSBB/ZykY+mRPAd00+FYbby3tWgrVaaaKyoj8I5Z4pc5 r3ozemjepWarXWDO6oGZcogHBxZVpId5WBvQifCheEpK0Ftkm7tnrBiKlCUxNKytHJ2ZO/Uw4J+/ 31IV4wX73VBHhZMbVTUpelzvrCWAuVwfNo+LcGsLmZBxPBwCa5sufpfgYaCOmopKl6lklxOyBlaz tYOmiyvGJQU5m7HJonOT4NQxii7XN3/vgO8Mxl9LS7MyC+eATgyfrCwI4ZlpE5Ei0aAhEkM1sAko 2Ag4V326Mj/Y2YQJjRKyjW9XUUWQrJLEBwY1hhkiVbto3mHKaTrmbvETrg5GX2zcVZsSADtFmqJK wEpq8Fvklw3e2QG98/PssZlZpUtAx+Zf5mYEOBjS27dIFJTVsTRD+5BK0NbCl8O75zIOgRRpbi4U v3jYHG2OVlXtiI3qPCGLrs/1TZ8rxQZibzxakhvc7giLNIffYlg1YPb/gDlWk52eVbUW1Hs4WSv0 ttantttjBWUNPNPEOXYq6Ks4NTlhJJjzUQgEgmwYLWFRIcsGr6qqotAhefsJWYb2wXmfDVo68tXJ 8W5mrPYy78rqOIaxYzRgfkHLh/fv37172w/evGn8p+H1q2cLitJSRtfsAByxPm7pZo/hqRrL3D11 EaCN+7h1ZJjzUWpq6lS90JXiW7nORQuBaOvo/56QZeoSVX5s8A7xaNpTxLc1aDvEQ7G950wDG2zf /vbD5fNnTx0/ekQMR3vhyOED+3ZtWbd4WlFaQmL2NNCxub6bPVZocz788kDXj+pHiDkfpaqmQdEN rBX/pf/iy4KLHo7qdkKWR9Jk8L1DABqWpnuas0WnLiqpIAnaZjzhLLAN6YarR3dv3bB6+ZJFC9tZ BLF48ZIlS5ZCLJPE0qWLFsyeNnFcQVZidLQwdw7oZvDteRn+/9pj2PnQMrAVjLsEePmdeZkjwpzD tduJBt7l4ofqNyFGaHU1lW4nZPmPXjzIOal/dJ66CE3PiSwz14Q6sN3ZZyc2L6mbXF1eXDhWRGFh YVFxcUlpWfm4iorKyioJVFZWlBcXZKfGR4YGB4fFFiwB3Qs+PVnYxR5D5lxkiKbcB7z83JSELt6A LFFH4jiuBeKzwlriuER1NaiNg3RClgTgUxfhJWyECgK2kJDmYP38yf5lUyrGjk5NjI8TER8vTEhK Tk3PzMoek5ObmyeB3JwxWelJseF8f18fv+CY4rWAKzIft1Z0M+cqog80eR6ga9O0rSLKfSSYc/jM TJyJTaaE8WkFj66hro7oWG0d4AlZkmjek+9vBR+krKauSYI0F84A26p7tH1WWXZSlCDA1wfG188/ kC8IjYiOFSYmp6SmpYsnLTUlSRgTHuzn4cpz9QyMrfgSsJnPVuULIHtMaDfniqqaZF0rrzHrAT3A 56vHClxMOy6XKSg01sguYZf4dt731dNEIjU6Vlu9U2cMcLVVPI3L0kUHKSM10LDmcdPAklEfbpo0 Rhjq6+poawNha2fv6OLm6RMYEhWfBCmekZkljsyM9NRkYUxooKezvb2Tm7+wBnQ/5878rva4fS0h qOQk4OX35mdBl9NHgDkfpaaJ07OPmC3+Y/0YYUVCoTVR7cdq5KwZooTdR1PiXSCTjtHEkFlmvOhJ YPPzPzdUpoT5OMFRkxCGRqYWXDsnd//ojLFlFVXVEyaKZUJ1VUVZUV5mnL+TjbUdzz95JujpMN3t MTyvpBs5RNT8Anj5hamJPjYjwpxDHR3LcAycIKHE70Q3FgaLJ8CrrU4RpQeGrM7A9cowOwM6AYuD AzHCq8ACzJ59ViEMcuUa6TLpdDpDW0ffyIzr6BVVsOfshYuXLl2WwKVL35w/d+bo7oluVpa2vICs hYCZlj3ssSI8xzB1AfU3W5t3VkW5t8VLjADNMRQ7j1IJYaK3g0zIJApNdKzGhGtDt/PRfKAAMula RCKFZeLIL9oG9KT3n09ICHS2MNDWolAoWnRtXUNzG7eIogNgj5zhYWlhw+PnrQdcLe+wx+0BD22b ap6ZywA9wJdrxoa4mGrLOg+5DRSGZO2TfUx8S5tiHXS0WPrGXL+MeYNbs7UHb1ZleJqxaRQtlrG9 f/bSF0AXnZ+RHsyz4rBoVAqVxmQbmNq4RxTvB3MyH6W7WVrauYWWHQVsYXd7rKCEQFP1rf3HgsZF /WdhVqCDEV3W9QbaQKJJ5oHCpRJ61rIArr4Rlyco2DzENVv/mh7vYsJmMNhGNt6J08FyH/9aUxrj 42BuwGYytdl6RpaO/sLKA4Dziq1xzlZcB8+YGtAFpvOQPe5mzuGtgdCqa4CXX5qeBJtzjExD2zvB kAz8o6dIyBR6KvTk2vokDNKxGr1xszrc3kiHpWPIdY8ctxNMuesLC2N8naxMjYyMzbku/rH5s74D lPy3smAHa1tnn+RZgCtMzdu72WMFlfZlYsDRr2VXdbSHpQ5ZcySY81GjsESmZ/Q4Sd9rfoRvUObM YagB2HK4MNDGSE/P0NKFn70EbJel+fry6uw4gb+Pb0BITEbprJOg84r3q9J8HGwdXANHLwH0S190 t8eiWDhz99SFgFHSr9cWhfLMRog5h/o5ge4cnbdDQmMv5mUVrRpwpgoI79ZmenONOUbmDj6ptTsA Yyufn1szc3x5SVnlpDkHfgQ2Py3HxkV6ONo7eYQWSfrdPbm/oKs9bt9g8c0FzVt/sCh75JjzUaM0 8DTL8GxJIWhNdQsODVOw+d+zEt25psbmtu6xhQu/AU6UePnw7t279c+lWR/8YWY639XB3tkrqgqs NkFr6zfTutrj9g2W4HLQPbkrM5J9bUQVJkaE5qNwFIPgLImnIt24NRxVtET8PD6aZ2VmzvUKTZ+0 Ywhr9N1aXBTt42Jv7+KTALjkB0+vu9rj9p3+qFrAA0Vb9o6P9bDSHSnmHNKcrOOTOf4LSc0F+1WD womSUCeuhbVHUFz56mMvhughzTdXVibz3R1s7Xn+6fMBn/JqbWFoV3Mu2vV1TZoL6ED8s744TBRJ NzLMOey4a9slli0d9Er876X+XN5vzAl0snZ2840pX7x9iIaXxrOrJmSEecErr65BuWsAn9J9ei3a YNGx9Bq9CvDyh0uygxyNZFxsoBtEhnFk8bzBTgt8+Yf0X9Hzeam+rq5u3vHj6kANrXQ0P9i/dPzo KF8nawtLW9eQEtAw5+7T644VmULQy7+bmeJrO4LM+ahRBBrHL3/mjkHtWE0Pbly7Jf36/J1J8Xwv t6CMyqlD0c1bnp7ePGdcRiQ0pzcxMuXyIqoBSwG27KiEZ+ed5rw9RqYStJLg/vExHpaQOR8JGyxt YKm69hmT1gzm4urbm6cOHTr1i/TCnZ2QGOgbnV/2wyA2pp2mJ+d3LK0dmxzm7WDO0dUztHSOBj2c 4dWqgmBnk05zLlqF49hF1AKWP21cWwhP7keOOYcgs8yjq5cCl0vom+df7920dv3nx8ErrXTwYXd5 fHRm4fhBdx3fPTi1c8X0sqxYvoedqZ42Q1vfzDl+FuA09P6cNF/bf6vzijZSDR1i6wBDXh/Oz/Cz M6TjZJyc2A0iw8i7cPa2wVpSb3lweOOiuhmzFm48Lv3JJa9WlheVFQ84Lao7zfU/HN66bNq4MYnh fi5cIzaNQqHpmDglSgj4/YTzE6LdLOEq3Ertmmvg6P/H3HeANZV1a/+igPQOCRAgJPRACCUQeuiE GkIIvffei/QiTVFAEBUbI4LYlbFj7/1axj5jwYYFQentu+ckIScoKg743X89zzg+Mck+2Wuvutd6 l7Kh34ZZfvxaAc1cG/X/S7KdSXBFveCijfPkxY3d2dlQmp2akpZb2fwvpvU8X1uZs2d+noRBE72P Tu7aWFOcFuVPcTDHayohpMRExKTkVAx9Z7nO5MY4R0MQbZ8ZXnNw8opIKxn6zxZ6qC3RmaAhL8Fs ZwVpAZ3+T3kuIa/pmrtmfmoiBi5sWZYdFxYYGByVVtH69Ne/4G7zivlz4EZ7Hp7Ys2V1RU5SuB+F RDTUVkXKSAgLCIDFXvrUWZqznkJfCxxaWmSqlg3guTAchadent3H+4v9iTrKMmIC3JyLFnEyaNHC hXTO/9/xXERW1Sxp1a75yH19PLq+JDnUi+zs5EYLTqne8+sGY+LcPE1VG+19fuXwrubVVfmpMcHe ZHsLAk4dhZASFeTl4eEXgSGx1sH5Netbduw/dPT4iRmp8+jBfTu2rC4MJeHV5SVZAxY4OHmEpJBY m5DZfLxldXGEkwEGCc7I5V7Mw8vLx8fHy7OYm4tz0f/pQPQFMir4gGWtp35tHuQMNPl87+q8GF83 WwsTE3M796D0+jO/LrPfTZ0Pf/jY0zcwC8dpvP/Di9tnDu1pbaotz0+LDfXzcLYxM9BWR8vBxIX4 ebi4uHmFJeXUDB18Y9Lyli6vbWhcy6I1dGoEaXVDXXVFUXZCgJOxJgqsxmbaY45FiwUlEKoGDt5R KTklVStXNTTORPSPFy9JCHI2wSrLSooI8vMLCImIAiQiLMjP+9UY9v8yxxdwwNE6jvmbD82183Ds zvaVWeGeJHO8tqYmztCKHJq3af4S55Ov/75z7sTx453nbz150f3xY08v2HzG9obhoc8fP7x4dvfC 0T93t21qrKkoyEqKCvGlutgTjfW0VFEIuLgwIGyAhuXiERSTQWkaWrnSgiLjk9MzsyDKzMzMyEhP T09LS02Ojw4L8HS2JmihZcUFeaYGJi1YxA3oCQU1PXMHd5/gyNjE5JTUGSglKSEmLIDmYm2EVZaD S4gIC4mKS0nLyMrKSMMkRMGzxznPE3MXTKcfsnwRFwpnE9vYcWVugj5w4Y/K1BCKrZG2GgqJVMLg rSjRZTvmLanbd+/qgS3r1zY2rNu0pW3Hrj37Og4eOnz0GFOxHu88Bjai7drWsmntquryoiXpidGh AV4UZztLEzxOQxkpCwM4DqJZLORYuAgEQVJQ0zWxdab4BIaER0ZNUWRkRHhYWEhIUFBggJ+vF9WN ZG2qr4lGSAqDLXXMHVvIRW/kUtc1tnRwoXh6+/rNRL4+NA83RxszvKayvLSkmCjgN6rh9A0JRgQD XU00XISfZz5HYy8A3cOFCxeBLgPwxw/9BUb7oSLOyq9m/7U5FTMDprw4IcDV0gCDRsClpGSQGga2 3kl1p+fJI5t8fPVgIyC6CSkZ2XmFpWUVVdUrVtbW1Tc0rAapoWFV7crllWXF+dnpyXFRYUF+XhQX ko2FMR6HUUHJSUuCksXNMKIgvp0oTF5Fm2Bh5+xO9fL1ZxLIKB8vGtXD3c3V2cnRwcbS3Egfq6Yo y5ioy9xC8PN8whIySFUtPYIp0crGbmaytSaaGelrA04EXFJcTAKuqO8YEBEdExMdGepJ1JBm/8p5 YDlwkjm5AI8BcBl+4i9MtR/q2fpXHrk3B++JYcq9ncz11JEg0puwGBzEfg5csnGWF44/o3fXOtcV JEcE0nz8A4NDwyOjY2Lj4hPoPWoAJScnJSbExUZHhoUE+nl7Ulwd7a0tTAx1sRoqKHkZKXFhQT6Q 4+DhB+SUk0dADIZU1zOzdSJTab5+AYEgBQQEAFz3plJcnRzsrInmJoBAamNUUXKATWAXSkYzl7A4 XA6loqGFA/spZiJ9PV2cloYqSl5aSlwMYLm8btC9Dx8+fAT++/DuuAVKXGj+BubSewq5FvPyCwoJ i4gIM/wFzkUzMR1qPyS4xNRenAPyF9OUO5jgVOSlRAV4eXjpEHIW5Kil86PdR2+fbi2I9nUjWtna k5xc3MgUD6onDexS8/EFyMfH24vmSaWQXZ1J9oB4mhDwuliMqhJSDthxwH3i4Wa4TIx8OSeom5Xw Dl4hUXGJKWnpGQwCjXhyQnSIN9mBaErQ19HSUEErIKQlRAX5QI9ragMZqpFfSFQSLiuPRKGVlGcm JTQKKS8LlxQTFgYVu4p1EQRpes9NAy7KP29zNIFjCIiugLCYJAwuLQ2HAWvS7di3tmMBq/1QFR9W 3jmH+Jxpym0IWCXQ9C3m4uLiERBHqOJtvJJqZzU+6Wf0/NL+ikgPW1NtHT28oZGxqZk50dLSytrG xtbWFtSjtjY21pZECzMTI0O8Hg6LUVNBI+VkgA0XYZ55SNMtWAj4YFLyOi7r9h/pPHHq9JkzZ5l0 5syZU0d3NOYCJopI0AZUhJwMjHFi6J+HdhhgOiBUQiJiEpJSMDgc2OdvCHgVJgXodBFBAX4BEQkZ lI4H28DKEzRtOUkhnnnKwDNEV1BMFq0BqB09XR1NFYQECMX1jZNIf3RAHuEKGBNq6ZU5cAYy5SgZ QGUBa4GSICSpgKFr93loc+u/eqwx3sNKT0ERraSipq6hqYXVxuF0dIFfqKcPEvhLcdpYLYy6mooS CiknKw0cdhEhAT6eKYYvYP1sQLWLyyhbZsy81Hh/9421yd7W+hpowN0WneI42+4xjScQbfPxCwgK fZcEAXbz8S5ezMMHhIYqxqEXoEW2eOoqwkTmq2MR+ElgU6Ec1sYzMCQ0JCTQ20lfQVyQ9xsnkWHK hcRlFLUtA0tn23g1A7GbcrgYuNJCcAIEN58IHNTuEUu3z1m7Tzw425blZamDEpeUgkvLIOTkFZBI RRQKjVZSoqtW4H9oFEoRqSCHALgtJSEmKiwI8pubnvKa5sGCbjcQamlT2r6/3tjj1eH2+koImKgg 72IGx9k3j+EkAx4yEOoDtHhmAv6Fiwv0orl5haWQGjbJ0Nn/soKig5YW5Zsn6FdGJCGj6XL4yd8g PXl8Pw0nDc5355j+2CywNz2HyMZZjcL4zv7cZjPlzAhkAX0sF6jd9QHtXnNyri3Mry8frAq0wcnz gnIlLCIqJi4uISkpJQWDgZqVTjCYlJSkhLiYKBAI08WL7rou/DZiAcJrcJS7SdgPc6eDx2LttRXh ogI8XDN8ByMW5mDQQogW0cMkJjH/eQGYn4cparvkQ0nJ14VuusoyX/N8tsnYb6JvcK/F4GjzNMgJ rzRWkPjKSYTA3tQMycl75gD2NnD+j8qUYMCUazFMOSfDcILjHOja3QjQ7hvmqN2Hbh1vinXCK3Jz guEII4PJzy8gIAgQpEgFBQBe0xObTHbPHKFyLOIRgiG17NN+0pJ6OcYGI8eErpuW65jiJdvOM15l Yzb7yvQ7GbQ+jQ3e4GGmExvPp32a+c3f4/W0ZZiPAIg5H5hMJq9jLdCTb6kiIwYOW5/mhTBxW828 cuZiyj8cAUy5P7spn8pWAYcK0u5zGrQ58fTavjyqsaok8yfTEw+AXmVoVohATcrJykd8T2Y4uPjA meceVd/pxp2iyY5gE1VZcToqKfNuZBGDmH9fyDoLdEXPxcVU8tygQmczB4wFCUGHoKqAs4n2dJ6D sHjTP804rzMcV8b7wBic7Y10K8pBly55NdMwqPa6K91OEwkT4WMpKXawN+vgqtm2YM+0L8/21ufS Tbkay5RDvhKo3WWZ2n0u3U9v755qiLTHyrBiJXZxm0azuKQEGxIk5DFmwVt/NgziS7W7HnCQgcie nugAcx0Mov+NmfagH0KAETwMsyMsDGgcumVhRQoLOLj4xRCqpsHXWN880RJuTb+pA1gCOtLMTwuB Hxbg52UPLCE9wnAb+fjB94HLAEqN7p8C5wDcZ2UdUjqEh/RXmqOeGj0yYBy+KbA3SYSKvlPs5jmI 4Njt9m9NOfSc7Np9DrN6Bu6db8mkmSmJ/pCXsyU6RAQKZ5dw8qcL34ixwiClxUWEwESHqKiICOAq gPsNbjnoIdK5Dmw5Nw+fgLCoOD02BoJjwIMUYbtEoR8yOXUz/8PPXr55293d/eb1vUIfcywKJgzI COPTQqKgcwoHAjwgvAOijek3MHQRZ6RcgOhQirWMKJh7AQ4fD7+oNApr6lsBaa7zme6mOCVZQLsz j88U2Ju6ESX98Bxy7IOX2gFT7v61KWftLlO7a1u4RZS2f/q3q4w9u7m/NMhWCz4vLGdWNuHdch/+ dOUPpe54NaQM4BzC4DIgATtNj8aBwAEBBxUAN6iS6bkQuKw8SkVdC4vVUldWREhLgcl9xn6D13DA yTehJCxdvXnrtm1bN60qinAmaChIAaYQEHF+IVEJuKwCmNPDYjGqaHkwJzD1YSbLAY7z8AmKiEtJ I5DKappYYBk1JSQCzPcAXoygKAyJIZBiW1hu2eTeJT52RpqKcMB3p2eT6CwHQYHMffLnUmzYc3Lr ypwoN0v816acjengdFVAu9MS/7V2n3z76NzaeBe8/DylKZkQEd4V3awlxoaGBgdAGp7+jBOtwRY4 NTRaTUtHl55f1dVUVUKraOAMza3MdVGSQPQPeJMCIuIwBEoNZ2TlRPb09vYkk8ChYXLMS7yFdGsr hdQyo0TnVNY1rltbvzw/lmalp4qQEAI+zi8kJiWrqIoztnKi0Ly9qS62xjgVBXq2l5shoYwMEJ+g qKS0vLIW3tzelertCyxjb66PYaXyNc1dQ0vOsfyy/j1VCQFu1mBNPphC5GA67Egty+CVcxhcP/n2 RHNlVrS/m6WGAlxMgIfdlE/xnKXdSQFL1v9crmakT89u7Mj3t1CZr9Q0B5cAHSKiEUo7vr196fTx Y0ePnjh/p2valcOpBBIBp21g6xkUHhEZFRXu62SKNyS6+ifWbduz1hAJKFchYUBI5ZVxZs6+0Usa tx84e/Zw++rMCKqNvoo8TEwI0H2LFnHxisBR2rZB2csbNzT/0dxUkxfqYqwFyomAAMhxJayJo09M 7tqdnWfO7N9SHuvjYKAqB2YG6FLEvBERlZRR1DCwpgQnVmzZe+rs2QNttcnBbubayvIIWQQSax2Y XrUVsp/vT7XWLV0S70NUhQvxcXPSYfeFJeW1bML/mAM4/sSzs3sb86K9XWyMddRgX5lyFtOntLu5 W3jJtp/4yTPT8Ot7h6vjXHSk5+nakdWQcIDlRY8/PL5r66amdU0bW3Yfu8Zef3kzi0I0MnPf3vWi q6vr5cuurp3ebt5xG+58AfTBQ0d1GZikpJS0vIqutVdcw8l/+kfpcjYx+uXx/mJ/Gx0lGQl6Gnox v5iMkgF105vud+D9yvt3F2Mc8epIuLiIMMBJFNaMElV76unAGPjpyfHhV2dWBtsBHh4zoQkKOb+w hDRSg+AYnN/6P93D4/Qnnxj5dKc1kWqmraqkjCGG3Hrb/QE6xSO9Pe+7X798sc1EQUwQxNgENTsC YxtzdE6Zkv7d62tKk7xsjXQ0VRQREpwzXtyxtLu1Z3z1v8KJHXl1eVO2v7kS53zxfAoiAhqkN3y2 rb6qJD83r7CibvP+y2yS/qjQj2TtHAeV/h/PTK/5i7FtZ6g6aAU5OQVlHUvvtL1Pv8pw9JzOpBoD jjOgohfzCknIqVlE3GT94/04e11VBbiEuARcQZ3gGrvpwfSi68HL2e6Gygx7Cfp4AqJSCBU8KbTy 0teps64tESSCDo5AWTHz7h1wUJYCwXTBVKAMxj55rpDZk1dKc1KjaRbaKigFOcBrEZxph1na3cEv fc3sJlp+RT0nVsY6afPN11XzFAZ3KVQU1NOxujgzMToiMi41r3I9e7XQ/dIQd9egGlbqePLgmv2f mH/f40PQVFNVwwK+2faXM9Tjv2kKImLkJYUF+AVF4YpYxyyo2v9srK2OqoIMDC6L0rYOrP7rW1l4 XUsjAEwXBGK+xczxNz4FF2Yox5+4lOZhaWoX8Z3Bfs2u6rLiAouBaI5fHG2R+esNB9/Q6J8xoQFe JLyqPALwaQGnVoL3my3mAHNEgDkzc4mt2vFvtPvEuapAE9F5u2qmg3ZqmgfWQs/yrGVpcoSfJ4Xq ExK/ZHn7bShDdbMsyscncReLo/2dF6f050iTrwVeV5dgH7Li0cwdGIN7wokacpIiwmBQjKdBoN/j 7RFWOmqKcgh5FT3H+P0zXkb0rKDqo6XFgFCfX0hcBqXjELX17cz7czfTi+SRMbMAD1Y7a8qDQTon jwAMs2R+OhjG9ntTKWSSKQYpIz0VzUiK8U0P2AThyjgTe2pYRu3hf6Pd+6qoWFG+eeI5E7TTOmor pIyvNWSEejrZWtmQPIISSppvsqXLymKDwtigIt/fYJUYfKwOsLUws6Ik7vruBdLo9iATVYSUOGCL MWahe1iWdLAmiKirrqSIUjdwS/8eBNurbCcsEi4GjhmUVdZ3TT7z3QzS5Tiv4NKZnfG3+Y6aSJgw LxDpCcL1alo6Os9cvHrzzr2Hj//+5+mz5y/o1NX19uPHvs9fBkbGJiZm1UA03uHm6uLibGOEoYPz sYh+gQyXlpaVlZNHqWINLBxp4TmNl7t7evs+A98/q2zvxPhIf8/rh+vsEKJQNdocec7oLySldLJW GT1UHkUjWRAMCOYOtIjcTRB6zvih0viIpGVPWS+8g/j7vDTI1dHFP+vsD/Ibn2uoeDRCGgixcHZJ EKjumzIfC33ALmAI7lnfh+o5E2GhriAtKQFDKOPJWT+IqQcrQuLWzSzCD1LttBTpPOcVlFIiOPqE x2fkl6+oX7uhecvW1rZt29rb27dv37Fr9569J89fv9f1aWBwdlI5+SrPGSQHooGGopyszFcki5BT UFLDGdv7xBXXt+w9cvz0uVezcx6Hv7x/fGH/+jwvjAwd1H8+BH0KtDMHUoaf2nIDXYgGOKwOwdo9 NL8F0qG9rUUJsdlrWInKSbaqktvFYV7e4QU/7pl+nGKvhVZQQGsYkPOesl59VOhlaYjTwhm75/wg fu0rp+ipIBEIBRWA5T/IYo4czIhI3z3zjp6LswZ5zsNJr2BRwRlZO1EDwuNSMrJz8wuLioqLi0tK SkqXlpWXV1T9sfPQ+ftv+vpnO5547FawM4PvNmaG2mpoBXk5hCyT4fKKyhgDS2daSGxqTsmK1evP zrLobnKo7829zq3VqTQ66vM81YhycPKKITSMvcsgZfiqKd2HZKqnhcEaWLlHlh+CfnTXurzEpOK9 Mx39yZOFUSHxpT9pzhpr8TPWUAZOvJnfSigGPLvE09oYr2/ilsbeLjYx3NfPrjMmj4UTgThMSU3f Je0H7nb/waLYiKyZO3ImW4PMNZFSQjyLGLfmaIyusZWDG9XHPygkNIyOghwBUCRY9hsTV7Wm9fDN lz2fZ18uNfJomfMUOdrb2VpbEgGytLazJzm5ulE8fQLCYpKXXu+bbcfpRP+nV7cObiqPd9dESYPz 1+bHnoOgnQpaFsG10Mm735DsTTLTw2rpGNl5pzdBbvvk+dqspLRll2Z65PHWgviUsjPs/zT66XXX y7d90yTuYYq9niYGi7eJbGGdnJG9mTR7CxNzlwQ2UOjR7lunT56+/Iwt5Psn08UQp6mFJyWcZ//K oQ+vul6+m3Lhe/eVxgeHpp/p7fsCHZiJ4aHB/i99vV35HgRGAw79EhUmp6SBMzAh2tg7Oru4urq6 0YlMJru7u1MoHl45y9bvufz0Q+/Ar3QFD90qdp6BXFxcyRRawNH3v5APGP/c03Xzz/VL48iaSuAs 1XkqCwYzMlIonG3sTtazTFyqTfJzsTTS1zey8UysYfPg+raVpydlr5rh7n9i/H19XsZS9hlzI88v H/lz/59HTt/9xPbGL8toJiCAtEvqCehrm1NpjjbWTuEboZrTz7eO7t3RvrPj5F3otd4qP0sjA4Jd +DY28R9+dgFYpuPQ6cf0td9tK4kL9A6ILdvYcRUKRHofXj11ePfWxuIAW11lIFbjXsQq1FXFaOuC 9YQmJqZMMgPI3NzcwoJISiysazvzuLvn8y+2gk8OvL7eTJ7G8/w9D/vGfu1rxno/PL+2b21xjJsG o8Vsvsw56MIp6zunQ6VpI8cblkT7kR3tHSnBWavusp3Lu415yUl5TV/HSEPdj6+caFuaU7yBDTiv 59K+lqbVDY3rt3acY8/ktYfbGBkaW3rmQ7mJt41JXq4kZ/8iaCzsl0sdrRvWrm36Y9fJf1jWYnJj lJMV0c6/gi0R8/H8XmCZ+oY1G9tPA/7ki+aiWH8qxTMooaipE0qqvjy9a2NdWXacrwNBAwkHL9EX 0qtixWEy8or0ckIMkzRB0gIICxDOKDSjatPRe28+9P7LgorJScDzn/x34AGjPe/+vrCjPjfMUUlB RhIsNZ6nNh8WyhckvL1nt60qz89ITkoraDzezfYQve0V6fGJRe3TE9RDj0/t3LR6efGSvNqb0Kvd R1vqK4pycwtKlq/ZcZ7tExeSXSzMLByCqqCT87AmwcfdzTv1MGtvhq93bFlTV1Ozak3z/susxMvk nymeTk5emdC1O2OZwrycnLzCioY9vQ8aciK83ZwcXT1D0+pOsPg0fmtHfWlmjD/ZxlATLUNvugJL oXn4hUTEJWHSgI8lJyfPRgoAIUFCqXrFFTX+eefV+0/zP4/jJzTy6e2jU1urM/ytwaYfYfZ7xTkS C+ULEtHPzx7duXH10oWLd55Oi7Qnzq9aEh+TuPTItDP/7uzOddXFS9JT0kraobTYx8Mbq/JSYqMi Y5KyShr2sCVp7i/xBAJ/l+i1ECvPV8b4UmmR1azzNfn3sbZ1tcsrK5fXrms/DWmJYzkBnl7xTWzL HNlYlZsSFwm4XpGxqXnVBYkBZJKNpZWdq19yHeQPDnWuK04N93Ii4jFoWUbTFVhwwb2Yl18ALCYU FWOROIMkmCQl6xyWVbPreldP32zd9/mhycHedw+ObSpP9DSBiQsL0WsT5quFcwrla/PPUUUery9I iIxIXMYmZv+ZfHmkeUVBWnx0VExqNRQyj5zZWJYRHejl4UHzj0wp3nAacn3/LvRztCdRUztYLtzY nuJIP6/ArKOsg9F34+iOzWtWgXK+eddZSCGcLIoMjCy+OW2ZdGAZCtmN7O7h5evvTbYnmhAMjS1I tMQGCN6wZ2dVSijVwVRXXVFGgtEhxay/YtQSgu3Q04mfSQKC4tZ+KZXbrnZ9+jVPbo40/vnjq9uH mgojXXUBCeeFypXngeWMSzVde7ZLte/Rm5bSpLDgkOTap2wvvj64viwzNizQPyA8awOkFR63VaaG ebnYWlraOtPC0lawpVP/KQ1ydXb1z4NqbD8154b7+0VXsvCLJl7cPX+0Y+e21tZtOztO3IB4fros PiqDLdvyhLkM0Yze0WFlBTZnaWthdY2sPRLXQFb/6cacMKqdsbaKPKvpilm0xyjMnQI++IrA+kKu xQLmngllLWf/fveh97+m30f63j+7srcxP8xek5f75y2Wv8jzWeOuv20rTwr19wtKW8PmkfUeaSpJ CfelulNoIfnHWC8PHKnLCKPam+F1dA3MSV5RJe0Q3+6XhlDIlLByqGnv5drMsMDgtGbI5x8bHR0Z BseAAn+MjEI7fbwiOWUpFM8NHq3LCKXam+JxWvSODh0dbU11FTRaBaNvQU7eAjkRV2viafZGYEfR 9KarBT8hekXhosVGHnGlG4799ea/pd8nB3rfPz67fVVOsI0aF1RhPB/8ZvD8m0u1makLYHmwN5UW mNUG/fCxq5tLEoOoTvZ2JHJYGcTFFy1FUZ52RvSLbD0Ll8C8Fuic3CgO9fTwimOb3He7LiUsKLLg /E81zeTuivScVU+hZ2opBJfBqqJAn0sRhUaD7ToysgoqODNy+gGW8RjtKAp2MtUGvDchvq+armZD HFwG5KiChn03XvX0Dv4X9Pt434fXd4+3LE/zNVP4HcBaHJzg2D6zwBU/rvscvtu8ND6A6uZKCcpj a7Z7s6MyOYBsa25iZuUcufIT6/VrDal+jsZaaIQ0AoUh2PsuYYPgOl4Q4kXzT29hWfjxU1WJYSHx y36OLtzfVpZVzFaherUh1ZcELCMLA7wtepscTFJCTExSBqVlQsllNx5pVCs9FVkxgW+arma5Saqk kKyV7Rf+fj89M/g7aHLk88dn1//cVJnggef9HbhaCzi46Zdq0S0/+imTb4+uKYzxdSPZO7gGlUKe 2vj51RlBblYEXR28qWM0VG84drAq0p0IVsWISSJU9Kx98v9kcXi0LTvY2zskDxp4M7C7JC4sLLXx 53Bo7zYWZ1dAwE5jBysZy4gLCQoIMnqOwb+JwhW1TLxKIDyPrvpoJ2OMvIQA4Lx93XQ1u23i5Lf0 S1vW3Hmv+/OXwd+K6z028OXDk3M7G4uiXbV5fguUGutS7cT3ddbI2/NbqjPDaU7WRAsb59BlUOKk p70kgmKF11LX0CaQ4iFHfGB3cZCTkYa8pLCQmIyynk1AOeQtvG1MDfTxjSyDUEI/bs6LDg3L3Prz wOFBfV52NdT1NbCrMNARWEYC0NhgcyRIYA2lsBRSyzyALfi8Uxlkp68iLcLD+aPOjh/vE68JLaFk 7f5rz3s+9/86WPNsaWLwS+/LO51bV2YFWaty/x6c86lLtbzvFOxMjn54cGJLXWFioLuduZGhMdEp eg2U0Xy4Ns3b3hCjpIjWMHBI7IQKKXbk+9sbqCEkhIUl5NQMHWMa2Yz38jh/H7/4FVB11bPGjIiQ 8JxdP7+z7KzIzFoJ3cD2b8/zszNQRYgLgsW2QFzFD/Y08PAJw1DalhFNLM01fqrI15o+IGBGyIHZ bRQHt7pLeG7dtpP33n7+MvCbpvGMfuntfnyxY1NVsidB4HfhojLKnE18yqFLNXqZc/+XLz0f3nc9 vHygrWlFYUoYzcmSoKuNw5u7JLazfu/4ycoIVzMsWk5WQU2flHKcxfORvUUBDoYaCoCZlUFrE30K oEuukT0FEX4+AalsAde1lclhweF5EJ7gaM/7t6+7nj97+s9TsIyh6+Wrl13Pnz55cKU+Oyl9JVS1 N7gz39feUF0eBhbbgj0WwvRSawFRaSVd+yQoqTe0I8cL5LkwD+ccIlwOLgHrgPSqDfsv//P+88Dw b1DwY4P9Pc9vdm5vLIl1xf0WU878IeClGjF0HRQ/v//ryrkTRw917N6xbcuGhuqSrIRQbzdbE11N NTWMrpl7xinWOz9vz/Wx1VdBwGCA0SYls5mHC1XhzqbayvKycmgtY7fkZsjt6mpMC/bxDsrew3L+ Jw6WxQQHhrHxfOjx1ROH9u5oa23Z2rpt+849+/buat+yYfWK4vSYqJTlUHZt4hg4Tw6rJCcNg8Fk 5NHKCtJiQgICwiBqmdsS6H0fN2d62+iryIryzSmTBYQ4BI/YgvrWY7de9g4Mjswz18eHBnpf3zu7 b3N1VqCV0m/S6/8PulSLgy7VJp+c2LV1w5q66ioQfCglLjzA09XODK+lgkKi1HTMPAsgK9C9Lols jkXCxCVllfUckiDd/p+XTak0GwJWTUVN28Q1pgaKA0cPLI32pXmFFp1jvfnLlryIAL+QnP2sPRx9 eGpvy4bGupqVNTV1q9dt3rJ5zcqyvIzEyOCAoNhyNpiCRw0JHtaGWFU0OJ3K1DGUqCUnKSYqDkdi gOATcju6NmaCdysKEoIztRz8wm5xcAvZBqRXNu068+Bt38DQ2DxyfXx48HP34yuH2uoLo110+H8j 3jXgwgmDl2oZ0H308MX2+srC7NSEmMiw4AAfqhvJyhSPpc9glVfBWfhVQvPXHq2IcCQAVltEDFCm dnG7Idd//OzyWA8bYzyeYO2ZVMdW0vJkdXoQjUqLrIDKYV6vTQvy8Q7MaGf545Ndp3dsqK+uLFu6 tGJ5bdPWM3sbStJjgn09KRRaaOExKEUz2FEaTrY21tfVBdZJO9nb5IpTgEvBEUpYi6A6yO14tDkn hGxrjFUQB9uW5iJAHJy8Wm5ReSub/7z4+F3/8PDoPHF9bGToy/u/r3fubKpI9TYV+a3QxyAes6ya IZVtdE7vgcbijPgwfy8PsquTg62lqaGuJsBxmIS4FEJZxzJsDXQ1cq7EHxy2ICokAkPpWEesZyv3 GTy2PCWISnb3iS7cxjakr297UaQXxZ0WWwPVGN9fGe/nSfVNavrEemnoekfz6uqKsqXlKxqaD7/6 z5edFclBnq6ODiRX34x2tiv67ral8QEebmTPkLQ2YJn+ChdtRQQCqaprHdnKluHfvSI7LszXV08W 7KKZ034u4OAStPBOKl297fCVJ+8+D42Mjs/Zh58cGxn88u6fGyf3NtfkhNpjfjOoPb3MGWPqvwyC wXvVWpYS7uNOsiGamRgZ6OE01ZQUZKXEAC9JHNDg9vH7oezWDsboJSEBISlFLDGgir3SdPhO67LC 3IIVO++zFRaNn16e4Ofu4kZL2sA6HxNny8JpZDI1in3+bO+V/S3rGuob1v7R8QAsmXi3IdPfxZZo TrSjxK5ij+M/nt5YXpBTWLfvKf2xXmbbY9GKShi8fQJbefvAzQNtLR23npKU6b3hc9tRINIRtw/O rGzacfTSwzd9gwDX5yLskxOjI0Of3z65frpja31xLFlf8DdPomKNzmmCZOdOY0aoJ4lI0NPWwqir KqHkZeEgLCcvH9h8g3fOhEKlT02M0UsCfIIS8pom1Nxz037N4MuH959+mCYFdwDN7u5EcvbK3Md6 bWh3TgDZydEtqJAd2GSo6/rxI4eP33jG1Cqvq8OczAkGBAtS0NKb05bpfXH/wUuWB3o72lJTRQ1L cE5jf5jJ4SHgSDyhYmAi/IvnWmoCNs+rOkfkVm/YcfjCX109AyOjY/9W2CfGR4cHel49vHayo3V1 aZKnsehvH0rE6lQ7DNVFdVZGe9qb6GgoKSrIIWTgYEs3/e52Mb8YYnppRVdtBH30Eh8PvxhgIJzj N/4YGGny8fqcUArJ1s7JrwAqkO/dkOrlZGtL8kxpnpaUGR8ZGRmFtvJephNBR1vH0MojrfVHoH0d nngNDM7INfNb7P2L3jh2jNo5bBsHtyDWPTp3+fr2A2f+5+9uQMWPjU/8qrRPTk4ASv1z9z+3L3bu a2koTfIyB2eV/G6I46nROZk3WU/S35LtSwLnaYMdvaIiQoIMjIdFi7j4wX5lnyqobuZmGWP0Eg83 rzBcSdc6oHTG2kgWPd5YEE51sCJaOwaVQ7n1rtoYsq2FuZVzaMUPRyRscdTTUNPAGZPCqn40uXkw 2URLU8fYNfPb8ve9XjoKUsK886E7wY1TdY1YUrmmdX/nxTvPAMsOCPv4rGugJicnx8dGh758eHHv 2pnDu5pXFSd4mk2NG/69xLhI1acUPmU9zeuGOFdznJKsBCDdEKo6B8dCLn7Q8gdDVmD8yBLG6KXF XIsFJZGapuSk1T+YWjT+YFNhlKcD0dTU0imyFvIfblUEOxGNCCY21JRNPwDX/SvZSksZraSuR6Sm b/x+w9fY0SBTrJaOsXPqN0M8RzZ46CiCpXDzU160CBAXUlBaWX3zroOnrtx92t07QJf2n/N9cmJi HJDwvnfP710/19mxrak6L8bd6L/D8SmACUOvasgtulseaItXRYgL8HCxgw+BRgzgOTFyD+ud/VsS nemjl7g4ufnBRltb/9zWT9/7oQOXmwqiaQ4WYPmj2/+2d6ZhTV1pHC8qUnbIRhKykYRA9pBAErKw BiQQloiRRUQWRRQIiApiQQREFCwuoLbaRalo1Wndq63SIlNB1BnHOmPr9kHr4zhqXYdRW/WZe+7N whKrPhPbTuv7Ed6bnJz37Pe8/59x0PB8YEFGrDJYHKKKz6nb9SyxricnqlLlbD8KlckP1ebU733W 0fz9faU6uUAQFKqd+enwsfbWkhSTAJ2d0vygiREXmVFcs+zdzh0Huo/+7dyVG3fNcbcZefDnpyDe A3dvXrlw+viRrn3bN7Q3zs6OC7RfsZ5nDo4uUMxDs9Zbt8aHqlLVAj8fhJQy6IUEOLCj8qJLrBPx 9eVTYwF6ycVxtKOzF54uUCVNW/Qn28Tox1f3tlcXpseHy0OkSs3EqkOWgPxn05zxkVIBTxAcrp/R fMh2dset/W9NihCCnCcKKyhcP7P5C9t+32+aYwgT87hCaVR26/DXdJcqEoBIkb1EB9+AV3OuKFJC Tnnd8nWbP93f9fWxU2cvXbt1d+AhHHlr6OFYw7374cC9H65dPn/6RN/hg3u3b1yzZF6BXkXwcnn1 87jZgEybL0uRvdNSMQMdM7XSQBJ6eM0g/ZyrMVo38t/WpgP0kuebY0aPAR09QBI1YUbjposj7w89 vdm3saViahoUcolEFqad0mjNQrm+dqZOJWL7s3hSTZqxZbeNNvPwzHvzp8RJ2TQCDkegskM06aXL 9tjwu398VUVmjIzPDuSK1fo5+4YVpKcwRsgg2E1c1FQtjs4eOGpS7qzat9/p2Lb7QFdP34lT3168 fPX6rTv37g8MwDd94BcY9+7cunH18sWzp//af+Twoc92bHl/VVNloSGChHZzGv0LUuYQaT5ZhnX/ daM+M1zEIHgN3zI4gPmczI4sti7NPyvRydgUjDtU4tFjXTxxVI4sxjCjbn339aEXiB5c6+1cVWuc khoXLhMHSUKj9SVrrMc0F5bljZNxGVQwao/LKGnacOLOkGHx6b3zn7RW5CaGifxJOBQKQ6DzQuMy jU0d3wxNM3h8+/TmltmTE5SiQCYDakCxU+q6B12wfnK7d0FaGM/Px8teIsKWmhk11sXLhxaTWTS/ cfm7HVt37AP5h739J06eOv2P785fAHb+7Jm/f3PyL8eO9v65+9D+PZ9s/mB184JZOcliMtYe+4iX slHwoBykW7qru7f/+InjfV9tnK6TcmAI1siYo6EhIWvDgZ6+Y8ePH/t6f11mhAiMlY5AB8rJzZtA 54fGGqbNa+348tzNB/DA9uTRnSsnD3Ssqi+flpEco5YGCSXyqKS8Buutpae9CzOixCwKkUBmCpRx aTOqV27uu3TnR/jxx49uXuzdtrq+LDs5MoRDw6M8PbwwvkyhUps+o7Z927Hv7/6E+D24eeHrzrZa Y1ZihIRNp1L8AoTKxIKGzpP//De0mv7p/vVzXWurc7VSNgXGe9m9GuE2T/aPm1xUWde8at2Gzdt3 7N63//ODXV8BieyensPdX3Yd/Hz/3l2fbN30/prli98qzdXL6ET0Lx7wN2DNTw8chavSF1QsWNS0 ZHFdZUGKWsAgjsxtB1MXFFWRJrOkamFjU1NDtXFSbEggBefhDCZ+WPKfyODLNSnZJTXL1nXuOnj0 WP/R7j1bN65tWVBeMAkwniRCvlidmFXc0Gnt5g+3zx2vFtAJWAyO5C9UjpuQV7Zw+Xtbdnf1He07 8sWOzvUr6udOz0yKlvGBwBCQG8Ca/MrrV364dW9Pf3//0c93dq5fXlcO7q+HcOkkAsGXFiiOSMmv bF63Zefefbu3fdi2qHxKokrIBNigV3LoAStjo3woTIUht2hOdcPS1rY1697f8FHnlo8//njL5k0d H7737uoVLYtrK0unpuv4dF/kkv2vwBtyGPOmG5pIhzoYYLDk5WQZ4tUif1sDDjxxYckB4nCdISsn Lzc7PTlaCrKAYPQSkM5w9sD4MnjSiARDTlFFbVNrW/vq9hUtjTVzivIz9dpIRbCQxxUoDSvXftQ7 aHX1r7bCePhyhacXFEyBPDoxLb9kXt2S1lVtbSvfbqqrKi2YnKqNkPKZ0O4RvhDhifglZeQbqxpa VrSvaW9rXVo3zzgValdhwVyoNjEYHNGPHRyRmDl9ds2ipc1N9VWl+WnxYeIAWKv2Vb2/gCvBzQtL oNADNPqMnIIiY/nc+dXVNdXV8ytnlxVPz500IUHG8iP5oIH+1a8Rb7iYYFDCkph8WXiMNiEhPjZC LmRRBsN1LAbtR9288dSAIEVkbHxCfFy0KpiDjE6gDsHo7uKBhqparIhOSM3MKZhpnDWrtGTmtJxJ hqRx4XIxnxMYwA5KWPbj0F1Mb31WlJhJQLmDHuzL4AarYxINWXnTi41lZcbiwvzsdH18lELMYZBA KgK4be5q8otNmpiVV1hSBn1NUWH+5LQUbWSoiO1HxHp7enpjoJJI1LHJEyfnFRRMy80yJMYoxYFU exy9/nyFwjrRrh7eaByRRKHRGUwTnoLuRyX74nEoWM/Szmyplywi0C739iEzuWKpQqlUyMQ8JtnH ZsormLM80ARqgEAiVygV8mBhoB+s3QXXIVBVBIpteIo/T6KIHKdLmTAxPT1tYmqKDkCeRBwWg05n smWTdg9dS9/+oEyv4tNwHi5vQsHEEGkBghBVVFzieEMa9LhhfHJ8DDQn8Fg06KvAvXSgC2rxi9Ym mf2StJoweRCXScGjoQkACM4QaAFCWZhGm5iSkqyLi1ZLBSwqHpEhf/XVCqtUOjkjF7bcLdra9ko3 +98KB7qnOwpH8mNxeHw+j83y88V5u9siXjnAEshoPIURALnyuIDDg7a+mjRJaXpjfWksrihEERYR rdFooiLUCgB5AlobJCqDE144lI/+9PAicDnRF+Xq5Air/PmQ6AF8sUwZHgk9Hg0YMsFCDpKUCbNU RpnUAIf6RYar5BIBm0mFOjnUj5ycgEQknsJkC4PlSnWYWiGD/guSed1HYhr+cIYIKkKRIpAA5YEG WCuIwuaIC0SwCDKstkmGXGlUMhFJjjXXoYPVAai88kVBYok4SMjnAMgTHovB+pAY/LiKoYez59uM 4+E9vjOCLoFVP2nMQK5AJJaAx6FWSKcQzckno0yqn8APD/x4AsAiEYsEAC1EJmC9PWDOzBjkRxEp dBaby+fzufB/n/XL/mCGqGg6w9rIOB8cDoP2cne1nfFqguwAuWUsDofDYrwRONtgpWXwWdBchsX7 ksFUBrJKoLYBCInuYJPFEKa0DBH2ubx+XlaMNJCMdgN5ojAnCVH3hWdCJgOaBEkwI8rV2cl8e9HB weyHs/rRKDDLyZStO8qkBgsVBJpUqTQqxfQpdsvl/b82pN9AkXKDAQ/uboNV1oe5ImrpLq4mzxG5 sSC7C07vdTfBlwAZBIOC2gY0l4HLqAxJ2sbBpygXPliQp1MhKk6mLmxS8TY/jsWgTFw0ayaC1c8L ND/ghwOsGWuy7qBPgpElGDS4EAv/spfOYPk9miUl18kCRLDJWjFr5A91HcHhMWV1W9qQuxuSResI 6EOMkHSrHNnTGz3v1ExNiQBIbDfzQhApCsJuQhqWi7PTMEbU8/wGe8AYKOsC6lelLv+GzJKSOxho 8iKuo2ylxjpYcBkII2SsiWsOLfq98HRJ6s5b9x8+evRg4IeL3RuXzc3TR4WYyAmWNFHAGTHDm8aa HrcB5bDhN6Q8ZlSqGa5uk+3xB7cXT3d9rucwSAjyJhYIttMEsbM7vjx55ruTvXs2vF1TNDkpSsqh 4YcK3Q1jjDzzm57vZ80mtm8m72t7MUP46Gy5LmdWTePS5qaFlcW5E+Jh+hzKnlzc1/bbMcBHRxHp fHmMPjO3YPq0vKwJumhFUCDNdEzyOua/P7Mc8oaoNdrEpCRdXJQymOdP8UHZPAB6bb8DQw55cWQG J0gaqlKrwCkviwbkfGzTLH4B+y8dOdPGDQplbmRzdHJlYW0NCmVuZG9iag0KMTEgMCBvYmoNCjw8 L1R5cGUvRm9udC9TdWJ0eXBlL1RydWVUeXBlL05hbWUvRjEvQmFzZUZvbnQvQUJDREVFK0NhbGli cmkvRW5jb2RpbmcvV2luQW5zaUVuY29kaW5nL0ZvbnREZXNjcmlwdG9yIDEyIDAgUi9GaXJzdENo YXIgMzIvTGFzdENoYXIgMTIyL1dpZHRocyA1NTcgMCBSPj4NCmVuZG9iag0KMTIgMCBvYmoNCjw8 L1R5cGUvRm9udERlc2NyaXB0b3IvRm9udE5hbWUvQUJDREVFK0NhbGlicmkvRmxhZ3MgMzIvSXRh bGljQW5nbGUgMC9Bc2NlbnQgNzUwL0Rlc2NlbnQgLTI1MC9DYXBIZWlnaHQgNzUwL0F2Z1dpZHRo IDUyMS9NYXhXaWR0aCAxNzQzL0ZvbnRXZWlnaHQgNDAwL1hIZWlnaHQgMjUwL1N0ZW1WIDUyL0Zv bnRCQm94WyAtNTAzIC0yNTAgMTI0MCA3NTBdIC9Gb250RmlsZTIgNTU1IDAgUj4+DQplbmRvYmoN CjEzIDAgb2JqDQo8PC9UeXBlL0V4dEdTdGF0ZS9CTS9Ob3JtYWwvQ0EgMT4+DQplbmRvYmoNCjE0 IDAgb2JqDQo8PC9UeXBlL0ZvbnQvU3VidHlwZS9UcnVlVHlwZS9OYW1lL0YyL0Jhc2VGb250L0FC Q0RFRStDYWxpYnJpLEJvbGQvRW5jb2RpbmcvV2luQW5zaUVuY29kaW5nL0ZvbnREZXNjcmlwdG9y IDE1IDAgUi9GaXJzdENoYXIgMzIvTGFzdENoYXIgMTE3L1dpZHRocyA1NjEgMCBSPj4NCmVuZG9i ag0KMTUgMCBvYmoNCjw8L1R5cGUvRm9udERlc2NyaXB0b3IvRm9udE5hbWUvQUJDREVFK0NhbGli cmksQm9sZC9GbGFncyAzMi9JdGFsaWNBbmdsZSAwL0FzY2VudCA3NTAvRGVzY2VudCAtMjUwL0Nh cEhlaWdodCA3NTAvQXZnV2lkdGggNTM2L01heFdpZHRoIDE3NTkvRm9udFdlaWdodCA3MDAvWEhl aWdodCAyNTAvU3RlbVYgNTMvRm9udEJCb3hbIC01MTkgLTI1MCAxMjQwIDc1MF0gL0ZvbnRGaWxl MiA1NTkgMCBSPj4NCmVuZG9iag0KMTYgMCBvYmoNCjw8L1R5cGUvUGFnZS9QYXJlbnQgMiAwIFIv UmVzb3VyY2VzPDwvWE9iamVjdDw8L0ltYWdlMTggMTggMCBSPj4vUGF0dGVybjw8L1AyMSAyMSAw IFI+Pi9Gb250PDwvRjIgMTQgMCBSPj4vUHJvY1NldFsvUERGL1RleHQvSW1hZ2VCL0ltYWdlQy9J bWFnZUldID4+L01lZGlhQm94WyAwIDAgNzIwIDU0MF0gL0NvbnRlbnRzIDE3IDAgUi9Hcm91cDw8 L1R5cGUvR3JvdXAvUy9UcmFuc3BhcmVuY3kvQ1MvRGV2aWNlUkdCPj4vVGFicy9TL1N0cnVjdFBh cmVudHMgMT4+DQplbmRvYmoNCjE3IDAgb2JqDQo8PC9GaWx0ZXIvRmxhdGVEZWNvZGUvTGVuZ3Ro IDI4OD4+DQpzdHJlYW0NCnicfZDNasMwEITvAr3DHO1A5F1JlmUIOeSvpFBIIdBC6CEYJVCIQx33 /SsHt03bpCcddmY+zSBbYTTKHqbLGWg8xmQ2xZsUBFJExFpTgUITcktoghRPA9RSMPZfGiLHZH+I dgMpHqXA/GEKXAD4GzDsvXnpip7lDfM1ljaqLBFpcIViKpGXuSKGVs45RnWQIlsetvvAHrMjroH1 n2baWrZXaNlq27ahqVGdYoBmnKq6MzGz8vnZ4Fk5cv8WNT1vso6JCw3jVOmw3nXLdUUYLv7CerCN b7wc+k0Zd1JskudQpy9Y30sxjwldyqeP2StfXPo2CW5pdaH0L+2qOb6mQ52EqkU69IlVFouwbd+b 1CThdCPJGqNyd5t6HuADzeR2+Q0KZW5kc3RyZWFtDQplbmRvYmoNCjE4IDAgb2JqDQo8PC9UeXBl L1hPYmplY3QvU3VidHlwZS9JbWFnZS9XaWR0aCAxNjUvSGVpZ2h0IDY3L0NvbG9yU3BhY2UvRGV2 aWNlUkdCL0JpdHNQZXJDb21wb25lbnQgOC9JbnRlcnBvbGF0ZSBmYWxzZS9TTWFzayAxOSAwIFIv RmlsdGVyL0ZsYXRlRGVjb2RlL0xlbmd0aCA5OTE3Pj4NCnN0cmVhbQ0KeJztXQVcVNn3X7vXXnMR RMTubhFEEQw6pLu7u7u7ZhiGoVsaVDAxQOwWMFARULED+H9nno4Ig4u7xu+/6/mcz/3cue/cc+Pc e+K9+9789tsv+AW/4Bf8I5g3d97CBYuXLF4yevTon92XX/AtoW/fvps2bbKzs8/IyKyuqn737t3b t++etLy7d+dx6xPk36Lk3r2GQxWHgoKCJSUlJ0+e/LO7/Au+GgYMGCAkJJSelv7y5av3799Dps+f v7h//8Hly1eOHzuelZkbE03O21d46tTpq1euPnjw8MWLF+/oAMr3Z8+eNzMz/yX3/xcwcOBAfT39 pkfNbW3tb968bW5+fPXK9UMVR7C7KRRKSEiou7u7ra2tmZmZvb29t7d3ZGRkIi0xNzf32LHK69dv Pn78FLXev29re9+empLGycn5swf0C3qEvXv33rxxq+19x5s37yC4O3fuXr169cyZM8eOHSssLExJ SYmJifHz83NycrKxsXF1dQ0MDIyNjUV5QUFBRUXF6dOnsf2hBKAKIPH2to73796HhoZOmDDhZ4/s F3wGmzfzVFWdef++/e2bd8+fvXz8+ElLy+Pm5ub79+/fvHkTcjzDgNLS0sxM+jaHlJHSaLTi4uLj x4+fP3++urr67Nmzt27damxsfPbsGTR7e3sHAfjp6Og4ePDgnz3KX0AHCzOrt2/aXr9+2/r02eOW J8+fPYcP1t7eDosM2Z0/f2H//v0BAQF6enqysrK7du3i4+Nbv349Dw/Pjh07xMTEFBUVTUxM4uPj Dx8+XFdX//Tp01evXrW1tXV0hvaOU6dO/fnnnz97rP9pwI6jUpOftb588uTZ/fsPHzU+ev78OYTz 5s2bu3fvYsNiL5PJ5ODgYGxPQ0NDeXn5PXv2bN26lZ9/2/btAjt37pSQkFBTU4O4XVxcgoKCQFxW VgaFgN39mbTbOiD/e3cbVq9e/bMH/R+FKVOmHqo43tLS+vBB462btdDb2M4Q9+3bt6G9Iej09PTk 5GRIMCw03MrSTk5WUVJSWlJCEntcWVkZmxq2Xlp6r4yMnJKiqouLR2wsCeo9Ozu7qKgI5r6hoYGQ NXY63Wt/3wZj8erFG3k5hZ899P8czOKeXXPmUuPDprra25cuXa6vpyvhO3fuQNCJDIADlpGRERQY oqGhA/mqq6tra2sjhaDl5ORQgp2Ofa2lpaWvr4/dDVWvoKBgZGialJQCg15SUoK0srIS5gChHNT7 yxcvX7+G2nj7+lWbnY3jz56A/xBM+GPC0SOnbtffvXjxMkzqlStXsKOrqqrS0tKio6Pj4uKwSSPC I+Rk5SBciHX37t2bN2+GHl7JgOUMWLFiBfET5Vu2bAENiCF6LAlNTc2cnJz8/HykWVlZcOSgN1pa WhobHzU3t7S2vnjc8lJZUf1nT8N/AoYMGZqetu/69VvV1TWInmCgIQ54WYiYYHzDwsIiI6KhpbF/ 4YZBjhDrokWLZs+ePX369KlTp44fP74zN5RwcHBwc3MvXLhw2bJloEddWHklJSUdHR3IGiuHbtBL y5qamuAP1NXVPbj/kKFVHm7fJvSzJuG/A1ZWjtXV5w7sP5iUlJSbm4s9mJWZZWZmZmVl5eDgYGRo Bn9bSEho3bp1CxYs4OLimjJlSu+ZQ+6E0KHwofzFxcVjoumhOhw56I2LFy+ePHny6NFjWGBVp2uK CysmTJj4/Ub6C/i2bC8qOpCfX+jp6WlqampsbAybu5UBiLDWrIGQ10Fvb9y4ce3atVDUSxmwZMkS pH379u1NE8OGDYPQoRNERUVVVVVRUUZGRkREBEsIP93d3e3t7e3s7L29fRzsnNRUtZZ8hKWfA0qg N773hPyLYfjwEZHh5PLyCnt7h6DQ0Cu1tR1fA3aOX+FfsbGxQehz586lUqlf1Qrgen39tfr6tJyc CRN/7f2/D0oKWkWFpWlp6RA3tjM1MfF6Xe3VWzfPXblcff7c6XNnq86dRaY7Xrp+DVKAg716zZre N8fOzn7mzBlUvHLzRneeaOs0A5FHBy7fuI7OXK+vBfGlG9dgXAYMGPD9puJfD5MmTvH1CSkpLvP3 94cx1dDQgFE+evz4/UePGhob6+7evV5be+3WrRt1dSwR/jRdcDdujB07tjfN8fPzNzc3o8qt27fB uQs3oi2kuHq7oQF9eNDUdL+x8U5DQ01NzbZt2773bPzrQWSPTFRkbHh4hK+vb2BgoKurKyzjrFmz btbWNrY0P33xHNj89EnTk8ctrU+Bj5+1Ekj8RDmhaRFb/WVb8PoI4ofNTWAOtgRDghWzFbTY+vIF yvHzwaNG+O2FhYXQCd9/Mv7lMG7seAtzh4z0TEjZ29sbG1xLS2vNmjUTJ07EVnrY9Ohx69OXb9+0 0e9ts0D6nbGOjrftH26D6+rq9tQQ/DSsB4Ls2csXr9+/I+ow+TB5vm17/+LNq1Yss+fPmltaEKBh HQ4dOvRHTsu/Fdav2+Lp4RsZGe3s7Axxh4WGIVbi4eFZtmQ5TCQM5ZMnT953eajRM7x58wZuc/dW EJtfv3699y5ZW3v769evGxsbL1++jGj9x0/LvxL69OmjKK8eE0O2tbVzcnJCCGxoaIhoa/fuPfCc OTk5EWHFxcU9e/asnfnM8q/g6tWrv//+e+dWEGqBw1fIuq3txYsXDQ0Nhw4dWrRo0ZTJbH9Onfaz pujfBJMmTdXRNoqJITk4OEKZBwQEYF9v2rRp+zZBzDMs+ODBg0eOHFleXo75773EExMTCf5YLYji ey/oDoaTD30CN41CoYwbN27rVn7BHTt5eLZ36TlsDQJwPj4+BOxqDEBm7dq1c+bM+WGzN2PGDOY9 AWQQXf6wpv8eLF28ytjI3M8vwNHREcrczc0NWxuB2LRp7FC/8LQJi8nFxQVVDO3ae4nr6OiMHz9+ //79vRc0mMMWPHr0qLa21sjIaMyYMegJQ9vwcs2Yi2BBSkoqIiLi1KlTIPsyK/Q2ISEBffjyfb9l y5ad6gTJyckRrEBI6NMd3dGjR+vp6ZWVlWFNdm/35cuXJSUlCgoKvbzv9INBUEDExpp+I4vQ5Jgf bG1paZlJkyaxsbENHz6cSQmDDkG8ffu2l7KDROBifZWsMVcPHjyoqqqChkGLEhIS8BWRR6/OnTvX e1ZdABZh3bp1LIevra3dm46BDMTz588nk8noZG8aRYf/1w7jwXDvlVFxdnJzZGhyhGCYXoh7h4AQ NiYUaRdnWF9f//Hjx1C2f3vmewIYaxj3O3fuwHXHMhs7Fo2Pg4a0s7NjOb0QAapg7dEfnr58iaWF Xn1Z80RHRw8ZMqTLDEAD9KZ7/Pz8iB//UqV0gZs3b44aNerHifOvYMSIkYoKGr4+9POE7u7uMNyb GTBtGgfsNeKmQYMGdakSFRXV2tra9fQRK2jvaG9r/wsyELx+8xrYwoi20AeixWls0yDrixcvEmRv 3r4BDdK39JPs9KNTMCuEzofffunSpRs3bkAtQO7tdJG3E02/b3sPYlREhuBz7NixLhK/desW0Q0C 6YcsPuK79+/QIlERer776Jhsu5ej3Q7GmsTE/jhx/hXA490ro+Tm5gGTDYcKsS1kDaXdr18/yBpR GDJdqkC9FxQW3G2496i5icDmxy2dsamluRHFjAxxlSDDz875+w8f3Ll3t7a+7lZd7dVrVy9euigm Jgb+/fv3RwolQ2xqNFR/5zYo791vQJWHjxoJhHALCwsFBAQIc4NNxMvLC6EwGyK68aDxYcOD+6gO JMTh5+/PHMvUP/8EDVGFQOaggER1FD5++gQpGkVnbt+9A1bgSYyFWZFAZrvoKurevd9w7dq1HyjP vwDO6dxysiqenl6QNSJuCB2GUlSUPu0DBw7sydmYPGXK/oqKc5cvV58/X3Px4tlLl7rgmQsXcAlI ZJASZEiJKtXnzlVWVR09caL8yJHSgweTU1O5Z836jWFckC5YuBCybn316kRV1Ynq6tM1NUQtAs8y Ulpy8pCPhoaoBZgzd+75K1eIDnzW6LlzJ6urT505U9/QUHX27KSPLzXwbt36sLkZNERvmcisDgT9 CUZXDx46VHzgAIVGy8jJwc8z588TzAliJjLHi4pV585dvHoVDuf3lmMvYRb3fHk5FR9vX8jaz88P 5ht7REFBkbjKnMbusHLVqgMVh8qPHD107Pjh45XdEeVM7FxYfuQYMgcPHykq259bWJSdl2/n6DRi xAgmZwTs0OpNT5+VVRw6cOhwxVE6PVJURHqk8gSw+tyF6dOns+xhXmERWgEls2kiRfX9FYcOosPH Kzds2kQQa+vqNrY8xaXOve2CpeUVBSWl6Tm5OwSFmJ7MkqXL0Lcuo2OOEa0TeOTEyZNVZyb+zzy5 mztn0d69ShC3v79/UFAQAjGEsWpqvTo4JC4lXXSgoqDsQH7p/l5iXklZXnEp0tyiktTM7KT0TFEJ yS5s9YyMX3V05BQUg4Zepbh0X1EpUqJ6fsn+89duZucX9dSrk+cuFJQeQJXOCFY5hcXIFB0oLyk/ xMPLSxB7BwQdPV2N8h67WlyalrMvikzhnDGDqMJcYNb2DmjoSyMtKQMBmuvuH/4smDN7kexeJU8P r2AGYHcjztXQ0Ohldf+wiNTcvOTs3N5jUlYOLTM7IT0zJJo0b+GiLgwnT5168MRp8EzMyAYx0kSs iqwcoiLyafvyL9yqb2xsPM2AU58DSu60PI1PTe+OlOTUuORUZFJy9m3YRI/yBgwcSE3PBEOwZdlP lKMDlNS0TTxbuo9dTEr6C2Mnup2QkRVOjv9nIvqWMHPGPBlpBXc3j7CwsPDwcB8fH/hIKiqqf1kR KzY+Pr75XQclNYOUlNp7JCenkZLS7Fw8xrB6VCq5V+5I9fnohKTYxJSYhGSkzIpECTIxtGRycnpS dl56QXF28f6c0gNIgRmFJdT07ChqYhg5PiIuoQuGx1FDYuLCSPFgvmT5CrTFwTkDfGJoKcDu/UQh WoymJfuHR7E0aiJS0plFpSzHSO8qvXpqVHyiilaPD4x+GMAHI4bAwT5TRprumSO8QliKDQ5fV15e /svVOTk5z5w586Stg5ScHklJjIxP6iVGUZNJyRlIB/XwipC5nQMlNQs8w+MSunKmJEZQaEhDydTg GHJwTFwoKR5kEQziMBI1jExFJiSWEhJDwaXOiELQB0bGBkTEhJIoM2bSb3XybOUvOlLJoiFGW/Ty +CTwVNc1YNlVdT2DtIIS1sNndBWIpleuYX1750cCwisivJ00caqYqIy1tS2JRIqLiyOTyYIMGDp0 WE91d+zY8eTJk9NX6khJGdEJqcDYxLReIikpvaD8WMv7DmVNHZbMIylJpMR0UMbQWLBFWygPj6MF RpJ8QyP9wqIDIkiBkeSASLJfeDQQmcBuGBRFR1D6hkR6BYWHxiYQLr2ajn5e+fFoakr3tlDCGFc6 2uLdtoNlV32CIhMy9vXUT6RRCSlgzlKJ/WBAbEuEq8OH/y4qvFdXRx+CplKpqampQkJCu3bt4uHh ZVnRwcEBoWvZ8WpySiY1Yx+BCZl5H3Ffp8LO5Z8wKafw7tO391rfrt2wqQvzwYMHJ2YVEAxZcqBl 5SVlFypqaE9j52DjmD7taxG12NnZ2D8caAyIImcUHfi8/58NBNKMT8tmn87iRujUP9mSc4toWfks h0l0Pi4t2zcs6luK7R/A6NGjR44c2ee3PruEJOXllChxlMTExLS0NFlZ2T179piYmHehR/BYWFgI WWcUHKCkZGMqknMKEzPzMf/IIIWk8BMpM09c6oz0S5n5uaWH6WvmWNWkKVM7NzFs+HCwpaRmE3WZ 3Jh80vJKMovKdwqLfYPhjxmTkluckltE8O+CRLu0jLwoSgrLmw+beLcePXsFZMSgulbPzE/OKUpI 36eha/jPu/pNAOIm3rjcsJ5fQlwmPDyCRqMlJSVh/woLC5uZfSbupUuXIha+/uBpLC0tigrHJpOS mkNOzoxLyUImLiUbGSKPQlxl/CQK4dnmMBE/QYBMdkkFJO4ZEDZw4KebtHAnQmJhjhNjEtIIMoLt R8xO3VcKFJGQ+Y1VxD1nzpwlPQPxgJJr5kyCeNnK1bllR5ld6ozMzsfQ0g1MrVjOnpKG9v7KM0QP e6iejerrNrFw6X8KjBgxgp2dfejQobO5F0qIy7q6uEHcycnJ2OPi4uLS0tIzZ84iKJWVlV++fJlf fjwgAqYwLiSWGkqi0dPYhDByIvLI0JFEC4qmgIYg+1DIoGHiB2J69YT0wgOPXnXIq2p27pWytr5X cIRvWAyYgBvR1oeKJBopKavmxn1LB7fuw4F7+eWb8yl5JeCzcQsfQS8iKVNQcSI4hkr05zOMhb9H DYqm+keQ+LYLspw9R09/CLSn6igPjIoLio77Y+Kkbyq0vw+w3RwcHGxsbOPGThAXk9fU1E5KSk5J ScnJycHUSUhIaGnpDBw4MDIy8nlHRwgpydknxMUvzD0w0iMoyj0wAqlHcBQzj3JcBY2jV6CjV5CT dzB+guATJRMZxESaVXastPLcitXrmb2aNp3T1s3X3sPfwTPQ0TvIySfY2Zferpt/uFtABLilFdLV gr+/P3Yr6DEEfn7+ffv2vevoiKJlgoDJHPSu/mGu/uEufqHoDxhqGVkwHwFom1gGRFNRDv4s0CfE yTvIxTeUaeg7A4yOT2isq18Y0b3uiHJwtnRksSx/IkyZMmXBggXDhg0TFBCXlpJFLJbBAE9Pz40b Ny5cuPDEiROl1ddtPQItnL2t3fyQsXEPACLTOY/U0tnH3NHLzNHTxM7d1N7DDOjoZe3mT1wl6JlI VATaeQcXn7wUEEObMOnTCYSFy1YY2riY2LmZ2rubOYCPJxDMzZ28zOk8/WJTC1502rbIU7LLHH1C Cc4gAFq5+lm5+Fq6+Fg4eZnYexjbuclr6o/4eJ4KniouWTp7d27iM3TwMHfAWDxYRtwzZ89zCYgy dfAw7akuUnvPXeL/W+frxo4dS7zNt3DBCmkpBUsLq8zMTKh0Z2dnXj6+m83NQdR9upauupYu+tbu hrZe+jYeBkBbTzoy8vRCa3cdCxctMyctU0c1I1tlPYtZ8xat2bRVy9RJz8qFICMomfihuq0n6pq7 BOWduK5maDNo8Ic7jVxcXDNmzVXQNlE1tFY3ttM0tdcyddAk0MRBy8wR/SEYEkyIjJ6VG8p1zJ11 LJy1zZ00TR01TOzBVs3ARk7TZNGyNZ0FN3HKnxiXpok9HZnMO6GGiYO6kd1OcTmW87aWZ5uOpbPG l6rbaxjbzVu84kdIsdcwatSouXPnrl69euLEydKSynJySiEhIbq6ulZubofq3hq5hCjoWSvo2ygb OSgbOygZ2SNVMXZESi9hFCoa2MrrWcvpWu7VMpfRMN0tqzl+In2f9h8wQEhaVU7XCgSd6zKRKEQG qaFzUGxhFd9uaVQUF5fctm0bnIphw39fvp5PREFbQsVQUs1YWt1EWsNEWtNURtNMVtsCvVIytCOQ 3gddK1l0QNNUSt1EUs1IQsVATElPQlmfd6fkdO55ffv17zLw2QtXSKkZiasYSPSI+uAzf/lalvPG t0tKQtXwi9UN9mqajRr7x/eW4NcCnPMNGzZApa9ds4V/q+DiJct9E/ODs07t1XMQUzWV0LCQ0rKS 0rSS1LSkZ7SskX7Ia1qJq5uDRlTFWFjRYLe83gYBsSFDP510GjthioiykZiKiaSG5adadA5M/FCI 1MA1wj48a9ailQICAlJSUpaWlhoaGsuXLx8wcNA0rrkLVmxat11sm7iKkIymoIymkIzWLlmd3XJ6 uxX0kO7cq7NzrzZxSUBKYzXfLu5FKydMmdZ/4EBmZ7ro5PGT/pzGNW8a15yecS479/yhI0aynDQ2 rjlsM+jYU3V2rrkc3Au+k8j+CYwfP554A3f0qDHTuJfElF+3DE4VVTcTVjERVTMX17T8iFZIxTTo iLyYuoWIqukeZWNhZaOd8vpC8roLV23pHp/OXb5hj5KRqJoZUZFRlwWKaViAp3V4loZd4PjJbJKS ktR4KoVC0dHRWbFi5XR2rn59PwRrg4cMGzlm/CR2LmK2mThlOjfKR47pupv6MOBHzOP/H5g2bdr8 +fO3ikhlnH+u4xoppm4urmEhid2nYyOlY8tAm49I/4lLIIAQRVVNhZWNdyrocXDPZ8kZbjCfmDIY Smhafaxu8znaMnnKGjr5pBzFQtq1RyQuLi4pKUlJSUlUWEJQQGTu3HmAcePG9eZJYm9EjIhjGAOG fwSWx7R62VZ36EKmpqa2jwHObm4//WEoAnAnf/+yG68MXIIVjRyVTZ1VzFyRKpk4Ie2MKFE0dlQw tJM3sJXVs5bRttgjrz12wpdCy3ETJ8vq2cgb2KFiF26d2RKNGrmFU8svC8mo6ujqampqKimqKitp b9zAB+9i1qxZXc6E9DS3vYGsrKzmbnDnzp28vLxNH08+fEOgJCaevXz5wpUrBSUl30PbbN68GbGz goIC7PKXKRGLHTp0qPTiA2vvCFOXAGNHX0M7uuesb+thgIydl+FHNCDKbTz1bNy1LVw0zZyEZVSG Dhv+Zf6ANZu36lq7GdgyXPpODD9ja+uBvIlLQGhq8b5TNzfyC61auVpRUUNGWg3zD3FPnjy5y2sp fxugcw4fPfqwpelhc1Nz61Ng09MnD1qaGxofEpGdl5fXN2mIgEmTJt1uuFd/987t27dNTU2/IWcC oKnAGd1+/KzVzMzsC5RYDA0NDQdrbnmGxSGQdPQNs/cOsfUMsvMMtvMKRr4LohCXEE1buvpuFRLu 27frqUWW0LdfPzUDi554fuDsSefs4B3qEUquvPog/8i5WXMXbOMX2cLDKyQkhPChyydf/gkg/Gxs bHzz7m1LS8uFCxcqKytPnjx569at1tbWF6/ohyExJzAc36o5WAp+fn4+Pj6kX/Vhk14CbDFxDvzd u3dwuXsiE5Hcm5xfFkFNCY5NCIyi+IXH+oRGe4dEeYdG+/SAuOQZFOkaELps5Ve8tg+YyjbNIyjC KzSqJ87MptGN4FhaTFJWCJk2esxYbG345wgfvuFpbfilHYxXHmpra7m5ucF59OjRU6dO9fPzQ2F7 e/vTp0+3bt0KSiwzFPr7+xO7UlBQMCcnR19fn8mqf//+WI0kEgka8uDBgyBeuHBhl+bAxIkBioqK XS7BZYImKSsrO3z4cExMTE+fEIRmMzIyys7OPnHiRH5+vo2NDfND8VpaWighlNLr16/Dw8PRW1FR 0c7VBw8ZomdiTklJj4xPCCNRgunPgqP8wiIJ9A/vEQMiol28fDg4OdEx9P+rzJzgHuEvcAYyWw+K jImIo8anZbr5+GFCsHq/7UlOa2vrDsarPZBRZ0uKddXW1oadgl1PiNvc3JyYSWgAxIYdjM+3Mt9F hW5E+Yez5R9fZ8CCMTEx6dwc8ZYK2JaUlDAL4Rb6+voyPgzbTqQdjBcrVFU/O0eE5aSurk68mtTO AKKVs2fPIp4CwbVr1zp3gHg1w97evsuQBw8ezDGdk4NjOjv9QTDHNHYGcnxEdnbi0fCnEgbOmDlz 5cqVCJRsbW0jIyNTU1MPHDjQnTlLQM+Jhrqz7Y7oFQfnjIWLF3NMn/4N1TgBpaWl9FuvL15gwn/r FJLv2LGD2CN1dXUwuCiB50ZMJl35v3mDaUeG+P6PoaEhQYwSaAlYTywS4nUqzDyxWgig0WgohKXw 8fEhSrA3YT4gmkePHt28eZP4liBYEWRsbGzMupmZmSh8/vz5vXv30AqcyaamJhDfv39fXFwcPjY8 TOL7tKiOS+hGfX09tFAvpwIcoDqgkVatWjWTi5uPV1BIUFhIaJeSkjI2BTpMpVLLy8uhVRBWQL0g hTKBHjt+vBJ9A83atZ/dicLawKxiyGFhYdBI8B6lpaUlJCTgeFtZWtnZ2Tk4OMDBYByo2MKzmW/L FoE5cxZiU8+ePRuW7hvaUALA8GZtbTtDKMLCwszyiRMnFhcX19+5c6uurqiIfswVnuHFK1ceNDY2 tbQ0NjXVMcrJZDIuQYEz3ndowPxHRUWtW7cOHdbT06urr7/T0PCouTk3N5dYRQi7qmtqmh8/xmLA 2Im23NzdUf3egwfY79ikiAGhJ2/fvdvy5Mnzly8Rfv7GWITWtrZEK1evXsUUwS6vWLEiJCSkpqaG eD9x5MiRUlJStfX1T1pbGx488PDwgKAxqK/6TxAsbHQeSx1aa9u27VoapnY2Lna2Tm5uHpAsfBsM /OHDh1jq16/fgNHB0LALCgoKCgsLMWOlDChjwP79+5GiEKsiJSUFcxUdHZ2WlgYCVDx+/DiUQ1RU tIW5hZ6uoZ6usY6WKR+vAC8vL4zFjBkzvsd3zpcuXVpZVXW1rg7iDggIwDRCS0NkEMf+w4dzMIyy slWMDwotXb782OnThyorK44dyy8pQSHxNA16ODUrq6yiAqip89kRLH0jo8OVlUdOnDh47BhhgGbN mXP01Knj1dWV1dVcjHeBl69cSbcO1dVoqPPrltb29ifPnj1ZU2Npa4uf0zk56xoaSsvL0atVnT5w hD782Wn7T5w0CczRz6MnT3L93XeN4RphWqAu4JZgM2qoG4UGxYUEx0RGxmRmZl2/dh3ODN2PffEC OgRyr62tO3XqFHY91gMhd2wE4sOnAEIbYJ1AHUELYalA7WBfoDw0NMzFxc3FycPFydfE2FFwxy4R EREsdUTZhDr95rBhM09pxdG0nLziiiO1DU3vOjou3qzPyCukpqTHxNMiSJQt/B++87NHXLy88lRq Nv0INA/fJ+W8YRPP2Ss3kzJzYyiJIxkOJDP8X7NufVZBcfq+gqT0LOIS/44dlTXnURIWTRrIuI1j Yml98uzFI1U1mBC4dtitxJHvQyerU3PyUrPzVTXpr5pKychXnr2QnJnj/DEqZHmTYQsf/+kLVzPz i+NoyV84XviXAAdp0aJFAgIC0LrwFmSk5R3sfKMiEmKi4smk+LLS/fV19fB2XjO+Wvue/m8TbYQv AVcBOwU2BSnEStC8ZAAyMEMwWFVVVXFxFD9ffx/vQF+fUE+3MGUlbXFxCWj+jRs3fj9ZA4QlpHNK y0NjKUEx5KBockBUbGBErF9YlHdQuIaeIVun7/yoaOrEJqWFkuK1DT9zvbT0jXL2V5CT05U0tbow F9wjQkpKC4mNs3b+8KRbU984ITM3kpqkqsk4ftynj6OnbxQ1OSohOSYxDeUR9DOrieFkBEckdAPp qnX0p/8OHj60rDxySsY2wZ1fGI6qjl5iTn50QrJ+t8NmXwuITRBEYP5lZWUNDAxgUxTkVXy8okgx ybHR1HgKLTMDocHJ+vrbkGNPrwATH69+9eoVpH/+/Hns+5iY2JDgsMCAsODAqMAAkq62uYSEpLy8 PPY1jCAXF9d3/a8KK2f36ITUUHKCuYOL+F4FCVkFUSnZLfwC3Y8xWDm5xSSmR1CSNmz+7JSmmZ0T OGQWH9Q0/OyeyYABA9KL9ofF0cIpNN5tAijp17+/e0AoJS0HfHi20pXGgIEDvYIjomlplLRsRXWt 3aISu8QkhSVkdolIbBUQwmrZKSI+4veRYOUXHh2Xmp2Qlbdj156exoLN7uztT0rJpKTnCOzskeyr APOPCIWfn19FRQVCl5OT09TQD/Inx8WmxZGSE6iptISUjIzsw4ePnjlTU3urFpYdihqeJFzEGzdu XLp0+ciRI/l5BWQSJToqNiIiNiI8LjKcGhlGMzd1EhMTJz6lCwUOZcLJyfnN/fDOAAVLSs4gp2TG JKUvX8364SYBw4ePiKKmkFOzyClZ8xcu7nxJ18QcG/Ni/cPHz55hZohCBO+IU6jp+6JpKQFRpEGD 6KfoR48ZCw7JuYWQ2ux59McKffv18wwMReHhmkvrP38zpXOwjCjG3T+YlJTx6HXHgcqTTB0OF9rT 05N5IGfosGGhsdSs4oM1N+5gV9JLhg7955+MgCmfM2cOfHU4hBoaGnCwlZWVlZRUzE2tgwOiadSc hPjMxIQMWkJaAjUF0k+kYQ1gJSRR45Pi4mhkUgKZRCPFJMaRUiPDE+1sPdRUtOBSYuXARd+yZcuS JUugwL/HHacuMGf+wvC4FK9gqO7IPxi3+nu66z5z9tzg6HhvUAZHjfvjM22zaMly94Bw75DoVx0d MEzw92CCEU8FxyZ4BUc6evijFYKSnYMzipoOPv7hZOahNSUNXc/AiEPVV2HXXF1dEWgjnLl06RKq 7xaV7PNRWDt2CXsGRQREUaAh4dM6OzsjJoLdjKFlKGvq9e9P/2Lk2HF/eIVEh8TSXjK+FOEXTtIx sezlrc6/BFjzefPmrVmzBt4+FDsCT8hdTU1NTk7ezMTCyd41KCAygZKRQstJScpJTKAjVkJSQk5o MNnTzd/a0l5dVVNGRgZLBYoCfiAfHx92BwKuH/YXJLzbd5o6uBtZOytrGX/5UcVG3u2gNLZxUdI2 6n51j6ScgZWjmb27tVuAvTf99q+lk7eJnauWsRUbx6dD6avWbw6hpFs6+2iZWBMvrQMmTJyMn4ZW zmb2nlauvtaufuZOXkY2LkY2rtt2iTJ7NWz4CHVDS0MbF3NHT8bt5RA7jyALZx9LVz+xvUoEt99H jjaxc0NdYzt3MydPsBLY8w2OZHcGDg4OhGkIADds2AC5w+bq6upC9PDh4dQpKirKMkBTQxNhJoSL LYy1oc4A+gNNUVFIGXEWdjQ0RudbCj8ANm7bvUtKaae0yvL1rF+aYMJ6vp2g3CWjunwdC8pBQ4Yu Xrlhp5SyjKaJnJa5nI6FoLji0jWbhw4f0Zlsp5SKspG9gp7V5h0incvHT5y6YetOMQVtKVVDGXVj MUWdzQLC7FxdvxY1ZvyEdbyCooo6exmtSKkbbxEUmzHn013xPn36Ll/PIyynKalqIKmqv0NcYfyE 7/VnfLCz2OzLli3Dfufh4YGex4aF9LFzofCJb15B+pA4RLx9+3YYF5gDGGhIGWvmp7zy3PuHj316 YQH79us/YtTY0eMnDhsxqsulP6awbxVXsYnI2qNkvFvJ+M8ZLD78NXjIsFHjJowa+8fAQV96Aj5w 8JDRDLJBQ1jHWag+/PfRg/9BFPZVwM7Ozs3NjS2PDYtdD5mu/Aj4CXW9ePFiLIyZM2d2+Y7TT4He PyL/MmX3S8wSzL+UtqWRR5SUlqWYuomApGr/AQO/XL33XeoN2Y+HyZMnf7/Y+X8cxv0x0cTJR8/G TdvCUUHLeNKvjz3+q2HMuPG7xCQEd4ts5OH7X3j98xf8F+D/ANXK5mENCmVuZHN0cmVhbQ0KZW5k b2JqDQoxOSAwIG9iag0KPDwvVHlwZS9YT2JqZWN0L1N1YnR5cGUvSW1hZ2UvV2lkdGggMTY1L0hl aWdodCA2Ny9Db2xvclNwYWNlL0RldmljZUdyYXkvTWF0dGVbIDAgMCAwXSAvQml0c1BlckNvbXBv bmVudCA4L0ludGVycG9sYXRlIGZhbHNlL0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGggMzgxND4+ DQpzdHJlYW0NCnicxVppWFNXGs5GViCBkEBYEkLYCcgSIICAoLIngApYqMUFFEVc6oIoKtuoqHUX neLSmQodx9FqnVqBaltq1bYo6gMiIFAUBESsiIBAljkXErnZWJ6nA+8Pntyz3POe73znO+/5LgjE ODDnWNlYWbCMx2s3PTAwtnTxnRsSFh4hiAgPDZnj48g2ok43KQXoMaw8ZocLIAjXb970sRD6FRbg yqaTp5uaHBQjO3/AcF7O1w9apSPoabh5LEkoCPHi0HSnm94w6FZ+EYIF+++LpEp48e9kYaiHucH0 09Rn88MEMed6lRmOoCJNGOxmpkecXo40u7mCqBNd6ikCiH9IEs62oZKmkaKusUtYZF6LRooQBq4s DHGgTR9LMtMnIvrSmBQhPEsNm2GoPU0cdc39hfH3x+UI9nqWwN1oeljqMP2Fqa0KbCSiof53PT19 Q0MiCbxcdCrKnT4dK04ymSlM74Ez6W2v+uHi2cP7DhSeL6n4o6tfDKu8GuVqMA17nOYuSO2GUWyr KM5KDA/w8XT38PabG7P2+I36Lpg5iyId9PBTzZFsE5bY/oGCuP324cQAVzsLUxpUacq2mcGP3nm9 9vUoy+MhHF3c1HIkMQMXVHwg0Hf/9KpgPpeio4UcbWLjEZ1XVvPhHHq/LcLGSA+AQiaip4YklRf1 5QeOvU9vFJ0qyM/fvc2dgoJNxMZrxcXHg/JWb6+cOrQ/Pz8/b8McElLzm/86kNghKf1qgs3dmdrw 8a2CDr5WbfQsGj6V/x+o7gsq1XCUSs45Yj80QhLtc9+otmnY7KIzFSSJrKAsdRyl0v4tZnKHQ5G9 igZUGohr8uaa4KdiuSlOMdXqSUpfzNMfYYCih/2qWj1UkRdmoTMVGwfPCNguD4E9yjTuziQClkis eXKzGkOXbpppQpgSjyRZRf0oG7X9J2WvE5+y1UIgSU75b1U5SsrXexhip2RrI3S5S2QGlJzMKlbW u71rjDF6vpeG1DnDjWAGHonCUwyZbDaTro0Zly+GSKHoUYiYyZPU5x+SDfpsZVDSFWU6f0Tbzn+g jqJUWh/p5DZLuHpP4dVr1745tmP+bB6bLHNQJM7EzX+Wr6ebC4CzHYOAROtyvAWbd4H4uyWSz5pk bMUzwm7KBt0bwOKl3JEoUfn9cJt6jtLBM1erO2HCo7uuZIOvKQ4aH228reNlZ+fTaghVlflshntK WYssPIiefx1ugh2XGQwEs4UyhTYUY02muGXUKlGRqMZ55XnA0Hbcmwq2Es7jF3jpDwm7axSudq8z OVqTsSRzqWyFG3xoRIyBX/5LzRRks6kWj1Fb8xEDjdCJfgEv+/2Rco/eVYaTCAsETqasX6E1CYfE Gof+/d3YHN+V7O8eq/7lx3Q0PVUh8veptqr2mYSKItqelHWbT9dCI5B489hLg6rvHMWLL9LSXsGe RR33fr7fAbfUE39ty6NjzhNgIJEyYY4oAveCrJvvcFxGkWyXl2teTtGjvTHCYphTDpTvT01cfQzu yZIsFv+mckexsiPnmE54h6PwM76VvdoTMdwLTXbZVKOJY39ZeqB7Onz1ftvgZ2thLzgL3xf/9RA0 KHSTdFXc+KVdoUh6xGLCTonEOn8vs5G7rBOG6rOrQz3HrqJkHjscTqDv0tqooNnBn/wDTrI8dLmC 14qfnEhLWPmloq/v4Ux852AcZCTFfLkSx5rEXVVVPKBF/ZEFtlTrI/CFE7193QnQpXBs3o7LUVjc 57tD7c2d1ytcRge3MCce0FE28uX2xcmmhrPeoBBA5K+9szPIXJs4q05NnSJ+WnZRYXJfhhrj0Qbx Chrl1QrGxH0SaSHfOKGk4TMNSXTIVaPApZKKrT4MPIqcMGb8Gca3ax/BH7vTrcAxpPexQgB+FKU/ YUOicQx5CFqhh0FB6tb7K/UhqDXFHIxFWzvGeSObzpF0hU3y9CM6EoE0SnsPLzzvNfH8Akabki7r dskUh0ZgDAUVUg0o9cQjkGbZ8KL+57WPlXHv6xU7FFz6O38dMHnrU/CywRybSZyLenSh7Fjs4Gpr 4TipmtNqQ59ZYpDm+fCi9sKNaWlpa9Zt3JIhx5ZVUcEn4G3E+7jgcMF634UXvlppMoljUY/Fk+0S UTBd3/WwhgTqMLqXG6KZmfBI/2w9z9bWzjVy76kzMpw+vt55tkIof7OOCZxdO+o5vLBq3sRdEoHQ MXcpl3XcywsvVUlDK6AhXM9kLTza/LnJlmxgHVkCb3SeK1QI5Y0f0cA+piYrHOBf+0wm5aXN5h+U dXyZPW50+YFvGl8JL6grSNxapGCj7jTnZQoBoCwQuKSSmwzl2U5KUJr4xMiPApV7mArEx72jzqjR NKPoKw5z2Q4PAJLPHIFLYtyuw1t1rTad1AWOylt4R+OQPcqK913W4twx1KSko2gJl38eXvR2Awu4 JCG4Hl74ZMHkvl1RHBbs0hD6xHWXbynfedr3PtRIcbDt+u75tjQvBVVeHwe5pE40XN5J/+MzyVyx Wcin9VJ1GCjfmbhVhdKzD1NQmNrAm6afi7IT+ExtkvPnVc87ZHhRc9QLuCRCN7C07oW88PmDFKtJ uSQCQeOvvaLOlN0XV/KtffNeqakarn50+37N8/b2jo721tpHJcWHtiSGuJlTsCis2dzUrDyAXIDt KYGmkAQnWkWvz86VISORR9Vhubrb6U3YMVGumU/UkGj9PJ6rT2SEn1N/SA6V7U1JXZORBcbMzly/ PDbY25FN14aElBYzIi1j27ZtGesWhXi52BgRISZaZJaDq5sMThyqtm1xY1PlTI3pYiSOamKij5Nr EIxxcoMqB1HVXoGlDhpJ4CSpPyarcoKdLGydXMCYLjPsLc3oZIIsO4D3qns/AKG3+fMABlFr2FpI DI5IkoOIx1CiOsGdMVLjJ1UtTs6FrzYzRq7xSIJNuhqFO/BjxixT4rDe4OV0quHYc3a+CRmNJQyP TMBhUKO6S/+T0VBW6aneVkjDjaC2JoKiyZDkBSAu3nQY9lykjsdpNfnTd99tDKSP2BpjGPZP1QUX /bTVlab+/SjW30BEkIiHA9VQuinNyp5lYGJnro1CEoydvPh2dCwSgTJddaeu6piXDhJrYOfJ58py Smgyh+fjbknGaHuclEBfOdgEKKMX/LOaPdN3fU88j0UfmROes0z1G1Tn6blmGqyAcb0GOLZU3K2F gv7lWWvu3ruacLruAkebFfbF47bWylwXXSTGalftHxVLLAh67tkVLW1V+1x1gJrTdki90fSyuTzR 2vVaB/SSqiNMIE3cKtU63ODpOGGQr6sdh23KtuIlnFIRwX2Z9poEAiEY3BwH/7V2xT7oOle69Ffg e0ADX/f1KRhRveIfvXXwfBBLX8cxTGMfDBtJUuJGQBuEloysWXe+PD1ewQMXBZsVF249qH78uK7x xZt+uE17v4sUCAThEKIWZf6nXqFysKNsEVuT+Kd88iew9Gae45IH0M1hK/BoSLV8sbT8Q/9iOz0o w/Es1iYJ8neoWrzDlCZokjf4br/sx3U+2EMGzsJlqUARpm3fe76yRVECDTRe3S4UCIQFt18qHoRv HxYudtOUhEaa5gGXrFnjO/cQsH/fvqPDR9bAq4M3oKk3N0IZ0M5oq41AplctnPdYKn1f//sLYIFf /OYAe0v+bGjuFVem59SDIftb72fYA0cl0ljWtsMIiM0ufarujqgMSVvp9nBnHU1JRgwX+tLb9vC3 Wmjpft9aCnVpuXLgOFjArsv791wCCmkoc1YRKP52MbheDT0s/nspUH9Ny46Dho3nduWfubApPAES f9VHl/sYQvNGYbSwI+D4pF6qHl8HDT79d5IbEx5yFIHzvT06n8acVMgxW48lLgE+OHQtydf/UyAH RfkLwV4cPJoG1nywvbmpFZi1OQe4cm9hrJdX4BxXayGoF/0z0pZGUHo9yyW2oKJDbU53dNie6sIY LkMDQQik0eRF370cwfI2aGihUwK4mnVlu+gzEppAhNu6GmzersytsHTBvcPgoTnNmqxLNdClLgD0 32yyJmJUzk1Th7mZZY1vxlBi/S03c8JsDcfgiNBf/Cf0jfftm/bKs2t8HVcBH2xYYWG0CJR2rmPh LLaBZa9dtRP8rUvNBe7V09HS0tr+sqng6CB0rzTAURm6aGoyYPw0nq72aLfyjDtwq7lXg3IbaLtz KN6DoyGIjwDF3A22X/s3p47krgx1oFtBu+hWCMXgY6BTxJcifTeBe95QYdwxMZRZ3Q6Wue36l0X/ ffTVtvi899AH/8DZud8H0Zk7AOPKdbMM1X5+MbOfmXiioqN3SIWnqP9lxcnF3nYmY1EE8WI4lN9I nuPtam1IwjtfAU9FbnhK2D3In2uqgIVE95IjLoLi4rBVwLziZw/r3kmrYnnJUBbm9cOnYuljX4dj YPze1mo3DTlMFtd/6cGS2s53olG9KBH1dT4pObjMn2s2NkUQyoOegqiyh0cjk3BoJH420Ff9O6ww ROc8+Z4U3U/3EYIQOrDLI6JEPkRNMDOwWO5nTQLnw8M/qv013tbYjvzQ5fsuVz7r6ul7P/C+r+dV c+Xl/OXhXlzmeBTBvS74j4HBpkWMEW8izWkYGGxMMEJhjIVFr6A9+b7z+ib/GSvB2dO10pK7+s47 QFP0pmKdkx5n2Y894EHc/WgLzy6lVSyVdJ9xH+tKyeF6zFm4OutAwdlzX5z4bGdafBDPnm00PkVA a8aagpOfepBHIhRxRtrxE+vddZFIkuW83Zd/e3Drq92L+B5bfwVsHkTSqe4pJ2/e++1awRo/Izxl xtJj31feLyv8NMDEaGbmN3fLDsRYjPPvCeY2jq4efG8/H767C9eaOdErCZbm6OfnSMPKn7h+flzo Ca3N8oxauuKTCE8OewmUFBo4yiNhqbYBHyUnxc12NCKgtPSs/WOTkhfOcWIQiQz3qEUxfhzdiX23 NB4rJqoBCkc2MNDFolSeUDiKsYWluRGZwNoD7aHyBKYWEkM0YHI4ZgYkoJeRaCLVjMNh0khaSBRO z5hlakAc/yPbXw1wumHQKASaubm+/fm3q510IQZINCiUU4E9IFFojYfaFABNm5manRHnrD+xT4z/ A1P+MbQNCmVuZHN0cmVhbQ0KZW5kb2JqDQoyMCAwIG9iag0KPDwvRnVuY3Rpb25UeXBlIDAvU2l6 ZVsgMjU2XSAvRGVjb2RlWyAwIDEgMCAxIDAgMV0gL1JhbmdlWyAwIDEgMCAxIDAgMV0gL0JpdHNQ ZXJTYW1wbGUgOC9Eb21haW5bIDAgMV0gL0VuY29kZVsgMCAyNTVdIC9PcmRlciAxL0ZpbHRlci9G bGF0ZURlY29kZS9MZW5ndGggNDU3Pj4NCnN0cmVhbQ0KeJyFwodS2gAABuDnsrV72zpREVEEkaGA oBDCCjMQ9h5hC4iADK1272Xbx+of4513rXf97hubNI6dv4ZTfBP/+jR3nEuMz1y8gbPETa6Zf2sO Sa6AvC0g7+C8Be/yF6z3zt9fRNsDId/+cIn7SIQOfLyM1BMxd0LsnFhxPl1F1zOUuCYl7qk19ExL uTMy7yyu+3BO7hPIacEGPa/w44IygIuqgFDFCNXMkjoo2gyKtkLLqAmLNeEVbQRXdVGUbMfW9DGp Pi41xGWGhGwnsb6bRLkxtWFKKUxpBZFWEhmlOasis2oyp7bkNq35LbQVNPaC1s5qHazOUdRRpW2q pHeW9a6ywV3BHU9111M1emtGX92E9B6B/oY50CADTZJpWpiWNdiyhvZtobYt3LZj5MAR6VDRDhXr OjHec2Hi0I3JvgdTA2964EsPkc6M6OzIj7mjAPeYyR8zhedB7kmQPQmxp6HiaRhLLyJYfhnFCr6K YfV1HGv4JoH1t0ncw3cpbOD7NDbxQwZb+DGL+/xPuTb/cx4P+F8K2OF/ZbuXi91vxd7FUu879/By uf/jr5X+WWXwz+FZdfjzyrXhr9roP+uj3/WjK/4BqNyYIQ0KZW5kc3RyZWFtDQplbmRvYmoNCjIx IDAgb2JqDQo8PC9QYXR0ZXJuVHlwZSAyL1NoYWRpbmc8PC9Db2xvclNwYWNlL0RldmljZVJHQi9T aGFkaW5nVHlwZSAyL0Nvb3Jkc1sgMCAxNTIuNjUgNzIwIDE1Mi42NV0gL0V4dGVuZFsgdHJ1ZSB0 cnVlXSAvRnVuY3Rpb24gMjAgMCBSPj4+Pg0KZW5kb2JqDQoyMiAwIG9iag0KPDwvVHlwZS9QYWdl L1BhcmVudCAyIDAgUi9SZXNvdXJjZXM8PC9FeHRHU3RhdGU8PC9HUzI0IDI0IDAgUi9HUzI3IDI3 IDAgUj4+L1hPYmplY3Q8PC9JbWFnZTI1IDI1IDAgUj4+L1BhdHRlcm48PC9QMjkgMjkgMCBSPj4v Rm9udDw8L0YzIDMwIDAgUi9GMSAxMSAwIFIvRjIgMTQgMCBSPj4vUHJvY1NldFsvUERGL1RleHQv SW1hZ2VCL0ltYWdlQy9JbWFnZUldID4+L01lZGlhQm94WyAwIDAgNzIwIDU0MF0gL0NvbnRlbnRz IDIzIDAgUi9Hcm91cDw8L1R5cGUvR3JvdXAvUy9UcmFuc3BhcmVuY3kvQ1MvRGV2aWNlUkdCPj4v VGFicy9TL1N0cnVjdFBhcmVudHMgMj4+DQplbmRvYmoNCjIzIDAgb2JqDQo8PC9GaWx0ZXIvRmxh dGVEZWNvZGUvTGVuZ3RoIDEwODI+Pg0Kc3RyZWFtDQp4nJ1Xy27iSBTdI/EPd1m0hqJeLrtGURZ5 tTLqHqU1SLOIZmHsglgBm7FNHn/ftwxJU4aio6wgyj33cercBzC5g7OzyffL2ytg5+dwcXUJ/w8H DBhljHEhWAyxYBApBrUdDv79AuVwMPn6j1CwaIYDDot3a8Y0Z8ozn38ZDn4MB3D9/RJgLxT/FWq8 w0ZGx7uoieT8SFQuJDUGMBromHJmIDIRZRwE1VpzyFaY2e0qXVgRwVUFxwKLXWBXQfyrAm4Smgjn 1sQJSI6fEmTCaRy913HgSx7wJZTi6iRfk7u0bW1dQtagK2GgyUoHVyKmokNiUM30SfbULvDFFB3e SMBKpnNXiaOGg8ZcFFahDeUGpqv9+Gz7Xl+Hg/szJuOL8/9g+tdwcI2ett5431sikASx7+2efCtG Y0HKzQvk9SgixZOtIa9Wo7EkaVE2MIrJprE54P/aCkaK1Hb5ClUJIz/cWwyVaJqo/RjgZMEjmGb3 ZJPbpwAQaaaJ9oCsw4QiRUr3APfEPtmyxaQNKQ4y3BJC8WWPkiI1jeOdm6rObT3SxNWLVS/TTZk9 hPIQUUxj5TuYpdkjYm2ZNwGUxKdNemFDEaRGI990XtXBF2CK6l4+i41tWkwolI2KsfuScDYHuo36 uvVJNYxKjtUxTtXubZxG1TGN+kicBRRlu48kV4GsuVCUSd/Wrq3TbpnbMnNfXoPPhrWaxAeHZS1w nkQ96xNiljw6MA++ruCU+6ZF13e1da25XqaZ+3Q9qMhz0T5ACqjNbNO01cr1ZZ52hqtw9jtSRYzj 9S3GbFMs266RncbXUKGneVjjkkbKd7AsZi/LkL2RlPfsT+pJf0hPQiZI1SfktAckf1cjSZ4hq8qm aPBriyPDkTCz7XOnHVvCtwInoiMV0jKHsipDfYN1Gi8vMg6NK3xgTG7ftIsCo3G07c9Qc2rBcCt6 yJNcxh/jknVP+hky95DkrnZ0PhW5bYLqw42spA9b1DZ1/OIC7WgecU7mS/vi+C9mxbJoX92b4BR3 7nEcO6t6t4XqDapWur1Uh8iODO0lGnwX7XaCb9us06yTwm8aisfKjf73me+SfDwx9AVqgPVgwZZj msrIt8WFjERDNcdl7Tb1qRQlriWjfDwudrfUQ2JWnEodzu5AaMmHhMZxsXP9GaHtI8l1p410tZ2J 1u145KGb8ek63UrG/fEnakmRLT9Bbgynkfb977gJ3zWsI2cfkqWdDsvqGTaNW/e/kwvvCN6Cf+RF 8xiy15ImPfugb3f/RL7tR6SI9weuPw/2h9srzw+Fu3Vw1aQNTr5uNK4rNyibYoa8dxso2Hbozfd5 6uIzpm99Um7Gk5s7i7ACdXAvxwJUpN9uwu1vgu5KJrerdV09WSwId+k4Jjc4cN6GzfYMhqtuzhSd UVA+bpRrLwreKEdba3IjjqYpcdhI38FB6T8BapftiQ0KZW5kc3RyZWFtDQplbmRvYmoNCjI0IDAg b2JqDQo8PC9UeXBlL0V4dEdTdGF0ZS9CTS9Ob3JtYWwvY2EgMT4+DQplbmRvYmoNCjI1IDAgb2Jq DQo8PC9UeXBlL1hPYmplY3QvU3VidHlwZS9JbWFnZS9XaWR0aCAxNjUvSGVpZ2h0IDY3L0NvbG9y U3BhY2UvRGV2aWNlUkdCL0JpdHNQZXJDb21wb25lbnQgOC9JbnRlcnBvbGF0ZSBmYWxzZS9TTWFz ayAyNiAwIFIvRmlsdGVyL0ZsYXRlRGVjb2RlL0xlbmd0aCA5OTE3Pj4NCnN0cmVhbQ0KeJztXQVc VNn3X7vXXnMRRMTubhFEEQw6pLu7u7u7ZhiGoVsaVDAxQOwWMFARULED+H9nno4Ig4u7xu+/6/mc z/3cue/cc+Pce+K9+9789tsv+AW/4Bf8I5g3d97CBYuXLF4yevTon92XX/AtoW/fvps2bbKzs8/I yKyuqn737t3bt++etLy7d+dx6xPk36Lk3r2GQxWHgoKCJSUlJ0+e/LO7/Au+GgYMGCAkJJSelv7y 5av3799Dps+fv7h//8Hly1eOHzuelZkbE03O21d46tTpq1euPnjw8MWLF+/oAMr3Z8+eNzMz/yX3 /xcwcOBAfT39pkfNbW3tb968bW5+fPXK9UMVR7C7KRRKSEiou7u7ra2tmZmZvb29t7d3ZGRkIi0x Nzf32LHK69dvPn78FLXev29re9+empLGycn5swf0C3qEvXv33rxxq+19x5s37yC4O3fuXr169cyZ M8eOHSssLExJSYmJifHz83NycrKxsXF1dQ0MDIyNjUV5QUFBRUXF6dOnsf2hBKAKIPH2to73796H hoZOmDDhZ4/sF3wGmzfzVFWdef++/e2bd8+fvXz8+ElLy+Pm5ub79+/fvHkTcjzDgNLS0sxM+jaH lJHSaLTi4uLjx4+fP3++urr67Nmzt27damxsfPbsGTR7e3sHAfjp6Og4ePDgnz3KX0AHCzOrt2/a Xr9+2/r02eOWJ8+fPYcP1t7eDosM2Z0/f2H//v0BAQF6enqysrK7du3i4+Nbv349Dw/Pjh07xMTE FBUVTUxM4uPjDx8+XFdX//Tp01evXrW1tXV0hvaOU6dO/fnnnz97rP9pwI6jUpOftb588uTZ/fsP HzU+ev78OYTz5s2bu3fvYsNiL5PJ5ODgYGxPQ0NDeXn5PXv2bN26lZ9/2/btAjt37pSQkFBTU4O4 XVxcgoKCQFxWVgaFgN39mbTbOiD/e3cbVq9e/bMH/R+FKVOmHqo43tLS+vBB462btdDb2M4Q9+3b t6G9Iej09PTk5GRIMCw03MrSTk5WUVJSWlJCEntcWVkZmxq2Xlp6r4yMnJKiqouLR2wsCeo9Ozu7 qKgI5r6hoYGQNXY63Wt/3wZj8erFG3k5hZ899P8czOKeXXPmUuPDprra25cuXa6vpyvhO3fuQNCJ DIADlpGRERQYoqGhA/mqq6tra2sjhaDl5ORQgp2Ofa2lpaWvr4/dDVWvoKBgZGialJQCg15SUoK0 srIS5gChHNT7yxcvX7+G2nj7+lWbnY3jz56A/xBM+GPC0SOnbtffvXjxMkzqlStXsKOrqqrS0tKi o6Pj4uKwSSPCI+Rk5SBciHX37t2bN2+GHl7JgOUMWLFiBfET5Vu2bAENiCF6LAlNTc2cnJz8/Hyk WVlZcOSgN1paWhobHzU3t7S2vnjc8lJZUf1nT8N/AoYMGZqetu/69VvV1TWInmCgIQ54WYiYYHzD wsIiI6KhpbF/4YZBjhDrokWLZs+ePX369KlTp44fP74zN5RwcHBwc3MvXLhw2bJloEddWHklJSUd HR3IGiuHbtBLy5qamuAP1NXVPbj/kKFVHm7fJvSzJuG/A1ZWjtXV5w7sP5iUlJSbm4s9mJWZZWZm ZmVl5eDgYGRoBn9bSEho3bp1CxYs4OLimjJlSu+ZQ+6E0KHwofzFxcVjoumhOhw56I2LFy+ePHny 6NFjWGBVp2uKCysmTJj4/Ub6C/i2bC8qOpCfX+jp6WlqampsbAybu5UBiLDWrIGQ10Fvb9y4ce3a tVDUSxmwZMkSpH379u1NE8OGDYPQoRNERUVVVVVRUUZGRkREBEsIP93d3e3t7e3s7L29fRzsnNRU tZZ8hKWfA0qgN773hPyLYfjwEZHh5PLyCnt7h6DQ0Cu1tR1fA3aOX+FfsbGxQehz586lUqlf1Qrg en39tfr6tJycCRN/7f2/D0oKWkWFpWlp6RA3tjM1MfF6Xe3VWzfPXblcff7c6XNnq86dRaY7Xrp+ DVKAg716zZreN8fOzn7mzBlUvHLzRneeaOs0A5FHBy7fuI7OXK+vBfGlG9dgXAYMGPD9puJfD5Mm TvH1CSkpLvP394cx1dDQgFE+evz4/UePGhob6+7evV5be+3WrRt1dSwR/jRdcDdujB07tjfN8fPz Nzc3o8qt27fBuQs3oi2kuHq7oQF9eNDUdL+x8U5DQ01NzbZt2773bPzrQWSPTFRkbHh4hK+vb2Bg oKurKyzjrFmzbtbWNrY0P33xHNj89EnTk8ctrU+Bj5+1Ekj8RDmhaRFb/WVb8PoI4ofNTWAOtgRD ghWzFbTY+vIFyvHzwaNG+O2FhYXQCd9/Mv7lMG7seAtzh4z0TEjZ29sbG1xLS2vNmjUTJ07EVnrY 9Ohx69OXb9+00e9ts0D6nbGOjrftH26D6+rq9tQQ/DSsB4Ls2csXr9+/I+ow+TB5vm17/+LNq1Ys s+fPmltaEKBhHQ4dOvRHTsu/Fdav2+Lp4RsZGe3s7Axxh4WGIVbi4eFZtmQ5TCQM5ZMnT953eajR M7x58wZuc/dWEJtfv3699y5ZW3v769evGxsbL1++jGj9x0/LvxL69OmjKK8eE0O2tbVzcnJCCGxo aIhoa/fuPfCcOTk5EWHFxcU9e/asnfnM8q/g6tWrv//+e+dWEGqBw1fIuq3txYsXDQ0Nhw4dWrRo 0ZTJbH9OnfazpujfBJMmTdXRNoqJITk4OEKZBwQEYF9v2rRp+zZBzDMs+ODBg0eOHFleXo75773E ExMTCf5YLYjiey/oDoaTD30CN41CoYwbN27rVn7BHTt5eLZ36TlsDQJwPj4+BOxqDEBm7dq1c+bM +WGzN2PGDOY9AWQQXf6wpv8eLF28ytjI3M8vwNHREcrczc0NWxuB2LRp7FC/8LQJi8nFxQVVDO3a e4nr6OiMHz9+//79vRc0mMMWPHr0qLa21sjIaMyYMegJQ9vwcs2Yi2BBSkoqIiLi1KlTIPsyK/Q2 ISEBffjyfb9ly5ad6gTJyckRrEBI6NMd3dGjR+vp6ZWVlWFNdm/35cuXJSUlCgoKvbzv9INBUEDE xpp+I4vQ5JgfbG1paZlJkyaxsbENHz6cSQmDDkG8ffu2l7KDROBifZWsMVcPHjyoqqqChkGLEhIS 8BWRR6/OnTvXe1ZdABZh3bp1LIevra3dm46BDMTz588nk8noZG8aRYf/1w7jwXDvlVFxdnJzZGhy hGCYXoh7h4AQNiYUaRdnWF9f//Hjx1C2f3vmewIYaxj3O3fuwHXHMhs7Fo2Pg4a0s7NjOb0QAapg 7dEfnr58iaWFXn1Z80RHRw8ZMqTLDEAD9KZ7/Pz8iB//UqV0gZs3b44aNerHifOvYMSIkYoKGr4+ 9POE7u7uMNybGTBtGgfsNeKmQYMGdakSFRXV2tra9fQRK2jvaG9r/wsyELx+8xrYwoi20AeixWls 0yDrixcvEmRv3r4BDdK39JPs9KNTMCuEzofffunSpRs3bkAtQO7tdJG3E02/b3sPYlREhuBz7Nix LhK/desW0Q0C6YcsPuK79+/QIlERer776Jhsu5ej3Q7GmsTE/jhx/hXA490ro+Tm5gGTDYcKsS1k DaXdr18/yBpRGDJdqkC9FxQW3G2496i5icDmxy2dsamluRHFjAxxlSDDz875+w8f3Ll3t7a+7lZd 7dVrVy9euigmJgb+/fv3RwolQ2xqNFR/5zYo791vQJWHjxoJhHALCwsFBAQIc4NNxMvLC6EwGyK6 8aDxYcOD+6gOJMTh5+/PHMvUP/8EDVGFQOaggER1FD5++gQpGkVnbt+9A1bgSYyFWZFAZrvoKure vd9w7dq1HyjPvwDO6dxysiqenl6QNSJuCB2GUlSUPu0DBw7sydmYPGXK/oqKc5cvV58/X3Px4tlL l7rgmQsXcAlIZJASZEiJKtXnzlVWVR09caL8yJHSgweTU1O5Z836jWFckC5YuBCybn316kRV1Ynq 6tM1NUQtAs8yUlpy8pCPhoaoBZgzd+75K1eIDnzW6LlzJ6urT505U9/QUHX27KSPLzXwbt36sLkZ NERvmcisDgT9CUZXDx46VHzgAIVGy8jJwc8z588TzAliJjLHi4pV585dvHoVDuf3lmMvYRb3fHk5 FR9vX8jaz88P5ht7REFBkbjKnMbusHLVqgMVh8qPHD107Pjh45XdEeVM7FxYfuQYMgcPHykq259b WJSdl2/n6DRixAgmZwTs0OpNT5+VVRw6cOhwxVE6PVJURHqk8gSw+tyF6dOns+xhXmERWgEls2ki RfX9FYcOosPHKzds2kQQa+vqNrY8xaXOve2CpeUVBSWl6Tm5OwSFmJ7MkqXL0Lcuo2OOEa0TeOTE yZNVZyb+zzy5mztn0d69ShC3v79/UFAQAjGEsWpqvTo4JC4lXXSgoqDsQH7p/l5iXklZXnEp0tyi ktTM7KT0TFEJyS5s9YyMX3V05BQUg4Zepbh0X1EpUqJ6fsn+89duZucX9dSrk+cuFJQeQJXOCFY5 hcXIFB0oLyk/xMPLSxB7BwQdPV2N8h67WlyalrMvikzhnDGDqMJcYNb2DmjoSyMtKQMBmuvuH/4s mDN7kexeJU8Pr2AGYHcjztXQ0Ohldf+wiNTcvOTs3N5jUlYOLTM7IT0zJJo0b+GiLgwnT5168MRp 8EzMyAYx0kSsiqwcoiLyafvyL9yqb2xsPM2AU58DSu60PI1PTe+OlOTUuORUZFJy9m3YRI/yBgwc SE3PBEOwZdlPlKMDlNS0TTxbuo9dTEr6C2Mnup2QkRVOjv9nIvqWMHPGPBlpBXc3j7CwsPDwcB8f H/hIKiqqf1kRKzY+Pr75XQclNYOUlNp7JCenkZLS7Fw8xrB6VCq5V+5I9fnohKTYxJSYhGSkzIpE CTIxtGRycnpSdl56QXF28f6c0gNIgRmFJdT07ChqYhg5PiIuoQuGx1FDYuLCSPFgvmT5CrTFwTkD fGJoKcDu/UQhWoymJfuHR7E0aiJS0plFpSzHSO8qvXpqVHyiilaPD4x+GMAHI4bAwT5TRprumSO8 QliKDQ5fV15e/svVOTk5z5w586Stg5ScHklJjIxP6iVGUZNJyRlIB/XwipC5nQMlNQs8w+MSunKm JEZQaEhDydTgGHJwTFwoKR5kEQziMBI1jExFJiSWEhJDwaXOiELQB0bGBkTEhJIoM2bSb3XybOUv OlLJoiFGW/Ty+CTwVNc1YNlVdT2DtIIS1sNndBWIpleuYX1750cCwisivJ00caqYqIy1tS2JRIqL iyOTyYIMGDp0WE91d+zY8eTJk9NX6khJGdEJqcDYxLReIikpvaD8WMv7DmVNHZbMIylJpMR0UMbQ WLBFWygPj6MFRpJ8QyP9wqIDIkiBkeSASLJfeDQQmcBuGBRFR1D6hkR6BYWHxiYQLr2ajn5e+fFo akr3tlDCGFc62uLdtoNlV32CIhMy9vXUT6RRCSlgzlKJ/WBAbEuEq8OH/y4qvFdXRx+CplKpqamp QkJCu3bt4uHhZVnRwcEBoWvZ8WpySiY1Yx+BCZl5H3Ffp8LO5Z8wKafw7tO391rfrt2wqQvzwYMH J2YVEAxZcqBl5SVlFypqaE9j52DjmD7taxG12NnZ2D8caAyIImcUHfi8/58NBNKMT8tmn87iRujU P9mSc4toWfksh0l0Pi4t2zcs6luK7R/A6NGjR44c2ee3PruEJOXllChxlMTExLS0NFlZ2T179piY mHehR/BYWFgIWWcUHKCkZGMqknMKEzPzMf/IIIWk8BMpM09c6oz0S5n5uaWH6WvmWNWkKVM7NzFs +HCwpaRmE3WZ3Jh80vJKMovKdwqLfYPhjxmTkluckltE8O+CRLu0jLwoSgrLmw+beLcePXsFZMSg ulbPzE/OKUpI36eha/jPu/pNAOIm3rjcsJ5fQlwmPDyCRqMlJSVh/woLC5uZfSbupUuXIha+/uBp LC0tigrHJpOSmkNOzoxLyUImLiUbGSKPQlxl/CQK4dnmMBE/QYBMdkkFJO4ZEDZw4KebtHAnQmJh jhNjEtIIMoLtR8xO3VcKFJGQ+Y1VxD1nzpwlPQPxgJJr5kyCeNnK1bllR5ld6ozMzsfQ0g1MrVjO npKG9v7KM0QPe6iejerrNrFw6X8KjBgxgp2dfejQobO5F0qIy7q6uEHcycnJ2OPi4uLS0tIzZ84i KJWVlV++fJlffjwgAqYwLiSWGkqi0dPYhDByIvLI0JFEC4qmgIYg+1DIoGHiB2J69YT0wgOPXnXI q2p27pWytr5XcIRvWAyYgBvR1oeKJBopKavmxn1LB7fuw4F7+eWb8yl5JeCzcQsfQS8iKVNQcSI4 hkr05zOMhb9HDYqm+keQ+LYLspw9R09/CLSn6igPjIoLio77Y+Kkbyq0vw+w3RwcHGxsbOPGThAX k9fU1E5KSk5JScnJycHUSUhIaGnpDBw4MDIy8nlHRwgpydknxMUvzD0w0iMoyj0wAqlHcBQzj3Jc BY2jV6CjV5CTdzB+guATJRMZxESaVXastPLcitXrmb2aNp3T1s3X3sPfwTPQ0TvIySfY2Zferpt/ uFtABLilFdLVgr+/P3Yr6DEEfn7+ffv2vevoiKJlgoDJHPSu/mGu/uEufqHoDxhqGVkwHwFom1gG RFNRDv4s0CfEyTvIxTeUaeg7A4yOT2isq18Y0b3uiHJwtnRksSx/IkyZMmXBggXDhg0TFBCXlpJF LJbBAE9Pz40bNy5cuPDEiROl1ddtPQItnL2t3fyQsXEPACLTOY/U0tnH3NHLzNHTxM7d1N7DDOjo Ze3mT1wl6JlIVATaeQcXn7wUEEObMOnTCYSFy1YY2riY2LmZ2rubOYCPJxDMzZ28zOk8/WJTC150 2rbIU7LLHH1CCc4gAFq5+lm5+Fq6+Fg4eZnYexjbuclr6o/4eJ4KniouWTp7d27iM3TwMHfAWDxY RtwzZ89zCYgydfAw7akuUnvPXeL/W+frxo4dS7zNt3DBCmkpBUsLq8zMTKh0Z2dnXj6+m83NQdR9 upauupYu+tbuhrZe+jYeBkBbTzoy8vRCa3cdCxctMyctU0c1I1tlPYtZ8xat2bRVy9RJz8qFICMo mfihuq0n6pq7BOWduK5maDNo8Ic7jVxcXDNmzVXQNlE1tFY3ttM0tdcyddAk0MRBy8wR/SEYEkyI jJ6VG8p1zJ11LJy1zZ00TR01TOzBVs3ARk7TZNGyNZ0FN3HKnxiXpok9HZnMO6GGiYO6kd1OcTmW 87aWZ5uOpbPGl6rbaxjbzVu84kdIsdcwatSouXPnrl69euLEydKSynJySiEhIbq6ulZubofq3hq5 hCjoWSvo2ygbOSgbOygZ2SNVMXZESi9hFCoa2MrrWcvpWu7VMpfRMN0tqzl+In2f9h8wQEhaVU7X CgSd6zKRKEQGqaFzUGxhFd9uaVQUF5fctm0bnIphw39fvp5PREFbQsVQUs1YWt1EWsNEWtNURtNM VtsCvVIytCOQ3gddK1l0QNNUSt1EUs1IQsVATElPQlmfd6fkdO55ffv17zLw2QtXSKkZiasYSPSI +uAzf/lalvPGt0tKQtXwi9UN9mqajRr7x/eW4NcCnPMNGzZApa9ds4V/q+DiJct9E/ODs07t1XMQ UzWV0LCQ0rKS0rSS1LSkZ7SskX7Ia1qJq5uDRlTFWFjRYLe83gYBsSFDP510GjthioiykZiKiaSG 5adadA5M/FCI1MA1wj48a9ailQICAlJSUpaWlhoaGsuXLx8wcNA0rrkLVmxat11sm7iKkIymoIym kIzWLlmd3XJ6uxX0kO7cq7NzrzZxSUBKYzXfLu5FKydMmdZ/4EBmZ7ro5PGT/pzGNW8a15yecS47 9/yhI0aynDQ2rjlsM+jYU3V2rrkc3Au+k8j+CYwfP554A3f0qDHTuJfElF+3DE4VVTcTVjERVTMX 17T8iFZIxTToiLyYuoWIqukeZWNhZaOd8vpC8roLV23pHp/OXb5hj5KRqJoZUZFRlwWKaViAp3V4 loZd4PjJbJKSktR4KoVC0dHRWbFi5XR2rn59PwRrg4cMGzlm/CR2LmK2mThlOjfKR47pupv6MOBH zOP/H5g2bdr8+fO3ikhlnH+u4xoppm4urmEhid2nYyOlY8tAm49I/4lLIIAQRVVNhZWNdyrocXDP Z8kZbjCfmDIYSmhafaxu8znaMnnKGjr5pBzFQtq1RyQuLi4pKUlJSUlUWEJQQGTu3HmAcePG9eZJ Ym9EjIhjGAOGfwSWx7R62VZ36EKmpqa2jwHObm4//WEoAnAnf/+yG68MXIIVjRyVTZ1VzFyRKpk4 Ie2MKFE0dlQwtJM3sJXVs5bRttgjrz12wpdCy3ETJ8vq2cgb2KFiF26d2RKNGrmFU8svC8mo6ujq ampqKimqKitpb9zAB+9i1qxZXc6E9DS3vYGsrKzmbnDnzp28vLxNH08+fEOgJCaevXz5wpUrBSUl 30PbbN68GbGzgoIC7PKXKRGLHTp0qPTiA2vvCFOXAGNHX0M7uuesb+thgIydl+FHNCDKbTz1bNy1 LVw0zZyEZVSGDhv+Zf6ANZu36lq7GdgyXPpODD9ja+uBvIlLQGhq8b5TNzfyC61auVpRUUNGWg3z D3FPnjy5y2spfxugcw4fPfqwpelhc1Nz61Ng09MnD1qaGxofEpGdl5fXN2mIgEmTJt1uuFd/987t 27dNTU2/IWcCoKnAGd1+/KzVzMzsC5RYDA0NDQdrbnmGxSGQdPQNs/cOsfUMsvMMtvMKRr4LohCX EE1buvpuFRLu27frqUWW0LdfPzUDi554fuDsSefs4B3qEUquvPog/8i5WXMXbOMX2cLDKyQkhPCh yydf/gkg/GxsbHzz7m1LS8uFCxcqKytPnjx569at1tbWF6/ohyExJzAc36o5WAp+fn4+Pj6kX/Vh k14CbDFxDvzdu3dwuXsiE5Hcm5xfFkFNCY5NCIyi+IXH+oRGe4dEeYdG+/SAuOQZFOkaELps5Ve8 tg+YyjbNIyjCKzSqJ87MptGN4FhaTFJWCJk2esxYbG345wgfvuFpbfilHYxXHmpra7m5ucF59OjR U6dO9fPzQ2F7e/vTp0+3bt0KSiwzFPr7+xO7UlBQMCcnR19fn8mqf//+WI0kEgka8uDBgyBeuHBh l+bAxIkBioqKXS7BZYImKSsrO3z4cExMTE+fEIRmMzIyys7OPnHiRH5+vo2NDfND8VpaWighlNLr 16/Dw8PRW1FR0c7VBw8ZomdiTklJj4xPCCNRgunPgqP8wiIJ9A/vEQMiol28fDg4OdEx9P+rzJzg HuEvcAYyWw+KjImIo8anZbr5+GFCsHq/7UlOa2vrDsarPZBRZ0uKddXW1oadgl1PiNvc3JyYSWgA xIYdjM+3Mt9FhW5E+Yez5R9fZ8CCMTEx6dwc8ZYK2JaUlDAL4Rb6+voyPgzbTqQdjBcrVFU/O0eE 5aSurk68mtTOAKKVs2fPIp4CwbVr1zp3gHg1w97evsuQBw8ezDGdk4NjOjv9QTDHNHYGcnxEdnbi 0fCnEgbOmDlz5cqVCJRsbW0jIyNTU1MPHDjQnTlLQM+Jhrqz7Y7oFQfnjIWLF3NMn/4N1TgBpaWl 9FuvL15gwn/rFJLv2LGD2CN1dXUwuCiB50ZMJl35v3mDaUeG+P6PoaEhQYwSaAlYTywS4nUqzDyx Wgig0WgohKXw8fEhSrA3YT4gmkePHt28eZP4liBYEWRsbGzMupmZmSh8/vz5vXv30AqcyaamJhDf v39fXFwcPjY8TOL7tKiOS+hGfX09tFAvpwIcoDqgkVatWjWTi5uPV1BIUFhIaJeSkjI2BTpMpVLL y8uhVRBWQL0ghTKBHjt+vBJ9A83atZ/dicLawKxiyGFhYdBI8B6lpaUlJCTgeFtZWtnZ2Tk4OMDB YByo2MKzmW/LFoE5cxZiU8+ePRuW7hvaUALA8GZtbTtDKMLCwszyiRMnFhcX19+5c6uurqiIfswV nuHFK1ceNDY2tbQ0NjXVMcrJZDIuQYEz3ndowPxHRUWtW7cOHdbT06urr7/T0PCouTk3N5dYRQi7 qmtqmh8/xmLA2Im23NzdUf3egwfY79ikiAGhJ2/fvdvy5Mnzly8Rfv7GWITWtrZEK1evXsUUwS6v WLEiJCSkpqaGeD9x5MiRUlJStfX1T1pbGx488PDwgKAxqK/6TxAsbHQeSx1aa9u27VoapnY2Lna2 Tm5uHpAsfBsM/OHDh1jq16/fgNHB0LALCgoKCgsLMWOlDChjwP79+5GiEKsiJSUFcxUdHZ2WlgYC VDx+/DiUQ1RUtIW5hZ6uoZ6usY6WKR+vAC8vL4zFjBkzvsd3zpcuXVpZVXW1rg7iDggIwDRCS0Nk EMf+w4dzMIyyslWMDwotXb782OnThyorK44dyy8pQSHxNA16ODUrq6yiAqip89kRLH0jo8OVlUdO nDh47BhhgGbNmXP01Knj1dWV1dVcjHeBl69cSbcO1dVoqPPrltb29ifPnj1ZU2Npa4uf0zk56xoa SsvL0atVnT5whD782Wn7T5w0CczRz6MnT3L93XeN4RphWqAu4JZgM2qoG4UGxYUEx0RGxmRmZl2/ dh3ODN2PffECOgRyr62tO3XqFHY91gMhd2wE4sOnAEIbYJ1AHUELYalA7WBfoDw0NMzFxc3FycPF ydfE2FFwxy4REREsdUTZhDr95rBhM09pxdG0nLziiiO1DU3vOjou3qzPyCukpqTHxNMiSJQt/B++ 87NHXLy88lRqNv0INA/fJ+W8YRPP2Ss3kzJzYyiJIxkOJDP8X7NufVZBcfq+gqT0LOIS/44dlTXn URIWTRrIuI1jYml98uzFI1U1mBC4dtitxJHvQyerU3PyUrPzVTXpr5pKychXnr2QnJnj/DEqZHmT YQsf/+kLVzPzi+NoyV84XviXAAdp0aJFAgIC0LrwFmSk5R3sfKMiEmKi4smk+LLS/fV19fB2XjO+ Wvue/m8TbYQvAVcBOwU2BSnEStC8ZAAyMEMwWFVVVXFxFD9ffx/vQF+fUE+3MGUlbXFxCWj+jRs3 fj9ZA4QlpHNKy0NjKUEx5KBockBUbGBErF9YlHdQuIaeIVun7/yoaOrEJqWFkuK1DT9zvbT0jXL2 V5CT05U0tbowF9wjQkpKC4mNs3b+8KRbU984ITM3kpqkqsk4ftynj6OnbxQ1OSohOSYxDeUR9DOr ieFkBEckdAPpqnX0p/8OHj60rDxySsY2wZ1fGI6qjl5iTn50QrJ+t8NmXwuITRBEYP5lZWUNDAxg UxTkVXy8okgxybHR1HgKLTMDocHJ+vrbkGNPrwATH69+9eoVpH/+/Hns+5iY2JDgsMCAsODAqMAA kq62uYSEpLy8PPY1jCAXF9d3/a8KK2f36ITUUHKCuYOL+F4FCVkFUSnZLfwC3Y8xWDm5xSSmR1CS Nmz+7JSmmZ0TOGQWH9Q0/OyeyYABA9KL9ofF0cIpNN5tAijp17+/e0AoJS0HfHi20pXGgIEDvYIj omlplLRsRXWt3aISu8QkhSVkdolIbBUQwmrZKSI+4veRYOUXHh2Xmp2Qlbdj156exoLN7uztT0rJ pKTnCOzskeyrAPOPCIWfn19FRQVCl5OT09TQD/Inx8WmxZGSE6iptISUjIzsw4ePnjlTU3urFpYd ihqeJFzEGzduXLp0+ciRI/l5BWQSJToqNiIiNiI8LjKcGhlGMzd1EhMTJz6lCwUOZcLJyfnN/fDO AAVLSs4gp2TGJKUvX8364SYBw4ePiKKmkFOzyClZ8xcu7nxJ18QcG/Ni/cPHz55hZohCBO+IU6jp +6JpKQFRpEGD6KfoR48ZCw7JuYWQ2ux59McKffv18wwMReHhmkvrP38zpXOwjCjG3T+YlJTx6HXH gcqTTB0OF9rT05N5IGfosGGhsdSs4oM1N+5gV9JLhg7955+MgCmfM2cOfHU4hBoaGnCwlZWVlZRU zE2tgwOiadSchPjMxIQMWkJaAjUF0k+kYQ1gJSRR45Pi4mhkUgKZRCPFJMaRUiPDE+1sPdRUtOBS YuXARd+yZcuSJUugwL/HHacuMGf+wvC4FK9gqO7IPxi3+nu66z5z9tzg6HhvUAZHjfvjM22zaMly 94Bw75DoVx0dMEzw92CCEU8FxyZ4BUc6evijFYKSnYMzipoOPv7hZOahNSUNXc/AiEPVV2HXXF1d EWgjnLl06RKq7xaV7PNRWDt2CXsGRQREUaAh4dM6OzsjJoLdjKFlKGvq9e9P/2Lk2HF/eIVEh8TS XjK+FOEXTtIxsezlrc6/BFjzefPmrVmzBt4+FDsCT8hdTU1NTk7ezMTCyd41KCAygZKRQstJScpJ TKAjVkJSQk5oMNnTzd/a0l5dVVNGRgZLBYoCfiAfHx92BwKuH/YXJLzbd5o6uBtZOytrGX/5UcVG 3u2gNLZxUdI26n51j6ScgZWjmb27tVuAvTf99q+lk7eJnauWsRUbx6dD6avWbw6hpFs6+2iZWBMv rQMmTJyMn4ZWzmb2nlauvtaufuZOXkY2LkY2rtt2iTJ7NWz4CHVDS0MbF3NHT8bt5RA7jyALZx9L Vz+xvUoEt99Hjjaxc0NdYzt3MydPsBLY8w2OZHcGDg4OhGkIADds2AC5w+bq6upC9PDh4dQpKirK MkBTQxNhJoSLLYy1oc4A+gNNUVFIGXEWdjQ0RudbCj8ANm7bvUtKaae0yvL1rF+aYMJ6vp2g3CWj unwdC8pBQ4YuXrlhp5SyjKaJnJa5nI6FoLji0jWbhw4f0Zlsp5SKspG9gp7V5h0incvHT5y6YetO MQVtKVVDGXVjMUWdzQLC7FxdvxY1ZvyEdbyCooo6exmtSKkbbxEUmzHn013xPn36Ll/PIyynKalq IKmqv0NcYfyE7/VnfLCz2OzLli3Dfufh4YGex4aF9LFzofCJb15B+pA4RLx9+3YYF5gDGGhIGWvm p7zy3PuHj316YQH79us/YtTY0eMnDhsxqsulP6awbxVXsYnI2qNkvFvJ+M8ZLD78NXjIsFHjJowa +8fAQV96Aj5w8JDRDLJBQ1jHWag+/PfRg/9BFPZVwM7Ozs3NjS2PDYtdD5mu/Aj4CXW9ePFiLIyZ M2d2+Y7TT4HePyL/MmX3S8wSzL+UtqWRR5SUlqWYuomApGr/AQO/XL33XeoN2Y+HyZMnf7/Y+X8c xv0x0cTJR8/GTdvCUUHLeNKvjz3+q2HMuPG7xCQEd4ts5OH7X3j98xf8F+D/ANXK5mENCmVuZHN0 cmVhbQ0KZW5kb2JqDQoyNiAwIG9iag0KPDwvVHlwZS9YT2JqZWN0L1N1YnR5cGUvSW1hZ2UvV2lk dGggMTY1L0hlaWdodCA2Ny9Db2xvclNwYWNlL0RldmljZUdyYXkvTWF0dGVbIDAgMCAwXSAvQml0 c1BlckNvbXBvbmVudCA4L0ludGVycG9sYXRlIGZhbHNlL0ZpbHRlci9GbGF0ZURlY29kZS9MZW5n dGggMzgxND4+DQpzdHJlYW0NCnicxVppWFNXGs5GViCBkEBYEkLYCcgSIICAoLIngApYqMUFFEVc 6oIoKtuoqHUXneLSmQodx9FqnVqBaltq1bYo6gMiIFAUBESsiIBAljkXErnZWJ6nA+8Pntyz3POe 73znO+/5LgjEODDnWNlYWbCMx2s3PTAwtnTxnRsSFh4hiAgPDZnj48g2ok43KQXoMaw8ZocLIAjX b970sRD6FRbgyqaTp5uaHBQjO3/AcF7O1w9apSPoabh5LEkoCPHi0HSnm94w6FZ+EYIF+++LpEp4 8e9kYaiHucH009Rn88MEMed6lRmOoCJNGOxmpkecXo40u7mCqBNd6ikCiH9IEs62oZKmkaKusUtY ZF6LRooQBq4sDHGgTR9LMtMnIvrSmBQhPEsNm2GoPU0cdc39hfH3x+UI9nqWwN1oeljqMP2Fqa0K bCSiof53PT19Q0MiCbxcdCrKnT4dK04ymSlM74Ez6W2v+uHi2cP7DhSeL6n4o6tfDKu8GuVqMA17 nOYuSO2GUWyrKM5KDA/w8XT38PabG7P2+I36Lpg5iyId9PBTzZFsE5bY/oGCuP324cQAVzsLUxpU acq2mcGP3nm99vUoy+MhHF3c1HIkMQMXVHwg0Hf/9KpgPpeio4UcbWLjEZ1XVvPhHHq/LcLGSA+A Qiaip4YklRf15QeOvU9vFJ0qyM/fvc2dgoJNxMZrxcXHg/JWb6+cOrQ/Pz8/b8McElLzm/86kNgh Kf1qgs3dmdrw8a2CDr5WbfQsGj6V/x+o7gsq1XCUSs45Yj80QhLtc9+otmnY7KIzFSSJrKAsdRyl 0v4tZnKHQ5G9igZUGohr8uaa4KdiuSlOMdXqSUpfzNMfYYCih/2qWj1UkRdmoTMVGwfPCNguD4E9 yjTuziQClkiseXKzGkOXbpppQpgSjyRZRf0oG7X9J2WvE5+y1UIgSU75b1U5SsrXexhip2RrI3S5 S2QGlJzMKlbWu71rjDF6vpeG1DnDjWAGHonCUwyZbDaTro0Zly+GSKHoUYiYyZPU5x+SDfpsZVDS FWU6f0Tbzn+gjqJUWh/p5DZLuHpP4dVr1745tmP+bB6bLHNQJM7EzX+Wr6ebC4CzHYOAROtyvAWb d4H4uyWSz5pkbMUzwm7KBt0bwOKl3JEoUfn9cJt6jtLBM1erO2HCo7uuZIOvKQ4aH228reNlZ+fT aghVlflshntKWYssPIiefx1ugh2XGQwEs4UyhTYUY02muGXUKlGRqMZ55XnA0Hbcmwq2Es7jF3jp Dwm7axSudq8zOVqTsSRzqWyFG3xoRIyBX/5LzRRks6kWj1Fb8xEDjdCJfgEv+/2Rco/eVYaTCAsE TqasX6E1CYfEGof+/d3YHN+V7O8eq/7lx3Q0PVUh8veptqr2mYSKItqelHWbT9dCI5B489hLg6rv HMWLL9LSXsGeRR33fr7fAbfUE39ty6NjzhNgIJEyYY4oAveCrJvvcFxGkWyXl2teTtGjvTHCYphT DpTvT01cfQzuyZIsFv+mckexsiPnmE54h6PwM76VvdoTMdwLTXbZVKOJY39ZeqB7Onz1ftvgZ2th LzgL3xf/9RA0KHSTdFXc+KVdoUh6xGLCTonEOn8vs5G7rBOG6rOrQz3HrqJkHjscTqDv0tqooNnB n/wDTrI8dLmC14qfnEhLWPmloq/v4Ux852AcZCTFfLkSx5rEXVVVPKBF/ZEFtlTrI/CFE7193QnQ pXBs3o7LUVjc57tD7c2d1ytcRge3MCce0FE28uX2xcmmhrPeoBBA5K+9szPIXJs4q05NnSJ+WnZR YXJfhhrj0QbxChrl1QrGxH0SaSHfOKGk4TMNSXTIVaPApZKKrT4MPIqcMGb8Gca3ax/BH7vTrcAx pPexQgB+FKU/YUOicQx5CFqhh0FB6tb7K/UhqDXFHIxFWzvGeSObzpF0hU3y9CM6EoE0SnsPLzzv NfH8Akabki7rdskUh0ZgDAUVUg0o9cQjkGbZ8KL+57WPlXHv6xU7FFz6O38dMHnrU/CywRybSZyL enSh7Fjs4Gpr4TipmtNqQ59ZYpDm+fCi9sKNaWlpa9Zt3JIhx5ZVUcEn4G3E+7jgcMF634UXvlpp MoljUY/Fk+0SUTBd3/WwhgTqMLqXG6KZmfBI/2w9z9bWzjVy76kzMpw+vt55tkIof7OOCZxdO+o5 vLBq3sRdEoHQMXcpl3XcywsvVUlDK6AhXM9kLTza/LnJlmxgHVkCb3SeK1QI5Y0f0cA+piYrHOBf +0wm5aXN5h+UdXyZPW50+YFvGl8JL6grSNxapGCj7jTnZQoBoCwQuKSSmwzl2U5KUJr4xMiPApV7 mArEx72jzqjRNKPoKw5z2Q4PAJLPHIFLYtyuw1t1rTad1AWOylt4R+OQPcqK913W4twx1KSko2gJ l38eXvR2Awu4JCG4Hl74ZMHkvl1RHBbs0hD6xHWXbynfedr3PtRIcbDt+u75tjQvBVVeHwe5pE40 XN5J/+MzyVyxWcin9VJ1GCjfmbhVhdKzD1NQmNrAm6afi7IT+ExtkvPnVc87ZHhRc9QLuCRCN7C0 7oW88PmDFKtJuSQCQeOvvaLOlN0XV/KtffNeqakarn50+37N8/b2jo721tpHJcWHtiSGuJlTsCis 2dzUrDyAXIDtKYGmkAQnWkWvz86VISORR9Vhubrb6U3YMVGumU/UkGj9PJ6rT2SEn1N/SA6V7U1J XZORBcbMzly/PDbY25FN14aElBYzIi1j27ZtGesWhXi52BgRISZaZJaDq5sMThyqtm1xY1PlTI3p YiSOamKij5NrEIxxcoMqB1HVXoGlDhpJ4CSpPyarcoKdLGydXMCYLjPsLc3oZIIsO4D3qns/AKG3 +fMABlFr2FpIDI5IkoOIx1CiOsGdMVLjJ1UtTs6FrzYzRq7xSIJNuhqFO/BjxixT4rDe4OV0quHY c3a+CRmNJQyPTMBhUKO6S/+T0VBW6aneVkjDjaC2JoKiyZDkBSAu3nQY9lykjsdpNfnTd99tDKSP 2BpjGPZP1QUX/bTVlab+/SjW30BEkIiHA9VQuinNyp5lYGJnro1CEoydvPh2dCwSgTJddaeu6piX DhJrYOfJ58pySmgyh+fjbknGaHuclEBfOdgEKKMX/LOaPdN3fU88j0UfmROes0z1G1Tn6blmGqyA cb0GOLZU3K2Fgv7lWWvu3ruacLruAkebFfbF47bWylwXXSTGalftHxVLLAh67tkVLW1V+1x1gJrT dki90fSyuTzR2vVaB/SSqiNMIE3cKtU63ODpOGGQr6sdh23KtuIlnFIRwX2Z9poEAiEY3BwH/7V2 xT7oOle69Ffge0ADX/f1KRhRveIfvXXwfBBLX8cxTGMfDBtJUuJGQBuEloysWXe+PD1ewQMXBZsV F249qH78uK7xxZt+uE17v4sUCAThEKIWZf6nXqFysKNsEVuT+Kd88iew9Gae45IH0M1hK/BoSLV8 sbT8Q/9iOz0ow/Es1iYJ8neoWrzDlCZokjf4br/sx3U+2EMGzsJlqUARpm3fe76yRVECDTRe3S4U CIQFt18qHoRvHxYudtOUhEaa5gGXrFnjO/cQsH/fvqPDR9bAq4M3oKk3N0IZ0M5oq41AplctnPdY Kn1f//sLYIFf/OYAe0v+bGjuFVem59SDIftb72fYA0cl0ljWtsMIiM0ufarujqgMSVvp9nBnHU1J RgwX+tLb9vC3Wmjpft9aCnVpuXLgOFjArsv791wCCmkoc1YRKP52MbheDT0s/nspUH9Ny46Dho3n duWfubApPAESf9VHl/sYQvNGYbSwI+D4pF6qHl8HDT79d5IbEx5yFIHzvT06n8acVMgxW48lLgE+ OHQtydf/UyAHRfkLwV4cPJoG1nywvbmpFZi1OQe4cm9hrJdX4BxXayGoF/0z0pZGUHo9yyW2oKJD bU53dNie6sIYLkMDQQik0eRF370cwfI2aGihUwK4mnVlu+gzEppAhNu6GmzersytsHTBvcPgoTnN mqxLNdClLgD032yyJmJUzk1Th7mZZY1vxlBi/S03c8JsDcfgiNBf/Cf0jfftm/bKs2t8HVcBH2xY YWG0CJR2rmPhLLaBZa9dtRP8rUvNBe7V09HS0tr+sqng6CB0rzTAURm6aGoyYPw0nq72aLfyjDtw q7lXg3IbaLtzKN6DoyGIjwDF3A22X/s3p47krgx1oFtBu+hWCMXgY6BTxJcifTeBe95QYdwxMZRZ 3Q6Wue36l0X/ffTVtvi899AH/8DZud8H0Zk7AOPKdbMM1X5+MbOfmXiioqN3SIWnqP9lxcnF3nYm Y1EE8WI4lN9InuPtam1IwjtfAU9FbnhK2D3In2uqgIVE95IjLoLi4rBVwLziZw/r3kmrYnnJUBbm 9cOnYuljX4djYPze1mo3DTlMFtd/6cGS2s53olG9KBH1dT4pObjMn2s2NkUQyoOegqiyh0cjk3Bo JH420Ff9O6wwROc8+Z4U3U/3EYIQOrDLI6JEPkRNMDOwWO5nTQLnw8M/qv013tbYjvzQ5fsuVz7r 6ul7P/C+r+dVc+Xl/OXhXlzmeBTBvS74j4HBpkWMEW8izWkYGGxMMEJhjIVFr6A9+b7z+ib/GSvB 2dO10pK7+s47QFP0pmKdkx5n2Y894EHc/WgLzy6lVSyVdJ9xH+tKyeF6zFm4OutAwdlzX5z4bGda fBDPnm00PkVAa8aagpOfepBHIhRxRtrxE+vddZFIkuW83Zd/e3Drq92L+B5bfwVsHkTSqe4pJ2/e ++1awRo/IzxlxtJj31feLyv8NMDEaGbmN3fLDsRYjPPvCeY2jq4efG8/H767C9eaOdErCZbm6Ofn SMPKn7h+flzoCa3N8oxauuKTCE8OewmUFBo4yiNhqbYBHyUnxc12NCKgtPSs/WOTkhfOcWIQiQz3 qEUxfhzdiX23NB4rJqoBCkc2MNDFolSeUDiKsYWluRGZwNoD7aHyBKYWEkM0YHI4ZgYkoJeRaCLV jMNh0khaSBROz5hlakAc/yPbXw1wumHQKASaubm+/fm3q510IQZINCiUU4E9IFFojYfaFABNm5ma nRHnrD+xT4z/A1P+MbQNCmVuZHN0cmVhbQ0KZW5kb2JqDQoyNyAwIG9iag0KPDwvVHlwZS9FeHRH U3RhdGUvQk0vTm9ybWFsL2NhIDAuNTAxOTY+Pg0KZW5kb2JqDQoyOCAwIG9iag0KPDwvRnVuY3Rp b25UeXBlIDAvU2l6ZVsgMjU2XSAvRGVjb2RlWyAwIDEgMCAxIDAgMV0gL1JhbmdlWyAwIDEgMCAx IDAgMV0gL0JpdHNQZXJTYW1wbGUgOC9Eb21haW5bIDAgMV0gL0VuY29kZVsgMCAyNTVdIC9PcmRl ciAxL0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGggNDU3Pj4NCnN0cmVhbQ0KeJyFwodS2gAABuDn srV72zpREVEEkaGAoBDCCjMQ9h5hC4iADK1272Xbx+of4513rXf97hubNI6dv4ZTfBP/+jR3nEuM z1y8gbPETa6Zf2sOSa6AvC0g7+C8Be/yF6z3zt9fRNsDId/+cIn7SIQOfLyM1BMxd0LsnFhxPl1F 1zOUuCYl7qk19ExLuTMy7yyu+3BO7hPIacEGPa/w44IygIuqgFDFCNXMkjoo2gyKtkLLqAmLNeEV bQRXdVGUbMfW9DGpPi41xGWGhGwnsb6bRLkxtWFKKUxpBZFWEhmlOasis2oyp7bkNq35LbQVNPaC 1s5qHazOUdRRpW2qpHeW9a6ywV3BHU9111M1emtGX92E9B6B/oY50CADTZJpWpiWNdiyhvZtobYt 3LZj5MAR6VDRDhXrOjHec2Hi0I3JvgdTA2964EsPkc6M6OzIj7mjAPeYyR8zhedB7kmQPQmxp6Hi aRhLLyJYfhnFCr6KYfV1HGv4JoH1t0ncw3cpbOD7NDbxQwZb+DGL+/xPuTb/cx4P+F8K2OF/ZbuX i91vxd7FUu879/Byuf/jr5X+WWXwz+FZdfjzyrXhr9roP+uj3/WjK/4BqNyYIQ0KZW5kc3RyZWFt DQplbmRvYmoNCjI5IDAgb2JqDQo8PC9QYXR0ZXJuVHlwZSAyL1NoYWRpbmc8PC9Db2xvclNwYWNl L0RldmljZVJHQi9TaGFkaW5nVHlwZSAyL0Nvb3Jkc1sgMCA0NjggNzIwIDQ2OF0gL0V4dGVuZFsg dHJ1ZSB0cnVlXSAvRnVuY3Rpb24gMjggMCBSPj4+Pg0KZW5kb2JqDQozMCAwIG9iag0KPDwvVHlw ZS9Gb250L1N1YnR5cGUvVHlwZTAvQmFzZUZvbnQvQUJDREVFK0NhbGlicmkvRW5jb2RpbmcvSWRl bnRpdHktSC9EZXNjZW5kYW50Rm9udHMgMzEgMCBSL1RvVW5pY29kZSA1NTQgMCBSPj4NCmVuZG9i ag0KMzEgMCBvYmoNClsgMzIgMCBSXSANCmVuZG9iag0KMzIgMCBvYmoNCjw8L0Jhc2VGb250L0FC Q0RFRStDYWxpYnJpL1N1YnR5cGUvQ0lERm9udFR5cGUyL1R5cGUvRm9udC9DSURUb0dJRE1hcC9J ZGVudGl0eS9EVyAxMDAwL0NJRFN5c3RlbUluZm8gMzMgMCBSL0ZvbnREZXNjcmlwdG9yIDM0IDAg Ui9XIDU1NiAwIFI+Pg0KZW5kb2JqDQozMyAwIG9iag0KPDwvT3JkZXJpbmcoSWRlbnRpdHkpIC9S ZWdpc3RyeShBZG9iZSkgL1N1cHBsZW1lbnQgMD4+DQplbmRvYmoNCjM0IDAgb2JqDQo8PC9UeXBl L0ZvbnREZXNjcmlwdG9yL0ZvbnROYW1lL0FCQ0RFRStDYWxpYnJpL0ZsYWdzIDMyL0l0YWxpY0Fu Z2xlIDAvQXNjZW50IDc1MC9EZXNjZW50IC0yNTAvQ2FwSGVpZ2h0IDc1MC9BdmdXaWR0aCA1MjEv TWF4V2lkdGggMTc0My9Gb250V2VpZ2h0IDQwMC9YSGVpZ2h0IDI1MC9TdGVtViA1Mi9Gb250QkJv eFsgLTUwMyAtMjUwIDEyNDAgNzUwXSAvRm9udEZpbGUyIDU1NSAwIFI+Pg0KZW5kb2JqDQozNSAw IG9iag0KPDwvVHlwZS9QYWdlL1BhcmVudCAyIDAgUi9SZXNvdXJjZXM8PC9YT2JqZWN0PDwvSW1h Z2UzNyAzNyAwIFI+Pi9FeHRHU3RhdGU8PC9HUzI3IDI3IDAgUi9HUzI0IDI0IDAgUi9HUzEzIDEz IDAgUj4+L1BhdHRlcm48PC9QNDAgNDAgMCBSPj4vRm9udDw8L0YzIDMwIDAgUi9GMSAxMSAwIFIv RjIgMTQgMCBSPj4vUHJvY1NldFsvUERGL1RleHQvSW1hZ2VCL0ltYWdlQy9JbWFnZUldID4+L01l ZGlhQm94WyAwIDAgNzIwIDU0MF0gL0NvbnRlbnRzIDM2IDAgUi9Hcm91cDw8L1R5cGUvR3JvdXAv Uy9UcmFuc3BhcmVuY3kvQ1MvRGV2aWNlUkdCPj4vVGFicy9TL1N0cnVjdFBhcmVudHMgMz4+DQpl bmRvYmoNCjM2IDAgb2JqDQo8PC9GaWx0ZXIvRmxhdGVEZWNvZGUvTGVuZ3RoIDk1MT4+DQpzdHJl YW0NCnicnVZbb9pKEH5H4j/Mo12VZe9rS1EecjlVjoSUqijnIemDYxZiBWxqG6r213fWmBTbbE7V J7A93zeXb3ZmYXoPFxfT2fXdDdDLS7i6uYZv4xEFSiiljHNqwHAKSlIo7Xj03wfIxyMGqzcbSjWj smO0/DAefR6P4HZ2DXDigP12MGmxKtam9RUJxs754oLEMaA30IYwGoOKFaEMONFaM0g349H0bpOs rDBwU8A5x7x1PP30hRtYVW0GLI5IxB1tbCIQDH8FiIgRo97yGHCJQZW4lEyeidx5k4236X1S17bM Ia2QCo2qNHdwyQ3hDRKdaqrfrZ5sHV/NkfAfAZjJfOkycaVhoDEWiVnomLAY5ptT/9Rli49MtI+f xqPHCyrM1eVXmP87Ht0i54GX9XkjjuXgp7yPwe3e5jWEMkhfkjy36wpCJoKktBCqYJuUSdilPXIJ KUmku1wTn60SBMvasd1nZb1L1tlPu0Dn4EFKI0g/4izH+iOm3G1DEdSVB6ow2zjqQk/dDERRA1EI 9sNZYQQlvOX0l36APpb/BB3ce6KPNdGmZ1tazHefFeGEB7tq/cNXNE4ZUaqLXWebLJxgudpyy6Au wGb1i+MsITQBw3DxP4RRUJQgaYwPGsL40BgIaHrjT3uMx4ZER+db1Et4NWZcEcO6iEWxcVkmWe7N EWXtgd5VV/fV7WoTUyIYhq1xFLHfyspzynaROMYI1uAUGdwUGwzdmzA6w7HUQVDACuXWOo0WFVT4 ZPdYNleENdjDIZ0oJ4Z7155UFSxRK5uk7t0LrHa2qs9qJAfNeAxbCIID8xDEw8w1xlNDmtv6e+FO 2et0kblwXn3pCGSXusv0nKSvNl/4zqZkmvDoFALNFtEwTx+Dj95pgIdKdTzha4f4Zjc7HybCndOL zssfxUT0bG2d+gYMi4ke5KBkExF5Cn0wgXOJn0ni3fY1f9S+LEZR+d+07ykyuC+TtM5S14vYfCFT zfhotkSxhLrAvqvdB18/COy2LmO+2zw3vV0CMmA3PcwqJIJQ46opdvkC3EdB0QP10GoWEa67tL6F c0zKUCKPtqohd76fgkUTyxY7NMtXUOTwgCnNIC3yZbbalUmdFb7BI3VEcAV0qL1aS6NIz/ZdlaOO ymeXSLuCGHaR+/L/nHGPU2hci0NOXDZS6eOqPNypmrtFcLfZlsXeYvWcSsbdGPB/Phg0b/pTQ0SH 7TG4PlwuvAdPRET3IF/SZN3MuudsndU/BlONn8tEuRNsukSD6vwCl8JY1A0KZW5kc3RyZWFtDQpl bmRvYmoNCjM3IDAgb2JqDQo8PC9UeXBlL1hPYmplY3QvU3VidHlwZS9JbWFnZS9XaWR0aCAxNjUv SGVpZ2h0IDY3L0NvbG9yU3BhY2UvRGV2aWNlUkdCL0JpdHNQZXJDb21wb25lbnQgOC9JbnRlcnBv bGF0ZSBmYWxzZS9TTWFzayAzOCAwIFIvRmlsdGVyL0ZsYXRlRGVjb2RlL0xlbmd0aCA5OTE3Pj4N CnN0cmVhbQ0KeJztXQVcVNn3X7vXXnMRRMTubhFEEQw6pLu7u7u7ZhiGoVsaVDAxQOwWMFARULED +H9nno4Ig4u7xu+/6/mcz/3cue/cc+Pce+K9+9789tsv+AW/4Bf8I5g3d97CBYuXLF4yevTon92X X/AtoW/fvps2bbKzs8/IyKyuqn737t3bt++etLy7d+dx6xPk36Lk3r2GQxWHgoKCJSUlJ0+e/LO7 /Au+GgYMGCAkJJSelv7y5av3799Dps+fv7h//8Hly1eOHzuelZkbE03O21d46tTpq1euPnjw8MWL F+/oAMr3Z8+eNzMz/yX3/xcwcOBAfT39pkfNbW3tb968bW5+fPXK9UMVR7C7KRRKSEiou7u7ra2t mZmZvb29t7d3ZGRkIi0xNzf32LHK69dvPn78FLXev29re9+empLGycn5swf0C3qEvXv33rxxq+19 x5s37yC4O3fuXr169cyZM8eOHSssLExJSYmJifHz83NycrKxsXF1dQ0MDIyNjUV5QUFBRUXF6dOn sf2hBKAKIPH2to73796HhoZOmDDhZ4/sF3wGmzfzVFWdef++/e2bd8+fvXz8+ElLy+Pm5ub79+/f vHkTcjzDgNLS0sxM+jaHlJHSaLTi4uLjx4+fP3++urr67Nmzt27damxsfPbsGTR7e3sHAfjp6Og4 ePDgnz3KX0AHCzOrt2/aXr9+2/r02eOWJ8+fPYcP1t7eDosM2Z0/f2H//v0BAQF6enqysrK7du3i 4+Nbv349Dw/Pjh07xMTEFBUVTUxM4uPjDx8+XFdX//Tp01evXrW1tXV0hvaOU6dO/fnnnz97rP9p wI6jUpOftb588uTZ/fsPHzU+ev78OYTz5s2bu3fvYsNiL5PJ5ODgYGxPQ0NDeXn5PXv2bN26lZ9/ 2/btAjt37pSQkFBTU4O4XVxcgoKCQFxWVgaFgN39mbTbOiD/e3cbVq9e/bMH/R+FKVOmHqo43tLS +vBB462btdDb2M4Q9+3bt6G9Iej09PTk5GRIMCw03MrSTk5WUVJSWlJCEntcWVkZmxq2Xlp6r4yM nJKiqouLR2wsCeo9Ozu7qKgI5r6hoYGQNXY63Wt/3wZj8erFG3k5hZ899P8czOKeXXPmUuPDprra 25cuXa6vpyvhO3fuQNCJDIADlpGRERQYoqGhA/mqq6tra2sjhaDl5ORQgp2Ofa2lpaWvr4/dDVWv oKBgZGialJQCg15SUoK0srIS5gChHNT7yxcvX7+G2nj7+lWbnY3jz56A/xBM+GPC0SOnbtffvXjx MkzqlStXsKOrqqrS0tKio6Pj4uKwSSPCI+Rk5SBciHX37t2bN2+GHl7JgOUMWLFiBfET5Vu2bAEN iCF6LAlNTc2cnJz8/HykWVlZcOSgN1paWhobHzU3t7S2vnjc8lJZUf1nT8N/AoYMGZqetu/69VvV 1TWInmCgIQ54WYiYYHzDwsIiI6KhpbF/4YZBjhDrokWLZs+ePX369KlTp44fP74zN5RwcHBwc3Mv XLhw2bJloEddWHklJSUdHR3IGiuHbtBLy5qamuAP1NXVPbj/kKFVHm7fJvSzJuG/A1ZWjtXV5w7s P5iUlJSbm4s9mJWZZWZmZmVl5eDgYGRoBn9bSEho3bp1CxYs4OLimjJlSu+ZQ+6E0KHwofzFxcVj oumhOhw56I2LFy+ePHny6NFjWGBVp2uKCysmTJj4/Ub6C/i2bC8qOpCfX+jp6WlqampsbAybu5UB iLDWrIGQ10Fvb9y4ce3atVDUSxmwZMkSpH379u1NE8OGDYPQoRNERUVVVVVRUUZGRkREBEsIP93d 3e3t7e3s7L29fRzsnNRUtZZ8hKWfA0qgN773hPyLYfjwEZHh5PLyCnt7h6DQ0Cu1tR1fA3aOX+Ff sbGxQehz586lUqlf1Qrgen39tfr6tJycCRN/7f2/D0oKWkWFpWlp6RA3tjM1MfF6Xe3VWzfPXblc ff7c6XNnq86dRaY7Xrp+DVKAg716zZreN8fOzn7mzBlUvHLzRneeaOs0A5FHBy7fuI7OXK+vBfGl G9dgXAYMGPD9puJfD5MmTvH1CSkpLvP394cx1dDQgFE+evz4/UePGhob6+7evV5be+3WrRt1dSwR /jRdcDdujB07tjfN8fPzNzc3o8qt27fBuQs3oi2kuHq7oQF9eNDUdL+x8U5DQ01NzbZt2773bPzr QWSPTFRkbHh4hK+vb2BgoKurKyzjrFmzbtbWNrY0P33xHNj89EnTk8ctrU+Bj5+1Ekj8RDmhaRFb /WVb8PoI4ofNTWAOtgRDghWzFbTY+vIFyvHzwaNG+O2FhYXQCd9/Mv7lMG7seAtzh4z0TEjZ29sb G1xLS2vNmjUTJ07EVnrY9Ohx69OXb9+00e9ts0D6nbGOjrftH26D6+rq9tQQ/DSsB4Ls2csXr9+/ I+ow+TB5vm17/+LNq1Yss+fPmltaEKBhHQ4dOvRHTsu/Fdav2+Lp4RsZGe3s7Axxh4WGIVbi4eFZ tmQ5TCQM5ZMnT953eajRM7x58wZuc/dWEJtfv3699y5ZW3v769evGxsbL1++jGj9x0/LvxL69Omj KK8eE0O2tbVzcnJCCGxoaIhoa/fuPfCcOTk5EWHFxcU9e/asnfnM8q/g6tWrv//+e+dWEGqBw1fI uq3txYsXDQ0Nhw4dWrRo0ZTJbH9OnfazpujfBJMmTdXRNoqJITk4OEKZBwQEYF9v2rRp+zZBzDMs +ODBg0eOHFleXo75773EExMTCf5YLYjiey/oDoaTD30CN41CoYwbN27rVn7BHTt5eLZ36TlsDQJw Pj4+BOxqDEBm7dq1c+bM+WGzN2PGDOY9AWQQXf6wpv8eLF28ytjI3M8vwNHREcrczc0NWxuB2LRp 7FC/8LQJi8nFxQVVDO3ae4nr6OiMHz9+//79vRc0mMMWPHr0qLa21sjIaMyYMegJQ9vwcs2Yi2BB SkoqIiLi1KlTIPsyK/Q2ISEBffjyfb9ly5ad6gTJyckRrEBI6NMd3dGjR+vp6ZWVlWFNdm/35cuX JSUlCgoKvbzv9INBUEDExpp+I4vQ5JgfbG1paZlJkyaxsbENHz6cSQmDDkG8ffu2l7KDROBifZWs MVcPHjyoqqqChkGLEhIS8BWRR6/OnTvXe1ZdABZh3bp1LIevra3dm46BDMTz588nk8noZG8aRYf/ 1w7jwXDvlVFxdnJzZGhyhGCYXoh7h4AQNiYUaRdnWF9f//Hjx1C2f3vmewIYaxj3O3fuwHXHMhs7 Fo2Pg4a0s7NjOb0QAapg7dEfnr58iaWFXn1Z80RHRw8ZMqTLDEAD9KZ7/Pz8iB//UqV0gZs3b44a NerHifOvYMSIkYoKGr4+9POE7u7uMNybGTBtGgfsNeKmQYMGdakSFRXV2tra9fQRK2jvaG9r/wsy ELx+8xrYwoi20AeixWls0yDrixcvEmRv3r4BDdK39JPs9KNTMCuEzofffunSpRs3bkAtQO7tdJG3 E02/b3sPYlREhuBz7NixLhK/desW0Q0C6YcsPuK79+/QIlERer776Jhsu5ej3Q7GmsTE/jhx/hXA 490ro+Tm5gGTDYcKsS1kDaXdr18/yBpRGDJdqkC9FxQW3G2496i5icDmxy2dsamluRHFjAxxlSDD z875+w8f3Ll3t7a+7lZd7dVrVy9euigmJgb+/fv3RwolQ2xqNFR/5zYo791vQJWHjxoJhHALCwsF BAQIc4NNxMvLC6EwGyK68aDxYcOD+6gOJMTh5+/PHMvUP/8EDVGFQOaggER1FD5++gQpGkVnbt+9 A1bgSYyFWZFAZrvoKurevd9w7dq1HyjPvwDO6dxysiqenl6QNSJuCB2GUlSUPu0DBw7sydmYPGXK /oqKc5cvV58/X3Px4tlLl7rgmQsXcAlIZJASZEiJKtXnzlVWVR09caL8yJHSgweTU1O5Z836jWFc kC5YuBCybn316kRV1Ynq6tM1NUQtAs8yUlpy8pCPhoaoBZgzd+75K1eIDnzW6LlzJ6urT505U9/Q UHX27KSPLzXwbt36sLkZNERvmcisDgT9CUZXDx46VHzgAIVGy8jJwc8z588TzAliJjLHi4pV585d vHoVDuf3lmMvYRb3fHk5FR9vX8jaz88P5ht7REFBkbjKnMbusHLVqgMVh8qPHD107Pjh45XdEeVM 7FxYfuQYMgcPHykq259bWJSdl2/n6DRixAgmZwTs0OpNT5+VVRw6cOhwxVE6PVJURHqk8gSw+tyF 6dOns+xhXmERWgEls2kiRfX9FYcOosPHKzds2kQQa+vqNrY8xaXOve2CpeUVBSWl6Tm5OwSFmJ7M kqXL0Lcuo2OOEa0TeOTEyZNVZyb+zzy5mztn0d69ShC3v79/UFAQAjGEsWpqvTo4JC4lXXSgoqDs QH7p/l5iXklZXnEp0tyiktTM7KT0TFEJyS5s9YyMX3V05BQUg4Zepbh0X1EpUqJ6fsn+89duZucX 9dSrk+cuFJQeQJXOCFY5hcXIFB0oLyk/xMPLSxB7BwQdPV2N8h67WlyalrMvikzhnDGDqMJcYNb2 DmjoSyMtKQMBmuvuH/4smDN7kexeJU8Pr2AGYHcjztXQ0Ohldf+wiNTcvOTs3N5jUlYOLTM7IT0z JJo0b+GiLgwnT5168MRp8EzMyAYx0kSsiqwcoiLyafvyL9yqb2xsPM2AU58DSu60PI1PTe+OlOTU uORUZFJy9m3YRI/yBgwcSE3PBEOwZdlPlKMDlNS0TTxbuo9dTEr6C2Mnup2QkRVOjv9nIvqWMHPG PBlpBXc3j7CwsPDwcB8fH/hIKiqqf1kRKzY+Pr75XQclNYOUlNp7JCenkZLS7Fw8xrB6VCq5V+5I 9fnohKTYxJSYhGSkzIpECTIxtGRycnpSdl56QXF28f6c0gNIgRmFJdT07ChqYhg5PiIuoQuGx1FD YuLCSPFgvmT5CrTFwTkDfGJoKcDu/UQhWoymJfuHR7E0aiJS0plFpSzHSO8qvXpqVHyiilaPD4x+ GMAHI4bAwT5TRprumSO8QliKDQ5fV15e/svVOTk5z5w586Stg5ScHklJjIxP6iVGUZNJyRlIB/Xw ipC5nQMlNQs8w+MSunKmJEZQaEhDydTgGHJwTFwoKR5kEQziMBI1jExFJiSWEhJDwaXOiELQB0bG BkTEhJIoM2bSb3XybOUvOlLJoiFGW/Ty+CTwVNc1YNlVdT2DtIIS1sNndBWIpleuYX1750cCwisi vJ00caqYqIy1tS2JRIqLiyOTyYIMGDp0WE91d+zY8eTJk9NX6khJGdEJqcDYxLReIikpvaD8WMv7 DmVNHZbMIylJpMR0UMbQWLBFWygPj6MFRpJ8QyP9wqIDIkiBkeSASLJfeDQQmcBuGBRFR1D6hkR6 BYWHxiYQLr2ajn5e+fFoakr3tlDCGFc62uLdtoNlV32CIhMy9vXUT6RRCSlgzlKJ/WBAbEuEq8OH /y4qvFdXRx+CplKpqampQkJCu3bt4uHhZVnRwcEBoWvZ8WpySiY1Yx+BCZl5H3Ffp8LO5Z8wKafw 7tO391rfrt2wqQvzwYMHJ2YVEAxZcqBl5SVlFypqaE9j52DjmD7taxG12NnZ2D8caAyIImcUHfi8 /58NBNKMT8tmn87iRujUP9mSc4toWfksh0l0Pi4t2zcs6luK7R/A6NGjR44c2ee3PruEJOXllChx lMTExLS0NFlZ2T179piYmHehR/BYWFgIWWcUHKCkZGMqknMKEzPzMf/IIIWk8BMpM09c6oz0S5n5 uaWH6WvmWNWkKVM7NzFs+HCwpaRmE3WZ3Jh80vJKMovKdwqLfYPhjxmTkluckltE8O+CRLu0jLwo SgrLmw+beLcePXsFZMSgulbPzE/OKUpI36eha/jPu/pNAOIm3rjcsJ5fQlwmPDyCRqMlJSVh/woL C5uZfSbupUuXIha+/uBpLC0tigrHJpOSmkNOzoxLyUImLiUbGSKPQlxl/CQK4dnmMBE/QYBMdkkF JO4ZEDZw4KebtHAnQmJhjhNjEtIIMoLtR8xO3VcKFJGQ+Y1VxD1nzpwlPQPxgJJr5kyCeNnK1bll R5ld6ozMzsfQ0g1MrVjOnpKG9v7KM0QPe6iejerrNrFw6X8KjBgxgp2dfejQobO5F0qIy7q6uEHc ycnJ2OPi4uLS0tIzZ84iKJWVlV++fJlffjwgAqYwLiSWGkqi0dPYhDByIvLI0JFEC4qmgIYg+1DI oGHiB2J69YT0wgOPXnXIq2p27pWytr5XcIRvWAyYgBvR1oeKJBopKavmxn1LB7fuw4F7+eWb8yl5 JeCzcQsfQS8iKVNQcSI4hkr05zOMhb9HDYqm+keQ+LYLspw9R09/CLSn6igPjIoLio77Y+Kkbyq0 vw+w3RwcHGxsbOPGThAXk9fU1E5KSk5JScnJycHUSUhIaGnpDBw4MDIy8nlHRwgpydknxMUvzD0w 0iMoyj0wAqlHcBQzj3JcBY2jV6CjV5CTdzB+guATJRMZxESaVXastPLcitXrmb2aNp3T1s3X3sPf wTPQ0TvIySfY2Zferpt/uFtABLilFdLVgr+/P3Yr6DEEfn7+ffv2vevoiKJlgoDJHPSu/mGu/uEu fqHoDxhqGVkwHwFom1gGRFNRDv4s0CfEyTvIxTeUaeg7A4yOT2isq18Y0b3uiHJwtnRksSx/IkyZ MmXBggXDhg0TFBCXlpJFLJbBAE9Pz40bNy5cuPDEiROl1ddtPQItnL2t3fyQsXEPACLTOY/U0tnH 3NHLzNHTxM7d1N7DDOjoZe3mT1wl6JlIVATaeQcXn7wUEEObMOnTCYSFy1YY2riY2LmZ2rubOYCP JxDMzZ28zOk8/WJTC1502rbIU7LLHH1CCc4gAFq5+lm5+Fq6+Fg4eZnYexjbuclr6o/4eJ4Kniou WTp7d27iM3TwMHfAWDxYRtwzZ89zCYgydfAw7akuUnvPXeL/W+frxo4dS7zNt3DBCmkpBUsLq8zM TKh0Z2dnXj6+m83NQdR9upauupYu+tbuhrZe+jYeBkBbTzoy8vRCa3cdCxctMyctU0c1I1tlPYtZ 8xat2bRVy9RJz8qFICMomfihuq0n6pq7BOWduK5maDNo8Ic7jVxcXDNmzVXQNlE1tFY3ttM0tdcy ddAk0MRBy8wR/SEYEkyIjJ6VG8p1zJ11LJy1zZ00TR01TOzBVs3ARk7TZNGyNZ0FN3HKnxiXpok9 HZnMO6GGiYO6kd1OcTmW87aWZ5uOpbPGl6rbaxjbzVu84kdIsdcwatSouXPnrl69euLEydKSynJy SiEhIbq6ulZubofq3hq5hCjoWSvo2ygbOSgbOygZ2SNVMXZESi9hFCoa2MrrWcvpWu7VMpfRMN0t qzl+In2f9h8wQEhaVU7XCgSd6zKRKEQGqaFzUGxhFd9uaVQUF5fctm0bnIphw39fvp5PREFbQsVQ Us1YWt1EWsNEWtNURtNMVtsCvVIytCOQ3gddK1l0QNNUSt1EUs1IQsVATElPQlmfd6fkdO55ffv1 7zLw2QtXSKkZiasYSPSI+uAzf/lalvPGt0tKQtXwi9UN9mqajRr7x/eW4NcCnPMNGzZApa9ds4V/ q+DiJct9E/ODs07t1XMQUzWV0LCQ0rKS0rSS1LSkZ7SskX7Ia1qJq5uDRlTFWFjRYLe83gYBsSFD P510GjthioiykZiKiaSG5adadA5M/FCI1MA1wj48a9ailQICAlJSUpaWlhoaGsuXLx8wcNA0rrkL Vmxat11sm7iKkIymoIymkIzWLlmd3XJ6uxX0kO7cq7NzrzZxSUBKYzXfLu5FKydMmdZ/4EBmZ7ro 5PGT/pzGNW8a15yecS479/yhI0aynDQ2rjlsM+jYU3V2rrkc3Au+k8j+CYwfP554A3f0qDHTuJfE lF+3DE4VVTcTVjERVTMX17T8iFZIxTToiLyYuoWIqukeZWNhZaOd8vpC8roLV23pHp/OXb5hj5KR qJoZUZFRlwWKaViAp3V4loZd4PjJbJKSktR4KoVC0dHRWbFi5XR2rn59PwRrg4cMGzlm/CR2LmK2 mThlOjfKR47pupv6MOBHzOP/H5g2bdr8+fO3ikhlnH+u4xoppm4urmEhid2nYyOlY8tAm49I/4lL IIAQRVVNhZWNdyrocXDPZ8kZbjCfmDIYSmhafaxu8znaMnnKGjr5pBzFQtq1RyQuLi4pKUlJSUlU WEJQQGTu3HmAcePG9eZJYm9EjIhjGAOGfwSWx7R62VZ36EKmpqa2jwHObm4//WEoAnAnf/+yG68M XIIVjRyVTZ1VzFyRKpk4Ie2MKFE0dlQwtJM3sJXVs5bRttgjrz12wpdCy3ETJ8vq2cgb2KFiF26d 2RKNGrmFU8svC8mo6ujqampqKimqKitpb9zAB+9i1qxZXc6E9DS3vYGsrKzmbnDnzp28vLxNH08+ fEOgJCaevXz5wpUrBSUl30PbbN68GbGzgoIC7PKXKRGLHTp0qPTiA2vvCFOXAGNHX0M7uuesb+th gIydl+FHNCDKbTz1bNy1LVw0zZyEZVSGDhv+Zf6ANZu36lq7GdgyXPpODD9ja+uBvIlLQGhq8b5T NzfyC61auVpRUUNGWg3zD3FPnjy5y2spfxugcw4fPfqwpelhc1Nz61Ng09MnD1qaGxofEpGdl5fX N2mIgEmTJt1uuFd/987t27dNTU2/IWcCoKnAGd1+/KzVzMzsC5RYDA0NDQdrbnmGxSGQdPQNs/cO sfUMsvMMtvMKRr4LohCXEE1buvpuFRLu27frqUWW0LdfPzUDi554fuDsSefs4B3qEUquvPog/8i5 WXMXbOMX2cLDKyQkhPChyydf/gkg/GxsbHzz7m1LS8uFCxcqKytPnjx569at1tbWF6/ohyExJzAc 36o5WAp+fn4+Pj6kX/Vhk14CbDFxDvzdu3dwuXsiE5Hcm5xfFkFNCY5NCIyi+IXH+oRGe4dEeYdG +/SAuOQZFOkaELps5Ve8tg+YyjbNIyjCKzSqJ87MptGN4FhaTFJWCJk2esxYbG345wgfvuFpbfil HYxXHmpra7m5ucF59OjRU6dO9fPzQ2F7e/vTp0+3bt0KSiwzFPr7+xO7UlBQMCcnR19fn8mqf//+ WI0kEgka8uDBgyBeuHBhl+bAxIkBioqKXS7BZYImKSsrO3z4cExMTE+fEIRmMzIyys7OPnHiRH5+ vo2NDfND8VpaWighlNLr16/Dw8PRW1FR0c7VBw8ZomdiTklJj4xPCCNRgunPgqP8wiIJ9A/vEQMi ol28fDg4OdEx9P+rzJzgHuEvcAYyWw+KjImIo8anZbr5+GFCsHq/7UlOa2vrDsarPZBRZ0uKddXW 1oadgl1PiNvc3JyYSWgAxIYdjM+3Mt9FhW5E+Yez5R9fZ8CCMTEx6dwc8ZYK2JaUlDAL4Rb6+voy PgzbTqQdjBcrVFU/O0eE5aSurk68mtTOAKKVs2fPIp4CwbVr1zp3gHg1w97evsuQBw8ezDGdk4Nj Ojv9QTDHNHYGcnxEdnbi0fCnEgbOmDlz5cqVCJRsbW0jIyNTU1MPHDjQnTlLQM+Jhrqz7Y7oFQfn jIWLF3NMn/4N1TgBpaWl9FuvL15gwn/rFJLv2LGD2CN1dXUwuCiB50ZMJl35v3mDaUeG+P6PoaEh QYwSaAlYTywS4nUqzDyxWgig0WgohKXw8fEhSrA3YT4gmkePHt28eZP4liBYEWRsbGzMupmZmSh8 /vz5vXv30AqcyaamJhDfv39fXFwcPjY8TOL7tKiOS+hGfX09tFAvpwIcoDqgkVatWjWTi5uPV1BI UFhIaJeSkjI2BTpMpVLLy8uhVRBWQL0ghTKBHjt+vBJ9A83atZ/dicLawKxiyGFhYdBI8B6lpaUl JCTgeFtZWtnZ2Tk4OMDBYByo2MKzmW/LFoE5cxZiU8+ePRuW7hvaUALA8GZtbTtDKMLCwszyiRMn FhcX19+5c6uurqiIfswVnuHFK1ceNDY2tbQ0NjXVMcrJZDIuQYEz3ndowPxHRUWtW7cOHdbT06ur r7/T0PCouTk3N5dYRQi7qmtqmh8/xmLA2Im23NzdUf3egwfY79ikiAGhJ2/fvdvy5Mnzly8Rfv7G WITWtrZEK1evXsUUwS6vWLEiJCSkpqaGeD9x5MiRUlJStfX1T1pbGx488PDwgKAxqK/6TxAsbHQe Sx1aa9u27VoapnY2Lna2Tm5uHpAsfBsM/OHDh1jq16/fgNHB0LALCgoKCgsLMWOlDChjwP79+5Gi EKsiJSUFcxUdHZ2WlgYCVDx+/DiUQ1RUtIW5hZ6uoZ6usY6WKR+vAC8vL4zFjBkzvsd3zpcuXVpZ VXW1rg7iDggIwDRCS0NkEMf+w4dzMIyyslWMDwotXb782OnThyorK44dyy8pQSHxNA16ODUrq6yi Aqip89kRLH0jo8OVlUdOnDh47BhhgGbNmXP01Knj1dWV1dVcjHeBl69cSbcO1dVoqPPrltb29ifP nj1ZU2Npa4uf0zk56xoaSsvL0atVnT5whD782Wn7T5w0CczRz6MnT3L93XeN4RphWqAu4JZgM2qo G4UGxYUEx0RGxmRmZl2/dh3ODN2PffECOgRyr62tO3XqFHY91gMhd2wE4sOnAEIbYJ1AHUELYalA 7WBfoDw0NMzFxc3FycPFydfE2FFwxy4REREsdUTZhDr95rBhM09pxdG0nLziiiO1DU3vOjou3qzP yCukpqTHxNMiSJQt/B++87NHXLy88lRqNv0INA/fJ+W8YRPP2Ss3kzJzYyiJIxkOJDP8X7NufVZB cfq+gqT0LOIS/44dlTXnURIWTRrIuI1jYml98uzFI1U1mBC4dtitxJHvQyerU3PyUrPzVTXpr5pK ychXnr2QnJnj/DEqZHmTYQsf/+kLVzPzi+NoyV84XviXAAdp0aJFAgIC0LrwFmSk5R3sfKMiEmKi 4smk+LLS/fV19fB2XjO+Wvue/m8TbYQvAVcBOwU2BSnEStC8ZAAyMEMwWFVVVXFxFD9ffx/vQF+f UE+3MGUlbXFxCWj+jRs3fj9ZA4QlpHNKy0NjKUEx5KBockBUbGBErF9YlHdQuIaeIVun7/yoaOrE JqWFkuK1DT9zvbT0jXL2V5CT05U0tbowF9wjQkpKC4mNs3b+8KRbU984ITM3kpqkqsk4ftynj6On bxQ1OSohOSYxDeUR9DOrieFkBEckdAPpqnX0p/8OHj60rDxySsY2wZ1fGI6qjl5iTn50QrJ+t8Nm XwuITRBEYP5lZWUNDAxgUxTkVXy8okgxybHR1HgKLTMDocHJ+vrbkGNPrwATH69+9eoVpH/+/Hns +5iY2JDgsMCAsODAqMAAkq62uYSEpLy8PPY1jCAXF9d3/a8KK2f36ITUUHKCuYOL+F4FCVkFUSnZ LfwC3Y8xWDm5xSSmR1CSNmz+7JSmmZ0TOGQWH9Q0/OyeyYABA9KL9ofF0cIpNN5tAijp17+/e0Ao JS0HfHi20pXGgIEDvYIjomlplLRsRXWt3aISu8QkhSVkdolIbBUQwmrZKSI+4veRYOUXHh2Xmp2Q lbdj156exoLN7uztT0rJpKTnCOzskeyrAPOPCIWfn19FRQVCl5OT09TQD/Inx8WmxZGSE6iptISU jIzsw4ePnjlTU3urFpYdihqeJFzEGzduXLp0+ciRI/l5BWQSJToqNiIiNiI8LjKcGhlGMzd1EhMT Jz6lCwUOZcLJyfnN/fDOAAVLSs4gp2TGJKUvX8364SYBw4ePiKKmkFOzyClZ8xcu7nxJ18QcG/Ni /cPHz55hZohCBO+IU6jp+6JpKQFRpEGD6KfoR48ZCw7JuYWQ2ux59McKffv18wwMReHhmkvrP38z pXOwjCjG3T+YlJTx6HXHgcqTTB0OF9rT05N5IGfosGGhsdSs4oM1N+5gV9JLhg7955+MgCmfM2cO fHU4hBoaGnCwlZWVlZRUzE2tgwOiadSchPjMxIQMWkJaAjUF0k+kYQ1gJSRR45Pi4mhkUgKZRCPF JMaRUiPDE+1sPdRUtOBSYuXARd+yZcuSJUugwL/HHacuMGf+wvC4FK9gqO7IPxi3+nu66z5z9tzg 6HhvUAZHjfvjM22zaMly94Bw75DoVx0dMEzw92CCEU8FxyZ4BUc6evijFYKSnYMzipoOPv7hZOah NSUNXc/AiEPVV2HXXF1dEWgjnLl06RKq7xaV7PNRWDt2CXsGRQREUaAh4dM6OzsjJoLdjKFlKGvq 9e9P/2Lk2HF/eIVEh8TSXjK+FOEXTtIxsezlrc6/BFjzefPmrVmzBt4+FDsCT8hdTU1NTk7ezMTC yd41KCAygZKRQstJScpJTKAjVkJSQk5oMNnTzd/a0l5dVVNGRgZLBYoCfiAfHx92BwKuH/YXJLzb d5o6uBtZOytrGX/5UcVG3u2gNLZxUdI26n51j6ScgZWjmb27tVuAvTf99q+lk7eJnauWsRUbx6dD 6avWbw6hpFs6+2iZWBMvrQMmTJyMn4ZWzmb2nlauvtaufuZOXkY2LkY2rtt2iTJ7NWz4CHVDS0Mb F3NHT8bt5RA7jyALZx9LVz+xvUoEt99Hjjaxc0NdYzt3MydPsBLY8w2OZHcGDg4OhGkIADds2AC5 w+bq6upC9PDh4dQpKirKMkBTQxNhJoSLLYy1oc4A+gNNUVFIGXEWdjQ0RudbCj8ANm7bvUtKaae0 yvL1rF+aYMJ6vp2g3CWjunwdC8pBQ4YuXrlhp5SyjKaJnJa5nI6FoLji0jWbhw4f0Zlsp5SKspG9 gp7V5h0incvHT5y6YetOMQVtKVVDGXVjMUWdzQLC7FxdvxY1ZvyEdbyCooo6exmtSKkbbxEUmzHn 013xPn36Ll/PIyynKalqIKmqv0NcYfyE7/VnfLCz2OzLli3Dfufh4YGex4aF9LFzofCJb15B+pA4 RLx9+3YYF5gDGGhIGWvmp7zy3PuHj316YQH79us/YtTY0eMnDhsxqsulP6awbxVXsYnI2qNkvFvJ +M8ZLD78NXjIsFHjJowa+8fAQV96Aj5w8JDRDLJBQ1jHWag+/PfRg/9BFPZVwM7Ozs3NjS2PDYtd D5mu/Aj4CXW9ePFiLIyZM2d2+Y7TT4HePyL/MmX3S8wSzL+UtqWRR5SUlqWYuomApGr/AQO/XL33 XeoN2Y+HyZMnf7/Y+X8cxv0x0cTJR8/GTdvCUUHLeNKvjz3+q2HMuPG7xCQEd4ts5OH7X3j98xf8 F+D/ANXK5mENCmVuZHN0cmVhbQ0KZW5kb2JqDQozOCAwIG9iag0KPDwvVHlwZS9YT2JqZWN0L1N1 YnR5cGUvSW1hZ2UvV2lkdGggMTY1L0hlaWdodCA2Ny9Db2xvclNwYWNlL0RldmljZUdyYXkvTWF0 dGVbIDAgMCAwXSAvQml0c1BlckNvbXBvbmVudCA4L0ludGVycG9sYXRlIGZhbHNlL0ZpbHRlci9G bGF0ZURlY29kZS9MZW5ndGggMzgxND4+DQpzdHJlYW0NCnicxVppWFNXGs5GViCBkEBYEkLYCcgS IICAoLIngApYqMUFFEVc6oIoKtuoqHUXneLSmQodx9FqnVqBaltq1bYo6gMiIFAUBESsiIBAljkX ErnZWJ6nA+8Pntyz3POe73znO+/5LgjEODDnWNlYWbCMx2s3PTAwtnTxnRsSFh4hiAgPDZnj48g2 ok43KQXoMaw8ZocLIAjXb970sRD6FRbgyqaTp5uaHBQjO3/AcF7O1w9apSPoabh5LEkoCPHi0HSn m94w6FZ+EYIF+++LpEp48e9kYaiHucH009Rn88MEMed6lRmOoCJNGOxmpkecXo40u7mCqBNd6ikC iH9IEs62oZKmkaKusUtYZF6LRooQBq4sDHGgTR9LMtMnIvrSmBQhPEsNm2GoPU0cdc39hfH3x+UI 9nqWwN1oeljqMP2Fqa0KbCSiof53PT19Q0MiCbxcdCrKnT4dK04ymSlM74Ez6W2v+uHi2cP7DhSe L6n4o6tfDKu8GuVqMA17nOYuSO2GUWyrKM5KDA/w8XT38PabG7P2+I36Lpg5iyId9PBTzZFsE5bY /oGCuP324cQAVzsLUxpUacq2mcGP3nm99vUoy+MhHF3c1HIkMQMXVHwg0Hf/9KpgPpeio4UcbWLj EZ1XVvPhHHq/LcLGSA+AQiaip4YklRf15QeOvU9vFJ0qyM/fvc2dgoJNxMZrxcXHg/JWb6+cOrQ/ Pz8/b8McElLzm/86kNghKf1qgs3dmdrw8a2CDr5WbfQsGj6V/x+o7gsq1XCUSs45Yj80QhLtc9+o tmnY7KIzFSSJrKAsdRyl0v4tZnKHQ5G9igZUGohr8uaa4KdiuSlOMdXqSUpfzNMfYYCih/2qWj1U kRdmoTMVGwfPCNguD4E9yjTuziQClkiseXKzGkOXbpppQpgSjyRZRf0oG7X9J2WvE5+y1UIgSU75 b1U5SsrXexhip2RrI3S5S2QGlJzMKlbWu71rjDF6vpeG1DnDjWAGHonCUwyZbDaTro0Zly+GSKHo UYiYyZPU5x+SDfpsZVDSFWU6f0Tbzn+gjqJUWh/p5DZLuHpP4dVr1745tmP+bB6bLHNQJM7EzX+W r6ebC4CzHYOAROtyvAWbd4H4uyWSz5pkbMUzwm7KBt0bwOKl3JEoUfn9cJt6jtLBM1erO2HCo7uu ZIOvKQ4aH228reNlZ+fTaghVlflshntKWYssPIiefx1ugh2XGQwEs4UyhTYUY02muGXUKlGRqMZ5 5XnA0Hbcmwq2Es7jF3jpDwm7axSudq8zOVqTsSRzqWyFG3xoRIyBX/5LzRRks6kWj1Fb8xEDjdCJ fgEv+/2Rco/eVYaTCAsETqasX6E1CYfEGof+/d3YHN+V7O8eq/7lx3Q0PVUh8veptqr2mYSKItqe lHWbT9dCI5B489hLg6rvHMWLL9LSXsGeRR33fr7fAbfUE39ty6NjzhNgIJEyYY4oAveCrJvvcFxG kWyXl2teTtGjvTHCYphTDpTvT01cfQzuyZIsFv+mckexsiPnmE54h6PwM76VvdoTMdwLTXbZVKOJ Y39ZeqB7Onz1ftvgZ2thLzgL3xf/9RA0KHSTdFXc+KVdoUh6xGLCTonEOn8vs5G7rBOG6rOrQz3H rqJkHjscTqDv0tqooNnBn/wDTrI8dLmC14qfnEhLWPmloq/v4Ux852AcZCTFfLkSx5rEXVVVPKBF /ZEFtlTrI/CFE7193QnQpXBs3o7LUVjc57tD7c2d1ytcRge3MCce0FE28uX2xcmmhrPeoBBA5K+9 szPIXJs4q05NnSJ+WnZRYXJfhhrj0QbxChrl1QrGxH0SaSHfOKGk4TMNSXTIVaPApZKKrT4MPIqc MGb8Gca3ax/BH7vTrcAxpPexQgB+FKU/YUOicQx5CFqhh0FB6tb7K/UhqDXFHIxFWzvGeSObzpF0 hU3y9CM6EoE0SnsPLzzvNfH8Akabki7rdskUh0ZgDAUVUg0o9cQjkGbZ8KL+57WPlXHv6xU7FFz6 O38dMHnrU/CywRybSZyLenSh7Fjs4Gpr4TipmtNqQ59ZYpDm+fCi9sKNaWlpa9Zt3JIhx5ZVUcEn 4G3E+7jgcMF634UXvlppMoljUY/Fk+0SUTBd3/WwhgTqMLqXG6KZmfBI/2w9z9bWzjVy76kzMpw+ vt55tkIof7OOCZxdO+o5vLBq3sRdEoHQMXcpl3XcywsvVUlDK6AhXM9kLTza/LnJlmxgHVkCb3Se K1QI5Y0f0cA+piYrHOBf+0wm5aXN5h+UdXyZPW50+YFvGl8JL6grSNxapGCj7jTnZQoBoCwQuKSS mwzl2U5KUJr4xMiPApV7mArEx72jzqjRNKPoKw5z2Q4PAJLPHIFLYtyuw1t1rTad1AWOylt4R+OQ PcqK913W4twx1KSko2gJl38eXvR2Awu4JCG4Hl74ZMHkvl1RHBbs0hD6xHWXbynfedr3PtRIcbDt +u75tjQvBVVeHwe5pE40XN5J/+MzyVyxWcin9VJ1GCjfmbhVhdKzD1NQmNrAm6afi7IT+ExtkvPn Vc87ZHhRc9QLuCRCN7C07oW88PmDFKtJuSQCQeOvvaLOlN0XV/KtffNeqakarn50+37N8/b2jo72 1tpHJcWHtiSGuJlTsCis2dzUrDyAXIDtKYGmkAQnWkWvz86VISORR9Vhubrb6U3YMVGumU/UkGj9 PJ6rT2SEn1N/SA6V7U1JXZORBcbMzly/PDbY25FN14aElBYzIi1j27ZtGesWhXi52BgRISZaZJaD q5sMThyqtm1xY1PlTI3pYiSOamKij5NrEIxxcoMqB1HVXoGlDhpJ4CSpPyarcoKdLGydXMCYLjPs Lc3oZIIsO4D3qns/AKG3+fMABlFr2FpIDI5IkoOIx1CiOsGdMVLjJ1UtTs6FrzYzRq7xSIJNuhqF O/BjxixT4rDe4OV0quHYc3a+CRmNJQyPTMBhUKO6S/+T0VBW6aneVkjDjaC2JoKiyZDkBSAu3nQY 9lykjsdpNfnTd99tDKSP2BpjGPZP1QUX/bTVlab+/SjW30BEkIiHA9VQuinNyp5lYGJnro1CEoyd vPh2dCwSgTJddaeu6piXDhJrYOfJ58pySmgyh+fjbknGaHuclEBfOdgEKKMX/LOaPdN3fU88j0Uf mROes0z1G1Tn6blmGqyAcb0GOLZU3K2Fgv7lWWvu3ruacLruAkebFfbF47bWylwXXSTGalftHxVL LAh67tkVLW1V+1x1gJrTdki90fSyuTzR2vVaB/SSqiNMIE3cKtU63ODpOGGQr6sdh23KtuIlnFIR wX2Z9poEAiEY3BwH/7V2xT7oOle69Ffge0ADX/f1KRhRveIfvXXwfBBLX8cxTGMfDBtJUuJGQBuE loysWXe+PD1ewQMXBZsVF249qH78uK7xxZt+uE17v4sUCAThEKIWZf6nXqFysKNsEVuT+Kd88iew 9Gae45IH0M1hK/BoSLV8sbT8Q/9iOz0ow/Es1iYJ8neoWrzDlCZokjf4br/sx3U+2EMGzsJlqUAR pm3fe76yRVECDTRe3S4UCIQFt18qHoRvHxYudtOUhEaa5gGXrFnjO/cQsH/fvqPDR9bAq4M3oKk3 N0IZ0M5oq41AplctnPdYKn1f//sLYIFf/OYAe0v+bGjuFVem59SDIftb72fYA0cl0ljWtsMIiM0u farujqgMSVvp9nBnHU1JRgwX+tLb9vC3Wmjpft9aCnVpuXLgOFjArsv791wCCmkoc1YRKP52Mbhe DT0s/nspUH9Ny46Dho3nduWfubApPAESf9VHl/sYQvNGYbSwI+D4pF6qHl8HDT79d5IbEx5yFIHz vT06n8acVMgxW48lLgE+OHQtydf/UyAHRfkLwV4cPJoG1nywvbmpFZi1OQe4cm9hrJdX4BxXayGo F/0z0pZGUHo9yyW2oKJDbU53dNie6sIYLkMDQQik0eRF370cwfI2aGihUwK4mnVlu+gzEppAhNu6 GmzersytsHTBvcPgoTnNmqxLNdClLgD032yyJmJUzk1Th7mZZY1vxlBi/S03c8JsDcfgiNBf/Cf0 jfftm/bKs2t8HVcBH2xYYWG0CJR2rmPhLLaBZa9dtRP8rUvNBe7V09HS0tr+sqng6CB0rzTAURm6 aGoyYPw0nq72aLfyjDtwq7lXg3IbaLtzKN6DoyGIjwDF3A22X/s3p47krgx1oFtBu+hWCMXgY6BT xJcifTeBe95QYdwxMZRZ3Q6Wue36l0X/ffTVtvi899AH/8DZud8H0Zk7AOPKdbMM1X5+MbOfmXii oqN3SIWnqP9lxcnF3nYmY1EE8WI4lN9InuPtam1IwjtfAU9FbnhK2D3In2uqgIVE95IjLoLi4rBV wLziZw/r3kmrYnnJUBbm9cOnYuljX4djYPze1mo3DTlMFtd/6cGS2s53olG9KBH1dT4pObjMn2s2 NkUQyoOegqiyh0cjk3BoJH420Ff9O6wwROc8+Z4U3U/3EYIQOrDLI6JEPkRNMDOwWO5nTQLnw8M/ qv013tbYjvzQ5fsuVz7r6ul7P/C+r+dVc+Xl/OXhXlzmeBTBvS74j4HBpkWMEW8izWkYGGxMMEJh jIVFr6A9+b7z+ib/GSvB2dO10pK7+s47QFP0pmKdkx5n2Y894EHc/WgLzy6lVSyVdJ9xH+tKyeF6 zFm4OutAwdlzX5z4bGdafBDPnm00PkVAa8aagpOfepBHIhRxRtrxE+vddZFIkuW83Zd/e3Drq92L +B5bfwVsHkTSqe4pJ2/e++1awRo/IzxlxtJj31feLyv8NMDEaGbmN3fLDsRYjPPvCeY2jq4efG8/ H767C9eaOdErCZbm6OfnSMPKn7h+flzoCa3N8oxauuKTCE8OewmUFBo4yiNhqbYBHyUnxc12NCKg tPSs/WOTkhfOcWIQiQz3qEUxfhzdiX23NB4rJqoBCkc2MNDFolSeUDiKsYWluRGZwNoD7aHyBKYW EkM0YHI4ZgYkoJeRaCLVjMNh0khaSBROz5hlakAc/yPbXw1wumHQKASaubm+/fm3q510IQZINCiU U4E9IFFojYfaFABNm5manRHnrD+xT4z/A1P+MbQNCmVuZHN0cmVhbQ0KZW5kb2JqDQozOSAwIG9i ag0KPDwvRnVuY3Rpb25UeXBlIDAvU2l6ZVsgMjU2XSAvRGVjb2RlWyAwIDEgMCAxIDAgMV0gL1Jh bmdlWyAwIDEgMCAxIDAgMV0gL0JpdHNQZXJTYW1wbGUgOC9Eb21haW5bIDAgMV0gL0VuY29kZVsg MCAyNTVdIC9PcmRlciAxL0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGggNDU3Pj4NCnN0cmVhbQ0K eJyFwodS2gAABuDnsrV72zpREVEEkaGAoBDCCjMQ9h5hC4iADK1272Xbx+of4513rXf97hubNI6d v4ZTfBP/+jR3nEuMz1y8gbPETa6Zf2sOSa6AvC0g7+C8Be/yF6z3zt9fRNsDId/+cIn7SIQOfLyM 1BMxd0LsnFhxPl1F1zOUuCYl7qk19ExLuTMy7yyu+3BO7hPIacEGPa/w44IygIuqgFDFCNXMkjoo 2gyKtkLLqAmLNeEVbQRXdVGUbMfW9DGpPi41xGWGhGwnsb6bRLkxtWFKKUxpBZFWEhmlOasis2oy p7bkNq35LbQVNPaC1s5qHazOUdRRpW2qpHeW9a6ywV3BHU9111M1emtGX92E9B6B/oY50CADTZJp WpiWNdiyhvZtobYt3LZj5MAR6VDRDhXrOjHec2Hi0I3JvgdTA2964EsPkc6M6OzIj7mjAPeYyR8z hedB7kmQPQmxp6HiaRhLLyJYfhnFCr6KYfV1HGv4JoH1t0ncw3cpbOD7NDbxQwZb+DGL+/xPuTb/ cx4P+F8K2OF/ZbuXi91vxd7FUu879/Byuf/jr5X+WWXwz+FZdfjzyrXhr9roP+uj3/WjK/4BqNyY IQ0KZW5kc3RyZWFtDQplbmRvYmoNCjQwIDAgb2JqDQo8PC9QYXR0ZXJuVHlwZSAyL1NoYWRpbmc8 PC9Db2xvclNwYWNlL0RldmljZVJHQi9TaGFkaW5nVHlwZSAyL0Nvb3Jkc1sgMCA0NjggNzIwIDQ2 OF0gL0V4dGVuZFsgdHJ1ZSB0cnVlXSAvRnVuY3Rpb24gMzkgMCBSPj4+Pg0KZW5kb2JqDQo0MSAw IG9iag0KPDwvVHlwZS9QYWdlL1BhcmVudCAyIDAgUi9SZXNvdXJjZXM8PC9FeHRHU3RhdGU8PC9H UzI0IDI0IDAgUi9HUzI3IDI3IDAgUi9HUzEzIDEzIDAgUj4+L1hPYmplY3Q8PC9JbWFnZTI1IDI1 IDAgUj4+L1BhdHRlcm48PC9QNDQgNDQgMCBSPj4vRm9udDw8L0YzIDMwIDAgUi9GMSAxMSAwIFIv RjIgMTQgMCBSPj4vUHJvY1NldFsvUERGL1RleHQvSW1hZ2VCL0ltYWdlQy9JbWFnZUldID4+L01l ZGlhQm94WyAwIDAgNzIwIDU0MF0gL0NvbnRlbnRzIDQyIDAgUi9Hcm91cDw8L1R5cGUvR3JvdXAv Uy9UcmFuc3BhcmVuY3kvQ1MvRGV2aWNlUkdCPj4vVGFicy9TL1N0cnVjdFBhcmVudHMgND4+DQpl bmRvYmoNCjQyIDAgb2JqDQo8PC9GaWx0ZXIvRmxhdGVEZWNvZGUvTGVuZ3RoIDg1Mj4+DQpzdHJl YW0NCnicnVZdb9s4EHw34P+wj1QRM/ymBAQBmq+eD3DTIkZ6QNoHxaEdAbKUk5QE/fe3VOTGtKw0 1yfJwM7MzmiXNBx+gaOjw9np9AzY8TGcnJ3Cv+MRA0YZY1wIZsEKBloxqNx49O0DFOPR4acroWBV j0ccVr+qGTOcqaB8+WE8+joewfnsFGBLir9KTTqsToztVGPJ+R5VLiRNEkA1MJZyloBONGUcBDXG cFissbPpOl05oeGshH3CohP2DuyrA57ENBaeNrExSI5PCTLm1OpfPnpcspeXUIqrN/M6/JI2jasK WNRIpRTUi8LDlbBUtEgUNcy8mZ7qhE/mSHghAZ3Ml96Jj4aDwV4UujAJ5QnM19v6zLvFn1x2Pz+N RzdHTNqT4x8w/3s8OkfOF16+yxsLjENs896Qz+4ZohC5KecypgkPyy+mF5dD5XFMpQ7LJ0O1iaFG hrW3ae3uIOKSuCdXNPjGyOI+LQqXQ5SQjyeRJFNI82giSV4++0cNUUyWpX+tIDKkfIomgrhq19FL FhQ/7948pKHWdl1wxg4iRXAWsAH+0goKD2UklKZmh6JtGjlcXg+gpELlELQt0JsXvTsvoY+EUcmx Ccap6tL0E6H2TUSIxB2kOCTbSDJdP1Tlk4NlmlWFq4c8CCuojEPomybMu0wIY/zq/oGJbST5mOOI dONRwfoxb7KH3AF+lYcqK6usydzgx4lxNlVI96Yx2zPWm7SNOYmZqd+Z66E3BrfQZH6PU+kGV1dz ymSIyIpF5VK/IO2eWZJn66xppzz1aUV+n3CZNO7SuqycX6jrWY2RHcDzfba4B6y4dYVbZk29d8P2 d80k1Zse8rRaOd+CJ69/1o1bd3tsSVrcwSIvH++gfHBV2mTFak9V/egb0STttbCjy62idqM7y6rW +cpdXg3NM9NUJiHsYHDtOc7IjsZ5lae+zWJ1iUEV/7Q+i8ETQFL5TjGpsSqsvbx6GipOBFXvJFb4 aeKw9q82pvx6NgTBEzsRIeb/nbYcTz1t3rNXcbBX/iKiSax6N6UVoLTZ3CMv/wbaW3FzkuEE47xP LDlv3/3VMpAds1QGbDfkdHMDDeSBd6TZgVwt0ryN8TbLs+YnfCfie9TLSOz1g3QxD+l6Gf0HGtUY nQ0KZW5kc3RyZWFtDQplbmRvYmoNCjQzIDAgb2JqDQo8PC9GdW5jdGlvblR5cGUgMC9TaXplWyAy NTZdIC9EZWNvZGVbIDAgMSAwIDEgMCAxXSAvUmFuZ2VbIDAgMSAwIDEgMCAxXSAvQml0c1BlclNh bXBsZSA4L0RvbWFpblsgMCAxXSAvRW5jb2RlWyAwIDI1NV0gL09yZGVyIDEvRmlsdGVyL0ZsYXRl RGVjb2RlL0xlbmd0aCA0NTc+Pg0Kc3RyZWFtDQp4nIXCh1LaAAAG4OeytXvbOlERUQSRoYCgEMIK MxD2HmELiIAMrXbvZdvH6h/jnXetd/3uG5s0jp2/hlN8E//6NHecS4zPXLyBs8RNrpl/aw5JroC8 LSDv4LwF7/IXrPfO319E2wMh3/5wiftIhA58vIzUEzF3QuycWHE+XUXXM5S4JiXuqTX0TEu5MzLv LK77cE7uE8hpwQY9r/DjgjKAi6qAUMUI1cySOijaDIq2QsuoCYs14RVtBFd1UZRsx9b0Mak+LjXE ZYaEbCexvptEuTG1YUopTGkFkVYSGaU5qyKzajKntuQ2rfkttBU09oLWzmodrM5R1FGlbaqkd5b1 rrLBXcEdT3XXUzV6a0Zf3YT0HoH+hjnQIANNkmlamJY12LKG9m2hti3ctmPkwBHpUNEOFes6Md5z YeLQjcm+B1MDb3rgSw+Rzozo7MiPuaMA95jJHzOF50HuSZA9CbGnoeJpGEsvIlh+GcUKvoph9XUc a/gmgfW3SdzDdyls4Ps0NvFDBlv4MYv7/E+5Nv9zHg/4XwrY4X9lu5eL3W/F3sVS7zv38HK5/+Ov lf5ZZfDP4Vl1+PPKteGv2ug/66Pf9aMr/gGo3JghDQplbmRzdHJlYW0NCmVuZG9iag0KNDQgMCBv YmoNCjw8L1BhdHRlcm5UeXBlIDIvU2hhZGluZzw8L0NvbG9yU3BhY2UvRGV2aWNlUkdCL1NoYWRp bmdUeXBlIDIvQ29vcmRzWyAwIDQ2OCA3MjAgNDY4XSAvRXh0ZW5kWyB0cnVlIHRydWVdIC9GdW5j dGlvbiA0MyAwIFI+Pj4+DQplbmRvYmoNCjQ1IDAgb2JqDQo8PC9UeXBlL1BhZ2UvUGFyZW50IDIg MCBSL1Jlc291cmNlczw8L0V4dEdTdGF0ZTw8L0dTMjQgMjQgMCBSL0dTMjcgMjcgMCBSL0dTMTMg MTMgMCBSPj4vWE9iamVjdDw8L0ltYWdlMjUgMjUgMCBSPj4vUGF0dGVybjw8L1A0OCA0OCAwIFI+ Pi9Gb250PDwvRjMgMzAgMCBSL0YxIDExIDAgUj4+L1Byb2NTZXRbL1BERi9UZXh0L0ltYWdlQi9J bWFnZUMvSW1hZ2VJXSA+Pi9NZWRpYUJveFsgMCAwIDcyMCA1NDBdIC9Db250ZW50cyA0NiAwIFIv R3JvdXA8PC9UeXBlL0dyb3VwL1MvVHJhbnNwYXJlbmN5L0NTL0RldmljZVJHQj4+L1RhYnMvUy9T dHJ1Y3RQYXJlbnRzIDU+Pg0KZW5kb2JqDQo0NiAwIG9iag0KPDwvRmlsdGVyL0ZsYXRlRGVjb2Rl L0xlbmd0aCA5MjU+Pg0Kc3RyZWFtDQp4nJ1WTW/bOBC9G/B/GPQkFWuGXyIlIJtDPpq2aIDsxuge gj0oMmULtSRXotO4v36HstxItuUGe7JlzXtv5s0MaTi7h/Pzs7urT9dALy7g8voKvo9HFCihlDLO qQbNKQSSQmXGo3/eQzEend0+cAnzejxiMP8VTaliVPbC0/fj0V/jEdzcXQF0pNir1KTFBpHSrWoo GDuiyrggUQSoBkoTRiMIooBQBpwopRgkOWb2KY/nhgdwXcIxYd4Kuwr0awUsCknIHW2kQxAMPwWI kBEd/KrjgEsc+MWlZPKkX2f3sbWmKiCpkUqGUCeFg0uuCW+QKKqoOumebIUvp0j4QQBWMk1dJc4a BgpzQWahIsIimOZdfeqqxUcm2sfb8ejxnAp9efEvTD+PRzfIueVl+7whRzt4l/fRu//6EfyJ9PLS nwhvZiAp86fMn3CvMDX4kWcXBnzlPZnauk+zNLkpLL4KvTJ1GPCl9/HrHbJEXlzMwD+WB0Frj+Yi FNG6yQXcIAVo/zRxae3R7HCMcUJFD0cbRFf3wPBg3/B+MhElgmEylBHZGuMslccs7SNxiAm63EW6 3NERsPE34/yp9x3ZYTmWolkfG8+e48LiBkCZgutCHje92DiX8SfXjUVczX7EldmaP2DTNi+ucbV2 3M9ZZdfxMvsZ26wswNdeahp2u3ZkHDO1i9i6F+bFkWd185DhsJeFNbmLWZVVXG1+JysFCXey23Qd FlUGnKCCyD3YyX6qNy0QpwHRr+18+4Z0gN59aXHe0f0sXroiXCPSZlkqqLN5kaVZsu2RXW7cwmRF Upm4NrgJLPBMmrqXWZKZItm4rTmyI3vyTAsiWvmVqXyxE8zjIhn0kAduq7vYkxbqAwsPdrS1kQlJ 5O9sHFrwDtj7eyD1SBMR9UPNbJ2g0WbQKhZKdw50MVm+2h5O7Xwzir41xtlVhUdXVtghNqkZYf0M cOqHgjFfJXvBX7Ji/fLHBz9wMy48c/mAX68H8CqQhPXxJzsVvmnY8SZFu//HsHeA3k0RPy2NW/of mV0MH1yaBKwHfDc4lSEerb3Q1fNiKFiFJOrF/sneDSUhmCB4zXajsWWb0m3buhpEYTz2rovCsy1t Lrz5UL8VGtX36WS/ol6/UFORKDzcLKSUgdrdxNt/Mc1t7t28rAwOf5Xlbphwnpd4FYTbq3qgLBER obp8j97t2tTIgjM/Ud7DetWe3naAIggCd/j2KA7K/A8kvDnhDQplbmRzdHJlYW0NCmVuZG9iag0K NDcgMCBvYmoNCjw8L0Z1bmN0aW9uVHlwZSAwL1NpemVbIDI1Nl0gL0RlY29kZVsgMCAxIDAgMSAw IDFdIC9SYW5nZVsgMCAxIDAgMSAwIDFdIC9CaXRzUGVyU2FtcGxlIDgvRG9tYWluWyAwIDFdIC9F bmNvZGVbIDAgMjU1XSAvT3JkZXIgMS9GaWx0ZXIvRmxhdGVEZWNvZGUvTGVuZ3RoIDQ1Nz4+DQpz dHJlYW0NCnichcKHUtoAAAbg57K1e9s6URFRBJGhgKAQwgozEPYeYQuIgAytdu9l28fqH+Odd613 /e4bmzSOnb+GU3wT//o0d5xLjM9cvIGzxE2umX9rDkmugLwtIO/gvAXv8hes987fX0TbAyHf/nCJ +0iEDny8jNQTMXdC7JxYcT5dRdczlLgmJe6pNfRMS7kzMu8srvtwTu4TyGnBBj2v8OOCMoCLqoBQ xQjVzJI6KNoMirZCy6gJizXhFW0EV3VRlGzH1vQxqT4uNcRlhoRsJ7G+m0S5MbVhSilMaQWRVhIZ pTmrIrNqMqe25Dat+S20FTT2gtbOah2szlHUUaVtqqR3lvWussFdwR1PdddTNXprRl/dhPQegf6G OdAgA02SaVqYljXYsob2baG2Ldy2Y+TAEelQ0Q4V6zox3nNh4tCNyb4HUwNveuBLD5HOjOjsyI+5 owD3mMkfM4XnQe5JkD0Jsaeh4mkYSy8iWH4ZxQq+imH1dRxr+CaB9bdJ3MN3KWzg+zQ28UMGW/gx i/v8T7k2/3MeD/hfCtjhf2W7l4vdb8XexVLvO/fwcrn/46+V/lll8M/hWXX488q14a/a6D/ro9/1 oyv+AajcmCENCmVuZHN0cmVhbQ0KZW5kb2JqDQo0OCAwIG9iag0KPDwvUGF0dGVyblR5cGUgMi9T aGFkaW5nPDwvQ29sb3JTcGFjZS9EZXZpY2VSR0IvU2hhZGluZ1R5cGUgMi9Db29yZHNbIDAgNDY4 IDcyMCA0NjhdIC9FeHRlbmRbIHRydWUgdHJ1ZV0gL0Z1bmN0aW9uIDQ3IDAgUj4+Pj4NCmVuZG9i ag0KNDkgMCBvYmoNCjw8L1R5cGUvUGFnZS9QYXJlbnQgMiAwIFIvUmVzb3VyY2VzPDwvWE9iamVj dDw8L0ltYWdlNTEgNTEgMCBSPj4vRXh0R1N0YXRlPDwvR1MyNyAyNyAwIFIvR1MyNCAyNCAwIFIv R1MxMyAxMyAwIFI+Pi9QYXR0ZXJuPDwvUDU0IDU0IDAgUj4+L0ZvbnQ8PC9GMyAzMCAwIFIvRjEg MTEgMCBSPj4vUHJvY1NldFsvUERGL1RleHQvSW1hZ2VCL0ltYWdlQy9JbWFnZUldID4+L0Fubm90 c1sgNTUgMCBSIDU2IDAgUiA1NyAwIFJdIC9NZWRpYUJveFsgMCAwIDcyMCA1NDBdIC9Db250ZW50 cyA1MCAwIFIvR3JvdXA8PC9UeXBlL0dyb3VwL1MvVHJhbnNwYXJlbmN5L0NTL0RldmljZVJHQj4+ L1RhYnMvUy9TdHJ1Y3RQYXJlbnRzIDY+Pg0KZW5kb2JqDQo1MCAwIG9iag0KPDwvRmlsdGVyL0Zs YXRlRGVjb2RlL0xlbmd0aCAxMTUzPj4NCnN0cmVhbQ0KeJydV21P40YQ/h4p/2HEJ+cEy76vXVGk 8lLuWuVEewhOQv1g4k3iKrFzjgOlv/5mHQN24g0Rn7CXnXlmnnlmPIHjazg5OR6ef7kAenoKZxfn 8KPfo0AJpZRxTg0YTkFJCoXt9+4+QdbvMZi83qFUMypbl8af+r2/+j24HJ4DNADYG8BRbasibWqs UDDWhcUFiSJANNCGMBqBihShDDjRWjMYzfu94y/zeGIVg4scuoB5DXx89Y0bmCzrDFgUkpA7t5EJ QTD8K0CEjBj1mseWL7HFEpeSyY7IHZqs0I6v47K0RQajJbpSEpajzJlLbgivLBFUU72TPVkDn92g w98FYCY3Y5eJo4aBxlgkZqEjwiK4mTfxqcsWX5moX6/6vfsTKszZ6T9w80e/d4k+137Zpt+QIx28 6fc++GqX5UAENoFBFDymRbmKZ+n/cZnmgyMRZO50UeSPaWKXMDBvN9BginZxkTzFhYVBFzhBPjsD EJoYUwdQeRzIoIIdHPEAoStY+185UIHNlvi+3AR48SiUIq7gTY9lDp9vhz4LKTXRsm0xWTkWZLD0 2CjUE91AafrfKrDaLHCbh4gSwZAHyoisC+FKKLtK2LbEpiFY1aZlcF7RhpzpIMufoFhlvty5CIlo G3+3lbHPwCgiwraF13lIq1I0714XOYrk3wpjVB4Ccvzn7fAQbvFheFfFXVT/BHev8LlWGLfacP35 2Ql0YQtnfusx1IwR7MW94q+p5Qan0cvdFNWXWMjH4LQOlU5gnBeQ2IfVZIKHaTbB2KWLXQWJXczy 57kLzGalNxuNY7CNU6Jf9OTLQiCzsm2xU356L/k5NbCPqK9hGPzmYxNnPQ6Z5tXZ0hXZS7/ShLZ9 x7NZ/oStHwZ3aZa4R4Mkw8H3ayek83y+qAfGQzpLy2cYMBnM88R6eQ9JJFsIB76rBgXXvrqTcLMf 4VQ4rx9hvGEZ3NjRFK4L+5jaJ8hyr854KIhsowbP1omzdLNi3Xhx8lz1Hx44XbtnnPfJarQewyZY Le0hPKxKmMbeKVxHyYx0Ol0jzavaYPO4uZpOsnScjmLXFCqYxNhXkGauqcarrIKK1xUMgzhLvI3D JWG6DbPOYpbGaw1454AifMNyZ0HDvQrKJHUBfaCgTcvgMqu4ephZeErLqaPoYBovfmUHVT0cIz6h Cq3dZGy5y3CYVKwk08e57yuIg33DDOF8vGPMqp3tbvaivfYbRvkbdfuvL69mwTDHzSPNxnn1HZnH lWSdatWag6QaN2HHWvMLzgoaLK13VESSRI0Iu9L9toizt32YNlJ+y5M2vbgdE+c3nkkGxWTj4O+r 9ec4ew+JdSFJ/DRwT7xbuC6uMILIEIE7uGRuH2Ioh5eVtem5Jh1XRt2dxP0L1zv0wHhHzEwZgnt+ w/PkZZ/dHb4LiYeYM4kwfNfSeiv8dxZQ57GB+o6cmWjp2XUd1lVuadpwkPgVq3fr9e+SdT44slGL 2NlHEnciiyPRDe9KnkcmwPUC13A8RBpxNUIxNwXr2800TkMlmogdafwEenMFVQ0KZW5kc3RyZWFt DQplbmRvYmoNCjUxIDAgb2JqDQo8PC9UeXBlL1hPYmplY3QvU3VidHlwZS9JbWFnZS9XaWR0aCAx NjUvSGVpZ2h0IDY3L0NvbG9yU3BhY2UvRGV2aWNlUkdCL0JpdHNQZXJDb21wb25lbnQgOC9JbnRl cnBvbGF0ZSBmYWxzZS9TTWFzayA1MiAwIFIvRmlsdGVyL0ZsYXRlRGVjb2RlL0xlbmd0aCA5OTE3 Pj4NCnN0cmVhbQ0KeJztXQVcVNn3X7vXXnMRRMTubhFEEQw6pLu7u7u7ZhiGoVsaVDAxQOwWMFAR ULED+H9nno4Ig4u7xu+/6/mcz/3cue/cc+Pce+K9+9789tsv+AW/4Bf8I5g3d97CBYuXLF4yevTo n92XX/AtoW/fvps2bbKzs8/IyKyuqn737t3bt++etLy7d+dx6xPk36Lk3r2GQxWHgoKCJSUlJ0+e /LO7/Au+GgYMGCAkJJSelv7y5av3799Dps+fv7h//8Hly1eOHzuelZkbE03O21d46tTpq1euPnjw 8MWLF+/oAMr3Z8+eNzMz/yX3/xcwcOBAfT39pkfNbW3tb968bW5+fPXK9UMVR7C7KRRKSEiou7u7 ra2tmZmZvb29t7d3ZGRkIi0xNzf32LHK69dvPn78FLXev29re9+empLGycn5swf0C3qEvXv33rxx q+19x5s37yC4O3fuXr169cyZM8eOHSssLExJSYmJifHz83NycrKxsXF1dQ0MDIyNjUV5QUFBRUXF 6dOnsf2hBKAKIPH2to73796HhoZOmDDhZ4/sF3wGmzfzVFWdef++/e2bd8+fvXz8+ElLy+Pm5ub7 9+/fvHkTcjzDgNLS0sxM+jaHlJHSaLTi4uLjx4+fP3++urr67Nmzt27damxsfPbsGTR7e3sHAfjp 6Og4ePDgnz3KX0AHCzOrt2/aXr9+2/r02eOWJ8+fPYcP1t7eDosM2Z0/f2H//v0BAQF6enqysrK7 du3i4+Nbv349Dw/Pjh07xMTEFBUVTUxM4uPjDx8+XFdX//Tp01evXrW1tXV0hvaOU6dO/fnnnz97 rP9pwI6jUpOftb588uTZ/fsPHzU+ev78OYTz5s2bu3fvYsNiL5PJ5ODgYGxPQ0NDeXn5PXv2bN26 lZ9/2/btAjt37pSQkFBTU4O4XVxcgoKCQFxWVgaFgN39mbTbOiD/e3cbVq9e/bMH/R+FKVOmHqo4 3tLS+vBB462btdDb2M4Q9+3bt6G9Iej09PTk5GRIMCw03MrSTk5WUVJSWlJCEntcWVkZmxq2Xlp6 r4yMnJKiqouLR2wsCeo9Ozu7qKgI5r6hoYGQNXY63Wt/3wZj8erFG3k5hZ899P8czOKeXXPmUuPD prra25cuXa6vpyvhO3fuQNCJDIADlpGRERQYoqGhA/mqq6tra2sjhaDl5ORQgp2Ofa2lpaWvr4/d DVWvoKBgZGialJQCg15SUoK0srIS5gChHNT7yxcvX7+G2nj7+lWbnY3jz56A/xBM+GPC0SOnbtff vXjxMkzqlStXsKOrqqrS0tKio6Pj4uKwSSPCI+Rk5SBciHX37t2bN2+GHl7JgOUMWLFiBfET5Vu2 bAENiCF6LAlNTc2cnJz8/HykWVlZcOSgN1paWhobHzU3t7S2vnjc8lJZUf1nT8N/AoYMGZqetu/6 9VvV1TWInmCgIQ54WYiYYHzDwsIiI6KhpbF/4YZBjhDrokWLZs+ePX369KlTp44fP74zN5RwcHBw c3MvXLhw2bJloEddWHklJSUdHR3IGiuHbtBLy5qamuAP1NXVPbj/kKFVHm7fJvSzJuG/A1ZWjtXV 5w7sP5iUlJSbm4s9mJWZZWZmZmVl5eDgYGRoBn9bSEho3bp1CxYs4OLimjJlSu+ZQ+6E0KHwofzF xcVjoumhOhw56I2LFy+ePHny6NFjWGBVp2uKCysmTJj4/Ub6C/i2bC8qOpCfX+jp6WlqampsbAyb u5UBiLDWrIGQ10Fvb9y4ce3atVDUSxmwZMkSpH379u1NE8OGDYPQoRNERUVVVVVRUUZGRkREBEsI P93d3e3t7e3s7L29fRzsnNRUtZZ8hKWfA0qgN773hPyLYfjwEZHh5PLyCnt7h6DQ0Cu1tR1fA3aO X+FfsbGxQehz586lUqlf1Qrgen39tfr6tJycCRN/7f2/D0oKWkWFpWlp6RA3tjM1MfF6Xe3VWzfP Xblcff7c6XNnq86dRaY7Xrp+DVKAg716zZreN8fOzn7mzBlUvHLzRneeaOs0A5FHBy7fuI7OXK+v BfGlG9dgXAYMGPD9puJfD5MmTvH1CSkpLvP394cx1dDQgFE+evz4/UePGhob6+7evV5be+3WrRt1 dSwR/jRdcDdujB07tjfN8fPzNzc3o8qt27fBuQs3oi2kuHq7oQF9eNDUdL+x8U5DQ01NzbZt2773 bPzrQWSPTFRkbHh4hK+vb2BgoKurKyzjrFmzbtbWNrY0P33xHNj89EnTk8ctrU+Bj5+1Ekj8RDmh aRFb/WVb8PoI4ofNTWAOtgRDghWzFbTY+vIFyvHzwaNG+O2FhYXQCd9/Mv7lMG7seAtzh4z0TEjZ 29sbG1xLS2vNmjUTJ07EVnrY9Ohx69OXb9+00e9ts0D6nbGOjrftH26D6+rq9tQQ/DSsB4Ls2csX r9+/I+ow+TB5vm17/+LNq1Yss+fPmltaEKBhHQ4dOvRHTsu/Fdav2+Lp4RsZGe3s7Axxh4WGIVbi 4eFZtmQ5TCQM5ZMnT953eajRM7x58wZuc/dWEJtfv3699y5ZW3v769evGxsbL1++jGj9x0/LvxL6 9OmjKK8eE0O2tbVzcnJCCGxoaIhoa/fuPfCcOTk5EWHFxcU9e/asnfnM8q/g6tWrv//+e+dWEGqB w1fIuq3txYsXDQ0Nhw4dWrRo0ZTJbH9OnfazpujfBJMmTdXRNoqJITk4OEKZBwQEYF9v2rRp+zZB zDMs+ODBg0eOHFleXo75773EExMTCf5YLYjiey/oDoaTD30CN41CoYwbN27rVn7BHTt5eLZ36Tls DQJwPj4+BOxqDEBm7dq1c+bM+WGzN2PGDOY9AWQQXf6wpv8eLF28ytjI3M8vwNHREcrczc0NWxuB 2LRp7FC/8LQJi8nFxQVVDO3ae4nr6OiMHz9+//79vRc0mMMWPHr0qLa21sjIaMyYMegJQ9vwcs2Y i2BBSkoqIiLi1KlTIPsyK/Q2ISEBffjyfb9ly5ad6gTJyckRrEBI6NMd3dGjR+vp6ZWVlWFNdm/3 5cuXJSUlCgoKvbzv9INBUEDExpp+I4vQ5JgfbG1paZlJkyaxsbENHz6cSQmDDkG8ffu2l7KDROBi fZWsMVcPHjyoqqqChkGLEhIS8BWRR6/OnTvXe1ZdABZh3bp1LIevra3dm46BDMTz588nk8noZG8a RYf/1w7jwXDvlVFxdnJzZGhyhGCYXoh7h4AQNiYUaRdnWF9f//Hjx1C2f3vmewIYaxj3O3fuwHXH Mhs7Fo2Pg4a0s7NjOb0QAapg7dEfnr58iaWFXn1Z80RHRw8ZMqTLDEAD9KZ7/Pz8iB//UqV0gZs3 b44aNerHifOvYMSIkYoKGr4+9POE7u7uMNybGTBtGgfsNeKmQYMGdakSFRXV2tra9fQRK2jvaG9r /wsyELx+8xrYwoi20AeixWls0yDrixcvEmRv3r4BDdK39JPs9KNTMCuEzofffunSpRs3bkAtQO7t dJG3E02/b3sPYlREhuBz7NixLhK/desW0Q0C6YcsPuK79+/QIlERer776Jhsu5ej3Q7GmsTE/jhx /hXA490ro+Tm5gGTDYcKsS1kDaXdr18/yBpRGDJdqkC9FxQW3G2496i5icDmxy2dsamluRHFjAxx lSDDz875+w8f3Ll3t7a+7lZd7dVrVy9euigmJgb+/fv3RwolQ2xqNFR/5zYo791vQJWHjxoJhHAL CwsFBAQIc4NNxMvLC6EwGyK68aDxYcOD+6gOJMTh5+/PHMvUP/8EDVGFQOaggER1FD5++gQpGkVn bt+9A1bgSYyFWZFAZrvoKurevd9w7dq1HyjPvwDO6dxysiqenl6QNSJuCB2GUlSUPu0DBw7sydmY PGXK/oqKc5cvV58/X3Px4tlLl7rgmQsXcAlIZJASZEiJKtXnzlVWVR09caL8yJHSgweTU1O5Z836 jWFckC5YuBCybn316kRV1Ynq6tM1NUQtAs8yUlpy8pCPhoaoBZgzd+75K1eIDnzW6LlzJ6urT505 U9/QUHX27KSPLzXwbt36sLkZNERvmcisDgT9CUZXDx46VHzgAIVGy8jJwc8z588TzAliJjLHi4pV 585dvHoVDuf3lmMvYRb3fHk5FR9vX8jaz88P5ht7REFBkbjKnMbusHLVqgMVh8qPHD107Pjh45Xd EeVM7FxYfuQYMgcPHykq259bWJSdl2/n6DRixAgmZwTs0OpNT5+VVRw6cOhwxVE6PVJURHqk8gSw +tyF6dOns+xhXmERWgEls2kiRfX9FYcOosPHKzds2kQQa+vqNrY8xaXOve2CpeUVBSWl6Tm5OwSF mJ7MkqXL0Lcuo2OOEa0TeOTEyZNVZyb+zzy5mztn0d69ShC3v79/UFAQAjGEsWpqvTo4JC4lXXSg oqDsQH7p/l5iXklZXnEp0tyiktTM7KT0TFEJyS5s9YyMX3V05BQUg4Zepbh0X1EpUqJ6fsn+89du ZucX9dSrk+cuFJQeQJXOCFY5hcXIFB0oLyk/xMPLSxB7BwQdPV2N8h67WlyalrMvikzhnDGDqMJc YNb2DmjoSyMtKQMBmuvuH/4smDN7kexeJU8Pr2AGYHcjztXQ0Ohldf+wiNTcvOTs3N5jUlYOLTM7 IT0zJJo0b+GiLgwnT5168MRp8EzMyAYx0kSsiqwcoiLyafvyL9yqb2xsPM2AU58DSu60PI1PTe+O lOTUuORUZFJy9m3YRI/yBgwcSE3PBEOwZdlPlKMDlNS0TTxbuo9dTEr6C2Mnup2QkRVOjv9nIvqW MHPGPBlpBXc3j7CwsPDwcB8fH/hIKiqqf1kRKzY+Pr75XQclNYOUlNp7JCenkZLS7Fw8xrB6VCq5 V+5I9fnohKTYxJSYhGSkzIpECTIxtGRycnpSdl56QXF28f6c0gNIgRmFJdT07ChqYhg5PiIuoQuG x1FDYuLCSPFgvmT5CrTFwTkDfGJoKcDu/UQhWoymJfuHR7E0aiJS0plFpSzHSO8qvXpqVHyiilaP D4x+GMAHI4bAwT5TRprumSO8QliKDQ5fV15e/svVOTk5z5w586Stg5ScHklJjIxP6iVGUZNJyRlI B/XwipC5nQMlNQs8w+MSunKmJEZQaEhDydTgGHJwTFwoKR5kEQziMBI1jExFJiSWEhJDwaXOiELQ B0bGBkTEhJIoM2bSb3XybOUvOlLJoiFGW/Ty+CTwVNc1YNlVdT2DtIIS1sNndBWIpleuYX1750cC wisivJ00caqYqIy1tS2JRIqLiyOTyYIMGDp0WE91d+zY8eTJk9NX6khJGdEJqcDYxLReIikpvaD8 WMv7DmVNHZbMIylJpMR0UMbQWLBFWygPj6MFRpJ8QyP9wqIDIkiBkeSASLJfeDQQmcBuGBRFR1D6 hkR6BYWHxiYQLr2ajn5e+fFoakr3tlDCGFc62uLdtoNlV32CIhMy9vXUT6RRCSlgzlKJ/WBAbEuE q8OH/y4qvFdXRx+CplKpqampQkJCu3bt4uHhZVnRwcEBoWvZ8WpySiY1Yx+BCZl5H3Ffp8LO5Z8w Kafw7tO391rfrt2wqQvzwYMHJ2YVEAxZcqBl5SVlFypqaE9j52DjmD7taxG12NnZ2D8caAyIImcU Hfi8/58NBNKMT8tmn87iRujUP9mSc4toWfksh0l0Pi4t2zcs6luK7R/A6NGjR44c2ee3PruEJOXl lChxlMTExLS0NFlZ2T179piYmHehR/BYWFgIWWcUHKCkZGMqknMKEzPzMf/IIIWk8BMpM09c6oz0 S5n5uaWH6WvmWNWkKVM7NzFs+HCwpaRmE3WZ3Jh80vJKMovKdwqLfYPhjxmTkluckltE8O+CRLu0 jLwoSgrLmw+beLcePXsFZMSgulbPzE/OKUpI36eha/jPu/pNAOIm3rjcsJ5fQlwmPDyCRqMlJSVh /woLC5uZfSbupUuXIha+/uBpLC0tigrHJpOSmkNOzoxLyUImLiUbGSKPQlxl/CQK4dnmMBE/QYBM dkkFJO4ZEDZw4KebtHAnQmJhjhNjEtIIMoLtR8xO3VcKFJGQ+Y1VxD1nzpwlPQPxgJJr5kyCeNnK 1bllR5ld6ozMzsfQ0g1MrVjOnpKG9v7KM0QPe6iejerrNrFw6X8KjBgxgp2dfejQobO5F0qIy7q6 uEHcycnJ2OPi4uLS0tIzZ84iKJWVlV++fJlffjwgAqYwLiSWGkqi0dPYhDByIvLI0JFEC4qmgIYg +1DIoGHiB2J69YT0wgOPXnXIq2p27pWytr5XcIRvWAyYgBvR1oeKJBopKavmxn1LB7fuw4F7+eWb 8yl5JeCzcQsfQS8iKVNQcSI4hkr05zOMhb9HDYqm+keQ+LYLspw9R09/CLSn6igPjIoLio77Y+Kk byq0vw+w3RwcHGxsbOPGThAXk9fU1E5KSk5JScnJycHUSUhIaGnpDBw4MDIy8nlHRwgpydknxMUv zD0w0iMoyj0wAqlHcBQzj3JcBY2jV6CjV5CTdzB+guATJRMZxESaVXastPLcitXrmb2aNp3T1s3X 3sPfwTPQ0TvIySfY2Zferpt/uFtABLilFdLVgr+/P3Yr6DEEfn7+ffv2vevoiKJlgoDJHPSu/mGu /uEufqHoDxhqGVkwHwFom1gGRFNRDv4s0CfEyTvIxTeUaeg7A4yOT2isq18Y0b3uiHJwtnRksSx/ IkyZMmXBggXDhg0TFBCXlpJFLJbBAE9Pz40bNy5cuPDEiROl1ddtPQItnL2t3fyQsXEPACLTOY/U 0tnH3NHLzNHTxM7d1N7DDOjoZe3mT1wl6JlIVATaeQcXn7wUEEObMOnTCYSFy1YY2riY2LmZ2rub OYCPJxDMzZ28zOk8/WJTC1502rbIU7LLHH1CCc4gAFq5+lm5+Fq6+Fg4eZnYexjbuclr6o/4eJ4K niouWTp7d27iM3TwMHfAWDxYRtwzZ89zCYgydfAw7akuUnvPXeL/W+frxo4dS7zNt3DBCmkpBUsL q8zMTKh0Z2dnXj6+m83NQdR9upauupYu+tbuhrZe+jYeBkBbTzoy8vRCa3cdCxctMyctU0c1I1tl PYtZ8xat2bRVy9RJz8qFICMomfihuq0n6pq7BOWduK5maDNo8Ic7jVxcXDNmzVXQNlE1tFY3ttM0 tdcyddAk0MRBy8wR/SEYEkyIjJ6VG8p1zJ11LJy1zZ00TR01TOzBVs3ARk7TZNGyNZ0FN3HKnxiX pok9HZnMO6GGiYO6kd1OcTmW87aWZ5uOpbPGl6rbaxjbzVu84kdIsdcwatSouXPnrl69euLEydKS ynJySiEhIbq6ulZubofq3hq5hCjoWSvo2ygbOSgbOygZ2SNVMXZESi9hFCoa2MrrWcvpWu7VMpfR MN0tqzl+In2f9h8wQEhaVU7XCgSd6zKRKEQGqaFzUGxhFd9uaVQUF5fctm0bnIphw39fvp5PREFb QsVQUs1YWt1EWsNEWtNURtNMVtsCvVIytCOQ3gddK1l0QNNUSt1EUs1IQsVATElPQlmfd6fkdO55 ffv17zLw2QtXSKkZiasYSPSI+uAzf/lalvPGt0tKQtXwi9UN9mqajRr7x/eW4NcCnPMNGzZApa9d s4V/q+DiJct9E/ODs07t1XMQUzWV0LCQ0rKS0rSS1LSkZ7SskX7Ia1qJq5uDRlTFWFjRYLe83gYB sSFDP510GjthioiykZiKiaSG5adadA5M/FCI1MA1wj48a9ailQICAlJSUpaWlhoaGsuXLx8wcNA0 rrkLVmxat11sm7iKkIymoIymkIzWLlmd3XJ6uxX0kO7cq7NzrzZxSUBKYzXfLu5FKydMmdZ/4EBm Z7ro5PGT/pzGNW8a15yecS479/yhI0aynDQ2rjlsM+jYU3V2rrkc3Au+k8j+CYwfP554A3f0qDHT uJfElF+3DE4VVTcTVjERVTMX17T8iFZIxTToiLyYuoWIqukeZWNhZaOd8vpC8roLV23pHp/OXb5h j5KRqJoZUZFRlwWKaViAp3V4loZd4PjJbJKSktR4KoVC0dHRWbFi5XR2rn59PwRrg4cMGzlm/CR2 LmK2mThlOjfKR47pupv6MOBHzOP/H5g2bdr8+fO3ikhlnH+u4xoppm4urmEhid2nYyOlY8tAm49I /4lLIIAQRVVNhZWNdyrocXDPZ8kZbjCfmDIYSmhafaxu8znaMnnKGjr5pBzFQtq1RyQuLi4pKUlJ SUlUWEJQQGTu3HmAcePG9eZJYm9EjIhjGAOGfwSWx7R62VZ36EKmpqa2jwHObm4//WEoAnAnf/+y G68MXIIVjRyVTZ1VzFyRKpk4Ie2MKFE0dlQwtJM3sJXVs5bRttgjrz12wpdCy3ETJ8vq2cgb2KFi F26d2RKNGrmFU8svC8mo6ujqampqKimqKitpb9zAB+9i1qxZXc6E9DS3vYGsrKzmbnDnzp28vLxN H08+fEOgJCaevXz5wpUrBSUl30PbbN68GbGzgoIC7PKXKRGLHTp0qPTiA2vvCFOXAGNHX0M7uues b+thgIydl+FHNCDKbTz1bNy1LVw0zZyEZVSGDhv+Zf6ANZu36lq7GdgyXPpODD9ja+uBvIlLQGhq 8b5TNzfyC61auVpRUUNGWg3zD3FPnjy5y2spfxugcw4fPfqwpelhc1Nz61Ng09MnD1qaGxofEpGd l5fXN2mIgEmTJt1uuFd/987t27dNTU2/IWcCoKnAGd1+/KzVzMzsC5RYDA0NDQdrbnmGxSGQdPQN s/cOsfUMsvMMtvMKRr4LohCXEE1buvpuFRLu27frqUWW0LdfPzUDi554fuDsSefs4B3qEUquvPog /8i5WXMXbOMX2cLDKyQkhPChyydf/gkg/GxsbHzz7m1LS8uFCxcqKytPnjx569at1tbWF6/ohyEx JzAc36o5WAp+fn4+Pj6kX/Vhk14CbDFxDvzdu3dwuXsiE5Hcm5xfFkFNCY5NCIyi+IXH+oRGe4dE eYdG+/SAuOQZFOkaELps5Ve8tg+YyjbNIyjCKzSqJ87MptGN4FhaTFJWCJk2esxYbG345wgfvuFp bfilHYxXHmpra7m5ucF59OjRU6dO9fPzQ2F7e/vTp0+3bt0KSiwzFPr7+xO7UlBQMCcnR19fn8mq f//+WI0kEgka8uDBgyBeuHBhl+bAxIkBioqKXS7BZYImKSsrO3z4cExMTE+fEIRmMzIyys7OPnHi RH5+vo2NDfND8VpaWighlNLr16/Dw8PRW1FR0c7VBw8ZomdiTklJj4xPCCNRgunPgqP8wiIJ9A/v EQMiol28fDg4OdEx9P+rzJzgHuEvcAYyWw+KjImIo8anZbr5+GFCsHq/7UlOa2vrDsarPZBRZ0uK ddXW1oadgl1PiNvc3JyYSWgAxIYdjM+3Mt9FhW5E+Yez5R9fZ8CCMTEx6dwc8ZYK2JaUlDAL4Rb6 +voyPgzbTqQdjBcrVFU/O0eE5aSurk68mtTOAKKVs2fPIp4CwbVr1zp3gHg1w97evsuQBw8ezDGd k4NjOjv9QTDHNHYGcnxEdnbi0fCnEgbOmDlz5cqVCJRsbW0jIyNTU1MPHDjQnTlLQM+Jhrqz7Y7o FQfnjIWLF3NMn/4N1TgBpaWl9FuvL15gwn/rFJLv2LGD2CN1dXUwuCiB50ZMJl35v3mDaUeG+P6P oaEhQYwSaAlYTywS4nUqzDyxWgig0WgohKXw8fEhSrA3YT4gmkePHt28eZP4liBYEWRsbGzMupmZ mSh8/vz5vXv30AqcyaamJhDfv39fXFwcPjY8TOL7tKiOS+hGfX09tFAvpwIcoDqgkVatWjWTi5uP V1BIUFhIaJeSkjI2BTpMpVLLy8uhVRBWQL0ghTKBHjt+vBJ9A83atZ/dicLawKxiyGFhYdBI8B6l paUlJCTgeFtZWtnZ2Tk4OMDBYByo2MKzmW/LFoE5cxZiU8+ePRuW7hvaUALA8GZtbTtDKMLCwszy iRMnFhcX19+5c6uurqiIfswVnuHFK1ceNDY2tbQ0NjXVMcrJZDIuQYEz3ndowPxHRUWtW7cOHdbT 06urr7/T0PCouTk3N5dYRQi7qmtqmh8/xmLA2Im23NzdUf3egwfY79ikiAGhJ2/fvdvy5Mnzly8R fv7GWITWtrZEK1evXsUUwS6vWLEiJCSkpqaGeD9x5MiRUlJStfX1T1pbGx488PDwgKAxqK/6TxAs bHQeSx1aa9u27VoapnY2Lna2Tm5uHpAsfBsM/OHDh1jq16/fgNHB0LALCgoKCgsLMWOlDChjwP79 +5GiEKsiJSUFcxUdHZ2WlgYCVDx+/DiUQ1RUtIW5hZ6uoZ6usY6WKR+vAC8vL4zFjBkzvsd3zpcu XVpZVXW1rg7iDggIwDRCS0NkEMf+w4dzMIyyslWMDwotXb782OnThyorK44dyy8pQSHxNA16ODUr q6yiAqip89kRLH0jo8OVlUdOnDh47BhhgGbNmXP01Knj1dWV1dVcjHeBl69cSbcO1dVoqPPrltb2 9ifPnj1ZU2Npa4uf0zk56xoaSsvL0atVnT5whD782Wn7T5w0CczRz6MnT3L93XeN4RphWqAu4JZg M2qoG4UGxYUEx0RGxmRmZl2/dh3ODN2PffECOgRyr62tO3XqFHY91gMhd2wE4sOnAEIbYJ1AHUEL YalA7WBfoDw0NMzFxc3FycPFydfE2FFwxy4REREsdUTZhDr95rBhM09pxdG0nLziiiO1DU3vOjou 3qzPyCukpqTHxNMiSJQt/B++87NHXLy88lRqNv0INA/fJ+W8YRPP2Ss3kzJzYyiJIxkOJDP8X7Nu fVZBcfq+gqT0LOIS/44dlTXnURIWTRrIuI1jYml98uzFI1U1mBC4dtitxJHvQyerU3PyUrPzVTXp r5pKychXnr2QnJnj/DEqZHmTYQsf/+kLVzPzi+NoyV84XviXAAdp0aJFAgIC0LrwFmSk5R3sfKMi EmKi4smk+LLS/fV19fB2XjO+Wvue/m8TbYQvAVcBOwU2BSnEStC8ZAAyMEMwWFVVVXFxFD9ffx/v QF+fUE+3MGUlbXFxCWj+jRs3fj9ZA4QlpHNKy0NjKUEx5KBockBUbGBErF9YlHdQuIaeIVun7/yo aOrEJqWFkuK1DT9zvbT0jXL2V5CT05U0tbowF9wjQkpKC4mNs3b+8KRbU984ITM3kpqkqsk4ftyn j6OnbxQ1OSohOSYxDeUR9DOrieFkBEckdAPpqnX0p/8OHj60rDxySsY2wZ1fGI6qjl5iTn50QrJ+ t8NmXwuITRBEYP5lZWUNDAxgUxTkVXy8okgxybHR1HgKLTMDocHJ+vrbkGNPrwATH69+9eoVpH/+ /Hns+5iY2JDgsMCAsODAqMAAkq62uYSEpLy8PPY1jCAXF9d3/a8KK2f36ITUUHKCuYOL+F4FCVkF USnZLfwC3Y8xWDm5xSSmR1CSNmz+7JSmmZ0TOGQWH9Q0/OyeyYABA9KL9ofF0cIpNN5tAijp17+/ e0AoJS0HfHi20pXGgIEDvYIjomlplLRsRXWt3aISu8QkhSVkdolIbBUQwmrZKSI+4veRYOUXHh2X mp2Qlbdj156exoLN7uztT0rJpKTnCOzskeyrAPOPCIWfn19FRQVCl5OT09TQD/Inx8WmxZGSE6ip tISUjIzsw4ePnjlTU3urFpYdihqeJFzEGzduXLp0+ciRI/l5BWQSJToqNiIiNiI8LjKcGhlGMzd1 EhMTJz6lCwUOZcLJyfnN/fDOAAVLSs4gp2TGJKUvX8364SYBw4ePiKKmkFOzyClZ8xcu7nxJ18Qc G/Ni/cPHz55hZohCBO+IU6jp+6JpKQFRpEGD6KfoR48ZCw7JuYWQ2ux59McKffv18wwMReHhmkvr P38zpXOwjCjG3T+YlJTx6HXHgcqTTB0OF9rT05N5IGfosGGhsdSs4oM1N+5gV9JLhg7955+MgCmf M2cOfHU4hBoaGnCwlZWVlZRUzE2tgwOiadSchPjMxIQMWkJaAjUF0k+kYQ1gJSRR45Pi4mhkUgKZ RCPFJMaRUiPDE+1sPdRUtOBSYuXARd+yZcuSJUugwL/HHacuMGf+wvC4FK9gqO7IPxi3+nu66z5z 9tzg6HhvUAZHjfvjM22zaMly94Bw75DoVx0dMEzw92CCEU8FxyZ4BUc6evijFYKSnYMzipoOPv7h ZOahNSUNXc/AiEPVV2HXXF1dEWgjnLl06RKq7xaV7PNRWDt2CXsGRQREUaAh4dM6OzsjJoLdjKFl KGvq9e9P/2Lk2HF/eIVEh8TSXjK+FOEXTtIxsezlrc6/BFjzefPmrVmzBt4+FDsCT8hdTU1NTk7e zMTCyd41KCAygZKRQstJScpJTKAjVkJSQk5oMNnTzd/a0l5dVVNGRgZLBYoCfiAfHx92BwKuH/YX JLzbd5o6uBtZOytrGX/5UcVG3u2gNLZxUdI26n51j6ScgZWjmb27tVuAvTf99q+lk7eJnauWsRUb x6dD6avWbw6hpFs6+2iZWBMvrQMmTJyMn4ZWzmb2nlauvtaufuZOXkY2LkY2rtt2iTJ7NWz4CHVD S0MbF3NHT8bt5RA7jyALZx9LVz+xvUoEt99Hjjaxc0NdYzt3MydPsBLY8w2OZHcGDg4OhGkIADds 2AC5w+bq6upC9PDh4dQpKirKMkBTQxNhJoSLLYy1oc4A+gNNUVFIGXEWdjQ0RudbCj8ANm7bvUtK aae0yvL1rF+aYMJ6vp2g3CWjunwdC8pBQ4YuXrlhp5SyjKaJnJa5nI6FoLji0jWbhw4f0Zlsp5SK spG9gp7V5h0incvHT5y6YetOMQVtKVVDGXVjMUWdzQLC7FxdvxY1ZvyEdbyCooo6exmtSKkbbxEU mzHn013xPn36Ll/PIyynKalqIKmqv0NcYfyE7/VnfLCz2OzLli3Dfufh4YGex4aF9LFzofCJb15B +pA4RLx9+3YYF5gDGGhIGWvmp7zy3PuHj316YQH79us/YtTY0eMnDhsxqsulP6awbxVXsYnI2qNk vFvJ+M8ZLD78NXjIsFHjJowa+8fAQV96Aj5w8JDRDLJBQ1jHWag+/PfRg/9BFPZVwM7Ozs3NjS2P DYtdD5mu/Aj4CXW9ePFiLIyZM2d2+Y7TT4HePyL/MmX3S8wSzL+UtqWRR5SUlqWYuomApGr/AQO/ XL33XeoN2Y+HyZMnf7/Y+X8cxv0x0cTJR8/GTdvCUUHLeNKvjz3+q2HMuPG7xCQEd4ts5OH7X3j9 8xf8F+D/ANXK5mENCmVuZHN0cmVhbQ0KZW5kb2JqDQo1MiAwIG9iag0KPDwvVHlwZS9YT2JqZWN0 L1N1YnR5cGUvSW1hZ2UvV2lkdGggMTY1L0hlaWdodCA2Ny9Db2xvclNwYWNlL0RldmljZUdyYXkv TWF0dGVbIDAgMCAwXSAvQml0c1BlckNvbXBvbmVudCA4L0ludGVycG9sYXRlIGZhbHNlL0ZpbHRl ci9GbGF0ZURlY29kZS9MZW5ndGggMzgxND4+DQpzdHJlYW0NCnicxVppWFNXGs5GViCBkEBYEkLY CcgSIICAoLIngApYqMUFFEVc6oIoKtuoqHUXneLSmQodx9FqnVqBaltq1bYo6gMiIFAUBESsiIBA ljkXErnZWJ6nA+8Pntyz3POe73znO+/5LgjEODDnWNlYWbCMx2s3PTAwtnTxnRsSFh4hiAgPDZnj 48g2ok43KQXoMaw8ZocLIAjXb970sRD6FRbgyqaTp5uaHBQjO3/AcF7O1w9apSPoabh5LEkoCPHi 0HSnm94w6FZ+EYIF+++LpEp48e9kYaiHucH009Rn88MEMed6lRmOoCJNGOxmpkecXo40u7mCqBNd 6ikCiH9IEs62oZKmkaKusUtYZF6LRooQBq4sDHGgTR9LMtMnIvrSmBQhPEsNm2GoPU0cdc39hfH3 x+UI9nqWwN1oeljqMP2Fqa0KbCSiof53PT19Q0MiCbxcdCrKnT4dK04ymSlM74Ez6W2v+uHi2cP7 DhSeL6n4o6tfDKu8GuVqMA17nOYuSO2GUWyrKM5KDA/w8XT38PabG7P2+I36Lpg5iyId9PBTzZFs E5bY/oGCuP324cQAVzsLUxpUacq2mcGP3nm99vUoy+MhHF3c1HIkMQMXVHwg0Hf/9KpgPpeio4Uc bWLjEZ1XVvPhHHq/LcLGSA+AQiaip4YklRf15QeOvU9vFJ0qyM/fvc2dgoJNxMZrxcXHg/JWb6+c OrQ/Pz8/b8McElLzm/86kNghKf1qgs3dmdrw8a2CDr5WbfQsGj6V/x+o7gsq1XCUSs45Yj80QhLt c9+otmnY7KIzFSSJrKAsdRyl0v4tZnKHQ5G9igZUGohr8uaa4KdiuSlOMdXqSUpfzNMfYYCih/2q Wj1UkRdmoTMVGwfPCNguD4E9yjTuziQClkiseXKzGkOXbpppQpgSjyRZRf0oG7X9J2WvE5+y1UIg SU75b1U5SsrXexhip2RrI3S5S2QGlJzMKlbWu71rjDF6vpeG1DnDjWAGHonCUwyZbDaTro0Zly+G SKHoUYiYyZPU5x+SDfpsZVDSFWU6f0Tbzn+gjqJUWh/p5DZLuHpP4dVr1745tmP+bB6bLHNQJM7E zX+Wr6ebC4CzHYOAROtyvAWbd4H4uyWSz5pkbMUzwm7KBt0bwOKl3JEoUfn9cJt6jtLBM1erO2HC o7uuZIOvKQ4aH228reNlZ+fTaghVlflshntKWYssPIiefx1ugh2XGQwEs4UyhTYUY02muGXUKlGR qMZ55XnA0Hbcmwq2Es7jF3jpDwm7axSudq8zOVqTsSRzqWyFG3xoRIyBX/5LzRRks6kWj1Fb8xED jdCJfgEv+/2Rco/eVYaTCAsETqasX6E1CYfEGof+/d3YHN+V7O8eq/7lx3Q0PVUh8veptqr2mYSK ItqelHWbT9dCI5B489hLg6rvHMWLL9LSXsGeRR33fr7fAbfUE39ty6NjzhNgIJEyYY4oAveCrJvv cFxGkWyXl2teTtGjvTHCYphTDpTvT01cfQzuyZIsFv+mckexsiPnmE54h6PwM76VvdoTMdwLTXbZ VKOJY39ZeqB7Onz1ftvgZ2thLzgL3xf/9RA0KHSTdFXc+KVdoUh6xGLCTonEOn8vs5G7rBOG6rOr Qz3HrqJkHjscTqDv0tqooNnBn/wDTrI8dLmC14qfnEhLWPmloq/v4Ux852AcZCTFfLkSx5rEXVVV PKBF/ZEFtlTrI/CFE7193QnQpXBs3o7LUVjc57tD7c2d1ytcRge3MCce0FE28uX2xcmmhrPeoBBA 5K+9szPIXJs4q05NnSJ+WnZRYXJfhhrj0QbxChrl1QrGxH0SaSHfOKGk4TMNSXTIVaPApZKKrT4M PIqcMGb8Gca3ax/BH7vTrcAxpPexQgB+FKU/YUOicQx5CFqhh0FB6tb7K/UhqDXFHIxFWzvGeSOb zpF0hU3y9CM6EoE0SnsPLzzvNfH8Akabki7rdskUh0ZgDAUVUg0o9cQjkGbZ8KL+57WPlXHv6xU7 FFz6O38dMHnrU/CywRybSZyLenSh7Fjs4Gpr4TipmtNqQ59ZYpDm+fCi9sKNaWlpa9Zt3JIhx5ZV UcEn4G3E+7jgcMF634UXvlppMoljUY/Fk+0SUTBd3/WwhgTqMLqXG6KZmfBI/2w9z9bWzjVy76kz Mpw+vt55tkIof7OOCZxdO+o5vLBq3sRdEoHQMXcpl3XcywsvVUlDK6AhXM9kLTza/LnJlmxgHVkC b3SeK1QI5Y0f0cA+piYrHOBf+0wm5aXN5h+UdXyZPW50+YFvGl8JL6grSNxapGCj7jTnZQoBoCwQ uKSSmwzl2U5KUJr4xMiPApV7mArEx72jzqjRNKPoKw5z2Q4PAJLPHIFLYtyuw1t1rTad1AWOylt4 R+OQPcqK913W4twx1KSko2gJl38eXvR2Awu4JCG4Hl74ZMHkvl1RHBbs0hD6xHWXbynfedr3PtRI cbDt+u75tjQvBVVeHwe5pE40XN5J/+MzyVyxWcin9VJ1GCjfmbhVhdKzD1NQmNrAm6afi7IT+Ext kvPnVc87ZHhRc9QLuCRCN7C07oW88PmDFKtJuSQCQeOvvaLOlN0XV/KtffNeqakarn50+37N8/b2 jo721tpHJcWHtiSGuJlTsCis2dzUrDyAXIDtKYGmkAQnWkWvz86VISORR9Vhubrb6U3YMVGumU/U kGj9PJ6rT2SEn1N/SA6V7U1JXZORBcbMzly/PDbY25FN14aElBYzIi1j27ZtGesWhXi52BgRISZa ZJaDq5sMThyqtm1xY1PlTI3pYiSOamKij5NrEIxxcoMqB1HVXoGlDhpJ4CSpPyarcoKdLGydXMCY LjPsLc3oZIIsO4D3qns/AKG3+fMABlFr2FpIDI5IkoOIx1CiOsGdMVLjJ1UtTs6FrzYzRq7xSIJN uhqFO/BjxixT4rDe4OV0quHYc3a+CRmNJQyPTMBhUKO6S/+T0VBW6aneVkjDjaC2JoKiyZDkBSAu 3nQY9lykjsdpNfnTd99tDKSP2BpjGPZP1QUX/bTVlab+/SjW30BEkIiHA9VQuinNyp5lYGJnro1C EoydvPh2dCwSgTJddaeu6piXDhJrYOfJ58pySmgyh+fjbknGaHuclEBfOdgEKKMX/LOaPdN3fU88 j0UfmROes0z1G1Tn6blmGqyAcb0GOLZU3K2Fgv7lWWvu3ruacLruAkebFfbF47bWylwXXSTGalft HxVLLAh67tkVLW1V+1x1gJrTdki90fSyuTzR2vVaB/SSqiNMIE3cKtU63ODpOGGQr6sdh23KtuIl nFIRwX2Z9poEAiEY3BwH/7V2xT7oOle69Ffge0ADX/f1KRhRveIfvXXwfBBLX8cxTGMfDBtJUuJG QBuEloysWXe+PD1ewQMXBZsVF249qH78uK7xxZt+uE17v4sUCAThEKIWZf6nXqFysKNsEVuT+Kd8 8iew9Gae45IH0M1hK/BoSLV8sbT8Q/9iOz0ow/Es1iYJ8neoWrzDlCZokjf4br/sx3U+2EMGzsJl qUARpm3fe76yRVECDTRe3S4UCIQFt18qHoRvHxYudtOUhEaa5gGXrFnjO/cQsH/fvqPDR9bAq4M3 oKk3N0IZ0M5oq41AplctnPdYKn1f//sLYIFf/OYAe0v+bGjuFVem59SDIftb72fYA0cl0ljWtsMI iM0ufarujqgMSVvp9nBnHU1JRgwX+tLb9vC3Wmjpft9aCnVpuXLgOFjArsv791wCCmkoc1YRKP52 MbheDT0s/nspUH9Ny46Dho3nduWfubApPAESf9VHl/sYQvNGYbSwI+D4pF6qHl8HDT79d5IbEx5y FIHzvT06n8acVMgxW48lLgE+OHQtydf/UyAHRfkLwV4cPJoG1nywvbmpFZi1OQe4cm9hrJdX4BxX ayGoF/0z0pZGUHo9yyW2oKJDbU53dNie6sIYLkMDQQik0eRF370cwfI2aGihUwK4mnVlu+gzEppA hNu6GmzersytsHTBvcPgoTnNmqxLNdClLgD032yyJmJUzk1Th7mZZY1vxlBi/S03c8JsDcfgiNBf /Cf0jfftm/bKs2t8HVcBH2xYYWG0CJR2rmPhLLaBZa9dtRP8rUvNBe7V09HS0tr+sqng6CB0rzTA URm6aGoyYPw0nq72aLfyjDtwq7lXg3IbaLtzKN6DoyGIjwDF3A22X/s3p47krgx1oFtBu+hWCMXg Y6BTxJcifTeBe95QYdwxMZRZ3Q6Wue36l0X/ffTVtvi899AH/8DZud8H0Zk7AOPKdbMM1X5+MbOf mXiioqN3SIWnqP9lxcnF3nYmY1EE8WI4lN9InuPtam1IwjtfAU9FbnhK2D3In2uqgIVE95IjLoLi 4rBVwLziZw/r3kmrYnnJUBbm9cOnYuljX4djYPze1mo3DTlMFtd/6cGS2s53olG9KBH1dT4pObjM n2s2NkUQyoOegqiyh0cjk3BoJH420Ff9O6wwROc8+Z4U3U/3EYIQOrDLI6JEPkRNMDOwWO5nTQLn w8M/qv013tbYjvzQ5fsuVz7r6ul7P/C+r+dVc+Xl/OXhXlzmeBTBvS74j4HBpkWMEW8izWkYGGxM MEJhjIVFr6A9+b7z+ib/GSvB2dO10pK7+s47QFP0pmKdkx5n2Y894EHc/WgLzy6lVSyVdJ9xH+tK yeF6zFm4OutAwdlzX5z4bGdafBDPnm00PkVAa8aagpOfepBHIhRxRtrxE+vddZFIkuW83Zd/e3Dr q92L+B5bfwVsHkTSqe4pJ2/e++1awRo/IzxlxtJj31feLyv8NMDEaGbmN3fLDsRYjPPvCeY2jq4e fG8/H767C9eaOdErCZbm6OfnSMPKn7h+flzoCa3N8oxauuKTCE8OewmUFBo4yiNhqbYBHyUnxc12 NCKgtPSs/WOTkhfOcWIQiQz3qEUxfhzdiX23NB4rJqoBCkc2MNDFolSeUDiKsYWluRGZwNoD7aHy BKYWEkM0YHI4ZgYkoJeRaCLVjMNh0khaSBROz5hlakAc/yPbXw1wumHQKASaubm+/fm3q510IQZI NCiUU4E9IFFojYfaFABNm5manRHnrD+xT4z/A1P+MbQNCmVuZHN0cmVhbQ0KZW5kb2JqDQo1MyAw IG9iag0KPDwvRnVuY3Rpb25UeXBlIDAvU2l6ZVsgMjU2XSAvRGVjb2RlWyAwIDEgMCAxIDAgMV0g L1JhbmdlWyAwIDEgMCAxIDAgMV0gL0JpdHNQZXJTYW1wbGUgOC9Eb21haW5bIDAgMV0gL0VuY29k ZVsgMCAyNTVdIC9PcmRlciAxL0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGggNDU3Pj4NCnN0cmVh bQ0KeJyFwodS2gAABuDnsrV72zpREVEEkaGAoBDCCjMQ9h5hC4iADK1272Xbx+of4513rXf97hub NI6dv4ZTfBP/+jR3nEuMz1y8gbPETa6Zf2sOSa6AvC0g7+C8Be/yF6z3zt9fRNsDId/+cIn7SIQO fLyM1BMxd0LsnFhxPl1F1zOUuCYl7qk19ExLuTMy7yyu+3BO7hPIacEGPa/w44IygIuqgFDFCNXM kjoo2gyKtkLLqAmLNeEVbQRXdVGUbMfW9DGpPi41xGWGhGwnsb6bRLkxtWFKKUxpBZFWEhmlOasi s2oyp7bkNq35LbQVNPaC1s5qHazOUdRRpW2qpHeW9a6ywV3BHU9111M1emtGX92E9B6B/oY50CAD TZJpWpiWNdiyhvZtobYt3LZj5MAR6VDRDhXrOjHec2Hi0I3JvgdTA2964EsPkc6M6OzIj7mjAPeY yR8zhedB7kmQPQmxp6HiaRhLLyJYfhnFCr6KYfV1HGv4JoH1t0ncw3cpbOD7NDbxQwZb+DGL+/xP uTb/cx4P+F8K2OF/ZbuXi91vxd7FUu879/Byuf/jr5X+WWXwz+FZdfjzyrXhr9roP+uj3/WjK/4B qNyYIQ0KZW5kc3RyZWFtDQplbmRvYmoNCjU0IDAgb2JqDQo8PC9QYXR0ZXJuVHlwZSAyL1NoYWRp bmc8PC9Db2xvclNwYWNlL0RldmljZVJHQi9TaGFkaW5nVHlwZSAyL0Nvb3Jkc1sgMCA0NjggNzIw IDQ2OF0gL0V4dGVuZFsgdHJ1ZSB0cnVlXSAvRnVuY3Rpb24gNTMgMCBSPj4+Pg0KZW5kb2JqDQo1 NSAwIG9iag0KPDwvU3VidHlwZS9MaW5rL1JlY3RbIDYwMC45OCA5NC44IDY0Mi42MiAxMjcuNjhd IC9CUzw8L1cgMD4+L0YgNC9BPDwvVHlwZS9BY3Rpb24vUy9VUkkvVVJJKGh0dHA6Ly93aWtpLnhl bnByb2plY3Qub3JnL3dpa2kvWGVuX25lc3RlZCkgPj4vU3RydWN0UGFyZW50IDc+Pg0KZW5kb2Jq DQo1NiAwIG9iag0KPDwvU3VidHlwZS9MaW5rL1JlY3RbIDY0Mi42MiA5NC44IDY0OC42MiAxMjcu NjhdIC9CUzw8L1cgMD4+L0YgNC9BPDwvVHlwZS9BY3Rpb24vUy9VUkkvVVJJKGh0dHA6Ly93aWtp LnhlbnByb2plY3Qub3JnL3dpa2kvWGVuX25lc3RlZCkgPj4vU3RydWN0UGFyZW50IDg+Pg0KZW5k b2JqDQo1NyAwIG9iag0KPDwvU3VidHlwZS9MaW5rL1JlY3RbIDgyLjc1MiA2Mi40IDE1Ny41MSA5 NS4yOF0gL0JTPDwvVyAwPj4vRiA0L0E8PC9UeXBlL0FjdGlvbi9TL1VSSS9VUkkoaHR0cDovL3dp a2kueGVucHJvamVjdC5vcmcvd2lraS9YZW5fbmVzdGVkKSA+Pi9TdHJ1Y3RQYXJlbnQgOT4+DQpl bmRvYmoNCjU4IDAgb2JqDQo8PC9UeXBlL1BhZ2UvUGFyZW50IDIgMCBSL1Jlc291cmNlczw8L1hP YmplY3Q8PC9JbWFnZTYwIDYwIDAgUj4+L0V4dEdTdGF0ZTw8L0dTMjcgMjcgMCBSL0dTMjQgMjQg MCBSL0dTMTMgMTMgMCBSPj4vUGF0dGVybjw8L1A2MyA2MyAwIFI+Pi9Gb250PDwvRjMgMzAgMCBS L0YxIDExIDAgUi9GMiAxNCAwIFI+Pi9Qcm9jU2V0Wy9QREYvVGV4dC9JbWFnZUIvSW1hZ2VDL0lt YWdlSV0gPj4vTWVkaWFCb3hbIDAgMCA3MjAgNTQwXSAvQ29udGVudHMgNTkgMCBSL0dyb3VwPDwv VHlwZS9Hcm91cC9TL1RyYW5zcGFyZW5jeS9DUy9EZXZpY2VSR0I+Pi9UYWJzL1MvU3RydWN0UGFy ZW50cyAxMD4+DQplbmRvYmoNCjU5IDAgb2JqDQo8PC9GaWx0ZXIvRmxhdGVEZWNvZGUvTGVuZ3Ro IDc4Mz4+DQpzdHJlYW0NCnicnVVNb5tAEL1b8n+YI47q9X6xy1ZRpMZJo1RKlcppeoh6oIATFAwu 4ET5953FOAEDbtqLDfa89+bNzM7C7BqOj2dX88szoCcncHo2h9/jEQVKKKWMc6pBcwqupJBH49GP I0jHIwb3rzGUKkZlK2h5NB59G4/g/GoO0BBgbwLTGusapWstTzDWp8UFMQZQDZQmjBpwjUsoA06U UgyC1Xg0u1z595GicJZBnzCvhWcXC67hvqgdMOMRj1taoz0QDL8FCI8R7b766HCJTpW4lEz2ZG7V ZKU2u/bLMspTCAqkUgKKILVwyTXhFRJFFVUHqydr4dMbJPwsAJ3cLK0TWxoGCnOR6EIZwgzcrJr6 1LrFVybq14vx6O6YCn168hNuvoxH58i55WX7vB7HcvAm752zuL6cn8NEOnEBPqxzfMrKLMgmU+4k sMxymLR5d2SCe0TukT3FebnxkyGIpJIo2YaEUfFYWtF1ARPtPD/EwQNMhOMniU0he7afxT7j1hzB fvUaFIpoXQv4lm21QVbrDdmjfOI61nGQpWkU4EMZZylMjFM++CkG2//CuFgn/suAEZdSItsy08FQ jyivHZulyUu/o143WDWxg67zqjtJVawkfoyGas1R0G1jb7/Oh4I9gSewHd0k7gyw+64B5solsm70 v41oE+l8CsMorPtSbNbrLLcDM2jcZcRTbYYljrNwcvDDMLbNtiOq3kZ/uUmD7c+xjStfPvzbvHEh CJ74rVacBskmjNP7jwMJMs8QKdqgg8VW+8VuJ2EoEYwDM5rg6nsttuwrdhuJG5hg/ZtI5zbE9ZuW Q7mjmLeHOJi7fl/uShDO/yv3BtIJknj9K/PzsJqUBz/HLgxNidZ2e7XgB414HSOdadiZwcWIW+4v ZjronaEG2vm+OB0ac+YihWiH51EY55Ed4Wqch6wrRoxsIw9aNy3ruPkVMZ7sHHjNQbpqt9m3t3J1 OzmXK1xbT5FdqzCZamexWdutXh1ke6zxJ7xoqseBu8ZIIlWTvr64OseU92UnsdmKt+Edx38ALeHx 1w0KZW5kc3RyZWFtDQplbmRvYmoNCjYwIDAgb2JqDQo8PC9UeXBlL1hPYmplY3QvU3VidHlwZS9J bWFnZS9XaWR0aCAxNjUvSGVpZ2h0IDY3L0NvbG9yU3BhY2UvRGV2aWNlUkdCL0JpdHNQZXJDb21w b25lbnQgOC9JbnRlcnBvbGF0ZSBmYWxzZS9TTWFzayA2MSAwIFIvRmlsdGVyL0ZsYXRlRGVjb2Rl L0xlbmd0aCA5OTE3Pj4NCnN0cmVhbQ0KeJztXQVcVNn3X7vXXnMRRMTubhFEEQw6pLu7u7u7ZhiG oVsaVDAxQOwWMFARULED+H9nno4Ig4u7xu+/6/mcz/3cue/cc+Pce+K9+9789tsv+AW/4Bf8I5g3 d97CBYuXLF4yevTon92XX/AtoW/fvps2bbKzs8/IyKyuqn737t3bt++etLy7d+dx6xPk36Lk3r2G QxWHgoKCJSUlJ0+e/LO7/Au+GgYMGCAkJJSelv7y5av3799Dps+fv7h//8Hly1eOHzuelZkbE03O 21d46tTpq1euPnjw8MWLF+/oAMr3Z8+eNzMz/yX3/xcwcOBAfT39pkfNbW3tb968bW5+fPXK9UMV R7C7KRRKSEiou7u7ra2tmZmZvb29t7d3ZGRkIi0xNzf32LHK69dvPn78FLXev29re9+empLGycn5 swf0C3qEvXv33rxxq+19x5s37yC4O3fuXr169cyZM8eOHSssLExJSYmJifHz83NycrKxsXF1dQ0M DIyNjUV5QUFBRUXF6dOnsf2hBKAKIPH2to73796HhoZOmDDhZ4/sF3wGmzfzVFWdef++/e2bd8+f vXz8+ElLy+Pm5ub79+/fvHkTcjzDgNLS0sxM+jaHlJHSaLTi4uLjx4+fP3++urr67Nmzt27damxs fPbsGTR7e3sHAfjp6Og4ePDgnz3KX0AHCzOrt2/aXr9+2/r02eOWJ8+fPYcP1t7eDosM2Z0/f2H/ /v0BAQF6enqysrK7du3i4+Nbv349Dw/Pjh07xMTEFBUVTUxM4uPjDx8+XFdX//Tp01evXrW1tXV0 hvaOU6dO/fnnnz97rP9pwI6jUpOftb588uTZ/fsPHzU+ev78OYTz5s2bu3fvYsNiL5PJ5ODgYGxP Q0NDeXn5PXv2bN26lZ9/2/btAjt37pSQkFBTU4O4XVxcgoKCQFxWVgaFgN39mbTbOiD/e3cbVq9e /bMH/R+FKVOmHqo43tLS+vBB462btdDb2M4Q9+3bt6G9Iej09PTk5GRIMCw03MrSTk5WUVJSWlJC EntcWVkZmxq2Xlp6r4yMnJKiqouLR2wsCeo9Ozu7qKgI5r6hoYGQNXY63Wt/3wZj8erFG3k5hZ89 9P8czOKeXXPmUuPDprra25cuXa6vpyvhO3fuQNCJDIADlpGRERQYoqGhA/mqq6tra2sjhaDl5ORQ gp2Ofa2lpaWvr4/dDVWvoKBgZGialJQCg15SUoK0srIS5gChHNT7yxcvX7+G2nj7+lWbnY3jz56A /xBM+GPC0SOnbtffvXjxMkzqlStXsKOrqqrS0tKio6Pj4uKwSSPCI+Rk5SBciHX37t2bN2+GHl7J gOUMWLFiBfET5Vu2bAENiCF6LAlNTc2cnJz8/HykWVlZcOSgN1paWhobHzU3t7S2vnjc8lJZUf1n T8N/AoYMGZqetu/69VvV1TWInmCgIQ54WYiYYHzDwsIiI6KhpbF/4YZBjhDrokWLZs+ePX369KlT p44fP74zN5RwcHBwc3MvXLhw2bJloEddWHklJSUdHR3IGiuHbtBLy5qamuAP1NXVPbj/kKFVHm7f JvSzJuG/A1ZWjtXV5w7sP5iUlJSbm4s9mJWZZWZmZmVl5eDgYGRoBn9bSEho3bp1CxYs4OLimjJl Su+ZQ+6E0KHwofzFxcVjoumhOhw56I2LFy+ePHny6NFjWGBVp2uKCysmTJj4/Ub6C/i2bC8qOpCf X+jp6WlqampsbAybu5UBiLDWrIGQ10Fvb9y4ce3atVDUSxmwZMkSpH379u1NE8OGDYPQoRNERUVV VVVRUUZGRkREBEsIP93d3e3t7e3s7L29fRzsnNRUtZZ8hKWfA0qgN773hPyLYfjwEZHh5PLyCnt7 h6DQ0Cu1tR1fA3aOX+FfsbGxQehz586lUqlf1Qrgen39tfr6tJycCRN/7f2/D0oKWkWFpWlp6RA3 tjM1MfF6Xe3VWzfPXblcff7c6XNnq86dRaY7Xrp+DVKAg716zZreN8fOzn7mzBlUvHLzRneeaOs0 A5FHBy7fuI7OXK+vBfGlG9dgXAYMGPD9puJfD5MmTvH1CSkpLvP394cx1dDQgFE+evz4/UePGhob 6+7evV5be+3WrRt1dSwR/jRdcDdujB07tjfN8fPzNzc3o8qt27fBuQs3oi2kuHq7oQF9eNDUdL+x 8U5DQ01NzbZt2773bPzrQWSPTFRkbHh4hK+vb2BgoKurKyzjrFmzbtbWNrY0P33xHNj89EnTk8ct rU+Bj5+1Ekj8RDmhaRFb/WVb8PoI4ofNTWAOtgRDghWzFbTY+vIFyvHzwaNG+O2FhYXQCd9/Mv7l MG7seAtzh4z0TEjZ29sbG1xLS2vNmjUTJ07EVnrY9Ohx69OXb9+00e9ts0D6nbGOjrftH26D6+rq 9tQQ/DSsB4Ls2csXr9+/I+ow+TB5vm17/+LNq1Yss+fPmltaEKBhHQ4dOvRHTsu/Fdav2+Lp4RsZ Ge3s7Axxh4WGIVbi4eFZtmQ5TCQM5ZMnT953eajRM7x58wZuc/dWEJtfv3699y5ZW3v769evGxsb L1++jGj9x0/LvxL69OmjKK8eE0O2tbVzcnJCCGxoaIhoa/fuPfCcOTk5EWHFxcU9e/asnfnM8q/g 6tWrv//+e+dWEGqBw1fIuq3txYsXDQ0Nhw4dWrRo0ZTJbH9OnfazpujfBJMmTdXRNoqJITk4OEKZ BwQEYF9v2rRp+zZBzDMs+ODBg0eOHFleXo75773EExMTCf5YLYjiey/oDoaTD30CN41CoYwbN27r Vn7BHTt5eLZ36TlsDQJwPj4+BOxqDEBm7dq1c+bM+WGzN2PGDOY9AWQQXf6wpv8eLF28ytjI3M8v wNHREcrczc0NWxuB2LRp7FC/8LQJi8nFxQVVDO3ae4nr6OiMHz9+//79vRc0mMMWPHr0qLa21sjI aMyYMegJQ9vwcs2Yi2BBSkoqIiLi1KlTIPsyK/Q2ISEBffjyfb9ly5ad6gTJyckRrEBI6NMd3dGj R+vp6ZWVlWFNdm/35cuXJSUlCgoKvbzv9INBUEDExpp+I4vQ5JgfbG1paZlJkyaxsbENHz6cSQmD DkG8ffu2l7KDROBifZWsMVcPHjyoqqqChkGLEhIS8BWRR6/OnTvXe1ZdABZh3bp1LIevra3dm46B DMTz588nk8noZG8aRYf/1w7jwXDvlVFxdnJzZGhyhGCYXoh7h4AQNiYUaRdnWF9f//Hjx1C2f3vm ewIYaxj3O3fuwHXHMhs7Fo2Pg4a0s7NjOb0QAapg7dEfnr58iaWFXn1Z80RHRw8ZMqTLDEAD9KZ7 /Pz8iB//UqV0gZs3b44aNerHifOvYMSIkYoKGr4+9POE7u7uMNybGTBtGgfsNeKmQYMGdakSFRXV 2tra9fQRK2jvaG9r/wsyELx+8xrYwoi20AeixWls0yDrixcvEmRv3r4BDdK39JPs9KNTMCuEzoff funSpRs3bkAtQO7tdJG3E02/b3sPYlREhuBz7NixLhK/desW0Q0C6YcsPuK79+/QIlERer776Jhs u5ej3Q7GmsTE/jhx/hXA490ro+Tm5gGTDYcKsS1kDaXdr18/yBpRGDJdqkC9FxQW3G2496i5icDm xy2dsamluRHFjAxxlSDDz875+w8f3Ll3t7a+7lZd7dVrVy9euigmJgb+/fv3RwolQ2xqNFR/5zYo 791vQJWHjxoJhHALCwsFBAQIc4NNxMvLC6EwGyK68aDxYcOD+6gOJMTh5+/PHMvUP/8EDVGFQOag gER1FD5++gQpGkVnbt+9A1bgSYyFWZFAZrvoKurevd9w7dq1HyjPvwDO6dxysiqenl6QNSJuCB2G UlSUPu0DBw7sydmYPGXK/oqKc5cvV58/X3Px4tlLl7rgmQsXcAlIZJASZEiJKtXnzlVWVR09caL8 yJHSgweTU1O5Z836jWFckC5YuBCybn316kRV1Ynq6tM1NUQtAs8yUlpy8pCPhoaoBZgzd+75K1eI DnzW6LlzJ6urT505U9/QUHX27KSPLzXwbt36sLkZNERvmcisDgT9CUZXDx46VHzgAIVGy8jJwc8z 588TzAliJjLHi4pV585dvHoVDuf3lmMvYRb3fHk5FR9vX8jaz88P5ht7REFBkbjKnMbusHLVqgMV h8qPHD107Pjh45XdEeVM7FxYfuQYMgcPHykq259bWJSdl2/n6DRixAgmZwTs0OpNT5+VVRw6cOhw xVE6PVJURHqk8gSw+tyF6dOns+xhXmERWgEls2kiRfX9FYcOosPHKzds2kQQa+vqNrY8xaXOve2C peUVBSWl6Tm5OwSFmJ7MkqXL0Lcuo2OOEa0TeOTEyZNVZyb+zzy5mztn0d69ShC3v79/UFAQAjGE sWpqvTo4JC4lXXSgoqDsQH7p/l5iXklZXnEp0tyiktTM7KT0TFEJyS5s9YyMX3V05BQUg4Zepbh0 X1EpUqJ6fsn+89duZucX9dSrk+cuFJQeQJXOCFY5hcXIFB0oLyk/xMPLSxB7BwQdPV2N8h67Wlya lrMvikzhnDGDqMJcYNb2DmjoSyMtKQMBmuvuH/4smDN7kexeJU8Pr2AGYHcjztXQ0Ohldf+wiNTc vOTs3N5jUlYOLTM7IT0zJJo0b+GiLgwnT5168MRp8EzMyAYx0kSsiqwcoiLyafvyL9yqb2xsPM2A U58DSu60PI1PTe+OlOTUuORUZFJy9m3YRI/yBgwcSE3PBEOwZdlPlKMDlNS0TTxbuo9dTEr6C2Mn up2QkRVOjv9nIvqWMHPGPBlpBXc3j7CwsPDwcB8fH/hIKiqqf1kRKzY+Pr75XQclNYOUlNp7JCen kZLS7Fw8xrB6VCq5V+5I9fnohKTYxJSYhGSkzIpECTIxtGRycnpSdl56QXF28f6c0gNIgRmFJdT0 7ChqYhg5PiIuoQuGx1FDYuLCSPFgvmT5CrTFwTkDfGJoKcDu/UQhWoymJfuHR7E0aiJS0plFpSzH SO8qvXpqVHyiilaPD4x+GMAHI4bAwT5TRprumSO8QliKDQ5fV15e/svVOTk5z5w586Stg5ScHklJ jIxP6iVGUZNJyRlIB/XwipC5nQMlNQs8w+MSunKmJEZQaEhDydTgGHJwTFwoKR5kEQziMBI1jExF JiSWEhJDwaXOiELQB0bGBkTEhJIoM2bSb3XybOUvOlLJoiFGW/Ty+CTwVNc1YNlVdT2DtIIS1sNn dBWIpleuYX1750cCwisivJ00caqYqIy1tS2JRIqLiyOTyYIMGDp0WE91d+zY8eTJk9NX6khJGdEJ qcDYxLReIikpvaD8WMv7DmVNHZbMIylJpMR0UMbQWLBFWygPj6MFRpJ8QyP9wqIDIkiBkeSASLJf eDQQmcBuGBRFR1D6hkR6BYWHxiYQLr2ajn5e+fFoakr3tlDCGFc62uLdtoNlV32CIhMy9vXUT6RR CSlgzlKJ/WBAbEuEq8OH/y4qvFdXRx+CplKpqampQkJCu3bt4uHhZVnRwcEBoWvZ8WpySiY1Yx+B CZl5H3Ffp8LO5Z8wKafw7tO391rfrt2wqQvzwYMHJ2YVEAxZcqBl5SVlFypqaE9j52DjmD7taxG1 2NnZ2D8caAyIImcUHfi8/58NBNKMT8tmn87iRujUP9mSc4toWfksh0l0Pi4t2zcs6luK7R/A6NGj R44c2ee3PruEJOXllChxlMTExLS0NFlZ2T179piYmHehR/BYWFgIWWcUHKCkZGMqknMKEzPzMf/I IIWk8BMpM09c6oz0S5n5uaWH6WvmWNWkKVM7NzFs+HCwpaRmE3WZ3Jh80vJKMovKdwqLfYPhjxmT kluckltE8O+CRLu0jLwoSgrLmw+beLcePXsFZMSgulbPzE/OKUpI36eha/jPu/pNAOIm3rjcsJ5f QlwmPDyCRqMlJSVh/woLC5uZfSbupUuXIha+/uBpLC0tigrHJpOSmkNOzoxLyUImLiUbGSKPQlxl /CQK4dnmMBE/QYBMdkkFJO4ZEDZw4KebtHAnQmJhjhNjEtIIMoLtR8xO3VcKFJGQ+Y1VxD1nzpwl PQPxgJJr5kyCeNnK1bllR5ld6ozMzsfQ0g1MrVjOnpKG9v7KM0QPe6iejerrNrFw6X8KjBgxgp2d fejQobO5F0qIy7q6uEHcycnJ2OPi4uLS0tIzZ84iKJWVlV++fJlffjwgAqYwLiSWGkqi0dPYhDBy IvLI0JFEC4qmgIYg+1DIoGHiB2J69YT0wgOPXnXIq2p27pWytr5XcIRvWAyYgBvR1oeKJBopKavm xn1LB7fuw4F7+eWb8yl5JeCzcQsfQS8iKVNQcSI4hkr05zOMhb9HDYqm+keQ+LYLspw9R09/CLSn 6igPjIoLio77Y+Kkbyq0vw+w3RwcHGxsbOPGThAXk9fU1E5KSk5JScnJycHUSUhIaGnpDBw4MDIy 8nlHRwgpydknxMUvzD0w0iMoyj0wAqlHcBQzj3JcBY2jV6CjV5CTdzB+guATJRMZxESaVXastPLc itXrmb2aNp3T1s3X3sPfwTPQ0TvIySfY2Zferpt/uFtABLilFdLVgr+/P3Yr6DEEfn7+ffv2vevo iKJlgoDJHPSu/mGu/uEufqHoDxhqGVkwHwFom1gGRFNRDv4s0CfEyTvIxTeUaeg7A4yOT2isq18Y 0b3uiHJwtnRksSx/IkyZMmXBggXDhg0TFBCXlpJFLJbBAE9Pz40bNy5cuPDEiROl1ddtPQItnL2t 3fyQsXEPACLTOY/U0tnH3NHLzNHTxM7d1N7DDOjoZe3mT1wl6JlIVATaeQcXn7wUEEObMOnTCYSF y1YY2riY2LmZ2rubOYCPJxDMzZ28zOk8/WJTC1502rbIU7LLHH1CCc4gAFq5+lm5+Fq6+Fg4eZnY exjbuclr6o/4eJ4KniouWTp7d27iM3TwMHfAWDxYRtwzZ89zCYgydfAw7akuUnvPXeL/W+frxo4d S7zNt3DBCmkpBUsLq8zMTKh0Z2dnXj6+m83NQdR9upauupYu+tbuhrZe+jYeBkBbTzoy8vRCa3cd CxctMyctU0c1I1tlPYtZ8xat2bRVy9RJz8qFICMomfihuq0n6pq7BOWduK5maDNo8Ic7jVxcXDNm zVXQNlE1tFY3ttM0tdcyddAk0MRBy8wR/SEYEkyIjJ6VG8p1zJ11LJy1zZ00TR01TOzBVs3ARk7T ZNGyNZ0FN3HKnxiXpok9HZnMO6GGiYO6kd1OcTmW87aWZ5uOpbPGl6rbaxjbzVu84kdIsdcwatSo uXPnrl69euLEydKSynJySiEhIbq6ulZubofq3hq5hCjoWSvo2ygbOSgbOygZ2SNVMXZESi9hFCoa 2MrrWcvpWu7VMpfRMN0tqzl+In2f9h8wQEhaVU7XCgSd6zKRKEQGqaFzUGxhFd9uaVQUF5fctm0b nIphw39fvp5PREFbQsVQUs1YWt1EWsNEWtNURtNMVtsCvVIytCOQ3gddK1l0QNNUSt1EUs1IQsVA TElPQlmfd6fkdO55ffv17zLw2QtXSKkZiasYSPSI+uAzf/lalvPGt0tKQtXwi9UN9mqajRr7x/eW 4NcCnPMNGzZApa9ds4V/q+DiJct9E/ODs07t1XMQUzWV0LCQ0rKS0rSS1LSkZ7SskX7Ia1qJq5uD RlTFWFjRYLe83gYBsSFDP510GjthioiykZiKiaSG5adadA5M/FCI1MA1wj48a9ailQICAlJSUpaW lhoaGsuXLx8wcNA0rrkLVmxat11sm7iKkIymoIymkIzWLlmd3XJ6uxX0kO7cq7NzrzZxSUBKYzXf Lu5FKydMmdZ/4EBmZ7ro5PGT/pzGNW8a15yecS479/yhI0aynDQ2rjlsM+jYU3V2rrkc3Au+k8j+ CYwfP554A3f0qDHTuJfElF+3DE4VVTcTVjERVTMX17T8iFZIxTToiLyYuoWIqukeZWNhZaOd8vpC 8roLV23pHp/OXb5hj5KRqJoZUZFRlwWKaViAp3V4loZd4PjJbJKSktR4KoVC0dHRWbFi5XR2rn59 PwRrg4cMGzlm/CR2LmK2mThlOjfKR47pupv6MOBHzOP/H5g2bdr8+fO3ikhlnH+u4xoppm4urmEh id2nYyOlY8tAm49I/4lLIIAQRVVNhZWNdyrocXDPZ8kZbjCfmDIYSmhafaxu8znaMnnKGjr5pBzF Qtq1RyQuLi4pKUlJSUlUWEJQQGTu3HmAcePG9eZJYm9EjIhjGAOGfwSWx7R62VZ36EKmpqa2jwHO bm4//WEoAnAnf/+yG68MXIIVjRyVTZ1VzFyRKpk4Ie2MKFE0dlQwtJM3sJXVs5bRttgjrz12wpdC y3ETJ8vq2cgb2KFiF26d2RKNGrmFU8svC8mo6ujqampqKimqKitpb9zAB+9i1qxZXc6E9DS3vYGs rKzmbnDnzp28vLxNH08+fEOgJCaevXz5wpUrBSUl30PbbN68GbGzgoIC7PKXKRGLHTp0qPTiA2vv CFOXAGNHX0M7uuesb+thgIydl+FHNCDKbTz1bNy1LVw0zZyEZVSGDhv+Zf6ANZu36lq7GdgyXPpO DD9ja+uBvIlLQGhq8b5TNzfyC61auVpRUUNGWg3zD3FPnjy5y2spfxugcw4fPfqwpelhc1Nz61Ng 09MnD1qaGxofEpGdl5fXN2mIgEmTJt1uuFd/987t27dNTU2/IWcCoKnAGd1+/KzVzMzsC5RYDA0N DQdrbnmGxSGQdPQNs/cOsfUMsvMMtvMKRr4LohCXEE1buvpuFRLu27frqUWW0LdfPzUDi554fuDs Sefs4B3qEUquvPog/8i5WXMXbOMX2cLDKyQkhPChyydf/gkg/GxsbHzz7m1LS8uFCxcqKytPnjx5 69at1tbWF6/ohyExJzAc36o5WAp+fn4+Pj6kX/Vhk14CbDFxDvzdu3dwuXsiE5Hcm5xfFkFNCY5N CIyi+IXH+oRGe4dEeYdG+/SAuOQZFOkaELps5Ve8tg+YyjbNIyjCKzSqJ87MptGN4FhaTFJWCJk2 esxYbG345wgfvuFpbfilHYxXHmpra7m5ucF59OjRU6dO9fPzQ2F7e/vTp0+3bt0KSiwzFPr7+xO7 UlBQMCcnR19fn8mqf//+WI0kEgka8uDBgyBeuHBhl+bAxIkBioqKXS7BZYImKSsrO3z4cExMTE+f EIRmMzIyys7OPnHiRH5+vo2NDfND8VpaWighlNLr16/Dw8PRW1FR0c7VBw8ZomdiTklJj4xPCCNR gunPgqP8wiIJ9A/vEQMiol28fDg4OdEx9P+rzJzgHuEvcAYyWw+KjImIo8anZbr5+GFCsHq/7UlO a2vrDsarPZBRZ0uKddXW1oadgl1PiNvc3JyYSWgAxIYdjM+3Mt9FhW5E+Yez5R9fZ8CCMTEx6dwc 8ZYK2JaUlDAL4Rb6+voyPgzbTqQdjBcrVFU/O0eE5aSurk68mtTOAKKVs2fPIp4CwbVr1zp3gHg1 w97evsuQBw8ezDGdk4NjOjv9QTDHNHYGcnxEdnbi0fCnEgbOmDlz5cqVCJRsbW0jIyNTU1MPHDjQ nTlLQM+Jhrqz7Y7oFQfnjIWLF3NMn/4N1TgBpaWl9FuvL15gwn/rFJLv2LGD2CN1dXUwuCiB50ZM Jl35v3mDaUeG+P6PoaEhQYwSaAlYTywS4nUqzDyxWgig0WgohKXw8fEhSrA3YT4gmkePHt28eZP4 liBYEWRsbGzMupmZmSh8/vz5vXv30AqcyaamJhDfv39fXFwcPjY8TOL7tKiOS+hGfX09tFAvpwIc oDqgkVatWjWTi5uPV1BIUFhIaJeSkjI2BTpMpVLLy8uhVRBWQL0ghTKBHjt+vBJ9A83atZ/dicLa wKxiyGFhYdBI8B6lpaUlJCTgeFtZWtnZ2Tk4OMDBYByo2MKzmW/LFoE5cxZiU8+ePRuW7hvaUALA 8GZtbTtDKMLCwszyiRMnFhcX19+5c6uurqiIfswVnuHFK1ceNDY2tbQ0NjXVMcrJZDIuQYEz3ndo wPxHRUWtW7cOHdbT06urr7/T0PCouTk3N5dYRQi7qmtqmh8/xmLA2Im23NzdUf3egwfY79ikiAGh J2/fvdvy5Mnzly8Rfv7GWITWtrZEK1evXsUUwS6vWLEiJCSkpqaGeD9x5MiRUlJStfX1T1pbGx48 8PDwgKAxqK/6TxAsbHQeSx1aa9u27VoapnY2Lna2Tm5uHpAsfBsM/OHDh1jq16/fgNHB0LALCgoK CgsLMWOlDChjwP79+5GiEKsiJSUFcxUdHZ2WlgYCVDx+/DiUQ1RUtIW5hZ6uoZ6usY6WKR+vAC8v L4zFjBkzvsd3zpcuXVpZVXW1rg7iDggIwDRCS0NkEMf+w4dzMIyyslWMDwotXb782OnThyorK44d yy8pQSHxNA16ODUrq6yiAqip89kRLH0jo8OVlUdOnDh47BhhgGbNmXP01Knj1dWV1dVcjHeBl69c SbcO1dVoqPPrltb29ifPnj1ZU2Npa4uf0zk56xoaSsvL0atVnT5whD782Wn7T5w0CczRz6MnT3L9 3XeN4RphWqAu4JZgM2qoG4UGxYUEx0RGxmRmZl2/dh3ODN2PffECOgRyr62tO3XqFHY91gMhd2wE 4sOnAEIbYJ1AHUELYalA7WBfoDw0NMzFxc3FycPFydfE2FFwxy4REREsdUTZhDr95rBhM09pxdG0 nLziiiO1DU3vOjou3qzPyCukpqTHxNMiSJQt/B++87NHXLy88lRqNv0INA/fJ+W8YRPP2Ss3kzJz YyiJIxkOJDP8X7NufVZBcfq+gqT0LOIS/44dlTXnURIWTRrIuI1jYml98uzFI1U1mBC4dtitxJHv QyerU3PyUrPzVTXpr5pKychXnr2QnJnj/DEqZHmTYQsf/+kLVzPzi+NoyV84XviXAAdp0aJFAgIC 0LrwFmSk5R3sfKMiEmKi4smk+LLS/fV19fB2XjO+Wvue/m8TbYQvAVcBOwU2BSnEStC8ZAAyMEMw WFVVVXFxFD9ffx/vQF+fUE+3MGUlbXFxCWj+jRs3fj9ZA4QlpHNKy0NjKUEx5KBockBUbGBErF9Y lHdQuIaeIVun7/yoaOrEJqWFkuK1DT9zvbT0jXL2V5CT05U0tbowF9wjQkpKC4mNs3b+8KRbU984 ITM3kpqkqsk4ftynj6OnbxQ1OSohOSYxDeUR9DOrieFkBEckdAPpqnX0p/8OHj60rDxySsY2wZ1f GI6qjl5iTn50QrJ+t8NmXwuITRBEYP5lZWUNDAxgUxTkVXy8okgxybHR1HgKLTMDocHJ+vrbkGNP rwATH69+9eoVpH/+/Hns+5iY2JDgsMCAsODAqMAAkq62uYSEpLy8PPY1jCAXF9d3/a8KK2f36ITU UHKCuYOL+F4FCVkFUSnZLfwC3Y8xWDm5xSSmR1CSNmz+7JSmmZ0TOGQWH9Q0/OyeyYABA9KL9ofF 0cIpNN5tAijp17+/e0AoJS0HfHi20pXGgIEDvYIjomlplLRsRXWt3aISu8QkhSVkdolIbBUQwmrZ KSI+4veRYOUXHh2Xmp2Qlbdj156exoLN7uztT0rJpKTnCOzskeyrAPOPCIWfn19FRQVCl5OT09TQ D/Inx8WmxZGSE6iptISUjIzsw4ePnjlTU3urFpYdihqeJFzEGzduXLp0+ciRI/l5BWQSJToqNiIi NiI8LjKcGhlGMzd1EhMTJz6lCwUOZcLJyfnN/fDOAAVLSs4gp2TGJKUvX8364SYBw4ePiKKmkFOz yClZ8xcu7nxJ18QcG/Ni/cPHz55hZohCBO+IU6jp+6JpKQFRpEGD6KfoR48ZCw7JuYWQ2ux59McK ffv18wwMReHhmkvrP38zpXOwjCjG3T+YlJTx6HXHgcqTTB0OF9rT05N5IGfosGGhsdSs4oM1N+5g V9JLhg7955+MgCmfM2cOfHU4hBoaGnCwlZWVlZRUzE2tgwOiadSchPjMxIQMWkJaAjUF0k+kYQ1g JSRR45Pi4mhkUgKZRCPFJMaRUiPDE+1sPdRUtOBSYuXARd+yZcuSJUugwL/HHacuMGf+wvC4FK9g qO7IPxi3+nu66z5z9tzg6HhvUAZHjfvjM22zaMly94Bw75DoVx0dMEzw92CCEU8FxyZ4BUc6evij FYKSnYMzipoOPv7hZOahNSUNXc/AiEPVV2HXXF1dEWgjnLl06RKq7xaV7PNRWDt2CXsGRQREUaAh 4dM6OzsjJoLdjKFlKGvq9e9P/2Lk2HF/eIVEh8TSXjK+FOEXTtIxsezlrc6/BFjzefPmrVmzBt4+ FDsCT8hdTU1NTk7ezMTCyd41KCAygZKRQstJScpJTKAjVkJSQk5oMNnTzd/a0l5dVVNGRgZLBYoC fiAfHx92BwKuH/YXJLzbd5o6uBtZOytrGX/5UcVG3u2gNLZxUdI26n51j6ScgZWjmb27tVuAvTf9 9q+lk7eJnauWsRUbx6dD6avWbw6hpFs6+2iZWBMvrQMmTJyMn4ZWzmb2nlauvtaufuZOXkY2LkY2 rtt2iTJ7NWz4CHVDS0MbF3NHT8bt5RA7jyALZx9LVz+xvUoEt99Hjjaxc0NdYzt3MydPsBLY8w2O ZHcGDg4OhGkIADds2AC5w+bq6upC9PDh4dQpKirKMkBTQxNhJoSLLYy1oc4A+gNNUVFIGXEWdjQ0 RudbCj8ANm7bvUtKaae0yvL1rF+aYMJ6vp2g3CWjunwdC8pBQ4YuXrlhp5SyjKaJnJa5nI6FoLji 0jWbhw4f0Zlsp5SKspG9gp7V5h0incvHT5y6YetOMQVtKVVDGXVjMUWdzQLC7FxdvxY1ZvyEdbyC ooo6exmtSKkbbxEUmzHn013xPn36Ll/PIyynKalqIKmqv0NcYfyE7/VnfLCz2OzLli3Dfufh4YGe x4aF9LFzofCJb15B+pA4RLx9+3YYF5gDGGhIGWvmp7zy3PuHj316YQH79us/YtTY0eMnDhsxqsul P6awbxVXsYnI2qNkvFvJ+M8ZLD78NXjIsFHjJowa+8fAQV96Aj5w8JDRDLJBQ1jHWag+/PfRg/9B FPZVwM7Ozs3NjS2PDYtdD5mu/Aj4CXW9ePFiLIyZM2d2+Y7TT4HePyL/MmX3S8wSzL+UtqWRR5SU lqWYuomApGr/AQO/XL33XeoN2Y+HyZMnf7/Y+X8cxv0x0cTJR8/GTdvCUUHLeNKvjz3+q2HMuPG7 xCQEd4ts5OH7X3j98xf8F+D/ANXK5mENCmVuZHN0cmVhbQ0KZW5kb2JqDQo2MSAwIG9iag0KPDwv VHlwZS9YT2JqZWN0L1N1YnR5cGUvSW1hZ2UvV2lkdGggMTY1L0hlaWdodCA2Ny9Db2xvclNwYWNl L0RldmljZUdyYXkvTWF0dGVbIDAgMCAwXSAvQml0c1BlckNvbXBvbmVudCA4L0ludGVycG9sYXRl IGZhbHNlL0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGggMzgxND4+DQpzdHJlYW0NCnicxVppWFNX Gs5GViCBkEBYEkLYCcgSIICAoLIngApYqMUFFEVc6oIoKtuoqHUXneLSmQodx9FqnVqBaltq1bYo 6gMiIFAUBESsiIBAljkXErnZWJ6nA+8Pntyz3POe73znO+/5LgjEODDnWNlYWbCMx2s3PTAwtnTx nRsSFh4hiAgPDZnj48g2ok43KQXoMaw8ZocLIAjXb970sRD6FRbgyqaTp5uaHBQjO3/AcF7O1w9a pSPoabh5LEkoCPHi0HSnm94w6FZ+EYIF+++LpEp48e9kYaiHucH009Rn88MEMed6lRmOoCJNGOxm pkecXo40u7mCqBNd6ikCiH9IEs62oZKmkaKusUtYZF6LRooQBq4sDHGgTR9LMtMnIvrSmBQhPEsN m2GoPU0cdc39hfH3x+UI9nqWwN1oeljqMP2Fqa0KbCSiof53PT19Q0MiCbxcdCrKnT4dK04ymSlM 74Ez6W2v+uHi2cP7DhSeL6n4o6tfDKu8GuVqMA17nOYuSO2GUWyrKM5KDA/w8XT38PabG7P2+I36 Lpg5iyId9PBTzZFsE5bY/oGCuP324cQAVzsLUxpUacq2mcGP3nm99vUoy+MhHF3c1HIkMQMXVHwg 0Hf/9KpgPpeio4UcbWLjEZ1XVvPhHHq/LcLGSA+AQiaip4YklRf15QeOvU9vFJ0qyM/fvc2dgoJN xMZrxcXHg/JWb6+cOrQ/Pz8/b8McElLzm/86kNghKf1qgs3dmdrw8a2CDr5WbfQsGj6V/x+o7gsq 1XCUSs45Yj80QhLtc9+otmnY7KIzFSSJrKAsdRyl0v4tZnKHQ5G9igZUGohr8uaa4KdiuSlOMdXq SUpfzNMfYYCih/2qWj1UkRdmoTMVGwfPCNguD4E9yjTuziQClkiseXKzGkOXbpppQpgSjyRZRf0o G7X9J2WvE5+y1UIgSU75b1U5SsrXexhip2RrI3S5S2QGlJzMKlbWu71rjDF6vpeG1DnDjWAGHonC UwyZbDaTro0Zly+GSKHoUYiYyZPU5x+SDfpsZVDSFWU6f0Tbzn+gjqJUWh/p5DZLuHpP4dVr1745 tmP+bB6bLHNQJM7EzX+Wr6ebC4CzHYOAROtyvAWbd4H4uyWSz5pkbMUzwm7KBt0bwOKl3JEoUfn9 cJt6jtLBM1erO2HCo7uuZIOvKQ4aH228reNlZ+fTaghVlflshntKWYssPIiefx1ugh2XGQwEs4Uy hTYUY02muGXUKlGRqMZ55XnA0Hbcmwq2Es7jF3jpDwm7axSudq8zOVqTsSRzqWyFG3xoRIyBX/5L zRRks6kWj1Fb8xEDjdCJfgEv+/2Rco/eVYaTCAsETqasX6E1CYfEGof+/d3YHN+V7O8eq/7lx3Q0 PVUh8veptqr2mYSKItqelHWbT9dCI5B489hLg6rvHMWLL9LSXsGeRR33fr7fAbfUE39ty6NjzhNg IJEyYY4oAveCrJvvcFxGkWyXl2teTtGjvTHCYphTDpTvT01cfQzuyZIsFv+mckexsiPnmE54h6Pw M76VvdoTMdwLTXbZVKOJY39ZeqB7Onz1ftvgZ2thLzgL3xf/9RA0KHSTdFXc+KVdoUh6xGLCTonE On8vs5G7rBOG6rOrQz3HrqJkHjscTqDv0tqooNnBn/wDTrI8dLmC14qfnEhLWPmloq/v4Ux852Ac ZCTFfLkSx5rEXVVVPKBF/ZEFtlTrI/CFE7193QnQpXBs3o7LUVjc57tD7c2d1ytcRge3MCce0FE2 8uX2xcmmhrPeoBBA5K+9szPIXJs4q05NnSJ+WnZRYXJfhhrj0QbxChrl1QrGxH0SaSHfOKGk4TMN SXTIVaPApZKKrT4MPIqcMGb8Gca3ax/BH7vTrcAxpPexQgB+FKU/YUOicQx5CFqhh0FB6tb7K/Uh qDXFHIxFWzvGeSObzpF0hU3y9CM6EoE0SnsPLzzvNfH8Akabki7rdskUh0ZgDAUVUg0o9cQjkGbZ 8KL+57WPlXHv6xU7FFz6O38dMHnrU/CywRybSZyLenSh7Fjs4Gpr4TipmtNqQ59ZYpDm+fCi9sKN aWlpa9Zt3JIhx5ZVUcEn4G3E+7jgcMF634UXvlppMoljUY/Fk+0SUTBd3/WwhgTqMLqXG6KZmfBI /2w9z9bWzjVy76kzMpw+vt55tkIof7OOCZxdO+o5vLBq3sRdEoHQMXcpl3XcywsvVUlDK6AhXM9k LTza/LnJlmxgHVkCb3SeK1QI5Y0f0cA+piYrHOBf+0wm5aXN5h+UdXyZPW50+YFvGl8JL6grSNxa pGCj7jTnZQoBoCwQuKSSmwzl2U5KUJr4xMiPApV7mArEx72jzqjRNKPoKw5z2Q4PAJLPHIFLYtyu w1t1rTad1AWOylt4R+OQPcqK913W4twx1KSko2gJl38eXvR2Awu4JCG4Hl74ZMHkvl1RHBbs0hD6 xHWXbynfedr3PtRIcbDt+u75tjQvBVVeHwe5pE40XN5J/+MzyVyxWcin9VJ1GCjfmbhVhdKzD1NQ mNrAm6afi7IT+ExtkvPnVc87ZHhRc9QLuCRCN7C07oW88PmDFKtJuSQCQeOvvaLOlN0XV/KtffNe qakarn50+37N8/b2jo721tpHJcWHtiSGuJlTsCis2dzUrDyAXIDtKYGmkAQnWkWvz86VISORR9Vh ubrb6U3YMVGumU/UkGj9PJ6rT2SEn1N/SA6V7U1JXZORBcbMzly/PDbY25FN14aElBYzIi1j27Zt GesWhXi52BgRISZaZJaDq5sMThyqtm1xY1PlTI3pYiSOamKij5NrEIxxcoMqB1HVXoGlDhpJ4CSp PyarcoKdLGydXMCYLjPsLc3oZIIsO4D3qns/AKG3+fMABlFr2FpIDI5IkoOIx1CiOsGdMVLjJ1Ut Ts6FrzYzRq7xSIJNuhqFO/BjxixT4rDe4OV0quHYc3a+CRmNJQyPTMBhUKO6S/+T0VBW6aneVkjD jaC2JoKiyZDkBSAu3nQY9lykjsdpNfnTd99tDKSP2BpjGPZP1QUX/bTVlab+/SjW30BEkIiHA9VQ uinNyp5lYGJnro1CEoydvPh2dCwSgTJddaeu6piXDhJrYOfJ58pySmgyh+fjbknGaHuclEBfOdgE KKMX/LOaPdN3fU88j0UfmROes0z1G1Tn6blmGqyAcb0GOLZU3K2Fgv7lWWvu3ruacLruAkebFfbF 47bWylwXXSTGalftHxVLLAh67tkVLW1V+1x1gJrTdki90fSyuTzR2vVaB/SSqiNMIE3cKtU63ODp OGGQr6sdh23KtuIlnFIRwX2Z9poEAiEY3BwH/7V2xT7oOle69Ffge0ADX/f1KRhRveIfvXXwfBBL X8cxTGMfDBtJUuJGQBuEloysWXe+PD1ewQMXBZsVF249qH78uK7xxZt+uE17v4sUCAThEKIWZf6n XqFysKNsEVuT+Kd88iew9Gae45IH0M1hK/BoSLV8sbT8Q/9iOz0ow/Es1iYJ8neoWrzDlCZokjf4 br/sx3U+2EMGzsJlqUARpm3fe76yRVECDTRe3S4UCIQFt18qHoRvHxYudtOUhEaa5gGXrFnjO/cQ sH/fvqPDR9bAq4M3oKk3N0IZ0M5oq41AplctnPdYKn1f//sLYIFf/OYAe0v+bGjuFVem59SDIftb 72fYA0cl0ljWtsMIiM0ufarujqgMSVvp9nBnHU1JRgwX+tLb9vC3Wmjpft9aCnVpuXLgOFjArsv7 91wCCmkoc1YRKP52MbheDT0s/nspUH9Ny46Dho3nduWfubApPAESf9VHl/sYQvNGYbSwI+D4pF6q Hl8HDT79d5IbEx5yFIHzvT06n8acVMgxW48lLgE+OHQtydf/UyAHRfkLwV4cPJoG1nywvbmpFZi1 OQe4cm9hrJdX4BxXayGoF/0z0pZGUHo9yyW2oKJDbU53dNie6sIYLkMDQQik0eRF370cwfI2aGih UwK4mnVlu+gzEppAhNu6GmzersytsHTBvcPgoTnNmqxLNdClLgD032yyJmJUzk1Th7mZZY1vxlBi /S03c8JsDcfgiNBf/Cf0jfftm/bKs2t8HVcBH2xYYWG0CJR2rmPhLLaBZa9dtRP8rUvNBe7V09HS 0tr+sqng6CB0rzTAURm6aGoyYPw0nq72aLfyjDtwq7lXg3IbaLtzKN6DoyGIjwDF3A22X/s3p47k rgx1oFtBu+hWCMXgY6BTxJcifTeBe95QYdwxMZRZ3Q6Wue36l0X/ffTVtvi899AH/8DZud8H0Zk7 AOPKdbMM1X5+MbOfmXiioqN3SIWnqP9lxcnF3nYmY1EE8WI4lN9InuPtam1IwjtfAU9FbnhK2D3I n2uqgIVE95IjLoLi4rBVwLziZw/r3kmrYnnJUBbm9cOnYuljX4djYPze1mo3DTlMFtd/6cGS2s53 olG9KBH1dT4pObjMn2s2NkUQyoOegqiyh0cjk3BoJH420Ff9O6wwROc8+Z4U3U/3EYIQOrDLI6JE PkRNMDOwWO5nTQLnw8M/qv013tbYjvzQ5fsuVz7r6ul7P/C+r+dVc+Xl/OXhXlzmeBTBvS74j4HB pkWMEW8izWkYGGxMMEJhjIVFr6A9+b7z+ib/GSvB2dO10pK7+s47QFP0pmKdkx5n2Y894EHc/WgL zy6lVSyVdJ9xH+tKyeF6zFm4OutAwdlzX5z4bGdafBDPnm00PkVAa8aagpOfepBHIhRxRtrxE+vd dZFIkuW83Zd/e3Drq92L+B5bfwVsHkTSqe4pJ2/e++1awRo/IzxlxtJj31feLyv8NMDEaGbmN3fL DsRYjPPvCeY2jq4efG8/H767C9eaOdErCZbm6OfnSMPKn7h+flzoCa3N8oxauuKTCE8OewmUFBo4 yiNhqbYBHyUnxc12NCKgtPSs/WOTkhfOcWIQiQz3qEUxfhzdiX23NB4rJqoBCkc2MNDFolSeUDiK sYWluRGZwNoD7aHyBKYWEkM0YHI4ZgYkoJeRaCLVjMNh0khaSBROz5hlakAc/yPbXw1wumHQKASa ubm+/fm3q510IQZINCiUU4E9IFFojYfaFABNm5manRHnrD+xT4z/A1P+MbQNCmVuZHN0cmVhbQ0K ZW5kb2JqDQo2MiAwIG9iag0KPDwvRnVuY3Rpb25UeXBlIDAvU2l6ZVsgMjU2XSAvRGVjb2RlWyAw IDEgMCAxIDAgMV0gL1JhbmdlWyAwIDEgMCAxIDAgMV0gL0JpdHNQZXJTYW1wbGUgOC9Eb21haW5b IDAgMV0gL0VuY29kZVsgMCAyNTVdIC9PcmRlciAxL0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGgg NDU3Pj4NCnN0cmVhbQ0KeJyFwodS2gAABuDnsrV72zpREVEEkaGAoBDCCjMQ9h5hC4iADK1272Xb x+of4513rXf97hubNI6dv4ZTfBP/+jR3nEuMz1y8gbPETa6Zf2sOSa6AvC0g7+C8Be/yF6z3zt9f RNsDId/+cIn7SIQOfLyM1BMxd0LsnFhxPl1F1zOUuCYl7qk19ExLuTMy7yyu+3BO7hPIacEGPa/w 44IygIuqgFDFCNXMkjoo2gyKtkLLqAmLNeEVbQRXdVGUbMfW9DGpPi41xGWGhGwnsb6bRLkxtWFK KUxpBZFWEhmlOasis2oyp7bkNq35LbQVNPaC1s5qHazOUdRRpW2qpHeW9a6ywV3BHU9111M1emtG X92E9B6B/oY50CADTZJpWpiWNdiyhvZtobYt3LZj5MAR6VDRDhXrOjHec2Hi0I3JvgdTA2964EsP kc6M6OzIj7mjAPeYyR8zhedB7kmQPQmxp6HiaRhLLyJYfhnFCr6KYfV1HGv4JoH1t0ncw3cpbOD7 NDbxQwZb+DGL+/xPuTb/cx4P+F8K2OF/ZbuXi91vxd7FUu879/Byuf/jr5X+WWXwz+FZdfjzyrXh r9roP+uj3/WjK/4BqNyYIQ0KZW5kc3RyZWFtDQplbmRvYmoNCjYzIDAgb2JqDQo8PC9QYXR0ZXJu VHlwZSAyL1NoYWRpbmc8PC9Db2xvclNwYWNlL0RldmljZVJHQi9TaGFkaW5nVHlwZSAyL0Nvb3Jk c1sgMCA0NjggNzIwIDQ2OF0gL0V4dGVuZFsgdHJ1ZSB0cnVlXSAvRnVuY3Rpb24gNjIgMCBSPj4+ Pg0KZW5kb2JqDQo2NCAwIG9iag0KPDwvVHlwZS9QYWdlL1BhcmVudCAyIDAgUi9SZXNvdXJjZXM8 PC9YT2JqZWN0PDwvSW1hZ2U2NiA2NiAwIFI+Pi9FeHRHU3RhdGU8PC9HUzI3IDI3IDAgUi9HUzI0 IDI0IDAgUi9HUzEzIDEzIDAgUj4+L1BhdHRlcm48PC9QNjkgNjkgMCBSPj4vRm9udDw8L0YzIDMw IDAgUi9GMSAxMSAwIFIvRjIgMTQgMCBSPj4vUHJvY1NldFsvUERGL1RleHQvSW1hZ2VCL0ltYWdl Qy9JbWFnZUldID4+L01lZGlhQm94WyAwIDAgNzIwIDU0MF0gL0NvbnRlbnRzIDY1IDAgUi9Hcm91 cDw8L1R5cGUvR3JvdXAvUy9UcmFuc3BhcmVuY3kvQ1MvRGV2aWNlUkdCPj4vVGFicy9TL1N0cnVj dFBhcmVudHMgMTE+Pg0KZW5kb2JqDQo2NSAwIG9iag0KPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0xl bmd0aCA5NTM+Pg0Kc3RyZWFtDQp4nJVW227jNhB9N+B/mJcC1KKheZcIBCngZBukwAJu120XyPZB cWhHhSV5JTlB/75DWU5M20y7L77OmTOXw0PBZAaXl5NP13c3wK6uYHpzDd/GIwaMMsa4ECyFVDDQ ikHjxqM/P0A1HnFYvcYwZjhTQdDyw3j063gEHz9dAxwQ8DeCiwGrrUkHrkxyfo5LSGotIBuYlHJm QVtNGQdBjTEcFuV4NLkr85UzBm5qOEcsBuLJ7WeRwqodOuA2o5nwaW2ageT4LkFmnKb6tY+TXPJk SkIprs5U7tlUzzaZ5V3nmgoWLaYyFtpF5eFKpFT0SCQ1zLw7PTUQT+eY8GcJ2Ml86Tvxo+FgsBaF XRhLuYV5ecjPfLf4lcvh6+14dH/JZDq9+gvmv4xHHzHnLi8/zpsJHIc4zHtP7iroEk2eHODrJm+7 HyEJE+3RgvfTDNBfXBWL1pKqI65oZm1PYmdNokj9t1t00NbL5EKR7iVvsEquSOO+JZJsi8Y9QmJI DguM3bZdXR4z7IZAca9nByENTdOBsCg3a1e6qsu7oq6Qh5F6Cbe//Y5zmcIiX6+TC0k84/kmlERx H+XcPK8aX+lDBKM5o+kR5jD/iXD0/xKOsCnNhkF+nzQOkWTuRXG+cC4s1ToM327arsFhubz0W8HJ TXEtIGI5pGSUhyk2zW7jsRFzRaUJIVX94pX7lLeAk87hoVfG+hG6vFm5aKp9v0ZTtU/18lQsnnyW l6Lf9Rp1JUldYVtb/ODrMgNDXfuALn9Y44gsmf0RLdkYKo94vsRiM9a39xYLvbcamC/uSfSkaYZm F8JYj4jVpLk8AgTH7buOkEDV+wKHI4TWHVOMsjTlYfy7UjfHUg/5Lc6KC+CoBTT8V6mrc1IPkXjv UFT/IRKlXrS41qjc0cwsDyGuareN8zJogePwGMOXH7xhTNE8BBFeSYu63KCfPBTrovvHmxj+xcmy bqK7UYyasK3eRaIWYlhGbRgf7WJo3CBiH7uqscqiWkUx/kbVIQbLRyt+jJm50j40QLy76PRk0Sdi 2y9bKqr+a9cn4H3bb2By49bFs/PXR1HBdrNbVD+FjAwLVH6B/qpZ444FyVsHX8mzwJ8oQ78RP31N YivEzkVQ7Pv9Z0H/6IsCT4g68XW8J5TGZfQpd888/d1P9ldU1Gi596AD8D35vN1s6qbz9pxcWH/P xTwa73ys5RAbv/Kl4ZRlQXA0r59RGDrbez8ekLifalwmPhweAu9Kb/wr154Ylzg/S0EFj1bZr+df 6i5eJA0KZW5kc3RyZWFtDQplbmRvYmoNCjY2IDAgb2JqDQo8PC9UeXBlL1hPYmplY3QvU3VidHlw ZS9JbWFnZS9XaWR0aCAxNjUvSGVpZ2h0IDY3L0NvbG9yU3BhY2UvRGV2aWNlUkdCL0JpdHNQZXJD b21wb25lbnQgOC9JbnRlcnBvbGF0ZSBmYWxzZS9TTWFzayA2NyAwIFIvRmlsdGVyL0ZsYXRlRGVj b2RlL0xlbmd0aCA5OTE3Pj4NCnN0cmVhbQ0KeJztXQVcVNn3X7vXXnMRRMTubhFEEQw6pLu7u7u7 ZhiGoVsaVDAxQOwWMFARULED+H9nno4Ig4u7xu+/6/mcz/3cue/cc+Pce+K9+9789tsv+AW/4Bf8 I5g3d97CBYuXLF4yevTon92XX/AtoW/fvps2bbKzs8/IyKyuqn737t3bt++etLy7d+dx6xPk36Lk 3r2GQxWHgoKCJSUlJ0+e/LO7/Au+GgYMGCAkJJSelv7y5av3799Dps+fv7h//8Hly1eOHzuelZkb E03O21d46tTpq1euPnjw8MWLF+/oAMr3Z8+eNzMz/yX3/xcwcOBAfT39pkfNbW3tb968bW5+fPXK 9UMVR7C7KRRKSEiou7u7ra2tmZmZvb29t7d3ZGRkIi0xNzf32LHK69dvPn78FLXev29re9+empLG ycn5swf0C3qEvXv33rxxq+19x5s37yC4O3fuXr169cyZM8eOHSssLExJSYmJifHz83NycrKxsXF1 dQ0MDIyNjUV5QUFBRUXF6dOnsf2hBKAKIPH2to73796HhoZOmDDhZ4/sF3wGmzfzVFWdef++/e2b d8+fvXz8+ElLy+Pm5ub79+/fvHkTcjzDgNLS0sxM+jaHlJHSaLTi4uLjx4+fP3++urr67Nmzt27d amxsfPbsGTR7e3sHAfjp6Og4ePDgnz3KX0AHCzOrt2/aXr9+2/r02eOWJ8+fPYcP1t7eDosM2Z0/ f2H//v0BAQF6enqysrK7du3i4+Nbv349Dw/Pjh07xMTEFBUVTUxM4uPjDx8+XFdX//Tp01evXrW1 tXV0hvaOU6dO/fnnnz97rP9pwI6jUpOftb588uTZ/fsPHzU+ev78OYTz5s2bu3fvYsNiL5PJ5ODg YGxPQ0NDeXn5PXv2bN26lZ9/2/btAjt37pSQkFBTU4O4XVxcgoKCQFxWVgaFgN39mbTbOiD/e3cb Vq9e/bMH/R+FKVOmHqo43tLS+vBB462btdDb2M4Q9+3bt6G9Iej09PTk5GRIMCw03MrSTk5WUVJS WlJCEntcWVkZmxq2Xlp6r4yMnJKiqouLR2wsCeo9Ozu7qKgI5r6hoYGQNXY63Wt/3wZj8erFG3k5 hZ899P8czOKeXXPmUuPDprra25cuXa6vpyvhO3fuQNCJDIADlpGRERQYoqGhA/mqq6tra2sjhaDl 5ORQgp2Ofa2lpaWvr4/dDVWvoKBgZGialJQCg15SUoK0srIS5gChHNT7yxcvX7+G2nj7+lWbnY3j z56A/xBM+GPC0SOnbtffvXjxMkzqlStXsKOrqqrS0tKio6Pj4uKwSSPCI+Rk5SBciHX37t2bN2+G Hl7JgOUMWLFiBfET5Vu2bAENiCF6LAlNTc2cnJz8/HykWVlZcOSgN1paWhobHzU3t7S2vnjc8lJZ Uf1nT8N/AoYMGZqetu/69VvV1TWInmCgIQ54WYiYYHzDwsIiI6KhpbF/4YZBjhDrokWLZs+ePX36 9KlTp44fP74zN5RwcHBwc3MvXLhw2bJloEddWHklJSUdHR3IGiuHbtBLy5qamuAP1NXVPbj/kKFV Hm7fJvSzJuG/A1ZWjtXV5w7sP5iUlJSbm4s9mJWZZWZmZmVl5eDgYGRoBn9bSEho3bp1CxYs4OLi mjJlSu+ZQ+6E0KHwofzFxcVjoumhOhw56I2LFy+ePHny6NFjWGBVp2uKCysmTJj4/Ub6C/i2bC8q OpCfX+jp6WlqampsbAybu5UBiLDWrIGQ10Fvb9y4ce3atVDUSxmwZMkSpH379u1NE8OGDYPQoRNE RUVVVVVRUUZGRkREBEsIP93d3e3t7e3s7L29fRzsnNRUtZZ8hKWfA0qgN773hPyLYfjwEZHh5PLy Cnt7h6DQ0Cu1tR1fA3aOX+FfsbGxQehz586lUqlf1Qrgen39tfr6tJycCRN/7f2/D0oKWkWFpWlp 6RA3tjM1MfF6Xe3VWzfPXblcff7c6XNnq86dRaY7Xrp+DVKAg716zZreN8fOzn7mzBlUvHLzRnee aOs0A5FHBy7fuI7OXK+vBfGlG9dgXAYMGPD9puJfD5MmTvH1CSkpLvP394cx1dDQgFE+evz4/UeP Ghob6+7evV5be+3WrRt1dSwR/jRdcDdujB07tjfN8fPzNzc3o8qt27fBuQs3oi2kuHq7oQF9eNDU dL+x8U5DQ01NzbZt2773bPzrQWSPTFRkbHh4hK+vb2BgoKurKyzjrFmzbtbWNrY0P33xHNj89EnT k8ctrU+Bj5+1Ekj8RDmhaRFb/WVb8PoI4ofNTWAOtgRDghWzFbTY+vIFyvHzwaNG+O2FhYXQCd9/ Mv7lMG7seAtzh4z0TEjZ29sbG1xLS2vNmjUTJ07EVnrY9Ohx69OXb9+00e9ts0D6nbGOjrftH26D 6+rq9tQQ/DSsB4Ls2csXr9+/I+ow+TB5vm17/+LNq1Yss+fPmltaEKBhHQ4dOvRHTsu/Fdav2+Lp 4RsZGe3s7Axxh4WGIVbi4eFZtmQ5TCQM5ZMnT953eajRM7x58wZuc/dWEJtfv3699y5ZW3v769ev GxsbL1++jGj9x0/LvxL69OmjKK8eE0O2tbVzcnJCCGxoaIhoa/fuPfCcOTk5EWHFxcU9e/asnfnM 8q/g6tWrv//+e+dWEGqBw1fIuq3txYsXDQ0Nhw4dWrRo0ZTJbH9OnfazpujfBJMmTdXRNoqJITk4 OEKZBwQEYF9v2rRp+zZBzDMs+ODBg0eOHFleXo75773EExMTCf5YLYjiey/oDoaTD30CN41CoYwb N27rVn7BHTt5eLZ36TlsDQJwPj4+BOxqDEBm7dq1c+bM+WGzN2PGDOY9AWQQXf6wpv8eLF28ytjI 3M8vwNHREcrczc0NWxuB2LRp7FC/8LQJi8nFxQVVDO3ae4nr6OiMHz9+//79vRc0mMMWPHr0qLa2 1sjIaMyYMegJQ9vwcs2Yi2BBSkoqIiLi1KlTIPsyK/Q2ISEBffjyfb9ly5ad6gTJyckRrEBI6NMd 3dGjR+vp6ZWVlWFNdm/35cuXJSUlCgoKvbzv9INBUEDExpp+I4vQ5JgfbG1paZlJkyaxsbENHz6c SQmDDkG8ffu2l7KDROBifZWsMVcPHjyoqqqChkGLEhIS8BWRR6/OnTvXe1ZdABZh3bp1LIevra3d m46BDMTz588nk8noZG8aRYf/1w7jwXDvlVFxdnJzZGhyhGCYXoh7h4AQNiYUaRdnWF9f//Hjx1C2 f3vmewIYaxj3O3fuwHXHMhs7Fo2Pg4a0s7NjOb0QAapg7dEfnr58iaWFXn1Z80RHRw8ZMqTLDEAD 9KZ7/Pz8iB//UqV0gZs3b44aNerHifOvYMSIkYoKGr4+9POE7u7uMNybGTBtGgfsNeKmQYMGdakS FRXV2tra9fQRK2jvaG9r/wsyELx+8xrYwoi20AeixWls0yDrixcvEmRv3r4BDdK39JPs9KNTMCuE zofffunSpRs3bkAtQO7tdJG3E02/b3sPYlREhuBz7NixLhK/desW0Q0C6YcsPuK79+/QIlERer77 6Jhsu5ej3Q7GmsTE/jhx/hXA490ro+Tm5gGTDYcKsS1kDaXdr18/yBpRGDJdqkC9FxQW3G2496i5 icDmxy2dsamluRHFjAxxlSDDz875+w8f3Ll3t7a+7lZd7dVrVy9euigmJgb+/fv3RwolQ2xqNFR/ 5zYo791vQJWHjxoJhHALCwsFBAQIc4NNxMvLC6EwGyK68aDxYcOD+6gOJMTh5+/PHMvUP/8EDVGF QOaggER1FD5++gQpGkVnbt+9A1bgSYyFWZFAZrvoKurevd9w7dq1HyjPvwDO6dxysiqenl6QNSJu CB2GUlSUPu0DBw7sydmYPGXK/oqKc5cvV58/X3Px4tlLl7rgmQsXcAlIZJASZEiJKtXnzlVWVR09 caL8yJHSgweTU1O5Z836jWFckC5YuBCybn316kRV1Ynq6tM1NUQtAs8yUlpy8pCPhoaoBZgzd+75 K1eIDnzW6LlzJ6urT505U9/QUHX27KSPLzXwbt36sLkZNERvmcisDgT9CUZXDx46VHzgAIVGy8jJ wc8z588TzAliJjLHi4pV585dvHoVDuf3lmMvYRb3fHk5FR9vX8jaz88P5ht7REFBkbjKnMbusHLV qgMVh8qPHD107Pjh45XdEeVM7FxYfuQYMgcPHykq259bWJSdl2/n6DRixAgmZwTs0OpNT5+VVRw6 cOhwxVE6PVJURHqk8gSw+tyF6dOns+xhXmERWgEls2kiRfX9FYcOosPHKzds2kQQa+vqNrY8xaXO ve2CpeUVBSWl6Tm5OwSFmJ7MkqXL0Lcuo2OOEa0TeOTEyZNVZyb+zzy5mztn0d69ShC3v79/UFAQ AjGEsWpqvTo4JC4lXXSgoqDsQH7p/l5iXklZXnEp0tyiktTM7KT0TFEJyS5s9YyMX3V05BQUg4Ze pbh0X1EpUqJ6fsn+89duZucX9dSrk+cuFJQeQJXOCFY5hcXIFB0oLyk/xMPLSxB7BwQdPV2N8h67 WlyalrMvikzhnDGDqMJcYNb2DmjoSyMtKQMBmuvuH/4smDN7kexeJU8Pr2AGYHcjztXQ0Ohldf+w iNTcvOTs3N5jUlYOLTM7IT0zJJo0b+GiLgwnT5168MRp8EzMyAYx0kSsiqwcoiLyafvyL9yqb2xs PM2AU58DSu60PI1PTe+OlOTUuORUZFJy9m3YRI/yBgwcSE3PBEOwZdlPlKMDlNS0TTxbuo9dTEr6 C2Mnup2QkRVOjv9nIvqWMHPGPBlpBXc3j7CwsPDwcB8fH/hIKiqqf1kRKzY+Pr75XQclNYOUlNp7 JCenkZLS7Fw8xrB6VCq5V+5I9fnohKTYxJSYhGSkzIpECTIxtGRycnpSdl56QXF28f6c0gNIgRmF JdT07ChqYhg5PiIuoQuGx1FDYuLCSPFgvmT5CrTFwTkDfGJoKcDu/UQhWoymJfuHR7E0aiJS0plF pSzHSO8qvXpqVHyiilaPD4x+GMAHI4bAwT5TRprumSO8QliKDQ5fV15e/svVOTk5z5w586Stg5Sc HklJjIxP6iVGUZNJyRlIB/XwipC5nQMlNQs8w+MSunKmJEZQaEhDydTgGHJwTFwoKR5kEQziMBI1 jExFJiSWEhJDwaXOiELQB0bGBkTEhJIoM2bSb3XybOUvOlLJoiFGW/Ty+CTwVNc1YNlVdT2DtIIS 1sNndBWIpleuYX1750cCwisivJ00caqYqIy1tS2JRIqLiyOTyYIMGDp0WE91d+zY8eTJk9NX6khJ GdEJqcDYxLReIikpvaD8WMv7DmVNHZbMIylJpMR0UMbQWLBFWygPj6MFRpJ8QyP9wqIDIkiBkeSA SLJfeDQQmcBuGBRFR1D6hkR6BYWHxiYQLr2ajn5e+fFoakr3tlDCGFc62uLdtoNlV32CIhMy9vXU T6RRCSlgzlKJ/WBAbEuEq8OH/y4qvFdXRx+CplKpqampQkJCu3bt4uHhZVnRwcEBoWvZ8WpySiY1 Yx+BCZl5H3Ffp8LO5Z8wKafw7tO391rfrt2wqQvzwYMHJ2YVEAxZcqBl5SVlFypqaE9j52DjmD7t axG12NnZ2D8caAyIImcUHfi8/58NBNKMT8tmn87iRujUP9mSc4toWfksh0l0Pi4t2zcs6luK7R/A 6NGjR44c2ee3PruEJOXllChxlMTExLS0NFlZ2T179piYmHehR/BYWFgIWWcUHKCkZGMqknMKEzPz Mf/IIIWk8BMpM09c6oz0S5n5uaWH6WvmWNWkKVM7NzFs+HCwpaRmE3WZ3Jh80vJKMovKdwqLfYPh jxmTkluckltE8O+CRLu0jLwoSgrLmw+beLcePXsFZMSgulbPzE/OKUpI36eha/jPu/pNAOIm3rjc sJ5fQlwmPDyCRqMlJSVh/woLC5uZfSbupUuXIha+/uBpLC0tigrHJpOSmkNOzoxLyUImLiUbGSKP Qlxl/CQK4dnmMBE/QYBMdkkFJO4ZEDZw4KebtHAnQmJhjhNjEtIIMoLtR8xO3VcKFJGQ+Y1VxD1n zpwlPQPxgJJr5kyCeNnK1bllR5ld6ozMzsfQ0g1MrVjOnpKG9v7KM0QPe6iejerrNrFw6X8KjBgx gp2dfejQobO5F0qIy7q6uEHcycnJ2OPi4uLS0tIzZ84iKJWVlV++fJlffjwgAqYwLiSWGkqi0dPY hDByIvLI0JFEC4qmgIYg+1DIoGHiB2J69YT0wgOPXnXIq2p27pWytr5XcIRvWAyYgBvR1oeKJBop Kavmxn1LB7fuw4F7+eWb8yl5JeCzcQsfQS8iKVNQcSI4hkr05zOMhb9HDYqm+keQ+LYLspw9R09/ CLSn6igPjIoLio77Y+Kkbyq0vw+w3RwcHGxsbOPGThAXk9fU1E5KSk5JScnJycHUSUhIaGnpDBw4 MDIy8nlHRwgpydknxMUvzD0w0iMoyj0wAqlHcBQzj3JcBY2jV6CjV5CTdzB+guATJRMZxESaVXas tPLcitXrmb2aNp3T1s3X3sPfwTPQ0TvIySfY2Zferpt/uFtABLilFdLVgr+/P3Yr6DEEfn7+ffv2 vevoiKJlgoDJHPSu/mGu/uEufqHoDxhqGVkwHwFom1gGRFNRDv4s0CfEyTvIxTeUaeg7A4yOT2is q18Y0b3uiHJwtnRksSx/IkyZMmXBggXDhg0TFBCXlpJFLJbBAE9Pz40bNy5cuPDEiROl1ddtPQIt nL2t3fyQsXEPACLTOY/U0tnH3NHLzNHTxM7d1N7DDOjoZe3mT1wl6JlIVATaeQcXn7wUEEObMOnT CYSFy1YY2riY2LmZ2rubOYCPJxDMzZ28zOk8/WJTC1502rbIU7LLHH1CCc4gAFq5+lm5+Fq6+Fg4 eZnYexjbuclr6o/4eJ4KniouWTp7d27iM3TwMHfAWDxYRtwzZ89zCYgydfAw7akuUnvPXeL/W+fr xo4dS7zNt3DBCmkpBUsLq8zMTKh0Z2dnXj6+m83NQdR9upauupYu+tbuhrZe+jYeBkBbTzoy8vRC a3cdCxctMyctU0c1I1tlPYtZ8xat2bRVy9RJz8qFICMomfihuq0n6pq7BOWduK5maDNo8Ic7jVxc XDNmzVXQNlE1tFY3ttM0tdcyddAk0MRBy8wR/SEYEkyIjJ6VG8p1zJ11LJy1zZ00TR01TOzBVs3A Rk7TZNGyNZ0FN3HKnxiXpok9HZnMO6GGiYO6kd1OcTmW87aWZ5uOpbPGl6rbaxjbzVu84kdIsdcw atSouXPnrl69euLEydKSynJySiEhIbq6ulZubofq3hq5hCjoWSvo2ygbOSgbOygZ2SNVMXZESi9h FCoa2MrrWcvpWu7VMpfRMN0tqzl+In2f9h8wQEhaVU7XCgSd6zKRKEQGqaFzUGxhFd9uaVQUF5fc tm0bnIphw39fvp5PREFbQsVQUs1YWt1EWsNEWtNURtNMVtsCvVIytCOQ3gddK1l0QNNUSt1EUs1I QsVATElPQlmfd6fkdO55ffv17zLw2QtXSKkZiasYSPSI+uAzf/lalvPGt0tKQtXwi9UN9mqajRr7 x/eW4NcCnPMNGzZApa9ds4V/q+DiJct9E/ODs07t1XMQUzWV0LCQ0rKS0rSS1LSkZ7SskX7Ia1qJ q5uDRlTFWFjRYLe83gYBsSFDP510GjthioiykZiKiaSG5adadA5M/FCI1MA1wj48a9ailQICAlJS UpaWlhoaGsuXLx8wcNA0rrkLVmxat11sm7iKkIymoIymkIzWLlmd3XJ6uxX0kO7cq7NzrzZxSUBK YzXfLu5FKydMmdZ/4EBmZ7ro5PGT/pzGNW8a15yecS479/yhI0aynDQ2rjlsM+jYU3V2rrkc3Au+ k8j+CYwfP554A3f0qDHTuJfElF+3DE4VVTcTVjERVTMX17T8iFZIxTToiLyYuoWIqukeZWNhZaOd 8vpC8roLV23pHp/OXb5hj5KRqJoZUZFRlwWKaViAp3V4loZd4PjJbJKSktR4KoVC0dHRWbFi5XR2 rn59PwRrg4cMGzlm/CR2LmK2mThlOjfKR47pupv6MOBHzOP/H5g2bdr8+fO3ikhlnH+u4xoppm4u rmEhid2nYyOlY8tAm49I/4lLIIAQRVVNhZWNdyrocXDPZ8kZbjCfmDIYSmhafaxu8znaMnnKGjr5 pBzFQtq1RyQuLi4pKUlJSUlUWEJQQGTu3HmAcePG9eZJYm9EjIhjGAOGfwSWx7R62VZ36EKmpqa2 jwHObm4//WEoAnAnf/+yG68MXIIVjRyVTZ1VzFyRKpk4Ie2MKFE0dlQwtJM3sJXVs5bRttgjrz12 wpdCy3ETJ8vq2cgb2KFiF26d2RKNGrmFU8svC8mo6ujqampqKimqKitpb9zAB+9i1qxZXc6E9DS3 vYGsrKzmbnDnzp28vLxNH08+fEOgJCaevXz5wpUrBSUl30PbbN68GbGzgoIC7PKXKRGLHTp0qPTi A2vvCFOXAGNHX0M7uuesb+thgIydl+FHNCDKbTz1bNy1LVw0zZyEZVSGDhv+Zf6ANZu36lq7Gdgy XPpODD9ja+uBvIlLQGhq8b5TNzfyC61auVpRUUNGWg3zD3FPnjy5y2spfxugcw4fPfqwpelhc1Nz 61Ng09MnD1qaGxofEpGdl5fXN2mIgEmTJt1uuFd/987t27dNTU2/IWcCoKnAGd1+/KzVzMzsC5RY DA0NDQdrbnmGxSGQdPQNs/cOsfUMsvMMtvMKRr4LohCXEE1buvpuFRLu27frqUWW0LdfPzUDi554 fuDsSefs4B3qEUquvPog/8i5WXMXbOMX2cLDKyQkhPChyydf/gkg/GxsbHzz7m1LS8uFCxcqKytP njx569at1tbWF6/ohyExJzAc36o5WAp+fn4+Pj6kX/Vhk14CbDFxDvzdu3dwuXsiE5Hcm5xfFkFN CY5NCIyi+IXH+oRGe4dEeYdG+/SAuOQZFOkaELps5Ve8tg+YyjbNIyjCKzSqJ87MptGN4FhaTFJW CJk2esxYbG345wgfvuFpbfilHYxXHmpra7m5ucF59OjRU6dO9fPzQ2F7e/vTp0+3bt0KSiwzFPr7 +xO7UlBQMCcnR19fn8mqf//+WI0kEgka8uDBgyBeuHBhl+bAxIkBioqKXS7BZYImKSsrO3z4cExM TE+fEIRmMzIyys7OPnHiRH5+vo2NDfND8VpaWighlNLr16/Dw8PRW1FR0c7VBw8ZomdiTklJj4xP CCNRgunPgqP8wiIJ9A/vEQMiol28fDg4OdEx9P+rzJzgHuEvcAYyWw+KjImIo8anZbr5+GFCsHq/ 7UlOa2vrDsarPZBRZ0uKddXW1oadgl1PiNvc3JyYSWgAxIYdjM+3Mt9FhW5E+Yez5R9fZ8CCMTEx 6dwc8ZYK2JaUlDAL4Rb6+voyPgzbTqQdjBcrVFU/O0eE5aSurk68mtTOAKKVs2fPIp4CwbVr1zp3 gHg1w97evsuQBw8ezDGdk4NjOjv9QTDHNHYGcnxEdnbi0fCnEgbOmDlz5cqVCJRsbW0jIyNTU1MP HDjQnTlLQM+Jhrqz7Y7oFQfnjIWLF3NMn/4N1TgBpaWl9FuvL15gwn/rFJLv2LGD2CN1dXUwuCiB 50ZMJl35v3mDaUeG+P6PoaEhQYwSaAlYTywS4nUqzDyxWgig0WgohKXw8fEhSrA3YT4gmkePHt28 eZP4liBYEWRsbGzMupmZmSh8/vz5vXv30AqcyaamJhDfv39fXFwcPjY8TOL7tKiOS+hGfX09tFAv pwIcoDqgkVatWjWTi5uPV1BIUFhIaJeSkjI2BTpMpVLLy8uhVRBWQL0ghTKBHjt+vBJ9A83atZ/d icLawKxiyGFhYdBI8B6lpaUlJCTgeFtZWtnZ2Tk4OMDBYByo2MKzmW/LFoE5cxZiU8+ePRuW7hva UALA8GZtbTtDKMLCwszyiRMnFhcX19+5c6uurqiIfswVnuHFK1ceNDY2tbQ0NjXVMcrJZDIuQYEz 3ndowPxHRUWtW7cOHdbT06urr7/T0PCouTk3N5dYRQi7qmtqmh8/xmLA2Im23NzdUf3egwfY79ik iAGhJ2/fvdvy5Mnzly8Rfv7GWITWtrZEK1evXsUUwS6vWLEiJCSkpqaGeD9x5MiRUlJStfX1T1pb Gx488PDwgKAxqK/6TxAsbHQeSx1aa9u27VoapnY2Lna2Tm5uHpAsfBsM/OHDh1jq16/fgNHB0LAL CgoKCgsLMWOlDChjwP79+5GiEKsiJSUFcxUdHZ2WlgYCVDx+/DiUQ1RUtIW5hZ6uoZ6usY6WKR+v AC8vL4zFjBkzvsd3zpcuXVpZVXW1rg7iDggIwDRCS0NkEMf+w4dzMIyyslWMDwotXb782OnThyor K44dyy8pQSHxNA16ODUrq6yiAqip89kRLH0jo8OVlUdOnDh47BhhgGbNmXP01Knj1dWV1dVcjHeB l69cSbcO1dVoqPPrltb29ifPnj1ZU2Npa4uf0zk56xoaSsvL0atVnT5whD782Wn7T5w0CczRz6Mn T3L93XeN4RphWqAu4JZgM2qoG4UGxYUEx0RGxmRmZl2/dh3ODN2PffECOgRyr62tO3XqFHY91gMh d2wE4sOnAEIbYJ1AHUELYalA7WBfoDw0NMzFxc3FycPFydfE2FFwxy4REREsdUTZhDr95rBhM09p xdG0nLziiiO1DU3vOjou3qzPyCukpqTHxNMiSJQt/B++87NHXLy88lRqNv0INA/fJ+W8YRPP2Ss3 kzJzYyiJIxkOJDP8X7NufVZBcfq+gqT0LOIS/44dlTXnURIWTRrIuI1jYml98uzFI1U1mBC4dtit xJHvQyerU3PyUrPzVTXpr5pKychXnr2QnJnj/DEqZHmTYQsf/+kLVzPzi+NoyV84XviXAAdp0aJF AgIC0LrwFmSk5R3sfKMiEmKi4smk+LLS/fV19fB2XjO+Wvue/m8TbYQvAVcBOwU2BSnEStC8ZAAy MEMwWFVVVXFxFD9ffx/vQF+fUE+3MGUlbXFxCWj+jRs3fj9ZA4QlpHNKy0NjKUEx5KBockBUbGBE rF9YlHdQuIaeIVun7/yoaOrEJqWFkuK1DT9zvbT0jXL2V5CT05U0tbowF9wjQkpKC4mNs3b+8KRb U984ITM3kpqkqsk4ftynj6OnbxQ1OSohOSYxDeUR9DOrieFkBEckdAPpqnX0p/8OHj60rDxySsY2 wZ1fGI6qjl5iTn50QrJ+t8NmXwuITRBEYP5lZWUNDAxgUxTkVXy8okgxybHR1HgKLTMDocHJ+vrb kGNPrwATH69+9eoVpH/+/Hns+5iY2JDgsMCAsODAqMAAkq62uYSEpLy8PPY1jCAXF9d3/a8KK2f3 6ITUUHKCuYOL+F4FCVkFUSnZLfwC3Y8xWDm5xSSmR1CSNmz+7JSmmZ0TOGQWH9Q0/OyeyYABA9KL 9ofF0cIpNN5tAijp17+/e0AoJS0HfHi20pXGgIEDvYIjomlplLRsRXWt3aISu8QkhSVkdolIbBUQ wmrZKSI+4veRYOUXHh2Xmp2Qlbdj156exoLN7uztT0rJpKTnCOzskeyrAPOPCIWfn19FRQVCl5OT 09TQD/Inx8WmxZGSE6iptISUjIzsw4ePnjlTU3urFpYdihqeJFzEGzduXLp0+ciRI/l5BWQSJToq NiIiNiI8LjKcGhlGMzd1EhMTJz6lCwUOZcLJyfnN/fDOAAVLSs4gp2TGJKUvX8364SYBw4ePiKKm kFOzyClZ8xcu7nxJ18QcG/Ni/cPHz55hZohCBO+IU6jp+6JpKQFRpEGD6KfoR48ZCw7JuYWQ2ux5 9McKffv18wwMReHhmkvrP38zpXOwjCjG3T+YlJTx6HXHgcqTTB0OF9rT05N5IGfosGGhsdSs4oM1 N+5gV9JLhg7955+MgCmfM2cOfHU4hBoaGnCwlZWVlZRUzE2tgwOiadSchPjMxIQMWkJaAjUF0k+k YQ1gJSRR45Pi4mhkUgKZRCPFJMaRUiPDE+1sPdRUtOBSYuXARd+yZcuSJUugwL/HHacuMGf+wvC4 FK9gqO7IPxi3+nu66z5z9tzg6HhvUAZHjfvjM22zaMly94Bw75DoVx0dMEzw92CCEU8FxyZ4BUc6 evijFYKSnYMzipoOPv7hZOahNSUNXc/AiEPVV2HXXF1dEWgjnLl06RKq7xaV7PNRWDt2CXsGRQRE UaAh4dM6OzsjJoLdjKFlKGvq9e9P/2Lk2HF/eIVEh8TSXjK+FOEXTtIxsezlrc6/BFjzefPmrVmz Bt4+FDsCT8hdTU1NTk7ezMTCyd41KCAygZKRQstJScpJTKAjVkJSQk5oMNnTzd/a0l5dVVNGRgZL BYoCfiAfHx92BwKuH/YXJLzbd5o6uBtZOytrGX/5UcVG3u2gNLZxUdI26n51j6ScgZWjmb27tVuA vTf99q+lk7eJnauWsRUbx6dD6avWbw6hpFs6+2iZWBMvrQMmTJyMn4ZWzmb2nlauvtaufuZOXkY2 LkY2rtt2iTJ7NWz4CHVDS0MbF3NHT8bt5RA7jyALZx9LVz+xvUoEt99Hjjaxc0NdYzt3MydPsBLY 8w2OZHcGDg4OhGkIADds2AC5w+bq6upC9PDh4dQpKirKMkBTQxNhJoSLLYy1oc4A+gNNUVFIGXEW djQ0RudbCj8ANm7bvUtKaae0yvL1rF+aYMJ6vp2g3CWjunwdC8pBQ4YuXrlhp5SyjKaJnJa5nI6F oLji0jWbhw4f0Zlsp5SKspG9gp7V5h0incvHT5y6YetOMQVtKVVDGXVjMUWdzQLC7FxdvxY1ZvyE dbyCooo6exmtSKkbbxEUmzHn013xPn36Ll/PIyynKalqIKmqv0NcYfyE7/VnfLCz2OzLli3Dfufh 4YGex4aF9LFzofCJb15B+pA4RLx9+3YYF5gDGGhIGWvmp7zy3PuHj316YQH79us/YtTY0eMnDhsx qsulP6awbxVXsYnI2qNkvFvJ+M8ZLD78NXjIsFHjJowa+8fAQV96Aj5w8JDRDLJBQ1jHWag+/PfR g/9BFPZVwM7Ozs3NjS2PDYtdD5mu/Aj4CXW9ePFiLIyZM2d2+Y7TT4HePyL/MmX3S8wSzL+UtqWR R5SUlqWYuomApGr/AQO/XL33XeoN2Y+HyZMnf7/Y+X8cxv0x0cTJR8/GTdvCUUHLeNKvjz3+q2HM uPG7xCQEd4ts5OH7X3j98xf8F+D/ANXK5mENCmVuZHN0cmVhbQ0KZW5kb2JqDQo2NyAwIG9iag0K PDwvVHlwZS9YT2JqZWN0L1N1YnR5cGUvSW1hZ2UvV2lkdGggMTY1L0hlaWdodCA2Ny9Db2xvclNw YWNlL0RldmljZUdyYXkvTWF0dGVbIDAgMCAwXSAvQml0c1BlckNvbXBvbmVudCA4L0ludGVycG9s YXRlIGZhbHNlL0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGggMzgxND4+DQpzdHJlYW0NCnicxVpp WFNXGs5GViCBkEBYEkLYCcgSIICAoLIngApYqMUFFEVc6oIoKtuoqHUXneLSmQodx9FqnVqBaltq 1bYo6gMiIFAUBESsiIBAljkXErnZWJ6nA+8Pntyz3POe73znO+/5LgjEODDnWNlYWbCMx2s3PTAw tnTxnRsSFh4hiAgPDZnj48g2ok43KQXoMaw8ZocLIAjXb970sRD6FRbgyqaTp5uaHBQjO3/AcF7O 1w9apSPoabh5LEkoCPHi0HSnm94w6FZ+EYIF+++LpEp48e9kYaiHucH009Rn88MEMed6lRmOoCJN GOxmpkecXo40u7mCqBNd6ikCiH9IEs62oZKmkaKusUtYZF6LRooQBq4sDHGgTR9LMtMnIvrSmBQh PEsNm2GoPU0cdc39hfH3x+UI9nqWwN1oeljqMP2Fqa0KbCSiof53PT19Q0MiCbxcdCrKnT4dK04y mSlM74Ez6W2v+uHi2cP7DhSeL6n4o6tfDKu8GuVqMA17nOYuSO2GUWyrKM5KDA/w8XT38PabG7P2 +I36Lpg5iyId9PBTzZFsE5bY/oGCuP324cQAVzsLUxpUacq2mcGP3nm99vUoy+MhHF3c1HIkMQMX VHwg0Hf/9KpgPpeio4UcbWLjEZ1XVvPhHHq/LcLGSA+AQiaip4YklRf15QeOvU9vFJ0qyM/fvc2d goJNxMZrxcXHg/JWb6+cOrQ/Pz8/b8McElLzm/86kNghKf1qgs3dmdrw8a2CDr5WbfQsGj6V/x+o 7gsq1XCUSs45Yj80QhLtc9+otmnY7KIzFSSJrKAsdRyl0v4tZnKHQ5G9igZUGohr8uaa4KdiuSlO MdXqSUpfzNMfYYCih/2qWj1UkRdmoTMVGwfPCNguD4E9yjTuziQClkiseXKzGkOXbpppQpgSjyRZ Rf0oG7X9J2WvE5+y1UIgSU75b1U5SsrXexhip2RrI3S5S2QGlJzMKlbWu71rjDF6vpeG1DnDjWAG HonCUwyZbDaTro0Zly+GSKHoUYiYyZPU5x+SDfpsZVDSFWU6f0Tbzn+gjqJUWh/p5DZLuHpP4dVr 1745tmP+bB6bLHNQJM7EzX+Wr6ebC4CzHYOAROtyvAWbd4H4uyWSz5pkbMUzwm7KBt0bwOKl3JEo Ufn9cJt6jtLBM1erO2HCo7uuZIOvKQ4aH228reNlZ+fTaghVlflshntKWYssPIiefx1ugh2XGQwE s4UyhTYUY02muGXUKlGRqMZ55XnA0Hbcmwq2Es7jF3jpDwm7axSudq8zOVqTsSRzqWyFG3xoRIyB X/5LzRRks6kWj1Fb8xEDjdCJfgEv+/2Rco/eVYaTCAsETqasX6E1CYfEGof+/d3YHN+V7O8eq/7l x3Q0PVUh8veptqr2mYSKItqelHWbT9dCI5B489hLg6rvHMWLL9LSXsGeRR33fr7fAbfUE39ty6Nj zhNgIJEyYY4oAveCrJvvcFxGkWyXl2teTtGjvTHCYphTDpTvT01cfQzuyZIsFv+mckexsiPnmE54 h6PwM76VvdoTMdwLTXbZVKOJY39ZeqB7Onz1ftvgZ2thLzgL3xf/9RA0KHSTdFXc+KVdoUh6xGLC TonEOn8vs5G7rBOG6rOrQz3HrqJkHjscTqDv0tqooNnBn/wDTrI8dLmC14qfnEhLWPmloq/v4Ux8 52AcZCTFfLkSx5rEXVVVPKBF/ZEFtlTrI/CFE7193QnQpXBs3o7LUVjc57tD7c2d1ytcRge3MCce 0FE28uX2xcmmhrPeoBBA5K+9szPIXJs4q05NnSJ+WnZRYXJfhhrj0QbxChrl1QrGxH0SaSHfOKGk 4TMNSXTIVaPApZKKrT4MPIqcMGb8Gca3ax/BH7vTrcAxpPexQgB+FKU/YUOicQx5CFqhh0FB6tb7 K/UhqDXFHIxFWzvGeSObzpF0hU3y9CM6EoE0SnsPLzzvNfH8Akabki7rdskUh0ZgDAUVUg0o9cQj kGbZ8KL+57WPlXHv6xU7FFz6O38dMHnrU/CywRybSZyLenSh7Fjs4Gpr4TipmtNqQ59ZYpDm+fCi 9sKNaWlpa9Zt3JIhx5ZVUcEn4G3E+7jgcMF634UXvlppMoljUY/Fk+0SUTBd3/WwhgTqMLqXG6KZ mfBI/2w9z9bWzjVy76kzMpw+vt55tkIof7OOCZxdO+o5vLBq3sRdEoHQMXcpl3XcywsvVUlDK6Ah XM9kLTza/LnJlmxgHVkCb3SeK1QI5Y0f0cA+piYrHOBf+0wm5aXN5h+UdXyZPW50+YFvGl8JL6gr SNxapGCj7jTnZQoBoCwQuKSSmwzl2U5KUJr4xMiPApV7mArEx72jzqjRNKPoKw5z2Q4PAJLPHIFL Ytyuw1t1rTad1AWOylt4R+OQPcqK913W4twx1KSko2gJl38eXvR2Awu4JCG4Hl74ZMHkvl1RHBbs 0hD6xHWXbynfedr3PtRIcbDt+u75tjQvBVVeHwe5pE40XN5J/+MzyVyxWcin9VJ1GCjfmbhVhdKz D1NQmNrAm6afi7IT+ExtkvPnVc87ZHhRc9QLuCRCN7C07oW88PmDFKtJuSQCQeOvvaLOlN0XV/Kt ffNeqakarn50+37N8/b2jo721tpHJcWHtiSGuJlTsCis2dzUrDyAXIDtKYGmkAQnWkWvz86VISOR R9Vhubrb6U3YMVGumU/UkGj9PJ6rT2SEn1N/SA6V7U1JXZORBcbMzly/PDbY25FN14aElBYzIi1j 27ZtGesWhXi52BgRISZaZJaDq5sMThyqtm1xY1PlTI3pYiSOamKij5NrEIxxcoMqB1HVXoGlDhpJ 4CSpPyarcoKdLGydXMCYLjPsLc3oZIIsO4D3qns/AKG3+fMABlFr2FpIDI5IkoOIx1CiOsGdMVLj J1UtTs6FrzYzRq7xSIJNuhqFO/BjxixT4rDe4OV0quHYc3a+CRmNJQyPTMBhUKO6S/+T0VBW6ane VkjDjaC2JoKiyZDkBSAu3nQY9lykjsdpNfnTd99tDKSP2BpjGPZP1QUX/bTVlab+/SjW30BEkIiH A9VQuinNyp5lYGJnro1CEoydvPh2dCwSgTJddaeu6piXDhJrYOfJ58pySmgyh+fjbknGaHuclEBf OdgEKKMX/LOaPdN3fU88j0UfmROes0z1G1Tn6blmGqyAcb0GOLZU3K2Fgv7lWWvu3ruacLruAkeb FfbF47bWylwXXSTGalftHxVLLAh67tkVLW1V+1x1gJrTdki90fSyuTzR2vVaB/SSqiNMIE3cKtU6 3ODpOGGQr6sdh23KtuIlnFIRwX2Z9poEAiEY3BwH/7V2xT7oOle69Ffge0ADX/f1KRhRveIfvXXw fBBLX8cxTGMfDBtJUuJGQBuEloysWXe+PD1ewQMXBZsVF249qH78uK7xxZt+uE17v4sUCAThEKIW Zf6nXqFysKNsEVuT+Kd88iew9Gae45IH0M1hK/BoSLV8sbT8Q/9iOz0ow/Es1iYJ8neoWrzDlCZo kjf4br/sx3U+2EMGzsJlqUARpm3fe76yRVECDTRe3S4UCIQFt18qHoRvHxYudtOUhEaa5gGXrFnj O/cQsH/fvqPDR9bAq4M3oKk3N0IZ0M5oq41AplctnPdYKn1f//sLYIFf/OYAe0v+bGjuFVem59SD Iftb72fYA0cl0ljWtsMIiM0ufarujqgMSVvp9nBnHU1JRgwX+tLb9vC3Wmjpft9aCnVpuXLgOFjA rsv791wCCmkoc1YRKP52MbheDT0s/nspUH9Ny46Dho3nduWfubApPAESf9VHl/sYQvNGYbSwI+D4 pF6qHl8HDT79d5IbEx5yFIHzvT06n8acVMgxW48lLgE+OHQtydf/UyAHRfkLwV4cPJoG1nywvbmp FZi1OQe4cm9hrJdX4BxXayGoF/0z0pZGUHo9yyW2oKJDbU53dNie6sIYLkMDQQik0eRF370cwfI2 aGihUwK4mnVlu+gzEppAhNu6GmzersytsHTBvcPgoTnNmqxLNdClLgD032yyJmJUzk1Th7mZZY1v xlBi/S03c8JsDcfgiNBf/Cf0jfftm/bKs2t8HVcBH2xYYWG0CJR2rmPhLLaBZa9dtRP8rUvNBe7V 09HS0tr+sqng6CB0rzTAURm6aGoyYPw0nq72aLfyjDtwq7lXg3IbaLtzKN6DoyGIjwDF3A22X/s3 p47krgx1oFtBu+hWCMXgY6BTxJcifTeBe95QYdwxMZRZ3Q6Wue36l0X/ffTVtvi899AH/8DZud8H 0Zk7AOPKdbMM1X5+MbOfmXiioqN3SIWnqP9lxcnF3nYmY1EE8WI4lN9InuPtam1IwjtfAU9FbnhK 2D3In2uqgIVE95IjLoLi4rBVwLziZw/r3kmrYnnJUBbm9cOnYuljX4djYPze1mo3DTlMFtd/6cGS 2s53olG9KBH1dT4pObjMn2s2NkUQyoOegqiyh0cjk3BoJH420Ff9O6wwROc8+Z4U3U/3EYIQOrDL I6JEPkRNMDOwWO5nTQLnw8M/qv013tbYjvzQ5fsuVz7r6ul7P/C+r+dVc+Xl/OXhXlzmeBTBvS74 j4HBpkWMEW8izWkYGGxMMEJhjIVFr6A9+b7z+ib/GSvB2dO10pK7+s47QFP0pmKdkx5n2Y894EHc /WgLzy6lVSyVdJ9xH+tKyeF6zFm4OutAwdlzX5z4bGdafBDPnm00PkVAa8aagpOfepBHIhRxRtrx E+vddZFIkuW83Zd/e3Drq92L+B5bfwVsHkTSqe4pJ2/e++1awRo/IzxlxtJj31feLyv8NMDEaGbm N3fLDsRYjPPvCeY2jq4efG8/H767C9eaOdErCZbm6OfnSMPKn7h+flzoCa3N8oxauuKTCE8OewmU FBo4yiNhqbYBHyUnxc12NCKgtPSs/WOTkhfOcWIQiQz3qEUxfhzdiX23NB4rJqoBCkc2MNDFolSe UDiKsYWluRGZwNoD7aHyBKYWEkM0YHI4ZgYkoJeRaCLVjMNh0khaSBROz5hlakAc/yPbXw1wumHQ KASaubm+/fm3q510IQZINCiUU4E9IFFojYfaFABNm5manRHnrD+xT4z/A1P+MbQNCmVuZHN0cmVh bQ0KZW5kb2JqDQo2OCAwIG9iag0KPDwvRnVuY3Rpb25UeXBlIDAvU2l6ZVsgMjU2XSAvRGVjb2Rl WyAwIDEgMCAxIDAgMV0gL1JhbmdlWyAwIDEgMCAxIDAgMV0gL0JpdHNQZXJTYW1wbGUgOC9Eb21h aW5bIDAgMV0gL0VuY29kZVsgMCAyNTVdIC9PcmRlciAxL0ZpbHRlci9GbGF0ZURlY29kZS9MZW5n dGggNDU3Pj4NCnN0cmVhbQ0KeJyFwodS2gAABuDnsrV72zpREVEEkaGAoBDCCjMQ9h5hC4iADK12 72Xbx+of4513rXf97hubNI6dv4ZTfBP/+jR3nEuMz1y8gbPETa6Zf2sOSa6AvC0g7+C8Be/yF6z3 zt9fRNsDId/+cIn7SIQOfLyM1BMxd0LsnFhxPl1F1zOUuCYl7qk19ExLuTMy7yyu+3BO7hPIacEG Pa/w44IygIuqgFDFCNXMkjoo2gyKtkLLqAmLNeEVbQRXdVGUbMfW9DGpPi41xGWGhGwnsb6bRLkx tWFKKUxpBZFWEhmlOasis2oyp7bkNq35LbQVNPaC1s5qHazOUdRRpW2qpHeW9a6ywV3BHU9111M1 emtGX92E9B6B/oY50CADTZJpWpiWNdiyhvZtobYt3LZj5MAR6VDRDhXrOjHec2Hi0I3JvgdTA296 4EsPkc6M6OzIj7mjAPeYyR8zhedB7kmQPQmxp6HiaRhLLyJYfhnFCr6KYfV1HGv4JoH1t0ncw3cp bOD7NDbxQwZb+DGL+/xPuTb/cx4P+F8K2OF/ZbuXi91vxd7FUu879/Byuf/jr5X+WWXwz+FZdfjz yrXhr9roP+uj3/WjK/4BqNyYIQ0KZW5kc3RyZWFtDQplbmRvYmoNCjY5IDAgb2JqDQo8PC9QYXR0 ZXJuVHlwZSAyL1NoYWRpbmc8PC9Db2xvclNwYWNlL0RldmljZVJHQi9TaGFkaW5nVHlwZSAyL0Nv b3Jkc1sgMCA0NjggNzIwIDQ2OF0gL0V4dGVuZFsgdHJ1ZSB0cnVlXSAvRnVuY3Rpb24gNjggMCBS Pj4+Pg0KZW5kb2JqDQo3MCAwIG9iag0KPDwvVHlwZS9QYWdlL1BhcmVudCAyIDAgUi9SZXNvdXJj ZXM8PC9YT2JqZWN0PDwvSW1hZ2U3MiA3MiAwIFI+Pi9FeHRHU3RhdGU8PC9HUzI3IDI3IDAgUi9H UzI0IDI0IDAgUi9HUzEzIDEzIDAgUj4+L1BhdHRlcm48PC9QNzUgNzUgMCBSPj4vRm9udDw8L0Yz IDMwIDAgUi9GMSAxMSAwIFIvRjIgMTQgMCBSPj4vUHJvY1NldFsvUERGL1RleHQvSW1hZ2VCL0lt YWdlQy9JbWFnZUldID4+L01lZGlhQm94WyAwIDAgNzIwIDU0MF0gL0NvbnRlbnRzIDcxIDAgUi9H cm91cDw8L1R5cGUvR3JvdXAvUy9UcmFuc3BhcmVuY3kvQ1MvRGV2aWNlUkdCPj4vVGFicy9TL1N0 cnVjdFBhcmVudHMgMTI+Pg0KZW5kb2JqDQo3MSAwIG9iag0KPDwvRmlsdGVyL0ZsYXRlRGVjb2Rl L0xlbmd0aCA5MDU+Pg0Kc3RyZWFtDQp4nJ1WXY/aVhB9R+I/zKMdlcv98rUtrVbqLmlE1VU3XdRW SvrgmIvtrvEltmGb/vrMGDYFjKPdPgCyPXPOzJlzx8D0Hq6upne38xnw62u4md3C5/GIA2eccyEl DyGUHALNobbj0R9voBqPBGTfYjg3guuToNWb8ej9eARv724BjgjEfwSTQ24Qm/DAFSkhLnFJxeIY kA1MyASPIYgDxgVIZowRkK7Ho+l8nWQ2lDBzcIlYHoin7x5kCFlz6EDEEYskwcZhBErgrwIVCRYG 3/roYameSlJroS9UTmy6Y5veJ21r6wrSBqEQvUkrStcyZLLLRFLDzXfV0wfimwUC/qQAO1msqBOS RoDBWjR2YWImYlisj/k5dYuXQh0u341HH664Cm+u/4LFz+PRW8Tc44pz3EiiHPIY94N355bUjW+8 pnU1Sg9+4C3trkhtA37oPTl/Ir360dce4Ge9TXP4ZNvWV56tKe2paHPwL3EzlPMivzIsDA/8ZVJn tkZOQk/zLeJWj/jV0LVbnSM/Q0mjmThFWiZtMhCthGIiOg0/Ru4NKHjRgGQcsugg5OtGcJzpzatl Udu07SS+3IAIFZPqNG1pm7TGnGKDg0O5BPfyZGchKUv35E9wPku8qbw2t9AU/+JgIxSUHoBN0t7M zis0AdPPVAVWuCsodblNSqBx2c9b25ALCLZ1NK12X01pf4CstklbfqG7xZoMtKndrqgy8CeBN5/+ +jrDSKUYnqh9LRtLNCtXr5MqxaaE9p5y2zm43uKTqup4jOcqWCVNS/WRtbHUzt0vHhHnuJUOpK1N c3KmKx2pkBX7w1EWj4iovIeHWTe8ifaSajmkrMLtFOhT4N9+nM8GwrUU7KyM73rWvMizwuBOjP6P Z48zvUVeNINmVZLF4jS+2W42rt5bPPIwN9mRkElRkjuSTyVNUqDRIKm+QNZ5a79x6m1FytNQf6HY otr+8zr7CBkz9SwhLgJBK87VkBdZjmYyHc1Hj2xls4SMsixtsz9RwxtI4VmMz8D/tNXQMFXMAnMa PYSsddCLvacz5/7GLQE7SyU2hRviMjxm0Vn+R38oWESo23BhPZuFJzZDHSSeTd2zGr7BdYAKdZD7 V3T3qqJth+XvFx5tfVwIM9vgrbQuNrRFcJnR6PGEw01JL4H0kc7a/e+DekX4Z+KIjdRyrUtd2bOJ vFRugJMU4QlAT4Gvl7kNsA0KZW5kc3RyZWFtDQplbmRvYmoNCjcyIDAgb2JqDQo8PC9UeXBlL1hP YmplY3QvU3VidHlwZS9JbWFnZS9XaWR0aCAxNjUvSGVpZ2h0IDY3L0NvbG9yU3BhY2UvRGV2aWNl UkdCL0JpdHNQZXJDb21wb25lbnQgOC9JbnRlcnBvbGF0ZSBmYWxzZS9TTWFzayA3MyAwIFIvRmls dGVyL0ZsYXRlRGVjb2RlL0xlbmd0aCA5OTE3Pj4NCnN0cmVhbQ0KeJztXQVcVNn3X7vXXnMRRMTu bhFEEQw6pLu7u7u7ZhiGoVsaVDAxQOwWMFARULED+H9nno4Ig4u7xu+/6/mcz/3cue/cc+Pce+K9 +9789tsv+AW/4Bf8I5g3d97CBYuXLF4yevTon92XX/AtoW/fvps2bbKzs8/IyKyuqn737t3bt++e tLy7d+dx6xPk36Lk3r2GQxWHgoKCJSUlJ0+e/LO7/Au+GgYMGCAkJJSelv7y5av3799Dps+fv7h/ /8Hly1eOHzuelZkbE03O21d46tTpq1euPnjw8MWLF+/oAMr3Z8+eNzMz/yX3/xcwcOBAfT39pkfN bW3tb968bW5+fPXK9UMVR7C7KRRKSEiou7u7ra2tmZmZvb29t7d3ZGRkIi0xNzf32LHK69dvPn78 FLXev29re9+empLGycn5swf0C3qEvXv33rxxq+19x5s37yC4O3fuXr169cyZM8eOHSssLExJSYmJ ifHz83NycrKxsXF1dQ0MDIyNjUV5QUFBRUXF6dOnsf2hBKAKIPH2to73796HhoZOmDDhZ4/sF3wG mzfzVFWdef++/e2bd8+fvXz8+ElLy+Pm5ub79+/fvHkTcjzDgNLS0sxM+jaHlJHSaLTi4uLjx4+f P3++urr67Nmzt27damxsfPbsGTR7e3sHAfjp6Og4ePDgnz3KX0AHCzOrt2/aXr9+2/r02eOWJ8+f PYcP1t7eDosM2Z0/f2H//v0BAQF6enqysrK7du3i4+Nbv349Dw/Pjh07xMTEFBUVTUxM4uPjDx8+ XFdX//Tp01evXrW1tXV0hvaOU6dO/fnnnz97rP9pwI6jUpOftb588uTZ/fsPHzU+ev78OYTz5s2b u3fvYsNiL5PJ5ODgYGxPQ0NDeXn5PXv2bN26lZ9/2/btAjt37pSQkFBTU4O4XVxcgoKCQFxWVgaF gN39mbTbOiD/e3cbVq9e/bMH/R+FKVOmHqo43tLS+vBB462btdDb2M4Q9+3bt6G9Iej09PTk5GRI MCw03MrSTk5WUVJSWlJCEntcWVkZmxq2Xlp6r4yMnJKiqouLR2wsCeo9Ozu7qKgI5r6hoYGQNXY6 3Wt/3wZj8erFG3k5hZ899P8czOKeXXPmUuPDprra25cuXa6vpyvhO3fuQNCJDIADlpGRERQYoqGh A/mqq6tra2sjhaDl5ORQgp2Ofa2lpaWvr4/dDVWvoKBgZGialJQCg15SUoK0srIS5gChHNT7yxcv X7+G2nj7+lWbnY3jz56A/xBM+GPC0SOnbtffvXjxMkzqlStXsKOrqqrS0tKio6Pj4uKwSSPCI+Rk 5SBciHX37t2bN2+GHl7JgOUMWLFiBfET5Vu2bAENiCF6LAlNTc2cnJz8/HykWVlZcOSgN1paWhob HzU3t7S2vnjc8lJZUf1nT8N/AoYMGZqetu/69VvV1TWInmCgIQ54WYiYYHzDwsIiI6KhpbF/4YZB jhDrokWLZs+ePX369KlTp44fP74zN5RwcHBwc3MvXLhw2bJloEddWHklJSUdHR3IGiuHbtBLy5qa muAP1NXVPbj/kKFVHm7fJvSzJuG/A1ZWjtXV5w7sP5iUlJSbm4s9mJWZZWZmZmVl5eDgYGRoBn9b SEho3bp1CxYs4OLimjJlSu+ZQ+6E0KHwofzFxcVjoumhOhw56I2LFy+ePHny6NFjWGBVp2uKCysm TJj4/Ub6C/i2bC8qOpCfX+jp6WlqampsbAybu5UBiLDWrIGQ10Fvb9y4ce3atVDUSxmwZMkSpH37 9u1NE8OGDYPQoRNERUVVVVVRUUZGRkREBEsIP93d3e3t7e3s7L29fRzsnNRUtZZ8hKWfA0qgN773 hPyLYfjwEZHh5PLyCnt7h6DQ0Cu1tR1fA3aOX+FfsbGxQehz586lUqlf1Qrgen39tfr6tJycCRN/ 7f2/D0oKWkWFpWlp6RA3tjM1MfF6Xe3VWzfPXblcff7c6XNnq86dRaY7Xrp+DVKAg716zZreN8fO zn7mzBlUvHLzRneeaOs0A5FHBy7fuI7OXK+vBfGlG9dgXAYMGPD9puJfD5MmTvH1CSkpLvP394cx 1dDQgFE+evz4/UePGhob6+7evV5be+3WrRt1dSwR/jRdcDdujB07tjfN8fPzNzc3o8qt27fBuQs3 oi2kuHq7oQF9eNDUdL+x8U5DQ01NzbZt2773bPzrQWSPTFRkbHh4hK+vb2BgoKurKyzjrFmzbtbW NrY0P33xHNj89EnTk8ctrU+Bj5+1Ekj8RDmhaRFb/WVb8PoI4ofNTWAOtgRDghWzFbTY+vIFyvHz waNG+O2FhYXQCd9/Mv7lMG7seAtzh4z0TEjZ29sbG1xLS2vNmjUTJ07EVnrY9Ohx69OXb9+00e9t s0D6nbGOjrftH26D6+rq9tQQ/DSsB4Ls2csXr9+/I+ow+TB5vm17/+LNq1Yss+fPmltaEKBhHQ4d OvRHTsu/Fdav2+Lp4RsZGe3s7Axxh4WGIVbi4eFZtmQ5TCQM5ZMnT953eajRM7x58wZuc/dWEJtf v3699y5ZW3v769evGxsbL1++jGj9x0/LvxL69OmjKK8eE0O2tbVzcnJCCGxoaIhoa/fuPfCcOTk5 EWHFxcU9e/asnfnM8q/g6tWrv//+e+dWEGqBw1fIuq3txYsXDQ0Nhw4dWrRo0ZTJbH9Onfazpujf BJMmTdXRNoqJITk4OEKZBwQEYF9v2rRp+zZBzDMs+ODBg0eOHFleXo75773EExMTCf5YLYjiey/o DoaTD30CN41CoYwbN27rVn7BHTt5eLZ36TlsDQJwPj4+BOxqDEBm7dq1c+bM+WGzN2PGDOY9AWQQ Xf6wpv8eLF28ytjI3M8vwNHREcrczc0NWxuB2LRp7FC/8LQJi8nFxQVVDO3ae4nr6OiMHz9+//79 vRc0mMMWPHr0qLa21sjIaMyYMegJQ9vwcs2Yi2BBSkoqIiLi1KlTIPsyK/Q2ISEBffjyfb9ly5ad 6gTJyckRrEBI6NMd3dGjR+vp6ZWVlWFNdm/35cuXJSUlCgoKvbzv9INBUEDExpp+I4vQ5JgfbG1p aZlJkyaxsbENHz6cSQmDDkG8ffu2l7KDROBifZWsMVcPHjyoqqqChkGLEhIS8BWRR6/OnTvXe1Zd ABZh3bp1LIevra3dm46BDMTz588nk8noZG8aRYf/1w7jwXDvlVFxdnJzZGhyhGCYXoh7h4AQNiYU aRdnWF9f//Hjx1C2f3vmewIYaxj3O3fuwHXHMhs7Fo2Pg4a0s7NjOb0QAapg7dEfnr58iaWFXn1Z 80RHRw8ZMqTLDEAD9KZ7/Pz8iB//UqV0gZs3b44aNerHifOvYMSIkYoKGr4+9POE7u7uMNybGTBt GgfsNeKmQYMGdakSFRXV2tra9fQRK2jvaG9r/wsyELx+8xrYwoi20AeixWls0yDrixcvEmRv3r4B DdK39JPs9KNTMCuEzofffunSpRs3bkAtQO7tdJG3E02/b3sPYlREhuBz7NixLhK/desW0Q0C6Ycs PuK79+/QIlERer776Jhsu5ej3Q7GmsTE/jhx/hXA490ro+Tm5gGTDYcKsS1kDaXdr18/yBpRGDJd qkC9FxQW3G2496i5icDmxy2dsamluRHFjAxxlSDDz875+w8f3Ll3t7a+7lZd7dVrVy9euigmJgb+ /fv3RwolQ2xqNFR/5zYo791vQJWHjxoJhHALCwsFBAQIc4NNxMvLC6EwGyK68aDxYcOD+6gOJMTh 5+/PHMvUP/8EDVGFQOaggER1FD5++gQpGkVnbt+9A1bgSYyFWZFAZrvoKurevd9w7dq1HyjPvwDO 6dxysiqenl6QNSJuCB2GUlSUPu0DBw7sydmYPGXK/oqKc5cvV58/X3Px4tlLl7rgmQsXcAlIZJAS ZEiJKtXnzlVWVR09caL8yJHSgweTU1O5Z836jWFckC5YuBCybn316kRV1Ynq6tM1NUQtAs8yUlpy 8pCPhoaoBZgzd+75K1eIDnzW6LlzJ6urT505U9/QUHX27KSPLzXwbt36sLkZNERvmcisDgT9CUZX Dx46VHzgAIVGy8jJwc8z588TzAliJjLHi4pV585dvHoVDuf3lmMvYRb3fHk5FR9vX8jaz88P5ht7 REFBkbjKnMbusHLVqgMVh8qPHD107Pjh45XdEeVM7FxYfuQYMgcPHykq259bWJSdl2/n6DRixAgm ZwTs0OpNT5+VVRw6cOhwxVE6PVJURHqk8gSw+tyF6dOns+xhXmERWgEls2kiRfX9FYcOosPHKzds 2kQQa+vqNrY8xaXOve2CpeUVBSWl6Tm5OwSFmJ7MkqXL0Lcuo2OOEa0TeOTEyZNVZyb+zzy5mztn 0d69ShC3v79/UFAQAjGEsWpqvTo4JC4lXXSgoqDsQH7p/l5iXklZXnEp0tyiktTM7KT0TFEJyS5s 9YyMX3V05BQUg4Zepbh0X1EpUqJ6fsn+89duZucX9dSrk+cuFJQeQJXOCFY5hcXIFB0oLyk/xMPL SxB7BwQdPV2N8h67WlyalrMvikzhnDGDqMJcYNb2DmjoSyMtKQMBmuvuH/4smDN7kexeJU8Pr2AG YHcjztXQ0Ohldf+wiNTcvOTs3N5jUlYOLTM7IT0zJJo0b+GiLgwnT5168MRp8EzMyAYx0kSsiqwc oiLyafvyL9yqb2xsPM2AU58DSu60PI1PTe+OlOTUuORUZFJy9m3YRI/yBgwcSE3PBEOwZdlPlKMD lNS0TTxbuo9dTEr6C2Mnup2QkRVOjv9nIvqWMHPGPBlpBXc3j7CwsPDwcB8fH/hIKiqqf1kRKzY+ Pr75XQclNYOUlNp7JCenkZLS7Fw8xrB6VCq5V+5I9fnohKTYxJSYhGSkzIpECTIxtGRycnpSdl56 QXF28f6c0gNIgRmFJdT07ChqYhg5PiIuoQuGx1FDYuLCSPFgvmT5CrTFwTkDfGJoKcDu/UQhWoym JfuHR7E0aiJS0plFpSzHSO8qvXpqVHyiilaPD4x+GMAHI4bAwT5TRprumSO8QliKDQ5fV15e/svV OTk5z5w586Stg5ScHklJjIxP6iVGUZNJyRlIB/XwipC5nQMlNQs8w+MSunKmJEZQaEhDydTgGHJw TFwoKR5kEQziMBI1jExFJiSWEhJDwaXOiELQB0bGBkTEhJIoM2bSb3XybOUvOlLJoiFGW/Ty+CTw VNc1YNlVdT2DtIIS1sNndBWIpleuYX1750cCwisivJ00caqYqIy1tS2JRIqLiyOTyYIMGDp0WE91 d+zY8eTJk9NX6khJGdEJqcDYxLReIikpvaD8WMv7DmVNHZbMIylJpMR0UMbQWLBFWygPj6MFRpJ8 QyP9wqIDIkiBkeSASLJfeDQQmcBuGBRFR1D6hkR6BYWHxiYQLr2ajn5e+fFoakr3tlDCGFc62uLd toNlV32CIhMy9vXUT6RRCSlgzlKJ/WBAbEuEq8OH/y4qvFdXRx+CplKpqampQkJCu3bt4uHhZVnR wcEBoWvZ8WpySiY1Yx+BCZl5H3Ffp8LO5Z8wKafw7tO391rfrt2wqQvzwYMHJ2YVEAxZcqBl5SVl FypqaE9j52DjmD7taxG12NnZ2D8caAyIImcUHfi8/58NBNKMT8tmn87iRujUP9mSc4toWfksh0l0 Pi4t2zcs6luK7R/A6NGjR44c2ee3PruEJOXllChxlMTExLS0NFlZ2T179piYmHehR/BYWFgIWWcU HKCkZGMqknMKEzPzMf/IIIWk8BMpM09c6oz0S5n5uaWH6WvmWNWkKVM7NzFs+HCwpaRmE3WZ3Jh8 0vJKMovKdwqLfYPhjxmTkluckltE8O+CRLu0jLwoSgrLmw+beLcePXsFZMSgulbPzE/OKUpI36eh a/jPu/pNAOIm3rjcsJ5fQlwmPDyCRqMlJSVh/woLC5uZfSbupUuXIha+/uBpLC0tigrHJpOSmkNO zoxLyUImLiUbGSKPQlxl/CQK4dnmMBE/QYBMdkkFJO4ZEDZw4KebtHAnQmJhjhNjEtIIMoLtR8xO 3VcKFJGQ+Y1VxD1nzpwlPQPxgJJr5kyCeNnK1bllR5ld6ozMzsfQ0g1MrVjOnpKG9v7KM0QPe6ie jerrNrFw6X8KjBgxgp2dfejQobO5F0qIy7q6uEHcycnJ2OPi4uLS0tIzZ84iKJWVlV++fJlffjwg AqYwLiSWGkqi0dPYhDByIvLI0JFEC4qmgIYg+1DIoGHiB2J69YT0wgOPXnXIq2p27pWytr5XcIRv WAyYgBvR1oeKJBopKavmxn1LB7fuw4F7+eWb8yl5JeCzcQsfQS8iKVNQcSI4hkr05zOMhb9HDYqm +keQ+LYLspw9R09/CLSn6igPjIoLio77Y+Kkbyq0vw+w3RwcHGxsbOPGThAXk9fU1E5KSk5JScnJ ycHUSUhIaGnpDBw4MDIy8nlHRwgpydknxMUvzD0w0iMoyj0wAqlHcBQzj3JcBY2jV6CjV5CTdzB+ guATJRMZxESaVXastPLcitXrmb2aNp3T1s3X3sPfwTPQ0TvIySfY2Zferpt/uFtABLilFdLVgr+/ P3Yr6DEEfn7+ffv2vevoiKJlgoDJHPSu/mGu/uEufqHoDxhqGVkwHwFom1gGRFNRDv4s0CfEyTvI xTeUaeg7A4yOT2isq18Y0b3uiHJwtnRksSx/IkyZMmXBggXDhg0TFBCXlpJFLJbBAE9Pz40bNy5c uPDEiROl1ddtPQItnL2t3fyQsXEPACLTOY/U0tnH3NHLzNHTxM7d1N7DDOjoZe3mT1wl6JlIVATa eQcXn7wUEEObMOnTCYSFy1YY2riY2LmZ2rubOYCPJxDMzZ28zOk8/WJTC1502rbIU7LLHH1CCc4g AFq5+lm5+Fq6+Fg4eZnYexjbuclr6o/4eJ4KniouWTp7d27iM3TwMHfAWDxYRtwzZ89zCYgydfAw 7akuUnvPXeL/W+frxo4dS7zNt3DBCmkpBUsLq8zMTKh0Z2dnXj6+m83NQdR9upauupYu+tbuhrZe +jYeBkBbTzoy8vRCa3cdCxctMyctU0c1I1tlPYtZ8xat2bRVy9RJz8qFICMomfihuq0n6pq7BOWd uK5maDNo8Ic7jVxcXDNmzVXQNlE1tFY3ttM0tdcyddAk0MRBy8wR/SEYEkyIjJ6VG8p1zJ11LJy1 zZ00TR01TOzBVs3ARk7TZNGyNZ0FN3HKnxiXpok9HZnMO6GGiYO6kd1OcTmW87aWZ5uOpbPGl6rb axjbzVu84kdIsdcwatSouXPnrl69euLEydKSynJySiEhIbq6ulZubofq3hq5hCjoWSvo2ygbOSgb OygZ2SNVMXZESi9hFCoa2MrrWcvpWu7VMpfRMN0tqzl+In2f9h8wQEhaVU7XCgSd6zKRKEQGqaFz UGxhFd9uaVQUF5fctm0bnIphw39fvp5PREFbQsVQUs1YWt1EWsNEWtNURtNMVtsCvVIytCOQ3gdd K1l0QNNUSt1EUs1IQsVATElPQlmfd6fkdO55ffv17zLw2QtXSKkZiasYSPSI+uAzf/lalvPGt0tK QtXwi9UN9mqajRr7x/eW4NcCnPMNGzZApa9ds4V/q+DiJct9E/ODs07t1XMQUzWV0LCQ0rKS0rSS 1LSkZ7SskX7Ia1qJq5uDRlTFWFjRYLe83gYBsSFDP510GjthioiykZiKiaSG5adadA5M/FCI1MA1 wj48a9ailQICAlJSUpaWlhoaGsuXLx8wcNA0rrkLVmxat11sm7iKkIymoIymkIzWLlmd3XJ6uxX0 kO7cq7NzrzZxSUBKYzXfLu5FKydMmdZ/4EBmZ7ro5PGT/pzGNW8a15yecS479/yhI0aynDQ2rjls M+jYU3V2rrkc3Au+k8j+CYwfP554A3f0qDHTuJfElF+3DE4VVTcTVjERVTMX17T8iFZIxTToiLyY uoWIqukeZWNhZaOd8vpC8roLV23pHp/OXb5hj5KRqJoZUZFRlwWKaViAp3V4loZd4PjJbJKSktR4 KoVC0dHRWbFi5XR2rn59PwRrg4cMGzlm/CR2LmK2mThlOjfKR47pupv6MOBHzOP/H5g2bdr8+fO3 ikhlnH+u4xoppm4urmEhid2nYyOlY8tAm49I/4lLIIAQRVVNhZWNdyrocXDPZ8kZbjCfmDIYSmha faxu8znaMnnKGjr5pBzFQtq1RyQuLi4pKUlJSUlUWEJQQGTu3HmAcePG9eZJYm9EjIhjGAOGfwSW x7R62VZ36EKmpqa2jwHObm4//WEoAnAnf/+yG68MXIIVjRyVTZ1VzFyRKpk4Ie2MKFE0dlQwtJM3 sJXVs5bRttgjrz12wpdCy3ETJ8vq2cgb2KFiF26d2RKNGrmFU8svC8mo6ujqampqKimqKitpb9zA B+9i1qxZXc6E9DS3vYGsrKzmbnDnzp28vLxNH08+fEOgJCaevXz5wpUrBSUl30PbbN68GbGzgoIC 7PKXKRGLHTp0qPTiA2vvCFOXAGNHX0M7uuesb+thgIydl+FHNCDKbTz1bNy1LVw0zZyEZVSGDhv+ Zf6ANZu36lq7GdgyXPpODD9ja+uBvIlLQGhq8b5TNzfyC61auVpRUUNGWg3zD3FPnjy5y2spfxug cw4fPfqwpelhc1Nz61Ng09MnD1qaGxofEpGdl5fXN2mIgEmTJt1uuFd/987t27dNTU2/IWcCoKnA Gd1+/KzVzMzsC5RYDA0NDQdrbnmGxSGQdPQNs/cOsfUMsvMMtvMKRr4LohCXEE1buvpuFRLu27fr qUWW0LdfPzUDi554fuDsSefs4B3qEUquvPog/8i5WXMXbOMX2cLDKyQkhPChyydf/gkg/GxsbHzz 7m1LS8uFCxcqKytPnjx569at1tbWF6/ohyExJzAc36o5WAp+fn4+Pj6kX/Vhk14CbDFxDvzdu3dw uXsiE5Hcm5xfFkFNCY5NCIyi+IXH+oRGe4dEeYdG+/SAuOQZFOkaELps5Ve8tg+YyjbNIyjCKzSq J87MptGN4FhaTFJWCJk2esxYbG345wgfvuFpbfilHYxXHmpra7m5ucF59OjRU6dO9fPzQ2F7e/vT p0+3bt0KSiwzFPr7+xO7UlBQMCcnR19fn8mqf//+WI0kEgka8uDBgyBeuHBhl+bAxIkBioqKXS7B ZYImKSsrO3z4cExMTE+fEIRmMzIyys7OPnHiRH5+vo2NDfND8VpaWighlNLr16/Dw8PRW1FR0c7V Bw8ZomdiTklJj4xPCCNRgunPgqP8wiIJ9A/vEQMiol28fDg4OdEx9P+rzJzgHuEvcAYyWw+KjImI o8anZbr5+GFCsHq/7UlOa2vrDsarPZBRZ0uKddXW1oadgl1PiNvc3JyYSWgAxIYdjM+3Mt9FhW5E +Yez5R9fZ8CCMTEx6dwc8ZYK2JaUlDAL4Rb6+voyPgzbTqQdjBcrVFU/O0eE5aSurk68mtTOAKKV s2fPIp4CwbVr1zp3gHg1w97evsuQBw8ezDGdk4NjOjv9QTDHNHYGcnxEdnbi0fCnEgbOmDlz5cqV CJRsbW0jIyNTU1MPHDjQnTlLQM+Jhrqz7Y7oFQfnjIWLF3NMn/4N1TgBpaWl9FuvL15gwn/rFJLv 2LGD2CN1dXUwuCiB50ZMJl35v3mDaUeG+P6PoaEhQYwSaAlYTywS4nUqzDyxWgig0WgohKXw8fEh SrA3YT4gmkePHt28eZP4liBYEWRsbGzMupmZmSh8/vz5vXv30AqcyaamJhDfv39fXFwcPjY8TOL7 tKiOS+hGfX09tFAvpwIcoDqgkVatWjWTi5uPV1BIUFhIaJeSkjI2BTpMpVLLy8uhVRBWQL0ghTKB Hjt+vBJ9A83atZ/dicLawKxiyGFhYdBI8B6lpaUlJCTgeFtZWtnZ2Tk4OMDBYByo2MKzmW/LFoE5 cxZiU8+ePRuW7hvaUALA8GZtbTtDKMLCwszyiRMnFhcX19+5c6uurqiIfswVnuHFK1ceNDY2tbQ0 NjXVMcrJZDIuQYEz3ndowPxHRUWtW7cOHdbT06urr7/T0PCouTk3N5dYRQi7qmtqmh8/xmLA2Im2 3NzdUf3egwfY79ikiAGhJ2/fvdvy5Mnzly8Rfv7GWITWtrZEK1evXsUUwS6vWLEiJCSkpqaGeD9x 5MiRUlJStfX1T1pbGx488PDwgKAxqK/6TxAsbHQeSx1aa9u27VoapnY2Lna2Tm5uHpAsfBsM/OHD h1jq16/fgNHB0LALCgoKCgsLMWOlDChjwP79+5GiEKsiJSUFcxUdHZ2WlgYCVDx+/DiUQ1RUtIW5 hZ6uoZ6usY6WKR+vAC8vL4zFjBkzvsd3zpcuXVpZVXW1rg7iDggIwDRCS0NkEMf+w4dzMIyyslWM DwotXb782OnThyorK44dyy8pQSHxNA16ODUrq6yiAqip89kRLH0jo8OVlUdOnDh47BhhgGbNmXP0 1Knj1dWV1dVcjHeBl69cSbcO1dVoqPPrltb29ifPnj1ZU2Npa4uf0zk56xoaSsvL0atVnT5whD78 2Wn7T5w0CczRz6MnT3L93XeN4RphWqAu4JZgM2qoG4UGxYUEx0RGxmRmZl2/dh3ODN2PffECOgRy r62tO3XqFHY91gMhd2wE4sOnAEIbYJ1AHUELYalA7WBfoDw0NMzFxc3FycPFydfE2FFwxy4REREs dUTZhDr95rBhM09pxdG0nLziiiO1DU3vOjou3qzPyCukpqTHxNMiSJQt/B++87NHXLy88lRqNv0I NA/fJ+W8YRPP2Ss3kzJzYyiJIxkOJDP8X7NufVZBcfq+gqT0LOIS/44dlTXnURIWTRrIuI1jYml9 8uzFI1U1mBC4dtitxJHvQyerU3PyUrPzVTXpr5pKychXnr2QnJnj/DEqZHmTYQsf/+kLVzPzi+No yV84XviXAAdp0aJFAgIC0LrwFmSk5R3sfKMiEmKi4smk+LLS/fV19fB2XjO+Wvue/m8TbYQvAVcB OwU2BSnEStC8ZAAyMEMwWFVVVXFxFD9ffx/vQF+fUE+3MGUlbXFxCWj+jRs3fj9ZA4QlpHNKy0Nj KUEx5KBockBUbGBErF9YlHdQuIaeIVun7/yoaOrEJqWFkuK1DT9zvbT0jXL2V5CT05U0tbowF9wj QkpKC4mNs3b+8KRbU984ITM3kpqkqsk4ftynj6OnbxQ1OSohOSYxDeUR9DOrieFkBEckdAPpqnX0 p/8OHj60rDxySsY2wZ1fGI6qjl5iTn50QrJ+t8NmXwuITRBEYP5lZWUNDAxgUxTkVXy8okgxybHR 1HgKLTMDocHJ+vrbkGNPrwATH69+9eoVpH/+/Hns+5iY2JDgsMCAsODAqMAAkq62uYSEpLy8PPY1 jCAXF9d3/a8KK2f36ITUUHKCuYOL+F4FCVkFUSnZLfwC3Y8xWDm5xSSmR1CSNmz+7JSmmZ0TOGQW H9Q0/OyeyYABA9KL9ofF0cIpNN5tAijp17+/e0AoJS0HfHi20pXGgIEDvYIjomlplLRsRXWt3aIS u8QkhSVkdolIbBUQwmrZKSI+4veRYOUXHh2Xmp2Qlbdj156exoLN7uztT0rJpKTnCOzskeyrAPOP CIWfn19FRQVCl5OT09TQD/Inx8WmxZGSE6iptISUjIzsw4ePnjlTU3urFpYdihqeJFzEGzduXLp0 +ciRI/l5BWQSJToqNiIiNiI8LjKcGhlGMzd1EhMTJz6lCwUOZcLJyfnN/fDOAAVLSs4gp2TGJKUv X8364SYBw4ePiKKmkFOzyClZ8xcu7nxJ18QcG/Ni/cPHz55hZohCBO+IU6jp+6JpKQFRpEGD6Kfo R48ZCw7JuYWQ2ux59McKffv18wwMReHhmkvrP38zpXOwjCjG3T+YlJTx6HXHgcqTTB0OF9rT05N5 IGfosGGhsdSs4oM1N+5gV9JLhg7955+MgCmfM2cOfHU4hBoaGnCwlZWVlZRUzE2tgwOiadSchPjM xIQMWkJaAjUF0k+kYQ1gJSRR45Pi4mhkUgKZRCPFJMaRUiPDE+1sPdRUtOBSYuXARd+yZcuSJUug wL/HHacuMGf+wvC4FK9gqO7IPxi3+nu66z5z9tzg6HhvUAZHjfvjM22zaMly94Bw75DoVx0dMEzw 92CCEU8FxyZ4BUc6evijFYKSnYMzipoOPv7hZOahNSUNXc/AiEPVV2HXXF1dEWgjnLl06RKq7xaV 7PNRWDt2CXsGRQREUaAh4dM6OzsjJoLdjKFlKGvq9e9P/2Lk2HF/eIVEh8TSXjK+FOEXTtIxsezl rc6/BFjzefPmrVmzBt4+FDsCT8hdTU1NTk7ezMTCyd41KCAygZKRQstJScpJTKAjVkJSQk5oMNnT zd/a0l5dVVNGRgZLBYoCfiAfHx92BwKuH/YXJLzbd5o6uBtZOytrGX/5UcVG3u2gNLZxUdI26n51 j6ScgZWjmb27tVuAvTf99q+lk7eJnauWsRUbx6dD6avWbw6hpFs6+2iZWBMvrQMmTJyMn4ZWzmb2 nlauvtaufuZOXkY2LkY2rtt2iTJ7NWz4CHVDS0MbF3NHT8bt5RA7jyALZx9LVz+xvUoEt99Hjjax c0NdYzt3MydPsBLY8w2OZHcGDg4OhGkIADds2AC5w+bq6upC9PDh4dQpKirKMkBTQxNhJoSLLYy1 oc4A+gNNUVFIGXEWdjQ0RudbCj8ANm7bvUtKaae0yvL1rF+aYMJ6vp2g3CWjunwdC8pBQ4YuXrlh p5SyjKaJnJa5nI6FoLji0jWbhw4f0Zlsp5SKspG9gp7V5h0incvHT5y6YetOMQVtKVVDGXVjMUWd zQLC7FxdvxY1ZvyEdbyCooo6exmtSKkbbxEUmzHn013xPn36Ll/PIyynKalqIKmqv0NcYfyE7/Vn fLCz2OzLli3Dfufh4YGex4aF9LFzofCJb15B+pA4RLx9+3YYF5gDGGhIGWvmp7zy3PuHj316YQH7 9us/YtTY0eMnDhsxqsulP6awbxVXsYnI2qNkvFvJ+M8ZLD78NXjIsFHjJowa+8fAQV96Aj5w8JDR DLJBQ1jHWag+/PfRg/9BFPZVwM7Ozs3NjS2PDYtdD5mu/Aj4CXW9ePFiLIyZM2d2+Y7TT4HePyL/ MmX3S8wSzL+UtqWRR5SUlqWYuomApGr/AQO/XL33XeoN2Y+HyZMnf7/Y+X8cxv0x0cTJR8/GTdvC UUHLeNKvjz3+q2HMuPG7xCQEd4ts5OH7X3j98xf8F+D/ANXK5mENCmVuZHN0cmVhbQ0KZW5kb2Jq DQo3MyAwIG9iag0KPDwvVHlwZS9YT2JqZWN0L1N1YnR5cGUvSW1hZ2UvV2lkdGggMTY1L0hlaWdo dCA2Ny9Db2xvclNwYWNlL0RldmljZUdyYXkvTWF0dGVbIDAgMCAwXSAvQml0c1BlckNvbXBvbmVu dCA4L0ludGVycG9sYXRlIGZhbHNlL0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGggMzgxND4+DQpz dHJlYW0NCnicxVppWFNXGs5GViCBkEBYEkLYCcgSIICAoLIngApYqMUFFEVc6oIoKtuoqHUXneLS mQodx9FqnVqBaltq1bYo6gMiIFAUBESsiIBAljkXErnZWJ6nA+8Pntyz3POe73znO+/5LgjEODDn WNlYWbCMx2s3PTAwtnTxnRsSFh4hiAgPDZnj48g2ok43KQXoMaw8ZocLIAjXb970sRD6FRbgyqaT p5uaHBQjO3/AcF7O1w9apSPoabh5LEkoCPHi0HSnm94w6FZ+EYIF+++LpEp48e9kYaiHucH009Rn 88MEMed6lRmOoCJNGOxmpkecXo40u7mCqBNd6ikCiH9IEs62oZKmkaKusUtYZF6LRooQBq4sDHGg TR9LMtMnIvrSmBQhPEsNm2GoPU0cdc39hfH3x+UI9nqWwN1oeljqMP2Fqa0KbCSiof53PT19Q0Mi CbxcdCrKnT4dK04ymSlM74Ez6W2v+uHi2cP7DhSeL6n4o6tfDKu8GuVqMA17nOYuSO2GUWyrKM5K DA/w8XT38PabG7P2+I36Lpg5iyId9PBTzZFsE5bY/oGCuP324cQAVzsLUxpUacq2mcGP3nm99vUo y+MhHF3c1HIkMQMXVHwg0Hf/9KpgPpeio4UcbWLjEZ1XVvPhHHq/LcLGSA+AQiaip4YklRf15QeO vU9vFJ0qyM/fvc2dgoJNxMZrxcXHg/JWb6+cOrQ/Pz8/b8McElLzm/86kNghKf1qgs3dmdrw8a2C Dr5WbfQsGj6V/x+o7gsq1XCUSs45Yj80QhLtc9+otmnY7KIzFSSJrKAsdRyl0v4tZnKHQ5G9igZU Gohr8uaa4KdiuSlOMdXqSUpfzNMfYYCih/2qWj1UkRdmoTMVGwfPCNguD4E9yjTuziQClkiseXKz GkOXbpppQpgSjyRZRf0oG7X9J2WvE5+y1UIgSU75b1U5SsrXexhip2RrI3S5S2QGlJzMKlbWu71r jDF6vpeG1DnDjWAGHonCUwyZbDaTro0Zly+GSKHoUYiYyZPU5x+SDfpsZVDSFWU6f0Tbzn+gjqJU Wh/p5DZLuHpP4dVr1745tmP+bB6bLHNQJM7EzX+Wr6ebC4CzHYOAROtyvAWbd4H4uyWSz5pkbMUz wm7KBt0bwOKl3JEoUfn9cJt6jtLBM1erO2HCo7uuZIOvKQ4aH228reNlZ+fTaghVlflshntKWYss PIiefx1ugh2XGQwEs4UyhTYUY02muGXUKlGRqMZ55XnA0Hbcmwq2Es7jF3jpDwm7axSudq8zOVqT sSRzqWyFG3xoRIyBX/5LzRRks6kWj1Fb8xEDjdCJfgEv+/2Rco/eVYaTCAsETqasX6E1CYfEGof+ /d3YHN+V7O8eq/7lx3Q0PVUh8veptqr2mYSKItqelHWbT9dCI5B489hLg6rvHMWLL9LSXsGeRR33 fr7fAbfUE39ty6NjzhNgIJEyYY4oAveCrJvvcFxGkWyXl2teTtGjvTHCYphTDpTvT01cfQzuyZIs Fv+mckexsiPnmE54h6PwM76VvdoTMdwLTXbZVKOJY39ZeqB7Onz1ftvgZ2thLzgL3xf/9RA0KHST dFXc+KVdoUh6xGLCTonEOn8vs5G7rBOG6rOrQz3HrqJkHjscTqDv0tqooNnBn/wDTrI8dLmC14qf nEhLWPmloq/v4Ux852AcZCTFfLkSx5rEXVVVPKBF/ZEFtlTrI/CFE7193QnQpXBs3o7LUVjc57tD 7c2d1ytcRge3MCce0FE28uX2xcmmhrPeoBBA5K+9szPIXJs4q05NnSJ+WnZRYXJfhhrj0QbxChrl 1QrGxH0SaSHfOKGk4TMNSXTIVaPApZKKrT4MPIqcMGb8Gca3ax/BH7vTrcAxpPexQgB+FKU/YUOi cQx5CFqhh0FB6tb7K/UhqDXFHIxFWzvGeSObzpF0hU3y9CM6EoE0SnsPLzzvNfH8Akabki7rdskU h0ZgDAUVUg0o9cQjkGbZ8KL+57WPlXHv6xU7FFz6O38dMHnrU/CywRybSZyLenSh7Fjs4Gpr4Tip mtNqQ59ZYpDm+fCi9sKNaWlpa9Zt3JIhx5ZVUcEn4G3E+7jgcMF634UXvlppMoljUY/Fk+0SUTBd 3/WwhgTqMLqXG6KZmfBI/2w9z9bWzjVy76kzMpw+vt55tkIof7OOCZxdO+o5vLBq3sRdEoHQMXcp l3XcywsvVUlDK6AhXM9kLTza/LnJlmxgHVkCb3SeK1QI5Y0f0cA+piYrHOBf+0wm5aXN5h+UdXyZ PW50+YFvGl8JL6grSNxapGCj7jTnZQoBoCwQuKSSmwzl2U5KUJr4xMiPApV7mArEx72jzqjRNKPo Kw5z2Q4PAJLPHIFLYtyuw1t1rTad1AWOylt4R+OQPcqK913W4twx1KSko2gJl38eXvR2Awu4JCG4 Hl74ZMHkvl1RHBbs0hD6xHWXbynfedr3PtRIcbDt+u75tjQvBVVeHwe5pE40XN5J/+MzyVyxWcin 9VJ1GCjfmbhVhdKzD1NQmNrAm6afi7IT+ExtkvPnVc87ZHhRc9QLuCRCN7C07oW88PmDFKtJuSQC QeOvvaLOlN0XV/KtffNeqakarn50+37N8/b2jo721tpHJcWHtiSGuJlTsCis2dzUrDyAXIDtKYGm kAQnWkWvz86VISORR9Vhubrb6U3YMVGumU/UkGj9PJ6rT2SEn1N/SA6V7U1JXZORBcbMzly/PDbY 25FN14aElBYzIi1j27ZtGesWhXi52BgRISZaZJaDq5sMThyqtm1xY1PlTI3pYiSOamKij5NrEIxx coMqB1HVXoGlDhpJ4CSpPyarcoKdLGydXMCYLjPsLc3oZIIsO4D3qns/AKG3+fMABlFr2FpIDI5I koOIx1CiOsGdMVLjJ1UtTs6FrzYzRq7xSIJNuhqFO/BjxixT4rDe4OV0quHYc3a+CRmNJQyPTMBh UKO6S/+T0VBW6aneVkjDjaC2JoKiyZDkBSAu3nQY9lykjsdpNfnTd99tDKSP2BpjGPZP1QUX/bTV lab+/SjW30BEkIiHA9VQuinNyp5lYGJnro1CEoydvPh2dCwSgTJddaeu6piXDhJrYOfJ58pySmgy h+fjbknGaHuclEBfOdgEKKMX/LOaPdN3fU88j0UfmROes0z1G1Tn6blmGqyAcb0GOLZU3K2Fgv7l WWvu3ruacLruAkebFfbF47bWylwXXSTGalftHxVLLAh67tkVLW1V+1x1gJrTdki90fSyuTzR2vVa B/SSqiNMIE3cKtU63ODpOGGQr6sdh23KtuIlnFIRwX2Z9poEAiEY3BwH/7V2xT7oOle69Ffge0AD X/f1KRhRveIfvXXwfBBLX8cxTGMfDBtJUuJGQBuEloysWXe+PD1ewQMXBZsVF249qH78uK7xxZt+ uE17v4sUCAThEKIWZf6nXqFysKNsEVuT+Kd88iew9Gae45IH0M1hK/BoSLV8sbT8Q/9iOz0ow/Es 1iYJ8neoWrzDlCZokjf4br/sx3U+2EMGzsJlqUARpm3fe76yRVECDTRe3S4UCIQFt18qHoRvHxYu dtOUhEaa5gGXrFnjO/cQsH/fvqPDR9bAq4M3oKk3N0IZ0M5oq41AplctnPdYKn1f//sLYIFf/OYA e0v+bGjuFVem59SDIftb72fYA0cl0ljWtsMIiM0ufarujqgMSVvp9nBnHU1JRgwX+tLb9vC3Wmjp ft9aCnVpuXLgOFjArsv791wCCmkoc1YRKP52MbheDT0s/nspUH9Ny46Dho3nduWfubApPAESf9VH l/sYQvNGYbSwI+D4pF6qHl8HDT79d5IbEx5yFIHzvT06n8acVMgxW48lLgE+OHQtydf/UyAHRfkL wV4cPJoG1nywvbmpFZi1OQe4cm9hrJdX4BxXayGoF/0z0pZGUHo9yyW2oKJDbU53dNie6sIYLkMD QQik0eRF370cwfI2aGihUwK4mnVlu+gzEppAhNu6GmzersytsHTBvcPgoTnNmqxLNdClLgD032yy JmJUzk1Th7mZZY1vxlBi/S03c8JsDcfgiNBf/Cf0jfftm/bKs2t8HVcBH2xYYWG0CJR2rmPhLLaB Za9dtRP8rUvNBe7V09HS0tr+sqng6CB0rzTAURm6aGoyYPw0nq72aLfyjDtwq7lXg3IbaLtzKN6D oyGIjwDF3A22X/s3p47krgx1oFtBu+hWCMXgY6BTxJcifTeBe95QYdwxMZRZ3Q6Wue36l0X/ffTV tvi899AH/8DZud8H0Zk7AOPKdbMM1X5+MbOfmXiioqN3SIWnqP9lxcnF3nYmY1EE8WI4lN9InuPt am1IwjtfAU9FbnhK2D3In2uqgIVE95IjLoLi4rBVwLziZw/r3kmrYnnJUBbm9cOnYuljX4djYPze 1mo3DTlMFtd/6cGS2s53olG9KBH1dT4pObjMn2s2NkUQyoOegqiyh0cjk3BoJH420Ff9O6wwROc8 +Z4U3U/3EYIQOrDLI6JEPkRNMDOwWO5nTQLnw8M/qv013tbYjvzQ5fsuVz7r6ul7P/C+r+dVc+Xl /OXhXlzmeBTBvS74j4HBpkWMEW8izWkYGGxMMEJhjIVFr6A9+b7z+ib/GSvB2dO10pK7+s47QFP0 pmKdkx5n2Y894EHc/WgLzy6lVSyVdJ9xH+tKyeF6zFm4OutAwdlzX5z4bGdafBDPnm00PkVAa8aa gpOfepBHIhRxRtrxE+vddZFIkuW83Zd/e3Drq92L+B5bfwVsHkTSqe4pJ2/e++1awRo/IzxlxtJj 31feLyv8NMDEaGbmN3fLDsRYjPPvCeY2jq4efG8/H767C9eaOdErCZbm6OfnSMPKn7h+flzoCa3N 8oxauuKTCE8OewmUFBo4yiNhqbYBHyUnxc12NCKgtPSs/WOTkhfOcWIQiQz3qEUxfhzdiX23NB4r JqoBCkc2MNDFolSeUDiKsYWluRGZwNoD7aHyBKYWEkM0YHI4ZgYkoJeRaCLVjMNh0khaSBROz5hl akAc/yPbXw1wumHQKASaubm+/fm3q510IQZINCiUU4E9IFFojYfaFABNm5manRHnrD+xT4z/A1P+ MbQNCmVuZHN0cmVhbQ0KZW5kb2JqDQo3NCAwIG9iag0KPDwvRnVuY3Rpb25UeXBlIDAvU2l6ZVsg MjU2XSAvRGVjb2RlWyAwIDEgMCAxIDAgMV0gL1JhbmdlWyAwIDEgMCAxIDAgMV0gL0JpdHNQZXJT YW1wbGUgOC9Eb21haW5bIDAgMV0gL0VuY29kZVsgMCAyNTVdIC9PcmRlciAxL0ZpbHRlci9GbGF0 ZURlY29kZS9MZW5ndGggNDU3Pj4NCnN0cmVhbQ0KeJyFwodS2gAABuDnsrV72zpREVEEkaGAoBDC CjMQ9h5hC4iADK1272Xbx+of4513rXf97hubNI6dv4ZTfBP/+jR3nEuMz1y8gbPETa6Zf2sOSa6A vC0g7+C8Be/yF6z3zt9fRNsDId/+cIn7SIQOfLyM1BMxd0LsnFhxPl1F1zOUuCYl7qk19ExLuTMy 7yyu+3BO7hPIacEGPa/w44IygIuqgFDFCNXMkjoo2gyKtkLLqAmLNeEVbQRXdVGUbMfW9DGpPi41 xGWGhGwnsb6bRLkxtWFKKUxpBZFWEhmlOasis2oyp7bkNq35LbQVNPaC1s5qHazOUdRRpW2qpHeW 9a6ywV3BHU9111M1emtGX92E9B6B/oY50CADTZJpWpiWNdiyhvZtobYt3LZj5MAR6VDRDhXrOjHe c2Hi0I3JvgdTA2964EsPkc6M6OzIj7mjAPeYyR8zhedB7kmQPQmxp6HiaRhLLyJYfhnFCr6KYfV1 HGv4JoH1t0ncw3cpbOD7NDbxQwZb+DGL+/xPuTb/cx4P+F8K2OF/ZbuXi91vxd7FUu879/Byuf/j r5X+WWXwz+FZdfjzyrXhr9roP+uj3/WjK/4BqNyYIQ0KZW5kc3RyZWFtDQplbmRvYmoNCjc1IDAg b2JqDQo8PC9QYXR0ZXJuVHlwZSAyL1NoYWRpbmc8PC9Db2xvclNwYWNlL0RldmljZVJHQi9TaGFk aW5nVHlwZSAyL0Nvb3Jkc1sgMCA0NjggNzIwIDQ2OF0gL0V4dGVuZFsgdHJ1ZSB0cnVlXSAvRnVu Y3Rpb24gNzQgMCBSPj4+Pg0KZW5kb2JqDQo3NiAwIG9iag0KPDwvVHlwZS9QYWdlL1BhcmVudCAy IDAgUi9SZXNvdXJjZXM8PC9YT2JqZWN0PDwvSW1hZ2U3OCA3OCAwIFI+Pi9FeHRHU3RhdGU8PC9H UzI3IDI3IDAgUi9HUzI0IDI0IDAgUi9HUzEzIDEzIDAgUj4+L1BhdHRlcm48PC9QODEgODEgMCBS Pj4vRm9udDw8L0YzIDMwIDAgUi9GMSAxMSAwIFIvRjIgMTQgMCBSPj4vUHJvY1NldFsvUERGL1Rl eHQvSW1hZ2VCL0ltYWdlQy9JbWFnZUldID4+L01lZGlhQm94WyAwIDAgNzIwIDU0MF0gL0NvbnRl bnRzIDc3IDAgUi9Hcm91cDw8L1R5cGUvR3JvdXAvUy9UcmFuc3BhcmVuY3kvQ1MvRGV2aWNlUkdC Pj4vVGFicy9TL1N0cnVjdFBhcmVudHMgMTM+Pg0KZW5kb2JqDQo3NyAwIG9iag0KPDwvRmlsdGVy L0ZsYXRlRGVjb2RlL0xlbmd0aCAxMTM0Pj4NCnN0cmVhbQ0KeJydV9tu20YQfRegf5hHMoDXe+Ot MAzUdhq4QFAXNtAASR9oibaYUlxlubLjv+8MRclaSau6fqFFa85czp6ZHcHpDZydnX6+vL4Cfn4O F1eX8GM84sAZ51xIyTPIJIdEc7DVePTXB2jHIwGPGxvOU8G1Z/TwYTz6czyCj58vAbYCiNcAJwM2 KdJsiJUrIQ7FkooVBWA0SDMmeAFJkTAuQLI0TQVM5uPR6fW8fKyyHK4MHAosh8Cnn25lBo/dUIEo cpZLclsgVgn8q0DlgmXJpo49X2qPJam10Acyp2i6j3Z6UzpX2RYmHbrKBXSTluBaZkz2SAya8vQo e3oIfHGHDn9TgJXcPVAlRI2AFHPRWEVaMFHA3Xw7Pqdq8VWo4fXTePT1jKvs4vxvuPt9PPqIPld+ xa7fXCIdctvv1+if6meso2oS++g1RGjNCuFDIGSbCMaVb1s2TXwiI/NMzw7iPCrBxkm0bNu6fQx5 UiplSe57+lK1IessZ1K+LUeVayZ2bG8sMmC+VxMHM9M5iFXkDNxXuz5WjDIUyUFWMecsG1zaCp0s mnJSTSEWInqu3Qyw7LI1blYRAUTFH7dAX5ilwwRCGWtUgzrk/t4YhxwGYAm1Qu7DtkPsaTLZ1aRf ZYFZEHFcMD0QR6rTh1TnI7HPGQpxGxndhCQksXmUb2vrOYmntHXzEp+oIFESQVnhY5cdHgAqHGEo cXwuHR6rRhHiEUxsSf/q8GSyqGqfamvaeUWxWgeoALSbmKZZAV1Q9avyZIZDbB22bh+MnZeuNi3E aYTPktwGM0cBc+m7+LJKJCRjkTDhA4KKl5wlvumNNaif730EFD3WOXtZVFSlfao7g+8W4hPsCUvM TM2ch5wnhdzNY8NqAJLiRBF5OPc9YaZ7w3KvBYeBKZXGUjfaPDwRQ/27BY7uZr1Kqp91R61Jk+ph 2U76z6Ytm7pXxAu2No9mJY61IrqvcD6ROAnmUF1VO6UundKXzvwSYoPnLNFe8KNkZG/qUlEUNBHf 0aXbyOjXpjHPJAFnSBRNh11Bk6oh+ZRT6qF63iv7sepI6MM0o9lme3X9WNaW2DumoXXkjDMtN7eS 7eVfNURot1wsKKR18C16ntV9Q84o4NRg4JaSctCfFvTHBctF52xVzg/Ni1XxezJYp6FxAr1mgRl0 obxzVJ0P+BYHbTOmCs/26DHnbztmjmrW7zrmLWR0PV9Y81ThxtLU5X3d1G6Ys3RxzSpkk6bogzVz KHGchO4p3MBU6ns+CY0NnrA0923v6+CITRTuVjuuSVHBoaRYtuP9KNvFm9jGgYUz5h1kbwH7dWt1 GQWEkmqWKw8SIlGgkUg8002fYs9Khh85PRLaaFazvCld35e2790ueGdkKW7knuvXfu4/TI9sK7kH /J9blGayeFOLCO6dGu2ouPDs3wuZBJ2k621v9WOhX5rXukeGpsGbWSj6WbHl4D83Zol9UOxAgjyj RLX2bW+XCyJ4YazbY04eKpJ+eeg0HLBn7l/lugAuDQplbmRzdHJlYW0NCmVuZG9iag0KNzggMCBv YmoNCjw8L1R5cGUvWE9iamVjdC9TdWJ0eXBlL0ltYWdlL1dpZHRoIDE2NS9IZWlnaHQgNjcvQ29s b3JTcGFjZS9EZXZpY2VSR0IvQml0c1BlckNvbXBvbmVudCA4L0ludGVycG9sYXRlIGZhbHNlL1NN YXNrIDc5IDAgUi9GaWx0ZXIvRmxhdGVEZWNvZGUvTGVuZ3RoIDk5MTc+Pg0Kc3RyZWFtDQp4nO1d BVxU2fdfu9decxFExO5uEUQRDDqku7u7u7tmGIahWxpUMDFA7BYwUBFQsQP4f2eejgiDi7vG77/r +ZzP/dy579xz49x74r373vz22y/4Bb/gF/wjmDd33sIFi5csXjJ69Oif3Zdf8C2hb9++mzZtsrOz z8jIrK6qfvfu3du37560vLt353HrE+TfouTevYZDFYeCgoIlJSUnT578s7v8C74aBgwYICQklJ6W /vLlq/fv30Omz5+/uH//weXLV44fO56VmRsTTc7bV3jq1OmrV64+ePDwxYsX7+gAyvdnz543MzP/ Jff/FzBw4EB9Pf2mR81tbe1v3rxtbn589cr1QxVHsLspFEpISKi7u7utra2ZmZm9vb23t3dkZGQi LTE3N/fYscrr128+fvwUtd6/b2t7356aksbJyfmzB/QLeoS9e/fevHGr7X3HmzfvILg7d+5evXr1 zJkzx44dKywsTElJiYmJ8fPzc3JysrGxcXV1DQwMjI2NRXlBQUFFRcXp06ex/aEEoAog8fa2jvfv 3oeGhk6YMOFnj+wXfAabN/NUVZ15/7797Zt3z5+9fPz4SUvL4+bm5vv379+8eRNyPMOA0tLSzEz6 NoeUkdJotOLi4uPHj58/f766uvrs2bO3bt1qbGx89uwZNHt7ewcB+Ono6Dh48OCfPcpfQAcLM6u3 b9pev37b+vTZ45Ynz589hw/W3t4OiwzZnT9/Yf/+/QEBAXp6erKysrt27eLj41u/fj0PD8+OHTvE xMQUFRVNTEzi4+MPHz5cV1f/9OnTV69etbW1dXSG9o5Tp079+eefP3us/2nAjqNSk5+1vnzy5Nn9 +w8fNT56/vw5hPPmzZu7d+9iw2Ivk8nk4OBgbE9DQ0N5efk9e/Zs3bqVn3/b9u0CO3fulJCQUFNT g7hdXFyCgoJAXFZWBoWA3f2ZtNs6IP97dxtWr179swf9H4UpU6Yeqjje0tL68EHjrZu10NvYzhD3 7du3ob0h6PT09OTkZEgwLDTcytJOTlZRUlJaUkISe1xZWRmbGrZeWnqvjIyckqKqi4tHbCwJ6j07 O7uoqAjmvqGhgZA1djrda3/fBmPx6sUbeTmFnz30/xzM4p5dc+ZS48Omutrbly5drq+nK+E7d+5A 0IkMgAOWkZERFBiioaED+aqrq2trayOFoOXk5FCCnY59raWlpa+vj90NVa+goGBkaJqUlAKDXlJS grSyshLmAKEc1PvLFy9fv4baePv6VZudjePPnoD/EEz4Y8LRI6du19+9ePEyTOqVK1ewo6uqqtLS 0qKjo+Pi4rBJI8Ij5GTlIFyIdffu3Zs3b4YeXsmA5QxYsWIF8RPlW7ZsAQ2IIXosCU1NzZycnPz8 fKRZWVlw5KA3WlpaGhsfNTe3tLa+eNzyUllR/WdPw38ChgwZmp627/r1W9XVNYieYKAhDnhZiJhg fMPCwiIjoqGlsX/hhkGOEOuiRYtmz549ffr0qVOnjh8/vjM3lHBwcHBzcy9cuHDZsmWgR11YeSUl JR0dHcgaK4du0EvLmpqa4A/U1dU9uP+QoVUebt8m9LMm4b8DVlaO1dXnDuw/mJSUlJubiz2YlZll ZmZmZWXl4OBgZGgGf1tISGjdunULFizg4uKaMmVK75lD7oTQofCh/MXFxWOi6aE6HDnojYsXL548 efLo0WNYYFWna4oLKyZMmPj9RvoL+LZsLyo6kJ9f6OnpaWpqamxsDJu7lQGIsNasgZDXQW9v3Lhx 7dq1UNRLGbBkyRKkffv27U0Tw4YNg9ChE0RFRVVVVVFRRkZGREQESwg/3d3d7e3t7ezsvb19HOyc 1FS1lnyEpZ8DSqA3vveE/Ith+PARkeHk8vIKe3uHoNDQK7W1HV8Ddo5f4V+xsbFB6HPnzqVSqV/V CuB6ff21+vq0nJwJE3/t/b8PSgpaRYWlaWnpEDe2MzUx8Xpd7dVbN89duVx9/tzpc2erzp1Fpjte un4NUoCDvXrNmt43x87OfubMGVS8cvNGd55o6zQDkUcHLt+4js5cr68F8aUb12BcBgwY8P2m4l8P kyZO8fUJKSku8/f3hzHV0NCAUT56/Pj9R48aGhvr7t69Xlt77datG3V1LBH+NF1wN26MHTu2N83x 8/M3Nzejyq3bt8G5CzeiLaS4eruhAX140NR0v7HxTkNDTU3Ntm3bvvds/OtBZI9MVGRseHiEr69v YGCgq6srLOOsWbNu1tY2tjQ/ffEc2Pz0SdOTxy2tT4GPn7USSPxEOaFpEVv9ZVvw+gjih81NYA62 BEOCFbMVtNj68gXK8fPBo0b47YWFhdAJ338y/uUwbux4C3OHjPRMSNnb2xsbXEtLa82aNRMnTsRW etj06HHr05dv37TR722zQPqdsY6Ot+0fboPr6ur21BD8NKwHguzZyxev378j6jD5MHm+bXv/4s2r Viyz58+aW1oQoGEdDh069EdOy78V1q/b4unhGxkZ7ezsDHGHhYYhVuLh4Vm2ZDlMJAzlkydP3nd5 qNEzvHnzBm5z91YQm1+/fr33Lllbe/vr168bGxsvX76MaP3HT8u/Evr06aMorx4TQ7a1tXNyckII bGhoiGhr9+498Jw5OTkRYcXFxT179qyd+czyr+Dq1au///5751YQaoHDV8i6re3FixcNDQ2HDh1a tGjRlMlsf06d9rOm6N8EkyZN1dE2iokhOTg4QpkHBARgX2/atGn7NkHMMyz44MGDR44cWV5ejvnv vcQTExMJ/lgtiOJ7L+gOhpMPfQI3jUKhjBs3butWfsEdO3l4tnfpOWwNAnA+Pj4E7GoMQGbt2rVz 5sz5YbM3Y8YM5j0BZBBd/rCm/x4sXbzK2Mjczy/A0dERytzNzQ1bG4HYtGnsUL/wtAmLycXFBVUM 7dp7ievo6IwfP37//v29FzSYwxY8evSotrbWyMhozJgx6AlD2/ByzZiLYEFKSioiIuLUqVMg+zIr 9DYhIQF9+PJ9v2XLlp3qBMnJyRGsQEjo0x3d0aNH6+nplZWVYU12b/fly5clJSUKCgq9vO/0g0FQ QMTGmn4ji9DkmB9sbWlpmUmTJrGxsQ0fPpxJCYMOQbx9+7aXsoNE4GJ9lawxVw8ePKiqqoKGQYsS EhLwFZFHr86dO9d7Vl0AFmHdunUsh6+trd2bjoEMxPPnzyeTyehkbxpFh//XDuPBcO+VUXF2cnNk aHKEYJheiHuHgBA2JhRpF2dYX1//8ePHULZ/e+Z7AhhrGPc7d+7AdccyGzsWjY+DhrSzs2M5vRAB qmDt0R+evnyJpYVefVnzREdHDxkypMsMQAP0pnv8/PyIH/9SpXSBmzdvjho16seJ869gxIiRigoa vj7084Tu7u4w3JsZMG0aB+w14qZBgwZ1qRIVFdXa2tr19BEraO9ob2v/CzIQvH7zGtjCiLbQB6LF aWzTIOuLFy8SZG/evgEN0rf0k+z0o1MwK4TOh99+6dKlGzduQC1A7u10kbcTTb9vew9iVESG4HPs 2LEuEr916xbRDQLphyw+4rv379AiURF6vvvomGy7l6PdDsaaxMT+OHH+FcDj3Suj5ObmAZMNhwqx LWQNpd2vXz/IGlEYMl2qQL0XFBbcbbj3qLmJwObHLZ2xqaW5EcWMDHGVIMPPzvn7Dx/cuXe3tr7u Vl3t1WtXL166KCYmBv79+/dHCiVDbGo0VH/nNijv3W9AlYePGgmEcAsLCwUEBAhzg03Ey8sLoTAb IrrxoPFhw4P7qA4kxOHn788cy9Q//wQNUYVA5qCARHUUPn76BCkaRWdu370DVuBJjIVZkUBmu+gq 6t6933Dt2rUfKM+/AM7p3HKyKp6eXpA1Im4IHYZSVJQ+7QMHDuzJ2Zg8Zcr+iopzly9Xnz9fc/Hi 2UuXuuCZCxdwCUhkkBJkSIkq1efOVVZVHT1xovzIkdKDB5NTU7lnzfqNYVyQLli4ELJuffXqRFXV ierq0zU1RC0CzzJSWnLykI+GhqgFmDN37vkrV4gOfNbouXMnq6tPnTlT39BQdfbspI8vNfBu3fqw uRk0RG+ZyKwOBP0JRlcPHjpUfOAAhUbLyMnBzzPnzxPMCWImMseLilXnzl28ehUO5/eWYy9hFvd8 eTkVH29fyNrPzw/mG3tEQUGRuMqcxu6wctWqAxWHyo8cPXTs+OHjld0R5UzsXFh+5BgyBw8fKSrb n1tYlJ2Xb+foNGLECCZnBOzQ6k1Pn5VVHDpw6HDFUTo9UlREeqTyBLD63IXp06ez7GFeYRFaASWz aSJF9f0Vhw6iw8crN2zaRBBr6+o2tjzFpc697YKl5RUFJaXpObk7BIWYnsySpcvQty6jY44RrRN4 5MTJk1VnJv7PPLmbO2fR3r1KELe/v39QUBACMYSxamq9OjgkLiVddKCioOxAfun+XmJeSVlecSnS 3KKS1MzspPRMUQnJLmz1jIxfdXTkFBSDhl6luHRfUSlSonp+yf7z125m5xf11KuT5y4UlB5Alc4I VjmFxcgUHSgvKT/Ew8tLEHsHBB09XY3yHrtaXJqWsy+KTOGcMYOowlxg1vYOaOhLIy0pAwGa6+4f /iyYM3uR7F4lTw+vYAZgdyPO1dDQ6GV1/7CI1Ny85Ozc3mNSVg4tMzshPTMkmjRv4aIuDCdPnXrw xGnwTMzIBjHSRKyKrByiIvJp+/Iv3KpvbGw8zYBTnwNK7rQ8jU9N746U5NS45FRkUnL2bdhEj/IG DBxITc8EQ7Bl2U+UowOU1LRNPFu6j11MSvoLYye6nZCRFU6O/2ci+pYwc8Y8GWkFdzePsLCw8PBw Hx8f+EgqKqp/WRErNj4+vvldByU1g5SU2nskJ6eRktLsXDzGsHpUKrlX7kj1+eiEpNjElJiEZKTM ikQJMjG0ZHJyelJ2XnpBcXbx/pzSA0iBGYUl1PTsKGpiGDk+Ii6hC4bHUUNi4sJI8WC+ZPkKtMXB OQN8YmgpwO79RCFajKYl+4dHsTRqIlLSmUWlLMdI7yq9empUfKKKVo8PjH4YwAcjhsDBPlNGmu6Z I7xCWIoNDl9XXl7+y9U5OTnPnDnzpK2DlJweSUmMjE/qJUZRk0nJGUgH9fCKkLmdAyU1CzzD4xK6 cqYkRlBoSEPJ1OAYcnBMXCgpHmQRDOIwEjWMTEUmJJYSEkPBpc6IQtAHRsYGRMSEkigzZtJvdfJs 5S86UsmiIUZb9PL4JPBU1zVg2VV1PYO0ghLWw2d0FYimV65hfXvnRwLCKyK8nTRxqpiojLW1LYlE iouLI5PJggwYOnRYT3V37Njx5MmT01fqSEkZ0QmpwNjEtF4iKSm9oPxYy/sOZU0dlswjKUmkxHRQ xtBYsEVbKA+PowVGknxDI/3CogMiSIGR5IBIsl94NBCZwG4YFEVHUPqGRHoFhYfGJhAuvZqOfl75 8WhqSve2UMIYVzra4t22g2VXfYIiEzL29dRPpFEJKWDOUon9YEBsS4Srw4f/Liq8V1dHH4KmUqmp qalCQkK7du3i4eFlWdHBwQGha9nxanJKJjVjH4EJmXkfcV+nws7lnzApp/Du07f3Wt+u3bCpC/PB gwcnZhUQDFlyoGXlJWUXKmpoT2PnYOOYPu1rEbXY2dnYPxxoDIgiZxQd+Lz/nw0E0oxPy2afzuJG 6NQ/2ZJzi2hZ+SyHSXQ+Li3bNyzqW4rtH8Do0aNHjhzZ57c+u4Qk5eWUKHGUxMTEtLQ0WVnZPXv2 mJiYd6FH8FhYWAhZZxQcoKRkYyqScwoTM/Mx/8gghaTwEykzT1zqjPRLmfm5pYfpa+ZY1aQpUzs3 MWz4cLClpGYTdZncmHzS8koyi8p3Cot9g+GPGZOSW5ySW0Tw74JEu7SMvChKCsubD5t4tx49ewVk xKC6Vs/MT84pSkjfp6Fr+M+7+k0A4ibeuNywnl9CXCY8PIJGoyUlJWH/CgsLm5l9Ju6lS5ciFr7+ 4GksLS2KCscmk5KaQ07OjEvJQiYuJRsZIo9CXGX8JArh2eYwET9BgEx2SQUk7hkQNnDgp5u0cCdC YmGOE2MS0ggygu1HzE7dVwoUkZD5jVXEPWfOnCU9A/GAkmvmTIJ42crVuWVHmV3qjMzOx9DSDUyt WM6ekob2/sozRA97qJ6N6us2sXDpfwqMGDGCnZ196NChs7kXSojLurq4QdzJycnY4+Li4tLS0jNn ziIolZWVX758mV9+PCACpjAuJJYaSqLR09iEMHIi8sjQkUQLiqaAhiD7UMigYeIHYnr1hPTCA49e dciranbulbK2vldwhG9YDJiAG9HWh4okGikpq+bGfUsHt+7DgXv55ZvzKXkl4LNxCx9BLyIpU1Bx IjiGSvTnM4yFv0cNiqb6R5D4tguynD1HT38ItKfqKA+MiguKjvtj4qRvKrS/D7DdHBwcbGxs48ZO EBeT19TUTkpKTklJycnJwdRJSEhoaekMHDgwMjLyeUdHCCnJ2SfExS/MPTDSIyjKPTACqUdwFDOP clwFjaNXoKNXkJN3MH6C4BMlExnERJpVdqy08tyK1euZvZo2ndPWzdfew9/BM9DRO8jJJ9jZl96u m3+4W0AEuKUV0tWCv78/divoMQR+fv59+/a96+iIomWCgMkc9K7+Ya7+4S5+oegPGGoZWTAfAWib WAZEU1EO/izQJ8TJO8jFN5Rp6DsDjI5PaKyrXxjRve6IcnC2dGSxLH8iTJkyZcGCBcOGDRMUEJeW kkUslsEAT0/PjRs3Lly48MSJE6XV1209Ai2cva3d/JCxcQ8AItM5j9TS2cfc0cvM0dPEzt3U3sMM 6Ohl7eZPXCXomUhUBNp5BxefvBQQQ5sw6dMJhIXLVhjauJjYuZnau5s5gI8nEMzNnbzM6Tz9YlML XnTatshTssscfUIJziAAWrn6Wbn4Wrr4WDh5mdh7GNu5yWvqj/h4ngqeKi5ZOnt3buIzdPAwd8BY PFhG3DNnz3MJiDJ18DDtqS5Se89d4v9b5+vGjh1LvM23cMEKaSkFSwurzMxMqHRnZ2dePr6bzc1B 1H26lq66li761u6Gtl76Nh4GQFtPOjLy9EJrdx0LFy0zJy1TRzUjW2U9i1nzFq3ZtFXL1EnPyoUg IyiZ+KG6rSfqmrsE5Z24rmZoM2jwhzuNXFxcM2bNVdA2UTW0Vje20zS11zJ10CTQxEHLzBH9IRgS TIiMnpUbynXMnXUsnLXNnTRNHTVM7MFWzcBGTtNk0bI1nQU3ccqfGJemiT0dmcw7oYaJg7qR3U5x OZbztpZnm46ls8aXqttrGNvNW7ziR0ix1zBq1Ki5c+euXr164sTJ0pLKcnJKISEhurq6Vm5uh+re GrmEKOhZK+jbKBs5KBs7KBnZI1UxdkRKL2EUKhrYyutZy+la7tUyl9Ew3S2rOX4ifZ/2HzBASFpV TtcKBJ3rMpEoRAapoXNQbGEV325pVBQXl9y2bRucimHDf1++nk9EQVtCxVBSzVha3URaw0Ra01RG 00xW2wK9UjK0I5DeB10rWXRA01RK3URSzUhCxUBMSU9CWZ93p+R07nl9+/XvMvDZC1dIqRmJqxhI 9Ij64DN/+VqW88a3S0pC1fCL1Q32apqNGvvH95bg1wKc8w0bNkClr12zhX+r4OIly30T84OzTu3V cxBTNZXQsJDSspLStJLUtKRntKyRfshrWomrm4NGVMVYWNFgt7zeBgGxIUM/nXQaO2GKiLKRmIqJ pIblp1p0Dkz8UIjUwDXCPjxr1qKVAgICUlJSlpaWGhoay5cvHzBw0DSuuQtWbFq3XWybuIqQjKag jKaQjNYuWZ3dcnq7FfSQ7tyrs3OvNnFJQEpjNd8u7kUrJ0yZ1n/gQGZnuujk8ZP+nMY1bxrXnJ5x Ljv3/KEjRrKcNDauOWwz6NhTdXauuRzcC76TyP4JjB8/nngDd/SoMdO4l8SUX7cMThVVNxNWMRFV MxfXtPyIVkjFNOiIvJi6hYiq6R5lY2Flo53y+kLyugtXbeken85dvmGPkpGomhlRkVGXBYppWICn dXiWhl3g+MlskpKS1HgqhULR0dFZsWLldHaufn0/BGuDhwwbOWb8JHYuYraZOGU6N8pHjum6m/ow 4EfM4/8fmDZt2vz587eKSGWcf67jGimmbi6uYSGJ3adjI6Vjy0Cbj0j/iUsggBBFVU2FlY13Kuhx cM9nyRluMJ+YMhhKaFp9rG7zOdoyecoaOvmkHMVC2rVHJC4uLikpSUlJSVRYQlBAZO7ceYBx48b1 5klib0SMiGMYA4Z/BJbHtHrZVnfoQqampraPAc5ubj/9YSgCcCd//7IbrwxcghWNHJVNnVXMXJEq mTgh7YwoUTR2VDC0kzewldWzltG22COvPXbCl0LLcRMny+rZyBvYoWIXbp3ZEo0auYVTyy8Lyajq 6OpqamoqKaoqK2lv3MAH72LWrFldzoT0NLe9gaysrOZucOfOnby8vE0fTz58Q6AkJp69fPnClSsF JSXfQ9ts3rwZsbOCggLs8pcpEYsdOnSo9OIDa+8IU5cAY0dfQzu656xv62GAjJ2X4Uc0IMptPPVs 3LUtXDTNnIRlVIYOG/5l/oA1m7fqWrsZ2DJc+k4MP2Nr64G8iUtAaGrxvlM3N/ILrVq5WlFRQ0Za DfMPcU+ePLnLayl/G6BzDh89+rCl6WFzU3PrU2DT0ycPWpobGh8SkZ2Xl9c3aYiASZMm3W64V3/3 zu3bt01NTb8hZwKgqcAZ3X78rNXMzOwLlFgMDQ0NB2tueYbFIZB09A2z9w6x9Qyy8wy28wpGvgui EJcQTVu6+m4VEu7bt+upRZbQt18/NQOLnnh+4OxJ5+zgHeoRSq68+iD/yLlZcxds4xfZwsMrJCSE 8KHLJ1/+CSD8bGxsfPPubUtLy4ULFyorK0+ePHnr1q3W1tYXr+iHITEnMBzfqjlYCn5+fj4+PqRf 9WGTXgJsMXEO/N27d3C5eyITkdybnF8WQU0Jjk0IjKL4hcf6hEZ7h0R5h0b79IC45BkU6RoQumzl V7y2D5jKNs0jKMIrNKonzsym0Y3gWFpMUlYImTZ6zFhsbfjnCB++4Wlt+KUdjFceamtrubm5wXn0 6NFTp0718/NDYXt7+9OnT7du3QpKLDMU+vv7E7tSUFAwJydHX1+fyap///5YjSQSCRry4MGDIF64 cGGX5sDEiQGKiopdLsFlgiYpKys7fPhwTExMT58QhGYzMjLKzs4+ceJEfn6+jY0N80PxWlpaKCGU 0uvXr8PDw9FbUVHRztUHDxmiZ2JOSUmPjE8II1GC6c+Co/zCIgn0D+8RAyKiXbx8ODg50TH0/6vM nOAe4S9wBjJbD4qMiYijxqdluvn4YUKwer/tSU5ra+sOxqs9kFFnS4p11dbWhp2CXU+I29zcnJhJ aADEhh2Mz7cy30WFbkT5h7PlH19nwIIxMTHp3BzxlgrYlpSUMAvhFvr6+jI+DNtOpB2MFytUVT87 R4TlpK6uTrya1M4AopWzZ88ingLBtWvXOneAeDXD3t6+y5AHDx7MMZ2Tg2M6O/1BMMc0dgZyfER2 duLR8KcSBs6YOXPlypUIlGxtbSMjI1NTUw8cONCdOUtAz4mGurPtjugVB+eMhYsXc0yf/g3VOAGl paX0W68vXmDCf+sUku/YsYPYI3V1dTC4KIHnRkwmXfm/eYNpR4b4/o+hoSFBjBJoCVhPLBLidSrM PLFaCKDRaCiEpfDx8SFKsDdhPiCaR48e3bx5k/iWIFgRZGxsbMy6mZmZKHz+/Pm9e/fQCpzJpqYm EN+/f19cXBw+NjxM4vu0qI5L6EZ9fT20UC+nAhygOqCRVq1aNZOLm49XUEhQWEhol5KSMjYFOkyl UsvLy6FVEFZAvSCFMoEeO368En0Dzdq1n92JwtrArGLIYWFh0EjwHqWlpSUkJOB4W1la2dnZOTg4 wMFgHKjYwrOZb8sWgTlzFmJTz549G5buG9pQAsDwZm1tO0MowsLCzPKJEycWFxfX37lzq66uqIh+ zBWe4cUrVx40Nja1tDQ2NdUxyslkMi5BgTPed2jA/EdFRa1btw4d1tPTq6uvv9PQ8Ki5OTc3l1hF CLuqa2qaHz/GYsDYibbc3N1R/d6DB9jv2KSIAaEnb9+92/LkyfOXLxF+/sZYhNa2tkQrV69exRTB Lq9YsSIkJKSmpoZ4P3HkyJFSUlK19fVPWlsbHjzw8PCAoDGor/pPECxsdB5LHVpr27btWhqmdjYu drZObm4ekCx8Gwz84cOHWOrXr9+A0cHQsAsKCgoKCwsxY6UMKGPA/v37kaIQqyIlJQVzFR0dnZaW BgJUPH78OJRDVFS0hbmFnq6hnq6xjpYpH68ALy8vjMWMGTO+x3fOly5dWllVdbWuDuIOCAjANEJL Q2QQx/7Dh3MwjLKyVYwPCi1dvvzY6dOHKisrjh3LLylBIfE0DXo4NSurrKICqKnz2REsfSOjw5WV R06cOHjsGGGAZs2Zc/TUqePV1ZXV1VyMd4GXr1xJtw7V1Wio8+uW1vb2J8+ePVlTY2lri5/TOTnr GhpKy8vRq1WdPnCEPvzZaftPnDQJzNHPoydPcv3dd43hGmFaoC7glmAzaqgbhQbFhQTHREbGZGZm Xb92Hc4M3Y998QI6BHKvra07deoUdj3WAyF3bATiw6cAQhtgnUAdQQthqUDtYF+gPDQ0zMXFzcXJ w8XJ18TYUXDHLhERESx1RNmEOv3msGEzT2nF0bScvOKKI7UNTe86Oi7erM/IK6SmpMfE0yJIlC38 H77zs0dcvLzyVGo2/Qg0D98n5bxhE8/ZKzeTMnNjKIkjGQ4kM/xfs259VkFx+r6CpPQs4hL/jh2V NedREhZNGsi4jWNiaX3y7MUjVTWYELh22K3Eke9DJ6tTc/JSs/NVNemvmkrJyFeevZCcmeP8MSpk eZNhCx//6QtXM/OL42jJXzhe+JcAB2nRokUCAgLQuvAWZKTlHex8oyISYqLiyaT4stL99XX18HZe M75a+57+bxNthC8BVwE7BTYFKcRK0LxkADIwQzBYVVVVcXEUP19/H+9AX59QT7cwZSVtcXEJaP6N Gzd+P1kDhCWkc0rLQ2MpQTHkoGhyQFRsYESsX1iUd1C4hp4hW6fv/Kho6sQmpYWS4rUNP3O9tPSN cvZXkJPTlTS1ujAX3CNCSkoLiY2zdv7wpFtT3zghMzeSmqSqyTh+3KePo6dvFDU5KiE5JjEN5RH0 M6uJ4WQERyR0A+mqdfSn/w4ePrSsPHJKxjbBnV8YjqqOXmJOfnRCsn63w2ZfC4hNEERg/mVlZQ0M DGBTFORVfLyiSDHJsdHUeAotMwOhwcn6+tuQY0+vABMfr3716hWkf/78eez7mJjYkOCwwICw4MCo wACSrra5hISkvLw89jWMIBcX13f9rworZ/fohNRQcoK5g4v4XgUJWQVRKdkt/ALdjzFYObnFJKZH UJI2bP7slKaZnRM4ZBYf1DT87J7JgAED0ov2h8XRwik03m0CKOnXv797QCglLQd8eLbSlcaAgQO9 giOiaWmUtGxFda3dohK7xCSFJWR2iUhsFRDCatkpIj7i95Fg5RceHZeanZCVt2PXnp7Ggs3u7O1P SsmkpOcI7OyR7KsA848IhZ+fX0VFBUKXk5PT1NAP8ifHxabFkZITqKm0hJSMjOzDh4+eOVNTe6sW lh2KGp4kXMQbN25cunT5yJEj+XkFZBIlOio2IiI2IjwuMpwaGUYzN3USExMnPqULBQ5lwsnJ+c39 8M4ABUtKziCnZMYkpS9fzfrhJgHDh4+IoqaQU7PIKVnzFy7ufEnXxBwb82L9w8fPnmFmiEIE74hT qOn7omkpAVGkQYPop+hHjxkLDsm5hZDa7Hn0xwp9+/XzDAxF4eGaS+s/fzOlc7CMKMbdP5iUlPHo dceBypNMHQ4X2tPTk3kgZ+iwYaGx1KzigzU37mBX0kuGDv3nn4yAKZ8zZw58dTiEGhoacLCVlZWV lFTMTa2DA6Jp1JyE+MzEhAxaQloCNQXST6RhDWAlJFHjk+LiaGRSAplEI8UkxpFSI8MT7Ww91FS0 4FJi5cBF37Jly5IlS6DAv8cdpy4wZ/7C8LgUr2Co7sg/GLf6e7rrPnP23ODoeG9QBkeN++MzbbNo yXL3gHDvkOhXHR0wTPD3YIIRTwXHJngFRzp6+KMVgpKdgzOKmg4+/uFk5qE1JQ1dz8CIQ9VXYddc XV0RaCOcuXTpEqrvFpXs81FYO3YJewZFBERRoCHh0zo7OyMmgt2MoWUoa+r170//YuTYcX94hUSH xNJeMr4U4RdO0jGx7OWtzr8EWPN58+atWbMG3j4UOwJPyF1NTU1OTt7MxMLJ3jUoIDKBkpFCy0lJ yklMoCNWQlJCTmgw2dPN39rSXl1VU0ZGBksFigJ+IB8fH3YHAq4f9hckvNt3mjq4G1k7K2sZf/lR xUbe7aA0tnFR0jbqfnWPpJyBlaOZvbu1W4C9N/32r6WTt4mdq5axFRvHp0Ppq9ZvDqGkWzr7aJlY Ey+tAyZMnIyfhlbOZvaeVq6+1q5+5k5eRjYuRjau23aJMns1bPgIdUNLQxsXc0dPxu3lEDuPIAtn H0tXP7G9SgS330eONrFzQ11jO3czJ0+wEtjzDY5kdwYODg6EaQgAN2zYALnD5urq6kL08OHh1Ckq KsoyQFNDE2EmhIstjLWhzgD6A01RUUgZcRZ2NDRG51sKPwA2btu9S0ppp7TK8vWsX5pgwnq+naDc JaO6fB0LykFDhi5euWGnlLKMpomclrmcjoWguOLSNZuHDh/RmWynlIqykb2CntXmHSKdy8dPnLph 604xBW0pVUMZdWMxRZ3NAsLsXF2/FjVm/IR1vIKiijp7Ga1IqRtvERSbMefTXfE+ffouX88jLKcp qWogqaq/Q1xh/ITv9Wd8sLPY7MuWLcN+5+HhgZ7HhoX0sXOh8IlvXkH6kDhEvH37dhgXmAMYaEgZ a+anvPLc+4ePfXphAfv26z9i1NjR4ycOGzGqy6U/prBvFVexicjao2S8W8n4zxksPvw1eMiwUeMm jBr7x8BBX3oCPnDwkNEMskFDWMdZqD7899GD/0EU9lXAzs7Ozc2NLY8Ni10Pma78CPgJdb148WIs jJkzZ3b5jtNPgd4/Iv8yZfdLzBLMv5S2pZFHlJSWpZi6iYCkav8BA79cvfdd6g3Zj4fJkyd/v9j5 fxzG/THRxMlHz8ZN28JRQct40q+PPf6rYcy48bvEJAR3i2zk4ftfeP3zF/wX4P8A1crmYQ0KZW5k c3RyZWFtDQplbmRvYmoNCjc5IDAgb2JqDQo8PC9UeXBlL1hPYmplY3QvU3VidHlwZS9JbWFnZS9X aWR0aCAxNjUvSGVpZ2h0IDY3L0NvbG9yU3BhY2UvRGV2aWNlR3JheS9NYXR0ZVsgMCAwIDBdIC9C aXRzUGVyQ29tcG9uZW50IDgvSW50ZXJwb2xhdGUgZmFsc2UvRmlsdGVyL0ZsYXRlRGVjb2RlL0xl bmd0aCAzODE0Pj4NCnN0cmVhbQ0KeJzFWmlYU1cazkZWIIGQQFgSQtgJyBIggICgsieAClioxQUU RVzqgigq26iodRed4tKZCh3H0WqdWoFqW2rVtijqAyIgUBQERKyIgECWORcSudlYnqcD7w+e3LPc 857vfOc77/kuCMQ4MOdY2VhZsIzHazc9MDC2dPGdGxIWHiGICA8NmePjyDaiTjcpBegxrDxmhwsg CNdv3vSxEPoVFuDKppOnm5ocFCM7f8BwXs7XD1qlI+hpuHksSSgI8eLQdKeb3jDoVn4RggX774uk Snjx72RhqIe5wfTT1GfzwwQx53qVGY6gIk0Y7GamR5xejjS7uYKoE13qKQKIf0gSzrahkqaRoq6x S1hkXotGihAGriwMcaBNH0sy0yci+tKYFCE8Sw2bYag9TRx1zf2F8ffH5Qj2epbA3Wh6WOow/YWp rQpsJKKh/nc9PX1DQyIJvFx0KsqdPh0rTjKZKUzvgTPpba/64eLZw/sOFJ4vqfijq18Mq7wa5Wow DXuc5i5I7YZRbKsozkoMD/DxdPfw9psbs/b4jfoumDmLIh308FPNkWwTltj+gYK4/fbhxABXOwtT GlRpyraZwY/eeb329SjL4yEcXdzUciQxAxdUfCDQd//0qmA+l6KjhRxtYuMRnVdW8+Ecer8twsZI D4BCJqKnhiSVF/XlB469T28UnSrIz9+9zZ2Cgk3ExmvFxceD8lZvr5w6tD8/Pz9vwxwSUvOb/zqQ 2CEp/WqCzd2Z2vDxrYIOvlZt9CwaPpX/H6juCyrVcJRKzjliPzRCEu1z36i2adjsojMVJImsoCx1 HKXS/i1mcodDkb2KBlQaiGvy5prgp2K5KU4x1epJSl/M0x9hgKKH/apaPVSRF2ahMxUbB88I2C4P gT3KNO7OJAKWSKx5crMaQ5dummlCmBKPJFlF/Sgbtf0nZa8Tn7LVQiBJTvlvVTlKytd7GGKnZGsj dLlLZAaUnMwqVta7vWuMMXq+l4bUOcONYAYeicJTDJlsNpOujRmXL4ZIoehRiJjJk9TnH5IN+mxl UNIVZTp/RNvOf6COolRaH+nkNku4ek/h1WvXvjm2Y/5sHpssc1AkzsTNf5avp5sLgLMdg4BE63K8 BZt3gfi7JZLPmmRsxTPCbsoG3RvA4qXckShR+f1wm3qO0sEzV6s7YcKju65kg68pDhofbbyt42Vn 59NqCFWV+WyGe0pZiyw8iJ5/HW6CHZcZDASzhTKFNhRjTaa4ZdQqUZGoxnnlecDQdtybCrYSzuMX eOkPCbtrFK52rzM5WpOxJHOpbIUbfGhEjIFf/kvNFGSzqRaPUVvzEQON0Il+AS/7/ZFyj95VhpMI CwROpqxfoTUJh8Qah/793dgc35Xs7x6r/uXHdDQ9VSHy96m2qvaZhIoi2p6UdZtP10IjkHjz2EuD qu8cxYsv0tJewZ5FHfd+vt8Bt9QTf23Lo2POE2AgkTJhjigC94Ksm+9wXEaRbJeXa15O0aO9McJi mFMOlO9PTVx9DO7JkiwW/6ZyR7GyI+eYTniHo/AzvpW92hMx3AtNdtlUo4ljf1l6oHs6fPV+2+Bn a2EvOAvfF//1EDQodJN0Vdz4pV2hSHrEYsJOicQ6fy+zkbusE4bqs6tDPceuomQeOxxOoO/S2qig 2cGf/ANOsjx0uYLXip+cSEtY+aWir+/hTHznYBxkJMV8uRLHmsRdVVU8oEX9kQW2VOsj8IUTvX3d CdClcGzejstRWNznu0PtzZ3XK1xGB7cwJx7QUTby5fbFyaaGs96gEEDkr72zM8hcmzirTk2dIn5a dlFhcl+GGuPRBvEKGuXVCsbEfRJpId84oaThMw1JdMhVo8ClkoqtPgw8ipwwZvwZxrdrH8Efu9Ot wDGk97FCAH4UpT9hQ6JxDHkIWqGHQUHq1vsr9SGoNcUcjEVbO8Z5I5vOkXSFTfL0IzoSgTRKew8v PO818fwCRpuSLut2yRSHRmAMBRVSDSj1xCOQZtnwov7ntY+Vce/rFTsUXPo7fx0weetT8LLBHJtJ nIt6dKHsWOzgamvhOKma02pDn1likOb58KL2wo1paWlr1m3ckiHHllVRwSfgbcT7uOBwwXrfhRe+ WmkyiWNRj8WT7RJRMF3f9bCGBOowupcbopmZ8Ej/bD3P1tbONXLvqTMynD6+3nm2Qih/s44JnF07 6jm8sGrexF0SgdAxdymXddzLCy9VSUMroCFcz2QtPNr8ucmWbGAdWQJvdJ4rVAjljR/RwD6mJisc 4F/7TCblpc3mH5R1fJk9bnT5gW8aXwkvqCtI3FqkYKPuNOdlCgGgLBC4pJKbDOXZTkpQmvjEyI8C lXuYCsTHvaPOqNE0o+grDnPZDg8Aks8cgUti3K7DW3WtNp3UBY7KW3hH45A9yor3Xdbi3DHUpKSj aAmXfx5e9HYDC7gkIbgeXvhkweS+XVEcFuzSEPrEdZdvKd952vc+1EhxsO367vm2NC8FVV4fB7mk TjRc3kn/4zPJXLFZyKf1UnUYKN+ZuFWF0rMPU1CY2sCbpp+LshP4TG2S8+dVzztkeFFz1Au4JEI3 sLTuhbzw+YMUq0m5JAJB46+9os6U3RdX8q19816pqRqufnT7fs3z9vaOjvbW2kclxYe2JIa4mVOw KKzZ3NSsPIBcgO0pgaaQBCdaRa/PzpUhI5FH1WG5utvpTdgxUa6ZT9SQaP08nqtPZISfU39IDpXt TUldk5EFxszOXL88NtjbkU3XhoSUFjMiLWPbtm0Z6xaFeLnYGBEhJlpkloOrmwxOHKq2bXFjU+VM jeliJI5qYqKPk2sQjHFygyoHUdVegaUOGkngJKk/Jqtygp0sbJ1cwJguM+wtzehkgiw7gPeqez8A obf58wAGUWvYWkgMjkiSg4jHUKI6wZ0xUuMnVS1OzoWvNjNGrvFIgk26GoU78GPGLFPisN7g5XSq 4dhzdr4JGY0lDI9MwGFQo7pL/5PRUFbpqd5WSMONoLYmgqLJkOQFIC7edBj2XKSOx2k1+dN3320M pI/YGmMY9k/VBRf9tNWVpv79KNbfQESQiIcD1VC6Kc3KnmVgYmeujUISjJ28+HZ0LBKBMl11p67q mJcOEmtg58nnynJKaDKH5+NuScZoe5yUQF852AQooxf8s5o903d9TzyPRR+ZE56zTPUbVOfpuWYa rIBxvQY4tlTcrYWC/uVZa+7eu5pwuu4CR5sV9sXjttbKXBddJMZqV+0fFUssCHru2RUtbVX7XHWA mtN2SL3R9LK5PNHa9VoH9JKqI0wgTdwq1Trc4Ok4YZCvqx2Hbcq24iWcUhHBfZn2mgQCIRjcHAf/ tXbFPug6V7r0V+B7QANf9/UpGFG94h+9dfB8EEtfxzFMYx8MG0lS4kZAG4SWjKxZd748PV7BAxcF mxUXbj2ofvy4rvHFm364TXu/ixQIBOEQohZl/qdeoXKwo2wRW5P4p3zyJ7D0Zp7jkgfQzWEr8GhI tXyxtPxD/2I7PSjD8SzWJgnyd6havMOUJmiSN/huv+zHdT7YQwbOwmWpQBGmbd97vrJFUQINNF7d LhQIhAW3XyoehG8fFi5205SERprmAZesWeM79xCwf9++o8NH1sCrgzegqTc3QhnQzmirjUCmVy2c 91gqfV//+wtggV/85gB7S/5saO4VV6bn1IMh+1vvZ9gDRyXSWNa2wwiIzS59qu6OqAxJW+n2cGcd TUlGDBf60tv28LdaaOl+31oKdWm5cuA4WMCuy/v3XAIKaShzVhEo/nYxuF4NPSz+eylQf03LjoOG jed25Z+5sCk8ARJ/1UeX+xhC80ZhtLAj4PikXqoeXwcNPv13khsTHnIUgfO9PTqfxpxUyDFbjyUu AT44dC3J1/9TIAdF+QvBXhw8mgbWfLC9uakVmLU5B7hyb2Gsl1fgHFdrIagX/TPSlkZQej3LJbag okNtTnd02J7qwhguQwNBCKTR5EXfvRzB8jZoaKFTAriadWW76DMSmkCE27oabN6uzK2wdMG9w+Ch Oc2arEs10KUuAPTfbLImYlTOTVOHuZlljW/GUGL9LTdzwmwNx+CI0F/8J/SN9+2b9sqza3wdVwEf bFhhYbQIlHauY+EstoFlr121E/ytS80F7tXT0dLS2v6yqeDoIHSvNMBRGbpoajJg/DServZot/KM O3CruVeDchtou3Mo3oOjIYiPAMXcDbZf+zenjuSuDHWgW0G76FYIxeBjoFPElyJ9N4F73lBh3DEx lFndDpa57fqXRf999NW2+Lz30Af/wNm53wfRmTsA48p1swzVfn4xs5+ZeKKio3dIhaeo/2XFycXe diZjUQTxYjiU30ie4+1qbUjCO18BT0VueErYPcifa6qAhUT3kiMuguLisFXAvOJnD+veSatieclQ Fub1w6di6WNfh2Ng/N7WajcNOUwW13/pwZLazneiUb0oEfV1Pik5uMyfazY2RRDKg56CqLKHRyOT cGgkfjbQV/07rDBE5zz5nhTdT/cRghA6sMsjokQ+RE0wM7BY7mdNAufDwz+q/TXe1tiO/NDl+y5X Puvq6Xs/8L6v51Vz5eX85eFeXOZ4FMG9LviPgcGmRYwRbyLNaRgYbEwwQmGMhUWvoD35vvP6Jv8Z K8HZ07XSkrv6zjtAU/SmYp2THmfZjz3gQdz9aAvPLqVVLJV0n3Ef60rJ4XrMWbg660DB2XNfnPhs Z1p8EM+ebTQ+RUBrxpqCk596kEciFHFG2vET6911kUiS5bzdl397cOur3Yv4Hlt/BWweRNKp7ikn b9777VrBGj8jPGXG0mPfV94vK/w0wMRoZuY3d8sOxFiM8+8J5jaOrh58bz8fvrsL15o50SsJlubo 5+dIw8qfuH5+XOgJrc3yjFq64pMITw57CZQUGjjKI2GptgEfJSfFzXY0IqC09Kz9Y5OSF85xYhCJ DPeoRTF+HN2Jfbc0HismqgEKRzYw0MWiVJ5QOIqxhaW5EZnA2gPtofIEphYSQzRgcjhmBiSgl5Fo ItWMw2HSSFpIFE7PmGVqQBz/I9tfDXC6YdAoBJq5ub79+bernXQhBkg0KJRTgT0gUWiNh9oUAE2b mZqdEeesP7FPjP8DU/4xtA0KZW5kc3RyZWFtDQplbmRvYmoNCjgwIDAgb2JqDQo8PC9GdW5jdGlv blR5cGUgMC9TaXplWyAyNTZdIC9EZWNvZGVbIDAgMSAwIDEgMCAxXSAvUmFuZ2VbIDAgMSAwIDEg MCAxXSAvQml0c1BlclNhbXBsZSA4L0RvbWFpblsgMCAxXSAvRW5jb2RlWyAwIDI1NV0gL09yZGVy IDEvRmlsdGVyL0ZsYXRlRGVjb2RlL0xlbmd0aCA0NTc+Pg0Kc3RyZWFtDQp4nIXCh1LaAAAG4Oey tXvbOlERUQSRoYCgEMIKMxD2HmELiIAMrXbvZdvH6h/jnXetd/3uG5s0jp2/hlN8E//6NHecS4zP XLyBs8RNrpl/aw5JroC8LSDv4LwF7/IXrPfO319E2wMh3/5wiftIhA58vIzUEzF3QuycWHE+XUXX M5S4JiXuqTX0TEu5MzLvLK77cE7uE8hpwQY9r/DjgjKAi6qAUMUI1cySOijaDIq2QsuoCYs14RVt BFd1UZRsx9b0Mak+LjXEZYaEbCexvptEuTG1YUopTGkFkVYSGaU5qyKzajKntuQ2rfkttBU09oLW zmodrM5R1FGlbaqkd5b1rrLBXcEdT3XXUzV6a0Zf3YT0HoH+hjnQIANNkmlamJY12LKG9m2hti3c tmPkwBHpUNEOFes6Md5zYeLQjcm+B1MDb3rgSw+Rzozo7MiPuaMA95jJHzOF50HuSZA9CbGnoeJp GEsvIlh+GcUKvoph9XUca/gmgfW3SdzDdyls4Ps0NvFDBlv4MYv7/E+5Nv9zHg/4XwrY4X9lu5eL 3W/F3sVS7zv38HK5/+Ovlf5ZZfDP4Vl1+PPKteGv2ug/66Pf9aMr/gGo3JghDQplbmRzdHJlYW0N CmVuZG9iag0KODEgMCBvYmoNCjw8L1BhdHRlcm5UeXBlIDIvU2hhZGluZzw8L0NvbG9yU3BhY2Uv RGV2aWNlUkdCL1NoYWRpbmdUeXBlIDIvQ29vcmRzWyAwIDQ2OCA3MjAgNDY4XSAvRXh0ZW5kWyB0 cnVlIHRydWVdIC9GdW5jdGlvbiA4MCAwIFI+Pj4+DQplbmRvYmoNCjgyIDAgb2JqDQo8PC9UeXBl L1BhZ2UvUGFyZW50IDIgMCBSL1Jlc291cmNlczw8L1hPYmplY3Q8PC9JbWFnZTg0IDg0IDAgUj4+ L0V4dEdTdGF0ZTw8L0dTMjcgMjcgMCBSL0dTMjQgMjQgMCBSL0dTMTMgMTMgMCBSPj4vUGF0dGVy bjw8L1A4NyA4NyAwIFI+Pi9Gb250PDwvRjMgMzAgMCBSL0YxIDExIDAgUi9GMiAxNCAwIFI+Pi9Q cm9jU2V0Wy9QREYvVGV4dC9JbWFnZUIvSW1hZ2VDL0ltYWdlSV0gPj4vQW5ub3RzWyA4OCAwIFJd IC9NZWRpYUJveFsgMCAwIDcyMCA1NDBdIC9Db250ZW50cyA4MyAwIFIvR3JvdXA8PC9UeXBlL0dy b3VwL1MvVHJhbnNwYXJlbmN5L0NTL0RldmljZVJHQj4+L1RhYnMvUy9TdHJ1Y3RQYXJlbnRzIDE0 Pj4NCmVuZG9iag0KODMgMCBvYmoNCjw8L0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGggMTA3MD4+ DQpzdHJlYW0NCnicnVZdb9s2FH034P9wH+VipvlNcQgCNElXpFhQbwmwAukeFFuxVdiSJ8lJ++93 KcuuaItut5c4Iu7nueceEiZTuLiY3F3f3gC9vISrm2v4ZzigQAmllHFODRhOQUkKZToc/PUG8uGA weJgQ6lmVHpGz2+Ggz+GA3h3dw3QScC+Jxi3vspq0+aKBWN9ubgg1gJmA20IoxaUVYQy4ERrzWC2 Hg4mt+tkkcYSbgroS8zbxJP399zAomo7YDYmMXdhrYlBMPwVIGJGjDr0cRJLnKDEpWSyp3KXTTbZ JtOkrtMyh1mFoWID1Sx37pIbwhtPTKqpPouebBNfPWDA3wRgJw/PrhMHDQONtUjsQlvCLDysu/mp 6xY/mWg/3w8HjxdUmKvLv+Hhw3DwDmPu4rLjuDFHOHg37mP06e30FpJ8DiMZ3WUlYg8f7yEpUxjp qNo+jfyo+1AiNsQv8TEah2xxyEb7tpuy+JLO6gpGTEWvWb3McqhHKlpi3v4omuJM5VHxaR6ylpao o/qOI+8QIjj0XpSEJsa0rtMSa2sqhtcyqxGrGlPLyKGGlQeK4MY6UnqRPl4n61UIKMWJ9c27oU9o pH6KRtwaErcY/DeidD2jq6JehhplkpJY+PYNhVSUrKpiNBYNUtsqRZ7ZM4i5xRV+yW7I92mJ7i/4 t99Ncktwip5bKMW+N62I3Nt+jqo0DfXGYyKUb98zlftNkh8GozuDOcQRknDRjeM0R6McIq0ZlIuj gz/dYkfL2pFt8+tk8hUJJ7DO8qUBgyCqPCoXk3MEMT11uJXAPfLqWOyFJPo8wo0UUSsIZbr6BsWP NlMp3G/pIxTeTGV3Iw7heYJKAxxSVHOiFKA9xzWhan+wGg5cSzj3ngPq9H/VcdkfHILuD5Y7tf6x LnAhCMr7AThPHEIc0tql6bieFwIusH7t2wdFRqoT21WSL7ZOykeMRk9ZPs/yBUqtieoCik1aJo5U 4XkaRuRRxNd0FSpWM2wuXOsJKeOfUi1mJWHx/1Gtrmf0sEyrYKNMCSKF7/AdOt1BLo6WyUsKy2Tu zhNYJ192+xfeCe6m4oUuXpxLWi5xj5NtEE68uYzveBZOewynz1pLiWAIiopJ5w6QfWj6jvg8Iwhw xzFIQcYk0b7ptCywy/l2ljrxr4LkZdTdz13P9XbmXJbNAFJ8a7mv0l0ls2K9SersKVtl9bfR2N2+ rLF5bWzSHD69dQhPb5Hdv/Te9vJkq/dtCqTdHu/2HYQp8Sk02qnh71m+xX+/wjyr6jJ72tb4lRWN Jjt+LIrmKbAIEoLis9BP81yUr0k5D26hJZr7HmeJwKjHBKf0xMbyZLkMB6n0/lm0ez3vxP92jc+y lxQbQZqPze5t6BBtroOxboHBlt0bMVQ3Z0R0MzziM3KzKcr6ZCC8t0QRO/33Apz0/S9NY7fNDQpl bmRzdHJlYW0NCmVuZG9iag0KODQgMCBvYmoNCjw8L1R5cGUvWE9iamVjdC9TdWJ0eXBlL0ltYWdl L1dpZHRoIDE2NS9IZWlnaHQgNjcvQ29sb3JTcGFjZS9EZXZpY2VSR0IvQml0c1BlckNvbXBvbmVu dCA4L0ludGVycG9sYXRlIGZhbHNlL1NNYXNrIDg1IDAgUi9GaWx0ZXIvRmxhdGVEZWNvZGUvTGVu Z3RoIDk5MTc+Pg0Kc3RyZWFtDQp4nO1dBVxU2fdfu9decxFExO5uEUQRDDqku7u7u7tmGIahWxpU MDFA7BYwUBFQsQP4f2eejgiDi7vG77/r+ZzP/dy579xz49x74r373vz22y/4Bb/gF/wjmDd33sIF i5csXjJ69Oif3Zdf8C2hb9++mzZtsrOzz8jIrK6qfvfu3du37560vLt353HrE+TfouTevYZDFYeC goIlJSUnT578s7v8C74aBgwYICQklJ6W/vLlq/fv30Omz5+/uH//weXLV44fO56VmRsTTc7bV3jq 1OmrV64+ePDwxYsX7+gAyvdnz543MzP/Jff/FzBw4EB9Pf2mR81tbe1v3rxtbn589cr1QxVHsLsp FEpISKi7u7utra2ZmZm9vb23t3dkZGQiLTE3N/fYscrr128+fvwUtd6/b2t7356aksbJyfmzB/QL eoS9e/fevHGr7X3HmzfvILg7d+5evXr1zJkzx44dKywsTElJiYmJ8fPzc3JysrGxcXV1DQwMjI2N RXlBQUFFRcXp06ex/aEEoAog8fa2jvfv3oeGhk6YMOFnj+wXfAabN/NUVZ15/7797Zt3z5+9fPz4 SUvL4+bm5vv379+8eRNyPMOA0tLSzEz6NoeUkdJotOLi4uPHj58/f766uvrs2bO3bt1qbGx89uwZ NHt7ewcB+Ono6Dh48OCfPcpfQAcLM6u3b9pev37b+vTZ45Ynz589hw/W3t4OiwzZnT9/Yf/+/QEB AXp6erKysrt27eLj41u/fj0PD8+OHTvExMQUFRVNTEzi4+MPHz5cV1f/9OnTV69etbW1dXSG9o5T p079+eefP3us/2nAjqNSk5+1vnzy5Nn9+w8fNT56/vw5hPPmzZu7d+9iw2Ivk8nk4OBgbE9DQ0N5 efk9e/Zs3bqVn3/b9u0CO3fulJCQUFNTg7hdXFyCgoJAXFZWBoWA3f2ZtNs6IP97dxtWr179swf9 H4UpU6Yeqjje0tL68EHjrZu10NvYzhD37du3ob0h6PT09OTkZEgwLDTcytJOTlZRUlJaUkISe1xZ WRmbGrZeWnqvjIyckqKqi4tHbCwJ6j07O7uoqAjmvqGhgZA1djrda3/fBmPx6sUbeTmFnz30/xzM 4p5dc+ZS48Omutrbly5drq+nK+E7d+5A0IkMgAOWkZERFBiioaED+aqrq2trayOFoOXk5FCCnY59 raWlpa+vj90NVa+goGBkaJqUlAKDXlJSgrSyshLmAKEc1PvLFy9fv4baePv6VZudjePPnoD/EEz4 Y8LRI6du19+9ePEyTOqVK1ewo6uqqtLS0qKjo+Pi4rBJI8Ij5GTlIFyIdffu3Zs3b4YeXsmA5QxY sWIF8RPlW7ZsAQ2IIXosCU1NzZycnPz8fKRZWVlw5KA3WlpaGhsfNTe3tLa+eNzyUllR/WdPw38C hgwZmp627/r1W9XVNYieYKAhDnhZiJhgfMPCwiIjoqGlsX/hhkGOEOuiRYtmz549ffr0qVOnjh8/ vjM3lHBwcHBzcy9cuHDZsmWgR11YeSUlJR0dHcgaK4du0EvLmpqa4A/U1dU9uP+QoVUebt8m9LMm 4b8DVlaO1dXnDuw/mJSUlJubiz2YlZllZmZmZWXl4OBgZGgGf1tISGjdunULFizg4uKaMmVK75lD 7oTQofCh/MXFxWOi6aE6HDnojYsXL548efLo0WNYYFWna4oLKyZMmPj9RvoL+LZsLyo6kJ9f6Onp aWpqamxsDJu7lQGIsNasgZDXQW9v3Lhx7dq1UNRLGbBkyRKkffv27U0Tw4YNg9ChE0RFRVVVVVFR RkZGREQESwg/3d3d7e3t7ezsvb19HOyc1FS1lnyEpZ8DSqA3vveE/Ith+PARkeHk8vIKe3uHoNDQ K7W1HV8Ddo5f4V+xsbFB6HPnzqVSqV/VCuB6ff21+vq0nJwJE3/t/b8PSgpaRYWlaWnpEDe2MzUx 8Xpd7dVbN89duVx9/tzpc2erzp1Fpjteun4NUoCDvXrNmt43x87OfubMGVS8cvNGd55o6zQDkUcH Lt+4js5cr68F8aUb12BcBgwY8P2m4l8PkyZO8fUJKSku8/f3hzHV0NCAUT56/Pj9R48aGhvr7t69 Xlt77datG3V1LBH+NF1wN26MHTu2N83x8/M3Nzejyq3bt8G5CzeiLaS4eruhAX140NR0v7HxTkND TU3Ntm3bvvds/OtBZI9MVGRseHiEr69vYGCgq6srLOOsWbNu1tY2tjQ/ffEc2Pz0SdOTxy2tT4GP n7USSPxEOaFpEVv9ZVvw+gjih81NYA62BEOCFbMVtNj68gXK8fPBo0b47YWFhdAJ338y/uUwbux4 C3OHjPRMSNnb2xsbXEtLa82aNRMnTsRWetj06HHr05dv37TR722zQPqdsY6Ot+0fboPr6ur21BD8 NKwHguzZyxev378j6jD5MHm+bXv/4s2rViyz58+aW1oQoGEdDh069EdOy78V1q/b4unhGxkZ7ezs DHGHhYYhVuLh4Vm2ZDlMJAzlkydP3nd5qNEzvHnzBm5z91YQm1+/fr33Lllbe/vr168bGxsvX76M aP3HT8u/Evr06aMorx4TQ7a1tXNyckIIbGhoiGhr9+498Jw5OTkRYcXFxT179qyd+czyr+Dq1au/ //5751YQaoHDV8i6re3FixcNDQ2HDh1atGjRlMlsf06d9rOm6N8EkyZN1dE2iokhOTg4QpkHBARg X2/atGn7NkHMMyz44MGDR44cWV5ejvnvvcQTExMJ/lgtiOJ7L+gOhpMPfQI3jUKhjBs3butWfsEd O3l4tnfpOWwNAnA+Pj4E7GoMQGbt2rVz5sz5YbM3Y8YM5j0BZBBd/rCm/x4sXbzK2Mjczy/A0dER ytzNzQ1bG4HYtGnsUL/wtAmLycXFBVUM7dp7ievo6IwfP37//v29FzSYwxY8evSotrbWyMhozJgx 6AlD2/ByzZiLYEFKSioiIuLUqVMg+zIr9DYhIQF9+PJ9v2XLlp3qBMnJyRGsQEjo0x3d0aNH6+np lZWVYU12b/fly5clJSUKCgq9vO/0g0FQQMTGmn4ji9DkmB9sbWlpmUmTJrGxsQ0fPpxJCYMOQbx9 +7aXsoNE4GJ9lawxVw8ePKiqqoKGQYsSEhLwFZFHr86dO9d7Vl0AFmHdunUsh6+trd2bjoEMxPPn zyeTyehkbxpFh//XDuPBcO+VUXF2cnNkaHKEYJheiHuHgBA2JhRpF2dYX1//8ePHULZ/e+Z7Ahhr GPc7d+7AdccyGzsWjY+DhrSzs2M5vRABqmDt0R+evnyJpYVefVnzREdHDxkypMsMQAP0pnv8/PyI H/9SpXSBmzdvjho16seJ869gxIiRigoavj7084Tu7u4w3JsZMG0aB+w14qZBgwZ1qRIVFdXa2tr1 9BEraO9ob2v/CzIQvH7zGtjCiLbQB6LFaWzTIOuLFy8SZG/evgEN0rf0k+z0o1MwK4TOh99+6dKl GzduQC1A7u10kbcTTb9vew9iVESG4HPs2LEuEr916xbRDQLphyw+4rv379AiURF6vvvomGy7l6Pd DsaaxMT+OHH+FcDj3Suj5ObmAZMNhwqxLWQNpd2vXz/IGlEYMl2qQL0XFBbcbbj3qLmJwObHLZ2x qaW5EcWMDHGVIMPPzvn7Dx/cuXe3tr7uVl3t1WtXL166KCYmBv79+/dHCiVDbGo0VH/nNijv3W9A lYePGgmEcAsLCwUEBAhzg03Ey8sLoTAbIrrxoPFhw4P7qA4kxOHn788cy9Q//wQNUYVA5qCARHUU Pn76BCkaRWdu370DVuBJjIVZkUBmu+gq6t6933Dt2rUfKM+/AM7p3HKyKp6eXpA1Im4IHYZSVJQ+ 7QMHDuzJ2Zg8Zcr+iopzly9Xnz9fc/Hi2UuXuuCZCxdwCUhkkBJkSIkq1efOVVZVHT1xovzIkdKD B5NTU7lnzfqNYVyQLli4ELJuffXqRFXVierq0zU1RC0CzzJSWnLykI+GhqgFmDN37vkrV4gOfNbo uXMnq6tPnTlT39BQdfbspI8vNfBu3fqwuRk0RG+ZyKwOBP0JRlcPHjpUfOAAhUbLyMnBzzPnzxPM CWImMseLilXnzl28ehUO5/eWYy9hFvd8eTkVH29fyNrPzw/mG3tEQUGRuMqcxu6wctWqAxWHyo8c PXTs+OHjld0R5UzsXFh+5BgyBw8fKSrbn1tYlJ2Xb+foNGLECCZnBOzQ6k1Pn5VVHDpw6HDFUTo9 UlREeqTyBLD63IXp06ez7GFeYRFaASWzaSJF9f0Vhw6iw8crN2zaRBBr6+o2tjzFpc697YKl5RUF JaXpObk7BIWYnsySpcvQty6jY44RrRN45MTJk1VnJv7PPLmbO2fR3r1KELe/v39QUBACMYSxamq9 OjgkLiVddKCioOxAfun+XmJeSVlecSnS3KKS1MzspPRMUQnJLmz1jIxfdXTkFBSDhl6luHRfUSlS onp+yf7z125m5xf11KuT5y4UlB5Alc4IVjmFxcgUHSgvKT/Ew8tLEHsHBB09XY3yHrtaXJqWsy+K TOGcMYOowlxg1vYOaOhLIy0pAwGa6+4f/iyYM3uR7F4lTw+vYAZgdyPO1dDQ6GV1/7CI1Ny85Ozc 3mNSVg4tMzshPTMkmjRv4aIuDCdPnXrwxGnwTMzIBjHSRKyKrByiIvJp+/Iv3KpvbGw8zYBTnwNK 7rQ8jU9N746U5NS45FRkUnL2bdhEj/IGDBxITc8EQ7Bl2U+UowOU1LRNPFu6j11MSvoLYye6nZCR FU6O/2ci+pYwc8Y8GWkFdzePsLCw8PBwHx8f+EgqKqp/WRErNj4+vvldByU1g5SU2nskJ6eRktLs XDzGsHpUKrlX7kj1+eiEpNjElJiEZKTMikQJMjG0ZHJyelJ2XnpBcXbx/pzSA0iBGYUl1PTsKGpi GDk+Ii6hC4bHUUNi4sJI8WC+ZPkKtMXBOQN8YmgpwO79RCFajKYl+4dHsTRqIlLSmUWlLMdI7yq9 empUfKKKVo8PjH4YwAcjhsDBPlNGmu6ZI7xCWIoNDl9XXl7+y9U5OTnPnDnzpK2DlJweSUmMjE/q JUZRk0nJGUgH9fCKkLmdAyU1CzzD4xK6cqYkRlBoSEPJ1OAYcnBMXCgpHmQRDOIwEjWMTEUmJJYS EkPBpc6IQtAHRsYGRMSEkigzZtJvdfJs5S86UsmiIUZb9PL4JPBU1zVg2VV1PYO0ghLWw2d0FYim V65hfXvnRwLCKyK8nTRxqpiojLW1LYlEiouLI5PJggwYOnRYT3V37Njx5MmT01fqSEkZ0QmpwNjE tF4iKSm9oPxYy/sOZU0dlswjKUmkxHRQxtBYsEVbKA+PowVGknxDI/3CogMiSIGR5IBIsl94NBCZ wG4YFEVHUPqGRHoFhYfGJhAuvZqOfl758WhqSve2UMIYVzra4t22g2VXfYIiEzL29dRPpFEJKWDO Uon9YEBsS4Srw4f/Liq8V1dHH4KmUqmpqalCQkK7du3i4eFlWdHBwQGha9nxanJKJjVjH4EJmXkf cV+nws7lnzApp/Du07f3Wt+u3bCpC/PBgwcnZhUQDFlyoGXlJWUXKmpoT2PnYOOYPu1rEbXY2dnY PxxoDIgiZxQd+Lz/nw0E0oxPy2afzuJG6NQ/2ZJzi2hZ+SyHSXQ+Li3bNyzqW4rtH8Do0aNHjhzZ 57c+u4Qk5eWUKHGUxMTEtLQ0WVnZPXv2mJiYd6FH8FhYWAhZZxQcoKRkYyqScwoTM/Mx/8gghaTw EykzT1zqjPRLmfm5pYfpa+ZY1aQpUzs3MWz4cLClpGYTdZncmHzS8koyi8p3Cot9g+GPGZOSW5yS W0Tw74JEu7SMvChKCsubD5t4tx49ewVkxKC6Vs/MT84pSkjfp6Fr+M+7+k0A4ibeuNywnl9CXCY8 PIJGoyUlJWH/CgsLm5l9Ju6lS5ciFr7+4GksLS2KCscmk5KaQ07OjEvJQiYuJRsZIo9CXGX8JArh 2eYwET9BgEx2SQUk7hkQNnDgp5u0cCdCYmGOE2MS0ggygu1HzE7dVwoUkZD5jVXEPWfOnCU9A/GA kmvmTIJ42crVuWVHmV3qjMzOx9DSDUytWM6ekob2/sozRA97qJ6N6us2sXDpfwqMGDGCnZ196NCh s7kXSojLurq4QdzJycnY4+Li4tLS0jNnziIolZWVX758mV9+PCACpjAuJJYaSqLR09iEMHIi8sjQ kUQLiqaAhiD7UMigYeIHYnr1hPTCA49edciranbulbK2vldwhG9YDJiAG9HWh4okGikpq+bGfUsH t+7DgXv55ZvzKXkl4LNxCx9BLyIpU1BxIjiGSvTnM4yFv0cNiqb6R5D4tguynD1HT38ItKfqKA+M iguKjvtj4qRvKrS/D7DdHBwcbGxs48ZOEBeT19TUTkpKTklJycnJwdRJSEhoaekMHDgwMjLyeUdH CCnJ2SfExS/MPTDSIyjKPTACqUdwFDOPclwFjaNXoKNXkJN3MH6C4BMlExnERJpVdqy08tyK1euZ vZo2ndPWzdfew9/BM9DRO8jJJ9jZl96um3+4W0AEuKUV0tWCv78/divoMQR+fv59+/a96+iIomWC gMkc9K7+Ya7+4S5+oegPGGoZWTAfAWibWAZEU1EO/izQJ8TJO8jFN5Rp6DsDjI5PaKyrXxjRve6I cnC2dGSxLH8iTJkyZcGCBcOGDRMUEJeWkkUslsEAT0/PjRs3Lly48MSJE6XV1209Ai2cva3d/JCx cQ8AItM5j9TS2cfc0cvM0dPEzt3U3sMM6Ohl7eZPXCXomUhUBNp5BxefvBQQQ5sw6dMJhIXLVhja uJjYuZnau5s5gI8nEMzNnbzM6Tz9YlMLXnTatshTssscfUIJziAAWrn6Wbn4Wrr4WDh5mdh7GNu5 yWvqj/h4ngqeKi5ZOnt3buIzdPAwd8BYPFhG3DNnz3MJiDJ18DDtqS5Se89d4v9b5+vGjh1LvM23 cMEKaSkFSwurzMxMqHRnZ2dePr6bzc1B1H26lq66li761u6Gtl76Nh4GQFtPOjLy9EJrdx0LFy0z Jy1TRzUjW2U9i1nzFq3ZtFXL1EnPyoUgIyiZ+KG6rSfqmrsE5Z24rmZoM2jwhzuNXFxcM2bNVdA2 UTW0Vje20zS11zJ10CTQxEHLzBH9IRgSTIiMnpUbynXMnXUsnLXNnTRNHTVM7MFWzcBGTtNk0bI1 nQU3ccqfGJemiT0dmcw7oYaJg7qR3U5xOZbztpZnm46ls8aXqttrGNvNW7ziR0ix1zBq1Ki5c+eu Xr164sTJ0pLKcnJKISEhurq6Vm5uh+reGrmEKOhZK+jbKBs5KBs7KBnZI1UxdkRKL2EUKhrYyutZ y+la7tUyl9Ew3S2rOX4ifZ/2HzBASFpVTtcKBJ3rMpEoRAapoXNQbGEV325pVBQXl9y2bRucimHD f1++nk9EQVtCxVBSzVha3URaw0Ra01RG00xW2wK9UjK0I5DeB10rWXRA01RK3URSzUhCxUBMSU9C WZ93p+R07nl9+/XvMvDZC1dIqRmJqxhI9Ij64DN/+VqW88a3S0pC1fCL1Q32apqNGvvH95bg1wKc 8w0bNkClr12zhX+r4OIly30T84OzTu3VcxBTNZXQsJDSspLStJLUtKRntKyRfshrWomrm4NGVMVY WNFgt7zeBgGxIUM/nXQaO2GKiLKRmIqJpIblp1p0Dkz8UIjUwDXCPjxr1qKVAgICUlJSlpaWGhoa y5cvHzBw0DSuuQtWbFq3XWybuIqQjKagjKaQjNYuWZ3dcnq7FfSQ7tyrs3OvNnFJQEpjNd8u7kUr J0yZ1n/gQGZnuujk8ZP+nMY1bxrXnJ5xLjv3/KEjRrKcNDauOWwz6NhTdXauuRzcC76TyP4JjB8/ nngDd/SoMdO4l8SUX7cMThVVNxNWMRFVMxfXtPyIVkjFNOiIvJi6hYiq6R5lY2Flo53y+kLyugtX beken85dvmGPkpGomhlRkVGXBYppWICndXiWhl3g+MlskpKS1HgqhULR0dFZsWLldHaufn0/BGuD hwwbOWb8JHYuYraZOGU6N8pHjum6m/ow4EfM4/8fmDZt2vz587eKSGWcf67jGimmbi6uYSGJ3adj I6Vjy0Cbj0j/iUsggBBFVU2FlY13KuhxcM9nyRluMJ+YMhhKaFp9rG7zOdoyecoaOvmkHMVC2rVH JC4uLikpSUlJSVRYQlBAZO7ceYBx48b15klib0SMiGMYA4Z/BJbHtHrZVnfoQqampraPAc5ubj/9 YSgCcCd//7IbrwxcghWNHJVNnVXMXJEqmTgh7YwoUTR2VDC0kzewldWzltG22COvPXbCl0LLcRMn y+rZyBvYoWIXbp3ZEo0auYVTyy8Lyajq6OpqamoqKaoqK2lv3MAH72LWrFldzoT0NLe9gaysrOZu cOfOnby8vE0fTz58Q6AkJp69fPnClSsFJSXfQ9ts3rwZsbOCggLs8pcpEYsdOnSo9OIDa+8IU5cA Y0dfQzu656xv62GAjJ2X4Uc0IMptPPVs3LUtXDTNnIRlVIYOG/5l/oA1m7fqWrsZ2DJc+k4MP2Nr 64G8iUtAaGrxvlM3N/ILrVq5WlFRQ0ZaDfMPcU+ePLnLayl/G6BzDh89+rCl6WFzU3PrU2DT0ycP WpobGh8SkZ2Xl9c3aYiASZMm3W64V3/3zu3bt01NTb8hZwKgqcAZ3X78rNXMzOwLlFgMDQ0NB2tu eYbFIZB09A2z9w6x9Qyy8wy28wpGvguiEJcQTVu6+m4VEu7bt+upRZbQt18/NQOLnnh+4OxJ5+zg HeoRSq68+iD/yLlZcxds4xfZwsMrJCSE8KHLJ1/+CSD8bGxsfPPubUtLy4ULFyorK0+ePHnr1q3W 1tYXr+iHITEnMBzfqjlYCn5+fj4+PqRf9WGTXgJsMXEO/N27d3C5eyITkdybnF8WQU0Jjk0IjKL4 hcf6hEZ7h0R5h0b79IC45BkU6RoQumzlV7y2D5jKNs0jKMIrNKonzsym0Y3gWFpMUlYImTZ6zFhs bfjnCB++4Wlt+KUdjFceamtrubm5wXn06NFTp0718/NDYXt7+9OnT7du3QpKLDMU+vv7E7tSUFAw JydHX1+fyap///5YjSQSCRry4MGDIF64cGGX5sDEiQGKiopdLsFlgiYpKys7fPhwTExMT58QhGYz MjLKzs4+ceJEfn6+jY0N80PxWlpaKCGU0uvXr8PDw9FbUVHRztUHDxmiZ2JOSUmPjE8II1GC6c+C o/zCIgn0D+8RAyKiXbx8ODg50TH0/6vMnOAe4S9wBjJbD4qMiYijxqdluvn4YUKwer/tSU5ra+sO xqs9kFFnS4p11dbWhp2CXU+I29zcnJhJaADEhh2Mz7cy30WFbkT5h7PlH19nwIIxMTHp3BzxlgrY lpSUMAvhFvr6+jI+DNtOpB2MFytUVT87R4TlpK6uTrya1M4AopWzZ88ingLBtWvXOneAeDXD3t6+ y5AHDx7MMZ2Tg2M6O/1BMMc0dgZyfER2duLR8KcSBs6YOXPlypUIlGxtbSMjI1NTUw8cONCdOUtA z4mGurPtjugVB+eMhYsXc0yf/g3VOAGlpaX0W68vXmDCf+sUku/YsYPYI3V1dTC4KIHnRkwmXfm/ eYNpR4b4/o+hoSFBjBJoCVhPLBLidSrMPLFaCKDRaCiEpfDx8SFKsDdhPiCaR48e3bx5k/iWIFgR ZGxsbMy6mZmZKHz+/Pm9e/fQCpzJpqYmEN+/f19cXBw+NjxM4vu0qI5L6EZ9fT20UC+nAhygOqCR Vq1aNZOLm49XUEhQWEhol5KSMjYFOkylUsvLy6FVEFZAvSCFMoEeO368En0Dzdq1n92JwtrArGLI YWFh0EjwHqWlpSUkJOB4W1la2dnZOTg4wMFgHKjYwrOZb8sWgTlzFmJTz549G5buG9pQAsDwZm1t O0MowsLCzPKJEycWFxfX37lzq66uqIh+zBWe4cUrVx40Nja1tDQ2NdUxyslkMi5BgTPed2jA/EdF Ra1btw4d1tPTq6uvv9PQ8Ki5OTc3l1hFCLuqa2qaHz/GYsDYibbc3N1R/d6DB9jv2KSIAaEnb9+9 2/LkyfOXLxF+/sZYhNa2tkQrV69exRTBLq9YsSIkJKSmpoZ4P3HkyJFSUlK19fVPWlsbHjzw8PCA oDGor/pPECxsdB5LHVpr27btWhqmdjYudrZObm4ekCx8Gwz84cOHWOrXr9+A0cHQsAsKCgoKCwsx Y6UMKGPA/v37kaIQqyIlJQVzFR0dnZaWBgJUPH78OJRDVFS0hbmFnq6hnq6xjpYpH68ALy8vjMWM GTO+x3fOly5dWllVdbWuDuIOCAjANEJLQ2QQx/7Dh3MwjLKyVYwPCi1dvvzY6dOHKisrjh3LLylB IfE0DXo4NSurrKICqKnz2REsfSOjw5WVR06cOHjsGGGAZs2Zc/TUqePV1ZXV1VyMd4GXr1xJtw7V 1Wio8+uW1vb2J8+ePVlTY2lri5/TOTnrGhpKy8vRq1WdPnCEPvzZaftPnDQJzNHPoydPcv3dd43h GmFaoC7glmAzaqgbhQbFhQTHREbGZGZmXb92Hc4M3Y998QI6BHKvra07deoUdj3WAyF3bATiw6cA QhtgnUAdQQthqUDtYF+gPDQ0zMXFzcXJw8XJ18TYUXDHLhERESx1RNmEOv3msGEzT2nF0bScvOKK I7UNTe86Oi7erM/IK6SmpMfE0yJIlC38H77zs0dcvLzyVGo2/Qg0D98n5bxhE8/ZKzeTMnNjKIkj GQ4kM/xfs259VkFx+r6CpPQs4hL/jh2VNedREhZNGsi4jWNiaX3y7MUjVTWYELh22K3Eke9DJ6tT c/JSs/NVNemvmkrJyFeevZCcmeP8MSpkeZNhCx//6QtXM/OL42jJXzhe+JcAB2nRokUCAgLQuvAW ZKTlHex8oyISYqLiyaT4stL99XX18HZeM75a+57+bxNthC8BVwE7BTYFKcRK0LxkADIwQzBYVVVV cXEUP19/H+9AX59QT7cwZSVtcXEJaP6NGzd+P1kDhCWkc0rLQ2MpQTHkoGhyQFRsYESsX1iUd1C4 hp4hW6fv/Kho6sQmpYWS4rUNP3O9tPSNcvZXkJPTlTS1ujAX3CNCSkoLiY2zdv7wpFtT3zghMzeS mqSqyTh+3KePo6dvFDU5KiE5JjEN5RH0M6uJ4WQERyR0A+mqdfSn/w4ePrSsPHJKxjbBnV8YjqqO XmJOfnRCsn63w2ZfC4hNEERg/mVlZQ0MDGBTFORVfLyiSDHJsdHUeAotMwOhwcn6+tuQY0+vABMf r3716hWkf/78eez7mJjYkOCwwICw4MCowACSrra5hISkvLw89jWMIBcX13f9rworZ/fohNRQcoK5 g4v4XgUJWQVRKdkt/ALdjzFYObnFJKZHUJI2bP7slKaZnRM4ZBYf1DT87J7JgAED0ov2h8XRwik0 3m0CKOnXv797QCglLQd8eLbSlcaAgQO9giOiaWmUtGxFda3dohK7xCSFJWR2iUhsFRDCatkpIj7i 95Fg5RceHZeanZCVt2PXnp7Ggs3u7O1PSsmkpOcI7OyR7KsA848IhZ+fX0VFBUKXk5PT1NAP8ifH xabFkZITqKm0hJSMjOzDh4+eOVNTe6sWlh2KGp4kXMQbN25cunT5yJEj+XkFZBIlOio2IiI2Ijwu MpwaGUYzN3USExMnPqULBQ5lwsnJ+c398M4ABUtKziCnZMYkpS9fzfrhJgHDh4+IoqaQU7PIKVnz Fy7ufEnXxBwb82L9w8fPnmFmiEIE74hTqOn7omkpAVGkQYPop+hHjxkLDsm5hZDa7Hn0xwp9+/Xz DAxF4eGaS+s/fzOlc7CMKMbdP5iUlPHodceBypNMHQ4X2tPTk3kgZ+iwYaGx1KzigzU37mBX0kuG Dv3nn4yAKZ8zZw58dTiEGhoacLCVlZWVlFTMTa2DA6Jp1JyE+MzEhAxaQloCNQXST6RhDWAlJFHj k+LiaGRSAplEI8UkxpFSI8MT7Ww91FS04FJi5cBF37Jly5IlS6DAv8cdpy4wZ/7C8LgUr2Co7sg/ GLf6e7rrPnP23ODoeG9QBkeN++MzbbNoyXL3gHDvkOhXHR0wTPD3YIIRTwXHJngFRzp6+KMVgpKd gzOKmg4+/uFk5qE1JQ1dz8CIQ9VXYddcXV0RaCOcuXTpEqrvFpXs81FYO3YJewZFBERRoCHh0zo7 OyMmgt2MoWUoa+r170//YuTYcX94hUSHxNJeMr4U4RdO0jGx7OWtzr8EWPN58+atWbMG3j4UOwJP yF1NTU1OTt7MxMLJ3jUoIDKBkpFCy0lJyklMoCNWQlJCTmgw2dPN39rSXl1VU0ZGBksFigJ+IB8f H3YHAq4f9hckvNt3mjq4G1k7K2sZf/lRxUbe7aA0tnFR0jbqfnWPpJyBlaOZvbu1W4C9N/32r6WT t4mdq5axFRvHp0Ppq9ZvDqGkWzr7aJlYEy+tAyZMnIyfhlbOZvaeVq6+1q5+5k5eRjYuRjau23aJ Mns1bPgIdUNLQxsXc0dPxu3lEDuPIAtnH0tXP7G9SgS330eONrFzQ11jO3czJ0+wEtjzDY5kdwYO Dg6EaQgAN2zYALnD5urq6kL08OHh1CkqKsoyQFNDE2EmhIstjLWhzgD6A01RUUgZcRZ2NDRG51sK PwA2btu9S0ppp7TK8vWsX5pgwnq+naDcJaO6fB0LykFDhi5euWGnlLKMpomclrmcjoWguOLSNZuH Dh/RmWynlIqykb2CntXmHSKdy8dPnLph604xBW0pVUMZdWMxRZ3NAsLsXF2/FjVm/IR1vIKiijp7 Ga1IqRtvERSbMefTXfE+ffouX88jLKcpqWogqaq/Q1xh/ITv9Wd8sLPY7MuWLcN+5+HhgZ7HhoX0 sXOh8IlvXkH6kDhEvH37dhgXmAMYaEgZa+anvPLc+4ePfXphAfv26z9i1NjR4ycOGzGqy6U/prBv FVexicjao2S8W8n4zxksPvw1eMiwUeMmjBr7x8BBX3oCPnDwkNEMskFDWMdZqD7899GD/0EU9lXA zs7Ozc2NLY8Ni10Pma78CPgJdb148WIsjJkzZ3b5jtNPgd4/Iv8yZfdLzBLMv5S2pZFHlJSWpZi6 iYCkav8BA79cvfdd6g3Zj4fJkyd/v9j5fxzG/THRxMlHz8ZN28JRQct40q+PPf6rYcy48bvEJAR3 i2zk4ftfeP3zF/wX4P8A1crmYQ0KZW5kc3RyZWFtDQplbmRvYmoNCjg1IDAgb2JqDQo8PC9UeXBl L1hPYmplY3QvU3VidHlwZS9JbWFnZS9XaWR0aCAxNjUvSGVpZ2h0IDY3L0NvbG9yU3BhY2UvRGV2 aWNlR3JheS9NYXR0ZVsgMCAwIDBdIC9CaXRzUGVyQ29tcG9uZW50IDgvSW50ZXJwb2xhdGUgZmFs c2UvRmlsdGVyL0ZsYXRlRGVjb2RlL0xlbmd0aCAzODE0Pj4NCnN0cmVhbQ0KeJzFWmlYU1cazkZW IIGQQFgSQtgJyBIggICgsieAClioxQUURVzqgigq26iodRed4tKZCh3H0WqdWoFqW2rVtijqAyIg UBQERKyIgECWORcSudlYnqcD7w+e3LPc857vfOc77/kuCMQ4MOdY2VhZsIzHazc9MDC2dPGdGxIW HiGICA8NmePjyDaiTjcpBegxrDxmhwsgCNdv3vSxEPoVFuDKppOnm5ocFCM7f8BwXs7XD1qlI+hp uHksSSgI8eLQdKeb3jDoVn4RggX774ukSnjx72RhqIe5wfTT1GfzwwQx53qVGY6gIk0Y7GamR5xe jjS7uYKoE13qKQKIf0gSzrahkqaRoq6xS1hkXotGihAGriwMcaBNH0sy0yci+tKYFCE8Sw2bYag9 TRx1zf2F8ffH5Qj2epbA3Wh6WOow/YWprQpsJKKh/nc9PX1DQyIJvFx0KsqdPh0rTjKZKUzvgTPp ba/64eLZw/sOFJ4vqfijq18Mq7wa5WowDXuc5i5I7YZRbKsozkoMD/DxdPfw9psbs/b4jfoumDmL Ih308FPNkWwTltj+gYK4/fbhxABXOwtTGlRpyraZwY/eeb329SjL4yEcXdzUciQxAxdUfCDQd//0 qmA+l6KjhRxtYuMRnVdW8+Ecer8twsZID4BCJqKnhiSVF/XlB469T28UnSrIz9+9zZ2Cgk3ExmvF xceD8lZvr5w6tD8/Pz9vwxwSUvOb/zqQ2CEp/WqCzd2Z2vDxrYIOvlZt9CwaPpX/H6juCyrVcJRK zjliPzRCEu1z36i2adjsojMVJImsoCx1HKXS/i1mcodDkb2KBlQaiGvy5prgp2K5KU4x1epJSl/M 0x9hgKKH/apaPVSRF2ahMxUbB88I2C4PgT3KNO7OJAKWSKx5crMaQ5dummlCmBKPJFlF/Sgbtf0n Za8Tn7LVQiBJTvlvVTlKytd7GGKnZGsjdLlLZAaUnMwqVta7vWuMMXq+l4bUOcONYAYeicJTDJls NpOujRmXL4ZIoehRiJjJk9TnH5IN+mxlUNIVZTp/RNvOf6COolRaH+nkNku4ek/h1WvXvjm2Y/5s Hpssc1AkzsTNf5avp5sLgLMdg4BE63K8BZt3gfi7JZLPmmRsxTPCbsoG3RvA4qXckShR+f1wm3qO 0sEzV6s7YcKju65kg68pDhofbbyt42Vn59NqCFWV+WyGe0pZiyw8iJ5/HW6CHZcZDASzhTKFNhRj Taa4ZdQqUZGoxnnlecDQdtybCrYSzuMXeOkPCbtrFK52rzM5WpOxJHOpbIUbfGhEjIFf/kvNFGSz qRaPUVvzEQON0Il+AS/7/ZFyj95VhpMICwROpqxfoTUJh8Qah/793dgc35Xs7x6r/uXHdDQ9VSHy 96m2qvaZhIoi2p6UdZtP10IjkHjz2EuDqu8cxYsv0tJewZ5FHfd+vt8Bt9QTf23Lo2POE2AgkTJh jigC94Ksm+9wXEaRbJeXa15O0aO9McJimFMOlO9PTVx9DO7JkiwW/6ZyR7GyI+eYTniHo/AzvpW9 2hMx3AtNdtlUo4ljf1l6oHs6fPV+2+Bna2EvOAvfF//1EDQodJN0Vdz4pV2hSHrEYsJOicQ6fy+z kbusE4bqs6tDPceuomQeOxxOoO/S2qig2cGf/ANOsjx0uYLXip+cSEtY+aWir+/hTHznYBxkJMV8 uRLHmsRdVVU8oEX9kQW2VOsj8IUTvX3dCdClcGzejstRWNznu0PtzZ3XK1xGB7cwJx7QUTby5fbF yaaGs96gEEDkr72zM8hcmzirTk2dIn5adlFhcl+GGuPRBvEKGuXVCsbEfRJpId84oaThMw1JdMhV o8ClkoqtPgw8ipwwZvwZxrdrH8Efu9OtwDGk97FCAH4UpT9hQ6JxDHkIWqGHQUHq1vsr9SGoNcUc jEVbO8Z5I5vOkXSFTfL0IzoSgTRKew8vPO818fwCRpuSLut2yRSHRmAMBRVSDSj1xCOQZtnwov7n tY+Vce/rFTsUXPo7fx0weetT8LLBHJtJnIt6dKHsWOzgamvhOKma02pDn1likOb58KL2wo1paWlr 1m3ckiHHllVRwSfgbcT7uOBwwXrfhRe+WmkyiWNRj8WT7RJRMF3f9bCGBOowupcbopmZ8Ej/bD3P 1tbONXLvqTMynD6+3nm2Qih/s44JnF076jm8sGrexF0SgdAxdymXddzLCy9VSUMroCFcz2QtPNr8 ucmWbGAdWQJvdJ4rVAjljR/RwD6mJisc4F/7TCblpc3mH5R1fJk9bnT5gW8aXwkvqCtI3FqkYKPu NOdlCgGgLBC4pJKbDOXZTkpQmvjEyI8ClXuYCsTHvaPOqNE0o+grDnPZDg8Aks8cgUti3K7DW3Wt Np3UBY7KW3hH45A9yor3Xdbi3DHUpKSjaAmXfx5e9HYDC7gkIbgeXvhkweS+XVEcFuzSEPrEdZdv Kd952vc+1EhxsO367vm2NC8FVV4fB7mkTjRc3kn/4zPJXLFZyKf1UnUYKN+ZuFWF0rMPU1CY2sCb pp+LshP4TG2S8+dVzztkeFFz1Au4JEI3sLTuhbzw+YMUq0m5JAJB46+9os6U3RdX8q19816pqRqu fnT7fs3z9vaOjvbW2kclxYe2JIa4mVOwKKzZ3NSsPIBcgO0pgaaQBCdaRa/PzpUhI5FH1WG5utvp TdgxUa6ZT9SQaP08nqtPZISfU39IDpXtTUldk5EFxszOXL88NtjbkU3XhoSUFjMiLWPbtm0Z6xaF eLnYGBEhJlpkloOrmwxOHKq2bXFjU+VMjeliJI5qYqKPk2sQjHFygyoHUdVegaUOGkngJKk/Jqty gp0sbJ1cwJguM+wtzehkgiw7gPeqez8Aobf58wAGUWvYWkgMjkiSg4jHUKI6wZ0xUuMnVS1OzoWv NjNGrvFIgk26GoU78GPGLFPisN7g5XSq4dhzdr4JGY0lDI9MwGFQo7pL/5PRUFbpqd5WSMONoLYm gqLJkOQFIC7edBj2XKSOx2k1+dN3320MpI/YGmMY9k/VBRf9tNWVpv79KNbfQESQiIcD1VC6Kc3K nmVgYmeujUISjJ28+HZ0LBKBMl11p67qmJcOEmtg58nnynJKaDKH5+NuScZoe5yUQF852AQooxf8 s5o903d9TzyPRR+ZE56zTPUbVOfpuWYarIBxvQY4tlTcrYWC/uVZa+7eu5pwuu4CR5sV9sXjttbK XBddJMZqV+0fFUssCHru2RUtbVX7XHWAmtN2SL3R9LK5PNHa9VoH9JKqI0wgTdwq1Trc4Ok4YZCv qx2Hbcq24iWcUhHBfZn2mgQCIRjcHAf/tXbFPug6V7r0V+B7QANf9/UpGFG94h+9dfB8EEtfxzFM Yx8MG0lS4kZAG4SWjKxZd748PV7BAxcFmxUXbj2ofvy4rvHFm364TXu/ixQIBOEQohZl/qdeoXKw o2wRW5P4p3zyJ7D0Zp7jkgfQzWEr8GhItXyxtPxD/2I7PSjD8SzWJgnyd6havMOUJmiSN/huv+zH dT7YQwbOwmWpQBGmbd97vrJFUQINNF7dLhQIhAW3XyoehG8fFi5205SERprmAZesWeM79xCwf9++ o8NH1sCrgzegqTc3QhnQzmirjUCmVy2c91gqfV//+wtggV/85gB7S/5saO4VV6bn1IMh+1vvZ9gD RyXSWNa2wwiIzS59qu6OqAxJW+n2cGcdTUlGDBf60tv28LdaaOl+31oKdWm5cuA4WMCuy/v3XAIK aShzVhEo/nYxuF4NPSz+eylQf03LjoOGjed25Z+5sCk8ARJ/1UeX+xhC80ZhtLAj4PikXqoeXwcN Pv13khsTHnIUgfO9PTqfxpxUyDFbjyUuAT44dC3J1/9TIAdF+QvBXhw8mgbWfLC9uakVmLU5B7hy b2Gsl1fgHFdrIagX/TPSlkZQej3LJbagokNtTnd02J7qwhguQwNBCKTR5EXfvRzB8jZoaKFTAria dWW76DMSmkCE27oabN6uzK2wdMG9w+ChOc2arEs10KUuAPTfbLImYlTOTVOHuZlljW/GUGL9LTdz wmwNx+CI0F/8J/SN9+2b9sqza3wdVwEfbFhhYbQIlHauY+EstoFlr121E/ytS80F7tXT0dLS2v6y qeDoIHSvNMBRGbpoajJg/DServZot/KMO3CruVeDchtou3Mo3oOjIYiPAMXcDbZf+zenjuSuDHWg W0G76FYIxeBjoFPElyJ9N4F73lBh3DExlFndDpa57fqXRf999NW2+Lz30Af/wNm53wfRmTsA48p1 swzVfn4xs5+ZeKKio3dIhaeo/2XFycXediZjUQTxYjiU30ie4+1qbUjCO18BT0VueErYPcifa6qA hUT3kiMuguLisFXAvOJnD+veSatieclQFub1w6di6WNfh2Ng/N7WajcNOUwW13/pwZLazneiUb0o EfV1Pik5uMyfazY2RRDKg56CqLKHRyOTcGgkfjbQV/07rDBE5zz5nhTdT/cRghA6sMsjokQ+RE0w M7BY7mdNAufDwz+q/TXe1tiO/NDl+y5XPuvq6Xs/8L6v51Vz5eX85eFeXOZ4FMG9LviPgcGmRYwR byLNaRgYbEwwQmGMhUWvoD35vvP6Jv8ZK8HZ07XSkrv6zjtAU/SmYp2THmfZjz3gQdz9aAvPLqVV LJV0n3Ef60rJ4XrMWbg660DB2XNfnPhsZ1p8EM+ebTQ+RUBrxpqCk596kEciFHFG2vET6911kUiS 5bzdl397cOur3Yv4Hlt/BWweRNKp7iknb9777VrBGj8jPGXG0mPfV94vK/w0wMRoZuY3d8sOxFiM 8+8J5jaOrh58bz8fvrsL15o50SsJlubo5+dIw8qfuH5+XOgJrc3yjFq64pMITw57CZQUGjjKI2Gp tgEfJSfFzXY0IqC09Kz9Y5OSF85xYhCJDPeoRTF+HN2Jfbc0HismqgEKRzYw0MWiVJ5QOIqxhaW5 EZnA2gPtofIEphYSQzRgcjhmBiSgl5FoItWMw2HSSFpIFE7PmGVqQBz/I9tfDXC6YdAoBJq5ub79 +bernXQhBkg0KJRTgT0gUWiNh9oUAE2bmZqdEeesP7FPjP8DU/4xtA0KZW5kc3RyZWFtDQplbmRv YmoNCjg2IDAgb2JqDQo8PC9GdW5jdGlvblR5cGUgMC9TaXplWyAyNTZdIC9EZWNvZGVbIDAgMSAw IDEgMCAxXSAvUmFuZ2VbIDAgMSAwIDEgMCAxXSAvQml0c1BlclNhbXBsZSA4L0RvbWFpblsgMCAx XSAvRW5jb2RlWyAwIDI1NV0gL09yZGVyIDEvRmlsdGVyL0ZsYXRlRGVjb2RlL0xlbmd0aCA0NTc+ Pg0Kc3RyZWFtDQp4nIXCh1LaAAAG4OeytXvbOlERUQSRoYCgEMIKMxD2HmELiIAMrXbvZdvH6h/j nXetd/3uG5s0jp2/hlN8E//6NHecS4zPXLyBs8RNrpl/aw5JroC8LSDv4LwF7/IXrPfO319E2wMh 3/5wiftIhA58vIzUEzF3QuycWHE+XUXXM5S4JiXuqTX0TEu5MzLvLK77cE7uE8hpwQY9r/DjgjKA i6qAUMUI1cySOijaDIq2QsuoCYs14RVtBFd1UZRsx9b0Mak+LjXEZYaEbCexvptEuTG1YUopTGkF kVYSGaU5qyKzajKntuQ2rfkttBU09oLWzmodrM5R1FGlbaqkd5b1rrLBXcEdT3XXUzV6a0Zf3YT0 HoH+hjnQIANNkmlamJY12LKG9m2hti3ctmPkwBHpUNEOFes6Md5zYeLQjcm+B1MDb3rgSw+Rzozo 7MiPuaMA95jJHzOF50HuSZA9CbGnoeJpGEsvIlh+GcUKvoph9XUca/gmgfW3SdzDdyls4Ps0NvFD Blv4MYv7/E+5Nv9zHg/4XwrY4X9lu5eL3W/F3sVS7zv38HK5/+Ovlf5ZZfDP4Vl1+PPKteGv2ug/ 66Pf9aMr/gGo3JghDQplbmRzdHJlYW0NCmVuZG9iag0KODcgMCBvYmoNCjw8L1BhdHRlcm5UeXBl IDIvU2hhZGluZzw8L0NvbG9yU3BhY2UvRGV2aWNlUkdCL1NoYWRpbmdUeXBlIDIvQ29vcmRzWyAw IDQ2OCA3MjAgNDY4XSAvRXh0ZW5kWyB0cnVlIHRydWVdIC9GdW5jdGlvbiA4NiAwIFI+Pj4+DQpl bmRvYmoNCjg4IDAgb2JqDQo8PC9TdWJ0eXBlL0xpbmsvUmVjdFsgMTM0LjIzIDI1OC4yOSAzNjku OTQgMjkxLjE3XSAvQlM8PC9XIDA+Pi9GIDQvQTw8L1R5cGUvQWN0aW9uL1MvVVJJL1VSSShodHRw Oi8veGVuc2VydmVyLm9yZy8pID4+L1N0cnVjdFBhcmVudCAxNT4+DQplbmRvYmoNCjg5IDAgb2Jq DQo8PC9UeXBlL1BhZ2UvUGFyZW50IDIgMCBSL1Jlc291cmNlczw8L1hPYmplY3Q8PC9JbWFnZTkx IDkxIDAgUj4+L0V4dEdTdGF0ZTw8L0dTMjcgMjcgMCBSL0dTMjQgMjQgMCBSL0dTMTMgMTMgMCBS Pj4vUGF0dGVybjw8L1A5NCA5NCAwIFI+Pi9Gb250PDwvRjMgMzAgMCBSL0YxIDExIDAgUi9GMiAx NCAwIFI+Pi9Qcm9jU2V0Wy9QREYvVGV4dC9JbWFnZUIvSW1hZ2VDL0ltYWdlSV0gPj4vTWVkaWFC b3hbIDAgMCA3MjAgNTQwXSAvQ29udGVudHMgOTAgMCBSL0dyb3VwPDwvVHlwZS9Hcm91cC9TL1Ry YW5zcGFyZW5jeS9DUy9EZXZpY2VSR0I+Pi9UYWJzL1MvU3RydWN0UGFyZW50cyAxNj4+DQplbmRv YmoNCjkwIDAgb2JqDQo8PC9GaWx0ZXIvRmxhdGVEZWNvZGUvTGVuZ3RoIDY0MD4+DQpzdHJlYW0N CnicnVRNa9tAEL0L9B/mKIVkvd+rhZCDEye4EJpiQw+hB9VZOya25Eoyaf59ZxU1lWTZhF60COa9 t+/NzsDoAS4vR/fX0xugV1cwvrmGX2FAgRJKKeOcGjCcgpIUChcG388gCwMGq48aSjWjslO0PAuD b2EAk/trgJYA+ydw0WCV1abRSgRjQ1pcEGsB1UAbwqgFZRWhDDjRWjNYbMNgNN2mK2cZ3OQwJMwb 4dHdjBtYlY0DZhOScE9rTQKC4SlAJIwY9eHjgEscpMSlZHLg5l5N1mqjh7SqXJHBokQqK6FcZB4u uSG8RqKopvpkerIRHs+R8FYAOpkvvRMfDQONd5HoQlvCLMy3bX3q3eIvE83vXRg8XlJhxlc/YP4l DCbI+c7L+rwJxzh4m/cxmtxOYV1CrKLq2UHmXiG20c88jy94VK2zFZRVmj2lRSyiJ4iZwLK0gthE CCrcbpMufFE8pE0wzkF9oYkxjf54+nXWQ/8tZ0ISabrlbaWDWFU/1q68pUQwlKeMyMa+D04OBddF 4lMlmGUbGc3yrfMh9b1/YDBlYbuYfOeKtE4V8y7fyspt4wsRlT7PPNu8gQ8eOwGv6+r5GLG0luik S4xdPFKteEJkr/pkiPpTIXKt/YT9R4ht5GdD7GCWLq0f576ooeU5bNYv7hiDNy56ojVusS/84cZ5 Xh1LmgmSJF3wOQ4Be2/Wa168QJxEp5qlDC443aU43ixNUbBXfbJZptMsdKsPhs4vE8NBKk2Uqjnf F2a9OKLJb3yS663LqnRTO5vtdz6WXV7glDMaLfMC7vYOx7+s8AN+XxzzivOtRFvp0W+SfrqjWz54 T4UvlHXRB97/APotc38NCmVuZHN0cmVhbQ0KZW5kb2JqDQo5MSAwIG9iag0KPDwvVHlwZS9YT2Jq ZWN0L1N1YnR5cGUvSW1hZ2UvV2lkdGggMTY1L0hlaWdodCA2Ny9Db2xvclNwYWNlL0RldmljZVJH Qi9CaXRzUGVyQ29tcG9uZW50IDgvSW50ZXJwb2xhdGUgZmFsc2UvU01hc2sgOTIgMCBSL0ZpbHRl ci9GbGF0ZURlY29kZS9MZW5ndGggOTkxNz4+DQpzdHJlYW0NCnic7V0FXFTZ91+7115zEUTE7m4R RBEMOqS7u7u7u2YYhqFbGlQwMUDsFjBQEVCxA/h/Z56OCIOLu8bvv+v5nM/93Lnv3HPj3Hvivfve /PbbL/gFv+AX/COYN3fewgWLlyxeMnr06J/dl1/wLaFv376bNm2ys7PPyMisrqp+9+7d27fvnrS8 u3fncesT5N+i5N69hkMVh4KCgiUlJSdPnvyzu/wLvhoGDBggJCSUnpb+8uWr9+/fQ6bPn7+4f//B 5ctXjh87npWZGxNNzttXeOrU6atXrj548PDFixfv6ADK92fPnjczM/8l9/8XMHDgQH09/aZHzW1t 7W/evG1ufnz1yvVDFUewuykUSkhIqLu7u62trZmZmb29vbe3d2RkZCItMTc399ixyuvXbz5+/BS1 3r9va3vfnpqSxsnJ+bMH9At6hL179968cavtfcebN+8guDt37l69evXMmTPHjh0rLCxMSUmJiYnx 8/NzcnKysbFxdXUNDAyMjY1FeUFBQUVFxenTp7H9oQSgCiDx9raO9+/eh4aGTpgw4WeP7Bd8Bps3 81RVnXn/vv3tm3fPn718/PhJS8vj5ubm+/fv37x5E3I8w4DS0tLMTPo2h5SR0mi04uLi48ePnz9/ vrq6+uzZs7du3WpsbHz27Bk0e3t7BwH46ejoOHjw4J89yl9ABwszq7dv2l6/ftv69NnjlifPnz2H D9be3g6LDNmdP39h//79AQEBenp6srKyu3bt4uPjW79+PQ8Pz44dO8TExBQVFU1MTOLj4w8fPlxX V//06dNXr161tbV1dIb2jlOnTv35558/e6z/acCOo1KTn7W+fPLk2f37Dx81Pnr+/DmE8+bNm7t3 72LDYi+TyeTg4GBsT0NDQ3l5+T179mzdupWff9v27QI7d+6UkJBQU1ODuF1cXIKCgkBcVlYGhYDd /Zm02zog/3t3G1avXv2zB/0fhSlTph6qON7S0vrwQeOtm7XQ29jOEPft27ehvSHo9PT05ORkSDAs NNzK0k5OVlFSUlpSQhJ7XFlZGZsatl5aeq+MjJySoqqLi0dsLAnqPTs7u6ioCOa+oaGBkDV2Ot1r f98GY/HqxRt5OYWfPfT/HMzinl1z5lLjw6a62tuXLl2ur6cr4Tt37kDQiQyAA5aRkREUGKKhoQP5 qqura2trI4Wg5eTkUIKdjn2tpaWlr6+P3Q1Vr6CgYGRompSUAoNeUlKCtLKyEuYAoRzU+8sXL1+/ htp4+/pVm52N48+egP8QTPhjwtEjp27X37148TJM6pUrV7Cjq6qq0tLSoqOj4+LisEkjwiPkZOUg XIh19+7dmzdvhh5eyYDlDFixYgXxE+VbtmwBDYgheiwJTU3NnJyc/Px8pFlZWXDkoDdaWloaGx81 N7e0tr543PJSWVH9Z0/DfwKGDBmanrbv+vVb1dU1iJ5goCEOeFmImGB8w8LCIiOioaWxf+GGQY4Q 66JFi2bPnj19+vSpU6eOHz++MzeUcHBwcHNzL1y4cNmyZaBHXVh5JSUlHR0dyBorh27QS8uamprg D9TV1T24/5ChVR5u3yb0sybhvwNWVo7V1ecO7D+YlJSUm5uLPZiVmWVmZmZlZeXg4GBkaAZ/W0hI aN26dQsWLODi4poyZUrvmUPuhNCh8KH8xcXFY6LpoTocOeiNixcvnjx58ujRY1hgVadrigsrJkyY +P1G+gv4tmwvKjqQn1/o6elpampqbGwMm7uVAYiw1qyBkNdBb2/cuHHt2rVQ1EsZsGTJEqR9+/bt TRPDhg2D0KETREVFVVVVUVFGRkZERARLCD/d3d3t7e3t7Oy9vX0c7JzUVLWWfISlnwNKoDe+94T8 i2H48BGR4eTy8gp7e4eg0NArtbUdXwN2jl/hX7GxsUHoc+fOpVKpX9UK4Hp9/bX6+rScnAkTf+39 vw9KClpFhaVpaekQN7YzNTHxel3t1Vs3z125XH3+3OlzZ6vOnUWmO166fg1SgIO9es2a3jfHzs5+ 5swZVLxy80Z3nmjrNAORRwcu37iOzlyvrwXxpRvXYFwGDBjw/abiXw+TJk7x9QkpKS7z9/eHMdXQ 0IBRPnr8+P1HjxoaG+vu3r1eW3vt1q0bdXUsEf40XXA3bowdO7Y3zfHz8zc3N6PKrdu3wbkLN6It pLh6u6EBfXjQ1HS/sfFOQ0NNTc22bdu+92z860Fkj0xUZGx4eISvr29gYKCrqyss46xZs27W1ja2 ND998RzY/PRJ05PHLa1PgY+ftRJI/EQ5oWkRW/1lW/D6COKHzU1gDrYEQ4IVsxW02PryBcrx88Gj RvjthYWF0AnffzL+5TBu7HgLc4eM9ExI2dvbGxtcS0trzZo1EydOxFZ62PTocevTl2/ftNHvbbNA +p2xjo637R9ug+vq6vbUEPw0rAeC7NnLF6/fvyPqMPkweb5te//izatWLLPnz5pbWhCgYR0OHTr0 R07LvxXWr9vi6eEbGRnt7OwMcYeFhiFW4uHhWbZkOUwkDOWTJ0/ed3mo0TO8efMGbnP3VhCbX79+ vfcuWVt7++vXrxsbGy9fvoxo/cdPy78S+vTpoyivHhNDtrW1c3JyQghsaGiIaGv37j3wnDk5ORFh xcXFPXv2rJ35zPKv4OrVq7///nvnVhBqgcNXyLqt7cWLFw0NDYcOHVq0aNGUyWx/Tp32s6bo3wST Jk3V0TaKiSE5ODhCmQcEBGBfb9q0afs2QcwzLPjgwYNHjhxZXl6O+e+9xBMTEwn+WC2I4nsv6A6G kw99AjeNQqGMGzdu61Z+wR07eXi2d+k5bA0CcD4+PgTsagxAZu3atXPmzPlhszdjxgzmPQFkEF3+ sKb/HixdvMrYyNzPL8DR0RHK3M3NDVsbgdi0aexQv/C0CYvJxcUFVQzt2nuJ6+jojB8/fv/+/b0X NJjDFjx69Ki2ttbIyGjMmDHoCUPb8HLNmItgQUpKKiIi4tSpUyD7Miv0NiEhAX348n2/ZcuWneoE ycnJEaxASOjTHd3Ro0fr6emVlZVhTXZv9+XLlyUlJQoKCr287/SDQVBAxMaafiOL0OSYH2xtaWmZ SZMmsbGxDR8+nEkJgw5BvH37tpeyg0TgYn2VrDFXDx48qKqqgoZBixISEvAVkUevzp0713tWXQAW Yd26dSyHr62t3ZuOgQzE8+fPJ5PJ6GRvGkWH/9cO48Fw75VRcXZyc2RocoRgmF6Ie4eAEDYmFGkX Z1hfX//x48dQtn975nsCGGsY9zt37sB1xzIbOxaNj4OGtLOzYzm9EAGqYO3RH56+fImlhV59WfNE R0cPGTKkywxAA/Sme/z8/Igf/1KldIGbN2+OGjXqx4nzr2DEiJGKChq+PvTzhO7u7jDcmxkwbRoH 7DXipkGDBnWpEhUV1dra2vX0ESto72hva/8LMhC8fvMa2MKIttAHosVpbNMg64sXLxJkb96+AQ3S t/ST7PSjUzArhM6H337p0qUbN25ALUDu7XSRtxNNv297D2JURIbgc+zYsS4Sv3XrFtENAumHLD7i u/fv0CJREXq+++iYbLuXo90OxprExP44cf4VwOPdK6Pk5uYBkw2HCrEtZA2l3a9fP8gaURgyXapA vRcUFtxtuPeouYnA5sctnbGppbkRxYwMcZUgw8/O+fsPH9y5d7e2vu5WXe3Va1cvXrooJiYG/v37 90cKJUNsajRUf+c2KO/db0CVh48aCYRwCwsLBQQECHODTcTLywuhMBsiuvGg8WHDg/uoDiTE4efv zxzL1D//BA1RhUDmoIBEdRQ+fvoEKRpFZ27fvQNW4EmMhVmRQGa76Crq3r3fcO3atR8oz78Azunc crIqnp5ekDUibggdhlJUlD7tAwcO7MnZmDxlyv6KinOXL1efP19z8eLZS5e64JkLF3AJSGSQEmRI iSrV585VVlUdPXGi/MiR0oMHk1NTuWfN+o1hXJAuWLgQsm599epEVdWJ6urTNTVELQLPMlJacvKQ j4aGqAWYM3fu+StXiA581ui5cyerq0+dOVPf0FB19uykjy818G7d+rC5GTREb5nIrA4E/QlGVw8e OlR84ACFRsvIycHPM+fPE8wJYiYyx4uKVefOXbx6FQ7n95ZjL2EW93x5ORUfb1/I2s/PD+Ybe0RB QZG4ypzG7rBy1aoDFYfKjxw9dOz44eOV3RHlTOxcWH7kGDIHDx8pKtufW1iUnZdv5+g0YsQIJmcE 7NDqTU+flVUcOnDocMVROj1SVER6pPIEsPrchenTp7PsYV5hEVoBJbNpIkX1/RWHDqLDxys3bNpE EGvr6ja2PMWlzr3tgqXlFQUlpek5uTsEhZiezJKly9C3LqNjjhGtE3jkxMmTVWcm/s88uZs7Z9He vUoQt7+/f1BQEAIxhLFqar06OCQuJV10oKKg7EB+6f5eYl5JWV5xKdLcopLUzOyk9ExRCckubPWM jF91dOQUFIOGXqW4dF9RKVKien7J/vPXbmbnF/XUq5PnLhSUHkCVzghWOYXFyBQdKC8pP8TDy0sQ ewcEHT1djfIeu1pcmpazL4pM4Zwxg6jCXGDW9g5o6EsjLSkDAZrr7h/+LJgze5HsXiVPD69gBmB3 I87V0NDoZXX/sIjU3Lzk7NzeY1JWDi0zOyE9MySaNG/hoi4MJ0+devDEafBMzMgGMdJErIqsHKIi 8mn78i/cqm9sbDzNgFOfA0rutDyNT03vjpTk1LjkVGRScvZt2ESP8gYMHEhNzwRDsGXZT5SjA5TU tE08W7qPXUxK+gtjJ7qdkJEVTo7/ZyL6ljBzxjwZaQV3N4+wsLDw8HAfHx/4SCoqqn9ZESs2Pj6+ +V0HJTWDlJTaeyQnp5GS0uxcPMawelQquVfuSPX56ISk2MSUmIRkpMyKRAkyMbRkcnJ6UnZeekFx dvH+nNIDSIEZhSXU9OwoamIYOT4iLqELhsdRQ2LiwkjxYL5k+Qq0xcE5A3xiaCnA7v1EIVqMpiX7 h0exNGoiUtKZRaUsx0jvKr16alR8oopWjw+MfhjAByOGwME+U0aa7pkjvEJYig0OX1deXv7L1Tk5 Oc+cOfOkrYOUnB5JSYyMT+olRlGTSckZSAf18IqQuZ0DJTULPMPjErpypiRGUGhIQ8nU4BhycExc KCkeZBEM4jASNYxMRSYklhISQ8GlzohC0AdGxgZExISSKDNm0m918mzlLzpSyaIhRlv08vgk8FTX NWDZVXU9g7SCEtbDZ3QViKZXrmF9e+dHAsIrIrydNHGqmKiMtbUtiUSKi4sjk8mCDBg6dFhPdXfs 2PHkyZPTV+pISRnRCanA2MS0XiIpKb2g/FjL+w5lTR2WzCMpSaTEdFDG0FiwRVsoD4+jBUaSfEMj /cKiAyJIgZHkgEiyX3g0EJnAbhgURUdQ+oZEegWFh8YmEC69mo5+XvnxaGpK97ZQwhhXOtri3baD ZVd9giITMvb11E+kUQkpYM5Sif1gQGxLhKvDh/8uKrxXV0cfgqZSqampqUJCQrt27eLh4WVZ0cHB AaFr2fFqckomNWMfgQmZeR9xX6fCzuWfMCmn8O7Tt/da367dsKkL88GDBydmFRAMWXKgZeUlZRcq amhPY+dg45g+7WsRtdjZ2dg/HGgMiCJnFB34vP+fDQTSjE/LZp/O4kbo1D/ZknOLaFn5LIdJdD4u Lds3LOpbiu0fwOjRo0eOHNnntz67hCTl5ZQocZTExMS0tDRZWdk9e/aYmJh3oUfwWFhYCFlnFByg pGRjKpJzChMz8zH/yCCFpPATKTNPXOqM9EuZ+bmlh+lr5ljVpClTOzcxbPhwsKWkZhN1mdyYfNLy SjKLyncKi32D4Y8Zk5JbnJJbRPDvgkS7tIy8KEoKy5sPm3i3Hj17BWTEoLpWz8xPzilKSN+noWv4 z7v6TQDiJt643LCeX0JcJjw8gkajJSUlYf8KCwubmX0m7qVLlyIWvv7gaSwtLYoKxyaTkppDTs6M S8lCJi4lGxkij0JcZfwkCuHZ5jARP0GATHZJBSTuGRA2cOCnm7RwJ0JiYY4TYxLSCDKC7UfMTt1X ChSRkPmNVcQ9Z86cJT0D8YCSa+ZMgnjZytW5ZUeZXeqMzM7H0NINTK1Yzp6Shvb+yjNED3uono3q 6zaxcOl/CowYMYKdnX3o0KGzuRdKiMu6urhB3MnJydjj4uLi0tLSM2fOIiiVlZVfvnyZX348IAKm MC4klhpKotHT2IQwciLyyNCRRAuKpoCGIPtQyKBh4gdievWE9MIDj151yKtqdu6Vsra+V3CEb1gM mIAb0daHiiQaKSmr5sZ9Swe37sOBe/nlm/MpeSXgs3ELH0EvIilTUHEiOIZK9OczjIW/Rw2KpvpH kPi2C7KcPUdPfwi0p+ooD4yKC4qO+2PipG8qtL8PsN0cHBxsbGzjxk4QF5PX1NROSkpOSUnJycnB 1ElISGhp6QwcODAyMvJ5R0cIKcnZJ8TFL8w9MNIjKMo9MAKpR3AUM49yXAWNo1ego1eQk3cwfoLg EyUTGcREmlV2rLTy3IrV65m9mjad09bN197D38Ez0NE7yMkn2NmX3q6bf7hbQAS4pRXS1YK/vz92 K+gxBH5+/n379r3r6IiiZYKAyRz0rv5hrv7hLn6h6A8YahlZMB8BaJtYBkRTUQ7+LNAnxMk7yMU3 lGnoOwOMjk9orKtfGNG97ohycLZ0ZLEsfyJMmTJlwYIFw4YNExQQl5aSRSyWwQBPT8+NGzcuXLjw xIkTpdXXbT0CLZy9rd38kLFxDwAi0zmP1NLZx9zRy8zR08TO3dTewwzo6GXt5k9cJeiZSFQE2nkH F5+8FBBDmzDp0wmEhctWGNq4mNi5mdq7mzmAjycQzM2dvMzpPP1iUwtedNq2yFOyyxx9QgnOIABa ufpZufhauvhYOHmZ2HsY27nJa+qP+HieCp4qLlk6e3du4jN08DB3wFg8WEbcM2fPcwmIMnXwMO2p LlJ7z13i/1vn68aOHUu8zbdwwQppKQVLC6vMzEyodGdnZ14+vpvNzUHUfbqWrrqWLvrW7oa2Xvo2 HgZAW086MvL0Qmt3HQsXLTMnLVNHNSNbZT2LWfMWrdm0VcvUSc/KhSAjKJn4obqtJ+qauwTlnbiu ZmgzaPCHO41cXFwzZs1V0DZRNbRWN7bTNLXXMnXQJNDEQcvMEf0hGBJMiIyelRvKdcyddSyctc2d NE0dNUzswVbNwEZO02TRsjWdBTdxyp8Yl6aJPR2ZzDuhhomDupHdTnE5lvO2lmebjqWzxpeq22sY 281bvOJHSLHXMGrUqLlz565evXrixMnSkspyckohISG6urpWbm6H6t4auYQo6Fkr6NsoGzkoGzso GdkjVTF2REovYRQqGtjK61nL6Vru1TKX0TDdLas5fiJ9n/YfMEBIWlVO1woEnesykShEBqmhc1Bs YRXfbmlUFBeX3LZtG5yKYcN/X76eT0RBW0LFUFLNWFrdRFrDRFrTVEbTTFbbAr1SMrQjkN4HXStZ dEDTVErdRFLNSELFQExJT0JZn3en5HTueX379e8y8NkLV0ipGYmrGEj0iPrgM3/5WpbzxrdLSkLV 8IvVDfZqmo0a+8f3luDXApzzDRs2QKWvXbOFf6vg4iXLfRPzg7NO7dVzEFM1ldCwkNKyktK0ktS0 pGe0rJF+yGtaiaubg0ZUxVhY0WC3vN4GAbEhQz+ddBo7YYqIspGYiomkhuWnWnQOTPxQiNTANcI+ PGvWopUCAgJSUlKWlpYaGhrLly8fMHDQNK65C1ZsWrddbJu4ipCMpqCMppCM1i5Znd1yersV9JDu 3Kuzc682cUlASmM13y7uRSsnTJnWf+BAZme66OTxk/6cxjVvGtecnnEuO/f8oSNGspw0Nq45bDPo 2FN1dq65HNwLvpPI/gmMHz+eeAN39Kgx07iXxJRftwxOFVU3E1YxEVUzF9e0/IhWSMU06Ii8mLqF iKrpHmVjYWWjnfL6QvK6C1dt6R6fzl2+YY+SkaiaGVGRUZcFimlYgKd1eJaGXeD4yWySkpLUeCqF QtHR0VmxYuV0dq5+fT8Ea4OHDBs5Zvwkdi5itpk4ZTo3ykeO6bqb+jDgR8zj/x+YNm3a/Pnzt4pI ZZx/ruMaKaZuLq5hIYndp2MjpWPLQJuPSP+JSyCAEEVVTYWVjXcq6HFwz2fJGW4wn5gyGEpoWn2s bvM52jJ5yho6+aQcxULatUckLi4uKSlJSUlJVFhCUEBk7tx5gHHjxvXmSWJvRIyIYxgDhn8Else0 etlWd+hCpqamto8Bzm5uP/1hKAJwJ3//shuvDFyCFY0clU2dVcxckSqZOCHtjChRNHZUMLSTN7CV 1bOW0bbYI689dsKXQstxEyfL6tnIG9ihYhdundkSjRq5hVPLLwvJqOro6mpqaiopqioraW/cwAfv YtasWV3OhPQ0t72BrKys5m5w586dvLy8TR9PPnxDoCQmnr18+cKVKwUlJd9D22zevBmxs4KCAuzy lykRix06dKj04gNr7whTlwBjR19DO7rnrG/rYYCMnZfhRzQgym089WzctS1cNM2chGVUhg4b/mX+ gDWbt+pauxnYMlz6Tgw/Y2vrgbyJS0BoavG+Uzc38gutWrlaUVFDRloN8w9xT548uctrKX8boHMO Hz36sKXpYXNTc+tTYNPTJw9amhsaHxKRnZeX1zdpiIBJkybdbrhXf/fO7du3TU1NvyFnAqCpwBnd fvys1czM7AuUWAwNDQ0Ha255hsUhkHT0DbP3DrH1DLLzDLbzCka+C6IQlxBNW7r6bhUS7tu366lF ltC3Xz81A4ueeH7g7Enn7OAd6hFKrrz6IP/IuVlzF2zjF9nCwyskJITwocsnX/4JIPxsbGx88+5t S0vLhQsXKisrT548eevWrdbW1hev6IchMScwHN+qOVgKfn5+Pj4+pF/1YZNeAmwxcQ783bt3cLl7 IhOR3JucXxZBTQmOTQiMoviFx/qERnuHRHmHRvv0gLjkGRTpGhC6bOVXvLYPmMo2zSMowis0qifO zKbRjeBYWkxSVgiZNnrMWGxt+OcIH77haW34pR2MVx5qa2u5ubnBefTo0VOnTvXz80Nhe3v706dP t27dCkosMxT6+/sTu1JQUDAnJ0dfX5/Jqn///liNJBIJGvLgwYMgXrhwYZfmwMSJAYqKil0uwWWC JikrKzt8+HBMTExPnxCEZjMyMsrOzj5x4kR+fr6NjQ3zQ/FaWlooIZTS69evw8PD0VtRUdHO1QcP GaJnYk5JSY+MTwgjUYLpz4Kj/MIiCfQP7xEDIqJdvHw4ODnRMfT/q8yc4B7hL3AGMlsPioyJiKPG p2W6+fhhQrB6v+1JTmtr6w7Gqz2QUWdLinXV1taGnYJdT4jb3NycmEloAMSGHYzPtzLfRYVuRPmH s+UfX2fAgjExMencHPGWCtiWlJQwC+EW+vr6Mj4M206kHYwXK1RVPztHhOWkrq5OvJrUzgCilbNn zyKeAsG1a9c6d4B4NcPe3r7LkAcPHswxnZODYzo7/UEwxzR2BnJ8RHZ24tHwpxIGzpg5c+XKlQiU bG1tIyMjU1NTDxw40J05S0DPiYa6s+2O6BUH54yFixdzTJ/+DdU4AaWlpfRbry9eYMJ/6xSS79ix g9gjdXV1MLgogedGTCZd+b95g2lHhvj+j6GhIUGMEmgJWE8sEuJ1Ksw8sVoIoNFoKISl8PHxIUqw N2E+IJpHjx7dvHmT+JYgWBFkbGxszLqZmZkofP78+b1799AKnMmmpiYQ379/X1xcHD42PEzi+7So jkvoRn19PbRQL6cCHKA6oJFWrVo1k4ubj1dQSFBYSGiXkpIyNgU6TKVSy8vLoVUQVkC9IIUygR47 frwSfQPN2rWf3YnC2sCsYshhYWHQSPAepaWlJSQk4HhbWVrZ2dk5ODjAwWAcqNjCs5lvyxaBOXMW YlPPnj0blu4b2lACwPBmbW07QyjCwsLM8okTJxYXF9ffuXOrrq6oiH7MFZ7hxStXHjQ2NrW0NDY1 1THKyWQyLkGBM953aMD8R0VFrVu3Dh3W09Orq6+/09DwqLk5NzeXWEUIu6prapofP8ZiwNiJttzc 3VH93oMH2O/YpIgBoSdv373b8uTJ85cvEX7+xliE1ra2RCtXr17FFMEur1ixIiQkpKamhng/ceTI kVJSUrX19U9aWxsePPDw8ICgMaiv+k8QLGx0HksdWmvbtu1aGqZ2Ni52tk5ubh6QLHwbDPzhw4dY 6tev34DRwdCwCwoKCgoLCzFjpQwoY8D+/fuRohCrIiUlBXMVHR2dlpYGAlQ8fvw4lENUVLSFuYWe rqGerrGOlikfrwAvLy+MxYwZM77Hd86XLl1aWVV1ta4O4g4ICMA0QktDZBDH/sOHczCMsrJVjA8K LV2+/Njp04cqKyuOHcsvKUEh8TQNejg1K6usogKoqfPZESx9I6PDlZVHTpw4eOwYYYBmzZlz9NSp 49XVldXVXIx3gZevXEm3DtXVaKjz65bW9vYnz549WVNjaWuLn9M5OesaGkrLy9GrVZ0+cIQ+/Nlp +0+cNAnM0c+jJ09y/d13jeEaYVqgLuCWYDNqqBuFBsWFBMdERsZkZmZdv3Ydzgzdj33xAjoEcq+t rTt16hR2PdYDIXdsBOLDpwBCG2CdQB1BC2GpQO1gX6A8NDTMxcXNxcnDxcnXxNhRcMcuERERLHVE 2YQ6/eawYTNPacXRtJy84oojtQ1N7zo6Lt6sz8grpKakx8TTIkiULfwfvvOzR1y8vPJUajb9CDQP 3yflvGETz9krN5Myc2MoiSMZDiQz/F+zbn1WQXH6voKk9CziEv+OHZU151ESFk0ayLiNY2JpffLs xSNVNZgQuHbYrcSR70Mnq1Nz8lKz81U16a+aSsnIV569kJyZ4/wxKmR5k2ELH//pC1cz84vjaMlf OF74lwAHadGiRQICAtC68BZkpOUd7HyjIhJiouLJpPiy0v31dfXwdl4zvlr7nv5vE22ELwFXATsF NgUpxErQvGQAMjBDMFhVVVVxcRQ/X38f70Bfn1BPtzBlJW1xcQlo/o0bN34/WQOEJaRzSstDYylB MeSgaHJAVGxgRKxfWJR3ULiGniFbp+/8qGjqxCalhZLitQ0/c7209I1y9leQk9OVNLW6MBfcI0JK SguJjbN2/vCkW1PfOCEzN5KapKrJOH7cp4+jp28UNTkqITkmMQ3lEfQzq4nhZARHJHQD6ap19Kf/ Dh4+tKw8ckrGNsGdXxiOqo5eYk5+dEKyfrfDZl8LiE0QRGD+ZWVlDQwMYFMU5FV8vKJIMcmx0dR4 Ci0zA6HByfr625BjT68AEx+vfvXqFaR//vx57PuYmNiQ4LDAgLDgwKjAAJKutrmEhKS8vDz2NYwg FxfXd/2vCitn9+iE1FBygrmDi/heBQlZBVEp2S38At2PMVg5ucUkpkdQkjZs/uyUppmdEzhkFh/U NPzsnsmAAQPSi/aHxdHCKTTebQIo6de/v3tAKCUtB3x4ttKVxoCBA72CI6JpaZS0bEV1rd2iErvE JIUlZHaJSGwVEMJq2SkiPuL3kWDlFx4dl5qdkJW3Y9eensaCze7s7U9KyaSk5wjs7JHsqwDzjwiF n59fRUUFQpeTk9PU0A/yJ8fFpsWRkhOoqbSElIyM7MOHj545U1N7qxaWHYoaniRcxBs3bly6dPnI kSP5eQVkEiU6KjYiIjYiPC4ynBoZRjM3dRITEyc+pQsFDmXCycn5zf3wzgAFS0rOIKdkxiSlL1/N +uEmAcOHj4iippBTs8gpWfMXLu58SdfEHBvzYv3Dx8+eYWaIQgTviFOo6fuiaSkBUaRBg+in6EeP GQsOybmFkNrsefTHCn379fMMDEXh4ZpL6z9/M6VzsIwoxt0/mJSU8eh1x4HKk0wdDhfa09OTeSBn 6LBhobHUrOKDNTfuYFfSS4YO/eefjIApnzNnDnx1OIQaGhpwsJWVlZWUVMxNrYMDomnUnIT4zMSE DFpCWgI1BdJPpGENYCUkUeOT4uJoZFICmUQjxSTGkVIjwxPtbD3UVLTgUmLlwEXfsmXLkiVLoMC/ xx2nLjBn/sLwuBSvYKjuyD8Yt/p7uus+c/bc4Oh4b1AGR4374zNts2jJcveAcO+Q6FcdHTBM8Pdg ghFPBccmeAVHOnr4oxWCkp2DM4qaDj7+4WTmoTUlDV3PwIhD1Vdh11xdXRFoI5y5dOkSqu8Wlezz UVg7dgl7BkUERFGgIeHTOjs7IyaC3YyhZShr6vXvT/9i5Nhxf3iFRIfE0l4yvhThF07SMbHs5a3O vwRY83nz5q1ZswbePhQ7Ak/IXU1NTU5O3szEwsneNSggMoGSkULLSUnKSUygI1ZCUkJOaDDZ083f 2tJeXVVTRkYGSwWKAn4gHx8fdgcCrh/2FyS823eaOrgbWTsraxl/+VHFRt7toDS2cVHSNup+dY+k nIGVo5m9u7VbgL03/favpZO3iZ2rlrEVG8enQ+mr1m8OoaRbOvtomVgTL60DJkycjJ+GVs5m9p5W rr7Wrn7mTl5GNi5GNq7bdokyezVs+Ah1Q0tDGxdzR0/G7eUQO48gC2cfS1c/sb1KBLffR442sXND XWM7dzMnT7AS2PMNjmR3Bg4ODoRpCAA3bNgAucPm6urqQvTw4eHUKSoqyjJAU0MTYSaEiy2MtaHO APoDTVFRSBlxFnY0NEbnWwo/ADZu271LSmmntMry9axfmmDCer6doNwlo7p8HQvKQUOGLl65YaeU soymiZyWuZyOhaC44tI1m4cOH9GZbKeUirKRvYKe1eYdIp3Lx0+cumHrTjEFbSlVQxl1YzFFnc0C wuxcXb8WNWb8hHW8gqKKOnsZrUipG28RFJsx59Nd8T59+i5fzyMspympaiCpqr9DXGH8hO/1Z3yw s9jsy5Ytw37n4eGBnseGhfSxc6HwiW9eQfqQOES8fft2GBeYAxhoSBlr5qe88tz7h499emEB+/br P2LU2NHjJw4bMarLpT+msG8VV7GJyNqjZLxbyfjPGSw+/DV4yLBR4yaMGvvHwEFfegI+cPCQ0Qyy QUNYx1moPvz30YP/QRT2VcDOzs7NzY0tjw2LXQ+ZrvwI+Al1vXjxYiyMmTNndvmO00+B3j8i/zJl 90vMEsy/lLalkUeUlJalmLqJgKRq/wEDv1y9913qDdmPh8mTJ3+/2Pl/HMb9MdHEyUfPxk3bwlFB y3jSr489/qthzLjxu8QkBHeLbOTh+194/fMX/Bfg/wDVyuZhDQplbmRzdHJlYW0NCmVuZG9iag0K OTIgMCBvYmoNCjw8L1R5cGUvWE9iamVjdC9TdWJ0eXBlL0ltYWdlL1dpZHRoIDE2NS9IZWlnaHQg NjcvQ29sb3JTcGFjZS9EZXZpY2VHcmF5L01hdHRlWyAwIDAgMF0gL0JpdHNQZXJDb21wb25lbnQg OC9JbnRlcnBvbGF0ZSBmYWxzZS9GaWx0ZXIvRmxhdGVEZWNvZGUvTGVuZ3RoIDM4MTQ+Pg0Kc3Ry ZWFtDQp4nMVaaVhTVxrORlYggZBAWBJC2AnIEiCAgKCyJ4AKWKjFBRRFXOqCKCrbqKh1F53i0pkK HcfRap1agWpbatW2KOoDIiBQFARErIiAQJY5FxK52ViepwPvD57cs9zznu985zvv+S4IxDgw51jZ WFmwjMdrNz0wMLZ08Z0bEhYeIYgIDw2Z4+PINqJONykF6DGsPGaHCyAI12/e9LEQ+hUW4Mqmk6eb mhwUIzt/wHBeztcPWqUj6Gm4eSxJKAjx4tB0p5veMOhWfhGCBfvvi6RKePHvZGGoh7nB9NPUZ/PD BDHnepUZjqAiTRjsZqZHnF6ONLu5gqgTXeopAoh/SBLOtqGSppGirrFLWGRei0aKEAauLAxxoE0f SzLTJyL60pgUITxLDZthqD1NHHXN/YXx98flCPZ6lsDdaHpY6jD9hamtCmwkoqH+dz09fUNDIgm8 XHQqyp0+HStOMpkpTO+BM+ltr/rh4tnD+w4Uni+p+KOrXwyrvBrlajANe5zmLkjthlFsqyjOSgwP 8PF09/D2mxuz9viN+i6YOYsiHfTwU82RbBOW2P6Bgrj99uHEAFc7C1MaVGnKtpnBj955vfb1KMvj IRxd3NRyJDEDF1R8INB3//SqYD6XoqOFHG1i4xGdV1bz4Rx6vy3CxkgPgEImoqeGJJUX9eUHjr1P bxSdKsjP373NnYKCTcTGa8XFx4PyVm+vnDq0Pz8/P2/DHBJS85v/OpDYISn9aoLN3Zna8PGtgg6+ Vm30LBo+lf8fqO4LKtVwlErOOWI/NEIS7XPfqLZp2OyiMxUkiaygLHUcpdL+LWZyh0ORvYoGVBqI a/LmmuCnYrkpTjHV6klKX8zTH2GAoof9qlo9VJEXZqEzFRsHzwjYLg+BPco07s4kApZIrHlysxpD l26aaUKYEo8kWUX9KBu1/SdlrxOfstVCIElO+W9VOUrK13sYYqdkayN0uUtkBpSczCpW1ru9a4wx er6XhtQ5w41gBh6JwlMMmWw2k66NGZcvhkih6FGImMmT1Ocfkg36bGVQ0hVlOn9E285/oI6iVFof 6eQ2S7h6T+HVa9e+ObZj/mwemyxzUCTOxM1/lq+nmwuAsx2DgETrcrwFm3eB+Lslks+aZGzFM8Ju ygbdG8DipdyRKFH5/XCbeo7SwTNXqzthwqO7rmSDrykOGh9tvK3jZWfn02oIVZX5bIZ7SlmLLDyI nn8dboIdlxkMBLOFMoU2FGNNprhl1CpRkajGeeV5wNB23JsKthLO4xd46Q8Ju2sUrnavMzlak7Ek c6lshRt8aESMgV/+S80UZLOpFo9RW/MRA43QiX4BL/v9kXKP3lWGkwgLBE6mrF+hNQmHxBqH/v3d 2BzflezvHqv+5cd0ND1VIfL3qbaq9pmEiiLanpR1m0/XQiOQePPYS4Oq7xzFiy/S0l7BnkUd936+ 3wG31BN/bcujY84TYCCRMmGOKAL3gqyb73BcRpFsl5drXk7Ro70xwmKYUw6U709NXH0M7smSLBb/ pnJHsbIj55hOeIej8DO+lb3aEzHcC0122VSjiWN/WXqgezp89X7b4GdrYS84C98X//UQNCh0k3RV 3PilXaFIesRiwk6JxDp/L7ORu6wThuqzq0M9x66iZB47HE6g79LaqKDZwZ/8A06yPHS5gteKn5xI S1j5paKv7+FMfOdgHGQkxXy5EseaxF1VVTygRf2RBbZU6yPwhRO9fd0J0KVwbN6Oy1FY3Oe7Q+3N ndcrXEYHtzAnHtBRNvLl9sXJpoaz3qAQQOSvvbMzyFybOKtOTZ0iflp2UWFyX4Ya49EG8Qoa5dUK xsR9Emkh3zihpOEzDUl0yFWjwKWSiq0+DDyKnDBm/BnGt2sfwR+7063AMaT3sUIAfhSlP2FDonEM eQhaoYdBQerW+yv1Iag1xRyMRVs7xnkjm86RdIVN8vQjOhKBNEp7Dy887zXx/AJGm5Iu63bJFIdG YAwFFVINKPXEI5Bm2fCi/ue1j5Vx7+sVOxRc+jt/HTB561PwssEcm0mci3p0oexY7OBqa+E4qZrT akOfWWKQ5vnwovbCjWlpaWvWbdySIceWVVHBJ+BtxPu44HDBet+FF75aaTKJY1GPxZPtElEwXd/1 sIYE6jC6lxuimZnwSP9sPc/W1s41cu+pMzKcPr7eebZCKH+zjgmcXTvqObywat7EXRKB0DF3KZd1 3MsLL1VJQyugIVzPZC082vy5yZZsYB1ZAm90nitUCOWNH9HAPqYmKxzgX/tMJuWlzeYflHV8mT1u dPmBbxpfCS+oK0jcWqRgo+4052UKAaAsELikkpsM5dlOSlCa+MTIjwKVe5gKxMe9o86o0TSj6CsO c9kODwCSzxyBS2LcrsNbda02ndQFjspbeEfjkD3Kivdd1uLcMdSkpKNoCZd/Hl70dgMLuCQhuB5e +GTB5L5dURwW7NIQ+sR1l28p33na9z7USHGw7fru+bY0LwVVXh8HuaRONFzeSf/jM8lcsVnIp/VS dRgo35m4VYXSsw9TUJjawJumn4uyE/hMbZLz51XPO2R4UXPUC7gkQjewtO6FvPD5gxSrSbkkAkHj r72izpTdF1fyrX3zXqmpGq5+dPt+zfP29o6O9tbaRyXFh7YkhriZU7AorNnc1Kw8gFyA7SmBppAE J1pFr8/OlSEjkUfVYbm62+lN2DFRrplP1JBo/Tyeq09khJ9Tf0gOle1NSV2TkQXGzM5cvzw22NuR TdeGhJQWMyItY9u2bRnrFoV4udgYESEmWmSWg6ubDE4cqrZtcWNT5UyN6WIkjmpioo+TaxCMcXKD KgdR1V6BpQ4aSeAkqT8mq3KCnSxsnVzAmC4z7C3N6GSCLDuA96p7PwCht/nzAAZRa9haSAyOSJKD iMdQojrBnTFS4ydVLU7Oha82M0au8UiCTboahTvwY8YsU+Kw3uDldKrh2HN2vgkZjSUMj0zAYVCj ukv/k9FQVump3lZIw42gtiaCosmQ5AUgLt50GPZcpI7HaTX503ffbQykj9gaYxj2T9UFF/201ZWm /v0o1t9ARJCIhwPVULopzcqeZWBiZ66NQhKMnbz4dnQsEoEyXXWnruqYlw4Sa2DnyefKckpoMofn 425Jxmh7nJRAXznYBCijF/yzmj3Td31PPI9FH5kTnrNM9RtU5+m5ZhqsgHG9Bji2VNythYL+5Vlr 7t67mnC67gJHmxX2xeO21spcF10kxmpX7R8VSywIeu7ZFS1tVftcdYCa03ZIvdH0srk80dr1Wgf0 kqojTCBN3CrVOtzg6ThhkK+rHYdtyrbiJZxSEcF9mfaaBAIhGNwcB/+1dsU+6DpXuvRX4HtAA1/3 9SkYUb3iH7118HwQS1/HMUxjHwwbSVLiRkAbhJaMrFl3vjw9XsEDFwWbFRduPah+/Liu8cWbfrhN e7+LFAgE4RCiFmX+p16hcrCjbBFbk/infPInsPRmnuOSB9DNYSvwaEi1fLG0/EP/Yjs9KMPxLNYm CfJ3qFq8w5QmaJI3+G6/7Md1PthDBs7CZalAEaZt33u+skVRAg00Xt0uFAiEBbdfKh6Ebx8WLnbT lIRGmuYBl6xZ4zv3ELB/376jw0fWwKuDN6CpNzdCGdDOaKuNQKZXLZz3WCp9X//7C2CBX/zmAHtL /mxo7hVXpufUgyH7W+9n2ANHJdJY1rbDCIjNLn2q7o6oDElb6fZwZx1NSUYMF/rS2/bwt1po6X7f Wgp1ably4DhYwK7L+/dcAgppKHNWESj+djG4Xg09LP57KVB/TcuOg4aN53bln7mwKTwBEn/VR5f7 GELzRmG0sCPg+KReqh5fBw0+/XeSGxMechSB8709Op/GnFTIMVuPJS4BPjh0LcnX/1MgB0X5C8Fe HDyaBtZ8sL25qRWYtTkHuHJvYayXV+AcV2shqBf9M9KWRlB6PcsltqCiQ21Od3TYnurCGC5DA0EI pNHkRd+9HMHyNmhooVMCuJp1ZbvoMxKaQITbuhps3q7MrbB0wb3D4KE5zZqsSzXQpS4A9N9ssiZi VM5NU4e5mWWNb8ZQYv0tN3PCbA3H4IjQX/wn9I337Zv2yrNrfB1XAR9sWGFhtAiUdq5j4Sy2gWWv XbUT/K1LzQXu1dPR0tLa/rKp4OggdK80wFEZumhqMmD8NJ6u9mi38ow7cKu5V4NyG2i7cyjeg6Mh iI8AxdwNtl/7N6eO5K4MdaBbQbvoVgjF4GOgU8SXIn03gXveUGHcMTGUWd0Olrnt+pdF/3301bb4 vPfQB//A2bnfB9GZOwDjynWzDNV+fjGzn5l4oqKjd0iFp6j/ZcXJxd52JmNRBPFiOJTfSJ7j7Wpt SMI7XwFPRW54Stg9yJ9rqoCFRPeSIy6C4uKwVcC84mcP695Jq2J5yVAW5vXDp2LpY1+HY2D83tZq Nw05TBbXf+nBktrOd6JRvSgR9XU+KTm4zJ9rNjZFEMqDnoKosodHI5NwaCR+NtBX/TusMETnPPme FN1P9xGCEDqwyyOiRD5ETTAzsFjuZ00C58PDP6r9Nd7W2I780OX7Llc+6+rpez/wvq/nVXPl5fzl 4V5c5ngUwb0u+I+BwaZFjBFvIs1pGBhsTDBCYYyFRa+gPfm+8/om/xkrwdnTtdKSu/rOO0BT9KZi nZMeZ9mPPeBB3P1oC88upVUslXSfcR/rSsnhesxZuDrrQMHZc1+c+GxnWnwQz55tND5FQGvGmoKT n3qQRyIUcUba8RPr3XWRSJLlvN2Xf3tw66vdi/geW38FbB5E0qnuKSdv3vvtWsEaPyM8ZcbSY99X 3i8r/DTAxGhm5jd3yw7EWIzz7wnmNo6uHnxvPx++uwvXmjnRKwmW5ujn50jDyp+4fn5c6AmtzfKM WrrikwhPDnsJlBQaOMojYam2AR8lJ8XNdjQioLT0rP1jk5IXznFiEIkM96hFMX4c3Yl9tzQeKyaq AQpHNjDQxaJUnlA4irGFpbkRmcDaA+2h8gSmFhJDNGByOGYGJKCXkWgi1YzDYdJIWkgUTs+YZWpA HP8j218NcLph0CgEmrm5vv35t6uddCEGSDQolFOBPSBRaI2H2hQATZuZmp0R56w/sU+M/wNT/jG0 DQplbmRzdHJlYW0NCmVuZG9iag0KOTMgMCBvYmoNCjw8L0Z1bmN0aW9uVHlwZSAwL1NpemVbIDI1 Nl0gL0RlY29kZVsgMCAxIDAgMSAwIDFdIC9SYW5nZVsgMCAxIDAgMSAwIDFdIC9CaXRzUGVyU2Ft cGxlIDgvRG9tYWluWyAwIDFdIC9FbmNvZGVbIDAgMjU1XSAvT3JkZXIgMS9GaWx0ZXIvRmxhdGVE ZWNvZGUvTGVuZ3RoIDQ1Nz4+DQpzdHJlYW0NCnichcKHUtoAAAbg57K1e9s6URFRBJGhgKAQwgoz EPYeYQuIgAytdu9l28fqH+Odd613/e4bmzSOnb+GU3wT//o0d5xLjM9cvIGzxE2umX9rDkmugLwt IO/gvAXv8hes987fX0TbAyHf/nCJ+0iEDny8jNQTMXdC7JxYcT5dRdczlLgmJe6pNfRMS7kzMu8s rvtwTu4TyGnBBj2v8OOCMoCLqoBQxQjVzJI6KNoMirZCy6gJizXhFW0EV3VRlGzH1vQxqT4uNcRl hoRsJ7G+m0S5MbVhSilMaQWRVhIZpTmrIrNqMqe25Dat+S20FTT2gtbOah2szlHUUaVtqqR3lvWu ssFdwR1PdddTNXprRl/dhPQegf6GOdAgA02SaVqYljXYsob2baG2Ldy2Y+TAEelQ0Q4V6zox3nNh 4tCNyb4HUwNveuBLD5HOjOjsyI+5owD3mMkfM4XnQe5JkD0Jsaeh4mkYSy8iWH4ZxQq+imH1dRxr +CaB9bdJ3MN3KWzg+zQ28UMGW/gxi/v8T7k2/3MeD/hfCtjhf2W7l4vdb8XexVLvO/fwcrn/46+V /lll8M/hWXX488q14a/a6D/ro9/1oyv+AajcmCENCmVuZHN0cmVhbQ0KZW5kb2JqDQo5NCAwIG9i ag0KPDwvUGF0dGVyblR5cGUgMi9TaGFkaW5nPDwvQ29sb3JTcGFjZS9EZXZpY2VSR0IvU2hhZGlu Z1R5cGUgMi9Db29yZHNbIDAgNDY4IDcyMCA0NjhdIC9FeHRlbmRbIHRydWUgdHJ1ZV0gL0Z1bmN0 aW9uIDkzIDAgUj4+Pj4NCmVuZG9iag0KOTUgMCBvYmoNCjw8L1R5cGUvUGFnZS9QYXJlbnQgMiAw IFIvUmVzb3VyY2VzPDwvRXh0R1N0YXRlPDwvR1MyNCAyNCAwIFIvR1MyNyAyNyAwIFIvR1MxMyAx MyAwIFI+Pi9YT2JqZWN0PDwvSW1hZ2UyNSAyNSAwIFI+Pi9QYXR0ZXJuPDwvUDk4IDk4IDAgUj4+ L0ZvbnQ8PC9GMyAzMCAwIFIvRjEgMTEgMCBSL0YyIDE0IDAgUj4+L1Byb2NTZXRbL1BERi9UZXh0 L0ltYWdlQi9JbWFnZUMvSW1hZ2VJXSA+Pi9Bbm5vdHNbIDk5IDAgUl0gL01lZGlhQm94WyAwIDAg NzIwIDU0MF0gL0NvbnRlbnRzIDk2IDAgUi9Hcm91cDw8L1R5cGUvR3JvdXAvUy9UcmFuc3BhcmVu Y3kvQ1MvRGV2aWNlUkdCPj4vVGFicy9TL1N0cnVjdFBhcmVudHMgMTc+Pg0KZW5kb2JqDQo5NiAw IG9iag0KPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0xlbmd0aCA1NzI+Pg0Kc3RyZWFtDQp4nH1TXYvi QBB8D+Q/9GNccJye7wHxQd0VDxZ2T2E55B48N0ZhTbwY7/ffjEZNjNmXDMl0V1VXqqH3Bv1+73U0 HQMdDGA4HsHfMKBACaUUGaMaNKMgBYU8DoOPJ0jDoDeZMQHJIQwQkms1pQqpqJWvn8LgPQzg+XUE UKHCG1W37JVW6ZLVcMQHrMg4sRYcGyhNkFqQVhKKwIhSCmG1c8qmu2USMwnjDB4Rs5LYT6BvE6A1 xDAPa7UBju7kwA0SLa9zNLB4wy8mBIpv/eq9LYsizlNYHRyUNXBYpb5dME3YqdORKqq+dU+UxMO5 A3zh4CaZr/0k3hoE5bQIN4WyBC3Md1V+6qd1r8jL10kYLPqU6+HgN8x/hMGzwzzj4j2uYc4OVsVd RL+yTpdHR+iIaLVM/bHepp+whI6M/nxlCXS6LNpnh8JfFRkc4sJfHff+6Rt4tJ2NZlMolnkSF67I F2bu4pEc4hx+KIkronUpqdjEJ5g6wKUDmSRc1jsmbbWCEW7rtV/Hg/t/LQ2MSoJ34G1CGGKj1jvW Vi4NkaYdugzJbO9MveREVnJyxVGC6CqMj65yW0WsQMiTuw8/fT6ijZtYRHGT7pZJ9YCLo7OjzpVc MlcT39DgVSpvDiOUg6REABLTvoq6thGOUxFrRGMrNAMh1SW9580/q5nu9nn2zwfn00VWR9O0iJPc pXNZbJtpvA5oLNGqirmIPrbFpq1eaCTc1Osnp0S5bchfZo3Qs4eToPBu1VAaUfgP6ps1Tw0KZW5k c3RyZWFtDQplbmRvYmoNCjk3IDAgb2JqDQo8PC9GdW5jdGlvblR5cGUgMC9TaXplWyAyNTZdIC9E ZWNvZGVbIDAgMSAwIDEgMCAxXSAvUmFuZ2VbIDAgMSAwIDEgMCAxXSAvQml0c1BlclNhbXBsZSA4 L0RvbWFpblsgMCAxXSAvRW5jb2RlWyAwIDI1NV0gL09yZGVyIDEvRmlsdGVyL0ZsYXRlRGVjb2Rl L0xlbmd0aCA0NTc+Pg0Kc3RyZWFtDQp4nIXCh1LaAAAG4OeytXvbOlERUQSRoYCgEMIKMxD2HmEL iIAMrXbvZdvH6h/jnXetd/3uG5s0jp2/hlN8E//6NHecS4zPXLyBs8RNrpl/aw5JroC8LSDv4LwF 7/IXrPfO319E2wMh3/5wiftIhA58vIzUEzF3QuycWHE+XUXXM5S4JiXuqTX0TEu5MzLvLK77cE7u E8hpwQY9r/DjgjKAi6qAUMUI1cySOijaDIq2QsuoCYs14RVtBFd1UZRsx9b0Mak+LjXEZYaEbCex vptEuTG1YUopTGkFkVYSGaU5qyKzajKntuQ2rfkttBU09oLWzmodrM5R1FGlbaqkd5b1rrLBXcEd T3XXUzV6a0Zf3YT0HoH+hjnQIANNkmlamJY12LKG9m2hti3ctmPkwBHpUNEOFes6Md5zYeLQjcm+ B1MDb3rgSw+Rzozo7MiPuaMA95jJHzOF50HuSZA9CbGnoeJpGEsvIlh+GcUKvoph9XUca/gmgfW3 SdzDdyls4Ps0NvFDBlv4MYv7/E+5Nv9zHg/4XwrY4X9lu5eL3W/F3sVS7zv38HK5/+Ovlf5ZZfDP 4Vl1+PPKteGv2ug/66Pf9aMr/gGo3JghDQplbmRzdHJlYW0NCmVuZG9iag0KOTggMCBvYmoNCjw8 L1BhdHRlcm5UeXBlIDIvU2hhZGluZzw8L0NvbG9yU3BhY2UvRGV2aWNlUkdCL1NoYWRpbmdUeXBl IDIvQ29vcmRzWyAwIDQ2OCA3MjAgNDY4XSAvRXh0ZW5kWyB0cnVlIHRydWVdIC9GdW5jdGlvbiA5 NyAwIFI+Pj4+DQplbmRvYmoNCjk5IDAgb2JqDQo8PC9TdWJ0eXBlL0xpbmsvUmVjdFsgMjY0Ljcg MzI5LjU3IDMxNS4xIDM2Mi40N10gL0JTPDwvVyAwPj4vRiA0L0E8PC9UeXBlL0FjdGlvbi9TL1VS SS9VUkkoaHR0cDovL3d3dy5nbHVzdGVyLm9yZy8yMDEzLzExL2EtZ2x1c3Rlci1ibG9jay1pbnRl cmZhY2UtcGVyZm9ybWFuY2UtYW5kLWNvbmZpZ3VyYXRpb24vKSA+Pi9TdHJ1Y3RQYXJlbnQgMTg+ Pg0KZW5kb2JqDQoxMDAgMCBvYmoNCjw8L1R5cGUvUGFnZS9QYXJlbnQgMiAwIFIvUmVzb3VyY2Vz PDwvRXh0R1N0YXRlPDwvR1MyNCAyNCAwIFIvR1MyNyAyNyAwIFIvR1MxMyAxMyAwIFI+Pi9YT2Jq ZWN0PDwvSW1hZ2UyNSAyNSAwIFI+Pi9QYXR0ZXJuPDwvUDEwMyAxMDMgMCBSPj4vRm9udDw8L0Yz IDMwIDAgUi9GMSAxMSAwIFIvRjIgMTQgMCBSPj4vUHJvY1NldFsvUERGL1RleHQvSW1hZ2VCL0lt YWdlQy9JbWFnZUldID4+L01lZGlhQm94WyAwIDAgNzIwIDU0MF0gL0NvbnRlbnRzIDEwMSAwIFIv R3JvdXA8PC9UeXBlL0dyb3VwL1MvVHJhbnNwYXJlbmN5L0NTL0RldmljZVJHQj4+L1RhYnMvUy9T dHJ1Y3RQYXJlbnRzIDE5Pj4NCmVuZG9iag0KMTAxIDAgb2JqDQo8PC9GaWx0ZXIvRmxhdGVEZWNv ZGUvTGVuZ3RoIDk1Mz4+DQpzdHJlYW0NCnicnVZNb+M2EL0b8H+Yo7SAaX6JFIsgwCbZXaRoALcJ tgV2e5Bs2hFiSa4kZ5t/36FsZyXLdINcZMmYecP35nFImM7g4mJ6d317A/TyEq5uruGf8YgCJZRS xjnVoDmFSFKo7Hj05wcoxqPpl3suYVWPRwxWr9GUKkZlL3z5YTz6fTyCT3fXAJ1S7GepyT43Mkrv q8aCsRNVGRfEGMBqoDRh1EBkIkIZcKKUYjDPcWW3ebKyPIKbEk4V5vvCjoH+yYCZmMTcwRodg2D4 K0DEjOjolccASwz04lIyeVav6SxpGlsVMK8RilEB9bxw+ZJrwttUrKqoOiuf3Fe+ekDEzwKQysPS UXHaMFC4GIk0lCHMwEPeXQB1dPGTif3nl/Ho2wUV+uryb3j4dTz6hJg7XHaMG3PUg3dxvwUfodjm qa0g1EG5DCcigML+cF9LmzTbytYQMho8Js/W/ZlaW0AYBVkeTniwWdvcFo1d/BL2i78yiSiJZL8i dGIHykQDZQh25aQ6ghK+x/TzH2QfNOhkB0pCqII0a8BDg0XYU9FP+ssWvmgjCCrfi/YiGzOILVFh GXz84w51hnAig6L8AXUogu1mg8+yavCJbTFBWpZNVqxcQ1ZbWzeYVvs6wSiRyr+oQSfUmzzKDSOS /V8XTnWgmxnMHl/qbJ6sYYHUsvoJNknLMmuysqhdd5Ji4VT57auz6B08l85/622O/pwnhYtwKnnI H0pGxo2bXcnUOtm2tV2436Z06HVTVtZhtWq6l53PcSTVsHWqt2qfLiK1IXHcL/Kv1yQRwy1xtKSJ LxZ9LI9Wv35Kk/nTmWbHR+C+ZSumBrHf0WTH8ef3E+eKRPE+Path9hUWVfZsK6cqpNY1E+dm6+g4 yArYfeQ17IcOxu3/yopy7UQvVy/fQ58iShAc9L2qZ92s3+RmFmui32PmTmJwn62KbJk5CujM1kV1 k6TZOmteIMs3VfncTs3aKZHMq7Ju35rH1nlpmVQLX6sksu7VOss5fhtn2R6d7yHdyXTjauqbcVIR qfvh+XbdZGm7icvGk8ejyI2sXp7PxVwx54ReLE5Hh3+YkCh8U85LnDG23cmrAnCohMKLeaCJG0Qe nN099hI3nLxrN0T0Us+2yrypVVqT6F2d6iQGs/vrW+9pJBQRphde46HjThwPTc6Ju2F2Es7yZLRH lOHNgJh4eL5rDjJShzvD7orX3nSC290GwnGBc3ui22NS+m2BF0zRw8L9ud20TRyymn7mpxYkGYLI PsiA5X/DmXi2DQplbmRzdHJlYW0NCmVuZG9iag0KMTAyIDAgb2JqDQo8PC9GdW5jdGlvblR5cGUg MC9TaXplWyAyNTZdIC9EZWNvZGVbIDAgMSAwIDEgMCAxXSAvUmFuZ2VbIDAgMSAwIDEgMCAxXSAv Qml0c1BlclNhbXBsZSA4L0RvbWFpblsgMCAxXSAvRW5jb2RlWyAwIDI1NV0gL09yZGVyIDEvRmls dGVyL0ZsYXRlRGVjb2RlL0xlbmd0aCA0NTc+Pg0Kc3RyZWFtDQp4nIXCh1LaAAAG4OeytXvbOlER UQSRoYCgEMIKMxD2HmELiIAMrXbvZdvH6h/jnXetd/3uG5s0jp2/hlN8E//6NHecS4zPXLyBs8RN rpl/aw5JroC8LSDv4LwF7/IXrPfO319E2wMh3/5wiftIhA58vIzUEzF3QuycWHE+XUXXM5S4JiXu qTX0TEu5MzLvLK77cE7uE8hpwQY9r/DjgjKAi6qAUMUI1cySOijaDIq2QsuoCYs14RVtBFd1UZRs x9b0Mak+LjXEZYaEbCexvptEuTG1YUopTGkFkVYSGaU5qyKzajKntuQ2rfkttBU09oLWzmodrM5R 1FGlbaqkd5b1rrLBXcEdT3XXUzV6a0Zf3YT0HoH+hjnQIANNkmlamJY12LKG9m2hti3ctmPkwBHp UNEOFes6Md5zYeLQjcm+B1MDb3rgSw+Rzozo7MiPuaMA95jJHzOF50HuSZA9CbGnoeJpGEsvIlh+ GcUKvoph9XUca/gmgfW3SdzDdyls4Ps0NvFDBlv4MYv7/E+5Nv9zHg/4XwrY4X9lu5eL3W/F3sVS 7zv38HK5/+Ovlf5ZZfDP4Vl1+PPKteGv2ug/66Pf9aMr/gGo3JghDQplbmRzdHJlYW0NCmVuZG9i ag0KMTAzIDAgb2JqDQo8PC9QYXR0ZXJuVHlwZSAyL1NoYWRpbmc8PC9Db2xvclNwYWNlL0Rldmlj ZVJHQi9TaGFkaW5nVHlwZSAyL0Nvb3Jkc1sgMCA0NjggNzIwIDQ2OF0gL0V4dGVuZFsgdHJ1ZSB0 cnVlXSAvRnVuY3Rpb24gMTAyIDAgUj4+Pj4NCmVuZG9iag0KMTA0IDAgb2JqDQo8PC9UeXBlL1Bh Z2UvUGFyZW50IDIgMCBSL1Jlc291cmNlczw8L1hPYmplY3Q8PC9JbWFnZTEwNiAxMDYgMCBSPj4v RXh0R1N0YXRlPDwvR1MyNyAyNyAwIFIvR1MyNCAyNCAwIFIvR1MxMyAxMyAwIFI+Pi9QYXR0ZXJu PDwvUDEwOSAxMDkgMCBSPj4vRm9udDw8L0YzIDMwIDAgUi9GMSAxMSAwIFIvRjIgMTQgMCBSPj4v UHJvY1NldFsvUERGL1RleHQvSW1hZ2VCL0ltYWdlQy9JbWFnZUldID4+L01lZGlhQm94WyAwIDAg NzIwIDU0MF0gL0NvbnRlbnRzIDEwNSAwIFIvR3JvdXA8PC9UeXBlL0dyb3VwL1MvVHJhbnNwYXJl bmN5L0NTL0RldmljZVJHQj4+L1RhYnMvUy9TdHJ1Y3RQYXJlbnRzIDIwPj4NCmVuZG9iag0KMTA1 IDAgb2JqDQo8PC9GaWx0ZXIvRmxhdGVEZWNvZGUvTGVuZ3RoIDc0Nz4+DQpzdHJlYW0NCniclVVN b9pAFLwj8R/ecR2VZb/XlqJIIaQRlVDTQtVD0oNjDFjFdmqbRP33fWsgxTFO05NZs2/mzcy+NQxv 4fx8OL2ajIFdXMBofAW/+j0GjDLGuBDMghUMtGJQxP3e9zPI+j0Oq5c9jBnOVGPT8qzf+9LvwfX0 CuCIgP8lGOxrdWDsnsuXnJ/iEpIGASAbGEs5C0AHmjIOghpjOERpvzecpOEq5szAOIdTzGLPPLyZ CQurci+BBz71hcMNrA+S41OC9Dm1+kVIC0u2bBJKcXWidcemarbhbVhVcZFBVCKUE1FGmatXwlJR lyKrQQFv+af2zKM5In6UgFLmSyfFmcPBYDMKZZiA8gDm6XEDzMnFJZf75U2/d3fOpB1d/ID5p37v GjF3uPw1ri/QD3GMe0dmeRqD1yw97OeaUa2b+8fTS08R8AaKJBmmlHoDQRjET3EGniTPSbV2zyyH dVgsnsOihb5rjKLZJ5uThlq7J5t8nk6/eZqUXQ2i1zJo1hzTtYzX7zJeBJb6e8H/Z+1xJbn8OoXQ 2ZMtAEXg0qAzqsttYQ2V6hXECCsmZVeJFAH1TbOkdlyTRRxt8Ccyc07KKnzY4GufhK6X02AHCUZT dQBLw8QbYJpVmGQ1FiPL3L0pwDPkIYx+YsIL7I9rEuXpYy23Sh6STVL97uDR3KfcNHneDM20Qmsd nkNwwlDt/yu4rqN3XE1mySpLlkkUZpWTui3DnSjnbZI+FvlTnMZZVX6op8En5TZaY1aAy7CVV/eB 4YGi/MAZbqs8DZ29VRLVZkcFYsZhleQ4XZbkS/cnrLZxWe1Cfkqi2M1bVSBxHCNz8I6MucGb8cCa 1CNcK1q49tdYv0myFeRLcJJyx9Vx/qyl5hXceD7qGlcl8apv7n4zeNsIHukMDfx28FaA0uZwRe2+ B/W1SCa7oFAUKhtYN4K7y0uSWZckLqg0x4B3ZPv4mBdowkCTeyLuvVa64lRrCg84E02kltw/Xveo 8A0KZW5kc3RyZWFtDQplbmRvYmoNCjEwNiAwIG9iag0KPDwvVHlwZS9YT2JqZWN0L1N1YnR5cGUv SW1hZ2UvV2lkdGggMTY1L0hlaWdodCA2Ny9Db2xvclNwYWNlL0RldmljZVJHQi9CaXRzUGVyQ29t cG9uZW50IDgvSW50ZXJwb2xhdGUgZmFsc2UvU01hc2sgMTA3IDAgUi9GaWx0ZXIvRmxhdGVEZWNv ZGUvTGVuZ3RoIDk5MTc+Pg0Kc3RyZWFtDQp4nO1dBVxU2fdfu9decxFExO5uEUQRDDqku7u7u7tm GIahWxpUMDFA7BYwUBFQsQP4f2eejgiDi7vG77/r+ZzP/dy579xz49x74r373vz22y/4Bb/gF/wj mDd33sIFi5csXjJ69Oif3Zdf8C2hb9++mzZtsrOzz8jIrK6qfvfu3du37560vLt353HrE+TfouTe vYZDFYeCgoIlJSUnT578s7v8C74aBgwYICQklJ6W/vLlq/fv30Omz5+/uH//weXLV44fO56VmRsT Tc7bV3jq1OmrV64+ePDwxYsX7+gAyvdnz543MzP/Jff/FzBw4EB9Pf2mR81tbe1v3rxtbn589cr1 QxVHsLspFEpISKi7u7utra2ZmZm9vb23t3dkZGQiLTE3N/fYscrr128+fvwUtd6/b2t7356aksbJ yfmzB/QLeoS9e/fevHGr7X3HmzfvILg7d+5evXr1zJkzx44dKywsTElJiYmJ8fPzc3JysrGxcXV1 DQwMjI2NRXlBQUFFRcXp06ex/aEEoAog8fa2jvfv3oeGhk6YMOFnj+wXfAabN/NUVZ15/7797Zt3 z5+9fPz4SUvL4+bm5vv379+8eRNyPMOA0tLSzEz6NoeUkdJotOLi4uPHj58/f766uvrs2bO3bt1q bGx89uwZNHt7ewcB+Ono6Dh48OCfPcpfQAcLM6u3b9pev37b+vTZ45Ynz589hw/W3t4OiwzZnT9/ Yf/+/QEBAXp6erKysrt27eLj41u/fj0PD8+OHTvExMQUFRVNTEzi4+MPHz5cV1f/9OnTV69etbW1 dXSG9o5Tp079+eefP3us/2nAjqNSk5+1vnzy5Nn9+w8fNT56/vw5hPPmzZu7d+9iw2Ivk8nk4OBg bE9DQ0N5efk9e/Zs3bqVn3/b9u0CO3fulJCQUFNTg7hdXFyCgoJAXFZWBoWA3f2ZtNs6IP97dxtW r179swf9H4UpU6Yeqjje0tL68EHjrZu10NvYzhD37du3ob0h6PT09OTkZEgwLDTcytJOTlZRUlJa UkISe1xZWRmbGrZeWnqvjIyckqKqi4tHbCwJ6j07O7uoqAjmvqGhgZA1djrda3/fBmPx6sUbeTmF nz30/xzM4p5dc+ZS48Omutrbly5drq+nK+E7d+5A0IkMgAOWkZERFBiioaED+aqrq2trayOFoOXk 5FCCnY59raWlpa+vj90NVa+goGBkaJqUlAKDXlJSgrSyshLmAKEc1PvLFy9fv4baePv6VZudjePP noD/EEz4Y8LRI6du19+9ePEyTOqVK1ewo6uqqtLS0qKjo+Pi4rBJI8Ij5GTlIFyIdffu3Zs3b4Ye XsmA5QxYsWIF8RPlW7ZsAQ2IIXosCU1NzZycnPz8fKRZWVlw5KA3WlpaGhsfNTe3tLa+eNzyUllR /WdPw38ChgwZmp627/r1W9XVNYieYKAhDnhZiJhgfMPCwiIjoqGlsX/hhkGOEOuiRYtmz549ffr0 qVOnjh8/vjM3lHBwcHBzcy9cuHDZsmWgR11YeSUlJR0dHcgaK4du0EvLmpqa4A/U1dU9uP+QoVUe bt8m9LMm4b8DVlaO1dXnDuw/mJSUlJubiz2YlZllZmZmZWXl4OBgZGgGf1tISGjdunULFizg4uKa MmVK75lD7oTQofCh/MXFxWOi6aE6HDnojYsXL548efLo0WNYYFWna4oLKyZMmPj9RvoL+LZsLyo6 kJ9f6OnpaWpqamxsDJu7lQGIsNasgZDXQW9v3Lhx7dq1UNRLGbBkyRKkffv27U0Tw4YNg9ChE0RF RVVVVVFRRkZGREQESwg/3d3d7e3t7ezsvb19HOyc1FS1lnyEpZ8DSqA3vveE/Ith+PARkeHk8vIK e3uHoNDQK7W1HV8Ddo5f4V+xsbFB6HPnzqVSqV/VCuB6ff21+vq0nJwJE3/t/b8PSgpaRYWlaWnp EDe2MzUx8Xpd7dVbN89duVx9/tzpc2erzp1Fpjteun4NUoCDvXrNmt43x87OfubMGVS8cvNGd55o 6zQDkUcHLt+4js5cr68F8aUb12BcBgwY8P2m4l8PkyZO8fUJKSku8/f3hzHV0NCAUT56/Pj9R48a Ghvr7t69Xlt77datG3V1LBH+NF1wN26MHTu2N83x8/M3Nzejyq3bt8G5CzeiLaS4eruhAX140NR0 v7HxTkNDTU3Ntm3bvvds/OtBZI9MVGRseHiEr69vYGCgq6srLOOsWbNu1tY2tjQ/ffEc2Pz0SdOT xy2tT4GPn7USSPxEOaFpEVv9ZVvw+gjih81NYA62BEOCFbMVtNj68gXK8fPBo0b47YWFhdAJ338y /uUwbux4C3OHjPRMSNnb2xsbXEtLa82aNRMnTsRWetj06HHr05dv37TR722zQPqdsY6Ot+0fboPr 6ur21BD8NKwHguzZyxev378j6jD5MHm+bXv/4s2rViyz58+aW1oQoGEdDh069EdOy78V1q/b4unh GxkZ7ezsDHGHhYYhVuLh4Vm2ZDlMJAzlkydP3nd5qNEzvHnzBm5z91YQm1+/fr33Lllbe/vr168b GxsvX76MaP3HT8u/Evr06aMorx4TQ7a1tXNyckIIbGhoiGhr9+498Jw5OTkRYcXFxT179qyd+czy r+Dq1au///5751YQaoHDV8i6re3FixcNDQ2HDh1atGjRlMlsf06d9rOm6N8EkyZN1dE2iokhOTg4 QpkHBARgX2/atGn7NkHMMyz44MGDR44cWV5ejvnvvcQTExMJ/lgtiOJ7L+gOhpMPfQI3jUKhjBs3 butWfsEdO3l4tnfpOWwNAnA+Pj4E7GoMQGbt2rVz5sz5YbM3Y8YM5j0BZBBd/rCm/x4sXbzK2Mjc zy/A0dERytzNzQ1bG4HYtGnsUL/wtAmLycXFBVUM7dp7ievo6IwfP37//v29FzSYwxY8evSotrbW yMhozJgx6AlD2/ByzZiLYEFKSioiIuLUqVMg+zIr9DYhIQF9+PJ9v2XLlp3qBMnJyRGsQEjo0x3d 0aNH6+nplZWVYU12b/fly5clJSUKCgq9vO/0g0FQQMTGmn4ji9DkmB9sbWlpmUmTJrGxsQ0fPpxJ CYMOQbx9+7aXsoNE4GJ9lawxVw8ePKiqqoKGQYsSEhLwFZFHr86dO9d7Vl0AFmHdunUsh6+trd2b joEMxPPnzyeTyehkbxpFh//XDuPBcO+VUXF2cnNkaHKEYJheiHuHgBA2JhRpF2dYX1//8ePHULZ/ e+Z7AhhrGPc7d+7AdccyGzsWjY+DhrSzs2M5vRABqmDt0R+evnyJpYVefVnzREdHDxkypMsMQAP0 pnv8/PyIH/9SpXSBmzdvjho16seJ869gxIiRigoavj7084Tu7u4w3JsZMG0aB+w14qZBgwZ1qRIV FdXa2tr19BEraO9ob2v/CzIQvH7zGtjCiLbQB6LFaWzTIOuLFy8SZG/evgEN0rf0k+z0o1MwK4TO h99+6dKlGzduQC1A7u10kbcTTb9vew9iVESG4HPs2LEuEr916xbRDQLphyw+4rv379AiURF6vvvo mGy7l6PdDsaaxMT+OHH+FcDj3Suj5ObmAZMNhwqxLWQNpd2vXz/IGlEYMl2qQL0XFBbcbbj3qLmJ wObHLZ2xqaW5EcWMDHGVIMPPzvn7Dx/cuXe3tr7uVl3t1WtXL166KCYmBv79+/dHCiVDbGo0VH/n Nijv3W9AlYePGgmEcAsLCwUEBAhzg03Ey8sLoTAbIrrxoPFhw4P7qA4kxOHn788cy9Q//wQNUYVA 5qCARHUUPn76BCkaRWdu370DVuBJjIVZkUBmu+gq6t6933Dt2rUfKM+/AM7p3HKyKp6eXpA1Im4I HYZSVJQ+7QMHDuzJ2Zg8Zcr+iopzly9Xnz9fc/Hi2UuXuuCZCxdwCUhkkBJkSIkq1efOVVZVHT1x ovzIkdKDB5NTU7lnzfqNYVyQLli4ELJuffXqRFXVierq0zU1RC0CzzJSWnLykI+GhqgFmDN37vkr V4gOfNbouXMnq6tPnTlT39BQdfbspI8vNfBu3fqwuRk0RG+ZyKwOBP0JRlcPHjpUfOAAhUbLyMnB zzPnzxPMCWImMseLilXnzl28ehUO5/eWYy9hFvd8eTkVH29fyNrPzw/mG3tEQUGRuMqcxu6wctWq AxWHyo8cPXTs+OHjld0R5UzsXFh+5BgyBw8fKSrbn1tYlJ2Xb+foNGLECCZnBOzQ6k1Pn5VVHDpw 6HDFUTo9UlREeqTyBLD63IXp06ez7GFeYRFaASWzaSJF9f0Vhw6iw8crN2zaRBBr6+o2tjzFpc69 7YKl5RUFJaXpObk7BIWYnsySpcvQty6jY44RrRN45MTJk1VnJv7PPLmbO2fR3r1KELe/v39QUBAC MYSxamq9OjgkLiVddKCioOxAfun+XmJeSVlecSnS3KKS1MzspPRMUQnJLmz1jIxfdXTkFBSDhl6l uHRfUSlSonp+yf7z125m5xf11KuT5y4UlB5Alc4IVjmFxcgUHSgvKT/Ew8tLEHsHBB09XY3yHrta XJqWsy+KTOGcMYOowlxg1vYOaOhLIy0pAwGa6+4f/iyYM3uR7F4lTw+vYAZgdyPO1dDQ6GV1/7CI 1Ny85Ozc3mNSVg4tMzshPTMkmjRv4aIuDCdPnXrwxGnwTMzIBjHSRKyKrByiIvJp+/Iv3KpvbGw8 zYBTnwNK7rQ8jU9N746U5NS45FRkUnL2bdhEj/IGDBxITc8EQ7Bl2U+UowOU1LRNPFu6j11MSvoL Yye6nZCRFU6O/2ci+pYwc8Y8GWkFdzePsLCw8PBwHx8f+EgqKqp/WRErNj4+vvldByU1g5SU2nsk J6eRktLsXDzGsHpUKrlX7kj1+eiEpNjElJiEZKTMikQJMjG0ZHJyelJ2XnpBcXbx/pzSA0iBGYUl 1PTsKGpiGDk+Ii6hC4bHUUNi4sJI8WC+ZPkKtMXBOQN8YmgpwO79RCFajKYl+4dHsTRqIlLSmUWl LMdI7yq9empUfKKKVo8PjH4YwAcjhsDBPlNGmu6ZI7xCWIoNDl9XXl7+y9U5OTnPnDnzpK2DlJwe SUmMjE/qJUZRk0nJGUgH9fCKkLmdAyU1CzzD4xK6cqYkRlBoSEPJ1OAYcnBMXCgpHmQRDOIwEjWM TEUmJJYSEkPBpc6IQtAHRsYGRMSEkigzZtJvdfJs5S86UsmiIUZb9PL4JPBU1zVg2VV1PYO0ghLW w2d0FYimV65hfXvnRwLCKyK8nTRxqpiojLW1LYlEiouLI5PJggwYOnRYT3V37Njx5MmT01fqSEkZ 0QmpwNjEtF4iKSm9oPxYy/sOZU0dlswjKUmkxHRQxtBYsEVbKA+PowVGknxDI/3CogMiSIGR5IBI sl94NBCZwG4YFEVHUPqGRHoFhYfGJhAuvZqOfl758WhqSve2UMIYVzra4t22g2VXfYIiEzL29dRP pFEJKWDOUon9YEBsS4Srw4f/Liq8V1dHH4KmUqmpqalCQkK7du3i4eFlWdHBwQGha9nxanJKJjVj H4EJmXkfcV+nws7lnzApp/Du07f3Wt+u3bCpC/PBgwcnZhUQDFlyoGXlJWUXKmpoT2PnYOOYPu1r EbXY2dnYPxxoDIgiZxQd+Lz/nw0E0oxPy2afzuJG6NQ/2ZJzi2hZ+SyHSXQ+Li3bNyzqW4rtH8Do 0aNHjhzZ57c+u4Qk5eWUKHGUxMTEtLQ0WVnZPXv2mJiYd6FH8FhYWAhZZxQcoKRkYyqScwoTM/Mx /8gghaTwEykzT1zqjPRLmfm5pYfpa+ZY1aQpUzs3MWz4cLClpGYTdZncmHzS8koyi8p3Cot9g+GP GZOSW5ySW0Tw74JEu7SMvChKCsubD5t4tx49ewVkxKC6Vs/MT84pSkjfp6Fr+M+7+k0A4ibeuNyw nl9CXCY8PIJGoyUlJWH/CgsLm5l9Ju6lS5ciFr7+4GksLS2KCscmk5KaQ07OjEvJQiYuJRsZIo9C XGX8JArh2eYwET9BgEx2SQUk7hkQNnDgp5u0cCdCYmGOE2MS0ggygu1HzE7dVwoUkZD5jVXEPWfO nCU9A/GAkmvmTIJ42crVuWVHmV3qjMzOx9DSDUytWM6ekob2/sozRA97qJ6N6us2sXDpfwqMGDGC nZ196NChs7kXSojLurq4QdzJycnY4+Li4tLS0jNnziIolZWVX758mV9+PCACpjAuJJYaSqLR09iE MHIi8sjQkUQLiqaAhiD7UMigYeIHYnr1hPTCA49edciranbulbK2vldwhG9YDJiAG9HWh4okGikp q+bGfUsHt+7DgXv55ZvzKXkl4LNxCx9BLyIpU1BxIjiGSvTnM4yFv0cNiqb6R5D4tguynD1HT38I tKfqKA+MiguKjvtj4qRvKrS/D7DdHBwcbGxs48ZOEBeT19TUTkpKTklJycnJwdRJSEhoaekMHDgw MjLyeUdHCCnJ2SfExS/MPTDSIyjKPTACqUdwFDOPclwFjaNXoKNXkJN3MH6C4BMlExnERJpVdqy0 8tyK1euZvZo2ndPWzdfew9/BM9DRO8jJJ9jZl96um3+4W0AEuKUV0tWCv78/divoMQR+fv59+/a9 6+iIomWCgMkc9K7+Ya7+4S5+oegPGGoZWTAfAWibWAZEU1EO/izQJ8TJO8jFN5Rp6DsDjI5PaKyr XxjRve6IcnC2dGSxLH8iTJkyZcGCBcOGDRMUEJeWkkUslsEAT0/PjRs3Lly48MSJE6XV1209Ai2c va3d/JCxcQ8AItM5j9TS2cfc0cvM0dPEzt3U3sMM6Ohl7eZPXCXomUhUBNp5BxefvBQQQ5sw6dMJ hIXLVhjauJjYuZnau5s5gI8nEMzNnbzM6Tz9YlMLXnTatshTssscfUIJziAAWrn6Wbn4Wrr4WDh5 mdh7GNu5yWvqj/h4ngqeKi5ZOnt3buIzdPAwd8BYPFhG3DNnz3MJiDJ18DDtqS5Se89d4v9b5+vG jh1LvM23cMEKaSkFSwurzMxMqHRnZ2dePr6bzc1B1H26lq66li761u6Gtl76Nh4GQFtPOjLy9EJr dx0LFy0zJy1TRzUjW2U9i1nzFq3ZtFXL1EnPyoUgIyiZ+KG6rSfqmrsE5Z24rmZoM2jwhzuNXFxc M2bNVdA2UTW0Vje20zS11zJ10CTQxEHLzBH9IRgSTIiMnpUbynXMnXUsnLXNnTRNHTVM7MFWzcBG TtNk0bI1nQU3ccqfGJemiT0dmcw7oYaJg7qR3U5xOZbztpZnm46ls8aXqttrGNvNW7ziR0ix1zBq 1Ki5c+euXr164sTJ0pLKcnJKISEhurq6Vm5uh+reGrmEKOhZK+jbKBs5KBs7KBnZI1UxdkRKL2EU KhrYyutZy+la7tUyl9Ew3S2rOX4ifZ/2HzBASFpVTtcKBJ3rMpEoRAapoXNQbGEV325pVBQXl9y2 bRucimHDf1++nk9EQVtCxVBSzVha3URaw0Ra01RG00xW2wK9UjK0I5DeB10rWXRA01RK3URSzUhC xUBMSU9CWZ93p+R07nl9+/XvMvDZC1dIqRmJqxhI9Ij64DN/+VqW88a3S0pC1fCL1Q32apqNGvvH 95bg1wKc8w0bNkClr12zhX+r4OIly30T84OzTu3VcxBTNZXQsJDSspLStJLUtKRntKyRfshrWomr m4NGVMVYWNFgt7zeBgGxIUM/nXQaO2GKiLKRmIqJpIblp1p0Dkz8UIjUwDXCPjxr1qKVAgICUlJS lpaWGhoay5cvHzBw0DSuuQtWbFq3XWybuIqQjKagjKaQjNYuWZ3dcnq7FfSQ7tyrs3OvNnFJQEpj Nd8u7kUrJ0yZ1n/gQGZnuujk8ZP+nMY1bxrXnJ5xLjv3/KEjRrKcNDauOWwz6NhTdXauuRzcC76T yP4JjB8/nngDd/SoMdO4l8SUX7cMThVVNxNWMRFVMxfXtPyIVkjFNOiIvJi6hYiq6R5lY2Flo53y +kLyugtXbeken85dvmGPkpGomhlRkVGXBYppWICndXiWhl3g+MlskpKS1HgqhULR0dFZsWLldHau fn0/BGuDhwwbOWb8JHYuYraZOGU6N8pHjum6m/ow4EfM4/8fmDZt2vz587eKSGWcf67jGimmbi6u YSGJ3adjI6Vjy0Cbj0j/iUsggBBFVU2FlY13KuhxcM9nyRluMJ+YMhhKaFp9rG7zOdoyecoaOvmk HMVC2rVHJC4uLikpSUlJSVRYQlBAZO7ceYBx48b15klib0SMiGMYA4Z/BJbHtHrZVnfoQqampraP Ac5ubj/9YSgCcCd//7IbrwxcghWNHJVNnVXMXJEqmTgh7YwoUTR2VDC0kzewldWzltG22COvPXbC l0LLcRMny+rZyBvYoWIXbp3ZEo0auYVTyy8Lyajq6OpqamoqKaoqK2lv3MAH72LWrFldzoT0NLe9 gaysrOZucOfOnby8vE0fTz58Q6AkJp69fPnClSsFJSXfQ9ts3rwZsbOCggLs8pcpEYsdOnSo9OID a+8IU5cAY0dfQzu656xv62GAjJ2X4Uc0IMptPPVs3LUtXDTNnIRlVIYOG/5l/oA1m7fqWrsZ2DJc +k4MP2Nr64G8iUtAaGrxvlM3N/ILrVq5WlFRQ0ZaDfMPcU+ePLnLayl/G6BzDh89+rCl6WFzU3Pr U2DT0ycPWpobGh8SkZ2Xl9c3aYiASZMm3W64V3/3zu3bt01NTb8hZwKgqcAZ3X78rNXMzOwLlFgM DQ0NB2tueYbFIZB09A2z9w6x9Qyy8wy28wpGvguiEJcQTVu6+m4VEu7bt+upRZbQt18/NQOLnnh+ 4OxJ5+zgHeoRSq68+iD/yLlZcxds4xfZwsMrJCSE8KHLJ1/+CSD8bGxsfPPubUtLy4ULFyorK0+e PHnr1q3W1tYXr+iHITEnMBzfqjlYCn5+fj4+PqRf9WGTXgJsMXEO/N27d3C5eyITkdybnF8WQU0J jk0IjKL4hcf6hEZ7h0R5h0b79IC45BkU6RoQumzlV7y2D5jKNs0jKMIrNKonzsym0Y3gWFpMUlYI mTZ6zFhsbfjnCB++4Wlt+KUdjFceamtrubm5wXn06NFTp0718/NDYXt7+9OnT7du3QpKLDMU+vv7 E7tSUFAwJydHX1+fyap///5YjSQSCRry4MGDIF64cGGX5sDEiQGKiopdLsFlgiYpKys7fPhwTExM T58QhGYzMjLKzs4+ceJEfn6+jY0N80PxWlpaKCGU0uvXr8PDw9FbUVHRztUHDxmiZ2JOSUmPjE8I I1GC6c+Co/zCIgn0D+8RAyKiXbx8ODg50TH0/6vMnOAe4S9wBjJbD4qMiYijxqdluvn4YUKwer/t SU5ra+sOxqs9kFFnS4p11dbWhp2CXU+I29zcnJhJaADEhh2Mz7cy30WFbkT5h7PlH19nwIIxMTHp 3BzxlgrYlpSUMAvhFvr6+jI+DNtOpB2MFytUVT87R4TlpK6uTrya1M4AopWzZ88ingLBtWvXOneA eDXD3t6+y5AHDx7MMZ2Tg2M6O/1BMMc0dgZyfER2duLR8KcSBs6YOXPlypUIlGxtbSMjI1NTUw8c ONCdOUtAz4mGurPtjugVB+eMhYsXc0yf/g3VOAGlpaX0W68vXmDCf+sUku/YsYPYI3V1dTC4KIHn RkwmXfm/eYNpR4b4/o+hoSFBjBJoCVhPLBLidSrMPLFaCKDRaCiEpfDx8SFKsDdhPiCaR48e3bx5 k/iWIFgRZGxsbMy6mZmZKHz+/Pm9e/fQCpzJpqYmEN+/f19cXBw+NjxM4vu0qI5L6EZ9fT20UC+n AhygOqCRVq1aNZOLm49XUEhQWEhol5KSMjYFOkylUsvLy6FVEFZAvSCFMoEeO368En0Dzdq1n92J wtrArGLIYWFh0EjwHqWlpSUkJOB4W1la2dnZOTg4wMFgHKjYwrOZb8sWgTlzFmJTz549G5buG9pQ AsDwZm1tO0MowsLCzPKJEycWFxfX37lzq66uqIh+zBWe4cUrVx40Nja1tDQ2NdUxyslkMi5BgTPe d2jA/EdFRa1btw4d1tPTq6uvv9PQ8Ki5OTc3l1hFCLuqa2qaHz/GYsDYibbc3N1R/d6DB9jv2KSI AaEnb9+92/LkyfOXLxF+/sZYhNa2tkQrV69exRTBLq9YsSIkJKSmpoZ4P3HkyJFSUlK19fVPWlsb Hjzw8PCAoDGor/pPECxsdB5LHVpr27btWhqmdjYudrZObm4ekCx8Gwz84cOHWOrXr9+A0cHQsAsK CgoKCwsxY6UMKGPA/v37kaIQqyIlJQVzFR0dnZaWBgJUPH78OJRDVFS0hbmFnq6hnq6xjpYpH68A Ly8vjMWMGTO+x3fOly5dWllVdbWuDuIOCAjANEJLQ2QQx/7Dh3MwjLKyVYwPCi1dvvzY6dOHKisr jh3LLylBIfE0DXo4NSurrKICqKnz2REsfSOjw5WVR06cOHjsGGGAZs2Zc/TUqePV1ZXV1VyMd4GX r1xJtw7V1Wio8+uW1vb2J8+ePVlTY2lri5/TOTnrGhpKy8vRq1WdPnCEPvzZaftPnDQJzNHPoydP cv3dd43hGmFaoC7glmAzaqgbhQbFhQTHREbGZGZmXb92Hc4M3Y998QI6BHKvra07deoUdj3WAyF3 bATiw6cAQhtgnUAdQQthqUDtYF+gPDQ0zMXFzcXJw8XJ18TYUXDHLhERESx1RNmEOv3msGEzT2nF 0bScvOKKI7UNTe86Oi7erM/IK6SmpMfE0yJIlC38H77zs0dcvLzyVGo2/Qg0D98n5bxhE8/ZKzeT MnNjKIkjGQ4kM/xfs259VkFx+r6CpPQs4hL/jh2VNedREhZNGsi4jWNiaX3y7MUjVTWYELh22K3E ke9DJ6tTc/JSs/NVNemvmkrJyFeevZCcmeP8MSpkeZNhCx//6QtXM/OL42jJXzhe+JcAB2nRokUC AgLQuvAWZKTlHex8oyISYqLiyaT4stL99XX18HZeM75a+57+bxNthC8BVwE7BTYFKcRK0LxkADIw QzBYVVVVcXEUP19/H+9AX59QT7cwZSVtcXEJaP6NGzd+P1kDhCWkc0rLQ2MpQTHkoGhyQFRsYESs X1iUd1C4hp4hW6fv/Kho6sQmpYWS4rUNP3O9tPSNcvZXkJPTlTS1ujAX3CNCSkoLiY2zdv7wpFtT 3zghMzeSmqSqyTh+3KePo6dvFDU5KiE5JjEN5RH0M6uJ4WQERyR0A+mqdfSn/w4ePrSsPHJKxjbB nV8YjqqOXmJOfnRCsn63w2ZfC4hNEERg/mVlZQ0MDGBTFORVfLyiSDHJsdHUeAotMwOhwcn6+tuQ Y0+vABMfr3716hWkf/78eez7mJjYkOCwwICw4MCowACSrra5hISkvLw89jWMIBcX13f9rworZ/fo hNRQcoK5g4v4XgUJWQVRKdkt/ALdjzFYObnFJKZHUJI2bP7slKaZnRM4ZBYf1DT87J7JgAED0ov2 h8XRwik03m0CKOnXv797QCglLQd8eLbSlcaAgQO9giOiaWmUtGxFda3dohK7xCSFJWR2iUhsFRDC atkpIj7i95Fg5RceHZeanZCVt2PXnp7Ggs3u7O1PSsmkpOcI7OyR7KsA848IhZ+fX0VFBUKXk5PT 1NAP8ifHxabFkZITqKm0hJSMjOzDh4+eOVNTe6sWlh2KGp4kXMQbN25cunT5yJEj+XkFZBIlOio2 IiI2IjwuMpwaGUYzN3USExMnPqULBQ5lwsnJ+c398M4ABUtKziCnZMYkpS9fzfrhJgHDh4+IoqaQ U7PIKVnzFy7ufEnXxBwb82L9w8fPnmFmiEIE74hTqOn7omkpAVGkQYPop+hHjxkLDsm5hZDa7Hn0 xwp9+/XzDAxF4eGaS+s/fzOlc7CMKMbdP5iUlPHodceBypNMHQ4X2tPTk3kgZ+iwYaGx1KzigzU3 7mBX0kuGDv3nn4yAKZ8zZw58dTiEGhoacLCVlZWVlFTMTa2DA6Jp1JyE+MzEhAxaQloCNQXST6Rh DWAlJFHjk+LiaGRSAplEI8UkxpFSI8MT7Ww91FS04FJi5cBF37Jly5IlS6DAv8cdpy4wZ/7C8LgU r2Co7sg/GLf6e7rrPnP23ODoeG9QBkeN++MzbbNoyXL3gHDvkOhXHR0wTPD3YIIRTwXHJngFRzp6 +KMVgpKdgzOKmg4+/uFk5qE1JQ1dz8CIQ9VXYddcXV0RaCOcuXTpEqrvFpXs81FYO3YJewZFBERR oCHh0zo7OyMmgt2MoWUoa+r170//YuTYcX94hUSHxNJeMr4U4RdO0jGx7OWtzr8EWPN58+atWbMG 3j4UOwJPyF1NTU1OTt7MxMLJ3jUoIDKBkpFCy0lJyklMoCNWQlJCTmgw2dPN39rSXl1VU0ZGBksF igJ+IB8fH3YHAq4f9hckvNt3mjq4G1k7K2sZf/lRxUbe7aA0tnFR0jbqfnWPpJyBlaOZvbu1W4C9 N/32r6WTt4mdq5axFRvHp0Ppq9ZvDqGkWzr7aJlYEy+tAyZMnIyfhlbOZvaeVq6+1q5+5k5eRjYu Rjau23aJMns1bPgIdUNLQxsXc0dPxu3lEDuPIAtnH0tXP7G9SgS330eONrFzQ11jO3czJ0+wEtjz DY5kdwYODg6EaQgAN2zYALnD5urq6kL08OHh1CkqKsoyQFNDE2EmhIstjLWhzgD6A01RUUgZcRZ2 NDRG51sKPwA2btu9S0ppp7TK8vWsX5pgwnq+naDcJaO6fB0LykFDhi5euWGnlLKMpomclrmcjoWg uOLSNZuHDh/RmWynlIqykb2CntXmHSKdy8dPnLph604xBW0pVUMZdWMxRZ3NAsLsXF2/FjVm/IR1 vIKiijp7Ga1IqRtvERSbMefTXfE+ffouX88jLKcpqWogqaq/Q1xh/ITv9Wd8sLPY7MuWLcN+5+Hh gZ7HhoX0sXOh8IlvXkH6kDhEvH37dhgXmAMYaEgZa+anvPLc+4ePfXphAfv26z9i1NjR4ycOGzGq y6U/prBvFVexicjao2S8W8n4zxksPvw1eMiwUeMmjBr7x8BBX3oCPnDwkNEMskFDWMdZqD7899GD /0EU9lXAzs7Ozc2NLY8Ni10Pma78CPgJdb148WIsjJkzZ3b5jtNPgd4/Iv8yZfdLzBLMv5S2pZFH lJSWpZi6iYCkav8BA79cvfdd6g3Zj4fJkyd/v9j5fxzG/THRxMlHz8ZN28JRQct40q+PPf6rYcy4 8bvEJAR3i2zk4ftfeP3zF/wX4P8A1crmYQ0KZW5kc3RyZWFtDQplbmRvYmoNCjEwNyAwIG9iag0K PDwvVHlwZS9YT2JqZWN0L1N1YnR5cGUvSW1hZ2UvV2lkdGggMTY1L0hlaWdodCA2Ny9Db2xvclNw YWNlL0RldmljZUdyYXkvTWF0dGVbIDAgMCAwXSAvQml0c1BlckNvbXBvbmVudCA4L0ludGVycG9s YXRlIGZhbHNlL0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGggMzgxND4+DQpzdHJlYW0NCnicxVpp WFNXGs5GViCBkEBYEkLYCcgSIICAoLIngApYqMUFFEVc6oIoKtuoqHUXneLSmQodx9FqnVqBaltq 1bYo6gMiIFAUBESsiIBAljkXErnZWJ6nA+8Pntyz3POe73znO+/5LgjEODDnWNlYWbCMx2s3PTAw tnTxnRsSFh4hiAgPDZnj48g2ok43KQXoMaw8ZocLIAjXb970sRD6FRbgyqaTp5uaHBQjO3/AcF7O 1w9apSPoabh5LEkoCPHi0HSnm94w6FZ+EYIF+++LpEp48e9kYaiHucH009Rn88MEMed6lRmOoCJN GOxmpkecXo40u7mCqBNd6ikCiH9IEs62oZKmkaKusUtYZF6LRooQBq4sDHGgTR9LMtMnIvrSmBQh PEsNm2GoPU0cdc39hfH3x+UI9nqWwN1oeljqMP2Fqa0KbCSiof53PT19Q0MiCbxcdCrKnT4dK04y mSlM74Ez6W2v+uHi2cP7DhSeL6n4o6tfDKu8GuVqMA17nOYuSO2GUWyrKM5KDA/w8XT38PabG7P2 +I36Lpg5iyId9PBTzZFsE5bY/oGCuP324cQAVzsLUxpUacq2mcGP3nm99vUoy+MhHF3c1HIkMQMX VHwg0Hf/9KpgPpeio4UcbWLjEZ1XVvPhHHq/LcLGSA+AQiaip4YklRf15QeOvU9vFJ0qyM/fvc2d goJNxMZrxcXHg/JWb6+cOrQ/Pz8/b8McElLzm/86kNghKf1qgs3dmdrw8a2CDr5WbfQsGj6V/x+o 7gsq1XCUSs45Yj80QhLtc9+otmnY7KIzFSSJrKAsdRyl0v4tZnKHQ5G9igZUGohr8uaa4KdiuSlO MdXqSUpfzNMfYYCih/2qWj1UkRdmoTMVGwfPCNguD4E9yjTuziQClkiseXKzGkOXbpppQpgSjyRZ Rf0oG7X9J2WvE5+y1UIgSU75b1U5SsrXexhip2RrI3S5S2QGlJzMKlbWu71rjDF6vpeG1DnDjWAG HonCUwyZbDaTro0Zly+GSKHoUYiYyZPU5x+SDfpsZVDSFWU6f0Tbzn+gjqJUWh/p5DZLuHpP4dVr 1745tmP+bB6bLHNQJM7EzX+Wr6ebC4CzHYOAROtyvAWbd4H4uyWSz5pkbMUzwm7KBt0bwOKl3JEo Ufn9cJt6jtLBM1erO2HCo7uuZIOvKQ4aH228reNlZ+fTaghVlflshntKWYssPIiefx1ugh2XGQwE s4UyhTYUY02muGXUKlGRqMZ55XnA0Hbcmwq2Es7jF3jpDwm7axSudq8zOVqTsSRzqWyFG3xoRIyB X/5LzRRks6kWj1Fb8xEDjdCJfgEv+/2Rco/eVYaTCAsETqasX6E1CYfEGof+/d3YHN+V7O8eq/7l x3Q0PVUh8veptqr2mYSKItqelHWbT9dCI5B489hLg6rvHMWLL9LSXsGeRR33fr7fAbfUE39ty6Nj zhNgIJEyYY4oAveCrJvvcFxGkWyXl2teTtGjvTHCYphTDpTvT01cfQzuyZIsFv+mckexsiPnmE54 h6PwM76VvdoTMdwLTXbZVKOJY39ZeqB7Onz1ftvgZ2thLzgL3xf/9RA0KHSTdFXc+KVdoUh6xGLC TonEOn8vs5G7rBOG6rOrQz3HrqJkHjscTqDv0tqooNnBn/wDTrI8dLmC14qfnEhLWPmloq/v4Ux8 52AcZCTFfLkSx5rEXVVVPKBF/ZEFtlTrI/CFE7193QnQpXBs3o7LUVjc57tD7c2d1ytcRge3MCce 0FE28uX2xcmmhrPeoBBA5K+9szPIXJs4q05NnSJ+WnZRYXJfhhrj0QbxChrl1QrGxH0SaSHfOKGk 4TMNSXTIVaPApZKKrT4MPIqcMGb8Gca3ax/BH7vTrcAxpPexQgB+FKU/YUOicQx5CFqhh0FB6tb7 K/UhqDXFHIxFWzvGeSObzpF0hU3y9CM6EoE0SnsPLzzvNfH8Akabki7rdskUh0ZgDAUVUg0o9cQj kGbZ8KL+57WPlXHv6xU7FFz6O38dMHnrU/CywRybSZyLenSh7Fjs4Gpr4TipmtNqQ59ZYpDm+fCi 9sKNaWlpa9Zt3JIhx5ZVUcEn4G3E+7jgcMF634UXvlppMoljUY/Fk+0SUTBd3/WwhgTqMLqXG6KZ mfBI/2w9z9bWzjVy76kzMpw+vt55tkIof7OOCZxdO+o5vLBq3sRdEoHQMXcpl3XcywsvVUlDK6Ah XM9kLTza/LnJlmxgHVkCb3SeK1QI5Y0f0cA+piYrHOBf+0wm5aXN5h+UdXyZPW50+YFvGl8JL6gr SNxapGCj7jTnZQoBoCwQuKSSmwzl2U5KUJr4xMiPApV7mArEx72jzqjRNKPoKw5z2Q4PAJLPHIFL Ytyuw1t1rTad1AWOylt4R+OQPcqK913W4twx1KSko2gJl38eXvR2Awu4JCG4Hl74ZMHkvl1RHBbs 0hD6xHWXbynfedr3PtRIcbDt+u75tjQvBVVeHwe5pE40XN5J/+MzyVyxWcin9VJ1GCjfmbhVhdKz D1NQmNrAm6afi7IT+ExtkvPnVc87ZHhRc9QLuCRCN7C07oW88PmDFKtJuSQCQeOvvaLOlN0XV/Kt ffNeqakarn50+37N8/b2jo721tpHJcWHtiSGuJlTsCis2dzUrDyAXIDtKYGmkAQnWkWvz86VISOR R9Vhubrb6U3YMVGumU/UkGj9PJ6rT2SEn1N/SA6V7U1JXZORBcbMzly/PDbY25FN14aElBYzIi1j 27ZtGesWhXi52BgRISZaZJaDq5sMThyqtm1xY1PlTI3pYiSOamKij5NrEIxxcoMqB1HVXoGlDhpJ 4CSpPyarcoKdLGydXMCYLjPsLc3oZIIsO4D3qns/AKG3+fMABlFr2FpIDI5IkoOIx1CiOsGdMVLj J1UtTs6FrzYzRq7xSIJNuhqFO/BjxixT4rDe4OV0quHYc3a+CRmNJQyPTMBhUKO6S/+T0VBW6ane VkjDjaC2JoKiyZDkBSAu3nQY9lykjsdpNfnTd99tDKSP2BpjGPZP1QUX/bTVlab+/SjW30BEkIiH A9VQuinNyp5lYGJnro1CEoydvPh2dCwSgTJddaeu6piXDhJrYOfJ58pySmgyh+fjbknGaHuclEBf OdgEKKMX/LOaPdN3fU88j0UfmROes0z1G1Tn6blmGqyAcb0GOLZU3K2Fgv7lWWvu3ruacLruAkeb FfbF47bWylwXXSTGalftHxVLLAh67tkVLW1V+1x1gJrTdki90fSyuTzR2vVaB/SSqiNMIE3cKtU6 3ODpOGGQr6sdh23KtuIlnFIRwX2Z9poEAiEY3BwH/7V2xT7oOle69Ffge0ADX/f1KRhRveIfvXXw fBBLX8cxTGMfDBtJUuJGQBuEloysWXe+PD1ewQMXBZsVF249qH78uK7xxZt+uE17v4sUCAThEKIW Zf6nXqFysKNsEVuT+Kd88iew9Gae45IH0M1hK/BoSLV8sbT8Q/9iOz0ow/Es1iYJ8neoWrzDlCZo kjf4br/sx3U+2EMGzsJlqUARpm3fe76yRVECDTRe3S4UCIQFt18qHoRvHxYudtOUhEaa5gGXrFnj O/cQsH/fvqPDR9bAq4M3oKk3N0IZ0M5oq41AplctnPdYKn1f//sLYIFf/OYAe0v+bGjuFVem59SD Iftb72fYA0cl0ljWtsMIiM0ufarujqgMSVvp9nBnHU1JRgwX+tLb9vC3Wmjpft9aCnVpuXLgOFjA rsv791wCCmkoc1YRKP52MbheDT0s/nspUH9Ny46Dho3nduWfubApPAESf9VHl/sYQvNGYbSwI+D4 pF6qHl8HDT79d5IbEx5yFIHzvT06n8acVMgxW48lLgE+OHQtydf/UyAHRfkLwV4cPJoG1nywvbmp FZi1OQe4cm9hrJdX4BxXayGoF/0z0pZGUHo9yyW2oKJDbU53dNie6sIYLkMDQQik0eRF370cwfI2 aGihUwK4mnVlu+gzEppAhNu6GmzersytsHTBvcPgoTnNmqxLNdClLgD032yyJmJUzk1Th7mZZY1v xlBi/S03c8JsDcfgiNBf/Cf0jfftm/bKs2t8HVcBH2xYYWG0CJR2rmPhLLaBZa9dtRP8rUvNBe7V 09HS0tr+sqng6CB0rzTAURm6aGoyYPw0nq72aLfyjDtwq7lXg3IbaLtzKN6DoyGIjwDF3A22X/s3 p47krgx1oFtBu+hWCMXgY6BTxJcifTeBe95QYdwxMZRZ3Q6Wue36l0X/ffTVtvi899AH/8DZud8H 0Zk7AOPKdbMM1X5+MbOfmXiioqN3SIWnqP9lxcnF3nYmY1EE8WI4lN9InuPtam1IwjtfAU9FbnhK 2D3In2uqgIVE95IjLoLi4rBVwLziZw/r3kmrYnnJUBbm9cOnYuljX4djYPze1mo3DTlMFtd/6cGS 2s53olG9KBH1dT4pObjMn2s2NkUQyoOegqiyh0cjk3BoJH420Ff9O6wwROc8+Z4U3U/3EYIQOrDL I6JEPkRNMDOwWO5nTQLnw8M/qv013tbYjvzQ5fsuVz7r6ul7P/C+r+dVc+Xl/OXhXlzmeBTBvS74 j4HBpkWMEW8izWkYGGxMMEJhjIVFr6A9+b7z+ib/GSvB2dO10pK7+s47QFP0pmKdkx5n2Y894EHc /WgLzy6lVSyVdJ9xH+tKyeF6zFm4OutAwdlzX5z4bGdafBDPnm00PkVAa8aagpOfepBHIhRxRtrx E+vddZFIkuW83Zd/e3Drq92L+B5bfwVsHkTSqe4pJ2/e++1awRo/IzxlxtJj31feLyv8NMDEaGbm N3fLDsRYjPPvCeY2jq4efG8/H767C9eaOdErCZbm6OfnSMPKn7h+flzoCa3N8oxauuKTCE8OewmU FBo4yiNhqbYBHyUnxc12NCKgtPSs/WOTkhfOcWIQiQz3qEUxfhzdiX23NB4rJqoBCkc2MNDFolSe UDiKsYWluRGZwNoD7aHyBKYWEkM0YHI4ZgYkoJeRaCLVjMNh0khaSBROz5hlakAc/yPbXw1wumHQ KASaubm+/fm3q510IQZINCiUU4E9IFFojYfaFABNm5manRHnrD+xT4z/A1P+MbQNCmVuZHN0cmVh bQ0KZW5kb2JqDQoxMDggMCBvYmoNCjw8L0Z1bmN0aW9uVHlwZSAwL1NpemVbIDI1Nl0gL0RlY29k ZVsgMCAxIDAgMSAwIDFdIC9SYW5nZVsgMCAxIDAgMSAwIDFdIC9CaXRzUGVyU2FtcGxlIDgvRG9t YWluWyAwIDFdIC9FbmNvZGVbIDAgMjU1XSAvT3JkZXIgMS9GaWx0ZXIvRmxhdGVEZWNvZGUvTGVu Z3RoIDQ1Nz4+DQpzdHJlYW0NCnichcKHUtoAAAbg57K1e9s6URFRBJGhgKAQwgozEPYeYQuIgAyt du9l28fqH+Odd613/e4bmzSOnb+GU3wT//o0d5xLjM9cvIGzxE2umX9rDkmugLwtIO/gvAXv8hes 987fX0TbAyHf/nCJ+0iEDny8jNQTMXdC7JxYcT5dRdczlLgmJe6pNfRMS7kzMu8srvtwTu4TyGnB Bj2v8OOCMoCLqoBQxQjVzJI6KNoMirZCy6gJizXhFW0EV3VRlGzH1vQxqT4uNcRlhoRsJ7G+m0S5 MbVhSilMaQWRVhIZpTmrIrNqMqe25Dat+S20FTT2gtbOah2szlHUUaVtqqR3lvWussFdwR1PdddT NXprRl/dhPQegf6GOdAgA02SaVqYljXYsob2baG2Ldy2Y+TAEelQ0Q4V6zox3nNh4tCNyb4HUwNv euBLD5HOjOjsyI+5owD3mMkfM4XnQe5JkD0Jsaeh4mkYSy8iWH4ZxQq+imH1dRxr+CaB9bdJ3MN3 KWzg+zQ28UMGW/gxi/v8T7k2/3MeD/hfCtjhf2W7l4vdb8XexVLvO/fwcrn/46+V/lll8M/hWXX4 88q14a/a6D/ro9/1oyv+AajcmCENCmVuZHN0cmVhbQ0KZW5kb2JqDQoxMDkgMCBvYmoNCjw8L1Bh dHRlcm5UeXBlIDIvU2hhZGluZzw8L0NvbG9yU3BhY2UvRGV2aWNlUkdCL1NoYWRpbmdUeXBlIDIv Q29vcmRzWyAwIDQ2OCA3MjAgNDY4XSAvRXh0ZW5kWyB0cnVlIHRydWVdIC9GdW5jdGlvbiAxMDgg MCBSPj4+Pg0KZW5kb2JqDQoxMTAgMCBvYmoNCjw8L1R5cGUvUGFnZS9QYXJlbnQgMiAwIFIvUmVz b3VyY2VzPDwvWE9iamVjdDw8L0ltYWdlNTEgNTEgMCBSPj4vRXh0R1N0YXRlPDwvR1MyNyAyNyAw IFIvR1MyNCAyNCAwIFIvR1MxMyAxMyAwIFI+Pi9QYXR0ZXJuPDwvUDExMyAxMTMgMCBSPj4vRm9u dDw8L0YzIDMwIDAgUi9GMSAxMSAwIFIvRjIgMTQgMCBSPj4vUHJvY1NldFsvUERGL1RleHQvSW1h Z2VCL0ltYWdlQy9JbWFnZUldID4+L01lZGlhQm94WyAwIDAgNzIwIDU0MF0gL0NvbnRlbnRzIDEx MSAwIFIvR3JvdXA8PC9UeXBlL0dyb3VwL1MvVHJhbnNwYXJlbmN5L0NTL0RldmljZVJHQj4+L1Rh YnMvUy9TdHJ1Y3RQYXJlbnRzIDIxPj4NCmVuZG9iag0KMTExIDAgb2JqDQo8PC9GaWx0ZXIvRmxh dGVEZWNvZGUvTGVuZ3RoIDEwNjg+Pg0Kc3RyZWFtDQp4nJ1X227jNhB9N+B/4KO0WNO8UwSCAI6T plnA2LQ20AWSPigWnVVjS66kJN2/71CWU13MNO2TLXnmzMyZOUMaTW/R2dl0Mb+5ROT8HF1cztGf 4xFBBBNCKGNEI80IkoKgwo5Hv31C2XhE0eObDSGKEtEx2nwaj34Zj9DVYo5QKwD9J8Ck8ZVG6SZW xCk9FYtxbAyCaEhpTIlB0khMKGJYKUXRejceTW928aOVFF3m6FRg1gSeXi+ZRo9lUwE1EY6YgzU6 QpzCJ0c8oljLtzoGWHzAEhOCihOZu2iijja9javKFhlalwBFKUflOnP+gmnMaleIqoh6lz7RRL5Y AeJPHEEpq40rxXFDkYJkBJShDKYGrXbtBIgrFx4h8uHxejy6OyNcX5z/jlZfxqMrwDzg0j5uxIAP 1sa9C2ZJkmaPKLOvKDTB97hIXuPCopDSYL+Nq00eTlhQ7Er3a5WjsBvkiCw0wyTqIn+zmcdaUo51 Lw8fsqRmYHtbhCLI/7DrCuVZ3/FQN4ZenqydK6z1sfZfF6GEyBMBhdcVPlhImsMrEbzEZbX94b6l u32Rv9jkMwpVsIufHF9phWxcptZlgsIo2OTF6UROJkEE5sckfm5T/mKzJC/qVOIsccHt7sEmiU3c q9av0Ip9XlQ+1ppATFMQRBPI3z1KGaayZ/3dpofiPD6aYN7zecihFo894xLzrnkbeiAROZDIoKWN TBjnGPRWY/qF4BuItrcTg6M8cY0un/d7GAUguR6Iky1+Ky4y2HShgL932OOcYdmL7djOknhrfRqj ERai6+TVIxMD27o7n99JSpJaxB2nebz9yyaxzyPS/bq94AY03wO/mn/zWCuYFtFrzuTD+mKEwInS uMEDAW2R4D6In2InqUUKgvtxH4KeeTDb77ep67iE9+siR76UhDYwbl3sfkpvtsAL7+VxbTPrlLus 8gLi7iD6RAarG7df/0XGVEWYHXG+Lma34C/rtVUvCc9MMhCo6frOttvXNJzwIMtgc3lGk0lMo66f f4zpwHbGyHTGaS0aDzvQVRjOjlc9nKV3MCNsmD+lwfJQH14elBnM//fyaHu3T5OyPhdebOEWyXob l2VzuAIrx2WvYCB9tIJWjOqivy9EN5y65+GlP5JYia7tURJOBvVR+FGpGeUybXoIh2ettDSrXKV5 8rw+HFxphmAf+qcIMhEdKP/dgUcEm6hj7MWNFI66pq2bg5dJ0nf6ulyubFn5hlMC9R/Kp6FMCSyP pvFzle9ip8jKMUUlfJbuwHF3DJ+wDXV0tWE2Rbyzr26T5MWT9/hguBv8v92cYC2ok64D9emO+qAP wE00VB/c6oRUx1vd4Rpf32aDm8OFC1oFnEx0rSx3bAFNS1+voTqY5hbgXQAHeH1FgjV7H/D7cFAu O5WaUPCfhHWRBuX+DVrF0XcNCmVuZHN0cmVhbQ0KZW5kb2JqDQoxMTIgMCBvYmoNCjw8L0Z1bmN0 aW9uVHlwZSAwL1NpemVbIDI1Nl0gL0RlY29kZVsgMCAxIDAgMSAwIDFdIC9SYW5nZVsgMCAxIDAg MSAwIDFdIC9CaXRzUGVyU2FtcGxlIDgvRG9tYWluWyAwIDFdIC9FbmNvZGVbIDAgMjU1XSAvT3Jk ZXIgMS9GaWx0ZXIvRmxhdGVEZWNvZGUvTGVuZ3RoIDQ1Nz4+DQpzdHJlYW0NCnichcKHUtoAAAbg 57K1e9s6URFRBJGhgKAQwgozEPYeYQuIgAytdu9l28fqH+Odd613/e4bmzSOnb+GU3wT//o0d5xL jM9cvIGzxE2umX9rDkmugLwtIO/gvAXv8hes987fX0TbAyHf/nCJ+0iEDny8jNQTMXdC7JxYcT5d RdczlLgmJe6pNfRMS7kzMu8srvtwTu4TyGnBBj2v8OOCMoCLqoBQxQjVzJI6KNoMirZCy6gJizXh FW0EV3VRlGzH1vQxqT4uNcRlhoRsJ7G+m0S5MbVhSilMaQWRVhIZpTmrIrNqMqe25Dat+S20FTT2 gtbOah2szlHUUaVtqqR3lvWussFdwR1PdddTNXprRl/dhPQegf6GOdAgA02SaVqYljXYsob2baG2 Ldy2Y+TAEelQ0Q4V6zox3nNh4tCNyb4HUwNveuBLD5HOjOjsyI+5owD3mMkfM4XnQe5JkD0Jsaeh 4mkYSy8iWH4ZxQq+imH1dRxr+CaB9bdJ3MN3KWzg+zQ28UMGW/gxi/v8T7k2/3MeD/hfCtjhf2W7 l4vdb8XexVLvO/fwcrn/46+V/lll8M/hWXX488q14a/a6D/ro9/1oyv+AajcmCENCmVuZHN0cmVh bQ0KZW5kb2JqDQoxMTMgMCBvYmoNCjw8L1BhdHRlcm5UeXBlIDIvU2hhZGluZzw8L0NvbG9yU3Bh Y2UvRGV2aWNlUkdCL1NoYWRpbmdUeXBlIDIvQ29vcmRzWyAwIDQ2OCA3MjAgNDY4XSAvRXh0ZW5k WyB0cnVlIHRydWVdIC9GdW5jdGlvbiAxMTIgMCBSPj4+Pg0KZW5kb2JqDQoxMTQgMCBvYmoNCjw8 L1R5cGUvUGFnZS9QYXJlbnQgMiAwIFIvUmVzb3VyY2VzPDwvWE9iamVjdDw8L0ltYWdlMTE2IDEx NiAwIFI+Pi9FeHRHU3RhdGU8PC9HUzI3IDI3IDAgUi9HUzI0IDI0IDAgUi9HUzEzIDEzIDAgUj4+ L1BhdHRlcm48PC9QMTE5IDExOSAwIFI+Pi9Gb250PDwvRjMgMzAgMCBSL0YxIDExIDAgUi9GNCAx MjAgMCBSL0YyIDE0IDAgUj4+L1Byb2NTZXRbL1BERi9UZXh0L0ltYWdlQi9JbWFnZUMvSW1hZ2VJ XSA+Pi9Bbm5vdHNbIDEyMiAwIFIgMTIzIDAgUiAxMjQgMCBSIDEyNSAwIFIgMTI2IDAgUiAxMjcg MCBSIDEyOCAwIFIgMTI5IDAgUl0gL01lZGlhQm94WyAwIDAgNzIwIDU0MF0gL0NvbnRlbnRzIDEx NSAwIFIvR3JvdXA8PC9UeXBlL0dyb3VwL1MvVHJhbnNwYXJlbmN5L0NTL0RldmljZVJHQj4+L1Rh YnMvUy9TdHJ1Y3RQYXJlbnRzIDIyPj4NCmVuZG9iag0KMTE1IDAgb2JqDQo8PC9GaWx0ZXIvRmxh dGVEZWNvZGUvTGVuZ3RoIDE0MjA+Pg0Kc3RyZWFtDQp4nJ1YS2/bRhC+C9B/2CMV1Kt9kwzSHGIn QYIGSBsBLeD0QImUxYQPlaTd+N93lg95l+RKbi6WtZiZb+f1zazQ+jN69Wr96frDDSKvX6M3N9fo n+WCIIIJIZQx4iOfESQFQVWyXPz5AhXLBUV3JxlCFCXCEtq/WC5+Xy7Q20/XCBkA9AngqteVofJ7 rIBTOofFOA5DBGhI+ZiSEMlQYkIRw0opinb5crH+kEd3CaUK3ZRoDpn1yOv3X5iP7ureBRoGOGDa bugHiFP45IgHFPvy5MjEFp+EiQlBxczVNZpo0dafo6ZJqgLtajBFaYjqXaH1BfMxa1UBVRF1Nn6i R36zAYvvOAJXNnvtig4ORQouI8ANFWIA2OTmBYh2F75S3n99v1zcviLcf/P6b7T5uFy8BZudXTq2 GzCIBzPt3nqbQ4IOK+49HpPqIa3LCq1CbxcVaCW8+2McNQlaUeo1ILZSXp7uqnJXxglKC9SezYFi COQsMFfY93vgJKqyR23zeIjqDqTco21ZNmOjgxVOCJaBbaVJ88QlLgkOlC1ump5kRY6zYjsREswp OEEoFn30dNzFXNxtTah1DKkwNdu4Oy5OJcWE2+IQ+NUV9/rgryjxtmkRVY/6UAdxm5Vb1Iro1Elv m6BkdcW8FJJU6X+0UFSjyAna3ZH50I0DaN1ERRxlZeG8KoOeJtzWyu+zJtV5dOWFhhia1NJxppwB Qyhb9hg9aoeyMop/QSvfg5I9RlWDSqjifVuUaZE2aZRdclVwHAxGv3dRKpJMF/5XLy5z8nWl/79g DLgOh4FtrIpynYk4rb+7tIIQQ0NYWk6EUGA1QvjqOYQFGVnV169il7ScMb1yCaszF540k3pWMzFI Bf+ZXnpSRFcdW2520FSlM+c8bAv1SY20Gk30PTm1R/wQFQ3MH1TqOkrrlgOBmzJgQS1UN7reHpKq TsviQnXRAMhqcsFy79JiLScbWt39pgQrJhHhAktT9daLq0gX4O5+3INzAQ1hWEpL3dnthGNui/4L BOOSFkC8Z+3OOMMkw3QcPC0Dsbi6ciEpQBLT4CWRzhqMGWfvSgsMIJw8xLBglugwCnWgxyNoJswC mNJnzwqzgFrgyhIFgmt9gWEHcM1A6TAzgaFROTuLxwUJU2UYg3+15Vy4FCBxOs2GwrlR5duinytN xN9ahF2jW2hX5nk3mWI3zwMfWmayFKZOfUzamZbuH1+6giUEDtXZy86UmYDdAI5MrXs9WR0gksB6 aUn/Wrf+ReMYzmReKqH3EFMbu3B8MhY9S7L+s0iWwjoMHz/Bsqam907vhu6K0RRkisdJ05ZsmtWo hopIXMFlIsShsJWfxRQS85Ha/+E9TgPsn0d9qk6hecIUzVvfiiNMC1dhUkj7BbdG4Q4CzAdRaBZn sKV+R5nCM0Xy5QiL4FAngVEnZuty04x+A8GSRSAZFFV3o4M/9DvDOzTN8QJWOIcVwv5m+/dyvb5g iJIZSwzCqbhl6UfLicU2bWoMddZ/PVblt448GlwCCVV361gT065e3xew2G6zZJ2n9W79w7jGJARt kODiEp6oIQI45vu6WPuDbLkQBKYvNQ4kh+09MA6UhCvLmQPRPoINldPBYPR0MMCeDoaLnQ4O3Wtz pqpku2rOZhg9bSaJcxpwWPlMK/1wdY1KKqjeZJ7kb80B4OIAWM/g5W0qOYc9cI1QlqieFfjQ5Nk5 rqR0ppw4OGcZI90PIu/HXTWtDB1cCeQOhN1VBoOM8OEAMtLapjMHwFt9VnuV08Fg9HRwcPx0QZnF /OCIgleImPyKABuHgAv0r/3up5LOubf6+Q194ab0duMxtG+9T7DygApsPfA3di4ceuZYer85edXH UH6WLLzq0uJuQt9szkPRbg2W+oQJ/wMkAfSbDQplbmRzdHJlYW0NCmVuZG9iag0KMTE2IDAgb2Jq DQo8PC9UeXBlL1hPYmplY3QvU3VidHlwZS9JbWFnZS9XaWR0aCAxNjUvSGVpZ2h0IDY3L0NvbG9y U3BhY2UvRGV2aWNlUkdCL0JpdHNQZXJDb21wb25lbnQgOC9JbnRlcnBvbGF0ZSBmYWxzZS9TTWFz ayAxMTcgMCBSL0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGggOTkxNz4+DQpzdHJlYW0NCnic7V0F XFTZ91+7115zEUTE7m4RRBEMOqS7u7u7u2YYhqFbGlQwMUDsFjBQEVCxA/h/Z56OCIOLu8bvv+v5 nM/93Lnv3HPj3Hvivfve/PbbL/gFv+AX/COYN3fewgWLlyxeMnr06J/dl1/wLaFv376bNm2ys7PP yMisrqp+9+7d27fvnrS8u3fncesT5N+i5N69hkMVh4KCgiUlJSdPnvyzu/wLvhoGDBggJCSUnpb+ 8uWr9+/fQ6bPn7+4f//B5ctXjh87npWZGxNNzttXeOrU6atXrj548PDFixfv6ADK92fPnjczM/8l 9/8XMHDgQH09/aZHzW1t7W/evG1ufnz1yvVDFUewuykUSkhIqLu7u62trZmZmb29vbe3d2RkZCIt MTc399ixyuvXbz5+/BS13r9va3vfnpqSxsnJ+bMH9At6hL179968cavtfcebN+8guDt37l69evXM mTPHjh0rLCxMSUmJiYnx8/NzcnKysbFxdXUNDAyMjY1FeUFBQUVFxenTp7H9oQSgCiDx9raO9+/e h4aGTpgw4WeP7Bd8Bps381RVnXn/vv3tm3fPn718/PhJS8vj5ubm+/fv37x5E3I8w4DS0tLMTPo2 h5SR0mi04uLi48ePnz9/vrq6+uzZs7du3WpsbHz27Bk0e3t7BwH46ejoOHjw4J89yl9ABwszq7dv 2l6/ftv69NnjlifPnz2HD9be3g6LDNmdP39h//79AQEBenp6srKyu3bt4uPjW79+PQ8Pz44dO8TE xBQVFU1MTOLj4w8fPlxXV//06dNXr161tbV1dIb2jlOnTv35558/e6z/acCOo1KTn7W+fPLk2f37 Dx81Pnr+/DmE8+bNm7t372LDYi+TyeTg4GBsT0NDQ3l5+T179mzdupWff9v27QI7d+6UkJBQU1OD uF1cXIKCgkBcVlYGhYDd/Zm02zog/3t3G1avXv2zB/0fhSlTph6qON7S0vrwQeOtm7XQ29jOEPft 27ehvSHo9PT05ORkSDAsNNzK0k5OVlFSUlpSQhJ7XFlZGZsatl5aeq+MjJySoqqLi0dsLAnqPTs7 u6ioCOa+oaGBkDV2Ot1rf98GY/HqxRt5OYWfPfT/HMzinl1z5lLjw6a62tuXLl2ur6cr4Tt37kDQ iQyAA5aRkREUGKKhoQP5qqura2trI4Wg5eTkUIKdjn2tpaWlr6+P3Q1Vr6CgYGRompSUAoNeUlKC tLKyEuYAoRzU+8sXL1+/htp4+/pVm52N48+egP8QTPhjwtEjp27X37148TJM6pUrV7Cjq6qq0tLS oqOj4+LisEkjwiPkZOUgXIh19+7dmzdvhh5eyYDlDFixYgXxE+VbtmwBDYgheiwJTU3NnJyc/Px8 pFlZWXDkoDdaWloaGx81N7e0tr543PJSWVH9Z0/DfwKGDBmanrbv+vVb1dU1iJ5goCEOeFmImGB8 w8LCIiOioaWxf+GGQY4Q66JFi2bPnj19+vSpU6eOHz++MzeUcHBwcHNzL1y4cNmyZaBHXVh5JSUl HR0dyBorh27QS8uamprgD9TV1T24/5ChVR5u3yb0sybhvwNWVo7V1ecO7D+YlJSUm5uLPZiVmWVm ZmZlZeXg4GBkaAZ/W0hIaN26dQsWLODi4poyZUrvmUPuhNCh8KH8xcXFY6LpoTocOeiNixcvnjx5 8ujRY1hgVadrigsrJkyY+P1G+gv4tmwvKjqQn1/o6elpampqbGwMm7uVAYiw1qyBkNdBb2/cuHHt 2rVQ1EsZsGTJEqR9+/btTRPDhg2D0KETREVFVVVVUVFGRkZERARLCD/d3d3t7e3t7Oy9vX0c7JzU VLWWfISlnwNKoDe+94T8i2H48BGR4eTy8gp7e4eg0NArtbUdXwN2jl/hX7GxsUHoc+fOpVKpX9UK 4Hp9/bX6+rScnAkTf+39vw9KClpFhaVpaekQN7YzNTHxel3t1Vs3z125XH3+3OlzZ6vOnUWmO166 fg1SgIO9es2a3jfHzs5+5swZVLxy80Z3nmjrNAORRwcu37iOzlyvrwXxpRvXYFwGDBjw/abiXw+T Jk7x9QkpKS7z9/eHMdXQ0IBRPnr8+P1HjxoaG+vu3r1eW3vt1q0bdXUsEf40XXA3bowdO7Y3zfHz 8zc3N6PKrdu3wbkLN6ItpLh6u6EBfXjQ1HS/sfFOQ0NNTc22bdu+92z860Fkj0xUZGx4eISvr29g YKCrqyss46xZs27W1ja2ND998RzY/PRJ05PHLa1PgY+ftRJI/EQ5oWkRW/1lW/D6COKHzU1gDrYE Q4IVsxW02PryBcrx88GjRvjthYWF0AnffzL+5TBu7HgLc4eM9ExI2dvbGxtcS0trzZo1EydOxFZ6 2PTocevTl2/ftNHvbbNA+p2xjo637R9ug+vq6vbUEPw0rAeC7NnLF6/fvyPqMPkweb5te//izatW LLPnz5pbWhCgYR0OHTr0R07LvxXWr9vi6eEbGRnt7OwMcYeFhiFW4uHhWbZkOUwkDOWTJ0/ed3mo 0TO8efMGbnP3VhCbX79+vfcuWVt7++vXrxsbGy9fvoxo/cdPy78S+vTpoyivHhNDtrW1c3JyQghs aGiIaGv37j3wnDk5ORFhxcXFPXv2rJ35zPKv4OrVq7///nvnVhBqgcNXyLqt7cWLFw0NDYcOHVq0 aNGUyWx/Tp32s6bo3wSTJk3V0TaKiSE5ODhCmQcEBGBfb9q0afs2QcwzLPjgwYNHjhxZXl6O+e+9 xBMTEwn+WC2I4nsv6A6Gkw99AjeNQqGMGzdu61Z+wR07eXi2d+k5bA0CcD4+PgTsagxAZu3atXPm zPlhszdjxgzmPQFkEF3+sKb/HixdvMrYyNzPL8DR0RHK3M3NDVsbgdi0aexQv/C0CYvJxcUFVQzt 2nuJ6+jojB8/fv/+/b0XNJjDFjx69Ki2ttbIyGjMmDHoCUPb8HLNmItgQUpKKiIi4tSpUyD7Miv0 NiEhAX348n2/ZcuWneoEycnJEaxASOjTHd3Ro0fr6emVlZVhTXZv9+XLlyUlJQoKCr287/SDQVBA xMaafiOL0OSYH2xtaWmZSZMmsbGxDR8+nEkJgw5BvH37tpeyg0TgYn2VrDFXDx48qKqqgoZBixIS EvAVkUevzp0713tWXQAWYd26dSyHr62t3ZuOgQzE8+fPJ5PJ6GRvGkWH/9cO48Fw75VRcXZyc2Ro coRgmF6Ie4eAEDYmFGkXZ1hfX//x48dQtn975nsCGGsY9zt37sB1xzIbOxaNj4OGtLOzYzm9EAGq YO3RH56+fImlhV59WfNER0cPGTKkywxAA/Sme/z8/Igf/1KldIGbN2+OGjXqx4nzr2DEiJGKChq+ PvTzhO7u7jDcmxkwbRoH7DXipkGDBnWpEhUV1dra2vX0ESto72hva/8LMhC8fvMa2MKIttAHosVp bNMg64sXLxJkb96+AQ3St/ST7PSjUzArhM6H337p0qUbN25ALUDu7XSRtxNNv297D2JURIbgc+zY sS4Sv3XrFtENAumHLD7iu/fv0CJREXq+++iYbLuXo90OxprExP44cf4VwOPdK6Pk5uYBkw2HCrEt ZA2l3a9fP8gaURgyXapAvRcUFtxtuPeouYnA5sctnbGppbkRxYwMcZUgw8/O+fsPH9y5d7e2vu5W Xe3Va1cvXrooJiYG/v3790cKJUNsajRUf+c2KO/db0CVh48aCYRwCwsLBQQECHODTcTLywuhMBsi uvGg8WHDg/uoDiTE4efvzxzL1D//BA1RhUDmoIBEdRQ+fvoEKRpFZ27fvQNW4EmMhVmRQGa76Crq 3r3fcO3atR8oz78AzunccrIqnp5ekDUibggdhlJUlD7tAwcO7MnZmDxlyv6KinOXL1efP19z8eLZ S5e64JkLF3AJSGSQEmRIiSrV585VVlUdPXGi/MiR0oMHk1NTuWfN+o1hXJAuWLgQsm599epEVdWJ 6urTNTVELQLPMlJacvKQj4aGqAWYM3fu+StXiA581ui5cyerq0+dOVPf0FB19uykjy818G7d+rC5 GTREb5nIrA4E/QlGVw8eOlR84ACFRsvIycHPM+fPE8wJYiYyx4uKVefOXbx6FQ7n95ZjL2EW93x5 ORUfb1/I2s/PD+Ybe0RBQZG4ypzG7rBy1aoDFYfKjxw9dOz44eOV3RHlTOxcWH7kGDIHDx8pKtuf W1iUnZdv5+g0YsQIJmcE7NDqTU+flVUcOnDocMVROj1SVER6pPIEsPrchenTp7PsYV5hEVoBJbNp IkX1/RWHDqLDxys3bNpEEGvr6ja2PMWlzr3tgqXlFQUlpek5uTsEhZiezJKly9C3LqNjjhGtE3jk xMmTVWcm/s88uZs7Z9HevUoQt7+/f1BQEAIxhLFqar06OCQuJV10oKKg7EB+6f5eYl5JWV5xKdLc opLUzOyk9ExRCckubPWMjF91dOQUFIOGXqW4dF9RKVKien7J/vPXbmbnF/XUq5PnLhSUHkCVzghW OYXFyBQdKC8pP8TDy0sQewcEHT1djfIeu1pcmpazL4pM4Zwxg6jCXGDW9g5o6EsjLSkDAZrr7h/+ LJgze5HsXiVPD69gBmB3I87V0NDoZXX/sIjU3Lzk7NzeY1JWDi0zOyE9MySaNG/hoi4MJ0+devDE afBMzMgGMdJErIqsHKIi8mn78i/cqm9sbDzNgFOfA0rutDyNT03vjpTk1LjkVGRScvZt2ESP8gYM HEhNzwRDsGXZT5SjA5TUtE08W7qPXUxK+gtjJ7qdkJEVTo7/ZyL6ljBzxjwZaQV3N4+wsLDw8HAf Hx/4SCoqqn9ZESs2Pj6++V0HJTWDlJTaeyQnp5GS0uxcPMawelQquVfuSPX56ISk2MSUmIRkpMyK RAkyMbRkcnJ6UnZeekFxdvH+nNIDSIEZhSXU9OwoamIYOT4iLqELhsdRQ2LiwkjxYL5k+Qq0xcE5 A3xiaCnA7v1EIVqMpiX7h0exNGoiUtKZRaUsx0jvKr16alR8oopWjw+MfhjAByOGwME+U0aa7pkj vEJYig0OX1deXv7L1Tk5Oc+cOfOkrYOUnB5JSYyMT+olRlGTSckZSAf18IqQuZ0DJTULPMPjErpy piRGUGhIQ8nU4BhycExcKCkeZBEM4jASNYxMRSYklhISQ8GlzohC0AdGxgZExISSKDNm0m918mzl LzpSyaIhRlv08vgk8FTXNWDZVXU9g7SCEtbDZ3QViKZXrmF9e+dHAsIrIrydNHGqmKiMtbUtiUSK i4sjk8mCDBg6dFhPdXfs2PHkyZPTV+pISRnRCanA2MS0XiIpKb2g/FjL+w5lTR2WzCMpSaTEdFDG 0FiwRVsoD4+jBUaSfEMj/cKiAyJIgZHkgEiyX3g0EJnAbhgURUdQ+oZEegWFh8YmEC69mo5+Xvnx aGpK97ZQwhhXOtri3baDZVd9giITMvb11E+kUQkpYM5Sif1gQGxLhKvDh/8uKrxXV0cfgqZSqamp qUJCQrt27eLh4WVZ0cHBAaFr2fFqckomNWMfgQmZeR9xX6fCzuWfMCmn8O7Tt/da367dsKkL88GD BydmFRAMWXKgZeUlZRcqamhPY+dg45g+7WsRtdjZ2dg/HGgMiCJnFB34vP+fDQTSjE/LZp/O4kbo 1D/ZknOLaFn5LIdJdD4uLds3LOpbiu0fwOjRo0eOHNnntz67hCTl5ZQocZTExMS0tDRZWdk9e/aY mJh3oUfwWFhYCFlnFBygpGRjKpJzChMz8zH/yCCFpPATKTNPXOqM9EuZ+bmlh+lr5ljVpClTOzcx bPhwsKWkZhN1mdyYfNLySjKLyncKi32D4Y8Zk5JbnJJbRPDvgkS7tIy8KEoKy5sPm3i3Hj17BWTE oLpWz8xPzilKSN+noWv4z7v6TQDiJt643LCeX0JcJjw8gkajJSUlYf8KCwubmX0m7qVLlyIWvv7g aSwtLYoKxyaTkppDTs6MS8lCJi4lGxkij0JcZfwkCuHZ5jARP0GATHZJBSTuGRA2cOCnm7RwJ0Ji YY4TYxLSCDKC7UfMTt1XChSRkPmNVcQ9Z86cJT0D8YCSa+ZMgnjZytW5ZUeZXeqMzM7H0NINTK1Y zp6Shvb+yjNED3uono3q6zaxcOl/CowYMYKdnX3o0KGzuRdKiMu6urhB3MnJydjj4uLi0tLSM2fO IiiVlZVfvnyZX348IAKmMC4klhpKotHT2IQwciLyyNCRRAuKpoCGIPtQyKBh4gdievWE9MIDj151 yKtqdu6Vsra+V3CEb1gMmIAb0daHiiQaKSmr5sZ9Swe37sOBe/nlm/MpeSXgs3ELH0EvIilTUHEi OIZK9OczjIW/Rw2KpvpHkPi2C7KcPUdPfwi0p+ooD4yKC4qO+2PipG8qtL8PsN0cHBxsbGzjxk4Q F5PX1NROSkpOSUnJycnB1ElISGhp6QwcODAyMvJ5R0cIKcnZJ8TFL8w9MNIjKMo9MAKpR3AUM49y XAWNo1ego1eQk3cwfoLgEyUTGcREmlV2rLTy3IrV65m9mjad09bN197D38Ez0NE7yMkn2NmX3q6b f7hbQAS4pRXS1YK/vz92K+gxBH5+/n379r3r6IiiZYKAyRz0rv5hrv7hLn6h6A8YahlZMB8BaJtY BkRTUQ7+LNAnxMk7yMU3lGnoOwOMjk9orKtfGNG97ohycLZ0ZLEsfyJMmTJlwYIFw4YNExQQl5aS RSyWwQBPT8+NGzcuXLjwxIkTpdXXbT0CLZy9rd38kLFxDwAi0zmP1NLZx9zRy8zR08TO3dTewwzo 6GXt5k9cJeiZSFQE2nkHF5+8FBBDmzDp0wmEhctWGNq4mNi5mdq7mzmAjycQzM2dvMzpPP1iUwte dNq2yFOyyxx9QgnOIABaufpZufhauvhYOHmZ2HsY27nJa+qP+HieCp4qLlk6e3du4jN08DB3wFg8 WEbcM2fPcwmIMnXwMO2pLlJ7z13i/1vn68aOHUu8zbdwwQppKQVLC6vMzEyodGdnZ14+vpvNzUHU fbqWrrqWLvrW7oa2Xvo2HgZAW086MvL0Qmt3HQsXLTMnLVNHNSNbZT2LWfMWrdm0VcvUSc/KhSAj KJn4obqtJ+qauwTlnbiuZmgzaPCHO41cXFwzZs1V0DZRNbRWN7bTNLXXMnXQJNDEQcvMEf0hGBJM iIyelRvKdcyddSyctc2dNE0dNUzswVbNwEZO02TRsjWdBTdxyp8Yl6aJPR2ZzDuhhomDupHdTnE5 lvO2lmebjqWzxpeq22sY281bvOJHSLHXMGrUqLlz565evXrixMnSkspyckohISG6urpWbm6H6t4a uYQo6Fkr6NsoGzkoGzsoGdkjVTF2REovYRQqGtjK61nL6Vru1TKX0TDdLas5fiJ9n/YfMEBIWlVO 1woEnesykShEBqmhc1BsYRXfbmlUFBeX3LZtG5yKYcN/X76eT0RBW0LFUFLNWFrdRFrDRFrTVEbT TFbbAr1SMrQjkN4HXStZdEDTVErdRFLNSELFQExJT0JZn3en5HTueX379e8y8NkLV0ipGYmrGEj0 iPrgM3/5WpbzxrdLSkLV8IvVDfZqmo0a+8f3luDXApzzDRs2QKWvXbOFf6vg4iXLfRPzg7NO7dVz EFM1ldCwkNKyktK0ktS0pGe0rJF+yGtaiaubg0ZUxVhY0WC3vN4GAbEhQz+ddBo7YYqIspGYiomk huWnWnQOTPxQiNTANcI+PGvWopUCAgJSUlKWlpYaGhrLly8fMHDQNK65C1ZsWrddbJu4ipCMpqCM ppCM1i5Znd1yersV9JDu3Kuzc682cUlASmM13y7uRSsnTJnWf+BAZme66OTxk/6cxjVvGtecnnEu O/f8oSNGspw0Nq45bDPo2FN1dq65HNwLvpPI/gmMHz+eeAN39Kgx07iXxJRftwxOFVU3E1YxEVUz F9e0/IhWSMU06Ii8mLqFiKrpHmVjYWWjnfL6QvK6C1dt6R6fzl2+YY+SkaiaGVGRUZcFimlYgKd1 eJaGXeD4yWySkpLUeCqFQtHR0VmxYuV0dq5+fT8Ea4OHDBs5Zvwkdi5itpk4ZTo3ykeO6bqb+jDg R8zj/x+YNm3a/Pnzt4pIZZx/ruMaKaZuLq5hIYndp2MjpWPLQJuPSP+JSyCAEEVVTYWVjXcq6HFw z2fJGW4wn5gyGEpoWn2sbvM52jJ5yho6+aQcxULatUckLi4uKSlJSUlJVFhCUEBk7tx5gHHjxvXm SWJvRIyIYxgDhn8Else0etlWd+hCpqamto8Bzm5uP/1hKAJwJ3//shuvDFyCFY0clU2dVcxckSqZ OCHtjChRNHZUMLSTN7CV1bOW0bbYI689dsKXQstxEyfL6tnIG9ihYhdundkSjRq5hVPLLwvJqOro 6mpqaiopqioraW/cwAfvYtasWV3OhPQ0t72BrKys5m5w586dvLy8TR9PPnxDoCQmnr18+cKVKwUl Jd9D22zevBmxs4KCAuzylykRix06dKj04gNr7whTlwBjR19DO7rnrG/rYYCMnZfhRzQgym089Wzc tS1cNM2chGVUhg4b/mX+gDWbt+pauxnYMlz6Tgw/Y2vrgbyJS0BoavG+Uzc38gutWrlaUVFDRloN 8w9xT548uctrKX8boHMOHz36sKXpYXNTc+tTYNPTJw9amhsaHxKRnZeX1zdpiIBJkybdbrhXf/fO 7du3TU1NvyFnAqCpwBndfvys1czM7AuUWAwNDQ0Ha255hsUhkHT0DbP3DrH1DLLzDLbzCka+C6IQ lxBNW7r6bhUS7tu366lFltC3Xz81A4ueeH7g7Enn7OAd6hFKrrz6IP/IuVlzF2zjF9nCwyskJITw ocsnX/4JIPxsbGx88+5tS0vLhQsXKisrT548eevWrdbW1hev6IchMScwHN+qOVgKfn5+Pj4+pF/1 YZNeAmwxcQ783bt3cLl7IhOR3JucXxZBTQmOTQiMoviFx/qERnuHRHmHRvv0gLjkGRTpGhC6bOVX vLYPmMo2zSMowis0qifOzKbRjeBYWkxSVgiZNnrMWGxt+OcIH77haW34pR2MVx5qa2u5ubnBefTo 0VOnTvXz80Nhe3v706dPt27dCkosMxT6+/sTu1JQUDAnJ0dfX5/Jqn///liNJBIJGvLgwYMgXrhw YZfmwMSJAYqKil0uwWWCJikrKzt8+HBMTExPnxCEZjMyMsrOzj5x4kR+fr6NjQ3zQ/FaWlooIZTS 69evw8PD0VtRUdHO1QcPGaJnYk5JSY+MTwgjUYLpz4Kj/MIiCfQP7xEDIqJdvHw4ODnRMfT/q8yc 4B7hL3AGMlsPioyJiKPGp2W6+fhhQrB6v+1JTmtr6w7Gqz2QUWdLinXV1taGnYJdT4jb3NycmElo AMSGHYzPtzLfRYVuRPmHs+UfX2fAgjExMencHPGWCtiWlJQwC+EW+vr6Mj4M206kHYwXK1RVPztH hOWkrq5OvJrUzgCilbNnzyKeAsG1a9c6d4B4NcPe3r7LkAcPHswxnZODYzo7/UEwxzR2BnJ8RHZ2 4tHwpxIGzpg5c+XKlQiUbG1tIyMjU1NTDxw40J05S0DPiYa6s+2O6BUH54yFixdzTJ/+DdU4AaWl pfRbry9eYMJ/6xSS79ixg9gjdXV1MLgogedGTCZd+b95g2lHhvj+j6GhIUGMEmgJWE8sEuJ1Ksw8 sVoIoNFoKISl8PHxIUqwN2E+IJpHjx7dvHmT+JYgWBFkbGxszLqZmZkofP78+b1799AKnMmmpiYQ 379/X1xcHD42PEzi+7SojkvoRn19PbRQL6cCHKA6oJFWrVo1k4ubj1dQSFBYSGiXkpIyNgU6TKVS y8vLoVUQVkC9IIUygR47frwSfQPN2rWf3YnC2sCsYshhYWHQSPAepaWlJSQk4HhbWVrZ2dk5ODjA wWAcqNjCs5lvyxaBOXMWYlPPnj0blu4b2lACwPBmbW07QyjCwsLM8okTJxYXF9ffuXOrrq6oiH7M FZ7hxStXHjQ2NrW0NDY11THKyWQyLkGBM953aMD8R0VFrVu3Dh3W09Orq6+/09DwqLk5NzeXWEUI u6prapofP8ZiwNiJttzc3VH93oMH2O/YpIgBoSdv373b8uTJ85cvEX7+xliE1ra2RCtXr17FFMEu r1ixIiQkpKamhng/ceTIkVJSUrX19U9aWxsePPDw8ICgMaiv+k8QLGx0HksdWmvbtu1aGqZ2Ni52 tk5ubh6QLHwbDPzhw4dY6tev34DRwdCwCwoKCgoLCzFjpQwoY8D+/fuRohCrIiUlBXMVHR2dlpYG AlQ8fvw4lENUVLSFuYWerqGerrGOlikfrwAvLy+MxYwZM77Hd86XLl1aWVV1ta4O4g4ICMA0QktD ZBDH/sOHczCMsrJVjA8KLV2+/Njp04cqKyuOHcsvKUEh8TQNejg1K6usogKoqfPZESx9I6PDlZVH Tpw4eOwYYYBmzZlz9NSp49XVldXVXIx3gZevXEm3DtXVaKjz65bW9vYnz549WVNjaWuLn9M5Oesa GkrLy9GrVZ0+cIQ+/Nlp+0+cNAnM0c+jJ09y/d13jeEaYVqgLuCWYDNqqBuFBsWFBMdERsZkZmZd v3Ydzgzdj33xAjoEcq+trTt16hR2PdYDIXdsBOLDpwBCG2CdQB1BC2GpQO1gX6A8NDTMxcXNxcnD xcnXxNhRcMcuERERLHVE2YQ6/eawYTNPacXRtJy84oojtQ1N7zo6Lt6sz8grpKakx8TTIkiULfwf vvOzR1y8vPJUajb9CDQP3yflvGETz9krN5Myc2MoiSMZDiQz/F+zbn1WQXH6voKk9CziEv+OHZU1 51ESFk0ayLiNY2JpffLsxSNVNZgQuHbYrcSR70Mnq1Nz8lKz81U16a+aSsnIV569kJyZ4/wxKmR5 k2ELH//pC1cz84vjaMlfOF74lwAHadGiRQICAtC68BZkpOUd7HyjIhJiouLJpPiy0v31dfXwdl4z vlr7nv5vE22ELwFXATsFNgUpxErQvGQAMjBDMFhVVVVxcRQ/X38f70Bfn1BPtzBlJW1xcQlo/o0b N34/WQOEJaRzSstDYylBMeSgaHJAVGxgRKxfWJR3ULiGniFbp+/8qGjqxCalhZLitQ0/c7209I1y 9leQk9OVNLW6MBfcI0JKSguJjbN2/vCkW1PfOCEzN5KapKrJOH7cp4+jp28UNTkqITkmMQ3lEfQz q4nhZARHJHQD6ap19Kf/Dh4+tKw8ckrGNsGdXxiOqo5eYk5+dEKyfrfDZl8LiE0QRGD+ZWVlDQwM YFMU5FV8vKJIMcmx0dR4Ci0zA6HByfr625BjT68AEx+vfvXqFaR//vx57PuYmNiQ4LDAgLDgwKjA AJKutrmEhKS8vDz2NYwgFxfXd/2vCitn9+iE1FBygrmDi/heBQlZBVEp2S38At2PMVg5ucUkpkdQ kjZs/uyUppmdEzhkFh/UNPzsnsmAAQPSi/aHxdHCKTTebQIo6de/v3tAKCUtB3x4ttKVxoCBA72C I6JpaZS0bEV1rd2iErvEJIUlZHaJSGwVEMJq2SkiPuL3kWDlFx4dl5qdkJW3Y9eensaCze7s7U9K yaSk5wjs7JHsqwDzjwiFn59fRUUFQpeTk9PU0A/yJ8fFpsWRkhOoqbSElIyM7MOHj545U1N7qxaW HYoaniRcxBs3bly6dPnIkSP5eQVkEiU6KjYiIjYiPC4ynBoZRjM3dRITEyc+pQsFDmXCycn5zf3w zgAFS0rOIKdkxiSlL1/N+uEmAcOHj4iippBTs8gpWfMXLu58SdfEHBvzYv3Dx8+eYWaIQgTviFOo 6fuiaSkBUaRBg+in6EePGQsOybmFkNrsefTHCn379fMMDEXh4ZpL6z9/M6VzsIwoxt0/mJSU8eh1 x4HKk0wdDhfa09OTeSBn6LBhobHUrOKDNTfuYFfSS4YO/eefjIApnzNnDnx1OIQaGhpwsJWVlZWU VMxNrYMDomnUnIT4zMSEDFpCWgI1BdJPpGENYCUkUeOT4uJoZFICmUQjxSTGkVIjwxPtbD3UVLTg UmLlwEXfsmXLkiVLoMC/xx2nLjBn/sLwuBSvYKjuyD8Yt/p7uus+c/bc4Oh4b1AGR4374zNts2jJ cveAcO+Q6FcdHTBM8PdgghFPBccmeAVHOnr4oxWCkp2DM4qaDj7+4WTmoTUlDV3PwIhD1Vdh11xd XRFoI5y5dOkSqu8WlezzUVg7dgl7BkUERFGgIeHTOjs7IyaC3YyhZShr6vXvT/9i5Nhxf3iFRIfE 0l4yvhThF07SMbHs5a3OvwRY83nz5q1ZswbePhQ7Ak/IXU1NTU5O3szEwsneNSggMoGSkULLSUnK SUygI1ZCUkJOaDDZ083f2tJeXVVTRkYGSwWKAn4gHx8fdgcCrh/2FyS823eaOrgbWTsraxl/+VHF Rt7toDS2cVHSNup+dY+knIGVo5m9u7VbgL03/favpZO3iZ2rlrEVG8enQ+mr1m8OoaRbOvtomVgT L60DJkycjJ+GVs5m9p5Wrr7Wrn7mTl5GNi5GNq7bdokyezVs+Ah1Q0tDGxdzR0/G7eUQO48gC2cf S1c/sb1KBLffR442sXNDXWM7dzMnT7AS2PMNjmR3Bg4ODoRpCAA3bNgAucPm6urqQvTw4eHUKSoq yjJAU0MTYSaEiy2MtaHOAPoDTVFRSBlxFnY0NEbnWwo/ADZu271LSmmntMry9axfmmDCer6doNwl o7p8HQvKQUOGLl65YaeUsoymiZyWuZyOhaC44tI1m4cOH9GZbKeUirKRvYKe1eYdIp3Lx0+cumHr TjEFbSlVQxl1YzFFnc0CwuxcXb8WNWb8hHW8gqKKOnsZrUipG28RFJsx59Nd8T59+i5fzyMspymp aiCpqr9DXGH8hO/1Z3yws9jsy5Ytw37n4eGBnseGhfSxc6HwiW9eQfqQOES8fft2GBeYAxhoSBlr 5qe88tz7h499emEB+/brP2LU2NHjJw4bMarLpT+msG8VV7GJyNqjZLxbyfjPGSw+/DV4yLBR4yaM GvvHwEFfegI+cPCQ0QyyQUNYx1moPvz30YP/QRT2VcDOzs7NzY0tjw2LXQ+ZrvwI+Al1vXjxYiyM mTNndvmO00+B3j8i/zJl90vMEsy/lLalkUeUlJalmLqJgKRq/wEDv1y9913qDdmPh8mTJ3+/2Pl/ HMb9MdHEyUfPxk3bwlFBy3jSr489/qthzLjxu8QkBHeLbOTh+194/fMX/Bfg/wDVyuZhDQplbmRz dHJlYW0NCmVuZG9iag0KMTE3IDAgb2JqDQo8PC9UeXBlL1hPYmplY3QvU3VidHlwZS9JbWFnZS9X aWR0aCAxNjUvSGVpZ2h0IDY3L0NvbG9yU3BhY2UvRGV2aWNlR3JheS9NYXR0ZVsgMCAwIDBdIC9C aXRzUGVyQ29tcG9uZW50IDgvSW50ZXJwb2xhdGUgZmFsc2UvRmlsdGVyL0ZsYXRlRGVjb2RlL0xl bmd0aCAzODE0Pj4NCnN0cmVhbQ0KeJzFWmlYU1cazkZWIIGQQFgSQtgJyBIggICgsieAClioxQUU RVzqgigq26iodRed4tKZCh3H0WqdWoFqW2rVtijqAyIgUBQERKyIgECWORcSudlYnqcD7w+e3LPc 857vfOc77/kuCMQ4MOdY2VhZsIzHazc9MDC2dPGdGxIWHiGICA8NmePjyDaiTjcpBegxrDxmhwsg CNdv3vSxEPoVFuDKppOnm5ocFCM7f8BwXs7XD1qlI+hpuHksSSgI8eLQdKeb3jDoVn4RggX774uk Snjx72RhqIe5wfTT1GfzwwQx53qVGY6gIk0Y7GamR5xejjS7uYKoE13qKQKIf0gSzrahkqaRoq6x S1hkXotGihAGriwMcaBNH0sy0yci+tKYFCE8Sw2bYag9TRx1zf2F8ffH5Qj2epbA3Wh6WOow/YWp rQpsJKKh/nc9PX1DQyIJvFx0KsqdPh0rTjKZKUzvgTPpba/64eLZw/sOFJ4vqfijq18Mq7wa5Wow DXuc5i5I7YZRbKsozkoMD/DxdPfw9psbs/b4jfoumDmLIh308FPNkWwTltj+gYK4/fbhxABXOwtT GlRpyraZwY/eeb329SjL4yEcXdzUciQxAxdUfCDQd//0qmA+l6KjhRxtYuMRnVdW8+Ecer8twsZI D4BCJqKnhiSVF/XlB469T28UnSrIz9+9zZ2Cgk3ExmvFxceD8lZvr5w6tD8/Pz9vwxwSUvOb/zqQ 2CEp/WqCzd2Z2vDxrYIOvlZt9CwaPpX/H6juCyrVcJRKzjliPzRCEu1z36i2adjsojMVJImsoCx1 HKXS/i1mcodDkb2KBlQaiGvy5prgp2K5KU4x1epJSl/M0x9hgKKH/apaPVSRF2ahMxUbB88I2C4P gT3KNO7OJAKWSKx5crMaQ5dummlCmBKPJFlF/Sgbtf0nZa8Tn7LVQiBJTvlvVTlKytd7GGKnZGsj dLlLZAaUnMwqVta7vWuMMXq+l4bUOcONYAYeicJTDJlsNpOujRmXL4ZIoehRiJjJk9TnH5IN+mxl UNIVZTp/RNvOf6COolRaH+nkNku4ek/h1WvXvjm2Y/5sHpssc1AkzsTNf5avp5sLgLMdg4BE63K8 BZt3gfi7JZLPmmRsxTPCbsoG3RvA4qXckShR+f1wm3qO0sEzV6s7YcKju65kg68pDhofbbyt42Vn 59NqCFWV+WyGe0pZiyw8iJ5/HW6CHZcZDASzhTKFNhRjTaa4ZdQqUZGoxnnlecDQdtybCrYSzuMX eOkPCbtrFK52rzM5WpOxJHOpbIUbfGhEjIFf/kvNFGSzqRaPUVvzEQON0Il+AS/7/ZFyj95VhpMI CwROpqxfoTUJh8Qah/793dgc35Xs7x6r/uXHdDQ9VSHy96m2qvaZhIoi2p6UdZtP10IjkHjz2EuD qu8cxYsv0tJewZ5FHfd+vt8Bt9QTf23Lo2POE2AgkTJhjigC94Ksm+9wXEaRbJeXa15O0aO9McJi mFMOlO9PTVx9DO7JkiwW/6ZyR7GyI+eYTniHo/AzvpW92hMx3AtNdtlUo4ljf1l6oHs6fPV+2+Bn a2EvOAvfF//1EDQodJN0Vdz4pV2hSHrEYsJOicQ6fy+zkbusE4bqs6tDPceuomQeOxxOoO/S2qig 2cGf/ANOsjx0uYLXip+cSEtY+aWir+/hTHznYBxkJMV8uRLHmsRdVVU8oEX9kQW2VOsj8IUTvX3d CdClcGzejstRWNznu0PtzZ3XK1xGB7cwJx7QUTby5fbFyaaGs96gEEDkr72zM8hcmzirTk2dIn5a dlFhcl+GGuPRBvEKGuXVCsbEfRJpId84oaThMw1JdMhVo8ClkoqtPgw8ipwwZvwZxrdrH8Efu9Ot wDGk97FCAH4UpT9hQ6JxDHkIWqGHQUHq1vsr9SGoNcUcjEVbO8Z5I5vOkXSFTfL0IzoSgTRKew8v PO818fwCRpuSLut2yRSHRmAMBRVSDSj1xCOQZtnwov7ntY+Vce/rFTsUXPo7fx0weetT8LLBHJtJ nIt6dKHsWOzgamvhOKma02pDn1likOb58KL2wo1paWlr1m3ckiHHllVRwSfgbcT7uOBwwXrfhRe+ WmkyiWNRj8WT7RJRMF3f9bCGBOowupcbopmZ8Ej/bD3P1tbONXLvqTMynD6+3nm2Qih/s44JnF07 6jm8sGrexF0SgdAxdymXddzLCy9VSUMroCFcz2QtPNr8ucmWbGAdWQJvdJ4rVAjljR/RwD6mJisc 4F/7TCblpc3mH5R1fJk9bnT5gW8aXwkvqCtI3FqkYKPuNOdlCgGgLBC4pJKbDOXZTkpQmvjEyI8C lXuYCsTHvaPOqNE0o+grDnPZDg8Aks8cgUti3K7DW3WtNp3UBY7KW3hH45A9yor3Xdbi3DHUpKSj aAmXfx5e9HYDC7gkIbgeXvhkweS+XVEcFuzSEPrEdZdvKd952vc+1EhxsO367vm2NC8FVV4fB7mk TjRc3kn/4zPJXLFZyKf1UnUYKN+ZuFWF0rMPU1CY2sCbpp+LshP4TG2S8+dVzztkeFFz1Au4JEI3 sLTuhbzw+YMUq0m5JAJB46+9os6U3RdX8q19816pqRqufnT7fs3z9vaOjvbW2kclxYe2JIa4mVOw KKzZ3NSsPIBcgO0pgaaQBCdaRa/PzpUhI5FH1WG5utvpTdgxUa6ZT9SQaP08nqtPZISfU39IDpXt TUldk5EFxszOXL88NtjbkU3XhoSUFjMiLWPbtm0Z6xaFeLnYGBEhJlpkloOrmwxOHKq2bXFjU+VM jeliJI5qYqKPk2sQjHFygyoHUdVegaUOGkngJKk/Jqtygp0sbJ1cwJguM+wtzehkgiw7gPeqez8A obf58wAGUWvYWkgMjkiSg4jHUKI6wZ0xUuMnVS1OzoWvNjNGrvFIgk26GoU78GPGLFPisN7g5XSq 4dhzdr4JGY0lDI9MwGFQo7pL/5PRUFbpqd5WSMONoLYmgqLJkOQFIC7edBj2XKSOx2k1+dN3320M pI/YGmMY9k/VBRf9tNWVpv79KNbfQESQiIcD1VC6Kc3KnmVgYmeujUISjJ28+HZ0LBKBMl11p67q mJcOEmtg58nnynJKaDKH5+NuScZoe5yUQF852AQooxf8s5o903d9TzyPRR+ZE56zTPUbVOfpuWYa rIBxvQY4tlTcrYWC/uVZa+7eu5pwuu4CR5sV9sXjttbKXBddJMZqV+0fFUssCHru2RUtbVX7XHWA mtN2SL3R9LK5PNHa9VoH9JKqI0wgTdwq1Trc4Ok4YZCvqx2Hbcq24iWcUhHBfZn2mgQCIRjcHAf/ tXbFPug6V7r0V+B7QANf9/UpGFG94h+9dfB8EEtfxzFMYx8MG0lS4kZAG4SWjKxZd748PV7BAxcF mxUXbj2ofvy4rvHFm364TXu/ixQIBOEQohZl/qdeoXKwo2wRW5P4p3zyJ7D0Zp7jkgfQzWEr8GhI tXyxtPxD/2I7PSjD8SzWJgnyd6havMOUJmiSN/huv+zHdT7YQwbOwmWpQBGmbd97vrJFUQINNF7d LhQIhAW3XyoehG8fFi5205SERprmAZesWeM79xCwf9++o8NH1sCrgzegqTc3QhnQzmirjUCmVy2c 91gqfV//+wtggV/85gB7S/5saO4VV6bn1IMh+1vvZ9gDRyXSWNa2wwiIzS59qu6OqAxJW+n2cGcd TUlGDBf60tv28LdaaOl+31oKdWm5cuA4WMCuy/v3XAIKaShzVhEo/nYxuF4NPSz+eylQf03LjoOG jed25Z+5sCk8ARJ/1UeX+xhC80ZhtLAj4PikXqoeXwcNPv13khsTHnIUgfO9PTqfxpxUyDFbjyUu AT44dC3J1/9TIAdF+QvBXhw8mgbWfLC9uakVmLU5B7hyb2Gsl1fgHFdrIagX/TPSlkZQej3LJbag okNtTnd02J7qwhguQwNBCKTR5EXfvRzB8jZoaKFTAriadWW76DMSmkCE27oabN6uzK2wdMG9w+Ch Oc2arEs10KUuAPTfbLImYlTOTVOHuZlljW/GUGL9LTdzwmwNx+CI0F/8J/SN9+2b9sqza3wdVwEf bFhhYbQIlHauY+EstoFlr121E/ytS80F7tXT0dLS2v6yqeDoIHSvNMBRGbpoajJg/DServZot/KM O3CruVeDchtou3Mo3oOjIYiPAMXcDbZf+zenjuSuDHWgW0G76FYIxeBjoFPElyJ9N4F73lBh3DEx lFndDpa57fqXRf999NW2+Lz30Af/wNm53wfRmTsA48p1swzVfn4xs5+ZeKKio3dIhaeo/2XFycXe diZjUQTxYjiU30ie4+1qbUjCO18BT0VueErYPcifa6qAhUT3kiMuguLisFXAvOJnD+veSatieclQ Fub1w6di6WNfh2Ng/N7WajcNOUwW13/pwZLazneiUb0oEfV1Pik5uMyfazY2RRDKg56CqLKHRyOT cGgkfjbQV/07rDBE5zz5nhTdT/cRghA6sMsjokQ+RE0wM7BY7mdNAufDwz+q/TXe1tiO/NDl+y5X Puvq6Xs/8L6v51Vz5eX85eFeXOZ4FMG9LviPgcGmRYwRbyLNaRgYbEwwQmGMhUWvoD35vvP6Jv8Z K8HZ07XSkrv6zjtAU/SmYp2THmfZjz3gQdz9aAvPLqVVLJV0n3Ef60rJ4XrMWbg660DB2XNfnPhs Z1p8EM+ebTQ+RUBrxpqCk596kEciFHFG2vET6911kUiS5bzdl397cOur3Yv4Hlt/BWweRNKp7ikn b9777VrBGj8jPGXG0mPfV94vK/w0wMRoZuY3d8sOxFiM8+8J5jaOrh58bz8fvrsL15o50SsJlubo 5+dIw8qfuH5+XOgJrc3yjFq64pMITw57CZQUGjjKI2GptgEfJSfFzXY0IqC09Kz9Y5OSF85xYhCJ DPeoRTF+HN2Jfbc0HismqgEKRzYw0MWiVJ5QOIqxhaW5EZnA2gPtofIEphYSQzRgcjhmBiSgl5Fo ItWMw2HSSFpIFE7PmGVqQBz/I9tfDXC6YdAoBJq5ub79+bernXQhBkg0KJRTgT0gUWiNh9oUAE2b mZqdEeesP7FPjP8DU/4xtA0KZW5kc3RyZWFtDQplbmRvYmoNCjExOCAwIG9iag0KPDwvRnVuY3Rp b25UeXBlIDAvU2l6ZVsgMjU2XSAvRGVjb2RlWyAwIDEgMCAxIDAgMV0gL1JhbmdlWyAwIDEgMCAx IDAgMV0gL0JpdHNQZXJTYW1wbGUgOC9Eb21haW5bIDAgMV0gL0VuY29kZVsgMCAyNTVdIC9PcmRl ciAxL0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGggNDU3Pj4NCnN0cmVhbQ0KeJyFwodS2gAABuDn srV72zpREVEEkaGAoBDCCjMQ9h5hC4iADK1272Xbx+of4513rXf97hubNI6dv4ZTfBP/+jR3nEuM z1y8gbPETa6Zf2sOSa6AvC0g7+C8Be/yF6z3zt9fRNsDId/+cIn7SIQOfLyM1BMxd0LsnFhxPl1F 1zOUuCYl7qk19ExLuTMy7yyu+3BO7hPIacEGPa/w44IygIuqgFDFCNXMkjoo2gyKtkLLqAmLNeEV bQRXdVGUbMfW9DGpPi41xGWGhGwnsb6bRLkxtWFKKUxpBZFWEhmlOasis2oyp7bkNq35LbQVNPaC 1s5qHazOUdRRpW2qpHeW9a6ywV3BHU9111M1emtGX92E9B6B/oY50CADTZJpWpiWNdiyhvZtobYt 3LZj5MAR6VDRDhXrOjHec2Hi0I3JvgdTA2964EsPkc6M6OzIj7mjAPeYyR8zhedB7kmQPQmxp6Hi aRhLLyJYfhnFCr6KYfV1HGv4JoH1t0ncw3cpbOD7NDbxQwZb+DGL+/xPuTb/cx4P+F8K2OF/ZbuX i91vxd7FUu879/Byuf/jr5X+WWXwz+FZdfjzyrXhr9roP+uj3/WjK/4BqNyYIQ0KZW5kc3RyZWFt DQplbmRvYmoNCjExOSAwIG9iag0KPDwvUGF0dGVyblR5cGUgMi9TaGFkaW5nPDwvQ29sb3JTcGFj ZS9EZXZpY2VSR0IvU2hhZGluZ1R5cGUgMi9Db29yZHNbIDAgNDY4IDcyMCA0NjhdIC9FeHRlbmRb IHRydWUgdHJ1ZV0gL0Z1bmN0aW9uIDExOCAwIFI+Pj4+DQplbmRvYmoNCjEyMCAwIG9iag0KPDwv VHlwZS9Gb250L1N1YnR5cGUvVHJ1ZVR5cGUvTmFtZS9GNC9CYXNlRm9udC9BQkNERUUrQ2FsaWJy aSxJdGFsaWMvRW5jb2RpbmcvV2luQW5zaUVuY29kaW5nL0ZvbnREZXNjcmlwdG9yIDEyMSAwIFIv Rmlyc3RDaGFyIDQ1L0xhc3RDaGFyIDEyMS9XaWR0aHMgNTYyIDAgUj4+DQplbmRvYmoNCjEyMSAw IG9iag0KPDwvVHlwZS9Gb250RGVzY3JpcHRvci9Gb250TmFtZS9BQkNERUUrQ2FsaWJyaSxJdGFs aWMvRmxhZ3MgMzIvSXRhbGljQW5nbGUgLTExL0FzY2VudCA3NTAvRGVzY2VudCAtMjUwL0NhcEhl aWdodCA3NTAvQXZnV2lkdGggNTIxL01heFdpZHRoIDE5ODQvRm9udFdlaWdodCA0MDAvWEhlaWdo dCAyNTAvU3RlbVYgNTIvRm9udEJCb3hbIC03MjUgLTI1MCAxMjYwIDc1MF0gL0ZvbnRGaWxlMiA1 NjMgMCBSPj4NCmVuZG9iag0KMTIyIDAgb2JqDQo8PC9TdWJ0eXBlL0xpbmsvUmVjdFsgMTUxLjM5 IDgxLjg0IDE5Mi42NyAxMTEuMTJdIC9CUzw8L1cgMD4+L0YgNC9BPDwvVHlwZS9BY3Rpb24vUy9V UkkvVVJJKGh0dHA6Ly94ZW5iaXRzLnhlbnByb2plY3Qub3JnL2RvY3MvdW5zdGFibGUvbWlzYy94 ZW4tY29tbWFuZC1saW5lLmh0bWwpID4+L1N0cnVjdFBhcmVudCAyMz4+DQplbmRvYmoNCjEyMyAw IG9iag0KPDwvU3VidHlwZS9MaW5rL1JlY3RbIDE5Mi42NyA4MS44NCAyMTcuNjMgMTExLjEyXSAv QlM8PC9XIDA+Pi9GIDQvQTw8L1R5cGUvQWN0aW9uL1MvVVJJL1VSSShodHRwOi8veGVuYml0cy54 ZW5wcm9qZWN0Lm9yZy9kb2NzL3Vuc3RhYmxlL21pc2MveGVuLWNvbW1hbmQtbGluZS5odG1sKSA+ Pi9TdHJ1Y3RQYXJlbnQgMjQ+Pg0KZW5kb2JqDQoxMjQgMCBvYmoNCjw8L1N1YnR5cGUvTGluay9S ZWN0WyAyMTcuNjMgODEuODQgNjU3Ljc0IDExMS4xMl0gL0JTPDwvVyAwPj4vRiA0L0E8PC9UeXBl L0FjdGlvbi9TL1VSSS9VUkkoaHR0cDovL3hlbmJpdHMueGVucHJvamVjdC5vcmcvZG9jcy91bnN0 YWJsZS9taXNjL3hlbi1jb21tYW5kLWxpbmUuaHRtbCkgPj4vU3RydWN0UGFyZW50IDI1Pj4NCmVu ZG9iag0KMTI1IDAgb2JqDQo8PC9TdWJ0eXBlL0xpbmsvUmVjdFsgMTA5LjI3IDUzLjA0IDEzMy44 NyA4Mi4zMl0gL0JTPDwvVyAwPj4vRiA0L0E8PC9UeXBlL0FjdGlvbi9TL1VSSS9VUkkoaHR0cDov L3hlbmJpdHMueGVucHJvamVjdC5vcmcvZG9jcy91bnN0YWJsZS9taXNjL3hlbi1jb21tYW5kLWxp bmUuaHRtbCkgPj4vU3RydWN0UGFyZW50IDI2Pj4NCmVuZG9iag0KMTI2IDAgb2JqDQo8PC9TdWJ0 eXBlL0xpbmsvUmVjdFsgMTMzLjg3IDUzLjA0IDE0MS4xOSA4Mi4zMl0gL0JTPDwvVyAwPj4vRiA0 L0E8PC9UeXBlL0FjdGlvbi9TL1VSSS9VUkkoaHR0cDovL3hlbmJpdHMueGVucHJvamVjdC5vcmcv ZG9jcy91bnN0YWJsZS9taXNjL3hlbi1jb21tYW5kLWxpbmUuaHRtbCkgPj4vU3RydWN0UGFyZW50 IDI3Pj4NCmVuZG9iag0KMTI3IDAgb2JqDQo8PC9TdWJ0eXBlL0xpbmsvUmVjdFsgMTQxLjE5IDUz LjA0IDIzOS4xNCA4Mi4zMl0gL0JTPDwvVyAwPj4vRiA0L0E8PC9UeXBlL0FjdGlvbi9TL1VSSS9V UkkoaHR0cDovL3hlbmJpdHMueGVucHJvamVjdC5vcmcvZG9jcy91bnN0YWJsZS9taXNjL3hlbi1j b21tYW5kLWxpbmUuaHRtbCkgPj4vU3RydWN0UGFyZW50IDI4Pj4NCmVuZG9iag0KMTI4IDAgb2Jq DQo8PC9TdWJ0eXBlL0xpbmsvUmVjdFsgMjM5LjE0IDUzLjA0IDI0Ni40NiA4Mi4zMl0gL0JTPDwv VyAwPj4vRiA0L0E8PC9UeXBlL0FjdGlvbi9TL1VSSS9VUkkoaHR0cDovL3hlbmJpdHMueGVucHJv amVjdC5vcmcvZG9jcy91bnN0YWJsZS9taXNjL3hlbi1jb21tYW5kLWxpbmUuaHRtbCkgPj4vU3Ry dWN0UGFyZW50IDI5Pj4NCmVuZG9iag0KMTI5IDAgb2JqDQo8PC9TdWJ0eXBlL0xpbmsvUmVjdFsg MjQ2LjQ2IDUzLjA0IDMzMy40NiA4Mi4zMl0gL0JTPDwvVyAwPj4vRiA0L0E8PC9UeXBlL0FjdGlv bi9TL1VSSS9VUkkoaHR0cDovL3hlbmJpdHMueGVucHJvamVjdC5vcmcvZG9jcy91bnN0YWJsZS9t aXNjL3hlbi1jb21tYW5kLWxpbmUuaHRtbCkgPj4vU3RydWN0UGFyZW50IDMwPj4NCmVuZG9iag0K MTMwIDAgb2JqDQo8PC9UeXBlL1BhZ2UvUGFyZW50IDIgMCBSL1Jlc291cmNlczw8L1hPYmplY3Q8 PC9JbWFnZTEzMiAxMzIgMCBSPj4vUGF0dGVybjw8L1AxMzUgMTM1IDAgUj4+L0ZvbnQ8PC9GMiAx NCAwIFI+Pi9FeHRHU3RhdGU8PC9HUzEzIDEzIDAgUj4+L1Byb2NTZXRbL1BERi9UZXh0L0ltYWdl Qi9JbWFnZUMvSW1hZ2VJXSA+Pi9NZWRpYUJveFsgMCAwIDcyMCA1NDBdIC9Db250ZW50cyAxMzEg MCBSL0dyb3VwPDwvVHlwZS9Hcm91cC9TL1RyYW5zcGFyZW5jeS9DUy9EZXZpY2VSR0I+Pi9UYWJz L1MvU3RydWN0UGFyZW50cyAzMT4+DQplbmRvYmoNCjEzMSAwIG9iag0KPDwvRmlsdGVyL0ZsYXRl RGVjb2RlL0xlbmd0aCAyOTM+Pg0Kc3RyZWFtDQp4nH2QTWvCQBCG7wv7H95jIriZ2U02GxAPfmJB sDTQgvQgIQoFI03i/+9G0ta22tMy7DvPMzOINhiNovV0NQONx5jMpniXgkCKiFhrSpFqQhIT6lKK 5wEqKRiHrwyRZYp/hPYDKR6lwHw9Ba4E/C0Y9r1JZtPe5QzzLZc2KsvgbbCpYsqQZIkihlbWWkZx lCJaHXeHko3G7IRbZv1nNR3HHN/QRZtd25Z1haLxADYJmqLquphZueTS4VhZsv+uanrhJPfIhYax KrPI993tulUY1o8RO3DsX/9z7K8aLZ/Y4NB05VKKbfBSVuEr8gcp5p7V8T4JzE659JqwDXAvq1Ol f2U39ektHOqgLFqEQxcszu25Dk1QNncgxs/s9H3h5QofNBR4kQ0KZW5kc3RyZWFtDQplbmRvYmoN CjEzMiAwIG9iag0KPDwvVHlwZS9YT2JqZWN0L1N1YnR5cGUvSW1hZ2UvV2lkdGggMTY1L0hlaWdo dCA2Ny9Db2xvclNwYWNlL0RldmljZVJHQi9CaXRzUGVyQ29tcG9uZW50IDgvSW50ZXJwb2xhdGUg ZmFsc2UvU01hc2sgMTMzIDAgUi9GaWx0ZXIvRmxhdGVEZWNvZGUvTGVuZ3RoIDk5MTc+Pg0Kc3Ry ZWFtDQp4nO1dBVxU2fdfu9decxFExO5uEUQRDDqku7u7u7tmGIahWxpUMDFA7BYwUBFQsQP4f2ee jgiDi7vG77/r+ZzP/dy579xz49x74r373vz22y/4Bb/gF/wjmDd33sIFi5csXjJ69Oif3Zdf8C2h b9++mzZtsrOzz8jIrK6qfvfu3du37560vLt353HrE+TfouTevYZDFYeCgoIlJSUnT578s7v8C74a BgwYICQklJ6W/vLlq/fv30Omz5+/uH//weXLV44fO56VmRsTTc7bV3jq1OmrV64+ePDwxYsX7+gA yvdnz543MzP/Jff/FzBw4EB9Pf2mR81tbe1v3rxtbn589cr1QxVHsLspFEpISKi7u7utra2ZmZm9 vb23t3dkZGQiLTE3N/fYscrr128+fvwUtd6/b2t7356aksbJyfmzB/QLeoS9e/fevHGr7X3Hmzfv ILg7d+5evXr1zJkzx44dKywsTElJiYmJ8fPzc3JysrGxcXV1DQwMjI2NRXlBQUFFRcXp06ex/aEE oAog8fa2jvfv3oeGhk6YMOFnj+wXfAabN/NUVZ15/7797Zt3z5+9fPz4SUvL4+bm5vv379+8eRNy PMOA0tLSzEz6NoeUkdJotOLi4uPHj58/f766uvrs2bO3bt1qbGx89uwZNHt7ewcB+Ono6Dh48OCf PcpfQAcLM6u3b9pev37b+vTZ45Ynz589hw/W3t4OiwzZnT9/Yf/+/QEBAXp6erKysrt27eLj41u/ fj0PD8+OHTvExMQUFRVNTEzi4+MPHz5cV1f/9OnTV69etbW1dXSG9o5Tp079+eefP3us/2nAjqNS k5+1vnzy5Nn9+w8fNT56/vw5hPPmzZu7d+9iw2Ivk8nk4OBgbE9DQ0N5efk9e/Zs3bqVn3/b9u0C O3fulJCQUFNTg7hdXFyCgoJAXFZWBoWA3f2ZtNs6IP97dxtWr179swf9H4UpU6Yeqjje0tL68EHj rZu10NvYzhD37du3ob0h6PT09OTkZEgwLDTcytJOTlZRUlJaUkISe1xZWRmbGrZeWnqvjIyckqKq i4tHbCwJ6j07O7uoqAjmvqGhgZA1djrda3/fBmPx6sUbeTmFnz30/xzM4p5dc+ZS48Omutrbly5d rq+nK+E7d+5A0IkMgAOWkZERFBiioaED+aqrq2trayOFoOXk5FCCnY59raWlpa+vj90NVa+goGBk aJqUlAKDXlJSgrSyshLmAKEc1PvLFy9fv4baePv6VZudjePPnoD/EEz4Y8LRI6du19+9ePEyTOqV K1ewo6uqqtLS0qKjo+Pi4rBJI8Ij5GTlIFyIdffu3Zs3b4YeXsmA5QxYsWIF8RPlW7ZsAQ2IIXos CU1NzZycnPz8fKRZWVlw5KA3WlpaGhsfNTe3tLa+eNzyUllR/WdPw38ChgwZmp627/r1W9XVNYie YKAhDnhZiJhgfMPCwiIjoqGlsX/hhkGOEOuiRYtmz549ffr0qVOnjh8/vjM3lHBwcHBzcy9cuHDZ smWgR11YeSUlJR0dHcgaK4du0EvLmpqa4A/U1dU9uP+QoVUebt8m9LMm4b8DVlaO1dXnDuw/mJSU lJubiz2YlZllZmZmZWXl4OBgZGgGf1tISGjdunULFizg4uKaMmVK75lD7oTQofCh/MXFxWOi6aE6 HDnojYsXL548efLo0WNYYFWna4oLKyZMmPj9RvoL+LZsLyo6kJ9f6OnpaWpqamxsDJu7lQGIsNas gZDXQW9v3Lhx7dq1UNRLGbBkyRKkffv27U0Tw4YNg9ChE0RFRVVVVVFRRkZGREQESwg/3d3d7e3t 7ezsvb19HOyc1FS1lnyEpZ8DSqA3vveE/Ith+PARkeHk8vIKe3uHoNDQK7W1HV8Ddo5f4V+xsbFB 6HPnzqVSqV/VCuB6ff21+vq0nJwJE3/t/b8PSgpaRYWlaWnpEDe2MzUx8Xpd7dVbN89duVx9/tzp c2erzp1Fpjteun4NUoCDvXrNmt43x87OfubMGVS8cvNGd55o6zQDkUcHLt+4js5cr68F8aUb12Bc BgwY8P2m4l8PkyZO8fUJKSku8/f3hzHV0NCAUT56/Pj9R48aGhvr7t69Xlt77datG3V1LBH+NF1w N26MHTu2N83x8/M3Nzejyq3bt8G5CzeiLaS4eruhAX140NR0v7HxTkNDTU3Ntm3bvvds/OtBZI9M VGRseHiEr69vYGCgq6srLOOsWbNu1tY2tjQ/ffEc2Pz0SdOTxy2tT4GPn7USSPxEOaFpEVv9ZVvw +gjih81NYA62BEOCFbMVtNj68gXK8fPBo0b47YWFhdAJ338y/uUwbux4C3OHjPRMSNnb2xsbXEtL a82aNRMnTsRWetj06HHr05dv37TR722zQPqdsY6Ot+0fboPr6ur21BD8NKwHguzZyxev378j6jD5 MHm+bXv/4s2rViyz58+aW1oQoGEdDh069EdOy78V1q/b4unhGxkZ7ezsDHGHhYYhVuLh4Vm2ZDlM JAzlkydP3nd5qNEzvHnzBm5z91YQm1+/fr33Lllbe/vr168bGxsvX76MaP3HT8u/Evr06aMorx4T Q7a1tXNyckIIbGhoiGhr9+498Jw5OTkRYcXFxT179qyd+czyr+Dq1au///5751YQaoHDV8i6re3F ixcNDQ2HDh1atGjRlMlsf06d9rOm6N8EkyZN1dE2iokhOTg4QpkHBARgX2/atGn7NkHMMyz44MGD R44cWV5ejvnvvcQTExMJ/lgtiOJ7L+gOhpMPfQI3jUKhjBs3butWfsEdO3l4tnfpOWwNAnA+Pj4E 7GoMQGbt2rVz5sz5YbM3Y8YM5j0BZBBd/rCm/x4sXbzK2Mjczy/A0dERytzNzQ1bG4HYtGnsUL/w tAmLycXFBVUM7dp7ievo6IwfP37//v29FzSYwxY8evSotrbWyMhozJgx6AlD2/ByzZiLYEFKSioi IuLUqVMg+zIr9DYhIQF9+PJ9v2XLlp3qBMnJyRGsQEjo0x3d0aNH6+nplZWVYU12b/fly5clJSUK Cgq9vO/0g0FQQMTGmn4ji9DkmB9sbWlpmUmTJrGxsQ0fPpxJCYMOQbx9+7aXsoNE4GJ9lawxVw8e PKiqqoKGQYsSEhLwFZFHr86dO9d7Vl0AFmHdunUsh6+trd2bjoEMxPPnzyeTyehkbxpFh//XDuPB cO+VUXF2cnNkaHKEYJheiHuHgBA2JhRpF2dYX1//8ePHULZ/e+Z7AhhrGPc7d+7AdccyGzsWjY+D hrSzs2M5vRABqmDt0R+evnyJpYVefVnzREdHDxkypMsMQAP0pnv8/PyIH/9SpXSBmzdvjho16seJ 869gxIiRigoavj7084Tu7u4w3JsZMG0aB+w14qZBgwZ1qRIVFdXa2tr19BEraO9ob2v/CzIQvH7z GtjCiLbQB6LFaWzTIOuLFy8SZG/evgEN0rf0k+z0o1MwK4TOh99+6dKlGzduQC1A7u10kbcTTb9v ew9iVESG4HPs2LEuEr916xbRDQLphyw+4rv379AiURF6vvvomGy7l6PdDsaaxMT+OHH+FcDj3Suj 5ObmAZMNhwqxLWQNpd2vXz/IGlEYMl2qQL0XFBbcbbj3qLmJwObHLZ2xqaW5EcWMDHGVIMPPzvn7 Dx/cuXe3tr7uVl3t1WtXL166KCYmBv79+/dHCiVDbGo0VH/nNijv3W9AlYePGgmEcAsLCwUEBAhz g03Ey8sLoTAbIrrxoPFhw4P7qA4kxOHn788cy9Q//wQNUYVA5qCARHUUPn76BCkaRWdu370DVuBJ jIVZkUBmu+gq6t6933Dt2rUfKM+/AM7p3HKyKp6eXpA1Im4IHYZSVJQ+7QMHDuzJ2Zg8Zcr+iopz ly9Xnz9fc/Hi2UuXuuCZCxdwCUhkkBJkSIkq1efOVVZVHT1xovzIkdKDB5NTU7lnzfqNYVyQLli4 ELJuffXqRFXVierq0zU1RC0CzzJSWnLykI+GhqgFmDN37vkrV4gOfNbouXMnq6tPnTlT39BQdfbs pI8vNfBu3fqwuRk0RG+ZyKwOBP0JRlcPHjpUfOAAhUbLyMnBzzPnzxPMCWImMseLilXnzl28ehUO 5/eWYy9hFvd8eTkVH29fyNrPzw/mG3tEQUGRuMqcxu6wctWqAxWHyo8cPXTs+OHjld0R5UzsXFh+ 5BgyBw8fKSrbn1tYlJ2Xb+foNGLECCZnBOzQ6k1Pn5VVHDpw6HDFUTo9UlREeqTyBLD63IXp06ez 7GFeYRFaASWzaSJF9f0Vhw6iw8crN2zaRBBr6+o2tjzFpc697YKl5RUFJaXpObk7BIWYnsySpcvQ ty6jY44RrRN45MTJk1VnJv7PPLmbO2fR3r1KELe/v39QUBACMYSxamq9OjgkLiVddKCioOxAfun+ XmJeSVlecSnS3KKS1MzspPRMUQnJLmz1jIxfdXTkFBSDhl6luHRfUSlSonp+yf7z125m5xf11KuT 5y4UlB5Alc4IVjmFxcgUHSgvKT/Ew8tLEHsHBB09XY3yHrtaXJqWsy+KTOGcMYOowlxg1vYOaOhL Iy0pAwGa6+4f/iyYM3uR7F4lTw+vYAZgdyPO1dDQ6GV1/7CI1Ny85Ozc3mNSVg4tMzshPTMkmjRv 4aIuDCdPnXrwxGnwTMzIBjHSRKyKrByiIvJp+/Iv3KpvbGw8zYBTnwNK7rQ8jU9N746U5NS45FRk UnL2bdhEj/IGDBxITc8EQ7Bl2U+UowOU1LRNPFu6j11MSvoLYye6nZCRFU6O/2ci+pYwc8Y8GWkF dzePsLCw8PBwHx8f+EgqKqp/WRErNj4+vvldByU1g5SU2nskJ6eRktLsXDzGsHpUKrlX7kj1+eiE pNjElJiEZKTMikQJMjG0ZHJyelJ2XnpBcXbx/pzSA0iBGYUl1PTsKGpiGDk+Ii6hC4bHUUNi4sJI 8WC+ZPkKtMXBOQN8YmgpwO79RCFajKYl+4dHsTRqIlLSmUWlLMdI7yq9empUfKKKVo8PjH4YwAcj hsDBPlNGmu6ZI7xCWIoNDl9XXl7+y9U5OTnPnDnzpK2DlJweSUmMjE/qJUZRk0nJGUgH9fCKkLmd AyU1CzzD4xK6cqYkRlBoSEPJ1OAYcnBMXCgpHmQRDOIwEjWMTEUmJJYSEkPBpc6IQtAHRsYGRMSE kigzZtJvdfJs5S86UsmiIUZb9PL4JPBU1zVg2VV1PYO0ghLWw2d0FYimV65hfXvnRwLCKyK8nTRx qpiojLW1LYlEiouLI5PJggwYOnRYT3V37Njx5MmT01fqSEkZ0QmpwNjEtF4iKSm9oPxYy/sOZU0d lswjKUmkxHRQxtBYsEVbKA+PowVGknxDI/3CogMiSIGR5IBIsl94NBCZwG4YFEVHUPqGRHoFhYfG JhAuvZqOfl758WhqSve2UMIYVzra4t22g2VXfYIiEzL29dRPpFEJKWDOUon9YEBsS4Srw4f/Liq8 V1dHH4KmUqmpqalCQkK7du3i4eFlWdHBwQGha9nxanJKJjVjH4EJmXkfcV+nws7lnzApp/Du07f3 Wt+u3bCpC/PBgwcnZhUQDFlyoGXlJWUXKmpoT2PnYOOYPu1rEbXY2dnYPxxoDIgiZxQd+Lz/nw0E 0oxPy2afzuJG6NQ/2ZJzi2hZ+SyHSXQ+Li3bNyzqW4rtH8Do0aNHjhzZ57c+u4Qk5eWUKHGUxMTE tLQ0WVnZPXv2mJiYd6FH8FhYWAhZZxQcoKRkYyqScwoTM/Mx/8gghaTwEykzT1zqjPRLmfm5pYfp a+ZY1aQpUzs3MWz4cLClpGYTdZncmHzS8koyi8p3Cot9g+GPGZOSW5ySW0Tw74JEu7SMvChKCsub D5t4tx49ewVkxKC6Vs/MT84pSkjfp6Fr+M+7+k0A4ibeuNywnl9CXCY8PIJGoyUlJWH/CgsLm5l9 Ju6lS5ciFr7+4GksLS2KCscmk5KaQ07OjEvJQiYuJRsZIo9CXGX8JArh2eYwET9BgEx2SQUk7hkQ NnDgp5u0cCdCYmGOE2MS0ggygu1HzE7dVwoUkZD5jVXEPWfOnCU9A/GAkmvmTIJ42crVuWVHmV3q jMzOx9DSDUytWM6ekob2/sozRA97qJ6N6us2sXDpfwqMGDGCnZ196NChs7kXSojLurq4QdzJycnY 4+Li4tLS0jNnziIolZWVX758mV9+PCACpjAuJJYaSqLR09iEMHIi8sjQkUQLiqaAhiD7UMigYeIH Ynr1hPTCA49edciranbulbK2vldwhG9YDJiAG9HWh4okGikpq+bGfUsHt+7DgXv55ZvzKXkl4LNx Cx9BLyIpU1BxIjiGSvTnM4yFv0cNiqb6R5D4tguynD1HT38ItKfqKA+MiguKjvtj4qRvKrS/D7Dd HBwcbGxs48ZOEBeT19TUTkpKTklJycnJwdRJSEhoaekMHDgwMjLyeUdHCCnJ2SfExS/MPTDSIyjK PTACqUdwFDOPclwFjaNXoKNXkJN3MH6C4BMlExnERJpVdqy08tyK1euZvZo2ndPWzdfew9/BM9DR O8jJJ9jZl96um3+4W0AEuKUV0tWCv78/divoMQR+fv59+/a96+iIomWCgMkc9K7+Ya7+4S5+oegP GGoZWTAfAWibWAZEU1EO/izQJ8TJO8jFN5Rp6DsDjI5PaKyrXxjRve6IcnC2dGSxLH8iTJkyZcGC BcOGDRMUEJeWkkUslsEAT0/PjRs3Lly48MSJE6XV1209Ai2cva3d/JCxcQ8AItM5j9TS2cfc0cvM 0dPEzt3U3sMM6Ohl7eZPXCXomUhUBNp5BxefvBQQQ5sw6dMJhIXLVhjauJjYuZnau5s5gI8nEMzN nbzM6Tz9YlMLXnTatshTssscfUIJziAAWrn6Wbn4Wrr4WDh5mdh7GNu5yWvqj/h4ngqeKi5ZOnt3 buIzdPAwd8BYPFhG3DNnz3MJiDJ18DDtqS5Se89d4v9b5+vGjh1LvM23cMEKaSkFSwurzMxMqHRn Z2dePr6bzc1B1H26lq66li761u6Gtl76Nh4GQFtPOjLy9EJrdx0LFy0zJy1TRzUjW2U9i1nzFq3Z tFXL1EnPyoUgIyiZ+KG6rSfqmrsE5Z24rmZoM2jwhzuNXFxcM2bNVdA2UTW0Vje20zS11zJ10CTQ xEHLzBH9IRgSTIiMnpUbynXMnXUsnLXNnTRNHTVM7MFWzcBGTtNk0bI1nQU3ccqfGJemiT0dmcw7 oYaJg7qR3U5xOZbztpZnm46ls8aXqttrGNvNW7ziR0ix1zBq1Ki5c+euXr164sTJ0pLKcnJKISEh urq6Vm5uh+reGrmEKOhZK+jbKBs5KBs7KBnZI1UxdkRKL2EUKhrYyutZy+la7tUyl9Ew3S2rOX4i fZ/2HzBASFpVTtcKBJ3rMpEoRAapoXNQbGEV325pVBQXl9y2bRucimHDf1++nk9EQVtCxVBSzVha 3URaw0Ra01RG00xW2wK9UjK0I5DeB10rWXRA01RK3URSzUhCxUBMSU9CWZ93p+R07nl9+/XvMvDZ C1dIqRmJqxhI9Ij64DN/+VqW88a3S0pC1fCL1Q32apqNGvvH95bg1wKc8w0bNkClr12zhX+r4OIl y30T84OzTu3VcxBTNZXQsJDSspLStJLUtKRntKyRfshrWomrm4NGVMVYWNFgt7zeBgGxIUM/nXQa O2GKiLKRmIqJpIblp1p0Dkz8UIjUwDXCPjxr1qKVAgICUlJSlpaWGhoay5cvHzBw0DSuuQtWbFq3 XWybuIqQjKagjKaQjNYuWZ3dcnq7FfSQ7tyrs3OvNnFJQEpjNd8u7kUrJ0yZ1n/gQGZnuujk8ZP+ nMY1bxrXnJ5xLjv3/KEjRrKcNDauOWwz6NhTdXauuRzcC76TyP4JjB8/nngDd/SoMdO4l8SUX7cM ThVVNxNWMRFVMxfXtPyIVkjFNOiIvJi6hYiq6R5lY2Flo53y+kLyugtXbeken85dvmGPkpGomhlR kVGXBYppWICndXiWhl3g+MlskpKS1HgqhULR0dFZsWLldHaufn0/BGuDhwwbOWb8JHYuYraZOGU6 N8pHjum6m/ow4EfM4/8fmDZt2vz587eKSGWcf67jGimmbi6uYSGJ3adjI6Vjy0Cbj0j/iUsggBBF VU2FlY13KuhxcM9nyRluMJ+YMhhKaFp9rG7zOdoyecoaOvmkHMVC2rVHJC4uLikpSUlJSVRYQlBA ZO7ceYBx48b15klib0SMiGMYA4Z/BJbHtHrZVnfoQqampraPAc5ubj/9YSgCcCd//7IbrwxcghWN HJVNnVXMXJEqmTgh7YwoUTR2VDC0kzewldWzltG22COvPXbCl0LLcRMny+rZyBvYoWIXbp3ZEo0a uYVTyy8Lyajq6OpqamoqKaoqK2lv3MAH72LWrFldzoT0NLe9gaysrOZucOfOnby8vE0fTz58Q6Ak Jp69fPnClSsFJSXfQ9ts3rwZsbOCggLs8pcpEYsdOnSo9OIDa+8IU5cAY0dfQzu656xv62GAjJ2X 4Uc0IMptPPVs3LUtXDTNnIRlVIYOG/5l/oA1m7fqWrsZ2DJc+k4MP2Nr64G8iUtAaGrxvlM3N/IL rVq5WlFRQ0ZaDfMPcU+ePLnLayl/G6BzDh89+rCl6WFzU3PrU2DT0ycPWpobGh8SkZ2Xl9c3aYiA SZMm3W64V3/3zu3bt01NTb8hZwKgqcAZ3X78rNXMzOwLlFgMDQ0NB2tueYbFIZB09A2z9w6x9Qyy 8wy28wpGvguiEJcQTVu6+m4VEu7bt+upRZbQt18/NQOLnnh+4OxJ5+zgHeoRSq68+iD/yLlZcxds 4xfZwsMrJCSE8KHLJ1/+CSD8bGxsfPPubUtLy4ULFyorK0+ePHnr1q3W1tYXr+iHITEnMBzfqjlY Cn5+fj4+PqRf9WGTXgJsMXEO/N27d3C5eyITkdybnF8WQU0Jjk0IjKL4hcf6hEZ7h0R5h0b79IC4 5BkU6RoQumzlV7y2D5jKNs0jKMIrNKonzsym0Y3gWFpMUlYImTZ6zFhsbfjnCB++4Wlt+KUdjFce amtrubm5wXn06NFTp0718/NDYXt7+9OnT7du3QpKLDMU+vv7E7tSUFAwJydHX1+fyap///5YjSQS CRry4MGDIF64cGGX5sDEiQGKiopdLsFlgiYpKys7fPhwTExMT58QhGYzMjLKzs4+ceJEfn6+jY0N 80PxWlpaKCGU0uvXr8PDw9FbUVHRztUHDxmiZ2JOSUmPjE8II1GC6c+Co/zCIgn0D+8RAyKiXbx8 ODg50TH0/6vMnOAe4S9wBjJbD4qMiYijxqdluvn4YUKwer/tSU5ra+sOxqs9kFFnS4p11dbWhp2C XU+I29zcnJhJaADEhh2Mz7cy30WFbkT5h7PlH19nwIIxMTHp3BzxlgrYlpSUMAvhFvr6+jI+DNtO pB2MFytUVT87R4TlpK6uTrya1M4AopWzZ88ingLBtWvXOneAeDXD3t6+y5AHDx7MMZ2Tg2M6O/1B MMc0dgZyfER2duLR8KcSBs6YOXPlypUIlGxtbSMjI1NTUw8cONCdOUtAz4mGurPtjugVB+eMhYsX c0yf/g3VOAGlpaX0W68vXmDCf+sUku/YsYPYI3V1dTC4KIHnRkwmXfm/eYNpR4b4/o+hoSFBjBJo CVhPLBLidSrMPLFaCKDRaCiEpfDx8SFKsDdhPiCaR48e3bx5k/iWIFgRZGxsbMy6mZmZKHz+/Pm9 e/fQCpzJpqYmEN+/f19cXBw+NjxM4vu0qI5L6EZ9fT20UC+nAhygOqCRVq1aNZOLm49XUEhQWEho l5KSMjYFOkylUsvLy6FVEFZAvSCFMoEeO368En0Dzdq1n92JwtrArGLIYWFh0EjwHqWlpSUkJOB4 W1la2dnZOTg4wMFgHKjYwrOZb8sWgTlzFmJTz549G5buG9pQAsDwZm1tO0MowsLCzPKJEycWFxfX 37lzq66uqIh+zBWe4cUrVx40Nja1tDQ2NdUxyslkMi5BgTPed2jA/EdFRa1btw4d1tPTq6uvv9PQ 8Ki5OTc3l1hFCLuqa2qaHz/GYsDYibbc3N1R/d6DB9jv2KSIAaEnb9+92/LkyfOXLxF+/sZYhNa2 tkQrV69exRTBLq9YsSIkJKSmpoZ4P3HkyJFSUlK19fVPWlsbHjzw8PCAoDGor/pPECxsdB5LHVpr 27btWhqmdjYudrZObm4ekCx8Gwz84cOHWOrXr9+A0cHQsAsKCgoKCwsxY6UMKGPA/v37kaIQqyIl JQVzFR0dnZaWBgJUPH78OJRDVFS0hbmFnq6hnq6xjpYpH68ALy8vjMWMGTO+x3fOly5dWllVdbWu DuIOCAjANEJLQ2QQx/7Dh3MwjLKyVYwPCi1dvvzY6dOHKisrjh3LLylBIfE0DXo4NSurrKICqKnz 2REsfSOjw5WVR06cOHjsGGGAZs2Zc/TUqePV1ZXV1VyMd4GXr1xJtw7V1Wio8+uW1vb2J8+ePVlT Y2lri5/TOTnrGhpKy8vRq1WdPnCEPvzZaftPnDQJzNHPoydPcv3dd43hGmFaoC7glmAzaqgbhQbF hQTHREbGZGZmXb92Hc4M3Y998QI6BHKvra07deoUdj3WAyF3bATiw6cAQhtgnUAdQQthqUDtYF+g PDQ0zMXFzcXJw8XJ18TYUXDHLhERESx1RNmEOv3msGEzT2nF0bScvOKKI7UNTe86Oi7erM/IK6Sm pMfE0yJIlC38H77zs0dcvLzyVGo2/Qg0D98n5bxhE8/ZKzeTMnNjKIkjGQ4kM/xfs259VkFx+r6C pPQs4hL/jh2VNedREhZNGsi4jWNiaX3y7MUjVTWYELh22K3Eke9DJ6tTc/JSs/NVNemvmkrJyFee vZCcmeP8MSpkeZNhCx//6QtXM/OL42jJXzhe+JcAB2nRokUCAgLQuvAWZKTlHex8oyISYqLiyaT4 stL99XX18HZeM75a+57+bxNthC8BVwE7BTYFKcRK0LxkADIwQzBYVVVVcXEUP19/H+9AX59QT7cw ZSVtcXEJaP6NGzd+P1kDhCWkc0rLQ2MpQTHkoGhyQFRsYESsX1iUd1C4hp4hW6fv/Kho6sQmpYWS 4rUNP3O9tPSNcvZXkJPTlTS1ujAX3CNCSkoLiY2zdv7wpFtT3zghMzeSmqSqyTh+3KePo6dvFDU5 KiE5JjEN5RH0M6uJ4WQERyR0A+mqdfSn/w4ePrSsPHJKxjbBnV8YjqqOXmJOfnRCsn63w2ZfC4hN EERg/mVlZQ0MDGBTFORVfLyiSDHJsdHUeAotMwOhwcn6+tuQY0+vABMfr3716hWkf/78eez7mJjY kOCwwICw4MCowACSrra5hISkvLw89jWMIBcX13f9rworZ/fohNRQcoK5g4v4XgUJWQVRKdkt/ALd jzFYObnFJKZHUJI2bP7slKaZnRM4ZBYf1DT87J7JgAED0ov2h8XRwik03m0CKOnXv797QCglLQd8 eLbSlcaAgQO9giOiaWmUtGxFda3dohK7xCSFJWR2iUhsFRDCatkpIj7i95Fg5RceHZeanZCVt2PX np7Ggs3u7O1PSsmkpOcI7OyR7KsA848IhZ+fX0VFBUKXk5PT1NAP8ifHxabFkZITqKm0hJSMjOzD h4+eOVNTe6sWlh2KGp4kXMQbN25cunT5yJEj+XkFZBIlOio2IiI2IjwuMpwaGUYzN3USExMnPqUL BQ5lwsnJ+c398M4ABUtKziCnZMYkpS9fzfrhJgHDh4+IoqaQU7PIKVnzFy7ufEnXxBwb82L9w8fP nmFmiEIE74hTqOn7omkpAVGkQYPop+hHjxkLDsm5hZDa7Hn0xwp9+/XzDAxF4eGaS+s/fzOlc7CM KMbdP5iUlPHodceBypNMHQ4X2tPTk3kgZ+iwYaGx1KzigzU37mBX0kuGDv3nn4yAKZ8zZw58dTiE GhoacLCVlZWVlFTMTa2DA6Jp1JyE+MzEhAxaQloCNQXST6RhDWAlJFHjk+LiaGRSAplEI8UkxpFS I8MT7Ww91FS04FJi5cBF37Jly5IlS6DAv8cdpy4wZ/7C8LgUr2Co7sg/GLf6e7rrPnP23ODoeG9Q BkeN++MzbbNoyXL3gHDvkOhXHR0wTPD3YIIRTwXHJngFRzp6+KMVgpKdgzOKmg4+/uFk5qE1JQ1d z8CIQ9VXYddcXV0RaCOcuXTpEqrvFpXs81FYO3YJewZFBERRoCHh0zo7OyMmgt2MoWUoa+r170// YuTYcX94hUSHxNJeMr4U4RdO0jGx7OWtzr8EWPN58+atWbMG3j4UOwJPyF1NTU1OTt7MxMLJ3jUo IDKBkpFCy0lJyklMoCNWQlJCTmgw2dPN39rSXl1VU0ZGBksFigJ+IB8fH3YHAq4f9hckvNt3mjq4 G1k7K2sZf/lRxUbe7aA0tnFR0jbqfnWPpJyBlaOZvbu1W4C9N/32r6WTt4mdq5axFRvHp0Ppq9Zv DqGkWzr7aJlYEy+tAyZMnIyfhlbOZvaeVq6+1q5+5k5eRjYuRjau23aJMns1bPgIdUNLQxsXc0dP xu3lEDuPIAtnH0tXP7G9SgS330eONrFzQ11jO3czJ0+wEtjzDY5kdwYODg6EaQgAN2zYALnD5urq 6kL08OHh1CkqKsoyQFNDE2EmhIstjLWhzgD6A01RUUgZcRZ2NDRG51sKPwA2btu9S0ppp7TK8vWs X5pgwnq+naDcJaO6fB0LykFDhi5euWGnlLKMpomclrmcjoWguOLSNZuHDh/RmWynlIqykb2CntXm HSKdy8dPnLph604xBW0pVUMZdWMxRZ3NAsLsXF2/FjVm/IR1vIKiijp7Ga1IqRtvERSbMefTXfE+ ffouX88jLKcpqWogqaq/Q1xh/ITv9Wd8sLPY7MuWLcN+5+HhgZ7HhoX0sXOh8IlvXkH6kDhEvH37 dhgXmAMYaEgZa+anvPLc+4ePfXphAfv26z9i1NjR4ycOGzGqy6U/prBvFVexicjao2S8W8n4zxks Pvw1eMiwUeMmjBr7x8BBX3oCPnDwkNEMskFDWMdZqD7899GD/0EU9lXAzs7Ozc2NLY8Ni10Pma78 CPgJdb148WIsjJkzZ3b5jtNPgd4/Iv8yZfdLzBLMv5S2pZFHlJSWpZi6iYCkav8BA79cvfdd6g3Z j4fJkyd/v9j5fxzG/THRxMlHz8ZN28JRQct40q+PPf6rYcy48bvEJAR3i2zk4ftfeP3zF/wX4P8A 1crmYQ0KZW5kc3RyZWFtDQplbmRvYmoNCjEzMyAwIG9iag0KPDwvVHlwZS9YT2JqZWN0L1N1YnR5 cGUvSW1hZ2UvV2lkdGggMTY1L0hlaWdodCA2Ny9Db2xvclNwYWNlL0RldmljZUdyYXkvTWF0dGVb IDAgMCAwXSAvQml0c1BlckNvbXBvbmVudCA4L0ludGVycG9sYXRlIGZhbHNlL0ZpbHRlci9GbGF0 ZURlY29kZS9MZW5ndGggMzgxND4+DQpzdHJlYW0NCnicxVppWFNXGs5GViCBkEBYEkLYCcgSIICA oLIngApYqMUFFEVc6oIoKtuoqHUXneLSmQodx9FqnVqBaltq1bYo6gMiIFAUBESsiIBAljkXErnZ WJ6nA+8Pntyz3POe73znO+/5LgjEODDnWNlYWbCMx2s3PTAwtnTxnRsSFh4hiAgPDZnj48g2ok43 KQXoMaw8ZocLIAjXb970sRD6FRbgyqaTp5uaHBQjO3/AcF7O1w9apSPoabh5LEkoCPHi0HSnm94w 6FZ+EYIF+++LpEp48e9kYaiHucH009Rn88MEMed6lRmOoCJNGOxmpkecXo40u7mCqBNd6ikCiH9I Es62oZKmkaKusUtYZF6LRooQBq4sDHGgTR9LMtMnIvrSmBQhPEsNm2GoPU0cdc39hfH3x+UI9nqW wN1oeljqMP2Fqa0KbCSiof53PT19Q0MiCbxcdCrKnT4dK04ymSlM74Ez6W2v+uHi2cP7DhSeL6n4 o6tfDKu8GuVqMA17nOYuSO2GUWyrKM5KDA/w8XT38PabG7P2+I36Lpg5iyId9PBTzZFsE5bY/oGC uP324cQAVzsLUxpUacq2mcGP3nm99vUoy+MhHF3c1HIkMQMXVHwg0Hf/9KpgPpeio4UcbWLjEZ1X VvPhHHq/LcLGSA+AQiaip4YklRf15QeOvU9vFJ0qyM/fvc2dgoJNxMZrxcXHg/JWb6+cOrQ/Pz8/ b8McElLzm/86kNghKf1qgs3dmdrw8a2CDr5WbfQsGj6V/x+o7gsq1XCUSs45Yj80QhLtc9+otmnY 7KIzFSSJrKAsdRyl0v4tZnKHQ5G9igZUGohr8uaa4KdiuSlOMdXqSUpfzNMfYYCih/2qWj1UkRdm oTMVGwfPCNguD4E9yjTuziQClkiseXKzGkOXbpppQpgSjyRZRf0oG7X9J2WvE5+y1UIgSU75b1U5 SsrXexhip2RrI3S5S2QGlJzMKlbWu71rjDF6vpeG1DnDjWAGHonCUwyZbDaTro0Zly+GSKHoUYiY yZPU5x+SDfpsZVDSFWU6f0Tbzn+gjqJUWh/p5DZLuHpP4dVr1745tmP+bB6bLHNQJM7EzX+Wr6eb C4CzHYOAROtyvAWbd4H4uyWSz5pkbMUzwm7KBt0bwOKl3JEoUfn9cJt6jtLBM1erO2HCo7uuZIOv KQ4aH228reNlZ+fTaghVlflshntKWYssPIiefx1ugh2XGQwEs4UyhTYUY02muGXUKlGRqMZ55XnA 0Hbcmwq2Es7jF3jpDwm7axSudq8zOVqTsSRzqWyFG3xoRIyBX/5LzRRks6kWj1Fb8xEDjdCJfgEv +/2Rco/eVYaTCAsETqasX6E1CYfEGof+/d3YHN+V7O8eq/7lx3Q0PVUh8veptqr2mYSKItqelHWb T9dCI5B489hLg6rvHMWLL9LSXsGeRR33fr7fAbfUE39ty6NjzhNgIJEyYY4oAveCrJvvcFxGkWyX l2teTtGjvTHCYphTDpTvT01cfQzuyZIsFv+mckexsiPnmE54h6PwM76VvdoTMdwLTXbZVKOJY39Z eqB7Onz1ftvgZ2thLzgL3xf/9RA0KHSTdFXc+KVdoUh6xGLCTonEOn8vs5G7rBOG6rOrQz3HrqJk HjscTqDv0tqooNnBn/wDTrI8dLmC14qfnEhLWPmloq/v4Ux852AcZCTFfLkSx5rEXVVVPKBF/ZEF tlTrI/CFE7193QnQpXBs3o7LUVjc57tD7c2d1ytcRge3MCce0FE28uX2xcmmhrPeoBBA5K+9szPI XJs4q05NnSJ+WnZRYXJfhhrj0QbxChrl1QrGxH0SaSHfOKGk4TMNSXTIVaPApZKKrT4MPIqcMGb8 Gca3ax/BH7vTrcAxpPexQgB+FKU/YUOicQx5CFqhh0FB6tb7K/UhqDXFHIxFWzvGeSObzpF0hU3y 9CM6EoE0SnsPLzzvNfH8Akabki7rdskUh0ZgDAUVUg0o9cQjkGbZ8KL+57WPlXHv6xU7FFz6O38d MHnrU/CywRybSZyLenSh7Fjs4Gpr4TipmtNqQ59ZYpDm+fCi9sKNaWlpa9Zt3JIhx5ZVUcEn4G3E +7jgcMF634UXvlppMoljUY/Fk+0SUTBd3/WwhgTqMLqXG6KZmfBI/2w9z9bWzjVy76kzMpw+vt55 tkIof7OOCZxdO+o5vLBq3sRdEoHQMXcpl3XcywsvVUlDK6AhXM9kLTza/LnJlmxgHVkCb3SeK1QI 5Y0f0cA+piYrHOBf+0wm5aXN5h+UdXyZPW50+YFvGl8JL6grSNxapGCj7jTnZQoBoCwQuKSSmwzl 2U5KUJr4xMiPApV7mArEx72jzqjRNKPoKw5z2Q4PAJLPHIFLYtyuw1t1rTad1AWOylt4R+OQPcqK 913W4twx1KSko2gJl38eXvR2Awu4JCG4Hl74ZMHkvl1RHBbs0hD6xHWXbynfedr3PtRIcbDt+u75 tjQvBVVeHwe5pE40XN5J/+MzyVyxWcin9VJ1GCjfmbhVhdKzD1NQmNrAm6afi7IT+ExtkvPnVc87 ZHhRc9QLuCRCN7C07oW88PmDFKtJuSQCQeOvvaLOlN0XV/KtffNeqakarn50+37N8/b2jo721tpH JcWHtiSGuJlTsCis2dzUrDyAXIDtKYGmkAQnWkWvz86VISORR9Vhubrb6U3YMVGumU/UkGj9PJ6r T2SEn1N/SA6V7U1JXZORBcbMzly/PDbY25FN14aElBYzIi1j27ZtGesWhXi52BgRISZaZJaDq5sM Thyqtm1xY1PlTI3pYiSOamKij5NrEIxxcoMqB1HVXoGlDhpJ4CSpPyarcoKdLGydXMCYLjPsLc3o ZIIsO4D3qns/AKG3+fMABlFr2FpIDI5IkoOIx1CiOsGdMVLjJ1UtTs6FrzYzRq7xSIJNuhqFO/Bj xixT4rDe4OV0quHYc3a+CRmNJQyPTMBhUKO6S/+T0VBW6aneVkjDjaC2JoKiyZDkBSAu3nQY9lyk jsdpNfnTd99tDKSP2BpjGPZP1QUX/bTVlab+/SjW30BEkIiHA9VQuinNyp5lYGJnro1CEoydvPh2 dCwSgTJddaeu6piXDhJrYOfJ58pySmgyh+fjbknGaHuclEBfOdgEKKMX/LOaPdN3fU88j0UfmROe s0z1G1Tn6blmGqyAcb0GOLZU3K2Fgv7lWWvu3ruacLruAkebFfbF47bWylwXXSTGalftHxVLLAh6 7tkVLW1V+1x1gJrTdki90fSyuTzR2vVaB/SSqiNMIE3cKtU63ODpOGGQr6sdh23KtuIlnFIRwX2Z 9poEAiEY3BwH/7V2xT7oOle69Ffge0ADX/f1KRhRveIfvXXwfBBLX8cxTGMfDBtJUuJGQBuEloys WXe+PD1ewQMXBZsVF249qH78uK7xxZt+uE17v4sUCAThEKIWZf6nXqFysKNsEVuT+Kd88iew9Gae 45IH0M1hK/BoSLV8sbT8Q/9iOz0ow/Es1iYJ8neoWrzDlCZokjf4br/sx3U+2EMGzsJlqUARpm3f e76yRVECDTRe3S4UCIQFt18qHoRvHxYudtOUhEaa5gGXrFnjO/cQsH/fvqPDR9bAq4M3oKk3N0IZ 0M5oq41AplctnPdYKn1f//sLYIFf/OYAe0v+bGjuFVem59SDIftb72fYA0cl0ljWtsMIiM0ufaru jqgMSVvp9nBnHU1JRgwX+tLb9vC3Wmjpft9aCnVpuXLgOFjArsv791wCCmkoc1YRKP52MbheDT0s /nspUH9Ny46Dho3nduWfubApPAESf9VHl/sYQvNGYbSwI+D4pF6qHl8HDT79d5IbEx5yFIHzvT06 n8acVMgxW48lLgE+OHQtydf/UyAHRfkLwV4cPJoG1nywvbmpFZi1OQe4cm9hrJdX4BxXayGoF/0z 0pZGUHo9yyW2oKJDbU53dNie6sIYLkMDQQik0eRF370cwfI2aGihUwK4mnVlu+gzEppAhNu6Gmze rsytsHTBvcPgoTnNmqxLNdClLgD032yyJmJUzk1Th7mZZY1vxlBi/S03c8JsDcfgiNBf/Cf0jfft m/bKs2t8HVcBH2xYYWG0CJR2rmPhLLaBZa9dtRP8rUvNBe7V09HS0tr+sqng6CB0rzTAURm6aGoy YPw0nq72aLfyjDtwq7lXg3IbaLtzKN6DoyGIjwDF3A22X/s3p47krgx1oFtBu+hWCMXgY6BTxJci fTeBe95QYdwxMZRZ3Q6Wue36l0X/ffTVtvi899AH/8DZud8H0Zk7AOPKdbMM1X5+MbOfmXiioqN3 SIWnqP9lxcnF3nYmY1EE8WI4lN9InuPtam1IwjtfAU9FbnhK2D3In2uqgIVE95IjLoLi4rBVwLzi Zw/r3kmrYnnJUBbm9cOnYuljX4djYPze1mo3DTlMFtd/6cGS2s53olG9KBH1dT4pObjMn2s2NkUQ yoOegqiyh0cjk3BoJH420Ff9O6wwROc8+Z4U3U/3EYIQOrDLI6JEPkRNMDOwWO5nTQLnw8M/qv01 3tbYjvzQ5fsuVz7r6ul7P/C+r+dVc+Xl/OXhXlzmeBTBvS74j4HBpkWMEW8izWkYGGxMMEJhjIVF r6A9+b7z+ib/GSvB2dO10pK7+s47QFP0pmKdkx5n2Y894EHc/WgLzy6lVSyVdJ9xH+tKyeF6zFm4 OutAwdlzX5z4bGdafBDPnm00PkVAa8aagpOfepBHIhRxRtrxE+vddZFIkuW83Zd/e3Drq92L+B5b fwVsHkTSqe4pJ2/e++1awRo/IzxlxtJj31feLyv8NMDEaGbmN3fLDsRYjPPvCeY2jq4efG8/H767 C9eaOdErCZbm6OfnSMPKn7h+flzoCa3N8oxauuKTCE8OewmUFBo4yiNhqbYBHyUnxc12NCKgtPSs /WOTkhfOcWIQiQz3qEUxfhzdiX23NB4rJqoBCkc2MNDFolSeUDiKsYWluRGZwNoD7aHyBKYWEkM0 YHI4ZgYkoJeRaCLVjMNh0khaSBROz5hlakAc/yPbXw1wumHQKASaubm+/fm3q510IQZINCiUU4E9 IFFojYfaFABNm5manRHnrD+xT4z/A1P+MbQNCmVuZHN0cmVhbQ0KZW5kb2JqDQoxMzQgMCBvYmoN Cjw8L0Z1bmN0aW9uVHlwZSAwL1NpemVbIDI1Nl0gL0RlY29kZVsgMCAxIDAgMSAwIDFdIC9SYW5n ZVsgMCAxIDAgMSAwIDFdIC9CaXRzUGVyU2FtcGxlIDgvRG9tYWluWyAwIDFdIC9FbmNvZGVbIDAg MjU1XSAvT3JkZXIgMS9GaWx0ZXIvRmxhdGVEZWNvZGUvTGVuZ3RoIDQ1Nz4+DQpzdHJlYW0NCnic hcKHUtoAAAbg57K1e9s6URFRBJGhgKAQwgozEPYeYQuIgAytdu9l28fqH+Odd613/e4bmzSOnb+G U3wT//o0d5xLjM9cvIGzxE2umX9rDkmugLwtIO/gvAXv8hes987fX0TbAyHf/nCJ+0iEDny8jNQT MXdC7JxYcT5dRdczlLgmJe6pNfRMS7kzMu8srvtwTu4TyGnBBj2v8OOCMoCLqoBQxQjVzJI6KNoM irZCy6gJizXhFW0EV3VRlGzH1vQxqT4uNcRlhoRsJ7G+m0S5MbVhSilMaQWRVhIZpTmrIrNqMqe2 5Dat+S20FTT2gtbOah2szlHUUaVtqqR3lvWussFdwR1PdddTNXprRl/dhPQegf6GOdAgA02SaVqY ljXYsob2baG2Ldy2Y+TAEelQ0Q4V6zox3nNh4tCNyb4HUwNveuBLD5HOjOjsyI+5owD3mMkfM4Xn Qe5JkD0Jsaeh4mkYSy8iWH4ZxQq+imH1dRxr+CaB9bdJ3MN3KWzg+zQ28UMGW/gxi/v8T7k2/3Me D/hfCtjhf2W7l4vdb8XexVLvO/fwcrn/46+V/lll8M/hWXX488q14a/a6D/ro9/1oyv+AajcmCEN CmVuZHN0cmVhbQ0KZW5kb2JqDQoxMzUgMCBvYmoNCjw8L1BhdHRlcm5UeXBlIDIvU2hhZGluZzw8 L0NvbG9yU3BhY2UvRGV2aWNlUkdCL1NoYWRpbmdUeXBlIDIvQ29vcmRzWyAwIDE1Mi42NSA3MjAg MTUyLjY1XSAvRXh0ZW5kWyB0cnVlIHRydWVdIC9GdW5jdGlvbiAxMzQgMCBSPj4+Pg0KZW5kb2Jq DQoxMzYgMCBvYmoNCjw8L1R5cGUvUGFnZS9QYXJlbnQgMiAwIFIvUmVzb3VyY2VzPDwvWE9iamVj dDw8L0ltYWdlMTA2IDEwNiAwIFI+Pi9FeHRHU3RhdGU8PC9HUzI3IDI3IDAgUi9HUzI0IDI0IDAg Ui9HUzEzIDEzIDAgUj4+L1BhdHRlcm48PC9QMTM5IDEzOSAwIFI+Pi9Gb250PDwvRjMgMzAgMCBS L0YxIDExIDAgUi9GNSAxNDAgMCBSL0YyIDE0IDAgUj4+L1Byb2NTZXRbL1BERi9UZXh0L0ltYWdl Qi9JbWFnZUMvSW1hZ2VJXSA+Pi9NZWRpYUJveFsgMCAwIDcyMCA1NDBdIC9Db250ZW50cyAxMzcg MCBSL0dyb3VwPDwvVHlwZS9Hcm91cC9TL1RyYW5zcGFyZW5jeS9DUy9EZXZpY2VSR0I+Pi9UYWJz L1MvU3RydWN0UGFyZW50cyAzMj4+DQplbmRvYmoNCjEzNyAwIG9iag0KPDwvRmlsdGVyL0ZsYXRl RGVjb2RlL0xlbmd0aCA5NDE+Pg0Kc3RyZWFtDQp4nJ1WW2/iRhR+R+I/nEd7JYY5c7NHQlThsumu FInusttKqz64xCRUi02NSZX++p6xTWJjTFAegPFwbt8353xjGC5gNBreTT/NgI/HMJlN4Z9+jwNn nHMUggcQCA5accjifu/3D5D0ewgPLzacG+SqYbT+0O/91u/B/G4KUEuArwkGla+2JqhyhRLxXC4h mbVA2cAEDLkFbTXjCIIZYxBW235v+GkbPcTIDcxSOJdZVJmHt19FAA/7CgLakIXCxbVBCBLpV4IM kQX6BUgrlmzRJJRCdaZ0l00V2YaLKM/jLIHVnkKhtLBfJc5fiYCJwpWyGgJwiT9VZZ4sKeJHCQRl uXZQHDkIhopRBMNYhhaW23oB3MGlR5TV422/92PEZTAZ/wnLz/3enGKWcfE0biiID1GP+8P7I078 puPRGoVihK9hDV22krdsbw65L7106w/oO988xR2+guAK052nxZ4+ZU81UFoqBQmllCys4jl+1Dl+ mp7Uk4woq3sSP/5AeJ0cKcOkbnp0cqSLdmzYLrKUOPq7yLHKwVfeJoH8MYY4yWNHXJZHm6SgkHbA t96q2KZ/M+cDvvHSNTynhwxWUfZLR2ojOHNz0VVmi2JzVYMKmt9AvlJ8fQvWPV0L3i47SVPMyKb9 xcqDq5rD9ZzS72mOuqf3fZPlh+jn5r/4Hm4X3+j4YH/Y7VJaZHkHIqlIBpthLgIKW0fB+Elpx+MQ wg3SG8fR8j4eSc3bmz/FievGuzSLqUHh5sudA+cPlPf1sKPlLu0GqEnVTTPeRYT2qiPD0DAbdh/Z yTk1zbmacAwMSbzkOA1oPeM40XRXTcs9y8dqxBHnxRbSbrUeDyRl07o007PLYUJLNjduvwhHpi7M i/sUy79xPh6IUZnquH5NSfb27X7UxK9pwLzMMvKrZhpVcZO+Y6brnt7i+69Ft+zz6K/Nz03+DFFy 7zrJ9Q5pl/TWaaFv2yhZdd0Miu7xk5LewIjXtRJKpsV7pr/u6S1Jpwsxjv+Fx2cnx7tSlZ82e3fz ZbBN72Mn0XkKDwQ8LhT+McruS213nHTdFlopJpqleuto73S/Q+M5Z6FpOlwmS1xFVhAya97DVc3R m6VbusfA1x4HoqYUSdktkiJUTDciXIYiG1DoknVT0RbJQIDS5viaUb45Vi9QXNPs2ZtyxM3H4kMz W4w/V6oc9XJey32aWU4qTuM/lqOjKowHelSGIXM38vTmXboGupKC9miLc+UqaZlU9XLPcPA/YGl3 QA0KZW5kc3RyZWFtDQplbmRvYmoNCjEzOCAwIG9iag0KPDwvRnVuY3Rpb25UeXBlIDAvU2l6ZVsg MjU2XSAvRGVjb2RlWyAwIDEgMCAxIDAgMV0gL1JhbmdlWyAwIDEgMCAxIDAgMV0gL0JpdHNQZXJT YW1wbGUgOC9Eb21haW5bIDAgMV0gL0VuY29kZVsgMCAyNTVdIC9PcmRlciAxL0ZpbHRlci9GbGF0 ZURlY29kZS9MZW5ndGggNDU3Pj4NCnN0cmVhbQ0KeJyFwodS2gAABuDnsrV72zpREVEEkaGAoBDC CjMQ9h5hC4iADK1272Xbx+of4513rXf97hubNI6dv4ZTfBP/+jR3nEuMz1y8gbPETa6Zf2sOSa6A vC0g7+C8Be/yF6z3zt9fRNsDId/+cIn7SIQOfLyM1BMxd0LsnFhxPl1F1zOUuCYl7qk19ExLuTMy 7yyu+3BO7hPIacEGPa/w44IygIuqgFDFCNXMkjoo2gyKtkLLqAmLNeEVbQRXdVGUbMfW9DGpPi41 xGWGhGwnsb6bRLkxtWFKKUxpBZFWEhmlOasis2oyp7bkNq35LbQVNPaC1s5qHazOUdRRpW2qpHeW 9a6ywV3BHU9111M1emtGX92E9B6B/oY50CADTZJpWpiWNdiyhvZtobYt3LZj5MAR6VDRDhXrOjHe c2Hi0I3JvgdTA2964EsPkc6M6OzIj7mjAPeYyR8zhedB7kmQPQmxp6HiaRhLLyJYfhnFCr6KYfV1 HGv4JoH1t0ncw3cpbOD7NDbxQwZb+DGL+/xPuTb/cx4P+F8K2OF/ZbuXi91vxd7FUu879/Byuf/j r5X+WWXwz+FZdfjzyrXhr9roP+uj3/WjK/4BqNyYIQ0KZW5kc3RyZWFtDQplbmRvYmoNCjEzOSAw IG9iag0KPDwvUGF0dGVyblR5cGUgMi9TaGFkaW5nPDwvQ29sb3JTcGFjZS9EZXZpY2VSR0IvU2hh ZGluZ1R5cGUgMi9Db29yZHNbIDAgNDY4IDcyMCA0NjhdIC9FeHRlbmRbIHRydWUgdHJ1ZV0gL0Z1 bmN0aW9uIDEzOCAwIFI+Pj4+DQplbmRvYmoNCjE0MCAwIG9iag0KPDwvVHlwZS9Gb250L1N1YnR5 cGUvVHlwZTAvQmFzZUZvbnQvQUJDREVFK0NhbGlicmksQm9sZC9FbmNvZGluZy9JZGVudGl0eS1I L0Rlc2NlbmRhbnRGb250cyAxNDEgMCBSL1RvVW5pY29kZSA1NTggMCBSPj4NCmVuZG9iag0KMTQx IDAgb2JqDQpbIDE0MiAwIFJdIA0KZW5kb2JqDQoxNDIgMCBvYmoNCjw8L0Jhc2VGb250L0FCQ0RF RStDYWxpYnJpLEJvbGQvU3VidHlwZS9DSURGb250VHlwZTIvVHlwZS9Gb250L0NJRFRvR0lETWFw L0lkZW50aXR5L0RXIDEwMDAvQ0lEU3lzdGVtSW5mbyAxNDMgMCBSL0ZvbnREZXNjcmlwdG9yIDE0 NCAwIFIvVyA1NjAgMCBSPj4NCmVuZG9iag0KMTQzIDAgb2JqDQo8PC9PcmRlcmluZyhJZGVudGl0 eSkgL1JlZ2lzdHJ5KEFkb2JlKSAvU3VwcGxlbWVudCAwPj4NCmVuZG9iag0KMTQ0IDAgb2JqDQo8 PC9UeXBlL0ZvbnREZXNjcmlwdG9yL0ZvbnROYW1lL0FCQ0RFRStDYWxpYnJpLEJvbGQvRmxhZ3Mg MzIvSXRhbGljQW5nbGUgMC9Bc2NlbnQgNzUwL0Rlc2NlbnQgLTI1MC9DYXBIZWlnaHQgNzUwL0F2 Z1dpZHRoIDUzNi9NYXhXaWR0aCAxNzU5L0ZvbnRXZWlnaHQgNzAwL1hIZWlnaHQgMjUwL1N0ZW1W IDUzL0ZvbnRCQm94WyAtNTE5IC0yNTAgMTI0MCA3NTBdIC9Gb250RmlsZTIgNTU5IDAgUj4+DQpl bmRvYmoNCjE0NSAwIG9iag0KPDwvVHlwZS9QYWdlL1BhcmVudCAyIDAgUi9SZXNvdXJjZXM8PC9Y T2JqZWN0PDwvSW1hZ2UxNDcgMTQ3IDAgUi9JbWFnZTkgOSAwIFI+Pi9QYXR0ZXJuPDwvUDE1MCAx NTAgMCBSPj4vRm9udDw8L0YxIDExIDAgUi9GMiAxNCAwIFI+Pi9FeHRHU3RhdGU8PC9HUzEzIDEz IDAgUj4+L1Byb2NTZXRbL1BERi9UZXh0L0ltYWdlQi9JbWFnZUMvSW1hZ2VJXSA+Pi9Bbm5vdHNb IDE1MSAwIFJdIC9NZWRpYUJveFsgMCAwIDcyMCA1NDBdIC9Db250ZW50cyAxNDYgMCBSL0dyb3Vw PDwvVHlwZS9Hcm91cC9TL1RyYW5zcGFyZW5jeS9DUy9EZXZpY2VSR0I+Pi9UYWJzL1MvU3RydWN0 UGFyZW50cyAzMz4+DQplbmRvYmoNCjE0NiAwIG9iag0KPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0xl bmd0aCA1MDA+Pg0Kc3RyZWFtDQp4nLVSXU/bQBB8t+T/sI82Euvb+8whRBEJRVRCCmCpSKgPkWXS tInTxoH+/a6dONjY0Kc+nfbuZmd2ZiGZwulpcjO+noA4O4OLyRh+h4EAgUIIklI4cFKA0QI2eRh8 PYIiDAjmhz9CWBK68+npKAxuwwAub8YALQJ6JTjeY423bs81UkRDXFKh98BsYB2S8GC8QUEg0VpL kK3CILlezeY5aQeTNQwxy/89muoRSK1JDxAk09l2m28KyEpuQEZAmRUVSgmBpGoEWULyHxLqFuFO qxDqH1ZK69G42kr2ChWBInZSApFDP2pZ6btG3v+aFQdms2e+SPn3Z87BQfpUGVf35TEsCgOSfHWk q50hlhNErwk2bG9ydc+Dzss3T3dXYfAY3T2XZb5c4nT2Eh/LaLnI8p/nD3kx3cQmWv/Isy2uq4fN PP4G6ZcwuEwH7LEtkY0yazWqrrA665oWWt16gnkmxllkqximeP+MaS6WYaBHBqlVG6fRtj9UzHKg Zj1dQHPRdGzqA+XholbUVN93e9JzwfWiQt7LobhoxMunX115jNI/i2pP2fQTiG103vKnbaqWEn0H zxGOp7GKZi/LRRUU5/cOlrcTXRcKH4U66owjQVn0tjONNIRW84NG07S8fc7L7WJdlJ/eHUGhewPq 6fgLq5ANJg0KZW5kc3RyZWFtDQplbmRvYmoNCjE0NyAwIG9iag0KPDwvVHlwZS9YT2JqZWN0L1N1 YnR5cGUvSW1hZ2UvV2lkdGggMTY1L0hlaWdodCA2Ny9Db2xvclNwYWNlL0RldmljZVJHQi9CaXRz UGVyQ29tcG9uZW50IDgvSW50ZXJwb2xhdGUgZmFsc2UvU01hc2sgMTQ4IDAgUi9GaWx0ZXIvRmxh dGVEZWNvZGUvTGVuZ3RoIDk5MTc+Pg0Kc3RyZWFtDQp4nO1dBVxU2fdfu9decxFExO5uEUQRDDqk u7u7u7tmGIahWxpUMDFA7BYwUBFQsQP4f2eejgiDi7vG77/r+ZzP/dy579xz49x74r373vz22y/4 Bb/gF/wjmDd33sIFi5csXjJ69Oif3Zdf8C2hb9++mzZtsrOzz8jIrK6qfvfu3du37560vLt353Hr E+TfouTevYZDFYeCgoIlJSUnT578s7v8C74aBgwYICQklJ6W/vLlq/fv30Omz5+/uH//weXLV44f O56VmRsTTc7bV3jq1OmrV64+ePDwxYsX7+gAyvdnz543MzP/Jff/FzBw4EB9Pf2mR81tbe1v3rxt bn589cr1QxVHsLspFEpISKi7u7utra2ZmZm9vb23t3dkZGQiLTE3N/fYscrr128+fvwUtd6/b2t7 356aksbJyfmzB/QLeoS9e/fevHGr7X3HmzfvILg7d+5evXr1zJkzx44dKywsTElJiYmJ8fPzc3Jy srGxcXV1DQwMjI2NRXlBQUFFRcXp06ex/aEEoAog8fa2jvfv3oeGhk6YMOFnj+wXfAabN/NUVZ15 /7797Zt3z5+9fPz4SUvL4+bm5vv379+8eRNyPMOA0tLSzEz6NoeUkdJotOLi4uPHj58/f766uvrs 2bO3bt1qbGx89uwZNHt7ewcB+Ono6Dh48OCfPcpfQAcLM6u3b9pev37b+vTZ45Ynz589hw/W3t4O iwzZnT9/Yf/+/QEBAXp6erKysrt27eLj41u/fj0PD8+OHTvExMQUFRVNTEzi4+MPHz5cV1f/9OnT V69etbW1dXSG9o5Tp079+eefP3us/2nAjqNSk5+1vnzy5Nn9+w8fNT56/vw5hPPmzZu7d+9iw2Iv k8nk4OBgbE9DQ0N5efk9e/Zs3bqVn3/b9u0CO3fulJCQUFNTg7hdXFyCgoJAXFZWBoWA3f2ZtNs6 IP97dxtWr179swf9H4UpU6Yeqjje0tL68EHjrZu10NvYzhD37du3ob0h6PT09OTkZEgwLDTcytJO TlZRUlJaUkISe1xZWRmbGrZeWnqvjIyckqKqi4tHbCwJ6j07O7uoqAjmvqGhgZA1djrda3/fBmPx 6sUbeTmFnz30/xzM4p5dc+ZS48Omutrbly5drq+nK+E7d+5A0IkMgAOWkZERFBiioaED+aqrq2tr ayOFoOXk5FCCnY59raWlpa+vj90NVa+goGBkaJqUlAKDXlJSgrSyshLmAKEc1PvLFy9fv4baePv6 VZudjePPnoD/EEz4Y8LRI6du19+9ePEyTOqVK1ewo6uqqtLS0qKjo+Pi4rBJI8Ij5GTlIFyIdffu 3Zs3b4YeXsmA5QxYsWIF8RPlW7ZsAQ2IIXosCU1NzZycnPz8fKRZWVlw5KA3WlpaGhsfNTe3tLa+ eNzyUllR/WdPw38ChgwZmp627/r1W9XVNYieYKAhDnhZiJhgfMPCwiIjoqGlsX/hhkGOEOuiRYtm z549ffr0qVOnjh8/vjM3lHBwcHBzcy9cuHDZsmWgR11YeSUlJR0dHcgaK4du0EvLmpqa4A/U1dU9 uP+QoVUebt8m9LMm4b8DVlaO1dXnDuw/mJSUlJubiz2YlZllZmZmZWXl4OBgZGgGf1tISGjdunUL Fizg4uKaMmVK75lD7oTQofCh/MXFxWOi6aE6HDnojYsXL548efLo0WNYYFWna4oLKyZMmPj9RvoL +LZsLyo6kJ9f6OnpaWpqamxsDJu7lQGIsNasgZDXQW9v3Lhx7dq1UNRLGbBkyRKkffv27U0Tw4YN g9ChE0RFRVVVVVFRRkZGREQESwg/3d3d7e3t7ezsvb19HOyc1FS1lnyEpZ8DSqA3vveE/Ith+PAR keHk8vIKe3uHoNDQK7W1HV8Ddo5f4V+xsbFB6HPnzqVSqV/VCuB6ff21+vq0nJwJE3/t/b8PSgpa RYWlaWnpEDe2MzUx8Xpd7dVbN89duVx9/tzpc2erzp1Fpjteun4NUoCDvXrNmt43x87OfubMGVS8 cvNGd55o6zQDkUcHLt+4js5cr68F8aUb12BcBgwY8P2m4l8PkyZO8fUJKSku8/f3hzHV0NCAUT56 /Pj9R48aGhvr7t69Xlt77datG3V1LBH+NF1wN26MHTu2N83x8/M3Nzejyq3bt8G5CzeiLaS4eruh AX140NR0v7HxTkNDTU3Ntm3bvvds/OtBZI9MVGRseHiEr69vYGCgq6srLOOsWbNu1tY2tjQ/ffEc 2Pz0SdOTxy2tT4GPn7USSPxEOaFpEVv9ZVvw+gjih81NYA62BEOCFbMVtNj68gXK8fPBo0b47YWF hdAJ338y/uUwbux4C3OHjPRMSNnb2xsbXEtLa82aNRMnTsRWetj06HHr05dv37TR722zQPqdsY6O t+0fboPr6ur21BD8NKwHguzZyxev378j6jD5MHm+bXv/4s2rViyz58+aW1oQoGEdDh069EdOy78V 1q/b4unhGxkZ7ezsDHGHhYYhVuLh4Vm2ZDlMJAzlkydP3nd5qNEzvHnzBm5z91YQm1+/fr33Lllb e/vr168bGxsvX76MaP3HT8u/Evr06aMorx4TQ7a1tXNyckIIbGhoiGhr9+498Jw5OTkRYcXFxT17 9qyd+czyr+Dq1au///5751YQaoHDV8i6re3FixcNDQ2HDh1atGjRlMlsf06d9rOm6N8EkyZN1dE2 iokhOTg4QpkHBARgX2/atGn7NkHMMyz44MGDR44cWV5ejvnvvcQTExMJ/lgtiOJ7L+gOhpMPfQI3 jUKhjBs3butWfsEdO3l4tnfpOWwNAnA+Pj4E7GoMQGbt2rVz5sz5YbM3Y8YM5j0BZBBd/rCm/x4s XbzK2Mjczy/A0dERytzNzQ1bG4HYtGnsUL/wtAmLycXFBVUM7dp7ievo6IwfP37//v29FzSYwxY8 evSotrbWyMhozJgx6AlD2/ByzZiLYEFKSioiIuLUqVMg+zIr9DYhIQF9+PJ9v2XLlp3qBMnJyRGs QEjo0x3d0aNH6+nplZWVYU12b/fly5clJSUKCgq9vO/0g0FQQMTGmn4ji9DkmB9sbWlpmUmTJrGx sQ0fPpxJCYMOQbx9+7aXsoNE4GJ9lawxVw8ePKiqqoKGQYsSEhLwFZFHr86dO9d7Vl0AFmHdunUs h6+trd2bjoEMxPPnzyeTyehkbxpFh//XDuPBcO+VUXF2cnNkaHKEYJheiHuHgBA2JhRpF2dYX1// 8ePHULZ/e+Z7AhhrGPc7d+7AdccyGzsWjY+DhrSzs2M5vRABqmDt0R+evnyJpYVefVnzREdHDxky pMsMQAP0pnv8/PyIH/9SpXSBmzdvjho16seJ869gxIiRigoavj7084Tu7u4w3JsZMG0aB+w14qZB gwZ1qRIVFdXa2tr19BEraO9ob2v/CzIQvH7zGtjCiLbQB6LFaWzTIOuLFy8SZG/evgEN0rf0k+z0 o1MwK4TOh99+6dKlGzduQC1A7u10kbcTTb9vew9iVESG4HPs2LEuEr916xbRDQLphyw+4rv379Ai URF6vvvomGy7l6PdDsaaxMT+OHH+FcDj3Suj5ObmAZMNhwqxLWQNpd2vXz/IGlEYMl2qQL0XFBbc bbj3qLmJwObHLZ2xqaW5EcWMDHGVIMPPzvn7Dx/cuXe3tr7uVl3t1WtXL166KCYmBv79+/dHCiVD bGo0VH/nNijv3W9AlYePGgmEcAsLCwUEBAhzg03Ey8sLoTAbIrrxoPFhw4P7qA4kxOHn788cy9Q/ /wQNUYVA5qCARHUUPn76BCkaRWdu370DVuBJjIVZkUBmu+gq6t6933Dt2rUfKM+/AM7p3HKyKp6e XpA1Im4IHYZSVJQ+7QMHDuzJ2Zg8Zcr+iopzly9Xnz9fc/Hi2UuXuuCZCxdwCUhkkBJkSIkq1efO VVZVHT1xovzIkdKDB5NTU7lnzfqNYVyQLli4ELJuffXqRFXVierq0zU1RC0CzzJSWnLykI+GhqgF mDN37vkrV4gOfNbouXMnq6tPnTlT39BQdfbspI8vNfBu3fqwuRk0RG+ZyKwOBP0JRlcPHjpUfOAA hUbLyMnBzzPnzxPMCWImMseLilXnzl28ehUO5/eWYy9hFvd8eTkVH29fyNrPzw/mG3tEQUGRuMqc xu6wctWqAxWHyo8cPXTs+OHjld0R5UzsXFh+5BgyBw8fKSrbn1tYlJ2Xb+foNGLECCZnBOzQ6k1P n5VVHDpw6HDFUTo9UlREeqTyBLD63IXp06ez7GFeYRFaASWzaSJF9f0Vhw6iw8crN2zaRBBr6+o2 tjzFpc697YKl5RUFJaXpObk7BIWYnsySpcvQty6jY44RrRN45MTJk1VnJv7PPLmbO2fR3r1KELe/ v39QUBACMYSxamq9OjgkLiVddKCioOxAfun+XmJeSVlecSnS3KKS1MzspPRMUQnJLmz1jIxfdXTk FBSDhl6luHRfUSlSonp+yf7z125m5xf11KuT5y4UlB5Alc4IVjmFxcgUHSgvKT/Ew8tLEHsHBB09 XY3yHrtaXJqWsy+KTOGcMYOowlxg1vYOaOhLIy0pAwGa6+4f/iyYM3uR7F4lTw+vYAZgdyPO1dDQ 6GV1/7CI1Ny85Ozc3mNSVg4tMzshPTMkmjRv4aIuDCdPnXrwxGnwTMzIBjHSRKyKrByiIvJp+/Iv 3KpvbGw8zYBTnwNK7rQ8jU9N746U5NS45FRkUnL2bdhEj/IGDBxITc8EQ7Bl2U+UowOU1LRNPFu6 j11MSvoLYye6nZCRFU6O/2ci+pYwc8Y8GWkFdzePsLCw8PBwHx8f+EgqKqp/WRErNj4+vvldByU1 g5SU2nskJ6eRktLsXDzGsHpUKrlX7kj1+eiEpNjElJiEZKTMikQJMjG0ZHJyelJ2XnpBcXbx/pzS A0iBGYUl1PTsKGpiGDk+Ii6hC4bHUUNi4sJI8WC+ZPkKtMXBOQN8YmgpwO79RCFajKYl+4dHsTRq IlLSmUWlLMdI7yq9empUfKKKVo8PjH4YwAcjhsDBPlNGmu6ZI7xCWIoNDl9XXl7+y9U5OTnPnDnz pK2DlJweSUmMjE/qJUZRk0nJGUgH9fCKkLmdAyU1CzzD4xK6cqYkRlBoSEPJ1OAYcnBMXCgpHmQR DOIwEjWMTEUmJJYSEkPBpc6IQtAHRsYGRMSEkigzZtJvdfJs5S86UsmiIUZb9PL4JPBU1zVg2VV1 PYO0ghLWw2d0FYimV65hfXvnRwLCKyK8nTRxqpiojLW1LYlEiouLI5PJggwYOnRYT3V37Njx5MmT 01fqSEkZ0QmpwNjEtF4iKSm9oPxYy/sOZU0dlswjKUmkxHRQxtBYsEVbKA+PowVGknxDI/3CogMi SIGR5IBIsl94NBCZwG4YFEVHUPqGRHoFhYfGJhAuvZqOfl758WhqSve2UMIYVzra4t22g2VXfYIi EzL29dRPpFEJKWDOUon9YEBsS4Srw4f/Liq8V1dHH4KmUqmpqalCQkK7du3i4eFlWdHBwQGha9nx anJKJjVjH4EJmXkfcV+nws7lnzApp/Du07f3Wt+u3bCpC/PBgwcnZhUQDFlyoGXlJWUXKmpoT2Pn YOOYPu1rEbXY2dnYPxxoDIgiZxQd+Lz/nw0E0oxPy2afzuJG6NQ/2ZJzi2hZ+SyHSXQ+Li3bNyzq W4rtH8Do0aNHjhzZ57c+u4Qk5eWUKHGUxMTEtLQ0WVnZPXv2mJiYd6FH8FhYWAhZZxQcoKRkYyqS cwoTM/Mx/8gghaTwEykzT1zqjPRLmfm5pYfpa+ZY1aQpUzs3MWz4cLClpGYTdZncmHzS8koyi8p3 Cot9g+GPGZOSW5ySW0Tw74JEu7SMvChKCsubD5t4tx49ewVkxKC6Vs/MT84pSkjfp6Fr+M+7+k0A 4ibeuNywnl9CXCY8PIJGoyUlJWH/CgsLm5l9Ju6lS5ciFr7+4GksLS2KCscmk5KaQ07OjEvJQiYu JRsZIo9CXGX8JArh2eYwET9BgEx2SQUk7hkQNnDgp5u0cCdCYmGOE2MS0ggygu1HzE7dVwoUkZD5 jVXEPWfOnCU9A/GAkmvmTIJ42crVuWVHmV3qjMzOx9DSDUytWM6ekob2/sozRA97qJ6N6us2sXDp fwqMGDGCnZ196NChs7kXSojLurq4QdzJycnY4+Li4tLS0jNnziIolZWVX758mV9+PCACpjAuJJYa SqLR09iEMHIi8sjQkUQLiqaAhiD7UMigYeIHYnr1hPTCA49edciranbulbK2vldwhG9YDJiAG9HW h4okGikpq+bGfUsHt+7DgXv55ZvzKXkl4LNxCx9BLyIpU1BxIjiGSvTnM4yFv0cNiqb6R5D4tguy nD1HT38ItKfqKA+MiguKjvtj4qRvKrS/D7DdHBwcbGxs48ZOEBeT19TUTkpKTklJycnJwdRJSEho aekMHDgwMjLyeUdHCCnJ2SfExS/MPTDSIyjKPTACqUdwFDOPclwFjaNXoKNXkJN3MH6C4BMlExnE RJpVdqy08tyK1euZvZo2ndPWzdfew9/BM9DRO8jJJ9jZl96um3+4W0AEuKUV0tWCv78/divoMQR+ fv59+/a96+iIomWCgMkc9K7+Ya7+4S5+oegPGGoZWTAfAWibWAZEU1EO/izQJ8TJO8jFN5Rp6DsD jI5PaKyrXxjRve6IcnC2dGSxLH8iTJkyZcGCBcOGDRMUEJeWkkUslsEAT0/PjRs3Lly48MSJE6XV 1209Ai2cva3d/JCxcQ8AItM5j9TS2cfc0cvM0dPEzt3U3sMM6Ohl7eZPXCXomUhUBNp5BxefvBQQ Q5sw6dMJhIXLVhjauJjYuZnau5s5gI8nEMzNnbzM6Tz9YlMLXnTatshTssscfUIJziAAWrn6Wbn4 Wrr4WDh5mdh7GNu5yWvqj/h4ngqeKi5ZOnt3buIzdPAwd8BYPFhG3DNnz3MJiDJ18DDtqS5Se89d 4v9b5+vGjh1LvM23cMEKaSkFSwurzMxMqHRnZ2dePr6bzc1B1H26lq66li761u6Gtl76Nh4GQFtP OjLy9EJrdx0LFy0zJy1TRzUjW2U9i1nzFq3ZtFXL1EnPyoUgIyiZ+KG6rSfqmrsE5Z24rmZoM2jw hzuNXFxcM2bNVdA2UTW0Vje20zS11zJ10CTQxEHLzBH9IRgSTIiMnpUbynXMnXUsnLXNnTRNHTVM 7MFWzcBGTtNk0bI1nQU3ccqfGJemiT0dmcw7oYaJg7qR3U5xOZbztpZnm46ls8aXqttrGNvNW7zi R0ix1zBq1Ki5c+euXr164sTJ0pLKcnJKISEhurq6Vm5uh+reGrmEKOhZK+jbKBs5KBs7KBnZI1Ux dkRKL2EUKhrYyutZy+la7tUyl9Ew3S2rOX4ifZ/2HzBASFpVTtcKBJ3rMpEoRAapoXNQbGEV325p VBQXl9y2bRucimHDf1++nk9EQVtCxVBSzVha3URaw0Ra01RG00xW2wK9UjK0I5DeB10rWXRA01RK 3URSzUhCxUBMSU9CWZ93p+R07nl9+/XvMvDZC1dIqRmJqxhI9Ij64DN/+VqW88a3S0pC1fCL1Q32 apqNGvvH95bg1wKc8w0bNkClr12zhX+r4OIly30T84OzTu3VcxBTNZXQsJDSspLStJLUtKRntKyR fshrWomrm4NGVMVYWNFgt7zeBgGxIUM/nXQaO2GKiLKRmIqJpIblp1p0Dkz8UIjUwDXCPjxr1qKV AgICUlJSlpaWGhoay5cvHzBw0DSuuQtWbFq3XWybuIqQjKagjKaQjNYuWZ3dcnq7FfSQ7tyrs3Ov NnFJQEpjNd8u7kUrJ0yZ1n/gQGZnuujk8ZP+nMY1bxrXnJ5xLjv3/KEjRrKcNDauOWwz6NhTdXau uRzcC76TyP4JjB8/nngDd/SoMdO4l8SUX7cMThVVNxNWMRFVMxfXtPyIVkjFNOiIvJi6hYiq6R5l Y2Flo53y+kLyugtXbeken85dvmGPkpGomhlRkVGXBYppWICndXiWhl3g+MlskpKS1HgqhULR0dFZ sWLldHaufn0/BGuDhwwbOWb8JHYuYraZOGU6N8pHjum6m/ow4EfM4/8fmDZt2vz587eKSGWcf67j Gimmbi6uYSGJ3adjI6Vjy0Cbj0j/iUsggBBFVU2FlY13KuhxcM9nyRluMJ+YMhhKaFp9rG7zOdoy ecoaOvmkHMVC2rVHJC4uLikpSUlJSVRYQlBAZO7ceYBx48b15klib0SMiGMYA4Z/BJbHtHrZVnfo QqampraPAc5ubj/9YSgCcCd//7IbrwxcghWNHJVNnVXMXJEqmTgh7YwoUTR2VDC0kzewldWzltG2 2COvPXbCl0LLcRMny+rZyBvYoWIXbp3ZEo0auYVTyy8Lyajq6OpqamoqKaoqK2lv3MAH72LWrFld zoT0NLe9gaysrOZucOfOnby8vE0fTz58Q6AkJp69fPnClSsFJSXfQ9ts3rwZsbOCggLs8pcpEYsd OnSo9OIDa+8IU5cAY0dfQzu656xv62GAjJ2X4Uc0IMptPPVs3LUtXDTNnIRlVIYOG/5l/oA1m7fq WrsZ2DJc+k4MP2Nr64G8iUtAaGrxvlM3N/ILrVq5WlFRQ0ZaDfMPcU+ePLnLayl/G6BzDh89+rCl 6WFzU3PrU2DT0ycPWpobGh8SkZ2Xl9c3aYiASZMm3W64V3/3zu3bt01NTb8hZwKgqcAZ3X78rNXM zOwLlFgMDQ0NB2tueYbFIZB09A2z9w6x9Qyy8wy28wpGvguiEJcQTVu6+m4VEu7bt+upRZbQt18/ NQOLnnh+4OxJ5+zgHeoRSq68+iD/yLlZcxds4xfZwsMrJCSE8KHLJ1/+CSD8bGxsfPPubUtLy4UL FyorK0+ePHnr1q3W1tYXr+iHITEnMBzfqjlYCn5+fj4+PqRf9WGTXgJsMXEO/N27d3C5eyITkdyb nF8WQU0Jjk0IjKL4hcf6hEZ7h0R5h0b79IC45BkU6RoQumzlV7y2D5jKNs0jKMIrNKonzsym0Y3g WFpMUlYImTZ6zFhsbfjnCB++4Wlt+KUdjFceamtrubm5wXn06NFTp0718/NDYXt7+9OnT7du3QpK LDMU+vv7E7tSUFAwJydHX1+fyap///5YjSQSCRry4MGDIF64cGGX5sDEiQGKiopdLsFlgiYpKys7 fPhwTExMT58QhGYzMjLKzs4+ceJEfn6+jY0N80PxWlpaKCGU0uvXr8PDw9FbUVHRztUHDxmiZ2JO SUmPjE8II1GC6c+Co/zCIgn0D+8RAyKiXbx8ODg50TH0/6vMnOAe4S9wBjJbD4qMiYijxqdluvn4 YUKwer/tSU5ra+sOxqs9kFFnS4p11dbWhp2CXU+I29zcnJhJaADEhh2Mz7cy30WFbkT5h7PlH19n wIIxMTHp3BzxlgrYlpSUMAvhFvr6+jI+DNtOpB2MFytUVT87R4TlpK6uTrya1M4AopWzZ88ingLB tWvXOneAeDXD3t6+y5AHDx7MMZ2Tg2M6O/1BMMc0dgZyfER2duLR8KcSBs6YOXPlypUIlGxtbSMj I1NTUw8cONCdOUtAz4mGurPtjugVB+eMhYsXc0yf/g3VOAGlpaX0W68vXmDCf+sUku/YsYPYI3V1 dTC4KIHnRkwmXfm/eYNpR4b4/o+hoSFBjBJoCVhPLBLidSrMPLFaCKDRaCiEpfDx8SFKsDdhPiCa R48e3bx5k/iWIFgRZGxsbMy6mZmZKHz+/Pm9e/fQCpzJpqYmEN+/f19cXBw+NjxM4vu0qI5L6EZ9 fT20UC+nAhygOqCRVq1aNZOLm49XUEhQWEhol5KSMjYFOkylUsvLy6FVEFZAvSCFMoEeO368En0D zdq1n92JwtrArGLIYWFh0EjwHqWlpSUkJOB4W1la2dnZOTg4wMFgHKjYwrOZb8sWgTlzFmJTz549 G5buG9pQAsDwZm1tO0MowsLCzPKJEycWFxfX37lzq66uqIh+zBWe4cUrVx40Nja1tDQ2NdUxyslk Mi5BgTPed2jA/EdFRa1btw4d1tPTq6uvv9PQ8Ki5OTc3l1hFCLuqa2qaHz/GYsDYibbc3N1R/d6D B9jv2KSIAaEnb9+92/LkyfOXLxF+/sZYhNa2tkQrV69exRTBLq9YsSIkJKSmpoZ4P3HkyJFSUlK1 9fVPWlsbHjzw8PCAoDGor/pPECxsdB5LHVpr27btWhqmdjYudrZObm4ekCx8Gwz84cOHWOrXr9+A 0cHQsAsKCgoKCwsxY6UMKGPA/v37kaIQqyIlJQVzFR0dnZaWBgJUPH78OJRDVFS0hbmFnq6hnq6x jpYpH68ALy8vjMWMGTO+x3fOly5dWllVdbWuDuIOCAjANEJLQ2QQx/7Dh3MwjLKyVYwPCi1dvvzY 6dOHKisrjh3LLylBIfE0DXo4NSurrKICqKnz2REsfSOjw5WVR06cOHjsGGGAZs2Zc/TUqePV1ZXV 1VyMd4GXr1xJtw7V1Wio8+uW1vb2J8+ePVlTY2lri5/TOTnrGhpKy8vRq1WdPnCEPvzZaftPnDQJ zNHPoydPcv3dd43hGmFaoC7glmAzaqgbhQbFhQTHREbGZGZmXb92Hc4M3Y998QI6BHKvra07deoU dj3WAyF3bATiw6cAQhtgnUAdQQthqUDtYF+gPDQ0zMXFzcXJw8XJ18TYUXDHLhERESx1RNmEOv3m sGEzT2nF0bScvOKKI7UNTe86Oi7erM/IK6SmpMfE0yJIlC38H77zs0dcvLzyVGo2/Qg0D98n5bxh E8/ZKzeTMnNjKIkjGQ4kM/xfs259VkFx+r6CpPQs4hL/jh2VNedREhZNGsi4jWNiaX3y7MUjVTWY ELh22K3Eke9DJ6tTc/JSs/NVNemvmkrJyFeevZCcmeP8MSpkeZNhCx//6QtXM/OL42jJXzhe+JcA B2nRokUCAgLQuvAWZKTlHex8oyISYqLiyaT4stL99XX18HZeM75a+57+bxNthC8BVwE7BTYFKcRK 0LxkADIwQzBYVVVVcXEUP19/H+9AX59QT7cwZSVtcXEJaP6NGzd+P1kDhCWkc0rLQ2MpQTHkoGhy QFRsYESsX1iUd1C4hp4hW6fv/Kho6sQmpYWS4rUNP3O9tPSNcvZXkJPTlTS1ujAX3CNCSkoLiY2z dv7wpFtT3zghMzeSmqSqyTh+3KePo6dvFDU5KiE5JjEN5RH0M6uJ4WQERyR0A+mqdfSn/w4ePrSs PHJKxjbBnV8YjqqOXmJOfnRCsn63w2ZfC4hNEERg/mVlZQ0MDGBTFORVfLyiSDHJsdHUeAotMwOh wcn6+tuQY0+vABMfr3716hWkf/78eez7mJjYkOCwwICw4MCowACSrra5hISkvLw89jWMIBcX13f9 rworZ/fohNRQcoK5g4v4XgUJWQVRKdkt/ALdjzFYObnFJKZHUJI2bP7slKaZnRM4ZBYf1DT87J7J gAED0ov2h8XRwik03m0CKOnXv797QCglLQd8eLbSlcaAgQO9giOiaWmUtGxFda3dohK7xCSFJWR2 iUhsFRDCatkpIj7i95Fg5RceHZeanZCVt2PXnp7Ggs3u7O1PSsmkpOcI7OyR7KsA848IhZ+fX0VF BUKXk5PT1NAP8ifHxabFkZITqKm0hJSMjOzDh4+eOVNTe6sWlh2KGp4kXMQbN25cunT5yJEj+XkF ZBIlOio2IiI2IjwuMpwaGUYzN3USExMnPqULBQ5lwsnJ+c398M4ABUtKziCnZMYkpS9fzfrhJgHD h4+IoqaQU7PIKVnzFy7ufEnXxBwb82L9w8fPnmFmiEIE74hTqOn7omkpAVGkQYPop+hHjxkLDsm5 hZDa7Hn0xwp9+/XzDAxF4eGaS+s/fzOlc7CMKMbdP5iUlPHodceBypNMHQ4X2tPTk3kgZ+iwYaGx 1KzigzU37mBX0kuGDv3nn4yAKZ8zZw58dTiEGhoacLCVlZWVlFTMTa2DA6Jp1JyE+MzEhAxaQloC NQXST6RhDWAlJFHjk+LiaGRSAplEI8UkxpFSI8MT7Ww91FS04FJi5cBF37Jly5IlS6DAv8cdpy4w Z/7C8LgUr2Co7sg/GLf6e7rrPnP23ODoeG9QBkeN++MzbbNoyXL3gHDvkOhXHR0wTPD3YIIRTwXH JngFRzp6+KMVgpKdgzOKmg4+/uFk5qE1JQ1dz8CIQ9VXYddcXV0RaCOcuXTpEqrvFpXs81FYO3YJ ewZFBERRoCHh0zo7OyMmgt2MoWUoa+r170//YuTYcX94hUSHxNJeMr4U4RdO0jGx7OWtzr8EWPN5 8+atWbMG3j4UOwJPyF1NTU1OTt7MxMLJ3jUoIDKBkpFCy0lJyklMoCNWQlJCTmgw2dPN39rSXl1V U0ZGBksFigJ+IB8fH3YHAq4f9hckvNt3mjq4G1k7K2sZf/lRxUbe7aA0tnFR0jbqfnWPpJyBlaOZ vbu1W4C9N/32r6WTt4mdq5axFRvHp0Ppq9ZvDqGkWzr7aJlYEy+tAyZMnIyfhlbOZvaeVq6+1q5+ 5k5eRjYuRjau23aJMns1bPgIdUNLQxsXc0dPxu3lEDuPIAtnH0tXP7G9SgS330eONrFzQ11jO3cz J0+wEtjzDY5kdwYODg6EaQgAN2zYALnD5urq6kL08OHh1CkqKsoyQFNDE2EmhIstjLWhzgD6A01R UUgZcRZ2NDRG51sKPwA2btu9S0ppp7TK8vWsX5pgwnq+naDcJaO6fB0LykFDhi5euWGnlLKMpomc lrmcjoWguOLSNZuHDh/RmWynlIqykb2CntXmHSKdy8dPnLph604xBW0pVUMZdWMxRZ3NAsLsXF2/ FjVm/IR1vIKiijp7Ga1IqRtvERSbMefTXfE+ffouX88jLKcpqWogqaq/Q1xh/ITv9Wd8sLPY7MuW LcN+5+HhgZ7HhoX0sXOh8IlvXkH6kDhEvH37dhgXmAMYaEgZa+anvPLc+4ePfXphAfv26z9i1NjR 4ycOGzGqy6U/prBvFVexicjao2S8W8n4zxksPvw1eMiwUeMmjBr7x8BBX3oCPnDwkNEMskFDWMdZ qD7899GD/0EU9lXAzs7Ozc2NLY8Ni10Pma78CPgJdb148WIsjJkzZ3b5jtNPgd4/Iv8yZfdLzBLM v5S2pZFHlJSWpZi6iYCkav8BA79cvfdd6g3Zj4fJkyd/v9j5fxzG/THRxMlHz8ZN28JRQct40q+P Pf6rYcy48bvEJAR3i2zk4ftfeP3zF/wX4P8A1crmYQ0KZW5kc3RyZWFtDQplbmRvYmoNCjE0OCAw IG9iag0KPDwvVHlwZS9YT2JqZWN0L1N1YnR5cGUvSW1hZ2UvV2lkdGggMTY1L0hlaWdodCA2Ny9D b2xvclNwYWNlL0RldmljZUdyYXkvTWF0dGVbIDAgMCAwXSAvQml0c1BlckNvbXBvbmVudCA4L0lu dGVycG9sYXRlIGZhbHNlL0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGggMzgxND4+DQpzdHJlYW0N CnicxVppWFNXGs5GViCBkEBYEkLYCcgSIICAoLIngApYqMUFFEVc6oIoKtuoqHUXneLSmQodx9Fq nVqBaltq1bYo6gMiIFAUBESsiIBAljkXErnZWJ6nA+8Pntyz3POe73znO+/5LgjEODDnWNlYWbCM x2s3PTAwtnTxnRsSFh4hiAgPDZnj48g2ok43KQXoMaw8ZocLIAjXb970sRD6FRbgyqaTp5uaHBQj O3/AcF7O1w9apSPoabh5LEkoCPHi0HSnm94w6FZ+EYIF+++LpEp48e9kYaiHucH009Rn88MEMed6 lRmOoCJNGOxmpkecXo40u7mCqBNd6ikCiH9IEs62oZKmkaKusUtYZF6LRooQBq4sDHGgTR9LMtMn IvrSmBQhPEsNm2GoPU0cdc39hfH3x+UI9nqWwN1oeljqMP2Fqa0KbCSiof53PT19Q0MiCbxcdCrK nT4dK04ymSlM74Ez6W2v+uHi2cP7DhSeL6n4o6tfDKu8GuVqMA17nOYuSO2GUWyrKM5KDA/w8XT3 8PabG7P2+I36Lpg5iyId9PBTzZFsE5bY/oGCuP324cQAVzsLUxpUacq2mcGP3nm99vUoy+MhHF3c 1HIkMQMXVHwg0Hf/9KpgPpeio4UcbWLjEZ1XVvPhHHq/LcLGSA+AQiaip4YklRf15QeOvU9vFJ0q yM/fvc2dgoJNxMZrxcXHg/JWb6+cOrQ/Pz8/b8McElLzm/86kNghKf1qgs3dmdrw8a2CDr5WbfQs Gj6V/x+o7gsq1XCUSs45Yj80QhLtc9+otmnY7KIzFSSJrKAsdRyl0v4tZnKHQ5G9igZUGohr8uaa 4KdiuSlOMdXqSUpfzNMfYYCih/2qWj1UkRdmoTMVGwfPCNguD4E9yjTuziQClkiseXKzGkOXbppp QpgSjyRZRf0oG7X9J2WvE5+y1UIgSU75b1U5SsrXexhip2RrI3S5S2QGlJzMKlbWu71rjDF6vpeG 1DnDjWAGHonCUwyZbDaTro0Zly+GSKHoUYiYyZPU5x+SDfpsZVDSFWU6f0Tbzn+gjqJUWh/p5DZL uHpP4dVr1745tmP+bB6bLHNQJM7EzX+Wr6ebC4CzHYOAROtyvAWbd4H4uyWSz5pkbMUzwm7KBt0b wOKl3JEoUfn9cJt6jtLBM1erO2HCo7uuZIOvKQ4aH228reNlZ+fTaghVlflshntKWYssPIiefx1u gh2XGQwEs4UyhTYUY02muGXUKlGRqMZ55XnA0Hbcmwq2Es7jF3jpDwm7axSudq8zOVqTsSRzqWyF G3xoRIyBX/5LzRRks6kWj1Fb8xEDjdCJfgEv+/2Rco/eVYaTCAsETqasX6E1CYfEGof+/d3YHN+V 7O8eq/7lx3Q0PVUh8veptqr2mYSKItqelHWbT9dCI5B489hLg6rvHMWLL9LSXsGeRR33fr7fAbfU E39ty6NjzhNgIJEyYY4oAveCrJvvcFxGkWyXl2teTtGjvTHCYphTDpTvT01cfQzuyZIsFv+mckex siPnmE54h6PwM76VvdoTMdwLTXbZVKOJY39ZeqB7Onz1ftvgZ2thLzgL3xf/9RA0KHSTdFXc+KVd oUh6xGLCTonEOn8vs5G7rBOG6rOrQz3HrqJkHjscTqDv0tqooNnBn/wDTrI8dLmC14qfnEhLWPml oq/v4Ux852AcZCTFfLkSx5rEXVVVPKBF/ZEFtlTrI/CFE7193QnQpXBs3o7LUVjc57tD7c2d1ytc Rge3MCce0FE28uX2xcmmhrPeoBBA5K+9szPIXJs4q05NnSJ+WnZRYXJfhhrj0QbxChrl1QrGxH0S aSHfOKGk4TMNSXTIVaPApZKKrT4MPIqcMGb8Gca3ax/BH7vTrcAxpPexQgB+FKU/YUOicQx5CFqh h0FB6tb7K/UhqDXFHIxFWzvGeSObzpF0hU3y9CM6EoE0SnsPLzzvNfH8Akabki7rdskUh0ZgDAUV Ug0o9cQjkGbZ8KL+57WPlXHv6xU7FFz6O38dMHnrU/CywRybSZyLenSh7Fjs4Gpr4TipmtNqQ59Z YpDm+fCi9sKNaWlpa9Zt3JIhx5ZVUcEn4G3E+7jgcMF634UXvlppMoljUY/Fk+0SUTBd3/WwhgTq MLqXG6KZmfBI/2w9z9bWzjVy76kzMpw+vt55tkIof7OOCZxdO+o5vLBq3sRdEoHQMXcpl3Xcywsv VUlDK6AhXM9kLTza/LnJlmxgHVkCb3SeK1QI5Y0f0cA+piYrHOBf+0wm5aXN5h+UdXyZPW50+YFv Gl8JL6grSNxapGCj7jTnZQoBoCwQuKSSmwzl2U5KUJr4xMiPApV7mArEx72jzqjRNKPoKw5z2Q4P AJLPHIFLYtyuw1t1rTad1AWOylt4R+OQPcqK913W4twx1KSko2gJl38eXvR2Awu4JCG4Hl74ZMHk vl1RHBbs0hD6xHWXbynfedr3PtRIcbDt+u75tjQvBVVeHwe5pE40XN5J/+MzyVyxWcin9VJ1GCjf mbhVhdKzD1NQmNrAm6afi7IT+ExtkvPnVc87ZHhRc9QLuCRCN7C07oW88PmDFKtJuSQCQeOvvaLO lN0XV/KtffNeqakarn50+37N8/b2jo721tpHJcWHtiSGuJlTsCis2dzUrDyAXIDtKYGmkAQnWkWv z86VISORR9Vhubrb6U3YMVGumU/UkGj9PJ6rT2SEn1N/SA6V7U1JXZORBcbMzly/PDbY25FN14aE lBYzIi1j27ZtGesWhXi52BgRISZaZJaDq5sMThyqtm1xY1PlTI3pYiSOamKij5NrEIxxcoMqB1HV XoGlDhpJ4CSpPyarcoKdLGydXMCYLjPsLc3oZIIsO4D3qns/AKG3+fMABlFr2FpIDI5IkoOIx1Ci OsGdMVLjJ1UtTs6FrzYzRq7xSIJNuhqFO/BjxixT4rDe4OV0quHYc3a+CRmNJQyPTMBhUKO6S/+T 0VBW6aneVkjDjaC2JoKiyZDkBSAu3nQY9lykjsdpNfnTd99tDKSP2BpjGPZP1QUX/bTVlab+/SjW 30BEkIiHA9VQuinNyp5lYGJnro1CEoydvPh2dCwSgTJddaeu6piXDhJrYOfJ58pySmgyh+fjbknG aHuclEBfOdgEKKMX/LOaPdN3fU88j0UfmROes0z1G1Tn6blmGqyAcb0GOLZU3K2Fgv7lWWvu3rua cLruAkebFfbF47bWylwXXSTGalftHxVLLAh67tkVLW1V+1x1gJrTdki90fSyuTzR2vVaB/SSqiNM IE3cKtU63ODpOGGQr6sdh23KtuIlnFIRwX2Z9poEAiEY3BwH/7V2xT7oOle69Ffge0ADX/f1KRhR veIfvXXwfBBLX8cxTGMfDBtJUuJGQBuEloysWXe+PD1ewQMXBZsVF249qH78uK7xxZt+uE17v4sU CAThEKIWZf6nXqFysKNsEVuT+Kd88iew9Gae45IH0M1hK/BoSLV8sbT8Q/9iOz0ow/Es1iYJ8neo WrzDlCZokjf4br/sx3U+2EMGzsJlqUARpm3fe76yRVECDTRe3S4UCIQFt18qHoRvHxYudtOUhEaa 5gGXrFnjO/cQsH/fvqPDR9bAq4M3oKk3N0IZ0M5oq41AplctnPdYKn1f//sLYIFf/OYAe0v+bGju FVem59SDIftb72fYA0cl0ljWtsMIiM0ufarujqgMSVvp9nBnHU1JRgwX+tLb9vC3Wmjpft9aCnVp uXLgOFjArsv791wCCmkoc1YRKP52MbheDT0s/nspUH9Ny46Dho3nduWfubApPAESf9VHl/sYQvNG YbSwI+D4pF6qHl8HDT79d5IbEx5yFIHzvT06n8acVMgxW48lLgE+OHQtydf/UyAHRfkLwV4cPJoG 1nywvbmpFZi1OQe4cm9hrJdX4BxXayGoF/0z0pZGUHo9yyW2oKJDbU53dNie6sIYLkMDQQik0eRF 370cwfI2aGihUwK4mnVlu+gzEppAhNu6GmzersytsHTBvcPgoTnNmqxLNdClLgD032yyJmJUzk1T h7mZZY1vxlBi/S03c8JsDcfgiNBf/Cf0jfftm/bKs2t8HVcBH2xYYWG0CJR2rmPhLLaBZa9dtRP8 rUvNBe7V09HS0tr+sqng6CB0rzTAURm6aGoyYPw0nq72aLfyjDtwq7lXg3IbaLtzKN6DoyGIjwDF 3A22X/s3p47krgx1oFtBu+hWCMXgY6BTxJcifTeBe95QYdwxMZRZ3Q6Wue36l0X/ffTVtvi899AH /8DZud8H0Zk7AOPKdbMM1X5+MbOfmXiioqN3SIWnqP9lxcnF3nYmY1EE8WI4lN9InuPtam1Iwjtf AU9FbnhK2D3In2uqgIVE95IjLoLi4rBVwLziZw/r3kmrYnnJUBbm9cOnYuljX4djYPze1mo3DTlM Ftd/6cGS2s53olG9KBH1dT4pObjMn2s2NkUQyoOegqiyh0cjk3BoJH420Ff9O6wwROc8+Z4U3U/3 EYIQOrDLI6JEPkRNMDOwWO5nTQLnw8M/qv013tbYjvzQ5fsuVz7r6ul7P/C+r+dVc+Xl/OXhXlzm eBTBvS74j4HBpkWMEW8izWkYGGxMMEJhjIVFr6A9+b7z+ib/GSvB2dO10pK7+s47QFP0pmKdkx5n 2Y894EHc/WgLzy6lVSyVdJ9xH+tKyeF6zFm4OutAwdlzX5z4bGdafBDPnm00PkVAa8aagpOfepBH IhRxRtrxE+vddZFIkuW83Zd/e3Drq92L+B5bfwVsHkTSqe4pJ2/e++1awRo/IzxlxtJj31feLyv8 NMDEaGbmN3fLDsRYjPPvCeY2jq4efG8/H767C9eaOdErCZbm6OfnSMPKn7h+flzoCa3N8oxauuKT CE8OewmUFBo4yiNhqbYBHyUnxc12NCKgtPSs/WOTkhfOcWIQiQz3qEUxfhzdiX23NB4rJqoBCkc2 MNDFolSeUDiKsYWluRGZwNoD7aHyBKYWEkM0YHI4ZgYkoJeRaCLVjMNh0khaSBROz5hlakAc/yPb Xw1wumHQKASaubm+/fm3q510IQZINCiUU4E9IFFojYfaFABNm5manRHnrD+xT4z/A1P+MbQNCmVu ZHN0cmVhbQ0KZW5kb2JqDQoxNDkgMCBvYmoNCjw8L0Z1bmN0aW9uVHlwZSAwL1NpemVbIDI1Nl0g L0RlY29kZVsgMCAxIDAgMSAwIDFdIC9SYW5nZVsgMCAxIDAgMSAwIDFdIC9CaXRzUGVyU2FtcGxl IDgvRG9tYWluWyAwIDFdIC9FbmNvZGVbIDAgMjU1XSAvT3JkZXIgMS9GaWx0ZXIvRmxhdGVEZWNv ZGUvTGVuZ3RoIDQ1Nz4+DQpzdHJlYW0NCnichcKHUtoAAAbg57K1e9s6URFRBJGhgKAQwgozEPYe YQuIgAytdu9l28fqH+Odd613/e4bmzSOnb+GU3wT//o0d5xLjM9cvIGzxE2umX9rDkmugLwtIO/g vAXv8hes987fX0TbAyHf/nCJ+0iEDny8jNQTMXdC7JxYcT5dRdczlLgmJe6pNfRMS7kzMu8srvtw Tu4TyGnBBj2v8OOCMoCLqoBQxQjVzJI6KNoMirZCy6gJizXhFW0EV3VRlGzH1vQxqT4uNcRlhoRs J7G+m0S5MbVhSilMaQWRVhIZpTmrIrNqMqe25Dat+S20FTT2gtbOah2szlHUUaVtqqR3lvWussFd wR1PdddTNXprRl/dhPQegf6GOdAgA02SaVqYljXYsob2baG2Ldy2Y+TAEelQ0Q4V6zox3nNh4tCN yb4HUwNveuBLD5HOjOjsyI+5owD3mMkfM4XnQe5JkD0Jsaeh4mkYSy8iWH4ZxQq+imH1dRxr+CaB 9bdJ3MN3KWzg+zQ28UMGW/gxi/v8T7k2/3MeD/hfCtjhf2W7l4vdb8XexVLvO/fwcrn/46+V/lll 8M/hWXX488q14a/a6D/ro9/1oyv+AajcmCENCmVuZHN0cmVhbQ0KZW5kb2JqDQoxNTAgMCBvYmoN Cjw8L1BhdHRlcm5UeXBlIDIvU2hhZGluZzw8L0NvbG9yU3BhY2UvRGV2aWNlUkdCL1NoYWRpbmdU eXBlIDIvQ29vcmRzWyAwIDM4MC43MyA3MjAgMzgwLjczXSAvRXh0ZW5kWyB0cnVlIHRydWVdIC9G dW5jdGlvbiAxNDkgMCBSPj4+Pg0KZW5kb2JqDQoxNTEgMCBvYmoNCjw8L1N1YnR5cGUvTGluay9S ZWN0WyAzMDYuMDUgMjExLjg1IDY2NC4zIDI0NC43M10gL0JTPDwvVyAwPj4vRiA0L0E8PC9UeXBl L0FjdGlvbi9TL1VSSS9VUkkobWFpbHRvOlJ1c3NlbGwuUGF2bGljZWtAWGVuUHJvamVjdC5vcmcp ID4+L1N0cnVjdFBhcmVudCAzND4+DQplbmRvYmoNCjE1MiAwIG9iag0KPDwvVGl0bGUoWGVuIFBy b2plY3QgNC40OiBGZWF0dXJlcyBhbmQgRnV0dXJlcykgL0F1dGhvcihSdXNzZWxsIFBhdmxpY2Vr KSAvQ3JlYXRpb25EYXRlKEQ6MjAxNDAzMTkyMzMyMDAtMDQnMDAnKSAvTW9kRGF0ZShEOjIwMTQw MzE5MjMzMjAwLTA0JzAwJykgL1Byb2R1Y2VyKP7/AE0AaQBjAHIAbwBzAG8AZgB0AK4AIABQAG8A dwBlAHIAUABvAGkAbgB0AK4AIAAyADAAMQAwKSAvQ3JlYXRvcij+/wBNAGkAYwByAG8AcwBvAGYA dACuACAAUABvAHcAZQByAFAAbwBpAG4AdACuACAAMgAwADEAMCkgPj4NCmVuZG9iag0KMTU5IDAg b2JqDQo8PC9UeXBlL09ialN0bS9OIDQwMC9GaXJzdCAzODM1L0ZpbHRlci9GbGF0ZURlY29kZS9M ZW5ndGggNTYyMz4+DQpzdHJlYW0NCnicvV1bjxy3lX4PkP9Qj9mXDO+XRRAgsR2s14ljSFrkwQqM sd1rK5ZnhNEYkP99vo992F3TVSRrSrv9IPWZ7joXnnuRRZb2cVKTDmryBh960jHh00zG8W87WRXw 6SdnLT7D5JLHp5u8jfiMU1B50j5MIfDvPMWIz6inZEE2mil7/g1cZUgQxFUiF1Apf/FyY4SvdfwG BJ0GRsI/x68TML0FRoIsPhOgEJQ4EUETIBvw11kRAUDiP2Jk/JwdAT0ZpUjZAQgE8I3mT0lNkALf ZAuATCOusRwk+BnnQDVHAJnXpMkEw28yAMhiQNREDxoKmksKFyp8mwIB0MmGDIGVC+cIrTpyVpPV ikJlAD5RqMkaTUADIGUNwAZSxsVUi8FooScOx03WO14DIEB1RgM9kqAGi2T4TQJQxgSsTBbQtVMa WAZGVZGAm0DYcNwAMgHYGUMFkGF4RSABgPmNsZNzhoCanC+8cI2HKY0F5QA3MTC9C5CQCnXRayqS jkONgmmmfmyYvLL8JgKgIqERT88yjs4IMaF1ADSRs/A3m4pTekv1w2YYOg3iJ+81sRIAGs2BYIAs BvbwgTbHSPALJQSQaAfQ8olMIZzPZIrxB4XBGW+noDlA7wFEXgPvZhgY8AsWvm0QJwHqAKAAUL0g EbwnAPQAw5pQYoIA6ESoFp4CIBEAnYTBGfwcMh0EjhtyIGUzRcWxI2Si5k+wUNQcaQwAMr9xU+Rw 6abR0lsgZbSeHqem6GgvhFV0UBLVFz3dD7EYfeTF+CZAKOMZrYYA6CT4l0GgxVR+ApD5E/w1KToS zJkYuQYDSMWXEXqJYsK7Ee20TmbYM1wgZXKUB6pJHg5rEDvJRwKgE+BWBtpPIREAnQhRLZwpJUYA REHgkrKfUqZRENQwF5nmCe7DtITUoskUWSIzNBFSUyYqTZWt5zVxyi7xm4Q8BE+xECWHEnYaAOxg 4TqZ1rHw1RwxXIvYybSORTTlzECEh2dah7rWSjGmEECAIiHkAaVJnJlQMS4s85li+FpmCUXlWOYd 5fC/NYR8CXVS8bCDhcNpxZixkEUrBo21uiRLfMdcqhKHzSyssiVkCEExlpmRBAE5QJr5hQlQMz8j iwBi4CCNALLlV0MokDJ/dXA/ywynPdMEAhGojt/xusj0whyJXM3vyC2BlnXkkTIhUslUuWM6V9Cl xQgAweQWkmlkrcxsRSgRskz7tDqiSxvajA4MiDUHDkmRCZFesSGzvfGOWZBUAixgHakE+IWFDjUi hHohRiIuqxmcE5SZ6uGCmWkSVUaTG9wcEILBsmpYJiTLgmTptBZya1ucKBLDEYM1C8z5nSXEkSMo NYZACNzAMjMDE6JUpaZFTwhS2USZWf1sioR4XYYdLUuezYgjyyrqFK0PmiyDjomcUKb0wHCMWwtH 1chAwGAlcK5QJq6npVkVXaClWftcoBUQnKimtAILKOoqIVJJtEImbuYoM+llapKlzjMnWtZUJGnF WgKI6QjiTnQXUk6EyoiIQU9ChQFEXdHjAYGqQ4CiU2ABQXEEBCkdo8dH6NmxiHuGf6n9PhFXkwo9 zGniZvYfjLKgWHQUOxUF7ihj7F08IXYrLH/UCCDozik2OPRqp3mdc6x3pOKIywgNoVQ8TQgac4zL QLuhCrJp0fyVuAl2ZPVDp8NKxigLmfIxyqKCfztGbUQksXASgq+U3ikay18NIfJg1EZ6mGPURo6V Hg8oUgJex4TJMoPGxlJXBcosyeSWFEsxeSCzAiLfjJzjGLWJPuRKZ6OpDUZtYtflXGmoQNUxVhNz tWOEJsafY0wnWoBaAgTvpxXRcHnWe80ejNpglKG9AcRIThBmYsJHw8VRMqZhNkjP+M0sII7RmBW5 0YszPIbdArszcgvs0ViaHOMyM7s5xmqm7zlGdyZ3x8yQPRuVUFqzTFz2QgGjccwRORZ6xEgcOeMy J1JmTOdM/bFqKcWuNrJD0+xcMBZA8G9mG/RxHC+rv2L1cPAjQIG/sl+jN7jS+Dl6cSoNH/TOvwDh GnZo7DFLv8Oej55dGtAIWzgWPhUpC7sH5HZwY21HkPE7UmZbwrhBm0hLs/tEAQEP1sHSRTt2MEju xDWEoCfPOq7ZWTj2mpo1xiW2jfRvttOAGBXs/LSnj7Np0oyAYztXIoD9nGZcera2mh7m2dLCcOiY VOn/2E2xlYMwaMLY+RreKfjSL7KP8rgWDSOuKT2Aoc97trCGnLwmrg/8lfQCJPWGfTjroNekEtkC ssNBZ8NfSYUNimeLZNgaeHYppa8uXY6lhjxbBmR5/spWk/cxni2dZVvpEZeAEq/LbE1Lv8mmkFnL sxG29FbPHtJSIt57AEr8jjwCMSwpx4JBypG3UKX5TeTBBhtpGBoqvami9KWBVZH6I8SWm/WMhY7d bLnngq94xBtaX4zas0d0tGNp8x1j0LMth/ODMu834N68jvTQy7EVZifMftmxOU7wGu9JOVNrbAg9 c2dpVWEo9tWlC/Ylc7PxY/yxU/ccuWYTh/zM+y7e9LDP0aWp5U2HZswE9tCafhrYYRiOPNDXmO9M ybGG9IKnFzJm0BWzJytQ6ZH4a2ItoyzIrKx+ht2xYfXzbFkZyfSwyHtAV3peNuiOGJH9h/OlMy4R rwjRh479c6bX8btQNM7mOkKLf/jDzVfl1lVNL25e3rx8d3t38+rXd4ebl48Pv3z3+Nnbw883X/0w 2fL7F5P64x9/+5sLnL+8+eGXh8PNn94+/u6T/3z9+n/eHx7ev3799vbh/U+//+TzVy8+f/XZ69ef Ht7/9Hj/7vXrD4e7b9493P/r8N3jN2/vf7j/BtHyIcTfv7v74T+mBesvvp70P6eTBH3u6/jmI/Ht Zvw9o0em+oBc2R6+W2WPrHhk/9Uajt+BE/rDfHX48Pjt/YdVAyFYcFGZGMHnbjpxHdNW13z75vvD Kv8ye/OizN8cP7V8Gvm08unkMzblRMbvB4IOy0g4IV0nEo4i9Nl3Q6FJoGMcu466wTpoF4rWo1gl ilWiPVvhkmx0AzMYszTDCek6ZjiK0GffNcN+AnadQDJC4K9/vv/+104yWSDqivj56oDTzFQLXD9i 6huIbsA0dJjGEdOwk2nqMM0jpnEf06zaTLMeMU07mZrOSE9M15Uk+T5J3k0S4UdZGyRVn6QkhaPU g/jo1aLUkWELgbyOuiHPRdFKFK3EJJ+inSTVKXeCKY/ynvXLvJevm/eOIvTZ9zux3QTsKgEuN2zL ewvEft7jgsa5UbjEdSOmfidT32G6Ne8tEMOAaeow3Zr3nstUqw7TbgoSRVTZGiS6KUe8phqySjsg tdo6p4Ffd9KNjLOscLW4byKU11E35K0seStL3sqSt3IWvSiR0LT1o09sGnnL6UXeOiNdJ28dReiz 7+at/QTsOgEzrO2ugXjy7PXAMjNTLXC35q0Foh0w9R2mYcQ07GQaO0zTiGncyTR3mPaTjpFkc1RI lbHhX7lPSjKHsR0SdSS9FGRUm4Ddkvh2cbW6yXVD1uLE2zEriSK1FASd5FOyl+0NrvYNzay17LbO SFfKWr4h8+astZuAXSfgTh4+ylqXnE/+vB5Wbu4Rl0ztiKlvIJoBU9dmavsB6GxH3uFdcdippNBh OuwO406mqcN02B2mfUy96lgm9S0jLYuTFu+IXhVUZR7ERzd5fSSBvIq6Je9ZK3lNhmQl/1kZmpX8 5zvB5Id5Ly/znr9y3ssNmTfnvd0E7DqBsDnvXXIeOHqYm+qS6ea8d4k4yHvBdZhuTl7PZRo6TDcn r+cyTR2mm5PXM5lG1Wbq+2VFVivEClUxVdZ1knFzRGdBKtf8/c///eLm79/+a/JHi69RHs1InShr tSLPX9/c/bSuIBldbLnEhYChKWDcLKBeJx2bpMejkGwrc3wmdcy+3UbazLCG94gmisNEaYllAtKk Tl4Z5aRoOrj94iurcBIidQSDpNwrtr7j+FsI6PWEvqXaelGtF2/1Um1lxVFUUR4ZbYqYRnMjos8n 1TZdd27kKEKffbfa7idg1wmM1z1cA3EwNzJf91jgbq22z2bqOky3zo0sEP2Aaeww3To38mymucmU jyVvq7bPZGqV7oy0PyGTJaJl1lNkbDh1v3BnmZDJkjSy75DaMkWSe7JsIJBXUbfkvSSlJIl2Ui0p Nd9l0VY7mKwa5T15HmWe985I18l7RxH67Lt5bz8Bu05Ab817C8R+CrLz6fsF7ta892ymrsN0a95b IA6ygY4dplvz3rOZ5g7TbgoSRVTZGn7VTT3iNdWQVdqBi/ae9pkvzV0SMFvmhHdxNbrJdUPWsrKS Z5UoVBYJraq5XbKW6Q1u1KUf7+yeZi1z3bmRowh99t2stZ+AXSdgt86NLDj370PsfJVgwXS47O93 MrUdpsPls7CTqW8zNd07LtF+VUiVcWDqbhzmjyMQV1G3hLCRBHZcTCw7wo6fEspGQtmGjolGMwJx +QznGelKIRwaMm8O4d0E7DqB8YqFayD2HzSz8xWLBe6wHPsGYhwwzR2mJ4HXUVMb1Q/zXNinpPl0 /YLpsDuLDcT+JCU3IraZDt0h7WTacQc/nAPOO5l2bDpwB5kCEoVUGRukbN+zhIQsQ4k3VekHcd3L 165jyC0EtFrF3ZKwZb3JypKbddKJytKbqKRsTW2KeFpZaSXstHza+4x0nYSdTEPmrQl7PwHbIDDM na6BOMid84WGS9zTdPTQVH51sv04gbBKeTRdcKIcVsRpzdBbmRS30f9fDCrOkIalwMpOBxla2Sbd lGFklPks+kL+YdpMO5mmNtM0HH9uSDtohFNnpGeB11FVBzV0UYPksSh5TBZRRNpBCPdy83yz0R4C NTdf4G7JzbIPysqKopX9T1ZWFkUlZWt928zDsFw+K2CvvHqRckPmzbl5NwG7TmDz6sUCcTChNl+9 WOBufbJzgdh/3tHOJ7IXuFtn8Z7NNHaY9ifUsvh5Dm0S/bl8MWCVcuAlvfCfz+EvhlEr+OpEWvwY rrnJdUvikOl/m2qCkGQo0/+2Tv/n1GTD8yb6iSMvH648I10ncWTfkHlr4thPwDYI5K1ac6v91dHw a5T1qMk5UfYr4rT6K3dcVijHlZxcYf+gwgxp3N4eJ6nr0MrxKG0Z+q2Om28kWeB2Wwc33zvTdIhO tIps+wnEVdQNge5k94k7zs6Xw2mOn14+g2jWtyU8reM0t0yr5ZT5GetKe6aVaki9edP0fgq2QWG8 FcO1MPvF0833YiyRhyXb72Ube2yHAR32ss0dtuOlibiT7XxtYsl2uDiR9rK1PbZDl8p72XZd6jTa dQNJWpHZfHGFapuqrCr9KN56qdT0lLOFQr3dukTekk1lD4qTvSfOyPBkp45oqRxm1bHgaPVCq+Vz E+7KyxciQ5//IJ3upmAbFDavYCwx+7Pzzj0x2CXycPbF72WbemyHjy6HnWznGy+WyN0pbrFBVUqV cmTyXkQ795EU4jruloCWyW0nk9tOJredTG6LMsqJcG0Zh7sttF7pj6683UJk6PPvB/R+CrZBYfOO iyXv/hyjm2+5WLLd+lzB89naHtutTxY8n63vsO0/zS02qEqpUo5M3gvo+UrQUgm1RPemRPbxnU/E XlLYkgx8DXZJcfIsuJNnwUWRdQit8Q3Pl9Ir1f3aB0xp15B6ezLYTcE2KMThXYtrYfYf3XPxiWNc Ig/LrG9hpj7b+WLFAjkNJ5DDXramx3a02+fsnnUp7On8k5Y7gVXiw4mCE/G0IlJzCkpmJ9387Kan zC9ltG0ZR1NVZxnzc2TMkkaz3iqja8qYxw1FlfG0J+uSul+nfnlZ2HZZ3HZZ2nZZbltnrGdJ0rIE 4ORwEyeP+Ts55MTJ4/4u55Y9nhcNp71lX5VzZkeZSk7QkpCobldNW46v7aSkUYS7HvIpGa7nQhEk SaebbI9W98kZydhV3lFh6JXu6D+Sgm7UpS11X84vdHJ+oZNVfSer+qKFcmxwU0ivhjFrlzcBZ6wr 1X2rGlJvrvtNChuOlrTP7sm8zFt7ma/2Ml/t5zPqS5mGPZhdPiB6xrqWLUJD6u222E3BNiiMt2y4 Fma/B/P6icEukTf3YAvMfqr0850AHZnXRc4d3PHRTmGnpuZnOy3ZDu8hYwuzP/3rn6woPFNTxvVE HvpU2qupnk+ZoU/lFubAp+xH+JTp+ZQd+tRp8vq5qrI9pxqvKehW0rIDr7I9r7JDz9CtVDfk2003 fRtZqfdPZvEXNLqtkSTSmp9quqhRWIOi+lo1fR3XKL93aq3XPY1voaAbxWFTuc4ybBmOPDzgZdua aK28I6DjFsNbtJVju85YVyrfF2furPLvl+/9FOwzKPx/nln/VICL27zjnPmqnG7YoJ0s7GdYp3WY xs2hd+J+TxY4FsyH628n5mGG1Z23lBGVF1N0OG+a+2watRf1shzj5zsNdlFK67hbgl8WUbwsnnhZ PPFOgl6WjkQN5eUcDVln1F89HA4v7u8fb17cvz387fZdeWtH8avbh8Nd+bm8vqMY7Ov6HoJ65H09 EroesVqPLqyHeNXzRep2+7qNte6Cq7sr6pO89em8+thOXXKuC1V1prretNb7o5p5qw046JP8X8Ia Xxx+nWz19b9gvHf3j4ebL/nfZ3ffn/+olnuJWL35r8Pt94eHI0ycCn9+9/bN3eHlj7fUIr/40x0o 3D6+ub+Tvx8e3/zvLYDy1z/uH3769v7+p5tP77/75WcIVb55/+Ph8EgpH2/+dvvdw/3s709+xP+z vz99c4u0Mfvi6CPna498cNkPD7c/S3KSsX75y8/vv55UefFKMVR58UoxSXnxSlF6efFKUWt58UpR ZHnxCqFQXrxCKJ6OyEmnQ3LyCeK7UerB5rq8mKWApryZpYC2vJqlgK68m6WA/vR8P99RVykcX9RS wHR6QI2v66rnU6ry1pajz5XXthTQlPe2HD3wNDvEN1PKBBFfYyRzRHxXVwXjGUxnMJ9Aq86gLi+E OTpxeSPM0Y/LK2EK6Gq6+udEIzzn/Roy+FCDTLqsQmT0Gohy0fAMdeEkmpHj+usJ+vVQ+/MZ64Xo 8IBjiXkxuZyFXY+nrkcznw9AJtHh+aOSIORU3HpQbT079nz8aSE2OtRPTCOHVdZDIOu5jPWoxPOh f4Xo6OwisaKcBFcPZ6vnpdUjzGbHS8nvp7OuBD/N1TI6OOTkm3Kd2ESOjaknuZwPFiHR4b5+XV1b rhNbyJkM52MFCrHRDmNptWUTeN2Xfd5xXIgMd70JUek4ZHtn3XFZN0HWfYnn3XGF+HDbhhA9bS+S 72s6jPUpbaEzN9Dw0e6aJiRo5DH88xPlJDJ8bPT0YK78LoY5PUZaiAyflhJiYhh5yq8+dlefg6sP pp2fqirEh09uSMGQCJJnXs5PchQioxVfMZQs69d19vNKcyEynD6uq1cigbwJ47xEUFcqBD/X6WZp p9RM4uF86PGi0V2YNItiEJlxqlNAdV6lTnTUyYN6M19vrs93cYXp1u5PDCGdcu1Yz93gb3/zbzG9 JPwNCmVuZHN0cmVhbQ0KZW5kb2JqDQo1NTQgMCBvYmoNCjw8L0ZpbHRlci9GbGF0ZURlY29kZS9M ZW5ndGggMzI2Pj4NCnN0cmVhbQ0KeJxdks1ugzAQhO88hY/pIcI2ARIJISUkkTj0R6V9AGIvKVIx liEH3r5ml6ZVLIH0aWbMmHVYlMfStCML31yvKhhZ0xrtYOhvTgG7wLU1gZBMt2pcCN+qq20Q+nA1 DSN0pWn6IMtY+O7FYXQTW+11f4GnIHx1Glxrrmz1WVSeq5u139CBGRkP8pxpaPxGz7V9qTtgIcbW pfZ6O05rn/lzfEwWmEQWVEb1GgZbK3C1uUKQcb9ylp39ygMw+kEXS+zSqK/aoT3yds4lz2faHJA2 55mEOCElMVK8J9oSHYl2SGlCdCJaNNplu0NKOVFBJJF2nChCOsREMVZfOt4b/55QFBgShSB3srhJ jx8OKIqUbFg0iukTsiCaq0kuE6R0gyQiogNp8n+Z+Y/Og7+PS92c85PC24EjmofTGrhfINvbOTU/ P8SwrosNCmVuZHN0cmVhbQ0KZW5kb2JqDQo1NTUgMCBvYmoNCjw8L0ZpbHRlci9GbGF0ZURlY29k ZS9MZW5ndGggOTU2OTYvTGVuZ3RoMSAyMDA1NDA+Pg0Kc3RyZWFtDQp4nOx8B3xUVfr2OffOZCZT MjPJTMpMkplkyARIIEAooUgGUiihpQwmgUBCQlMQDFWa2FCDWLH3XlCZDKJRLKjYu4u66tpW13V3 QbGuCyT5nnPfOSGA+um3u9/+9/fPSZ55nvOecs95T7lvTJBxxpgLHzo2rbhywrhDq77rxZRv9zLm Oa9kbHFVovsZD2NfhxlzP1MydlLR5qonMhn74gBjxt3jiktK//z0t4eZ8tVnjKlfjps2tXJh08gz GbesZvw6y7jK0NhnPvy0kyl3nc3YuFlTK/MG/eOzd1MZ47/HU+sbFzcsXRdz7oWM9dFhAIsaVy73 ha/d8yZjtdcxpk+dt3T+4h9+mGxhrN9SxmLd8xuWLWWpzI/nf4z29vmLTpt3/iVttzI2u42xqWsW zG1o+jyr4wT0PxPlQxfAYL3PgGfzrcj3WrB4+ephH3gnMaYUMBZ48eS5zaesa5+Pvl5Zx5g1d9GS xoYnb7n/Bca2D2YsvXRxw+qlGUOy+qE9+me+UxoWzw2sLP+OsffuYiwucemSZcs7PWwTxrNblC9t nrv05O1KBx59AR5nZ8K3+hva1Hf3bZ1tG/U9SzEykXb9bd3Lgp/JvGrNoYPtm2P3GR5ENpYpjBLa xbAOxveYbjp08OBNsfu0nrolXZGw2DLZOUzP5gEKs7M8Npcxx8V4ropSVZfDL0aJUX+1Ph9dphOr r7NNCjMyxaZXFEWnKrpPmNIZZPd2aiNAmlzp87EgplNMYzDcoAR8jN8oytSH9HFipug97sho+GsY 0c1iXX5b0tWye3XFrOEny/axe7vn1S+Ozv9cUu9j9+otbMZx/R0+0l7R/bq+jmrfm9qodT/dNuYd PLfvT5fpJ7HG3/SsTOpHP4c16qqP8cN9bNxPtVE/Z7ajnpnJ7vnVz2thmYZ0dsJx9mw2AP2m/9p+ etL/vqS+xWb+1ja6wexqdQ6r/ZV164963iFW92vaKaeyrN86rv+fSd3DhvyaesJXUvO3cd//hsT/ 2vlW1/NuPaqfq3+qfkwTu7r7844bS8GvW7Ou+tG+xBoqLx7dr5rByn9NH8r9LOO3PPOfSRjn1l9b V72eZerbjl9DdRXro97IMo+z92E1/+z4elJP6kk9qSf99yTlWm6SWt35y+9v3sn6am16sV2Knl2p 38Su+FeNQ0069mfI6PiWsRKt/HDnDz/b9jB7sqv+YnYOsOZfNa6ffN4Qtrl73pD973zavzfh5+ST /9NjEAnjGA/cDzQD84EBwFwxPqAxWqfiPzU+5XpW8C/tr7Wz7J/tA/Hd+F8qx7mY9c8+oyf1pJ7U k3pST+pJPakn9aSe1JN6Uk/qST2pJ/WkntSTetK/NalRpNJvSfgU7W/omDqC6fggGALMx3QsBsrK MlkW68OGsRHsBDaB1bA17CZ2n8/uS/Bl+gK+4s5OrUcrWmSx3iyXDUe9QlbGGo6rxzu/Z0znVKeL BjodDaWzUXnm0zmfNnxa82n+p59Ff2uTGf0U/428gE1iC46fgTpRvVINqc1qtbpI3afuV79Uv1IP qF+r36jfqt+rJ6qT1WsxBweLZ8mYZ4BlY2x5bBQbzYpZCcZ3IuZSy2axJvS+jC1np7E1XOE2budu ns5782m8ltfxhXwRX8JX8JV8PT+fb+YX8Iv5NXwn382f5M/y5/jLLIbv00b09XG/ceJMif6No8J+ OfEjc9J8M1zLblBP1/hnZokSzFOrPwb6p+fLfnnGxwzj/2X+/4akrv0X9VOj7XKZW358DV3v39Rh z+n4jbsjOK5p9qy6mTNqa6pDVZUV5dOmTpk8qWzihPHjSkuKi8aOCRaOPmHUyBHDC4YNHZLXv19u 70BWL3+mN9npsNusZlOs0RCj16kKZ7kl/tJ6XzhQH9YF/OPH9xN5fwMMDd0M9WEfTKVH1wn76rVq vqNrBlFz3jE1g1Qz2FWT232j2Kh+ub4Svy/8SrHf18Zry6uhtxT7a3zh/ZqerGldQMtYkcnIQAtf SfKCYl+Y1/tKwqUrF7SU1Bejv1azqchfNNfUL5e1msyQZqhwb//SVt57NNeE0rtkRKvCjFbx2LCa VdLQFJ5WXl1S7MnIqNFsrEjrKxxTFDZoffkWijGzzb7W3N0tF7TZ2Zz6HEuTv6lhZnVYbUCjFrWk peXcsCMn3MdfHO6z5rNkTHluONdfXBLO8aOzsoquB/CwPsvu97V8zzB4//59R1saopaYLPv3TEgx xS43oVxqhrFhhJhfRoYYy+a2IJuDTHhjeTXlfWyOJ8KCeTk1YaVelOyWJa6QKNkoS7qa1/szxFKV 1Ee/Vy5IDm+c4+uXC+9r31n4RrkvrAbq5zQuENwwt8VfXEx+q6oOB4shgg3RuZa0DshD/YZ6TGKh cEN5dTjPvzTs9I+lCjD4xBosrKzWmkSbhZ1FYVbfGG0VzispFuPylbTUF9MARV/+8uqHWX7nx62D fZ4d+WwwqxHjCCcWYVECJS3VTfPC3npPE/bnPF+1JyMcrIH7avzVc2vEKvnt4T4f43EZ2hO1Vpjb MbVlZTFzQ5bRV6141BqxWjD4SvHhHzsKBXYsl5YVKzp2lK+ae5ishqdEawh1VD/IqFlF40WRKpoW jfdk1GRQ+oUheaJj0meFjd36ssPQNSZ6zs8OjWqLAfXxlcwt7jbAozrVRwcY7e2nx6kIX0QfjBZG sZzjZZGahZMLm4JuNJNYxWRfmE3zVfvn+mv82EPBadVibsLX2vqWVfrLymurtdWO7pKqo3JUXkC5 MMtAscwoRdiDpTkeuaxafpyW78qOP6Z4giz2tRj9ZZUtonN/tEPmwwnCpGMCExo2F8QPxtEsxe3m L23w4+VS2tLQ1rlxTktrMNiytKR+wQjRh39CU4u/snqURxtrRfV6zxrxqHhWxsuqxvbLxd0zttXP zytvDfLzKmurH7Yz5juvqjqicKWofmxNay+UVT/sYyyoWRVhFUaR8YmM6KkCGaNW3/NwkLGNWqlO M2j5xjbONJtR2jhrbFPIZpc2BTYd2YKaTSQsUvICuBjXbYmvSSzPupoFLfU14nCxRCwlvnmY+0ez sOIf3cqVGEvY5J87Nmz2jxX2QmEvJHuMsBuwMXgih3PEndRS78c9hQ1VzTyctqIquvS1dXZWVWe8 4tlfk4GtNhOorQ7H5uDu12dNRL1xAvUwjwtvbGwQ42ChatHWkDWhsQbbVnaIKhPCseghNtoDapRq bcR2RKNGrA0WUGu/EZnwxppwTY54aPXCGm0728NsvH8Elp361AfEg/JqWuL9g7SziaNgyjpXUCzG xiqryeJBFg+rIScZLBh5ox9FjfU+eFvHGiux1ekuNXnIMhdXoi4wV4PJEy1kYlpqltlqCsf2R4f4 FtrcXxxJfZahpoYGr+XOjVbAs+1hM0YU6ObKaAN4B0UTxFjwfS6GKqo+Kbopb2MV/tW4WcSgtZ4M KA5bsyY04PKn9mZY/AWysVHcEeZoH3vIahAzt8DvalZVW+ed/tMyuqV+uX7xchAbk3kexsZmNS3H GsIzcvrlGo+1WjVzS4vR+tMNyF9GaxcLo68Ebw3GIrGqr005+4HYZD4R4iwpzpTiDCk2SnG6FBuk WC/FOinWSrFGitOkWC3FKilWSrFCiuVSLJPiVCmWSrFEilOkWCzFIilOluIkKRZKsUCK+VLMk2Ku FE1SNEoxR4oGKeqlmC3FLCnqpJgpxQwpaqWokaJaihOlmC5FSIoqKSqlqJCiXIppUkyVYooUk6WY JEWZFBOlmCDFeCnGSVEqRYkUxVIUSTFWijFSBKUolGK0FCdIMUqKkVKMkGK4FAVSDJNiqBRDpBgs Rb4Ug6QYKMUAKfKk6C9FPylypciRoq8UfaToLUW2FAEpsqToJYVfikwpMqTwSeGVIl2KNClSpfBI 4ZYiRYpkKZKkSJTCJYVTigQp4qVwSGGXwiZFnBRWKSxSmKUwSRErhVEKgxQxUuil0EmhSqFIwaVg UcE7peiQol2Kw1IckuKgFP+Q4kcp/i7FD1J8L8V3UnwrxTdSfC3FASm+kuJLKfZLsU+Kv0nxVyn+ IsUXUvxZis+l+JMUn0nxqRR/lOITKT6W4iMpPpTiAyn+IMX7UrwnxbtS/F6Kd6R4W4q3pNgrxe+k eFOKN6R4XYrXpHhVilekeFmKl6R4UYoXpHheiuekeFaKZ6TYI8XTUjwlxZNS7JbiCSkel+IxKR6V YpcUj0jxsBRtUjwkxYNS7JTiASl2SBGRolWKsBTbpbhfivukuFeKbVLcI8XdUtwlxZ1S3CHF7VLc JsWtUtwixc1S3CTFjVLcIMX1UlwnxbVSXCPF1VJcJcWVUlwhxeVSbJXiMikuleISKS6W4iIpLpRi ixQXSLFZihYpzpfiPCnOlWKTFOdIIcMeLsMeLsMeLsMeLsMeLsMeLsMeLsMeLsMeLsMeLsMeLsMe LsMeLsMeLsMeLsMeLsMeLsMe3iyFjH+4jH+4jH+4jH+4jH+4jH+4jH+4jH+4jH+4jH+4jH+4jH+4 jH+4jH+4jH+4jH+4jH+4jH+4jH+4jH+4jH+4jH+4jH+4jH+4jH+4jH+4jH+4jH+4jH+4jH+4jH+4 jH+4DHu4DHu4DHu4jHa4jHa4jHa4jHa4jHa4jHa4jHa4jHa4jHZ40Q4hEDVH0kd7ETNH0l2gMyl3 RiR9BGgj5U4n2hBJt4DWU24d0VqiNUSnRdLGgFZH0opAq4hWEq2gsuWUW0bUTMZTI2ljQUuJlhCd QlUWEy0iOjmSWgI6iWgh0QKi+UTzIqnFoLmUayJqJJpD1EBUTzSbaBa1q6PcTKIZRLVENUTVRCcS TScKEVURVRJVEJUTTSOaSjSFaDLRJKIyookRzwTQBKLxEc9E0Dii0oinDFQS8UwCFRMVEY2lsjHU LkhUSO1GE51ANIpqjiQaQc2HExUQDSMaSjSEOhtMlE+9DCIaSDSAOssj6k/t+hHlEuUQ9SXqQ9Sb KJu6DhBlUZ+9iPxEmdR1BpGP2nmJ0onSiFKJPETuiHsKKIUoOeKeCkoiSiSji8hJxgSieCIHldmJ bGSMI7ISWajMTGQiiqUyI5GBKCaSMg2kj6SUg3REKhkVynEiphHvJOrQqvB2yh0mOkR0kMr+Qbkf if5O9APR95HkKtB3keRK0LeU+4boa6IDVPYV5b4k2k+0j8r+RvRXMv6F6AuiPxN9TlX+RLnPKPcp 5f5I9AnRx1T2EdGHZPyA6A9E7xO9R1Xepdzvid6JJJ0IejuSNB30FtFeMv6O6E2iN4hepyqvEb1K xleIXiZ6iehFqvIC0fNkfI7oWaJniPYQPU01n6Lck0S7iZ6gsseJHiPjo0S7iB4hepiojWo+RLkH iXYSPUC0I5JYCIpEEmeAWonCRNuJ7ie6j+heom1E90QScV/zu6mXu4jupLI7iG4nuo3oVqJbiG4m uonoRursBurleqLrqOxaomuIria6ihpcSbkriC4n2kpll1EvlxJdQmUXE11EdCHRFqILqOZmyrUQ nU90HtG5RJsirgbQORHXHNDZRGdFXPNAZxKdEXGFQBsjLlzG/PSIayhoA9F6ar6O2q0lWhNxNYFO o+ariVYRrSRaQbScaBl13UzNTyVaGnE1gpZQZ6dQzcVEi4hOJjqJaCG1W0A0n0Y2j5rPJWqimo1E c4gaiOqJZhPNoknX0chmEs2gSddS1zX0oGqiE2m40+lBIeqliqiSqIKoPOIMgqZFnOIJUyNOsb2n RJxngSZHnP1Ak6hKGdHEiBNxAZ9AufFE48hYGnFuAJVEnOeCiiPO00FFEedG0NhIfCloDFGQqJBo dCQe73d+AuVGRRw1oJFEIyIOsTWGExVEHONAwyKOatDQiKMWNITKBhPlRxy5oEFUc2DEISY2IOIQ ZzOPqD8170dPyCXKoc76EvWhznoTZRMFiLIiDuGlXkR+6jOT+sygznzUi5condqlEaUSeYjcRCkR ex0oOWKfBUqK2GeDEolcRE6iBKJ4auCgBnYy2ojiiKxEFqppppomMsYSGYkMRDFUU081dWRUiRQi TsSCnbY5XoEOW6O33dbkPQx9CDgI/AO2H2H7O/AD8D3wHezfAt+g7GvkDwBfAV8C+2HfB/wNZX9F /i/AF8Cfgc/j5nv/FLfA+xnwKfBH4BPYPgZ/BHwIfID8H8DvA+8B7wK/t57sfcc60Ps2+C3rIu9e a8D7O+BN6DesOd7XgdeAV1H+CmwvWxd7X4J+EfoF6OetJ3mfsy70Pmtd4H3GOt+7B22fRn9PAU8C wc7d+HwCeBx4zHKq91FLs3eXZZn3Ecty78NAG/AQ7A8CO1H2AMp2wBYBWoEwsN18mvd+8xrvfeZ1 3nvN673bzBu89wB3A3cBdwJ3ALeb+3lvA98K3II2N4NvMp/svRH6Bujrgeugr0Vf16Cvq9HXVbBd CVwBXA5sBS4DLkW7S9DfxaYp3otMU70XmuZ7t5hu915gutN7jprlPVst8J7FC7xnhjaGzti2MXR6 aH1ow7b1IfN6bl7vWV+2fu36bevfXx+MjzGtC60Jrd22JnRaaFVo9bZVoUeUTWyeck5wVGjlthUh 3QrniuUr1O9W8G0rePEKPmAFV9gK+wrfCtWyPNQcWratOcSapzVvbA4360aGmz9uVlgzN7V17t7R 7EkvBQfXNVvtpaeGloSWblsSOmXe4tBJGODCgvmhBdvmh+YVNIXmbmsKNRbMCTUU1IdmF9SFZm2r C80sqA3N2FYbqimoDp2I+tMLqkKhbVWhyoLyUMW28tDUgimhKbBPLigLTdpWFppYMD40Ydv40LiC 0lAJJs9S7am+VNUuBjAlFSNhHj52gCfo+dhzwKNjnrBnt0eNt7m9bqWPLYUXTU3hS1JOT7koRbUl v5asBJP75Jbakl5L+ijpqyRdQjCpT/9SlmhP9CWqLjG3xMlVpRoXFhMPHKLNdXKiP1Bqc3Gby+tS SrwuzhwfOw44VNcT9tfsis3GbbZOmxK0obotzhuniI/OODUYN3BYqc3qtSrio9OqJgatsIgesy3T qkptZq9ZCRWap5qVoLmwqDRo7jeglKncxznjdpBqFKPgLm8pzvWORK7neJ+3VlXm5JS1GVlFWdg4 bUaYnxfOqhSfwfLacMx5YRaqnVHdyvmFNa1cKaoKO8VvbLX8OVu2sLFpZeG0yurwTWk1ZeGNEEEh OiFYWmsiG1uTM2vZimU5Octn4WPWsuU52jdyfIXI5Qij+F62HHnxtULLs5xfTFQNNHsZ0nJpXP7L rf6nJ/6fHsB/f2pl4o8MxnQqZ7Mm5SzgTOAMYCNwOrABWA+sA9YCa4DTgNXAKmAlsAJYDiwDTgWW AkuAU4DFwCLgZOAkYCGwAJgPzAPmAk1AIzAHaADqgdnALKAOmAnMAGqBGqAaOBGYDoSAKqASqADK gWnAVGAKMBmYBJQBE4EJwHhgHFAKlADFQBEwFhgDBIFCYDRwAjAKGAmMAIYDBcAwYCgwBBgM5AOD gIHAACAP6A/0A3KBHKAv0AfoDWQDASAL6AX4gUwgA/ABXiAdSANSAQ/gBlKAZCAJSARcgBNIAOIB B2AHbEAcYAUsgBkwAbGAETAAMYAe0I3pxKcKKAAHGGvisPEOoB04DBwCDgL/AH4E/g78AHwPfAd8 C3wDfA0cAL4CvgT2A/uAvwF/Bf4CfAH8Gfgc+BPwGfAp8EfgE+Bj4CPgQ+AD4A/A+8B7wLvA74F3 gLeBt4C9wO+AN4E3gNeB14BXgVeAl4GXgBeBF4DngeeAZ4FngD3A08BTwJPAbuAJ4HHgMeBRYBfw CPAw0AY8BDwI7AQeAHYAEaAVCAPbgfuB+4B7gW3APcDdwF3AncAdwO3AbcCtwC3AzcBNwI3ADcD1 wHXAtcA1wNXAVcCVwBXA5cBW4DLgUuAS4GLgIuBCYAtwAbAZaAHOB84DzgU2AeewpjEbOc4/x/nn OP8c55/j/HOcf47zz3H+Oc4/x/nnOP8c55/j/HOcf47zz3H+Oc4/x/nnzQDuAI47gOMO4LgDOO4A jjuA4w7guAM47gCOO4DjDuC4AzjuAI47gOMO4LgDOO4AjjuA4w7guAM47gCOO4DjDuC4AzjuAI47 gOMO4LgDOO4AjjuA4w7guAM4zj/H+ec4/xxnn+Psc5x9jrPPcfY5zj7H2ec4+xxnn+Ps/6fv4f/y VPOfHsB/eUqePYsxww2MdVx21F9yT2MnsWVsI742sS3sMvYEe5/NYWdBXc1uYnewu1mYPcleYO/8 pr9j/7+kjtP0i5lFfYjFsATGOg927u+4A2jTx3WzXIZcgs53xNJp7/zyGNuXHZd12jvaYuKZSWtr Vd6E9Vve3nkQ71fkO4eKvHIutE1r8bXhho7tHXce44NyVstmsJmsjtWzBsxf/FX6QnjmZLaILWan aLlTUDYfn/OQm41auEs0faTWErYUaGbL2Qq2El9LoZdFc6LsVC2/gq3C12rtX0esZevY+ujnKs2y DiVrtPxqYAM7HStzBjtTU5LJchY7m52DVTuXncfO/8Xc+V2qhW1mF2CdL2QX/azeclTuYnxdwi7F ftjKLmdXsKuwL65l1x1jvVKzX8NuYDdiz4iyy2G5UVOi9FH2LNvJ7mfb2YOaLxvhNfKI9Ms8zYdL 4YN1mOFZ3UZM/lvV5a0NmLuYW0t0pqthP7Nbi5VRP4qaZ6Em9ULrIHpZf4wnLsYcSB+ZEeUu1+Z/ xNrdK79klf64rptnrtVyQh1r/Tl9BbseJ/BmfAqvCnULNKkbNd3dfkNX3Zu0/K3sNnY71uJOTUkm yx3Qd7K7cLbvYdvYvfg6orsr4vvZfdrKhVkri7Ad7AGs5IPsIdam2X+p7KfsO6L2SJflYfYI24Ud 8jjbjZvmKXxJy2OwPRG17tFslH+KPY28qEW5Z9lzuKFeZC+xl9lr7BnkXtU+n0fudfYm+x17h1uh 3mB/wWc7e13/GYtjYxjTPwI/X8dm4UuPW2mZ+iZuEZUZ2HA2mU1hMx5lVrzuE9kIvnOnq7jY2M/w OF7lCvMhGDAyzouCNp1ifcjtLvQ/NCRmi+qY0Mb7PVBo2IIwt7D9w/ZX89o/3B8/PG8/z/vgkw8/ sX/9qmN4Xv4nez8ZOIA7MhwanHGKweCM8Wf2V4ZkB4bm5w8arQwZHPBnximabfDQYaPV/EHpiuqU ltGKyHP1zcO16tT2GGWDv3B6vj7dbXNaY/RKanJ8v1FZ9soZWaP6pxlUQ4yqNxp6DxubWbaoJPM9 gyPNlZgWbzTGpyW60hyG9vf1cQe/0ccdKtItOrRVjRk5s7CXepXJqOhiYtrSk1P6jsyYMN2WYNeZ E+yORKMh3mHpXTyzfZMrVfSR6nJRX+2T4RZ/50HdBr2TZbIAu/5h1qvziwcsdj7J3xYVgbbOAw+Y IcxSmCCCbqGy7OLTqn1atM9gb54linPNfHIvfyDrO4vZkpyZ5jdZeaLOwix2i7Ld/4T/Nb/qt/gt 8WkV8SF9iBUWFsYPH56XV1fnSBrugHTk2/cPcuTD4zl19CpkOTlZiYkxmsuz1Qw1TvVnBgJDh3Hy c5LBr2boVhi5PcvrzUqI1S1p//wk1ZTgT03LsnEjj+isKdnpvr7uON1a/hF/6oRET5xONVhi+ciO F2KtsTp9nCdRFzHHGVXVaDNvaV8r/i3kveIfd2F3pbMcVsCeD7q9yXY+2Wu3iQ8rPpIt+PBhruJ3 xMHeblcQ5a4gyl0uc66onCsq54rKuaJyrqic+wh+JmSdu3dCs0A+PL0DNcEHdtiibNX4hx0Wjb/Y YRas2IPWm8y7zYrZnf3dwIGGXtp/lS4f3MbNrYYqVri/UNu3w3le3Sea0wbtzSEBc07OcNJwqjNO 58/IDAxxDB6anwHvucR+Tlf54P6K3+8QmznhiNRxb8HUxlMndNyf1KdPEg8s39o4KDFnTN8hM0t6 d7S7C2onRvYUVQxNmZI17uTyVw+OrC4K8GUnzK8Y3dflzdadme3NrVozuX/VuIJ405CKUxSeN2lI akedf+TU9g9GVI/ydhSkDqtgnDV0HtBZ9Ok4xXN2pLKROVGv5ES9At4nvAL+UnglJ+qVnMfxM3Yc S+Z5LIMFeG4koVK3i/dlQ9gA3r81djqO9N79AjyPpm9/e8/AAVnOuJhuxzLGFT2m4gC7nOmKmLfY VjqLojc6g7PXTtjw0kWTK6944/SCk2pLPUa9qjOajXGDpp46dfqWpmFDGi+eMXlZ+WCbwRSjPmRP jo9z9sn2VN329fU3H94+0+Xr64lLcMc7UxNis/OySzY9uW7tY6ePCeQFYhzpOIFil12EXRbPvGxV MK0wgyeInZMgdk6CE3NOiMeEE5Ix24RdYucwN/nGHfWNO7pj3NEd4476xr0LP/fHwjeWSFy5p40H WvW0S6Qv9sodUSdutKO2hKHbBrho+u0H7uj4Ulv+rLu+uL585+Al92za3rrunubhyjV3Hbq9ghb6 xFu/uHrhzrMnHnaM3vik+PermJm6DjPLZStb3dnRFc2Ojjo7Ours6Kizo6POblMcwdjYBF+CD4N3 t3Fj0LoxwHcH+OsBHgjEpIhf0FjLs0GtMV27vu7UZkwrT7tG7NHdr62zctxO92c4jpHqOp3Jamy/ TMxQmWe0GvV6fHTE8IgRV4MuFnqKwo1Wk25cvCfeSLM1xnuc8R6HseOkWHtqQrzbbugYaHR4tHl3 HlSrMO9sNrPVkBCdd0J03gnReSdE550QnXcC5r3TmsbS0wyY2o6EhJSYNt57R2Z5irggo2+kvD2O 4V2z48dNRr5t5HTVKkzM0AHvGTB4TQeNTp87OdNpxFRLNeuehFTMYrzB7nEleByx7X8yWA16PT50 94tZpokZzej8Urda72OF7JZgWmqqLVns0GSxQ5PF3ZZssgiFWSSL1bOyJ7K5LzuYXZ+tZtui87dF 52+LnmRb9CTbovO3ib8OzxvMBye3cdMDmZnD80bv4ia84028T2R4pbON57bmTRfrjdPsIHdE77m9 dXV7ui66qF+OOs1DhznELhCnXfOWQ9yAR86/TrdaZ7QYLAWzzqo9+Z6VhSVr7p47au2Qjr0Ohy4W 74hrzYnxpvgRM+c0Dbxi363T6+7ef/HEM+eWuE26WQlpCcZA/8CUlseXrNt9dnFaGj8tsxfcaDTa U+M7EtyBtMxkS929B7ZeczDc4Pb3cWfS/tBNwzs3j7U9UDiQ+y1RF1miLrJEt4glukUsURdZhHNT k3qZhffNwvtm4X2z8L5Z3A9m8Y5IYkEXXizBBPFhd/BJLIhyliR+aYECwQ+iLKlvBV4guUHbbgt/ 3cItR7+NcaD2F3K8NfYKt0a33JGDVZfVtdW67zq6NV2wSambZnRmJLt9TmP7DqgUsfOMzszklAyn UZms7UUoN7yPLWcxKqPbn5Ja955U7QeVGKmj54tXw38uNu2hwqSpSduTVBZ1IYu6kEVdyKIuZFEX skdwJ5o6dz8ET5jsFdp0Mc2uizDruMnwajnuWFdGUkr30R4ZoTz1P2JU+WxO0DFQHIYBYk3yhMow Rcdnio7PFB2fKTo+U3R8JrHEFld2RYbJ7qmwH4mOCuWlDe/jk8YZCGTzn3B/NChyOWMMnCcmqj8a nJkef26ioaPXsWvAX4yxJ2W43b4EgzW+o5K/6jCkigswxm5Szm0/resqOLIWTyqFsRaDTg+D1Z3U 3tl+jTsheteXYfZuNv5h5qLJuqKTdUUn64pO1hWdrEv8OwcWa6twtfGc6GXO816Ri9Ht9u7aWOJS K8ONHNu+J6lP1yReFyFcmdOTEIu7+X451EM3xzpSoysTk4P7eBS7N2ivH710tGIdMCApL8/UPznZ 3fYrX6ZiYdJ7DbRYTOL0mcTpM4nTZxKnzyRW2iT2FuK6YIrYaL2GlpuTk6x5yQP7x3h7l3tD8nAV xiPIzcdEZXSGSNfepRzDT8jLzxexb7e96Oci3kXky/1H3fFa6MvzxXpr/onJMTq9KUkZCUalI181 u9KcrnSnWekYx3HSUpKxyLmeBb4BvZJj+So932R2ewMpi22eBMuRLT3/0FaDyaDqEMrgh4uru+x3 9O1lcff2HD5RvSO9b4o5NiHNFb3JNugd7AR2zo5sm80ZdabGtihbNT4gnOmMOtOpOTPd1L//IOHM Qck28YGKg+wWoVBlkKhiZ+kFFab+tmxdingPih2iuU847zjf5eVHtwx5CmfDn5jo+gl/patJ+YFu u0q3wepyW4e5s/1+V8cC35hURVGMCd7kZG+8MdddkZbtTXPwEWlDBw1M5ggDErwpib544zgnfpoy pw3KVj4evn7k+CsmHv6267Tc0zvTlNTH2/784Mb6uryp26Yqj+NnDUQSFoP4/340du7XfaHPYAmI ENYF3U7hA6fYUE4R7jlFuOdMJjflB2N9bADbiJ9G0qPOTY/u1PToizQ9+iJNjzo3fRdCYhNLwWvT VukXJ0s//eiwr67bTwJH/XiqRX3dYmDdFxMv+3DrpW9tLp649cOtF+3dUrIze8ZVS5deNbtPoPbK 5lOvmdVbueL6w62zT7zjh5uuPrh99vTbv737lMc2T6m6YNf85t2bJ1dd9KiIcHEzPofzl8r6sNWt vWL+D2VfAt5WeaZ7/rNq11m077J2y5IteZU3HS+xLcdOYpvESYgTspGGJQtJCJAMW0JaCpSlwFxa ZqCdXmg7LRCyOVAu8Nx0ett5wtCWhnZuYdJnpgOlT9rC9BYoWLn/d86RLDvhttfGOkfH1kHf93/b +37fr2iCsJogrOZyrOZyrCYICybgFPygHj+ox8+bzGjMDxjKDwO7hBDDtcIxljVhMY3H7BOmmlJJ NRB+YbUUWVwi0TWFLvUDef93b/qyXgq7IarUe5C9fnz79WOpE13TMw1PfHXZtqEo9eWNj+/oLmer foGXmnMW1908vfyaFsvcx8nhzeoK9zGfxyucILqIL8l+Q1hMghRJkCIJi5yERU7CIiexJLKBCPma fLf7KF9eU05eU05eW+W8tsp5TTl52FUnhg3mzCxKHXdOxeh2WGozLPUbZ0EJhfn1rlZHhVwTo2kg wdZCIA0DMmiRBWApDCbWtmbv4d7co5srlnDPT+8fkVK99aUdI0mbrvydxUZxgzMosOHi2u5Aw6qn PnzyKx+DZXzwdxMPH96V6R6os0oR8vyO792zbOq+Fz53w8v3YjN5iVDthDZiO2kjBokH5QCfFdp1 WNR20Fq7svbtoMV2UFs7lv9UCvB2qiiArvCZoOlM0AxK0AxK0HQmwPizL8tjTHFyl4xk2dmD7eZE eMKphWYFSVyoKq4GPxe02KLQD1nqEkNyOAOUBqOdksOBWuKJeLwCoIysLRrwhG1Ger8903tF156K iWFAJeX6PEv3LEtE+tcVQi2ZpG2vRVeeG1zhLjY/+M3Bzf1BHJp1OHLgwJhrmS5G5n5RNT1cnjOU uWPVzoG+bcs7bZZ097Jc+d+jfuquse1Oji2PhbtW4Bg9fPECtRnbYol45zTRd/Hd41YejfVpKurT VNenReg+TVV9s2SDnM7Lkg2N5WUBjUfz0bzJ64LXeiHteXkeHvBLvLAc3hfIHOS+Y16l1nrlmFs7 2tTjSSsUoqbsiyhBtOOSPi4bhVA7apeNJjQmwOyNAc7ahXbB0Y3xz4k+L5OacmDb1qIXXoILAqC7 dHqGv8CDg89XpqL6i0Vhja7YtkrPZdnPgPsstXlg/9dm+nZOdzmNGAjoLM0rdo92zAxE85Pbd3xu srlr+4NXpKfHuyWWJinWyBkbB2c621a0ePJT1+y4ZqoZXXvllzbnHaE6Vyzo8ItcXTISaF/R3L6s K9fce8Xu5RO3rcpY3UHJKLgk0SfpfRG/v6k/1rasO9/cM7Ubr5EVR8g3seXXEVtPuWRAVAJo7ThU sH91uITyQ7j4ygmwfFYE8OjXImIel7jvK8r5fpo/k65Cx/kivhIJlALrTQXyPlypFfGZBompwwog VhDjJ39fNcRNOsEnSSqpCPXWt3F+uxnXgmniMdl/VQaFwGtD4MUhMJ0QVEwhsBrY3yoLtXgFWxrh 0AR2aAI7NIEdmsAOTWDHCyQPtTygGhiCk/X4Fob4JD/pnbcbBcRocTA9byIz6NKyWQt5NYXBzUtu n9137XO3DqqgWdI1TO0rLd03kVZUE5b06O0bT9/e33vzyf1UpKKOTz9Ye2RNpmH1ndOUsxYf1OHo 9jmslSixQ/ZHIbAlo8gDx7gHJZ0obkYNbtTgQu5ZzUmVEwh7rsoVOJFFuOR2uV3xWHDSxYgqihEL RUFEqiOAhMTMDJqZmUnPpGNK8UhDSdTWVlMy5h0OliNP0RZ3wu8IuwQTR5XX6JCYrPOFRT2N9iC0 ndLh0BWMmildAMhRhOt+o45+XqFPdWbDJy/TRbgO9CnI2IMr7fNYxm5i27F4N8LJ6iN5ABw7hk1Q ByfJRhTjlSsxVOeCk1QdcoXgJJNDmSaUiaJMBLVP1k9GmoxULSjFdV8Rrxz+AlpY+45VK2OqcrZY zIUCM4do3pcKBNM+C11+n/wzZfGkQuEGn5Uqf5tFQjwUjEociSII2Si9LRbwhW16CqVI5KdYKeIP RHjExC0CVHOChfrxp42Vc/ofnR7QisX4yRm602jFUVtnNX7yT3SXAZ8zFo8TNNSEPf1PCvZvkv2p RpTKorgLxZ0o4UBJAqUmI0bBPynUAD/srTPK1zwBjlCV/66Rtioiov7DzIipulDUbqTL58tvMSZ7 NBCOWxkz2lh+1sTxOEDFHQYWOZCNMUh1/mBCoE3l53odHitD6Yx6kpqbw8UqxVg9DnKKLDq8Vpri cFDwof/QmTllvee+D/IElNrORtQTa07jBPDXg3ATdlynwm28IpuA7IhNellxktVsGdXG8/lANS8u zrLO5ra2dqlqySUVD9p15YeMjDURDsQcRuaYO+8hnTn3ccoo1XmiKZ4xog/LVWdFb5H/CstGc2ZD +d7WvV2F3e3oRoOFgwVz4JpkHc6eRepHGNXLxHNyyNof7G/sp4x6Z4sJS9QC8awFQlkLD/7ZMos+ lC1EImElkImAiEd0apm1U8NCnZoSOis+3TlL6mSb4Pw+0cK3kF2vtCCiBbW0ZPvqZ5FXtr5eh+rq aP972dGeX5rGaaKxwngqJNjM7vUzlcL+THr9TEFjP/O4YFmPESQYDMY6rTXFXnOrVuNpV2gl1nFq MnQAWUYVeZ/XE7R0PTgxvGci07v3m9sPOnLLCj0bSzmTDgMZztu/6uqWjV+4Iv6N+wa39AfXrOjb 2eMymXAlblpbHIoNXd03tms0NtSyotXrj/h1vNvq9nsifqlh5a1XnHFmiqmhqf5BrN3HsHZ/xuzG 1oMR5AkcrA3hNs1Y2jTjadP0Bc8VfbXNoo9krz0NFXQ6BD0B0H8ackyaV1oFpEHWE3ZDW2uYZppm EXMyPuod4scK+PQoM65kBaxCZ6GKIud1Vs0LCfulCUINJhWQxAkOhwIbfta8+YGZdGloKKETvXYM C1lOCrncGCMml46MJDfdM518xt6ySg71yksSgwcHele3u9E7+148PCTEO1M7sCli8zPpmA6l0sMP c79OdUT4ZYee27fkzi09Yn1/vvzY1HT35gPY39ZijYWoHxKtxN1HfUqFpTrcec3R3j0ODnYZsv13 C0n2i++p5DtplM2NFmRxvxOUDeaRYHQWkcelUeq3Oag/9OaRXMMsYo/qx6GTkr6gPFSJ1zNVmn1R O4VVyyu2tplChUiGc3cvXd248dGtrX27H1uTnhhsdelZUjRbE90rO/ffFpZnugurimkTUBBfF9yC 2R3zi/KBY/vuevmWLt5T57JILjERDCfDp56ZPrQ6HU1HdJIfsMNVWC+PM9cTcaJA3CMHi13I6C2A dxag2ihAtVoA6yiAsRReRB8TBNGoaq1RU1ajpqxGzWMbNWU1gkEZpPCQsZDw0pZ62PDhGsWuTh+z jDNjUGAp5lRc1FdR7KlK4tS6IIYLVaui4vFawNVOPc4JPhu0aocfu3LzvdPJ/KYHNyw/JHO2INiU /qmBvxksYgvCFtUX7pGHEu6KAe0fXzV+6OimvS8eHl4yQBorbMTcEmw7mw7Kg3duxbY0kANtzWBt PYajWppoIZ6R6xvbim072ygJvEkKQZNCCjdAbd8A2lLbl0p8w7bw8YnB9DfSJDTmToC3tdCa8dGa jSnPjcpRDXA06C8cbvjB7fQDNPkKjV6nEU37Gn8ZH3W9d5Vll4W06N/zKQY2U9vNUZ3yrbRqbEoP U3FQNhKuMSv7QuMj7Yk2RaEc9VjCPfd8YGjXhLyl1GjijCxFUpyxbdVueefTN3R2735y8zWPXJV5 irp5f8+63jqSJBPhpTetyto9ds7iFs2S1WR0u6TeW2Zv2Xv6jiWDe766Wrrz4ezY1nbIe7GLfyaP MDfhSmfL8w4eHFBxPK8WtbyVaOXVwplXMyYvbG1tqo/NXnxdFoGdjxkutA174heaRkJj/IiCQvPA 1aTPNL+v+ljzmUU9DbvG7tai0IjW32iu9DTII7hWYzl7IOWNtYQsP8RZnRGtP9Th0OQKSbrbeB5C zW2RketHI/1RE67hrJLTwuiNelfzROcmTvBI0dCnv4VyD5qdlD0UlTwCN7P+86tSZqtJ8kKHvLX8 Zepu6n8RvcQyYgPxumwXM8PgZcM6LPJwiJfQ2HBzEVeBoIKi5l/4eP4k/KrILcenstkqorHlXtra RDVzHFgPr+jrFdmMTzLNnNfLNWdo0LHcAkpeDf+L1SEev2x1fUw24mPM2sRRHaP/app6126/qoP6 TfdIfaj/Fx2jV/4itFxrEhbVttE5NfSnm8+Ccp24YIaSWcAX+bNp/F+68gBaxzp2ONRUEE+wOJ45 nBrSr9hcO06vLW3Ko+rZ4TzA/2o6hWZ6PJGwUNoz6m7JekfEl5+5fVn7Zq/o7Gv77cCuyWzLtU/t vv6xTQ18OBfKNeZjwWjLujvGUsNBxAtCubx1pmm40bn1ytxIo3Nqw8RvQimX/vCNS7f2eqm9kWB0 unHZTVMNfoeYDUSypIEM96zp6t21MheT17SEezua3e6xhp6r4rGZ/vFbrsjodeHy++u2hTpKyTVX B9tH5tZ3FkmdO5NK2vsG/E29YN+P4bruSZyZ88TNx4stqH6+TakZdk3/Uutn4rTsDKjNKKUtpXSk lLBhhN8Z1D5UoN7N44xyKjMaHXKPKeFTIV5Qo9aGUZNxYWEzRskm3GV6HWo1aKee1IlqznVlS029 BwfxU4XwrqTi4QdKaw+Mhd0Veyat4+sHo6tXzt1TuVKbf5eWeq6+eyNEyrsu/hlNMI2EnQgT954q RpZHdkYoh1bLLUCkknI8vwi5qkj1RXI34SPsn9UG0VRqx2o6aQjC/Ahs8jzu5kuKfs5dSGvRUMss l+9USZB2wRixFaLexQqQGro60/BTVQF1mFMF5lBTZ32qgH+wxBd/Vv4y2oIljhJNxJFjy/Mw0aMU C/j4AbzvWCWww6gPCBCDz7tImwjt72rKfVWuat2PY59scLuJfBZkzGIZjyWDJRvOpEcZxUuxpEJz c6WeVaXFsjILCB3HQpS+QOyJgLxlOJRxYfhKcXqOjTjDjQFLJeiBDurTXV311i0HrkjrDGZBNEPn nrFlRkrUP16qDtUPDmI/aCEekU3FNpTKoZwsonFcHr2uCJfT0l8OpDcpRyX95V4kE0QdhjmqDj67 p4tdw+PIZAhQieoijjojkyz5hoSKeyhkLi62cHWv5IT8+YoVVM3gr2oEHtRhDOSNuKxs+fBi+0BX 6EQ3xk91dr3ZWn4B7TAbFeoRwz49+qBsvtRNPv0JRkpmPYWTqt7k4ssvlGOCXYsdqBfrzE7ISn92 p9KfvTwUnLcR9NFxAz+kSKwZwOX7sZdYtvvSt6a9C+Z1XOOsIN6TvSJ0YZUZmrjCPiQU6mHXJBq6 dA5DZURr5jXeq8a3QMABHZdAXu36Kf0/pfWnhDkDtu9TK4DDWtF76ViLettLxl9eRB/hIMsj9vml o7j4ZmVz32jvUKajlBlz16x/bQOnoPHSQqHSuYZoqWz2+3+FzM+KoXYNUWvGwryuhlJJZ2sYzBb2 LAHvcYYlztEwkC3srUZWVvQ5HX6eG7u/1LFmsInPTCwdjk7fWArOx9hIYVGMvfQKdRgXJhSlN+r2 r1zuaexL5gbrJRx8xyo5CK9gnnhYtqorCA9aOlq8Sp8xVQNgMWDk+UpWUsYmaiYm0EentMQEaUk2 ZEbr3dFSRfVQNVQzU6WbpGn7r0hP9r+UnqpK/Nvxv5CeFigKK+gqyE6ABt/GGoJO4jdlXzGFkiJK CcAlxk0orkNxDtUr7NVluofnL9s9hGI90GhAhpq2ZGhhW/IF0gBc/ykrMb4LL5MbdrlbRyMYOWrw GhCiprLGarNxpvL1l7qO1Nude757w87/vqOtsOc7e/Cx/Rlv7zXLS9sHw97iNctHrhkMoV/vOH1k af+tx2/Ax1F8PFi6c1OhZcOd46N3biy0rL8TuIXyw9TPsG6AW7gduIVw22WmLtToMz9+AUWMXaUV FIJB6XioDMNleYUSv/wzeYXL0QqXsZHPphUeWp8c7JOjNcZis3tFLjU2PpHZ9EWgFZoVWmEoMXjL QO+adg/6zY3fOzTM17VEyr2VWEj/BtsMBazezfW9KfvY4Wf3LbljS7eUGsiVvzK1unvLQQU/Y209 rmnriOzF6goa0+AwaYOpQrEoQS4N2LmeaFbNpmZq9T1tarUyzVqZWsXY2R4rGXvSQZrPAnb2jHYA dubHIedfHjsv0FmroDK7FXtxtn42dtaDmwVtXGp0pJQAFeU3P7ghObRkuB4Gn20+gbsEP5ePVzSF zqYKEWsFQwuxrtT1FdWV/48KolVCBoNoJTqRTyvM4Obju1pR3KoZ1fxAm2ZcVs3qrGBcYk2jA6yM 8GCbi8n69Gjcag+V7GOEFu6VhJ+u1sK1APBygUYxIpZ8mmT1Op3TH7W7m1o7I4vDTKyvs+A3h6N+ E00hapMjIOj1ep0tO9Y+99ylgeZQ22DCSukMBr1FmWucuHiBfA1LXCJek02NS4tLly+9bemzS5ma ZuKftCaiYhR9QE9Ji5qMSnMR/VIOqh1FpZcIJqY1FAEiQ8zxvoD+pAzTGKAsMslGjSqO4/sVTc+a SFP2rXbDb4UVwlXCLoFSG4f/G7qGo453VWestgy1huEMtIBqGobztfT/b8OQfK15/Z3LmqaXNDkM NDQE08VVHfWDeW9CXrFyQk6kJg9MRkc6U3aOwtWRgdXXtZUa6+WUPSlPrpySE8iy5Dq83k63LRqU cP3pDXnFSFss3pIM1qV7V3W3biw1mEQ7b7I6eMHNcw63Q4o0+RKtyVBdffcVsBbhi78nr6e/S3QS 646nCCGS0XSe0dYio61FRnPIjGaVGTBCk9OcuRAZ8ZsvOEdyUH1zatg+C2bXrLFXZ8+o1B59eYJh IQ3hqNAx5PU6PpTKOoe2yP5brSJ0Df+mUqi9A9yxaH2nfdgZ9dl0jJ6hr/TX8RY9G1u6ZxlpURmG c5VRmXMqB1E2zGzQG/SMxQVyPww8H/U9XBM8JAdxJWBMgAUlwIIS0EtLKEEqwSslF/r4pOppQU0r QU0r+PiR4ptwckwZ4NecNajZaBCwil7KlBJGxl3ChRkzT/bVjuNVTeqyZN+i5mJb+zzt9zgn+u1O v8COP6qkfs6mYhRn40hT74ElnC2IPVfUVyuC/SuXdW+7exNZV/HOuT8u3zAQW72S3Fe5onUZqQNY Pw3Ev58mIhdxNoNCN6j03mJBFFBPAsihyWnXjrb58lc5itWZiYt/kNth4AJXFQJK8CjJoLokvtBT h6J1KAynxTCKhlFIuRpC0RBKWNGNYRQGkksv2EfCIey1Yehd6rEphoFhhGewEmG4vwlGJJOlsNFT Mo7N93/SsO9jRqkc0up/SidM1Tt0/9LKTpzqcFxNipCcamMoQFIHEEmR5bO02ZMMBJJuC11+jWZg jMvpj0h6ukxTn5AGKex1BgSOeoLWG0zcp9+CpiatsxioaZOopzAmJPGDfs5jMpH/qTfpKFJnBG23 YoxxGGt7CfH2aWIYh6ceLFoHkF+pDtQOx1gWxcMoHkLxIIoHUNyPEj6UpFGKQp1dqKsTdWVQN/yb MnY0zmv0ARxlAzZXPoTvwFu1y3BUWmVWuGztKyl/B8os8sv5nfxtPM3LomOEby7FSp0PNKAG+F0D RE1ecoxsa9jfQC7BV51jelDyz0CTM2eKxbNYk6q+51vHavNY/VIVzVb1TCW4ml7rZVRec8ocppny h5TZmQwE690m6iWSfJYye1KBYAI/K3/M0BhdOH11oo76BUn+gNSL2OyDoo58k0TnSL0U9rj8sCyc zTq/KOR9ev3cnvklsto4vRGvEEaqcx69Hq+QGQdeGFZ1VZ6ROgOsVwp7x1K8Xo3EkdNEDitGAH4f 4kYWIkZXFrmwPZ6Efp4LObXY4KhcciA9WGs94FZ4TTeBOiKozYiMIYAXsCpGY64pVYIebkmoQgi1 M99Y7cqD8ar2m445bJVNTdRlerqSNN/THdBJiWAgYjfSP3+TNtrrfP6YgPTIVf5Qh6REyB+xGeiz r9MGIej1x0RSX/64wSKZGIzOObS1/FV8oBiTZEGn0NMWyUxTrIErH0XLWZj2NNqs5fUQPXAVeBDr J0pMnia8WNZW8HwvSnmRSwHPLhS3tFnIhB55ICV3epC7AxTnRsGS2yCVDEvp5cRSDbRCtz6tOi04 b5hSRW2XYG453lLt0ksKq+OwcWTzTWwu7wkJJHtQz1Pll3V8NBCos+kZhKiPWKEu5IsKbPkELzAm mwUVaNFArbO7LAyls5rnsuQ5ycjgPCFiSdbgovZN6hSRJrpOEzyWxAFTE3FliqwR/75FP6gn9TEB g5Zj7hFrQgEv+I0D+Z7HtcLZGZizro4gK0wvWrCJQBn3QnBKvsnqLLq5c3Yv2CO6r3wbL8GMMkkb BRMH18r70FM6s54dkrwC5wvXWRwON09eE46J+DlrcQghi8vp4ece5XhcaZHIcPFP6JfMesJOpAjL CSbmHeeHsFLfeq1mZpOKVwmwRZsMX+Jgk59P5ASks0d83ohdZ9G7k8FgCvuDKxUMJt16tK9S9VIv mEQTw5oE0yeFcNprNHrT4XDGbTS6Mwr/+SdqGr+TFmKEiMuWaDSotx1jmCb9YCfkSHS0aQhKh7dg l6TCr6vvsLo9UnmXWj11Sdd5MRKkpvNrbx3nIgl7QNSxSC/6REffuoInJG/s75yWUwYOJ0PWVpjY 2HLtV7Y0lc9gaQIhLA2WLhTA0lH/tvoLV7Ux71ut4P4I51eJSw2uyxc2LIm7Ay5W8DtcbinoEXs+ d++nXYulRUR9+W20hzhPeAnD80anj+DfOKsO/nGcGvHapaqW97AWp3A3Y5bckuA0IPouoyvqcUed xvuDLdmM+zXOoFOCEJJu94Z4luVDgLNevPghuo96REHs3qOEbZY8cMoQiLjHGOsIUTxbPAsFWP7S 0Vxh8SLfBysaSsKKJkNBVQcLnlOhUAPI1xCqy8AxM5cMqxewwDiReTIQEf8Wv58dWGIj4TwKo2av nISRMj2FQxd+K+lXQfwafnVHY293Fn6uH27MLsE/0AV69OKH9B+It+EeRISof5lwkQeJAGEiDxAi lvngKTZs13utcM/m5rN57F6/gu+Ft2Y+4xxtb+zuzMIP+p9ZOOvCGfNM5dp1Q43Zwcv8YMlQ+R3K wPwP7EO6ozxDNGLLdGqLqPGi3Ddps81vd4dFmiVnaLMUsOMylWbeN1t1NGeWzOwBs1WP19Bmxvdb go6TWbKHsBKW4wRnvEATMGasdYnC6ttVokFWFMrrRfyFvo59nkEfJwLBeDzACh4CYb++QJPkrfgu wvP4LqeRj/isG9GkJH1alERRol7VW/UM2RaPROKxiF7dZfYqGqK6qFewJZmPEQYrlvCsdpdFTtWV m97b37dvVVNu1b4+fMyRh+CxCT8b2DOdy63ai+92V/lp9F/MPXj96mQ7BcmQAhhGKQGTsgeNdxHF Rmyb6kAOi+t+0VmdR8pSSnxUtYp+v2Fmw5UMsvjdokcyUW2THb5gYbIZ6Xmfw+njSWbTD8trzr1Z XvvPJsHIkKyOufrHP39r9+5f/uIn22iWxYmJB/luwe/oHfyOwkTzaUJUq1RRQzlwPAHvTFSGS40K jlbfYTpfnQHlKhm1TWxtIRNavHQ6RPSOr2OijTJJHtHjNyNm3fr162mS9zntPkFHbttHune/9fMf X83oWJLBIfxH6Ok3z6Gnf6jnDfjdsfTZ8nLsyfdQV5NfYfZVYrQ3PswP4xh9ttZ5qQrFteiKw04e YnmnKLqsrNNgCztdYZselT+/4FpTnDpSpSb+pXJWzi28xvPw71leNLM3MVlil/IpEtcc233IFZtF 18u5rMmV6SAOuFa6VhJDm/f+KpgM5m79nbD2dytWLOVMh7K7o4wQxN/re3533eGJpb9fj22x+MYF BR+LzkIeorqyFxsA9Ktn4PKr/I/PYVj9KwGGopGGDxPqjGElsDvb1eTOUSwgQ1oL/gvmQdTGfVSp IFmlVlTYHFrrk7Yj9iYh3rt2/3hqqC3GJZeOLAmn+5ujLoMl1DF1w1ioqy3vEWhfXHRbGHIN3zSQ 6s/XOQyNN7z8wI2z925ZUu/gmm9942ulG6fbMAJnSERzpsLGO5e9WJ77hxFjsGPNbd/9t/u+8fvH x+a+F1/RjNF7xKFvLbryHcX4J59SaPBLR/avbZaihViyEOWFcFP3SH16542717RbQ03h1RYLzeEC qmV6KjU0s+26/PTf7R9uWbP30N237UrsnD0yKkgCZ3UKFtFqMthsltXf+M8vtXz+sSf+2+e3di5/ 4F9ekQdTfZOrJoKjK4RIIUFNYnu6FiPbl5iQkmkfO02M4urUaSXHrxpF6X1FdHURDRRRSxFFi6g4 Sw7INpPPZ7qlFV3Tipa2os5WlG5FrfgXJ3cRKITdB0CDOoP37il8G6LJhEyzF/8sG/ATU+fFpiYm PouI56U1g7PIfpTZUN0/jl1o5g1cn878Sqn+RRgpU85g31+6hiqhF1Mj3CIms8LnvtRy3VO7Jw6u 64nxYnb5/qd2xMbkBgtHk4gz6o3xtvHmmSMrU5Snb3xVbvsDa+LPONvW9sdGlxQ94eL6ory+14/+ YeUTN5eSo9d98Rvrp7799/ds69ZbRaPZKllED6+zCJax27+1zhpwWQtb776qc0N/1OwMinc8sz3T NLEVsu4I1u0PlB03aeI92b2IJI9VSPIMYKUYKD2Dauhv6PnYgGGwwdYTG2zkt71I4vRJhFRyJaSF pZDGgoY0mgEf34V8ihEx/HtGst4Am3lkglI+Q0EPs0aG5QaSUHCysqEMVkqZhocTA2HINHjhI2it U7DTpbKRZ37OF9fVeHFqexNppeb+bKadriFMaeoHjdc/d8ctT1+dbrruudsP4ONzFm+6e7xp5TU9 jkDf1pGOlT24oiC/+Mifjm6c/taHTz78oXL8zsav3Liy3b3i3u9d9+A/394ZHVh/w13Y5J7BxcAT jJPIEr+Wo9EAivpR1IciXhT1oKhbm3NNKboXATE1KTMeoO4mRIBqiZTGVqU0haY03ialKTSlQbIU bA2yBFzwIpcRHo2CZvD4+MYxfE9Bm42ruf6KthkEqx6/4kkBCZI4i4rHIpMpfhZx6g7EfHHurMIV wtdZGL+pTM6DZon0PC6e0dBBZXQeV/KsiofbY1ovTVAS8BOswczNreNMRpbVm3XI8meYtKFYox7V 0ybRJbpCIvsertGZQWADOd4jiR5BT/38EQNtDjgFF29iX6ZoGkcwI/vJ/XpcSGBt34C1/Ti26V7i YdmcakPpAEr5gWOQZyuhQ0YOsGKHksQdIQXLkpmTzTH8TRQ0XRdeIG8jjKpyjMAoGKFDJnQUQqEC Nr7syWYHm53iC7MoWdGQyqw2Km1p4KjPVrfdKzpSuIMFygE6YBEAYKu7jjhl08HjDK5x5lotditH GaymT6a3F0Rf64oWZegUg1eaZHSurjXXdq2/bybrGD6y8yzZrLMamVHYUcHxAYct4HSakWHdQzdt SqfHO+vqknU6MWC3OniLPRpxta67ZUnvgfufveGcXlTqp204JjyE9bcaMaeJtVhlPlDZWpTTYaXk wPFzit5yoLfcLNkqG5ZNxZctc0loXAYuK47/JA4Ui4yvxmXK4tXxFfZaeaU3pAx8qSbrxZo/odAG ypQm+LdFM02LZu0WWDgJL4OlC4YBumQFrHYhxXQ1E5YNcLFL6BIcbbPIKBtKUw3/FQoxJdgsY6xu lmm8UOCr+2XSaYXdeaO6XUYZeoIGsljgK532SmRnlbK7yoGr2ylV5vdSFDe/iPYART3Uu/fb1/bt Xt1p1bGUxaxvndo52L9lsC49dfP4AbxWHGu06Hf3by8lPC0TrZ0bx/IGYCVwBSh1rtwpr/3ClZlQ 79qugZ0rMuiGNfdf3W73By0WXKFHfaFYqK53Zb59tVyH3cMuua1cnbymPVlqC0aSEcbqdUCylfA6 Z6/YN9yzfaJgJLnWFdfi2A8T9z9VJtSzxCdyJxByGZRoQNEEisZRzIfiXhRRAlTMhWJOFHeguB3F bSjOI7zEUQZFaZT2IiVaiWq0yjhc+MQR4rWZH3XW5/wpmAXyZbP87MVPZT/+Cx7cjweL4IGm5iGJ 8FBc8/DZHAmCVmMVjRNAZXRSNsDsJN3UmPBmlQWm02GeN4QnDepkPPa65gv5vMYopTW2HjbCnlWO 8x646AstHBisuiaaj1UOFEFh6qc28aHKfuG590y8GdfoBg79hJECDYFwLsA/JNjLXyPLV6Kn0a5w vPyHCkWNeJYPuKSA22mmRGAWGIx/Pv2nCPmbuU7wuK3Y4x5lLDhivSqbE+0o0aa0qCklYp1UA1a7 FpXalY8bgi1/sFkgiVWfhA2U4BdJy/L8zvxteSp/+a2hL5DNyk4ELZeeUOZqpFloWMPcmuRqg889 MDV0/jEEs/VMw4RrgevMXADXaUwj/pzmMWdm3lCdR1UuaHfeWxa0jGAOILLgA0cwpNOG1KhHh24/ el33dVe0WVmGpHRGzlA/vH1kYNdENjFxcFXP6rjPFfSTPTqrgbGJZX+k1LTzqZ0F9OTnvr6zU3C7 LCbBIwpeQef2e0KD20Z7NxSDJk+MtIZDehwEo8nyIwzZuvGLFy9WakmSpX5EgOY3Yx94Fms+SLx5 mhBw7DIIYTQm8Ly2OXLhpsl3tTz5kWKLexXin5+tvIrnVYpaeRWvvUr5tRF6C/t4cBxWayuEKysb RjXD6j9XZmXtWkaumYN7V/u4gPMn8GvsjDCLMsc8E8bqJjYlJSurkNb6AJV2wHwnQKFQa5k66lmK 0bPlLGN1Rj11cYFk0XtzX5YkxmDRkx9Y7EaWPiP6vW7LJ6+ZMNxnMfCnR5NRCecVVvThCDKJtfkU zhRNRD/xkiylsqieQSmFw6+Po7gBDUJoCIGYgzh9mCuZw39LDhVypdz2HJXOoRxsqdQTFksIwzRS rc8VCz1/HCy0C/IEfmkX1CfKFq99Xaita6jr6i4q2oW6Zsm0bGmMoZj8QSjEtf2xfgpbre4ot6qm cFdKdmUsf0ar2vO1NqtY7f9l72vAo6qutfc+58z/JBlCwBAxHBEhKA1RAVOIOGBUICgpFkhi5WZI JsnIJBlmJiGJBI4xtcGkbaRcf6L2glWvtrZaW7zaWjsxNEHNZ/EfldqUtv4VMf6nNuXcd69zMplg bOm97fN9z/PlLHhn/6691rv3WnPOZCDKiT/oPH/MPwRWxn4bY5F8T1rOV665L3T2V5bNSwM5Lrsr 64K15/nai+ZJC3eXBr9TPOfcq+8Kf6X5a945kx6Yubz0wmVfWzJ9Wm7J8oIO6Wdfvf8/2quWuDyp qTMypmYkW1JSUwq23/O1GTlLKjquWH9b/SVzL6u+Ye8l2gPBnPlryhcu2ZR/5pfE/Xqu/r7kl26i T8lmelPTWKbTM41PeyBlx4wz+BkPWFrg9Bb8wTPpC91//9+xS/6Zl2xesbJq+YzT8zevXLPZm9Hh OX3RmWcsON0z+YyFM7POm5HEL71se/G52RuaC1duK1mw6MqmlbkbFp82PfeK3PwrF07JXHIF43qB fliusSwUT/yPssl6bOR7sDFxnCeL/xV+H863nT5swmGlD/zjn0HE/3XWTEty2vS0qae6ZLvcakme cuqUKae6Zbvd4bDJ9qTJbovD7rLKtuQ0F0Mkr9APW0JYc46SxjzSN8Sr7EJM25Qsvo0JrjbyXPkO eSVLYqey037Kkm1TXI9xJ1PYJGA6E1945vPPMz6WSPh8aeqkMTX5jlNS/upOmZo2SfooNS2xLMtZ M2ZkzZo58/gG8QO0M2fONP4Hzr2G8PlfKH+UNiXIrw2RC8aRnypXxuUvQiyXfKH8yvIr6+QEidmu TJDnxxf7asibjl2GOMsT5GlDXOvHlQPu4rh0J50zIWNk4IskuTHFMo7cbojngnEk9s+VST/8vKSe Q/L98WXyOSRPC0lLTpD3pmiJMjX5C+TuqXefsvSU/zIkvXkc+fP/RKbtHE8yvKemx+Xe6UlxCU7I hPx/Kj8WclrWCVIM2XtaT2byScmiBCmGbB8jd5Mcm7H0H5RWQ9SKf6WcnvZPkL6Z28/InJU66+Uz O87cPfs8yNH/jcw5/yRly9+VlhPkFxMyIRMyIRMyIRMyIRMyIRMyIRMyIRMyIRMyIRMyIRPy/6bQ z5E5Y0lZjEvz3Yw5eAZTWKr+PnAOYYH+NrCYsFwvBVbpA8CI/p/AqP4gsEm/mim8S+8HxvRXgX36 y0yRL9MfA65jKcAi5gaGoXMSU/SjwHL9IDCivwmM6m8BG/UXgE16H5vEs8QY6BQYI+wVc6EZZXmd /geWCguPAQsIiwnLmZOlovdTlo5VjgDLYXk6VnkLGNU/ADbqvwM26a+wdIx8ElgES6Zj/DvAVIyc Ds0CC+DpdGgWuBHrTueS/jrQg9Wn8wzon84z9deAWXoM2EzldmrvEhpgOTTzbprVJ8pg4I9sNtb6 JjAVNs8mL2aTF7PJi9lY6/fARtgzGys+CRQrzsaKR4GZ0D8ba4mWdmrp1H/DZsOXBcAi/UJgUP8l mwPfPwFGCKPgZA68PsLmwKrfA7uhfw5Y/QDYh/Y82PMQcA72NA/2/AewmHAjrMrDvv8eGIUvecRD Hqw6BMzQfwsUPOSBhzeBdWAsj9cTNlP7Tiq308gOKncKnWDpVeA+aonptwG79b3APv0HLA9cvc6W wqp3gHP0Z4EF+vPAYsJynLqlsOoFYESvBkb1G4BNejFbCkveBgr9S6H5IWC3/giwT/8xW4ozOYkV YBfeBpaD4QI6hwXQ8A6wEbtZAD1oBz8fAfvBYQEYPggsAlcbMDcALAerG4jhDZj1G2CT/jHbAH5e AHr0F4EZ8GID+HkZmIUo2ABORLmd2jvh+wbeRe19ArGKBCw6/hdgUN8NDOs9rBhrPQsUdhbDzo+A jRhfjBWfY8W8kC0BBtgaYC+bwYrhYwAYZG3AHSyTldB5KwGT7wILcHJKwKTAjTiTJdAvyhGcqxLo FyPFaSmB5YeBzfpLwJj+BrAb+1gCJoGIayfbCDbeB5bjLG2EBoFRamnUPwQ2QfNGzH0b2K2/B+yD Fxvh16eIWAVZpRy2vQSco/8KWKD3AosJN4Lbcsh0Vg5Wxe+f9ujit0hn6OL3V2fq4jdIF+rid1fX 6eI3ZNcTNlP7Tiq308gOKnfq4rdb76NyTBe/37tbF7/9u1cXv/O7Txe/7btfD7Ny7EI2cIPeBCzS FwKD+r8Dw7ChCjY/z6ooC1Wh9zCLoGUPUDAcgRdvAgvAagReCNyI/YpAHCwCL74F9Oi3AjP0+4CZ ehewUL8dWKc/A6wnbIZtEXghyu00soPKnbA2Ai9EuQ+nLgKbf8QisAf7B5v/C1iknwcM6jcBw4is KCz8HlBEUxQWCiwgLCYUPEdpv6Kw8FGgB1EThYWPADP1fcBC/Slgnb4fWE8oLIzCQlFup5EdVO6E DVFYKMoxnPMo7HyaRWFhFrBIPxcY1u/FCU5Ftm+EPb8EFlC5mFDk20as/gIwE7m6Eat/CmxGRDdi LdHehUzeiFVESwzR2ojd/DWwD3HXCP0PsCZ4XQVM1X8BnENYoD8OLCbciNPYBH+bgB7dB8zQm4GZ ODNNyCFPAAtxHpr4VYjTJh6A/iYwcCewnrAZJ6oJDIhyO83toHInMnwTLHwBuI9aYvrPgd2ks1f/ GbAPXjdh725nTWAG76PYuwpgkT4ZGNSvA4b1di7Bko+AXfq7QPAJ7NY/APZSS5/+Kk/BmPeAnfon wC79U2CMyt2EvfrLwD4q9+t/4B54/R6wGZiJuceAXfrHQDErk2ZlYtbvgH36h8B+/SjPwqxDQI/+ PDBDfxqYqf8fYBb1Fur7gc36i8B26u3U/wiMsSRgN7MC+5gTSNrgdQuwSG8AhvUngchUvBCrvAr0 wOtCrPIuMBN2FiLLTQY2w/dC6BftOAO8ELnuFGCQreQlxFUJcVVCXJUQVyXEVQlxFYT+3wA9+kFg hn4AmKk/DmzWfw5sp5ZOjA9CzyfAffobPAgLf8LrSH8d6a8j/XWkv47015H+ehpTT2PqaUw9jamn MfU0phntnwK79SFgL1htRvvHwH4w1gxmXuM7aU930p7upD3dSbuzk3ZnJ+3pTtrTnbSn7eDHyTvg 3UtAj34EmIH2Dnj3R2AhlZv13wLbqYw7B2AMrHZgd1xAsTsdWL0QiDgFhrGnnbDkXWCX/jYwBs47 yYZO2PAOsA/WdsKGY7wLq78J9BBmYHwXVn8H2Iwd78K6oqVL/z3vguZuHsP4I0AxPibucICZhFmw J0Y2xzD3XWA7tXeChxjeMZ3AGHMDuwn7CPuxUzHY7wMW6UXAsP4s78YqbwM90NCNVY4BMwmzcCa7 sYooi1W6sYoodxJ24V62m1bpxip2YB+V+7Ev3cRSN1bBLmKVF3kvVnkN6NGfAyJ3ATP1p4DNONu9 ImsBO3E2eqHZCtwHe3ox9wneh7m/A3pgfx/mvgXMBCd9sNAJLKT2ZmpvJxTns4946CML+8jCPtrB PrKwDxbWAIt05ESs8jzvF3duQA+VM2BnP1YRmIXd7Mcq7wGbqbed2juxd/2wU/TGwEm/uG8E9unH EHWKuBfH+/41wIheB4zqVwMbmRPYpFfL67DXL8rr5Kj+FO4VFOYGpuqvAucQ4j0IWExYrlcCq6C5 CNoCwKgeAjbp+XIRLDwELGRTgcirwJj+E2C3/hiwj8r9WLcInn4buUDRH5VFpL8mi0gXmElYqP9G FpEusFN/RUZ212+TwyIHAmOEvbAtLJ415O0ipoABdiGelb4kiS/fyvTcVE4o0xNUMtVk+j5wsqyY ZZnlyKlmWUkYY8Ezx3KzbE1ot7HP5BKzbGdnyQfNsoOpylfNslPaEx/vYuuVqFl2s7OUp8xyknSL 8pFZTmZBW4d4xqPrXNuQWebMZj/LLEvM5mgyyzJLd1xrlpWEMRbmdtxqlq0J7TbW7LjbLNvZFMeA WXYwj3OmWXbywvh4Fzvbea5ZdrMpzqvMchJf7Qyb5WS2yPU4LOGKw+TZKBs8G2WDZ6Ns8GyUlYQx Bs9G2ZrQbvBslA2ejbLBs1E2eDbKBs9G2eDZKBs8G2WD5/uYys5lOZBclC7DHXgZC7Na3PnVsgrc X6nsIpTCLEToQ0sApRqWjZ5lLAhR2Vq0VeIeM4pZoubHqx+j64HlGHkR5gUxZhPaAhgRoHE+/K2G rnIaW4NaBG011GfMD8ACFX99GBeAhkbUtqIUxVpiTB00RtHuR03YXIfZ5eivgTVCS62pNYoR1eaa YoQKH2tpTbFKhHxZSb5WoEX4WId2P80IU0uQrI6afpShZx5prqaWIGn0gSOjfWSVaugJEmMh08oa tFTTqoZO4Wc0wQKxYoh8MfgeYduwXaxUCwZU+G8wLqyqxlgf1o9STXgcje+HwZmxikq215h+1RK3 m2jkqMWJHgnWGmie4fVm1LPpPCTu5hzSVk0aGomHOnPnE/kWO2b47yf7hf/GvoTpNIhXY0Wx1yp0 hOLeGDZWmmMiqDWZ2qPwwtih+vgu+eiM+NBaPcavkdNcBkt8tH6ZuX42ndhK2ivR8/kYWPw5rxfH o2YhW2+eooB53hZC4yL0jn/q/eb5NbzxmfZXUq9hj99kTNhYTidXWLWZ9mxkzvi9Ff9QBI+eFmNv 1qEWIBvE+lfQaY+O2cf5pgW1CR6UmXEXJS/9dJZXo6WMZdEez8WYctJ/KVllzI1CQmBxPmQrSTbF +FjLs0l7NcbgOY/sryQPQtDQiFaxgxXki4icsVpH2kX2MHZgc1xfMdlsnNpGOm0RsjBKcRWhPGDM VskHEZN+OlEBWsNgaBPNHWHvYvC3GhnRmBtO6DHiuZw4GY3RrbRWGcXweOsadTG2DKeojjgsj5/5 cuoP0YltTDjnIfK0xjzphi4/oYjcE/0W/UaGyMKsuXQ6q+GXPx6zn7eq5nOaT56jUe0jWVo186xx esrG5LvP+z56XsfatSSBAeGJ4YuR9UdOfTj+DlJOObSGcqnvCz01ePaN4dRvnv4TY0CwKk5eHc0s p3wkvPHH9YiRQcppf2uH/llxMRoT88kaEQPGO1E27VWINdynnpuTk6teFigL10ZqK6LqRbXhUG3Y Fw3U1mSry4JBdW2gsioaUdf6I/5wvb88+yJfMLApHFADEdWnVteW+8M1asRXE1HRH6hQK3zVgWCj ujUQrVIjdZuiQb8arq2rKQ/UVEbUWgyN+qsxs6ZcLasN1/jDkWx1ZVSt8PuidWF/RA37fUE1EMUa ZZF5aqTaBwvKfCGUxZTqumA0EILKmrpqfxgjI/4oKYiooXAt7BZmQ3swWLtVrYLhaqA65CuLqoEa NSr8gGWYogYDNVirtkLdFKgkxcZCUX9DFJMDm/3ZqunmnIha7atpVMvq4Lxhd7QK6/u3qmEffAkH 4DYm+qrVupBYBhor0RIJNGF4tBYO1QuXfOpWX7jaWEvQXFblC8Mwfzh7rb+yLugLx3dg8cjSi8XW LFwPiuCUujB70bkJ1PvBL5bxQX9lQNjhh2FhX7m/2hferNaKnoRqxfgbTLTAm3U1gSjmXxH1RQ0f 50NBLS1Qhr2LhgP+SPbqurIsX2SuWu5XLw3XojcaDS2eP3/r1q3Z1SPKs8tqq+dHG0O1lWFfqKpx flm0orYmGjGHinKFDw5sFuOKa+tAbaNaF/HDCLgkulUfdtIfrg5EhUGbGsm8i9etXobeMFWwz+V1 xo5urQqUVSXMxWugpixYVy64qFXLA5FQEAsIzkPhAAaUYZS/JpqtjqxdW4MDkRWYq/qrN4lJo6pq RgaPaxENF0ca9EdAT5lx7uKrE6+mriVkQFYAq+DoC+rDIkDKa7fWBGt9iYvCZp9hKYiP70BtXTRU FwXt9YEyvxhT5Q+GTnDoZPaCdmJ+ub/ChyDK9kVCDfHnQaans+vZeBfHCDxRsMnMpussBc8uxlMU w7M94/nGz+D+xqUoy9xujjFS8GTHJyWJ8fKDJzs+JUWMF0+NJzfe4xHjrbknO37SJDHetu1kx0+e jPF4ZeKpUqHx4qm6gHASS2KpLIOl4355OlvAZuNOYQ67HE8LVyJHV7E85OelrIXls2/jTuJ2zLqP bWAP4x27h5WwZ9lG9joy+Z8wcohFuIVFeSpr5HNYE1/AJb6Mp/DV3MOLeQYv55l8C8/i23gh38lL +E38Kv49HuAP8iD/Ja/l/byOv8Lr+R94Mxef1H3G2yUb75DSeKc0g3dJZ/F90iIek5bxbmk175Wu 4n1SFe+X6uRVkiZfJn1TXid1yRukO+Ui6YdysfQTOSg9KoelJ+Wo9Gv5GulFebv0urxDele+WRqW b5MV+ah8qvyunCUfkxfK78nL5UF5jfy+/DX5AzkgfyjXyx/L1ylfljuVZfId2P+7x3Io3/c/5PAu zPoxOHwcHD4NDl8Bh2+Aww9ZFdRGeJL4SQE4nA8O88DhSnD4VXC4CRxWg8NrwOH14HA3ONwLDh8A h4+Bw6fB4Svg8E1w+AE4/CvfKdnB4RRwOBMcfgkc5oLDi8FhITi8EhwGweFWcNgKDr8NDu8Ahz8A hz8Bh4+Dw/3g8Clw+Co4HACHb4DD98ChLt8sp4DDU8BhDji8AByuAocbwGE5ONwCDreDw3ZweAs4 vBsc/gyc9Yzl0BZM4PAUcHgmODwPHC4Dh2vA4VXgcDM4bASH3wCH/w4OvwcOf4ZZB8DhS+BQ/Izt r2wjd7FyPg0c4rmPLwSHq8FhGTjcAg53gMN2cNgFDu8Bh/vEJ+jg8CA4/C04PAYOh3lQSuK10nRe J53N66WlvFlaBQ7Xg0M/OIyCQw0cdoDDLnB4Dzh8CBz+Chw+Cw4HwOFRcPgXeZ3sBBOT5SJ5hlws z5aD8pfksHyhHJUvlq+RC8DMOnmHXAkOG8FhCzi8Axz+ABw+Cg77wOGL4PD34PB9cKjLHytJypeV U5VlygKE7gVjOXQlnsNp4DALHJ4PDi8Bh+vET67BobjfagGHN4LDPeDwAXB4ALNeBoeD4FBnJThz G/lccJgLDi8Fh+vBYS04bAOHN4PDe8DhQ+DwCXD4DDh8HRy+Aw4/4yWSg18lTeMBaQ44zAWHK8Bh ETjcDA63gsPrwOEucLgXHP4QHD4KDvvA4fPg8Lfg8ANweJz3y0k4RdPky+S5YOjL4HA5OLwcHK4D hxvBYQgc1oPDbeDwenB4Kzi8HxzuA4fPgcPfgcNBcKjLg0qy/L5ymvyBMk/+UFkCDleBw2JwGAaH 14zl0DMrgcNTweHZ4HCJ+NYCOLwSHG4Gh9eDw73g8Mfi/3wBh8+Cw6OsgNvYBj6TFfNzweEacPhv 4LAWHO4Ah13iJ3fg8CA4/BM4/AtPQUx6wFWGNJtnSufzLCmfF0rrwKEfHNaDw6+Dw5vB4b3g8FFw +Aw4fA0cvgUOh3iHbOed8hTeJc/k++RzeExeyrvlAt4rl/I+uRocNoPDG8DhbWDtfnC4Dxw+AQ6f BIfPgcM/gsM/gcP3weFf5B1KinyzcoZ8G3g6qhTI7ypXyseUzfJ7yjXgsB0c3gYOfwAOfw4OnwaH r4HDT8ChPpbDKWckcHgaOMwGhwXgsEp8/wIc3gAO/xMc7geHL4LDN8Dhp+xingYOzwGHl4PDfwOH Gji8Axz+CBz+EhweBod/Zo3SVNaE8yWBrxRpLTgsB4dhcNgKDneBw7vA4T5w2AcOXwGHx3itzHid nMrr5bm8WT6f75Qv5u3yenBYCQ7rwOF14PA74HAvOHwEHP4aHP4GHH4mr1Ls8mVKhrwOvGxQFslF Sr5cDH6CylflsHK1HFVC8jXKVnm70gIObwaHOIfKw+DwZXD4Fjj8s/yexSkPWk6V37fkyh9YVsof Wkrkjy2blS9btinLLLcyZrlT3L/Ybfjj8WRl5W9rabFbuN020Nk52NbWNigq1lCbhqstZLdyu32w rRUXehT0DGoa/mhjKhoNy83XtNtb83OpggnDYpadc7uimRepbuvcE9vT2dkmFFjMjkG7ndudPT13 47r1VlKwf/9dd+3e3dFBlYZWuhpIAVmJSQ5bQo+VfKCuzjbSbS3t1Lyqp7PUbmF265BqXCPGGeoE CS0t+flZWR6P3cXsrla1VV3lXeX9CkTVVDiGua0rVuTkrFjRSora2goLhSKrhVttg/aGtjayygYn 2sTqVoVbLSHhVIja7WIIBtH4UNuQpjXYFWZXcryDXnFhkNXa0NlZqoUM7qHpwQNiikEdMxhyyrpd VpnpRYwc1DRB5Z7OMRxb7dzqfPjJnbhoSUOXuTouYZXVZthKO2K1GQba7VaZW5UBQwu8sIa0WI5n wKYwm2IYm0NqxOhbqqwWZrUYZFgdzOpo09q0dcj9MyFGH3oK2+yjw7xesYBlAAVtIMFmppE3Ax5P qdfLvLLEuIwhVs6tsiZuJzWOS9a4DXN2uSzMYbHbPR5VaNQ0LiMlDHArU6zDirC6dHCw1ClBu+gV l9dLVVEQl6bJMk7enj17HA5ud2Wy09nl2i7tTu0u7TbmRZ6gbSauiC1USvcQ60NmD1ZXvfFKyG43 h+XkFBZ2DuEk0YGjU2325HrpdBiVITJe7Ly5ToPdM2C3M7tj0+7dVVPnzr1EtjCLdYgN/Y0gxTG2 iYDTNDPg/qlBahs/SAVf3Vo3uLpT2w0Rez42WBGSjtz8FlxYIh6RIljtoz158j8lWN2fC1YakY/u rPyWLwpWh4U7bFpitFqNaKUOezxc6Sh1DooOhTkQruPF64iyLwhYZTRgHQp3IGDNiHVw7ogT/r8K WZFtHoydELKUYLzjx6z1b8SsdTRmrePEbKLVTCOPSjtPJmodJxe1Lgn6R6IW0Ur1kbA14tYh4tbp 5Hb3DKZql3t3QW7ytsMeL97d6ViNRi4qo5FLPSORa1TMyEVlNHJRGY1cEWPxyBU98cg116HIdSBy fWwX2427DhdL02ZpFzFFUDjE2JDDwRwOO0uDCJaXsR10PhxW7rALxUM42kN4J3PY85aT28vzRM0x 1CpCpQV94ogNaUYMj9aGNOMd0OEQ877V0mLOE5OOCxh7xGi9ViOq21qFFutI15DDyR3uGK693r1E 6C5vBwQR63B27917486dX//6dVTLW36tuLCUUEem01F3iD62nF0bl+XYDa6NDmtDdiLbxY0F8e6w MYftuMe84rZT5iDShOZlIEzQJuizM4eLO5JE0N9ghv05mgh70OuwX7t81qz0WbOWX0t6zSzh8dgs 3Ca2ugGn32nlTjuUPrIfFu1/RHQZ9zltIepSFCXaga6OqM3KbeLOYljTtjkV5rTEo9+LkTbbNnEi NAxoGKMTLhLpZgbQ3LLuGE0BSAJOC3eKdGHug5Nz5+gWaTYHt7l/wvoprRpChpi6R4xqNZY12/c/ IjZAVE3b4YVN4TYzKWiiLBJcqcczIBKZZcSTHNJH6uCwoElEPELe5mQ2V74333uWJmQS7qyNbnQW FrY5E4YiFEj/oEcE9aCTS86RNwtwQN6KmMtRBQmKxCRFxDESgg1uixShSZxLKEs2TN21K8nKXFZF GZMnuGIZwOOOxXbcQns5NDQUSpK506ImZAqVWkTBuNCFrOK0duJyiVOTomEL1UvVneoudZf3m5Qv LmTmiTQTBtXMhKEOmX1ki3e0ZpxdnGtbelbWihVtw3b7SEwiadhNLcgaRtqgkcPkEVyimpE3kDic TuZ0+fB4LFJHOXNoTm+qd6b3dE2xMavtOGPHnQ7mxOkeTR87EA8UcTbudFBgiTQx7LSjunSZwcay paLqHG6hWL0WveKMDo/kjGHalngK0Wgwzf32tdeac8U8nWafcERJVevIzUGrqNrincNOF3cmxUpj pcjRe25Ub0Sc3qCKeCWlIpUYuQT5wulaaroyci1DxiD1wi0jr7ic4467kLFYnACkltbWFvOoiWMu 9sBpY057PLd44j4ZyYtY/Xx2sTNhf3KrOnJbMZphnOgzMgylGFIfTzEeMzCVbQgkl5W7RD5ITDI2 M8lQnzJ+lnEpzCWyTDzN2NC3XYS6hlu/bWPV/t0847JwF+2LmWhcnLsSdvFflGmEqw2U3Qf/1ZnG xSXXSKYRNJDDIjxPJtc4MFm4/IXZxs4sdh3ZBtEusk2yzF0J2UZkGWoaTTdmvnFRvnG7cYpSYjmq 13NJ50403Oj5jtoR87JSNsMIIPOZVbBrkZx2NZ5zzF6ySfUOx6sNoNp8r0mPpx2qboOTCb15XvOI GNV44vHG1xXbZh/8W6nHZhepx+VkLqebpZKcDvFqOzRo92pel427zNij7OOyo57pM/jx+jJF3Tl0 vZF/Wq4fosMr8o+ZgEbrBJrLwV2uGaxU8zLsJfu2oUcr1WYw6ho9t3rCGT7xTJNVLfFbnBaxymhu wqpJ3JUSS4+l78nak9W5onOFyPlft3/d3mKnVWLaHkgnpE1rhbRArjVsm87KxiShZahPZyYNdJNG Uej8gqGnIV/FBxv5iqzDfsDPHLvYPZeNuRIylucEx0fVLWW0M2If8Ec7nfZG7JEbQj62wKOLPYZk CWf3eLwer8sBMoUCI+HZ4/ejgjmsTQ9WxtrmJy7IZzgtbht3U7J8ZL+4N9v/yJgnT+qVcC2+RPRe sth8xhQ5Db0W5rbkjiY1cXLso1mtZdsJyltajLebOH9Jsu5MTGxqzG3lbkqEI/vs5tydeAw0u4vb kx+N9aqtCULPpSOLjHlIdY32UIKj+og3cIweTs0Mp5n3/eJdBm8yeM+xer1Dhmu5pNVYADTgSdQ+ 7rPqSKIznrJFakOmcyUOR7iOPGwgcLUhN5fc8Zt1wQ1xEGpD1J+Y7excEk/r7MR05xbpLtnG3DZJ Gkl4Zr6zfD7fpcjcLfKd11wSJZXaqDSS8CjjuW0i4yWJY2eLpeeonktXrDiA4GrrbLux81ulRs6j s2/wPUK5y5FT2Gke9eNUb2gF2YpIe6N15D1JQmyI/OJOS5uVn9+qw2vqNxKfRP2ibmS+Uf3HTUfh 6ej6YkeVIZeLudwhb5u2k90AqYs5Vaeaqs5Ul8Xi6c/tYm5XMktmp5Kco52jlcZ24N5G3N647dzt HO7t7d0/3NvT09M77HagYQYLaaUsliClaJnBkBfc7uOsR+vWYglXt9ajHWcUAcdFfZhaj482HDfG 0fQZWshr6O4zp5fGQrEZGnWO6tQTF4i5JRycMQ3C7p7e/v5Dg4cO9ff29ojF7AkDjruTudszMH1g +mDewXmHgoeCB1b39+/v6Ovocfe4abGB2GDsYOwQpB/SC3ki1hPrjrld3J00g20xKRqR0tiWGCgw CCOuaKFk9xeP1tgAyyFGh1kv6yHpZaJs1Lo14iivIhYbaJiebLX2N7jtzO3Q00evE3gZvXzahYz2 1lhOiNhbY5fFfrtTuHtSt7Xb2nN9WUdZR0V/Rf+iQwuK8hrSc9JzDAJ7Kiry0tPzKip6etxO3e3w aT7tPCYkU/zStrjQM+22Xqt1e2/vM/VJdp7kFCYcfqNHXG8cNp76K8iuijzql3EtqaT+yiXikRtu 9vbiJGzKS7LyJGteaWnpUKl5uUX/DhzD3m2x7Zix/cQlenqSJJ6kxGJ4Axq5PIqeZMnJYSxn9BpI svEkh+jtxdEYPNTf32tOTLgcbu5IOTzwZk7vGKHPBeLrGZ8SVFC5Is+d0PfGYeMAOpxx/+ArPSwd GhhZQnxc0LBfbKu7o0Hc01lH3c0l3eY6IEd8RCA+iyxjQhZBpkMcyfgjDmtZeuUt5bcseDBvML00 vZQ+IqB9E9vmHn9uOiSHkRHD7vT0HJyP4SRJSkqIIfBIXDV0WK1Wdy64A48WmUsWWBjT8FbosAi6 mWBcvC+iJjmhQwTLJBtLtmGaG8rTBe9iTowr3GId5OLjOF2zYnFHwzCuBo+C/TaGmBFfWppDjVQy L9Fvwcmw94srGeE7yTaQnpuTXhkMHkUA9x/qf+XQMyHKRV7kC3GAzf0Z2SK3M7fh0Ejg6NSwrRd7 A0vBwWiDNc+K1t5tFJrJOOlTwdtsVsEuQWDCdCaERm8X+7XNHC0aMonL3tEVdVnwZ/AwalPZhWLR IdxAu5NDahtl6J0szJQBh8fhmeQ53eMdUPBg5BAZmpnfQnGyO6UiJpc1hoMsrTLs38wWB33RGrYa PfyKtctV7Kr4f+DFzwitLAn3PUaNM2wHm0LtRouEu6IUeDWVySsLC1ewWWvXXKaynK+uLVBx22WM Ed8D8rBTqCZjhUlx7XiAw13YNLOGOx82mWWwU8tCkRC7i/D7hA8SPkz4GOETm/3hGnaA8BnCFwhf JRwgfIPwqPgeG/tAILcSZhBmEy4nXE94dfXm6s18O+H1hN8ivInwu4T3EP4o/m2ev4f8JNEOJmVw YAXDiDvm+r/YJmEfkv7hV3G6xffgxTelW/CMdCd7iD3BnmNH2AdcYg7y1G56e5SJf4MiY14acggX P1vli43XtuuN1zuGEubgvB27c0ydu4fH1pNnj61PSh1bn9w1tn7m8bH1rBP6z8oYW1+ALCcl1j9K 6Lcyfmne2PrqG/DqxJnOYoXi3+1gTguoypEK2Q7pLulltke+Q76DvaBElb3sRcvz1jYuO69w+vij zm/gMe2A2+O+WLrIfaX7u1JjUnnS1dIvknYkdUj7k6Vku/Rc8qfJn0qvMK59IrixvpT08LhyEPJq 0h8S5B1TDo4jHyXPjEsWZDEkH3I1yS0nStLB5DuTf+q5yZQ9CfJ9IeKOfRxxTiqMyw2TdsflE0NS p48j2ZAFaV0Jcpch1HOCpD2UdiAuz0wZgLwhZKoynqRmT02dmnXKDQmym+SJceXgKZ+NSHpaekZc 8k1ZNa4Ukqw3X8eKZqIY10vyQlyM2a+nD047a1r5tO9Ou1fIidqn/Wg8MbRPe2TaEVM+GhWxyrTP aC1N/D1t9RmL47L6jLVxKTflaoh2xtWzzoV4z8w+M/+Mq4HZZz4x+8Ccl0g+yiqBhObOhsybe2Tu EP4emXv8rANnf1fI3CNnP3b2O2e/M0+Zlzwvbd7PIC9kL4UUZpfMv92Ux8/Rzpt93lsLdi1aAFl6 fvr5Jec35D5kymO5vbkvLD4Lkrv4+iWHL7CSdF7wBMnw0kVL7zfl4QuGUb9/6SDVBi+ULpSW3n/h PO+3vI8ty764CPL6pVUXdBqj8TpojFq5VIxbuXrVzFU5q5auurdgNklhwdUkDQXXF9wObCh4CjKw umm1tvr1y0KQmy4vxajCy5+5/JmCp4CHRQly5PKjl3+2RiO5Z00/yetrjuLv62s+KVTWfIL+o4Ul hYcLj3wlCtm1VsW4e9Z8YvSsbVrzydo/rD22rnB9b1HRValXTb9qdqVSWVJ5qPKzkdeqeZCHajw1 M0MNoZZQLHQkdDT0yRZly7lb8rdUbAltadrStuWmLfdveXjL/i3PhUPhXeF7wx9EWCQ1siKyKfJY 5KXoguim6O116+va6h6v+6jeWj+v/pL6++v/m7czAW+qTPv3SU6bhCZhKbugGEAUFFFAccAFFRlE rYjL4DIaEdS4i7JbaA2CC4grgjquiIACasQRlUyBspXFUpq2NkhpS0gaT0pbek5jAd///Z4WRPi8 Pr//dX3fleuek5wt7/P7Pc/znnSYdw5MHja5cUrXKcOneKdMmPLulJVTSqZ2n3rX1G+mlkxtnOaa 1mHaJdOumjZu2pJpJdP7TB82/e7pC6cvn75nuvHM0GemPfNDpi1zaOaEzC8yN2UemXHajAdnLJmh zRw8c8rMlVmj/qRXfXNyP/pjt8ma9PtL9hHzL0/Nr6YO8ie1N/LkivtjnTRl+n/ZdY51nhNef+wd WZt+f8nukFX4+6upL8ge2np5p00d36APl15eQ9c0e7C5pd+2GUV/Xdjyo9YL3PnHeybntjF6jJPX ur9pufD33tmkEt15mNl/m87q3vKjY+rJvbIXm+eWyuPm+c0Kct9v3Pvp5B9xRal5t3xGt4Btqfn6 fXaInzQrDDthHvh9JvhIjvuU7r/8lO6f1tzzXzT7vdnlzftwdcthvF94rBPix9Jmv+hNTf2nqb81 +0hPpANK18Yd747HHKXHdRqZVSGv+N3jHqOzKrIquJs8q55jozpX9Bh9ak7QBwtP6Kj/RZ89sa+e 2lObO/cmM5uauuj1x/qn7Ovs4VuztM5L2TO606iLB2bs7JDSNI+ZW+asjo3t95FV6cdmn2OzSnrX Dim/z0BNWSnnNvPsFHkG167vkC6PyD3yLLk/vas7/1imdjotvSszYLq8Xr5v2vv7PHriTCrHYs6a zfPmCTNnOnc4eZ584w+zY37zzNju2Og53tj07fL7rxvVfl+nYYznD+pL1aTGOHVCxR7TuKkSpZpN mdJjHHqPlG5KJTqNave26fdS6c0JVT2480piPTbDFjbdNUvrlJWlNb3kN8htj9HSFfmuKdPkNks7 6/ye/ZtomuF69jdnpRNecoZrmt3M+fH/82XOqSe8Tj3DnGlPeDXPuMdfp14hZ9r/2cuci//y6/iM /Sevk5WSr+Pz+J+8zJn9L7/Mp42/+DpZHfMZ5YTXqfqZzy4nvGTeNzn9P3udeuf/fnR/7dWks3x2 afnRZbaR3S874i6VTz3m6xVzj00+6ZifXhnZXT4DNR/jxRPUJfKpqWmv7P3ynXyZT0djzCcr+QxV c3mN+XzE0xHv1l/2ivl0knX8KUa+ltyYlbHnxiz5BGN+WtL8nNP0fglPQRVyj3yikddlNL/MJ56n zWcjzjWPLpH/2XklZy+RT1N0i14Ze8znrinNr1Hmnl7yqcv8NCpjj+xLzcd48eR2Ac9q8glNXjfb fMfLfE57wnye41zzSe3489p1o66wmoockVrc9HSTEpfZzHgYcdNIr8sz7y2/abZ5L/O+f6zEUx09 MQ/OLmr6pNjkeoFynUC5SqBcI1CuEKgGlUGKXOco31wtT77TzLW2LObKfla5ap+5Zp9T+UwcUXLF EYtXaWu5VxltGat0ttyneCzjlDaWh811AgfKFfHM9fAs5rp3KZzr4tw2nOvi3DTzfhHOqlZaWO5W unK8B8dv5fjpHO/Bvc7iXh65Pp25Ip1TricnV5BTn2EcmeLfjHewWineUvcrF6gRpb8aVc5Vq8Qu Nc6vXXn3fHPNuBS5sptc102u6mau6TZFaaWMVFrDYKW3MgTkGm/j4X6QK73Jdd4mwiSYDFNArvom 13ybDs9AJswAP9fPgudgNsyB5+EFeBFegrmwRrlK+Q6SvP8NhNLbooAFRilDLDfBaLgZbgGfcqNc UU6uJ6feplyq3qk41HvgEeV5uVqTmq2cqfqVM1LeFwUpH8CHUKD0TtkNhRCCIiiGEvgJSiEMe+Bn pXdqa7ErdZ8oSP1FcaVqvE9AjSiwpSojbb3ZDlB62y5m+4jYZXsUHoPHYaKI2iYB2tjQxoY2tmmA NrZVyhDbF/BvaFCG2Pso3eznwj1Kb7sXxsKTMAGmQhZkAxrZX4FX4X34ULnK/hnbBFRDDdRCHTQA Gjrug3EwHiYq3VooypAW7ZRuZu4eMNfIk++qzBXv2pO1AbI2QLb1ItuuJNueJdtuJtvGkm3Xkm1D 5ep0cg069TbxslyFTq5BJ1egk+vPqUGxRK0kzyKKqh4gB6uUO80822+uRdfmeFXcrfQ74f4juP8k 7n8N9x8k14rj3m/I1eLkWnFypTi5Thz3+4H73aa05C4HuctB7tKau5zNXR7jLv24Sz/uci53kStJ 7pVrunEnuUpef3NNNxnpVnP1tU7c4z/c4z/c4xzLPeI77tOP+9zDfQZyn5u5zxVyTTXu1c+yUHwr 10iTK6Fxv0lyLTS5EppcB02ugqZWiHpGl6fGqNYqpa8ab67YNty1D3f1cddB3PUa7tqTO57D3XbL VY/MlUj/Tf46mzvMUTqJ7CyLFL/QlFnwHMyGOfA8vAAvglxfcy7kiaSyDbbDDtgJP0I+7IIC2A2F EIIS+FkIZS+UwT4ohwqoFNuU/RCBOhFWDlHn9aCDAQ2QpLv9yvFGOAxH4Cj8xliE0CwKWMyuWKne QYbdJQ6qd7P1ioMpBUJL2Q2FEIIiKIYS+AlKIQx74GeIiWRKFcThF9AgAdVwEGqgFurgENQDY0n5 DYTYlpouttmHiqT9GhgJ10GGiNpvYXsr3MHxO+FuuEdodi+MhYc59iTbCfA07yfDFJjK52fYZrHN htm8nwP4YJ/P9hW2r8LrvH8D3oQF8Bb3f5/9H/F+Me8/4/0q3n8PeGTHIzse2fHIHhbCvgfwyI5H djyy7+OacqgAPLJXibA9Dr8QiwYJkW+vhoMcq+HetVAH9XzGO7vBtoHPeOS4D8bBePyyKi8r7cyZ S1VeJndvlSth4W8qn1bwaSSfriXLc9UflXMVC3sNZRiZGSYzw2RmmMwMk5lhMjNMZobJzDCZGSYz w5wdJdOSZFqSTEuSaUkyLUmmJckijYwxyBiDjDHIGIPvk+uihdV/KqnqvTCWDLpPVJI1YbImTNaE yZowWRMma8JkTZisCZM1YbImTNaEyZowTho4aeCkgYthXAzjnIFrYVwL45aBUwZOhXEljBthVE+i ehLVk6ieRPUkqmqoqqGogaIGihqoGEZFAxXDqBhGxbBZsaWKHS2vpJIdzL1rmXtXq/nMtbuYhZht TH3jRLiLCMtNfZ/hk1zftyv6PssdipUxzJMe5kkP86SHedLDPOlhnvQwT3qYJz3Mkx7mSQ/fdDFz ZU/myp7UbCE1W0jNFlKz5dSsTs3q1KxOzerUrM58mk7NRqjZCDUboWYj1Cx+K9cxbw6kTsup0zLq tJw6LVPHKr3U++Ravcos5tFuzKPdmEe7MHd6mDs9zJ0e5k4Pc6eHudPD3Olh7vQwd3qYOz3MnR7m Tg+1GKEWI9RihFospPZ0aq6Qmiuk5iLMcR7mOA/zm4f5zcO85qFWIsxtHua2ntRKhPnNQ/4Xkv+F 5H8h+V9I/peT/+Xkv07+68x/6cx/6eR/hJwvJOd1cj7CHOhh/vMw/3mY/zwy30UdWtfxfPayeA4H RtDPy+nnE3FiBE58wtG5ZPs1agFPUoXiNzWkjDXdC3N2KWeVMGO+LGbwaSzXFnDtbvYO5dqXuXYz 147k2kKuu12xNdfRPzgzxJmFnDnSfL6SOfOpeafxHL+C4zs5XsTxIdzpBY5+wZ2u4k553OkC8/yf zOfEveZ/GkqapZXSzXIHPAKPwuPwBDwJE+BpeJGZvo1c41KuZylXs5RrWZrPRh8oHdXvlYvUdfhf ofRg1r6Zp8R0Zu7TeErsocboDFWMIM6+X5SLmM8niHVc0YFnyu5yTuf6R5RrmcHuIOfvVK5V7zaf vq5VWjKyLoysCyPrwsi6MLIujKwLI+vCyLowsi6MrAtXtuPKx7iyHVc+Zl7p5ko3V7q50s2Vbq50 c6WbK91c6eZKN1f24soLubIXV15oXuniShdXurjSxZUurnRxpYsrXVzp4kpX85UDm68cSCR3Kn14 18fUOGA+IzTINS7l2nBwE4yGm+EWJY1ntzSe3dJ4dkvj2S2thfzvaVPkOpVyzcXmJ41c06NypdBy jqiw9IY+cC6cB33hfOgHF8CF0B8GwEC4CC6GQXAJ/A0GwxC4FC6Dy+EKGApXwlVwNQyDa2A4/B1G wLUwEq6D6+EGyIAb4W14B96F9+B9+AA+hI/gY1gMn8AS+BSWwjJYDp/B57ACVsIq+AK+hK8gAF/D ap7WctiuE6WW9bABcmEjbGL/ZhGybIGtkAfbQK6XuQN2wo88QdzBr5W7RX7KRp4kNsFm2AJbIQ+2 wXbYIUIpO+FHEUptIypS20F76AAdoRN0FhW2+bAI0MD2njhgWyIO2j6FpbAMlsPX7N/AlqdN20be 54uQbTfnl/DeEBX20+EM6AZngkcctHeHHtATzoJeImQ/G84RpfbeQC7YyQU7vtv783kAx4aIA/ZL 2Y4WBx1WUeFQIQVSwQZ2cEALSAMnuMANLaEVtAbidaRDWyBuB3E7iNtB3A7idhC34zToAl2B8TsY v4PxOxi/wwPdoQf0hLOgF2PqLw44BsDfRMgxGIawbygMh7/DPZw3lu39HHuA8x4EHzwEEzmWCTNg JmTBfPZ/zPmfcv5SUepYxuflUMc+XVS0sACxtmgrQi2Io0V7caDFmeTQdHNNVtSxoI4FdSyoY0Ed C+pYuMKCOhbUsaCMuXJrG0iHttAO2kMH6AidoDPItV3lyq7d4EzwQHfoAT3hLOgFZ8uVgfmV3Rv6 wLlwHvSF86EfXAAXQn8YAAPhIrgYBsEl8DcYDEPgUrgMLocrYChcCVfB1TAMroHh8HcYAdfCSLgO rocbIANuBLkq7U0wGm6GW+BWxn0b/APGwO0gV5SdATMhC7LhWfDDLHgOZsMceB7kCrdyfdtX4TV4 Hd6AN2EBvAVyxdd34F14D96HD+BD+Ag+hsXwCSwBZkDLUlgGy+Ez+BxWwEqg11rotZYv4SsIwNdy dV250i2shw2QCxvlOrOwBbZCHmyDk7vIreJeufou80ArOv+lzAOt6P5yRf9dKXS8FDpeCh0vhY6X QsdLoeOl0PFS6HgpdLwUOl4KHS+Fjpeykt8oq+AL+BK+ggB8DavhW5FIWQPfwffwA6yFIPwHcmAd rIcNkAs7FFfKTvhRcaW2UdJS2ynO1PbQATpCJ+isOG1zRcI2T2i2+bxfwPuFImpbxJyEB2Y3+4Bj xGL7hGOM2caYbYzZRpe2rRL7bV/AVxwLgOxy33D+v9m3huPfwfd8/gEYp41xmt1vM5/zOLaN7Xb2 7YCd8CPkKy7bbr6b33Y2ftvZithXLBrMTlnK2Pg9Z4tyLb9ZbBrvebq28XRtOwj8ZrHxm8XGbxbb IagHHQxiaxD77S1Fwt4KWkMb6CQa7J3hNOgCXeF0Jc1+BnSDM6GX4rKfDedAb7iQff3ZDgBmWTuz a1PXVVwOq+J0qJACqWAD+U/HHdAC0sAJLnBDS2gFraENpENbaKekOdpDB+gInaAznAZdoCswTgfj dDBOB+N0eKA79ICecBacLRKOc/mNdh70hfP5zJOC40LeH+vEA3l/MQyCS+BvxDEYruf9DcDvXMeN XDdK5DpugtFwu2hw3MM47+e8k7s0v3cd/N51TIZMxjADZkIW57/Ad1P/ZtdewHYh910Eb8M78Cn3 WwrHuvhn7MNDh861h0VDC0Xsb2GR/4MvobWQ/1o/jW0b9rdVXGZnZ4Zq0ZF9naAz0I9bdJV/l5SV 3vxclSnXsTaf0dYf3/+YXD/a/DuKfN6qVlKtI8Rd6g1iA0+nafJvWxxLKOdZLxBx60AYBFfACLHL eq3YZr0ObuCp/Faxl6eLPTxd7EkbI7al3QFzRDzteXgBXoSXYC7MA37Lpc2HV+BVeA1ehzfgTVgA b8FCWARvwzvwLvwL3oP34QP4ED6Cj2GxiLvOFXFFZaSGdQy/iSfwG3oI49cZv24dLCKMX7dezfYF UW59kd8udyp96V99OXNb2s0iknYL3AZ3wX2iPO0heAQegyfgaZgjdGLTiU0nNp3YdGLTiU0nNp3Y dGLTiU0nNp3YdGLTiU0nNp3YdGLTiU0nNp3YdGLTiU0nNp3YdGLTiU0nNp3YdGLTnSNFufM6uB5u gAy4EUbBTaKc2HU8HCSKcWi71fRRbDH/ctiN2JcS91LrnWKldRw8Ci+IHDSQ66iXEvtSYl9K7EuJ fSmx5xB7DrHnEHsOsecQe07aFLEybSpMh2x4TqxkXDmMK4dx5TCuHMaVw7hyGFcO48pRrsQBHw74 GFslDvgYXwMZVE8G1TPOMkZSwkhK1Ft/q1fH/KYzu7hxph+zixt3+jX/xs8lu+rJrnpGV8LoShhd CaMrYXQljK4EZ3w448MZH874cMaHMz6c8eGMD2d8OOPDGR/O+HDGhzM+nPHhjA9nfDjjwxkfzvhw xoczPpzx4YwPZ3w448MZH874cMaHMz4UKEGBEhQoQYESFChBgRIUKEGBEpzxKVejghcVvHixFRW8 +LHVOkI5negziD6j+e+tLzX/nu6DCh1QYQAqdECFAc1/Jb4dr7bi1Va82opXW1EjAzUyUCMDNTJQ IwM1MlDDixpe1PCihhc1vKjhRQ0vanhRw4saXtTwooYXNbyo4UUNL2p4UcOLGl7U8KKGFzW8qOFF DS9qeFHDixpe1PCihhc1vKjhRY0M1MhAjQzUyECNDNTIQI0M1MhADa9iJxfqidhFxK8S8SQiTifC GUQ4WemMRrnok4s2RWhThA7paJDO0deJP5f4c4k/l/hzib+I+IuIv4j4i4i/iPiLGEcR4yhiHEWM o4hxFDGOIsZRxDiKqBWf+PSkflev9LXeRI8bAz763EP0uIfhEeDejHjf8V6XSc+YKbY5p4u48xnI hBkwE7IgG54FP8yC52A20Bud9EYnvdFJb3TSG530Rie90UlvdNIbnfRGJ33RSV900hed9EUnfdFJ X3TSF530xZYtIA2c9DzZ2ePm2HVqPEKNR6jxCLrJ3+m9OFpA7Uao3Qi1G6F2I9RuhLHrjF1n7Dpj 1xm7zth1xq4zdp2x64xdZ+w6Y9cZu87YdcauM3adseuMXWfsOmPXGbvO2HXGrjN2nbHrjF1n7Dpj 1xm7zth1xq4zdp2xy541RvyE2ttReN3xniUjKlP6E1GA4xUcb8CNI7hxBDeOcG4Z5zo410mlpBHp +VRKGtGe3/w3oE04dASHjhBlgCgDRBkgygBRBogyQJQBogwQZYAoA0QZIMoAUQaIMkCUAaIMEGWA KANEGSDKAFEGiDJAlAGiDBBlgCgDRBkgygBRBogyQJQBogwQZUC5iEj8eLMFb7ZYfUpX/NlCBPdR Ab9SAQaRzCKSjs1/meko/zJDJG/Jv2bh3Ra824J3W/BuC95tISo/UfmJyk9UfqLyE5WfqPxE5Scq P1H5icpPVH6i8hOVn6j8ROUnKj9R+YnKT1R+ovITlZ+o/ETlJyo/UfmJyk9UfqLyE5WfqPxE5Scq P3U8xqzjS4jix+b/zmk4o36dUX+lOIl3B/HuINYdxNWemNpz5E3i2UE8O4hnB/HsIJ4dis06EV8n iV+tk8UB6yzyYp6otr4p/9LO3kbrLGEoFv7zV6U3ZxjWKWTEVJglQtbZisM6h6vniph1gVy/Xxy2 LhKHnTzfOnm+dZ4OZ0A3OBM80B3Gcc54uB8egAfBBw/Bw/AIPAqPwePwBDwJE+ApeBomwiSYDFNg KkwTh814GhlppTVTRIllv/UNcdDKLz3lDusEsv0pmMjeKUQ5FWaKfGsWZMOzMEtpb50tVlnnc94r Yp/1VXgNXoeFYg3xrXFaxXanCimQCjawgwNaQBo4wQVuaAmtoDW0gXRoC+2gPXSAjtAJOsNp0EVU o2E1GlajYTUaVqNhNRpWo2G1c7DIdw6BS+EyuByugKFwJVwFV8MwuAaGw99hBFwL44hjPNwPD8CD 4IOH4GF4BB6Fx+BxeAKehAnwFDwNE2ESTIYpMBWmiTVKCpmzFxV3o2K5dYGoJZdmiTrypEEZhQtJ XEjiQCMOyAwrZ8YxmHEMzjBQOYnKSWYYgxnGYIYxmGEMZhiDGcZA/STqJ1E/ifpJ1E+ifhL1k6if RP0k6idRP4n6SdRPon4S9ZOon0T9JOonUT+J+knUT6J+EvWTqJ9E/STqN6J+I+o3on4j6jeifiPq N6J+I7OcwSxnMMsZzHIGs5zBLGcwyxnMcgbqJlE3ibpJ1E2ibhJ1k6ibRN0k6iZRN4m6SdRNom4S dZOom0TdJOomUTeJuknUTaJuEnWTqJuk5iaR3bIWM9F0Btk9S2mJ2pWoXYHaB5Un0DiIxkEyPcaZ W9C6Eq0rrdP4nCmquKqOzNfIfI3M18h8DR+O4kMQH4L4UGt9WWymAoqpgGIqoJgKKKaWttMbNuFR CI9CeBTEoyAeBfEoiEdBPAriURCPgngUxKMgHgXxKIhHQTwK4lEQj4J4FMSjIB4F8SiIR0E8CuJR EI+CeBTEoyAeBfEoiEdBPAriURCPKvGoEo8q8agSjyrxqBKPKvGokgrRqBCNCtGoEI0K0agQjQrR qBCNCtGoEI0K0agQjQrRqBCNCtGoEA2Pg3gcxOMgHgfxOIjHQTwO4nEQj0N4HMLjEB6H8DiExyE8 DuFxCI9DeBzC4xAeh/A4hMchPA7hcQiPQ3gcwuMQHofwOITHITwOKT4cjOBgBAcP4fd6XDyIc6U4 9wvOVeNcNc5V41w1/rvw/yvc03BPs77Evnk4PV+swMEYDsZwMIaDMRxM4GAtebIWF8twsQwXNVzU cFHDRQ0XNVzUcDGCixFcjOBiBBcjuBjBxQguRnAxgosRXIzgYgQXI7gYwcUILkZwMYKLEVyM4GIE FyO4GMHFCC5GcDGCS9W4VI1L1bhUjUvVuFSNS9W4VI1L1bhUjUvVuFSNS9W4VI1L1bhUjUsaLmm4 pOGShksaLmm4pOGShktluFSGS2W4VIZLZbhUhktluFSGS2W4VIZLZbhUhktluFSGS2W4VIZLZbhU hktluFSGS2W4VIZLZcoFuGTgkmFWY5ML9bhQiwu1OGDggPzdVIu6tahbi7q1qFuLurWoa6CugboG 6hqoa6CugboG6hqoa6CugboG6hqoa6CugboG6hqoa6CugboG6hqoa6CugboG6hqoa6BOLerUok4t 6tSiTi3q1KJOLerUKn3oDEfoDEeofo35PM36ElHMJQpz9LxfAAuZ7xcxb3fhqa4rnA5nQDc4EzzQ HcZxzni4Hx6AB4EnSLRuQOsGtG5A6wa0bkDrBrRuQOsGtG5A6wa0bkDrBrRuQOsGtG5A6wa0blAe ROsYWscYscaINaogThXEqYI4VRA39T9WAeh+SubzBG+Vf9n482yP4UcMP2L4EcOPGH7E8COGHzH8 iOFHDD9i+BHDjxh+xPAjhh8x/IjhRww/YvgRw48YfsTwI4YfMfyIoaCGghoKaiiooaCGghoKaiio UQ1xqiFONcSphjjVEKca4lRDnGqIUw1xqiFONcSphjjVEKca4lRDnGqI/4VqiONQHIfiOBTHoTgO xXEojkNxHIrjUByH4jgUx6E4DsVxKI5DcRyK41Ach+I4FMehOA7FcShuzvE15n8LeTFeaXil0W00 uk0E7TW0lxpraKyhsYbGGhpraKyhsYbGGhpraKyhsYbGGhpraKyhsYbGGhpraKyhsYbGGhpraKyh sYbGGhrLGDVi1IhRI0aNGDVi1IhRI0aNGDVi1IhRI0aNGDVi1IhRI0bNKXNhIkyCyUC+EaPmlP+/ q63pxfofa4ZMe8msdIOeavx3NcKz+ySeUfllSrW5qDYb1VZOpbWn0tKUjOMdZSKzcSbM4Hf5LL7r BVFDZtdwdpLarGF2rueq81HYQOH6E56aasjuGrK7huyuIbtryO6a/6NuU0P21ZB9NWRfDdlXQ/bV kH01ZF/N/+pTkfy1kkSpzcd/t9QravO+JC4dVm5F2zy0zcO/BP4l0Fb+sinFiVT0jaJv1Ox/8/n8 Br8R3uRJaSH7FokoukbRNYquUXSNomsUXaPomoeueeiah6556JqHrnnomoeueeiah6556JqHrnno moeueeiah6556JqHrnnomoeueeiah6556JqHrnnomkdOJcipBDmVIKcS5FSCnEqQUwlyKoHuUXSP onsU3aPoHkX3KLpH0T2K7lF0j6J7FN2j6B5F9yi6R9E9iu5RdI+iexTdo+geRfcoukfRPeqUcU6E STAZpsBUmCaipsa/NldCUmlrXa10sK7jiXM9eblBZFk3i6XWQzxn6GK+9VeRr9I51b78eu0nVqkD ReT4v1a+TWmt/sP8/zOU/6Yw5gqLnTi2mPuuhPVUwAZRaM0l0zfCZr5zC9ttImzdyS/dQr4txLYI YkoLaxWVqvOMa/Ak1ACNolZVxD7VDg7ozK//fqJSvVAcUvvDALhIGOoQUeHyCs01XuxwPQz0CNfj bJ8QYdeTQE9wTWebyXYG8Azt8gMzpmseUJWu+Rx/nX30PtdbfF4I73KPxeJX1zLuvwq+EIdcX8JX 7AvweQ1bYnLls28XFEAxn0sgzPs9sI/zEmKf6xA0iH3udqLa3R46AL8O3fw6dPdk/0Nih5tnejfj cs8R9e554pD7TVgEH4tqZWSzqqX4lETVYlRNoGoCVY+g6n5ULUHVYlQ9hKrFqFqMmgZq1qFmHUrW oWQdStah4q+oqKOijoo6CiZQsBQFi1GwGAVLUbAYBUtQsAQFS1Gw5CQFS1EwgYIJFEygYAkKlqJg KQomUDCBgsWol0C9BOrpqKejXALFdBTTUUxHKR2ldJRKoFQdStWhVB1K1aFUHUrVoVQdStWhVB1K FTcrVYpSCZTSUUpHKR2l6pTu1uViunW1+AKlguTgYRRagiq/WPeKB8izidYq8T7ZfZu1niftX8Xl 5NkmVRW5qk28rLrEY2R7SG0nPGo35X71LPE0md9dPV9chWofk/3Dybl31MvFDPVKcWfzv84qU/8h PlDHiIdUn1gr//0SUX1HT1rHLLEBNouf+cYD+LGXb4zwDVXctYY7VnDHg9TSEGrpMn4RLsexdWIX V8l62W7WSEw5g6sLuHIrV+5nbBHG5uQOhWY9DBSFXLlObOWqA1z1DVe05Ypyvq/MrF9+VZs13I06 7cvnfmIvV+1jlLnK6WTWIfPKXDJrI2whY7Zx9U6yqpCnyBDbIrGf7NhPduwnM/aTGeVkRjlZUU5W HCIrDpEVh8iIJBmRJCOSZEQ5mZAkE5Jkwn6c249zh3BNdv6Y0pLx2Bj5Yr5vOd/7LbGugS2iEV33 oGfENUUY3L+O+9dx/zrXIj6/JwzuU6ekcFU9I5/AFRUy73kSXk4vWU0sG0Q+e8PWXfQRqeFeEUe3 Xdy3mPsWK2P41vmcnUVNVZrZ8q3I5NszubIWJRpRopE7VKKEQIn65rqqR4l6a4lYyR0DZFK+VSN7 0qCdGK92wI2O0Al6iKfUnnCW+EU9B597Q1/cQ3f1Co5faf7b5QsZzYXUXiXq1qNuPbVXicL1KCxQ WFB7laiQidICJeajxHyUmE/9VaJ2I2o3onYjagvqr5L6q0T1RlRvRK1MlK9HsUzXCjrRSvhePOXK ZbsddsBO+AlK4WeOlbEt5x4V4im3Ija5U8VKtw3s4OFzL3iIDpUt5lODlbjZ6F4gKtxvwUJ4G/4l VipOMrKObKzA6QF0n6N0n6N0n6O4PohKP0qlH6XSj1LVR5Wu+CG9NNC+Bu1ruMpGj6qlR9XSo2qJ vZ7Y64m9nrhriLuGuGuItYZYa+gvtfSXWnpLLb2llt5SS37X0ltqGWs946yhV9TSK2rpFbWWNL4x mwxYgPs5uP8a7r9mXYujQVgnNltzmRU3wmbxMVlw2FrA/kJyq0RMtP4kfrCWQhj2wM+wV8yxlrGt gEruuZ9tBKIQU7LJloA1zvtfQCPzEmyr4aB4yloDtbyvg0PCR2/Kp3OX0LlLqODb6FE7rYc5dgSO irXW39gKZmELWEH2rxSyLZX3NvpUmshSnbx3iUfNftaKbWtoA+nQTgwhW0eQrSPI1hHMrbPV08Rk tQvHukI35XbVw7Y79KDn9YSzxF1qLz6fDefwuTf04f150FdcTY+8l86yAteycS0b17LJ9hvol/PU izlnEFwinlX/xnYwDBEz1UvZXgaXi39SFSPUoby/UkygMm5r/hezK6iQyeodSif1bvCJH+mvn7t8 It/1EDwhDlMlh6mQ16iQw2RJNlmSTZZku7I5/iw8Dy/AizBX6eCaBy/DfM5/k30L4C0+L4RF3Ocd Pr/H9n3xqOtD+BgWi9muT8RkZrOZruV8/gw+hxViOFU1nBluJhmYTQZm83wwm1luputr8axrNXzD eWvY9z3n/cD7tRBkfy6fN7N/C/fNY9822M6+HbAT8rnXLiiA3ZxfzLkl8BPHSoHuTXZnU7XDXXvF D1TucGbRmVTvCKp3uKuSfeSgixx0HQDy0BWDKpHjIg9d5KFLA3LQdRBqoJYOUAcG75NiretXaOT9 USDnXOQcXSHLTd65yTu3Kta6U9imiol0iYl0iYluB59b0D3SgBx0u0SO2w0ted8KWrO/DaRDW/a3 EyXM9CXM9CXujtyvE+d0htOgC3SF0zm3G8fPBA/f3519dFi6UZZ7psinwrPdc5QObrx247Ubr90v wVyYx7HXxWQqP5tONZxONZxONZwukE23Gu5+h/v8i3G/zz0/5v6L+fwJLIFPxVOKhy4xgS7xpTkz rzfn8410gigVP5/K/ieVvZqqXUXVbmXO1anY/1CxlVTlLqoxjypcSxXupuquobLuppJWUTHzqJiN VEyUKnmTKtlNFQTJ/k/I/hvJ/hyyX/4vFS4m439UxtKvljGSz5mxCqyrmKVW0xO+Zd8aWM88t4Fj uaKI7lnEzJVDz0owc61mDkww2ipmr9XMXqvpX4sZ+Ub6VBUj30kvymXUJfSbCvpNBSOP0q8LGflB enYhPbuQfpLL6FfQC1bQC1YwysOMcrR85mH2KnDdS6cdL1Yzg61mBitgBltNbSaozQQzWAH1uYz6 TFCfy6jPZdTnMmawAtcsrnsOXoK5ooiuXkRXL6I2E8xmBcxmBXT4Ijp8EbW5jNlsNbW5jFpaQd6v IM9XkNNVzCeFzCeF5G0Vc0ohuVpFnuaSl4vJy8Xk5WJysYpcqyDXKsi1CnKrityqIq8qyKsK8iqX uaiQnMplhltNTi1jhitg5igiPxaTH1XkRwVPkGvJgyCs4wlts/gWpf8fcWcCHUWV9u9bdaurkupm D2GVfRHcAFFHFOOScRkBh1EUQUEHlAETBQUUQgDHbVwBRYgCgoIYYQQkjsriyiC4BBLSgUpnMRIC pNNUWBKSkND3e6qN89f5z/fNmfnmnO9wnlNd1bfqvve9977v7+0Tug+RHXJZC9cSzYuI5kWsh2/x ailezcGrOayJj4jcJXh2N5G6CM/uxrO7WRuVrI3DROM8onEe0TiPNXI+a6SWKBsiyoZYKwWsk3Ii azaRNZvIms2aySeaFhBFHSJnHhExl4iYi9cP4fVDePsQETCXCJhLBMwlAuYSAXPx7CGiXi5RL5dI l0tEc4hiIaJYiCjmEMWyiWLZRDCHCFZABCsgWhUQrUJEpxDRKUR0ChGdsolO2USnbKJTAVEpRFQK NUWlbKJRiGjkEI3ymJ3dRJYiIksRs7SbGdpNdCkhupQQQUqIFkVEiyIiQxGRoYjIUMRM5TBTOcxU DlGhhAhQxEzlMFM57PwiZmo3Oz+XHZ/Ljs9lx+ey43PZ8bns+Gx2eza7PcRuD7HbQ+z2bHZ7iN1e xCzmsMuL2OVF7PIidnkRNfFR1LGnqwerRnEJu8yrsx5gR2WwozLYUV8yz/PZNfXM61rmNYt5zWK3 hJnXMuZ1A3O6gTndwI6oYxfUMRfzmYv57IA65mM+K76OVZ7BKs9glWcwF/NZ5XWs8jpWeQarPIPV XI+/NuCnDazmeny1AV+V4asyVnU9/ipjJdfjnyz8k4V/svBPGau5ntVcj4+y8FEW/tnA6q1j9Waw cusZcxZj3KFeZMXWMoJPODuF7TVqHWuzRHRkZKc4K2dkFYysgpEdZ1TZxIEwI8tmZNlYdwrrsrEu G+tOYV02Vp3ColNYVIFFFVhUgTWnsOYU1lRgTQXWZGOFV8tWiK70VENPBfRUTk/l9HQUH3o1ag69 VdNbDr3l0FsNveXQWw691dBbDr44iS9O0msNvjhJzzX0XE7P5fRcji9O0nsNvdfQezm9l9N7Dr17 9WE5NUIJ8fKU2suo99JzNT0WEcu2EHEPEHG9+uCjWMQ1aVXdVEOFm/4P00VytBgU81wp7xTxTmns zKvtGmJ+9DXddZKzCM/fz/NPoIYdNG0ED59hnDaeEOBDk5pgQXfO+8AKdZxnlMRmJpfWhWQRz8Zq 0Ydn7OSdj/HfSZ61lRaHf6rvY/lGEF8siANbbWVUIxnNBPx4Ej+W4McS/OjV1yX47yQ2bMWGndiw Ext24stf1t2doPPP6u/utO/FXuzDcQXtV3LNq7k1xuyKdth3AptOYFMlNlU2fYJThfUV2FWFXVXY UYUdVdhQRd8n6PsEfZ+g30r6raTfSvqrpL9K+qqinxP0USl68fRtjP4rRr77Z1E2iJ/fo6fTsahq x/5S5KmmuSxg9JO9v+j5Kfow4t30uo1et9Hrtn8YebxI0512XpTpw9GLGCto+/cRIz6WRU+hA+qp rU3mdZSa2vTXHXvp+c7YX4wOwu4SWn7ErGVTF+zH/s/w0safRRAvMzh4agVz7eXdw3hrBd5awXg+ 46nP87QNzGI22m0/HlyBB1cwk9l4cQU7wmFHOMxoNuP7jF3hMMYSxljCGEuY1Ww02H402H701v6/ ixwOs5zNLGf/LXJ05xm91ArG/hnjLmGWs2PRoxNeL8TrhbFPI2qIIvVqB1Yfw/OFWHwMi73PcI7h 7UK8XYiVx7DwGF4uxMuFeLkQLxfi5UK8XIiHC+npGB4uxLuFeLcQ7xbi3UJ2VQ1R9wzZj9XDCqtR nwmdLHgGpVQvJGpkF2cnODsiunPmUsPUoU9c9IlLpqwlU9aSKWubPiMMo1mOo+PryHhhMl2YTFdL pqtFr9eR7cJo9Dp0hYsmryO71ZLdaslutejuOnR3HZmtlsxWi+5wyWxhtIdLpqkl09SSXWpFPLm8 HkuWk7tdcran6w7Tq8sMrmYGV8eiSjzZvlomEEkuUBFGUEGriLxEtCDCUPOIgfTjCIPnHOI53meu dd4IGHEg9glC2GuPJxLYT5eoOq57n8rSgvsOiraceaOvZvTVjL46NvIxaIVxKv9nI69m5NWxUedw zIV9UAhFwOgYWTUjq2Zk1aIbve3BvzX49wD+PfDzypy+I/RSjm9r6KGcHsr/Vo1vjn3iV45va/Dt AXxb84sK/QDnTuxTwFiljm8P0Hs5vj3w82pdaIy8RvSSzXiVoFaillzUkotacrHpQ2z6EG/VoJgq UEzep2vH8FMlyshlBhqZgfXMwHrqyNbUkd5fR3qqpwLVU4FdH6JuKlA3FaibCtRNBWqmAjVTgT0f omQqUDEuNn2IoqhAUVSgKCpQExXCwpr36fkUPdbR4yl6q6e3b+ntW9GTd3/Ab0ewsQAbC2h5uukz 7P83Q5eg7K5gXV+DH9aoI/jwDD4887dZ2sy1LM63cNyG0trF8eezdoBzB36avWLalNL+oCr4xSwm 4rVSvFaK10rxVCmeKsXu75s+kyrFI6V4pBRvlOKNUrxRijdK8UYp3ijFE6V4ohQvlOKFUrxQihdK RUfGWcwYixljMWOsYoxBxpjHGPMYYx5K1Vt1eYwnD1UZRlWGGUsxytJbgXmMJY+x5KEkw4wjj3Hk MY5ixlDMGPIYQx5jyIv9L8qecrzoKTLERPWauA/uh0fUKjFbLRJpMAfSYS6UqQxxCMrhJG3q1UJx BhqgEc6qhdq5KkfrB/3hPDgfLoAL4SIYAANhEFwMg+ESuBQug1/B5TAEroArYShcBUlwNVwD18J1 kAy/huvhBrgRboLfwM0wDIbDCLgFJot22ufqM+0L9ZH2JeyAv8JO2KU+0XbD1/ANfKs+MVaqRcYq eBOyOd8De4GxGlFQaqGvpXrN11pl+FDZPlS2D5XtawftoQOUqkW+CG2OwXG1yOwHl0KKes1MhQfh IZihVpkzAb+bC1SOmaM+Mal4rD7qE6svnKs+svrBILiY8ythjMqwxsI4tdBaCmuglPMf4CAwZ1aF WmWFoYr3qjk/rRbG6SonToIBPjABpRiHUoyLBxv8EIBm0BxaQEtoBa2hDVyuPokbAuN5fT/H+Rzf 4ZipPoqrUTnxPCu+Dfr4btFa7RFtgOgn2kIitIO+cC70g/5wHtwMw2A4jIBb4LcwEn4Ht8LtcCdM VMtZuctZuctZuXPFdLVCzICZ8Cg8BrNVJqs5k9WcyWrOZDVnGs+pPcbz8AK8CC/BAlgIi+BleAUW w6uwBFZy3yp4U2Uy68t9B9QeXxEUw/dQyvXDHI9AhPePwXGunVV7TBMsiAcb2kMH6A19AD+Y+IHV kWkO5ngpxys43gB3wzgYD/dAilrOylnOylnOylnOypnLyplrMl6T8bKCMuMe8nwjFqkc8TK8Aovh VVgCa+EdyIR3YR18A9/Cd5ANe2Av5EAu7IM8CEI+OFCmNhMTNhMTNhMTvhanoBpq4DTUQr3aSJzY SJzYSJzYSJzYaBxVOUYFhKESIkB1YrhQBcfhBJwEKhajGrz7oqDURvbbZotYYLH3Lfa6xV632OfW CPW1dRvHUTCGNmNhnNpoPcD5dJgBj8JjMAeehmeA/WbhIwsfWfjIwkfsp43WWxzXcNzIcRvgBws/ WPjBwg/stc3stc3stc3stc3sta/Za19blRCBKu6t5jr+YN9t1C4UhmglfGB6vy/k/fQGxIP37d1+ CMR+S72VaA5DRKK4AiaqNNZ4Gms8jTU+gzU+hTU+hTU+hTU+hTU+RcziCbNVKus8lXWeyjpPZZ2n iidEC/EkPAVPwzPwJ3gWnoPn4QXYIrqIrVCmZjOjs5nR2czoYmY0kxnNZEYzmdFMZjRTeN8gXa/S mdV0ZjWdWU1nVtO111W+tgyWwxuwElbBm/AWrIY18DashXcgE96FdbAe/gzvwQbYCJvgfdgMWfCB ytcHiBb6QJGoD+aYBDeqNP0m9Yh+M4zkfLJ6XJ+iUvQHIEWloNlulmPVdHTbzXI8x+nqGzlD5coc 4ZO5IkHmoXrzqcr3C1uWqUx5CC1SLs6Vhzke8b4biGOlaG1MF62MGTATHoXHYBbMhjSYA+kwF+bB SpVKvEglXqQa+0QLIw+CkA/74QA4UAAhKIQiKAb8yWpPZ7WnE2vSfK1UPqt+NjEm1VcpbOJLGvEl jfiS6msQrUwJrC2zNbSBntBPpZr9OQ6Ei0UiMSXVvIzXKSqN+JFG/EgjfqQRP2YQP2YQP6YQP6aY rCVzNrCWzNdUvvl67H/Q51vnQBfoCt1gIIxQmey02ey02ey0dGuaaGE9DPPhcVgES7m+kuObogu7 Kd1az+tS2v8AB4E1x85ZzM5ZzM7JZOdkWsdEvOVCFe2reZ/1xw5Kt2pFi7gElR/XFhKhHbSHDtAR OkFnwNY4bI3D1jhsjesOPaAn9ILeMIFnTYT7IJ3zuTBP5cdrKt8erR6xx0C6SrHnAfvGZt/Y7Bub fWOzb2z2jf0ivAQLYCEwXvtleAUWw6uwBJZCBrwGr8MyWA4r4A3AP/YqeBPegtWwRrTwp8EcSIe5 MA/wrR/f+v8I7G8/+9vP/vazv/3Y6cdOP3b6sdOPnX7s9GOnHzv92OnHTj82+rHRj41+bPRjox8b /djox8bAeaJF83iwwU980OVedkoZ0ch75X33SDv9UaJZIPbrAiZYEOf90gjY3u8/Nf3ySDNoDq1V CAUQQgGEUAAhFEAIBRBCAYRQACEUQAgFEEIBhIh8bYh8bVACYZRAGCUQRgmEUQJhlEAYJRBGCYRR AmGUQBglECZKTiJKTiJKThJ/UK6YDFPgAUiBVHgQHoKpMA0ehkfUZCLqVCLqVCLqVCLqVCLqVKJp MtE0mWiaTDRNJpomE01toqlNNLWJpjbR1Caa2kRTm2hqE01toqlN3i0i7xaRd4vIu0Xk3SLybhF5 t0h4n3dkwruwDraIDkTeDuRfl/zrkn9d8q9L/nXJvy751yX/uuRfl/zrkn9d8q9L/nWJ1tOI1tOI 1tPEEWrZo1ABYaiECBwDF6rgOJyAk2opkX0tkX0tkX0tkX0tkX0tUX0WUX0WUX0WUX0WUX0Wmt5B 0ztoegdN76DpHTS9g6Z30PQOmt5B0ztoegdN76DpHTS9g6Z30PQOmt5B0ztoegdN76DpHTS9g6Z3 0PQOmt5B0ztoegdN76DpHTS9g6Z30PQOmt5B0ztoegdN76DpHTS9g6Z30PSO9luRqI2E38GtcBu8 roJkoiCZKEgmCpKJgmSiIJkoSCYKkomCZKIgmShIJgqSiYJkoiCZKEgmCpKJgmSiIJkoSCYKkomC ZKIgmShIJgqSiYJkoiC1RBa1xHZqie3UEtupJbZTS2ynlsiilsiilsiilsiilsjSvhO2lg17YK+w yWIBsliALBbQh3j/R5XjdRxvVPPIZiPIZiNi2WysiugTYTLZ7WdZTU9VETLbUDLbFDLbUDLbFGrx BfIR9Z7cpr6Un4rm8guy317q+Vzq9DzRjiwXJstJeYD6/sdM5yPT9Yp9x2SY65VknukiQJYLkOUC ZLkAWS5AlguQ5QJkuQBZLkCWC5DlAmS5AEo6jJIOo6TDKOkwSjqMkg6jpMMo6TBKOoySDqOkwyjp MEo6bCxVrpEBr8HrsAyWwwp4A1aqZDJnMpkzmbori7ori7oriyxqk0VtsqhNFrXJojZZ1CaL2mRR myxqk0VtsqhNFrXRmS4600VnuuhMF53pojNddKaLznTRmS4600VnuuhMF53pGjUqYpyGWqiDejgD DdAI7Aky8ywy8ywy8yQyc5DMPI36z6H+c6j/HOo/h/rPof5zqBJCVAkhqoQwVUKIDJ7sO6RcKoUQ lUKITD6JTD7Jh00+bCKjJ5PRA1QNIV+Uc6VcU4AGOkgRINMHqChCVBQhKooQFUWIzB8g8weoLEJU FiGzM23PgZ5c6815HyDWUmWEUAbJKIOAOYD3WYOogzZUHSEUQjIKIUDlEaLyCFF5hKg8QlQeISqP EMphEsphEsphEsphkkkcNYmjJnHUfASmwww1GTUxGTUxFTUxFRWRTD3roCSCKImg+UbsG5kSzU3w QexbmRLNnRxzVBYqI2gyl9S9jlkrElEcQRRHEMURRHEEqYWzqIWzqIW3UwtvR4EEqYe3Uw9nWVcI m5o4i7rApS5wqQtc6gKXuqAIlbKWusClLnBRK9NQK9Osu1TEuhvGqVnUB66Vwmv2lPUgPARTYRrP fBgYF7VDEbWDS+3gUju4KBwbhWNTQ7jUEK71HO2fj32roIvqsaknXOoJl3rCpZ5wUUGzUEE2KqgD dYWLEpqFErKpLVxqC5fawqW2cKktXGoLF4U0DYU0DYU0DYU0zTrEs8vhMBDrLWI9qmkpqmkpqmkt qmktamkWamkaamktamkWasmm1neo9R1qfYda36HWd6j1HWp9h1rfodZ3qPUdan2HWt+h1neo9R1q fYda36HWd6j1HVRXENUVRHUFUV1BVFcQ1RVEdQVRXUFUVxDVFUR1BVFdQVRXENUVRHUFUV1BVFcQ 1RWMG4RNF8PlKituCIzn2RM4nwj3wf1cm8TxDzAZpsBDKoxCC6LQgii0YNx87lnA9Xdom6m2x73L 63VQo5x4IRJRcMF4xhbfRmXFtxW2fasqs2+D22G0GoGyG2HfxevHVMSeBWnwk9J7nNdPwTMigOIL oPgCKL4Aii+A4gug+AIovgCKL4DiC6D4Aii+AIovgOILoPgCKL4Aii+A4gug+AIovgCKL4DiC6D4 Aii+AIovgOILoPgCKL4Aii+A4gv8Hyq+wC8UX1vxkrpSGyeGa/eIW7V7xWPa78WvtQniSm2iuEO/ UYzWJ4vb5Sh1rRytrpFb1Vr5qRouD6qv0YYJkggnD6tF8qjaJStEJxmm3qpUp0VX8VJ0h1iv9om/ qn08/aqmb4O9lKefx9PP4+lXa5PVaXJrOb1QzVGVjVJD6GUovcyQ29U2+Ql8Go3Iz9VfyHEH5Jdq p9yhXqL3J+m5TparI/Q+hN4X0Luk9zfofYeIk3vUGpmDTVTycp+aIPPUFhnkrv2qkKxYjE5dr77C tq9oeSe5cw+tl9I6Te6LRmn9Jq1vIo/+hTse5Y7XY9/teBHWppPNzyF736QPJ5NPVpP1B4XU16GT d6jf67tUhl4iLtFryMgJooW8SL0tt4sAWfoiRvA+Pe2iHpVyH7VmvvqALO3j6VFGFCRTpzVlatlU k0pGdkRWMKow1yvVMe0OYagtwgcmWBAH8WCDHwLQDJpDC7VNtIQhqlBcAU+oTeJJeAqehmfgT/As PAfPwwvwEj7conLFVpWr6apQk2CAD0ywIA7iwQY/NIOW0ApaQxtIgLaQCO2gPXSALtAVukF36AE9 oRf0hj7QF36rirWR8Du4FW6DdJgL82A+PA5/hCfgSXgKnoZn4E+wUBVoi+BleAUWw6uwBJaqAn2A 2qQPhiQYqT7Wn1Uh/TkVYpWPYlYirLNG1tgmZiLCGruFNdYoT0ePylp2RJ2yZH20Vp6JFsoGZcrG 6BF5ViXJKNeV6mD4okcNU11rWMoy4qK1Rny00LCVafijR4yASjKacb057aarLcYMmAmPwmMwC2ZD GsyBdJgL8+AtVWishjXwNqyFdyAT3oV1sB7+DO/BBtgIm+B92AxZ8AH8BT5WxcYW2ArbYDt8Ap/C Z/A5fAFfwg74K+xTm4w8CEI+7IcD4EABhKAQiqBYbfI1qC2mBNav6VPbzNYc20BP6A8D4WJVaF7G 8QVVbC6BDM4Zp/k2rxmPyXhMxmMyHnMj1zbBZsiCj2AL17fCNtgO2G5iu/kNr7+F73idDXtgL+yH A6rADPHeEaiEE3ASTkE11ECtKraaQwtoCa2gvSqwOkBH6ASdYbAqtC6DaWqT9TDMh8dhEayEN1Wu tZ5jrdoU11cVx52nCuMu5DiA4wi4hdd3qoK4Cbw/Ee6DZ7mewfXX4HVYBuuhQRXEC1Uc34oj+yue fRXfETqrQnuCCtlTIAUehKkwHdjvNvvdZr/b7Heb/W6z3+0X4SVYAAsBe+2X4RVYDK/CElgKGfAa vA7LYDmsgDeAMdqr4E14C1bDGrXJ/xsV8t8Mw2A4jIBb4LcwEtLUx/45kA5zYR7Mh8fhj/AEPAlP wdPwDPwJnoXn4Hl4AV6El2ABLISX4RVYDK/CElgKGfCa+jhwntrUPF593NwGv/pYGOSKTUT+sMwX FxKXG8WrYrZaJtJgDqTDXKhXIernEPVziPo5RP0con52qZ9d6meX+tmlfnapn13qZ5f62aV+dqmf Xepnl/rZpX52qZ9d6meX+tmlfnapn13qZ5f62aV+dqmfXepnl/rZpX52qZ9d6meX+tmlfnapn13q Z5f62aV+dqmfXepnl/rZpX52qZ9d6meX+tn1voVL+wo7d6kINWuEmjVCzRqhZo1Qh2ZQh2ZQd+ZR d+ZRd+bpa9TR2N9H/vhXRz/oteoHsplDFlsm94qu5MtSMtgL1HDLqOGWUcMto4aLUMNFqOG8+ilE /RSifgpRM7nUTC41k0vN5FIzudRMLjXSMuqgZdQpy6hJllFDLKOGcKkRItQGLnVAhDogYvVXIeu8 2PdxRtD+npYPobNDaOsQWjiEBg6hf130r4v+ddG/LvrXRf+66F8X/euif130r4v+ddG/LvrXRf+6 6F8X/euif130r4tejaBXI+hVF40aiZvBs+fz+h3vW9OUi9500ZuR+AT202iVgcbMQFPmoSnzAunq aGAuzFNHmyWoH5q1hUToCt3gca6vVj8InazyZ/I6Ok5uFZfLbeJu+ZkYLD8X7fHvR/JLlNQO0Vfu ESPw9Qjqeh+K4Spq+9YyKAbh9+9RDl3QOQe5Wib6oxdGoBf6yKPiep77ZdNn2efR0xdqPe1fifW5 ifemoCq2ieZc+5qzvd73Uv7/36WrTRZJ//j7dLFnILvjSnodRj68CRt+vDKQbFnL1WvJltvIluHY dxRXer9GydXOnF0V+0yxHW17Y4P3WwSHxQW0uJCzvSKJESbwXhfG6n3r22iVLaeLIdj/pTEUvaZz ZTdn39Ka3IQmrOKsmLMU0YyzM5ztFn2FIZKED0ywIA7iwQY/BKAZNKfHUaKtHIPGGwcpjGkbOvBz dOYXKteYLpKMGTATHoXHYBbMhjSYA+kwF+aJJGr5JGr2JGr2JGr0JGr0JGryJOrvJGrvJOrtpNjv XzRD3VbTUzGjOCw/Yya9XzP5Qn2Iuq1k7NPxyVbs+oRWjJaxNxOttRzRU8sVA/DMOPxwnRxDq7Fi rBwX+465sTJFfeF9K5GcqQ7KJeJSuVRcRj8uM90bJbPBuFwMMoaIAXhrrOjCHV3oZzCzOV10o6dj Xv+xnpo1/a7JLnkXd99N+3s43stxOissRxWgkSPo4/rY+tkv4rhLCtP7JRRaJ9IykZbxtHRpUSUS RRlRFA0lytFND9OTN6czVR66O8KstyDi5saeF2QG87mLZ3qK2NdaNVLDN1LDN1IjN1IjN1IjN1Ij N1L7NtLnKHXU+x9PPLE/O8WKPS1fVYt2v+jzLmLWPZDK2KajxPeqE1hXxThcVlxb+q7hrp3066ff un/ar59+D3q/zcLTWtOvjyfW8MQIT6zmifE87UTTKBrZZ6O46n1f4F0o+XvgYd6ZLjpwZzwWm9x5 mjsbubMZtkQ9r3FnA7uiTNwgDkE51LOyz0ADNMJZosMoKpfRaoC8i2hxtxgv7+F4L8dUap+HsWem Wi3nsC6WiF+xHq7E4zn0OCQ2N/vUilhvQbWfPZdAlXOmaY0MMni2EQUl+vpaixusMTAWxom+1lJY A6Wc/wAHATutKq5VczyNbd73P1ZhWT1jrsey/oy7Hsv6M+6OjNuLGHGM12asR+QB0TK26rZzx5fc cYg7OnLHIe7oyB2/onVLbD4cW3n7VAN213HnodhdwdjvEoyhv7Gs5HEcx3OcQVQ8KHoQ8aqIMTaR sQORsRXxbnvsF3W8+QvRSnKlinkYxavRsb3hfRteonyEVfUo+e4wdh+lxwrlxtZbKfcd4j6bp8fx ZJ13QqKDmKhOiPvgfniE2R/FfI7BrnEwg5XptS5jlRzG00ewqYL6MsxTKsmTQ0U7X0t1wheBY+qE mQKp8CA8BDNgJs9t3vSbQA5PDvHkkHyEUc0g5h9kHstYRYfYQbHREoeP4qMK9V2sFm+HfQ3Y14B9 DU2j9z5TLuEpJTxF5yn9sbElT6nlKVGe4n3TfBxP+MH7PSLsa8C+BuxrwL4G7GvAvgbsaxAXiIli mLgP7ofZIlmkwRxIh7kimR5b0OP5xCwfHh5JzPLh5ZHErHfw9GY8/QnrdBfr9CbW6TC5Ti1iTN+S Ifr8aA15y7PmKGricjGENTrEGKocY6VINlbBmyLZ11IM85VyjHA8BsdFstkPLoUUMcxMhQfhIfDs i8Oq003rRm9aN3psrjwPVqgjsU8jNmD32qZWiU2tErHbpeWg2CcQFSqPlZES3UEteIzar5Ra7xi1 XalxbrSctZYSdblaxZUq41x1FU9NiZbI0/i5gbsbiQ1n1R7Dp2qpC+sMv6qm5R5aXh+79wvezeVK Llfs2L2uPEN/DXjlrMqnxowa8cLk3iit8qklo7RMIi6lRA/TS5QqtRrLIrKeYwO9NrIyf7yzkV6j VKfVWBwx4jjaWOHn+o9PamQENay6FOraWqHxlCqeEuUpiiccjfVtCo27q7g7yt2KO4822dDP81N0 ITYc5O6e3F3I3aflGXasZ30j6/gsKy6KTlDqLLYc5Gk9eVohTzttxKtgbFR+5jkgWlIph3nyWWx6 z8uiSueJddhRLKNC5646+i42mvH6XNXdaxHdS4sj9Od5KkSLIzzT81KIZxzHu383X8x+0zxx9z+Z n1jb2LzQ9p/MB2P8X84D8fRf9D9R5j/sd8b43/g79s4/9LNobiSIeKMt9rUXttGRp3Xins5ohnN4 3YX3uvJeD97rxXlv3uvDe33JB4aRSA+deLcbx97MScBI4IwawmhH/x3poRM9ec/qwvWuXO/O9V5c 7811nsMseK29njs1tfB68p7VGrt03i03ErnSDtqLLtjXmpblPLML9unYp3NXudGN97tDD673ok1v rvXhdV/vV8l5SjG2eiPUjQ7Y2lH4mp7i3V2M/d4IdaMn7/XivR/v1hlvArRl7SVic3ue25GxdGL2 O9PXOd64eL8r73fj/R6834trvXm/D+/3ZXyMgrlpy3MTudoO2qv92BDFOweNzszlOYy5C2260qYb 73eHHrTpSZtetOlDm75kNm+eAjG/thcJ2OF5rA47ErDDjx2BmG97cN4r5sE6bEjABr83K0LGxt6x yc8/Wu95T8bG/eMdVU1W66LFv7sm2LUu/vu7dcFuv0g0+1fXBncNENZ/tz54t7do859aIzztfEb9 b64T7j5XtPrfrhWecrk3ov/MemEmvonN47+1ZmK5odm/um5iUf1ceTpaQSS9h4jTmag2XJ6JVhHV fi0bo2Giz0SiWjei2hDDF60got5DNOpMVBtuxEeriGq/NvzRMJFpIlGtG1FtiJEQPY1HLsAj/fBI P6M95x3U+XikOVYNxCt98EpvowvXu9KuG226Qw/Oe9KuF+16064P7fqyauKp3ALUXEnS+12fHaIN ajcBpdsLVfErtMJO1F6L2G8LbdXGiSu0e8T12r3iee33HCdQuY9Sy+Xt1CJ3qK0oj+WxX6rr9z+0 2hlr5f0G0oHY1Z/ONv3tTKeS/1T7XG2KvfJ+3e4gr1pQJV8ghBhCTdpfXMO/AeJmcasYKG4Xd3D1 TrTcleIP4gXxG/GSWCceElvFp5x9zr9F4huxX7wsHP6tFMVUJ6vEEZ74rtZJ6yT2aV20C0SeNkwb Lsq0W7TbRLk2RrtLVGrjtfHC1e7VJooqLUV7UJzSZmgZ4rT2Ov86asv510l7g3+dtXe1ddo52ufa Xq2rPkAfpF2kD9Yv0wbpQ/Qh2qX6VXqSdpl+nZ6sXa5fr1+vXaHfqN+sXakP14drV+sj9Vu1a/Tb 9dFasj5WH6vdoI/Xx2s36hP1+7Sb9En6JO1mfbL+oDZMf1ifqf1Of0x/RrtDf1Z/UZukL9CXaCl6 hv6aNl1fo7+vzdSz9J3ak/oufb+2VHf0Mu0dvUKv1LL0Kv249qF+Uq/VPtbr9QbtU11JoX0hdSm1 HdKSzbSdsoVsrX0nE2SCliMTZUctV3aXPbT9spfsrTmyr+ynheT58gKtWF4kL9K+lwPlIK1UDpaX agflEHmFVi6Hyqu0I/JqebVWIa+V12phmSyTtUo5XN6iReRtcrRWJcfICVq1TJGpWlQ+LB/VhZwj 5+imnCvn6pZcIpfqcXKD3KDb8gP5ge6XH8mP9IDcInfozeQeeUBvLw/KSr2HPC2Vfr7hM5rrlxoJ xrn61cZQY6g+yphuPKPfbjxn/EWfYnxsfKovMbKNvfoKY59Rrq8yjhpK/8Bn+2z9O1/AF9CzfS19 rfU9vjxfgZ7rK/KV6o6vzFemF/sO+w7rJb6jvgr9e1+l77j+g++k76R+xFfjq9WP+up99Xqlr8HX oEd8Z02ffsy0zOb6abOl2VKPmq3Ntroy25tdpDS7mxdL27zEvESeY15m3iC7mLeYo+RF5t3mH+Wl 5pPm0/Iu81nzeTneXGAukL83F5kvywnmq+ar8j5zqblc3m+uMlfJFHO1uVqmmm+bb8sHzfVmlnzI /NDcLh8zPzO/lPPMr8xd8gnzazNfPmUeMB35shkyQ3KxWWJ+L181j5hhudQ8YTbKZZawdPmOZVnd 5DqrjzVY/tW63Boq86yrraulY11n3SALrN9YI2SJNdIaKcus26zb5CHrdut2WW6NscbLw9YEa6KM WJOtydK1HrAek1XWbGuuPGvNtx43dOtp67+o+w74Kor17Xdnd2fmnDObhCRACh0EFERqQIoUAQsq WLGhWLFXbAiieFVUFAQv4BVBBSsKVlCwXsHeEbDQEQFBRLqAzPfMe05iYgKhXf1/e377ZnZ22tkz 88zzzu4+uSsI1D3q3kCqoWp0oNV/1H+CTDVGjQmy1Fg1LshWE9SEoJKaqKYHldV76qOgvvpKzQkO UT+odUELtUFtDY5V25UNTtJ1dd3gVF1fHxScphvpQ4IzdXPdPDhLH6pbB2frtrpdcI7uoDsE5+kj 9dHB+foYfUzQRx+nuwcX6RP1ycEl+jR9WnC5Pk/3Ca7QV+qrg2t1P90vuF4P0AOCG/StelBwo75L 3x3crO/VQ4Jb9FA9NLhVD9fDg9v0SP1wMEg/pZ8OBuuJemJwj56kJwX36nV6fTBEb9Qbg/v1Fr0l GBoD8AXDYkEsCIbHVCwejIiZWOVgVCw3lhuMj+XHqgUTYjViNYKn4yfGTw+eifeO9w5ejJ8fPz94 KX5R/OLg5fil8UuDV+OXx68IpsSvil8VvBa/Pn598Hq8X7xfMC3ePz4wmB6/K/5c8Hb8nfiHwbL4 7Pi8YE18QXxZsCn+eyIv2JGonRgW1kgMTzwW3p+YkngrHJv4IrEufMookxN+YhqYLuF8c6q5KNxi LjVXyZi5xvSV6eZ6c6PMNP1MP1nR9Dd3yEpmsLlf1jDDzDBZzww3D8r6ZqR5VDYwj5vHZYGZYJ6T Lc1k84rsYKaa6bKredO8KbuZt83b8hjzrvlQHms+NV/Lk8035ht5ppljvpW9zPdmoextFpu18kKz 3myR15utZrvsb3ZEJAdGIhJyUBREUt4e6SiSd0YZUSU5JMqJcuSIKC+qIh+MqkV15KioblRXjo0G RgPluOi26A75aDQ4uk8+ET0QjZATo39HI+Wk6KHoIflC9HD0sHwxeiR6TL4UjY+eklPTRFqafCMt M62y/CgtP62q/CJtc9pW+TWJOPg7kelUoQfVpxq0nzY7zS61P1FjuwLhH8pMscM+bCfj86u9B0c9 7BnIMxOhFanzK+zPsItTR5tK5Xdnf7Yb8PnznCqjnvXYHyy3vTdjf7NEzALUUMnVstMNnhfSfWe3 IWwwk59JEY6Xlmxj4bcpo85P7SK7xn6GEpbg2y4vr427sWmUOjJV+o92tZ1pl6WO1pWqfRX2+Xah nWW32KMphmt3ENUsdn5HeZXZjfjtNqCEP1uO6w/Gkjz7hH2CDPai3/AvuX/Bvsx+jzIW4DAEz6pL hyFUnc/OsJ/bOeg/6Dvw28uu/1n7uB2Lv4Oxt7eN7HW2L0LFrmPht0dodancO+z7djl60Pv2E7QD v4O7eiVzFaX9tJxLQfBTidI4dH8qZg3K/qywbxbvFamYDfjm63Dtf7DrwffTEdUcv0JR7XYV/0Kr ClOXyr/arsQYW1N4xd3KKP+dVzxNee1Opfu+xNHVJY4+3L0ysDXh9KmeZufi99N2bjk1by42tptQ q3JSP2efdiPavr/bbSqZ/yfXO1yfLXVm9m7kxjezd3Joyl/Hsz13N/Kjj9hXGLcWuN9tTzf7DKPp M7iupTe9WyX8aqcxau5mvyijhHW736vKyJ1CWPv1XuV+ge1chxz7fWu2G/X/lJzL7Db0o/V7XIPZ 5dl62E/gWgpnvMXJT+p89TLyHIhPdXwOLNHKJ1N/v0h+dpG/SZn5U1cXvWQj0GnjzhoM/PzF/gYE W8RjyvXqLRw/gk9Xs+/Yt+w3bkbfSf7txcL3Ui7wvyd1dyMkFTcfc8P00lhclGdbsfAwzDzpdBT1 RnhSKm4prt5XO59VC+vnHv0Q8seAPtekkNzFv2Qnk2+n7jT/X3thCPbUB/H3pc5/aD/A9f84dVQa v7cWC9+D3Ll0LDkm1D4V96Z9HSU8v9P6fyw7fgd+MYeP9nh7nD3fdk+lHlcq/yCg2BP2eful/aZY tKBedDsNQeh+GuremaHn0HMn0VSww+n0FjXlVYUCeo/mUEv6jpZRN1rueXSq19vrTdfCoz+B+jpf nq53XjzdIC4Rl9NN8Me/pQHiB7GUbhErxAq6S/wsVtFg55vTPWKT2ExDxDaxje53vjkNdb45PQDf PEEj/Op+dRrtn+n3oof83v459HAwJZhCzqu1NDbMDDPpU/mqfJU+k2/Kt+hz+YOcR19KKy197Xw6 muV8OvpW9VDH03zn09FC+HQ9aZHz6WiJ8+lohfPp6Gfn09Eq59PR786nox3w6e71CN7cA55UI9Ro L+Z8Oi/d+XRehvPpvApqvJrgZTmfzqvofDqvLny6dd7B8Oas1137OvTO0FrHvbO00WneObqCzvLO 1xV1Za+PztNVvEt0NV3Du1zX1gd4V+nDdHvvWnhtF3jXwTsb7N0I7+xer5/zv7ybnU/k9Xc+kTcg cXNimHeb83S8USbD5HjTzXPmOW+GWWrWejOdr+HNcr6G953zNbx5ztfwFjpfw1vkfA1vqfM1vJXO 1/DWOl/D+835Gt4G52t425wf4W13foT3h/MjhEiLpSWESquYVlnE07akbRXunsJc7jEe9xiBHjMS HsUo+g/69MM0ATFP4KPoSXoWs9RE9CfJ/UmiP72BUfcmelWce1UcveojxH9M31CCZuMj0MvmgFV/ R/PArubTEoyxpehzNWk5/YYRvw6fWrSeNlNt2oJPHfqd/qADaAd6ZAXukVW5R/rcIw33SIMeeRll iMvRLw33y0z0y/lUSSwQCyhLLBSLqbJYIpZQjliK/lqF+2s+99cc7q8Vub/mcX/NElZYyvJB/ykb vVbAYqOK6LsKYfz4lOvH0I+zuR/nox+fSXX9XujN9dCbeyN8Dvp0Pe7TVdGn55MXLAiWkQh+CpaT DFYEaygR/BpsoGrBxmATpQebg+1UPfgDvf8A7v01ufdX5d5flXt/Ve79VdH7D6ds1Vl1poTqorpQ oLpiPIQYD0cjppvqhphj1DGk1LHqWNLqOIyT2hgnPZD3eIyWGI+WhFsBoUj1xJhJw5g5g2qqM1Uv SldnqbPoAHU2RlEFHkUVeBR5GEWXItdl6iqkuVpdg5hr1bUkVF91HWq5Xl2Pkm/ASEtgpN2MXP1V f8QPUAOQ/haMvYjHnufWU5BmsLob9d6j7sXZoWooYoapYcj1gHoAaUaokYgZpUahJaPVaMRgfFLc jU+UM1aNRa5xahzix6vxKGeCmoCUE9VExDynJiHvZDUZ1+EF9QquzKvqdbRzmpqGazJdTUer3lMz 0dr31Uco8yuFnqlmK/RJNVd9j9J+UAuphlqkluKa/KhWoK6V6meqpVap1biSv6g1VEf9qn5FjWvV OrR5g9qAlBvVRpzdpDYhfrPajJZsUb+j/K1qK0reprah5O1qO2WpP9QfqH2H2oG8Vln3/1V1SFUd msACTWCBJrBAE1igCSzQBBZoAgs0gQWakAc0uQt2sB5MwmEKBQ5TyHOYQgaY0h92QHwgZThkIR/I ModMYm7iW4oS3yXWUYZDGfIdylAuUGYpZZkfzY+UbZaZZRSZn8xPVMksN8txdoVZQTlmpVlJVczP 5heE15g1SP+r+RVp1pq1SLPerEd4g9lIeWaT2YQ0m80WpNlqtuLsNrOdEmaHsZQTOdc6y+EXbBAF sGEkKRMopqlyFIviVDFKRAmkNFFEVYBrWYjJjipRnkM3qgR0y4PNj6ogTbWoOmVHNaIaKKdmVAvh 2lFtpK8T1UEY2Id4YB9iHonGopZx0aPI9Vj0GEoeH01AmU9ET1FFh4bkOzSkDIeGlAHEejGFhsPw 8RkNQ6DhaIQfBg76jIMSKPgcwpPoNdjXCb0NaPgOwv8FBvo0EzjoAwdnAzHnAF99Xr/XjIM+42BF xsFKjINxxsHKjIM5jIO5jIN5jIPGS/fSKfJO906Hvcy7HPZK7xrYvl5f2Hu8eygCSh5PglEyBpQ8 H9ahZIJRMsYomcaYmC1Wi9VUgXEwk3EwS/wh/qB0RsAMP/ADygT2aYTjfpwq+Kf7p1MV/wx+ks1h X1XGvur+Wf5ZiD+bn25zOFiVcbC6f65/HuUX4eBy8oGAG0gD+7ZTnFEvj1Gvklu1xfjsqDpi9HZS nchnjNPqCGBcAIzrhrBDN5/RTTK65ajuqjtiHLr56kR1IuxJ6mSkdBgXMLpVYnSLM7rlAd16k1Hn qnNhz1PnIf0F6gLYPqoPrEM6zUgXTyFdX9UXMdcB6SRjnFY3qZuQt5/qh/SFSDcQ4STGDVK3I+yQ TjPS+Yx0cTVEDUGu+9T9iHGopxn1TAr1hqvhiHfYpxn78hj1fEa9QD0C1PNTqPeoehThx9RjQLTH 1eNI73DQZxzMK4aDPuOgBg5OQziJfW+odxF+T30J67BPA/u+R9ihXkVGvUqMenFGvcqMejmMermM enmMekatV+uRy2FfJca+HMa+vBT2bQfG+YxxRnvaIz+JVvEb4zdRLH5z/GbYAfEBlIgPBDYl4rfF b0PMHfE7KMY4JRLDEw+RYMTJNr8AazLMb2YdZTK+ZDCyZANZNiO8xfxO6cCUHRjnDlMqRH7kUzrQ RFEa40gm40g2ECQTYYcgWVHlqDLSOOzIjqpGVRFfPYUdNVGCw45Mxo4Mxo4KjB2ZwI5HUOa4aBxy jY/GI/0EoEYmo4Yg0XStW3lt+dPhBXQ0nboznv//x2ZX2JVuTx0tKsvvcus8vNa3p2X/6Fa42PN+ h49/KKyT7Zcp73O18z/ZF/3eLrHLS67olF9v4QqdvWrPW7h/N9sNnqf7u1Pfu1SOFfC0P9j7dZmi clb/9cj+xjYVD19xA67sErsGe9HKXjFPNLtY7u+R6lty6x6VEUqtMBZ613/TFi9qTfF6DZ3GcavK Wl2wP5dem7Pr7GL7Hc6Uuguxt1vhKnnJIzd+Ur262HoB2u4XhVfv7Fe2C0uvau6vrew7OOXmmmAf 47/beTX8Q7e79SH7DEIfpdIU9iw3gjfaLwrj96ieH7mPLvnz2K2C2fnFUtzH60FurXwhh35Ea4oj VOr67u7vy6vWS8pPt+cbelqxcu0mux37VrfWZf8okW5X96X+j21/85jfjc2O2YfMPcoobwnVRx+s tg+l7nqrT4ytDk8ZU8vcgA27fQ9x3+eKv5RXolXFx95u5n/JvmVfSN0fyLbj7Fscu9TN7sVn773i D98CGxcxf1jO3ITRzM1JdhH+TkylWsP32z7GPhOf5SVXrhnJcqlwbXYG5oKP7FfYxyD2aDvLfsLx 3yRZBN/RPm3PW1qq5StLHPEcal8sFnOJHW8vt3e7VX57TVFsG8S95sZd6buO5O65lr4X+rN9B9/l +/03Ugv7g5vHgGCFvPAjSt2fLd4G4HLRvRF3j6Wckj/bX23c2w1XKeK/D7j7zaXO9rUzSqRN/p2P 2W2p6yF7Ud9s1+uZb/F1ciHMb4tSVw3WXmw/5997M/llzGERNS5V5hqMg19Sd5d8IEfhXafNybP7 Pr/9eR+65P3KQpbiuBfP2z/is6YU91zI3LOM0Y7RvJ+xq6ztL3g2q9T57X+NScVfXXY87cl99D3e 7IV7mCH5jMVgewf//ZUR4GW3I/S0nZIM8blCfsb3O/FLvb4XrXvJvgbEfDV1NMM+S+75oKkujB3I CRSbAZQoZMG/An0/SeFE8v5ZWqkyP7Cv2rdTZWa7o1R8CXSwds9by/kwSu13RUeFvstiFyr0K5NM nBHtI9c/ks+IpMbPOkbkXrYHH71N7m7eVdhvQGiYHY257oZUKcWebcEVmG777UVrz7ED7OP2coT+ i1H9uO3D+HAfZqPHcZ3ftmPsRZhbf3X3APmbTbOT7KPJmlOzRp7971/KXG7nwKtMjtwWRaEU77S/ J/fdZ8wlyt7A473oqaCSsxTP00WeLzPfRfzcQ/EnLhqVfGLl79pK3sXlJ5h+Kb8l/I1KPX/1d2wl PVl3VdGH15eHn/zr7DdPd0+24vwDo8F5WXPxdyd3uotS/rzv7bWP2P72X3YUh79Af3/MPSmTmoeS fHGjfQX7W/tWD5fUOPkkyz6VsdT+hJmQ50f8pj+hHxZx7uSvbteCc6wtiwHucV17wbmL5f4k+aui LQ4HP0sdLUyNn1Sr/5nxXNZmL7QX2DfsFBJ8NMBeD7TunWQEdqrdgqMh9mp7qK0NHG1ub7AX70Nd Sf5YY5/am8KkpE9b9LzhYyXP7s/NTtgPZbjeOyeJ6uC3pX59Pr/Efv3nLPzPbmjNDxhzvOaJPuw8 xSJPJcl0cfYD7Dt5VvXv3tDe+4uPXPCraf9ke3a+YbT1ddwp+aSrvRbs6BuMvuS5t9n+YF+3Z9i7 ERpq5yXj9rKuD/a9vXtY44biz3n9392KOO66fX+6sqxn3ffnlmSH4N/LMOvthxWL8p5R3mXe3exR djKv7a/a+5qKbbn7pZTd2sCF9pm52gf2R0vKqSOFdGC3+7wuv59+pfJqWQpm+z8eKftvA+vZsN+u TOY+tGN/jPe/8X7E3vRG8J4lyZypNzsK10U+5/sMn+8y8xWptC/seb1/97Y370CUKmOnd0N2kYdX 691KUdITTq7oFN0Lju/KP+a13Vy6nOSe18v59+ItL7uc544/3yUrXJPbXd8uQUfsea3/6FZpbzPu +Z0nck81uPvSRZ69nc72F+BzuXcj/q9t4P0bd/7ORLF0W/73bdm9bfcQcm9n9TLflSq3Ln6C4M93 B/mORVHPipeZqTCtW6uqQmdgzP0DW0nunkQNeE/l4CzfifkH1vvsb/uxrMWUWlEu842jA/ktJ3cH /YsyzpZXtnuPanFhzsIQr/AvTsUU1tmG6/pLu4od3fVnmYVtce9rlWqVeyuribtLszdeux1jn7TT it4DS4UcI0itaX5R1I4mpdr75J7XVyL/XjwpZL/muxIfFx3zM0Dgm3K37/Ttxtt7O6m7zHeTy8nz E69auZmcsYCPZmDsJZEhvit+yTNKOh22e+9rlpF/b55/mOXet+R9U/KYbWrVfNfokPouVUo+b4T+ 9Zv9ivcxVBmcdGXqbtKi5JjmvnbJnre0nO+RvMNWzFu3ve0N9ik7lnUDip7psd3sS3tY8oy/hzG7 Nu68HrujrLvKyTuKf4n7rfy7OHu78TMyKWS268An1oEffWu//xOJ7GrEuXvGrewpfPwyesAc28vO dMf2bfugfd+tmPO5ESXKnl8Yv0ct6m4vt7fZo1NHHEIP7MPhJ+14ew36wRiwtWmYeV2KKfZV+0pq 1nar85WoMd9zvtFexnHJ5xHHglc/4n4Pp5JQ9BRQibUg+3vh2/x71N6H7DPw1f6TOvqc6x7DOP85 XwN39/UFu8G+ywmSb+2nnjBI9eIWe17rP7X9T97GLl3L4kLESt53/qe2vblPhV/6Fyq26lCkkLA7 c08Wued3TuRwFWoO37MG510G1rGMZ5N8amZnY4S6z3y7wB6K8dKHjE3O6yk/FaMz6VNVTh2/lLpT IajojWmOf24X34OfrbD9MM+lViBtR3s29m72QsqyyTm4UENjAPYuto092abebLAf2nn8tIQbsT9j Tlqc8l8bUH2eORtwql2vbpTdrsfseNhnio6nOV+uxJMVJ6UCZ9AJ1Iqask7MAXym+HeP7/jaJnZs 5pnyDXupfdnNYfYWe7sLodR7SlSbfAbs0r1o72X2Snz/K/lAI3QZ4+btPFN/hd9y+Y7km/RTWRWk cOMra69NlbEbPl6Zda8sP02pPKv5iQDHE7g3cW+egeOAT5td8h2XK53aovWCZpWjY3d6SsduEB3l Ca8inc/qdDeyOt1gVqe7xzvd60XDvIu9i+lB1qX7t3eddw+N9oZ4o2iSU6ejaU6djqY7dTp6w6nT 0Zveu94X9LZoLJrQ56K5KKAvnTodzRLtRXv6xqnT0WxxlOhGc8U14lr6XtwobqJ5YpgYQQvEBDGB loinxCRaKqaIqbRKvC5ep1/EG+ItWiNmiJn0m/hIfETrxWfic9ogvhRf0SYxS8yiLWKOmEO/+8aP aKuf4WfSdqcwR5YV5ogV5kK/jl/HU6wwp1lVLuEX+AVexKpyaawql8GqcpmsJ5fln+6f4WX7Z/ln e5Xcu3JejlN98/Kc6pvXKJgavOWd7lTfvHOd0pt3gVN68y4MM8IKXp8wO8z1LnZ6b96V4bxwsXe9 03vz+ju9N2+A03vzbnF6b96tTu/NuzPcGG7z7nIab979TuPNG+U03rxxTuPNe9RpvHkTnMabN9Fp vHlvOY03722n8eZ9KXvJO725Tt1NeE7dTQRO3U2ETt1NKKfuJrR8VI4XaU7XTWQ6XTeR5XTdRBWn 6yZqO103UU9+JL8VBzpFN3GoU3QTreVyuUq0dYpuoqNTdBPHOkU30cMpuolLnKKbuMm9Hydu0UIL MVBLrcStOqETYpBO1xnidp2ts8UdOkfnijt1VV1VDNY1dS1xt1NcE/c6xTUxxCmuiaG6iW4iHnC6 a2K4010TI5zumvi37qA7ilFOd0085HTXxBinuyYecbprYpzTXROP6wt1HzHe6a6JJ3Rf3Vc87dTX xDNOfU0869TXxER9t75bTNJD9BAxWQ/Vw8QLTn1NvOTU18TLTn1NvO7U18R0/bJ+S7yh39GzxId6 jp4r5unv9A9igZ6vl4vFeqVeL1Y7VTax2amyiS3axjzxu1NlE9udKpv4w6my+V4sN1bNj5wem58V qxWr72fHGsQa+fmxprGmfvVYi1gLv0asZayNXzPWLtbJrxvrHOvsN4x1jR3pHxw7OtbNbxw7Ntbd bxrrGTvVbxG7InaN3zJeI17Hb+vU3fyOTt3NP8qptflHO7U2/yqn1ubf5NTa/NucWpt/d+KkxHn+ RPfWnj/dqbX57xll0v1PnU6bP9ucYS7y1zqdNn+H02kLAqfTFiin0xbEnU5bkHA6bUFFp9MWVHE6 bUFVp9MW1HA6bUEDM8FMDBo6nbagudNpC1o7nbagvdNpCzo4nbago9NpC45yOm1BD6fTFhzvdNqC k8xisyQ43amsBWc6lbWgl1NZC851KmvBRU5lLbjUqawFl6eJNB1ckWbS0oLr0jLTsoMbnbJacHPa 5rTNwS3plO4FA0l4S4B6afD40imDPKqAj0+ZmIcDysHcHWJWPwDxdfFRVA+zoKaGQMkY8LANGeCh +z8Ph/F/wHCImcaImQ7EPAW5euJTAbjZCyWeRedRBzofGNoRGHoNmMO1+HSivnQjVaSb8KlE/egW 1DwQCJsDhDWU60VeGuXxG8L5XgYw92Bgbj3E1PfqU2PvQO8gxDfwGiDcEFicy1jcBFjcHbYHELkL 64Xmer2Ay00Zl5syLjcDLvdH/ADvLmruDfYGo8y7gdT5QOqhVOAN8/5NLb2RQO0mjNpNGLWbMGo3 Bmo/g/CzwO7GwO6ZmA/e996nNt4H3ifU1vsUaN6O0VwAzZvDtgCmS8b0DMZ0wZiewZiezZh+OGP6 IYzprRjTqwDTn6Hq4lnxLFUVE8XzVFNMAsrXYpSvxShfAyj/BuybwPpqjPV1GOurAus/g/0ciF8D iP8l7FfA/WqM+9UY92sD9w0d4EdA/7qM/vUZ/esB/XPoID/Xz6UGfp6fR53dTIAwZgI6EDNBPdj6 /oHIhfmAGrr5ALla+61h2/htcLad3w72MP8wpMHcAIu5ATHuXesj+F3rI/n96iP4/eoj+Z3qrpgn BtJhwa3BXeRhthhG6cEDwUg6NBgVjKas4KFgLLUOxgWPUeXg8eB5yg0mBa9SHmaUqdTUqYlSczev UFs3r5Bx8wpsRphBHcMKYQVq4mYXaorZ5Rvyw9nhbKoRzgnnUHo4N5xLQfht+B2FmHXmIWZ+OB8x C8IFpMKF4ULS4aJwEVUMF4eLKeHmJIrcnISUK8IVVCFcGa6kTMxMq8gLV4e/oMY14a+UFa4N11Jl N1ehxo3hRsoJN4WbqF24OdyMtm0Jt6A9v4e/I7w13IrwtnAbHRb+Ef6BkndIQVnSlwEdJkMZkocZ ThEmC6kpkjEZp3SZkAnypZGGcmQkI2on02Qa0mAWdP/VXWYhb7asiLw5Mhfp82Q+ZcoqsipKriar kVNArQlbS9ZCCbVlbaSvI+sg/QGyPtIfKA+kyvIgeRDiG8gGFMiGsiGlyYNlI5R/iDwEeRvLxiit iWyCNE1lU+RtJpuRcTMu6mopWyK+lWyNlG1kG5TQVnagUHaUXZCyq+xKSh4hj0Cbu8vj8b1OkCej /F6yN2o/R56LWs6TF6KcPvJS6iAvk1dSR3mV7Isar5PXUyd5gwR6yJtkP6okb5Y3o7X95S34LgPl rSjnNnkbShgkB6GE2+XtlJD/kv9CLXfIO5DmTnknagEDoHzHAKgxGMAD1FwOl8OpmeMBlAseMApn R8vRlCcfksAB+bB8mNrKMXIMrvaj8lHYx+Tj1NRpwCI9uAJKmCgnwj4n0UvlJDkJeSfLF6iLfFG+ iJJfki/j7BQ5BXmnyqmIf01OQ8rp8g2kfFu+g7Pvyv9SARjG+4j/QH5AjcAzPkL6j+XHiPlEfoKU n8ovkPJL+SXa85X8GmlmyVlo4TdyNto8R86hg+VcOZdaym/lt8gLjoJcC+QClLxQLkSu5XI5Slsh f0b6VXIV0v8mNyLNJrkJV2Oz3Iy2bZHbKdfxGGoGHhMhnKYqUHOVqbIoX2WrylSgclQVaqmqqhrU BCynHrVV9dWBdJQ6SDWgNqqhaoiYg9Uh1E41Vo1RQhPVBCmbqqZI00w1w9nmCr4juNGh1EK1Vq1R VxvVBunbqrY42061Q11OU8BznImaOs4EC84EC84EC84EC84EC84EC84EC85EeY4zUb7jTLDgTHSw 40wIgzNRW8eZKNdp1VIj3VF3RC4wJ8SAOSENmBMsmBMVOOZELcGc4AnoProPtQN/upLS9VX6aqQB i0JesCjEg0Uh5a36VpRzm74N4UF6EOLBqNAeMCqkH6qHUnM9TA9DLvAqagZeNRIxozR6nR6tH0b4 Kf0U6npaP01HOaaFGDAtijumBQumBQumBQumBbtS/0bt9Tq9DrWs1+tRDlgXNXasC2GrrfvfWzGi LjEv5lGuY2CUDwamYHVMU4sYNmoci8fiCJtYGmx6DPNvLCOWQQWxCrFMxGTFsqhtLDuWTc1iFWMV qV2sUqwy4nNjudQ8lhfLo4Nj+bF8hKvEqqCWqrGqOFstVg0x4HYIg9uhJeB2sOB2sOB2sOB2sOB2 sOB2sOB2sOB2sOB2sOB2sOB2FHfcjtqD251IGfGT4ieRjJ8cPxnhU+KnINwz3hPhU+OnU7Zjfoi5 Kz6BRPyJ+HMIg/8hDP6HNOB/SPN7wiOREIk8OtyxQGqV1G5wLJCEY4GwYIGwZ5gzqKo505xJNUwv 04sqmLPMWVTdnG3Optqmt+lNtcw55hzyzbnmAoQvNBcifR/TB2kuMhchzaXmUoQvM5dTHXOFuQJp rjRXIc015hqcvdb0pWpgljcg/kZzI+LBL2H7m/6wA8wtVMUMNLdSTXObGYSUt5vbkfJf5g7UONjc i5gh5n6UDA6KWoab4bAjzINIM9KMQptHm9Eo5yHzH4QfNg8j/RgzBuFHzCMoc6wZi7PjzDiqZx41 j9KBjrlSfTDXCdTAPGGeoM7mSfMMws+aZ5FmopmIs5PNZNgXzIvU0LxkXsLZl80rODvVvEYHmdfN NMRMN9MRA74LC74L+675Lx1g3jMzkGameZ/qmg/MB0j5ofkQtXxqvkDMl+ZrlAk2jPLnmDmwc823 SPO9+QFn55l5KGe+WYDwQrOQmoMlL0ZpS8wSque4MlUDVx5EVaLbo39RreiOCFcJvHkwNYzujnCt oiHREKoe3Rfdh5gHouHUIBoRjaDOjk8jBnyaGjo+TdmOT5NwfBoWfBoWfJqyHZ+mpmB2HZhPd2U+ LZhJJ3lzIWN2/DiN+XEanYZPGjPjI5kZH83MOJOZ8THMjCsxM67MzDiHmXFuMf2ekPV7NOv3hKzf E7J+T5z1e0LW7wlZvydi/Z6Q9XtC1u8JWb8nnfV7QtbvSWf9npD1e45i/Z5urN+Txfo9x7J+z3Gs 39Od9Xt6sH5PHph6Arw58iLm6LnUwsvz8sChHVNvBabenVozFz/RO9k7DfGOi7fxLvQuBMO+zrsO 9nqvH3hzfzDylmDkg6kduPjdCN/r3Yv0jpG3BCMfRR3AxcdQR7DwV2Bf9V6lTt4U722cdSy8J7Pw w5mFd2YW3gUsvDH5zML9YvzbB/8+nPn3UeDf3ZiFO4WhgBWGKrDCUAVWGKrICkMVmKMfzxz9UHG3 uIcOc8r+dFKKqTte3kBMFpPpQPEaeHltZuQHMCOvJz4Rn4B/Oy5eU3wtvkb8bPDvmqxaVFV8J+aD kS8UC2GdglFDVnU7SPwoliFmuVgO67TdqrGyUR3xi1iDsNM3qit+E+sQdipH9cU2sR1hp3VUXewQ lqqx4lEt3/MFwk73qK4f+iHCTv2oFqsf1fETfgIx6WD/jZj3N2Xe35x5/wl+vl8F8Y79N/Jrg/0f 4tcF+2/E7L+xf5B/EMIN/YawTfxm1AyeQEuEW/mt6GD/UPgDjdgfaOK3hT/QyG/vt0f5zh9oxJ7A yewJnMKewMnsCZzCPkBXsP+RlAbeP5YymfHnMOPPZ8bfKpgCxt8GjH8GtQtmBp9SJ+b9nYtpMoWs yZTOmkxZrMnUgz2Bo9kT6Mj6TN3YH2gNf2AWSfYBVPgdfADJPoBiHyCN2b9i9p8T/hj+CJb/U7gc MY73S2b8lZnxH82MP5MZfw4z/txwQ7gB1nH6rszpFXP6TOb0XZnTCynB6RWzecVsPpdZe1fm64qZ eiYz9Vxm512Zlyvm5TnMy7uCi8PvlY3AyCVz8Uzm4l1TLLy5bI70BbIA6R0X78osPMm5FfNsxdz6 SObWRzO3zmRufQxz60rMrSszt85hbp3L7DlXDpFDwCnvk/eBTTr23JoZc1s5Uo5EvGPMLZgxd5Rj 5VjwSMeVC+Tj4MptmSvnM1duJ5+Uz4LHTwRLzmeWfCLz43byFfkKcjmWXMAs+USw5NeQ93Vw5Xzm yq2YK7eT78kZKGGmnIn0jisXMEvOZ5bcillyO2bJneXXYMltmSV3ZJZcwCy5HbPkDsySuzBLbiHn y/k46/hxkhm3kKvlWsQ4ftyK+XFr5scnyh1yBxiqY8ZtmRm3AzOujLDjxB2YE3dUNdUB1ImZcWdm xj2ZGR/OPLgj8+CezIM7Mw/OVy1VS1jHgLswA+6s2qv2KNMpiqWzlljIWmLprCKWzipiIauIxVlF 7DhWEQtZRSxUJ6gTULvTEgtZSyydVcS6sYpYFquI9WAVsTxWEctjFbGQVcRCVhELWUUsnVXEsoqp iKWzilicVcTSWUUsj1XEQlYRS2cVsbCYiljIKmLprCIWsopYFquI5bGKWMgqYumsIpZXTEUsZBWx dFYR68EqYiHrh4XF9MNC1g+LWD8snfXDQtYP61FMPyxk/bB01g8LWT8snfXDQtYPC1k/LJ31w0LW DzuK9cO6sX5YFuuHHcv6Ycexflh31g/rwfpheawfFrJ+WDfWDzuO9cN6FNMPC1k/LI/1w0L4MFnU Gh7LAdSR/ZNOup6uB9+gvq4Prt9AN6BWuqE+GP5GI90I8Y1145TfUqCb6mbUhb2XAl2gW8E6H6az bqPboBznw3TSXfURsEfqbijtGH0s0hynj6MWujs8mXa6hz4BHkJP3RNnnT/TQZ+tz0Z7ztXnIldS idF5OJ3h4VyCupyHk6av1tegnGv1tch1nb6ODtc36BsQM0APxLdwfk5r9m3yWbmxgD2ctvp+fT+s 83O6sJ/TVv9bAyXYzylgD6edHqfHIWa8Ho/anbfTmb2dnvoZ/SxyOZ+nnX5eP480k/ULsC/D80no BXop7DL4PAn2eY5gn6eT3qA3oGTn87TW2/Q2fDvn8yTY5zmRfZ6O7PO0ZW+ngL2d1uztFMQieDht 4eFUoA7s4XRmD+dw9nC6wMOpBC+ociwHKXPh4bRi3yaf/ZlO8GfqoZaD4M8k4M80hy2ItYZtBx8m wT5MAj5Md1jnvSTYe0mw93IEvJeTUh6L81VOhR/y/9j7/qg2kjvPaiELDSMzDMMQjmEYhmEYhiGE MCxhOZYlhCEsSwhhCeclBAkhhFC3Wq1WqyWEaP1EJg7HMqzjEB9xHOLz+YjDY31ezuEch/h8Xi/h ER7D+lgfyxHCY1k/HuFYwnKEZe5bJcFgT5KZfe/+u3v1Pp8uV1dXV1V/6/tD7i4aSMTSGNUIJS1R Lag4yhhlBGaiGGA2igXmojhgIUoAxnvRPU/2onue7EX3ItmL7kWyF93zZC+650nkE0Fimy89+9Kz qej3n6189kuo+Fnds05UR3aqk5NoRw4RzlsQReAY5i0Sw7ypaoUY5lVVu8oInjqOW14lEctbELGY Ic+pLBA5iCoRSnCs8pqqU9UJJV0qN0QpOD55ncQnb5H45E2IT85BydchSnmTRClvqP5M9WdQH8cn b6m+oboAZ78J8ckbEJ98C1rD8cnrJD4JRSavkcgkW/Vd1XeBv6f6HjCOTPJIZFKr+o8QmXwaIpPr UP4D1SjKIZHJp0lk8jaJTPIgMvlPUHJT9Zfok6px1TjU/KHqh1CO45NPqW5DfJKtuqO6A2fvQWSS Q2KSPBKT1KqmVD+Fs9OqGSjHkcnbqvdU70FNHJPkqf5W9QjK/wfEJG9DTPJ30NoSRCbJJDLJUS2r luG+OD7JJfHJp1S/UIGPR3YHzCL7kWaqHqs2oATvFJiq2lRtQR7vF5hO9gtMJfsFZpH9AlPJfoGv kP1Ik1X/rPpnYLx3YJbqfRV4gGQHwTRwzMEDJPsIvkL2Jk0muwm+TPYmTSZ7CqaTPQWzyN6kmaej Tz8H5Xh/wfTTL5x+AUrwLoMZZJfBV04nnE6Es3ivwSyy12A62Wswg+w1mHY69XQqnMU7DqaTHQdT yY6DaaeNp43oVRKJvQ6RmJdEYiAPp8+ePgsRWg9EX6+T6OttEnfVQtz1DchfOD2Ickj09fbpi6cv Qh7vXJhOdi58mexcmEV2LswgOxemk50L5Yh6aTvJA86vKuIc+p8IaRoAGoAewAB4gOP4SHEjcJQA AcA5QD/gAmAIMAy4BhgF3ARMACYB9wHTgDnAAmAJyTxTBEizSiDzzAIeQv4xYAuwCzhAqFkGUAKi AXGAREBKqA/N6b/lmBVqqzk3DHxNAaCYnEPNZYDKUH/JNcOhMTbXAOoBjaHy8FHmWSSguDHAOORX jstCWAdshvMPATvh/H4IXhSGAqACxAISAMmhut40Uh81awGG0Dw1s8dzHqqbSeqhZgHgBHgAwfAY ekP38+aExzoAGARcCp+/Ej6fH0YRlMFzbMbjuQ24ezyW0JjHAbcBdwEPADOAecAjwDJgLXzcOHE8 qr8N2AsfH4Wv2ztx/hAhrRwQBYgBxAOSPjji56dNBWR87KPMW/rBs8Jj02aHn/W/FIlPgsj3udB9 iFwlhuqR+55EHqDwg+NxG6F2Zd4KKC8BlIflD85pqz44amsBZ+TPNy2bKrtmNQEzIqwgrAI+Z44F 7jcnAF8wJwMPmdOAh82ZXbP4Knej5po5x61tWjPVdD1s2jDVdy1qRs35hIuO8zfNpV2L+Kzb0LRt auxa0UyYK7pWQvkw75m0XeuaSXM14Trg+yR/n+SnzQ3Ac2YN8IJZD7xkZrrW8VVuFtgA+UMT27Wp WTXzwI/NDuAts9S1icvdglpuErp2NLvmAPCB+ZzbqY4yObv2m2XmfsIXCA8BK5vLgKPNw8Bx5mvA ieZR4BTzza59fJXb05xunpCG1DEmjwQza56UkDreFJQUmN1BdZKpV1I155rvAxeYpyUVLnH3hsrD nGoakGLVGaZBKaG52Dx3zGXmBSkBl7sHwpxtuiQlN1ealwivAteQfL35MXCjeQtYa94FNpgPjpnl ZO7BZoFTui+p80xXpLRmJxctpZHWMsMlHi7uiHGJ+4q60DQi5TQHuUTCKUd5XO4eUZeYxqT85l4u XcrHefeYuoTLgny5aVwqah7gcgkXHOcHuWLgS1wZ8BWuEniEqwEe4+pJvlEqwte6x9VVpttSqbrW dFeqaB7ntMd8m9O6bzff5QxShfqM6YFUrW4yzZA+sISF4/wDzgk90ZnmpbrmGc5zzPNcUKpTG02P pIb2yQ4P4SDhXuD7HQPA0x2DwHMdl4AXOq4AL3WMSA34qm5n+2rHWLdHzZmWJY1aNK1J+vbHHePA Wx23CeP8bsddSY/PdgfVLtOGpGg/6HggKYwy00Z3b4jVPtO2xBiVHTOE54GjST6a5OM6HgEndiwD p3SsAad3bEgMvqp7AHgP8j2mQ4k3ZnVsA+d27AEXdEAJLu8eVPexcslhLHZiLnNGdV9Sn2ejJMlY 6YzBbAySfDxwjTMJuN6ZCtzozADWOrOBDc48ScJXdV8xss7C7hH1RfWKFDAKzhIpoL7MxkjnMHvT 1FfZeKnf6HSWA3ucVVI/LukeC5WH+TqbJF1Q32BTpSFj0Fl7zL3OM7B2oLx7PMy32Axp2DjgbCKs O84POo3Al5wc8BWnCDzidAGPOX3A486e7tvG284+t1Z9h82WrhnvOs933yWtjYZLHjgvAs9gxiXd D9T32DzppnHeeZnw1aM8Lu+eUU+xhdKE8ZHzujSB893zxmXnje5H6lm2RJo0rsHMAztvHec3nHeA t533gPecU8CHzllpkpY7HwJHORelSXxt97L6IVsu3VcvslXSNB3jXHmK453r0rR6ha2V5tTr7Blp gU5ybhLeOc6nOvelBfUm2yQt0Rmd6JizOxXSknqH1UmrzY+4XsIDwMskv8YNAm9wl4C3uSvAe9wI 8CE3Jq3iq9x3tXJu3P1Avc8apccaxHLSljaKuw0cQziecBJ3V9rCZ90zGgUrSrsaBfcAM85rU7kZ d7RGxbqkA20GN0/40VP5bG4ZOI9bAy7kNoBLuG3pAF/lntfEsj63TJPA9riV2nJuD7iKOwSutciB z1ii3EpNMtvnjtY2EdZZYtyPNGnseXec1miJJ5xEONUdp0mzZECes2QDi5Y8YJelEJdD/WWtz1IC JT2WcveaJpO96E7U9lmqgM9bat2Jmhz2sjSH2b2hvWg5497W5LNXof5lSxO0kG/RYYaS5VB5mIvY 6+4UTSl7A/p21WIEvk74hoWDmcHle9pbFhGsJ8lrKthb7nTtHYuLsO+Y71l6gKcsfcCzlvPADy0X gRctl4FXLFfdh9p1y3WPHNq5487SJFtuAJey94Cr2Sno56blFvAOZlKyrKljZ9252n3LnScZl3sg bLXcc6e3KCxTnhhNA/vQXdCissy6C3DeE69psECJRsMuknGFeOUo3xJrWQdOsGwCJ1t2gNMs+8CZ PALO4RUwdnztnkbPrriLNQy77i5ryedVT3ERH+su0/DsprtS42B33DUtpdwAZj7hmCv4ZHeNRmL3 3fUt1XwacB3hBj4TWMPneJKwT+JJbdHz+eCfgG/gyWhh+KKu9RaeLwV28BUhC+7JxnbQk9ci8dVS ckuAr5OSsSXyFLac4xuwVeI1wGBrPCUt/bxeym+5wDNgX2C9eMpbhnheWsVy66lqGeYd0kHLNV4C HuUDIRnz1OLn6znTcpM/507XVPD9wDAPnqaWCf4CnhN+CDg00kl+GPg+f81dQyzOGp3XqQLrgzX/ Bl3YGSsxdElnAnB5Z3JYP29jLde9R1d1pknD6ludmcBYzxzStZ05WOd05gODJgnK6TOdRaA9mjpL pQUi+cst0/yoR9cyx9/0GFsW+AkP17LET3rEllX+ftdiy2N+umulZYuf87igzgLU2eWXPL6WA37V 06OT8Y89fTolv+U5r4vmd7s21VX8gVSqi7PKPBd1iVal57L6jDVaqtalWOM8V9UZ1kTPdXW2NUVK 1qVb090PdFnWLM8NXa4113Mr5G/oCqwFnju6Ymtx1yz2KDz3dGXWMs+UrtJaiZ+CtebIsutqrPWE G4HroW+zukar1vNQp7UaPIs6g5X1rOhYq+BZ1wlWp2dT57R6PDshn7ZZZg2CFxfyo4iXovNYe8F3 JX6jLmgdAO61DoIXh2Vjv1lrBdYNWK94kW7QOuJV6C5Zx7wq3RVcUy23jnft6East72xIc9NM2S9 2zWrG7M+gDVOfFTduHWma7050Trfta+7bX0EdzdYl2Ee7lrXgB9YN6Q03Yx1G3ywEese9Gfeegj8 SJB7+jS7QhS0vyzEeBN0a0K8ZxbPgDdZtyEkhWTbm6bbFlKhnT0hQ8rXHQrZ3sxWuZDnzQl5mK1R QqE3vzVGKPEW4XXhLW2NF8rBSwdf3VsR4tYkoSrkgXurT3Ad4QZyFw1hfWuqUNu13pohnOnabM0W mrp2sEftZVrzBF04zxN24PXllcIzCf6wN0D4HO6Vt7+1UDB6+0N5whdaSwROim0tF0Twh8Er9g61 VgmukA/sHT7B18BTFaS01lrBB3wGM/ZavaMhbm0SekKeqvdmq07ok3JajcJ5YCiHEk64GPJaPSUf sHcCr3rvJOH7IW4Vhcvgi4JH6p1udQlXwfMEv9Q71+oTrkvVrT3CDWBOuAU+54xwB3xL/FwWQtza J9zzLmlThSlY3VgzR7eeF2bBeqYKDyF/UVj0rmqShRVsEYR17+PWy8Kme7v1qrDj3Wq9Lux7d1tv 2JD3oPWWTeGThXU70d6aBpvKp2y9Y4sFbeywJfiiQ5qw9Z4t2RfXOmVL8yW2zlrKfSmtD22ZvvSQ D6A12nLAFhAr07qI9XbIRreu2PJ9Wa3rtiJfbusmtratO7ZSsHqgtXwF2llbha+gdZ+b9xVrz9uq 3Yl6ZKvzJYbt8lVbgztar7BpsC9h00urepWNwTbdxksH+libwx2nT7BJcN9FWwDbLxvoQH2yrR/K 02wX3HEtObahI0uhz7QN+8r0ObZr0DfwJbyx+nzbqGcWj85XqS+y3QxpWve8vtQ2Ae1U2CbBCoDN 9dXoq9kbvnpsp3yN+jrbfZ9W32Cb9hn0Gtucj8Xz5hNIO0693rbg8+gZ2xLEOKDDfcGQt4PZ0xTi I6+GFX29mEMlvgHCg7gPvkuEr+h526pbpnfYHruVegl7I9gz8TTpA7atUB7sHTBcBbbAN4K1rm9E f862G/IrfGNhhlF4avX9tgOwFyRPxjWivyDK3Cn6IVEJHgX4Fb5x/bAYHfIioFfH7BvUXhXj3Fn6 a2Ii8KiYErL40A6w77b+ppgesvK+u/oJMcudq58Uc4GhHEruiwUhK+97cIJnsJ3yzRMeJPxIPy0W g+0GC+5b1s+JZWCpwY771vQLYqW7Ur8k1gCvivVgxarFRnc9mfMNwtvhmXksat0F+i3R4C7T74qs u0Z/IArSaptMdPr2aF1nRTCKNnZWB6pprrMOWOxskPppV6dG0tO+Tr2koHs6mWAM1OHhbF+nIxhP n++U4OzFzkAwib7ceS6YSl/t7Ido6HLnBekcfb1zKJihPt85LEn0jc5rwWz6VudoMI++03kzWAgW c0Iapu91Tvp76KnO+8ESerZzOlgeig7UU51z0gT9sHMhWEUvOm8Ea+mVzqXgGXq9cxXiuPXOx8d+ +GbnVrCJ3unchfx+54H/BoNcsqCOUbiUQSOjckUHOSbWFRcUmQRXYtDFJLtSgr5QBGqsdKVDzBWK dEhMwaS5soI9oSiPyYQSnslx5ULMBbY+2Ge84ioI9tEZruLgeSbfVRa8yBS5KoNGYxauqe5z1UgO ptRVH7wcirPaJ12NR/FsKMZkKkhcWWlcwxGfS3t89xGXAZjESky1i4WIKRTjHEKMOcnUdW55i4zF LgHab3A5g1cZjcsDcRbMQPA6o3cFw77KAMO4eqVhhncNSAuMwzUYvMFIrkvBW6F4kAm4rgTvMOdc I8F72M8JTjH9rjGIqSGyDs4SfshccI2D1YAIGuwFcHARs5vE1MEVfJfgeoiZIddtGNEwxFw8c811 V3Lg+De4yYy6HoTzO4T3sb90FoVnEqLXs4owQ6/OqpibrpmzqlCecCwz4ZqXLjCTrkcQvUIMezaB ue9aDkWsZ5NPcJrxgWsNZmzatQE8hxnHmJ4zIWYWXNuhuPJsJrPk2pNuMquuQ2Aoh5LHXfJQjHk2 5wTnYy/ubBHh0hAzW11REDlC/Hi2gtntioE4EaLIs9XMQVe8NGeSdSUBK7tSpQVTdFdGsAk/l7N1 hBvUfV3ZwU1TXFeeNGFK7CqUpk0pXSVQM72rXGpoU4oe3yGJHYg9IroLYpa2aDHol7fFib3+KI1C HPDGtiWKg9h2iJf8MW0pmCF/xR/fli6O+JOAx445Sxz3p7blirf9GW0FcJUyFNO1FYt3/dltZeID f15bpTjjL2yrEef9JW2JWH8S3murFx95t7C29JcTrtL6xGV3XFujuOavbdOKG/4zmnxx273cZhD3 /E1trHjo1xE2Yj3p58KxFbBfbBPscr8rFGe1Oe1Rfl+bxx7j72kL2uP9fW299iT/+bYBeyrwoD3D fxHrTP9lwlfbLtmz/deB89yytiv2Qv+NthF7if9GyKa0jdnL/bfaxu1V/jttt+21/nttd+1n/FNt D+xN3iKiRZVtM3adpG+btxv9s22P7Jz/YduyXfQvahi7y13Wtmb3uYvbNuw90s2QhcLsX9FIYA0h b+/zOUOeW2uM/bx/vW3bftG/qUH2y/6dtj37Vf9+26H9uu+wLct+w59qkNtv+bMNUfY7AWSIsd8L KAzx9qmAypBkn5X6DaniYCD2ZGuGDPvDQIIh274YSDbk2VcCaYZC+3og01Bi3wzkGMrtO4F8Q5V9 P1BkqHWgQKnhjEMRqDA0OVSBaoPOEQtsdCQEYsPMOZKlVYPoSAvUGVyOTL/P4HPkBBoMPY78gMbQ 5ygK6A3nHaUBxnDRURHgDZcd1QEHfr4ByXBV4wgEDNcddYFzhiQH6HzDDYcm0B96doZbDn3gguGO g/H0Ge45+MCQYcrhAJ51SIFhw0O49Jph0XHOF6epcECEZVhxXABedwwFRg2bjuHATcOO4xrwvr0w MNGOHKPepXaF46akaFc5JgKT7bGOycD99gTHfYlpT3ZMB6bb0xxzgbn2TMdCYKE9h531FrXnO5b8 he1FjtXAEtR8DDVLHVuB1dBd2iscu4HH7dWOA89se12HLLClURgypN32hg5lYFdT1BHtTmnXdMQF Dtr1HYndsnamI6Vb2c4bXN1KTV0HWOd2R0dWN/hyHbnu+napo6A7rj3QUdyd2H6uo6w7pb2/o7I7 vS23o8a7hbk7KxT1t1/oqO/ObR/qaOwuwN5LdzH2UrrL8K8o3ZWhFUd+wegN/1Lx5Oq4E/6tgPwy 0F3TPtyh9Wdg+95dj2Pw7kYsjd3a0K9DRD/stV8TB6F94om1j3YY3PNt6R2sez786w35XaX9Jst1 G9q2O4RuNhT1t090OLsF/Kw9tUiGPkFtUf8LIepX1C6SUfvUr5Gcel9GIYXslEyBnpE9K1OhZ2Ux sufRadmLsnj0nCxR9hJ6XpYqew29IMuQvYlelH1b9m30iYiKiD9CCafKT30eJZ7iT1lR0qmfnPoJ So6GhF6JTon+AkqJroluRNXR6uhu9JXod6N/jHzRD6I30F9Eb0bvoofQmy8hOfnrB9HoOfQMeh7V oWdRPdKiLyId+jpqRP8W9aEA6kfvoSD6G/RzNIV+QUWh/06pqNPofeo56kWKovA3Tkr83iT1CaqB aqOSqHYqSGVSPdR5qoIapL5NfZn6S+pn1FcifhDxA0qUC3IbZZd75D6qQ94j/zrlkr8rf5fyyL8p /xbllX9H/j0qIB+Vj1Ffk4/Lf0j1yn8s/zHVL/9v8r+i3iXfY56Xz8nfo74pX5IvU9+Sr8n/gRqS /1L+S+qy/Ffyf6K+i9+io66ceuHUC9R/OPXeqUPqmuKUIo2aV7yheIPaUbypyKZ+pfiMopD6Nf7C g3pf8TlFmUyuKFd8QaZQfFHRKItWNCt0siSFXsHLUhQ2hST7pOJrij7ZZxT9iiHZHyi+o7gqq8Rf TshqFaOKn8r+RDGjmJFZFLOKBRmvWFQsyjoVy4plmUvx94rHsi78PpbMq/hHxY4sqNhVHMp6IlHk adm7kbGRL8q+E/mJyNdk34tMj/w92VjkZyMZ2WSkNXJAthH5jchvRKgivxk5FHE68vuRoxEv4L+r GvGJyP8ceSsiKXIi8icRyfh9oIj0yL+JXIjIi3wUuRZREPkPkf8U8Y4yXXkjok75j8+8GvHz6F9H /1qOv5djUA+wCiXjr41Lx8JQArJQOqOt2GMMZRV/9LAsh2EZgXFWLDMeJljG1PQz48xt5m7ZBPOA mWHmmUfMMrNWFVWVyvRWiczAO5XvGJhB5hJzhRlhxqpS3ykDqZKDjG8RGf8Voqj3qfeRDCQ6BkXA uZfJm6hI9n3Z9xEl+4HsB3BuTPYXKEL2I9mP0CnyJqpC9jPZz5CSfAn2jOw92TyKIu+gqsjbp6dl P5f9HEWT906fk/1S9ktYHfjN0tgIKoI6/qvBpyIUKJ58OZYQER8Rj/5VREJEAkokb4q+FJERkYFe Jl+FJUcURRShFPIN2KsRJRGfRankq5g08s7G69B/FRVLZg4zou8hF32PnqJn6Yf0Ir1Cr9Ob9A69 zyB6h1EwKiaWSSBIZtKYTHqTyWHymSKmlKlgqpk6poHRMHqGYXjGwUhMgDnH9DMXmCFmmOAaM8rc ZCaYSeY+M83MMQsnk6meWWJWmcfM1nHaZQ5MMpPyRIo2xZkSTSlQmv5EajSlQ90sU66pgDk4SqZi U5mpEhinGpOW2TIZoC5r0poEk9PkMQVNvdBmumnANGi6ZLoC46eeYcJaA3+z/jyZkwRIESgJkhyl ozfQKZQFKRJ9CpISFUJ6BhVBikLFkJ5FZegd8nb5H4PWwd9dPof+FDWgGNQEKRb0jg69gAyQ4pAV CeSLSyf51tJN3ij3o0TQR++il9A3Ib2M/h2kZPTv0VX0Cvo+pFfRKKRU9ENIr6H/AikN/QjS6+i/ onvQvylIGeSvYb+JFtDfokz0d5Cy0C8gfRL9PaRstI3+Efq+h/43+jQ6hPQ2JaMiUR4VBbqvkLw/ /q9B98WgIvL+eDGVTL2K/pB6jXoNfY5871kG2rCGfNHZgMqpr1Ia9HlKS2nRH5N3yavI151foBiK QdWUmTKjL1I2SkQ1VBflQ7WgO4PoDGjPr6E/pb5O9aKvUP1UP/oq+bqzCTTpLaSmJqgJ1EJNUj9B Ouo+9VdIT/019dfIQP2UmkbtRH5p0AIZiFFmKjORmbydxyk/rcxFFvJGnlVZqCxEgrJYWYxs5Esi kbx/Z1dqlM2oQ9mibEGd8GzX0C6R/Xy8s4TxJmACMAm4D5gOYy6MBcAS+jfGCeOk8b5x2jhnXDAu GVeNj41bxl3gA1pGKyFF03F0Ip1Cp9NZdC5dQBfTZXQlXUPX0420ljbQLC3QTtpDB+leeoAepC/R VyCN0GP0OH2bvks/oGfoefoRvUyv0Rv0Nr1HHzI9jJyJYmKYeCaJSWUymGwmjylkSiCVM1VMLXMG UhOjY4wMx4iMi/FB6mPOMxfxXxA9pT3VDkbwq9FNZH+Fd/6vyfcXID1HpDyGSPnzRMpfIFIeR6T8 RSLl8UTKE4iUJxIpf4lIeRKR8mQi5a8QKU8hUp5KpPw1IuVpRMpfJ1KeTqT8DSLlb6JpSJlE1t8i sp5FZD2byPqniKznEFn/NJH1t4ms/x7IugzlE/n+DJHv36deppJB7rFkFxHJ/gMi2cXk+4g/JNJc QqT5s0SaS4k0fw6kuQvWgJtywxrAX0l8nkhzBZHmSurPqT+H9YBluop8H/EFIs3VRJprqGmQ41pq hppBf6L8svLLqE7ZoGxAX1a2K9vx99oxnphz8JxUMPfPIsrSBHKXCygAFAPKwmWVgBpAPaARl8mf N+ZZ8um53w1SZ4GfNxZaiowlllJ66UngMmO5pYJeBTzmH2EYqyzV9NbvBq5jrLXUGc9YGujdD4D/ bWyyaOgDi4aR8ctGnUXPKH83SJ1ofs1otDBMnIUxchaeQLQ4mERACs+SfDq/wWTx20aXRTL6LAEm 9wOQfxfwe8Yeyzmm+CNQxh8ylVa5sc/ST3DecsF40TLE1ISA83hsTP0HIGO9bBlmGi3D+Ehw1XKN 0X40cD3jdcuo8YblJmN4EsZblomjdk/CeMcyybAfwHjPcv/jgGsSLxqnLNPGWcvcb8RDywIGpxMv YxgXLUsfCyuWVeO65fGHsGnZwuCM1j7jjmX344DjxKvGfcsBBo14GYGCV2JwongdH82sbYTW8Fpa xUfTsXzc0+Bc4g06gU/8KHA+8RZpI5lPIUjj0+lMPusJ5PC5H0I+X/AEivjij41Svoyu4Cs/hGq+ hq7j6z+EBr7xCeBxfwwwgjWK1vMGmuHZ3wg4xzitMYzHGk/q8bzwseDgnbTEez4E3F4Q0GtNogN8 8OOAGbCm0uf43mP08wPHwOcHAZesGSR/xZrNjFjz6Av8IOnvU2DGrIUkP8Rf+igw49YS5ra1/Ik2 hvkrT+AaP/Ih4GvvWqvoUX6MeWCtJccZ65nf1J/fipv8OD3B3/4QJvm79H3+wYcwzc+cBDNvbTrS 7Sd18ZGuPNZxj6y6Yx20bDWe1CPHcnLyuR49l6M5WrNyx3O7YRVP9onokh7QKbD2ub6QDuDOh9Yv WVcX+URiN0DeucuAq+KdI3nmrsMR7oPPM9tWF7Nn9TGH1h6T3NqH7Yspynoel+OxmWKsF03x1stY v5qSrFexnjSlWq+bMqw3sA0wZVtvYd1Oxgzybsqz3jnSz6ZC6z1TiXUKj9tUbp3Fc2Gqsj7EuhO3 SVBrXTSdsa6YmqzrJp1102S07pg4675JFBCeX2KD8FzCHJpcYCfD9szkA/sTnmdTD7TTJyhwG+Tc eUFluijEYrtzbGtPPKPjNjHCNuXIFuA+YdtouiwkkL5dFZKPnjOpj3U/PHtil8HmkbFdF9JwmekG 2PDCELC9xvP7BKpCdhnbK2KP4T5HthgfCUB+yNiesrHkXgDTLYuEgW3skV09gumOpR/j2EZimxm2 jSdt5RM2Mmwnj2C6B3YQnjGxfWAPTVOWCQwit9jO3QnhWGcBTLNCJjk+FHJMi0I+KQf9YVoRikzr QqlpU6gw7QjVpByvYWxL8LqFdYTXk2lfqGOR0IB1EasQNGRdHK2DsF4ksgXtYD3HqkA3hdcIeV6g t/D1RzrwQ2vrqXV1rF+O+g9tYL3Jxgp6/MzZBIE5vh7Xh/XGJgs8myY4cL/ZTEFic4QA0eF4PDAG Nl84xxYJ/eS6j9I/4X6xpWE9frTGgyfqhPtMxvqUPj4eD9bDR/ht9/ot+pStCB+r+TE8pmM8rSdP 6kqsH4905EmdCHVJO7gOPgdzwNZZq7gb4j3uljiFgX0b/LyJX3NHnCVloLPYOVs0d098eOS/cFPi IhsQJokeA7+DmxVXiE8BOo0dFR6zkjBx5BNwD8V1otOw/cd+A9Z1i+ImttHcirjDrYv77KRwwG3a EbdjV3D7dpUF2WMtCnuCRWVPJj5ZWF+Sa7FvFvabiM9z5KPgtsJt4HOWWHsa1pe4X8e+3ZEftvOB DiY48mHCvgduC/tjlgR7JvZ3LMn2nKPrSX0YD/k3zBdZJzA2S5o9n5Rhv/EIYT/xCTztC4Z9vycQ nten/bpjYF/sCE/7dUc+2m/wzSyZIXykb4Z9r5P+F/a5jvyuEz4W7iu5FtcJz8mH1hasP7ZBuPCh daURho58LFYvDLOMcA3roqN6LC+MYrlmHcJNIk9HegDXwWsO5I8czwn32X5hmuQvCHPskLCAcXK9 scPCEtYR7DVhlcjnTWHrQ34MgJ0QdglAHjHIOsR6675NRo7TNuXRGsRrgl2wxbFLtsTj9Yd10Kot heiax7Z0dsuWxe7acrHtOQIeL46xyPqDMbMHtgKzzFZM2gb9YVbaysg4w/XN0bZKc5ytxpxoqzen 2BqxLjKn27TmLJvBnGtjzQU2Ads/YgOxfgKfwFxsc5rLbB6sj82VtiCJWcAWmmtsveZ624C50TaI 58ustV0yG2xXcJxgFmxjeJ7MTts4rm/22G6bg7a75l7bA+wDYv1/pJvNA7YZ86BtngDaw3YGy7b5 ku0RnnfzFduyecS2huXMPGbbIDoMnqN53LZNzt227ZE27toOsS43PxDl5hkxyjwvxpgfifHmZTHJ vCammjfEDPO2mI3n17wn5hE9hsd/KBbiIycXS7A8cFFiORcjVnHxYi2XJJ45lh/wwbH/waWKTVyG qOOyRSMpD+tcLk/kuEJRJM8P1glXIrq4ctHHVYk9x7J6FAcc2SjIc7ViH67DnRHP4zIkQ1R0MLof of//Pyj/D/0Pysb/Ye9coKuqrr2/z977nESEU8QUISKNqSLyEgNSRApKkUfOA6SolFKJOfs8RW6K FJHSCBRtpBSBq5SiIqUUYwREihQwIHJ5SSkCRUCLlIsUKWCkQiPlQvjm/O0diJGO2nG/b4xvjHvH GvN/JnPPNfdac8011yPHo/Hppb8DONXGiHhuPC/eKt4uXhDvGu8x2I73jhfGBwreFx/mVLslnqcU L46nnHNuiY+Mj46Pi0+IPxmfGp8Znx2fG18Qr4gvHTwtviJeOXhtfH18S3x7POiVmdDu+PvxHK8c jB+Jn4h/Gj8Tr0nYiQaJxommiRaJ/ETrRIdE50S3xJ2JPnGztohGODEoMSTxQDzbLQknkUmUiN4Y WqgtUk19pu+TN+g9f6MKie3+/1fuQSMyNwZIuYp70Cbcg17NPehXuQdtaqSMjHGNMUJKLreh13Ib eh23oV/jNjSP29DruQ39OrehN3AbeiO3oTdxG9qa29CbuQ1tw21oW25D28mc22Z0MLZLuZXb0AJu QztxG3obt6FdjI+MvxjfMI5L6cad6B3ciX6TO9Ge3IneyZ3oXdyJfsvX0tfS6M2d6N3cifbhTrQv d6L9uBPtz51oIXeiIe5Ew74f+R43or6JvonGPdyJDuJO9Nvcid7Lbeh9MtN/a9zvW+VbZQzlTvS7 3Il+jzvR4fYU+6dGEb80WGyvtFcZjszrTUbCPmr/xUjJ/K0WX/qMsUbppViNSY9je2L7Y4diR2NV Uk7HzorjA05Dp4nTzGlJSTgjnFHOWKdUymRnijPdmeU878x3yp0llBucNk5Hp4vTndIL7OdEBQc7 Q50iLRo3ZluJm/Ze3DTh/RoxpozRTRI9Giu2+L9AokdjJUCsZEmk3C0xpHfmV0h0DJUY0vi4kvho yD15I+nXQxJJGg2NJRZmSDxpHDSRKFgo8aQRkGO8JuWrREBTIuAaGf8NErd6H95cxvw9iTAd9WsZ 9RbcgV8nI3/MaMkY5/kayxhfz+jmM65fZ0Rv8A33FRk3MqI3yYiWGK19Y2RE23DL3dY3VUaxHaPY nlHswJ32Lb7f+lYaHQ1fdpfs7nXGo419VaxN/eKMcybEOsa61BanVay7V3rVL86TsX6xqFucqbHB scHOTJHUK85sZ25sqJQiKQktzgI+R8RG1RanIjb2i8VZioWxsVKvTHaLsyI2JTbFqRSc/sXirI/N ij1/scxXXa+Ue2VJ/ZJekl4eWx5bXVsSJ2PrvLKpfkmvjm2rfVd6XWyXlPkiqVfinWPVsX1S9H0H tKRaO0H5PEwNSrzqi9Zjm1J9sLCp1rOxY25Jb4qdjJ1MlwtWf7Gkt0n/zl0sUce8WLLdchlPbXG2 O0En52LZ7eRS3r/kidriHHTynFa1hRE/4rSrV04IfeoUULpKOePJa+K2YI+LPYrGSuMNnN5fLPHG TmG8qTPQuU9LvIUzzC3xfGekSIqd4nhrp7iOnYsl3iF2zEldLCOd0bXF9X7sgIyIxHe8G7HbL35n vI/GWDysnogP0viIDxHuAXrbLu7EM7QoQ19dSxopuxilbel96QNEw2G8fwxPn4iXyNzpKP7rEuse HxMrj48XLwfjk6R9ZfFpEstF8Wck3sfG5zhmfJ7E8vTisvhCp6u8d5rEyWTRXRRfFl8ZOxdfG98Q 3yot1vifHt9BL4tkxLbEJsf3iEY0vj9+SGzprKVHaLpzRUd3cmxw/Ki0v0r6fFrkU0Svi8y6KfGz wnWMP5AwYt0TgUTDRJNEs0TLxA3M5cFuSbRJdNT5muiS6C6lV6KfzNYR7oxNRBODeZu8KTE0NjlR pHMyIZZFc0RiVGJsojQxOTYrMcWbfzoDyxPTEyMk1oLEW648neUUOl0Tzzu5ifmJ8sQSZ1hiuYyv jFZ8WmJ1Yl1ik3iundNb2jTL2Z7Yltgl2vukHHAKEquJQO0lY6V6UiRi1EuJw0LHnN4yh6cnqkU+ OnEuaSYOJLOT8u5kTjI3mZdslWwnvs4kCzTek12TPZK9k4XJgRrj4lnGPHlfvLVEW9fksMSIZLGU VHKk00OLPBudLEiOkx4UOvfJkwnOsOSTGqeCxcmpyZnJ2cm5iRuSC2LHkhVOKrlU4nGk9i25Ilkp 7yyWCB2t/UufjC1PV6ccyQzr0udkfA5If3pLvEzPmJlsyQLlmaBkik2JWckTmZxYs9jq4q3JgZnc TJ7Oa4kZ8VamVaZdpiBRnuma6SERqpmjWrKZeqc8vTq92tWITU/tyPQWW5rviGA03SwjESy2dmUK Y7MyA2NLMvfFNjmm6K2W9pzMDBNueXJYpji2Lt4tWZDqlkllRmZGkwW9TJYZlyazJrumd6V3ZSZk npQ8d9jNdZmpmZm8Td6UmR07lpmr2UzwZGZuZkGmIrM01TQjGT05zM1c5K7s9LFMZWaqMyyzXluS XC/jpLEzLLkluV3jxy3xadLuTcndmpOS78sYH3QGyugckbhqJ/mgXfKE+HpB8lOnR/JMsiYWTdkp yTuxw6nGqabFW4u3plrICC6QuDkZG5vKT7VOdUh1TnVL3ekUJw6o32PLna6pPqlw7GRqUGpI4nDq AZk9UyTBZJyR8v4Dsj4eSd0pMzgoOatYnpSkxqTGO7mpSamy1LTUM7FSJzs1JzUvtTC2K7UotSy1 0gmm1orVYGpDamtsn1g+kNohbQpKW/ak9qcOpY6mqlKnpY3bxHZ27KRonk0b6UBsSrqhZJsmMpei EjfNpE47iZWu6ZYSvyfSN8SWpFonTyRPxKclD8YOJHal26Q7pm8QP5jpLunu6V6Jbel+6Wh6cHpo uiidSPdzCuVzRKI6PSo9VrRLU9OS29OT01Oc0enp6Vnp59PzU9PS5XGH3VT7/z1h/g86YaaMEr7V 0FT/bzJF5YbvQdPIKVogpULKUikrpFQWVQ6VUrS+aP3wfcP3FW2Rsr1oO7LdUt6XorKDUo5IkXpD qoZUFZ2Q8mmRnmHNYDQ4QN7RmBONwYnG5Cxjsee1Ocv4OcUE2PNmcYrJ5hRzBSeXKzm5NGTPG2TP +xX2vI05s1zFaeVqw9fYaTySPvG9w6LOhq8oLJ/d5HOQfVW/hUV9vgwVFsrnIqFl/4BWulQ4zKV+ a78kbRDaehna4VLhaPnc8+WocIJ87vfokEdHXep/wP0snC00V/gqodNfpMIK+Tz7z6lwhVCl2DU8 Cgg1/DzRt3rUv0k9avYvUEuhGy5DbS5jV6ljPery5Sgqfu/fXajXP6B+LkX3uNQ/+iVpsNDQy1CR S1EZt/6JL0dRGdv+Izwa5dFYl6JH3c/IQfncJVQqNPmLFJUY6D/ln1P0tGdjukezhJ6vR/MvQ+X1 aMm/QMuFVl+G1gltugxtq0e7vhwVHpHPfUXMj8uSPCs8IfSpp3f4S9IxoZOXoX2ezRr5rP5yFLLl 89wlKjQv0UWdxt5nU6EW8iz70rvqUijfe3/wn1OotVCHz9cvzKlHuZchrdtZPvPks5v3eefl2/OP qLCVULvLUIFQ18tQj89TqE+d/F0339bmSy+PhcJFF/NLaFDR5/NHbZzUHVfP3xd9NKSObx/4fJsu 5pS6OaB2DntzS9eM2pgf0KxeTFe7z0OOUEaoxM0Rur6Exrty7VNoklCZm1+LdLwkT4aeEZrjrgGh eV5+P+vGe0h8UpufQ7KmhZa5/Q2t9PwgNjVfqk1I7cp4hiQvhsR3IWlDSO0e9fzr+VPrsk7WrmGH 6vhZ7IQN14Y+C8t6EW7otav+ONUbo4trSu04lblrY7iJ27Zwszr1z7p94d/LvLVP/h1u6ckW1aGV l6H66/KOy9CeOutrnTX2IlXVoXrr68X18r+zTrYs+vxa2Kbo0hpYZ727mLOEwr28T1m3wlFvjkn+ CMuaFJY1KCzrTzjhyWUO6/rBvO3jzqewrDPhUW4uCo/15oU3D2rzosaW2tE8R36qnSNlbt7S+hdz YP25VW9e1eaXi3OrzGv/ZG/Mp1yqj77Mt7CsTeFZbrvDsiaFdQ064OUk7YOsQeElXr1/loPq5/HL 6dS2+TL5+OKz7Ev0D3PdP8uneZ+nL+TJurmyoE6OrJMP0c3zdLq6PtAcPUDiZ0Abl3Rvo+Ote5oB HT2ZxEqkt/Cax7z9ywDZG4WrvTwmYzpAY2uym88i6nv1l7cnGNDPy2W6/s/y8pzGn6zRA8TeALEX kfYOkLgZIPYGSJwNUJsSYwNKvfxZmy+XeHuz2n3TqEt5FFueDdo42c2XtKt+Hq6Xgy/uYWrzsPZT bekziakB0+vUn+L1p4vrL/Zc0rcBszxZ9zrU7zJUfy9YdBny/Fp/X3eRSutQ/X1d7R7tv7M3W170 +f3XuqJL+666e6wir+7qOj6pP7dk/oW3FX1hXoV3FV3cY4V1Xh9wc9HFfHXYjevwMS+eauWqU+3F n35KXol48y4icywSdKnufIvkuDkikuvGZ6TVZfYxQpF2HhW4RB5U+129zx6X5qDOiYisdZGBdeaf 6EXuc+dbRNboSLFQyl17aol8VOH6SfscGSk02rMt/YiM8/rp6UfkTBd5Umiq0MwiclFktpCc4SIL hCrc9U+JPCl7gshSoRVuPo5UunGqa2FkvdAWoe2ev3YLve+eEyJHXD9FTrj6EVk7ImeEatw9oOb/ 2twclTUg2sAltcc6I7Edbez6PSp70GgLN86i+a4fdRyjrb1nHTwbnd1cHpU9YlT2h1HNPbIfi8o+ LCr7qqjsp6KO699oxstj0v9oifc5xo2HqOyForIHisoaEZ12KX40d+t+ICp7oajshaLzPLmXc6Oy H4gucu3rPImKj6KyB4iurROrteeA2jVK+OgGVye61ZXptzEarW+08X+/jfE/6a7MbmNv0L+omluN Vw0jK0+olVA7oQKhrkI96nz2FioUGih0n9AwoWKhlNBIodFC44QmCD0pNFVoptBsoblCC4QqPFoq tEKoUmi90Bah7UK7hd4XOih0xHvniX/w+anQGY9Uv8Ywsm1Xnt1AqLHXthPep/Qhu6lQC6F8V37x s7VQB7et2Z0v9Tm7m9CdQn2Ewq6d7EHu+7KHCD0g5HjyjFCJ0BjXbvZ4oUlCZULThJ4RmiM0T2ih 0CLvc1mdz1r9lUJrvc95Xr21dZ5vENoqtENoj9B+oUOXPtU/2UeFqv6Fz1pfnHb9+K8SY1CXBrqk 9hmvg57u0Xp01v3fztd+1tavtXtFQKihN94iv6LJpc8rmgm1NF4N9QtFQ4NDQ0NFoQQ0IjQqNDZU GpocmhKaHpoVej40P1QeWhJaHlodWhfaFNoW2iVlX+hA6HDoWOhkqDp0LmyGs8PBcE44F8oLt+Lf 7aQUhLsK9Qj3DheGB4bvC00PDwuVh4vDqfBIaHR4XHhC+Mnw1PDM8Ozw3PCCcEV4qfx7RbgyvD68 Jbw9vDv8fvhg+Ej4RPjT8JlwTcSONIg0jjSNtIjkR1pHOkQ6R7pF7oz0iYT1ucgHRYZEHog4kUyk JDImMj4yCSqLTIs8c1maE5kXWRgaEVnklWVSLsevlLI2siGyVfgdXtkT2Q8dknJUSlXkdORs1IgG oIbRJrImNL/sLy4Y3i8uZPOLCw34xYWG/OJCkF9caMwvLjThFxdy+MWFpvziwjX81kLzYF7wVuPa YKdgb6N9MBZMGT2DI4LfN+4Ojg4+ZoSCpcHHjXuCk4NPGN8Ozgi+YdwbXBNca0wIbgkeNybx6wsL /z9umc/XxFfC91VW6/9NPr/AI8ks+T086u1RYR1eSWZN/n0er3rDPL7Yo5RHknXzJevmS9bNl6yb /6SnO9XTV9nMOv+e7X3O9WhBnXdWeP9earQt3CplR+Gewv2Fh6QcBQ8VVkk5XXg2ZIQCoYZuKdwa ahJqFmoZukGkbUTeMtQx1KXwUKh7qJfMSWZl4WmZl9FQkYzVV/ilDYPf2DD5jQ0rWBAsMOzg3cE+ hj/YPxgxsvi9jYbB4cFiGYd08CHjuuCo4CNGXnBc8EdGfnBS8MdGq2BlsNJoHXwz+KZxc/BE8ITR 5v+xdV/Nd+1vCQ6V6PDVXAnfAP5W+FvhO9n9BDv7RyMvRv5z+KmCBf7X4PvBu3VvhR9I3VsEOyDv bI/EjtYtwP4wu5Oi/7v63Sf/OOFz7F6K/h8ILkPnRX3vefjza2jDJOQPwXeC7wTf2W2th+PA76Mj Ns//p91W8KDXo7Y8/S6toqf27fQrTctTylv74LN5alDrZSQPUzeE5CvwPan7KNa+Qkt6gn50uqCT EOwI3xG+wO6GPAPfBQvIwU48LeDpN+w7FP0P0ZJuaCrfyfoUHdcPU7FWiTUdi1vscuQudgUHoeNg cwU2xRvmPfpGs72/SPAJv8xucwx8T3Cff5Rgqer4TPBZ9GmnaShaCTSf9ccEF2LzKpX49irvO8XT Gejfjf7T8DlYOwUeRP+s/TuRm/ZGwUH2bn2L8r5PkCTsvYLdVceoVvQVgn8H1yhaFpr9sXOv6vs+ xEI5/GKe9kX/Avpt4I+A68HX0T9u/5tohv3/IfwZjVsz4H9T+BqV+4r9WwUP2RIJZq7qGMf9EwX/ pug74kkErQLs5IItqBsHZ4DX2Bd4+qDw7yia++ErwR3gs/YwHaPAcXAFWAGWgVWKWc3kXZ3dEUTz iYD+hkoxfE+wkYcVYBmoda9BcwNPlyLZh6QUyTx33JUXXAFWgGVgFaj6/dEcTy3DRf8vNCrgn6Xl C+FXgws9SQVYBlaBvaUv6/xlRFFKkbfvBU9Rd4aHK8AKsAxUCzPwxtOqY80Gn6bNp8CD2DmobfYd 928TPA0e978AloDDQSLBf0IsXMN4nUHzIHjMw4nEwHqNDSQ1WKjBQg0WaoiKQzw9hOSQJ1ktaNGX 6/0biJltYAk4HNypSCQcdGNMeYk0tbYT/rjs6bUNIjG7eSh9MTdrlJotkLRA0oLZ3UItC24EVxOZ i6SP49z4xPJ0cIZXV+fFI8T8Nfp/4pZ3vQCWgMPBjeAJUG3up+5+vLEDazvgn4V/0UP13lbaeU+W Wmvkohtp8Atd9L/ByJYwjvr0FPzxwDfVwy5qqwwkcqZVzEW+g5HdgWQZc6QVmEcWupX89kSgteDj yD8iF52Gn6kriO/P5LRGbj5UTV8Df1LwarLZZPAavLEEnXbMhXfh7wHLvRwo64sP+2aWYmCnjn7g p+oNP7nULlKfBFYqH2invHWU2C4nTgqI3m3UWulfpnXtJbRKn2bcfB7QzNlWUebmbubUbuaRzo4b 4Wfw9M9eHx+hPQnqvoL+K/iZDOM/qv5RlFyt6I5X+4Csj+YY9BvBb0C/1MseFeSBMl0dmIMJ5M+C V4E38pa94IWsfjqaWYt4rz69W0dZZq7yOR6qzdu8nDxX+GbE5E4keeD7gWt1fMm3LxLP95O3l2sW 9e8iJneopr81sZetEhk7jeEczee+be4slrOyrAiMyy71sOSB1cTYamalixuZL6vBjawgmqtzta74 801qTWQGTSQO9S0/0FZZ/fWp1d/NKrbsVXzXMcd7UWtl4DPyg+p31dZKJKvkiM50ifB3dWWh5QVe /pmIpr5lATgDXB+4SfnAz5i5A3SVYebu52mlh+4MVX5woC1PTyA5QfvVw10COzXX0doXdDX0/Z41 MZfWnkf+Gj6/Dj6PvhzSnZI50Fb72+2g4FHdPZrNFWW8JpJVdNTm0Me5OtesW1kHb1a08myRmG9j +Tk0T2H5T/B/gu+L/W3qeUG1XEibRyoaS+GPgff7Gxi6r1D7dzBSbbCw3V1/dR8l+4QHyX4a4VPY vRyzM/RC4+3rPJ1Dy3fyrjVYy9We2n9Qb/jxif0Z4ztG13erqVqz3lXevgO+D/2tohefkSs+Yybm 0k6yvVmpLbQ60/crvNZqS/Lh29myd/Vtpte/tWU36LuTtm2hLtFudrNH6Byn1mDdA5uDrY8Fn7Hv Fss9GMfltqPxaT4n/G6sfeShWnsRO7dhs8C2BT9UlKi7ztBdmXjAysIPL1FrFDidGDhqq/eWYKE1 +HPsROF/QN9fwM+96GOGWh+B+8G0ekx2WdqLSbprFf4KjQrWoIexVkw7B2Mn4J+lGcCLRu3dG7Tn bOAGRf8p8F1wDfJ8sFBzgrvnVE2zI9jNv5d1RPk+7i4UOzvBzdjZjJ3N2Pkj+gn0EyoxS5B0RxJ1 d63KG9XaEsF3wTXI8+FVv5G7s+Uta1xkH9UfO/21rnkv/L0ur3YE1yDPB69D0oL4Yb+BzQ+xdhos BxeDi2xdAftisy82+2KzLzb7YrMvXuqrlq02qmm1wQPrsbAe/nX417UX4tW5tF/xN25/lZe2zcXO XGqdwoJKutLOzzzcyszSNgzy38Js1dGZaOtuc513OtC3bLT3MGc5Haim4e7kD7O3b84poB/4Ntaa Y78a3AMuou4QsA91VyL/CNxmS5QG8rVfgQpFO6M69nb/KpnpvCswyq/r1DB8VYIH/o5+UL0aqGBe 30prdxInH4LTvXPKXkZnEzG5l1Hbi2eIT51l4oFWOlL+awSf50xkotkSzZ3wk3l7dzfeGIuXVWJZ jJSFvD/6H4KfgeXgJnby5YEjvEUlF3RcZHyVP+IhYw2/0o0clUgkFDKChYy4nKONydYf5FwZ9V+p GJBz6/l3dCaef8cvo2w9x05pq/rEvl3XHTuuvPUa+O/Iy3U/Zr9IVkRf9sa6L/oadUPsix5C8y09 b9qbNUtbnB+te/W8bDfm6W+o9WvFrGuRN8XCOXAR+kXESamOhfW6+tY6AN8X7KRo5+kY2fnERhn6 bxJR7yn6F6DTiajIVU3rKUb2Y/gMT2/maTOipTcW3LPqIrAf7+rJruBFVsA+6jHrQ1aQMnLjBlaN Tbo/seaxI53GGjSf/eF4JE+wq6nCzlpwN/gu+B52DoPbwUdZm95jnV2p6H8LvhRcRXatZg36ie7f 7Lbs4t7z+BVgBVgGVulTPXn5j+H//mg2BG8PfEfQPZFxQrRWeVgBloFq4TU0x1LrdZUIqmSgSvwP EBXD2Os+CobAEnaGo9h/9uFMyg7WbkX8vMG70LTKNJfaSAS1F0exfKOHK8AKsAwUa/6b9UwaeJOY 2exvKrWuxNo8MAZyPrVz6Ptj8Cs8XAFWgGU81X49pr6y1yifdV3gF+AQtU8t20P1D2cEa5H6werJ rm+8hy+AJeBwkFjSnVugAeP+PTT7aG703+jfLPwn/rcEf4F8j4cl4HBwI3iLxhtPNyHZhOQp3eta r+oM9f2IvXRL8Jvgo+wt8zgH3c7etR274mlE1KNE7DTdB5p9sPwb+Mc4vS6nbR8g/0Dt2CHaf0Al 9rUevgCWgMNBnV83aavsr+kZNvCSG/M6I8zDWLsSnMcOYQLzKIf9w/eJ/+d5+p6HL4Al4HBwIzri T/t6fYv/Lb1XFFSdVdRaBZ+DB6rx0vv+CuZCS33qIifWI3pitY+qxL9GW2KvgP8E3iZObPTH+48z Ci7q6fUdPb2KNzQqttsTaJtGrAG/ipav4qmbRXuAV/pzBA0dL3/zwD3Cz1e5/3oi+QPwMS+Xauap JJfOQGcK+i8z4z5mHl1JRu1KBp4D/4ZmYIkrqeVfx7hswianV2smlh/GWlv4FXr+lROuPi1Bs1Ix e41GeLbBaevnWObOJMvN9r/jdFPGDD3GDHqd2XEbyOnYWoyFl7Bm2E9IrUrs/FbbZnNPZXMilrHQ NTTOWfgR5cVCFbibeV0F7ma2VoG7ae1vhP8Zb1yJl87pHsB6juy0GbRp2xt6RrZ/BY5WtLg5sbYG ntT1jlk8A/519F+k7s+Y6WUqCaQ0GwQeQv4W+gfBe8F5gWrFrKG60qHza42crGvhm4KdsHYO/Wdo cwNdHewmek9l3+LPJX6UN7Vt/hM6+nYT5s5497xJPCzyb9E4Ubn9oXem1hvLCs44tzOv++oakdWP sXuXkbpD+UADfyN5eoY1a5WeiCV6NSf01qdZ/VhZ5ulskny1GtxIXloN6hpayD1SW+QHkB9A/gny w8jfQz4Max/wFvfkNZ6VcTe4St/rP6g9CnAfay3jxD2fNW626pv/oedryXLD8fBntFnz0u161g40 YtZXMbvXKoont5FnbqElitt5eiX7oit15yP58Dxz4QUyhj4tBcu87KG19pI33tRzt+jMQT6H9pOv Ao8Lv4I2321fK/hLRTsP/y+lp39kdMagc7+nqZKWnIPe1j7aV+kZ2eJW2XJPbfs4tW0hJ/8QP7Rg 3NtzLvsF0dLML7kokE2tz9ghvKrncX/GlpOFPY0cO5K6I6k7Fb5c32V+gzcWMy4vcup36NFPOOHu ZkbYSH6mp3K7Le38LvoneSOt8k+GH69nc+vf4F2dh7HQBfye7pdk36izcpV9ja4LtPAj4tw9Td9F JPSl77dYldKvoWonMBocp2jPsxeTOXVGfEt5/1j/WFql/hyMjvv3jjVkM78+tR7RVczvw05j/L+K Fv5az93W+/Cf6GnduhW+r57WrVfoy1e0JX5mkH2/3Vwkc2n/BOsTwcctiQT7mP6VJ/Ar9oQP6mld eqftuVbP7NYUbD7iofqwEXi/ntP9q8Dv6DnC+i/te6ApHijkDH6IWkV6Tre+Cr+Wp6dpz19o4TLk f+VvGXnqmUBr3t4DHE5/R4BdvL2lrqrNqbVNT+7mH/Tkbv0E/zTn/vAgLXwQLGR0nmIcQzpqEr2C 5mIkLWjnHE4xM8CeLs8JZQZzbQYnnRl6qpKnchLx38SOeh2aPwZf9z9BPlQ+CIZcxEIICyEs9EWz irNeW5XYbZHsRTLHlhH3Ude8AXyS8/K3OS9/m1PY7ZzvfqFnJYkE0TdTaL7HG5uy/2yPtfZa1+4N P9FFJBPVmuAa5Pngdazs4hn/TnqXseVUaD2Pzdux7/auB/hDPXtK++kFNttisy09raKnVeor+361 HOjt3wX+WKMIC0tdxD/F8P3wQ89AGF8pDuD8/r6e36UXYb37snfy3jAz6I9YOIW1sK5W2irJPIrP 2TcKPmBPEvlYMirnZTlf69OnwBZIetiThS+xtW3tkZBv7esYi4/BvypaWxX92xXt9uBErevvwFu+ is3+YDdwAdbKXF9h4ROwNR5+DHxYM17WZvVAdhR/nuHc9xC39A8rnxVg1XtQn/pvwsNb0ewNH1c+ a7Nay47qzsRfw3nwdvrlxkZXRrk34/I8fA4WuqPzit4PWEXqfzuXUVhKbFyvq5h1RHtnLYZvDF+K zgGwPbXywRxGs6nW9c/XEfcvQN4JzZcY5aeUNz9GcnugC/iMxhuazXU0JU6eIAcq7sDmIvgbaXMO PvyhykXzDK09wwzlL/UXXjZ8hnXhbfjF+rdssODCS/A3g2X6V3Lv6cvgfPTHwbvYDJyB3K27BH4J 1haBHyD5AH4fOiI377mgN6LtwSfAMWBPcB9YqugzFY3TSApAQ9FKwD8LLgSv8nj9q8Fe6p5CMgO8 m1pPw+fw9CB4FglvMQch+QTetd+dt1eD7/H07+AarFno9AfvRf6hx2sbypEsRtIX/gK12sAfAdeD r4PH0QzDn4EPwNeAzcBDNW10Z0h70Df+phLL9UwLMFclPnrtux98B/l++EpwBzqu9+6puUssdHbH QnmzJzgXnOeOAnwBaIDPggtrdHe6zvW/Snyvgqd4+nssz3Z7B3+N63l0atC53u0LkoO06gj8Tq8v d9GvbKk7jrrjVWLgH9/jaBbUROnFHFo+h9bOoW2KM5CcAo8juV7RcPkWYC54mDe2AvPAW8GPeJcb gTPh/wzm1vQSHAx/NSM72Y1JlZtL4NvV6On7XfhuyIkKM0sxQKQFHlW0V2HhvHog8LDy/q2M9ULX Mxee0782ov9TNzawNpM2fIbO3/HVPTorZU41I/4Vp7ujfP5TnXH0dIyHJpgneA3YEyzlaSnWSlUi /lR5H+QFoOFhnq4L8M96qJpRvL3X83weozAXVP5ulVtP8/Q0tW6jhW6En6ZH+N/3vjsi9PRFN57h HXSW46VdbvZQX9m78Zg7f3PgW+CZ9eivr7lTb6Xgx2DnB/AvKFrMYqs/EXgGv83gKaPpuw75cfWh 7xxtDuC9XHqUjZdqFCWuXF77iK98PwXdOHzQwzzqzsWO6r+DzV08fRnEn8ZJen0MfAH8/YWrBc/T xwZIXoO/Dj6PURsIv52WH+Vpc+UlY5SL5E6ePgLO4elcPEC0W7fCuzM9Vz1m3ozcnRFvg89hOY6F OJb3eF5S3s1s25jXG5itHzEKZBWfjefvwI6bCbeDf7nQST0Jv9XNgWhOQfPrbg7kLTuRM/vsCcyd zfCfXegr7XTXkflkm3fVV/Yd8H2QV2HnM3gyoXkF2BbMd+csOpvB33rZ6TZBVgrfFnSWuzMaJAOY z+ClHujsBt28QdyarAviVTlTWMx930vgKNDNFa3Bn4M/QD4avheYIQIfQ/6ytxZoPE/yePWAu3YM Q58cYha7awqjGcD/zcAZ4DtgJUg+973GeF2AfwM8S90d7njB40nfJ/AJMIqXquEb8XQNfH/w3ppq bSHyD7E5HVwMLvLmr/sujfzNRH41M+JesC/y9fBd0Z+INdYd30beXkNssDL6yORWczTXEC3wvmqy 8R74RciHwLt5ldEPVBBRjcEfk2HYnwRaYs3NSPfS2tcvPK9/Y8LChZqf0l9B3ybwLHl4EJlkMfgA mmfJww3pi7tO5Xh5NY/Y1szQHUl3vNedrFKNvBF+WOOh5l4Lzf4eqoVyni72MI91ZwQ+zKOdmpfy eLoNfJ26A7ljPM0dfgtuGlsEfiOaDb1v1+i3U7rynZzz3C3frN9y9L2jaFbw99+NnD25ofL92dZv 5qzjRMZfW8zegSt1pvMXnO3Km2/Bf2rv46zK37x0f24MNVvpuOiNhNXGTuvb7V/pHkN5s8r+q0aj ovWpvdDQ+yXRNPYr+lLU6qfor+BOIwB2sMfr3MRCuS37XmsYFs7p08Bgag0CO/P9hDNgtp2rI279 UD1mbVAd5c0J+l+4mCMUrRLrANZE09ii6Mt3ayHZpWifUJReKM63fqa9wE5vvVUwN7l2eDpE0T8J C2fAA+AUcJml9zltFM1KS0/3eXquN88gaeIfSjv1W2QNVWLsUt7Yryj6ym9RfX937ORRq6Ol399r Zc3W0bfm07ZFeqdNrWVgNyStVd+/llqHvZbo0yFI5lrjNNsg7+Ghfo/I9qzNVy/RthXK+w7SHsv0 KfpP66/ewJumqRLfWp7qN5A7+Q7xjVn9VttAc4pge711MSvNpzXrmj/Rlpu/1nmtvPmk+aRgqal/ 3TZV3zcDHKRoPYTOsybfdTSnC95iPSX4Gnw76yXsCO87hSZ1zbup+zT81Vg7pVHq+xNvP2terXPZ 1KgYYjajnY01/k3+ym8GRHKX+RWdy+ZNOpdV3xcF71E0/qZoWVjoh7V7zeaaM813sKl8tfmhrhrw i9AMY6GGul+DPwK+5VMPL6cNx3xfF80OPr3hlLwoknM+/Svzed9pXQvMjppXzQn81V5/Wfa476C2 R9F3l9lUJeZKXbl8f9Y1F2wBdlAUa4LGh/DTwSa+A2ge0JkOv983TlcTbL7jWyD4jO+Puh5pS4yP sPA3bYl5zjD0W+j2ScVADvx/wjfi2+lXwn8D+atIxI79y4DYtIeCvcETitZRcLGivyHyc4qmDf4M SWt0vqcY2ItmGzDM03z4YvghaB5BgtyeopjVEv4mnr4JnkbCW6zfwcfhJ4ADkUwCxyr6aK3Zg6dv wx+kPQF0ZoAVPN0I/xr8x+AA8DvI6ZF1nrqutW3gj8E0+C6aneHpl/VfvPH78Btozx7wGJJfYc2h Vlc0tyK/Hn4J/Av4ZCX8o+CL4M3U+mWWrD6Ba93RUd4+AV5wx0h5f0Mk5+DvdMcIyUx3pJS3vgcW gyVYe8AdL2pluaMGj08Cn7ijhv5i8AhP8xWzWiJ5k7bdguZUMOP6h7d/ixauc32iElkTlXc9hp/t +WB33oi3fX/lKZ40K7FA1PmfATehPw/cBUZAem27kfYC7SxF/0Ys4HN/kDYQP2YrYu8K9A+j8wp8 TzTdGOsFBhWzX9G62V+lnRY6fbHwWzAH+bX0ujWe2Yr+szxljti7qXUD78K31jPuvMOHe6mLb+0p 4E3Y+Q06HbGPP827qLscObPM78Zqine5M7GlG3vY+T08muZT1DqOzr+DboTgPWuUG8m893p89X/Y +w4oK4qt3V1V3afOnO5TDDikIUjOwgwMSBIFAUkiIAqSlBwcgjAMiAiIZBGQJJJFkoiYUJEkcchB cs45Z2FgZl7Vd9p7mdH39P7e/19vvXfXWevr3bt27a7atWvv6jp9+iwyyG6CMwXXCvlhaWAFYH3U 3Qm6FDSUBJ4HPgB/CK7VGvTL0IN+2bi6XQaSo6BnEmhYniM+WLOB8cBXIBO64m5gyEOWofRNIMZF ZMUVuwJheQmOdRtX7AN+KKZhDlqh2Y2Za6cDJwMQkUHAKwS08VCkQlThNyCPulYc8HPgfPBDsRG0 2AHOBtDHcHX4lcDc4bdQC15nh2ZTqEcrIBOA/FRwQuO+EvwGwEgg2iwQM33DoDPUKniFdRiIOWXB Nxha7uuPWu9APhE0ZqLVF3gAfIypgP3tZuAjRlmIWhb8gSOqW+2ASyF/Bz4zAP4TilcLgIhFNuaR eB+cUOS8hrqhMcW4C4yUD74kmgIx18QYILxXbjfoh1fYyF82vN0Ha0v03YdSC/ICMUqUA75krk5k 7kGsT5PNt0VNgFWBVwyKC8AvDdou+I8Mcgv4ITiFINPcoG8/JIsA66A0D+hWoBtD8hw44FsjDMqc oAui9GfgHXBwFbEFdFvQA4D1wBkI7G2QobW8Eko3gT6B9vgg8xFwAUrXg/4G9FXgS8DXwEePRBLq hrRtBb4P7AjcC8kY0OiXeIgrvgV6HdqzD3gJnM+grQ1qlYXkZvBzg14EehpssgR0L+AMYGHUzYa6 KZB5DvRYlHYD3QJ8CURffNeBJVA6EtgJ+DxqrcJ1s6OFoZajv9YsYEXURa/ZTZSiR3w56mL07fHA BMjPBO4CvggMtTA04qF+9QPmhwb03VbQiXHkBeADYZA/A5kvQD8LydBYVwGilh+l/oxop4DMC9Dw IzACpRNAwzOtPZDJB82wjED7xXcojYIeWIZXBn8x+PBeO+QDHaAt5OEhX90GPmT4cHAuo3QcEKPD YQfRHTgF2kLjWBpYAVgfpTtBl0KtksDzwAfgD4HO1qBfhh603MZV7DKQHAU9k0DDVhwzy5oNjAe+ ApnQFXcDQ2O6DKVvAmFJkRVX7AqE9SQ41m1csQ/4oWgA77VC8wI+b6cDJwMQc0pgHAW08dAcx3zk NyCPulYc8HPgfPBDUQW02AHOBtDHcHV4goCH81uoBT+xQz4f6tEKyAQgPxWc0MiuBL8BMBKINgtE G98w6Ay1CuNuHQZiFlgYfYaW+/qj1juQTwSNuWP1BR4AH2MqYH+7GfiY3RY8gSMSWu2ASyEDr7ZC keQa6NBIYTQF7O+Dh4imQPi8GAOE78nt8H+MtY14bsNXfbChRI98KLUgLxAfRDmDdJgfJLMrsl2X 5gvtY4hRmlMD993tzG6DmIWdhJoonW5+GytymefTxCTspXDD4RfBH2X45gELMr+2MJxmBu1dBq3i 4N9B3W4ovWDQ1x10O2ANaLsWksR1G3u7GfnI7FGYe8Pp4Az2djyK47d1ZhelFvZPErEfEoG9kYXg zzZ1+U5w2qF0ImgODdeA8cD56LtrkA+ABRqaHRKegF2LGNAx4kdT18hQCvYrnvD2TzTSSSNjl4Se BqhVFTsk5Q2HPWFN1fxM3t7IQuyBLMR+iMbksSlmn6peynYTe0E3Nve2fKehWTXQTVBaFfQK0Acg 2Re0H3R5lK5FrUvgZAhpA+dUsrnTLwaZDKgVBWyF0n0hRGkk6ESUfgIN+cCfA34Z0EVQ6gPdHvTQ UBsMzQ6G2oDS3oZObpByT3tCAXC+pawaD4GebmiRDvfyKQZFJeAtcBJBT4LkcYP2LoMWA58DF6LU b5DdAX0NGAV5gswoYBHgIJTGow3jQbcCPR9XvAyZPqA3ojQWegLQvwY422u5aUkncJaAsxw4Aoie ihooVeAMSF6Gf2E3mlcmm53AXNDcxWuD4R8xYyQqGaQjqLsIOAbasOPBz4DT0MhYBZLNs2rPorRy 8jyNyVRH88MhE204/EaozdA8y7TBlwOcFYZmY8BvkPyN8U8jb61D6T5TqvtuRseF5gbgZ4HO0Wh/ tpRE3c6BaO1dtO2QqWV3Q1/OgT8TXtfP1GJlcK0+oPNAT1TyI3yD8MjYEzjCoF5NGTwBTnbInAOd waB4Hq2Kwagl4Fq9obkdWnjCoM+CbQuFPCTlFeN1RoZnMBzz/h0dITHLrHDTF18WyJ8ztF0dMi44 TUJ+CGtnx1VcWCaDsRgbgl43TjZ7s7Fo4XzQgeRGxseSzW7nE8C6uHoCrFENdCsjye6gVhToe5BM gIYxoEeCvw/W2Ap+AXBuo/QjcA5B20fgPAvJ6wZ1xMF4hfwQ7a+DvpxEG07AE0KePN70Wt8FHIOV MO7AARipO5BPhobiuFZ5lEbBf06AX9agju9mXGp6MgbPwAd2QfPOkP09a5iWV0VfTsBWmcAPAhtD Mta77iPMi0fwvVvwhJCksVtOQ2vfvgVPNjItgGPAaQTJSFwrEpLbUSsBMpOBS1Ba15u/JXVffGjz YvRxG/jZgT+jPR1Ckuhvl1CvjaT2Iuxaw6N8nlVnwathDWMZ1gGaJyIOrIT11njXMnpKYqQyhSIV al1DrTWQTIa3R0FyMTwzwtC+PJQOnrYMI27aPzU0o705YrQ1wxjlA76BFl7xIl5W5Bpzla3enJ2k S78OzWWjTUfLiWhVSdQKxVWjeRB2ia9RG/hVG5PTU+pr+lV43SXIIA6I0Dwaibp1+RZ4/jKMpunj qlBshGR/8BvC8uMN6ri0DLHCRJXQiMwH+lGaC72ugv4eA44CPoLmqhiv54B5gLU8GRPl+nnjaCLb OBMztT8sw2yaB694hG9yH8FXH8GfH2EsDH0fdhvgZbGs4JheT0ZPK4ayGGLONYzOcoMSXiSRZcQF SLYBIsfRDeOHeg18FDHwFmKgiTAN0c7y8NIo+PBOeDVikZacBUkj/xX4sZCsAbo2+LPR8n2gF4Jf PXkPsBtm3y2zJjdXSZ6Ucgrj1cDMVozpi+hXnlBeS16L7+szmtai5QPRl1yQbJCMNQ/qZqecWmek N7KaTvrSaCbCe97IMr/T8XYaDVIA/IDhExlOclPzlHVyE/MkfDJ+D5IcAB0NOhp0KfOcdnKMeZZe 87uBvwD06+b5MfNkvqbXg74G+oqhza94dN2l5i034MeYpwG1ni/wbpa7eL/NcoPmdwRE5nfuyRHm 1xzJEeb3IMnf+mLNW27ke+YtN4ZOWmHo5IG+0eYtN/KG0e87Y1BeB33Y6JcXQD8EHZKpDywFyZbA Nua9N6ZtSSdCbfZ9DPlZoEO1LqHNd8DPB364QfkcelcceB39HYTSxUAJ/tOQrIJrXQF/M3SWBKc8 LBPiJKK0KeRH4IqbYaVEYH9cvTIki6KukYwCHQW6pG8j+PdBF4WeEL8AWvIq6MKgX4Oe/Qb9EjTe 5OP3o7QpOMOh7SfzDhxoeBoaokFHgy5lfi+v5X8BnQmYEbWqoc0l0eZWGOVp6OldlKJtvrngvA5c D7yD0swaS8ivQH8NnStBj4TMd8Bx4C8GvQv0bdNC8xYO3Vrjh6XwvbxISgENu5lv0pOjky6a9iRh LMw375pzy5QmrTCWDHGS+wNzAVELGqKT1kESdZPQ66RpoM9A51rQ+0BfQyk8KukgOOehxzyBQxRg w/yXSLR+u3ssRbTv3vZN6hfbMq4LfUv6zu/lBlVykb6zSEmhjOSSj7JTXspAxak0laPnqBY1ouZa R316h96j1tSRulJPGurJB0lSDspHT1AJKqO1VKba1Jha6Ks2oL40UEeOTtSN4mkY/mMwVEeRX8eM /BRBUfQ0VaAqOjq/Rq8Tp5fpXXqf2tKb9Bb1ouGUiUTNevVqUK0GL72Yi1o1bFA7F02Clsx4Z+iT OjYX0BqjqSI9Ty/Qi9SE3iBBRagh9aNB1I5iqTv1phGoE0a5qCCZTPcMVaW6VJQ+AD8LhWs75KZI KqT1lqKyVImqUQ16iZpSS93uYvQK9afB1J46Uw96m0Z6LUhPDuWhbFRYa4ihZ6k61aR61IxakU1P 0as0gIZQB+pCcdTHvMu0dckercWrwBbAdsAuwHhgv9YtY+PEEOAY4GTgbOAi4JLWLXu0FWuAG4Hb gXuAh4AnWrfu3E2cA94xaHFgODAnsBiwfJvYju2t6sA6wAZtunTtbDUGtgC2AXYCdgPGA/u2696y tTUQOBI4ETgTuAC4GLhSK25pbQRuB+4BHort0rOzdQJ4DngFeAt4H5hs0LZiu7aOtQPAcGAWYE5d 2N3OBywCjAKWAVYEVgHW6Gr01AU2BDYBvgFsB4wFdu/avU0XuzewH3BQN8MfARwDnAicCpwFnA9c 1EOPkb0YuBS4BrgRuB24r0fHLu3sI8BTwAvAa8A7wMQenVt38xEwAIwA5gQWApbs0SMq2lcRWBVY B9gQ2AzYRmNJXywwDtgXOAg4EjheYynfVOBs4ELgYuBy4DqNMb6twF3AA8BjwDPASz16turhuwG8 B3xkUHKgH6h69OzWQ0YAI4G5gAWAxYAl47QlZVlgJWBVYC1gPeCrQLMa5zr2RPwLR6HneTbK/l+i GF4c+n9GW0cMW0dRSf5/25mFsxDNdNRLi8G/iELHOQfvXP47FNPR+48xw19GjhHhWqs5w26PyQ9m lfiXMf1fxhy/w/C/jLnQUoEjewxNDx7nqT9FoTNVJsryL1KZQXGdn/L8S8e8lO9fOuanAv/CkelM +uf45zZhOoP/Oab7SxitVxtxOuuPp9m0mNbRHjpDd5jFIlg+FsOqsoasDYtjg9h4NpstZuvYHnaG 3eEWz8nr8D58BJ/MF/ClfDM/xC/xRBEQkaKIKC9qiSaik+gjRojJYoGeg+Za/pDPirppzlulOR+Z 5nzUY+dWmnKfnuYHSLLHzgMxqc/dWanrq3up9Uc0SX2ekVLrzxiR5rxAGvkaac6bpTlP05+Mh1Kf ZyqU5rxemvPeqduffWbq8hzLU5/nL5bmvPhj53r+5Y9KUz4Q51zHhwyhHhasFzoWCvXc0j6XSceq Ah53p3c85B3PeMcbfyRd5FvvuNw7JnjHXalbUVSl7mXRpanPSwxMLV/iSOrz6K2pz0v+kOZ8Serz Ug3TnL+a5rxbmvPuac4nPuZlmigzKc350tTyZdKM0u/Kt6c535nmfFfqUSy3XaPSlmnNJlA7NhXR tpX+kJ6p44nZ4XZ65IoM5HNrqgS3hlqnVqk1muNjV9lVLXeD3SDGbrFbxNlddpeEqqwqk6WeV8/r vGn8gYtqooa5Hs/AM2qO+QWRMu0RQV2zuD7PpO9GutNUSqATlMgidBv8ulURbn3ibg23gcaa7ssa a+nWh+uYnEvfLUTpe56K6gIJHq7bdBHHBKXvtHhGfX4ZxwS1j7g+O6AxQR3SuFH31XhoJOVRJ3Rb V+nSkzgmqFP6uEafn8Yx4THJM57kWU/ynCd53pP8rb210d46aO+LaO9vJXVR8hJK6j1eojajhVvR wu1o4W8lO1GyCyV7UMJJcv3R08zh5sntcB6urZpRW1W41d0XtNVXqVXk021aoy0ltIT5NjKU9fXU 0vVbYrwII8VYIkvUo5bCUrS1bK7XPdBrQ68PeiWP5JHk53l4HgrjhXghCogaejQdu5Xdily7jd2G gnY7ux0pu4PdgdLZ3e3uFG7H2XGU3o634ymDyqVy0RMqj8qj+5RP5aOMqoAqQJlUIaXv+VQRVYSy qGKqGGVVxVVxilRRKgrv5S5F2VVpVZpyqKfV05RTlVPl6ElVQVWgXOoZ9QzlVs+qZ/XoGH/LC3/L p15QL1B+1Vw1pwKqtWpNBVVb1ZYKqfaqPRVWsSqWiqguqosOFN1UNyqm4lQcPaXiVTwVV71Vbyqh +ql+FKUGqAEUrQapQVRSDVVDqZQaroZTjBqpRlJpNUqNojLqI/URPa3GqXFUVk1QE6ic+lh9TOXV J+oTqqCmqCnaP6epafSMmqFmUCX1qfqUnlWfqc/oOTVHzaHKap6aR1XU5+pzel59ob6gqupL9SVV U1+rr6m6+lZ9Sy+oxWox1VA/qB+oplqillAttVQtpdpqhVpBdTDeL2K862pfWUcvaV9JoHpqo/aW +mqz9q4Gaqv2rpfVdu1dDdVO7VWvqF3aq15Ve7RXNVL79BxprA7oOfKaOqTnSBN1TB2jpngndjN1 XV2n5uqmukkt1G11m15Xd9VdMu/5Hqjnx0DtSelYOurPIlkOGoB/Rh3EmrBmNJjFss40DP+GOoK9 xeLoAzaCjaDRbBL7hMawm+wmjWX32D0axx6yhzTeBBmawH3cRxO5y136mKfn6WkSz8Qz0Sc8G89G k3lenpem8MK8ME3lUbweTeNxvCet5L14L1ql1xF9aDV/l/ejNXwQH0Tr+FA+lNbz8Xw8JfCP+ce0 gc/m+2mjCOr480jEiBhKFlVEVUoRNUVNxsU0MY0JK876lFl2a7s1K2m3tduyUnZ7uz2LsTvaHVlp u4fdg5Wxe9o92dN2L7sXK2vv9g1j5QIvB1qy64GhDmPJbrhbjb/tNnWn86+CbYKd+O1g/+BInqi4 8gu/yq1yi3Qqr8orwlV+lV+kVwVVQZFBFVaFxROqqCoqItRT6imRUZVQJUQmFa2iRWYVo2JEFlVG lRFZVVlVVkSq8qq8yKYqqooiu6qkKokc6jn1nMipqqgq4klVVVUVuVQNVUPkVi1UC5HH/Dm1yKva qXYin+qgOoj8qrPqLAqorqqrKKjeUm+JQqqn6ikKq16qlyii3lZvi6Kqv+oviqn31HviKTVYDRbF 1TA1TJRQI9QIEaU+VB+KaDVajRYl1Vg1VpRS49V4EaMmqomitJqkJokyarKaLJ5WU9VUUVZNV9NF OTVTzRTl1Sw1S1RQs9VsUVHNVXPFM2q+mi8qqQVqgXhWLVQLxXNqkVokKqtv1DeiivpOfSeeV9+r 70VV9aP6UVRTP6mfRHW1TC0TL6iVaqWooVar1aKmWqvWilpqvVovaqsNaoOoozapTeJFtUVtEXXV NrVNvKR2qB2invpF/SLqq91qt2ig9qq94mW1X+0XDdVBdVC8og6rw+JVdVwdF43UVXVVNFY31A3x mrqlbokm6o66I5qqe+pX0cy7lzIrnxjE2sLanW3WnDXX7LasLTHrR+tH4r4kXxIJfyV/JT17/j3R WHvuf6Lx/+fR+J/eFwnvK2JWW6yj7/B/fOw/PvZv8jFmd9Lr+XCWh8eI6lZjyk7lqQrVogbURN8v dNLr9z56PTCCxtJkmkUL6FtaSmtoM+2iQ3SKLtEtvbIn5mNuWG8SYT3C4sLexrFnWB8c48PewbFX 2Lv6GKepfjjGhfXHsWfYABzjw97DsVfY+/rYU8sNwjEubDCOPcOG4BgfNhTHXmHD9TFey43AMS7s Axx7ho3EMT7sQxx7hY3Wx15abgyOcWEf4dgzbCyO8WHjcOwV1pe4Lh2osWfYMI3xYaM09vobFpmA nvcIm+hZ5mPPMpM8y3ziWWayZ5kpnkWmehaZ5llkhmeRmZ5FPvUsMsuzyGeeReZ4FpnrWWSeZ5H5 nkU+9yzyhWeRhZ5FvvQsssizyFeeRcbr/vcImw6LzIZFFvxNi3zjWeRbzyLfeRZZ7Fnke88iP3oW WeL5yk+eZZZ6llnmWWa5Z5kVnmVWehb52bPIas8iazyLrPUsss6zyHrPIhs8i2z0LLLJs8hmzyJb PIt8DYv8AE9ZBYsk/E2LbPMsst2zyA7PIjs9i/ziWWS3Z5E9nkX2ehbZ51lkv2eRg55FDnkWOez5 yhHPMkc9yxzzLHPcs8wJzzInPYuc9ixyxrPIWc8i5zyLnPcsshUW2QWLHICnnPqbFrnoWeSSZ5HL nkWueBa56lnkumeRG55FbnoWueVZ5LZnkbueRe55FvnVs8h9zyIPPIs89CzyyLNIkmeRZM9XUkKW CVDIMgEWskyAhywTEJ5lLsAi12CRO7BIovEU8z+Npt3YTWtMhdkuPkPUES+JdqK96CTeFD1ET9FL vC3eFcPEcDFCfCBGig/1vcspcVqcEWfFOXFeXBAXxSVxWVwRV8U1cV3cEDfFLXFb3BF3g2XM/yix nWynvsB08+tcUVvUJi7qirokRBvRlizRQXQkn+guupNfxIk4ChPxIl6vBHqL3uSIvqIvuaKfeJ+C YoqYQk+IpWIbRQRLB0tjlyGSAlZO60krl5XbymPltfJZ+a0CVkHTM92iu9hdZ5Tlsb2JotgPijUS umZBTyL7YxLFHivTlhSxWpqsCMu8C6yQVYgc77oRVkYrk5XZymJltSLNu++0xD+vyykfpbMyWE9Y tuWzpOW3wqyA5ViuFbSUlc4Kt8x+l6X71l83wdTh1jNWJXKtylZlUrqsDGURc8V8sVB8JdaJ9SJB bBAbxSaxWWwRW8W2P7K42S0Tc8QcrXGe+V2z+EJ8oe29SOg4qi23Vl/vlLj8D+1ztNQXunSpWCaW ixVipfhZrBKrxRqx9o/GGNrnirla+3wx3zyRKRZq7V8JHZ11C7dp7aYfRntxivhDrX/QD9jslGcz U+8vehfqGW/Q9ewufDG9T4NoMA2hoTSMhut5/QGNxL+LjqYx9JGe5eNoPE2gifQxTaJP9JyfQlNp Gk2nGTSTPtUR4DOaTXNoLs2j+fS5jgdf0EL6khbRV/Q1faOjw3e0mL6nH+hHWkI/6VixjJbTClpJ P9MqWq0jx1paR+spgTbQRtqk48gW2krbaDvtoJ30i44qu2kP7aV9tJ8O0EEdYw7TETpKx+g4naCT OuKcpjN0ls7RebpAF3X8uUxX6Cpdo+t0g27qaHSb7tBduke/0n16QIn0kB5REiVTinZoxuvzBvxl 3pC/wl/ljXhj/hpvwpvyZrw5b8Ff52/wlrwVb83b8La8HW/PO/COvBN/k8fyzrwL78q78bf4TH6A H+SH+GF+hB/lx/hxfoKf5Kf4aX6Gn+Xn+Hl+gV/kl/hlfkUE+FV+TTj8Or/Bb/Jb/Da/w+/ye/xX fp8/4In8IX/Ek3gyT9EhyDxtL4QlbOETUvhFmKgvGoiXRUPRTDQXb4iWorN4SwwSg8UQMVSME5+I qeJr8Y34TiwWS8RPYrvYIXaKX8QusVvsEXvFPrFfHBAHxSFxWBwRR8UxcVycECetClZF87+t1h5r r7XP2m8dsA5ah6zD1hHrqHXMOm6dsE5ap6zT1hnrrHXOOm9dsC5al6zL1hXrqnXNum7dsG5at6zb 1h3rrnXP+tW6bz2wEq2H1iMryUq2UuygnUFWllXk87KqrCaryxdkDVlT1pK1ZR35oqwrX5L1ZH3Z QL4sG8pX5KuykWwsX5NNZFPZTDaXLeTr8g3ZUraSrfWnrf6015+OspN8U8bKzrKL7Cq7ybdkd9lD xsmeMl72kr3l27KP/vSV78p+sr8cIN+TA+X7cpAcLIfIoXKYHC5HyA/kSPmhHCVHyzHyIzlWjpPj 5QQ5UX4sJ8lP5GQ5RU6V0+R0OUPOlJ/KWfIzOVt+IRfKL+Ui+ZX8Wn4jv5XfycXye/mD+e9X+ZNc KpfJ5XKFXCl/lqvkarlGrpXr5HqZIDfIjXKT3Cy3yK1ym9wud8id8he5S+6We+ReuU/ulwfkQXlI HpZH5FF5TB6XJ+RJeUqelmfkWXlOnpcX5EV5SV6WV+RVeU1elzfkTXlL3pcPZKJ8KB/JJJksU/zk Z3KOnCvnyfnyc7lA3pZ35F15T/4a6B14O9An8E6gb+DdQL9A/8CAwHuBgYH3A4MCgwNDnHecvs67 Tj+nvzPAec8Z6LzvDHKGOEOdYc5wZ4TzgTPS+dAZ5Yx2xjiTnSnOVGeaM92Z4cx0PnVmOZ85s505 zlxnnjPf+dxZ4HzhfOkscr5yvna+cb51vnMWO987PzurnNXOGmets85Z7yQ4m50tzjZnu7PD2en8 4uxydjt7nL3OPueAc9I57Zx1zjsXncvOdeemc9u549x17jm/OvedB06i89B55CQ7KS65zOWucC3X dn3uafeMe9Y95553L7gX3UvuZfeKe9W95l53b7g33VvubfeOe9e95/7q3ncfuInuQ/eRm+QmuylB CrIgD4qgFbSDvqAM+oNhwUDQCbrBYFAF0wXDg+mDGYJPBCOCGYOZgpmDWYJZg5HBbMHswRzBnMEn g7mCuYN5gnmD+YL5gwWCU4JTg9OC04MzgjODnwZnBT8Lzg7OCc4NzgvOx7fP2JHFzmh/PoPrCIr9 zk9FLZ3f94oXdX7fL5qIpnRQtBCv02Hk0KOim+hGx3TGe4+Oi7FiLJ0Wk8QkOoPMfhZ56xzy1nnk rQvIWxfFD+JHuoQMccUqZ5VnhH1TbgfsAIuyw+1wFo2d0ZK+k75z7IKMkjHsGnZJbweGBqZwHpgT +JlnDmwK3OclsVfaCrukc3W2v0VhenWQR+f8unoFNFlngJU6OutLOIOJq02gFoIy39GEUybK7mzQ 5/udjRoPOps0Hna2/kN2v6ZWk1+vJbJQTr0CKBL69sg5aPjOYY1bnKMatznHNe5wrpqaKqPRqDIZ jSqz0QhdSdD623c0YfpsvQpo3KCcVCXpUBKOkvSpSrKgJCtKIlHCKUyPWpQeu7Lc/FtSBV6BOK/O q5PgNXlNsvhL/CWyA+MC48gX+DHwI8nAjcANrY/b8/kv/005NnWG/X87v/7PZFiTQ/9q3vzvzJkZ ZBvZTnaQ7+gMZDJnNZ0z6yCb1deZaRTyZGOdI012DOXGtn8xK/b9k3z4+2z4ic6D/8yAj2eX/9uy 4T+ync6Lk3T+fjwrVtarD7P2CK08zLqjnl55PPDWHQ/1quM1veKYjjXHDL3iSNRe+6r21NeNX/6W O3nn1HnTDXfTuxncJ9wIN6Obyc3sZnGzupFuNje7m8PN6T7p5nJzu3ncvG4+N79bwC3oFnILu0X+ MNsO/uN8q8JUQDl/Kesu/H3eVelUuEr/u+y7wdnobEIO3vqHWXi/zsMHncPOUef4b/lYZVKZkZOv /m+zctLv87LKorKqyP9Sdk6Vm92k/4HsXJdxllHfykayQhTB6rGGlBfflBZiLVhbKsras/ZUinVk HSmGvck6U2nWlfWhsqwvm0BV2WQ2jVqw79kOasW78zh6l8fzd2kA78/fo2H8fT6UPuDD+Yc0ho/m Y2kCvvP8hE/kOtrjHn+6cEUGmiEiRATNFZlEEZoniokStFxEi6q0Chl/DzL+Xty97bNmWTvokp3e Ts+y2Pfseyyrfd++zyLtRDuRZfNpc7HsvuG+D1kO32jfOJbHN8E3iRX0TfZNY0V9M3wLWAnfQt9i VsH3gy+BVfVt9O1kr/j2+faxFr6DvsPsdd9R33HWSq8NklhbX4peGwyUZWQFtkQ+I59lK/2F/UXY an8xfwm21h/tj2Yb/GX8ZdhGfzl/ObbJfH/GNvuf8z/Htvir+Kuwrf7q/upsm7+mvybb7q/jr8N2 +Bv6G7Kd/kb+RuwXfxN/E7bL/7q/Ndvt7+jvyA6E6dt+djDQKtCaHQq0DXRgRwKdAnHsRCA+EM8u 6zw7hV3RefZndlfn2fss2eFOUy6d5k4f3tKd4Z7i/YMfBifztaHnW/Td6CJ849KctfM4PzzGYVSe fN7ao4Be08To8jn6Y3CRXhXMwdGcrfDOVuizo/pjnrIpyopqrynOiut0V5aV1TpfYC/o5FKb1SaL TWKT8JTNRmppR9rZ7Ox2Djun/aSdy85t57Hz2vns/HYBu6BdyC5sF7GL2sXsp+zidgk7yo62S9ql 2G62h+1l+9h+doAdZIfYYXaEHWXH2HF2gp1kp9hpdoadZefYeXaBXWSX2GV2xRKWJe6JX8V98UAk iofikUgSySLl7/As3RWLY6fBwq8V0uPbrCz6Iyi7/ljacgV1T4uReS6thP74tVXL63ViRf0JUCX9 cagqVSOXauuPokb6k45eoyZ6fdhCfzJQG/15gjroTwT1oDjKSG9TH8pM/fUnq56dnCJZOhZO2fQc jaQcLCfLSTnxTMOTer7Wo1x6vjah3PhWNw9mal4Wy2IpH55yyM96sngqwN5l7+o5PZwNp8LsAzaS irAxbAwV0zN4Mj2lZ/D3VJytYqupBEtgGyiabWVbqRT2m2Iw88pgTV0Lu04tsOv0BvbCIh/bC3sK T1NV4M20xXLwaB6tV45leBnzGzFeVZfU4rX0yrEBb6BXjo14I7L1+qct+fTK5029chwWGEH+wMjA GHICcwPzKDzweWAhZQjsC+ynTIGDgSOUJXA8cFqvqfs6/Si3ziKDKJ/JEFRYZ4hPqaiJ51RCx/N9 FK2j+FEqrSP5cSqjY/lpelrH87NUVt9jnadyOqZfpPI6rl+mCjq2X9VjlbYvxdGXmryT7kvOVH0p x8vpEtMjwevpexoLPbLRI59e5zUhiX759SruLQr7X+1dB1gUybbu6pmBYUKTJYokkSg95CRIVBEB AcWEkgVEQEAwoBIEsxgQFVEBcwBRFFBEwIiKAXfNinHXDAImDPCqj6joum/vu+/et9/7vkt91KkO 01Onzqn//Ke7pxv04oFeQtBLBvSS45XwSrFG+3jlhAroqA46avIe8Z4QOrxnvBasF6Npf9BUBJpa gKZWOA5uwXnCNpxtOIDWrqD1IByf3hBDcXT6hDOUz1dfmV85hoJGxoyOzJP2CJtuHY2799HFs3cZ yv26jkQ7USlekvu6H54BPxkDOxKPG4wEG2zLgfEQg/EQh/HgwnhIYN4bQPBgVPhgbQGMjZA3mjea oHBmPpuQxNnXCmzzHN46QhXnYOWENq+SV0NY4EyshbDntfLeEWGYQ8wjJmO2sIyYgdnBbiIdx/4D xCoc668T68HmlWDzgziC3yMOgeWrwPKHwfLVYPkjYPkasHwtjuwtRB2O7q3EURzhPxHHcDwXI85j jqNIXMG8RoNowlxGn/gdsxI+0YzZhTTRimO8Ms4AMBLiDGkKQTAZJOHEnGUghjN32xC+/JkCV+I8 /kxvtPYf3g+edvlv2vurPxDBYFUafN67hz/Q3/yB8CPsv64jCTe4di/3dT+SYPHyeZvxd9by6rGP d/CZmYPXQpb/uSca0Ae6u5df+mqD0eyfQHf8SXnAQgKwEAEWsgAL2YCFHMBCMcBCccBCLmChBGAh D7CQD1goACykAAslAQulAAtlAAtlAQvlAAvlAQsVAAuZ3zYfxRoIyMGsQ8TAv7wWRCIeksG91ET6 yATZICfkjnxw74JRFIpDSZg/paP5aCnKwd9agLai3WgfqkRH0HF0Bl3EY3MLj8Nj1Ixeofc4AImR AlKGVCTVSG1SH4+xBdLH2uvisTACOQZHYEYGIGuQ45ENyAnIFmQgsgMZhAaADEb2IEOQA8hQNBBk GHIEGY5cQEYiN5DROKozMhZ5gczjKDCSXc5RBFnBUWIk9YHLZyRHlitgpNhmrhBkNZcCeYQrCfIT VwpkJ1caZBdXhpGYQcmCdJBE8D1RSA+jkSTmGiReMsT1GMw4GP6CMQlriT0R6yjCdSAywXUQMsV1 MMJcButmjutQZIHrMGSJ63DkxNx/gpxxPQm54joacxYSazUY13FoCK6nIHdcxyMPXOehYbjOR564 XseRI0isrzyuKzjM2ZcPXGwYrCn2aqwnG9fVXMx5sI5izB1VXHFcd3K5uO7iShAk1g0zMK4DoYfn 1jgc86NxrE8h5hKLiRwin9hM7Cb2E4eJ40QD8Stxi3hIPMf40n1NEXuSIvZ1bexLNLJAdtibBiNP 5IdHIxBrFY124tHKwyO0C2QA2g1yPCoGOQGVgAxEe0AGY3RnZAjaCzII7QMZispAhqH9IMO5vRmJ dVRjJNayD8hqrjrII1wNkJ+4miA7uVogu7jajMQa9wXpgDaA/TaC5QrAcoVguSKw3Caw2Waw2Raw 4law3Daw3Haw3A7GHlw5GHF5GPFeMOIKMOKKMOJKMOLKMOIqMOKqMOKIYEsScGc5C7CCgJmOJJmf iTBPE/aE+/p1CRPgAXA2DPUCX1MAH1Fkvps5ClL62opgPInBXownueArUDNX6ZAURigCyeO8CgES kYAvTFxVJBagEcgfjUaj0EgUwRuFI+CYz+emyankbHI+uYqVx9rB2kd9pD5RnVQXRtn1vA28jbwC XiGviLeJtxkjbh3vKO8Y7zjvBO8k7xSvnnpLkRSLYlMcSowSp7i8Dt573gfeR94nXievi49hj7+c v4K/kp/DX8XP5a/mr+Gv5ZfzK/iV/IP8Q/wq/mF+Nf8I/wb/Fr+Jf5d/n/+Q/zv/Mf8p/zm/mf+S 3yYQF3AFEgKegC8QCIQCSiApMBAYCowE/QXGAlogEpgITAVmAnOBhcBSYCWwFtgIbAV2ggECe4GD YKDAUeAkcBa4CFwpASWkKEqGkqXkqHdUB/WeUqFUKeY6qA5kngRkmxzMuobimBZFRmPmkIizSgE5 C2eVQrhvloIcUhIyQyk4/yvN2svaS8iI7RErJWTFKsQqCHmxt2JvMWfE+RKhwORLmFs18X4j9Jis CTOp+Zg/2PCLMXNwxhn/dcIDZ/03iWHAHzyBP3gBf/AG/jAc+IMP8Adf4A9+wB9GAH8YCfzBH/jD KH4nZg6jBVKYLQQDW5gFbCGVksdsIQPreYgY849Y9J+z4L/FTl8sxIPRJGA0JWAcZWAcVWActUFz I9DcAjQfDpr7AU/y/5x9cuBtg7jtTjDnlp0ItZ7+/6MX/7k/fvYdfARp8BQCPIUFFhYDe1JgT0mw pxTYUxrsKQP2lAV7yoE95cGevcCeCmBPRbCnEthTGdtNgVDp7j2fQ/XoPYU5b/eMZeY8+CkBforA T0nwU1b3ZwUcyR6fVcSs5CsKfJnpgBwwC8CTOeDJ4uDJ3M+ZNGpFb9CHbjYgTfYiVUgtUo81hBPC CeNM5ERyEjhTOcmUBqVF9aX6UXqUAWVEGVMiyoyyoKwoG8qOsqcGUk6UCzWYGk+FUuFUBDWZiqWm UFOpZGo6NYdKozKp+dRCagmVTa2gcqhcag2VR+VTG6gCqojaTG2ltlM7qd1UCbWXKqMOUBXUQaqK OkLVUceoE9Qp6jR1ljpHXaAaqV+oy9RV6jp1k7pDvaBeUm3UK+rNf37p8Z/7Pv9lv/SQwpw/nCNL fcAx3+Efuq8dz0QUJXarx13IXOYuna/3+Pw39+l8vcMHH4McQI7vcaaDWTMUI9DX8wXoFfEWc3Rz 0grv4YzXeZHDyZHkaHIcGYqxKg6j3izmutrPCnMtrWfBR/m+WP2xMFfeehbmOt1Pi/MPxY25ivdd 8fpjYa7o9SxYlz8pOB58V7DO35fRPys4fnxX8Ch9X8ZD+bYc+kOZiEvUn5S4nxV+5/cFR63vi9IP RfP70q3f5/7CEf5zfuRPzo8gognHTzsc6wdjlu0Hz2L58gQW5mksC4llRC7OfoqI7UQJzn8OEbXE SZwBXSKu4fGj4Xrz/7S2+qdqr3+m/ulZkM/nSARY5DJ5D+HI5AI41vWC7IG5zoKQHs6jSRztV+F2 LlqN22sQ8wbxDTjzItEB1MI8hRa14nylDd7D8Rq9we23qANi5gfc/og6cbuLZN6CQpJs7HMcUgy3 xUnmya18EuffpBDeKSJF4hyblCHlcFue7IXbCsw7QnBcVcFtVVIDtzVJnLmR2szbR3CM1cNtfVIf tw1IA9w2JA0J5q0qRrjdn2TeBrSOXIfb+WQ+bq8n1+P2BtYgeJLsEILFcufIMs+q42B9OcocV+bp ipxBBIszmBPEPCucE4nbUcybiXGsTsbtacxTqziZnEzczuLUEsxblutw+ygXIzOXxFkkydWRmEQg iWgJzPQkJgt3EEi4U4izXuEuYR1uHxWewO2TmKkiSg3zDBZmk12Q4WFUliQlNT7/zhosQxLB3b8O /sZBEHAQBBwE9fgVKwIOgoCDIOAgCDgIgt+eIOAgCDgIAg6CgIMg4CAIOAgCDvK5hyQwEQRMBAET QcBEEDARBEwEARNBwEQQMBEETAQBE0HARBAwEQRMBAETQcBEEDARBEwEARNBwEQQMBEETAQBE0HA RBAwEQRMBAETQcBEEDARBEwEARNBwEQQMBEETAQBE0HARBAwEQRMBAETQcBEEDARBEwEARNBwEQQ MBEETAQBE0HARBAwEQRMBAETQcBEEDARBEwEARNBwEQQMBEETAQBE0HARBAwEQRMBAETQcBEEDAR BEwEARNBwEQQMBEETAQBE0HARBAwEQRMBAETQcBEEDARBEzkyzNKvj6xRCUBSzlYS6hMotNVJopJ 6GcNznorROJkQbrKKLzKj0RIxKclxDgGFItU5hB0kBjPQAyxUbolidgFvvRw2rDHGtUitVRVuKRk R3gRwUQCEYtBNIxIxP/MJSZ7WqPHwdhy/cQ3eVm1Gy144oQUpzxbeOOJc9XFgvRe+nQ6W4ZOJ98X sEhEYnCoIxbZ2c2XbrR/E/L8zkBa+LWniI37FCcyoPXEWCPYfFlN59i46fGREyMS1XVD9NRF1taW 6sMiQ+JjE2LDE9WdY+Pj+ovUaNXPO8t/vyU2PigxMjZGpEH3YbazZBW/bfeJjU1Ud5yaGBEbH5k4 nVZTEFpb0iIRTVvS+G+MgtCEFpmYiroX/4YepSPNnsPCvKkqHcMKXs8j0xEidpDVdXG/27Z5quhu XD1tPP20aMeSvhPeda7y2FTRub5I3T5leNG6ouxAk0mNTqHTm3cnnfa70fYsP0s1e+Pc8LITk2YE a13pbdckiVY8zj1eYxSelxehs/aijWGN4MAonTq3Rzx7q1zDHbrW258PyXB6MFeyKi96RNDu9JTC QKNkjydr94fa5nmrirjacht3PFpuoPj7gDUhcoGjOGEbe1v6zHu7rSWHPKnyS80I17IFqTU2z/1y PEs+bZsxOdFzj2JDroSuBuG/LDDSsmqojLjdyK6xHzaH87hbL6WN9G8ptx3fKy2ZfePNkZLUVZ2l 5+Zc2aYcP87uzOGX3E2adJlY5uky9WTZzDskCzv+prTtdNoWOq0Ij2ZvxE7Lo9NWp0qNvRjXEhm/ QWv4bLl9w5Z2nS2M/7+3X/pf+DiLseGqx/zaJe2rFc1fVCLta8nS7eMCTTZu4J+15yyfn33a5neN tpf+Kw0PFAyqD275eLXB1nbMDgu/yE7tyQ6nG3Y2cVJui5YM2CgVF1XVKeOlGFn78aLzA+kx6l5P g2fu2alUb2DZ1+hIWKHMwr6SIZve+ql2aJy+It/uszvG2UT8U7rCu98mRguHv6lu9TlV/eg4/VFd JDG/9yo95WGXe5NbWlPvsvaPfbX3dr1/c9iQUz5+5ftZujJdy6685GbPrlx9Ypel4cMZD7cnP0gq IC5GOdRdslh411Fmu3mUStRN83u/qrIfbndl148xtYoZpioMruAVLf7lsp+D2znVEVvjbsrYzFs5 deO2SwUYFQLpdJbHZ1Tg9d8lfcu7a9z6s7VfMKX33wUGeN5bmeA/jAAmGAxEJnjR/AsYTAcExQcR kyVH+IpkaWlmgSvL8w9KiIiMmZiIv0aKppiV4rLiPmGhk2NjQr90jPdnHdOiNT53TLnn9tAwdd/I iTH4qOrezo5/iQoV02ddCShztd5utlt0o6Ov+ZDk2g99NpxyndLS6Pb418XHJnn4BL9aSx4bdm1I tLG2fVjNea0K/uCKOVNvu1bvzKa8T/Q1aCt4JNTq0+io/T547QUl1y0r3fusPVdmrHnM3Sgl9rq8 mu1iaynr29V6r8JtjZBJV2e/wVsPRKN5+R8O7QuZk94xriBtbubS0rbKnE0XrLZ6Zyr0m+d5m35D DHh1smNA2pGsF9HW2/qbvdnffw9vVvDyaeH5axKEWXvajrerH/SSWRJy1vC6iatSc5V7rq23r+L5 8OHTdxbPqx9pvzHde34MZ6953Uztap/wAWs9Gwxmm8bMHSTWuOGiexYZk0Vsrp13x7cbFd7TaW9p WQYU+rIFNE+MiwMahyPOYv3/gApJpo+yzGsnOTQLC7o3s4Ji92LLNfQ+n0TEjd3TeuO4Z95wl/6b XEJe0nxmsySbjadRVo+pAxgzc1fJbHedtvOHPROLRvVL1J9alvVpl0fONGLYkzPPFG9FnqCKUtpJ 55Nn5jW88204urF6ZOzLEJcdLkRzbn3eZdVK/kYlYc7VG2rFerNaXmxN2J3dZL10wJqow1aTL83f o/XpzpMrkRLL51d33iOqzNrfpnRIyfTnPNPLXek0SXdKhVX2XXHh6YCIc9WpjpPCt1dVVC01O9PG kkqZ8frSXac7Mzvv3dvd+ebOZWFZ3JUVD7zKrYpSjH4dcNOMH2xJbkyL0lrwZlxIdumYKuurgYtH zFU2fW27piBdUDRhUZlhReGWs7tuqJfX0EqZ6nJC/cM+rxzvjqcfrNCNnFcXd799267zqU7xSRTG mCiMMT7dGBMkOW0YMCRWz3nEwTjzN87qL4BjStMYcUwx4NDWtAmzaMos0on/lq51b2f9yfa/xJqi m7wlF47WDVl3bqeNWbHW6Ek3o49oaFbk1D8tqTl5WeeoifSiwzcCDD9YjFSTNyjJFt6W2xSj6zGn l4Pj7iUD97rNF15PyyleLXbR3yVp3NPWj9T9OYmbTM8m/tbyIKhwNqvCteuyvczl0jPjhRdntlXI Cj8GRulmTl1cUXw487HC/mVHXvcqDw54IX3Hpllj7KI9qQnHXB+sWpAcuO5RcXKd5RJTOWPZm8Gn S5R3eK2ZWPyrujU95e6SiW73T6q+EnonOho/5mhHaUwaUrri+D7rU05bJo9TdN+VfXVphv003qBr m/fN1Tp2v21m+F73xGodx6H5QXKBnnR9evtFflxK84hhyZe4I5LSurHmHZ32Gsa+tyQzY/EkFKvt MWHbNQYuTRn+zm/omt8UrkZlmHH66zz+OTQxONFbi61I90r9+TR3YXbowx5A29LWBZYF5lmmEYmJ cTbGxiHx0f0nf7Fh/5DYycZxkyKZtcZx8bGhU0MSE4ydfbGj9cer6MFfvhLzEDvahrb6skyTWYbd B0xOTv7ZAcPiexwp8YcJBGgz0D/Wd+IG9QwzRP2uMNSu+Nm1tDnNwumJyV6rBym2E/KRs28GLyv6 NLEw/6Gu3vsRV9d2eteMlyg7uPVFevsatdjR71+33hP8sohr30tBvbH2gOsgrk6gv8TQnJfchkPD Yl7eHyyja75II/7OhPI9kTLaOc1PzCRuzo6JXcHzOaPvMWSniWHW48KGAJ3Dh+3ujt2XwT9kruo1 13VQV1VO4WjxHbm3p1X7z9myzbOhrTg/z/H+2XHa9rfmmA3yfHOhfub6Z+Wn80PkfPcU57VcrblQ ULhr1ZkZBvMMa09d/xjNulFjVdzaOE5JQbL27ZnUrVJc5dvLtB6VFnrYPy2V1plG1Rke3DzpVLYd Rpv1GG0yv6DNkJQXgDacvw9t/CInhyUkBk2O64k2FrS1yIIWmZubAL0RwaIJzSzSaVv/LX3rR/f9 HCjVYpwj4yLC4tVdfF3VXX09bUS0i5WRuZWZpZGzk5vVlx1Zsmp/ooRvWHxSZEjYXwLU00OckPrr 00vmuthvKTv+wmOD9h3rJDWJKybuo6ZdMri+RXxZy6MBH6p1UjZ9+G3WbJML1wcssrZse3fN1qzX ryvSP5g9j8iMV86+W+lxtzKz3ZRH1hUlJZh7BLRW3HOf1bsyZ9rNLrVMeSe3Kefn9POXaczwsr3w vunNohcOxIPLTUEdCkuGbk6zex058Om9BTXiXocSZz4R/Dbo6a7o1ssT07jvep2ZJVuVcF/C433w hxcF1nk2nc+k64PUgkdd4/llXLYdOvT+iGrjQOWlKzjONwKepfO0VksUcERhi1Z6qjlqFK1Y9snV xTXWfK+rZXHkjrAOM+e9Ckdtre9JLW5TnvfAz7uP7XpRcU+A+gZIs+Nf9ncYqXe379uISvRx6L3Z Fx7Yf4c9sY89HVYfNNs1NCv7cP7T3baOzicv/q+wJzEhLiToX4I9X46U+DME5f4BhX8CUJEz0iUE vRqbLrgt6F/TaDYjbU4/XUf99l80VlCriyf4jtfreFHn57591lvZi3y5jmFtWfJEzIOM3rqu2wyt TW7H5lmOadbyyfZjLXHYlh9q9caiXs653MZ+zWnhsSlpuu3h20T3xwVkd/j43Bv3bOWy9ZESHgsa G5M8zIRR91JcthmMzfCb46qt1Pf4QrcTfR8opUbqyb1ROPlS0zDNbbzBq46tJ5PttWI7toZmLi0K Fu4wUtv+2zL7OV2lSz+uft76ib3n3JDzYxJ3v2+X7aNifX7T/iuHX+1vri9uG6n2wa61/oq+y+Ga fIdZ4Yrn9qmH8M4MHBBmopSyr3JAnc5gT02ltTGL6brW5d8DlFQUf61XLdF3l/RN1z6jZkws+hGm /p7kqxudaDMzSwadrPHi35B8/QE4/wpvblnGfNhT7+Q+RbH+/GB739r3u+QOGZpUyXj51Ge8sDe9 PkS0Qrd8eejdPt5zDx0d2jiH865l6pFFp7ZfLomMC5/WL/xxeUVL5sFzzTs/yWzmj9bUM74w8PpI tkrSgcmhk939bt5ubarZmHEq9c4cD9Iy53XtBu5ItYhB567XJo0znlXel71/5Ngo1ZCu1BS75svs vsOskxPFA46Ou5ZlaTj1NPVUzVoiJalzfXTMjLvP7bNXb5hCTdD3UgwONNlwKcPTQHNchOuiJuO5 Ut77Og4oL4lu7rtO9t1ZqauZ1Kv0pASLk6tmFDUEij3nlGaZVrzLGTvXce6ozJyY0j6Ggxti853v Rj2eo7N00me8SUe6eES0fz5D/1+kX1JiEt0nQOURk1MRPdDzp+Co9PUDciRboMYjfImpRDDhTDh+ n5r9Ia/7CUDlDJMWHU3xrpJeWhgkjqjFca5LWhL8qh0kOEZdlcN9M1VfWC+v2DSS37S43Fal8cPu bacr9g7XUInlRs6exCrSdHsRvX9yimal2y9z25dIHhFfaFH3bPaTuADXjSsuNZy/vbT2Xo3+uZTn p0tMLs87eDbkuEWjokZNUpNtXplKwgaN+df275fxW/wq/2iYe56uTn7gQknbU7Jh0wZXXSjOsPEq DR7VRD95Yt37wYK2G9ZpHbIai0NTQ8TYuW15pLPxTLf5h7rI62Ed7k03WIkryzgxgob1t3SDUga3 KuRLa1iRqvN2i53INan8beBJ3wHVOxY0PQ63XPJKMze/oTTZb7jNlXiXfVpvROnsPRikdpEI0Wnz /sas7Ltc8ds57oK0G7TcV3vrIpE4iwN3LzNe0G1MCZZI0PO0Ou7NtyW+iKJ7bpWntb59kC3CPvY2 2108bejypgPcPO/SBTWfdL2WH6BDe3xEIBpJ+xXop+oSw4hIIoSIJ2LhzHw4kUioE37EdCIOL03E 64NwK4KYXqiTqv2n4TVxelzsxPiguIjp6j/AGzsdEeo1v1eOViJs5PKU5w87376qNH/lwKKnlKk/ u9kqwe3jx70la1vu0g9mL3z97BVr5uvL4zpeJ65P5ceU3SgxZsWw456yrrxRWGBUO3eV5ZYL9nMD /Knpp68pXav5ZLpow60y9aIKt2cHZ298safW/uTTGpc7jY6H3z2RU1o4tHUlcr0wwVSwaE7J4k3O S+o/enaFFK84dk7Ub0TC/sCK5ey3p4VJJYOnlZB5qWdKlptZ6Jz8PVRQsJQ8PbnPrJLZI82P/yKb ss9Jc9XaCzM845I2lRic0Hw0I+FqQEF2YYu/l4g0kEpyeZ/jphqcIzszO+XhXK27m9Z5WrJPeoTv fLzlxpZRWrMW0I195ArTyT50OqnyzUZionRSgFdx/89d9MeI9F2CId7togUBtGJPT+R/uwqE8Hd+ 3cIRSeJQayWiTXCgNbE2NR/zB0cku7SpO+VBSwL6T6Dnuyq/3nP3+bsfMItxkTurj7lzje5UnlbZ el2Dc0rwPDxLu8uJvOD8srq+UD0p9/7heyuXygy8r6NftHX5oqDFih0N+nu9lee9m7n8qe+JgY+r jAKyz7usCI0ZGdjXiX8qi0x1bNZcO/OEyQzv5uj5D99bKLw+uWhFcG+/vF9/k5UpvLK+5G2Xvw1r 0JPLzaPaw+0dJw4dX3Gk+nqm0UP/yvrlu4KnRDlsk+UevWDQMLVp7cLp0+Iyit3yjpZlLPAcZGOQ 4athsr3z6SmHxCSytmRnvG9AZcSp2c9EAyLy+qW27xcrffRLpbRh+qXomj13pux7nBG8vRwl0Teo gb77xnLa3+63COX4asgvmugWIxU1ebSsT8x+IfFfuEO8PA0KZW5kc3RyZWFtDQplbmRvYmoNCjU1 NiAwIG9iag0KWyAwWyA1MDddICAzWyAyMjYgNTc5XSAgMTdbIDU0NCA1MzNdICAyNFsgNjE1XSAg MjhbIDQ4OF0gIDM4WyA0NTkgNjMxXSAgNDRbIDYyM10gIDQ3WyAyNTJdICA2MFsgNTIwXSAgNjJb IDQyMF0gIDY4WyA4NTUgNjQ2XSAgNzVbIDY2Ml0gIDg3WyA1MTddICA4OVsgNjczIDU0M10gIDk0 WyA0NTldICAxMDBbIDQ4N10gIDEwNFsgNjQyXSAgMTE1WyA1NjcgODkwXSAgMTIxWyA1MTkgNDg3 XSAgMjU4WyA0NzldICAyNzFbIDUyNSA0MjNdICAyODJbIDUyNV0gIDI4NlsgNDk4XSAgMjk2WyAz MDVdICAzMzZbIDQ3MV0gIDM0NlsgNTI1XSAgMzQ5WyAyMzBdICAzNjFbIDIzOV0gIDM2NFsgNDU1 XSAgMzY3WyAyMzBdICAzNzNbIDc5OSA1MjVdICAzODFbIDUyN10gIDM5M1sgNTI1XSAgMzk1WyA1 MjUgMzQ5XSAgNDAwWyAzOTFdICA0MTBbIDMzNV0gIDQzN1sgNTI1XSAgNDQ4WyA0NTIgNzE1XSAg NDU0WyA0MzMgNDUzXSAgNDYwWyAzOTVdICA4NDVbIDQ2M10gIDg1M1sgMjUwXSAgODU1WyAyNjgg MjUyIDY5MF0gIDg3NlsgMzg2XSAgODgyWyAzMDZdICA4ODRbIDQ5OF0gIDg5MVsgNDk4XSAgODk0 WyAzMDMgMzAzXSAgOTE5WyA0MDFdICA5MjNbIDg5NF0gIDEwMDRbIDUwNyA1MDcgNTA3IDUwNyA1 MDcgNTA3IDUwNyA1MDddICAxMDEzWyA1MDddICAxMDgxWyA3MTVdICAxMDg5WyA0OThdIF0gDQpl bmRvYmoNCjU1NyAwIG9iag0KWyAyMjYgMCA0MDEgMCAwIDcxNSAwIDAgMzAzIDMwMyAwIDAgMjUw IDMwNiAyNTIgMzg2IDUwNyA1MDcgNTA3IDUwNyA1MDcgNTA3IDUwNyA1MDcgMCA1MDcgMjY4IDAg MCA0OTggMCA0NjMgODk0IDU3OSA1NDQgNTMzIDYxNSA0ODggNDU5IDYzMSA2MjMgMjUyIDAgNTIw IDQyMCA4NTUgNjQ2IDY2MiA1MTcgNjczIDU0MyA0NTkgNDg3IDY0MiA1NjcgODkwIDUxOSA0ODcg MCAwIDAgMCAwIDAgMCA0NzkgNTI1IDQyMyA1MjUgNDk4IDMwNSA0NzEgNTI1IDIzMCAyMzkgNDU1 IDIzMCA3OTkgNTI1IDUyNyA1MjUgNTI1IDM0OSAzOTEgMzM1IDUyNSA0NTIgNzE1IDQzMyA0NTMg Mzk1XSANCmVuZG9iag0KNTU4IDAgb2JqDQo8PC9GaWx0ZXIvRmxhdGVEZWNvZGUvTGVuZ3RoIDMx Nz4+DQpzdHJlYW0NCnicXZJNboMwEIX3nMLLdBGBHQyJhJBSaCQW/VFpD0DsIUUqxjLOgtvXHpO2 iiWQPs17nscMcdXUjRosid/MJFqwpB+UNDBPVyOAnOEyqIgyIgdhV8K3GDsdxc7cLrOFsVH9FBUF id9dcbZmIZujnM7wEMWvRoIZ1IVsPqvWcXvV+htGUJYkUVkSCb276LnTL90IJEbbtpGuPthl6zx/ io9FA2HINIQRk4RZdwJMpy4QFYk7JSlO7pQRKHlX3wfXuRdfnUH1zqmThCWlJ8qQ0h0SywJlSGka qEbiT0gclZQGyjgSrwMdkLJToArzrJ3pLcctNs25l9E89MzqVR3q/C42zdcWJ2yxr5ByhnQ4BkqR HnkgjLbjB0fMf9m/MH5Mfpu/OxBXY9z4ceU4dz/xQcHvX6En7V3++QFMw6YSDQplbmRzdHJlYW0N CmVuZG9iag0KNTU5IDAgb2JqDQo8PC9GaWx0ZXIvRmxhdGVEZWNvZGUvTGVuZ3RoIDgxNjg0L0xl bmd0aDEgMTc1NTE2Pj4NCnN0cmVhbQ0KeJzsnAlgVMX9+Gfe2yN77ybZI9kku5vNbo5NdnOHQEge IQk5CElIVhIgkBCOeGBiIFyKotYrghceVSvgUY+isllQg6Ciorb1rKXWemKlKmoq3i1I9ved990N AbG11rb/9p9Jvu8z853jzXy/M/PmbRYIJYQY4SIhjRXNNdNa8vvUhLsmlhDrpZXlFS0XlcQcIeS2 bkIUqyvLp089M/tzPyGb9FChdVpFZdX7T37+DeGuSCGE//O0xobmA230ekK2HiD0premNfvLn9p/ gBKuai8h0+Y1NPtyv4l+fSIh9FW4a0fX0s7eZ9612ghJ64D6e7pWLLf7agpqCKl9iRBZ1OLeJUtv /bD8XkIy7XD/mCWdy3qJhTjh/lCd6JecsXpx5ynNMkIaoT2bt3tR58L3ZCNV0P5cyC/sBoVmgzwO 0tdCOqV76fJVvUuUQ4RwEwhxp52+qO/MwoNF0J8rGlmdM3q6Omd+M/0pQnqjCEmqWtq5qtd6xJQE eVCH2M/sXLroyr3rbybkSuiTNr+3Z9nyUCN5mJBb9rP83r5Fvc8cWu4lpCAfjPozwmwr3TR09dLa rPm6ki9JXBTrN9n10TnPMT6V/NO+I68d3aD4WP4UlFUQjmCAejIyQuhe5ZYjrx2+WPGx2NKYwH/G NLpk0kSkooIjeuIjYEV1F9xXLCKp5XZDbpT0RmkeNJmE5F8iD3MkinA6OcdLJDwneYdwIYHcG4I6 ClaxvtluJ2Bvuxv7IN/Eue2EbhYb3SPVspFC69pjvaEvkh8cJCWk4YfX/nbg7yUbfsz2vm+Qjfx4 95WUY1vStaTxxDz+l6Tsx7rP3+1HN3H8u+41Hv47A/85mfaD6rWR6u9TTlJH6o5Ly0ntD7nf/0Kg X5PT/5HynCr0+ne0c+7J9LILyLlg75PmsSCp/34+O2lfXj2+XT6H1Hyvek8T8w+95z8aYOyr/133 Gg/jYTyMh/Hwvx24m8l7kTj/AFn2veoUkC2ck6yVDpJz/nU9+3838BeMP4f/1QHe31P+030YD+Nh PIyH8TAexsN4GA/jYTyMh/EwHsbDeBgP42E8jIfx8F8d+LAkhL/F9hdIQYw7QCTkDUhnEDvElBDT kGTiJflkIikjU0kVqSdNpJm0kk6yiJxGekg/2WJ3h0JiKxqodXzZxnDZLnIqOYP0hcvS0Jdw+wx+ N5/Ia0MvhvaHvobaKuIgt0Y6GOp6Ny/cN/cJfU8I0wKxpNFPzHm+lr+BzCJtVE/jaRJtp6fSHtpP V9C1dD29it5EHyAy+rFY9tMTv7sHaS78TT+O/O1Ax9zt5KZtHRM/NCY+azRWH45En2R8FeIVxgHX eaPab/3thUI/caThNIwXruERi5rIqP8rAt8mzscfL/wPz2Ohav689rlzZre1+luaZzY1Nsyon15X W1M9raqyYmr5FKGsdHLJpInFE4oKC3zerMw0tyvFmWyzxBr0Oo1KqYiSy6QSnqMks9JZ1WEPuDsC ErezujqLpZ2doOgco+gI2EFVdXyZgL1DLGY/vqQAJRefUFLAksJoSaq3l5CSrEx7pdMeeL7CaR+i s5taIb6hwtlmDwyL8XoxLnGLCQ0kHA6oYa+0dFfYA7TDXhmoWtE9UNlRAe0NqpRTnVMXKbMyyaBS BVEVxAJpzt5BmlZKxQiXVjlxkCNRGnbbAO+q7FwYaGxqraywOhxtoo5MFdsKyKYG5GJb9lNZn8nl 9sHMPQPrh/RkQYdHvdC5sHNua4DvhEoDfOXAwCUBgyeQ7qwIpK85YIEhLwpkOisqAx4nNFY3c/QG NCB16Z32gS8JdN45/PHxms6wRubSf0lYlA1x1EyQH4kT6Bv0EMbncLC+XD4kkAWQCKxrasW0nSyw Bong87QFuA6WsyeSY/SznHWRnNHqHU4Hc1VlR/h3RbclsG6BPSsTrC/+uuAX8u0B3t2xoKubsXPR gLOiAu3W0hoQKiAidIbHWjmY7YPynR0wiFOZGZpaAz5nbyDWWY4FQGFnPji1uVWsEq4WiJ0aIB1d 4VoBX2UF65e9cqCjAjvI2nI2te4keaH9g/l26/Y8WKJtrB8B01RwirtyoHXh4oCtw7oQ5udie6vV ERDawHxtztZFbcxLTn0gfT/cziHeUawFYzuhdKQwG7ncFWVv5ax8G/MWKOxVcHGWl0CGHtwlJplH y0vsrdRKIsXgLuESLHZcO5DgXVOrWRbPqk6ttjraHBj+Rpes4T5JXYGoMW3pQTHaJ7zPd3YNS7MO pdsrF1WM6eBxjUrDHQy3dvJ+cswW4RtDjSjmzupIFu+ClQs6DpoRVcyLFnuANNpbnYucbU6YQ0Jj Kxsbs7Xo37pmZ13T7FbR2+FZ0nJcCvMnYCpAHJAdSXBTYQ5WeawRt4rpaWJ6NFl9QnZNJNs+EOWs ax5gjTvDDRI7rCAYtMxd03n5hOh8WJpVsLs5qzqddr29aqBzKLRuwcCgIAz0VnZ0T2RtOGsWDjib W0usYl9ntq61rmG3iiZ1tK6lPCsT9p7yQSe9tGlQoJc2z27dqSfEfmlLa5Cj3NSO8rbBFMhr3Wkn RBC1HNMyJUvYWYK1NBMSUWJ5606BkHVirkRUiOmuIUpEXVRER0nXEIc6fUTHgU6COkHUsQBOsnSD iWG7rbQvZO45p617oKONLS5iAlfCLw1QZykJcM7SQcrJ1AGlc1F5QOUsZ/oypi9DvYzp5TAxqImC cdieNNDhhH0KJlQrsVKcijxr0j4UCrW0Op63Drc5YKrNBZndGlB4YO+Xumqh3DQmHaCeFljX1cn6 QfytrK7cVdPVBtM20iAUqQkooAVFuAUoUSXWYdMRKnWBb8CBYv11kAisawu0edhNW09tE6ezPkCq nRPB7dim1M1u5GsbiHbmimsTloLSdQmDAvpGmltRY4Uk3KwNjSRXQ8+7nJDV1WEHa0tIVzNMddxL lVbULIItUeJeJIrSGs4kbFi8S6VRBhReaBB+WVzlZUtS6pK3tWHnxdQl4QJwb31ABT1yjzFluAJY B7JqWF/g9xLoKiv6OGumaYjMdK6CnYV1WmxJDtkBjaumEzZ/rK8CjXNCpHIU2yNU4Tb2olbORq4G u/OulqHQXc7VjjEhK9PJHg5sYhLrTpjYpG3gREVgjicrM+pErUZUDwxEaU5eAe0VpRklKMmggh/i /hpMSrQNcX8JJnkAXweTMgFfIb5EfIF5n2PqM8SniEOITxB/xpLDiI9R+RHiQ8RBxAeI9xHvIf6E OBBMUgDexdQfEe8EE6MB+4OJcYC3g4k+wFuINxFvIF7HIq9h6g+IVxG/R7yC+B1iH+K3iJcRv0G8 hHgR8QJ24nnEc4hnEb/G2/4KS/4S8QziacRTiL2IJxFPIB5H7EE8hm0+ingElbsRuxAPI3YihhAP IR5EPIDYgdiOCCIGgwm5gABiWzAhD3A/4j7EvYitiF8EE3IA9yDuxnp3Ie5E/BxxB+J2xG1Y/VbE FsRmxCbELYifYdM3I27C6jcifoq4AXE94jqsdy1iI+IaxNWIqxBXIq7Apjdg9fWIyxEDiMsQl2KF SxAXIy5C/ARxIeKCoDUfcD5iHeI8xLmItYhzEGcj1iBWI1YhViJWIPoRyxHLEH2IsxC9iJ5gfAHg TMRSxBmI0xGnIU5FdCOWIBYjFiEWIroQCxCdiA7EfMQ8RDtiLmIOYjaiLRhXBGhFzEKcgvAjWhDN iJmIJkQjogExA1GPmI6oQ9QiahDViGmIKkQlogIxFVGOmIIQEGWIUsRkRAliEmIiojhoKQZMQBQh ChEFiHxEHiIXkYPIFsHToMULKR8qvYgsRCbCg8hApCPSEKkIN8IVNE8CpCCcQTOb0MlB80SAA5V2 hA2RhEhEJCCsiHhEHMKCMCNMCCPeIRbvEIPKaIQBoUfoEFqEBqFGqBBKhALbjELIUSlDSBESBI/g EBRBRNAQYgRxFPEN4gjiMOKviL8gvhZvS78SR0S/ROUXiM8RnyE+RRxCfIL4M2IY8THiI8SHiIOI DxDv4/3eC5qcgD8hDgRNMMHou4g/Bk0TAO8g9gdNUwFvB00VgLcQbyLeCJoqAa8HTVWA1xB/QLyK Tf8e8Qo29jtsbB/it4iXsbHfYL2XEC8iXkA8j3gO8SzW+zU2/SvEL7HzzyCexvs9FTSVA/ZihSfx Rk9grx/HxvYgHkM8ingEsRuxC/EwNr0Tmx7Cph/Cph9EPIDYgTfajggiBvG2AcQ2xP3Y9H2IexFb Eb9A3BM0wr5L7w4apwDuQtwZNNYDfh40zgDcETQ2AG4PGmcCbgsaBcCtWGQLFtmMRTZhkVsw72dY 8mZM3YQlb0T8FCvcgLg+aGwEXIfVr0VsRFyDXboaS16FJa9EXBE0NgE2YMn1iMsRA8HYVsBlwdg2 wKXB2LmAS4Kx7YCLg7G1gIuCsXMAP8G8C7HkBVjkfGEb8JCu0vaJttq2Xz3D9gTI4yB7QB5TnWIL ggyCBEC2gdwPch/IvSBbQX4Bcg/I3SB3gdwJ8nOQO0BuB7kN5FaQLSCbQTYpu203gdwI8lOQG0Cu B7kO5FqQjSDXgFwNcpWi23YlyBUgG0DWg0xRcN9wh8kpxMYdAXYTGz0vGMOW47nBaDa1liOWBQ1s avUhzkL0InoQZyKWIs5AnI44DVGCmBTUM0xEFCMmIIoQhYgCRD4iD5Eb1LF5moPIRkQjDAg9QofQ IjRBcMoQVSNUCCVCgYhCyIMa5mqZMAf4Z5BhkI9BPgL5EOQguPNtkLdA3gR5A+R1kNdA/gBueRXk 9yCPgjwCshtkF8jDILeAK34GMkTXoaXXBA1syq9G46xCrESsQPQjpiLK0Q5TEAKiDFGKmIxDNiJi ETEMO3me54KC7Y5HeY7sANkLwvME+3I2ohm9PhN71oRoRDQgZiDqEdMRdYhaRA2iGjENUYWoRFQg khEO7LwdYUMkIRIRCQgrIh4Rh7DgMM0Ik3Az8CjINyBHQA6D/BUc/BeQr0G+AvkS5AuQz8Grn4F8 CvI+yHsgfwI5APIuyB9B3gHvPg/yHMizIL8G+RXIL0GeAXka5CmQvSBPggyBPAQefxDkAZAdINtB bmbe546ijdcizkGcGjTAUYh2I5agWRYjFiEWIroQCxCdiA7EfMQ8RDtiLmIOYjaiDdGKmIU4BeFH tCB8CC+aOguRifAgMhDpiDREKsKNcKFvUhBOhBQhQfAIDkFxRRLhNmAIZATkAzDsKyC/A9kH8luQ l0F+A/ISyIsgL4Chd4JcxLtsP+G9tgup13ZB9Tr/+VvX+c+rXus/d+tav2rtpLV1a3nVWivg7LVb 176+VnZO9Rr/2VvX+CVrYtdwytXVK/2rtq70q1ZS9Yrqfn9L/4H+L/r52P6W/oX9y/uv7d8HCvkd /Tv69/bzQ6E9QnT/hElV6/qv6udiIZ8j/VTH1I5+lbZqeXWff9nWPr+kL7+Pm/RFH93fR7nsPtrY 19HHQantfSlpVax0QZ8pvkrfl90n9PFnVff4e7f2+Bt6enrO69nc81iP9LyeK3u4bRDjhB6FpurM 6qX+t5dSspsLET3IHi4U5JU9u7gRQskn3IgQoqeDAU4DQ5zqXeLv3rrEv9i70L9o60J/l3eBv9Pb 4Z/vbffP29run+ud7Z+zdba/zdvqnwXlT/G2+P1bW/zN3ib/zK1N/gbvDP8M0Nd76/zTt9b5a73V /pqt1f7GajrNW+Wv5Att8AQhSfDbm7Qu6VCSRNWR2JvI9SbuTzyUyPcmHErgzrNSXfx58VfG8zq4 cHiJs8VdGbc5blucVCdGeHVv9LportewzsBlGwTDS4b9BgkxbDFwuit1m3XbdHyDbr7uE11IJ9mm o9u0j2lf1PIN2vnaHi2v07I0rxe03pwqncamEab5NHyJT1OmadDwV2qooPHmVgmalNSqMnWDer6a 36ymgtqdXvWJMqTkBCVkfKIIKbiQghKe2illfzi1Uz6K+YgabVUwH7ebqJTC0WKwpdnjqRuSh2bW BaIa5wTopQFXM7sKTbMDsksDxD97TusgpVe0DVJuaksgln1wLKYv2rCBlCfWBRKbWwNbEtvqAusg IrBICCIkcdBEyts885b1L1u23LPMAxeQectAs7wffkVQuAL7l7Oc5csIFPF8R2AlljH0i4WW9c/v hzYgA9TLRDVLzROLfFcb/9bwnSP5dwT6n7z5/9/BMn8eIfJNhIxsHPO37/Ph52dkK3mAPEweJ78m vyWfUyXpIBeRx8i75EPyGTkCy1ROjTSBpv9T3wM4LoxcKF1KNPweImP/g0XocOjgyD2hg4RItWM0 GyFllriPaULRoeETdSMbR4ZGXpCpiF6sq+eeBe0hOhw6zJWxdKiQpblLWFyscUi+aWTbyObjutNL +kg/WUVWkzXkbLKWnEvOIxeSi8kl5FJyGdjiPIhfTtaTDeQKciW5ilxNriEbybXkOnI9uYH8lNxI biI3gx1vIZvI5nAeS2+Cn+vFXJZzG7mT3EPuBd5O7iA/J3eRuyH9C7D+veR+0KEG0/eBZgu5FbR3 gpaVYrpt8BMggyRItpMd4DNMR1JDZA95kDwE3Ane3EV2k0fIo+DHPeDZJ0Qd00TS310Sr0+SveQp 8jR5hvyS/ApmxrPkOfI8eYG8+INynhrVsNRL5DfkZZhr+8jvyCvk9+QP5HXyFnmb7Cd/hFn38bfy X4USr0GZN8Ol3oFSfyIHoeQwlMRyWOYNMfcDsYV9UHc/OUCjyJeUI0dICGLMe9eLHrpR9CPzHvPO HaKdmT+2QZp56K5R39wHNr4P/MlSLH5T2Bv3Q9lBsGDEfie32gth76C9d0MZZguW83zYFs+EPcHa eXS07rNiXlCs98Roq8csiiP83RjrvDHGhn8i74mWQeth7jHrsRIHoAyzMmvjeNv+Eeqi9Vldph9b h+W9BumDsDt8DJZm/Ej0xEfk/dH4++H8YfJn8gn5UrweIp/CfvI5+QLSX4HmEKS+rT1R8zX8/IX8 lRwGD35Djo5JHT0h5ygZAR8TSilHeTJyLHZMK4oEjhgy2NOiqIIqqZpqqJbq4CgiPyFHNZpj+FaO +iR5ClETTWNoLOyXZmqh8dQK+2YiTaI26qDJY/LiRnPskOOkKdQVzjOJNeNG69qghHlM2XSaTVfC 1UO91AfxHJpPC2gRLQZNFqRzIT0R8rJFlpNGsoCcQQ5LP+Ceg/ZjYVcZZP8v3sgy/nXYMXkiJ8Wk nswgLbuJht4C2+pE+uyOioqoLPmjkOSInT5LosB8twgxEk5jtZY5C2Tr+SZDTZl8PddCyo6+9ebT cHk+utj3PPW9OfzKsP7o04Zi3/C+4ZxsanAYRInVcnK5TOZM9nIFqe7CvLzcUq4g3+1M1nKiLr+w qJTPy03i+NiIppRjacq//k0DX3k0hVvtmNScI6Uel9kWExXF25I0rjy7rq7eWZgWL5VEyXhplDy1 sNzpX1mb/ILSkpqQmGpRAhMTgEefkGoPfybVHpklqTiym/uguLU0RbZao+Kkiqhb0pKMKTkJk+s0 Oo1UazXHJ8ijDFplRnXn0RvjXWal0uyKT3CxtlxHJ8HZvyH0kUQtdYLdLmeHT39rMIF4HuWeIVpi oZ3EQdyhD3aodHS6m705xjRL4LXwoYJsC1Nls1dLQXEKsZTF1x/17BsuYxcK1tqbk23d/UMbyMlu c8Vq0bz50YWFYDmZMWxJZmNjbBLHTM4sKlHzMqWpbE5/xUWvXN/YuunNiwoX+iusShkvUWoVOm/N oqr61f5M36yz66sW1/g0SnWUZG+cMy7anOIwzbz9i9t+Tsn9s6MT3dboBHdCUka82ulxlvXf2d13 1xkFjjR7lMXDvp25IXSY74IZlkp2opUG5TFD3LWCSZNIkhLlaTpaL7eoNXS6XK+C6MN0FokJHXoQ 4jExcbKh0P7tUAIIltDS6TJ4w94hJDfF+WHgMPJhjwcmnAfgoT7fXkPxcC7YTzD8iO2CTdm0dToM DrCaEaOR2WnIL8xjahiiSqsYaaMbFFqVVIwvU9tyU915SZosB9fJtJLbktIt6pE7lJa0pKS0eNVI kkqvksngIrkuM1UVl4HWkp0F1iohf0BrCSpNdrbZ51N6LZb4IW7hjpQctVoJkYdISmFTnFpl2UWz iEC8oUM79E5ues5Q6JBgZzGznl01eDX7snO8Mltak80f7ZeKgywrizYXsxMhjDY3N7eM+vYN5xry 9OxiKJ7sy8sz5IEtH/hx74IzNGw8J9XyLJZKncdZlE1PM82jsBWwqFF2liox25WSnaDmRi6TRNuy k5OzbdH8yPWcKskH+kRVYda93vJsu5paJDRZY0uf4Bq0psZpUpR6pUwGF0nikQMag5KXMmsnHHl3 VH9+XqHOWZzxzVGeZkxM0WmhFvvOMfhBwoMfEkg6WReetymyXdxGYiCJ3OOCghhc4jp0DVHPdplM 7RwKr1UnKHYIxib16EyCiTTsYdbVi5PzwX+sYmT6OU+ccxJpvpep2XqW8BUXPLLuDE2SOOPUOWk0 x9u8fGVL5shwdlV9eu+KMn9hAn/R0ruXlYx0jY59vc8nN5fOP29BRWuGaqQmebIfRt4YMkk3Sl2w XieRDTjy7UpHdBr7MgFJyAXsiHYoNVmRbmcN0bmCytzskhSJ4ypin4gJGtyYhj37ni9jAykWt7Zh iIAFtv+A+mAGadgAqeHnR/jJwFakPElK84/f4qQb5WptlOP0c84v8l7YeMM719c1bjp409Vv39hg zhTSSzumpJqUI332+nUdnRc0OuzT13Uynp2SaZGnTO0sM9rqbzty3y1Hts2bcetXd8+68YIz0gsn JGiMedyri+5cOaV6ze2zT//FqrLqc+6EVVsWOsivB5vVkF1osZ1kCnfDAym5KblqK/vuAVF72QIq Ikqa9aChCH5MJREDlAzRLEE9xSpNbzaJFjCxDwwFacQCZTD6YY+huNjn08MUYhMpmiWGxQeF90dq NjLNkr2SiGHx2eyVhdMnPkhk/PrpF9zfNXVZ66R4lUShU2rzGntqsqcXJGTXL+heUJ9d2b+5zTu3 sTRWLuV4uUalyq6aW+QRPEZfw8LuhTOy6U8W37Qk32RLjs/x2jLiVY40hzmj1J1ZluPJnuxf3tS+ od2rtSTFas3O+MS0eHWCw2p05Sd6MH8Z2N0Bq7RCGkt85Dy0+26SzF1LLCSFaxSUXrPPa4Efomb7 pmBS2WHfvE6IFojK7nSq0mc6VYbEmYbIRgX2KKNxvjxfvEX/JlgoHq5oabigiazCSWuxPc1kwlmZ yvNsT3O7C4sohWuhuJfFxLBTDZSBs2VqtMpSNsFXaNNKP/9MprUVZeUXx6pjaOHI/miNubTYV2TX yN59U6ZJzMvKnWhSGUb2dzkzTDKJQq+mvx3JUusVEpkpw8kVcDEpHqOU6Uda6L1MLzVlpBw9BKt4 GszIFfzvSR4RaHr4dKIw5w9xc3aQ1FQycYirFPQG3kw/N1PzkDqffpNP89lnowr2yMzP907JGKIW wbo/mfJrkzckc0JyY3JHMq9LtiVzaklysiQRHqGCVg0TK9Gip/WJh721k2HuCQpITD4gqOslxOLD mYYP0/nz2tvb57cPG9iDtf2s4fazYE/YWwyzL5dtCoLuP9wb8cnEnOh2FxSM2WLyCsI7S1gjETcd Oa4CU15uYRG/ItaTkZVuKNpwyrSVs7Inr96xcpYhdUp2Wdf0PL3KoJIpE6rm9Uw69bqOzK87Jp9S GDetrKDNa9Pq5XK9dtqkclfNGdUzltWlFGaUZcQmJCdo491mW0qiMykm3X/x3NeiU/IcE4TCfHaa qg59yDv4V0gBuWX0zJn6KLdcPHPaiI2khJd/CvsDT0yt5GFaTXLAkio4+ORkihtBJvsrkaCojxwd PaOHz7254cPnP9fScafQyN4hw61DNvYICkORyi0Ta2d5l2w+o2jqqjsWpNVPLTAppHys3uDOr85d 0B2fV5+XXzfBrVGo5ZJAvNOiMzvi9cLaHcsvfnJdKWwPJp3FGTfRB2a74ZrqM2tdNrdNac1gz/A6 WAPPSZcSN5zQrwtbS2Ut3sWxf8bj4/oEZYyjSlWcapVoMyK7JsyzGkFhqc0Xx5cPqR2Ctl46PfJI Zg8jM+wT7LUGp63ih7Yx9iQ0dr7lmsyGyKONd7vHPtOK+OeUlvQke1qcqvKGuYs3tKXlLbhmft2a EnY8csHx6HBhV2HONI8xOr0iPz4nr9CerNIpJRKlTtVVO7Ph4u1dKx+9uHryJArnH/HkqTyaX1Gd M3NRwYTTmnN1yUVpzG61YLcHYe/wkHwqDZ8AYmIcmexbTZ58yRCznIPPjMnkrJlPStgyNWtoPZHo Jdz0RkmHhNsiCUg4iSTBBxZhp2xGwQ5lfAfctZaviFav5Qy8VmFR03qFBQoo/iokRCaRZx8szeHw Km0/a167Z3heO9g7903YjH2ixf+99xafjDKnY8y8NR4/uzljaqHoJzn/YHrK0Xesk9qnlC+sydYp 1FE8J4nSTJy9vHzl9lWTSlfcc1rv5sXZX/Bz5mdP88Vx9LA3s7h9SnKMOUYe7Ygz2Uw6rcVsKFnz 8NqVj11UVd6/ZZ79tNUpk5t94JfTQ4fpBukMYoQ3w0r0y2PExD0Gh1Qj10GUxEbPfkCI09fgVHsF 5hrF12/rzpPkHXcSjwwkhq1TN7yGwzSka9TitEpURxhT2uKfNNnfUpKs1CmlUrjwa2BuwUzSKWn2 9IkTaqZPKiZc6PWRjXQL9DSFZJP5kRORi3ss6FGTIW7+jrg4kusdomdvT7PVxLK/UgvSBjyWlL0y bMjLY1uR2O/tf6fgsTGETy0m8dBy8uFsSKk5szZ9YrxSwvFRyiipLTrebVGrE8JjY+Ni45OcekFb lkodbU40J7hMSqneWVTCb/z2MGE3Phc8skbaCx4pC7+t6TRGChukSkk1hKokMNqOBwSlvgrNTn2i 3cVnT7t1e0R9Uk982/qjRpc6I8sX+yBTwGptJFvD7ylV8H49f3tSUq6SfZeysTR1F8yOXKIPb096 9q2CutqUoWP7e72gFabUllZlTajJmh43HXuFZ5vwhgUeKd43zD7OKRan0z/V2PHjFZ8KcsPfUIQt YgwfpvADIqNMwVznhpc/g7PAlTW3EOyUwuxkSC5M8c4tiJhNGZ9us2eYlbUbG4taK3MNafV1dalt a+rso/bkDFm1BYlVU49u+24Nf04ktqSx0ewpcXlKU2NKlgzUh+cB/zL4IJecH/ZBRgwzehJRgQdI kh5el7fDY1PPzKQOm01QCVm1GXEpNaM2ikYLhd8VI4b+R2r+Hcseb0gj/7I6ISfFlZOgjkkpdmcv +LbJbmyes7Y+edRQ9OiUv2UWMEcn7FPVoYMSCVgjBt4hz4rsU7FcPzx1k+CqJHHhyRI3ROMFha7W aQm//ybA+q6PvJ+Iky68e33fGsfeYkb3ZukJ74USScmaobNXBpZPmLzmobNXBZZNGDlqzG0um9BS aDXltJQWtxTG04N9uy+tLT93aEXfI5fUTjl36Pzynpne9IaeacCs9Bk96HNul3jC7g373K2D1S6o SbxOaVP6lLyGV7KHEHhPOUSbBaXgqXXrjPYao+izyHqYz55ue8PeVv798mOGKD5yTuJecYHIuF3w 5FFGxcYlRRszssDJJzjXWToBXmiT7BaVFDbEuhRvvFIeJTeklGQe3fdt9/bkTnHreLlCqTayz6lq Qge5z2D0NeTgsTde7+gbb4WQTNQSL/UeKIKtUPm+oUhgk7jIXsTx4muqroSWsM+QrOKr6gH2mlpr 0rPTPjFRvcT02ahbwT7hd9V28WV1frtHP9wOv8e9CAv2f/HdfsD7MfdZcfcVzblzqrNNakmUWqHy CP7C5ILUWNfk+qb6ya7ceZe0ZDQImTFREp6Xq6MU7uK67ORcu95d2tDUUOqmSdOXz0jVmS3GrMxE p1EelxSvjU+LT/LYE5IzhdllwunTM9TRRp3OaDNbk2PlRotRG++MtWXYExyZQht4yRz6mLtCMkgm ko3opYcMBs2kdOLMYk8G83Efwti2O6sTNRGFhh36zdU57HtlgjxsHFhgz4vLMu9o7t5cAx7HdpKs H9II7lSS8OeA7BmNr1qROYzHLBn72MsUOXZxV6iinb6ihLozq5NPj4ll0/I0VSLuYE+wiRob86R3 Uqw9ziCXqWTSNZm+GHhquxtWzaS/8hUlppmVz8CDUyqFB+czSnNaYpFvpL2mRq6Qy40pYK3V7H2B fxp28dPDK1qVii8LNm6+oIvJqklVSeNqUiyRB90Jx3rxAwS2ZYnvBdrvU/xk7wCj69gg7liFRcfe Bp5TxqXbHOkW2Jhnzl1b7xAHD0s62gXbd2dR5C0geeye3H3ZYm5UMRJVJW7gXFNEA/v1e6FPOSLt hlNMOrHthhPlELHDifKKB1VSl7VeX0XKyt58IbwXRz6w5Y+dsE74O807VBnngQ0mTvl/7J0JdFXV ufj3ucO5Q+69CXgDScB4GYSEIUTGCGFyQGWQCDKor0BGiGTi5gYSDBCtT6mPUkpta6kDttY6tEit tmoHoyBSBPQJxqDCi6CiNtCIEnlAc95v73NucgP4Srv+a731Xyv387fvPufs4dvf9+3hBDBaiu+y UWlpIy/zO/19Rqenjwn5/aEx6emj+/i1J6InGPs6f9Cvu/yX+M/MTM/qGx/fNyt90JX94uP7XSnf RSqNL+x56DZSXC+m/VGMsr0oJgqnbfLv4ici6Skv2L4zKUGk9+9/mSf4W6cz03PNWPkXm3v9JhO1 j6G3PLLISG1fLcyf5MT+QdTAgQNk7Jmz+bw3/XP3E3vesDkrrndrY0b2GZri0zyaOzHUIzBqxvCe vcbMzhpxY9blXuayUw9m3bho5PInlg5va/T3GZM2iFFjhUFpY/r47R/MunvRWPe27t3t7kBccygt ydM3a/rgzJyxlwWTgp6kIX37hYK9eiZMLlt/dv65RrGJzcaX2kv2Z9T+2us3IviC7YXfe1P7cRiI v15M3DNxDxNU/qT5XM27neuqlwLSLaP7+Hzmd+Dca3uPQVn94+P7Zw0aPLZ/QkL/sX+/ftCV8saV gwaNk9/j5OlnFfo8rqWJOOF51mOfjgpXZF4ee/B+fPLNN0+aPGf2pA3fmjRx/oJJE+X/66TW+Mo5 SutDrZ6inxj0skgi7lKFDw93x/Mv/F7vk+jpFS/bGzFiz/DhBKCUzk07vyGv/WhCzszxEu2tiTNz ZG6C9qa6x9V3b5swft4FwLY19gLbe84V0bmQaNPl/z7Cpv8u3dlrwHUJ1zEX9khVGo7F2Ld9MkTv DLQPUC8jibZtnsS+Kb364VRfryGh0JBe3rYST7BfSq++iW6tpyZvTr7Cvj76I3nt5egC1Ta5873E RLTrzznzI2dQDBIZ4kvrjSPoytBcgzW9t+ZK0FwBTfdrcZnyxTgu3jZDZGrx9ow+CS/YFj830OEQ Q1+yeUQP48QkPw979MoYqBangS9oc59zJCR4B7+gFT43qc8sb/SPIJg4I/4+eDsjHnxsz5UyrIar 15fB6g2Gd5hJowfGawMztIGDtQG9tYEJ2sCANsCvXUAnpcrF94h56cfqxvqo9/B+ie0LZh8rmMdo 1itBN+n6flof+0eJ3St9qZkD+l9xaVxbt0CPeJfd5fdqG51Jg68aNuL6wcHKhJ5txba2p7V5WmTE qM+jq+HnruRhA0PDBvS9xPaax+9xyD8uOnvyCtvdf/+1+TeEHv7Hol1xkbLzXxfbuosRuwf5eVQc C/8lae6SzuJs/GbRy84Xl9eShv9LcQ/+BnkkRj7sEM/PvYM6yUP/m8T1tuRv54vvnn9F/LYu6ZIu uQjJUfLe+RLoGxgfWPt/KO/+/ybxP+6SLumSLumSLumSLumSLumSLumSLumSLumSLumSLumSLvnX RP05ssZ/80nHiHrhFPeJ7uIW4wsxQHRXqZlfYHxMWmMcFQM0m7GTNEHlU4xm0lTjMOkqdWeDTO3z jYViHuX3iXmUbyRNMN4jTeHpPMr/F+kqlW4wPifdJOLFPGqliltEjXCIW7RiMVMsoIVjXHc3XiK9 RaUL6LGGdt4mTTUOkK5S6SZ153njoGYjf0xLoN+vSFcZrVoqd05oVer+cpWu4+k+0gTjCClakaYa n5GuUvkNMkWf6fK3anB/E+WbSROMj0lT1J1UymyivLy/yfjUPh89D5LeYhy1z+fOXmw71NZXCOu3 lxSo1K4sHlBXMm8TbvsgEf2tO2PtDivvEEn2FCvvJD/Byuvk51p5lzhtL7PybjHI/pGV94iQY4mV 99o2t/cVJ+Y61lp5nxjkOGTl/bYHnG4rHxAlrs3tvwNnuNtn5TXhck+w8jbh8Dwa/W034lLPeivv ED7PT6y8k/zTVl4n/3sr7xKrPNusvFsketqsvEckeCdZea+W095XnBjszbHyPpHovcPK+7Xp3g1W PiBGx30gf0uRw2PZ2cybdjbzpp3NvGlnM2/a2cybdjbzpp3NvGlnM2/a2cybdjbzpp3NvGlnM2/a 2cybdjbzpp2fFCExXGQiWeRmiGKRL8KiXFRCkYhw72pyYVGh0lzuFJMrExk8mSxKkJCYxb3FYgnP KtVVId+FlF5OWkDJq6lXQpk87hVToliVy4VS2ipQZcu4quRemXpm1i9GgxDkUk7+ZpsarlaQi9CX LFNFixHuF3IVVr8lp4zWikkXq1bKrVYjlCi1+pQlQoyxXPUpe6lUY7lBjbWIO3KMVdwvVDXC6k6J 0jpijSOfJ0NUy6XqTolqMRcbmfejvZTSTomyWIWlZRl3SlWvZptynJEYDWSPFWospr2j1jZ1lz2V Y4EQ4zctLrUqpaz83T8RdSVHHGn3h2kzs5eQ0r3MGle5sm2eKtmhceyIpNWqVT1z1Eu5zlDxEOvN gaq1UtVCjbJDleX5WHtLj5njL1T6y/GbfgmraJDfZo/S1yHaqGgfjanjYqtMJVcrrdYjjML00PJ2 L+WqGMnlbmmncUWjOR9NclX/+Vb/GReI+rHnjTMkruJZCa2NbZ8xo8RcK4KKrVgbRWujedq57tD2 uheeCYVWTJsjzLXGtFg9NXUstKwo9S5Q0SzHsFT5MVrnwk+L/qlZ3RFBpr/mcFWsdJD9z1YzINLJ t8MsDcpjRpBvzcWIGmWhiu/p3MkXacrv6ZQpUO1fp7Qy60aQCqw7DFmhJEPN+86aZ6jWSykTId6k /ovVCCpooYa70qtFaixyNnVuNXpfriimB5a2t3eL0tmM5BoVgZVKw4iaa5VqbTBrh9QY5DwtVFFW rPowLZSn6katdy32m84qadYNxzwx53iBsknHvF2h+spX8/pC/ZrXsmw+UVSlbFjQPg8K1HO50pgj iMZ+hRppmRX9ZluFKpWz+dxxy+fmqpFGrXQVnaWMq7B9Hp+vVdl5LV+8jTpaj67cIWvtNaMnv9Ma eP7YO+K1s17jYiwgR2KOxdwJolEfbt9VCtS6WqbW19xvHKlp59xONi20ov/cOSCtKiOvStUsUGuU HE1hezuyZIla5/43D/2/mhcdc2KY0kbOAXN3ylC+qhDVT4aGZ2ZmhWYU54fLK8uLIqGry8MV5eHc SHF5WUZocklJaFbx4iWRytCswsrC8PLCgoyrc0uK88LFoeLKUG6otLygMFwWqswtqwzxvLgoVJRb WlxSE1pRHFkSqqzKi5QUhsLlVWUFxWWLK0PlFI0UllKzrCCUXx4uKwxXZoRuiISKCnMjVeHCylC4 MLckVByhj/zKIaHK0lw0yM+tIC+rlFaVRIoraLKsqrQwTMnKwohqoDJUES5Hb6k2rZeUlK8ILUHx UHFpRW5+JFRcForIcaAZVUIlxWX0VV4UyiterBo2O4oUVkeoXLy0MCNkDXNgZag0t6wmlF/F4E29 I0vov3BFKJzLWMLFDJuKuaWhqgrZDS0u5k5l8UqKR8oZ0HI5pNzQitxwqdmXNHP+ktwwihWGM9pN PzbaZ+iq8pKCsdIxo+ZiIIYUGpUxerj1dKh8GuOEQixNh7n0tLhYalSIiuHcgsLS3PDSULl8EnNZ dGFXKwMxrjllxRHqz47kRszRDqOBctVBPl6MhIsLKzOmV+Wn5VamhwoKQ9eFy3kaiVSMHTZsxYoV GaXRxjPyy0uHRWoqyheHcyuW1AzLjxSVl0UqraIyX5TLAJbKcreUV2HkmlBVZSFKMCT5OJSLTwvD pcURqVBejVLv2jnTJ/M0rC7weEGV6dsVS4rzl8TU5bu4LL+kqkDaojxUUFxZUUIH0voV4WIK5FOq sCySEYr2XV5GaKQVp4cKS/NkpY6myqKFL6iRKi6DG/NXYp58MwLbe1d2tdoapxRIK6YXJoE0fVhO lYLyFWUl5bmxnaJzrqkphm/3QHlVpKIqgtmXF+cXyjJLCksqzhnQxfhCeWJYQWFRLtMpI7eyojr6 my6NGeKlC/xPKuV7mJ33Di/vyy7DILVZb1hCS+N7rRDt724X/nS3t/h8GmW0rRdb3u+X5W1ZF1s+ Pl6Vr7/Y8gkJsrz9+ost362bKv/WxZa/5BLKd1e/b9XN+54sL9+ye6vfsTpA+MU1IkXMY2W+RWSL BWIqK/Y8zSYKtARRrqWIlVqquFf7ltioFYvNWrnYqlWJP2nLxU5tldinrROHtA3iM22T+Ep7HudM 1eLsM7Qk+zztcvt8LdN+izbG/mNtgr1Fm4Kqszvroc37J/VYix4/QI9H0eM36PEyeryFHu+jxyfo 8QV6nEUPD3oE0aMvemSixzj0uAo9bkCPm+h3QWc9bM/H6BFAj97oMQI9JqPHv6HH7ehRjR53o8cG 9HgEPZ5Gj5fQYzd6vI8ex9HjtLZO07UNWnf58xH0GIIeWehxHXrMRY889ChGjzB63IEe3+msh2NC jB7x6JGKHmPQYwp65KNHGD3uRI/vosdP0ONJ9HgePbajRwN6fIIe/62t0pzo0Q09LkWPdPQYgx5X o8ds9MhHj3L0WI4ea9CDGNJ+3FkP5zsxeiSgRwg9xqHHNPS4Xf4/WdHjh+jxM/R4Bj3q0WMPehxE jxatStO05VoP9OiHHpnoMR49pqLHLehRhB4r0GMtetyPHj9Fj8fQ49fo8afOerg2xuhxKXpkoMc0 9Pg39FiFHuvR42n0eBE9XkePA+hxFD1OaeWaDz1S0WMUelyNHjehx0L0KEWPVejxH+jxEHo8gx5/ RI9t6LEbPRrQ46hcV9xO4dYrdtbz2VmhLk7V15+Sl26PcHtfqTuCfF33Tt3Bur8gqkRLY2NjCyU8 buF21+5Qn1p7tKWW6qQHKty6cLt2767OzKzevVt3Cl1vSapubKzWHUJ3Vsjmzc6S5F15XxapaKTj ao9NeOz19aJefeLshse+aJFYZH7q3fJnPPXWR3cL3dv6vvyYfci2Gq22+FTodqE7msyyZs9NFZlN Lofhcixqke1lqsKqWrXbprkdqix9mwNNSqqQXes2oUuVuG+zCRtZm1vYPO+/b7drbufmzZvlcPWs rPnzHziblOTWNberertsaHu126nFmlRzx51nUln81O7du08pk2puzzeY1IVJd5SUZGWVlOy4sEk9 uvC4fD5fLa3trtV1obuqd5+tr6/9321qPY0a1Sv0uDN1u+ujotqRCuJJs0k+Zrct55rW7SCiFkVt K0ureiigeUzbSiU8TuHRKx6Isa7jgtaVxfCMCqaodT0uzePOzlNN5WV7dM3jYoSmfT1xmsffxOeL pv9c9D6ya9FeRBZyqwHIUnEezePN5nS+rV2KhPqJYJ3HSWvYu6kiC4MT3h73tqKi7KTsoqJtLl24 XNXrpG1rXU7NZU6anRVeXfO6ozbnka653FjoLL732jSvo93q9X678Do6zI7hrQLRj8uruXyxlt9d r5ozbb872rS0vsuhuSzr18u8rsyf2SQti/1PqfazVA2zcq3sy1nf7gKvU/O6TBdIjVw2zaV8oJyg 2cjbvMIWJ3VwyKJyhqjwSoo6wuti4NmrD8sGD6/OlnZwncUVp5QrvD7NG2iqaOFzYKuUNzPfzNyB yGqes23Ed5v0m8+reeMmiDXiSN0rlhypWyMm1mloqWxbfXZ7/ala37qz1arqjugU2GHa5iyWP6s8 4qqWPZ+qjnNpcR6dz3LVy3LTbmdxydnaf+CSpvo4mxYX4xLlE//7dUasT1yay/NBm5qjKl+r+jGj ovFUjE9a6hdltiif6PhEOqU6S9VQdduWy86iPpE6xekizlV9dp3Pl5WZKTIz/4FX4pRXvC7hdffO zi4p2d3W5vPFuRn9hDUfqjY/XDMhTtfi3NIv9Sqpj/NrcfFNWU1ZLdUtau3d88CeB9584PWk15OU 4TpcU++P0+J8E8Waug9jDPJh/Zq6ifWiSSxSLUvvNFX3lu6J84g4zyt1+Wzio5HeKpVXr6g1jqLr mCRnS8z1kXr1289W+1yar8NZ2MTtkitg2462+lfbai1vRN1VH3AYcQ5lGuvT0uSzab5Yh9W7fZo7 8EGT0XJUxZspqtUP2j5Rho92obymFujGU01mXadU7ZRccE+1eJ3CG/UbjlO1dlie89lsPr29S/Tz 6ZrPrVzXu8N3zhjfOaXvNJvP8p1P+U45K5A6enRR0Q7D0HWfR/N5L8Pii+potF0W1a2pu0woU7W1 tXuy3hfQfN2aejf1bsluyW4saSyRE/31da+v2+bb5vO5aeps2+vbtr1uejPg03x+2q5fVM9/7bII f15WL1pEpmo/e/Wr+DM7oN+DbzzC5411aKxL5TqMEe/RV0t7qCU2q/Yj+vmoNsvv1vxeO59xa45u 27bt6Jpx7GssuquPbjNkTEqfOWPcWh/vMHzOWL/iWL9N87dPDvXx+DRP/Lme3ZGp2j5kHNmmPu09 0e/qbLWiR71br7Qk8ghYGa9yBkX9i4NVTbOR1407/Dabv8PDUle/S/N7qs+u1/VAtqmrPDGYPo5x sk+zBaRaTqfmd6uThXJFILVH1Mu6sN5ovOJntvnCnl8TLhHBxeHCpWJsSW6kTEzniTZ71lUhkcRb oqHeZHTeHYLWlSZcnOAT1X3zDqciztI9EPsNOTnXi/6zZs4IicybZ00LsbeZZeQ7ZYL6/QUGea/o 1t66Q8Rx/ky2rpzCJy7hLaVXfkVlhXhMpU+pdKtKf6fSP6r01aWF4TKxU6V7Vbpfpe+ptEmln6i0 Wf5ERJyQqaarNEWlGSq9SqVzVXp76dLSpdpqld6j0vUq/ZFKH1bp4yrd0v5m+I9S7SJTDh7YhvMM Fmb7xy7/d/ds+MH/T38HeJ/KELPUT9/vEhvFz8Sz4lXxtjgsTvAe4VEjdVujbRbyzzrt1AsytzX5 PqCNNb/X7je/H9oUU4d4O5rS6VpzRjpf6w93vvbc1/na173zderyztd9znned2Pn6yFPCI8t5npo ScxzXWgTn+t8fa2Nby8xnSZyGE+AOndhqkxbjlhje8z2rthsf8j+kNjviDgeFe849+lrNbt3tjdX e9F7b5ym7fQl+K61Xe27zfewrcZf4L/d9if/Gv862/aALeC2vR34OvC17YDQ7syRttH3+bdeUHYh +/2HYuQjS3ZdQI4HerdLX2QkMgEpULLxXPHvCjwY2JKwwZJNMfKYktMXkm6OblPb5e5u69ulxZTu PS4gaUhG8P4YedgU9eQcCf4q+Gq77Ex8D2lS0nYh6Z7Ww9ejb8+7LbkvRu5X8uoF5a2ep6OSFExK aZdrLJl6QclRMtf67ix1VirL7VCyv13M2oeSWpIHJRckP5z8hJRzW0/eciExW09+IfmwJV91iOwl +bTqq05y6fR+Ge0yqd+UdplvyQIk0m9B/wHIyMv7Xp7VbwFp38t/N+CPA3cp+TTtRqQgPQUJpTek N0ND+olBfxy8UUp6w+Ctgw8hp4bYhriHbEF2ZgxHrsm4cdgGS569IjIiZcQHI+8ZnYYMH+Mbc+OY kqzHLdma9VLWzrGpyJCxy8ftzm6VMr52/BYln05InXC/JQ+P/5Tr+yc0qqvGCZ8j908MTlo+6bHJ Pa6dhOy4Lmd8rVma70az1A0DZLkbRk71YtQBUzdMCyjJmjZLyVfTbdOTpved9hW5HKRohpihzyiY 0Tqj9cbeN35CuayZN8+8eXoOaZ7MIUtmhmfW5ehKhuTcqGRRThksyqnOuSunmufhnMabbr1p0U0n bjoxK2HWw5QbwjP1ZNapnOrZebNL5uydd838hm9t+Nambz22+K7FjUvmLqmOfi95aslTxZll68s2 V7QuE8smLFu07PZlkWV3Ldu67NVlHy07vuxUWA8Hw4PCI8NXhXPCxysTKgdUVlSurtxQuaOyKTI2 cnPk2UhTVUrV/qrTyzOXFy2vXr5p+XMrUlbcvOLZ6iXV91U/V723uqnGW9O7ZkrNhppdK/uvnLJy ycqVK+9e+fjKrSvfviN4x5Q7Hrjj2Tt4/69Nqp1aW1C7pfbTVYNWRVZtWdW0OnX1yNW3r167umFN cM2ta55Y80ld77o/f8OqtfXclanzulP3UYfIFeXOQIeYa8k3zL6p5865zjPFjPULrj/RNShGOq8i d47sELk+3HlVh5grg1xNEx5L2tHzflbk/RMaWT/Vaqy+WXm7TWWl3Rh4MGGDf1d09ey23r+/W0u/ +bKuf2tgY8cqalqJdXqCWonNUr0DD0atJ++qVVmW3S+fq/KWBWl3q/8Qa/qD1NivWtuFdhv43q+k Y5/46Jz9YULMjtCxJzwo9T5vH3js3H2Atd9hrft3R1d81Q61AxPIb4yuhfjjCctfrE7mCmSucJYf WRVZA6XX5revj1GPssolTZXlOzzcbwrtyOdfcT8n+TDX50UDa+D+mNX0Amts7Jp6/npqrdo7VByZ K+ik6Nop13TuTJHtcj0lKWd02sybE9vMnUx9s2v1PM1e1dbDxz5k7TzRHaV7j8S2jt3HjEe5v8ny iW2yBLVf7eGTT+QdtZdxRz7r3sO/KxqnSSk8b6IH2uh5t7pS9zt21Ng9Veqk9s/oDtq+h7Jn+i6w Z95/3p75lrlTskcGo2Ph+WlTD6XJ3dOyEt9LugbdOnlDWvHcmRu1uDkjpW3NiOk3H+tPlb6VdknK Cd6vPP+E9FTM7M5I3tK9R/teu99qtc6MB+kXM76St1zet/8AE3NX6z9A7UQxInc1c0dTe+K/KGof jZHzS6jdNUasXbZdzq+hdtd/StT+e9HSvkt/g5xrKSnte/c3iNrNL1rUCeMi5VzrqHNJjJxvP3Ve iREZ6aan/zk5v+V/rN3FiWlneV4JPJjdOtU7/lP/fnnSUVIr72S3ytONvBpfO9Urzz3mMymcmobI k5J5V+1Fn5uiTkST1GlKnpsaJzSqM5E8NzVSo1adR/T2c4uUITn6zLwcXZ5Z1NUQ62Rj5odw7lki 76jTDfXktxRZnhq6am2RejpEpslbKD1Enp96+KYFZubJs5Y8ZynJUncC8pylrrJm5smVyHqGyGVC nsjUCc2mzmaILE8NeYKjpDyNdZzPpmVN+FzZ41NpiZtOmHbIblWjQV9Tz+k5smV13rPJtsx2O8/D 8/0ZGwUDd5lXQtfqjb32Gcav7HNEsn2+iLeHjaP2P4t0YePJG1w1qlyzfY5xVGik/y1spPvs8419 vJs/bbSK7Uartkj003LFHC2P73yRphWIVG2pSKXkTfJvx9tLjL8IjXY+Fg7KxlM2lbLxlPWq9pop 9YXwaAtECs+H8nwhz4fxfChtDaetNGr/UukTR+5Z9E211xqv2FcZj6DvCPsR41H7R2Ko/WMx3H6U Z58ZjfbPeduNantYOMhdJv/WPdo8TUv7RLWIF6NEAowVfcQ4KKD9QiiCSuOgiKBVFSyHFVAN8m/s rzReE3dALayC1fBtkSzuhn+He+BeWAvfgfvgP2AdvMgb+EtwinwbGCJZE6BBjsjSboJZMBtuhmIx U9shejLihfa5Itt+m/DZF0KJKLOvYaR3in72b4tUxyPGa47N8Ci8LZId+2A/vAMN8C40wgF4D96H D+CgSHYmGI3OJuM151+Fw9lM/hi0GK/pTjFKT+d7hOijj+a7xGjUS6EMyqHKOKgvB2yjYxsd2+gr Advoz4gsfSv8Hr4WWa5BoqdrMCwUya5FkAfLIAw1UAd3AjZybYDvwyPwqEhzPc33MTgOLfAFnICv ARu686EACqFK9PQIkeUJip4qdo8T116V+wyvnxKJRO0uonYX0daPaJtGtN1FtN1KtC0k2nKItusp XU+8XGWfS6zMM54ibuYQN2tpIWL/s7HJfoQ4+1h47Z8YL9s/E9NUnB2l1CeiW/usWCCyY9pfSPuV tD+H9idTOs9qezu1xtP2Ztp+2movRwRiWvHSyhhaKaOVbFrJtubEGLQ8Skuzaen7tJJDCy+rkf5e 5ZJo40+08SfaSNMWGi/RTjbtFNPONNq5lXamaMXG27SVrT1gPE/NP9Bed9qrQbNK2kxBsxpa22g/ bHyBdtvtnzKzPiPmPrdmrD9mxg6l1eHW7Jcz9h1qHmTmzTAeIn7jzBVG/kyX+wfET8S3jWZxN/w7 3AP3wlr4DtwH/wHrYJdxRrwBu2EP7IU34S34T3gb9sF+eAca4aDRJg7Bf0ETfAiH4YjxlvgIPoYT xrviS+ND8RWchFb4Gk4Z74j/Zk6fhjNwFv4ObehiGM2aAE2tip/YbzVa7P9mtNoX8L3IaHW8bTQ7 9sF+eAca4F1ohAPwHrwPH8BB+NQ44/gMPoe/QjMcg+PwN2iBL+AEfAlfAbo42sBgznY33nJNMs64 roWpMA1uND503cz3HLiV57fBAuM110Kj2bUI8mApz5bxHYYI+RVQDTVc1/Jdx/edcA/5ewE/uL7H 9wa+vw8/IH8//BB+BD+m/Ue4/zPyj5F/mvwz5P8A+MiFj1z4yIWPXO8bba4PAB+58JELH7ma0PFD OAz4yPWZ8a7rc/grY2mGY8Y7ruPwN9puoe0v4AR8RVl852rl/tdc4yN3PhRAIf6yifUiiKdOC7tY bxxo372cXL3IlfyXT6uI8kb7m6Kv0LjbKq4hMhuIzAYis4HIbCAyG4jMBiKzgchsIDIbiMwGSh8i 0s4QaWeItDNE2hki7QyRdoYoaiZiWomYViKmlYhppb899Ndk/xYzIRfyjI/t+cbHRE0DUdNA1DQQ NQ1ETQNR00DUNBA1DURNA1HTQNQ0EDUNeLIVT7biyVa82IAXG/BcK15rwGsNeKsVT7XiqQa80oA3 GrD6Gax+BqufwepnsPoZrNqMVZuxaCsWbcWirVixASu2YsUGrNiAFRvUjN0jXNgyi5mss/c+xN77 gP0t0cf+n6K7nd1G2feoZd8PlX2/w9WVXF2Nfavl2ULMZ58Msk8G2SeD7JNB9skg+2SQfTLIPhlk nwyyTwbpaSh7ZQp7ZQpz9hBz9hBz9hBz9iBz9iRz9iRz9iRz9iRz9iT7aTxz9gBz9gBz9gBz9gBz Fn+z2s4VaczTY8zTZubpMeZpsz1PDLHnQ4kosPbRy9hHg+ydQfbOIHtnkL0zyN4ZZO8MsncG2TuD 7J1B9s4ge2eQvTPIXDzAXDzAXDzAXDzE3DvJnDvEnDvEnDvAHhdkjwuyvwXZ34Lsa0HmygH2tiB7 Wwpz5QD7W5D4P0T8HyL+DxH/h4j/g8T/QeL/JPF/kv0vnv0vnvg/QMwfIuZPEvMH2AOD7H9B9r8g +18QT803jsmoZ4zMbU5p61m957B3zTUOsar/lOdr8cfzPH2cmB9uf5s8s9L+DvuY9OG7lD5IqUZW 6vXGaq5qqHuAuvJugbUP7qHuUOrupd4UoVPycUquouRhSv4XJW9XpywZOU+plm7j+Qye7+W5jJGr aGkdTx+lpTRa2k5LQ1T5ZnVaPKLSVva/eM6Ct0IJlEI5VMAyCEME7hPDRDetXs31B2l9o+xdeXYz /EGMtL8ChznnHhFTOCvGs38HOSsm2z/l+zNOVp9z76+czOzU3EuNHpwsk+XOTv0Skc0+divnrttE jn2BOoOxS6NZGpqloVkamqWhWRqapaFZGpqloVkamhF99HEbJ7YFfC8UZapmkJpBagapGaRmkJpB agapGaRmkJpBag6n5mRqDqfmZFUznprx1IynZjw146kZT814asZTM56a8VbNaVZNeUa5DY8tZF5J G7+kTgqnsdZh+W8Q2ctvglkwG24WHk5wHk5wHk5wHk5wHo/8d4sOLNydOrfLfy+qzuPSRx+J/Vqa cURLh0EwGIbAUMiAYZAJV8BwGAEjYRSMhjGQBVfCWBgH2TAeJsBEmAST4Sq4Gq6Ba2EKXAfXww0w FabBdJgBN8JM2GQc1n4KD8LD8AhshkfhZ/BzeAx+AY/DL+EJeBKegqfhV/Br2ALPwFb4DTwLv4Xn 4HnjSyxyWHvFOKi9CttgO7wGO7j/utGg7YS/wC54A3ZzntgDe+FN5u2tRO4CY5/jNeNLxw54HXbC X2AXvAG7YQ+7wV5402hwdjMOO4PGEWci9ICekATJxhH9e/AT47CODfSHjWb9ceNL/ZfwBDwJT8Fz 3N/G93Z4jfxbRoO+j/KcW/RW44jrUuOwKxUugxD0Mb509YV+0B8uhwHsHAMhjXUrHQZRbjBcAcO5 HsGzcew22XzPMr5024wjbjs4wAk6uMANHvBCHPjADwGIhwToBt3hEggah92J0AN6QhIkQwr0gt6A /m70d6O/G/3dfaAv9IP+cDkMQKfhnBtGwJXsfGNhHPcmwRS4DhbSXx7fRTxbTLklUAy3QxVtrILV sAbqKPs97v+c8r+k/BPGQfeTXD8FJ7h30jji0YzDHsbqucRo8DAOT6LR7AkRQ9WajWixgwOcoIML 3OABL8SBHxKMo1o36A6XQBASoQf0hCRIhhQiLNU4pl0GIegDfaEf9IfLYQAMhDTWmnQYBINhCAyF DBgGmXAFDIcRMBJGwWgYA1lwJYyFcZAN42ECTIRJINezq+BquAauhSlwHVwPN8BUmAbTYQbcCDMh x/hMuwlmwWy4GeYwvrkwD+bDLbCKsayGNVAHd8Jd8G24G/4d7oF7YS3w1qFtME5r34eN8AO4H34I P4IfwybWzJ/Cg/AwPAKb4VH4GfwcHoNfwOPwS3gCngR2Q+1p+BX8GrbAM7AVfgPPwm/hOahnLX8F XoVtsB1eg9dhJ/wFdsEbsNs4zipynFXkOKvIcVbpe1mly9kHkln5s9kHkln9s1m133Ww4jlY8Rys eA5WPAcrnoMVz8GK52DFc7DiOVjxHKx4DlY8xxbjmOMZ2Aq/gWfht/AcPA8vwIvwEvwB/gh/gj/D y1APr8CrsA22wx4R79gLb4p4ZzfhdQZFwJkIPaAnJEGyCOjrjGP6d1mFvkf+R+QfMI7qPxFeHR+w mh3XN/OMsei/4Bk66+iso7POKq0/Y3ymbwX01dGXVe64/jvK/557L/L8JUBfHX119NTRk9XvuP46 ZXbx7A2ud8Me2AtvwlsiXt9H37zh6bzh6Q3ce9c4zUp5XH8P3Xir049S96/km8lzxtY5Y+t/A95c 9C8ofwK+hK/gJLQytq+Nz1wB45grHhKgGyQZp13JkAK9oDdcKryuVLgMQjCAU+FASIN0uIJ7w/ke ASNZecfAOOO4K1vEu20i4LaDA5yggwvc4AEvxIEP/BCAeEiAbtAdLoGg8LoToQf0hCRIhhToJf8e JqCnGz3d6OlGT3cf6Av9oD9cDqwz7sEwhBVxKGSQz2TlvIL8cOM4K/Fx90jyo/+Ht3uPj7uu8z3+ 60yatJOEKJSryGVhFXQRRUAXXF3W3UVUvOyunhbPas5ZQFpuKm0gaAFtFbm13FqKBawSC70silJ2 ac62G4HaUDsNTZNOtGnStM5MyHSmk/ya2qB8z3NmI4f17D727ONxHvvHy7nkN7/f9/N+fy7f39gE vA/vr3RmcVyAj3t+KT4RctM+6XOzwsS0L1jblX72RZ+7CrMxB+50p9lXTrsR8133FtyK2xx/h+up eZ26OG2px2XO9TC+g+V4wvmexCo/X4013osdd9BnXw0T06MwPH1KlJo+Teem4fSUxzd7/6ioSTcv TjeVph/rveNwfNg//QScWPlGslLdk3upO1TlUHVftvH19xd6f0H1G5TKHqscTU18JHw2eWnlm6ko VflWq/qzP0q8O2QT5+J9IZf4kMePhB2JS8KLiY/h0tDlTBk7iqwdRTY1M7yYugy3e/5t3IE7cRfu xj1YhMW4F/fhfjyAB7EES/EQluFhfAfL8QgexWP4Llbge/g+HkdbyDa8M2SjpJWOJ2a6G66s/0Lr j60/TlwQMtYfJz7s8Y6wJ3Fn2KNvnaJnneLIF1N/HTKpv8Fn8d/xd2FPag6uwXX4Eubi9hCLLRZb LLZYbLHYYrHFYovFFostFlsstlhssdhiscVii8UWiy0WWyy2WGyx2GKxxWKLxRaLLRZbLLZYbLHY 4vqPhj31H8PHcSk+gU/iU/h02CP2mIfvCzs5lElUfQzt1e8iThb7GnGvSXwutCcux7W4I3TSoLNy NyL2NWJfI/Y1Yl8j9k6xd4q9U+ydYu8Ue2fqptCeasVX8XV8M7RbV6d1dVpXp3V1WlendXVaV6d1 dUYXcaCFAy3WluVAi/VNyKCyDCpb5y+sZMhKhpKfee2Q9TZN3s2cNXk3c9bkd4QZ2VWWXWWrG7K6 IasbsrohqxuyuiHOtHCmhTMtnGnhTAtnWjjTwpkWzrRwpoUzLZxp4UwLZ1o408KZFs60cKaFMy2c aeFMC2daONPCmRbOtHCmhTMtnGnhTAtnWigwRIEhCgxRYIgCQxQYosAQBYY40xJ9mArNVGjmxTYq NPNjW+Ij0QminyX6Wdx6l7vX703eQ793cq6ePTlXz568L27m1TZebePVNl5to8YsasyixixqzKLG LGrMokYzNZqp0UyNZmo0U6OZGs3UaKZGMzWaqdFMjWZqNFOjmRrN1GimRjM1mqnRTI1majRTo5ka zdRopkYzNZqp0UyNZmo0U6OZGrOoMYsas6gxixqzqDGLGrOoMYsazVGdXCiL+EwR3yLi+SI+WoTX i/Bz0fE0epo+T9OmizZddGiiQeX/P1ot/qfF/7T4nxb/0+LvEn+X+LvE3yX+LvF3WUeXdXRZR5d1 dFlHl3V0WUeXdXSpldmU/tf9bjQ6K/FpWTpTr5utz83R467GNbgu9FS/ufhdr5uvZ9waXqz/asjW fw3zcQtuxW34Or6BBViIb+Jb0Bvr9cZ6vbFeb6zXG+v1xnq9sV5vrNcb6/XGen2xXl+s1xfr9cV6 fbFeX6zXF+v1xSOmI4V6PW9K9duvytpjNd6nxvvUeB/d6ulWX62em0Kf2u1Tu31qt0/t9ll7bO2x tcfWHlt7bO2xtcfWHlt7bO2xtcfWHlt7bO2xtcfWHlt7bO2xtcfWHlt7bO2xtcfWHlt7bO2xtcfW Hlt7bO2xtcfWHlt7pWfNDLuonaFw++s9qxLRrugcEbX5+a/8fIIb49wY58a4Y3/h2Hc79gMqJSXS M1RKSrRnyKN7Kr2fQ+McGhdlmyjbRNkmyjZRtomyTZRtomwTZZso20TZJso2UbaJsk2UbaJsE2Wb KNtE2SbKNlG2ibJNlG2ibBNlmyjbRNkmyjZRtomyTZRtomwTZVt0nkhaebOVN1sTs6Nj+LNVBFeo gIIK2CuSe0RyokjeIZITRfIOkSwSyY94t5V3W3m3lXdbebdVVK2iahVVq6haRdUqqlZRtYqqVVSt omoVVauoWkXVKqpWUbWKqlVUraJqFVWrqFpF1SqqVlG1iqpVVK2iahVVq6haRdUqqlZRtYqqVVSt 6nhmtY7fL4rtonhm8v+PrewrVkb14u0Ub6dYO8V1tJiO9pMfiqdTPJ3i6RRPp3g6o9rEPB63yOAb w3BioU/fYz4sqXzH7t3DiYVhPJrifw9FZzriUOIm77VW39+W+FY0PXG7T9vLJ5ZGb0os8/7D4XD9 W3Ai3oqTcDJOwan4A1yOK3AlvoirMBtzcDWuwbW4DtfjS/gyvoIbMBfzYH31N8Ka6q2p/uZwuBrP YSvNJuaHklhyiQdDMfGQ9V+W+Iq+dgPmefcmUbbi1rA9cRu+jm9gYfTWxLfChsRix90b+hP34X48 gGVhs/g21yf0siRqMBW1qMM0TEcK9WhAI45AE96EN+NIHIUZOBrH4Fgch+NxAt4SyjQs07BMwzIN yzQs07BMw3L9BWF7/YX4AP4EH8SH8Ke4CH+GD+PP8Rf4S1yMj+ASXC6OK3AlvoirMBtzcDWuwbW4 DtfjS/gyvoIbMBfz0IIbcRNacXPYHNXInD1UHKTicGJpeFUuLQyvyJND0ae4EHMhfkMm9Zg4RROn 6IgileNEZZf2d6FowhRNmKIJUzRhiiZMkfox9WPqx9SPqR9TP6Z+TP2Y+jH1Y+rH1I+pH1M/pn5M /Zj6MfVj6sfUj6kfUz+mfkz9mPrxf5jBH7WOj+HjuBSfwCfxKXwalzvHFbgSX8RVmI05uBrX4Fpc h+vxJXwZtKFuTN2YujF1Y+rG1I2pG1M3jqZRd0CGj8vwQuIWObwwmkHtIWoPUbscfYnGHTTukOlZ R6ZpnaV1NnGzSp3PiVt88tZwQOYfkPkHZP4BZ6nlwxY+bOFDKbFIx7w37FUBe1XAXhWwVy3t0Bs6 edTDox4ebeHRFh5t4dEWHm3h0RYedfCog0cdPOrgUQePOnjUwaMOHnXwqINHHTzq4FEHjzp41MGj Dh518KiDRx086uBRB486eNTBow4edfAoy6Msj7I8yvIoy6Msj7I8yqqQAyrkgAo5oEIOqJADKuSA CjmgQg6okAMq5IAKOaBCDqiQAyrkgAo5oEIO8HgLj7fweAuPt/B4C4+38HgLj7fwuIfHPTzu4XEP j3t43MPjHh738LiHxz087uFxD497eNzD4x4e9/C4h8c9PO7hcQ+Pe3jcw+OeaDYHCxwscDDmdzsX Y87t4lyJc2XOlTlX5lzF/2P5/xz3CtwrJO7y3j2cXhye4uB+Du7n4H4O7ufgAQ6OyZNuLua5mOdi gYsFLha4WOBigYsFLha4WOBigYsFLha4WOBigYsFLha4WOBigYsFLha4WOBigYsFLha4WOBigYsF Lha4WOBigYsFLha4VOZSmUtlLpW5VOZSmUtlLpW5VOZSmUtlLpW5VOZSmUtlLpW5VOBSgUsFLhW4 VOBSgUsFLhW4lOdSnkt5LuW5lOdSnkt5LuW5lOdSnkt5LuW5lOdSnkt5LuW5lOdSnkt5LuW5lOdS nkv56N1cGufSeLUaF0ZNXChzYYwLYxwY50DlvmmMumPUHaPuGHXHqDtG3XHqjlN3nLrj1B2n7jh1 x6k7Tt1x6o5Td5y649Qdp+44dcepO07dceqOU3ecuuPUHafuOHXHqTtO3XHqjFFnjDpj1Bmjzhh1 xqgzRp2x6B06w4TOMKEL7zPPU4m7RHF3NX+s3vOlWObnD4cJFTeh4iZU3ISKm1BxEypuQsVNqLgJ Wk/QeoLWE7SeoPUErSdoPUHrCVpP0HqC1hO0nqD1BK0naD1B6wlaT9B6gtYTtJ6g9QStJ2g9EV1F 60FaD1pxwYor/SunCnKqIKcKclX9f1cBi2X5vbrhfbgfD8AOPlH5ZuPfz/ZBfgzyY5Afg/wY5Mcg Pwb5MciPQX4M8mOQH4P8GOTHID8G+THIj0F+DPJjkB+D/BjkxyA/BvkxyI9BChYoWKBggYIFChYo WKBggYKVasiphpxqyKmGnGrIqYacasiphpxqyKmGnGrIqYacasiphpxqyKmG3P9DNWQ5lOVQlkNZ DmU5lOVQlkNZDmU5lOVQlkNZDmU5lOVQlkNZDmU5lOVQlkNZDmU5lOVQtjrjS3ale6LzX+9eD+o4 9pK0L9D+v6ajXI4rcCW+iKswGzwXY0GMBTEWxFgQY0GMBTEWxFgQY6G+kgvz0IIbId/EWBBjwR63 RUT/p2YKKj7WbyuVPq6njv9HNWLv3mKPvVAef0u+3uX53fZKi919L42OjD5BuSLlitVd+Xzc4qiF Hu/Q9++E+z61WZnOZZ86s7q7XeL5sjBK4VHZXZLdJdldkt0l2V2S3SXKFylfpHyR8kXKFylfpHyR 8kXKFylfpHyR8kXKFylfpHyR8kXKFylfpHyR8kXKFylfpHyR8kXKF2VfSfaVZF9J9pVkX0n2lWRf SfaVODPKmVHOjHJmlDOjnBnlzChnRjkzyplRzoxyZpQzo5wZ5cwoZ0Y5M8qZUc6McmaUM6OcGeXM aPVu5RCltrx+31KOktX7GnfSXHo1+gxte2nby78S/0pm6UE/3cWJevrm6Zuv9r/FXHpQR1lip7TM DvbhMEzXPF3zdM3TNU/XfKoyGxKhl669dO2lay9de+naS9deuvbStZeuvXTtpWsvXXvp2kvXXrr2 0rWXrr107aVrL1176dpL11669tK1V06V5FRJTpXkVElOleRUSU6V5FSJ7nm65+mep3ue7nm65+me p3ue7sN0H6b7MN2H6T5M92G6D9N9mO7DdB+m+zDdh+k+TPdhug/TfZjuw3Qfpvsw3YfpPkz3YboP VzWu6D5C419HRybWyeSO8GLip/Ly+TA38bPweGIs/CJxMNyZOBxeTjaGoeRZYSR5dngyeW4YfP3f KX82OiH536KmyX+vPMStNm48pcJ+Kvuft4d9gRMv4mcqbTNntniethfdwckej73IR0cnhk2xgz43 7vOHMOFqURhI1mEazEZXzyXf4/1z8F6cFw4kLwx7G5pDoeGK0NlwNfSHhus9UqOBGg36QcNXPc4P +YZbcCsWeO9u792DRXC/0/CA9x7EQ57LnoZHnKMtjDescv4f4kdhpOFp/Nh7P/H6OY9iaujy3svY jp1eZ/BLz3dh0HH7w0DDGA6FgcYZId94NI7ByTgFp3t/Tuhs/Lrn1tV4exhuvCeMNC7Bw3jcjuWj k6ru4dGrVN1J1X6q9lP1t1TdRdUcVXdSdZSqO6m6k5pFahaoWaBkgZIFShaoeIiKZSqWqVimYImC eyi4k4I7KbiHgjspmKNgjoJ7KJj7PQX3ULCfgv0U7KdgjoJ7KLiHgv0U7KfgTuqVqFeiXpl6ZcqV KFamWJliZUqVKVWmVIlSBUoVKFWgVIFSBUoVKFWgVIFSBUrtnFRqD6X6KVWmVJlSZUoVolMTq8Ps xLqwllKb5OBvKPQUVfKJ3eEr8uy2xHBYKbNnJ+KwXmZfJs/6k8mQSdaG5cmG8O1qps8IZydPjuYk /zDcLuv/LPmu8HdU+6nM/7ica09+MDyevChcPvmNVP/kv0qek5wdNqqC9qjB1Xv51OvqP3e1fbxI u9qQsxeccczZep2trIYuVEMXRUdY97hPbfepwz5VqY9x6z3HpzOTFZi3rv3WdaIz9DpD1hl6osZq pM/bOf0s/Mgn3usTe1xvl091i+hVn9zjUydPfirjUwPRW2VUyaeKMmlMJo3JohFZFMuiYdc+KIuG ZdGwrBiWFcMyYlhGxDIilg2xbCjJhpJsKMmEMZkwJhPGZEIsA8ZkwJgMGObYMMdK3BrT4/PR6dbS KN42+7rVrvuP1vAcNodfV/8N70wZcFMoOn/W+bPOn2142OvHQtF5slGNTx228it9oqfirL6xOrzE 8wHv9ng3nZBdVf126xczaPeZ0OO8PdFMV13k6NvUUtYnfuTq8119vk8eosRBShx0hp2JLe7N066z gyI9HnuRCWuccZ0M2p4oyIYUZoSbkmZq0kxNmqnJ08KC5On4Qx6f4fWZOMv+6ly+f8jzi0JsNZdY zSVqLkvdw9Q9rOayFD7c8KVoRsOXYadGhfkNX/V8flhEiUWUWKTustQ+SO2D1D7YsNjPH/Deg3jI 62V42Oceca7HPP495Z5Ce1jQ8ILHn2Mr0ujDL9DvZwMe92AoLGiMwk8bp4Y1jbWow6levw1zwmEO LFJ7WW4ebFzKkYewDN/Bo2GNidxRzcQhTv+lrvOarvOarvMa1z+swl9T4a+p8NdU82vRifwo075A +yztsz7V+MbeJPay2MtiL4s7K+6suCuxZsWafb2v/Bs9xVrL1pl9Y4+YknLFeTLgm9xfz/0F3F+Q +CeObkCHan0hOibxIn6mh2yRp9u9X+kfGVOxz933L/BL7EI/dofbEwMeh7BX/u3z+CvkkI++Llt+ nHjF8xEUnGO/xyJKrnsAZc9HMRZu0pO6deycjp1TvbMrvSnxqvd+g9+GHYnXPAZVPQUJVPpWjWyb 6nlt+KGMnJusr1b9rap+MNkUHky+CW/GkZgRLpKtl8nWy2TrZWbq2uQJYUXyLX52Ik6O/jZ5qsc/ wGnhUpl8qUy+Jfk2r9+OM8JMGT0z+Q7P/whnhb/SG+fqKlu5tpprq7m2WrZ/Sp9cnzzfMe/D+8NP kn/s8QJcGNqSH/D4J/hgWKQqLkv+qecXhdtUxpX66R79tPIvs29OXhadlPw8Zodtle/IG2aH7Q1z 8KXoCFVyhApZoEKOkCXzZMk8WTKv4et+/g18G3fgTtwdHdNwDxZhseOXeG8pHvJ6GR52nuVeP+bx u+HBhu/hcbSFtQ0/CCtMsbaG1V6vwVr8fZipqmaabG0ycLUMXG1fsNZ0a2t4JvykYR2eddxz3msP lzb8L8//CRu8/4LPya2Gzc77kve24Ofe24o0upzrZWxHt+N3OjaDPj/7BX7p/V3od97doVvlzjQ9 21TvZar30oa93pODDXKwIQt52JDHcOhpkIcN8rChADnYUMIBlMU9inHPfx12NBzGhOe/hZxrkHO6 wtxGedco7xqTYUdjjcep3qtFHaZ5PV33SEEONjaEnsZGHOF5E97k/TfjSBzl/RkhZ8LnTPhc47HO d5xjjscJeAtOxFsde7Kfn4JTXeMPvKfD6kZzG28N21X4vMbbo2Maed3I60ZeN96Fu3FPWN34QFih 8lfrVDN1qpk61UxdYLVuNbNxufM86jzfdc7Hnb/N6x9gJZ4IC6o7iat0iZ/oCp12EgM6wj/pBL9U 8Xeo7BtU9hpVu1bVdpi3sYr9BxW7T1XuVI0vqMIfqcLtqu4SlXWFSnpcxdylYn6iYvaokrtUyRZV sEH2L5/8HadnZf+z1f9P+ythW/Q/9auVVrLSxNqc+KEZvS5s0bce17cet6pK9/xH3fN53fN5k2vV 5AzvMAPzVrvP9OowvTr0r1VW/qI+lbXydGWCWXVOv9mn3+yz8t36db+Vj+vZ/Xp2/+SEe0IvWKUX rLLKg1Z5feW3NEyvzQ3/wx73itBhgnWYYJtNsI7X9wgtXt8UHp/cK6xUnyvV50oTbHOD+46Gb+Iu 3B2e19Wf19Wfr+4dHvDzB/GQ18vwsHM84ryPeWwPq+T9Knm+Sk5nzZN+86Rf3mbNlH65mp2cXqvk 5Sp5uUouZuXaPrm2T67tk1tZuZWVV/vk1b7qdDvdTvJfJlyHnFppwm02OZ6XH6vkR1Z+7IvmmRKb TIlN8mGjXPgBpUumwya58EndvFs3r3TxF6naT9XtVN0uJ36scw9Qtkun7qZsF2W75Ea52qGPCTt0 4x268Q45co4cOazL9umyfZP7tS6dtV1nbddZ2+XMNt30ZV10s865Q0fcpCNuonqJ6iVql3TATTrg Jh1wkw64SQfcRNmSrrdJ19uk023S0TbrYn26WJ8utlkXa9fF2nWwzTrYyzrYy7rVy7pVn+7Upzv1 6U59ulO77tSuO7XrTi/rSn26Up+u1K4rtetGfbrRZt1oB3e6dJZunaWbS10c6tJdBnSXAR1kQLfo 1i0qnaFbZ+jWGbo5tZ1T2zm1XVcY0AG6ObWdU9tVfjenulT+JhW/ScVvUvGbVPwmFb9Jxber9nbV 3qfa+1R7n2pvV+19qr1S5dtVebcq71bl3aq8231w3s64sqc+N0xE56myWEU1q6glKmqJivoZn9tU zSG+ruTrSr6uVC05vhb5uoana3i6RkXEqiDmRRsv2lRAZafcJuNjWb5Eli+R5Ut40SbLY1le2Skv keVLZPMheq2h0xrZfIhWa2hVpFVRVh+iV1EmH6LPSvqspM9K+hRl8yHZfIhGK2m0kj5rZG8se5fI 3ENiXinG58O3ZOxBEfzQqzFrPxgek5uZ6ASRlbzqE9mAyAZElhXVS/pATmQviewlq6vcnb1kdS9Z XcnqXrKqkhWVrGjAigasaMBqSlZTspoBqxmwmpesomQVA9HJrjRWvS8Zd7VDmLBL/K19clTdvZRd rdvVKtNqzNUqOdPtamOuVplKY7QYc9UxWoy58pgr97lynyv30WLM1cdcfczV+1y9z9W7XX3M1fvc I+wOj4h8m6i3uXLZFbN62fd13J067k497VEdd0tU66jxyfun8uRvLJ2VnBmdFp2hynOqPOeIAUfs +93dtSMHRDIukrQqr+iWFklaFGkVkFMBOdGkRZIWybhIxkUxrgJyKiCnAnIqIKcCcv/qzvdYx7zV e7+7Az7N89NDWjbnKne7sjknm3OyOSebc1Vvf2llv656O9Wr0ep3KocxoZPUVn4bya7qfLuq8+3V M2IohP1+VtDr9+ud+/XOfXrnPr2z0hv364v79cF9zra7mjc7qmdKVhUsR29zjnV+8hx3R5xrvSMO vK6LPQRNRugxQo8R11g/+W8sW7k8Qp8RuoxweYQ2I9wdsYb11rDOGtZZwzpOj/wrTd7i9Yn4nSan Ov50r9/m8VHHf7f6nUkhmiL6cnSs9Y1Mzrld1rSrUrnWNGT1v7KuIesaso4h6xiyhiHXHnHtEdeu XHeX6+5y3V2ut8v1drnWkOtUrrErOt3ZnxD9epG3v2EGVO7117tSsdrzU9V/qfPAZKbtqu5sv6I/ TvZGEbe76hOu+oSrPvFv9sVKHzzVcZUe+DaPlX72qGN/v59Nt5p/sILd1W8baqu/FzvHlbe58rbJ 3xPaFJ1j3RlHPs+1tLuWrPVvptJGKq2nUmXtT8voilLP8LqyKyhS6xlqPSOezc76PWdbz8W0nWVl Ej9DwWc4WcnyZ2R5TpbnOJoW32bZnhNjRowZMWa4mrZDzNohZu0GKxN6PaXXU3q9rM9xOc3lNNXX U3292DdT/hmxbxZ3hstpDqyP3kL1Lqp3iblTBCVx/7NVV5TvsuKiFRetrkjtLmp3WWXRCotU7qJy F5W7qNxF5S4qd1G4y5WKFO6ibhd1u6jbRd0u9XUw3E+b7fQYlmEmgno628w+L/w6Storba1+u3Ze 2B2d6tXB6reWp+lxp+M9YdQcHzXHRx0xboaP2FGVJr9lHDGHR8zhUXN4dPJbxpHqt4zt+t6/fNM4 avaOmr2jb/imcdTcHbUrGjN3R+yMxszBUXNw1OwbjabbaRyykkfsLMrVb3DPDXlXrfxGwpMcfLL6 re00e5FycoY1n1X9fnBv9fuK83z6M9Ff6H8nRTXOsbd6jrPDq5XvXUXLP8cPOXYPFWaI6LxwqKrH Bs+K0dGelX/vm8Zi8jI738+HPSIuirj4hm8Gi//ON4PFN97BR6e4UuXb4P103UfXfb/3jXDeVfbT dL8r7HeF/W/45na/q+yn6X6a7qPp/t/79nY/Tfe//u1tv2MGvR7SCd/wjWw0RdRxdHqyser4D+zh xuzhxuzhxqzpWWt6llKH7ONK9nElR49Wv+v7kJ9fVP0tv3WUX6cPn6IPV/49dc5erGQvVrKuZ+25 SvZcJXuukj1XyR6rZI9Vsp5n7a9K9lZj1vSsfU7JPqdkn1OyxylFdVbzY1eOq98wVhy8yJU/Ezpc rSM6zU/30G23Ne6yxl2OrHyj/gr9huk3TL9h+g3S71Dleyoa7qbhIRoeouEwDYdpuJuGh2i421p3 0XA3DYdpOEzDYRrupuFuGg7TcNiad9HwkPXuouEwDYdpOBwdQ7UBqg1QbYBS/ZTqt+5d1p2h1ABF +inST41+avRTo58a/dTop0Y/JfopMUCFfir0U6GfCv3RCeLMizEvxnxVjbOd+T0m8jl4L96vXn6k Tz2NZzxfh/aQt98dFUtaLGmxpO1vR8WRFkdaHHkx5MWQFkNaDOnq73BW/rXx8dGy6HKd4ApciRvC k9HN4d7oq/ga5uMW7A0/iPbhVxh1zOGwOJrAq/gNfhsWTzkjdE85E+/AO/FHOAvvwtl4N96Dc/Be nIvzcD7eh/fjj3EBLsQH8Cf4ID6EP8VF+DN8GH+Ov8Bf4mJ8BJfgo/gYPo5L8Ql8ErOjk6b8c+ic 0hFemPJTPI8X8CJ+hs3oxEvYEl6o+W64t2YFvoetXqexDWKteQ0hLJ76prBy6pHhB1NnhO6pR+MY HIvjcDwGw71TC47ZjwPh3tozcT6uCStrr8V1uB7zwpO1LaB77eLQXdsVXqgdD911bwsv1L0dZ+BM nIP34gO4LPyg7nP4fFhc9xDaMOj1HgyBZ3XD4cm6V1Dys9jr8bB4WiJ0T0vCfJ82FbWwf51m/zrN /J5mfk+rRwMacQSaYKZPM9OnmenTjsIfhxemXYAveH6lx9s8PuHxSRwM3dOda/pR4YXob6MjZdxR mIGjcQyOxdtxBs7EO/BOfAwfx6X4BD6JT+HT+Cv8NT6LWbg8rJW5a2XuWpl7ZzTXPcI8tOBG3ISb w1Oy+SnZ/JRsfko2P1VzZ0jX3IW7oSpqFmEx7sV9uB8P4EGomJql+K7PrcD3wlNcXzt1Z0hPVV1T +zGAQe9nPeZQ8PP9OOC934Z0bS3sq2unI4XjcDz+EG8DHWrpIDueqj3X4/keL/R4Mf4Wn8cX0Ixr wlqZs1bmrJU5a2XOnTLnzlrx1opXBj017fqKNtF99lT34wE8iCVYCvutqLLfehKrsBovYQt+jq1I Yxu68DK2oxs70IMM9oZ1esI6PWGdntAdueeJYvA+kruRex99YqM+sVGf2KhPbNQnNtbkQ3fNMF7B CApwz1RThH1ojX1ojf1ljXPWOGeNc9ZUPvcaQtio3tbV6QV1ar9Ordep9Tp1XqfO6/4Gn8Fljvkc Ph821l3t9VzMw424CV/Dt3A71FsdjepoVEejOhqpp4113/fY5vGHHttBhzo61NGhjg5qbZ1aW6fW 1qm1dWqtW61114mpTkxqbqOaW1dHD3W3ccq7ohq7kamoRR2mYTpSqEcDGlH5m9MXRGdFF+LysFyO L5fjy+X4cjm+Qo6vkOMr5PgKOb6i8l97lucL5flCeb5Qni+U5wv/E39L6pxoPfaGpRxdytGlHF3D 0Q0c3cDRDRzdwNEN0a+jN3N1EVcXcXURVxdxddF/1e/FJ94dHZ94T3RW4lyPH8JHwvLEJWFp4mP4 dHRcYnZYnZgTvpG4GteEb9izXZf8XPi2fdt1yS94nOtOZp453RU1JV+OZiS70WPK9kYnJfeGjcl9 Xv8qOiOZrf5Vh9OSr3gciZpq5kYn1cxDC27ETWjFzfgqvob5uAW3Vv+O1kL9YqF+sfA/+3e0ZPsi 2b5Iti/Sa5ZXfyf/yLBUj1k4dSQ6Un9Zrr8s118WTn01Oqk2CblVeySOwmk4MyysfYfH9+C90Vl6 ysLa93l+TViufyzXP5brH8v1j+X6x3L9Y4X+saJWLtXeDLn0+u/6d4eh/+v39iu/i/+JsEGlLVVp S1Xaotf/Dtfv/gZX5W9vPeT9f/n7W+eopkXVv8E16Pg9GIKcUzlrVM4albNB5Wyo2x+9ua6IkuNj P5d/KmhR5e90/X/7Hf03/q2vN/yufeX36FMzw9KUuFLzwzdSt0LdpNRNSt2k1E1K3aTUTeoeLMJi 3Avxpu7HA3gQS7AUD2EZHsZ3sByP4FE8BvqkVuB7+D4eR1t0fP1Xo+Pqv4b5uAW34jZ8Hd/AAizE N/Et3I5v4w7cibtwN+7BIizGvbgfD+BBLMFSPIRleDg6ruGd0fFHTI+OOyKF+ug4u8VtqmBv9a+Y bKv+5ZOTEjfqZk26WZNu1qSbNVX/iwnTUfnv7NWjAY04Akfa3R6FGTgax+BYvB120HYA/XYA/XYA /TrfaTrfaXYCOTuBnJ1Azk4gZyeQsxPI2Qnk7ARydgI5O4Fc5b8dr0vO1SXn6pJzo6vcac3GHFyN a3AtrsP1lX+rji/jK7ghtP6bHfXmcLFuerFuerFuerFuerFumtJNU7ppSjdN6aYp3TSlm6Z005Ru mtJNU+Zu1tzNmrtZczdr7mbN3ay5mzV3s+Zu1tzNmrtZnfc0nfc087ds/pbN37L5WzZ/y+Zv2fwt m79l87ds/pbN37L5WzZ/y7r1fbr1fbr1fVEuFKI8hvEKRlDAfhRRwgGUMRp+rLM/p7M/p7M/p7M/ p7M/p6sv0NUX6OoLdPUFuvoCe/qMPX3Gnj5jT5+xp8/Y02fs6TP29Bl7+ow9fcaePmNPn7Gnz9jT Z+zpM/b0GXv6jD19xp4+Y0+fsafP2NNn7Okz9vQZe/qMPX3Gnj5jT5+xp8/Y02fs6TP29Bl7+ow9 fcaePmNPn7Gnz9jTZ+zpM/b0mSmfio6f8mn8Ff4af4PvhLRJlDaJ0iZR2iRKm0RpkyhtEqVNorRJ lDaJ0iZR2iRKm0RpkyhtEqVNorRJlDaJ0iZR2iRKm0RpkyhtEqVNorRJlHYvsd69xEb3EhvdS2x0 L7HRvcRG9xLr3Uusdy+x3r3EevcS66f8PEpN2Yo0tkUpU6zJFDvCFGtKuN8xyZoS7mlMs+dMs8tN s8ur0+xzoZC4HLPDQ2+caolrq3/d5WKTbY7JdrHJVvkrST9M3hCeSLabYhuixmRHuD25LfzIlGsy 5VKmXM6USyV3hiGTbs3k3y46qfp3Ll/x/kg01ZRrMuWaTLkmU67JlGsy5ZpMuSZTrsmUazLlmky5 JlOuyU46Zyeds5PO2Unn7KRzdtI5O+mcnXTOTjpnJ52zk87ZSefspHM1D4VyzTI8jO9gOR7Bo3gM 3w0Xm5wXm5wXu+9a775rvfuu9aZoyhRNmaIpUzRliqZM0ZQpmjJFU6ZoyhRNmaIpUzRln1m2zyzb Z5btM8v2mWX7zLJ9Ztk+s2yfWbbPLNtnlu0zy/aZ5ZqDoVAzjkP4NQ5jAq/iN1ATJvMCk3mByTzX ZE6bzPe5/8u4/8u4/8u4/8u4/8u4/8u4S+h3l9DvLiHnLuF/U3cm8FVUZ/8/M2funLmTubkBwhLA AIK49KWt1Pf1U61dfF36d6lSl1JQxIK1Ki7VgIqA4lLABQEVUFFB0L41Vn1bN4IIilpRewUiEJfr kgABDMuwhCWQ837PyQXDEpWlvu9/7uc3y5mzPHPmOb/z/GZubrLM4KcmlugYpZBFKWSZyUuYyUsS 2JTAJmb0U5nR06iGbKKeY61jXwAHuECKNDN9GkWRRVFkURRZFEWWmT/NzJ9GWWRRFlm/PXkPAZ1J O4zjrgCuRWVkiQxOJTJI+z/k/NFsfyQ6ozqyRAinEiGkUR5ZlEcW5ZFFeWRRHlmUR5bIoYTIoYTI oYTIocSHR3141IdH/etACRiobySauHFnNAGHomcriCQyRBIZ/1ER+s+KIv858Dz7L7F9k+08XUaU kfG5l+jeCt/8IuchOkPEkSHiyBBxZNDCZWjhMrTwLLTwLCKQDHp4Fnq4TB0vQjRxGbogRhfE6IIY XRCjC5YRpUxHF8TogphoZSzRylh1ga5RF4I++jb0QawGsM+YUleBq8E14I/UeS3gutAOy9AOMdoh RjvERDghEU6IhojRELG6k/x32V82jIl6QvREjJ6I0RMxeiImCrqNKCgkCuqMroiJhG4jEgrRFjHa IkZbxGiLGG0Roy1iIqSxREhjiZDGEiGNVUuoeylYBuB6BdcTNf2NqOlvRE3TiZqmEy3dRrQ0lmhp OtHSbURLIVq/Aq1fgdavQOtXoPUr0PoVaP0KtH4FWr8CrV+B1q9A61eg9SvQ+hVo/Qq0fgVavwKt X0HUlSHqyhB1ZYi6MkRdGaKuDFFXhqgrQ9SVIerKEHVliLoyRF0Zoq4MUVeGqCtD1JUh6soE3bHp R+DHuiw4DlxE3f047g8uAb8n7VK2fwCXgcvB1bqaCC1DhJYhQssEt1DmXtL/TN7/0rOCv7D/FNio K5JCFBHBZZJcW7KFLku2FGF4ji4P0YXh+aCn7k9k1z+8gP0bdE14I7gJ7Ij0hrN/Bxgh0kR8aSK+ NBFfmogvTcSXJuJLE/GlifjSRHxpIr40EV+aiC9NxJcm4ksT8aWJ+NJEfGkivjQRX5qIL03Elybi SxPxpYn40kR8aSK+NBFfmogvTcSX/l+M+NK7RHwtxWh9itNH9HL6govFDc7vxMVOP3G201/0d38p TnQvEz+R5+nzZU/dQ5bpMvmq7i8rdTmxYaFcYn/jdYpcrjNyBVpqJXrrS10rOojR9ctFqV4i3tBL qP2E3C/Snk3tv6D2X+R+SbbW/FY0rRTRSkgrJ9DKqbQyRr6i35Ezwas6lLPZvqar5OvUPkc/RutT aLlOLrWtn0Xrk2g9pPUXaL1cBDJDjnnYhJKXC7C9XM+VH5C2iBlxMTkibHsX294lZ1/mzgy5p5B7 JLlbkruU3Oczj86ixDBK3CY6md+XxNrJzOb/xux9mXsmM/ll+m73KvPdTtHJnaMHuv/QU9xPxfHu RvRoIfHzD/SL8hVm31fFD7mCt2mpDD0aygVWi2aYpdPUXscVfc5MPTI3U4c5TRpyZbFcwVXZXxrU a5zfCE8/KRLABwoEIAlC89fZIAIpkA/SKPsCcJzOiOPBbXqUuB3cAf4ERoCRYBS4E9wF7gaj9Wwx XT8vyvTzjkv8I4EHEsAHCgQgCUKQB1KgADBPOs1BCwCXOHCJA5c4cIkDlzhwiQN3OHCHA3c4cIcD dzhwhwN3OHCH0xUcDs7W5U4P8GvA2HYY285QMAzcDG4Bw8Gt4DZwO7gD/AmMACPBGD3XGQvGgfvA /eABMB5M0HPdH+pR7jHgZ6AHd2+Uzrh3cmde1b/mrtTgZ7X42HPciZqG33zkuLb+dblJF8rN9Vm5 pb5cbq1/StbVV8ht9dPldp0n60nX9TVeov51z9eFnqrPekF9uZesf8oL6yu8vPrpXqTzvBTp+eQr 0U96A8EgcD24AdwIBoObwBAwFAwDNwNiW4/Y1iO29YhtPWJbj9jWI7b1iG09YluP2NYjtvWIbT1i W4/Y1iO29YhtPWJbj9jWI7b1XgAv63JvOigDM8ArYCZ4FcwCs8Fr4HUwB7wBFuhRXjn4ACwEi8Bi UAE+BB+Bj8EnIKtHJer0k74E+K+f0KV+c7YtQGdwFDga/Ii44Fi2d+tyfzyYyDHX6T/BPtfjcz0+ 1+NzPf6zpD0H/gb+Dl4C00kvAzPAKwDbfWz332H/XfAe+/8EGfA+WAQW67n+R5yrBl+CGKwD68EG sBFs0uUqH6RBAWgG2ui5qgi0Be1Ae3AMccqx4I96lLoW3AKGg7HgMTBFP69K2W7So4LDdXnwPea4 77P9IdtfgbPY/62eG/TjfH9wCcAfg4mkPwgeAg+DUlCn5yaFLk82Y8v4SjKukszRSebnsB+4HAwA V4FrQAlgvIeM95DxHjLeQ8Z7yHgP7wGjwb1gDMDecBy4D9wPHgDjwQQwETwIHgIPg0ngEfAo4BrD yWAKeBxMBdP0qLzTdCbvdHAGOBNwrXlngbNBD3CTnpI3BAwFw8DN4BYwHNwKbgO3gzvAn8AIMBKM AneCu8Dd4B4wGtwLxoBx4D5wP3gAjAcTwETwoJ4SfU+Pyk/qKfkhyNNThAf7PwfzV8uFzGWLmcce EIPhz5vAEDAUDANb4NKtoA5sA9vhqiN0jH6O0c8x+jlGP8fo5xj9HKOfY/RzjH6O0c8x+jlGP8fo 5xj9HKOfY/RzjH6O0c8x+jlGP8fo5xj9HKOfY/RzjH6O0c8x+jlGP8fo5xj9HKOfY/RzjH6O0c8x +jlGP8fo5xj9HKOfY/N7YM5bOotmrUGz1qBZa9CsNWjWGnToE+jQJ9CdWXRnFt2ZdafpSma0J5nJ lru1epW7Sa+yf9n0GrrzfWajeTrLDPYkGq4UDVeKhitFw9Wg4WrQcEY/ZdBPGfRTBs0Uo5liNFOM ZorRTDGaKUYjlaKDStEppWiSUjREKRoiRiOYXxCN0QE16IAadZTOqu/ZXwM1vwRqYvkMcXaG2DpD LJwhBs4Q/8bEvzHxb0z8GxP/xsS/MfFvTPwbE//GxL8x8W9M/BsT/8bEvzHxb0z8GxP/xsS/MfFq DfFqDfFqTIxqfqEzSxwaE4PWEHfGxJsx8WZNslBniTGfIMZ8gpgyS0yZjYbqymgYuFlXpgr1qlRL 0Ap0AB3BcNKn2m83LdFPMq8TY8oy8SM5Q/STs0QXOVu0pX/fk6+LlnKOOFxmxOn09elW1y8Qv0Db p+UHojv9XmOeYhPnVJJaJboRL5xun2Gbv2dYQdTS8Cy7Oy29pqeTf7pt8znODROS9o4grdzkFHnO 2SJ0eoBfg3PAueAy0R31FqLejHILUWlh0vzXVQ97ihkdP7G/icx8iA0NKcXMltWkHsFsWcpsWW7j QdQ4LVcRCa0Qv7DPFE3e7thg/h/CMixu+P1k+6vSJiYy703s78/11PNlCX3zGj50gkhTtqdewNEn 5J5JLDhbb+SokqMBlJutt3C0QBwuPGpPAB8oEIAkCEEeiEAK5NPieaKZ7KX/IfuAAfTiDL2Imj6j pnleiejuDQSDwPXgBnAjGAxuAkPAUDAM3Cy6o+W7o9m7o9m7o9G7o9G7o8m7o7+7o727o7exxdpa Rkw3g76aqb+QsxhFs/WHtDiD6HY1114ivodPNONsbHyBay8UzZ154hBnvjgs9720S2QvcjX8UvP3 zC81ywH2b7relYOIb8eLI+UEUKZXcKcPJZL5m/djcZR3nDiM3uot8imRTzs/4G6WcAdm6tW09K5t KUULX9JCRl5A+xcSgfZlezHbElqZpz8hRq4hPt5m/WeRSFAqFL75byzkLiJnETmLyBmTY6NoJapg UWIosbTh1/tsi4PYwhPc9QSMW0F9G2DdjZSITZ0mIk4017Vo+Fo0fC0auRaNXItGrkUj16J9a2nz PK61J7WUcOcylDK1mSemrXdp8wLq7wuuFI5t+316fh7p82lvAf1cjucsJDJfJPK+Vbt5uXYrqS3N VdRRYyU11lBjTI1+7ulbws4f+eSOZU9rRxY7svJae487Y7GS5pebG2yppWQettRR2iiUWHxfVIlj xRKwFGwRXcVWUAe2ge2iKzX3tWrpAsbZheI82ZftxWyvRMlcS82D9Bw5hDs5Hk+fwIgl6qGPuth7 s0D/zbb2gV7MmCtE5WzDR7rjI9096vbqgRZdE83FsaoX6A36iK5qApgGPuf4C1AJsFOtIW0D21ps S2JZLRZ1w5puXGth7u4wuzICzD1ejM8YT5uF/bPomWpyF9I71ZQopER3ciexcxU9sx5bY2zdbPrV lspY/+Qe4cudGbu1+HNnORAmrBStG+J1/LWau2P+TmuFnmP/k4+5Z1lyhaRsxI4dvxCX+3aMvA4f uZ7xvxx/WEH/+7nftK+mDNzGFSwDK3RWFIn+WHIJ+D24zv4Hg1rsyWBLhtyFNncVLVoVx7kVMKJ9 7sq8eIIoThTo6kQNWKWr/QHgSnAVuBoMBIOoNz/3fxHML3FmqTkrr+OKBnKlldy3Kr2SK93ScKV6 E1bX0cpcq71bY1+MfTH2xTtHSS9q6gOuw7aB3JdKSlZhu9HRDWrTXN3n5n8gYV+MfTH2xdgXY1+M fbFv3ql0Eyh3cQn4PRjM8U1gCBgKhlFzw39NOhKOys/9Dr1hnF/AURPo5Rfo5TfwyzL88if45Sny Kfy1EsuquDZrDfNUNfdsuc7ik8fik8d6J+gK7zHRzZsMpohuiQJxSuJztjVsV4G1opt/pHn3CQaI U/wrwVXgamDsC3L3yPhMIuczCXuvllmPiO3Th1LsfjKXqyiXqwi7Y3J2t7aZ++/LAfV/lpv1GrRe 1lN6DVou6x1R/zY2D6j/nNRaUmq9I/S/UeuA+sWyljtVR+lt1LRdV3oJvcULdZ1HPELOSnIebcs+ w9kKUiqobaMtm5Fb4QlTdjveoCmTFMqWjdBg+WyP0MWiOTnfppU6VGmMZTXSfCu8jla36a2UnE/J WlqtQ43GWFzjERVRyxYs2EpN86kJe+u/4E4NQMc21LKRWuqopd7YbNtuKL2R0nWUrre2N9iQEK0o OQAbKuUm+mwz2y30H1Fy7sor5HbGdL1eSk1bsKXS80URtVVSW62XZJZv6BGuXyS9lF5KzVuw6R4z a9ZXUqPpg2pZz5yj7PVXeyn2j9DC5njW3pGtNlfDXUnaXObOLKB3d7tfxBO5+0Tpb7g/Nq+9L+T9 hvshCg70PohoX/sfLz7I/Y6PN9Hf9sxe+1nke4Ui8FpSaxsRem1BO8q0p/wh7BOteh04dyj7XcBh nOvKucNNVOm1oo52nO3I9jDTB14hR2gGrzV52tqzsa2rmPQO7Hdiv4vNHZt6hG9zt7GtbrQ5DrWt bBTNsSvB2RqvFSmtQRtRjH1pctZQZzH2US/owHFHzncCh5LehTyHkdaV/cNpI59aqrHVXGHCK6L1 tkLmajGlq7HfXGHC68y5LpxrKJ0QBdgQUnqVvdI21NuWXO3ovfakN7QfUsMq2wOHcr4LaYdxvivp pm2ugvpbcraVXuu1NteKx1kbuJftafcQ0orJ04G0juTpZPqAPNYW8nQlz+EwnblPaduvbURh7j7V YUchduRjR9r27aEcN9ynOmwoxIZ8c1ds7yVypTbsYr257oYSG3Zand5fn2DUfsDebn7BaO8gUvvq G5TqzChtwj8464oWB8tHqK0lKfvpJ5SORLMD9RVqaWWu6OD4C3dimr2P++Uz9opS++o3tLmZaLa2 fj5c2A3G8WC1o+XW+ldhtXZyW/0c2OfHsr6+DlYr8BL18+HGbrCRB6sd7SXrX4XV2nl59XNgph97 qfo6WI0xWP8hPdKWHknRIymvTf3b9EhLr239MqzqQq949IrrFZOvA/k6kqcTOJR8ncnXhXyHka8r +Q7Ha5IotTQa6xRp/ovQHBvVFxLlFhNVdDfP7Yn2iux/Mipz+ojjnb7iFOdicZfzO7b9KGX+79D5 +k35G6KhnnqS/e94R35Nrjdtrh3/cWnSzqPndh65TgoF3E0IcZz4mTgKzf0L8UNxujhHHC3OF78h 9bfEbT8RfxB3i9PEaPGUuFqUiVc5ms1nrHhHLBLjRAWa4zFR7aTFX512TjuxyCl2uonFzhnOmaSe 5ZwrVji9nAvEGuci5yKxzrnY6S/WOwOcq8QmZ6AzUWx1HuJT7Ezi08F5lE9H5y/OU04nZ7bzvtPZ /aHb3fmRe4x7rPMf7nHucc5x7k/dnznHu//pnuSc4J7inuL8zP2le7rzc/dM90znJLeHe45zsnu+ 29P5pdvb7e2c7l7kXuSc4fZ3L3HOdC91L3XOci9zr3LOdq91Bznnuze4I5ze7ij3HucK9153vHON O9F90LnBneb+tzPY/bv7pjPS/Ye7yHnYrXCrnFJ3uful85K7xl3rzHDXuZucme4Wt86Z42opnLek K6XztlQy5bwj07K5M18WykJnoWwl2zqLZCd5qPOx7CIPc7LycHmk85n8N9nNqZQ/kD9wlsijZXdn qTxG/odTLY+Txzsr5Qnyp06N/Ln8ubNanihPdNbIk+RJzlp5pjzLieW5sqezQfaS/ZwtcoC8kqav lde7CTlEDnHz5DA5zI3keDnBTcln5DNuWj4vn3cL5EvyJbeZnC7nuM1lRi52D5GV8kv3cFkrtXu0 l/Dy3eO9Qu8I92TvBO8Et5dX4o1we3t3ei+4V3sve6+6D3v/9N53H/cWeEvdJ7zlnnanJ8JE6M5P RInIXZAoSDR3yxPliQ/dRYlPEp+72URVosqtTCxLLHOrEssTK9wliS8Ta91liXWJdW5NYmNik7sq sSWxxV2bqEvUuXFiu59w1/nKz3fr/AK/QEq/ud9Sen4bv1gGfif/RzLt/7v/7/JQ/1j/VNnZP8s/ Tx7jX+jfKo/3b/f/JC/2R/l3yf7+vf698lJ/rD9O/sF/wH9AXu5P8CfJK/zJ/mT5R3+qP1Ve6z/h PyGv80v9v8sS/0X/FTnUn+W/Lm/33/LfkiP9uf48Ocov9xfKsf5iv0Le73/kfyTH+5/6n8kJfrW/ Uj7ox/42+YgSypV/UUp1lE+rruoY+ZY6Tp0gF6qfq5/LD9V/qlPlR+o09Sv5meqhesgl6lx1rlyq zle/kctUL3WRXK76qf5ytbpMXSbXqivUDTJWg9UwqdUtarjnqT+puzxf3asmepF6SD3ktVKT1CSv tXpUPea1UVPVNK+tKlUzvPZqjprrdVPz1TrvGLUBkjs/6Bp09X4XHBEc5fULvh/8wPt9cExwjPeH 4MfBcd5lwU+CE7wrgl8Gp3lXBmcEZ3jXBL8KzvL+GJwTnOddF/w2+K03KOgXXOpdH1wd/NEbEgwO Bns3B0ODod4twS3Brd7wYEQwyrs9uCu42xsR3Bvc640KxgXjvDuD8cHD3l3Bn4P/8sYGpUGpd1/w TPCMd3+wLljvPRBsDDZ6E4LNwWZvYhIy8x5MeknPezipksqblGTxHkmmkwXeo8kWyZbe5GRRssib mmyXbO9NSxYni70nw3PCXt6fw75hX+/ZsH/Y33su/EN4mfff4RXhFd7fwyvDq7znw2vCa7wXw0Hh IO+lcHA42Hs5HBLe7E0PR4RPezPD2eHbXlW4MPzEqwk/DZd6G8IteW29bXmd88YkivPG5U1J3J33 Yt6riUl57+etSzwRqahNYm70vejkxMdRz+gPidroiugaX0XXRiV+KhoU3eAXRIOjwX6LaEh0h18Y jYxG+8XRmGiMf1g0Lrrf7xqNjyb7R0aPR4/7x0TToqf9f4+ejZ73fxq9FM3wT4pmRjP9/xfNimb5 p0WvRW/7p0fvRQv8c6IPog/8XtGiqMLvHX0Ufeb3ib6I1vr9o/XRZr8k2hpt8wdH9SnhD025Kde/ JeWlfH94KplK+benClKt/FGpNqk2/phU21R7f2yqONXFvz/VNdXVfzh1c+pmf1JqeOoO/5HUyNQ9 /uOpsan7/P9KPZAa75emHkw96P819XDqYf+Z1COpKf6zqampP/vP57v5+f70/Ob5rf238tvlH+K/ l78pf6v/vnCTtzKjiLyyglfE4aKDOCiL/lR/JrqhrISev9fzdXq0foZPrb6Bo4v0Jfpp/QJ7lfZs pa5m/UUub+0epc3Zah3z+epc4R651oDbv9HSkeC/Gx1XUHtL00KTS6i3Guv0evbNd2RPFV05zu6s YfnOvcq9tDdff6JX6Hf5VOq1ROsHurSmzsm25ipdo+fuaF3X7NFyje21Gp2l9y8W7eixI43lubN1 39SQ3qhX63V6uV66M6kFqavtuee5e2n9IntL9lqWXHoVrdfqFcL0WrHoLH7eYD1nFulFeMtnZq+J th/Vk8xV6oHgV/pEPVyPYO+znee/bHyVu5Wto68/pe3X9JtcfcydSuTOfLhbzre+sQ82iJyn6TF2 Hes11J7zwkY9syP/Rnpsnd6sF5LvNHu1x9PzOSv1Sr2S9Ypc3s17lF5Dny0zPpIbF7Wird2WN321 Tdid3eXoikb7r3y7Gli+/1WL3LFykdALv6FVMwJX5g6OEsd8bd4n9UPGT4wP7fuil5orxLs+2ePM F99Ydi24ze49vfsdNOz0DaWrQJllpI++GvnfdsGrN9p1+V5Opr9VDevA5/vabq7s7Nz2hf0o+4hd v2Wu/yAvx31j28sb7qveApeu3sfav75XjwXn2Ta+aFg3fHJn9zY7HsmnA58jd7HwSbt+v+HzNaWP 3mvpZXa9Sm+AuzY0ZSrnDKut1B+bcWjKNHB4w5wH272h39H/aLJ0o1lVjxKdYOQzxVns/8WmlDNP vaIrmizdaN7S45gHisTJKE9GkE35mLHwxlfs3FTbZgbFj0zpY1CtuXQ9Xb/EHNskL33F9bklTf/1 Iv1Ge3amflnP1q/m8q7ao3SjmZ2eStt5yMwqZ9iUN2i9TJc12XYTcUG9iQje1b/VPfQV+rxc3j2Y TI+iX9/W/9Sf7cIzrugjbkOhC/T6veavTsTTIhLPiJfEEWIG2r271e7/Ieag3Y8VH6LdT0elO6Kn 09fpK65DPf9alBjdLAYZxSyudy93rxQ3on0rxFD3Y/dTMcytdKvErejg5eJ2d6X7pbjDqGExwq11 N4lRbp1bJ+4yaljcbdSwGI0azhNjpPlNogfkBfJCMV72lReLid6L3oviIXSkFg8nmieai7n+C/4L 4h1/pv+qeNf/2P9E/NPXvhbvG/0k5hn9JBaqs1UP8ZHRT+ITo59E1ugn8ZnRT2Kp0U+i2ugnsdzo J1Fr9JOoM/pJbEc/jXWkuk9NdHyjopzIqCgnZVSUk29UlFNgVJTT3Kgop7NRUc5RRkU5ZwQySDg9 gyAInd5BFOQ7fYJmQQvn4qBl0NrpH7QN2juXBsVBR+fyoHNwmHNl8NPgZ841KKdLnGtRSCOdgSik u5zrjQZybjBaxLnRaBFncN5NeWOcYUZhOPdHBVEb5+Xo6ehp57WoKlrrvG5ifGeeifGdRSbGdz40 Mb7ziYnxnayJ8Z3PTYzvLDUxvlNjYnxnlYnxnbUmxnc2mfjd2Wzid2eLid+d+vxkfp4r81vmt3b9 /M35W90kfrPQ+o1j/cbFb8YTyU8QDxHfPCymkfIEHyWeFE+JQJTiVb71Kh+vekUkxUx8K7S+FeJb c0l/R3wg8qh1IWUX8UnhbZ+IfJEVlYyxKjyvo6gWMaNmHZ9OYr3YJA4Vm/l0FlvEdtFF1OOXzaxf trd+Ka1fRtYvI/xygChwr8Q7I+udzfHOrGjlfoqPtsBHK0VrtwpPbWc9ta311NbWU1taTy2yntrC 1a4WLaTAXwvxV5c1i2iJ1yr2ue2ijUziwYXWg9viwReIw+SF+HFX/Lgv+xfjzV2tN7fHm7PC8T71 lgrXW+ZVC99b7q0Wed4ab4M4xNvo1Yq0t8nbJoq97fh9F+v3Ha3ft7d+3976fXvr9+3x+/8Uheok dZLIUyerk4WnTmEkJBgJp5FyujqdlDPUGUKpM9WZIlC/YoQcygg5m7I9GCdJO07yGCfni5T6DaMl n9HSW3RUF6gLRVr1UX1EF3UR46eZHT/N7PhxGD9XUGqAuoY8f1TXknKduk64qkQNpJVBahA1X88Y y2OM3USpIWoI6UPVUPIPY9Sl7KhzGHUjyDNSjaLdOxmBaUbgvaSMUWMoNVaNJc99ajwpE9QELJmo JpLCyBShGZnCjMxHKfWYeoz0qWoq9UxT08hZqkpJeVo9Q9ln1bP0w3PqeXrmBTUdO8tUGX0yQ83A qjnqTax9S82lzvkKn1QLFd6oFquPqO1j9ZnooD5XVfTJErWctlaolaKT+lLV0JOr1GrRWa1Ra2hx rVqHzRvUBnJuVBs5W6tqSd+kNmHJZrWF+reqrdRcp+qoeZvaJlqo7Wo7rderespqpUWe4RHR3vAI a3iENTzCGh5hDY+whkdYwyOs4RHW8Ihw4JERrEcGI4Vr2ER4hk2EY9hERLDJENZDw5tFgeEUIeGU RSLKW5xXIVJ5H+atEwWGX4Q0/CLawC9VokW0JFoiCqOl0VKRipZFy0SrqDqq5uzyaLloHa2IVoh2 0cpoFfuro9XkXxOtIc/aaC151kfr2d8QbRRFUW1US55N0WbybI22crYu2ibyovpIi9Yphr9oYZiL tZfyWCdSvmgOf4WiZSovlUeeKJUS7eCyFqQUplqJIsNoohWM1pZ1u1R78hSnOojCVMdUR2rolDqU /c6pzuTvkurCPnxHOnxHyiOpR6n/sdRkSk1JTaHmqalp1PlE6s+ipWFAYRlQFBgGFAWw1F9zDDiG j9zJgBPZfxjuk5b7EjDf0+w/I15mPV2UWQaczf7r8J4Ub8J9Eu5bCFcuEovZr+CjLPdJy32Flvta Wu5LWu5rZbmvteW+Npb7iiz35TlpJy0ip5fTi/UAB6ZzrnauZV3ilLC+07kT7uvh9hCuZcYAZuzP 2jBjaJkxsMyYsmzYwq1xzf+NMAzYzDJgc3e7u13kW+5LS096ohmsF7AfylAUyF6yl2gne8ve4hDL eu0t6xXLPrIP6RfJi0g3DNjeMmCx/J3sJ9ruZMBqIeG+DULBettE0vJdkeW7luapKOPzRHWikJbX FIx2OmvDZdJyWcJyWWt1ljqLFMNlUp2jzmF9rjqPnIbFWloWS1oWK4LF+jK2f6d+x7qf6kfOS9Ql rC9Vl7I2jKYsoyVzjFaiSkgZCKMlLJcpdaO60TLaYPIbRlMw2s3sN3DZreo29g2jKcto0jJaUt2t 7qbUPWo0KYbdlGW3vBy7jVPjhLQcpyzHFVl2k+oReE3meG2ymsz+FDVF+Opx9Tg5DdNJy3RFjZhO WqZTMF0Z+4bdlHpFvcb+HDWPtWE3Bbt9xL7htULLay0tryUtr7WyvNba8loby2tFltfy1Hq1nlKG 3Vpadmtt2a0ox27bYDFpWSwvcAJHyAY+Cm8IbxRBeFN4E+uh4VARhjfDPmE4PBxOyh3hHSKwTOTm jct7ULiWU1pEq2CTdBRH8KllkLTljhZwxyb2N0dbRD6sUc9INqxRkJIpKfLhCyVSli+aWb5oAVM0 Z98wRfNU61Rr8hiOaJE6JHUI6R3giOZwRCdqMBzRzHJE2nJEgeWIZnDEI9T5WOoxSk1NTSX/NNih mWUHV7jdepqnmUdv/cntKJJzm4rj/y8vep2uNLD78a5PbnbmqdVLv/YZZVN1myeyn4K59ujTHWlG vding3XmCVnD8yKsiHd9gtm0HsydX5Db/n7fLTtYi+6tJ9ntum+Vu1JnjNr7ts/RmqynZtd985x1 57Oydai+Sp01vakX78z11d3LPbm2fW5+DaBYpE1um7bHs+9/6RLmLGncalr81KZ9vvvd16v3fN6F 9/xTz9Wb9sc3v3nR83Lbqpwnr210bv0O660Ve7mf+pO9j6WDYtk+16wn6wl2W6vn4Rnvg2f0/XpB 7r7vtN8+WZyHD729X+O9RjR6C9Hw3qTR2bv1WnikJtejy40ljQrv8IaN36KdzWKvbzsOdOFOfmX9 BvpqNTBPjTbtkmvlniX/ry07n3mt+Ha+cqCM9LV17+1pc9O539Iv6Df0c4an2G94slmee0a5Ymeu ZV9x2z7U/bF5fpnjvpX2DVAMg5i3Is801M/xHLb/MGB/l+eZulQYfuq+46pg3XJY6meik17c8CZA V+mM3Y7e8YTvwJbGb7ca3h7pv+48fkRfrkfpvnoW+xfsTD1RD9DT7UyzW6/vjaW4gjI9Cx9v8tnp ftq9zjJNznpjie3xxrNW3PjJuP7oa2t7++Baty8LbJR7/6ZLdjvzhr5j5/7OGQyPMHyxhJn1a6+p idYMY5p7YfvG+ufKXD+x1gNtO8q+D959pi6039JqXJeJAD5lzgpNTbnYYEvuXPxNff4tbP2KKRu9 BdvBjQ3xCBxfbdvaxfPseKveY36v2d/3Svu7NESljY6bjH4av8FslDrj4NrTqObz9iGzfc+jR+be KdYyopeZN4T6OV3a8KZwl/k9znnZi/pv+2HXK8QFL+X234aj7ftcMz6NDxBjVObeqdRaZq3IRRcN LJrara5ZlntesDw/q+EdiH5nlxzb993CXMkFotHb9hxzLrAcNMvuw4WWN19r8IKGN5INoyN35mR9 kj2aqX9PT14ObtX3sP27TX1jl9b+Tq+X6F/vh51X60mGu7n+L9jrzd5wFMIk/RRz4BjdQ48zioFU oxme1VMbxoy+1BYu3PE+NVdXOaOdyF8cYfcbVFYu+jJv9ez3R4x/7Md3QKzX7Hyz3TAX5/azIqd9 vtJxYtfYrOPu33v41y+NY0jzTk6vMrP+15bYLb7/bpZd3mvaN+t61ddHYraXv1uVJhr3J/6z2cZR G79eH1iO2Q87m37/vA91fKf9ox/Vt+vRepDdr0SNPqkfzJ2p0R/Y7SqYeNVXkdt+tXKifvQA7fwY 7ZXJPYlZohfp9xp9h8zG1Sie9/X6nd8f2L9WvuGZzdeWrTKxN9t68B7xeW42sN83MN/tsRF/U9/Z +u4WWLuvNr9p3MYeXc/xdSgVq5xND+g6/ZIeq49jDsnA4ZP3787piXbT+YAsbbivc3JHORXb8CRA NFJTB77sw/e6mqphre1Bw8MriFf3uMuc/8iovoOtVfZ1IbJagRUNenQlfrq20Tk7y+DH7zHC3tlr 8e9swc7Sxt9dgZfm/O9Zs7dFX6IvMAxp9Azr0Rw/p/9p93OKDz94SZ+t7xZGf32+fz72Xd8HvGPL d9vivi07WF9/uef3R/ehln/pM7BcRFnDnLXmwJ7z7e+zA/N+4lvmfNZ+23j3b4nt69LpAMt/64U5 /gCe9emxB8+SJlrI8btefSB3/mDObU22kdVbv+tnFvu+6JetZjjQ/jj8oBjzL1sO9C8bmGn2422N fZa88+mX/Y7wjrEVNj3KbIzcWfQSaj9arNkf1jZ3/yu9lnsW+O2+PR7Z7yj//7AU7U8h8wx/P0ot aDyzmL/jYJ6q/de8hfxXLMSvG/6Ht++Ba+o8235yQk4OcIKIFAHRIUVFRERklIIi/hl1lllnnXPO SoAQHIYk5B9OEnISUomWWkctZdbXWuucpc4yZ621zllnLbO+1llnna+1zvlZ65yvc84668x3PXci peve9m2/3zf53de5uc/zPOc5Jyf3c90J5/KLV6zQ7a8w8jtf5S/0ifl/+Knf7l7L6M/pxe/gFPYg 7tF/8z9ejfb5H1Id8IfPz0D0efi/+XOb/rP8fxrnDxF74zO7RkeeJUjs99zBlxn5bVy3t+8ehXtk d5+FuHu8EjrSp+bT77e2T0aL2Obwtt8//szDeL4N7Q7/vcaXnOdm9Nsc8cmjz753R87h7gzG/9M8 N3/5I/X1Pfuvn2T8gl6/73/mfITPfvvyP/77Sp804FW68MWtPtPrw8j7nb7zp++D7v49RcznPIHC zyOFTfkq7/fQhS/6BPhf9joVsfC3GvzT7Sss8u3G5/QKf1qa8un3X+hk6CI97TmapWFL341i9SHW QXfT9778/D537q8T9tX8oWUhfei50NP07fAn75nvhzbS9uPP/t3Fv3hC8C+hP///+TSf/iIk/F3V SXCcd1CdngS/7nsyhr6x4Z/kl4Xm0e+HQja0qg/14oxeCVkjn2t+6jstWkdqQ7O+wmxMGPWhiE8e PTf8dOjl0L7QU6HK0AG6I1Lom+1jdyuqUAOPsRH826GQPWSh2A1c8/dDG3AuL4d6Qi9EvsH51GdY tDY8EXryK8xzU+hg36d5B0PPAbsjfOSPoe2hJxG7Gmka3a/yD2fAzC9/vH/3v3/HNzJ0V4X/XuEz 9/u/4ejvfaXv4z5k/T6Bidx9XzzOQFgCKyc/E7z+XpbBzx/vLP4//BSxLOSjc7AP8O77AO+cCuSJ AaEJ1D6272ieUHnEDX/zfKDveU5t+K9fIu12/Q9zD2e8p5HvacUJeUPfDjXCHmUZoRJqEsnv9AT2 pNDUUF3oEXi/5Ib5bQh1h35Df3sTPlo6G8nisKVny3HHv/iF1+Gzc+oJW+S33Tinft9jRP66Jh9M 82uM/198d58j39uvTdKdayE5NC10HnnpVyELxugKrcJ57Q493v+qsLvPc/vD+eFLzvOHuF/Czwhr 4FlCPwg9TvfQSfqLT1045/erhOjJ8/BfBvyvecCnj3jps880/i96/SXy3qUKl767+SsTadeAz1nf eY8UNhGvv8De+ALdoQUR3SE/+6ZKUN3DDKQptJQ0hYKkKbRStUD1CFut+oHqB2wNqQk9pXKqVrIu VbvqabaNawqx3VxTiL3GNYXYHq4pxH6pel31NvuVkCeMZ0eEAqGQHeWaQuwdYbIwmR3nmkLsd8I3 hQfZu4JNsLNTwlLhh+y0sFp4kp0RNgmb2Dnhp8I29kdhp/AK+5PwqvAq+7OwR9jLrggHhDfYX4Tf CL9hfxX+UzjCrgtHhd+yG8I7wjvspnBCOMH+rpbVOnZLHa9OYLe5LhALkS4QI10gjTpTnanSki6Q RFpAsepCdaFKR1pAcaQFFE9aQAmkAjRIvUD9fVWiepG6UpXEn71QJXOtHlUq1+pR5Ua9ErVXtYBr 9aiquT6Pqpbr86iMmnjNQFWdJlGTovoBV+lRWbhKj8rFVXpUzVylR+XmKj0qD1fpUXm5So/qUc3f NB+rlnNlHtXjXJlH1cmVeVTruTKP6lmuzKN6nivzqLq5Mo/ql1yZR7WXK/Oo3ubKPKoTXJlHdZsr 86hCXJlHELgyj6DmyjyChivzCKK4QXxekLkmjxDPNXmEgVyTR0jlmjzCcK7JI4zgmjzCSPEd8aSQ y9V4hAKuxiN8XfxA/JNwH1fjESZyNR5hBlfjER7kajxCLVfjERz8aQxhqSRIgvBDSZS0wjIpVooV 3NIAKV7wSIlSouCVkqUUQZGGSkMFvzRcyhBauX6O8CjXzxGWc/0cYYU0XhovPMZVdIR2rqIjPM5V dIQnpCnSFOFHXEtH6OBaOsJTXEtH6ORaOkIX19IRnpGMUp2wjmvpCOslh+QQnuOKOsJGrqgjPM8V dYRN0gpphfBTqV1qF7ZIT0irhRe4oo7wIlfUEbZyRR1hO1fUEXZwLR3hZa6lI7zCtXSEXVxLR3iV a+kIr3EtHWEP19IRfsm1dIS9XEtH2BedEp0m/Jqr6AhvchUdoZer6AhHuSqO8FuuiiN8xFVx1Iyr 4qglroqjjo+dG1ujzudPcqinclUc9UxZKw9QP8z1cNQL5e/Li9VNXA9H/SjXw1E/xvVw1Ku4Ho76 R1wPR93B9XDU67gejvp5roej3sT1cNQ/5Xo46u3yJvlF9S+4Ho76Na6Ho36d6+GoD3I9HPWbXA9H 3cv1cNRHuR6O+l2uh6M+yfVw1P8l/0E+p/4DV7NR/5Gr2ajPczUb9YdczUb931zNRn2Nq9mor8cJ cZL6b3FyXJz6dlxCXKI6xBVsooS4j+I+itIMYANUUSITVK8jQ8UhEw1g8UyFtXUgU2N1HYxoMhuC zJvGRiA+Ej9aNoqNYRLLQUaLRo8SrH0T2SSsqaXIbjJlN5mymw7ZbR56fRc/A5DjHsHYi1gNehgi +c6G49jxM4k52FI2iP0QP4lsGWth9zAvsmESsqHMBqt0qjiWTE+HpajikR9TkR9HIZKlymJjVaNV 2YiPUY2Bn4O8OZjyZi7y5kPA2cieZaTINlj1CHLoOMqh4yiH5iGHuhH3qNrYeFVQFcSYK5BVU5BV n2D5qtWqp9gEVScybC5l2FzKsLmUYcciw74Avxt5dizy7Btsuuqg6iC7T/Wm6i1WpDqMzHs/ZV4B mbcA+HXkX5HybxzlX4Hybxzl3wTKv6WUf3Mo/xZQ/h2C/PsCGyZ0C90sTXhR+BlLF7YhIw+njDyc MvLXkJH3AH+JvDyU8vK9lJfTkJf/E3gE2flryM5Hgb9Fjh5KOXoo5egM5GiZZap1yNQjKFOPokw9 Epk6mY1Wp6hTWLY6VZ3KJvOsDR9Zm2Uha48CZqlHoxdyNxvDczd6FauLgSXqEuydpJ4ELFWXog3y OBB5HBH+nN1Ues5uGj1bN5WerZtGz9NNQU73suIoJaqNqZDZVzNd1I+iOtnXo56O6mIDo34ctZ4V Rj0b9Ry7J2pj1M/Y4KhtUS+zZGT/V9g4rtfGxvM1gBXxNYDF8DUAGK+JZxM1AzUDWS5fCdg4rATH mVrzO83v2Nc0JzQnmE7zruZdFqU5qfk902CFOI3Ie5r3EDmjOcO0mvc17zNJc1Zzlg3iKweL5SsH 2lzUXGQDNB9qPmTxWD/+xFSay5o/41hXNP/NBmquaq6ye/iKgmP9TfM3lqS5obnB7td8pPkIs7qp uYmZ/F3zd/i3NLfgf6z5mBVr/qH5B0a+IwpsoKgWo1ixqBE1TIV1SMuQxkWJxYrRYgzTibFiLFOL siizJFEn6tj9YpwYhzZYq9gArFWD0DdRvAd9k8UUtE8Vh7B4MU0cipGHicPQd7g4HJghZmCEe8V7 0T5TzET7EWIW2o8WR7N7xGwxG/Ex4hgWJeaIOUwWx4q5GH+cOA5988Q8jDZeHI82+WI++k4QJ7AY vi7iWPeJ9yFeJBajZYlYghEmimVMI04Rv4GW5WI504oPiA9gzg+J38Z5zRG/g/EfEfU4epVYjaPU iEaMUycuYSWiSbSwiaJVdOCITtHFJolNIvKG+ENxGUsUm8VmzNYttuBcvKKCcXyiDyP4RT9GCIgB jP+o+Cj2LheXY3yszSyFr81sLNbmH7HxYofYwfL4Cs0GY4V+Gnu7xC6WLP5YxHtffEZ8hhWJ68R1 uM4bxA3A58SNbBxX1kN7rOIY4UXxReBWEXemuE3chr4viT2sTPy5+HOMvF38BfbuFHei7yviK4jv Enej5WviHrT8lbgPe18X97N8vvYj/hvxN2h5SDwE/y3xLbQ5LL6NNkfFo5jJO+I7mNVx8XeY5wnx BEsV3xXfZRPEk+JJ9AJXQPsz4hmM9r74Ptp/IH6AcS6Kl9D+T+Kf0P4v4t/Q5oZ4A1fgI/EjzOem eJsN5nyC5YFP6ODHaQey8doE7SCWok3UDmb52mRtGpugHapNZ7lgG6NYkTZLO5pN12Zrx7D7tDna HETGasex+7V52jyMMF47Hi3ztfloM0E7AXsLtAWIF2uLcZQSbQlaTtRORHySdhKOwp8hVXHWwsZx 1gIEawGCtQDBWoBgLUCwFiBYCxCshSVz1sJSOGsBgrWwVM5a4IO1sCLOWthgzlrQHqwFPlgL9oK1 AMFaWD5nLWwCWIsR7eukOnY/uIuF6SSr1Ig2YDDoCwaDOBgMWiqSgnF8kg++X/IjDjaDmYDNoP0T 0hNsvLRaWo1e4DQsD5ymE5GnJdxdUpf0DPyfSj/FsbZIW9h0znIQuSZdwwh/lf6KNuA6bCznOiwl mn/wURatilaxwZzxIALGA8Q/NhaMB+tjdHx0PMsH7xnEiqIToxNZXvQ90few+7meIBsfnRqdylKj h0QPgZ8WnYZxwIrYeLCih1lczNyYuUyM+U7Md+DPi5kH/7sx34U/P2YBS+CcCZG2mE1MiPlJzFb4 YE7wwZzQBswJbf4eq2JCrBCbyko5f2IF4SdhOX9iAudPQPAn4Pfl77M0eaG8kH1NfkR+hA2QF8mL 2DC5Uq5kGbJe1rPhcpVcxdRytVwL3ygb0b5OrkObxfJitFkiL4FvkhvYvbJZNqONRbaijU22Ya9d drCh4GRNiC+VlyIOZgZ0y26gR25hQ2SvrLB02Sf70bJVbkXLgPwojhiUH0OkXV6FkcHecJQOuQP4 pLwGbTrlpzHnLrkL4/xYXgv/GfkZtF8nr4P/H/J/YMz18nrsfVZ+lo2UN8gbWBbnfGwUON8mli3/ RP4Jmyxvll+A3y13o82L8ovY+5L8ErBH/jkbI2+Xt2PvL+Qd2PuKvIuNll+VdyPymvwaImCKQDBF 4OvyfpYp/1o+gDZvyAfZCPlN+U207JV7cZTD8tuIHJWPYUzwSIx/Qj4BfFc+iTan5P/C3tPyaYzz nnwG/vvy+2w8+OUfMNo5+RwbyVkmGwqW6WdDdK26ABuue1SHqwTGGWRjdCt0uFa6dl07G6Z7XPc4 Ij/SdbBs3ZO6J9lkzkQRARNlYzgTZQmciTKBM1EgmCgjJsoSOBNl48CJcoiJTiMmKhAHDTPOMNeM 7ccsdex7+NERp/wGccoH+nHKbxKnTCROeQ9xyiTilMn9VA80pHogkuqBhlQPNBHFF656oCHVAw2p HsSQ6oGGVA80pHqgIdUDmVQPNKR6IJPqgYZUD6aT6kE5qR7Ek+rBDFI9mEmqBw+S6kEFqR4MBseN BePUqXTEblPAbvHDCojjFoLjPgQ2yVnsQ6rvqL6HOGex96uMKiP7OvirE+hSLWPFKje47NfBZYOs BCx2BfzHVI+hPeeyXweXfZpNAotdx0rBX3cAX1a9zCardqp+hb2cvz5M/LWM+OsU4q9TwV/zWBTx 1yhirgOIuUaBueIVAnP9JhskPAj+Ooh0GcKKNXGkyxBHugwJpMsQR+z2W8Ru7xNWCCvZRK46zGYT x00jRjtGeEl4iY0WdoHR3ktcdgRx2VHCW8JbYK6cxQ4XjgnHEP8dmOtw0noYIvxeeA9c9n3hfSDX fcgmFZws4bzwfxD5QPgAyLVwhpIeRIbwZ+EKfK4KkSn8RbgGn2tDjBQ+Fm7D5woRw4Q7QogNJZ2I dLVKLcDnahGZao1aA59rRqSTZkSGOlYdi8gA8OaxxJjHE2OeQIx5lnqIOg1xzpvHqu8Fb85VjwRv Hku8eZw6W50NP0eNSgocegLLB4e+D36RuojlqO8Hkx5LTDpPPRFMeqx6snoyxudMeixx6G8Th55D HPrbxKHnEHueBt7cCd78NLjyQOLKScSVU4grF0btBFe+H1z5ACuJeiPqMJtMjHlKPyULDSlZyKRk EU9KFhXEoR8gDl1KqhblxKSLiDdriTFriTHriCtriSsnac5rzoMHX9B8gAjnx/cQP36gHz9OIn6c rLmuuQ7kDHgaMWBtPwY8jRiwIIpgwFrivlrivsnEcacRu9X247XJxGWnEYvVEotNIhY7Dcx1LPZ+ wlmnEVuNFQvEArQsFAvRknPWacRWw9xUS3xUSxz0G8RBH+jHQb9JHDSROOg9xEGTiIMmE9dMFtvF djDXx8XHWQFxzSLil8Vip9iJOOeXqcQvS8X14no2lZhlgbgRzLKYmGUKMcsScbPYzSaDX25DhHPK h4hNlog7xB3oxTllAXHKh8Apd6Hvq2CWKcQsC4lZloi/Fg9ghDfEN9D+TfFNtOfMMoWYZSExyxJi llPEY+IxjMD5ZSnxywLilyXELycRv5xK/DJVfE98D3s5s7zLKS+LVxHhzLKQmGURMcuHxDviHVZM nLKYOGUJOOVg+JxNTiI2Waodrh3BJhOnnEKc8mHilGXEIEuJQT5MDHIKMcgU7X3a+4CcQU4lBjlF O1k7GWNyvRWZ9FY0pLcik96KTHormn7aUTNJb0VDeisa7RztHBydq65oSHVFJtWVclJdiSfVlQpS XRlMqiuDSXVFQ6orGlJd0ZDqikyqK/H9VFdkUl2RSHVFJtWVwaS6oiHVFZlUVzT9VFc0pLoik+qK hlRX4kl1ZTCprmhIdUUm1ZXB/VRXNKS6IpPqSgWprmhIdUXTT3VFQ6orMaS6IpPqioZUVyr6qa5o SHVFJtUVDamuyKS6oiHVFQ2prsikuqIh1ZXppLpSTqor8aS6MoNUV2aS6sqDpLpSQaorg0l1RUOq K+WkujKTVFcq+qmuaEh1ZTCprmhQA4DFgvGPYKXE7ydLo6RRrAQsP4sVS2OkMaxQypHGsgIw/lzE 86S8CO8vkPKlCWwqsf8CqVAqAvIaYIpUIpVgnDKpDFguPQCcIT2I0Sqkb6HNLGkWaoaHUA+USN+V vos4rwcmSZVSJWZSLVWjfVibilcIU1Ah1OMo4QqhUbJhBLtkRy+n5GRlUpPUhIhH8mL+vE4ootog hbSsCqhCKJZWSauAvE6YSnVCsfSUhPxAdUIBVQgl0rPSs4g8Lz2Po/NqYQpVCw9LL0jd6MVrhhLp Z9LP0OYlqQfI64fJ0nXpOkbg9UOR9LH0MZtE9cNDVD+UUv1QHC1FS6yA6oei6JjoGPg61A/F0QOj B6I9ryKmUBVRRlXE1Oik6CTUGIOjk9EyBbVEIVURKdHp0elsMqqIuWwAVQ4DUDPMZ4NiFqByGBSz MGYhIjUxNWxiTH1MPdAUYwKaY8xAa4wV6IhxALnCThwp7MSRwk4CKewkkMJOHCnsxFEFEkU1xrdi h8RmsPtiZ8Z+m02MNcQuY7MjSmC86lCj0hjDoqiWGEO1xGi5lmqJH8j1YLq8fhhOlcMYVA4W+Fa5 EQzeJbsQ4TXDvXKz3IyIR/aCzfM6YQTVCWOoThiNOmElIo+hWhhN1cIo+Qn5CbTndcIY+Sm5E3uf Rp0wCnXCjzEarxNGUJ0wnCqEe6lCGCs/Jz8HfF5+HsgrhAlUIcySX0CFkIcKYSviP5O3sXFUIeRR hZBPFcIEVAi/QGSH/DLLkXfKO9HyVflVxHmdkCvvQZ0wVt4r78XeA6gQxlFtMIFqg1nyIfkt7D0s H0GcVwj58jvyO2jJa4MJ8u/lU4j/F2qDfNQG72G0M6gQhlKFME4+K5/FcXmdMJ7qhFz5jzK4Fmke ZZOOWpZ8Sb6MCNc/SpevyFfhcxWkTFJBSicVpGxSQUonFaRhpKM2VP6H/A8gV0TKlkMymBjpImWA IIOJkTrSMNJUG0oaSUN0kk6Cz5WSMkkpKZuU1bJ0cboBiHPVpEzdIN0gRLh20kjSThqmS9alYi9X UMomBaVMUlAaSQpKGTr8YC/XUcokHaV00lHK0NXr6lH/8IpoBCoiH0tDRYT7Qdema2OjUBG1I86r oHyqf2ah/nkKfqeui42jKihft1a3Fj7XY8okPaYhpMeUTXpMI0mPKTOs1sZUQ66lKdjK6pXsfcb0 C2B6mBFmgtlgS/u2qsbN2LZEYgHYSthqWCdsHWwjbAtsG2wHbDdsH+wg7DDsGOwkE/xmMqY/Qyb4 HbBl8M/DLsGuwm7AbjNWJcAkWFz42FWJsFRYer/tyH6/54THqsqHFcFKYdP7bWfCZsPmRfrw7UJY NWwxDPOqcvRtBb9CpmrcCtsOf3lfLGztsI6IvwzWFfHXR2xTxLphPbCdsD2w/ZG2vdSeVfE58+1y WDusg+YVbnuE2rGqLth62CZYN6wHtjNyvOPw98D2w3jbIzAeOxXZfypiZxHjdgHnswu2t+9cWNVl 2DXYTdgdxqqjYDGw+PB1r06CpUW2GZ9s+9pnhe8BvqX28eHf+/bnwgpgxbAyWDms4pMtf/2q58Dm 99sughn6beth1r6t4L8Qnne1K3xu1e7IOP4vZ3Rf97dA2Pg8PjXenH+yIGxVZBv8zDiCn89tDWxt +LWp3gDb3G+7FbY9amBlsbnc69CfsdzmaBUIJeB5axzwkjUReNWaCrxhTQfeto70Ongv5XqVYM1R blWWmSu8yyrLzXO8SpVkzScs6vPjrKVehe/1scoK83zv8qpE63Tv8rAfwTnmRd72qlTrTMLZ/+Sn W+cBR1oXAnOs1cB862JvO+/lEyvnmw3ejspF5npvV1WR1QwstTqA063LvF087pMrDWard33VTKsC nG1d7kuorDe7vJuq5lnbCTsIu4ALreuB1dZNwMXWbqDZ2gN0WHcCl5ldvuQqxbrHN6zSanZ7u6uW W/d7uytdZr+3p6rd7PdlVrrNQe/Oqg5rL7DLegS43hz0ZVdtovh6jpV+8yrvnsqgeY13f1W39Xgf 9lhPeffzuC8vgqvMa729VTuxl+PZPn+P9QJwv/UysNd6DXjEerMPj1vv+AqrTjVG+SZWrjFv8B6p OtsY4z1Cox2PRC40xgMvc+QR39TKtebN3lNV13DNOc686/O4b0blBvNW79mqm41J3rPc982qutOY Bn+zebv3QnVUYwZhVp8f05gLjG8sACY1FgPTGsuAGY3l5FcAs8zbfXMrt5p3eS9Xbjfv9V6rzm2c 41vwKSxonO9bULnLfMB7s3Kv+ZD3TnVx4yJCQ59f1ljvvVN5wHxUiaoub7T2YUWjS4mqPGQ+ocTU 9yy7Qnid8BZwZzMD7mkWgfubZWBvcwLwSHOyEsN7BWbVH28e1ral8qj5tBJfecJ8TkmqP9WcCTzb nE3I/QvNeUoS39u2rfK0+aK3p/5yc6G3J+xH8Jz5ipJWf615IuHUf/JvNs8A3mmepaQtiWqeC4xp XqCk8V5tOyovmq8rGZVXzLeUrCXxzXpgUrMRmNZsUrJ4vG135XULU3KXZDTbgFnNS9v2Vd6yiErB ktzmFsIA4UpgQfNqYHFzJ7CseR2wvHkjsKJ5i1LAe7UdXDKnedvyc3qmn6EUL5nfvEMp1osWWSnj 2HZYL1sSlPIli5p3Aw3N+5RyHmk7Fo5HMMGSrFToky3DlDlL6psP9qG1+bAyh8fbTkZwmCVTmb/E 1XyM8GSf724+A/Q3nwcGmy8BVzVfBa5pvgFc23y77cySDW6h7bw+05KtLFqy2S0pi2g0QySy1R13 F3mk7ZI+25Kn1C/ZjtcO6E686/N421V9nqWQn5c7FfOH33ZsyS53OvxCy0TFumSveyRhTp9/wJ0P POQuAh51lwJPuKcDT7tnAs+5ZytW3rfthn6iZari0k+1zFDcSy665/XhFcLr7oWKG9d2Fq7wDMtc xb/klruacPFd38TcZsVfedGyQMkwiW5HH8ruZUqGfpZFrwSr5zS6Cf19/vzGIHBR4yqgoXENsL5x LdDauEEJ8l4+fbWrcbPPqJ9rMSqr9AssJmVNtbtxK9BPGCRc1bhdWcP3+kx6vcWmrNXrG3dx5H71 msa9yla90bLU21G9tvEA4aF/8jc0HgVubjwB3Np4Gri98Zy3g/fy2fQmS4uyQW+zBJTN1bsaLwL3 Nl4BHmi8DjzUeEvZrF9qWalsrT5KeMLGfEv1LZbVyvbq0zaRUCZMULbrW2zJ8M/ZhgEv2jKBV2zZ PG5Z7Wupvm7LQ+SWrdAX0AcsncquGmabCBRtU5Vd+pWWdcreGtmyzreyJsE2Q9mrX23ZqGyvSbbN Ag6zzcU4iPhaCFeH9+o7LVuUA/p1lm3K1ppM24I+zLbpcWUQ93XW5NmMvnVhX7/RskM5VFNoMxHa +nCibSlwqq0FOMMWAM6yrQTOta0GLrB1+jbW6G3rfFswzm7laI3RtlE5Cn8fcIvlIGZosm0h3IZZ IYJ5brMcVk7U2Gw7Po087ttWs9S227ejpsW2TynQ77AcU07XBGwHldPc9+3W77Adhr/bcpLO6Bjh J3627Qxwpe08cLXtErDTdhW4znYDr9Ea222cO/rifPdZznhP6Q9azivnajbahT7cQrjNLinn9Ict l5SL+mOWq/wesMcRJt7Fmh32VNwDJy03lCs1u+3pfbjPPhJ40J7j21dz2FzuO1hzzJ4PfsK5weGa k/Yib3vNGXsp8Lx9emQFP8bXQd/Jmkv2md7emqv22d5eWonO1Nywz+Orkn2h90LNbfMh33mDYK/2 3jFI9sXeO/R+uWSIs5vx3uH37VVDot3h7TCk2pcB0+1K5B67wV9f323DSPty5ZB+o70diOvgFww5 9g5+TexdQDpTQ759PbDIvknZzFecttumBLeC1QeZPyiYkt3LlTTTMHc7MNPdEc7PQYlnuWCcKdvd pcw35bnXK/N5ngkmmgrdm3jOcXcDkUmCqaaJ7h5kj6nunYqf3/m+FkOpvVupMEy39/glw0z7Tn+c YbZ9j/esYZ59v1cxLLT3epcbqu1H/IlocxxtFttP+VMNZvtZX4LBYb+grDEss1/2pxsU+zVvl2G5 /ab3sqHdfsc/0tDhiPLnGLocMd4ew3pHvD/fsMmR5C8ydDvSvL2GHkeGv9Sw05Hln27Y48j1zwzz DcN+R4F/tqHXUeyfxxmFb5bhiKPMv9Bw3FHOXwVHhb86vLIbTjnmAM865gMvOBb5FxsuOwx+s+Ga o97vMNx0WP3LDHccLr9SG+Vw+5fXxjj8/vYwp62a5wji1SfuFGYptfGOVf4+3uhY4+2qTXKsxUqN e8PfVdXr2ODvqk1zbPavr81wbPVvqs1ybPc7anOpZYFjl3d/bbFjr7+7tsxxAH6545DXUVvhOAqc 4zjhba+d7zgNXOQ4591Ua3BcBNY7rnh7a62O60CX45b3SK3byYB+p4j5BJ0ycJUzwd9TNdOZ7F1f u8Y5zL+zdq0zE9wDV8C/p3aDMztyb+trNzvzMM5WZ6H3Tu1250T//tpdzqn+3tq9nGHWHnDO8B+p PeSc5T/O3xf+U7VHnXPB0sHV/WcJL9SecC4IM3D/ZcJrhDcJ7/CjtEaFsfa0U+/tqD3nNOLcLzpN mNsVs7U1pva60xbx4wmT+PurNa32Fr+SnA+3ZhBmcd7bmmtkzqWtueQXEBYbRWeLd49RdgbAh8GK W8uMCc6VYQ7cWk5YQTin6oJztfeIMdnZCRzGkbPW1vmEi4yZznVhptpqMGY7N3pPGfOcW4CII1Lo 3BZmra31hFZCF3/Xt7oJ/WE0TnTu8F42TjXvag0aZzh3e68ZZ5n3tq4yznXu8940LnAeBOqdh713 jEbnMXBLvC6tawjXGk3Ok/64GqMTWdFoc55v3WBc6rzUuhkRZEVji/MGZh5w3m7dalzpElq3G1e7 JGWvsdMV17rLuM6V2LoX8dTWA8aNrvTWQ8YtrpHI6pS9jdtcOa1HjTtc+cjGx1xFrSfCmdC421Xa etq4zzW99ZzxoGtm60XjYdfs1ivGY8QBTrvmYS0IrzKUt8NrtPGkayFWfKy2rdeNZ/hqazzvqsZK h6zVeqtmhmtx6y3jJZc5wIxXXQ5ll/GGa1nrufC6XJPpUnAut13LOZdwtSvBOsHVwdd0V5e3o05y rb+72tbFuTbx9cvVrRyqS3T1IJLq2glMd+25u1LUjXTtD4h1Oa5e+PmuIwG5rsh1PJDAzy6QXFfq OhXJtLa66a6zGGem64KyuW6263JgWN0817VAJq7MzUB23ULXnUBeXXVTVKCwbnFTTGAiv26BqTTO jBrWFK/sqjM3JQVm8RwemBthO8DAAkL9XVZjsQWMhMRzAjbCpXwOgRbCQJ2jKU3ZUDezKQMzWcbZ SJ1iWekX6pY3ZYX9wErC1XwtCHTyrBvorGunKwx2EVhHuJH4w426jqZcrBfwA1sIO+u6mgqUA3Xr m4rBKMArAtvqNjWVhVmEX+AY2EG4uiazqVw5ir0VwO6mOZEV/wbHwO66nqb54VU+sK9uZ9Mi5UTd niYDEHFE9jfVh1f5wEHCw4TH+DoVOEm4mvBMXW+TFWs3VvBWQ92RJhdWaqzjgfN1x5vcysW6U01+ 5WL1gaYg7o3dTauUK3TNLxFepeuwo+5s0xrldN2FprXKubrLTRuwphMLrbvWtFkpMM1w7wmmm2a5 9wdum+a6e4MjTQvcRx7tNendx4M5JqP7lLfHZHKfpTYX0Mbmvgzeu9R9LZhvanHfDBaZAu47wVLT Sk9UcLpptScGI3R64oMzTes8ScHZpo2eNKXMtMWTEZxn2ubJCi407fDkYt3c7SkIVpv2eYq9l00H PWXBxeHqwHTYU66Um455KoJm02F3etsx00nPnKDDdMYzn6+qnkXBZREeft5jIKwHXvJYg4rpqscV XG664XEH2023Pf5gR4PgCQa7GiTPquD6hjjPmuCmcAW6JNezFjVXuNKhmqIh0bMh2B2u8hpSPZuB 6Z6tqAj4Wt+zJOjZHuwxiZ5dwZ0NIz17g8sbcjwHgu1L4qllvufQ8u0NRZ6jwT3hOqu+x4Oat6HU cxr17DXPOSWtYbrnIurKXM8VpaBhpuf63aM3zPbcwhyoSmqY18JQMYXns7BFBFa3yMH9SzJaEpTc hsUtycHeBnPLMG8HvwLBIw2OlswwV2nb0bCsJRujKS15ir9heUth8HhDe8vE4KlwPdjQ0TI1eLah q2VG8ALnOcHLDetbZmFdQ2UdvEZ4s2FTy9xwvRy8w7E1i6Mvk+OKKH6UFXSsFfEmuQXXv6G7BbVw Q0+LUcnl9e+KpIadLaaIn0aYwfnSirtXEtXrilzCAj6rFcUNe1psK4rJLyMsb9jfslSpaOhtaUH1 ihp2RUXDkZZAuGJdEcb5hKgrW1biih1vWX0XeY3pu81xhaHhVEtnuK5cUd9wtmWdUt9woWUjEHFE LrdsCdeYODrHMkKqNFdQzbjCRehu+L/sfQ9QHNeZ5+thGEYYjzHGmGBMMCIYY0wwVrBCCFZkTGQZ hpkBEy3GmGBuprtn+g/D/OlpFIyIZsAKp8JarcJqFUXHcjqVorCKSkdkrawoOoVoFUrhFFbLqnQq rFUpipZSdArRcoqC73tf98AI4Vip3au6qqS++r33pvv169fvfd/v+/rR3dzqGoE7R7h/fK9HmOs6 DPeJcBf5Xp8w33W0e41o7DoBaWLXGMR4pq7x7hw6L+9txXT727Nd597bKSZ3TXVXiWldl7o3ipld V7p7xJyu692Jrrngge4+55bgIWCt+eARiFEVYMUDrDF4/JsX2cTgqc232eTgmU072LTgxCaFzQzC vdtCenHzXTYneDlsgPQapjcgzQ/Ohs1sUfBO2MKuCk5AxI73dM4tCoGWyxRTOJVdoySFM9gqJSWc 7dxH+ZOmcJZqJT2cxzq8xeFCdgOkJa2zCtzBsc1Kbng126YUhCtYXikOV7KyUhpezwaU8u5TNA3b KE+GG/R7K0zZjcrad+fYHulwuIntU9aFW9mtijXMstuV+rDI7lQawz52j9IC6U7FGVbZvYon3I1p hD2geMP9kCqQHlK6eg5CurnnIOXS8Db2iLIlPMgeVwbCu9lTyo7wMHtG2RXez04oQ+GDlEXDo+x5 ZV/4GHtRGemW2cvK4fBJ9ppy9N0L7A3lBHDgemUsfJqdVcbDZzUPRdPwZMtU4GT4QsuUci48rUVu /+mMMhW+yt5RLoVnOKJcCd96e6ty/d3TnEm5GZ7jkpTbYTOXotwNz3PpIUNPA5cVMkeMXG7IEknk CkKpkWSuOJQRSYttjSsNZUcyIc2L5HDlocJIPrc2VBIp4taFVkdWcdZQRaSMqw9VRtZwjaH1kSqu JWSLVHPOUEPEwXlCTZENnDfUGmmGlI20cUpIjPBcV8gXkbnNIXWTk9sS6o4EuIFQJLKR2xHqj/To 6a7Qtkifpi2ts6HByFZuKLQ7sp3bFxqO7ORGQvsje7jDoYORvdzR0GjkAHcidCxyCNo5Ce2MhU5H jnDjobOR49y50GTkFDcVurBpH3cpNB0545oPXe0+w10JzUB6PXQrMsHdDM29Ow3pPKS3VWPkPHdX TYxc5A1qcuQyb1bTItd4i5oZucGnqjmRWT5DzY/c4bPVom6ez1NX9RK+UC3rPs+XqGvCc/xqtarX xFeo1T0H+UrVAX3Ds/Dr1Q29SbxNbe5NaalX23rTW1pUvnsn36DKvVktO9RAb27LLnVjbwGkPd0T fJPa11sM6dbe4pYRdXtvKd+q7uzOaZlS9/SW86y6t3ctL6oHetfxPvVQr5VX1SO99dyQehxGCdLe Ru2un+9WT/W28BH1TC+u2/RirNLr5fulrl5FszgaY2wq0Fcq7rWOo9pagbYyEN7Gb1Mneruof+/d TO/Be7foOomrQ3RtYdMOflA93zugRWL8bvUipMPq5U1effUG11VYo+Tp3UGto3eXdtfP71ev9Q7h XedtYiBPMDeZ/00I81sGfjF3mN8RI/OxgSEmQ7zBRFYYHjIkkYcMyYZHycOGxw1p5BFDhuFJ8qgh x7CSPGbINzxLHjd8x/Ad8kTcurjXSHp8VfxXSUa8N76DZMb/OP7HJMsCQj5rybbUkGyLzdJErJa3 LWHypuV9y49Ij+W0ZYb8wHLDcpuch97YiRHfX7WQR8gK8iipJw+RBtJKakkb+RZpIv+ZbCWbyQD5 BYmQfyQfkTPkX5hE8k9MEvMw+Zh5hHmcYZgMJp8x0+cXmSeYRsbFZDIcE2EKmD5mO7OOGWS+w7zB /Hfm58ybcd+P+z4TMPqMfiZo7Db2MCFjn/FbzEbj+8b3mW7jt41/zWwyftf4t8xm44jxIPOecdT4 AdNv/JHxR8yA8SfGnzLv49t/243njL9gvm28ZJxm/tp41fgrZpfx18ZfM3uMvzX+G/Nf6NNszHD8 Y/GPMf8t/hfx88w+U7wpl5k0PWN6hpk1PWsqYn5reslUxvyOvqnAfGx6xVRpMJqqTDUGk6nW1GSw mL5uajNkmpwmryHb5Dd1GZ43vWfaanjJNGDaZfiy6bumvYb19D0Ag8M0YvqZoc501nTW0G6aME0Z vKaLpouGTtO0adqw0fRL03XDN+jzUoZNpt+YZg0R023TvKEvgSQ8bHg/ISXhccN3E55IWGn424S8 hC8YDiZ8JcFjOJHQkbDNMJPwVwl/FUef9dkV93DC9xJG4h6j/w8u7omEHyYcictMOJrw47gs+rxO XF7CPyZMxa1KuJBwNW51wq8S/i3uVXOe+VBcvfk3K56O+8jyO8vvjPSNLw/pgzSJZNE3gr9yE3CX kLUlgDySJw69xov7xBHx8GsHxKPiCXFMHBfPiVOS2e6TLFKqlGEflbKlPKlQKpFWSxXVd2qyvjpk PSZeqiHiFfG6eFO8Ld6VDDVZr/eDVhlBx2+ijv+WMMzHzMfEABqdTOJg31P4RCgxfM/wPcIYvm/4 Puw7aPgBiTN8aPiQxOMToSbDzw0/J2Z8l2mF4ReGSZKIz4Im4VOgDxs+MnxELPj85yOGXxt+Hf3v X3FMHLPw3w7j40wkDd99So9Li0sjn4lLj0snGfjE5pNx+XH55Cl8rykrrjyunGTjW0xPx62J+wrJ wXc8cvGZjc9B/5OYFBw5mhIxk0D8IOaI+WKRuEosE9eIVWK16BA3QNostom8KAMC4kaxR+yDfVvF 7eJOcY+4VzwgHhKPiMfFU+IZcUI8L14UL0N6TbwhzsK+WfGORCSIyiSItySIdiWImu6RExLEQhLE PQtileqlRqklRpySR/JKitQFdRdlTBqHdLO0RRqQdki7FmRI2ieNSIdRjkJ752BbqTQFpUvSFShd l25Cm6XSbemubJC2wPUzKzw6a9D3yh/FMUkHiSOZIEaSR54h8aQQJIF8HsRMykBWkHKQRFIB8hCp JK/i+4OvA+tobw7+BWnENwebob02kMcIC5JKOoiPPE5CRCVPkHdBPkO+CZIBfPQ+eZJ8G+Qp8jcg WeS/kr3ks+R7IE+TEZAc8gHISvL3ILnkQ5DPkf9BTkH/zoDk4//vfJZMkX8mBeR/gRSSfwF5nvwS pIjcIr+Bvs+R/0NeIPMgLzIGJoGsYhKB+8rwOe4vAfclk3J8jruCyWKeJi8zK5mV5BV8Y7ES2NBG XsX/c1fFvMW0kK8yrUwreR2f6a7G9xNrGA/jIVZGYiRSy/iZALEx32B6iAO4M0I2AHu+R/6C+RbT T95kBpgB8ha+n9gMTHqEvM0cZY6Sd5gTzI9JGzPG/JQ4mX9g/oGwzM+YccKh/rqBBfKJx1xgLiAS Pj0nm18wl5B2fGKuw1xmLiM+c4W5gvjxfZkAPh8XNLeYv05C5nfM75BOmNur5Dbqfin93o2QAkgH ZAFyAQU6inWUAsrJ14R0IUvIFQqEYqFUKBfWCusEq1AvNAotglPwgHgBitAlbBa2CAPCDmGXMCTs E0aEw8JR4YQwJowL54Qp4ZJwRbgu3BRuC3dFA4hZtIipYoaYLeaJhWKJuFqsEMbESnG9aBMbxGmx SWwVWVEUfaIqdosRsV/cJg6C7BaHxf3iQZBR8Zh4UjwtnhUnxQsgV8UZ8Rb9v2jxrfEcOMG3LM2g sQbQz/8o/a4BeQS1PBm1/FHU8sdQy1NRyx9HLU9DLU9HLc9ALX8StTwTtTwLtfyzqOXZqOU5qOUr UctzUcs/h1qeh1r+DGr5s2QcpAB1/TnU9ULU9SLU9c+jrhejrr+Auv4i6voXQNcNpBT1+yXU7y8y TzFZoPdUs8tRs7+Mml2B7ym8jNq8BrX5K6jNa1GbXwFt/gbYwLvMu2AD9G2Fr6I2r0NtXs/8JfOX YA9Up6vxPYUa1GYrarONGQc9djBnmbOkzvyG+Q1Sb240N5I3zJyZo28cJ3cnb4F5SoKxf4gwvkOE eLYABgA7ALtg2xHIhwD7ACOAw7DtuPFRT79vh5j7h4F1CgJFnm2+XZ5B35BYfC/oNs9u3z6xFFAe WEXhGfaNiGv/MGgdz37fYc9B31Fx3SLob8+o74RoBdQHyjzHfGNi4x8G1mkJrPGc9I2LTt+457Tv HOKsb0r0ALyBKiwrgWqxK+DwTPoueS74roibF4G/twQ2eKZ918WBT8GOQDO2cdV3EzHju+255bsr 7tJAy545v0EcWgT97Zn3m8V9fjPNKQSj3yKOfDpoPSHRnyok+zPEw/dCSPNnC5n+PPHovRBy/IXi iUUI+f6SB0HHdnVcKPKvFlb5K5ZFmb+SomOneo5CWONf/0Co8tuEan/DJ6FjjzolOPxNDwLvcOii sMHfimj2s4g2v0jRsVe9RHPvpJrUcUC9IvB+nyD71aXwHgxdEwL+7k9DxyH1escR9aaw0R9B9Pj7 hT7/tnuw1T94H7b7d9+Dnf7hB8Ye/35hr//gfTjgHxUO+Y/dh6VjfcR/8kEgjgXahOP+08Ip/9ll AfvE8QAvngvIWO+Mf/KBMOG/sKzu0PamAJcCAeG8f/pBIF4JbBQu+q8u4LJ/ZgF0/3XAzUAPlm8H +sS7ga3CNf8t7O8SSIbAdizf8M99GiRzYKdkCey5p41Z//w9uBMwLoWUGtgrZQQOiCSQKGUHDmGe FziyXH8+CaIpkCwmBdLuQ0ogU0wP5NyHrEB+LKTCwPEot9/DxTpXRjlOKgmcinKQtDpwJpZHFvQk dl6j8xIdo4rAxMLYVgbOx/YJueQ4cAroY8cpTS87zug2TO1qAnBevU31veMi4LJ6N6rPHdcgh/NI 6wMXJVvgstQQuCY1BW5IrYFZ6l8kNnCHbsdrAx8hiUFCfYnkC5okNZgkdQdTpEgwXeoPZknbgrmU 2+k1S4PBAml3sJjyszQcLJX2B8ulg8G1yMvA6XQspNHgOsqd0rGglbYrnQzWS6eDjdLZYIs0GXRK F4IeaTrola4GFfSR1AdRn0DHcCZQJN0KdlE/Js2B/4mO83zQKhuDm2kbdJ+cGNwiJwcH0PdEfW3M HC20SaH7lKgvoP2ivlFOC+6QM4O75Jzg0MI80/owd3Tu5fzgPrkoOCKvCh6Wy4JHcdsa8OHbNFB/ Tf32PRjW/LJc5TuM/hjOE/XFNEeA/uC1LfGxNKeQq32XKKh/jPrVKGSH7ybFgo+kPlP3jbG+MtZH Rv1kFPIG8IPgC9H3gT+Um/3ZFKi31M/laJDbgieoXsp8cEyWg+NYDgTPyRuDU6izwB9yT/CS3Be8 gvu2Bq9jvj14U94ZvE3tVt4TvEvtCa9rr2KQDyhm+ZBiQbuI2oHOi5RL5SNKKuU5+Thwk24j8ikl g/IWPT7KgffZ1hK7WuAX3bZoG5Q35TOBWXlCyaZ9XDge6lN7k88refJFpVC+rJTI15TV8g2lgvab chK9BnlWqZTvKJpv+DQO0vvVTnQej/LSVEwdvc94rUv4eOF6KA9H8Unn+gQ+bTfpeVIgkc5FFPfx ZCxXUn6McmQMH9K62A6tQ7kJxqA9JXCg40angc5xx2ynmV5nx51Oi490pvpMnRl0O3KWrO7zJXVm Y/wCekfr+lI68zDegLjDl95ZiDEFcJovq7ME4zQ9JvDldq72FXRWUP/vK+6spFznK+1ELvSVd9oo qI361nY2+NZ1Nvmsna2Uh331nayvsVPEmAz40tfS6cNjnZ3qQsxEYx49RsG29DboPp+ns7vDoW7B fkVju2hs4FjkYEQ0htFjD9oWtuHtjHgzQg48Jno8rU85mv6mekHHgF6b0tmP22jcGIUeJ96DB4kF ad+iMV1MXLcAGs9FsTSui8Zoy8Rmvi4Nnxqb0dgrNv6iMVc07oqNsWhf6bG0TnRMdNtqT1dsmGcp De25ShPqKo15onZVoLS2FyssolQR28sVX/taRW1fp3S3W5UIol7pb29UtsXqe3uLMohwKrupfbV7 lOF2r7K/XVEOtncpo8vaG9wftG9WjrVvUU62Dyin23coZ6P21r5LmVwoDykXEPuUaQq0vRHlavth ZQbzo8qtqA22n1Dm2seU+fbxkHHB/sCu2s+FErE/U6Fkylntl0Jp1PdEQWPK9iuhzPbroRy85puh /PbboSLKXZQ/2u+GVlGfEq3vNYTKvObQGq8lVOVNDVVTffRmhzZ480LN3sJQm7ckxNO4wLs6JNN2 6Ph5K0IBb2VoI8a2MP/e9aEery3Uh2gIbaVjTsfO2xTa7m0N7fSyoT1eMbSXcrfXFzqA9dXQIW93 6Ig3EjpOY0Bvf+hUlJu920Jnon7JOxia8O4Onaf3I979ocv0nsI7GrrhPRaa9Z4M3fGeVgkdR+9Z 1UTvR6jv9l5QU2gb3mk1nc6z96qaRe3KO6Pmem+pBd45tdg7r5Z2GNXyjkR1LfXvdF9HsrqO2hzW g353pKnWjky1viNHbaR978hXWzqKVCed845VqqejTPXS6+pYoyodVWpXR7W6GTlB51zKkx0b1AHq Kzua1R0dbequDl4donzXEVBHOjaqh6nu0vGi5Y4e9SjqM+hCR596omOrOkbHkRgIY4lYBgj5819Q /oT+gjJDbi3+HYCrJh5O5gLcRq6H6+O2ctu5ndwebi93ANJD3BGuWpcA4jh3inPocoab4M5zF7nL 3LWGY9wNbpa7wxPe1HCVT+JTvpbGpzdM81lcmyZQA8Dn8gUcr0nD6a8l88V8acMoX86v5dfxVr6e b+RbeCfv4b28wnfxm7kNUYEaW/gBfge/i2vWhB/i9/EjUO8w9o/2iNak++gZ4Qx0nf/h/aDbr/2H rIPWgG3UgjyK66ApuA76GK6DPo7roGmEJTx5gnhAMnA19ElcDX0KV0M/i6uh2bga+jSuhq7E1dBc XA39HK6GPoOrofm4GvosroYW4Groc7gaWgg2N06KyFmQF3A1tARXQ1/E1dAv4GpoKfkl+RV5ifwr SBmuiX4J10S/jGuiL+Oa6BpcE/0Krom+wmQxWaQS10RfxTXRKlwT/Squia7DNdHXcE10Pa6Jvo5r otXMN5h3iZXZxGwidlwTdeCaaB2uib6Bq6ENYOk/JF9jPmA+II24Jvomrom+hWuibxu3GL9FWvBb ea3GI8YPSBvY9RhxGq8Zf0VYsN/bhM6fQroWdZVNJSVsKpvBZrN5bCFICbuarWAr2fWsjW1gm1C2 sYPsbnaY3Q9ykB1lj7En2dPsWXaSvYDSyrKsyPrw+EJWxbSbjUDaCtJPheqN4TnQm+d1vUnB81ON McAcPQPaQ3XFCONfAtpDdcWEupIAmvIq6BBdM18B2tEIOkT14yHUjyRcJ38YrssNmkS1IRl04X3Q J6oHKaAFe0GfqAakkh+API4akIYa8ATM/ynQW7oe/hmY838GDaOz/iTOeiaugT8FM3+dZOEcZzPJ MMdP4+zm4LyuxBnNZd5mWsjncEafgRmVST4TgBktwFXu55h+mMVCnMXn9e9I0jXtzzM/ZI6QYsKY S83li/PhajA+6mpYKmwP2+dqcrW6+jVht7qa2O1UXOxSYXe6RJdPE3aPS3Wp7F7YskTYA67drm6Q CIjW5iHMt7kGo8IegTr3CXvcNQwt7Hcd1GVUE/YUpmcgPXa/sBOuk67TCxJxjkVloeXIUpFOuLe6 zromoyKNuS7oMr1UpHHo1VVNpHOuGdcMmwhblog0JV1y3ZKuuOZA5qlI18UJ1zxrZBOjIt1kk5cK jE6fa5grd02yaZo4z2ki3WYz2UzpOpu52M+YHt91DrA5UXHNsflRgRa1tovY80vkInsZzrNqQa6x ZVScA/dfNXvDlcGuWRBaL42tWiKzgDtsNYqDdXBE286ZuCTIN2itU+FSuHS2+X7hstg2LpflUV+6 uQJ6xVS4Yq6UK3fe5dZy6zjrYjsxLdY7z8Xok8wGuEZN2I2acC1Uvzkn6q7IeTgv1QVOoTrDdVH9 4Daz57kteLVV3AC3A3u0A1vfxQbYANUU2YDjMSybZQsdVTmVjr6cQUeaG+L2cSPcYe4od8LVxI3B cePQ9jluyuXjLnFXuOuuCHcT+rebu83d5Q28mbfwqXwGn83n8YWu3c4TfAm/mq/gK/n1vI1v4Jug xyL08hjfilYW4Vle5H28yle6fHw3H4G2qNXiFWHN3WgncEV8v0vlt/GD/G5XAz8MbY9BvVawpVF+ P5Sa+IP8KKTH+JP8af4sP8lfQFtWNeGn+av0avkZ/hY/x8+7jWCtVAbdie5kdxrqOJzJnekadedQ a3TnA4rcq9xl7jXuKne166Tb4Trt3kBboZbnbna3aZrKrnLzbtkdcG9kHe4el8/d597KtrGZ7u3u nTDKG9173HvdB9yHQF+rYAbK3Efcx92nQOcc7jMgE2y1+zxqYBFbpM0V1mumGkPnyn0RcNl9zX2D LXLPwp6A+w44dZMnyZPCrvKk87s9WZ5cT4Fr0lPsKaVHeMo9az3rQKyo42XcFtxa72n0tLAOj9Pj 8XhBFE8X6DCVMs9mzxbPAPS6zdXt2eHZxWZ6hqieevZ5RjyHPUc9JzxjnnEPWK1nyjXouQT6KNNr 81zxXPfc5NaChgbYIs9t7gSMzSi3FizugpwN3NUsTsh5cqHrqlwC+jzvmpNXA1MkyxXcFbkSbHnS OSavFyfECWrXrkrZxubLDXKT3Mqv57KkJBjtYaqVwGaUn+boaaEW1IBfp2URmIryHWqwVpMyDM5L pWtG9jkHZBV0vBu250O9SeCrTJkecVbul7dBHwfl3fKwvF8+KI8iC87IxygDyifl03C2s/I2eRLl AvCcUeM6flTGs1ENlged5+SrlM3kq9AyrTkj35Ln5HnXSblfYy7krmTZADIIY5pDe+K+5rkr0E+8 mQWLkAoMtU/IEDKc+0BX9gjZQh7lJFerUMj7hBK2TFgtVLh7hEq2Slgv2IQGoYndILQKLOwRBZ/7 mqAK3UKEWqzQL2wTBl3d7p3CbmFY2C8cFEaFQeGYcFI4LZwVJoULHBGmAVeFGeGWMCfMi0a+UEwU k137hQvua65jYhrUbnJNu/twDz6T4/LRp3Lch7h99Mkc1+6FZ3OaxTbXtMjj0zn6szmuefpsjjDJ XdGfz9nqOrnsMzrXxBvCpDgLtjbHJdGndLgkyQR66gB9tcLMH2QDUgpwY75zbPHJHQ68hVTKJkvp 7mT9qR39aR22TaoXi/QndbLwWZ3FJ3OiT+Qc9Xgxmnr+z3eYf0J3mCyR8amGNEiJ8wphXCUk1TkN ctV59a2mt5qcMyCDzkEs33Leemv6rWnnHMi8c55ucxlBEl2JdFtTV1OXKxkkzZXWvKp5lSsTJMeV A+cxWKyWWjhHMt7RELyjMeC9TBzGvEa8l4nHuxgTxrwJeBdjxruYFXjn8hDeuSRhzGvBmPcRjHmT 8Z7lUbxbeYwwyW3JIl4TPnfobCOMsw9yuEdxbjU+un7e2fMgqN7l7HndCEj8BCRrqB7R8HraAyIT kLMM8jVUj0Fe9GCoPgf5Kh1lOtZocDZrefV1wE0oVwGq70f1Xcgdn44as97GBh20/bYl4JeBvASB PwIbAT3LoA+wdRlsX4KdDwaHCfI9gL2fgAMaHEkaXj/0gDgCOP7JcKRAfurBYKe6c0bHhI7zGhzp Wm6H+XFkQfki4PL9sFM9u/bpcOQCCqB8Q8cs4M69qCbLwLQESX8EYCyq05cBXE917v1YOtbVBQ+G mtWQFwNKPwGwr6YCUKnXK39ArF1ed7AN2qYN8nUPhpoGyK2IPszrYxCt06rnLECEcuPiuWJR49PL LZ+OGhXQvaQN5xJ47kdNBNAPZS/wTpuW1wwu359PhALoWgabAVuWwcC9qNm9yN338G2UL6M8NrzI LzX77+WPBT2JndfovETH6GDM2I7e26cFTonVzagNR22LtqXrvKN+iV7T+TwGOAk4DTjr7KmlfQD/ UnNB206vifqImmkn+hIncGzNDOAWYA4A12+lfqtau14r+Cor9VUwL1Y41grHWCkPyDqnwzhY8zW+ tBZp7VrBnzhhvxX8hxU4xQptWWlbG/TxjY4nHEv9pJVyP22zbHGcaVvWgNYG3WcFLrf2aP26b56W zNGCP9HnibZFfaMVeN8K82TdHnO8Q5s7+tsKY28FHreC3VkP6HWMMUheBkv9cv4yKHIu+tcYH7uA qhgs9bFRf/nv8ZMbnff6wj7nog+M8XfW85peWoH/rZf1Muic9Yaus6BvVuBy6x3tdy3Rc+Dq2iTN bmtTNHui11UL/FsL/Fubq9tF1A50XqRcWlug81z9oo3Ulmr8RY9f4MCltrXErhb4RbetWp2Lqf7X rtX6uHB8i2ZvtXB8LT0PnLsW+K+2Res38hJcQy20V+vRj/s0/lnC48vWifZ5GT5eQGMMPulcn8Kn dB7uwVKejOXKzTEcGcuJxfqxXfq+Ao2jHS3aHDuc2nU64HwOqOdQtO2Us+ygOw44DuOXjVpdB5wD 4w2IOxyU6y7rfDag66YeEzh2AIATqP93DOk8t09r1zGigdqo4zDgKOCExsMO4DTHuM6fwJeOc/qx U87FmGkihkdHFtvAWOoS9PuU3q+lPLyEgxdimCgPj+htXHH22Pr1Y6LHX9O4GX/v1cYAr+26vm1P DA4sgweJBU85F2O6CedCXLeAizFYGtdFY7R/T2yW4rw3/spyLsRd9/iy4/qx6YtjErWt2i16Tu1u h3Mx5tHtqhZ0onZIB+hDLYx5LcxfLcxf7QkdoAO14/fqe+05HVOafdXCPNfCPNXC+NfeXN7eKDfW 3gbAvY3NADAv2pvNElNO1ZGhgdqeLRuQp+eFizZoKwEA39kqYuwPrtlWqfXHtl7jLJtN8z1R0JjS BvGcrUm7ZhvEbTZW4y7KHzZR8ynR+jaI12wQh9kgDrNFNH20bQNAPGWDGMc2rMUFtv16OzB+NohJ bKMaH9P5t0EMYTup47Q25nTsbPS4SQDEErZpjbttV/X6EEPYIIawzWkxoG3eucDNduOiX7JDPGFP 1u5H7JnaPYUdfKQdfKQd4gZ7mTaO9jXa/Qj13fZqrQ27Q5tn+wbNruxwD2kHf2gH/2enbYOvs2/U /Dvu69FsjpZpv+0wr3bwefbtWt/toH/2Pdqc22m9A9p12SmHgb3Zj2ucsMC5wGH2M5qvtIOd2ek9 00WN7+y0Pzc03aXjRcv2WU2fqS7YYVwdRBtH+jTGwycf/smfn8b4U1orMxYYT9G/qBrOkL8jJCEb kAcoBJQAVgMqYvJKPV8PsAEaAE2AVgALEAE+gAroBkQA/YBtgEHAbsCwjv2Ag4BRwDHAScBpwFnA pH6uC4BpwNWYfCbm9y3AHGCeELMRkBiTJwPSAJlafZqbcwD5gCLAKkBZTL4GUAWoBjgAG/T6zYA2 AA+QAQHARkAPoA+wFbAdsBOwB7AXcABwCHAEcBxwCnAGMAE4r12X+SLgsp5fi8mj9W9oY4r5Bf04 Nmb/LOAO/otvssIEAHtdkbKY0/FZkQ7IislzAQUxeTGgdDGnfV5RDlirH7/ujwPOWSzWa6Dnv6e9 9CWwAur13Hp/OysaAS3aeK9wAjwxuRegkL+zb7EP2HfYd9mH7PsoTIp9xH7YftR+wj5mH7efs0/Z L5k89iv26/ab9tv2uw6DwwxicaQ6MhzZjjxHoaPEsdpR4ah0rHfYEA2OJvzd6mAdosOHUB3djoij 3z7u2GbyOAYdux3DiP2Og45RxzHHScdpx1nHpOMCHDftuOqYcdxyzDnm64x1iXXJdWl1mXU5dfkO X11R3aq6sro1dVV11XWOug11zXVtdXydDAjQY+o21vXU9dVtrdtet7NuT93eugN1hxBH6o7XnUKc qZtAnK+7iLhcd63uhkmpm9XlzkKJlu/UE11MIEmOufoU2H5Rk/r0+ixAen0uSAFIcX1pfXndbP1a ivp19VbwCZ9Z9osLRP/ighm/uJCIX1xIwi8uWPCLC8kG+sWFFPziQip+cSENv7jwBH5r4TOWbMsL 5EnLi5ZK8rzlHQtLXrZ4LO3kVYvPEiKvW7os7xK7ZbMlTOos71v+nrxh+dBynHRbTlv+lfTg1xf2 /n/cM4ZJYWR8XuUoeY6Qled1gKWvvKzjmo4bMWUKsO6Vd/TyZfqP27VyrklHkg6w9FywoFyw7lyo lFug1c0t1uvTbaUxv8v1fK2OdYvnzLVqv3PryXN2E0iSPcWebs8CybUXoBTbS+3l9rX2dXarvR6l 0d5id9o9dq9dga1d9s1Q2gJHFOjWqNkjtcQh+1GYq0fwSxsEv7FhwG9sxFlKLCXEaHnVUkXiLa9Z akgCfm8jyfK2pRXmgbO4yVMWr6WDZFtUyzdIjqXH8k2SZzlmOUbyLT+y/Ig8a5mxzJCC/8etM/Nv Gr8EaWM8D+lDWE7E8iosr8Lyi1h+wWilaXw3ln2QlsR/G8tfwjKP5eew/DoeVQhpkd5aHbbWRfdi /SZjPk3jHfSpp3gVyqnGXJrG+yE9hHW+S4/9PZZ//yG204Pb3Vqv9L5VYMsdWF6H27Ec/3Wamr6N 27+MW96Bdj6iPfz9dPwG7G0FXpF27HNY503s7RewzXew/EUsc9jzV/DqWDyWll+I+xi3PI/lj7CF h3DvOtwuYMuv4PZ2LD+C5ZexThGevQnP8gie5WUsv4JlrX4p1ndCWozlYiyXGMswLcUWcAumL+L2 l3CUXop341nKsA4tvxg3iEeNYU0ftjyE5T1YPovlfiwfo32YX4P1K3D7FzDdDOnnMX0R5+tF46uY fhGPasPzcph+QBiDJ34rpBXxfZCG4+HshgCWn8A0DtOp+J2QRmhN5lFMd+JRJZgSmsa9izWH4r8F 6eH4v4H0abqFuULLzO9w7y6s/xbW34PlVZimYpu/wjorjT+DNNP4E0gdxkl6Flpm/iemP8XtTuM/ QWqlNRkzps14lAHLH9I0LhdrvoPbBVqfmccWfojlD3FvA+7NwPqv/l/Wzj1O52rt/+t7vKehCY1j cghTTY7jrJJyiBK2NKEIg10ONSgKSW057RIl7LbisbVTe1IklUO7g5BKxSSpUA2PCBXKae551ue9 7j9iP6/fbv9+v9d+vd6u+1rXutZa11rrWt/1ve9mU3cvPBHeZfWdI1keD++0chxtVTSk9wZEmyz3 hHbl+HVkY05Fa60mAx5IaSyDq/FTB2ZRdxicB2tGF1PaX1ES/VPI2+AeODe8VXOUuBD6YnwaFqKp A/vYtia4GcTy4bhY84hc0ZFaFalVkVoVsXmZ0pfRbEczGc1/aSV4ZSVb+qI8WBaiqYNczHqw69Mf iP146uagMcgm+hZKcwlchH4RY1mBvMLJ9HAFPVxBf1bENnsEHzOumqzAmtg3pVdF8JRj9LhWF6Xz 8TYfb/PxNh9v8xUluwJtHwLaDVyLmdTKZHTf4+17xnXCHneWURHcCF+Cpym1ey2ozDwex3IHPASP R1tYG79ozUhj99FG+BI8DbdolrHfg889TqNa3rn0qqFkc0o2dkVthC/B02Jos4HvubUn2cvA24Ho XVEacyrRG/tv1B96Ukcj8k/Thyw0WWiy6GEWPcxypfQ/KzxkR3qbW8nRUa1hWplH3Rb0fAisGY/G ZiN8CZ6m3aZa27IPIkfiuQfOxdtcIrZJO8tmpEWs6jdZq46sQOQVjniej5yJfSbznimNnZ3hRB5q dDaGwxkve1a0rRcRf2kKWD8tYSdyYOXoOcvv486WM9AfET1od8dzzPLz2q1otmPZh12QCZvgJ0cM ZiAviubQc1sraIr/x6jbBvtvkOvDN9x6JnO+RhbdxS5ISB+f1NqIlyhu0YWqGw5V9OJdkuMukoPX WfkdWM+fiYlQ441nh7vVW1bXJOI2Sv2x+7ELMW8AKxPzBrAykW8AKxP/BrAy+7EBrMxcNICyP0b/ Z+G5KmMfRm5ZATNd7oovI1M1saymnninJHtvM7OtE5cqg2EfIG+n1mSXo+j5ZPZvjsszKg0eYF8/ gM0iWBNexY4ucky8Ktq7ulpUaR9WTh8yw0Jp7Nkk/x0pbeKyBHW/T9zMCrG7wG8AW4VfkJ1kcyWa OuEu9uCvlm3YLz/H9uT135Xe7ohfyfx2R3h5yMuU4aO97Asj+6gHeeAwmsrknA3stXMSNh96/2S/ hMz+Sc2mzUiHWeeH2emH2bmHtU9TZA8iF4bsTfnxh0c/WZ4nWg9bqOXyjzLMIcYyQX0OukT/tOzq ch3n43DGNSBhn6D8B9yolXOs504au/zbzFNHJyCjuDqVD7fQH3GeY/wEPEr2WMjTgnLRKUq3pags cWP8J3JIU/as2DZxESf1LnLULiJpT2pvXbiTtn4if/6qyFD6KpYXIGeTORtEU6y8P7zO8sdwKHOn LNqUdpsiJ+ATjHcz9KNjdkRpUT7nu/w04SmlNrFqRytb4YfYf4CHD1zmpPVu8JjmwruEzNmHfP4e 8uMwL7JPmH5P/OcyazXwU4SGzO/tgOOwL9CovZPhKMY4zjI73KZ8gs2zjOiA+uk9g4eFGnvUVFGK ssRgrtakzUvWW3BYcjgGeYx6HvyBWa5Mpvo1lam0rs6Xt6C6emhPQ426HOP6OvzKyo3C9638Mppm 9OQneD992MG4WiH3oG77cLllu1An9WzJ9txRrL7CMisob+WDeDsFX0DfFg/Nw8mWP8HrI7vH/ZC+ XUiLr2G/NNyg9YbPk3Ay+mN4aIW3Lcj90a+PdtJnrfyH9bRmn8rGWM5RJrf6dtb/zXFjaz8i1J4a ItrnQ9VqT3z+Hr3PvhvHChTf09O7Xyu+GV4Os2E67AVnWbpn3e5YNoHd47rKeJK9T1PMhumwF5TN YOxn4G0Gmi5o+kXKsWnUTVPrltkwHfaCsm+OZV8s1zryLJeHnzx6Phx5eErOhumwF8wlz/S1UbqK Z+8kPpN4e835DF/QCsdPLn5y8ZOLn1z85BKNXHkL2ssy6Ap70fO9+NmLvAF5A/2vFW8lGo5upFvp FYxK43MrdS+H0o+L7I3Pz4Dl7Z1e+bAtWc5mCb8r+r+I3gbkO6J27G6xAM02LMsz0qrhy5YTJPu+ GHREzoPDVSsoK9rTR3XLUWst/n9Ak6+d6OdGLVjDiuFMRSxuo5HG68TwadUKf9UTcnRAcjyJp47m xHAssfWxb0Pd7ezfZtx9uuk+a2OVR5TyiFIeUcpjpvKIkuT36E9/7APkWsR5uGijx+qNumqV6uZu R6Gz4C/hW1ZTNbVu3cpMZzW6NZnN6krXfY05rY0+D59J+FqKOuleS4zGXjZVNGt2PdRldI5uPdTF JpvSWWhm0dt7bI6dFNj9mOwSHBGjmsYr/ljvPYo/jh609n/VDT3YFPWz8WypDB8Okhwsg0+gXxKN tFwgSw97e/pbhtWpe70YD8Xybb2dCDfo3UWwGw836X1IWIbSV6j1rJi4AH0FPJyGBdj342Y6QfMe vKrsHexEvhY2FsMaus+GF3EuT8X+n8zsF2K0GJvGksMqsgymkVUOIg+h9FJKK4lxOzy4G3QB7Ehb VykHBgv0xiPooHM2+I6ngqncC9bpuT1YrxuxfXayNt4MxdNbRFTHo3lYTwjRIfy8CQvhZ/AL/BTB zXBMWIK+v55mxeht5AnwDe7Lv3A7fkVPfeFVPPutTsm+qCc3y0I0dSi1J0vcnPgPx7I0bBnfZ/kW Hh6BBx3lwbIQjTwsw/Kv1DotTXgaDU+e0ZOcj0/yRLoOjoM7eML8lCfJdTzHLuAGndRTpV1LekLe S4s94KvKtFFlfFZW3Wgs8lgny49lIRrrJ/qTbsoJn3EFUQXLG/Czn35er/0evoiHjBTlJwM/GcTn RcbyouITtZScuCf+C7xXawM/9zkS1XPwX6CxB6N5xvvcUc9vlhvhS/A0NjaPxW2Z64ew7BDZG0c0 N65uvV2pm2awUvqwoqM8WL4ET8MuGh2l3KCD9dIEi6i7T7vS+4rn5PvhHPgOz5MTuZNO4U76IM9L M3g24J7uHdIToL8Qz5WQP9GtOWgdJbV30DeWn/Bb9T/k2Tsc5Ih+EL0dRG8H0dsZ6lU4Snfn+CNq GZ4YqzJ27t3BjfB1nhNeYURzuEHP4knsQ/zXc6SVerRSj1bqYf+hohpOUVtxk2g83MibDdUq74im K9H4hYgdj3axF1qxqh21Puvr7mzXm9XE+RFrA/kORnQfe+o+7D+PvmdGHBXharpHh6E00YBwDT2U PBG5PP0vj6Ycq3Ee7BllWm9FugtHV8czrGar9NF8StuLwWrkI7IJy3J3XodNoeyjdPZOddiLu/CL 3IJ/FKPKek6LxqpW3JpW2uDzfc7Hr/G8DG8PwQzduMOVlD7LbsqE56v0HN4UpfXm5lWiLB3lKb8l 3iaHd5Dsf8ndvDl76jT7ZYHbxWhiPJySz7Te4TO2VllOgRPqoY28ZqdY92ibryozLw2g7tfPcL/+ h2Rr2QBWZqc3gJWZrwZQdZ+NlQd20wfeVIQ94qo648hXG+B95JDauomH3+j2HS4X7Tmo1bUpfpZ1 rj2+Dvk0o1hA3d3kxlelibcoV8RD0b8NB5IfdlP3Jngw0QhO1gkoTZTQikpcgH0F+Cw+yajBEt21 w2t17wj7w0xO5JujBayuo8jWPu6Jvj/3r9Xc+PLYa9/FlTn7rD7iJmv3oO5H7/FMdViW4YPkgUl6 2k88xX48rnmMOzObT0oTt40Un6q61doVrpzGuz5/gZh4SmdQsEW7LxitW7alRrESeSW7e6pkW9dR pfUorc7OcvJ96kPYWK3Ys9XeyMIruJd9zvucQtHuoJc4SY9yhurGNEZjiTbrhI17kF1/4klgEbeY 27m1ndA9PeTdY7BQN3R/ijJ8PER9jg6RE94ku/YnAp9J9ovgZkpvjM+D+WpRq8jORZFOZEonwEPk mTeoxVvQoKLu7DYjLaPny5TlYrvmw3OZi3pwALM2PlS+fQ+WMPY9zE41bLjdB7PgNPgH9Lnc4Ao1 0rATmlrITcOP8a97H3HzviQapYnGhdzEJ+kWH44Lf7A9HESt6/V8Fe1jtawLbyEXabyrqbuautez WqoS+QNwKv1ZxdxdwP3xUWb8DU6ZJcx1azQv6R4RchsN38S+A95eEaOtyCvI7THyBO7UzkMr+JDu +OHX7OXz9dQadlM/oyiar4xBP59itaziWfGBYL3VFymS8WdapfYkEieL4Xeh5uVZ8vw4ydH3kc76 VzmtdmFzO5nwJHlyAKXlxOAvOiWj6ephfAMR+JrebtetPyylW38wihv0QXrVhVFXZ1zt1avoAyJw M/rlGkXwTmhvDeHT+sYtnB98QR+sHH+O/23YD2KWB+k9gF3navFT9LWQ/5qykc9H9B4gNmK4UG8D wu7Sx2Powyzsq+ptgP8j/vvC7ui/wUM3ydETyHVcK7ydq8eu5HyMvyRWqyBPwsELcDx0+7E8z7Fr iWcQfmnlbJ1KwTqiN5f3n+VopTNsQ8Q2kRmKyWbHic80eC1rrD53pVWwWUq+HGbDdNiLUnv3iR7l Gf4HLP8MX42WWP+tkOvBGSlmw3QoD9diWY2b5gPShA+gqYDmEDfc6dwxF8Je8BPu8vTHf44b3+O8 Wziq25nda7aW/3csj9Lu/XriDRfhc5Hqhg8j703xcpgN06F68pPeCdibb18byXqM8TV9ox38Nz6z YT/4tm6+4SV4m5bi5TAbplPaC9qIhR/Lc/yWvvWz/Lv18C61aqeoKC3Hc0dFw8a5KxETH2Ps1fQ+ wY7CaqKv9bbBtiL5K+TatF5bmnApfbtCDI6E9n4djAj/qX0RPUJmU+lxSo/BIWju1806WAqHShO1 w/5eYlsdHhVtZnhZpzPyIrhXtaJiMdyGzzzpgyl4rgF/ID9MC1dY9qa0KRFeCGfJJi1LEUgjDtFj 3DePcHpuk5y4izN0KaWPEuEHiN6V8GHW2Bw8ZMln2nI9EcWPcxtdHa62pfem1ra9RwcvpdZnHnco rZwpkq2fPGY8jwhLbqq3E+EYWnlGfuxzY32tBNZtFVib/iygrYFRWcscMehCPCcwpzvhUOwfwP4i 5DHM/k3SxLW1QqLF6BvDSvRzmmT/IB7+HN8Kf9bcYXO/Zj9uR+laNFfgswDNH+j5GGL+tvTxW/G5 9PlcoqFfXzQusaeACUreR35Rvx+AOSXPIV8Kp+rXCKnS5yG/JSgZi+xYCc5C7+ouRV6KtwL4NZqv kbdjY/X+sBK982wNH4ajYUUYwO1wsuiVFU0STQ40YvAA8iK4AtZ0clLvq4uoewrNfNiHWguRm8BM bL5HrgWrwu7oP4Ub0AyGXdCk0Z+DaHw0a/FcG00eHI7e9Xk4/XkNORdWwb49NnvhCfSdkY8jx8h1 4Z6k8mEd2mVEXoY03gH8XI19FqyDfh42rifOfhuci2ZYsrnWqou/ZL8i3A7/y8UceaCLObKBi+CK pPbyxy7m0niz4SlK5+N/hRsXcmXk5ZQGsKEbC7LnxoKH81KjkP4bN67kR9bDbXgYjL6FGx32Ocka VjMgmcsocul5Lj3MpSdiJvoTyDVF224unnNpS2xJW52I5wX4PwKr0IpbJ6yZYAa8lHE1pdZjsE3S Pp94rs/14RuwDEyIiUpiPFsMP4ItNfb4b+jTJAevp9Zwc1bmIH0D61ZmUt9bHUOelaxt5V+SzZjN vczjXuIvjnOzXLxDu4zRtU6O0C5DHu3k4k3IpYibOJnSyckbYSkiKX039DnUMsgmJZfSHkSzKMUR ULVuRHOjNF4R8T+V4ghYitnpACX3UWmwEJvvU5S3BkT+KCO60u2dpN6AtUH/c2q12Mj477pVUXzK ymNYUcukiU5is0qaqBL7qFMxv1sgwnOTZfS0n2yhfVqsZ3VWoPe0YuutRDNBtJ51eyIDBF3xf5xo z8NyLiuzFj5PFOsbgfpJnTWdGUVMNGInE/kqjPpcGMA6yU6wFOtTmnOIwwHVMsQtuDq1YhXD2+A8 bB6EeWjGpLwpthcgu8jPTVE265L2TPEzGOmrxMet+Wz6v5+Y/JiKbUsrs84t9Radlew9ATdDn7G/ oxjaHraE0pAPg3b42Qo/xBv53/tCNuYQK7lWspZlN/Tz0L8njdmH/jxYmll4MrX3NV898VnDZUi4 A+5PnmakLaC+r+EE8d6GBejdqnB5sjueD9CTZ9A31BoLWT9hkeyjrBIbk8Dlz0/Vn+CwYhiOQR7D SP9Aqct1v7o8oPFaqrfnY1MdfTlsvkZuhPxyKh/a3nrN0PwEXQ5hXH4r2ANydvgutuQT7yvIqeS9 gL4tbA7x5l+ftE9KPvkkuBDLpZBz1t8C+8Op6Gdi6fqwGs0seBq+nzqbNDtzXJ8lhy8ij6fWCDjE nW6sipg1VhfG1C1C3kZpU+RlqTUgGfruFK6B5lM0rWE/2kpDvwOuRc/pYE/eT2z/yepektJx6HNT uzUXb7l4yCVv5FIqzV5kd2qXh+554w68fQDdmTgSmScHbxUR64jl15wRZd2M63TwqyHnY7kL7ibz 3w555gmHQs7WiMjHPCkFbh6HM4oNJYPZ3e0VHzdrTp8al06E7mSntfAqbGoV7+McyYUjyOqSO5Dt 98BPyRhd0HdJXgVLEZ9SxF/6bHLIWqK0NiXrLGhAaV6KI+htKXaTbF5LxbYDlL4frELm74q3DSmq bls4jG9GjvANyF95W/vXhE78hsgN4wO2biPki3kGfo7fDnXmm8pWUYnGxfucPZL9L5D/yZ3d/boj yW8wavH96QZunT35jrVnfJNyAvoDkn0nH4naK6fx3Wtl3Q5Mjt/KytMjvblqEt6hO374N8tNkv1P Qv2eZLkY/BzqPlgoS7NX9G6nVkcxelMMY1g/1FvBjnjrjp8lvBtpjZ/Tsol7ULe7a1f0d8B2YRXL 48E4aJ+6g8HIo9H3FIP8YKf0ks0W0atL6Q4xysRmEiwIHrX08dAu9BiL9GMh3qI5rkW4E06EywO9 Tc0W/dnINaLeVi6S7B3VL4ptD+2NICgtjdkY2Juj+Ur010hvNso+6kDdCs6D9H5asFp7KlipbB8s Qq9ah1QapWOzBB5CnyVavTw0EaOF9Oo4bAUnyo/fM9Vna++FYrhdDLrDAnoY+J6otzrGR/Z9Xxrv TUq5Z3nf8qvpH7SG/enKV/4UjcvXd8rPSPaO+Pqd3jZf75Yf8SdYTvZtfvbKyt6bA5+CgRg8gIdF /jTLFb5WeM1Avz5qE0xTFpXGO4XNfFrsQ62FyE1gpp9mbb7Hppav1V7VP18z6+vbxo6SvQ2wQP8f jn4XPx1WUAaAI+FMmCEGtfGQJ9kf7lfTnvLtWvXvkuyX87/W3ke/FstcLKtQt72nJzEfb3u9f+jZ ycuymjrefisXenZ3+2U9/fIwkOzV9RvSQzsWczLM1ImpUi+C0/1m0vivW8/XU7cOzErJOywTojmG t3mwIf7reN8RQxsf/5Q3XvOCZg+e52KTEM0h1TK/qif+F8bw3zg0EuM+on4/bzUvI7+PfAz5DuQn 7Yr6Il5sOR5eIUalxOC/YQGayrC06F8E/459P2wGiHESm/bwDkqvQb4f+UEsN8Jf0LdEv1pMtEG+ HV6CzVbka2ELNB8gz0J+DPZEM5/+lIGu3Qj5NL3qiGYD3EGtYuSdsA6au+A4NIw3bErd6cghpR/B I2iuR+6FnKCtqaL3K7KL3ud4eAibG9BvR98IeT3y+8SBaAQvwk2wPrW+SAzT9w5uXiRHpeCFbnaQ K8PSsK2bHcnh+26OJAcD4Ag4Gm8T3ExRq6abL+SRbqaw3Ah/Qd9STLTB8yXot9K3xtgzlvBRFxls +iMHLibS+KPoT1V67kpPwt5E6U3kfGzKwn3U2oa9m8dqsCK9Za4johS5NeB6/gR0vfqSnrs1/BOW o+jbKvwPhm69DWQF0rd4CJa0FXwM38HmVjgIzQHkDDFtp3ymsZLjS6k7HG/YJLqhb0JPLnX7hegd oNZ72GSi30vdWsh4C35A7oD8MHI6sltR4/FTwCwkGdc1cDW8HT6O5W3UWonMConvZOxuPxbR7hTk VugPYkk0Evch+9TKRb7brW1af97FGVan7mJk5ssnevHTcAEalytmuf2Ch0bM8npYlj53xiYPsqei 2sjMS9gVNsfDTch94XXYFMLdlA6FTn8xJIf47OXwH7AT/t+Gz8F52JAP/YXU2s8aPoSGufAZS7gM smfDq7FcAT+DS/FWD/kYNj1gHzTk2Bj7mFyUuAV78moYI9NKTF4Nj0L2SHAYmRFFY9CQP0MsAyLs swKDb5HZZdGr2CyBLqdNQ+8y7RuQeQxcVCdDsmL0HfJceA69uhxLVlHAvgjoYcDpEN5DLbcSdqEn DgkyQNQd/Rr07MHgSsjej1+iz8MgKydkFCEzGxJV343CzS+nQ0ymDd18UTckMwSurdfhFuhWkcsw LhO68+jP9I0zJXTnGqsiOBe5PGSnxC4zX8vqfYx1W4Z1u4M9jp+QXRkR5+AjSsnw4WXQ5QHmN2I9 B3Poz734nwlZCcFY6E7nb5BPQDynkV3T6HP0CrXYcQmX015Az+zElIbvUpfcGNylXhlT0gpWgi/q xEnq273x8AoxKiUG/w0L0FSGpUX/Ivh37PthM0CMk9i0h3dQeg3y/cgPYrkR/oK+JfrVYqIN8u3w Emy2Il8LW6D5AHkW8mOwJ5r59KcMdO1GyKfpVUc0G+AOahUj74R10NwFx6FhvGFT6k5HDin9CB5B cz1yL+QEbU0VvV+RXfQ+x8ND2NyAfjv6Rsjrkd8nDkQjeBFugvWp24TSC2Fb/GAfjICj0UygtCYc Sa3G6PEfPgr7w4B2R8GqeHD6k7A3dd9EzsemLNwHt2Hv4lkNVqRFYh7R28jNBX0In4CuJ19S6tbS T8j0IVyF58HQzftAVgJ9i4dgSVvBx/AdbG6Fg9AcQM4Q05jNNFZUfCl1h+MNm0Q3NOjT3kOTSd29 6GshUzf4AbkD8sPI6chuHh+Ht6FZicy8xHcyCrfCi/A5BbkV+oNYMq7Efcg+tXKR78byeeTq2C9G Jto+Y4+fhgvQuB3HLgg7I+dBVmBUG5nohV1hc2rdhNwXXodNIdxN6VDo9BdDdpzPyg//ATvh/234 HJyHDdnDX0it/aJ3CA0x9OlzuAyywsOrsVwBP4NL8VYP+Rg2PWAfNGSkGPuYnZu4BXuyUBgj00pM FgqPQlZycBiZEUVj0JBtQiwDIumzToJvkdkL0avYLIEuA0xD7/LSG5BVHbioTobkkOg75LnwHHp1 OZaskIDVG9DDgFwa3kMtN+O70BOHBHsk6o5+DXp2SnAlZIfGL9HnYZAVEjKKkJkNiarvRuHml1wa k5dCN1/UDdm/gWvrdbgFulXk8oDLNi57/5m+kYFDdwqwKoJzkctDdkHsMoOzd5Ek14WXQfZjyNxF rNVgDm3dS92ZkFkOxkJ3Tn2DfALiM43MlkZ/oleoxa5JuKzyAnoiH1MavktdspP5OAiM3onptyu1 o3Texui/7+7IG6HBgb71XsR7pE6UPhNFRm+QMi3n8SbNl8b/Hv0M6cNYlvYQivTmBP2tYrRFDOuj P4qHfEr3ifFI5MGwIz4POUtan67/Fj4orTdm/jNoHk6979Lbv2O8PbuON2kn3RszNItVy/8EjY/9 IbiEMZYW/YmMtAfvxNbztqoJcpPgNdWSjSmR3js/9ZbM0nzDO7Ec/HSnVjveXLWSxjs/nG/0rqxA u4bSZ2BPMZlfov8yt1uJfim0pkRvJnvqDYb/iWSvLnJvStshr0XejuV4yV4SD1mUvkutbcjlnDc0 3yYXoVHdhnAA+qQsvZNo/oJ9beo+S2kz5GxKY+Q/Ik/BshWtf4HlfkrvlZzsrv6End0ojH7velxy cB5tXYScb3iziiZEswn7HWIcGq0NehJkY1MJ2Yc7sUxDLo3cRbRrSPISWlyOPBt5CZYV4CLeDu1F HozNaOr2VovBylSfVTqWdj+kn9uRj6Za1GpsiHwr9gOSq/XmTXqzJam3uB3xOYfSidQ9R/G3GY/3 omhmMiPD8N85+Rx9kH1/yf569TyoK9mu6eY6DanVXhpb92lb+nRypY0VK8R7Pam3o0tVanPXc4xX I8rGw7cmnXf4K8mB+u80L3Kt6FcQtrfq+QvoKxH58ozxE/mM7sV/RvJJa7MCm5lJrfwL8JlB6Tuw kXrlPeWip9F5k2GO7P2s5Fu0u0mzI9lfg5wF02BD0ba1Bvkt2lqgdUiLk0ym9o7a9deY8/Rmkogd osXu6IvgemZ5IbUK6Ntu2IbVxVqKBqJJyj7YWaJvE6qW/GB5BJ/DXCtuvthfx1O7TJGZjpwQ9be/ bHZlFYVT4TVaA3EzlUafqw9Rt5KTzMUyWMBOVN0LXE8k28goVsdKvufpaDY7lHaJVVXNnTeZvrVD M1pz508nbkuQWyVbKz7JwdgMpnQSo5gk/8WH0ezjezd5KA3bSeNfqm92whZE+BCa9cmxWr0ai7ef udiNfRqsk9RfIYj4Pmi++hZkJv9GW/nsiEJ9R0BvDT28MKlvhQaX6JcAaYzxZUZ9jtaVdx1rdbAi EL7s5kute6+71SXLmDVmR/cWJ7tiWJs8863LG9qDdnSK4VGVxkvVileIz870qifxLEfdhuyFctLb WxvfOIhRunoYdGVv9tR8mZOKgI1JAbNwA5YaUZfk5/AbWsxmJcvPuORj1FXMRyomli9Sdyd197HC tc6rKCZepSTf41B6S/IYsr6LCYn5O9gsxX6xIzF5it8vzaX0STy0ZETTaKtl6jceb/FkJT/L3e+d 8J9Hn9OI+c3MyBLRm0l8PjTdbUzKkB8aopkomo2Kho3YDPLYk9pr5Jw28mPn6BR9izh9xA+xP6RI RgthDnNXhezUT/Y22loJMa3sIOazyW+h1r/NaWQz5rcn2WayNIbfkpmv4ApitZRdmcU6nIH9GleL VgbSn/2Mt3UqA19BbNXKWtbMTDcK/KRJb0+oiF+qaBd3ULvx4/oLTnaF67+ze8+01h2QVorY3fms tNr4L1C7doWfYn2eR9bK5KzJ5FTiZGH9Z7BOQrJQX+x/IZvNoCc7TA557xH6LHmePZHsOicalVir vvwHtxL/1112SmXFDpzCzclgLTiv5X8+lkeJxlA8TEqNwsqxy+cz3V5LnW76bwwn+h8g60TYSKya MdLC5Mdk6U3svtXEQf9law8x+pHfpK3Ew2xW+DA0rYnhVHmze3kZcdNc74MzWFfj0Zdh301kVYyV bH7lRNuMZjz2hakdXcCZ5XJ+jrIK66G0Ym6+Ylx93exzXi92peTVbeyOSmTRiXAYmiTnYwWeIlpx pryJhpwfvcAKySGSY/k2fzRruConAk9rCZ5n7AnOcwVtVVKsgsLUai8ke6wkBxpG4TJ5IXlA7IvN W8mnjL6jz6dXyjM34qELNktYw7ejycL+wxTzmZd8VnshI81ndCs5hRfRZ6tJnij5lpXQnfHeaS2f dycmtUamnsrck5vW4XvUnWiqWfktxriK/u8Sk43kreQX/S0sywHWZgTv9/bxRo63oGl892TSZWM5 gG/rpDF4uCXSb1N7x8f0d9KQ05EbITdCbhLvQLMQTSHyFP2uNS5ALkQupvRcyYmm+gtpaJrY2ZOH z7AJ+dton4vxcfUhIT+ZcXsxMUd/IU3/NV9yQWKJ/kKa5OK1kpMPxU/pL6QlDuub5URFeJy/hLZH /p2sv25h5RPo+etnieeRr0G+XX8nLdqgv5PmxhgXyT6tnOREOpan6W1j/PTHpgqlHRlXC3iCUc+g dA3ycfRZaDZD/bfSOWk18XkFrQ/hO/FCZB+bP+F5GVEqpEWf1qchv0bdVvo1sqP6b2O4W/q0DORW eHD6HPrQD7kl8h/x8A3259EfSH9yXH/i2fTnHf1lM0bdPDXqxnjuj80t2E9DbgET1LoKmb9BlxiK zHgTXRmFWmli6Al/da1xHFHaEzmklYPEZAqaxpTa2Uk2gI0TAXwEmz1wK5Yl6BvR51X0mbnj14NB 8SHk5jBXrRSvVx+KP0beJSYHwN5o9smyeIUinNLfA0vB8vgpjzwONqfWKmp9h7wBPfEpXkBbb6D/ QHLSxwMznurDz9jspFZN9y26Sfempu03Qd59I4eZzD+OHDTUTBjW/+47zXKdQDd2v6aGsXmxpMSU N6VNbKqaWqacqW+a2vi2MdeZm00f6+MPZpx50OSZO8xd5h4zJWV/rkmYC01tc75pYJpZL1eb601P 09e22t2MNw+ZgWaIyTejzVT+/2tdnQyTZjNOHZvRG9pz7XJzjelsepnbjG9uNPebP5lBZqgZYcaY aaaCCTp169bRXNe96w01zIAe3a+vYebhpSJ/j7q6zelZ1mMj+yTQ1lxrbjC9TT8T2BO+h5lgJpnB ZpgZae4106lzjqlhLrY+c8yVpp3pYi4zf0ZfyZSxcahpqphLrN/GpoV9KmhvOpqu5hbT3/a7rrnJ PGAeNn80w80oc589x10PyppS5iJzgbnUemhirrIndSfTzdxqBtizpJ7JNRPNZHO7zcJ3m7H6O9l5 OaPyglzYFw6Gd8LRcEJe/2F3B5PhTPgUXAyXwtfz+o8aFLwDN8LNsBDugLvz8obnB3vhUTH0YRlY DdaFrQYOu+OPYQfYGXYfeOddw8OesC8cCIfAfDgajh88sn9e+BB8BM6BC+ELcAV80zruH26Em2Eh 3DHsznuGh7vhXvgD/Bkeh0kxCofdlTcsSodlYCVYzRaOjGrDbNgQNoNXwGtgx7vkpwvsAXvDfnAw HAZH3jVy4J3RvXACnJQv/XQ4E86B8+EiuAQuHWXnKFoBV8F34Ea4GW4bdcedg6Ov4LdwHzwEj8KT o4bn5ccGpsNMWA1eAnNGjWrYKL4CtoOdYQ94KxxomRMPg3fD8XASfATOtmwcz4eLYQFcAdfAdZZN 4g/hFrgd7oRFcP+oewaMin+Ev8DTYsKHaTBj1D35oxKZsAqsAbNgXZhzt41kogVsDdvB62A3mAv1 5sa3uSfzP/g3sPv8AlP1/0ry+CPb/2dGRu+9YpsX0/6/fQr55GTPVP8Xnvs7Gdg8V4q/5///Ink2 e//vLPe76TMjvvWqT17qnBLTfzfL/m5e+C8s87tZg54G/Ov9hhrBb3UZ/5aBPakqmEr/oVQRybfn 00X/0b+1+PPPv//fOibrP/jXsyfpv+e/j4lnT/B/z/N+FxvZp4277ak/2yw2K8w6U2iKzFEv9DK9 2l4Tr53Xwxvo3e1N8mZ7i70V3jqv0CvyjvqhX83v7I/1p/tP+S/4q/xN/g5/v38ySA+qBNlBq+C6 oHcwJBgbTA+eCl6we1Btpbk1G3Q56/OAsz4/ctbnGb/5HJ5VHtttvt0kvN98Tm9y5ufSi86sn/HL mf4ze5/5ubw503/5zLM+Z51l3/Gsz7ee9fms8ZTfcebnCpec9bnbWZ/vPbP/VReeWX7hmjM/16l7 1uf6v/ls91+dhmeVP8Rn3+aHcm6EF3dz/17iRh7aNVfB5qqslPaT1L87Uv8Wpf798X+zzl6e+ndN 6t/1qX+3nNmLyzLOHOVlq8783OChM+0bfHXm50Yfnvk5Z+VZn18/83PjHmd9zj3rc/5Zn0ee9XnO b1aZFZrNO+vzqjPtm501S/9Svvmsz5+c9XnLmbPYcrNlho1MnvekGezNJ9sOsP8zdqfO1i8yorKc FeVMXLpTxvrSHTPWZbyV8Y7VxN5B76C1+9H70Xjez97PxveOecdMkHF1xtUmzGib0daem1oPftA+ 6Kj2/HJ+eauxbQcZ6s//sPcVYFYcS9vV3TOnz5mZU7ssCyzLQnCXXYJDILgGJ0gCwRYLFlggcPFA kIRAcHeHkOBE8GABgru7u/tXUwwEbsh/81/7/ud/Qj909ZmZM9v1dnXVWz1zZlSQvpmVPiekbKQN jIX1cBweinDqg596Fe5UAumUcipTXdqpQnUZ6n0o+eTklC1EU85TAM+DkqHUpwss1yNlWjIBfb7E cj3uBUmf9lO9Hg9SvREMttBISInHqa+raO8JluvxJMk19PkUy/WvHHnaO/KMd+RZ78hz3pEv+luW +1uO+/se9/fFnvK8pwLvqfjqHvyFe7iFe/gr9/DFnu28Zyfv2c17JGhJhaaZLd1fmYTKUEI1AaGq nBJOSUJ9Fa4CH/VpDSFFWbZ0r0k/j/o0tej79Xi8gEdKiIfiIY3aM/GM0DIl8R4+r8nn9fF5tYyU keCXKWVKCMj0Mj1YqrQqDbZZ36wPjtnQbAhBs5HZCNBsYjaBELON2QZCzTgzDuKZ7c32EIbJMTnE x5SYknRKjakhAabFtJAQ0yPlfJgRM0IEZsbMkBizYlaIxGiM5nc+vA1RmBNzQlLMjbkhGebFvPAW 5sf8kBzfwXcgBRbCQjQ6rr2lYntLjSWxJKTB2lgb0mIDbADpMBZjIT02xsaQAZtjc8iILbElOYrW 2BoyYxzGQRZsj+0hK36Kn0I27IpdIRq7Y3eIwV7YC7JjH+wDb2M/7Ac58Ev8EnLiV/gV5MKv8WvI jUNwCOTBYTgM8uIIHAH5cBSOgvw4BseQfY7DcfAOTsAJUBAn4SQohFNwCryL03AaFMYZOAOK4Cyc BUVxDs6BYvgNfgPF8Tv8DkrgAlwAJXERLoJSuASXQGlchsugDP6AP0BZXI7LoRyP93s83uXJVn6G CmQr66EibiRrqYS/kHVVxi1kXVXwV7KuqridrKoa7iSreh93k1VVx700R2rgfpojNfEgzZFaeBSP wgf8voUP8Rpeg9p4A29AHbyFt+AjvIN3KM+X0JPmR0+ypBARAt1EpEgK3fmt271ELfEh9BbNRQvo y2/a7i8+EXHwhegv+sNAMVKMgkHihrgBg8VdcReGiEfiEQx1nQwMkz7pg+HSkQ6MkPFkPBgpE8qE MEomkUlgtEwlU8EYmUFmgLEyWlaEcTJOtoMVsoPsAKuIR3SC1bKL7AprZC/ZC36WfWQfWCeHyqGw Xo6QI2CDnCr3wUYVJP/zWOVQOeCpKqKKwTPXpoVU49Q4oYw4Y5IwzAZmA5HdjDVjxdtmY7OxyGE2 NZuKnGZbs63IZbYz24ncZgezg8hj7vL1FXmtKlY9cc3qYwvx1Al1isuOzgfOePltsGGwmbwV7Bb8 Uj5EiX7lxxSYQoVgKkylQjENplHxMB2mU2GYATOo+JgJM6lwzIJZVALMhtlUQozBGJUIc2AOFYG5 MJdKjHkwj4rEfJhPJcECWEBFYUEsqJLiu/iuSoZFsIh6C4thMZUcS2EplQLrYB2VEhtiQ5UKG2Ej lRqbYBOVBltgC5UWW2ErlQ4/wU9UemyH7VQG7IAdVEbsiB1VJuyG3VRm7IE9VBbsjb1VVuyLfVU2 7I/9VTQOwAEqBgfiQJUdB+Ng9TYOxaEqBw7H4SonjsSRKheOxtEqN47FsSoPjsfxKi9OxIkqH07G ySo/TsWpqgBOx+nqHZyJM1VBnI2zVSGci3PVuzgP56nCOB/nqyK4EBeqorgYF6tiuBSXquL4PX6v SuCP+KMqiStwhSqFq3G1Ko1rca0qg+twnSqLG3CDKoebcJN6DzfjZlUet+JWVQG34TZVEXfgDlUJ d+EuVRn34B5VBffhPlUVD+ABVQ0P4SH1Ph7DY6o6XsErqgZex+uqJt7Em6oW3sbb6gO8i/fUh14u 5TKfHOxrM5A5m6K2qE2bY0UsCGOpsRSk74nvCSh/QX9Bmj1/eeO/vPG/xxv/Zn2RbH0ZXbYlmvoO /WVjf9nYv8nGhNmM+HyoSClzqBJGDYiCfFAEykBlqEX5QjPi752ID/SHwTAaJsNsWAA/wBr4BXbC QTgJF+EmMXsQPuEEPgUVaBuIC3Rk2S7QiWX7wN9Ydgh0IRlHra4s4wLdWLYLdGfZPtCDZYfAZyTb 0XG9WMYFerNsF/icZftAH5YdAv1Itqfj+rOMC3zBsl3gS5btAwNYdggMJNmBjhvEMi7wNct2gcEs 2weGsOwQ6AyS9vakul2gL9XtA19R3eFfQGQYa942MNxDZoSHzEgPmVEeMqM9ZMZ4iIz1EBnnITLB Q2Sih8gkD5HJHiJTPESmeYhM9xCZ4SEy00NklofIHA+RuR4i33iIzPMQ+dZDZCjp3zYwnhGZyojM /hcRme8hssBDZKGHyCIPkcUeIks9RJZ5tvK9h8wPHjI/esj85CGz3ENmhYfISg+R1R4iazxE1nqI /Owhss5DZIOHyEYPkU0eIr94iGz2EPmOEVnClrKKEVn/LyKy1UPkVw+RbR4i2z1EdniI7PIQ2e0h ssdDZK+HyD4PkQMeIgc9RA55tnLYQ+aIh8xRD5ljHjLHPWROeIic8hA57SFyxkPkrIfIOQ+RLYzI TkZkP1vKyX8RkQseIhc9RC55iFz2ELniIXLNQ+S6h8gND5GbHiK3PETueIjc9RC55yFy30PkgYfI Iw+Rxx4iTzxEnnq28uw5MhY8R8YSz5Gx5HNkLOUhc54RucqI3GZEHrqW4r4D2O03r6bVgAxip5yg yqkKqpFqrJqpj1Vb1U51UB1VF9VX9VP91RfqSzWAcpeT6pQ6rc6os+qcOq8uqIvqkrqsrqir6pq6 rm6om+qWuq3uBHO57+gT28V2+gPj3d/mq7KqLEhVXpUHpRqqWDBUE9UUfKqNagN+FafiIKDaq/bE BD5Vn4KtOqvO4Kiu6jMIqjFqDMRXP6itEB7MGczJqwyRYBnJjLeM5EYKI6WRykhtpDHSGulczahH d3h1XUDEK2sTmXg9qLl7BH0znXdE1CtHZH5lHyGpmtPRYIQb7hN90xvpwfb+briRwEhoJDIijMRG pJHEiKIjfvu7ElJDiBFmxDdMw2dow28EDMuwDccIGmiEGKGGu95lkG7dqAvud6TxjlEQHKOwURiQ 9uWCCDVdzVRz1bfqZ7VOrVcb1Ea1Sf2iNqstauubEHdXy9Q0NY3OOEO591vNUXMI73mK/Cght5b+ 3kl16eXZp9FRc2jvD+pH9ZNarlaolWqVWq3WqLVvGmM++3Q1nc4+U7lPC5mr5tLZv1XknamHW+ns rh7u2bNC+BvP+gY9GLOTHmbu9/6kdfH3XGug75kt5SL4DHpBb/gc+kBf6Efz+gv4kt9cPRAGwdc0 y4fAUBgGw2EEjIRRNOfHwFgYB+NhAkyESeQBpsBUmAbTYQbMhFnkD+bAXPgG5sG38B3MJ++wEBbB YlgCS2EZfE++4kf4CZbDClgJq2A1eY618DOsg/WwATbCJvIjm2ELbIVfYRtshx3kVXbBbtgDe2Ef 7IcD5GMOwWE4AkfhGByHE+RxTsFpOANn4Rychwvkfy7BZbgCV+EaXIcb5I1uwW24A3fhHtyHB/AQ HsFjeAJP4RkZtJCVZGVZRVaV1eT7srqsIWvKWvID+aGsLevIj2RdWU/Wlw1kQxkrG8nGsolsKpvJ j2Vz2UK2lK1ka/mJnCj3ywPyoDwkD8sj8qg8Jo/LE/KkPCVPyzPyrDwnz8sL8qK8JC8rS16RV5Ut r8nr8oa8KW/J2/KOvCvvyfvygXwoH8nH8ol8Kp+RC3J/i6GUoUzlU1r5VUBVUpVVFVVVfahqq7qq nmqhPlG9VG/1ueqjhqhRaqz6Ts1XC9UitUx9r35V29R2tUPtVLvUbrVH7VX71H51QB1Uh9RhdUQd VcfUcXXCyG8UcN8Jbuw29hh7jX3GfuOAcdA4ZBw2jhhHjWPGceOEcdI4ZZw2zhhnjXPGeeOCcdG4 ZFw2rhhXjWvGdeOGcdO4Zdw27hh3jXvGfeOB8dB4ZDw2nhhPjWdm0AzThXURXVQX08V1CV1Sl9Kl dRldVpfT7+nyuoKuqCvpyrqKrqqr6fd1dV1D19S19Af6Q11b19Ef6bq6nq6vG1CJpdKYSlPdTH+s m+sWuqVupVvrT3Qb3VbH6Xa6ve6gP9UddScqnXUX3VV30911D91Tf6Z76d76c91H99X9dH/9hf5S D9Bf6YF6kP5aD9ZD9FA9TA/XI/RIPUqP1mP0WD1Oj9cT9EQ9SU/WU/RUPUfP1d/oefpb/Z2erxfo hXqRXqyXuO8V19/rH/SP+ie9XK/QK/UqvVqv0Wv1z3qdXq836I16k/5Fb9Zb9Fb9q96mt+sdeqfe pXfrPXqv3qf36wP6oD6kD+sj+qg+po/rE/qkPqVP6zP6rD6nz+sL+qK+pC/rK/qqvqav6xv6pr6v H+iH+pF+rJ/op/qZH/xCT9PT9Qw9U8/Ss/UtfVvf0Xf1PetTq6PVyfqb1dnqYnW1ulndrR5WT+sz q5fV2/rc/pvd2e5id7W72d3tHnZP+zO7l/253cfua/ez+9tf2F/aA+yv7IH2IHu0PcYea4+zx9sT 7In2JHuyPcWeak+zp9sz7Jn2LHu2Pcf+xp5nf2t/Z8+3F9gL7UX2Ynulvcpeba+x19o/2+vs9fYv 9mZ7q/2rvc3ebu+wd9q77N32Hnuvvd8+YZ+yz9jn7Av2JfuafcO+Zd+279h37Xv2ffuB/dB+ZD+2 n9rPHHCEIx3lGI7p+JxTzmnnjHPWOeecdy44F51LzmXninPVueZcd244N51bzm3njnPXuefcdx44 D51HzmPnifPUeRaEoAjKoAoaQTPoC+qgPxgIWkE76ASDQQyGBEOD8YJhwfjB8GCCYMJgomBEMHEw MpgkGBVMGkwWfCuYPJgimDKYKpg6mCaYNjgmODY4Ljg+OCE4MTgpODk4JTg1OC04PTgjOJOvPvOK LK+MdpMTJHlQXu+cpMpQfN+j3qP4vk/VUh/AAVVHfQSHOIYeUa1VazhKEa8HHFOD1WA4pUaqkXCa I/sZjltnOW6d47h1nuPWBbVELYWLHCEuG3mNfAJ43VSalmmJaDPUDBUxvDKa3XfCd1ac19E6h7jK q6S3rD7WGCmtadZKmcjaZN2X2XmttD6vkk6naH8TAsQOUlLML08MaDRFgBXknelP2L1B4iZuzeWW e40mFBJClL2BPu+zN1J9wN5E9SF7y8tj91FrNfiJS0RAMmIAGZ9fPbIPuNvtQ1Rvto9QvdU+RvU2 +4r7TUzgnhETumfERO4Z+VxP+KwvrtEE6NM6tKjegPZre0J4Tyjviffangjek5j3RPIeCQEatWga uzzSvc88v8wPUpaQJUDJ0rI0GLKCrACmNcQaAj5rqbUUtHXduk7nk+ZMueM/FGNfj7D/f8fX/06E dWPon42b/8mYGaYb6ka6if4bRSA3chanmFmOo1klikxfcZysQTHSjY7PY2Psn4yKnf9BPPx9NBxF cfC3CPhqdPl/LRq+jHYUF0dS/H41KhYm9uFyj+fMw+UdFYl5PPB4xyNiHTWJcYxnzjGBGMdDstr3 yVI/cu3yReyULV6Pm06oE88Jc+I74U4CJ6GTyIlwEjuRThInyknqJHPecpI7KZyUTiontZPGSeuk c9I7GZyMb4y2vd8cbzGAFtp/KurO/X3cxRAMxXi/i74b7I32Jo7BW94YhfdRHD5gH7KP2MdexGNM iIk4Jl/5w6j85PdxGSMwMUb+U9H5tdjsPPkvROfyQooElMpGivQQLiqKqpCKr5SmF3VELGQSjUVj eFs0FU0hh/hYtICcopXoBHlEZzEMionRYhzUEYvFNqgv28g46CLbyy7QXXaTPaCv/Ez2gS9kPzkA BsmBcjAM42ueo+RwSd6ec/zxylFhMEGFq3CYrhKqjDBDZVbZ4CcVo4rBKo74uzni7+Hsba8x2dgG F814ZjwRYd4174rE5n3zvog0H5oPRRIfwSWifP18A0RS30DfEJHSN8w3UqTzjfaNE5l8E3yzRTbf XN8ikd+3xLdeFPNt9G0X1Xx7fXtFHd8B3yHxke+I75ioT9zgiYj1PSNu0FPn0vnFMv2OLiRW+DP4 M4rV/sz+bGKtP8YfIzb4c/lziY3+vP68YpN7/Uz84n/X/67Y7C/iLyK2+Ev4S4it/tL+0uJXfzl/ ObHNX9VfVWz3V/dXFzv8tfy1xE7/R/4GYpe/qb+p2B+gtF8csOpbDcRBK9ZqIg5bzaw4cdxqb7UX lyjOjhGXKc6uFHcozt4XT21pfyC1XdvuJOs5E5yTsltwQHC0XPv8/hbKRufxFZfaopG3ZckrWwTk A5/HPdISp8lB+6dRcet5xAqmsXQ/Lfc+LadPR6i4d9lkEpnIarIK9y2IeUQeOmdJUZKCS1lRFgwx Uozku2w2Qj0z0kxiRplJzWTmW2ZyM4WZ0kxlpjbTmGnNdGZ6M4OZ0cxkZjazmFnNbGa0GWNmN98W u8RusUfsFfvEfnFAHBSHxGFxRBwVx8RxcUKcFKfEaXFGnBXnxHlxQVwUl8RlQxmGuqvuqfvqgXqo HqnH6ol6qp79K9sMUsWQvNJg8K8V4vHVrAgqCqKoGIRcOtI0M7j3pWWj4idU8xFPLEDFgoJUbCgG xcGBslQQqlMJgZpQi/hhHSph0JBKfGhCJRzaQhwkgI7QCRJBNyqJaXZKiBQhIhSS0ByNhKQimUgG yfiehrdovlaE5DRfa0EKvqqbkmdqKtFcNIfUfJdDGtFOtIe0oovoQnO6n+gHGcQX4kvIKAaJQZCZ ZvBoyEIzeDFkFavEasgm1osNECO2iC3wNq835eCZl4s5dRledarDq051eS0s8pW1sCx8N1V++SEh llTGyBhijrnc50TKYrIY7SkjyxBzrCwrE3OsLquDSfwnFnzEfD4m5tjX6g9+60trENjWdGsGhFqz rLkQZu219kFC64B1GCKsY9Yp4tSd7a6QgqJIL0jtRgjIQBFiEmRy/TlkI3++F2LIix+BnOTJj0Eu 8uWnIDf58zOQh3Ksc5CXfPoFyEd+/RLkJ99+hcbq73XJyrqUls1Il2Sv6ZJX5qU9rkZKVqScxmCN TNbIRzyvFmjWy08s7hMIsF4W6xVkvcJYr3BrnvUdabTAWgJJWMfkrGNK65x1AdJal6xrpJeraVbW NIY1zcWa5qE4OI3yhBmUbRRirYuz1iUpPt2FshSdnlCG8vzqazmanw1Zo2yujuS73XkPL7e4rfQ0 eweJ4S+3STFbfEefwl8eRzPgDRgUkIQbI2Hw2JqMh4/x0IyHn/EIEO+tDRajYvNoO4xN0Kpp1QSk zLwrhFD2NZjGfKg1BqIoB1sCqa1l1krIRZnYNSho3bDuQyxxiD7QgtjCIOhE7GAu9KTYvxiGUaw/ AON4zJfxmH9PEfwE/MAj/yOP/E888st55FfwyK/kkV9Fkf0arKbofgPWUIR/AmspnvvgV+I4EbCX eE0KOEpcJiOcJVZiw1ViF/HgBsX4SMoAyBNShvQJgJtBQhF3lQEquXfbQBX7b05x+JW+k1SM+tPH 8bNu/0NHv7QH4N9kUq7p2nzFV+wh+jd7gKru76C9bRJK8LX78JfHSVDWWGsq/c1V1kay8Qe2O3No K2f5z3uSgvsQ7fXyRV/zkTf7J7w7fTMB+0JgXyjYFyr2hQb7QpN9oY99oWZf6GdfGGBfaLEvtNkX OuwLkX1hCPvCUPaFYewL47MvDGdfmIB9YSL2he5TO9aQBo4spX6Ad//htSApLBFGvUwpMorsIp8o IsqIytS7+qKZaC3aE3/qKfqKr8RQ+qsTxXQxVywQy8QK8bP4RWwnbA4TDufFVXFbPKQA5JOODJMR MplMLTMSxrlERtI+PWGRhWUtisCurC3ysqwj8rH8SORnWVcUYFlPvMOyvijIsoEoxLKheJdlrCjM spEoxrKpKMGyOUV1V7YSFViONhO50lhiRrBcaiZ2JT7y26404/sdV/qm+oMsl/uR5Qp/CMsn/lCW T/3xWD7zh7mSGFR8loVCBP+dZiIDeaMQ4hqSPmWmuhYxDpe/kE8iLckSSccYquuK7FTXE29TXV8Q lyHdclLdUOSiOlbkprqRKOLefyKKUv2xKE51c+IskrQqRXVrUZrqT0QZqtuIclSPFu9RPVaUp3qM GQ6S9E1A9VLTXX155KeBIU3JqklPg+rlfuI8pKPPvaPKr6l+6vdT/cwfAEm6EQPzF4IMNLc+pJjf nGJ9Z3CfATAUxsJUmAuL4Cf4GbbAbjgMp+Ey+RfvmiJZUgTZemqypWiRSxQgayolyouqhEZd0qq5 mE1ojSaE5rCsLeayrCO+YfmRmMeyrviWZX3y7q5sIOazrCcWsGwoFrKMFYtYNvIndSXpmMyVpOVb LJf7k7Nc4U/B8ok/Jcun/lQsn/lTu5I0TsOykBjP4zeBR24ij9wkHrnJPHJTeMym8phN41GcziM3 g0duJo/cLHc8/OGMeAJGPCEjnogRj2DEEzPikYx4EkY8ihEXYIQA31mu2FcAz3QR4v5MxH2WeHm+ rz89ZGcewKthIiHbWiK2kQj3b7tnEYlftpq4luT6XvInw9lWuHav0olQ8lAgElBeJdgTSfYvblyN gH6imqguaooa4n3RxKpBEbDW87Vp2U52lX3lMDVazVIL8DE+waf4jLzsOGu8NcGaaE2yJltTrKnk cVdba6y11s/WOmu9tcHaiPdQokIDTfShRr/1wHpoPbIeW0+sp9Yzm9ye/bU92B5iD7WH2cPtEfZI e5S9xF5qL7O/t3+wf7R/spfbK+yD9mH7qH3cPmmfts/a5+2L9mX7qn3dvulox+8EHMuxHccJOuiE OJmczE4WJ6uTzYl2YpzszttODienk8vJ7eRx8jr5nPxOAecdp6BTyHnXKewUcYo6xZzi6GAQEcMw PobjfXyADzEJRqF7HTQtZ57A2aZJrKssxbRmsjkxhzjKKh3ZhbLKIN83i5xDhnBmGMrrv/HUfDUf wnzf+r6D+L6lvqWQwHfPd484I+VLkMjNl4hbHbXOQAY3ayIm1Zf4Qz77G2IORSnjPwDlKOs/BO8x fyjP/KEC84eKzB8qMX+ozPyhCvOHqswfqjF/eJ/5Q3XmDzXsp8QcajqhxBbqM1vowmyhOyYgtvAZ 6fkD1PozI/rPjeB/ZJxejJDFaAKjGWAcwxjHJIxjatY8C2ueizWvxJpXZZ5U/Xn2aVpmkGdhGXDX lotAslft/++t+I/t8bnt0BnisaUAW4riEfbxeCKPZwiPZyiPZzwezzAez/g8nuE8ngl4PBPyeCbi 8Yzg8UzM4xlJ45YIkni9t018pfdInNebse6cZzsFtlPBdirZTpX3XccMeeW7EcRKXnqBFzOdPQfP ArZkky1ZsyX7n2fS4oa4Kx55bCCeTCiTyFQygyptNjBjzcZmU7Ot2c7sgCkwFabBdJgBM2EWzIYx mANzYR7MhwWwIL6LRbAYlsI62BAbYRNsga3wE2yHHbAjdsMe2Bv7Yn8cgANxMA7F4TgSR+NYHI8T cTJOxek4E2fjXJyH83EhLsal+D3+iCtwNa7FdbgBN+Fm3IrbcAfuwj24Dw/gITyGV/A63sTbePev +z7/uu/z3/ZLj1Di/I3M+PiIYn6hP3VfO81E0cx3+JW7kP3uXTov7/H5P9yn8/IOHzqHfEfWeWWl w91SljzQy/UCcdt9Y4XMKfPQEUVpWwVZSb4va8oPZUPyVa3J63Vxr6u9qbjX0l4tdJbXS57fF/fK 26vFvU73xlL070oJ9yrea6XC74t7Re/VQrr8QaF48FohnV8vNd9UKH68Vgil10sdLr99bvh3pTGV Zn9QWr+p2E9fLxS1Xi+J/66kfL14+j3vL5/hr/WRP1gfEXCU4mcBivWliGVX5WexvHgCi/s0lv4w CIZT9jMZZsI8yn9+gFWwnjKgnbCf8Ivm683/t3Wef6qu8M/Ub1wFeb5G4pAY7uY9UNjNBSjWJeTs wb3OIkQGyqMlRXv3GYnDxQhqjxTuMzbHU+YlxWJxjdrXxQ3KV26SNxEULe9S+554wDHzEbUfi6fU fibddyBJabjPbJQ+amt+i5AtKf+WQRnCv8akHFuGSfcJdQlkQmonku5zzyJlEmpHyRTUTikpc5Op ZTpqp5cZqJ2R31iUSWaidmaZmdpZZBZqZ5Xu88rGyDHUHivHUnucHEft8aokP0+4NChVxozvPrXV JH3NSPcdXmYJsyQos5RZj9r1zabUbmZ+4j7L3exA7U/NXtTubfam9ufmKvf52+Zqaq/xk2f2S8oi pT9t4GMQgeYBYnqBFsFZIIKzg5T1BucEV1N7TXAdtdcTUxWYjHiGIjb5jDM88sohMiTF899Z88hI qO/9Ovg3DiKYgwjmIOKVX7EK5iCCOYhgDiKYgwjmIII5iGAOIpiDCOYggjmIYA4imIM876FkJiKY iQhmIoKZiGAmIpiJCGYigpmIYCYimIkIZiKCmYhgJiKYiQhmIoKZiGAmIpiJCGYigpmIYCYimIkI ZiKCmYhgJiKYiQhmIoKZiGAmIpiJCGYigpmIYCYimIkIZiKCmYhgJiKYiQhmIoKZiGAmIpiJCGYi gpmIYCYimIkIZiKCmYhgJiKYiQhmIoKZiGAmIpiJCGYigpmIYCYimIkIZiKCmYhgJiKYiQhmIoKZ iGAmIpiJCGYigpmIYCYimIkIZiKCmYhgJiKYiQhmIoKZiGAmIpiJvHhGycsnliRpSzKct0KSj6N7 JmnsC2T8vNTn94JCy4k9k9SgTVWlEDF2dMBnZkIlI02IruezMvmEIXrmlsKYWCW6UnTmV7ZETU7W PYovKRWAClAf2kIrcqKxEEf/3UtMBaNTvHIyI7xur4ILKhTq+yhny5J1fPe/Kl1nwsoaE3smzBjd 0wiL7ikfTlRSSHIOq+GLAgX6xttR8G6Dy8fejQ6+7KkwqE+tYzJFZ/CpaoYdP2XRVq07tmnauElc 8vQNMiSPyZs3d/L3mjZo06ptq0ZxyYu2atM6a0yy6KjnByd4fU+rNvXimrZqGZMi+i13v4of8dv+ yq1axSUv3C6uSas2TeM6RidLFMybOzomJjo6dzT9q5UomD06JvvbMd7H/4Ue9RQpX4VFmKB6kluh 7ZbsKQTMkstXtz6b/2b5JOknjPi0TvTFybMGpPno/tNh5aYsfTpucvKCnStNHjN5YN3sH+8o0rDj 1bntN1U9ePPS2M+jBk7o1Wjhuo871U+1N2mBoyFi8PnhP6/M0mj06CZpR23Pl3mls7hG2tUlzlkF 8wzPPCt93pmXS39W5FSvkB9HN69Wb27PzpPqZulQ7sKoRQ3zj64YFeNPHT5h1rmvM0WcfWdkg/C6 NczYCUlzV+5zb8a1oXJ9kl0rqxVf2K/7ynyXqw4tP+/JjE4t4sp/G7FleCB9Cqg+qG7T3D+WDdMF 3n/2waOpjSz/9J093q9+bUn+Ogl7dDAO3l0xr/uwp99t7bZ3RmSbDwv88tN1/5SU0Qt9vTctTN4h fu9jUpHhT+kxM7rHtOgekwnNpMLoMTq6x4juoR9sb32taZvxqSp1DV/w3lfPNk9q898fv57/wMaV O4bDzturBtwaEZHzyjKRen+HeLc+rJt9wnh7c0Hz674DN+U7m+Lm9epDMi+eWHJj/WuP923Jn7/W rFxVmz5N3aLQpi2zj5qdj8QMeGdCaOtmPz4NqxDRdNXj7UVPxauVvMLF+n/7dnbijZlyp8myInZS WP80IQ2m3Ksa9SDFpr0JblWe27Jodv2kZ6L7Zxo3D1a6u/xG5Q3Lz/0c/Th5TKBv0mEZIt/bk1RO u9H9uFr0we35RzZWvxpbekPlqksWqfRhzwbtve4f2HXZiHVzcmc+3en0zA6n2k+E7c0Krd6Zq//x wmEzczZL0uxQzhO7o4zTM4sbG2u9nafle1HB+kutyV/u2lO1UImtUdWmtz4Ulq/PkHYTZuycSF6h bnRPVe65V7Cyzol3uOKzD8dtXvXCpyT933IGNO/zZKd/5AGykzOIyU4fc75wBh3Zg9JJfPFltSox 8aPjuR/88a3q9do2adqycRz9mdBodDfq+LpybMMWrVo2fNEx6486lio6xfOORb66v2Fs8ipNG7ek syavWLTwP/QKSzt22Vv7f6o1z7Cmlq2PB0joIE2q0ruUHQgl9BZKqAJiAwVC70LooRNQqSKKcOiI SBMEJEiRehABKSrSpL9cKQJSBAGVG7h4RI/nOR/uva/P/ZSsWXtmT/as/2/Nmp1KBPw+rAQ6ss0n pePbtMuR+RRxZaVfc+5VbKuznrH1Riphq/6Qjos4r5JtYw8PjkIbF+I9hmgoSqA2+p3v1Fr2Wyoe jn5V3h3r1F4WRP5NJEfq80px7lakKMZ9+Di7fCycBj7WILRhJy9KILH3RUD73iMXguj03doKVEj4 tnl2WCQ2vnytJjmvV/aeEZZJINpgDNgEKW60byuGPYlacoEXiME2q8TKyIOsb/jZpd/xoooqW2tb 53xsSBeH6hIZlkCwLNchb8sbmTD32J32LyqN7jBTygo3uuoGeSjVHMjbYGynmGrQfSpY0i1Si7g/ sw8ZRegWBbrbFD1hckiFHSBsC6DfhwIfmBIgJybFJzQIhISI6H8DFcf250iP3xqCIQAR/gM4ud9A DWYEM3Sf7PEBeVwsWx1pM0g7rSGWp4F6D1Dsu4+BwXgZRR2RzgFjAosfBCP513rqDdC55wTQwt6V UZ+L9ZL9QPrznYvMbxx/p87FrBOqt3dGd3806W7JajBzf4/SKNQALd/uSBs4UUORxUKVPDjCXioU tLJ0z6skYRwer3jHqV7W9cXVMp7PE/OvHcluXG34MgWqg61vYbZp6MQgi0K3b6o5C17BySZMklA9 s3B43hCq6mx3vw5XFw/rXCOiwQR8eDGpNhH4ZWqq5MvmxABVpcfrpBnDatlcjOgrxVEYhbUMYVaY E8+1TXNUQvmFOvigZeyZSFbJD/J3ssMpcy/HVIrgcvK7ikc4qxsBFiwnA5VwvfGG6uQlYCZJ0DG6 2WN6vaC4J1TN04cazxgnPGOMDxljdcxP/2CHRHRURxA8Z36hqr8CRxIA8MSRxAMHgAMS+6bkvgmg /ytTO/QT/YX/b1mTO0oe19vSrPPb8yI5WCnPeedRlydc3LjkjoUHje0D/C0StDH1IxYiu9Jm7MdP PUigGmPIcxPUC2FUVi2JU3moeZVqOCy5NIW476yGj/nC6ifq6RB0nmQXenZlxionmAiH2BtQohso 77xE1Re4hqOn+mTpJIj1jsWV1mPnmKoSn3xgrLa2WKKdkFvmuhhTFurVipi5dc3X8re3pb7NMnGS DOL0o9bPHrAWGt6xL33FCQeuTMbZa063n9igMkKris9BeJ24nHXKk9oq4E/V8l3NmZHFCYPxEUp+ 5FpDdysieVqn1wLtHiLRDfyquulWDJYGQEf4eh+FB2b5jL7vC9IzPmGHrPkIhH04ePYnj+0rFi9C 4qYjgl3nUonHnP5oqntnlmnQKQIGEeOf+zma9jlxkgfMDDCG/lzmGvsXcIAVAXkAni2TLRUl6YBG e8iJi6M8XcRcv66hGMrdVdzD2XG/VdzD093GG4X2Elc3wQeaGL4J0P56S/w+RAGQA2S/2gBhlMjh gL6+vj8b0NbzyEjoHwR0QBuVs+4m9pmcETAC6n8w6SqULg6FhSxT+aN9DVO0mNdBxx2DR60Tcz/b 56T/n6DQzpnB1C9GjZfIKh/fWwpfv8Pufn7nw+oU5csYUiVGJs7+pkcILVJ+y7NkusnvSbtr9d3e T2vTCUrFcHlOXK4uc6TjTV6eh5GNBru5J5Ebdwrr6RRJiETN5XRb8NfXK0xerIigqJU6YRiJ0Nqr S845T1J4e8yv4WxIfoFB91ppeprqdJc5r9KbEJiWwWZvR2DGYvWzdBSDSVlp2spgY292TvGtzoBT 0SJNT4c/uRCNNMqWrvabszAda9rqDL1HQ8o6lsjztjxHT2mhnJbfj7pZ5PFd56cJCnjaZOBpg/1K Gx3M0gFtIL+ONqaOrrZeaCtXj6O0kQbgUGkAKiUlcbC9gR6YEsC+CYTd+6/MTQDg+1eiZHdTd/Rw sPXk1DBBcCJMDOSggIasqJQsTEZUXU1T9uuFRPTsf/EjTGw9fRxRtn8LqIVaCKpj2P9BpIZSfmXb kl4m7wTch53stQTynN+LU8P5JIkrbxV3G/gxebuzQcESvcOKMXCZtY9D8jDGV0nhu7B3DlhP1oTJ Gr3JGuy6JDlhc66Pl5SexSpuChl0sibZb3SPHXtcTfNKT4jAWbr+CEP53p3xzZglZdDMwLjVNlOc 7t0whQ+OKgtT1xpJDGvRgfOUs1oLxS6rA/ZhpB8ZO4Po67ymyfR2rHeXsuFpcl8WaTus2K3PDZGb RgzI6+pOn2kQt2SNT4Koj1gshpPzpJBlQ6C2MTcN2FW5cpMSPyM0EO5SDxEypY6Fttsw9YdMLfLw KZrYNdboGVMjDvkMaOlRQH0DUrDnezFlM6FJvi2HGoJPulPBvTNK37HHfc5AOeUxrFg3KqE+faFE XlW9ve/fYg/aywNl9R9hz9eR0D8jKOmfKPwTQDkGhJNRMvaP92peE2vshwWEhQgIqgqvv+RKok4p vWxySWh7qdkUeT9oi76PgmFbfy3qOMhtJuKkIKJABC4x5p4mc2GZxzjBlChOuSDdRnZTuoNBvVpO 6c4zqtYrYYLrdgXQaXOLhG1j4ynzxZuJGY5ketf6+330YFROUxiNglMXI0xDELwsfG3XNX/nm2EJ dRRi2GRqf88tEqZ56dTG9r12XyUe9+17Ntj4XGuqQlH2+7OJSiF75fGfUt6tfgaXPdfpuYAu2Vmn 52CD9+RVva7fqFruKF0zY99VWO14LaxR35iuHGTH/LyCE0XeqaJoK8GCqahRbObXNuBmSXWLBZpX b3wPKBonilTDJhBfMe0oguNcgH3uj5j6NcXXIZ0AGExmn05wvPkLiq8/gfPvePNGxm23rEMNeYW5 o0dbyaRpp5ihVkSijs7QuCNiSUlyWAeaJFh9w2aSwyiytkW3PwTyccX7SczT+wMPHD3s/ATs5qpx K9jHz5eLPtPdpTjPLSTeqzJsBmbzeeRq44o0HR1bHW/MingaOhGiRyiT/KEpk9SM3UHr+XCTj7l4 UDUfuMrsotMJ1F4oRmF5AMynD/dFk1i0mA9FyYh4P6NeYIeTYXy+ZLi4BUy+U0pIybxCfVnYkNna UiLzRYTBKW5zB0TMuHgkjVHF9iPWOJdlvt/oP3bRDGKpN8J9vKTbbwXkdlsSv4OUR0niPiZfjFSN PIdNdivnENHudk9Xn3SaC+GPd/4Xb8IJBPFPhPfnCv2fKL9oiMkOD0CPE+zXVKAj9PwpHFn+6MBA CKZkJweZgLxB1iB1kOr3pdmf6rqfACpZnxbagjGqo43PsSIhoI71QMSteJk2KJNBRPdqTptgTyzB b+DyzCjGY6vl2fp3Swqe4R6e5mJzJ3UMdibK5dZccqlyxXDXaL6MXI879oTkunTzYvC8hwUiK+lF d89YfNNUo/BzzLtnDyQGoh93odqk+5m5Gn3G5dMq2bwyua4OVVXRmcZupLfYItME+dMtrx+Tf0pv 66dd11saIWdYbn1uHJifh5+cubY2Ag/bpueKtQlFEYNvr6URqosHal6t3SMctt1Gjo8QoW9WQtwo uzPeCFphtFeZ0mm5ZAlPRJcQ/35bomZWpd1EsaHw2vicnUzcBvft9O5yX9PTcq89NSp4NqHh4DI8 pIoJCQiAsOhfWJV9Vyt+O+PODhsBGP5Yb0ECKAkR5ODfy/tRcLiYZERQyqPH6vjZfLMooNTAUe9x gOdbRzAUH2NLLp6G52Ps3ZwZFYjJP2cx2HSGFwI2R7pQQs0A02zhUEGQPsgRhAJ5gtwPTubtQGgQ J8gU5A/ywFv2+HYr/DcHkH8OfyjvX6ZXtL+Hu72nlYeDP+cPeAOHE4AorOfC/OJepsezbiKR6QuD GQPdmVrWQmptIyqLYNNNg2e3mjc+7aFyFidB/q08eQIpdm3XVbHs5qmLgSN8RIu9Hm8bWi4gmzTP TVuuSSVr7iwES0kXdNo2FQewXmhyksskT2WwYraY3fig0t7D2aWi3vdl7cQTh0vBqtRFWoYEqFlp gdlB9yjDRqxSCmEQXDd+TPBSA1ODrt7NDk6OjLWZxqqi7iXT5PzENqaQ6CW20CtbfdRN1apzsoYz 3TXWv42r+WDSOEhaC3E1ReKumkPjJFSx1f4zFy66di2uzvdIL9Zq2634dXxSyKpupxcpoZWdur5z n9mOxGoqJpLg8nmdOoOccEIOIJyQ7dsaEUPDCSnxTaT/7yH6Y0b6rsAgOQzRbAuA+WgkUnx7C0SA v+cfHgj0GD7VykIBCXyilYBLSl/4UyBWyqWlGGDnT9OTxiA3cuXi+a3Z3H9g1n6IqKq9pL7dFjQq mm9FoMBC7dkr5md60Z0nSm+J/IaxKGuIhu12xlReTwqbZt17MxgP28OgcqdE8A0T7JaeU5tEpz6F V+ySfDA4qtyPhfUfxMpqWRMRDZFDJ/OFIcxn+V1aZG4GjNfXFrHOeD7pvBVl6Jk2nb1JK7TxGtoc nJJCOJ/p7ZsEwmEqNZU7t/Irhoj5dbtbnfWMbtZv5fDlD7jpeGjEFYYMLszSdLMz51545W1D6eXr pc4n9Jh5YvLqNo4PCSXb6+MuGH3Enlm+IyJbT8GCvZ9ZUXXe0NQAm7z+pmtqQ/azrHlXvV7LqIUV 1qE4qn7ePg9XGNACKYQf38aJYqxB/wRK09lrDQplbmRzdHJlYW0NCmVuZG9iag0KNTYwIDAgb2Jq DQpbIDBbIDUwN10gIDNbIDIyNl0gIDE4WyA1MjldICAzOFsgNDU5XSAgNjhbIDg3NF0gIDg3WyA1 MzJdICA4OVsgNjg2XSAgOTRbIDQ3M10gIDEyMVsgNTUxXSAgMjU4WyA0OTRdICAyNzJbIDQxOF0g IDI4MlsgNTM3XSAgMjg2WyA1MDNdICAzNDlbIDI0Nl0gIDM2MVsgMjU1XSAgMzY3WyAyNDZdICAz NzNbIDgxMyA1MzddICAzODFbIDUzOF0gIDM5NlsgMzU1XSAgNDAwWyAzOTldICA0MTBbIDM0N10g IDQzN1sgNTM3XSAgODQ1WyA0NjNdICA4NTVbIDI3NiAyNjcgNzExXSAgMTAwOFsgNTA3XSBdIA0K ZW5kb2JqDQo1NjEgMCBvYmoNClsgMjI2IDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMjY3IDAg MCAwIDAgMCA1MDcgMCAwIDAgMCAwIDI3NiAwIDAgMCAwIDQ2MyAwIDAgMCAwIDAgMCA0NTkgMCAw IDAgMCAwIDAgMCAwIDAgNTMyIDY4NiAwIDAgMCAwIDAgMCA1NTEgMCAwIDAgMCAwIDAgMCAwIDQ5 NCAwIDQxOCA1MzcgNTAzIDAgMCAwIDI0NiAyNTUgMCAwIDAgNTM3IDUzOCAwIDAgMzU1IDM5OSAz NDcgNTM3XSANCmVuZG9iag0KNTYyIDAgb2JqDQpbIDMwNiAwIDAgMCAwIDAgMCAwIDAgMCAwIDAg MCAwIDAgMCA0OTggMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAw IDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDUxNCAwIDQxNiA1MTQgNDc4IDAgMCAwIDIzMCAwIDAg MjMwIDc5MSA1MTQgNTEzIDAgMCAzNDMgMzg5IDMzNSA1MTQgMCAwIDAgNDQ3XSANCmVuZG9iag0K NTYzIDAgb2JqDQo8PC9GaWx0ZXIvRmxhdGVEZWNvZGUvTGVuZ3RoIDc3OTc2L0xlbmd0aDEgMTY2 MDM2Pj4NCnN0cmVhbQ0KeJzsfAlAXNXV/3nvzb4PszAwMAsDBBj2JUBCwoQtYQshMBGyQlgSkhAI gWisiamtxuK+a+pabV3iMhk3otatsX6t1VTrF7tFbbXaRbS2LjU28J37zhsCGJf69/+3/f5zL/f9 zj333HPPPffce9+EMMABgA0fMlhW1VK7eOGk4ijw/ToA57nVFVWtH90flw5w6TIARXx1RUNl9pFr YgAu/DmAsGdxVXWNOSHxOuD7TFg/tnhZU8vhM979NcDVW4A7O2ZxS7DC9EL3x8An7gGov7CpJSf/ ozd/+QAA90sctaOrv3Nw9UdbrgJIvxj7N3TtGPY8tPu5pwFq3gOQW3sHN/Tf9OeKOwEyfwugtmzo 3D4ICeDD8R/H/qYNW3b2Pn5JoBOgQQVgfXFjT2f369+Z+BXqX43tczciQ3+74W2sX4715I39w6ct +UDRBsCXAMxZsblnaGv69XNWAJwZwva7twx0dfac2nkamobjuV7o7zxtMO4Z80XYfwzbPVs7+3ue rFpwGGBPB4AhMDiwfXjSBOegPTey9sGhnsF1P5p8FaDorwBmHphv5dePNe3+dmCdsex9iEMzMT38 lzN+xvCppKsHjxUef0ZjVSUAD2oslLCfAiaAO6S58VjhMS22A7cPpiVZJZMxboTVIBcZPJggB9Aq 9biZtAgyP3cxtqrk18gLUKWLUPg5nMODCnijnOd5mYaX/Q74yQDcOYl91KxjY4vHw7R7TGSD8no+ FRk3iEp/KDezmaJ2A0TTtKR4CZZ/3TZEUzT9v06yRGj+Mv2EVmj4MvqFF6Dxy4z3vyFxR6D8/6Ye RSuUo78/dQyZE5Z+2TH5R2fqFRLptvncfnfDti875r+acO6DX4Ue4XKwfRV6oimaoimaouk/N/Hf hYe/bhs+K/HbYcnXbcPsJBTBh1+3DdEUTZ+XhH9C7ddtQzRFUzRFUzRFUzRFUzRFUzRFUzRFUzRF UzRFUzRFUzT9xyRBKgni/x8EeBRrSPF3gAy+h3UXmJDD/v+dHpIgCxZAI3RCD/TBAIzATrjLY5qc FHvqwTvV3oXtW2Boqp2bfB+HqZbJJj+Em1D2PdaBW8o/9dp6adz4KYusWOxoT8TAOuEqzsTFcy5u gBvhdnC7uPO5i7l93P2g4N4SRd6VdJxIHPDS/2/k4bMTd2KUk7pn6LO7yxZ9jv6qz2mPmIF20iyl +hrxKc1YpCOzpvanv5je/zXp3z4aAzXr1q5ZvWple1uwtWV587KmpY0N9XW1SxbXVFdVViwKlC9c UDZ/XmlJ8dyinOyszLTUlGRfktthNZuMeq1GrVIq5DKB5yCz2lfT4QmldoRkqb4lS7JY3deJjM5p jI6QB1k1M2VCng5RzDNTMoCSvbMkAyQZmJLkTJ4yKMvK9FT7PKFnq3yeMW5lcxvSF1T52j2hcZFu FGlZqljRY8XrxR6easfGKk+I6/BUh2p2bByt7qhCfQe0mkpfZY8mKxMOaLRIapEKpfkGD3BpCzmR 4NOq5x3gQaVnw4aElOrO7tCy5rbqKqfX2y7yoFLUFVJUhpSiLk8fsxnO8xzIfHz0/DETrO/w67p9 3Z2r20JCJ3YaFapHR/eGzP5Quq8qlH766w6cck8o01dVHfL7UFn98qkBuJA8xeTzjL4PaLxv/K2Z nE6Jo0gxvQ+MZFOcchO2R2hA29BCnJ/Xy2w5bywA67ES2tPcRnUPrHeGIZDjbw/xHazl8UiLLcha 9kRaprp3+Lxsqao7pJ8dGx2hPes9WZnoffEnBX+w3RMSUjvWd21k2Nkz6quqIr+1toUCVUgEOqW5 Vh/IzUH5zg6cRB9zQ3NbKMc3GLL6KkgAGR62Bn0tbWIXqVvIWhmCji6pVyinuorZ5ake7agiA5ku X3PbQSiYfPVAocd5bwEUQjuzI2SvxEVJrR5t6+4NuTuc3RifvZ42pzcUaEf3tfvaetrZKvlMofRX cTivOKLYC+c2SzoizGauTFF52nin0M5WCxmeGnz4KsqwwYTLJVbZilaUedo4J0TEcBRJglEz9GBF SKlcwpoE1rVyidPb7qX0GSY5JZvkKSHVNF0mZEzZRON8qmkkzQxK91T3VE0zcIZSuWSgpO3kdvLM F9LA2EPFlnNJpElIwZ2LPB7ViCy2ig5PCJZ52nw9vnYfxlBgWRubG/O1uL71Lb765pVt4mpLUdI6 o0btJVQLgRebIxW+EmOwxu+MLKtYXyzWp6pLZjXXRpo9oypffcsoU+6TFIIHdxBOWpFa23leSUwh bs0aPN18NZ0+j8lTM9o5Nrln/eiBQGB0sLpj4zymw1fbPepraStzirYub9vlPJ0NFQP1XH1rRVYm nj0VB3zcuc0HAty5LSvbDpoAPOe2toV5jq/sqGg/kIxtbQc9AAGRyzMuY7KKh1WYpuVYUYnyzoMB gD1iq0xkiPWuMQ5EnirC46BrjCeeKcLjkScjXkDksYSL5NiILsbjttrTzZbnjPaNox3tbHOBHZcS f7gQ51sIId638ADHK3Qhja+nIqT1VTB+OeOXE1/B+EoMDM7OoXPYmTTa4cNzCgOqDZwchaLAVHrG Jidb27zPOsfbvRhqq7GsbAup/Xj2y1PqUG4xKx3IXhza09XJ7IBgG+urTKntasewjShEkdqQGjWo JQ0oUSP2YeGInbpwbXABxf57sBLa0x5q97NB2/raxXA2hWCJbx4uO+mUp7KBctpHY3z54t7EraBJ 2ctAjbZBSxtxnFjFwdrJSUodWt7lw6auDg96WwZdLRjqdJZqnMTpwSNRltojFo1TagQ2LSFFq9eE 1NmoEH8Yrc1mW1KeomxvJ+PF2l5JAMc2hbRoUeo0V0od0DvYVMtswZ+9aCoTfYKpaR6D5b7T8GRh RoualNgc0qfUduLhT/21yPGVRDqr2BmhlXQcIq6SzVyHfhdSWscmb/Xt9E5LWZk+djmwwATnQQxs aB+dzQit8mdlqmZz9SJ7dFSlP3kH8pdKP4XIhANqYYw/Pexa6B7jdxKcFnZpEU4l2BF2zUMYIRgm ke1h13yEobCrDGEbwSDBQNi1AGErQT912EKwOZy4CGETQV84sQJhYzixEmEDQS9BD0E3QRd1WE8d Ogk6qG0dwdpwQjXCGoLVBKsIVhK0E7QRnEKwgiBI0EqwnKCZYBlBE8HScEIVQiPVGgjqCeoIagmW ECwmqCGoJqgKO2sRKsPOOoQKgkUEgbCzHqGcYGHY2YCwgKCMYD7BPIIWglLSWUJQTMrmEhQRFJLO AoJ86pdHkEuQQ5BNkEXKMqm7n/plUFs6QRrBHJJMJUihDskEPuqXRJJeAg+Bm8BFkBiOX4qQQOAM xzchxBPEETioLZbATkwbgZXAQm0xBGZimqhmJDAQU0+gI9ASaAjU4bhlCKpwXDOCkkBBICeQkYhA NZ6AIwARuEmCCYLjYgfun1T7mOAYwUcE/yD4kOCDsKMF4X2C98KOVoS/E/yN4F2Cv5LIOwRvE3Oc 4C2CvxD8mUT+RPBHgjep7Q2CPxC8TvAaifye4HfEfJXgFYKXCY6GY1cg/JbgN+HYUxB+TfArYv6S 4CViHiH4b4IXCX5BIi9Q7Xmq/ZzgMDGfI3iW4GcEzxD8lCR/QvBfxHya4McETxEcCtvxXOJ+FLaX IzxJ8ETYvgrhcYLHCB4l+CHBIwQPEzxE/Q4SjBHzQYIHCO4nuI/gXoIwwQHqFyJb7qHa3QR3kcid BPsJ7iC4neA26ncrdfgBMb9PcAvBzQTfI7iJ4EaCGwiuD9vWI1xHcG3Y1oXw3bCtG2Ff2NaDcE3Y 1otwNcFVBFcSXEFwOcFlBJeGbZ0Il5DOi0nnRaTzQoILSPX51OE8glGS/A6JnBu2BRH2krJzSNnZ BN8myW+RlrOo+zcJ9hCcSbCbYBfBGQTfIDg9bMMzmdtJI5xGqk8l2EEjjJAtwwTbabwh6r6NYJBg gGArQT/BFoLNNJVNNF4fwcawbS7CBoLesPUshJ6wlcVud9h6JkJX2Mr6rSdmZ9gaQOgg5jpirg1b dyOsCVu/hbA6bD0bYVXYgpcwtzJscSG0E7SFLRqEUwhWhC14zXPBsAXvd66VoIVgediC1zzXHLbg xc4tI2gKxzCrl4ZjahAaCRqIWU9QR8xagiUEi8MxeG9yNSRSTcwqgsqweTFCRdjMNuWisLkNIRA2 tyOUh80rERYSLAibWbSWEcwnmEdQGjb7EUrC5kyE4rC5FGEuQVHYzAYqpIEKCPLDZubBPILcsJk5 Mocgm2zJIsgkk/xkUgZBOpmURjCHjEglSCFIJvBRhySS9JJJHjLCTeO5CBJJMoHASd3jCeIIHCQZ S2AnA20EVrLTQgPFEJipn4nASGAg0JOIjmrasGkNgiZsWougDpvWIagIlAQKAjlJykhSICZPwBFA YBJxEuUmEI9j+SeWj7EcQ95H2PEfSH+I5QMs72N5z7je/XcsfzN2ud81drv/iuUdLG9jGUf+W1j+ gm1/xvqfsPwRy5tY3kD+H7C8jvRriL/H8juUexXrr2B5GctRLL/F8hssvzZscP/KsNH9SywvYTmC 5b+R9yLiL7C8gOV5rP8c8TCW57A8i+VnWJ7B8lMsP8HyX/rN7qf1W9w/1me4n0I8pM90/wh5TyL9 hL7fHZh8XL/J/Zi+z/2ofqP7h9jyiD7P/TCWh7Ac1G1zj+mG3A/qtrsf0A2778dyH5Z7sR5GPIAy ISz3YLkby11Y7sSyH8sdWG7X7nbfpj3dfat2p/sHiN/XnuG+RbvLfTPyv4flJiw3YrkBy/VYrsNy LZbvYtmnzXJfg+Vqza3uqzTfd1+JeAWWy7FchuVSzUb3JZqz3Bdrvuu+SHOd+0LNDe4LkH8+lrOF FPe3hRL3t7gS91nBPcFv7t8TPDO4K7h7/66gdhen3eXcVb/rG7v27/rNrkCMQnNG8PTgN/afHtwZ PDV42v5Tgw/x34Fe/txAWXDH/pGgbMQ6MjwivDfC7R/hqka43BGOhxHTiGdE0A0Hh4Lb9w8FYWjZ 0J6h0JBsfmjo1SEehjjN2OTj9w45XTWIgTOG9KaabcGB4OD+geDW3v7gJjSwr2RDcOP+DcHeku5g z/7uYFfJ+mBnSUdwXcma4Nr9a4KrS1YGV+1fGWwvaQuegvIrSlqDwf2twZaS5uDy/c3BppKlwaXI byypDzbsrw/WlSwJ1u5fElxcUhOsxslDginBkyCYmAFLE9AS/OxbkesMOF91/tUpA2fI+bhTiDHG u+P5dGMcV9kUxw3EnRl3UZxgdBx28AFHemaNMfZw7Cux78TKLIHY9OwasJvsHrtgY3OzN7bWiFhe RZhXJM610e5LrTHaOKPNbeOr3TYOzK+a/2oWbI+ZDpt4o5EzGieNfMCI4kaD28Czx6RBCBjyimuM ereeZ49JvWAP6JHDNM7RLWutMWrdWj5Yrm3S8gFteWVNQJuVWwMC5+E49jsPDyeomBWczV2D+/pe Oyfn8D4/0Nri99ePKSeX14dUy1aFuHNDKS3sGWheGVKci5+6V65qO8BxF7Yf4PjK1pCV/WuRWD/7 ggugIrE+lNjSFroxsb0+tAeJACMmkYDEA3aoaPev3T6y3e8fXouPtduH/eIP1rgRVvMzJvvZPox1 lkfEOvg/M5EYwrrtmIYjzOHP7vUfm7iv24B/8+RYt5b9zkh5PcDEZTN+m7UMNsF22IP5HLgALoPH 4DewHr6F1DVwI/wAbocQPAE/gZe+ml+eUZrYKe8HnfAgKMACMHlscnziB1jG5IZpnMuwZpF5TnAm TZNvz+K9PXHZpGliTBEDGrGvnn8BuX/njk8e48tZfXIuq/N7kTaKPd5VXj9xz8StM8ypgwZohSCs gFOgHZpgKZZl0AyNsAbWib+164Ye6IUNsBH60F+bYQv0w1YsvTAAg7ANhtCHwzACO5AeljhUPw12 wumwS8JvwBlI78Tn6SK1G85Ez39zCs+awhOcb8HZWL6Nz3NgL5wL30Fkz5m8mbVROA/Ox/W8EC6a oi86KZfRF8MVWC6BS3HVL0f6alz7ffBduFbkXgZXwlVi7Qb4HrZfOUOWtZ2Qvw6uR6kb4SaUvBmj 59ZZskzyBngEfogx9WN4FKPtMaSehINIPwmvwKvwOrwJf4Q/cX5uLrcY/gbvwWH0fi96nfl8UHyy 36FumPL4qejbiGd3o8dm+mGH1Eb+PEv0U6TtVJTci6tx1rQ+o+I6RXQx6Yiu6f5ic2IzOsGjGV42 xTkx75m9SG66z2Z6cJ/Imdk627PT6Zs+teVm+D6WW/DJ1mF2LULdhjuclTtgP9yJFD1P1CPUXXA3 3INnwQG4F+6HB+BBGJuq34e1E+1hkROROTn/IXhYjILH4HFx/X8Eh0TeY0gdlFofk1oeEukn4Wk8 hZ6Bn8Gz8BTGztNieQaew/h4Hl7AU+u38LIUQUfECPJxfvg5PC9LhV/KDZxceBye5JfCaVh/ib8G VwLkr4OBfY/UxHbh13h6CKCE+eIp0HR/lj3LripbpOHGoRaUXDfw4OHOBxVwXHcgRsanFCuEZqfe PNjMNVcp+VYoP/ry0TUvH30W8Vku5+j4kXHT8SPjMaWlOTl5uZzZaxaL1cArlQqFLymbLy6eO7eg IH8hX1SYzfuSDFhSiwoX8sULhYJ8Fy+KkqTIRWHGFX79z1VC03EF/w139dalybzbabDq5JxH7o5V LWjKthi9RWlpgRy3UqPg5SqFKn1eVVLV2nnxE/cLSq1S47Hb4w1ymVKnUnviLHEG2USN3HDsb3LD x5WyLR9fLuQVblg+V361RsXLFIpHnLEp82u8cX6PxWgx6Qxyiz1GobTEaFMX1B0/TxUbH6vUaJQ6 k0btcNhVao1CZzpeAhwsnzymOIT+nAf3PsTv4ndDm5+9FwXbAhWZXqs+O9uSBRqb1ZOl0Zg8F2Vx uVmcMYvTCllZ83J0+GpY2JydpbeAxu7J0tmsmTneeQZnarMzaArKg2l+RzmmmNhSc0E5l1PgP8Tl 55fG5axbu2bNGrO/1JFjRp+buQJzAf7gIw/fVRO/sMa83PYUgyAuj8XHMfenzhF8QoSFS8NWIdZS wEmkUv4LXmP1xjk8MXL+d/zxJlVGWnoS9xLSxDbL+XFZjMNp6Pb4E02yh+V8hdGVkpUwZHSY5bI4 pU4pl+NDtuHjKwx6ow5X4eop3q1Wl0Wtj09L+Ge7cKtzjtOgtiTa2P8jap4cF34n/BRSMV4veIg/ k98z5eN71Ykq1xh3z32pc1Lnq8a4ux8EYypnEVLzxnhXINYC6vlzElMVgrc246P4urn/CBgahQbR B/GN4+XjzA9czviL6M+j4+g/07i5tJT50P4FOjLvRYKbXIahKyvIt8dK4atUpqZiqMtsVhfPQr9Y yJQlZ1jjTahWX7VmaP6yvoWxtpz6Tee3t5+Zb5GlplmdJhn3i5z+qrmnVOa58fV9rr94oKMuJs5s kCm16js8DYGMktXDC0ouvPz8gcol5atMBkGlU75VXV3Qunloa6avutS3YMulbex/VzWg11YIP4Ei 2DvLZwkJYGbuSUwr/DDNLefkmg9y6jwfpEGcKY7XCHHWY4GURjbX+MbjLwL6xj9ejgQC+upQaQ5z UMK/2hW9xTY5cxP5xM5cgt6yWQ0KOgzQdy6ZsEJpsOgMrrz6eYGu2lyXfmX7ojWLMkwqtUytd5Q1 rc676QZb/tKhKzvT6hYVJSqFpTGpXntisqsouGXrhtQNmzzpHqNB5/W54pITLbd8b8Ell41uDujt 3vgYKZZkpfg2lgnls/0S0HizypOwQZ1UzNwTb0vKFObUIFOtAoUh96OEunmz4wDDoBx3IPmlIH/X XsOhQ8w9cV+46yeiSCZ5AvcdnY1KLhJGdoqiLCE5wxZvkvMeMYrmnzI/xaa059ZvOq/N37Cw0NbL aayeOIcb9+jEEQymomBVnsdUUTs9lG7z1penuwura+vc8y6+5LzNFRZvdhw3odSzzahXHl9fvSRv +aZtW7M7N5RtuvQU9FwjxtN1uAuzoWy25x7IyC9WyEA9xhsCap9Z5xKsVl/OGK8P2MCneLS4OMNl Nuvyn8+o070ScEnxgS4wl7LzKwfD6kW8O3JiS3H/xYr7z/IFekUiyqdQzIgmXjl9N6L/Cpn7eCWT EK4LnPvi5ZuU8q6BQG99rlqtlqn0Kt2C1u789nPaM+Pmrjj12vWtI/VJty+rW9TdWGzu7bsg6OP/ gLdPhnehs3uTxW7R6zQJifFqXaxFl9ZyRuuiKy49p3dhRkVzcUF5VkNPSXxWGXqrfPIY9448B9/b 02HTTG/dl+62umCMXx/Qatwul9WdLkuOM45xix+QB5Jr46QQeblx3CyeTkdeHGdHO3rlwc+RZQ6R zm7pVp12kouB9Ce5OSHDlZgaw8sVMU6kUiz8xIfs7HbEufHsvpcTj3EkOdnPElJjNZrY1ISElDi1 Oi7l4zyVViWT4UP4Nt6oSOmU7JxhM31Xvg1ssHjWfjLZQBvQ4OWnlclNNXIyVpxT/LMF+WyZtZ9s xElIp2kxJ5n9xgkDOQ2vtokWyri4iD3yEhXZo5Lskb+JcboKbp1lT2lVVlZ2aaw9ybs0aRWswsHx ptCUJGlb6sxpHwVq60qyvbEasGdpk1YtrSo1FCysLWhIaJBsE61j59ohvIlzcg7h4WYuyMdIPITw Y6TEy9f7r+qafgfPnVskxarwGSzJK0rCWAKbVaGUb+A0Nq8DnaPgB+TKvAX5mzvqzMt4YpoU3IBS nl9WsImYEZfez+E9a7U5jTIuyVi9ur+0bEVxvGCtWb2lpHJliUOlnPIzn5lYGB9oWLD5shUTW08w XfPiFtTOZApnY4QI7Gq6MwmvLG9pU46voTwjtaKt0FeVLK2SEMJVmgffmLVKqXnx8c5UmUEAI2cV jIYU20eBuXUpToMs3piXqvL4az0NasmN5EU8Pw6x5cAlmFoH++f3Es8Pxb/gaiGkUm7D+PPQDkFv Fi4oGlhX/6nerFq7bQHzIX8EZ338uRMuc8+zL6j/TJelV7bhKbIUz9zn0UuxkANtM/10EG8zd0AN DpODtwiOZHZjaXWJ71vq0l8LKE+cltLrzThziuaTzXSIymael5ErWnxtkQnPJ5S2nXrVmo7vtGU4 550iUu0Zd9vymkrK1jeWpsTY85aWLOhkFL+9bt9Fu9cWZ7ftaa7bd+GZa4tz2vaszF9W7PLXrh8Y KclfVuLy160fHKYI4P+GcyuALbPv4TSzOTEmARITdGOcI2AKZNXFJJjTEucoYpNqY6dOClr5nEPm Aul8PAi6zxGfNtvP3FN2tAzPE71KZYl1WZPaVyw2N808JaU19saW1zXPMftcsQqFcK0s1uVxxig1 yvkbL2yZGPjk0t6S3lCaJFeqFQq2B9ST4/xf0AM1cNdMDzyCoX8cX3YL8T712+djBp+xMOCsPpzm kefKA3JBrjkcqPN8lAYZpgxeJ2TkvBxwnvy9yyy+nhxin8xM4yYxDJL/T3TNfI/Dc8cls0n1OamR tzhe+qTH3mV4yaN/UWiNap03tzI7syrbUbRsTVNR8YZLV+a0VObqVUpeIX66SipevqC4qTCusGl1 U1HhurObUxeXZWq1whaN12O3OKxx/mJXWlFG+vyW8pqdp+QZ7E6dyqxT2R32GK3T7XRmlXkzivwZ pS2Bim0t2boYu1bDPL1t8h3+KdldUA2js2ItfW6mv9hfoVIvUi8qVvv9ucWxxbGQW7GkeFGZKvM1 td87d4nxHwHv1I5BF4znP1taipfAs8ypMaUs+ky79h46ZNpLL3+WL9A7Eok+4dPfXtinMvqUXFBQ HIlQlOKf4hUarUH9Ro9M4c91piXaVSq1HMNL5cnIiS1ZXuLk5XKhZ5dWp9BZ9Lv9nNYq3gpyzv+G USNcprbZ7WbNhMZWaC7IUWvUWqPe7XIolQatwlHQOFeX6PEYuGN6iyHFYz+i1KllMrVOecSOfhzE 8+j3wiP4Bjgyy49JWgfkleXn+ZLjHKB1JOfF+cry1fLiWldt5j8Cpkb5iTdfegXAN4BDh/CwNovv e7FfoM+0m3Lq89bcqa0r+lH6nDXFy+Q0MYk2q9Mo572m6jUDpVVrSuPUygHpSkSPbFUotE6/u2ig oz6midNG2HHoTRn7h4Pbk+oDaSmL2ou81T6+MLKPj78QX5Loyku2LthyRRt3YYSNHrJNXC7cjB7K hY2zPnX5rJb0h3kTACRxx+91ONjrsi9gCFiya30qa2Kttd7QJN1PYnThtPEzxfjUR1LdSeWkS8wg KMWXvdRU9IiQmjq17ywFCwUxduzCzTK5d+nG8zomjiti4lPinL4YXvveFTyvxOhwus1KboRf2N26 2M1rbcnOLJdwizZWs+qpl/78zYkbVBgEcp3VwJUKAzqrEjeyICgNmuNJp9x38Ied7IjT4W318OQH /BnytfgmmAPzA1ab1u7TOn32NJnfpbWBRmaS+8e45fe5Gk01aRHn+MvLjz+HL/30rpsjHuSzX1uF k//j0O3sGLbZ440y/k5B50iOdyZZZMIreMxoDZm+eJ9FKdeYNKYMb2KyBScXeUcUHtLHaOVyXYzu 437DnDk+jdGgMjqM+tS0FK1JqzY5cBWXcPfxpfwCnEns/aCNeU11wl72aeVZtJFtXq/0sdWLe7KU U6i0uKvW6HU87kWjlrvZoOUTFNbYWKsuJkZuiXVYtDHopQ+FXmG5fAQ/GcyBskVasHK7wQVu3oh1 QFoDFt4YUGvnyOOSF5sWT/fU0UP4cWD86Ljp+NHxWW6yK2dV+V9xarMjJiZWL+OWcNrYpNhcn2wi jVOb4pGpm8YUzom4hjvMKJNpIm82B+2u5UqEo0KtaPec+6zg1iYvUnMCJIAKnyZIk/7xCz30Mnsj O3pohpd45iXLrLpwEfpKb9YcN+hNCr3NxP/doF8qsrTHDbopFnejwurAj1sxVq3P67Byw0qr3WHR x9i0SV6HBXfUbf8emWuP5q8tv/fpGXfQJ7KQIOV7v84sS/sCefBEllfKj0zPiqrPzE9RVp7+yaxy fal8z+dndVY0R/P/9/nSrzg//lVlTUI0f+V5UzRHczRHczRHczRHczRHczRHczRHczRHczRHczRH czRH8+dl8a/02Pdh3oHPeOgAGZRxJo6f/Ds+TZNvs+/BFGmX+Nw1+Q7n4vZNvo/Pp5EzgvRb+Hx6 8jfcDpHeIdK78Pkedz73NGi584WhyZfY92dO/gmfrHUf6n8dnybk7EP9jHZN/hmfuybfxOc+HGUf 9nqCe5rbBxp8Pg28MIR96btgs/gkoG+0BegWn4I4C4NYYzQPOiEDIt98u1CQSbQMEoR4iZaDQ6iQ aAXyV0q0Eo4JOyRaBRnCWxKtBo9sUKI1/I1TY2lhhexiidZBhuwNidbzV8tNEm2ALcrbpr7BNl9l lWgOlKoaieZBob5dogVwq6+UaBkY1DdJtBx06vslWoH8JyRaCbvUhyVaBTaNRqLVYNI0SLSGWzY1 lhb8mtUSrUP5vRKt5xo010q0AeZq/8i+KVimlvxMNPmZaPIz0eRnosnPRJOfiSY/E01+Jpr8TDT5 mWjyM9HkZ6LJz0STn4kmP98OHsiHXMwlSDVCH3TBEAzAdiy9MIy8SqSGYFB8diKHfbfsVsjGlkWw BbMHliOP/VXqMPZitR7EHpTegc9ulKzEfltQZj3y+lCiT5TrxNKPurpF2a1Y2468rWIb9e9DCzxY OqW/ttyJtVORGsaxmMwIahxGfg/WhsRvvN2K2vrwuUHUMiBpHUaJfmlMJuHBOQ6IY/aIfzPL5lIr zrUXOZ3iX3QOibPwiNgpzpKNS/PowpZMUXO/yNkiauxEHxE/Mko/6tkiemxQsnIrcvrFUUknm+fw NAvYiIPiXMjfEW+T7WykAfSAR/wL4A2iF/rEv0dlfx08LNbYjIen1oN8RqN4RNu3SvMaEH27XpQ8 YfH0GTGvnSb2o1lvxnq2GA/TV3OOqK1f1LBT9MOItPLT/c1WjObfI9rP5k/rMiRGA0Maka21B3UM Ts2GbNwgyWzH2umS9mGcBa3QjqlV6hRjpBO5/TPmFYnmLrSkUxy/Sxo/+yRRP+8T86T1iaz/vKld UwQrpCjqk+KtCDXOxdaZ/bNm9D/5juiRYptm2inNbYPYSrb2SN5k9neLUc3msllcz0ifk7f2/ku7 +0Qk0boFsdYn2sDGbxFnMjxjjXMkCwamzaBL2pPD4ix7xDhvQE4XpInrn44y3aL+xaJV1HdY/Nv1 eagxB1eS5Wxx/8+0PFvU3o8ywxh3zP4N4gwGUcNO5LLV7RXnwnbVTK0RPjtZaAU2T+lrF22miN4p RuJ20cJhcc9tF88I6u0R58D2a48YbX3iGOSh9WLfiPeq0X8NeFpS36FpLbTXu0WfnNi/p4pjdYn7 +2TjUp3JdmEUjYg+7J7aD91iOztxaAaRPTAoznSrtAtIV4/4ZLt69rxZO50eadgrXYzOfpxXz9R+ /qRVWz+h+Yv76IT2yAnukc5gip6uGWfhJ+d+Il5n2jV/mgfYTGgudCNEon5o6nbpFs/XreI52/mp MyU/d87waY8U/bP3APMqi7wRsWe3eFax2fRM6WGSW8Tz7rNW6KvaFyf2RI70fRKd0i2VLa7VIJx2 uyc/N7fE09jXNTSwfaB32FM5MDQ4MNQ53DewNft/iDsT8KiKrO/X7e70lgVQECSO0xBAQJaAgKDI AAYICExkhMFtJB0SSMg2SVhHJbYZZBtkGMVlGEGcMYgLiA5BETrKogSIIUASTEMDITHchAaRNFF5 ue+vbndCUN7vZb7n+Z6Pen59t6o6dc7/VNXtCMYxIjXVMSl5xsycbMekxOzErDmJ0/s8GJ+a7MxK diRnO+IdaRnTE7PSHdnx6dkOnicnOZLi05JT5zvmJufMdGTPduakJjqyMmanT09On5HtyKBqTmIa LdOnOxIystITs7L7OMbmOJIS43NmZyVmO7IS41MdyTnYSMju5chOi2cECfGZnMsmabNTc5Iz6TJ9 dlpiFjWzE3P0DrIdmVkZjFsOm95TUzPmOmYycEdyWmZ8Qo4jOd2RI/1gZDRxpCanYysjyeFMnqF3 HDCUkzgvh8bJsxL7OIJu3pXtSItPn+9ImI3zgXHnzMR+4lxHVjy+ZCXjNg3j0xyzM6UZepzBnezk BVTPycChOdKleMfc+Ky0gC0Z5oSZ8VkMLDGrT3Po72uyiT/S//ukNAOnECKccgzsM6h/8HnvwPMW QiQSbYzGY21GshxVIsPMip+emBafNcuRIZ+0uEy6sdx6kPBtcnpyDu1/lxOfE/C4Lx1k6AYSUDIn Kzkxu8/42Qnd47N7OKYnOsZkZfA0Jyfzvr59586d2yetqfM+CRlpfXPmZ2bMyIrPnDm/b0JOUkZ6 TnawqjxPiseBWbLeoxmzCfR8x+zsRAaBS/KxIx5dE7PSknPkgJzz9eGNmjx+BE+z9AtUnz47oO/c mckJM1u05ZicnpA6e7qMRYZjenJ2ZioGpAKZWclUSKBWYnpOH0eT7Yx00qN7cg9HYppTNrrWVXpT 5RuOSK8uE5zwZxOehEAWNlvX4xrs6359AN2TscJEkKHPktNlesbc9NSM+JZGGXN8YKQEvlmBjNk5 mbNzCPuc5IREWWdmYmrmzxy6GS10JfpOT0yKZ0r1ic/OnCe/j8nfDaF1EItu+L/QUahhk383Xlg0 TbQK/nYR+c+ouge/Byk3bNf0J8Y0IixMUeRv87jZ+uHhev0LN1u/VStZ3/DIzdZv3Vqvv+1m67dp I+sb77jZ+rfeSv0Y/fekWPnuJ+vLb9y3yt+MohhEO6W1cCgdxd3KnWKw8qR4UMkQccps8aQyR6Qr z4j5RCpPWSle5Nu+/O0nb/N9/0PjOLHTmCX2G18Rh+j5GP2d+pmN6v/BxhBsxGDjYWw8hY1MbPwJ G4uw8VdsrMHGO9j4GBufY+NrbByl5+P0V3O9DWV/CxvtsRGFjb7YGIaNcdiYio0Z2FiAjUXYWIWN N7CxERvbsLEbG4excRobtfT8Hf39eL0Nw54WNm7HRlds9MPGCGxMwMYT2EjFxkJsLMPGK9h4Cxub sLEDG/uwUYGNWmz46PmyLtl1NowtbURiozs2BmJjNDZ+h40EbORgYwk2VmPjLWxsxsYObBzAxjFs nMXGj8ZXFGEaodjo6ZbrbZjKW9j4FTbuxsYQbEzFRhI25mFjKTbexMYmbOzAxn5sHMPGWWxcNo5T 2hqzlG7Y6IWNQfT0oJx/VptitcfnxudOorwsXhZLKOYQxWweHLt45cpMeRoSHZubu3KaNUSxmq3W a/fN0bEXcnMzrQbFahwuhg8fnpubG7gYHrgw2xSz/XExPTcmd8m1jjNjY1euXBnsYPHildPMJsVs ygy0CKHO4OGO1q1PWkyKxTT8grw9Ta8cK9tlWs3UiImNjYtzDMeawWoKGBO5ilExmU4aTQZrSFzc OmOIEmJuFI1Wu2INnVYYP/zh4ZOGr8p9KXcxxWxWzJahMXmLX53ZwkGbWbFZTCbTtQc38tBmUGwB D2/soux66vSYxYsX66eDY/LyFmfe2EWrSZHDD/ooa8fExGBa+miWPkbjo81gsAV9bOmkTTppkhWf FqLRFqbYwh3R0XFx0+LWjXWMdYxz5A3PG24xKxbrUDmCV2daQhSLWTqKp3aLYid2pqZHVJMDbczN nRdwTwQN2o2K3ehwNHlrsSuWsEdzk4bHUBbrodRN4K90WD+XDuOxNBcydVqgmVlYzINjhkdbF2fa TIotxOG4oHc4TW8RE/DabhEWy8iRMTHdo7Gom6aiblvk5iomxRRywWQy2M04vs5kIVrPCnHFHq7Y IxwdorvHdY+Li1sZu3Js66WtFznyHNf5HnCQoSzODLUoofh+nfPWoPPSpsnhaPI+1KiEmhwt3A9V LOFPFCY4RlJkfIMR/n/hvrTd5P51/ocG/LfScqEQV0PDldBW0v9o6X+c9J8I4H+ew2pRrLZhI0e6 XHnLc6xmxUoIhusxCLMqYTZFUQzNT6lqHTpy5JXc3Lx5QbdFk9thRiWsOQz6JA9VrM1xaIqEbu0J 58iRIwmAfjFU7zxvnr5wyFjobS3Cahk6kmCY8ubZQxS72eFoDPSbqbcaKf8wpFCrsFpHjBjZuUv3 7nIehBkNYebmUQQiEkJEQgxhFrkyNEckrJUS1nrwnYPvHDoodWiq/HMg9UDa8j2vftnhyw42q2Kz /yYhYdeuXXuL59gsis16h3NaIX92zwu3KeF2JVcWo/gN34wSxC697BXFfA+TlW13JCXtvaJXNinh puhoIabpf+ggeCd6WvMdW7hia5Wemf1qQodA2Rstiz6G9OwE/uzdu1e/ujMwor3z9DUoNbOpAwtW hzqnZQ6+I2z5vFCzEmqOjr4S7D5Tb5kQ6KZ4TphN2GxyJZfj7kYZKgZTosU0USjCQ5Rwc4cOHaID 4xOFhYq+PoZYDOHWpKQDBxabbIrFtjBXvnbovwJMvgXYxXrDVGFMmJ+VKtrOyEqcJe5Ljc9JF+N5 ovxu0kiH6EBtTX8jMYtw+du+9CtFWESEaKffD9wxsJO1ErdRjGNJUtFl0m8nOET0I5MecohhwTry 3bC1aK9fGbHQprl3kwgVt4jbg1chIoy9sKOITMjMzhT/1D836p+b9c+t+udn+ucXs/hyKb7SP4v1 zyP65zf650n9s0b/rJffbMRF+amY9c+O+mcf/XOk/jlF/0xJm5U2S3lW/1ykf67QP1frn2/on2/r nx80v+H9b5/KTX5aiaSRGLCicC5/cv//754BHcL/42OEuFP0EZP0n6S5xCqxXmwRX4hScVpc5N3G pntqDXpbL+R/vzDSrq3+Gxblb/m7L3BcEBM4vjixRRvy7cj666+/N1x/fanX9deXO1x//cO6666V MPv11xFvX3/dutv11x1HCpuhxXWkucVzs1B6P3L9df/1HO3kdHcRhz8RtHERqmhDnFho+KehXKwz /sP4D3HElGN6UxwNOW5epRjtr9nzlU/sB0PHKF+FTQlbZngw7M2wM4b54RvDNxt2hO8JLzXsjoiN mGgobfVAqwcMx4SStUH6Zs4K892ohFspncN7tSj9g8V6gzI0fEFzyaWsoqyhlMoSIX5ewq0R9ohe rWqC5UKL4pel9RM3LEmtP2sqbcxtOjSXpcFSeINSSqloO6xFiQ0U/cnPStspbVObS1a7PMpSvWy4 UWlT2m5ru6/a99TL1BuWpPYrm8vG9pubyzfBcpJS076+RfHr935WOjioVdPB0WFOhzm318oizzrM 6Wju2KHjpI7LO+7tWCJL4O610rHmRkW3WdPxQqBE2q8V2XNka71/h+RX4zr1ai4jO01tLunBkktZ 3Sm3cyxlUudtnYs539Z5W9T4LpO6TtPLgq4nKf5u71G23DXzrmdh5l153cf1cMhy18wew3qkUlw9 lvdY1bM1pdvdyylv3L3h7g+CpaT3qr6D+/4Y3bbfVkph/9f7e/r/eM/TwbLonpX3vDHgAuXqwLhB 6+/dLcvgKYNf0kvpkLAhS4OFK66XDinWr4qHVFCWDrl6/+L7tw7tPnz18NUjeo3cMnhKoDbH4kCt mG2yXszeUWtGbRy1bXTn0ev0UjT6jF4ujhFjbhvjGH2Rs4mU6WOuxobFpow1UXqOvUS9onHOcc4x E/nMlGeUOeNyHzI/1EUvPce3Hd+RMnj8MHiJ8vr4KxNum+CY4Bj/+oSeE1ZOWMl9nkxMgqcn3DZ+ 8ET/b8XDzkkVj6Q86ni056MD4oudA5yfOj1Nx4QIyqszh82MS347eXOyL6V1SseULin9UwanjEtJ TZmTkpuyImVNypaUz1KKUipmzZn16qwPZjWmmlM7pPZJHZz6WOrM1KWp76UWp15IM6c50u5LG542 Me2JtAVpa9I+TTuSdiKtNu3HdFN6t/To9EnpL6XvzWid0fNG9zJiMp7NWJnxRYYns1vmtMz1mfV/ 7Haje3+c+scfb7wOBVeiFuX6lSTLca3INSJryrUSWB1+PpeunwuBfL7hytG0erQo18//rOXXipzt Wa9fK4F5LtfBVv7ba9v3ZC3tPKSYlU9fR/Uja2brz8LX4IW9VU24tWnda9MhvHObpZ3SZdswX4S4 tv4Fo7FAbyOCtRZE2JuiJO/K9VTWlfbaLJX3myLVpgNXvViN7RH28M6yN9qsalXDsbNerq3w/X+2 sq+5tpa3WM3tcty/WMH9v1jBkwLrNiu2uWmt1vuRXq9pszRCyNVIrm7oUcLZSbn+BNaYwGrFyiaV Sm9Wj1VLXl3TkAjLPuoj7fr9C52mBvpkPW2xhgbWyOZV8IZrYGB11e1PDa56I5vWO+726jS1Ywnn 9N9v6zhnuw2B/UQ/sne0X8mOsaHd1uYdIbjStylst+HarhDILLnH6LU3yBq0ndpuq3yi36GWvN+m MNzalG3tN/NsKX3TXj/X717bz1ruaHIs+u7VtH9d28G2Bkd3/Z6VFNypNuq7VGBv6sl1wCZWRxe1 y2v/DaM4GYxsILr6/GnfIpaR9sDMkTELKNspXca1U7r0uf3JtsPay+iXyPi3mIO9Otbg1UmZBU3Z IHsMRJu69bIeO0tsgMDe0jlW3w9aFLm3BPYVfWf6vyz6btai3KDGtutLcK9rLr9soe9x/1HRd8Gb Lx/8n8vPIyVL8w76PxR9T73pou/zN1l+Hh397aBF+WX89LeGFkXmcUDp/6z8suf/fXQ3VwJxlm8N EfZ7d49aM7g0vLN839DLFHnn3t3yHUNeDZ4yao18+wg8k2XA1QFX5ftK4K6+W1QEimwzfLX+TiPf XoqHFOtvJvLtpZgWU3gz6Bh8g6CMy9TfGzrKNwt5rR/lO4Ws81KgyBqyDiV4p2PNQ13kWwrzfN24 TPlGI99m9FKk31kn32b0q6JxmXIdCT6j8E60cfQZ+eajvwkJ/R2Ior//mPQ3JerKt55r70Gji4ZU 6B6XSl8nOAKe3rs7OKq2gRGOmaj3Ld+rhOwr0O/P5tovFGupc9dpgSthVgq1T4wTtGXGyaKVcaoI M2ZpXxp3ikE8CdeOKxEQqVUqd0ChdoinZ4WBM9U4WasSCp+XhYHPz41Tta9EK/GudkXs1q7Qdj9t 99P2DG3PKNPErUq8GKs4xa+UBNFZmS7ClVniFlreR8sYY6q2VSj0Wy1M1A2j7q3UDaNumN5/NbV8 tAnXPPTrod/D9HtY+YPoRP0u1J9M/c7U70bfXei7M72tYbwnRChn7+BfG+PT2krjM9qT+DfEWKWt Np4R0cZq0cv4rehpPKtVGFW+VUprpVg7JaxYK8daeVMEeHI7T8yMdpn826QiHY9Hi9Yg/+7A/fK/ +2ulIhGSIFvzihytXsyGOTAX5sF8vssu0PaJP8HT8Aw8C8+LISIP/gyL4AVYDEtgKSyD5fCJGCU+ hUa+B18VDqEJhyKE/BU3DiVZPKzsFZF4m2ycIu43Pi4sxqcgVSw2LhS/Nj4Hz4tfmdZq+0zr4E0o FUNMh+EIHIUyKIcKOAbfQCV44LgYEtJWKw1RtX0hDcIc4uf8Mvyo7TMTC/M9HB8Qfc3DOc7RSs1z YR7Mh4Wa15wLz2n1Zhc8L8zmPPizts8yUERaBkGKcFhmQRo8LYZYnoE8zvHdgu+WVzj/O6zhfCO8 J0ZZtnIkFpYf4CeeXYH/Eg6rQQyx2ji+w5G61ndhu4i0PSYi9RyuId/tetbViNvJ3I/I3I/QfAaa z0DzSWg+iQzrQ4Y9QoYtIsMmk2HTybCxZNi4QF5pA41TtBXG32sLyI1B5MbL5MY0407tbWOV6Ed+ GY012kXjWfG4nluV1Dou2rWYKS9i70XsrcHeGuxFY+832MvEXgz2ErB3P/YG0foxbL2ErYIWtlbR /2f0P1ncQq/n6fU8vW6m1830uoleN9FrJL32oNdUer2HXvvTay967Y4XJ+g5kZ730+s99LiBWRip HaXlUZ7u487fxB30XUjfhfS9gL4XUGM2NWbrEXqKGTKNkceLbPofSP+T6P8BJVnzYiNaeZV2hdqn 2BmGnUV4sAhbA/HARe/LjKe1K3hxyVir+fGkj1HVruqz/RKWLmHpHJbOYelWrPTCSgpW+mFlBFa6 YqEHvR+hpyPCxGr2Nvkfjrrh3LnEKpXF2vGaeJ7PPPgzLIIXYDEsgaWwDJZDkdYo9sMBOAjF8DWU wCEohcNwBI5CBRzXfhAnwAsn4RSchirtkDgD1XBRKxPfayfFJWgAP1yGRu2g+EHbLn6En+AK/Bdc 1c4IjbVTgKKd0VfBxzSP8QnO/8BxmnbGVKr5TIfhCByFMiiHCjgG30AleOA41GqNprOgQh3Uwznw wXm4AN/BRfgeLgFjMV0FTdsecpt2yPKQ1miJg8kwBR7VTlqe4jgNEnmeBMnadkuKdsYyC9JgDs+e 1nyWZ2Ah5y54HvJ49gJHYm8h9pa/cr4KXuH+6xz/znEN99/gfC2sgzdhPf1v5P77nG/ifCvnn3K+ FzxwHE6AF2q0HyzfQi2cBRXqGGM9nAMfXNLKLA2AJhY0saCJ5QdAE8tPjOEK/Bdo2iGr0E5aFW27 1aD5rDbtjPUdjozF+i65YxArRFt9VzSKFdpZzorI8xIRwpVcK+ZxNYOs32X8WvQUCnf9IobM9JKZ XjLTS2Z6yUwvmeklM71kppfM9JKZXmqrZFojmdZIpjWSaY1kWiOZ1kgW1ZMxfjLGT8b4yRh/075p fFKEGOPBqZ02JminyRovWeMla7xkjZes8ZI1XrLGS9Z4yRovWeMla7xkjRcl/SjpR0k/KnpR0Yty flTzopoXtfwo5UcpL6p4UcNL1BuJeiNRbyTqjUS9kajWE9V6Iuonon4i6ieKXqLoJ4peouglil59 xnqEhViO0N9Lntb+xL492Vgi7jIeYgc7zM4n4yvfQo7gYZUwcbWEq4lcDSC+a8RU9tMo9tMo9tMo 9tMo9tMo9tMo9tMo9tMo9tMo9tMorAxjT+3KntqV+VrCfC1hvpYwX6uYr8eZr8eZr8eZr8eZr8eJ tMZ89TBfPcxXD/PVw3z1MNIk9tzBzNEK5ugJ5mgFc/SE0Sm6GXkvYQ/OYw/uwh7ciT3Ywb4bxb4b xb4bxb4bxb4bxb4bxb4bxb4bxb4bxb4bxb4bxb4bxTz0MA89zEMP87CEeXec+VbCfCthvnnYL6PY L6PYK6PYK6PYI6OYJx72ySj2ya7MEw97ZRS5X0Lul5D7JeR+CblfRe5XkfvHyf3jqKShkkbue8j3 EvL9OPnuYT+NYi+NYi+NYi+NEqHEfCUxf4sV/StW9EPE/jli/2/U20l+jzKWsqIf0a4aj4oEXa9T 1D5DrTPsuyvkKq2l0PYAbf/NXRdtV8g3NtqOo62fdo/xrrRC20LNVdSsoOZhaqZR62s9S97Re/ob z5fo+9fv9Xx4TZ9hWVoxPY3UR3GUdzNZv1Tf77/XP/28BURq37OzfC/sSitxp/IYpEIaZEAm/BGy IAeWijtFO3alUnalUtp+S9tvlULemidra7H7KhZq9PesdaK7cbsYYPwcTvOeWyV+x9tmW94GOvK2 2dVYy/lZxqaK1sY6MUA8of+rpb/DGngD1sI6eBPWw1vwT/gXvA35sAHegY3wLrwH78MHsAk2w4ew BT6Cj6GQt+fPOX4Bu2A37IG9eCL/VdRXsA+KYD9vK4+xa/9B+9R0UKs0FcPXWmVIO97eGI+Z8Zi/ 0SrNx5nT3aEH9IS7oZ9WaekP93A+AAZq31oGwVDOH4BhPBujVVodWr21E3SGKOgCXaEb3AX0a6Vf K/1a6dfaC3pDH+gL0dAPFtJXLrwH27VvrfhmxTcrvlnPcc+n1dvGwKNape0x7VthQcdj6His6TuK /JdeaHYb3w468xbxmLDx9jzW+AeOT4mxIoIMiSRDIsmQSDIkkgyJJEMiyZBIMiSSDIkkQyJp6aDl LFo6aDlLbxlBywhaRtAygpYRtIygZQQtI2gZQcsIWnajZQ9adqNlj/+45cBgy4G8aT7O95qnRC8R gp+V+FmJnzvxcyd+fqy//16Wb6P697wDPD9AHt/KnSTyeKr+7UbOEVWsIDNVMlMlM1UyUyUzVTJT JTNVMlMlM1UyUyUzVTJTJTNVMlMlM1UyUyUzVTJTJTNVMlMlM1UyUyUzVTJTJTNVMlNV/s17a6F2 iuw8RnYeIzuPkZ3HyM5jZGcV2VlOdpaTneVkZznZWa4c0L5TDkIxfK19R7aWkK0lpj3aedNe+BK+ gn1QBPvhABzUysnmcrK5nGxWyWaVbFbNG7TvzJu18+YPYQt8BB/DTu4f5FgM2CHry8l61Xxa+47M V8l8lcxXyXzV0ks7b+kNfaAvREM/rZzZUM5sOMZsOMZsqGI2VDEbVGbDMWZDuWU0fY3h+KR2nlmh MitUZoXKrFCZFSqzQmVWqMwKlVmhMitUZoXKrFCZFSqzQmVWqMwKlVmhMitUayp9zdO+s86HhVo5 M6Tc+hz3FsFy+AtsgPe4/z51PoBNsBm2a1XMIpVZpDKLVOtR7p2l7jnq+rRj1vNcX9C+sw3WzjOz VGZWOTOryvY495L4HtJIZp0is04p3fkm3wN6wt3QC3pDH+gL0dAP+sM9MAAGwiC4FwbDELgP7oeh 8AAMg9/AcBgBI+FBiIFRMBrGQCyMhXHwEIyHCTARfgvPaJeVZ2Eh5MJz4ILnIQ/+DIvgBVgMK+Gv sAr+Bi/By7AaXgH5r0X/DmvgDVgL6+BNWA9vwT/hX/A25MMGYDdTNsK78B68Dx/AJtgMH8IW+Ag+ BnYe5XP4AnbBbtgDX8JXsA+KYD8c0GqYKTXMlBpmSg0z3cVMf4aVw8JacT8rh/xJwf2mbdpl0yfw KWyHz2AH7AQ3sG6YPocvYBfshoMizFQMX4uwkHbCHtKB4+3QESLhDviVCDMTH/NrHNdxJAZmYsCM qzFv4ho7Zuww02rM+zgWAeM0l3Eshwo4Bt/Q/jjtTnJ+Ck5rNRYhwiy3a5ctHSES7oAo6AJdoRvc Bd2F3dIDesLdQM5ZyDkLOWch5yxDuUdeWcgrZmONhdyxhkMEtILW0AZugVuhLbSD9oDPVny24rMV n634bMVn653wa3AIu7UTdIYo6AJdoRvcBYzNytisjM3K2Ky9oDf0gb4QDf0gTbtszYF5Wg2zusa6 kL5zgfyzroV/cf4evM+zD2ATbIZdtN0Ne2Avz49y7wT1vUAsrcTSeo77PjjPswvwnXbZxnyzjeA4 RthtzBXb7zl/lOPjWo2+t6jMcJVMNJJRi8mo9frdc9w9x45ziB1H/tTwoH63irtVwbpLqPsPYeLu Ge6eafoZmwgxxGoz+Q7/Ee/TbYM/kfxe9DKwohkGwL1aveE3HGO1Q4ax2n7DQzBBO0qPp1j9q1n9 q+1vaPvt6+CgptqL4WsogUNQCofhCByFMiiHCjgG30AleIAV3n4CvHASTsFpqIIzUA018C3UwllQ NTXsj+ybBsNU3mCz+FZ2u+E+rdbwICzRqgxLtSrmW2/mWm+eHrK/ptXaX4c1sB7e0arsm2ELfAxb 4VOtKnQl/BVWwd/gJXgZVsMrfFMJITJ1REVGYz/RkG/jJ8Wvsb0W22sNj8N0SIMlWgXjqJDfsrC/ Fvtrsb8W+2uxX4H9CuxXYL8C+xXYr7Dv5JkbPocvYb+2ljFVMKYKxlTBmCoYUwVjqmBMFYypQoxA NRequRhbJaq5GF8Dql1CtUuMs5iRVDIS+ZPV3oy3HatRCNGJZjUKIULRvMcvke8iKHoJRS8xukpG V8noKhldJaOrZHSVKO1CaRdKu1DahdIulHahtAulXSjtQmkXSrtQ2oXSLpR2obQLpV0o7UJpF0q7 UNqF0i6UdqG0C6VdKO1CaRdKu1DahdIulHYRgUoiUEkEKolAJRGoJAKVRKCSCFSSCS7xIFFwEgUn WhQRBSd6FBli0WaJFof3cXg/im8vy/j2soIojCMKtxGFe4jCbUThHqKQTxSeR6sitCpCqyK0KiIa cUQjjmjEEY04ohFHNOKIhpNoOImGk2g4iYaTaDiJhpNoOImGk2g4iYaTaDiJhpNoOImGk2g4iYaT aDiJhpNoOImGk2g4iYaTaDiJhpNoOImGk2g4iYaTaDiJRhzRiCMacUQjjmjEEY04ohFHNOKIhlOY g9/6XsPb1/F2Ct4txbvX9Hmyh9jsIS5lxKWMGNyC/7fw9CV834Pve/B9D77vwfcyfC/D9zJ8L8P3 MnwvYwxljKGMMZQxhjLGUMYYyhhDGWMoY54k8y11gvxZpL6+tKX370Rvw8PaWWbsGZ4WGlK0HYZZ kArpWnnwJ2+7WVt223dpO+x7tB2hn2tnQ7+AXbAb9sBe+BK+gn1QBPvhAByEYvgaSuAQlMJhOAJH oQwq4Bh8A5XggeNwArza2YjfQhwwXv0braqPvYH5Xc38rmZ+VxO3fsStn76+7GQ9dMPn8CXs16oZ ewNjb2DsDYy9gbE3MPYGxt7A2BsYewNjb2DsDYy9gbE3MPYGxt7A2BsYewNjb2DsDYy9gbE3MPYG xt7A2BsYewNjb2DsDYy9gbE3MPYGxt7A2BsYewM6TNWOEe0iIvxV889xpEebRD88KuB5Jc/Po8ZF 1LiIGhepW0bd2OAskWtFSHCtCCGPXkedi6hzEQ8L8LAADwvwsAAPC/CwAA8L8LAADwvwsAAPC/Cw AA8L8LAADwvwsAAPC/CwAA8L8LAADwvwsAAPC/CwAA8L8LAADwvwsAAPC/CwAA8L8LAADwvEQLzI R5cidCkyJIs70KaI0S8n+w+R/WfxIh8v2gfnevvgXN9CDN5GtyJ0K0K3InQrQrcivMrHq3y8yser fLzKx6t8vMrHq3y8yserfLzKx6t8vMrHq3y8yserfLzKx6t8vMrHq3y8yserfLzKx6t8vMrHq3y8 yserfLzKx6t8vMrHq3y8yhcWdLmCF8vw4mu8KMOLZYx6L6M+JULxdyf+7sTXnfglfWrPk3z82Yk/ O/FnJ/7sxJ+d5MAc7aphLuRx/heOL8ufynDXZ8gjsxU+G1kn52qNnB0xLBImwwvU4puLYbVoZXhV +8nwmvZT6EZ4F96D9+ED2ASb4UPYAh/Bx/Bv2AoFsA0+gU9hO3wGO2AnuKFQ+4lxzdVOGp7Rahjf KcNL2jnDK9ol8aghS/vCkA3zyNL5sFArMeTCc+CCPHGbYRHHF7UThpVaueGvsAr+Bq+yxrGehcZq X4SOhXHwEIyHCTARfgtx8DBMgt/BIzAZpsDvYSo8Co/B4/AEPAl/gKdgGsSzEzkhAaZDIiTBDJgJ jDmUMYcy5tDnIQ/+DIw99AVYDEtgKSyD5fAXWAEvwkb8eBfeg/fhA9gEm+FD2AIfwcfwb9gKBbAN PoFPYTt8BjtgJ7ihUNuD2nOI3iLtMFE8ZljNd0oDeXAR/f16btQLKzVOo5AfhS4anpV5Ixy0qKLF Sb1FJkq5UcptmM2b41wiP4/jfFjAG5nU9VlaLuTdKReeAxfkaRq7kJtdyI21S4YVqLZS86KiFxW9 qOglF0rJ1zLU9KCmhx3JzY7kZkdysyO52ZHc7EhuVHajshuV3ajsRmU3KrtR2Y3KblR2o7Ibld2o 7EZlNyq7UdmNym5UdqOyG5XdqOxGZTcqu1HZjcpuVHajcj0q16NyPSrXo3I9Ktejcj0q16NyHSrX oXIdKtehch0q16FyHSrXoXIdKtehch0q16FyHSrXoXIdKtexq7rZVd3sqm52VTe7qptd1c2u6mZX dZMFHrLAQxZ4yAIPWeAhCzxkgYcs8JAFHrLAQxZ4yAIPWeAhCzxkgYcs8JAFHrLAQxZ4yAIPWeAh CzxkgUcko2A1Claj4CX03o6KUrlSlCtHOR/K+VDOh3JSfxv6f4h6XtTzGpaxVsiZ+6L2FgqeRMGT KHgSBU+i4HEUrCVPvkDFMlQsQ0UvKnpR0YuKXlT0oqIXFatRsRoVq1GxGhWrUbEaFatRsRoVq1Gx GhWrUbEaFatRsRoVq1GxGhWrUbEaFatRsRoVq1GxGhWrUbEaFatRyYdKPlTyoZIPlXyo5EMlHyr5 UMmHSj5U8qGSD5V8qORDJR8q+VDJi0peVPKikheVvKjkRSUvKnlRqQyVylCpDJXKUKkMlcpQqQyV ylCpDJXKUKkMlcpQqQyVylCpDJXKQuX71Xb4DHbATnBDIe9V0ajkRyW/PhvzRBtUuIQKjajQiAJ+ FJDv741Et5HoNhLdRqLbSHQbia6f6PqJrp/o+omun+j6ia6f6PqJrp/o+omun+j6ia6f6PqJrp/o +omun+j6ia6f6PqJrp/o+omun+j6ia6f6DQSnUai00h0GolOI9FpJDqNRKdRmJn159hjwg3L2FuW yxFzZJ8RM/GtFt9qm9eOhXwDzYXnwAV51GT+4Gud9JNMqyXTasm0WjKtluxSyS4V/+vwvw7/6/C/ Dv/r8L8O/2vxvxb/a/G/Fv9r8b8W/2vxvxb/a/G/Fv9r8b8W/2vxvxb/a/G/Fv9r8b8W/2vxvxb/ a/G/Fv9r8b8W/2tvYo1QyT6V7FPJPpXsU8k+lexTyT6V7FPJPpXsU8k+lexTyT6V7FPJPpX41hHf OuJbR3zriG8d8a0jvnXEt47sU8k+lexTyT6V7FPJPpXsU8k+lexTyT6V7FPJPpXsU8k+lexTyT6V 7FPJPpXsU8k+lexTyT41tFD/tp2nfaf/PHsQWvnQysfsrmd2VxN7H7H3EWMfMfYRYx8x9hFjHzH2 EWMfMfYRYx8x9hFjHzH2EWMfMfYRYx8x9hFj33/zdufxUdbn3sfvzB2SEO4R3JdWrSvaui+tSzW1 u9VuxyO12tbq6YI+nPbhwbq0Uj1UjoXautStHKq2enqOdIG6FyOKgCwaEsNAMjAkIUAgw2RCIAwB Ar/nPSOeV895PX8/f3y8595+y3Vdv+v6/kIysnGRjYtsXGTjIhsX2bjIxkU2Lppj0RyL5lg0x6I5 Fs2xaI5FcyyaY9Eci+ZYNMeiORbNsWiORXMsmmPRHIvmWDTHojkWzbFojsVojNy3QwTuFYF7y9Wv ssJ+4dr9YvVRT90Q9vLwXh7ey8N7eXgvD+/l4b08vJd2u5WekftF+ej9Ub5RlB8myg9UN99fwZOj U1I/jY5S9YbcPYMVd/z/WKEV5VdWeosrn8pzHIxin3b5tMtsh6N/NMacMebYocQOpbJONJsRVl/R 6iuaVdqYD+T99cZd5P0B3h+w8opWXtHKK1p5RSuvWD+3EhU588qZV868cuaVM6+ceeXMK2deOfPK mVfOvHLmlTOvnHnlzCtnXjnzyplXzrxy5pUzr5x55cwrZ145finxS4lfSvxS4pcSv5T4pcQv5cxU tHKKVk7RyilaOUUrpziq7NPHKlE1IKoGRNWAqBoQVQOiakBUDYiqAVE1IKoGRNWAqBoQVQOiakBU DYiqAVE1IKoGRNWAqBoQVQOiakBUDVTsu5sVi+w7FB2SetE+ZX54K/Umbb0g3JZaHP4ztV2t3BEe Su0KLXES8nE65OLRYUt8CE7Hea59Mfyp8m/146Ix8deiZP9P7go89oy2/yJS36TcF9BxC8PO1CIs lm2XiOK3qefllLKdZGql4ypsFqu90UF6bUuVsBO79RLZjdeiDkeGUnx26InPwbk4P2yLLw7Lkz+E weSPoSX5K17w+UXHl8Ka5GU0Op/vuCAUk4VYhKWutYadyQpksNL9rGursdZ5B7q1kQ+lpF/7O1AK PclODLm2y3kIpXQah4We9OE4Akc7PwbH+Xw8Tg7L0+eGtvSFuATX4jp8A9/F93Az5oSW9OJQTBtX uinsTK/w7hp0oje0RZ9n0W0sWmDNlazZx5p9rLlzvzUzrLl8vzWXs+ZyVuxjxTwrli24lQW3suBW 1tvOettZbzvLrWe5AsstZ7nlLFdgueUsl2G5DMsVWC7DcttYbhvLbWO5Asv1sVwfy/WxXIblCixX YLk+lutjueWstp7V1rPadlbbzmLrWWo7S21nqe0stJ2FtrPQehbaykJbWWgrC+VZKM9CeRbKs1Ce hbay0HIW2sZCBRbqY6HtLLSdhbazUD46MTUr/CD1YmgUyfNZ5t9ZZh+L9Kc6RPTmaHKqNzwlqr+d Ggx/ENWfEVtvxXFYFNeER0T4lSJ8lQg/NR4TZscH4hCfj41+GJ8UrhPxp8ZnhC/EZ4bJIv8ccfdw fGm4K74sXK8C/dq+eL19cfn3/J6JbwpvVH5LYbSRlP212WjW67mfTzbpeaPe+vVW1FtRL8X4WLvr 0x3Pw9XRxdbTJd6eJdPNty4WWEeLQ7O5lMzjeC21amWpVlZqZZ1W2rTSZqyjtNKmlUx0gDeXeLPH my9562BvNet/rTff8GbWm53ezHoz680x3lzpzXY772f0s0CNWCgvL8ISkfc2Nb0c1ooIWyfC1ml1 hDdj0bNO9KwTOetEzjqRs07UrBM1JVFTEjUlETMkYoZEzJCIWSdShkTKkEhZx7PreLaULv/eXUqr B2i13gzKET/L3F8xnr9hiYi92vyusVbnafPvo7LT+QZtiBBtLAgTyuvCrmAWy79oJSwIy1xpSr3L CxltdvDA1aFZW83RjXqa4cm7rK8uTz+vx/v0eJ+3+lhhDyvs8fZKViixwnstrHRchfYwR2uviK6W VCEsi+uRhE1su4ltN8WH4XAcgWNZ7ITwWnwiTgqb41NcOxWnh2623xhfHNXGDc4vC32Vn7aUf7vk 2vd+2mWddrF0P0v3W6ddrN3P2iXWLlmnXSxyH6uXrTKDVWawygxrtYvl97D8Hpbfw/Ila7XLWu3i gT08sIfl7uOFfta7L+mPapPtYVMyiB0+74pq01XhtXR92JQ+CAfDnNLH4kMwl/RJjid7bqzjKc4/ G5alrwhz0lfii/i+8wmYE/p5Z4b128XTe9I5z69FB7qwPsyJRonatSK2PfV2JRLOZbGPVf618ltG 81KUSl7GfKyMUmrWe5G6iY8KfFTwRo381iu/9cpvvf8jAgvsUGCHcp4qmHtBbuqVm3rlpV55qVde 6pWXeuWl3v0RWZBneuWZXnmmt+oDVQ+EmVUP4iH8Gg/jETyKx8JMI5omkh4RRe+IommiaFrqNbE3 D/PF30IKaxEWh9miaXuq1fVM6BBFd6eyctdqrEEOa9ER7k11OnZjPTZgIzZhc3SdqHshlfd5Cwrh /lSfYxH9YVJqKwZ83obt4SZ5r0VFaFcR2mWBa+S/Rak97g1jb3gttc8xhMa4CinEqA6T4hGONeFp kX1/PMrnJFwle6wU4VfJlffKlffGB4VfivarRPs3RPs3RPs31OoH46PCb+IPuPdBHBtdEx/neDxO CBOsgglWwa3xyc7H4hTvn4oP+3waTg//IOfeKuf+klen8OoUXp1ipVwu/z4Rf9T1j+GCcE98oeNF uDjcF3/c8RJcGm63mr4Rf8LnyzxzdXh0/2+tvWJl3S+ujhJXR8nXL8nXz9SsCzNrT8CJOAknY2yY WfdkmDnyMnwtzExmh2XJHLykor2MeWGaVbddpE0TadNE2rRksftLsBzNaEFrdFSyAhms9Pwa13JY 67wDnd5b53yD48bwy2QTepEPDyZbwm9U0/uSrc4HsA3bw1VW6VUq7H2ieIoonkKXPKjK3pfsDvck ezDsuRAetIInpFPhl+kY1eEeq/kquuXB9AHhN+kxrh2Ig1w7GHxoNUyxGqZYDVPSR3r+aM8eg2Pd +xCOc/148GH6xNAoA1ylit8nA3xDBpiQPtW1D+MjOA2n4wycibNwNs7BeTgfH8XHwqT0Bfi4z5fK Ig34hM+fwqfxGXw23J/+nOPncbn7X3C8Itwt09wt09yd/pLzL2vjK/iqz/+Aq/CPuBrjXP8arsHX nV8b2imNdkqjPf1N7X3LtevxbdyAG/FPnv2u+9/D9/U/3rWbXJvg8yJZbXGYlm6KjkrzdZqv03yd fhfWtcwxJZ1l4zWOOTZaiw50Ou9yXKed9cZtPVMw7em88y0ooC9Mik6SSe6QSV6ROTZVlPRiNWhJ GN6vaqbKAN+VAV6zul+2utvV9x1W9hwru9vqXWbVrrFa/2i1LrdaH7Ram6zWJiv1QavxeqvvRavs AatsmVX2mpX1b1ZWxspZasW8aMU8YMUs2P+3B9Mqv4F5gxw318heUi2bU/byRrhcrpsv1803yh0y 8p9l5DYZuc1oX5XnelTNp9XeTRUNs9LnVWgPi82iSW7baRZZ+WuNGWx5X7WaxWrKdaNZlKjXjdTr RjlojdyRkztyRrjXCMu/RTpfdWxO/iPkVcinVcinVchmFfJp67THOu1RIZut1fnWao+1OtdanWut zlUhm5Nl3nsb76I1tKkSbapEm3Xao1o2q5bNKkabitFmnc5XLZ+2TudbVzlrICfmc+J7JxW7kYrd KIZ3UrIbxe1OMbtGjC4Wo4vF6GJxufO/KdwbnN+I95Xu9z1/s3cnOM4JT4uvuSpms0rUJlYWi5Wd FbX7L6pKi6rSIjbeYfFhsfEaS7ez9LCq0sLKw6w8LEbOUQ1aVYNWcfJ2RQOW3N+JXarQXooq4u/q 0MrKS1m5rCzfFjNZMZMRMyUxUxIzGdk9I7tnZPeM+DlD/ORl7YysnRFHTbJ0kyzdJEs3iaUmmTkn I7fLwhmeGZY9W2TP8i5tmHeGeaedd9p5pV3WbJE1W2TNFlmzRdZs4YF2mbJFpmyRHVtYflgmbJf9 MrJfRvZrl/2aZL8mma9d5svJfDlZLifLZWS1jKyWkdUyslqTrNYkqzXJajnZLCObZWSzJtmsSRbL yGLtsliGJ5fKSK0yUiuPLuXNpbJSm6zUJvO0yTKtskyrjNIqo7TKKK282sKrLbzaIpu0yRytvNrC qy0yRiuvLuXRYVmjRbZokS1aZIsW2aJFtmiRLZpkiiaZIiNTZGSKjEzRJFNkZIpWXm+RIVpliFYZ olWGaLWP3xwdyBNp1h6Mzrcii2LhdqtvptU30+rrFhOTrbASv/+B31/h91esrAK/Z/l9Fp/P4vNZ VlDRqinyyWQ+mWzFFPllshVStCpmWhUzrYqZfDLZqihaFUWrYqZVMVP0l9hsFlvNEv0l9prFXln2 yloFJTbLivwSG73CRq+w0StslBX9JdFfYqdX2OkVNpol2ouifaZIL5nzK+a4IPxcdG80g5edbZdN doQnxa7aaWaDzjaa2WYz27z/5wVNckbezJrMrMnoBo2uyeiajG7Q6JqMatCIBo1osxFtNqLNRjNo NINGs9loNhtNk1EMGsVmu6JumW1HRUF16KmjnGPZsKi3Fr0N6q1Fby1626G3Fr216G2H3lrYosgW Rb3uYIuinnfouUPPHXruYIui3nfofYfeO/TeofcWve/Qe0dUL0/+zswzZr1Kz4N63CT3NcrObbJz Vg5srGTnmv37zE5P9tpLXmkveVZ8TXROxXKd7uTc6fqvs93lFqMRzsqz63bWp/3l2u+LUhRS+d+o z6XL20VWga13hwE5eFBeG5TXivJaUV4ryluDctagHFXUWocsvkN12G3tx3IH+0Qna6PTnbKW3aqt uZ7oYc1trLnNk2tZMseKOVbM6aP8d2OzzevPLLqVRXMsmmPR8k8Jciy51RjmGkOnMXQaQyerln96 sI1Vt7HqNhbdyqJbWXQbi24zxrmsmjPOucbZybpbWXdbxRbd5poy11R0uHHuNLYBYysaW3F/TA2Y xRbjGzC+AeMZMJ4BYxkwhp3GsNMYyrm9qP+i/ov6Leq3qM8B/ZXzdrFihYWssIQFlsjL3fJyt/7b WH6lnobk4W6zL/92xIq/8+4K46s2vury3zPITd1yUzcLLNH7Qr0v1PtCealbXuqWl7rlpW55qVse 6jbzJXJQt5kvkUu6jWahXNItl3TLJd1ySbe9svpmJH1GstlctxnBg/v/vb+8Ty7/1eEKtaTdHrlD pe92XK/eFMIC1prNWs+z1vPmMN+6aGexJ/h+lZZ6WO0JVnvCvBbs/y21Vl7togjbWfIJlnyCZ7tY 8wlrpd1aaefhLvNbYL20m2OXOXaZYxcvd1F27ZRdOxXXzuLPs/jzLP68ddTO61283sX6z7P+8+a+ gAeeMPcF5t3F61088Xz0AdbPsn52/09GdlV+MhKFAg9kjbhgxAWjK7B2lrWzRlkwwgIrZ1k5y8pZ Vs6ycpaVsyyc1VOBhbOsm2XdLOtmWTcrxnbIx7tDRzmKoipnvxVv5Z8HnB82RsfZK/XTNT10TY8q OqSKDqmiQ+W7KmhbfC0ffIsOydup99MhO1AKQyrfEN3fr/q10fr9NEkPbd+v2g2pdkOq3RD93k+/ 96t0QyrdEM1S/rlkG93So+oMqTpD6fJfltUawatG8Or+lfc7rb3q6Vc9+WpUZSx90UV2wCU74JId cMkOuGQHXLIDLtkBl+yAS7RDkXbYTDv00g79tEM/7dBLOxRohwLtUDDbYbqhl27opRt6Va/NZtlF JxRE2Wo7sZKdWMlOrGQnVrITK9mJlezESnZiJTuxEkuUtUAXLdBLC/SySBdLDLNEF0sMq/+9LDFM A/TSAL00QC9LDLPEsNrfq/b3qvm9LNGl5hfU3V51t1fd7VVzeyvzHWCTJKw3lx5zGTKXIXPp2f/z 777KM5uiQ2nnfbxW4rUSr5X2e2wFj634O2+VeKv8k+M23inxTol3yj8pLvFKqeKRFY5r0Fn+XYdK ZBzBJ1180qX9Ae0PaH/AnS595LSd03ZO2wPaHtB2js+6tD+g/QHtD2h/QPsD/Nilj7Ja7dLPgH4G 9DMQ1ZhNf3xBNCLZjT3RiHQ1joxGlPO/KvMtMyz/DfMCETE3OpI9utijmx26+XQDn27g0w382c2f 3VrrZJv1fLmBb7r5ppsvuvmhmx+6+aGb/bvZv5v9u9l+A9t3s30323ezfXd0vl4GRdE2PQ3qaVBP g3oa1NOgngb1NKin0n+zynnOL6hYf6PeB1W/T6p+Z5jFarNYzVobjWjQiAZZbePfWW0j5ViiHEuU Yyldrm8H4WDo+79Z80j3j3XtQ3jfsif5fDLNPtbxfcvmfF6LDrCyWQ1a6/8vKx9jNQzycgcvd5hP p/l0mk+nufSL8kHj7DTOTtE9aJz9xtkvwgd5usN4+0V5eYydxthpjJ3G2C/SB0V6eYydxtjJ+x08 32F8ncbXaUydlb8XGhtfH42NHo++Ex6PvovvYVK4K/px+GH0E9yJyfgp1ru3ARuxLTwV7QoPRLux B8PYGx6oOiU6rOpUfBgfwWk4HWfgTJyFs3EOzsV5OB8fxcdwAS7ERbgYH8cluBQN+AQuwyfxKXwa n8Fn8Tl8HpfjC7gCV+KL+BK+jJuiw6veCK9VzQ8vV72JBViIRVgc5lUtwVIsw9thXvWT4YfVT+F3 aHK+HM0w1+p9COGBEYeEx0cchiOiw0YciaPwAXwQRyMffjii5P5O7A4/rDkXn8Ct4fGa23A77sBd 4a6auzHVvd9Eh9WsDvNqo+iw2rMdz8G54eXa83AJLnX+OfBZLZ/V3hQeqP09ZmOL8wL6UMRgeKp2 B/iqNoTH66rCA3Xp6LC6AzAaY3AgDsLBOASH4nCYU5051ZlTnTnVmVOdOdUdg2NxV5hXdzf+3ec/ Ob7l2OdYDC+P5L+RbD7y62Fe9M3oIOr0YByCQ3EYDsdYnIJT8WF8BFfgSnwRX8KX8RV8Ff+Aq0CZ RF/Hd8JMkTtT5M6sRO4tKuuPcCtuw+34cXhWND8rmp8Vzc+K5merp4fm6l/gPvwSv8L9eAAP4iH8 Gg/jETyKJ733FH4XnuX1mSPWheYRPdiEXuRd3+o4gJL7O7E7PFtTG5prxuBAsEENG9QcjxNwJs7C 2TgH53r+UsdPOH7G0Zxrvo/xuAk349YwU+TMFDkzRc7M/4qcfwm/rZmCqeHZuhfLtokeDC3RQ/g1 HsYjeBR/wH/gP/EsZmEZ3sY7aIJdamSXGtmlRnapkV1qtAIZrEQ71ofn5ITn5ITn5IRl0XYMYgdK 2IldYbY8MVuemC1PzJYnZldvDi3VdrTVeWxBAX0ooh9bMYBt2I5BlN/bhxBmW2/P1V4RWmq/gqsx DtdU/j56We31jt/Gdz3zPdwUZtfe6vwu3I0p+BnuBfvUsk/tDDyBJ/EUfoffe+/PjrMd5zq+hRzW ogOd2KL9AvpQhLlba8tqzb3W3K252dbcc3VRWGbdzZYLq6Mxsv6YqAa1qEP5e33rMQoJ0jgAsmBk FYnxiWJ8ohifKMZ/IMZvEOM3iPEbxPgNYrz8fxkaKc7Hi/Px4ny8OB8vzsdHP4tGR/dgKv4V9+Ln mIbp+AXuw9/0Mxfrw2M8+hiPPsaj9/LoFB6dwqNTeHQKj06JaEVencyrk3l1Mq9O5tXJVaxY9W+Y CdasYs0q1qxizarf42k8g3+HCKwSgVUisEoEVonAqj/iT2D1qr9gNubgr3gOz+MFe/CzotEpVSR1 nmMDPh8mpi4Pd6SuwFejg1M3hYdSN4fpqf+F8l8aXBu+EF8XbqECvhBf73hLWBa3qMfvRofEK6Lj 45X026qoPl4f9sQbaL6N0alxj+Om6LQ477glOqj6lmhM9Y9wK27D7bgDP8ZPcCcm46e4C0+G8XLF eLlifHVrNLp6BTJYiVVoQzuyWI01yGEt2FKkTxbpk+WZiSMODS0i/jH5ZfyIHdFIuWWi3DJRbhlf I5ZqxEuNeKn5II7G6TjXvfMcL4YKKp+Mr7nM51vDRLljotwxUe6YKHf8QO74gdxxg9xxQ83PopE1 92Cq5/mrhr9qyhF/Ck7Fh/ERfLyy2qZYZY9ZZY9ZZZNr74xG106GmKoVU7Uz8XvXZzn+SSWb7fNL Pm/xfAF9KGIw3GvV3GvVTLFqptSKr9pdEF9Wz2NWzxSrZ3JdKhpd96HQUnccjscJOBEn4WSMhXHW GWedcdYZZ91pOB1n4EychbPxrLaMq+6PWOB8IRaFlpGfCy31T4Q76p/CgjC9fhGaotH1y9GMFrwL Pq3n03o+refTej6t59N6Pq3n03o+refTej6t59P6DnSiC+vQjfXYgI3owSZsRi/y0ehR86ODR72J BViIRXgLi7EES7EMb+MdNGE5VNpRLXgXrViBDFZiFdqRxWqsQQ5r0YHO6OBkYjT6gC9HBx/wFVhP lGJzFMfrK3uC5uhEn2pTJ8tkSeW7xmtQizqU//+Y9RiFpPJ91olMlqj++sMhOBSH4XCMxSk4FR/G R3CRHi/GFSFPBeSpgDwVkKcC8lRAngrIUwF5KiBPBeSpgLwMOUmGnCRDTorGh2J0E27G/8IE/DN+ gB/if2Miyt8QNCncIZtOk02nyabTZNNpsuk0mXScTDpOJh0nk46TScfJpIlMmsikiUyayKSJTJrI pIlMmsikiUyaqLlZNTer5mbV3Kyam1Vzs2puVs3NqrlZNTer5mZl3bSsm1Z782pvXu3Nq715tTev 9ubV3rzam1d782pvXu3Nq715tTcvU0+XqafL1NOjTc43o/xvA3lsQQF9KKIfWzGAbZ7fHqbK6lNl 9amy+lRZfaqMPlFGnyijT5TRJ8roE2X0jIyekdEzMnpGRs/I6BkZPSOjZ2T0jIyekdEzMnpGRs/I 6BkZPSOjZ2T0jIyekdEzMnpGRs/I6BkZPSOjZ2T0jIyeoclfoMkbafJGmryRJm+kyRtp8kaavJEm b6TJG2nyxqp3ovqqJixHc1SvGqRVg0Q1SKcuCptUhHTqU46fDz9VFW5UFW5UFZLUdSGf+g5uCveq DrepDrepDrel/jnkVYjzVYibVYjzVYib4/8T7o9fteedF6Xj+WFC3By2qhYHqRZHqRZ51SKO2+w1 19ujblBJNqoi5W+Uy7u+Rfa/JUpUi0S1SFSLRLVIVItEtUhUi0S1SFSLRLVIVIuEGs1To3lqNE+N 5qnRPDWap0bz1GieGs1To3lqNE+N5qnRfPVjoVj9OH6DGfg3zMRv8QSeDONUoHEq0Dh7l0Z7l0Z7 l0bVKFGNEtUoUY0S1ShRjRLVKFGNEtUoUY0S1ShRjRJaLU+r5Wm1PK2Wp9XytFqeVsvTanlaLU+r 5Wm1PK2Wp9Xy1TtQwk4MYRd2Yw+GIbZUuIkq3EQVbpIKl1HhplPUWYo6S1HnKeqsijduRDEUqeos VZ1V+SapfJNGDLm2C7vDOBUwobCzNXWhWDMS9RiFBPKPyphQ31nqO0t9Z6nvrEqZ1JT/Ov14n0/A yZ4di9NdO9P5WTgb5+BcfZzn+kXuX+x4SXQwhZ5VUcepqAmVnqXSs1R6lkrPUulZKj2r0k5SaSep tJNU2kk1P/b+T3AnJuOnuCvcofreofpOU32nqbrjVN2Mqpup+c+ovmYexLi9YKMqnKnpjupV4oxK nFGJMypxxv6w0f6w0f6w0f6wUWXO2CM22iM21n7W859zlEtp5TytnKeV87RyVvWeSivnaeW8Kj5d FZ9e+32fx+OmMJFmztfehttxB36Mn0DsqvIJPZ2np7P0dJ6eztPTeZU/UfkTujpPV+drxWqtWKWv 89RAQmPnaew8jZ2nsfPUwUTqIKEO0rR2nkKYSCEk9Hae3s7T23l6O09v5+ntPOUwnXKYTjlMpxym 14q/WvFXK/5qxV+t+KMmplMT06mJqdTEVCpiIhUxnYqYSkVMpCISKiJDRWSoiAwVkaEiMlREhorI UBEZKiJDRWSoiAwVkaEiMlREhorIUBEZKiJDRWTqbo/q6+7AXaHRPriRqkioioSqSOyHG+v+7N5f MBtz8GLIUxsZaiNDbWTqVrrW57ki+n3eGtVTIBl75saR10X19b8Jm+pnYCaeCDdSJTfW/97neSFf /zrmY0G4jUq5rX6xz2oItZKmVtLUSppaSVMraWolTa2kqZU0tZKmVtLUSppaSVMraWolTa2kqZU0 tZKmVtLUSppaSVMraWolTa2kqZU0tZKmVtLUSppaSVMraWolTa0k1EpCrSTUSkKtJNRKQq0k1EpC rSTUSkKtJNRKQq0k1EpCrSTUSkKtJNRKQq0k1EpCrSTUSkKtJNRKQq0k1EpCrSTUSkKtJNRKQq2k qZWEWkmolSQ6MvpV+PTffWPT/KoP4lvRuKpvR1dX3RDdWXVj9Mmqf4o+U/Wd6OrU56PrUjdVvr/t 0/E14ZPx3PCHeF64Mu62R1jv+oZQjHvCA/HmsCTujT4Q50NrvCWUouP0MjL6Y2iLFoY2vU3Q2wS9 3aq3W/V2ud5O19sFejtdb2fq7dN6O1BvB+jtQr1dqrcfxY1hbvwa5u3bEr8RXlJv2uI3w8J4QfiV UUw1gqF4Y+gxiguN4ldGERvFb41iQVQXLw/PxC3GZocet4Z/ileEv8UZb60Ka1QotjLGl4zxJU9+ XR1r9vSjnr4zbt23z9O/8/TlatqL3rjdGzOi46NfRedXpaPaqgPwRrhLdT1aNf1E6ov2WjJD6gcq 7KzoxNSCcFlqcbgy1RGdn9oRvhNfav/UGCWq5hlm8Ve9LbHPiuNWe6iV4QVVc4Qe9pnVSpXzzv2V M96/14rNrifuNbO861tCX9WpUXWYG41ADWpRh5GoxygkSOMAjA6N0RhcFFZHF+Nn4a3oHkzFv+Je /BzTMB2/wH34FTv+LayN5oa1/LiaH1dXjcGBOAgH4xAcisNwOI7AkTgGx+JDOA7H4wSciJNwMsZi cshV/RR34W78C6bgZ7gHU/GvuBc/xwNhXdWDeAi/xsN4BI/isbAudVZ4OXUeGvDV8HpqWuhOTQ/d IvcfK9+ruaHy3ZpzWLQgXr4iXobj0r7N8c7wqXgo1MW79u2Md+9bE+8JNfHwvk3x3tAQ73M9hCOq R+zbXF0TPlVdG+qq6/btrB65b011faipHrVvU3USGqrTrh/guVvC3Oof4VbchttxB36Mn+BOTMZP cRf+ElZXz8Yc/BXP4Xm8gBfxSshV/w1z8Soa8Rrm4XW8gfl4EwuwEK3hreoVyGAlVqEN7chiNdYg h7XhrRqxVCNeasRLjXip+aDj0Tgd5+FiXBJW11zm+GjI1TyF3zuf7Wg8NcZTs8j5W1jq8zKs9HmV o9VW044surAurKvZ4N4O7MEw9mIfQlhde2TI1R6FD+CDOCGsqz0RJ+FkjMWd4a3ayRCrtWK1diZm 4U9hbe1L4a26FP455OomhtV1tzg+7PiI45NhXd2z7nm27o/ocK0TxlW3DgMhN/KysG7k13B9WD3y 22F1/bOhu34OnsMLeAlz0RRerl+OZrTgXbRiBTJYiVVoQzuyWI01yGEtOtCJLqxDN9ZjAzaiB5uw Gb3Ih5dHPRC6Rz2Ih/BrPIxH8Cgew/zw+qg3sQALsQhvYTGWYCmW4W28gyYsRzNa8C5asQIZrMQq tCOL1ViDHNaiA53h9WRi5W/+Xz/gK7D2omp5d44smo9XynttYTi62v5xhv3jDPvHGfaPM+wfZ9hf LbO/WmZ/tcz+apn91TLZtVj1Vsja5xTscwr2OQX7nIJ9TsHe5XF7l8ftVd6xV3nHXuWd1DNhl6yb kW3Xvf+7E/GR9ibzwww782Pk9k6Z9iHafwbtP4P2n0H7F2j/Au1foLuX0d3L6O5ltPUM+nkGfTuD lp1Be86gM8vf4legJ8vf3pet/Wjle8oKNGSBJlxGry2j0co/1yz/PHMZ3VOgewq0TqHu1ZClZcrf tlcYeW3I0iuP0yuP0yfv0CfvJAvCrmQhFiEftiZDCGFrOo2jccz/+P2N939vY3HYVfk9jZSs9if1 YVo0Op4bXRi/Gn0zfj06L34jOsL8X4rfVJ0XRGPj5dGX2OJL9msjVJ7Enm1MnInOZpcOFeg4NbM7 ukRtH6nufEndGRtvjj6r3QX7f9Z3mp7m62lleLTS5zb3bladyt8TuJIq6A3Lo6qqm6IGnm8utxtd rLUr5dnLtf3elbNl4Z2uflIW7pOFt1W++XFL2KXF9XrpjS6o/CzlCM+eXPnZytlGc4rez3DWHH3M yI90b4Q5XG3c14Sm+BZznh/mV19S+X70a9TW+eEdT8tJdEO/s5yzCdTFG+rw/LA0GhtVG+UI1KAW dRiJeoxCgjQOiBriq6ND7YNftAd+USuX2P82a6lNS632sw32sw32sw32sw32sw32sw32sw32sw32 sw32sw32sw32sw32ZA32Xg32Xg32Wg32Wg32Vg32UQ32UA32TcZSGevcMKinnFn0xK+L3jdCVo8v UkBbzP2W6DS+PtTdwfJszf2A6KCqlujEqnejM1nmmxXNdq2nrouui79V+f7D6+IJYZEd/NL41rAu fjT6aPwY5vLDq9HJKuSfqy+Mzq4uf3t77K2TvHGSfs7lzVui4/TUV46mSk8jrKcsrVSgk3ZVfL+q /H96c7XorL+ivgq8NVoGaPXMsCww7E6x/FxZ6ehhOW83i8CV8oLoCAPe7tdmHw8f7J2SO4v2Pz9U blGvza62aPlds251baXe33tiuPJEOcpqPFHyxPB7MV7+xlXttoU9lVG1eOKiyjhb6any3UxYJZ4O ofL26OG9Nur2t94Tt5X/RaIyzhZn74Yt3tuzf9br3emOjrcS+sVovRVzlBUzxjpojKr8t7/ybedD onxfXP4dp9jTdZ5MOcuafflsvbH2uLNJG700Z97dLeXvcrBO9rm7S+v73mvdutmstV4RX9bZ5ffH eGLn/ifK36Va525X5Zv7jSy8Y/WMfe+uPFy+u1m/qUprvaGnsobL7ZW/J3yI3feGTtqmj5Yp/xv4 3tDvU9mXJU/twTCr7w3N1SPCEN0zVD0qDHqiufJsq09lm+12tkePe1k1hH3/l7nrgK+i2PpnZnZn 9t7sJgQSSIAkEAgQIIBK7ypNEAEVpBfFgv2pqM+n4vPps9f3BAvqExUFBWyAoiKIgHSQ3gkQelE6 gsz3n7k3oSQQCJZv97dz5545U+7smf+cM7tzrhMiDt5jSF0C3egYWnwAqQdxdw7hPh5GiZGSTY7F yHEUpR+DlnUULdnheKghUpMpYTFKOIp7ehC9ewj9dRi5jmiNnFtsXZIYcu1GrmPIpZFji62zOOrM Fua/GQ5B9z+MHv9VL7KtPIpRfExvtbldnY0SOEpYiRIOOCG9yLY8Ri+FZrfVliRRwiHUt0Ycs5yH UMcaJ7D9fQjy8av9HcuRsgn5TZuXU6yTQCEnEe1KQp7SVMyBXuOUJc9JQTwVaWlIS0daRXzPQFol pFWG3DlOSdRQBqnl8JmBe+E7CfiWqHc5pUxZqKEMajJlpYKeBnp5Uw7oGaCjHJKWO4nCthzDkY64 Kas42sWRmuOUBKUUriRKQ/uKgzMHZaahfRzt48iV45RDenlc6aBXBE8GaJUQr2z+exClrEJbI78w GW0tTW60FJN7Fdof+YUVkFYRaZHcHL83AVciZK4k2pyEckvjt5TRe5EzjPrxu5CehvRySE9HekXQ MpBeCemV8fvwK/Q2lHAIJexzSuFKgqQlg7s07mdZ3McU/OZU8KSBpxzSy+NKB08F8ECrdCqBpzJG p7lPvu3XJEpAO0yPHUI7EtCOGLTDt32bju8VbQ8eQhsS0IYYc1dIRO9upJ8jrTe9J6J31vZ5tNUc 89mBY1sxCvpAaspCItvD5tgNiWwJm2MbJKg/pDINUtkINsdWjIY+kKiykMr2sDl2QypbwubYBunq D8lMg2Q2chKO/YpeyEIvVEMvZDlJxw6hF7LQC+Z+XoieqIyeyHRSwZcGejnwlcdnOvgq4LOiNvf0 QvRGZfRGJnQA2JCYF5pBi4iF9lACyGjs1QygR31gxjTMA3EUwCacB9t+Hmz7ebDtG8G2bwXb/hnY 9q1g27eCbd8Ks9FQ0QVYfg1s+a56qM01AbkmINcE5MosJNdUm8v4zF5qqbnfPsn7xlk8ZvQsImqI +bMqXYyzFrWjq+gC6kLXgNqNbqDGdBM9S21hxY+kO2gCTcS3SThfopm0hF6mZTjfpg2UQ/+jzYzR uyxgiTSRlWFlaDpLZVn0I7uctadlrAPrQCtYd9aTVrI+rA+tYf3Q5rXsVnY7bWAD2dO0iT3LXqWj 7HWcITYUZ5i9hTOGjWAjmc8msXksltfiF7JUXpvXY+V5Q96QZfCmvBmrxC/lLVgV3oq3YlV5G96O VePteXtWk3fiV7FavAvvyi7iPXgPVpf34X1YPd6fX8/q8xv5jawhH8BvZ434XfxedjG/nz/BWvGn +HOsC3+BD2Y9+Kv8NXYdf49/yq7nn/Op7G4+nS9h/+bL+AY2mG/h29kwvpv/zIZz6NDsQ36YH2Gj uRbEPhVcCPa5UCKGjRWBCNgEESfi2NeiuCjOvhElRWn2rSgv0tn3oqLIYD+IyiKTTRPVRRabIWqK mmyWuEBcyGaL2qIumysaikZsgWgimrOF4hLRgi0V7UUHtkJcLbqy1aK7uI6tF7eK29gOcZe4j+0S D4oH2T7xsHiY7ReDxRB2QIwWo9kh8YX4gh0W48V49qv4SkxhR8RcsZRj/hPbOWYboXlpx3VieUUn wanCazhNnCb8Uuce5wnewnnaeYd3dUY7Y/mdzpfORH6/M8eZxwc5Pzk5/FFni6P5YDfWjeWj3WJu MT7GTXBL8k/c1e4G/rm7yd3GJ7g73Z38O/dn92c+yd3j7uWT3f3ur3yKe9Q9yme4WjI+Uwop+Bzp SpfPlUrG8XkyXibxZbK0LM3XybIyjWfLdFmF58hqsgnfIZvJZlzLi2UnQbKb7CPi5Y3yWZEkn5cv iqbyP/IVcbF8Tb4mWsg35FDRUr4jh4vWcqQcKdrLMXKMuEKOlWNFB/ml/FJ0lF/Lb0UnOUlOElfL qXKa6CxnyNniGrlQLhQ95GK5QvSUq+V6ca3cKDeKm+QWuVUMkHvkfnGLPKJI3KFiVCAGqmRVTdyv LlANxTOqsWoqXlEtVRvxqmqn2omh6gp1pXhTdVbdxDDVU/UUH6g+qo/4UPVT/cQIdb26WYxUt6s7 xCfqHnWP+Ezdq/4lPlePq6fEZPWMelZMUy+pl8WP6hU1WMxUr6t3xWz1vnpfLFEfqA/EUjVCjRTL 1Bg1RqxQ49Q0sVLNVYvEDrVKZYu9arv6TRxW2nMd31Ne2Cnh3erd6pTybvfudJK8e7yBThnvPu8+ J8V7wHvASfUGeY84ad7L3stOee+/3itOuvea94ZT0Xvbe9up7I3wRjlVvLHeeCfLm+RNcmp5U7wp zgXedO9H50JvjjfPqe0t8H5y6nmLvcVOA2+Zt8xp6K3ysp1G3k5vl3Ox94v3i3Opt8/b57QI1Q81 cFqGGoUaOa1DTUNNnTahtqG2zmWh9qH2TttQh1AHp12oc6iLc3moW6iHc0WoT6if0ynUP9TfuTr8 Wvh/Tufw8PBwp1d4ZHik0zs8OjzG6RP+NPyp0y/8efgL59rwuPA4p3/4m/A3zvXhSeFJzg3h78NT nRvDc8J7nFtiZEys81JMmZh05/WYijHVnGExzWL6OiNjBsQscWbHLIvZ7DaMOeo7bls/0a/vXuW3 93u79/l/859xn/Lf8ke77/mf+uPcsf6X/gT3a/8bf6I70Z/kT3In+9/7s9zv/bn+Ine2v8Rf4i70 l/kr3EX+Kn+ju9Tf5G9y1/nb/N1utr/H3+Nu9g/4h9wt/m8BuduDUBDr7g6KB0nu/iAlSHWPBuWC 8u6xoEKQISmoHFSWIsgM6konaBA0lcWD5sElMiloEbSSZYI2QRuZGrQNLpdpwRXBVTI96BL0lFWC 3kFvWTPoG1wrawX9g5vlRcGtwa2yYTA1mCobBdODWbJxMDdYKC8OlgbLZetgZbBKtg3WBmvl5UF2 kC3bBxuCzfKKYGuwU14V2yb2atk1tmtsL3l9bL/Y6+QtcU3imsvbiYcmmX9EjtkTT1SF0uh3OfRm vZnK4SLo0AWlH9P36hH6Y8QexHWNbqcn6vcR22ZT1+sVCNdFeffny73NXHoHzl15xLj8bcB1f6Et bYfrkxO+r9FrCDrwGfMcwLVc70XUx7zdDXY96Zy81N15sS0F5J2u1+nt+lu9DJ9z9azC2lfo4aHM KZHacH6aW+fxVuTVvBPXar0WvXZId6EQudAryuelHiusIr1b79N70T/ZeSQFqv2mP9IfodfMHVxZ YF5Tdw5q361X46tLYfRZE8Qyoy1fQA1wkbkKzD9Im3c1SPfG1VTX1AP1HSf19Ka8WL76IWszIY9b 9Gw9C23YpeeSjKZsPYVzTqF9sMa23sS+iPbJdj0e1nwkdVU+/gM4D+kjeh44W5p/aYf+5kRk0/ZI znHJicj+Sblz9AZt9lkR7Ffzfa79x3TIXh7HrlPznKbdJ/WK/uCUX3R2R+ReHbDhRr2RPFxnrvUI rsPRLzWp3hl5h+gPEe7QP551e07MvUl/hnBfpJ9OSikQf07iOKi/MrKF2CQjpyeldS009y+4PrOI tPzU3IUf+mUjTXpkgaPGO4v8u/UEezd2nGvNufmP4+w5530u+jmtCHm/seHSAntMFq090aNioXWb ecHML0cwvrafY+n+GVOr4LrS1hFBxezIGU0taG7NxJmGM/OkFg634bzIeYbcFxSYe68NMQPro/kx JY/rmN4KTNyKEZfbH3YG0O/ZcDkwcw3w5iwOPZhKAZdqU0fEv7SUPZidt5y+7pNyv4hZJI5aU1/E 7dhH3m36l4LmzlNymll4KHKHqCTdnUedor8m9/Tzar6R4uJ33wT6KJtq5ogjuTiuj+bLfeSE+LMY u8mUTk8jfqmlfAct5kc95rR15xRMP4Z69DjdRrfU/XXrKO/b+XI/Gv08eY7k1Iv+Bbuf6Hl6AfPq S/QxpHQ0jYc0fk0T6UK7IlCXptASIPByyqF2di2gK+vL+tLdsMCvpHuM7U33Gqub7uM389vo77Cf l9FDfCXfQA/Dit5CT/BtfDs9aWxpepof4AfpWX6EH6HnjS1NLxhbml4ytjT9R6SJNHpV9BS96DXR V/SjN5xxzjh6E1aoprfckm5Jmi2/k9/RHDld/khzZY7cRPNVWIXpJ2N30UJjd9Ey1UP1pNXG7qK1 sLuupXXG7qL1xu6iLcbuom3G7qLtxu6iw8buomOwuwYzgsU1lEn1lnqXhYzdxeKM3cWKGbuLxavR agwrYewulmjsLlYJdtdvLAsWV5h18GK9YqyHV8JLZL29JK806+eleGmsv1feq8Bu9Cp5VdjNXlWv OrvNq+ldwO70HvMeZ3fDyvqIDYQ1NZfdD2tqAXvA2EvsH8aGYQ8aG4Y9FDM5Zgn7p7FM2BC/i9+b fW1sCfaDsQ3YVGMbsIXGNmDLjW3AVhnbgK01tgFbZ2wDtsHYBmyrsQ3Yz8Y2YL8Y24DtM7YBO2L0 fnbU6P3sN6P3cx7bIbYTV7E9YnvxcFzTuObcrO0utRLDrMRwSMxg6CRD6HXI8xv0Hijv41Q0nEZi DvoI8iStPEnI0zcYbd9CqsJWqsKQqhmgz6RFFEOLyfhqWoIzgJytolhaTeupnF1/Kk+b6ReM8z04 02kvHaQKdAhnRTpMv1EGHYNExluJTLESKaxE+lYifUjkrVSM3wa59K1cFodcrqaSfA1fQyX4Wp5N pfh6vp6S+AbIa1krr2WsvCZZeU208lraymsJrrmmEgKKOyVAajlCHJQI2VWIe8KjZBGCHCdYOS4D Oe5JlUQvSHNlSHNfxPtBpitbmU6BTK8m5qxxcog7m5zNJJ0tzi6KcXY7+yjV2e8coDjnoHOU0pzf IP0ZVvrLW+lPsdKfYqU/xUp/CqT/CkpQHVQHilEdVUdyVCeMBxfjoTMoXVQXUK5R15BSXVVX8lQ3 jJMKGCc9kLcnRkvIjpYYs0pBgboWYyYWY+YGKq9uVDdRnBqgBlCGuhmjKN6Oong7ihhG0b3IdZ/6 B3geVA+B8rB6mLgapB5BLf9U/0TJj2KkxWCk/Ru5nlBPgP6kehL8T2HsBXbsMbPmAZ7/qP+i3lfU YKS+rl4H5Q31BnINVUPB85Z6B5Rhahha8q56FxSMTwqb8YlyRqgRyDVSjQR9tBqNcsaoMeAcp8aB Ml59hbwT1AT0w9fqO/TMJPUD2jlVTUWfTFPT0Kq5aj5au0AtQpmr1Frwr1PZKHm9ykFpm9Q2Kqe2 q13ok91qL+rap/ZTujqgIJPqkDpMFdWv6lfUeET9hjZrpam8Z5SxCh7zGGV43OPEICYOhT3Xcynw pCcp1lOeohIeDgp5OCneC3thijFoQikGTRACTRACTRACTRACTRACTRACTRACTRACTVDLHG8Owrne XOIGU8gxmELMYAr5wJTvEU4JT6ViBllIAFnKku+n+KkU+Gl+fSpmUAZ0oAwlA2UyqURQNahKCUG1 oBoFQfWgOpUMsoIspNYIalBSUDOoSWWDWsFFiNcOaoO/TlAHPHWDuuBpEDRAvGHQiEoHjYPG4GkS NAVP86A5Ui8OLqEYIFdL0FsFrUAHfiFsG7RF2C64nIoDxa6gUkGHoCMlBp2CTuC8MrgKNXYJuoHS PeiJkoFuqKVv0Bdhv+Ba8PQPrkebbwhuQDk3BjchPiAYAP6bg5sRB/aBDuwDZUOwEbXkBJuQa3Ow GSVvDbahzO3BTko0aEjCoCEVM2hIxYBYo6Jo+CJOkYeGryL+BnBQWBx0gYIfIz6avkT4FU2waDgJ 8e+BgYKmAgcFcHAxcHMJ8FXYtXdlcVBYHEywOJhocTBkcbCkxcFSFgeTLA4mWxyMYXEsjnzWnXVH eCsD6rE72F0I72H3IHyaPQ0c7MQ7Ebco6QEl+yM0KBm2KOlZlAwsJpbgO/gOoKfBwXiLg8X5b/w3 irUIGCcc4VA8sM9DPCzCVEx0F92Bej0EMMViX1mLfamit+gNeh/RB3SDg2UtDqaKa8V1VDoPBzeT AALuIwXsO0ohi3rJFvUSzcoqRml71Z6ERTcFXOuC0CCasIjmWkQrpbqr7qAYRBOqt4IEA9f6gtNg WaLFspDFsmRg2S0Y4bep2xDerm4H553qToR3qbsQGlxTFtdCUVwbpAaB8ghwzbWIptRj6jGLa4+D 3+CaAq49jXgE0Z5TzyNucE1ZXBMW10JqiBqCXK+q10AxGKcsxsVEMe5N9SboBumURbpki3FCfQh0 E1F0+0h9hPjHCvOrGqVGgdPgnbB4l3wC3gmLdwp4NxVxg3FKTVezEZ+rViI0GKeAcTmIG3RLsOiW aNEtZNGtpEW3Uhbdkiy6JVt0i1HH1DHkMhiXaDGulMW45CjGKWCZsFgW4/mej7hFpfDE8HfkhSeH JyOcEp5C4fBUYFA4PD08HZRZ4VnkWTziMcti1hK3yFIiuAiYEhfUC+pTvMWROIsgJYAgTRBvGjSj WGBHC1AMdhQLLgsuA6Vd0B44ZfAi3uJFCSBFV8QNUhQPegW9wGMwokRwXXAd6NcDI4oDI25ECQYj 4i1GxFmMKGYxIh4YsQFl5gQ5yLU12Ar+bUCHeIsOnHjVYmaNpsZn9a+k5nT16bT5/8+HXge7c1Nk nUivzb8qErWeClyrK6TkbL1S77b24hS7/rDCUnPsSsKC6LqsKXuDtSKz9SK9yHJE69ILz1h6dB1P Dzj3lv1+h26nP7ef+VaeC+ReByv9h7Ozds9YzsaT4+jTjbmrgnoOenUZenO1XqCX5nEdv38JebQF epeeBw08CTmilmJktfFPOcJ57Thx/dmnbhFavvW1TZHVipNou/RC/Nbduauqv+8RWe3Sy3Jl7cT6 T2wzWpFvBf10Y+l3atk5j0b9nn7Hfh5Fa2fYa4gegc+Z0fToWoddndyv5xe2XltgHRv0RkhidA0r EjPrI3mr1v9F+vbICrVeD+4Z0X49qS598CxqOpi7bvb7Hnrf8bboA+ir/fpXuzJ90urOOa8E/gVH rkRiZG89M2cu3x/YlnzPOs7I/Zkeqz8xa/RUUr+tx1raOj3bfq7O4zrj3HCakpcCLXbrxZE7iNgy O3ZX2PlopOXYZVPmmpVqnJujq4zRuuwIKkOXRr99p2fqb8GRTG3x+b2lfRCdwR7B1ePcW3jG1kdm 6E/yvvfTw/Tt+kn7JO0fedRGoIFH/3IqkmM85rvHmIGn6Flmlv6d23rAjh8reQZh8o9zvev4+viZ JfTcpOcPOOzTYv3yqc+H9X0FPc3Qa4AZG4qoLy01ueycHUS+W3KQG+qHLfUwiciTtbx8pq5YqnVK abtQ3i5bhovPdblUG5pniUvOvYUnlZ93X04sKfr0MSc6iuZGn0meJHkW/3ef+jTRPKM/vxad63Hq 8778a/hR+tMFUotwh8/20E+cA3OqzfGUfsh+mqfMX6AvvwCOTjCf0RJz5/fIM9kNp3/ycIZWjdJj MGePjn6boT+Kju4ZuGZbHeOgkf1oOzbp2dFxH6nrlLcu9Pdo4WSL81lAoc+i1B9O4tEGrYvQ0sV0 4pPvCHJmW7mz5UVkzbZ7juWdn5uLzBOp+RZdb7LfJunp+m/6R32/fle/DqyMIm0kRzR+AD09sAit vEcP1G/qOxGbpbcg9jfEnoMV9KYej54Zpm8Bir8N2iLbW1/o/0UkNlpXmcick1faFr0EeG7GYm3M XNExGbUJjA7zq42d83Nn21s7T0Tp3Hts48a6i9o+tpa15mlc5IlctK6s43fizzpOfEPFtA49s7eQ WcZIwb4/ul35atV5sQNWp12Kzw1nzDE5dwwXscY3dXc9SA+x8TmQl2F6oo1vioxloxvpx3B9WvQ6 bClt9D/PK/8GvROXnSMgfwbV8qypiLaCOW0lrrPSbs9Qz6Ii51wQfXqebd9NWxN5e8VijJnx1kW5 /nTZP/XQN+vr9dTcN4/0P6C3zDRrJlb7HasPIe05/ZDO0pl6pG6Ce//3Akt5rdB6Iu94pJ93e984 6dtn51veaWr573nmzwFOL4nMqxi1K/KlbwJ1m158fAXmrzn0PIySDZFWQBtbXsC8uBwSkF30cfD7 HGjDM3TC+0GY7775K9uT/4Bd9XxkdcR+ewBjZ3MEO/P0h/WwA5/TL+nD0IRWFvxWSuH9fLr3Gn/f w+I9pALj/7xsv7x3jv6AQ68/sZ7zm531hefbmkLKXxvRi9Cf5zUjnf/acKE1bMLMWugbU3/1cWYt 6ByOfO96n2X9+daazyLPLpPreM6zHVlFqevPPs53zbMozxVgS2yOalJubhl5K/3+6XvX1pVMd5p3 zs+5zqKse289/vQlr/7I+7K/FVoXp9bnXuNfcpQsSqbcGfKc8kw2uY7P//a95Z2wjApZ8y1KXX/M AXtz3+ne4DyB6zzsuN/tiCkkvST1OP6k7q84zHyKEbbyzPsX7HOmP9l+P9sdFafJPSH6mR29phbA lGnf2E4omp5l3wnPzs0Zidkr943zSI2NiE55K/ykunLXIvNyDy+gNebN8gvMe+e5v+qc2jlUT8A5 PPrNxuwzjAnRXxFpwQX52lmEuvLyFkHLhsVv3lrIW+22+vN+koWtW0fr+oM10AKPE/cgREYxLySH oibmZa9zPYr0vGO9fd6Rp+nZUbC98HEVrSvlFOp83J/5eiaVokw9LbpSOjW6ggQJ0h3PvYVnbMV0 G47N+95V3w8b8RWzO0Dfnke9VL9wmgLcAsrceTbzRlEOqztFLNc9einG/nyEq06YY3eA/jOZdbvb 7PfPgbi99Gz8qun4TbP19VG+108qdZW+sght6aav1G/pq6LfbEzfbGMf6+H6Hrs6NSFyf/V4nF9E 76KpqyTVtE88H9C3Wpp5n+EtWOJv6U9w13PMMwlLP2ndRR/RQ4vQziFApim5vxixEQjNzjPzNlOO HqM/xN2abBPt/qtc2z5aV+1zr/HPPgrfyXneNWyLjFfcgcOFc5/FkQx8SqYyprchobjwLRXjfDbO mbhW6ToYcz0pTmec1I72xyKoEd3Fqr/R8y3OmR2W5rl+1E48Pp7z/ZJvbfgAMLWMjdXV3VHXFRgv JXSDkzgH4eqhO2Ps2HcAgEtr9Ao9Sr8HWd2md0cthWpU2eJzdcsz+dy7Qn8HTTlXAs27K5Nxrjmu B+nu9qM7daEGVN/WVe3UunS8Jp2iFdBgin5Mf41rkP6X/ZyQ++wwesRa/nuL0M6B+l79fPT5uY/Y 3TifA/15m/qphmWhx+EOHLfVg6LW9TsdPF+8sDlRQY8S4J1aiC+W7lFfLI/SZdbDSn+WyqrRbda3 yj+sb5WHWC/Wix5mA9gAGmS9qjzCHmJP07/Ys2wIvWS8qtCbxqsKGZ8qb9HbxqsK/Y9NZvNoGK/F L6BPeW1elz43XlVoHG/Gm9F441WFvuSX8XY0gd/F76Zv+f387/Qdf5H/hybz9/h7NJV/wEfTND6O j6e5/Cv+Fc3n3/CJtID/wKfSIj6Dz6AlfA6fS0v5fL6AlvOFfCGt5Ev4ElplfKLQalFMFKc1xhsK ZRtvKLRJVBQVaYvxhkJbjQcU2iEaiUa0SzQRTWm3aC6a0y+ihWhBe0R30YP2it6iD+2374kfNH5K 6LDxU8IC46eEZTjjnYksy/gpYXWMbxJW3/gmYQ3cBDeRNXST3BTW2HgoYZcYDyXsMuOhhF1hPJSw DsZDCetoPJSwK42HEtbV1dJl3YxXEtbXeCVhA4xXEvY345WE3WW8krB7jVcS9pDxSsJeNF5J2EvG KwkbZrySsBHGKwmbZ7ySsJ+MVxK22HglYUuMVxK2TI6UH7M1xisJyzZeSdh645WEbTBeSdhG45WE bTZeSdgW45WEbTNeSdgu45WE7TZeSdh+45WEHTFeSdhR45WEHTNeSTg3Xkm4Z7yS8BjjlYSnGq8k vIrxSsKrmTfKeU0v8AJey4v3ivMLvFJeKX6RV8Yry2t75bxyvK5X0cvg9bxML5M38LK8Gryh8RrC GxuvIbyJ8RrCmxuvIfwS4zWEX2q8hvAW3hPeE7yV8R3CWxvfIbyN8R3C2xrfIby997E3il9hfIfw jt4EbwK/yngQ4VcbDyK8s/Egwrt487x5vKv3k/cT7+Yt9pbw7saDCO9pPIjwXsaDCL/OeBDh1xvf IfwG4zuE32R8h/ABxncIv9n4DuG3GN8h/FbjO4TfZnyH8DuM7xB+l/Edwgca3yH8XuM7hD9sfIHw QcYXCH/f+ALho40vED7O+ALhE2NejxnB15l3z/nPxhcIP+S39zsLZryAiLD/jj9aZBgvIOIi4wVE NDBeQERj4wVENDNeQERz4wVEtDVeQEQn4wVEXGm8gIjOxguI6O1v8beIPsYXiOjr/+L/Im7w9/uH xI3GF4i4xfgCEXcYXyBiYFA6KC0eDMoGqeIh4xFEPGI8gohHjUcQ8bjx5CH+bTx5iCeMJw/xrPHk IV42njzEK8aThxgS2yb2CvFq7JWxV4u3Y7vGdhfDjPcO8X5ck7gm4sO4VnGtxQjiQA8HWF4XaFuM GMXjFFQcWrNDSZjZXCpLGaBXwqkwQ1WDblMdiBYCdjWCDdEY828MNbVeIg26+RbdAqBbF+S6Bmcc MK4Xyu5N11E96g+8qw+8uwv13I2zAd1D91MJ+jvOBHqAHqZEGgQ0LAk0jKVSdj9LEisGZKwMZKwM ShVWhTJZJqsKejVgZabFyqoWK6tarKxmsbKaxcrqwMonKIs9yZ5E3qeAm0nAzReoBnuRvUI12WBg aFWLoVUthla1GJoJDB2B+EggaSaQdCo1Y9PYNLqITWezqDabDWytY7GVA1trI6wDhJUWYWMtwnKL sLEWYYtbhG1oEbaKRdhaFmGTgbAjqCwfyUdSaf4RH0WpfDQwN81ibprF3BRg7jcIvwXylrHIW94i b2kg7xyEc4G/KcDf+QgXAIXLWBQuY1G4nEXhdIvCIaBwElUUySKZMkRpIHIji8gZFpErAJErI6wC XE63uFzJ4nIF4HIThE2BzukWndMtOlewO32a2J0+Te3uniZ2d09Ti9SNgdSDqK7zCPCaAa9fpMB5 yRlMFzhDnFcp3nnNeYsudN523qFEg+NUCjg+nqoZr1Nk0ZxqGzSnsEFzhAluAtV3E91EqmownaoB 09eQcNe6aynFXeeuo8DNdrPJcde7G8gF1m8CZbO7GZQt7hZS7lZ3K3nuNncblTBzAMWYOQA8e9w9 FOfudfdSMcwE+4m5B9yDqOuQe5ji3V/dXynRzA2oS7uaSkrjYKCOZJJRWHLJqZrxZ4W4Ix3EXelS XcwfigLpSZ/iZSAxsmScjCOGGSWePFlcFqcYWUImgCdRJpKQJWVJlFxKlkLJSTIJPJh1KA6zTgry pso05E2XFcBfUWZQMVlJVkbJVWQV5K0mqyGsLqujhCyZBf4asgb4a8oLwX+RvIgSZW1ZG/Q6sg45 sq6sS76sJ+uj/AayAfI2lA1RWiPZCDyNZWPkbSKb4BdhhkNdF8uLQb9EtgBnS9kSJbSSbcmV7WQH cHaUHUnJTrIT2txN9sDv6in7oPwb5c2o/RZ5K2q5Td6Jcv4mB1I9ea/8O9WXD8iHUeMg+Qg1kP+U j1IJ+S/5GCXIx+XjaO2/5ZP4LU/Jp1HOM/IZlPCsfBYlPC+fR/kvyBeQ+qKERJlZlpLMLEuZmGXf oCw5VA6l6phr3wF9mBxGpeS78j2qKt+X71NtOVwORw+PlCMRfiQ/xv3CTIxcmIkRYiYG/9fya5Tw jfwWFMzH4MR8DPoMOROUWXI21TCzMuiL5WLQl8jloK+QK1D+arkada2Ra1H7OrmOKstsmU015Xq5 HvyYucG/RW5BCVvlVvDvkfvAuV/uB+cRqamUMg8oMs1cTtUxl5elLJWiUilJpal0qqEqqMpUU1VR 1agq5vgLqba6SNWmZqqOqksXqXqqHij1VUOqg7m/MXiaqCZIbaqagt5StUSZrVQrpLZWrUFpo9qg ZLPXjBnNgKoZzQAhNAOE0AwQQjNACM0AITQDhNAMEEIzIOtPjKw/MYTQDKiy0QwQh2ZAtY1mAE5o BqBAM0AIzYBqGM2AakIz+Bg8o7xRVAf6wVgKvHHeePBAS0AuaAmgQ0sA53RvOsIfvR9Bga6AeqEr gHOxt5iyvCXeEvBDY6Dq0BhWgbLaW43UNV424ju9nahll7eLmhkdgrKgQ9SnUqEGoQaUZDQJyjSa BOLQJBBCk0AITQL0zqHOiHcJdaEa0Ce6Ue1Q91B3qh7qEepBdaBb9EFpfUN9qXKoX6gf4tAzKAt6 xmsUG349/DrJ8BvhNxAfGh6K+JvhNxF/K/w/Km60EFDmhLcRD28P7yFpdBHiRhehWKOLUHHoIq1B aRPTlxoajYRqRXbDGY2EuNFIEEIjQfiO/w6V9of5wyjFf9d/l+L89/z3qKz/vv8+lfOH+8Mpzf/A /4CE/6H/EeIf+x+Df5Q/Cjyj/dHg+dT/FPHP/M+pvP+F/wV4xvrjwPOl/yVSv/InUBloOd+CPtGf CDp0HYTf+98jnOL/QMn+VH8apfrT/R/BOcOfAc6Z/izUONfHfOT/5C9CydCHUMsyfxnC5f4K8Kzy V6PNa/w1KGetvw7xbD8b/Ov99Yhv8DegzI3+RqRCc6IKRnOiEDSnbZThb/e3UyN/h78bcWhRoO/3 9yM84B+kSv4h/xDov/nHqKKvYTpmQK8KU8UgJvApPcABSmwQS42gaSWCUjJIokpG36IQ9K2yCFOC VPBA60JqhaAiwowgg7KM7oVyoHtRGeheP1JyMCOYSWnBrAC/F3rYXJQzL8CvDn4KfqKywcJgIShL g2UobXmwHDVCPwMF+hlVMvoZFTf6GXGjnyGEfkbc6GdU3Ohn0LY4z7L62aVWP+NWM5NRPSyigRl9 y7f6ltkr1Q2h0bRaWE2rldW0illNq43VtBKsppVoNa2SVtMqdcIeZtfuYVZ2D7Nr9zC7dg9zyO5h du0eZtfuYY6xe5hdu4fZtXuYXbuHObB7mF27hzniy8G1e5hb2j3Mre0e5ni7h/kyu4e5rd3D3M7u Yb7c7mFOYpzFUDL0vwBhMZYMras0Kw2ty+h/daH/daD6rCO7mjqwzgwj0+p8DdgN7AaqwwaygQjv ZQ9QQ/YgexDxh6D5NYLm9xTiz7BnwG/0vzrQ/4ZQE2h+Q6kpdL4vEI5lY6HnjWPfIdXofFdZna+5 1fkutjrfJdD5apGwOp84QdsT0PYutdreZdD22lmdz+yyduwu6zi7yzrO7rIuYXdZx1mNsL3VCOvx p/jT1Nh4I6WOVi8sbbXATD6Gj6HK/EtogeWt/lfB6n8ZfBafBU3RaH5p/Cf+E+iLoe2l2Z3bZfhy vho65Vq+FqHZxV3VeraowjfyHFA2880IjX+LsnZ3dzrfyXchbvZ4V+S/8D2Im53elfgRfvT/WDsD qDbyet//Z5IMgSaU7XZZlmVZlkVkESvb5SFSZCnbZRFZRBZrrbUEGkIImZmQTEISQjIJIYTa28PW vtpba+VhRazdyuX0cruIvYgVexFrrdjLq8hFrFg5nIqIvFp57Pv9f2G7XfXpvnPemfP95M9/Zv6Z zPzz/39/OTM/oEyf936K3WDfIkn41HeKglGwUKbPfqcpVAqID/AJ8BR8AjxVsUWxBWq2guPMQseZ jY5zJzrOCsWTiiSop74zS/Es+M4PKtLBd2ah79yhyFRkQhkW4POKF8jzilzFh6Gcp8gjH1B8RJEP ZepKP6QoAFeapXhR8SK0T11pFvrRT6IfrUI/+kn0o1XoRF8CD3qCaMB9nqH/cxN8Z7yyV/kGeQLd Z65yCNznR8B9XiG7lN9XTpIX0YPufui5dBU+l67F59IfwefSy9GVlqArLcRn1F9Bb5qHTpRDD8qh B9Wg++TQfcar7qrugtdcVv0eaqjjfAwdZwk6zjh0nPHoOB9Xbag2wDFQT/kSekoOPWUcesqX0FOy XBx4Sg7dJIdu8nF0jS+hX+TQKcahU3wc3eFL6As59IXx6AtfAi/4YVhLXWAcusCXNv1fIVcIWxZx RbAldYEvof/j0O1x6PA4dHV70NWVoKuLQ1dXiq5uO7q6x9DVxaOrexzd2+PcCe4E2cV9kfsieCDq 3vK4r3BfIflcD9cD9dS3vYC+rZDr5/pJMTq2HO48OLZ87g0Orhr6tl3cAHeRvAju7RLUvMkNk0+g b9vFXeYuw17UveVw3+W+C/Vj3Bjs+z0O5ir0c7no53ZxP+KuQQs/5uB7zf2E+wlsP8VNwTbU2+Wi t9uF3m43N8PNQAvU4RWiw8tBh7cLHd5H0eEVo8N7gfsN9xtY+3vu99AO9XYvcGvcfaihDi8XHV5e FBvFkk9ERUdBDB21LSoBSN3eLnB7qVCmPu+j6PMKo7KissHDUbe3G93ea+j2itDhFaLDew0d3u6o F6NeJE9EFUcVA6nPK0aftzuqLKoM2qTZE7SYPUGF2RO0mD1Bi9kTVJg9IRqzJ5Rh9gQVZk9QRX0u 6nPw7jSHggpzKGgxh8IrmEPhEcyhUI45FBIwh0IC5lBQYQ4FFeZQUGEOBS3mUHjkoRwKWsyhEMkK o8UcCgmYQ0GFORS0mENB9VAOBRXmUNBiDgUV5lB4BHMoJGAOBRXmUNBiDoWEh3IoqDCHghZzKJRj DgUV5lBQPZRDQYU5FLZgDgUt5lBQYQ6F8odyKKgwh4IWcyioMIeCFnMoqDCHggpzKGgxh4IKcyi8 jDkUXsEcCo9gDoWPYQ6FMsyh8HHMoVCOORQSMIeCCnMovII5FMowh0L5QzkUVJhDIQFzKKjAqT9G 8sCjPw1MUT9PCtGLv6jm1TzZBY5cIPnqZnUzyVVb1TbwvpJagnqH2kGeQI+eo3aqXQR/w4OyR+0F Ur++W+1X+6GdkDoEPKL+J+BR9evQ2jH1F2Cb4+rj5AX1fwcfv0v9ZfWXoZ76+I+qv6b+GhxJv7of to9knaHOfjc4+wF4F+rsNep/U1+CFt5Uvwl7fVv9bVKk/o76O1DzPfX34fjH1ePQAnX2T2CWmhz0 9/nqKfUUkLr8YnT5+eqfq39O8tHl56C/36X+tfrXUPNb9W/h3anX341e/zX179TLsBd1/LvUf1D/ Abb5o3qN5KP7fzE6Pzof3Dx1/3nRu6N3k49Gl0SXkE9EvxL9CinESCA/uiK6ArahkUBedGV0JZRf g0ggP/rT0Z+G7Wk8sBvjgSKMB4qjD0QfIE9Efy76IGxZA1FBbnRddB3UGKIN5EWICk5tRgI0BjgD MUAPRgK9Mb1Q842Yb5CCmIGYAeBgzCDwYsxF4FDMEHA4ZhhIs2ZsxawZWzFrxqOYNeNRzJqxFbNm bMWIQoExw6tbarcYyYe3dG/5IinYcm7LKKnEnBpKjCKUEDk0gzunscFzGBu8X/NNjA2+pRkAn03j gacxEngOIoF/hfKQ5t/Ai49oRqCGxgDPaL6r+S7UfE/zfXDn1Pc/i77/OfT97wfffx1qfgLu//3o /t+n+ZnmZ7A99f3PaX6umYG1vwDf/z7w/f8FrVHf/yz6/qfR8T+j+bXm1yRL8xvNb4C/1fwWSH3/ TvT9FZrfge//kGZZswL1f9Cskh3o/j+E7v95dP87NX/S/Alq7mv+TD6gWdesw5Zvad4iO8FUMuDj Wa2CZGmVWiX5gDYGYoMdGBXsxKigQhunfQTWbtNuh3oaGzyvfUL7BGxJo4Kd2qe1KVD/jDYV6p/V PgutpUGEkIQRwg5tujadfAjjhGxthjYD1j6n/SCspXlMMjFDUoY2W7sTamhOkxRtjjYXyjSzSRpm NknBzCaZmNkkBTObPIUZkpK0L2lfAtIsJ5nal7UvQ5nmOknVvqIthTLNePIUZktKwrwnT2K2pCTM fpKG2U8yMVtShrZa+ynMmbQP6j+j/QzU0Hwo6ZgP5SntQa0O1tKsKJmYFSUNs6KkY1aUVK1Ra4S1 NDdKGuZGScHcKKnaAe0AREE0LnoW4qIfkESIi6A/aH+k/RFEPtcgFnoWY6HnMQqqgCjo51Ce0c7C GaOx0PPaOe0clGmOlTTMsfIk5ljJxBwr6ZhjJQ1zrCgJ8+RKkgxWVKM4TP6LEJ0V5AR5QUHQYVD3 g1fGqoPXE6DToF5QP+gC6CJoGDQKGgdNgm6ApkGzoNugRdAyaI2wARlFdOsoNhACHSGklgXB0F0b C9oOSgSlgNJBWZHjqt0ZOYbavP/LayG0dQxe90SE+5SBKkF7QQdAdZHjrTVuvgogCeQGyZG2Nl/Z wEnQGfjsBpAZymcf1EV0DjSwWTcEGtmsH9vU1U1dA02BboHmQAub2y7h9qQ2FDkOep5q6bk4huc8 su0K6B7UnQTRbc+CzoEGQEOb772x+VlHQGOgq5uf7VrkeNqVm4qBuinQLfg8VpBzc3/a9hxoAbQE WgHR94R265Qg2K8uDhQPSgKlbr5mvLN93Q5QzuZrzOZ+OQ+tzwcVgUpA5aAq0L53Xun1qzsI0oNM IMvf+Pvdr2w7PSYHyBP5bHUBUHjzev8/CPv8Q6o7uqnjoFOgHlAf6DxocLOevl4CXQZdAU08tP91 FNtOz9dN0ExEf/U+81TKR2pMIvGdqVVbhoCxlhHkGHC75Sow0XINmGKZAqZbbgGzLHO+M3Qvf2bt TsuCP7vGInK+szUOUeM7V5tnWUKuPCgXWu75ztG1/twaj7jNN1C7x7LhG4iUNxkQE3xDtWXNSmBl c8yDchmW9zbHAQ80xwPrmpOAxuZU3xDdy18ATIZyWEzzjdQKzRlAqXkH0N2c4xuh9f7imqNipm+s Vm7OB4aai/ylNcfFbN/V2iPNJcBjzeXIKuDJ5n3AM80HgWeb9cBzzSbgQLPFd5Xu5a+oHWp2yKaa U2Ku71rtSLPHd62mRyzwTVH6q4HFvlu1Y80B4NXmsO8WrfHvr71G6yNra/rEUt9czXmxwrdQO9V8 FHgLOdd83LdA6/06pKFmUKz2LdUuNJ8CLjX3AFewfK+5D7jRfN63VKdsHgTGNF96wLjmy35zXXzz Fb+15pK437dSl9Q84VvB1u5t1qQ2XwdmUNIav7PmsqjzbdTtaL4JzGmeQUKZ1vu9NVdEg6ysy2+e l5W07A/WXGm+A+UJ0SzH1BU13wWWNK8Cy7Fc1XwfuM9KgAetHFBv1QBN1m1YTpBj6L7+wzXXRasc V3NTdMrxdRZrMtCB9FiT/d11AWuaHF8zI3rlpJp5MQjHELZmAo9as5G0fNyaC0dyRzwsp9adshY8 YI+1WE6tuSt2yxlNjtZcZAGyGOhpLQUGWiuA4dZq4NHW/cDjrTo5g+7VOdt0qtXQebtmVTwh76i5 L56Wc5p6Ws3AvlYrkpbPtzrlHLq2c1FHxF7fVNNgqxd4SeztXI5Qx4n9cn7T5dYg8jDwCpavYHmi tRt4vfUE8GbraeBMa6+cT/fqXANegLJGvCgXNc239gPvtF4A3m2FGlrfua7bJg7LJU2rrZT3W0fD rC5BHJXLzaR1nNJcgOVJINd6A6hpnQZua50FJrTeBia3LsrldK+w2pzWuhyO1SXrDHKVObN1Ta7S pYnj8j7K9jhdpjgpHzRnt64Dcz2sfJDWdI5H6jeZLd6Q9bpccVo2mQs86gcs9sTKJlof3o5M1BWI s7LFXOrZjkx8UK7wpACrPenA/Z4soM6zE2jw5AHNnsJwitnq2ePP1hWLt2WH2ekpC6dja57NGq+n EhikpDWdw7pScVEOmA979iIPvF2m9eEsXYW4LIfN3Z46OUzL4Z3mEx5jOE9XLa7JR82n4cwDPcKD cq9HAvZ73MALHhl40RMCDnuOAEc9x+SjdN9woW6/uC4f1+ksrHzKPO45+Rec9JyRT+kMFrXcozNb YuU+8w3PWeS5B+Vpz4Dcp7NatsvnzbOeoQe87RmRz+uclkR5sK7PWgo8b60ADmL5krUaeNm6H3jF qgNOWA3A61azPEj38p+ou2m1+k/rvJYU+ZIuaEmXL9fNWJ3AeeQd5F2rV75M1/p7dYctWfIV3WFr kJKW61ath+UZXbdlpzxRd9/ajTwBnMfyPC0fItbTQM7aC9RY+4HbrBfkCbqXv193wpInX9edthTK Nw8lWC8Ck63DwDTrKDDTOi7f1PVa9sgzh7KRudZJ/wVdv6VMnj9UYL2BnAYWW2fleV2/9TaUS62L wArrMrDaukbrLWX+i4f2W9ehRmdj/cO6C5ZK+c4hg00NNNti5Tu6i5a9cBWA/tFDVtt2/7hu2HIA tnfaEoFeWwql5QC048V6pG7UUiff1Y1bjHBsQVu6PFM3SHnosC0LzgzU+ycPddt2+m9geVo3aRHk 1UMnbHnIQnkVtgceOm3bA+y1lQH7bZXAC7a9wIu2A8BhW51/9tCozei/De1I8n1dr00AjlvcwBsW GY5n3CYBJylpjX9RN20J+cmhGzY3cPodYv3yoVmb7F87dNsW8q/rZi1H/NyhRRuQlgOsbtZ2DMq3 Lcfwc51EngEuY3nNdha4bjsnz+hZ2wBQbRsCxtpGgNttY/DZYV/4vIuWk36Nbtlyxr9Nn2i7CkxB piOzbNf823RrlrP+BN265Zw/Wb/TWgHMs00BC5F7bLf8ybWsZcCfpi+zzQErkXttC8ADtqWAmnqS QKy+zrYC/gS8QWC73mi75xvSC7YNoCQpIzN4IJHOg4EUvVuK8S3pZSnOt0RnokC6PiTF01lJSgLC XBPI0h+RUmWl/piUISvp9yWwU39S2gHfHei3gTz9GSlHntCflfKB56QieV4/YCkLFNLrG9ijH5JK 5FXdpFQOhPMQKNOPSFX0nEj7gJFPOiYdBF6V9P5kOuOE95gXPWNyBh35w2XmZc9VOd+85rkGXPdM bY7PlXSUC+/lWc8t2aIr8MwB6ThzgFd7FuiY41kCwkgSruNjPStyH7/dc0/u01+zrvsv6qckU6BS f0uyBPbq5yRH4IB+QfIE6vRLUsB3Tr8ihX0D+nvS0YARtjkO22xIpwJCvVLqCUj1MVJfwF0fJ50P yPXx0iD4q+vSJTmuPkm6HAjVp0pXAkdqZqQJOak+Q7oeOFZzXroZOFkzKM34lup3SPP+0/U50p3A mfp86W7gbMRv1BdJq4Fz9SXSffkodRSBgfpyOwkM1VfZOXoV7Jq3Z/b6ffZtwIP2BKAejm2k3mRP DozVW+xpgav1Dntm4Fq9x54dmKoP2HMDt+rD9oLAXP1R6mnrj9uLfVfrT1HvVN9DXUp9n70UvCv6 xvrz9grgoL0aXBztGwv1l+z7gZftusBS/RW7IbBSP2E3B+7VruCW1+1W31j9TbszsFE/Q51b/bzd C+9yxx4E3qUetX7Vfhh4397tu2og9hNAzn7at2TQ2HuB2+z9vhVDgv0CMNl+UY4xpNmHgZn20YDb kG0f940Zcu2T7UpDgf1GYISegfYYQ7F9OtK32+MMpfZZaKfCfltWGqrti+3xhv325fakiMM06Oxr 7akGg329PYN+L9p3GMwOFlw6ePX2HGS+wepQRxx4exGyBFmOrMJ32Yc8aHA6Yn1DBq9ju2/EEHQk +saoo27XGw47UjbLJqSFfr/aHYZuPJPgh9s9yAA9qvaw4YQjvT2M5aPI44bTjizfnKHXsRP8MLji 9lOGfkdexAO39yD7kOfrMqzZcK4uOAqBFympa20fRF4yDDv2RJxq+2XDqKPMt2EYd1QCoR5qJh17 I661/QpyAnmdfuvbbyJnIjTccBwALwqOtH3eMO2oA+cJvrT9jmHWYZSTDLcdAnDRIYHnPOVwg7ek 1+UuctWw7JDb79etOkLw7aYj84xhzXEEZs9VB4yfhnXHySDR9TrO0BnBcTbINbCOc/7xBrVjIKhp iHUMBbc1bHeMBBMaEh1jweTNsR1H74YUx9VgWkO64xqMxuuOqWBmQxYdCRt2Om4FsxvyHHPB3IZC GxssaNjjWAgWRzxAQ5ljSZ5vqKSzTMNeOm43HKBzdEOdYyVY2mB03AtWwOwMs22D4NiAWQ9GrWD1 of4WZbC6QbJ2B/cfKm6Jke80uFvioH0Z5+VgSzy0E2pJgvaPtKQCj7VkwGx+oWUHtHyyJQfe8UxL PvBsSxG877kWGAMbBlrKoWaopQo40gKjX8MYnSkarrYcDOoarrXo4ZyAlwhsNEy1mAIj9NMFDQ23 WiyRkTZobphrcUA7Cy0efzKdkYPWhiWLMehsWLEcCXob7rUEgsGGjZZw8LBR2XI02E3PW/AEtnNa f63leLDXGNNyKthPx/DgBWMcuh3wPMGLyOG3XY0lKziKHEdOIm/gMUxHaIxv6ZGvG5Na+uSbxlTq RqgzCc4aM1rOR8ow39Ga29RvBBcPGazrwUXjjpbBiK8ILiPX8FOsG3NaLnWwtNyhxppFY37LZfmu sajlCjgK8BUdscaSlomIiwjOIseRN+BaXJfvG8tbbgKrWmYiM35wnbJju3Ffy3xklu9INB5sueMn Rn3LXSDUQ42pZdXP0bPXkYJMR2bReapjJyV8aqTR0nIf5m6YwTvyjA4ngZka5vGOQqPHyfkTjAGn Bhh2boNZrMyZ4E+jc3THHmQZnodx41Fnsp8zHnem+bcZTzkz/cnGHme2PGjsc+Z2VPKJno2wkU9p U4Z6+PS2GGBWW5x8kN/ZFi/n8HltSb4pvrAtNSzANhmwdk/bjrDEl7XlwNrKtnyo2dtWFHbzB9pK IBpKayuX9/F1bVVhWZfQtk8u541tB8MhXmjTh4/wUpspfExX0GaRLby7zdFxi5fbPOGTfKgtED4T iQ50FW1hOcwfaTsaPssfA/9/jj/Zdjw8wJ9pOwVxnLmt520fzp9t6wsP8efazkN5oG0wFMMPtV0K j/AjbZfDY/xY25XwVf5q20T4Gn+t7Xp4ip9quxm+FYlAzaRtBmKuSKSDMQV/q20+PBeJ8vg5qCni F9ruQMxF5/oF8/62u8DZttXwEr/Udj+8wq94SXisaZ5uqdvm5eQS/p5XE74XibOaHN5tD+JZjDH5 DRpXQiR4mkZ83oQH767zJgMxVhKU3jSImCIxzkWIMY8KMW197RlNq95MuUSI82aHN4R4by7EWXAG upRCkrcg4lW6YoRUb7FsETK8pXKfsMNb0RUn5Hiru+Ij8aCQ793flSQUeXVdGI93ZQglXgPE1BBZ d0WYI5R7zb4pGkF35SOLKP3VWC7BdymPUKjyWuV8YR/EXEXCQa9TLqHxb1eVoPd6N8v7kAepX+rS b55JiF67TJSB7fSoOrYLJm+wy0LLXQ6kR7B4D8t6weHthugVYtiugODxnohErF1h5FHkcbPXexrO WMDbCwxT0hizfZWy65Rw1NsfiSu7eoTj3gtyQDjlvQiEeqjp8Q5HYsyuPuR55CB1cV2XkJeRV4Q+ 7yhEjhA/dk0I573jECdCFNl1XRj0Tso9wiXvDeBl7zSc8yve2fAQXpebyBnoFbfbPcKEd1EOC9e9 y/Ip4aZ3Dbac8a7LGcbzzoKOvRg74HyEY1eKPGMcdBZ3HDBecpZ21OkOOysCG8bLzmoa3zn3dxiN VyihrOsQjBNOQ4cEND/gdae1w2286XR2yMYZ2OtmJKYzzju9HSHjHWew44jxrvNwxzHjqrO746Tx Mh0/Kf3TxvvOE0ENjc46ziDPHtrvPC3PNxJnb8e5Rs7Z33FON+y84F9s1Dgvdgw0bnMOdwwhR3Cc HNuMrYAdVxsTnKMd1yJxVmOyc7xjqjHNOdlxqzHTeaNjrjHbOd2x0JjrnAVmO293LOGYuYK811jg XOzYAC6HlI3FzrVQTGOpcz0UE5lTGitcbChuk9UudSi+cb8rNpTUqHNtb89oNMB8lNZodiXKOY1W V0ootdHpSg9lNHpdWaEdumXXTv+2xqArz69pPOwqlAN0nAyepgzl1LIwG0LZtSd4OuLcDAZXWSi/ sdtVGSrSBV17QyWNJ1wHQuWNp111HXuN113GDndjr0voCDX2u6RQVeMFlzu0r/GiSw4dbBx2heSD jaPO6pD+Xa2Nu46ETI2TrmMhS+MN18mQo3HadSbkaZx1nQ0FGm+7zoXCjYuugdDRxmXXUOh445pr JHSqcd01Fuoxsa6rQLXrWki/yVjXlDxo2u66FeozJbrmOqZMKa6F0HlTumspNGjKcq2ELpl2uu6F LpvyXBuhK6ZCtzI0Qa9v6Lppj249dNNU5o4JzTQOu2HMN1W640PzkWtn2utOCt0xHXCnBtymOndG 6K7J6N4BFNw5oVWT5M4P3Te53UXBbN2kGzyGSXZDnGUKuas6iemIe18nZzrmPgg86Vzr1JjOuPXt 901n3SbflOmc29K5zTTgdnQmmIbcHjnfNOIOdCabxtzhzjTTVffRzkzTNUuoPcM05T7eccx0y32q M9s05+6BLRfcfZ25m++y5D7fWWBacQ8GRkz33Jc6i3WHG8flK6YN9+XOUt2o+0pnRZPSPdFZ3RTj vt65vynOfbNT1xRvSuzU6abdM52GpiT3fKe5lnXf8ac1pbrvdlqbMtyrnc6mHe77nd6mnFbSGWzK b+WCmqaiVq7zcCTqbypp1XR2N5W3bus8Qd1L52nqUjp76a8onf2Rbxz+glFNHYV/8S++HVLkt4LI LwOdF5qqWhM6L9L5vXOYxuCdo7Q3do5Hfh2i44N/ummfsxrax99qmg62Jvv7jROtaf7+zV9v6O8q i016S3rnZGN3a2bnjUjU32Rqze6cbrLAd5klLHmcWWZ+TwjzR2aNsMx95s9EybzFMoRjVSxHotkt rIZsYePYR4iWfYyNJ1vZRPZJ8gibyj5LHmUz2OfIY+yX2S+TxxWlio+RBFWl6pMkUeVRtZEk1Q9V PyTJsfpYPXk61hD7BZISeyK2l1TEfi32h+Szsf+5VUUCW2O37iT/sjVnawG5CUdTRZT49GQs2Uqi ySOkmmwhe0kd+QTRk8+TA+SfyFESJN3kpyREfkZ+SSbIr5gY8p+MhtGSt5itzGMMwyQyGYya3sXI PM7sZxqYJKaRCTGZTJg5zpQyJ5kvM59i/pX5MfNZxRuKNxiHUlLamRalrAwwLmVY+XnGo3xd+Toj K7+o/GfGr/yK8qtMUHlBOcB0KYeUbzJHlP+u/HemW/l95Q+Y1/H5uOPKG8qfMl9UzirnmH9WLih/ y5xW/k75O6ZH+Ufl/2L+B72njTmrelz1OPN11S84NdPPbeV2MFPc89zzzCr3ApfH/JHbze1h/kyf AGDe4l7lKlglV8l9muW4z3AGNpZr4gQ2ibNwHjaF83Fh9oPcF7iT7Ie5U1wf+1HuG9wAW0bvtWer uEvcz9jXuGlumm3mbnHzrJVb4BbYVm6RW2Q93O+5VbaN3jXF+rn/zW2wIXrXFBuOYqOi2a6oLVEJ 7OtRT0WlsF+JSo3awX416vmoInYgqjyqhR2N8kZ9mV2K6onqUWiieqO+rtBGDUW9qXiU/r8nxeNR Y1HfUyRFfT9qUpFM791RpEfNRf1KkRP166jfK/KiVtWs4mW1WX1PUR39kegGxS+37t66W0mfiTKT MFBDkunTwcUsKBaUCCok6cLsHm9J1Z5x4faeC8KisCysfWxeWBfZPYtVReJOMU8sfDlP3COWiZXi XvGAWPdq/6ujovrlOTH25asvL4jbxUQxRUwXs14dfXkM+pYSevoy9vQ/EoZ5i3mLsNCv4/BZ0qfw 7lDCfpP9JmHYN9g3YN0A+y9EwX6H/Q5R4d2hHPtj9sdEjc8CRbM/ZadIDN4XqsE7QrXsL9lfkli8 F3Qr+zv2d2//Xx8Fo2Ae/DczlYIj8QqNQkMSFPGKePKEIkGRQBLx7s0nFRmKDPIUPiOUrChQFJAU fDroGUWRYjdJxacp0vDOjffB8WuYbXjmKIlQRDxCkVAigAcT9gkHBb1gEiyCQwDnJASEsHBUOA46 JfQIffCXSTgvDAqXhMvCFWFCuC7cFGaEeeGOcFdYFe6LRFgVOeGuqBEmRI24TUwQk8U0MVPMFnPF ArFYLH3XMi5WiNXiflH3YDGIZtEqOh9avGJQPCx2Q+2Jh5ZJ8QbQLJ4We8V+eH17uSBeFIeBdBkV p2GvUniPWfG2uCguw15r0OK6eMLCimaL2hILn5+JHoRrSO9ggF4EowY9JwmwKEgSLEqSTt5PVCQL lijyIVjo/d35ML4UwBJDCmHZQvaQl/EJu4/D2BN5tu4zZD8+W3cQ2tPD8igxwrKd2IhEHiMu4iaP Ex8sT5B2WBJhVHqdPEm+CMtT5EuwJJOvkT7yNPkmLM+QC7CkkjdheZZ8G5Y08h1Y3ke+R67A8U3A koH/pe85Mk3+J8kkv4Ali/wKlg+S38Cyg6yQP8Cx3yN/Is+TDVheYFgmiuQwMTAC5uM93btgBIwj BXhPdyGTzDxDXmSeZZ4lL+GTfXtgTKwkL+N/sCphPsfoyCtMHVNHPo73d5fjk32vMmbGTCoYkRHJ Jxg74yCVTBsTIFUwgobIPhhDu8hnmM8zR8hnmW6mm3wOn+87COPpJVLDDDPD5BAzynyX6Jlx5gfE wPwH8x/EyPyQmSSN2H+bYBQQiFkNF46IeA+dRd2idpJmvG/OppbVMpHUQXWQ2PE5FwfeJdei7lN/ nbjU31B/g7TCtV0ga9j3c2mmFT4ZlAbKBGWDcjdVsKliUCn5NJ/GZ/LZfC5fwBfzpXwFX83v53VA A2/mrcIK7+S9fJA/zHfzJ/jTfC/fz1/gL/LD/Cg/zk/yN/hpfpa/zS/yy/wavy6wglqIhWW7kCik COlClrBTyBMKhT1CmVAp7BUOCHWCUbgnCIIkuAVZCAlHhGPCSeGMcFY4J2wIA8KQMCKMwXJVuCZM CbeEOWFBWBKWRKUYI9LnEViVWWWDqfCrsWehx7LQP/9/9e9XYdmKvTwOe/kj2MsfxV6+HXv5Y9jL 47GXJ2AvT8Re/iT28iTs5cnYy5/GXp6CvTwVe/mz2MvTsJe/D3t5Ovby92Mvf45MwpKJff0D2Nez sK/vwL7+Iezr2djXn8e+/gL29f8GfZ0ludi/P4z9+yPMU0wy9HvaswuwZ38Ue3YhPrPwIvbmIuzN u7E3F2Nvfgl6cxt8B3yMD74D9MmFV7A3l2JvLmO+wHwBvg+0T5fjMwuvYm+uwN5cyUxCP65irjHX yGvqL6m/RKrVPeoe8in1t9Tfos/kxslxh+E6aeDcbyGMbYoQcz/oAugiaHizbhQ0DpoE3aB1ykfM 52znhdK/L9ymwl5mHrANmodsl4Tqd4vWmUdsl4X9IJ29kso8ZrsiGP6+6Dbmq7YJ8zXbdcH8jujf 5inbTcEKctr3mm/ZZgTv3xduE7QfMM/Z5oXDtnnzgu0Oasl2V+gGnZBuY/m0vU7otRvNK7ZV8z3b faH/HeHfF+yCeUMiwsV/oGG7JIza3bxS4lAxkoaPk7YJ4xHRMv1swuQ7on/z8VKCcENKoK+oJClZ mP7HotvxqVIanyFlCrPvFr9Dyn673YfF50i5wu13xOdLBe9F1ilXHF8kFfMlUunfVLlUQWW95Yqn 4quk6vekfdJ+/qCk+yvpJQOVdc6h5E2S+b3IuuBK4i2SFeWQnCiP5KWyLrlS6WvzbWcKf1Oa5gNS kA9Lh/9S1hVXBn9U6v5Hst5z7cA2jksnUKek03yP1Psu9Un9f6Xz0oV3aVC6+J51SRrmL0ujf6Ur 0jg/IU3+la5LN94l+rnfg4RFu8zPSLP8vHT7bwrWCcv2kLBmP4Lb3ZEW35PuSsv8qrT2V6LtrUuz Ims/xt+X1t+LRLX9pEDs7ANxdvXbwvWxoP/D3tdARXVea5+ZOWfAn4yGEqIEKSGEGPyJIZYaQ9Ua gohwZqBErbFKUM6c+QFmBpkZrDXGGkutteo11BJjvFxLCSXGUEPQqjHGv1Kv1dSgsdbrR6yhxhBr qDF+Bu/ezzmDI5KVdN3vW+uu1eZd+zmbffbZ5/3Ze7/7PbhIdMVG8LEVm8sSKhpKB1ZY0N9eVJZc sRV9iKqI/jIqG1nRXJZasTP8+dIhFbG3UHxFwm3Ez46r2FuaVJFcNqHiEK4ZFUf66s8XUWlKxcjS MRWpt1FaxbjS9IoJt9HkioxwKsuuOB7K7bfkYj1XhnJcma3iVCgHlU2vOBueR3r8JHxd9TXpmaPZ Fed75rao4mJ4n5BLuimnUOyXi1oOKO+vxzDFVfngBat532B/L48hiqscG/Ln8kS60nv4fplacbms tOJq2YKK7rKFfpH3l7Il/v4s57GVLfcPLlvpj+H8WrbWH8d5smy9P7Fso3847wFlm/2jObdjzOTv ZQ3+saH8XLbVP76s2T+Jx12205/Jc1G215/DuZNtgg7588uO+GeWHffPKTvln1921u8sO+/3lF30 +7FH8h7EewLP4WXaJ/X9rOwq7T+hee72x3hE/yK2wfc8/f1LPYP9Vdh7Qntt2Br12GTS95TQXsB9 4r3RE+NfxX3zxPnX9awz69Pa8dpjX6Y9j8fmSfTXsMwznPbwrRrxfs3zewvt1fZl7Fm8H9N7Qnsx X0HkPxhbrz2Wr0ye0eVdTLzHhvbVEHnGLjAzhfZI7Jn63hi+V96yR+r7ZIg842kfpDXG3kf7oWfS gjFM8Fve58Zq1JOziDyZ/k245vjrPPn+RsQY5Q/PTH+TZ46/xTPfv9vj9O+DnGKY9w/ELcURx5PH 42/1+P1HORd5FvnbEBd6HITyIvsW2+E851lK+SkUI7xelLf4+VAOvC22esVVKL/0xBbboLzpqfKf xpqv8reHnoc+xZtnnb/DU+Pv5H57Nvm7PHX+a5zDkZN4DI0BwdMUMOO5L8tBer88LXoeD+Wl62E6 ep8x1l75uGc8lIdD9IW57gvyqWe3ft1XkcxjCtFteTI8V3J+DOXIsHyItWc7rMO5iebA01qxt3x4 5fjy0ZWTmLi24fXmmqZ8bGUmZJSzvFmBZeXjK3NC9Uv5pMp8z7VAGvIY1R3lmZUzUVNQTvMmBQo9 XYExoZqgPKdyDnIa7/9cN3Cuy6+cz3t0+cxKZ/mcSo83LeArn1/pL3dWLir3VC4t91dWlS+qXFW+ tHIdajI9X/KzqM1CdRPXPHqNAlu6DfSxqrKG8yX6FartQnWY82YOBoVqGL32YFtcj5WvqtzE9U75 usq6nudZn8fDP3MtyDUXja28prIRMq4bQ6TXibdQ71pQr/1uIX1ee9d1PcS1WIh613WhGq2P2qx8 k0ZfWptx7RVef3HNFaq7wmss7is/yzqhOekdWxR/nqOBgbfFVVsgKlRjeU4HhnjaA/Gci3ryVUcg if3a0xlIgT+F5KzDMcf+R1evEEj3mgOTwQ8MZHmjAjJTeLx5hwQKOEd44wOz2D+9KQHltjqGyDsm 4AaRPzIhDilvedMDQVwnBxaHYpBjwisHVngLAqt74o/iyjsrUM3x5i0MbPAqgVqvO1DPe0+IkI/o jIX4ozF7fYEt3mBgG2xT/vAuDuzAOHV977LAHu+KwAHv6sBhb3XgHc5F3g2Bk97awBlvfeCcd0vg Au9/TMiTVBN4twUueXcErnA+9u4JXGc/5b3QeyBo9B4ORnrfCVowXyeD0d4zwVg+J3gvBJN5nryX giNZ33slmOq9HhznMwYncA3I+T+Um32RwQyfJZjNxPawz/B5KDpo43n3xQan+xKCs9nPfMnBIuQw WkffyKCKe6nBUtgYF1zAudw3IbjQlxFc4ssOLvfZgit904NrfbOD631FwY0+NbiZ59dXGmxAHqPx +xYEt+K6MNjM/uBbEtzpWx7c61sZPORbGzwS8h+uwbn+8K0PHvdtDJ7ybQ6ehVzPub6G4Hnf1uBF ts9x4msOXvbtDF717Q129/hq6BwQ2qOI9x2qFFnHd6SyP8sEo2CwHLa04e8o/uv3KP9cv0e5KFy+ +dsAuyK47Svsq+3V9g32Wnu9fYt9m32HfY/9AOFh+zt2RW+rQSftZ+xuvZ2zX7Bfsl+xX1eNaqRq UaNnjFVj1QQ1WR2ppqrj1Alqhn2ZfbHW1EgmNVu1kQxt+ll1ujp7xnC1yB5UVbVUXTCjUV2oLlGX qyvVtep6daO6WVXtPq2RRoO6VW1Wd9qDWiONveoh9Yh6HP3jHrEm3+M30hv4a/8dl8jDp/4/+Rqa SxFipXYnvoZG4Wvo1/A19C58DY0RVMEp3C24qcXim+g9+CY6DN9Ev45vogn4Jnovvoneh2+iSfgm ej++iT6Ab6LD8U30QXwTTcE30RH4JjqSIu+wMFo4Qu1hfBNNxTfRR/BN9Bv4JpomfCD8Vfim8CG1 8fgy+hi+jH4LX0Yn4svoJHwZ/Ta+jD5uiDfECxn4MvoEvoxm4svoFHwZzcKX0an4MpqNL6PT8GU0 x/ADwzOCbHjW8KyQhy+j+fgy+h18GX0S30SnU7y/IcwwbDdsF2bhy+hT+DL6PXwZnSuuEH8iFOIv 0RWJLeJ2YT5F9wFBETvEvwoqRfEVmkuDEBQW3/RVZayQqoxVxiuTlEwlh1q+MlOZo8xXnIpH8SuL 0PYprcpRpU05Ta1d6VA6lS7lml2wm+0DuSlLlSpllbJOqUHbBKxTGgmblBZlNzf2G+MI8ptRut9E 4f3sMUZaowfIe9hXRJr/VPIe9hUzfCWCPOUJ8iH+ct6PvGMW+RD7xwD4x0B8Lb+DxuUiT2JvGEy+ sIb8if0girygjvyJPSBaeI3aXfCAGHjA3bT++8hv+av4UFrz98jDeNXvwarH4Uv4MFr5C0I81jjB MJjW+F6sbiLW9T6saJJhrqFQuB8r+gCtqEcYbvDTiqbgW/cIw0paxZFYxVFYxdH4sv2Q4Q1DizBG MESmRabfXI/iKvHO4qreTTmpnCleVbwu1JRzxTV629S7KReK64obtaZcKm4qblKukKRXU67bjcUt 1HZT28fNHmm30LW1+Gio2aOL225v9lhYaCs+rbd2rdkTijuKO+yRhJ23N3tycVfxtVBTBNbVmmLW 28DezT3EHa9EKUNCzZ2kxOstqXdzpygpoXe5xyjcBCWld3OnuRKVNGr8vnRu7nTFR9fJSlaoqfNv t072J8NCUs/MylpzZykFSoFbJpx1e3MX0PgKQ42euvmfW2/m3s0+0p5KfQqGmn2cLp9wcyZCzZ6h LFaW9TTSonesuLXZs4lsymq0aqXaPl2Xz7YX0XVDaETUTttVpfb2Zi9V6qltUbZxsy9QdmjNvtC+ xL5c2UOrvlLZc/tIqM9raY4O9LTDyjs9LV1r9vXs3/aN8N06+2Z7A3xsK3ymGR61k+zsxXhX2A8R xz3aC/uaJfIUezNWKcU9y12I1Srk2VfbeKLt2fYjFDur7Mcpcmrsp+xn7eftFxWf/TLNVZb9Kvny bns3+XubKqr9s2PIlzvVwWqMGkfXRJrRdsVHPw9XRyuF6lh1vDqJesz+36lmYtZ2qzlqTnE7axQ3 qvnqTLLFUYsRQVOLFfbN9uImdY5Sq84vrlKdJO8gvXUUdR2qh7hVql9dVFyjLlWr1FXqOrVG3YRY btKaWqc2cryqTfZme7Paou6maG3VIlbdp7bibfQm9Sj1po1jUj1NltvVDrVT7VKvOYTiLodZiz+O QMXsGOiIIl/zwd/MdHcIrXO1I96RpGxxpDjG0BqPU/Y40pR0NdGR7pjsyKJZX0ErYHbI5KXsc9WO AmqzlNWOdM0DqWGtoFcLnyGZo5BIUWod5PEOH8nfcQQdix3LHCscq5Wgo9qxQVmtxjhqFZ+j3rGF dLY5djj2OA44Djuq4eNmxzuwc9JxxnGGvLjZcc5xwXHJccVxXdnArbjRaXRscUbCV7c5Ljgtyg5n NPsp4R5nrHrameBMdo50piqyc5xywDmBvHcJe6Izw5nttJEHH6CfzPblbkWJcrud5CNKvNtH2Tbd HVRq3YuLO8mDFcoCZlcLZYok97LiHPeKYj+Ndoej2r3aXc1xTT5Ds+Xe4K5117u3uLe5d5CHUuag bBDPPqCY3Xvce0jjgLu2uNM1yX6IbHG+gwdDE1kGHpyojHEfLu5SqygbvkN3FNIbQnFT4D5JXBTP ghKv+t1n3Occte4L7kucBRUt/43hucKc7XBfUdvc10uMlOcma7muJLLEwm/jN5VEK3JJLGczwoKS 2JKEkuSSkWpMSWpxR8k4LXMhd7nVtpIJ6iJlh2s498Q5nayz7+xwznYWKWanyo16m0j9TnKWsn84 FzgXOmTnErq7HD4hKyucK6mtpRXf4Fzv3EjrttnZoNQ6tzpSnM38rLNZqXfuJL8pKG5z7nWkOUup 7XQeUj3OI/TGJBr3WVW0n1UKnMedp5xnnecpetqdF52X7UuKu5T04nWOJHWmGkM924I7V53dLtGR 5OrvGuyKccUVn6ZdoFrZ4tysjHENd412jZ1/yH6cdhqf/aprvJJGltNdk0g/U5FdOa5810zXHNd8 l5O8NoW8wU253ufyuPyuRcV+11IlyVVFcUx517XKsY1GOESpVuPIR9a5apQs1yZXnauOokcmm42u JuUc+c4Kmr36J8+7divLXPtcrYRHXW2u0659Sr2r3dXhcLs6XV2kHeO65iyi0tfsSHMLFCtp7oHu KEea4xKqqVH/Omf+050zVcGDf+EQw/+vhnnxgmFeoRA9L5ZaArXkecmz5dnyvJHzRj7V9lTbvNR5 qXydPWv2rKernq6CbBy1CfMmzF42e9m8DGrZ1Pi5NGrVs6vn2ebZ6D1GyzrL8/SOwTjXCDjXGHGi MaHyFXGikXCWMaPyjcBZJhJnmX44vwzA+WUgKl8LKt9BqHwH4+RyJ84sXxMMg+cPLsWY8G8Qi9YK hqIGuq6n61bxzmmDizZ/FcrZRtcYorgvoESNcg5oNG34V6TRRGP7oPEa5Zyh66SvRjkX6JqpU45O +RrlZGnXXCNRJPEziebcTrnRdJ3/5ZSbQJRMvFMnD5G/F43ugxb1oqX/AFURreqD1vVhl6mmF236 apTHc19H1PgF1KRR3iSNprV8RdpNtK8PatUoj9ft6FejPF7bNp1O69SuUV6+drVl07qnE99B1Hk7 5bEPdH055c3RbVzTKEcgMveigX1QVC8a8g9QPFFSH5RCNKYPSutF6V+Ncm10nazFR59E93KnE83W 9eSvSAVEs/qgybpNla6FX41yS+mqhJE7jEI6C/XrEqLlxPtuviucclfqfPDLKXct0fpeNhb3omV9 ED+7ka4r6LpZvzb03Z8vpNVE1X3QBqLaPqj+VsrdWnQzf4fn21C+DOWx5pv5JXfnrfmjx0/C1zW0 LqE52hs2t4du7VNPTgnPAaEYDsUX7xm6z+dRH27x6ULtfu4RouNEp7QcwftL7nlNzmPKvUh0uQj5 tWillidzu4s2y2IR9gC5f5GW3+dr/i7znOj5WaY9TY7TxisnavMgD9fyJdtkktku+YJMeVGmuZOp DzLbzdfnNzSf3H/eJ0N7WE7YPLMdp2aD78m0X8h+vV+916nXGvXsJ6F14rFyXxZpfZOXhj0/X18/ /pnHla+PrUqXxYRRYh/Ue18e3wdNKrq5v4btsT00M4x677Gh/fJ/sk9WFd26F64rurkHhu13PTmL SG7Ur7RvyS26nPKHTHuSTHuQTPuPfFSXUwzz/oG43arFk0z7jHxay0Vyux4XoTjQ8yJ8q1XPc+6w GLms5S1+vicH9o6tXnHVk19CsXVZ73+nvuZdYc8HtXiTaW+yClq/rbQnWXkPytJzEo3BSnuQdYj+ 3Jfln955vC+dUJ/7yMc95AujL3rXl+XTFb2od54Mz5Ubim7myPCcOFl/tlq/l67l6Dzyn7x1GnFt w+uNuqZGl5GvWLcQz3lMr1/yqDayFup5jNY0j2uiTi2fWXnueb70miCvSc9lvP8Lep5j/6M9Oo/s 5ZE9K/U3j+sfrmvIz/LYJtcxHXr+1PMlnh1fdLNuOn0zj8KWbgN97NTyJfrVOw/3ysE9NUwoD/M4 2RbfJ5/Kuxb2fJc2HvzcqMcJjS1f0GV1YdTUB/WuBVv7IH1ee9d1PdQRRr3rulCN9j+pzeKLbq2/ Uopu1l1hNRb3Fc8m3ZyT22KL4s+adntcWdOLemosK8mtWVouCulZZc2vrQW6P4Xy2G4trqx6fFkp r1j1uLNSjFmDGoXHm5XjiuXLdP9cXXR7HUNkrdZpg0aIPbZfq1/rb8Ygx4SV9jrrjrD4Iz3rHi3e rLRHWw8TvaPtPSHi8fIZi+eJx2w9SXRGt03jsJ7Tx6nrW+lMZ71EdIXoehFykc1IRGc4m4UoWtv/ mJAnqSawxRIlaPnYlqz7Ke2FtpFEqUTjtPmyTSDK0M4JNps2T7bpmr6N9g5bEZGq1YCc/0O52UZ7 gG2BTqnaPsO+bVuozbuNalDbcs3PbCu1eeR1tK3V763XbWzUcrmNakQb1Yc2yj02qsdsVIfZqK6y UT1lO6LNr+24nsd4/Kf061nNH2xUC9moBrLRHmG7GuY/9E6uB2xUC+VRLZTXX5frOTeP6oG8GH39 KE7yaI7yqAbIGx7mq6FzQGiPIj5vtKaTN1aT4V9mRFoG/OtfZvzzfTETU8R9/NtVY6vwqiBEJBAl E40kSiUaRzQh7JpBlE1kI5pONJuoiEglKiVaQLSQaAnRcqKVRGuJ1hNtJNpM1KDTVqJmop1Ee4kO ER0hOk50Su/DWf2d57/gepHosk6sf5WoWxAiRaL+RIO1vkXG6Nc4okSi4USjNTs917Hafe5r5Hii SdqYIzOJcojyiWYSzSGar70v0knkIfLr9hcRLSWqIlpFtI6ohmgTUR1RI1ETUQvRbqJ9RK1ER/Vr W5j+aaJ2/dqiP9cedr+DqJOoi+iaQMFKZL555fnpR5HcL4poCFF8Hz/3viYRpRCNIUrT5vIfopG3 Ur90nSYTZRHJRAVEs4gKdTlfFSI3kY8oGPb8Yp2WEa3Q6LZ3rAa9mrspty63MbcptyV3N2hfbqvZ nHs0ty33dG57bkduZ25X7jVZkM3yQDlKHiLHy0nUUuQxcpqcLk+Ws2RZLpBnyYX8a2uQTw7i58XU lskriFbL1fIGuVauz22Xt8jb5B3yHvkA6LD8jnxSPiOfky/Il+Qr8nWr0RpptVijrbHWBGuydaQ1 1TrOOsGaYc222qzTrbOtRVbVWmpdYF1oXWJdbl1pXWtdb91o3WxtwP2t1mbrTute6yHrEetx6ynr Wet560XrZetVa7dNJOpvG2yLscXZEpnHz8Nto21jbeNtk6hlUsuhxlf+mfl8avzzTGpzbPNtTmoe an7bIttSW5VtlW2drca2yVZna7Q12Vpsu237bK22o7Y222lbO+0MQ/v8SwyC/pcYIvGXGPrjLzEM xF9isOAvMQzGX2KIwl9iiMZfYojBX2K4G3+DYahFsQSEeyyVlhXCKMvLli3CREuT5Q3hCcsOy5vC NMs+y34hz9Jq+b3wHcuJQQbhyUGmQaKwZJBl0MPCUvxVhrr/xT0zGKIMHvzblR38/9u+76hOFOX3 UVTfR9F8H0XxfRTF93WF8UwU0RSMkCVRNCcN1ORJUToN0YmiNokUkyhqkyhqk9I03aR0XZ9lFGVJ WbotWZcX6DRLfy/fK9R+TlKEEbk11MIjirGFYyosorTWE1e5p+WBFBcCR1duE+IrPLrSZJnWahD+ AoeAv71hxN/eMFmClqAgWn5iWSlIlp9Z/k2IwN/hGGj5paWe1uFVy2vCMEuLZbuQYNljeVtItByy /E5IHmQcZBSGD5IGScKDg1IHpQop/5+tG7qfEh8nXCqVEw4AbwPfD/zDujyLcKy0APIiyH8OfiVh qvQa+Czw2rMPg7fh2YcIR7P886tiKezws/1hP0F8hHC29BT/OyhpIeSTCTOlCsJ10HmJ3/t5E/Of /wl9qIb8RfCPAMfivY/oyHamSF68fTJ4fvsNcQTxGdCZAHxCH90I6JShh4+j/4+i/z48xXw/0xX0 Ko7HThsxzZvETw3DqGdJJYTf0q0NAv8N2Gf5QEiypIngHwevaabhvRRN3ZHgM8D3F8dDzuMSIH9C lzOfDj4TOACamZifv4mPET9KcqH/4/EU8wNMl6EzmmcG65UnufHsSswV8wNNf0WvhhJGY0R38bzR 2IvAs6aB5Z9/hFX4CLNqgHwKMEKs51ED7wROAT4CzQHiOGA+4Td57MY8SeHfZkuFhM/xWIx+8BOB J3nmjYtZx2AEPg/9VEaTAp3npXmEdbB2J0sMJ5g3fIK7a6D/BPR/Bj4adj4BnoX+NfH3JDeK+wnz xeNsn3nDx5Ao4gnCdNYRrjAasoGfAXcxmkzQnAo7T7K+4X1YqAf/Cu5Ogf4N6KeAPw/cC3wd+h+K 5HvGHOlt4hEjRrP0JvHdLDcUSa2E7SL5kjGWdYQPpWcJ/85oOK9LCE2psBMLjMOzxcA1wLvFG7j7 NPF/YDSeBr8TeBT4vDibV8f8IeFPdWwGNgCrgJ2MEUPojdcx229A8w0z/x2XdeAnAr063wCsAvKz U6F5BXfbWWLqD8lWSDZp6868YayOzcAGYBWwE8hPTYX+FjwrAFOlXxBmYt0/g+SgjjyWOvAngRd1 vhnYAKwCdkIzg04TSVIVfEwlfBr6jwMfBvYD3g9cA/w78G0dm4ENwCogW/4/mL2fsY7pLWCrzvMY P8GzM3TkZ6PAx/F4DR9Kh4kfBhyv8y8CPcC5wP3Ai2Tzbqz+VWhGMRou6PgsPGovexok3bAQxRaI 3w/+WcTOYeB+oCbZQTrfQK/ulfbBA9lCP0biPcC5kBwj/pfwrrPw21eZJ+89jDhieQmdSQwGK/sw 9UcbF4/oIHu+MQ6SOEji0MM4jDEO/ZG5J+TtjTTShRjpD2F5C3ANcLtugSOuHNF0t/kukoyDPBaW Y2E5FpZjYTmWZ4+iku03QPM08JLOk75hI+wfBXbqvAf5CqMD/gYz1oqxvB7Bb/ECJ8KrFeZN/SGp k37L/gP+fnjO/eCHmb9FOIaR1oV6a4BEuAHLMu7m4O5O3D2Ku9sR402I0GRgAiLiYWTX58zDCZ+B /APkwy7wa3nfNPwFefUOLRuzpnBFspP8a8ioy4Dfx4wtgs5IxOC74L8OrNfzsIPksG8cCoxgjIDn mF/i+ZGQ1cXFPBbzYebNkzCunyP2FcRFf3jafzKKOYijq5AE9SiuQnSwzRapibBE3ML5BOM9grE8 D808RN8PzZzt7wD/PeYp23A+yYe8Ts9IzN8JnRng12iRC/2/YCz7YHMt7EfgXT9FRmoHPoRe5Ukd PNuMtPswap4w13yScCM0J4K/Av2teibkqJ+vZTOWm9ZjHtbj7kHg48AZwH7AYRFZwEa8nSUB9iLK KsxnAtNh+X7w39B3nI3ED0FcHIMkAXjKfA97DnaTlxBZd/AOYpiBvSnAO4VhKaN0DRFxlZ+S0hHj NyCRgcmIgi62YLob8RWNvWxMxDh4HfvANqyXAM0PEXGPcQySt+9AJtFwP6KY72bgbjGy0K/1aGX5 aMj3YhfLYfu0Lm8iE7JHjcGO2YQ+3IkRmXhEpqnQ+QskR0WqHg2TIZmOebhg/pTwCp4qRI6aDsl5 ZK0HzO/yzss9J9Qy6rPILfyuzcA1wL3mBwjfNv+UcCL/H+cNf0DmOY27O3X0oIfMF5hH4O5FZBXO RVaskWo+xr1Cb1/kasHwn6gZYrEun0P+GlZtGKOg7e/tXIsabSLbPyJaCDu4ujMOZRQ68cZyjNeH MW7kPGB6GDnkQUZTgkgS4+9g+QVo/gKW/wv8FFg+DK84zDYN2dxbYSv6fAE4Q+pPks9Qh+TD8mNY qRTYOaJVJlzNUgXF/GpEygrUdRdEJ/rPvnof7tagz8fwrmOwFstjFP/I8yBhNsRPGU1+rHIMWzO9 y7z4GPhMjLQT/f8UGexTxHUsevshbO7kHprGYtT99N5yTxLBjxTp5GI4iFG/IVK9LVxC3w7h2W3Q GS+6OWPgqQKuh40Fpo8I14lPkOUJWMFt4nz2beMLxB+HtQ90ZGsvwc439FkSiX+fkfxtmMD1Ks2A KQLz8Cs85QOuhid0iDx7WyB5GSs+HNaeQg9l8BWYgRcx25MxUiee/QB4GjgNsd+OsSyV5oPvx17B O6mA9RI2wmYJsAi9LYBNs1TN+UT3TB5vBb9XeAE618xJjNInwHeBuyBPBGaThaNalc6atA8yjpdO IOczn6nV7bBzDHgQdg7CzkHY+RP0FegrLDF6IEmHRNbqfOZpp/sE+C5wF+SJ4Fn/Du0sgLfs0hDV 5lTYmcrPGp8E/6TGsx3CXZAnAodBEge/2o+ZZJvvw1oXsB74CrBR5P16CmxOgc0psDkFNqfA5hTM 0hS2bEphTVMKZmAvLOwF/zr413kUNKsb0X/G32jjZZ76thF2NuKpT2CBJePQz0915OjYJXIf8qWH EMW8Os+KvIfu0c9T/Jb9YhtiGecp1hS0s885nIaG4tyUBfwdrA2F/SvANmAjnp0JzMSzLZB/ADws kt+aE3lc5gZG0ck64hFpO2UAvMvsk3gHnI258mAGPoO+hWfV3IB4fxi9PQY/eR+4Wj/ZncDqHIBP nsCqncDMwD85+mgGknmlpLsJN+AUaYRmPDSPgV+Gt6dr/oa1eJklJhNWygT5VOi/D/wUWA88gPNO vfk83sKSG7wutL7Mn9cRaw2+RfMclpAnZGMFs7HidHIXFNMf6Qw+RhpA6Df/hM7yiMfP35fWkf4L qOtaeU7ER3knEouZN70G/DfI67l6FF9CtoQ+1f9cv30dz05D/eaC5lt8QhcPcvY24cRtelKiHCgO xt3f4KlfMkbcA3kMLFwHNkK/EH6ymNfC9DrPrekM+CnARxjFBF4jMRG+UQX9N+FR7zFKm6HzCLwi ljVNP8bKfgTeibsP4u4QeEsGLGin+0ZgFt41EdXLS9gTM3nGTO9jZ6lCttyH3eQAVzWmTaifV2Fv qmU0LYLkOVRHnbCzG3gc+C7wPdg5BzwCDGDPeg87bwuj9Bb4xUCttr+CvelHqIpHoD58T+ebgQ3A KiDXtO/xqVO6gPmfCs2BwEfN3yXUTqOLgNt1bABWAdnCa9BE1S2+zhJClthYIs2BV8xG1RoATgM+ j7OMB5WnD1VuJurtOq5CxWR40W/xRuibqjijipAQ8lg6YP9+HZuBDcAqIFmTHuTTuvlNeM5BKYae GgBrm4DzgCdgMxozUAm+WcdmYAOwCnd5dJU8Y+Iu5iOGmX8BnMn28ZSoI8/SMdhv5NkwTUQ1uEjH F4Ee4FwgPIorOnN/rP73oJnJGVK6XzpI/MfSW4S/gLxNRw9wLnA/8CH2Otw9AMkBSH7MlbDpVY5T ww9QgccDvwUMoOZMwNntUdS0I1Ezr4JfBeC3q7g+NGbC8m/AV3Kta9yGvv0Z8j+zHXEa+n+GJeI9 Or4I9ADnAjnKHuBeiV/nc7r5V5rnc1wYz8HaAOAmVAtLEE3ROKF7EQUbcPc9HV8EeoBzgfuhQ/Mp 3stvkd7iL8CErIOzPyHz2neMK5ilU1IDIiKe72qI8/h5PnGLHSyRdnFPxGbwH4MX4Sci9BdJH2IV NORz9x/43E2zwV5xRFyCvrHHCuC3o+fbcVfLpROAA6RoQoHXSxpqziO+luXSvfDkPwMr9YzK+Wcn Muoa6KyA/suIu48QRwOQV8chD9eA/y3nYfIrekrag3U5AJstyLRrYbkE1kaAb+Yzu1iIux5o7mSM 3MUeHokzmvRzWO5mb4nQcv7vceqpQoReQAS9jujASZ/il3PIK7DwK1gTxOfoqZ2w8wb3TcQZnDLV cawF76TFOHGXM08WOoHHEdedwOOI1k7gcfT2N8Tju6XYglm6zpWA6QXkqINAEX37LZ/Exf8ALmA0 4buQqdW8nHc9RPEa8K9D/yU8i6+gpiqWmFXOBmYX5G9B/yzwSeAm8xXGiFm830Hnl+w5EfeAjwE+ AmvXoY+vpmJ/3iPEKP4iJz4kxcJ/mDdy36SLvPpiFGJnkf6tzIu98hD7CcvF9/XTOp+wGnACehRx PYV3iogsrN27WKnHmDf3l+6gu1exc23n8zJ5L+eEDL4bkYX9ZRNHE+WrHcD9yEs7gLyTZuPcPQLy M5CfgfxjyM9B/h7ks2Htz3iLdi5bhP3xOHA7v1c6yyMy4zu2qQkn8VrsdOtxHn+bz92U5eZihj9F nzkvPcpncPMdiPpORPduRhFfOynPPISeMB7B3QGojgaYH0M+/Byx8CIyBt9dDKzSswc/dQJ5400+ j5NODeQ16D/ylfkZ4pvR5yfEewj/nVFMwPxvxUj/hNXxQ2eGrsmSeJyJfsdjFO/kE7QJp3WTdqY7 iTPdIeTk72Me4rDuo7TTN7xliES5yByJpz5FnfAqn9Mlp0jnC3EVcmwpni3FsyvB1/O7jN/EG4uw Li/hbPgjnHyPIxZEjO6nfGYXR6CHT0ETJ1wT+iMtA7+Iz+ymMvCaTgkspAG/x/US1Y0cj9vFu3lH QN8+gIdrp+xvwwemYNQPmXbSiGaxHfMC4EJGcZP4CnImx8LjzEtBKYhe8UwWQEdA1tqFPCbxXVM5 71+SAXYGY+a3o4e/5PO46RT4j/kUb3oY/BQ+xZt+jbEM4p5IiB1xhjiUJBvR/yWmjwmfMZEPiBf4 92vm/0BN+DSf4ml03J97+CxvWgGb5TryHN4BnMHnd2k78Lt8jjD9Xx67OQYzkI1TeTueKuTzu+ku 8Ltxtwv9+St62AT53/DbnwSeGfNwvH0CcC7G6wam6bUl76dD8dRhPssb/8hnedOPMD9D8X3yLHr4 NDAbq/NjrOM0XjXyW0LjK5DEoZ81OMWsAU7UeJxQ1iDK1uCks4ZPVXSXTiLSA6io90Dzh8DXpeeQ CZm3AKdpCAvTYGEaLEyBZifOeiNYIo6A5AQkNWKQv1TgpJwEXI7z8ndwXv4OTmGP4nz3Cz4rkSeQ vlGF5nt4Ywwqz1GwNoqfFTPAP6shJM+yNcJdkCcCh2FPp5mRjmF0TpFOhaYNsPko7GujmwD8Pp89 qf8YBWyOgM0RGGknRtrJcyXOYMvmDOkd4A/Zi2Bhq4aYnyLwWZiHieYczBWjFef3U3x+p1Hk8Dcx 8Rjem4MI+hMsfAJrObxPca8o5zC+IN5POEdcSvIgcinOy3S+5rs/BsZBMkFcRrxH5L6NggSZVhyG tfgI+DdGUyujdIRRHAV8lp+VRuMtd8HmVOB44GZYq9LmChY+Bg7HDFcCSzjXRRzkGYiUMZ9Xce5z 4bcJJcxHmLHfPc13pQcww63QzABfzHzEQbYWKXNNInXjPPgoxqX5xjiscgbWZQP4aFhIh86v+fuA qZDnX4zFKmyFb9zL+5fpPI/O9Ar4weAXQ+cMcBSeSgRGYzVj+Fmplldc2gz5I9D8FVb5x8wbP4Lk UXMakE/uTmgO5dUkP3kOOZDxKGw2gr8ffY7GHH6f5aR5Fb29igjlf5lQduNlwSAMv/E7/hcON17h 3+MDS4DfBabf+BXhvBsPQl7F/6IA8iJd82VgLSwsxFMLIRkCXEP477qFLXjjFsgv8L+juNEI/DOe ZSy9cZLQynJj3g3+gjoK+BzQD5wIPAlczGgwMgpdkKQCBUaTAv55YB3wTp3n30ScwLOfQLIG+ASe +hn4aNw9C7wGCd5izIfkY/Ca/XS8/QrwPdz9DLgL1kzQmQp8EvL3dZ77UA/JK5BMAX8DT6WAPw/c C3wd+CE0c8BfBW8G3w0c0s2/oWjvTuFaEf2BvrCGJSZtZuKAsSwxYNSGGcA/QH4a/E7gUehos5fX /W2yMBb8d5g3TgS6gZvwlqPgBUbqA/PzgM8D67q5at0Dy3+Fzg+Ab+HuC7C/Xhsj+LvBr4ZON3Tu xVu2g49D37bh7jFodkD+Q3100LkRSXYWavMAzWz9WZol4Srm6hnIU7tljJH2d+MdjMI58FVAB6Ph XeDfgZ9B523w3cDr0GzC25OBCcCHgR+gh5p/rgX/F2Bs92TCAvBfw7ov0zyW5cYt4Ed282n9XfDj IYfPGCMYzfBDc4BR3A4Ln/PMmEuYl1rhCVUY49kbL/BvS6H/E81zYG0t+vApdA5ifvI4cinihiA6 GFdD/+ufU+Vj+G/2zj3epqr7/2PNsdae++y9zXVwHHed5F65k5AkRSVJJUnKNXTcr0lIkiQJlQqV VJJ0U4lDKrfkloSQkFvujks6nH2+c3zWen5ffHu9np7f8/z55NV7jTXmmGPNOeaYY+299j7nnMNM rwGbg5lg46QCM2R2QhtJYTO0DoPnZqKxeSL6CtBXR/S2gGfA3dLKldDaEXwRHIRe5cJrieXb4Nfg yVAWmweT8gS7H+SCouc+aF0NnoKHWphRkWBdEAGsl7M1WEFE5vVgd0DuBJt5iOqGoBZJbN2NiHBQ DdIgRxHJb2D/TbKhPPWCvAn6gfA2AJppQg4qw5/I57OI9gtoRQ7YbBef+dH3EOK/A+OPYC6rIBeD fEDib/NQ4r8TPBDqM+AnA2N4FSOU7P0Q/BI8BH0Q/2fBe8D24PBQDnzKJwWTYD8P+h4g1oiOY08d RNymgWvyClrmYo4xaD6GXBK7MgtZ0QL6tZj1AbQWxdwP5c2ymoZo7Qf9dEQMe4qrQa4OD8Ukzqoi 9MG++w58ED47w0Nn+JwPTUnIQXUNcmA1xrMfcUZlc1ysVD34Carx2qB25dWQGEJeFdRhWI6F5RVh HZar/AA99rg7Ajt0BeQ/8prYcQb3shmodT9JlNx6kG+G/ij8/AEZ1VilgKiKqnRQGWCzAvwC4/8w WcsSdytnJWzmBXUDRJ1RkxGlBrDZCAbVCdmucG+yUbXvdxgVxnkX7AsGFakC+DI4APr+su7cBppW YHfk86No/RZ8D9yNHTEylCUawb2sLXqhaqkOwT0OKxvBWhQBXwAzwHUg8sfB/cX5WEh5kBeCOfCw PlwjkRFb5xjkmmBzxG0p5HxBhCHfAt6TPCPjRK928PkYOAeWjSFvR/7/gPxfi31xNVgR+pmQ68D+ CfjBHZCSyBDco509iHlR2CxCzkC29RCfi0GeA31ryEENRw5EZiOvUkHc+zy8UoqUgregml2BcX6W N1U+BYOHvOSzmKOlsxyti4KIofK3RBX6AGwX5BIqz1bMRYExsFNYw6UyfIp6mwZNfXg7g8qzFK3b EI3XwUVhxRB7xM3G/FWMJ5AzcI8WmxHgY+AroRy0ZiLCIheC/zXoexY2r4KfQdMCz0hP4+liCcjN I5/aaCfCT53kmzzD8G2oXDwhr+hlSXYJ1Wx8Wr0M76PxnM3Z68p3opbg3SU+OVKNI3GpDPg0aq3I 6mvI2e4WvO/G53fyXiPvjKpK8qw7Jnc3t5vc69235BUR5HT3hIxf6Ebcd6wmG9+dyBE6o9Gri9Db gOczxcBUd6jsZXioKVTT3e/w7uwEPgmVXr3BlmA6vCXdYtbyE37McjnvlpoJeaD8LJVqLeSWvEPe Y4olLRY6Br2WC90tQm7Lz1nNLPQtIU9F1Cfo2xat5YReC/TaCq4Cx4J7WD4h2soS8w48RMYvzyWs N9HU9drARt4FZImG3hCZ5kEzGXKO2LtnYL9e6JziJTI7niL1HJbThe4CyCPAEtDsRq+jQq8N5LFg AbB1qLGjUlVF5nQZLb2Evt2FPETozMRIWDlC75T8TiXISinROIvRKt9sr+HYOCfP4Vs9LdRYqRLy vEhlqedlRuppGb96W/a7yGq0Gi2ZqeRumyH2zofgeCE/A5tFCt8fUxMsJ/Ezlh9DnsDvwo/I+WH5 Ja7YEX3fglwN1Eo+y87F1XNUQdndCjmgimCcqZLtCt9PUBGruUH5srtVeXm/I/ZOc/BOIZ0WMsND U3i7RxWVWqHWwWcg/yb3FJGdObBsBg9J9L0M8j7wa8e+o3TmYQwHHflUsbIjT2VtvbSa8458Pp7r nJK7g+ws5xTkW900eeXg7JTxCJ0bVLplQTVf7mvOXuuhGFgArCy03izpN8gTwALODljukH0Nebsz RO4s8LlO2XcWzmRnm9W/gzhHZDyqBPzsB09jv08hsuve27WtyTmRNMi7IOcTGZ/Lz4hcA/2Hovfk SeObkZmWbcDG4GEhHwA/EHoJ6M8LlQs+B00F2DwgjGyGZSWwGVpLQ+4AuTUs90EDvTtWqEtBLo/W r8BT0OAq/D3kzpBHgC2gGQkOFjoYrWqA1u8g78R4IrB5AZyN1mWQP4Z8BLwDvA96zIhz0Tfwthp8 EuwG/gTLmpAxLz6HK/aBvBTj2QQehOYteOuEXnVguQr6yyHPhTwNMZkPeRD4OlgRvd7U9u4TKR6s jsjuYTAvWCORvQQ05yE3DNYImonBSonMD4AdwN7w1i5YL/TSwapBRkwix4JVg/0H4D60lhbqUtB8 hbFVgeU4sHsQH1z9RoxwSRAT0agSkIOIIc7uDLA+rohoOyfQikiqLHhA1nmTweWwfwPcAN4OYtZu kGnTMM5hsC8LD4i5ZzAG5I8qh9xLgf0e2LwP+XpYBjnWCDTC6PvSN1oI42TYNIGHL8A06Itj1hUQ mVWwfxGt2CPuRvQqg2shtjw52HeI4Wb0RWzdsWB5+PkUNlXhH/FUN6DvPOixy7wgV7viWsFOLBXk HvysgQxL9Qx6HYLNJDDIEESP+waZjOtejljNFTonoHkN1wrysBZYD7wTfddDrgEP1cH94J/Qj8a1 OkK+C34wLw9X92rDcjz8TIGMyCvUB3cmOBC8BzbBFX8EgwxZiNZHQKwLF8UVe4GIvIbGPYkrDoE+ qGnYg26wu7FzPR+aAiAqAyMrGN5UUKlQVdRx2KOv2x98D5wFfVAbIfM6aFZA3oGrI68Ye0dloxey zgt2UzCjRbCJwX4qNMG6L4a+JVgMxJgZNTMyBj6DUSEr3G0g9pSL3HAw8shw9HoM9jmQsRPdoeAW 6LGmjPh7baFHjXJRtVzkg0JVd7uAC2B/CjkzAvkT1KvZIGqRh33ET0ITVM6j6BusKdadsVIR5BLf D2Kv8QQQ2avXCqPICg/3Lw/ZHkG0NeYeQasLe0aN4mvBO+TqRPI+xX0zKZ95tQEbg4eFfAD8QOgl oD8vVC74HDQVYPOAMLIZlpXAZmgtDbkD5Naw3AcN9O5YoS4FuTxavwJPQYOr8PeQO0MeAbaAZiQ4 WOhgtKoBWr+DvBPjicDmBXA2WpdB/hjyEfAO8D7oMSPORd/A22rwSbAb+BMsa0LGvPgcrtgH8lKM ZxN4EJq34K0TetWB5SroL4c8F/I0xGQ+5EHg62BF9C2OvnmwaQh5Ilp7Q24HvQYxl8gxsApax4Hd wRvRawmuWwIjDEaO+bozwProi1k7J9CKGaks9MXqe5PB5bB/A9wA3g4GIwxWPJjXMLAsPGDunoFP rKMqhxxIgf0e2LwP+XpYBmvdCESvKFqjhTBOhk0TePgCTEPri5CRme5G2JSBZ0SGMX7+FK1V4QeR UTdAPw96ZK8X5EBXeAsyPMjVNdDDRj0DzSG0TgKxOgpx4L7ga/AWrGMtsB54J1rXQ66BXtXB/eCf 0I+Gz46Q74IfjNzDVbzasBwPP1MgI1YKO8udCQ4E74FNcMUfwWBNF6L1ERCR5KK4Yi8Q0dPQuCdx xSHQB9UA2esG+wI57/nQFACxpxjryPCmgj2O/aiOwx593f7ge+As6IOqApnXQbMC8g5cHZnAyHCV jV7IEy/I+WBGi2ATg/1UaIKVXQx9S7AYiDEzqk1kDHwGo8K6u9tA7AIXq+9g5JHh6PUY7HMgY++4 Q8Et0GNNGfH32kKP3e0iExQqodsFXAAbZLUbVJKjkIOVwmoy4h9BhvD9IHKeJ4DIPb0W+Y+19lDP PeRqBDHUmFEErS7sGfWBrxXSIHXEytnuWpKfyozhacB4q0nI+3FuIM8ceBSeJ9yC1umeR/K9iDTJ PTxFUaJRv0M/Ht+7i+AZiCsa51Xo2wq9DUK3MuxLwENvtB4QRvpC7gI2hc1ReDiFq7cOn2yUsTwr T05UH2jOupXFD56i7MJTlNrB0w9o9uFZym7oV6NvFp6ZDIbNUXBg8PxEZq0y8eThbk9+9qemkFPx FGW9tFKeyE5BaLICWWy8NEQsA/poSHlnXdCdKleHZha4HCwnTE7Mk+dRLfLWijfIreWdrFovsnMT 5DZobQx5EeQtsBwKOQq5Llq/Ra+D0BQIvEGzOykjuQo2BdCrKtgBrZsCorUY5By0vgIPZaB/G/ra kCuhNQL5YchPB2MQ2fk5GANaB4ucbJl3xkagHDSfkDyd2Ap5usjsi0x5Qm4AZkOTAxnv69WvQm+D 0HWgV+ActEaFzinIR8GqsCfYjAcrgaPQOhBjmAy5A+RZuOIh2AyBvBKtmfATg74LrvINODMcv4yn OzTzockCx4KYL41MbpRVSC6UPIRmcFKe+GXAc89wDKJ/Q9ZI7RHSdvicC07A1c/D8mwwNrHhnUn5 Zt310DcW/+pE8l2rT1IzO6pUWO4SjToOP3fD/+/w1lbsIyWhf1ZkVsmPLdPF3l0aXBc+MxGf6aK3 1xVvd2H8xfNyrKY+Rns6mLXYey1x3XHIt8qw3wNNT4kDHcfIE6J3DJhMnrf6NUI1EGwtdL4Bd4IH YTNPyDdiPK2ROTXBdFx9ebj6VkNtkrIrVyPCb4AVMKO+Qf4HKxuMBPqdwij8aOw+++rXzjFSBH1n i+zdHKyvjNlrgxnNC1dhBvQL8drvY3mGHGRjOJdsrM55xCcbO7E3NPIcdRfkqvAwGRErCLkDehWA /VLYZEHTDnJP6CcgMhMgz4X/EpC/hk0/2H8Cbw9Cw7D/FJZRaXXHYJyYIzdFJmNH02sYiSuMDMWs m0sE3KlCVSLYX1i7Tck5WJ05Us/RK4k47Aw5Q+4m0J8S2lova7cXoyoHzgKrIhqrMbaqMja7skFW Z+NTBmndA64AN8GyLjyb0Fs2dpDkyWzM1IVmHuy3QXMY8kz4bAjNreC90J8PV2oGZNEMw1Wmw6Yd OB82dcHm4X6vbkc7I5hFmHuya9YEtQL6rWAveO4a5GEQDcTnI+y+OciltliFd+C5dWCPvnXheTA0 86E5C/t08hGNGcgBiXkSEY7C/0vwdhjr2E4s7cgXyjrKmO3ravHQEvafwPKhwD6sh3LFl5JTZIRh zSTUbcyXXsLVxc/aIEOwEz/Hc+Oj1EleRQv5QN6dVm6FWR+ETW/k2HapBt446Etj/LeGeSXR+0TJ N806QTMC+VkF+hLg1qCWotoMxqwN9APBKDgLMx2DOfYOYotKNRsxrwNNU9S6YcHYQg9SPydJ/bQj lAwvgkhWh01XXDcn3K3v4jP9YN+dR2UuitEGd7fg/iIxbCG1yF2AWWTkDUOrj8yxjOCepWcFNQfx b4aaUx/MCXeBvZbGvuPW4VpLnWkYxCesBqJfj51eAvLQsHJK62vQZyJv0yHfBn1X2KyG3Bv6Crhb pSH/54cVOFt+m1DeblTLlrZ1PVa2SnDnSsrvSJmXVwh3tE6y+lIN7GuVlqgVpRATy2RZ8UCE3x9I rvxsUfh0UUgx6GOiJxJN8mX5ZnhysXx7P9kE8jjIN0HuEeqnyfN8+f6/1cxG64Py3Tb5OQIrL4N8 FPJhkeVnjpK95DvzyYnQ15RvMFoP7+M3+awh+Y1JWZZT5HNMaiE/9Z+8WX72JDlSfnolmRXJtNym ba/co5ALi2zH+bzlz/q4jCqyR66ij0HeJv71AcjnIItNL/npkuT9EfkdTS/r9mAn+b1AGFvjYMwR +W1OQ7RdzeQTEXhG65ORgxj5TnhLhaXwCd1QvuOn5fcRjYzKpx71vFGIzDxE4FfMwhcNbF6OtpHv EEZWWb4Ujtbu6OSjui6uJfpHIznwfz/8j8XvMhL9KOibyvfzk6P02+h7pYxN34/xizwC8sjISsuv 9FnLFtC/CP3NkXKWg3UryBUxtvswu81iH9WIknxHcXY0inWUvm+gb5PIM7jWl5ZXw083+LkP8ouQ m8jvAbA+B8GPyLOxUk0i6dDYjE0+FzktcQgpms8gN4HcC3JTby3me0rGj3y7E2ziSev9YBN9JfJK 5HqRd2AjeXgdMrCifF5p17cwYlsYIxc+oj+E/iPLAZCfhNwrshhjWIwsGgf9OFzxU3ASOBFX3wD+ AM0GUOR+iE8/7IIa+G4A5eZZ+TL5tkAyLp/XJ6vlym+mKglSruyO8vJZf7JawFy795OFchdZloOm ZHI4WjPgJwMa+IHParl2/yY7B35yZQwVc6dBL3uhVO63uNYmy7Tco9AILwOr5f4MSp2pnrvfsmCy Ee4SRDHnpZRmxB0f7ZtJaQ/37fwIjcxs378nzSf73vKulo0yyFbKvDxKpwRFqARdQQWoMtWiunQD 3UatqZ310dLWpe7UmwbSUBpJY2h82CMfaSpJZaggVaHaVI8a2bp/H9l1o7uoMz1CfWgQPU5P0jP0 PP7GZtDLUNTWs7KURlXpGnv1G+l2akMPkaK7qQtlUl/8RdBRNJYmWGu+pUWLptSs5R23Z1CXu1ve lkHT4acIfl/uZfYOUY4KUTW6jhpTU2pO91N7YqpE99DD1IP60aM0nJ6iZ+kF9IpRBpUnue/WoQZ0 E91BV9JEtBSlVNt6ORWjClSYatC1dD3dTLdQC2pLHezor6JW1JV6Un8aQiNoNI2jSeE48lOcSlNx qmjlmtSQmtCtdCc9QB3Jo6vpXupGvWgAPUZP0NP0HE2mFztW79eRR4BjwAngFPANcFbH9pn9+SNw AbgUXAtuAXd3bN+vMx8Gs8GzYFLoumCsY8cevd1UsBR4FVgXbAq2Ajt1yuz2sNsbHAgO7dSzVw93 JDgGHA9OBl8F3wDf6dK3fUd3Dvg5uARcBW4Ed4AHrOP2bjZ4FkwKPTez54AeXgxMBdPBEmBpsAJY ObNXx0yvJlgXbAQ2BZtbk77e3WAb8CGwC5gJ9gUH9xJvw8BR4FhwAvgSOBWc0atvp57eLHAuOK+3 6BeAS8Dl4GpwA7gF3NHPrpS3BzwIZoNnwaQwEunXrWeXSAIsABYBS4FlwEr9enTsHakK1gUbg83B 1mCHfv2qVotkgv3BoeAocBw42bJ6ZCo4E5wDzgOzwKWWNSKrwY3gdnAPeBg8ZVkzcl6oFRgFDZgG FrOspTPAcuBVYHWwDtig34AO/XRj8FawBdgKbAt26Degdz/dFewJ9geHgCPA0f1ttPU4cCI4BZwO zgRng/JaXNnaU+hfOLLd3SWo5P+XZF+T/VN69l/E1tIofpnwf+bMxVkgO5Txf2j+JtlWt4St9P+e 5NhK/dcs+LfJWBHGncQhPL3CHU7+F8b/Ngv8bZb6P8z/t3k5xuvi6FxAGfmFOv+fku0dq7C9Q/1r UhFIyt6brviXjmXsvflfOcrfV//7R4cq/A1W/Bv853Fz7N38nzP1b7GGvfsPtq99ptAs+9ppJW2h A3TWiTpFnApOHaep09rp6gx2xjhTnFnOfGels8U54JxVUVVEVVcPqfFqupqrFqu1aoc6qpJsuBRX 5gbcnNtxTx7G43k6z+XFvNbuX7leNMht7nnJ+chLzidfcr74kvMlF5zbfcO7LziP2JJRmbRzwXls 7MXnibMX9/ebXew/7aOLzwu1uth/oe6XnA+9xH76JeefXHK+++Lz9KqXnA+75PydS87XXjz+Emcu bi9V4OLzsmMuOR97wbndt2XHXdK+A+fKVvECwQzLzwmOFXqjxbU1NN1WjnKBtuJV4bF2eGwYHpv9 lfWVJjwWCY+lw2Pli0dxZfeLZ3lV+sXn8ocFLrSv3ubi85o7Lz6vteqS89UXn9fuesl590vOR11y PvqS89kXn1/T8IKss0LdRpecd7rYvm6XS84vbR98yfmQS86HXryq1w22NDZSHZ0XqYszFXeZDvYf OZOdyfKc0StkdfI3QdmLeQkvn1g4yrF98TdIHfwNUrEoQJHE834iMd6P+RE/ajUR54hzxNodd45b u2wnm5Rz2jlNbJ42T5NrnjHP2Du1ZJDim7ipjEgVUHK9VPJsnSjIhfhKrmrPPc7H9l7KqZxKDqdx mu1RiSsRcxWuYkfvOJXtjNLtu6q+NJWW007KcdLsTKJ2bmmJl0klxiemWD6feMVygo1Bqr1HZNiK W9W+e6vvVyZWqXbcVXBM+FXtsZA9r4Zjwi9Byp6Vskz4GZYSMcn7YlTaL0ds5xvzy+OY8CvYY9Se V8QxcYFlpdDyytDyqtDy6tDyH+N9AeOdiPFOwnj/0TIZLS+i5aULW/xUjLAARpiGEf6jJR0tRdBS DC2KtLL/7OaNK/kufKqyvVUhG3lOjEs8R64dXYTsGtpV1NaPo+RT3uBVAeF3n7fHmhJW03FynBy7 snlOno2Wpzxy4deD3wj8alVMFaOoKq1KU4qqoCpQjG/hWyjuZXqZlPB6ej0pn9fb603Gs+9SyPeG ekMp1RvmDaP83ghvBBUwXUwXKmi6mq6UZrqb7lTIZJpMSjc9TU8qbHqb3lTE9DV9qajpb/pTMTPQ DMTv1H+USpjHzGNU0jxuHqdSZrgZTpeZJ8wTlGGeNE/S5eYp8xSVRk5egZwsY54zz1FZ85Z5i8qZ 98x7VN68b96nCuYD8wFVNJ+YT6iSmWfm2TL1ufmcrjILzAK62mSZLKpsFpvFVMUsNUupqllullM1 s8qsoupmjVlDNcw6s45qmg1mA9UyG81Gqm02m810jfnZ/Ex1zDazja41v5hfqK751fxK9cwus4vq m9/Mb3Sd2Wv2UgOz3+yn683v5ndqaA6ZQ3SDOWKOUCNzzByjG80Jc4Iam5PmJN1kzpgzdLM5a85S E5NjcqipOW/O0y0maZJ0qy8vE27z2WdqhvW+Hevd3OZKjO6wuZKgFr6x2XKnn2qzq6VfwGbXXX6a za67/XSbVff4RWxWtfKL2ay61y9h90hrv5TdI/f5GXaPtPHL+GXofvw++7Z+Lb8WPeBf419D7fxr /WvpQb+eXw/PPUba/THSZpLv+DTcKeaUpBGoK6OcNk5besrJdHrQGPw947FOH6c/PeuMdcbS8/a1 xis0wTnhnKCJzhnnDE1yzjnnaLIUInpRRVSEXlIJlaCXVX6Vn6aodJVOr6jiqji9qq5QV9BrqqKq SFNVVdWCpqn+agAtVoPUIFqihqgh9LV6XA2jb9QoNYqWqqfV07RMTVaTabl6Wb1MK9RMtZlW2ppk 6DzX5JqU5EbcmPIkpx3F03iaw25/903H9Xp4PZzqXi+vl1PD6+P1cWp6/bx+Ti3vce9xp7Y33Bvu XOM94T3h1PF+iUx0ro29EnvXORZbE2/iJBOtEs+qRxNvJvaoD/PNzveROplvWb4NKsc0Nc05ah42 D7NvuplunGoeMY9wftPD9OACppfpxQVNH9OH00w/048LmQFmAKebQWYQFzZDzBAuYoaaoVzUDDPD uJgZYUZwcTPSjOQSZpQZxSXNaDOaS5kxZgxfZsaasZxhxpvxfLmZaWZyaTPbzOYrzBwzh8uYuWYu lzWfmk+5nPnMfMblzRfmC65gFpqFXNEsMou4kvnKfMVXmmVmGV9lVpgVfLX53nzPlc1as5armPVm PVc1P5ofuZr5yfzE1c0Ws4VrmK1mK9c02812rmV2mB1c2+w0O/kas9vs5jpmj9nD15p9Zh/XNQfM Aa5nDpqDXN8cNof5OnPUHOUG5rg5ztebbJPNDc0pc4pvMH+YP7iR+dP8yTeac+YcNza5JpdvMnkm j2+2CehwE9/1XW7qa1/zLX6Kn8K3+nE/zrf5+fx83My3//Htfn4/Pzf3C/oF+Q6/kF+IW/iF/cJ8 p1/UL8ot/eJ+cb7LL+mX5Lv9y/zL+B7/cv9ybuWX9cvyvX4Nvwa39mv7tfk+v45fh9v4df26fL9f 37+O2+J9noPXUzVRa6+Ue5/zgPOAVXd2OpPjfuF+QUpHdZQ4Oio6yu6e/1bj/1bj/0w1/t/sK4bs k1fsyukW2fvfHPtvjv2HcszxutvX/KlOaVWTb3ZbUwmqS43oVmpJbey7ju729fsQ+3pgLE2kV2kG zaZPaAF9Q6toA22l3XSQsu0re3IiTiJlMXHKlykLUr7CcWHKEhyzUr7GcVHKt/a4wEpLcVyQsgzH hSnLccxKWYHjopTv7HGhtVuF44KU73FcmLIax6yUNTguSllnj1nWbj2OC1J+wHFhygYcs1J+xHFR yk/2uMjabcJxQcpmHBembMExK+VnHBelfEPKtq60XJiy1jIrZaPlon8jItsw8y9TtoeR+SWMzI4w Mr+GkdkZRmZXGJHdYUR+CyOyN4zIvjAi+8OIHAgj8nsYkUNhRA6HETkSRuRoGJFjYUROhBHJDiNy MozIqTAip8OIbLXz/zJlDyJyEBE5/m9G5I8wImfDiPwZRiQnjMi5MCK5YUSSYa7kBZGJURCZmBNE JqaCyMQ4iEzMDSIS84KIxHQQkVg0iEgsJYhILBZEJBYPIhLLF0QkZoKIxPwgIrHUICKx/GFEziAi 5yVTYhGJSCzx70UkVjCISCwtiEisUBCRWHoQkVjhICKxokFEYsWCiMSKhxEpEUakZBiRy8KIZIQR uTzIlVjpMDJXhJEpE0ambBiZcmFkyocRqRhGpFIYkSvDiFwVRuTqICKxAhKRWBFEpJRkSqzCvxmR KmFEqoYRqRZGpHoYkRphRGqFEakdRuSaMCJ1wohcG0akXhiR+mFErgsj0iCMyPVhRG4II9IojMiN YUQah7lyUxiZm8PINAkj0zSMzC1hZCojIjURkbqISEPJFPlLqzJuPKNrTRWdDep1bsZ3cBd+mLvz I9yPB/AgfpQf5zH8DI/lZ3kcP2ffu+zm33gP7+V9vJ8P8O98kA/xYT7CR/kYH+cTnM0n+RSfzjdU /gaas95Zby8wXX4Cmm/j20hxc25OzJ24M7nclbtRhPtyX4pyf+5PKTyQB9pXAoN5MMV5KA+lBA/j Jykfv8avUUFewGsoLd9j+R4ju6r2VUjMLeVe5ma4l7ul3SvcMm5Zt5xbXmZmR3Qaz/odKnLBs4mr 5SkXZ4qF7Vk+tChxgUXlC9rsbuZMa01umiu/Ka6CW4Hi4XXT3EJuulvYLeIWdYvJb0a0Fv97XfkE wHcLuAVdz4242o26KW7MjbsJN59r7FuIVDe/fP5h5zbcDkH6KPc6twEl3BvcG0iewNSmIvwOz+I5 /CEv5WW8nFfwSv6OV/H3vJrX/FXE5Ykav81vW4/vys+O8/v8vo33XJ5r57GAv7XX282H/p/3t63V +7Z1AS/kLF7Ei/krXsJf8zf87V+tMby/w+9Y77N4lnyrkOdY7x/yh9b7UrsuLuYh3itT2l96/Yt5 IGa7w5hJv7+ZXegn2WD7eT3VPHqSRtFTNJqepjH0jN3Xz9I4/H3g52kCvWB3+ST5dgG9RC/TFHrF 7vnXaCpNo+n0Or1Bb9oK8BbNpLfpHXqXZtF7th68T3PoA5pLH9JH9LGtDp/SPPqMPqcvaD59aWvF QsqiRbSYvqIl9LWtHN/SUlpGy2kFraTvbB35nlbTGlpL62g9/WCryo+0kX6iTbSZttDPtsZso+30 C+2gX2kn7bIV5zfaQ3tpH+2nA/S7rT+H6DAdoaN0jI7TCVuNTtIpOk1n6A86S39SDp2j85RLScqz Ce2oO1VLdZe6W92jWql7VWt1n2qj7ldt1QOqnXpQPaTaqw6qo+qkOqsu6mHVVXVT3dUjKlP1UD1V L9Vb9VFvqC3qZ7VVbVPb1S9qh/pV7VS71G71m9qj9qp9ar86oH5XB9UhdZhj6og6ynF1TB1XJ1S2 OqlOqdPqjPpDnVV/qhx1Tp1XuSqp8uxt0GHFzC57HGHNUU7hO7kl38V3c1t+gB/i9tyD+/AofopH 89M8iV/hqfwRf8yf8jyez1/yWl7H6/kH3sA/8kb+iTfxZt7CP/NW3sbb+Rfewb/yTt7l1nPry19e dje6P7mb3M3uFvdnd6u7zd3u/uLucH91d7q73N3ub+4ed6+7z93vHnB/dw+6h9zD7hH3qHvMPe6e cLPdk+4p97R7xv3DPev+6ea459zzbq6bdPO8/F66bqZv1831HbqFvlO31Hfpu/U9upW+V7fW9+k2 +n7dVj+g2+kH9UO6ve6gO+pOurPuoh/WXXU33V0/ojN1D93T/utt//W1//rrAXqgHqQH60f1EP2Y Hqof18P0cD1CP6FH6if1KP2U/fe0HqOf0WP1s3qcfk6P18/rCfoFPVFP0pP1i/ol/bKeol/Rr+rX 9FQ9TU/Xr+s39Jt6hn5Lz9Rv63f0u3qWfk/P1u/rOfoDPVd/qD/XX+j5+ku9QC/UWXqRXqy/0kv0 1/J3m/VSvUwv1yv0Sv2dXqW/16v1Gr1Wr9Pr9Q96g/5Rb9Q/6U16s96if9Zb9Ta9Xf+id+hf9U69 S+/Wv+k9eq/ep/frA/p3fVAf0of1EX1UH9PH9QmdrU/qU/q0PqP/0Gf1nzpHn9PndW6Uo27Ui0ai OhqNpkRj0Xg0oT/SH+tP9Kd6nv5MJ3VelKJOVMUWx76KLYl9Hfsm9m1saWxZbHlsRWxl7LvYqtj3 sdXxr+PfxL+NL40viy+Pr4ivjH8XXxVfHV8TXxtfF18f/yG+If5jfGP8p/im+M74rvju+G/xPfG9 8X3x/fED8d/jB+OH4ofjR+JH48fix+Mn4ifjp+Kn42fif8TPxv+M58TPJbxEJKET0URKIpaIJxKJ 1ET+RMFEWqJQIj1ROFEkUTRRLFE8USJRKlE+UTFxZeLqRJVEtUStxDWJaxN1E/US9RPXJRokrv8f 9r4DLIqkW7uqZ3qmmenukaCgIJJUFJQZchJFgooICAgmkKwEBRHjoggK6hpwXSNrQMw554S7rjnv mnPOCV1zuKePqOi6/+7/3W+//e//XOuxTnWYpuucqvd9q7p6hm/G+/LNeX8+gA/kW/At+VZ8EN+a DxYaCA0FO8FeaCQ0FhwEraATHAUnwVlwEVwFN8Fd8BA8BS/BW2gi+AhNhWaCr9Bc8BP8hQAhUGgh tBRaCUFCayFYaCOECKFCmNBWCBcihEihnRAlRAvthQ5CR6GT0FmIEWKFLkKcEC8kCIlCkpAspAhd hW5CqpAmpAsZwiXhsnBFuCpcE64LN4Sbwi3htnBHuCvcE+4D7lq+n5HFmdE8ZgYDCIrznTNlQcDv x2RtgN9PyDrKOpFTslhZF3IGOfScLEuWRc4D4+WTC7JxsnHkimyybDK5isx+DXnrOvLWDeStm8hb t2RrZevIbWSIu3IPuSclOG/KsCIrUi1rxBpRHc6MOiruKB7Sm0ovZVN6H2dJH6sOqC4xjOqOmmWM 1Rq1D+OIc6UJOEs6F9i+guiBOrAi9iQEFFAJMMBWQGf4E+p9hNFosFSBJekZTTVSg5jxAmzX5oHl NHV4DeSWvMGHc3lQABppjYkBXNUcFEDD90+P+DrSft4Scn3eGnJDvi7k1Xkn6ZNiJ+mKYmfpimKM dEW8lh9etfIZjRgKW2oxDHJBbPvZkXZ4JAqPRH92JBaPdMEjcXiEIXoQNS3Ezp2RfmPLi/EiDBPI gIJkWjGtiJwJZUIJqzqlOkUUqjeqN0SpdlW7wvUYdj5z5G/i2M8Z9v9vfv3PMKzEoX+VN/9Ozqyh zFT2VPZSFgEDScwZBpwZjWzWGZhpCvJkInCkxI7vuTHrL7LisD/hw9+z4WzgwU8MWJVd/h9jw09s x8mAw+d+xorBoD4k7fFeeUi6o5OyIyd/rzs4BaiOJFAcC1BzLFSmcyy02ihoqV2kdvmBO5nun/Mm H8VH8+35DnxHvhPfmY/hY/kufBwfzyfwiXwSn8yn8F35bnwqn8an8xl8d74Hn8lnfZVt932db8VQ MUxs+5dYt+L3vCu2E6PE6N+xr8CLvAY52OCrLFwbeLgOb8lb83U/8LHYWYxBTnb6Q1b2+z0vi7Fi FzHuX2Lnz7nZ7z/AzqGUodVhKFuL2hIjGkYjiTU+KbWlsTSZ2NGutCtxoqk0lTjTdNqduNBMOoC4 01w6gfjTEjqNxNI19BBJYLKZHDKQ6cMMJIOZPCafDGeGMMPISGYEM5qMZYqZcWQCPvOcwkxkAO1x jD9dxssMyAxcgTFXVkPWkMyT2cscyGaZTuZPypHxf0XGP4ajt+PyMvkhcputzlanJgqiILSmglEw tJYChs3UVGGsMKZmiu8Vk2htxRTFNGqlmKEoo/UVsxXzqJ1igWI1dVCsVWylXopyxWHqrziqOE3b KS4qLtJYxRXFNdpFcUNxiyYo7igJTVYySo5+o1SBQihQ+ioD6XplS2UQ3cplcll0O5fN9aY/cX25 vnQXl8vl0t1cHpdH90hP0eherogrovu44dxwup8bxY2iB7hirpge5MZx4+ghroQroYe5adw0eoQr 5UrpUW4Ot4D+wi3jltGTekF6QfSUar5qAT2tWqRaSs+qlqs20ouqzarN9A6w7SV6V/VGzdLfgG19 6Ft1S/VMRqmepS5n4vlrgi2TJ/wiXGR+er8SBsakS/G5SwxNqdyztsoeSjzBje8VSD1QNs5wfA4k KV8K2mAOWmlrS+XWFtg6B0laj2NH7aDtNKaNgfTcqTtcswVtARTTmrYmcjqZTsb1OLtJPGvD1mXr sfVZW7YB25C1Y+3ZRmxj1oHVsjrWkXVinVkX1pV1Y91ZD9aT9WK92Sb0F/orPUaP0xP0JD1FT9Mz 9Cw9R8/TC/QivUQv0yv0Kr1Gr9Mb9Ca9JX1bHL0rl8nlsqeyZ7Lnsheyl7JXsteyN7K3snf/nX1y qIqcwfkGOa6Y1cdnWiaQZMQMkhzXY7LgPXuiJA6QOPCqJ6hFb0gq4gNJTfxJAOFJa0giiYakIR1I R1CJsZAMSBIkQ9INkhHpRXJIddKfDCDGJA9STVwfVYtqaDViCj21FqlNzak5MceVDXVwxZQF9NqO xBKf7Vphf7WmGTSD2OBah7q0N+1D6tGBdCD07BF0BGlAR9JRpCEdS8cSe+jHJaQR9OM1pDEtp9uJ A91JdxEd3U/3EyecdXLG/ueKyjoI555ice4pDmfEalWZEXPAdVdeDChUUpvRMTrQj66Mq/QeHuMP R4KYINCP4Uw46MdoJpqwoIKSiQL0TzpRqg6qDhNOdVR1nKhVd1X3SDXVA1UFMVCbqWuTGuo6aiti oq6rbkDMgE12EEvgkr3ERuIJ0gB44gaxk1CdOACqmxEdYLk1cQE8r0tcAdEbEDdAdTviDiOtRsQD kN2BeAK664gXILwTxOrLumixLq2YNKiL+Wd18WA84IhUIxkTBiMbOdaIxRopQO11JEqsFwdarifR w3qpsF4C1ssA62WkeqJ6SkxUz1WviSnW0QLraKVupHYg9dQ6tQvUS6ppY6ypDmvqijV1Bza8Q7yB CytIU6x1ANa6BbCUN2kNHOUH45T3z2CDoX8mYY10Uh2l7zQknpV11FWeYwu9dyyd+HEfQxfS5bBl 9PE86AFf8YE3A35DT8gxtiz6Q4H+UKI/OPSHHqjfGKJCr6gx2jz6RlDNUM0gIozPdxANjMFOQsxP qy4RM9Ud8IqN6q2ahRprwBM+aje1D0kGJXGAdAfNcJwMAI1QQQpAAbwiE4Dx65BpGPP1GPMNwOP1 yUaM/CaM/GaM/BaM/FaM/DaMfDnwuwvZDhzvRn4EnvcjPwGrB5ODoHRiyXFQN13JeVA0WeQ6aJO2 5D5ojGjyCJg+DsYBgIQwTupJiDSOJM2luQbSVlpzQyLU2/mR5CB8JpFO+cvn4feK/k1nf2wPJAGj 6ohtPqxKe3D81B5IJPH5uI8hgTBC/dQeHKX5btVl1W1C1Aq1SPTUTeGvGUh7caz//k4s8R60lXf5 4V49Ac3+BXSHT1avXCsqYSFFLJQhFsoRC1nEQgVioRKxkEMs1EMsVCEWqhELecRCEbFQg1hYDbHQ ALHQELHQCLGwOmKhMWJhTULZkxJfMiGycnYzu5M9TJr96XMhhqqoAdyrFW1IHaknbU6DaDjcYwJN o1m0D2ipAjqcjqHj4W+X0rl0MV1J19OtdAfdSw+Dh86CN27S+/QJfQk0pGB4xoAxYcwZG6YheNqV NgQf2IJHGqHtCDws2RjqgTaWeqLtQr3QxlFvtPG0CdoE6oM2kTZFm0SboU2mvmhTqD/aVBqINgO4 XbKZNBRtCWsqWfla1gztOra2ZDW+nLFkWWPORLKKpVxNtLu4Wmh3c/g5GK7g55R6HH5OqeLMJQs6 qg7aQk0L/DtptAFgkgYUBwNb9pB3BN0hqRgHyGOpFvIuFFAKaghtE+rnBHkCBUUDdXOBPIm6Qp5M 3SBPoc2ltSjUD/J0GgB5BigXBmrVEvIs2grynjQI8mwaDHkJbQP5VBoC+Q+sCWGgvjUhX8dKa2B9 OYEwUFMRwrOU00C+i6sG+W5OX1pdxUGvgPoZQq7ijAgDdasOeSFpAD2sMzB/BjB+LhlKRpHxZCqZ TRaT1WQz2UH2k1/JWXKV3AWUqXy+CC3JBFq8DbQlLXWl3tCaWtIQGgneiINaZdCF4K0S8NAitDF0 MdpYugRtF7oUbRxdhjYBMF6yiXQF2ni6Em0SXYU2ma5Gm8I1kCzUUWptJVBLO7S7OHu0uzmp9ZVA XRuj1eMc0Ko4rWShxjq0hXQ6xm8GRq4UIzcTI1eGkZuFMZuNMZuDUZyLkZuHkZuPkVsgxYOzQI9b oset0OPW6HEb9Hhd9Hg99Hh99LgtetzjL3j6NZWDn42oGXjZnjp/xcfZtB8dRIfSbyXGhFZRRufT pXQ13QiIsROQ4ihg2nnAr9v0IX3KOREZq6YazhVtR6452hjOD20s54+2CxeANo4LRBvPtUCbwLVE m8i1kixjwAXhdjLXGm0KF4I2lQtDm8G1Q5vJdUBbwiVKFnyVJFnwVjLaXVwK2t1cV8mCz7qh1eNS 0aq4NMmC59LRFnJSr9Jw0J9gS+pPHTmpJ8Vwku6P5TykKHKeUhQ5LylynLcUS66JFEvOR4oi11SK ItdMiiIn9apUTupV6Vyo1P+4tlL/48Kl/sdFSP2Pi5T6HxeF8Y6W+h/XXup/XEeMfSeMfWeMfQzG PhZj3wVjH4exj8fYJ2DsKZFzNaQ7xpLvh5ImEN9dYJFBCOI/BX+p4fPSyxMyTSCcwcI5IfhWiS0w n/eHWVNaA3HIGPHDRLpP6Yq05sdSN6mWEjsD40xEHMFceppLqwGHEVodxt8UuYpBBpKU11SyD3zs yDlxzpwL58q5ce6cB+fJeXHeXBPOh2vKNeOac36cPxfABXItuJZcKy6Ia80Fc224EC6UC+PacuFc BBfJteOiuGiuPdeBtqPRtANtT6NoN9V00Fyl75+JML2ZQcxwZoKsRLZAtpI1Z+uwFqwla8Vaa5pr /DT+SqoJ4DpynbjOXAwXy3Xh4rh4LoHz5RK5JC6ZS+G6ct24VC6NSwctcEV1VXVNdV11Q3VTdUt1 G3SBUs2p9dQqtVrNqwW1qGkithRbiUFiazFYbCOGgGZopvZVN1f7qf3VAepAdQv1CfVJ9Sn1afUZ 9Vn1OfV59QX1a/Ub9Vv1Ox5cyDO8jJfzFrwVb8PX4235hrw935jX8o68M+/Ku/Nt+BA+lA/j2/Lh fAQfybfje/LZfC8+h+/N9+H78v34/vwA/hs+lx/ID+Lz+MF8Pl/AD+GH8oV8ET+MH86P4L/lR4rh YoQYKbYXO4gdNT6apppmYryYICZC3BpAO4mEuEkzI41gbNAaVHEak0F0TA6TQ5yZgcxA4oJrvF1x vsMNZzHc8VmFh2yFbAXxZE2AI70UGxQbia9iu2I78VNKr9H4S69RkABOAOYLlMb5pIM0zicJahu1 HUmXRvukl/og6N5c9WNQvIV8HVC8Y3hL3pIUo+4di7r3O9S941D3fo+6dzzq3gmoeyei7p2Euncy 6t4pqHtLeH9QvD/wUaByZ6PK3YYq90exE6jcn6HmG0nHvxLjfzGmf0PkPsZMhd4k6E099KMB+tEU /WiDNW+ENXfFmrfFmkeivo9+P2vCiqw+4kQQ2QN5c2JetRd92a7/uIW+b01wBX1sOwTbjgwjrMB4 ihhPDcazGsZTH+NpgPE0xHgaYTyrYzxrYDyNMZ4mGM+aGM9aELcYYlp59xrWoMrdizBWq+z3EhJh yyXYcim2XAZbrqzys9VYwyqfNQE1/RFL3mOEJgDxTJo9JNiqWWzVSmzP0ptb35Lm/248q4pUSvrX EArv0hZ0K8EeaIu9rjH2N4f381T0EX1KX1WqbH2mBmPKWDMNZK3Y7mwm25PtxQ5k89h8sauYKqaL 3cVMsafYS+wt9hUHiLniIHGwWCAOFYvE4eK34hhxtrhQXCwuFVeJa8R14iZxi7hN/FncJe4TD4qH xV/EY+JJ8bR4VjwvXhQvi1fF6+JN8bZ4V7wvPhQrxCfiM/GF+Ep8I77TUI1co9ToadQaQaPR6GsM NdU1xpqaGlNNbU0djaWmrsZJ46px13hqvP93bfX/rq3+t71NVQ1UUQprrPEFPVX4l94dAbygaYrr VVb6c9JKuI/r6P4Pa+E+rqKDazBNmNgq84jSntaAkx9n4+gT8gzGvi6MO5zhB/tCmbZMFNOB6cwk AaJmATb/JD27/lqSnldXTXCVz5P775P0dLtqkp6FfzX5fZECpSfln6XQ3yfpqXnVBHX5gwSs9VmC On+eOnwtAct9lsBLn6dYTJ+2k75IXSGl/UHK+loCRv08RX2RunyRun2eKuuHd/v+Cv87+/gHs4+U nAeW9wZFIn1nUyR+/9OX3/00Eca6ZWQ+WQqj3Y2knOyE8e5RchL8p8U1Hf+3ufu/lIf+K/lX5xjf z0DyYMroQjjHTxpHAdfVwJFXLXyPvAGVRpVhdAKUJ9JJUJ5Mp0F5Ol0N5TX0gfQN2vQRkdEK/A2h 3+hTKD+jL5AzX0H5NX0L5XeM9GtODCOHNscyCigrGelbp9UMD2UBfxupGqMPZQPGCMrVmRpQNsbf ParFmELZjLGEshVjDWUb6VeUgGMbQLkh0xDKdowdlO0ZeyL9OlQjKDdmpN8w+4H5AcpTmalQnsZM g/J0mfQLgi2BmWWyINYYRqmSimFACYVK31DPtoVxejibDuUMtheUc9hvoJzL5kO5gB0D5WK2GMpj 8bfV97H7oLyf4wkFBSTNR9WA0THljDkdlB31VhCqt1JvJZHprRLAV8JD4SGRCY9EJaEiJ6qJTORB W1MxCTSHTNMENCCFkXILwmhaaroSWvndMhKeJ1S+sf9Jj1DUIxT1CK3y1jhFPUJRj1DUIxT1CEU9 QlGPUNQjFPUIRT1CUY9Q1CMU9cj7O2RQlVBUJRRVCUVVQlGVUFQlFFUJRVVCUZVQVCUUVQlFVUJR lVBUJRRVCUVVQlGVUFQlFFUJRVVCUZVQVCUUVQlFVUJRlVBUJRRVCUVVQlGVUFQlFFUJRVVCUZVQ VCUUVQlFVUJRlVBUJRRVCUVVQlGVUFQlFFUJRVVCUZVQVCUUVQlFVUJRlVBUJRRVCUVVQlGVUFQl FFUJRVVCUZVQVCUUVQlFVUJRlVBUJRRVCUVVQlGVUFQlFFUJRVVCUZVQVCUUVQlFVUJRlVBUJRRV CUVVQlGVUFQlH76h6OP3FZn2AmuEe4lpurbAtKtCr2FRy6JnAlUypQWm7WFXJEOpTq3VU7B2ooyp xRJtvEJlp6ByWuDGUHlphLat1r7KHrMy88Fm+PDWm4SSBNKLZAKgJpMc+C89zPXRWla5mNzo3AjV 8udGG4rcav46IuNyJ1lym8CbpQU1GmoL5AbaAuZlqYyhDADFdjLS23u4/hGfp4l3LzTTCh/vlMrh nrJ0dtoGClk7udrQyi8zq392atduORa2iQ0sdB4ebhZtUhOzM3tlpuRY+GVmZzXWmWvN3p9c/fMj mdnxOamZPXSW2jrScZmhyafj4ZmZORa+vXO6ZWan5vTXmhsLHm5anU6rddPCv47GgqNW5+ikq9z8 B+6ogFpVdQtliawAmh3sVzEFlJIFzJbtWde9KkJMbWdM6hervV22YHTdLs/fTgiete7ttDILn9y2 ZT+UFcc5ph9pntT//uI+eyJPV9yZWmRWPGNoyqqf0wckWB+v7X1eQ8fdnLhjW6OUkpJu9aYc9rTf xq9pX2974A2Vj/tE+wW2HvPvthrS/MpQzaaSjHbxiwtyZ8Y16ht8a8rqJK+SMDMdZ2M0Y8GN7+xM rjeZnGgU155NnlHbLXzYs3kPxjM7TX/Z1i5g1YjB2zzvRo4PWfpm3oDuOSHLTPZP1LO1JNFj41Ld NrU2UHpHvev0anaKipt7ND8q+sFar9ga+X3lp59uXTp4wtvlB/KOz6uV3dl77+aH3Cwr7SpF4Z5V Fn0NCy8wMmj4s/Lna/PnaPPLwJu1qTy/RJs/aXC1ToezHqRmT7duO8hoZZsx7/bNzP7Px6/gT9q4 TIrhhJvq8tGPJ5m43FtPbU721X/cOc5xxnT1Ph/2u+HFezyvW1Y8jP7efk1pi90JD16f2O/l1XGB a2TqW5vuTffsX3iezT2nG91kRrWstE1vDUJNUstfH/a7ot/RIvR2wjfLFtbcbedWt9HW5JkG39bV JM56Fmn2wnLP8eqPwxf38HNUvikwfn6ta4bQ9umWR+G7ttzYoX1todMbXntCg1ptjtVm5jwafFG2 utOTFed2R99PbrUrPHLtapmtwbuxxx9yxYPWT/p5kZv91QFX5/e90qeUHE5ruv2o67cXfQ3mu6SZ pp1xufSrmfzq/AD57o5O7j3amAkJ61Rlo345Ftk08IBZu7lZZww8h33fe8a8o6WACnHaAlnwe1RQ NV6kfzbsXedp+8o/YErtfwoMoN+7O8I/QABHAAOdI2y6fACD/oigcBGFIdMuQmeo1Zc2OENVdHyv bqk9uubAn6mmFaWdSkNleHJS98weSR9uTPVHN2attXx/Y7WqHk9KtohI7doDrmoR5uf7p6iwrv/A 4zGrAjzmOy/WnX5R16VV3/JXdabvCuj54EjgzV9H/ZQeHJ7wZArzU5uTrTIcbHyStx20XqduuS6v 97mALQuLxbCf69pVlN4QrOsc8bV5mTDlUM2AOd8H1ZlyYJWD1U9BjXIzT1U39xrlUc3j3JYGT1K8 GlHHd2/rt5y7JoMOm/pq48rEvIIXnUvzhxaOWV6xfvysQ+5zwwqN6w8LOad9Spo82fmiSf7WonsZ HvMaOz9d3XiZamDCd/1Spk7uJRQtq9jx2GJDqMHoxH32pxwDat7fFDTRKyzC5GBK2/4LlwzbHeUz oyBseA92hcv2b2y2hKc0mRKy326QU4+hLRRHph8OKmJ6FJHZ5cMuRFSiwktt/jOtoQQKdeW8VqXg gNBYVimT/c+ACo10j4bSD+eyWhkYbW1phyivITfaX/tgH5LVadmj0ztCStr6N57ln/hQq5YOa+Ry 6EZFVboOYsw3i5YOCqpXcXBzSE5Z+/o5DXuvKnqzKHh8P9Lm1t47JmdTfxbLch8zfjv3Dtv/PGL/ jzO2RGU+TPRf4E/uT9xdcsxsvXpGTWH8idPmSxoMfHBvbq/Fxec9xjSZnLbZvfvR4cus31y4dTxV 77vhW95eIpucHz/LfVHNoDF7p8HE75un2/Zc5158USnsiel2YMtg3/SU+ZvWbRrjvLdCVi13wG9H Lza/8M3bS5cWv3164ZiwKuv4uCuha93Lchv92uSMszrBjZmRn2Y94mnnxOLlHTd5nIgb1W5oLaff vCaXFvBlXUausl83c86+Ract1m7T1iy0MBIabg5/4nsxVntlnG3qsO1Zlx/PW3RwcPPsPiJgTBpg THglxsRr+rVBhSSr2o9YwJl/sFd/ABwnrRYQxwkAR+uhdZQ2naRNbc7fcmuVx2V/cPxPsabsjGr0 oR+3t/rhwEJP5yXWHdLPZGy1tFo3fvftpdt2Hqv3o6P+yM2nY+xfuUaZV7dbWiycM5rVwzY4r0ZT 38Wjm60IHC6cyh+/ZJLicLR/n863H70WL+flzHLal3PtwZX4mYNk6wLeHfMxOLZ8b6xw+JuKdYbC 67g028Leo9Yt2Vx403j12K2/1VibEHNP/4LnfctOI5cN7vVTwJUJI/rG/XBjSd/tbqOdjBwMzyTs WVprQejkrkt+tfDQ9rw4umvg5Z1mT4SwHF+Hm6xNmmV6q+Xjdqz02NV8TvfOJkGLik+MGeLTT9Xi 5OyVQ61/ulzxTcqKoJwt9XxbT403igvR7i54fFidlXu/XZu+R7l2ffIrsea5Nv839H1tjdRjoRMq yqt02MeWzcbktn0e2XryNeMTaUOc2cb1bn4dmiScqG0tN9HWGPz1bu4vnVBH3kTrpfUodSt1KXLq lpOT5engkJid0bj7hxg2Tszs7pCVnirtdcjKzkzqnZjTy8EvAhpaY9ilbfnhT4IO8dZ6at0/bGuZ IvvKC/bt2/drF0zOrnKlnC86EKJNs+jMiK7TLYY4U/G6cWvvJXdO5ufdF/rn9A2d1MLkMameOuhM wtiyN11nTr1q2+BluxNT3oZti9VbtWHuvYLHk80zO7z87dEl/peRnE8NY4sj5WsCWnD14qL1Wo9/ yO3f2KbHw8stDWxdRlpmX+iydlmqgc34+7ec9c4M6pE5ThW+t2Fwq4WO9kU3Z+6Pqbd5s/fFTiuH qDe6mIUODWjxbtP4mR2UCyae67clOm/OvJD9FUumlvhe3tfZxudsnnOLkKeHdn8z7c7aPVMTjSKW LSl5cGLbodKZiybsHWA3zL5816nXGbLT29yXPDrSuaaxpvzZ3sFzq3G1zo21vrF8ZrDP7eX69fqJ 2+03zE7fVewNaDMN0KbwA9q0yr2HaMP+c2gTmdo9uVdOfPesqmjjqvXQuWp1Li6OKG90uOmolTa1 +XP/lnurr637nijNe/ilZnVLzrbwjwiwCIgI8dRp/d0bubg7uzXyax7o/uFEmaH5H1QiIjm7T2pi 8p8C1O2NbOLuU/2XDvX3mbNqx73g6TYXPPqY6x13DGrf76jdqTnKsQ9uNHm1pV7urFfXBg5yPHSq yUgPt4rnJ72ca/w6ruCV891uhdm1ii+uD764vvCxk4rZXtanl0twzKN1l4IG1l4/vt+Zd+aF1ZsH 9jyYVz/a4MiQUK9DL88/HXmvKbly7Hz8C+PRrWfne/+W2uz2pRHblKEbc765xV9rcXtRxqNjXfO5 5zX2DjTc1OuyXvDLhFf3Sj1KPN/e0d8db57Q/qQqcsgxr9atL7fb4hBXa8w41u90zJ0ClfUkvVJW lzzy+xBzX8uycWPfBPgHZLqsCHBbkrog+YWz3wrjH708LlUbVVFr2JXIsDpe03RLqgLUJ0AalP2w cdOoBhfrPuu2nr5ufWnQoSs+n2FP5s2QppM2OC9qXVS8eertxV6+fjsP/7ewJ6dXVmL8vwV7Plwp 52sIyv0Ohb8CUKkDCvT4GkfOHwoc0XjbEecB+Xn1bX0bPv7Fcpw4aUmXiNgGL+5tjwyaP/CZ4WG1 0Ys2FUXVSY8rQ2rbBsyz93A8l1ni1vG+dXhxpGx003lTk9yfuu428lvr6TN5j/BTz3zbxynzdJc7 xxS/CA+/1PnO92OnpeoFjzhypE+ws5B2Kdd/nl2nIZF5ATY16+74NvDnuldqDk5tYPTUeOdDK/v8 wFi7Jy/m7uzrY535Ym5S4ZiyBGFBI/P518b65L1bPub1pLuP3siXHWh1sGPO4pePDeuYehyctfr4 5ier7+9eUhFl/sr70e7jDf03b5vadGCKyYGVFomqvc2aJDvWzF25vsn2ei1DrGpO6TFKu/3Rd58D VLU09ZTQclJ3kf6ZgDrtB3Qt+xKm/pnBVyU6aZ2d3SR08oDNf2Dw9Tvg/DO8OevW49Wy3c2Deprs PtjSJ6L85SKjjfaOmwxCw3cPuefjdKqVbpzt2u+SLtYJG7rxx9ZH8tjnD3pvHblr/rGlqVkp/eqn 3Fy77kHhhgP3F74xmK3uYNXA4VCzU1Fy0z5ruid1D4o8c+7R+W0zhuwafCEvmHEb/1v5dC7KvFuL A6fK+3R2GLi2rnx1VKc0s8R3g3O97x+T123j0TdHGfNj55NFbva994i3zT30cvu8nZbRY8DFuz7F k6b3FLs0DDVJiHOcfnRIiJ1V524BI887DK0WtvLFmlqjM+7X/cHw+b5qJwrFJwV9ernunDCgbH+c 4i67vMhp3fPxnYb6Dm1fOL7H8jr2LfdnTvW7mHYzr96Y9Pd4U0BtwSM2X++h/yOGX9UUepUToNWp NKYiVdDzq+BY8+MHjBg5b64iEaQ3SSB+xPfzodnvxnVfAajxbfR1P+aGbdIfMzNeScVRWQGjH/SK 3NJUj230bn3biEKzex7frZsVpT4/aq2X6ZFXi+ftWbeiraVpJpc6KF1WZhV4L2N191yr9YG/DH08 WrNV+a3r9juDbmXFBMwYd3T/wXNjyi9ta3gg9+6epY7Hhm3Yl7jD9YiJ5bY+571KVpn2mm45/OTq 1QaRo55M/TE5qMS23tS4bzVeuwyT+7XcdGjJEM/Q5Qntz2tv3fKofWVExWmP/BeGlqOSBicq5BMr Shg/h28Ch298x5xKfhF0/rQs5/tVbA9+/7SztvG5LR8ZT9W3dGfMhi1W/DzRcf21ZjsjmmxZMOL8 zRS30U+sJk7dv7xvZFvP49n+K62f6grkywCkFjGUavOH/YOjss/Gip/muEvzT2uNPsbbluqUMhbf E5BaQWUw9WQ6vuq0OtzNpy21TtRWPVpda/3pg3IdtLHLy0b0nnvB4/u5xeXzOz5I03/8bava2qQq H+F1UdrI0oaDbUkbkkoSSTbJxJn5FJJDLEgk6U+yYKsr7I+HUjfSf2a9wTZ/SK85/bMyu2bHZ3Xr b/EFvMkLKBni1bZwn/2WGdtH3iltXhZ81u7uCau1g53bblvcfs3c8UvcA2YEDzC7eGNh0ku36vEp b9OLu4XND8leIYy/2fu34lbTn9xY1j7m6tFqa4warWz6682X5Ls7fS426+7VYXVy+3YjSjw4oyL7 lnsKXF9d3mRU3j2Pqn3rrXwR1my2t1db036lXQZ2vh/Qf+Hhh/qDxLh7PwxrObTIPkTRaUeY653o Z/MDLVZVrO6dp7xm2+x5ox5FPzWbuyBqcH7M6Rmzqe2jmr/+MjF6+qo+cdpLUXntTYf7k8OrGtms yY6YbTY090X3hldlsmrfTraae85w17a9k0NGnpho9Ej/3hshNFFc3/Ds0StGshl3+kbenTezgKmj LWBMP8VIoStgeNjF/ceb6JeM9NkAQ1nZREtjtCZVW6L601MgCn/z4xFWpwGqdddpHYFoHT2cgVu/ bIhjHm/wHWcW80veo3N7rzuUXHepO/XxF5glNZHDaamabkdv7qrfvlfkNcfA0HM/T9xQz9ZxSsHh NTlbc0Kj7E/Ouu728sqLYXdie5cfPZa4Ia2Fle/+Uf8VygA1/6QH9KKNU0fBdxyWJG0uASEOyuza a0dV+e+V2t7EfTjyuFILCvIyBzJ/8ydjYIN43fz5lrcr1EECeikptcwfdhckiZgai6mIWuCmLtRA QEb+J9AQVxCFo7IJdIlSjDbiHuEC8+jPaUAWzSJWsKoYqsgPGupmcRiGRIvE4jW3ZwQqQVeeR6Co VIIGn9yYyaV7d+xlIf5KwfQXPTStTjy8s7jkWVL2ZSoVWQBE56sjUHUaI1m1DDzu6HT546ZCeIWi LOvcvFKK5NawDQDzyfXgDQplbmRzdHJlYW0NCmVuZG9iag0KNTY0IDAgb2JqDQo8PC9UeXBlL1hS ZWYvU2l6ZSA1NjQvV1sgMSA0IDJdIC9Sb290IDEgMCBSL0luZm8gMTUyIDAgUi9JRFs8RjgxRDQx REEzQTk2M0U0OEEyQTQxQThFQ0Q2RjdCQzI+PEY4MUQ0MURBM0E5NjNFNDhBMkE0MUE4RUNENkY3 QkMyPl0gL0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGggMTMzNT4+DQpzdHJlYW0NCnicLdd5nE1l AMbx+8y9DWnsSyRbKCJLY8qWiTZEsoQYzCBbZd/3LUnZUsi+FCFZhrImJHtESIqxlFQig6xNM8/v zB/z/byfOfee95zznvM7Ewql/6SlKf13zlAog6FGdU3UJBPZaMpWNtXOmBo9THy0GdHZnDxiTg03 KWySsticbmbO1DdnO5lzhzNQTCNT8K4pPN4UKWGKDjAl0kzJOFNvjUloAzNNmzKwySTWBDZJCoEP TG2rmXazTMc5ZmIhM2eXmd8cLpiFfG4RoyVMaWkWsyzJrKhjVh03q7uY5BSzbrlJKWsuHTNXOsIN k7rIXG1irslcb2dubs4gqlh1U+G8ie1nKmU2cd5fVJWuJvGi6T7d9CoF602fgqb/JTOPD6wsYFYv MclVzRqfnqj1TU2Kr23UZV/bqNQcMN9cy2NuTsggXCyrqbDOxNYGn5dwpT4mzqcgXHmBSSxmuu0z PRPAxxDunWj6+qDDA3zQ4YGZ4ZwZ7IsTHt7AjPQpD4/qZUafMGNzmRVTzJZ4s/Wg2eaTHN6+2+yq ZfZ4YYb3djD7i5tDd8ytIRlEspQ2MRtMVq/rSDaBt4xk93dGckw1Ob2jSK7ycNvk3mnyeGaRvF6t kXxe0JH8MSbe90OkQRXTcI9pxJc1PmqaHTAtEiHVtBwGc01CbWBHrcaZ1l4FkSSmNHalme4LEJnh CxCZOcbMik1/HqTfRHPVHwbAQBO6F4JNBqV/YHb7YBQSREEYIpAJ7oFoyAzZIAvfOZjRfRADWaEY ZGfLIYxyQE7IBUWgMOSB3FAI8kFeyA/3wwNQAB6EglAUYuEh5jKUUXEoASWhIpSHR+BhKA2loByU gUfhMSgLFeBxeA4qMYlhjOLgCXgSakFNqAKV4WmoBlXhKagO8VADnoVnoDk8zySGM3oBakMdaAqv wItQF16C+lAPXoYG0AgaQhNoDM2gL7zKXEYwagEtIQF6Qy9oDa2gIyRCG2gLSdAe2kEHeA16Qg/o BK9DZ+gC3eANeBO6QnfoA+9APw5sJCNu0RC3aCi4Rd+GMRDcToMgWKbBnfMWBFcsWD3BVwenbjSM grEwE8Yxl+Bv78J7MB6mwzSYCBNgMkyCqTAF3ocP4QOYAR/BEpjFJIJ5zoY5MBcWwyKYD/NgISyA T+Bj+BS2wFJ2FJyzZfAZLIfNsAlWwOewGlbBSlgDybARvoC1sA6+hA2wHr6CI/A1Ewyu+1bYBtvh MByCHfAN7IO98C3shp2wC/bAd7AfvoeDcAB+gF/hKBMM1ucx+BGOwxk4DSfgJ0iBX+BnOAUn4Ryc havwG7sN1u55+B0uwBX4By7DJfgDLsKf8Bf8DansIcjZNUbBDXsd/oUb/I3+KajhLbgJd+A2/Ad3 +UAQ2jRGhFZkV4RWZFf0VjROVFvBDRuElsKKwopEikSKJIvsisIqyC6FFb0V+RSpE/kUzwLRVFFR 0VQFwSTlIq0irSLXItAitCLloqmisApiQ0XFQ0ekVcRUpFW0SrRKpFWkVURRFFYUVnRatFgEUyRS 1Fe0X4RdtFj0VkGLibAIpoiw6K2orwityK4Irciu6K3ouyilaKp4toq0irSKioq8iHyKJ61oqiis iKlonCiXaKrorUirSKvIroi3iLeCwtJ+UV9RWNFb0VTRVJFd0VTRVBFMkVaRVpFWkVaRTwXho5ui JKKpIp8inyKfopui76LForciraLT4k1AfdNfZpN3+CV4rf+HjS4z2pTzC3l0+WmmYtEMMnWfbHps MT39j1+mXulv4v8D385FGg0KZW5kc3RyZWFtDQplbmRvYmoNCnhyZWYNCjAgNTY1DQowMDAwMDAw MTUzIDY1NTM1IGYNCjAwMDAwMDAwMTcgMDAwMDAgbg0KMDAwMDAwMDEyNiAwMDAwMCBuDQowMDAw MDAwMzMwIDAwMDAwIG4NCjAwMDAwMDA2NTYgMDAwMDAgbg0KMDAwMDAwMTIxMSAwMDAwMCBuDQow MDAwMDExMzIwIDAwMDAwIG4NCjAwMDAwMTUzMzAgMDAwMDAgbg0KMDAwMDAxNTk4NSAwMDAwMCBu DQowMDAwMDE2MTM0IDAwMDAwIG4NCjAwMDAwMzMxMjkgMDAwMDAgbg0KMDAwMDA1NzA0NSAwMDAw MCBuDQowMDAwMDU3MjE2IDAwMDAwIG4NCjAwMDAwNTc0NTcgMDAwMDAgbg0KMDAwMDA1NzUxMSAw MDAwMCBuDQowMDAwMDU3Njg3IDAwMDAwIG4NCjAwMDAwNTc5MzMgMDAwMDAgbg0KMDAwMDA1ODIx NiAwMDAwMCBuDQowMDAwMDU4NTc5IDAwMDAwIG4NCjAwMDAwNjg2OTAgMDAwMDAgbg0KMDAwMDA3 MjcwMSAwMDAwMCBuDQowMDAwMDczMzU3IDAwMDAwIG4NCjAwMDAwNzM1MDggMDAwMDAgbg0KMDAw MDA3Mzg0OSAwMDAwMCBuDQowMDAwMDc1MDA3IDAwMDAwIG4NCjAwMDAwNzUwNjEgMDAwMDAgbg0K MDAwMDA4NTE3MiAwMDAwMCBuDQowMDAwMDg5MTgzIDAwMDAwIG4NCjAwMDAwODkyNDMgMDAwMDAg bg0KMDAwMDA4OTg5OSAwMDAwMCBuDQowMDAwMDkwMDQ0IDAwMDAwIG4NCjAwMDAwOTAxNzcgMDAw MDAgbg0KMDAwMDA5MDIwNyAwMDAwMCBuDQowMDAwMDkwMzY4IDAwMDAwIG4NCjAwMDAwOTA0NDIg MDAwMDAgbg0KMDAwMDA5MDY4MyAwMDAwMCBuDQowMDAwMDkxMDM2IDAwMDAwIG4NCjAwMDAwOTIw NjIgMDAwMDAgbg0KMDAwMDEwMjE3MyAwMDAwMCBuDQowMDAwMTA2MTg0IDAwMDAwIG4NCjAwMDAx MDY4NDAgMDAwMDAgbg0KMDAwMDEwNjk4NSAwMDAwMCBuDQowMDAwMTA3MzM4IDAwMDAwIG4NCjAw MDAxMDgyNjUgMDAwMDAgbg0KMDAwMDEwODkyMSAwMDAwMCBuDQowMDAwMTA5MDY2IDAwMDAwIG4N CjAwMDAxMDk0MDkgMDAwMDAgbg0KMDAwMDExMDQwOSAwMDAwMCBuDQowMDAwMTExMDY1IDAwMDAw IG4NCjAwMDAxMTEyMTAgMDAwMDAgbg0KMDAwMDExMTU4NCAwMDAwMCBuDQowMDAwMTEyODEzIDAw MDAwIG4NCjAwMDAxMjI5MjQgMDAwMDAgbg0KMDAwMDEyNjkzNSAwMDAwMCBuDQowMDAwMTI3NTkx IDAwMDAwIG4NCjAwMDAxMjc3MzYgMDAwMDAgbg0KMDAwMDEyNzkxMCAwMDAwMCBuDQowMDAwMTI4 MDg0IDAwMDAwIG4NCjAwMDAxMjgyNTcgMDAwMDAgbg0KMDAwMDEyODYxMSAwMDAwMCBuDQowMDAw MTI5NDY5IDAwMDAwIG4NCjAwMDAxMzk1ODAgMDAwMDAgbg0KMDAwMDE0MzU5MSAwMDAwMCBuDQow MDAwMTQ0MjQ3IDAwMDAwIG4NCjAwMDAxNDQzOTIgMDAwMDAgbg0KMDAwMDE0NDc0NiAwMDAwMCBu DQowMDAwMTQ1Nzc0IDAwMDAwIG4NCjAwMDAxNTU4ODUgMDAwMDAgbg0KMDAwMDE1OTg5NiAwMDAw MCBuDQowMDAwMTYwNTUyIDAwMDAwIG4NCjAwMDAxNjA2OTcgMDAwMDAgbg0KMDAwMDE2MTA1MSAw MDAwMCBuDQowMDAwMTYyMDMxIDAwMDAwIG4NCjAwMDAxNzIxNDIgMDAwMDAgbg0KMDAwMDE3NjE1 MyAwMDAwMCBuDQowMDAwMTc2ODA5IDAwMDAwIG4NCjAwMDAxNzY5NTQgMDAwMDAgbg0KMDAwMDE3 NzMwOCAwMDAwMCBuDQowMDAwMTc4NTE4IDAwMDAwIG4NCjAwMDAxODg2MjkgMDAwMDAgbg0KMDAw MDE5MjY0MCAwMDAwMCBuDQowMDAwMTkzMjk2IDAwMDAwIG4NCjAwMDAxOTM0NDEgMDAwMDAgbg0K MDAwMDE5MzgxMiAwMDAwMCBuDQowMDAwMTk0OTU4IDAwMDAwIG4NCjAwMDAyMDUwNjkgMDAwMDAg bg0KMDAwMDIwOTA4MCAwMDAwMCBuDQowMDAwMjA5NzM2IDAwMDAwIG4NCjAwMDAyMDk4ODEgMDAw MDAgbg0KMDAwMDIxMDAzNyAwMDAwMCBuDQowMDAwMjEwMzkxIDAwMDAwIG4NCjAwMDAyMTExMDYg MDAwMDAgbg0KMDAwMDIyMTIxNyAwMDAwMCBuDQowMDAwMjI1MjI4IDAwMDAwIG4NCjAwMDAyMjU4 ODQgMDAwMDAgbg0KMDAwMDIyNjAyOSAwMDAwMCBuDQowMDAwMjI2NDAwIDAwMDAwIG4NCjAwMDAy MjcwNDcgMDAwMDAgbg0KMDAwMDIyNzcwMyAwMDAwMCBuDQowMDAwMjI3ODQ4IDAwMDAwIG4NCjAw MDAyMjgwNjggMDAwMDAgbg0KMDAwMDIyODQyNiAwMDAwMCBuDQowMDAwMjI5NDU1IDAwMDAwIG4N CjAwMDAyMzAxMTIgMDAwMDAgbg0KMDAwMDIzMDI1OSAwMDAwMCBuDQowMDAwMjMwNjE5IDAwMDAw IG4NCjAwMDAyMzE0NDIgMDAwMDAgbg0KMDAwMDI0MTU1NSAwMDAwMCBuDQowMDAwMjQ1NTY3IDAw MDAwIG4NCjAwMDAyNDYyMjQgMDAwMDAgbg0KMDAwMDI0NjM3MSAwMDAwMCBuDQowMDAwMjQ2NzI5 IDAwMDAwIG4NCjAwMDAyNDc4NzQgMDAwMDAgbg0KMDAwMDI0ODUzMSAwMDAwMCBuDQowMDAwMjQ4 Njc4IDAwMDAwIG4NCjAwMDAyNDkxMjMgMDAwMDAgbg0KMDAwMDI1MDYyMCAwMDAwMCBuDQowMDAw MjYwNzMzIDAwMDAwIG4NCjAwMDAyNjQ3NDUgMDAwMDAgbg0KMDAwMDI2NTQwMiAwMDAwMCBuDQow MDAwMjY1NTQ5IDAwMDAwIG4NCjAwMDAyNjU3MjkgMDAwMDAgbg0KMDAwMDI2NTk4MCAwMDAwMCBu DQowMDAwMjY2MTg1IDAwMDAwIG4NCjAwMDAyNjYzOTAgMDAwMDAgbg0KMDAwMDI2NjU5NSAwMDAw MCBuDQowMDAwMjY2Nzk5IDAwMDAwIG4NCjAwMDAyNjcwMDMgMDAwMDAgbg0KMDAwMDI2NzIwNyAw MDAwMCBuDQowMDAwMjY3NDExIDAwMDAwIG4NCjAwMDAyNjc2MTUgMDAwMDAgbg0KMDAwMDI2Nzkz MSAwMDAwMCBuDQowMDAwMjY4MzAwIDAwMDAwIG4NCjAwMDAyNzg0MTMgMDAwMDAgbg0KMDAwMDI4 MjQyNSAwMDAwMCBuDQowMDAwMjgzMDgyIDAwMDAwIG4NCjAwMDAyODMyMzUgMDAwMDAgbg0KMDAw MDI4MzYwNiAwMDAwMCBuDQowMDAwMjg0NjIzIDAwMDAwIG4NCjAwMDAyODUyODAgMDAwMDAgbg0K MDAwMDI4NTQyNyAwMDAwMCBuDQowMDAwMjg1NTY3IDAwMDAwIG4NCjAwMDAyODU1OTkgMDAwMDAg bg0KMDAwMDI4NTc2OCAwMDAwMCBuDQowMDAwMjg1ODQzIDAwMDAwIG4NCjAwMDAyODYwOTAgMDAw MDAgbg0KMDAwMDI4NjQ0NyAwMDAwMCBuDQowMDAwMjg3MDIzIDAwMDAwIG4NCjAwMDAyOTcxMzYg MDAwMDAgbg0KMDAwMDMwMTE0OCAwMDAwMCBuDQowMDAwMzAxODA1IDAwMDAwIG4NCjAwMDAzMDE5 NTggMDAwMDAgbg0KMDAwMDMwMjEzMSAwMDAwMCBuDQowMDAwMDAwMTU0IDY1NTM1IGYNCjAwMDAw MDAxNTUgNjU1MzUgZg0KMDAwMDAwMDE1NiA2NTUzNSBmDQowMDAwMDAwMTU3IDY1NTM1IGYNCjAw MDAwMDAxNTggNjU1MzUgZg0KMDAwMDAwMDE1OSA2NTUzNSBmDQowMDAwMDAwMTYwIDY1NTM1IGYN CjAwMDAwMDAxNjEgNjU1MzUgZg0KMDAwMDAwMDE2MiA2NTUzNSBmDQowMDAwMDAwMTYzIDY1NTM1 IGYNCjAwMDAwMDAxNjQgNjU1MzUgZg0KMDAwMDAwMDE2NSA2NTUzNSBmDQowMDAwMDAwMTY2IDY1 NTM1IGYNCjAwMDAwMDAxNjcgNjU1MzUgZg0KMDAwMDAwMDE2OCA2NTUzNSBmDQowMDAwMDAwMTY5 IDY1NTM1IGYNCjAwMDAwMDAxNzAgNjU1MzUgZg0KMDAwMDAwMDE3MSA2NTUzNSBmDQowMDAwMDAw MTcyIDY1NTM1IGYNCjAwMDAwMDAxNzMgNjU1MzUgZg0KMDAwMDAwMDE3NCA2NTUzNSBmDQowMDAw MDAwMTc1IDY1NTM1IGYNCjAwMDAwMDAxNzYgNjU1MzUgZg0KMDAwMDAwMDE3NyA2NTUzNSBmDQow MDAwMDAwMTc4IDY1NTM1IGYNCjAwMDAwMDAxNzkgNjU1MzUgZg0KMDAwMDAwMDE4MCA2NTUzNSBm DQowMDAwMDAwMTgxIDY1NTM1IGYNCjAwMDAwMDAxODIgNjU1MzUgZg0KMDAwMDAwMDE4MyA2NTUz NSBmDQowMDAwMDAwMTg0IDY1NTM1IGYNCjAwMDAwMDAxODUgNjU1MzUgZg0KMDAwMDAwMDE4NiA2 NTUzNSBmDQowMDAwMDAwMTg3IDY1NTM1IGYNCjAwMDAwMDAxODggNjU1MzUgZg0KMDAwMDAwMDE4 OSA2NTUzNSBmDQowMDAwMDAwMTkwIDY1NTM1IGYNCjAwMDAwMDAxOTEgNjU1MzUgZg0KMDAwMDAw MDE5MiA2NTUzNSBmDQowMDAwMDAwMTkzIDY1NTM1IGYNCjAwMDAwMDAxOTQgNjU1MzUgZg0KMDAw MDAwMDE5NSA2NTUzNSBmDQowMDAwMDAwMTk2IDY1NTM1IGYNCjAwMDAwMDAxOTcgNjU1MzUgZg0K MDAwMDAwMDE5OCA2NTUzNSBmDQowMDAwMDAwMTk5IDY1NTM1IGYNCjAwMDAwMDAyMDAgNjU1MzUg Zg0KMDAwMDAwMDIwMSA2NTUzNSBmDQowMDAwMDAwMjAyIDY1NTM1IGYNCjAwMDAwMDAyMDMgNjU1 MzUgZg0KMDAwMDAwMDIwNCA2NTUzNSBmDQowMDAwMDAwMjA1IDY1NTM1IGYNCjAwMDAwMDAyMDYg NjU1MzUgZg0KMDAwMDAwMDIwNyA2NTUzNSBmDQowMDAwMDAwMjA4IDY1NTM1IGYNCjAwMDAwMDAy MDkgNjU1MzUgZg0KMDAwMDAwMDIxMCA2NTUzNSBmDQowMDAwMDAwMjExIDY1NTM1IGYNCjAwMDAw MDAyMTIgNjU1MzUgZg0KMDAwMDAwMDIxMyA2NTUzNSBmDQowMDAwMDAwMjE0IDY1NTM1IGYNCjAw MDAwMDAyMTUgNjU1MzUgZg0KMDAwMDAwMDIxNiA2NTUzNSBmDQowMDAwMDAwMjE3IDY1NTM1IGYN CjAwMDAwMDAyMTggNjU1MzUgZg0KMDAwMDAwMDIxOSA2NTUzNSBmDQowMDAwMDAwMjIwIDY1NTM1 IGYNCjAwMDAwMDAyMjEgNjU1MzUgZg0KMDAwMDAwMDIyMiA2NTUzNSBmDQowMDAwMDAwMjIzIDY1 NTM1IGYNCjAwMDAwMDAyMjQgNjU1MzUgZg0KMDAwMDAwMDIyNSA2NTUzNSBmDQowMDAwMDAwMjI2 IDY1NTM1IGYNCjAwMDAwMDAyMjcgNjU1MzUgZg0KMDAwMDAwMDIyOCA2NTUzNSBmDQowMDAwMDAw MjI5IDY1NTM1IGYNCjAwMDAwMDAyMzAgNjU1MzUgZg0KMDAwMDAwMDIzMSA2NTUzNSBmDQowMDAw MDAwMjMyIDY1NTM1IGYNCjAwMDAwMDAyMzMgNjU1MzUgZg0KMDAwMDAwMDIzNCA2NTUzNSBmDQow MDAwMDAwMjM1IDY1NTM1IGYNCjAwMDAwMDAyMzYgNjU1MzUgZg0KMDAwMDAwMDIzNyA2NTUzNSBm DQowMDAwMDAwMjM4IDY1NTM1IGYNCjAwMDAwMDAyMzkgNjU1MzUgZg0KMDAwMDAwMDI0MCA2NTUz NSBmDQowMDAwMDAwMjQxIDY1NTM1IGYNCjAwMDAwMDAyNDIgNjU1MzUgZg0KMDAwMDAwMDI0MyA2 NTUzNSBmDQowMDAwMDAwMjQ0IDY1NTM1IGYNCjAwMDAwMDAyNDUgNjU1MzUgZg0KMDAwMDAwMDI0 NiA2NTUzNSBmDQowMDAwMDAwMjQ3IDY1NTM1IGYNCjAwMDAwMDAyNDggNjU1MzUgZg0KMDAwMDAw MDI0OSA2NTUzNSBmDQowMDAwMDAwMjUwIDY1NTM1IGYNCjAwMDAwMDAyNTEgNjU1MzUgZg0KMDAw MDAwMDI1MiA2NTUzNSBmDQowMDAwMDAwMjUzIDY1NTM1IGYNCjAwMDAwMDAyNTQgNjU1MzUgZg0K MDAwMDAwMDI1NSA2NTUzNSBmDQowMDAwMDAwMjU2IDY1NTM1IGYNCjAwMDAwMDAyNTcgNjU1MzUg Zg0KMDAwMDAwMDI1OCA2NTUzNSBmDQowMDAwMDAwMjU5IDY1NTM1IGYNCjAwMDAwMDAyNjAgNjU1 MzUgZg0KMDAwMDAwMDI2MSA2NTUzNSBmDQowMDAwMDAwMjYyIDY1NTM1IGYNCjAwMDAwMDAyNjMg NjU1MzUgZg0KMDAwMDAwMDI2NCA2NTUzNSBmDQowMDAwMDAwMjY1IDY1NTM1IGYNCjAwMDAwMDAy NjYgNjU1MzUgZg0KMDAwMDAwMDI2NyA2NTUzNSBmDQowMDAwMDAwMjY4IDY1NTM1IGYNCjAwMDAw MDAyNjkgNjU1MzUgZg0KMDAwMDAwMDI3MCA2NTUzNSBmDQowMDAwMDAwMjcxIDY1NTM1IGYNCjAw MDAwMDAyNzIgNjU1MzUgZg0KMDAwMDAwMDI3MyA2NTUzNSBmDQowMDAwMDAwMjc0IDY1NTM1IGYN CjAwMDAwMDAyNzUgNjU1MzUgZg0KMDAwMDAwMDI3NiA2NTUzNSBmDQowMDAwMDAwMjc3IDY1NTM1 IGYNCjAwMDAwMDAyNzggNjU1MzUgZg0KMDAwMDAwMDI3OSA2NTUzNSBmDQowMDAwMDAwMjgwIDY1 NTM1IGYNCjAwMDAwMDAyODEgNjU1MzUgZg0KMDAwMDAwMDI4MiA2NTUzNSBmDQowMDAwMDAwMjgz IDY1NTM1IGYNCjAwMDAwMDAyODQgNjU1MzUgZg0KMDAwMDAwMDI4NSA2NTUzNSBmDQowMDAwMDAw Mjg2IDY1NTM1IGYNCjAwMDAwMDAyODcgNjU1MzUgZg0KMDAwMDAwMDI4OCA2NTUzNSBmDQowMDAw MDAwMjg5IDY1NTM1IGYNCjAwMDAwMDAyOTAgNjU1MzUgZg0KMDAwMDAwMDI5MSA2NTUzNSBmDQow MDAwMDAwMjkyIDY1NTM1IGYNCjAwMDAwMDAyOTMgNjU1MzUgZg0KMDAwMDAwMDI5NCA2NTUzNSBm DQowMDAwMDAwMjk1IDY1NTM1IGYNCjAwMDAwMDAyOTYgNjU1MzUgZg0KMDAwMDAwMDI5NyA2NTUz NSBmDQowMDAwMDAwMjk4IDY1NTM1IGYNCjAwMDAwMDAyOTkgNjU1MzUgZg0KMDAwMDAwMDMwMCA2 NTUzNSBmDQowMDAwMDAwMzAxIDY1NTM1IGYNCjAwMDAwMDAzMDIgNjU1MzUgZg0KMDAwMDAwMDMw MyA2NTUzNSBmDQowMDAwMDAwMzA0IDY1NTM1IGYNCjAwMDAwMDAzMDUgNjU1MzUgZg0KMDAwMDAw MDMwNiA2NTUzNSBmDQowMDAwMDAwMzA3IDY1NTM1IGYNCjAwMDAwMDAzMDggNjU1MzUgZg0KMDAw MDAwMDMwOSA2NTUzNSBmDQowMDAwMDAwMzEwIDY1NTM1IGYNCjAwMDAwMDAzMTEgNjU1MzUgZg0K MDAwMDAwMDMxMiA2NTUzNSBmDQowMDAwMDAwMzEzIDY1NTM1IGYNCjAwMDAwMDAzMTQgNjU1MzUg Zg0KMDAwMDAwMDMxNSA2NTUzNSBmDQowMDAwMDAwMzE2IDY1NTM1IGYNCjAwMDAwMDAzMTcgNjU1 MzUgZg0KMDAwMDAwMDMxOCA2NTUzNSBmDQowMDAwMDAwMzE5IDY1NTM1IGYNCjAwMDAwMDAzMjAg NjU1MzUgZg0KMDAwMDAwMDMyMSA2NTUzNSBmDQowMDAwMDAwMzIyIDY1NTM1IGYNCjAwMDAwMDAz MjMgNjU1MzUgZg0KMDAwMDAwMDMyNCA2NTUzNSBmDQowMDAwMDAwMzI1IDY1NTM1IGYNCjAwMDAw MDAzMjYgNjU1MzUgZg0KMDAwMDAwMDMyNyA2NTUzNSBmDQowMDAwMDAwMzI4IDY1NTM1IGYNCjAw MDAwMDAzMjkgNjU1MzUgZg0KMDAwMDAwMDMzMCA2NTUzNSBmDQowMDAwMDAwMzMxIDY1NTM1IGYN CjAwMDAwMDAzMzIgNjU1MzUgZg0KMDAwMDAwMDMzMyA2NTUzNSBmDQowMDAwMDAwMzM0IDY1NTM1 IGYNCjAwMDAwMDAzMzUgNjU1MzUgZg0KMDAwMDAwMDMzNiA2NTUzNSBmDQowMDAwMDAwMzM3IDY1 NTM1IGYNCjAwMDAwMDAzMzggNjU1MzUgZg0KMDAwMDAwMDMzOSA2NTUzNSBmDQowMDAwMDAwMzQw IDY1NTM1IGYNCjAwMDAwMDAzNDEgNjU1MzUgZg0KMDAwMDAwMDM0MiA2NTUzNSBmDQowMDAwMDAw MzQzIDY1NTM1IGYNCjAwMDAwMDAzNDQgNjU1MzUgZg0KMDAwMDAwMDM0NSA2NTUzNSBmDQowMDAw MDAwMzQ2IDY1NTM1IGYNCjAwMDAwMDAzNDcgNjU1MzUgZg0KMDAwMDAwMDM0OCA2NTUzNSBmDQow MDAwMDAwMzQ5IDY1NTM1IGYNCjAwMDAwMDAzNTAgNjU1MzUgZg0KMDAwMDAwMDM1MSA2NTUzNSBm DQowMDAwMDAwMzUyIDY1NTM1IGYNCjAwMDAwMDAzNTMgNjU1MzUgZg0KMDAwMDAwMDM1NCA2NTUz NSBmDQowMDAwMDAwMzU1IDY1NTM1IGYNCjAwMDAwMDAzNTYgNjU1MzUgZg0KMDAwMDAwMDM1NyA2 NTUzNSBmDQowMDAwMDAwMzU4IDY1NTM1IGYNCjAwMDAwMDAzNTkgNjU1MzUgZg0KMDAwMDAwMDM2 MCA2NTUzNSBmDQowMDAwMDAwMzYxIDY1NTM1IGYNCjAwMDAwMDAzNjIgNjU1MzUgZg0KMDAwMDAw MDM2MyA2NTUzNSBmDQowMDAwMDAwMzY0IDY1NTM1IGYNCjAwMDAwMDAzNjUgNjU1MzUgZg0KMDAw MDAwMDM2NiA2NTUzNSBmDQowMDAwMDAwMzY3IDY1NTM1IGYNCjAwMDAwMDAzNjggNjU1MzUgZg0K MDAwMDAwMDM2OSA2NTUzNSBmDQowMDAwMDAwMzcwIDY1NTM1IGYNCjAwMDAwMDAzNzEgNjU1MzUg Zg0KMDAwMDAwMDM3MiA2NTUzNSBmDQowMDAwMDAwMzczIDY1NTM1IGYNCjAwMDAwMDAzNzQgNjU1 MzUgZg0KMDAwMDAwMDM3NSA2NTUzNSBmDQowMDAwMDAwMzc2IDY1NTM1IGYNCjAwMDAwMDAzNzcg NjU1MzUgZg0KMDAwMDAwMDM3OCA2NTUzNSBmDQowMDAwMDAwMzc5IDY1NTM1IGYNCjAwMDAwMDAz ODAgNjU1MzUgZg0KMDAwMDAwMDM4MSA2NTUzNSBmDQowMDAwMDAwMzgyIDY1NTM1IGYNCjAwMDAw MDAzODMgNjU1MzUgZg0KMDAwMDAwMDM4NCA2NTUzNSBmDQowMDAwMDAwMzg1IDY1NTM1IGYNCjAw MDAwMDAzODYgNjU1MzUgZg0KMDAwMDAwMDM4NyA2NTUzNSBmDQowMDAwMDAwMzg4IDY1NTM1IGYN CjAwMDAwMDAzODkgNjU1MzUgZg0KMDAwMDAwMDM5MCA2NTUzNSBmDQowMDAwMDAwMzkxIDY1NTM1 IGYNCjAwMDAwMDAzOTIgNjU1MzUgZg0KMDAwMDAwMDM5MyA2NTUzNSBmDQowMDAwMDAwMzk0IDY1 NTM1IGYNCjAwMDAwMDAzOTUgNjU1MzUgZg0KMDAwMDAwMDM5NiA2NTUzNSBmDQowMDAwMDAwMzk3 IDY1NTM1IGYNCjAwMDAwMDAzOTggNjU1MzUgZg0KMDAwMDAwMDM5OSA2NTUzNSBmDQowMDAwMDAw NDAwIDY1NTM1IGYNCjAwMDAwMDA0MDEgNjU1MzUgZg0KMDAwMDAwMDQwMiA2NTUzNSBmDQowMDAw MDAwNDAzIDY1NTM1IGYNCjAwMDAwMDA0MDQgNjU1MzUgZg0KMDAwMDAwMDQwNSA2NTUzNSBmDQow MDAwMDAwNDA2IDY1NTM1IGYNCjAwMDAwMDA0MDcgNjU1MzUgZg0KMDAwMDAwMDQwOCA2NTUzNSBm DQowMDAwMDAwNDA5IDY1NTM1IGYNCjAwMDAwMDA0MTAgNjU1MzUgZg0KMDAwMDAwMDQxMSA2NTUz NSBmDQowMDAwMDAwNDEyIDY1NTM1IGYNCjAwMDAwMDA0MTMgNjU1MzUgZg0KMDAwMDAwMDQxNCA2 NTUzNSBmDQowMDAwMDAwNDE1IDY1NTM1IGYNCjAwMDAwMDA0MTYgNjU1MzUgZg0KMDAwMDAwMDQx NyA2NTUzNSBmDQowMDAwMDAwNDE4IDY1NTM1IGYNCjAwMDAwMDA0MTkgNjU1MzUgZg0KMDAwMDAw MDQyMCA2NTUzNSBmDQowMDAwMDAwNDIxIDY1NTM1IGYNCjAwMDAwMDA0MjIgNjU1MzUgZg0KMDAw MDAwMDQyMyA2NTUzNSBmDQowMDAwMDAwNDI0IDY1NTM1IGYNCjAwMDAwMDA0MjUgNjU1MzUgZg0K MDAwMDAwMDQyNiA2NTUzNSBmDQowMDAwMDAwNDI3IDY1NTM1IGYNCjAwMDAwMDA0MjggNjU1MzUg Zg0KMDAwMDAwMDQyOSA2NTUzNSBmDQowMDAwMDAwNDMwIDY1NTM1IGYNCjAwMDAwMDA0MzEgNjU1 MzUgZg0KMDAwMDAwMDQzMiA2NTUzNSBmDQowMDAwMDAwNDMzIDY1NTM1IGYNCjAwMDAwMDA0MzQg NjU1MzUgZg0KMDAwMDAwMDQzNSA2NTUzNSBmDQowMDAwMDAwNDM2IDY1NTM1IGYNCjAwMDAwMDA0 MzcgNjU1MzUgZg0KMDAwMDAwMDQzOCA2NTUzNSBmDQowMDAwMDAwNDM5IDY1NTM1IGYNCjAwMDAw MDA0NDAgNjU1MzUgZg0KMDAwMDAwMDQ0MSA2NTUzNSBmDQowMDAwMDAwNDQyIDY1NTM1IGYNCjAw MDAwMDA0NDMgNjU1MzUgZg0KMDAwMDAwMDQ0NCA2NTUzNSBmDQowMDAwMDAwNDQ1IDY1NTM1IGYN CjAwMDAwMDA0NDYgNjU1MzUgZg0KMDAwMDAwMDQ0NyA2NTUzNSBmDQowMDAwMDAwNDQ4IDY1NTM1 IGYNCjAwMDAwMDA0NDkgNjU1MzUgZg0KMDAwMDAwMDQ1MCA2NTUzNSBmDQowMDAwMDAwNDUxIDY1 NTM1IGYNCjAwMDAwMDA0NTIgNjU1MzUgZg0KMDAwMDAwMDQ1MyA2NTUzNSBmDQowMDAwMDAwNDU0 IDY1NTM1IGYNCjAwMDAwMDA0NTUgNjU1MzUgZg0KMDAwMDAwMDQ1NiA2NTUzNSBmDQowMDAwMDAw NDU3IDY1NTM1IGYNCjAwMDAwMDA0NTggNjU1MzUgZg0KMDAwMDAwMDQ1OSA2NTUzNSBmDQowMDAw MDAwNDYwIDY1NTM1IGYNCjAwMDAwMDA0NjEgNjU1MzUgZg0KMDAwMDAwMDQ2MiA2NTUzNSBmDQow MDAwMDAwNDYzIDY1NTM1IGYNCjAwMDAwMDA0NjQgNjU1MzUgZg0KMDAwMDAwMDQ2NSA2NTUzNSBm DQowMDAwMDAwNDY2IDY1NTM1IGYNCjAwMDAwMDA0NjcgNjU1MzUgZg0KMDAwMDAwMDQ2OCA2NTUz NSBmDQowMDAwMDAwNDY5IDY1NTM1IGYNCjAwMDAwMDA0NzAgNjU1MzUgZg0KMDAwMDAwMDQ3MSA2 NTUzNSBmDQowMDAwMDAwNDcyIDY1NTM1IGYNCjAwMDAwMDA0NzMgNjU1MzUgZg0KMDAwMDAwMDQ3 NCA2NTUzNSBmDQowMDAwMDAwNDc1IDY1NTM1IGYNCjAwMDAwMDA0NzYgNjU1MzUgZg0KMDAwMDAw MDQ3NyA2NTUzNSBmDQowMDAwMDAwNDc4IDY1NTM1IGYNCjAwMDAwMDA0NzkgNjU1MzUgZg0KMDAw MDAwMDQ4MCA2NTUzNSBmDQowMDAwMDAwNDgxIDY1NTM1IGYNCjAwMDAwMDA0ODIgNjU1MzUgZg0K MDAwMDAwMDQ4MyA2NTUzNSBmDQowMDAwMDAwNDg0IDY1NTM1IGYNCjAwMDAwMDA0ODUgNjU1MzUg Zg0KMDAwMDAwMDQ4NiA2NTUzNSBmDQowMDAwMDAwNDg3IDY1NTM1IGYNCjAwMDAwMDA0ODggNjU1 MzUgZg0KMDAwMDAwMDQ4OSA2NTUzNSBmDQowMDAwMDAwNDkwIDY1NTM1IGYNCjAwMDAwMDA0OTEg NjU1MzUgZg0KMDAwMDAwMDQ5MiA2NTUzNSBmDQowMDAwMDAwNDkzIDY1NTM1IGYNCjAwMDAwMDA0 OTQgNjU1MzUgZg0KMDAwMDAwMDQ5NSA2NTUzNSBmDQowMDAwMDAwNDk2IDY1NTM1IGYNCjAwMDAw MDA0OTcgNjU1MzUgZg0KMDAwMDAwMDQ5OCA2NTUzNSBmDQowMDAwMDAwNDk5IDY1NTM1IGYNCjAw MDAwMDA1MDAgNjU1MzUgZg0KMDAwMDAwMDUwMSA2NTUzNSBmDQowMDAwMDAwNTAyIDY1NTM1IGYN CjAwMDAwMDA1MDMgNjU1MzUgZg0KMDAwMDAwMDUwNCA2NTUzNSBmDQowMDAwMDAwNTA1IDY1NTM1 IGYNCjAwMDAwMDA1MDYgNjU1MzUgZg0KMDAwMDAwMDUwNyA2NTUzNSBmDQowMDAwMDAwNTA4IDY1 NTM1IGYNCjAwMDAwMDA1MDkgNjU1MzUgZg0KMDAwMDAwMDUxMCA2NTUzNSBmDQowMDAwMDAwNTEx IDY1NTM1IGYNCjAwMDAwMDA1MTIgNjU1MzUgZg0KMDAwMDAwMDUxMyA2NTUzNSBmDQowMDAwMDAw NTE0IDY1NTM1IGYNCjAwMDAwMDA1MTUgNjU1MzUgZg0KMDAwMDAwMDUxNiA2NTUzNSBmDQowMDAw MDAwNTE3IDY1NTM1IGYNCjAwMDAwMDA1MTggNjU1MzUgZg0KMDAwMDAwMDUxOSA2NTUzNSBmDQow MDAwMDAwNTIwIDY1NTM1IGYNCjAwMDAwMDA1MjEgNjU1MzUgZg0KMDAwMDAwMDUyMiA2NTUzNSBm DQowMDAwMDAwNTIzIDY1NTM1IGYNCjAwMDAwMDA1MjQgNjU1MzUgZg0KMDAwMDAwMDUyNSA2NTUz NSBmDQowMDAwMDAwNTI2IDY1NTM1IGYNCjAwMDAwMDA1MjcgNjU1MzUgZg0KMDAwMDAwMDUyOCA2 NTUzNSBmDQowMDAwMDAwNTI5IDY1NTM1IGYNCjAwMDAwMDA1MzAgNjU1MzUgZg0KMDAwMDAwMDUz MSA2NTUzNSBmDQowMDAwMDAwNTMyIDY1NTM1IGYNCjAwMDAwMDA1MzMgNjU1MzUgZg0KMDAwMDAw MDUzNCA2NTUzNSBmDQowMDAwMDAwNTM1IDY1NTM1IGYNCjAwMDAwMDA1MzYgNjU1MzUgZg0KMDAw MDAwMDUzNyA2NTUzNSBmDQowMDAwMDAwNTM4IDY1NTM1IGYNCjAwMDAwMDA1MzkgNjU1MzUgZg0K MDAwMDAwMDU0MCA2NTUzNSBmDQowMDAwMDAwNTQxIDY1NTM1IGYNCjAwMDAwMDA1NDIgNjU1MzUg Zg0KMDAwMDAwMDU0MyA2NTUzNSBmDQowMDAwMDAwNTQ0IDY1NTM1IGYNCjAwMDAwMDA1NDUgNjU1 MzUgZg0KMDAwMDAwMDU0NiA2NTUzNSBmDQowMDAwMDAwNTQ3IDY1NTM1IGYNCjAwMDAwMDA1NDgg NjU1MzUgZg0KMDAwMDAwMDU0OSA2NTUzNSBmDQowMDAwMDAwNTUwIDY1NTM1IGYNCjAwMDAwMDA1 NTEgNjU1MzUgZg0KMDAwMDAwMDU1MiA2NTUzNSBmDQowMDAwMDAwNTUzIDY1NTM1IGYNCjAwMDAw MDAwMDAgNjU1MzUgZg0KMDAwMDMwODE2NSAwMDAwMCBuDQowMDAwMzA4NTY3IDAwMDAwIG4NCjAw MDA0MDQzNTYgMDAwMDAgbg0KMDAwMDQwNTA0OSAwMDAwMCBuDQowMDAwNDA1Mzk5IDAwMDAwIG4N CjAwMDA0MDU3OTIgMDAwMDAgbg0KMDAwMDQ4NzU2OSAwMDAwMCBuDQowMDAwNDg3ODcxIDAwMDAw IG4NCjAwMDA0ODgxMDkgMDAwMDAgbg0KMDAwMDQ4ODMxOSAwMDAwMCBuDQowMDAwNTY2Mzg4IDAw MDAwIG4NCnRyYWlsZXINCjw8L1NpemUgNTY1L1Jvb3QgMSAwIFIvSW5mbyAxNTIgMCBSL0lEWzxG ODFENDFEQTNBOTYzRTQ4QTJBNDFBOEVDRDZGN0JDMj48RjgxRDQxREEzQTk2M0U0OEEyQTQxQThF Q0Q2RjdCQzI+XSA+Pg0Kc3RhcnR4cmVmDQo1Njc5MjgNCiUlRU9GDQp4cmVmDQowIDANCnRyYWls ZXINCjw8L1NpemUgNTY1L1Jvb3QgMSAwIFIvSW5mbyAxNTIgMCBSL0lEWzxGODFENDFEQTNBOTYz RTQ4QTJBNDFBOEVDRDZGN0JDMj48RjgxRDQxREEzQTk2M0U0OEEyQTQxQThFQ0Q2RjdCQzI+XSAv UHJldiA1Njc5MjgvWFJlZlN0bSA1NjYzODg+Pg0Kc3RhcnR4cmVmDQo1NzkzODkNCiUlRU9G --_002_55E78A57290FB64FA0D3CF672F9F3DA21BC41CSJCPEX01CL03citri_ Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Disposition: inline _______________________________________________ Xen-devel mailing list Xen-devel@lists.xen.org http://lists.xen.org/xen-devel --_002_55E78A57290FB64FA0D3CF672F9F3DA21BC41CSJCPEX01CL03citri_-- From advisory-board-bounces@lists.xenproject.org Thu Mar 20 10:37:09 2014 Return-path: Envelope-to: archives@lists.xenproject.org Delivery-date: Thu, 20 Mar 2014 10:37:09 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WQaLV-0000Pj-0k; Thu, 20 Mar 2014 10:37:09 +0000 Received: from mail6.bemta4.messagelabs.com ([85.158.143.247]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WQaLS-0000Pc-Rb for advisory-board@lists.xenproject.org; Thu, 20 Mar 2014 10:37:07 +0000 Received: from [85.158.143.35:59171] by server-3.bemta-4.messagelabs.com id E9/15-13602-2D4CA235; Thu, 20 Mar 2014 10:37:06 +0000 X-Env-Sender: lars.kurth@citrix.com X-Msg-Ref: server-3.tower-21.messagelabs.com!1395311822!3477107!1 X-Originating-IP: [185.25.65.24] X-SpamReason: No, hits=-1.2 required=7.0 tests=BODY_RANDOM_LONG, HTML_MESSAGE, MIME_BASE64_TEXT, ML_RADAR_FP_R_14, ML_RADAR_SPEW_LINKS_23, spamassassin: X-StarScan-Received: X-StarScan-Version: 6.11.1; banners=-,-,- X-VirusChecked: Checked Received: (qmail 7054 invoked from network); 20 Mar 2014 10:37:02 -0000 Received: from smtp.ctxuk.citrix.com (HELO SMTP.EU.CITRIX.COM) (185.25.65.24) by server-3.tower-21.messagelabs.com with RC4-SHA encrypted SMTP; 20 Mar 2014 10:37:02 -0000 X-IronPort-AV: E=Sophos;i="4.97,694,1389744000"; d="scan'208,217";a="11869058" Received: from unknown (HELO AMSPEX01CL03.citrite.net) ([10.69.60.9]) by AMSPIP01.EU.Citrix.com with ESMTP; 20 Mar 2014 10:37:01 +0000 Received: from AMSPEX01CL01.citrite.net ([169.254.6.75]) by AMSPEX01CL03.citrite.net ([169.254.8.213]) with mapi id 14.02.0342.004; Thu, 20 Mar 2014 11:37:01 +0100 From: Lars Kurth To: Advisory-board discussions , "Wilson, Matt" Thread-Topic: [Advisory-board] Xen Project 4.4 Release Thread-Index: AQHPN+cAYPnpGnlFV0a962jsY+l2QprRWUcAgAEhoYCAADaigIAAB6+AgAGNyACAAMWPAIAAgM2AgAAhlACAAB8agIAAA7eAgAATlQCAADJIAIAAHO0AgBOsLtA= Date: Thu, 20 Mar 2014 10:37:01 +0000 Message-ID: References: <6848793A-A83B-40A1-A40C-2AA9DCC1E80A@citrix.com> <2BCAC582-CB61-4E16-96C4-6C1AEFAF81FB@citrix.com> <545D5AEE-789B-4534-9983-A9EA3FD1ECC1@citrix.com> <25264475-F9F3-401F-A7E8-579896CD2D0B@citrix.com> , In-Reply-To: Accept-Language: en-GB, en-US Content-Language: en-GB X-MS-Has-Attach: X-MS-TNEF-Correlator: x-originating-ip: [10.69.46.1] MIME-Version: 1.0 X-DLP: AMS1 Cc: Jennifer Cloer Subject: Re: [Advisory-board] Xen Project 4.4 Release X-BeenThere: advisory-board@lists.xenproject.org X-Mailman-Version: 2.1.13 Precedence: list Reply-To: Advisory-board discussions List-Id: Advisory-board discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: multipart/mixed; boundary="===============4997032678153424191==" Sender: advisory-board-bounces@lists.xenproject.org Errors-To: advisory-board-bounces@lists.xenproject.org --===============4997032678153424191== Content-Language: en-GB Content-Type: multipart/alternative; boundary="_000_B5EC053C78C5D746BD8AC3386F2303C9157318AMSPEX01CL01citri_" --_000_B5EC053C78C5D746BD8AC3386F2303C9157318AMSPEX01CL01citri_ Content-Type: text/plain; charset="big5" Content-Transfer-Encoding: base64 U2FyYWgsDQpmcm9tIHRoZSBjb3ZlcmFnZSBJIGhhdmUgc2VlbiBpdCBsb29rcyBhcyBpZiB3ZSBk aWQgd2VsbA0KUmVnYXJkcw0KTGFycw0KX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18N CkZyb206IGFkdmlzb3J5LWJvYXJkLWJvdW5jZXNAbGlzdHMueGVucHJvamVjdC5vcmcgW2Fkdmlz b3J5LWJvYXJkLWJvdW5jZXNAbGlzdHMueGVucHJvamVjdC5vcmddIG9uIGJlaGFsZiBvZiBTYXJh aCBDb253YXkgW3Njb253YXlAbGludXhmb3VuZGF0aW9uLm9yZ10NClNlbnQ6IDA3IE1hcmNoIDIw MTQgMjM6MTENClRvOiBXaWxzb24sIE1hdHQNCkNjOiBBZHZpc29yeS1ib2FyZCBkaXNjdXNzaW9u czsgSmVubmlmZXIgQ2xvZXINClN1YmplY3Q6IFJlOiBbQWR2aXNvcnktYm9hcmRdIFhlbiBQcm9q ZWN0IDQuNCBSZWxlYXNlDQoNCkhpIGFsbCwNCg0KSSd2ZSBhZ2dyZWdhdGVkIGFsbCBlZGl0cyBh bmQgaGF2ZSBkb25lIGEgbGVnYWwgcmV2aWV3IG9mIHRoZSBicmFuZCBuYW1lIHVzZS4NCg0KU2V2 ZXJhbCByZXBvcnRlcnMgYXJlIHBsYW5uaW5nIGFydGljbGVzIGZvciBNb25kYXkgQU0gd2hlbiB0 aGUgZW1iYXJnbyBsaWZ0cyBvbiB0aGlzIHJlbGVhc2UuDQoNCkknbSBjbG9zaW5nIGVkaXRzIG5v dyBhbmQgZmluYWxpemluZyBmb3IgdGhlIHdpcmUuIEknbGwgd29yayB3aXRoIExhcnMgYW5kIEpl bm5pZmVyIG1vdmluZyBmb3J3YXJkIHRvIGltcHJvdmUgdGhlIHdyaXRpbmcgYW5kIGVzdGFibGlz aCBhIGJldHRlciByZXZpZXcgcHJvY2Vzcy4NCg0KVGhhbmtzLA0KDQoNCg0KDQoNCk9uIEZyaSwg TWFyIDcsIDIwMTQgYXQgNDoyNyBQTSwgV2lsc29uLCBNYXR0IDxtc3dAYW1hem9uLmNvbTxtYWls dG86bXN3QGFtYXpvbi5jb20+PiB3cm90ZToNCg0KSW4gcGFydGljdWxhcjoNCg0KIlhlbiBQcm9q ZWN0IDQuNCBIeXBlcnZpc29yIiAtPiAiWGVuIFByb2plY3QgSHlwZXJ2aXNvciB2ZXJzaW9uIDQu NCINCg0KIlRoaXMgcmVsZWFzZSBmdXJ0aGVyIGFkdmFuY2VzIHRoZSBQcm9qZWN0oaZzIHBvc2l0 aW9uIGFzIGEgZmFzdCwgc2NhbGFibGUsIHNlY3VyZSB2aXJ0dWFsaXphdGlvbiBlbmdpbmUgZm9y IHRoZSBpbmR1c3RyeaGmcyBicm9hZGVzdCByYW5nZSBvZiBzZXJ2ZXIsIFBDIGNoaXBzZXRzIGFu ZCBuZXh0LWdlbmVyYXRpb24gbG93LXBvd2VyIHN5c3RlbSBvbiBjaGlwcyAoU29DKSBkZXZpY2Vz LiIgIFBDIGNoaXBzZXRzPyBXb3VsZG4ndCBpdCBtYWtlIG1vcmUgc2Vuc2UgdG8gc2F5IHNvbWV0 aGluZyBsaWtlICJzZXJ2ZXIsIHdvcmtzdGF0aW9uIGFuZCBsb3ctcG93ZXIgc3lzdGVtIG9uIGEg Y2hpcCAoU29DKSBkZXZpY2VzIj8gTm90ZSB0aGUgZHJvcCBvZiAibmV4dC1nZW5lcmF0aW9uIiBz aW5jZSBTb0MgaXMgcXVpdGUgZXN0YWJsaXNoZWQgdG9kYXkuDQoNCiJBZGRpdGlvbmFsbHksIGRl dmVsb3BlcnMgY3JlYXRpbmcgc2VydmljZXMgYW5kIGFwcHMgd2l0aCBlbWJlZGRlZCwgbW9iaWxl IGFuZCBjbG91ZCBzeXN0ZW1zIHdpbGwgYmVuZWZpdCBmcm9tIHRoZSB1cGRhdGVkIGV2ZW50IGNo YW5uZWwgaW1wbGVtZW50YXRpb24gd2hlbiBzY2FsaW5nIG91dCB0aGVpciBJbmZyYXN0cnVjdHVy ZSBhcyBhIFNlcnZpY2Ugb2ZmZXJpbmdzLiIgImFwcHMiIC0+ICJhcHBsaWNhdGlvbnMiLg0KDQpX ZSBuZWVkIHRvIGhhdmUgYSBkZWxpYmVyYXRlIGRlY2lzaW9uIHRvIGludHJvZHVjZSAiWGVuIFBy b2plY3QgQXJjaGl0ZWN0dXJlIiBpbiBvdXIgbm9tZW5jbGF0dXJlLiBJJ20gbm90IGF3YXJlIG9m IGEgdXNlIGxpa2UgdGhpcyBpbiB0aGUgcGFzdC4NCg0KIkFsbCB0aGUgdXNlcnNwYWNlIHRvb2xz LCBzdWNoIGFzIHRoZSB4bCBtYW5hZ2VtZW50IHRvb2wsIGFyZSA2NC1iaXQgcmVhZHkgYW5kIGNh biBiZSB1c2VkIHRvIGNyZWF0ZSA2NC1iaXQgdmlydHVhbCBtYWNoaW5lcyBvdXQgb2YgdGhlIGJv eC4iIC0gd3JpdHRlbiBsaWtlIGEgZGV2ZWxvcGVyIChubyBvZmZlbnNlIHRvIGRldmVsb3BlcnMg b24gdGhpcyBsaXN0KS4NCg0KDQoiVG9wIGNvbnRyaWJ1dG9ycyBpbmNsdWRlIEFtYXpvbiwgQU1E LCBBbmFsb2cgRGV2aWNlcywgQnJvYWRjb20sIENpdHJpeCwgRnVqaXRzdSwgSW50ZWwsIExpbmFy bywgTlNBLCBPcmFjbGUsIFN1c2UsIFZlcml6b24vVGVycmVtYXJrLCBwbHVzIG51bWVyb3VzIGlu ZGl2aWR1YWwgYW5kIGFjYWRlbWljIGNvbnRyaWJ1dG9ycy4gIkFtYXpvbiIgbXVzdCBiZSAiQW1h em9uIFdlYiBTZXJ2aWNlcyIuICJTdXNlIiBzaG91bGQgYmUgIlNVU0UiLiAicGx1cyIgc2hvdWxk IGJlIHNvbWV0aGluZyBsaWtlICJhbG9uZyB3aXRoIi4gIlRvcCBjb250cmlidXRvcnMgLi4gYWNh ZGVtaWMgY29udHJpYnV0b3JzIiBpcyBhIGJpdCByZWR1bmRhbnQuIFBlcmhhcHMgImFjYWRlbWlj IGluc3RpdHV0aW9ucyI/DQoNCg0KDQpUaGVyZSdzIGEgbG90IG9mIHJvb20gZm9yIGltcHJvdmVt ZW50IG9uIHRoaXMuIEluY29ycG9yYXRpbmcgYSBmZXcga2V5IGNoYW5nZXMgaXNuJ3QgcmVhbGx5 IGdvaW5nIHRvIG1ha2UgdGhpcyBhIHF1YWxpdHkgcmVsZWFzZSB3aXRoIGEgc3Ryb25nIHN0b3J5 LiBPdmVyYWxsLCBJJ20gcXVpdGUgc3VycHJpc2VkIGFuZCBkaXNhcHBvaW50ZWQgd2l0aCB0aGUg Y3VycmVudCBzdGF0ZS4NCg0KLS1tc3cNCg0KX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X18NCkZyb206IGFkdmlzb3J5LWJvYXJkLWJvdW5jZXNAbGlzdHMueGVucHJvamVjdC5vcmc8bWFp bHRvOmFkdmlzb3J5LWJvYXJkLWJvdW5jZXNAbGlzdHMueGVucHJvamVjdC5vcmc+IFthZHZpc29y eS1ib2FyZC1ib3VuY2VzQGxpc3RzLnhlbnByb2plY3Qub3JnPG1haWx0bzphZHZpc29yeS1ib2Fy ZC1ib3VuY2VzQGxpc3RzLnhlbnByb2plY3Qub3JnPl0gb24gYmVoYWxmIG9mIE1hcmsgSGlua2xl IFtNYXJrLkhpbmtsZUBjaXRyaXguY29tPG1haWx0bzpNYXJrLkhpbmtsZUBjaXRyaXguY29tPl0N ClNlbnQ6IEZyaWRheSwgTWFyY2ggMDcsIDIwMTQgMTA6MjcgQU0NCg0KVG86IEFkdmlzb3J5LWJv YXJkIGRpc2N1c3Npb25zDQpDYzogSmVubmlmZXIgQ2xvZXINClN1YmplY3Q6IFJlOiBbQWR2aXNv cnktYm9hcmRdIFhlbiBQcm9qZWN0IDQuNCBSZWxlYXNlDQoNCkkgZG9uoaZ0IGRpc2FncmVlIHdp dGggTWF0dCB0aGUgdGV4dCBpcyAgYXdrd2FyZCBwYXJ0aWN1bGFybHkgYmVjYXVzZSBvZiBpdKGm cyBoaWdobHkgdGVjaG5pY2FsIG5hdHVyZS4gRG8geW91IGhhdmUgYW55IHNwZWNpZmljIGZlZWRi YWNrIGZvciBTYXJhaCB0byBpbmNvcnBvcmF0ZS4gSSBkaWRuoaZ0IHdhbnQgdG8gcHVzaCB0b28g aGFyZCBzaW5jZSB0aGUgY2xvY2sgaXMgdGlja2luZyBidXQgd2Ugc2hvdWxkIGdldCB0aGlzIHJp Z2h0Lg0KDQpHb2luZyBmb3J3YXJkIEkgd291bGQgbGlrZSB0byBzdWdnZXN0IHVzaW5nIE9yYWNs ZaGmcyBidWxsZXRlZCBsaXN0IGZvcm1hdCBmb3IgdGhlaXIgcHJlc3MgcmVsZWFzZXMgc2luY2Ug dHlpbmcgdG9nZXRoZXIgdGhlIGFjdHVhbCBuZXdzIGFuZCB0ZWNoIGNvbnRlbnQgaW50byBhIGNv bXBlbGxpbmcgbmFycmF0aXZlIGlzIHByZXR0eSB0b3VnaC4gSGVyZSBhbiBleGFtcGxlIG9mIHdo YXQgSaGmZCBwcm9wb3NlLg0KDQpodHRwOi8vd3d3Lm9yYWNsZS5jb20vdXMvY29ycG9yYXRlL3By ZXNzLzIwMzMzNzYNCg0KUmVnYXJkcywgTWFyaw0KDQoNCk9uIE1hciA3LCAyMDE0LCBhdCAxMjox NyBQTSwgV2lsc29uLCBNYXR0IDxtc3dAYW1hem9uLmNvbTxtYWlsdG86bXN3QGFtYXpvbi5jb20+ PiB3cm90ZToNCg0KSSdtIG5vdCBzYXRpc2ZpZWQgd2l0aCB0aGUgcXVhbGl0eSBvZiB0aGlzIHRl eHQgKHR5cG9zLCBldGMuKSBnaXZlbiB0aGUgcGxhbiB0byBwdXQgaXQgb24gdGhlIHdpcmUgTW9u ZGF5LiBXZSBzdGlsbCBkb24ndCBoYXZlIGEgc3Ryb25nIG1lc3NhZ2UgYW5kIGEgcGxhbiBvbiBo b3cgd2UgcGxhbiB0byBicmFuZCB0aGUgdGVjaG5vbG9naWVzIHRoYXQgYXJlIHByb2R1Y2VkIGJ5 IHRoZSBjb21tdW5pdHkuDQoNCi0tbXN3DQoNCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fDQpGcm9tOiBhZHZpc29yeS1ib2FyZC1ib3VuY2VzQGxpc3RzLnhlbnByb2plY3Qub3JnPG1h aWx0bzphZHZpc29yeS1ib2FyZC1ib3VuY2VzQGxpc3RzLnhlbnByb2plY3Qub3JnPiBbYWR2aXNv cnktYm9hcmQtYm91bmNlc0BsaXN0cy54ZW5wcm9qZWN0Lm9yZzxtYWlsdG86YWR2aXNvcnktYm9h cmQtYm91bmNlc0BsaXN0cy54ZW5wcm9qZWN0Lm9yZz5dIG9uIGJlaGFsZiBvZiBNYXJrIEhpbmts ZSBbTWFyay5IaW5rbGVAY2l0cml4LmNvbTxtYWlsdG86TWFyay5IaW5rbGVAY2l0cml4LmNvbT5d DQpTZW50OiBGcmlkYXksIE1hcmNoIDA3LCAyMDE0IDk6MDQgQU0NClRvOiBBZHZpc29yeS1ib2Fy ZCBkaXNjdXNzaW9ucw0KQ2M6IEplbm5pZmVyIENsb2VyDQpTdWJqZWN0OiBSZTogW0Fkdmlzb3J5 LWJvYXJkXSBYZW4gUHJvamVjdCA0LjQgUmVsZWFzZQ0KDQpTYXJhaCwNCg0KQnJhbmRpbmcgc2Vl bXMgdG8gYmUgYXBwbGllZCBhcHByb3ByaWF0ZWx5IHRob3VnaCBJIHRoaW5rIHRoZXJlIHdlcmUg YSBjb3VwbGUgb2Ygc3BlbGxpbmcgaXNzdWVzIEkgY2F1Z2h0LiBBdHRhY2hlZCBpcyBmaW5lIGJ5 IG1lIHRob3VnaCB0aGUgYnJhbmRpbmcgYW5kIGZsb3cgaXMgc3RpbGwgYSBiaXQgY2hhbGxlbmdp bmcuDQoNCk1hcmsNCg0KDQpPbiBNYXIgNywgMjAxNCwgYXQgMTA6MTMgQU0sIFNhcmFoIENvbndh eSA8c2NvbndheUBsaW51eGZvdW5kYXRpb24ub3JnPG1haWx0bzpzY29ud2F5QGxpbnV4Zm91bmRh dGlvbi5vcmc+PiB3cm90ZToNCg0KSGkgZXZlcnlvbmUuDQoNCkkndmUgaW5jb3Jwb3JhdGVkIGV2 ZXJ5b25lJ3MgZWRpdHMuIEkgdHJpZWQgdG8gcmVjb25jaWxlIHRoZSBUTS1yZWxhdGVkIGlzc3Vl cyBvZiBicmFuZCBjb25mdXNpb24gYW5kIGZsb3cgYXMgYmVzdCBJIGNvdWxkLiBBcyB5b3UgY2Fu IGltYWdpbmUsIEkgZ290IHZhcnlpbmcgZWRpdHMsIHdoaWNoIHN0YXJ0ZWQgdG8gY29uZmxpY3Qg d2l0aCBvbmUgYW5vdGhlci4NCg0KVGhpcyB3b3VsZCBiZW5lZml0IGZyb20gYW5vdGhlciBUTSBy ZXZpZXcvZmluYWwgYXBwcm92YWwuIENhbiBzb21lb25lIHN0ZXAgdXAgdG8gZG8gdGhpcyBhbmQg bWFrZSBhIGZpbmFsIGNhbGw/DQoNCk1pa2UgRC4sIENpdHJpeCBpcyBvbiB0aGUgZnVsbCBBQiBl bWFpbCBsaXN0IHNvIHRoZXkndmUgYmVlbiBpbnZvbHZlZCBpbiByZXZpZXdzLg0KDQpQbGVhc2Ug YWR2aXNlIHNvb25lc3QuDQoNClRoYW5rcywNCg0KDQoNCg0KT24gRnJpLCBNYXIgNywgMjAxNCBh dCA4OjEzIEFNLCBSaWNoYXJkIFBoZWxhbiA8UmljaGFyZC5QaGVsYW5AYXJtLmNvbTxtYWlsdG86 UmljaGFyZC5QaGVsYW5AYXJtLmNvbT4+IHdyb3RlOg0KSGksDQoNCkkgYWdyZWUgd2l0aCBNYXJr IGFzIHRoZSBjdXJyZW50IHByZXNzIHJlbGVhc2UgaXMgaGlnaGxpZ2h0aW5nIGlzc3VlcyB0aGF0 IHNlZW0gdG8gbWFrZSB0aGUgYXJ0aWN1bGF0aW9uIG9mIGJyYW5kIGFuZCBicmFuZCB2YWx1ZXMg bW9yZSBjdW1iZXJzb21lIHRoYW4gaXMgZGVzaXJhYmxlLg0KDQpJJ20gaGFwcHkgdG8gZ28gd2l0 aCB0aGUgcHJvcG9zZWQgY2hhbmdlcyBmb3IgdGhlIHJlYXNvbnMgc3RhdGVkLg0KDQpPbmUgbWlu b3IgcG9pbnQsIEknZCBwcmVmZXIgIj+mU3lzdGVtIG9uIENoaXAgKFNvQykgZGV2aWNlcy4iLCB0 d28gc2V0cyBvZiBwbHVyYWxzIG1ha2UgaXQgdW5jbGVhciBob3cgbWFueSBzeXN0ZW1zIGFyZSBv biBlYWNoIGNoaXAgYW5kIHRoZSBwbHVyYWxzIGdldCBzdWJtZXJnZWQgaW50byB0aGUgYWNyb255 bTsgY29tbW9uIHVzYWdlIHNlZW1zIHRvIGJlIFNvQ3MuDQoNClRoYW5rcywNCg0KUmljaGFyZC4N Cg0KRnJvbTogTWFyayBIaW5rbGUgPE1hcmsuSGlua2xlQGNpdHJpeC5jb208bWFpbHRvOk1hcmsu SGlua2xlQGNpdHJpeC5jb20+Pg0KUmVwbHktVG86IEFkdmlzb3J5LWJvYXJkIGRpc2N1c3Npb25z IDxhZHZpc29yeS1ib2FyZEBsaXN0cy54ZW5wcm9qZWN0Lm9yZzxtYWlsdG86YWR2aXNvcnktYm9h cmRAbGlzdHMueGVucHJvamVjdC5vcmc+Pg0KRGF0ZTogRnJpZGF5LCA3IE1hcmNoIDIwMTQgMDU6 MzINClRvOiBBZHZpc29yeS1ib2FyZCBkaXNjdXNzaW9ucyA8YWR2aXNvcnktYm9hcmRAbGlzdHMu eGVucHJvamVjdC5vcmc8bWFpbHRvOmFkdmlzb3J5LWJvYXJkQGxpc3RzLnhlbnByb2plY3Qub3Jn Pj4NCg0KU3ViamVjdDogUmU6IFtBZHZpc29yeS1ib2FyZF0gWGVuIFByb2plY3QgNC40IFJlbGVh c2UNCg0KTXkgYXBvbG9naWVzIGZvciB0aGUgc2xvdyByZXBseSBJIHdhcyBzdHVjayBvbiB0aGUg cm9hZCBhbmQgY291bGRuPz8gcmVhZCB0aGUgcmVsZWFzZSBvbiBteSBwaG9uZSB0byBmb3JtdWxh dGUgYSBwcm9wZXIgcmVzcG9uc2UuIEkgc2hvdWxkIG1vdmUgdG8gYSBoaWdobHkgZWxhc3RpYyBY ZW4gUHJvamVjdC1wb3dlcmVkIGNsb3VkIHRoYXQgYWxsb3dzIG1lIHRvIGF1dG9zY2FsZSA7KSAo c29ycnkgYmFkIGNsb3VkIGpva2UpLg0KDQpJIGFtIGZpbmUgd2l0aG91dCBkb2luZyB0aGUgYWNy b255bSBhbmQgSSB0aGluayB0aGUgcmVhbGlnbmluZyBhbmQgYnJhbmRpbmcgZGlzY3Vzc2lvbiBz aG91bGQgYmUgaGFkLiBJPz8gbGlrZSB0byBoYXZlIHRoYXQgZGlzY3Vzc2lvbiBkdXJpbmcgb3Vy IG5leHQgYm9hcmQgbWVldGluZy4gR2l2ZW4gdGltZSBpcyBvZiB0aGUgZXNzZW5jZSBJIHRoaW5r IHdlIHNob3VsZCBqdXN0IHVwZGF0ZSB0aGUgbGlua3MgdG8gdmVyc2lvbiB2ZXJzdXMgWGVuIDQu My4xLg0KDQpBbHNvIEkgdG9vayBhIHNob3QgYXQgdGhlIHdvcmRpbmcgb2YgdGhlIHByZXNzIHJl bGVhc2UuIEl0Pz8gcHJvYmFibHkgbm90IHBlcmZlY3QgYnV0IG1ha2VzIGl0IHJlYWQgYSBiaXQg YmV0dGVyLiBBdHRhY2hlZCBhcmUgbXkgcHJvcG9zZWQgZWRpdHMuIFNhcmFoLCBJIHNlbnQgeW91 IHRoZSB3b3JkIGRvYyB3aXRoIHRyYWNrIGNoYW5nZXMgYXNzdW1pbmcgd2UgaGF2ZSBzb21lIGVk aXRzIHRvIGFncmVlIG9uLg0KDQoNClJlZ2FyZHMsIE1hcmsNCg0KDQpYZW4gUHJvamVjdCBSZWxl YXNlcyBVcGRhdGUgdG8gRW50ZXJwcmlzZSBIeXBlcnZpc29yIFNvZnR3YXJlDQoNCk9wZW4gU291 cmNlIFZpcnR1YWxpemF0aW9uIFNvZnR3YXJlIFJlbGVhc2UgSW5jbHVkZXMgQWRkaXRpb25hbCBB Uk0gU3VwcG9ydCBhbmQgU2NhbGFiaWxpdHkgZm9yIENsb3VkIGFuZCBNb2JpbGUgRW52aXJvbm1l bnRzDQoNCg0KDQpTQU4gRlJBTkNJU0NPLCBNYXJjaCAxMCwgMjAxNCA/Py9zcGFuPiBYZW4gUHJv amVjdCwgYSBDb2xsYWJvcmF0aXZlIFByb2plY3QgaG9zdGVkIGF0IFRoZSBMaW51eCBGb3VuZGF0 aW9uLCB0b2RheSBhbm5vdW5jZWQgYXZhaWxhYmlsaXR5IG9mIHRoZSBYZW4gUHJvamVjdCA0LjQg d2l0aCBlbmhhbmNlZCBBUk0gc3VwcG9ydC4gVGhlIGxhdGVzdCByZWxlYXNlIGFsc28gaW5jbHVk ZXMgbWFqb3IgcGVyZm9ybWFuY2UgYW5kIHN5c3RlbSBzY2FsYWJpbGl0eSBpbXByb3ZlbWVudHMg Zm9yIGVudGVycHJpc2UgY29tcHV0aW5nLCBzdWNoIGFzIG1vYmlsZSBhbmQgY2xvdWQgZW52aXJv bm1lbnRzLCB3aGVyZSB2aXJ0dWFsaXphdGlvbiB0ZWNobm9sb2d5IGlzIGluY3JlYXNpbmdseSBp biBkZW1hbmQuDQoNClRoaXMgcmVsZWFzZSBmdXJ0aGVyIGFkdmFuY2VzIHRoZSBQcm9qZWN0Pz8v c3Bhbj5zIHBvc2l0aW9uIGFzIGEgZmFzdCwgc2NhbGFibGUsIHNlY3VyZSB2aXJ0dWFsaXphdGlv biBlbmdpbmUgZm9yIHRoZSBpbmR1c3RyeT8/L3NwYW4+cyBicm9hZGVzdCByYW5nZSBvZiBzZXJ2 ZXIsIFBDIGNoaXBzZXRzIGFuZCBuZXh0LWdlbmVyYXRpb24gbG93LXBvd2VyIHN5c3RlbXMgb24g Y2hpcHMgKFNvQykuDQoNCk1ham9yIGNvbnRyaWJ1dGlvbnMgZnJvbSBBTUQsIENpdHJpeCwgSW50 ZWwsIE9yYWNsZSBhbmQgU1VTRSBhcmUgcHVzaGluZyB0aGUgWGVuIFByb2plY3Qgc29mdHdhcmUg dG8gdGFrZSBhZHZhbnRhZ2Ugb2YgdGhlIGxhdGVzdCBoYXJkd2FyZS4gQWRkaXRpb25hbGx5LCBk ZXZlbG9wZXJzIGNyZWF0aW5nIHNlcnZpY2VzIGFuZCBhcHBzIHdpdGggZW1iZWRkZWQsIG1vYmls ZSBhbmQgY2xvdWQgc3lzdGVtcyB3aWxsIGJlbmVmaXQgZnJvbSBuZXcgZmVhdHVyZXMgc3VjaCBh cyBldmVudCBjaGFubmVsaW5nIHdoZW4gc2NhbGluZyBvdXQgdGhlaXIgSW5mcmFzdHJ1Y3R1cmUg YXMgYSBTZXJ2aWNlIG9mZmVyaW5ncy4NCg0KPz8vc3Bhbj5WaXJ0dWFsaXphdGlvbiBhbmQgbG93 LXBvd2VyZWQgc2VydmVycyBhcmUgbGVhZGluZyBjb21wYW5pZXMgdG8gcmV0aGluayB0aGUgZGF0 YSBjZW50ZXIgYW5kIGl0cyBwb3RlbnRpYWwgZm9yIGVmZmljaWVuY3ksPz8gc2FpZCBMYXJzIEt1 cnRoLCBDaGFpcm1hbiBvZiB0aGUgWGVuIFByb2plY3QgYWR2aXNvcnkgYm9hcmQuID8/L3NwYW4+ T3VyIHNvbHV0aW9uIGNvbnRhaW5zIElULXJlbGF0ZWQgY29zdHMsIHBsdXMgbWVldHMgdGhlIHNl Y3VyaXR5IGFuZCBzY2FsYWJpbGl0eSBuZWVkcyBvZiB0b2RheT8/L3NwYW4+cyBlbGFzdGljIGNs b3VkLCBtb2JpbGUgYW5kIHNvY2lhbCBuZXR3b3JraW5nIGNvbXBhbmllcy4gVGhlIGxhdGVzdCB1 cGRhdGVzIGNvbnRpbnVlIHRoZSBQcm9qZWN0Pz8vc3Bhbj5zIHRyYWNrIHJlY29yZCBvZiByaWNo IGNvbGxhYm9yYXRpb24gYW5kIHdpZGVzcHJlYWQgZGV2ZWxvcG1lbnQgZnJvbSBtYW55IG9mIHRo ZSB3b3JsZD8/L3NwYW4+cyB0ZWNobm9sb2d5IGxlYWRlcnMuIFRoaXMgY2VydGFpbmx5IGV4cGxh aW5zIHRoZSBzaWduaWZpY2FudCBncm93dGggb2YgQVJNIHN1cHBvcnQsIHdoaWNoIHdlPz8vc3Bh bj5yZSBwbGVhc2VkIHRvIHNlZSBhZHZhbmNlIHNvIHF1aWNrbHkuPz8vc3Bhbj4NCg0KU3VwcG9y dCBmb3IgQVJNIG9uIFhlbiBQcm9qZWN0IEFyY2hpdGVjdHVyZSBHcm93cyBRdWlja2x5DQoNClRo ZSBuZXcgcmVsZWFzZSBpbnRyb2R1Y2VzIHNpZ25pZmljYW50IHN0YWJpbGl0eSwgdXNhYmlsaXR5 IGFuZCBwZXJmb3JtYW5jZSBpbXByb3ZlbWVudHMgZm9yIHRoZSBBUk0gYXJjaGl0ZWN0dXJlIGFu ZCBleHRlbmRlZCBoYXJkd2FyZSBjb21wYXRpYmlsaXR5LiAgQXBwbGllZE1pY3JvPz8vc3Bhbj5z IFgtR2VuZSwgdGhlIEFybmRhbGUgQm9hcmQsIENhbHhlZGEgRUNYLTIwMDAsIFRJIE9NQVA1IGFu ZCB0aGUgQWxsd2lubmVyIFN1blhpIGJvYXJkcyBhcmUgYWxsIHN1cHBvcnRlZC4gVGhlIHN1YnN0 YW50aWFsbHkgaW1wcm92ZWQgbXVsdGlwbGF0Zm9ybSBjYXBhYmlsaXRpZXMgb2YgdGhlIGh5cGVy dmlzb3IgYWxsb3cgaGFyZHdhcmUgYW5kIGVtYmVkZGVkIHZlbmRvcnMgdG8gcG9ydCB0aGUgWGVu IFByb2plY3QgdGVjaG5vbG9neSB0byBuZXcgQVJNIFNvQ3MgZWFzaWx5LCBzaG9ydGVuaW5nIHRo ZWlyIHRpbWUgdG8gbWFya2V0Lg0KDQoNCg0KQWRkaXRpb25hbCBlbmhhbmNlbWVudHMgaW4gdGhp cyByZWxlYXNlIGluY2x1ZGVkIDY0LWJpdCBndWVzdCBzdXBwb3J0IG9uIEFSTXY4IHBsYXRmb3Jt cy4gQWxsIHRoZSB1c2Vyc3BhY2UgdG9vbHMsIHN1Y2ggYXMgdGhlIHhsIG1hbmFnZW1lbnQgdG9v bCwgYXJlIDY0LWJpdCByZWFkeSBhbmQgY2FuIGJlIHVzZWQgdG8gY3JlYXRlIDY0LWJpdCB2aXJ0 dWFsIG1hY2hpbmVzIG91dCBvZiB0aGUgYm94Lg0KDQoNCg0KVGhlIFhlbiBQcm9qZWN0IGh5cGVy Y2FsbCBBQkkgaXMgbm93IHN0YWJsZSBhbmQgd2lsbCBiZSBtYWludGFpbmVkIGZvciBiYWNrd2Fy ZCBjb21wYXRpYmlsaXR5LCBzbyB1c2VycyBjYW4gdHJ1c3QgZnV0dXJlIHJlbGVhc2VzIHRvIGJv b3Qgb2xkZXIgb3BlcmF0aW5nIHN5c3RlbXMuDQoNCkFkZGl0aW9uYWwgaW1wcm92ZW1lbnRzIGlu Y2x1ZGUgZXh0ZW5kZWQgc3VwcG9ydCBmb3IgQVJNIHNwZWNpZmljIGJvb3Rsb2FkZXJzIGFuZCBm aXJtd2FyZSBpbnRlcmZhY2VzLCBhbmQgc3VwcG9ydCBmb3IgcGh5c2ljYWwgcGFydGl0aW9ucyBh bmQgTFZNIHZvbHVtZXMgdG8gc3RvcmUgZGlza3Mgb2YgdmlydHVhbCBtYWNoaW5lcy4NCg0KDQoN CkltcHJvdmVkIEV2ZW50IENoYW5uZWwgU2NhbGFiaWxpdHkgRm9yIENsb3VkIENvbXB1dGluZw0K DQpYZW4gUHJvamVjdCBkZXZlbG9wZXJzIGNvbnRpbnVlcyB0byBkcml2ZSBpbm5vdmF0aW9uIGFu ZCBjb2xsYWJvcmF0aW9uIGFyb3VuZCBzZXJ2ZXIgdmlydHVhbGl6YXRpb24gYW5kIHRoZSBjbG91 ZC4gUG93ZXJpbmcgbWFueSBvZiB0aGUgbGFyZ2VzdCBjbG91ZHMgaW4gcHJvZHVjdGlvbiB0b2Rh eSwgaW5jbHVkaW5nIEFtYXpvbiBFQzIsIFJhY2tzcGFjZSBDbG91ZCBhbmQgb3RoZXJzLCB0aGUg Y29tbXVuaXR5IHVuZGVyc3RhbmRzIHRoZSBuZWVkIHRvIHJ1biBtb3JlIHZpcnR1YWwgbWFjaGlu ZXMgb24gYSBzaW5nbGUgaG9zdC4NCg0KWWV0IGRlbWFuZHMgb24gaHlwZXJ2aXNvciBzY2FsYWJp bGl0eSBjb250aW51ZSB0byBpbmNyZWFzZSwgYm90aCBmcm9tIGxhcmdlciBtYWNoaW5lcywgbmV3 IHdvcmtsb2FkcyBzdWNoIGFzIHZpcnR1YWxpemF0aW9uIGRlc2t0b3AgaW5mcmFzdHJ1Y3R1cmVz IChWREkpIGFuZCBuZXcgY2xvdWQgT1MgdGVjaG5vbG9naWVzLCBpbmNsdWRpbmcgTWlyYWdlT1Ms IEVybGFuZ09uWGVuLCBPU3YsIGFuZCBIYWxWTS4gUmVjb2duaXppbmcgdGhhdCBoaWdoLWF2YWls YWJpbGl0eSBhbmQgc3RhYmlsaXR5IGFyZSBjcml0aWNhbCB0byBWRElzIGFuZCBjbG91ZCBkZXBs b3ltZW50czsgdGhlIFhlblNlcnZlciB0ZWFtIGF0IENpdHJpeCBjb250cmlidXRlZCB0aGUgbmV3 IGV2ZW50IGNoYW5uZWwgaW1wbGVtZW50YXRpb24gdG8gdGhlIFhlbiBQcm9qZWN0LiBUbyBoZWxw IGVsaW1pbmF0ZSB3b3JrbG9hZCBsaW1pdGF0aW9ucyBmb3IgdXNlcnMsIHRoaXMgZW5hYmxlcyB0 aGUgaHlwZXJ2aXNvciB0byBydW4gdGhvdXNhbmRzIG9mIGd1ZXN0cyBvbiBhIHNpbmdsZSBwaHlz aWNhbCBtYWNoaW5lLg0KDQpFeHBlcmltZW50YWwgU3VwcG9ydCBmb3IgUFZIIE1vZGUgZm9yIEd1 ZXN0DQoNCk9yYWNsZSBoYXMgY29udHJpYnV0ZWQgYSBmdW5jdGlvbmFsIHByZXZpZXcgb2YgYSBu ZXcgdmlydHVhbGl6YXRpb24gbW9kZSBjYWxsZWQgUFZIIGN1cnJlbnRseSBhdmFpbGFibGUgdG8g dmlydHVhbGl6ZWQgZ3Vlc3RzLiA8aHR0cDovL2Jsb2cueGVuLm9yZy9pbmRleC5waHAvMjAxNC8w MS8zMS9saW51eC0zLTE0LWFuZC1wdmgvPiBQVkggaXMgYW4gZXh0ZW5zaW9uIHRvIHRoZSBjbGFz c2ljIFhlbiBQcm9qZWN0IFBhcmF2aXJ0dWFsaXphdGlvbiAoUFYpIHRoYXQgdXNlcyB0aGUgaGFy ZHdhcmUgdmlydHVhbGl6YXRpb24gZXh0ZW5zaW9ucyBhdmFpbGFibGUgb24gbW9kZXJuIHg4NiBw cm9jZXNzb3JzLiBQVkggdXNlcyBQViBkcml2ZXJzIGZvciBib290IGFuZCBJL08gYW5kIEludGVs IGhhcmR3YXJlIHZpcnR1YWxpemF0aW9uIGV4dGVuc2lvbnMgZm9yIHBhZ2UgdGFibGUgb3BlcmF0 aW9ucywgc3lzdGVtIGNhbGxzIGFuZCBvdGhlciBwcml2aWxlZ2VkIG9wZXJhdGlvbnMuIFRoaXMg bm90IG9ubHkgaW1wcm92ZXMgcGVyZm9ybWFuY2UgYW5kIHNlY3VyaXR5LCBidXQgYWxzbyBzaW1w bGlmaWVzIHRoZSBhcmNoaXRlY3R1cmUgYW5kIFhlbiBQcm9qZWN0IEh5cGVydmlzb3ItTGludXgg aW50ZXJmYWNlIHNpZ25pZmljYW50bHkuDQoNCj8/L3NwYW4+UFZIIGlzIGEgbWFqb3IgZGV2ZWxv cG1lbnQgZm9yIFhlbiBQcm9qZWN0IHNvZnR3YXJlIG9uIHg4NiBhbmQgaGFzIHRoZSBwb3RlbnRp YWwgdG8gZ3JlYXRseSBzaW1wbGlmeSB0aGUgTGludXggaW50ZXJmYWNlIGluIGR1ZSB0aW1lLCA/ PyBzYWlkIEtvbnJhZCBSemVzenV0ZWsgV2lsaywgU29mdHdhcmUgRGV2ZWxvcG1lbnQgTWFuYWdl ciBhdCBPcmFjbGUsIGEgWGVuIFByb2plY3QgYWR2aXNvcnkgYm9hcmQgbWVtYmVyLiA/Py9zcGFu PldlIGV4cGVjdCBQVkggdG8gaGF2ZSB0aGUgYmVzdCBjaGFyYWN0ZXJpc3RpY3Mgb2YgYWxsIHZp cnR1YWxpemF0aW9uIG1vZGVzIC0tIGEgc2ltcGxlLCBmYXN0LCBzZWN1cmUgaW50ZXJmYWNlLCB3 aXRoIGxvdyBtZW1vcnkgb3ZlcmhlYWQsIHRoYXQgYWxzbyB0YWtlcyBmdWxsIGFkdmFudGFnZSBv ZiB0aGUgbGF0ZXN0IGhhcmR3YXJlLj8/L3NwYW4+DQoNCg0KDQpBZGRpdGlvbmFsIGtleSB1cGRh dGVzIGluY2x1ZGU6DQoNCu+/ve+/vSAgICAgQmV0dGVyIHBlcmZvcm1hbmNlIHdpdGggbW9kZXJu IHN0b3JhZ2UgZGV2aWNlcyBhbmQgYmlnIGRhdGEgLS0gSW5kaXJlY3QgZGVzY3JpcHRvcnMgZm9y IGJsb2NrIFBWIHByb3RvY29sIChMaW51eCkgYWxsb3cgZWFjaCBpbmRpdmlkdWFsIHJlcXVlc3Qg dG8gdHJpcGxlIGluIHNpemUsIGdyZWF0bHkgaW1wcm92aW5nIEkvTyBwZXJmb3JtYW5jZSB3aGVu IHJ1bm5pbmcgb24gZmFzdCBzdG9yYWdlIHRlY2hub2xvZ2llcyBzdWNoIGFzIHNvbGlkLXN0YXRl IGRyaXZlIGFuZCBSQUlELiBBdmFpbGFibGUgaW4gYW55IGd1ZXN0IHJ1bm5pbmcgTGludXggMy4x MSBvciBoaWdoZXIgKHJlZ2FyZGxlc3Mgb2YgWGVuIFByb2plY3QgdmVyc2lvbikuDQoNCg0KDQrv v73vv70gICAgIE1vcmUgcG93ZXJmdWwgZHJpdmVyIGRvbWFpbnMgLS0gRGlzayBkcml2ZXIgZG9t YWlucyBjYW4gbm93IHVuaWZvcm1seSBydW4gYmxvY2sgc2NyaXB0cyBhbmQgdXNlci1zcGFjZSBi YWNrZW5kcywgc3VjaCBhcyBxZGlzaywgYnJpbmdpbmcgdGhlbSB1cCB0byBmZWF0dXJlIHBhcml0 eSB3aXRoIGRvbWFpbiAwLiBUaGlzIG1lYW5zIGhvc3QgYWRtaW5pc3RyYXRvcnMgY2FuIHRha2Ug YWR2YW50YWdlIG9mIHRoZSBlbmhhbmNlZCBzZWN1cml0eSwgc2NhbGFiaWxpdHksIGFuZCByb2J1 c3RuZXNzIHByb3ZpZGVkIGJ5IGRyaXZlciBkb21haW5zIHdpdGhvdXQgc2FjcmlmaWNpbmcgdGhl IHdpZGUgYXJyYXkgb2YgZGlzayBjb25maWd1cmF0aW9uIG9wdGlvbnMgcHJvdmlkZWQgYnkgWGVu IGluIGRvbTAuDQoNCu+/ve+/vSAgICAgTmV3IFNQSUNFIHByb3RvY29sIHN1cHBvcnQgLS0gRnVu Y3Rpb25hbGl0eSBzdWNoIGFzIGNsaXBib2FyZCBzaGFyaW5nIGFuZCBVU0IgcmVkaXJlY3Rpb24g Y3JlYXRlcyBhIG11Y2ggcmljaGVyIGNvbm5lY3Rpb24gZm9yIHZpcnR1YWwgZGVza3RvcHMgYW5k IGJldHRlciBncmFwaGljcyBwZXJmb3JtYW5jZS4NCg0K77+977+9ICAgICBFbmhhbmNlZCBkaWFn bm9zdGljcyBhbmQga2V4ZWMgZGVidWcgc3VwcG9ydCAtLSBXaGVuIGEgY3Jhc2ggaGFwcGVucywg YSBzcGVjaWFsIGtlcm5lbCBpcyBhbGxvd2VkIGltbWVkaWF0ZSB0byBjb2xsZWN0IGluZm9ybWF0 aW9uIGFib3V0IHRoZSByb290IGNhdXNlLCBvZmZlcmluZyBkZXZlbG9wZXJzIGJldHRlciBkaWFn bm9zaXMgYW5kIHJlcGFpciBhYmlsaXRpZXMuDQoNClRoZSA0LjQgcmVsZWFzZSBpcyB0aGUgcmVz dWx0IG9mIGEgYnJvYWQsIGNvbGxhYm9yYXRpdmUgZGV2ZWxvcG1lbnQgZWZmb3J0IHJlcHJlc2Vu dGluZyBlbmdpbmVlcnMgZnJvbSBtb3JlIHRoYW4gMTMgbGVhZGluZyBoYXJkd2FyZSwgc29mdHdh cmUgYW5kIHNlY3VyaXR5IHZlbmRvcnMuIFRvcCBjb250cmlidXRvcnMgaW5jbHVkZSBBbWF6b24s IEFNRCwgQW5hbG9nIERldmljZXMsIEJyb2FkY29tLCBDaXRyaXgsIEZ1aml0c3UsIEludGVsLCBM aW5hcm8sIE5TQSwgT3JhY2xlLCBTdXNlLCBWZXJpem9uL1RlcnJlbWFyaywgcGx1cyBudW1lcm91 cyBpbmRpdmlkdWFsIGFuZCBhY2FkZW1pYyBjb250cmlidXRvcnMuIFRoZSBmcmVlbHkgYXZhaWxh YmxlIGRvd25sb2FkIGNhbiBiZSBmb3VuZCBvbiB0aGUgWGVuUHJvamVjdC5vcmc8aHR0cDovL3hl bnByb2plY3Qub3JnLz4gd2Vic2l0ZSAoaW5zZXJ0IHVybCkuDQoNCg0KDQpBYm91dCBYZW4gUHJv amVjdA0KDQpUaGUgWGVuIFByb2plY3Qgc29mdHdhcmUgaXMgYW4gb3BlbiBzb3VyY2UgdmlydHVh bGl6YXRpb24gcGxhdGZvcm0gbGljZW5zZWQgdW5kZXIgdGhlIEdQTHYyIHdpdGggYSBzaW1pbGFy IGdvdmVybmFuY2Ugc3RydWN0dXJlIHRvIHRoZSBMaW51eCBrZXJuZWwuIERlc2lnbmVkIGZyb20g dGhlIHN0YXJ0IGZvciBjbG91ZCBjb21wdXRpbmcsIHRoZSBQcm9qZWN0IGhhcyBtb3JlIHRoYW4g YSBkZWNhZGUgb2YgZGV2ZWxvcG1lbnQgYW5kIGlzIGJlaW5nIHVzZWQgYnkgbW9yZSB0aGFuIDEw IG1pbGxpb24gdXNlcnMuIEEgQ29sbGFib3JhdGl2ZSBQcm9qZWN0IGF0IFRoZSBMaW51eCBGb3Vu ZGF0aW9uLCB0aGUgWGVuIFByb2plY3QgdGVhbSBpcyBmb2N1c2VkIG9uIGFkdmFuY2luZyB2aXJ0 dWFsaXphdGlvbiBpbiBhIG51bWJlciBvZiBkaWZmZXJlbnQgY29tbWVyY2lhbCBhbmQgb3BlbiBz b3VyY2UgYXBwbGljYXRpb25zIGluY2x1ZGluZyBzZXJ2ZXIgdmlydHVhbGl6YXRpb24sIEluZnJh c3RydWN0dXJlIGFzIGEgU2VydmljZSAoSWFhUyksIGRlc2t0b3AgdmlydHVhbGl6YXRpb24sIHNl Y3VyaXR5IGFwcGxpY2F0aW9ucywgZW1iZWRkZWQgYW5kIGhhcmR3YXJlIGFwcGxpYW5jZXMuIEl0 IGNvdW50cyBtYW55IGluZHVzdHJ5IGFuZCBvcGVuIHNvdXJjZSBjb21tdW5pdHkgbGVhZGVycyBh bW9uZyBpdHMgbWVtYmVycyBpbmNsdWRpbmc6IEFtYXpvbiBXZWIgU2VydmljZXMsIEFNRCwgQVJN LCBCcm9taXVtLCBDYWx4ZWRhLCBDQSBUZWNobm9sb2dpZXMsIENpc2NvLCBDaXRyaXgsIEdvb2ds ZSwgSW50ZWwsIE9yYWNsZSwgU2Ftc3VuZyBhbmQgVmVyaXpvbi4gRm9yIG1vcmUgaW5mb3JtYXRp b24gYWJvdXQgdGhlIFhlbiBQcm9qZWN0IGh5cGVydmlzb3IgYW5kIHRvIHBhcnRpY2lwYXRlLCBw bGVhc2UgdmlzaXRodHRwOi8veGVucHJvamVjdC48aHR0cDovL3hlbnByb2plY3Qub3JnLz5vcmc8 aHR0cDovL3hlbnByb2plY3Qub3JnLz4uDQoNCiMjIw0KDQpTYXJhaCBDb253YXkNCg0KVGhlIFhl biBQcm9qZWN0DQoNCk1lZGlhIENvbnRhY3QNCg0KcHVibGljaXR5QGxpc3RzLnhlbnByb2plY3Qu b3JnPG1haWx0bzpwdWJsaWNpdHlAbGlzdHMueGVucHJvamVjdC5vcmc+DQoNCg0KT24gTWFyIDYs IDIwMTQsIGF0IDEyOjQ0IFBNLCBXaWxzb24sIE1hdHQgPG1zd0BhbWF6b24uY29tPG1haWx0bzpt c3dAYW1hem9uLmNvbT4+IHdyb3RlOg0KDQpNYXJrLCB0aG91Z2h0cz8NCg0KX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX18NCkZyb206IFdpbHNvbiwgTWF0dA0KU2VudDogV2VkbmVzZGF5 LCBNYXJjaCAwNSwgMjAxNCAxMDowMSBBTQ0KVG86IEFkdmlzb3J5LWJvYXJkIGRpc2N1c3Npb25z DQpTdWJqZWN0OiBSRTogW0Fkdmlzb3J5LWJvYXJkXSBYZW4gUHJvamVjdCA0LjQgUmVsZWFzZQ0K DQpJJ2QgcmF0aGVyIHVzZSAiWGVuIFByb2plY3QgSHlwZXJ2aXNvciIgdGhhbiBpbnRyb2R1Y2Ug YW4gYWNyb255bS4gSSB0aGluayBpdCdzIGltcG9ydGFudCB0aGF0ICJYZW4gUHJvamVjdCIgbm90 IGJlIHNwbGl0IGZyb20gIkh5cGVydmlzb3IuIg0KDQpUaGlzIHN0aWxsIGRvZXNuJ3QgYWRkcmVz cyBob3cgdGhlIHVtYnJlbGxhIHByb2plY3QgaXMgY2FsbGVkLiBUaGlzIG5ldyByZWxlYXNlIGRv ZXNuJ3Qgb25seSBpbmNsdWRlIHRoZSBoeXBlcnZpc29yLCBidXQgYWxzbyB0aGUgYXNzb2NpYXRl ZCB0b29sc3RhY2sgYW5kIHV0aWxpdGllcy4gTWF5YmUgd2UncmUgT0sgY2FsbGluZyBhbGwgb2Yg dGhhdCB0aGUgIkh5cGVydmlzb3IsIiBldmVuIGlmIHdlIGlkZW50aWZ5IHRoZSBkZXZlbG9wbWVu dCB0ZWFtcyBkaWZmZXJlbnRseS4NCg0KSG93IHNob3VsZCB3ZSByZS1hbGlnbiBhbGwgb2YgdGhl IGJyYW5kaW5nPyBGb3IgZXhhbXBsZTogaHR0cDovL3hlbnByb2plY3Qub3JnL2RldmVsb3BlcnMv dGVhbXMvaHlwZXJ2aXNvci5odG1sDQoNClNob3VsZCB0aGUgbGlua3MgdW5kZXIgIkh5cGVydmlz b3IgRG93bmxvYWRzIiBiZSAidmVyc2lvbiA0LjMuMSIgaW5zdGVhZCBvZiAiWGVuIDQuMy4xIiB0 byByZXNvbHZlIHRoZSB0cmFkZW1hcmsgY29uY2VybnM/DQoNCi0tbXN3DQoNCl9fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fDQpGcm9tOiBhZHZpc29yeS1ib2FyZC1ib3VuY2VzQGxpc3Rz LnhlbnByb2plY3Qub3JnPG1haWx0bzphZHZpc29yeS1ib2FyZC1ib3VuY2VzQGxpc3RzLnhlbnBy b2plY3Qub3JnPiBbYWR2aXNvcnktYm9hcmQtYm91bmNlc0BsaXN0cy54ZW5wcm9qZWN0Lm9yZzxt YWlsdG86YWR2aXNvcnktYm9hcmQtYm91bmNlc0BsaXN0cy54ZW5wcm9qZWN0Lm9yZz5dIG9uIGJl aGFsZiBvZiBTYXJhaCBDb253YXkgW3Njb253YXlAbGludXhmb3VuZGF0aW9uLm9yZzxtYWlsdG86 c2NvbndheUBsaW51eGZvdW5kYXRpb24ub3JnPl0NClNlbnQ6IFdlZG5lc2RheSwgTWFyY2ggMDUs IDIwMTQgOTozMyBBTQ0KVG86IEFkdmlzb3J5LWJvYXJkIGRpc2N1c3Npb25zDQpTdWJqZWN0OiBS ZTogW0Fkdmlzb3J5LWJvYXJkXSBYZW4gUHJvamVjdCA0LjQgUmVsZWFzZQ0KDQpNYXJrIGV0IGFs bCwNCg0KSSBhZ3JlZSB0aGF0IHVzaW5nIFhlbiBQcm9qZWN0IGlzIGEgbW91dGhmdWwuIEdpdmVu IHRoYXQgdGhlcmUgaXMgY2xvc2Ugb3ZlcmxhcCBhbmQgb2NjYXNpb25hbCBicmFuZGluZyBjb25m dXNpb24gd2l0aCBDaXRyaXggcHJvZHVjdHMsIGlmIHdlIGFkZCBhbm90aGVyIG5ldyB0ZXJtIG9y IGFjcm9ueW0gaW50byB0aGUgbWl4LCB3ZSdsbCB3YW50IHRvIGJlIGRpbGlnZW50IGFib3V0IGJl aW5nIGNvbnNpc3RlbnQgaW4gYmxvZ3MsIHByZXNlbnRhdGlvbnMsIG5ld3MgcmVsZWFzZXMsIHdl YiBzaXRlIGNvcHksIGN1c3RvbWVyIHRlc3RpbW9uaWFscyBldGMuDQoNCkZvciB0aGUgc2FrZSBv ZiBzaW1wbGljaXR5LCBob3cgYWJvdXQgdXNpbmcgWFBIIC0gYWxsIHVwcGVyY2FzZSAtIG9uIHNl Y29uZCByZWZlcmVuY2U/IFRob3VnaHRzPw0KDQpUaGFua3MsDQoNCg0KDQoNCg0KDQpPbiBXZWQs IE1hciA1LCAyMDE0IGF0IDk6MTggQU0sIE1hcmsgSGlua2xlIDxNYXJrLkhpbmtsZUBjaXRyaXgu Y29tPG1haWx0bzpNYXJrLkhpbmtsZUBjaXRyaXguY29tPj4gd3JvdGU6DQpIb3cgYWJvdXQgdGhp cyBjb252ZW50aW9uIG9ubHkgc2F5IFhlbiBQcm9qZWN0IGFuZCBYZW4gUHJvamVjdCBoeXBlcnZp c29yIG9uY2UgdGhlbi4gVXNlIHRoZSBhYmJyZXZpYXRpb24gWFBoIHRocm91Z2hvdXQgdGhlIHJl bGVhc2UuIEp1c3Qgc25pcHBpbmcgTWF0dD8/IGV4YW1wbGUgdG8gbWFrZSB0aGUgcG9pbnQuIEkg d291bGQgZ3Vlc3MgdGhhdCB0aGUgYXBwcm9wcmlhdGUgY2FwaXRhbGl6YXRpb24gd291bGQgYmUg bG93ZXIgY2FzZSBmb3IgdGhlIHdvcmQgaHlwZXJ2aXNvci4NCg0KTWFyaw0KDQoNClRoZSBYZW4g UHJvamVjdCwgYSBDb2xsYWJvcmF0aXZlIFByb2plY3QgaG9zdGVkIGF0IFRoZSBMaW51eCBGb3Vu ZGF0aW9uLCB0b2RheSBhbm5vdW5jZWQgYXZhaWxhYmlsaXR5IG9mIHRoZSBYZW4gUHJvamVjdCBo eXBlcnZpc29yKFhQaCkgNC40IHdpdGggZW5oYW5jZWQgQVJNIHN1cHBvcnQuDQoNClhQaCA0LjQg ZnVydGhlciBhZHZhbmNlcyB0aGUgUHJvamVjdD8/L3NwYW4+cyBwb3NpdGlvbiBhcyBhIGZhc3Qs IHNjYWxhYmxlLCBzZWN1cmUgdmlydHVhbGl6YXRpb24gZW5naW5lIGZvciB0aGUgaW5kdXN0cnk/ Py9zcGFuPnMgYnJvYWRlc3QgcmFuZ2Ugb2Ygc2VydmVyLCBQQyBjaGlwc2V0cyBhbmQgbmV4dC1n ZW5lcmF0aW9uIGxvdy1wb3dlciBzeXN0ZW1zIG9uIGNoaXBzIChTb0MpLg0KDQpPbiBNYXIgNCwg MjAxNCwgYXQgNDowMSBQTSwgV2lsc29uLCBNYXR0IDxtc3dAYW1hem9uLmNvbTxtYWlsdG86bXN3 QGFtYXpvbi5jb20+PiB3cm90ZToNCg0KVGhlICJYZW4gUHJvamVjdCIgdGVybWlub2xvZ3kgbWFr ZXMgdGhlIG1lc3NhZ2UgZXh0cmVtZWx5IGN1bWJlcnNvbWUuDQoNCg0KVGhlIFhlbiBQcm9qZWN0 LCBhIENvbGxhYm9yYXRpdmUgUHJvamVjdCBob3N0ZWQgYXQgVGhlIExpbnV4IEZvdW5kYXRpb24s IHRvZGF5IGFubm91bmNlZCBhdmFpbGFiaWxpdHkgb2YgdGhlIFhlbiBQcm9qZWN0IDQuNCBIeXBl cnZpc29yIHdpdGggZW5oYW5jZWQgWGVuIFByb2plY3Qtb24tQVJNIHN1cHBvcnQuDQoNCldoeSBu b3QganVzdCBzYXkgImVuaGFuY2VkIEFSTSBzdXBwb3J0Ij8gV2Ugc2hvdWxkIGFkb3B0IHNvbWUg dXNhZ2UgZ3VpZGVsaW5lcyBmb3Igc3ViLXByb2plY3QgYnJhbmRpbmcuIFdlIHNob3VsZG4ndCBp bnNlcnQgd29yZHMvbnVtYmVycyBiZXR3ZWVuICJYZW4gUHJvamVjdCIgYW5kIGEgc3ViLXByb2pl Y3QgbmFtZS4NCg0KVGhlIFhlbiBQcm9qZWN0LCBhIENvbGxhYm9yYXRpdmUgUHJvamVjdCBob3N0 ZWQgYXQgVGhlIExpbnV4IEZvdW5kYXRpb24sIHRvZGF5IGFubm91bmNlZCB2ZXJzaW9uIDQuNCBv ZiB0aGUgWGVuIFByb2plY3QgSHlwZXJ2aXNvciB3aXRoIGVuaGFuY2VkIEFSTSBzdXBwb3J0Lg0K DQpvcg0KVGhlIFhlbiBQcm9qZWN0LCBhIENvbGxhYm9yYXRpdmUgUHJvamVjdCBob3N0ZWQgYXQg VGhlIExpbnV4IEZvdW5kYXRpb24sIHRvZGF5IGFubm91bmNlZCB0aGUgcmVsZWFzZSBvZiBYZW4g UHJvamVjdCBIeXBlcnZpc29yIDQuNCB3aXRoIGVuaGFuY2VkIEFSTSBzdXBwb3J0Lg0KDQpMYXRl ciBvbiwgdGhpcyByZWxlYXNlIGlzIGNhbGxlZCAiWGVuIFByb2plY3QgNC40Ig0KDQoNClRoZSBY ZW4gUHJvamVjdCA0LjQgcmVsZWFzZSBmdXJ0aGVyIGFkdmFuY2VzIHRoZSBQcm9qZWN0Pz8vc3Bh bj5zIHBvc2l0aW9uIGFzIGEgZmFzdCwgc2NhbGFibGUsIHNlY3VyZSB2aXJ0dWFsaXphdGlvbiBl bmdpbmUgZm9yIHRoZSBpbmR1c3RyeT8/L3NwYW4+cyBicm9hZGVzdCByYW5nZSBvZiBzZXJ2ZXIs IFBDIGNoaXBzZXRzIGFuZCBuZXh0LWdlbmVyYXRpb24gbG93LXBvd2VyIHN5c3RlbXMgb24gY2hp cHMgKFNvQykuDQoNClRoYXQgZG9lc24ndCBmbG93IHdlbGwuIEhvdyBhcmUgd2UgcmVsZWFzaW5n IHZlcnNpb24gNC40IG9mIGEgcHJvamVjdD8gRG8gd2Ugd2FudCB0byBjYWxsIHRoZSBvdmVyYWxs IHJlbGVhc2UgIlhlbiBQcm9qZWN0IEFyY2hpdGVjdHVyZSA0LjQiPyBPciBkbyB3ZSBuZWVkIHRv IGNvbWUgdXAgd2l0aCBzb21lIG90aGVyIHByb2plY3QgYnJhbmRpbmc/DQoNCi0tbXN3DQoNCl9f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fDQpGcm9tOiBhZHZpc29yeS1ib2FyZC1ib3Vu Y2VzQGxpc3RzLnhlbnByb2plY3Qub3JnPG1haWx0bzphZHZpc29yeS1ib2FyZC1ib3VuY2VzQGxp c3RzLnhlbnByb2plY3Qub3JnPiBbYWR2aXNvcnktYm9hcmQtYm91bmNlc0BsaXN0cy54ZW5wcm9q ZWN0Lm9yZzxtYWlsdG86YWR2aXNvcnktYm9hcmQtYm91bmNlc0BsaXN0cy54ZW5wcm9qZWN0Lm9y Zz5dIG9uIGJlaGFsZiBvZiBTYXJhaCBDb253YXkgW3Njb253YXlAbGludXhmb3VuZGF0aW9uLm9y ZzxtYWlsdG86c2NvbndheUBsaW51eGZvdW5kYXRpb24ub3JnPl0NClNlbnQ6IFR1ZXNkYXksIE1h cmNoIDA0LCAyMDE0IDEyOjE2IFBNDQoNClRvOiBhZHZpc29yeS1ib2FyZEBsaXN0cy54ZW5wcm9q ZWN0Lm9yZzxtYWlsdG86YWR2aXNvcnktYm9hcmRAbGlzdHMueGVucHJvamVjdC5vcmc+DQpTdWJq ZWN0OiBbQWR2aXNvcnktYm9hcmRdIFhlbiBQcm9qZWN0IDQuNCBSZWxlYXNlDQoNCkhpIGV2ZXJ5 b25lLg0KDQpBdHRhY2hlZCBpcyB0aGUgWGVuIFByb2plY3QgNC40IG5ld3MgcmVsZWFzZSBhbm5v dWNlbWVudCB0aGF0IHdpbGwgZ28gb3V0IGF0IDggYS5tLiBFVCBvbiBNb25kYXksIE1hcmNoIDEw Lg0KDQpJZiB5b3UgaGF2ZSBhbnkgYWRkaXRpb25hbCBjb21tZW50cyBvciBlZGl0cywgcGxlYXNl IGdldCBiYWNrIHRvIG1lIGJ5IFRodXJzZGF5IG1vcm5pbmcgYXQgdGhlIGxhdGVzdC4NCg0KVGhh bmtzLA0KDQoNCi0tDQpTYXJhaCBDb253YXkNClBSIE1hbmFnZXINClRoZSBMaW51eCBGb3VuZGF0 aW9uDQpzY29ud2F5QGxpbnV4Zm91bmRhdGlvbi5vcmc8bWFpbHRvOnNjb253YXlAbGludXhmb3Vu ZGF0aW9uLm9yZz4NCig5NzgpIDU3OC01MzAwPHRlbDolMjg5NzglMjklMjA1NzgtNTMwMD4gIENl bGwNClNreXBlOiAgc2FyYWguay5jb253YXkNCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fDQpBZHZpc29yeS1ib2FyZCBtYWlsaW5nIGxpc3QNCkFkdmlzb3J5 LWJvYXJkQGxpc3RzLnhlbnByb2plY3Qub3JnPG1haWx0bzpBZHZpc29yeS1ib2FyZEBsaXN0cy54 ZW5wcm9qZWN0Lm9yZz4NCmh0dHA6Ly9saXN0cy54ZW5wcm9qZWN0Lm9yZy9jZ2ktYmluL21haWxt YW4vbGlzdGluZm8vYWR2aXNvcnktYm9hcmQNCg0KDQpfX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fXw0KQWR2aXNvcnktYm9hcmQgbWFpbGluZyBsaXN0DQpBZHZp c29yeS1ib2FyZEBsaXN0cy54ZW5wcm9qZWN0Lm9yZzxtYWlsdG86QWR2aXNvcnktYm9hcmRAbGlz dHMueGVucHJvamVjdC5vcmc+DQpodHRwOi8vbGlzdHMueGVucHJvamVjdC5vcmcvY2dpLWJpbi9t YWlsbWFuL2xpc3RpbmZvL2Fkdmlzb3J5LWJvYXJkDQoNCg0KDQoNCi0tDQpTYXJhaCBDb253YXkN ClBSIE1hbmFnZXINClRoZSBMaW51eCBGb3VuZGF0aW9uDQpzY29ud2F5QGxpbnV4Zm91bmRhdGlv bi5vcmc8bWFpbHRvOnNjb253YXlAbGludXhmb3VuZGF0aW9uLm9yZz4NCig5NzgpIDU3OC01MzAw PHRlbDolMjg5NzglMjklMjA1NzgtNTMwMD4gIENlbGwNClNreXBlOiAgc2FyYWguay5jb253YXkN Cl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fDQpBZHZpc29y eS1ib2FyZCBtYWlsaW5nIGxpc3QNCkFkdmlzb3J5LWJvYXJkQGxpc3RzLnhlbnByb2plY3Qub3Jn PG1haWx0bzpBZHZpc29yeS1ib2FyZEBsaXN0cy54ZW5wcm9qZWN0Lm9yZz4NCmh0dHA6Ly9saXN0 cy54ZW5wcm9qZWN0Lm9yZy9jZ2ktYmluL21haWxtYW4vbGlzdGluZm8vYWR2aXNvcnktYm9hcmQN Cg0KDQotLSBJTVBPUlRBTlQgTk9USUNFOiBUaGUgY29udGVudHMgb2YgdGhpcyBlbWFpbCBhbmQg YW55IGF0dGFjaG1lbnRzIGFyZSBjb25maWRlbnRpYWwgYW5kIG1heSBhbHNvIGJlIHByaXZpbGVn ZWQuIElmIHlvdSBhcmUgbm90IHRoZSBpbnRlbmRlZCByZWNpcGllbnQsIHBsZWFzZSBub3RpZnkg dGhlIHNlbmRlciBpbW1lZGlhdGVseSBhbmQgZG8gbm90IGRpc2Nsb3NlIHRoZSBjb250ZW50cyB0 byBhbnkgb3RoZXIgcGVyc29uLCB1c2UgaXQgZm9yIGFueSBwdXJwb3NlLCBvciBzdG9yZSBvciBj b3B5IHRoZSBpbmZvcm1hdGlvbiBpbiBhbnkgbWVkaXVtLiBUaGFuayB5b3UuDQoNCkFSTSBMaW1p dGVkLCBSZWdpc3RlcmVkIG9mZmljZSAxMTAgRnVsYm91cm4gUm9hZCwgQ2FtYnJpZGdlIENCMSA5 TkosIFJlZ2lzdGVyZWQgaW4gRW5nbGFuZCAmIFdhbGVzLCBDb21wYW55IE5vOiAyNTU3NTkwDQpB Uk0gSG9sZGluZ3MgcGxjLCBSZWdpc3RlcmVkIG9mZmljZSAxMTAgRnVsYm91cm4gUm9hZCwgQ2Ft YnJpZGdlIENCMSA5TkosIFJlZ2lzdGVyZWQgaW4gRW5nbGFuZCAmIFdhbGVzLCBDb21wYW55IE5v OiAyNTQ4NzgyDQoNCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fDQpBZHZpc29yeS1ib2FyZCBtYWlsaW5nIGxpc3QNCkFkdmlzb3J5LWJvYXJkQGxpc3RzLnhl bnByb2plY3Qub3JnPG1haWx0bzpBZHZpc29yeS1ib2FyZEBsaXN0cy54ZW5wcm9qZWN0Lm9yZz4N Cmh0dHA6Ly9saXN0cy54ZW5wcm9qZWN0Lm9yZy9jZ2ktYmluL21haWxtYW4vbGlzdGluZm8vYWR2 aXNvcnktYm9hcmQNCg0KDQoNCg0KLS0NClNhcmFoIENvbndheQ0KUFIgTWFuYWdlcg0KVGhlIExp bnV4IEZvdW5kYXRpb24NCnNjb253YXlAbGludXhmb3VuZGF0aW9uLm9yZzxtYWlsdG86c2Nvbndh eUBsaW51eGZvdW5kYXRpb24ub3JnPg0KKDk3OCkgNTc4LTUzMDA8dGVsOiUyODk3OCUyOSUyMDU3 OC01MzAwPiAgQ2VsbA0KU2t5cGU6ICBzYXJhaC5rLmNvbndheQ0KPFhlblByb2plY3RVcGRhdGU0 LjQzLjYuMjAxNCgyKWRvY3g+X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX18NCkFkdmlzb3J5LWJvYXJkIG1haWxpbmcgbGlzdA0KQWR2aXNvcnktYm9hcmRAbGlz dHMueGVucHJvamVjdC5vcmc8bWFpbHRvOkFkdmlzb3J5LWJvYXJkQGxpc3RzLnhlbnByb2plY3Qu b3JnPg0KaHR0cDovL2xpc3RzLnhlbnByb2plY3Qub3JnL2NnaS1iaW4vbWFpbG1hbi9saXN0aW5m by9hZHZpc29yeS1ib2FyZA0KDQpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fXw0KQWR2aXNvcnktYm9hcmQgbWFpbGluZyBsaXN0DQpBZHZpc29yeS1ib2FyZEBs aXN0cy54ZW5wcm9qZWN0Lm9yZzxtYWlsdG86QWR2aXNvcnktYm9hcmRAbGlzdHMueGVucHJvamVj dC5vcmc+DQpodHRwOi8vbGlzdHMueGVucHJvamVjdC5vcmcvY2dpLWJpbi9tYWlsbWFuL2xpc3Rp bmZvL2Fkdmlzb3J5LWJvYXJkDQoNCg0KDQoNCi0tDQpTYXJhaCBDb253YXkNClBSIE1hbmFnZXIN ClRoZSBMaW51eCBGb3VuZGF0aW9uDQpzY29ud2F5QGxpbnV4Zm91bmRhdGlvbi5vcmc8bWFpbHRv OnNjb253YXlAbGludXhmb3VuZGF0aW9uLm9yZz4NCig5NzgpIDU3OC01MzAwICBDZWxsDQpTa3lw ZTogIHNhcmFoLmsuY29ud2F5DQo= --_000_B5EC053C78C5D746BD8AC3386F2303C9157318AMSPEX01CL01citri_ Content-Type: text/html; charset="big5" Content-Transfer-Encoding: quoted-printable
Sarah,
from the coverage I have seen it looks as if we did well
Regards
Lars
From: advisory-board-bounces@lists.xenpro= ject.org [advisory-board-bounces@lists.xenproject.org] on behalf of Sarah C= onway [sconway@linuxfoundation.org]
Sent: 07 March 2014 23:11
To: Wilson, Matt
Cc: Advisory-board discussions; Jennifer Cloer
Subject: Re: [Advisory-board] Xen Project 4.4 Release

Hi all, 

I've aggregated all edits and have done a legal review of the brand na= me use. 

Several reporters are planning articles for Monday AM when the embargo= lifts on this release. 

I'm closing edits now and finalizing for the wire. I'll work with Lars= and Jennifer moving forward to improve the writing and establish a better = review process. 

Thanks, 





On Fri, Mar 7, 2014 at 4:27 PM, Wilson, Matt <msw@amazon.com&= gt; wrote:

In particular:

"Xen = Project 4.4 Hypervisor" -> "Xen Project Hypervisor version 4.4"

"This release furth= er advances the Project=A1=A6s position as a fast, scalable, secure virtual= ization engine for the industry=A1=A6s broadest range of server, PC chipset= s and next-generation low-power = system on chips (SoC) devices."  PC chipsets? Wouldn't it make m= ore sense to say something like "server, workstation and low-power sys= tem on a chip (SoC) devices"? Note the drop of "next-generation&q= uot; since SoC is quite established today.

"Additionally, deve= lopers creating services and apps with embedded, mobile and cloud systems w= ill benefit from the updated event channel implementation when scaling out = their Infrastructure as a Service offerings." "apps" -> "applications".

We need to have a delibe= rate decision to introduce "Xen Project Archit= ecture" in our nomenclature. I'm not aware of a use like this in the p= ast.

"All the userspace too= ls, such as the xl management tool, are 64-bit ready and can be used to cre= ate 64-bit virtual machines out of the box." - written like a develope= r (no offense to developers on this list).


"Top contributo= rs include Amazon, AMD, Analog Devices, Broadcom, Citrix, Fujitsu, Intel, Linar= o, NSA, Oracle, Suse, Verizon/Terremark, plus numerous individual and acade= mic contributors. "Amazon" must be "Amazon Web Se= rvices". "Suse" should be "SUSE". "plus"= should be something like "along with". "Top contributors .. academi= c contributors" is a bit redundant. Perhaps "academic institution= s"?

 

There's a lot of room for improvement on this. Incorporating a few key= changes isn't really going to make this a quality release with a strong st= ory. Overall, I'm quite surprised and disappointed with the current state.<= /div>

--msw

From: advisory-board-bounces@lists.xenproject.org [advisory-board-bounc= es@lists.xenproject.org] on behalf of Mark Hinkle [Mark.Hinkle@citrix.com]
Sent: Friday, March 07, 2014 10:27 AM

To: Advisory-board discussions
Cc: Jennifer Cloer
Subject: Re: [Advisory-board] Xen Project 4.4 Release

I don=A1=A6t disagree with Matt the text is  awkward particu= larly because of it=A1=A6s highly technical nature. Do you have any specifi= c feedback for Sarah to incorporate. I didn=A1=A6t want to push too hard si= nce the clock is ticking but we should get this right. 

Going forward I would like to suggest using Oracle=A1=A6s bulleted lis= t format for their press releases since tying together the actual news and = tech content into a compelling narrative is pretty tough. Here an example o= f what I=A1=A6d propose.  

http://www.oracle.com/us/corporate/press/2033376

Regards, Mark 


On Mar 7, 2014, at 12:17 PM, Wilson, Matt <msw@amazon.com> wrote:

I'm not s= atisfied with the quality of this text (typos, etc.) given the plan to put = it on the wire Monday. We still don't have a strong message and a plan on h= ow we plan to brand the technologies that are produced by the community.

--msw

From: = advisory-board-bounces@lists.xenproject.org [advisor= y-board-bounces@lists.xenproject.org] on behalf of Mark Hinkle [Mark.Hinkle@citrix.com]
Sent: Friday, March 07, 2014 9:04 AM
To: Advisory-board discussions
Cc: Jennifer Cloer
Subject: Re: [Advisory-board] Xen Project 4.4 Rele= ase

Sarah, 

Branding seems to be applied appropriately though I think there were a= couple of spelling issues I caught. Attached is fine by me though the bran= ding and flow is still a bit challenging. 

Mark 


On Mar 7, 2014, at 10:13 AM, Sarah Conway <sconway@linuxfoundation.org>= ; wrote:

Hi everyone.

I've incorporated everyone's edits. I tried to reconcile the TM-relate= d issues of brand confusion and flow as best I could. As you can imagine, I= got varying edits, which started to conflict with one another.

This would benefit from another TM review/final approval. Can someone = step up to do this and make a final call? 

Mike D., Citrix is on the full AB email list so they've been involved = in reviews. 

Please advise soonest. 

Thanks,




On Fri, Mar 7, 2014 at 8:13 AM, Richard Phelan <Richard.Phelan@arm.com> wrote:
Hi,

I agree with Mark as the current press release is highlighting issues = that seem to make the articulation of brand and brand values more cumbersom= e than is desirable.

I'm happy to go with the proposed changes for the reasons stated.

One minor point, I'd prefer "?=A6System on Chip (SoC) devices.&qu= ot;, two sets of plurals make it unclear how many systems are on each chip = and the plurals get submerged into the acronym; common usage seems to be So= Cs.

Thanks,

Richard.

From: Mark Hinkle= <Mark.Hinkl= e@citrix.com>
Reply-To: Advisor= y-board discussions <advisory-board@lists.xenproject.org>
Date: Friday, 7 M= arch 2014 05:32
To: Advisory-boar= d discussions <advisory-board@lists.xenproject.org>

Subject: Re: [Adv= isory-board] Xen Project 4.4 Release

My apologies for the slow reply I was s= tuck on the road and couldn?? read the release on my phone to formulate a p= roper response. I should move to a highly elastic Xen Project-powered cloud= that allows me to autoscale ;) (sorry bad cloud joke). 

I am fine without doing the acronym and I think the realigning and bra= nding discussion should be had. I?? like to have that discussion during our= next board meeting. Given time is of the essence I think we should just up= date the links to version versus Xen 4.3.1. 

Also I took a shot at the wording of the press release. It?? probably = not perfect but makes it read a bit better. Attached are my proposed edits.= Sarah, I sent you the word doc with track changes assuming we have some ed= its to agree on. 


Regards, Mark 

Xen Project Releases Upda= te to Enterprise Hypervisor Software

<= span style=3D"font-size:12pt">Open Source Virtualization Software Release I= ncludes Additional ARM Support and Scalability for Cloud and Mobile Environ= ments 

<= span style=3D"font-size:12pt"> 

SAN FRANCISCO, March 10, 2014 ??/span>&n= bsp;Xen Project, a Collaborative Project hosted at The Linux Foundation, today announced availability of the Xen Project 4= .4 with enhanced ARM support. The latest release also includes major perfor= mance and system scalability improvements for enterprise computing, such as= mobile and cloud environments, where virtualization technology is increasingly in demand.

This release= further advances the Project??/span>s position as a fast, scalabl= e, secure virtualization engine for the industry??= /span>s broadest range of server, PC chipsets and next-generation low-power system= s on chips (SoC).

Major contri= butions from AMD, Citrix, Intel, Oracle and SUSE are pushing the Xen Projec= t software to take advantage of the latest hardware. Additionally, develope= rs creating services and apps with embedded, mobile and cloud systems will benefit from new features such as event chan= neling when scaling out their Infrastructure as a Service offerings.=

??/span><= span style=3D"font-size:12pt">Virtualization and low-powered servers are le= ading companies to rethink the data center and its potential for efficiency= ,?? said Lars Kurth, Chairman of the Xen Project advisory board. = ??/span>Our solution contains IT-related costs, plus meets the security and sc= alability needs of today?= ?/span>s elastic cloud, mobile and social networking companies. The latest updates = continue the Project??/span>s track record of rich collaboration and widespread development= from many of the world??= /span>s technology leaders. This certainly explains the significant growth of ARM = support, which we??/span&= gt;re pleased to see advance so quickly.??/span>

Support for ARM on Xen Project Architecture Grows Quickly<= /span>

The new release introduces significant st= ability, usability and performance improvements for the ARM architecture an= d extended hardware compatibility.  AppliedMicro??/span>s X-Gene, the Arndale Board, Calxeda ECX-2000, TI OMAP5 and the Allwinner Su= nXi boards are all supported. The substantially improved multiplatform capa= bilities of the hypervisor allow hardware and embedded vendors to port the = Xen Project technology to new ARM SoCs easily, shortening their time to market.<= /p>

 

Additional enhancements in this release i= ncluded 64-bit guest support on ARMv8 platforms. All the userspace tools, s= uch as the xl management tool, are 64-bit ready and can be used to create 6= 4-bit virtual machines out of the box.

 

The Xen Project hypercall ABI is now stab= le and will be maintained for backward compatibility, so users can trust fu= ture releases to boot older operating systems.

Additional improvements include extended = support for ARM specific bootloaders and firmware interfaces, and support f= or physical partitions and LVM volumes to store disks of virtual machines.<= u>

 

Improved Event Channel Scalability For Cloud Computing=

Xen Project = developers continues to drive innovation and collaboration around server vi= rtualization and the cloud. Powering many of the largest clouds in producti= on today, including Amazon EC2, Rackspace Cloud and others, the community understands the need to run more virtual m= achines on a single host.

Yet demands = on hypervisor scalability continue to increase, both from larger machines, = new workloads such as virtualization desktop infrastructures (VDI) and new = cloud OS technologies, including MirageOS, ErlangOnXen, OSv, and HalVM. Recognizing that high-availability and stabil= ity are critical to VDIs and cloud deployments; the XenServer team at Citri= x contributed the new event channel implementation to the Xen Project. To h= elp eliminate workload limitations for users, this enables the hypervisor to run thousands of guests on a sin= gle physical machine.   

Experimental Support for PVH Mode for Guest

Oracle has c= ontributed a functional preview of a new virtualization mode called PVH currently available to virtualized guests. PVH is an extension to = the classic Xen Project Paravirtualization (PV) that uses the hardware virt= ualization extensions available on modern x86 processors. PVH uses PV drivers for boot and I/O and Intel hardware vi= rtualization extensions for page table operations, system calls and other p= rivileged operations. This not only improves performance and security, but = also simplifies the architecture and Xen Project Hypervisor-Linux interface significantly.

??/span>PVH is a major development for Xen Project software on x86 and has = the potential to greatly simplify the Linux interface in due time, ?? said Konrad Rzeszutek Wilk, Sof= tware Development Manager at Oracle, a Xen Project advisory board member. ??/span>We expect PVH to have the best characteristics o= f all virtualization modes -- a simple, fast, secure interface, with low memory overhead, that also takes full advantage= of the latest hardware.??/span>

 

Additional k= ey updates include:

=EF=BF=BD=EF=BF=BD    &= nbsp;Better performance with m= odern storage devices and big data -- Indirect descriptors for block PV pro= tocol (Linux) allow each individual request to triple in size, greatly improving= I/O performance when running on fast storage technologies such as solid-st= ate drive and RAID. Available in any guest running Linux 3.11 or higher (re= gardless of Xen Project version).

 = ;

=EF=BF=BD=EF=BF=BD    &= nbsp;More powerful driver doma= ins -- Disk driver domains can now uniformly run block scripts and user-space backends= , such as qdisk, bringing them up to feature parity with domain 0. This mea= ns host administrators can take advantage of the enhanced security, scalabi= lity, and robustness provided by driver domains without sacrificing the wide array of disk configuration op= tions provided by Xen in dom0.=

=EF=BF=BD=EF=BF=BD    &= nbsp;New SPICE protocol suppor= t -- Functionality such as clipboard sharing and USB redirection creates a = much richer connection for virtual desktops and better graphics performance.

=EF=BF=BD=EF=BF=BD    &= nbsp;Enhanced diagnostics and = kexec debug support -- When a crash happens, a special kernel is allowed im= mediate to collect information about the root cause, offering developers better di= agnosis and repair abilities.<= /p>

The 4.4 release is the result of a broad,= collaborative development effort representing engineers from more than 13 = leading hardware, software and security vendors. Top contributors include A= mazon, AMD, Analog Devices, Broadcom, Citrix, Fujitsu, Intel, Linaro, NSA, Oracle, Suse, Verizon/Terremark, plus= numerous individual and academic contributors. The freely available downlo= ad can be found on the XenProject.org website (insert url).

 

About Xen Project

The Xen Proj= ect software is an open source virtualization platform licensed under the G= PLv2 with a similar governance structure to the Linux kernel. Designed from= the start for cloud computing, the Project has more than a decade of development and is being used by more th= an 10 million users. A Collaborative Project at The Linux Foundation, the X= en Project team is focused on advancing virtualization in a number of diffe= rent commercial and open source applications including server virtualization, Infrastructure as a Service = (IaaS), desktop virtualization, security applications, embedded and hardwar= e appliances. It counts many industry and open source community leaders amo= ng its members including: Amazon Web Services, AMD, ARM, Bromium, Calxeda, CA Technologies, Cisco, Citrix, = Google, Intel, Oracle, Samsung and Verizon. For more information about the = Xen Project hypervisor and to participate, please visithttp://xenproject.org.=

###

Sarah Conway=

The Xen Proj= ect

Media Contac= t

publicity@lists.xen= project.org



On Mar 6, 2014, at 12:44 PM, Wilson, Matt <msw@amazon.com> wrote:

Mark, tho= ughts?

From: = Wilson, Matt
Sent: Wednesday, March 05, 2014 10:01 AM
To: Advisory-board discussions
Subject: RE: [Advisory-board] Xen Project 4.4 Rele= ase

I'd rather use "Xen Project Hypervisor" than introduce an ac= ronym. I think it's important that "Xen Project" not be split fro= m "Hypervisor."

This still doesn't address how the umbrella project is called. This new rel= ease doesn't only include the hypervisor, but also the associated toolstack= and utilities. Maybe we're OK calling all of that the "Hypervisor,&qu= ot; even if we identify the development teams differently.

How should we re-align all of the branding? For example: http://xenproject.org/developers/teams/hypervis= or.html

Should the links under "Hypervisor Downloads" be "versi= on 4.3.1" instead of "Xen 4.3.1" to resolve the trademark co= ncerns?

--msw

From: = advisory-board-bounces@lists.xenproject.org [advisory-board-bounces@lists.xenproject.org] on behalf of Sarah Conway [sconway@linuxfoundation.org]
Sent: Wednesday, March 05, 2014 9:33 AM
To: Advisory-board discussions
Subject: Re: [Advisory-board] Xen Project 4.4 Rele= ase

Mark et all, 

I agree t= hat using Xen Project is a mouthful. Given that there is close overlap and occasional branding confus= ion with Citrix products, if we add another new term or acronym into the mix, we'll want to be dili= gent about being consistent in blogs, presentations, news releases, web site copy, customer testimonials etc. 

For the sake of simplicity, how about using XPH - all up= percase - on second reference? Thoughts?

Thanks,






On Wed, Mar 5, 2014 at 9:18 AM, Mark Hinkle <M= ark.Hinkle@citrix.com> wrote:
How about this convention only say Xen = Project and Xen Project hypervisor once then. Use the abbreviation XPh thro= ughout the release. Just snipping Matt?? example to make the point. I would= guess that the appropriate capitalization would be lower case for the word hypervisor. 

Mark 

The&n= bsp;Xen Project, a C= ollaborative Project hosted at The Linux Foundation, today announced availa= bility of the Xen Project hypervisor(XPh) 4.4 with enhanced ARM support.

XPh 4= .4 further advances the Project??/span>s position as a fast, scalable, secure virtualization engin= e for the industry??/span>s broadest range of server, PC chipsets and next-generation low-power system= s on chips (SoC).


On Mar 4, 2014, at 4:01 PM, Wilson, Matt <msw@amazon.com> wrote:

The "Xen Project" terminology makes the message extremely cu= mbersome.

The Xen Projec= t, a Collaborative Project hosted at The Linux Foundation, today ann= ounced availability of the Xen Project 4.4 Hypervisor with enhanced <= /span>Xen Project-on= -ARM support.

Why not just say "enhanced ARM support"? We should adopt some usa= ge guidelines for sub-project branding. We shouldn't insert words/numbers b= etween "Xen Project" and a sub-project name.

The= Xen Project, a Collaborative Project hosted at The Linux Foundation, today= announced version 4.4 of the Xen Project Hypervisor with enhanced ARM supp= ort.

or
The= Xen Project, a Collaborative Project hosted at The Linux Foundation, today= announced the release of Xen Project Hypervisor 4.4 with enhanced ARM supp= ort.
Later on, this release is called "Xen Project 4.4"

The X= en Project 4.4 release further advances the Project??/span>s position as a fast, scalable, secure = virtualization engine for the industry??/span&g= t;s broadest range of server, PC chipsets and next-generation low-power system= s on chips (SoC).

That doesn't flow well. How are we releasing version 4.4 of a project?= Do we want to call the overall release "Xen Project Architecture 4.4&= quot;? Or do we need to come up with some other project branding?

--msw

From: = advisory-board-bounces@lists.xenproject.org [advisory-board-bounces@lists.xenproject.org] on behalf of Sarah Conway [sconway@linuxfoundation.org]
Sent: Tuesday, March 04, 2014 12:16 PM

To: advisory-board@lists.xenproject.org
Subject: [Advisory-board] Xen Project 4.4 Release<= br>

Hi everyone.

Attached is the Xen Project 4.4 news release annoucement that will go = out at 8 a.m. ET on Monday, March 10. 

If you have any additional comments or edits, please get back to me by= Thursday morning at the latest. 

Thanks, 


-- 
Sarah Conway
PR Manager
The Linux Foundation
sconway@li= nuxfoundation.org
Skype:  sarah.k.conway
_______________________________________________
Advisory-board mailing list
Ad= visory-board@lists.xenproject.org
http://lists.xenproject.org/cgi-bin/mailman/listinfo= /advisory-board


_______________________________________________
Advisory-board mailing list
Ad= visory-board@lists.xenproject.org
http://lists.xenproject.org/cgi-bin/mailman/listinfo= /advisory-board




-- 
Sarah Conway
PR Manager
The Linux Foundation
sconway@li= nuxfoundation.org
Skype:  sarah.k.conway
_______________________________________________
Advisory-board mailing list
Ad= visory-board@lists.xenproject.org
http://lists.xenproject.org/cgi-bin/mailman/listinfo= /advisory-board


-- IMPORTANT NOTICE: The contents of this email and an= y attachments are confidential and may also be privileged. If you are not t= he intended recipient, please notify the sender immediately and do not disc= lose the contents to any other person, use it for any purpose, or store or copy the information in any medium. Th= ank you.

ARM Limited, Registered office 110 Fulbourn Road, Cambridge CB1 9NJ, Regist= ered in England & Wales, Company No: 2557590
ARM Holdings plc, Registered office 110 Fulbourn Road, Cambridge CB1 9NJ, R= egistered in England & Wales, Company No: 2548782

_______________________________________________
Advisory-board mailing list
Ad= visory-board@lists.xenproject.org
http://lists.xenproject.org/cgi-bin/mailman/listinfo= /advisory-board




-- 
Sarah Conway
PR Manager
The Linux Foundation
sconway@li= nuxfoundation.org
Skype:  sarah.k.conway
<XenProjectUpdate4.43.6.2014(2)docx>____________________= ___________________________
Advisory-board mailing list
Ad= visory-board@lists.xenproject.org
http://lists.xenproject.org/cgi-bin/mailman/listinfo= /advisory-board

_______________________________________________
Advisory-board mailing list
Ad= visory-board@lists.xenproject.org
http://lists.xenproject.org/cgi-bin/mailman/listinfo= /advisory-board




--
Sarah Conway
PR Manager
The Linux Foundation
sconway@li= nuxfoundation.org
(978) 578-5300  Cell
Skype:  sarah.k.conway
--_000_B5EC053C78C5D746BD8AC3386F2303C9157318AMSPEX01CL01citri_-- --===============4997032678153424191== Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Disposition: inline _______________________________________________ Advisory-board mailing list Advisory-board@lists.xenproject.org http://lists.xenproject.org/cgi-bin/mailman/listinfo/advisory-board --===============4997032678153424191==-- From xen-users-bounces@lists.xen.org Mon Mar 24 10:23:53 2014 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Mon, 24 Mar 2014 10:23:53 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WS21n-0000Pd-O4; Mon, 24 Mar 2014 10:22:47 +0000 Received: from mail6.bemta14.messagelabs.com ([193.109.254.103]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WS21l-0000PM-Bf for xen-users@lists.xen.org; Mon, 24 Mar 2014 10:22:46 +0000 Received: from [193.109.254.147:63562] by server-12.bemta-14.messagelabs.com id 7A/A7-27473-47700335; Mon, 24 Mar 2014 10:22:44 +0000 X-Env-Sender: facu.curti@gmail.com X-Msg-Ref: server-6.tower-27.messagelabs.com!1395656561!3702375!1 X-Originating-IP: [209.85.213.45] X-SpamReason: No, hits=1.2 required=7.0 tests=HTML_20_30,HTML_MESSAGE, ML_RADAR_SPEW_LINKS_14,RCVD_BY_IP,spamassassin: X-StarScan-Received: X-StarScan-Version: 6.11.1; banners=-,-,- X-VirusChecked: Checked Received: (qmail 4043 invoked from network); 24 Mar 2014 10:22:42 -0000 Received: from mail-yh0-f45.google.com (HELO mail-yh0-f45.google.com) (209.85.213.45) by server-6.tower-27.messagelabs.com with RC4-SHA encrypted SMTP; 24 Mar 2014 10:22:42 -0000 Received: by mail-yh0-f45.google.com with SMTP id a41so4849105yho.18 for ; Mon, 24 Mar 2014 03:22:41 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20120113; h=mime-version:date:message-id:subject:from:to:content-type; bh=X+Hf5C+ePxuFQ3axWwchUJO+DDrerRHE/ixJCvzp4Bk=; b=tZUk4XiHwGblSRoSXc5UX5mJbxPR1/MSHxovaVrCpmAsheaBu8skNMjjvCm9CjkqJo RBlYhaXPDRWYA2ciEsOoQmZHtBHkrZi8ggy9Z6OQWhNFGAULYDP+80XbLJl9AEA4+m4j wm6QtwVEMb2WV+UivAyL++MlJ8OxN3PkPiZ3QeXo/hQj6LrzyYkhnu0VECbv6W78oP7M 3FzpAlhPYFe+VqQ2Squfrt1l5xxve1mk4qMpQ1w1KQHD61j3V7X+hI5Aefd5BkLKSxLB 6r4a3Q4TuCvfdHLFkceg8MxFoHpuiH+bMVRA176vHS0APggZbvXBKcd30DldkTV8PRX1 YN5w== MIME-Version: 1.0 X-Received: by 10.236.16.161 with SMTP id h21mr88788703yhh.77.1395656561464; Mon, 24 Mar 2014 03:22:41 -0700 (PDT) Received: by 10.170.40.80 with HTTP; Mon, 24 Mar 2014 03:22:41 -0700 (PDT) Date: Mon, 24 Mar 2014 07:22:41 -0300 Message-ID: From: Facundo Curti To: xen-users@lists.xen.org Content-Type: multipart/mixed; boundary=001a11c2aeda93361b04f5579d4e Subject: [Xen-users] xen, efi and grub2 on gentoo . No console will be availible to OS X-BeenThere: xen-users@lists.xen.org X-Mailman-Version: 2.1.13 Precedence: list List-Id: Xen user discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Sender: xen-users-bounces@lists.xen.org Errors-To: xen-users-bounces@lists.xen.org --001a11c2aeda93361b04f5579d4e Content-Type: multipart/alternative; boundary=001a11c2aeda93361704f5579d4c --001a11c2aeda93361704f5579d4c Content-Type: text/plain; charset=UTF-8 Hi all! Im new in list and xen world. I hope to make my first install successfully :). As title suggest, I have a gentoo PC with uefi, grub2 and xen. When I try to boot the system, it says "WARNING: No console will be available to OS". Stays there a few seconds, and then restarts, making a infinity bucle. I can boot the system from a USB booteable, selecting to boot from my current kernel (without xen). I was searching on Internet, and old mail lists, and this is a common problem (see links [1-4] at the end). But I didnt find a way to fix it :/ My info: app-emulation/xen-4.3.1-r5 USE="efi xsm -custom-cflags -debug -flask" sys-boot/grub-2.00_p5107-r2:2 USE="device-mapper efiemu multislot nls truetype -custom-cflags -debug -doc (-libzfs) -mount -sdl -static {-test}" GRUB_PLATFORMS="efi-64 -coreboot -efi-32 -emu -ieee1275 -multiboot -pc -qemu -qemu-mips -yeeloong" My files: /boot: total 21176 -rw-r--r-- 1 root root 81004 mar 24 02:14 config-dom0-3.12.13 drwxr-xr-x 4 root root 16384 dic 31 1969 efi drwxr-xr-x 7 root root 4096 mar 24 06:47 grub -rwxr-xr-x 1 root root 4423072 mar 24 02:14 kernel-3.12.13-gentoo -rwxr-xr-x 1 root root 17351830 mar 24 02:14 kernel-dom0-3.12.13 -rw-r--r-- 1 root root 417 mar 24 07:13 tmp -rw-r--r-- 1 root root 879272 mar 24 05:18 xen-4.3.1.gz -rw-r--r-- 1 root root 879272 mar 24 05:18 xen-4.3.gz -rw-r--r-- 1 root root 879272 mar 24 05:18 xen-4.gz -rw-r--r-- 1 root root 879272 mar 24 05:18 xen.gz -rw-r--r-- 1 root root 1858672 mar 24 05:18 xen-syms-4.3.1 /boot/efi/: total 4 drwxr-xr-x 3 root root 2048 mar 24 04:04 EFI drwxr-xr-x 2 root root 2048 mar 24 06:30 gentoo /boot/efi/EFI: total 2 drwxr-xr-x 2 root root 2048 mar 24 04:04 gentoo /boot/efi/EFI/gentoo: total 120 -rwxr-xr-x 1 root root 121856 mar 24 2014 grubx64.efi /boot/efi/gentoo: total 19034 -rwxr-xr-x 1 root root 17351830 mar 24 06:21 kernel-dom0-3.12.13 -rwxr-xr-x 1 root root 2134522 mar 24 05:18 xen-4.3.1.efi -rwxr-xr-x 1 root root 100 mar 24 06:30 xen.cfg I also let attached my default/grub, my grub.cfg and my kernel config I hope somebody can help me please. Thank you! :) [1] http://lists.xen.org/archives/html/xen-users/2012-08/msg00125.html [2] http://xen.1045712.n5.nabble.com/xen-4-1-3-EFI-boot-and-quot-no-console-to-OS-quot-problem-td5714925.html [3] http://osdir.com/ml/general/2013-03/msg37740.html [4] http://en.it-usenet.org/thread/11824/75310/ --001a11c2aeda93361704f5579d4c Content-Type: text/html; charset=UTF-8 Content-Transfer-Encoding: quoted-printable
Hi all! Im new in list and xen world. I hope to = make my first install successfully :). As title suggest, I have a gentoo= PC with uefi, grub2 and xen. When I try to boot the system, it says "= WARNING: No console will be available to OS". Stays there a few second= s, and then restarts, making a infinity bucle. I can boot the system from a= USB booteable, selecting to boot from my current kernel (without xen).


I was searching on Internet, and old mail lists, and this is a comm= on problem (see links [1-4] at the end). But I didnt find a way to fix it := /

My info:

app-emulation/xen-4.3.1-r5=C2=A0 USE=3D"= ;efi xsm -custom-cflags -debug -flask"
sys-boot/grub-2.00_p5107-r2:2=C2=A0 USE=3D"device-mapper efiemu multis= lot nls truetype -custom-cflags -debug -doc (-libzfs) -mount -sdl -static {= -test}" GRUB_PLATFORMS=3D"efi-64 -coreboot -efi-32 -emu -ieee1275= -multiboot -pc -qemu -qemu-mips -yeeloong"

My files:

/boot:
total 21176
-rw-r--r-- 1 root root= =C2=A0=C2=A0=C2=A0 81004 mar 24 02:14 config-dom0-3.12.13
drwxr-xr-x 4 r= oot root=C2=A0=C2=A0=C2=A0 16384 dic 31=C2=A0 1969 efi
drwxr-xr-x 7 root= root=C2=A0=C2=A0=C2=A0=C2=A0 4096 mar 24 06:47 grub
-rwxr-xr-x 1 root root=C2=A0 4423072 mar 24 02:14 kernel-3.12.13-gentoo
= -rwxr-xr-x 1 root root 17351830 mar 24 02:14 kernel-dom0-3.12.13
-rw-r--= r-- 1 root root=C2=A0=C2=A0=C2=A0=C2=A0=C2=A0 417 mar 24 07:13 tmp
-rw-r= --r-- 1 root root=C2=A0=C2=A0 879272 mar 24 05:18 xen-4.3.1.gz
-rw-r--r-- 1 root root=C2=A0=C2=A0 879272 mar 24 05:18 xen-4.3.gz
-rw-r-= -r-- 1 root root=C2=A0=C2=A0 879272 mar 24 05:18 xen-4.gz
-rw-r--r-- 1 r= oot root=C2=A0=C2=A0 879272 mar 24 05:18 xen.gz
-rw-r--r-- 1 root root= =C2=A0 1858672 mar 24 05:18 xen-syms-4.3.1

/boot/efi/:
total 4
drwxr-xr-x 3 root root 2048 mar 24 04:04 EFI<= br>drwxr-xr-x 2 root root 2048 mar 24 06:30 gentoo

/boot/efi/EFI:total 2
drwxr-xr-x 2 root root 2048 mar 24 04:04 gentoo

/boot/ef= i/EFI/gentoo:
total 120
-rwxr-xr-x 1 root root 121856 mar 24=C2=A0 2014 grubx64.efi
/boot/efi/gentoo:
total 19034
-rwxr-xr-x 1 root root 17351830 ma= r 24 06:21 kernel-dom0-3.12.13
-rwxr-xr-x 1 root root=C2=A0 2134522 mar = 24 05:18 xen-4.3.1.efi
-rwxr-xr-x 1 root root=C2=A0=C2=A0=C2=A0=C2=A0=C2=A0 100 mar 24 06:30 xen.c= fg

I also let attached my default/grub, my grub.cfg and my kern= el config

I hope somebody can help me please. Thank you! = :)
--001a11c2aeda93361704f5579d4c-- --001a11c2aeda93361b04f5579d4e Content-Type: application/octet-stream; name=grub Content-Disposition: attachment; filename=grub Content-Transfer-Encoding: base64 X-Attachment-Id: f_ht5ln4ed0 IyBDb3B5cmlnaHQgMTk5OS0yMDEzIEdlbnRvbyBGb3VuZGF0aW9uCiMgRGlzdHJpYnV0ZWQgdW5k ZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2MgojICRIZWFk ZXI6IC92YXIvY3Zzcm9vdC9nZW50b28teDg2L3N5cy1ib290L2dydWIvZmlsZXMvZ3J1Yi5kZWZh dWx0LTIsdiAxLjQgMjAxMy8wOS8yMSAxODoxMDo1NSBmbG9wcHltIEV4cCAkCiMKIyBUbyBwb3B1 bGF0ZSBhbGwgY2hhbmdlcyBpbiB0aGlzIGZpbGUgeW91IG5lZWQgdG8gcmVnZW5lcmF0ZSB5b3Vy CiMgZ3J1YiBjb25maWd1cmF0aW9uIGZpbGUgYWZ0ZXJ3YXJkczoKIyAgICAgJ2dydWIyLW1rY29u ZmlnIC1vIC9ib290L2dydWIvZ3J1Yi5jZmcnCiMKIyBTZWUgdGhlIGdydWIgaW5mbyBwYWdlIGZv ciBkb2N1bWVudGF0aW9uIG9uIHBvc3NpYmxlIHZhcmlhYmxlcyBhbmQKIyB0aGVpciBhc3NvY2lh dGVkIHZhbHVlcy4gCgpHUlVCX0RJU1RSSUJVVE9SPSJHZW50b28iCgpHUlVCX0RFRkFVTFQ9MApH UlVCX0hJRERFTl9USU1FT1VUPTAKR1JVQl9ISURERU5fVElNRU9VVF9RVUlFVD10cnVlCkdSVUJf VElNRU9VVD0xCgojIEFwcGVuZCBwYXJhbWV0ZXJzIHRvIHRoZSBsaW51eCBrZXJuZWwgY29tbWFu ZCBsaW5lCiMgR1JVQl9DTURMSU5FX0xJTlVYPSIiCgojIEFwcGVuZCBwYXJhbWV0ZXJzIHRvIHRo ZSBsaW51eCBrZXJuZWwgY29tbWFuZCBsaW5lIGZvciBub24tcmVjb3ZlcnkgZW50cmllcwpHUlVC X0NNRExJTkVfTElOVVhfREVGQVVMVD0iZGVmYXVsdCBpbml0PS9zYmluL2luaXQiCgojIFVuY29t bWVudCB0byBkaXNhYmxlIGdyYXBoaWNhbCB0ZXJtaW5hbCAoZ3J1Yi1wYyBvbmx5KQojR1JVQl9U RVJNSU5BTD1jb25zb2xlCgojIFRoZSByZXNvbHV0aW9uIHVzZWQgb24gZ3JhcGhpY2FsIHRlcm1p bmFsLgojIE5vdGUgdGhhdCB5b3UgY2FuIHVzZSBvbmx5IG1vZGVzIHdoaWNoIHlvdXIgZ3JhcGhp YyBjYXJkIHN1cHBvcnRzIHZpYSBWQkUuCiMgWW91IGNhbiBzZWUgdGhlbSBpbiByZWFsIEdSVUIg d2l0aCB0aGUgY29tbWFuZCBgdmJlaW5mbycuCiNHUlVCX0dGWE1PREU9NjQweDQ4MAoKIyBQYXRo IHRvIHRoZW1lIHNwZWMgdHh0IGZpbGUuCiMgVGhlIHN0YXJmaWVsZCBpcyBieSBkZWZhdWx0IHBy b3ZpZGVkIHdpdGggdXNlIHRydWV0eXBlLgojIE5PVEU6IHdoZW4gZW5hYmxpbmcgY3VzdG9tIHRo ZW1lLCBlbnN1cmUgeW91IGhhdmUgcmVxdWlyZWQgZm9udC9ldGMuCiNHUlVCX1RIRU1FPSIvYm9v dC9ncnViL3RoZW1lcy9zdGFyZmllbGQvdGhlbWUudHh0IgoKIyBCYWNrZ3JvdW5kIGltYWdlIHVz ZWQgb24gZ3JhcGhpY2FsIHRlcm1pbmFsLgojIENhbiBiZSBpbiB2YXJpb3VzIGJpdG1hcCBmb3Jt YXRzLgojR1JVQl9CQUNLR1JPVU5EPSIvYm9vdC9ncnViL215YmFja2dyb3VuZC5wbmciCgojIFVu Y29tbWVudCBpZiB5b3UgZG9uJ3Qgd2FudCBHUlVCIHRvIHBhc3MgInJvb3Q9VVVJRD14eHgiIHBh cmFtZXRlciB0byBrZXJuZWwKI0dSVUJfRElTQUJMRV9MSU5VWF9VVUlEPXRydWUKCiMgVW5jb21t ZW50IHRvIGRpc2FibGUgZ2VuZXJhdGlvbiBvZiByZWNvdmVyeSBtb2RlIG1lbnUgZW50cmllcwoj R1JVQl9ESVNBQkxFX1JFQ09WRVJZPXRydWUKCiNPcGNpb25lcyBwYXJhIFhFTjoKR1JVQl9DTURM SU5FX0xJTlVYX1hFTl9SRVBMQUNFPSJtYXhfbG9vcD0xMjgiCkdSVUJfQ01ETElORV9YRU49ImRv bTBfbWVtPTUxMiIK --001a11c2aeda93361b04f5579d4e Content-Type: application/octet-stream; name="grub.cfg" Content-Disposition: attachment; filename="grub.cfg" Content-Transfer-Encoding: base64 X-Attachment-Id: f_ht5loivy1 IwojIERPIE5PVCBFRElUIFRISVMgRklMRQojCiMgSXQgaXMgYXV0b21hdGljYWxseSBnZW5lcmF0 ZWQgYnkgZ3J1YjItbWtjb25maWcgdXNpbmcgdGVtcGxhdGVzCiMgZnJvbSAvZXRjL2dydWIuZCBh bmQgc2V0dGluZ3MgZnJvbSAvZXRjL2RlZmF1bHQvZ3J1YgojCgojIyMgQkVHSU4gL2V0Yy9ncnVi LmQvMDBfaGVhZGVyICMjIwppZiBbIC1zICRwcmVmaXgvZ3J1YmVudiBdOyB0aGVuCiAgbG9hZF9l bnYKZmkKaWYgWyAiJHtuZXh0X2VudHJ5fSIgXSA7IHRoZW4KICAgc2V0IGRlZmF1bHQ9IiR7bmV4 dF9lbnRyeX0iCiAgIHNldCBuZXh0X2VudHJ5PQogICBzYXZlX2VudiBuZXh0X2VudHJ5CiAgIHNl dCBib290X29uY2U9dHJ1ZQplbHNlCiAgIHNldCBkZWZhdWx0PSIwIgpmaQoKaWYgWyB4IiR7ZmVh dHVyZV9tZW51ZW50cnlfaWR9IiA9IHh5IF07IHRoZW4KICBtZW51ZW50cnlfaWRfb3B0aW9uPSIt LWlkIgplbHNlCiAgbWVudWVudHJ5X2lkX29wdGlvbj0iIgpmaQoKZXhwb3J0IG1lbnVlbnRyeV9p ZF9vcHRpb24KCmlmIFsgIiR7cHJldl9zYXZlZF9lbnRyeX0iIF07IHRoZW4KICBzZXQgc2F2ZWRf ZW50cnk9IiR7cHJldl9zYXZlZF9lbnRyeX0iCiAgc2F2ZV9lbnYgc2F2ZWRfZW50cnkKICBzZXQg cHJldl9zYXZlZF9lbnRyeT0KICBzYXZlX2VudiBwcmV2X3NhdmVkX2VudHJ5CiAgc2V0IGJvb3Rf b25jZT10cnVlCmZpCgpmdW5jdGlvbiBzYXZlZGVmYXVsdCB7CiAgaWYgWyAteiAiJHtib290X29u Y2V9IiBdOyB0aGVuCiAgICBzYXZlZF9lbnRyeT0iJHtjaG9zZW59IgogICAgc2F2ZV9lbnYgc2F2 ZWRfZW50cnkKICBmaQp9CgpmdW5jdGlvbiBsb2FkX3ZpZGVvIHsKICBpZiBbIHgkZmVhdHVyZV9h bGxfdmlkZW9fbW9kdWxlID0geHkgXTsgdGhlbgogICAgaW5zbW9kIGFsbF92aWRlbwogIGVsc2UK ICAgIGluc21vZCBlZmlfZ29wCiAgICBpbnNtb2QgZWZpX3VnYQogICAgaW5zbW9kIGllZWUxMjc1 X2ZiCiAgICBpbnNtb2QgdmJlCiAgICBpbnNtb2QgdmdhCiAgICBpbnNtb2QgdmlkZW9fYm9jaHMK ICAgIGluc21vZCB2aWRlb19jaXJydXMKICBmaQp9CgppZiBbIHgkZmVhdHVyZV9kZWZhdWx0X2Zv bnRfcGF0aCA9IHh5IF0gOyB0aGVuCiAgIGZvbnQ9dW5pY29kZQplbHNlCmluc21vZCBwYXJ0X2dw dAppbnNtb2QgZXh0MgpzZXQgcm9vdD0naGQxLGdwdDInCmlmIFsgeCRmZWF0dXJlX3BsYXRmb3Jt X3NlYXJjaF9oaW50ID0geHkgXTsgdGhlbgogIHNlYXJjaCAtLW5vLWZsb3BweSAtLWZzLXV1aWQg LS1zZXQ9cm9vdCAtLWhpbnQtYmlvcz1oZDEsZ3B0MiAtLWhpbnQtZWZpPWhkMSxncHQyIC0taGlu dC1iYXJlbWV0YWw9YWhjaTEsZ3B0MiAgZjQ1M2Y4OGQtYTM1OS00ZTBkLTg1ODYtZTBjMjYwMGMz YjJkCmVsc2UKICBzZWFyY2ggLS1uby1mbG9wcHkgLS1mcy11dWlkIC0tc2V0PXJvb3QgZjQ1M2Y4 OGQtYTM1OS00ZTBkLTg1ODYtZTBjMjYwMGMzYjJkCmZpCiAgICBmb250PSIvdXNyL3NoYXJlL2dy dWIvdW5pY29kZS5wZjIiCmZpCgppZiBsb2FkZm9udCAkZm9udCA7IHRoZW4KICBzZXQgZ2Z4bW9k ZT1hdXRvCiAgbG9hZF92aWRlbwogIGluc21vZCBnZnh0ZXJtCiAgc2V0IGxvY2FsZV9kaXI9JHBy ZWZpeC9sb2NhbGUKICBzZXQgbGFuZz1lc19BUgogIGluc21vZCBnZXR0ZXh0CmZpCnRlcm1pbmFs X291dHB1dCBnZnh0ZXJtCmlmIHNsZWVwIC0taW50ZXJydXB0aWJsZSAwIDsgdGhlbgogIHNldCB0 aW1lb3V0PTEKZmkKIyMjIEVORCAvZXRjL2dydWIuZC8wMF9oZWFkZXIgIyMjCgojIyMgQkVHSU4g L2V0Yy9ncnViLmQvMjBfbGludXhfeGVuICMjIwptZW51ZW50cnkgJ0dlbnRvbyBHTlUvTGludXgs IGNvbiBlbCBoaXBlcnZpc29yIFhlbicgLS1jbGFzcyBnZW50b28gLS1jbGFzcyBnbnUtbGludXgg LS1jbGFzcyBnbnUgLS1jbGFzcyBvcyAtLWNsYXNzIHhlbiAkbWVudWVudHJ5X2lkX29wdGlvbiAn eGVuLWdudWxpbnV4LXNpbXBsZS1mNDUzZjg4ZC1hMzU5LTRlMGQtODU4Ni1lMGMyNjAwYzNiMmQn IHsKCWluc21vZCBwYXJ0X2dwdAoJaW5zbW9kIGV4dDIKCXNldCByb290PSdoZDEsZ3B0MicKCWlm IFsgeCRmZWF0dXJlX3BsYXRmb3JtX3NlYXJjaF9oaW50ID0geHkgXTsgdGhlbgoJICBzZWFyY2gg LS1uby1mbG9wcHkgLS1mcy11dWlkIC0tc2V0PXJvb3QgLS1oaW50LWJpb3M9aGQxLGdwdDIgLS1o aW50LWVmaT1oZDEsZ3B0MiAtLWhpbnQtYmFyZW1ldGFsPWFoY2kxLGdwdDIgIGY0NTNmODhkLWEz NTktNGUwZC04NTg2LWUwYzI2MDBjM2IyZAoJZWxzZQoJICBzZWFyY2ggLS1uby1mbG9wcHkgLS1m cy11dWlkIC0tc2V0PXJvb3QgZjQ1M2Y4OGQtYTM1OS00ZTBkLTg1ODYtZTBjMjYwMGMzYjJkCglm aQoJZWNobwknQ2FyZ2FuZG8gWGVuIHhlbi4uLicKICAgICAgICBpZiBbICIkZ3J1Yl9wbGF0Zm9y bSIgPSAicGMiIC1vICIkZ3J1Yl9wbGF0Zm9ybSIgPSAiIiBdOyB0aGVuCiAgICAgICAgICAgIHhl bl9ybV9vcHRzPQogICAgICAgIGVsc2UKICAgICAgICAgICAgeGVuX3JtX29wdHM9Im5vLXJlYWwt bW9kZSBlZGQ9b2ZmIgogICAgICAgIGZpCgltdWx0aWJvb3QJL2Jvb3QveGVuLmd6IHBsYWNlaG9s ZGVyIGRvbTBfbWVtPTUxMiAgJHt4ZW5fcm1fb3B0c30KCWVjaG8JJ0NhcmdhbmRvIExpbnV4IGRv bTAtMy4xMi4xMy4uLicKCW1vZHVsZQkvYm9vdC9rZXJuZWwtZG9tMC0zLjEyLjEzIHBsYWNlaG9s ZGVyIHJvb3Q9L2Rldi9zZGIyIHJvIG1heF9sb29wPTEyOCBkZWZhdWx0IGluaXQ9L3NiaW4vaW5p dAp9CnN1Ym1lbnUgJ09wY2lvbmVzIGF2YW56YWRhcyBwYXJhIEdlbnRvbyBHTlUvTGludXggKGNv biBlbCBoaXBlcnZpc29yIFhlbiknICRtZW51ZW50cnlfaWRfb3B0aW9uICdnbnVsaW51eC1hZHZh bmNlZC1mNDUzZjg4ZC1hMzU5LTRlMGQtODU4Ni1lMGMyNjAwYzNiMmQnIHsKCXN1Ym1lbnUgJ0hp cGVydmlzb3IgWGVuLCB2ZXJzacOzbiB4ZW4nICRtZW51ZW50cnlfaWRfb3B0aW9uICd4ZW4taHlw ZXJ2aXNvci14ZW4tZjQ1M2Y4OGQtYTM1OS00ZTBkLTg1ODYtZTBjMjYwMGMzYjJkJyB7CgkJbWVu dWVudHJ5ICdHZW50b28gR05VL0xpbnV4LCBjb24gWGVuIHhlbiB5IExpbnV4IGRvbTAtMy4xMi4x MycgLS1jbGFzcyBnZW50b28gLS1jbGFzcyBnbnUtbGludXggLS1jbGFzcyBnbnUgLS1jbGFzcyBv cyAtLWNsYXNzIHhlbiAkbWVudWVudHJ5X2lkX29wdGlvbiAneGVuLWdudWxpbnV4LWRvbTAtMy4x Mi4xMy1hZHZhbmNlZC1mNDUzZjg4ZC1hMzU5LTRlMGQtODU4Ni1lMGMyNjAwYzNiMmQnIHsKCQkJ aW5zbW9kIHBhcnRfZ3B0CgkJCWluc21vZCBleHQyCgkJCXNldCByb290PSdoZDEsZ3B0MicKCQkJ aWYgWyB4JGZlYXR1cmVfcGxhdGZvcm1fc2VhcmNoX2hpbnQgPSB4eSBdOyB0aGVuCgkJCSAgc2Vh cmNoIC0tbm8tZmxvcHB5IC0tZnMtdXVpZCAtLXNldD1yb290IC0taGludC1iaW9zPWhkMSxncHQy IC0taGludC1lZmk9aGQxLGdwdDIgLS1oaW50LWJhcmVtZXRhbD1haGNpMSxncHQyICBmNDUzZjg4 ZC1hMzU5LTRlMGQtODU4Ni1lMGMyNjAwYzNiMmQKCQkJZWxzZQoJCQkgIHNlYXJjaCAtLW5vLWZs b3BweSAtLWZzLXV1aWQgLS1zZXQ9cm9vdCBmNDUzZjg4ZC1hMzU5LTRlMGQtODU4Ni1lMGMyNjAw YzNiMmQKCQkJZmkKCQkJZWNobwknQ2FyZ2FuZG8gWGVuIHhlbi4uLicKCQkgICAgICAgIGlmIFsg IiRncnViX3BsYXRmb3JtIiA9ICJwYyIgLW8gIiRncnViX3BsYXRmb3JtIiA9ICIiIF07IHRoZW4K CQkgICAgICAgICAgICB4ZW5fcm1fb3B0cz0KCQkgICAgICAgIGVsc2UKCQkgICAgICAgICAgICB4 ZW5fcm1fb3B0cz0ibm8tcmVhbC1tb2RlIGVkZD1vZmYiCgkJICAgICAgICBmaQoJCQltdWx0aWJv b3QJL2Jvb3QveGVuLmd6IHBsYWNlaG9sZGVyIGRvbTBfbWVtPTUxMiAgJHt4ZW5fcm1fb3B0c30K CQkJZWNobwknQ2FyZ2FuZG8gTGludXggZG9tMC0zLjEyLjEzLi4uJwoJCQltb2R1bGUJL2Jvb3Qv a2VybmVsLWRvbTAtMy4xMi4xMyBwbGFjZWhvbGRlciByb290PS9kZXYvc2RiMiBybyBtYXhfbG9v cD0xMjggZGVmYXVsdCBpbml0PS9zYmluL2luaXQKCQl9CgkJbWVudWVudHJ5ICdHZW50b28gR05V L0xpbnV4LCBjb24gWGVuIHhlbiB5IExpbnV4IGRvbTAtMy4xMi4xMyAobW9kbyBkZSByZWN1cGVy YWNpw7NuKScgLS1jbGFzcyBnZW50b28gLS1jbGFzcyBnbnUtbGludXggLS1jbGFzcyBnbnUgLS1j bGFzcyBvcyAtLWNsYXNzIHhlbiAkbWVudWVudHJ5X2lkX29wdGlvbiAneGVuLWdudWxpbnV4LWRv bTAtMy4xMi4xMy1yZWNvdmVyeS1mNDUzZjg4ZC1hMzU5LTRlMGQtODU4Ni1lMGMyNjAwYzNiMmQn IHsKCQkJaW5zbW9kIHBhcnRfZ3B0CgkJCWluc21vZCBleHQyCgkJCXNldCByb290PSdoZDEsZ3B0 MicKCQkJaWYgWyB4JGZlYXR1cmVfcGxhdGZvcm1fc2VhcmNoX2hpbnQgPSB4eSBdOyB0aGVuCgkJ CSAgc2VhcmNoIC0tbm8tZmxvcHB5IC0tZnMtdXVpZCAtLXNldD1yb290IC0taGludC1iaW9zPWhk MSxncHQyIC0taGludC1lZmk9aGQxLGdwdDIgLS1oaW50LWJhcmVtZXRhbD1haGNpMSxncHQyICBm NDUzZjg4ZC1hMzU5LTRlMGQtODU4Ni1lMGMyNjAwYzNiMmQKCQkJZWxzZQoJCQkgIHNlYXJjaCAt LW5vLWZsb3BweSAtLWZzLXV1aWQgLS1zZXQ9cm9vdCBmNDUzZjg4ZC1hMzU5LTRlMGQtODU4Ni1l MGMyNjAwYzNiMmQKCQkJZmkKCQkJZWNobwknQ2FyZ2FuZG8gWGVuIHhlbi4uLicKCQkgICAgICAg IGlmIFsgIiRncnViX3BsYXRmb3JtIiA9ICJwYyIgLW8gIiRncnViX3BsYXRmb3JtIiA9ICIiIF07 IHRoZW4KCQkgICAgICAgICAgICB4ZW5fcm1fb3B0cz0KCQkgICAgICAgIGVsc2UKCQkgICAgICAg ICAgICB4ZW5fcm1fb3B0cz0ibm8tcmVhbC1tb2RlIGVkZD1vZmYiCgkJICAgICAgICBmaQoJCQlt dWx0aWJvb3QJL2Jvb3QveGVuLmd6IHBsYWNlaG9sZGVyIGRvbTBfbWVtPTUxMiAke3hlbl9ybV9v cHRzfQoJCQllY2hvCSdDYXJnYW5kbyBMaW51eCBkb20wLTMuMTIuMTMuLi4nCgkJCW1vZHVsZQkv Ym9vdC9rZXJuZWwtZG9tMC0zLjEyLjEzIHBsYWNlaG9sZGVyIHJvb3Q9L2Rldi9zZGIyIHJvIHNp bmdsZSBtYXhfbG9vcD0xMjgKCQl9Cgl9CglzdWJtZW51ICdIaXBlcnZpc29yIFhlbiwgdmVyc2nD s24gNC4zLjEnICRtZW51ZW50cnlfaWRfb3B0aW9uICd4ZW4taHlwZXJ2aXNvci00LjMuMS1mNDUz Zjg4ZC1hMzU5LTRlMGQtODU4Ni1lMGMyNjAwYzNiMmQnIHsKCQltZW51ZW50cnkgJ0dlbnRvbyBH TlUvTGludXgsIGNvbiBYZW4gNC4zLjEgeSBMaW51eCBkb20wLTMuMTIuMTMnIC0tY2xhc3MgZ2Vu dG9vIC0tY2xhc3MgZ251LWxpbnV4IC0tY2xhc3MgZ251IC0tY2xhc3Mgb3MgLS1jbGFzcyB4ZW4g JG1lbnVlbnRyeV9pZF9vcHRpb24gJ3hlbi1nbnVsaW51eC1kb20wLTMuMTIuMTMtYWR2YW5jZWQt ZjQ1M2Y4OGQtYTM1OS00ZTBkLTg1ODYtZTBjMjYwMGMzYjJkJyB7CgkJCWluc21vZCBwYXJ0X2dw dAoJCQlpbnNtb2QgZXh0MgoJCQlzZXQgcm9vdD0naGQxLGdwdDInCgkJCWlmIFsgeCRmZWF0dXJl X3BsYXRmb3JtX3NlYXJjaF9oaW50ID0geHkgXTsgdGhlbgoJCQkgIHNlYXJjaCAtLW5vLWZsb3Bw eSAtLWZzLXV1aWQgLS1zZXQ9cm9vdCAtLWhpbnQtYmlvcz1oZDEsZ3B0MiAtLWhpbnQtZWZpPWhk MSxncHQyIC0taGludC1iYXJlbWV0YWw9YWhjaTEsZ3B0MiAgZjQ1M2Y4OGQtYTM1OS00ZTBkLTg1 ODYtZTBjMjYwMGMzYjJkCgkJCWVsc2UKCQkJICBzZWFyY2ggLS1uby1mbG9wcHkgLS1mcy11dWlk IC0tc2V0PXJvb3QgZjQ1M2Y4OGQtYTM1OS00ZTBkLTg1ODYtZTBjMjYwMGMzYjJkCgkJCWZpCgkJ CWVjaG8JJ0NhcmdhbmRvIFhlbiA0LjMuMS4uLicKCQkgICAgICAgIGlmIFsgIiRncnViX3BsYXRm b3JtIiA9ICJwYyIgLW8gIiRncnViX3BsYXRmb3JtIiA9ICIiIF07IHRoZW4KCQkgICAgICAgICAg ICB4ZW5fcm1fb3B0cz0KCQkgICAgICAgIGVsc2UKCQkgICAgICAgICAgICB4ZW5fcm1fb3B0cz0i bm8tcmVhbC1tb2RlIGVkZD1vZmYiCgkJICAgICAgICBmaQoJCQltdWx0aWJvb3QJL2Jvb3QveGVu LTQuMy4xLmd6IHBsYWNlaG9sZGVyIGRvbTBfbWVtPTUxMiAgJHt4ZW5fcm1fb3B0c30KCQkJZWNo bwknQ2FyZ2FuZG8gTGludXggZG9tMC0zLjEyLjEzLi4uJwoJCQltb2R1bGUJL2Jvb3Qva2VybmVs LWRvbTAtMy4xMi4xMyBwbGFjZWhvbGRlciByb290PS9kZXYvc2RiMiBybyBtYXhfbG9vcD0xMjgg ZGVmYXVsdCBpbml0PS9zYmluL2luaXQKCQl9CgkJbWVudWVudHJ5ICdHZW50b28gR05VL0xpbnV4 LCBjb24gWGVuIDQuMy4xIHkgTGludXggZG9tMC0zLjEyLjEzIChtb2RvIGRlIHJlY3VwZXJhY2nD s24pJyAtLWNsYXNzIGdlbnRvbyAtLWNsYXNzIGdudS1saW51eCAtLWNsYXNzIGdudSAtLWNsYXNz IG9zIC0tY2xhc3MgeGVuICRtZW51ZW50cnlfaWRfb3B0aW9uICd4ZW4tZ251bGludXgtZG9tMC0z LjEyLjEzLXJlY292ZXJ5LWY0NTNmODhkLWEzNTktNGUwZC04NTg2LWUwYzI2MDBjM2IyZCcgewoJ CQlpbnNtb2QgcGFydF9ncHQKCQkJaW5zbW9kIGV4dDIKCQkJc2V0IHJvb3Q9J2hkMSxncHQyJwoJ CQlpZiBbIHgkZmVhdHVyZV9wbGF0Zm9ybV9zZWFyY2hfaGludCA9IHh5IF07IHRoZW4KCQkJICBz ZWFyY2ggLS1uby1mbG9wcHkgLS1mcy11dWlkIC0tc2V0PXJvb3QgLS1oaW50LWJpb3M9aGQxLGdw dDIgLS1oaW50LWVmaT1oZDEsZ3B0MiAtLWhpbnQtYmFyZW1ldGFsPWFoY2kxLGdwdDIgIGY0NTNm ODhkLWEzNTktNGUwZC04NTg2LWUwYzI2MDBjM2IyZAoJCQllbHNlCgkJCSAgc2VhcmNoIC0tbm8t ZmxvcHB5IC0tZnMtdXVpZCAtLXNldD1yb290IGY0NTNmODhkLWEzNTktNGUwZC04NTg2LWUwYzI2 MDBjM2IyZAoJCQlmaQoJCQllY2hvCSdDYXJnYW5kbyBYZW4gNC4zLjEuLi4nCgkJICAgICAgICBp ZiBbICIkZ3J1Yl9wbGF0Zm9ybSIgPSAicGMiIC1vICIkZ3J1Yl9wbGF0Zm9ybSIgPSAiIiBdOyB0 aGVuCgkJICAgICAgICAgICAgeGVuX3JtX29wdHM9CgkJICAgICAgICBlbHNlCgkJICAgICAgICAg ICAgeGVuX3JtX29wdHM9Im5vLXJlYWwtbW9kZSBlZGQ9b2ZmIgoJCSAgICAgICAgZmkKCQkJbXVs dGlib290CS9ib290L3hlbi00LjMuMS5neiBwbGFjZWhvbGRlciBkb20wX21lbT01MTIgJHt4ZW5f cm1fb3B0c30KCQkJZWNobwknQ2FyZ2FuZG8gTGludXggZG9tMC0zLjEyLjEzLi4uJwoJCQltb2R1 bGUJL2Jvb3Qva2VybmVsLWRvbTAtMy4xMi4xMyBwbGFjZWhvbGRlciByb290PS9kZXYvc2RiMiBy byBzaW5nbGUgbWF4X2xvb3A9MTI4CgkJfQoJfQoJc3VibWVudSAnSGlwZXJ2aXNvciBYZW4sIHZl cnNpw7NuIDQuMycgJG1lbnVlbnRyeV9pZF9vcHRpb24gJ3hlbi1oeXBlcnZpc29yLTQuMy1mNDUz Zjg4ZC1hMzU5LTRlMGQtODU4Ni1lMGMyNjAwYzNiMmQnIHsKCQltZW51ZW50cnkgJ0dlbnRvbyBH TlUvTGludXgsIGNvbiBYZW4gNC4zIHkgTGludXggZG9tMC0zLjEyLjEzJyAtLWNsYXNzIGdlbnRv byAtLWNsYXNzIGdudS1saW51eCAtLWNsYXNzIGdudSAtLWNsYXNzIG9zIC0tY2xhc3MgeGVuICRt ZW51ZW50cnlfaWRfb3B0aW9uICd4ZW4tZ251bGludXgtZG9tMC0zLjEyLjEzLWFkdmFuY2VkLWY0 NTNmODhkLWEzNTktNGUwZC04NTg2LWUwYzI2MDBjM2IyZCcgewoJCQlpbnNtb2QgcGFydF9ncHQK CQkJaW5zbW9kIGV4dDIKCQkJc2V0IHJvb3Q9J2hkMSxncHQyJwoJCQlpZiBbIHgkZmVhdHVyZV9w bGF0Zm9ybV9zZWFyY2hfaGludCA9IHh5IF07IHRoZW4KCQkJICBzZWFyY2ggLS1uby1mbG9wcHkg LS1mcy11dWlkIC0tc2V0PXJvb3QgLS1oaW50LWJpb3M9aGQxLGdwdDIgLS1oaW50LWVmaT1oZDEs Z3B0MiAtLWhpbnQtYmFyZW1ldGFsPWFoY2kxLGdwdDIgIGY0NTNmODhkLWEzNTktNGUwZC04NTg2 LWUwYzI2MDBjM2IyZAoJCQllbHNlCgkJCSAgc2VhcmNoIC0tbm8tZmxvcHB5IC0tZnMtdXVpZCAt LXNldD1yb290IGY0NTNmODhkLWEzNTktNGUwZC04NTg2LWUwYzI2MDBjM2IyZAoJCQlmaQoJCQll Y2hvCSdDYXJnYW5kbyBYZW4gNC4zLi4uJwoJCSAgICAgICAgaWYgWyAiJGdydWJfcGxhdGZvcm0i ID0gInBjIiAtbyAiJGdydWJfcGxhdGZvcm0iID0gIiIgXTsgdGhlbgoJCSAgICAgICAgICAgIHhl bl9ybV9vcHRzPQoJCSAgICAgICAgZWxzZQoJCSAgICAgICAgICAgIHhlbl9ybV9vcHRzPSJuby1y ZWFsLW1vZGUgZWRkPW9mZiIKCQkgICAgICAgIGZpCgkJCW11bHRpYm9vdAkvYm9vdC94ZW4tNC4z Lmd6IHBsYWNlaG9sZGVyIGRvbTBfbWVtPTUxMiAgJHt4ZW5fcm1fb3B0c30KCQkJZWNobwknQ2Fy Z2FuZG8gTGludXggZG9tMC0zLjEyLjEzLi4uJwoJCQltb2R1bGUJL2Jvb3Qva2VybmVsLWRvbTAt My4xMi4xMyBwbGFjZWhvbGRlciByb290PS9kZXYvc2RiMiBybyBtYXhfbG9vcD0xMjggZGVmYXVs dCBpbml0PS9zYmluL2luaXQKCQl9CgkJbWVudWVudHJ5ICdHZW50b28gR05VL0xpbnV4LCBjb24g WGVuIDQuMyB5IExpbnV4IGRvbTAtMy4xMi4xMyAobW9kbyBkZSByZWN1cGVyYWNpw7NuKScgLS1j bGFzcyBnZW50b28gLS1jbGFzcyBnbnUtbGludXggLS1jbGFzcyBnbnUgLS1jbGFzcyBvcyAtLWNs YXNzIHhlbiAkbWVudWVudHJ5X2lkX29wdGlvbiAneGVuLWdudWxpbnV4LWRvbTAtMy4xMi4xMy1y ZWNvdmVyeS1mNDUzZjg4ZC1hMzU5LTRlMGQtODU4Ni1lMGMyNjAwYzNiMmQnIHsKCQkJaW5zbW9k IHBhcnRfZ3B0CgkJCWluc21vZCBleHQyCgkJCXNldCByb290PSdoZDEsZ3B0MicKCQkJaWYgWyB4 JGZlYXR1cmVfcGxhdGZvcm1fc2VhcmNoX2hpbnQgPSB4eSBdOyB0aGVuCgkJCSAgc2VhcmNoIC0t bm8tZmxvcHB5IC0tZnMtdXVpZCAtLXNldD1yb290IC0taGludC1iaW9zPWhkMSxncHQyIC0taGlu dC1lZmk9aGQxLGdwdDIgLS1oaW50LWJhcmVtZXRhbD1haGNpMSxncHQyICBmNDUzZjg4ZC1hMzU5 LTRlMGQtODU4Ni1lMGMyNjAwYzNiMmQKCQkJZWxzZQoJCQkgIHNlYXJjaCAtLW5vLWZsb3BweSAt LWZzLXV1aWQgLS1zZXQ9cm9vdCBmNDUzZjg4ZC1hMzU5LTRlMGQtODU4Ni1lMGMyNjAwYzNiMmQK CQkJZmkKCQkJZWNobwknQ2FyZ2FuZG8gWGVuIDQuMy4uLicKCQkgICAgICAgIGlmIFsgIiRncnVi X3BsYXRmb3JtIiA9ICJwYyIgLW8gIiRncnViX3BsYXRmb3JtIiA9ICIiIF07IHRoZW4KCQkgICAg ICAgICAgICB4ZW5fcm1fb3B0cz0KCQkgICAgICAgIGVsc2UKCQkgICAgICAgICAgICB4ZW5fcm1f b3B0cz0ibm8tcmVhbC1tb2RlIGVkZD1vZmYiCgkJICAgICAgICBmaQoJCQltdWx0aWJvb3QJL2Jv b3QveGVuLTQuMy5neiBwbGFjZWhvbGRlciBkb20wX21lbT01MTIgJHt4ZW5fcm1fb3B0c30KCQkJ ZWNobwknQ2FyZ2FuZG8gTGludXggZG9tMC0zLjEyLjEzLi4uJwoJCQltb2R1bGUJL2Jvb3Qva2Vy bmVsLWRvbTAtMy4xMi4xMyBwbGFjZWhvbGRlciByb290PS9kZXYvc2RiMiBybyBzaW5nbGUgbWF4 X2xvb3A9MTI4CgkJfQoJfQoJc3VibWVudSAnSGlwZXJ2aXNvciBYZW4sIHZlcnNpw7NuIDQnICRt ZW51ZW50cnlfaWRfb3B0aW9uICd4ZW4taHlwZXJ2aXNvci00LWY0NTNmODhkLWEzNTktNGUwZC04 NTg2LWUwYzI2MDBjM2IyZCcgewoJCW1lbnVlbnRyeSAnR2VudG9vIEdOVS9MaW51eCwgY29uIFhl biA0IHkgTGludXggZG9tMC0zLjEyLjEzJyAtLWNsYXNzIGdlbnRvbyAtLWNsYXNzIGdudS1saW51 eCAtLWNsYXNzIGdudSAtLWNsYXNzIG9zIC0tY2xhc3MgeGVuICRtZW51ZW50cnlfaWRfb3B0aW9u ICd4ZW4tZ251bGludXgtZG9tMC0zLjEyLjEzLWFkdmFuY2VkLWY0NTNmODhkLWEzNTktNGUwZC04 NTg2LWUwYzI2MDBjM2IyZCcgewoJCQlpbnNtb2QgcGFydF9ncHQKCQkJaW5zbW9kIGV4dDIKCQkJ c2V0IHJvb3Q9J2hkMSxncHQyJwoJCQlpZiBbIHgkZmVhdHVyZV9wbGF0Zm9ybV9zZWFyY2hfaGlu dCA9IHh5IF07IHRoZW4KCQkJICBzZWFyY2ggLS1uby1mbG9wcHkgLS1mcy11dWlkIC0tc2V0PXJv b3QgLS1oaW50LWJpb3M9aGQxLGdwdDIgLS1oaW50LWVmaT1oZDEsZ3B0MiAtLWhpbnQtYmFyZW1l dGFsPWFoY2kxLGdwdDIgIGY0NTNmODhkLWEzNTktNGUwZC04NTg2LWUwYzI2MDBjM2IyZAoJCQll bHNlCgkJCSAgc2VhcmNoIC0tbm8tZmxvcHB5IC0tZnMtdXVpZCAtLXNldD1yb290IGY0NTNmODhk LWEzNTktNGUwZC04NTg2LWUwYzI2MDBjM2IyZAoJCQlmaQoJCQllY2hvCSdDYXJnYW5kbyBYZW4g NC4uLicKCQkgICAgICAgIGlmIFsgIiRncnViX3BsYXRmb3JtIiA9ICJwYyIgLW8gIiRncnViX3Bs YXRmb3JtIiA9ICIiIF07IHRoZW4KCQkgICAgICAgICAgICB4ZW5fcm1fb3B0cz0KCQkgICAgICAg IGVsc2UKCQkgICAgICAgICAgICB4ZW5fcm1fb3B0cz0ibm8tcmVhbC1tb2RlIGVkZD1vZmYiCgkJ ICAgICAgICBmaQoJCQltdWx0aWJvb3QJL2Jvb3QveGVuLTQuZ3ogcGxhY2Vob2xkZXIgZG9tMF9t ZW09NTEyICAke3hlbl9ybV9vcHRzfQoJCQllY2hvCSdDYXJnYW5kbyBMaW51eCBkb20wLTMuMTIu MTMuLi4nCgkJCW1vZHVsZQkvYm9vdC9rZXJuZWwtZG9tMC0zLjEyLjEzIHBsYWNlaG9sZGVyIHJv b3Q9L2Rldi9zZGIyIHJvIG1heF9sb29wPTEyOCBkZWZhdWx0IGluaXQ9L3NiaW4vaW5pdAoJCX0K CQltZW51ZW50cnkgJ0dlbnRvbyBHTlUvTGludXgsIGNvbiBYZW4gNCB5IExpbnV4IGRvbTAtMy4x Mi4xMyAobW9kbyBkZSByZWN1cGVyYWNpw7NuKScgLS1jbGFzcyBnZW50b28gLS1jbGFzcyBnbnUt bGludXggLS1jbGFzcyBnbnUgLS1jbGFzcyBvcyAtLWNsYXNzIHhlbiAkbWVudWVudHJ5X2lkX29w dGlvbiAneGVuLWdudWxpbnV4LWRvbTAtMy4xMi4xMy1yZWNvdmVyeS1mNDUzZjg4ZC1hMzU5LTRl MGQtODU4Ni1lMGMyNjAwYzNiMmQnIHsKCQkJaW5zbW9kIHBhcnRfZ3B0CgkJCWluc21vZCBleHQy CgkJCXNldCByb290PSdoZDEsZ3B0MicKCQkJaWYgWyB4JGZlYXR1cmVfcGxhdGZvcm1fc2VhcmNo X2hpbnQgPSB4eSBdOyB0aGVuCgkJCSAgc2VhcmNoIC0tbm8tZmxvcHB5IC0tZnMtdXVpZCAtLXNl dD1yb290IC0taGludC1iaW9zPWhkMSxncHQyIC0taGludC1lZmk9aGQxLGdwdDIgLS1oaW50LWJh cmVtZXRhbD1haGNpMSxncHQyICBmNDUzZjg4ZC1hMzU5LTRlMGQtODU4Ni1lMGMyNjAwYzNiMmQK CQkJZWxzZQoJCQkgIHNlYXJjaCAtLW5vLWZsb3BweSAtLWZzLXV1aWQgLS1zZXQ9cm9vdCBmNDUz Zjg4ZC1hMzU5LTRlMGQtODU4Ni1lMGMyNjAwYzNiMmQKCQkJZmkKCQkJZWNobwknQ2FyZ2FuZG8g WGVuIDQuLi4nCgkJICAgICAgICBpZiBbICIkZ3J1Yl9wbGF0Zm9ybSIgPSAicGMiIC1vICIkZ3J1 Yl9wbGF0Zm9ybSIgPSAiIiBdOyB0aGVuCgkJICAgICAgICAgICAgeGVuX3JtX29wdHM9CgkJICAg ICAgICBlbHNlCgkJICAgICAgICAgICAgeGVuX3JtX29wdHM9Im5vLXJlYWwtbW9kZSBlZGQ9b2Zm IgoJCSAgICAgICAgZmkKCQkJbXVsdGlib290CS9ib290L3hlbi00Lmd6IHBsYWNlaG9sZGVyIGRv bTBfbWVtPTUxMiAke3hlbl9ybV9vcHRzfQoJCQllY2hvCSdDYXJnYW5kbyBMaW51eCBkb20wLTMu MTIuMTMuLi4nCgkJCW1vZHVsZQkvYm9vdC9rZXJuZWwtZG9tMC0zLjEyLjEzIHBsYWNlaG9sZGVy IHJvb3Q9L2Rldi9zZGIyIHJvIHNpbmdsZSBtYXhfbG9vcD0xMjgKCQl9Cgl9Cn0KCiMjIyBFTkQg L2V0Yy9ncnViLmQvMjBfbGludXhfeGVuICMjIwoKIyMjIEJFR0lOIC9ldGMvZ3J1Yi5kLzMwX29z LXByb2JlciAjIyMKIyMjIEVORCAvZXRjL2dydWIuZC8zMF9vcy1wcm9iZXIgIyMjCgojIyMgQkVH SU4gL2V0Yy9ncnViLmQvNDBfY3VzdG9tICMjIwojIFRoaXMgZmlsZSBwcm92aWRlcyBhbiBlYXN5 IHdheSB0byBhZGQgY3VzdG9tIG1lbnUgZW50cmllcy4gIFNpbXBseSB0eXBlIHRoZQojIG1lbnUg ZW50cmllcyB5b3Ugd2FudCB0byBhZGQgYWZ0ZXIgdGhpcyBjb21tZW50LiAgQmUgY2FyZWZ1bCBu b3QgdG8gY2hhbmdlCiMgdGhlICdleGVjIHRhaWwnIGxpbmUgYWJvdmUuCiMjIyBFTkQgL2V0Yy9n cnViLmQvNDBfY3VzdG9tICMjIwoKIyMjIEJFR0lOIC9ldGMvZ3J1Yi5kLzQxX2N1c3RvbSAjIyMK aWYgWyAtZiAgJHtjb25maWdfZGlyZWN0b3J5fS9jdXN0b20uY2ZnIF07IHRoZW4KICBzb3VyY2Ug JHtjb25maWdfZGlyZWN0b3J5fS9jdXN0b20uY2ZnCmVsaWYgWyAteiAiJHtjb25maWdfZGlyZWN0 b3J5fSIgLWEgLWYgICRwcmVmaXgvY3VzdG9tLmNmZyBdOyB0aGVuCiAgc291cmNlICRwcmVmaXgv Y3VzdG9tLmNmZzsKZmkKIyMjIEVORCAvZXRjL2dydWIuZC80MV9jdXN0b20gIyMjCg== --001a11c2aeda93361b04f5579d4e Content-Type: application/octet-stream; name="config-dom0-3.12.13" Content-Disposition: attachment; filename="config-dom0-3.12.13" Content-Transfer-Encoding: base64 X-Attachment-Id: f_ht5low9d2 IwojIEF1dG9tYXRpY2FsbHkgZ2VuZXJhdGVkIGZpbGU7IERPIE5PVCBFRElULgojIExpbnV4L3g4 NiAzLjEyLjEzLWdlbnRvbyBLZXJuZWwgQ29uZmlndXJhdGlvbgojCgojCiMgR2VudG9vIExpbnV4 CiMKQ09ORklHX0dFTlRPT19MSU5VWD15CkNPTkZJR19HRU5UT09fTElOVVhfVURFVj15CgojCiMg U3VwcG9ydCBmb3IgaW5pdCBzeXN0ZW1zLCBzeXN0ZW0gYW5kIHNlcnZpY2UgbWFuYWdlcnMKIwpD T05GSUdfR0VOVE9PX0xJTlVYX0lOSVRfU0NSSVBUPXkKIyBDT05GSUdfR0VOVE9PX0xJTlVYX0lO SVRfU1lTVEVNRCBpcyBub3Qgc2V0CkNPTkZJR182NEJJVD15CkNPTkZJR19YODZfNjQ9eQpDT05G SUdfWDg2PXkKQ09ORklHX0lOU1RSVUNUSU9OX0RFQ09ERVI9eQpDT05GSUdfT1VUUFVUX0ZPUk1B VD0iZWxmNjQteDg2LTY0IgpDT05GSUdfQVJDSF9ERUZDT05GSUc9ImFyY2gveDg2L2NvbmZpZ3Mv eDg2XzY0X2RlZmNvbmZpZyIKQ09ORklHX0xPQ0tERVBfU1VQUE9SVD15CkNPTkZJR19TVEFDS1RS QUNFX1NVUFBPUlQ9eQpDT05GSUdfSEFWRV9MQVRFTkNZVE9QX1NVUFBPUlQ9eQpDT05GSUdfTU1V PXkKQ09ORklHX05FRURfRE1BX01BUF9TVEFURT15CkNPTkZJR19ORUVEX1NHX0RNQV9MRU5HVEg9 eQpDT05GSUdfR0VORVJJQ19JU0FfRE1BPXkKQ09ORklHX0dFTkVSSUNfQlVHPXkKQ09ORklHX0dF TkVSSUNfQlVHX1JFTEFUSVZFX1BPSU5URVJTPXkKQ09ORklHX0dFTkVSSUNfSFdFSUdIVD15CkNP TkZJR19BUkNIX01BWV9IQVZFX1BDX0ZEQz15CkNPTkZJR19SV1NFTV9YQ0hHQUREX0FMR09SSVRI TT15CkNPTkZJR19HRU5FUklDX0NBTElCUkFURV9ERUxBWT15CkNPTkZJR19BUkNIX0hBU19DUFVf UkVMQVg9eQpDT05GSUdfQVJDSF9IQVNfQ0FDSEVfTElORV9TSVpFPXkKQ09ORklHX0FSQ0hfSEFT X0NQVV9BVVRPUFJPQkU9eQpDT05GSUdfSEFWRV9TRVRVUF9QRVJfQ1BVX0FSRUE9eQpDT05GSUdf TkVFRF9QRVJfQ1BVX0VNQkVEX0ZJUlNUX0NIVU5LPXkKQ09ORklHX05FRURfUEVSX0NQVV9QQUdF X0ZJUlNUX0NIVU5LPXkKQ09ORklHX0FSQ0hfSElCRVJOQVRJT05fUE9TU0lCTEU9eQpDT05GSUdf QVJDSF9TVVNQRU5EX1BPU1NJQkxFPXkKQ09ORklHX0FSQ0hfV0FOVF9IVUdFX1BNRF9TSEFSRT15 CkNPTkZJR19BUkNIX1dBTlRfR0VORVJBTF9IVUdFVExCPXkKQ09ORklHX1pPTkVfRE1BMzI9eQpD T05GSUdfQVVESVRfQVJDSD15CkNPTkZJR19BUkNIX1NVUFBPUlRTX09QVElNSVpFRF9JTkxJTklO Rz15CkNPTkZJR19BUkNIX1NVUFBPUlRTX0RFQlVHX1BBR0VBTExPQz15CkNPTkZJR19YODZfNjRf U01QPXkKQ09ORklHX1g4Nl9IVD15CkNPTkZJR19BUkNIX0hXRUlHSFRfQ0ZMQUdTPSItZmNhbGwt c2F2ZWQtcmRpIC1mY2FsbC1zYXZlZC1yc2kgLWZjYWxsLXNhdmVkLXJkeCAtZmNhbGwtc2F2ZWQt cmN4IC1mY2FsbC1zYXZlZC1yOCAtZmNhbGwtc2F2ZWQtcjkgLWZjYWxsLXNhdmVkLXIxMCAtZmNh bGwtc2F2ZWQtcjExIgpDT05GSUdfQVJDSF9DUFVfUFJPQkVfUkVMRUFTRT15CkNPTkZJR19BUkNI X1NVUFBPUlRTX1VQUk9CRVM9eQpDT05GSUdfREVGQ09ORklHX0xJU1Q9Ii9saWIvbW9kdWxlcy8k VU5BTUVfUkVMRUFTRS8uY29uZmlnIgpDT05GSUdfSVJRX1dPUks9eQpDT05GSUdfQlVJTERUSU1F X0VYVEFCTEVfU09SVD15CgojCiMgR2VuZXJhbCBzZXR1cAojCkNPTkZJR19JTklUX0VOVl9BUkdf TElNSVQ9MzIKQ09ORklHX0NST1NTX0NPTVBJTEU9IiIKIyBDT05GSUdfQ09NUElMRV9URVNUIGlz IG5vdCBzZXQKQ09ORklHX0xPQ0FMVkVSU0lPTj0iIgojIENPTkZJR19MT0NBTFZFUlNJT05fQVVU TyBpcyBub3Qgc2V0CkNPTkZJR19IQVZFX0tFUk5FTF9HWklQPXkKQ09ORklHX0hBVkVfS0VSTkVM X0JaSVAyPXkKQ09ORklHX0hBVkVfS0VSTkVMX0xaTUE9eQpDT05GSUdfSEFWRV9LRVJORUxfWFo9 eQpDT05GSUdfSEFWRV9LRVJORUxfTFpPPXkKQ09ORklHX0hBVkVfS0VSTkVMX0xaND15CiMgQ09O RklHX0tFUk5FTF9HWklQIGlzIG5vdCBzZXQKIyBDT05GSUdfS0VSTkVMX0JaSVAyIGlzIG5vdCBz ZXQKIyBDT05GSUdfS0VSTkVMX0xaTUEgaXMgbm90IHNldAojIENPTkZJR19LRVJORUxfWFogaXMg bm90IHNldAojIENPTkZJR19LRVJORUxfTFpPIGlzIG5vdCBzZXQKQ09ORklHX0tFUk5FTF9MWjQ9 eQpDT05GSUdfREVGQVVMVF9IT1NUTkFNRT0iKG5vbmUpIgpDT05GSUdfU1dBUD15CkNPTkZJR19T WVNWSVBDPXkKQ09ORklHX1NZU1ZJUENfU1lTQ1RMPXkKQ09ORklHX1BPU0lYX01RVUVVRT15CkNP TkZJR19QT1NJWF9NUVVFVUVfU1lTQ1RMPXkKQ09ORklHX0ZIQU5ETEU9eQojIENPTkZJR19BVURJ VCBpcyBub3Qgc2V0CgojCiMgSVJRIHN1YnN5c3RlbQojCkNPTkZJR19HRU5FUklDX0lSUV9QUk9C RT15CkNPTkZJR19HRU5FUklDX0lSUV9TSE9XPXkKQ09ORklHX0dFTkVSSUNfUEVORElOR19JUlE9 eQpDT05GSUdfSVJRX0ZPUkNFRF9USFJFQURJTkc9eQpDT05GSUdfU1BBUlNFX0lSUT15CkNPTkZJ R19DTE9DS1NPVVJDRV9XQVRDSERPRz15CkNPTkZJR19BUkNIX0NMT0NLU09VUkNFX0RBVEE9eQpD T05GSUdfR0VORVJJQ19USU1FX1ZTWVNDQUxMPXkKQ09ORklHX0dFTkVSSUNfQ0xPQ0tFVkVOVFM9 eQpDT05GSUdfR0VORVJJQ19DTE9DS0VWRU5UU19CVUlMRD15CkNPTkZJR19HRU5FUklDX0NMT0NL RVZFTlRTX0JST0FEQ0FTVD15CkNPTkZJR19HRU5FUklDX0NMT0NLRVZFTlRTX01JTl9BREpVU1Q9 eQpDT05GSUdfR0VORVJJQ19DTU9TX1VQREFURT15CgojCiMgVGltZXJzIHN1YnN5c3RlbQojCkNP TkZJR19USUNLX09ORVNIT1Q9eQpDT05GSUdfSFpfUEVSSU9ESUM9eQojIENPTkZJR19OT19IWl9J RExFIGlzIG5vdCBzZXQKIyBDT05GSUdfTk9fSFpfRlVMTCBpcyBub3Qgc2V0CkNPTkZJR19OT19I Wj15CkNPTkZJR19ISUdIX1JFU19USU1FUlM9eQoKIwojIENQVS9UYXNrIHRpbWUgYW5kIHN0YXRz IGFjY291bnRpbmcKIwpDT05GSUdfVElDS19DUFVfQUNDT1VOVElORz15CiMgQ09ORklHX1ZJUlRf Q1BVX0FDQ09VTlRJTkdfR0VOIGlzIG5vdCBzZXQKIyBDT05GSUdfSVJRX1RJTUVfQUNDT1VOVElO RyBpcyBub3Qgc2V0CkNPTkZJR19CU0RfUFJPQ0VTU19BQ0NUPXkKQ09ORklHX0JTRF9QUk9DRVNT X0FDQ1RfVjM9eQpDT05GSUdfVEFTS1NUQVRTPXkKQ09ORklHX1RBU0tfREVMQVlfQUNDVD15CiMg Q09ORklHX1RBU0tfWEFDQ1QgaXMgbm90IHNldAoKIwojIFJDVSBTdWJzeXN0ZW0KIwpDT05GSUdf VFJFRV9QUkVFTVBUX1JDVT15CkNPTkZJR19QUkVFTVBUX1JDVT15CkNPTkZJR19SQ1VfU1RBTExf Q09NTU9OPXkKIyBDT05GSUdfUkNVX1VTRVJfUVMgaXMgbm90IHNldApDT05GSUdfUkNVX0ZBTk9V VD02NApDT05GSUdfUkNVX0ZBTk9VVF9MRUFGPTE2CiMgQ09ORklHX1JDVV9GQU5PVVRfRVhBQ1Qg aXMgbm90IHNldAojIENPTkZJR19UUkVFX1JDVV9UUkFDRSBpcyBub3Qgc2V0CiMgQ09ORklHX1JD VV9CT09TVCBpcyBub3Qgc2V0CiMgQ09ORklHX1JDVV9OT0NCX0NQVSBpcyBub3Qgc2V0CkNPTkZJ R19JS0NPTkZJRz1tCkNPTkZJR19JS0NPTkZJR19QUk9DPXkKQ09ORklHX0xPR19CVUZfU0hJRlQ9 MTMKQ09ORklHX0hBVkVfVU5TVEFCTEVfU0NIRURfQ0xPQ0s9eQpDT05GSUdfQVJDSF9TVVBQT1JU U19OVU1BX0JBTEFOQ0lORz15CkNPTkZJR19BUkNIX1dBTlRTX1BST1RfTlVNQV9QUk9UX05PTkU9 eQpDT05GSUdfQ0dST1VQUz15CiMgQ09ORklHX0NHUk9VUF9ERUJVRyBpcyBub3Qgc2V0CiMgQ09O RklHX0NHUk9VUF9GUkVFWkVSIGlzIG5vdCBzZXQKIyBDT05GSUdfQ0dST1VQX0RFVklDRSBpcyBu b3Qgc2V0CkNPTkZJR19DUFVTRVRTPXkKQ09ORklHX1BST0NfUElEX0NQVVNFVD15CkNPTkZJR19D R1JPVVBfQ1BVQUNDVD15CiMgQ09ORklHX1JFU09VUkNFX0NPVU5URVJTIGlzIG5vdCBzZXQKIyBD T05GSUdfQ0dST1VQX1BFUkYgaXMgbm90IHNldAojIENPTkZJR19DR1JPVVBfU0NIRUQgaXMgbm90 IHNldAojIENPTkZJR19CTEtfQ0dST1VQIGlzIG5vdCBzZXQKIyBDT05GSUdfQ0hFQ0tQT0lOVF9S RVNUT1JFIGlzIG5vdCBzZXQKQ09ORklHX05BTUVTUEFDRVM9eQpDT05GSUdfVVRTX05TPXkKQ09O RklHX0lQQ19OUz15CiMgQ09ORklHX1VTRVJfTlMgaXMgbm90IHNldApDT05GSUdfUElEX05TPXkK Q09ORklHX05FVF9OUz15CiMgQ09ORklHX1VJREdJRF9TVFJJQ1RfVFlQRV9DSEVDS1MgaXMgbm90 IHNldAojIENPTkZJR19TQ0hFRF9BVVRPR1JPVVAgaXMgbm90IHNldAojIENPTkZJR19TWVNGU19E RVBSRUNBVEVEIGlzIG5vdCBzZXQKIyBDT05GSUdfUkVMQVkgaXMgbm90IHNldApDT05GSUdfQkxL X0RFVl9JTklUUkQ9eQpDT05GSUdfSU5JVFJBTUZTX1NPVVJDRT0iIgpDT05GSUdfUkRfR1pJUD15 CkNPTkZJR19SRF9CWklQMj15CkNPTkZJR19SRF9MWk1BPXkKQ09ORklHX1JEX1haPXkKQ09ORklH X1JEX0xaTz15CkNPTkZJR19SRF9MWjQ9eQpDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkU9eQpD T05GSUdfU1lTQ1RMPXkKQ09ORklHX0FOT05fSU5PREVTPXkKQ09ORklHX0hBVkVfVUlEMTY9eQpD T05GSUdfU1lTQ1RMX0VYQ0VQVElPTl9UUkFDRT15CkNPTkZJR19IQVZFX1BDU1BLUl9QTEFURk9S TT15CiMgQ09ORklHX0VYUEVSVCBpcyBub3Qgc2V0CkNPTkZJR19VSUQxNj15CiMgQ09ORklHX1NZ U0NUTF9TWVNDQUxMIGlzIG5vdCBzZXQKQ09ORklHX0tBTExTWU1TPXkKIyBDT05GSUdfS0FMTFNZ TVNfQUxMIGlzIG5vdCBzZXQKQ09ORklHX1BSSU5USz15CkNPTkZJR19CVUc9eQpDT05GSUdfRUxG X0NPUkU9eQpDT05GSUdfUENTUEtSX1BMQVRGT1JNPXkKQ09ORklHX0JBU0VfRlVMTD15CkNPTkZJ R19GVVRFWD15CkNPTkZJR19FUE9MTD15CkNPTkZJR19TSUdOQUxGRD15CkNPTkZJR19USU1FUkZE PXkKQ09ORklHX0VWRU5URkQ9eQpDT05GSUdfU0hNRU09eQpDT05GSUdfQUlPPXkKQ09ORklHX1BD SV9RVUlSS1M9eQojIENPTkZJR19FTUJFRERFRCBpcyBub3Qgc2V0CkNPTkZJR19IQVZFX1BFUkZf RVZFTlRTPXkKCiMKIyBLZXJuZWwgUGVyZm9ybWFuY2UgRXZlbnRzIEFuZCBDb3VudGVycwojCkNP TkZJR19QRVJGX0VWRU5UUz15CiMgQ09ORklHX0RFQlVHX1BFUkZfVVNFX1ZNQUxMT0MgaXMgbm90 IHNldApDT05GSUdfVk1fRVZFTlRfQ09VTlRFUlM9eQpDT05GSUdfQ09NUEFUX0JSSz15CkNPTkZJ R19TTEFCPXkKIyBDT05GSUdfU0xVQiBpcyBub3Qgc2V0CkNPTkZJR19QUk9GSUxJTkc9eQojIENP TkZJR19PUFJPRklMRSBpcyBub3Qgc2V0CkNPTkZJR19IQVZFX09QUk9GSUxFPXkKQ09ORklHX09Q Uk9GSUxFX05NSV9USU1FUj15CiMgQ09ORklHX0tQUk9CRVMgaXMgbm90IHNldApDT05GSUdfSlVN UF9MQUJFTD15CiMgQ09ORklHX0hBVkVfNjRCSVRfQUxJR05FRF9BQ0NFU1MgaXMgbm90IHNldApD T05GSUdfSEFWRV9FRkZJQ0lFTlRfVU5BTElHTkVEX0FDQ0VTUz15CkNPTkZJR19BUkNIX1VTRV9C VUlMVElOX0JTV0FQPXkKQ09ORklHX0hBVkVfSU9SRU1BUF9QUk9UPXkKQ09ORklHX0hBVkVfS1BS T0JFUz15CkNPTkZJR19IQVZFX0tSRVRQUk9CRVM9eQpDT05GSUdfSEFWRV9PUFRQUk9CRVM9eQpD T05GSUdfSEFWRV9LUFJPQkVTX09OX0ZUUkFDRT15CkNPTkZJR19IQVZFX0FSQ0hfVFJBQ0VIT09L PXkKQ09ORklHX0hBVkVfRE1BX0FUVFJTPXkKQ09ORklHX1VTRV9HRU5FUklDX1NNUF9IRUxQRVJT PXkKQ09ORklHX0dFTkVSSUNfU01QX0lETEVfVEhSRUFEPXkKQ09ORklHX0hBVkVfUkVHU19BTkRf U1RBQ0tfQUNDRVNTX0FQST15CkNPTkZJR19IQVZFX0NMSz15CkNPTkZJR19IQVZFX0RNQV9BUElf REVCVUc9eQpDT05GSUdfSEFWRV9IV19CUkVBS1BPSU5UPXkKQ09ORklHX0hBVkVfTUlYRURfQlJF QUtQT0lOVFNfUkVHUz15CkNPTkZJR19IQVZFX1VTRVJfUkVUVVJOX05PVElGSUVSPXkKQ09ORklH X0hBVkVfUEVSRl9FVkVOVFNfTk1JPXkKQ09ORklHX0hBVkVfUEVSRl9SRUdTPXkKQ09ORklHX0hB VkVfUEVSRl9VU0VSX1NUQUNLX0RVTVA9eQpDT05GSUdfSEFWRV9BUkNIX0pVTVBfTEFCRUw9eQpD T05GSUdfQVJDSF9IQVZFX05NSV9TQUZFX0NNUFhDSEc9eQpDT05GSUdfSEFWRV9DTVBYQ0hHX0xP Q0FMPXkKQ09ORklHX0hBVkVfQ01QWENIR19ET1VCTEU9eQpDT05GSUdfQVJDSF9XQU5UX0NPTVBB VF9JUENfUEFSU0VfVkVSU0lPTj15CkNPTkZJR19BUkNIX1dBTlRfT0xEX0NPTVBBVF9JUEM9eQpD T05GSUdfSEFWRV9BUkNIX1NFQ0NPTVBfRklMVEVSPXkKQ09ORklHX1NFQ0NPTVBfRklMVEVSPXkK Q09ORklHX0hBVkVfQ09OVEVYVF9UUkFDS0lORz15CkNPTkZJR19IQVZFX0lSUV9USU1FX0FDQ09V TlRJTkc9eQpDT05GSUdfSEFWRV9BUkNIX1RSQU5TUEFSRU5UX0hVR0VQQUdFPXkKQ09ORklHX0hB VkVfQVJDSF9TT0ZUX0RJUlRZPXkKQ09ORklHX01PRFVMRVNfVVNFX0VMRl9SRUxBPXkKQ09ORklH X09MRF9TSUdTVVNQRU5EMz15CkNPTkZJR19DT01QQVRfT0xEX1NJR0FDVElPTj15CgojCiMgR0NP Vi1iYXNlZCBrZXJuZWwgcHJvZmlsaW5nCiMKIyBDT05GSUdfSEFWRV9HRU5FUklDX0RNQV9DT0hF UkVOVCBpcyBub3Qgc2V0CkNPTkZJR19TTEFCSU5GTz15CkNPTkZJR19SVF9NVVRFWEVTPXkKQ09O RklHX0JBU0VfU01BTEw9MApDT05GSUdfTU9EVUxFUz15CiMgQ09ORklHX01PRFVMRV9GT1JDRV9M T0FEIGlzIG5vdCBzZXQKQ09ORklHX01PRFVMRV9VTkxPQUQ9eQpDT05GSUdfTU9EVUxFX0ZPUkNF X1VOTE9BRD15CkNPTkZJR19NT0RWRVJTSU9OUz15CiMgQ09ORklHX01PRFVMRV9TUkNWRVJTSU9O X0FMTCBpcyBub3Qgc2V0CiMgQ09ORklHX01PRFVMRV9TSUcgaXMgbm90IHNldApDT05GSUdfU1RP UF9NQUNISU5FPXkKQ09ORklHX0JMT0NLPXkKQ09ORklHX0JMS19ERVZfQlNHPXkKQ09ORklHX0JM S19ERVZfQlNHTElCPXkKIyBDT05GSUdfQkxLX0RFVl9JTlRFR1JJVFkgaXMgbm90IHNldAojIENP TkZJR19CTEtfQ01ETElORV9QQVJTRVIgaXMgbm90IHNldAoKIwojIFBhcnRpdGlvbiBUeXBlcwoj CkNPTkZJR19QQVJUSVRJT05fQURWQU5DRUQ9eQojIENPTkZJR19BQ09STl9QQVJUSVRJT04gaXMg bm90IHNldAojIENPTkZJR19BSVhfUEFSVElUSU9OIGlzIG5vdCBzZXQKIyBDT05GSUdfT1NGX1BB UlRJVElPTiBpcyBub3Qgc2V0CiMgQ09ORklHX0FNSUdBX1BBUlRJVElPTiBpcyBub3Qgc2V0CiMg Q09ORklHX0FUQVJJX1BBUlRJVElPTiBpcyBub3Qgc2V0CiMgQ09ORklHX01BQ19QQVJUSVRJT04g aXMgbm90IHNldApDT05GSUdfTVNET1NfUEFSVElUSU9OPXkKIyBDT05GSUdfQlNEX0RJU0tMQUJF TCBpcyBub3Qgc2V0CiMgQ09ORklHX01JTklYX1NVQlBBUlRJVElPTiBpcyBub3Qgc2V0CiMgQ09O RklHX1NPTEFSSVNfWDg2X1BBUlRJVElPTiBpcyBub3Qgc2V0CiMgQ09ORklHX1VOSVhXQVJFX0RJ U0tMQUJFTCBpcyBub3Qgc2V0CkNPTkZJR19MRE1fUEFSVElUSU9OPXkKIyBDT05GSUdfTERNX0RF QlVHIGlzIG5vdCBzZXQKQ09ORklHX1NHSV9QQVJUSVRJT049eQojIENPTkZJR19VTFRSSVhfUEFS VElUSU9OIGlzIG5vdCBzZXQKIyBDT05GSUdfU1VOX1BBUlRJVElPTiBpcyBub3Qgc2V0CiMgQ09O RklHX0tBUk1BX1BBUlRJVElPTiBpcyBub3Qgc2V0CkNPTkZJR19FRklfUEFSVElUSU9OPXkKIyBD T05GSUdfU1lTVjY4X1BBUlRJVElPTiBpcyBub3Qgc2V0CiMgQ09ORklHX0NNRExJTkVfUEFSVElU SU9OIGlzIG5vdCBzZXQKQ09ORklHX0JMT0NLX0NPTVBBVD15CgojCiMgSU8gU2NoZWR1bGVycwoj CkNPTkZJR19JT1NDSEVEX05PT1A9eQpDT05GSUdfSU9TQ0hFRF9ERUFETElORT15CkNPTkZJR19J T1NDSEVEX0NGUT15CiMgQ09ORklHX0RFRkFVTFRfREVBRExJTkUgaXMgbm90IHNldApDT05GSUdf REVGQVVMVF9DRlE9eQojIENPTkZJR19ERUZBVUxUX05PT1AgaXMgbm90IHNldApDT05GSUdfREVG QVVMVF9JT1NDSEVEPSJjZnEiCkNPTkZJR19VTklOTElORV9TUElOX1VOTE9DSz15CkNPTkZJR19N VVRFWF9TUElOX09OX09XTkVSPXkKQ09ORklHX0ZSRUVaRVI9eQoKIwojIFByb2Nlc3NvciB0eXBl IGFuZCBmZWF0dXJlcwojCkNPTkZJR19aT05FX0RNQT15CkNPTkZJR19TTVA9eQojIENPTkZJR19Y ODZfTVBQQVJTRSBpcyBub3Qgc2V0CiMgQ09ORklHX1g4Nl9FWFRFTkRFRF9QTEFURk9STSBpcyBu b3Qgc2V0CkNPTkZJR19YODZfSU5URUxfTFBTUz15CkNPTkZJR19YODZfU1VQUE9SVFNfTUVNT1JZ X0ZBSUxVUkU9eQpDT05GSUdfU0NIRURfT01JVF9GUkFNRV9QT0lOVEVSPXkKQ09ORklHX0hZUEVS VklTT1JfR1VFU1Q9eQpDT05GSUdfUEFSQVZJUlQ9eQojIENPTkZJR19QQVJBVklSVF9ERUJVRyBp cyBub3Qgc2V0CiMgQ09ORklHX1BBUkFWSVJUX1NQSU5MT0NLUyBpcyBub3Qgc2V0CkNPTkZJR19Y RU49eQpDT05GSUdfWEVOX0RPTTA9eQpDT05GSUdfWEVOX1BSSVZJTEVHRURfR1VFU1Q9eQpDT05G SUdfWEVOX1BWSFZNPXkKQ09ORklHX1hFTl9NQVhfRE9NQUlOX01FTU9SWT01MDAKQ09ORklHX1hF Tl9TQVZFX1JFU1RPUkU9eQojIENPTkZJR19LVk1fR1VFU1QgaXMgbm90IHNldAojIENPTkZJR19Q QVJBVklSVF9USU1FX0FDQ09VTlRJTkcgaXMgbm90IHNldApDT05GSUdfUEFSQVZJUlRfQ0xPQ0s9 eQpDT05GSUdfTk9fQk9PVE1FTT15CiMgQ09ORklHX01FTVRFU1QgaXMgbm90IHNldAojIENPTkZJ R19NSzggaXMgbm90IHNldAojIENPTkZJR19NUFNDIGlzIG5vdCBzZXQKQ09ORklHX01DT1JFMj15 CiMgQ09ORklHX01BVE9NIGlzIG5vdCBzZXQKIyBDT05GSUdfR0VORVJJQ19DUFUgaXMgbm90IHNl dApDT05GSUdfWDg2X0lOVEVSTk9ERV9DQUNIRV9TSElGVD02CkNPTkZJR19YODZfTDFfQ0FDSEVf U0hJRlQ9NgpDT05GSUdfWDg2X0lOVEVMX1VTRVJDT1BZPXkKQ09ORklHX1g4Nl9VU0VfUFBST19D SEVDS1NVTT15CkNPTkZJR19YODZfUDZfTk9QPXkKQ09ORklHX1g4Nl9UU0M9eQpDT05GSUdfWDg2 X0NNUFhDSEc2ND15CkNPTkZJR19YODZfQ01PVj15CkNPTkZJR19YODZfTUlOSU1VTV9DUFVfRkFN SUxZPTY0CkNPTkZJR19YODZfREVCVUdDVExNU1I9eQpDT05GSUdfQ1BVX1NVUF9JTlRFTD15CkNP TkZJR19DUFVfU1VQX0FNRD15CkNPTkZJR19DUFVfU1VQX0NFTlRBVVI9eQpDT05GSUdfSFBFVF9U SU1FUj15CkNPTkZJR19IUEVUX0VNVUxBVEVfUlRDPXkKQ09ORklHX0RNST15CkNPTkZJR19HQVJU X0lPTU1VPXkKQ09ORklHX0NBTEdBUllfSU9NTVU9eQpDT05GSUdfQ0FMR0FSWV9JT01NVV9FTkFC TEVEX0JZX0RFRkFVTFQ9eQpDT05GSUdfU1dJT1RMQj15CkNPTkZJR19JT01NVV9IRUxQRVI9eQpD T05GSUdfTUFYU01QPXkKQ09ORklHX05SX0NQVVM9NDA5NgpDT05GSUdfU0NIRURfU01UPXkKQ09O RklHX1NDSEVEX01DPXkKIyBDT05GSUdfUFJFRU1QVF9OT05FIGlzIG5vdCBzZXQKIyBDT05GSUdf UFJFRU1QVF9WT0xVTlRBUlkgaXMgbm90IHNldApDT05GSUdfUFJFRU1QVD15CkNPTkZJR19QUkVF TVBUX0NPVU5UPXkKQ09ORklHX1g4Nl9MT0NBTF9BUElDPXkKQ09ORklHX1g4Nl9JT19BUElDPXkK IyBDT05GSUdfWDg2X1JFUk9VVEVfRk9SX0JST0tFTl9CT09UX0lSUVMgaXMgbm90IHNldApDT05G SUdfWDg2X01DRT15CkNPTkZJR19YODZfTUNFX0lOVEVMPXkKIyBDT05GSUdfWDg2X01DRV9BTUQg aXMgbm90IHNldApDT05GSUdfWDg2X01DRV9USFJFU0hPTEQ9eQojIENPTkZJR19YODZfTUNFX0lO SkVDVCBpcyBub3Qgc2V0CkNPTkZJR19YODZfVEhFUk1BTF9WRUNUT1I9eQojIENPTkZJR19JOEsg aXMgbm90IHNldApDT05GSUdfTUlDUk9DT0RFPXkKQ09ORklHX01JQ1JPQ09ERV9JTlRFTD15CiMg Q09ORklHX01JQ1JPQ09ERV9BTUQgaXMgbm90IHNldApDT05GSUdfTUlDUk9DT0RFX09MRF9JTlRF UkZBQ0U9eQpDT05GSUdfTUlDUk9DT0RFX0lOVEVMX0xJQj15CkNPTkZJR19NSUNST0NPREVfSU5U RUxfRUFSTFk9eQojIENPTkZJR19NSUNST0NPREVfQU1EX0VBUkxZIGlzIG5vdCBzZXQKQ09ORklH X01JQ1JPQ09ERV9FQVJMWT15CkNPTkZJR19YODZfTVNSPXkKQ09ORklHX1g4Nl9DUFVJRD15CkNP TkZJR19BUkNIX1BIWVNfQUREUl9UXzY0QklUPXkKQ09ORklHX0FSQ0hfRE1BX0FERFJfVF82NEJJ VD15CkNPTkZJR19ESVJFQ1RfR0JQQUdFUz15CiMgQ09ORklHX05VTUEgaXMgbm90IHNldApDT05G SUdfQVJDSF9TUEFSU0VNRU1fRU5BQkxFPXkKQ09ORklHX0FSQ0hfU1BBUlNFTUVNX0RFRkFVTFQ9 eQpDT05GSUdfQVJDSF9TRUxFQ1RfTUVNT1JZX01PREVMPXkKQ09ORklHX0FSQ0hfUFJPQ19LQ09S RV9URVhUPXkKQ09ORklHX0lMTEVHQUxfUE9JTlRFUl9WQUxVRT0weGRlYWQwMDAwMDAwMDAwMDAK Q09ORklHX1NFTEVDVF9NRU1PUllfTU9ERUw9eQpDT05GSUdfU1BBUlNFTUVNX01BTlVBTD15CkNP TkZJR19TUEFSU0VNRU09eQpDT05GSUdfSEFWRV9NRU1PUllfUFJFU0VOVD15CkNPTkZJR19TUEFS U0VNRU1fRVhUUkVNRT15CkNPTkZJR19TUEFSU0VNRU1fVk1FTU1BUF9FTkFCTEU9eQpDT05GSUdf U1BBUlNFTUVNX0FMTE9DX01FTV9NQVBfVE9HRVRIRVI9eQpDT05GSUdfU1BBUlNFTUVNX1ZNRU1N QVA9eQpDT05GSUdfSEFWRV9NRU1CTE9DSz15CkNPTkZJR19IQVZFX01FTUJMT0NLX05PREVfTUFQ PXkKQ09ORklHX0FSQ0hfRElTQ0FSRF9NRU1CTE9DSz15CiMgQ09ORklHX0hBVkVfQk9PVE1FTV9J TkZPX05PREUgaXMgbm90IHNldAojIENPTkZJR19NRU1PUllfSE9UUExVRyBpcyBub3Qgc2V0CkNP TkZJR19QQUdFRkxBR1NfRVhURU5ERUQ9eQpDT05GSUdfU1BMSVRfUFRMT0NLX0NQVVM9NApDT05G SUdfQ09NUEFDVElPTj15CkNPTkZJR19NSUdSQVRJT049eQpDT05GSUdfUEhZU19BRERSX1RfNjRC SVQ9eQpDT05GSUdfWk9ORV9ETUFfRkxBRz0xCkNPTkZJR19CT1VOQ0U9eQpDT05GSUdfVklSVF9U T19CVVM9eQpDT05GSUdfTU1VX05PVElGSUVSPXkKIyBDT05GSUdfS1NNIGlzIG5vdCBzZXQKQ09O RklHX0RFRkFVTFRfTU1BUF9NSU5fQUREUj02NTUzNgpDT05GSUdfQVJDSF9TVVBQT1JUU19NRU1P UllfRkFJTFVSRT15CiMgQ09ORklHX01FTU9SWV9GQUlMVVJFIGlzIG5vdCBzZXQKIyBDT05GSUdf VFJBTlNQQVJFTlRfSFVHRVBBR0UgaXMgbm90IHNldApDT05GSUdfQ1JPU1NfTUVNT1JZX0FUVEFD SD15CkNPTkZJR19DTEVBTkNBQ0hFPXkKQ09ORklHX0ZST05UU1dBUD15CiMgQ09ORklHX0NNQSBp cyBub3Qgc2V0CkNPTkZJR19aQlVEPXkKQ09ORklHX1pTV0FQPXkKIyBDT05GSUdfWDg2X0NIRUNL X0JJT1NfQ09SUlVQVElPTiBpcyBub3Qgc2V0CkNPTkZJR19YODZfUkVTRVJWRV9MT1c9NjQKQ09O RklHX01UUlI9eQojIENPTkZJR19NVFJSX1NBTklUSVpFUiBpcyBub3Qgc2V0CkNPTkZJR19YODZf UEFUPXkKQ09ORklHX0FSQ0hfVVNFU19QR19VTkNBQ0hFRD15CkNPTkZJR19BUkNIX1JBTkRPTT15 CkNPTkZJR19YODZfU01BUD15CkNPTkZJR19FRkk9eQpDT05GSUdfRUZJX1NUVUI9eQpDT05GSUdf U0VDQ09NUD15CkNPTkZJR19DQ19TVEFDS1BST1RFQ1RPUj15CiMgQ09ORklHX0haXzEwMCBpcyBu b3Qgc2V0CiMgQ09ORklHX0haXzI1MCBpcyBub3Qgc2V0CiMgQ09ORklHX0haXzMwMCBpcyBub3Qg c2V0CkNPTkZJR19IWl8xMDAwPXkKQ09ORklHX0haPTEwMDAKQ09ORklHX1NDSEVEX0hSVElDSz15 CiMgQ09ORklHX0tFWEVDIGlzIG5vdCBzZXQKIyBDT05GSUdfQ1JBU0hfRFVNUCBpcyBub3Qgc2V0 CkNPTkZJR19QSFlTSUNBTF9TVEFSVD0weDEwMDAwMDAKIyBDT05GSUdfUkVMT0NBVEFCTEUgaXMg bm90IHNldApDT05GSUdfUEhZU0lDQUxfQUxJR049MHgxMDAwMDAwCkNPTkZJR19IT1RQTFVHX0NQ VT15CkNPTkZJR19CT09UUEFSQU1fSE9UUExVR19DUFUwPXkKIyBDT05GSUdfREVCVUdfSE9UUExV R19DUFUwIGlzIG5vdCBzZXQKQ09ORklHX0NPTVBBVF9WRFNPPXkKIyBDT05GSUdfQ01ETElORV9C T09MIGlzIG5vdCBzZXQKQ09ORklHX0FSQ0hfRU5BQkxFX01FTU9SWV9IT1RQTFVHPXkKCiMKIyBQ b3dlciBtYW5hZ2VtZW50IGFuZCBBQ1BJIG9wdGlvbnMKIwpDT05GSUdfQVJDSF9ISUJFUk5BVElP Tl9IRUFERVI9eQpDT05GSUdfU1VTUEVORD15CkNPTkZJR19TVVNQRU5EX0ZSRUVaRVI9eQpDT05G SUdfSElCRVJOQVRFX0NBTExCQUNLUz15CkNPTkZJR19ISUJFUk5BVElPTj15CkNPTkZJR19QTV9T VERfUEFSVElUSU9OPSIvZGV2L3NkYjMiCkNPTkZJR19QTV9TTEVFUD15CkNPTkZJR19QTV9TTEVF UF9TTVA9eQojIENPTkZJR19QTV9BVVRPU0xFRVAgaXMgbm90IHNldAojIENPTkZJR19QTV9XQUtF TE9DS1MgaXMgbm90IHNldApDT05GSUdfUE1fUlVOVElNRT15CkNPTkZJR19QTT15CiMgQ09ORklH X1BNX0RFQlVHIGlzIG5vdCBzZXQKQ09ORklHX1BNX0NMSz15CkNPTkZJR19XUV9QT1dFUl9FRkZJ Q0lFTlRfREVGQVVMVD15CkNPTkZJR19BQ1BJPXkKQ09ORklHX0FDUElfU0xFRVA9eQpDT05GSUdf QUNQSV9QUk9DRlM9eQpDT05GSUdfQUNQSV9QUk9DRlNfUE9XRVI9eQojIENPTkZJR19BQ1BJX0VD X0RFQlVHRlMgaXMgbm90IHNldAojIENPTkZJR19BQ1BJX0FDIGlzIG5vdCBzZXQKIyBDT05GSUdf QUNQSV9CQVRURVJZIGlzIG5vdCBzZXQKQ09ORklHX0FDUElfQlVUVE9OPXkKQ09ORklHX0FDUElf VklERU89eQpDT05GSUdfQUNQSV9GQU49bQojIENPTkZJR19BQ1BJX0RPQ0sgaXMgbm90IHNldApD T05GSUdfQUNQSV9QUk9DRVNTT1I9eQpDT05GSUdfQUNQSV9IT1RQTFVHX0NQVT15CiMgQ09ORklH X0FDUElfUFJPQ0VTU09SX0FHR1JFR0FUT1IgaXMgbm90IHNldApDT05GSUdfQUNQSV9USEVSTUFM PXkKIyBDT05GSUdfQUNQSV9DVVNUT01fRFNEVCBpcyBub3Qgc2V0CiMgQ09ORklHX0FDUElfSU5J VFJEX1RBQkxFX09WRVJSSURFIGlzIG5vdCBzZXQKQ09ORklHX0FDUElfQkxBQ0tMSVNUX1lFQVI9 MAojIENPTkZJR19BQ1BJX0RFQlVHIGlzIG5vdCBzZXQKIyBDT05GSUdfQUNQSV9QQ0lfU0xPVCBp cyBub3Qgc2V0CkNPTkZJR19YODZfUE1fVElNRVI9eQpDT05GSUdfQUNQSV9DT05UQUlORVI9eQoj IENPTkZJR19BQ1BJX1NCUyBpcyBub3Qgc2V0CiMgQ09ORklHX0FDUElfSEVEIGlzIG5vdCBzZXQK IyBDT05GSUdfQUNQSV9CR1JUIGlzIG5vdCBzZXQKIyBDT05GSUdfQUNQSV9BUEVJIGlzIG5vdCBz ZXQKQ09ORklHX1NGST15CgojCiMgQ1BVIEZyZXF1ZW5jeSBzY2FsaW5nCiMKQ09ORklHX0NQVV9G UkVRPXkKQ09ORklHX0NQVV9GUkVRX1RBQkxFPXkKIyBDT05GSUdfQ1BVX0ZSRVFfU1RBVCBpcyBu b3Qgc2V0CkNPTkZJR19DUFVfRlJFUV9ERUZBVUxUX0dPVl9QRVJGT1JNQU5DRT15CiMgQ09ORklH X0NQVV9GUkVRX0RFRkFVTFRfR09WX1VTRVJTUEFDRSBpcyBub3Qgc2V0CiMgQ09ORklHX0NQVV9G UkVRX0RFRkFVTFRfR09WX09OREVNQU5EIGlzIG5vdCBzZXQKIyBDT05GSUdfQ1BVX0ZSRVFfREVG QVVMVF9HT1ZfQ09OU0VSVkFUSVZFIGlzIG5vdCBzZXQKQ09ORklHX0NQVV9GUkVRX0dPVl9QRVJG T1JNQU5DRT15CiMgQ09ORklHX0NQVV9GUkVRX0dPVl9QT1dFUlNBVkUgaXMgbm90IHNldAojIENP TkZJR19DUFVfRlJFUV9HT1ZfVVNFUlNQQUNFIGlzIG5vdCBzZXQKIyBDT05GSUdfQ1BVX0ZSRVFf R09WX09OREVNQU5EIGlzIG5vdCBzZXQKIyBDT05GSUdfQ1BVX0ZSRVFfR09WX0NPTlNFUlZBVElW RSBpcyBub3Qgc2V0CgojCiMgeDg2IENQVSBmcmVxdWVuY3kgc2NhbGluZyBkcml2ZXJzCiMKQ09O RklHX1g4Nl9JTlRFTF9QU1RBVEU9eQojIENPTkZJR19YODZfUENDX0NQVUZSRVEgaXMgbm90IHNl dApDT05GSUdfWDg2X0FDUElfQ1BVRlJFUT15CiMgQ09ORklHX1g4Nl9BQ1BJX0NQVUZSRVFfQ1BC IGlzIG5vdCBzZXQKIyBDT05GSUdfWDg2X1BPV0VSTk9XX0s4IGlzIG5vdCBzZXQKIyBDT05GSUdf WDg2X1NQRUVEU1RFUF9DRU5UUklOTyBpcyBub3Qgc2V0CiMgQ09ORklHX1g4Nl9QNF9DTE9DS01P RCBpcyBub3Qgc2V0CgojCiMgc2hhcmVkIG9wdGlvbnMKIwojIENPTkZJR19YODZfU1BFRURTVEVQ X0xJQiBpcyBub3Qgc2V0CgojCiMgQ1BVIElkbGUKIwpDT05GSUdfQ1BVX0lETEU9eQojIENPTkZJ R19DUFVfSURMRV9NVUxUSVBMRV9EUklWRVJTIGlzIG5vdCBzZXQKQ09ORklHX0NQVV9JRExFX0dP Vl9MQURERVI9eQpDT05GSUdfQ1BVX0lETEVfR09WX01FTlU9eQojIENPTkZJR19BUkNIX05FRURT X0NQVV9JRExFX0NPVVBMRUQgaXMgbm90IHNldApDT05GSUdfSU5URUxfSURMRT15CgojCiMgTWVt b3J5IHBvd2VyIHNhdmluZ3MKIwojIENPTkZJR19JNzMwMF9JRExFIGlzIG5vdCBzZXQKCiMKIyBC dXMgb3B0aW9ucyAoUENJIGV0Yy4pCiMKQ09ORklHX1BDST15CkNPTkZJR19QQ0lfRElSRUNUPXkK Q09ORklHX1BDSV9NTUNPTkZJRz15CkNPTkZJR19QQ0lfWEVOPXkKQ09ORklHX1BDSV9ET01BSU5T PXkKQ09ORklHX1BDSUVQT1JUQlVTPXkKIyBDT05GSUdfUENJRUFFUiBpcyBub3Qgc2V0CkNPTkZJ R19QQ0lFQVNQTT15CiMgQ09ORklHX1BDSUVBU1BNX0RFQlVHIGlzIG5vdCBzZXQKIyBDT05GSUdf UENJRUFTUE1fREVGQVVMVCBpcyBub3Qgc2V0CiMgQ09ORklHX1BDSUVBU1BNX1BPV0VSU0FWRSBp cyBub3Qgc2V0CkNPTkZJR19QQ0lFQVNQTV9QRVJGT1JNQU5DRT15CkNPTkZJR19QQ0lFX1BNRT15 CkNPTkZJR19QQ0lfTVNJPXkKIyBDT05GSUdfUENJX0RFQlVHIGlzIG5vdCBzZXQKIyBDT05GSUdf UENJX1JFQUxMT0NfRU5BQkxFX0FVVE8gaXMgbm90IHNldApDT05GSUdfUENJX1NUVUI9bQpDT05G SUdfWEVOX1BDSURFVl9GUk9OVEVORD15CkNPTkZJR19IVF9JUlE9eQpDT05GSUdfUENJX0FUUz15 CkNPTkZJR19QQ0lfSU9WPXkKIyBDT05GSUdfUENJX1BSSSBpcyBub3Qgc2V0CkNPTkZJR19QQ0lf UEFTSUQ9eQojIENPTkZJR19QQ0lfSU9BUElDIGlzIG5vdCBzZXQKQ09ORklHX1BDSV9MQUJFTD15 CgojCiMgUENJIGhvc3QgY29udHJvbGxlciBkcml2ZXJzCiMKQ09ORklHX0lTQV9ETUFfQVBJPXkK Q09ORklHX0FNRF9OQj15CkNPTkZJR19QQ0NBUkQ9bQpDT05GSUdfUENNQ0lBPW0KIyBDT05GSUdf UENNQ0lBX0xPQURfQ0lTIGlzIG5vdCBzZXQKQ09ORklHX0NBUkRCVVM9eQoKIwojIFBDLWNhcmQg YnJpZGdlcwojCkNPTkZJR19ZRU5UQT1tCkNPTkZJR19ZRU5UQV9PMj15CkNPTkZJR19ZRU5UQV9S SUNPSD15CkNPTkZJR19ZRU5UQV9UST15CkNPTkZJR19ZRU5UQV9FTkVfVFVORT15CkNPTkZJR19Z RU5UQV9UT1NISUJBPXkKQ09ORklHX1BENjcyOT1tCkNPTkZJR19JODIwOTI9bQpDT05GSUdfUEND QVJEX05PTlNUQVRJQz15CiMgQ09ORklHX0hPVFBMVUdfUENJIGlzIG5vdCBzZXQKIyBDT05GSUdf UkFQSURJTyBpcyBub3Qgc2V0CiMgQ09ORklHX1g4Nl9TWVNGQiBpcyBub3Qgc2V0CgojCiMgRXhl Y3V0YWJsZSBmaWxlIGZvcm1hdHMgLyBFbXVsYXRpb25zCiMKQ09ORklHX0JJTkZNVF9FTEY9eQpD T05GSUdfQ09NUEFUX0JJTkZNVF9FTEY9eQpDT05GSUdfQVJDSF9CSU5GTVRfRUxGX1JBTkRPTUla RV9QSUU9eQpDT05GSUdfQ09SRV9EVU1QX0RFRkFVTFRfRUxGX0hFQURFUlM9eQpDT05GSUdfQklO Rk1UX1NDUklQVD15CiMgQ09ORklHX0hBVkVfQU9VVCBpcyBub3Qgc2V0CkNPTkZJR19CSU5GTVRf TUlTQz15CkNPTkZJR19DT1JFRFVNUD15CkNPTkZJR19JQTMyX0VNVUxBVElPTj15CiMgQ09ORklH X0lBMzJfQU9VVCBpcyBub3Qgc2V0CiMgQ09ORklHX1g4Nl9YMzIgaXMgbm90IHNldApDT05GSUdf Q09NUEFUPXkKQ09ORklHX0NPTVBBVF9GT1JfVTY0X0FMSUdOTUVOVD15CkNPTkZJR19TWVNWSVBD X0NPTVBBVD15CkNPTkZJR19LRVlTX0NPTVBBVD15CkNPTkZJR19YODZfREVWX0RNQV9PUFM9eQpD T05GSUdfTkVUPXkKCiMKIyBOZXR3b3JraW5nIG9wdGlvbnMKIwpDT05GSUdfUEFDS0VUPW0KIyBD T05GSUdfUEFDS0VUX0RJQUcgaXMgbm90IHNldApDT05GSUdfVU5JWD15CiMgQ09ORklHX1VOSVhf RElBRyBpcyBub3Qgc2V0CkNPTkZJR19YRlJNPXkKQ09ORklHX1hGUk1fQUxHTz15CkNPTkZJR19Y RlJNX1VTRVI9eQojIENPTkZJR19YRlJNX1NVQl9QT0xJQ1kgaXMgbm90IHNldAojIENPTkZJR19Y RlJNX01JR1JBVEUgaXMgbm90IHNldAojIENPTkZJR19YRlJNX1NUQVRJU1RJQ1MgaXMgbm90IHNl dAojIENPTkZJR19ORVRfS0VZIGlzIG5vdCBzZXQKQ09ORklHX0lORVQ9eQojIENPTkZJR19JUF9N VUxUSUNBU1QgaXMgbm90IHNldAojIENPTkZJR19JUF9BRFZBTkNFRF9ST1VURVIgaXMgbm90IHNl dApDT05GSUdfSVBfUE5QPXkKQ09ORklHX0lQX1BOUF9ESENQPXkKIyBDT05GSUdfSVBfUE5QX0JP T1RQIGlzIG5vdCBzZXQKIyBDT05GSUdfSVBfUE5QX1JBUlAgaXMgbm90IHNldAojIENPTkZJR19O RVRfSVBJUCBpcyBub3Qgc2V0CiMgQ09ORklHX05FVF9JUEdSRV9ERU1VWCBpcyBub3Qgc2V0CiMg Q09ORklHX05FVF9JUF9UVU5ORUwgaXMgbm90IHNldApDT05GSUdfU1lOX0NPT0tJRVM9eQojIENP TkZJR19JTkVUX0FIIGlzIG5vdCBzZXQKIyBDT05GSUdfSU5FVF9FU1AgaXMgbm90IHNldAojIENP TkZJR19JTkVUX0lQQ09NUCBpcyBub3Qgc2V0CiMgQ09ORklHX0lORVRfWEZSTV9UVU5ORUwgaXMg bm90IHNldAojIENPTkZJR19JTkVUX1RVTk5FTCBpcyBub3Qgc2V0CiMgQ09ORklHX0lORVRfWEZS TV9NT0RFX1RSQU5TUE9SVCBpcyBub3Qgc2V0CiMgQ09ORklHX0lORVRfWEZSTV9NT0RFX1RVTk5F TCBpcyBub3Qgc2V0CiMgQ09ORklHX0lORVRfWEZSTV9NT0RFX0JFRVQgaXMgbm90IHNldApDT05G SUdfSU5FVF9MUk89eQojIENPTkZJR19JTkVUX0RJQUcgaXMgbm90IHNldAojIENPTkZJR19UQ1Bf Q09OR19BRFZBTkNFRCBpcyBub3Qgc2V0CkNPTkZJR19UQ1BfQ09OR19DVUJJQz15CkNPTkZJR19E RUZBVUxUX1RDUF9DT05HPSJjdWJpYyIKQ09ORklHX1RDUF9NRDVTSUc9eQojIENPTkZJR19JUFY2 IGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUV09SS19TRUNNQVJLIGlzIG5vdCBzZXQKIyBDT05GSUdf TkVUV09SS19QSFlfVElNRVNUQU1QSU5HIGlzIG5vdCBzZXQKQ09ORklHX05FVEZJTFRFUj15CiMg Q09ORklHX05FVEZJTFRFUl9ERUJVRyBpcyBub3Qgc2V0CkNPTkZJR19ORVRGSUxURVJfQURWQU5D RUQ9eQpDT05GSUdfQlJJREdFX05FVEZJTFRFUj15CgojCiMgQ29yZSBOZXRmaWx0ZXIgQ29uZmln dXJhdGlvbgojCiMgQ09ORklHX05FVEZJTFRFUl9ORVRMSU5LX0FDQ1QgaXMgbm90IHNldAojIENP TkZJR19ORVRGSUxURVJfTkVUTElOS19RVUVVRSBpcyBub3Qgc2V0CiMgQ09ORklHX05FVEZJTFRF Ul9ORVRMSU5LX0xPRyBpcyBub3Qgc2V0CiMgQ09ORklHX05GX0NPTk5UUkFDSyBpcyBub3Qgc2V0 CiMgQ09ORklHX05FVEZJTFRFUl9YVEFCTEVTIGlzIG5vdCBzZXQKIyBDT05GSUdfSVBfVlMgaXMg bm90IHNldAoKIwojIElQOiBOZXRmaWx0ZXIgQ29uZmlndXJhdGlvbgojCiMgQ09ORklHX05GX0RF RlJBR19JUFY0IGlzIG5vdCBzZXQKIyBDT05GSUdfSVBfTkZfSVBUQUJMRVMgaXMgbm90IHNldAoj IENPTkZJR19JUF9ORl9BUlBUQUJMRVMgaXMgbm90IHNldAojIENPTkZJR19CUklER0VfTkZfRUJU QUJMRVMgaXMgbm90IHNldAojIENPTkZJR19JUF9EQ0NQIGlzIG5vdCBzZXQKQ09ORklHX0lQX1ND VFA9bQojIENPTkZJR19TQ1RQX0RCR19PQkpDTlQgaXMgbm90IHNldApDT05GSUdfU0NUUF9ERUZB VUxUX0NPT0tJRV9ITUFDX01ENT15CiMgQ09ORklHX1NDVFBfREVGQVVMVF9DT09LSUVfSE1BQ19T SEExIGlzIG5vdCBzZXQKIyBDT05GSUdfU0NUUF9ERUZBVUxUX0NPT0tJRV9ITUFDX05PTkUgaXMg bm90IHNldApDT05GSUdfU0NUUF9DT09LSUVfSE1BQ19NRDU9eQojIENPTkZJR19TQ1RQX0NPT0tJ RV9ITUFDX1NIQTEgaXMgbm90IHNldAojIENPTkZJR19SRFMgaXMgbm90IHNldAojIENPTkZJR19U SVBDIGlzIG5vdCBzZXQKIyBDT05GSUdfQVRNIGlzIG5vdCBzZXQKIyBDT05GSUdfTDJUUCBpcyBu b3Qgc2V0CkNPTkZJR19TVFA9eQpDT05GSUdfQlJJREdFPXkKIyBDT05GSUdfQlJJREdFX0lHTVBf U05PT1BJTkcgaXMgbm90IHNldApDT05GSUdfSEFWRV9ORVRfRFNBPXkKIyBDT05GSUdfVkxBTl84 MDIxUSBpcyBub3Qgc2V0CiMgQ09ORklHX0RFQ05FVCBpcyBub3Qgc2V0CkNPTkZJR19MTEM9eQoj IENPTkZJR19MTEMyIGlzIG5vdCBzZXQKIyBDT05GSUdfSVBYIGlzIG5vdCBzZXQKIyBDT05GSUdf QVRBTEsgaXMgbm90IHNldAojIENPTkZJR19YMjUgaXMgbm90IHNldAojIENPTkZJR19MQVBCIGlz IG5vdCBzZXQKIyBDT05GSUdfUEhPTkVUIGlzIG5vdCBzZXQKIyBDT05GSUdfSUVFRTgwMjE1NCBp cyBub3Qgc2V0CiMgQ09ORklHX05FVF9TQ0hFRCBpcyBub3Qgc2V0CiMgQ09ORklHX0RDQiBpcyBu b3Qgc2V0CiMgQ09ORklHX0ROU19SRVNPTFZFUiBpcyBub3Qgc2V0CiMgQ09ORklHX0JBVE1BTl9B RFYgaXMgbm90IHNldAojIENPTkZJR19PUEVOVlNXSVRDSCBpcyBub3Qgc2V0CiMgQ09ORklHX1ZT T0NLRVRTIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUTElOS19NTUFQIGlzIG5vdCBzZXQKIyBDT05G SUdfTkVUTElOS19ESUFHIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX01QTFNfR1NPIGlzIG5vdCBz ZXQKQ09ORklHX1JQUz15CkNPTkZJR19SRlNfQUNDRUw9eQpDT05GSUdfWFBTPXkKIyBDT05GSUdf TkVUUFJJT19DR1JPVVAgaXMgbm90IHNldApDT05GSUdfTkVUX1JYX0JVU1lfUE9MTD15CkNPTkZJ R19CUUw9eQojIENPTkZJR19CUEZfSklUIGlzIG5vdCBzZXQKQ09ORklHX05FVF9GTE9XX0xJTUlU PXkKCiMKIyBOZXR3b3JrIHRlc3RpbmcKIwpDT05GSUdfTkVUX1BLVEdFTj1tCiMgQ09ORklHX0hB TVJBRElPIGlzIG5vdCBzZXQKIyBDT05GSUdfQ0FOIGlzIG5vdCBzZXQKIyBDT05GSUdfSVJEQSBp cyBub3Qgc2V0CiMgQ09ORklHX0JUIGlzIG5vdCBzZXQKIyBDT05GSUdfQUZfUlhSUEMgaXMgbm90 IHNldAojIENPTkZJR19XSVJFTEVTUyBpcyBub3Qgc2V0CiMgQ09ORklHX1dJTUFYIGlzIG5vdCBz ZXQKIyBDT05GSUdfUkZLSUxMIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUXzlQIGlzIG5vdCBzZXQK IyBDT05GSUdfQ0FJRiBpcyBub3Qgc2V0CiMgQ09ORklHX0NFUEhfTElCIGlzIG5vdCBzZXQKIyBD T05GSUdfTkZDIGlzIG5vdCBzZXQKQ09ORklHX0hBVkVfQlBGX0pJVD15CgojCiMgRGV2aWNlIERy aXZlcnMKIwoKIwojIEdlbmVyaWMgRHJpdmVyIE9wdGlvbnMKIwpDT05GSUdfVUVWRU5UX0hFTFBF Ul9QQVRIPSIvc2Jpbi91ZGV2YWRtIgpDT05GSUdfREVWVE1QRlM9eQojIENPTkZJR19ERVZUTVBG U19NT1VOVCBpcyBub3Qgc2V0CkNPTkZJR19TVEFOREFMT05FPXkKQ09ORklHX1BSRVZFTlRfRklS TVdBUkVfQlVJTEQ9eQpDT05GSUdfRldfTE9BREVSPXkKQ09ORklHX0ZJUk1XQVJFX0lOX0tFUk5F TD15CkNPTkZJR19FWFRSQV9GSVJNV0FSRT0iIgpDT05GSUdfRldfTE9BREVSX1VTRVJfSEVMUEVS PXkKIyBDT05GSUdfREVCVUdfRFJJVkVSIGlzIG5vdCBzZXQKIyBDT05GSUdfREVCVUdfREVWUkVT IGlzIG5vdCBzZXQKQ09ORklHX1NZU19IWVBFUlZJU09SPXkKIyBDT05GSUdfR0VORVJJQ19DUFVf REVWSUNFUyBpcyBub3Qgc2V0CkNPTkZJR19SRUdNQVA9eQpDT05GSUdfUkVHTUFQX0kyQz1tCkNP TkZJR19ETUFfU0hBUkVEX0JVRkZFUj15CgojCiMgQnVzIGRldmljZXMKIwpDT05GSUdfQ09OTkVD VE9SPXkKQ09ORklHX1BST0NfRVZFTlRTPXkKIyBDT05GSUdfTVREIGlzIG5vdCBzZXQKIyBDT05G SUdfUEFSUE9SVCBpcyBub3Qgc2V0CkNPTkZJR19QTlA9eQpDT05GSUdfUE5QX0RFQlVHX01FU1NB R0VTPXkKCiMKIyBQcm90b2NvbHMKIwpDT05GSUdfUE5QQUNQST15CkNPTkZJR19CTEtfREVWPXkK IyBDT05GSUdfQkxLX0RFVl9GRCBpcyBub3Qgc2V0CkNPTkZJR19CTEtfREVWX1BDSUVTU0RfTVRJ UDMyWFg9bQojIENPTkZJR19CTEtfQ1BRX0RBIGlzIG5vdCBzZXQKIyBDT05GSUdfQkxLX0NQUV9D SVNTX0RBIGlzIG5vdCBzZXQKIyBDT05GSUdfQkxLX0RFVl9EQUM5NjAgaXMgbm90IHNldAojIENP TkZJR19CTEtfREVWX1VNRU0gaXMgbm90IHNldAojIENPTkZJR19CTEtfREVWX0NPV19DT01NT04g aXMgbm90IHNldApDT05GSUdfQkxLX0RFVl9MT09QPXkKQ09ORklHX0JMS19ERVZfTE9PUF9NSU5f Q09VTlQ9OAojIENPTkZJR19CTEtfREVWX0NSWVBUT0xPT1AgaXMgbm90IHNldAojIENPTkZJR19C TEtfREVWX0RSQkQgaXMgbm90IHNldApDT05GSUdfQkxLX0RFVl9OQkQ9bQojIENPTkZJR19CTEtf REVWX05WTUUgaXMgbm90IHNldApDT05GSUdfQkxLX0RFVl9TWDg9bQpDT05GSUdfQkxLX0RFVl9S QU09bQpDT05GSUdfQkxLX0RFVl9SQU1fQ09VTlQ9MTYKQ09ORklHX0JMS19ERVZfUkFNX1NJWkU9 ODE5MgojIENPTkZJR19CTEtfREVWX1hJUCBpcyBub3Qgc2V0CiMgQ09ORklHX0NEUk9NX1BLVENE VkQgaXMgbm90IHNldApDT05GSUdfQVRBX09WRVJfRVRIPW0KIyBDT05GSUdfWEVOX0JMS0RFVl9G Uk9OVEVORCBpcyBub3Qgc2V0CkNPTkZJR19YRU5fQkxLREVWX0JBQ0tFTkQ9eQojIENPTkZJR19C TEtfREVWX0hEIGlzIG5vdCBzZXQKIyBDT05GSUdfQkxLX0RFVl9SQkQgaXMgbm90IHNldAojIENP TkZJR19CTEtfREVWX1JTWFggaXMgbm90IHNldAoKIwojIE1pc2MgZGV2aWNlcwojCiMgQ09ORklH X1NFTlNPUlNfTElTM0xWMDJEIGlzIG5vdCBzZXQKIyBDT05GSUdfQUQ1MjVYX0RQT1QgaXMgbm90 IHNldAojIENPTkZJR19BVE1FTF9QV00gaXMgbm90IHNldAojIENPTkZJR19EVU1NWV9JUlEgaXMg bm90IHNldAojIENPTkZJR19JQk1fQVNNIGlzIG5vdCBzZXQKIyBDT05GSUdfUEhBTlRPTSBpcyBu b3Qgc2V0CiMgQ09ORklHX1NHSV9JT0M0IGlzIG5vdCBzZXQKQ09ORklHX1RJRk1fQ09SRT1tCiMg Q09ORklHX1RJRk1fN1hYMSBpcyBub3Qgc2V0CiMgQ09ORklHX0lDUzkzMlM0MDEgaXMgbm90IHNl dAojIENPTkZJR19BVE1FTF9TU0MgaXMgbm90IHNldAojIENPTkZJR19FTkNMT1NVUkVfU0VSVklD RVMgaXMgbm90IHNldAojIENPTkZJR19IUF9JTE8gaXMgbm90IHNldAojIENPTkZJR19BUERTOTgw MkFMUyBpcyBub3Qgc2V0CiMgQ09ORklHX0lTTDI5MDAzIGlzIG5vdCBzZXQKIyBDT05GSUdfSVNM MjkwMjAgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX1RTTDI1NTAgaXMgbm90IHNldAojIENP TkZJR19TRU5TT1JTX0JIMTc4MCBpcyBub3Qgc2V0CiMgQ09ORklHX1NFTlNPUlNfQkgxNzcwIGlz IG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19BUERTOTkwWCBpcyBub3Qgc2V0CiMgQ09ORklHX0hN QzYzNTIgaXMgbm90IHNldAojIENPTkZJR19EUzE2ODIgaXMgbm90IHNldAojIENPTkZJR19WTVdB UkVfQkFMTE9PTiBpcyBub3Qgc2V0CiMgQ09ORklHX0JNUDA4NV9JMkMgaXMgbm90IHNldAojIENP TkZJR19QQ0hfUEhVQiBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9TV0lUQ0hfRlNBOTQ4MCBpcyBu b3Qgc2V0CiMgQ09ORklHX1NSQU0gaXMgbm90IHNldAojIENPTkZJR19DMlBPUlQgaXMgbm90IHNl dAoKIwojIEVFUFJPTSBzdXBwb3J0CiMKIyBDT05GSUdfRUVQUk9NX0FUMjQgaXMgbm90IHNldAoj IENPTkZJR19FRVBST01fTEVHQUNZIGlzIG5vdCBzZXQKIyBDT05GSUdfRUVQUk9NX01BWDY4NzUg aXMgbm90IHNldApDT05GSUdfRUVQUk9NXzkzQ1g2PW0KIyBDT05GSUdfQ0I3MTBfQ09SRSBpcyBu b3Qgc2V0CgojCiMgVGV4YXMgSW5zdHJ1bWVudHMgc2hhcmVkIHRyYW5zcG9ydCBsaW5lIGRpc2Np cGxpbmUKIwojIENPTkZJR19TRU5TT1JTX0xJUzNfSTJDIGlzIG5vdCBzZXQKCiMKIyBBbHRlcmEg RlBHQSBmaXJtd2FyZSBkb3dubG9hZCBtb2R1bGUKIwojIENPTkZJR19BTFRFUkFfU1RBUEwgaXMg bm90IHNldAojIENPTkZJR19WTVdBUkVfVk1DSSBpcyBub3Qgc2V0CkNPTkZJR19IQVZFX0lERT15 CiMgQ09ORklHX0lERSBpcyBub3Qgc2V0CgojCiMgU0NTSSBkZXZpY2Ugc3VwcG9ydAojCkNPTkZJ R19TQ1NJX01PRD15CkNPTkZJR19SQUlEX0FUVFJTPW0KQ09ORklHX1NDU0k9eQpDT05GSUdfU0NT SV9ETUE9eQpDT05GSUdfU0NTSV9UR1Q9bQpDT05GSUdfU0NTSV9ORVRMSU5LPXkKQ09ORklHX1ND U0lfUFJPQ19GUz15CgojCiMgU0NTSSBzdXBwb3J0IHR5cGUgKGRpc2ssIHRhcGUsIENELVJPTSkK IwpDT05GSUdfQkxLX0RFVl9TRD15CiMgQ09ORklHX0NIUl9ERVZfU1QgaXMgbm90IHNldAojIENP TkZJR19DSFJfREVWX09TU1QgaXMgbm90IHNldApDT05GSUdfQkxLX0RFVl9TUj15CiMgQ09ORklH X0JMS19ERVZfU1JfVkVORE9SIGlzIG5vdCBzZXQKQ09ORklHX0NIUl9ERVZfU0c9eQpDT05GSUdf Q0hSX0RFVl9TQ0g9eQojIENPTkZJR19TQ1NJX01VTFRJX0xVTiBpcyBub3Qgc2V0CiMgQ09ORklH X1NDU0lfQ09OU1RBTlRTIGlzIG5vdCBzZXQKIyBDT05GSUdfU0NTSV9MT0dHSU5HIGlzIG5vdCBz ZXQKQ09ORklHX1NDU0lfU0NBTl9BU1lOQz15CgojCiMgU0NTSSBUcmFuc3BvcnRzCiMKQ09ORklH X1NDU0lfU1BJX0FUVFJTPW0KQ09ORklHX1NDU0lfRkNfQVRUUlM9bQojIENPTkZJR19TQ1NJX0ZD X1RHVF9BVFRSUyBpcyBub3Qgc2V0CkNPTkZJR19TQ1NJX0lTQ1NJX0FUVFJTPW0KQ09ORklHX1ND U0lfU0FTX0FUVFJTPXkKQ09ORklHX1NDU0lfU0FTX0xJQlNBUz15CiMgQ09ORklHX1NDU0lfU0FT X0FUQSBpcyBub3Qgc2V0CiMgQ09ORklHX1NDU0lfU0FTX0hPU1RfU01QIGlzIG5vdCBzZXQKQ09O RklHX1NDU0lfU1JQX0FUVFJTPW0KIyBDT05GSUdfU0NTSV9TUlBfVEdUX0FUVFJTIGlzIG5vdCBz ZXQKQ09ORklHX1NDU0lfTE9XTEVWRUw9eQojIENPTkZJR19JU0NTSV9UQ1AgaXMgbm90IHNldAoj IENPTkZJR19JU0NTSV9CT09UX1NZU0ZTIGlzIG5vdCBzZXQKIyBDT05GSUdfU0NTSV9DWEdCM19J U0NTSSBpcyBub3Qgc2V0CiMgQ09ORklHX1NDU0lfQ1hHQjRfSVNDU0kgaXMgbm90IHNldAojIENP TkZJR19TQ1NJX0JOWDJfSVNDU0kgaXMgbm90IHNldAojIENPTkZJR19TQ1NJX0JOWDJYX0ZDT0Ug aXMgbm90IHNldAojIENPTkZJR19CRTJJU0NTSSBpcyBub3Qgc2V0CiMgQ09ORklHX0JMS19ERVZf M1dfWFhYWF9SQUlEIGlzIG5vdCBzZXQKIyBDT05GSUdfU0NTSV9IUFNBIGlzIG5vdCBzZXQKIyBD T05GSUdfU0NTSV8zV185WFhYIGlzIG5vdCBzZXQKIyBDT05GSUdfU0NTSV8zV19TQVMgaXMgbm90 IHNldAojIENPTkZJR19TQ1NJX0FDQVJEIGlzIG5vdCBzZXQKIyBDT05GSUdfU0NTSV9BQUNSQUlE IGlzIG5vdCBzZXQKIyBDT05GSUdfU0NTSV9BSUM3WFhYIGlzIG5vdCBzZXQKIyBDT05GSUdfU0NT SV9BSUM3WFhYX09MRCBpcyBub3Qgc2V0CiMgQ09ORklHX1NDU0lfQUlDNzlYWCBpcyBub3Qgc2V0 CiMgQ09ORklHX1NDU0lfQUlDOTRYWCBpcyBub3Qgc2V0CiMgQ09ORklHX1NDU0lfTVZTQVMgaXMg bm90IHNldAojIENPTkZJR19TQ1NJX01WVU1JIGlzIG5vdCBzZXQKIyBDT05GSUdfU0NTSV9EUFRf STJPIGlzIG5vdCBzZXQKIyBDT05GSUdfU0NTSV9BRFZBTlNZUyBpcyBub3Qgc2V0CiMgQ09ORklH X1NDU0lfQVJDTVNSIGlzIG5vdCBzZXQKIyBDT05GSUdfU0NTSV9FU0FTMlIgaXMgbm90IHNldAoj IENPTkZJR19NRUdBUkFJRF9ORVdHRU4gaXMgbm90IHNldAojIENPTkZJR19NRUdBUkFJRF9MRUdB Q1kgaXMgbm90IHNldAojIENPTkZJR19NRUdBUkFJRF9TQVMgaXMgbm90IHNldAojIENPTkZJR19T Q1NJX01QVDJTQVMgaXMgbm90IHNldAojIENPTkZJR19TQ1NJX01QVDNTQVMgaXMgbm90IHNldAoj IENPTkZJR19TQ1NJX1VGU0hDRCBpcyBub3Qgc2V0CiMgQ09ORklHX1NDU0lfSFBUSU9QIGlzIG5v dCBzZXQKIyBDT05GSUdfU0NTSV9CVVNMT0dJQyBpcyBub3Qgc2V0CiMgQ09ORklHX1ZNV0FSRV9Q VlNDU0kgaXMgbm90IHNldAojIENPTkZJR19MSUJGQyBpcyBub3Qgc2V0CiMgQ09ORklHX0xJQkZD T0UgaXMgbm90IHNldAojIENPTkZJR19GQ09FIGlzIG5vdCBzZXQKIyBDT05GSUdfRkNPRV9GTklD IGlzIG5vdCBzZXQKIyBDT05GSUdfU0NTSV9ETVgzMTkxRCBpcyBub3Qgc2V0CiMgQ09ORklHX1ND U0lfRUFUQSBpcyBub3Qgc2V0CiMgQ09ORklHX1NDU0lfRlVUVVJFX0RPTUFJTiBpcyBub3Qgc2V0 CiMgQ09ORklHX1NDU0lfR0RUSCBpcyBub3Qgc2V0CkNPTkZJR19TQ1NJX0lTQ0k9eQojIENPTkZJ R19TQ1NJX0lQUyBpcyBub3Qgc2V0CiMgQ09ORklHX1NDU0lfSU5JVElPIGlzIG5vdCBzZXQKIyBD T05GSUdfU0NTSV9JTklBMTAwIGlzIG5vdCBzZXQKIyBDT05GSUdfU0NTSV9TVEVYIGlzIG5vdCBz ZXQKIyBDT05GSUdfU0NTSV9TWU01M0M4WFhfMiBpcyBub3Qgc2V0CiMgQ09ORklHX1NDU0lfSVBS IGlzIG5vdCBzZXQKIyBDT05GSUdfU0NTSV9RTE9HSUNfMTI4MCBpcyBub3Qgc2V0CiMgQ09ORklH X1NDU0lfUUxBX0ZDIGlzIG5vdCBzZXQKIyBDT05GSUdfU0NTSV9RTEFfSVNDU0kgaXMgbm90IHNl dAojIENPTkZJR19TQ1NJX0xQRkMgaXMgbm90IHNldAojIENPTkZJR19TQ1NJX0RDMzk1eCBpcyBu b3Qgc2V0CiMgQ09ORklHX1NDU0lfREMzOTBUIGlzIG5vdCBzZXQKIyBDT05GSUdfU0NTSV9ERUJV RyBpcyBub3Qgc2V0CiMgQ09ORklHX1NDU0lfUE1DUkFJRCBpcyBub3Qgc2V0CiMgQ09ORklHX1ND U0lfUE04MDAxIGlzIG5vdCBzZXQKIyBDT05GSUdfU0NTSV9TUlAgaXMgbm90IHNldAojIENPTkZJ R19TQ1NJX0JGQV9GQyBpcyBub3Qgc2V0CiMgQ09ORklHX1NDU0lfQ0hFTFNJT19GQ09FIGlzIG5v dCBzZXQKQ09ORklHX1NDU0lfTE9XTEVWRUxfUENNQ0lBPXkKIyBDT05GSUdfUENNQ0lBX0FIQTE1 MlggaXMgbm90IHNldApDT05GSUdfUENNQ0lBX0ZET01BSU49bQpDT05GSUdfUENNQ0lBX1FMT0dJ Qz1tCkNPTkZJR19QQ01DSUFfU1lNNTNDNTAwPW0KIyBDT05GSUdfU0NTSV9ESCBpcyBub3Qgc2V0 CiMgQ09ORklHX1NDU0lfT1NEX0lOSVRJQVRPUiBpcyBub3Qgc2V0CkNPTkZJR19BVEE9eQojIENP TkZJR19BVEFfTk9OU1RBTkRBUkQgaXMgbm90IHNldAojIENPTkZJR19BVEFfVkVSQk9TRV9FUlJP UiBpcyBub3Qgc2V0CkNPTkZJR19BVEFfQUNQST15CiMgQ09ORklHX1NBVEFfWlBPREQgaXMgbm90 IHNldApDT05GSUdfU0FUQV9QTVA9eQoKIwojIENvbnRyb2xsZXJzIHdpdGggbm9uLVNGRiBuYXRp dmUgaW50ZXJmYWNlCiMKQ09ORklHX1NBVEFfQUhDST15CiMgQ09ORklHX1NBVEFfQUhDSV9QTEFU Rk9STSBpcyBub3Qgc2V0CiMgQ09ORklHX1NBVEFfSU5JQzE2MlggaXMgbm90IHNldAojIENPTkZJ R19TQVRBX0FDQVJEX0FIQ0kgaXMgbm90IHNldAojIENPTkZJR19TQVRBX1NJTDI0IGlzIG5vdCBz ZXQKQ09ORklHX0FUQV9TRkY9eQoKIwojIFNGRiBjb250cm9sbGVycyB3aXRoIGN1c3RvbSBETUEg aW50ZXJmYWNlCiMKIyBDT05GSUdfUERDX0FETUEgaXMgbm90IHNldAojIENPTkZJR19TQVRBX1FT VE9SIGlzIG5vdCBzZXQKIyBDT05GSUdfU0FUQV9TWDQgaXMgbm90IHNldApDT05GSUdfQVRBX0JN RE1BPXkKCiMKIyBTQVRBIFNGRiBjb250cm9sbGVycyB3aXRoIEJNRE1BCiMKQ09ORklHX0FUQV9Q SUlYPXkKIyBDT05GSUdfU0FUQV9ISUdIQkFOSyBpcyBub3Qgc2V0CiMgQ09ORklHX1NBVEFfTVYg aXMgbm90IHNldAojIENPTkZJR19TQVRBX05WIGlzIG5vdCBzZXQKIyBDT05GSUdfU0FUQV9QUk9N SVNFIGlzIG5vdCBzZXQKIyBDT05GSUdfU0FUQV9SQ0FSIGlzIG5vdCBzZXQKIyBDT05GSUdfU0FU QV9TSUwgaXMgbm90IHNldAojIENPTkZJR19TQVRBX1NJUyBpcyBub3Qgc2V0CiMgQ09ORklHX1NB VEFfU1ZXIGlzIG5vdCBzZXQKIyBDT05GSUdfU0FUQV9VTEkgaXMgbm90IHNldAojIENPTkZJR19T QVRBX1ZJQSBpcyBub3Qgc2V0CiMgQ09ORklHX1NBVEFfVklURVNTRSBpcyBub3Qgc2V0CgojCiMg UEFUQSBTRkYgY29udHJvbGxlcnMgd2l0aCBCTURNQQojCiMgQ09ORklHX1BBVEFfQUxJIGlzIG5v dCBzZXQKQ09ORklHX1BBVEFfQU1EPXkKIyBDT05GSUdfUEFUQV9BUkFTQU5fQ0YgaXMgbm90IHNl dAojIENPTkZJR19QQVRBX0FSVE9QIGlzIG5vdCBzZXQKIyBDT05GSUdfUEFUQV9BVElJWFAgaXMg bm90IHNldAojIENPTkZJR19QQVRBX0FUUDg2N1ggaXMgbm90IHNldAojIENPTkZJR19QQVRBX0NN RDY0WCBpcyBub3Qgc2V0CiMgQ09ORklHX1BBVEFfQ1M1NTIwIGlzIG5vdCBzZXQKIyBDT05GSUdf UEFUQV9DUzU1MzAgaXMgbm90IHNldAojIENPTkZJR19QQVRBX0NTNTUzNiBpcyBub3Qgc2V0CiMg Q09ORklHX1BBVEFfQ1lQUkVTUyBpcyBub3Qgc2V0CiMgQ09ORklHX1BBVEFfRUZBUiBpcyBub3Qg c2V0CiMgQ09ORklHX1BBVEFfSFBUMzY2IGlzIG5vdCBzZXQKIyBDT05GSUdfUEFUQV9IUFQzN1gg aXMgbm90IHNldAojIENPTkZJR19QQVRBX0hQVDNYMk4gaXMgbm90IHNldAojIENPTkZJR19QQVRB X0hQVDNYMyBpcyBub3Qgc2V0CiMgQ09ORklHX1BBVEFfSVQ4MjEzIGlzIG5vdCBzZXQKIyBDT05G SUdfUEFUQV9JVDgyMVggaXMgbm90IHNldAojIENPTkZJR19QQVRBX0pNSUNST04gaXMgbm90IHNl dAojIENPTkZJR19QQVRBX01BUlZFTEwgaXMgbm90IHNldAojIENPTkZJR19QQVRBX05FVENFTEwg aXMgbm90IHNldAojIENPTkZJR19QQVRBX05JTkpBMzIgaXMgbm90IHNldAojIENPTkZJR19QQVRB X05TODc0MTUgaXMgbm90IHNldApDT05GSUdfUEFUQV9PTERQSUlYPXkKIyBDT05GSUdfUEFUQV9P UFRJRE1BIGlzIG5vdCBzZXQKIyBDT05GSUdfUEFUQV9QREMyMDI3WCBpcyBub3Qgc2V0CiMgQ09O RklHX1BBVEFfUERDX09MRCBpcyBub3Qgc2V0CiMgQ09ORklHX1BBVEFfUkFESVNZUyBpcyBub3Qg c2V0CiMgQ09ORklHX1BBVEFfUkRDIGlzIG5vdCBzZXQKIyBDT05GSUdfUEFUQV9TQzEyMDAgaXMg bm90IHNldApDT05GSUdfUEFUQV9TQ0g9eQojIENPTkZJR19QQVRBX1NFUlZFUldPUktTIGlzIG5v dCBzZXQKIyBDT05GSUdfUEFUQV9TSUw2ODAgaXMgbm90IHNldAojIENPTkZJR19QQVRBX1NJUyBp cyBub3Qgc2V0CiMgQ09ORklHX1BBVEFfVE9TSElCQSBpcyBub3Qgc2V0CiMgQ09ORklHX1BBVEFf VFJJRkxFWCBpcyBub3Qgc2V0CiMgQ09ORklHX1BBVEFfVklBIGlzIG5vdCBzZXQKIyBDT05GSUdf UEFUQV9XSU5CT05EIGlzIG5vdCBzZXQKCiMKIyBQSU8tb25seSBTRkYgY29udHJvbGxlcnMKIwoj IENPTkZJR19QQVRBX0NNRDY0MF9QQ0kgaXMgbm90IHNldAojIENPTkZJR19QQVRBX01QSUlYIGlz IG5vdCBzZXQKIyBDT05GSUdfUEFUQV9OUzg3NDEwIGlzIG5vdCBzZXQKIyBDT05GSUdfUEFUQV9P UFRJIGlzIG5vdCBzZXQKIyBDT05GSUdfUEFUQV9QQ01DSUEgaXMgbm90IHNldAojIENPTkZJR19Q QVRBX1JaMTAwMCBpcyBub3Qgc2V0CgojCiMgR2VuZXJpYyBmYWxsYmFjayAvIGxlZ2FjeSBkcml2 ZXJzCiMKIyBDT05GSUdfUEFUQV9BQ1BJIGlzIG5vdCBzZXQKIyBDT05GSUdfQVRBX0dFTkVSSUMg aXMgbm90IHNldAojIENPTkZJR19QQVRBX0xFR0FDWSBpcyBub3Qgc2V0CkNPTkZJR19NRD15CkNP TkZJR19CTEtfREVWX01EPXkKQ09ORklHX01EX0FVVE9ERVRFQ1Q9eQpDT05GSUdfTURfTElORUFS PW0KQ09ORklHX01EX1JBSUQwPW0KQ09ORklHX01EX1JBSUQxPW0KQ09ORklHX01EX1JBSUQxMD1t CiMgQ09ORklHX01EX1JBSUQ0NTYgaXMgbm90IHNldAojIENPTkZJR19NRF9NVUxUSVBBVEggaXMg bm90IHNldAojIENPTkZJR19NRF9GQVVMVFkgaXMgbm90IHNldAojIENPTkZJR19CQ0FDSEUgaXMg bm90IHNldAojIENPTkZJR19CTEtfREVWX0RNIGlzIG5vdCBzZXQKIyBDT05GSUdfVEFSR0VUX0NP UkUgaXMgbm90IHNldAojIENPTkZJR19GVVNJT04gaXMgbm90IHNldAoKIwojIElFRUUgMTM5NCAo RmlyZVdpcmUpIHN1cHBvcnQKIwpDT05GSUdfRklSRVdJUkU9bQojIENPTkZJR19GSVJFV0lSRV9P SENJIGlzIG5vdCBzZXQKIyBDT05GSUdfRklSRVdJUkVfU0JQMiBpcyBub3Qgc2V0CiMgQ09ORklH X0ZJUkVXSVJFX05FVCBpcyBub3Qgc2V0CiMgQ09ORklHX0ZJUkVXSVJFX05PU1kgaXMgbm90IHNl dAojIENPTkZJR19JMk8gaXMgbm90IHNldAojIENPTkZJR19NQUNJTlRPU0hfRFJJVkVSUyBpcyBu b3Qgc2V0CkNPTkZJR19ORVRERVZJQ0VTPXkKQ09ORklHX01JST15CkNPTkZJR19ORVRfQ09SRT15 CiMgQ09ORklHX0JPTkRJTkcgaXMgbm90IHNldAojIENPTkZJR19EVU1NWSBpcyBub3Qgc2V0CiMg Q09ORklHX0VRVUFMSVpFUiBpcyBub3Qgc2V0CiMgQ09ORklHX05FVF9GQyBpcyBub3Qgc2V0CiMg Q09ORklHX05FVF9URUFNIGlzIG5vdCBzZXQKIyBDT05GSUdfTUFDVkxBTiBpcyBub3Qgc2V0CiMg Q09ORklHX1ZYTEFOIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUQ09OU09MRSBpcyBub3Qgc2V0CiMg Q09ORklHX05FVFBPTEwgaXMgbm90IHNldAojIENPTkZJR19ORVRfUE9MTF9DT05UUk9MTEVSIGlz IG5vdCBzZXQKIyBDT05GSUdfVFVOIGlzIG5vdCBzZXQKIyBDT05GSUdfVkVUSCBpcyBub3Qgc2V0 CiMgQ09ORklHX05MTU9OIGlzIG5vdCBzZXQKIyBDT05GSUdfQVJDTkVUIGlzIG5vdCBzZXQKCiMK IyBDQUlGIHRyYW5zcG9ydCBkcml2ZXJzCiMKQ09ORklHX1ZIT1NUX05FVD1tCkNPTkZJR19WSE9T VF9SSU5HPW0KQ09ORklHX1ZIT1NUPW0KCiMKIyBEaXN0cmlidXRlZCBTd2l0Y2ggQXJjaGl0ZWN0 dXJlIGRyaXZlcnMKIwojIENPTkZJR19ORVRfRFNBX01WODhFNlhYWCBpcyBub3Qgc2V0CiMgQ09O RklHX05FVF9EU0FfTVY4OEU2MDYwIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX0RTQV9NVjg4RTZY WFhfTkVFRF9QUFUgaXMgbm90IHNldAojIENPTkZJR19ORVRfRFNBX01WODhFNjEzMSBpcyBub3Qg c2V0CiMgQ09ORklHX05FVF9EU0FfTVY4OEU2MTIzXzYxXzY1IGlzIG5vdCBzZXQKQ09ORklHX0VU SEVSTkVUPXkKIyBDT05GSUdfTkVUX1ZFTkRPUl8zQ09NIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVU X1ZFTkRPUl9BREFQVEVDIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX1ZFTkRPUl9BTFRFT04gaXMg bm90IHNldAojIENPTkZJR19ORVRfVkVORE9SX0FNRCBpcyBub3Qgc2V0CkNPTkZJR19ORVRfVkVO RE9SX0FSQz15CiMgQ09ORklHX05FVF9WRU5ET1JfQVRIRVJPUyBpcyBub3Qgc2V0CiMgQ09ORklH X05FVF9DQURFTkNFIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX1ZFTkRPUl9CUk9BRENPTSBpcyBu b3Qgc2V0CiMgQ09ORklHX05FVF9WRU5ET1JfQlJPQ0FERSBpcyBub3Qgc2V0CiMgQ09ORklHX05F VF9DQUxYRURBX1hHTUFDIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX1ZFTkRPUl9DSEVMU0lPIGlz IG5vdCBzZXQKIyBDT05GSUdfTkVUX1ZFTkRPUl9DSVNDTyBpcyBub3Qgc2V0CiMgQ09ORklHX0RO RVQgaXMgbm90IHNldAojIENPTkZJR19ORVRfVkVORE9SX0RFQyBpcyBub3Qgc2V0CiMgQ09ORklH X05FVF9WRU5ET1JfRExJTksgaXMgbm90IHNldAojIENPTkZJR19ORVRfVkVORE9SX0VNVUxFWCBp cyBub3Qgc2V0CiMgQ09ORklHX05FVF9WRU5ET1JfRVhBUiBpcyBub3Qgc2V0CiMgQ09ORklHX05F VF9WRU5ET1JfRlVKSVRTVSBpcyBub3Qgc2V0CiMgQ09ORklHX05FVF9WRU5ET1JfSFAgaXMgbm90 IHNldAojIENPTkZJR19ORVRfVkVORE9SX0lOVEVMIGlzIG5vdCBzZXQKIyBDT05GSUdfSVAxMDAw IGlzIG5vdCBzZXQKIyBDT05GSUdfSk1FIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX1ZFTkRPUl9N QVJWRUxMIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX1ZFTkRPUl9NRUxMQU5PWCBpcyBub3Qgc2V0 CiMgQ09ORklHX05FVF9WRU5ET1JfTUlDUkVMIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX1ZFTkRP Ul9NWVJJIGlzIG5vdCBzZXQKIyBDT05GSUdfRkVBTE5YIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVU X1ZFTkRPUl9OQVRTRU1JIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX1ZFTkRPUl9OVklESUEgaXMg bm90IHNldAojIENPTkZJR19ORVRfVkVORE9SX09LSSBpcyBub3Qgc2V0CiMgQ09ORklHX0VUSE9D IGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX1BBQ0tFVF9FTkdJTkUgaXMgbm90IHNldAojIENPTkZJ R19ORVRfVkVORE9SX1FMT0dJQyBpcyBub3Qgc2V0CkNPTkZJR19ORVRfVkVORE9SX1JFQUxURUs9 eQojIENPTkZJR184MTM5Q1AgaXMgbm90IHNldAojIENPTkZJR184MTM5VE9PIGlzIG5vdCBzZXQK Q09ORklHX1I4MTY5PXkKIyBDT05GSUdfU0hfRVRIIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX1ZF TkRPUl9SREMgaXMgbm90IHNldAojIENPTkZJR19ORVRfVkVORE9SX1NFRVEgaXMgbm90IHNldAoj IENPTkZJR19ORVRfVkVORE9SX1NJTEFOIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX1ZFTkRPUl9T SVMgaXMgbm90IHNldAojIENPTkZJR19TRkMgaXMgbm90IHNldAojIENPTkZJR19ORVRfVkVORE9S X1NNU0MgaXMgbm90IHNldAojIENPTkZJR19ORVRfVkVORE9SX1NUTUlDUk8gaXMgbm90IHNldAoj IENPTkZJR19ORVRfVkVORE9SX1NVTiBpcyBub3Qgc2V0CiMgQ09ORklHX05FVF9WRU5ET1JfVEVI VVRJIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX1ZFTkRPUl9USSBpcyBub3Qgc2V0CiMgQ09ORklH X05FVF9WRU5ET1JfVklBIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX1ZFTkRPUl9XSVpORVQgaXMg bm90IHNldAojIENPTkZJR19ORVRfVkVORE9SX1hJUkNPTSBpcyBub3Qgc2V0CiMgQ09ORklHX0ZE REkgaXMgbm90IHNldAojIENPTkZJR19ISVBQSSBpcyBub3Qgc2V0CiMgQ09ORklHX05FVF9TQjEw MDAgaXMgbm90IHNldApDT05GSUdfUEhZTElCPW0KCiMKIyBNSUkgUEhZIGRldmljZSBkcml2ZXJz CiMKIyBDT05GSUdfQVQ4MDNYX1BIWSBpcyBub3Qgc2V0CiMgQ09ORklHX0FNRF9QSFkgaXMgbm90 IHNldApDT05GSUdfTUFSVkVMTF9QSFk9bQpDT05GSUdfREFWSUNPTV9QSFk9bQpDT05GSUdfUVNF TUlfUEhZPW0KQ09ORklHX0xYVF9QSFk9bQpDT05GSUdfQ0lDQURBX1BIWT1tCkNPTkZJR19WSVRF U1NFX1BIWT1tCkNPTkZJR19TTVNDX1BIWT1tCkNPTkZJR19CUk9BRENPTV9QSFk9bQojIENPTkZJ R19CQ004N1hYX1BIWSBpcyBub3Qgc2V0CkNPTkZJR19JQ1BMVVNfUEhZPW0KIyBDT05GSUdfUkVB TFRFS19QSFkgaXMgbm90IHNldAojIENPTkZJR19OQVRJT05BTF9QSFkgaXMgbm90IHNldAojIENP TkZJR19TVEUxMFhQIGlzIG5vdCBzZXQKIyBDT05GSUdfTFNJX0VUMTAxMUNfUEhZIGlzIG5vdCBz ZXQKIyBDT05GSUdfTUlDUkVMX1BIWSBpcyBub3Qgc2V0CkNPTkZJR19NRElPX0JJVEJBTkc9bQoj IENPTkZJR19QUFAgaXMgbm90IHNldAojIENPTkZJR19TTElQIGlzIG5vdCBzZXQKCiMKIyBVU0Ig TmV0d29yayBBZGFwdGVycwojCkNPTkZJR19VU0JfQ0FUQz1tCkNPTkZJR19VU0JfS0FXRVRIPW0K Q09ORklHX1VTQl9QRUdBU1VTPW0KQ09ORklHX1VTQl9SVEw4MTUwPW0KIyBDT05GSUdfVVNCX1JU TDgxNTIgaXMgbm90IHNldApDT05GSUdfVVNCX1VTQk5FVD1tCkNPTkZJR19VU0JfTkVUX0FYODgx N1g9bQpDT05GSUdfVVNCX05FVF9BWDg4MTc5XzE3OEE9bQpDT05GSUdfVVNCX05FVF9DRENFVEhF Uj1tCiMgQ09ORklHX1VTQl9ORVRfQ0RDX0VFTSBpcyBub3Qgc2V0CkNPTkZJR19VU0JfTkVUX0NE Q19OQ009bQojIENPTkZJR19VU0JfTkVUX0NEQ19NQklNIGlzIG5vdCBzZXQKQ09ORklHX1VTQl9O RVRfRE05NjAxPW0KIyBDT05GSUdfVVNCX05FVF9TUjk3MDAgaXMgbm90IHNldAojIENPTkZJR19V U0JfTkVUX1NNU0M3NVhYIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX05FVF9TTVNDOTVYWCBpcyBu b3Qgc2V0CiMgQ09ORklHX1VTQl9ORVRfR0w2MjBBIGlzIG5vdCBzZXQKQ09ORklHX1VTQl9ORVRf TkVUMTA4MD1tCiMgQ09ORklHX1VTQl9ORVRfUExVU0IgaXMgbm90IHNldApDT05GSUdfVVNCX05F VF9NQ1M3ODMwPW0KIyBDT05GSUdfVVNCX05FVF9STkRJU19IT1NUIGlzIG5vdCBzZXQKIyBDT05G SUdfVVNCX05FVF9DRENfU1VCU0VUIGlzIG5vdCBzZXQKQ09ORklHX1VTQl9ORVRfWkFVUlVTPW0K IyBDT05GSUdfVVNCX05FVF9DWDgyMzEwX0VUSCBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9ORVRf S0FMTUlBIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX05FVF9RTUlfV1dBTiBpcyBub3Qgc2V0CiMg Q09ORklHX1VTQl9ORVRfSU5UNTFYMSBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9JUEhFVEggaXMg bm90IHNldAojIENPTkZJR19VU0JfU0lFUlJBX05FVCBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9W TDYwMCBpcyBub3Qgc2V0CiMgQ09ORklHX1dMQU4gaXMgbm90IHNldAoKIwojIEVuYWJsZSBXaU1B WCAoTmV0d29ya2luZyBvcHRpb25zKSB0byBzZWUgdGhlIFdpTUFYIGRyaXZlcnMKIwojIENPTkZJ R19XQU4gaXMgbm90IHNldAojIENPTkZJR19YRU5fTkVUREVWX0ZST05URU5EIGlzIG5vdCBzZXQK Q09ORklHX1hFTl9ORVRERVZfQkFDS0VORD15CiMgQ09ORklHX1ZNWE5FVDMgaXMgbm90IHNldAoj IENPTkZJR19JU0ROIGlzIG5vdCBzZXQKCiMKIyBJbnB1dCBkZXZpY2Ugc3VwcG9ydAojCkNPTkZJ R19JTlBVVD15CkNPTkZJR19JTlBVVF9GRl9NRU1MRVNTPW0KQ09ORklHX0lOUFVUX1BPTExERVY9 eQpDT05GSUdfSU5QVVRfU1BBUlNFS01BUD1tCiMgQ09ORklHX0lOUFVUX01BVFJJWEtNQVAgaXMg bm90IHNldAoKIwojIFVzZXJsYW5kIGludGVyZmFjZXMKIwpDT05GSUdfSU5QVVRfTU9VU0VERVY9 eQpDT05GSUdfSU5QVVRfTU9VU0VERVZfUFNBVVg9eQpDT05GSUdfSU5QVVRfTU9VU0VERVZfU0NS RUVOX1g9MTAyNApDT05GSUdfSU5QVVRfTU9VU0VERVZfU0NSRUVOX1k9NzY4CkNPTkZJR19JTlBV VF9KT1lERVY9bQpDT05GSUdfSU5QVVRfRVZERVY9eQojIENPTkZJR19JTlBVVF9FVkJVRyBpcyBu b3Qgc2V0CgojCiMgSW5wdXQgRGV2aWNlIERyaXZlcnMKIwpDT05GSUdfSU5QVVRfS0VZQk9BUkQ9 eQojIENPTkZJR19LRVlCT0FSRF9BRFA1NTg4IGlzIG5vdCBzZXQKIyBDT05GSUdfS0VZQk9BUkRf QURQNTU4OSBpcyBub3Qgc2V0CkNPTkZJR19LRVlCT0FSRF9BVEtCRD15CiMgQ09ORklHX0tFWUJP QVJEX1FUMTA3MCBpcyBub3Qgc2V0CiMgQ09ORklHX0tFWUJPQVJEX1FUMjE2MCBpcyBub3Qgc2V0 CkNPTkZJR19LRVlCT0FSRF9MS0tCRD1tCiMgQ09ORklHX0tFWUJPQVJEX1RDQTY0MTYgaXMgbm90 IHNldAojIENPTkZJR19LRVlCT0FSRF9UQ0E4NDE4IGlzIG5vdCBzZXQKIyBDT05GSUdfS0VZQk9B UkRfTE04MzIzIGlzIG5vdCBzZXQKIyBDT05GSUdfS0VZQk9BUkRfTE04MzMzIGlzIG5vdCBzZXQK IyBDT05GSUdfS0VZQk9BUkRfTUFYNzM1OSBpcyBub3Qgc2V0CiMgQ09ORklHX0tFWUJPQVJEX01D UyBpcyBub3Qgc2V0CiMgQ09ORklHX0tFWUJPQVJEX01QUjEyMSBpcyBub3Qgc2V0CkNPTkZJR19L RVlCT0FSRF9ORVdUT049bQojIENPTkZJR19LRVlCT0FSRF9PUEVOQ09SRVMgaXMgbm90IHNldAoj IENPTkZJR19LRVlCT0FSRF9TQU1TVU5HIGlzIG5vdCBzZXQKQ09ORklHX0tFWUJPQVJEX1NUT1dB V0FZPW0KQ09ORklHX0tFWUJPQVJEX1NVTktCRD1tCkNPTkZJR19LRVlCT0FSRF9YVEtCRD1tCkNP TkZJR19JTlBVVF9NT1VTRT15CkNPTkZJR19NT1VTRV9QUzI9eQpDT05GSUdfTU9VU0VfUFMyX0FM UFM9eQpDT05GSUdfTU9VU0VfUFMyX0xPR0lQUzJQUD15CkNPTkZJR19NT1VTRV9QUzJfU1lOQVBU SUNTPXkKQ09ORklHX01PVVNFX1BTMl9DWVBSRVNTPXkKQ09ORklHX01PVVNFX1BTMl9MSUZFQk9P Sz15CkNPTkZJR19NT1VTRV9QUzJfVFJBQ0tQT0lOVD15CiMgQ09ORklHX01PVVNFX1BTMl9FTEFO VEVDSCBpcyBub3Qgc2V0CiMgQ09ORklHX01PVVNFX1BTMl9TRU5URUxJQyBpcyBub3Qgc2V0CiMg Q09ORklHX01PVVNFX1BTMl9UT1VDSEtJVCBpcyBub3Qgc2V0CkNPTkZJR19NT1VTRV9TRVJJQUw9 bQpDT05GSUdfTU9VU0VfQVBQTEVUT1VDSD1tCiMgQ09ORklHX01PVVNFX0JDTTU5NzQgaXMgbm90 IHNldAojIENPTkZJR19NT1VTRV9DWUFQQSBpcyBub3Qgc2V0CiMgQ09ORklHX01PVVNFX1ZTWFhY QUEgaXMgbm90IHNldAojIENPTkZJR19NT1VTRV9TWU5BUFRJQ1NfSTJDIGlzIG5vdCBzZXQKIyBD T05GSUdfTU9VU0VfU1lOQVBUSUNTX1VTQiBpcyBub3Qgc2V0CiMgQ09ORklHX0lOUFVUX0pPWVNU SUNLIGlzIG5vdCBzZXQKIyBDT05GSUdfSU5QVVRfVEFCTEVUIGlzIG5vdCBzZXQKIyBDT05GSUdf SU5QVVRfVE9VQ0hTQ1JFRU4gaXMgbm90IHNldAojIENPTkZJR19JTlBVVF9NSVNDIGlzIG5vdCBz ZXQKCiMKIyBIYXJkd2FyZSBJL08gcG9ydHMKIwpDT05GSUdfU0VSSU89eQpDT05GSUdfU0VSSU9f STgwNDI9eQpDT05GSUdfU0VSSU9fU0VSUE9SVD15CkNPTkZJR19TRVJJT19DVDgyQzcxMD1tCkNP TkZJR19TRVJJT19QQ0lQUzI9eQpDT05GSUdfU0VSSU9fTElCUFMyPXkKIyBDT05GSUdfU0VSSU9f UkFXIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VSSU9fQUxURVJBX1BTMiBpcyBub3Qgc2V0CiMgQ09O RklHX1NFUklPX1BTMk1VTFQgaXMgbm90IHNldAojIENPTkZJR19TRVJJT19BUkNfUFMyIGlzIG5v dCBzZXQKIyBDT05GSUdfR0FNRVBPUlQgaXMgbm90IHNldAoKIwojIENoYXJhY3RlciBkZXZpY2Vz CiMKQ09ORklHX1RUWT15CkNPTkZJR19WVD15CkNPTkZJR19DT05TT0xFX1RSQU5TTEFUSU9OUz15 CkNPTkZJR19WVF9DT05TT0xFPXkKQ09ORklHX1ZUX0NPTlNPTEVfU0xFRVA9eQpDT05GSUdfSFdf Q09OU09MRT15CkNPTkZJR19WVF9IV19DT05TT0xFX0JJTkRJTkc9eQpDT05GSUdfVU5JWDk4X1BU WVM9eQojIENPTkZJR19ERVZQVFNfTVVMVElQTEVfSU5TVEFOQ0VTIGlzIG5vdCBzZXQKIyBDT05G SUdfTEVHQUNZX1BUWVMgaXMgbm90IHNldAojIENPTkZJR19TRVJJQUxfTk9OU1RBTkRBUkQgaXMg bm90IHNldAojIENPTkZJR19OT1pPTUkgaXMgbm90IHNldAojIENPTkZJR19OX0dTTSBpcyBub3Qg c2V0CiMgQ09ORklHX1RSQUNFX1NJTksgaXMgbm90IHNldAoKIwojIEtDb3B5CiMKQ09ORklHX0tD T1BZPW0KQ09ORklHX0RFVktNRU09eQoKIwojIFNlcmlhbCBkcml2ZXJzCiMKQ09ORklHX1NFUklB TF84MjUwPXkKQ09ORklHX1NFUklBTF84MjUwX0RFUFJFQ0FURURfT1BUSU9OUz15CkNPTkZJR19T RVJJQUxfODI1MF9QTlA9eQpDT05GSUdfU0VSSUFMXzgyNTBfQ09OU09MRT15CkNPTkZJR19GSVhf RUFSTFlDT05fTUVNPXkKQ09ORklHX1NFUklBTF84MjUwX0RNQT15CkNPTkZJR19TRVJJQUxfODI1 MF9QQ0k9eQpDT05GSUdfU0VSSUFMXzgyNTBfQ1M9bQpDT05GSUdfU0VSSUFMXzgyNTBfTlJfVUFS VFM9NApDT05GSUdfU0VSSUFMXzgyNTBfUlVOVElNRV9VQVJUUz00CkNPTkZJR19TRVJJQUxfODI1 MF9FWFRFTkRFRD15CkNPTkZJR19TRVJJQUxfODI1MF9NQU5ZX1BPUlRTPXkKQ09ORklHX1NFUklB TF84MjUwX1NIQVJFX0lSUT15CiMgQ09ORklHX1NFUklBTF84MjUwX0RFVEVDVF9JUlEgaXMgbm90 IHNldApDT05GSUdfU0VSSUFMXzgyNTBfUlNBPXkKIyBDT05GSUdfU0VSSUFMXzgyNTBfRFcgaXMg bm90IHNldAoKIwojIE5vbi04MjUwIHNlcmlhbCBwb3J0IHN1cHBvcnQKIwojIENPTkZJR19TRVJJ QUxfTUZEX0hTVSBpcyBub3Qgc2V0CkNPTkZJR19TRVJJQUxfQ09SRT15CkNPTkZJR19TRVJJQUxf Q09SRV9DT05TT0xFPXkKIyBDT05GSUdfU0VSSUFMX0pTTSBpcyBub3Qgc2V0CiMgQ09ORklHX1NF UklBTF9TQ0NOWFAgaXMgbm90IHNldAojIENPTkZJR19TRVJJQUxfVElNQkVSREFMRSBpcyBub3Qg c2V0CiMgQ09ORklHX1NFUklBTF9BTFRFUkFfSlRBR1VBUlQgaXMgbm90IHNldAojIENPTkZJR19T RVJJQUxfQUxURVJBX1VBUlQgaXMgbm90IHNldAojIENPTkZJR19TRVJJQUxfUENIX1VBUlQgaXMg bm90IHNldAojIENPTkZJR19TRVJJQUxfQVJDIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VSSUFMX1JQ MiBpcyBub3Qgc2V0CiMgQ09ORklHX1NFUklBTF9GU0xfTFBVQVJUIGlzIG5vdCBzZXQKIyBDT05G SUdfU0VSSUFMX1NUX0FTQyBpcyBub3Qgc2V0CkNPTkZJR19IVkNfRFJJVkVSPXkKQ09ORklHX0hW Q19JUlE9eQpDT05GSUdfSFZDX1hFTj15CkNPTkZJR19IVkNfWEVOX0ZST05URU5EPXkKIyBDT05G SUdfSVBNSV9IQU5ETEVSIGlzIG5vdCBzZXQKQ09ORklHX0hXX1JBTkRPTT15CiMgQ09ORklHX0hX X1JBTkRPTV9USU1FUklPTUVNIGlzIG5vdCBzZXQKQ09ORklHX0hXX1JBTkRPTV9JTlRFTD15CiMg Q09ORklHX0hXX1JBTkRPTV9BTUQgaXMgbm90IHNldAojIENPTkZJR19IV19SQU5ET01fQVRNRUwg aXMgbm90IHNldAojIENPTkZJR19IV19SQU5ET01fVklBIGlzIG5vdCBzZXQKIyBDT05GSUdfSFdf UkFORE9NX0VYWU5PUyBpcyBub3Qgc2V0CkNPTkZJR19OVlJBTT1tCiMgQ09ORklHX1IzOTY0IGlz IG5vdCBzZXQKIyBDT05GSUdfQVBQTElDT00gaXMgbm90IHNldAoKIwojIFBDTUNJQSBjaGFyYWN0 ZXIgZGV2aWNlcwojCiMgQ09ORklHX1NZTkNMSU5LX0NTIGlzIG5vdCBzZXQKIyBDT05GSUdfQ0FS RE1BTl80MDAwIGlzIG5vdCBzZXQKIyBDT05GSUdfQ0FSRE1BTl80MDQwIGlzIG5vdCBzZXQKIyBD T05GSUdfSVBXSVJFTEVTUyBpcyBub3Qgc2V0CkNPTkZJR19NV0FWRT1tCiMgQ09ORklHX1JBV19E UklWRVIgaXMgbm90IHNldAojIENPTkZJR19IUEVUIGlzIG5vdCBzZXQKIyBDT05GSUdfSEFOR0NI RUNLX1RJTUVSIGlzIG5vdCBzZXQKIyBDT05GSUdfVENHX1RQTSBpcyBub3Qgc2V0CiMgQ09ORklH X1RFTENMT0NLIGlzIG5vdCBzZXQKQ09ORklHX0RFVlBPUlQ9eQpDT05GSUdfSTJDPXkKQ09ORklH X0kyQ19CT0FSRElORk89eQojIENPTkZJR19JMkNfQ09NUEFUIGlzIG5vdCBzZXQKQ09ORklHX0ky Q19DSEFSREVWPW0KIyBDT05GSUdfSTJDX01VWCBpcyBub3Qgc2V0CiMgQ09ORklHX0kyQ19IRUxQ RVJfQVVUTyBpcyBub3Qgc2V0CiMgQ09ORklHX0kyQ19TTUJVUyBpcyBub3Qgc2V0CgojCiMgSTJD IEFsZ29yaXRobXMKIwpDT05GSUdfSTJDX0FMR09CSVQ9eQojIENPTkZJR19JMkNfQUxHT1BDRiBp cyBub3Qgc2V0CiMgQ09ORklHX0kyQ19BTEdPUENBIGlzIG5vdCBzZXQKCiMKIyBJMkMgSGFyZHdh cmUgQnVzIHN1cHBvcnQKIwoKIwojIFBDIFNNQnVzIGhvc3QgY29udHJvbGxlciBkcml2ZXJzCiMK Q09ORklHX0kyQ19BTEkxNTM1PW0KQ09ORklHX0kyQ19BTEkxNTYzPW0KQ09ORklHX0kyQ19BTEkx NVgzPW0KQ09ORklHX0kyQ19BTUQ3NTY9bQpDT05GSUdfSTJDX0FNRDc1Nl9TNDg4Mj1tCkNPTkZJ R19JMkNfQU1EODExMT1tCkNPTkZJR19JMkNfSTgwMT1tCiMgQ09ORklHX0kyQ19JU0NIIGlzIG5v dCBzZXQKIyBDT05GSUdfSTJDX0lTTVQgaXMgbm90IHNldApDT05GSUdfSTJDX1BJSVg0PW0KQ09O RklHX0kyQ19ORk9SQ0UyPW0KIyBDT05GSUdfSTJDX05GT1JDRTJfUzQ5ODUgaXMgbm90IHNldApD T05GSUdfSTJDX1NJUzU1OTU9bQpDT05GSUdfSTJDX1NJUzYzMD1tCkNPTkZJR19JMkNfU0lTOTZY PW0KQ09ORklHX0kyQ19WSUE9bQpDT05GSUdfSTJDX1ZJQVBSTz1tCgojCiMgQUNQSSBkcml2ZXJz CiMKIyBDT05GSUdfSTJDX1NDTUkgaXMgbm90IHNldAoKIwojIEkyQyBzeXN0ZW0gYnVzIGRyaXZl cnMgKG1vc3RseSBlbWJlZGRlZCAvIHN5c3RlbS1vbi1jaGlwKQojCiMgQ09ORklHX0kyQ19ERVNJ R05XQVJFX1BMQVRGT1JNIGlzIG5vdCBzZXQKIyBDT05GSUdfSTJDX0RFU0lHTldBUkVfUENJIGlz IG5vdCBzZXQKIyBDT05GSUdfSTJDX0VHMjBUIGlzIG5vdCBzZXQKQ09ORklHX0kyQ19PQ09SRVM9 bQojIENPTkZJR19JMkNfUENBX1BMQVRGT1JNIGlzIG5vdCBzZXQKIyBDT05GSUdfSTJDX1BYQV9Q Q0kgaXMgbm90IHNldApDT05GSUdfSTJDX1NJTVRFQz1tCiMgQ09ORklHX0kyQ19YSUxJTlggaXMg bm90IHNldAoKIwojIEV4dGVybmFsIEkyQy9TTUJ1cyBhZGFwdGVyIGRyaXZlcnMKIwojIENPTkZJ R19JMkNfRElPTEFOX1UyQyBpcyBub3Qgc2V0CiMgQ09ORklHX0kyQ19QQVJQT1JUX0xJR0hUIGlz IG5vdCBzZXQKQ09ORklHX0kyQ19UQU9TX0VWTT1tCkNPTkZJR19JMkNfVElOWV9VU0I9bQoKIwoj IE90aGVyIEkyQy9TTUJ1cyBidXMgZHJpdmVycwojCiMgQ09ORklHX0kyQ19TVFVCIGlzIG5vdCBz ZXQKIyBDT05GSUdfSTJDX0RFQlVHX0NPUkUgaXMgbm90IHNldAojIENPTkZJR19JMkNfREVCVUdf QUxHTyBpcyBub3Qgc2V0CiMgQ09ORklHX0kyQ19ERUJVR19CVVMgaXMgbm90IHNldAojIENPTkZJ R19TUEkgaXMgbm90IHNldAojIENPTkZJR19IU0kgaXMgbm90IHNldAoKIwojIFBQUyBzdXBwb3J0 CiMKQ09ORklHX1BQUz1tCiMgQ09ORklHX1BQU19ERUJVRyBpcyBub3Qgc2V0CgojCiMgUFBTIGNs aWVudHMgc3VwcG9ydAojCiMgQ09ORklHX1BQU19DTElFTlRfS1RJTUVSIGlzIG5vdCBzZXQKIyBD T05GSUdfUFBTX0NMSUVOVF9MRElTQyBpcyBub3Qgc2V0CiMgQ09ORklHX1BQU19DTElFTlRfR1BJ TyBpcyBub3Qgc2V0CgojCiMgUFBTIGdlbmVyYXRvcnMgc3VwcG9ydAojCgojCiMgUFRQIGNsb2Nr IHN1cHBvcnQKIwpDT05GSUdfUFRQXzE1ODhfQ0xPQ0s9bQoKIwojIEVuYWJsZSBQSFlMSUIgYW5k IE5FVFdPUktfUEhZX1RJTUVTVEFNUElORyB0byBzZWUgdGhlIGFkZGl0aW9uYWwgY2xvY2tzLgoj CiMgQ09ORklHX1BUUF8xNTg4X0NMT0NLX1BDSCBpcyBub3Qgc2V0CkNPTkZJR19QSU5DVFJMPXkK CiMKIyBQaW4gY29udHJvbGxlcnMKIwojIENPTkZJR19QSU5NVVggaXMgbm90IHNldAojIENPTkZJ R19QSU5DT05GIGlzIG5vdCBzZXQKIyBDT05GSUdfREVCVUdfUElOQ1RSTCBpcyBub3Qgc2V0CkNP TkZJR19BUkNIX1dBTlRfT1BUSU9OQUxfR1BJT0xJQj15CkNPTkZJR19HUElPX0RFVlJFUz15CiMg Q09ORklHX0dQSU9MSUIgaXMgbm90IHNldAojIENPTkZJR19XMSBpcyBub3Qgc2V0CkNPTkZJR19Q T1dFUl9TVVBQTFk9eQojIENPTkZJR19QT1dFUl9TVVBQTFlfREVCVUcgaXMgbm90IHNldAojIENP TkZJR19QREFfUE9XRVIgaXMgbm90IHNldAojIENPTkZJR19URVNUX1BPV0VSIGlzIG5vdCBzZXQK IyBDT05GSUdfQkFUVEVSWV9EUzI3ODAgaXMgbm90IHNldAojIENPTkZJR19CQVRURVJZX0RTMjc4 MSBpcyBub3Qgc2V0CiMgQ09ORklHX0JBVFRFUllfRFMyNzgyIGlzIG5vdCBzZXQKIyBDT05GSUdf QkFUVEVSWV9TQlMgaXMgbm90IHNldAojIENPTkZJR19CQVRURVJZX0JRMjd4MDAgaXMgbm90IHNl dAojIENPTkZJR19CQVRURVJZX01BWDE3MDQwIGlzIG5vdCBzZXQKIyBDT05GSUdfQkFUVEVSWV9N QVgxNzA0MiBpcyBub3Qgc2V0CiMgQ09ORklHX0NIQVJHRVJfTUFYODkwMyBpcyBub3Qgc2V0CiMg Q09ORklHX0NIQVJHRVJfTFA4NzI3IGlzIG5vdCBzZXQKIyBDT05GSUdfQ0hBUkdFUl9CUTI0MTVY IGlzIG5vdCBzZXQKIyBDT05GSUdfQ0hBUkdFUl9TTUIzNDcgaXMgbm90IHNldAojIENPTkZJR19Q T1dFUl9SRVNFVCBpcyBub3Qgc2V0CiMgQ09ORklHX1BPV0VSX0FWUyBpcyBub3Qgc2V0CkNPTkZJ R19IV01PTj15CkNPTkZJR19IV01PTl9WSUQ9bQojIENPTkZJR19IV01PTl9ERUJVR19DSElQIGlz IG5vdCBzZXQKCiMKIyBOYXRpdmUgZHJpdmVycwojCkNPTkZJR19TRU5TT1JTX0FCSVRVR1VSVT1t CkNPTkZJR19TRU5TT1JTX0FCSVRVR1VSVTM9bQojIENPTkZJR19TRU5TT1JTX0FENzQxNCBpcyBu b3Qgc2V0CkNPTkZJR19TRU5TT1JTX0FENzQxOD1tCkNPTkZJR19TRU5TT1JTX0FETTEwMjE9bQpD T05GSUdfU0VOU09SU19BRE0xMDI1PW0KQ09ORklHX1NFTlNPUlNfQURNMTAyNj1tCkNPTkZJR19T RU5TT1JTX0FETTEwMjk9bQpDT05GSUdfU0VOU09SU19BRE0xMDMxPW0KQ09ORklHX1NFTlNPUlNf QURNOTI0MD1tCiMgQ09ORklHX1NFTlNPUlNfQURUNzQxMCBpcyBub3Qgc2V0CiMgQ09ORklHX1NF TlNPUlNfQURUNzQxMSBpcyBub3Qgc2V0CiMgQ09ORklHX1NFTlNPUlNfQURUNzQ2MiBpcyBub3Qg c2V0CkNPTkZJR19TRU5TT1JTX0FEVDc0NzA9bQojIENPTkZJR19TRU5TT1JTX0FEVDc0NzUgaXMg bm90IHNldAojIENPTkZJR19TRU5TT1JTX0FTQzc2MjEgaXMgbm90IHNldApDT05GSUdfU0VOU09S U19LOFRFTVA9bQojIENPTkZJR19TRU5TT1JTX0sxMFRFTVAgaXMgbm90IHNldAojIENPTkZJR19T RU5TT1JTX0ZBTTE1SF9QT1dFUiBpcyBub3Qgc2V0CkNPTkZJR19TRU5TT1JTX0FTQjEwMD1tCkNP TkZJR19TRU5TT1JTX0FUWFAxPW0KIyBDT05GSUdfU0VOU09SU19EUzYyMCBpcyBub3Qgc2V0CkNP TkZJR19TRU5TT1JTX0RTMTYyMT1tCkNPTkZJR19TRU5TT1JTX0k1S19BTUI9bQpDT05GSUdfU0VO U09SU19GNzE4MDVGPW0KQ09ORklHX1NFTlNPUlNfRjcxODgyRkc9bQpDT05GSUdfU0VOU09SU19G NzUzNzVTPW0KQ09ORklHX1NFTlNPUlNfRlNDSE1EPW0KIyBDT05GSUdfU0VOU09SU19HNzYwQSBp cyBub3Qgc2V0CiMgQ09ORklHX1NFTlNPUlNfRzc2MiBpcyBub3Qgc2V0CkNPTkZJR19TRU5TT1JT X0dMNTE4U009bQpDT05GSUdfU0VOU09SU19HTDUyMFNNPW0KIyBDT05GSUdfU0VOU09SU19ISUg2 MTMwIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19IVFUyMSBpcyBub3Qgc2V0CkNPTkZJR19T RU5TT1JTX0NPUkVURU1QPW0KQ09ORklHX1NFTlNPUlNfSVQ4Nz1tCiMgQ09ORklHX1NFTlNPUlNf SkM0MiBpcyBub3Qgc2V0CiMgQ09ORklHX1NFTlNPUlNfTElORUFHRSBpcyBub3Qgc2V0CkNPTkZJ R19TRU5TT1JTX0xNNjM9bQojIENPTkZJR19TRU5TT1JTX0xNNzMgaXMgbm90IHNldApDT05GSUdf U0VOU09SU19MTTc1PW0KQ09ORklHX1NFTlNPUlNfTE03Nz1tCkNPTkZJR19TRU5TT1JTX0xNNzg9 bQpDT05GSUdfU0VOU09SU19MTTgwPW0KQ09ORklHX1NFTlNPUlNfTE04Mz1tCkNPTkZJR19TRU5T T1JTX0xNODU9bQpDT05GSUdfU0VOU09SU19MTTg3PW0KQ09ORklHX1NFTlNPUlNfTE05MD1tCkNP TkZJR19TRU5TT1JTX0xNOTI9bQpDT05GSUdfU0VOU09SU19MTTkzPW0KIyBDT05GSUdfU0VOU09S U19MVEM0MTUxIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19MVEM0MjE1IGlzIG5vdCBzZXQK IyBDT05GSUdfU0VOU09SU19MVEM0MjQ1IGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19MVEM0 MjYxIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19MTTk1MjM0IGlzIG5vdCBzZXQKIyBDT05G SUdfU0VOU09SU19MTTk1MjQxIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19MTTk1MjQ1IGlz IG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19NQVgxNjA2NSBpcyBub3Qgc2V0CkNPTkZJR19TRU5T T1JTX01BWDE2MTk9bQojIENPTkZJR19TRU5TT1JTX01BWDE2NjggaXMgbm90IHNldAojIENPTkZJ R19TRU5TT1JTX01BWDE5NyBpcyBub3Qgc2V0CiMgQ09ORklHX1NFTlNPUlNfTUFYNjYzOSBpcyBu b3Qgc2V0CiMgQ09ORklHX1NFTlNPUlNfTUFYNjY0MiBpcyBub3Qgc2V0CkNPTkZJR19TRU5TT1JT X01BWDY2NTA9bQojIENPTkZJR19TRU5TT1JTX01BWDY2OTcgaXMgbm90IHNldAojIENPTkZJR19T RU5TT1JTX01DUDMwMjEgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX05DVDY3NzUgaXMgbm90 IHNldAojIENPTkZJR19TRU5TT1JTX05UQ19USEVSTUlTVE9SIGlzIG5vdCBzZXQKQ09ORklHX1NF TlNPUlNfUEM4NzM2MD1tCkNPTkZJR19TRU5TT1JTX1BDODc0Mjc9bQpDT05GSUdfU0VOU09SU19Q Q0Y4NTkxPW0KIyBDT05GSUdfUE1CVVMgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX1NIVDIx IGlzIG5vdCBzZXQKQ09ORklHX1NFTlNPUlNfU0lTNTU5NT1tCiMgQ09ORklHX1NFTlNPUlNfU01N NjY1IGlzIG5vdCBzZXQKQ09ORklHX1NFTlNPUlNfRE1FMTczNz1tCiMgQ09ORklHX1NFTlNPUlNf RU1DMTQwMyBpcyBub3Qgc2V0CiMgQ09ORklHX1NFTlNPUlNfRU1DMjEwMyBpcyBub3Qgc2V0CiMg Q09ORklHX1NFTlNPUlNfRU1DNlcyMDEgaXMgbm90IHNldApDT05GSUdfU0VOU09SU19TTVNDNDdN MT1tCkNPTkZJR19TRU5TT1JTX1NNU0M0N00xOTI9bQpDT05GSUdfU0VOU09SU19TTVNDNDdCMzk3 PW0KIyBDT05GSUdfU0VOU09SU19TQ0g1NlhYX0NPTU1PTiBpcyBub3Qgc2V0CiMgQ09ORklHX1NF TlNPUlNfQURTMTAxNSBpcyBub3Qgc2V0CiMgQ09ORklHX1NFTlNPUlNfQURTNzgyOCBpcyBub3Qg c2V0CiMgQ09ORklHX1NFTlNPUlNfQU1DNjgyMSBpcyBub3Qgc2V0CiMgQ09ORklHX1NFTlNPUlNf SU5BMjA5IGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19JTkEyWFggaXMgbm90IHNldApDT05G SUdfU0VOU09SU19USE1DNTA9bQojIENPTkZJR19TRU5TT1JTX1RNUDEwMiBpcyBub3Qgc2V0CiMg Q09ORklHX1NFTlNPUlNfVE1QNDAxIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19UTVA0MjEg aXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX1ZJQV9DUFVURU1QIGlzIG5vdCBzZXQKQ09ORklH X1NFTlNPUlNfVklBNjg2QT1tCkNPTkZJR19TRU5TT1JTX1ZUMTIxMT1tCkNPTkZJR19TRU5TT1JT X1ZUODIzMT1tCkNPTkZJR19TRU5TT1JTX1c4Mzc4MUQ9bQpDT05GSUdfU0VOU09SU19XODM3OTFE PW0KQ09ORklHX1NFTlNPUlNfVzgzNzkyRD1tCkNPTkZJR19TRU5TT1JTX1c4Mzc5Mz1tCiMgQ09O RklHX1NFTlNPUlNfVzgzNzk1IGlzIG5vdCBzZXQKQ09ORklHX1NFTlNPUlNfVzgzTDc4NVRTPW0K IyBDT05GSUdfU0VOU09SU19XODNMNzg2TkcgaXMgbm90IHNldApDT05GSUdfU0VOU09SU19XODM2 MjdIRj1tCkNPTkZJR19TRU5TT1JTX1c4MzYyN0VIRj1tCkNPTkZJR19TRU5TT1JTX0FQUExFU01D PW0KCiMKIyBBQ1BJIGRyaXZlcnMKIwojIENPTkZJR19TRU5TT1JTX0FDUElfUE9XRVIgaXMgbm90 IHNldAojIENPTkZJR19TRU5TT1JTX0FUSzAxMTAgaXMgbm90IHNldApDT05GSUdfVEhFUk1BTD15 CiMgQ09ORklHX1RIRVJNQUxfSFdNT04gaXMgbm90IHNldApDT05GSUdfVEhFUk1BTF9ERUZBVUxU X0dPVl9TVEVQX1dJU0U9eQojIENPTkZJR19USEVSTUFMX0RFRkFVTFRfR09WX0ZBSVJfU0hBUkUg aXMgbm90IHNldAojIENPTkZJR19USEVSTUFMX0RFRkFVTFRfR09WX1VTRVJfU1BBQ0UgaXMgbm90 IHNldAojIENPTkZJR19USEVSTUFMX0dPVl9GQUlSX1NIQVJFIGlzIG5vdCBzZXQKQ09ORklHX1RI RVJNQUxfR09WX1NURVBfV0lTRT15CkNPTkZJR19USEVSTUFMX0dPVl9VU0VSX1NQQUNFPXkKIyBD T05GSUdfQ1BVX1RIRVJNQUwgaXMgbm90IHNldAojIENPTkZJR19USEVSTUFMX0VNVUxBVElPTiBp cyBub3Qgc2V0CiMgQ09ORklHX0lOVEVMX1BPV0VSQ0xBTVAgaXMgbm90IHNldApDT05GSUdfWDg2 X1BLR19URU1QX1RIRVJNQUw9bQoKIwojIFRleGFzIEluc3RydW1lbnRzIHRoZXJtYWwgZHJpdmVy cwojCiMgQ09ORklHX1dBVENIRE9HIGlzIG5vdCBzZXQKQ09ORklHX1NTQl9QT1NTSUJMRT15Cgoj CiMgU29uaWNzIFNpbGljb24gQmFja3BsYW5lCiMKQ09ORklHX1NTQj1tCkNPTkZJR19TU0JfU1BS T009eQpDT05GSUdfU1NCX1BDSUhPU1RfUE9TU0lCTEU9eQpDT05GSUdfU1NCX1BDSUhPU1Q9eQoj IENPTkZJR19TU0JfQjQzX1BDSV9CUklER0UgaXMgbm90IHNldApDT05GSUdfU1NCX1BDTUNJQUhP U1RfUE9TU0lCTEU9eQpDT05GSUdfU1NCX1BDTUNJQUhPU1Q9eQpDT05GSUdfU1NCX1NESU9IT1NU X1BPU1NJQkxFPXkKIyBDT05GSUdfU1NCX1NESU9IT1NUIGlzIG5vdCBzZXQKIyBDT05GSUdfU1NC X0RFQlVHIGlzIG5vdCBzZXQKQ09ORklHX1NTQl9EUklWRVJfUENJQ09SRV9QT1NTSUJMRT15CkNP TkZJR19TU0JfRFJJVkVSX1BDSUNPUkU9eQpDT05GSUdfQkNNQV9QT1NTSUJMRT15CgojCiMgQnJv YWRjb20gc3BlY2lmaWMgQU1CQQojCiMgQ09ORklHX0JDTUEgaXMgbm90IHNldAoKIwojIE11bHRp ZnVuY3Rpb24gZGV2aWNlIGRyaXZlcnMKIwojIENPTkZJR19NRkRfQ09SRSBpcyBub3Qgc2V0CiMg Q09ORklHX01GRF9DUzU1MzUgaXMgbm90IHNldAojIENPTkZJR19NRkRfQVMzNzExIGlzIG5vdCBz ZXQKIyBDT05GSUdfUE1JQ19BRFA1NTIwIGlzIG5vdCBzZXQKIyBDT05GSUdfTUZEX0NST1NfRUMg aXMgbm90IHNldAojIENPTkZJR19QTUlDX0RBOTAzWCBpcyBub3Qgc2V0CiMgQ09ORklHX01GRF9E QTkwNTJfSTJDIGlzIG5vdCBzZXQKIyBDT05GSUdfTUZEX0RBOTA1NSBpcyBub3Qgc2V0CiMgQ09O RklHX01GRF9EQTkwNjMgaXMgbm90IHNldAojIENPTkZJR19NRkRfTUMxM1hYWF9JMkMgaXMgbm90 IHNldAojIENPTkZJR19IVENfUEFTSUMzIGlzIG5vdCBzZXQKIyBDT05GSUdfTFBDX0lDSCBpcyBu b3Qgc2V0CiMgQ09ORklHX0xQQ19TQ0ggaXMgbm90IHNldAojIENPTkZJR19NRkRfSkFOWl9DTU9E SU8gaXMgbm90IHNldAojIENPTkZJR19NRkRfS0VNUExEIGlzIG5vdCBzZXQKIyBDT05GSUdfTUZE Xzg4UE04MDAgaXMgbm90IHNldAojIENPTkZJR19NRkRfODhQTTgwNSBpcyBub3Qgc2V0CiMgQ09O RklHX01GRF84OFBNODYwWCBpcyBub3Qgc2V0CiMgQ09ORklHX01GRF9NQVg3NzY4NiBpcyBub3Qg c2V0CiMgQ09ORklHX01GRF9NQVg3NzY5MyBpcyBub3Qgc2V0CiMgQ09ORklHX01GRF9NQVg4OTA3 IGlzIG5vdCBzZXQKIyBDT05GSUdfTUZEX01BWDg5MjUgaXMgbm90IHNldAojIENPTkZJR19NRkRf TUFYODk5NyBpcyBub3Qgc2V0CiMgQ09ORklHX01GRF9NQVg4OTk4IGlzIG5vdCBzZXQKIyBDT05G SUdfTUZEX1ZJUEVSQk9BUkQgaXMgbm90IHNldAojIENPTkZJR19NRkRfUkVUVSBpcyBub3Qgc2V0 CiMgQ09ORklHX01GRF9QQ0Y1MDYzMyBpcyBub3Qgc2V0CiMgQ09ORklHX01GRF9SREMzMjFYIGlz IG5vdCBzZXQKIyBDT05GSUdfTUZEX1JUU1hfUENJIGlzIG5vdCBzZXQKIyBDT05GSUdfTUZEX1JD NVQ1ODMgaXMgbm90IHNldAojIENPTkZJR19NRkRfU0VDX0NPUkUgaXMgbm90IHNldAojIENPTkZJ R19NRkRfU0k0NzZYX0NPUkUgaXMgbm90IHNldApDT05GSUdfTUZEX1NNNTAxPW0KIyBDT05GSUdf TUZEX1NNU0MgaXMgbm90IHNldAojIENPTkZJR19BQlg1MDBfQ09SRSBpcyBub3Qgc2V0CiMgQ09O RklHX01GRF9TVE1QRSBpcyBub3Qgc2V0CiMgQ09ORklHX01GRF9TWVNDT04gaXMgbm90IHNldAoj IENPTkZJR19NRkRfVElfQU0zMzVYX1RTQ0FEQyBpcyBub3Qgc2V0CiMgQ09ORklHX01GRF9MUDg3 ODggaXMgbm90IHNldAojIENPTkZJR19NRkRfUEFMTUFTIGlzIG5vdCBzZXQKIyBDT05GSUdfVFBT NjEwNVggaXMgbm90IHNldAojIENPTkZJR19UUFM2NTA3WCBpcyBub3Qgc2V0CiMgQ09ORklHX01G RF9UUFM2NTA5MCBpcyBub3Qgc2V0CiMgQ09ORklHX01GRF9UUFM2NTIxNyBpcyBub3Qgc2V0CiMg Q09ORklHX01GRF9UUFM2NTg2WCBpcyBub3Qgc2V0CiMgQ09ORklHX01GRF9UUFM4MDAzMSBpcyBu b3Qgc2V0CiMgQ09ORklHX1RXTDQwMzBfQ09SRSBpcyBub3Qgc2V0CiMgQ09ORklHX1RXTDYwNDBf Q09SRSBpcyBub3Qgc2V0CiMgQ09ORklHX01GRF9XTDEyNzNfQ09SRSBpcyBub3Qgc2V0CiMgQ09O RklHX01GRF9MTTM1MzMgaXMgbm90IHNldAojIENPTkZJR19NRkRfVEMzNTg5WCBpcyBub3Qgc2V0 CiMgQ09ORklHX01GRF9UTUlPIGlzIG5vdCBzZXQKIyBDT05GSUdfTUZEX1ZYODU1IGlzIG5vdCBz ZXQKIyBDT05GSUdfTUZEX0FSSVpPTkFfSTJDIGlzIG5vdCBzZXQKIyBDT05GSUdfTUZEX1dNODQw MCBpcyBub3Qgc2V0CiMgQ09ORklHX01GRF9XTTgzMVhfSTJDIGlzIG5vdCBzZXQKIyBDT05GSUdf TUZEX1dNODM1MF9JMkMgaXMgbm90IHNldAojIENPTkZJR19NRkRfV004OTk0IGlzIG5vdCBzZXQK IyBDT05GSUdfUkVHVUxBVE9SIGlzIG5vdCBzZXQKIyBDT05GSUdfTUVESUFfU1VQUE9SVCBpcyBu b3Qgc2V0CgojCiMgR3JhcGhpY3Mgc3VwcG9ydAojCkNPTkZJR19BR1A9eQpDT05GSUdfQUdQX0FN RDY0PW0KQ09ORklHX0FHUF9JTlRFTD15CiMgQ09ORklHX0FHUF9TSVMgaXMgbm90IHNldAojIENP TkZJR19BR1BfVklBIGlzIG5vdCBzZXQKQ09ORklHX1ZHQV9BUkI9eQpDT05GSUdfVkdBX0FSQl9N QVhfR1BVUz0xNgojIENPTkZJR19WR0FfU1dJVENIRVJPTyBpcyBub3Qgc2V0CkNPTkZJR19EUk09 eQpDT05GSUdfRFJNX0tNU19IRUxQRVI9eQpDT05GSUdfRFJNX0xPQURfRURJRF9GSVJNV0FSRT15 CgojCiMgSTJDIGVuY29kZXIgb3IgaGVscGVyIGNoaXBzCiMKIyBDT05GSUdfRFJNX0kyQ19DSDcw MDYgaXMgbm90IHNldAojIENPTkZJR19EUk1fSTJDX1NJTDE2NCBpcyBub3Qgc2V0CiMgQ09ORklH X0RSTV9JMkNfTlhQX1REQTk5OFggaXMgbm90IHNldAojIENPTkZJR19EUk1fVERGWCBpcyBub3Qg c2V0CiMgQ09ORklHX0RSTV9SMTI4IGlzIG5vdCBzZXQKIyBDT05GSUdfRFJNX1JBREVPTiBpcyBu b3Qgc2V0CiMgQ09ORklHX0RSTV9OT1VWRUFVIGlzIG5vdCBzZXQKQ09ORklHX0RSTV9JOTE1PXkK Q09ORklHX0RSTV9JOTE1X0tNUz15CkNPTkZJR19EUk1fSTkxNV9QUkVMSU1JTkFSWV9IV19TVVBQ T1JUPXkKIyBDT05GSUdfRFJNX01HQSBpcyBub3Qgc2V0CiMgQ09ORklHX0RSTV9TSVMgaXMgbm90 IHNldAojIENPTkZJR19EUk1fVklBIGlzIG5vdCBzZXQKIyBDT05GSUdfRFJNX1NBVkFHRSBpcyBu b3Qgc2V0CiMgQ09ORklHX0RSTV9WTVdHRlggaXMgbm90IHNldAojIENPTkZJR19EUk1fR01BNTAw IGlzIG5vdCBzZXQKIyBDT05GSUdfRFJNX1VETCBpcyBub3Qgc2V0CiMgQ09ORklHX0RSTV9BU1Qg aXMgbm90IHNldAojIENPTkZJR19EUk1fTUdBRzIwMCBpcyBub3Qgc2V0CiMgQ09ORklHX0RSTV9D SVJSVVNfUUVNVSBpcyBub3Qgc2V0CiMgQ09ORklHX0RSTV9RWEwgaXMgbm90IHNldAojIENPTkZJ R19WR0FTVEFURSBpcyBub3Qgc2V0CkNPTkZJR19WSURFT19PVVRQVVRfQ09OVFJPTD15CkNPTkZJ R19IRE1JPXkKQ09ORklHX0ZCPXkKQ09ORklHX0ZJUk1XQVJFX0VESUQ9eQojIENPTkZJR19GQl9E REMgaXMgbm90IHNldApDT05GSUdfRkJfQk9PVF9WRVNBX1NVUFBPUlQ9eQpDT05GSUdfRkJfQ0ZC X0ZJTExSRUNUPXkKQ09ORklHX0ZCX0NGQl9DT1BZQVJFQT15CkNPTkZJR19GQl9DRkJfSU1BR0VC TElUPXkKIyBDT05GSUdfRkJfQ0ZCX1JFVl9QSVhFTFNfSU5fQllURSBpcyBub3Qgc2V0CkNPTkZJ R19GQl9TWVNfRklMTFJFQ1Q9eQpDT05GSUdfRkJfU1lTX0NPUFlBUkVBPXkKQ09ORklHX0ZCX1NZ U19JTUFHRUJMSVQ9eQojIENPTkZJR19GQl9GT1JFSUdOX0VORElBTiBpcyBub3Qgc2V0CkNPTkZJ R19GQl9TWVNfRk9QUz15CkNPTkZJR19GQl9ERUZFUlJFRF9JTz15CiMgQ09ORklHX0ZCX1NWR0FM SUIgaXMgbm90IHNldAojIENPTkZJR19GQl9NQUNNT0RFUyBpcyBub3Qgc2V0CiMgQ09ORklHX0ZC X0JBQ0tMSUdIVCBpcyBub3Qgc2V0CiMgQ09ORklHX0ZCX01PREVfSEVMUEVSUyBpcyBub3Qgc2V0 CiMgQ09ORklHX0ZCX1RJTEVCTElUVElORyBpcyBub3Qgc2V0CgojCiMgRnJhbWUgYnVmZmVyIGhh cmR3YXJlIGRyaXZlcnMKIwojIENPTkZJR19GQl9DSVJSVVMgaXMgbm90IHNldAojIENPTkZJR19G Ql9QTTIgaXMgbm90IHNldAojIENPTkZJR19GQl9DWUJFUjIwMDAgaXMgbm90IHNldAojIENPTkZJ R19GQl9BUkMgaXMgbm90IHNldAojIENPTkZJR19GQl9BU0lMSUFOVCBpcyBub3Qgc2V0CiMgQ09O RklHX0ZCX0lNU1RUIGlzIG5vdCBzZXQKIyBDT05GSUdfRkJfVkdBMTYgaXMgbm90IHNldAojIENP TkZJR19GQl9VVkVTQSBpcyBub3Qgc2V0CkNPTkZJR19GQl9WRVNBPXkKQ09ORklHX0ZCX0VGST15 CiMgQ09ORklHX0ZCX040MTEgaXMgbm90IHNldAojIENPTkZJR19GQl9IR0EgaXMgbm90IHNldAoj IENPTkZJR19GQl9TMUQxM1hYWCBpcyBub3Qgc2V0CiMgQ09ORklHX0ZCX05WSURJQSBpcyBub3Qg c2V0CiMgQ09ORklHX0ZCX1JJVkEgaXMgbm90IHNldAojIENPTkZJR19GQl9JNzQwIGlzIG5vdCBz ZXQKIyBDT05GSUdfRkJfTEU4MDU3OCBpcyBub3Qgc2V0CiMgQ09ORklHX0ZCX01BVFJPWCBpcyBu b3Qgc2V0CiMgQ09ORklHX0ZCX1JBREVPTiBpcyBub3Qgc2V0CiMgQ09ORklHX0ZCX0FUWTEyOCBp cyBub3Qgc2V0CiMgQ09ORklHX0ZCX0FUWSBpcyBub3Qgc2V0CiMgQ09ORklHX0ZCX1MzIGlzIG5v dCBzZXQKIyBDT05GSUdfRkJfU0FWQUdFIGlzIG5vdCBzZXQKIyBDT05GSUdfRkJfU0lTIGlzIG5v dCBzZXQKIyBDT05GSUdfRkJfVklBIGlzIG5vdCBzZXQKIyBDT05GSUdfRkJfTkVPTUFHSUMgaXMg bm90IHNldAojIENPTkZJR19GQl9LWVJPIGlzIG5vdCBzZXQKIyBDT05GSUdfRkJfM0RGWCBpcyBu b3Qgc2V0CiMgQ09ORklHX0ZCX1ZPT0RPTzEgaXMgbm90IHNldAojIENPTkZJR19GQl9WVDg2MjMg aXMgbm90IHNldAojIENPTkZJR19GQl9UUklERU5UIGlzIG5vdCBzZXQKIyBDT05GSUdfRkJfQVJL IGlzIG5vdCBzZXQKIyBDT05GSUdfRkJfUE0zIGlzIG5vdCBzZXQKIyBDT05GSUdfRkJfQ0FSTUlO RSBpcyBub3Qgc2V0CiMgQ09ORklHX0ZCX1NNNTAxIGlzIG5vdCBzZXQKIyBDT05GSUdfRkJfU01T Q1VGWCBpcyBub3Qgc2V0CiMgQ09ORklHX0ZCX1VETCBpcyBub3Qgc2V0CiMgQ09ORklHX0ZCX0dP TERGSVNIIGlzIG5vdCBzZXQKIyBDT05GSUdfRkJfVklSVFVBTCBpcyBub3Qgc2V0CkNPTkZJR19Y RU5fRkJERVZfRlJPTlRFTkQ9eQojIENPTkZJR19GQl9NRVRST05PTUUgaXMgbm90IHNldAojIENP TkZJR19GQl9NQjg2MlhYIGlzIG5vdCBzZXQKIyBDT05GSUdfRkJfQlJPQURTSEVFVCBpcyBub3Qg c2V0CiMgQ09ORklHX0ZCX0FVT19LMTkwWCBpcyBub3Qgc2V0CiMgQ09ORklHX0ZCX1NJTVBMRSBp cyBub3Qgc2V0CiMgQ09ORklHX0VYWU5PU19WSURFTyBpcyBub3Qgc2V0CkNPTkZJR19CQUNLTElH SFRfTENEX1NVUFBPUlQ9eQpDT05GSUdfTENEX0NMQVNTX0RFVklDRT1tCiMgQ09ORklHX0xDRF9Q TEFURk9STSBpcyBub3Qgc2V0CkNPTkZJR19CQUNLTElHSFRfQ0xBU1NfREVWSUNFPXkKQ09ORklH X0JBQ0tMSUdIVF9HRU5FUklDPW0KIyBDT05GSUdfQkFDS0xJR0hUX0FQUExFIGlzIG5vdCBzZXQK IyBDT05GSUdfQkFDS0xJR0hUX1NBSEFSQSBpcyBub3Qgc2V0CiMgQ09ORklHX0JBQ0tMSUdIVF9B RFA4ODYwIGlzIG5vdCBzZXQKIyBDT05GSUdfQkFDS0xJR0hUX0FEUDg4NzAgaXMgbm90IHNldAoj IENPTkZJR19CQUNLTElHSFRfTE0zNjMwIGlzIG5vdCBzZXQKIyBDT05GSUdfQkFDS0xJR0hUX0xN MzYzOSBpcyBub3Qgc2V0CiMgQ09ORklHX0JBQ0tMSUdIVF9MUDg1NVggaXMgbm90IHNldAojIENP TkZJR19CQUNLTElHSFRfTFY1MjA3TFAgaXMgbm90IHNldAojIENPTkZJR19CQUNLTElHSFRfQkQ2 MTA3IGlzIG5vdCBzZXQKCiMKIyBDb25zb2xlIGRpc3BsYXkgZHJpdmVyIHN1cHBvcnQKIwpDT05G SUdfVkdBX0NPTlNPTEU9eQojIENPTkZJR19WR0FDT05fU09GVF9TQ1JPTExCQUNLIGlzIG5vdCBz ZXQKQ09ORklHX0RVTU1ZX0NPTlNPTEU9eQpDT05GSUdfRlJBTUVCVUZGRVJfQ09OU09MRT15CkNP TkZJR19GUkFNRUJVRkZFUl9DT05TT0xFX0RFVEVDVF9QUklNQVJZPXkKIyBDT05GSUdfRlJBTUVC VUZGRVJfQ09OU09MRV9ST1RBVElPTiBpcyBub3Qgc2V0CiMgQ09ORklHX0ZCX0NPTl9ERUNPUiBp cyBub3Qgc2V0CkNPTkZJR19MT0dPPXkKQ09ORklHX0xPR09fTElOVVhfTU9OTz15CkNPTkZJR19M T0dPX0xJTlVYX1ZHQTE2PXkKQ09ORklHX0xPR09fTElOVVhfQ0xVVDIyND15CkNPTkZJR19TT1VO RD15CkNPTkZJR19TT1VORF9PU1NfQ09SRT15CkNPTkZJR19TT1VORF9PU1NfQ09SRV9QUkVDTEFJ TT15CkNPTkZJR19TTkQ9bQpDT05GSUdfU05EX1RJTUVSPW0KQ09ORklHX1NORF9QQ009bQpDT05G SUdfU05EX0hXREVQPW0KQ09ORklHX1NORF9SQVdNSURJPW0KQ09ORklHX1NORF9DT01QUkVTU19P RkZMT0FEPW0KQ09ORklHX1NORF9KQUNLPXkKQ09ORklHX1NORF9TRVFVRU5DRVI9bQojIENPTkZJ R19TTkRfU0VRX0RVTU1ZIGlzIG5vdCBzZXQKQ09ORklHX1NORF9PU1NFTVVMPXkKQ09ORklHX1NO RF9NSVhFUl9PU1M9bQpDT05GSUdfU05EX1BDTV9PU1M9bQpDT05GSUdfU05EX1BDTV9PU1NfUExV R0lOUz15CkNPTkZJR19TTkRfU0VRVUVOQ0VSX09TUz15CiMgQ09ORklHX1NORF9IUlRJTUVSIGlz IG5vdCBzZXQKQ09ORklHX1NORF9EWU5BTUlDX01JTk9SUz15CkNPTkZJR19TTkRfTUFYX0NBUkRT PTMyCkNPTkZJR19TTkRfU1VQUE9SVF9PTERfQVBJPXkKIyBDT05GSUdfU05EX1ZFUkJPU0VfUFJP Q0ZTIGlzIG5vdCBzZXQKIyBDT05GSUdfU05EX1ZFUkJPU0VfUFJJTlRLIGlzIG5vdCBzZXQKIyBD T05GSUdfU05EX0RFQlVHIGlzIG5vdCBzZXQKQ09ORklHX1NORF9WTUFTVEVSPXkKQ09ORklHX1NO RF9LQ1RMX0pBQ0s9eQpDT05GSUdfU05EX0RNQV9TR0JVRj15CkNPTkZJR19TTkRfUkFXTUlESV9T RVE9bQpDT05GSUdfU05EX09QTDNfTElCX1NFUT1tCiMgQ09ORklHX1NORF9PUEw0X0xJQl9TRVEg aXMgbm90IHNldAojIENPTkZJR19TTkRfU0JBV0VfU0VRIGlzIG5vdCBzZXQKQ09ORklHX1NORF9F TVUxMEsxX1NFUT1tCkNPTkZJR19TTkRfTVBVNDAxX1VBUlQ9bQpDT05GSUdfU05EX09QTDNfTElC PW0KQ09ORklHX1NORF9WWF9MSUI9bQpDT05GSUdfU05EX0FDOTdfQ09ERUM9bQpDT05GSUdfU05E X0RSSVZFUlM9eQojIENPTkZJR19TTkRfUENTUCBpcyBub3Qgc2V0CiMgQ09ORklHX1NORF9EVU1N WSBpcyBub3Qgc2V0CiMgQ09ORklHX1NORF9BTE9PUCBpcyBub3Qgc2V0CiMgQ09ORklHX1NORF9W SVJNSURJIGlzIG5vdCBzZXQKIyBDT05GSUdfU05EX01UUEFWIGlzIG5vdCBzZXQKIyBDT05GSUdf U05EX1NFUklBTF9VMTY1NTAgaXMgbm90IHNldApDT05GSUdfU05EX01QVTQwMT1tCiMgQ09ORklH X1NORF9BQzk3X1BPV0VSX1NBVkUgaXMgbm90IHNldApDT05GSUdfU05EX1NCX0NPTU1PTj1tCkNP TkZJR19TTkRfU0IxNl9EU1A9bQpDT05GSUdfU05EX1BDST15CkNPTkZJR19TTkRfQUQxODg5PW0K Q09ORklHX1NORF9BTFMzMDA9bQpDT05GSUdfU05EX0FMUzQwMDA9bQpDT05GSUdfU05EX0FMSTU0 NTE9bQojIENPTkZJR19TTkRfQVNJSFBJIGlzIG5vdCBzZXQKQ09ORklHX1NORF9BVElJWFA9bQpD T05GSUdfU05EX0FUSUlYUF9NT0RFTT1tCkNPTkZJR19TTkRfQVU4ODEwPW0KQ09ORklHX1NORF9B VTg4MjA9bQpDT05GSUdfU05EX0FVODgzMD1tCiMgQ09ORklHX1NORF9BVzIgaXMgbm90IHNldApD T05GSUdfU05EX0FaVDMzMjg9bQpDT05GSUdfU05EX0JUODdYPW0KIyBDT05GSUdfU05EX0JUODdY X09WRVJDTE9DSyBpcyBub3Qgc2V0CkNPTkZJR19TTkRfQ0EwMTA2PW0KQ09ORklHX1NORF9DTUlQ Q0k9bQojIENPTkZJR19TTkRfT1hZR0VOIGlzIG5vdCBzZXQKQ09ORklHX1NORF9DUzQyODE9bQpD T05GSUdfU05EX0NTNDZYWD1tCkNPTkZJR19TTkRfQ1M0NlhYX05FV19EU1A9eQpDT05GSUdfU05E X0NTNTUzMD1tCiMgQ09ORklHX1NORF9DUzU1MzVBVURJTyBpcyBub3Qgc2V0CiMgQ09ORklHX1NO RF9DVFhGSSBpcyBub3Qgc2V0CkNPTkZJR19TTkRfREFSTEEyMD1tCkNPTkZJR19TTkRfR0lOQTIw PW0KQ09ORklHX1NORF9MQVlMQTIwPW0KQ09ORklHX1NORF9EQVJMQTI0PW0KQ09ORklHX1NORF9H SU5BMjQ9bQpDT05GSUdfU05EX0xBWUxBMjQ9bQpDT05GSUdfU05EX01PTkE9bQpDT05GSUdfU05E X01JQT1tCkNPTkZJR19TTkRfRUNITzNHPW0KQ09ORklHX1NORF9JTkRJR089bQpDT05GSUdfU05E X0lORElHT0lPPW0KQ09ORklHX1NORF9JTkRJR09ESj1tCiMgQ09ORklHX1NORF9JTkRJR09JT1gg aXMgbm90IHNldAojIENPTkZJR19TTkRfSU5ESUdPREpYIGlzIG5vdCBzZXQKQ09ORklHX1NORF9F TVUxMEsxPW0KQ09ORklHX1NORF9FTVUxMEsxWD1tCkNPTkZJR19TTkRfRU5TMTM3MD1tCkNPTkZJ R19TTkRfRU5TMTM3MT1tCkNPTkZJR19TTkRfRVMxOTM4PW0KQ09ORklHX1NORF9FUzE5Njg9bQoj IENPTkZJR19TTkRfRVMxOTY4X0lOUFVUIGlzIG5vdCBzZXQKQ09ORklHX1NORF9GTTgwMT1tCkNP TkZJR19TTkRfSERBX0lOVEVMPW0KQ09ORklHX1NORF9IREFfUFJFQUxMT0NfU0laRT02NApDT05G SUdfU05EX0hEQV9IV0RFUD15CiMgQ09ORklHX1NORF9IREFfUkVDT05GSUcgaXMgbm90IHNldAoj IENPTkZJR19TTkRfSERBX0lOUFVUX0JFRVAgaXMgbm90IHNldAojIENPTkZJR19TTkRfSERBX0lO UFVUX0pBQ0sgaXMgbm90IHNldAojIENPTkZJR19TTkRfSERBX1BBVENIX0xPQURFUiBpcyBub3Qg c2V0CkNPTkZJR19TTkRfSERBX0NPREVDX1JFQUxURUs9eQpDT05GSUdfU05EX0hEQV9DT0RFQ19B TkFMT0c9eQpDT05GSUdfU05EX0hEQV9DT0RFQ19TSUdNQVRFTD15CkNPTkZJR19TTkRfSERBX0NP REVDX1ZJQT15CkNPTkZJR19TTkRfSERBX0NPREVDX0hETUk9eQpDT05GSUdfU05EX0hEQV9JOTE1 PXkKQ09ORklHX1NORF9IREFfQ09ERUNfQ0lSUlVTPXkKQ09ORklHX1NORF9IREFfQ09ERUNfQ09O RVhBTlQ9eQpDT05GSUdfU05EX0hEQV9DT0RFQ19DQTAxMTA9eQpDT05GSUdfU05EX0hEQV9DT0RF Q19DQTAxMzI9eQojIENPTkZJR19TTkRfSERBX0NPREVDX0NBMDEzMl9EU1AgaXMgbm90IHNldApD T05GSUdfU05EX0hEQV9DT0RFQ19DTUVESUE9eQpDT05GSUdfU05EX0hEQV9DT0RFQ19TSTMwNTQ9 eQpDT05GSUdfU05EX0hEQV9HRU5FUklDPXkKQ09ORklHX1NORF9IREFfUE9XRVJfU0FWRV9ERUZB VUxUPTAKQ09ORklHX1NORF9IRFNQPW0KQ09ORklHX1NORF9IRFNQTT1tCkNPTkZJR19TTkRfSUNF MTcxMj1tCkNPTkZJR19TTkRfSUNFMTcyND1tCkNPTkZJR19TTkRfSU5URUw4WDA9bQpDT05GSUdf U05EX0lOVEVMOFgwTT1tCkNPTkZJR19TTkRfS09SRzEyMTI9bQojIENPTkZJR19TTkRfTE9MQSBp cyBub3Qgc2V0CiMgQ09ORklHX1NORF9MWDY0NjRFUyBpcyBub3Qgc2V0CkNPTkZJR19TTkRfTUFF U1RSTzM9bQojIENPTkZJR19TTkRfTUFFU1RSTzNfSU5QVVQgaXMgbm90IHNldApDT05GSUdfU05E X01JWEFSVD1tCkNPTkZJR19TTkRfTk0yNTY9bQpDT05GSUdfU05EX1BDWEhSPW0KQ09ORklHX1NO RF9SSVBUSURFPW0KQ09ORklHX1NORF9STUUzMj1tCkNPTkZJR19TTkRfUk1FOTY9bQpDT05GSUdf U05EX1JNRTk2NTI9bQpDT05GSUdfU05EX1NPTklDVklCRVM9bQpDT05GSUdfU05EX1RSSURFTlQ9 bQpDT05GSUdfU05EX1ZJQTgyWFg9bQpDT05GSUdfU05EX1ZJQTgyWFhfTU9ERU09bQojIENPTkZJ R19TTkRfVklSVFVPU08gaXMgbm90IHNldApDT05GSUdfU05EX1ZYMjIyPW0KQ09ORklHX1NORF9Z TUZQQ0k9bQojIENPTkZJR19TTkRfVVNCIGlzIG5vdCBzZXQKQ09ORklHX1NORF9GSVJFV0lSRT15 CiMgQ09ORklHX1NORF9GSVJFV0lSRV9TUEVBS0VSUyBpcyBub3Qgc2V0CiMgQ09ORklHX1NORF9J U0lHSFQgaXMgbm90IHNldAojIENPTkZJR19TTkRfU0NTMVggaXMgbm90IHNldApDT05GSUdfU05E X1BDTUNJQT15CkNPTkZJR19TTkRfVlhQT0NLRVQ9bQpDT05GSUdfU05EX1BEQVVESU9DRj1tCkNP TkZJR19TTkRfU09DPW0KIyBDT05GSUdfU05EX0FUTUVMX1NPQyBpcyBub3Qgc2V0CiMgQ09ORklH X1NORF9ERVNJR05XQVJFX0kyUyBpcyBub3Qgc2V0CkNPTkZJR19TTkRfU09DX0kyQ19BTkRfU1BJ PW0KIyBDT05GSUdfU05EX1NJTVBMRV9DQVJEIGlzIG5vdCBzZXQKIyBDT05GSUdfU09VTkRfUFJJ TUUgaXMgbm90IHNldApDT05GSUdfQUM5N19CVVM9bQoKIwojIEhJRCBzdXBwb3J0CiMKQ09ORklH X0hJRD15CiMgQ09ORklHX0hJRF9CQVRURVJZX1NUUkVOR1RIIGlzIG5vdCBzZXQKQ09ORklHX0hJ RFJBVz15CiMgQ09ORklHX1VISUQgaXMgbm90IHNldApDT05GSUdfSElEX0dFTkVSSUM9eQoKIwoj IFNwZWNpYWwgSElEIGRyaXZlcnMKIwpDT05GSUdfSElEX0E0VEVDSD15CiMgQ09ORklHX0hJRF9B Q1JVWCBpcyBub3Qgc2V0CkNPTkZJR19ISURfQVBQTEU9eQojIENPTkZJR19ISURfQVBQTEVJUiBp cyBub3Qgc2V0CiMgQ09ORklHX0hJRF9BVVJFQUwgaXMgbm90IHNldApDT05GSUdfSElEX0JFTEtJ Tj15CkNPTkZJR19ISURfQ0hFUlJZPXkKQ09ORklHX0hJRF9DSElDT05ZPXkKIyBDT05GSUdfSElE X1BST0RJS0VZUyBpcyBub3Qgc2V0CkNPTkZJR19ISURfQ1lQUkVTUz15CiMgQ09ORklHX0hJRF9E UkFHT05SSVNFIGlzIG5vdCBzZXQKIyBDT05GSUdfSElEX0VNU19GRiBpcyBub3Qgc2V0CiMgQ09O RklHX0hJRF9FTEVDT00gaXMgbm90IHNldAojIENPTkZJR19ISURfRUxPIGlzIG5vdCBzZXQKQ09O RklHX0hJRF9FWktFWT15CiMgQ09ORklHX0hJRF9IT0xURUsgaXMgbm90IHNldAojIENPTkZJR19I SURfSFVJT04gaXMgbm90IHNldAojIENPTkZJR19ISURfS0VZVE9VQ0ggaXMgbm90IHNldAojIENP TkZJR19ISURfS1lFIGlzIG5vdCBzZXQKIyBDT05GSUdfSElEX1VDTE9HSUMgaXMgbm90IHNldAoj IENPTkZJR19ISURfV0FMVE9QIGlzIG5vdCBzZXQKQ09ORklHX0hJRF9HWVJBVElPTj1tCiMgQ09O RklHX0hJRF9JQ0FERSBpcyBub3Qgc2V0CiMgQ09ORklHX0hJRF9UV0lOSEFOIGlzIG5vdCBzZXQK Q09ORklHX0hJRF9LRU5TSU5HVE9OPXkKIyBDT05GSUdfSElEX0xDUE9XRVIgaXMgbm90IHNldAoj IENPTkZJR19ISURfTEVOT1ZPX1RQS0JEIGlzIG5vdCBzZXQKQ09ORklHX0hJRF9MT0dJVEVDSD15 CiMgQ09ORklHX0hJRF9MT0dJVEVDSF9ESiBpcyBub3Qgc2V0CiMgQ09ORklHX0xPR0lURUNIX0ZG IGlzIG5vdCBzZXQKIyBDT05GSUdfTE9HSVJVTUJMRVBBRDJfRkYgaXMgbm90IHNldAojIENPTkZJ R19MT0dJRzk0MF9GRiBpcyBub3Qgc2V0CiMgQ09ORklHX0xPR0lXSEVFTFNfRkYgaXMgbm90IHNl dAojIENPTkZJR19ISURfTUFHSUNNT1VTRSBpcyBub3Qgc2V0CkNPTkZJR19ISURfTUlDUk9TT0ZU PXkKQ09ORklHX0hJRF9NT05URVJFWT15CiMgQ09ORklHX0hJRF9NVUxUSVRPVUNIIGlzIG5vdCBz ZXQKIyBDT05GSUdfSElEX05UUklHIGlzIG5vdCBzZXQKIyBDT05GSUdfSElEX09SVEVLIGlzIG5v dCBzZXQKQ09ORklHX0hJRF9QQU5USEVSTE9SRD1tCiMgQ09ORklHX1BBTlRIRVJMT1JEX0ZGIGlz IG5vdCBzZXQKQ09ORklHX0hJRF9QRVRBTFlOWD1tCiMgQ09ORklHX0hJRF9QSUNPTENEIGlzIG5v dCBzZXQKIyBDT05GSUdfSElEX1BSSU1BWCBpcyBub3Qgc2V0CiMgQ09ORklHX0hJRF9ST0NDQVQg aXMgbm90IHNldAojIENPTkZJR19ISURfU0FJVEVLIGlzIG5vdCBzZXQKQ09ORklHX0hJRF9TQU1T VU5HPW0KQ09ORklHX0hJRF9TT05ZPW0KIyBDT05GSUdfSElEX1NQRUVETElOSyBpcyBub3Qgc2V0 CiMgQ09ORklHX0hJRF9TVEVFTFNFUklFUyBpcyBub3Qgc2V0CkNPTkZJR19ISURfU1VOUExVUz1t CiMgQ09ORklHX0hJRF9HUkVFTkFTSUEgaXMgbm90IHNldAojIENPTkZJR19ISURfU01BUlRKT1lQ TFVTIGlzIG5vdCBzZXQKIyBDT05GSUdfSElEX1RJVk8gaXMgbm90IHNldAojIENPTkZJR19ISURf VE9QU0VFRCBpcyBub3Qgc2V0CiMgQ09ORklHX0hJRF9USElOR00gaXMgbm90IHNldAojIENPTkZJ R19ISURfVEhSVVNUTUFTVEVSIGlzIG5vdCBzZXQKIyBDT05GSUdfSElEX1dBQ09NIGlzIG5vdCBz ZXQKIyBDT05GSUdfSElEX1dJSU1PVEUgaXMgbm90IHNldAojIENPTkZJR19ISURfWElOTU8gaXMg bm90IHNldAojIENPTkZJR19ISURfWkVST1BMVVMgaXMgbm90IHNldAojIENPTkZJR19ISURfWllE QUNST04gaXMgbm90IHNldAojIENPTkZJR19ISURfU0VOU09SX0hVQiBpcyBub3Qgc2V0CgojCiMg VVNCIEhJRCBzdXBwb3J0CiMKQ09ORklHX1VTQl9ISUQ9bQojIENPTkZJR19ISURfUElEIGlzIG5v dCBzZXQKQ09ORklHX1VTQl9ISURERVY9eQoKIwojIEkyQyBISUQgc3VwcG9ydAojCiMgQ09ORklH X0kyQ19ISUQgaXMgbm90IHNldApDT05GSUdfVVNCX09IQ0lfTElUVExFX0VORElBTj15CkNPTkZJ R19VU0JfU1VQUE9SVD15CkNPTkZJR19VU0JfQ09NTU9OPXkKQ09ORklHX1VTQl9BUkNIX0hBU19I Q0Q9eQpDT05GSUdfVVNCPXkKIyBDT05GSUdfVVNCX0RFQlVHIGlzIG5vdCBzZXQKQ09ORklHX1VT Ql9BTk5PVU5DRV9ORVdfREVWSUNFUz15CgojCiMgTWlzY2VsbGFuZW91cyBVU0Igb3B0aW9ucwoj CkNPTkZJR19VU0JfREVGQVVMVF9QRVJTSVNUPXkKIyBDT05GSUdfVVNCX0RZTkFNSUNfTUlOT1JT IGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX09URyBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9NT04g aXMgbm90IHNldAojIENPTkZJR19VU0JfV1VTQl9DQkFGIGlzIG5vdCBzZXQKCiMKIyBVU0IgSG9z dCBDb250cm9sbGVyIERyaXZlcnMKIwojIENPTkZJR19VU0JfQzY3WDAwX0hDRCBpcyBub3Qgc2V0 CkNPTkZJR19VU0JfWEhDSV9IQ0Q9eQpDT05GSUdfVVNCX0VIQ0lfSENEPXkKIyBDT05GSUdfVVNC X0VIQ0lfUk9PVF9IVUJfVFQgaXMgbm90IHNldAojIENPTkZJR19VU0JfRUhDSV9UVF9ORVdTQ0hF RCBpcyBub3Qgc2V0CkNPTkZJR19VU0JfRUhDSV9QQ0k9eQpDT05GSUdfVVNCX0VIQ0lfSENEX1BM QVRGT1JNPXkKIyBDT05GSUdfVVNCX09YVTIxMEhQX0hDRCBpcyBub3Qgc2V0CkNPTkZJR19VU0Jf SVNQMTE2WF9IQ0Q9bQojIENPTkZJR19VU0JfSVNQMTc2MF9IQ0QgaXMgbm90IHNldAojIENPTkZJ R19VU0JfSVNQMTM2Ml9IQ0QgaXMgbm90IHNldAojIENPTkZJR19VU0JfRlVTQkgyMDBfSENEIGlz IG5vdCBzZXQKIyBDT05GSUdfVVNCX0ZPVEcyMTBfSENEIGlzIG5vdCBzZXQKQ09ORklHX1VTQl9P SENJX0hDRD1tCkNPTkZJR19VU0JfT0hDSV9IQ0RfUENJPW0KQ09ORklHX1VTQl9PSENJX0hDRF9T U0I9eQpDT05GSUdfVVNCX09IQ0lfSENEX1BMQVRGT1JNPW0KQ09ORklHX1VTQl9VSENJX0hDRD1t CiMgQ09ORklHX1VTQl9TTDgxMV9IQ0QgaXMgbm90IHNldAojIENPTkZJR19VU0JfUjhBNjY1OTdf SENEIGlzIG5vdCBzZXQKQ09ORklHX1VTQl9IQ0RfU1NCPW0KIyBDT05GSUdfVVNCX0hDRF9URVNU X01PREUgaXMgbm90IHNldAoKIwojIFVTQiBEZXZpY2UgQ2xhc3MgZHJpdmVycwojCiMgQ09ORklH X1VTQl9BQ00gaXMgbm90IHNldAojIENPTkZJR19VU0JfUFJJTlRFUiBpcyBub3Qgc2V0CiMgQ09O RklHX1VTQl9XRE0gaXMgbm90IHNldAojIENPTkZJR19VU0JfVE1DIGlzIG5vdCBzZXQKCiMKIyBO T1RFOiBVU0JfU1RPUkFHRSBkZXBlbmRzIG9uIFNDU0kgYnV0IEJMS19ERVZfU0QgbWF5CiMKCiMK IyBhbHNvIGJlIG5lZWRlZDsgc2VlIFVTQl9TVE9SQUdFIEhlbHAgZm9yIG1vcmUgaW5mbwojCkNP TkZJR19VU0JfU1RPUkFHRT15CiMgQ09ORklHX1VTQl9TVE9SQUdFX0RFQlVHIGlzIG5vdCBzZXQK IyBDT05GSUdfVVNCX1NUT1JBR0VfUkVBTFRFSyBpcyBub3Qgc2V0CkNPTkZJR19VU0JfU1RPUkFH RV9EQVRBRkFCPW0KQ09ORklHX1VTQl9TVE9SQUdFX0ZSRUVDT009bQpDT05GSUdfVVNCX1NUT1JB R0VfSVNEMjAwPW0KQ09ORklHX1VTQl9TVE9SQUdFX1VTQkFUPW0KQ09ORklHX1VTQl9TVE9SQUdF X1NERFIwOT1tCkNPTkZJR19VU0JfU1RPUkFHRV9TRERSNTU9bQpDT05GSUdfVVNCX1NUT1JBR0Vf SlVNUFNIT1Q9bQpDT05GSUdfVVNCX1NUT1JBR0VfQUxBVURBPW0KIyBDT05GSUdfVVNCX1NUT1JB R0VfT05FVE9VQ0ggaXMgbm90IHNldApDT05GSUdfVVNCX1NUT1JBR0VfS0FSTUE9bQojIENPTkZJ R19VU0JfU1RPUkFHRV9DWVBSRVNTX0FUQUNCIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX1NUT1JB R0VfRU5FX1VCNjI1MCBpcyBub3Qgc2V0CgojCiMgVVNCIEltYWdpbmcgZGV2aWNlcwojCiMgQ09O RklHX1VTQl9NREM4MDAgaXMgbm90IHNldAojIENPTkZJR19VU0JfTUlDUk9URUsgaXMgbm90IHNl dAojIENPTkZJR19VU0JfRFdDMyBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9DSElQSURFQSBpcyBu b3Qgc2V0CgojCiMgVVNCIHBvcnQgZHJpdmVycwojCkNPTkZJR19VU0JfU0VSSUFMPW0KQ09ORklH X1VTQl9TRVJJQUxfR0VORVJJQz15CiMgQ09ORklHX1VTQl9TRVJJQUxfU0lNUExFIGlzIG5vdCBz ZXQKQ09ORklHX1VTQl9TRVJJQUxfQUlSQ0FCTEU9bQpDT05GSUdfVVNCX1NFUklBTF9BUkszMTE2 PW0KIyBDT05GSUdfVVNCX1NFUklBTF9CRUxLSU4gaXMgbm90IHNldApDT05GSUdfVVNCX1NFUklB TF9DSDM0MT1tCkNPTkZJR19VU0JfU0VSSUFMX1dISVRFSEVBVD1tCiMgQ09ORklHX1VTQl9TRVJJ QUxfRElHSV9BQ0NFTEVQT1JUIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX1NFUklBTF9DUDIxMFgg aXMgbm90IHNldAojIENPTkZJR19VU0JfU0VSSUFMX0NZUFJFU1NfTTggaXMgbm90IHNldAojIENP TkZJR19VU0JfU0VSSUFMX0VNUEVHIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX1NFUklBTF9GVERJ X1NJTyBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9TRVJJQUxfVklTT1IgaXMgbm90IHNldAojIENP TkZJR19VU0JfU0VSSUFMX0lQQVEgaXMgbm90IHNldAojIENPTkZJR19VU0JfU0VSSUFMX0lSIGlz IG5vdCBzZXQKIyBDT05GSUdfVVNCX1NFUklBTF9FREdFUE9SVCBpcyBub3Qgc2V0CiMgQ09ORklH X1VTQl9TRVJJQUxfRURHRVBPUlRfVEkgaXMgbm90IHNldAojIENPTkZJR19VU0JfU0VSSUFMX0Y4 MTIzMiBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9TRVJJQUxfR0FSTUlOIGlzIG5vdCBzZXQKQ09O RklHX1VTQl9TRVJJQUxfSVBXPW0KIyBDT05GSUdfVVNCX1NFUklBTF9JVVUgaXMgbm90IHNldAoj IENPTkZJR19VU0JfU0VSSUFMX0tFWVNQQU5fUERBIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX1NF UklBTF9LRVlTUEFOIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX1NFUklBTF9LTFNJIGlzIG5vdCBz ZXQKIyBDT05GSUdfVVNCX1NFUklBTF9LT0JJTF9TQ1QgaXMgbm90IHNldAojIENPTkZJR19VU0Jf U0VSSUFMX01DVF9VMjMyIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX1NFUklBTF9NRVRSTyBpcyBu b3Qgc2V0CkNPTkZJR19VU0JfU0VSSUFMX01PUzc3MjA9bQpDT05GSUdfVVNCX1NFUklBTF9NT1M3 ODQwPW0KQ09ORklHX1VTQl9TRVJJQUxfTkFWTUFOPW0KIyBDT05GSUdfVVNCX1NFUklBTF9QTDIz MDMgaXMgbm90IHNldApDT05GSUdfVVNCX1NFUklBTF9PVEk2ODU4PW0KIyBDT05GSUdfVVNCX1NF UklBTF9RQ0FVWCBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9TRVJJQUxfUVVBTENPTU0gaXMgbm90 IHNldAojIENPTkZJR19VU0JfU0VSSUFMX1NQQ1A4WDUgaXMgbm90IHNldAojIENPTkZJR19VU0Jf U0VSSUFMX1NBRkUgaXMgbm90IHNldAojIENPTkZJR19VU0JfU0VSSUFMX1NJRVJSQVdJUkVMRVNT IGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX1NFUklBTF9TWU1CT0wgaXMgbm90IHNldAojIENPTkZJ R19VU0JfU0VSSUFMX1RJIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX1NFUklBTF9DWUJFUkpBQ0sg aXMgbm90IHNldAojIENPTkZJR19VU0JfU0VSSUFMX1hJUkNPTSBpcyBub3Qgc2V0CkNPTkZJR19V U0JfU0VSSUFMX1dXQU49bQpDT05GSUdfVVNCX1NFUklBTF9PUFRJT049bQpDT05GSUdfVVNCX1NF UklBTF9PTU5JTkVUPW0KIyBDT05GSUdfVVNCX1NFUklBTF9PUFRJQ09OIGlzIG5vdCBzZXQKIyBD T05GSUdfVVNCX1NFUklBTF9YU0VOU19NVCBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9TRVJJQUxf V0lTSEJPTkUgaXMgbm90IHNldAojIENPTkZJR19VU0JfU0VSSUFMX1pURSBpcyBub3Qgc2V0CiMg Q09ORklHX1VTQl9TRVJJQUxfU1NVMTAwIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX1NFUklBTF9R VDIgaXMgbm90IHNldAojIENPTkZJR19VU0JfU0VSSUFMX0RFQlVHIGlzIG5vdCBzZXQKCiMKIyBV U0IgTWlzY2VsbGFuZW91cyBkcml2ZXJzCiMKIyBDT05GSUdfVVNCX0VNSTYyIGlzIG5vdCBzZXQK IyBDT05GSUdfVVNCX0VNSTI2IGlzIG5vdCBzZXQKQ09ORklHX1VTQl9BRFVUVVg9bQojIENPTkZJ R19VU0JfU0VWU0VHIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX1JJTzUwMCBpcyBub3Qgc2V0CiMg Q09ORklHX1VTQl9MRUdPVE9XRVIgaXMgbm90IHNldAojIENPTkZJR19VU0JfTENEIGlzIG5vdCBz ZXQKIyBDT05GSUdfVVNCX0xFRCBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9DWVBSRVNTX0NZN0M2 MyBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9DWVRIRVJNIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNC X0lETU9VU0UgaXMgbm90IHNldAojIENPTkZJR19VU0JfRlRESV9FTEFOIGlzIG5vdCBzZXQKIyBD T05GSUdfVVNCX0FQUExFRElTUExBWSBpcyBub3Qgc2V0CkNPTkZJR19VU0JfU0lTVVNCVkdBPW0K Q09ORklHX1VTQl9TSVNVU0JWR0FfQ09OPXkKIyBDT05GSUdfVVNCX0xEIGlzIG5vdCBzZXQKIyBD T05GSUdfVVNCX1RSQU5DRVZJQlJBVE9SIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX0lPV0FSUklP UiBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9URVNUIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX0VI U0VUX1RFU1RfRklYVFVSRSBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9JU0lHSFRGVyBpcyBub3Qg c2V0CiMgQ09ORklHX1VTQl9ZVVJFWCBpcyBub3Qgc2V0CkNPTkZJR19VU0JfRVpVU0JfRlgyPW0K IyBDT05GSUdfVVNCX0hTSUNfVVNCMzUwMyBpcyBub3Qgc2V0CgojCiMgVVNCIFBoeXNpY2FsIExh eWVyIGRyaXZlcnMKIwojIENPTkZJR19VU0JfUEhZIGlzIG5vdCBzZXQKIyBDT05GSUdfTk9QX1VT Ql9YQ0VJViBpcyBub3Qgc2V0CiMgQ09ORklHX0FNMzM1WF9QSFlfVVNCIGlzIG5vdCBzZXQKIyBD T05GSUdfU0FNU1VOR19VU0IyUEhZIGlzIG5vdCBzZXQKIyBDT05GSUdfU0FNU1VOR19VU0IzUEhZ IGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX0lTUDEzMDEgaXMgbm90IHNldAojIENPTkZJR19VU0Jf UkNBUl9QSFkgaXMgbm90IHNldAojIENPTkZJR19VU0JfR0FER0VUIGlzIG5vdCBzZXQKIyBDT05G SUdfVVdCIGlzIG5vdCBzZXQKQ09ORklHX01NQz1tCiMgQ09ORklHX01NQ19ERUJVRyBpcyBub3Qg c2V0CiMgQ09ORklHX01NQ19VTlNBRkVfUkVTVU1FIGlzIG5vdCBzZXQKIyBDT05GSUdfTU1DX0NM S0dBVEUgaXMgbm90IHNldAoKIwojIE1NQy9TRC9TRElPIENhcmQgRHJpdmVycwojCkNPTkZJR19N TUNfQkxPQ0s9bQpDT05GSUdfTU1DX0JMT0NLX01JTk9SUz04CkNPTkZJR19NTUNfQkxPQ0tfQk9V TkNFPXkKQ09ORklHX1NESU9fVUFSVD1tCiMgQ09ORklHX01NQ19URVNUIGlzIG5vdCBzZXQKCiMK IyBNTUMvU0QvU0RJTyBIb3N0IENvbnRyb2xsZXIgRHJpdmVycwojCkNPTkZJR19NTUNfU0RIQ0k9 bQojIENPTkZJR19NTUNfU0RIQ0lfUENJIGlzIG5vdCBzZXQKIyBDT05GSUdfTU1DX1NESENJX0FD UEkgaXMgbm90IHNldAojIENPTkZJR19NTUNfU0RIQ0lfUExURk0gaXMgbm90IHNldAojIENPTkZJ R19NTUNfU0RIQ0lfUFhBVjMgaXMgbm90IHNldAojIENPTkZJR19NTUNfU0RIQ0lfUFhBVjIgaXMg bm90IHNldApDT05GSUdfTU1DX1dCU0Q9bQpDT05GSUdfTU1DX1RJRk1fU0Q9bQojIENPTkZJR19N TUNfU0RSSUNPSF9DUyBpcyBub3Qgc2V0CiMgQ09ORklHX01NQ19DQjcxMCBpcyBub3Qgc2V0CiMg Q09ORklHX01NQ19WSUFfU0RNTUMgaXMgbm90IHNldAojIENPTkZJR19NTUNfVlVCMzAwIGlzIG5v dCBzZXQKIyBDT05GSUdfTU1DX1VTSEMgaXMgbm90IHNldAojIENPTkZJR19NRU1TVElDSyBpcyBu b3Qgc2V0CkNPTkZJR19ORVdfTEVEUz15CkNPTkZJR19MRURTX0NMQVNTPW0KCiMKIyBMRUQgZHJp dmVycwojCiMgQ09ORklHX0xFRFNfTE0zNTMwIGlzIG5vdCBzZXQKIyBDT05GSUdfTEVEU19MTTM2 NDIgaXMgbm90IHNldAojIENPTkZJR19MRURTX1BDQTk1MzIgaXMgbm90IHNldAojIENPTkZJR19M RURTX0xQMzk0NCBpcyBub3Qgc2V0CiMgQ09ORklHX0xFRFNfTFA1NTIxIGlzIG5vdCBzZXQKIyBD T05GSUdfTEVEU19MUDU1MjMgaXMgbm90IHNldAojIENPTkZJR19MRURTX0xQNTU2MiBpcyBub3Qg c2V0CiMgQ09ORklHX0xFRFNfTFA4NTAxIGlzIG5vdCBzZXQKIyBDT05GSUdfTEVEU19DTEVWT19N QUlMIGlzIG5vdCBzZXQKIyBDT05GSUdfTEVEU19QQ0E5NTVYIGlzIG5vdCBzZXQKIyBDT05GSUdf TEVEU19QQ0E5NjNYIGlzIG5vdCBzZXQKIyBDT05GSUdfTEVEU19CRDI4MDIgaXMgbm90IHNldAoj IENPTkZJR19MRURTX0lOVEVMX1NTNDIwMCBpcyBub3Qgc2V0CiMgQ09ORklHX0xFRFNfVENBNjUw NyBpcyBub3Qgc2V0CiMgQ09ORklHX0xFRFNfTE0zNTV4IGlzIG5vdCBzZXQKIyBDT05GSUdfTEVE U19PVDIwMCBpcyBub3Qgc2V0CiMgQ09ORklHX0xFRFNfQkxJTktNIGlzIG5vdCBzZXQKCiMKIyBM RUQgVHJpZ2dlcnMKIwpDT05GSUdfTEVEU19UUklHR0VSUz15CkNPTkZJR19MRURTX1RSSUdHRVJf VElNRVI9bQojIENPTkZJR19MRURTX1RSSUdHRVJfT05FU0hPVCBpcyBub3Qgc2V0CkNPTkZJR19M RURTX1RSSUdHRVJfSEVBUlRCRUFUPW0KIyBDT05GSUdfTEVEU19UUklHR0VSX0JBQ0tMSUdIVCBp cyBub3Qgc2V0CiMgQ09ORklHX0xFRFNfVFJJR0dFUl9DUFUgaXMgbm90IHNldAojIENPTkZJR19M RURTX1RSSUdHRVJfREVGQVVMVF9PTiBpcyBub3Qgc2V0CgojCiMgaXB0YWJsZXMgdHJpZ2dlciBp cyB1bmRlciBOZXRmaWx0ZXIgY29uZmlnIChMRUQgdGFyZ2V0KQojCiMgQ09ORklHX0xFRFNfVFJJ R0dFUl9UUkFOU0lFTlQgaXMgbm90IHNldAojIENPTkZJR19MRURTX1RSSUdHRVJfQ0FNRVJBIGlz IG5vdCBzZXQKIyBDT05GSUdfQUNDRVNTSUJJTElUWSBpcyBub3Qgc2V0CiMgQ09ORklHX0lORklO SUJBTkQgaXMgbm90IHNldAojIENPTkZJR19FREFDIGlzIG5vdCBzZXQKQ09ORklHX1JUQ19MSUI9 eQpDT05GSUdfUlRDX0NMQVNTPXkKQ09ORklHX1JUQ19IQ1RPU1lTPXkKQ09ORklHX1JUQ19TWVNU T0hDPXkKQ09ORklHX1JUQ19IQ1RPU1lTX0RFVklDRT0icnRjMCIKIyBDT05GSUdfUlRDX0RFQlVH IGlzIG5vdCBzZXQKCiMKIyBSVEMgaW50ZXJmYWNlcwojCkNPTkZJR19SVENfSU5URl9TWVNGUz15 CkNPTkZJR19SVENfSU5URl9QUk9DPXkKQ09ORklHX1JUQ19JTlRGX0RFVj15CkNPTkZJR19SVENf SU5URl9ERVZfVUlFX0VNVUw9eQojIENPTkZJR19SVENfRFJWX1RFU1QgaXMgbm90IHNldAoKIwoj IEkyQyBSVEMgZHJpdmVycwojCiMgQ09ORklHX1JUQ19EUlZfRFMxMzA3IGlzIG5vdCBzZXQKQ09O RklHX1JUQ19EUlZfRFMxMzc0PW0KIyBDT05GSUdfUlRDX0RSVl9EUzE2NzIgaXMgbm90IHNldAoj IENPTkZJR19SVENfRFJWX0RTMzIzMiBpcyBub3Qgc2V0CkNPTkZJR19SVENfRFJWX01BWDY5MDA9 bQojIENPTkZJR19SVENfRFJWX1JTNUMzNzIgaXMgbm90IHNldAojIENPTkZJR19SVENfRFJWX0lT TDEyMDggaXMgbm90IHNldAojIENPTkZJR19SVENfRFJWX0lTTDEyMDIyIGlzIG5vdCBzZXQKIyBD T05GSUdfUlRDX0RSVl9YMTIwNSBpcyBub3Qgc2V0CiMgQ09ORklHX1JUQ19EUlZfUENGMjEyNyBp cyBub3Qgc2V0CiMgQ09ORklHX1JUQ19EUlZfUENGODUyMyBpcyBub3Qgc2V0CiMgQ09ORklHX1JU Q19EUlZfUENGODU2MyBpcyBub3Qgc2V0CiMgQ09ORklHX1JUQ19EUlZfUENGODU4MyBpcyBub3Qg c2V0CkNPTkZJR19SVENfRFJWX000MVQ4MD1tCkNPTkZJR19SVENfRFJWX000MVQ4MF9XRFQ9eQoj IENPTkZJR19SVENfRFJWX0JRMzJLIGlzIG5vdCBzZXQKIyBDT05GSUdfUlRDX0RSVl9TMzUzOTBB IGlzIG5vdCBzZXQKIyBDT05GSUdfUlRDX0RSVl9GTTMxMzAgaXMgbm90IHNldAojIENPTkZJR19S VENfRFJWX1JYODU4MSBpcyBub3Qgc2V0CiMgQ09ORklHX1JUQ19EUlZfUlg4MDI1IGlzIG5vdCBz ZXQKIyBDT05GSUdfUlRDX0RSVl9FTTMwMjcgaXMgbm90IHNldAojIENPTkZJR19SVENfRFJWX1JW MzAyOUMyIGlzIG5vdCBzZXQKCiMKIyBTUEkgUlRDIGRyaXZlcnMKIwoKIwojIFBsYXRmb3JtIFJU QyBkcml2ZXJzCiMKQ09ORklHX1JUQ19EUlZfQ01PUz1tCiMgQ09ORklHX1JUQ19EUlZfRFMxMjg2 IGlzIG5vdCBzZXQKIyBDT05GSUdfUlRDX0RSVl9EUzE1MTEgaXMgbm90IHNldApDT05GSUdfUlRD X0RSVl9EUzE1NTM9bQpDT05GSUdfUlRDX0RSVl9EUzE3NDI9bQpDT05GSUdfUlRDX0RSVl9TVEsx N1RBOD1tCkNPTkZJR19SVENfRFJWX000OFQ4Nj1tCiMgQ09ORklHX1JUQ19EUlZfTTQ4VDM1IGlz IG5vdCBzZXQKQ09ORklHX1JUQ19EUlZfTTQ4VDU5PW0KIyBDT05GSUdfUlRDX0RSVl9NU002MjQy IGlzIG5vdCBzZXQKIyBDT05GSUdfUlRDX0RSVl9CUTQ4MDIgaXMgbm90IHNldAojIENPTkZJR19S VENfRFJWX1JQNUMwMSBpcyBub3Qgc2V0CkNPTkZJR19SVENfRFJWX1YzMDIwPW0KIyBDT05GSUdf UlRDX0RSVl9EUzI0MDQgaXMgbm90IHNldAoKIwojIG9uLUNQVSBSVEMgZHJpdmVycwojCiMgQ09O RklHX1JUQ19EUlZfTU9YQVJUIGlzIG5vdCBzZXQKCiMKIyBISUQgU2Vuc29yIFJUQyBkcml2ZXJz CiMKIyBDT05GSUdfUlRDX0RSVl9ISURfU0VOU09SX1RJTUUgaXMgbm90IHNldApDT05GSUdfRE1B REVWSUNFUz15CiMgQ09ORklHX0RNQURFVklDRVNfREVCVUcgaXMgbm90IHNldAoKIwojIERNQSBE ZXZpY2VzCiMKIyBDT05GSUdfSU5URUxfTUlEX0RNQUMgaXMgbm90IHNldApDT05GSUdfSU5URUxf SU9BVERNQT1tCiMgQ09ORklHX0RXX0RNQUNfQ09SRSBpcyBub3Qgc2V0CiMgQ09ORklHX0RXX0RN QUMgaXMgbm90IHNldAojIENPTkZJR19EV19ETUFDX1BDSSBpcyBub3Qgc2V0CiMgQ09ORklHX1RJ TUJfRE1BIGlzIG5vdCBzZXQKIyBDT05GSUdfUENIX0RNQSBpcyBub3Qgc2V0CkNPTkZJR19ETUFf RU5HSU5FPXkKQ09ORklHX0RNQV9BQ1BJPXkKCiMKIyBETUEgQ2xpZW50cwojCiMgQ09ORklHX0FT WU5DX1RYX0RNQSBpcyBub3Qgc2V0CiMgQ09ORklHX0RNQVRFU1QgaXMgbm90IHNldApDT05GSUdf RENBPW0KQ09ORklHX0FVWERJU1BMQVk9eQpDT05GSUdfVUlPPW0KQ09ORklHX1VJT19DSUY9bQoj IENPTkZJR19VSU9fUERSVl9HRU5JUlEgaXMgbm90IHNldAojIENPTkZJR19VSU9fRE1FTV9HRU5J UlEgaXMgbm90IHNldAojIENPTkZJR19VSU9fQUVDIGlzIG5vdCBzZXQKIyBDT05GSUdfVUlPX1NF UkNPUzMgaXMgbm90IHNldAojIENPTkZJR19VSU9fUENJX0dFTkVSSUMgaXMgbm90IHNldAojIENP TkZJR19VSU9fTkVUWCBpcyBub3Qgc2V0CiMgQ09ORklHX1VJT19NRjYyNCBpcyBub3Qgc2V0CkNP TkZJR19WSVJUX0RSSVZFUlM9eQoKIwojIFZpcnRpbyBkcml2ZXJzCiMKIyBDT05GSUdfVklSVElP X1BDSSBpcyBub3Qgc2V0CiMgQ09ORklHX1ZJUlRJT19NTUlPIGlzIG5vdCBzZXQKCiMKIyBNaWNy b3NvZnQgSHlwZXItViBndWVzdCBzdXBwb3J0CiMKIyBDT05GSUdfSFlQRVJWIGlzIG5vdCBzZXQK CiMKIyBYZW4gZHJpdmVyIHN1cHBvcnQKIwpDT05GSUdfWEVOX0JBTExPT049eQojIENPTkZJR19Y RU5fU0VMRkJBTExPT05JTkcgaXMgbm90IHNldApDT05GSUdfWEVOX1NDUlVCX1BBR0VTPXkKQ09O RklHX1hFTl9ERVZfRVZUQ0hOPXkKQ09ORklHX1hFTl9CQUNLRU5EPXkKQ09ORklHX1hFTkZTPXkK Q09ORklHX1hFTl9DT01QQVRfWEVORlM9eQpDT05GSUdfWEVOX1NZU19IWVBFUlZJU09SPXkKQ09O RklHX1hFTl9YRU5CVVNfRlJPTlRFTkQ9eQpDT05GSUdfWEVOX0dOVERFVj15CkNPTkZJR19YRU5f R1JBTlRfREVWX0FMTE9DPW0KQ09ORklHX1NXSU9UTEJfWEVOPXkKQ09ORklHX1hFTl9UTUVNPW0K Q09ORklHX1hFTl9QQ0lERVZfQkFDS0VORD1tCkNPTkZJR19YRU5fUFJJVkNNRD15CkNPTkZJR19Y RU5fQUNQSV9QUk9DRVNTT1I9bQojIENPTkZJR19YRU5fTUNFX0xPRyBpcyBub3Qgc2V0CkNPTkZJ R19YRU5fSEFWRV9QVk1NVT15CiMgQ09ORklHX1NUQUdJTkcgaXMgbm90IHNldAojIENPTkZJR19Y ODZfUExBVEZPUk1fREVWSUNFUyBpcyBub3Qgc2V0CkNPTkZJR19DTEtERVZfTE9PS1VQPXkKQ09O RklHX0hBVkVfQ0xLX1BSRVBBUkU9eQpDT05GSUdfQ09NTU9OX0NMSz15CgojCiMgQ29tbW9uIENs b2NrIEZyYW1ld29yawojCiMgQ09ORklHX0NPTU1PTl9DTEtfREVCVUcgaXMgbm90IHNldAojIENP TkZJR19DT01NT05fQ0xLX1NJNTM1MSBpcyBub3Qgc2V0CgojCiMgSGFyZHdhcmUgU3BpbmxvY2sg ZHJpdmVycwojCkNPTkZJR19DTEtFVlRfSTgyNTM9eQpDT05GSUdfSTgyNTNfTE9DSz15CkNPTkZJ R19DTEtCTERfSTgyNTM9eQojIENPTkZJR19NQUlMQk9YIGlzIG5vdCBzZXQKIyBDT05GSUdfSU9N TVVfU1VQUE9SVCBpcyBub3Qgc2V0CgojCiMgUmVtb3RlcHJvYyBkcml2ZXJzCiMKIyBDT05GSUdf U1RFX01PREVNX1JQUk9DIGlzIG5vdCBzZXQKCiMKIyBScG1zZyBkcml2ZXJzCiMKIyBDT05GSUdf UE1fREVWRlJFUSBpcyBub3Qgc2V0CiMgQ09ORklHX0VYVENPTiBpcyBub3Qgc2V0CiMgQ09ORklH X01FTU9SWSBpcyBub3Qgc2V0CiMgQ09ORklHX0lJTyBpcyBub3Qgc2V0CiMgQ09ORklHX05UQiBp cyBub3Qgc2V0CiMgQ09ORklHX1ZNRV9CVVMgaXMgbm90IHNldAojIENPTkZJR19QV00gaXMgbm90 IHNldAojIENPTkZJR19JUEFDS19CVVMgaXMgbm90IHNldAojIENPTkZJR19SRVNFVF9DT05UUk9M TEVSIGlzIG5vdCBzZXQKIyBDT05GSUdfRk1DIGlzIG5vdCBzZXQKCiMKIyBGaXJtd2FyZSBEcml2 ZXJzCiMKIyBDT05GSUdfRUREIGlzIG5vdCBzZXQKQ09ORklHX0ZJUk1XQVJFX01FTU1BUD15CkNP TkZJR19ERUxMX1JCVT1tCkNPTkZJR19EQ0RCQVM9bQojIENPTkZJR19ETUlJRCBpcyBub3Qgc2V0 CiMgQ09ORklHX0RNSV9TWVNGUyBpcyBub3Qgc2V0CiMgQ09ORklHX0lTQ1NJX0lCRlRfRklORCBp cyBub3Qgc2V0CiMgQ09ORklHX0dPT0dMRV9GSVJNV0FSRSBpcyBub3Qgc2V0CgojCiMgRUZJIChF eHRlbnNpYmxlIEZpcm13YXJlIEludGVyZmFjZSkgU3VwcG9ydAojCkNPTkZJR19FRklfVkFSUz15 CgojCiMgRmlsZSBzeXN0ZW1zCiMKQ09ORklHX0RDQUNIRV9XT1JEX0FDQ0VTUz15CkNPTkZJR19F WFQyX0ZTPXkKIyBDT05GSUdfRVhUMl9GU19YQVRUUiBpcyBub3Qgc2V0CiMgQ09ORklHX0VYVDJf RlNfWElQIGlzIG5vdCBzZXQKQ09ORklHX0VYVDNfRlM9bQojIENPTkZJR19FWFQzX0RFRkFVTFRT X1RPX09SREVSRUQgaXMgbm90IHNldApDT05GSUdfRVhUM19GU19YQVRUUj15CkNPTkZJR19FWFQz X0ZTX1BPU0lYX0FDTD15CkNPTkZJR19FWFQzX0ZTX1NFQ1VSSVRZPXkKQ09ORklHX0VYVDRfRlM9 eQpDT05GSUdfRVhUNF9GU19QT1NJWF9BQ0w9eQpDT05GSUdfRVhUNF9GU19TRUNVUklUWT15CiMg Q09ORklHX0VYVDRfREVCVUcgaXMgbm90IHNldApDT05GSUdfSkJEPW0KQ09ORklHX0pCRDI9eQoj IENPTkZJR19KQkQyX0RFQlVHIGlzIG5vdCBzZXQKQ09ORklHX0ZTX01CQ0FDSEU9eQpDT05GSUdf UkVJU0VSRlNfRlM9bQojIENPTkZJR19SRUlTRVJGU19DSEVDSyBpcyBub3Qgc2V0CiMgQ09ORklH X1JFSVNFUkZTX1BST0NfSU5GTyBpcyBub3Qgc2V0CkNPTkZJR19SRUlTRVJGU19GU19YQVRUUj15 CkNPTkZJR19SRUlTRVJGU19GU19QT1NJWF9BQ0w9eQpDT05GSUdfUkVJU0VSRlNfRlNfU0VDVVJJ VFk9eQpDT05GSUdfSkZTX0ZTPW0KQ09ORklHX0pGU19QT1NJWF9BQ0w9eQpDT05GSUdfSkZTX1NF Q1VSSVRZPXkKIyBDT05GSUdfSkZTX0RFQlVHIGlzIG5vdCBzZXQKIyBDT05GSUdfSkZTX1NUQVRJ U1RJQ1MgaXMgbm90IHNldApDT05GSUdfWEZTX0ZTPW0KQ09ORklHX1hGU19RVU9UQT15CkNPTkZJ R19YRlNfUE9TSVhfQUNMPXkKQ09ORklHX1hGU19SVD15CiMgQ09ORklHX1hGU19XQVJOIGlzIG5v dCBzZXQKIyBDT05GSUdfWEZTX0RFQlVHIGlzIG5vdCBzZXQKQ09ORklHX0dGUzJfRlM9bQojIENP TkZJR19HRlMyX0ZTX0xPQ0tJTkdfRExNIGlzIG5vdCBzZXQKQ09ORklHX09DRlMyX0ZTPW0KQ09O RklHX09DRlMyX0ZTX08yQ0I9bQpDT05GSUdfT0NGUzJfRlNfVVNFUlNQQUNFX0NMVVNURVI9bQoj IENPTkZJR19PQ0ZTMl9ERUJVR19NQVNLTE9HIGlzIG5vdCBzZXQKIyBDT05GSUdfT0NGUzJfREVC VUdfRlMgaXMgbm90IHNldApDT05GSUdfQlRSRlNfRlM9bQpDT05GSUdfQlRSRlNfRlNfUE9TSVhf QUNMPXkKIyBDT05GSUdfQlRSRlNfRlNfQ0hFQ0tfSU5URUdSSVRZIGlzIG5vdCBzZXQKIyBDT05G SUdfQlRSRlNfRlNfUlVOX1NBTklUWV9URVNUUyBpcyBub3Qgc2V0CiMgQ09ORklHX0JUUkZTX0RF QlVHIGlzIG5vdCBzZXQKIyBDT05GSUdfQlRSRlNfQVNTRVJUIGlzIG5vdCBzZXQKIyBDT05GSUdf TklMRlMyX0ZTIGlzIG5vdCBzZXQKQ09ORklHX0ZTX1BPU0lYX0FDTD15CkNPTkZJR19FWFBPUlRG Uz15CkNPTkZJR19GSUxFX0xPQ0tJTkc9eQpDT05GSUdfRlNOT1RJRlk9eQpDT05GSUdfRE5PVElG WT15CkNPTkZJR19JTk9USUZZX1VTRVI9eQpDT05GSUdfRkFOT1RJRlk9eQpDT05GSUdfUVVPVEE9 eQojIENPTkZJR19RVU9UQV9ORVRMSU5LX0lOVEVSRkFDRSBpcyBub3Qgc2V0CiMgQ09ORklHX1BS SU5UX1FVT1RBX1dBUk5JTkcgaXMgbm90IHNldAojIENPTkZJR19RVU9UQV9ERUJVRyBpcyBub3Qg c2V0CkNPTkZJR19RVU9UQV9UUkVFPW0KIyBDT05GSUdfUUZNVF9WMSBpcyBub3Qgc2V0CiMgQ09O RklHX1FGTVRfVjIgaXMgbm90IHNldApDT05GSUdfUVVPVEFDVEw9eQpDT05GSUdfUVVPVEFDVExf Q09NUEFUPXkKQ09ORklHX0FVVE9GUzRfRlM9eQpDT05GSUdfRlVTRV9GUz1tCkNPTkZJR19DVVNF PW0KQ09ORklHX0dFTkVSSUNfQUNMPXkKCiMKIyBDYWNoZXMKIwojIENPTkZJR19GU0NBQ0hFIGlz IG5vdCBzZXQKCiMKIyBDRC1ST00vRFZEIEZpbGVzeXN0ZW1zCiMKQ09ORklHX0lTTzk2NjBfRlM9 eQpDT05GSUdfSk9MSUVUPXkKQ09ORklHX1pJU09GUz15CkNPTkZJR19VREZfRlM9eQpDT05GSUdf VURGX05MUz15CgojCiMgRE9TL0ZBVC9OVCBGaWxlc3lzdGVtcwojCkNPTkZJR19GQVRfRlM9eQpD T05GSUdfTVNET1NfRlM9eQpDT05GSUdfVkZBVF9GUz15CkNPTkZJR19GQVRfREVGQVVMVF9DT0RF UEFHRT00MzcKQ09ORklHX0ZBVF9ERUZBVUxUX0lPQ0hBUlNFVD0iaXNvODg1OS0xIgpDT05GSUdf TlRGU19GUz15CiMgQ09ORklHX05URlNfREVCVUcgaXMgbm90IHNldApDT05GSUdfTlRGU19SVz15 CgojCiMgUHNldWRvIGZpbGVzeXN0ZW1zCiMKQ09ORklHX1BST0NfRlM9eQpDT05GSUdfUFJPQ19L Q09SRT15CkNPTkZJR19QUk9DX1NZU0NUTD15CkNPTkZJR19QUk9DX1BBR0VfTU9OSVRPUj15CkNP TkZJR19TWVNGUz15CkNPTkZJR19UTVBGUz15CkNPTkZJR19UTVBGU19QT1NJWF9BQ0w9eQpDT05G SUdfVE1QRlNfWEFUVFI9eQpDT05GSUdfSFVHRVRMQkZTPXkKQ09ORklHX0hVR0VUTEJfUEFHRT15 CkNPTkZJR19DT05GSUdGU19GUz15CkNPTkZJR19NSVNDX0ZJTEVTWVNURU1TPXkKIyBDT05GSUdf QURGU19GUyBpcyBub3Qgc2V0CiMgQ09ORklHX0FGRlNfRlMgaXMgbm90IHNldApDT05GSUdfRUNS WVBUX0ZTPW0KIyBDT05GSUdfRUNSWVBUX0ZTX01FU1NBR0lORyBpcyBub3Qgc2V0CiMgQ09ORklH X0hGU19GUyBpcyBub3Qgc2V0CiMgQ09ORklHX0hGU1BMVVNfRlMgaXMgbm90IHNldAojIENPTkZJ R19CRUZTX0ZTIGlzIG5vdCBzZXQKIyBDT05GSUdfQkZTX0ZTIGlzIG5vdCBzZXQKIyBDT05GSUdf RUZTX0ZTIGlzIG5vdCBzZXQKIyBDT05GSUdfTE9HRlMgaXMgbm90IHNldAojIENPTkZJR19DUkFN RlMgaXMgbm90IHNldApDT05GSUdfU1FVQVNIRlM9bQojIENPTkZJR19TUVVBU0hGU19YQVRUUiBp cyBub3Qgc2V0CkNPTkZJR19TUVVBU0hGU19aTElCPXkKQ09ORklHX1NRVUFTSEZTX0xaTz15CkNP TkZJR19TUVVBU0hGU19YWj15CiMgQ09ORklHX1NRVUFTSEZTXzRLX0RFVkJMS19TSVpFIGlzIG5v dCBzZXQKQ09ORklHX1NRVUFTSEZTX0VNQkVEREVEPXkKQ09ORklHX1NRVUFTSEZTX0ZSQUdNRU5U X0NBQ0hFX1NJWkU9MwojIENPTkZJR19WWEZTX0ZTIGlzIG5vdCBzZXQKIyBDT05GSUdfTUlOSVhf RlMgaXMgbm90IHNldAojIENPTkZJR19PTUZTX0ZTIGlzIG5vdCBzZXQKIyBDT05GSUdfSFBGU19G UyBpcyBub3Qgc2V0CiMgQ09ORklHX1FOWDRGU19GUyBpcyBub3Qgc2V0CiMgQ09ORklHX1FOWDZG U19GUyBpcyBub3Qgc2V0CiMgQ09ORklHX1JPTUZTX0ZTIGlzIG5vdCBzZXQKIyBDT05GSUdfUFNU T1JFIGlzIG5vdCBzZXQKIyBDT05GSUdfU1lTVl9GUyBpcyBub3Qgc2V0CiMgQ09ORklHX1VGU19G UyBpcyBub3Qgc2V0CiMgQ09ORklHX0YyRlNfRlMgaXMgbm90IHNldApDT05GSUdfRUZJVkFSX0ZT PXkKIyBDT05GSUdfTkVUV09SS19GSUxFU1lTVEVNUyBpcyBub3Qgc2V0CkNPTkZJR19OTFM9eQpD T05GSUdfTkxTX0RFRkFVTFQ9Imlzbzg4NTktMSIKQ09ORklHX05MU19DT0RFUEFHRV80Mzc9bQoj IENPTkZJR19OTFNfQ09ERVBBR0VfNzM3IGlzIG5vdCBzZXQKIyBDT05GSUdfTkxTX0NPREVQQUdF Xzc3NSBpcyBub3Qgc2V0CiMgQ09ORklHX05MU19DT0RFUEFHRV84NTAgaXMgbm90IHNldAojIENP TkZJR19OTFNfQ09ERVBBR0VfODUyIGlzIG5vdCBzZXQKIyBDT05GSUdfTkxTX0NPREVQQUdFXzg1 NSBpcyBub3Qgc2V0CiMgQ09ORklHX05MU19DT0RFUEFHRV84NTcgaXMgbm90IHNldAojIENPTkZJ R19OTFNfQ09ERVBBR0VfODYwIGlzIG5vdCBzZXQKIyBDT05GSUdfTkxTX0NPREVQQUdFXzg2MSBp cyBub3Qgc2V0CiMgQ09ORklHX05MU19DT0RFUEFHRV84NjIgaXMgbm90IHNldAojIENPTkZJR19O TFNfQ09ERVBBR0VfODYzIGlzIG5vdCBzZXQKIyBDT05GSUdfTkxTX0NPREVQQUdFXzg2NCBpcyBu b3Qgc2V0CiMgQ09ORklHX05MU19DT0RFUEFHRV84NjUgaXMgbm90IHNldAojIENPTkZJR19OTFNf Q09ERVBBR0VfODY2IGlzIG5vdCBzZXQKIyBDT05GSUdfTkxTX0NPREVQQUdFXzg2OSBpcyBub3Qg c2V0CiMgQ09ORklHX05MU19DT0RFUEFHRV85MzYgaXMgbm90IHNldAojIENPTkZJR19OTFNfQ09E RVBBR0VfOTUwIGlzIG5vdCBzZXQKIyBDT05GSUdfTkxTX0NPREVQQUdFXzkzMiBpcyBub3Qgc2V0 CiMgQ09ORklHX05MU19DT0RFUEFHRV85NDkgaXMgbm90IHNldAojIENPTkZJR19OTFNfQ09ERVBB R0VfODc0IGlzIG5vdCBzZXQKIyBDT05GSUdfTkxTX0lTTzg4NTlfOCBpcyBub3Qgc2V0CiMgQ09O RklHX05MU19DT0RFUEFHRV8xMjUwIGlzIG5vdCBzZXQKIyBDT05GSUdfTkxTX0NPREVQQUdFXzEy NTEgaXMgbm90IHNldAojIENPTkZJR19OTFNfQVNDSUkgaXMgbm90IHNldApDT05GSUdfTkxTX0lT Tzg4NTlfMT15CiMgQ09ORklHX05MU19JU084ODU5XzIgaXMgbm90IHNldAojIENPTkZJR19OTFNf SVNPODg1OV8zIGlzIG5vdCBzZXQKIyBDT05GSUdfTkxTX0lTTzg4NTlfNCBpcyBub3Qgc2V0CiMg Q09ORklHX05MU19JU084ODU5XzUgaXMgbm90IHNldAojIENPTkZJR19OTFNfSVNPODg1OV82IGlz IG5vdCBzZXQKIyBDT05GSUdfTkxTX0lTTzg4NTlfNyBpcyBub3Qgc2V0CiMgQ09ORklHX05MU19J U084ODU5XzkgaXMgbm90IHNldAojIENPTkZJR19OTFNfSVNPODg1OV8xMyBpcyBub3Qgc2V0CiMg Q09ORklHX05MU19JU084ODU5XzE0IGlzIG5vdCBzZXQKIyBDT05GSUdfTkxTX0lTTzg4NTlfMTUg aXMgbm90IHNldAojIENPTkZJR19OTFNfS09JOF9SIGlzIG5vdCBzZXQKIyBDT05GSUdfTkxTX0tP SThfVSBpcyBub3Qgc2V0CiMgQ09ORklHX05MU19NQUNfUk9NQU4gaXMgbm90IHNldAojIENPTkZJ R19OTFNfTUFDX0NFTFRJQyBpcyBub3Qgc2V0CiMgQ09ORklHX05MU19NQUNfQ0VOVEVVUk8gaXMg bm90IHNldAojIENPTkZJR19OTFNfTUFDX0NST0FUSUFOIGlzIG5vdCBzZXQKIyBDT05GSUdfTkxT X01BQ19DWVJJTExJQyBpcyBub3Qgc2V0CiMgQ09ORklHX05MU19NQUNfR0FFTElDIGlzIG5vdCBz ZXQKIyBDT05GSUdfTkxTX01BQ19HUkVFSyBpcyBub3Qgc2V0CiMgQ09ORklHX05MU19NQUNfSUNF TEFORCBpcyBub3Qgc2V0CiMgQ09ORklHX05MU19NQUNfSU5VSVQgaXMgbm90IHNldAojIENPTkZJ R19OTFNfTUFDX1JPTUFOSUFOIGlzIG5vdCBzZXQKIyBDT05GSUdfTkxTX01BQ19UVVJLSVNIIGlz IG5vdCBzZXQKQ09ORklHX05MU19VVEY4PXkKQ09ORklHX0RMTT1tCiMgQ09ORklHX0RMTV9ERUJV RyBpcyBub3Qgc2V0CgojCiMgS2VybmVsIGhhY2tpbmcKIwpDT05GSUdfVFJBQ0VfSVJRRkxBR1Nf U1VQUE9SVD15CgojCiMgcHJpbnRrIGFuZCBkbWVzZyBvcHRpb25zCiMKIyBDT05GSUdfUFJJTlRL X1RJTUUgaXMgbm90IHNldApDT05GSUdfREVGQVVMVF9NRVNTQUdFX0xPR0xFVkVMPTQKIyBDT05G SUdfQk9PVF9QUklOVEtfREVMQVkgaXMgbm90IHNldAoKIwojIENvbXBpbGUtdGltZSBjaGVja3Mg YW5kIGNvbXBpbGVyIG9wdGlvbnMKIwojIENPTkZJR19ERUJVR19JTkZPIGlzIG5vdCBzZXQKQ09O RklHX0VOQUJMRV9XQVJOX0RFUFJFQ0FURUQ9eQpDT05GSUdfRU5BQkxFX01VU1RfQ0hFQ0s9eQpD T05GSUdfRlJBTUVfV0FSTj0yMDQ4CiMgQ09ORklHX1NUUklQX0FTTV9TWU1TIGlzIG5vdCBzZXQK IyBDT05GSUdfUkVBREFCTEVfQVNNIGlzIG5vdCBzZXQKQ09ORklHX1VOVVNFRF9TWU1CT0xTPXkK IyBDT05GSUdfREVCVUdfRlMgaXMgbm90IHNldAojIENPTkZJR19IRUFERVJTX0NIRUNLIGlzIG5v dCBzZXQKIyBDT05GSUdfREVCVUdfU0VDVElPTl9NSVNNQVRDSCBpcyBub3Qgc2V0CkNPTkZJR19B UkNIX1dBTlRfRlJBTUVfUE9JTlRFUlM9eQpDT05GSUdfRlJBTUVfUE9JTlRFUj15CiMgQ09ORklH X0RFQlVHX0ZPUkNFX1dFQUtfUEVSX0NQVSBpcyBub3Qgc2V0CiMgQ09ORklHX01BR0lDX1NZU1JR IGlzIG5vdCBzZXQKQ09ORklHX0RFQlVHX0tFUk5FTD15CgojCiMgTWVtb3J5IERlYnVnZ2luZwoj CiMgQ09ORklHX0RFQlVHX1BBR0VBTExPQyBpcyBub3Qgc2V0CiMgQ09ORklHX0RFQlVHX09CSkVD VFMgaXMgbm90IHNldAojIENPTkZJR19ERUJVR19TTEFCIGlzIG5vdCBzZXQKQ09ORklHX0hBVkVf REVCVUdfS01FTUxFQUs9eQojIENPTkZJR19ERUJVR19LTUVNTEVBSyBpcyBub3Qgc2V0CiMgQ09O RklHX0RFQlVHX1NUQUNLX1VTQUdFIGlzIG5vdCBzZXQKIyBDT05GSUdfREVCVUdfVk0gaXMgbm90 IHNldAojIENPTkZJR19ERUJVR19WSVJUVUFMIGlzIG5vdCBzZXQKQ09ORklHX0RFQlVHX01FTU9S WV9JTklUPXkKIyBDT05GSUdfREVCVUdfUEVSX0NQVV9NQVBTIGlzIG5vdCBzZXQKQ09ORklHX0hB VkVfREVCVUdfU1RBQ0tPVkVSRkxPVz15CiMgQ09ORklHX0RFQlVHX1NUQUNLT1ZFUkZMT1cgaXMg bm90IHNldApDT05GSUdfSEFWRV9BUkNIX0tNRU1DSEVDSz15CiMgQ09ORklHX0RFQlVHX1NISVJR IGlzIG5vdCBzZXQKCiMKIyBEZWJ1ZyBMb2NrdXBzIGFuZCBIYW5ncwojCiMgQ09ORklHX0xPQ0tV UF9ERVRFQ1RPUiBpcyBub3Qgc2V0CiMgQ09ORklHX0RFVEVDVF9IVU5HX1RBU0sgaXMgbm90IHNl dAojIENPTkZJR19QQU5JQ19PTl9PT1BTIGlzIG5vdCBzZXQKQ09ORklHX1BBTklDX09OX09PUFNf VkFMVUU9MApDT05GSUdfU0NIRURfREVCVUc9eQojIENPTkZJR19TQ0hFRFNUQVRTIGlzIG5vdCBz ZXQKIyBDT05GSUdfVElNRVJfU1RBVFMgaXMgbm90IHNldApDT05GSUdfREVCVUdfUFJFRU1QVD15 CgojCiMgTG9jayBEZWJ1Z2dpbmcgKHNwaW5sb2NrcywgbXV0ZXhlcywgZXRjLi4uKQojCiMgQ09O RklHX0RFQlVHX1JUX01VVEVYRVMgaXMgbm90IHNldAojIENPTkZJR19SVF9NVVRFWF9URVNURVIg aXMgbm90IHNldAojIENPTkZJR19ERUJVR19TUElOTE9DSyBpcyBub3Qgc2V0CiMgQ09ORklHX0RF QlVHX01VVEVYRVMgaXMgbm90IHNldAojIENPTkZJR19ERUJVR19XV19NVVRFWF9TTE9XUEFUSCBp cyBub3Qgc2V0CiMgQ09ORklHX0RFQlVHX0xPQ0tfQUxMT0MgaXMgbm90IHNldAojIENPTkZJR19Q Uk9WRV9MT0NLSU5HIGlzIG5vdCBzZXQKIyBDT05GSUdfTE9DS19TVEFUIGlzIG5vdCBzZXQKIyBD T05GSUdfREVCVUdfQVRPTUlDX1NMRUVQIGlzIG5vdCBzZXQKIyBDT05GSUdfREVCVUdfTE9DS0lO R19BUElfU0VMRlRFU1RTIGlzIG5vdCBzZXQKIyBDT05GSUdfREVCVUdfS09CSkVDVCBpcyBub3Qg c2V0CkNPTkZJR19ERUJVR19CVUdWRVJCT1NFPXkKIyBDT05GSUdfREVCVUdfV1JJVEVDT1VOVCBp cyBub3Qgc2V0CiMgQ09ORklHX0RFQlVHX0xJU1QgaXMgbm90IHNldAojIENPTkZJR19ERUJVR19T RyBpcyBub3Qgc2V0CiMgQ09ORklHX0RFQlVHX05PVElGSUVSUyBpcyBub3Qgc2V0CiMgQ09ORklH X0RFQlVHX0NSRURFTlRJQUxTIGlzIG5vdCBzZXQKCiMKIyBSQ1UgRGVidWdnaW5nCiMKIyBDT05G SUdfUFJPVkVfUkNVX0RFTEFZIGlzIG5vdCBzZXQKIyBDT05GSUdfU1BBUlNFX1JDVV9QT0lOVEVS IGlzIG5vdCBzZXQKIyBDT05GSUdfUkNVX1RPUlRVUkVfVEVTVCBpcyBub3Qgc2V0CkNPTkZJR19S Q1VfQ1BVX1NUQUxMX1RJTUVPVVQ9MjEKQ09ORklHX1JDVV9DUFVfU1RBTExfVkVSQk9TRT15CiMg Q09ORklHX1JDVV9DUFVfU1RBTExfSU5GTyBpcyBub3Qgc2V0CiMgQ09ORklHX1JDVV9UUkFDRSBp cyBub3Qgc2V0CiMgQ09ORklHX0RFQlVHX0JMT0NLX0VYVF9ERVZUIGlzIG5vdCBzZXQKIyBDT05G SUdfTk9USUZJRVJfRVJST1JfSU5KRUNUSU9OIGlzIG5vdCBzZXQKIyBDT05GSUdfRkFVTFRfSU5K RUNUSU9OIGlzIG5vdCBzZXQKIyBDT05GSUdfTEFURU5DWVRPUCBpcyBub3Qgc2V0CkNPTkZJR19B UkNIX0hBU19ERUJVR19TVFJJQ1RfVVNFUl9DT1BZX0NIRUNLUz15CiMgQ09ORklHX0RFQlVHX1NU UklDVF9VU0VSX0NPUFlfQ0hFQ0tTIGlzIG5vdCBzZXQKQ09ORklHX1VTRVJfU1RBQ0tUUkFDRV9T VVBQT1JUPXkKQ09ORklHX0hBVkVfRlVOQ1RJT05fVFJBQ0VSPXkKQ09ORklHX0hBVkVfRlVOQ1RJ T05fR1JBUEhfVFJBQ0VSPXkKQ09ORklHX0hBVkVfRlVOQ1RJT05fR1JBUEhfRlBfVEVTVD15CkNP TkZJR19IQVZFX0ZVTkNUSU9OX1RSQUNFX01DT1VOVF9URVNUPXkKQ09ORklHX0hBVkVfRFlOQU1J Q19GVFJBQ0U9eQpDT05GSUdfSEFWRV9EWU5BTUlDX0ZUUkFDRV9XSVRIX1JFR1M9eQpDT05GSUdf SEFWRV9GVFJBQ0VfTUNPVU5UX1JFQ09SRD15CkNPTkZJR19IQVZFX1NZU0NBTExfVFJBQ0VQT0lO VFM9eQpDT05GSUdfSEFWRV9GRU5UUlk9eQpDT05GSUdfSEFWRV9DX1JFQ09SRE1DT1VOVD15CkNP TkZJR19UUkFDSU5HX1NVUFBPUlQ9eQojIENPTkZJR19GVFJBQ0UgaXMgbm90IHNldAoKIwojIFJ1 bnRpbWUgVGVzdGluZwojCiMgQ09ORklHX1RFU1RfTElTVF9TT1JUIGlzIG5vdCBzZXQKIyBDT05G SUdfQkFDS1RSQUNFX1NFTEZfVEVTVCBpcyBub3Qgc2V0CiMgQ09ORklHX1JCVFJFRV9URVNUIGlz IG5vdCBzZXQKIyBDT05GSUdfSU5URVJWQUxfVFJFRV9URVNUIGlzIG5vdCBzZXQKIyBDT05GSUdf QVRPTUlDNjRfU0VMRlRFU1QgaXMgbm90IHNldAojIENPTkZJR19URVNUX1NUUklOR19IRUxQRVJT IGlzIG5vdCBzZXQKIyBDT05GSUdfVEVTVF9LU1RSVE9YIGlzIG5vdCBzZXQKIyBDT05GSUdfUFJP VklERV9PSENJMTM5NF9ETUFfSU5JVCBpcyBub3Qgc2V0CiMgQ09ORklHX0RNQV9BUElfREVCVUcg aXMgbm90IHNldAojIENPTkZJR19TQU1QTEVTIGlzIG5vdCBzZXQKQ09ORklHX0hBVkVfQVJDSF9L R0RCPXkKIyBDT05GSUdfS0dEQiBpcyBub3Qgc2V0CiMgQ09ORklHX1NUUklDVF9ERVZNRU0gaXMg bm90IHNldAojIENPTkZJR19YODZfVkVSQk9TRV9CT09UVVAgaXMgbm90IHNldApDT05GSUdfRUFS TFlfUFJJTlRLPXkKIyBDT05GSUdfRUFSTFlfUFJJTlRLX0RCR1AgaXMgbm90IHNldAojIENPTkZJ R19YODZfUFREVU1QIGlzIG5vdCBzZXQKQ09ORklHX0RFQlVHX1JPREFUQT15CkNPTkZJR19ERUJV R19ST0RBVEFfVEVTVD15CiMgQ09ORklHX0RFQlVHX1NFVF9NT0RVTEVfUk9OWCBpcyBub3Qgc2V0 CiMgQ09ORklHX0RFQlVHX05YX1RFU1QgaXMgbm90IHNldApDT05GSUdfRE9VQkxFRkFVTFQ9eQoj IENPTkZJR19ERUJVR19UTEJGTFVTSCBpcyBub3Qgc2V0CiMgQ09ORklHX0lPTU1VX0RFQlVHIGlz IG5vdCBzZXQKIyBDT05GSUdfSU9NTVVfU1RSRVNTIGlzIG5vdCBzZXQKQ09ORklHX0hBVkVfTU1J T1RSQUNFX1NVUFBPUlQ9eQpDT05GSUdfSU9fREVMQVlfVFlQRV8wWDgwPTAKQ09ORklHX0lPX0RF TEFZX1RZUEVfMFhFRD0xCkNPTkZJR19JT19ERUxBWV9UWVBFX1VERUxBWT0yCkNPTkZJR19JT19E RUxBWV9UWVBFX05PTkU9MwpDT05GSUdfSU9fREVMQVlfMFg4MD15CiMgQ09ORklHX0lPX0RFTEFZ XzBYRUQgaXMgbm90IHNldAojIENPTkZJR19JT19ERUxBWV9VREVMQVkgaXMgbm90IHNldAojIENP TkZJR19JT19ERUxBWV9OT05FIGlzIG5vdCBzZXQKQ09ORklHX0RFRkFVTFRfSU9fREVMQVlfVFlQ RT0wCiMgQ09ORklHX0NQQV9ERUJVRyBpcyBub3Qgc2V0CiMgQ09ORklHX09QVElNSVpFX0lOTElO SU5HIGlzIG5vdCBzZXQKIyBDT05GSUdfREVCVUdfTk1JX1NFTEZURVNUIGlzIG5vdCBzZXQKIyBD T05GSUdfWDg2X0RFQlVHX1NUQVRJQ19DUFVfSEFTIGlzIG5vdCBzZXQKCiMKIyBTZWN1cml0eSBv cHRpb25zCiMKQ09ORklHX0tFWVM9eQojIENPTkZJR19FTkNSWVBURURfS0VZUyBpcyBub3Qgc2V0 CkNPTkZJR19LRVlTX0RFQlVHX1BST0NfS0VZUz15CiMgQ09ORklHX1NFQ1VSSVRZX0RNRVNHX1JF U1RSSUNUIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VDVVJJVFkgaXMgbm90IHNldAojIENPTkZJR19T RUNVUklUWUZTIGlzIG5vdCBzZXQKQ09ORklHX0RFRkFVTFRfU0VDVVJJVFlfREFDPXkKQ09ORklH X0RFRkFVTFRfU0VDVVJJVFk9IiIKQ09ORklHX1hPUl9CTE9DS1M9bQpDT05GSUdfQ1JZUFRPPXkK CiMKIyBDcnlwdG8gY29yZSBvciBoZWxwZXIKIwojIENPTkZJR19DUllQVE9fRklQUyBpcyBub3Qg c2V0CkNPTkZJR19DUllQVE9fQUxHQVBJPXkKQ09ORklHX0NSWVBUT19BTEdBUEkyPXkKQ09ORklH X0NSWVBUT19BRUFEPW0KQ09ORklHX0NSWVBUT19BRUFEMj15CkNPTkZJR19DUllQVE9fQkxLQ0lQ SEVSPXkKQ09ORklHX0NSWVBUT19CTEtDSVBIRVIyPXkKQ09ORklHX0NSWVBUT19IQVNIPXkKQ09O RklHX0NSWVBUT19IQVNIMj15CkNPTkZJR19DUllQVE9fUk5HPW0KQ09ORklHX0NSWVBUT19STkcy PXkKQ09ORklHX0NSWVBUT19QQ09NUDI9eQpDT05GSUdfQ1JZUFRPX01BTkFHRVI9eQpDT05GSUdf Q1JZUFRPX01BTkFHRVIyPXkKIyBDT05GSUdfQ1JZUFRPX1VTRVIgaXMgbm90IHNldAojIENPTkZJ R19DUllQVE9fTUFOQUdFUl9ESVNBQkxFX1RFU1RTIGlzIG5vdCBzZXQKQ09ORklHX0NSWVBUT19H RjEyOE1VTD15CiMgQ09ORklHX0NSWVBUT19OVUxMIGlzIG5vdCBzZXQKIyBDT05GSUdfQ1JZUFRP X1BDUllQVCBpcyBub3Qgc2V0CkNPTkZJR19DUllQVE9fV09SS1FVRVVFPXkKQ09ORklHX0NSWVBU T19DUllQVEQ9eQpDT05GSUdfQ1JZUFRPX0FVVEhFTkM9bQojIENPTkZJR19DUllQVE9fVEVTVCBp cyBub3Qgc2V0CkNPTkZJR19DUllQVE9fQUJMS19IRUxQRVJfWDg2PXkKQ09ORklHX0NSWVBUT19H TFVFX0hFTFBFUl9YODY9eQoKIwojIEF1dGhlbnRpY2F0ZWQgRW5jcnlwdGlvbiB3aXRoIEFzc29j aWF0ZWQgRGF0YQojCiMgQ09ORklHX0NSWVBUT19DQ00gaXMgbm90IHNldAojIENPTkZJR19DUllQ VE9fR0NNIGlzIG5vdCBzZXQKIyBDT05GSUdfQ1JZUFRPX1NFUUlWIGlzIG5vdCBzZXQKCiMKIyBC bG9jayBtb2RlcwojCkNPTkZJR19DUllQVE9fQ0JDPXkKIyBDT05GSUdfQ1JZUFRPX0NUUiBpcyBu b3Qgc2V0CiMgQ09ORklHX0NSWVBUT19DVFMgaXMgbm90IHNldApDT05GSUdfQ1JZUFRPX0VDQj1t CkNPTkZJR19DUllQVE9fTFJXPXkKQ09ORklHX0NSWVBUT19QQ0JDPW0KQ09ORklHX0NSWVBUT19Y VFM9eQoKIwojIEhhc2ggbW9kZXMKIwpDT05GSUdfQ1JZUFRPX0NNQUM9bQpDT05GSUdfQ1JZUFRP X0hNQUM9eQpDT05GSUdfQ1JZUFRPX1hDQkM9bQojIENPTkZJR19DUllQVE9fVk1BQyBpcyBub3Qg c2V0CgojCiMgRGlnZXN0CiMKQ09ORklHX0NSWVBUT19DUkMzMkM9eQojIENPTkZJR19DUllQVE9f Q1JDMzJDX0lOVEVMIGlzIG5vdCBzZXQKIyBDT05GSUdfQ1JZUFRPX0NSQzMyIGlzIG5vdCBzZXQK IyBDT05GSUdfQ1JZUFRPX0NSQzMyX1BDTE1VTCBpcyBub3Qgc2V0CkNPTkZJR19DUllQVE9fQ1JD VDEwRElGPW0KIyBDT05GSUdfQ1JZUFRPX0NSQ1QxMERJRl9QQ0xNVUwgaXMgbm90IHNldAojIENP TkZJR19DUllQVE9fR0hBU0ggaXMgbm90IHNldApDT05GSUdfQ1JZUFRPX01END1tCkNPTkZJR19D UllQVE9fTUQ1PXkKQ09ORklHX0NSWVBUT19NSUNIQUVMX01JQz1tCiMgQ09ORklHX0NSWVBUT19S TUQxMjggaXMgbm90IHNldAojIENPTkZJR19DUllQVE9fUk1EMTYwIGlzIG5vdCBzZXQKIyBDT05G SUdfQ1JZUFRPX1JNRDI1NiBpcyBub3Qgc2V0CiMgQ09ORklHX0NSWVBUT19STUQzMjAgaXMgbm90 IHNldApDT05GSUdfQ1JZUFRPX1NIQTE9eQpDT05GSUdfQ1JZUFRPX1NIQTFfU1NTRTM9eQpDT05G SUdfQ1JZUFRPX1NIQTI1Nl9TU1NFMz15CkNPTkZJR19DUllQVE9fU0hBNTEyX1NTU0UzPXkKQ09O RklHX0NSWVBUT19TSEEyNTY9eQpDT05GSUdfQ1JZUFRPX1NIQTUxMj15CiMgQ09ORklHX0NSWVBU T19UR1IxOTIgaXMgbm90IHNldAojIENPTkZJR19DUllQVE9fV1A1MTIgaXMgbm90IHNldAojIENP TkZJR19DUllQVE9fR0hBU0hfQ0xNVUxfTklfSU5URUwgaXMgbm90IHNldAoKIwojIENpcGhlcnMK IwpDT05GSUdfQ1JZUFRPX0FFUz15CkNPTkZJR19DUllQVE9fQUVTX1g4Nl82ND1tCkNPTkZJR19D UllQVE9fQUVTX05JX0lOVEVMPW0KIyBDT05GSUdfQ1JZUFRPX0FOVUJJUyBpcyBub3Qgc2V0CkNP TkZJR19DUllQVE9fQVJDND1tCkNPTkZJR19DUllQVE9fQkxPV0ZJU0g9bQpDT05GSUdfQ1JZUFRP X0JMT1dGSVNIX0NPTU1PTj1tCiMgQ09ORklHX0NSWVBUT19CTE9XRklTSF9YODZfNjQgaXMgbm90 IHNldApDT05GSUdfQ1JZUFRPX0NBTUVMTElBPW0KQ09ORklHX0NSWVBUT19DQU1FTExJQV9YODZf NjQ9eQpDT05GSUdfQ1JZUFRPX0NBTUVMTElBX0FFU05JX0FWWF9YODZfNjQ9eQpDT05GSUdfQ1JZ UFRPX0NBTUVMTElBX0FFU05JX0FWWDJfWDg2XzY0PXkKQ09ORklHX0NSWVBUT19DQVNUX0NPTU1P Tj1tCkNPTkZJR19DUllQVE9fQ0FTVDU9bQpDT05GSUdfQ1JZUFRPX0NBU1Q1X0FWWF9YODZfNjQ9 bQpDT05GSUdfQ1JZUFRPX0NBU1Q2PW0KQ09ORklHX0NSWVBUT19DQVNUNl9BVlhfWDg2XzY0PW0K Q09ORklHX0NSWVBUT19ERVM9eQpDT05GSUdfQ1JZUFRPX0ZDUllQVD1tCiMgQ09ORklHX0NSWVBU T19LSEFaQUQgaXMgbm90IHNldAojIENPTkZJR19DUllQVE9fU0FMU0EyMCBpcyBub3Qgc2V0CiMg Q09ORklHX0NSWVBUT19TQUxTQTIwX1g4Nl82NCBpcyBub3Qgc2V0CkNPTkZJR19DUllQVE9fU0VF RD1tCkNPTkZJR19DUllQVE9fU0VSUEVOVD15CkNPTkZJR19DUllQVE9fU0VSUEVOVF9TU0UyX1g4 Nl82ND15CkNPTkZJR19DUllQVE9fU0VSUEVOVF9BVlhfWDg2XzY0PXkKQ09ORklHX0NSWVBUT19T RVJQRU5UX0FWWDJfWDg2XzY0PXkKQ09ORklHX0NSWVBUT19URUE9bQpDT05GSUdfQ1JZUFRPX1RX T0ZJU0g9bQpDT05GSUdfQ1JZUFRPX1RXT0ZJU0hfQ09NTU9OPXkKQ09ORklHX0NSWVBUT19UV09G SVNIX1g4Nl82ND15CkNPTkZJR19DUllQVE9fVFdPRklTSF9YODZfNjRfM1dBWT15CkNPTkZJR19D UllQVE9fVFdPRklTSF9BVlhfWDg2XzY0PXkKCiMKIyBDb21wcmVzc2lvbgojCkNPTkZJR19DUllQ VE9fREVGTEFURT1tCiMgQ09ORklHX0NSWVBUT19aTElCIGlzIG5vdCBzZXQKQ09ORklHX0NSWVBU T19MWk89eQpDT05GSUdfQ1JZUFRPX0xaND1tCkNPTkZJR19DUllQVE9fTFo0SEM9bQoKIwojIFJh bmRvbSBOdW1iZXIgR2VuZXJhdGlvbgojCkNPTkZJR19DUllQVE9fQU5TSV9DUFJORz1tCiMgQ09O RklHX0NSWVBUT19VU0VSX0FQSV9IQVNIIGlzIG5vdCBzZXQKIyBDT05GSUdfQ1JZUFRPX1VTRVJf QVBJX1NLQ0lQSEVSIGlzIG5vdCBzZXQKQ09ORklHX0NSWVBUT19IVz15CiMgQ09ORklHX0NSWVBU T19ERVZfUEFETE9DSyBpcyBub3Qgc2V0CiMgQ09ORklHX0FTWU1NRVRSSUNfS0VZX1RZUEUgaXMg bm90IHNldApDT05GSUdfSEFWRV9LVk09eQpDT05GSUdfVklSVFVBTElaQVRJT049eQojIENPTkZJ R19LVk0gaXMgbm90IHNldAojIENPTkZJR19CSU5BUllfUFJJTlRGIGlzIG5vdCBzZXQKCiMKIyBM aWJyYXJ5IHJvdXRpbmVzCiMKQ09ORklHX1JBSUQ2X1BRPW0KQ09ORklHX0JJVFJFVkVSU0U9eQpD T05GSUdfR0VORVJJQ19TVFJOQ1BZX0ZST01fVVNFUj15CkNPTkZJR19HRU5FUklDX1NUUk5MRU5f VVNFUj15CkNPTkZJR19HRU5FUklDX05FVF9VVElMUz15CkNPTkZJR19HRU5FUklDX0ZJTkRfRklS U1RfQklUPXkKQ09ORklHX0dFTkVSSUNfUENJX0lPTUFQPXkKQ09ORklHX0dFTkVSSUNfSU9NQVA9 eQpDT05GSUdfR0VORVJJQ19JTz15CkNPTkZJR19BUkNIX1VTRV9DTVBYQ0hHX0xPQ0tSRUY9eQpD T05GSUdfQ01QWENIR19MT0NLUkVGPXkKQ09ORklHX0NSQ19DQ0lUVD1tCkNPTkZJR19DUkMxNj15 CkNPTkZJR19DUkNfVDEwRElGPW0KQ09ORklHX0NSQ19JVFVfVD15CkNPTkZJR19DUkMzMj15CiMg Q09ORklHX0NSQzMyX1NFTEZURVNUIGlzIG5vdCBzZXQKQ09ORklHX0NSQzMyX1NMSUNFQlk4PXkK IyBDT05GSUdfQ1JDMzJfU0xJQ0VCWTQgaXMgbm90IHNldAojIENPTkZJR19DUkMzMl9TQVJXQVRF IGlzIG5vdCBzZXQKIyBDT05GSUdfQ1JDMzJfQklUIGlzIG5vdCBzZXQKQ09ORklHX0NSQzc9bQpD T05GSUdfTElCQ1JDMzJDPXkKIyBDT05GSUdfQ1JDOCBpcyBub3Qgc2V0CkNPTkZJR19aTElCX0lO RkxBVEU9eQpDT05GSUdfWkxJQl9ERUZMQVRFPW0KQ09ORklHX0xaT19DT01QUkVTUz15CkNPTkZJ R19MWk9fREVDT01QUkVTUz15CkNPTkZJR19MWjRfQ09NUFJFU1M9bQpDT05GSUdfTFo0SENfQ09N UFJFU1M9bQpDT05GSUdfTFo0X0RFQ09NUFJFU1M9eQpDT05GSUdfWFpfREVDPXkKQ09ORklHX1ha X0RFQ19YODY9eQojIENPTkZJR19YWl9ERUNfUE9XRVJQQyBpcyBub3Qgc2V0CiMgQ09ORklHX1ha X0RFQ19JQTY0IGlzIG5vdCBzZXQKIyBDT05GSUdfWFpfREVDX0FSTSBpcyBub3Qgc2V0CiMgQ09O RklHX1haX0RFQ19BUk1USFVNQiBpcyBub3Qgc2V0CiMgQ09ORklHX1haX0RFQ19TUEFSQyBpcyBu b3Qgc2V0CkNPTkZJR19YWl9ERUNfQkNKPXkKIyBDT05GSUdfWFpfREVDX1RFU1QgaXMgbm90IHNl dApDT05GSUdfREVDT01QUkVTU19HWklQPXkKQ09ORklHX0RFQ09NUFJFU1NfQlpJUDI9eQpDT05G SUdfREVDT01QUkVTU19MWk1BPXkKQ09ORklHX0RFQ09NUFJFU1NfWFo9eQpDT05GSUdfREVDT01Q UkVTU19MWk89eQpDT05GSUdfREVDT01QUkVTU19MWjQ9eQpDT05GSUdfSEFTX0lPTUVNPXkKQ09O RklHX0hBU19JT1BPUlQ9eQpDT05GSUdfSEFTX0RNQT15CkNPTkZJR19DSEVDS19TSUdOQVRVUkU9 eQpDT05GSUdfQ1BVTUFTS19PRkZTVEFDSz15CkNPTkZJR19DUFVfUk1BUD15CkNPTkZJR19EUUw9 eQpDT05GSUdfTkxBVFRSPXkKQ09ORklHX0FSQ0hfSEFTX0FUT01JQzY0X0RFQ19JRl9QT1NJVElW RT15CkNPTkZJR19BVkVSQUdFPXkKIyBDT05GSUdfQ09SRElDIGlzIG5vdCBzZXQKIyBDT05GSUdf RERSIGlzIG5vdCBzZXQKQ09ORklHX1VDUzJfU1RSSU5HPXkKQ09ORklHX0ZPTlRfU1VQUE9SVD15 CiMgQ09ORklHX0ZPTlRTIGlzIG5vdCBzZXQKQ09ORklHX0ZPTlRfOHg4PXkKQ09ORklHX0ZPTlRf OHgxNj15Cg== --001a11c2aeda93361b04f5579d4e Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Disposition: inline _______________________________________________ Xen-users mailing list Xen-users@lists.xen.org http://lists.xen.org/xen-users --001a11c2aeda93361b04f5579d4e-- From xen-devel-bounces@lists.xen.org Mon Mar 24 12:34:23 2014 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Mon, 24 Mar 2014 12:34:23 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WS459-0001aN-4Y; Mon, 24 Mar 2014 12:34:23 +0000 Received: from mail6.bemta4.messagelabs.com ([85.158.143.247]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WS456-0001a5-Q3 for xen-devel@lists.xen.org; Mon, 24 Mar 2014 12:34:21 +0000 Received: from [85.158.143.35:24262] by server-3.bemta-4.messagelabs.com id CB/63-13602-C4620335; Mon, 24 Mar 2014 12:34:20 +0000 X-Env-Sender: roger.pau@citrix.com X-Msg-Ref: server-4.tower-21.messagelabs.com!1395664456!4251063!1 X-Originating-IP: [66.165.176.89] X-SpamReason: No, hits=0.0 required=7.0 tests=sa_preprocessor: VHJ1c3RlZCBJUDogNjYuMTY1LjE3Ni44OSA9PiAyMDMwMDc=\n X-StarScan-Received: X-StarScan-Version: 6.11.1; banners=-,-,- X-VirusChecked: Checked Received: (qmail 1206 invoked from network); 24 Mar 2014 12:34:18 -0000 Received: from smtp.citrix.com (HELO SMTP.CITRIX.COM) (66.165.176.89) by server-4.tower-21.messagelabs.com with RC4-SHA encrypted SMTP; 24 Mar 2014 12:34:18 -0000 X-IronPort-AV: E=Sophos;i="4.97,720,1389744000"; d="scan'208";a="114277916" Received: from accessns.citrite.net (HELO FTLPEX01CL03.citrite.net) ([10.9.154.239]) by FTLPIPO01.CITRIX.COM with ESMTP; 24 Mar 2014 12:34:08 +0000 Received: from [IPv6:::1] (10.80.16.47) by smtprelay.citrix.com (10.13.107.80) with Microsoft SMTP Server id 14.2.342.4; Mon, 24 Mar 2014 08:34:07 -0400 Message-ID: <5330263E.9060109@citrix.com> Date: Mon, 24 Mar 2014 13:34:06 +0100 From: =?ISO-8859-1?Q?Roger_Pau_Monn=E9?= User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.7; rv:24.0) Gecko/20100101 Thunderbird/24.4.0 MIME-Version: 1.0 To: xen-devel , Jan Beulich X-Enigmail-Version: 1.6 X-DLP: MIA1 Subject: [Xen-devel] Commit 7e90098 breaks Xen build on FreeBSD X-BeenThere: xen-devel@lists.xen.org X-Mailman-Version: 2.1.13 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Sender: xen-devel-bounces@lists.xen.org Errors-To: xen-devel-bounces@lists.xen.org Hello, This is the failed build output: # gmake -j12 xen gmake -C xen install gmake[1]: Entering directory `/root/xen/xen_pvh/xen' gmake -f Rules.mk _install gmake[2]: Entering directory `/root/xen/xen_pvh/xen' gmake -C tools gmake[3]: Entering directory `/root/xen/xen_pvh/xen/tools' gmake symbols gmake[4]: Entering directory `/root/xen/xen_pvh/xen/tools' gcc -Wall -Werror -Wstrict-prototypes -O2 -fomit-frame-pointer -fno-strict-aliasing -Wdeclaration-after-statement -o symbols symbols.c gmake[4]: Leaving directory `/root/xen/xen_pvh/xen/tools' gmake[3]: Leaving directory `/root/xen/xen_pvh/xen/tools' gmake -f /root/xen/xen_pvh/xen/Rules.mk include/xen/compile.h gmake[3]: Entering directory `/root/xen/xen_pvh/xen' __ __ _ _ ____ _ _ _ \ \/ /___ _ __ | || | | ___| _ _ _ __ ___| |_ __ _| |__ | | ___ \ // _ \ '_ \ | || |_ |___ \ __| | | | '_ \/ __| __/ _` | '_ \| |/ _ \ / \ __/ | | | |__ _| ___) |__| |_| | | | \__ \ || (_| | |_) | | __/ /_/\_\___|_| |_| |_|(_)____/ \__,_|_| |_|___/\__\__,_|_.__/|_|\___| gmake[3]: Leaving directory `/root/xen/xen_pvh/xen' [ -e include/asm ] || ln -sf asm-x86 include/asm gmake -f /root/xen/xen_pvh/xen/Rules.mk -C include gmake[3]: Entering directory `/root/xen/xen_pvh/xen/include' mkdir -p compat mkdir -p compat mkdir -p compat grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/event_channel.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/event_channel.c.new grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/elfnote.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/elfnote.c.new grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/callback.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/callback.c.new mkdir -p compat grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/features.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/features.c.new mkdir -p compat grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/grant_table.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/grant_table.c.new mkdir -p compat grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/kexec.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/kexec.c.new mkdir -p compat grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/memory.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/memory.c.new mkdir -p compat grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/nmi.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/nmi.c.new mkdir -p compat grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/physdev.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/physdev.c.new mkdir -p compat grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/platform.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/platform.c.new mkdir -p compat grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/sched.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/sched.c.new mkdir -p compat grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/tmem.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/tmem.c.new mv -f compat/nmi.c.new compat/nmi.c mv -f compat/features.c.new compat/features.c mv -f compat/callback.c.new compat/callback.c mkdir -p compat grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/trace.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/trace.c.new mv -f compat/elfnote.c.new compat/elfnote.c mkdir -p compat grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/vcpu.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/vcpu.c.new mv -f compat/kexec.c.new compat/kexec.c mkdir -p compat grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/version.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/version.c.new mv -f compat/sched.c.new compat/sched.c mv -f compat/event_channel.c.new compat/event_channel.c mkdir -p compat grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/xen.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/xen.c.new mkdir -p compat grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/xencomm.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/xencomm.c.new mv -f compat/tmem.c.new compat/tmem.c mv -f compat/memory.c.new compat/memory.c mkdir -p compat grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/xenoprof.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/xenoprof.c.new mkdir -p compat/arch-x86 grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/arch-x86/xen-mca.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/arch-x86/xen-mca.c.new mv -f compat/version.c.new compat/version.c mv -f compat/physdev.c.new compat/physdev.c mkdir -p compat/arch-x86 grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/arch-x86/xen.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/arch-x86/xen.c.new mv -f compat/xencomm.c.new compat/xencomm.c mv -f compat/trace.c.new compat/trace.c mv -f compat/grant_table.c.new compat/grant_table.c mkdir -p compat/arch-x86 grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/arch-x86/xen-x86_32.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/arch-x86/xen-x86_32.c.new mv -f compat/vcpu.c.new compat/vcpu.c mkdir -p compat grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/arch-x86_32.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/arch-x86_32.c.new cat >compat/xlat.h.new for i in public/trace.h public/tmem.h public/platform.h public/physdev.h public/grant_table.h public/callback.h public/xen-compat.h public/sched.h public/features.h public/xen.h public/dom0_ops.h public/mem_event.h public/version.h public/event_channel.h public/xenoprof.h public/elfnote.h public/gcov.h public/vcpu.h public/xencomm.h public/nmi.h public/kexec.h public/memory.h public/hvm/params.h public/hvm/hvm_info_table.h public/hvm/ioreq.h public/hvm/hvm_op.h public/hvm/hvm_xs_strings.h public/hvm/e820.h public/hvm/pvdrivers.h public/io/vscsiif.h public/io/libxenvchan.h public/io/pciif.h public/io/tpmif.h public/io/blkif.h public/io/usbif.h public/io/netif.h public/io/xenbus.h public/io/fbif.h public/io/fsif.h public/io/console.h public/io/ring.h public/io/protocols.h public/io/kbdif.h public/io/xs_wire.h; do clang -ansi -include stdint.h -Wall -W -Werror -S -o /dev/null -x c $i || exit 1; echo $i; done >headers.chk.new mv -f compat/xlat.h.new compat/xlat.h mv -f compat/platform.c.new compat/platform.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/callback.i compat/callback.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/elfnote.i compat/elfnote.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/event_channel.i compat/event_channel .c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/features.i compat/features.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/grant_table.i compat/grant_table.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/kexec.i compat/kexec.c mv -f compat/xenoprof.c.new compat/xenoprof.c mv -f compat/arch-x86_32.c.new compat/arch-x86_32.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/memory.i compat/memory.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/nmi.i compat/nmi.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/physdev.i compat/physdev.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/platform.i compat/platform.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/sched.i compat/sched.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/tmem.i compat/tmem.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/trace.i compat/trace.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/vcpu.i compat/vcpu.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/version.i compat/version.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/xencomm.i compat/xencomm.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/xenoprof.i compat/xenoprof.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/arch-x86_32.i compat/arch-x86_32.c mv -f compat/arch-x86/xen-x86_32.c.new compat/arch-x86/xen-x86_32.c set -e; id=_$(echo compat/callback.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/callback.h.new; \ echo "#define $id" >>compat/callback.h.new; \ echo "#include " >>compat/callback.h.new; \ echo "#include " >>compat/callback.h.new; \ echo "#pragma pack(4)" >>compat/callback.h.new; \ grep -v '^# [0-9]' compat/callback.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/callback.h.new; \ echo "#pragma pack()" >>compat/callback.h.new; \ echo "#endif /* $id */" >>compat/callback.h.new set -e; id=_$(echo compat/elfnote.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/elfnote.h.new; \ echo "#define $id" >>compat/elfnote.h.new; \ echo "#include " >>compat/elfnote.h.new; \ echo "#include " >>compat/elfnote.h.new; \ echo "#pragma pack(4)" >>compat/elfnote.h.new; \ grep -v '^# [0-9]' compat/elfnote.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/elfnote.h.new; \ echo "#pragma pack()" >>compat/elfnote.h.new; \ echo "#endif /* $id */" >>compat/elfnote.h.new mv -f compat/arch-x86/xen-mca.c.new compat/arch-x86/xen-mca.c set -e; id=_$(echo compat/event_channel.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/event_channel.h.new; \ echo "#define $id" >>compat/event_channel.h.new; \ echo "#include " >>compat/event_channel.h.new; \ echo "#include " >>compat/event_channel.h.new; \ echo "#pragma pack(4)" >>compat/event_channel.h.new; \ grep -v '^# [0-9]' compat/event_channel.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/event_channel.h.new; \ echo "#pragma pack()" >>compat/event_channel.h.new; \ echo "#endif /* $id */" >>compat/event_channel.h.new mv -f compat/arch-x86/xen.c.new compat/arch-x86/xen.c set -e; id=_$(echo compat/features.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/features.h.new; \ echo "#define $id" >>compat/features.h.new; \ echo "#include " >>compat/features.h.new; \ echo "#include " >>compat/features.h.new; \ echo "#pragma pack(4)" >>compat/features.h.new; \ grep -v '^# [0-9]' compat/features.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/features.h.new; \ echo "#pragma pack()" >>compat/features.h.new; \ echo "#endif /* $id */" >>compat/features.h.new set -e; id=_$(echo compat/grant_table.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/grant_table.h.new; \ echo "#define $id" >>compat/grant_table.h.new; \ echo "#include " >>compat/grant_table.h.new; \ echo "#include " >>compat/grant_table.h.new; \ echo "#pragma pack(4)" >>compat/grant_table.h.new; \ grep -v '^# [0-9]' compat/grant_table.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/grant_table.h.new; \ echo "#pragma pack()" >>compat/grant_table.h.new; \ echo "#endif /* $id */" >>compat/grant_table.h.new set -e; id=_$(echo compat/kexec.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/kexec.h.new; \ echo "#define $id" >>compat/kexec.h.new; \ echo "#include " >>compat/kexec.h.new; \ echo "#include " >>compat/kexec.h.new; \ echo "#pragma pack(4)" >>compat/kexec.h.new; \ grep -v '^# [0-9]' compat/kexec.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/kexec.h.new; \ echo "#pragma pack()" >>compat/kexec.h.new; \ echo "#endif /* $id */" >>compat/kexec.h.new set -e; id=_$(echo compat/memory.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/memory.h.new; \ echo "#define $id" >>compat/memory.h.new; \ echo "#include " >>compat/memory.h.new; \ echo "#include " >>compat/memory.h.new; \ echo "#pragma pack(4)" >>compat/memory.h.new; \ grep -v '^# [0-9]' compat/memory.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/memory.h.new; \ echo "#pragma pack()" >>compat/memory.h.new; \ echo "#endif /* $id */" >>compat/memory.h.new set -e; id=_$(echo compat/nmi.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/nmi.h.new; \ echo "#define $id" >>compat/nmi.h.new; \ echo "#include " >>compat/nmi.h.new; \ echo "#include " >>compat/nmi.h.new; \ echo "#pragma pack(4)" >>compat/nmi.h.new; \ grep -v '^# [0-9]' compat/nmi.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/nmi.h.new; \ echo "#pragma pack()" >>compat/nmi.h.new; \ echo "#endif /* $id */" >>compat/nmi.h.new set -e; id=_$(echo compat/physdev.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/physdev.h.new; \ echo "#define $id" >>compat/physdev.h.new; \ echo "#include " >>compat/physdev.h.new; \ echo "#include " >>compat/physdev.h.new; \ echo "#pragma pack(4)" >>compat/physdev.h.new; \ grep -v '^# [0-9]' compat/physdev.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/physdev.h.new; \ echo "#pragma pack()" >>compat/physdev.h.new; \ echo "#endif /* $id */" >>compat/physdev.h.new set -e; id=_$(echo compat/platform.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/platform.h.new; \ echo "#define $id" >>compat/platform.h.new; \ echo "#include " >>compat/platform.h.new; \ echo "#include " >>compat/platform.h.new; \ echo "#pragma pack(4)" >>compat/platform.h.new; \ grep -v '^# [0-9]' compat/platform.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/platform.h.new; \ echo "#pragma pack()" >>compat/platform.h.new; \ echo "#endif /* $id */" >>compat/platform.h.new mv -f compat/features.h.new compat/features.h mv -f compat/callback.h.new compat/callback.h mv -f compat/elfnote.h.new compat/elfnote.h set -e; id=_$(echo compat/sched.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/sched.h.new; \ echo "#define $id" >>compat/sched.h.new; \ echo "#include " >>compat/sched.h.new; \ echo "#include " >>compat/sched.h.new; \ echo "#pragma pack(4)" >>compat/sched.h.new; \ grep -v '^# [0-9]' compat/sched.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/sched.h.new; \ echo "#pragma pack()" >>compat/sched.h.new; \ echo "#endif /* $id */" >>compat/sched.h.new set -e; id=_$(echo compat/tmem.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/tmem.h.new; \ echo "#define $id" >>compat/tmem.h.new; \ echo "#include " >>compat/tmem.h.new; \ echo "#include " >>compat/tmem.h.new; \ echo "#pragma pack(4)" >>compat/tmem.h.new; \ grep -v '^# [0-9]' compat/tmem.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/tmem.h.new; \ echo "#pragma pack()" >>compat/tmem.h.new; \ echo "#endif /* $id */" >>compat/tmem.h.new mv -f compat/event_channel.h.new compat/event_channel.h set -e; id=_$(echo compat/trace.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/trace.h.new; \ echo "#define $id" >>compat/trace.h.new; \ echo "#include " >>compat/trace.h.new; \ echo "#include " >>compat/trace.h.new; \ echo "#pragma pack(4)" >>compat/trace.h.new; \ grep -v '^# [0-9]' compat/trace.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/trace.h.new; \ echo "#pragma pack()" >>compat/trace.h.new; \ echo "#endif /* $id */" >>compat/trace.h.new mv -f compat/nmi.h.new compat/nmi.h mv -f compat/kexec.h.new compat/kexec.h set -e; id=_$(echo compat/vcpu.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/vcpu.h.new; \ echo "#define $id" >>compat/vcpu.h.new; \ echo "#include " >>compat/vcpu.h.new; \ echo "#include " >>compat/vcpu.h.new; \ echo "#pragma pack(4)" >>compat/vcpu.h.new; \ grep -v '^# [0-9]' compat/vcpu.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/vcpu.h.new; \ echo "#pragma pack()" >>compat/vcpu.h.new; \ echo "#endif /* $id */" >>compat/vcpu.h.new mv -f compat/grant_table.h.new compat/grant_table.h mv -f compat/xen.c.new compat/xen.c mv -f compat/memory.h.new compat/memory.h set -e; id=_$(echo compat/version.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/version.h.new; \ echo "#define $id" >>compat/version.h.new; \ echo "#include " >>compat/version.h.new; \ echo "#include " >>compat/version.h.new; \ echo "#pragma pack(4)" >>compat/version.h.new; \ grep -v '^# [0-9]' compat/version.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/version.h.new; \ echo "#pragma pack()" >>compat/version.h.new; \ echo "#endif /* $id */" >>compat/version.h.new set -e; id=_$(echo compat/xencomm.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/xencomm.h.new; \ echo "#define $id" >>compat/xencomm.h.new; \ echo "#include " >>compat/xencomm.h.new; \ echo "#include " >>compat/xencomm.h.new; \ echo "#pragma pack(4)" >>compat/xencomm.h.new; \ grep -v '^# [0-9]' compat/xencomm.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/xencomm.h.new; \ echo "#pragma pack()" >>compat/xencomm.h.new; \ echo "#endif /* $id */" >>compat/xencomm.h.new mv -f compat/physdev.h.new compat/physdev.h set -e; id=_$(echo compat/xenoprof.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/xenoprof.h.new; \ echo "#define $id" >>compat/xenoprof.h.new; \ echo "#include " >>compat/xenoprof.h.new; \ echo "#include " >>compat/xenoprof.h.new; \ echo "#pragma pack(4)" >>compat/xenoprof.h.new; \ grep -v '^# [0-9]' compat/xenoprof.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/xenoprof.h.new; \ echo "#pragma pack()" >>compat/xenoprof.h.new; \ echo "#endif /* $id */" >>compat/xenoprof.h.new mv -f compat/platform.h.new compat/platform.h clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/arch-x86/xen-mca.i compat/arch-x86/x en-mca.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/arch-x86/xen.i compat/arch-x86/xen.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/arch-x86/xen-x86_32.i compat/arch-x8 6/xen-x86_32.c set -e; id=_$(echo compat/arch-x86_32.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/arch-x86_32.h.new; \ echo "#define $id" >>compat/arch-x86_32.h.new; \ echo "#include " >>compat/arch-x86_32.h.new; \ \ echo "#pragma pack(4)" >>compat/arch-x86_32.h.new; \ grep -v '^# [0-9]' compat/arch-x86_32.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/arch-x86_32.h.new; \ echo "#pragma pack()" >>compat/arch-x86_32.h.new; \ echo "#endif /* $id */" >>compat/arch-x86_32.h.new mv -f compat/sched.h.new compat/sched.h mv -f compat/trace.h.new compat/trace.h mv -f compat/tmem.h.new compat/tmem.h clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/xen.i compat/xen.c set -e; id=_$(echo compat/arch-x86/xen-mca.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/arch-x86/xen-mca.h.new; \ echo "#define $id" >>compat/arch-x86/xen-mca.h.new; \ echo "#include " >>compat/arch-x86/xen-mca.h.new; \ \ echo "#pragma pack(4)" >>compat/arch-x86/xen-mca.h.new; \ grep -v '^# [0-9]' compat/arch-x86/xen-mca.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/arch-x86/xen-mca.h.new; \ echo "#pragma pack()" >>compat/arch-x86/xen-mca.h.new; \ echo "#endif /* $id */" >>compat/arch-x86/xen-mca.h.new set -e; id=_$(echo compat/arch-x86/xen.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/arch-x86/xen.h.new; \ echo "#define $id" >>compat/arch-x86/xen.h.new; \ echo "#include " >>compat/arch-x86/xen.h.new; \ \ echo "#pragma pack(4)" >>compat/arch-x86/xen.h.new; \ grep -v '^# [0-9]' compat/arch-x86/xen.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/arch-x86/xen.h.new; \ echo "#pragma pack()" >>compat/arch-x86/xen.h.new; \ echo "#endif /* $id */" >>compat/arch-x86/xen.h.new mv -f compat/xencomm.h.new compat/xencomm.h mv -f compat/version.h.new compat/version.h mv -f compat/vcpu.h.new compat/vcpu.h set -e; id=_$(echo compat/arch-x86/xen-x86_32.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/arch-x86/xen-x86_32.h.new; \ echo "#define $id" >>compat/arch-x86/xen-x86_32.h.new; \ echo "#include " >>compat/arch-x86/xen-x86_32.h.new; \ \ echo "#pragma pack(4)" >>compat/arch-x86/xen-x86_32.h.new; \ grep -v '^# [0-9]' compat/arch-x86/xen-x86_32.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/arch-x86/xen-x86_32.h.new; \ echo "#pragma pack()" >>compat/arch-x86/xen-x86_32.h.new; \ echo "#endif /* $id */" >>compat/arch-x86/xen-x86_32.h.new mv -f compat/xenoprof.h.new compat/xenoprof.h mv -f compat/arch-x86_32.h.new compat/arch-x86_32.h set -e; id=_$(echo compat/xen.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/xen.h.new; \ echo "#define $id" >>compat/xen.h.new; \ echo "#include " >>compat/xen.h.new; \ echo "#include " >>compat/xen.h.new; \ echo "#pragma pack(4)" >>compat/xen.h.new; \ grep -v '^# [0-9]' compat/xen.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/xen.h.new; \ echo "#pragma pack()" >>compat/xen.h.new; \ echo "#endif /* $id */" >>compat/xen.h.new mv -f compat/arch-x86/xen.h.new compat/arch-x86/xen.h mv -f compat/arch-x86/xen-x86_32.h.new compat/arch-x86/xen-x86_32.h mv -f compat/arch-x86/xen-mca.h.new compat/arch-x86/xen-mca.h mv headers.chk.new headers.chk mv -f compat/xen.h.new compat/xen.h rm compat/xen.c compat/kexec.i compat/arch-x86_32.c compat/arch-x86/xen-x86_32.c compat/sched.c compat/vcpu.c compat/xen.i compat/physdev.i compat/tmem.i compat/trace.i compat/features.i compat/callback.c compat/xencomm.i compat/arch-x86/xen.i compat/elfnote.c compat/arch-x86/xen-mca.i compat/version.i compat/event_channel.i compat/platform.i compat/kexec.c compat/tmem.c compat/nmi.i compat/arch-x86/xen-x86_32.i compat/elfnote.i compat/physdev.c compat/vcpu.i compat/trace.c compat/features.c compat/event_channel.c compat/grant_table.i compat/memory.c compat/xencomm.c compat/arch-x86/xen.c compat/arch-x86/xen-mca.c compat/version.c compat/arch-x86_32.i compat/platform.c compat/memory.i compat/sched.i compat/nmi.c compat/callback.i compat/xenoprof.c compat/xenoprof.i compat/grant_table.c gmake[3]: Leaving directory `/root/xen/xen_pvh/xen/include' gmake -f /root/xen/xen_pvh/xen/Rules.mk -C arch/x86 asm-offsets.s gmake[3]: Entering directory `/root/xen/xen_pvh/xen/arch/x86' clang -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -include /root/xen/xen_pvh/xen/include/xen/config.h -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -MMD -MF .asm-offsets.s.d -S -o asm-offsets.s x86_64/asm-offsets.c In file included from x86_64/asm-offsets.c:10: In file included from /root/xen/xen_pvh/xen/include/xen/sched.h:7: In file included from /root/xen/xen_pvh/xen/include/xen/shared.h:6: In file included from /root/xen/xen_pvh/xen/include/compat/xen.h:3: /root/xen/xen_pvh/xen/include/xen/compat.h:221:48: error: declaration of 'enum XLAT_start_info_console' will not be visible outside of this function [-Werror,-Wvisibility] void xlat_start_info(struct start_info *, enum XLAT_start_info_console); ^ 1 error generated. gmake[3]: *** [asm-offsets.s] Error 1 gmake[3]: Leaving directory `/root/xen/xen_pvh/xen/arch/x86' gmake[2]: *** [/root/xen/xen_pvh/xen/xen] Error 2 gmake[2]: Leaving directory `/root/xen/xen_pvh/xen' gmake[1]: *** [install] Error 2 gmake[1]: Leaving directory `/root/xen/xen_pvh/xen' gmake: *** [install-xen] Error 2 On the other hand, if I don't use multiple make jobs: # gmake xen gmake -C xen install gmake[1]: Entering directory `/root/xen/xen_pvh/xen' gmake -f Rules.mk _install gmake[2]: Entering directory `/root/xen/xen_pvh/xen' gmake -C tools gmake[3]: Entering directory `/root/xen/xen_pvh/xen/tools' gmake symbols gmake[4]: Entering directory `/root/xen/xen_pvh/xen/tools' gcc -Wall -Werror -Wstrict-prototypes -O2 -fomit-frame-pointer -fno-strict-aliasing -Wdeclaration-after-statement -o symbols symbols.c gmake[4]: Leaving directory `/root/xen/xen_pvh/xen/tools' gmake[3]: Leaving directory `/root/xen/xen_pvh/xen/tools' gmake -f /root/xen/xen_pvh/xen/Rules.mk include/xen/compile.h gmake[3]: Entering directory `/root/xen/xen_pvh/xen' __ __ _ _ ____ _ _ _ \ \/ /___ _ __ | || | | ___| _ _ _ __ ___| |_ __ _| |__ | | ___ \ // _ \ '_ \ | || |_ |___ \ __| | | | '_ \/ __| __/ _` | '_ \| |/ _ \ / \ __/ | | | |__ _| ___) |__| |_| | | | \__ \ || (_| | |_) | | __/ /_/\_\___|_| |_| |_|(_)____/ \__,_|_| |_|___/\__\__,_|_.__/|_|\___| gmake[3]: Leaving directory `/root/xen/xen_pvh/xen' [ -e include/asm ] || ln -sf asm-x86 include/asm gmake -f /root/xen/xen_pvh/xen/Rules.mk -C include gmake[3]: Entering directory `/root/xen/xen_pvh/xen/include' mkdir -p compat grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/callback.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/callback.c.new mv -f compat/callback.c.new compat/callback.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/callback.i compat/callback.c set -e; id=_$(echo compat/callback.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/callback.h.new; \ echo "#define $id" >>compat/callback.h.new; \ echo "#include " >>compat/callback.h.new; \ echo "#include " >>compat/callback.h.new; \ echo "#pragma pack(4)" >>compat/callback.h.new; \ grep -v '^# [0-9]' compat/callback.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/callback.h.new; \ echo "#pragma pack()" >>compat/callback.h.new; \ echo "#endif /* $id */" >>compat/callback.h.new mv -f compat/callback.h.new compat/callback.h mkdir -p compat grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/elfnote.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/elfnote.c.new mv -f compat/elfnote.c.new compat/elfnote.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/elfnote.i compat/elfnote.c set -e; id=_$(echo compat/elfnote.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/elfnote.h.new; \ echo "#define $id" >>compat/elfnote.h.new; \ echo "#include " >>compat/elfnote.h.new; \ echo "#include " >>compat/elfnote.h.new; \ echo "#pragma pack(4)" >>compat/elfnote.h.new; \ grep -v '^# [0-9]' compat/elfnote.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/elfnote.h.new; \ echo "#pragma pack()" >>compat/elfnote.h.new; \ echo "#endif /* $id */" >>compat/elfnote.h.new mv -f compat/elfnote.h.new compat/elfnote.h mkdir -p compat grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/event_channel.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/event_channel.c.new mv -f compat/event_channel.c.new compat/event_channel.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/event_channel.i compat/event_channel .c set -e; id=_$(echo compat/event_channel.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/event_channel.h.new; \ echo "#define $id" >>compat/event_channel.h.new; \ echo "#include " >>compat/event_channel.h.new; \ echo "#include " >>compat/event_channel.h.new; \ echo "#pragma pack(4)" >>compat/event_channel.h.new; \ grep -v '^# [0-9]' compat/event_channel.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/event_channel.h.new; \ echo "#pragma pack()" >>compat/event_channel.h.new; \ echo "#endif /* $id */" >>compat/event_channel.h.new mv -f compat/event_channel.h.new compat/event_channel.h mkdir -p compat grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/features.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/features.c.new mv -f compat/features.c.new compat/features.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/features.i compat/features.c set -e; id=_$(echo compat/features.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/features.h.new; \ echo "#define $id" >>compat/features.h.new; \ echo "#include " >>compat/features.h.new; \ echo "#include " >>compat/features.h.new; \ echo "#pragma pack(4)" >>compat/features.h.new; \ grep -v '^# [0-9]' compat/features.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/features.h.new; \ echo "#pragma pack()" >>compat/features.h.new; \ echo "#endif /* $id */" >>compat/features.h.new mv -f compat/features.h.new compat/features.h mkdir -p compat grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/grant_table.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/grant_table.c.new mv -f compat/grant_table.c.new compat/grant_table.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/grant_table.i compat/grant_table.c set -e; id=_$(echo compat/grant_table.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/grant_table.h.new; \ echo "#define $id" >>compat/grant_table.h.new; \ echo "#include " >>compat/grant_table.h.new; \ echo "#include " >>compat/grant_table.h.new; \ echo "#pragma pack(4)" >>compat/grant_table.h.new; \ grep -v '^# [0-9]' compat/grant_table.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/grant_table.h.new; \ echo "#pragma pack()" >>compat/grant_table.h.new; \ echo "#endif /* $id */" >>compat/grant_table.h.new mv -f compat/grant_table.h.new compat/grant_table.h mkdir -p compat grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/kexec.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/kexec.c.new mv -f compat/kexec.c.new compat/kexec.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/kexec.i compat/kexec.c set -e; id=_$(echo compat/kexec.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/kexec.h.new; \ echo "#define $id" >>compat/kexec.h.new; \ echo "#include " >>compat/kexec.h.new; \ echo "#include " >>compat/kexec.h.new; \ echo "#pragma pack(4)" >>compat/kexec.h.new; \ grep -v '^# [0-9]' compat/kexec.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/kexec.h.new; \ echo "#pragma pack()" >>compat/kexec.h.new; \ echo "#endif /* $id */" >>compat/kexec.h.new mv -f compat/kexec.h.new compat/kexec.h mkdir -p compat grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/memory.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/memory.c.new mv -f compat/memory.c.new compat/memory.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/memory.i compat/memory.c set -e; id=_$(echo compat/memory.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/memory.h.new; \ echo "#define $id" >>compat/memory.h.new; \ echo "#include " >>compat/memory.h.new; \ echo "#include " >>compat/memory.h.new; \ echo "#pragma pack(4)" >>compat/memory.h.new; \ grep -v '^# [0-9]' compat/memory.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/memory.h.new; \ echo "#pragma pack()" >>compat/memory.h.new; \ echo "#endif /* $id */" >>compat/memory.h.new mv -f compat/memory.h.new compat/memory.h mkdir -p compat grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/nmi.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/nmi.c.new mv -f compat/nmi.c.new compat/nmi.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/nmi.i compat/nmi.c set -e; id=_$(echo compat/nmi.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/nmi.h.new; \ echo "#define $id" >>compat/nmi.h.new; \ echo "#include " >>compat/nmi.h.new; \ echo "#include " >>compat/nmi.h.new; \ echo "#pragma pack(4)" >>compat/nmi.h.new; \ grep -v '^# [0-9]' compat/nmi.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/nmi.h.new; \ echo "#pragma pack()" >>compat/nmi.h.new; \ echo "#endif /* $id */" >>compat/nmi.h.new mv -f compat/nmi.h.new compat/nmi.h mkdir -p compat grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/physdev.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/physdev.c.new mv -f compat/physdev.c.new compat/physdev.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/physdev.i compat/physdev.c set -e; id=_$(echo compat/physdev.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/physdev.h.new; \ echo "#define $id" >>compat/physdev.h.new; \ echo "#include " >>compat/physdev.h.new; \ echo "#include " >>compat/physdev.h.new; \ echo "#pragma pack(4)" >>compat/physdev.h.new; \ grep -v '^# [0-9]' compat/physdev.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/physdev.h.new; \ echo "#pragma pack()" >>compat/physdev.h.new; \ echo "#endif /* $id */" >>compat/physdev.h.new mv -f compat/physdev.h.new compat/physdev.h mkdir -p compat grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/platform.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/platform.c.new mv -f compat/platform.c.new compat/platform.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/platform.i compat/platform.c set -e; id=_$(echo compat/platform.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/platform.h.new; \ echo "#define $id" >>compat/platform.h.new; \ echo "#include " >>compat/platform.h.new; \ echo "#include " >>compat/platform.h.new; \ echo "#pragma pack(4)" >>compat/platform.h.new; \ grep -v '^# [0-9]' compat/platform.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/platform.h.new; \ echo "#pragma pack()" >>compat/platform.h.new; \ echo "#endif /* $id */" >>compat/platform.h.new mv -f compat/platform.h.new compat/platform.h mkdir -p compat grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/sched.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/sched.c.new mv -f compat/sched.c.new compat/sched.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/sched.i compat/sched.c set -e; id=_$(echo compat/sched.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/sched.h.new; \ echo "#define $id" >>compat/sched.h.new; \ echo "#include " >>compat/sched.h.new; \ echo "#include " >>compat/sched.h.new; \ echo "#pragma pack(4)" >>compat/sched.h.new; \ grep -v '^# [0-9]' compat/sched.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/sched.h.new; \ echo "#pragma pack()" >>compat/sched.h.new; \ echo "#endif /* $id */" >>compat/sched.h.new mv -f compat/sched.h.new compat/sched.h mkdir -p compat grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/tmem.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/tmem.c.new mv -f compat/tmem.c.new compat/tmem.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/tmem.i compat/tmem.c set -e; id=_$(echo compat/tmem.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/tmem.h.new; \ echo "#define $id" >>compat/tmem.h.new; \ echo "#include " >>compat/tmem.h.new; \ echo "#include " >>compat/tmem.h.new; \ echo "#pragma pack(4)" >>compat/tmem.h.new; \ grep -v '^# [0-9]' compat/tmem.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/tmem.h.new; \ echo "#pragma pack()" >>compat/tmem.h.new; \ echo "#endif /* $id */" >>compat/tmem.h.new mv -f compat/tmem.h.new compat/tmem.h mkdir -p compat grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/trace.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/trace.c.new mv -f compat/trace.c.new compat/trace.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/trace.i compat/trace.c set -e; id=_$(echo compat/trace.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/trace.h.new; \ echo "#define $id" >>compat/trace.h.new; \ echo "#include " >>compat/trace.h.new; \ echo "#include " >>compat/trace.h.new; \ echo "#pragma pack(4)" >>compat/trace.h.new; \ grep -v '^# [0-9]' compat/trace.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/trace.h.new; \ echo "#pragma pack()" >>compat/trace.h.new; \ echo "#endif /* $id */" >>compat/trace.h.new mv -f compat/trace.h.new compat/trace.h mkdir -p compat grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/vcpu.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/vcpu.c.new mv -f compat/vcpu.c.new compat/vcpu.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/vcpu.i compat/vcpu.c set -e; id=_$(echo compat/vcpu.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/vcpu.h.new; \ echo "#define $id" >>compat/vcpu.h.new; \ echo "#include " >>compat/vcpu.h.new; \ echo "#include " >>compat/vcpu.h.new; \ echo "#pragma pack(4)" >>compat/vcpu.h.new; \ grep -v '^# [0-9]' compat/vcpu.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/vcpu.h.new; \ echo "#pragma pack()" >>compat/vcpu.h.new; \ echo "#endif /* $id */" >>compat/vcpu.h.new mv -f compat/vcpu.h.new compat/vcpu.h mkdir -p compat grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/version.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/version.c.new mv -f compat/version.c.new compat/version.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/version.i compat/version.c set -e; id=_$(echo compat/version.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/version.h.new; \ echo "#define $id" >>compat/version.h.new; \ echo "#include " >>compat/version.h.new; \ echo "#include " >>compat/version.h.new; \ echo "#pragma pack(4)" >>compat/version.h.new; \ grep -v '^# [0-9]' compat/version.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/version.h.new; \ echo "#pragma pack()" >>compat/version.h.new; \ echo "#endif /* $id */" >>compat/version.h.new mv -f compat/version.h.new compat/version.h mkdir -p compat grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/xen.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/xen.c.new mv -f compat/xen.c.new compat/xen.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/xen.i compat/xen.c set -e; id=_$(echo compat/xen.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/xen.h.new; \ echo "#define $id" >>compat/xen.h.new; \ echo "#include " >>compat/xen.h.new; \ echo "#include " >>compat/xen.h.new; \ echo "#pragma pack(4)" >>compat/xen.h.new; \ grep -v '^# [0-9]' compat/xen.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/xen.h.new; \ echo "#pragma pack()" >>compat/xen.h.new; \ echo "#endif /* $id */" >>compat/xen.h.new mv -f compat/xen.h.new compat/xen.h mkdir -p compat grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/xencomm.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/xencomm.c.new mv -f compat/xencomm.c.new compat/xencomm.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/xencomm.i compat/xencomm.c set -e; id=_$(echo compat/xencomm.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/xencomm.h.new; \ echo "#define $id" >>compat/xencomm.h.new; \ echo "#include " >>compat/xencomm.h.new; \ echo "#include " >>compat/xencomm.h.new; \ echo "#pragma pack(4)" >>compat/xencomm.h.new; \ grep -v '^# [0-9]' compat/xencomm.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/xencomm.h.new; \ echo "#pragma pack()" >>compat/xencomm.h.new; \ echo "#endif /* $id */" >>compat/xencomm.h.new mv -f compat/xencomm.h.new compat/xencomm.h mkdir -p compat grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/xenoprof.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/xenoprof.c.new mv -f compat/xenoprof.c.new compat/xenoprof.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/xenoprof.i compat/xenoprof.c set -e; id=_$(echo compat/xenoprof.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/xenoprof.h.new; \ echo "#define $id" >>compat/xenoprof.h.new; \ echo "#include " >>compat/xenoprof.h.new; \ echo "#include " >>compat/xenoprof.h.new; \ echo "#pragma pack(4)" >>compat/xenoprof.h.new; \ grep -v '^# [0-9]' compat/xenoprof.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/xenoprof.h.new; \ echo "#pragma pack()" >>compat/xenoprof.h.new; \ echo "#endif /* $id */" >>compat/xenoprof.h.new mv -f compat/xenoprof.h.new compat/xenoprof.h mkdir -p compat/arch-x86 grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/arch-x86/xen-mca.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/arch-x86/xen-mca.c.new mv -f compat/arch-x86/xen-mca.c.new compat/arch-x86/xen-mca.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/arch-x86/xen-mca.i compat/arch-x86/x en-mca.c set -e; id=_$(echo compat/arch-x86/xen-mca.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/arch-x86/xen-mca.h.new; \ echo "#define $id" >>compat/arch-x86/xen-mca.h.new; \ echo "#include " >>compat/arch-x86/xen-mca.h.new; \ \ echo "#pragma pack(4)" >>compat/arch-x86/xen-mca.h.new; \ grep -v '^# [0-9]' compat/arch-x86/xen-mca.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/arch-x86/xen-mca.h.new; \ echo "#pragma pack()" >>compat/arch-x86/xen-mca.h.new; \ echo "#endif /* $id */" >>compat/arch-x86/xen-mca.h.new mv -f compat/arch-x86/xen-mca.h.new compat/arch-x86/xen-mca.h mkdir -p compat/arch-x86 grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/arch-x86/xen.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/arch-x86/xen.c.new mv -f compat/arch-x86/xen.c.new compat/arch-x86/xen.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/arch-x86/xen.i compat/arch-x86/xen.c set -e; id=_$(echo compat/arch-x86/xen.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/arch-x86/xen.h.new; \ echo "#define $id" >>compat/arch-x86/xen.h.new; \ echo "#include " >>compat/arch-x86/xen.h.new; \ \ echo "#pragma pack(4)" >>compat/arch-x86/xen.h.new; \ grep -v '^# [0-9]' compat/arch-x86/xen.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/arch-x86/xen.h.new; \ echo "#pragma pack()" >>compat/arch-x86/xen.h.new; \ echo "#endif /* $id */" >>compat/arch-x86/xen.h.new mv -f compat/arch-x86/xen.h.new compat/arch-x86/xen.h mkdir -p compat/arch-x86 grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/arch-x86/xen-x86_32.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/arch-x86/xen-x86_32.c.new mv -f compat/arch-x86/xen-x86_32.c.new compat/arch-x86/xen-x86_32.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/arch-x86/xen-x86_32.i compat/arch-x8 6/xen-x86_32.c set -e; id=_$(echo compat/arch-x86/xen-x86_32.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/arch-x86/xen-x86_32.h.new; \ echo "#define $id" >>compat/arch-x86/xen-x86_32.h.new; \ echo "#include " >>compat/arch-x86/xen-x86_32.h.new; \ \ echo "#pragma pack(4)" >>compat/arch-x86/xen-x86_32.h.new; \ grep -v '^# [0-9]' compat/arch-x86/xen-x86_32.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/arch-x86/xen-x86_32.h.new; \ echo "#pragma pack()" >>compat/arch-x86/xen-x86_32.h.new; \ echo "#endif /* $id */" >>compat/arch-x86/xen-x86_32.h.new mv -f compat/arch-x86/xen-x86_32.h.new compat/arch-x86/xen-x86_32.h mkdir -p compat grep -v 'DEFINE_XEN_GUEST_HANDLE(long)' public/arch-x86_32.h | \ python /root/xen/xen_pvh/xen/tools/compat-build-source.py >compat/arch-x86_32.c.new mv -f compat/arch-x86_32.c.new compat/arch-x86_32.c clang -E -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -I/root/xen/xen_pvh/xen/include -I/root/xen/xen_pvh/xen/include/asm-x86/mach-generic -I/root/xen/xen_pvh/xen/include/asm-x86/mach-default -msoft-float -fno-stack-protector -fno-exceptions -Wnested-externs -DHAVE_GAS_VMX -DHAVE_GAS_EPT -DHAVE_GAS_FSGSBASE -mno-red-zone -mno-sse -fpic -fno-asynchronous-unwind-tables -DGCC_HAS_VISIBILITY_ATTRIBUTE -fno-builtin -fno-common -Werror -Wredundant-decls -Wno-pointer-arith -pipe -g -D__XEN__ -nostdinc -Wno-parentheses -Wno-format -Wno-unused-value -DVERBOSE -DHAS_ACPI -DHAS_GDBSX -DHAS_PASSTHROUGH -DHAS_PCI -DHAS_IOPORTS -fno-omit-frame-pointer -DCONFIG_FRAME_POINTER -Wno-parentheses -Wno-format -Wno-unused-value -O1 -fno-omit-frame-pointer -m64 -g -fno-strict-aliasing -std=gnu99 -Wall -Wstrict-prototypes -Wdeclaration-after-statement -include public/xen-compat.h -m32 -o compat/arch-x86_32.i compat/arch-x86_32.c set -e; id=_$(echo compat/arch-x86_32.h | tr '[:lower:]-/.' '[:upper:]___'); \ echo "#ifndef $id" >compat/arch-x86_32.h.new; \ echo "#define $id" >>compat/arch-x86_32.h.new; \ echo "#include " >>compat/arch-x86_32.h.new; \ \ echo "#pragma pack(4)" >>compat/arch-x86_32.h.new; \ grep -v '^# [0-9]' compat/arch-x86_32.i | \ python /root/xen/xen_pvh/xen/tools/compat-build-header.py | uniq >>compat/arch-x86_32.h.new; \ echo "#pragma pack()" >>compat/arch-x86_32.h.new; \ echo "#endif /* $id */" >>compat/arch-x86_32.h.new mv -f compat/arch-x86_32.h.new compat/arch-x86_32.h cat >compat/xlat.h.new [build stuck here] _______________________________________________ Xen-devel mailing list Xen-devel@lists.xen.org http://lists.xen.org/xen-devel From xen-devel-bounces@lists.xen.org Tue Mar 25 16:00:24 2014 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Tue, 25 Mar 2014 16:00:24 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WSTm3-0002Fq-Vu; Tue, 25 Mar 2014 16:00:24 +0000 Received: from mail6.bemta14.messagelabs.com ([193.109.254.103]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1WSTm2-0002FH-AY for xen-devel@lists.xen.org; Tue, 25 Mar 2014 16:00:23 +0000 Received: from [193.109.254.147:35041] by server-11.bemta-14.messagelabs.com id 61/5B-09902-518A1335; Tue, 25 Mar 2014 16:00:21 +0000 X-Env-Sender: wei.liu2@citrix.com X-Msg-Ref: server-7.tower-27.messagelabs.com!1395763215!4068030!3 X-Originating-IP: [66.165.176.63] X-SpamReason: No, hits=0.0 required=7.0 tests=sa_preprocessor: VHJ1c3RlZCBJUDogNjYuMTY1LjE3Ni42MyA9PiAzMDYwNDg=\n X-StarScan-Received: X-StarScan-Version: 6.11.1; banners=-,-,- X-VirusChecked: Checked Received: (qmail 7358 invoked from network); 25 Mar 2014 16:00:20 -0000 Received: from smtp02.citrix.com (HELO SMTP02.CITRIX.COM) (66.165.176.63) by server-7.tower-27.messagelabs.com with RC4-SHA encrypted SMTP; 25 Mar 2014 16:00:20 -0000 X-IronPort-AV: E=Sophos;i="4.97,728,1389744000"; d="scan'208";a="113414632" Received: from accessns.citrite.net (HELO FTLPEX01CL03.citrite.net) ([10.9.154.239]) by FTLPIPO02.CITRIX.COM with ESMTP; 25 Mar 2014 15:59:59 +0000 Received: from ukmail1.uk.xensource.com (10.80.16.128) by smtprelay.citrix.com (10.13.107.80) with Microsoft SMTP Server id 14.2.342.4; Tue, 25 Mar 2014 11:59:55 -0400 Received: from dt47.uk.xensource.com ([10.80.229.47] helo=dt47.uk.xensource.com.) by ukmail1.uk.xensource.com with esmtp (Exim 4.69) (envelope-from ) id 1WSTlc-00072o-3K; Tue, 25 Mar 2014 15:59:56 +0000 From: Wei Liu To: , Date: Tue, 25 Mar 2014 15:59:55 +0000 Message-ID: <1395763195-22502-4-git-send-email-wei.liu2@citrix.com> X-Mailer: git-send-email 1.7.10.4 In-Reply-To: <1395763195-22502-1-git-send-email-wei.liu2@citrix.com> References: <1395763195-22502-1-git-send-email-wei.liu2@citrix.com> MIME-Version: 1.0 X-DLP: MIA2 Cc: anthony.perard@citrix.com, Wei Liu , stefano.stabellini@eu.citrix.com Subject: [Xen-devel] [PATCH resend 3/3] xen: factor out common functions X-BeenThere: xen-devel@lists.xen.org X-Mailman-Version: 2.1.13 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Sender: xen-devel-bounces@lists.xen.org Errors-To: xen-devel-bounces@lists.xen.org So common functions used by both HVM and PV are factored out from xen-all.c to xen-common.c. Finally rename xen-all.c to xen-hvm.c, as those functions are only useful to HVM guest. Create *-stub files and modify Makefile.target to reflect the changes. Signed-off-by: Wei Liu --- Makefile.target | 6 +- xen-all.c | 1228 --------------------------------------------------- xen-common-stub.c | 19 + xen-common.c | 123 ++++++ xen-hvm-stub.c | 66 +++ xen-hvm.c | 1129 ++++++++++++++++++++++++++++++++++++++++++++++ xen-mapcache-stub.c | 39 ++ xen-stub.c | 70 --- 8 files changed, 1380 insertions(+), 1300 deletions(-) delete mode 100644 xen-all.c create mode 100644 xen-common-stub.c create mode 100644 xen-common.c create mode 100644 xen-hvm-stub.c create mode 100644 xen-hvm.c create mode 100644 xen-mapcache-stub.c delete mode 100644 xen-stub.c diff --git a/Makefile.target b/Makefile.target index ba12340..02090aa 100644 --- a/Makefile.target +++ b/Makefile.target @@ -120,8 +120,10 @@ obj-y += dump.o LIBS+=$(libs_softmmu) # xen support -obj-$(CONFIG_XEN) += xen-all.o xen-mapcache.o -obj-$(call lnot,$(CONFIG_XEN)) += xen-stub.o +obj-$(CONFIG_XEN) += xen-common.o +obj-$(CONFIG_XEN_I386) += xen-hvm.o xen-mapcache.o +obj-$(call lnot,$(CONFIG_XEN)) += xen-common-stub.o +obj-$(call lnot,$(CONFIG_XEN_I386)) += xen-hvm-stub.o xen-mapcache-stub.o # Hardware support ifeq ($(TARGET_NAME), sparc64) diff --git a/xen-all.c b/xen-all.c deleted file mode 100644 index ba34739..0000000 --- a/xen-all.c +++ /dev/null @@ -1,1228 +0,0 @@ -/* - * Copyright (C) 2010 Citrix Ltd. - * - * This work is licensed under the terms of the GNU GPL, version 2. See - * the COPYING file in the top-level directory. - * - * Contributions after 2012-01-13 are licensed under the terms of the - * GNU GPL, version 2 or (at your option) any later version. - */ - -#include - -#include "hw/pci/pci.h" -#include "hw/i386/pc.h" -#include "hw/xen/xen_common.h" -#include "hw/xen/xen_backend.h" -#include "qmp-commands.h" - -#include "sysemu/char.h" -#include "qemu/range.h" -#include "sysemu/xen-mapcache.h" -#include "trace.h" -#include "exec/address-spaces.h" - -#include -#include -#include - -//#define DEBUG_XEN - -#ifdef DEBUG_XEN -#define DPRINTF(fmt, ...) \ - do { fprintf(stderr, "xen: " fmt, ## __VA_ARGS__); } while (0) -#else -#define DPRINTF(fmt, ...) \ - do { } while (0) -#endif - -static MemoryRegion ram_memory, ram_640k, ram_lo, ram_hi; -static MemoryRegion *framebuffer; -static bool xen_in_migration; - -/* Compatibility with older version */ -#if __XEN_LATEST_INTERFACE_VERSION__ < 0x0003020a -static inline uint32_t xen_vcpu_eport(shared_iopage_t *shared_page, int i) -{ - return shared_page->vcpu_iodata[i].vp_eport; -} -static inline ioreq_t *xen_vcpu_ioreq(shared_iopage_t *shared_page, int vcpu) -{ - return &shared_page->vcpu_iodata[vcpu].vp_ioreq; -} -# define FMT_ioreq_size PRIx64 -#else -static inline uint32_t xen_vcpu_eport(shared_iopage_t *shared_page, int i) -{ - return shared_page->vcpu_ioreq[i].vp_eport; -} -static inline ioreq_t *xen_vcpu_ioreq(shared_iopage_t *shared_page, int vcpu) -{ - return &shared_page->vcpu_ioreq[vcpu]; -} -# define FMT_ioreq_size "u" -#endif -#ifndef HVM_PARAM_BUFIOREQ_EVTCHN -#define HVM_PARAM_BUFIOREQ_EVTCHN 26 -#endif - -#define BUFFER_IO_MAX_DELAY 100 - -typedef struct XenPhysmap { - hwaddr start_addr; - ram_addr_t size; - char *name; - hwaddr phys_offset; - - QLIST_ENTRY(XenPhysmap) list; -} XenPhysmap; - -typedef struct XenIOState { - shared_iopage_t *shared_page; - buffered_iopage_t *buffered_io_page; - QEMUTimer *buffered_io_timer; - /* the evtchn port for polling the notification, */ - evtchn_port_t *ioreq_local_port; - /* evtchn local port for buffered io */ - evtchn_port_t bufioreq_local_port; - /* the evtchn fd for polling */ - XenEvtchn xce_handle; - /* which vcpu we are serving */ - int send_vcpu; - - struct xs_handle *xenstore; - MemoryListener memory_listener; - QLIST_HEAD(, XenPhysmap) physmap; - hwaddr free_phys_offset; - const XenPhysmap *log_for_dirtybit; - - Notifier exit; - Notifier suspend; - Notifier wakeup; -} XenIOState; - -/* Xen specific function for piix pci */ - -int xen_pci_slot_get_pirq(PCIDevice *pci_dev, int irq_num) -{ - return irq_num + ((pci_dev->devfn >> 3) << 2); -} - -void xen_piix3_set_irq(void *opaque, int irq_num, int level) -{ - xc_hvm_set_pci_intx_level(xen_xc, xen_domid, 0, 0, irq_num >> 2, - irq_num & 3, level); -} - -void xen_piix_pci_write_config_client(uint32_t address, uint32_t val, int len) -{ - int i; - - /* Scan for updates to PCI link routes (0x60-0x63). */ - for (i = 0; i < len; i++) { - uint8_t v = (val >> (8 * i)) & 0xff; - if (v & 0x80) { - v = 0; - } - v &= 0xf; - if (((address + i) >= 0x60) && ((address + i) <= 0x63)) { - xc_hvm_set_pci_link_route(xen_xc, xen_domid, address + i - 0x60, v); - } - } -} - -void xen_hvm_inject_msi(uint64_t addr, uint32_t data) -{ - xen_xc_hvm_inject_msi(xen_xc, xen_domid, addr, data); -} - -static void xen_suspend_notifier(Notifier *notifier, void *data) -{ - xc_set_hvm_param(xen_xc, xen_domid, HVM_PARAM_ACPI_S_STATE, 3); -} - -/* Xen Interrupt Controller */ - -static void xen_set_irq(void *opaque, int irq, int level) -{ - xc_hvm_set_isa_irq_level(xen_xc, xen_domid, irq, level); -} - -qemu_irq *xen_interrupt_controller_init(void) -{ - return qemu_allocate_irqs(xen_set_irq, NULL, 16); -} - -/* Memory Ops */ - -static void xen_ram_init(ram_addr_t ram_size, MemoryRegion **ram_memory_p) -{ - MemoryRegion *sysmem = get_system_memory(); - ram_addr_t below_4g_mem_size, above_4g_mem_size = 0; - ram_addr_t block_len; - - block_len = ram_size; - if (ram_size >= HVM_BELOW_4G_RAM_END) { - /* Xen does not allocate the memory continuously, and keep a hole at - * HVM_BELOW_4G_MMIO_START of HVM_BELOW_4G_MMIO_LENGTH - */ - block_len += HVM_BELOW_4G_MMIO_LENGTH; - } - memory_region_init_ram(&ram_memory, NULL, "xen.ram", block_len); - *ram_memory_p = &ram_memory; - vmstate_register_ram_global(&ram_memory); - - if (ram_size >= HVM_BELOW_4G_RAM_END) { - above_4g_mem_size = ram_size - HVM_BELOW_4G_RAM_END; - below_4g_mem_size = HVM_BELOW_4G_RAM_END; - } else { - below_4g_mem_size = ram_size; - } - - memory_region_init_alias(&ram_640k, NULL, "xen.ram.640k", - &ram_memory, 0, 0xa0000); - memory_region_add_subregion(sysmem, 0, &ram_640k); - /* Skip of the VGA IO memory space, it will be registered later by the VGA - * emulated device. - * - * The area between 0xc0000 and 0x100000 will be used by SeaBIOS to load - * the Options ROM, so it is registered here as RAM. - */ - memory_region_init_alias(&ram_lo, NULL, "xen.ram.lo", - &ram_memory, 0xc0000, below_4g_mem_size - 0xc0000); - memory_region_add_subregion(sysmem, 0xc0000, &ram_lo); - if (above_4g_mem_size > 0) { - memory_region_init_alias(&ram_hi, NULL, "xen.ram.hi", - &ram_memory, 0x100000000ULL, - above_4g_mem_size); - memory_region_add_subregion(sysmem, 0x100000000ULL, &ram_hi); - } -} - -void xen_ram_alloc(ram_addr_t ram_addr, ram_addr_t size, MemoryRegion *mr) -{ - unsigned long nr_pfn; - xen_pfn_t *pfn_list; - int i; - - if (runstate_check(RUN_STATE_INMIGRATE)) { - /* RAM already populated in Xen */ - fprintf(stderr, "%s: do not alloc "RAM_ADDR_FMT - " bytes of ram at "RAM_ADDR_FMT" when runstate is INMIGRATE\n", - __func__, size, ram_addr); - return; - } - - if (mr == &ram_memory) { - return; - } - - trace_xen_ram_alloc(ram_addr, size); - - nr_pfn = size >> TARGET_PAGE_BITS; - pfn_list = g_malloc(sizeof (*pfn_list) * nr_pfn); - - for (i = 0; i < nr_pfn; i++) { - pfn_list[i] = (ram_addr >> TARGET_PAGE_BITS) + i; - } - - if (xc_domain_populate_physmap_exact(xen_xc, xen_domid, nr_pfn, 0, 0, pfn_list)) { - hw_error("xen: failed to populate ram at " RAM_ADDR_FMT, ram_addr); - } - - g_free(pfn_list); -} - -static XenPhysmap *get_physmapping(XenIOState *state, - hwaddr start_addr, ram_addr_t size) -{ - XenPhysmap *physmap = NULL; - - start_addr &= TARGET_PAGE_MASK; - - QLIST_FOREACH(physmap, &state->physmap, list) { - if (range_covers_byte(physmap->start_addr, physmap->size, start_addr)) { - return physmap; - } - } - return NULL; -} - -static hwaddr xen_phys_offset_to_gaddr(hwaddr start_addr, - ram_addr_t size, void *opaque) -{ - hwaddr addr = start_addr & TARGET_PAGE_MASK; - XenIOState *xen_io_state = opaque; - XenPhysmap *physmap = NULL; - - QLIST_FOREACH(physmap, &xen_io_state->physmap, list) { - if (range_covers_byte(physmap->phys_offset, physmap->size, addr)) { - return physmap->start_addr; - } - } - - return start_addr; -} - -#if CONFIG_XEN_CTRL_INTERFACE_VERSION >= 340 -static int xen_add_to_physmap(XenIOState *state, - hwaddr start_addr, - ram_addr_t size, - MemoryRegion *mr, - hwaddr offset_within_region) -{ - unsigned long i = 0; - int rc = 0; - XenPhysmap *physmap = NULL; - hwaddr pfn, start_gpfn; - hwaddr phys_offset = memory_region_get_ram_addr(mr); - char path[80], value[17]; - - if (get_physmapping(state, start_addr, size)) { - return 0; - } - if (size <= 0) { - return -1; - } - - /* Xen can only handle a single dirty log region for now and we want - * the linear framebuffer to be that region. - * Avoid tracking any regions that is not videoram and avoid tracking - * the legacy vga region. */ - if (mr == framebuffer && start_addr > 0xbffff) { - goto go_physmap; - } - return -1; - -go_physmap: - DPRINTF("mapping vram to %"HWADDR_PRIx" - %"HWADDR_PRIx"\n", - start_addr, start_addr + size); - - pfn = phys_offset >> TARGET_PAGE_BITS; - start_gpfn = start_addr >> TARGET_PAGE_BITS; - for (i = 0; i < size >> TARGET_PAGE_BITS; i++) { - unsigned long idx = pfn + i; - xen_pfn_t gpfn = start_gpfn + i; - - rc = xc_domain_add_to_physmap(xen_xc, xen_domid, XENMAPSPACE_gmfn, idx, gpfn); - if (rc) { - DPRINTF("add_to_physmap MFN %"PRI_xen_pfn" to PFN %" - PRI_xen_pfn" failed: %d\n", idx, gpfn, rc); - return -rc; - } - } - - physmap = g_malloc(sizeof (XenPhysmap)); - - physmap->start_addr = start_addr; - physmap->size = size; - physmap->name = (char *)mr->name; - physmap->phys_offset = phys_offset; - - QLIST_INSERT_HEAD(&state->physmap, physmap, list); - - xc_domain_pin_memory_cacheattr(xen_xc, xen_domid, - start_addr >> TARGET_PAGE_BITS, - (start_addr + size) >> TARGET_PAGE_BITS, - XEN_DOMCTL_MEM_CACHEATTR_WB); - - snprintf(path, sizeof(path), - "/local/domain/0/device-model/%d/physmap/%"PRIx64"/start_addr", - xen_domid, (uint64_t)phys_offset); - snprintf(value, sizeof(value), "%"PRIx64, (uint64_t)start_addr); - if (!xs_write(state->xenstore, 0, path, value, strlen(value))) { - return -1; - } - snprintf(path, sizeof(path), - "/local/domain/0/device-model/%d/physmap/%"PRIx64"/size", - xen_domid, (uint64_t)phys_offset); - snprintf(value, sizeof(value), "%"PRIx64, (uint64_t)size); - if (!xs_write(state->xenstore, 0, path, value, strlen(value))) { - return -1; - } - if (mr->name) { - snprintf(path, sizeof(path), - "/local/domain/0/device-model/%d/physmap/%"PRIx64"/name", - xen_domid, (uint64_t)phys_offset); - if (!xs_write(state->xenstore, 0, path, mr->name, strlen(mr->name))) { - return -1; - } - } - - return 0; -} - -static int xen_remove_from_physmap(XenIOState *state, - hwaddr start_addr, - ram_addr_t size) -{ - unsigned long i = 0; - int rc = 0; - XenPhysmap *physmap = NULL; - hwaddr phys_offset = 0; - - physmap = get_physmapping(state, start_addr, size); - if (physmap == NULL) { - return -1; - } - - phys_offset = physmap->phys_offset; - size = physmap->size; - - DPRINTF("unmapping vram to %"HWADDR_PRIx" - %"HWADDR_PRIx", at " - "%"HWADDR_PRIx"\n", start_addr, start_addr + size, phys_offset); - - size >>= TARGET_PAGE_BITS; - start_addr >>= TARGET_PAGE_BITS; - phys_offset >>= TARGET_PAGE_BITS; - for (i = 0; i < size; i++) { - unsigned long idx = start_addr + i; - xen_pfn_t gpfn = phys_offset + i; - - rc = xc_domain_add_to_physmap(xen_xc, xen_domid, XENMAPSPACE_gmfn, idx, gpfn); - if (rc) { - fprintf(stderr, "add_to_physmap MFN %"PRI_xen_pfn" to PFN %" - PRI_xen_pfn" failed: %d\n", idx, gpfn, rc); - return -rc; - } - } - - QLIST_REMOVE(physmap, list); - if (state->log_for_dirtybit == physmap) { - state->log_for_dirtybit = NULL; - } - g_free(physmap); - - return 0; -} - -#else -static int xen_add_to_physmap(XenIOState *state, - hwaddr start_addr, - ram_addr_t size, - MemoryRegion *mr, - hwaddr offset_within_region) -{ - return -ENOSYS; -} - -static int xen_remove_from_physmap(XenIOState *state, - hwaddr start_addr, - ram_addr_t size) -{ - return -ENOSYS; -} -#endif - -static void xen_set_memory(struct MemoryListener *listener, - MemoryRegionSection *section, - bool add) -{ - XenIOState *state = container_of(listener, XenIOState, memory_listener); - hwaddr start_addr = section->offset_within_address_space; - ram_addr_t size = int128_get64(section->size); - bool log_dirty = memory_region_is_logging(section->mr); - hvmmem_type_t mem_type; - - if (!memory_region_is_ram(section->mr)) { - return; - } - - if (!(section->mr != &ram_memory - && ( (log_dirty && add) || (!log_dirty && !add)))) { - return; - } - - trace_xen_client_set_memory(start_addr, size, log_dirty); - - start_addr &= TARGET_PAGE_MASK; - size = TARGET_PAGE_ALIGN(size); - - if (add) { - if (!memory_region_is_rom(section->mr)) { - xen_add_to_physmap(state, start_addr, size, - section->mr, section->offset_within_region); - } else { - mem_type = HVMMEM_ram_ro; - if (xc_hvm_set_mem_type(xen_xc, xen_domid, mem_type, - start_addr >> TARGET_PAGE_BITS, - size >> TARGET_PAGE_BITS)) { - DPRINTF("xc_hvm_set_mem_type error, addr: "TARGET_FMT_plx"\n", - start_addr); - } - } - } else { - if (xen_remove_from_physmap(state, start_addr, size) < 0) { - DPRINTF("physmapping does not exist at "TARGET_FMT_plx"\n", start_addr); - } - } -} - -static void xen_region_add(MemoryListener *listener, - MemoryRegionSection *section) -{ - memory_region_ref(section->mr); - xen_set_memory(listener, section, true); -} - -static void xen_region_del(MemoryListener *listener, - MemoryRegionSection *section) -{ - xen_set_memory(listener, section, false); - memory_region_unref(section->mr); -} - -static void xen_sync_dirty_bitmap(XenIOState *state, - hwaddr start_addr, - ram_addr_t size) -{ - hwaddr npages = size >> TARGET_PAGE_BITS; - const int width = sizeof(unsigned long) * 8; - unsigned long bitmap[(npages + width - 1) / width]; - int rc, i, j; - const XenPhysmap *physmap = NULL; - - physmap = get_physmapping(state, start_addr, size); - if (physmap == NULL) { - /* not handled */ - return; - } - - if (state->log_for_dirtybit == NULL) { - state->log_for_dirtybit = physmap; - } else if (state->log_for_dirtybit != physmap) { - /* Only one range for dirty bitmap can be tracked. */ - return; - } - - rc = xc_hvm_track_dirty_vram(xen_xc, xen_domid, - start_addr >> TARGET_PAGE_BITS, npages, - bitmap); - if (rc < 0) { - if (rc != -ENODATA) { - memory_region_set_dirty(framebuffer, 0, size); - DPRINTF("xen: track_dirty_vram failed (0x" TARGET_FMT_plx - ", 0x" TARGET_FMT_plx "): %s\n", - start_addr, start_addr + size, strerror(-rc)); - } - return; - } - - for (i = 0; i < ARRAY_SIZE(bitmap); i++) { - unsigned long map = bitmap[i]; - while (map != 0) { - j = ffsl(map) - 1; - map &= ~(1ul << j); - memory_region_set_dirty(framebuffer, - (i * width + j) * TARGET_PAGE_SIZE, - TARGET_PAGE_SIZE); - }; - } -} - -static void xen_log_start(MemoryListener *listener, - MemoryRegionSection *section) -{ - XenIOState *state = container_of(listener, XenIOState, memory_listener); - - xen_sync_dirty_bitmap(state, section->offset_within_address_space, - int128_get64(section->size)); -} - -static void xen_log_stop(MemoryListener *listener, MemoryRegionSection *section) -{ - XenIOState *state = container_of(listener, XenIOState, memory_listener); - - state->log_for_dirtybit = NULL; - /* Disable dirty bit tracking */ - xc_hvm_track_dirty_vram(xen_xc, xen_domid, 0, 0, NULL); -} - -static void xen_log_sync(MemoryListener *listener, MemoryRegionSection *section) -{ - XenIOState *state = container_of(listener, XenIOState, memory_listener); - - xen_sync_dirty_bitmap(state, section->offset_within_address_space, - int128_get64(section->size)); -} - -static void xen_log_global_start(MemoryListener *listener) -{ - if (xen_enabled()) { - xen_in_migration = true; - } -} - -static void xen_log_global_stop(MemoryListener *listener) -{ - xen_in_migration = false; -} - -static MemoryListener xen_memory_listener = { - .region_add = xen_region_add, - .region_del = xen_region_del, - .log_start = xen_log_start, - .log_stop = xen_log_stop, - .log_sync = xen_log_sync, - .log_global_start = xen_log_global_start, - .log_global_stop = xen_log_global_stop, - .priority = 10, -}; - -void qmp_xen_set_global_dirty_log(bool enable, Error **errp) -{ - if (enable) { - memory_global_dirty_log_start(); - } else { - memory_global_dirty_log_stop(); - } -} - -/* get the ioreq packets from share mem */ -static ioreq_t *cpu_get_ioreq_from_shared_memory(XenIOState *state, int vcpu) -{ - ioreq_t *req = xen_vcpu_ioreq(state->shared_page, vcpu); - - if (req->state != STATE_IOREQ_READY) { - DPRINTF("I/O request not ready: " - "%x, ptr: %x, port: %"PRIx64", " - "data: %"PRIx64", count: %" FMT_ioreq_size ", size: %" FMT_ioreq_size "\n", - req->state, req->data_is_ptr, req->addr, - req->data, req->count, req->size); - return NULL; - } - - xen_rmb(); /* see IOREQ_READY /then/ read contents of ioreq */ - - req->state = STATE_IOREQ_INPROCESS; - return req; -} - -/* use poll to get the port notification */ -/* ioreq_vec--out,the */ -/* retval--the number of ioreq packet */ -static ioreq_t *cpu_get_ioreq(XenIOState *state) -{ - int i; - evtchn_port_t port; - - port = xc_evtchn_pending(state->xce_handle); - if (port == state->bufioreq_local_port) { - timer_mod(state->buffered_io_timer, - BUFFER_IO_MAX_DELAY + qemu_clock_get_ms(QEMU_CLOCK_REALTIME)); - return NULL; - } - - if (port != -1) { - for (i = 0; i < max_cpus; i++) { - if (state->ioreq_local_port[i] == port) { - break; - } - } - - if (i == max_cpus) { - hw_error("Fatal error while trying to get io event!\n"); - } - - /* unmask the wanted port again */ - xc_evtchn_unmask(state->xce_handle, port); - - /* get the io packet from shared memory */ - state->send_vcpu = i; - return cpu_get_ioreq_from_shared_memory(state, i); - } - - /* read error or read nothing */ - return NULL; -} - -static uint32_t do_inp(pio_addr_t addr, unsigned long size) -{ - switch (size) { - case 1: - return cpu_inb(addr); - case 2: - return cpu_inw(addr); - case 4: - return cpu_inl(addr); - default: - hw_error("inp: bad size: %04"FMT_pioaddr" %lx", addr, size); - } -} - -static void do_outp(pio_addr_t addr, - unsigned long size, uint32_t val) -{ - switch (size) { - case 1: - return cpu_outb(addr, val); - case 2: - return cpu_outw(addr, val); - case 4: - return cpu_outl(addr, val); - default: - hw_error("outp: bad size: %04"FMT_pioaddr" %lx", addr, size); - } -} - -/* - * Helper functions which read/write an object from/to physical guest - * memory, as part of the implementation of an ioreq. - * - * Equivalent to - * cpu_physical_memory_rw(addr + (req->df ? -1 : +1) * req->size * i, - * val, req->size, 0/1) - * except without the integer overflow problems. - */ -static void rw_phys_req_item(hwaddr addr, - ioreq_t *req, uint32_t i, void *val, int rw) -{ - /* Do everything unsigned so overflow just results in a truncated result - * and accesses to undesired parts of guest memory, which is up - * to the guest */ - hwaddr offset = (hwaddr)req->size * i; - if (req->df) { - addr -= offset; - } else { - addr += offset; - } - cpu_physical_memory_rw(addr, val, req->size, rw); -} - -static inline void read_phys_req_item(hwaddr addr, - ioreq_t *req, uint32_t i, void *val) -{ - rw_phys_req_item(addr, req, i, val, 0); -} -static inline void write_phys_req_item(hwaddr addr, - ioreq_t *req, uint32_t i, void *val) -{ - rw_phys_req_item(addr, req, i, val, 1); -} - - -static void cpu_ioreq_pio(ioreq_t *req) -{ - uint32_t i; - - if (req->dir == IOREQ_READ) { - if (!req->data_is_ptr) { - req->data = do_inp(req->addr, req->size); - } else { - uint32_t tmp; - - for (i = 0; i < req->count; i++) { - tmp = do_inp(req->addr, req->size); - write_phys_req_item(req->data, req, i, &tmp); - } - } - } else if (req->dir == IOREQ_WRITE) { - if (!req->data_is_ptr) { - do_outp(req->addr, req->size, req->data); - } else { - for (i = 0; i < req->count; i++) { - uint32_t tmp = 0; - - read_phys_req_item(req->data, req, i, &tmp); - do_outp(req->addr, req->size, tmp); - } - } - } -} - -static void cpu_ioreq_move(ioreq_t *req) -{ - uint32_t i; - - if (!req->data_is_ptr) { - if (req->dir == IOREQ_READ) { - for (i = 0; i < req->count; i++) { - read_phys_req_item(req->addr, req, i, &req->data); - } - } else if (req->dir == IOREQ_WRITE) { - for (i = 0; i < req->count; i++) { - write_phys_req_item(req->addr, req, i, &req->data); - } - } - } else { - uint64_t tmp; - - if (req->dir == IOREQ_READ) { - for (i = 0; i < req->count; i++) { - read_phys_req_item(req->addr, req, i, &tmp); - write_phys_req_item(req->data, req, i, &tmp); - } - } else if (req->dir == IOREQ_WRITE) { - for (i = 0; i < req->count; i++) { - read_phys_req_item(req->data, req, i, &tmp); - write_phys_req_item(req->addr, req, i, &tmp); - } - } - } -} - -static void handle_ioreq(ioreq_t *req) -{ - if (!req->data_is_ptr && (req->dir == IOREQ_WRITE) && - (req->size < sizeof (target_ulong))) { - req->data &= ((target_ulong) 1 << (8 * req->size)) - 1; - } - - switch (req->type) { - case IOREQ_TYPE_PIO: - cpu_ioreq_pio(req); - break; - case IOREQ_TYPE_COPY: - cpu_ioreq_move(req); - break; - case IOREQ_TYPE_TIMEOFFSET: - break; - case IOREQ_TYPE_INVALIDATE: - xen_invalidate_map_cache(); - break; - default: - hw_error("Invalid ioreq type 0x%x\n", req->type); - } -} - -static int handle_buffered_iopage(XenIOState *state) -{ - buf_ioreq_t *buf_req = NULL; - ioreq_t req; - int qw; - - if (!state->buffered_io_page) { - return 0; - } - - memset(&req, 0x00, sizeof(req)); - - while (state->buffered_io_page->read_pointer != state->buffered_io_page->write_pointer) { - buf_req = &state->buffered_io_page->buf_ioreq[ - state->buffered_io_page->read_pointer % IOREQ_BUFFER_SLOT_NUM]; - req.size = 1UL << buf_req->size; - req.count = 1; - req.addr = buf_req->addr; - req.data = buf_req->data; - req.state = STATE_IOREQ_READY; - req.dir = buf_req->dir; - req.df = 1; - req.type = buf_req->type; - req.data_is_ptr = 0; - qw = (req.size == 8); - if (qw) { - buf_req = &state->buffered_io_page->buf_ioreq[ - (state->buffered_io_page->read_pointer + 1) % IOREQ_BUFFER_SLOT_NUM]; - req.data |= ((uint64_t)buf_req->data) << 32; - } - - handle_ioreq(&req); - - xen_mb(); - state->buffered_io_page->read_pointer += qw ? 2 : 1; - } - - return req.count; -} - -static void handle_buffered_io(void *opaque) -{ - XenIOState *state = opaque; - - if (handle_buffered_iopage(state)) { - timer_mod(state->buffered_io_timer, - BUFFER_IO_MAX_DELAY + qemu_clock_get_ms(QEMU_CLOCK_REALTIME)); - } else { - timer_del(state->buffered_io_timer); - xc_evtchn_unmask(state->xce_handle, state->bufioreq_local_port); - } -} - -static void cpu_handle_ioreq(void *opaque) -{ - XenIOState *state = opaque; - ioreq_t *req = cpu_get_ioreq(state); - - handle_buffered_iopage(state); - if (req) { - handle_ioreq(req); - - if (req->state != STATE_IOREQ_INPROCESS) { - fprintf(stderr, "Badness in I/O request ... not in service?!: " - "%x, ptr: %x, port: %"PRIx64", " - "data: %"PRIx64", count: %" FMT_ioreq_size ", size: %" FMT_ioreq_size "\n", - req->state, req->data_is_ptr, req->addr, - req->data, req->count, req->size); - destroy_hvm_domain(false); - return; - } - - xen_wmb(); /* Update ioreq contents /then/ update state. */ - - /* - * We do this before we send the response so that the tools - * have the opportunity to pick up on the reset before the - * guest resumes and does a hlt with interrupts disabled which - * causes Xen to powerdown the domain. - */ - if (runstate_is_running()) { - if (qemu_shutdown_requested_get()) { - destroy_hvm_domain(false); - } - if (qemu_reset_requested_get()) { - qemu_system_reset(VMRESET_REPORT); - destroy_hvm_domain(true); - } - } - - req->state = STATE_IORESP_READY; - xc_evtchn_notify(state->xce_handle, state->ioreq_local_port[state->send_vcpu]); - } -} - -static int store_dev_info(int domid, CharDriverState *cs, const char *string) -{ - struct xs_handle *xs = NULL; - char *path = NULL; - char *newpath = NULL; - char *pts = NULL; - int ret = -1; - - /* Only continue if we're talking to a pty. */ - if (strncmp(cs->filename, "pty:", 4)) { - return 0; - } - pts = cs->filename + 4; - - /* We now have everything we need to set the xenstore entry. */ - xs = xs_open(0); - if (xs == NULL) { - fprintf(stderr, "Could not contact XenStore\n"); - goto out; - } - - path = xs_get_domain_path(xs, domid); - if (path == NULL) { - fprintf(stderr, "xs_get_domain_path() error\n"); - goto out; - } - newpath = realloc(path, (strlen(path) + strlen(string) + - strlen("/tty") + 1)); - if (newpath == NULL) { - fprintf(stderr, "realloc error\n"); - goto out; - } - path = newpath; - - strcat(path, string); - strcat(path, "/tty"); - if (!xs_write(xs, XBT_NULL, path, pts, strlen(pts))) { - fprintf(stderr, "xs_write for '%s' fail", string); - goto out; - } - ret = 0; - -out: - free(path); - xs_close(xs); - - return ret; -} - -void xenstore_store_pv_console_info(int i, CharDriverState *chr) -{ - if (i == 0) { - store_dev_info(xen_domid, chr, "/console"); - } else { - char buf[32]; - snprintf(buf, sizeof(buf), "/device/console/%d", i); - store_dev_info(xen_domid, chr, buf); - } -} - -static void xenstore_record_dm_state(struct xs_handle *xs, const char *state) -{ - char path[50]; - - if (xs == NULL) { - fprintf(stderr, "xenstore connection not initialized\n"); - exit(1); - } - - snprintf(path, sizeof (path), "device-model/%u/state", xen_domid); - if (!xs_write(xs, XBT_NULL, path, state, strlen(state))) { - fprintf(stderr, "error recording dm state\n"); - exit(1); - } -} - -static void xen_main_loop_prepare(XenIOState *state) -{ - int evtchn_fd = -1; - - if (state->xce_handle != XC_HANDLER_INITIAL_VALUE) { - evtchn_fd = xc_evtchn_fd(state->xce_handle); - } - - state->buffered_io_timer = timer_new_ms(QEMU_CLOCK_REALTIME, handle_buffered_io, - state); - - if (evtchn_fd != -1) { - qemu_set_fd_handler(evtchn_fd, cpu_handle_ioreq, NULL, state); - } -} - - -/* Initialise Xen */ - -static void xen_change_state_handler(void *opaque, int running, - RunState state) -{ - if (running) { - /* record state running */ - xenstore_record_dm_state(xenstore, "running"); - } -} - -static void xen_hvm_change_state_handler(void *opaque, int running, - RunState rstate) -{ - XenIOState *xstate = opaque; - if (running) { - xen_main_loop_prepare(xstate); - } -} - -static void xen_exit_notifier(Notifier *n, void *data) -{ - XenIOState *state = container_of(n, XenIOState, exit); - - xc_evtchn_close(state->xce_handle); - xs_daemon_close(state->xenstore); -} - -int xen_init(QEMUMachine *machine) -{ - xen_xc = xen_xc_interface_open(0, 0, 0); - if (xen_xc == XC_HANDLER_INITIAL_VALUE) { - xen_be_printf(NULL, 0, "can't open xen interface\n"); - return -1; - } - qemu_add_vm_change_state_handler(xen_change_state_handler, NULL); - - return 0; -} - -static void xen_read_physmap(XenIOState *state) -{ - XenPhysmap *physmap = NULL; - unsigned int len, num, i; - char path[80], *value = NULL; - char **entries = NULL; - - snprintf(path, sizeof(path), - "/local/domain/0/device-model/%d/physmap", xen_domid); - entries = xs_directory(state->xenstore, 0, path, &num); - if (entries == NULL) - return; - - for (i = 0; i < num; i++) { - physmap = g_malloc(sizeof (XenPhysmap)); - physmap->phys_offset = strtoull(entries[i], NULL, 16); - snprintf(path, sizeof(path), - "/local/domain/0/device-model/%d/physmap/%s/start_addr", - xen_domid, entries[i]); - value = xs_read(state->xenstore, 0, path, &len); - if (value == NULL) { - g_free(physmap); - continue; - } - physmap->start_addr = strtoull(value, NULL, 16); - free(value); - - snprintf(path, sizeof(path), - "/local/domain/0/device-model/%d/physmap/%s/size", - xen_domid, entries[i]); - value = xs_read(state->xenstore, 0, path, &len); - if (value == NULL) { - g_free(physmap); - continue; - } - physmap->size = strtoull(value, NULL, 16); - free(value); - - snprintf(path, sizeof(path), - "/local/domain/0/device-model/%d/physmap/%s/name", - xen_domid, entries[i]); - physmap->name = xs_read(state->xenstore, 0, path, &len); - - QLIST_INSERT_HEAD(&state->physmap, physmap, list); - } - free(entries); -} - -static void xen_wakeup_notifier(Notifier *notifier, void *data) -{ - xc_set_hvm_param(xen_xc, xen_domid, HVM_PARAM_ACPI_S_STATE, 0); -} - -int xen_hvm_init(MemoryRegion **ram_memory) -{ - int i, rc; - unsigned long ioreq_pfn; - unsigned long bufioreq_evtchn; - XenIOState *state; - - state = g_malloc0(sizeof (XenIOState)); - - state->xce_handle = xen_xc_evtchn_open(NULL, 0); - if (state->xce_handle == XC_HANDLER_INITIAL_VALUE) { - perror("xen: event channel open"); - g_free(state); - return -errno; - } - - state->xenstore = xs_daemon_open(); - if (state->xenstore == NULL) { - perror("xen: xenstore open"); - g_free(state); - return -errno; - } - - state->exit.notify = xen_exit_notifier; - qemu_add_exit_notifier(&state->exit); - - state->suspend.notify = xen_suspend_notifier; - qemu_register_suspend_notifier(&state->suspend); - - state->wakeup.notify = xen_wakeup_notifier; - qemu_register_wakeup_notifier(&state->wakeup); - - xc_get_hvm_param(xen_xc, xen_domid, HVM_PARAM_IOREQ_PFN, &ioreq_pfn); - DPRINTF("shared page at pfn %lx\n", ioreq_pfn); - state->shared_page = xc_map_foreign_range(xen_xc, xen_domid, XC_PAGE_SIZE, - PROT_READ|PROT_WRITE, ioreq_pfn); - if (state->shared_page == NULL) { - hw_error("map shared IO page returned error %d handle=" XC_INTERFACE_FMT, - errno, xen_xc); - } - - xc_get_hvm_param(xen_xc, xen_domid, HVM_PARAM_BUFIOREQ_PFN, &ioreq_pfn); - DPRINTF("buffered io page at pfn %lx\n", ioreq_pfn); - state->buffered_io_page = xc_map_foreign_range(xen_xc, xen_domid, XC_PAGE_SIZE, - PROT_READ|PROT_WRITE, ioreq_pfn); - if (state->buffered_io_page == NULL) { - hw_error("map buffered IO page returned error %d", errno); - } - - state->ioreq_local_port = g_malloc0(max_cpus * sizeof (evtchn_port_t)); - - /* FIXME: how about if we overflow the page here? */ - for (i = 0; i < max_cpus; i++) { - rc = xc_evtchn_bind_interdomain(state->xce_handle, xen_domid, - xen_vcpu_eport(state->shared_page, i)); - if (rc == -1) { - fprintf(stderr, "bind interdomain ioctl error %d\n", errno); - return -1; - } - state->ioreq_local_port[i] = rc; - } - - rc = xc_get_hvm_param(xen_xc, xen_domid, HVM_PARAM_BUFIOREQ_EVTCHN, - &bufioreq_evtchn); - if (rc < 0) { - fprintf(stderr, "failed to get HVM_PARAM_BUFIOREQ_EVTCHN\n"); - return -1; - } - rc = xc_evtchn_bind_interdomain(state->xce_handle, xen_domid, - (uint32_t)bufioreq_evtchn); - if (rc == -1) { - fprintf(stderr, "bind interdomain ioctl error %d\n", errno); - return -1; - } - state->bufioreq_local_port = rc; - - /* Init RAM management */ - xen_map_cache_init(xen_phys_offset_to_gaddr, state); - xen_ram_init(ram_size, ram_memory); - - qemu_add_vm_change_state_handler(xen_hvm_change_state_handler, state); - - state->memory_listener = xen_memory_listener; - QLIST_INIT(&state->physmap); - memory_listener_register(&state->memory_listener, &address_space_memory); - state->log_for_dirtybit = NULL; - - /* Initialize backend core & drivers */ - if (xen_be_init() != 0) { - fprintf(stderr, "%s: xen backend core setup failed\n", __FUNCTION__); - exit(1); - } - xen_be_register("console", &xen_console_ops); - xen_be_register("vkbd", &xen_kbdmouse_ops); - xen_be_register("qdisk", &xen_blkdev_ops); - xen_read_physmap(state); - - return 0; -} - -void destroy_hvm_domain(bool reboot) -{ - XenXC xc_handle; - int sts; - - xc_handle = xen_xc_interface_open(0, 0, 0); - if (xc_handle == XC_HANDLER_INITIAL_VALUE) { - fprintf(stderr, "Cannot acquire xenctrl handle\n"); - } else { - sts = xc_domain_shutdown(xc_handle, xen_domid, - reboot ? SHUTDOWN_reboot : SHUTDOWN_poweroff); - if (sts != 0) { - fprintf(stderr, "xc_domain_shutdown failed to issue %s, " - "sts %d, %s\n", reboot ? "reboot" : "poweroff", - sts, strerror(errno)); - } else { - fprintf(stderr, "Issued domain %d %s\n", xen_domid, - reboot ? "reboot" : "poweroff"); - } - xc_interface_close(xc_handle); - } -} - -void xen_register_framebuffer(MemoryRegion *mr) -{ - framebuffer = mr; -} - -void xen_shutdown_fatal_error(const char *fmt, ...) -{ - va_list ap; - - va_start(ap, fmt); - vfprintf(stderr, fmt, ap); - va_end(ap); - fprintf(stderr, "Will destroy the domain.\n"); - /* destroy the domain */ - qemu_system_shutdown_request(); -} - -void xen_modified_memory(ram_addr_t start, ram_addr_t length) -{ - if (unlikely(xen_in_migration)) { - int rc; - ram_addr_t start_pfn, nb_pages; - - if (length == 0) { - length = TARGET_PAGE_SIZE; - } - start_pfn = start >> TARGET_PAGE_BITS; - nb_pages = ((start + length + TARGET_PAGE_SIZE - 1) >> TARGET_PAGE_BITS) - - start_pfn; - rc = xc_hvm_modified_memory(xen_xc, xen_domid, start_pfn, nb_pages); - if (rc) { - fprintf(stderr, - "%s failed for "RAM_ADDR_FMT" ("RAM_ADDR_FMT"): %i, %s\n", - __func__, start, nb_pages, rc, strerror(-rc)); - } - } -} diff --git a/xen-common-stub.c b/xen-common-stub.c new file mode 100644 index 0000000..0bba290 --- /dev/null +++ b/xen-common-stub.c @@ -0,0 +1,19 @@ +/* + * Copyright (C) 2014 Citrix Systems UK Ltd. + * + * This work is licensed under the terms of the GNU GPL, version 2 or later. + * See the COPYING file in the top-level directory. + */ + +#include "qemu-common.h" +#include "hw/xen/xen.h" + +void xenstore_store_pv_console_info(int i, CharDriverState *chr) +{ +} + +int xen_init(QEMUMachine *machine) +{ + return -ENOSYS; +} + diff --git a/xen-common.c b/xen-common.c new file mode 100644 index 0000000..aa71b1a --- /dev/null +++ b/xen-common.c @@ -0,0 +1,123 @@ +/* + * Copyright (C) 2014 Citrix Systems UK Ltd. + * + * This work is licensed under the terms of the GNU GPL, version 2. See + * the COPYING file in the top-level directory. + * + * Contributions after 2012-01-13 are licensed under the terms of the + * GNU GPL, version 2 or (at your option) any later version. + */ + +#include "hw/xen/xen_backend.h" +#include "qmp-commands.h" +#include "sysemu/char.h" + +//#define DEBUG_XEN + +#ifdef DEBUG_XEN +#define DPRINTF(fmt, ...) \ + do { fprintf(stderr, "xen: " fmt, ## __VA_ARGS__); } while (0) +#else +#define DPRINTF(fmt, ...) \ + do { } while (0) +#endif + +static int store_dev_info(int domid, CharDriverState *cs, const char *string) +{ + struct xs_handle *xs = NULL; + char *path = NULL; + char *newpath = NULL; + char *pts = NULL; + int ret = -1; + + /* Only continue if we're talking to a pty. */ + if (strncmp(cs->filename, "pty:", 4)) { + return 0; + } + pts = cs->filename + 4; + + /* We now have everything we need to set the xenstore entry. */ + xs = xs_open(0); + if (xs == NULL) { + fprintf(stderr, "Could not contact XenStore\n"); + goto out; + } + + path = xs_get_domain_path(xs, domid); + if (path == NULL) { + fprintf(stderr, "xs_get_domain_path() error\n"); + goto out; + } + newpath = realloc(path, (strlen(path) + strlen(string) + + strlen("/tty") + 1)); + if (newpath == NULL) { + fprintf(stderr, "realloc error\n"); + goto out; + } + path = newpath; + + strcat(path, string); + strcat(path, "/tty"); + if (!xs_write(xs, XBT_NULL, path, pts, strlen(pts))) { + fprintf(stderr, "xs_write for '%s' fail", string); + goto out; + } + ret = 0; + +out: + free(path); + xs_close(xs); + + return ret; +} + +void xenstore_store_pv_console_info(int i, CharDriverState *chr) +{ + if (i == 0) { + store_dev_info(xen_domid, chr, "/console"); + } else { + char buf[32]; + snprintf(buf, sizeof(buf), "/device/console/%d", i); + store_dev_info(xen_domid, chr, buf); + } +} + + +static void xenstore_record_dm_state(struct xs_handle *xs, const char *state) +{ + char path[50]; + + if (xs == NULL) { + fprintf(stderr, "xenstore connection not initialized\n"); + exit(1); + } + + snprintf(path, sizeof (path), "device-model/%u/state", xen_domid); + if (!xs_write(xs, XBT_NULL, path, state, strlen(state))) { + fprintf(stderr, "error recording dm state\n"); + exit(1); + } +} + + +static void xen_change_state_handler(void *opaque, int running, + RunState state) +{ + if (running) { + /* record state running */ + xenstore_record_dm_state(xenstore, "running"); + } +} + +int xen_init(QEMUMachine *machine) +{ + xen_xc = xen_xc_interface_open(0, 0, 0); + if (xen_xc == XC_HANDLER_INITIAL_VALUE) { + xen_be_printf(NULL, 0, "can't open xen interface\n"); + return -1; + } + qemu_add_vm_change_state_handler(xen_change_state_handler, NULL); + + return 0; +} + diff --git a/xen-hvm-stub.c b/xen-hvm-stub.c new file mode 100644 index 0000000..00fa9b3 --- /dev/null +++ b/xen-hvm-stub.c @@ -0,0 +1,66 @@ +/* + * Copyright (C) 2010 Citrix Ltd. + * + * This work is licensed under the terms of the GNU GPL, version 2. See + * the COPYING file in the top-level directory. + * + * Contributions after 2012-01-13 are licensed under the terms of the + * GNU GPL, version 2 or (at your option) any later version. + */ + +#include "qemu-common.h" +#include "hw/xen/xen.h" +#include "exec/memory.h" +#include "qmp-commands.h" +#include "hw/xen/xen_common.h" + +int xen_pci_slot_get_pirq(PCIDevice *pci_dev, int irq_num) +{ + return -1; +} + +void xen_piix3_set_irq(void *opaque, int irq_num, int level) +{ +} + +void xen_piix_pci_write_config_client(uint32_t address, uint32_t val, int len) +{ +} + +void xen_hvm_inject_msi(uint64_t addr, uint32_t data) +{ +} + +void xen_cmos_set_s3_resume(void *opaque, int irq, int level) +{ +} + +void xen_ram_alloc(ram_addr_t ram_addr, ram_addr_t size, MemoryRegion *mr) +{ +} + +qemu_irq *xen_interrupt_controller_init(void) +{ + return NULL; +} + +void xen_register_framebuffer(MemoryRegion *mr) +{ +} + +void xen_modified_memory(ram_addr_t start, ram_addr_t length) +{ +} + +int xen_hvm_init(MemoryRegion **ram_memory) +{ + return 0; +} + +void qmp_xen_set_global_dirty_log(bool enable, Error **errp) +{ +} + +void xen_shutdown_fatal_error(const char *fmt, ...) +{ +} diff --git a/xen-hvm.c b/xen-hvm.c new file mode 100644 index 0000000..0a49055 --- /dev/null +++ b/xen-hvm.c @@ -0,0 +1,1129 @@ +/* + * Copyright (C) 2010 Citrix Ltd. + * + * This work is licensed under the terms of the GNU GPL, version 2. See + * the COPYING file in the top-level directory. + * + * Contributions after 2012-01-13 are licensed under the terms of the + * GNU GPL, version 2 or (at your option) any later version. + */ + +#include + +#include "hw/pci/pci.h" +#include "hw/i386/pc.h" +#include "hw/xen/xen_common.h" +#include "hw/xen/xen_backend.h" +#include "qmp-commands.h" + +#include "sysemu/char.h" +#include "qemu/range.h" +#include "sysemu/xen-mapcache.h" +#include "trace.h" +#include "exec/address-spaces.h" + +#include +#include +#include + +//#define DEBUG_XEN_HVM + +#ifdef DEBUG_XEN_HVM +#define DPRINTF(fmt, ...) \ + do { fprintf(stderr, "xen: " fmt, ## __VA_ARGS__); } while (0) +#else +#define DPRINTF(fmt, ...) \ + do { } while (0) +#endif + +static MemoryRegion ram_memory, ram_640k, ram_lo, ram_hi; +static MemoryRegion *framebuffer; +static bool xen_in_migration; + +/* Compatibility with older version */ +#if __XEN_LATEST_INTERFACE_VERSION__ < 0x0003020a +static inline uint32_t xen_vcpu_eport(shared_iopage_t *shared_page, int i) +{ + return shared_page->vcpu_iodata[i].vp_eport; +} +static inline ioreq_t *xen_vcpu_ioreq(shared_iopage_t *shared_page, int vcpu) +{ + return &shared_page->vcpu_iodata[vcpu].vp_ioreq; +} +# define FMT_ioreq_size PRIx64 +#else +static inline uint32_t xen_vcpu_eport(shared_iopage_t *shared_page, int i) +{ + return shared_page->vcpu_ioreq[i].vp_eport; +} +static inline ioreq_t *xen_vcpu_ioreq(shared_iopage_t *shared_page, int vcpu) +{ + return &shared_page->vcpu_ioreq[vcpu]; +} +# define FMT_ioreq_size "u" +#endif +#ifndef HVM_PARAM_BUFIOREQ_EVTCHN +#define HVM_PARAM_BUFIOREQ_EVTCHN 26 +#endif + +#define BUFFER_IO_MAX_DELAY 100 + +typedef struct XenPhysmap { + hwaddr start_addr; + ram_addr_t size; + char *name; + hwaddr phys_offset; + + QLIST_ENTRY(XenPhysmap) list; +} XenPhysmap; + +typedef struct XenIOState { + shared_iopage_t *shared_page; + buffered_iopage_t *buffered_io_page; + QEMUTimer *buffered_io_timer; + /* the evtchn port for polling the notification, */ + evtchn_port_t *ioreq_local_port; + /* evtchn local port for buffered io */ + evtchn_port_t bufioreq_local_port; + /* the evtchn fd for polling */ + XenEvtchn xce_handle; + /* which vcpu we are serving */ + int send_vcpu; + + struct xs_handle *xenstore; + MemoryListener memory_listener; + QLIST_HEAD(, XenPhysmap) physmap; + hwaddr free_phys_offset; + const XenPhysmap *log_for_dirtybit; + + Notifier exit; + Notifier suspend; + Notifier wakeup; +} XenIOState; + +/* Xen specific function for piix pci */ + +int xen_pci_slot_get_pirq(PCIDevice *pci_dev, int irq_num) +{ + return irq_num + ((pci_dev->devfn >> 3) << 2); +} + +void xen_piix3_set_irq(void *opaque, int irq_num, int level) +{ + xc_hvm_set_pci_intx_level(xen_xc, xen_domid, 0, 0, irq_num >> 2, + irq_num & 3, level); +} + +void xen_piix_pci_write_config_client(uint32_t address, uint32_t val, int len) +{ + int i; + + /* Scan for updates to PCI link routes (0x60-0x63). */ + for (i = 0; i < len; i++) { + uint8_t v = (val >> (8 * i)) & 0xff; + if (v & 0x80) { + v = 0; + } + v &= 0xf; + if (((address + i) >= 0x60) && ((address + i) <= 0x63)) { + xc_hvm_set_pci_link_route(xen_xc, xen_domid, address + i - 0x60, v); + } + } +} + +void xen_hvm_inject_msi(uint64_t addr, uint32_t data) +{ + xen_xc_hvm_inject_msi(xen_xc, xen_domid, addr, data); +} + +static void xen_suspend_notifier(Notifier *notifier, void *data) +{ + xc_set_hvm_param(xen_xc, xen_domid, HVM_PARAM_ACPI_S_STATE, 3); +} + +/* Xen Interrupt Controller */ + +static void xen_set_irq(void *opaque, int irq, int level) +{ + xc_hvm_set_isa_irq_level(xen_xc, xen_domid, irq, level); +} + +qemu_irq *xen_interrupt_controller_init(void) +{ + return qemu_allocate_irqs(xen_set_irq, NULL, 16); +} + +/* Memory Ops */ + +static void xen_ram_init(ram_addr_t ram_size, MemoryRegion **ram_memory_p) +{ + MemoryRegion *sysmem = get_system_memory(); + ram_addr_t below_4g_mem_size, above_4g_mem_size = 0; + ram_addr_t block_len; + + block_len = ram_size; + if (ram_size >= HVM_BELOW_4G_RAM_END) { + /* Xen does not allocate the memory continuously, and keep a hole at + * HVM_BELOW_4G_MMIO_START of HVM_BELOW_4G_MMIO_LENGTH + */ + block_len += HVM_BELOW_4G_MMIO_LENGTH; + } + memory_region_init_ram(&ram_memory, NULL, "xen.ram", block_len); + *ram_memory_p = &ram_memory; + vmstate_register_ram_global(&ram_memory); + + if (ram_size >= HVM_BELOW_4G_RAM_END) { + above_4g_mem_size = ram_size - HVM_BELOW_4G_RAM_END; + below_4g_mem_size = HVM_BELOW_4G_RAM_END; + } else { + below_4g_mem_size = ram_size; + } + + memory_region_init_alias(&ram_640k, NULL, "xen.ram.640k", + &ram_memory, 0, 0xa0000); + memory_region_add_subregion(sysmem, 0, &ram_640k); + /* Skip of the VGA IO memory space, it will be registered later by the VGA + * emulated device. + * + * The area between 0xc0000 and 0x100000 will be used by SeaBIOS to load + * the Options ROM, so it is registered here as RAM. + */ + memory_region_init_alias(&ram_lo, NULL, "xen.ram.lo", + &ram_memory, 0xc0000, below_4g_mem_size - 0xc0000); + memory_region_add_subregion(sysmem, 0xc0000, &ram_lo); + if (above_4g_mem_size > 0) { + memory_region_init_alias(&ram_hi, NULL, "xen.ram.hi", + &ram_memory, 0x100000000ULL, + above_4g_mem_size); + memory_region_add_subregion(sysmem, 0x100000000ULL, &ram_hi); + } +} + +void xen_ram_alloc(ram_addr_t ram_addr, ram_addr_t size, MemoryRegion *mr) +{ + unsigned long nr_pfn; + xen_pfn_t *pfn_list; + int i; + + if (runstate_check(RUN_STATE_INMIGRATE)) { + /* RAM already populated in Xen */ + fprintf(stderr, "%s: do not alloc "RAM_ADDR_FMT + " bytes of ram at "RAM_ADDR_FMT" when runstate is INMIGRATE\n", + __func__, size, ram_addr); + return; + } + + if (mr == &ram_memory) { + return; + } + + trace_xen_ram_alloc(ram_addr, size); + + nr_pfn = size >> TARGET_PAGE_BITS; + pfn_list = g_malloc(sizeof (*pfn_list) * nr_pfn); + + for (i = 0; i < nr_pfn; i++) { + pfn_list[i] = (ram_addr >> TARGET_PAGE_BITS) + i; + } + + if (xc_domain_populate_physmap_exact(xen_xc, xen_domid, nr_pfn, 0, 0, pfn_list)) { + hw_error("xen: failed to populate ram at " RAM_ADDR_FMT, ram_addr); + } + + g_free(pfn_list); +} + +static XenPhysmap *get_physmapping(XenIOState *state, + hwaddr start_addr, ram_addr_t size) +{ + XenPhysmap *physmap = NULL; + + start_addr &= TARGET_PAGE_MASK; + + QLIST_FOREACH(physmap, &state->physmap, list) { + if (range_covers_byte(physmap->start_addr, physmap->size, start_addr)) { + return physmap; + } + } + return NULL; +} + +static hwaddr xen_phys_offset_to_gaddr(hwaddr start_addr, + ram_addr_t size, void *opaque) +{ + hwaddr addr = start_addr & TARGET_PAGE_MASK; + XenIOState *xen_io_state = opaque; + XenPhysmap *physmap = NULL; + + QLIST_FOREACH(physmap, &xen_io_state->physmap, list) { + if (range_covers_byte(physmap->phys_offset, physmap->size, addr)) { + return physmap->start_addr; + } + } + + return start_addr; +} + +#if CONFIG_XEN_CTRL_INTERFACE_VERSION >= 340 +static int xen_add_to_physmap(XenIOState *state, + hwaddr start_addr, + ram_addr_t size, + MemoryRegion *mr, + hwaddr offset_within_region) +{ + unsigned long i = 0; + int rc = 0; + XenPhysmap *physmap = NULL; + hwaddr pfn, start_gpfn; + hwaddr phys_offset = memory_region_get_ram_addr(mr); + char path[80], value[17]; + + if (get_physmapping(state, start_addr, size)) { + return 0; + } + if (size <= 0) { + return -1; + } + + /* Xen can only handle a single dirty log region for now and we want + * the linear framebuffer to be that region. + * Avoid tracking any regions that is not videoram and avoid tracking + * the legacy vga region. */ + if (mr == framebuffer && start_addr > 0xbffff) { + goto go_physmap; + } + return -1; + +go_physmap: + DPRINTF("mapping vram to %"HWADDR_PRIx" - %"HWADDR_PRIx"\n", + start_addr, start_addr + size); + + pfn = phys_offset >> TARGET_PAGE_BITS; + start_gpfn = start_addr >> TARGET_PAGE_BITS; + for (i = 0; i < size >> TARGET_PAGE_BITS; i++) { + unsigned long idx = pfn + i; + xen_pfn_t gpfn = start_gpfn + i; + + rc = xc_domain_add_to_physmap(xen_xc, xen_domid, XENMAPSPACE_gmfn, idx, gpfn); + if (rc) { + DPRINTF("add_to_physmap MFN %"PRI_xen_pfn" to PFN %" + PRI_xen_pfn" failed: %d\n", idx, gpfn, rc); + return -rc; + } + } + + physmap = g_malloc(sizeof (XenPhysmap)); + + physmap->start_addr = start_addr; + physmap->size = size; + physmap->name = (char *)mr->name; + physmap->phys_offset = phys_offset; + + QLIST_INSERT_HEAD(&state->physmap, physmap, list); + + xc_domain_pin_memory_cacheattr(xen_xc, xen_domid, + start_addr >> TARGET_PAGE_BITS, + (start_addr + size) >> TARGET_PAGE_BITS, + XEN_DOMCTL_MEM_CACHEATTR_WB); + + snprintf(path, sizeof(path), + "/local/domain/0/device-model/%d/physmap/%"PRIx64"/start_addr", + xen_domid, (uint64_t)phys_offset); + snprintf(value, sizeof(value), "%"PRIx64, (uint64_t)start_addr); + if (!xs_write(state->xenstore, 0, path, value, strlen(value))) { + return -1; + } + snprintf(path, sizeof(path), + "/local/domain/0/device-model/%d/physmap/%"PRIx64"/size", + xen_domid, (uint64_t)phys_offset); + snprintf(value, sizeof(value), "%"PRIx64, (uint64_t)size); + if (!xs_write(state->xenstore, 0, path, value, strlen(value))) { + return -1; + } + if (mr->name) { + snprintf(path, sizeof(path), + "/local/domain/0/device-model/%d/physmap/%"PRIx64"/name", + xen_domid, (uint64_t)phys_offset); + if (!xs_write(state->xenstore, 0, path, mr->name, strlen(mr->name))) { + return -1; + } + } + + return 0; +} + +static int xen_remove_from_physmap(XenIOState *state, + hwaddr start_addr, + ram_addr_t size) +{ + unsigned long i = 0; + int rc = 0; + XenPhysmap *physmap = NULL; + hwaddr phys_offset = 0; + + physmap = get_physmapping(state, start_addr, size); + if (physmap == NULL) { + return -1; + } + + phys_offset = physmap->phys_offset; + size = physmap->size; + + DPRINTF("unmapping vram to %"HWADDR_PRIx" - %"HWADDR_PRIx", at " + "%"HWADDR_PRIx"\n", start_addr, start_addr + size, phys_offset); + + size >>= TARGET_PAGE_BITS; + start_addr >>= TARGET_PAGE_BITS; + phys_offset >>= TARGET_PAGE_BITS; + for (i = 0; i < size; i++) { + unsigned long idx = start_addr + i; + xen_pfn_t gpfn = phys_offset + i; + + rc = xc_domain_add_to_physmap(xen_xc, xen_domid, XENMAPSPACE_gmfn, idx, gpfn); + if (rc) { + fprintf(stderr, "add_to_physmap MFN %"PRI_xen_pfn" to PFN %" + PRI_xen_pfn" failed: %d\n", idx, gpfn, rc); + return -rc; + } + } + + QLIST_REMOVE(physmap, list); + if (state->log_for_dirtybit == physmap) { + state->log_for_dirtybit = NULL; + } + g_free(physmap); + + return 0; +} + +#else +static int xen_add_to_physmap(XenIOState *state, + hwaddr start_addr, + ram_addr_t size, + MemoryRegion *mr, + hwaddr offset_within_region) +{ + return -ENOSYS; +} + +static int xen_remove_from_physmap(XenIOState *state, + hwaddr start_addr, + ram_addr_t size) +{ + return -ENOSYS; +} +#endif + +static void xen_set_memory(struct MemoryListener *listener, + MemoryRegionSection *section, + bool add) +{ + XenIOState *state = container_of(listener, XenIOState, memory_listener); + hwaddr start_addr = section->offset_within_address_space; + ram_addr_t size = int128_get64(section->size); + bool log_dirty = memory_region_is_logging(section->mr); + hvmmem_type_t mem_type; + + if (!memory_region_is_ram(section->mr)) { + return; + } + + if (!(section->mr != &ram_memory + && ( (log_dirty && add) || (!log_dirty && !add)))) { + return; + } + + trace_xen_client_set_memory(start_addr, size, log_dirty); + + start_addr &= TARGET_PAGE_MASK; + size = TARGET_PAGE_ALIGN(size); + + if (add) { + if (!memory_region_is_rom(section->mr)) { + xen_add_to_physmap(state, start_addr, size, + section->mr, section->offset_within_region); + } else { + mem_type = HVMMEM_ram_ro; + if (xc_hvm_set_mem_type(xen_xc, xen_domid, mem_type, + start_addr >> TARGET_PAGE_BITS, + size >> TARGET_PAGE_BITS)) { + DPRINTF("xc_hvm_set_mem_type error, addr: "TARGET_FMT_plx"\n", + start_addr); + } + } + } else { + if (xen_remove_from_physmap(state, start_addr, size) < 0) { + DPRINTF("physmapping does not exist at "TARGET_FMT_plx"\n", start_addr); + } + } +} + +static void xen_region_add(MemoryListener *listener, + MemoryRegionSection *section) +{ + memory_region_ref(section->mr); + xen_set_memory(listener, section, true); +} + +static void xen_region_del(MemoryListener *listener, + MemoryRegionSection *section) +{ + xen_set_memory(listener, section, false); + memory_region_unref(section->mr); +} + +static void xen_sync_dirty_bitmap(XenIOState *state, + hwaddr start_addr, + ram_addr_t size) +{ + hwaddr npages = size >> TARGET_PAGE_BITS; + const int width = sizeof(unsigned long) * 8; + unsigned long bitmap[(npages + width - 1) / width]; + int rc, i, j; + const XenPhysmap *physmap = NULL; + + physmap = get_physmapping(state, start_addr, size); + if (physmap == NULL) { + /* not handled */ + return; + } + + if (state->log_for_dirtybit == NULL) { + state->log_for_dirtybit = physmap; + } else if (state->log_for_dirtybit != physmap) { + /* Only one range for dirty bitmap can be tracked. */ + return; + } + + rc = xc_hvm_track_dirty_vram(xen_xc, xen_domid, + start_addr >> TARGET_PAGE_BITS, npages, + bitmap); + if (rc < 0) { + if (rc != -ENODATA) { + memory_region_set_dirty(framebuffer, 0, size); + DPRINTF("xen: track_dirty_vram failed (0x" TARGET_FMT_plx + ", 0x" TARGET_FMT_plx "): %s\n", + start_addr, start_addr + size, strerror(-rc)); + } + return; + } + + for (i = 0; i < ARRAY_SIZE(bitmap); i++) { + unsigned long map = bitmap[i]; + while (map != 0) { + j = ffsl(map) - 1; + map &= ~(1ul << j); + memory_region_set_dirty(framebuffer, + (i * width + j) * TARGET_PAGE_SIZE, + TARGET_PAGE_SIZE); + }; + } +} + +static void xen_log_start(MemoryListener *listener, + MemoryRegionSection *section) +{ + XenIOState *state = container_of(listener, XenIOState, memory_listener); + + xen_sync_dirty_bitmap(state, section->offset_within_address_space, + int128_get64(section->size)); +} + +static void xen_log_stop(MemoryListener *listener, MemoryRegionSection *section) +{ + XenIOState *state = container_of(listener, XenIOState, memory_listener); + + state->log_for_dirtybit = NULL; + /* Disable dirty bit tracking */ + xc_hvm_track_dirty_vram(xen_xc, xen_domid, 0, 0, NULL); +} + +static void xen_log_sync(MemoryListener *listener, MemoryRegionSection *section) +{ + XenIOState *state = container_of(listener, XenIOState, memory_listener); + + xen_sync_dirty_bitmap(state, section->offset_within_address_space, + int128_get64(section->size)); +} + +static void xen_log_global_start(MemoryListener *listener) +{ + if (xen_enabled()) { + xen_in_migration = true; + } +} + +static void xen_log_global_stop(MemoryListener *listener) +{ + xen_in_migration = false; +} + +static MemoryListener xen_memory_listener = { + .region_add = xen_region_add, + .region_del = xen_region_del, + .log_start = xen_log_start, + .log_stop = xen_log_stop, + .log_sync = xen_log_sync, + .log_global_start = xen_log_global_start, + .log_global_stop = xen_log_global_stop, + .priority = 10, +}; + +/* get the ioreq packets from share mem */ +static ioreq_t *cpu_get_ioreq_from_shared_memory(XenIOState *state, int vcpu) +{ + ioreq_t *req = xen_vcpu_ioreq(state->shared_page, vcpu); + + if (req->state != STATE_IOREQ_READY) { + DPRINTF("I/O request not ready: " + "%x, ptr: %x, port: %"PRIx64", " + "data: %"PRIx64", count: %" FMT_ioreq_size ", size: %" FMT_ioreq_size "\n", + req->state, req->data_is_ptr, req->addr, + req->data, req->count, req->size); + return NULL; + } + + xen_rmb(); /* see IOREQ_READY /then/ read contents of ioreq */ + + req->state = STATE_IOREQ_INPROCESS; + return req; +} + +/* use poll to get the port notification */ +/* ioreq_vec--out,the */ +/* retval--the number of ioreq packet */ +static ioreq_t *cpu_get_ioreq(XenIOState *state) +{ + int i; + evtchn_port_t port; + + port = xc_evtchn_pending(state->xce_handle); + if (port == state->bufioreq_local_port) { + timer_mod(state->buffered_io_timer, + BUFFER_IO_MAX_DELAY + qemu_clock_get_ms(QEMU_CLOCK_REALTIME)); + return NULL; + } + + if (port != -1) { + for (i = 0; i < max_cpus; i++) { + if (state->ioreq_local_port[i] == port) { + break; + } + } + + if (i == max_cpus) { + hw_error("Fatal error while trying to get io event!\n"); + } + + /* unmask the wanted port again */ + xc_evtchn_unmask(state->xce_handle, port); + + /* get the io packet from shared memory */ + state->send_vcpu = i; + return cpu_get_ioreq_from_shared_memory(state, i); + } + + /* read error or read nothing */ + return NULL; +} + +static uint32_t do_inp(pio_addr_t addr, unsigned long size) +{ + switch (size) { + case 1: + return cpu_inb(addr); + case 2: + return cpu_inw(addr); + case 4: + return cpu_inl(addr); + default: + hw_error("inp: bad size: %04"FMT_pioaddr" %lx", addr, size); + } +} + +static void do_outp(pio_addr_t addr, + unsigned long size, uint32_t val) +{ + switch (size) { + case 1: + return cpu_outb(addr, val); + case 2: + return cpu_outw(addr, val); + case 4: + return cpu_outl(addr, val); + default: + hw_error("outp: bad size: %04"FMT_pioaddr" %lx", addr, size); + } +} + +/* + * Helper functions which read/write an object from/to physical guest + * memory, as part of the implementation of an ioreq. + * + * Equivalent to + * cpu_physical_memory_rw(addr + (req->df ? -1 : +1) * req->size * i, + * val, req->size, 0/1) + * except without the integer overflow problems. + */ +static void rw_phys_req_item(hwaddr addr, + ioreq_t *req, uint32_t i, void *val, int rw) +{ + /* Do everything unsigned so overflow just results in a truncated result + * and accesses to undesired parts of guest memory, which is up + * to the guest */ + hwaddr offset = (hwaddr)req->size * i; + if (req->df) { + addr -= offset; + } else { + addr += offset; + } + cpu_physical_memory_rw(addr, val, req->size, rw); +} + +static inline void read_phys_req_item(hwaddr addr, + ioreq_t *req, uint32_t i, void *val) +{ + rw_phys_req_item(addr, req, i, val, 0); +} +static inline void write_phys_req_item(hwaddr addr, + ioreq_t *req, uint32_t i, void *val) +{ + rw_phys_req_item(addr, req, i, val, 1); +} + + +static void cpu_ioreq_pio(ioreq_t *req) +{ + uint32_t i; + + if (req->dir == IOREQ_READ) { + if (!req->data_is_ptr) { + req->data = do_inp(req->addr, req->size); + } else { + uint32_t tmp; + + for (i = 0; i < req->count; i++) { + tmp = do_inp(req->addr, req->size); + write_phys_req_item(req->data, req, i, &tmp); + } + } + } else if (req->dir == IOREQ_WRITE) { + if (!req->data_is_ptr) { + do_outp(req->addr, req->size, req->data); + } else { + for (i = 0; i < req->count; i++) { + uint32_t tmp = 0; + + read_phys_req_item(req->data, req, i, &tmp); + do_outp(req->addr, req->size, tmp); + } + } + } +} + +static void cpu_ioreq_move(ioreq_t *req) +{ + uint32_t i; + + if (!req->data_is_ptr) { + if (req->dir == IOREQ_READ) { + for (i = 0; i < req->count; i++) { + read_phys_req_item(req->addr, req, i, &req->data); + } + } else if (req->dir == IOREQ_WRITE) { + for (i = 0; i < req->count; i++) { + write_phys_req_item(req->addr, req, i, &req->data); + } + } + } else { + uint64_t tmp; + + if (req->dir == IOREQ_READ) { + for (i = 0; i < req->count; i++) { + read_phys_req_item(req->addr, req, i, &tmp); + write_phys_req_item(req->data, req, i, &tmp); + } + } else if (req->dir == IOREQ_WRITE) { + for (i = 0; i < req->count; i++) { + read_phys_req_item(req->data, req, i, &tmp); + write_phys_req_item(req->addr, req, i, &tmp); + } + } + } +} + +static void handle_ioreq(ioreq_t *req) +{ + if (!req->data_is_ptr && (req->dir == IOREQ_WRITE) && + (req->size < sizeof (target_ulong))) { + req->data &= ((target_ulong) 1 << (8 * req->size)) - 1; + } + + switch (req->type) { + case IOREQ_TYPE_PIO: + cpu_ioreq_pio(req); + break; + case IOREQ_TYPE_COPY: + cpu_ioreq_move(req); + break; + case IOREQ_TYPE_TIMEOFFSET: + break; + case IOREQ_TYPE_INVALIDATE: + xen_invalidate_map_cache(); + break; + default: + hw_error("Invalid ioreq type 0x%x\n", req->type); + } +} + +static int handle_buffered_iopage(XenIOState *state) +{ + buf_ioreq_t *buf_req = NULL; + ioreq_t req; + int qw; + + if (!state->buffered_io_page) { + return 0; + } + + memset(&req, 0x00, sizeof(req)); + + while (state->buffered_io_page->read_pointer != state->buffered_io_page->write_pointer) { + buf_req = &state->buffered_io_page->buf_ioreq[ + state->buffered_io_page->read_pointer % IOREQ_BUFFER_SLOT_NUM]; + req.size = 1UL << buf_req->size; + req.count = 1; + req.addr = buf_req->addr; + req.data = buf_req->data; + req.state = STATE_IOREQ_READY; + req.dir = buf_req->dir; + req.df = 1; + req.type = buf_req->type; + req.data_is_ptr = 0; + qw = (req.size == 8); + if (qw) { + buf_req = &state->buffered_io_page->buf_ioreq[ + (state->buffered_io_page->read_pointer + 1) % IOREQ_BUFFER_SLOT_NUM]; + req.data |= ((uint64_t)buf_req->data) << 32; + } + + handle_ioreq(&req); + + xen_mb(); + state->buffered_io_page->read_pointer += qw ? 2 : 1; + } + + return req.count; +} + +static void handle_buffered_io(void *opaque) +{ + XenIOState *state = opaque; + + if (handle_buffered_iopage(state)) { + timer_mod(state->buffered_io_timer, + BUFFER_IO_MAX_DELAY + qemu_clock_get_ms(QEMU_CLOCK_REALTIME)); + } else { + timer_del(state->buffered_io_timer); + xc_evtchn_unmask(state->xce_handle, state->bufioreq_local_port); + } +} + +static void cpu_handle_ioreq(void *opaque) +{ + XenIOState *state = opaque; + ioreq_t *req = cpu_get_ioreq(state); + + handle_buffered_iopage(state); + if (req) { + handle_ioreq(req); + + if (req->state != STATE_IOREQ_INPROCESS) { + fprintf(stderr, "Badness in I/O request ... not in service?!: " + "%x, ptr: %x, port: %"PRIx64", " + "data: %"PRIx64", count: %" FMT_ioreq_size ", size: %" FMT_ioreq_size "\n", + req->state, req->data_is_ptr, req->addr, + req->data, req->count, req->size); + destroy_hvm_domain(false); + return; + } + + xen_wmb(); /* Update ioreq contents /then/ update state. */ + + /* + * We do this before we send the response so that the tools + * have the opportunity to pick up on the reset before the + * guest resumes and does a hlt with interrupts disabled which + * causes Xen to powerdown the domain. + */ + if (runstate_is_running()) { + if (qemu_shutdown_requested_get()) { + destroy_hvm_domain(false); + } + if (qemu_reset_requested_get()) { + qemu_system_reset(VMRESET_REPORT); + destroy_hvm_domain(true); + } + } + + req->state = STATE_IORESP_READY; + xc_evtchn_notify(state->xce_handle, state->ioreq_local_port[state->send_vcpu]); + } +} + +static void xen_main_loop_prepare(XenIOState *state) +{ + int evtchn_fd = -1; + + if (state->xce_handle != XC_HANDLER_INITIAL_VALUE) { + evtchn_fd = xc_evtchn_fd(state->xce_handle); + } + + state->buffered_io_timer = timer_new_ms(QEMU_CLOCK_REALTIME, handle_buffered_io, + state); + + if (evtchn_fd != -1) { + qemu_set_fd_handler(evtchn_fd, cpu_handle_ioreq, NULL, state); + } +} + + +static void xen_hvm_change_state_handler(void *opaque, int running, + RunState rstate) +{ + XenIOState *xstate = opaque; + if (running) { + xen_main_loop_prepare(xstate); + } +} + +static void xen_exit_notifier(Notifier *n, void *data) +{ + XenIOState *state = container_of(n, XenIOState, exit); + + xc_evtchn_close(state->xce_handle); + xs_daemon_close(state->xenstore); +} + +static void xen_read_physmap(XenIOState *state) +{ + XenPhysmap *physmap = NULL; + unsigned int len, num, i; + char path[80], *value = NULL; + char **entries = NULL; + + snprintf(path, sizeof(path), + "/local/domain/0/device-model/%d/physmap", xen_domid); + entries = xs_directory(state->xenstore, 0, path, &num); + if (entries == NULL) + return; + + for (i = 0; i < num; i++) { + physmap = g_malloc(sizeof (XenPhysmap)); + physmap->phys_offset = strtoull(entries[i], NULL, 16); + snprintf(path, sizeof(path), + "/local/domain/0/device-model/%d/physmap/%s/start_addr", + xen_domid, entries[i]); + value = xs_read(state->xenstore, 0, path, &len); + if (value == NULL) { + g_free(physmap); + continue; + } + physmap->start_addr = strtoull(value, NULL, 16); + free(value); + + snprintf(path, sizeof(path), + "/local/domain/0/device-model/%d/physmap/%s/size", + xen_domid, entries[i]); + value = xs_read(state->xenstore, 0, path, &len); + if (value == NULL) { + g_free(physmap); + continue; + } + physmap->size = strtoull(value, NULL, 16); + free(value); + + snprintf(path, sizeof(path), + "/local/domain/0/device-model/%d/physmap/%s/name", + xen_domid, entries[i]); + physmap->name = xs_read(state->xenstore, 0, path, &len); + + QLIST_INSERT_HEAD(&state->physmap, physmap, list); + } + free(entries); +} + +static void xen_wakeup_notifier(Notifier *notifier, void *data) +{ + xc_set_hvm_param(xen_xc, xen_domid, HVM_PARAM_ACPI_S_STATE, 0); +} + +int xen_hvm_init(MemoryRegion **ram_memory) +{ + int i, rc; + unsigned long ioreq_pfn; + unsigned long bufioreq_evtchn; + XenIOState *state; + + state = g_malloc0(sizeof (XenIOState)); + + state->xce_handle = xen_xc_evtchn_open(NULL, 0); + if (state->xce_handle == XC_HANDLER_INITIAL_VALUE) { + perror("xen: event channel open"); + g_free(state); + return -errno; + } + + state->xenstore = xs_daemon_open(); + if (state->xenstore == NULL) { + perror("xen: xenstore open"); + g_free(state); + return -errno; + } + + state->exit.notify = xen_exit_notifier; + qemu_add_exit_notifier(&state->exit); + + state->suspend.notify = xen_suspend_notifier; + qemu_register_suspend_notifier(&state->suspend); + + state->wakeup.notify = xen_wakeup_notifier; + qemu_register_wakeup_notifier(&state->wakeup); + + xc_get_hvm_param(xen_xc, xen_domid, HVM_PARAM_IOREQ_PFN, &ioreq_pfn); + DPRINTF("shared page at pfn %lx\n", ioreq_pfn); + state->shared_page = xc_map_foreign_range(xen_xc, xen_domid, XC_PAGE_SIZE, + PROT_READ|PROT_WRITE, ioreq_pfn); + if (state->shared_page == NULL) { + hw_error("map shared IO page returned error %d handle=" XC_INTERFACE_FMT, + errno, xen_xc); + } + + xc_get_hvm_param(xen_xc, xen_domid, HVM_PARAM_BUFIOREQ_PFN, &ioreq_pfn); + DPRINTF("buffered io page at pfn %lx\n", ioreq_pfn); + state->buffered_io_page = xc_map_foreign_range(xen_xc, xen_domid, XC_PAGE_SIZE, + PROT_READ|PROT_WRITE, ioreq_pfn); + if (state->buffered_io_page == NULL) { + hw_error("map buffered IO page returned error %d", errno); + } + + state->ioreq_local_port = g_malloc0(max_cpus * sizeof (evtchn_port_t)); + + /* FIXME: how about if we overflow the page here? */ + for (i = 0; i < max_cpus; i++) { + rc = xc_evtchn_bind_interdomain(state->xce_handle, xen_domid, + xen_vcpu_eport(state->shared_page, i)); + if (rc == -1) { + fprintf(stderr, "bind interdomain ioctl error %d\n", errno); + return -1; + } + state->ioreq_local_port[i] = rc; + } + + rc = xc_get_hvm_param(xen_xc, xen_domid, HVM_PARAM_BUFIOREQ_EVTCHN, + &bufioreq_evtchn); + if (rc < 0) { + fprintf(stderr, "failed to get HVM_PARAM_BUFIOREQ_EVTCHN\n"); + return -1; + } + rc = xc_evtchn_bind_interdomain(state->xce_handle, xen_domid, + (uint32_t)bufioreq_evtchn); + if (rc == -1) { + fprintf(stderr, "bind interdomain ioctl error %d\n", errno); + return -1; + } + state->bufioreq_local_port = rc; + + /* Init RAM management */ + xen_map_cache_init(xen_phys_offset_to_gaddr, state); + xen_ram_init(ram_size, ram_memory); + + qemu_add_vm_change_state_handler(xen_hvm_change_state_handler, state); + + state->memory_listener = xen_memory_listener; + QLIST_INIT(&state->physmap); + memory_listener_register(&state->memory_listener, &address_space_memory); + state->log_for_dirtybit = NULL; + + /* Initialize backend core & drivers */ + if (xen_be_init() != 0) { + fprintf(stderr, "%s: xen backend core setup failed\n", __FUNCTION__); + exit(1); + } + xen_be_register("console", &xen_console_ops); + xen_be_register("vkbd", &xen_kbdmouse_ops); + xen_be_register("qdisk", &xen_blkdev_ops); + xen_read_physmap(state); + + return 0; +} + +void destroy_hvm_domain(bool reboot) +{ + XenXC xc_handle; + int sts; + + xc_handle = xen_xc_interface_open(0, 0, 0); + if (xc_handle == XC_HANDLER_INITIAL_VALUE) { + fprintf(stderr, "Cannot acquire xenctrl handle\n"); + } else { + sts = xc_domain_shutdown(xc_handle, xen_domid, + reboot ? SHUTDOWN_reboot : SHUTDOWN_poweroff); + if (sts != 0) { + fprintf(stderr, "xc_domain_shutdown failed to issue %s, " + "sts %d, %s\n", reboot ? "reboot" : "poweroff", + sts, strerror(errno)); + } else { + fprintf(stderr, "Issued domain %d %s\n", xen_domid, + reboot ? "reboot" : "poweroff"); + } + xc_interface_close(xc_handle); + } +} + +void xen_register_framebuffer(MemoryRegion *mr) +{ + framebuffer = mr; +} + +void xen_shutdown_fatal_error(const char *fmt, ...) +{ + va_list ap; + + va_start(ap, fmt); + vfprintf(stderr, fmt, ap); + va_end(ap); + fprintf(stderr, "Will destroy the domain.\n"); + /* destroy the domain */ + qemu_system_shutdown_request(); +} + +void xen_modified_memory(ram_addr_t start, ram_addr_t length) +{ + if (unlikely(xen_in_migration)) { + int rc; + ram_addr_t start_pfn, nb_pages; + + if (length == 0) { + length = TARGET_PAGE_SIZE; + } + start_pfn = start >> TARGET_PAGE_BITS; + nb_pages = ((start + length + TARGET_PAGE_SIZE - 1) >> TARGET_PAGE_BITS) + - start_pfn; + rc = xc_hvm_modified_memory(xen_xc, xen_domid, start_pfn, nb_pages); + if (rc) { + fprintf(stderr, + "%s failed for "RAM_ADDR_FMT" ("RAM_ADDR_FMT"): %i, %s\n", + __func__, start, nb_pages, rc, strerror(-rc)); + } + } +} + +void qmp_xen_set_global_dirty_log(bool enable, Error **errp) +{ + if (enable) { + memory_global_dirty_log_start(); + } else { + memory_global_dirty_log_stop(); + } +} diff --git a/xen-mapcache-stub.c b/xen-mapcache-stub.c new file mode 100644 index 0000000..f4ddf53 --- /dev/null +++ b/xen-mapcache-stub.c @@ -0,0 +1,39 @@ +/* + * Copyright (C) 2014 Citrix Ltd. + * + * This work is licensed under the terms of the GNU GPL, version 2. See + * the COPYING file in the top-level directory. + * + * Contributions after 2012-01-13 are licensed under the terms of the + * GNU GPL, version 2 or (at your option) any later version. + */ + +#include "config.h" + +#include + +#include "hw/xen/xen_backend.h" + +#include + +#include "sysemu/xen-mapcache.h" +#include "trace.h" + +uint8_t *xen_map_cache(hwaddr phys_addr, hwaddr size, + uint8_t lock) +{ + abort(); + return NULL; +} + +ram_addr_t xen_ram_addr_from_mapcache(void *ptr) +{ + abort(); + return 0; +} + +void xen_invalidate_map_cache_entry(uint8_t *buffer) +{ + abort(); +} + diff --git a/xen-stub.c b/xen-stub.c deleted file mode 100644 index 59927cb..0000000 --- a/xen-stub.c +++ /dev/null @@ -1,70 +0,0 @@ -/* - * Copyright (C) 2010 Citrix Ltd. - * - * This work is licensed under the terms of the GNU GPL, version 2. See - * the COPYING file in the top-level directory. - * - * Contributions after 2012-01-13 are licensed under the terms of the - * GNU GPL, version 2 or (at your option) any later version. - */ - -#include "qemu-common.h" -#include "hw/xen/xen.h" -#include "exec/memory.h" -#include "qmp-commands.h" - -void xenstore_store_pv_console_info(int i, CharDriverState *chr) -{ -} - -int xen_pci_slot_get_pirq(PCIDevice *pci_dev, int irq_num) -{ - return -1; -} - -void xen_piix3_set_irq(void *opaque, int irq_num, int level) -{ -} - -void xen_piix_pci_write_config_client(uint32_t address, uint32_t val, int len) -{ -} - -void xen_hvm_inject_msi(uint64_t addr, uint32_t data) -{ -} - -void xen_cmos_set_s3_resume(void *opaque, int irq, int level) -{ -} - -void xen_ram_alloc(ram_addr_t ram_addr, ram_addr_t size, MemoryRegion *mr) -{ -} - -qemu_irq *xen_interrupt_controller_init(void) -{ - return NULL; -} - -int xen_init(QEMUMachine *machine) -{ - return -ENOSYS; -} - -void xen_register_framebuffer(MemoryRegion *mr) -{ -} - -void qmp_xen_set_global_dirty_log(bool enable, Error **errp) -{ -} - -void xen_modified_memory(ram_addr_t start, ram_addr_t length) -{ -} - -int xen_hvm_init(MemoryRegion **ram_memory) -{ - return 0; -} -- 1.7.10.4 _______________________________________________ Xen-devel mailing list Xen-devel@lists.xen.org http://lists.xen.org/xen-devel